1use std::cell::{Cell, RefCell};
9use std::collections::HashSet;
10use std::hash::Hash;
11use std::rc::Rc;
12
13use day_core::*;
14use day_reactive::{AnyBinding, Binding, Scope, Signal, watch};
15use day_spec::props::*;
16
17use crate::{Decorate, Decorated, IntoReactive, IntoText, MenuEntry, Reactive, TextSource};
18use day_spec::{Event, Proposal, Rect, Size, kinds};
19
20pub fn when<P: Piece>(
38 cond: impl Fn() -> bool + 'static,
39 build_arm: impl Fn() -> P + 'static,
40) -> When {
41 When {
42 cond: Rc::new(cond),
43 then: Rc::new(move || AnyPiece::new(build_arm())),
44 otherwise: None,
45 }
46}
47
48#[must_use]
50pub struct When {
51 cond: Rc<dyn Fn() -> bool>,
52 then: Rc<dyn Fn() -> AnyPiece>,
53 otherwise: Option<Rc<dyn Fn() -> AnyPiece>>,
54}
55
56#[day_macros::builder(WhenBuilder)]
57impl When {
58 pub fn otherwise<P: Piece>(mut self, build_arm: impl Fn() -> P + 'static) -> Self {
64 self.otherwise = Some(Rc::new(move || AnyPiece::new(build_arm())));
65 self
66 }
67}
68
69impl Piece for When {
70 fn build(self, cx: &mut BuildCx) -> RNode {
71 let anchor = cx.layout_only(
72 Rc::new(PassThrough),
73 Flex {
74 is_group: true,
75 ..Default::default()
76 },
77 Boundary::No,
78 );
79 let state: Rc<RefCell<Option<Scope>>> = Rc::new(RefCell::new(None));
80 let owner = Scope::current();
87 let When {
88 cond,
89 then,
90 otherwise,
91 } = self;
92
93 let mount = {
94 let state = state.clone();
95 move |on: bool| {
96 if !with_tree(|t| t.node_exists(anchor)) {
98 return;
99 }
100 if let Some(scope) = state.borrow_mut().take() {
104 scope.dispose();
105 while with_tree(|t| t.child_count(anchor)) > 0 {
107 let child = with_tree(|t| t.first_child(anchor));
108 match child {
109 Some(c) => with_tree(|t| t.remove_subtree(c)),
110 None => break,
111 }
112 }
113 }
114 let arm = if on { Some(&then) } else { otherwise.as_ref() };
115 if let Some(arm) = arm {
116 let scope = owner.enter(Scope::child);
117 scope.enter(|| {
118 let mut cx = BuildCx::new(anchor);
119 let _ = arm().build(&mut cx);
120 });
121 *state.borrow_mut() = Some(scope);
122 }
123 }
124 };
125
126 let initial = {
127 let cond = cond.clone();
128 day_reactive::untrack(move || cond())
129 };
130 mount(initial);
131 watch(
132 move || cond(),
133 move |now, old| {
134 if Some(now) != old {
135 mount(*now);
136 }
137 },
138 );
139 anchor
140 }
141}
142
143fn in_row_scope<R>(build: impl FnOnce() -> R) -> R {
151 Scope::child().enter(build)
152}
153
154pub struct ItemSlot<T: 'static, K: 'static> {
156 sig: Signal<T>,
157 key: Signal<K>,
158}
159
160impl<T: 'static, K: 'static> Clone for ItemSlot<T, K> {
161 fn clone(&self) -> Self {
162 *self
163 }
164}
165impl<T: 'static, K: 'static> Copy for ItemSlot<T, K> {}
166
167impl<T: Clone + 'static, K: Clone + 'static> ItemSlot<T, K> {
168 #[must_use]
173 pub fn get(self) -> T {
174 self.sig.get()
175 }
176 pub fn with<R>(self, f: impl FnOnce(&T) -> R) -> R {
178 self.sig.with(f)
179 }
180 pub fn field<V: Clone>(self, f: impl FnOnce(&T) -> V) -> V {
183 self.sig.with(f)
184 }
185 #[must_use]
188 pub fn key(self) -> K {
189 self.key.get()
190 }
191}
192
193pub fn keyed<K, P>(
209 key: impl Fn() -> Option<K> + 'static,
210 build: impl Fn(&K) -> P + 'static,
211) -> Keyed<K>
212where
213 K: PartialEq + Clone + 'static,
214 P: Piece,
215{
216 Keyed {
217 key: Rc::new(key),
218 build: Rc::new(move |k| AnyPiece::new(build(k))),
219 }
220}
221
222pub fn switch<K, P>(selector: impl Fn() -> K + 'static, arm: impl Fn(&K) -> P + 'static) -> Keyed<K>
236where
237 K: PartialEq + Clone + 'static,
238 P: Piece,
239{
240 keyed(move || Some(selector()), arm)
241}
242
243pub struct Keyed<K: 'static> {
245 key: Rc<dyn Fn() -> Option<K>>,
246 build: Rc<dyn Fn(&K) -> AnyPiece>,
247}
248
249impl<K: PartialEq + Clone + 'static> Piece for Keyed<K> {
250 fn build(self, cx: &mut BuildCx) -> RNode {
251 let anchor = cx.layout_only(
252 Rc::new(PassThrough),
253 Flex {
254 is_group: true,
255 ..Default::default()
256 },
257 Boundary::No,
258 );
259 let owner = Scope::current();
263 let Keyed { key, build } = self;
264 let live: Rc<RefCell<Option<Scope>>> = Rc::new(RefCell::new(None));
265 let mount = {
266 let live = live.clone();
267 move |k: &Option<K>| {
268 if !with_tree(|t| t.node_exists(anchor)) {
269 return;
270 }
271 if let Some(scope) = live.borrow_mut().take() {
274 scope.dispose();
275 while with_tree(|t| t.child_count(anchor)) > 0 {
276 match with_tree(|t| t.first_child(anchor)) {
277 Some(c) => with_tree(|t| t.remove_subtree(c)),
278 None => break,
279 }
280 }
281 }
282 if let Some(k) = k {
283 let scope = owner.enter(Scope::child);
284 scope.enter(|| {
285 let mut cx = BuildCx::new(anchor);
286 let _ = build(k).build(&mut cx);
287 });
288 *live.borrow_mut() = Some(scope);
289 }
290 }
291 };
292 let initial = {
293 let key = key.clone();
294 day_reactive::untrack(move || key())
295 };
296 mount(&initial);
297 watch(
299 move || key(),
300 move |now, old| {
301 if Some(now) != old {
302 mount(now);
303 }
304 },
305 );
306 anchor
307 }
308}
309
310pub trait LoadSource<T: 'static, M>: 'static {
313 fn into_load_reader(self) -> Rc<dyn Fn() -> day_reactive::Load<T>>;
314}
315
316pub struct ResourceMark;
318
319impl<T: Clone + 'static> LoadSource<T, ResourceMark> for day_reactive::Resource<T> {
320 fn into_load_reader(self) -> Rc<dyn Fn() -> day_reactive::Load<T>> {
321 Rc::new(move || self.signal().get())
322 }
323}
324
325impl<T: Clone + 'static> LoadSource<T, crate::SignalMark> for Signal<day_reactive::Load<T>> {
326 fn into_load_reader(self) -> Rc<dyn Fn() -> day_reactive::Load<T>> {
327 Rc::new(move || self.get())
328 }
329}
330
331impl<T: 'static, F: Fn() -> day_reactive::Load<T> + 'static> LoadSource<T, crate::FnMark> for F {
332 fn into_load_reader(self) -> Rc<dyn Fn() -> day_reactive::Load<T>> {
333 Rc::new(self)
334 }
335}
336
337pub struct Loaded<T: 'static> {
340 source: Rc<dyn Fn() -> day_reactive::Load<T>>,
341 last: Rc<RefCell<T>>,
342}
343
344impl<T: 'static> Clone for Loaded<T> {
345 fn clone(&self) -> Self {
346 Loaded {
347 source: self.source.clone(),
348 last: self.last.clone(),
349 }
350 }
351}
352
353impl<T: Clone + 'static> Loaded<T> {
354 #[must_use]
358 pub fn get(&self) -> T {
359 if let day_reactive::Load::Ready(v) = (self.source)() {
360 *self.last.borrow_mut() = v.clone();
361 v
362 } else {
363 self.last.borrow().clone()
364 }
365 }
366 pub fn with<R>(&self, f: impl FnOnce(&T) -> R) -> R {
368 let v = self.get();
369 f(&v)
370 }
371}
372
373pub fn load<T, P, M>(
388 state: impl LoadSource<T, M>,
389 ready: impl Fn(Loaded<T>) -> P + 'static,
390) -> LoadPiece<T>
391where
392 T: Clone + 'static,
393 P: Piece,
394{
395 LoadPiece {
396 source: state.into_load_reader(),
397 ready: Rc::new(move |v| AnyPiece::new(ready(v))),
398 loading: None,
399 failed: None,
400 }
401}
402
403#[must_use]
405pub struct LoadPiece<T: 'static> {
406 source: Rc<dyn Fn() -> day_reactive::Load<T>>,
407 ready: Rc<dyn Fn(Loaded<T>) -> AnyPiece>,
408 loading: Option<Rc<dyn Fn() -> AnyPiece>>,
409 failed: Option<FailedArm>,
410}
411
412type FailedArm = Rc<dyn Fn(&(dyn std::error::Error + 'static)) -> AnyPiece>;
414
415impl<T: Clone + 'static> LoadPiece<T> {
416 pub fn loading<P: Piece>(mut self, build: impl Fn() -> P + 'static) -> Self {
418 self.loading = Some(Rc::new(move || AnyPiece::new(build())));
419 self
420 }
421 pub fn failed<P: Piece>(
423 mut self,
424 build: impl Fn(&(dyn std::error::Error + 'static)) -> P + 'static,
425 ) -> Self {
426 self.failed = Some(Rc::new(move |e| AnyPiece::new(build(e))));
427 self
428 }
429}
430
431#[derive(Clone, Copy, PartialEq, Eq)]
433enum LoadArm {
434 Loading,
435 Ready,
436 Failed,
437}
438
439impl<T: Clone + 'static> Piece for LoadPiece<T> {
440 fn build(self, cx: &mut BuildCx) -> RNode {
441 let LoadPiece {
442 source,
443 ready,
444 loading,
445 failed,
446 } = self;
447 let arm_source = source.clone();
448 let error_source = source.clone();
449 keyed(
450 move || {
451 Some(match arm_source() {
452 day_reactive::Load::Loading => LoadArm::Loading,
453 day_reactive::Load::Ready(_) => LoadArm::Ready,
454 day_reactive::Load::Failed(_) => LoadArm::Failed,
455 })
456 },
457 move |arm| match arm {
458 LoadArm::Loading => loading.as_ref().map(|f| f()),
459 LoadArm::Failed => {
460 failed
461 .as_ref()
462 .and_then(|f| match day_reactive::untrack(|| error_source()) {
463 day_reactive::Load::Failed(e) => Some(f(&*e)),
464 _ => None,
465 })
466 }
467 LoadArm::Ready => match day_reactive::untrack(|| source()) {
468 day_reactive::Load::Ready(v) => Some(ready(Loaded {
469 source: source.clone(),
470 last: Rc::new(RefCell::new(v)),
471 })),
472 _ => None,
473 },
474 },
475 )
476 .build(cx)
477 }
478}
479
480pub fn adaptive<C: PieceSeq>(children: C) -> Adaptive<C> {
493 Adaptive {
494 children,
495 spacing: 0.0,
496 at: day_spec::WidthClass::Compact,
497 align: CrossAlign::Center,
498 }
499}
500
501#[must_use]
503pub struct Adaptive<C: PieceSeq> {
504 children: C,
505 spacing: f64,
506 at: day_spec::WidthClass,
507 align: CrossAlign,
508}
509
510#[day_macros::builder(AdaptiveBuilder)]
511impl<C: PieceSeq> Adaptive<C> {
512 pub fn spacing(mut self, s: impl Into<f64>) -> Self {
514 self.spacing = s.into();
515 self
516 }
517 pub fn stack_at(mut self, at: day_spec::WidthClass) -> Self {
519 self.at = at;
520 self
521 }
522 pub fn align(mut self, a: crate::VAlign) -> Self {
525 self.align = match a {
526 crate::VAlign::Top => CrossAlign::Leading,
527 crate::VAlign::Center => CrossAlign::Center,
528 crate::VAlign::Bottom => CrossAlign::Trailing,
529 crate::VAlign::FirstBaseline => CrossAlign::FirstBaseline,
530 };
531 self
532 }
533}
534
535struct AdaptiveLayout {
538 axis: std::cell::Cell<Axis>,
539 spacing: f64,
540 row_align: CrossAlign,
541}
542
543impl AdaptiveLayout {
544 fn stack(&self) -> StackLayout {
545 let axis = self.axis.get();
546 StackLayout {
547 axis,
548 spacing: self.spacing,
549 align: match axis {
550 Axis::Vertical => CrossAlign::Leading,
551 Axis::Horizontal => self.row_align,
552 },
553 }
554 }
555}
556
557impl Layout for AdaptiveLayout {
558 fn measure(&self, cx: &mut dyn LayoutOps, children: &[RNode], p: Proposal) -> Size {
559 self.stack().measure(cx, children, p)
560 }
561 fn place(&self, cx: &mut dyn LayoutOps, children: &[RNode], bounds: Rect) {
562 self.stack().place(cx, children, bounds);
563 }
564 fn baseline(&self, cx: &mut dyn LayoutOps, children: &[RNode], size: Size) -> Option<f64> {
565 self.stack().baseline(cx, children, size)
566 }
567}
568
569impl<C: PieceSeq> Piece for Adaptive<C> {
570 fn build(self, cx: &mut BuildCx) -> RNode {
571 let at = self.at;
572 let stacked = move || size_class().is_some_and(|c| c.width <= at);
573 let layout = Rc::new(AdaptiveLayout {
574 axis: std::cell::Cell::new(if day_reactive::untrack(stacked) {
575 Axis::Vertical
576 } else {
577 Axis::Horizontal
578 }),
579 spacing: self.spacing,
580 row_align: self.align,
581 });
582 let node = cx.native(
583 kinds::CONTAINER,
584 &ContainerProps::default(),
585 layout.clone(),
586 Flex::default(),
587 Boundary::No,
588 );
589 cx.under(node, |cx| self.children.build_each(cx));
590 watch(stacked, move |now: &bool, _| {
592 layout.axis.set(if *now {
593 Axis::Vertical
594 } else {
595 Axis::Horizontal
596 });
597 day_core::invalidate_size(node);
598 });
599 node
600 }
601}
602
603pub trait RowSource {
612 type Slot: Copy + 'static;
614 type Ref: 'static;
616 type Conn: RowConn<Slot = Self::Slot, Ref = Self::Ref>;
617 fn connect(self) -> Self::Conn;
618}
619
620pub trait RowConn: 'static {
623 type Slot: Copy + 'static;
624 type Ref: 'static;
625
626 fn refresh(&self) -> Vec<u64>;
631 fn len(&self) -> usize;
633 fn is_empty(&self) -> bool {
634 self.len() == 0
635 }
636 fn token_at(&self, index: usize) -> u64;
638 fn tokens_now(&self) -> Vec<u64>;
640 fn slot_at(&self, index: usize) -> Option<Self::Slot>;
643 fn rebind(&self, slot: &Self::Slot, index: usize);
645 fn select_ref(&self, index: usize) -> Option<Self::Ref>;
647 fn values_flow_by_reload(&self) -> bool;
652 fn take_row_events(&self) -> Option<Vec<day_spec::props::RowDelta>> {
657 None
658 }
659 fn commit_move(&self, from: usize, to: usize);
661 fn commit_delete(&self, index: usize);
663}
664
665pub fn items<T, K>(
668 f: impl Fn() -> Vec<T> + 'static,
669 key_of: impl Fn(&T) -> K + 'static,
670) -> Items<T, K>
671where
672 T: Clone + 'static,
673 K: Clone + Hash + 'static,
674{
675 Items {
676 f: Rc::new(f),
677 key_of: Rc::new(key_of),
678 }
679}
680
681pub struct Items<T: 'static, K: 'static> {
683 f: Rc<dyn Fn() -> Vec<T>>,
684 key_of: Rc<dyn Fn(&T) -> K>,
685}
686
687impl<T: Clone + 'static, K: Clone + Hash + 'static> RowSource for Items<T, K> {
688 type Slot = ItemSlot<T, K>;
689 type Ref = K;
690 type Conn = ItemsConn<T, K>;
691 fn connect(self) -> ItemsConn<T, K> {
692 ItemsConn {
693 f: self.f,
694 key_of: self.key_of,
695 snapshot: RefCell::new(Vec::new()),
696 tokens: RefCell::new(Vec::new()),
697 }
698 }
699}
700
701pub struct ItemsConn<T: 'static, K: 'static> {
703 f: Rc<dyn Fn() -> Vec<T>>,
704 key_of: Rc<dyn Fn(&T) -> K>,
705 snapshot: RefCell<Vec<T>>,
706 tokens: RefCell<Vec<u64>>,
707}
708
709impl<T: Clone + 'static, K: Clone + Hash + 'static> RowConn for ItemsConn<T, K> {
710 type Slot = ItemSlot<T, K>;
711 type Ref = K;
712
713 fn refresh(&self) -> Vec<u64> {
714 let its = (self.f)();
715 let toks: Vec<u64> = its.iter().map(|t| key_token(&(self.key_of)(t))).collect();
716 *self.snapshot.borrow_mut() = its;
717 (*self.tokens.borrow_mut()).clone_from(&toks);
718 toks
719 }
720 fn len(&self) -> usize {
721 self.snapshot.borrow().len()
722 }
723 fn token_at(&self, index: usize) -> u64 {
724 self.tokens.borrow().get(index).copied().unwrap_or(0)
725 }
726 fn tokens_now(&self) -> Vec<u64> {
727 self.tokens.borrow().clone()
728 }
729 fn slot_at(&self, index: usize) -> Option<ItemSlot<T, K>> {
730 let item = self.snapshot.borrow().get(index).cloned()?;
731 let key = (self.key_of)(&item);
732 Some(ItemSlot {
733 sig: Signal::new(item),
734 key: Signal::new(key),
735 })
736 }
737 fn rebind(&self, slot: &ItemSlot<T, K>, index: usize) {
738 let Some(item) = self.snapshot.borrow().get(index).cloned() else {
739 return; };
741 slot.key.set((self.key_of)(&item));
742 slot.sig.set(item);
743 }
744 fn select_ref(&self, index: usize) -> Option<K> {
745 self.snapshot.borrow().get(index).map(|t| (self.key_of)(t))
746 }
747 fn values_flow_by_reload(&self) -> bool {
748 true
749 }
750 fn commit_move(&self, from: usize, to: usize) {
751 let mut snap = self.snapshot.borrow_mut();
752 let mut toks = self.tokens.borrow_mut();
753 if from >= snap.len() || to >= snap.len() {
754 return;
755 }
756 let item = snap.remove(from);
757 snap.insert(to, item);
758 let tok = toks.remove(from);
759 toks.insert(to, tok);
760 }
761 fn commit_delete(&self, index: usize) {
762 let mut snap = self.snapshot.borrow_mut();
763 let mut toks = self.tokens.borrow_mut();
764 if index >= snap.len() {
765 return;
766 }
767 snap.remove(index);
768 toks.remove(index);
769 }
770}
771
772struct EachRow<S: 'static> {
773 token: u64,
774 slot: S,
775 scope: Scope,
776 root: RNode,
777}
778
779pub fn each<S, P>(source: S, build_row: impl Fn(S::Slot) -> P + 'static) -> impl Piece
786where
787 S: RowSource + 'static,
788 P: Piece,
789{
790 piece_fn(move |cx| {
791 let anchor = cx.layout_only(
792 Rc::new(PassThrough),
793 Flex {
794 is_group: true,
795 ..Default::default()
796 },
797 Boundary::No,
798 );
799 let owner = Scope::current();
803 let conn = Rc::new(source.connect());
804 let rows: Rc<RefCell<Vec<EachRow<S::Slot>>>> = Rc::new(RefCell::new(Vec::new()));
805 let build_row = Rc::new(build_row);
806
807 let sync = {
808 let rows = rows.clone();
809 let conn = conn.clone();
810 let build_row = build_row.clone();
811 move |tokens: &Vec<u64>| {
812 if !with_tree(|t| t.node_exists(anchor)) {
820 return;
821 }
822 if cfg!(debug_assertions) {
823 let mut seen = HashSet::new();
824 for k in tokens {
825 assert!(seen.insert(*k), "day: duplicate key in `each` diff");
826 }
827 }
828 let mut old = std::mem::take(&mut *rows.borrow_mut());
829 let mut next: Vec<EachRow<S::Slot>> = Vec::with_capacity(tokens.len());
830 for (index, tok) in tokens.iter().enumerate() {
831 if let Some(pos) = old.iter().position(|r| r.token == *tok) {
832 let row = old.remove(pos);
833 conn.rebind(&row.slot, index);
836 next.push(row);
837 } else {
838 let scope = owner.enter(Scope::child);
839 let built = scope.enter(|| {
840 let slot = conn.slot_at(index)?;
841 let mut cx = BuildCx::new(anchor);
842 Some((slot, in_row_scope(|| build_row(slot).build(&mut cx))))
843 });
844 match built {
845 Some((slot, root)) => next.push(EachRow {
846 token: *tok,
847 slot,
848 scope,
849 root,
850 }),
851 None => scope.dispose(),
852 }
853 }
854 }
855 for row in old {
857 row.scope.dispose();
858 with_tree(|t| t.remove_subtree(row.root));
859 }
860 let order: Vec<RNode> = next.iter().map(|r| r.root).collect();
862 with_tree(|t| t.reorder_children(anchor, order));
863 *rows.borrow_mut() = next;
864 }
865 };
866
867 let initial = {
868 let conn = conn.clone();
869 day_reactive::untrack(move || conn.refresh())
870 };
871 sync(&initial);
872 let conn2 = conn.clone();
873 watch(move || conn2.refresh(), move |new, _| sync(new));
874 anchor
875 })
876}
877
878fn key_token<K: Hash>(k: &K) -> u64 {
884 use std::hash::Hasher;
885 let mut h = std::collections::hash_map::DefaultHasher::new();
886 k.hash(&mut h);
887 h.finish()
888}
889
890#[must_use]
894pub struct List<S: RowSource> {
895 source: Option<S>,
896 build_row: Rc<dyn Fn(S::Slot) -> AnyPiece>,
897 row_height: RowHeight,
898 on_select: Option<Rc<dyn Fn(S::Ref)>>,
899 on_activate: Option<Rc<dyn Fn(S::Ref)>>,
900 on_selection: Option<SelectionFn<S::Ref>>,
901 multi_select: bool,
902 selected_rows: Option<Rc<dyn Fn() -> Vec<usize>>>,
903 selection: Option<ListSelection<S::Ref>>,
904 scroll_to_end: Option<day_reactive::Trigger>,
905 scroll_to_row: Option<AnyBinding<Option<usize>>>,
906 first_visible_row: Option<AnyBinding<usize>>,
907 stick_to_bottom: bool,
908 reorder: Option<Reorder>,
909 delete: Option<Delete>,
910 swipe_leading: Option<SwipeProvider>,
911 swipe_trailing: Option<SwipeProvider>,
912 separators: Option<bool>,
913 inset_grouped: bool,
914 editing: crate::Reactive<bool>,
915 sections: Option<ListSections<S::Slot>>,
916}
917
918struct ListSections<Slot> {
921 key: Rc<dyn Fn(usize) -> u64>,
922 header: Rc<dyn Fn(Slot) -> AnyPiece>,
923}
924
925type SelectionFn<R> = Rc<dyn Fn(Vec<R>)>;
927
928pub trait SelectionKey {
931 fn selection_key(&self) -> u64;
932}
933
934struct ListSelection<R> {
937 key: Rc<dyn Fn() -> Option<u64>>,
938 write: Rc<dyn Fn(Option<u64>)>,
939 key_of: Rc<dyn Fn(&R) -> u64>,
940}
941
942#[derive(Clone)]
948enum ItemIcon {
949 Vector(Reactive<day_spec::VectorName>),
950 Symbol(day_spec::Symbol),
951}
952
953impl ItemIcon {
954 fn spec(&self, tracked: bool) -> day_spec::Icon {
956 match self {
957 ItemIcon::Vector(r) => {
958 let name = if tracked { r.get() } else { r.get_untracked() };
959 day_spec::Icon::Image(name.as_str().to_owned())
960 }
961 ItemIcon::Symbol(s) => day_spec::Icon::Symbol(*s),
962 }
963 }
964}
965
966#[must_use]
968pub struct ListItem {
969 title: TextSource,
970 subtitle: Option<TextSource>,
971 detail: Option<TextSource>,
972 icon: Option<ItemIcon>,
973 icon_tint: Option<Reactive<day_spec::Color>>,
974 checked: Option<Reactive<bool>>,
975}
976
977pub fn list_item<M>(title: impl IntoText<M>) -> ListItem {
993 ListItem {
994 title: title.into_text(),
995 subtitle: None,
996 detail: None,
997 icon: None,
998 icon_tint: None,
999 checked: None,
1000 }
1001}
1002
1003#[day_macros::builder(ListItemBuilder)]
1004impl ListItem {
1005 pub fn subtitle<M>(mut self, text: impl IntoText<M>) -> Self {
1007 self.subtitle = Some(text.into_text());
1008 self
1009 }
1010 pub fn detail<M>(mut self, text: impl IntoText<M>) -> Self {
1012 self.detail = Some(text.into_text());
1013 self
1014 }
1015 pub fn icon<M>(mut self, name: impl IntoReactive<day_spec::VectorName, M>) -> Self {
1019 self.icon = Some(ItemIcon::Vector(name.into_reactive()));
1020 self
1021 }
1022 pub fn symbol(mut self, symbol: day_spec::Symbol) -> Self {
1024 self.icon = Some(ItemIcon::Symbol(symbol));
1025 self
1026 }
1027 pub fn icon_tint<M>(mut self, color: impl IntoReactive<day_spec::Color, M>) -> Self {
1029 self.icon_tint = Some(color.into_reactive());
1030 self
1031 }
1032 pub fn checked<M>(mut self, on: impl IntoReactive<bool, M>) -> Self {
1035 self.checked = Some(on.into_reactive());
1036 self
1037 }
1038}
1039
1040impl Piece for ListItem {
1041 fn build(self, cx: &mut BuildCx) -> RNode {
1042 if day_core::capability(day_spec::Cap::ListItem) == day_spec::Support::Native {
1043 self.build_native(cx)
1044 } else {
1045 self.compose().build(cx)
1046 }
1047 }
1048}
1049
1050impl ListItem {
1051 fn build_native(self, cx: &mut BuildCx) -> RNode {
1053 let text = |t: &Option<TextSource>| t.as_ref().map_or_default(TextSource::initial);
1054 let props = ListItemProps {
1055 title: self.title.initial(),
1056 subtitle: text(&self.subtitle),
1057 detail: text(&self.detail),
1058 icon: self.icon.as_ref().map(|i| i.spec(false)),
1059 icon_tint: self.icon_tint.as_ref().map(Reactive::get_untracked),
1060 checked: self.checked.as_ref().is_some_and(Reactive::get_untracked),
1061 };
1062 let node = cx.leaf(
1064 kinds::LIST_ITEM,
1065 &props,
1066 Flex {
1067 grow_w: true,
1068 whole_row: true,
1069 ..Default::default()
1070 },
1071 );
1072 let patch = move |p: ListItemPatch, size: bool| {
1073 with_tree(|t| t.patch(node, Box::new(p), size));
1074 };
1075 let bind_text =
1076 |src: Option<TextSource>, seed: String, make: fn(String) -> ListItemPatch| {
1077 if let Some(src @ TextSource::Dyn(_)) = src {
1078 day_reactive::bind_seeded(
1079 seed,
1080 move || src.resolve(),
1081 move |t: &String| patch(make(t.clone()), true),
1082 );
1083 }
1084 };
1085 bind_text(Some(self.title), props.title, ListItemPatch::Title);
1086 bind_text(self.subtitle, props.subtitle, ListItemPatch::Subtitle);
1087 bind_text(self.detail, props.detail, ListItemPatch::Detail);
1088 if let Some(icon @ ItemIcon::Vector(Reactive::Dyn(_))) = self.icon {
1089 day_reactive::bind_seeded(
1090 props.icon,
1091 move || Some(icon.spec(true)),
1092 move |i| patch(ListItemPatch::Icon(i.clone()), false),
1093 );
1094 }
1095 if let Some(tint @ Reactive::Dyn(_)) = self.icon_tint {
1096 day_reactive::bind_seeded(
1097 props.icon_tint,
1098 move || Some(tint.get()),
1099 move |c| patch(ListItemPatch::IconTint(*c), false),
1100 );
1101 }
1102 if let Some(on @ Reactive::Dyn(_)) = self.checked {
1103 day_reactive::bind_seeded(
1104 props.checked,
1105 move || on.get(),
1106 move |b: &bool| patch(ListItemPatch::Checked(*b), true),
1107 );
1108 }
1109 node
1110 }
1111
1112 fn compose(self) -> impl Piece {
1114 use crate::{column, image, label, row, vector, when};
1115 let tint = self.icon_tint;
1116 let leading = self.icon.map(move |icon| match icon {
1117 ItemIcon::Vector(src) => {
1118 let glyph = vector(move || src.get()).template();
1119 match tint {
1120 Some(t) => glyph
1121 .tint(move || t.get())
1122 .decorative()
1123 .frame(20.0, 20.0)
1124 .any(),
1125 None => glyph.decorative().frame(20.0, 20.0).any(),
1126 }
1127 }
1128 ItemIcon::Symbol(sym) => match sym.outline_svg() {
1129 Some(svg) => image(svg.into_bytes()).template().frame(20.0, 20.0).any(),
1130 None => crate::spacer().frame(20.0, 20.0).any(),
1131 },
1132 });
1133 let titles = column((
1134 label(self.title),
1135 self.subtitle
1136 .map(|t| label(t).font(day_spec::Font::Footnote).secondary()),
1137 ))
1138 .spacing(2.0)
1139 .align(crate::HAlign::Leading)
1140 .grow(Dimension::Width);
1141 let detail = self.detail.map(|t| label(t).secondary());
1142 let checked = self.checked.clone();
1143 let mark = checked.map(|on| {
1144 when(
1145 move || on.get(),
1146 || {
1147 let svg = day_spec::Symbol::Check.outline_svg().unwrap_or_default();
1148 image(svg.into_bytes())
1149 .template()
1150 .decorative()
1151 .frame(16.0, 16.0)
1152 },
1153 )
1154 });
1155 let selected = self.checked;
1156 row((leading, titles, detail, mark))
1157 .spacing(crate::Space::M)
1158 .align(crate::VAlign::Center)
1159 .grow(Dimension::Width)
1160 .a11y(move |a| match selected {
1161 Some(on) => a.selected(move || on.get()),
1162 None => a,
1163 })
1164 }
1165}
1166
1167type SwipeProvider = Rc<dyn Fn(usize) -> Vec<SwipeAction>>;
1170
1171#[must_use]
1175pub struct SwipeAction {
1176 label: TextSource,
1177 destructive: bool,
1178 tint: Option<day_spec::Color>,
1179 symbol: Option<day_spec::Symbol>,
1180 handler: Rc<dyn Fn()>,
1181}
1182
1183pub fn swipe_action<M>(label: impl IntoText<M>) -> SwipeAction {
1189 SwipeAction {
1190 label: label.into_text(),
1191 destructive: false,
1192 tint: None,
1193 symbol: None,
1194 handler: Rc::new(|| {}),
1195 }
1196}
1197
1198impl SwipeAction {
1199 pub fn destructive(mut self) -> Self {
1202 self.destructive = true;
1203 self
1204 }
1205 pub fn tint(mut self, color: day_spec::Color) -> Self {
1208 self.tint = Some(color);
1209 self
1210 }
1211 pub fn symbol(mut self, symbol: day_spec::Symbol) -> Self {
1215 self.symbol = Some(symbol);
1216 self
1217 }
1218 pub fn action(mut self, f: impl Fn() + 'static) -> Self {
1222 self.handler = Rc::new(f);
1223 self
1224 }
1225}
1226
1227#[derive(Clone)]
1236#[must_use]
1237pub struct Reorder {
1238 moved: Rc<dyn Fn(usize, usize)>,
1239 guard: Option<Rc<dyn Fn(usize, usize) -> ReorderVerdict>>,
1240 enabled: Reactive<bool>,
1241}
1242
1243impl Reorder {
1244 pub fn new(moved: impl Fn(usize, usize) + 'static) -> Reorder {
1249 Reorder {
1250 moved: Rc::new(moved),
1251 guard: None,
1252 enabled: Reactive::Const(true),
1253 }
1254 }
1255 pub fn guard(mut self, g: impl Fn(usize, usize) -> ReorderVerdict + 'static) -> Reorder {
1261 self.guard = Some(Rc::new(g));
1262 self
1263 }
1264 pub fn enabled<M>(mut self, on: impl IntoReactive<bool, M>) -> Reorder {
1268 self.enabled = on.into_reactive();
1269 self
1270 }
1271}
1272
1273#[derive(Clone)]
1283#[must_use]
1284pub struct Delete {
1285 deleted: Rc<dyn Fn(usize)>,
1286 label: Option<TextSource>,
1287 guard: Option<Rc<dyn Fn(usize) -> bool>>,
1288 enabled: Reactive<bool>,
1289}
1290
1291impl Delete {
1292 pub fn new(deleted: impl Fn(usize) + 'static) -> Delete {
1297 Delete {
1298 deleted: Rc::new(deleted),
1299 label: None,
1300 guard: None,
1301 enabled: Reactive::Const(true),
1302 }
1303 }
1304 pub fn label<M>(mut self, text: impl IntoText<M>) -> Delete {
1308 self.label = Some(text.into_text());
1309 self
1310 }
1311 pub fn guard(mut self, g: impl Fn(usize) -> bool + 'static) -> Delete {
1315 self.guard = Some(Rc::new(g));
1316 self
1317 }
1318 pub fn enabled<M>(mut self, on: impl IntoReactive<bool, M>) -> Delete {
1321 self.enabled = on.into_reactive();
1322 self
1323 }
1324}
1325
1326#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1330pub enum ReorderVerdict {
1331 Allow,
1333 Deny,
1335 Retarget(usize),
1337}
1338
1339pub fn list<S, P>(source: S, build_row: impl Fn(S::Slot) -> P + 'static) -> List<S>
1343where
1344 S: RowSource + 'static,
1345 P: Piece,
1346{
1347 List {
1348 source: Some(source),
1349 build_row: Rc::new(move |slot| AnyPiece::new(build_row(slot))),
1350 row_height: RowHeight::Automatic,
1351 on_select: None,
1352 on_activate: None,
1353 on_selection: None,
1354 multi_select: false,
1355 selected_rows: None,
1356 selection: None,
1357 scroll_to_end: None,
1358 scroll_to_row: None,
1359 first_visible_row: None,
1360 stick_to_bottom: false,
1361 reorder: None,
1362 delete: None,
1363 swipe_leading: None,
1364 swipe_trailing: None,
1365 separators: None,
1366 inset_grouped: false,
1367 editing: crate::Reactive::Const(false),
1368 sections: None,
1369 }
1370}
1371
1372#[day_macros::builder(ListBuilder<S>)]
1373impl<S: RowSource + 'static> List<S> {
1374 pub fn row_height(mut self, h: RowHeight) -> Self {
1376 self.row_height = h;
1377 self
1378 }
1379 pub fn on_activate(mut self, f: impl Fn(S::Ref) + 'static) -> Self {
1382 self.on_activate = Some(Rc::new(f));
1383 self
1384 }
1385
1386 pub fn on_select(mut self, f: impl Fn(S::Ref) + 'static) -> Self {
1389 self.on_select = Some(Rc::new(f));
1390 self
1391 }
1392 pub fn multi_select(mut self) -> Self {
1396 self.multi_select = true;
1397 self
1398 }
1399 pub fn on_selection(mut self, f: impl Fn(Vec<S::Ref>) + 'static) -> Self {
1403 self.on_selection = Some(Rc::new(f));
1404 self
1405 }
1406 pub fn selected_rows(mut self, rows: impl Fn() -> Vec<usize> + 'static) -> Self {
1410 self.selected_rows = Some(Rc::new(rows));
1411 self
1412 }
1413 pub fn selection(mut self, selected: impl Binding<Option<u64>>) -> Self
1422 where
1423 S::Ref: SelectionKey,
1424 {
1425 let selected = AnyBinding::new(selected);
1426 self.selection = Some(ListSelection {
1427 key: Rc::new(move || selected.get()),
1428 write: Rc::new(move |key| selected.set_if_changed(key)),
1429 key_of: Rc::new(|row: &S::Ref| row.selection_key()),
1430 });
1431 self
1432 }
1433 pub fn scroll_to_end(mut self, trigger: day_reactive::Trigger) -> Self {
1439 self.scroll_to_end = Some(trigger);
1440 self
1441 }
1442 pub fn stick_to_bottom(mut self) -> Self {
1447 self.stick_to_bottom = true;
1448 self
1449 }
1450
1451 pub fn scroll_to_row(mut self, target: impl Binding<Option<usize>>) -> Self {
1456 self.scroll_to_row = Some(AnyBinding::new(target));
1457 self
1458 }
1459
1460 pub fn first_visible_row(mut self, first: impl Binding<usize>) -> Self {
1464 self.first_visible_row = Some(AnyBinding::new(first));
1465 self
1466 }
1467
1468 pub fn reorderable(mut self, reorder: Reorder) -> Self {
1476 self.reorder = Some(reorder);
1477 self
1478 }
1479
1480 pub fn deletable(mut self, delete: Delete) -> Self {
1489 self.delete = Some(delete);
1490 self
1491 }
1492
1493 pub fn swipe_leading(mut self, provider: impl Fn(usize) -> Vec<SwipeAction> + 'static) -> Self {
1502 self.swipe_leading = Some(Rc::new(provider));
1503 self
1504 }
1505
1506 pub fn swipe_trailing(
1509 mut self,
1510 provider: impl Fn(usize) -> Vec<SwipeAction> + 'static,
1511 ) -> Self {
1512 self.swipe_trailing = Some(Rc::new(provider));
1513 self
1514 }
1515
1516 pub fn separators(mut self) -> Self {
1524 self.separators = Some(true);
1525 self
1526 }
1527
1528 pub fn inset_grouped(mut self) -> Self {
1532 self.inset_grouped = true;
1533 self
1534 }
1535
1536 pub fn no_separators(mut self) -> Self {
1538 self.separators = Some(false);
1539 self
1540 }
1541
1542 pub fn sections<K: Hash, P: Piece>(
1568 mut self,
1569 key: impl Fn(usize) -> K + 'static,
1570 header: impl Fn(S::Slot) -> P + 'static,
1571 ) -> Self {
1572 self.sections = Some(ListSections {
1573 key: Rc::new(move |i| key_token(&key(i))),
1574 header: Rc::new(move |slot| AnyPiece::new(header(slot))),
1575 });
1576 self
1577 }
1578
1579 pub fn editing<M>(mut self, on: impl crate::IntoReactive<bool, M>) -> Self {
1587 self.editing = on.into_reactive();
1588 self
1589 }
1590}
1591
1592fn slot_builder<C: RowConn>(
1595 conn: Rc<C>,
1596 builder: Rc<dyn Fn(C::Slot) -> AnyPiece>,
1597) -> Box<dyn Fn(usize, RNode) -> BuiltRow> {
1598 Box::new(move |index, anchor| {
1599 let scope = Scope::child();
1600 let conn = conn.clone();
1601 let builder = builder.clone();
1602 let rebind = scope.enter(move || {
1603 let Some(slot) = conn.slot_at(index) else {
1606 return Rc::new(|_: usize| {}) as Rc<dyn Fn(usize)>;
1607 };
1608 let mut rowcx = BuildCx::new(anchor);
1609 in_row_scope(|| builder(slot).build(&mut rowcx));
1610 Rc::new(move |i: usize| conn.rebind(&slot, i)) as Rc<dyn Fn(usize)>
1612 });
1613 BuiltRow { scope, rebind }
1614 })
1615}
1616
1617impl<S: RowSource + 'static> Piece for List<S> {
1618 fn build(mut self, cx: &mut BuildCx) -> RNode {
1619 let props = ListProps {
1620 activatable: self.on_activate.is_some(),
1621 row_height: self.row_height,
1622 selectable: self.on_select.is_some()
1623 || self.on_selection.is_some()
1624 || self.selection.is_some()
1625 || self.on_activate.is_some(),
1626 multi_select: self.multi_select,
1627 reorderable: self.reorder.is_some(),
1630 deletable: self.delete.is_some() && self.sections.is_none(),
1631 delete_label: self
1632 .delete
1633 .as_ref()
1634 .and_then(|d| d.label.as_ref())
1635 .map_or_default(TextSource::initial),
1636 swipe_actions: self.swipe_leading.is_some() || self.swipe_trailing.is_some(),
1637 separators: self.separators,
1638 editing: self.editing.get_untracked(),
1639 sections: self.sections.is_some(),
1640 inset_grouped: self.inset_grouped,
1641 };
1642 let node = cx.leaf(
1643 kinds::LIST,
1644 &props,
1645 Flex {
1646 grow_w: true,
1647 grow_h: true,
1648 ..Default::default()
1649 },
1650 );
1651
1652 let conn = Rc::new(self.source.take().expect("List built once").connect());
1656 let section_keys: Rc<RefCell<Vec<u64>>> = Rc::new(RefCell::new(Vec::new()));
1659 let key_of_row = self.sections.as_ref().map(|s| s.key.clone());
1660 let refresh = {
1661 let (conn, keys, key_of_row) = (conn.clone(), section_keys.clone(), key_of_row.clone());
1662 Rc::new(move || {
1663 let tokens = conn.refresh();
1664 if let Some(key) = &key_of_row {
1665 *keys.borrow_mut() = (0..conn.len()).map(|i| key(i)).collect();
1666 }
1667 (tokens, keys.borrow().clone())
1668 })
1669 };
1670 let pending_echo: Rc<RefCell<Option<Vec<u64>>>> = Rc::new(RefCell::new(None));
1674
1675 if let Some(activate) = self.on_activate.clone() {
1676 let conn = conn.clone();
1677 cx.on(node, move |event| {
1678 if let Event::ListActivated(row) = event
1679 && let Some(reference) = conn.select_ref(*row)
1680 {
1681 activate(reference);
1682 }
1683 });
1684 }
1685
1686 if self.on_select.is_some() || self.on_selection.is_some() {
1690 let (on_select, on_selection) = (self.on_select.clone(), self.on_selection.clone());
1691 let conn = conn.clone();
1692 cx.on(node, move |ev| match ev {
1693 Event::SelectionChanged(i) => {
1694 if let Some(f) = &on_select
1695 && let Some(r) = conn.select_ref(*i as usize)
1696 {
1697 f(r);
1698 }
1699 if let Some(f) = &on_selection {
1700 f(conn.select_ref(*i as usize).into_iter().collect());
1701 }
1702 }
1703 Event::SelectionSet(rows) => {
1704 if let Some(f) = &on_selection {
1705 f(rows
1706 .iter()
1707 .filter_map(|i| conn.select_ref(*i as usize))
1708 .collect());
1709 }
1710 }
1711 _ => {}
1712 });
1713 }
1714
1715 let user_pick: Rc<Cell<Option<Option<u64>>>> = Rc::new(Cell::new(None));
1721 let reveal = Rc::new(Cell::new(false));
1722 let apply_selection: Option<Rc<dyn Fn()>> = self.selection.as_ref().map(|sel| {
1723 let (key, conn, reveal) = (sel.key.clone(), conn.clone(), reveal.clone());
1724 Rc::new(move || {
1725 let wanted = day_reactive::untrack(|| key());
1726 let row = wanted.and_then(|k| conn.tokens_now().iter().position(|t| *t == k));
1727 let scroll = row.filter(|_| reveal.replace(false));
1728 day_reactive::on_main(move || {
1731 day_core::list_set_selected(node, row.into_iter().collect());
1732 if let Some(row) = scroll {
1733 list_scroll_to_row(node, row);
1734 }
1735 });
1736 }) as Rc<dyn Fn()>
1737 });
1738 if let Some(sel) = &self.selection {
1739 let (write, key_of) = (sel.write.clone(), sel.key_of.clone());
1740 let (conn, pick) = (conn.clone(), user_pick.clone());
1741 cx.on(node, move |ev| {
1742 let row = match ev {
1743 Event::SelectionChanged(i) => conn.select_ref(*i as usize),
1744 Event::SelectionSet(rows) => {
1745 rows.first().and_then(|i| conn.select_ref(*i as usize))
1746 }
1747 _ => return,
1748 };
1749 let key = row.as_ref().map(|r| key_of(r));
1750 pick.set(Some(key));
1751 write(key);
1752 });
1753 }
1754
1755 if let Some(on_reorder) = self.reorder.as_ref().map(|r| r.moved.clone()) {
1758 cx.on(node, move |ev| {
1759 if let Event::ListReorder { from, to } = ev {
1760 on_reorder(*from, *to);
1761 }
1762 });
1763 }
1764
1765 if let Some(on_delete) = self.delete.as_ref().map(|d| d.deleted.clone()) {
1768 cx.on(node, move |ev| {
1769 if let Event::ListDelete(index) = ev {
1770 on_delete(*index);
1771 }
1772 });
1773 }
1774
1775 if self.swipe_leading.is_some() || self.swipe_trailing.is_some() {
1781 let (leading, trailing) = (self.swipe_leading.clone(), self.swipe_trailing.clone());
1782 cx.on(node, move |ev| {
1783 if let Event::ListSwipe {
1784 index,
1785 edge,
1786 action,
1787 } = ev
1788 {
1789 let provider = match edge {
1790 day_spec::SwipeEdge::Leading => leading.as_ref(),
1791 day_spec::SwipeEdge::Trailing => trailing.as_ref(),
1792 };
1793 if let Some(p) = provider
1794 && let Some(a) = p(*index).get(*action)
1795 {
1796 (a.handler)();
1797 }
1798 }
1799 });
1800 }
1801
1802 if let Some(signal) = self.first_visible_row {
1804 cx.on(node, move |event| {
1805 if let Event::Custom { tag, num, text } = event
1806 && (*tag == "day-list-first-visible"
1807 || (tag.is_empty() && text == "day-list-first-visible"))
1808 && num.is_finite()
1809 && *num >= 0.0
1810 {
1811 signal.set_if_changed(*num as usize);
1812 }
1813 });
1814 }
1815 let driver = ListDriver {
1816 track_viewport: self.first_visible_row.is_some(),
1817 row_height: self.row_height,
1818 len: {
1819 let conn = conn.clone();
1820 Box::new(move || conn.len())
1821 },
1822 token_at: {
1823 let conn = conn.clone();
1824 Box::new(move |i| conn.token_at(i))
1825 },
1826 build: slot_builder(conn.clone(), self.build_row.clone()),
1827 sections: self.sections.as_ref().map(|sections| ListSectionsDriver {
1828 key_at: {
1829 let keys = section_keys.clone();
1830 Box::new(move |i| keys.borrow().get(i).copied().unwrap_or_default())
1831 },
1832 build: slot_builder(conn.clone(), sections.header.clone()),
1833 }),
1834 delete: self.delete.as_ref().map(|delete| ListDeleteDriver {
1835 can_delete: {
1837 let (guard, enabled) = (delete.guard.clone(), delete.enabled.clone());
1838 Box::new(move |i| {
1839 enabled.get_untracked() && guard.as_ref().is_none_or(|g| g(i))
1840 })
1841 },
1842 deleted: {
1846 let (conn, echo, keys) =
1847 (conn.clone(), pending_echo.clone(), section_keys.clone());
1848 Box::new(move |index| {
1849 if index >= conn.len() {
1850 return;
1851 }
1852 conn.commit_delete(index);
1853 if index < keys.borrow().len() {
1854 keys.borrow_mut().remove(index);
1855 }
1856 *echo.borrow_mut() = Some(conn.tokens_now());
1857 enqueue_event(rnode_to_id(node), Event::ListDelete(index));
1858 })
1859 },
1860 }),
1861 reorder: self.reorder.as_ref().map(|reorder| ListReorderDriver {
1862 can_move: {
1865 let (guard, enabled) = (reorder.guard.clone(), reorder.enabled.clone());
1866 Box::new(move |from, to| {
1867 if !enabled.get_untracked() {
1868 return -1;
1869 }
1870 match guard.as_ref().map(|g| g(from, to)) {
1871 None | Some(ReorderVerdict::Allow) => to as i64,
1872 Some(ReorderVerdict::Deny) => -1,
1873 Some(ReorderVerdict::Retarget(i)) => i as i64,
1874 }
1875 })
1876 },
1877 moved: {
1881 let (conn, echo, keys) =
1882 (conn.clone(), pending_echo.clone(), section_keys.clone());
1883 Box::new(move |from, to| {
1884 if from >= conn.len() || to >= conn.len() {
1885 return;
1886 }
1887 conn.commit_move(from, to);
1888 {
1889 let mut keys = keys.borrow_mut();
1890 if from < keys.len() && to < keys.len() {
1891 let k = keys.remove(from);
1892 keys.insert(to, k);
1893 }
1894 }
1895 *echo.borrow_mut() = Some(conn.tokens_now());
1896 enqueue_event(rnode_to_id(node), Event::ListReorder { from, to });
1897 })
1898 },
1899 }),
1900 swipe: (self.swipe_leading.is_some() || self.swipe_trailing.is_some()).then(|| {
1901 ListSwipeDriver {
1902 actions_at: {
1905 let (leading, trailing) =
1906 (self.swipe_leading.clone(), self.swipe_trailing.clone());
1907 Box::new(move |i, edge| {
1908 let provider = match edge {
1909 day_spec::SwipeEdge::Leading => leading.as_ref(),
1910 day_spec::SwipeEdge::Trailing => trailing.as_ref(),
1911 };
1912 provider.map_or_else(Vec::new, |p| {
1913 p(i).iter()
1914 .map(|a| day_spec::ListSwipeAction {
1915 label: a.label.resolve(),
1916 destructive: a.destructive,
1917 tint: a.tint,
1918 symbol: a.symbol,
1919 })
1920 .collect()
1921 })
1922 })
1923 },
1924 performed: {
1927 let conn = conn.clone();
1928 Box::new(move |index, edge, action| {
1929 if index >= conn.len() {
1930 return;
1931 }
1932 enqueue_event(
1933 rnode_to_id(node),
1934 Event::ListSwipe {
1935 index,
1936 edge,
1937 action,
1938 },
1939 );
1940 })
1941 },
1942 }
1943 }),
1944 };
1945 install_list(node, driver);
1946
1947 {
1952 let (conn, echo, stick) = (conn.clone(), pending_echo.clone(), self.stick_to_bottom);
1953 let reselect = apply_selection.clone();
1954 let initial = {
1955 let refresh = refresh.clone();
1956 day_reactive::untrack(move || refresh())
1957 };
1958 list_reload(node);
1964 let last: RefCell<(Vec<u64>, Vec<u64>)> = RefCell::new(initial);
1965 watch(
1966 move || refresh(),
1967 move |rows: &(Vec<u64>, Vec<u64>), _| {
1968 let toks = &rows.0;
1969 let pending = pending_echo.borrow_mut().take();
1970 let is_echo = pending.as_ref().is_some_and(|e| e == toks);
1971 let unchanged = !conn.values_flow_by_reload() && *last.borrow() == *rows;
1973 *last.borrow_mut() = rows.clone();
1974 if !is_echo && pending.is_some() {
1975 let _ = conn.take_row_events();
1979 list_reload(node);
1980 if let Some(apply) = &reselect {
1981 apply();
1982 }
1983 } else if !is_echo && !unchanged {
1984 match conn.take_row_events() {
1985 Some(deltas) if !deltas.is_empty() => list_splice(node, deltas),
1986 Some(_) => {}
1987 None => list_reload(node),
1988 }
1989 if stick {
1990 list_scroll_to_end(node);
1991 }
1992 if let Some(apply) = &reselect {
1994 apply();
1995 }
1996 } else {
1997 let _ = conn.take_row_events();
2000 }
2001 },
2002 );
2003 let _ = echo;
2004 }
2005
2006 if let Some(trigger) = self.scroll_to_end {
2010 watch(
2011 move || trigger.track(),
2012 move |(): &(), _| list_scroll_to_end(node),
2013 );
2014 }
2015
2016 if let Some(sig) = self.scroll_to_row {
2020 watch(
2021 move || sig.get(),
2022 move |row: &Option<usize>, _| {
2023 if let Some(row) = row {
2024 list_scroll_to_row(node, *row);
2025 }
2026 },
2027 );
2028 }
2029
2030 if let editing @ crate::Reactive::Dyn(_) =
2032 std::mem::replace(&mut self.editing, crate::Reactive::Const(false))
2033 {
2034 watch(
2035 move || editing.get(),
2036 move |on: &bool, old| {
2037 if old.is_some() {
2038 list_set_editing(node, *on);
2039 }
2040 },
2041 );
2042 }
2043
2044 if let (Some(sel), Some(apply)) = (self.selection.take(), apply_selection) {
2048 let first = Cell::new(true);
2049 day_reactive::bind(
2050 move || (sel.key)(),
2051 move |key: &Option<u64>| {
2052 let initial = first.replace(false);
2053 let picked = user_pick.take() == Some(*key);
2057 reveal.set(!initial && !picked && key.is_some());
2058 apply();
2059 },
2060 );
2061 }
2062
2063 if let Some(rows) = self.selected_rows {
2067 day_reactive::bind(
2068 move || rows(),
2069 move |rows: &Vec<usize>| {
2070 let rows = rows.clone();
2073 day_reactive::on_main(move || day_core::list_set_selected(node, rows));
2074 },
2075 );
2076 }
2077 node
2078 }
2079}
2080
2081#[cfg(feature = "model")]
2086mod model_rows {
2087 use super::*;
2088 use day_model::{Elem, Identified, Keyed, Source, Store};
2089
2090 pub struct ModelSlot<T: 'static> {
2095 store: Store<Keyed<T>>,
2096 cur: Signal<u64>,
2097 }
2098
2099 impl<T> Clone for ModelSlot<T> {
2100 fn clone(&self) -> Self {
2101 *self
2102 }
2103 }
2104 impl<T> Copy for ModelSlot<T> {}
2105
2106 impl<T: Identified + Clone + 'static> ModelSlot<T> {
2107 pub fn for_key(store: Store<Keyed<T>>, key: u64) -> ModelSlot<T> {
2110 ModelSlot {
2111 store,
2112 cur: Signal::new(key),
2113 }
2114 }
2115 pub fn rebind_key(&self, key: u64) {
2117 self.cur.set_if_changed(key);
2118 }
2119 }
2120
2121 impl<T: Identified + 'static> ModelSlot<T> {
2122 pub fn key(self) -> u64 {
2126 self.cur.get()
2127 }
2128 pub fn item(self) -> Elem<T> {
2131 self.store.elem(self.cur.get())
2132 }
2133 fn elem_now(self) -> Elem<T> {
2134 self.store.elem(self.cur.get_untracked())
2135 }
2136 }
2137
2138 impl<T: Identified + 'static> Source<T> for ModelSlot<T> {
2139 const DYNAMIC: bool = true;
2141 fn track_extra(self) {
2142 self.cur.track();
2143 }
2144 fn path(self) -> day_model::Path {
2145 self.elem_now().path()
2146 }
2147 fn node(self) -> day_model::NodeId {
2148 self.elem_now().node()
2149 }
2150 fn components(self, out: &mut Vec<u64>) {
2151 self.elem_now().components(out);
2152 }
2153 fn with_value_untracked<R>(self, f: impl FnOnce(Option<&T>) -> R) -> R {
2154 self.elem_now().with_value_untracked(f)
2155 }
2156 fn update_value(self, f: impl FnOnce(&mut T)) -> bool {
2157 self.elem_now().update_value(f)
2158 }
2159 fn bump_version(self) {
2160 self.elem_now().bump_version();
2161 }
2162 }
2163
2164 impl<T: Identified + 'static> SelectionKey for Elem<T> {
2166 fn selection_key(&self) -> u64 {
2167 self.key()
2168 }
2169 }
2170
2171 impl<T: Identified + Clone + 'static> RowSource for Store<Keyed<T>> {
2173 type Slot = ModelSlot<T>;
2174 type Ref = Elem<T>;
2175 type Conn = StoreConn<T>;
2176 fn connect(self) -> StoreConn<T> {
2177 StoreConn {
2178 store: self,
2179 rows: None,
2180 keys: RefCell::new(Vec::new()),
2181 }
2182 }
2183 }
2184
2185 pub struct Rows<T: 'static> {
2189 store: Store<Keyed<T>>,
2190 f: Rc<dyn Fn() -> Vec<u64>>,
2191 }
2192
2193 impl<T: Identified + Clone + 'static> RowSource for Rows<T> {
2194 type Slot = ModelSlot<T>;
2195 type Ref = Elem<T>;
2196 type Conn = StoreConn<T>;
2197 fn connect(self) -> StoreConn<T> {
2198 StoreConn {
2199 store: self.store,
2200 rows: Some(self.f),
2201 keys: RefCell::new(Vec::new()),
2202 }
2203 }
2204 }
2205
2206 pub trait StoreRows<T: 'static> {
2208 fn rows(self, f: impl Fn() -> Vec<u64> + 'static) -> Rows<T>;
2209 }
2210
2211 impl<T: Identified + Clone + 'static> StoreRows<T> for Store<Keyed<T>> {
2212 fn rows(self, f: impl Fn() -> Vec<u64> + 'static) -> Rows<T> {
2213 Rows {
2214 store: self,
2215 f: Rc::new(f),
2216 }
2217 }
2218 }
2219
2220 pub struct StoreConn<T: 'static> {
2222 store: Store<Keyed<T>>,
2223 rows: Option<Rc<dyn Fn() -> Vec<u64>>>,
2224 keys: RefCell<Vec<u64>>,
2225 }
2226
2227 impl<T: Identified + Clone + 'static> RowConn for StoreConn<T> {
2228 type Slot = ModelSlot<T>;
2229 type Ref = Elem<T>;
2230
2231 fn refresh(&self) -> Vec<u64> {
2232 let keys = match &self.rows {
2233 Some(f) => f(),
2234 None => self.store.keys(),
2235 };
2236 *self.keys.borrow_mut() = keys.clone();
2237 keys
2238 }
2239 fn len(&self) -> usize {
2240 self.keys.borrow().len()
2241 }
2242 fn token_at(&self, index: usize) -> u64 {
2243 self.keys.borrow().get(index).copied().unwrap_or(0)
2244 }
2245 fn tokens_now(&self) -> Vec<u64> {
2246 self.keys.borrow().clone()
2247 }
2248 fn slot_at(&self, index: usize) -> Option<ModelSlot<T>> {
2249 let key = self.keys.borrow().get(index).copied()?;
2250 Some(ModelSlot {
2251 store: self.store,
2252 cur: Signal::new(key),
2253 })
2254 }
2255 fn rebind(&self, slot: &ModelSlot<T>, index: usize) {
2256 if let Some(key) = self.keys.borrow().get(index).copied() {
2257 slot.cur.set_if_changed(key);
2260 }
2261 }
2262 fn select_ref(&self, index: usize) -> Option<Elem<T>> {
2263 let key = self.keys.borrow().get(index).copied()?;
2264 Some(self.store.elem(key))
2265 }
2266 fn values_flow_by_reload(&self) -> bool {
2267 false
2268 }
2269 fn commit_move(&self, from: usize, to: usize) {
2270 let mut keys = self.keys.borrow_mut();
2271 if from >= keys.len() || to >= keys.len() {
2272 return;
2273 }
2274 let k = keys.remove(from);
2275 keys.insert(to, k);
2276 }
2277 fn commit_delete(&self, index: usize) {
2278 let mut keys = self.keys.borrow_mut();
2279 if index >= keys.len() {
2280 return;
2281 }
2282 keys.remove(index);
2283 }
2284 }
2285
2286 pub struct StoreTree<T: 'static> {
2290 store: Store<Keyed<T>>,
2291 children: Rc<dyn Fn(Option<u64>) -> Vec<u64>>,
2292 }
2293
2294 pub trait StoreTrees<T: 'static> {
2296 fn tree(self, children: impl Fn(Option<u64>) -> Vec<u64> + 'static) -> StoreTree<T>;
2297 }
2298
2299 impl<T: Identified + Clone + 'static> StoreTrees<T> for Store<Keyed<T>> {
2300 fn tree(self, children: impl Fn(Option<u64>) -> Vec<u64> + 'static) -> StoreTree<T> {
2301 StoreTree {
2302 store: self,
2303 children: Rc::new(children),
2304 }
2305 }
2306 }
2307
2308 impl<T: Identified + Clone + 'static> super::NodeSource for StoreTree<T> {
2309 type Slot = ModelSlot<T>;
2310 type Key = u64;
2311 type Conn = StoreTreeConn<T>;
2312 fn connect(self) -> StoreTreeConn<T> {
2313 StoreTreeConn {
2314 store: self.store,
2315 children: self.children,
2316 shape: RefCell::new(super::TreeShape::default()),
2317 }
2318 }
2319 }
2320
2321 pub struct StoreTreeConn<T: 'static> {
2324 store: Store<Keyed<T>>,
2325 children: Rc<dyn Fn(Option<u64>) -> Vec<u64>>,
2326 shape: RefCell<super::TreeShape>,
2327 }
2328
2329 impl<T: Identified + Clone + 'static> super::TreeConn for StoreTreeConn<T> {
2330 type Slot = ModelSlot<T>;
2331 type Key = u64;
2332
2333 fn refresh(&self) -> Vec<(u64, Option<u64>)> {
2334 let mut shape = super::TreeShape::default();
2335 let mut seen = HashSet::new();
2336 let mut stack: Vec<(Option<u64>, u64)> = (self.children)(None)
2339 .into_iter()
2340 .rev()
2341 .map(|k| (None, k))
2342 .collect();
2343 while let Some((parent, key)) = stack.pop() {
2344 if !seen.insert(key) {
2345 debug_assert!(false, "day: cycle or duplicate key in store tree");
2346 continue;
2347 }
2348 shape.tokens.push(key);
2349 shape.parents.insert(key, parent);
2350 shape.children.entry(parent).or_default().push(key);
2351 for child in (self.children)(Some(key)).into_iter().rev() {
2352 stack.push((Some(key), child));
2353 }
2354 }
2355 let fp = shape.fingerprint();
2356 *self.shape.borrow_mut() = shape;
2357 fp
2358 }
2359 fn tokens_now(&self) -> Vec<u64> {
2360 self.shape.borrow().tokens.clone()
2361 }
2362 fn children_len(&self, parent: Option<u64>) -> usize {
2363 self.shape
2364 .borrow()
2365 .children
2366 .get(&parent)
2367 .map(|v| v.len())
2368 .unwrap_or(0)
2369 }
2370 fn child_token(&self, parent: Option<u64>, index: usize) -> u64 {
2371 self.shape
2372 .borrow()
2373 .children
2374 .get(&parent)
2375 .and_then(|v| v.get(index).copied())
2376 .unwrap_or(0)
2377 }
2378 fn parent_of(&self, token: u64) -> Option<Option<u64>> {
2379 self.shape.borrow().parents.get(&token).copied()
2380 }
2381 fn key_of(&self, token: u64) -> Option<u64> {
2382 self.shape
2383 .borrow()
2384 .parents
2385 .contains_key(&token)
2386 .then_some(token)
2387 }
2388 fn token_of(&self, key: &u64) -> u64 {
2389 *key
2390 }
2391 fn slot_for(&self, token: u64) -> Option<ModelSlot<T>> {
2392 self.shape
2393 .borrow()
2394 .parents
2395 .contains_key(&token)
2396 .then(|| ModelSlot::for_key(self.store, token))
2397 }
2398 fn rebind(&self, slot: &ModelSlot<T>, token: u64) {
2399 slot.rebind_key(token);
2400 }
2401 fn values_flow_by_reload(&self) -> bool {
2402 false
2403 }
2404 }
2405}
2406
2407#[cfg(feature = "model")]
2408pub use model_rows::{ModelSlot, Rows, StoreRows, StoreTree, StoreTreeConn, StoreTrees};
2409
2410pub use day_spec::MoveVerdict;
2417
2418pub trait NodeSource {
2422 type Slot: Copy + 'static;
2424 type Key: Clone + Hash + Eq + 'static;
2426 type Conn: TreeConn<Slot = Self::Slot, Key = Self::Key>;
2427 fn connect(self) -> Self::Conn;
2428}
2429
2430pub trait TreeConn: 'static {
2433 type Slot: Copy + 'static;
2434 type Key: Clone + Hash + Eq + 'static;
2435
2436 fn refresh(&self) -> Vec<(u64, Option<u64>)>;
2440 fn tokens_now(&self) -> Vec<u64>;
2442 fn children_len(&self, parent: Option<u64>) -> usize;
2443 fn child_token(&self, parent: Option<u64>, index: usize) -> u64;
2444 fn parent_of(&self, token: u64) -> Option<Option<u64>>;
2446 fn key_of(&self, token: u64) -> Option<Self::Key>;
2447 fn token_of(&self, key: &Self::Key) -> u64;
2449 fn slot_for(&self, token: u64) -> Option<Self::Slot>;
2452 fn rebind(&self, slot: &Self::Slot, token: u64);
2454 fn values_flow_by_reload(&self) -> bool;
2457}
2458
2459pub fn branches<T, K>(
2464 f: impl Fn() -> Vec<T> + 'static,
2465 key_of: impl Fn(&T) -> K + 'static,
2466 parent_of: impl Fn(&T) -> Option<K> + 'static,
2467) -> Branches<T, K>
2468where
2469 T: Clone + 'static,
2470 K: Clone + Hash + Eq + 'static,
2471{
2472 Branches {
2473 f: Rc::new(f),
2474 key_of: Rc::new(key_of),
2475 parent_of: Rc::new(parent_of),
2476 }
2477}
2478
2479type ParentOf<T, K> = Rc<dyn Fn(&T) -> Option<K>>;
2481
2482pub struct Branches<T: 'static, K: 'static> {
2484 f: Rc<dyn Fn() -> Vec<T>>,
2485 key_of: Rc<dyn Fn(&T) -> K>,
2486 parent_of: ParentOf<T, K>,
2487}
2488
2489impl<T: Clone + 'static, K: Clone + Hash + Eq + 'static> NodeSource for Branches<T, K> {
2490 type Slot = ItemSlot<T, K>;
2491 type Key = K;
2492 type Conn = BranchesConn<T, K>;
2493 fn connect(self) -> BranchesConn<T, K> {
2494 BranchesConn {
2495 f: self.f,
2496 key_of: self.key_of,
2497 parent_of: self.parent_of,
2498 snapshot: RefCell::new(Vec::new()),
2499 shape: RefCell::new(TreeShape::default()),
2500 }
2501 }
2502}
2503
2504#[derive(Default)]
2506struct TreeShape {
2507 tokens: Vec<u64>,
2509 children: std::collections::HashMap<Option<u64>, Vec<u64>>,
2510 parents: std::collections::HashMap<u64, Option<u64>>,
2511 index_of: std::collections::HashMap<u64, usize>,
2513}
2514
2515impl TreeShape {
2516 fn fingerprint(&self) -> Vec<(u64, Option<u64>)> {
2517 self.tokens
2518 .iter()
2519 .map(|t| (*t, self.parents.get(t).copied().flatten()))
2520 .collect()
2521 }
2522}
2523
2524pub struct BranchesConn<T: 'static, K: 'static> {
2526 f: Rc<dyn Fn() -> Vec<T>>,
2527 key_of: Rc<dyn Fn(&T) -> K>,
2528 parent_of: ParentOf<T, K>,
2529 snapshot: RefCell<Vec<T>>,
2530 shape: RefCell<TreeShape>,
2531}
2532
2533impl<T: Clone + 'static, K: Clone + Hash + Eq + 'static> TreeConn for BranchesConn<T, K> {
2534 type Slot = ItemSlot<T, K>;
2535 type Key = K;
2536
2537 fn refresh(&self) -> Vec<(u64, Option<u64>)> {
2538 let its = (self.f)();
2539 let mut shape = TreeShape::default();
2540 let toks: Vec<u64> = its.iter().map(|t| key_token(&(self.key_of)(t))).collect();
2541 let present: HashSet<u64> = toks.iter().copied().collect();
2542 for (i, item) in its.iter().enumerate() {
2543 let tok = toks[i];
2544 let parent = (self.parent_of)(item)
2546 .map(|k| key_token(&k))
2547 .filter(|p| present.contains(p));
2548 shape.tokens.push(tok);
2549 shape.parents.insert(tok, parent);
2550 shape.children.entry(parent).or_default().push(tok);
2551 shape.index_of.insert(tok, i);
2552 }
2553 *self.snapshot.borrow_mut() = its;
2554 let fp = shape.fingerprint();
2555 *self.shape.borrow_mut() = shape;
2556 fp
2557 }
2558 fn tokens_now(&self) -> Vec<u64> {
2559 self.shape.borrow().tokens.clone()
2560 }
2561 fn children_len(&self, parent: Option<u64>) -> usize {
2562 self.shape
2563 .borrow()
2564 .children
2565 .get(&parent)
2566 .map_or(0, std::vec::Vec::len)
2567 }
2568 fn child_token(&self, parent: Option<u64>, index: usize) -> u64 {
2569 self.shape
2570 .borrow()
2571 .children
2572 .get(&parent)
2573 .and_then(|v| v.get(index).copied())
2574 .unwrap_or(0)
2575 }
2576 fn parent_of(&self, token: u64) -> Option<Option<u64>> {
2577 self.shape.borrow().parents.get(&token).copied()
2578 }
2579 fn key_of(&self, token: u64) -> Option<K> {
2580 let idx = self.shape.borrow().index_of.get(&token).copied()?;
2581 self.snapshot.borrow().get(idx).map(|t| (self.key_of)(t))
2582 }
2583 fn token_of(&self, key: &K) -> u64 {
2584 key_token(key)
2585 }
2586 fn slot_for(&self, token: u64) -> Option<ItemSlot<T, K>> {
2587 let idx = self.shape.borrow().index_of.get(&token).copied()?;
2588 let item = self.snapshot.borrow().get(idx).cloned()?;
2589 let key = (self.key_of)(&item);
2590 Some(ItemSlot {
2591 sig: Signal::new(item),
2592 key: Signal::new(key),
2593 })
2594 }
2595 fn rebind(&self, slot: &ItemSlot<T, K>, token: u64) {
2596 let Some(idx) = self.shape.borrow().index_of.get(&token).copied() else {
2597 return; };
2599 let Some(item) = self.snapshot.borrow().get(idx).cloned() else {
2600 return;
2601 };
2602 slot.key.set((self.key_of)(&item));
2603 slot.sig.set(item);
2604 }
2605 fn values_flow_by_reload(&self) -> bool {
2606 true
2607 }
2608}
2609
2610#[must_use]
2619pub struct Move<K: 'static> {
2620 moved: TreeMoveFn<K>,
2621 guard: Option<TreeGuardFn<K>>,
2622 enabled: Reactive<bool>,
2623}
2624
2625impl<K: 'static> Move<K> {
2626 pub fn new(moved: impl Fn(K, Option<K>, Option<usize>) + 'static) -> Move<K> {
2631 Move {
2632 moved: Rc::new(moved),
2633 guard: None,
2634 enabled: Reactive::Const(true),
2635 }
2636 }
2637 pub fn guard(
2641 mut self,
2642 g: impl Fn(&K, Option<&K>, Option<usize>) -> MoveVerdict + 'static,
2643 ) -> Move<K> {
2644 self.guard = Some(Rc::new(g));
2645 self
2646 }
2647 pub fn enabled<M>(mut self, on: impl IntoReactive<bool, M>) -> Move<K> {
2650 self.enabled = on.into_reactive();
2651 self
2652 }
2653}
2654
2655#[must_use]
2656pub struct TreePiece<S: NodeSource> {
2657 source: Option<S>,
2658 build_row: Rc<dyn Fn(S::Slot) -> AnyPiece>,
2659 row_height: RowHeight,
2660 indent: Option<f64>,
2661 section_headers: bool,
2662 on_expansion: Option<ExpansionFn<S::Key>>,
2663 expanded: Option<AnyBinding<HashSet<S::Key>>>,
2664 expandable: Option<KeyPredicate<S::Key>>,
2665 selected: Option<Rc<dyn Fn() -> Vec<S::Key>>>,
2666 on_selection: Option<SelectionKeysFn<S::Key>>,
2667 multi_select: bool,
2668 movable: bool,
2669 on_move: Option<TreeMoveFn<S::Key>>,
2670 move_guard: Option<TreeGuardFn<S::Key>>,
2671 type_ahead: Option<KeyTextFn<S::Key>>,
2672 reveal: Option<AnyBinding<Option<S::Key>>>,
2673 row_id: Option<KeyIdFn<S::Key>>,
2674 row_menu: Option<RowMenuEntriesFn<S::Key>>,
2675}
2676
2677type ExpansionFn<K> = Rc<dyn Fn(K, bool)>;
2679type TreeMoveFn<K> = Rc<dyn Fn(K, Option<K>, Option<usize>)>;
2680type TreeGuardFn<K> = Rc<dyn Fn(&K, Option<&K>, Option<usize>) -> MoveVerdict>;
2682type KeyPredicate<K> = Rc<dyn Fn(&K) -> bool>;
2684type SelectionKeysFn<K> = Rc<dyn Fn(Vec<K>)>;
2686type KeyTextFn<K> = Rc<dyn Fn(&K) -> String>;
2688type KeyIdFn<K> = Rc<dyn Fn(&K) -> day_core::ElementId>;
2690type RowMenuEntriesFn<K> = Rc<dyn Fn(&K) -> Vec<MenuEntry>>;
2692
2693pub fn tree<S, P>(source: S, build_row: impl Fn(S::Slot) -> P + 'static) -> TreePiece<S>
2697where
2698 S: NodeSource + 'static,
2699 P: Piece,
2700{
2701 TreePiece {
2702 source: Some(source),
2703 build_row: Rc::new(move |slot| AnyPiece::new(build_row(slot))),
2704 row_height: RowHeight::Automatic,
2705 indent: None,
2706 section_headers: false,
2707 on_expansion: None,
2708 expanded: None,
2709 expandable: None,
2710 selected: None,
2711 on_selection: None,
2712 multi_select: false,
2713 movable: false,
2714 on_move: None,
2715 move_guard: None,
2716 type_ahead: None,
2717 reveal: None,
2718 row_id: None,
2719 row_menu: None,
2720 }
2721}
2722
2723#[day_macros::builder(TreeBuilder<S>)]
2724impl<S: NodeSource + 'static> TreePiece<S> {
2725 pub fn row_height(mut self, h: RowHeight) -> Self {
2727 self.row_height = h;
2728 self
2729 }
2730 pub fn indent(mut self, pts: f64) -> Self {
2732 self.indent = Some(pts);
2733 self
2734 }
2735 pub fn section_headers(mut self) -> Self {
2739 self.section_headers = true;
2740 self
2741 }
2742 pub fn on_expansion(mut self, f: impl Fn(S::Key, bool) + 'static) -> Self {
2745 self.on_expansion = Some(Rc::new(f));
2746 self
2747 }
2748 pub fn expanded(mut self, set: impl Binding<HashSet<S::Key>>) -> Self {
2752 self.expanded = Some(AnyBinding::new(set));
2753 self
2754 }
2755 pub fn expandable(mut self, f: impl Fn(&S::Key) -> bool + 'static) -> Self {
2759 self.expandable = Some(Rc::new(f));
2760 self
2761 }
2762 pub fn selected(mut self, f: impl Fn() -> Vec<S::Key> + 'static) -> Self {
2766 self.selected = Some(Rc::new(f));
2767 self
2768 }
2769 pub fn on_selection(mut self, f: impl Fn(Vec<S::Key>) + 'static) -> Self {
2772 self.on_selection = Some(Rc::new(f));
2773 self
2774 }
2775 pub fn multi_select(mut self) -> Self {
2777 self.multi_select = true;
2778 self
2779 }
2780 pub fn movable(mut self, mv: Move<S::Key>) -> Self {
2788 self.movable = true;
2789 self.on_move = Some(mv.moved);
2790 let enabled = mv.enabled;
2793 let guard = mv.guard;
2794 self.move_guard = Some(Rc::new(move |k: &S::Key, p: Option<&S::Key>, i| {
2795 if !enabled.get_untracked() {
2796 return MoveVerdict::Deny;
2797 }
2798 match &guard {
2799 Some(g) => g(k, p, i),
2800 None => MoveVerdict::Allow,
2801 }
2802 }));
2803 self
2804 }
2805 pub fn type_ahead(mut self, f: impl Fn(&S::Key) -> String + 'static) -> Self {
2808 self.type_ahead = Some(Rc::new(f));
2809 self
2810 }
2811 pub fn reveal(mut self, target: impl Binding<Option<S::Key>>) -> Self {
2814 self.reveal = Some(AnyBinding::new(target));
2815 self
2816 }
2817 pub fn row_id(mut self, f: impl Fn(&S::Key) -> day_core::ElementId + 'static) -> Self {
2821 self.row_id = Some(Rc::new(f));
2822 self
2823 }
2824 pub fn row_context_menu(mut self, f: impl Fn(&S::Key) -> Vec<MenuEntry> + 'static) -> Self {
2830 self.row_menu = Some(Rc::new(f));
2831 self
2832 }
2833
2834 fn build_composed(mut self, cx: &mut BuildCx) -> RNode {
2841 fn visible<C: TreeConn + ?Sized>(
2844 conn: &C,
2845 is_open: &dyn Fn(u64) -> bool,
2846 parent: Option<u64>,
2847 depth: u16,
2848 out: &mut Vec<(u64, u16)>,
2849 ) {
2850 for i in 0..conn.children_len(parent) {
2851 let t = conn.child_token(parent, i);
2852 out.push((t, depth));
2853 if is_open(t) {
2854 visible(conn, is_open, Some(t), depth + 1, out);
2855 }
2856 }
2857 }
2858 const CHEVRON_W: f64 = 18.0;
2861 const DEFAULT_INDENT: f64 = 14.0;
2862
2863 let conn = Rc::new(self.source.take().expect("TreePiece built once").connect());
2864 let open_sig: Signal<HashSet<u64>> = Signal::new(HashSet::new());
2868 let expanded_sig = self.expanded;
2869
2870 let is_open: Rc<dyn Fn(u64) -> bool> = {
2872 let conn = conn.clone();
2873 match expanded_sig {
2874 Some(sig) => Rc::new(move |t| match conn.key_of(t) {
2875 Some(k) => sig.with(|s| s.contains(&k)),
2876 None => false,
2877 }),
2878 None => Rc::new(move |t| open_sig.with(|s| s.contains(&t))),
2879 }
2880 };
2881 let set_open: Rc<dyn Fn(u64, bool)> = {
2882 let (conn, is_open, changed) =
2883 (conn.clone(), is_open.clone(), self.on_expansion.clone());
2884 Rc::new(move |t, on| {
2885 if day_reactive::untrack(|| is_open(t)) == on {
2886 return;
2887 }
2888 let Some(key) = conn.key_of(t) else {
2889 return;
2890 };
2891 if let Some(sig) = expanded_sig {
2892 sig.update(|s| {
2893 if on {
2894 s.insert(key.clone());
2895 } else {
2896 s.remove(&key);
2897 }
2898 });
2899 } else {
2900 open_sig.update(|s| {
2901 if on {
2902 s.insert(t);
2903 } else {
2904 s.remove(&t);
2905 }
2906 });
2907 }
2908 if let Some(f) = &changed {
2909 f(key, on);
2910 }
2911 })
2912 };
2913
2914 let expandable_of: Rc<dyn Fn(u64) -> bool> = {
2916 let (conn, f) = (conn.clone(), self.expandable.clone());
2917 Rc::new(move |tok| match &f {
2918 Some(f) => conn.key_of(tok).is_some_and(|k| f(&k)),
2919 None => conn.children_len(Some(tok)) > 0,
2920 })
2921 };
2922
2923 let flatten: Rc<dyn Fn() -> Vec<(u64, u16)>> = {
2924 let (conn, is_open) = (conn.clone(), is_open.clone());
2925 Rc::new(move || {
2926 let _shape = conn.refresh();
2927 let mut rows = Vec::new();
2928 visible(&*conn, &*is_open, None, 0, &mut rows);
2929 rows
2930 })
2931 };
2932
2933 let step = self.indent.unwrap_or(DEFAULT_INDENT);
2937 let build_row = {
2938 let (conn, user_row, row_id) =
2939 (conn.clone(), self.build_row.clone(), self.row_id.clone());
2940 let (is_open, expandable_of, set_open) =
2941 (is_open.clone(), expandable_of.clone(), set_open.clone());
2942 let row_menu = self.row_menu.clone();
2943 move |slot: ItemSlot<(u64, u16), u64>| -> AnyPiece {
2944 let (token0, depth0) = day_reactive::untrack(|| slot.get());
2945 let Some(user_slot) = conn.slot_for(token0) else {
2946 return AnyPiece::new(crate::spacer());
2948 };
2949 let depth = Rc::new(std::cell::Cell::new(f64::from(depth0)));
2950 let chevron = {
2951 let (is_open, expandable_of) = (is_open.clone(), expandable_of.clone());
2952 let (set_open, is_open_tap) = (set_open.clone(), is_open.clone());
2953 let expandable_tap = expandable_of.clone();
2954 crate::label(move || {
2955 let t = slot.get().0;
2956 if expandable_of(t) {
2960 if is_open(t) { "▼" } else { "▶" }
2961 } else {
2962 ""
2963 }
2964 .to_string()
2965 })
2966 .align(TextAlign::Center)
2967 .width(CHEVRON_W)
2968 .on_tap(move || {
2969 let t = day_reactive::untrack(|| slot.get().0);
2970 if expandable_tap(t) {
2971 set_open(t, !day_reactive::untrack(|| is_open_tap(t)));
2972 }
2973 })
2974 };
2975 let content = crate::row((chevron, user_row(user_slot)));
2976 let shell = TreeRowShell {
2977 depth: depth.clone(),
2978 step,
2979 content: AnyPiece::new(content),
2980 }
2981 .tweak({
2982 let (conn, row_id) = (conn.clone(), row_id.clone());
2983 move |n| {
2984 let id_conn = conn.clone();
2985 let set_ids = move |tok: u64| {
2986 if let Some(rid) = &row_id
2987 && let Some(k) = id_conn.key_of(tok)
2988 {
2989 with_tree(|t| t.set_id(n, rid(&k).as_str().to_owned()));
2990 }
2991 };
2992 set_ids(token0);
2993 watch(
2994 move || slot.get(),
2995 move |(tok, d), _| {
2996 conn.rebind(&user_slot, *tok);
2997 depth.set(f64::from(*d));
2998 set_ids(*tok);
2999 },
3000 );
3001 }
3002 });
3003 match &row_menu {
3004 Some(f) => {
3008 let (conn, f) = (conn.clone(), f.clone());
3009 AnyPiece::new(shell.context_menu(move |_p: day_spec::Point| {
3010 match conn.key_of(day_reactive::untrack(|| slot.get().0)) {
3011 Some(k) => f(&k),
3012 None => Vec::new(),
3013 }
3014 }))
3015 }
3016 None => AnyPiece::new(shell),
3017 }
3018 }
3019 };
3020
3021 let section_header: Rc<dyn Fn(u64) -> bool> = {
3022 let (conn, expandable, sections) =
3023 (conn.clone(), expandable_of.clone(), self.section_headers);
3024 Rc::new(move |t| sections && conn.parent_of(t) == Some(None) && expandable(t))
3025 };
3026 let scroll_sig: Signal<Option<usize>> = Signal::new(None);
3027 let mut lst = list(
3028 items(
3029 {
3030 let flatten = flatten.clone();
3031 move || flatten()
3032 },
3033 |r: &(u64, u16)| r.0,
3034 ),
3035 build_row,
3036 )
3037 .row_height(self.row_height)
3038 .apply_if(self.multi_select, ListBuilder::multi_select)
3039 .scroll_to_row(scroll_sig);
3040 let selected_tokens = Signal::new(Vec::<u64>::new());
3043 let selection_revision = Signal::new(0u64);
3044 if self.on_selection.is_some() || (self.section_headers && self.selected.is_some()) {
3045 let conn = conn.clone();
3046 let header = section_header.clone();
3047 let callback = self.on_selection.clone();
3048 lst = lst.on_selection(move |toks: Vec<u64>| {
3049 if toks.iter().any(|t| header(*t)) {
3050 selection_revision.update(|r| *r += 1);
3051 return;
3052 }
3053 selected_tokens.set(toks.clone());
3054 if let Some(f) = &callback {
3055 f(toks.iter().filter_map(|t| conn.key_of(*t)).collect());
3056 }
3057 });
3058 }
3059 let mut repair_selection: Option<Rc<dyn Fn() -> Vec<usize>>> = None;
3060 if self.selected.is_some() || (self.section_headers && self.on_selection.is_some()) {
3061 let (conn, flatten, selected) = (conn.clone(), flatten.clone(), self.selected.clone());
3062 let section_header = section_header.clone();
3063 let rows: Rc<dyn Fn() -> Vec<usize>> = Rc::new(move || {
3064 let rows = flatten();
3065 let want: HashSet<u64> = match &selected {
3066 Some(sel) => sel().iter().map(|k| conn.token_of(k)).collect(),
3067 None => selected_tokens.get().into_iter().collect(),
3068 };
3069 rows.iter()
3070 .enumerate()
3071 .filter(|(_, r)| want.contains(&r.0) && !section_header(r.0))
3072 .map(|(i, _)| i)
3073 .collect()
3074 });
3075 repair_selection = Some(rows.clone());
3076 lst = lst.selected_rows(move || rows());
3077 }
3078 let node = lst.build(cx);
3079 if let Some(rows) = repair_selection {
3080 day_reactive::bind(
3081 move || selection_revision.get(),
3082 move |revision| {
3083 if *revision != 0 {
3084 let rows = day_reactive::untrack(|| rows());
3085 day_reactive::on_main(move || day_core::list_set_selected(node, rows));
3086 }
3087 },
3088 );
3089 }
3090
3091 {
3094 let (on_move, conn_ev, set_open) =
3095 (self.on_move.clone(), conn.clone(), set_open.clone());
3096 cx.on(node, move |ev| match ev {
3097 Event::TreeExpanded { token, expanded } => set_open(*token, *expanded),
3098 Event::TreeMove {
3099 token,
3100 parent,
3101 index,
3102 } => {
3103 if let Some(f) = &on_move
3104 && let Some(key) = conn_ev.key_of(*token)
3105 {
3106 f(key, parent.and_then(|p| conn_ev.key_of(p)), *index);
3107 }
3108 }
3109 _ => {}
3110 });
3111 }
3112
3113 let driver = TreeDriver {
3115 section_header: {
3116 let f = section_header.clone();
3117 Box::new(move |t| f(t))
3118 },
3119 row_height: self.row_height,
3120 children_len: {
3121 let conn = conn.clone();
3122 Box::new(move |p| conn.children_len(p))
3123 },
3124 child_token: {
3125 let conn = conn.clone();
3126 Box::new(move |p, i| conn.child_token(p, i))
3127 },
3128 expandable: {
3129 let f = expandable_of.clone();
3130 Box::new(move |t| f(t))
3131 },
3132 expanded: {
3133 let is_open = is_open.clone();
3134 Box::new(move |t| day_reactive::untrack(|| is_open(t)))
3135 },
3136 build: Box::new(|_tok, _anchor| TreeBuiltRow {
3139 scope: Scope::child(),
3140 rebind: Rc::new(|_| {}),
3141 }),
3142 type_select_text: Box::new(|_| String::new()),
3143 resolve_row: {
3144 let (conn, row_id) = (conn.clone(), self.row_id.clone());
3145 Box::new(move |id| {
3146 let rid = row_id.as_ref()?;
3147 conn.tokens_now()
3148 .into_iter()
3149 .find(|t| conn.key_of(*t).is_some_and(|k| rid(&k).as_str() == id))
3150 })
3151 },
3152 row_menu: None,
3153 moves: self.movable.then(|| {
3154 let can = {
3155 let (conn, expandable_of, guard) =
3156 (conn.clone(), expandable_of.clone(), self.move_guard.clone());
3157 move |tok: u64, parent: Option<u64>, index: Option<usize>| {
3158 let Some(key) = conn.key_of(tok) else {
3159 return MoveVerdict::Deny;
3160 };
3161 let parent_key = match parent {
3162 Some(p) => {
3163 if p == tok || !expandable_of(p) {
3164 return MoveVerdict::Deny;
3165 }
3166 let mut cur = Some(p);
3167 while let Some(c) = cur {
3168 if c == tok {
3169 return MoveVerdict::Deny;
3170 }
3171 cur = conn.parent_of(c).flatten();
3172 }
3173 match conn.key_of(p) {
3174 Some(k) => Some(k),
3175 None => return MoveVerdict::Deny,
3176 }
3177 }
3178 None => None,
3179 };
3180 match &guard {
3181 Some(g) => g(&key, parent_key.as_ref(), index),
3182 None => MoveVerdict::Allow,
3183 }
3184 }
3185 };
3186 let can_commit = can.clone();
3187 TreeMovesDriver {
3188 can_move: Box::new(can),
3189 moved: Box::new(move |t, p, i| {
3190 if can_commit(t, p, i) == MoveVerdict::Deny {
3191 return;
3192 }
3193 enqueue_event(
3194 rnode_to_id(node),
3195 Event::TreeMove {
3196 token: t,
3197 parent: p,
3198 index: i,
3199 },
3200 );
3201 }),
3202 }
3203 }),
3204 };
3205 install_tree(node, driver);
3206
3207 if let Some(sig) = self.reveal {
3210 let (conn, set_open, flatten) = (conn.clone(), set_open.clone(), flatten.clone());
3211 watch(
3212 move || sig.get(),
3213 move |key: &Option<S::Key>, _| {
3214 let Some(key) = key else { return };
3215 let tok = conn.token_of(key);
3216 let mut cur = conn.parent_of(tok).flatten();
3217 while let Some(p) = cur {
3218 set_open(p, true);
3219 cur = conn.parent_of(p).flatten();
3220 }
3221 let row = day_reactive::untrack(|| flatten())
3222 .iter()
3223 .position(|r| r.0 == tok);
3224 if let Some(row) = row {
3225 scroll_sig.set(Some(row));
3226 }
3227 },
3228 );
3229 }
3230
3231 node
3232 }
3233}
3234
3235struct TreeIndent {
3239 depth: Rc<std::cell::Cell<f64>>,
3240 step: f64,
3241}
3242
3243impl Layout for TreeIndent {
3244 fn measure(&self, cx: &mut dyn LayoutOps, children: &[RNode], p: Proposal) -> Size {
3245 let pad = self.depth.get() * self.step;
3246 let child_p = Proposal::new(p.width.map(|w| (w - pad).max(0.0)), p.height);
3247 let s = match children.first() {
3248 Some(&c) => cx.measure_child(c, child_p),
3249 None => Size::ZERO,
3250 };
3251 Size::new(s.width + pad, s.height)
3252 }
3253 fn place(&self, cx: &mut dyn LayoutOps, children: &[RNode], bounds: Rect) {
3254 if let Some(&c) = children.first() {
3255 let pad = (self.depth.get() * self.step).min(bounds.size.width);
3256 let inner = Size::new(bounds.size.width - pad, bounds.size.height);
3257 let _ = cx.measure_child(c, Proposal::exact(inner));
3258 cx.place_child(c, Rect::new(pad, 0.0, inner.width, inner.height));
3259 }
3260 }
3261}
3262
3263struct TreeRowShell {
3266 depth: Rc<std::cell::Cell<f64>>,
3267 step: f64,
3268 content: AnyPiece,
3269}
3270
3271impl Piece for TreeRowShell {
3272 fn build(self, cx: &mut BuildCx) -> RNode {
3273 let w = cx.native(
3277 kinds::CONTAINER,
3278 &ContainerProps {
3279 background: None,
3280 corner_radius: 0.0,
3281 clips: false,
3282 role: None,
3283 },
3284 Rc::new(TreeIndent {
3285 depth: self.depth,
3286 step: self.step,
3287 }),
3288 Flex {
3289 grow_w: true,
3290 ..Default::default()
3291 },
3292 Boundary::No,
3293 );
3294 cx.under(w, |cx| {
3295 let _ = self.content.build(cx);
3296 });
3297 w
3298 }
3299}
3300
3301impl<S: NodeSource + 'static> Piece for TreePiece<S> {
3302 fn build(mut self, cx: &mut BuildCx) -> RNode {
3303 let cap = if self.section_headers && !self.multi_select {
3309 day_spec::Cap::TreeSections
3310 } else {
3311 day_spec::Cap::Tree
3312 };
3313 if day_core::capability(cap) != day_spec::Support::Native {
3314 return self.build_composed(cx);
3315 }
3316 let props = TreeProps {
3317 section_headers: self.section_headers,
3318 row_height: self.row_height,
3319 selectable: self.selected.is_some() || self.on_selection.is_some(),
3320 multi_select: self.multi_select,
3321 movable: self.movable,
3322 indent: self.indent,
3323 };
3324 let node = cx.leaf(
3325 kinds::TREE,
3326 &props,
3327 Flex {
3328 grow_w: true,
3329 grow_h: true,
3330 ..Default::default()
3331 },
3332 );
3333
3334 let conn = Rc::new(self.source.take().expect("TreePiece built once").connect());
3335
3336 let open_tokens: Rc<RefCell<HashSet<u64>>> = Rc::new(RefCell::new(HashSet::new()));
3340
3341 let expandable_of: Rc<dyn Fn(u64) -> bool> = {
3343 let (conn, f) = (conn.clone(), self.expandable.clone());
3344 Rc::new(move |tok| match &f {
3345 Some(f) => conn.key_of(tok).is_some_and(|k| f(&k)),
3346 None => conn.children_len(Some(tok)) > 0,
3347 })
3348 };
3349
3350 let section_header: Rc<dyn Fn(u64) -> bool> = {
3351 let (conn, expandable, sections) =
3352 (conn.clone(), expandable_of.clone(), self.section_headers);
3353 Rc::new(move |t| sections && conn.parent_of(t) == Some(None) && expandable(t))
3354 };
3355 {
3357 let (on_selection, expanded_sig) = (self.on_selection.clone(), self.expanded);
3358 let (on_move, conn_ev, open) =
3359 (self.on_move.clone(), conn.clone(), open_tokens.clone());
3360 let changed = self.on_expansion.clone();
3361 let header = section_header.clone();
3362 cx.on(node, move |ev| match ev {
3363 Event::TreeSelection(tokens) => {
3364 if let Some(f) = &on_selection {
3365 f(tokens
3366 .iter()
3367 .filter(|t| !header(**t))
3368 .filter_map(|t| conn_ev.key_of(*t))
3369 .collect());
3370 }
3371 }
3372 Event::TreeExpanded { token, expanded } => {
3373 let Some(key) = conn_ev.key_of(*token) else {
3374 return;
3375 };
3376 let was = expanded_sig.map_or_else(
3377 || open.borrow().contains(token),
3378 |sig| day_reactive::untrack(|| sig.with(|s| s.contains(&key))),
3379 );
3380 if was == *expanded {
3381 return;
3382 }
3383 if let Some(sig) = &expanded_sig {
3384 if let Some(key) = conn_ev.key_of(*token) {
3390 sig.update(|set| {
3391 if *expanded {
3392 set.insert(key.clone());
3393 } else {
3394 set.remove(&key);
3395 }
3396 });
3397 }
3398 } else {
3399 if *expanded {
3404 open.borrow_mut().insert(*token);
3405 } else {
3406 open.borrow_mut().remove(token);
3407 }
3408 day_core::tree_set_expanded(node, *token, *expanded);
3409 }
3410 if let Some(f) = &changed {
3411 f(key, *expanded);
3412 }
3413 }
3414 Event::TreeMove {
3415 token,
3416 parent,
3417 index,
3418 } => {
3419 if let Some(f) = &on_move
3420 && let Some(key) = conn_ev.key_of(*token)
3421 {
3422 f(key, parent.and_then(|p| conn_ev.key_of(p)), *index);
3423 }
3424 }
3425 _ => {}
3426 });
3427 }
3428
3429 let driver = TreeDriver {
3431 section_header: {
3432 let f = section_header.clone();
3433 Box::new(move |t| f(t))
3434 },
3435 row_height: self.row_height,
3436 children_len: {
3437 let conn = conn.clone();
3438 Box::new(move |p| conn.children_len(p))
3439 },
3440 child_token: {
3441 let conn = conn.clone();
3442 Box::new(move |p, i| conn.child_token(p, i))
3443 },
3444 expandable: {
3445 let f = expandable_of.clone();
3446 Box::new(move |t| f(t))
3447 },
3448 expanded: {
3449 let open = open_tokens.clone();
3450 Box::new(move |t| open.borrow().contains(&t))
3451 },
3452 build: {
3453 let (conn, build_row, row_id) =
3454 (conn.clone(), self.build_row.clone(), self.row_id.clone());
3455 Box::new(move |token, anchor| {
3456 let scope = Scope::child();
3457 let (conn, build_row, row_id) =
3458 (conn.clone(), build_row.clone(), row_id.clone());
3459 let rebind = scope.enter(move || {
3460 let Some(slot) = conn.slot_for(token) else {
3463 return Rc::new(|_: u64| {}) as Rc<dyn Fn(u64)>;
3464 };
3465 let mut rowcx = BuildCx::new(anchor);
3466 let root = build_row(slot).build(&mut rowcx);
3467 if let Some(rid) = &row_id
3468 && let Some(k) = conn.key_of(token)
3469 {
3470 with_tree(|t| t.set_id(root, rid(&k).as_str().to_owned()));
3471 }
3472 Rc::new(move |tok: u64| {
3475 conn.rebind(&slot, tok);
3476 if let Some(rid) = &row_id
3477 && let Some(k) = conn.key_of(tok)
3478 {
3479 with_tree(|t| t.set_id(root, rid(&k).as_str().to_owned()));
3480 }
3481 }) as Rc<dyn Fn(u64)>
3482 });
3483 TreeBuiltRow { scope, rebind }
3484 })
3485 },
3486 type_select_text: {
3487 let (conn, f) = (conn.clone(), self.type_ahead.clone());
3488 Box::new(move |tok| match &f {
3489 Some(f) => conn.key_of(tok).map_or_default(|k| f(&k)),
3490 None => String::new(),
3491 })
3492 },
3493 resolve_row: {
3494 let (conn, row_id) = (conn.clone(), self.row_id.clone());
3495 Box::new(move |id| {
3496 let rid = row_id.as_ref()?;
3497 conn.tokens_now()
3498 .into_iter()
3499 .find(|t| conn.key_of(*t).is_some_and(|k| rid(&k).as_str() == id))
3500 })
3501 },
3502 row_menu: self.row_menu.clone().map(|f| {
3503 let conn = conn.clone();
3506 let last: Rc<RefCell<Option<Scope>>> = Rc::default();
3507 {
3508 let last = last.clone();
3509 Scope::current().on_cleanup(move || {
3510 if let Some(s) = last.borrow_mut().take() {
3511 s.dispose();
3512 }
3513 });
3514 }
3515 Box::new(move |tok: u64| {
3516 let Some(key) = conn.key_of(tok) else {
3517 return Vec::new();
3518 };
3519 if let Some(s) = last.borrow_mut().take() {
3520 s.dispose();
3521 }
3522 let scope = Scope::child();
3523 let items = scope.enter(|| crate::menus::lower_menu_scoped(f(&key)));
3524 *last.borrow_mut() = Some(scope);
3525 items
3526 }) as day_core::tree_driver::RowMenuFn
3527 }),
3528 moves: self.movable.then(|| {
3529 let can = {
3533 let (conn, expandable_of, guard) =
3534 (conn.clone(), expandable_of.clone(), self.move_guard.clone());
3535 move |tok: u64, parent: Option<u64>, index: Option<usize>| {
3536 let Some(key) = conn.key_of(tok) else {
3537 return MoveVerdict::Deny;
3538 };
3539 let parent_key = match parent {
3540 Some(p) => {
3541 if p == tok || !expandable_of(p) {
3542 return MoveVerdict::Deny;
3543 }
3544 let mut cur = Some(p);
3546 while let Some(c) = cur {
3547 if c == tok {
3548 return MoveVerdict::Deny;
3549 }
3550 cur = conn.parent_of(c).flatten();
3551 }
3552 match conn.key_of(p) {
3553 Some(k) => Some(k),
3554 None => return MoveVerdict::Deny,
3555 }
3556 }
3557 None => None,
3558 };
3559 match &guard {
3560 Some(g) => g(&key, parent_key.as_ref(), index),
3561 None => MoveVerdict::Allow,
3562 }
3563 }
3564 };
3565 let can_commit = can.clone();
3566 TreeMovesDriver {
3567 can_move: Box::new(can),
3568 moved: Box::new(move |t, p, i| {
3571 if can_commit(t, p, i) == MoveVerdict::Deny {
3572 return;
3573 }
3574 enqueue_event(
3575 rnode_to_id(node),
3576 Event::TreeMove {
3577 token: t,
3578 parent: p,
3579 index: i,
3580 },
3581 );
3582 }),
3583 }
3584 }),
3585 };
3586 install_tree(node, driver);
3587
3588 let apply_expansion = {
3592 let (conn, open) = (conn.clone(), open_tokens.clone());
3593 let expanded_sig = self.expanded;
3594 move || {
3595 let desired: HashSet<u64> = match &expanded_sig {
3596 Some(sig) => {
3597 let conn = &conn;
3598 sig.get_untracked()
3599 .iter()
3600 .map(|k| conn.token_of(k))
3601 .collect()
3602 }
3603 None => open.borrow().clone(),
3604 };
3605 let present: HashSet<u64> = conn.tokens_now().into_iter().collect();
3606 let mut ordered: Vec<u64> = desired
3609 .iter()
3610 .filter(|t| present.contains(t))
3611 .copied()
3612 .collect();
3613 let depth_of = |mut t: u64| {
3614 let mut d = 0usize;
3615 while let Some(Some(p)) = conn.parent_of(t) {
3616 d += 1;
3617 t = p;
3618 }
3619 d
3620 };
3621 ordered.sort_by_key(|t| depth_of(*t));
3622 for t in ordered {
3623 tree_set_expanded(node, t, true);
3624 }
3625 open.borrow_mut().clone_from(&desired);
3626 }
3627 };
3628 let apply_selection = {
3629 let (conn, selected) = (conn.clone(), self.selected.clone());
3630 move || {
3631 if let Some(sel) = &selected {
3632 let keys = day_reactive::untrack(|| sel());
3633 let toks: Vec<u64> = keys.iter().map(|k| conn.token_of(k)).collect();
3634 tree_set_selected(node, toks);
3635 }
3636 }
3637 };
3638 {
3639 let conn2 = conn.clone();
3640 let initial = {
3641 let conn = conn.clone();
3642 day_reactive::untrack(move || conn.refresh())
3643 };
3644 tree_reload(node);
3648 apply_expansion();
3649 apply_selection();
3650 let last: RefCell<Vec<(u64, Option<u64>)>> = RefCell::new(initial);
3651 let (apply_expansion, apply_selection) =
3652 (apply_expansion.clone(), apply_selection.clone());
3653 let conn3 = conn.clone();
3654 watch(
3655 move || conn2.refresh(),
3656 move |shape: &Vec<(u64, Option<u64>)>, _| {
3657 let unchanged = !conn3.values_flow_by_reload() && *last.borrow() == *shape;
3658 (*last.borrow_mut()).clone_from(shape);
3659 if unchanged {
3660 return;
3661 }
3662 tree_reload(node);
3663 apply_expansion();
3664 apply_selection();
3665 },
3666 );
3667 }
3668
3669 if let Some(sig) = self.expanded {
3671 let (conn, open) = (conn.clone(), open_tokens.clone());
3672 watch(
3673 move || sig.get(),
3674 move |set: &HashSet<S::Key>, _| {
3675 let desired: HashSet<u64> = set.iter().map(|k| conn.token_of(k)).collect();
3676 let current = open.borrow().clone();
3677 for t in desired.difference(¤t) {
3678 tree_set_expanded(node, *t, true);
3679 }
3680 for t in current.difference(&desired) {
3681 tree_set_expanded(node, *t, false);
3682 }
3683 open.borrow_mut().clone_from(&desired);
3684 },
3685 );
3686 }
3687
3688 if let Some(sel) = self.selected.clone() {
3691 let conn = conn.clone();
3692 watch(
3693 move || sel(),
3694 move |keys: &Vec<S::Key>, _| {
3695 let toks: Vec<u64> = keys.iter().map(|k| conn.token_of(k)).collect();
3696 tree_set_selected(node, toks);
3697 },
3698 );
3699 }
3700
3701 if let Some(sig) = self.reveal {
3703 let (conn, open, expanded_sig) = (conn.clone(), open_tokens.clone(), self.expanded);
3704 watch(
3705 move || sig.get(),
3706 move |key: &Option<S::Key>, _| {
3707 let Some(key) = key else { return };
3708 let tok = conn.token_of(key);
3709 let mut ancestors = Vec::new();
3710 let mut cur = conn.parent_of(tok).flatten();
3711 while let Some(p) = cur {
3712 ancestors.push(p);
3713 cur = conn.parent_of(p).flatten();
3714 }
3715 for p in ancestors.iter().rev() {
3716 tree_set_expanded(node, *p, true);
3717 open.borrow_mut().insert(*p);
3718 if let Some(sig) = &expanded_sig
3719 && let Some(k) = conn.key_of(*p)
3720 {
3721 sig.update(|set| {
3722 set.insert(k.clone());
3723 });
3724 }
3725 }
3726 tree_reveal(node, tok);
3727 },
3728 );
3729 }
3730
3731 node
3732 }
3733}
3734
3735pub fn test_host<P: Piece>(content: impl Fn() -> P + 'static) -> impl Piece {
3753 let content = Rc::new(content);
3754 piece_fn(move |cx| {
3755 let generation = Signal::new(0u64);
3758 day_core::conformance::set_host(Some(Rc::new(move || generation.update(|g| *g += 1))));
3759 Scope::current().on_cleanup(|| day_core::conformance::set_host(None));
3760 each(
3761 items(move || vec![generation.get()], |g: &u64| *g),
3762 move |_| match day_core::conformance::active() {
3763 Some(case) => guarded_page(case),
3764 None => AnyPiece::new(content()),
3765 },
3766 )
3767 .build(cx)
3768 })
3769}
3770
3771pub fn guarded_page(case: day_core::conformance::Case) -> AnyPiece {
3774 AnyPiece::new(piece_fn(move |cx| {
3775 let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
3776 case.build_page().map(|page| page.build(&mut *cx))
3777 }));
3778 match built {
3779 Ok(Some(root)) => root,
3780 Ok(None) => crate::label("").build(cx),
3781 Err(payload) => {
3782 let message = day_core::conformance::panic_message(payload.as_ref());
3783 day_core::conformance::note_page_panic(message.clone());
3784 crate::label(format!("panicked: {message}")).build(cx)
3785 }
3786 }
3787 }))
3788}
3789
3790#[cfg(feature = "conformance")]
3791pub(crate) mod conformance {
3792 use day_core::conformance::{Case, Drive, Fail};
3793 use day_geometry::Insets;
3794 use day_reactive::Signal;
3795 use day_spec::props::RowHeight;
3796 use day_spec::{Cap, Font, kinds};
3797
3798 use crate::*;
3799
3800 fn names_list(names: Signal<Vec<String>>) -> List<Items<String, String>> {
3802 list(
3803 items(move || names.get(), |n: &String| n.clone()),
3804 |row: ItemSlot<String, String>| {
3805 label(move || row.get())
3808 .id_of(move || day_core::id!(conformance_row, row.get()))
3809 .padding(Insets::symmetric(12.0, 6.0))
3810 },
3811 )
3812 .row_height(RowHeight::Uniform(32.0))
3813 }
3814
3815 fn names(list: &[&str]) -> Signal<Vec<String>> {
3816 Signal::new(list.iter().map(std::string::ToString::to_string).collect())
3817 }
3818
3819 #[day_macros::test(day_core)]
3822 fn list_items_show_their_parts() -> Case {
3823 Case::new()
3824 .proves(kinds::LIST_ITEM)
3825 .proves_cap(Cap::ListItem)
3826 .requires(Cap::ListItem)
3827 .page(|| {
3828 let done = Signal::new(false);
3829 let rows = names(&["Milk", "Bread"]);
3830 column((
3831 button("Done")
3832 .action(move || done.update(|d| *d = !*d))
3833 .id(day_core::id!(toggle_done)),
3834 list(
3835 items(move || rows.get(), |n: &String| n.clone()),
3836 move |row: ItemSlot<String, String>| {
3837 list_item(move || row.get())
3838 .subtitle("aisle 4")
3839 .checked(move || done.get())
3840 .id_of(move || day_core::id!(conformance_item, row.get()))
3841 },
3842 )
3843 .height(200.0),
3844 ))
3845 })
3846 .drive(|d: Drive| async move {
3847 d.assert_visible("conformance_item:Milk").await?;
3848 d.tap("toggle_done").await?;
3849 d.assert_visible("conformance_item:Bread").await
3850 })
3851 }
3852
3853 #[day_macros::test(day_core)]
3855 fn list_rows_realize() -> Case {
3856 Case::new()
3857 .proves_duty("attach_list")
3858 .proves_duty("adopt")
3859 .proves(kinds::LIST)
3860 .proves(kinds::LIST_CELL)
3861 .page(|| {
3862 names_list(names(&["Alpha", "Beta", "Gamma"]))
3863 .id(day_core::id!(list))
3864 .height(200.0)
3865 })
3866 .drive(|d: Drive| async move {
3867 d.assert_text("conformance_row:Alpha", "Alpha").await?;
3868 d.assert_text("conformance_row:Gamma", "Gamma").await
3869 })
3870 }
3871
3872 #[day_macros::test(day_core)]
3874 fn list_follows_source() -> Case {
3875 Case::new()
3876 .proves_duty("release")
3877 .proves(kinds::LIST)
3878 .page(|| {
3879 let rows = names(&["Alpha", "Beta"]);
3880 column((
3881 button("Add")
3882 .action(move || rows.update(|v| v.push("Delta".into())))
3883 .id(day_core::id!(add)),
3884 button("Drop")
3885 .action(move || rows.update(|v| v.retain(|n| n != "Alpha")))
3886 .id(day_core::id!(drop)),
3887 names_list(rows).id(day_core::id!(list)).height(200.0),
3888 ))
3889 })
3890 .drive(|d: Drive| async move {
3891 d.assert_missing("conformance_row:Delta").await?;
3892 d.tap("add").await?;
3893 d.assert_text("conformance_row:Delta", "Delta").await?;
3894 d.tap("drop").await?;
3895 d.assert_missing("conformance_row:Alpha").await?;
3896 d.assert_text("conformance_row:Beta", "Beta").await
3897 })
3898 }
3899
3900 #[day_macros::test(day_core)]
3903 fn list_append_then_scroll() -> Case {
3904 Case::new()
3905 .proves(kinds::LIST)
3906 .page(|| {
3907 let rows = names(&[]);
3908 let scroll = Signal::new(None);
3909 column((
3910 button("Append").id(day_core::id!(append)).action(move || {
3911 rows.update(|rows| rows.push(format!("Item {}", rows.len())));
3912 scroll.set(Some(rows.with(|rows| rows.len() - 1)));
3913 }),
3914 names_list(rows)
3915 .scroll_to_row(scroll)
3916 .id(day_core::id!(list))
3917 .height(120.0),
3918 ))
3919 })
3920 .drive(|d: Drive| async move {
3921 for index in 0..8 {
3923 d.tap("append").await?;
3924 d.assert_visible(&format!("conformance_row:Item%20{index}"))
3925 .await?;
3926 }
3927 Ok(())
3928 })
3929 }
3930
3931 const SIZED: [(&str, Font, &str); 5] = [
3933 ("small", Font::Caption2, "Small print"),
3934 ("large", Font::LargeTitle, "Large"),
3935 ("body", Font::Body, "Body text"),
3936 (
3937 "wrap",
3938 Font::Footnote,
3939 "A footnote long enough to wrap onto three lines or more in a narrow list, \
3940 whatever the platform's type scale, so its row is several lines tall",
3941 ),
3942 ("end", Font::Body, "End"),
3943 ];
3944
3945 const GROWN: &str = "Body text that grew long enough to wrap onto several lines, \
3947 the way a row does when its content changes after it was first sized";
3948
3949 fn sized_list(grown: Signal<bool>) -> List<Items<&'static str, &'static str>> {
3952 list(
3953 items(|| SIZED.iter().map(|r| r.0).collect(), |k: &&str| *k),
3954 move |slot: ItemSlot<&'static str, &'static str>| {
3955 let arm = |key: &'static str, font: Font, text: &'static str| {
3958 when(
3959 move || slot.get() == key,
3960 move || {
3961 label(move || {
3962 if key == "body" && grown.get() {
3963 GROWN.to_string()
3964 } else {
3965 text.to_string()
3966 }
3967 })
3968 .font(font)
3969 .id_of(move || day_core::id!(sized, slot.get()))
3970 },
3971 )
3972 };
3973 let [a, b, c, d, e] = SIZED;
3974 column((
3975 arm(a.0, a.1, a.2),
3976 arm(b.0, b.1, b.2),
3977 arm(c.0, c.1, c.2),
3978 arm(d.0, d.1, d.2),
3979 arm(e.0, e.1, e.2),
3980 ))
3981 .spacing(0.0)
3982 },
3983 )
3984 .row_height(RowHeight::Automatic)
3985 .no_separators()
3986 }
3987
3988 struct SizedRow {
3991 key: &'static str,
3992 content: f64,
3993 row: f64,
3994 top: f64,
3995 }
3996
3997 fn sized_rows() -> Result<Vec<SizedRow>, Fail> {
4003 day_core::try_with_tree(|t| {
4004 SIZED
4005 .iter()
4006 .map(|(key, ..)| {
4007 let id = format!("sized:{key}");
4008 let node = t
4009 .find_by_id(&id)
4010 .ok_or_else(|| Fail(format!("no element {id:?}")))?;
4011 let content = t
4012 .node_frame(node)
4013 .ok_or_else(|| Fail(format!("{id:?} has no Day frame")))?;
4014 let mut anchor = node;
4015 while t.node_kind(anchor) != Some(kinds::LIST_CELL) {
4016 anchor = t
4017 .parent_of(anchor)
4018 .ok_or_else(|| Fail(format!("{id:?} is not inside a list cell")))?;
4019 }
4020 let row = t
4021 .node_frame(anchor)
4022 .ok_or_else(|| Fail(format!("{id:?}'s row has no Day frame")))?;
4023 let native = t
4024 .read_native(node)
4025 .and_then(|n| n.frame)
4026 .ok_or_else(|| Fail(format!("{id:?} has no native frame")))?;
4027 Ok(SizedRow {
4028 key,
4029 content: content.size.height,
4030 row: row.size.height,
4031 top: native.origin.y,
4032 })
4033 })
4034 .collect()
4035 })
4036 .unwrap_or_else(|| Err(Fail("the tree is busy".into())))
4037 }
4038
4039 fn rows_fit() -> Result<Vec<(&'static str, f64)>, Fail> {
4047 let rows = sized_rows()?;
4048 let spare = |r: &SizedRow| (r.row - r.content) / 2.0;
4049 let expected = |a: &SizedRow, b: &SizedRow| a.row - spare(a) + spare(b);
4050 let chrome = (rows[1].top - rows[0].top) - expected(&rows[0], &rows[1]);
4051 for pair in rows.windows(2) {
4052 let (this, next) = (&pair[0], &pair[1]);
4053 let pitch = next.top - this.top;
4054 if pitch + 0.5 < this.content {
4055 return Err(Fail(format!(
4056 "row {:?} is {:.1} tall but the next row starts {pitch:.1} below it: the \
4057 native row clips its content",
4058 this.key, this.content
4059 )));
4060 }
4061 let want = expected(this, next) + chrome;
4062 if (pitch - want).abs() > 1.5 {
4063 return Err(Fail(format!(
4064 "row {:?} holds {:.1} of content in a {:.1} row, and the next row starts \
4065 {pitch:.1} below it where {want:.1} was expected (the first row's chrome \
4066 allowance is {chrome:.1}): the native row did not take its content's height",
4067 this.key, this.content, this.row
4068 )));
4069 }
4070 }
4071 Ok(rows.into_iter().map(|r| (r.key, r.content)).collect())
4072 }
4073
4074 fn height_of(rows: &[(&str, f64)], key: &str) -> f64 {
4075 rows.iter().find(|r| r.0 == key).map_or(0.0, |r| r.1)
4076 }
4077
4078 #[day_macros::test(day_core)]
4081 fn list_rows_size_to_content() -> Case {
4082 Case::new()
4083 .proves(kinds::LIST)
4084 .proves(kinds::LIST_CELL)
4085 .page(|| {
4086 let grown = Signal::new(false);
4087 column((
4088 button("Grow")
4089 .action(move || grown.update(|g| *g = !*g))
4090 .id(day_core::id!(grow)),
4091 sized_list(grown)
4092 .id(day_core::id!(list))
4093 .width(240.0)
4094 .height(480.0),
4095 ))
4096 })
4097 .drive(|d: Drive| async move {
4098 d.assert_visible("sized:end").await?;
4099 d.shot("sized-rows").await?;
4100 let rows = rows_fit()?;
4101 let (small, large) = (height_of(&rows, "small"), height_of(&rows, "large"));
4104 d.check(
4105 large > small * 1.5,
4106 "a large-title row is taller than a caption row",
4107 )?;
4108 let body = height_of(&rows, "body");
4109 d.check(
4110 height_of(&rows, "wrap") > body * 1.5,
4111 "the footnote wrapped",
4112 )?;
4113 d.tap("grow").await?;
4115 d.wait_idle().await?;
4116 d.pause(0.3).await?;
4117 d.shot("sized-rows-grown").await?;
4118 let grew = rows_fit()?;
4119 d.check(height_of(&grew, "body") > body * 1.5, "the body row grew")?;
4120 d.tap("grow").await?;
4121 d.wait_idle().await?;
4122 d.pause(0.3).await?;
4123 let shrank = rows_fit()?;
4124 d.check(
4125 (height_of(&shrank, "body") - body).abs() < 1.0,
4126 "the body row shrank back",
4127 )
4128 })
4129 }
4130
4131 #[day_macros::test(day_core)]
4133 fn list_select_and_activate() -> Case {
4134 Case::new()
4135 .proves(kinds::LIST)
4136 .page(|| {
4137 let picked = Signal::new(String::new());
4138 let opened = Signal::new(String::new());
4139 column((
4140 label(move || format!("picked {}", picked.get())).id(day_core::id!(picked)),
4141 label(move || format!("opened {}", opened.get())).id(day_core::id!(opened)),
4142 names_list(names(&["Alpha", "Beta", "Gamma"]))
4143 .on_select(move |k| picked.set(k))
4144 .on_activate(move |k| opened.set(k))
4145 .id(day_core::id!(list))
4146 .height(200.0),
4147 ))
4148 })
4149 .drive(|d: Drive| async move {
4150 d.select("list", 1).await?;
4151 d.assert_text("picked", "picked Beta").await?;
4152 d.activate("list", 2).await?;
4153 d.assert_text("opened", "opened Gamma").await
4154 })
4155 }
4156
4157 #[day_macros::test(day_core)]
4159 fn list_reorder_moves_row() -> Case {
4160 Case::new()
4161 .proves(kinds::LIST)
4162 .page(|| {
4163 let rows = names(&["Alpha", "Beta", "Gamma"]);
4164 column((
4165 label(move || rows.get().join(",")).id(day_core::id!(order)),
4166 names_list(rows)
4167 .reorderable(Reorder::new(move |from, to| {
4168 rows.update(|v| {
4169 let item = v.remove(from);
4170 v.insert(to.min(v.len()), item);
4171 });
4172 }))
4173 .id(day_core::id!(list))
4174 .height(200.0),
4175 ))
4176 })
4177 .drive(|d: Drive| async move {
4178 d.reorder("list", 0, 2).await?;
4179 d.assert_text("order", "Beta,Gamma,Alpha").await?;
4180 d.assert_text("conformance_row:Alpha", "Alpha").await
4181 })
4182 }
4183
4184 #[day_macros::test(day_core)]
4186 fn list_delete_row() -> Case {
4187 Case::new()
4188 .proves(kinds::LIST)
4189 .page(|| {
4190 let rows = names(&["Alpha", "Beta", "Gamma"]);
4191 column((
4192 label(move || rows.get().join(",")).id(day_core::id!(order)),
4193 names_list(rows)
4194 .deletable(Delete::new(move |at| {
4195 rows.update(|v| {
4196 v.remove(at);
4197 });
4198 }))
4199 .id(day_core::id!(list))
4200 .height(200.0),
4201 ))
4202 })
4203 .drive(|d: Drive| async move {
4204 d.delete_row("list", 1).await?;
4205 d.assert_text("order", "Alpha,Gamma").await?;
4206 d.assert_missing("conformance_row:Beta").await
4207 })
4208 }
4209
4210 #[day_macros::test(day_core)]
4212 fn list_swipe_action() -> Case {
4213 Case::new()
4214 .proves(kinds::LIST)
4215 .page(|| {
4216 let rows = names(&["Alpha", "Beta", "Gamma"]);
4217 let flagged = Signal::new(String::new());
4218 column((
4219 label(move || format!("flagged {}", flagged.get())).id(day_core::id!(flagged)),
4220 names_list(rows)
4221 .swipe_trailing(move |at| {
4222 let name = rows.get_untracked()[at].clone();
4223 vec![swipe_action("Flag").action(move || flagged.set(name.clone()))]
4224 })
4225 .id(day_core::id!(list))
4226 .height(200.0),
4227 ))
4228 })
4229 .drive(|d: Drive| async move {
4230 d.swipe_row("list", 2, false, 0).await?;
4231 d.assert_text("flagged", "flagged Gamma").await
4232 })
4233 }
4234
4235 #[day_macros::test(day_core)]
4237 fn list_scroll_to_row() -> Case {
4238 Case::new()
4239 .proves(kinds::LIST)
4240 .page(|| {
4241 let rows: Signal<Vec<String>> =
4242 Signal::new((0..300).map(|n| format!("Row {n}")).collect());
4243 let jump: Signal<Option<usize>> = Signal::new(None);
4244 column((
4245 button("Jump")
4246 .action(move || jump.set(Some(250)))
4247 .id(day_core::id!(jump)),
4248 names_list(rows)
4249 .scroll_to_row(jump)
4250 .id(day_core::id!(list))
4251 .height(200.0),
4252 ))
4253 })
4254 .drive(|d: Drive| async move {
4255 d.assert_missing("conformance_row:Row%20250").await?;
4256 d.tap("jump").await?;
4257 d.assert_text("conformance_row:Row%20250", "Row 250").await
4258 })
4259 }
4260
4261 struct RowAlive(std::rc::Rc<std::cell::Cell<usize>>);
4266
4267 impl RowAlive {
4268 fn new(live: &std::rc::Rc<std::cell::Cell<usize>>) -> Self {
4269 live.set(live.get() + 1);
4270 RowAlive(live.clone())
4271 }
4272 }
4273
4274 impl Drop for RowAlive {
4275 fn drop(&mut self) {
4276 self.0.set(self.0.get().saturating_sub(1));
4277 }
4278 }
4279
4280 const ROWS_ALIVE_BOUND: usize = 256;
4287
4288 #[day_macros::test(day_core)]
4290 fn list_recycles_distant_rows() -> Case {
4291 let built = std::rc::Rc::new(std::cell::Cell::new(0usize));
4292 let live = std::rc::Rc::new(std::cell::Cell::new(0usize));
4293 let (count, alive) = (built.clone(), live.clone());
4294 Case::new()
4295 .proves(kinds::LIST)
4296 .proves_cap(Cap::ListRecycling)
4297 .timeout(180.0)
4300 .requires_support("native list recycling", || {
4301 if day_core::capability(Cap::ListRecycling) == day_spec::Support::Native {
4302 day_spec::Support::Native
4303 } else {
4304 day_spec::Support::Unsupported
4305 }
4306 })
4307 .page(move || {
4308 count.set(0);
4309 alive.set(0);
4310 let (count, alive) = (count.clone(), alive.clone());
4311 let rows = Signal::new((0..4000).collect::<Vec<usize>>());
4312 let jump = Signal::new(None);
4313 let next = Signal::new(40usize);
4314 let pressed = Signal::new(String::new());
4315 column((
4316 button("Far").id(day_core::id!(far)).action(move || {
4317 jump.set(Some(next.get_untracked()));
4318 next.update(|n| *n += 40);
4319 }),
4320 button("Back")
4321 .id(day_core::id!(back))
4322 .action(move || jump.set(Some(0))),
4323 label(move || pressed.get()).id(day_core::id!(pressed)),
4324 list(items(move || rows.get(), |n: &usize| *n), move |slot| {
4325 count.set(count.get() + 1);
4326 let guard = RowAlive::new(&alive);
4327 button(move || {
4328 let _ = &guard;
4329 format!("Row {}", slot.get())
4330 })
4331 .id_of(move || day_core::id!(conformance_row, slot.key()))
4332 .action(move || pressed.set(format!("Pressed {}", slot.get())))
4333 })
4334 .row_height(RowHeight::Uniform(32.0))
4335 .scroll_to_row(jump)
4336 .height(160.0),
4337 ))
4338 })
4339 .drive(move |d: Drive| {
4340 let (built, live) = (built.clone(), live.clone());
4341 async move {
4342 d.assert_text("conformance_row:0", "Row 0").await?;
4343 for row in (40..=3600).step_by(40) {
4351 d.tap("far").await?;
4352 d.assert_text(&format!("conformance_row:{row}"), &format!("Row {row}"))
4353 .await?;
4354 d.assert_missing("conformance_row:1").await?;
4355 d.tap(&format!("conformance_row:{row}")).await?;
4356 d.assert_text("pressed", &format!("Pressed {row}")).await?;
4357 d.tap("back").await?;
4358 d.assert_text("conformance_row:0", "Row 0").await?;
4359 d.tap("conformance_row:0").await?;
4360 d.assert_text("pressed", "Pressed 0").await?;
4361 }
4362 d.wait_idle().await?;
4365 d.pause(0.3).await?;
4366 d.check(
4367 live.get() <= ROWS_ALIVE_BOUND,
4368 &format!(
4369 "{} rows alive after 180 jumps of a five-row viewport ({} built): \
4370 discarded cells keep their rows",
4371 live.get(),
4372 built.get()
4373 ),
4374 )
4375 }
4376 })
4377 }
4378
4379 #[day_macros::test(day_core)]
4382 fn list_releases_discarded_rows() -> Case {
4383 const TOTAL: usize = 3000;
4384 const STRIDE: usize = 1237;
4385 let built = std::rc::Rc::new(std::cell::Cell::new(0usize));
4386 let live = std::rc::Rc::new(std::cell::Cell::new(0usize));
4387 let (count, alive) = (built.clone(), live.clone());
4388 Case::new()
4389 .proves(kinds::LIST)
4390 .proves_cap(Cap::ListRecycling)
4391 .timeout(90.0)
4392 .requires_support("native list recycling", || {
4393 if day_core::capability(Cap::ListRecycling) == day_spec::Support::Native {
4394 day_spec::Support::Native
4395 } else {
4396 day_spec::Support::Unsupported
4397 }
4398 })
4399 .page(move || {
4400 count.set(0);
4401 alive.set(0);
4402 let (count, alive) = (count.clone(), alive.clone());
4403 let rows = Signal::new((0..TOTAL).collect::<Vec<usize>>());
4404 let jump = Signal::new(None);
4405 let at = Signal::new(0usize);
4406 let pressed = Signal::new(String::new());
4407 column((
4408 button("Far").id(day_core::id!(far)).action(move || {
4411 let next = (at.get_untracked() + STRIDE) % TOTAL;
4412 at.set(next);
4413 jump.set(Some(next));
4414 }),
4415 button("Shrink")
4418 .id(day_core::id!(shrink))
4419 .action(move || rows.set((0..5).collect())),
4420 button("Regrow")
4421 .id(day_core::id!(regrow))
4422 .action(move || rows.set((0..TOTAL).collect())),
4423 button("Rotate")
4425 .id(day_core::id!(rotate))
4426 .action(move || rows.update(|r| r.rotate_left(7))),
4427 label(move || pressed.get()).id(day_core::id!(pressed)),
4428 list(items(move || rows.get(), |n: &usize| *n), move |slot| {
4429 count.set(count.get() + 1);
4430 let guard = RowAlive::new(&alive);
4431 button(move || {
4432 let _ = &guard;
4433 format!("Row {}", slot.get())
4434 })
4435 .id_of(move || day_core::id!(conformance_row, slot.key()))
4436 .action(move || pressed.set(format!("Pressed {}", slot.get())))
4437 })
4438 .row_height(RowHeight::Uniform(32.0))
4439 .scroll_to_row(jump)
4440 .height(160.0),
4441 ))
4442 })
4443 .drive(move |d: Drive| {
4444 let (built, live) = (built.clone(), live.clone());
4445 async move {
4446 d.assert_text("conformance_row:0", "Row 0").await?;
4447 let (mut at, mut rotation) = (0usize, 0usize);
4448 let key_at = |i: usize, rotation: usize| (i + rotation) % TOTAL;
4450 for _ in 0..10 {
4451 at = (at + STRIDE) % TOTAL;
4453 d.tap("far").await?;
4454 let key = key_at(at, rotation);
4455 d.assert_text(&format!("conformance_row:{key}"), &format!("Row {key}"))
4456 .await?;
4457 d.tap(&format!("conformance_row:{key}")).await?;
4458 d.assert_text("pressed", &format!("Pressed {key}")).await?;
4459 d.tap("far").await?;
4461 d.tap("far").await?;
4462 at = (at + 2 * STRIDE) % TOTAL;
4463 let key = key_at(at, rotation);
4464 d.assert_text(&format!("conformance_row:{key}"), &format!("Row {key}"))
4465 .await?;
4466 d.tap("shrink").await?;
4469 d.assert_text("conformance_row:3", "Row 3").await?;
4470 if key >= 5 {
4471 d.assert_missing(&format!("conformance_row:{key}")).await?;
4472 }
4473 d.tap("regrow").await?;
4474 d.tap("rotate").await?;
4477 rotation = 7;
4478 at = (at + STRIDE) % TOTAL;
4479 d.tap("far").await?;
4480 let key = key_at(at, rotation);
4481 d.assert_text(&format!("conformance_row:{key}"), &format!("Row {key}"))
4482 .await?;
4483 }
4484 d.wait_idle().await?;
4485 d.pause(0.3).await?;
4486 d.check(
4487 live.get() <= ROWS_ALIVE_BOUND,
4488 &format!(
4489 "{} rows alive after the churn ({} built): discarded cells keep \
4490 their rows",
4491 live.get(),
4492 built.get()
4493 ),
4494 )
4495 }
4496 })
4497 }
4498
4499 #[day_macros::test(day_core)]
4501 fn list_shrink_and_regrow() -> Case {
4502 Case::new()
4503 .proves(kinds::LIST)
4504 .page(|| {
4505 let rows = Signal::new((0..300).map(|n| format!("Row {n}")).collect());
4506 let jump = Signal::new(None);
4507 column((
4508 button("Jump")
4509 .id(day_core::id!(jump))
4510 .action(move || jump.set(Some(250))),
4511 button("Clear")
4512 .id(day_core::id!(clear))
4513 .action(move || rows.set(Vec::new())),
4514 button("Restore")
4515 .id(day_core::id!(restore))
4516 .action(move || {
4517 rows.set(vec!["New first".into(), "New last".into()]);
4518 jump.set(Some(1));
4519 }),
4520 names_list(rows).scroll_to_row(jump).height(160.0),
4521 ))
4522 })
4523 .drive(|d: Drive| async move {
4524 d.tap("jump").await?;
4525 d.assert_text("conformance_row:Row%20250", "Row 250")
4526 .await?;
4527 d.tap("clear").await?;
4528 d.assert_missing("conformance_row:Row%20250").await?;
4529 d.tap("restore").await?;
4530 d.assert_text("conformance_row:New%20first", "New first")
4531 .await?;
4532 d.assert_text("conformance_row:New%20last", "New last")
4533 .await
4534 })
4535 }
4536
4537 type Node = (String, Option<String>);
4538
4539 fn names_tree(rows: Signal<Vec<Node>>) -> TreePiece<Branches<Node, String>> {
4542 tree(
4543 branches(
4544 move || rows.get(),
4545 |n: &Node| n.0.clone(),
4546 |n: &Node| n.1.clone(),
4547 ),
4548 |row: ItemSlot<Node, String>| {
4549 label(move || row.get().0)
4550 .id_of(move || day_core::id!(conformance_row, row.get().0))
4551 .padding(Insets::symmetric(8.0, 4.0))
4552 },
4553 )
4554 .row_height(RowHeight::Uniform(28.0))
4555 .row_id(|k: &String| day_core::id!(tree_row, k))
4556 }
4557
4558 fn fruit() -> Signal<Vec<Node>> {
4559 let n = |name: &str, parent: Option<&str>| (name.to_string(), parent.map(str::to_owned));
4560 Signal::new(vec![
4561 n("Fruit", None),
4562 n("Apple", Some("Fruit")),
4563 n("Pear", Some("Fruit")),
4564 n("Nuts", None),
4565 ])
4566 }
4567
4568 #[day_macros::test(day_core)]
4570 fn tree_rows_disclose() -> Case {
4571 Case::new()
4572 .proves_duty("attach_tree")
4573 .proves_cap(Cap::Tree)
4574 .proves(kinds::TREE)
4575 .requires(Cap::Tree)
4576 .page(|| names_tree(fruit()).id(day_core::id!(tree)).height(240.0))
4577 .drive(|d: Drive| async move {
4578 d.assert_text("conformance_row:Fruit", "Fruit").await?;
4579 d.assert_text("conformance_row:Nuts", "Nuts").await?;
4580 d.assert_missing("conformance_row:Apple").await?;
4581 d.expand("tree", "tree_row:Fruit", true).await?;
4582 d.assert_text("conformance_row:Apple", "Apple").await?;
4583 d.expand("tree", "tree_row:Fruit", false).await?;
4584 d.assert_missing("conformance_row:Apple").await
4585 })
4586 }
4587
4588 #[day_macros::test(day_core)]
4590 fn tree_expanded_signal() -> Case {
4591 Case::new()
4592 .proves(kinds::TREE)
4593 .requires(Cap::Tree)
4594 .page(|| {
4595 let open = Signal::new(std::collections::HashSet::from(["Fruit".to_string()]));
4596 names_tree(fruit())
4597 .expanded(open)
4598 .id(day_core::id!(tree))
4599 .height(240.0)
4600 })
4601 .drive(|d: Drive| async move { d.assert_text("conformance_row:Pear", "Pear").await })
4602 }
4603
4604 #[day_macros::test(day_core)]
4607 fn tree_section_expansion_contract() -> Case {
4608 Case::new()
4609 .proves_duty("attach_tree")
4610 .proves_cap(Cap::TreeSections)
4611 .proves(kinds::TREE)
4612 .requires(Cap::TreeSections)
4613 .page(|| {
4614 let rows = fruit();
4615 let open = Signal::new(std::collections::HashSet::from(["Fruit".to_owned()]));
4616 let changes = Signal::new(0usize);
4617 column((
4618 label(move || {
4619 format!("{}:{}", open.with(|s| s.contains("Fruit")), changes.get())
4620 })
4621 .id(day_core::id!(state)),
4622 button("restore")
4623 .id(day_core::id!(restore))
4624 .action(move || {
4625 open.set(std::collections::HashSet::from(["Fruit".to_owned()]));
4626 }),
4627 button("filter")
4628 .id(day_core::id!(filter))
4629 .action(move || rows.update(|r| r.retain(|n| n.0 != "Apple"))),
4630 names_tree(rows)
4631 .section_headers()
4632 .expanded(open)
4633 .on_expansion(move |_, _| changes.update(|n| *n += 1))
4634 .id(day_core::id!(tree))
4635 .height(240.0),
4636 ))
4637 })
4638 .drive(|d: Drive| async move {
4639 d.assert_text("state", "true:0").await?;
4640 d.assert_text("conformance_row:Apple", "Apple").await?;
4641 d.expand("tree", "tree_row:Fruit", false).await?;
4642 d.assert_text("state", "false:1").await?;
4643 d.assert_missing("conformance_row:Apple").await?;
4644 d.expand("tree", "tree_row:Fruit", false).await?;
4645 d.assert_text("state", "false:1").await?;
4646 d.tap("filter").await?;
4647 d.assert_missing("conformance_row:Pear").await?;
4648 d.tap("restore").await?;
4649 d.assert_text("conformance_row:Pear", "Pear").await?;
4650 d.assert_text("state", "true:1").await
4651 })
4652 }
4653
4654 #[day_macros::test(day_core)]
4656 fn tree_move_reparents() -> Case {
4657 Case::new()
4658 .proves_cap(Cap::TreeMove)
4659 .proves(kinds::TREE)
4660 .requires(Cap::Tree)
4661 .page(|| {
4662 let rows = fruit();
4663 let open = Signal::new(std::collections::HashSet::from([
4664 "Fruit".to_string(),
4665 "Nuts".to_string(),
4666 ]));
4667 column((
4668 label(move || {
4669 rows.get()
4670 .iter()
4671 .map(|(n, p)| format!("{n}<{}", p.clone().unwrap_or_default()))
4672 .collect::<Vec<_>>()
4673 .join(",")
4674 })
4675 .id(day_core::id!(shape)),
4676 names_tree(rows)
4678 .expanded(open)
4679 .expandable(|k: &String| k == "Fruit" || k == "Nuts")
4680 .movable(Move::new(move |key, parent, _at| {
4681 rows.update(|v| {
4682 if let Some(n) = v.iter_mut().find(|n| n.0 == key) {
4683 n.1 = parent;
4684 }
4685 });
4686 }))
4687 .id(day_core::id!(tree))
4688 .height(240.0),
4689 ))
4690 })
4691 .drive(|d: Drive| async move {
4692 d.tree_move("tree", "tree_row:Pear", Some("tree_row:Nuts"), None)
4693 .await?;
4694 d.assert_text("shape", "Fruit<,Apple<Fruit,Pear<Nuts,Nuts<")
4695 .await?;
4696 d.assert_text("conformance_row:Pear", "Pear").await
4697 })
4698 }
4699}