tasks initial impl (still working on task_on trait method)

src/bin/test/main.rs

@@ -1,214 +0,0 @@
-use cosmic_text::Family;
-use std::{cell::RefCell, rc::Rc};
-use winit::event::WindowEvent;
-
-iris::state_prelude!(DefaultRsc<Client>);
-
-fn main() {
-    DefaultApp::<Client>::run();
-}
-
-#[derive(DefaultUiState)]
-pub struct Client {
-    ui_state: DefaultUiState,
-    info: WidgetRef<Text>,
-}
-
-impl DefaultAppState for Client {
-    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self::Event>) -> Self {
-        let rrect = rect(Color::WHITE).radius(20);
-        let pad_test = (
-            rrect.color(Color::BLUE),
-            (
-                rrect
-                    .color(Color::RED)
-                    .sized((100, 100))
-                    .center()
-                    .width(rest(2)),
-                (
-                    rrect.color(Color::ORANGE),
-                    rrect.color(Color::LIME).pad(10.0),
-                )
-                    .span(Dir::RIGHT)
-                    .width(rest(2)),
-                rrect.color(Color::YELLOW),
-            )
-                .span(Dir::RIGHT)
-                .pad(10)
-                .width(rest(3)),
-        )
-            .span(Dir::RIGHT)
-            .add(rsc);
-
-        let span_test = (
-            rrect.color(Color::GREEN).width(100),
-            rrect.color(Color::ORANGE),
-            rrect.color(Color::CYAN),
-            rrect.color(Color::BLUE).width(rel(0.5)),
-            rrect.color(Color::MAGENTA).width(100),
-            rrect.color(Color::RED).width(100),
-        )
-            .span(Dir::LEFT)
-            .add(rsc);
-
-        let span_add = Span::empty(Dir::RIGHT).add(rsc);
-
-        let add_button = rect(Color::LIME)
-            .radius(30)
-            .on(CursorSense::click(), move |_, rsc| {
-                let child = image(include_bytes!("assets/sungals.png"))
-                    .center()
-                    .add_strong(rsc);
-                span_add(rsc).push(child);
-            })
-            .sized((150, 150))
-            .align(Align::BOT_RIGHT);
-
-        let del_button = rect(Color::RED)
-            .radius(30)
-            .on(CursorSense::click(), move |_, rsc| {
-                span_add(rsc).pop();
-            })
-            .sized((150, 150))
-            .align(Align::BOT_LEFT);
-
-        let span_add_test = (span_add, add_button, del_button).stack().add(rsc);
-
-        let btext = |content| wtext(content).size(30);
-
-        let text_test = (
-            btext("this is a").align(Align::LEFT),
-            btext("teeeeeeeest").align(Align::RIGHT),
-            btext("okkk\nokkkkkk!").align(Align::LEFT),
-            btext("hmm"),
-            btext("a"),
-            (
-                btext("'").family(Family::Monospace).align(Align::TOP),
-                btext("'").family(Family::Monospace),
-                btext(":gamer mode").family(Family::Monospace),
-                rect(Color::CYAN).sized((10, 10)).center(),
-                rect(Color::RED).sized((100, 100)).center(),
-                rect(Color::PURPLE).sized((50, 50)).align(Align::TOP),
-            )
-                .span(Dir::RIGHT)
-                .center(),
-            wtext("pretty cool right?").size(50),
-        )
-            .span(Dir::DOWN)
-            .add(rsc);
-
-        let texts = Span::empty(Dir::DOWN).gap(10).add(rsc);
-        let msg_area = texts.scrollable().masked().background(rect(Color::SKY));
-        let add_text = wtext("add")
-            .editable(EditMode::MultiLine)
-            .text_align(Align::LEFT)
-            .size(30)
-            .attr::<Selectable>(())
-            .on(Submit, move |ctx, rsc| {
-                let w = ctx.widget;
-                let content = w.edit(rsc).take();
-                let text = wtext(content)
-                    .editable(EditMode::MultiLine)
-                    .size(30)
-                    .text_align(Align::LEFT)
-                    .wrap(true)
-                    .attr::<Selectable>(());
-                let msg_box = text
-                    .background(rect(Color::WHITE.darker(0.5)))
-                    .add_strong(rsc);
-                texts(rsc).push(msg_box);
-            })
-            .add(rsc);
-        let text_edit_scroll = (
-            msg_area.height(rest(1)),
-            (
-                Rect::new(Color::WHITE.darker(0.9)),
-                (
-                    add_text.width(rest(1)),
-                    Rect::new(Color::GREEN)
-                        .on(CursorSense::click(), move |ctx, rsc| {
-                            rsc.run_event::<Submit>(add_text, &mut (), ctx.state);
-                        })
-                        .sized((40, 40)),
-                )
-                    .span(Dir::RIGHT)
-                    .pad(10),
-            )
-                .stack()
-                .size(StackSize::Child(1))
-                .layer_offset(1)
-                .align(Align::BOT),
-        )
-            .span(Dir::DOWN)
-            .add(rsc);
-
-        let main = WidgetPtr::new().add(rsc);
-
-        let vals = Rc::new(RefCell::new((0, Vec::new())));
-        let mut switch_button = |color, to: WidgetRef, label| {
-            let to = to.upgrade(rsc);
-            let vec = &mut vals.borrow_mut().1;
-            let i = vec.len();
-            if vec.is_empty() {
-                vec.push(None);
-                main(rsc).set(to);
-            } else {
-                vec.push(Some(to));
-            }
-            let vals = vals.clone();
-            let rect = rect(color)
-                .on(CursorSense::click(), move |ctx, rsc| {
-                    let (prev, vec) = &mut *vals.borrow_mut();
-                    if let Some(h) = vec[i].take() {
-                        vec[*prev] = main(rsc).replace(h);
-                        *prev = i;
-                    }
-                    ctx.widget(rsc).color = color.darker(0.3);
-                })
-                .on(
-                    CursorSense::HoverStart | CursorSense::unclick(),
-                    move |ctx, rsc| {
-                        ctx.widget(rsc).color = color.brighter(0.2);
-                    },
-                )
-                .on(CursorSense::HoverEnd, move |ctx, rsc| {
-                    ctx.widget(rsc).color = color;
-                });
-            (rect, wtext(label).size(30).text_align(Align::CENTER)).stack()
-        };
-
-        let tabs = (
-            switch_button(Color::RED, pad_test, "pad"),
-            switch_button(Color::GREEN, span_test, "span"),
-            switch_button(Color::BLUE, span_add_test, "image span"),
-            switch_button(Color::MAGENTA, text_test, "text layout"),
-            switch_button(
-                Color::YELLOW.mul_rgb(0.5),
-                text_edit_scroll,
-                "text edit scroll",
-            ),
-        )
-            .span(Dir::RIGHT);
-
-        let info = wtext("").add(rsc);
-        let info_sect = info.pad(10).align(Align::RIGHT);
-
-        ((tabs.height(40), main.pad(10)).span(Dir::DOWN), info_sect)
-            .stack()
-            .set_root(rsc);
-
-        Self { ui_state, info }
-    }
-
-    fn window_event(&mut self, _: WindowEvent, rsc: &mut DefaultRsc<Self>) {
-        let new = format!(
-            "widgets: {}\nactive: {}\nviews: {}",
-            rsc.ui.num_widgets(),
-            rsc.ui.active_widgets(),
-            self.ui_state.renderer.ui.view_count()
-        );
-        if new != *rsc.ui[self.info].content {
-            *rsc.ui[self.info].content = new;
-        }
-    }
-}

