1use crate::{
2 point, px, Action, AnyDrag, AnyElement, AnyTooltip, AnyView, AppContext, BorrowAppContext,
3 BorrowWindow, Bounds, ClickEvent, DispatchPhase, Element, ElementId, FocusEvent, FocusHandle,
4 IntoElement, KeyContext, KeyDownEvent, KeyUpEvent, LayoutId, MouseButton, MouseDownEvent,
5 MouseMoveEvent, MouseUpEvent, ParentElement, Pixels, Point, Render, ScrollWheelEvent,
6 SharedString, Size, StackingOrder, Style, StyleRefinement, Styled, Task, View, Visibility,
7 WindowContext,
8};
9use collections::HashMap;
10use refineable::Refineable;
11use smallvec::SmallVec;
12use std::{
13 any::{Any, TypeId},
14 cell::RefCell,
15 cmp::Ordering,
16 fmt::Debug,
17 mem,
18 rc::Rc,
19 time::Duration,
20};
21use taffy::style::Overflow;
22use util::ResultExt;
23
24const DRAG_THRESHOLD: f64 = 2.;
25const TOOLTIP_DELAY: Duration = Duration::from_millis(500);
26
27pub struct GroupStyle {
28 pub group: SharedString,
29 pub style: StyleRefinement,
30}
31
32pub trait InteractiveElement: Sized + Element {
33 fn interactivity(&mut self) -> &mut Interactivity;
34
35 fn group(mut self, group: impl Into<SharedString>) -> Self {
36 self.interactivity().group = Some(group.into());
37 self
38 }
39
40 fn id(mut self, id: impl Into<ElementId>) -> Stateful<Self> {
41 self.interactivity().element_id = Some(id.into());
42
43 Stateful { element: self }
44 }
45
46 fn track_focus(mut self, focus_handle: &FocusHandle) -> Focusable<Self> {
47 self.interactivity().focusable = true;
48 self.interactivity().tracked_focus_handle = Some(focus_handle.clone());
49 Focusable { element: self }
50 }
51
52 fn key_context<C, E>(mut self, key_context: C) -> Self
53 where
54 C: TryInto<KeyContext, Error = E>,
55 E: Debug,
56 {
57 if let Some(key_context) = key_context.try_into().log_err() {
58 self.interactivity().key_context = Some(key_context);
59 }
60 self
61 }
62
63 fn hover(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self {
64 self.interactivity().hover_style = f(StyleRefinement::default());
65 self
66 }
67
68 fn group_hover(
69 mut self,
70 group_name: impl Into<SharedString>,
71 f: impl FnOnce(StyleRefinement) -> StyleRefinement,
72 ) -> Self {
73 self.interactivity().group_hover_style = Some(GroupStyle {
74 group: group_name.into(),
75 style: f(StyleRefinement::default()),
76 });
77 self
78 }
79
80 fn on_mouse_down(
81 mut self,
82 button: MouseButton,
83 listener: impl Fn(&MouseDownEvent, &mut WindowContext) + 'static,
84 ) -> Self {
85 self.interactivity().mouse_down_listeners.push(Box::new(
86 move |event, bounds, phase, cx| {
87 if phase == DispatchPhase::Bubble
88 && event.button == button
89 && bounds.visibly_contains(&event.position, cx)
90 {
91 (listener)(event, cx)
92 }
93 },
94 ));
95 self
96 }
97
98 fn on_any_mouse_down(
99 mut self,
100 listener: impl Fn(&MouseDownEvent, &mut WindowContext) + 'static,
101 ) -> Self {
102 self.interactivity().mouse_down_listeners.push(Box::new(
103 move |event, bounds, phase, cx| {
104 if phase == DispatchPhase::Bubble && bounds.visibly_contains(&event.position, cx) {
105 (listener)(event, cx)
106 }
107 },
108 ));
109 self
110 }
111
112 fn on_mouse_up(
113 mut self,
114 button: MouseButton,
115 listener: impl Fn(&MouseUpEvent, &mut WindowContext) + 'static,
116 ) -> Self {
117 self.interactivity()
118 .mouse_up_listeners
119 .push(Box::new(move |event, bounds, phase, cx| {
120 if phase == DispatchPhase::Bubble
121 && event.button == button
122 && bounds.visibly_contains(&event.position, cx)
123 {
124 (listener)(event, cx)
125 }
126 }));
127 self
128 }
129
130 fn on_any_mouse_up(
131 mut self,
132 listener: impl Fn(&MouseUpEvent, &mut WindowContext) + 'static,
133 ) -> Self {
134 self.interactivity()
135 .mouse_up_listeners
136 .push(Box::new(move |event, bounds, phase, cx| {
137 if phase == DispatchPhase::Bubble && bounds.visibly_contains(&event.position, cx) {
138 (listener)(event, cx)
139 }
140 }));
141 self
142 }
143
144 fn on_mouse_down_out(
145 mut self,
146 listener: impl Fn(&MouseDownEvent, &mut WindowContext) + 'static,
147 ) -> Self {
148 self.interactivity().mouse_down_listeners.push(Box::new(
149 move |event, bounds, phase, cx| {
150 if phase == DispatchPhase::Capture && !bounds.visibly_contains(&event.position, cx)
151 {
152 (listener)(event, cx)
153 }
154 },
155 ));
156 self
157 }
158
159 fn on_mouse_up_out(
160 mut self,
161 button: MouseButton,
162 listener: impl Fn(&MouseUpEvent, &mut WindowContext) + 'static,
163 ) -> Self {
164 self.interactivity()
165 .mouse_up_listeners
166 .push(Box::new(move |event, bounds, phase, cx| {
167 if phase == DispatchPhase::Capture
168 && event.button == button
169 && !bounds.visibly_contains(&event.position, cx)
170 {
171 (listener)(event, cx);
172 }
173 }));
174 self
175 }
176
177 fn on_mouse_move(
178 mut self,
179 listener: impl Fn(&MouseMoveEvent, &mut WindowContext) + 'static,
180 ) -> Self {
181 self.interactivity().mouse_move_listeners.push(Box::new(
182 move |event, bounds, phase, cx| {
183 if phase == DispatchPhase::Bubble && bounds.visibly_contains(&event.position, cx) {
184 (listener)(event, cx);
185 }
186 },
187 ));
188 self
189 }
190
191 fn on_scroll_wheel(
192 mut self,
193 listener: impl Fn(&ScrollWheelEvent, &mut WindowContext) + 'static,
194 ) -> Self {
195 self.interactivity().scroll_wheel_listeners.push(Box::new(
196 move |event, bounds, phase, cx| {
197 if phase == DispatchPhase::Bubble && bounds.visibly_contains(&event.position, cx) {
198 (listener)(event, cx);
199 }
200 },
201 ));
202 self
203 }
204
205 /// Capture the given action, before normal action dispatch can fire
206 fn capture_action<A: Action>(
207 mut self,
208 listener: impl Fn(&A, &mut WindowContext) + 'static,
209 ) -> Self {
210 self.interactivity().action_listeners.push((
211 TypeId::of::<A>(),
212 Box::new(move |action, phase, cx| {
213 let action = action.downcast_ref().unwrap();
214 if phase == DispatchPhase::Capture {
215 (listener)(action, cx)
216 }
217 }),
218 ));
219 self
220 }
221
222 /// Add a listener for the given action, fires during the bubble event phase
223 fn on_action<A: Action>(mut self, listener: impl Fn(&A, &mut WindowContext) + 'static) -> Self {
224 self.interactivity().action_listeners.push((
225 TypeId::of::<A>(),
226 Box::new(move |action, phase, cx| {
227 let action = action.downcast_ref().unwrap();
228 if phase == DispatchPhase::Bubble {
229 (listener)(action, cx)
230 }
231 }),
232 ));
233 self
234 }
235
236 fn on_boxed_action(
237 mut self,
238 action: &Box<dyn Action>,
239 listener: impl Fn(&Box<dyn Action>, &mut WindowContext) + 'static,
240 ) -> Self {
241 let action = action.boxed_clone();
242 self.interactivity().action_listeners.push((
243 (*action).type_id(),
244 Box::new(move |_, phase, cx| {
245 if phase == DispatchPhase::Bubble {
246 (listener)(&action, cx)
247 }
248 }),
249 ));
250 self
251 }
252
253 fn on_key_down(
254 mut self,
255 listener: impl Fn(&KeyDownEvent, &mut WindowContext) + 'static,
256 ) -> Self {
257 self.interactivity()
258 .key_down_listeners
259 .push(Box::new(move |event, phase, cx| {
260 if phase == DispatchPhase::Bubble {
261 (listener)(event, cx)
262 }
263 }));
264 self
265 }
266
267 fn capture_key_down(
268 mut self,
269 listener: impl Fn(&KeyDownEvent, &mut WindowContext) + 'static,
270 ) -> Self {
271 self.interactivity()
272 .key_down_listeners
273 .push(Box::new(move |event, phase, cx| {
274 if phase == DispatchPhase::Capture {
275 listener(event, cx)
276 }
277 }));
278 self
279 }
280
281 fn on_key_up(mut self, listener: impl Fn(&KeyUpEvent, &mut WindowContext) + 'static) -> Self {
282 self.interactivity()
283 .key_up_listeners
284 .push(Box::new(move |event, phase, cx| {
285 if phase == DispatchPhase::Bubble {
286 listener(event, cx)
287 }
288 }));
289 self
290 }
291
292 fn capture_key_up(
293 mut self,
294 listener: impl Fn(&KeyUpEvent, &mut WindowContext) + 'static,
295 ) -> Self {
296 self.interactivity()
297 .key_up_listeners
298 .push(Box::new(move |event, phase, cx| {
299 if phase == DispatchPhase::Capture {
300 listener(event, cx)
301 }
302 }));
303 self
304 }
305
306 fn drag_over<S: 'static>(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self {
307 self.interactivity()
308 .drag_over_styles
309 .push((TypeId::of::<S>(), f(StyleRefinement::default())));
310 self
311 }
312
313 fn group_drag_over<S: 'static>(
314 mut self,
315 group_name: impl Into<SharedString>,
316 f: impl FnOnce(StyleRefinement) -> StyleRefinement,
317 ) -> Self {
318 self.interactivity().group_drag_over_styles.push((
319 TypeId::of::<S>(),
320 GroupStyle {
321 group: group_name.into(),
322 style: f(StyleRefinement::default()),
323 },
324 ));
325 self
326 }
327
328 fn on_drop<W: 'static>(
329 mut self,
330 listener: impl Fn(&View<W>, &mut WindowContext) + 'static,
331 ) -> Self {
332 self.interactivity().drop_listeners.push((
333 TypeId::of::<W>(),
334 Box::new(move |dragged_view, cx| {
335 listener(&dragged_view.downcast().unwrap(), cx);
336 }),
337 ));
338 self
339 }
340}
341
342pub trait StatefulInteractiveElement: InteractiveElement {
343 fn focusable(mut self) -> Focusable<Self> {
344 self.interactivity().focusable = true;
345 Focusable { element: self }
346 }
347
348 fn overflow_scroll(mut self) -> Self {
349 self.interactivity().base_style.overflow.x = Some(Overflow::Scroll);
350 self.interactivity().base_style.overflow.y = Some(Overflow::Scroll);
351 self
352 }
353
354 fn overflow_x_scroll(mut self) -> Self {
355 self.interactivity().base_style.overflow.x = Some(Overflow::Scroll);
356 self
357 }
358
359 fn overflow_y_scroll(mut self) -> Self {
360 self.interactivity().base_style.overflow.y = Some(Overflow::Scroll);
361 self
362 }
363
364 fn track_scroll(mut self, scroll_handle: &ScrollHandle) -> Self {
365 self.interactivity().scroll_handle = Some(scroll_handle.clone());
366 self
367 }
368
369 fn active(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
370 where
371 Self: Sized,
372 {
373 self.interactivity().active_style = f(StyleRefinement::default());
374 self
375 }
376
377 fn group_active(
378 mut self,
379 group_name: impl Into<SharedString>,
380 f: impl FnOnce(StyleRefinement) -> StyleRefinement,
381 ) -> Self
382 where
383 Self: Sized,
384 {
385 self.interactivity().group_active_style = Some(GroupStyle {
386 group: group_name.into(),
387 style: f(StyleRefinement::default()),
388 });
389 self
390 }
391
392 fn on_click(mut self, listener: impl Fn(&ClickEvent, &mut WindowContext) + 'static) -> Self
393 where
394 Self: Sized,
395 {
396 self.interactivity()
397 .click_listeners
398 .push(Box::new(move |event, cx| listener(event, cx)));
399 self
400 }
401
402 fn on_drag<W>(mut self, listener: impl Fn(&mut WindowContext) -> View<W> + 'static) -> Self
403 where
404 Self: Sized,
405 W: 'static + Render,
406 {
407 debug_assert!(
408 self.interactivity().drag_listener.is_none(),
409 "calling on_drag more than once on the same element is not supported"
410 );
411 self.interactivity().drag_listener = Some(Box::new(move |cursor_offset, cx| AnyDrag {
412 view: listener(cx).into(),
413 cursor_offset,
414 }));
415 self
416 }
417
418 fn on_hover(mut self, listener: impl Fn(&bool, &mut WindowContext) + 'static) -> Self
419 where
420 Self: Sized,
421 {
422 debug_assert!(
423 self.interactivity().hover_listener.is_none(),
424 "calling on_hover more than once on the same element is not supported"
425 );
426 self.interactivity().hover_listener = Some(Box::new(listener));
427 self
428 }
429
430 fn tooltip(mut self, build_tooltip: impl Fn(&mut WindowContext) -> AnyView + 'static) -> Self
431 where
432 Self: Sized,
433 {
434 debug_assert!(
435 self.interactivity().tooltip_builder.is_none(),
436 "calling tooltip more than once on the same element is not supported"
437 );
438 self.interactivity().tooltip_builder = Some(Rc::new(build_tooltip));
439
440 self
441 }
442}
443
444pub trait FocusableElement: InteractiveElement {
445 fn focus(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
446 where
447 Self: Sized,
448 {
449 self.interactivity().focus_style = f(StyleRefinement::default());
450 self
451 }
452
453 fn in_focus(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
454 where
455 Self: Sized,
456 {
457 self.interactivity().in_focus_style = f(StyleRefinement::default());
458 self
459 }
460
461 fn on_focus(mut self, listener: impl Fn(&FocusEvent, &mut WindowContext) + 'static) -> Self
462 where
463 Self: Sized,
464 {
465 self.interactivity()
466 .focus_listeners
467 .push(Box::new(move |focus_handle, event, cx| {
468 if event.focused.as_ref() == Some(focus_handle) {
469 listener(event, cx)
470 }
471 }));
472 self
473 }
474
475 fn on_blur(mut self, listener: impl Fn(&FocusEvent, &mut WindowContext) + 'static) -> Self
476 where
477 Self: Sized,
478 {
479 self.interactivity()
480 .focus_listeners
481 .push(Box::new(move |focus_handle, event, cx| {
482 if event.blurred.as_ref() == Some(focus_handle) {
483 listener(event, cx)
484 }
485 }));
486 self
487 }
488
489 fn on_focus_in(mut self, listener: impl Fn(&FocusEvent, &mut WindowContext) + 'static) -> Self
490 where
491 Self: Sized,
492 {
493 self.interactivity()
494 .focus_listeners
495 .push(Box::new(move |focus_handle, event, cx| {
496 let descendant_blurred = event
497 .blurred
498 .as_ref()
499 .map_or(false, |blurred| focus_handle.contains(blurred, cx));
500 let descendant_focused = event
501 .focused
502 .as_ref()
503 .map_or(false, |focused| focus_handle.contains(focused, cx));
504
505 if !descendant_blurred && descendant_focused {
506 listener(event, cx)
507 }
508 }));
509 self
510 }
511
512 fn on_focus_out(mut self, listener: impl Fn(&FocusEvent, &mut WindowContext) + 'static) -> Self
513 where
514 Self: Sized,
515 {
516 self.interactivity()
517 .focus_listeners
518 .push(Box::new(move |focus_handle, event, cx| {
519 let descendant_blurred = event
520 .blurred
521 .as_ref()
522 .map_or(false, |blurred| focus_handle.contains(blurred, cx));
523 let descendant_focused = event
524 .focused
525 .as_ref()
526 .map_or(false, |focused| focus_handle.contains(focused, cx));
527 if descendant_blurred && !descendant_focused {
528 listener(event, cx)
529 }
530 }));
531 self
532 }
533}
534
535pub type FocusListeners = SmallVec<[FocusListener; 2]>;
536
537pub type FocusListener = Box<dyn Fn(&FocusHandle, &FocusEvent, &mut WindowContext) + 'static>;
538
539pub type MouseDownListener =
540 Box<dyn Fn(&MouseDownEvent, &InteractiveBounds, DispatchPhase, &mut WindowContext) + 'static>;
541pub type MouseUpListener =
542 Box<dyn Fn(&MouseUpEvent, &InteractiveBounds, DispatchPhase, &mut WindowContext) + 'static>;
543
544pub type MouseMoveListener =
545 Box<dyn Fn(&MouseMoveEvent, &InteractiveBounds, DispatchPhase, &mut WindowContext) + 'static>;
546
547pub type ScrollWheelListener =
548 Box<dyn Fn(&ScrollWheelEvent, &InteractiveBounds, DispatchPhase, &mut WindowContext) + 'static>;
549
550pub type ClickListener = Box<dyn Fn(&ClickEvent, &mut WindowContext) + 'static>;
551
552pub type DragListener = Box<dyn Fn(Point<Pixels>, &mut WindowContext) -> AnyDrag + 'static>;
553
554type DropListener = dyn Fn(AnyView, &mut WindowContext) + 'static;
555
556pub type TooltipBuilder = Rc<dyn Fn(&mut WindowContext) -> AnyView + 'static>;
557
558pub type KeyDownListener = Box<dyn Fn(&KeyDownEvent, DispatchPhase, &mut WindowContext) + 'static>;
559
560pub type KeyUpListener = Box<dyn Fn(&KeyUpEvent, DispatchPhase, &mut WindowContext) + 'static>;
561
562pub type DragEventListener = Box<dyn Fn(&MouseMoveEvent, &mut WindowContext) + 'static>;
563
564pub type ActionListener = Box<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext) + 'static>;
565
566pub fn div() -> Div {
567 Div {
568 interactivity: Interactivity::default(),
569 children: SmallVec::default(),
570 }
571}
572
573pub struct Div {
574 interactivity: Interactivity,
575 children: SmallVec<[AnyElement; 2]>,
576}
577
578impl Styled for Div {
579 fn style(&mut self) -> &mut StyleRefinement {
580 &mut self.interactivity.base_style
581 }
582}
583
584impl InteractiveElement for Div {
585 fn interactivity(&mut self) -> &mut Interactivity {
586 &mut self.interactivity
587 }
588}
589
590impl ParentElement for Div {
591 fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
592 &mut self.children
593 }
594}
595
596impl Element for Div {
597 type State = DivState;
598
599 fn layout(
600 &mut self,
601 element_state: Option<Self::State>,
602 cx: &mut WindowContext,
603 ) -> (LayoutId, Self::State) {
604 let mut child_layout_ids = SmallVec::new();
605 let mut interactivity = mem::take(&mut self.interactivity);
606 let (layout_id, interactive_state) = interactivity.layout(
607 element_state.map(|s| s.interactive_state),
608 cx,
609 |style, cx| {
610 cx.with_text_style(style.text_style().cloned(), |cx| {
611 child_layout_ids = self
612 .children
613 .iter_mut()
614 .map(|child| child.layout(cx))
615 .collect::<SmallVec<_>>();
616 cx.request_layout(&style, child_layout_ids.iter().copied())
617 })
618 },
619 );
620 self.interactivity = interactivity;
621 (
622 layout_id,
623 DivState {
624 interactive_state,
625 child_layout_ids,
626 },
627 )
628 }
629
630 fn paint(
631 self,
632 bounds: Bounds<Pixels>,
633 element_state: &mut Self::State,
634 cx: &mut WindowContext,
635 ) {
636 let mut child_min = point(Pixels::MAX, Pixels::MAX);
637 let mut child_max = Point::default();
638 let content_size = if element_state.child_layout_ids.is_empty() {
639 bounds.size
640 } else if let Some(scroll_handle) = self.interactivity.scroll_handle.as_ref() {
641 let mut state = scroll_handle.0.borrow_mut();
642 state.child_bounds = Vec::with_capacity(element_state.child_layout_ids.len());
643 state.bounds = bounds;
644 let requested = state.requested_scroll_top.take();
645
646 for (ix, child_layout_id) in element_state.child_layout_ids.iter().enumerate() {
647 let child_bounds = cx.layout_bounds(*child_layout_id);
648 child_min = child_min.min(&child_bounds.origin);
649 child_max = child_max.max(&child_bounds.lower_right());
650 state.child_bounds.push(child_bounds);
651
652 if let Some(requested) = requested.as_ref() {
653 if requested.0 == ix {
654 *state.offset.borrow_mut() =
655 bounds.origin - (child_bounds.origin - point(px(0.), requested.1));
656 }
657 }
658 }
659 (child_max - child_min).into()
660 } else {
661 for child_layout_id in &element_state.child_layout_ids {
662 let child_bounds = cx.layout_bounds(*child_layout_id);
663 child_min = child_min.min(&child_bounds.origin);
664 child_max = child_max.max(&child_bounds.lower_right());
665 }
666 (child_max - child_min).into()
667 };
668
669 self.interactivity.paint(
670 bounds,
671 content_size,
672 &mut element_state.interactive_state,
673 cx,
674 |style, scroll_offset, cx| {
675 if style.visibility == Visibility::Hidden {
676 return;
677 }
678
679 let z_index = style.z_index.unwrap_or(0);
680
681 cx.with_z_index(z_index, |cx| {
682 cx.with_z_index(0, |cx| {
683 style.paint(bounds, cx);
684 });
685 cx.with_z_index(1, |cx| {
686 cx.with_text_style(style.text_style().cloned(), |cx| {
687 cx.with_content_mask(style.overflow_mask(bounds), |cx| {
688 cx.with_element_offset(scroll_offset, |cx| {
689 for child in self.children {
690 child.paint(cx);
691 }
692 })
693 })
694 })
695 })
696 })
697 },
698 );
699 }
700}
701
702impl IntoElement for Div {
703 type Element = Self;
704
705 fn element_id(&self) -> Option<ElementId> {
706 self.interactivity.element_id.clone()
707 }
708
709 fn into_element(self) -> Self::Element {
710 self
711 }
712}
713
714pub struct DivState {
715 child_layout_ids: SmallVec<[LayoutId; 4]>,
716 interactive_state: InteractiveElementState,
717}
718
719impl DivState {
720 pub fn is_active(&self) -> bool {
721 self.interactive_state.pending_mouse_down.borrow().is_some()
722 }
723}
724
725pub struct Interactivity {
726 pub element_id: Option<ElementId>,
727 pub key_context: Option<KeyContext>,
728 pub focusable: bool,
729 pub tracked_focus_handle: Option<FocusHandle>,
730 pub scroll_handle: Option<ScrollHandle>,
731 pub focus_listeners: FocusListeners,
732 pub group: Option<SharedString>,
733 pub base_style: StyleRefinement,
734 pub focus_style: StyleRefinement,
735 pub in_focus_style: StyleRefinement,
736 pub hover_style: StyleRefinement,
737 pub group_hover_style: Option<GroupStyle>,
738 pub active_style: StyleRefinement,
739 pub group_active_style: Option<GroupStyle>,
740 pub drag_over_styles: SmallVec<[(TypeId, StyleRefinement); 2]>,
741 pub group_drag_over_styles: SmallVec<[(TypeId, GroupStyle); 2]>,
742 pub mouse_down_listeners: SmallVec<[MouseDownListener; 2]>,
743 pub mouse_up_listeners: SmallVec<[MouseUpListener; 2]>,
744 pub mouse_move_listeners: SmallVec<[MouseMoveListener; 2]>,
745 pub scroll_wheel_listeners: SmallVec<[ScrollWheelListener; 2]>,
746 pub key_down_listeners: SmallVec<[KeyDownListener; 2]>,
747 pub key_up_listeners: SmallVec<[KeyUpListener; 2]>,
748 pub action_listeners: SmallVec<[(TypeId, ActionListener); 8]>,
749 pub drop_listeners: SmallVec<[(TypeId, Box<DropListener>); 2]>,
750 pub click_listeners: SmallVec<[ClickListener; 2]>,
751 pub drag_listener: Option<DragListener>,
752 pub hover_listener: Option<Box<dyn Fn(&bool, &mut WindowContext)>>,
753 pub tooltip_builder: Option<TooltipBuilder>,
754}
755
756#[derive(Clone, Debug)]
757pub struct InteractiveBounds {
758 pub bounds: Bounds<Pixels>,
759 pub stacking_order: StackingOrder,
760}
761
762impl InteractiveBounds {
763 pub fn visibly_contains(&self, point: &Point<Pixels>, cx: &WindowContext) -> bool {
764 self.bounds.contains_point(point) && cx.was_top_layer(&point, &self.stacking_order)
765 }
766}
767
768impl Interactivity {
769 pub fn layout(
770 &mut self,
771 element_state: Option<InteractiveElementState>,
772 cx: &mut WindowContext,
773 f: impl FnOnce(Style, &mut WindowContext) -> LayoutId,
774 ) -> (LayoutId, InteractiveElementState) {
775 let mut element_state = element_state.unwrap_or_default();
776
777 // Ensure we store a focus handle in our element state if we're focusable.
778 // If there's an explicit focus handle we're tracking, use that. Otherwise
779 // create a new handle and store it in the element state, which lives for as
780 // as frames contain an element with this id.
781 if self.focusable {
782 element_state.focus_handle.get_or_insert_with(|| {
783 self.tracked_focus_handle
784 .clone()
785 .unwrap_or_else(|| cx.focus_handle())
786 });
787 }
788
789 if let Some(scroll_handle) = self.scroll_handle.as_ref() {
790 element_state.scroll_offset = Some(scroll_handle.0.borrow().offset.clone());
791 }
792
793 let style = self.compute_style(None, &mut element_state, cx);
794 let layout_id = f(style, cx);
795 (layout_id, element_state)
796 }
797
798 pub fn paint(
799 mut self,
800 bounds: Bounds<Pixels>,
801 content_size: Size<Pixels>,
802 element_state: &mut InteractiveElementState,
803 cx: &mut WindowContext,
804 f: impl FnOnce(Style, Point<Pixels>, &mut WindowContext),
805 ) {
806 let style = self.compute_style(Some(bounds), element_state, cx);
807
808 if style
809 .background
810 .as_ref()
811 .is_some_and(|fill| fill.color().is_some_and(|color| !color.is_transparent()))
812 {
813 cx.with_z_index(style.z_index.unwrap_or(0), |cx| cx.add_opaque_layer(bounds))
814 }
815
816 let interactive_bounds = Rc::new(InteractiveBounds {
817 bounds: bounds.intersect(&cx.content_mask().bounds),
818 stacking_order: cx.stacking_order().clone(),
819 });
820
821 if let Some(mouse_cursor) = style.mouse_cursor {
822 let mouse_position = &cx.mouse_position();
823 let hovered = interactive_bounds.visibly_contains(mouse_position, cx);
824 if hovered {
825 cx.set_cursor_style(mouse_cursor);
826 }
827 }
828
829 for listener in self.mouse_down_listeners.drain(..) {
830 let interactive_bounds = interactive_bounds.clone();
831 cx.on_mouse_event(move |event: &MouseDownEvent, phase, cx| {
832 listener(event, &*interactive_bounds, phase, cx);
833 })
834 }
835
836 for listener in self.mouse_up_listeners.drain(..) {
837 let interactive_bounds = interactive_bounds.clone();
838 cx.on_mouse_event(move |event: &MouseUpEvent, phase, cx| {
839 listener(event, &*interactive_bounds, phase, cx);
840 })
841 }
842
843 for listener in self.mouse_move_listeners.drain(..) {
844 let interactive_bounds = interactive_bounds.clone();
845 cx.on_mouse_event(move |event: &MouseMoveEvent, phase, cx| {
846 listener(event, &*interactive_bounds, phase, cx);
847 })
848 }
849
850 for listener in self.scroll_wheel_listeners.drain(..) {
851 let interactive_bounds = interactive_bounds.clone();
852 cx.on_mouse_event(move |event: &ScrollWheelEvent, phase, cx| {
853 listener(event, &*interactive_bounds, phase, cx);
854 })
855 }
856
857 let hover_group_bounds = self
858 .group_hover_style
859 .as_ref()
860 .and_then(|group_hover| GroupBounds::get(&group_hover.group, cx));
861
862 if let Some(group_bounds) = hover_group_bounds {
863 let hovered = group_bounds.contains_point(&cx.mouse_position());
864 cx.on_mouse_event(move |event: &MouseMoveEvent, phase, cx| {
865 if phase == DispatchPhase::Capture {
866 if group_bounds.contains_point(&event.position) != hovered {
867 cx.notify();
868 }
869 }
870 });
871 }
872
873 if self.hover_style.is_some()
874 || self.base_style.mouse_cursor.is_some()
875 || cx.active_drag.is_some() && !self.drag_over_styles.is_empty()
876 {
877 let bounds = bounds.intersect(&cx.content_mask().bounds);
878 let hovered = bounds.contains_point(&cx.mouse_position());
879 cx.on_mouse_event(move |event: &MouseMoveEvent, phase, cx| {
880 if phase == DispatchPhase::Capture {
881 if bounds.contains_point(&event.position) != hovered {
882 cx.notify();
883 }
884 }
885 });
886 }
887
888 if cx.active_drag.is_some() {
889 let drop_listeners = mem::take(&mut self.drop_listeners);
890 let interactive_bounds = interactive_bounds.clone();
891 cx.on_mouse_event(move |event: &MouseUpEvent, phase, cx| {
892 if phase == DispatchPhase::Bubble
893 && interactive_bounds.visibly_contains(&event.position, &cx)
894 {
895 if let Some(drag_state_type) =
896 cx.active_drag.as_ref().map(|drag| drag.view.entity_type())
897 {
898 for (drop_state_type, listener) in &drop_listeners {
899 if *drop_state_type == drag_state_type {
900 let drag = cx
901 .active_drag
902 .take()
903 .expect("checked for type drag state type above");
904
905 listener(drag.view.clone(), cx);
906 cx.notify();
907 cx.stop_propagation();
908 }
909 }
910 } else {
911 cx.active_drag = None;
912 }
913 }
914 });
915 }
916
917 let click_listeners = mem::take(&mut self.click_listeners);
918 let drag_listener = mem::take(&mut self.drag_listener);
919
920 if !click_listeners.is_empty() || drag_listener.is_some() {
921 let pending_mouse_down = element_state.pending_mouse_down.clone();
922 let mouse_down = pending_mouse_down.borrow().clone();
923 if let Some(mouse_down) = mouse_down {
924 if let Some(drag_listener) = drag_listener {
925 let active_state = element_state.clicked_state.clone();
926 let interactive_bounds = interactive_bounds.clone();
927
928 cx.on_mouse_event(move |event: &MouseMoveEvent, phase, cx| {
929 if cx.active_drag.is_some() {
930 if phase == DispatchPhase::Capture {
931 cx.notify();
932 }
933 } else if phase == DispatchPhase::Bubble
934 && interactive_bounds.visibly_contains(&event.position, cx)
935 && (event.position - mouse_down.position).magnitude() > DRAG_THRESHOLD
936 {
937 *active_state.borrow_mut() = ElementClickedState::default();
938 let cursor_offset = event.position - bounds.origin;
939 let drag = drag_listener(cursor_offset, cx);
940 cx.active_drag = Some(drag);
941 cx.notify();
942 cx.stop_propagation();
943 }
944 });
945 }
946
947 let interactive_bounds = interactive_bounds.clone();
948 cx.on_mouse_event(move |event: &MouseUpEvent, phase, cx| {
949 if phase == DispatchPhase::Bubble
950 && interactive_bounds.visibly_contains(&event.position, cx)
951 {
952 let mouse_click = ClickEvent {
953 down: mouse_down.clone(),
954 up: event.clone(),
955 };
956 for listener in &click_listeners {
957 listener(&mouse_click, cx);
958 }
959 }
960 *pending_mouse_down.borrow_mut() = None;
961 cx.notify();
962 });
963 } else {
964 let interactive_bounds = interactive_bounds.clone();
965 cx.on_mouse_event(move |event: &MouseDownEvent, phase, cx| {
966 if phase == DispatchPhase::Bubble
967 && interactive_bounds.visibly_contains(&event.position, cx)
968 {
969 *pending_mouse_down.borrow_mut() = Some(event.clone());
970 cx.notify();
971 }
972 });
973 }
974 }
975
976 if let Some(hover_listener) = self.hover_listener.take() {
977 let was_hovered = element_state.hover_state.clone();
978 let has_mouse_down = element_state.pending_mouse_down.clone();
979 let interactive_bounds = interactive_bounds.clone();
980
981 cx.on_mouse_event(move |event: &MouseMoveEvent, phase, cx| {
982 if phase != DispatchPhase::Bubble {
983 return;
984 }
985 let is_hovered = interactive_bounds.visibly_contains(&event.position, cx)
986 && has_mouse_down.borrow().is_none();
987 let mut was_hovered = was_hovered.borrow_mut();
988
989 if is_hovered != was_hovered.clone() {
990 *was_hovered = is_hovered;
991 drop(was_hovered);
992
993 hover_listener(&is_hovered, cx);
994 }
995 });
996 }
997
998 if let Some(tooltip_builder) = self.tooltip_builder.take() {
999 let active_tooltip = element_state.active_tooltip.clone();
1000 let pending_mouse_down = element_state.pending_mouse_down.clone();
1001 let interactive_bounds = interactive_bounds.clone();
1002
1003 cx.on_mouse_event(move |event: &MouseMoveEvent, phase, cx| {
1004 let is_hovered = interactive_bounds.visibly_contains(&event.position, cx)
1005 && pending_mouse_down.borrow().is_none();
1006 if !is_hovered {
1007 active_tooltip.borrow_mut().take();
1008 return;
1009 }
1010
1011 if phase != DispatchPhase::Bubble {
1012 return;
1013 }
1014
1015 if active_tooltip.borrow().is_none() {
1016 let task = cx.spawn({
1017 let active_tooltip = active_tooltip.clone();
1018 let tooltip_builder = tooltip_builder.clone();
1019
1020 move |mut cx| async move {
1021 cx.background_executor().timer(TOOLTIP_DELAY).await;
1022 cx.update(|_, cx| {
1023 active_tooltip.borrow_mut().replace(ActiveTooltip {
1024 tooltip: Some(AnyTooltip {
1025 view: tooltip_builder(cx),
1026 cursor_offset: cx.mouse_position(),
1027 }),
1028 _task: None,
1029 });
1030 cx.notify();
1031 })
1032 .ok();
1033 }
1034 });
1035 active_tooltip.borrow_mut().replace(ActiveTooltip {
1036 tooltip: None,
1037 _task: Some(task),
1038 });
1039 }
1040 });
1041
1042 let active_tooltip = element_state.active_tooltip.clone();
1043 cx.on_mouse_event(move |_: &MouseDownEvent, _, _| {
1044 active_tooltip.borrow_mut().take();
1045 });
1046
1047 if let Some(active_tooltip) = element_state.active_tooltip.borrow().as_ref() {
1048 if active_tooltip.tooltip.is_some() {
1049 cx.active_tooltip = active_tooltip.tooltip.clone()
1050 }
1051 }
1052 }
1053
1054 let active_state = element_state.clicked_state.clone();
1055 if !active_state.borrow().is_clicked() {
1056 cx.on_mouse_event(move |_: &MouseUpEvent, phase, cx| {
1057 if phase == DispatchPhase::Capture {
1058 *active_state.borrow_mut() = ElementClickedState::default();
1059 cx.notify();
1060 }
1061 });
1062 } else {
1063 let active_group_bounds = self
1064 .group_active_style
1065 .as_ref()
1066 .and_then(|group_active| GroupBounds::get(&group_active.group, cx));
1067 let interactive_bounds = interactive_bounds.clone();
1068 cx.on_mouse_event(move |down: &MouseDownEvent, phase, cx| {
1069 if phase == DispatchPhase::Bubble {
1070 let group = active_group_bounds
1071 .map_or(false, |bounds| bounds.contains_point(&down.position));
1072 let element = interactive_bounds.visibly_contains(&down.position, cx);
1073 if group || element {
1074 *active_state.borrow_mut() = ElementClickedState { group, element };
1075 cx.notify();
1076 }
1077 }
1078 });
1079 }
1080
1081 let overflow = style.overflow;
1082 if overflow.x == Overflow::Scroll || overflow.y == Overflow::Scroll {
1083 let scroll_offset = element_state
1084 .scroll_offset
1085 .get_or_insert_with(Rc::default)
1086 .clone();
1087 let line_height = cx.line_height();
1088 let scroll_max = (content_size - bounds.size).max(&Size::default());
1089 let interactive_bounds = interactive_bounds.clone();
1090
1091 cx.on_mouse_event(move |event: &ScrollWheelEvent, phase, cx| {
1092 if phase == DispatchPhase::Bubble
1093 && interactive_bounds.visibly_contains(&event.position, cx)
1094 {
1095 let mut scroll_offset = scroll_offset.borrow_mut();
1096 let old_scroll_offset = *scroll_offset;
1097 let delta = event.delta.pixel_delta(line_height);
1098
1099 if overflow.x == Overflow::Scroll {
1100 scroll_offset.x =
1101 (scroll_offset.x + delta.x).clamp(-scroll_max.width, px(0.));
1102 }
1103
1104 if overflow.y == Overflow::Scroll {
1105 scroll_offset.y =
1106 (scroll_offset.y + delta.y).clamp(-scroll_max.height, px(0.));
1107 }
1108
1109 if *scroll_offset != old_scroll_offset {
1110 cx.notify();
1111 cx.stop_propagation();
1112 }
1113 }
1114 });
1115 }
1116
1117 if let Some(group) = self.group.clone() {
1118 GroupBounds::push(group, bounds, cx);
1119 }
1120
1121 let scroll_offset = element_state
1122 .scroll_offset
1123 .as_ref()
1124 .map(|scroll_offset| *scroll_offset.borrow());
1125
1126 cx.with_key_dispatch(
1127 self.key_context.clone(),
1128 element_state.focus_handle.clone(),
1129 |_, cx| {
1130 for listener in self.key_down_listeners.drain(..) {
1131 cx.on_key_event(move |event: &KeyDownEvent, phase, cx| {
1132 listener(event, phase, cx);
1133 })
1134 }
1135
1136 for listener in self.key_up_listeners.drain(..) {
1137 cx.on_key_event(move |event: &KeyUpEvent, phase, cx| {
1138 listener(event, phase, cx);
1139 })
1140 }
1141
1142 for (action_type, listener) in self.action_listeners {
1143 cx.on_action(action_type, listener)
1144 }
1145
1146 if let Some(focus_handle) = element_state.focus_handle.as_ref() {
1147 for listener in self.focus_listeners {
1148 let focus_handle = focus_handle.clone();
1149 cx.on_focus_changed(move |event, cx| listener(&focus_handle, event, cx));
1150 }
1151 }
1152
1153 f(style, scroll_offset.unwrap_or_default(), cx)
1154 },
1155 );
1156
1157 if let Some(group) = self.group.as_ref() {
1158 GroupBounds::pop(group, cx);
1159 }
1160 }
1161
1162 pub fn compute_style(
1163 &self,
1164 bounds: Option<Bounds<Pixels>>,
1165 element_state: &mut InteractiveElementState,
1166 cx: &mut WindowContext,
1167 ) -> Style {
1168 let mut style = Style::default();
1169 style.refine(&self.base_style);
1170
1171 if let Some(focus_handle) = self.tracked_focus_handle.as_ref() {
1172 if focus_handle.within_focused(cx) {
1173 style.refine(&self.in_focus_style);
1174 }
1175
1176 if focus_handle.is_focused(cx) {
1177 style.refine(&self.focus_style);
1178 }
1179 }
1180
1181 if let Some(bounds) = bounds {
1182 let mouse_position = cx.mouse_position();
1183 if let Some(group_hover) = self.group_hover_style.as_ref() {
1184 if let Some(group_bounds) = GroupBounds::get(&group_hover.group, cx) {
1185 if group_bounds.contains_point(&mouse_position)
1186 && cx.was_top_layer(&mouse_position, cx.stacking_order())
1187 {
1188 style.refine(&group_hover.style);
1189 }
1190 }
1191 }
1192 if self.hover_style.is_some() {
1193 if bounds
1194 .intersect(&cx.content_mask().bounds)
1195 .contains_point(&mouse_position)
1196 && cx.was_top_layer(&mouse_position, cx.stacking_order())
1197 {
1198 style.refine(&self.hover_style);
1199 }
1200 }
1201
1202 if let Some(drag) = cx.active_drag.take() {
1203 for (state_type, group_drag_style) in &self.group_drag_over_styles {
1204 if let Some(group_bounds) = GroupBounds::get(&group_drag_style.group, cx) {
1205 if *state_type == drag.view.entity_type()
1206 && group_bounds.contains_point(&mouse_position)
1207 {
1208 style.refine(&group_drag_style.style);
1209 }
1210 }
1211 }
1212
1213 for (state_type, drag_over_style) in &self.drag_over_styles {
1214 if *state_type == drag.view.entity_type()
1215 && bounds
1216 .intersect(&cx.content_mask().bounds)
1217 .contains_point(&mouse_position)
1218 {
1219 style.refine(drag_over_style);
1220 }
1221 }
1222
1223 cx.active_drag = Some(drag);
1224 }
1225 }
1226
1227 let clicked_state = element_state.clicked_state.borrow();
1228 if clicked_state.group {
1229 if let Some(group) = self.group_active_style.as_ref() {
1230 style.refine(&group.style)
1231 }
1232 }
1233
1234 if clicked_state.element {
1235 style.refine(&self.active_style)
1236 }
1237
1238 style
1239 }
1240}
1241
1242impl Default for Interactivity {
1243 fn default() -> Self {
1244 Self {
1245 element_id: None,
1246 key_context: None,
1247 focusable: false,
1248 tracked_focus_handle: None,
1249 scroll_handle: None,
1250 focus_listeners: SmallVec::default(),
1251 // scroll_offset: Point::default(),
1252 group: None,
1253 base_style: StyleRefinement::default(),
1254 focus_style: StyleRefinement::default(),
1255 in_focus_style: StyleRefinement::default(),
1256 hover_style: StyleRefinement::default(),
1257 group_hover_style: None,
1258 active_style: StyleRefinement::default(),
1259 group_active_style: None,
1260 drag_over_styles: SmallVec::new(),
1261 group_drag_over_styles: SmallVec::new(),
1262 mouse_down_listeners: SmallVec::new(),
1263 mouse_up_listeners: SmallVec::new(),
1264 mouse_move_listeners: SmallVec::new(),
1265 scroll_wheel_listeners: SmallVec::new(),
1266 key_down_listeners: SmallVec::new(),
1267 key_up_listeners: SmallVec::new(),
1268 action_listeners: SmallVec::new(),
1269 drop_listeners: SmallVec::new(),
1270 click_listeners: SmallVec::new(),
1271 drag_listener: None,
1272 hover_listener: None,
1273 tooltip_builder: None,
1274 }
1275 }
1276}
1277
1278#[derive(Default)]
1279pub struct InteractiveElementState {
1280 pub focus_handle: Option<FocusHandle>,
1281 pub clicked_state: Rc<RefCell<ElementClickedState>>,
1282 pub hover_state: Rc<RefCell<bool>>,
1283 pub pending_mouse_down: Rc<RefCell<Option<MouseDownEvent>>>,
1284 pub scroll_offset: Option<Rc<RefCell<Point<Pixels>>>>,
1285 pub active_tooltip: Rc<RefCell<Option<ActiveTooltip>>>,
1286}
1287
1288pub struct ActiveTooltip {
1289 tooltip: Option<AnyTooltip>,
1290 _task: Option<Task<()>>,
1291}
1292
1293/// Whether or not the element or a group that contains it is clicked by the mouse.
1294#[derive(Copy, Clone, Default, Eq, PartialEq)]
1295pub struct ElementClickedState {
1296 pub group: bool,
1297 pub element: bool,
1298}
1299
1300impl ElementClickedState {
1301 fn is_clicked(&self) -> bool {
1302 self.group || self.element
1303 }
1304}
1305
1306#[derive(Default)]
1307pub struct GroupBounds(HashMap<SharedString, SmallVec<[Bounds<Pixels>; 1]>>);
1308
1309impl GroupBounds {
1310 pub fn get(name: &SharedString, cx: &mut AppContext) -> Option<Bounds<Pixels>> {
1311 cx.default_global::<Self>()
1312 .0
1313 .get(name)
1314 .and_then(|bounds_stack| bounds_stack.last())
1315 .cloned()
1316 }
1317
1318 pub fn push(name: SharedString, bounds: Bounds<Pixels>, cx: &mut AppContext) {
1319 cx.default_global::<Self>()
1320 .0
1321 .entry(name)
1322 .or_default()
1323 .push(bounds);
1324 }
1325
1326 pub fn pop(name: &SharedString, cx: &mut AppContext) {
1327 cx.default_global::<Self>().0.get_mut(name).unwrap().pop();
1328 }
1329}
1330
1331pub struct Focusable<E> {
1332 pub element: E,
1333}
1334
1335impl<E: InteractiveElement> FocusableElement for Focusable<E> {}
1336
1337impl<E> InteractiveElement for Focusable<E>
1338where
1339 E: InteractiveElement,
1340{
1341 fn interactivity(&mut self) -> &mut Interactivity {
1342 self.element.interactivity()
1343 }
1344}
1345
1346impl<E: StatefulInteractiveElement> StatefulInteractiveElement for Focusable<E> {}
1347
1348impl<E> Styled for Focusable<E>
1349where
1350 E: Styled,
1351{
1352 fn style(&mut self) -> &mut StyleRefinement {
1353 self.element.style()
1354 }
1355}
1356
1357impl<E> Element for Focusable<E>
1358where
1359 E: Element,
1360{
1361 type State = E::State;
1362
1363 fn layout(
1364 &mut self,
1365 state: Option<Self::State>,
1366 cx: &mut WindowContext,
1367 ) -> (LayoutId, Self::State) {
1368 self.element.layout(state, cx)
1369 }
1370
1371 fn paint(self, bounds: Bounds<Pixels>, state: &mut Self::State, cx: &mut WindowContext) {
1372 self.element.paint(bounds, state, cx)
1373 }
1374}
1375
1376impl<E> IntoElement for Focusable<E>
1377where
1378 E: Element,
1379{
1380 type Element = E;
1381
1382 fn element_id(&self) -> Option<ElementId> {
1383 self.element.element_id()
1384 }
1385
1386 fn into_element(self) -> Self::Element {
1387 self.element
1388 }
1389}
1390
1391impl<E> ParentElement for Focusable<E>
1392where
1393 E: ParentElement,
1394{
1395 fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
1396 self.element.children_mut()
1397 }
1398}
1399
1400pub struct Stateful<E> {
1401 element: E,
1402}
1403
1404impl<E> Styled for Stateful<E>
1405where
1406 E: Styled,
1407{
1408 fn style(&mut self) -> &mut StyleRefinement {
1409 self.element.style()
1410 }
1411}
1412
1413impl<E> StatefulInteractiveElement for Stateful<E>
1414where
1415 E: Element,
1416 Self: InteractiveElement,
1417{
1418}
1419
1420impl<E> InteractiveElement for Stateful<E>
1421where
1422 E: InteractiveElement,
1423{
1424 fn interactivity(&mut self) -> &mut Interactivity {
1425 self.element.interactivity()
1426 }
1427}
1428
1429impl<E: FocusableElement> FocusableElement for Stateful<E> {}
1430
1431impl<E> Element for Stateful<E>
1432where
1433 E: Element,
1434{
1435 type State = E::State;
1436
1437 fn layout(
1438 &mut self,
1439 state: Option<Self::State>,
1440 cx: &mut WindowContext,
1441 ) -> (LayoutId, Self::State) {
1442 self.element.layout(state, cx)
1443 }
1444
1445 fn paint(self, bounds: Bounds<Pixels>, state: &mut Self::State, cx: &mut WindowContext) {
1446 self.element.paint(bounds, state, cx)
1447 }
1448}
1449
1450impl<E> IntoElement for Stateful<E>
1451where
1452 E: Element,
1453{
1454 type Element = Self;
1455
1456 fn element_id(&self) -> Option<ElementId> {
1457 self.element.element_id()
1458 }
1459
1460 fn into_element(self) -> Self::Element {
1461 self
1462 }
1463}
1464
1465impl<E> ParentElement for Stateful<E>
1466where
1467 E: ParentElement,
1468{
1469 fn children_mut(&mut self) -> &mut SmallVec<[AnyElement; 2]> {
1470 self.element.children_mut()
1471 }
1472}
1473
1474#[derive(Default)]
1475struct ScrollHandleState {
1476 // not great to have the nested rc's...
1477 offset: Rc<RefCell<Point<Pixels>>>,
1478 bounds: Bounds<Pixels>,
1479 child_bounds: Vec<Bounds<Pixels>>,
1480 requested_scroll_top: Option<(usize, Pixels)>,
1481}
1482
1483#[derive(Clone)]
1484pub struct ScrollHandle(Rc<RefCell<ScrollHandleState>>);
1485
1486impl ScrollHandle {
1487 pub fn new() -> Self {
1488 Self(Rc::default())
1489 }
1490
1491 pub fn offset(&self) -> Point<Pixels> {
1492 self.0.borrow().offset.borrow().clone()
1493 }
1494
1495 pub fn top_item(&self) -> usize {
1496 let state = self.0.borrow();
1497 let top = state.bounds.top() - state.offset.borrow().y;
1498
1499 match state.child_bounds.binary_search_by(|bounds| {
1500 if top < bounds.top() {
1501 Ordering::Greater
1502 } else if top > bounds.bottom() {
1503 Ordering::Less
1504 } else {
1505 Ordering::Equal
1506 }
1507 }) {
1508 Ok(ix) => ix,
1509 Err(ix) => ix.min(state.child_bounds.len().saturating_sub(1)),
1510 }
1511 }
1512
1513 pub fn bounds_for_item(&self, ix: usize) -> Option<Bounds<Pixels>> {
1514 self.0.borrow().child_bounds.get(ix).cloned()
1515 }
1516
1517 /// scroll_to_item scrolls the minimal amount to ensure that the item is
1518 /// fully visible
1519 pub fn scroll_to_item(&self, ix: usize) {
1520 let state = self.0.borrow();
1521
1522 let Some(bounds) = state.child_bounds.get(ix) else {
1523 return;
1524 };
1525
1526 let scroll_offset = state.offset.borrow().y;
1527
1528 if bounds.top() + scroll_offset < state.bounds.top() {
1529 state.offset.borrow_mut().y = state.bounds.top() - bounds.top();
1530 } else if bounds.bottom() + scroll_offset > state.bounds.bottom() {
1531 state.offset.borrow_mut().y = state.bounds.bottom() - bounds.bottom();
1532 }
1533 }
1534
1535 pub fn logical_scroll_top(&self) -> (usize, Pixels) {
1536 let ix = self.top_item();
1537 let state = self.0.borrow();
1538
1539 if let Some(child_bounds) = state.child_bounds.get(ix) {
1540 (
1541 ix,
1542 child_bounds.top() + state.offset.borrow().y - state.bounds.top(),
1543 )
1544 } else {
1545 (ix, px(0.))
1546 }
1547 }
1548
1549 pub fn set_logical_scroll_top(&self, ix: usize, px: Pixels) {
1550 self.0.borrow_mut().requested_scroll_top = Some((ix, px));
1551 }
1552}