new event system in place

Author: togglebyte

anathema-backend/src/lib.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 
 use anathema_geometry::{Pos, Size};
 use anathema_value_resolver::{AttributeStorage, Scope};
-use anathema_widgets::components::events::Event;
+use anathema_widgets::components::events::ComponentEvent;
 use anathema_widgets::error::Result;
 use anathema_widgets::layout::{Constraints, LayoutCtx, LayoutFilter, PositionFilter, Viewport};
 use anathema_widgets::paint::PaintFilter;
@@ -14,7 +14,7 @@ pub mod tui;
 pub trait Backend {
     fn size(&self) -> Size;
 
-    fn next_event(&mut self, timeout: Duration) -> Option<Event>;
+    fn next_event(&mut self, timeout: Duration) -> Option<ComponentEvent>;
 
     fn resize(&mut self, new_size: Size, glyph_map: &mut GlyphMap);
 

anathema-backend/src/tui/events.rs

@@ -1,6 +1,8 @@
 use std::time::Duration;
 
-use anathema_widgets::components::events::{Event, KeyCode, KeyEvent, KeyState, MouseButton, MouseEvent, MouseState};
+use anathema_widgets::components::events::{
+    ComponentEvent, KeyCode, KeyEvent, KeyState, MouseButton, MouseEvent, MouseState,
+};
 use crossterm::event::{Event as CTEvent, KeyEventKind, read};
 pub use crossterm::event::{
     KeyCode as CTKeyCode, KeyEvent as CTKeyEvent, KeyEventState, KeyModifiers, MouseButton as CTMouseButton,
@@ -14,18 +16,18 @@ impl Events {
     /// Poll events given a duration.
     /// If no event is available within the duration
     /// the function will return `None`.
-    pub fn poll(&self, timeout: Duration) -> Option<Event> {
+    pub fn poll(&self, timeout: Duration) -> Option<ComponentEvent> {
         match crossterm::event::poll(timeout).ok()? {
             true => {
                 let event = read().map(Into::into).ok()?;
 
                 let event = match event {
-                    CTEvent::Paste(_) => Event::Noop,
-                    CTEvent::FocusGained => Event::Focus,
-                    CTEvent::FocusLost => Event::Blur,
-                    CTEvent::Key(key_ev) => Event::Key(key_code_to_key_code(key_ev)),
-                    CTEvent::Mouse(mouse_ev) => Event::Mouse(mouse_to_mouse(mouse_ev)),
-                    CTEvent::Resize(width, height) => Event::Resize((width, height).into()),
+                    CTEvent::Paste(_) => ComponentEvent::Noop,
+                    CTEvent::FocusGained => ComponentEvent::Focus,
+                    CTEvent::FocusLost => ComponentEvent::Blur,
+                    CTEvent::Key(key_ev) => ComponentEvent::Key(key_code_to_key_code(key_ev)),
+                    CTEvent::Mouse(mouse_ev) => ComponentEvent::Mouse(mouse_to_mouse(mouse_ev)),
+                    CTEvent::Resize(width, height) => ComponentEvent::Resize((width, height).into()),
                 };
 
                 Some(event)

anathema-backend/src/tui/mod.rs

@@ -10,7 +10,7 @@ use std::time::Duration;
 
 use anathema_geometry::{LocalPos, Pos, Size};
 use anathema_value_resolver::AttributeStorage;
-use anathema_widgets::components::events::Event;
+use anathema_widgets::components::events::ComponentEvent;
 pub use anathema_widgets::{Attributes, Style};
 use anathema_widgets::{GlyphMap, PaintChildren, WidgetRenderer};
 use crossterm::cursor::{RestorePosition, SavePosition};
@@ -153,7 +153,7 @@ impl Backend for TuiBackend {
         self.screen.size()
     }
 
-    fn next_event(&mut self, timeout: Duration) -> Option<Event> {
+    fn next_event(&mut self, timeout: Duration) -> Option<ComponentEvent> {
         self.events.poll(timeout)
     }
 

anathema-default-widgets/src/testing.rs

@@ -6,7 +6,7 @@ use anathema_templates::blueprints::Blueprint;
 use anathema_templates::{Document, Globals, ToSourceKind};
 use anathema_value_resolver::{AttributeStorage, Attributes, Scope};
 use anathema_widgets::components::ComponentRegistry;
-use anathema_widgets::components::events::Event;
+use anathema_widgets::components::events::ComponentEvent;
 use anathema_widgets::layout::{Constraints, LayoutCtx, Viewport};
 use anathema_widgets::paint::{Glyph, paint};
 use anathema_widgets::query::{Children, Elements};
@@ -37,7 +37,7 @@ impl Backend for TestBackend {
         self.surface.size
     }
 
-    fn next_event(&mut self, _timeout: std::time::Duration) -> Option<Event> {
+    fn next_event(&mut self, _timeout: std::time::Duration) -> Option<ComponentEvent> {
         None
     }
 

anathema-runtime/src/builder.rs

@@ -4,7 +4,7 @@ use anathema_default_widgets::register_default_widgets;
 use anathema_geometry::Size;
 use anathema_templates::{Document, ToSourceKind};
 use anathema_widgets::components::deferred::DeferredComponents;
-use anathema_widgets::components::events::Event;
+use anathema_widgets::components::events::ComponentEvent;
 use anathema_widgets::components::{Component, ComponentId, ComponentRegistry, Emitter, ViewMessage};
 use anathema_widgets::tabindex::TabIndex;
 use anathema_widgets::{Factory, Widget};
@@ -86,7 +86,6 @@ impl<G: GlobalEventHandler> Builder<G> {
         component: C,
         state: C::State,
     ) -> Result<ComponentId<C::Message>> {
-        let ident = ident.into();
         let id = self.document.add_component(ident, template.to_source_kind())?.into();
         self.component_registry.add_component(id, component, state);
         Ok(id.into())
@@ -106,7 +105,6 @@ impl<G: GlobalEventHandler> Builder<G> {
     {
         let component = C::default();
         let state = C::State::default();
-        let ident = ident.into();
         let id = self.document.add_component(ident, template.to_source_kind())?.into();
         self.component_registry.add_component(id, component, state);
         Ok(id.into())
@@ -126,15 +124,14 @@ impl<G: GlobalEventHandler> Builder<G> {
         FS: 'static + FnMut() -> C::State,
         C: Component + 'static,
     {
-        let ident = ident.into();
         let id = self.document.add_component(ident, template.to_source_kind())?.into();
         self.component_registry.add_prototype(id, proto, state);
         Ok(())
     }
 
     pub fn with_global_event_handler<Eh>(self, global_event_handler: Eh) -> Builder<Eh>
     where
-        Eh: Fn(Event, &mut TabIndex<'_, '_>, &mut DeferredComponents) -> Option<Event>,
+        Eh: Fn(ComponentEvent, &mut TabIndex<'_, '_>, &mut DeferredComponents) -> Option<ComponentEvent>,
     {
         Builder {
             factory: self.factory,
@@ -185,7 +182,7 @@ impl<G: GlobalEventHandler> Builder<G> {
                     Ok(_) => continue,
                     Err(Error::Stop) => break Ok(()),
                     Err(Error::Template(_error)) => todo!(),
-                    Err(Error::Widget(_error)) => {}
+                    Err(Error::Widget(err)) => panic!("this should not panic in the future: {err}"),
                     Err(e) => break Err(e),
                 },
             }

anathema-runtime/src/error.rs

@@ -11,6 +11,7 @@ pub enum Error {
     Notify(notify::Error),
     Widget(anathema_widgets::error::Error),
     Stop,
+    InvalidComponentName,
 }
 
 impl Display for Error {
@@ -20,6 +21,7 @@ impl Display for Error {
             Error::Stop => write!(f, "stopping"),
             Error::Notify(err) => write!(f, "{err}"),
             Error::Widget(err) => write!(f, "{err}"),
+            Error::InvalidComponentName => write!(f, "no such component"),
         }
     }
 }

anathema-runtime/src/events.rs

@@ -1,19 +1,24 @@
 use anathema_widgets::components::deferred::DeferredComponents;
-use anathema_widgets::components::events::{Event, KeyCode, KeyEvent};
+use anathema_widgets::components::events::{ComponentEvent, KeyCode, KeyEvent};
 use anathema_widgets::tabindex::TabIndex;
 
 pub trait GlobalEventHandler {
     fn handle(
         &self,
-        event: Event,
+        event: ComponentEvent,
         tabindex: &mut TabIndex<'_, '_>,
         components: &mut DeferredComponents,
-    ) -> Option<Event>;
+    ) -> Option<ComponentEvent>;
 }
 
 impl GlobalEventHandler for () {
-    fn handle(&self, event: Event, tabindex: &mut TabIndex<'_, '_>, _: &mut DeferredComponents) -> Option<Event> {
-        if let Event::Key(KeyEvent {
+    fn handle(
+        &self,
+        event: ComponentEvent,
+        tabindex: &mut TabIndex<'_, '_>,
+        _: &mut DeferredComponents,
+    ) -> Option<ComponentEvent> {
+        if let ComponentEvent::Key(KeyEvent {
             code: KeyCode::Tab,
             ctrl: false,
             ..
@@ -23,7 +28,7 @@ impl GlobalEventHandler for () {
             return None;
         }
 
-        if let Event::Key(KeyEvent {
+        if let ComponentEvent::Key(KeyEvent {
             code: KeyCode::BackTab, ..
         }) = event
         {
@@ -32,22 +37,22 @@ impl GlobalEventHandler for () {
         }
 
         if event.is_ctrl_c() {
-            return Some(Event::Stop);
+            return Some(ComponentEvent::Stop);
         }
         Some(event)
     }
 }
 
 impl<T> GlobalEventHandler for T
 where
-    T: Fn(Event, &mut TabIndex<'_, '_>, &mut DeferredComponents) -> Option<Event>,
+    T: Fn(ComponentEvent, &mut TabIndex<'_, '_>, &mut DeferredComponents) -> Option<ComponentEvent>,
 {
     fn handle(
         &self,
-        event: Event,
+        event: ComponentEvent,
         tabindex: &mut TabIndex<'_, '_>,
         components: &mut DeferredComponents,
-    ) -> Option<Event> {
+    ) -> Option<ComponentEvent> {
         self(event, tabindex, components)
     }
 }

anathema-runtime/src/runtime/mod.rs

@@ -9,7 +9,7 @@ use anathema_templates::blueprints::Blueprint;
 use anathema_templates::{Document, Globals};
 use anathema_value_resolver::{AttributeStorage, Scope};
 use anathema_widgets::components::deferred::{CommandKind, DeferredComponents};
-use anathema_widgets::components::events::Event;
+use anathema_widgets::components::events::ComponentEvent;
 use anathema_widgets::components::{
     AnyComponentContext, AssociatedEvents, ComponentKind, ComponentRegistry, Emitter, ViewMessage,
 };
@@ -230,7 +230,7 @@ pub struct Frame<'rt, 'bp, G> {
 }
 
 impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
-    pub fn handle_global_event(&mut self, event: Event) -> Option<Event> {
+    pub fn handle_global_event(&mut self, event: ComponentEvent) -> Option<ComponentEvent> {
         let mut changed = false;
         let mut tabindex = TabIndex::new(&mut self.tabindex, self.tree.view_mut(), &mut changed);
 
@@ -257,21 +257,21 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
         event
     }
 
-    pub fn event(&mut self, event: Event) {
+    pub fn event(&mut self, event: ComponentEvent) {
         #[cfg(feature = "profile")]
         puffin::profile_function!();
 
         let Some(event) = self.handle_global_event(event) else { return };
-        if let Event::Stop = event {
+        if let ComponentEvent::Stop = event {
             self.stop = true;
             return;
         }
 
         match event {
-            Event::Noop => return,
-            Event::Stop => todo!(),
+            ComponentEvent::Noop => return,
+            ComponentEvent::Stop => todo!(),
             // Component specific event
-            Event::Blur | Event::Focus | Event::Key(_) => {
+            ComponentEvent::Blur | ComponentEvent::Focus | ComponentEvent::Key(_) => {
                 let Some(Index {
                     widget_id, state_id, ..
                 }) = self.tabindex
@@ -280,13 +280,13 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
                 };
                 self.send_event_to_component(event, widget_id, state_id);
             }
-            Event::Mouse(_) | Event::Resize(_) => {
+            ComponentEvent::Mouse(_) | ComponentEvent::Resize(_) => {
                 for i in 0..self.layout_ctx.components.len() {
                     let Some((widget_id, state_id)) = self.layout_ctx.components.get(i) else { continue };
                     self.send_event_to_component(event, widget_id, state_id);
                 }
             }
-            Event::Tick(_) => panic!("this event should never be sent to the runtime"),
+            ComponentEvent::Tick(_) => panic!("this event should never be sent to the runtime"),
         }
     }
 
@@ -376,7 +376,7 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
 
     fn poll_events<B: Backend>(&mut self, remaining: Duration, fps_now: Instant, backend: &mut B) {
         while let Some(event) = backend.next_event(remaining) {
-            if let Event::Resize(size) = event {
+            if let ComponentEvent::Resize(size) = event {
                 self.layout_ctx.viewport.resize(size);
                 self.needs_layout = true;
                 backend.resize(size, self.layout_ctx.glyph_map);
@@ -434,25 +434,36 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
         #[cfg(feature = "profile")]
         puffin::profile_function!();
 
-        while let Some(event) = self.assoc_events.next() {
-            let Some((widget_id, state_id)) = self.layout_ctx.components.get_by_widget_id(event.parent.into()) else {
-                return;
-            };
+        while let Some(assoc_event) = self.assoc_events.next() {
+            let mut parent = assoc_event.parent;
+            let external_ident = self.document.strings.get_ref_unchecked(assoc_event.external());
+            let internal_ident = self.document.strings.get_ref_unchecked(assoc_event.internal());
+            let sender = self.document.strings.get_ref_unchecked(assoc_event.sender);
+            let mut event = assoc_event.to_event(internal_ident, external_ident, sender);
+
+            loop {
+                let Some((widget_id, state_id)) = self.layout_ctx.components.get_by_widget_id(parent.into()) else {
+                    return;
+                };
+
+                let stop_propagation = self
+                    .with_component(widget_id, state_id, |comp, children, ctx| {
+                        let next_parent = ctx.parent();
+                        comp.dyn_component.any_component_event(children, ctx, &mut event);
 
-            panic!(
-                "this is going to be reworked. this was working while SharedState didn't have a lifetime, it does now so... figure it out"
-            );
-            // let Some(remote_state) = self.layout_ctx.states.get(event.state) else { return };
-            // let Some(remote_state) = remote_state.shared_state() else { return };
-            // self.with_component(widget_id, state_id, |comp, children, ctx| {
-            //     // TODO:
-            //     // Create a new event type
-            //     // if the event is stopped then return from drain_assoc_events
-
-            //     let event_ident = self.document.strings.get_ref_unchecked(event.external);
-            //     comp.dyn_component
-            //         .any_receive(children, ctx, event_ident, &*remote_state);
-            // });
+                        parent = match next_parent {
+                            Some(p) => p,
+                            None => return true,
+                        };
+
+                        event.should_stop_propagation()
+                    })
+                    .unwrap_or(true);
+
+                if stop_propagation {
+                    break;
+                }
+            }
         }
     }
 
@@ -521,7 +532,7 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
         Ok(())
     }
 
-    fn send_event_to_component(&mut self, event: Event, widget_id: WidgetId, state_id: StateId) {
+    fn send_event_to_component(&mut self, event: ComponentEvent, widget_id: WidgetId, state_id: StateId) {
         self.with_component(widget_id, state_id, |comp, elements, ctx| {
             comp.dyn_component.any_event(elements, ctx, event);
         });
@@ -537,6 +548,7 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
             let WidgetKind::Component(component) = &mut container.kind else {
                 panic!("this is always a component")
             };
+
             let Some(state) = self.layout_ctx.states.get_mut(state_id) else {
                 panic!("a component always has a state")
             };
@@ -548,6 +560,7 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
 
                     let ctx = AnyComponentContext::new(
                         component.parent.map(Into::into),
+                        component.name_id,
                         state_id,
                         component.assoc_functions,
                         self.assoc_events,
@@ -570,7 +583,7 @@ impl<'rt, 'bp, G: GlobalEventHandler> Frame<'rt, 'bp, G> {
 
         for i in 0..self.layout_ctx.components.len() {
             let Some((widget_id, state_id)) = self.layout_ctx.components.get_ticking(i) else { continue };
-            let event = Event::Tick(dt);
+            let event = ComponentEvent::Tick(dt);
             self.send_event_to_component(event, widget_id, state_id);
         }
     }

anathema-state/src/states.rs

@@ -1,7 +1,7 @@
 use std::any::Any;
 use std::fmt::Debug;
 
-use anathema_store::slab::{Slab, SlabIndex};
+use anathema_store::slab::{Slab, SlabIndex, Ticket};
 
 use crate::{Color, Hex, PendingValue, Type, Value};