Owned callbacks.

Author: viridia

crates/bevy_core_widgets/src/callback.rs

@@ -1,5 +1,7 @@
-use bevy_ecs::system::{Commands, SystemId, SystemInput};
-use bevy_ecs::world::{DeferredWorld, World};
+use bevy_ecs::component::Component;
+use bevy_ecs::lifecycle::HookContext;
+use bevy_ecs::system::{Commands, EntityCommands, IntoSystem, SystemId, SystemInput};
+use bevy_ecs::world::{DeferredWorld, EntityWorldMut, World};
 
 /// A callback defines how we want to be notified when a widget changes state. Unlike an event
 /// or observer, callbacks are intended for "point-to-point" communication that cuts across the
@@ -111,3 +113,100 @@ impl Notify for DeferredWorld<'_> {
         }
     }
 }
+
+/// A component that hangs on to a registered one-shot system, and unregisters it when the
+/// component is despawned.
+#[derive(Component)]
+#[component(on_remove = on_despawn_callback_owner::<I>, storage = "SparseSet")]
+pub struct OwnedCallbackSystem<I: SystemInput + Send>(SystemId<I, ()>);
+
+fn on_despawn_callback_owner<I: SystemInput + Send + 'static>(
+    mut world: DeferredWorld,
+    context: HookContext,
+) {
+    let system_id = world
+        .entity(context.entity)
+        .get::<OwnedCallbackSystem<I>>()
+        .unwrap()
+        .0;
+    world.commands().unregister_system(system_id);
+}
+
+/// Methods for registering scoped callbacks.
+pub trait RegisterOwnedCallback {
+    /// Registers a scoped one-shot system, with no input, that will be removed when the parent
+    /// entity is despawned.
+    fn register_owned_callback<M, I: IntoSystem<(), (), M> + 'static>(
+        &mut self,
+        callback: I,
+    ) -> Callback;
+
+    /// Registers a scoped one-shot systemm, with input, that will be removed when the
+    /// parent entity is despawned.
+    fn register_owned_callback_with<
+        M,
+        A: SystemInput + Send + 'static,
+        I: IntoSystem<A, (), M> + 'static,
+    >(
+        &mut self,
+        callback: I,
+    ) -> Callback<A>;
+}
+
+impl RegisterOwnedCallback for EntityCommands<'_> {
+    fn register_owned_callback<M, I: IntoSystem<(), (), M> + 'static>(
+        &mut self,
+        callback: I,
+    ) -> Callback {
+        let system_id = self.commands().register_system(callback);
+        let owner = self.id();
+        self.commands()
+            .spawn((OwnedCallbackSystem(system_id), crate::owner::OwnedBy(owner)));
+        Callback::System(system_id)
+    }
+
+    fn register_owned_callback_with<
+        M,
+        A: SystemInput + Send + 'static,
+        I: IntoSystem<A, (), M> + 'static,
+    >(
+        &mut self,
+        callback: I,
+    ) -> Callback<A> {
+        let owner = self.id();
+        let system_id = self.commands().register_system(callback);
+        self.commands()
+            .spawn((OwnedCallbackSystem(system_id), crate::owner::OwnedBy(owner)));
+        Callback::System(system_id)
+    }
+}
+
+impl RegisterOwnedCallback for EntityWorldMut<'_> {
+    fn register_owned_callback<M, I: IntoSystem<(), (), M> + 'static>(
+        &mut self,
+        callback: I,
+    ) -> Callback {
+        let owner = self.id();
+        let system_id = self.world_scope(|world| world.register_system(callback));
+        self.world_scope(|world| {
+            world.spawn((OwnedCallbackSystem(system_id), crate::owner::OwnedBy(owner)));
+        });
+        Callback::System(system_id)
+    }
+
+    fn register_owned_callback_with<
+        M,
+        A: SystemInput + Send + 'static,
+        I: IntoSystem<A, (), M> + 'static,
+    >(
+        &mut self,
+        callback: I,
+    ) -> Callback<A> {
+        let owner = self.id();
+        let system_id = self.world_scope(|world| world.register_system(callback));
+        self.world_scope(|world| {
+            world.spawn((OwnedCallbackSystem(system_id), crate::owner::OwnedBy(owner)));
+        });
+        Callback::System(system_id)
+    }
+}

crates/bevy_core_widgets/src/lib.rs

@@ -20,10 +20,11 @@ mod core_checkbox;
 mod core_radio;
 mod core_scrollbar;
 mod core_slider;
+pub mod owner;
 
 use bevy_app::{App, Plugin};
 
-pub use callback::{Callback, Notify};
+pub use callback::{Callback, Notify, RegisterOwnedCallback};
 pub use core_button::{CoreButton, CoreButtonPlugin};
 pub use core_checkbox::{CoreCheckbox, CoreCheckboxPlugin, SetChecked, ToggleChecked};
 pub use core_radio::{CoreRadio, CoreRadioGroup, CoreRadioGroupPlugin};

crates/bevy_core_widgets/src/owner.rs

@@ -0,0 +1,51 @@
+//! Defines relationships for ownership of an entity, with no other inherited semantics.
+use core::slice;
+
+use bevy_ecs::{component::Component, entity::Entity};
+
+/// A component that represents the owner of an entity. Ownership only determines lifetime,
+/// such that the owned entity will be despawned when its owner is despawned. It does not imply
+/// any other kind of semantic connection between the two entities.
+// TODO: Consider renaming and/or moving this.
+#[derive(Component, Clone, PartialEq, Eq, Debug)]
+#[relationship(relationship_target = Owned)]
+pub struct OwnedBy(pub Entity);
+
+impl OwnedBy {
+    /// Return the owned entity.
+    pub fn get(&self) -> Entity {
+        self.0
+    }
+}
+
+impl Default for OwnedBy {
+    fn default() -> Self {
+        OwnedBy(Entity::PLACEHOLDER)
+    }
+}
+
+/// A component that represents a collection of entities that are owned by another entity.
+// #[derive(Component, Default, Reflect)]
+// #[reflect(Component)]
+#[derive(Component, Default)]
+#[relationship_target(relationship = OwnedBy, linked_spawn)]
+pub struct Owned(Vec<Entity>);
+
+impl<'a> IntoIterator for &'a Owned {
+    type Item = <Self::IntoIter as Iterator>::Item;
+
+    type IntoIter = slice::Iter<'a, Entity>;
+
+    #[inline(always)]
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
+impl core::ops::Deref for Owned {
+    type Target = [Entity];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}