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

refactor events; watch prep work

Browse Source
This commit is contained in:
galister
2025-06-27 04:16:24 +09:00
parent 1215a50324
commit afb4919970
21 changed files with 613 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
uidev/src/main.rs
View File

@@ -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()?),
"" => Box::new(TestbedGeneric::new(listeners)?),
_ => 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 {
shift: Vec2::new(x, y),
pos: mouse / scale,
device: 0,
}))
.push_event(
&listeners,
&wgui::event::Event::MouseWheel(MouseWheelEvent {
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 {
shift: Vec2::new(pos.x as f32 / 5.0, pos.y as f32 / 5.0),
pos: mouse / scale,
device: 0,
}))
.push_event(
&listeners,
&wgui::event::Event::MouseWheel(MouseWheelEvent {
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 {
pos: mouse / scale,
button: MouseButton::Left,
device: 0,
}))
.push_event(
&listeners,
&wgui::event::Event::MouseDown(MouseDownEvent {
pos: mouse / scale,
button: MouseButton::Left,
device: 0,
}),
(&mut (), &mut ()),
)
.unwrap();
} else {
testbed
.layout()
.push_event(&wgui::event::Event::MouseUp(MouseUpEvent {
pos: mouse / scale,
button: MouseButton::Left,
device: 0,
}))
.push_event(
&listeners,
&wgui::event::Event::MouseUp(MouseUpEvent {
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 {
pos: mouse / scale,
device: 0,
}))
.push_event(
&listeners,
&wgui::event::Event::MouseMotion(MouseMotionEvent {
pos: mouse / scale,
device: 0,
}),
(&mut (), &mut ()),
)
.unwrap();
}
Event::WindowEvent {

5
uidev/src/testbed/mod.rs
View File

@@ -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 layout(&mut self) -> &mut Layout;
fn update(&mut self, width: f32, height: f32, timestep_alpha: f32) -> anyhow::Result<()>;
fn layout(&mut self) -> &mut Layout;
}

30
uidev/src/testbed/testbed_any.rs
View File

@@ -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> {
let path = format!("gui/{name}.xml");
let (layout, _state) = wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), &path)?;
Ok(Self { layout })
}
pub fn new(name: &str) -> anyhow::Result<Self> {
let path = format!("gui/{name}.xml");
let (layout, _state) =
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<()> {
self
.layout
.update(Vec2::new(width, height), timestep_alpha)?;
Ok(())
}
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
}
fn layout(&mut self) -> &mut Layout {
&mut self.layout
}
}

29
uidev/src/testbed/testbed_dashboard.rs
View File

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

148
uidev/src/testbed/testbed_generic.rs
View File

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

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

@@ -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
{
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));
})));
}
//TODO: Highlight background on mouse enter
// 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));
})));
}
//TODO: Bring back old color on mouse leave
Ok(button)
}
}

80
wgui/src/event.rs
View File

@@ -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 type MouseLeaveCallback = Box<dyn Fn(&mut CallbackData, ())>;
pub type MousePressCallback = Box<dyn Fn(&mut CallbackData, MouseButton)>;
pub type MouseReleaseCallback = Box<dyn Fn(&mut CallbackData, MouseButton)>;
pub type InternalStateChangeCallback = Box<dyn Fn(&mut CallbackData, usize)>;
pub enum EventListener {
MouseEnter(MouseEnterCallback),
MouseLeave(MouseLeaveCallback),
MousePress(MousePressCallback),
MouseRelease(MouseReleaseCallback),
InternalStateChange(InternalStateChangeCallback),
pub enum CallbackMetadata {
None,
MouseButton(MouseButton),
Custom(usize),
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum EventListenerKind {
MousePress,
MouseRelease,
MouseEnter,
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())
}
}

93
wgui/src/layout.rs
View File

@@ -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(
widget_id,
node_id,
event,
&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,
if let Some(listeners) = listeners.get(widget_id) {
match widget.process_event(
widget_id,
listeners,
node_id,
style,
taffy_layout: l,
dirty_nodes,
},
) {
widget::EventResult::Pass => {
// go on
}
widget::EventResult::Consumed => {
iter_children = false;
}
widget::EventResult::Outside => {
iter_children = false;
event,
user_data,
&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,
taffy_layout: l,
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);
}
}
}

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

