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

wgui: ParserResult struct

Browse Source
This commit is contained in:
Aleksander
2025-06-18 19:57:21 +02:00
parent a883e580b6
commit 021f98973d
7 changed files with 171 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
wgui/src/parser.rs
View File

@@ -48,16 +48,14 @@ struct ParserFile<'a> {
path: PathBuf,
document: Rc<XmlDocument>,
ctx: Rc<RefCell<ParserContext<'a>>>,
current_template: Rc<Template>,
template_parameters: HashMap<Rc<str>, Rc<str>>,
}
#[derive(Default)]
pub struct ParserState {
pub ids: HashMap<Rc<str>, WidgetID>,
pub struct ParserResult {
ids: HashMap<Rc<str>, WidgetID>,
}
impl ParserState {
impl ParserResult {
pub fn require_by_id(&self, id: &str) -> anyhow::Result<WidgetID> {
match self.ids.get(id) {
Some(id) => Ok(*id),
@@ -70,7 +68,7 @@ struct ParserContext<'a> {
layout: &'a mut Layout,
var_map: VarMap,
templates: HashMap<Rc<str>, Rc<Template>>,
state: &'a mut ParserState,
ids: HashMap<Rc<str>, WidgetID>,
}
// Parses a color from a HTML hex string
@@ -562,6 +560,39 @@ fn parse_widget_sprite<'a>(
Ok(())
}
fn parse_widget_other<'a>(
xml_tag_name: &str,
file: &'a ParserFile,
ctx: &mut ParserContext,
node: roxmltree::Node<'a, 'a>,
parent_id: WidgetID,
) -> anyhow::Result<()> {
let Some(template) = ctx.templates.get(xml_tag_name) else {
log::error!("Undefined tag named \"{}\"", xml_tag_name);
return Ok(()); // not critical
};
let template_parameters: HashMap<Rc<str>, Rc<str>> = iter_attribs(file, ctx, &node).collect();
let template_file = ParserFile {
ctx: file.ctx.clone(),
document: template.node_document.clone(),
path: file.path.clone(),
template_parameters,
};
let doc = template_file.document.clone();
let template_node = doc
.borrow_doc()
.get_node(template.node)
.ok_or(anyhow::anyhow!("template node invalid"))?;
parse_children(&template_file, ctx, template_node, parent_id)?;
Ok(())
}
fn parse_widget_label<'a>(
file: &'a ParserFile,
ctx: &mut ParserContext,
@@ -800,7 +831,7 @@ fn parse_universal<'a>(
match key.as_ref() {
"id" => {
// Attach a specific widget to name-ID map (just like getElementById)
if ctx.state.ids.insert(value.clone(), widget_id).is_some() {
if ctx.ids.insert(value.clone(), widget_id).is_some() {
log::warn!("duplicate ID \"{}\" in the same layout file!", value);
}
}
@@ -835,30 +866,7 @@ fn parse_children<'a>(
}
"" => { /* ignore */ }
other_tag_name => {
let Some(template) = ctx.templates.get(other_tag_name) else {
log::error!("Undefined tag named \"{}\"", other_tag_name);
continue;
};
let template_parameters: HashMap<Rc<str>, Rc<str>> =
iter_attribs(file, ctx, &child_node).collect();
let template_file = ParserFile {
ctx: file.ctx.clone(),
document: template.node_document.clone(),
path: file.path.clone(),
template_parameters,
current_template: template.clone(),
};
let doc = template_file.document.clone();
let template_node = doc
.borrow_doc()
.get_node(template.node)
.ok_or(anyhow::anyhow!("template node invalid"))?;
parse_children(&template_file, ctx, template_node, parent_id)?;
parse_widget_other(other_tag_name, file, ctx, child_node, parent_id)?;
}
}
}
@@ -869,13 +877,12 @@ pub fn parse_from_assets(
layout: &mut Layout,
parent_id: WidgetID,
path: &str,
) -> anyhow::Result<ParserState> {
) -> anyhow::Result<ParserResult> {
let path = PathBuf::from(path);
let mut result = ParserState::default();
let ctx_rc = Rc::new(RefCell::new(ParserContext {
layout,
state: &mut result,
ids: Default::default(),
var_map: Default::default(),
templates: Default::default(),
}));
@@ -884,11 +891,27 @@ pub fn parse_from_assets(
let (file, node_layout) = get_doc_from_path(ctx_rc.clone(), &mut ctx, &path)?;
parse_document_root(file, &mut ctx, parent_id, node_layout)?;
// move everything essential to the result
let result = ParserResult {
ids: std::mem::take(&mut ctx.ids),
};
drop(ctx);
Ok(result)
}
pub fn new_layout_from_assets(
assets: Box<dyn AssetProvider>,
path: &str,
) -> anyhow::Result<(Layout, ParserResult)> {
let mut layout = Layout::new(assets)?;
let widget = layout.root_widget;
let state = parse_from_assets(&mut layout, widget, path)?;
Ok((layout, state))
}
fn assets_path_to_xml(assets: &mut Box<dyn AssetProvider>, path: &Path) -> anyhow::Result<String> {
let data = assets.load_from_path(&path.to_string_lossy())?;
Ok(String::from_utf8(data)?)
@@ -911,17 +934,11 @@ fn get_doc_from_path<'a>(
let root = document.borrow_doc().root();
let tag_layout = require_tag_by_name(&root, "layout")?;
let template = Template {
node: root.id(),
node_document: document.clone(),
};
let file = ParserFile {
ctx: ctx_rc.clone(),
path: PathBuf::from(path),
document: document.clone(),
current_template: Rc::new(template),
template_parameters: Default::default(), // todo
template_parameters: Default::default(),
};
Ok((file, tag_layout.id()))

7
wgui/uidev-vk/src/testbed/testbed_any.rs
View File

@@ -9,12 +9,7 @@ pub struct TestbedAny {
impl TestbedAny {
pub fn new(name: &str) -> anyhow::Result<Self> {
let path = format!("gui/{name}.xml");
let mut layout = Layout::new(Box::new(assets::Asset {}))?;
let parent = layout.root_widget;
let _res = wgui::parser::parse_from_assets(&mut layout, parent, &path)?;
let (layout, _state) = wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), &path)?;
Ok(Self { layout })
}
}

9
wgui/uidev-vk/src/testbed/testbed_dashboard.rs
View File

@@ -9,13 +9,8 @@ pub struct TestbedDashboard {
impl TestbedDashboard {
pub fn new() -> anyhow::Result<Self> {
const XML_PATH: &str = "gui/dashboard.xml";
let mut layout = Layout::new(Box::new(assets::Asset {}))?;
let parent = layout.root_widget;
let _res = wgui::parser::parse_from_assets(&mut layout, parent, XML_PATH)?;
let (layout, _state) =
wgui::parser::new_layout_from_assets(Box::new(assets::Asset {}), XML_PATH)?;
Ok(Self { layout })
}
}

9
wgui/uidev-vk/src/testbed/testbed_generic.rs
View File

@@ -20,13 +20,8 @@ impl TestbedGeneric {
pub fn new() -> anyhow::Result<Self> {
const XML_PATH: &str = "gui/testbed.xml";
let mut layout = Layout::new(Box::new(assets::Asset {}))?;
layout.assets.load_from_path(XML_PATH)?;
let parent = layout.root_widget;
let res = wgui::parser::parse_from_assets(&mut layout, parent, 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")?;

7
wlx-overlay-s/src/assets/key.xml Normal file
View File

@@ -0,0 +1,7 @@
<layout>
<template name="Key">
<rectangle color="#FF0000" width="32" height="32" margin="4">
</rectangle>
</template>
</layout>

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

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

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

@@ -15,7 +15,7 @@ use crate::{
},
config::{self, ConfigType},
graphics::CommandBuffers,
gui::panel::GuiPanel,
gui::{self, panel::GuiPanel},
hid::{
ALT, CTRL, KEYS_TO_MODS, KeyModifier, KeyType, META, NUM_LOCK, SHIFT, SUPER, VirtualKey,
XkbKeymap, get_key_type,
@@ -125,6 +125,9 @@ where
keymap = None;
}
let (key_layout, _state) =
wgui::parser::new_layout_from_assets(Box::new(gui::asset::GuiAsset {}), "key.xml")?;
for row in 0..LAYOUT.key_sizes.len() {
let (div, _) = panel.layout.add_child(
background,
@@ -142,113 +145,115 @@ where
height: length(PIXELS_PER_UNIT),
};
if let Some(key) = LAYOUT.main_layout[row][col].as_ref() {
let mut label = Vec::with_capacity(2);
let mut maybe_state: Option<KeyButtonData> = None;
let mut cap_type = KeyCapType::Regular;
let Some(key) = LAYOUT.main_layout[row][col].as_ref() else {
continue;
};
if let Ok(vk) = VirtualKey::from_str(key) {
if let Some(keymap) = keymap.as_ref() {
match get_key_type(vk) {
KeyType::Symbol => {
let label0 = keymap.label_for_key(vk, 0);
let label1 = keymap.label_for_key(vk, SHIFT);
let mut label = Vec::with_capacity(2);
let mut maybe_state: Option<KeyButtonData> = None;
let mut cap_type = KeyCapType::Regular;
if label0.chars().next().is_some_and(char::is_alphabetic) {
label.push(label1);
if has_altgr {
cap_type = KeyCapType::RegularAltGr;
label.push(keymap.label_for_key(vk, META));
} else {
cap_type = KeyCapType::Regular;
}
if let Ok(vk) = VirtualKey::from_str(key) {
if let Some(keymap) = keymap.as_ref() {
match get_key_type(vk) {
KeyType::Symbol => {
let label0 = keymap.label_for_key(vk, 0);
let label1 = keymap.label_for_key(vk, SHIFT);
if label0.chars().next().is_some_and(char::is_alphabetic) {
label.push(label1);
if has_altgr {
cap_type = KeyCapType::RegularAltGr;
label.push(keymap.label_for_key(vk, META));
} else {
label.push(label0);
label.push(label1);
if has_altgr {
label.push(keymap.label_for_key(vk, META));
cap_type = KeyCapType::ReversedAltGr;
} else {
cap_type = KeyCapType::Reversed;
}
cap_type = KeyCapType::Regular;
}
} else {
label.push(label0);
label.push(label1);
if has_altgr {
label.push(keymap.label_for_key(vk, META));
cap_type = KeyCapType::ReversedAltGr;
} else {
cap_type = KeyCapType::Reversed;
}
}
KeyType::NumPad => {
label.push(keymap.label_for_key(vk, NUM_LOCK));
}
KeyType::Other => {}
}
KeyType::NumPad => {
label.push(keymap.label_for_key(vk, NUM_LOCK));
}
KeyType::Other => {}
}
}
if let Some(mods) = KEYS_TO_MODS.get(vk) {
maybe_state = Some(KeyButtonData::Modifier {
modifier: *mods,
sticky: false,
});
} else {
maybe_state = Some(KeyButtonData::Key { vk, pressed: false });
}
} else if let Some(macro_verbs) = LAYOUT.macros.get(key) {
maybe_state = Some(KeyButtonData::Macro {
verbs: key_events_for_macro(macro_verbs),
if let Some(mods) = KEYS_TO_MODS.get(vk) {
maybe_state = Some(KeyButtonData::Modifier {
modifier: *mods,
sticky: false,
});
} else if let Some(exec_args) = LAYOUT.exec_commands.get(key) {
if exec_args.is_empty() {
log::error!("Keyboard: EXEC args empty for {key}");
} else {
let mut iter = exec_args.iter().cloned();
if let Some(program) = iter.next() {
maybe_state = Some(KeyButtonData::Exec {
program,
args: iter.by_ref().take_while(|arg| arg[..] != *"null").collect(),
release_program: iter.next(),
release_args: iter.collect(),
});
}
}
} else {
log::error!("Unknown key: {key}");
maybe_state = Some(KeyButtonData::Key { vk, pressed: false });
}
} else if let Some(macro_verbs) = LAYOUT.macros.get(key) {
maybe_state = Some(KeyButtonData::Macro {
verbs: key_events_for_macro(macro_verbs),
});
} else if let Some(exec_args) = LAYOUT.exec_commands.get(key) {
if exec_args.is_empty() {
log::error!("Keyboard: EXEC args empty for {key}");
} else {
let mut iter = exec_args.iter().cloned();
if let Some(program) = iter.next() {
maybe_state = Some(KeyButtonData::Exec {
program,
args: iter.by_ref().take_while(|arg| arg[..] != *"null").collect(),
release_program: iter.next(),
release_args: iter.collect(),
});
}
}
} else {
log::error!("Unknown key: {key}");
}
if let Some(state) = maybe_state {
if label.is_empty() {
label = LAYOUT.label_for_key(key);
}
let _ = panel.layout.add_child(
div,
Rectangle::create(RectangleParams {
border_color: parse_color_hex("#dddddd").unwrap(),
border: 2.0,
round: WLength::Units(4.0),
..Default::default()
})
.unwrap(),
taffy::Style {
size: my_size,
min_size: my_size,
max_size: my_size,
..Default::default()
},
)?;
} else {
let _ = panel.layout.add_child(
div,
Rectangle::create(RectangleParams {
border_color: wgui::drawing::Color::new(0., 0., 0., 0.),
color: wgui::drawing::Color::new(0., 0., 0., 0.),
border: 2.0,
round: WLength::Units(4.0),
..Default::default()
})
.unwrap(),
taffy::Style {
size: my_size,
min_size: my_size,
max_size: my_size,
..Default::default()
},
)?;
if let Some(state) = maybe_state {
if label.is_empty() {
label = LAYOUT.label_for_key(key);
}
let _ = panel.layout.add_child(
div,
Rectangle::create(RectangleParams {
border_color: parse_color_hex("#dddddd").unwrap(),
border: 2.0,
round: WLength::Units(4.0),
..Default::default()
})
.unwrap(),
taffy::Style {
size: my_size,
min_size: my_size,
max_size: my_size,
..Default::default()
},
)?;
} else {
let _ = panel.layout.add_child(
div,
Rectangle::create(RectangleParams {
border_color: wgui::drawing::Color::new(0., 0., 0., 0.),
color: wgui::drawing::Color::new(0., 0., 0., 0.),
border: 2.0,
round: WLength::Units(4.0),
..Default::default()
})
.unwrap(),
taffy::Style {
size: my_size,
min_size: my_size,
max_size: my_size,
..Default::default()
},
)?;
}
}
}