Merge pull request #2 from derenv/subprocess

Subprocess

Author: derenv

Cargo.toml

@@ -8,9 +8,9 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-#adwaita = { version = "0.1.1", package = "libadwaita"}
-gtk = { version = "0.4.8", package = "gtk4" }
-#glib = { version = "0.15.12", package = "glib" }
+#adwaita = { version = "^0.1.1", package = "libadwaita"}
+gtk = { version = "^0.4.8", package = "gtk4" }
+#glib = { version = "^0.15.12", package = "glib" }
 
-#gobject = { version = "0.15.10", package = "gobject-sys" }
-libappindicator = { version = "0.7.1", package = "libappindicator" }
+#gobject = { version = "^0.15.10", package = "gobject-sys" }
+libappindicator = { version = "^0.7.1", package = "libappindicator" }

src/main.rs

@@ -21,13 +21,16 @@
 // Modules
 mod custom_button;
 //use custom_button::CustomButton;
+mod subprocess;
+
+use std::ffi::OsStr;
 
 // Imports
 use gtk::prelude::*;
 use gtk::{
     /* Libraries */ gio,
     /* Application */ Application, ApplicationWindow,
-    /* Widgets */ Button
+    /* Widgets */ Button,
 };
 //use std::env;
 //use std::path::Path;
@@ -54,18 +57,58 @@ fn main() {
 
 // Build Function
 fn build_ui(app: &Application) {
-    // Button Child
-    let button = Button::builder()
-        .label("Press me!")
+    // Button Child 1
+    let button1 = Button::builder()
+        .label("Open Settings")
+        .margin_top(12)
+        .margin_bottom(12)
+        .margin_start(12)
+        .margin_end(12)
+        .build();
+    // Connect to "clicked" signal of `button`
+    button1.connect_clicked(move |_| {
+        println!("Trying to open settings!"); //DEBUG
+
+        // Ideally we should grab if nvidia-settings 'failed' somehow or exited normally
+        match subprocess::exec_check(&[OsStr::new("nvidia-settings")], None::<&gio::Cancellable>) {
+            Ok(_x) => {
+                println!("........yay"); //DEBUG
+            }
+            Err(_y) => {
+                println!("........fak"); //DEBUG
+            }
+        };
+    });
+    // Button Child 2
+    let button2 = Button::builder()
+        .label("Get GPU Names")
         .margin_top(12)
         .margin_bottom(12)
         .margin_start(12)
         .margin_end(12)
         .build();
     // Connect to "clicked" signal of `button`
-    button.connect_clicked(move |button| {
-        // Set the label to "Hello World!" after the button has been clicked on
-        button.set_label("Hello World!");
+    button2.connect_clicked(move |_| {
+        println!("Trying to open settings!"); //DEBUG
+
+        // Ideally we should grab if nvidia-settings 'failed' somehow or exited normally
+        match subprocess::exec_communicate(
+            &[
+                OsStr::new("nvidia-settings"),
+                OsStr::new("-q"),
+                OsStr::new("GpuUUID"),
+                OsStr::new("-t"),
+            ],
+            None,
+            None::<&gio::Cancellable>,
+        ) {
+            Ok(_x) => {
+                println!("........yay"); //DEBUG
+            }
+            Err(_y) => {
+                println!("........fak"); //DEBUG
+            }
+        };
     });
 
     // Menu Child
@@ -95,7 +138,8 @@ fn build_ui(app: &Application) {
     window.set_show_menubar(true);
 
     // Add children to window
-    window.set_child(Some(&button));
+    window.set_child(Some(&button1));
+    //window.set_child(Some(&button2));
 
     // Present window
     window.show();

src/subprocess/mod.rs

@@ -0,0 +1,161 @@
+// SPDX-FileCopyrightText: 2022 Deren Vural
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/*
+ * Name:
+ * mod.rs
+ *
+ * Description:
+ * Public-facing subprocess module
+ *
+ * Made:
+ * 15/09/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ * https://blog.logrocket.com/a-practical-guide-to-async-in-rust/
+ */
+
+// Imports
+use gtk::prelude::*;
+use gtk::{gio, glib};
+use std::ffi::OsStr;
+
+/*
+ * Name:
+ * execCheck
+ *
+ * Description:
+ * Execute a command asynchronously and check the exit status
+ *
+ * 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
+ *
+ * @param {string[]} argv - a list of string arguments
+ * @param {Gio.Cancellable} [cancellable] - optional cancellable object
+ * @returns {Promise<boolean>} - The process success
+ *
+ */
+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) }
+            }
+            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(())
+                }
+            }
+            //*/
+        }
+    }
+}
+
+pub fn exec_communicate(
+    argv: &[&OsStr],
+    _input: Option<&str>,
+    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
+            match proc.communicate(None, cancellable) {
+                Err(err) => Err(err),
+                Ok(_out) => {
+                    println!("....process finished"); //DEBUG
+                    Ok(())
+                }
+            }
+        }
+    }
+}