separate CallbackData and CallbackDataCommon, refactoring

wgui/src/animation.rs

@@ -1,7 +1,7 @@
 use glam::{FloatExt, Vec2};
 
 use crate::{
-	event::WidgetCallback,
+	event::CallbackDataCommon,
 	layout::{WidgetID, WidgetMap, WidgetNodeMap},
 	widget::{WidgetData, WidgetObj},
 };
@@ -37,28 +37,12 @@ impl AnimationEasing {
 pub struct CallbackData<'a> {
 	pub obj: &'a mut dyn WidgetObj,
 	pub data: &'a mut WidgetData,
-	pub widgets: &'a WidgetMap,
 	pub widget_id: WidgetID,
 	pub widget_size: Vec2,
 	pub pos: f32, // 0.0 (start of animation) - 1.0 (end of animation)
-	pub needs_redraw: bool,
-	pub dirty_nodes: &'a mut Vec<taffy::NodeId>,
-}
-
-impl<'a> WidgetCallback<'a> for CallbackData<'a> {
-	fn get_widgets(&self) -> &'a WidgetMap {
-		self.widgets
-	}
-
-	fn mark_redraw(&mut self) {
-		self.needs_redraw = true;
-	}
-
-	fn mark_dirty(&mut self, node_id: taffy::NodeId) {
-		self.dirty_nodes.push(node_id);
-	}
 }
 
