Merge branch 'zshell-img-tools' of git.zach-dev.cc:zach/z-bar-qt into zshell-img-tools

zshell-img-tools/src/config.rs

@@ -10,10 +10,10 @@ pub struct Config {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EffectsConfig {
-    pub corner_radius: f32,
+    pub radius: f32,
-    pub drop_shadow: bool,
+    pub shadow: bool,
-    pub rounded_corners: bool,
+    pub rounding: bool,
-    pub shadow_blur_radius: f32,
+    pub shadow_blur: f32,
     pub shadow_color: [u8; 4],
     pub shadow_offset_x: f32,
     pub shadow_offset_y: f32,

zshell-img-tools/src/effects.rs

@@ -5,15 +5,15 @@ use tiny_skia::{
 };
 
 pub fn apply_effects(img: RgbaImage, cfg: &EffectsConfig) -> RgbaImage {
-    let img = if cfg.rounded_corners {
+    let img = if cfg.rounding {
-        apply_rounded_corners(img, cfg.corner_radius)
+        apply_rounding(img, cfg.radius)
     } else {
         img
     };
-    if cfg.drop_shadow {
+    if cfg.shadow {
-        apply_drop_shadow(
+        apply_shadow(
             img,
-            cfg.shadow_blur_radius,
+            cfg.shadow_blur,
             cfg.shadow_offset_x,
             cfg.shadow_offset_y,
             cfg.shadow_color,
@@ -23,7 +23,7 @@ pub fn apply_effects(img: RgbaImage, cfg: &EffectsConfig) -> RgbaImage {
     }
 }
 
-pub fn apply_rounded_corners(img: RgbaImage, radius: f32) -> RgbaImage {
+pub fn apply_rounding(img: RgbaImage, radius: f32) -> RgbaImage {
     let (w, h) = img.dimensions();
     let mut mask = Pixmap::new(w, h).expect("mask pixmap");
     let path = rounded_rect_path(0.0, 0.0, w as f32, h as f32, radius);
@@ -47,16 +47,16 @@ pub fn apply_rounded_corners(img: RgbaImage, radius: f32) -> RgbaImage {
     pixmap_to_rgba_image(pixmap)
 }
 
-pub fn apply_drop_shadow(
+pub fn apply_shadow(
     img: RgbaImage,
-    blur_radius: f32,
+    blur: f32,
     offset_x: f32,
     offset_y: f32,
     // blur_passes: u32,
     shadow_color: [u8; 4],
 ) -> RgbaImage {
     let (iw, ih) = img.dimensions();
-    let br = blur_radius.ceil() as u32;
+    let br = blur.ceil() as u32;
     let bp = 1;
     // Original idea
     // let spread = br * bp;

zshell-img-tools/src/main.rs

@@ -7,10 +7,10 @@ use std::process::{Command, Stdio};
 
 #[derive(Default)]
 struct CliOverrides {
-    rounded_corners: Option<bool>,
+    rounding: Option<bool>,
-    corner_radius: Option<f32>,
+    radius: Option<f32>,
-    drop_shadow: Option<bool>,
+    shadow: Option<bool>,
-    shadow_blur_radius: Option<f32>,
+    shadow_blur: Option<f32>,
     shadow_offset_x: Option<f32>,
     shadow_offset_y: Option<f32>,
     // Accepted as four comma-separated u8 values, e.g. `255,0,0,200`
@@ -57,13 +57,10 @@ fn extract_image_path() -> Option<String> {
 }
 
 fn main() {
-    let image_path = extract_image_path();
+    if let Some(path) = extract_image_path() && let Err(e) = run() {
-    if let Some(path) = image_path {
-        if let Err(e) = run() {
         eprintln!("Error: {}", e);
         push_image(&path).ok();
     }
-    }
 }
 
 fn run() -> Result<()> {
@@ -79,26 +76,23 @@ fn run() -> Result<()> {
             "--image" => {
                 image_path = Some(next_arg(&args, &mut i, "--image")?);
             }
-            "--corner" => {
+            "--rounding" => {
-                let val = next_arg(&args, &mut i, "--corners")?;
+                let val = next_arg(&args, &mut i, "--rounding")?;
-                overrides.rounded_corners = Some(parse_bool(&val)?);
+                overrides.rounding = Some(parse_bool(&val)?);
             }
-            "--corner-radius" => {
+            "--radius" => {
-                let val = next_arg(&args, &mut i, "--corner-radius")?;
+                let val = next_arg(&args, &mut i, "--radius")?;
-                overrides.corner_radius = Some(
+                overrides.radius = Some(val.parse::<f32>().context("--radius must be a number")?);
-                    val.parse::<f32>()
-                        .context("--corner-radius must be a number")?,
-                );
             }
             "--shadow" => {
                 let val = next_arg(&args, &mut i, "--shadow")?;
-                overrides.drop_shadow = Some(parse_bool(&val)?);
+                overrides.shadow = Some(parse_bool(&val)?);
             }
             "--shadow-blur" => {
                 let val = next_arg(&args, &mut i, "--shadow-blur")?;
-                overrides.shadow_blur_radius = Some(
+                overrides.shadow_blur = Some(
                     val.parse::<f32>()
-                        .context("--shadow-blur-radius must be a number")?,
+                        .context("--shadow-blur must be a number")?,
                 );
             }
             "--shadow-offset-x" => {
@@ -132,21 +126,19 @@ fn run() -> Result<()> {
     let image_path = image_path.context("Missing --image <path>")?;
 
     // Check if any arguments were provided
-    let cli_args_provided = overrides.rounded_corners.is_some()
+    let cli_args_provided = overrides.rounding.is_some()
-        || overrides.corner_radius.is_some()
+        || overrides.radius.is_some()
-        || overrides.drop_shadow.is_some()
+        || overrides.shadow.is_some()
-        || overrides.shadow_blur_radius.is_some()
+        || overrides.shadow_blur.is_some()
         || overrides.shadow_offset_x.is_some()
         || overrides.shadow_offset_y.is_some()
         || overrides.shadow_color.is_some();
     let mut effects = if cli_args_provided {
         // If all args provided
-        let rounded_corners = overrides.rounded_corners.context("Missing --corner")?;
+        let rounding = overrides.rounding.context("Missing --rounding")?;
-        let corner_radius = overrides.corner_radius.context("Missing --corner-radius")?;
+        let radius = overrides.radius.context("Missing --radius")?;
-        let drop_shadow = overrides.drop_shadow.context("Missing --shadow")?;
+        let shadow = overrides.shadow.context("Missing --shadow")?;
-        let shadow_blur_radius = overrides
+        let shadow_blur = overrides.shadow_blur.context("Missing --shadow-blur")?;
-            .shadow_blur_radius
-            .context("Missing --shadow-blur")?;
         let shadow_offset_x = overrides
             .shadow_offset_x
             .context("Missing --shadow-offset-x")?;
@@ -155,10 +147,10 @@ fn run() -> Result<()> {
             .context("Missing --shadow-offset-y")?;
         let shadow_color = overrides.shadow_color.context("Missing --shadow-color")?;
         config::EffectsConfig {
-            rounded_corners,
+            rounding,
-            corner_radius,
+            radius,
-            drop_shadow,
+            shadow,
-            shadow_blur_radius,
+            shadow_blur,
             shadow_offset_x,
             shadow_offset_y,
             shadow_color,
@@ -171,8 +163,8 @@ fn run() -> Result<()> {
 
     // if scale is set do
     if let Some(scale) = scale.filter(|&s| s != 1.0) {
-        effects.corner_radius *= scale;
+        effects.radius *= scale;
-        effects.shadow_blur_radius *= scale;
+        effects.shadow_blur *= scale;
         effects.shadow_offset_x *= scale;
         effects.shadow_offset_y *= scale;
     }