added optional snowflakes on root window

Author: simon0302010

Cargo.lock

@@ -16,4 +16,5 @@ libc = "0.2.177"
 chrono = "0.4.42"
 dirs = "6.0.0"
 sysinfo = "0.37"
-battery = "0.7"
+battery = "0.7"
+rand = "0.9"

Cargo.toml

@@ -3,6 +3,7 @@ exec = []
 
 [general]
 update_ms = "auto"
+snowflakes = false
 
 [window]
 scale_steps = 20

gridwm.toml

@@ -49,12 +49,14 @@ impl Default for Window {
 #[serde(default)]
 pub struct General {
     pub update_ms: String,
+    pub snowflakes: bool,
 }
 
 impl Default for General {
     fn default() -> Self {
         Self {
-            update_ms: "5".to_string(),
+            update_ms: "auto".to_string(),
+            snowflakes: false,
         }
     }
 }

src/gridwm/config.rs

@@ -3,12 +3,14 @@ mod config;
 mod error;
 mod keybinds;
 mod signals;
+mod winter;
 
 use bar::*;
 use config::Config;
 use error::*;
 use keybinds::*;
 use signals::*;
+use winter::*;
 
 use log::*;
 use std::{
@@ -56,6 +58,7 @@ pub struct GridWM {
     win_bar_windows: HashMap<Window, Window>,
     refresh_rate: i16,
     trigger_redraw: bool,
+    snowflakes: Vec<Snowflake>,
 }
 
 pub type Window = u64;
@@ -177,6 +180,12 @@ impl GridWM {
             }
         };
 
+        let mut snowflakes: Vec<Snowflake> = Vec::new();
+
+        if config.general.snowflakes {
+            snowflakes = generate_snowflakes(screen_width, screen_height);
+        }
+
         Ok(GridWM {
             display,
             config,
@@ -194,6 +203,7 @@ impl GridWM {
             win_bar_windows: HashMap::new(),
             refresh_rate,
             trigger_redraw: true,
+            snowflakes,
         })
     }
 
@@ -548,6 +558,18 @@ impl GridWM {
                 self.trigger_redraw = true;
             }
 
+            // snowflakes
+            if self.config.general.snowflakes {
+                draw_snowflakes(
+                    self.display,
+                    &mut self.snowflakes,
+                    self.screen_width,
+                    self.screen_height,
+                    self.bar_gc,
+                );
+                self.trigger_redraw = true;
+            }
+
             if self.config.bar.enable && self.trigger_redraw {
                 self.draw_bar(None);
             }
@@ -1046,7 +1068,15 @@ impl GridWM {
                 }
             };
 
-            xlib::XClearArea(self.display, root, 0, 0, self.screen_width as u32, 50, 0);
+            xlib::XClearArea(
+                self.display,
+                root,
+                0,
+                0,
+                self.screen_width as u32,
+                self.config.bar.height,
+                0,
+            );
             xlib::XFillRectangle(
                 self.display,
                 root,

src/gridwm/mod.rs

@@ -0,0 +1,73 @@
+use std::ffi::CString;
+
+use rand::Rng;
+use x11::xlib::{Display, GC, XClearArea, XDefaultRootWindow, XDrawString};
+
+#[derive(Debug)]
+pub struct Snowflake {
+    pub x: f32,
+    pub y: f32,
+    pub speed: f32,
+    pub drift: f32,
+}
+
+pub fn draw_snowflakes(
+    display: *mut Display,
+    snowflakes: &mut Vec<Snowflake>,
+    screen_width: i16,
+    screen_height: i16,
+    flake_gc: GC,
+) {
+    unsafe {
+        let root = XDefaultRootWindow(display);
+
+        for flake in snowflakes {
+            XClearArea(
+                display,
+                root,
+                flake.x as i32 - 2,
+                flake.y as i32 - 14,
+                18,
+                20,
+                0,
+            );
+
+            flake.y += flake.speed;
+            flake.x += flake.drift;
+
+            if flake.y > screen_height as f32 {
+                flake.y = 0.0;
+            }
+            if flake.x < 0.0 {
+                flake.x = screen_width as f32
+            } else if flake.x > screen_width as f32 {
+                flake.x = 0.0
+            }
+
+            let flake_str = CString::new("*").unwrap_or_default();
+            XDrawString(
+                display,
+                root,
+                flake_gc,
+                flake.x as i32,
+                flake.y as i32,
+                flake_str.as_ptr(),
+                flake_str.to_bytes().len() as i32,
+            );
+        }
+    }
+}
+
+// snowflake generation
+pub fn generate_snowflakes(screen_width: i16, screen_height: i16) -> Vec<Snowflake> {
+    let mut rng = rand::rng();
+
+    (0..40)
+        .map(|_| Snowflake {
+            x: rng.random_range(0.0..=screen_width as f32),
+            y: rng.random_range(0.0..=screen_height as f32),
+            speed: rng.random_range(0.5..=1.8),
+            drift: rng.random_range(-0.3..=0.3),
+        })
+        .collect()
+}