Major Refactor

Replacing a lot of copypasta code from the extension with improved versions! A lot of work done on the displaying and notably *updating* of stats.

Updated MainWindow UI
- Removed the last of the example menu buttons

Updated CSS
- Added outline/border to the GpuPage class grid objects

Updated MainWindow class
- Moved TemperatureUnit enum here from Formatter class
- Moved get_setting(), update_setting() and create_provider() functions to separate MainWindow trait, leaving only the callbacks in the orginal (clean separation of normal functions vs callbacks)
- Added `self` param to create_provider() function
- Updated to finish memory, fan and temperature closures for Formatter objects
- Updated create_gpu_page() function to use reference to a Provider as a param
- Updated refresh_cards() function to properly grab and pass Provider object
- Removed now unecessary code examples from setup_actions() function

Updated GpuPage class:
- Changed provider struct member to a Cell<Option<Provider>> instead of Rc<RefCell<Provider>>
- Updated build process for page in setup_widgets() function
- Now using the parent Provider, this is important to ensure the Property objects available from the Provider and properties being shown are the same (lots of Arc+Mutex)
- Updated Default trait for new struct members

Updated Processor class:
- Removed call and tail_call struct member variables, replaced with start_call and end_call strings
- This allows proper building of program call in process() function
- Updated Default trait for new struct members

Updated Property class:
- Removed call_extension, icon and gpu_count struct member variables, replaced with id (String)
- Replaced parse() function with full version, now parses info from ONE GPU and is run in a loop by whatever controls it
- Updated Default trait for new struct members

Updated Provider class:
- Replaced explicit properties with a properties struct member, which stores a list of Property objects in a RefCell
- This allows custom lists of properties, which will make adding customization in later *much* easier
- Updated get_gpu_data() function to handle dynamic lists of properties
- Removed update_property_value() function

Updated Formatter class:
- Cleaned up imports
- Added settings object and func closure to struct members
- Added get_setting() function to Formatter trait
- Added constructed() function to ObjectImpl trait to enable loading settings (it calls setup_settings())
- Added the new func struct member to constructor
- Added setup_settings() function
- Replaced format() function with full version, now grabs any formatting settings e.g. temperature unit and passes to func when calling
- Updated Default trait for new struct members

Signed-off-by: Deren Vural <[email protected]>

Author: Deren Vural

src/formatter/imp.rs

@@ -19,15 +19,21 @@
  */
 
 // Imports
-use glib::{once_cell::sync::Lazy, ParamSpec, Value};
-use gtk::{glib, subclass::prelude::*};
+use adwaita::{gio, glib, prelude::*, subclass::prelude::*};
+use std::cell::Cell;
+use gio::Settings;
+use glib::{once_cell::sync::OnceCell, once_cell::sync::Lazy, ParamSpec, Value, FromVariant};
+use gtk::{subclass::prelude::*};
 
 // Modules
 //
 
 /// Object holding the State and any Template Children
 #[derive(Default)]
-pub struct Formatter;
+pub struct Formatter {
+    pub settings: OnceCell<Settings>,
+    pub func: Cell<Option<fn(Vec<String>, Option<Vec<(String, String)>>) -> Option<String>>>
+}
 
 /// The central trait for subclassing a GObject
 #[glib::object_subclass]
@@ -40,6 +46,34 @@ impl ObjectSubclass for Formatter {
     type ParentType = gtk::Widget;
 }
 
