macro goodness

src/bin/test/main.rs

@@ -1,23 +1,20 @@
-use std::{cell::RefCell, rc::Rc};
-
 use cosmic_text::Family;
-use iris::prelude::*;
-use len_fns::*;
+use std::{cell::RefCell, rc::Rc};
 use winit::{event::WindowEvent, event_loop::ActiveEventLoop, window::WindowAttributes};
 
+iris::state_prelude!(Client);
+
 fn main() {
     App::<Client>::run();
 }
 
-#[derive(HasUi, HasUiState)]
+#[derive(DefaultUiState)]
 pub struct Client {
-    ui: Ui<Self>,
-    ui_state: UiState<Self>,
-    info: WidgetRef<Self, Text<Self>>,
+    ui: Ui,
+    ui_state: UiState,
+    info: WidgetRef<Text>,
 }
 
-event_ctx!(Client);
-
 impl DefaultAppState for Client {
     fn new(event_loop: &ActiveEventLoop, _proxy: Proxy<Self::Event>) -> Self {
         let mut ui = Ui::new();
@@ -153,7 +150,7 @@ impl DefaultAppState for Client {
             let main = WidgetPtr::new().handles(ui);
 
             let vals = Rc::new(RefCell::new((0, Vec::new())));
-            let mut switch_button = |color, to: WidgetHandle<Self>, label| {
+            let mut switch_button = |color, to: WidgetHandle, label| {
                 let vec = &mut vals.borrow_mut().1;
                 let i = vec.len();
                 if vec.is_empty() {

src/default/mod.rs

@@ -52,7 +52,10 @@ pub trait HasUiState: Sized + 'static + HasUi {
     fn ui_state(&mut self) -> &mut UiState<Self>;
     fn ui_with_ui_state(&mut self) -> (&mut Ui<Self>, &mut UiState<Self>) {
         // as long as you're not doing anything actually unhinged this should always work safely
-        (unsafe { std::mem::transmute(self.ui()) }, self.ui_state())
+        (
+            unsafe { std::mem::transmute::<&mut Ui<Self>, &mut Ui<Self>>(self.ui()) },
+            self.ui_state(),
+        )
     }
 }
 

src/event.rs

@@ -23,34 +23,3 @@ pub mod eventable {
         }
     }
 }
-
-// TODO: naming in here is a bit weird like eventable
-#[macro_export]
-macro_rules! event_ctx {
-    ($ty: ty) => {
-        mod local_event_trait {
-            use super::*;
-            #[allow(unused_imports)]
-            use $crate::prelude::*;
-
-            pub trait EventableCtx<WL: WidgetLike<$ty, Tag>, Tag> {
-                fn on<E: EventLike>(
-                    self,
-                    event: E,
-                    f: impl for<'a> WidgetEventFn<$ty, <E::Event as Event>::Data<'a>, WL::Widget>,
-                ) -> impl WidgetIdFn<$ty, WL::Widget>;
-            }
-            impl<WL: WidgetLike<$ty, Tag>, Tag> EventableCtx<WL, Tag> for WL {
-                fn on<E: EventLike>(
-                    self,
-                    event: E,
-                    f: impl for<'a> WidgetEventFn<Client, <E::Event as Event>::Data<'a>, WL::Widget>,
-                ) -> impl WidgetIdFn<Client, WL::Widget> {
-                    eventable::Eventable::on(self, event, f)
-                }
-            }
-        }
-        use local_event_trait::*;
-    };
-}
-pub use event_ctx;

src/lib.rs

@@ -4,9 +4,29 @@
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 
-mod default;
-mod event;
-mod widget;
+pub mod default;
+pub mod event;
+pub mod state;
+pub mod widget;
+
+pub use iris_core;
+pub use iris_macro;
+
+#[macro_export]
+macro_rules! state_prelude {
+    ($state:ty) => {
+        iris::event_state!($state);
+        iris::iris_core::core_state!($state);
+        iris::default_state!($state);
+        iris::widget_state!($state);
+        pub use iris::{
+            default::*,
+            iris_core::{len_fns::*, util::Vec2, *},
+            iris_macro::*,
+            widget::*,
+        };
+    };
+}
 
 pub mod prelude {
     use super::*;
@@ -17,4 +37,5 @@ pub mod prelude {
     pub use widget::*;
 
     pub use iris_core::util::Vec2;
+    pub use state::*;
 }

src/state.rs

@@ -0,0 +1,60 @@
+#[macro_export]
+macro_rules! default_state {
+    ($vis:vis $state:ty) => {
+        $vis type UiState = $crate::default::UiState<$state>;
+    };
+}
+
+#[macro_export]
+macro_rules! widget_state {
+    ($vis:vis $state:ty) => {
+        $crate::widget_state!(
+            $vis $state;
+            Aligned,
+            LayerOffset,
+            MaxSize,
+            Offset,
+            Scroll,
+            Sized,
+            Span,
+            Stack,
+            Text,
+            TextEdit,
+            Masked,
+            WidgetPtr,
+        );
+    };
+    ($vis:vis $state:ty; $($ty:ident,)*) => {
+        $($vis type $ty = $crate::widget::$ty<$state>;)*
+    }
+}
+
+#[macro_export]
+macro_rules! event_state {
+    ($state:ty) => {
+        mod local_event_trait {
+            use super::*;
+            #[allow(unused_imports)]
+            use $crate::prelude::*;
+
+            pub trait EventableCtx<WL: WidgetLike<$state, Tag>, Tag> {
+                fn on<E: EventLike>(
+                    self,
+                    event: E,
+                    f: impl for<'a> WidgetEventFn<$state, <E::Event as Event>::Data<'a>, WL::Widget>,
+                ) -> impl WidgetIdFn<$state, WL::Widget>;
+            }
+            impl<WL: WidgetLike<$state, Tag>, Tag> EventableCtx<WL, Tag> for WL {
+                fn on<E: EventLike>(
+                    self,
+                    event: E,
+                    f: impl for<'a> WidgetEventFn<Client, <E::Event as Event>::Data<'a>, WL::Widget>,
+                ) -> impl WidgetIdFn<Client, WL::Widget> {
+                    eventable::Eventable::on(self, event, f)
+                }
+            }
+        }
+        use local_event_trait::*;
+    };
+}
+pub use event_state;