refactor events; watch prep work

uidev/src/main.rs

@@ -19,7 +19,10 @@ use vulkano::{
     sync::GpuFuture,
 };
 use wgui::{
-    event::{MouseButton, MouseDownEvent, MouseMotionEvent, MouseUpEvent, MouseWheelEvent},
+    event::{
+        EventListenerCollection, MouseButton, MouseDownEvent, MouseMotionEvent, MouseUpEvent,
+        MouseWheelEvent,
+    },
     gfx::WGfx,
     renderer_vk::{self},
 };
@@ -29,7 +32,7 @@ use winit::{
     keyboard::{KeyCode, PhysicalKey},
 };
 
-use crate::testbed::{testbed_dashboard::TestbedDashboard, testbed_generic::TestbedGeneric};
+use crate::testbed::testbed_generic::TestbedGeneric;
 
 mod assets;
 mod profiler;
@@ -53,11 +56,12 @@ fn init_logging() {
         .init();
 }
 
-fn load_testbed() -> anyhow::Result<Box<dyn Testbed>> {
+fn load_testbed(
+    listeners: &mut EventListenerCollection<(), ()>,
+) -> anyhow::Result<Box<dyn Testbed>> {
     let name = std::env::var("TESTBED").unwrap_or_default();
     Ok(match name.as_str() {
-        "dashboard" => Box::new(TestbedDashboard::new()?),
+        "" => Box::new(TestbedGeneric::new(listeners)?),
-        "" => Box::new(TestbedGeneric::new()?),
         _ => Box::new(TestbedAny::new(&name)?),
     })
 }
@@ -92,7 +96,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut scale = window.scale_factor() as f32;
 
-    let mut testbed = load_testbed()?;
+    let mut listeners = EventListenerCollection::default();
+
+    let mut testbed = load_testbed(&mut listeners)?;
 
     let mut mouse = Vec2::ZERO;
 
@@ -119,19 +125,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             } => match delta {
                 MouseScrollDelta::LineDelta(x, y) => testbed
                     .layout()
-                    .push_event(&wgui::event::Event::MouseWheel(MouseWheelEvent {
+                    .push_event(
-                        shift: Vec2::new(x, y),
+                        &listeners,
-                        pos: mouse / scale,
+                        &wgui::event::Event::MouseWheel(MouseWheelEvent {
-                        device: 0,
+                            shift: Vec2::new(x, y),
-                    }))
+                            pos: mouse / scale,
+                            device: 0,
+                        }),
+                        (&mut (), &mut ()),
+                    )
                     .unwrap(),
                 MouseScrollDelta::PixelDelta(pos) => testbed
                     .layout()
-                    .push_event(&wgui::event::Event::MouseWheel(MouseWheelEvent {
+                    .push_event(
-                        shift: Vec2::new(pos.x as f32 / 5.0, pos.y as f32 / 5.0),
+                        &listeners,
-                        pos: mouse / scale,
+                        &wgui::event::Event::MouseWheel(MouseWheelEvent {
-                        device: 0,
+                            shift: Vec2::new(pos.x as f32 / 5.0, pos.y as f32 / 5.0),
-                    }))
+                            pos: mouse / scale,
+                            device: 0,
+                        }),
+                        (&mut (), &mut ()),
+                    )
                     .unwrap(),
             },
             Event::WindowEvent {
@@ -142,20 +156,28 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     if matches!(state, winit::event::ElementState::Pressed) {
                         testbed
                             .layout()
-                            .push_event(&wgui::event::Event::MouseDown(MouseDownEvent {
+                            .push_event(
-                                pos: mouse / scale,
+                                &listeners,
-                                button: MouseButton::Left,
+                                &wgui::event::Event::MouseDown(MouseDownEvent {
-                                device: 0,
+                                    pos: mouse / scale,
-                            }))
+                                    button: MouseButton::Left,
+                                    device: 0,
+                                }),
+                                (&mut (), &mut ()),
+                            )
                             .unwrap();
                     } else {
                         testbed
                             .layout()
-                            .push_event(&wgui::event::Event::MouseUp(MouseUpEvent {
+                            .push_event(
-                                pos: mouse / scale,
+                                &listeners,
-                                button: MouseButton::Left,
+                                &wgui::event::Event::MouseUp(MouseUpEvent {
-                                device: 0,
+                                    pos: mouse / scale,
-                            }))
+                                    button: MouseButton::Left,
+                                    device: 0,
+                                }),
+                                (&mut (), &mut ()),
+                            )
                             .unwrap();
                     }
                 }
@@ -167,10 +189,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 mouse = vec2(position.x as _, position.y as _);
                 testbed
                     .layout()
-                    .push_event(&wgui::event::Event::MouseMotion(MouseMotionEvent {
+                    .push_event(
-                        pos: mouse / scale,
+                        &listeners,
-                        device: 0,
+                        &wgui::event::Event::MouseMotion(MouseMotionEvent {
-                    }))
+                            pos: mouse / scale,
+                            device: 0,
+                        }),
+                        (&mut (), &mut ()),
+                    )
                     .unwrap();
             }
             Event::WindowEvent {

uidev/src/testbed/mod.rs

@@ -1,10 +1,9 @@
 use wgui::layout::Layout;
 
 pub mod testbed_any;
-pub mod testbed_dashboard;
 pub mod testbed_generic;
 
 pub trait Testbed {
-	fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()>;
+    fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()>;
-	fn layout(&mut self) -> &mut Layout;
+    fn layout(&mut self) -> &mut Layout;
 }

uidev/src/testbed/testbed_any.rs

@@ -3,26 +3,26 @@ use glam::Vec2;
 use wgui::layout::Layout;
 
 pub struct TestbedAny {
-	pub layout: Layout,
+    pub layout: Layout,
 }
 
 impl TestbedAny {
-	pub fn new(name: &str) -> anyhow::Result<Self> {
+    pub fn new(name: &str) -> anyhow::Result<Self> {
-		let path = format!("gui/{name}.xml");
+        let path = format!("gui/{name}.xml");
-		let (layout, _state) = wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), &path)?;
+        let (layout, _state) =
-		Ok(Self { layout })
+            wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), &path)?;
-	}
+        Ok(Self { layout })
+    }
 }
 
 impl Testbed for TestbedAny {
-	fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()> {
+    fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()> {
-		self
+        self.layout
-			.layout
+            .update(Vec2::new(width, height), timestep_alpha)?;
-			.update(Vec2::new(width, height), timestep_alpha)?;
+        Ok(())
-		Ok(())
+    }
-	}
 
-	fn layout(&mut self) -> &mut Layout {
+    fn layout(&mut self) -> &mut Layout {
-		&mut self.layout
+        &mut self.layout
-	}
+    }
 }

uidev/src/testbed/testbed_dashboard.rs

