Updated MainWindow class

- Cleaned up crate imports into single line
- Changed default gpu_count to 0 for obvious reasons
- Cleaned up create_provider function
- Added function comment headers
- Cleaned up refresh_cards function (removed unecessary settings fetch, mostly finished row creation, removed uneeded tests)
- Removed most uneeded actions from setup_actions function

Updated Processor class
- Switched to "&str" instead of "&'static str" in constructor, all stored as "String" anyway
- Removed old TODO statement

Updated Property class
- Removed old TODO statement
- Fixed incorrect property name in constructor ("gpu_count" -> "gpu-count")
- Added function comment headers
- Cleaned up some comments
- Added "update_value" function

Updated Provider class
- Fixed incorrect NAME value
- Added missing "provider_type" (i32) property
- Renamed properties to include "-property" if using Property class
- Added check to constructor in case of default or empty Vec input
- Refactored "get_gpu_uuids" function
- Changed "open_settings" return type to use String instead of &str (easier for passing)
- Added "update_property_value" function, for updating Property class objects internal fields

Updated MainWindow UI file
- Removed uneeded menu options
- Moved app and nvidia settings buttons into a "Preferences" submenu
- Added "show-separators" property to the left pane list box
- Added "row_activated" signal to the left pane list box, calling "card_selected" function
- Commented out default cards, need to have text here if at 0 cards!

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

Author: Deren Vural

src/mainwindow/imp.rs

@@ -29,9 +29,7 @@ use glib::{clone, Object};
 use std::cell::RefMut;
 
 // Modules
