Updated Processor Class

- Added docs in comments
- Properly commented traits and functions
- Changed to Cell<String> as custom properties should be stored in Cells (and Strings are nicer)
- Added properties() function to ObjectImpl to register custom GObject properties
- Added set_property() function to ObjectImpl as custom GObject properties mutator
- Added property() function to ObjectImpl as custom GObject properties accessor
- Finished working constructor, calls to set_property() function with args
- Removed test from parse() and removed old version
- Added mutator calls to process() function (finally!)
- Cleaned up comments in mod.rs
- Commented test prints in process() function (will probably need later)

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

Author: Deren Vural

src/processor/imp.rs

@@ -15,22 +15,27 @@
  * Deren Vural
  *
  * Notes:
- *
+ * https://github.com/gtk-rs/gtk4-rs/blob/master/book/src/g_object_properties.md
+ * https://github.com/gtk-rs/gtk4-rs/blob/master/book/listings/g_object_properties/4/custom_button/imp.rs
+ * https://github.com/gtk-rs/gtk4-rs/blob/master/book/listings/g_object_properties/4/custom_button/mod.rs
  */
 
 // Imports
-use gtk::glib;
+use gtk::glib::{ self, ParamSpec, Value };
+use gtk::prelude::*;
 use gtk::subclass::prelude::*;
+use gtk::glib::once_cell::sync::Lazy;
+use std::cell::Cell;
 
-// Object holding the state
+// Object holding the State
 #[derive(Default)]
 pub struct Processor {
-    name: &'static str,
-    //base_call: &'static str,
-    //call: &'static str,
-    //tail_call: &'static str,
+    base_call: Cell<String>,
+    call: Cell<String>,
+    tail_call: Cell<String>,
 }
 
