slight re-structure

src/events.rs

@@ -3,7 +3,9 @@ use std::{
     collections::HashMap,
 };
 
-use crate::Close;
+use crate::event;
+
+event!(Close);
 
 pub trait Event {
     fn as_any(self: Box<Self>) -> Box<dyn Any>;

src/extensions/keypress.rs

@@ -1,14 +1,13 @@
 use crossterm::event::{KeyCode, KeyModifiers};
 
-use crate::{event_manager::EventManager, Close, Event, Extension, Screen};
+use crate::{
+    event,
+    events::{Close, EventManager},
+    extensions::Extension,
+    Screen,
+};
 
-#[derive(Clone)]
+event!(KeyPress(pub crossterm::event::KeyEvent));
-pub struct KeyPress(pub crossterm::event::KeyEvent);
-impl Event for KeyPress {
-    fn as_any(self: Box<Self>) -> Box<dyn std::any::Any> {
-        self
-    }
-}
 
 pub trait KeyPressEventHandler {
     fn on_keypress(&mut self, event: KeyPress);

src/extensions/mod.rs

@@ -1 +1,40 @@
 pub mod keypress;
+
+use crate::{events::EventManager, Screen};
+
+pub trait Extension {
+    fn init(&mut self, screen: &mut Screen, events: &mut EventManager);
+    fn tick_start(&mut self, screen: &mut Screen, events: &mut EventManager);
+    fn tick_end(&mut self, screen: &mut Screen, events: &mut EventManager);
+}
+
+pub struct ExtensionManager(Vec<Box<dyn Extension>>);
+
+impl Extension for ExtensionManager {
+    fn init(&mut self, screen: &mut Screen, events: &mut EventManager) {
+        for ext in &mut self.0 {
+            ext.init(screen, events);
+        }
+    }
+
+    fn tick_start(&mut self, screen: &mut Screen, events: &mut EventManager) {
+        for ext in &mut self.0 {
+            ext.tick_start(screen, events);
+        }
+    }
+
+    fn tick_end(&mut self, screen: &mut Screen, events: &mut EventManager) {
+        for ext in &mut self.0 {
+            ext.tick_end(screen, events);
+        }
+    }
+}
+
+impl ExtensionManager {
+    pub fn new() -> ExtensionManager {
+        ExtensionManager(Vec::new())
+    }
+    pub fn add<E: Extension + 'static>(&mut self, extension: E) {
+        self.0.push(Box::new(extension));
+    }
+}

src/lib.rs

@@ -1,12 +1,14 @@
 use std::any::Any;
 
 use crate::{
-    event_manager::{Event, EventManager},
+    events::EventManager,
+    extensions::{Extension, ExtensionManager},
     render_scope::RenderScope,
 };
 
-pub mod event_manager;
+pub mod events;
 pub mod extensions;
+pub mod macros;
 pub mod render_scope;
 pub mod text;
 pub mod utils;
@@ -19,60 +21,6 @@ pub trait Element {
     fn as_any(self: Box<Self>) -> Box<dyn Any>;
 }
 
-pub trait Extension {
-    fn init(&mut self, screen: &mut Screen, events: &mut EventManager);
-    fn tick_start(&mut self, screen: &mut Screen, events: &mut EventManager);
-    fn tick_end(&mut self, screen: &mut Screen, events: &mut EventManager);
-}
-
-pub struct ExtensionManager(Vec<Box<dyn Extension>>);
-
-impl Extension for ExtensionManager {
-    fn init(&mut self, screen: &mut Screen, events: &mut EventManager) {
-        for ext in &mut self.0 {
-            ext.init(screen, events);
-        }
-    }
-
-    fn tick_start(&mut self, screen: &mut Screen, events: &mut EventManager) {
-        for ext in &mut self.0 {
-            ext.tick_start(screen, events);
-        }
-    }
-
-    fn tick_end(&mut self, screen: &mut Screen, events: &mut EventManager) {
-        for ext in &mut self.0 {
-            ext.tick_end(screen, events);
-        }
-    }
-}
-
-impl ExtensionManager {
-    pub fn new() -> ExtensionManager {
-        ExtensionManager(Vec::new())
-    }
-    pub fn add<E: Extension + 'static>(&mut self, extension: E) {
-        self.0.push(Box::new(extension));
-    }
-}
-
-pub struct EventHandlerFn(pub Box<dyn FnMut(Box<dyn Event>)>);
-
-impl std::fmt::Debug for EventHandlerFn {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "FnMut()")
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Close;
-
-impl Event for Close {
-    fn as_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-}
-
 pub struct Screen {
     pub elements: Vec<Box<dyn Element>>,
 }
@@ -91,7 +39,7 @@ impl Screen {
     pub fn run(
         &mut self,
         events: &mut EventManager,
-        extension_manager: &mut ExtensionManager,
+        extensions: &mut ExtensionManager,
     ) -> std::io::Result<()> {
         let mut scope = RenderScope {};
 
@@ -99,16 +47,16 @@ impl Screen {
             elem.init(events);
         }
 
-        extension_manager.init(self, events);
+        extensions.init(self, events);
 
         loop {
-            extension_manager.tick_start(self, events);
+            extensions.tick_start(self, events);
 
             for elem in &mut self.elements {
                 elem.render(&mut scope);
             }
 
-            extension_manager.tick_end(self, events);
+            extensions.tick_end(self, events);
         }
     }
 }

src/macros.rs

@@ -0,0 +1,37 @@
+#[macro_export]
+macro_rules! event {
+    ($name:ident) => {
+        #[derive(Debug, Clone)]
+        pub struct $name;
+
+        impl $crate::events::Event for $name {
+            fn as_any(self: Box<Self>) -> Box<dyn std::any::Any> {
+                self
+            }
+        }
+    };
+
+    ($name:ident {$($inner:tt)*}) => {
+        #[derive(Debug, Clone)]
+        pub struct $name {
+            $($inner)*
+        }
+
+        impl $crate::events::Event for $name {
+            fn as_any(self: Box<Self>) -> Box<dyn std::any::Any> {
+                self
+            }
+        }
+    };
+
+    ($name:ident ($($inner:tt)*)) => {
+        #[derive(Debug, Clone)]
+        pub struct $name ($($inner)*);
+
+        impl $crate::events::Event for $name {
+            fn as_any(self: Box<Self>) -> Box<dyn std::any::Any> {
+                self
+            }
+        }
+    };
+}

src/main.rs

@@ -1,5 +1,7 @@
 use osui::{
-    event_manager::EventManager, extensions::keypress::KeyPressExtension, ExtensionManager, Screen,
+    events::EventManager,
+    extensions::{keypress::KeyPressExtension, ExtensionManager},
+    Screen,
 };
 
 fn main() {