+impl Formatter {
+    /**
+     * Name:
+     * get_setting
+     *
+     * Description:
+     * Generic function for getting setting value
+     *
+     * Made:
+     * 30/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    pub fn get_setting<T: FromVariant>(&self, name: &str) -> T {
+        // Return the value of the property
+        match self.settings.get() {
+            Some(settings) => {
+                settings.get::<T>(name)
+            },
+            None => panic!("`settings` should be set in `setup_settings`.")
+        }
+    }
+}
+
 /**
  * Trait Name:
  * ObjectImpl
@@ -57,6 +91,30 @@ impl ObjectSubclass for Formatter {
  *
  */
 impl ObjectImpl for Formatter {
+    /**
+     * Name:
+     * constructed
+     *
+     * Description:
+     * Called during construction, allows calling setup functions
+     *
+     * Made:
+     * 18/11/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    fn constructed(&self, obj: &Self::Type) {
+        // Call "constructed" on parent
+        self.parent_constructed(obj);
+
+        // Setup
+        obj.setup_settings();
+    }
+
     /**
      * Name:
      * properties

src/formatter/mod.rs

@@ -22,11 +22,12 @@
 mod imp;
 
 // Imports
+use adwaita::{gio, glib};
 use glib::Object;
-use gtk::glib;
-
+use gio::Settings;
+use gtk::subclass::prelude::*;
 // Modules
-//
+use crate::{APP_ID};
 
 // GObject wrapper for Formatter
 glib::wrapper! {
@@ -68,52 +69,113 @@ impl Formatter {
      * Notes:
      *
      */
-    pub fn new() -> Self {
-        Object::new(&[]).expect("Failed to create `Formatter`.")
+    pub fn new(func: fn(Vec<String>, Option<Vec<(String, String)>>) -> Option<String>) -> Self {
+        let obj: Formatter = Object::new(&[]).expect("Failed to create `Formatter`.");
+
+        // Set properties
+        obj.imp().func.set(Some(func));
+
+        obj
     }
 
-    pub fn format(
-        self,
-        values: Vec<String>,
-        func: fn(Vec<String>) -> Option<String>,
-    ) -> Option<String> {
-        let mut results: Vec<String> = Vec::new();
-
-        // For each item in input list
-        for i in values {
-            // Remove all non-number characters
-            let cleaned_value: String = i
-                .chars()
-                .filter(|c| {
-                    // check if (base 10) digit
-                    if c.is_digit(10) {
-                        true
-                    } else {
-                        // check if full-stop
-                        c.eq(&'.')
-                    }
-                })
-                .collect();
-
-            // Convert to float
-            match cleaned_value.parse::<f64>() {
-                Ok(parsed_value) => {
-                    // Convert to string
-                    results.push(parsed_value.to_string());
+    /**
+     * Name:
+     * setup_settings
+     *
+     * Description:
+     * Load settings for APP_ID
+     *
+     * Made:
+     * 18/11/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    fn setup_settings(&self) {
+        let settings = Settings::new(APP_ID);
+        self.imp()
+            .settings
+            .set(settings)
+            .expect("`settings` should not be set before calling `setup_settings`.");
+    }
+
+    /*
+     * Name:
+     * format
+     *
+     * Description:
+     * Given some valid string value, remove non-digit chars (excluding points) and apply formatting
+     *
+     * Made:
+     * 12/11/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    pub fn format(self, value: String) -> Option<String> {
+        //println!("FORMATTING");//TEST
+
+        // Remove all non-number characters
+        let cleaned_value: String = value
+            .chars()
+            .filter(|c| {
+                // check if (base 10) digit
+                if c.is_digit(10) {
+                    true
+                } else {
+                    // check if full-stop
+                    c.eq(&'.')
                 }
-                Err(err) => {
-                    // Catch any errors..
-                    println!("Not a valid number: {}", err);
+            })
+            .collect();
+
+        // Convert to float
+        match cleaned_value.parse::<f64>() {
+            Ok(parsed_value) => {
+                // Apply any valid formatting
+                match self.imp().func.take() {
+                    Some(func) => {
+                        // Grab all format info from settings (this is done here to keep in one place)
+                        //===
+                        // Temperature format
+                        let temp_format: i32 = self.imp().get_setting::<i32>("tempformat");
+                        let mut params: Vec<(String, String)> = vec![];
+                        if let 0 = temp_format {
+                            params.push((String::from("tempformat"), String::from("C")));
+                        } else if let 1 = temp_format {
+                            params.push((String::from("tempformat"), String::from("F")));
+                        }
+                        //TODO: ???
+                        //
+                        //===
+
+                        // Use function
+                        let result: Option<String>;
+                        if params.len() > 0 {
+                            result = func(vec![parsed_value.to_string()], Some(params));
+                        } else {
+                            result = func(vec![parsed_value.to_string()], None);
+                        }
+                        // Return it!
+                        self.imp().func.set(Some(func));
+
+                        result
+                    },
+                    None => panic!("Missing formatting function!")
                 }
             }
-        }
+            Err(err) => {
+                // Catch any errors..
+                println!("Not a valid number: {}", err);
 
-        // Check for empty results
-        if !results.is_empty() {
-            // Apply any valid formatting
-            func(results)
-        } else {
-            None
+                None
+            }
         }
     }
 }
@@ -136,6 +198,11 @@ impl Formatter {
  */
 impl Default for Formatter {
     fn default() -> Self {
-        Self::new()
+        let func: fn(Vec<String>, Option<Vec<(String, String)>>) -> Option<String> = |input: Vec<String>, params: Option<Vec<(String, String)>>| {
+            Some(String::from(input.get(0).unwrap()))
+        };
+
+
+        Self::new(func)
     }
 }

src/gpu_page/imp.rs

@@ -26,7 +26,7 @@ use glib::{
     ToValue, Value,
 };
 use gtk::{subclass::prelude::*, CompositeTemplate};
-use std::{cell::Cell, cell::Ref, cell::RefCell, rc::Rc};
+use std::{cell::Cell, sync::Arc};
 
 // Modules
 use crate::provider::Provider;
@@ -38,7 +38,7 @@ pub struct GpuPage {
     pub settings: OnceCell<Settings>,
     uuid: Cell<String>,
     name: Cell<String>,
-    provider: Rc<RefCell<Provider>>,
+    provider: Cell<Option<Provider>>,
 }
 
 /// The central trait for subclassing a GObject
@@ -264,9 +264,9 @@ impl ObjectImpl for GpuPage {
                 value.to_value()
             }
             "provider" => {
-                let value: Ref<Provider> = self.provider.borrow();
+                let value: Option<Provider> = self.provider.take();
 
-                //self.provider.set(value.clone());
+                self.provider.set(value.clone());
 
                 value.to_value()
             }