@@ -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) => {
for listener in &$self.event_listeners {
if let EventListener::$ev(callback) = listener {
($self:ident, $listeners:ident, $widget_id:ident, $node_id:ident, $params:ident, $kind:ident, $user_data:expr, $metadata:expr) => {
for listener in $listeners {
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
}
}
}

8
wgui/src/widget/text.rs
View File

@@ -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 {

4
wlx-overlay-s/src/assets/gui/watch.xml
View File

@@ -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" />

5
wlx-overlay-s/src/config.rs
View File

@@ -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 {

1
wlx-overlay-s/src/gui/mod.rs
View File

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

103
wlx-overlay-s/src/gui/panel.rs
View File

@@ -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,
MouseUpEvent, MouseWheelEvent,
Event as WguiEvent, EventListenerCollection, InternalStateChangeEvent, MouseButton,
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 {
fn on_scroll(&mut self, _app: &mut AppState, hit: &PointerHit, delta_y: f32, delta_x: f32) {
impl<S> InteractionHandler for GuiPanel<S> {
fn on_scroll(&mut self, app: &mut AppState, hit: &PointerHit, delta_y: f32, delta_x: f32) {
self.layout
.push_event(&WguiEvent::MouseWheel(MouseWheelEvent {
shift: vec2(delta_x, delta_y),
pos: hit.uv * self.layout.content_size,
device: hit.pointer,
}))
.push_event(
&self.listeners,
&WguiEvent::MouseWheel(MouseWheelEvent {
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> {
self.layout
.push_event(&WguiEvent::MouseMotion(MouseMotionEvent {
fn on_hover(&mut self, app: &mut AppState, hit: &PointerHit) -> Option<Haptics> {
self.push_event(
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) {
self.layout
.push_event(&WguiEvent::MouseLeave(MouseLeaveEvent { device: pointer }))
.unwrap(); // want panic
fn on_left(&mut self, app: &mut AppState, pointer: usize) {
self.push_event(
app,
&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
.push_event(&WguiEvent::MouseDown(MouseDownEvent {
self.push_event(
app,
&WguiEvent::MouseDown(MouseDownEvent {
pos: hit.uv * self.layout.content_size,
button,
device: hit.pointer,
}))
.unwrap(); // want panic
}),
);
} else {
self.layout
.push_event(&WguiEvent::MouseUp(MouseUpEvent {
self.push_event(
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()?;
}

26
wlx-overlay-s/src/gui/timer.rs Normal file
View File

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

2
wlx-overlay-s/src/overlays/anchor.rs
View File

@@ -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 {

4
wlx-overlay-s/src/overlays/custom.rs
View File

@@ -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 {

106
wlx-overlay-s/src/overlays/keyboard/builder.rs
View File

@@ -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 {
invoke_action: None,
let state = KeyboardState {
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({
let (k, kb) = (key_state.clone(), state.clone());
move |data, ()| {
EventListenerKind::MouseEnter,
Box::new({
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({
let (k, kb) = (key_state.clone(), state.clone());
move |data, ()| {
EventListenerKind::MouseLeave,
Box::new({
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({
let (k, kb) = (key_state.clone(), state.clone());
move |data, button| {
kb.borrow_mut().invoke_action = Some(super::InvokeAction {
key: k.clone(),
button,
pressed: true,
});
EventListenerKind::MousePress,
Box::new({
let k = key_state.clone();
move |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);
}
})),
}),
);
panel.layout.add_event_listener(
panel.listeners.add(
*widget_id,
EventListener::MouseRelease(Box::new({
let (k, kb) = (key_state.clone(), state.clone());
move |data, button| {
kb.borrow_mut().invoke_action = Some(super::InvokeAction {
key: k.clone(),
button,
pressed: false,
});
if !matches!(&k.button_state, KeyButtonData::Modifier { sticky, .. } if sticky.get()) {
EventListenerKind::MouseRelease,
Box::new({
let k = key_state.clone();
move |data, app, state| {
if handle_release(app, &k, state) {
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({
let (k, kb) = (key_state.clone(), state.clone());
move |data, _| {
if (kb.borrow().modifiers & modifier) != 0 {
EventListenerKind::InternalStateChange,
Box::new({
let k = key_state.clone();
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(
key_state: Rc<KeyState>,
_keyboard_state: Rc<RefCell<KeyboardState>>,
data: &mut event::CallbackData,
) {
fn on_enter_anim(key_state: Rc<KeyState>, 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(
key_state: Rc<KeyState>,
_keyboard_state: Rc<RefCell<KeyboardState>>,
data: &mut event::CallbackData,
) {
fn on_leave_anim(key_state: Rc<KeyState>, data: &mut event::CallbackData) {
data.animations.push(Animation::new(
data.widget_id,
15,

61
wlx-overlay-s/src/overlays/keyboard/mod.rs
View File

@@ -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,
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);
}
}
panel: GuiPanel<KeyboardState>,
}
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);
let _ = self
.panel
.layout
.push_event(&wgui::event::Event::InternalStateChange(
InternalStateChangeEvent { metadata: 0 },
));
self.panel.push_event(
app,
&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
.layout
.push_event(&wgui::event::Event::InternalStateChange(
InternalStateChangeEvent { metadata: 0 },
))?;
self.panel.push_event(
app,
&wgui::event::Event::InternalStateChange(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,
}
}

2
wlx-overlay-s/src/overlays/toast.rs
View File

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

130
wlx-overlay-s/src/overlays/watch.rs
View File

@@ -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,
taffy::{self, prelude::length},
widget::{
rectangle::{Rectangle, RectangleParams},
util::WLength,
},
event::{self, EventListenerKind},
widget::text::TextLabel,
};
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() {
if id.starts_with("clock") {}
panel
.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);
}