haalka 0.7.1

ergonomic reactive Bevy UI library powered by FRP signals
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

//! Semantics for managing global event listeners.

use bevy_platform::sync::{Arc, OnceLock};

use super::{
    element::UiRoot,
    raw::{RawElWrapper, observe, register_system, utils::remove_system_holder_on_remove},
    utils::clone,
};
use apply::Apply;
use bevy_ecs::{event::PropagateEntityTrigger, prelude::*, traversal::Traversal};

/// Enables registering "global" event listeners on the [`UiRoot`] node. The [`UiRoot`] must be
/// manually registered with [`UiRootable::ui_root`](super::element::UiRootable::ui_root) for this
/// to work as expected.
pub trait GlobalEventAware: RawElWrapper {
    /// When an `E` [`Event`] propagates to the [`UiRoot`] node, run a [`System`] which takes
    /// [`In`](`System::In`) this element's [`Entity`] (not the [`UiRoot`]'s) and a
    /// [`GlobalEventData`] with the [`Event`].
    #[allow(clippy::type_complexity)]
    fn on_global_event_with_system<E, const AUTO_PROPAGATE: bool, T, Marker>(
        self,
        handler: impl IntoSystem<In<(Entity, GlobalEventData<E>)>, (), Marker> + Send + 'static,
    ) -> Self
    where
        E: EntityEvent + for<'a> Event<Trigger<'a> = PropagateEntityTrigger<AUTO_PROPAGATE, E, T>> + Clone,
        T: Traversal<E> + 'static,
    {
        self.update_raw_el(|raw_el| {
            let system_holder = Arc::new(OnceLock::new());
            let observer_holder = Arc::new(OnceLock::new());
            raw_el
                .on_spawn(clone!((system_holder) move |world, _| {
                    let _ = system_holder.set(register_system(world, handler));
                }))
                .apply(remove_system_holder_on_remove(system_holder.clone()))
                .on_spawn_with_system(clone!((observer_holder, system_holder) move |In(entity), child_ofs: Query<&ChildOf>, ui_roots: Query<&UiRoot>, mut commands: Commands| {
                    for ancestor in child_ofs.iter_ancestors(entity) {
                        if ui_roots.contains(ancestor) {
                            commands.queue(clone!((system_holder, observer_holder) move |world: &mut World| {
                                let observer = observe(world, ancestor, clone!((system_holder) move |event: On<E>, mut commands: Commands| {
                                    commands.run_system_with(system_holder.get().copied().unwrap(), (entity, GlobalEventData { original_event_target: event.original_event_target(), event: (*event).clone() }));
                                })).id();
                                let _ = observer_holder.set(observer);
                            }));
                            break;
                        }
                    }
                }))
                .on_remove(move |world, _| {
                    if let Some(&observer) = observer_holder.get() {
                        world.commands().queue(move |world: &mut World| {
                            let _ = world.try_despawn(observer);
                        })
                    }
                })
        })
    }

    /// When an `E` [`Event`] propagates to the [`UiRoot`] node, run a function with the [`Event`].
    fn on_global_event<E, const AUTO_PROPAGATE: bool, T>(
        self,
        mut handler: impl FnMut(E) + Send + Sync + 'static,
    ) -> Self
    where
        E: EntityEvent + for<'a> Event<Trigger<'a> = PropagateEntityTrigger<AUTO_PROPAGATE, E, T>> + Clone,
        T: Traversal<E> + 'static,
    {
        self.on_global_event_with_system::<E, AUTO_PROPAGATE, T, _>(
            move |In((_, event)): In<(Entity, GlobalEventData<E>)>| handler(event.event),
        )
    }
}

/// Container for global event data, including the original target entity and the event itself.
pub struct GlobalEventData<E> {
    /// The entity that originally received/triggered the event.
    pub original_event_target: Entity,
    /// The actual event data.
    pub event: E,
}