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

uidev: re-format code

Browse Source
This commit is contained in:
Aleksander
2025-09-13 12:18:27 +02:00
parent 1d8f8aca3e
commit c2628c0a15
7 changed files with 440 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
uidev/.editorconfig Normal file
View File

@@ -0,0 +1,8 @@
root = true
[*.rs]
indent_style = tab
indent_size = 2
charset = utf-8
trim_trailing_whitespace = false
insert_final_newline = false

2
uidev/rustfmt.toml Normal file
View File

@@ -0,0 +1,2 @@
tab_spaces = 2
hard_tabs = true

585
uidev/src/main.rs
View File

@@ -8,28 +8,27 @@ use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt; use tracing_subscriber::util::SubscriberInitExt;
use vulkan::init_window; use vulkan::init_window;
use vulkano::{ use vulkano::{
Validated, VulkanError, Validated, VulkanError,
command_buffer::CommandBufferUsage, command_buffer::CommandBufferUsage,
format::Format, format::Format,
image::{ImageUsage, view::ImageView}, image::{ImageUsage, view::ImageView},
swapchain::{ swapchain::{
Surface, SurfaceInfo, Swapchain, SwapchainCreateInfo, SwapchainPresentInfo, Surface, SurfaceInfo, Swapchain, SwapchainCreateInfo, SwapchainPresentInfo, acquire_next_image,
acquire_next_image, },
}, sync::GpuFuture,
sync::GpuFuture,
}; };
use wgui::{ use wgui::{
event::{ event::{
EventListenerCollection, MouseButtonIndex, MouseDownEvent, MouseMotionEvent, MouseUpEvent, EventListenerCollection, MouseButtonIndex, MouseDownEvent, MouseMotionEvent, MouseUpEvent,
MouseWheelEvent, MouseWheelEvent,
}, },
gfx::WGfx, gfx::WGfx,
renderer_vk::{self}, renderer_vk::{self},
}; };
use winit::{ use winit::{
event::{ElementState, Event, MouseScrollDelta, WindowEvent}, event::{ElementState, Event, MouseScrollDelta, WindowEvent},
event_loop::ControlFlow, event_loop::ControlFlow,
keyboard::{KeyCode, PhysicalKey}, keyboard::{KeyCode, PhysicalKey},
}; };
use crate::testbed::{testbed_dashboard::TestbedDashboard, testbed_generic::TestbedGeneric}; use crate::testbed::{testbed_dashboard::TestbedDashboard, testbed_generic::TestbedGeneric};
@@ -41,332 +40,324 @@ mod timestep;
mod vulkan; mod vulkan;
fn init_logging() { fn init_logging() {
tracing_subscriber::registry() tracing_subscriber::registry()
.with( .with(
tracing_subscriber::fmt::layer() tracing_subscriber::fmt::layer()
.pretty() .pretty()
.with_writer(std::io::stderr), .with_writer(std::io::stderr),
) )
.with( .with(
/* read RUST_LOG env var */ /* read RUST_LOG env var */
EnvFilter::builder() EnvFilter::builder()
.with_default_directive(LevelFilter::DEBUG.into()) .with_default_directive(LevelFilter::DEBUG.into())
.from_env_lossy(), .from_env_lossy(),
) )
.init(); .init();
} }
fn load_testbed( fn load_testbed(
listeners: &mut EventListenerCollection<(), ()>, listeners: &mut EventListenerCollection<(), ()>,
) -> anyhow::Result<Box<dyn Testbed>> { ) -> anyhow::Result<Box<dyn Testbed>> {
let name = std::env::var("TESTBED").unwrap_or_default(); let name = std::env::var("TESTBED").unwrap_or_default();
Ok(match name.as_str() { Ok(match name.as_str() {
"dashboard" => Box::new(TestbedDashboard::new(listeners)?), "dashboard" => Box::new(TestbedDashboard::new(listeners)?),
"" => Box::new(TestbedGeneric::new(listeners)?), "" => Box::new(TestbedGeneric::new(listeners)?),
_ => Box::new(TestbedAny::new(&name, listeners)?), _ => Box::new(TestbedAny::new(&name, listeners)?),
}) })
} }
fn main() -> Result<(), Box<dyn std::error::Error>> { fn main() -> Result<(), Box<dyn std::error::Error>> {
init_logging(); init_logging();
let (gfx, event_loop, window, surface) = init_window()?; let (gfx, event_loop, window, surface) = init_window()?;
let inner_size = window.inner_size(); let inner_size = window.inner_size();
let mut swapchain_size = [inner_size.width, inner_size.height]; let mut swapchain_size = [inner_size.width, inner_size.height];
let mut swapchain_create_info = let mut swapchain_create_info =
swapchain_create_info(&gfx, gfx.surface_format, surface.clone(), swapchain_size); swapchain_create_info(&gfx, gfx.surface_format, surface.clone(), swapchain_size);
let (mut swapchain, mut images) = { let (mut swapchain, mut images) = {
let (swapchain, images) = Swapchain::new( let (swapchain, images) = Swapchain::new(
gfx.device.clone(), gfx.device.clone(),
surface.clone(), surface.clone(),
swapchain_create_info.clone(), swapchain_create_info.clone(),
)?; )?;
let image_views = images let image_views = images
.into_iter() .into_iter()
.map(|image| ImageView::new_default(image).unwrap()) .map(|image| ImageView::new_default(image).unwrap())
.collect::<Vec<_>>(); .collect::<Vec<_>>();
(swapchain, image_views) (swapchain, image_views)
}; };
let mut recreate = false; let mut recreate = false;
let mut scale = window.scale_factor() as f32; let mut scale = window.scale_factor() as f32;
let mut listeners = EventListenerCollection::default(); let mut listeners = EventListenerCollection::default();
let mut testbed = load_testbed(&mut listeners)?; let mut testbed = load_testbed(&mut listeners)?;
let mut mouse = Vec2::ZERO; let mut mouse = Vec2::ZERO;
let mut shared_context = renderer_vk::context::SharedContext::new(gfx.clone())?; let mut shared_context = renderer_vk::context::SharedContext::new(gfx.clone())?;
let mut render_context = renderer_vk::context::Context::new(&mut shared_context, scale)?; let mut render_context = renderer_vk::context::Context::new(&mut shared_context, scale)?;
render_context.update_viewport(&mut shared_context, swapchain_size, scale)?; render_context.update_viewport(&mut shared_context, swapchain_size, scale)?;
println!("new swapchain_size: {swapchain_size:?}"); println!("new swapchain_size: {swapchain_size:?}");
let mut profiler = profiler::Profiler::new(1000); let mut profiler = profiler::Profiler::new(1000);
let mut frame_index: u64 = 0; let mut frame_index: u64 = 0;
let mut timestep = Timestep::new(); let mut timestep = Timestep::new();
timestep.set_tps(60.0); timestep.set_tps(60.0);
#[allow(deprecated)] #[allow(deprecated)]
event_loop.run(move |event, elwt| { event_loop.run(move |event, elwt| {
elwt.set_control_flow(ControlFlow::Poll); elwt.set_control_flow(ControlFlow::Poll);
match event { match event {
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::MouseWheel { delta, .. }, event: WindowEvent::MouseWheel { delta, .. },
.. ..
} => match delta { } => match delta {
MouseScrollDelta::LineDelta(x, y) => testbed MouseScrollDelta::LineDelta(x, y) => testbed
.layout() .layout()
.push_event( .push_event(
&mut listeners, &mut listeners,
&wgui::event::Event::MouseWheel(MouseWheelEvent { &wgui::event::Event::MouseWheel(MouseWheelEvent {
shift: Vec2::new(x, y), shift: Vec2::new(x, y),
pos: mouse / scale, pos: mouse / scale,
device: 0, device: 0,
}), }),
(&mut (), &mut ()), (&mut (), &mut ()),
) )
.unwrap(), .unwrap(),
MouseScrollDelta::PixelDelta(pos) => testbed MouseScrollDelta::PixelDelta(pos) => testbed
.layout() .layout()
.push_event( .push_event(
&mut listeners, &mut listeners,
&wgui::event::Event::MouseWheel(MouseWheelEvent { &wgui::event::Event::MouseWheel(MouseWheelEvent {
shift: Vec2::new(pos.x as f32 / 5.0, pos.y as f32 / 5.0), shift: Vec2::new(pos.x as f32 / 5.0, pos.y as f32 / 5.0),
pos: mouse / scale, pos: mouse / scale,
device: 0, device: 0,
}), }),
(&mut (), &mut ()), (&mut (), &mut ()),
) )
.unwrap(), .unwrap(),
}, },
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::MouseInput { state, button, .. }, event: WindowEvent::MouseInput { state, button, .. },
.. ..
} => { } => {
if matches!(button, winit::event::MouseButton::Left) { if matches!(button, winit::event::MouseButton::Left) {
if matches!(state, winit::event::ElementState::Pressed) { if matches!(state, winit::event::ElementState::Pressed) {
testbed testbed
.layout() .layout()
.push_event( .push_event(
&mut listeners, &mut listeners,
&wgui::event::Event::MouseDown(MouseDownEvent { &wgui::event::Event::MouseDown(MouseDownEvent {
pos: mouse / scale, pos: mouse / scale,
index: MouseButtonIndex::Left, index: MouseButtonIndex::Left,
device: 0, device: 0,
}), }),
(&mut (), &mut ()), (&mut (), &mut ()),
) )
.unwrap(); .unwrap();
} else { } else {
testbed testbed
.layout() .layout()
.push_event( .push_event(
&mut listeners, &mut listeners,
&wgui::event::Event::MouseUp(MouseUpEvent { &wgui::event::Event::MouseUp(MouseUpEvent {
pos: mouse / scale, pos: mouse / scale,
index: MouseButtonIndex::Left, index: MouseButtonIndex::Left,
device: 0, device: 0,
}), }),
(&mut (), &mut ()), (&mut (), &mut ()),
) )
.unwrap(); .unwrap();
} }
} }
} }
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::CursorMoved { position, .. }, event: WindowEvent::CursorMoved { position, .. },
.. ..
} => { } => {
mouse = vec2(position.x as _, position.y as _); mouse = vec2(position.x as _, position.y as _);
testbed testbed
.layout() .layout()
.push_event( .push_event(
&mut listeners, &mut listeners,
&wgui::event::Event::MouseMotion(MouseMotionEvent { &wgui::event::Event::MouseMotion(MouseMotionEvent {
pos: mouse / scale, pos: mouse / scale,
device: 0, device: 0,
}), }),
(&mut (), &mut ()), (&mut (), &mut ()),
) )
.unwrap(); .unwrap();
} }
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::KeyboardInput { event, .. }, event: WindowEvent::KeyboardInput { event, .. },
.. ..
} => { } => {
if event.state == ElementState::Pressed { if event.state == ElementState::Pressed {
if event.physical_key == PhysicalKey::Code(KeyCode::Equal) { if event.physical_key == PhysicalKey::Code(KeyCode::Equal) {
scale *= 1.25; scale *= 1.25;
render_context render_context
.update_viewport(&mut shared_context, swapchain_size, scale) .update_viewport(&mut shared_context, swapchain_size, scale)
.unwrap(); .unwrap();
} }
if event.physical_key == PhysicalKey::Code(KeyCode::Minus) { if event.physical_key == PhysicalKey::Code(KeyCode::Minus) {
scale *= 0.75; scale *= 0.75;
render_context render_context
.update_viewport(&mut shared_context, swapchain_size, scale) .update_viewport(&mut shared_context, swapchain_size, scale)
.unwrap(); .unwrap();
} }
} }
} }
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::CloseRequested, event: WindowEvent::CloseRequested,
.. ..
} => { } => {
elwt.exit(); elwt.exit();
} }
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::Resized(_), event: WindowEvent::Resized(_),
.. ..
} => { } => {
recreate = true; recreate = true;
} }
Event::WindowEvent { Event::WindowEvent {
event: WindowEvent::RedrawRequested, event: WindowEvent::RedrawRequested,
.. ..
} => { } => {
if recreate { if recreate {
let inner_size = window.inner_size(); let inner_size = window.inner_size();
swapchain_size = [inner_size.width, inner_size.height]; swapchain_size = [inner_size.width, inner_size.height];
swapchain_create_info.image_extent = swapchain_size; swapchain_create_info.image_extent = swapchain_size;
(swapchain, images) = { (swapchain, images) = {
let (swapchain, images) = let (swapchain, images) = swapchain.recreate(swapchain_create_info.clone()).unwrap();
swapchain.recreate(swapchain_create_info.clone()).unwrap();
let image_views = images let image_views = images
.into_iter() .into_iter()
.map(|image| ImageView::new_default(image).unwrap()) .map(|image| ImageView::new_default(image).unwrap())
.collect::<Vec<_>>(); .collect::<Vec<_>>();
(swapchain, image_views) (swapchain, image_views)
}; };
render_context render_context
.update_viewport(&mut shared_context, swapchain_size, scale) .update_viewport(&mut shared_context, swapchain_size, scale)
.unwrap(); .unwrap();
println!("new swapchain_size: {swapchain_size:?}"); println!("new swapchain_size: {swapchain_size:?}");
recreate = false; recreate = false;
window.request_redraw(); window.request_redraw();
} }
while timestep.on_tick() { while timestep.on_tick() {
testbed.layout().tick().unwrap(); testbed.layout().tick().unwrap();
} }
testbed testbed
.update( .update(
(swapchain_size[0] as f32 / scale) as _, (swapchain_size[0] as f32 / scale) as _,
(swapchain_size[1] as f32 / scale) as _, (swapchain_size[1] as f32 / scale) as _,
timestep.alpha, timestep.alpha,
) )
.unwrap(); .unwrap();
if !render_context.dirty && !testbed.layout().check_toggle_needs_redraw() { if !render_context.dirty && !testbed.layout().check_toggle_needs_redraw() {
// no need to redraw // no need to redraw
std::thread::sleep(std::time::Duration::from_millis(5)); // dirty fix to prevent cpu burning precious cycles doing a busy loop std::thread::sleep(std::time::Duration::from_millis(5)); // dirty fix to prevent cpu burning precious cycles doing a busy loop
return; return;
} }
log::trace!("drawing frame {frame_index}"); log::trace!("drawing frame {frame_index}");
frame_index += 1; frame_index += 1;
profiler.start(); profiler.start();
{ {
let (image_index, _, acquire_future) = match acquire_next_image( let (image_index, _, acquire_future) =
swapchain.clone(), match acquire_next_image(swapchain.clone(), None).map_err(Validated::unwrap) {
None, Ok(r) => r,
) Err(VulkanError::OutOfDate) => {
.map_err(Validated::unwrap) recreate = true;
{ return;
Ok(r) => r, }
Err(VulkanError::OutOfDate) => { Err(e) => panic!("failed to acquire next image: {e}"),
recreate = true; };
return;
}
Err(e) => panic!("failed to acquire next image: {e}"),
};
let tgt = images[image_index as usize].clone(); let tgt = images[image_index as usize].clone();
let mut cmd_buf = gfx let mut cmd_buf = gfx
.create_gfx_command_buffer(CommandBufferUsage::OneTimeSubmit) .create_gfx_command_buffer(CommandBufferUsage::OneTimeSubmit)
.unwrap(); .unwrap();
cmd_buf.begin_rendering(tgt).unwrap(); cmd_buf.begin_rendering(tgt).unwrap();
let primitives = wgui::drawing::draw(testbed.layout()).unwrap(); let primitives = wgui::drawing::draw(testbed.layout()).unwrap();
render_context render_context
.draw(&mut shared_context, &mut cmd_buf, &primitives) .draw(&mut shared_context, &mut cmd_buf, &primitives)
.unwrap(); .unwrap();
cmd_buf.end_rendering().unwrap(); cmd_buf.end_rendering().unwrap();
let cmd_buf = cmd_buf.build().unwrap(); let cmd_buf = cmd_buf.build().unwrap();
acquire_future acquire_future
.then_execute(gfx.queue_gfx.clone(), cmd_buf) .then_execute(gfx.queue_gfx.clone(), cmd_buf)
.unwrap() .unwrap()
.then_swapchain_present( .then_swapchain_present(
gfx.queue_gfx.clone(), gfx.queue_gfx.clone(),
SwapchainPresentInfo::swapchain_image_index( SwapchainPresentInfo::swapchain_image_index(swapchain.clone(), image_index),
swapchain.clone(), )
image_index, .then_signal_fence_and_flush()
), .unwrap()
) .wait(None)
.then_signal_fence_and_flush() .unwrap();
.unwrap() }
.wait(None)
.unwrap();
}
profiler.end(); profiler.end();
} }
Event::AboutToWait => { Event::AboutToWait => {
// should be limited to vsync // should be limited to vsync
window.request_redraw(); window.request_redraw();
} }
_ => (), _ => (),
} }
})?; })?;
Ok(()) Ok(())
} }
fn swapchain_create_info( fn swapchain_create_info(
graphics: &WGfx, graphics: &WGfx,
format: Format, format: Format,
surface: Arc<Surface>, surface: Arc<Surface>,
extent: [u32; 2], extent: [u32; 2],
) -> SwapchainCreateInfo { ) -> SwapchainCreateInfo {
let surface_capabilities = graphics let surface_capabilities = graphics
.device .device
.physical_device() .physical_device()
.surface_capabilities(&surface, SurfaceInfo::default()) .surface_capabilities(&surface, SurfaceInfo::default())
.unwrap(); // want panic .unwrap(); // want panic
SwapchainCreateInfo { SwapchainCreateInfo {
min_image_count: surface_capabilities.min_image_count.max(2), min_image_count: surface_capabilities.min_image_count.max(2),
image_format: format, image_format: format,
image_extent: extent, image_extent: extent,
image_usage: ImageUsage::COLOR_ATTACHMENT, image_usage: ImageUsage::COLOR_ATTACHMENT,
composite_alpha: surface_capabilities composite_alpha: surface_capabilities
.supported_composite_alpha .supported_composite_alpha
.into_iter() .into_iter()
.next() .next()
.unwrap(), // want panic .unwrap(), // want panic
..Default::default() ..Default::default()
} }
} }

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

