ragnarok/
executor.rs

1use crate::{
2    EmmitableEvent,
3    NameOfEvent,
4    NodeKey,
5    NodesState,
6    NodesStatesUpdate,
7    PotentialEvent,
8    SourceEvent,
9};
10
11#[derive(Clone, Debug, PartialEq)]
12pub struct ProcessedEvents<
13    Key: NodeKey,
14    Name: NameOfEvent,
15    Emmitable: EmmitableEvent,
16    Source: SourceEvent,
17> {
18    pub emmitable_events: Vec<Emmitable>,
19    pub flattened_potential_events: Vec<PotentialEvent<Key, Name, Source>>,
20    pub nodes_states_update: NodesStatesUpdate<Key>,
21}
22
23impl<Key: NodeKey, Name: NameOfEvent, Emmitable: EmmitableEvent, Source: SourceEvent> Default
24    for ProcessedEvents<Key, Name, Emmitable, Source>
25{
26    fn default() -> Self {
27        Self {
28            emmitable_events: Vec::default(),
29            flattened_potential_events: Vec::default(),
30            nodes_states_update: NodesStatesUpdate::default(),
31        }
32    }
33}
34
35pub trait EventsExecutor
36where
37    Self: std::marker::Sized,
38{
39    type Name: NameOfEvent;
40    type Key: NodeKey;
41    type Emmitable: EmmitableEvent<Key = Self::Key, Name = Self::Name>;
42    type Source: SourceEvent;
43
44    /// Call the event handler of the given [Self::Emmitable].
45    fn emit_event(&mut self, event: Self::Emmitable) -> bool;
46
47    // All events have been emitted
48    fn emitted_events(&mut self) {}
49}
50
51impl<T: EventsExecutor> private::Sealed for T {}
52
53impl<T: EventsExecutor + private::Sealed> EventsExecutorRunner for T {
54    type Name = T::Name;
55    type Key = T::Key;
56    type Emmitable = T::Emmitable;
57    type Source = T::Source;
58    fn run(
59        mut self,
60        nodes_state: &mut NodesState<Self::Key>,
61        ProcessedEvents {
62            mut emmitable_events,
63            flattened_potential_events,
64            mut nodes_states_update,
65        }: ProcessedEvents<Self::Key, Self::Name, Self::Emmitable, Self::Source>,
66    ) {
67        let mut processed_events = Vec::<Self::Emmitable>::new();
68
69        #[cfg(debug_assertions)]
70        tracing::info!("Processing {} Tree events", emmitable_events.len());
71
72        while !emmitable_events.is_empty() {
73            let emmitable_event = emmitable_events.remove(0);
74
75            let default_action_enabled = self.emit_event(emmitable_event.clone());
76
77            if !default_action_enabled {
78                // Get the events that this event can cancel
79                let cancellable_events = emmitable_event.name().get_cancellable_events();
80
81                // Remove the rest of emmitable events that are cancellable
82                emmitable_events.retain(|event| !cancellable_events.contains(&event.name()));
83
84                // Discard the potential events that dont find a matching emmitable event
85                // So for instance, a cancelled potential mousemove event wont be discarded if a emmitable mousenter was processed before
86                // At the same time, a cancelled potential mousemove event that actually gets discarded will only discard the node state
87                // made in this run, but will not change what was already before this run
88                // So if the affected node was already being hovered from the last events run, it will continue to be as so
89                for potential_event in &flattened_potential_events {
90                    let is_cancellable = cancellable_events.contains(&potential_event.name);
91                    if is_cancellable {
92                        let processed_event = processed_events.iter().find(|event| {
93                            potential_event.name == event.source()
94                                && potential_event.node_key == event.key()
95                        });
96                        if processed_event.is_none() {
97                            nodes_states_update
98                                .discard(&potential_event.name, &potential_event.node_key);
99                        }
100                    }
101                }
102            }
103
104            processed_events.push(emmitable_event);
105        }
106
107        self.emitted_events();
108
109        nodes_state.apply_update(nodes_states_update);
110    }
111}
112
113pub trait EventsExecutorRunner: private::Sealed
114where
115    Self: std::marker::Sized,
116{
117    type Name: NameOfEvent;
118    type Key: NodeKey;
119    type Emmitable: EmmitableEvent<Key = Self::Key, Name = Self::Name>;
120    type Source: SourceEvent;
121
122    fn run(
123        self,
124        nodes_state: &mut NodesState<Self::Key>,
125        processed_events: ProcessedEvents<Self::Key, Self::Name, Self::Emmitable, Self::Source>,
126    );
127}
128
129#[doc(hidden)]
130mod private {
131    pub trait Sealed {}
132}
ragnarok/executor.rs

ragnarok/
executor.rs
