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 value: f64,
74 pub flag: bool,
75 pub selected: i64,
76 pub options: Vec<String>,
79 pub enabled: bool,
80 pub focused: bool,
82}
83
84pub struct NodeData<H> {
85 pub kind: PieceKind,
86 pub handle: Option<H>,
87 pub parent: RNode,
88 pub children: Vec<RNode>,
89 pub layout: Rc<dyn Layout>,
90 pub flex: Flex,
91 pub scope: Scope,
92 pub id: Option<String>,
93 pub parked_id: Option<String>,
99 pub a11y: day_spec::A11yProps,
103 pub cache: Vec<((u64, u64), Size)>,
105 pub baseline_cache: Option<((u64, u64), Option<f64>)>,
109 pub probe: NodeProbe,
110 pub needs_measure: bool,
111 pub needs_layout: bool,
114 pub last_native_frame: Option<Rect>,
115 pub is_boundary: bool,
116 pub scroll_content: Option<Size>,
119 pub implicit_anim: Option<day_spec::AnimSpec>,
123 pub tweaked: bool,
127}
128
129pub type EventHandler = Rc<dyn Fn(&Event)>;
131
132pub type EventObserver = dyn Fn(NodeId, &Event);
135
136#[derive(Clone, Copy, PartialEq, Eq, Debug)]
139pub enum WindowRootReply {
140 Open(RNode),
142 Pending(RNode),
145 Unsupported,
147}
148
149struct WindowEntry {
157 root: RNode,
158 size: Size,
159}
160
161#[derive(Clone)]
163enum ContextMenuModel {
164 Items(Vec<day_spec::MenuItem>),
165 Provider(day_spec::ContextMenuFn),
166}
167
168pub struct Tree<B: Toolkit> {
169 mounted_id_families: std::collections::BTreeSet<String>,
170 pub toolkit: B,
171 nodes: SlotMap<RNode, NodeData<B::Handle>>,
172 windows: Vec<WindowEntry>,
173 layout_dirty: bool,
174 handlers: HashMap<RNode, Vec<EventHandler>>,
175 gestures: HashMap<RNode, Vec<day_spec::GestureKind>>,
178 element_outer: HashMap<RNode, RNode>,
181 release_queue: Vec<(day_spec::PieceKind, B::Handle)>,
184 lists: HashMap<RNode, crate::list::ListState>,
186 trees: HashMap<RNode, crate::tree_driver::TreeState>,
187 context_menus: HashMap<RNode, ContextMenuModel>,
191 implicit_anim_count: usize,
194}
195
196impl<B: Toolkit> Tree<B> {
197 fn clear_subtree_ids(&mut self, anchor: RNode) {
202 let mut stack = vec![anchor];
203 while let Some(n) = stack.pop() {
204 if let Some(d) = self.nodes.get_mut(n) {
205 if let Some(id) = d.id.take() {
206 d.parked_id = Some(id);
207 }
208 stack.extend(d.children.iter().copied());
209 }
210 }
211 }
212
213 fn restore_subtree_ids(&mut self, anchor: RNode) {
217 let mut stack = vec![anchor];
218 while let Some(n) = stack.pop() {
219 if let Some(d) = self.nodes.get_mut(n) {
220 if let Some(id) = d.parked_id.take()
221 && d.id.is_none()
222 {
223 d.id = Some(id);
224 }
225 stack.extend(d.children.iter().copied());
226 }
227 }
228 }
229
230 pub fn new(toolkit: B, root_handle: B::Handle, window_size: Size) -> Self {
231 let mut nodes = SlotMap::with_key();
232 let root = nodes.insert(NodeData {
233 kind: kinds::CONTAINER,
234 handle: Some(root_handle),
235 parent: RNode::null(),
236 children: Vec::new(),
237 layout: Rc::new(PassThrough),
238 flex: Flex::default(),
239 scope: Scope::root(),
240 id: None,
241 parked_id: None,
242 a11y: Default::default(),
243 cache: Vec::new(),
244 baseline_cache: None,
245 probe: NodeProbe::default(),
246 needs_measure: true,
247 needs_layout: true,
248 last_native_frame: None,
249 scroll_content: None,
250 implicit_anim: None,
251 tweaked: false,
252 is_boundary: true,
253 });
254 Tree {
255 mounted_id_families: Default::default(),
256 toolkit,
257 nodes,
258 windows: vec![WindowEntry {
259 root,
260 size: window_size,
261 }],
262 layout_dirty: true,
263 handlers: HashMap::new(),
264 gestures: HashMap::new(),
265 element_outer: HashMap::new(),
266 release_queue: Vec::new(),
267 lists: HashMap::new(),
268 trees: HashMap::new(),
269 context_menus: HashMap::new(),
270 implicit_anim_count: 0,
271 }
272 }
273
274 pub(crate) fn create_cell_anchor(
277 &mut self,
278 handle: B::Handle,
279 scope: Scope,
280 layout: Rc<dyn Layout>,
281 ) -> RNode {
282 self.nodes.insert(NodeData {
283 kind: kinds::LIST_CELL,
284 handle: Some(handle),
285 parent: RNode::null(),
286 children: Vec::new(),
287 layout,
288 flex: Flex::default(),
289 scope,
290 id: None,
291 parked_id: None,
292 a11y: Default::default(),
293 cache: Vec::new(),
294 baseline_cache: None,
295 probe: NodeProbe::default(),
296 needs_measure: true,
297 needs_layout: true,
298 last_native_frame: None,
299 scroll_content: None,
300 implicit_anim: None,
301 tweaked: false,
302 is_boundary: true,
303 })
304 }
305
306 pub fn root(&self) -> RNode {
307 self.windows[0].root
308 }
309
310 pub(crate) fn node(&self, n: RNode) -> Option<&NodeData<B::Handle>> {
311 self.nodes.get(n)
312 }
313 pub(crate) fn node_mut(&mut self, n: RNode) -> Option<&mut NodeData<B::Handle>> {
314 self.nodes.get_mut(n)
315 }
316
317 pub(crate) fn resolve_anim(&self, node: RNode) -> Option<day_spec::AnimSpec> {
322 if crate::reduce_motion_now() {
325 return None;
326 }
327 if let Some(a) = crate::anim::current_anim() {
328 return Some(a);
329 }
330 if self.implicit_anim_count == 0 {
331 return None;
332 }
333 let mut cur = node;
334 loop {
335 let n = self.nodes.get(cur)?;
336 if n.implicit_anim.is_some() {
337 return n.implicit_anim;
338 }
339 if n.parent == cur {
340 return None;
341 }
342 cur = n.parent;
343 }
344 }
345
346 fn native_ancestor(&self, mut n: RNode) -> RNode {
348 loop {
349 let Some(node) = self.nodes.get(n) else {
350 return self.windows[0].root;
353 };
354 if node.handle.is_some() {
355 return n;
356 }
357 n = node.parent;
358 }
359 }
360
361 fn native_descendants(&self, container: RNode, out: &mut Vec<RNode>) {
363 let Some(node) = self.nodes.get(container) else {
364 return;
365 };
366 for &c in &node.children {
367 match self.nodes.get(c) {
368 Some(cd) if cd.handle.is_some() => out.push(c),
369 Some(_) => self.native_descendants(c, out),
370 None => {}
371 }
372 }
373 }
374
375 fn native_index_for(&self, ancestor: RNode, target: RNode) -> usize {
378 fn walk<B: Toolkit>(tree: &Tree<B>, n: RNode, target: RNode, count: &mut usize) -> bool {
379 if n == target {
380 return true;
381 }
382 let Some(node) = tree.nodes.get(n) else {
383 return false;
384 };
385 if node.handle.is_some() && n != target {
386 *count += 1;
388 return false;
389 }
390 for &c in &node.children {
391 if walk(tree, c, target, count) {
392 return true;
393 }
394 }
395 false
396 }
397 let mut count = 0;
398 let Some(anc) = self.nodes.get(ancestor) else {
399 return 0;
400 };
401 for &c in &anc.children {
402 if c == target || self.subtree_contains(c, target) {
403 let mut cnt = count;
405 walk(self, c, target, &mut cnt);
406 return cnt;
407 }
408 let mut roots = Vec::new();
409 match self.nodes.get(c) {
410 Some(cd) if cd.handle.is_some() => count += 1,
411 Some(_) => {
412 self.native_descendants(c, &mut roots);
413 count += roots.len();
414 }
415 None => {}
416 }
417 }
418 count
419 }
420
421 fn subtree_contains(&self, root: RNode, target: RNode) -> bool {
422 if root == target {
423 return true;
424 }
425 let Some(node) = self.nodes.get(root) else {
426 return false;
427 };
428 node.children
429 .iter()
430 .any(|&c| self.subtree_contains(c, target))
431 }
432
433 fn attach_impl(&mut self, parent: RNode, child: RNode, index: usize) {
435 {
436 let p = self
437 .nodes
438 .get_mut(parent)
439 .expect("attach to missing parent");
440 let idx = index.min(p.children.len());
441 p.children.insert(idx, child);
442 }
443 self.nodes
444 .get_mut(child)
445 .expect("attach missing child")
446 .parent = parent;
447 let ancestor = self.native_ancestor(parent);
450 let anc_handle = self.nodes[ancestor]
451 .handle
452 .clone()
453 .expect("native ancestor");
454 let mut roots = Vec::new();
455 match self.nodes.get(child) {
456 Some(cd) if cd.handle.is_some() => roots.push(child),
457 Some(_) => self.native_descendants(child, &mut roots),
458 None => {}
459 }
460 for r in roots {
461 let idx = self.native_index_for(ancestor, r);
462 let h = self.nodes[r].handle.clone().unwrap();
463 self.toolkit.insert(&anc_handle, &h, idx);
464 }
465 self.mark_needs_measure_impl(parent);
466 }
467
468 fn remove_subtree_impl(&mut self, node: RNode) {
469 let parent = self
472 .nodes
473 .get(node)
474 .map(|n| n.parent)
475 .unwrap_or(RNode::null());
476 if let Some(p) = self.nodes.get_mut(parent) {
477 p.children.retain(|&c| c != node);
478 }
479 let anc_handle = if parent.is_null() {
483 None
484 } else {
485 let ancestor = self.native_ancestor(parent);
486 self.nodes.get(ancestor).and_then(|n| n.handle.clone())
487 };
488 let mut roots = Vec::new();
489 match self.nodes.get(node) {
490 Some(nd) if nd.handle.is_some() => roots.push(node),
491 Some(_) => self.native_descendants(node, &mut roots),
492 None => {}
493 }
494 if let Some(anc_handle) = anc_handle {
495 for r in &roots {
496 let h = self.nodes[*r].handle.clone().unwrap();
497 self.toolkit.remove(&anc_handle, &h);
498 }
499 }
500 self.collect_and_release(node);
501 if parent.is_null() {
502 self.layout_dirty = true;
503 } else {
504 self.mark_needs_measure_impl(parent);
505 }
506 }
507
508 fn collect_and_release(&mut self, start: RNode) {
513 let mut stack = vec![start];
514 while let Some(n) = stack.pop() {
515 self.context_menus.remove(&n);
520 if let Some(list) = self.lists.remove(&n) {
521 for (_, cell) in list.cells {
522 cell.scope.dispose();
523 stack.push(cell.anchor);
528 }
529 }
530 if let Some(tree) = self.trees.remove(&n) {
532 for (_, cell) in tree.cells {
533 cell.scope.dispose();
534 stack.push(cell.anchor);
535 }
536 }
537 let Some(data) = self.nodes.remove(n) else {
538 continue;
539 };
540 self.handlers.remove(&n);
541 self.gestures.remove(&n);
542 self.element_outer.remove(&n);
543 day_spec::keys::forget(rnode_to_id(n));
544 if data.implicit_anim.is_some() {
545 self.implicit_anim_count = self.implicit_anim_count.saturating_sub(1);
546 }
547 if let Some(h) = data.handle {
548 if data.kind != kinds::LIST_CELL {
554 self.release_queue.push((data.kind, h));
555 }
556 }
557 stack.extend(data.children);
558 }
559 }
560
561 fn mark_needs_measure_impl(&mut self, node: RNode) {
562 let mut cur = node;
563 let mut measure = true;
564 while let Some(n) = self.nodes.get_mut(cur) {
565 n.needs_layout = true;
566 if measure {
567 n.needs_measure = true;
568 n.cache.clear();
569 }
570 if n.is_boundary {
571 measure = false;
572 }
573 if n.parent.is_null() {
574 break;
575 }
576 cur = n.parent;
577 }
578 self.layout_dirty = true;
579 }
580
581 fn invalidate_subtree(&mut self, node: RNode) {
587 let mut stack = vec![node];
588 while let Some(cur) = stack.pop() {
589 if let Some(n) = self.nodes.get_mut(cur) {
590 n.needs_measure = true;
591 n.cache.clear();
592 stack.extend(n.children.iter().copied());
593 }
594 }
595 }
596
597 fn layout_list_cell_at(&mut self, node: RNode, key: usize, width: f64) {
601 let Some(state) = self.lists.get(&node) else {
602 return;
603 };
604 let (anchor, stale, header) = match state.cells.get(&key) {
605 Some(b) if b.active => (b.anchor, b.laid_width != Some(width), b.header),
606 _ => return,
607 };
608 let row_height = if header {
611 day_spec::props::RowHeight::Automatic
612 } else {
613 state.driver.row_height
614 };
615 if stale {
620 self.invalidate_subtree(anchor);
621 if let Some(b) = self
622 .lists
623 .get_mut(&node)
624 .and_then(|s| s.cells.get_mut(&key))
625 {
626 b.laid_width = Some(width);
627 }
628 }
629 let height = match row_height {
630 day_spec::props::RowHeight::Uniform(h) => h,
631 day_spec::props::RowHeight::Automatic => {
632 crate::layout::measure_node(self, anchor, Proposal::new(Some(width), None)).height
633 }
634 };
635 let previous = self
636 .lists
637 .get_mut(&node)
638 .and_then(|s| s.cells.get_mut(&key))
639 .and_then(|b| b.laid_height.replace(height));
640 if previous.is_some_and(|p| (p - height).abs() > 0.25)
644 && let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone())
645 {
646 self.toolkit.update(
647 &handle,
648 kinds::LIST,
649 &day_spec::props::ListPatch::RowSizeInvalidated { cell: key, height } as &dyn Any,
650 None,
651 );
652 }
653 crate::layout::place_node(
654 self,
655 anchor,
656 Rect::new(0.0, 0.0, width, height),
657 Point::ZERO,
658 true,
659 );
660 self.nodes[anchor].needs_measure = false;
664 }
665
666 fn layout_tree_cell_at(&mut self, node: RNode, key: usize, width: f64) {
669 let Some(state) = self.trees.get(&node) else {
670 return;
671 };
672 let (anchor, stale) = match state.cells.get(&key) {
673 Some(b) => (b.anchor, b.laid_width != Some(width)),
674 None => return,
675 };
676 let row_height = state.driver.row_height;
677 let native_height = state.cells.get(&key).and_then(|b| b.native_height);
678 if stale {
679 self.invalidate_subtree(anchor);
680 if let Some(b) = self
681 .trees
682 .get_mut(&node)
683 .and_then(|s| s.cells.get_mut(&key))
684 {
685 b.laid_width = Some(width);
686 }
687 }
688 let height = native_height.unwrap_or_else(|| match row_height {
689 day_spec::props::RowHeight::Uniform(h) => h,
690 day_spec::props::RowHeight::Automatic => {
691 crate::layout::measure_node(self, anchor, Proposal::new(Some(width), None)).height
692 }
693 });
694 if let Some(b) = self
695 .trees
696 .get_mut(&node)
697 .and_then(|s| s.cells.get_mut(&key))
698 {
699 b.laid_height = Some(height);
700 }
701 crate::layout::place_node(
702 self,
703 anchor,
704 Rect::new(0.0, 0.0, width, height),
705 Point::ZERO,
706 true,
707 );
708 self.nodes[anchor].needs_measure = false;
709 }
710
711 fn layout_now(&mut self) {
712 for i in 0..self.windows.len() {
715 let (root, size) = (self.windows[i].root, self.windows[i].size);
716 let p = Proposal::exact(size);
717 crate::layout::measure_node(self, root, p);
718 crate::layout::place_node(self, root, Rect::from_size(size), Point::ZERO, true);
719 }
720 let dirty_cells: Vec<(RNode, usize)> = self
726 .lists
727 .iter()
728 .flat_map(|(list, state)| {
729 state.cells.iter().filter_map(|(key, cell)| {
730 if !cell.active {
731 return None;
732 }
733 self.nodes
734 .get(cell.anchor)
735 .filter(|n| n.needs_layout)
736 .map(|_| (*list, *key))
737 })
738 })
739 .collect();
740 let dirty_tree_cells: Vec<(RNode, usize)> = self
741 .trees
742 .iter()
743 .flat_map(|(tree, state)| {
744 state.cells.iter().filter_map(|(key, cell)| {
745 self.nodes
746 .get(cell.anchor)
747 .filter(|n| n.needs_layout)
748 .map(|_| (*tree, *key))
749 })
750 })
751 .collect();
752 for (tree, key) in dirty_tree_cells {
753 self.tree_layout_cell(tree, key);
754 }
755 for (list, key) in dirty_cells {
756 self.list_layout_cell(list, key);
757 }
758 let queue = std::mem::take(&mut self.release_queue);
759 for (kind, h) in queue {
760 self.toolkit.release_piece(kind, &h);
763 self.toolkit.release(h);
764 }
765 }
766}
767
768#[derive(Clone, Debug, PartialEq)]
777pub enum ScrollTarget {
778 Top,
779 Bottom,
780 Leading,
781 Trailing,
782 Offset(Point),
783 Id(String),
784}
785
786pub trait TreeOps {
787 #[allow(clippy::too_many_arguments)]
790 fn create_node(
791 &mut self,
792 kind: PieceKind,
793 props: &dyn Any,
794 layout: Rc<dyn Layout>,
795 flex: Flex,
796 native: bool,
797 is_boundary: bool,
798 scope: Scope,
799 ) -> RNode;
800 fn attach(&mut self, parent: RNode, child: RNode);
801 fn reparent(&mut self, child: RNode, parent: RNode) -> bool;
803 fn native_window_tabs(&self) -> bool;
804 fn native_document_tabs(&self) -> bool;
805 fn group_windows(&mut self, roots: &[RNode]);
806 fn window_tab_order(&self, root: RNode) -> Vec<day_spec::NodeId>;
807
808 fn attach_at(&mut self, parent: RNode, child: RNode, index: usize);
809 fn reorder_children(&mut self, parent: RNode, order: Vec<RNode>);
810 fn remove_subtree(&mut self, node: RNode);
811 fn node_exists(&self, node: RNode) -> bool;
813 fn dark_mode(&mut self) -> bool;
815 fn reduce_motion(&mut self) -> bool;
817 fn set_appearance(&mut self, dark: Option<bool>);
819 fn set_app_badge(&mut self, badge: &day_spec::AppBadge);
821 fn on_event(&mut self, node: RNode, h: EventHandler);
822 fn handlers_for(&self, node: RNode) -> Vec<EventHandler>;
823 fn native_view_of(&self, node: RNode) -> Option<RNode>;
827 fn wrappers_above(&self, node: RNode) -> Vec<RNode>;
830 fn gesture_target(&self, node: RNode, kind: day_spec::GestureKind) -> Option<RNode>;
838 fn set_element_outer(&mut self, inner: RNode, outer: RNode);
842 fn set_id(&mut self, node: RNode, id: String);
843 fn mounted_id_families(&self) -> Vec<String>;
845 fn set_grid_facts(&mut self, node: RNode, facts: GridFacts);
848 fn forward_whole_row(&mut self, wrapper: RNode, inner: RNode);
851 fn set_a11y(&mut self, node: RNode, a11y: A11yProps);
852 fn announce(&mut self, text: &str, urgent: bool);
854 fn enable_gesture(&mut self, node: RNode, kind: day_spec::GestureKind);
857 fn focus_node(&mut self, node: RNode, focused: bool);
859 fn set_focusable(&mut self, node: RNode, focusable: bool);
862 fn set_probe_focused(&mut self, node: RNode, focused: bool);
864 fn set_probe_selected(&mut self, node: RNode, selected: Option<usize>);
869 fn set_probe_value(&mut self, node: RNode, value: f64, text: String);
874 fn set_app_menu(&mut self, items: Vec<day_spec::MenuItem>);
875 fn set_context_menu(&mut self, node: RNode, items: Vec<day_spec::MenuItem>);
876 fn edit_window_toolbar(&mut self, root: RNode, ops: Vec<day_spec::ToolbarOp>) -> bool;
881 fn patch_window_toolbar(&mut self, root: RNode, patch: day_spec::ToolbarPatch) -> bool;
883 fn scroll_to_target(&mut self, node: RNode, target: &ScrollTarget, animated: bool) -> bool;
888 fn scroll_reveal(&mut self, node: RNode, animated: bool) -> bool;
891 fn patch(&mut self, node: RNode, patch: Box<dyn Any>, affects_size: bool);
892 fn replay(&mut self, node: RNode, ops: Vec<DrawOp>);
893 fn request_frame(&mut self, root: RNode, cb: day_spec::FrameCallback) -> day_spec::CancelFrame;
894 fn set_implicit_anim(&mut self, node: RNode, anim: Option<day_spec::AnimSpec>);
898 fn set_node_opacity(&mut self, node: RNode, opacity: f64);
901 fn set_node_transform(&mut self, node: RNode, t: day_spec::Transform);
904 fn set_node_selectable(&mut self, node: RNode, selectable: bool);
907 fn set_node_input_traits(&mut self, node: RNode, traits: &day_spec::InputTraits);
911 fn set_node_cursor(&mut self, node: RNode, cursor: day_spec::Cursor);
914 fn set_node_drag_region(&mut self, node: RNode, drag: bool);
917 fn note_node_tweaked(&mut self, node: RNode) {
921 let _ = node;
922 }
923 fn mark_needs_measure(&mut self, node: RNode);
924 fn mark_layout_dirty(&mut self);
925 fn invalidate_all_measurements(&mut self);
929 fn layout_if_needed(&mut self);
930 fn set_window_size(&mut self, s: Size);
931 fn set_route(&mut self, route: &str);
935 fn child_count(&self, node: RNode) -> usize;
936 fn first_child(&self, node: RNode) -> Option<RNode>;
937 fn parent_of(&self, node: RNode) -> Option<RNode>;
940 fn node_kind(&self, node: RNode) -> Option<PieceKind>;
941 fn node_id(&self, node: RNode) -> Option<String>;
944 fn node_handle_any(&self, node: RNode) -> Option<Box<dyn Any>>;
950 fn node_frame(&self, node: RNode) -> Option<Rect>;
951 fn node_probe(&self, node: RNode) -> Option<NodeProbe>;
952 fn node_a11y(&self, node: RNode) -> Option<A11yProps>;
954 fn read_native(&self, node: RNode) -> Option<day_spec::NativeSnapshot>;
957 fn a11y_nodes(&self) -> Vec<(String, PieceKind, A11yProps, day_spec::NativeSnapshot)>;
960 fn find_by_id(&self, id: &str) -> Option<RNode>;
961 fn toggle_sidebar(&mut self, _host: RNode) -> bool {
966 false
967 }
968 fn native_back(&mut self) -> bool {
972 false
973 }
974 fn prepare_snapshot(
975 &mut self,
976 root: Option<RNode>,
977 revision: u32,
978 ) -> Result<day_spec::capture::Readiness, String>;
979 fn snapshot(&mut self) -> Result<Vec<u8>, String>;
980 fn snapshot_origin(&mut self) -> Option<Point>;
983 fn snapshot_chrome(&mut self) -> Result<Vec<u8>, String>;
985
986 fn decode_image(&mut self, req: u64, id: day_spec::BitmapId, bytes: &[u8]);
992 fn image_info(&mut self, id: day_spec::BitmapId) -> Option<day_spec::BitmapInfo>;
994 fn image_properties(&mut self, id: day_spec::BitmapId) -> Option<day_spec::ImageProperties>;
996 fn encode_image(&mut self, req: u64, id: day_spec::BitmapId, spec: &day_spec::EncodeSpec);
998 fn image_encode_formats(&mut self) -> Vec<day_spec::ImageFormat>;
1000 fn release_image(&mut self, id: day_spec::BitmapId);
1002 fn render_bitmap(
1005 &mut self,
1006 req: u64,
1007 id: day_spec::BitmapId,
1008 ops: &[day_spec::DrawOp],
1009 size: Size,
1010 scale: f64,
1011 );
1012 fn render_pdf(&mut self, req: u64, pages: &[day_spec::PdfPage], info: &day_spec::PdfInfo);
1015 fn window_image_support(&mut self) -> day_spec::Support;
1017 fn font_families(&mut self) -> Vec<day_spec::FontFamilyInfo>;
1019 fn measure_text(
1021 &mut self,
1022 text: &str,
1023 size: f64,
1024 font: &day_spec::CanvasFont,
1025 ) -> Option<day_spec::TextMetrics>;
1026 fn ui_idle(&mut self) -> bool;
1028 fn root_node(&self) -> RNode;
1029
1030 fn open_window_root(&mut self, options: &WindowOptions, kind: WindowKind) -> WindowRootReply;
1039 fn adopt_window_root(&mut self, root: RNode, raw: day_spec::RawHandle, size: Size) -> bool;
1043 fn remove_window_root(&mut self, root: RNode);
1046 fn set_root_size(&mut self, root: RNode, s: Size);
1048
1049 fn fit_window(&mut self, root: RNode, size: Size);
1053 fn add_extra_layout_root(&mut self, node: RNode, size: Size);
1059 fn drop_extra_layout_root(&mut self, node: RNode);
1062 fn close_native_window(&mut self, root: RNode);
1065 fn quit_app(&mut self);
1067 fn focus_native_window(&mut self, root: RNode);
1069 fn set_native_window_title(&mut self, root: RNode, title: &str);
1071 fn apply_window(&mut self, root: RNode, change: &day_spec::WindowChange);
1074 fn set_dock_menu(&mut self, items: &[day_spec::MenuItem]);
1076 fn set_status_items(&mut self, items: &[day_spec::StatusItemSpec]);
1078 fn set_app_progress(&mut self, progress: day_spec::AppProgress);
1080 fn set_dock_visible(&mut self, visible: bool);
1082 fn set_keep_running(&mut self, keep: bool);
1084 fn native_window_frame(&self, root: RNode) -> Option<day_spec::Rect>;
1086 fn monitors(&self) -> Vec<day_spec::Monitor>;
1088 fn set_launcher_shortcuts(&mut self, shortcuts: &[day_spec::LauncherShortcut]);
1090 fn snapshot_of(&mut self, root: RNode) -> Result<Vec<u8>, String>;
1092 fn capability(&self, cap: Cap) -> Support;
1094 fn attach_refresh(&mut self, node: RNode, host: NodeId);
1096 fn set_presented(&mut self, node: RNode, visible: bool);
1097 fn supports_lifecycle(&self, phase: day_spec::Lifecycle) -> bool;
1099 fn present(&mut self, req: u64, spec: &present::PresentSpec);
1101 fn dismiss(&mut self, req: u64);
1103 fn open_url(&mut self, url: &str);
1105 fn share_support(&self) -> Support;
1106 fn share_url(&mut self, url: &str, title: &str) -> bool;
1107 fn application_handlers(
1108 &mut self,
1109 query: &day_spec::applications::HandlerQuery,
1110 ) -> Result<day_spec::applications::ApplicationHandlers, day_spec::applications::ApplicationError>;
1111 fn open_url_with_application(
1112 &mut self,
1113 url: &str,
1114 application: &str,
1115 completion: day_spec::applications::OpenApplicationCompletion,
1116 );
1117
1118 fn defer_system_gestures(&mut self, edges: day_spec::Edges);
1120 fn set_status_bar_hidden(&mut self, hidden: bool);
1123
1124 fn install_list(&mut self, node: RNode, driver: crate::list::ListDriver);
1128 fn list_prepare_cell(
1132 &mut self,
1133 node: RNode,
1134 key: usize,
1135 cell: RawHandle,
1136 header: bool,
1137 ) -> crate::list::CellStep;
1138 fn list_store_cell(
1140 &mut self,
1141 node: RNode,
1142 key: usize,
1143 anchor: RNode,
1144 built: crate::list::BuiltRow,
1145 header: bool,
1146 );
1147 fn list_layout_cell(&mut self, node: RNode, key: usize);
1149 fn list_layout_cell_width(&mut self, node: RNode, key: usize, width: f64);
1153 fn list_cell_height(&self, node: RNode, key: usize) -> f64;
1156 fn list_cell_keys(&self, node: RNode) -> Vec<usize>;
1160 fn list_recycle_cell(&mut self, node: RNode, key: usize);
1164 fn list_release_cell(&mut self, node: RNode, key: usize);
1166 fn list_pin_cell(&mut self, node: RNode, key: usize);
1169 fn list_reload(&mut self, node: RNode);
1171 fn list_splice(&mut self, node: RNode, deltas: Vec<day_spec::props::RowDelta>);
1172 fn set_undo_state(&mut self, state: &day_spec::UndoState);
1173 fn set_edit_state(&mut self, state: &day_spec::EditState);
1174 fn modifiers(&mut self) -> day_spec::Modifiers;
1175 fn list_scroll_to_end(&mut self, node: RNode);
1177 fn list_scroll_to_row(&mut self, node: RNode, row: usize);
1179 fn list_set_selected(&mut self, node: RNode, rows: Vec<usize>);
1182 fn list_set_editing(&mut self, node: RNode, on: bool);
1185 fn list_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::list::ListDriver>>;
1188
1189 fn install_tree(&mut self, node: RNode, driver: crate::tree_driver::TreeDriver);
1193 fn tree_prepare_cell(
1195 &mut self,
1196 node: RNode,
1197 key: usize,
1198 cell: RawHandle,
1199 ) -> crate::tree_driver::TreeCellStep;
1200 fn tree_store_cell(
1202 &mut self,
1203 node: RNode,
1204 key: usize,
1205 anchor: RNode,
1206 built: crate::tree_driver::TreeBuiltRow,
1207 );
1208 fn tree_layout_cell(&mut self, node: RNode, key: usize);
1210 fn tree_layout_cell_width(&mut self, node: RNode, key: usize, width: f64);
1212 fn tree_layout_cell_size(&mut self, node: RNode, key: usize, size: Size);
1213 fn tree_cell_height(&self, node: RNode, key: usize) -> f64;
1216 fn tree_recycle_cell(&mut self, node: RNode, key: usize);
1220 fn tree_reload(&mut self, node: RNode);
1223 fn tree_set_expanded(&mut self, node: RNode, token: u64, expanded: bool);
1225 fn tree_set_selected(&mut self, node: RNode, tokens: Vec<u64>);
1227 fn tree_reveal(&mut self, node: RNode, token: u64);
1229 fn tree_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::tree_driver::TreeDriver>>;
1232 fn set_drag_source(&mut self, node: RNode, source: day_spec::transfer::Source);
1234 fn set_drop_target(&mut self, node: RNode, target: day_spec::transfer::Target);
1235 fn set_context_menu_fn(&mut self, node: RNode, f: day_spec::ContextMenuFn);
1237 fn context_menu_of(&mut self, node: RNode) -> Option<day_spec::ContextMenuFn>;
1242}
1243
1244impl<B: Toolkit> TreeOps for Tree<B> {
1245 fn set_presented(&mut self, node: RNode, visible: bool) {
1246 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
1247 self.toolkit.set_presented(&handle, visible);
1248 }
1249 }
1250
1251 fn attach_refresh(&mut self, node: RNode, host: NodeId) {
1252 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
1253 self.toolkit.attach_refresh(&handle, host);
1254 }
1255 }
1256
1257 fn capability(&self, cap: Cap) -> Support {
1258 self.toolkit.capability(cap)
1259 }
1260
1261 fn supports_lifecycle(&self, phase: day_spec::Lifecycle) -> bool {
1262 self.toolkit.supports_lifecycle(phase)
1263 }
1264
1265 fn present(&mut self, req: u64, spec: &present::PresentSpec) {
1266 self.toolkit.present(req, spec);
1267 }
1268
1269 fn dismiss(&mut self, req: u64) {
1270 self.toolkit.dismiss(req);
1271 }
1272
1273 fn open_url(&mut self, url: &str) {
1274 self.toolkit.open_url(url);
1275 }
1276 fn share_support(&self) -> Support {
1277 self.toolkit.share_support()
1278 }
1279 fn share_url(&mut self, url: &str, title: &str) -> bool {
1280 self.toolkit.share_url(url, title)
1281 }
1282
1283 fn application_handlers(
1284 &mut self,
1285 query: &day_spec::applications::HandlerQuery,
1286 ) -> Result<day_spec::applications::ApplicationHandlers, day_spec::applications::ApplicationError>
1287 {
1288 self.toolkit.application_handlers(query)
1289 }
1290
1291 fn open_url_with_application(
1292 &mut self,
1293 url: &str,
1294 application: &str,
1295 completion: day_spec::applications::OpenApplicationCompletion,
1296 ) {
1297 self.toolkit
1298 .open_url_with_application(url, application, completion);
1299 }
1300
1301 fn set_appearance(&mut self, dark: Option<bool>) {
1302 self.toolkit.set_appearance(dark);
1303 }
1304
1305 fn set_app_badge(&mut self, badge: &day_spec::AppBadge) {
1306 self.toolkit.set_app_badge(badge);
1307 }
1308
1309 fn defer_system_gestures(&mut self, edges: day_spec::Edges) {
1310 self.toolkit.defer_system_gestures(edges);
1311 }
1312
1313 fn set_status_bar_hidden(&mut self, hidden: bool) {
1314 self.toolkit.set_status_bar_hidden(hidden);
1315 }
1316
1317 fn create_node(
1318 &mut self,
1319 kind: PieceKind,
1320 props: &dyn Any,
1321 layout: Rc<dyn Layout>,
1322 flex: Flex,
1323 native: bool,
1324 is_boundary: bool,
1325 scope: Scope,
1326 ) -> RNode {
1327 let mut probe = NodeProbe {
1328 enabled: true,
1329 ..Default::default()
1330 };
1331 {
1332 use day_spec::props::*;
1333 if let Some(p) = props.downcast_ref::<LabelProps>() {
1334 probe.text = p.text.clone();
1335 } else if let Some(p) = props.downcast_ref::<NavMenuProps>() {
1336 probe.selected = p.selected.map(|i| i as i64).unwrap_or(-1);
1337 probe.value = probe.selected as f64;
1338 } else if let Some(p) = props.downcast_ref::<ButtonProps>() {
1339 probe.text = p.title.clone();
1340 probe.enabled = p.enabled;
1341 probe.flag = p.selected;
1343 } else if let Some(p) = props.downcast_ref::<ToggleProps>() {
1344 probe.flag = p.on;
1345 probe.enabled = p.enabled;
1346 } else if let Some(p) = props.downcast_ref::<SliderProps>() {
1347 probe.value = p.value;
1348 probe.enabled = p.enabled;
1349 } else if let Some(p) = props.downcast_ref::<TextFieldProps>() {
1350 probe.text = p.text.clone();
1351 probe.enabled = p.enabled;
1352 } else if let Some(p) = props.downcast_ref::<ProgressProps>() {
1353 probe.flag = p.value.is_none();
1355 probe.value = p.value.unwrap_or(0.0);
1356 } else if let Some(p) = props.downcast_ref::<PickerProps>() {
1357 probe.selected = p.selected as i64;
1358 probe.value = p.selected as f64;
1359 probe.text = p.options.get(p.selected).cloned().unwrap_or_default();
1362 probe.options = p.options.clone();
1363 probe.enabled = p.enabled;
1364 } else if let Some(p) = props.downcast_ref::<TextAreaProps>() {
1365 probe.text = p.text.clone();
1366 }
1367 }
1368 let node = self.nodes.insert(NodeData {
1369 kind,
1370 handle: None,
1371 parent: RNode::null(),
1372 children: Vec::new(),
1373 layout,
1374 flex,
1375 scope,
1376 id: None,
1377 parked_id: None,
1378 a11y: Default::default(),
1379 cache: Vec::new(),
1380 baseline_cache: None,
1381 probe,
1382 needs_measure: true,
1383 needs_layout: true,
1384 last_native_frame: None,
1385 scroll_content: None,
1386 implicit_anim: None,
1387 tweaked: false,
1388 is_boundary,
1389 });
1390 if native {
1391 let h = self.toolkit.realize(kind, props, rnode_to_id(node));
1392 self.nodes[node].handle = Some(h);
1393 }
1394 node
1395 }
1396
1397 fn attach(&mut self, parent: RNode, child: RNode) {
1398 let index = self
1399 .nodes
1400 .get(parent)
1401 .map(|p| p.children.len())
1402 .unwrap_or(0);
1403 self.attach_impl(parent, child, index);
1404 }
1405
1406 fn native_window_tabs(&self) -> bool {
1407 self.toolkit.native_window_tabs()
1408 }
1409 fn native_document_tabs(&self) -> bool {
1410 self.toolkit.native_document_tabs()
1411 }
1412 fn group_windows(&mut self, roots: &[RNode]) {
1413 let hosts = roots
1414 .iter()
1415 .filter_map(|r| self.nodes.get(*r)?.handle.clone())
1416 .collect::<Vec<_>>();
1417 self.toolkit.group_windows(&hosts);
1418 }
1419 fn window_tab_order(&self, root: RNode) -> Vec<day_spec::NodeId> {
1420 self.nodes
1421 .get(root)
1422 .and_then(|n| n.handle.as_ref())
1423 .map(|h| self.toolkit.window_tab_order(h))
1424 .unwrap_or_default()
1425 }
1426 fn reparent(&mut self, child: RNode, parent: RNode) -> bool {
1427 if !self.nodes.contains_key(child) || !self.nodes.contains_key(parent) {
1428 return false;
1429 }
1430 let old = self.nodes[child].parent;
1431 if old == parent {
1432 return true;
1433 }
1434 if self.windows.iter().any(|w| w.root == child) {
1436 return false;
1437 }
1438 let mut up = parent;
1439 while let Some(n) = self.nodes.get(up) {
1440 if up == child {
1441 return false;
1442 }
1443 up = n.parent;
1444 }
1445 let ancestor = self.native_ancestor(old);
1446 let handle = self.nodes.get(ancestor).and_then(|n| n.handle.clone());
1447 let mut roots = Vec::new();
1448 if self.nodes[child].handle.is_some() {
1449 roots.push(child);
1450 } else {
1451 self.native_descendants(child, &mut roots);
1452 }
1453 if let Some(h) = handle {
1454 for r in roots {
1455 self.toolkit
1457 .remove(&h, self.nodes[r].handle.as_ref().unwrap());
1458 }
1459 }
1460 if let Some(p) = self.nodes.get_mut(old) {
1461 p.children.retain(|n| *n != child);
1462 }
1463 self.mark_needs_measure_impl(old);
1464 self.attach(parent, child);
1465 self.layout_dirty = true;
1466 true
1467 }
1468
1469 fn attach_at(&mut self, parent: RNode, child: RNode, index: usize) {
1470 self.attach_impl(parent, child, index);
1471 }
1472
1473 fn reorder_children(&mut self, parent: RNode, order: Vec<RNode>) {
1474 if self.nodes.get(parent).is_some_and(|p| p.children == order) {
1482 return;
1483 }
1484 if let Some(p) = self.nodes.get_mut(parent) {
1485 p.children = order;
1486 }
1487 let ancestor = self.native_ancestor(parent);
1489 let anc_handle = self.nodes[ancestor]
1490 .handle
1491 .clone()
1492 .expect("native ancestor");
1493 let mut desired = Vec::new();
1494 self.native_descendants(ancestor, &mut desired);
1495 for (i, r) in desired.iter().enumerate() {
1496 let h = self.nodes[*r].handle.clone().unwrap();
1497 self.toolkit.move_child(&anc_handle, &h, i);
1498 }
1499 self.mark_needs_measure_impl(parent);
1500 }
1501
1502 fn remove_subtree(&mut self, node: RNode) {
1503 debug_assert!(
1506 !self.windows.iter().any(|w| w.root == node),
1507 "remove_subtree called with a window root"
1508 );
1509 self.remove_subtree_impl(node);
1510 }
1511
1512 fn on_event(&mut self, node: RNode, h: EventHandler) {
1513 self.handlers.entry(node).or_default().push(h);
1514 }
1515
1516 fn handlers_for(&self, node: RNode) -> Vec<EventHandler> {
1517 self.handlers.get(&node).cloned().unwrap_or_default()
1518 }
1519 fn native_view_of(&self, node: RNode) -> Option<RNode> {
1520 let mut cur = node;
1521 for _ in 0..16 {
1522 let n = self.nodes.get(cur)?;
1523 if n.handle.is_some() {
1524 return Some(cur);
1525 }
1526 match n.children.as_slice() {
1527 [only] => cur = *only,
1528 _ => return None,
1529 }
1530 }
1531 None
1532 }
1533 fn gesture_target(&self, node: RNode, kind: day_spec::GestureKind) -> Option<RNode> {
1534 let has = |n: RNode| self.gestures.get(&n).is_some_and(|k| k.contains(&kind));
1535 if has(node) {
1536 return Some(node);
1537 }
1538 let mut cur = node;
1541 let mut bound = self.element_outer.get(&node).copied();
1542 while let Some(outer) = bound {
1543 if cur == outer {
1544 bound = self.element_outer.get(&outer).copied();
1545 continue;
1546 }
1547 let Some(parent) = self.nodes.get(cur).map(|n| n.parent) else {
1548 break;
1549 };
1550 if parent == cur || !self.nodes.contains_key(parent) {
1551 break;
1552 }
1553 cur = parent;
1554 if has(cur) {
1555 return Some(cur);
1556 }
1557 }
1558 self.wrappers_above(cur).into_iter().find(|w| has(*w))
1559 }
1560
1561 fn set_element_outer(&mut self, inner: RNode, outer: RNode) {
1562 if inner != outer {
1563 self.element_outer.insert(inner, outer);
1564 }
1565 }
1566
1567 fn wrappers_above(&self, node: RNode) -> Vec<RNode> {
1568 let mut out = Vec::new();
1569 let mut cur = node;
1570 for _ in 0..16 {
1571 let Some(parent) = self.nodes.get(cur).map(|n| n.parent) else {
1572 break;
1573 };
1574 match self.nodes.get(parent) {
1575 Some(p) if p.handle.is_none() && p.children.len() == 1 && parent != cur => {
1576 out.push(parent);
1577 cur = parent;
1578 }
1579 _ => break,
1580 }
1581 }
1582 out
1583 }
1584 fn node_exists(&self, node: RNode) -> bool {
1585 self.nodes.contains_key(node)
1586 }
1587 fn dark_mode(&mut self) -> bool {
1588 self.toolkit.dark_mode()
1589 }
1590 fn reduce_motion(&mut self) -> bool {
1591 self.toolkit.reduce_motion()
1592 }
1593
1594 fn mounted_id_families(&self) -> Vec<String> {
1595 self.mounted_id_families.iter().cloned().collect()
1596 }
1597 fn set_id(&mut self, node: RNode, id: String) {
1598 if self.nodes.contains_key(node) {
1599 self.mounted_id_families
1600 .insert(crate::element_id::family_of(&id).to_owned());
1601 }
1602 if let Some(n) = self.nodes.get_mut(node) {
1603 n.id = Some(id.clone());
1604 n.a11y.merge(&A11yProps {
1605 identifier: Some(id),
1606 ..Default::default()
1607 });
1608 if let Some(h) = n.handle.clone() {
1609 self.toolkit.set_a11y(&h, &n.a11y);
1610 }
1611 }
1612 }
1613
1614 fn forward_whole_row(&mut self, wrapper: RNode, inner: RNode) {
1615 let whole = self.nodes.get(inner).is_some_and(|n| n.flex.whole_row);
1616 if let Some(n) = self.nodes.get_mut(wrapper) {
1617 n.flex.whole_row = whole;
1618 }
1619 }
1620
1621 fn set_grid_facts(&mut self, node: RNode, facts: GridFacts) {
1622 if let Some(n) = self.nodes.get_mut(node) {
1623 let g = &mut n.flex.grid;
1624 if facts.is_row {
1625 g.is_row = true;
1626 }
1627 if facts.row_valign.is_some() {
1628 g.row_valign = facts.row_valign;
1629 }
1630 if facts.col_span != 0 {
1631 g.col_span = facts.col_span;
1632 }
1633 if facts.align.is_some() {
1634 g.align = facts.align;
1635 }
1636 }
1637 }
1638
1639 fn announce(&mut self, text: &str, urgent: bool) {
1640 self.toolkit.announce(text, urgent);
1641 }
1642
1643 fn set_a11y(&mut self, node: RNode, a11y: A11yProps) {
1644 if let Some(n) = self.nodes.get_mut(node) {
1645 n.a11y.merge(&a11y);
1648 if n.kind == kinds::CANVAS
1652 && let Some(text) = n.a11y.value.clone().or_else(|| n.a11y.label.clone())
1653 {
1654 n.probe.text = text;
1655 }
1656 if let Some(h) = n.handle.clone() {
1657 self.toolkit.set_a11y(&h, &n.a11y);
1658 }
1659 }
1660 }
1661
1662 fn enable_gesture(&mut self, node: RNode, kind: day_spec::GestureKind) {
1663 let kinds = self.gestures.entry(node).or_default();
1664 if !kinds.contains(&kind) {
1665 kinds.push(kind);
1666 }
1667 let mut cur = node;
1673 for _ in 0..16 {
1674 let Some(n) = self.nodes.get(cur) else { return };
1675 if let Some(h) = n.handle.clone() {
1676 if kind == day_spec::GestureKind::Tap && n.kind == kinds::BUTTON {
1677 log::warn!(
1678 "tap gesture attached to native button {:?} (id: {:?}): \
1679 use .action(...) instead of .on_tap(...) or .on_tap_at(...). \
1680 A separate gesture recognizer can delay pressed feedback and \
1681 bypass native keyboard, accessibility, and disabled behavior",
1682 rnode_to_id(cur),
1683 n.id,
1684 );
1685 }
1686 self.toolkit.enable_gesture(&h, rnode_to_id(node), kind);
1687 return;
1688 }
1689 match n.children.as_slice() {
1690 [only] => cur = *only,
1691 _ => break,
1692 }
1693 }
1694 log::warn!(
1695 "enable_gesture({kind:?}) found no native view under the target node — \
1696 the gesture will not fire natively (attach it to a piece with a native handle)"
1697 );
1698 }
1699
1700 fn focus_node(&mut self, node: RNode, focused: bool) {
1701 let mut cur = node;
1704 for _ in 0..16 {
1705 let Some(n) = self.nodes.get(cur) else { return };
1706 if let Some(h) = n.handle.clone() {
1707 self.toolkit.focus(&h, rnode_to_id(node), focused);
1708 return;
1709 }
1710 match n.children.as_slice() {
1711 [only] => cur = *only,
1712 _ => return,
1713 }
1714 }
1715 }
1716
1717 fn set_focusable(&mut self, node: RNode, focusable: bool) {
1718 let mut cur = node;
1722 for _ in 0..16 {
1723 let Some(n) = self.nodes.get(cur) else { return };
1724 if let Some(h) = n.handle.clone() {
1725 self.toolkit.set_focusable(&h, rnode_to_id(node), focusable);
1726 return;
1727 }
1728 match n.children.as_slice() {
1729 [only] => cur = *only,
1730 _ => break,
1731 }
1732 }
1733 log::warn!(
1734 "set_focusable found no native view under the target node — \
1735 the piece will not join the focus order"
1736 );
1737 }
1738
1739 fn set_probe_focused(&mut self, node: RNode, focused: bool) {
1740 if let Some(n) = self.nodes.get_mut(node) {
1741 n.probe.focused = focused;
1742 }
1743 for w in self.wrappers_above(node) {
1748 if let Some(p) = self.nodes.get_mut(w) {
1749 p.probe.focused = focused;
1750 }
1751 }
1752 let mut cur = node;
1758 for _ in 0..16 {
1759 let Some(n) = self.nodes.get(cur) else { break };
1760 if n.handle.is_some() && cur != node {
1761 if let Some(p) = self.nodes.get_mut(cur) {
1762 p.probe.focused = focused;
1763 }
1764 break;
1765 }
1766 let next = match n.children.as_slice() {
1767 [only] => *only,
1768 _ => break,
1769 };
1770 if let Some(p) = self.nodes.get_mut(next) {
1771 p.probe.focused = focused;
1772 }
1773 cur = next;
1774 }
1775 FOCUSED.with(|f| match focused {
1780 true => f.set(Some(node)),
1781 false if f.get() == Some(node) => f.set(None),
1782 false => {}
1783 });
1784 }
1785
1786 fn set_probe_selected(&mut self, node: RNode, selected: Option<usize>) {
1787 if let Some(n) = self.nodes.get_mut(node) {
1788 n.probe.selected = selected.map(|i| i as i64).unwrap_or(-1);
1791 n.probe.value = n.probe.selected as f64;
1792 }
1793 }
1794
1795 fn set_probe_value(&mut self, node: RNode, value: f64, text: String) {
1796 if let Some(n) = self.nodes.get_mut(node) {
1797 n.probe.value = value;
1798 n.probe.text = text;
1799 }
1800 }
1801
1802 fn set_app_menu(&mut self, items: Vec<day_spec::MenuItem>) {
1803 collect_menu_families(&items, &mut self.mounted_id_families);
1804 self.toolkit.set_app_menu(&items);
1805 }
1806
1807 fn edit_window_toolbar(&mut self, root: RNode, ops: Vec<day_spec::ToolbarOp>) -> bool {
1808 let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) else {
1809 return false;
1810 };
1811 for op in &ops {
1812 if let day_spec::ToolbarOp::Insert { item, .. } = op {
1813 self.mounted_id_families
1814 .insert(crate::element_id::family_of(&item.id).to_owned());
1815 }
1816 }
1817 self.toolkit.edit_toolbar(&h, &ops)
1818 }
1819
1820 fn patch_window_toolbar(&mut self, root: RNode, patch: day_spec::ToolbarPatch) -> bool {
1821 let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) else {
1822 return false;
1823 };
1824 self.toolkit.update_toolbar(&h, &patch);
1825 true
1826 }
1827
1828 fn set_context_menu(&mut self, node: RNode, items: Vec<day_spec::MenuItem>) {
1829 let target = if self.nodes.get(node).is_some_and(|n| n.handle.is_some()) {
1834 Some(node)
1835 } else {
1836 let mut roots = Vec::new();
1837 self.native_descendants(node, &mut roots);
1838 roots.first().copied()
1839 };
1840 let Some(t) = target else {
1841 log::warn!("context_menu on a subtree with no native view — menu dropped");
1842 return;
1843 };
1844 collect_menu_families(&items, &mut self.mounted_id_families);
1845 let model = ContextMenuModel::Items(items.clone());
1846 self.context_menus.insert(node, model.clone());
1847 self.context_menus.insert(t, model);
1848 if let Some(h) = self.nodes.get(t).and_then(|n| n.handle.clone()) {
1849 self.toolkit.set_context_menu(&h, rnode_to_id(t), &items);
1850 }
1851 }
1852
1853 fn scroll_to_target(&mut self, node: RNode, target: &ScrollTarget, animated: bool) -> bool {
1854 if let ScrollTarget::Id(id) = target {
1856 let Some(el) = self.find_by_id(id) else {
1857 return false;
1858 };
1859 return self.scroll_reveal(el, animated);
1860 }
1861 let Some(n) = self.nodes.get(node) else {
1862 return false;
1863 };
1864 if n.kind == kinds::NAV_MENU {
1865 return match (n.handle.clone(), target) {
1866 (Some(h), ScrollTarget::Top | ScrollTarget::Bottom) => self
1867 .toolkit
1868 .nav_scroll_to_edge(&h, matches!(target, ScrollTarget::Bottom)),
1869 _ => false,
1870 };
1871 }
1872 if n.kind != kinds::SCROLL {
1873 return false;
1874 }
1875 let Some(h) = n.handle.clone() else {
1876 return false;
1877 };
1878 let viewport = n.last_native_frame.map(|f| f.size).unwrap_or(Size::ZERO);
1879 let content = n.scroll_content.unwrap_or(viewport);
1880 let rect = match target {
1883 ScrollTarget::Top | ScrollTarget::Leading => Rect::new(0.0, 0.0, 1.0, 1.0),
1884 ScrollTarget::Bottom => Rect::new(0.0, (content.height - 1.0).max(0.0), 1.0, 1.0),
1885 ScrollTarget::Trailing => Rect::new((content.width - 1.0).max(0.0), 0.0, 1.0, 1.0),
1886 ScrollTarget::Offset(p) => Rect::new(p.x, p.y, viewport.width, viewport.height),
1889 ScrollTarget::Id(_) => unreachable!("routed to scroll_reveal above"),
1890 };
1891 self.toolkit
1892 .scroll_to(&h, rect, animated && !crate::reduce_motion_now());
1893 true
1894 }
1895
1896 fn scroll_reveal(&mut self, node: RNode, animated: bool) -> bool {
1897 let Some(mut rect) = self.nodes.get(node).and_then(|n| n.last_native_frame) else {
1901 return false;
1902 };
1903 let mut anc = match self.nodes.get(node) {
1904 Some(n) => n.parent,
1905 None => return false,
1906 };
1907 loop {
1908 let Some(a) = self.nodes.get(anc) else {
1909 return false; };
1911 if a.kind == kinds::SCROLL {
1912 let Some(h) = a.handle.clone() else {
1913 return false;
1914 };
1915 self.toolkit
1916 .scroll_to(&h, rect, animated && !crate::reduce_motion_now());
1917 return true;
1918 }
1919 if a.handle.is_some()
1920 && let Some(f) = a.last_native_frame
1921 {
1922 rect.origin.x += f.origin.x;
1923 rect.origin.y += f.origin.y;
1924 }
1925 anc = a.parent;
1926 }
1927 }
1928
1929 fn patch(&mut self, node: RNode, patch: Box<dyn Any>, affects_size: bool) {
1930 {
1931 use day_spec::props::*;
1932 if let Some(n) = self.nodes.get_mut(node) {
1933 if let Some(p) = patch.downcast_ref::<LabelPatch>() {
1934 match p {
1938 LabelPatch::Text(t) => n.probe.text = t.clone(),
1939 LabelPatch::Runs(t, _) => n.probe.text = t.clone(),
1940 LabelPatch::Font(_) | LabelPatch::Color(_) => {}
1941 }
1942 } else if let Some(p) = patch.downcast_ref::<ButtonPatch>() {
1943 match p {
1944 ButtonPatch::Title(t) => n.probe.text = t.clone(),
1945 ButtonPatch::Content(c) => n.probe.text = c.title.clone(),
1946 ButtonPatch::Enabled(e) => n.probe.enabled = *e,
1947 ButtonPatch::Selected(on) => n.probe.flag = *on,
1948 ButtonPatch::Style(_) => {}
1950 }
1951 } else if let Some(p) = patch.downcast_ref::<TogglePatch>() {
1952 match p {
1953 TogglePatch::On(v) => n.probe.flag = *v,
1954 TogglePatch::Enabled(e) => n.probe.enabled = *e,
1955 }
1956 } else if let Some(p) = patch.downcast_ref::<SliderPatch>() {
1957 match p {
1958 SliderPatch::Value(v) => n.probe.value = *v,
1959 SliderPatch::Enabled(e) => n.probe.enabled = *e,
1960 }
1961 } else if let Some(p) = patch.downcast_ref::<PickerPatch>() {
1962 match p {
1963 PickerPatch::Selected(i) => {
1964 n.probe.selected = *i as i64;
1965 n.probe.value = *i as f64;
1966 }
1967 PickerPatch::Options(opts) => n.probe.options = opts.clone(),
1968 PickerPatch::Enabled(e) => n.probe.enabled = *e,
1969 }
1970 let i = n.probe.selected.max(0) as usize;
1971 n.probe.text = n.probe.options.get(i).cloned().unwrap_or_default();
1972 } else if let Some(TextAreaPatch::SetText(t)) =
1973 patch.downcast_ref::<TextAreaPatch>()
1974 {
1975 n.probe.text = t.clone();
1976 } else if let Some(ProgressPatch::Value(v)) = patch.downcast_ref::<ProgressPatch>()
1977 {
1978 n.probe.flag = v.is_none();
1979 n.probe.value = v.unwrap_or(0.0);
1980 } else if let Some(p) = patch.downcast_ref::<TextFieldPatch>() {
1981 match p {
1982 TextFieldPatch::Text { text, .. } => n.probe.text = text.clone(),
1983 TextFieldPatch::Enabled(e) => n.probe.enabled = *e,
1984 _ => {}
1985 }
1986 } else if let Some(NavMenuPatch::Selected(sel)) =
1987 patch.downcast_ref::<NavMenuPatch>()
1988 {
1989 n.probe.selected = sel.map(|i| i as i64).unwrap_or(-1);
1990 n.probe.value = n.probe.selected as f64;
1991 }
1992 }
1993 }
1994 let Some(n) = self.nodes.get(node) else {
1995 return;
1996 };
1997 let kind = n.kind;
1998 if let Some(h) = n.handle.clone() {
1999 let anim = self.resolve_anim(node);
2000 self.toolkit.update(&h, kind, patch.as_ref(), anim.as_ref());
2001 }
2002 if affects_size {
2003 self.mark_needs_measure_impl(node);
2004 }
2005 }
2006
2007 fn set_implicit_anim(&mut self, node: RNode, anim: Option<day_spec::AnimSpec>) {
2008 let had = self
2009 .nodes
2010 .get(node)
2011 .map(|n| n.implicit_anim.is_some())
2012 .unwrap_or(false);
2013 if let Some(n) = self.nodes.get_mut(node) {
2014 n.implicit_anim = anim;
2015 } else {
2016 return;
2017 }
2018 match (had, anim.is_some()) {
2019 (false, true) => self.implicit_anim_count += 1,
2020 (true, false) => self.implicit_anim_count = self.implicit_anim_count.saturating_sub(1),
2021 _ => {}
2022 }
2023 }
2024
2025 fn set_node_opacity(&mut self, node: RNode, opacity: f64) {
2026 let Some(h) = self.nodes.get(node).and_then(|n| n.handle.clone()) else {
2027 return;
2028 };
2029 let anim = self.resolve_anim(node);
2030 self.toolkit.set_opacity(&h, opacity, anim.as_ref());
2031 }
2032
2033 fn set_node_transform(&mut self, node: RNode, t: day_spec::Transform) {
2034 let Some(n) = self.nodes.get(node) else {
2035 return;
2036 };
2037 let Some(h) = n.handle.clone() else {
2038 return;
2039 };
2040 let size = n.last_native_frame.map(|f| f.size).unwrap_or(Size::ZERO);
2043 let anim = self.resolve_anim(node);
2044 self.toolkit.set_transform(&h, t, size, anim.as_ref());
2045 }
2046
2047 fn set_node_selectable(&mut self, node: RNode, selectable: bool) {
2048 let Some(h) = self.nodes.get(node).and_then(|n| n.handle.clone()) else {
2049 return;
2050 };
2051 if let Some(new) = self.toolkit.set_selectable(&h, selectable)
2054 && let Some(n) = self.nodes.get_mut(node)
2055 {
2056 if n.tweaked {
2057 log::warn!(
2058 "`.selectable()` rebuilt this widget as a different native class, \
2059 discarding an earlier tweak's changes — apply `.selectable()` BEFORE the \
2060 tweak so it runs against the widget that ships (docs/tweaks.md)."
2061 );
2062 }
2063 n.handle = Some(new);
2064 }
2065 }
2066
2067 fn set_node_input_traits(&mut self, node: RNode, traits: &day_spec::InputTraits) {
2068 let Some(h) = self.nodes.get(node).and_then(|n| n.handle.clone()) else {
2069 return;
2070 };
2071 if let Some(new) = self.toolkit.set_input_traits(&h, traits)
2074 && let Some(n) = self.nodes.get_mut(node)
2075 {
2076 if n.tweaked {
2077 log::warn!(
2078 "a text field's `.secure()` rebuilt this widget as a different native \
2079 class, discarding an earlier tweak's changes (docs/tweaks.md)."
2080 );
2081 }
2082 n.handle = Some(new);
2083 n.last_native_frame = None;
2084 self.mark_needs_measure_impl(node);
2085 }
2086 }
2087
2088 fn set_node_cursor(&mut self, node: RNode, cursor: day_spec::Cursor) {
2089 let Some(h) = self
2093 .native_view_of(node)
2094 .and_then(|n| self.nodes.get(n))
2095 .and_then(|n| n.handle.clone())
2096 else {
2097 return;
2098 };
2099 self.toolkit.set_cursor(&h, cursor);
2100 }
2101
2102 fn set_node_drag_region(&mut self, node: RNode, drag: bool) {
2103 let Some(h) = self
2105 .native_view_of(node)
2106 .and_then(|n| self.nodes.get(n))
2107 .and_then(|n| n.handle.clone())
2108 else {
2109 log::warn!(
2110 "window_drag_region found no native view under the target node; give the \
2111 region a piece with a native view (a background, a row)"
2112 );
2113 return;
2114 };
2115 self.toolkit.set_drag_region(&h, drag);
2116 }
2117
2118 fn note_node_tweaked(&mut self, node: RNode) {
2119 if let Some(n) = self.nodes.get_mut(node) {
2120 n.tweaked = true;
2121 }
2122 }
2123
2124 fn request_frame(&mut self, root: RNode, cb: day_spec::FrameCallback) -> day_spec::CancelFrame {
2125 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2126 self.toolkit.request_frame(&h, cb)
2127 } else {
2128 Box::new(|| {})
2129 }
2130 }
2131
2132 fn replay(&mut self, node: RNode, ops: Vec<DrawOp>) {
2133 let Some(n) = self.nodes.get(node) else {
2134 return;
2135 };
2136 let size = n.last_native_frame.map(|f| f.size).unwrap_or(Size::ZERO);
2137 if let Some(h) = n.handle.clone() {
2138 self.toolkit.replay(&h, &ops, size);
2139 }
2140 }
2141
2142 fn mark_needs_measure(&mut self, node: RNode) {
2143 self.mark_needs_measure_impl(node);
2144 }
2145
2146 fn mark_layout_dirty(&mut self) {
2147 self.layout_dirty = true;
2148 }
2149
2150 fn invalidate_all_measurements(&mut self) {
2151 for (_, n) in self.nodes.iter_mut() {
2152 n.needs_measure = true;
2153 n.needs_layout = true;
2154 n.cache.clear();
2155 }
2156 for state in self.lists.values_mut() {
2160 for cell in state.cells.values_mut() {
2161 cell.laid_width = None;
2162 }
2163 }
2164 for state in self.trees.values_mut() {
2165 for cell in state.cells.values_mut() {
2166 cell.laid_width = None;
2167 }
2168 }
2169 self.layout_dirty = true;
2170 }
2171
2172 fn layout_if_needed(&mut self) {
2173 if !self.layout_dirty {
2174 return;
2175 }
2176 self.layout_dirty = false;
2177 self.layout_now();
2178 }
2179
2180 fn set_route(&mut self, route: &str) {
2181 self.toolkit.set_route(route);
2182 }
2183
2184 fn set_window_size(&mut self, s: Size) {
2185 if s != self.windows[0].size {
2188 self.windows[0].size = s;
2189 let root = self.windows[0].root;
2190 self.mark_needs_measure_impl(root);
2191 }
2192 }
2193
2194 fn child_count(&self, node: RNode) -> usize {
2195 self.nodes.get(node).map(|n| n.children.len()).unwrap_or(0)
2196 }
2197
2198 fn first_child(&self, node: RNode) -> Option<RNode> {
2199 self.nodes
2200 .get(node)
2201 .and_then(|n| n.children.first().copied())
2202 }
2203
2204 fn parent_of(&self, node: RNode) -> Option<RNode> {
2205 self.nodes
2206 .get(node)
2207 .map(|n| n.parent)
2208 .filter(|p| !p.is_null() && *p != node)
2209 }
2210
2211 fn node_kind(&self, node: RNode) -> Option<PieceKind> {
2212 self.nodes.get(node).map(|n| n.kind)
2213 }
2214
2215 fn node_id(&self, node: RNode) -> Option<String> {
2216 self.nodes.get(node).and_then(|n| n.id.clone())
2217 }
2218
2219 fn node_handle_any(&self, node: RNode) -> Option<Box<dyn Any>> {
2220 self.nodes
2221 .get(node)
2222 .and_then(|n| n.handle.clone())
2223 .map(|h| Box::new(h) as Box<dyn Any>)
2224 }
2225
2226 fn node_frame(&self, node: RNode) -> Option<Rect> {
2227 self.nodes.get(node).and_then(|n| n.last_native_frame)
2228 }
2229
2230 fn node_probe(&self, node: RNode) -> Option<NodeProbe> {
2231 self.nodes.get(node).map(|n| n.probe.clone())
2232 }
2233
2234 fn node_a11y(&self, node: RNode) -> Option<A11yProps> {
2235 self.nodes.get(node).map(|n| n.a11y.clone())
2236 }
2237
2238 fn read_native(&self, node: RNode) -> Option<day_spec::NativeSnapshot> {
2239 let n = self.nodes.get(node)?;
2240 let h = n.handle.as_ref()?;
2241 Some(self.toolkit.read_native(h))
2242 }
2243
2244 fn a11y_nodes(&self) -> Vec<(String, PieceKind, A11yProps, day_spec::NativeSnapshot)> {
2245 self.nodes
2246 .values()
2247 .filter_map(|n| {
2248 let id = n.id.clone()?;
2249 let h = n.handle.as_ref()?;
2250 Some((id, n.kind, n.a11y.clone(), self.toolkit.read_native(h)))
2251 })
2252 .collect()
2253 }
2254
2255 fn find_by_id(&self, id: &str) -> Option<RNode> {
2256 let focused = crate::windows::focused_window()
2259 .map(|w| id_to_rnode(crate::windows::window_node_id(&w)))
2260 .unwrap_or_else(|| self.root());
2261 let mut fallback = None;
2262 for (key, node) in &self.nodes {
2263 if node.id.as_deref() != Some(id) {
2264 continue;
2265 }
2266 fallback.get_or_insert(key);
2267 let mut ancestor = key;
2268 while let Some(node) = self.nodes.get(ancestor) {
2269 if self.windows.iter().any(|w| w.root == ancestor) {
2272 if ancestor == focused {
2273 return Some(key);
2274 }
2275 break;
2276 }
2277 ancestor = if node.kind == kinds::LIST_CELL && node.parent.is_null() {
2278 self.lists
2281 .iter()
2282 .find_map(|(&owner, state)| {
2283 state
2284 .cells
2285 .values()
2286 .any(|c| c.anchor == ancestor)
2287 .then_some(owner)
2288 })
2289 .or_else(|| {
2290 self.trees.iter().find_map(|(&owner, state)| {
2291 state
2292 .cells
2293 .values()
2294 .any(|c| c.anchor == ancestor)
2295 .then_some(owner)
2296 })
2297 })
2298 .unwrap_or(node.parent)
2299 } else {
2300 node.parent
2301 };
2302 }
2303 }
2304 fallback
2305 }
2306
2307 fn toggle_sidebar(&mut self, host: RNode) -> bool {
2308 let Some(h) = self.nodes.get(host).and_then(|n| n.handle.as_ref()) else {
2309 return false;
2310 };
2311 self.toolkit.toggle_sidebar(h)
2312 }
2313
2314 fn native_back(&mut self) -> bool {
2315 self.toolkit.native_back()
2316 }
2317
2318 fn prepare_snapshot(
2319 &mut self,
2320 root: Option<RNode>,
2321 revision: u32,
2322 ) -> Result<day_spec::capture::Readiness, String> {
2323 let host = match root {
2324 Some(root) if self.windows[0].root != root => Some(
2325 self.nodes
2326 .get(root)
2327 .and_then(|n| n.handle.clone())
2328 .ok_or("window is gone")?,
2329 ),
2330 _ => None,
2331 };
2332 self.toolkit.prepare_snapshot(host.as_ref(), revision)
2333 }
2334
2335 fn snapshot(&mut self) -> Result<Vec<u8>, String> {
2336 self.toolkit.snapshot_window()
2337 }
2338
2339 fn snapshot_origin(&mut self) -> Option<Point> {
2340 let root = self.windows[0].root;
2341 let h = self.nodes.get(root).and_then(|n| n.handle.clone())?;
2342 self.toolkit.snapshot_origin(&h)
2343 }
2344
2345 fn snapshot_chrome(&mut self) -> Result<Vec<u8>, String> {
2346 self.toolkit.snapshot_window_chrome()
2347 }
2348
2349 fn decode_image(&mut self, req: u64, id: day_spec::BitmapId, bytes: &[u8]) {
2350 self.toolkit.decode_image(req, id, bytes);
2351 }
2352
2353 fn image_info(&mut self, id: day_spec::BitmapId) -> Option<day_spec::BitmapInfo> {
2354 self.toolkit.image_info(id)
2355 }
2356
2357 fn image_properties(&mut self, id: day_spec::BitmapId) -> Option<day_spec::ImageProperties> {
2358 self.toolkit.image_properties(id)
2359 }
2360
2361 fn encode_image(&mut self, req: u64, id: day_spec::BitmapId, spec: &day_spec::EncodeSpec) {
2362 self.toolkit.encode_image(req, id, spec);
2363 }
2364
2365 fn image_encode_formats(&mut self) -> Vec<day_spec::ImageFormat> {
2366 self.toolkit.encode_formats()
2367 }
2368
2369 fn release_image(&mut self, id: day_spec::BitmapId) {
2370 self.toolkit.release_image(id);
2371 }
2372
2373 fn render_bitmap(
2374 &mut self,
2375 req: u64,
2376 id: day_spec::BitmapId,
2377 ops: &[day_spec::DrawOp],
2378 size: Size,
2379 scale: f64,
2380 ) {
2381 self.toolkit.render_bitmap(req, id, ops, size, scale);
2382 }
2383
2384 fn render_pdf(&mut self, req: u64, pages: &[day_spec::PdfPage], info: &day_spec::PdfInfo) {
2385 self.toolkit.render_pdf(req, pages, info);
2386 }
2387
2388 fn window_image_support(&mut self) -> day_spec::Support {
2389 self.toolkit.capability(day_spec::Cap::Snapshot)
2390 }
2391
2392 fn font_families(&mut self) -> Vec<day_spec::FontFamilyInfo> {
2393 self.toolkit.font_families()
2394 }
2395
2396 fn measure_text(
2397 &mut self,
2398 text: &str,
2399 size: f64,
2400 font: &day_spec::CanvasFont,
2401 ) -> Option<day_spec::TextMetrics> {
2402 self.toolkit.measure_text(text, size, font)
2403 }
2404
2405 fn ui_idle(&mut self) -> bool {
2406 self.toolkit.ui_idle()
2407 }
2408
2409 fn root_node(&self) -> RNode {
2410 self.windows[0].root
2411 }
2412
2413 fn open_window_root(&mut self, options: &WindowOptions, kind: WindowKind) -> WindowRootReply {
2414 let root = self.nodes.insert(NodeData {
2417 kind: kinds::CONTAINER,
2418 handle: None,
2419 parent: RNode::null(),
2420 children: Vec::new(),
2421 layout: Rc::new(PassThrough),
2422 flex: Flex::default(),
2423 scope: Scope::root(),
2424 id: None,
2425 parked_id: None,
2426 a11y: Default::default(),
2427 cache: Vec::new(),
2428 baseline_cache: None,
2429 probe: NodeProbe::default(),
2430 needs_measure: true,
2431 needs_layout: true,
2432 last_native_frame: None,
2433 scroll_content: None,
2434 implicit_anim: None,
2435 tweaked: false,
2436 is_boundary: true,
2437 });
2438 match self.toolkit.open_window(rnode_to_id(root), options, kind) {
2439 day_spec::WindowOpenReply::Open(h) => {
2440 self.nodes[root].handle = Some(h);
2441 self.windows.push(WindowEntry {
2442 root,
2443 size: options.size,
2444 });
2445 self.layout_dirty = true;
2446 WindowRootReply::Open(root)
2447 }
2448 day_spec::WindowOpenReply::Pending => WindowRootReply::Pending(root),
2449 day_spec::WindowOpenReply::Unsupported => {
2450 self.nodes.remove(root);
2451 WindowRootReply::Unsupported
2452 }
2453 }
2454 }
2455
2456 fn adopt_window_root(&mut self, root: RNode, raw: day_spec::RawHandle, size: Size) -> bool {
2457 let Some(node) = self.nodes.get_mut(root) else {
2458 return false; };
2460 let handle = self.toolkit.adopt(raw);
2461 node.handle = Some(handle);
2462 node.needs_measure = true;
2463 self.windows.push(WindowEntry { root, size });
2464 self.layout_dirty = true;
2465 true
2466 }
2467
2468 fn remove_window_root(&mut self, root: RNode) {
2469 if self.windows.len() <= 1 {
2477 self.collect_and_release(root);
2478 self.layout_dirty = true;
2479 return;
2480 }
2481 self.windows.retain(|w| w.root != root);
2482 self.collect_and_release(root);
2485 self.layout_dirty = true;
2486 }
2487
2488 fn set_root_size(&mut self, root: RNode, s: Size) {
2489 if let Some(w) = self.windows.iter_mut().find(|w| w.root == root)
2490 && w.size != s
2491 {
2492 w.size = s;
2493 self.mark_needs_measure_impl(root);
2494 }
2495 }
2496
2497 fn fit_window(&mut self, root: RNode, size: Size) {
2498 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2499 self.toolkit.fit_window(&h, size);
2500 }
2501 self.set_root_size(root, size);
2502 }
2503
2504 fn add_extra_layout_root(&mut self, node: RNode, size: Size) {
2505 if !self.windows.iter().any(|w| w.root == node) {
2506 self.windows.push(WindowEntry { root: node, size });
2507 self.layout_dirty = true;
2508 }
2509 }
2510
2511 fn drop_extra_layout_root(&mut self, node: RNode) {
2512 debug_assert!(
2513 self.windows.first().map(|w| w.root) != Some(node),
2514 "drop_extra_layout_root called with the primary root"
2515 );
2516 self.windows.retain(|w| w.root != node);
2517 }
2518
2519 fn close_native_window(&mut self, root: RNode) {
2520 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2521 self.toolkit.close_window(&h);
2522 }
2523 }
2524
2525 fn quit_app(&mut self) {
2526 self.toolkit.quit_app();
2527 }
2528
2529 fn focus_native_window(&mut self, root: RNode) {
2530 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2531 self.toolkit.focus_window(&h);
2532 }
2533 }
2534
2535 fn set_native_window_title(&mut self, root: RNode, title: &str) {
2536 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2537 self.toolkit.set_window_title(&h, title);
2538 }
2539 }
2540
2541 fn apply_window(&mut self, root: RNode, change: &day_spec::WindowChange) {
2542 if let Some(h) = self.nodes.get(root).and_then(|n| n.handle.clone()) {
2543 self.toolkit.apply_window(&h, change);
2544 }
2545 }
2546
2547 fn set_dock_menu(&mut self, items: &[day_spec::MenuItem]) {
2548 self.toolkit.set_dock_menu(items);
2549 }
2550
2551 fn set_status_items(&mut self, items: &[day_spec::StatusItemSpec]) {
2552 self.toolkit.set_status_items(items);
2553 }
2554
2555 fn set_app_progress(&mut self, progress: day_spec::AppProgress) {
2556 self.toolkit.set_app_progress(progress);
2557 }
2558
2559 fn set_dock_visible(&mut self, visible: bool) {
2560 self.toolkit.set_dock_visible(visible);
2561 }
2562
2563 fn set_keep_running(&mut self, keep: bool) {
2564 self.toolkit.set_keep_running(keep);
2565 }
2566
2567 fn native_window_frame(&self, root: RNode) -> Option<day_spec::Rect> {
2568 let h = self.nodes.get(root).and_then(|n| n.handle.clone())?;
2569 self.toolkit.window_frame(&h)
2570 }
2571
2572 fn monitors(&self) -> Vec<day_spec::Monitor> {
2573 self.toolkit.monitors()
2574 }
2575
2576 fn set_launcher_shortcuts(&mut self, shortcuts: &[day_spec::LauncherShortcut]) {
2577 self.toolkit.set_launcher_shortcuts(shortcuts);
2578 }
2579
2580 fn snapshot_of(&mut self, root: RNode) -> Result<Vec<u8>, String> {
2581 if self.windows[0].root == root {
2582 return self.toolkit.snapshot_window();
2583 }
2584 match self.nodes.get(root).and_then(|n| n.handle.clone()) {
2585 Some(h) => self.toolkit.snapshot_window_of(&h),
2586 None => Err("window is gone".into()),
2587 }
2588 }
2589
2590 fn install_list(&mut self, node: RNode, driver: crate::list::ListDriver) {
2591 let driver = Rc::new(driver);
2592 let sections = driver
2593 .sections
2594 .is_some()
2595 .then(|| crate::list::register_sections(node, driver.clone()));
2596 self.lists.insert(
2597 node,
2598 crate::list::ListState {
2599 driver: driver.clone(),
2600 cells: HashMap::new(),
2601 sections: sections.clone(),
2602 },
2603 );
2604 let source = crate::list::make_source(node, driver, sections);
2605 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2606 self.toolkit.attach_list(&handle, source);
2607 }
2608 }
2609
2610 fn list_prepare_cell(
2611 &mut self,
2612 node: RNode,
2613 key: usize,
2614 cell: RawHandle,
2615 header: bool,
2616 ) -> crate::list::CellStep {
2617 if let Some(state) = self.lists.get_mut(&node)
2621 && state.cells.get(&key).is_some_and(|b| b.header != header)
2622 && let Some(old) = state.cells.remove(&key)
2623 {
2624 old.scope.dispose();
2625 self.remove_subtree_impl(old.anchor);
2626 }
2627 if let Some(state) = self.lists.get_mut(&node)
2628 && let Some(bound) = state.cells.get_mut(&key)
2629 {
2630 bound.active = true;
2631 let (rebind, anchor, pinned) = (bound.rebind.clone(), bound.anchor, bound.pinned);
2632 if !pinned {
2636 self.restore_subtree_ids(anchor);
2637 }
2638 return crate::list::CellStep::Rebind { rebind, anchor };
2639 }
2640 let mut metrics = match self.nodes.get(node).and_then(|n| n.handle.clone()) {
2643 Some(list) => self.toolkit.list_row_metrics(&list),
2644 None => day_spec::RowMetrics::default(),
2645 };
2646 if header {
2650 metrics.insets.top = 0.0;
2651 metrics.insets.bottom = 0.0;
2652 metrics.min_height = 0.0;
2653 }
2654 let handle = self.toolkit.adopt(cell);
2655 let anchor = self.create_cell_anchor(
2656 handle,
2657 Scope::child(),
2658 Rc::new(crate::layout::CellMetrics(metrics)),
2659 );
2660 crate::list::CellStep::Build { anchor }
2661 }
2662
2663 fn list_store_cell(
2664 &mut self,
2665 node: RNode,
2666 key: usize,
2667 anchor: RNode,
2668 built: crate::list::BuiltRow,
2669 header: bool,
2670 ) {
2671 if let Some(state) = self.lists.get_mut(&node) {
2672 state.cells.insert(
2673 key,
2674 crate::list::BoundCell {
2675 anchor,
2676 active: true,
2677 scope: built.scope,
2678 rebind: built.rebind,
2679 native_width: None,
2680 laid_width: None,
2681 laid_height: None,
2682 header,
2683 pinned: false,
2684 },
2685 );
2686 }
2687 }
2688
2689 fn list_layout_cell(&mut self, node: RNode, key: usize) {
2690 let native = self
2696 .lists
2697 .get(&node)
2698 .and_then(|s| s.cells.get(&key))
2699 .and_then(|c| c.native_width);
2700 let width = native.unwrap_or_else(|| {
2701 self.nodes
2702 .get(node)
2703 .and_then(|n| n.last_native_frame)
2704 .map(|f| f.size.width)
2705 .unwrap_or(self.windows[0].size.width)
2706 });
2707 self.layout_list_cell_at(node, key, width);
2708 }
2709
2710 fn list_layout_cell_width(&mut self, node: RNode, key: usize, width: f64) {
2711 if let Some(cell) = self
2714 .lists
2715 .get_mut(&node)
2716 .and_then(|s| s.cells.get_mut(&key))
2717 {
2718 cell.native_width = Some(width);
2719 }
2720 self.layout_list_cell_at(node, key, width);
2721 }
2722
2723 fn list_cell_height(&self, node: RNode, key: usize) -> f64 {
2724 self.lists
2725 .get(&node)
2726 .and_then(|s| s.cells.get(&key))
2727 .filter(|b| b.active)
2728 .and_then(|b| b.laid_height)
2729 .unwrap_or(0.0)
2730 }
2731
2732 fn list_cell_keys(&self, node: RNode) -> Vec<usize> {
2733 self.lists
2734 .get(&node)
2735 .map(|s| {
2736 s.cells
2737 .iter()
2738 .filter_map(|(key, cell)| cell.active.then_some(*key))
2739 .collect()
2740 })
2741 .unwrap_or_default()
2742 }
2743
2744 fn list_reload(&mut self, node: RNode) {
2745 if let Some(map) = self.lists.get(&node).and_then(|s| s.sections.as_ref()) {
2746 map.invalidate();
2747 }
2748 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2749 self.toolkit.update(
2750 &handle,
2751 kinds::LIST,
2752 &day_spec::props::ListPatch::Reload as &dyn Any,
2753 None,
2754 );
2755 }
2756 }
2757
2758 fn list_splice(&mut self, node: RNode, deltas: Vec<day_spec::props::RowDelta>) {
2759 if self.lists.get(&node).is_some_and(|s| s.sections.is_some()) {
2762 self.list_reload(node);
2763 return;
2764 }
2765 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2766 self.toolkit.update(
2767 &handle,
2768 kinds::LIST,
2769 &day_spec::props::ListPatch::Splice(deltas) as &dyn Any,
2770 None,
2771 );
2772 }
2773 }
2774
2775 fn set_undo_state(&mut self, state: &day_spec::UndoState) {
2776 self.toolkit.set_undo_state(state);
2777 }
2778
2779 fn set_edit_state(&mut self, state: &day_spec::EditState) {
2780 self.toolkit.set_edit_state(state);
2781 }
2782
2783 fn modifiers(&mut self) -> day_spec::Modifiers {
2784 self.toolkit.modifiers()
2785 }
2786
2787 fn list_scroll_to_end(&mut self, node: RNode) {
2788 if self.lists.get(&node).map(|s| (s.driver.len)()).unwrap_or(0) == 0 {
2791 return;
2792 }
2793 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2794 self.toolkit.update(
2795 &handle,
2796 kinds::LIST,
2797 &day_spec::props::ListPatch::ScrollToEnd as &dyn Any,
2798 None,
2799 );
2800 }
2801 }
2802
2803 fn list_scroll_to_row(&mut self, node: RNode, row: usize) {
2804 let len = self.lists.get(&node).map(|s| (s.driver.len)()).unwrap_or(0);
2805 if len == 0 {
2806 return;
2807 }
2808 let mut row = row.min(len - 1);
2809 if let Some(map) = self.lists.get(&node).and_then(|s| s.sections.as_ref()) {
2810 row = map.display_of(row).unwrap_or(row);
2811 }
2812 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2813 self.toolkit.update(
2814 &handle,
2815 kinds::LIST,
2816 &day_spec::props::ListPatch::ScrollToRow(row) as &dyn Any,
2817 None,
2818 );
2819 }
2820 }
2821
2822 fn list_set_editing(&mut self, node: RNode, on: bool) {
2823 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2824 self.toolkit.update(
2825 &handle,
2826 kinds::LIST,
2827 &day_spec::props::ListPatch::Editing(on) as &dyn Any,
2828 None,
2829 );
2830 }
2831 }
2832
2833 fn list_set_selected(&mut self, node: RNode, rows: Vec<usize>) {
2834 let rows = match self.lists.get(&node).and_then(|s| s.sections.as_ref()) {
2835 Some(map) => rows.iter().filter_map(|i| map.display_of(*i)).collect(),
2836 None => rows,
2837 };
2838 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2839 self.toolkit.update(
2840 &handle,
2841 kinds::LIST,
2842 &day_spec::props::ListPatch::Selected(rows) as &dyn Any,
2843 None,
2844 );
2845 }
2846 }
2847
2848 fn list_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::list::ListDriver>> {
2849 self.lists.get(&node).map(|s| s.driver.clone())
2850 }
2851
2852 fn install_tree(&mut self, node: RNode, driver: crate::tree_driver::TreeDriver) {
2853 let driver = Rc::new(driver);
2854 self.trees.insert(
2855 node,
2856 crate::tree_driver::TreeState {
2857 driver: driver.clone(),
2858 cells: HashMap::new(),
2859 },
2860 );
2861 let source = crate::tree_driver::make_tree_source(node, driver);
2862 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
2863 self.toolkit.attach_tree(&handle, source);
2864 }
2865 }
2866
2867 fn tree_prepare_cell(
2868 &mut self,
2869 node: RNode,
2870 key: usize,
2871 cell: RawHandle,
2872 ) -> crate::tree_driver::TreeCellStep {
2873 if let Some(state) = self.trees.get(&node)
2874 && let Some(bound) = state.cells.get(&key)
2875 {
2876 let (rebind, anchor) = (bound.rebind.clone(), bound.anchor);
2877 self.restore_subtree_ids(anchor);
2879 return crate::tree_driver::TreeCellStep::Rebind { rebind, anchor };
2880 }
2881 let handle = self.toolkit.adopt(cell);
2885 let anchor =
2886 self.create_cell_anchor(handle, Scope::child(), Rc::new(crate::layout::CellCenter));
2887 crate::tree_driver::TreeCellStep::Build { anchor }
2888 }
2889
2890 fn tree_store_cell(
2891 &mut self,
2892 node: RNode,
2893 key: usize,
2894 anchor: RNode,
2895 built: crate::tree_driver::TreeBuiltRow,
2896 ) {
2897 if let Some(state) = self.trees.get_mut(&node) {
2898 state.cells.insert(
2899 key,
2900 crate::tree_driver::TreeBoundCell {
2901 anchor,
2902 scope: built.scope,
2903 rebind: built.rebind,
2904 native_width: None,
2905 native_height: None,
2906 laid_width: None,
2907 laid_height: None,
2908 },
2909 );
2910 }
2911 }
2912
2913 fn tree_layout_cell(&mut self, node: RNode, key: usize) {
2914 let native = self
2918 .trees
2919 .get(&node)
2920 .and_then(|s| s.cells.get(&key))
2921 .and_then(|c| c.native_width);
2922 let width = native.unwrap_or_else(|| {
2923 self.nodes
2924 .get(node)
2925 .and_then(|n| n.last_native_frame)
2926 .map(|f| f.size.width)
2927 .unwrap_or(self.windows[0].size.width)
2928 });
2929 self.layout_tree_cell_at(node, key, width);
2930 }
2931
2932 fn tree_layout_cell_width(&mut self, node: RNode, key: usize, width: f64) {
2933 if let Some(cell) = self
2936 .trees
2937 .get_mut(&node)
2938 .and_then(|s| s.cells.get_mut(&key))
2939 {
2940 cell.native_width = Some(width);
2941 }
2942 self.layout_tree_cell_at(node, key, width);
2943 }
2944
2945 fn tree_cell_height(&self, node: RNode, key: usize) -> f64 {
2946 self.trees
2947 .get(&node)
2948 .and_then(|s| s.cells.get(&key))
2949 .and_then(|b| b.laid_height)
2950 .unwrap_or(0.0)
2951 }
2952
2953 fn tree_layout_cell_size(&mut self, node: RNode, key: usize, size: Size) {
2954 let changed = self
2955 .trees
2956 .get_mut(&node)
2957 .and_then(|s| s.cells.get_mut(&key))
2958 .and_then(|cell| {
2959 let changed = cell.native_height != Some(size.height);
2960 cell.native_height = Some(size.height);
2961 changed.then_some(cell.anchor)
2962 });
2963 if let Some(anchor) = changed {
2964 self.invalidate_subtree(anchor);
2965 }
2966 self.tree_layout_cell_width(node, key, size.width);
2967 }
2968
2969 fn tree_recycle_cell(&mut self, node: RNode, key: usize) {
2970 let Some(anchor) = self
2971 .trees
2972 .get(&node)
2973 .and_then(|s| s.cells.get(&key))
2974 .map(|b| b.anchor)
2975 else {
2976 return;
2977 };
2978 self.clear_subtree_ids(anchor);
2979 }
2980
2981 fn list_recycle_cell(&mut self, node: RNode, key: usize) {
2982 let Some(anchor) = self
2983 .lists
2984 .get_mut(&node)
2985 .and_then(|s| s.cells.get_mut(&key))
2986 .map(|b| {
2987 b.active = false;
2988 b.laid_height = None;
2993 b.anchor
2994 })
2995 else {
2996 return;
2997 };
2998 self.clear_subtree_ids(anchor);
2999 }
3000
3001 fn list_release_cell(&mut self, node: RNode, key: usize) {
3002 let Some(cell) = self.lists.get_mut(&node).and_then(|s| s.cells.remove(&key)) else {
3004 return;
3005 };
3006 cell.scope.dispose();
3011 self.remove_subtree_impl(cell.anchor);
3012 }
3013
3014 fn list_pin_cell(&mut self, node: RNode, key: usize) {
3015 let Some(anchor) = self
3016 .lists
3017 .get_mut(&node)
3018 .and_then(|s| s.cells.get_mut(&key))
3019 .map(|b| {
3020 b.pinned = true;
3021 b.anchor
3022 })
3023 else {
3024 return;
3025 };
3026 self.clear_subtree_ids(anchor);
3027 }
3028
3029 fn tree_reload(&mut self, node: RNode) {
3030 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3031 self.toolkit.update(
3032 &handle,
3033 kinds::TREE,
3034 &day_spec::props::TreePatch::Reload as &dyn Any,
3035 None,
3036 );
3037 }
3038 }
3039
3040 fn tree_set_expanded(&mut self, node: RNode, token: u64, expanded: bool) {
3041 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3042 self.toolkit.update(
3043 &handle,
3044 kinds::TREE,
3045 &day_spec::props::TreePatch::Expand(token, expanded) as &dyn Any,
3046 None,
3047 );
3048 }
3049 }
3050
3051 fn tree_set_selected(&mut self, node: RNode, tokens: Vec<u64>) {
3052 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3053 self.toolkit.update(
3054 &handle,
3055 kinds::TREE,
3056 &day_spec::props::TreePatch::Selected(tokens) as &dyn Any,
3057 None,
3058 );
3059 }
3060 }
3061
3062 fn tree_reveal(&mut self, node: RNode, token: u64) {
3063 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3064 self.toolkit.update(
3065 &handle,
3066 kinds::TREE,
3067 &day_spec::props::TreePatch::Reveal(token) as &dyn Any,
3068 None,
3069 );
3070 }
3071 }
3072
3073 fn tree_driver(&mut self, node: RNode) -> Option<std::rc::Rc<crate::tree_driver::TreeDriver>> {
3074 self.trees.get(&node).map(|s| s.driver.clone())
3075 }
3076
3077 fn set_drag_source(&mut self, node: RNode, source: day_spec::transfer::Source) {
3078 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3079 self.toolkit.set_drag_source(&handle, source);
3080 }
3081 }
3082 fn set_drop_target(&mut self, node: RNode, target: day_spec::transfer::Target) {
3083 if let Some(handle) = self.nodes.get(node).and_then(|n| n.handle.clone()) {
3084 self.toolkit.set_drop_target(&handle, target);
3085 }
3086 }
3087 fn set_context_menu_fn(&mut self, node: RNode, f: day_spec::ContextMenuFn) {
3088 let target = if self.nodes.get(node).is_some_and(|n| n.handle.is_some()) {
3091 Some(node)
3092 } else {
3093 let mut roots = Vec::new();
3094 self.native_descendants(node, &mut roots);
3095 roots.first().copied()
3096 };
3097 let Some(target) = target else {
3098 log::warn!("context_menu_fn on a subtree with no native view — menu dropped");
3099 return;
3100 };
3101 let model = ContextMenuModel::Provider(f.clone());
3102 self.context_menus.insert(node, model.clone());
3103 self.context_menus.insert(target, model);
3104 if let Some(handle) = self.nodes.get(target).and_then(|n| n.handle.clone()) {
3105 self.toolkit
3106 .set_context_menu_fn(&handle, rnode_to_id(target), f);
3107 }
3108 }
3109
3110 fn context_menu_of(&mut self, node: RNode) -> Option<day_spec::ContextMenuFn> {
3111 let mut cur = node;
3114 loop {
3115 if let Some(model) = self.context_menus.get(&cur) {
3116 return Some(match model {
3117 ContextMenuModel::Items(items) => {
3118 let items = items.clone();
3119 Rc::new(move |_| items.clone())
3120 }
3121 ContextMenuModel::Provider(f) => f.clone(),
3122 });
3123 }
3124 let parent = self.nodes.get(cur)?.parent;
3127 if parent == cur {
3128 return None;
3129 }
3130 cur = parent;
3131 }
3132 }
3133}
3134
3135day_reactive::tls_slots! {
3140 tree;
3141 static TREE: std::mem::ManuallyDrop<RefCell<Option<Box<dyn TreeOps>>>> =
3150 const { std::mem::ManuallyDrop::new(RefCell::new(None)) };
3151 static EVENTS: RefCell<VecDeque<(NodeId, Event)>> = const { RefCell::new(VecDeque::new()) };
3152 static PUMP_PENDING: Cell<bool> = const { Cell::new(false) };
3153 static PUMP_ACTIVE: Cell<bool> = const { Cell::new(false) };
3154 static DEFERRED: RefCell<Vec<Box<dyn FnOnce() + Send>>> = const { RefCell::new(Vec::new()) };
3157 static EVENT_OBSERVER: RefCell<Option<Rc<EventObserver>>> = const { RefCell::new(None) };
3161 static PUMP_GEN: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
3166
3167 static FOCUSED: std::cell::Cell<Option<RNode>> = const { std::cell::Cell::new(None) };
3169}
3170
3171pub fn install_tree(tree: Box<dyn TreeOps>) {
3172 crate::nav::clear_controllers();
3174 TREE.with(|t| *t.borrow_mut() = Some(tree));
3175 let _ = crate::image::canvas_exports();
3178}
3179
3180pub fn prepare_remount() {
3198 day_reactive::recover_from_panic();
3204 uninstall_tree();
3205 day_reactive::recover_from_panic();
3207 crate::lifecycle::reset_handlers();
3208 crate::menu::reset_menus();
3209}
3210
3211pub fn is_mounted() -> bool {
3217 TREE.with(|t| t.borrow().is_some())
3218}
3219
3220pub fn uninstall_tree() {
3222 crate::image::reset();
3224 crate::nav::clear_controllers();
3225 crate::windows::reset_windows();
3226 crate::status::reset_status();
3227 crate::reset_ambient();
3230 TREE.with(|t| *t.borrow_mut() = None);
3231 EVENTS.with(|e| e.borrow_mut().clear());
3232 PUMP_PENDING.with(|c| c.set(false));
3233 EVENT_OBSERVER.with(|o| *o.borrow_mut() = None);
3236}
3237
3238pub fn with_tree<R>(f: impl FnOnce(&mut dyn TreeOps) -> R) -> R {
3242 let r = TREE.with(|t| {
3243 let mut opt = t.borrow_mut();
3244 let ops = opt.as_mut().expect("day: no tree installed on this thread");
3245 f(ops.as_mut())
3246 });
3247 if PUMP_PENDING.with(|c| c.replace(false)) {
3248 pump_events();
3249 }
3250 run_deferred();
3251 r
3252}
3253
3254pub(crate) fn run_posted_or_defer(f: Box<dyn FnOnce() + Send>) {
3261 let borrowed = TREE.with(|t| t.try_borrow_mut().is_err());
3262 if borrowed {
3263 DEFERRED.with(|d| d.borrow_mut().push(f));
3264 } else {
3265 crate::contain_posted_panic(f);
3266 }
3267}
3268
3269fn run_deferred() {
3273 loop {
3274 let batch = DEFERRED.with(|d| std::mem::take(&mut *d.borrow_mut()));
3275 if batch.is_empty() {
3276 return;
3277 }
3278 for f in batch {
3279 crate::contain_posted_panic(f);
3280 }
3281 }
3282}
3283
3284pub fn capability(cap: day_spec::Cap) -> day_spec::Support {
3288 with_tree(|t| t.capability(cap))
3289}
3290
3291pub fn open_url(url: &str) {
3296 if crate::conformance::intercept_open_url(url) {
3299 return;
3300 }
3301 with_tree(|t| t.open_url(url));
3302}
3303
3304pub fn announce(text: &str) {
3310 crate::conformance::note_announcement(text);
3311 with_tree(|t| t.announce(text, false));
3312}
3313
3314pub fn announce_urgent(text: &str) {
3317 crate::conformance::note_announcement(text);
3318 with_tree(|t| t.announce(text, true));
3319}
3320
3321pub fn share_support() -> Support {
3323 with_tree(|t| t.share_support())
3324}
3325pub fn share_url(url: &str, title: &str) -> bool {
3329 with_tree(|t| t.share_url(url, title))
3330}
3331
3332pub fn application_handlers(
3335 query: &day_spec::applications::HandlerQuery,
3336) -> Result<day_spec::applications::ApplicationHandlers, day_spec::applications::ApplicationError> {
3337 with_tree(|t| t.application_handlers(query))
3338}
3339
3340pub fn default_browser()
3342-> Result<Option<day_spec::applications::Application>, day_spec::applications::ApplicationError> {
3343 application_handlers(&day_spec::applications::HandlerQuery::Scheme(
3344 "https".into(),
3345 ))
3346 .map(|h| h.default)
3347}
3348
3349pub async fn open_url_with_application(
3352 url: &str,
3353 application: &str,
3354) -> Result<(), day_spec::applications::ApplicationError> {
3355 let (send, receive) = day_async::oneshot();
3356 with_tree(|t| {
3357 t.open_url_with_application(url, application, Box::new(move |result| send.send(result)))
3358 });
3359 receive
3360 .await
3361 .unwrap_or(Err(day_spec::applications::ApplicationError::LaunchFailed))
3362}
3363
3364pub fn invalidate_size(node: RNode) {
3370 with_tree(|t| {
3371 t.mark_needs_measure(node);
3372 t.mark_layout_dirty();
3373 });
3374}
3375
3376pub fn try_with_tree<R>(f: impl FnOnce(&mut dyn TreeOps) -> R) -> Option<R> {
3386 let r = TREE.with(|t| {
3387 let mut opt = t.try_borrow_mut().ok()?;
3388 let ops = opt.as_mut()?;
3389 Some(f(ops.as_mut()))
3390 });
3391 if r.is_some() {
3392 if PUMP_PENDING.with(|c| c.replace(false)) {
3393 pump_events();
3394 }
3395 run_deferred();
3396 }
3397 r
3398}
3399
3400pub(crate) fn with_tree_if_free<R>(f: impl FnOnce(&mut dyn TreeOps) -> R) -> Option<R> {
3403 TREE.with(|t| {
3404 let mut opt = t.try_borrow_mut().ok()?;
3405 let ops = opt.as_mut()?;
3406 Some(f(ops.as_mut()))
3407 })
3408}
3409
3410pub(crate) fn tree_absent() -> bool {
3413 TREE.try_with(|t| t.try_borrow().map(|o| o.is_none()).unwrap_or(false))
3415 .unwrap_or(true)
3416}
3417
3418pub(crate) fn request_pump() {
3421 PUMP_PENDING.with(|c| c.set(true));
3422}
3423
3424pub fn has_tree() -> bool {
3425 !tree_absent()
3428}
3429
3430pub fn enqueue_event(id: NodeId, ev: Event) {
3433 enqueue_events([(id, ev)]);
3434}
3435
3436pub(crate) fn enqueue_native_event(id: NodeId, ev: Event) {
3441 if let Some(ev) = crate::list::translate_native_event(id, ev) {
3442 enqueue_event(id, ev);
3443 }
3444}
3445
3446pub fn enqueue_events(evs: impl IntoIterator<Item = (NodeId, Event)>) {
3451 let observer = EVENT_OBSERVER.with(|o| o.borrow().clone());
3460 match observer {
3461 Some(obs) => {
3462 let batch: Vec<(NodeId, Event)> = evs.into_iter().collect();
3463 for (id, ev) in &batch {
3464 obs(*id, ev);
3465 }
3466 EVENTS.with(|e| e.borrow_mut().extend(batch));
3467 }
3468 None => EVENTS.with(|e| e.borrow_mut().extend(evs)),
3469 }
3470 let tree_free = TREE.with(|t| t.try_borrow_mut().is_ok());
3471 if tree_free {
3472 pump_events();
3473 } else {
3474 PUMP_PENDING.with(|c| c.set(true));
3475 }
3476}
3477
3478pub fn pump_generation() -> u64 {
3480 PUMP_GEN.with(|g| g.get())
3481}
3482
3483pub fn set_event_observer(observer: Option<Box<EventObserver>>) {
3492 EVENT_OBSERVER.with(|o| *o.borrow_mut() = observer.map(Rc::from));
3493}
3494
3495pub fn id_of(node: NodeId) -> Option<String> {
3502 try_with_tree(|t| t.node_id(id_to_rnode(node))).flatten()
3503}
3504
3505pub fn label_of(node: NodeId) -> Option<String> {
3509 try_with_tree(|t| {
3510 let rnode = id_to_rnode(node);
3511 let a11y = t
3512 .node_a11y(rnode)
3513 .and_then(|a| a.label)
3514 .filter(|s| !s.is_empty());
3515 a11y.or_else(|| {
3516 t.node_probe(rnode)
3517 .map(|p| p.text)
3518 .filter(|s| !s.is_empty())
3519 })
3520 })
3521 .flatten()
3522}
3523
3524pub fn pump_events() {
3532 if PUMP_ACTIVE.with(|active| active.replace(true)) {
3536 return;
3537 }
3538 struct PumpGuard;
3539 impl Drop for PumpGuard {
3540 fn drop(&mut self) {
3541 PUMP_ACTIVE.with(|active| active.set(false));
3542 }
3543 }
3544 let _guard = PumpGuard;
3545 let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
3546 loop {
3547 pump_events_inner();
3548 if EVENTS.with(|events| events.borrow().is_empty()) {
3551 break;
3552 }
3553 }
3554 }));
3555 if let Err(payload) = result {
3556 let msg = payload
3557 .downcast_ref::<&str>()
3558 .map(|s| (*s).to_string())
3559 .or_else(|| payload.downcast_ref::<String>().cloned())
3560 .unwrap_or_else(|| "unknown panic".to_string());
3561 log::warn!(
3562 "a native event handler panicked and was contained — the app continues, but \
3563 reactive/UI state may be inconsistent until the next interaction. Cause: {msg}"
3564 );
3565 EVENTS.with(|e| e.borrow_mut().clear());
3567 PUMP_PENDING.with(|c| c.set(false));
3568 day_reactive::recover_from_panic();
3569 crate::notify_contained_panic();
3570 }
3571}
3572
3573fn pump_events_inner() {
3574 crate::image::flush_deferred_releases();
3576 PUMP_GEN.with(|g| g.set(g.get() + 1));
3581 crate::nav::maybe_notify_route_change();
3582 loop {
3583 let item = EVENTS.with(|e| e.borrow_mut().pop_front());
3584 let Some((id, ev)) = item else { break };
3585 if let Event::PresentResult { req, result } = ev {
3587 crate::present::resolve_presentation(req, result);
3588 continue;
3589 }
3590 if let Event::ImageDecoded { req, result } = ev {
3593 crate::image::resolve_image_decode(req, result);
3594 continue;
3595 }
3596 if let Event::ImageEncoded { req, result } = ev {
3597 crate::image::resolve_image_encode(req, result);
3598 continue;
3599 }
3600 if let Event::BitmapRendered { req, result } = ev {
3602 crate::image::resolve_bitmap_render(req, result);
3603 continue;
3604 }
3605 if let Event::PdfRendered { req, result } = ev {
3606 crate::image::resolve_pdf_render(req, result);
3607 continue;
3608 }
3609 if let Event::MenuAction(action) = ev {
3611 crate::menu::dispatch_menu_action(action);
3612 continue;
3613 }
3614 if let Event::ToolbarChanged { action, value } = &ev {
3617 crate::toolbar::dispatch_toolbar_value(*action, value);
3618 continue;
3619 }
3620 if let Event::Lifecycle(phase) = ev {
3622 crate::lifecycle::dispatch_lifecycle(phase);
3623 continue;
3624 }
3625 if ev == Event::FocusChanged(false) {
3630 let paired = EVENTS.with(|e| {
3631 let mut q = e.borrow_mut();
3632 let gain = q
3633 .iter()
3634 .position(|(gid, gev)| *gid != id && *gev == Event::FocusChanged(true));
3635 gain.map(|i| q.remove(i).expect("indexed event"))
3636 });
3637 if let Some((gid, gev)) = paired {
3638 dispatch_focus_probe(gid, &gev);
3639 dispatch_to_node(gid, &gev);
3640 }
3641 }
3642 if let Event::FocusChanged(_) = ev {
3643 dispatch_focus_probe(id, &ev);
3644 }
3645 dispatch_to_node(id, &ev);
3646 }
3647 day_reactive::flush_sync();
3648 crate::nav::maybe_notify_route_change();
3655}
3656
3657pub fn focused_node() -> Option<RNode> {
3661 FOCUSED.with(|f| f.get())
3662}
3663
3664fn dispatch_focus_probe(id: NodeId, ev: &Event) {
3666 if let Event::FocusChanged(f) = ev {
3667 let node = id_to_rnode(id);
3668 with_tree(|t| t.set_probe_focused(node, *f));
3669 }
3670}
3671
3672pub fn scroll_to(node: RNode, target: ScrollTarget) {
3677 with_tree(|t| {
3678 t.scroll_to_target(node, &target, true);
3679 });
3680}
3681
3682fn dispatch_to_node(id: NodeId, ev: &Event) {
3684 let node = if id == day_spec::WINDOW_NODE {
3685 with_tree(|t| t.root_node())
3686 } else {
3687 id_to_rnode(id)
3688 };
3689 let gesture = match ev {
3695 Event::Tap(_) => Some(day_spec::GestureKind::Tap),
3696 Event::LongPress(_) => Some(day_spec::GestureKind::LongPress),
3697 Event::Drag { .. } => Some(day_spec::GestureKind::Drag),
3698 Event::Pan { .. } => Some(day_spec::GestureKind::Pan),
3699 Event::Pinch { .. } => Some(day_spec::GestureKind::Pinch),
3700 Event::Hover { .. } => Some(day_spec::GestureKind::Hover),
3701 _ => None,
3702 };
3703 let node = match gesture.and_then(|k| with_tree(|t| t.gesture_target(node, k))) {
3704 Some(target) => target,
3705 None => node,
3706 };
3707 let mut handlers = with_tree(|t| t.handlers_for(node));
3708 if matches!(ev, Event::Key(_) | Event::FocusChanged(_)) {
3713 with_tree(|t| {
3714 for w in t.wrappers_above(node) {
3715 handlers.extend(t.handlers_for(w));
3716 }
3717 });
3718 }
3719 if handlers.is_empty() {
3720 if cfg!(debug_assertions)
3724 && matches!(ev, Event::Pressed | Event::Tap(_))
3725 && !with_tree(|t| t.node_exists(node))
3726 {
3727 log::warn!("{ev:?} dropped — node {id:?} no longer exists (stale reference)");
3728 }
3729 return;
3730 }
3731 day_reactive::batch(|| {
3732 for h in &handlers {
3733 h(ev);
3734 }
3735 });
3736}
3737
3738fn collect_menu_families(
3739 items: &[day_spec::MenuItem],
3740 families: &mut std::collections::BTreeSet<String>,
3741) {
3742 for item in items {
3743 match item {
3744 day_spec::MenuItem::Action { id: Some(id), .. } => {
3745 families.insert(crate::element_id::family_of(id).to_owned());
3746 }
3747 day_spec::MenuItem::Submenu { items, .. } => collect_menu_families(items, families),
3748 _ => {}
3749 }
3750 }
3751}
3752
3753#[cfg(test)]
3754mod thread_exit_tests {
3755 use super::*;
3756 use std::sync::Arc;
3757 use std::sync::atomic::{AtomicBool, Ordering};
3758
3759 struct Probe(Arc<AtomicBool>);
3761
3762 impl Drop for Probe {
3763 fn drop(&mut self) {
3764 self.0.store(true, Ordering::SeqCst);
3765 }
3766 }
3767
3768 impl Toolkit for Probe {
3769 type Handle = ();
3770 fn realize(&mut self, _: PieceKind, _: &dyn Any, _: NodeId) -> Self::Handle {}
3771 fn release(&mut self, _: Self::Handle) {}
3772 fn insert(&mut self, _: &Self::Handle, _: &Self::Handle, _: usize) {}
3773 fn remove(&mut self, _: &Self::Handle, _: &Self::Handle) {
3774 panic!("test probe has no attached children to remove");
3775 }
3776 fn move_child(&mut self, _: &Self::Handle, _: &Self::Handle, _: usize) {}
3777 fn measure(&mut self, _: &Self::Handle, _: PieceKind, _: Proposal) -> Size {
3778 Size::new(0.0, 0.0)
3779 }
3780 fn set_frame(&mut self, _: &Self::Handle, _: Rect, _: Option<&AnimSpec>) {}
3781 fn set_input_traits(&mut self, _: &Self::Handle, _: &InputTraits) -> Option<Self::Handle> {
3782 None
3783 }
3784 fn set_event_sink(&mut self, _: EventSink) {}
3785 fn update(&mut self, _: &Self::Handle, _: &'static str, _: &dyn Any, _: Option<&AnimSpec>) {
3786 }
3787 }
3788
3789 fn install_probe(dropped: &Arc<AtomicBool>) {
3790 let tree = Tree::new(Probe(dropped.clone()), (), Size::new(0.0, 0.0));
3791 install_tree(Box::new(tree));
3792 }
3793
3794 #[test]
3799 fn the_tree_is_not_dropped_when_its_thread_ends() {
3800 let dropped = Arc::new(AtomicBool::new(false));
3801 let d = dropped.clone();
3802 std::thread::spawn(move || install_probe(&d))
3803 .join()
3804 .expect("thread");
3805 assert!(
3806 !dropped.load(Ordering::SeqCst),
3807 "the thread-local destructor dropped the tree, and with it the native widgets"
3808 );
3809 }
3810
3811 #[test]
3814 fn uninstall_still_drops_the_tree() {
3815 let dropped = Arc::new(AtomicBool::new(false));
3816 let d = dropped.clone();
3817 std::thread::spawn(move || {
3818 install_probe(&d);
3819 uninstall_tree();
3820 assert!(
3821 d.load(Ordering::SeqCst),
3822 "uninstall_tree must drop the tree"
3823 );
3824 })
3825 .join()
3826 .expect("thread");
3827 }
3828
3829 #[test]
3830 fn removing_an_unattached_node_releases_without_native_detach() {
3831 let dropped = Arc::new(AtomicBool::new(false));
3832 let mut tree = Tree::new(Probe(dropped), (), Size::new(0.0, 0.0));
3833 let scope = Scope::detached();
3834 let node = tree.create_node(
3835 "fixture.detached",
3836 &(),
3837 Rc::new(crate::LeafLayout),
3838 Flex::default(),
3839 true,
3840 false,
3841 scope,
3842 );
3843 tree.remove_subtree(node);
3844 assert!(!tree.node_exists(node));
3845 assert_eq!(
3846 tree.release_queue.len(),
3847 1,
3848 "the unattached native handle must still be released"
3849 );
3850 scope.dispose();
3851 }
3852
3853 #[test]
3858 fn a_post_during_a_tree_borrow_runs_at_the_safe_point() {
3859 std::thread::spawn(|| {
3860 install_probe(&Arc::new(AtomicBool::new(false)));
3861 let ran = Arc::new(AtomicBool::new(false));
3862 let r = ran.clone();
3863 with_tree(|_| {
3864 run_posted_or_defer(Box::new(move || {
3865 with_tree(|_| r.store(true, Ordering::SeqCst));
3868 }));
3869 assert!(!ran.load(Ordering::SeqCst), "ran inside the borrow");
3870 });
3871 assert!(
3872 ran.load(Ordering::SeqCst),
3873 "never ran after the borrow was released"
3874 );
3875 let now = Arc::new(AtomicBool::new(false));
3877 let n = now.clone();
3878 run_posted_or_defer(Box::new(move || n.store(true, Ordering::SeqCst)));
3879 assert!(
3880 now.load(Ordering::SeqCst),
3881 "a post with the tree free must run at once"
3882 );
3883 uninstall_tree();
3884 })
3885 .join()
3886 .expect("thread");
3887 }
3888}