Skip to main content

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