-use crate::{provider, settingswindow, APP_ID};
-use provider::Provider;
-use settingswindow::SettingsWindow;
+use crate::{APP_ID, provider::Provider, settingswindow::SettingsWindow};
 
 // GObject wrapper for Property
 glib::wrapper! {
@@ -243,15 +241,6 @@ impl MainWindow {
      * have a single globally accessible action instead, we call add_action on our application instead.
      */
     fn setup_actions(&self) {
-        /*
-        let action_close = SimpleAction::new("close", None);
-        action_close.connect_activate(clone!(@weak self as window => move |_, _| {
-            window.close();
-        }));
-        self.add_action(&action_close);
-        actions.add_action(&action_close);
-        */
-
         // Create action from key "open_nvidia_settings" and add to action group "win"
         let open_nvidia_settings: SimpleAction = SimpleAction::new("open_nvidia_settings", None);
         open_nvidia_settings.connect_activate(clone!(@weak self as window => move |_, _| {
@@ -311,70 +300,6 @@ impl MainWindow {
         self.add_action(&open_nvidia_settings);
 
         /*
-        // Create action from key "subprocess" and add to action group "win"
-        let subprocess: SimpleAction = SimpleAction::new("subprocess", None);
-        subprocess.connect_activate(clone!(@weak self as window => move |_, _| {
-            match subprocess::exec_communicate(
-                &[
-                    OsStr::new("nvidia-settings"),
-                    OsStr::new("-q"),
-                    OsStr::new("GpuUUID"),
-                    OsStr::new("-t"),
-                ],
-                None::<&gio::Cancellable>,
-            ) {
-                Ok(return_val) => match return_val {
-                    (None, None) => println!("no stdout or stderr, something went really wrong..."),
-                    (None, Some(stderr_buffer)) => match std::str::from_utf8(&stderr_buffer) {
-                        Ok(stderr_buffer_contents) => {
-                            println!("Process failed with error: {}", stderr_buffer_contents)
-                        }
-                        Err(err) => panic!("{}", err),
-                    },
-                    (Some(stdout_buffer), None) => match std::str::from_utf8(&stdout_buffer) {
-                        Ok(stdout_buffer_contents) => {
-                            println!("Process suceeded, returning: `{}`", stdout_buffer_contents)
-                        }
-                        Err(err) => panic!("{}", err),
-                    },
-                    (Some(stdout_buffer), Some(stderr_buffer)) => {
-                        match std::str::from_utf8(&stdout_buffer) {
-                            Ok(stdout_buffer_contents) => match std::str::from_utf8(&stderr_buffer) {
-                                Ok(stderr_buffer_contents) => println!(
-                                    "Process suceeded, returning: `{}` but with error: `{}`",
-                                    stdout_buffer_contents, stderr_buffer_contents
-                                ),
-                                Err(err) => panic!("{}", err),
-                            },
-                            Err(err) => panic!("{}", err),
-                        }
-                    }
-                },
-                Err(err) => println!("something went wrong: {}", err),
-            };
-        }));
-        self.add_action(&subprocess);
-
-        // Create action from key "processor" and add to action group "win"
-        let processor: SimpleAction = SimpleAction::new("processor", None);
-        processor.connect_activate(clone!(@weak self as window => move |_, _| {
-            let p: Processor = Processor::new("nvidia-settings", "-q GpuUUID -t");
-
-            //NOTE: Leaving this here for future use..
-            //p.set_property("base-call", "nvidia-settings");
-            //p.set_property("call", "nvidia-settings");
-            //p.set_property("tail-call", "t");
-
-            match p.process() {
-                Ok(output) => match output {
-                    Some(valid_output) => println!("Process suceeded, returning: `{}`", valid_output),
-                    None => println!("Process encountered an unknown error.."),
-                },
-                Err(err) => println!("Process encountered an error, returning: `{}`", err),
-            }
-        }));
-        self.add_action(&processor);
-
         // Create action from key "formatter_and_property" and add to action group "win"
         let formatter_and_property: SimpleAction =
             SimpleAction::new("formatter_and_property", None);
@@ -597,58 +522,6 @@ impl MainWindow {
             }
         }));
         self.add_action(&formatter_and_property);
-
-        // Create action from key "providers" and add to action group "win"
-        let providers: SimpleAction = SimpleAction::new("providers", None);
-        providers.connect_activate(clone!(@weak self as window => move |_, _| {
-            let _gpu_count: i32 = 1;
-
-            // SETTINGS
-            let _settings_prov: Provider = Provider::new(|| {
-                vec![
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"), "utilization.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"), "temperature.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"), "memory.used,memory.total", "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"), "fan.speed",                "", &Formatter::new(), &1),
-                ]
-            }, 0);
-
-            // SMI
-            let _smi_prov: Provider = Provider::new(|| {
-                vec![
-                    Property::new(&Processor::new("nvidia-smi", "--query-gpu=gpu_name --format=csv,noheader"), "utilization.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-smi", "--query-gpu=gpu_name --format=csv,noheader"), "temperature.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-smi", "--query-gpu=gpu_name --format=csv,noheader"), "memory.used,memory.total", "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-smi", "--query-gpu=gpu_name --format=csv,noheader"), "fan.speed",                "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-smi", "--query-gpu=gpu_name --format=csv,noheader"), "power.draw",               "", &Formatter::new(), &1),
-                ]
-            }, 1);
-
-            // SETTINGS & SMI
-            let _both_prov: Provider = Provider::new(|| {
-                vec![
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"),                         "utilization.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"),                         "temperature.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"),                         "memory.used,memory.total", "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-settings", "-q GpuUUID -t"),                         "fan.speed",                "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("nvidia-smi", "--query-gpu=gpu_name --format=csv,noheader"), "power.draw",               "", &Formatter::new(), &1),
-                ]
-            }, 2);
-
-            // OPTIMUS
-            let _optimus_prov: Provider = Provider::new(|| {
-                vec![
-                    Property::new(&Processor::new("optirun", "nvidia-smi --query-gpu=gpu_name --format=csv,noheader"), "utilization.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("optirun", "nvidia-smi --query-gpu=gpu_name --format=csv,noheader"), "temperature.gpu",          "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("optirun", "nvidia-smi --query-gpu=gpu_name --format=csv,noheader"), "memory.used,memory.total", "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("optirun", "nvidia-smi --query-gpu=gpu_name --format=csv,noheader"), "fan.speed",                "", &Formatter::new(), &1),
-                    Property::new(&Processor::new("optirun", "nvidia-smi --query-gpu=gpu_name --format=csv,noheader"), "power.draw",               "", &Formatter::new(), &1),
-                ]
-            }, 3);
-        }));
-        self.add_action(&providers);
-
-        //self.emit_activate_focus()
         */
 
         let open_app_settings: SimpleAction = SimpleAction::new("open_app_settings", None);

src/mainwindow/mod.rs

@@ -68,10 +68,10 @@ impl Processor {
      * Notes:
      *
      */
-    pub fn new(base_call: &'static str, tail_call: &'static str) -> Self {
+    pub fn new(base_call: &str, tail_call: &str) -> Self {
         let obj: Processor = Object::new(&[]).expect("Failed to create `Processor`");
 
-        // TODO: set properties
+        // Set properties
         obj.set_property("base-call", base_call.to_string());
         obj.set_property("call", base_call.to_string().clone());
         obj.set_property("tail-call", tail_call.to_string());

src/processor/mod.rs

@@ -81,16 +81,32 @@ impl Property {
     ) -> Self {
         let obj: Property = Object::new(&[]).expect("Failed to create `Property`.");
 
-        // TODO: set properties
+        // Set properties
         obj.set_property("processor", processor);
         obj.set_property("call-extension", call_extension.to_string());
         obj.set_property("icon", icon.to_string());
         obj.set_property("formatter", formatter);
-        obj.set_property("gpu_count", gpu_count);
+        obj.set_property("gpu-count", gpu_count);
 
         obj
     }
 
+    /*
+     * Name:
+     * parse
+     *
+     * Description:
+     *
+     *
+     * Made:
+     * 06/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
     // Parsing
     //https://doc.rust-lang.org/std/primitive.array.html
     //https://www.tutorialspoint.com/rust/rust_array.htm
@@ -104,7 +120,7 @@ impl Property {
 
         // For each GPU
         for i in 0..self.property::<i32>("gpu-count") {
-            // format properties using formatter and add to return values
+            // Format properties using formatter and add to return values
             let formatter = self.property::<Formatter>("formatter");
             match formatter.format(values.get(i as usize).unwrap().clone(), func) {
                 Some(result) => results.push(result),
@@ -115,9 +131,47 @@ impl Property {
         Some(results)
     }
 
+    /*
+     * Name:
+     * get_call_extension
+     *
+     * Description:
+     * Get the call extension property
+     *
+     * Made:
+     * 06/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
     pub fn get_call_extension(&self) -> String {
+        // Return the call-extension property
         self.property::<String>("call-extension")
     }
+
+    /*
+     * Name:
+     * update_value
+     *
+     * Description:
+     * Update a property with a new value
+     *
+     * Made:
+     * 29/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    pub fn update_value<T: ToValue>(&self, property_name: &str, value: T) {
+        // Update property with new value
+        self.set_property(property_name, value);
+    }
 }
 
 /*

src/property/mod.rs

@@ -34,13 +34,14 @@ pub struct Provider {
     memory_usage: Cell<Property>,
     fan_speed: Cell<Property>,
     power_usage: Cell<Property>,
+    provider_type: Cell<i32>,
 }
 
 // The central trait for subclassing a GObject
 #[glib::object_subclass]
 impl ObjectSubclass for Provider {
     //Crate+Obj to avoid collisions
-    const NAME: &'static str = "NvidiaMonitorRustProcessor";
+    const NAME: &'static str = "NvidiaMonitorRustProvider";
     // the actual GObject that will be created
     type Type = super::Provider;
     // Parent GObject we inherit from
@@ -96,6 +97,7 @@ impl ObjectImpl for Provider {
                 glib::ParamSpecObject::builder("memory-usage-property", glib::Type::OBJECT).build(),
                 glib::ParamSpecObject::builder("fan-speed-property", glib::Type::OBJECT).build(),
                 glib::ParamSpecObject::builder("power-usage-property", glib::Type::OBJECT).build(),
+                glib::ParamSpecInt::builder("provider-type").build(),
             ]
         });
 
@@ -125,37 +127,43 @@ impl ObjectImpl for Provider {
         //println!("setting: {:?}", pspec.name());//TEST
 
         match pspec.name() {
-            "utilization" => {
+            "utilization-property" => {
                 let input_utilization_property = value
                     .get()
                     .expect("The value needs to be of type `Property`.");
                 self.utilization.replace(input_utilization_property);
             }
-            "temperature" => {
+            "temperature-property" => {
                 let input_temperature_property = value
                     .get()
                     .expect("The value needs to be of type `Property`.");
                 self.temperature.replace(input_temperature_property);
             }
-            "memory-usage" => {
+            "memory-usage-property" => {
                 let input_memory_usage_property = value
                     .get()
                     .expect("The value needs to be of type `Property`.");
                 self.memory_usage.replace(input_memory_usage_property);
             }
-            "fan-speed" => {
+            "fan-speed-property" => {
                 let input_fan_speed_property = value
                     .get()
                     .expect("The value needs to be of type `Property`.");
                 self.fan_speed.replace(input_fan_speed_property);
             }
-            "power-usage" => {
+            "power-usage-property" => {
                 let input_power_usage_property = value
                     .get()
                     .expect("The value needs to be of type `Property`.");
                 self.power_usage.replace(input_power_usage_property);
             }
-            _ => unimplemented!(), //TODO
+            "provider-type" => {
+                let input_provider_type_property = value
+                    .get()
+                    .expect("The value needs to be of type `i32`.");
+                self.provider_type.replace(input_provider_type_property);
+            }
+            _ => panic!("Property `{}` does not exist..", pspec.name())
         }
     }
 
@@ -179,46 +187,54 @@ impl ObjectImpl for Provider {
         //println!("getting: {:?}", pspec.name());//TEST
 
         match pspec.name() {
-            "utilization" => {
+            "utilization-property" => {
                 //TODO: this seems ridiculous..
                 let value = self.utilization.take();
 
                 self.utilization.set(value.clone());
 
                 value.to_value()
             }
-            "temperature" => {
+            "temperature-property" => {
                 //TODO: this seems ridiculous..
                 let value = self.temperature.take();
 
                 self.temperature.set(value.clone());
 
                 value.to_value()
             }
-            "memory-usage" => {
+            "memory-usage-property" => {
                 //TODO: this seems ridiculous..
                 let value = self.memory_usage.take();
 
                 self.memory_usage.set(value.clone());
 
                 value.to_value()
             }
-            "fan-speed" => {
+            "fan-speed-property" => {
                 //TODO: this seems ridiculous..
                 let value = self.fan_speed.take();
 
                 self.fan_speed.set(value.clone());
 
                 value.to_value()
             }
-            "power-usage" => {
+            "power-usage-property" => {
                 //TODO: this seems ridiculous..
                 let value = self.power_usage.take();
 
                 self.power_usage.set(value.clone());
 
                 value.to_value()
             }
+            "provider-type" => {
+                //TODO: this seems ridiculous..
+                let value = self.provider_type.take();
+
+                self.provider_type.set(value.clone());
+
+                value.to_value()
+            }
             _ => unimplemented!(), //TODO
         }
     }