Updated Properties

New property "Memory Controller Utilization", cleaned up property labels and nvidia-settings specific fixes

Updated MainWindow class
- Updated create_providers() function to handle new Processor struct member "middle_call"
- Updated create_providers() function to handle a new property - memory controller utilization
- Updated create_providers() function to handle nvidia-settings (provider_type=1) properties properly
- Commented out "GPUCurrentFanSpeedRPM" property (nvidia-settings) as this is queried without a uuid and instead all fans are given (needs testing with multi-gpu setup)

Updated GpuPage class
- Updated test values to change depending on provider type (needed to test nvidia-settings properties as they differ quite a bit)
- Updated the callback function to create labels of appropriate size!
- Updated some comments

Updated Processor class:
- Added a "middle_call" struct member to allow handling of nvidia-settings properties which are more complicated
- Updated gtk properties functions accordingly
- Update process() function accordingly
- Updated process() function to handle the new size of call_stack (3)
- Updated process() function to give some output on invalid_size
- Updated default trait to handle new struct member

Updated Property class:
- Updated parse function to handle strange ID's: "GPUUtilization" covers gpu and memory controller for nvidia-settings and doesn't need cleaned, and "gpu_name" doesn't need cleaned
- Updated default trait to handle new Processor struct member

Updated Provider class:
- Updated get_gpu_uuids() function to handle new Processor struct member
- Updated get_gpu_uuids() function to handle new memory controller utilization property
- Disabled "GPUCurrentFanSpeedRPM" property (nvidia-settings) as this is queried without a uuid and instead all fans are given (needs testing with multi-gpu setup)
- Added commented encoder/decoder util properties as these should be next (but may need external program)

Updated Formatter class:
- Updated format() function to have new parameter "clean", specifying if cleanup should happen here or in the func that was given to the formatter. This is needed for some nvidia-settings properties

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

Author: Deren Vural

src/formatter/mod.rs

@@ -117,63 +117,93 @@ impl Formatter {
      * Notes:
      *
      */
-    pub fn format(self, value: String) -> Option<String> {
+    pub fn format(self, value: String, clean: bool) -> 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(&'.')
-                }
-            })
-            .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.is_empty() {
-                            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));
+        // Apply cleaning if required
+        if clean {
+            // 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(&'.')
+                    }
+                })
+                .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.is_empty() {
+                                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
+                            // Return final result
+                            result
+                        }
+                        None => panic!("Missing formatting function!"),
                     }
-                    None => panic!("Missing formatting function!"),
+                }
+                Err(err) => {
+                    // Catch any errors..
+                    println!("Not a valid number: {}", err);
+
+                    None
                 }
             }
-            Err(err) => {
-                // Catch any errors..
-                println!("Not a valid number: {}", err);
+        } else {
+            // 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)
+                    //===
+                    let mut _params: Vec<(String, String)> = vec![]; //mut
+                    //TODO: ???
+                    //
+                    //===
 
-                None
+                    // Use function
+                    let result: Option<String>;
+                    if !_params.is_empty() {
+                        result = func(vec![value], Some(_params));
+                    } else {
+                        result = func(vec![value], None);
+                    }
+                    // Return it!
+                    self.imp().func.set(Some(func));
+
+                    // Return final result
+                    result
+                }
+                None => panic!("Missing formatting function!"),
             }
         }
     }

src/gpu_page/mod.rs