+pub type AnimationCallback = Box<dyn Fn(&mut CallbackDataCommon, &mut CallbackData)>;
 pub struct Animation {
 	target_widget: WidgetID,
 
@@ -72,7 +56,7 @@ pub struct Animation {
 	pos_prev: f32,
 	last_tick: bool,
 
-	callback: Box<dyn Fn(&mut CallbackData)>,
+	callback: AnimationCallback,
 }
 
 #[derive(Default)]
@@ -85,7 +69,7 @@ impl Animation {
 		target_widget: WidgetID,
 		ticks: u32,
 		easing: AnimationEasing,
-		callback: Box<dyn Fn(&mut CallbackData)>,
+		callback: AnimationCallback,
 	) -> Self {
 		Animation::new_ex(target_widget, 0, ticks, easing, callback)
 	}
@@ -95,7 +79,7 @@ impl Animation {
 		animation_id: u32,
 		ticks: u32,
 		easing: AnimationEasing,
-		callback: Box<dyn Fn(&mut CallbackData)>,
+		callback: AnimationCallback,
 	) -> Self {
 		Self {
 			target_widget,
@@ -133,18 +117,23 @@ impl Animation {
 
 		let data = &mut CallbackData {
 			widget_id: self.target_widget,
-			dirty_nodes,
-			widgets: widget_map,
 			widget_size: Vec2::new(layout.size.width, layout.size.height),
 			obj,
 			data,
 			pos,
-			needs_redraw: false,
 		};
 
-		(self.callback)(data);
+		let common = &mut CallbackDataCommon {
+			dirty_nodes,
+			needs_redraw: false,
+			trigger_haptics: false,
+			widgets: widget_map,
+			taffy_layout: layout,
+		};
 
-		if data.needs_redraw {
+		(self.callback)(common, data);
+
+		if common.needs_redraw {
 			res.needs_redraw = true;
 		}
 

wgui/src/components/button.rs

@@ -1,11 +1,11 @@
-use std::sync::Arc;
+use std::rc::Rc;
 use taffy::{AlignItems, JustifyContent, prelude::length};
 
 use crate::{
 	animation::{Animation, AnimationEasing},
 	components::Component,
 	drawing::{self, Color},
-	event::{EventListenerCollection, EventListenerKind, WidgetCallback},
+	event::{CallbackDataCommon, EventListenerCollection, EventListenerKind},
 	layout::{Layout, WidgetID},
 	renderer_vk::text::{FontWeight, TextStyle},
 	widget::{
@@ -48,10 +48,7 @@ pub struct Button {
 impl Component for Button {}
 
 impl Button {
-	pub fn set_text<'a, C>(&self, callback_data: &mut C, text: &str)
+	pub fn set_text<'a, 'b, C>(&self, callback_data: &mut CallbackDataCommon, text: &str) {
-	where
-		C: WidgetCallback<'a>,
-	{
 		callback_data.call_on_widget(self.text_id, |label: &mut TextLabel| {
 			label.set_text(text);
 		});
@@ -72,28 +69,28 @@ fn anim_hover(rect: &mut Rectangle, button: &Button, pos: f32) {
 	rect.params.border = 3.0;
 }
 
-fn anim_hover_in(button: Arc<Button>, widget_id: WidgetID) -> Animation {
+fn anim_hover_in(button: Rc<Button>, widget_id: WidgetID) -> Animation {
 	Animation::new(
 		widget_id,
 		10,
 		AnimationEasing::OutQuad,
-		Box::new(move |data| {
+		Box::new(move |common, data| {
 			let rect = data.obj.get_as_mut::<Rectangle>();
 			anim_hover(rect, &button, data.pos);
-			data.needs_redraw = true;
+			common.mark_redraw();
 		}),
 	)
 }
 
-fn anim_hover_out(button: Arc<Button>, widget_id: WidgetID) -> Animation {
+fn anim_hover_out(button: Rc<Button>, widget_id: WidgetID) -> Animation {
 	Animation::new(
 		widget_id,
 		15,
 		AnimationEasing::OutQuad,
-		Box::new(move |data| {
+		Box::new(move |common, data| {
 			let rect = data.obj.get_as_mut::<Rectangle>();
 			anim_hover(rect, &button, 1.0 - data.pos);
-			data.needs_redraw = true;
+			common.mark_redraw();
 		}),
 	)
 }
@@ -103,7 +100,7 @@ pub fn construct<U1, U2>(
 	listeners: &mut EventListenerCollection<U1, U2>,
 	parent: WidgetID,
 	params: Params,
-) -> anyhow::Result<Arc<Button>> {
+) -> anyhow::Result<Rc<Button>> {
 	let mut style = params.style;
 
 	// force-override style
@@ -147,7 +144,7 @@ pub fn construct<U1, U2>(
 		},
 	)?;
 
-	let button = Arc::new(Button {
+	let _button = Rc::new(Button {
 		body: rect_id,
 		text_id,
 		text_node,
@@ -157,27 +154,27 @@ pub fn construct<U1, U2>(
 
 	//let mut widget = layout.widget_map.get(rect_id).unwrap().lock().unwrap();
 
-	let _button = button.clone();
+	let button = _button.clone();
 	listeners.add(
 		rect_id,
 		EventListenerKind::MouseEnter,
-		Box::new(move |data, _, _| {
+		Box::new(move |common, data, _, _| {
 			data
 				.animations
-				.push(anim_hover_in(_button.clone(), data.widget_id));
+				.push(anim_hover_in(button.clone(), data.widget_id));
 		}),
 	);
 
-	let _button = button.clone();
+	let button = _button.clone();
 	listeners.add(
 		rect_id,
 		EventListenerKind::MouseLeave,
-		Box::new(move |data, _, _| {
+		Box::new(move |common, data, _, _| {
 			data
 				.animations
-				.push(anim_hover_out(_button.clone(), data.widget_id));
+				.push(anim_hover_out(button.clone(), data.widget_id));
 		}),
 	);
 
-	Ok(button)
+	Ok(_button)
 }

wgui/src/components/slider.rs

@@ -1,4 +1,7 @@
-use std::sync::Arc;
+use std::{
+	cell::{RefCell, RefMut},
+	rc::Rc,
+};
 
 use glam::{Mat4, Vec2, Vec3};
 use taffy::prelude::{length, percent};
@@ -7,7 +10,7 @@ use crate::{
 	animation::{Animation, AnimationEasing},
 	components::Component,
 	drawing::{self},
-	event::{self, EventListenerCollection, EventListenerKind, WidgetCallback},
+	event::{self, CallbackDataCommon, EventListenerCollection, EventListenerKind},
 	layout::{Layout, WidgetID},
 	renderer_vk::util,
 	widget::{
@@ -35,26 +38,37 @@ impl Default for Params {
 	}
 }
 
+pub struct SliderState {
+	dragging: bool,
+	hovered: bool,
+	value: f32,
+	min_value: f32,
+	max_value: f32,
+}
+
 pub struct Slider {
-	pub body: WidgetID,             // Outer rectangle
+	body: WidgetID,                  // Div
-	pub slider_handle_id: WidgetID, // Inner rectangle
+	slider_handle_id: WidgetID,      // Div
-	pub slider_handle_node: taffy::NodeId,
+	slider_handle_rect_id: WidgetID, // Rectangle
+	slider_handle_node: taffy::NodeId,
+	state: Rc<RefCell<SliderState>>,
 }
 
 impl Component for Slider {}
 
 impl Slider {
-	pub fn set_value<'a, C>(&self, callback_data: &mut C, _value: f32)
+	fn get_state(&self) -> RefMut<'_, SliderState> {
-	where
+		self.state.borrow_mut()
-		C: WidgetCallback<'a>,
+	}
-	{
+
-		callback_data.mark_redraw();
+	pub fn set_value(&self, state: &mut SliderState, common: &mut CallbackDataCommon, value: f32) {
-		callback_data.mark_dirty(self.slider_handle_node);
+		state.value = value;
-		callback_data.call_on_widget(self.slider_handle_id, |_rect: &mut Rectangle| {
+
-			// todo
+		common.mark_dirty(self.slider_handle_node);
-		});
+
-		callback_data.mark_redraw();
+		common.call_on_widget(self.slider_handle_id, |div: &mut Div| {});
-		callback_data.mark_dirty(self.slider_handle_node);
+		common.mark_redraw();
+		common.mark_dirty(self.slider_handle_node);
 	}
 }
 
@@ -84,11 +98,11 @@ fn on_enter_anim(data: &mut event::CallbackData, handle_id: WidgetID) {
 		handle_id,
 		5,
 		AnimationEasing::OutQuad,
-		Box::new(move |data| {
+		Box::new(move |common, data| {
 			let rect = data.obj.get_as_mut::<Rectangle>();
 			data.data.transform = get_anim_transform(data.pos, data.widget_size);
 			anim_rect(rect, data.pos);
-			data.needs_redraw = true;
+			common.mark_redraw();
 		}),
 	));
 }
@@ -98,23 +112,102 @@ fn on_leave_anim(data: &mut event::CallbackData, handle_id: WidgetID) {
 		handle_id,
 		10,
 		AnimationEasing::OutQuad,
-		Box::new(move |data| {
+		Box::new(move |common, data| {
 			let rect = data.obj.get_as_mut::<Rectangle>();
 			data.data.transform = get_anim_transform(1.0 - data.pos, data.widget_size);
 			anim_rect(rect, 1.0 - data.pos);
-			data.needs_redraw = true;
+			common.mark_redraw();
 		}),
 	));
 }
 
 const PAD_PERCENT: f32 = 0.75;
 
+fn register_event_mouse_enter<U1, U2>(
+	slider: Rc<Slider>,
+	listeners: &mut EventListenerCollection<U1, U2>,
+) {
+	listeners.add(
+		slider.body,
+		EventListenerKind::MouseEnter,
+		Box::new(move |common, data, _, _| {
+			common.trigger_haptics();
+			slider.get_state().hovered = true;
+			on_enter_anim(data, slider.slider_handle_rect_id);
+		}),
+	);
+}
+
+fn register_event_mouse_leave<U1, U2>(
+	slider: Rc<Slider>,
+	listeners: &mut EventListenerCollection<U1, U2>,
+) {
+	listeners.add(
+		slider.body,
+		EventListenerKind::MouseLeave,
+		Box::new(move |common, data, _, _| {
+			common.trigger_haptics();
+			slider.get_state().hovered = false;
+			on_leave_anim(data, slider.slider_handle_rect_id);
+		}),
+	);
+}
+
+fn register_event_mouse_motion<U1, U2>(
+	slider: Rc<Slider>,
+	listeners: &mut EventListenerCollection<U1, U2>,
+) {
+	listeners.add(
+		slider.body,
+		EventListenerKind::MouseMotion,
+		Box::new(move |_common, _data, _, _| {}),
+	);
+}
+
+fn register_event_mouse_press<U1, U2>(
+	slider: Rc<Slider>,
+	listeners: &mut EventListenerCollection<U1, U2>,
+) {
+	listeners.add(
+		slider.body,
+		EventListenerKind::MousePress,
+		Box::new(move |common, _data, _, _| {
+			common.trigger_haptics();
+
+			let mut state = slider.get_state();
+			if state.hovered {
+				state.dragging = true;
+				let val = state.min_value;
+				slider.set_value(&mut state, common, val);
+			}
+		}),
+	);
+}
+
+fn register_event_mouse_release<U1, U2>(
+	slider: Rc<Slider>,
+	listeners: &mut EventListenerCollection<U1, U2>,
+) {
+	listeners.add(
+		slider.body,
+		EventListenerKind::MouseRelease,
+		Box::new(move |common, _data, _, _| {
+			common.trigger_haptics();
+
+			let mut state = slider.get_state();
+			if state.dragging {
+				state.dragging = false;
+			}
+		}),
+	);
+}
+
 pub fn construct<U1, U2>(
 	layout: &mut Layout,
 	listeners: &mut EventListenerCollection<U1, U2>,
 	parent: WidgetID,
 	params: Params,
-) -> anyhow::Result<Arc<Slider>> {
+) -> anyhow::Result<Rc<Slider>> {
 	let mut style = params.style;
 	style.position = taffy::Position::Relative;
 	style.min_size = style.size;
@@ -172,37 +265,26 @@ pub fn construct<U1, U2>(
 		},
 	)?;
 
-	let slider = Arc::new(Slider {
+	let slider = Rc::new(Slider {
 		body: body_id,
 		slider_handle_node,
+		slider_handle_rect_id,
 		slider_handle_id,
+		state: Rc::new(RefCell::new(SliderState {
+			dragging: false,
+			hovered: false,
+			max_value: params.max_value,
+			value: params.initial_value,
+			min_value: params.min_value,
+		})),
 	});
 
-	//let mut widget = layout.widget_map.get(rect_id).unwrap().lock().unwrap();
+	register_event_mouse_enter(slider.clone(), listeners);
-
+	register_event_mouse_leave(slider.clone(), listeners);
-	listeners.add(
+	register_event_mouse_motion(slider.clone(), listeners);
-		body_id,
+	register_event_mouse_press(slider.clone(), listeners);
-		EventListenerKind::MouseEnter,
+	register_event_mouse_leave(slider.clone(), listeners);
-		Box::new(move |data, _, _| {
+	register_event_mouse_release(slider.clone(), listeners);
-			data.trigger_haptics = true;
-			on_enter_anim(data, slider_handle_rect_id);
-		}),
-	);
-
-	listeners.add(
-		body_id,
-		EventListenerKind::MouseMotion,
-		Box::new(move |_data, _, _| {}),
-	);
-
-	listeners.add(
-		body_id,
-		EventListenerKind::MouseLeave,
-		Box::new(move |data, _, _| {
-			data.trigger_haptics = true;
-			on_leave_anim(data, slider_handle_rect_id);
-		}),
-	);
 
 	Ok(slider)
 }

wgui/src/event.rs

@@ -74,13 +74,21 @@ impl Event {
 	}
 }
 
-pub trait WidgetCallback<'a> {
+pub struct CallbackDataCommon<'a> {
-	fn call_on_widget<WIDGET, FUNC>(&self, widget_id: WidgetID, func: FUNC)
+	pub widgets: &'a WidgetMap,
+	pub taffy_layout: &'a taffy::Layout,
+	pub dirty_nodes: &'a mut Vec<taffy::NodeId>,
+	pub needs_redraw: bool,
+	pub trigger_haptics: bool,
+}
+
+impl<'a> CallbackDataCommon<'a> {
+	pub fn call_on_widget<WIDGET, FUNC>(&self, widget_id: WidgetID, func: FUNC)
 	where
 		WIDGET: WidgetObj,
 		FUNC: FnOnce(&mut WIDGET),
 	{
-		let Some(widget) = self.get_widgets().get(widget_id) else {
+		let Some(widget) = self.widgets.get(widget_id) else {
 			debug_assert!(false);
 			return;
 		};
@@ -91,38 +99,32 @@ pub trait WidgetCallback<'a> {
 		func(m);
 	}
 
-	fn get_widgets(&self) -> &'a WidgetMap;
+	pub fn mark_redraw(&mut self) {
-	fn mark_redraw(&mut self);
+		self.needs_redraw = true;
-	fn mark_dirty(&mut self, node_id: taffy::NodeId);
+	}
+
+	pub fn mark_dirty(&mut self, node_id: taffy::NodeId) {
+		self.dirty_nodes.push(node_id);
+	}
+
+	pub fn trigger_haptics(&mut self) {
+		self.trigger_haptics = true;
+	}
+
+	pub fn get_taffy_layout(&self) -> &taffy::Layout {
+		self.taffy_layout
+	}
 }
 
 pub struct CallbackData<'a> {
 	pub obj: &'a mut dyn WidgetObj,
 	pub widget_data: &'a mut WidgetData,
 	pub animations: &'a mut Vec<animation::Animation>,
-	pub widgets: &'a WidgetMap,
 	pub widget_id: WidgetID,
 	pub node_id: taffy::NodeId,
-	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> {
-	fn get_widgets(&self) -> &'a WidgetMap {
-		self.widgets
-	}
-
-	fn mark_redraw(&mut self) {
-		self.needs_redraw = true;
-	}
-
-	fn mark_dirty(&mut self, node_id: taffy::NodeId) {
-		self.dirty_nodes.push(node_id);
-	}
-}
-
 pub enum CallbackMetadata {
 	None,
 	MouseButton(MouseButton),
@@ -139,7 +141,8 @@ pub enum EventListenerKind {
 	InternalStateChange,
 }
 
-pub type EventCallback<U1, U2> = Box<dyn Fn(&mut CallbackData, &mut U1, &mut U2)>;
+pub type EventCallback<U1, U2> =
+	Box<dyn Fn(&mut CallbackDataCommon, &mut CallbackData, &mut U1, &mut U2)>;
 
 pub struct EventListener<U1, U2> {
 	pub kind: EventListenerKind,
@@ -150,7 +153,7 @@ impl<U1, U2> EventListener<U1, U2> {
 	pub fn callback_for_kind(
 		&self,
 		kind: EventListenerKind,
-	) -> Option<&impl Fn(&mut CallbackData, &mut U1, &mut U2)> {
+	) -> Option<&impl Fn(&mut CallbackDataCommon, &mut CallbackData, &mut U1, &mut U2)> {
 		if self.kind == kind {
 			Some(&self.callback)
 		} else {

wgui/src/widget/mod.rs

@@ -6,7 +6,8 @@ use crate::{
 	any::AnyTrait,
 	drawing,
 	event::{
-		CallbackData, CallbackMetadata, Event, EventListener, EventListenerKind, MouseWheelEvent,
+		CallbackData, CallbackDataCommon, CallbackMetadata, Event, EventListener, EventListenerKind,
+		MouseWheelEvent,
 	},
 	layout::{Layout, WidgetID, WidgetMap},
 	transform_stack::TransformStack,
@@ -188,20 +189,25 @@ macro_rules! call_event {
 				let mut data = CallbackData {
 					obj: $self.obj.as_mut(),
 					widget_data: &mut $self.data,
-					widgets: $params.widgets,
 					animations: $params.animations,
-					dirty_nodes: $params.dirty_nodes,
 					$widget_id,
 					$node_id,
-					needs_redraw: false,
-					trigger_haptics: false,
 					metadata: $metadata,
 				};
-				callback(&mut data, $user_data.0, $user_data.1);
+
-				if data.trigger_haptics {
+				let mut common = CallbackDataCommon {
+					widgets: $params.widgets,
+					needs_redraw: false,
+					trigger_haptics: false,
+					dirty_nodes: $params.dirty_nodes,
+					taffy_layout: $params.taffy_layout,
+				};
+
+				callback(&mut common, &mut data, $user_data.0, $user_data.1);
+				if common.trigger_haptics {
 					*$params.trigger_haptics = true;
 				}
-				if data.needs_redraw {
+				if common.needs_redraw {
 					*$params.needs_redraw = true;
 				}
 			}

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

@@ -191,8 +191,8 @@ where
                     EventListenerKind::MouseEnter,
                     Box::new({
                         let k = key_state.clone();
-                        move |data, _app, _state| {
+                        move |common, data, _app, _state| {
-                            data.trigger_haptics = true;
+                            common.trigger_haptics();
                             on_enter_anim(k.clone(), data);
                         }
                     }),
@@ -202,8 +202,8 @@ where
                     EventListenerKind::MouseLeave,
                     Box::new({
                         let k = key_state.clone();
-                        move |data, _app, _state| {
+                        move |common, data, _app, _state| {
-                            data.trigger_haptics = true;
+                            common.trigger_haptics();
                             on_leave_anim(k.clone(), data);
                         }
                     }),
@@ -213,13 +213,13 @@ where
                     EventListenerKind::MousePress,
                     Box::new({
                         let k = key_state.clone();
-                        move |data, app, state| {
+                        move |common, data, app, state| {
                             let CallbackMetadata::MouseButton(button) = data.metadata else {
                                 panic!("CallbackMetadata should contain MouseButton!");
                             };
 
                             handle_press(app, &k, state, button);
-                            on_press_anim(k.clone(), data);
+                            on_press_anim(k.clone(), common, data);
                         }
                     }),
                 );
@@ -228,9 +228,9 @@ where
                     EventListenerKind::MouseRelease,
                     Box::new({
                         let k = key_state.clone();
-                        move |data, app, state| {
+                        move |common, data, app, state| {
                             if handle_release(app, &k, state) {
-                                on_release_anim(k.clone(), data);
+                                on_release_anim(k.clone(), common, data);
                             }
                         }
                     }),
@@ -242,11 +242,11 @@ where
                         EventListenerKind::InternalStateChange,
                         Box::new({
                             let k = key_state.clone();
-                            move |data, _app, state| {
+                            move |common, data, _app, state| {
                                 if (state.modifiers & modifier) != 0 {
-                                    on_press_anim(k.clone(), data);
+                                    on_press_anim(k.clone(), common, data);
                                 } else {
-                                    on_release_anim(k.clone(), data);
+                                    on_release_anim(k.clone(), common, data);
                                 }
                             }
                         }),
@@ -304,11 +304,11 @@ fn on_enter_anim(key_state: Rc<KeyState>, data: &mut event::CallbackData) {
         data.widget_id,
         10,
         AnimationEasing::OutBack,
-        Box::new(move |data| {
+        Box::new(move |common, data| {
             let rect = data.obj.get_as_mut::<Rectangle>();
             set_anim_color(&key_state, rect, data.pos);
             data.data.transform = get_anim_transform(data.pos, data.widget_size);
-            data.needs_redraw = true;
+            common.mark_redraw();
         }),
     ));
 }
@@ -318,31 +318,39 @@ fn on_leave_anim(key_state: Rc<KeyState>, data: &mut event::CallbackData) {
         data.widget_id,
         15,
         AnimationEasing::OutQuad,
-        Box::new(move |data| {
+        Box::new(move |common, data| {
             let rect = data.obj.get_as_mut::<Rectangle>();
             set_anim_color(&key_state, rect, 1.0 - data.pos);
             data.data.transform = get_anim_transform(1.0 - data.pos, data.widget_size);
-            data.needs_redraw = true;
+            common.mark_redraw();
         }),
     ));
 }
 
-fn on_press_anim(key_state: Rc<KeyState>, data: &mut event::CallbackData) {
+fn on_press_anim(
+    key_state: Rc<KeyState>,
+    common: &mut event::CallbackDataCommon,
+    data: &mut event::CallbackData,
+) {
     if key_state.drawn_state.get() {
         return;
     }
     let rect = data.obj.get_as_mut::<Rectangle>();
     rect.params.border_color = Color::new(1.0, 1.0, 1.0, 1.0);
-    data.needs_redraw = true;
+    common.mark_redraw();
     key_state.drawn_state.set(true);
 }
 
-fn on_release_anim(key_state: Rc<KeyState>, data: &mut event::CallbackData) {
+fn on_release_anim(
+    key_state: Rc<KeyState>,
+    common: &mut event::CallbackDataCommon,
+    data: &mut event::CallbackData,
+) {
     if !key_state.drawn_state.get() {
         return;
     }
     let rect = data.obj.get_as_mut::<Rectangle>();
     rect.params.border_color = key_state.border_color;
-    data.needs_redraw = true;
+    common.mark_redraw();
     key_state.drawn_state.set(false);
 }

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

@@ -90,7 +90,7 @@ where
             panel.listeners.add(
                 widget_id,
                 EventListenerKind::InternalStateChange,
-                Box::new(move |data, _, _| {
+                Box::new(move |_common, data, _, _| {
                     clock_on_tick(&clock, data);
                 }),
             );