@@ -5,6 +5,6 @@ pub mod testbed_dashboard;
pub mod testbed_generic; pub mod testbed_generic;
pub trait Testbed { 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;
} }

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

@@ -1,48 +1,46 @@
use crate::{assets, testbed::Testbed}; use crate::{assets, testbed::Testbed};
use glam::Vec2; use glam::Vec2;
use wgui::{ use wgui::{
event::EventListenerCollection, event::EventListenerCollection,
globals::WguiGlobals, globals::WguiGlobals,
layout::Layout, layout::Layout,
parser::{ParseDocumentParams, ParserState}, parser::{ParseDocumentParams, ParserState},
}; };
pub struct TestbedAny { pub struct TestbedAny {
pub layout: Layout, pub layout: Layout,
#[allow(dead_code)] #[allow(dead_code)]
state: ParserState, state: ParserState,
} }
impl TestbedAny { impl TestbedAny {
pub fn new( pub fn new(name: &str, listeners: &mut EventListenerCollection<(), ()>) -> anyhow::Result<Self> {
name: &str, let path = format!("gui/{name}.xml");
listeners: &mut EventListenerCollection<(), ()>,
) -> anyhow::Result<Self> {
let path = format!("gui/{name}.xml");
let globals = WguiGlobals::new(Box::new(assets::Asset {}))?; let globals = WguiGlobals::new(Box::new(assets::Asset {}))?;
let (layout, state) = wgui::parser::new_layout_from_assets( let (layout, state) = wgui::parser::new_layout_from_assets(
listeners, listeners,
&ParseDocumentParams { &ParseDocumentParams {
globals, globals,
path: &path, path: &path,
extra: Default::default(), extra: Default::default(),
}, },
)?; )?;
Ok(Self { layout, state }) Ok(Self { layout, state })
} }
} }
impl Testbed for TestbedAny { 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.layout self
.update(Vec2::new(width, height), timestep_alpha)?; .layout
Ok(()) .update(Vec2::new(width, height), timestep_alpha)?;
} Ok(())
}
fn layout(&mut self) -> &mut Layout { fn layout(&mut self) -> &mut Layout {
&mut self.layout &mut self.layout
} }
} }

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

