RomanNum3ral
/
wayvr
mirror of https://github.com/wayvr-org/wayvr.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

wgui: Simplify usage and code, no more start_common(), Layout processes alterables

This commit is contained in:
Aleksander 2026-04-08 00:29:32 +02:00 committed by galister
parent 47bb5ab7a2
commit 0c87d47ce6
16 changed files with 111 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
dash-frontend/src/frontend.rs
View File

@ -280,10 +280,8 @@ impl<T: 'static> Frontend<T> {
}
fn update_time(&mut self, data: &mut T) -> anyhow::Result<()> {
let mut c = self.layout.start_common();
let mut common = c.common();
{
let mut common = self.layout.common();
let mut label = common
.state
.widgets
@ -304,7 +302,6 @@ impl<T: 'static> Frontend<T> {
label.set_text(&mut common, Translation::from_raw_text(&text));
}
c.finish()?;
Ok(())
}
@ -327,9 +324,7 @@ impl<T: 'static> Frontend<T> {
}
fn refresh_popup_manager(&mut self) -> anyhow::Result<()> {
let mut c = self.layout.start_common();
self.popup_manager.refresh(c.common().alterables);
c.finish()?;
self.popup_manager.refresh(&mut self.layout.alterables);
Ok(())
}
@ -376,8 +371,7 @@ impl<T: 'static> Frontend<T> {
}
fn set_tab_title(&mut self, translation: &str, icon: &str) -> anyhow::Result<()> {
let mut c = self.layout.start_common();
let mut common = c.common();
let mut common = self.layout.common();
{
let mut label = common
@ -398,7 +392,6 @@ impl<T: 'static> Frontend<T> {
);
}
c.finish()?;
Ok(())
}

9
dash-frontend/src/tab/home.rs
View File

@ -59,9 +59,12 @@ impl<T> TabHome<T> {
parent_id,
)?;
let mut c = frontend.layout.start_common();
let widget_label = state.fetch_widget(&c.layout.state, "label_hello")?.widget;
configure_label_hello(&mut c.common(), widget_label, frontend.interface.general_config(data));
let widget_label = state.fetch_widget(&frontend.layout.state, "label_hello")?.widget;
configure_label_hello(
&mut frontend.layout.common(),
widget_label,
frontend.interface.general_config(data),
);
let btn_apps = state.fetch_component_as::<ComponentButton>("btn_apps")?;
let btn_games = state.fetch_component_as::<ComponentButton>("btn_games")?;

4
dash-frontend/src/tab/monado.rs
View File