@@ -1,29 +0,0 @@
-use crate::{assets, testbed::Testbed};
-use glam::Vec2;
-use wgui::layout::Layout;
-
-pub struct TestbedDashboard {
-	pub layout: Layout,
-}
-
-impl TestbedDashboard {
-	pub fn new() -> anyhow::Result<Self> {
-		const XML_PATH: &str = "gui/dashboard.xml";
-		let (layout, _state) =
-			wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), XML_PATH)?;
-		Ok(Self { layout })
-	}
-}
-
-impl Testbed for TestbedDashboard {
-	fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()> {
-		self
-			.layout
-			.update(Vec2::new(width, height), timestep_alpha)?;
-		Ok(())
-	}
-
-	fn layout(&mut self) -> &mut Layout {
-		&mut self.layout
-	}
-}

uidev/src/testbed/testbed_generic.rs

@@ -2,98 +2,98 @@ use std::{cell::RefCell, rc::Rc};
 
 use glam::{Mat4, Vec2};
 use wgui::{
-	drawing::{self},
+    drawing::{self},
-	event::EventListener,
+    event::{EventListenerCollection, EventListenerKind},
-	layout::{Layout, WidgetID},
+    layout::{Layout, WidgetID},
-	renderer_vk::text::TextStyle,
+    renderer_vk::text::TextStyle,
 };
 
 use crate::{assets, testbed::Testbed};
 
 pub struct TestbedGeneric {
-	pub layout: Layout,
+    pub layout: Layout,
-	rot: f32,
+    rot: f32,
-	widget_id: Rc<RefCell<Option<WidgetID>>>,
+    widget_id: Rc<RefCell<Option<WidgetID>>>,
 }
 
 impl TestbedGeneric {
-	pub fn new() -> anyhow::Result<Self> {
+    pub fn new(listeners: &mut EventListenerCollection<(), ()>) -> anyhow::Result<Self> {
-		const XML_PATH: &str = "gui/testbed.xml";
+        const XML_PATH: &str = "gui/testbed.xml";
 
-		let (mut layout, res) =
+        let (mut layout, res) =
-			wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), XML_PATH)?;
+            wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), XML_PATH)?;
 
-		use wgui::components::button;
+        use wgui::components::button;
-		let my_div_parent = res.require_by_id("my_div_parent")?;
+        let my_div_parent = res.require_by_id("my_div_parent")?;
-		// create some buttons for testing
+        // create some buttons for testing
-		for i in 0..4 {
+        for i in 0..4 {
-			let n = i as f32 / 4.0;
+            let n = i as f32 / 4.0;
-			button::construct(
+            button::construct(
-				&mut layout,
+                &mut layout,
-				my_div_parent,
+                my_div_parent,
-				button::Params {
+                button::Params {
-					text: "I'm a button!",
+                    text: "I'm a button!",
-					color: drawing::Color::new(1.0 - n, n * n, n, 1.0),
+                    color: drawing::Color::new(1.0 - n, n * n, n, 1.0),
-					..Default::default()
+                    ..Default::default()
-				},
+                },
-			)?;
+            )?;
-		}
+        }
 
-		let button = button::construct(
+        let button = button::construct(
-			&mut layout,
+            &mut layout,
-			my_div_parent,
+            my_div_parent,
-			button::Params {
+            button::Params {
-				text: "Click me!!",
+                text: "Click me!!",
-				color: drawing::Color::new(0.2, 0.2, 0.2, 1.0),
+                color: drawing::Color::new(0.2, 0.2, 0.2, 1.0),
-				size: Vec2::new(256.0, 64.0),
+                size: Vec2::new(256.0, 64.0),
-				text_style: TextStyle {
+                text_style: TextStyle {
-					size: Some(30.0),
+                    size: Some(30.0),
-					..Default::default()
+                    ..Default::default()
-				},
+                },
-			},
+            },
-		)?;
+        )?;
 
-		let widget_id = Rc::new(RefCell::new(None));
+        let widget_id = Rc::new(RefCell::new(None));
 
-		let wid = widget_id.clone();
+        let wid = widget_id.clone();
-		layout.add_event_listener(
+        listeners.add(
-			button.body,
+            button.body,
-			EventListener::MouseRelease(Box::new(move |data, _| {
+            EventListenerKind::MouseRelease,
-				button.set_text(data, "Congratulations!");
+            Box::new(move |data, (), ()| {
-				*wid.borrow_mut() = Some(data.widget_id);
+                button.set_text(data, "Congratulations!");
-			})),
+                *wid.borrow_mut() = Some(data.widget_id);
-		);
+            }),
+        );
 
-		Ok(Self {
+        Ok(Self {
-			layout,
+            layout,
-			rot: 0.0,
+            rot: 0.0,
-			widget_id,
+            widget_id,
-		})
+        })
-	}
+    }
 }
 
 impl Testbed for TestbedGeneric {
-	fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()> {
+    fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()> {
-		if let Some(widget_id) = *self.widget_id.borrow() {
+        if let Some(widget_id) = *self.widget_id.borrow() {
-			self.rot += 0.01;
+            self.rot += 0.01;
 
-			let a = self.layout.widget_map.get(widget_id).unwrap();
+            let a = self.layout.widget_map.get(widget_id).unwrap();
-			let mut widget = a.lock().unwrap();
+            let mut widget = a.lock().unwrap();
-			widget.data.transform = Mat4::IDENTITY
+            widget.data.transform = Mat4::IDENTITY
-				* Mat4::from_rotation_y(-self.rot)
+                * Mat4::from_rotation_y(-self.rot)
-				* Mat4::from_rotation_x(self.rot * 0.25)
+                * Mat4::from_rotation_x(self.rot * 0.25)
-				* Mat4::from_rotation_z(-self.rot * 0.1);
+                * Mat4::from_rotation_z(-self.rot * 0.1);
 
-			self.layout.needs_redraw = true;
+            self.layout.needs_redraw = true;
-		}
+        }
 
-		self
+        self.layout
-			.layout
+            .update(Vec2::new(width, height), timestep_alpha)?;
-			.update(Vec2::new(width, height), timestep_alpha)?;
+        Ok(())
-		Ok(())
+    }
-	}
 
-	fn layout(&mut self) -> &mut Layout {
+    fn layout(&mut self) -> &mut Layout {
-		&mut self.layout
+        &mut self.layout
-	}
+    }
-}
+}

wgui/src/components/button.rs

@@ -6,7 +6,7 @@ use taffy::{AlignItems, JustifyContent, prelude::length};
 use crate::{
 	animation::{Animation, AnimationEasing},
 	drawing::{self, Color},
-	event::{EventListener, WidgetCallback},
+	event::WidgetCallback,
 	layout::{Layout, WidgetID},
 	renderer_vk::text::{FontWeight, TextStyle},
 	widget::{
@@ -135,8 +135,6 @@ pub fn construct(
 		},
 	)?;
 
-	let mut widget = layout.widget_map.get(rect_id).unwrap().lock().unwrap();
-
 	let button = Arc::new(Button {
 		body: rect_id,
 		color: params.color,
@@ -144,25 +142,9 @@ pub fn construct(
 		text_node,
 	});
 
-	// Highlight background on mouse enter
+	//TODO: Highlight background on mouse enter
-	{
-		let button = button.clone();
-		widget.add_event_listener(EventListener::MouseEnter(Box::new(move |data, _| {
-			data
-				.animations
-				.push(anim_hover_in(button.clone(), data.widget_id));
-		})));
-	}
 
-	// Bring back old color on mouse leave
+	//TODO: Bring back old color on mouse leave
-	{
-		let button = button.clone();
-		widget.add_event_listener(EventListener::MouseLeave(Box::new(move |data, _| {
-			data
-				.animations
-				.push(anim_hover_out(button.clone(), data.widget_id));
-		})));
-	}
 
 	Ok(button)
-}
+}