@@ -2,24 +2,24 @@ use crate::testbed::Testbed;
use wgui::{event::EventListenerCollection, layout::Layout}; use wgui::{event::EventListenerCollection, layout::Layout};
pub struct TestbedDashboard { pub struct TestbedDashboard {
frontend: dash_frontend::Frontend, frontend: dash_frontend::Frontend,
} }
impl TestbedDashboard { impl TestbedDashboard {
pub fn new(listeners: &mut EventListenerCollection<(), ()>) -> anyhow::Result<Self> { pub fn new(listeners: &mut EventListenerCollection<(), ()>) -> anyhow::Result<Self> {
Ok(Self { Ok(Self {
frontend: dash_frontend::Frontend::new(dash_frontend::FrontendParams { listeners })?, frontend: dash_frontend::Frontend::new(dash_frontend::FrontendParams { listeners })?,
}) })
} }
} }
impl Testbed for TestbedDashboard { impl Testbed for TestbedDashboard {
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.frontend.update(width, height, timestep_alpha)?; self.frontend.update(width, height, timestep_alpha)?;
Ok(()) Ok(())
} }
fn layout(&mut self) -> &mut Layout { fn layout(&mut self) -> &mut Layout {
self.frontend.get_layout() self.frontend.get_layout()
} }
} }

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