@ -281,9 +281,7 @@ impl SubtabGeneralSettings {
// get brightness
let slider_brightness = state.fetch_component_as::<ComponentSlider>("slider_brightness")?;
if let Some(brightness) = frontend.interface.monado_brightness_get(data) {
let mut c = frontend.layout.start_common();
slider_brightness.set_value(&mut c.common(), brightness * 100.0);
c.finish()?;
slider_brightness.set_value(&mut frontend.layout.common(), brightness * 100.0);
slider_brightness.on_value_changed({
let tasks = tasks.clone();

10
dash-frontend/src/tab/settings/mod.rs
View File

@ -5,7 +5,6 @@ use wgui::{
assets::AssetPath,
components::tabs::ComponentTabs,
drawing,
event::{CallbackDataCommon, EventAlterables},
globals::WguiGlobals,
i18n::Translation,
layout::{Layout, WidgetID},
@ -212,15 +211,10 @@ impl<T> Tab<T> for TabSettings<T> {
let mut s = name.splitn(5, ';');
(s.next(), s.next(), s.next(), s.next(), s.next())
} {
let mut common = frontend.layout.common();
let mut label = self
.state
.fetch_widget_as::<WidgetLabel>(&frontend.layout.state, &format!("{id}_value"))?;
let mut alterables = EventAlterables::default();
let mut common = CallbackDataCommon {
alterables: &mut alterables,
state: &frontend.layout.state,
};
.fetch_widget_as::<WidgetLabel>(&common.state, &format!("{id}_value"))?;
let translation = Translation {
text: text.into(),

18
dash-frontend/src/views/audio_settings.rs
View File

@ -653,9 +653,6 @@ impl View {
}
fn update_button_highlights(&self, layout: &mut Layout) -> anyhow::Result<()> {
let mut c = layout.start_common();
let mut common = c.common();
let num: u8 = match &self.mode {
CurrentMode::Sinks => 0,
CurrentMode::Sources => 1,
@ -663,20 +660,21 @@ impl View {
CurrentMode::CardProfileSelector(_) => 255,
};
let mut com = layout.common();
let mut perform = |btn_num: u8, btn: &Rc<ComponentButton>| {
let color = if num == btn_num {
common.state.theme.accent_color
com.state.theme.accent_color
} else {
common.state.theme.button_color
com.state.theme.button_color
};
btn.set_color(&mut common, color);
btn.set_color(&mut com, color);
};
perform(0, &self.btn_sinks);
perform(1, &self.btn_sources);
perform(2, &self.btn_cards);
c.finish()?;
Ok(())
}
@ -801,9 +799,7 @@ impl View {
par,
)?;
let mut c = params.layout.start_common();
let mut common = c.common();
let mut common = params.layout.common();
let checkbox = data.fetch_component_as::<ComponentCheckbox>("checkbox")?;
let btn_mute = data.fetch_component_as::<ComponentButton>("btn_mute")?;
let slider = data.fetch_component_as::<ComponentSlider>("slider")?;
@ -838,8 +834,6 @@ impl View {
})
});
c.finish()?;
Ok(())
}

12
dash-frontend/src/views/game_launcher.rs
View File

@ -140,16 +140,15 @@ impl View {
layout: &mut Layout,
mut details: cached_fetcher::AppDetailsJSONData,
) -> anyhow::Result<()> {
let mut c = layout.start_common();
{
let label_author = self.state.fetch_widget(&c.layout.state, "label_author")?.widget;
let label_description = self.state.fetch_widget(&c.layout.state, "label_description")?.widget;
let mut c = layout.common();
let label_author = self.state.fetch_widget(&c.state, "label_author")?.widget;
let label_description = self.state.fetch_widget(&c.state, "label_description")?.widget;
if let Some(developer) = details.developers.pop() {
label_author
.cast::<WidgetLabel>()?
.set_text(&mut c.common(), Translation::from_raw_text_string(developer));
.set_text(&mut c, Translation::from_raw_text_string(developer));
}
let desc = if let Some(desc) = &details.short_description {
@ -163,11 +162,10 @@ impl View {
if let Some(desc) = desc {
label_description
.cast::<WidgetLabel>()?
.set_text(&mut c.common(), Translation::from_raw_text(desc));
.set_text(&mut c, Translation::from_raw_text(desc));
}
}
c.finish()?;
Ok(())
}

8
dash-frontend/src/views/game_list.rs
View File

@ -233,16 +233,14 @@ impl View {
}
// set page text
let mut c = layout.start_common();
{
let mut common = c.common();
let mut widget = common.state.widgets.cast_as::<WidgetLabel>(self.id_label_page)?;
let mut c = layout.common();
let mut widget = c.state.widgets.cast_as::<WidgetLabel>(self.id_label_page)?;
widget.set_text(
&mut common,
&mut c,
Translation::from_raw_text_string(format!("{}/{}", self.cur_page + 1, self.page_count)),
);
}
c.finish()?;
fill_game_list(
&mut ConstructEssentials {

11
dash-frontend/src/views/remote_skymap_downloader.rs
View File

@ -10,7 +10,6 @@ use crate::{
use wgui::{
assets::AssetPath,
components::button::ComponentButton,
event::EventAlterables,
globals::WguiGlobals,
i18n::Translation,
layout::{Layout, WidgetID},
@ -80,13 +79,9 @@ impl View {
let str_creation_date = par.globals.i18n().translate("CREATION_DATE");
let str_modification_date = par.globals.i18n().translate("MODIFICATION_DATE");
{
let mut alterables = EventAlterables::default();
let image = parser_state.fetch_widget(&par.layout.state, "image")?.widget;
let mut image = image.cast::<WidgetImage>()?;
image.set_content(&mut alterables, par.preview_image);
par.layout.process_alterables(alterables)?;
}
let image = parser_state.fetch_widget(&par.layout.state, "image")?.widget;
let mut image = image.cast::<WidgetImage>()?;
image.set_content(&mut par.layout.alterables, par.preview_image);
// Set author label
parser_state

52
wayvr/src/gui/panel/mod.rs
View File

@ -1,10 +1,20 @@
use std::{cell::RefCell, rc::Rc};
use super::timer::GuiTimer;
use crate::{
app_misc,
backend::input::{Haptics, HoverResult, PointerHit, PointerMode},
backend::task::ModifyPanelCommand,
state::AppState,
subsystem::hid::WheelDelta,
windowing::backend::{
FrameMeta, OverlayBackend, OverlayEventData, RenderResources, ShouldRender, ui_transform,
},
};
use anyhow::Context;
use button::setup_custom_button;
use glam::{Affine2, Vec2, vec2};
use idmap::IdMap;
use label::setup_custom_label;
use std::{cell::RefCell, rc::Rc};
use wgui::{
assets::AssetPath,
components::{
@ -12,9 +22,9 @@ use wgui::{
slider::ComponentSlider,
},
event::{
CallbackDataCommon, Event as WguiEvent, EventAlterables, EventCallback, EventListenerID,
EventListenerKind, InternalStateChangeEvent, MouseButtonEvent, MouseButtonIndex,
MouseLeaveEvent, MouseMotionEvent, MouseWheelEvent,
Event as WguiEvent, EventCallback, EventListenerID, EventListenerKind,
InternalStateChangeEvent, MouseButtonEvent, MouseButtonIndex, MouseLeaveEvent,
MouseMotionEvent, MouseWheelEvent,
},
gfx::cmd::WGfxClearMode,
i18n::Translation,
@ -33,19 +43,6 @@ use wgui::{
use wlx_common::overlays::{BackendAttrib, BackendAttribValue};
use wlx_common::timestep::Timestep;
use crate::{
app_misc,
backend::input::{Haptics, HoverResult, PointerHit, PointerMode},
backend::task::ModifyPanelCommand,
state::AppState,
subsystem::hid::WheelDelta,
windowing::backend::{
FrameMeta, OverlayBackend, OverlayEventData, RenderResources, ShouldRender, ui_transform,
},
};
use super::timer::GuiTimer;
pub mod button;
pub mod device_list;
mod label;
@ -493,17 +490,13 @@ pub fn apply_custom_command<T>(
element: &str,
command: &ModifyPanelCommand,
) -> anyhow::Result<()> {
let mut alterables = EventAlterables::default();
let mut com = CallbackDataCommon {
alterables: &mut alterables,
state: &panel.layout.state,
};
let mut com = panel.layout.common();
match command {
ModifyPanelCommand::SetText(text) => {
if let Ok(mut label) = panel
.parser_state
.fetch_widget_as::<WidgetLabel>(&panel.layout.state, element)
.fetch_widget_as::<WidgetLabel>(&com.state, element)
{
label.set_text(&mut com, Translation::from_raw_text(text));
} else if let Ok(button) = panel
@ -516,10 +509,7 @@ pub fn apply_custom_command<T>(
}
}
ModifyPanelCommand::SetImage(path) => {
if let Ok(pair) = panel
.parser_state
.fetch_widget(&panel.layout.state, element)
{
if let Ok(pair) = panel.parser_state.fetch_widget(&com.state, element) {
let data = CustomGlyphData::from_assets(
&app.wgui_globals,
wgui::assets::AssetPath::File(path),
@ -541,10 +531,7 @@ pub fn apply_custom_command<T>(
let color = parse_color_hex(color)
.context("Invalid color format, must be a html hex color!")?;
if let Ok(pair) = panel
.parser_state
.fetch_widget(&panel.layout.state, element)
{
if let Ok(pair) = panel.parser_state.fetch_widget(&com.state, element) {
if let Some(mut rect) = pair.widget.get_as::<WidgetRectangle>() {
rect.set_color(&mut com, color);
} else if let Some(mut label) = pair.widget.get_as::<WidgetLabel>() {
@ -610,6 +597,5 @@ pub fn apply_custom_command<T>(
}
}
panel.layout.process_alterables(alterables)?;
Ok(())
}

28
wayvr/src/gui/panel/overlay_list.rs
View File

@ -1,15 +1,12 @@
use std::{collections::HashMap, rc::Rc};
use crate::windowing::{OverlayID, backend::OverlayEventData, window::OverlayCategory};
use slotmap::{Key, SecondaryMap};
use std::{collections::HashMap, rc::Rc};
use wgui::{
components::button::ComponentButton,
event::{CallbackDataCommon, EventAlterables},
layout::Layout,
parser::{Fetchable, ParseDocumentParams, ParserState},
};
use crate::windowing::{OverlayID, backend::OverlayEventData, window::OverlayCategory};
#[derive(Default)]
/// Helper for managing a list of overlays
/// Populates `id="panels_root"` with `<Screen>`, `<Mirror>`, `<Panel>` templates
@ -25,7 +22,6 @@ impl OverlayList {
layout: &mut Layout,
parser_state: &mut ParserState,
event_data: &OverlayEventData,
alterables: &mut EventAlterables,
doc_params: &ParseDocumentParams,
) -> anyhow::Result<bool> {
let mut elements_changed = false;
@ -98,11 +94,7 @@ impl OverlayList {
};
if meta.visible {
let mut com = CallbackDataCommon {
alterables,
state: &layout.state,
};
overlay_button.set_sticky_state(&mut com, true);
overlay_button.set_sticky_state(&mut layout.common(), true);
}
self.overlay_buttons.insert(meta.id, overlay_button);
continue;
@ -121,31 +113,23 @@ impl OverlayList {
let overlay_button = parser_state
.fetch_component_as::<ComponentButton>(&format!("overlay_{i}"))?;
if meta.visible {
let mut com = CallbackDataCommon {
alterables,
state: &layout.state,
};
overlay_button.set_sticky_state(&mut com, true);
overlay_button.set_sticky_state(&mut layout.common(), true);
}
self.overlay_buttons.insert(meta.id, overlay_button);
}
elements_changed = true;
}
OverlayEventData::VisibleOverlaysChanged(overlays) => {
let mut com = CallbackDataCommon {
alterables,
state: &layout.state,
};
let mut overlay_buttons = self.overlay_buttons.clone();
for visible in overlays.as_ref() {
if let Some(btn) = overlay_buttons.remove(*visible) {
btn.set_sticky_state(&mut com, true);
btn.set_sticky_state(&mut layout.common(), true);
}
}
for btn in overlay_buttons.values() {
btn.set_sticky_state(&mut com, false);
btn.set_sticky_state(&mut layout.common(), false);
}
}
_ => {}

16
wayvr/src/gui/panel/set_list.rs
View File

@ -2,7 +2,6 @@ use std::{collections::HashMap, rc::Rc};
use wgui::{
components::button::ComponentButton,
event::{CallbackDataCommon, EventAlterables},
layout::Layout,
parser::{Fetchable, ParseDocumentParams, ParserState},
};
@ -23,25 +22,20 @@ impl SetList {
layout: &mut Layout,
parser_state: &mut ParserState,
event_data: &OverlayEventData,
alterables: &mut EventAlterables,
doc_params: &ParseDocumentParams,
) -> anyhow::Result<bool> {
let mut elements_changed = false;
match event_data {
OverlayEventData::ActiveSetChanged(current_set) => {
let mut com = CallbackDataCommon {
alterables,
state: &layout.state,
};
if let Some(old_set) = self.current_set.take()
&& let Some(old_set) = self.set_buttons.get_mut(old_set)
{
old_set.set_sticky_state(&mut com, false);
old_set.set_sticky_state(&mut layout.common(), false);
}
if let Some(new_set) = current_set
&& let Some(new_set) = self.set_buttons.get_mut(*new_set)
{
new_set.set_sticky_state(&mut com, true);
new_set.set_sticky_state(&mut layout.common(), true);
}
self.current_set = *current_set;
}
@ -59,11 +53,7 @@ impl SetList {
let set_button =
parser_state.fetch_component_as::<ComponentButton>(&format!("set_{i}"))?;
if self.current_set == Some(i) {
let mut com = CallbackDataCommon {
alterables,
state: &layout.state,
};
set_button.set_sticky_state(&mut com, true);
set_button.set_sticky_state(&mut layout.common(), true);
}
self.set_buttons.push(set_button);
}

64
wayvr/src/overlays/edit/mod.rs
View File

@ -10,7 +10,7 @@ use glam::vec2;
use slotmap::Key;
use wgui::{
components::{button::ComponentButton, checkbox::ComponentCheckbox, slider::ComponentSlider},
event::{CallbackDataCommon, EventAlterables, EventCallback},
event::EventCallback,
i18n::Translation,
parser::Fetchable,
widget::EventResult,
@ -466,98 +466,82 @@ fn reset_panel(
*panel.state.id.borrow_mut() = id;
let state = owc.active_state.as_mut().unwrap();
let mut alterables = EventAlterables::default();
let mut common = CallbackDataCommon {
alterables: &mut alterables,
state: &panel.layout.state,
};
let mut com = panel.layout.common();
let c = panel
.parser_state
.fetch_component_as::<ComponentButton>("top_grab")?;
c.set_sticky_state(&mut common, !state.grabbable);
c.set_sticky_state(&mut com, !state.grabbable);
let c = panel
.parser_state
.fetch_component_as::<ComponentSlider>("lerp_slider")?;
c.set_value(&mut common, state.positioning.get_lerp().unwrap_or(1.0));
c.set_value(&mut com, state.positioning.get_lerp().unwrap_or(1.0));
let c = panel
.parser_state
.fetch_component_as::<ComponentSlider>("alpha_slider")?;
c.set_value(&mut common, state.alpha);
c.set_value(&mut com, state.alpha);
let c = panel
.parser_state
.fetch_component_as::<ComponentSlider>("curve_slider")?;
c.set_value(&mut common, state.curvature.unwrap_or(0.0));
c.set_value(&mut com, state.curvature.unwrap_or(0.0));
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("additive_box")?;
c.set_checked(&mut common, state.additive);
c.set_checked(&mut com, state.additive);
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("align_box")?;
c.set_checked(&mut common, state.positioning.get_align().unwrap_or(false));
c.set_checked(&mut com, state.positioning.get_align().unwrap_or(false));
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("global_box")?;
c.set_checked(&mut common, owc.global);
c.set_checked(&mut com, owc.global);
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("angle_fade_box")?;
c.set_checked(&mut common, state.angle_fade);
c.set_checked(&mut com, state.angle_fade);
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("block_input_box")?;
c.set_checked(&mut common, state.block_input);
c.set_checked(&mut com, state.block_input);
panel
.state
.pos
.reset(&mut common, &state.positioning.into());
panel.state.lock.reset(&mut common, state.interactable);
panel.state.tabs.reset(&mut common);
panel.state.pos.reset(&mut com, &state.positioning.into());
panel.state.lock.reset(&mut com, state.interactable);
panel.state.tabs.reset(&mut com);
if let Some(stereo) = attrib_value!(
owc.backend.get_attrib(BackendAttrib::Stereo),
BackendAttribValue::Stereo
) {
panel
.state
.tabs
.set_tab_visible(&mut common, "stereo", true);
panel.state.stereo.reset(&mut common, &stereo);
panel.state.tabs.set_tab_visible(&mut com, "stereo", true);
panel.state.stereo.reset(&mut com, &stereo);
// Set the checkbox label based on stereo mode
let translation = get_stereo_full_frame_translation(stereo);
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("stereo_full_frame_box")?;
c.set_text(&mut common, Translation::from_translation_key(translation));
c.set_text(&mut com, Translation::from_translation_key(translation));
} else {
panel
.state
.tabs
.set_tab_visible(&mut common, "stereo", false);
panel.state.tabs.set_tab_visible(&mut com, "stereo", false);
}
if let Some(mouse) = attrib_value!(
owc.backend.get_attrib(BackendAttrib::MouseTransform),
BackendAttribValue::MouseTransform
) {
panel.state.tabs.set_tab_visible(&mut common, "mouse", true);
panel.state.mouse.reset(&mut common, &mouse);
panel.state.tabs.set_tab_visible(&mut com, "mouse", true);
panel.state.mouse.reset(&mut com, &mouse);
} else {
panel
.state
.tabs
.set_tab_visible(&mut common, "mouse", false);
panel.state.tabs.set_tab_visible(&mut com, "mouse", false);
}
if let Some(full_frame) = attrib_value!(
@ -567,7 +551,7 @@ fn reset_panel(
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("stereo_full_frame_box")?;
c.set_checked(&mut common, full_frame);
c.set_checked(&mut com, full_frame);
}
if let Some(adjust_mouse) = attrib_value!(
@ -577,11 +561,9 @@ fn reset_panel(
let c = panel
.parser_state
.fetch_component_as::<ComponentCheckbox>("stereo_adjust_mouse_box")?;
c.set_checked(&mut common, adjust_mouse);
c.set_checked(&mut com, adjust_mouse);
}
panel.layout.process_alterables(alterables)?;
Ok(())
}

7
wayvr/src/overlays/keyboard/builder.rs
View File

@ -25,7 +25,7 @@ use wgui::{
animation::{Animation, AnimationEasing},
assets::AssetPath,
drawing::{self, Color},
event::{self, CallbackMetadata, EventAlterables, EventListenerKind},
event::{self, CallbackMetadata, EventListenerKind},
layout::LayoutUpdateParams,
log::LogErr,
parser::{Fetchable, ParseDocumentParams},
@ -444,13 +444,10 @@ pub(super) fn create_keyboard_panel(
panel.on_notify = Some(Box::new({
let name = "kbd";
move |panel, app, event_data| {
let mut alterables = EventAlterables::default();
let mut elems_changed = panel.state.overlay_list.on_notify(
&mut panel.layout,
&mut panel.parser_state,
&event_data,
&mut alterables,
&doc_params,
)?;
@ -458,7 +455,6 @@ pub(super) fn create_keyboard_panel(
&mut panel.layout,
&mut panel.parser_state,
&event_data,
&mut alterables,
&doc_params,
)?;
@ -536,7 +532,6 @@ pub(super) fn create_keyboard_panel(
panel.process_custom_elems(app);
}
panel.layout.process_alterables(alterables)?;
Ok(())
}
}));

30
wayvr/src/overlays/watch.rs
View File

@ -4,7 +4,7 @@ use glam::{Affine3A, Quat, Vec3, vec3};
use wgui::{
assets::AssetPath,
components::button::ComponentButton,
event::{CallbackDataCommon, EventAlterables, StyleSetRequest},
event::StyleSetRequest,
parser::{Fetchable, ParseDocumentParams},
taffy,
};
@ -48,9 +48,7 @@ pub fn create_watch(app: &mut AppState) -> anyhow::Result<OverlayWindowConfig> {
let mut panel =
GuiPanel::new_from_template(app, watch_xml, state, NewGuiPanelParams::default())?;
let mut alterables = EventAlterables::default();
sets_or_overlays(&panel, app, &mut alterables);
panel.layout.process_alterables(alterables)?;
sets_or_overlays(&mut panel, app);
let doc_params = ParseDocumentParams {
globals: panel.layout.state.globals.clone(),
@ -61,13 +59,10 @@ pub fn create_watch(app: &mut AppState) -> anyhow::Result<OverlayWindowConfig> {
panel.on_notify = Some(Box::new({
let name = WATCH_NAME;
move |panel, app, event_data| {
let mut alterables = EventAlterables::default();
let mut elems_changed = panel.state.overlay_list.on_notify(
&mut panel.layout,
&mut panel.parser_state,
&event_data,
&mut alterables,
&doc_params,
)?;
@ -75,7 +70,6 @@ pub fn create_watch(app: &mut AppState) -> anyhow::Result<OverlayWindowConfig> {
&mut panel.layout,
&mut panel.parser_state,
&event_data,
&mut alterables,
&doc_params,
)?;
@ -93,16 +87,12 @@ pub fn create_watch(app: &mut AppState) -> anyhow::Result<OverlayWindowConfig> {
.parser_state
.fetch_component_as::<ComponentButton>("btn_edit_mode")
{
let mut com = CallbackDataCommon {
alterables: &mut alterables,
state: &panel.layout.state,
};
btn_edit_mode.set_sticky_state(&mut com, edit_mode);
btn_edit_mode.set_sticky_state(&mut panel.layout.common(), edit_mode);
}
}
OverlayEventData::SettingsChanged => {
panel.layout.mark_redraw();
sets_or_overlays(panel, app, &mut alterables);
sets_or_overlays(panel, app);
if app.session.config.clock_12h != panel.state.clock_12h {
panel.state.clock_12h = app.session.config.clock_12h;
@ -135,7 +125,6 @@ pub fn create_watch(app: &mut AppState) -> anyhow::Result<OverlayWindowConfig> {
panel.process_custom_elems(app);
}
panel.layout.process_alterables(alterables)?;
Ok(())
}
}));
@ -173,11 +162,7 @@ pub fn create_watch(app: &mut AppState) -> anyhow::Result<OverlayWindowConfig> {
})
}
fn sets_or_overlays(
panel: &GuiPanel<WatchState>,
app: &mut AppState,
alterables: &mut EventAlterables,
) {
fn sets_or_overlays(panel: &mut GuiPanel<WatchState>, app: &mut AppState) {
let display = if app.session.config.sets_on_watch {
[taffy::Display::None, taffy::Display::Flex]
} else {
@ -196,6 +181,9 @@ fn sets_or_overlays(
];
for i in 0..2 {
alterables.set_style(widget[i], StyleSetRequest::Display(display[i]));
panel
.layout
.alterables
.set_style(widget[i], StyleSetRequest::Display(display[i]));
}
}

53
wgui/src/layout.rs
View File

@ -163,6 +163,9 @@ pub struct Layout {
sounds_to_play_once: Vec<WguiSoundType>,
focused_component: Option<ComponentWeak>,
// Global EventAlterables queue, always processed in update() call at the end
pub alterables: EventAlterables,
pub widgets_to_tick: Vec<WidgetID>,
// *Main root*
@ -218,31 +221,11 @@ fn add_child_internal(
))
}
pub struct LayoutCommon<'a> {
alterables: EventAlterables,
pub layout: &'a mut Layout,
}
impl LayoutCommon<'_> {
pub const fn common(&mut self) -> CallbackDataCommon<'_> {
impl Layout {
pub fn common(&mut self) -> CallbackDataCommon<'_> {
CallbackDataCommon {
alterables: &mut self.alterables,
state: &self.layout.state,
}
}
pub fn finish(self) -> anyhow::Result<()> {
self.layout.process_alterables(self.alterables)?;
Ok(())
}
}
impl Layout {
// helper function
pub fn start_common(&mut self) -> LayoutCommon<'_> {
LayoutCommon {
alterables: EventAlterables::default(),
layout: self,
state: &self.state,
}
}
@ -596,6 +579,7 @@ impl Layout {
tasks: LayoutTasks::new(),
sounds_to_play_once: Vec::new(),
focused_component: None,
alterables: Default::default(),
})
}
@ -683,10 +667,12 @@ impl Layout {
}
pub fn update(&mut self, params: &mut LayoutUpdateParams) -> anyhow::Result<LayoutUpdateResult> {
let mut alterables = EventAlterables::default();
// get all queued alterables and process them
let alterables = std::mem::take(&mut self.alterables);
self
.animations
.process(&self.state, &mut alterables, params.timestep_alpha);
.process(&self.state, &mut self.alterables, params.timestep_alpha);
self.process_alterables(alterables)?;
self.try_recompute_layout(params.size)?;
@ -720,9 +706,7 @@ impl Layout {
}
}
LayoutTask::Dispatch(func) => {
let mut c = self.start_common();
func(&mut c.common())?;
c.finish()?;
func(&mut self.common())?;
}
LayoutTask::SetWidgetStyle(widget_id, style_request) => {
self.set_style_request(widget_id, &style_request);
@ -740,29 +724,26 @@ impl Layout {
}
pub fn set_focus(&mut self, to_focus: Option<&Component>) -> anyhow::Result<()> {
let mut c = self.start_common();
if let Some(focused) = &c.layout.focused_component
if let Some(focused) = &self.focused_component
&& let Some(focused) = focused.upgrade()
{
// Unfocus
focused.on_focus_change(&mut FocusChangeData {
common: &mut c.common(),
common: &mut self.common(),
focused: false,
});
c.layout.focused_component = None;
self.focused_component = None;
}
if let Some(to_focus) = to_focus {
to_focus.0.on_focus_change(&mut FocusChangeData {
common: &mut c.common(),
common: &mut self.common(),
focused: true,
});
c.layout.focused_component = Some(to_focus.weak());
self.focused_component = Some(to_focus.weak());
}
c.finish()?;
Ok(())
}

9
wgui/src/windowing/window.rs
View File

@ -271,21 +271,20 @@ impl WguiWindow {
content.id
};
let mut c = params.layout.start_common();
if let Some(width) = params.extra.fixed_width {
c.common()
params
.layout
.alterables
.set_style(content_id, StyleSetRequest::Width(length(width)));
}
if let Some(height) = params.extra.fixed_height {
c.common()
params
.layout
.alterables
.set_style(content_id, StyleSetRequest::Height(length(height)));
}
c.finish()?;
Ok(())
}