fix: avoid setting power cap if it was not changed

lact-gui/src/app/root_stack/oc_page/mod.rs

@@ -1,4 +1,5 @@
 mod clocks_frame;
+mod oc_adjustment;
 mod performance_frame;
 mod power_cap_frame;
 mod stats_frame;

lact-gui/src/app/root_stack/oc_page/oc_adjustment/imp.rs

@@ -0,0 +1,27 @@
+use gtk::glib;
+use gtk::subclass::prelude::*;
+use std::rc::Rc;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+#[derive(Default)]
+pub struct OcAdjustment {
+    pub changed: Rc<AtomicBool>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for OcAdjustment {
+    const NAME: &'static str = "OcAdjustment";
+    type Type = super::OcAdjustment;
+    type ParentType = gtk::Adjustment;
+}
+
+impl ObjectImpl for OcAdjustment {}
+
+impl WidgetImpl for OcAdjustment {}
+
+impl AdjustmentImpl for OcAdjustment {
+    fn value_changed(&self) {
+        self.parent_value_changed();
+        self.changed.store(true, Ordering::SeqCst);
+    }
+}

lact-gui/src/app/root_stack/oc_page/oc_adjustment/mod.rs

@@ -0,0 +1,65 @@
+mod imp;
+
+use glib::Object;
+use gtk::{
+    glib::{self},
+    subclass::prelude::*,
+    traits::AdjustmentExt,
+};
+use std::sync::atomic::Ordering;
+use tracing::debug;
+
+glib::wrapper! {
+    pub struct OcAdjustment(ObjectSubclass<imp::OcAdjustment>)
+        @extends gtk::Adjustment, gtk::Widget,
+        @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
+}
+
+impl OcAdjustment {
+    pub fn new(
+        value: f64,
+        lower: f64,
+        upper: f64,
+        step_increment: f64,
+        page_increment: f64,
+        page_size: f64,
+    ) -> Self {
+        let oc_adjustment: Self = Object::builder().build();
+
+        let adjustment = oc_adjustment.imp().obj();
+        adjustment.set_lower(lower);
+        adjustment.set_upper(upper);
+        adjustment.set_step_increment(step_increment);
+        adjustment.set_page_increment(page_increment);
+        adjustment.set_page_size(page_size);
+
+        oc_adjustment.set_initial_value(value);
+
+        oc_adjustment
+    }
+
+    pub fn get_changed_value(&self, filter_zero: bool) -> Option<f64> {
+        let inner = self.imp();
+        let changed = inner.changed.load(Ordering::SeqCst);
+
+        if changed {
+            let value = inner.obj().value();
+
+            if filter_zero && value == 0.0 {
+                None
+            } else {
+                debug!("Value was changed, returning {value}");
+                Some(value)
+            }
+        } else {
+            debug!("Value is unchanged, returning None");
+            None
+        }
+    }
+
+    pub fn set_initial_value(&self, value: f64) {
+        let inner = self.imp();
+        inner.obj().set_value(value);
+        inner.changed.store(false, Ordering::SeqCst);
+    }
+}

lact-gui/src/app/root_stack/oc_page/power_cap_frame.rs

@@ -1,3 +1,4 @@
+use super::oc_adjustment::OcAdjustment;
 use crate::app::root_stack::section_box;
 use gtk::*;
 use gtk::{glib::clone, prelude::*};
@@ -8,7 +9,7 @@ use tracing::error;
 pub struct PowerCapFrame {
     pub container: Box,
     default_cap: Rc<Cell<Option<f64>>>,
-    adjustment: Adjustment,
+    adjustment: OcAdjustment,
 }
 
 impl PowerCapFrame {
@@ -22,7 +23,7 @@ impl PowerCapFrame {
         let label = Label::new(None);
         root_box.append(&label);
 
-        let adjustment = Adjustment::new(0.0, 0.0, 0.0, 1.0, 10.0, 0.0);
+        let adjustment = OcAdjustment::new(0.0, 0.0, 0.0, 1.0, 10.0, 0.0);
 
         adjustment.connect_value_changed(clone!(@strong label => move |adj| {
             let text = format!("{}/{} {}", adj.value().round(), adj.upper(), value_suffix);
@@ -74,7 +75,7 @@ impl PowerCapFrame {
         }
 
         if let Some(power_cap) = power_cap {
-            self.adjustment.set_value(power_cap);
+            self.adjustment.set_initial_value(power_cap);
         } else {
             self.container.set_visible(false);
         }
@@ -83,13 +84,7 @@ impl PowerCapFrame {
     }
 
     pub fn get_cap(&self) -> Option<f64> {
-        // Using match gives a warning that floats shouldn't be used in patterns
-        let cap = self.adjustment.value();
-        if cap == 0.0 {
-            None
-        } else {
-            Some(cap)
-        }
+        self.adjustment.get_changed_value(true)
     }
 
     pub fn connect_cap_changed<F: Fn() + 'static>(&self, f: F) {