src/default/mod.rs

@@ -17,6 +17,7 @@ mod event;
 mod input;
 mod render;
 mod sense;
+mod task;
 
 pub use app::*;
 pub use attr::*;
@@ -24,6 +25,7 @@ pub use event::*;
 pub use input::*;
 pub use render::*;
 pub use sense::*;
+pub use task::*;
 
 pub type Proxy<Event> = EventLoopProxy<Event>;
 
@@ -79,19 +81,25 @@ pub trait DefaultAppState: HasDefaultUiState {
     }
 }
 
-pub struct DefaultRsc<State> {
+pub struct DefaultRsc<State: 'static> {
     pub ui: Ui,
     pub events: EventManager<Self>,
+    pub tasks: Tasks<Self>,
     _state: PhantomData<State>,
 }
 
-impl<State> Default for DefaultRsc<State> {
-    fn default() -> Self {
-        Self {
-            ui: Default::default(),
-            events: Default::default(),
-            _state: Default::default(),
-        }
+impl<State> DefaultRsc<State> {
+    fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Self>) {
+        let (tasks, recv) = Tasks::init(window);
+        (
+            Self {
+                ui: Default::default(),
+                events: Default::default(),
+                tasks,
+                _state: Default::default(),
+            },
+            recv,
+        )
     }
 }
 
@@ -105,9 +113,11 @@ impl<State> HasUi for DefaultRsc<State> {
     }
 }
 
