ragnarok 0.1.0

UI Events processor. Originally made for Freya but works for other libraries.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::collections::hash_map::Iter;

use itertools::Itertools;

use crate::{
    measure_emmitable_events,
    measure_potential_events,
    measure_source_global_events,
    Area,
    CursorPoint,
    EmmitableEvent,
    NameOfEvent,
    NodeKey,
    NodesState,
    ProcessedEvents,
    SourceEvent,
};

pub trait EventsMeasurer
where
    Self: std::marker::Sized,
{
    type Name: NameOfEvent;
    type Key: NodeKey;
    type Emmitable: EmmitableEvent<Key = Self::Key, Name = Self::Name>;
    type Source: SourceEvent<Name = Self::Name>;

    fn measure(
        &mut self,
        source_events: &mut Vec<Self::Source>,
        nodes_state: &mut NodesState<Self::Key>,
        focus_id: Option<Self::Key>,
    ) -> ProcessedEvents<Self::Key, Self::Name, Self::Emmitable, Self::Source> {
        // Get potential events that could be emitted based on the elements layout and viewports
        let potential_events = measure_potential_events::<
            Self::Key,
            Self::Name,
            Self::Source,
            Self::Emmitable,
        >(source_events, self, focus_id);

        // Get what events can be actually emitted based on what elements are listening
        let mut emmitable_events =
            measure_emmitable_events::<Self::Key, Self::Name, Self::Source, Self::Emmitable>(
                &potential_events,
                self,
            );

        // Get potential collateral events, e.g. mousemove -> mouseenter
        let collateral_emmitable_events =
            nodes_state.retain_states(self, &emmitable_events, source_events);
        nodes_state.filter_emmitable_events::<Self::Emmitable, Self::Name>(&mut emmitable_events);
        let nodes_states_update = nodes_state
            .create_update::<Self::Emmitable, Self::Name, Self::Source>(self, &potential_events);

        // Get the global events
        measure_source_global_events::<Self::Key, Self::Name, Self::Source, Self::Emmitable>(
            self,
            source_events,
            &mut emmitable_events,
        );
        // Join all the emmitable events and sort them
        emmitable_events.extend(collateral_emmitable_events);
        emmitable_events.sort_unstable();

        let mut flattened_potential_events = potential_events.into_values().flatten().collect_vec();
        flattened_potential_events.sort_unstable();

        // Clear the source events vec as all events have been processed
        source_events.clear();

        ProcessedEvents {
            emmitable_events,
            flattened_potential_events,
            nodes_states_update,
        }
    }

    fn get_layers(&self) -> Iter<'_, i16, Vec<Self::Key>>;
    fn get_listeners_of(&self, name: &Self::Name) -> Vec<Self::Key>;

    fn is_point_inside(&self, key: Self::Key, cursor: CursorPoint) -> bool;
    fn is_node_parent_of(&self, key: Self::Key, parent: Self::Key) -> bool;
    fn is_listening_to(&self, key: Self::Key, name: &Self::Name) -> bool;
    fn is_node_transparent(&self, key: Self::Key) -> bool;

    fn try_area_of(&self, key: Self::Key) -> Option<Area>;

    fn new_emmitable_event(
        &self,
        key: Self::Key,
        name: Self::Name,
        source: Self::Source,
        area: Option<Area>,
    ) -> Self::Emmitable;
}