Create windows with UserEvent

Cargo.toml

@@ -17,6 +17,8 @@ lazy_static = "1.4.0"
 slotmap = "1.0.6"
 vello = { git = "https://github.com/linebender/vello", version = "0.0.1" }
 winit = "0.29.3"
+anyhow = "1.0.75"
+clap = "4.4.8"
 
 [package.metadata.docs.rs]
 features = ["full"]

examples/app.rs

@@ -8,20 +8,20 @@ async fn main() {
     let ui = UserInterface::new();
 
     // Window A
-    let tree = ui.insert(LocalTree::builder(Window::default()));
+    let tree = ui.insert(LocalTree::builder(Window::new(&ui)));
 
     let a = tree.insert(Text::new("Window A"));
     tree.root().push_child(a.key);
 
     // Window B
-    let sub_tree = ui.insert(LocalTree::builder(Window::default()));
+    let sub_tree = ui.insert(LocalTree::builder(Window::new(&ui)));
     tree.insert(sub_tree.tree.clone());
 
     let b = sub_tree.insert(Text::new("Window B"));
     sub_tree.root().push_child(b.key);
 
     // Window C
-    let window_c = sub_tree.insert(Window::default());
+    let window_c = sub_tree.insert(Window::new(&ui));
     sub_tree.root().push_child(window_c.key);
 
     let a = sub_tree.insert(Text::new("Window C"));

src/any_element.rs

@@ -2,13 +2,18 @@ use std::any::Any;
 
 use vello::SceneBuilder;
 
-use crate::Element;
+use crate::{
+    element::{Lifecycle, LifecycleContext},
+    Element,
+};
 
 pub trait AnyElement {
     fn as_any(&self) -> &dyn Any;
 
     fn as_any_mut(&mut self) -> &mut dyn Any;
 
+    fn lifecycle_any(&mut self, cx: LifecycleContext, lifecycle: Lifecycle);
+
     fn handle_any(&mut self, msg: Box<dyn Any>);
 
     fn render_any(&mut self, scene: SceneBuilder);
@@ -26,6 +31,10 @@ where
         self
     }
 
+    fn lifecycle_any(&mut self, cx: LifecycleContext, lifecycle: Lifecycle) {
+        self.lifecycle(cx, lifecycle)
+    }
+
     fn handle_any(&mut self, msg: Box<dyn Any>) {
         self.handle(*msg.downcast().unwrap())
     }

src/element/mod.rs

@@ -1,23 +1,29 @@
+use slotmap::DefaultKey;
 use vello::SceneBuilder;
 
 mod text;
 pub use text::{Text, TextMessage};
 
-pub trait Element {
-    type Message;
+mod window;
+pub use window::Window;
 
-    fn handle(&mut self, msg: Self::Message);
+use crate::TreeKey;
 
-    fn render(&mut self, scene: SceneBuilder);
+pub struct LifecycleContext {
+    pub tree_key: TreeKey,
+    pub key: DefaultKey,
+}
+
+pub enum Lifecycle {
+    Build,
 }
 
-#[derive(Default)]
-pub struct Window {}
+pub trait Element {
+    type Message;
 
-impl Element for Window {
-    type Message = ();
+    fn lifecycle(&mut self, _cx: LifecycleContext, _lifecycle: Lifecycle) {}
 
-    fn handle(&mut self, _msg: Self::Message) {}
+    fn handle(&mut self, msg: Self::Message);
 
-    fn render(&mut self, _scene: SceneBuilder) {}
+    fn render(&mut self, scene: SceneBuilder);
 }

src/element/text.rs

@@ -1,6 +1,5 @@
-use std::borrow::Cow;
-
 use crate::{Element, LocalElementRef};
+use std::borrow::Cow;
 
 pub enum TextMessage {
     SetContent(Cow<'static, str>),

src/element/window.rs

@@ -0,0 +1,26 @@
+use crate::{Element, UserInterface};
+use vello::SceneBuilder;
+
+use super::LifecycleContext;
+
+pub struct Window {
+    ui: UserInterface,
+}
+
+impl Window {
+    pub fn new(ui: &UserInterface) -> Self {
+        Self { ui: ui.clone() }
+    }
+}
+
+impl Element for Window {
+    type Message = ();
+
+    fn lifecycle(&mut self, cx: LifecycleContext, _lifecycle: super::Lifecycle) {
+        self.ui.insert_window(cx.tree_key, cx.key)
+    }
+
+    fn handle(&mut self, _msg: Self::Message) {}
+
+    fn render(&mut self, _scene: SceneBuilder) {}
+}

src/tree/local.rs

@@ -1,5 +1,7 @@
 use super::{TreeBuilder, TreeMessage};
-use crate::{element::Window, AnyElement, Element, LocalElementRef, TreeKey, UserInterface};
+use crate::{
+    element::LifecycleContext, AnyElement, Element, LocalElementRef, TreeKey, UserInterface,
+};
 use slotmap::{DefaultKey, SlotMap, SparseSecondaryMap};
 use std::{cell::RefCell, marker::PhantomData, rc::Rc};
 use vello::{Scene, SceneBuilder};
@@ -40,19 +42,22 @@ impl<E> LocalTree<E> {
         let element: Rc<RefCell<Box<dyn AnyElement>>> = Rc::new(RefCell::new(Box::new(element)));
         let key = self.inner.borrow_mut().elements.insert(element.clone());
 
+        // TODO
+        element.borrow_mut().lifecycle_any(
+            LifecycleContext {
+                tree_key: self.inner.borrow().key,
+                key,
+            },
+            crate::element::Lifecycle::Build,
+        );
+
         LocalElementRef {
             element,
             tree: self.clone(),
             key,
             _marker: PhantomData,
         }
     }
-
-    pub fn insert_window(&self) -> LocalElementRef<E, Window> {
-        let window = self.insert(Window {});
-        self.ui.insert_window(self.inner.borrow().key, window.key);
-        window
-    }
 }
 
 impl<E: Element> Element for LocalTree<E> {