@@ -3,130 +3,131 @@ use std::rc::Rc;
use crate::{assets, testbed::Testbed}; use crate::{assets, testbed::Testbed};
use glam::Vec2; use glam::Vec2;
use wgui::{ use wgui::{
components::{ components::{
Component, Component,
button::{ButtonClickCallback, ComponentButton}, button::{ButtonClickCallback, ComponentButton},
checkbox::ComponentCheckbox, checkbox::ComponentCheckbox,
}, },
drawing::Color, drawing::Color,
event::EventListenerCollection, event::EventListenerCollection,
globals::WguiGlobals, globals::WguiGlobals,
i18n::Translation, i18n::Translation,
layout::{Layout, Widget}, layout::{Layout, Widget},
parser::{ParseDocumentExtra, ParseDocumentParams, ParserState}, parser::{ParseDocumentExtra, ParseDocumentParams, ParserState},
widget::{label::WidgetLabel, rectangle::WidgetRectangle}, widget::{label::WidgetLabel, rectangle::WidgetRectangle},
}; };
pub struct TestbedGeneric { pub struct TestbedGeneric {
pub layout: Layout, pub layout: Layout,
#[allow(dead_code)] #[allow(dead_code)]
state: ParserState, state: ParserState,
} }
fn button_click_callback( fn button_click_callback(
button: Component, button: Component,
label: Widget, label: Widget,
text: &'static str, text: &'static str,
) -> ButtonClickCallback { ) -> ButtonClickCallback {
Box::new(move |e| { Box::new(move |e| {
label.get_as_mut::<WidgetLabel>().set_text( label.get_as_mut::<WidgetLabel>().set_text(
&mut e.state.globals.i18n(), &mut e.state.globals.i18n(),
Translation::from_raw_text(text), Translation::from_raw_text(text),
); );
button.try_cast::<ComponentButton>()?.set_text( button.try_cast::<ComponentButton>()?.set_text(
e.state, e.state,
e.alterables, e.alterables,
Translation::from_raw_text("this button has been clicked"), Translation::from_raw_text("this button has been clicked"),
); );
Ok(()) Ok(())
}) })
} }
fn handle_button_click(button: Rc<ComponentButton>, label: Widget, text: &'static str) { fn handle_button_click(button: Rc<ComponentButton>, label: Widget, text: &'static str) {
button.on_click(button_click_callback( button.on_click(button_click_callback(
Component(button.clone()), Component(button.clone()),
label, label,
text, text,
)); ));
} }
impl TestbedGeneric { impl TestbedGeneric {
pub fn new(listeners: &mut EventListenerCollection<(), ()>) -> anyhow::Result<Self> { pub fn new(listeners: &mut EventListenerCollection<(), ()>) -> anyhow::Result<Self> {
const XML_PATH: &str = "gui/various_widgets.xml"; const XML_PATH: &str = "gui/various_widgets.xml";
let globals = WguiGlobals::new(Box::new(assets::Asset {}))?; let globals = WguiGlobals::new(Box::new(assets::Asset {}))?;
let extra = ParseDocumentExtra { let extra = ParseDocumentExtra {
on_custom_attrib: Some(Box::new(move |par| { on_custom_attrib: Some(Box::new(move |par| {
if par.attrib == "my_custom" { if par.attrib == "my_custom" {
let mut rect = par.get_widget_as::<WidgetRectangle>().unwrap(); let mut rect = par.get_widget_as::<WidgetRectangle>().unwrap();
rect.params.color = match par.value { rect.params.color = match par.value {
"red" => Color::new(1.0, 0.0, 0.0, 1.0), "red" => Color::new(1.0, 0.0, 0.0, 1.0),
"green" => Color::new(0.0, 1.0, 0.0, 1.0), "green" => Color::new(0.0, 1.0, 0.0, 1.0),
"blue" => Color::new(0.0, 0.0, 1.0, 1.0), "blue" => Color::new(0.0, 0.0, 1.0, 1.0),
_ => Color::new(1.0, 1.0, 1.0, 1.0), _ => Color::new(1.0, 1.0, 1.0, 1.0),
} }
} }
})), })),
dev_mode: false, dev_mode: false,
}; };
let (layout, state) = wgui::parser::new_layout_from_assets( let (layout, state) = wgui::parser::new_layout_from_assets(
listeners, listeners,
&ParseDocumentParams { &ParseDocumentParams {
globals, globals,
path: XML_PATH, path: XML_PATH,
extra, extra,
}, },
)?; )?;
let label_cur_option = state.fetch_widget(&layout.state, "label_current_option")?; let label_cur_option = state.fetch_widget(&layout.state, "label_current_option")?;
let button_click_me = state.fetch_component_as::<ComponentButton>("button_click_me")?; let button_click_me = state.fetch_component_as::<ComponentButton>("button_click_me")?;
let button = button_click_me.clone(); let button = button_click_me.clone();
button_click_me.on_click(Box::new(move |e| { button_click_me.on_click(Box::new(move |e| {
button.set_text( button.set_text(
e.state, e.state,
e.alterables, e.alterables,
Translation::from_raw_text("congrats!"), Translation::from_raw_text("congrats!"),
); );
Ok(()) Ok(())
})); }));
let button_red = state.fetch_component_as::<ComponentButton>("button_red")?; let button_red = state.fetch_component_as::<ComponentButton>("button_red")?;
let button_aqua = state.fetch_component_as::<ComponentButton>("button_aqua")?; let button_aqua = state.fetch_component_as::<ComponentButton>("button_aqua")?;
let button_yellow = state.fetch_component_as::<ComponentButton>("button_yellow")?; let button_yellow = state.fetch_component_as::<ComponentButton>("button_yellow")?;
handle_button_click(button_red, label_cur_option.clone(), "Clicked red"); handle_button_click(button_red, label_cur_option.clone(), "Clicked red");
handle_button_click(button_aqua, label_cur_option.clone(), "Clicked aqua"); handle_button_click(button_aqua, label_cur_option.clone(), "Clicked aqua");
handle_button_click(button_yellow, label_cur_option.clone(), "Clicked yellow"); handle_button_click(button_yellow, label_cur_option.clone(), "Clicked yellow");
let cb_first = state.fetch_component_as::<ComponentCheckbox>("cb_first")?; let cb_first = state.fetch_component_as::<ComponentCheckbox>("cb_first")?;
let label = label_cur_option.clone(); let label = label_cur_option.clone();
cb_first.on_toggle(Box::new(move |e| { cb_first.on_toggle(Box::new(move |e| {
let mut widget = label.get_as_mut::<WidgetLabel>(); let mut widget = label.get_as_mut::<WidgetLabel>();
widget.set_text( widget.set_text(
&mut e.state.globals.i18n(), &mut e.state.globals.i18n(),
Translation::from_raw_text(&format!("checkbox toggle: {}", e.checked)), Translation::from_raw_text(&format!("checkbox toggle: {}", e.checked)),
); );
Ok(()) Ok(())
})); }));
Ok(Self { layout, state }) Ok(Self { layout, state })
} }
} }
impl Testbed for TestbedGeneric { 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<()> {
self.layout self
.update(Vec2::new(width, height), timestep_alpha)?; .layout
Ok(()) .update(Vec2::new(width, height), timestep_alpha)?;
} Ok(())
}
fn layout(&mut self) -> &mut Layout { fn layout(&mut self) -> &mut Layout {
&mut self.layout &mut self.layout
} }
} }