wgui/src/event.rs

@@ -1,4 +1,5 @@
 use glam::Vec2;
+use slotmap::SecondaryMap;
 
 use crate::{
 	animation,
@@ -105,6 +106,7 @@ pub struct CallbackData<'a> {
 	pub dirty_nodes: &'a mut Vec<taffy::NodeId>,
 	pub needs_redraw: bool,
 	pub trigger_haptics: bool,
+	pub metadata: CallbackMetadata,
 }
 
 impl<'a> WidgetCallback<'a> for CallbackData<'a> {
@@ -121,16 +123,70 @@ impl<'a> WidgetCallback<'a> for CallbackData<'a> {
 	}
 }
 
-pub type MouseEnterCallback = Box<dyn Fn(&mut CallbackData, ())>;
+pub enum CallbackMetadata {
-pub type MouseLeaveCallback = Box<dyn Fn(&mut CallbackData, ())>;
+	None,
-pub type MousePressCallback = Box<dyn Fn(&mut CallbackData, MouseButton)>;
+	MouseButton(MouseButton),
-pub type MouseReleaseCallback = Box<dyn Fn(&mut CallbackData, MouseButton)>;
+	Custom(usize),
-pub type InternalStateChangeCallback = Box<dyn Fn(&mut CallbackData, usize)>;
+}
-
+
-pub enum EventListener {
+#[derive(Clone, Copy, PartialEq, Eq)]
-	MouseEnter(MouseEnterCallback),
+pub enum EventListenerKind {
-	MouseLeave(MouseLeaveCallback),
+	MousePress,
-	MousePress(MousePressCallback),
+	MouseRelease,
-	MouseRelease(MouseReleaseCallback),
+	MouseEnter,
-	InternalStateChange(InternalStateChangeCallback),
+	MouseLeave,
+	InternalStateChange,
+}
+
+pub type EventCallback<U1, U2> = Box<dyn Fn(&mut CallbackData, &mut U1, &mut U2)>;
+
+pub struct EventListener<U1, U2> {
+	pub kind: EventListenerKind,
+	pub callback: EventCallback<U1, U2>,
+}
+
+impl<U1, U2> EventListener<U1, U2> {
+	pub fn callback_for_kind(
+		&self,
+		kind: EventListenerKind,
+	) -> Option<&impl Fn(&mut CallbackData, &mut U1, &mut U2)> {
+		if self.kind == kind {
+			Some(&self.callback)
+		} else {
+			None
+		}
+	}
+}
+
+pub struct EventListenerCollection<U1, U2> {
+	map: SecondaryMap<WidgetID, Vec<EventListener<U1, U2>>>,
+}
+
+// derive only works if generics also implement Default
+impl<U1, U2> Default for EventListenerCollection<U1, U2> {
+	fn default() -> Self {
+		Self {
+			map: SecondaryMap::default(),
+		}
+	}
+}
+
+impl<U1, U2> EventListenerCollection<U1, U2> {
+	pub fn add(
+		&mut self,
+		widget_id: WidgetID,
+		kind: EventListenerKind,
+		callback: EventCallback<U1, U2>,
+	) {
+		let new_item = EventListener { kind, callback };
+		if let Some(vec) = self.map.get_mut(widget_id) {
+			vec.push(new_item);
+		} else {
+			self.map.insert(widget_id, vec![new_item]);
+		}
+	}
+
+	pub fn get(&self, widget_id: WidgetID) -> Option<&[EventListener<U1, U2>]> {
+		self.map.get(widget_id).map(|v| v.as_slice())
+	}
 }

wgui/src/layout.rs

@@ -3,7 +3,7 @@ use std::sync::{Arc, Mutex};
 use crate::{
 	animation::{self, Animations},
 	assets::AssetProvider,
-	event::{self, EventListener},
+	event::{self, EventListenerCollection},
 	transform_stack::{Transform, TransformStack},
 	widget::{self, EventParams, WidgetState, div::Div},
 };
@@ -89,26 +89,30 @@ impl Layout {
 		)
 	}
 
