Add literal tag

src/config/mod.rs

@@ -57,10 +57,7 @@ impl EwwConfig {
         let content = std::fs::read_to_string(path)?;
         let document = roxmltree::Document::parse(&content)?;
 
-        let start = std::time::Instant::now();
         let result = EwwConfig::from_xml_element(XmlNode::from(document.root_element()).as_element()?);
-        let end = std::time::Instant::now();
-        dbg!(end - start);
         result
     }
 
@@ -97,7 +94,12 @@ impl EwwConfig {
                     "var" => {
                         initial_variables.insert(
                             VarName(node.attr("name")?.to_owned()),
-                            PrimitiveValue::parse_string(&node.only_child()?.as_text()?.text()),
+                            PrimitiveValue::parse_string(
+                                &node
+                                    .only_child()
+                                    .and_then(|c| Ok(c.as_text()?.text()))
+                                    .unwrap_or_else(|_| String::new()),
+                            ),
                         );
                     }
                     "script-var" => {

src/config/xml_ext.rs

@@ -17,6 +17,7 @@ pub enum XmlNode<'a, 'b> {
     Text(XmlText<'a, 'b>),
     Ignored(roxmltree::Node<'a, 'b>),
 }
+
 impl<'a, 'b> fmt::Display for XmlNode<'a, 'b> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {

src/eww_state.rs

@@ -168,7 +168,7 @@ impl EwwState {
             }
         };
         if let Err(e) = result {
-            eprintln!("{:?}", e);
+            eprintln!("Error resolving values: {:?}", e);
         }
     }
 }

src/widgets/mod.rs

@@ -1,5 +1,4 @@
-use crate::config::element;
+use crate::config::{element, WindowName};
-use crate::config::WindowName;
 use crate::eww_state::*;
 use crate::value::{AttrValue, VarName};
 use anyhow::*;
@@ -21,12 +20,13 @@ pub fn run_command<T: std::fmt::Display>(cmd: &str, arg: T) {
     }
 }
 
-struct BuilderArgs<'a, 'b, 'c, 'd> {
+struct BuilderArgs<'a, 'b, 'c, 'd, 'e> {
     eww_state: &'a mut EwwState,
     local_env: &'b HashMap<VarName, AttrValue>,
     widget: &'c element::WidgetUse,
     unhandled_attrs: Vec<&'c str>,
     window_name: &'d WindowName,
+    widget_definitions: &'e HashMap<String, element::WidgetDefinition>,
 }
 
 /// Generate a [gtk::Widget] from a [element::WidgetUse].
@@ -43,7 +43,7 @@ pub fn widget_use_to_gtk_widget(
     local_env: &HashMap<VarName, AttrValue>,
     widget: &element::WidgetUse,
 ) -> Result<gtk::Widget> {
-    let builtin_gtk_widget = build_gtk_widget(widget_definitions, eww_state, window_name, local_env, widget)?;
+    let builtin_gtk_widget = build_builtin_gtk_widget(widget_definitions, eww_state, window_name, local_env, widget)?;
 
     let gtk_widget = if let Some(builtin_gtk_widget) = builtin_gtk_widget {
         builtin_gtk_widget
@@ -100,7 +100,7 @@ pub fn widget_use_to_gtk_widget(
 ///
 /// This may return `Err` in case there was an actual error while parsing or resolving the widget,
 /// Or `Ok(None)` if the widget_use just didn't match any widget name.
-fn build_gtk_widget(
+fn build_builtin_gtk_widget(
     widget_definitions: &HashMap<String, element::WidgetDefinition>,
     eww_state: &mut EwwState,
     window_name: &WindowName,
@@ -113,6 +113,7 @@ fn build_gtk_widget(
         widget,
         window_name,
         unhandled_attrs: widget.attrs.keys().map(|x| x.as_ref()).collect(),
+        widget_definitions,
     };
     let gtk_widget = match widget_to_gtk_widget(&mut bargs) {
         Ok(Some(gtk_widget)) => gtk_widget,
@@ -142,6 +143,7 @@ fn build_gtk_widget(
                 )
             })?;
             gtk_widget.add(&child_widget);
+            child_widget.show();
         }
     }
 

src/widgets/widget_definitions.rs

@@ -1,4 +1,6 @@
 use super::{run_command, BuilderArgs};
+use crate::config;
+use crate::eww_state;
 use crate::resolve_block;
 use crate::value::{AttrValue, PrimitiveValue};
 use anyhow::*;
@@ -21,6 +23,7 @@ pub(super) fn widget_to_gtk_widget(bargs: &mut BuilderArgs) -> Result<Option<gtk
         "label" => build_gtk_label(bargs)?.upcast(),
         "text" => build_gtk_text(bargs)?.upcast(),
         "aspect" => build_gtk_aspect_frame(bargs)?.upcast(),
+        "literal" => build_gtk_literal(bargs)?.upcast(),
         _ => return Ok(None),
     };
     Ok(Some(gtk_widget))
@@ -136,6 +139,30 @@ fn build_gtk_text(bargs: &mut BuilderArgs) -> Result<gtk::Label> {
     Ok(gtk_widget)
 }
 
+fn build_gtk_literal(bargs: &mut BuilderArgs) -> Result<gtk::Frame> {
+    let gtk_widget = gtk::Frame::new(None);
+    // TODO these clones here are dumdum
+    let window_name = bargs.window_name.clone();
+    let widget_definitions = bargs.widget_definitions.clone();
+    resolve_block!(bargs, gtk_widget, {
+        prop(content: as_string) {
+            let document = roxmltree::Document::parse(&content)?;
+            let content_widget_use = config::element::WidgetUse::from_xml_node(document.root_element().into())?;
+            let child_widget = super::widget_use_to_gtk_widget(
+                &widget_definitions,
+                &mut eww_state::EwwState::default(),
+                &window_name,
+                &std::collections::HashMap::new(),
+                &content_widget_use,
+            )?;
+            gtk_widget.get_children().iter().for_each(|w| gtk_widget.remove(w));
+            gtk_widget.add(&child_widget);
+            child_widget.show();
+        }
+    });
+    Ok(gtk_widget)
+}
+
 fn build_gtk_aspect_frame(_bargs: &mut BuilderArgs) -> Result<gtk::AspectFrame> {
     let gtk_widget = gtk::AspectFrame::new(None, 0.5, 0.5, 1.0, true);
     Ok(gtk_widget)