-impl<State: 'static> HasEvents for DefaultRsc<State> {
+impl<State: 'static> HasState for DefaultRsc<State> {
     type State = State;
+}
 
+impl<State: 'static> HasEvents for DefaultRsc<State> {
     fn events(&self) -> &EventManager<Self> {
         &self.events
     }
@@ -120,11 +130,9 @@ impl<State: 'static> HasEvents for DefaultRsc<State> {
 pub struct DefaultApp<State: DefaultAppState> {
     rsc: DefaultRsc<State>,
     state: State,
+    task_recv: TaskMsgReceiver<DefaultRsc<State>>,
 }
 
-// impl StateLike for DefaultRsc<State> {
-// }
-//
 impl<State: DefaultAppState> AppState for DefaultApp<State> {
     type Event = State::Event;
 
@@ -132,9 +140,14 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
         let window = event_loop
             .create_window(State::window_attributes())
             .unwrap();
-        let mut rsc = DefaultRsc::default();
-        let state = State::new(DefaultUiState::new(window), &mut rsc, proxy);
-        Self { rsc, state }
+        let default_state = DefaultUiState::new(window);
+        let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone());
+        let state = State::new(default_state, &mut rsc, proxy);
+        Self {
+            rsc,
+            state,
+            task_recv,
+        }
     }
 
     fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
@@ -142,6 +155,10 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
     }
 
     fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
+        for update in self.task_recv.try_iter() {
+            update(&mut self.state, &mut self.rsc);
+        }
+
         let ui_state = self.state.default_state_mut();
         let input_changed = ui_state.input.event(&event);
         let cursor_state = ui_state.cursor_state().clone();

src/default/task.rs

@@ -0,0 +1,85 @@
+use iris_core::HasState;
+use std::{
+    pin::Pin,
+    sync::{
+        Arc,
+        mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel},
+    },
+};
+use tokio::{
+    runtime::Runtime,
+    sync::mpsc::{
+        UnboundedReceiver as AsyncReceiver, UnboundedSender as AsyncSender,
+        unbounded_channel as async_channel,
+    },
+};
+use winit::window::Window;
+
+pub type TaskMsgSender<Rsc> = SyncSender<Box<dyn TaskUpdate<Rsc>>>;
+pub type TaskMsgReceiver<Rsc> = SyncReceiver<Box<dyn TaskUpdate<Rsc>>>;
+
+pub trait TaskUpdate<Rsc: HasState>: FnOnce(&mut Rsc::State, &mut Rsc) + Send {}
+impl<F: FnOnce(&mut Rsc::State, &mut Rsc) + Send, Rsc: HasState> TaskUpdate<Rsc> for F {}
+
+pub struct Tasks<Rsc: HasState> {
+    start: AsyncSender<BoxTask>,
+    window: Arc<Window>,
+    msg_send: SyncSender<Box<dyn TaskUpdate<Rsc>>>,
+}
+
+pub struct TaskCtx<Rsc: HasState> {
+    send: TaskMsgSender<Rsc>,
+}
+
+impl<Rsc: HasState> TaskCtx<Rsc> {
+    pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
+        let _ = self.send.send(Box::new(f));
+    }
+}
+impl<Rsc: HasState + 'static> TaskCtx<Rsc> {
+    fn new(send: TaskMsgSender<Rsc>) -> Self {
+        Self { send }
+    }
+}
+
+type BoxTask = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+impl<Rsc: HasState> Tasks<Rsc> {
+    pub fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Rsc>) {
+        let (start, start_recv) = async_channel();
+        let (msgs, msgs_recv) = sync_channel();
+        std::thread::spawn(|| {
+            let rt = Runtime::new().unwrap();
+            rt.block_on(listen(start_recv))
+        });
+        (
+            Self {
+                start,
+                msg_send: msgs,
+                window,
+            },
+            msgs_recv,
+        )
+    }
+
+    pub fn spawn<F: for<'a> AsyncFnOnce(&'a mut TaskCtx<Rsc>) + 'static + std::marker::Send>(
+        &mut self,
+        task: F,
+    ) where
+        for<'a> <F as AsyncFnOnce<(&'a mut TaskCtx<Rsc>,)>>::CallOnceFuture: Send,
+    {
+        let send = self.msg_send.clone();
+        let window = self.window.clone();
+        let _ = self.start.send(Box::pin(async move {
+            let mut ctx = TaskCtx::new(send);
+            task(&mut ctx).await;
+            window.request_redraw();
+        }));
+    }
+}
+
+async fn listen(mut recv: AsyncReceiver<BoxTask>) {
+    while let Some(task) = recv.recv().await {
+        tokio::spawn(task);
+    }
+}