-	fn push_event_children(
+	fn push_event_children<U1, U2>(
 		&self,
+		listeners: &EventListenerCollection<U1, U2>,
 		parent_node_id: taffy::NodeId,
 		state: &mut PushEventState,
 		event: &event::Event,
 		dirty_nodes: &mut Vec<taffy::NodeId>,
+		user_data: &mut (&mut U1, &mut U2),
 	) -> anyhow::Result<()> {
 		for child_id in self.tree.child_ids(parent_node_id) {
-			self.push_event_widget(state, child_id, event, dirty_nodes)?;
+			self.push_event_widget(listeners, state, child_id, event, dirty_nodes, user_data)?;
 		}
 
 		Ok(())
 	}
 
-	fn push_event_widget(
+	fn push_event_widget<U1, U2>(
 		&self,
+		listeners: &EventListenerCollection<U1, U2>,
 		state: &mut PushEventState,
 		node_id: taffy::NodeId,
 		event: &event::Event,
 		dirty_nodes: &mut Vec<taffy::NodeId>,
+		user_data: &mut (&mut U1, &mut U2),
 	) -> anyhow::Result<()> {
 		let l = self.tree.layout(node_id)?;
 		let Some(widget_id) = self.tree.get_node_context(node_id).cloned() else {
@@ -134,38 +138,42 @@ impl Layout {
 
 		let mut iter_children = true;
 
-		match widget.process_event(
+		if let Some(listeners) = listeners.get(widget_id) {
-			widget_id,
+			match widget.process_event(
-			node_id,
+				widget_id,
-			event,
+				listeners,
-			&mut EventParams {
-				transform_stack: state.transform_stack,
-				widgets: &self.widget_map,
-				tree: &self.tree,
-				animations: state.animations,
-				needs_redraw: &mut state.needs_redraw,
-				trigger_haptics: &mut state.trigger_haptics,
 				node_id,
-				style,
+				event,
-				taffy_layout: l,
+				user_data,
-				dirty_nodes,
+				&mut EventParams {
-			},
+					transform_stack: state.transform_stack,
-		) {
+					widgets: &self.widget_map,
-			widget::EventResult::Pass => {
+					tree: &self.tree,
-				// go on
+					animations: state.animations,
-			}
+					needs_redraw: &mut state.needs_redraw,
-			widget::EventResult::Consumed => {
+					trigger_haptics: &mut state.trigger_haptics,
-				iter_children = false;
+					node_id,
-			}
+					style,
-			widget::EventResult::Outside => {
+					taffy_layout: l,
-				iter_children = false;
+					dirty_nodes,
+				},
+			) {
+				widget::EventResult::Pass => {
+					// go on
+				}
+				widget::EventResult::Consumed => {
+					iter_children = false;
+				}
+				widget::EventResult::Outside => {
+					iter_children = false;
+				}
 			}
 		}
 
 		drop(widget); // free mutex
 
 		if iter_children {
-			self.push_event_children(node_id, state, event, dirty_nodes)?;
+			self.push_event_children(listeners, node_id, state, event, dirty_nodes, user_data)?;
 		}
 
 		state.transform_stack.pop();
@@ -191,7 +199,12 @@ impl Layout {
 		}
 	}
 
-	pub fn push_event(&mut self, event: &event::Event) -> anyhow::Result<()> {
+	pub fn push_event<U1, U2>(
+		&mut self,
+		listeners: &EventListenerCollection<U1, U2>,
+		event: &event::Event,
+		mut user_data: (&mut U1, &mut U2),
+	) -> anyhow::Result<()> {
 		let mut transform_stack = TransformStack::new();
 		let mut animations_to_add = Vec::<animation::Animation>::new();
 		let mut dirty_nodes = Vec::new();
@@ -203,7 +216,14 @@ impl Layout {
 			trigger_haptics: false,
 		};
 
-		self.push_event_widget(&mut state, self.root_node, event, &mut dirty_nodes)?;
+		self.push_event_widget(
+			listeners,
+			&mut state,
+			self.root_node,
+			event,
+			&mut dirty_nodes,
+			&mut user_data,
+		)?;
 
 		for node in dirty_nodes {
 			self.tree.mark_dirty(node)?;
@@ -339,13 +359,4 @@ impl Layout {
 
 		Ok(())
 	}
-
+}
-	// helper function
-	pub fn add_event_listener(&self, widget_id: WidgetID, listener: EventListener) {
-		let Some(widget) = self.widget_map.get(widget_id) else {
-			debug_assert!(false);
-			return;
-		};
-		widget.lock().unwrap().add_event_listener(listener);
-	}
-}

wgui/src/widget/mod.rs

@@ -5,7 +5,9 @@ use crate::{
 	animation,
 	any::AnyTrait,
 	drawing,
-	event::{CallbackData, Event, EventListener, MouseWheelEvent},
+	event::{
+		CallbackData, CallbackMetadata, Event, EventListener, EventListenerKind, MouseWheelEvent,
+	},
 	layout::{Layout, WidgetID, WidgetMap},
 	transform_stack::TransformStack,
 };
@@ -70,7 +72,6 @@ impl WidgetData {
 pub struct WidgetState {
 	pub data: WidgetData,
 	pub obj: Box<dyn WidgetObj>,
-	pub event_listeners: Vec<EventListener>,
 }
 
 impl WidgetState {
@@ -88,7 +89,6 @@ impl WidgetState {
 				scrolling: Vec2::default(),
 				transform: glam::Mat4::IDENTITY,
 			},
-			event_listeners: Vec::new(),
 			obj,
 		})
 	}
@@ -182,9 +182,9 @@ impl dyn WidgetObj {
 }
 
 macro_rules! call_event {
-	($self:ident, $widget_id:ident, $node_id:ident, $params:ident, $ev:ident, $cb_arg:expr) => {
+	($self:ident, $listeners:ident, $widget_id:ident, $node_id:ident, $params:ident, $kind:ident, $user_data:expr, $metadata:expr) => {
-		for listener in &$self.event_listeners {
+		for listener in $listeners {
-			if let EventListener::$ev(callback) = listener {
+			if let Some(callback) = listener.callback_for_kind(EventListenerKind::$kind) {
 				let mut data = CallbackData {
 					obj: $self.obj.as_mut(),
 					widget_data: &mut $self.data,
@@ -195,8 +195,9 @@ macro_rules! call_event {
 					$node_id,
 					needs_redraw: false,
 					trigger_haptics: false,
+					metadata: $metadata,
 				};
-				callback(&mut data, $cb_arg);
+				callback(&mut data, $user_data.0, $user_data.1);
 				if data.trigger_haptics {
 					*$params.trigger_haptics = true;
 				}
@@ -209,10 +210,6 @@ macro_rules! call_event {
 }
 
 impl WidgetState {
-	pub fn add_event_listener(&mut self, listener: EventListener) {
-		self.event_listeners.push(listener);
-	}
-
 	pub fn get_scroll_shift(&self, info: &ScrollbarInfo, l: &taffy::Layout) -> Vec2 {
 		Vec2::new(
 			(info.content_size.x - l.content_box_width()) * self.data.scrolling.x,
@@ -322,11 +319,13 @@ impl WidgetState {
 		true
 	}
 
-	pub fn process_event(
+	pub fn process_event<U1, U2>(
 		&mut self,
 		widget_id: WidgetID,
+		listeners: &[EventListener<U1, U2>],
 		node_id: taffy::NodeId,
 		event: &Event,
+		user_data: &mut (&mut U1, &mut U2),
 		params: &mut EventParams,
 	) -> EventResult {
 		let hovered = event.test_mouse_within_transform(params.transform_stack.get());
@@ -334,12 +333,30 @@ impl WidgetState {
 		match &event {
 			Event::MouseDown(e) => {
 				if hovered && self.data.set_device_pressed(e.device, true) {
-					call_event!(self, widget_id, node_id, params, MousePress, e.button);
+					call_event!(
+						self,
+						listeners,
+						widget_id,
+						node_id,
+						params,
+						MousePress,
+						user_data,
+						CallbackMetadata::MouseButton(e.button)
+					);
 				}
 			}
 			Event::MouseUp(e) => {
 				if self.data.set_device_pressed(e.device, false) {
-					call_event!(self, widget_id, node_id, params, MouseRelease, e.button);
+					call_event!(
+						self,
+						listeners,
+						widget_id,
+						node_id,
+						params,
+						MouseRelease,
+						user_data,
+						CallbackMetadata::MouseButton(e.button)
+					);
 				}
 			}
 			Event::MouseWheel(e) => {
@@ -350,28 +367,57 @@ impl WidgetState {
 			Event::MouseMotion(e) => {
 				if self.data.set_device_hovered(e.device, hovered) {
 					if self.data.is_hovered() {
-						call_event!(self, widget_id, node_id, params, MouseEnter, ());
+						call_event!(
+							self,
+							listeners,
+							widget_id,
+							node_id,
+							params,
+							MouseEnter,
+							user_data,
+							CallbackMetadata::None
+						);
 					} else {
-						call_event!(self, widget_id, node_id, params, MouseLeave, ());
+						call_event!(
+							self,
+							listeners,
+							widget_id,
+							node_id,
+							params,
+							MouseLeave,
+							user_data,
+							CallbackMetadata::None
+						);
 					}
 				}
 			}
 			Event::MouseLeave(e) => {
 				if self.data.set_device_hovered(e.device, false) {
-					call_event!(self, widget_id, node_id, params, MouseLeave, ());
+					call_event!(
+						self,
+						listeners,
+						widget_id,
+						node_id,
+						params,
+						MouseLeave,
+						user_data,
+						CallbackMetadata::None
+					);
 				}
 			}
 			Event::InternalStateChange(e) => {
 				call_event!(
 					self,
+					listeners,
 					widget_id,
 					node_id,
 					params,
 					InternalStateChange,
-					e.metadata
+					user_data,
+					CallbackMetadata::Custom(e.metadata)
 				);
 			}
 		}
 		EventResult::Pass
 	}
-}
+}

wgui/src/widget/text.rs

@@ -50,6 +50,10 @@ impl TextLabel {
 	}
 
 	pub fn set_text(&mut self, text: &str) {
+		if self.params.content.as_str() == text {
+			return;
+		}
+
 		self.params.content = String::from(text);
 		let attrs = Attrs::from(&self.params.style);
 		let mut font_system = FONT_SYSTEM.lock().unwrap(); // safe unwrap
@@ -63,6 +67,10 @@ impl TextLabel {
 			self.params.style.align.map(|a| a.into()),
 		);
 	}
+
+	pub fn get_text(&self) -> &str {
+		&self.params.content
+	}
 }
 
 impl WidgetObj for TextLabel {

wlx-overlay-s/src/assets/gui/watch.xml

@@ -1,6 +1,4 @@
 <layout>
-  <include src="wlx_theme.xml" />
-
   <theme>
     <var key="border" value="2" />
     <var key="kbd_color" value="#a6da95" />
@@ -33,7 +31,7 @@
         </div>
         <div flex_direction="row">
           <div id="clock_main" flex_direction="column" padding="4">
-            <label text="23:59" id="clock0" color="~clock0_color" size="~clock0_size" weight="bold" />
+            <label text="23:59" id="clock0_time" color="~clock0_color" size="~clock0_size" weight="bold" />
             <label text="22/2/2022" id="clock0_date" color="~clock0_color" size="~clock0_date_size" weight="bold" />
             <div width="100%" padding="2" />
             <label text="Friday" id="clock0_dow" color="~clock0_color" size="~clock0_dow_size" weight="bold" />

wlx-overlay-s/src/config.rs

@@ -8,10 +8,10 @@ use crate::state::LeftRight;
 use chrono::Offset;
 use config::Config;
 use config::File;
-use glam::vec3a;
 use glam::Affine3A;
 use glam::Quat;
 use glam::Vec3A;
+use glam::vec3a;
 use idmap::IdMap;
 use log::error;
 use serde::Deserialize;
@@ -312,6 +312,9 @@ pub struct GeneralConfig {
 
     #[serde(default = "def_timezones")]
     pub timezones: Vec<String>,
+
+    #[serde(default = "def_false")]
+    pub clock_12h: bool,
 }
 
 impl GeneralConfig {

wlx-overlay-s/src/gui/mod.rs

@@ -1,3 +1,4 @@
 pub mod asset;
 pub mod panel;
+pub mod timer;
 mod timestep;

wlx-overlay-s/src/gui/panel.rs

@@ -4,8 +4,8 @@ use glam::{Vec2, vec2};
 use vulkano::{command_buffer::CommandBufferUsage, image::view::ImageView};
 use wgui::{
     event::{
-        Event as WguiEvent, MouseButton, MouseDownEvent, MouseLeaveEvent, MouseMotionEvent,
+        Event as WguiEvent, EventListenerCollection, InternalStateChangeEvent, MouseButton,
-        MouseUpEvent, MouseWheelEvent,
+        MouseDownEvent, MouseLeaveEvent, MouseMotionEvent, MouseUpEvent, MouseWheelEvent,
     },
     layout::Layout,
     parser::ParserResult,
@@ -22,21 +22,25 @@ use crate::{
     state::AppState,
 };
 
-use super::{asset::GuiAsset, timestep::Timestep};
+use super::{asset::GuiAsset, timer::GuiTimer, timestep::Timestep};
 
 const MAX_SIZE: u32 = 2048;
 const MAX_SIZE_VEC2: Vec2 = vec2(MAX_SIZE as _, MAX_SIZE as _);
 
-pub struct GuiPanel {
+pub struct GuiPanel<S> {
     pub layout: Layout,
+    pub state: S,
+    pub timers: Vec<GuiTimer>,
+    pub listeners: EventListenerCollection<AppState, S>,
     context: WguiContext,
     timestep: Timestep,
 }
 
-impl GuiPanel {
+impl<S> GuiPanel<S> {
     pub fn new_from_template(
         app: &mut AppState,
         path: &str,
+        state: S,
     ) -> anyhow::Result<(Self, ParserResult)> {
         let (layout, parser_result) =
             wgui::parser::new_layout_from_assets(Box::new(gui::asset::GuiAsset {}), path)?;
@@ -50,12 +54,15 @@ impl GuiPanel {
                 layout,
                 context,
                 timestep,
+                state,
+                timers: vec![],
+                listeners: EventListenerCollection::default(),
             },
             parser_result,
         ))
     }
 
-    pub fn new_blank(app: &mut AppState) -> anyhow::Result<Self> {
+    pub fn new_blank(app: &mut AppState, state: S) -> anyhow::Result<Self> {
         let layout = Layout::new(Box::new(GuiAsset {}))?;
         let context = WguiContext::new(&mut app.wgui_shared, 1.0)?;
         let mut timestep = Timestep::new();
@@ -65,15 +72,27 @@ impl GuiPanel {
             layout,
             context,
             timestep,
+            state,
+            timers: vec![],
+            listeners: EventListenerCollection::default(),
         })
     }
 
     pub fn update_layout(&mut self) -> anyhow::Result<()> {
         self.layout.update(MAX_SIZE_VEC2, 0.0)
     }
+
+    pub fn push_event(&mut self, app: &mut AppState, event: &WguiEvent) {
+        if let Err(e) = self
+            .layout
+            .push_event(&self.listeners, event, (app, &mut self.state))
+        {
+            log::error!("Failed to push event: {e:?}");
+        }
+    }
 }
 
-impl OverlayBackend for GuiPanel {
+impl<S> OverlayBackend for GuiPanel<S> {
     fn set_renderer(&mut self, _: Box<dyn OverlayRenderer>) {
         log::debug!("Attempted to replace renderer on GuiPanel!");
     }
@@ -82,24 +101,29 @@ impl OverlayBackend for GuiPanel {
     }
 }
 
-impl InteractionHandler for GuiPanel {
+impl<S> InteractionHandler for GuiPanel<S> {
-    fn on_scroll(&mut self, _app: &mut AppState, hit: &PointerHit, delta_y: f32, delta_x: f32) {
+    fn on_scroll(&mut self, app: &mut AppState, hit: &PointerHit, delta_y: f32, delta_x: f32) {
         self.layout
-            .push_event(&WguiEvent::MouseWheel(MouseWheelEvent {
+            .push_event(
-                shift: vec2(delta_x, delta_y),
+                &self.listeners,
-                pos: hit.uv * self.layout.content_size,
+                &WguiEvent::MouseWheel(MouseWheelEvent {
-                device: hit.pointer,
+                    shift: vec2(delta_x, delta_y),
-            }))
+                    pos: hit.uv * self.layout.content_size,
+                    device: hit.pointer,
+                }),
+                (app, &mut self.state),
+            )
             .unwrap(); // want panic
     }
 
-    fn on_hover(&mut self, _app: &mut AppState, hit: &PointerHit) -> Option<Haptics> {
+    fn on_hover(&mut self, app: &mut AppState, hit: &PointerHit) -> Option<Haptics> {
-        self.layout
+        self.push_event(
-            .push_event(&WguiEvent::MouseMotion(MouseMotionEvent {
+            app,
+            &WguiEvent::MouseMotion(MouseMotionEvent {
                 pos: hit.uv * self.layout.content_size,
                 device: hit.pointer,
-            }))
+            }),
-            .unwrap(); // want panic
+        );
 
         self.layout
             .check_toggle_haptics_triggered()
@@ -110,13 +134,14 @@ impl InteractionHandler for GuiPanel {
             })
     }
 
-    fn on_left(&mut self, _app: &mut AppState, pointer: usize) {
+    fn on_left(&mut self, app: &mut AppState, pointer: usize) {
-        self.layout
+        self.push_event(
-            .push_event(&WguiEvent::MouseLeave(MouseLeaveEvent { device: pointer }))
+            app,
-            .unwrap(); // want panic
+            &WguiEvent::MouseLeave(MouseLeaveEvent { device: pointer }),
+        );
     }
 
-    fn on_pointer(&mut self, _app: &mut AppState, hit: &PointerHit, pressed: bool) {
+    fn on_pointer(&mut self, app: &mut AppState, hit: &PointerHit, pressed: bool) {
         let button = match hit.mode {
             PointerMode::Left => MouseButton::Left,
             PointerMode::Right => MouseButton::Right,
@@ -125,26 +150,28 @@ impl InteractionHandler for GuiPanel {
         };
 
         if pressed {
-            self.layout
+            self.push_event(
-                .push_event(&WguiEvent::MouseDown(MouseDownEvent {
+                app,
+                &WguiEvent::MouseDown(MouseDownEvent {
                     pos: hit.uv * self.layout.content_size,
                     button,
                     device: hit.pointer,
-                }))
+                }),
-                .unwrap(); // want panic
+            );
         } else {
-            self.layout
+            self.push_event(
-                .push_event(&WguiEvent::MouseUp(MouseUpEvent {
+                app,
+                &WguiEvent::MouseUp(MouseUpEvent {
                     pos: hit.uv * self.layout.content_size,
                     button,
                     device: hit.pointer,
-                }))
+                }),
-                .unwrap(); // want panic
+            );
         }
     }
 }
 
-impl OverlayRenderer for GuiPanel {
+impl<S> OverlayRenderer for GuiPanel<S> {
     fn init(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
         if self.layout.content_size.x * self.layout.content_size.y == 0.0 {
             self.update_layout()?;
@@ -161,7 +188,15 @@ impl OverlayRenderer for GuiPanel {
         Ok(())
     }
 
-    fn should_render(&mut self, _app: &mut AppState) -> anyhow::Result<ShouldRender> {
+    fn should_render(&mut self, app: &mut AppState) -> anyhow::Result<ShouldRender> {
+        //TODO: this only executes one timer event per frame
+        if let Some(signal) = self.timers.iter_mut().find_map(GuiTimer::check_tick) {
+            self.push_event(
+                app,
+                &WguiEvent::InternalStateChange(InternalStateChangeEvent { metadata: signal }),
+            );
+        }
+
         while self.timestep.on_tick() {
             self.layout.tick()?;
         }

wlx-overlay-s/src/gui/timer.rs

@@ -0,0 +1,26 @@
+use std::time::{Duration, Instant};
+
+pub struct GuiTimer {
+    interval: Duration,
+    next_tick: Instant,
+    signal: usize,
+}
+
+impl GuiTimer {
+    pub fn new(interval: Duration, signal: usize) -> Self {
+        Self {
+            interval,
+            next_tick: Instant::now() + interval,
+            signal,
+        }
+    }
+
+    pub fn check_tick(&mut self) -> Option<usize> {
+        if self.next_tick > Instant::now() {
+            return None;
+        }
+
+        self.next_tick = Instant::now() + self.interval;
+        Some(self.signal)
+    }
+}

wlx-overlay-s/src/overlays/anchor.rs

@@ -11,7 +11,7 @@ pub fn create_anchor<O>(app: &mut AppState) -> anyhow::Result<OverlayData<O>>
 where
     O: Default,
 {
-    let (panel, _) = GuiPanel::new_from_template(app, "gui/anchor.xml")?;
+    let (panel, _) = GuiPanel::new_from_template(app, "gui/anchor.xml", ())?;
 
     Ok(OverlayData {
         state: OverlayState {

wlx-overlay-s/src/overlays/custom.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use glam::{Vec3A, vec2};
+use glam::Vec3A;
 
 use crate::{
     backend::overlay::{OverlayBackend, OverlayState},
@@ -18,7 +18,7 @@ pub fn create_custom(
 
     unreachable!();
 
-    let panel = GuiPanel::new_blank(app).ok()?;
+    let panel = GuiPanel::new_blank(app, ()).ok()?;
     panel.update_layout().ok()?;
 
     let state = OverlayState {

wlx-overlay-s/src/overlays/keyboard/builder.rs

@@ -1,10 +1,10 @@
-use std::{cell::RefCell, collections::HashMap, rc::Rc};
+use std::{collections::HashMap, rc::Rc};
 
 use glam::{Affine2, Mat4, Vec2, Vec3, vec2, vec3a};
 use wgui::{
     animation::{Animation, AnimationEasing},
     drawing::Color,
-    event::{self, EventListener},
+    event::{self, CallbackMetadata, EventListenerKind},
     renderer_vk::util,
     taffy::{self, prelude::length},
     widget::{
@@ -22,7 +22,8 @@ use crate::{
 };
 
 use super::{
-    KEYBOARD_NAME, KeyButtonData, KeyState, KeyboardBackend, KeyboardState,
+    KEYBOARD_NAME, KeyButtonData, KeyState, KeyboardBackend, KeyboardState, handle_press,
+    handle_release,
     layout::{self, AltModifier, KeyCapType},
 };
 
@@ -38,8 +39,7 @@ where
     O: Default,
 {
     let layout = layout::Layout::load_from_disk();
-    let state = Rc::new(RefCell::new(KeyboardState {
+    let state = KeyboardState {
-        invoke_action: None,
         modifiers: 0,
         alt_modifier: match layout.alt_modifier {
             AltModifier::Shift => SHIFT,
@@ -50,9 +50,9 @@ where
             _ => 0,
         },
         processes: vec![],
-    }));
+    };
 
-    let mut panel = GuiPanel::new_blank(app)?;
+    let mut panel = GuiPanel::new_blank(app, state)?;
 
     let (background, _) = panel.layout.add_child(
         panel.layout.root_widget,
@@ -179,70 +179,70 @@ where
                     })
                 };
 
-                panel.layout.add_event_listener(
+                panel.listeners.add(
                     *widget_id,
-                    EventListener::MouseEnter(Box::new({
+                    EventListenerKind::MouseEnter,
-                        let (k, kb) = (key_state.clone(), state.clone());
+                    Box::new({
-                        move |data, ()| {
+                        let k = key_state.clone();
+                        move |data, _app, _state| {
                             data.trigger_haptics = true;
-                            on_enter_anim(k.clone(), kb.clone(), data);
+                            on_enter_anim(k.clone(), data);
                         }
-                    })),
+                    }),
                 );
-                panel.layout.add_event_listener(
+                panel.listeners.add(
                     *widget_id,
-                    EventListener::MouseLeave(Box::new({
+                    EventListenerKind::MouseLeave,
-                        let (k, kb) = (key_state.clone(), state.clone());
+                    Box::new({
-                        move |data, ()| {
+                        let k = key_state.clone();
+                        move |data, _app, _state| {
                             data.trigger_haptics = true;
-                            on_leave_anim(k.clone(), kb.clone(), data);
+                            on_leave_anim(k.clone(), data);
                         }
-                    })),
+                    }),
                 );
-                panel.layout.add_event_listener(
+                panel.listeners.add(
                     *widget_id,
-                    EventListener::MousePress(Box::new({
+                    EventListenerKind::MousePress,
-                        let (k, kb) = (key_state.clone(), state.clone());
+                    Box::new({
-                        move |data, button| {
+                        let k = key_state.clone();
-                            kb.borrow_mut().invoke_action = Some(super::InvokeAction {
+                        move |data, app, state| {
-                                key: k.clone(),
+                            let CallbackMetadata::MouseButton(button) = data.metadata else {
-                                button,
+                                panic!("CallbackMetadata should contain MouseButton!");
-                                pressed: true,
+                            };
-                            });
+
+                            handle_press(app, &k, state, button);
                             on_press_anim(k.clone(), data);
                         }
-                    })),
+                    }),
                 );
-                panel.layout.add_event_listener(
+                panel.listeners.add(
                     *widget_id,
-                    EventListener::MouseRelease(Box::new({
+                    EventListenerKind::MouseRelease,
-                        let (k, kb) = (key_state.clone(), state.clone());
+                    Box::new({
-                        move |data, button| {
+                        let k = key_state.clone();
-                            kb.borrow_mut().invoke_action = Some(super::InvokeAction {
+                        move |data, app, state| {
-                                key: k.clone(),
+                            if handle_release(app, &k, state) {
-                                button,
-                                pressed: false,
-                            });
-                            if !matches!(&k.button_state, KeyButtonData::Modifier { sticky, .. } if sticky.get()) {
                                 on_release_anim(k.clone(), data);
                             }
                         }
-                    })),
+                    }),
                 );
 
                 if let Some(modifier) = my_modifier {
-                    panel.layout.add_event_listener(
+                    panel.listeners.add(
                         *widget_id,
-                        EventListener::InternalStateChange(Box::new({
+                        EventListenerKind::InternalStateChange,
-                            let (k, kb) = (key_state.clone(), state.clone());
+                        Box::new({
-                            move |data, _| {
+                            let k = key_state.clone();
-                                if (kb.borrow().modifiers & modifier) != 0 {
+                            move |data, _app, state| {
+                                if (state.modifiers & modifier) != 0 {
                                     on_press_anim(k.clone(), data);
                                 } else {
                                     on_release_anim(k.clone(), data);
                                 }
                             }
-                        })),
+                        }),
                     );
                 }
             } else {
@@ -273,7 +273,7 @@ where
             interaction_transform,
             ..Default::default()
         },
-        backend: Box::new(KeyboardBackend { panel, state }),
+        backend: Box::new(KeyboardBackend { panel }),
         ..Default::default()
     })
 }
@@ -300,11 +300,7 @@ fn set_anim_color(key_state: &KeyState, rect: &mut Rectangle, pos: f32) {
     rect.params.color2.b = key_state.color2.b + br2;
 }
 
-fn on_enter_anim(
+fn on_enter_anim(key_state: Rc<KeyState>, data: &mut event::CallbackData) {
-    key_state: Rc<KeyState>,
-    _keyboard_state: Rc<RefCell<KeyboardState>>,
-    data: &mut event::CallbackData,
-) {
     data.animations.push(Animation::new(
         data.widget_id,
         10,
@@ -318,11 +314,7 @@ fn on_enter_anim(
     ));
 }
 
-fn on_leave_anim(
+fn on_leave_anim(key_state: Rc<KeyState>, data: &mut event::CallbackData) {
-    key_state: Rc<KeyState>,
-    _keyboard_state: Rc<RefCell<KeyboardState>>,
-    data: &mut event::CallbackData,
-) {
     data.animations.push(Animation::new(
         data.widget_id,
         15,

wlx-overlay-s/src/overlays/keyboard/mod.rs

@@ -1,7 +1,6 @@
 use std::{
-    cell::{Cell, RefCell},
+    cell::Cell,
     process::{Child, Command},
-    rc::Rc,
     sync::Arc,
 };
 
@@ -29,23 +28,7 @@ pub const KEYBOARD_NAME: &str = "kbd";
 const AUTO_RELEASE_MODS: [KeyModifier; 5] = [SHIFT, CTRL, ALT, SUPER, META];
 
 struct KeyboardBackend {
-    panel: GuiPanel,
+    panel: GuiPanel<KeyboardState>,
-    state: Rc<RefCell<KeyboardState>>,
-}
-
-impl KeyboardBackend {
-    fn handle_invoke(&mut self, app: &mut AppState) {
-        let mut keyboard = self.state.borrow_mut();
-        let Some(action) = keyboard.invoke_action.take() else {
-            return;
-        };
-
-        if action.pressed {
-            handle_press(app, &action.key, &mut keyboard, action.button);
-        } else {
-            handle_release(app, &action.key, &mut keyboard);
-        }
-    }
 }
 
 impl OverlayBackend for KeyboardBackend {
@@ -60,13 +43,10 @@ impl OverlayBackend for KeyboardBackend {
 impl InteractionHandler for KeyboardBackend {
     fn on_pointer(&mut self, app: &mut AppState, hit: &PointerHit, pressed: bool) {
         self.panel.on_pointer(app, hit, pressed);
-        self.handle_invoke(app);
+        self.panel.push_event(
-        let _ = self
+            app,
-            .panel
+            &wgui::event::Event::InternalStateChange(InternalStateChangeEvent { metadata: 0 }),
-            .layout
+        );
-            .push_event(&wgui::event::Event::InternalStateChange(
-                InternalStateChangeEvent { metadata: 0 },
-            ));
     }
     fn on_scroll(&mut self, app: &mut AppState, hit: &PointerHit, delta_y: f32, delta_x: f32) {
         self.panel.on_scroll(app, hit, delta_y, delta_x);
@@ -99,29 +79,21 @@ impl OverlayRenderer for KeyboardBackend {
         self.panel.frame_meta()
     }
     fn pause(&mut self, app: &mut AppState) -> anyhow::Result<()> {
-        self.state.borrow_mut().modifiers = 0;
+        self.panel.state.modifiers = 0;
         app.hid_provider.set_modifiers_routed(0);
         self.panel.pause(app)
     }
     fn resume(&mut self, app: &mut AppState) -> anyhow::Result<()> {
         self.panel.resume(app)?;
-        self.panel
+        self.panel.push_event(
-            .layout
+            app,
-            .push_event(&wgui::event::Event::InternalStateChange(
+            &wgui::event::Event::InternalStateChange(InternalStateChangeEvent { metadata: 0 }),
-                InternalStateChangeEvent { metadata: 0 },
+        );
-            ))?;
         Ok(())
     }
 }
 
-struct InvokeAction {
-    key: Rc<KeyState>,
-    button: MouseButton,
-    pressed: bool,
-}
-
 struct KeyboardState {
-    invoke_action: Option<InvokeAction>,
     modifiers: KeyModifier,
     alt_modifier: KeyModifier,
     processes: Vec<Child>,
@@ -207,7 +179,7 @@ fn handle_press(
     }
 }
 
-fn handle_release(app: &mut AppState, key: &KeyState, keyboard: &mut KeyboardState) {
+fn handle_release(app: &mut AppState, key: &KeyState, keyboard: &mut KeyboardState) -> bool {
     match &key.button_state {
         KeyButtonData::Key { vk, pressed } => {
             pressed.set(false);
@@ -219,11 +191,15 @@ fn handle_release(app: &mut AppState, key: &KeyState, keyboard: &mut KeyboardSta
             }
             app.hid_provider.send_key_routed(*vk, false);
             app.hid_provider.set_modifiers_routed(keyboard.modifiers);
+            true
         }
         KeyButtonData::Modifier { modifier, sticky } => {
-            if !sticky.get() {
+            if sticky.get() {
+                false
+            } else {
                 keyboard.modifiers &= !*modifier;
                 app.hid_provider.set_modifiers_routed(keyboard.modifiers);
+                true
             }
         }
         KeyButtonData::Exec {
@@ -241,7 +217,8 @@ fn handle_release(app: &mut AppState, key: &KeyState, keyboard: &mut KeyboardSta
                     keyboard.processes.push(child);
                 }
             }
+            true
         }
-        _ => {}
+        _ => true,
     }
 }

wlx-overlay-s/src/overlays/toast.rs

@@ -166,7 +166,7 @@ fn new_toast(toast: Toast, app: &mut AppState) -> Option<(OverlayState, Box<dyn
         toast.title
     };
 
-    let mut panel = GuiPanel::new_blank(app).ok()?;
+    let mut panel = GuiPanel::new_blank(app, ()).ok()?;
 
     let (rect, _) = panel
         .layout

wlx-overlay-s/src/overlays/watch.rs

@@ -1,55 +1,102 @@
+use std::{rc::Rc, time::Duration};
+
+use chrono::Local;
+use chrono_tz::Tz;
 use glam::Vec3A;
+use regex::Regex;
 use wgui::{
-    parser::parse_color_hex,
+    event::{self, EventListenerKind},
-    taffy::{self, prelude::length},
+    widget::text::TextLabel,
-    widget::{
-        rectangle::{Rectangle, RectangleParams},
-        util::WLength,
-    },
 };
 
 use crate::{
     backend::overlay::{OverlayData, OverlayState, Positioning, Z_ORDER_WATCH, ui_transform},
-    gui::panel::GuiPanel,
+    gui::{panel::GuiPanel, timer::GuiTimer},
     state::AppState,
 };
 
 pub const WATCH_NAME: &str = "watch";
 
+struct WatchState {}
+
+#[allow(clippy::significant_drop_tightening)]
 pub fn create_watch<O>(app: &mut AppState) -> anyhow::Result<OverlayData<O>>
 where
     O: Default,
 {
-    let (mut panel, parser) = GuiPanel::new_from_template(app, "gui/watch.xml")?;
+    let state = WatchState {};
+    let (mut panel, parser) = GuiPanel::new_from_template(app, "gui/watch.xml", state)?;
 
-    for (id, widget) in parser.ids.iter() {
+    panel
-        if id.starts_with("clock") {}
+        .timers
+        .push(GuiTimer::new(Duration::from_millis(100), 0));
+
+    let clock_regex = Regex::new(r"^clock([0-9])_([a-z]+)$").unwrap();
+
+    for (id, widget_id) in parser.ids {
+        if let Some(cap) = clock_regex.captures(&id) {
+            let tz_idx: usize = cap.get(1).unwrap().as_str().parse().unwrap(); // safe due to regex
+            let tz_str = (tz_idx > 0)
+                .then(|| app.session.config.timezones.get(tz_idx - 1))
+                .flatten();
+            let role = cap.get(2).unwrap().as_str();
+
+            let mut widget = panel
+                .layout
+                .widget_map
+                .get_mut(widget_id)
+                .unwrap() // want panic
+                .lock()
+                .unwrap(); // want panic
+
+            let label = widget.obj.get_as_mut::<TextLabel>();
+
+            let format = match role {
+                "tz" => {
+                    if let Some(s) =
+                        tz_str.and_then(|tz| tz.split('/').next_back().map(|x| x.replace('_', " ")))
+                    {
+                        label.set_text(&s);
+                    } else {
+                        label.set_text("Local");
+                    }
+
+                    continue;
+                }
+                "date" => "%x",
+                "dow" => "%A",
+                "time" => {
+                    if app.session.config.clock_12h {
+                        "%I:%M %p"
+                    } else {
+                        "%H:%M"
+                    }
+                }
+                _ => {
+                    label.set_text("ERR");
+                    continue;
+                }
+            };
+
+            let clock = ClockState {
+                timezone: tz_str.and_then(|tz| {
+                    tz.parse()
+                        .inspect_err(|e| log::warn!("Invalid timezone: {e:?}"))
+                        .ok()
+                }),
+                format: format.into(),
+            };
+
+            panel.listeners.add(
+                widget_id,
+                EventListenerKind::InternalStateChange,
+                Box::new(move |data, _, _| {
+                    clock_on_tick(&clock, data);
+                }),
+            );
+        }
     }
 
-    if let Ok(clock) = parser.require_by_id("clock0") {}
-
-    let (_, _) = panel.layout.add_child(
-        panel.layout.root_widget,
-        Rectangle::create(RectangleParams {
-            color: wgui::drawing::Color::new(0., 0., 0., 0.5),
-            border_color: parse_color_hex("#00ffff").unwrap(),
-            border: 2.0,
-            round: WLength::Units(4.0),
-            ..Default::default()
-        })
-        .unwrap(),
-        taffy::Style {
-            size: taffy::Size {
-                width: length(100.),
-                height: length(50.),
-            },
-            align_items: Some(taffy::AlignItems::Center),
-            justify_content: Some(taffy::JustifyContent::Center),
-            padding: length(4.0),
-            ..Default::default()
-        },
-    )?;
-
     let positioning = Positioning::FollowHand {
         hand: app.session.config.watch_hand as _,
         lerp: 1.0,
@@ -103,3 +150,18 @@ where
         watch.state.alpha = watch.state.alpha.clamp(0., 1.);
     }
 }
+
+struct ClockState {
+    timezone: Option<Tz>,
+    format: Rc<str>,
+}
+
+fn clock_on_tick(clock: &ClockState, data: &mut event::CallbackData) {
+    let date_time = clock.timezone.as_ref().map_or_else(
+        || format!("{}", Local::now().format(&clock.format)),
+        |tz| format!("{}", Local::now().with_timezone(tz).format(&clock.format)),
+    );
+
+    let label = data.obj.get_as_mut::<TextLabel>();
+    label.set_text(&date_time);
+}