Tie aware mapping to prevent 10% jumps

Author: subhojeet-roy

cosmic-applet-battery/src/app.rs

@@ -98,6 +98,7 @@ struct CosmicBatteryApplet {
     zbus_connection: Option<zbus::Connection>,
     dragging_screen_brightness: bool,
     dragging_kbd_brightness: bool,
+    last_coarse_k: Option<i32>,
 }
 
 impl CosmicBatteryApplet {
@@ -135,18 +136,62 @@ impl CosmicBatteryApplet {
             format!("cosmic-applet-battery-level-{battery_percent}-{limited}{charging}symbolic",);
     }
 
+    #[inline]
+    fn raw_from_step_index(k: i32, max_raw: i32) -> i32 {
+        // round(k * max / 20) using integer math
+        ((k * max_raw + 10) / 20)
+    }
+
+    /// Resolve rung k for a given raw on coarse panels (max<=20) in a tie-aware way.
+    /// If multiple rungs map to the same raw, use the last displayed rung to keep
+    /// GUI steps monotonic in 5% increments (no 10% jumps).
+    fn resolve_rung_tie_aware(&self, raw: i32, max_raw: i32) -> i32 {
+        // Exact matches: all k s.t. forward map equals this raw
+        let mut ks: Vec<i32> = (0..=20)
+            .filter(|&k| Self::raw_from_step_index(k, max_raw) == raw)
+            .collect();
+
+        if ks.is_empty() {
+            // Fallback to nearest k
+            let mut best_k = 0;
+            let mut best_d = i32::MAX;
+            for k in 0..=20 {
+                let d = (Self::raw_from_step_index(k, max_raw) - raw).abs();
+                if d < best_d {
+                    best_d = d;
+                    best_k = k;
+                }
+            }
+            return best_k;
+        }
+        if ks.len() == 1 || self.last_coarse_k.is_none() {
+            return ks[0];
+        }
+
+        let prev = self.last_coarse_k.unwrap();
+        let k_lo = ks[0];
+        let k_hi = *ks.last().unwrap();
+        // Entering tie from below -> lower first; from above -> higher first
+        if prev < k_lo { return k_lo; }
+        if prev == k_lo { return k_hi; }   // stuck raw, next upward step
+        if prev > k_hi { return k_hi; }
+        if prev == k_hi { return k_lo; }   // stuck raw, next downward step
+        k_lo
+    }
+
+
     fn screen_brightness_percent(&self) -> Option<f64> {
-        let raw = self.screen_brightness? as i64;
-        let max = self.max_screen_brightness?.max(1) as i64;
+        let raw = self.screen_brightness? as i32;
+        let max = self.max_screen_brightness?.max(1) as i32;
         if max <= 20 {
-            // Matching brightness calculation logic from cosmic-osd and cosmic-settings-daemon
-            let mut k = (raw * 20 + max / 2) / max;
-            if k < 0 { k = 0; }
-            if k > 20 { k = 20; }
+            // TIE-AWARE: invert daemon setpoints with prev-k memory
+            let k = self.resolve_rung_tie_aware(raw.max(0), max);
             let p = if k == 0 { 1 } else { 5 * k };
-            Some((p as f64) / 100.0)
+            Some(p as f64 / 100.0)
         } else {
-            let p = ((raw * 100 + max / 2) / max).clamp(1, 100) as f64;
+            // Fine panels: exact integer percent with 1% floor
+            let p = (((raw as i64) * 100 + (max as i64) / 2) / (max as i64))
+                .clamp(1, 100) as f64;
             Some(p / 100.0)
         }
     }
@@ -265,6 +310,15 @@ impl cosmic::Application for CosmicBatteryApplet {
                     brightness
                 };
                 self.screen_brightness = Some(snapped);
+                // Maintain tie-aware rung memory so GUI steps are 5% even if raw repeats
+                if let Some(max) = self.max_screen_brightness {
+                    if max > 0 && max <= 20 {
+                        let k = self.resolve_rung_tie_aware(snapped.max(0), max.max(1));
+                        self.last_coarse_k = Some(k);
+                    } else {
+                        self.last_coarse_k = None;
+                    }
+                }
                 if !self.dragging_screen_brightness {
                     self.dragging_screen_brightness = true;
                     self.update_display();
@@ -484,11 +538,24 @@ impl cosmic::Application for CosmicBatteryApplet {
                 }
                 settings_daemon::Event::MaxDisplayBrightness(max_brightness) => {
                     self.max_screen_brightness = Some(max_brightness);
+                    if max_brightness > 20 {
+                        // Fine panel: no tie memory needed
+                        self.last_coarse_k = None;
+                    }
                 }
                 settings_daemon::Event::DisplayBrightness(brightness) => {
                     if !self.dragging_screen_brightness {
                         self.screen_brightness = Some(brightness);
                     }
+                    // Keep tie-aware rung memory in sync with daemon reports
+                    if let Some(max) = self.max_screen_brightness {
+                        if max <= 20 {
+                            let k = self.resolve_rung_tie_aware(brightness.max(0), max.max(1));
+                            self.last_coarse_k = Some(k);
+                        } else {
+                            self.last_coarse_k = None;
+                        }
+                    }
                 }
             },
             Message::Surface(a) => {