@@ -165,14 +165,29 @@ impl GpuPage {
                 // TODO: Load config of gpu (use uuid as ID)
                 // TODO: needs to be a vector as may bed of variable size..
                 //let statistics: Vec<&str> = load_json_settings(&self.property("uuid"));//array?vector?json-type object?
-                let statistics_data: Vec<&str> = vec![
-                    "util",
-                    "temp",
-                    "memory_usage",
-                    "memory_total",
-                    "fan_speed",
-                    "power_usage",
-                ];
+                let statistics_data: Vec<&str>;//TEST
+                match self.property::<Provider>("provider").property::<i32>("provider-type") {
+                    1 => {
+                        statistics_data = vec![
+                            "util",
+                            "temp",
+                            "memory_usage",
+                            "memory_total",
+                            "mem_ctrl_util",
+                        ];
+                    }
+                    _ => {
+                        statistics_data = vec![
+                            "util",
+                            "temp",
+                            "memory_usage",
+                            "memory_total",
+                            "mem_ctrl_util",
+                            "fan_speed",
+                            "power_usage",
+                        ];
+                    }
+                }
                 let statistics_store: Arc<Mutex<Vec<&str>>> = Arc::new(Mutex::new(statistics_data));
 
                 // Edit button
@@ -220,38 +235,94 @@ impl GpuPage {
                     //child_manager.set_property("outline-width", 1);
                     //child_manager.set_property("border-radius", 3);
 
-                    // Fetch layout manager for this child grid
+                    // Fetch layout manager for this (grid) child
                     let internal_grid_manager = new_grid.layout_manager().expect("Fuck..");
 
-                    // Build label & add to grid
+                    // Decide on title label size
+                    let space: i32;
+                    let pretty_label: &str;
+                    match statistic.to_owned() {
+                        "util" => {
+                            pretty_label = "GPU Utilization";
+                            space = 5
+                        },
+                        "mem_ctrl_util" => {
+                            pretty_label = "Memory Controller Utilization";
+                            space = 5
+                        },
+                        "encoder_util" => {
+                            pretty_label = "Encoder Utilization";
+                            space = 5
+                        },
+                        "decoder_util" => {
+                            pretty_label = "Decoder Utilization";
+                            space = 5
+                        },
+                        "fan_speed" => {
+                            pretty_label = "Fan Speed";
+                            space = 5
+                        },
+                        "temp" => {
+                            pretty_label = "Temperature";
+                            space = 5
+                        },
+                        "memory_usage" => {
+                            pretty_label = "Memory Usage";
+                            space = 8
+                        },
+                        "memory_total" => {
+                            pretty_label = "Memory Total";
+                            space = 8
+                        },
+                        "power_usage" => {
+                            pretty_label = "Power Usage";
+                            space = 8
+                        },
+                        _ => {
+                            pretty_label = statistic;
+                            space = 5
+                        },
+                    }
+
+                    // Build title label & add to grid
                     let new_title: String = String::from(statistic.to_owned()) + "_label";
                     let new_title_label: Label = Label::builder()
-                        .label(statistic)
+                        .label(pretty_label)
                         .name(&new_title)
                         .hexpand(true)
                         .hexpand_set(true)
                         .halign(Align::Center)
                         //.valign(Align::Center)
                         .margin_top(12)
                         .margin_bottom(12)
+                        .width_chars(space)
                         .build();
                     new_grid.attach(&new_title_label, 0, 0, 1, 1);
 
-                    // Set layout properties of child
+                    // Set layout properties of (title label) child
                     let title_manager: LayoutChild = internal_grid_manager.layout_child(&new_title_label);
                     title_manager.set_property("row-span", 1);
 
-                    // Build label & add to grid
+                    // Decide on content label size
+                    let space: i32;
+                    match statistic.to_owned() {
+                        "util" | "fan_speed" | "temp" => space = 5,
+                        "memory_usage" | "memory_total" => space = 8,
+                        _ => space = 5,
+                    }
+
+                    // Build content label & add to grid
                     let new_content: String = String::from(statistic.to_owned());
                     let new_content_label: Label = Label::builder()
                         .label("")
                         .name(&new_content)
                         //.halign(Align::End)
                         //.valign(Align::Center)
+                        .width_chars(space)
                         .build();
                     new_grid.attach(&new_content_label, 1, 0, 1, 1);
 
-                    // Set layout properties of child
+                    // Set layout properties of (content label) child
                     let content_manager: LayoutChild = internal_grid_manager.layout_child(&new_content_label);
                     content_manager.set_property("row-span", 1);