Spacings can now be styled via CSS

Author: vars1ty

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "hybrid-bar"
 authors = [ "varsity <[email protected]>" ]
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 description = "A simple status bar made for wlroots compositors."
 license = "MIT"

README.md

@@ -11,7 +11,8 @@ It supports:
 - Buttons with `on click` actions via a bash command;
 - Spacings;
 - Transparency (+ blur if your compositor supports it);
-- Custom CSS
+- Custom CSS;
+- Custom update-frequency for dynamic widgets (ones with a `command` set)
 
 In other words, it's a simple Wayland status bar that does one thing: Display the stuff __you__ put onto it. Nothing more, nothing less, no over-engineered dogshit.
 ## I have no config
@@ -27,7 +28,7 @@ Here's an example:
 
 ```json
 {
-    "background": {
+    "hybrid": {
         "r": 10,
         "g": 10,
         "b": 10,

WIDGETS.md

@@ -1,4 +1,11 @@
 # Widgets
+> **Warning**:
+> Widgets with a command set are updated every few milliseconds from the value at `hybrid:update_rate`.
+>
+> An unspecified value (or one below `5`) will default to `5`, meaning it calls bash-commands every 5 milliseconds.
+>
+> This can be performance intensive, so it's recommended that you set the update-rate to something like `100`.
+***
 Available widgets:
 
 Labels:

examples/config.json

@@ -1,5 +1,6 @@
 {
-    "background": {
+    "hybrid": {
+        "update_rate": 100,
         "r": 10,
         "g": 10,
         "b": 10,

src/config.rs

@@ -1,9 +1,6 @@
-use crate::{
-    constant_messages::{FAILED_PARSING_CONFIG, FAILED_PARSING_CONTENT},
-    environment, proc,
-};
+use crate::{environment, proc};
 use json::JsonValue;
-use std::{any::TypeId, fmt::Display, fs, io::Error};
+use std::{any::TypeId, fmt::Display, fs};
 
 /// Gets the root home path to Hybrid.
 pub fn get_path() -> String {
@@ -21,27 +18,29 @@ pub fn read_config() -> JsonValue {
         &fs::read_to_string(&conf_path)
             .expect(format!("[ERROR] Failed reading config file from '{conf_path}'!\n").as_str()),
     )
-    .expect(FAILED_PARSING_CONFIG)
+    .expect(format!("[ERROR] Failed parsing config from '{conf_path}'!\n").as_str())
 }
 
 /// If the `key` exists inside `root`, the value of it is returned.
 /// If not, a default value is instead returned.
-pub fn try_get<T>(root: &str, key: &str) -> Result<(String, i32), Error>
+pub fn try_get<T>(root: &str, key: &str) -> (String, i32)
 where
     T: Display + 'static,
 {
     let cfg = &read_config()[root];
     let is_string = TypeId::of::<T>() == TypeId::of::<String>();
     if cfg.has_key(key) {
         if !is_string {
-            return Ok((
+            return (
                 String::default(),
-                cfg[key].as_i32().expect(FAILED_PARSING_CONTENT),
-            ));
+                cfg[key]
+                    .as_i32()
+                    .expect(format!("[ERROR] Failed parsing {root}:{key} as i32!\n").as_str()),
+            );
         }
 
-        Ok((cfg[key].to_string(), 0))
+        (cfg[key].to_string(), 0)
     } else {
-        Ok((String::default(), 0))
+        (String::default(), 0)
     }
 }

src/constant_messages.rs

@@ -1,4 +1,4 @@
-use crate::{constant_messages::CANNOT_ACCESS_VEC, debug::log, proc, ui};
+use crate::{config, debug::log, proc, ui};
 use gtk::traits::*;
 use std::time::Duration;
 
@@ -10,13 +10,35 @@ pub fn update() {
         glib::Continue(true)
     };
 
-    // Executes the "tick" closure every 100ms.
-    glib::timeout_add_local(Duration::from_millis(100), tick);
+    // Executes the "tick" closure for every millisecond specified in hybrid:update_rate.
+
+    glib::timeout_add_local(Duration::from_millis(get_update_rate()), tick);
+}
+
+/// Returns the set update-rate.
+fn get_update_rate() -> u64 {
+    let mut update_rate = config::try_get::<i32>("hybrid", "update_rate").1;
+    // Clamp the value to a minimum of 5.
+    if update_rate < 5 {
+        update_rate = 5;
+    }
+
+    if update_rate < 100 {
+        println!("[HYBRID] [CRITICAL WARNING] Your update-rate is {update_rate}ms! Expect performance drawbacks")
+    }
+
+    update_rate
+        .try_into()
+        .expect("[ERROR] Cannot convert update_rate into u64!\n")
 }
 
 /// Updates all of the labels.
 fn update_labels() {
-    for widget in ui::VEC.lock().expect(CANNOT_ACCESS_VEC).iter() {
+    for widget in ui::VEC
+        .lock()
+        .expect("[ERROR] Cannot access ui::VEC!\n")
+        .iter()
+    {
         let mut text = widget.text.clone();
         // Append to the cloned text if the command isn't empty.
         if !widget.command.is_empty() {

src/loop.rs

@@ -4,7 +4,6 @@ extern crate lazy_static;
 #[path = "widgets/button_widget.rs"]
 mod button_widget;
 mod config;
-mod constant_messages;
 mod debug;
 mod environment;
 #[path = "widgets/label_widget.rs"]
@@ -17,9 +16,9 @@ mod structures;
 mod ui;
 mod widget;
 
-use constant_messages::*;
 use debug::log;
 use gtk::gdk::*;
+use gtk::gio::ApplicationFlags;
 use gtk::prelude::*;
 use gtk::*;
 use gtk_layer_shell::Edge;
@@ -32,7 +31,7 @@ use widget::HWidget;
 fn get_anchors() -> [(gtk_layer_shell::Edge, bool); 4] {
     let pos = environment::try_get_var("HYBRID_POS", "TOP");
     if pos != "TOP" && pos != "BOTTOM" {
-        panic!("{}", INVALID_BAR_POSITION)
+        panic!("[ERROR] Invalid position! Values: [ TOP, BOTTOM ]\n")
     }
 
     // If the position was valid, return the result.
@@ -88,7 +87,7 @@ fn load_css() {
 
     // Add the provider to the default screen
     StyleContext::add_provider_for_screen(
-        &Screen::default().expect(MISSING_DISPLAY),
+        &Screen::default().expect("[ERROR] Couldn't find any valid displays!\n"),
         &provider,
         STYLE_PROVIDER_PRIORITY_APPLICATION,
     );
@@ -97,7 +96,7 @@ fn load_css() {
 /// Called upon application startup.
 fn main() {
     log("Building application...");
-    let application = Application::new(None, Default::default());
+    let application = Application::new(None, ApplicationFlags::default());
     log("Loading CSS...");
     application.connect_startup(|_| load_css());
     log("Creating viewport...");
@@ -120,9 +119,9 @@ fn set_visual(window: &ApplicationWindow, _screen: Option<&gdk::Screen>) {
 
 /// Converts the value of a child inside `background` to a `f64`.
 fn get_background_float(cfg: &JsonValue, identifier: &str, from_255: bool) -> f64 {
-    let mut res = cfg["background"][identifier]
+    let mut res = cfg["hybrid"][identifier]
         .as_f64()
-        .expect("[ERROR] Failed converting background:{identifier} to f64!\n");
+        .expect(format!("[ERROR] Failed converting hybrid:{identifier} to f64!\n").as_str());
 
     // Only divide by 255 if explicitly told to.
     if from_255 {
@@ -144,6 +143,6 @@ fn draw(_: &ApplicationWindow, ctx: &cairo::Context) -> Inhibit {
     // Apply
     ctx.set_source_rgba(r, g, b, a);
     ctx.set_operator(cairo::Operator::Screen);
-    ctx.paint().expect(FAILED_PAINTING);
+    ctx.paint().expect("[ERROR] Failed painting!\n");
     Inhibit(false)
 }

src/main.rs

@@ -1,10 +1,5 @@
 use crate::{
-    button_widget::ButtonWidget,
-    constant_messages::{INVALID_IDENTIFIER, INVALID_WIDGET_ALIGNMENT},
-    debug::log,
-    r#loop::update,
-    spacing_widget::SpacingWidget,
-    *,
+    button_widget::ButtonWidget, debug::log, r#loop::update, spacing_widget::SpacingWidget, *,
 };
 use gtk::traits::*;
 use std::{str::FromStr, sync::Mutex};
@@ -37,6 +32,21 @@ pub fn build_widgets(window: &gtk::ApplicationWindow) {
     update();
 }
 
+/// Gets the widget name for a specific key.
+fn get_widget_name(identifiers: Vec<&str>, separator: char, count: usize) -> String {
+    // Stores the unique widget name temporarily.
+    let mut widget_name = String::default();
+    for i in 1..count {
+        widget_name.push_str(identifiers[i]);
+        // Only add '_' to the end if the remaining amount of items isn't 1.
+        if i != count - 1 {
+            widget_name.push(separator);
+        }
+    }
+
+    widget_name
+}
+
 /// Creates all of the widgets.
 fn create_components(left: &Box, centered: &Box, right: &Box) {
     // Add all of the widgets defined from the config.
@@ -60,28 +70,21 @@ fn create_components(left: &Box, centered: &Box, right: &Box) {
         let widget_alignment = key
             .split(ALIGNMENT)
             .nth(0)
-            .expect(INVALID_WIDGET_ALIGNMENT)
+            .expect("[ERROR] Invalid widget alignment!\n")
             .to_uppercase();
 
-        // Stores the unique widget name temporarily.
-        let mut widget_name = String::default();
-        for i in 1..count {
-            widget_name.push_str(identifiers[i]);
-            // Only add '_' to the end if the remaining amount of items isn't 1.
-            if i != count - 1 {
-                widget_name.push(SEPARATOR);
-            }
-        }
-
         // Base keys, text and command being optional.
-        let text = config::try_get::<String>(key, "text").unwrap().0;
-        let command = config::try_get::<String>(key, "command").unwrap().0;
-        let alignment = structures::Align::from_str(&widget_alignment).expect(INVALID_IDENTIFIER);
+        let text = config::try_get::<String>(key, "text").0;
+        let command = config::try_get::<String>(key, "command").0;
+        let alignment = structures::Align::from_str(&widget_alignment)
+            .expect("[ERROR] Invalid widget alignment!\n");
 
         log(format!(
             "Adding widget '{identifier}' with alignment '{widget_alignment}'",
         ));
 
+        let widget_name = get_widget_name(identifiers, SEPARATOR, count);
+
         // Check for identifiers.
         // Defo. not clean or pretty, will probably fix it later.
         if identifier.contains("label") {
@@ -103,14 +106,15 @@ fn create_components(left: &Box, centered: &Box, right: &Box) {
             button.add(alignment, left, centered, right)
         } else if identifier.contains("spacing") {
             let spacing = SpacingWidget {
-                spacing_start: config::try_get::<i32>(key, "spacing_start").unwrap().1,
-                spacing_end: config::try_get::<i32>(key, "spacing_end").unwrap().1,
+                name: widget_name,
+                spacing_start: config::try_get::<i32>(key, "spacing_start").1,
+                spacing_end: config::try_get::<i32>(key, "spacing_end").1,
             };
 
             spacing.add(alignment, left, centered, right)
         } else {
             // You are stupid.
-            panic!("{}", INVALID_WIDGET_IDENTIFIER)
+            panic!("[ERROR] There are no widgets identified as '{identifier}'!\n")
         }
     }
 }

src/ui.rs

@@ -1,8 +1,5 @@
 use crate::{debug::log, structures::Align, widget::HWidget};
-use gtk::{
-    traits::{ButtonExt, ContainerExt, WidgetExt},
-    Box, Button,
-};
+use gtk::{traits::*, *};
 
 /// Creates a new button widget.
 pub struct ButtonWidget {
@@ -34,4 +31,3 @@ impl HWidget for ButtonWidget {
         log(format!("Added a new button widget named '{}'", self.name));
     }
 }
-

src/widgets/button_widget.rs

@@ -1,11 +1,5 @@
-use gtk::{
-    traits::{ContainerExt, WidgetExt},
-    Box, Label,
-};
-
-use crate::{
-    constant_messages::CANNOT_ACCESS_VEC, debug::log, structures::Align, ui::VEC, widget::HWidget,
-};
+use crate::{debug::log, structures::Align, ui::VEC, widget::HWidget};
+use gtk::{traits::*, *};
 
 /// Creates a new label widget.
 pub struct LabelWidget {
@@ -32,6 +26,8 @@ impl HWidget for LabelWidget {
         }
 
         log(format!("Added a new label widget named '{}'", self.name));
-        VEC.lock().expect(CANNOT_ACCESS_VEC).push(self);
+        VEC.lock()
+            .expect("[ERROR] Cannot access ui::VEC!\n")
+            .push(self);
     }
 }

src/widgets/label_widget.rs

@@ -1,11 +1,9 @@
 use crate::{debug::log, structures::Align, widget::HWidget};
-use gtk::{
-    traits::{ContainerExt, WidgetExt},
-    Box, Orientation,
-};
+use gtk::{traits::*, *};
 
 /// Creates a new basic spacing widget.
 pub struct SpacingWidget {
+    pub name: String,
     pub spacing_start: i32,
     pub spacing_end: i32,
 }
@@ -14,6 +12,8 @@ pub struct SpacingWidget {
 impl HWidget for SpacingWidget {
     fn add(self, align: Align, left: &Box, centered: &Box, right: &Box) {
         let widget = Box::new(Orientation::Horizontal, 0);
+        // 0.2.2: Allow for named spacings
+        widget.set_widget_name(&self.name);
         widget.set_margin_start(self.spacing_start);
         widget.set_margin_end(self.spacing_end);