Merge pull request #3 from derenv/async_check

Async check

Author: derenv

src/main.rs

@@ -22,6 +22,7 @@
 mod custom_button;
 //use custom_button::CustomButton;
 mod subprocess;
+mod processor;
 
 use std::ffi::OsStr;
 

src/processor/imp.rs

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2022 Deren Vural
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/*
+ * Name:
+ * imp.rs
+ *
+ * Description:
+ * Implementation of our custom GObject class (Processor)
+ *
+ * Made:
+ * 18/09/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ *
+ */
+
+// Imports
+use gtk::glib;
+use gtk::subclass::prelude::*;
+
+// Object holding the state
+#[derive(Default)]
+pub struct Processor {
+    name: String,
+    base_call: String,
+    tail_call: String,
+    call: String,
+}
+
+// The central trait for subclassing a GObject
+#[glib::object_subclass]
+impl ObjectSubclass for Processor {
+    //Crate+Obj to avoid collisions
+    const NAME: &'static str = "NvidiaExtensionRustProcessor";
+    // the actual GObject that will be created
+    type Type = super::Processor;
+    // Parent GObject we inherit from
+    type ParentType = gtk::Widget;
+}
+
+// Trait shared by all GObjects
+impl ObjectImpl for Processor {}
+
+// Trait shared by all widgets
+impl WidgetImpl for Processor {}

src/processor/mod.rs

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2022 Deren Vural
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/*
+ * Name:
+ * mod.rs
+ *
+ * Description:
+ * Public-facing interface/wrapper for our custom GObject (Processor)
+ *
+ * Made:
+ * 12/09/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ *
+ */
+
+// Custom GObjects
+mod imp;
+
+// Imports
+use glib::Object;
+use gtk::glib;
+
+glib::wrapper! {
+    pub struct Processor(ObjectSubclass<imp::Processor>)
+        @extends gtk::Widget,
+        //@extends gtk::Button, gtk::Widget,
+        @implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
+}
+
+impl Processor {
+    pub fn new(name: &str, base_call: &str, tail_call: &str) -> Self {
+        Object::new(&[
+            ("name", &name),
+            ("base_call", &base_call),
+            ("tail_call", &tail_call)
+        ]).expect("Failed to create `Processor`.")
+    }
+
+    pub fn parse() {
+        todo!()
+    }
+
+    pub fn process(self) {
+        todo!()
+    }
+
+    pub fn add_property(self) {
+        todo!()
+    }
+
+    pub fn get_name(self) -> String {
+        self.name
+    }
+}

src/subprocess/mod.rs

@@ -19,6 +19,7 @@
  */
 
 // Imports
+use gtk::glib::Bytes;
 use gtk::prelude::*;
 use gtk::{gio, glib};
 use std::ffi::OsStr;
@@ -40,107 +41,50 @@ use std::ffi::OsStr;
  * Made by:
  * Deren Vural
  *
- * @param {string[]} argv - a list of string arguments
- * @param {Gio.Cancellable} [cancellable] - optional cancellable object
- * @returns {Promise<boolean>} - The process success
+ * Notes:
  *
  */
 pub fn exec_check(
     argv: &[&OsStr],
     cancellable: Option<&impl IsA<gio::Cancellable>>,
 ) -> Result<(), glib::Error> {
     // Create subprocess
-    println!("..creating subprocess"); //DEBUG
     match gio::Subprocess::newv(argv, gio::SubprocessFlags::NONE) {
         Err(err) => Err(err),
         Ok(proc) => {
-            println!("..Subprocess successfully created!"); //DEBUG
-
             // Run subprocess
-
-            // Define callback
-            //This should be called when the process is done
-            /*
-            let callback = |q: Result<(), glib::Error>| {
-                match q {
-                    Err(err) => {
-                        Err(err)
-                    },
-                    Ok(_out) => {
-                        println!("....process finished");//DEBUG
-                        Ok(())
-                    },
-                }
-            };
-
-            struct Listener {
-                done: bool
-            }
-            impl Listener {
-                pub fn on_call(&mut self, done: bool) { self.done = done }
-            }
-            struct Caller<'callback> {
-                callback: Box<dyn FnMut(bool) + 'callback>,
-            }
-            impl Caller<'_> {
-                pub fn call(&mut self) { (self.callback)(true) }
+            match proc.wait_async(cancellable, |_| ()) {
+                _ => Ok(()),
             }
-            let mut listener = Listener { done: false };
-            let mut caller = Caller { callback: Box::new(|x| listener.on_call(x)) };
-
-            //fn callback_fn(x: bool){println!("callback bitch!! {}", x)}
-            //let callback_box = Box::new(|x: bool| callback_fn(x));
-
-            //proc.wait_future();//not sure what this does tbh
-            */
-
-            /*
-            Do i just not use Results with callback versions?
-            */
-            // This doesn't work
-            /*
-            match proc.wait_async(cancellable,None) {
-                Err(err) => {
-                    Err(err)
-                },
-                Ok(_out) => {
-                    println!("....process finished");//DEBUG
-                    Ok(())
-                },
-            }
-            */
-            // This also doesn't work
-            /*
-            match proc.wait_async(cancellable, callback) {
-                Err(err) => {
-                    Err(err)
-                },
-                Ok(_out) => {
-                    println!("....process finished");//DEBUG
-                    Ok(())
-                },
-            }
-            */
-
-            //*
-            // This works but holds up main thread..
-            match proc.wait(cancellable) {
-                Err(err) => Err(err),
-                Ok(_out) => {
-                    println!("....process finished"); //DEBUG
-                    Ok(())
-                }
-            }
-            //*/
         }
     }
 }
 
+/*
+ * Name:
+ * exec_communicate
+ *
+ * Description:
+ * Execute a command and return any output
+ *
+ * If given, @cancellable can be used to stop the process before it finishes.
+ *
+ * https://gtk-rs.org/gtk-rs-core/stable/0.14/docs/src/gio/auto/subprocess.rs.html
+ *
+ * Made:
+ * 15/09/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ *
+ */
 pub fn exec_communicate(
     argv: &[&OsStr],
     _input: Option<&str>,
     cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(), glib::Error> {
+) -> Result<(Option<Bytes>, Option<Bytes>), glib::Error> {
     // Create subprocess
     println!("..creating subprocess"); //DEBUG
     match gio::Subprocess::newv(argv, gio::SubprocessFlags::NONE) {
@@ -151,10 +95,7 @@ pub fn exec_communicate(
             // Run subprocess
             match proc.communicate(None, cancellable) {
                 Err(err) => Err(err),
-                Ok(_out) => {
-                    println!("....process finished"); //DEBUG
-                    Ok(())
-                }
+                Ok(out) => Ok(out),
             }
         }
     }