src/event.rs

@@ -1,17 +1,20 @@
-use crate::prelude::*;
+use iris_core::*;
+use iris_macro::*;
+
+use crate::default::{TaskCtx, Tasks};
 
 pub mod eventable {
     use super::*;
     widget_trait! {
-        pub trait Eventable<Rsc: HasEvents + 'static>;
+        pub trait Eventable<Rsc: HasEvents>;
         fn on<E: EventLike>(
             self,
             event: E,
             f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, WL::Widget>,
         ) -> impl WidgetIdFn<Rsc, WL::Widget> {
-            move |state| {
-                let id = self.add(state);
-                state.register_event(id, event.into_event(), move |ctx, rsc| {
+            move |rsc| {
+                let id = self.add(rsc);
+                rsc.register_event(id, event.into_event(), move |ctx, rsc| {
                     f(&mut EventIdCtx {
                         widget: id,
                         state: ctx.state,
@@ -22,4 +25,52 @@ pub mod eventable {
             }
         }
     }
+
+    // widget_trait! {
+    //     pub trait TaskEventable<Rsc: HasEvents + HasTasks>;
+    //     fn task_on<E: EventLike>(
+    //         self,
+    //         event: E,
+    //         f: impl for<'a> AsyncWidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, WL::Widget>,
+    //     ) -> impl WidgetIdFn<Rsc, WL::Widget> {
+    //         move |rsc| {
+    //             let id = self.add(rsc);
+    //             rsc.register_event(id, event.into_event(), move |ctx, rsc| {
+    //                 rsc.tasks_mut().spawn(async move |task| {
+    //                     f(&mut AsyncEventIdCtx {
+    //                         widget: id,
+    //                         state: ctx.state,
+    //                         data: ctx.data,
+    //                         task,
+    //                     }, rsc).await;
+    //                 });
+    //             });
+    //             id
+    //         }
+    //     }
+    // }
+}
+
+pub trait HasTasks: Sized + HasState + HasEvents {
+    fn tasks_mut(&mut self) -> &mut Tasks<Self>;
+}
+
+pub trait AsyncWidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
+    AsyncFn(&mut AsyncEventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
+{
+}
+impl<
+    Rsc: HasEvents,
+    F: AsyncFn(&mut AsyncEventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static,
+    Data,
+    W: ?Sized,
+> AsyncWidgetEventFn<Rsc, Data, W> for F
+{
+}
+
+pub struct AsyncEventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
+    pub widget: WidgetRef<W>,
+    pub state: &'a mut Rsc::State,
+    pub data: &'a mut Data,
+    pub task: &'a mut TaskCtx<Rsc>,
 }

src/lib.rs

@@ -4,6 +4,7 @@
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(option_into_flat_iter)]
+#![feature(async_fn_traits)]
 
 pub mod default;
 pub mod event;

src/typed.rs

@@ -30,7 +30,7 @@ macro_rules! event_state {
                 }
             }
         }
-        $vis type EventManager = $crate::prelude::EventManager<<$rsc as HasEvents>::State>;
+        $vis type EventManager = $crate::prelude::EventManager<<$rsc as HasState>::State>;
         $vis use local_event_trait::*;
     };
 }

src/widget/trait_fns.rs

@@ -84,7 +84,7 @@ widget_trait! {
     }
 
     fn scrollable(self) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
-        use eventable::*;
+        use eventable::Eventable;
         move |state| {
             Scroll::new(self.add_strong(state), Axis::Y)
                 .on(CursorSense::Scroll, |ctx, rsc| {