1use std::any::Any;
10use std::cell::{Cell, RefCell};
11use std::collections::{HashMap, VecDeque};
12use std::rc::Rc;
13
14use day_reactive::Scope;
15use day_spec::*;
16use slotmap::{Key, KeyData, SlotMap, new_key_type};
17
18use crate::layout::{Alignment, CrossAlign, Layout, PassThrough};
19
20new_key_type! {
21 pub struct RNode;
23}
24
25pub fn rnode_to_id(n: RNode) -> NodeId {
26 NodeId(n.data().as_ffi())
27}
28pub fn id_to_rnode(id: NodeId) -> RNode {
29 RNode::from(KeyData::from_ffi(id.0))
30}
31
32#[derive(Clone, Copy, Debug, Default, PartialEq)]
34pub struct Flex {
35 pub grow_w: bool,
37 pub grow_h: bool,
38 pub yields_h: bool,
42 pub is_spacer: bool,
44 pub is_group: bool,
46 pub grid: GridFacts,
48 pub whole_row: bool,
52}
53
54#[derive(Clone, Copy, Debug, Default, PartialEq)]
58pub struct GridFacts {
59 pub is_row: bool,
61 pub row_valign: Option<CrossAlign>,
63 pub col_span: u16,
65 pub align: Option<Alignment>,
67}
68
69#[derive(Clone, Debug, Default)]
71pub struct NodeProbe {
72 pub text: String,
73 pub font: Option<day_spec::FontSpec>,
75 pub value: f64,
76 pub flag: bool,
77 pub selected: i64,
78 pub options: Vec<String>,
81 pub enabled: bool,
82 pub focused: bool,
84}
85
86pub struct NodeData<H> {
87 pub kind: PieceKind,
88 pub handle: Option<H>,
89 pub parent: RNode,
90 pub children: Vec<RNode>,
91 pub layout: Rc<dyn Layout>,
92 pub flex: Flex,
93 pub scope: Scope,
94 pub id: Option<String>,
95 pub parked_id: Option<String>,
101 pub a11y: day_spec::A11yProps,
105 pub cache: Vec<((u64, u64), Size)>,
107 pub baseline_cache: Option<((u64, u64), Option<f64>)>,
111 pub probe: NodeProbe,
112 pub needs_measure: bool,
113 pub needs_layout: bool,
116 pub last_native_frame: Option<Rect>,
117 pub is_boundary: bool,
118 pub scroll_content: Option<Size>,
121 pub implicit_anim: Option<day_spec::AnimSpec>,
125 pub tweaked: bool,
129}
130
131pub type EventHandler = Rc<dyn Fn(&Event)>;
133
134pub type EventObserver = dyn Fn(NodeId, &Event);
137
138#[derive(Clone, Copy, PartialEq, Eq, Debug)]
141pub enum WindowRootReply {
142 Open(RNode),
144 Pending(RNode),
147 Unsupported,
149}
150
151struct WindowEntry {
159 root: RNode,
160 size: Size,
161}
162
163#[derive(Clone)]
165enum ContextMenuModel {
166 Items(Vec<day_spec::MenuItem>),
167 Provider(day_spec::ContextMenuFn),
168}
169
170pub struct Tree<B: Toolkit> {
171 mounted_id_families: std::collections::BTreeSet<String>,
172 pub toolkit: B,
173 nodes: SlotMap<RNode, NodeData<B::Handle>>,
174 windows: Vec<WindowEntry>,
175 layout_dirty: bool,
176 handlers: HashMap<RNode, Vec<EventHandler>>,
177 gestures: HashMap<RNode, Vec<day_spec::GestureKind>>,
180 element_outer: HashMap<RNode, RNode>,
183 element_targets: HashMap<RNode, RNode>,
185 release_queue: Vec<(day_spec::PieceKind, B::Handle)>,
188 lists: HashMap<RNode, crate::list::ListState>,
190 trees: HashMap<RNode, crate::tree_driver::TreeState>,
191 context_menus: HashMap<RNode, ContextMenuModel>,
195 implicit_anim_count: usize,
198}
199
200impl<B: Toolkit> Tree<B> {
201 fn clear_subtree_ids(&mut self, anchor: RNode) {
206 let mut stack = vec![anchor];
207 while let Some(n) = stack.pop() {
208 if let Some(d) = self.nodes.get_mut(n) {
209 if let Some(id) = d.id.take() {
210 d.parked_id = Some(id);
211 }
212 stack.extend(d.children.iter().copied());
213 }
214 }
215 }
216
217 fn restore_subtree_ids(&mut self, anchor: RNode) {
221 let mut stack = vec![anchor];
222 while let Some(n) = stack.pop() {
223 if let Some(d) = self.nodes.get_mut(n) {
224 if let Some(id) = d.parked_id.take()
225 && d.id.is_none()
226 {
227 d.id = Some(id);
228 }
229 stack.extend(d.children.iter().copied());
230 }
231 }
232 }
233
234 pub fn new(toolkit: B, root_handle: B::Handle, window_size: Size) -> Self {
235 let mut nodes = SlotMap::with_key();
236 let root = nodes.insert(NodeData {
237 kind: kinds::CONTAINER,
238 handle: Some(root_handle),
239 parent: RNode::null(),
240 children: Vec::new(),
241 layout: Rc::new(PassThrough),
242 flex: Flex::default(),
243 scope: Scope::root(),
244 id: None,
245 parked_id: None,
246 a11y: Default::default(),
247 cache: Vec::new(),
248 baseline_cache: None,
249 probe: NodeProbe::default(),
250 needs_measure: true,
251 needs_layout: true,
252 last_native_frame: None,
253 scroll_content: None,
254 implicit_anim: None,
255 tweaked: false,
256 is_boundary: true,
257 });
258 Tree {
259 mounted_id_families: Default::default(),
260 toolkit,
261 nodes,
262 windows: vec![WindowEntry {
263 root,
264 size: window_size,
265 }],
266 layout_dirty: true,
267 handlers: HashMap::new(),
268 gestures: HashMap::new(),
269 element_outer: HashMap::new(),
270 element_targets: HashMap::new(),
271 release_queue: Vec::new(),
272 lists: HashMap::new(),
273 trees: HashMap::new(),
274 context_menus: HashMap::new(),
275 implicit_anim_count: 0,
276 }
277 }
278
279 pub(crate) fn create_cell_anchor(
282 &mut self,
283 handle: B::Handle,
284 scope: Scope,
285 layout: Rc<dyn Layout>,
286 ) -> RNode {
287 self.nodes.insert(NodeData {
288 kind: kinds::LIST_CELL,
289 handle: Some(handle),
290 parent: RNode::null(),
291 children: Vec::new(),
292 layout,
293 flex: Flex::default(),
294 scope,
295 id: None,
296 parked_id: None,
297 a11y: Default::default(),
298 cache: Vec::new(),
299 baseline_cache: None,
300 probe: NodeProbe::default(),
301 needs_measure: true,
302 needs_layout: true,
303 last_native_frame: None,
304 scroll_content: None,
305 implicit_anim: None,
306 tweaked: false,
307 is_boundary: true,
308 })
309 }
310
311 pub fn root(&self) -> RNode {
312 self.windows[0].root
313 }
314
315 pub(crate) fn node(&self, n: RNode) -> Option<&NodeData<B::Handle>> {
316 self.nodes.get(n)
317 }
318 pub(crate) fn node_mut(&mut self, n: RNode) -> Option<&mut NodeData<B::Handle>> {
319 self.nodes.get_mut(n)
320 }
321
322 pub(crate) fn resolve_anim(&self, node: RNode) -> Option<day_spec::AnimSpec> {
327 if crate::reduce_motion_now() {
330 return None;
331 }
332 if let Some(a) = crate::anim::current_anim() {
333 return Some(a);
334 }
335 if self.implicit_anim_count == 0 {
336 return None;
337 }
338 let mut cur = node;
339 loop {
340 let n = self.nodes.get(cur)?;
341 if n.implicit_anim.is_some() {
342 return n.implicit_anim;
343 }
344 if n.parent == cur {
345 return None;
346 }
347 cur = n.parent;
348 }
349 }
350
351 fn native_ancestor(&self, mut n: RNode) -> RNode {
353 loop {
354 let Some(node) = self.nodes.get(n) else {
355 return self.windows[0].root;
358 };
359 if node.handle.is_some() {
360 return n;
361 }
362 n = node.parent;
363 }
364 }
365
366 fn native_descendants(&self, container: RNode, out: &mut Vec<RNode>) {
368 let Some(node) = self.nodes.get(container) else {
369 return;
370 };
371 for &c in &node.children {
372 match self.nodes.get(c) {
373 Some(cd) if cd.handle.is_some() => out.push(c),
374 Some(_) => self.native_descendants(c, out),
375 None => {}
376 }
377 }
378 }
379
380 fn native_index_for(&self, ancestor: RNode, target: RNode) -> usize {
383 fn walk<B: Toolkit>(tree: &Tree<B>, n: RNode, target: RNode, count: &mut usize) -> bool {
384 if n == target {
385 return true;
386 }
387 let Some(node) = tree.nodes.get(n) else {
388 return false;
389 };
390 if node.handle.is_some() && n != target {
391 *count += 1;
393 return false;
394 }
395 for &c in &node.children {
396 if walk(tree, c, target, count) {
397 return true;
398 }
399 }
400 false
401 }
402 let mut count = 0;
403 let Some(anc) = self.nodes.get(ancestor) else {
404 return 0;
405 };
406 for &c in &anc.children {
407 if c == target || self.subtree_contains(c, target) {
408 let mut cnt = count;
410 walk(self, c, target, &mut cnt);
411 return cnt;
412 }
413 let mut roots = Vec::new();
414 match self.nodes.get(c) {
415 Some(cd) if cd.handle.is_some() => count += 1,
416 Some(_) => {
417 self.native_descendants(c, &mut roots);
418 count += roots.len();
419 }
420 None => {}
421 }
422 }
423 count
424 }
425
426 fn subtree_contains(&self, root: RNode, target: RNode) -> bool {
427 if root == target {
428 return true;
429 }
430 let Some(node) = self.nodes.get(root) else {
431 return false;
432 };
433 node.children
434 .iter()
435 .any(|&c| self.subtree_contains(c, target))
436 }
437
438 fn attach_impl(&mut self, parent: RNode, child: RNode, index: usize) {
440 {
441 let p = self
442 .nodes
443 .get_mut(parent)
444 .expect("attach to missing parent");
445 let idx = index.min(p.children.len());
446 p.children.insert(idx, child);
447 }
448 self.nodes
449 .get_mut(child)
450 .expect("attach missing child")
451 .parent = parent;
452 let ancestor = self.native_ancestor(parent);
455 let anc_handle = self.nodes[ancestor]
456 .handle
457 .clone()
458 .expect("native ancestor");
459 let mut roots = Vec::new();
460 match self.nodes.get(child) {
461 Some(cd) if cd.handle.is_some() => roots.push(child),
462 Some(_) => self.native_descendants(child, &mut roots),
463 None => {}
464 }
465 for r in roots {
466 let idx = self.native_index_for(ancestor, r);
467 let h = self.nodes[r].handle.clone().unwrap();
468 self.toolkit.insert(&anc_handle, &h, idx);
469 }
470 self.mark_needs_measure_impl(parent);
471 }
472
473 fn remove_subtree_impl(&mut self, node: RNode) {
474 let parent = self
477 .nodes
478 .get(node)
479 .map(|n| n.parent)
480 .unwrap_or(RNode::null());
481 if let Some(p) = self.nodes.get_mut(parent) {
482 p.children.retain(|&c| c != node);
483 }
484 let anc_handle = if parent.is_null() {
488 None
489 } else {
490 let ancestor = self.native_ancestor(parent);
491 self.nodes.get(ancestor).and_then(|n| n.handle.clone())
492 };
493 let mut roots = Vec::new();
494 match self.nodes.get(node) {
495 Some(nd) if nd.handle.is_some() => roots.push(node),
496 Some(_) => self.native_descendants(node, &mut roots),
497 None => {}
498 }
499 if let Some(anc_handle) = anc_handle {
500 for r in &roots {
501 let h = self.nodes[*r].handle.clone().unwrap();
502 self.toolkit.remove(&anc_handle, &h);
503 }
504 }
505 self.collect_and_release(node);
506 if parent.is_null() {
507 self.layout_dirty = true;
508 } else {
509 self.mark_needs_measure_impl(parent);
510 }
511 }
512
513 fn collect_and_release(&mut self, start: RNode) {
518 let mut stack = vec![start];
519 while let Some(n) = stack.pop() {
520 self.context_menus.remove(&n);
525 if let Some(list) = self.lists.remove(&n) {
526 for (_, cell) in list.cells {
527 cell.scope.dispose();
528 stack.push(cell.anchor);
533 }
534 }
535 if let Some(tree) = self.trees.remove(&n) {
537 for (_, cell) in tree.cells {
538 cell.scope.dispose();
539 stack.push(cell.anchor);
540 }
541 }
542 let Some(data) = self.nodes.remove(n) else {
543 continue;
544 };
545 self.handlers.remove(&n);
546 self.gestures.remove(&n);
547 self.element_outer.remove(&n);
548 self.element_targets.remove(&n);
549 day_spec::keys::forget(rnode_to_id(n));
550 if data.implicit_anim.is_some() {
551 self.implicit_anim_count = self.implicit_anim_count.saturating_sub(1);
552 }
553 if let Some(h) = data.handle {
554 if data.kind != kinds::LIST_CELL {
560 self.release_queue.push((data.kind, h));
561 }
562 }
563 stack.extend(data.children);
564 }
565 }
566
567 fn mark_needs_measure_impl(&mut self, node: RNode) {
568 let mut cur = node;
569 let mut measure = true;
570 while let Some(n) = self.nodes.get_mut(cur) {
571 n.needs_layout = true;
572 if measure {
573 n.needs_measure = true;
574 n.cache.clear();
575 }
576 if n.is_boundary {
577 measure = false;
578 }
579 if n.parent.is_null() {
580 break;
581 }
582 cur = n.parent;
583 }
584 self.layout_dirty = true;
585 }
586
587 fn invalidate_subtree(&mut self, node: RNode) {
593 let mut stack = vec![node];
594 while let Some(cur) = stack.pop() {
595 if let Some(n) = self.nodes.get_mut(cur) {
596 n.needs_measure = true;
597 n.cache.clear();
598 stack.extend(n.children.iter().copied());
599 }
600 }
601 }
602
603 fn layout_list_cell_at(&mut self, node: RNode, key: usize, width: f64) {
607 let Some(state) = self.lists.get(&node) else {
608 return;
609 };
610 let (anchor, stale, header) = match state.cells.get(&key) {
611 Some(b) if b.active => (b.anchor, b.laid_width != Some(width), b.header),
612 _ => return,
613 };
614 let row_height = if header {
617 day_spec::props::RowHeight::Automatic
618 } else {
619 state.driver.row_height
620 };
621 if stale {
626 self.invalidate_subtree(anchor);
627 if let Some(b) = self
628 .lists
629 .get_mut(&node)
630 .and_then(|s| s.cells.get_mut(&key))
631 {
632 b.laid_width = Some(width);
633 }
634 }
635 let height = match row_height {
636 day_spec::props::RowHeight::Uniform(h) => h,
637 day_spec::props::RowHeight::Automatic => {
638 crate::layout::measure_node(self, anchor, Proposal::new(Some(width), None)).height
639 }
640 };
641 let previous = self
642 .lists
643 .get_mut(&node)
644 .and_then(|s| s.cells.get_mut(&key))
645 .and_then(|b| b.laid_height.replace(height));
646 if previous.is_some_and(|p| (p - height).abs() > 0.25)
650 && let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone())
651 {
652 self.toolkit.update(
653 &handle,
654 kinds::LIST,
655 &day_spec::props::ListPatch::RowSizeInvalidated { cell: key, height } as &dyn Any,
656 None,
657 );
658 }
659 crate::layout::place_node(
660 self,
661 anchor,
662 Rect::new(0.0, 0.0, width, height),
663 Point::ZERO,
664 true,
665 );
666 self.nodes[anchor].needs_measure = false;
670 }
671
672 fn layout_tree_cell_at(&mut self, node: RNode, key: usize, width: f64) {
675 let Some(state) = self.trees.get(&node) else {
676 return;
677 };
678 let (anchor, stale) = match state.cells.get(&key) {
679 Some(b) => (b.anchor, b.laid_width != Some(width)),
680 None => return,
681 };
682 let row_height = state.driver.row_height;
683 let native_height = state.cells.get(&key).and_then(|b| b.native_height);
684 if stale {
685 self.invalidate_subtree(anchor);
686 if let Some(b) = self
687 .trees
688 .get_mut(&node)
689 .and_then(|s| s.cells.get_mut(&key))
690 {
691 b.laid_width = Some(width);
692 }
693 }
694 let height = native_height.unwrap_or_else(|| match row_height {
695 day_spec::props::RowHeight::Uniform(h) => h,
696 day_spec::props::RowHeight::Automatic => {
697 crate::layout::measure_node(self, anchor, Proposal::new(Some(width), None)).height
698 }
699 });
700 if let Some(b) = self
701 .trees
702 .get_mut(&node)
703 .and_then(|s| s.cells.get_mut(&key))
704 {
705 b.laid_height = Some(height);
706 }
707 crate::layout::place_node(
708 self,
709 anchor,
710 Rect::new(0.0, 0.0, width, height),
711 Point::ZERO,
712 true,
713 );
714 self.nodes[anchor].needs_measure = false;
715 }
716
717 fn layout_now(&mut self) {
718 for i in 0..self.windows.len() {
721 let (root, size) = (self.windows[i].root, self.windows[i].size);
722 let p = Proposal::exact(size);
723 crate::layout::measure_node(self, root, p);
724 crate::layout::place_node(self, root, Rect::from_size(size), Point::ZERO, true);
725 }
726 let dirty_cells: Vec<(RNode, usize)> = self
732 .lists
733 .iter()
734 .flat_map(|(list, state)| {
735 state.cells.iter().filter_map(|(key, cell)| {
736 if !cell.active {
737 return None;
738 }
739 self.nodes
740 .get(cell.anchor)
741 .filter(|n| n.needs_layout)
742 .map(|_| (*list, *key))
743 })
744 })
745 .collect();
746 let dirty_tree_cells: Vec<(RNode, usize)> = self
747 .trees
748 .iter()
749 .flat_map(|(tree, state)| {
750 state.cells.iter().filter_map(|(key, cell)| {
751 self.nodes
752 .get(cell.anchor)
753 .filter(|n| n.needs_layout)
754 .map(|_| (*tree, *key))
755 })
756 })
757 .collect();
758 for (tree, key) in dirty_tree_cells {
759 self.tree_layout_cell(tree, key);
760 }
761 for (list, key) in dirty_cells {
762 self.list_layout_cell(list, key);
763 }
764 let queue = std::mem::take(&mut self.release_queue);
765 for (kind, h) in queue {
766 self.toolkit.release_piece(kind, &h);
769 self.toolkit.release(h);
770 }
771 }
772}
773
774#[derive(Clone, Debug, PartialEq)]
783pub enum ScrollTarget {
784 Top,
785 Bottom,
786 Leading,
787 Trailing,
788 Offset(Point),
789 Id(String),
790}
791
792pub trait TreeOps {
793 #[allow(clippy::too_many_arguments)]
796 fn create_node(
797 &mut self,
798 kind: PieceKind,
799 props: &dyn Any,
800 layout: Rc<dyn Layout>,
801 flex: Flex,
802 native: bool,
803 is_boundary: bool,
804 scope: Scope,
805 ) -> RNode;
806 fn attach(&mut self, parent: RNode, child: RNode);
807 fn reparent(&mut self, child: RNode, parent: RNode) -> bool;
809 fn native_window_tabs(&self) -> bool;
810 fn native_document_tabs(&self) -> bool;
811 fn group_windows(&mut self, roots: &[RNode]);
812 fn window_tab_order(&self, root: RNode) -> Vec<day_spec::NodeId>;
813
814 fn attach_at(&mut self, parent: RNode, child: RNode, index: usize);
815 fn reorder_children(&mut self, parent: RNode, order: Vec<RNode>);
816 fn remove_subtree(&mut self, node: RNode);
817 fn node_exists(&self, node: RNode) -> bool;
819 fn dark_mode(&mut self) -> bool;
821 fn system_color(&mut self, role: day_spec::SystemColor) -> day_spec::Color;
822 fn reduce_motion(&mut self) -> bool;
824 fn set_appearance(&mut self, dark: Option<bool>);
826 fn set_app_badge(&mut self, badge: &day_spec::AppBadge);
828 fn on_event(&mut self, node: RNode, h: EventHandler);
829 fn handlers_for(&self, node: RNode) -> Vec<EventHandler>;
830 fn native_view_of(&self, node: RNode) -> Option<RNode>;
834 fn wrappers_above(&self, node: RNode) -> Vec<RNode>;
837 fn gesture_target(&self, node: RNode, kind: day_spec::GestureKind) -> Option<RNode>;
845 fn set_element_outer(&mut self, inner: RNode, outer: RNode);
849 fn set_element_target(&mut self, outer: RNode, target: RNode);
851 fn element_target(&self, node: RNode) -> RNode;
852 fn set_id(&mut self, node: RNode, id: String);
853 fn mounted_id_families(&self) -> Vec<String>;
855 fn set_grid_facts(&mut self, node: RNode, facts: GridFacts);
858 fn forward_whole_row(&mut self, wrapper: RNode, inner: RNode);
861 fn set_a11y(&mut self, node: RNode, a11y: A11yProps);
862 fn announce(&mut self, text: &str, urgent: bool);
864 fn enable_gesture(&mut self, node: RNode, kind: day_spec::GestureKind);
867 fn focus_node(&mut self, node: RNode, focused: bool);
869 fn set_focusable(&mut self, node: RNode, focusable: bool);
872 fn set_probe_focused(&mut self, node: RNode, focused: bool);
874 fn set_probe_selected(&mut self, node: RNode, selected: Option<usize>);
879 fn set_probe_value(&mut self, node: RNode, value: f64, text: String);
884 fn set_app_menu(&mut self, items: Vec<day_spec::MenuItem>);
885 fn set_context_menu(&mut self, node: RNode, items: Vec<day_spec::MenuItem>);
886 fn edit_window_toolbar(&mut self, root: RNode, ops: Vec<day_spec::ToolbarOp>) -> bool;
891 fn patch_window_toolbar(&mut self, root: RNode, patch: day_spec::ToolbarPatch) -> bool;
893 fn scroll_to_target(&mut self, node: RNode, target: &ScrollTarget, animated: bool) -> bool;
898 fn scroll_reveal(&mut self, node: RNode, animated: bool) -> bool;
901 fn patch(&mut self, node: RNode, patch: Box<dyn Any>, affects_size: bool);
902 fn replay(&mut self, node: RNode, ops: Vec<DrawOp>);
903 fn request_frame(&mut self, root: RNode, cb: day_spec::FrameCallback) -> day_spec::CancelFrame;
904 fn set_implicit_anim(&mut self, node: RNode, anim: Option<day_spec::AnimSpec>);
908 fn set_node_opacity(&mut self, node: RNode, opacity: f64);
911 fn set_node_transform(&mut self, node: RNode, t: day_spec::Transform);
914 fn set_node_selectable(&mut self, node: RNode, selectable: bool);
917 fn set_node_input_traits(&mut self, node: RNode, traits: &day_spec::InputTraits);
921 fn set_node_cursor(&mut self, node: RNode, cursor: day_spec::Cursor);
924 fn set_node_drag_region(&mut self, node: RNode, drag: bool);
927 fn note_node_tweaked(&mut self, node: RNode) {
931 let _ = node;
932 }
933 fn mark_needs_measure(&mut self, node: RNode);
934 fn mark_layout_dirty(&mut self);
935 fn invalidate_all_measurements(&mut self);
939 fn layout_if_needed(&mut self);
940 fn set_window_size(&mut self, s: Size);
941 fn set_route(&mut self, route: &str);
945 fn child_count(&self, node: RNode) -> usize;
946 fn first_child(&self, node: RNode) -> Option<RNode>;
947 fn parent_of(&self, node: RNode) -> Option<RNode>;
950 fn node_kind(&self, node: RNode) -> Option<PieceKind>;
951 fn node_id(&self, node: RNode) -> Option<String>;
954 fn node_handle_any(&self, node: RNode) -> Option<Box<dyn Any>>;
960 fn node_frame(&self, node: RNode) -> Option<Rect>;
961 fn node_probe(&self, node: RNode) -> Option<NodeProbe>;
962 fn node_a11y(&self, node: RNode) -> Option<A11yProps>;
964 fn read_native(&self, node: RNode) -> Option<day_spec::NativeSnapshot>;
967 fn a11y_nodes(&self) -> Vec<(String, PieceKind, A11yProps, day_spec::NativeSnapshot)>;
970 fn find_by_id(&self, id: &str) -> Option<RNode>;
971 fn toggle_sidebar(&mut self, _host: RNode) -> bool {
976 false
977 }
978 fn native_back(&mut self) -> bool {
982 false
983 }
984 fn prepare_snapshot(
985 &mut self,
986 root: Option<RNode>,
987 revision: u32,
988 ) -> Result<day_spec::capture::Readiness, String>;
989 fn snapshot(&mut self) -> Result<Vec<u8>, String>;
990 fn snapshot_origin(&mut self) -> Option<Point>;
993 fn snapshot_chrome(&mut self) -> Result<Vec<u8>, String>;
995
996 fn decode_image(&mut self, req: u64, id: day_spec::BitmapId, bytes: &[u8]);
1002 fn image_info(&mut self, id: day_spec::BitmapId) -> Option<day_spec::BitmapInfo>;
1004 fn image_properties(&mut self, id: day_spec::BitmapId) -> Option<day_spec::ImageProperties>;
1006 fn encode_image(&mut self, req: u64, id: day_spec::BitmapId, spec: &day_spec::EncodeSpec);
1008 fn image_encode_formats(&mut self) -> Vec<day_spec::ImageFormat>;
1010 fn release_image(&mut self, id: day_spec::BitmapId);
1012 fn render_bitmap(
1015 &mut self,
1016 req: u64,
1017 id: day_spec::BitmapId,
1018 ops: &[day_spec::DrawOp],
1019 size: Size,
1020 scale: f64,
1021 );
1022 fn render_pdf(&mut self, req: u64, pages: &[day_spec::PdfPage], info: &day_spec::PdfInfo);
1025 fn window_image_support(&mut self) -> day_spec::Support;
1027 fn font_families(&mut self) -> Vec<day_spec::FontFamilyInfo>;
1029 fn measure_text(
1031 &mut self,
1032 text: &str,
1033 size: f64,
1034 font: &day_spec::CanvasFont,
1035 ) -> Option<day_spec::TextMetrics>;
1036 fn ui_idle(&mut self) -> bool;
1038 fn root_node(&self) -> RNode;
1039
1040 fn open_window_root(&mut self, options: &WindowOptions, kind: WindowKind) -> WindowRootReply;
1049 fn adopt_window_root(&mut self, root: RNode, raw: day_spec::RawHandle, size: Size) -> bool;
1053 fn remove_window_root(&mut self, root: RNode);
1056 fn set_root_size(&mut self, root: RNode, s: Size);
1058
1059 fn fit_window(&mut self, root: RNode, size: Size);
1063 fn add_extra_layout_root(&mut self, node: RNode, size: Size);
1069 fn drop_extra_layout_root(&mut self, node: RNode);
1072 fn close_native_window(&mut self, root: RNode);
1075 fn quit_app(&mut self);
1077 fn focus_native_window(&mut self, root: RNode);
1079 fn set_native_window_title(&mut self, root: RNode, title: &str);
1081 fn apply_window(&mut self, root: RNode, change: &day_spec::WindowChange);
1084 fn set_dock_menu(&mut self, items: &[day_spec::MenuItem]);
1086 fn set_status_items(&mut self, items: &[day_spec::StatusItemSpec]);
1088 fn set_app_progress(&mut self, progress: day_spec::AppProgress);
1090 fn set_dock_visible(&mut self, visible: bool);
1092 fn set_keep_running(&mut self, keep: bool);
1094 fn native_window_frame(&self, root: RNode) -> Option<day_spec::Rect>;
1096 fn monitors(&self) -> Vec<day_spec::Monitor>;
1098 fn set_launcher_shortcuts(&mut self, shortcuts: &[day_spec::LauncherShortcut]);
1100 fn snapshot_of(&mut self, root: RNode) -> Result<Vec<u8>, String>;
1102 fn capability(&self, cap: Cap) -> Support;
1104 fn attach_refresh(&mut self, node: RNode, host: NodeId);
1106 fn set_presented(&mut self, node: RNode, visible: bool);
1107 fn supports_lifecycle(&self, phase: day_spec::Lifecycle) -> bool;
1109 fn present(&mut self, req: u64, spec: &present::PresentSpec);
1111 fn dismiss(&mut self, req: u64);
1113 fn open_url(&mut self, url: &str);
1115 fn share_support(&self) -> Support;
1116 fn share_url(&mut self, url: &str, title: &str) -> bool;
1117 fn application_handlers(
1118 &mut self,
1119 query: &day_spec::applications::HandlerQuery,
1120 ) -> Result<day_spec::applications::ApplicationHandlers, day_spec::applications::ApplicationError>;
1121 fn open_url_with_application(
1122 &mut self,
1123 url: &str,
1124 application: &str,
1125 completion: day_spec::applications::OpenApplicationCompletion,
1126 );
1127
1128 fn defer_system_gestures(&mut self, edges: day_spec::Edges);
1130 fn set_status_bar_hidden(&mut self, hidden: bool);
1133
1134 fn install_list(&mut self, node: RNode, driver: crate::list::ListDriver);
1138 fn list_prepare_cell(
1142 &mut self,
1143 node: RNode,
1144 key: usize,
1145 cell: RawHandle,
1146 header: bool,
1147 ) -> crate::list::CellStep;
1148 fn list_store_cell(
1150 &mut self,
1151 node: RNode,
1152 key: usize,
1153 anchor: RNode,
1154 built: crate::list::BuiltRow,
1155 header: bool,
1156 );
1157 fn list_layout_cell(&mut self, node: RNode, key: usize);
1159 fn list_layout_cell_width(&mut self, node: RNode, key: usize, width: f64);
1163 fn list_cell_height(&self, node: RNode, key: usize) -> f64;
1166 fn list_cell_keys(&self, node: RNode) -> Vec<usize>;
1170 fn list_recycle_cell(&mut self, node: RNode, key: usize);
1174 fn list_release_cell(&mut self, node: RNode, key: usize);
1176 fn list_pin_cell(&mut self, node: RNode, key: usize);
1179 fn list_reload(&mut self, node: RNode);
1181 fn list_splice(&mut self, node: RNode, deltas: Vec<day_spec::props::RowDelta>);
1182 fn set_undo_state(&mut self, state: &day_spec::UndoState);
1183 fn set_edit_state(&mut self, state: &day_spec::EditState);
1184 fn modifiers(&mut self) -> day_spec::Modifiers;
1185 fn list_scroll_to_end(&mut self, node: RNode);
1187 fn list_scroll_to_row(&mut self, node: RNode, row: usize);
1189 fn list_set_selected(&mut self, node: RNode, rows: Vec<usize>);
1192 fn list_set_editing(&mut self, node: RNode, on: bool);
1195 fn list_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::list::ListDriver>>;
1198
1199 fn install_tree(&mut self, node: RNode, driver: crate::tree_driver::TreeDriver);
1203 fn tree_prepare_cell(
1205 &mut self,
1206 node: RNode,
1207 key: usize,
1208 cell: RawHandle,
1209 ) -> crate::tree_driver::TreeCellStep;
1210 fn tree_store_cell(
1212 &mut self,
1213 node: RNode,
1214 key: usize,
1215 anchor: RNode,
1216 built: crate::tree_driver::TreeBuiltRow,
1217 );
1218 fn tree_layout_cell(&mut self, node: RNode, key: usize);
1220 fn tree_layout_cell_width(&mut self, node: RNode, key: usize, width: f64);
1222 fn tree_layout_cell_size(&mut self, node: RNode, key: usize, size: Size);
1223 fn tree_cell_height(&self, node: RNode, key: usize) -> f64;
1226 fn tree_recycle_cell(&mut self, node: RNode, key: usize);
1230 fn tree_reload(&mut self, node: RNode);
1233 fn tree_set_expanded(&mut self, node: RNode, token: u64, expanded: bool);
1235 fn tree_set_selected(&mut self, node: RNode, tokens: Vec<u64>);
1237 fn tree_reveal(&mut self, node: RNode, token: u64);
1239 fn tree_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::tree_driver::TreeDriver>>;
1242 fn set_drag_source(&mut self, node: RNode, source: day_spec::transfer::Source);
1244 fn set_drop_target(&mut self, node: RNode, target: day_spec::transfer::Target);
1245 fn set_context_menu_fn(&mut self, node: RNode, f: day_spec::ContextMenuFn);
1247 fn context_menu_of(&mut self, node: RNode) -> Option<day_spec::ContextMenuFn>;
1252}
1253
1254impl<B: Toolkit> TreeOps for Tree<B> {
1255 fn set_presented(&mut self, node: RNode, visible: bool) {
1256 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
1257 self.toolkit.set_presented(&handle, visible);
1258 }
1259 }
1260
1261 fn attach_refresh(&mut self, node: RNode, host: NodeId) {
1262 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
1263 self.toolkit.attach_refresh(&handle, host);
1264 }
1265 }
1266
1267 fn capability(&self, cap: Cap) -> Support {
1268 self.toolkit.capability(cap)
1269 }
1270
1271 fn supports_lifecycle(&self, phase: day_spec::Lifecycle) -> bool {
1272 self.toolkit.supports_lifecycle(phase)
1273 }
1274
1275 fn present(&mut self, req: u64, spec: &present::PresentSpec) {
1276 self.toolkit.present(req, spec);
1277 }
1278
1279 fn dismiss(&mut self, req: u64) {
1280 self.toolkit.dismiss(req);
1281 }
1282
1283 fn open_url(&mut self, url: &str) {
1284 self.toolkit.open_url(url);
1285 }
1286 fn share_support(&self) -> Support {
1287 self.toolkit.share_support()
1288 }
1289 fn share_url(&mut self, url: &str, title: &str) -> bool {
1290 self.toolkit.share_url(url, title)
1291 }
1292
1293 fn application_handlers(
1294 &mut self,
1295 query: &day_spec::applications::HandlerQuery,
1296 ) -> Result<day_spec::applications::ApplicationHandlers, day_spec::applications::ApplicationError>
1297 {
1298 self.toolkit.application_handlers(query)
1299 }
1300
1301 fn open_url_with_application(
1302 &mut self,
1303 url: &str,
1304 application: &str,
1305 completion: day_spec::applications::OpenApplicationCompletion,
1306 ) {
1307 self.toolkit
1308 .open_url_with_application(url, application, completion);
1309 }
1310
1311 fn set_appearance(&mut self, dark: Option<bool>) {
1312 self.toolkit.set_appearance(dark);
1313 }
1314
1315 fn set_app_badge(&mut self, badge: &day_spec::AppBadge) {
1316 self.toolkit.set_app_badge(badge);
1317 }
1318
1319 fn defer_system_gestures(&mut self, edges: day_spec::Edges) {
1320 self.toolkit.defer_system_gestures(edges);
1321 }
1322
1323 fn set_status_bar_hidden(&mut self, hidden: bool) {
1324 self.toolkit.set_status_bar_hidden(hidden);
1325 }
1326
1327 fn create_node(
1328 &mut self,
1329 kind: PieceKind,
1330 props: &dyn Any,
1331 layout: Rc<dyn Layout>,
1332 flex: Flex,
1333 native: bool,
1334 is_boundary: bool,
1335 scope: Scope,
1336 ) -> RNode {
1337 let mut probe = NodeProbe {
1338 enabled: true,
1339 ..Default::default()
1340 };
1341 {
1342 use day_spec::props::*;
1343 if let Some(p) = props.downcast_ref::<LabelProps>() {
1344 probe.text = p.text.clone();
1345 probe.font = Some(p.font);
1346 } else if let Some(p) = props.downcast_ref::<NavMenuProps>() {
1347 probe.selected = p.selected.map(|i| i as i64).unwrap_or(-1);
1348 probe.value = probe.selected as f64;
1349 } else if let Some(p) = props.downcast_ref::<ButtonProps>() {
1350 probe.text = p.title.clone();
1351 probe.enabled = p.enabled;
1352 probe.flag = p.selected;
1354 } else if let Some(p) = props.downcast_ref::<ToggleProps>() {
1355 probe.flag = p.on;
1356 probe.enabled = p.enabled;
1357 } else if let Some(p) = props.downcast_ref::<SliderProps>() {
1358 probe.value = p.value;
1359 probe.enabled = p.enabled;
1360 } else if let Some(p) = props.downcast_ref::<TextFieldProps>() {
1361 probe.text = p.text.clone();
1362 probe.enabled = p.enabled;
1363 } else if let Some(p) = props.downcast_ref::<ProgressProps>() {
1364 probe.flag = p.value.is_none();
1366 probe.value = p.value.unwrap_or(0.0);
1367 } else if let Some(p) = props.downcast_ref::<PickerProps>() {
1368 probe.selected = p.selected as i64;
1369 probe.value = p.selected as f64;
1370 probe.text = p.options.get(p.selected).cloned().unwrap_or_default();
1373 probe.options = p.options.clone();
1374 probe.enabled = p.enabled;
1375 } else if let Some(p) = props.downcast_ref::<TextAreaProps>() {
1376 probe.text = p.text.clone();
1377 }
1378 }
1379 let node = self.nodes.insert(NodeData {
1380 kind,
1381 handle: None,
1382 parent: RNode::null(),
1383 children: Vec::new(),
1384 layout,
1385 flex,
1386 scope,
1387 id: None,
1388 parked_id: None,
1389 a11y: Default::default(),
1390 cache: Vec::new(),
1391 baseline_cache: None,
1392 probe,
1393 needs_measure: true,
1394 needs_layout: true,
1395 last_native_frame: None,
1396 scroll_content: None,
1397 implicit_anim: None,
1398 tweaked: false,
1399 is_boundary,
1400 });
1401 if native {
1402 let h = self.toolkit.realize(kind, props, rnode_to_id(node));
1403 self.nodes[node].handle = Some(h);
1404 }
1405 node
1406 }
1407
1408 fn attach(&mut self, parent: RNode, child: RNode) {
1409 let index = self
1410 .nodes
1411 .get(parent)
1412 .map(|p| p.children.len())
1413 .unwrap_or(0);
1414 self.attach_impl(parent, child, index);
1415 }
1416
1417 fn native_window_tabs(&self) -> bool {
1418 self.toolkit.native_window_tabs()
1419 }
1420 fn native_document_tabs(&self) -> bool {
1421 self.toolkit.native_document_tabs()
1422 }
1423 fn group_windows(&mut self, roots: &[RNode]) {
1424 let hosts = roots
1425 .iter()
1426 .filter_map(|r| self.nodes.get(*r)?.handle.clone())
1427 .collect::<Vec<_>>();
1428 self.toolkit.group_windows(&hosts);
1429 }
1430 fn window_tab_order(&self, root: RNode) -> Vec<day_spec::NodeId> {
1431 self.nodes
1432 .get(root)
1433 .and_then(|n| n.handle.as_ref())
1434 .map(|h| self.toolkit.window_tab_order(h))
1435 .unwrap_or_default()
1436 }
1437 fn reparent(&mut self, child: RNode, parent: RNode) -> bool {
1438 if !self.nodes.contains_key(child) || !self.nodes.contains_key(parent) {
1439 return false;
1440 }
1441 let old = self.nodes[child].parent;
1442 if old == parent {
1443 return true;
1444 }
1445 if self.windows.iter().any(|w| w.root == child) {
1447 return false;
1448 }
1449 let mut up = parent;
1450 while let Some(n) = self.nodes.get(up) {
1451 if up == child {
1452 return false;
1453 }
1454 up = n.parent;
1455 }
1456 let ancestor = self.native_ancestor(old);
1457 let handle = self.nodes.get(ancestor).and_then(|n| n.handle.clone());
1458 let mut roots = Vec::new();
1459 if self.nodes[child].handle.is_some() {
1460 roots.push(child);
1461 } else {
1462 self.native_descendants(child, &mut roots);
1463 }
1464 if let Some(h) = handle {
1465 for r in roots {
1466 self.toolkit
1468 .remove(&h, self.nodes[r].handle.as_ref().unwrap());
1469 }
1470 }
1471 if let Some(p) = self.nodes.get_mut(old) {
1472 p.children.retain(|n| *n != child);
1473 }
1474 self.mark_needs_measure_impl(old);
1475 self.attach(parent, child);
1476 self.layout_dirty = true;
1477 true
1478 }
1479
1480 fn attach_at(&mut self, parent: RNode, child: RNode, index: usize) {
1481 self.attach_impl(parent, child, index);
1482 }
1483
1484 fn reorder_children(&mut self, parent: RNode, order: Vec<RNode>) {
1485 if self.nodes.get(parent).is_some_and(|p| p.children == order) {
1493 return;
1494 }
1495 if let Some(p) = self.nodes.get_mut(parent) {
1496 p.children = order;
1497 }
1498 let ancestor = self.native_ancestor(parent);
1500 let anc_handle = self.nodes[ancestor]
1501 .handle
1502 .clone()
1503 .expect("native ancestor");
1504 let mut desired = Vec::new();
1505 self.native_descendants(ancestor, &mut desired);
1506 for (i, r) in desired.iter().enumerate() {
1507 let h = self.nodes[*r].handle.clone().unwrap();
1508 self.toolkit.move_child(&anc_handle, &h, i);
1509 }
1510 self.mark_needs_measure_impl(parent);
1511 }
1512
1513 fn remove_subtree(&mut self, node: RNode) {
1514 debug_assert!(
1517 !self.windows.iter().any(|w| w.root == node),
1518 "remove_subtree called with a window root"
1519 );
1520 self.remove_subtree_impl(node);
1521 }
1522
1523 fn on_event(&mut self, node: RNode, h: EventHandler) {
1524 self.handlers.entry(node).or_default().push(h);
1525 }
1526
1527 fn handlers_for(&self, node: RNode) -> Vec<EventHandler> {
1528 self.handlers.get(&node).cloned().unwrap_or_default()
1529 }
1530 fn native_view_of(&self, node: RNode) -> Option<RNode> {
1531 let mut cur = node;
1532 for _ in 0..16 {
1533 let n = self.nodes.get(cur)?;
1534 if n.handle.is_some() {
1535 return Some(cur);
1536 }
1537 match n.children.as_slice() {
1538 [only] => cur = *only,
1539 _ => return None,
1540 }
1541 }
1542 None
1543 }
1544 fn gesture_target(&self, node: RNode, kind: day_spec::GestureKind) -> Option<RNode> {
1545 let has = |n: RNode| self.gestures.get(&n).is_some_and(|k| k.contains(&kind));
1546 if has(node) {
1547 return Some(node);
1548 }
1549 let mut cur = node;
1552 let mut bound = self.element_outer.get(&node).copied();
1553 while let Some(outer) = bound {
1554 if cur == outer {
1555 bound = self.element_outer.get(&outer).copied();
1556 continue;
1557 }
1558 let Some(parent) = self.nodes.get(cur).map(|n| n.parent) else {
1559 break;
1560 };
1561 if parent == cur || !self.nodes.contains_key(parent) {
1562 break;
1563 }
1564 cur = parent;
1565 if has(cur) {
1566 return Some(cur);
1567 }
1568 }
1569 self.wrappers_above(cur).into_iter().find(|w| has(*w))
1570 }
1571
1572 fn set_element_target(&mut self, outer: RNode, target: RNode) {
1573 if outer != target {
1574 self.element_targets.insert(outer, target);
1575 self.set_element_outer(target, outer);
1576 }
1577 }
1578
1579 fn element_target(&self, node: RNode) -> RNode {
1580 self.element_targets
1581 .get(&node)
1582 .copied()
1583 .filter(|n| self.nodes.contains_key(*n))
1584 .unwrap_or(node)
1585 }
1586
1587 fn set_element_outer(&mut self, inner: RNode, outer: RNode) {
1588 if inner != outer {
1589 self.element_outer.insert(inner, outer);
1590 }
1591 }
1592
1593 fn wrappers_above(&self, node: RNode) -> Vec<RNode> {
1594 let mut out = Vec::new();
1595 let mut cur = node;
1596 for _ in 0..16 {
1597 let Some(parent) = self.nodes.get(cur).map(|n| n.parent) else {
1598 break;
1599 };
1600 match self.nodes.get(parent) {
1601 Some(p) if p.handle.is_none() && p.children.len() == 1 && parent != cur => {
1602 out.push(parent);
1603 cur = parent;
1604 }
1605 _ => break,
1606 }
1607 }
1608 out
1609 }
1610 fn node_exists(&self, node: RNode) -> bool {
1611 self.nodes.contains_key(node)
1612 }
1613 fn system_color(&mut self, role: day_spec::SystemColor) -> day_spec::Color {
1614 self.toolkit.system_color(role)
1615 }
1616
1617 fn dark_mode(&mut self) -> bool {
1618 self.toolkit.dark_mode()
1619 }
1620 fn reduce_motion(&mut self) -> bool {
1621 self.toolkit.reduce_motion()
1622 }
1623
1624 fn mounted_id_families(&self) -> Vec<String> {
1625 self.mounted_id_families.iter().cloned().collect()
1626 }
1627 fn set_id(&mut self, node: RNode, id: String) {
1628 if self.nodes.contains_key(node) {
1629 self.mounted_id_families
1630 .insert(crate::element_id::family_of(&id).to_owned());
1631 }
1632 if let Some(n) = self.nodes.get_mut(node) {
1633 n.id = Some(id.clone());
1634 n.a11y.merge(&A11yProps {
1635 identifier: Some(id),
1636 ..Default::default()
1637 });
1638 if let Some(h) = n.handle.clone() {
1639 self.toolkit.set_a11y(&h, &n.a11y);
1640 }
1641 }
1642 }
1643
1644 fn forward_whole_row(&mut self, wrapper: RNode, inner: RNode) {
1645 let whole = self.nodes.get(inner).is_some_and(|n| n.flex.whole_row);
1646 if let Some(n) = self.nodes.get_mut(wrapper) {
1647 n.flex.whole_row = whole;
1648 }
1649 }
1650
1651 fn set_grid_facts(&mut self, node: RNode, facts: GridFacts) {
1652 if let Some(n) = self.nodes.get_mut(node) {
1653 let g = &mut n.flex.grid;
1654 if facts.is_row {
1655 g.is_row = true;
1656 }
1657 if facts.row_valign.is_some() {
1658 g.row_valign = facts.row_valign;
1659 }
1660 if facts.col_span != 0 {
1661 g.col_span = facts.col_span;
1662 }
1663 if facts.align.is_some() {
1664 g.align = facts.align;
1665 }
1666 }
1667 }
1668
1669 fn announce(&mut self, text: &str, urgent: bool) {
1670 self.toolkit.announce(text, urgent);
1671 }
1672
1673 fn set_a11y(&mut self, node: RNode, a11y: A11yProps) {
1674 if let Some(n) = self.nodes.get_mut(node) {
1675 n.a11y.merge(&a11y);
1678 if n.kind == kinds::CANVAS
1682 && let Some(text) = n.a11y.value.clone().or_else(|| n.a11y.label.clone())
1683 {
1684 n.probe.text = text;
1685 }
1686 if let Some(h) = n.handle.clone() {
1687 self.toolkit.set_a11y(&h, &n.a11y);
1688 }
1689 }
1690 }
1691
1692 fn enable_gesture(&mut self, node: RNode, kind: day_spec::GestureKind) {
1693 let kinds = self.gestures.entry(node).or_default();
1694 if !kinds.contains(&kind) {
1695 kinds.push(kind);
1696 }
1697 let mut cur = node;
1703 for _ in 0..16 {
1704 let Some(n) = self.nodes.get(cur) else { return };
1705 if let Some(h) = n.handle.clone() {
1706 if kind == day_spec::GestureKind::Tap && n.kind == kinds::BUTTON {
1707 log::warn!(
1708 "tap gesture attached to native button {:?} (id: {:?}): \
1709 use .action(...) instead of .on_tap(...) or .on_tap_at(...). \
1710 A separate gesture recognizer can delay pressed feedback and \
1711 bypass native keyboard, accessibility, and disabled behavior",
1712 rnode_to_id(cur),
1713 n.id,
1714 );
1715 }
1716 self.toolkit.enable_gesture(&h, rnode_to_id(node), kind);
1717 return;
1718 }
1719 match n.children.as_slice() {
1720 [only] => cur = *only,
1721 _ => break,
1722 }
1723 }
1724 log::warn!(
1725 "enable_gesture({kind:?}) found no native view under the target node — \
1726 the gesture will not fire natively (attach it to a piece with a native handle)"
1727 );
1728 }
1729
1730 fn focus_node(&mut self, node: RNode, focused: bool) {
1731 let mut cur = node;
1734 for _ in 0..16 {
1735 let Some(n) = self.nodes.get(cur) else { return };
1736 if let Some(h) = n.handle.clone() {
1737 self.toolkit.focus(&h, rnode_to_id(node), focused);
1738 return;
1739 }
1740 match n.children.as_slice() {
1741 [only] => cur = *only,
1742 _ => return,
1743 }
1744 }
1745 }
1746
1747 fn set_focusable(&mut self, node: RNode, focusable: bool) {
1748 let mut cur = node;
1752 for _ in 0..16 {
1753 let Some(n) = self.nodes.get(cur) else { return };
1754 if let Some(h) = n.handle.clone() {
1755 self.toolkit.set_focusable(&h, rnode_to_id(node), focusable);
1756 return;
1757 }
1758 match n.children.as_slice() {
1759 [only] => cur = *only,
1760 _ => break,
1761 }
1762 }
1763 log::warn!(
1764 "set_focusable found no native view under the target node — \
1765 the piece will not join the focus order"
1766 );
1767 }
1768
1769 fn set_probe_focused(&mut self, node: RNode, focused: bool) {
1770 if let Some(n) = self.nodes.get_mut(node) {
1771 n.probe.focused = focused;
1772 }
1773 for w in self.wrappers_above(node) {
1778 if let Some(p) = self.nodes.get_mut(w) {
1779 p.probe.focused = focused;
1780 }
1781 }
1782 let mut cur = node;
1788 for _ in 0..16 {
1789 let Some(n) = self.nodes.get(cur) else { break };
1790 if n.handle.is_some() && cur != node {
1791 if let Some(p) = self.nodes.get_mut(cur) {
1792 p.probe.focused = focused;
1793 }
1794 break;
1795 }
1796 let next = match n.children.as_slice() {
1797 [only] => *only,
1798 _ => break,
1799 };
1800 if let Some(p) = self.nodes.get_mut(next) {
1801 p.probe.focused = focused;
1802 }
1803 cur = next;
1804 }
1805 FOCUSED.with(|f| match focused {
1810 true => f.set(Some(node)),
1811 false if f.get() == Some(node) => f.set(None),
1812 false => {}
1813 });
1814 }
1815
1816 fn set_probe_selected(&mut self, node: RNode, selected: Option<usize>) {
1817 if let Some(n) = self.nodes.get_mut(node) {
1818 n.probe.selected = selected.map(|i| i as i64).unwrap_or(-1);
1821 n.probe.value = n.probe.selected as f64;
1822 }
1823 }
1824
1825 fn set_probe_value(&mut self, node: RNode, value: f64, text: String) {
1826 if let Some(n) = self.nodes.get_mut(node) {
1827 n.probe.value = value;
1828 n.probe.text = text;
1829 }
1830 }
1831
1832 fn set_app_menu(&mut self, items: Vec<day_spec::MenuItem>) {
1833 collect_menu_families(&items, &mut self.mounted_id_families);
1834 self.toolkit.set_app_menu(&items);
1835 }
1836
1837 fn edit_window_toolbar(&mut self, root: RNode, ops: Vec<day_spec::ToolbarOp>) -> bool {
1838 let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) else {
1839 return false;
1840 };
1841 for op in &ops {
1842 if let day_spec::ToolbarOp::Insert { item, .. } = op {
1843 self.mounted_id_families
1844 .insert(crate::element_id::family_of(&item.id).to_owned());
1845 }
1846 }
1847 self.toolkit.edit_toolbar(&h, &ops)
1848 }
1849
1850 fn patch_window_toolbar(&mut self, root: RNode, patch: day_spec::ToolbarPatch) -> bool {
1851 let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) else {
1852 return false;
1853 };
1854 self.toolkit.update_toolbar(&h, &patch);
1855 true
1856 }
1857
1858 fn set_context_menu(&mut self, node: RNode, items: Vec<day_spec::MenuItem>) {
1859 let target = if self.nodes.get(node).is_some_and(|n| n.handle.is_some()) {
1864 Some(node)
1865 } else {
1866 let mut roots = Vec::new();
1867 self.native_descendants(node, &mut roots);
1868 roots.first().copied()
1869 };
1870 let Some(t) = target else {
1871 log::warn!("context_menu on a subtree with no native view — menu dropped");
1872 return;
1873 };
1874 collect_menu_families(&items, &mut self.mounted_id_families);
1875 let model = ContextMenuModel::Items(items.clone());
1876 self.context_menus.insert(node, model.clone());
1877 self.context_menus.insert(t, model);
1878 if let Some(h) = self.nodes.get(t).and_then(|n| n.handle.clone()) {
1879 self.toolkit.set_context_menu(&h, rnode_to_id(t), &items);
1880 }
1881 }
1882
1883 fn scroll_to_target(&mut self, node: RNode, target: &ScrollTarget, animated: bool) -> bool {
1884 if let ScrollTarget::Id(id) = target {
1886 let Some(el) = self.find_by_id(id) else {
1887 return false;
1888 };
1889 return self.scroll_reveal(el, animated);
1890 }
1891 let Some(n) = self.nodes.get(node) else {
1892 return false;
1893 };
1894 if n.kind == kinds::NAV_MENU {
1895 return match (n.handle.clone(), target) {
1896 (Some(h), ScrollTarget::Top | ScrollTarget::Bottom) => self
1897 .toolkit
1898 .nav_scroll_to_edge(&h, matches!(target, ScrollTarget::Bottom)),
1899 _ => false,
1900 };
1901 }
1902 if n.kind != kinds::SCROLL {
1903 return false;
1904 }
1905 let Some(h) = n.handle.clone() else {
1906 return false;
1907 };
1908 let viewport = n.last_native_frame.map(|f| f.size).unwrap_or(Size::ZERO);
1909 let content = n.scroll_content.unwrap_or(viewport);
1910 let rect = match target {
1913 ScrollTarget::Top | ScrollTarget::Leading => Rect::new(0.0, 0.0, 1.0, 1.0),
1914 ScrollTarget::Bottom => Rect::new(0.0, (content.height - 1.0).max(0.0), 1.0, 1.0),
1915 ScrollTarget::Trailing => Rect::new((content.width - 1.0).max(0.0), 0.0, 1.0, 1.0),
1916 ScrollTarget::Offset(p) => Rect::new(p.x, p.y, viewport.width, viewport.height),
1919 ScrollTarget::Id(_) => unreachable!("routed to scroll_reveal above"),
1920 };
1921 self.toolkit
1922 .scroll_to(&h, rect, animated && !crate::reduce_motion_now());
1923 true
1924 }
1925
1926 fn scroll_reveal(&mut self, node: RNode, animated: bool) -> bool {
1927 let Some(mut rect) = self.nodes.get(node).and_then(|n| n.last_native_frame) else {
1931 return false;
1932 };
1933 let mut anc = match self.nodes.get(node) {
1934 Some(n) => n.parent,
1935 None => return false,
1936 };
1937 loop {
1938 let Some(a) = self.nodes.get(anc) else {
1939 return false; };
1941 if a.kind == kinds::SCROLL {
1942 let Some(h) = a.handle.clone() else {
1943 return false;
1944 };
1945 self.toolkit
1946 .scroll_to(&h, rect, animated && !crate::reduce_motion_now());
1947 return true;
1948 }
1949 if a.handle.is_some()
1950 && let Some(f) = a.last_native_frame
1951 {
1952 rect.origin.x += f.origin.x;
1953 rect.origin.y += f.origin.y;
1954 }
1955 anc = a.parent;
1956 }
1957 }
1958
1959 fn patch(&mut self, node: RNode, patch: Box<dyn Any>, affects_size: bool) {
1960 {
1961 use day_spec::props::*;
1962 if let Some(n) = self.nodes.get_mut(node) {
1963 if let Some(p) = patch.downcast_ref::<LabelPatch>() {
1964 match p {
1968 LabelPatch::Text(t) => n.probe.text = t.clone(),
1969 LabelPatch::Runs(t, _) => n.probe.text = t.clone(),
1970 LabelPatch::Font(font) => n.probe.font = Some(*font),
1971 LabelPatch::Color(_) => {}
1972 }
1973 } else if let Some(p) = patch.downcast_ref::<ButtonPatch>() {
1974 match p {
1975 ButtonPatch::Title(t) => n.probe.text = t.clone(),
1976 ButtonPatch::Content(c) => n.probe.text = c.title.clone(),
1977 ButtonPatch::Enabled(e) => n.probe.enabled = *e,
1978 ButtonPatch::Selected(on) => n.probe.flag = *on,
1979 ButtonPatch::Style(_) => {}
1981 }
1982 } else if let Some(p) = patch.downcast_ref::<TogglePatch>() {
1983 match p {
1984 TogglePatch::On(v) => n.probe.flag = *v,
1985 TogglePatch::Enabled(e) => n.probe.enabled = *e,
1986 }
1987 } else if let Some(p) = patch.downcast_ref::<SliderPatch>() {
1988 match p {
1989 SliderPatch::Value(v) => n.probe.value = *v,
1990 SliderPatch::Enabled(e) => n.probe.enabled = *e,
1991 }
1992 } else if let Some(p) = patch.downcast_ref::<PickerPatch>() {
1993 match p {
1994 PickerPatch::Selected(i) => {
1995 n.probe.selected = *i as i64;
1996 n.probe.value = *i as f64;
1997 }
1998 PickerPatch::Options(opts) => n.probe.options = opts.clone(),
1999 PickerPatch::Enabled(e) => n.probe.enabled = *e,
2000 }
2001 let i = n.probe.selected.max(0) as usize;
2002 n.probe.text = n.probe.options.get(i).cloned().unwrap_or_default();
2003 } else if let Some(TextAreaPatch::SetText(t)) =
2004 patch.downcast_ref::<TextAreaPatch>()
2005 {
2006 n.probe.text = t.clone();
2007 } else if let Some(ProgressPatch::Value(v)) = patch.downcast_ref::<ProgressPatch>()
2008 {
2009 n.probe.flag = v.is_none();
2010 n.probe.value = v.unwrap_or(0.0);
2011 } else if let Some(p) = patch.downcast_ref::<TextFieldPatch>() {
2012 match p {
2013 TextFieldPatch::Text { text, .. } => n.probe.text = text.clone(),
2014 TextFieldPatch::Enabled(e) => n.probe.enabled = *e,
2015 _ => {}
2016 }
2017 } else if let Some(NavMenuPatch::Selected(sel)) =
2018 patch.downcast_ref::<NavMenuPatch>()
2019 {
2020 n.probe.selected = sel.map(|i| i as i64).unwrap_or(-1);
2021 n.probe.value = n.probe.selected as f64;
2022 }
2023 }
2024 }
2025 let Some(n) = self.nodes.get(node) else {
2026 return;
2027 };
2028 let kind = n.kind;
2029 if let Some(h) = n.handle.clone() {
2030 let anim = self.resolve_anim(node);
2031 self.toolkit.update(&h, kind, patch.as_ref(), anim.as_ref());
2032 }
2033 if affects_size {
2034 self.mark_needs_measure_impl(node);
2035 }
2036 }
2037
2038 fn set_implicit_anim(&mut self, node: RNode, anim: Option<day_spec::AnimSpec>) {
2039 let had = self
2040 .nodes
2041 .get(node)
2042 .map(|n| n.implicit_anim.is_some())
2043 .unwrap_or(false);
2044 if let Some(n) = self.nodes.get_mut(node) {
2045 n.implicit_anim = anim;
2046 } else {
2047 return;
2048 }
2049 match (had, anim.is_some()) {
2050 (false, true) => self.implicit_anim_count += 1,
2051 (true, false) => self.implicit_anim_count = self.implicit_anim_count.saturating_sub(1),
2052 _ => {}
2053 }
2054 }
2055
2056 fn set_node_opacity(&mut self, node: RNode, opacity: f64) {
2057 let Some(h) = self.nodes.get(node).and_then(|n| n.handle.clone()) else {
2058 return;
2059 };
2060 let anim = self.resolve_anim(node);
2061 self.toolkit.set_opacity(&h, opacity, anim.as_ref());
2062 }
2063
2064 fn set_node_transform(&mut self, node: RNode, t: day_spec::Transform) {
2065 let Some(n) = self.nodes.get(node) else {
2066 return;
2067 };
2068 let Some(h) = n.handle.clone() else {
2069 return;
2070 };
2071 let size = n.last_native_frame.map(|f| f.size).unwrap_or(Size::ZERO);
2074 let anim = self.resolve_anim(node);
2075 self.toolkit.set_transform(&h, t, size, anim.as_ref());
2076 }
2077
2078 fn set_node_selectable(&mut self, node: RNode, selectable: bool) {
2079 let Some(h) = self.nodes.get(node).and_then(|n| n.handle.clone()) else {
2080 return;
2081 };
2082 if let Some(new) = self.toolkit.set_selectable(&h, selectable)
2085 && let Some(n) = self.nodes.get_mut(node)
2086 {
2087 if n.tweaked {
2088 log::warn!(
2089 "`.selectable()` rebuilt this widget as a different native class, \
2090 discarding an earlier tweak's changes — apply `.selectable()` BEFORE the \
2091 tweak so it runs against the widget that ships (docs/tweaks.md)."
2092 );
2093 }
2094 n.handle = Some(new);
2095 }
2096 }
2097
2098 fn set_node_input_traits(&mut self, node: RNode, traits: &day_spec::InputTraits) {
2099 let Some(h) = self.nodes.get(node).and_then(|n| n.handle.clone()) else {
2100 return;
2101 };
2102 if let Some(new) = self.toolkit.set_input_traits(&h, traits)
2105 && let Some(n) = self.nodes.get_mut(node)
2106 {
2107 if n.tweaked {
2108 log::warn!(
2109 "a text field's `.secure()` rebuilt this widget as a different native \
2110 class, discarding an earlier tweak's changes (docs/tweaks.md)."
2111 );
2112 }
2113 n.handle = Some(new);
2114 n.last_native_frame = None;
2115 self.mark_needs_measure_impl(node);
2116 }
2117 }
2118
2119 fn set_node_cursor(&mut self, node: RNode, cursor: day_spec::Cursor) {
2120 let Some(h) = self
2124 .native_view_of(node)
2125 .and_then(|n| self.nodes.get(n))
2126 .and_then(|n| n.handle.clone())
2127 else {
2128 return;
2129 };
2130 self.toolkit.set_cursor(&h, cursor);
2131 }
2132
2133 fn set_node_drag_region(&mut self, node: RNode, drag: bool) {
2134 let Some(h) = self
2136 .native_view_of(node)
2137 .and_then(|n| self.nodes.get(n))
2138 .and_then(|n| n.handle.clone())
2139 else {
2140 log::warn!(
2141 "window_drag_region found no native view under the target node; give the \
2142 region a piece with a native view (a background, a row)"
2143 );
2144 return;
2145 };
2146 self.toolkit.set_drag_region(&h, drag);
2147 }
2148
2149 fn note_node_tweaked(&mut self, node: RNode) {
2150 if let Some(n) = self.nodes.get_mut(node) {
2151 n.tweaked = true;
2152 }
2153 }
2154
2155 fn request_frame(&mut self, root: RNode, cb: day_spec::FrameCallback) -> day_spec::CancelFrame {
2156 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2157 self.toolkit.request_frame(&h, cb)
2158 } else {
2159 Box::new(|| {})
2160 }
2161 }
2162
2163 fn replay(&mut self, node: RNode, ops: Vec<DrawOp>) {
2164 let Some(n) = self.nodes.get(node) else {
2165 return;
2166 };
2167 let size = n.last_native_frame.map(|f| f.size).unwrap_or(Size::ZERO);
2168 if let Some(h) = n.handle.clone() {
2169 self.toolkit.replay(&h, &ops, size);
2170 }
2171 }
2172
2173 fn mark_needs_measure(&mut self, node: RNode) {
2174 self.mark_needs_measure_impl(node);
2175 }
2176
2177 fn mark_layout_dirty(&mut self) {
2178 self.layout_dirty = true;
2179 }
2180
2181 fn invalidate_all_measurements(&mut self) {
2182 for (_, n) in self.nodes.iter_mut() {
2183 n.needs_measure = true;
2184 n.needs_layout = true;
2185 n.cache.clear();
2186 }
2187 for state in self.lists.values_mut() {
2191 for cell in state.cells.values_mut() {
2192 cell.laid_width = None;
2193 }
2194 }
2195 for state in self.trees.values_mut() {
2196 for cell in state.cells.values_mut() {
2197 cell.laid_width = None;
2198 }
2199 }
2200 self.layout_dirty = true;
2201 }
2202
2203 fn layout_if_needed(&mut self) {
2204 if !self.layout_dirty {
2205 return;
2206 }
2207 self.layout_dirty = false;
2208 self.layout_now();
2209 }
2210
2211 fn set_route(&mut self, route: &str) {
2212 self.toolkit.set_route(route);
2213 }
2214
2215 fn set_window_size(&mut self, s: Size) {
2216 if s != self.windows[0].size {
2219 self.windows[0].size = s;
2220 let root = self.windows[0].root;
2221 self.mark_needs_measure_impl(root);
2222 }
2223 }
2224
2225 fn child_count(&self, node: RNode) -> usize {
2226 self.nodes.get(node).map(|n| n.children.len()).unwrap_or(0)
2227 }
2228
2229 fn first_child(&self, node: RNode) -> Option<RNode> {
2230 self.nodes
2231 .get(node)
2232 .and_then(|n| n.children.first().copied())
2233 }
2234
2235 fn parent_of(&self, node: RNode) -> Option<RNode> {
2236 self.nodes
2237 .get(node)
2238 .map(|n| n.parent)
2239 .filter(|p| !p.is_null() && *p != node)
2240 }
2241
2242 fn node_kind(&self, node: RNode) -> Option<PieceKind> {
2243 self.nodes.get(node).map(|n| n.kind)
2244 }
2245
2246 fn node_id(&self, node: RNode) -> Option<String> {
2247 self.nodes.get(node).and_then(|n| n.id.clone())
2248 }
2249
2250 fn node_handle_any(&self, node: RNode) -> Option<Box<dyn Any>> {
2251 self.nodes
2252 .get(node)
2253 .and_then(|n| n.handle.clone())
2254 .map(|h| Box::new(h) as Box<dyn Any>)
2255 }
2256
2257 fn node_frame(&self, node: RNode) -> Option<Rect> {
2258 self.nodes.get(node).and_then(|n| n.last_native_frame)
2259 }
2260
2261 fn node_probe(&self, node: RNode) -> Option<NodeProbe> {
2262 self.nodes.get(node).map(|n| n.probe.clone())
2263 }
2264
2265 fn node_a11y(&self, node: RNode) -> Option<A11yProps> {
2266 self.nodes.get(node).map(|n| n.a11y.clone())
2267 }
2268
2269 fn read_native(&self, node: RNode) -> Option<day_spec::NativeSnapshot> {
2270 let n = self.nodes.get(node)?;
2271 let h = n.handle.as_ref()?;
2272 Some(self.toolkit.read_native(h))
2273 }
2274
2275 fn a11y_nodes(&self) -> Vec<(String, PieceKind, A11yProps, day_spec::NativeSnapshot)> {
2276 self.nodes
2277 .values()
2278 .filter_map(|n| {
2279 let id = n.id.clone()?;
2280 let h = n.handle.as_ref()?;
2281 Some((id, n.kind, n.a11y.clone(), self.toolkit.read_native(h)))
2282 })
2283 .collect()
2284 }
2285
2286 fn find_by_id(&self, id: &str) -> Option<RNode> {
2287 let focused = crate::windows::focused_window()
2290 .map(|w| id_to_rnode(crate::windows::window_node_id(&w)))
2291 .unwrap_or_else(|| self.root());
2292 let mut fallback = None;
2293 for (key, node) in &self.nodes {
2294 if node.id.as_deref() != Some(id) {
2295 continue;
2296 }
2297 fallback.get_or_insert(key);
2298 let mut ancestor = key;
2299 while let Some(node) = self.nodes.get(ancestor) {
2300 if self.windows.iter().any(|w| w.root == ancestor) {
2303 if ancestor == focused {
2304 return Some(key);
2305 }
2306 break;
2307 }
2308 ancestor = if node.kind == kinds::LIST_CELL && node.parent.is_null() {
2309 self.lists
2312 .iter()
2313 .find_map(|(&owner, state)| {
2314 state
2315 .cells
2316 .values()
2317 .any(|c| c.anchor == ancestor)
2318 .then_some(owner)
2319 })
2320 .or_else(|| {
2321 self.trees.iter().find_map(|(&owner, state)| {
2322 state
2323 .cells
2324 .values()
2325 .any(|c| c.anchor == ancestor)
2326 .then_some(owner)
2327 })
2328 })
2329 .unwrap_or(node.parent)
2330 } else {
2331 node.parent
2332 };
2333 }
2334 }
2335 fallback
2336 }
2337
2338 fn toggle_sidebar(&mut self, host: RNode) -> bool {
2339 let Some(h) = self.nodes.get(host).and_then(|n| n.handle.as_ref()) else {
2340 return false;
2341 };
2342 self.toolkit.toggle_sidebar(h)
2343 }
2344
2345 fn native_back(&mut self) -> bool {
2346 self.toolkit.native_back()
2347 }
2348
2349 fn prepare_snapshot(
2350 &mut self,
2351 root: Option<RNode>,
2352 revision: u32,
2353 ) -> Result<day_spec::capture::Readiness, String> {
2354 let host = match root {
2355 Some(root) if self.windows[0].root != root => Some(
2356 self.nodes
2357 .get(root)
2358 .and_then(|n| n.handle.clone())
2359 .ok_or("window is gone")?,
2360 ),
2361 _ => None,
2362 };
2363 self.toolkit.prepare_snapshot(host.as_ref(), revision)
2364 }
2365
2366 fn snapshot(&mut self) -> Result<Vec<u8>, String> {
2367 self.toolkit.snapshot_window()
2368 }
2369
2370 fn snapshot_origin(&mut self) -> Option<Point> {
2371 let root = self.windows[0].root;
2372 let h = self.nodes.get(root).and_then(|n| n.handle.clone())?;
2373 self.toolkit.snapshot_origin(&h)
2374 }
2375
2376 fn snapshot_chrome(&mut self) -> Result<Vec<u8>, String> {
2377 self.toolkit.snapshot_window_chrome()
2378 }
2379
2380 fn decode_image(&mut self, req: u64, id: day_spec::BitmapId, bytes: &[u8]) {
2381 self.toolkit.decode_image(req, id, bytes);
2382 }
2383
2384 fn image_info(&mut self, id: day_spec::BitmapId) -> Option<day_spec::BitmapInfo> {
2385 self.toolkit.image_info(id)
2386 }
2387
2388 fn image_properties(&mut self, id: day_spec::BitmapId) -> Option<day_spec::ImageProperties> {
2389 self.toolkit.image_properties(id)
2390 }
2391
2392 fn encode_image(&mut self, req: u64, id: day_spec::BitmapId, spec: &day_spec::EncodeSpec) {
2393 self.toolkit.encode_image(req, id, spec);
2394 }
2395
2396 fn image_encode_formats(&mut self) -> Vec<day_spec::ImageFormat> {
2397 self.toolkit.encode_formats()
2398 }
2399
2400 fn release_image(&mut self, id: day_spec::BitmapId) {
2401 self.toolkit.release_image(id);
2402 }
2403
2404 fn render_bitmap(
2405 &mut self,
2406 req: u64,
2407 id: day_spec::BitmapId,
2408 ops: &[day_spec::DrawOp],
2409 size: Size,
2410 scale: f64,
2411 ) {
2412 self.toolkit.render_bitmap(req, id, ops, size, scale);
2413 }
2414
2415 fn render_pdf(&mut self, req: u64, pages: &[day_spec::PdfPage], info: &day_spec::PdfInfo) {
2416 self.toolkit.render_pdf(req, pages, info);
2417 }
2418
2419 fn window_image_support(&mut self) -> day_spec::Support {
2420 self.toolkit.capability(day_spec::Cap::Snapshot)
2421 }
2422
2423 fn font_families(&mut self) -> Vec<day_spec::FontFamilyInfo> {
2424 self.toolkit.font_families()
2425 }
2426
2427 fn measure_text(
2428 &mut self,
2429 text: &str,
2430 size: f64,
2431 font: &day_spec::CanvasFont,
2432 ) -> Option<day_spec::TextMetrics> {
2433 self.toolkit.measure_text(text, size, font)
2434 }
2435
2436 fn ui_idle(&mut self) -> bool {
2437 self.toolkit.ui_idle()
2438 }
2439
2440 fn root_node(&self) -> RNode {
2441 self.windows[0].root
2442 }
2443
2444 fn open_window_root(&mut self, options: &WindowOptions, kind: WindowKind) -> WindowRootReply {
2445 let root = self.nodes.insert(NodeData {
2448 kind: kinds::CONTAINER,
2449 handle: None,
2450 parent: RNode::null(),
2451 children: Vec::new(),
2452 layout: Rc::new(PassThrough),
2453 flex: Flex::default(),
2454 scope: Scope::root(),
2455 id: None,
2456 parked_id: None,
2457 a11y: Default::default(),
2458 cache: Vec::new(),
2459 baseline_cache: None,
2460 probe: NodeProbe::default(),
2461 needs_measure: true,
2462 needs_layout: true,
2463 last_native_frame: None,
2464 scroll_content: None,
2465 implicit_anim: None,
2466 tweaked: false,
2467 is_boundary: true,
2468 });
2469 match self.toolkit.open_window(rnode_to_id(root), options, kind) {
2470 day_spec::WindowOpenReply::Open(h) => {
2471 self.nodes[root].handle = Some(h);
2472 self.windows.push(WindowEntry {
2473 root,
2474 size: options.size,
2475 });
2476 self.layout_dirty = true;
2477 WindowRootReply::Open(root)
2478 }
2479 day_spec::WindowOpenReply::Pending => WindowRootReply::Pending(root),
2480 day_spec::WindowOpenReply::Unsupported => {
2481 self.nodes.remove(root);
2482 WindowRootReply::Unsupported
2483 }
2484 }
2485 }
2486
2487 fn adopt_window_root(&mut self, root: RNode, raw: day_spec::RawHandle, size: Size) -> bool {
2488 let Some(node) = self.nodes.get_mut(root) else {
2489 return false; };
2491 let handle = self.toolkit.adopt(raw);
2492 node.handle = Some(handle);
2493 node.needs_measure = true;
2494 self.windows.push(WindowEntry { root, size });
2495 self.layout_dirty = true;
2496 true
2497 }
2498
2499 fn remove_window_root(&mut self, root: RNode) {
2500 if self.windows.len() <= 1 {
2508 self.collect_and_release(root);
2509 self.layout_dirty = true;
2510 return;
2511 }
2512 self.windows.retain(|w| w.root != root);
2513 self.collect_and_release(root);
2516 self.layout_dirty = true;
2517 }
2518
2519 fn set_root_size(&mut self, root: RNode, s: Size) {
2520 if let Some(w) = self.windows.iter_mut().find(|w| w.root == root)
2521 && w.size != s
2522 {
2523 w.size = s;
2524 self.mark_needs_measure_impl(root);
2525 }
2526 }
2527
2528 fn fit_window(&mut self, root: RNode, size: Size) {
2529 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2530 self.toolkit.fit_window(&h, size);
2531 }
2532 self.set_root_size(root, size);
2533 }
2534
2535 fn add_extra_layout_root(&mut self, node: RNode, size: Size) {
2536 if !self.windows.iter().any(|w| w.root == node) {
2537 self.windows.push(WindowEntry { root: node, size });
2538 self.layout_dirty = true;
2539 }
2540 }
2541
2542 fn drop_extra_layout_root(&mut self, node: RNode) {
2543 debug_assert!(
2544 self.windows.first().map(|w| w.root) != Some(node),
2545 "drop_extra_layout_root called with the primary root"
2546 );
2547 self.windows.retain(|w| w.root != node);
2548 }
2549
2550 fn close_native_window(&mut self, root: RNode) {
2551 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2552 self.toolkit.close_window(&h);
2553 }
2554 }
2555
2556 fn quit_app(&mut self) {
2557 self.toolkit.quit_app();
2558 }
2559
2560 fn focus_native_window(&mut self, root: RNode) {
2561 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2562 self.toolkit.focus_window(&h);
2563 }
2564 }
2565
2566 fn set_native_window_title(&mut self, root: RNode, title: &str) {
2567 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2568 self.toolkit.set_window_title(&h, title);
2569 }
2570 }
2571
2572 fn apply_window(&mut self, root: RNode, change: &day_spec::WindowChange) {
2573 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2574 self.toolkit.apply_window(&h, change);
2575 }
2576 }
2577
2578 fn set_dock_menu(&mut self, items: &[day_spec::MenuItem]) {
2579 self.toolkit.set_dock_menu(items);
2580 }
2581
2582 fn set_status_items(&mut self, items: &[day_spec::StatusItemSpec]) {
2583 self.toolkit.set_status_items(items);
2584 }
2585
2586 fn set_app_progress(&mut self, progress: day_spec::AppProgress) {
2587 self.toolkit.set_app_progress(progress);
2588 }
2589
2590 fn set_dock_visible(&mut self, visible: bool) {
2591 self.toolkit.set_dock_visible(visible);
2592 }
2593
2594 fn set_keep_running(&mut self, keep: bool) {
2595 self.toolkit.set_keep_running(keep);
2596 }
2597
2598 fn native_window_frame(&self, root: RNode) -> Option<day_spec::Rect> {
2599 let h = self.nodes.get(root).and_then(|n| n.handle.clone())?;
2600 self.toolkit.window_frame(&h)
2601 }
2602
2603 fn monitors(&self) -> Vec<day_spec::Monitor> {
2604 self.toolkit.monitors()
2605 }
2606
2607 fn set_launcher_shortcuts(&mut self, shortcuts: &[day_spec::LauncherShortcut]) {
2608 self.toolkit.set_launcher_shortcuts(shortcuts);
2609 }
2610
2611 fn snapshot_of(&mut self, root: RNode) -> Result<Vec<u8>, String> {
2612 if self.windows[0].root == root {
2613 return self.toolkit.snapshot_window();
2614 }
2615 match self.nodes.get(root).and_then(|n| n.handle.clone()) {
2616 Some(h) => self.toolkit.snapshot_window_of(&h),
2617 None => Err("window is gone".into()),
2618 }
2619 }
2620
2621 fn install_list(&mut self, node: RNode, driver: crate::list::ListDriver) {
2622 let driver = Rc::new(driver);
2623 let sections = driver
2624 .sections
2625 .is_some()
2626 .then(|| crate::list::register_sections(node, driver.clone()));
2627 self.lists.insert(
2628 node,
2629 crate::list::ListState {
2630 driver: driver.clone(),
2631 cells: HashMap::new(),
2632 sections: sections.clone(),
2633 },
2634 );
2635 let source = crate::list::make_source(node, driver, sections);
2636 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2637 self.toolkit.attach_list(&handle, source);
2638 }
2639 }
2640
2641 fn list_prepare_cell(
2642 &mut self,
2643 node: RNode,
2644 key: usize,
2645 cell: RawHandle,
2646 header: bool,
2647 ) -> crate::list::CellStep {
2648 if let Some(state) = self.lists.get_mut(&node)
2652 && state.cells.get(&key).is_some_and(|b| b.header != header)
2653 && let Some(old) = state.cells.remove(&key)
2654 {
2655 old.scope.dispose();
2656 self.remove_subtree_impl(old.anchor);
2657 }
2658 if let Some(state) = self.lists.get_mut(&node)
2659 && let Some(bound) = state.cells.get_mut(&key)
2660 {
2661 bound.active = true;
2662 let (rebind, anchor, pinned) = (bound.rebind.clone(), bound.anchor, bound.pinned);
2663 if !pinned {
2667 self.restore_subtree_ids(anchor);
2668 }
2669 return crate::list::CellStep::Rebind { rebind, anchor };
2670 }
2671 let mut metrics = match self.nodes.get(node).and_then(|n| n.handle.clone()) {
2674 Some(list) => self.toolkit.list_row_metrics(&list),
2675 None => day_spec::RowMetrics::default(),
2676 };
2677 if header {
2681 metrics.insets.top = 0.0;
2682 metrics.insets.bottom = 0.0;
2683 metrics.min_height = 0.0;
2684 }
2685 let handle = self.toolkit.adopt(cell);
2686 let anchor = self.create_cell_anchor(
2687 handle,
2688 Scope::child(),
2689 Rc::new(crate::layout::CellMetrics(metrics)),
2690 );
2691 crate::list::CellStep::Build { anchor }
2692 }
2693
2694 fn list_store_cell(
2695 &mut self,
2696 node: RNode,
2697 key: usize,
2698 anchor: RNode,
2699 built: crate::list::BuiltRow,
2700 header: bool,
2701 ) {
2702 if let Some(state) = self.lists.get_mut(&node) {
2703 state.cells.insert(
2704 key,
2705 crate::list::BoundCell {
2706 anchor,
2707 active: true,
2708 scope: built.scope,
2709 rebind: built.rebind,
2710 native_width: None,
2711 laid_width: None,
2712 laid_height: None,
2713 header,
2714 pinned: false,
2715 },
2716 );
2717 }
2718 }
2719
2720 fn list_layout_cell(&mut self, node: RNode, key: usize) {
2721 let native = self
2727 .lists
2728 .get(&node)
2729 .and_then(|s| s.cells.get(&key))
2730 .and_then(|c| c.native_width);
2731 let width = native.unwrap_or_else(|| {
2732 self.nodes
2733 .get(node)
2734 .and_then(|n| n.last_native_frame)
2735 .map(|f| f.size.width)
2736 .unwrap_or(self.windows[0].size.width)
2737 });
2738 self.layout_list_cell_at(node, key, width);
2739 }
2740
2741 fn list_layout_cell_width(&mut self, node: RNode, key: usize, width: f64) {
2742 if let Some(cell) = self
2745 .lists
2746 .get_mut(&node)
2747 .and_then(|s| s.cells.get_mut(&key))
2748 {
2749 cell.native_width = Some(width);
2750 }
2751 self.layout_list_cell_at(node, key, width);
2752 }
2753
2754 fn list_cell_height(&self, node: RNode, key: usize) -> f64 {
2755 self.lists
2756 .get(&node)
2757 .and_then(|s| s.cells.get(&key))
2758 .filter(|b| b.active)
2759 .and_then(|b| b.laid_height)
2760 .unwrap_or(0.0)
2761 }
2762
2763 fn list_cell_keys(&self, node: RNode) -> Vec<usize> {
2764 self.lists
2765 .get(&node)
2766 .map(|s| {
2767 s.cells
2768 .iter()
2769 .filter_map(|(key, cell)| cell.active.then_some(*key))
2770 .collect()
2771 })
2772 .unwrap_or_default()
2773 }
2774
2775 fn list_reload(&mut self, node: RNode) {
2776 if let Some(map) = self.lists.get(&node).and_then(|s| s.sections.as_ref()) {
2777 map.invalidate();
2778 }
2779 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2780 self.toolkit.update(
2781 &handle,
2782 kinds::LIST,
2783 &day_spec::props::ListPatch::Reload as &dyn Any,
2784 None,
2785 );
2786 }
2787 }
2788
2789 fn list_splice(&mut self, node: RNode, deltas: Vec<day_spec::props::RowDelta>) {
2790 if self.lists.get(&node).is_some_and(|s| s.sections.is_some()) {
2793 self.list_reload(node);
2794 return;
2795 }
2796 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2797 self.toolkit.update(
2798 &handle,
2799 kinds::LIST,
2800 &day_spec::props::ListPatch::Splice(deltas) as &dyn Any,
2801 None,
2802 );
2803 }
2804 }
2805
2806 fn set_undo_state(&mut self, state: &day_spec::UndoState) {
2807 self.toolkit.set_undo_state(state);
2808 }
2809
2810 fn set_edit_state(&mut self, state: &day_spec::EditState) {
2811 self.toolkit.set_edit_state(state);
2812 }
2813
2814 fn modifiers(&mut self) -> day_spec::Modifiers {
2815 self.toolkit.modifiers()
2816 }
2817
2818 fn list_scroll_to_end(&mut self, node: RNode) {
2819 if self.lists.get(&node).map(|s| (s.driver.len)()).unwrap_or(0) == 0 {
2822 return;
2823 }
2824 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2825 self.toolkit.update(
2826 &handle,
2827 kinds::LIST,
2828 &day_spec::props::ListPatch::ScrollToEnd as &dyn Any,
2829 None,
2830 );
2831 }
2832 }
2833
2834 fn list_scroll_to_row(&mut self, node: RNode, row: usize) {
2835 let len = self.lists.get(&node).map(|s| (s.driver.len)()).unwrap_or(0);
2836 if len == 0 {
2837 return;
2838 }
2839 let mut row = row.min(len - 1);
2840 if let Some(map) = self.lists.get(&node).and_then(|s| s.sections.as_ref()) {
2841 row = map.display_of(row).unwrap_or(row);
2842 }
2843 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2844 self.toolkit.update(
2845 &handle,
2846 kinds::LIST,
2847 &day_spec::props::ListPatch::ScrollToRow(row) as &dyn Any,
2848 None,
2849 );
2850 }
2851 }
2852
2853 fn list_set_editing(&mut self, node: RNode, on: bool) {
2854 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2855 self.toolkit.update(
2856 &handle,
2857 kinds::LIST,
2858 &day_spec::props::ListPatch::Editing(on) as &dyn Any,
2859 None,
2860 );
2861 }
2862 }
2863
2864 fn list_set_selected(&mut self, node: RNode, rows: Vec<usize>) {
2865 let rows = match self.lists.get(&node).and_then(|s| s.sections.as_ref()) {
2866 Some(map) => rows.iter().filter_map(|i| map.display_of(*i)).collect(),
2867 None => rows,
2868 };
2869 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2870 self.toolkit.update(
2871 &handle,
2872 kinds::LIST,
2873 &day_spec::props::ListPatch::Selected(rows) as &dyn Any,
2874 None,
2875 );
2876 }
2877 }
2878
2879 fn list_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::list::ListDriver>> {
2880 self.lists.get(&node).map(|s| s.driver.clone())
2881 }
2882
2883 fn install_tree(&mut self, node: RNode, driver: crate::tree_driver::TreeDriver) {
2884 let driver = Rc::new(driver);
2885 self.trees.insert(
2886 node,
2887 crate::tree_driver::TreeState {
2888 driver: driver.clone(),
2889 cells: HashMap::new(),
2890 },
2891 );
2892 let source = crate::tree_driver::make_tree_source(node, driver);
2893 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2894 self.toolkit.attach_tree(&handle, source);
2895 }
2896 }
2897
2898 fn tree_prepare_cell(
2899 &mut self,
2900 node: RNode,
2901 key: usize,
2902 cell: RawHandle,
2903 ) -> crate::tree_driver::TreeCellStep {
2904 if let Some(state) = self.trees.get(&node)
2905 && let Some(bound) = state.cells.get(&key)
2906 {
2907 let (rebind, anchor) = (bound.rebind.clone(), bound.anchor);
2908 self.restore_subtree_ids(anchor);
2910 return crate::tree_driver::TreeCellStep::Rebind { rebind, anchor };
2911 }
2912 let handle = self.toolkit.adopt(cell);
2916 let anchor =
2917 self.create_cell_anchor(handle, Scope::child(), Rc::new(crate::layout::CellCenter));
2918 crate::tree_driver::TreeCellStep::Build { anchor }
2919 }
2920
2921 fn tree_store_cell(
2922 &mut self,
2923 node: RNode,
2924 key: usize,
2925 anchor: RNode,
2926 built: crate::tree_driver::TreeBuiltRow,
2927 ) {
2928 if let Some(state) = self.trees.get_mut(&node) {
2929 state.cells.insert(
2930 key,
2931 crate::tree_driver::TreeBoundCell {
2932 anchor,
2933 scope: built.scope,
2934 rebind: built.rebind,
2935 native_width: None,
2936 native_height: None,
2937 laid_width: None,
2938 laid_height: None,
2939 },
2940 );
2941 }
2942 }
2943
2944 fn tree_layout_cell(&mut self, node: RNode, key: usize) {
2945 let native = self
2949 .trees
2950 .get(&node)
2951 .and_then(|s| s.cells.get(&key))
2952 .and_then(|c| c.native_width);
2953 let width = native.unwrap_or_else(|| {
2954 self.nodes
2955 .get(node)
2956 .and_then(|n| n.last_native_frame)
2957 .map(|f| f.size.width)
2958 .unwrap_or(self.windows[0].size.width)
2959 });
2960 self.layout_tree_cell_at(node, key, width);
2961 }
2962
2963 fn tree_layout_cell_width(&mut self, node: RNode, key: usize, width: f64) {
2964 if let Some(cell) = self
2967 .trees
2968 .get_mut(&node)
2969 .and_then(|s| s.cells.get_mut(&key))
2970 {
2971 cell.native_width = Some(width);
2972 }
2973 self.layout_tree_cell_at(node, key, width);
2974 }
2975
2976 fn tree_cell_height(&self, node: RNode, key: usize) -> f64 {
2977 self.trees
2978 .get(&node)
2979 .and_then(|s| s.cells.get(&key))
2980 .and_then(|b| b.laid_height)
2981 .unwrap_or(0.0)
2982 }
2983
2984 fn tree_layout_cell_size(&mut self, node: RNode, key: usize, size: Size) {
2985 let changed = self
2986 .trees
2987 .get_mut(&node)
2988 .and_then(|s| s.cells.get_mut(&key))
2989 .and_then(|cell| {
2990 let changed = cell.native_height != Some(size.height);
2991 cell.native_height = Some(size.height);
2992 changed.then_some(cell.anchor)
2993 });
2994 if let Some(anchor) = changed {
2995 self.invalidate_subtree(anchor);
2996 }
2997 self.tree_layout_cell_width(node, key, size.width);
2998 }
2999
3000 fn tree_recycle_cell(&mut self, node: RNode, key: usize) {
3001 let Some(anchor) = self
3002 .trees
3003 .get(&node)
3004 .and_then(|s| s.cells.get(&key))
3005 .map(|b| b.anchor)
3006 else {
3007 return;
3008 };
3009 self.clear_subtree_ids(anchor);
3010 }
3011
3012 fn list_recycle_cell(&mut self, node: RNode, key: usize) {
3013 let Some(anchor) = self
3014 .lists
3015 .get_mut(&node)
3016 .and_then(|s| s.cells.get_mut(&key))
3017 .map(|b| {
3018 b.active = false;
3019 b.laid_height = None;
3024 b.anchor
3025 })
3026 else {
3027 return;
3028 };
3029 self.clear_subtree_ids(anchor);
3030 }
3031
3032 fn list_release_cell(&mut self, node: RNode, key: usize) {
3033 let Some(cell) = self.lists.get_mut(&node).and_then(|s| s.cells.remove(&key)) else {
3035 return;
3036 };
3037 cell.scope.dispose();
3042 self.remove_subtree_impl(cell.anchor);
3043 }
3044
3045 fn list_pin_cell(&mut self, node: RNode, key: usize) {
3046 let Some(anchor) = self
3047 .lists
3048 .get_mut(&node)
3049 .and_then(|s| s.cells.get_mut(&key))
3050 .map(|b| {
3051 b.pinned = true;
3052 b.anchor
3053 })
3054 else {
3055 return;
3056 };
3057 self.clear_subtree_ids(anchor);
3058 }
3059
3060 fn tree_reload(&mut self, node: RNode) {
3061 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3062 self.toolkit.update(
3063 &handle,
3064 kinds::TREE,
3065 &day_spec::props::TreePatch::Reload as &dyn Any,
3066 None,
3067 );
3068 }
3069 }
3070
3071 fn tree_set_expanded(&mut self, node: RNode, token: u64, expanded: bool) {
3072 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3073 self.toolkit.update(
3074 &handle,
3075 kinds::TREE,
3076 &day_spec::props::TreePatch::Expand(token, expanded) as &dyn Any,
3077 None,
3078 );
3079 }
3080 }
3081
3082 fn tree_set_selected(&mut self, node: RNode, tokens: Vec<u64>) {
3083 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3084 self.toolkit.update(
3085 &handle,
3086 kinds::TREE,
3087 &day_spec::props::TreePatch::Selected(tokens) as &dyn Any,
3088 None,
3089 );
3090 }
3091 }
3092
3093 fn tree_reveal(&mut self, node: RNode, token: u64) {
3094 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3095 self.toolkit.update(
3096 &handle,
3097 kinds::TREE,
3098 &day_spec::props::TreePatch::Reveal(token) as &dyn Any,
3099 None,
3100 );
3101 }
3102 }
3103
3104 fn tree_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::tree_driver::TreeDriver>> {
3105 self.trees.get(&node).map(|s| s.driver.clone())
3106 }
3107
3108 fn set_drag_source(&mut self, node: RNode, source: day_spec::transfer::Source) {
3109 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3110 self.toolkit.set_drag_source(&handle, source);
3111 }
3112 }
3113 fn set_drop_target(&mut self, node: RNode, target: day_spec::transfer::Target) {
3114 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3115 self.toolkit.set_drop_target(&handle, target);
3116 }
3117 }
3118 fn set_context_menu_fn(&mut self, node: RNode, f: day_spec::ContextMenuFn) {
3119 let target = if self.nodes.get(node).is_some_and(|n| n.handle.is_some()) {
3122 Some(node)
3123 } else {
3124 let mut roots = Vec::new();
3125 self.native_descendants(node, &mut roots);
3126 roots.first().copied()
3127 };
3128 let Some(target) = target else {
3129 log::warn!("context_menu_fn on a subtree with no native view — menu dropped");
3130 return;
3131 };
3132 let model = ContextMenuModel::Provider(f.clone());
3133 self.context_menus.insert(node, model.clone());
3134 self.context_menus.insert(target, model);
3135 if let Some(handle) = self.nodes.get(target).and_then(|n| n.handle.clone()) {
3136 self.toolkit
3137 .set_context_menu_fn(&handle, rnode_to_id(target), f);
3138 }
3139 }
3140
3141 fn context_menu_of(&mut self, node: RNode) -> Option<day_spec::ContextMenuFn> {
3142 let mut cur = node;
3145 loop {
3146 if let Some(model) = self.context_menus.get(&cur) {
3147 return Some(match model {
3148 ContextMenuModel::Items(items) => {
3149 let items = items.clone();
3150 Rc::new(move |_| items.clone())
3151 }
3152 ContextMenuModel::Provider(f) => f.clone(),
3153 });
3154 }
3155 let parent = self.nodes.get(cur)?.parent;
3158 if parent == cur {
3159 return None;
3160 }
3161 cur = parent;
3162 }
3163 }
3164}
3165
3166day_reactive::tls_slots! {
3171 tree;
3172 static TREE: std::mem::ManuallyDrop<RefCell<Option<Box<dyn TreeOps>>>> =
3181 const { std::mem::ManuallyDrop::new(RefCell::new(None)) };
3182 static EVENTS: RefCell<VecDeque<(NodeId, Event)>> = const { RefCell::new(VecDeque::new()) };
3183 static PUMP_PENDING: Cell<bool> = const { Cell::new(false) };
3184 static PUMP_ACTIVE: Cell<bool> = const { Cell::new(false) };
3185 static DEFERRED: RefCell<Vec<Box<dyn FnOnce() + Send>>> = const { RefCell::new(Vec::new()) };
3188 static EVENT_OBSERVER: RefCell<Option<Rc<EventObserver>>> = const { RefCell::new(None) };
3192 static PUMP_GEN: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
3197
3198 static FOCUSED: std::cell::Cell<Option<RNode>> = const { std::cell::Cell::new(None) };
3200}
3201
3202pub fn install_tree(tree: Box<dyn TreeOps>) {
3203 crate::nav::clear_controllers();
3205 TREE.with(|t| *t.borrow_mut() = Some(tree));
3206 crate::note_appearance_changed();
3208 let _ = crate::system_color(day_spec::SystemColor::Accent);
3209 let _ = crate::image::canvas_exports();
3212}
3213
3214pub fn prepare_remount() {
3232 day_reactive::recover_from_panic();
3238 uninstall_tree();
3239 day_reactive::recover_from_panic();
3241 crate::lifecycle::reset_handlers();
3242 crate::menu::reset_menus();
3243}
3244
3245pub fn is_mounted() -> bool {
3251 TREE.with(|t| t.borrow().is_some())
3252}
3253
3254pub fn uninstall_tree() {
3256 crate::image::reset();
3258 crate::nav::clear_controllers();
3259 crate::windows::reset_windows();
3260 crate::status::reset_status();
3261 crate::reset_ambient();
3264 TREE.with(|t| *t.borrow_mut() = None);
3265 EVENTS.with(|e| e.borrow_mut().clear());
3266 PUMP_PENDING.with(|c| c.set(false));
3267 EVENT_OBSERVER.with(|o| *o.borrow_mut() = None);
3270}
3271
3272pub fn with_tree<R>(f: impl FnOnce(&mut dyn TreeOps) -> R) -> R {
3276 let r = TREE.with(|t| {
3277 let mut opt = t.borrow_mut();
3278 let ops = opt.as_mut().expect("day: no tree installed on this thread");
3279 f(ops.as_mut())
3280 });
3281 if PUMP_PENDING.with(|c| c.replace(false)) {
3282 pump_events();
3283 }
3284 run_deferred();
3285 r
3286}
3287
3288pub(crate) fn run_posted_or_defer(f: Box<dyn FnOnce() + Send>) {
3295 let Ok(borrowed) = TREE.try_with(|t| t.try_borrow_mut().is_err()) else {
3298 return;
3299 };
3300 if borrowed {
3301 DEFERRED.with(|d| d.borrow_mut().push(f));
3302 } else {
3303 crate::contain_posted_panic(f);
3304 }
3305}
3306
3307fn run_deferred() {
3311 loop {
3312 let batch = DEFERRED.with(|d| std::mem::take(&mut *d.borrow_mut()));
3313 if batch.is_empty() {
3314 return;
3315 }
3316 for f in batch {
3317 crate::contain_posted_panic(f);
3318 }
3319 }
3320}
3321
3322pub fn capability(cap: day_spec::Cap) -> day_spec::Support {
3326 with_tree(|t| t.capability(cap))
3327}
3328
3329pub fn open_url(url: &str) {
3334 if crate::conformance::intercept_open_url(url) {
3337 return;
3338 }
3339 with_tree(|t| t.open_url(url));
3340}
3341
3342pub fn announce(text: &str) {
3348 crate::conformance::note_announcement(text);
3349 with_tree(|t| t.announce(text, false));
3350}
3351
3352pub fn announce_urgent(text: &str) {
3355 crate::conformance::note_announcement(text);
3356 with_tree(|t| t.announce(text, true));
3357}
3358
3359pub fn share_support() -> Support {
3361 with_tree(|t| t.share_support())
3362}
3363pub fn share_url(url: &str, title: &str) -> bool {
3367 with_tree(|t| t.share_url(url, title))
3368}
3369
3370pub fn application_handlers(
3373 query: &day_spec::applications::HandlerQuery,
3374) -> Result<day_spec::applications::ApplicationHandlers, day_spec::applications::ApplicationError> {
3375 with_tree(|t| t.application_handlers(query))
3376}
3377
3378pub fn default_browser()
3380-> Result<Option<day_spec::applications::Application>, day_spec::applications::ApplicationError> {
3381 application_handlers(&day_spec::applications::HandlerQuery::Scheme(
3382 "https".into(),
3383 ))
3384 .map(|h| h.default)
3385}
3386
3387pub async fn open_url_with_application(
3390 url: &str,
3391 application: &str,
3392) -> Result<(), day_spec::applications::ApplicationError> {
3393 let (send, receive) = day_async::oneshot();
3394 with_tree(|t| {
3395 t.open_url_with_application(url, application, Box::new(move |result| send.send(result)))
3396 });
3397 receive
3398 .await
3399 .unwrap_or(Err(day_spec::applications::ApplicationError::LaunchFailed))
3400}
3401
3402pub fn invalidate_size(node: RNode) {
3408 with_tree(|t| {
3409 t.mark_needs_measure(node);
3410 t.mark_layout_dirty();
3411 });
3412}
3413
3414pub fn try_with_tree<R>(f: impl FnOnce(&mut dyn TreeOps) -> R) -> Option<R> {
3424 let r = TREE.with(|t| {
3425 let mut opt = t.try_borrow_mut().ok()?;
3426 let ops = opt.as_mut()?;
3427 Some(f(ops.as_mut()))
3428 });
3429 if r.is_some() {
3430 if PUMP_PENDING.with(|c| c.replace(false)) {
3431 pump_events();
3432 }
3433 run_deferred();
3434 }
3435 r
3436}
3437
3438pub(crate) fn with_tree_if_free<R>(f: impl FnOnce(&mut dyn TreeOps) -> R) -> Option<R> {
3441 TREE.with(|t| {
3442 let mut opt = t.try_borrow_mut().ok()?;
3443 let ops = opt.as_mut()?;
3444 Some(f(ops.as_mut()))
3445 })
3446}
3447
3448pub(crate) fn tree_absent() -> bool {
3451 TREE.try_with(|t| t.try_borrow().map(|o| o.is_none()).unwrap_or(false))
3453 .unwrap_or(true)
3454}
3455
3456pub(crate) fn request_pump() {
3459 PUMP_PENDING.with(|c| c.set(true));
3460}
3461
3462pub fn has_tree() -> bool {
3463 !tree_absent()
3466}
3467
3468pub fn enqueue_event(id: NodeId, ev: Event) {
3471 enqueue_events([(id, ev)]);
3472}
3473
3474pub(crate) fn enqueue_native_event(id: NodeId, ev: Event) {
3479 if let Some(ev) = crate::list::translate_native_event(id, ev) {
3480 enqueue_event(id, ev);
3481 }
3482}
3483
3484pub fn enqueue_events(evs: impl IntoIterator<Item = (NodeId, Event)>) {
3489 let observer = EVENT_OBSERVER.with(|o| o.borrow().clone());
3498 match observer {
3499 Some(obs) => {
3500 let batch: Vec<(NodeId, Event)> = evs.into_iter().collect();
3501 for (id, ev) in &batch {
3502 obs(*id, ev);
3503 }
3504 EVENTS.with(|e| e.borrow_mut().extend(batch));
3505 }
3506 None => EVENTS.with(|e| e.borrow_mut().extend(evs)),
3507 }
3508 let tree_free = TREE.with(|t| t.try_borrow_mut().is_ok());
3509 if tree_free {
3510 pump_events();
3511 } else {
3512 PUMP_PENDING.with(|c| c.set(true));
3513 }
3514}
3515
3516pub fn pump_generation() -> u64 {
3518 PUMP_GEN.with(|g| g.get())
3519}
3520
3521pub fn set_event_observer(observer: Option<Box<EventObserver>>) {
3530 EVENT_OBSERVER.with(|o| *o.borrow_mut() = observer.map(Rc::from));
3531}
3532
3533pub fn id_of(node: NodeId) -> Option<String> {
3540 try_with_tree(|t| t.node_id(id_to_rnode(node))).flatten()
3541}
3542
3543pub fn label_of(node: NodeId) -> Option<String> {
3547 try_with_tree(|t| {
3548 let rnode = id_to_rnode(node);
3549 let a11y = t
3550 .node_a11y(rnode)
3551 .and_then(|a| a.label)
3552 .filter(|s| !s.is_empty());
3553 a11y.or_else(|| {
3554 t.node_probe(rnode)
3555 .map(|p| p.text)
3556 .filter(|s| !s.is_empty())
3557 })
3558 })
3559 .flatten()
3560}
3561
3562pub fn pump_events() {
3570 if PUMP_ACTIVE.with(|active| active.replace(true)) {
3574 return;
3575 }
3576 struct PumpGuard;
3577 impl Drop for PumpGuard {
3578 fn drop(&mut self) {
3579 PUMP_ACTIVE.with(|active| active.set(false));
3580 }
3581 }
3582 let _guard = PumpGuard;
3583 let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
3584 loop {
3585 pump_events_inner();
3586 if EVENTS.with(|events| events.borrow().is_empty()) {
3589 break;
3590 }
3591 }
3592 }));
3593 if let Err(payload) = result {
3594 let msg = payload
3595 .downcast_ref::<&str>()
3596 .map(|s| (*s).to_string())
3597 .or_else(|| payload.downcast_ref::<String>().cloned())
3598 .unwrap_or_else(|| "unknown panic".to_string());
3599 log::warn!(
3600 "a native event handler panicked and was contained — the app continues, but \
3601 reactive/UI state may be inconsistent until the next interaction. Cause: {msg}"
3602 );
3603 EVENTS.with(|e| e.borrow_mut().clear());
3605 PUMP_PENDING.with(|c| c.set(false));
3606 day_reactive::recover_from_panic();
3607 crate::notify_contained_panic();
3608 }
3609}
3610
3611fn pump_events_inner() {
3612 crate::image::flush_deferred_releases();
3614 PUMP_GEN.with(|g| g.set(g.get() + 1));
3619 crate::nav::maybe_notify_route_change();
3620 loop {
3621 let item = EVENTS.with(|e| e.borrow_mut().pop_front());
3622 let Some((id, ev)) = item else { break };
3623 if let Event::PresentResult { req, result } = ev {
3625 crate::present::resolve_presentation(req, result);
3626 continue;
3627 }
3628 if let Event::ImageDecoded { req, result } = ev {
3631 crate::image::resolve_image_decode(req, result);
3632 continue;
3633 }
3634 if let Event::ImageEncoded { req, result } = ev {
3635 crate::image::resolve_image_encode(req, result);
3636 continue;
3637 }
3638 if let Event::BitmapRendered { req, result } = ev {
3640 crate::image::resolve_bitmap_render(req, result);
3641 continue;
3642 }
3643 if let Event::PdfRendered { req, result } = ev {
3644 crate::image::resolve_pdf_render(req, result);
3645 continue;
3646 }
3647 if let Event::MenuAction(action) = ev {
3649 crate::menu::dispatch_menu_action(action);
3650 continue;
3651 }
3652 if let Event::ToolbarChanged { action, value } = &ev {
3655 crate::toolbar::dispatch_toolbar_value(*action, value);
3656 continue;
3657 }
3658 if let Event::Lifecycle(phase) = ev {
3660 crate::lifecycle::dispatch_lifecycle(phase);
3661 continue;
3662 }
3663 if ev == Event::FocusChanged(false) {
3668 let paired = EVENTS.with(|e| {
3669 let mut q = e.borrow_mut();
3670 let gain = q
3671 .iter()
3672 .position(|(gid, gev)| *gid != id && *gev == Event::FocusChanged(true));
3673 gain.map(|i| q.remove(i).expect("indexed event"))
3674 });
3675 if let Some((gid, gev)) = paired {
3676 dispatch_focus_probe(gid, &gev);
3677 dispatch_to_node(gid, &gev);
3678 }
3679 }
3680 if let Event::FocusChanged(_) = ev {
3681 dispatch_focus_probe(id, &ev);
3682 }
3683 dispatch_to_node(id, &ev);
3684 }
3685 day_reactive::flush_sync();
3686 crate::nav::maybe_notify_route_change();
3693}
3694
3695pub fn focused_node() -> Option<RNode> {
3699 FOCUSED.with(|f| f.get())
3700}
3701
3702fn dispatch_focus_probe(id: NodeId, ev: &Event) {
3704 if let Event::FocusChanged(f) = ev {
3705 let node = id_to_rnode(id);
3706 with_tree(|t| t.set_probe_focused(node, *f));
3707 }
3708}
3709
3710pub fn scroll_to(node: RNode, target: ScrollTarget) {
3715 with_tree(|t| {
3716 t.scroll_to_target(node, &target, true);
3717 });
3718}
3719
3720fn dispatch_to_node(id: NodeId, ev: &Event) {
3722 let node = if id == day_spec::WINDOW_NODE {
3723 with_tree(|t| t.root_node())
3724 } else {
3725 id_to_rnode(id)
3726 };
3727 let gesture = match ev {
3733 Event::Tap(_) => Some(day_spec::GestureKind::Tap),
3734 Event::LongPress(_) => Some(day_spec::GestureKind::LongPress),
3735 Event::Drag { .. } => Some(day_spec::GestureKind::Drag),
3736 Event::Pan { .. } => Some(day_spec::GestureKind::Pan),
3737 Event::Pinch { .. } => Some(day_spec::GestureKind::Pinch),
3738 Event::Rotate { .. } => Some(day_spec::GestureKind::Rotate),
3739 Event::Hover { .. } => Some(day_spec::GestureKind::Hover),
3740 _ => None,
3741 };
3742 let node = match gesture.and_then(|k| with_tree(|t| t.gesture_target(node, k))) {
3743 Some(target) => target,
3744 None => node,
3745 };
3746 let mut handlers = with_tree(|t| t.handlers_for(node));
3747 if matches!(ev, Event::Key(_) | Event::FocusChanged(_)) {
3752 with_tree(|t| {
3753 for w in t.wrappers_above(node) {
3754 handlers.extend(t.handlers_for(w));
3755 }
3756 });
3757 }
3758 if handlers.is_empty() {
3759 if cfg!(debug_assertions)
3763 && matches!(ev, Event::Pressed | Event::Tap(_))
3764 && !with_tree(|t| t.node_exists(node))
3765 {
3766 log::warn!("{ev:?} dropped — node {id:?} no longer exists (stale reference)");
3767 }
3768 return;
3769 }
3770 day_reactive::batch(|| {
3771 for h in &handlers {
3772 h(ev);
3773 }
3774 });
3775}
3776
3777fn collect_menu_families(
3778 items: &[day_spec::MenuItem],
3779 families: &mut std::collections::BTreeSet<String>,
3780) {
3781 for item in items {
3782 match item {
3783 day_spec::MenuItem::Action { id: Some(id), .. } => {
3784 families.insert(crate::element_id::family_of(id).to_owned());
3785 }
3786 day_spec::MenuItem::Submenu { items, .. } => collect_menu_families(items, families),
3787 _ => {}
3788 }
3789 }
3790}
3791
3792#[cfg(test)]
3793mod thread_exit_tests {
3794 use super::*;
3795 use std::sync::Arc;
3796 use std::sync::atomic::{AtomicBool, Ordering};
3797
3798 struct Probe(Arc<AtomicBool>);
3800
3801 impl Drop for Probe {
3802 fn drop(&mut self) {
3803 self.0.store(true, Ordering::SeqCst);
3804 }
3805 }
3806
3807 impl Toolkit for Probe {
3808 type Handle = ();
3809 fn realize(&mut self, _: PieceKind, _: &dyn Any, _: NodeId) -> Self::Handle {}
3810 fn release(&mut self, _: Self::Handle) {}
3811 fn insert(&mut self, _: &Self::Handle, _: &Self::Handle, _: usize) {}
3812 fn remove(&mut self, _: &Self::Handle, _: &Self::Handle) {
3813 panic!("test probe has no attached children to remove");
3814 }
3815 fn move_child(&mut self, _: &Self::Handle, _: &Self::Handle, _: usize) {}
3816 fn measure(&mut self, _: &Self::Handle, _: PieceKind, _: Proposal) -> Size {
3817 Size::new(0.0, 0.0)
3818 }
3819 fn set_frame(&mut self, _: &Self::Handle, _: Rect, _: Option<&AnimSpec>) {}
3820 fn set_input_traits(&mut self, _: &Self::Handle, _: &InputTraits) -> Option<Self::Handle> {
3821 None
3822 }
3823 fn set_event_sink(&mut self, _: EventSink) {}
3824 fn update(&mut self, _: &Self::Handle, _: &'static str, _: &dyn Any, _: Option<&AnimSpec>) {
3825 }
3826 }
3827
3828 fn install_probe(dropped: &Arc<AtomicBool>) {
3829 let tree = Tree::new(Probe(dropped.clone()), (), Size::new(0.0, 0.0));
3830 install_tree(Box::new(tree));
3831 }
3832
3833 #[test]
3838 fn the_tree_is_not_dropped_when_its_thread_ends() {
3839 let dropped = Arc::new(AtomicBool::new(false));
3840 let d = dropped.clone();
3841 std::thread::spawn(move || install_probe(&d))
3842 .join()
3843 .expect("thread");
3844 assert!(
3845 !dropped.load(Ordering::SeqCst),
3846 "the thread-local destructor dropped the tree, and with it the native widgets"
3847 );
3848 }
3849
3850 #[test]
3853 fn uninstall_still_drops_the_tree() {
3854 let dropped = Arc::new(AtomicBool::new(false));
3855 let d = dropped.clone();
3856 std::thread::spawn(move || {
3857 install_probe(&d);
3858 uninstall_tree();
3859 assert!(
3860 d.load(Ordering::SeqCst),
3861 "uninstall_tree must drop the tree"
3862 );
3863 })
3864 .join()
3865 .expect("thread");
3866 }
3867
3868 #[test]
3869 fn removing_an_unattached_node_releases_without_native_detach() {
3870 let dropped = Arc::new(AtomicBool::new(false));
3871 let mut tree = Tree::new(Probe(dropped), (), Size::new(0.0, 0.0));
3872 let scope = Scope::detached();
3873 let node = tree.create_node(
3874 "fixture.detached",
3875 &(),
3876 Rc::new(crate::LeafLayout),
3877 Flex::default(),
3878 true,
3879 false,
3880 scope,
3881 );
3882 tree.remove_subtree(node);
3883 assert!(!tree.node_exists(node));
3884 assert_eq!(
3885 tree.release_queue.len(),
3886 1,
3887 "the unattached native handle must still be released"
3888 );
3889 scope.dispose();
3890 }
3891
3892 #[test]
3897 fn a_post_during_a_tree_borrow_runs_at_the_safe_point() {
3898 std::thread::spawn(|| {
3899 install_probe(&Arc::new(AtomicBool::new(false)));
3900 let ran = Arc::new(AtomicBool::new(false));
3901 let r = ran.clone();
3902 with_tree(|_| {
3903 run_posted_or_defer(Box::new(move || {
3904 with_tree(|_| r.store(true, Ordering::SeqCst));
3907 }));
3908 assert!(!ran.load(Ordering::SeqCst), "ran inside the borrow");
3909 });
3910 assert!(
3911 ran.load(Ordering::SeqCst),
3912 "never ran after the borrow was released"
3913 );
3914 let now = Arc::new(AtomicBool::new(false));
3916 let n = now.clone();
3917 run_posted_or_defer(Box::new(move || n.store(true, Ordering::SeqCst)));
3918 assert!(
3919 now.load(Ordering::SeqCst),
3920 "a post with the tree free must run at once"
3921 );
3922 uninstall_tree();
3923 })
3924 .join()
3925 .expect("thread");
3926 }
3927}