+
 // The central trait for subclassing a GObject
 #[glib::object_subclass]
 impl ObjectSubclass for Processor {
@@ -42,8 +47,172 @@ impl ObjectSubclass for Processor {
     type ParentType = gtk::Widget;
 }
 
-// Trait shared by all GObjects
-impl ObjectImpl for Processor {}
+/*
+ * Trait Name:
+ * ObjectImpl
+ *
+ * Description:
+ * Trait shared by all GObjects
+ *
+ * Made:
+ * 05/10/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ *
+ */
+impl ObjectImpl for Processor {
+    /*
+     * Name:
+     * properties
+     *
+     * Description:
+     * Create list of custom properties for our GObject
+     *
+     * Made:
+     * 05/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     * beware that you need to use kebab-case (https://en.wikipedia.org/wiki/Letter_case#Kebab_case)
+     *
+     * ParamSpec Examples:
+     * glib::ParamSpecString::builder("icon").build(),
+     * glib::ParamSpecUInt::builder("gpu_count").build(),
+     * glib::ParamSpecString::builder("call_extension").build(),
+     * TODO: these are from property class
+     * glib::ParamSpecBoxed::builder("processor").build(),
+     * glib::ParamSpecObject::builder("formatter").build(),
+     */
+    fn properties() -> &'static [ParamSpec] {
+        static PROPERTIES: Lazy<Vec<ParamSpec>> =
+            Lazy::new(|| {
+                vec![
+                    glib::ParamSpecString::builder("base-call").build(),
+                    glib::ParamSpecString::builder("call").build(),
+                    glib::ParamSpecString::builder("tail-call").build(),
+                ]
+            }
+        );
+
+        //println!("PROPERTIES: {:?}", PROPERTIES);//TEST
+        //println!("trying to add `base_call`: {:?}", glib::ParamSpecString::builder("base_call").build());//TEST
+
+        PROPERTIES.as_ref()
+    }
+
+    /*
+     * Name:
+     * set_property
+     *
+     * Description:
+     * Mutator for custom GObject properties
+     *
+     * Made:
+     * 05/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    fn set_property(
+        &self,
+        _obj: &Self::Type,
+        _id: usize,
+        value: &Value,
+        pspec: &ParamSpec,
+    ) {
+        //println!("setting: {:?}", pspec.name());//TEST
+
+        match pspec.name() {
+            "base-call" => {
+                let input_base_call =
+                    value.get().expect("The value needs to be of type `String`.");
+                self.base_call.replace(input_base_call);
+            },
+            "call" => {
+                let input_call =
+                    value.get().expect("The value needs to be of type `String`.");
+                self.call.replace(input_call);
+            },
+            "tail-call" => {
+                let input_tail_call =
+                    value.get().expect("The value needs to be of type `String`.");
+                self.tail_call.replace( input_tail_call);
+            },
+            _ => unimplemented!(),//TODO
+        }
+    }
+
+    /*
+     * Name:
+     * property
+     *
+     * Description:
+     * Accessir for custom GObject properties
+     *
+     * Made:
+     * 05/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &ParamSpec) -> Value {
+        //println!("getting: {:?}", pspec.name());//TEST
+
+        match pspec.name() {
+            "base-call" => {
+                //TODO: this seems ridiculous..
+                let value = self.base_call.take();
 
-// Trait shared by all widgets
+                self.base_call.set(value.clone());
+
+                return value.to_value();
+            },
+            "call" => {
+                //TODO: this seems ridiculous..
+                let value = self.call.take();
+
+                self.call.set(value.clone());
+
+                return value.to_value();
+            },
+            "tail-call" => {
+                //TODO: this seems ridiculous..
+                let value = self.tail_call.take();
+
+                self.tail_call.set(value.clone());
+
+                return value.to_value();
+            },
+            _ => unimplemented!(),//TODO
+        }
+    }
+}
+
+/*
+ * Trait Name:
+ * WidgetImpl
+ *
+ * Description:
+ * Trait shared by all widgets
+ *
+ * Made:
+ * 18/09/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ * leaving blank atm, boilerplate
+ */
 impl WidgetImpl for Processor {}

src/processor/mod.rs

@@ -25,34 +25,83 @@ mod imp;
 // Imports
 use super::subprocess;
 use glib::Object;
-use gtk::{ glib, gio };
+use gtk::{ glib, gio, prelude::ObjectExt };
 use std::ffi::OsStr;
 
 glib::wrapper! {
-    //pub struct Processor(ObjectSubclass<imp::Processor<'a>>)
     pub struct Processor(ObjectSubclass<imp::Processor>)
         @extends gtk::Widget,
         @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
 }
 
-// Trait shared by all processors
+/*
+ * Trait Name:
+ * Processor
+ *
+ * Description:
+ * Trait shared by all processors
+ *
+ * Made:
+ * 18/09/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ *
+ */
 impl Processor {
-    pub fn new(name: &'static str, /*base_call: &'static str, tail_call: &'static str*/) -> Self {
-        Object::new(&[
-            ("name", &name),/*
-            ("base_call", &base_call),
-            ("call", &base_call.clone()),
-            ("tail_call", &tail_call),*/
-        ]).expect("Failed to create `Processor`")
+    /*
+     * Name:
+     * new
+     *
+     * Description:
+     * Create a new Processor object
+     *
+     * Made:
+     * 18/09/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    pub fn new(base_call: &'static str, tail_call: &'static str) -> Self {
+        let obj: Processor = Object::new(&[]).expect("Failed to create `Processor`");
+
+        // TODO: 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());
+
+        return obj;
     }
 
+    /*
+     * Name:
+     * process
+     *
+     * Description:
+     * Runs call stack and return result
+     *
+     * Made:
+     * 18/09/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     * we'll know what possible sizes will exist (wherever this gets implemented)
+     */
     pub fn process(self) -> Result<Option<String>, glib::Error> {
-        // Create string of args
-        //NOTE: we'll know what possible sizes will exist (wherever this gets implemented)
-        let mut call_stack: String = String::from("nvidia-settings");
-        let tail_call: &str = "-q GpuUUID -t";
+        // Create call stack of program and args
+        let tail_call = self.property::<String>("tail-call");
+        let mut call_stack = self.property::<String>("call");
         call_stack.push_str(" ");
-        call_stack.push_str(tail_call);
+        call_stack.push_str(tail_call.as_str());
+
+        // Turn call stack into bytes and create vector for final call stack
         let call_stack_bytes: &[u8] = call_stack.as_bytes();
         let mut call_stack_items: Vec<&OsStr> = Vec::new();
 
@@ -64,7 +113,7 @@ impl Processor {
                 let item_osstr: &OsStr;
                 match std::str::from_utf8(&call_stack_bytes[start..i]) {
                     Ok(result) => {
-                        println!("item: {}", result);
+                        //println!("item: {}", result);//TEST
                         item_osstr = OsStr::new(result)
                     },
                     Err(err) => panic!("{}", err),
@@ -77,7 +126,7 @@ impl Processor {
                 let item_osstr: &OsStr;
                 match std::str::from_utf8(&call_stack_bytes[start..]) {
                     Ok(result) => {
-                        println!("item: {}", result);
+                        //println!("item: {}", result);//TEST
                         item_osstr = OsStr::new(result)
                     },
                     Err(err) => panic!("{}", err),
@@ -86,7 +135,7 @@ impl Processor {
             }
         }
 
-        // Build OsStr array from vector
+        // Build OsStr array from vector (if matching a specific size)
         match call_stack_items.len() {
             4 => {
                 // Build array
@@ -166,19 +215,29 @@ impl Processor {
         todo!()
         //self.name.
     }
-
-    fn parse(self, input: &String) -> String {
-        // Grab input string as owned, then return
-        //(this function is designed to be overloaded by subclasses)
-        input.replace("\n", "").to_owned()
-    }
     */
 
+    /*
+     * Name:
+     * parse
+     *
+     * Description:
+     * Grab input string as owned, append test formatting and then return
+     *
+     * Made:
+     * 18/09/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     * This function is designed to be overloaded by subclasses
+     */
     fn parse(self, input: &String) -> String {
-        // Grab input string as owned, append test formatting and then return
-        let mut output = input.replace("\n", "").to_owned();
-        output.push_str("-FUCK");
+        //NOTE: leaving this here for future use..
+        //let mut output = input.replace("\n", "").to_owned();
+        //output.push_str("-FUCK");
 
-        output
+        input.replace("\n", "").to_owned()
     }
 }