ragnarok/
measurer.rs

1use itertools::Itertools;
2
3use crate::{
4    Area,
5    CursorPoint,
6    EmmitableEvent,
7    NameOfEvent,
8    NodeKey,
9    NodesState,
10    ProcessedEvents,
11    SourceEvent,
12    measure_emmitable_events,
13    measure_potential_events,
14    measure_source_global_events,
15};
16
17pub trait EventsMeasurer
18where
19    Self: std::marker::Sized,
20{
21    type Name: NameOfEvent;
22    type Key: NodeKey;
23    type Emmitable: EmmitableEvent<Key = Self::Key, Name = Self::Name>;
24    type Source: SourceEvent<Name = Self::Name>;
25
26    fn get_layers(&self) -> impl Iterator<Item = (&i16, impl Iterator<Item = &Self::Key>)>;
27    fn get_listeners_of(&self, name: &Self::Name) -> impl Iterator<Item = &Self::Key>;
28
29    fn is_point_inside(&self, key: &Self::Key, cursor: CursorPoint) -> bool;
30    fn is_node_parent_of(&self, key: &Self::Key, parent: Self::Key) -> bool;
31    fn is_listening_to(&self, key: &Self::Key, name: &Self::Name) -> bool;
32    fn is_node_transparent(&self, key: &Self::Key) -> bool;
33
34    fn try_area_of(&self, key: &Self::Key) -> Option<Area>;
35
36    fn new_emmitable_event(
37        &self,
38        key: Self::Key,
39        name: Self::Name,
40        source: Self::Source,
41        area: Option<Area>,
42    ) -> Self::Emmitable;
43}
44
45impl<T: EventsMeasurer> private::Sealed for T {}
46
47impl<T: EventsMeasurer + private::Sealed> EventsMeasurerRunner for T {
48    type Name = T::Name;
49    type Key = T::Key;
50    type Emmitable = T::Emmitable;
51    type Source = T::Source;
52
53    #[cfg_attr(feature = "hotpath", hotpath::measure)]
54    fn run(
55        &mut self,
56        source_events: &mut Vec<Self::Source>,
57        nodes_state: &mut NodesState<Self::Key>,
58        focus_id: Option<Self::Key>,
59    ) -> ProcessedEvents<Self::Key, Self::Name, Self::Emmitable, Self::Source> {
60        // Get potential events that could be emitted based on the elements layout and viewports
61        let potential_events = measure_potential_events::<
62            Self::Key,
63            Self::Name,
64            Self::Source,
65            Self::Emmitable,
66        >(source_events, self, focus_id);
67
68        // Get what events can be actually emitted based on what elements are listening
69        let mut emmitable_events =
70            measure_emmitable_events::<Self::Key, Self::Name, Self::Source, Self::Emmitable>(
71                &potential_events,
72                self,
73            );
74
75        // Get potential collateral events, e.g. mousemove -> mouseenter
76        let collateral_emmitable_events =
77            nodes_state.retain_states(self, &emmitable_events, source_events);
78        nodes_state.filter_emmitable_events::<Self::Emmitable, Self::Name>(&mut emmitable_events);
79        let nodes_states_update = nodes_state
80            .create_update::<Self::Emmitable, Self::Name, Self::Source>(self, &potential_events);
81
82        // Get the global events
83        measure_source_global_events::<Self::Key, Self::Name, Self::Source, Self::Emmitable>(
84            self,
85            source_events,
86            &mut emmitable_events,
87        );
88        // Join all the emmitable events and sort them
89        emmitable_events.extend(collateral_emmitable_events);
90        emmitable_events.sort_unstable();
91
92        let mut flattened_potential_events = potential_events.into_values().flatten().collect_vec();
93        flattened_potential_events.sort_unstable();
94
95        // Clear the source events vec as all events have been processed
96        source_events.clear();
97
98        ProcessedEvents {
99            emmitable_events,
100            flattened_potential_events,
101            nodes_states_update,
102        }
103    }
104}
105
106pub trait EventsMeasurerRunner
107where
108    Self: std::marker::Sized,
109{
110    type Name: NameOfEvent;
111    type Key: NodeKey;
112    type Emmitable: EmmitableEvent<Key = Self::Key, Name = Self::Name>;
113    type Source: SourceEvent<Name = Self::Name>;
114
115    fn run(
116        &mut self,
117        source_events: &mut Vec<Self::Source>,
118        nodes_state: &mut NodesState<Self::Key>,
119        focus_id: Option<Self::Key>,
120    ) -> ProcessedEvents<Self::Key, Self::Name, Self::Emmitable, Self::Source>;
121}
122
123#[doc(hidden)]
124mod private {
125    pub trait Sealed {}
126}