Jayden/wayvr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

separate CallbackData and CallbackDataCommon, refactoring

Browse Source
This commit is contained in:
Aleksander
2025-07-02 22:06:19 +02:00
parent 40f50a147b
commit 283d7fd64e
7 changed files with 233 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
wgui/src/animation.rs
View File

@@ -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;
}

39
wgui/src/components/button.rs
View File

@@ -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)
where
C: WidgetCallback<'a>,
{
pub fn set_text<'a, 'b, C>(&self, callback_data: &mut CallbackDataCommon, text: &str) {
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)
}

176
wgui/src/components/slider.rs
View File

@@ -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
pub slider_handle_id: WidgetID, // Inner rectangle
pub slider_handle_node: taffy::NodeId,
body: WidgetID, // Div
slider_handle_id: WidgetID, // Div
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)
where
C: WidgetCallback<'a>,
{
callback_data.mark_redraw();
callback_data.mark_dirty(self.slider_handle_node);
callback_data.call_on_widget(self.slider_handle_id, |_rect: &mut Rectangle| {
// todo
});
callback_data.mark_redraw();
callback_data.mark_dirty(self.slider_handle_node);
fn get_state(&self) -> RefMut<'_, SliderState> {
self.state.borrow_mut()
}
pub fn set_value(&self, state: &mut SliderState, common: &mut CallbackDataCommon, value: f32) {
state.value = value;
common.mark_dirty(self.slider_handle_node);
common.call_on_widget(self.slider_handle_id, |div: &mut Div| {});
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();
listeners.add(
body_id,
EventListenerKind::MouseEnter,
Box::new(move |data, _, _| {
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);
}),
);
register_event_mouse_enter(slider.clone(), listeners);
register_event_mouse_leave(slider.clone(), listeners);
register_event_mouse_motion(slider.clone(), listeners);
register_event_mouse_press(slider.clone(), listeners);
register_event_mouse_leave(slider.clone(), listeners);
register_event_mouse_release(slider.clone(), listeners);
Ok(slider)
}

55
wgui/src/event.rs
View File

@@ -74,13 +74,21 @@ impl Event {
}
}
pub trait WidgetCallback<'a> {
fn call_on_widget<WIDGET, FUNC>(&self, widget_id: WidgetID, func: FUNC)
pub struct CallbackDataCommon<'a> {
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;
fn mark_redraw(&mut self);
fn mark_dirty(&mut self, node_id: taffy::NodeId);
pub fn mark_redraw(&mut self) {
self.needs_redraw = true;
}
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 {

22
wgui/src/widget/mod.rs
View File

@@ -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;
}
}