Merge pull request #60 from derenv/reload_on_settings_exit

Reload on settings exit

Author: derenv

src/gpu_page/imp.rs

@@ -22,7 +22,8 @@ use adwaita::{gio, glib, prelude::*, subclass::prelude::*};
 use gio::Settings;
 use glib::{
     once_cell::sync::Lazy, once_cell::sync::OnceCell, signal::Inhibit,
-    subclass::InitializingObject, FromVariant, ParamSpec, Value,
+    subclass::InitializingObject, subclass::Signal, subclass::SignalType, FromVariant, ParamSpec,
+    Value,
 };
 use gtk::{
     subclass::prelude::*, Button, CompositeTemplate, PolicyType, ScrolledWindow, Stack,
@@ -53,12 +54,15 @@ enum TemperatureUnit {
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/main-window.ui")]
 pub struct MainWindow {
+    // Public
     pub settings: OnceCell<Settings>,
     pub settings_window: Rc<RefCell<SettingsWindowContainer>>,
     pub provider: Cell<Option<Provider>>,
 
+    // Private
     gpu_pages: RefCell<Vec<GpuPage>>,
 
+    // Template Children
     #[template_child]
     pub gpu_stack: TemplateChild<Stack>,
 }
@@ -1344,32 +1348,13 @@ impl MainWindow {
             }
         }
     }
-}
 
-/**
- * Name:
- * MainWindow
- *
- * Description:
- * Trait defining template callbacks shared by all MainWindow objects
- *
- * Made:
- * 13/10/2022
- *
- * Made by:
- * Deren Vural
- *
- * Notes:
- *
- */
-#[gtk::template_callbacks]
-impl MainWindow {
     /**
      * Name:
      * refresh_cards
      *
      * Description:
-     * Template callback for GPU list refresh button
+     * Re-create the GpuPages and stack contents when called
      *
      * Made:
      * 28/10/2022
@@ -1380,10 +1365,7 @@ impl MainWindow {
      * Notes:
      *
      */
-    #[template_callback]
-    fn refresh_cards(&self, _button: &Button) {
-        // println!("GPU Scan Button Pressed!"); //TEST
-
+    pub fn refresh_cards(&self) {
         // Clear current ActionRow objects from GtkListBox
         let mut done: bool = false;
         while !done {
@@ -1544,58 +1526,47 @@ impl MainWindow {
                 }
             }
         }
+    }
+}
 
-        /*
-        // Load refresh time (s) from settings
-        let refresh_rate: u32 = self.get_setting::<i32>("refreshrate") as u32;
-
-        // Create thread safe container for provider
-        // Grab copy of current provider
-        let provider_container: Option<Provider> = self.provider.take();
-        self.provider.set(provider_container.clone());
-        let provider_store: Arc<Mutex<Option<Provider>>> = Arc::new(Mutex::new(provider_container));
-
-        // Wrapper around `NonNull<RawType>` that just implements `Send`
-        struct WrappedPointer(Settings);
-        unsafe impl Send for WrappedPointer {}
-        // Safe wrapper around `WrappedPointer` that gives access to the pointer
-        // only with the mutex locked.
-        struct SafeType {
-            inner: Mutex<WrappedPointer>,
-        }
-        let settings_store: SafeType = SafeType
-        {
-            inner: Mutex::new(WrappedPointer(self.settings.get().expect("").to_owned()))
-        };
-
-        // Async check for provider changes
-        //glib::timeout_add_seconds(refresh_rate, clone!(@strong self as window => move || {
-        //glib::timeout_add_seconds(refresh_rate, clone!(@strong settings_store as window => move || {
-        glib::timeout_add_seconds_local(refresh_rate, move || {
-            // Grab locked data
-            // settings object
-            let settings_container: MutexGuard<WrappedPointer> = settings_store.inner.lock().unwrap();
-            // current provider for scanning gpu data
-            let provider_lock: Arc<Mutex<Option<Provider>>> = Arc::clone(&provider_store);
-            let mut provider_container: MutexGuard<Option<Provider>> = provider_lock.lock().unwrap();
-
-
-            // Check provider type in settings
-            let provider_type: i32 = settings_container.0.get("provider");
-
-            // If type has been changed, update provider
-            match &mut *provider_container {
-                Some(prov) => {
-                    if prov.property::<i32>("provider_type") != provider_type {
-                        //
-                    }
-                }
-                None => todo!(),
-            }
-
-            Continue(true)
-        });
-        */
+/**
+ * Name:
+ * MainWindow
+ *
+ * Description:
+ * Trait defining template callbacks shared by all MainWindow objects
+ *
+ * Made:
+ * 13/10/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ *
+ */
+#[gtk::template_callbacks]
+impl MainWindow {
+    /**
+     * Name:
+     * refresh_cards
+     *
+     * Description:
+     * Template callback for GPU list refresh button
+     *
+     * Made:
+     * 28/10/2022
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     *
+     */
+    #[template_callback]
+    fn refresh_cards_clicked(&self, _button: &Button) {
+        // println!("GPU Scan Button Pressed!"); //TEST
+        self.refresh_cards();
     }
 }
 
@@ -1740,6 +1711,38 @@ impl ObjectImpl for MainWindow {
             _ => panic!("Property `{}` does not exist..", pspec.name()),
         }
     }
+
+    /**
+     * Name:
+     * signals
+     *
+     * Description:
+     * Defines the list of signals
+     *
+     * Made:
+     * 10/01/2023
+     *
+     * Made by:
+     * Deren Vural
+     *
+     * Notes:
+     * beware that you need to use kebab-case (<https://en.wikipedia.org/wiki/Letter_case#Kebab_case>)
+     *
+     * <https://gtk-rs.org/gtk4-rs/stable/latest/book/g_object_signals.html>
+     *
+     * SignalType::from(i32::static_type())
+     */
+    fn signals() -> &'static [Signal] {
+        static SIGNALS: Lazy<Vec<Signal>> = Lazy::new(|| {
+            vec![Signal::builder(
+                "update-all-views",
+                &[],
+                SignalType::from(i32::static_type()),
+            )
+            .build()]
+        });
+        SIGNALS.as_ref()
+    }
 }
 
 /**

src/gpu_page/mod.rs

@@ -24,7 +24,7 @@ use imp::SettingsWindowContainer;
 // Imports
 use adwaita::{gio, glib, prelude::*, subclass::prelude::*};
 use gio::{Settings, SimpleAction};
-use glib::{clone, Object};
+use glib::{clone, closure, Object};
 use std::cell::RefMut;
 
 // Modules
@@ -72,6 +72,7 @@ impl MainWindow {
      *
      */
     pub fn new(app: &adwaita::Application) -> Self {
+        // Create new window
         Object::new(&[("application", app)]).expect("`MainWindow` should be  instantiable.")
     }
 
@@ -139,7 +140,23 @@ impl MainWindow {
      *
      */
     fn setup_widgets(&self) {
-        //
+        // Connect closure to re-load stored views (with different settings) when a settings window is closed
+        //NOTE: expected return value seems to be broken - look at imp.rs:1772
+        self.connect_closure(
+            "update-all-views",
+            false,
+            closure!(move |window: MainWindow| {
+                println!("closure called!"); //TEST
+
+                // Reload views
+                println!("reloading views.."); //TEST
+                window.imp().refresh_cards();
+                println!("views reloaded.."); //TEST
+
+                // Return final value
+                0
+            }),
+        );
     }
 
     /**
@@ -339,7 +356,7 @@ impl MainWindow {
                             let app: adwaita::Application = adwaita::Application::builder().application_id(APP_ID).build();
 
                             // Create new settings window
-                            let new_settings_window: SettingsWindow = SettingsWindow::new(&app);
+                            let new_settings_window: SettingsWindow = SettingsWindow::new(&app, &window);
 
                             // Show new settings window
                             new_settings_window.show();
@@ -361,7 +378,7 @@ impl MainWindow {
                     let app: adwaita::Application = adwaita::Application::builder().application_id(APP_ID).build();
 
                     // Create settings window
-                    let new_settings_window: SettingsWindow = SettingsWindow::new(&app);
+                    let new_settings_window: SettingsWindow = SettingsWindow::new(&app, &window);
 
                     // Show new settings window
                     new_settings_window.show();

src/mainwindow/imp.rs

@@ -80,6 +80,7 @@ impl ModificationWindow {
         uuid: &str,
         parent_window: &GpuPage,
     ) -> Self {
+        // Create new window
         let obj: ModificationWindow = Object::new(&[("application", app)])
             .expect("`ModificationWindow` should be  instantiable.");
 
@@ -99,6 +100,7 @@ impl ModificationWindow {
         obj.setup_settings();
         obj.setup_widgets();
 
+        // Return final object
         obj
     }
 
@@ -387,7 +389,7 @@ impl ModificationWindow {
                 window.imp().update_stored_data();
                 // println!("CHANGES APPLIED.."); //TEST
 
-                // TODO: Emit signal to notify changes made to view (and thus reload required)
+                // Emit signal to notify changes made to view (and thus reload required)
                 let modification_window_container: RefMut<ParentContainer> = window.imp().parent_window.borrow_mut();
                 let _result = modification_window_container.window.as_ref().unwrap().emit_by_name::<i32>("update-views", &[&window.property::<i32>("new-view-id")]);
 
@@ -417,7 +419,7 @@ impl ModificationWindow {
                     window.imp().delete_stored_data();
                     // println!("VIEW DELETED.."); //TEST
 
-                    // TODO: Emit signal to notify changes made to view (and thus reload required)
+                    // Emit signal to notify changes made to view (and thus reload required)
                     let modification_window_container: RefMut<ParentContainer> = window.imp().parent_window.borrow_mut();
                     let _result = modification_window_container.window.as_ref().unwrap().emit_by_name::<i32>("update-views", &[&(-1).to_value()]);
 

src/mainwindow/mod.rs

@@ -43,7 +43,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
             <property name="tooltip-text" translatable="yes">Scan for GPUs</property>
 
             <!-- Signals -->
-            <signal name="clicked" handler="refresh_cards" swapped="true"/>
+            <signal name="clicked" handler="refresh_cards_clicked" swapped="true"/>
           </object>
         </child>
       </object>

src/modificationwindow/mod.rs

@@ -23,15 +23,27 @@ use gio::Settings;
 use glib::{once_cell::sync::Lazy, ParamSpec, Value};
 use glib::{once_cell::sync::OnceCell, signal::Inhibit, subclass::InitializingObject};
 use gtk::{subclass::prelude::*, CheckButton, CompositeTemplate, SpinButton, TemplateChild};
+use std::{cell::RefCell, cell::RefMut, rc::Rc};
 
 // Modules
 //use crate::utils::data_path;
+use crate::mainwindow::MainWindow;
+
+/// Structure for storing a SettingsWindow object and any related information
+#[derive(Default)]
+pub struct ParentContainer {
+    pub window: Option<MainWindow>,
+}
 
 /// Object holding the State and any Template Children
 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/settings-window.ui")]
 pub struct SettingsWindow {
+    // Public
     pub settings: OnceCell<Settings>,
+    pub parent_window: Rc<RefCell<ParentContainer>>,
+
+    // Template Children
     #[template_child]
     pub refreshrate_input: TemplateChild<SpinButton>,
     #[template_child]
@@ -368,6 +380,15 @@ impl WindowImpl for SettingsWindow {
         // Store state in settings
         self.update_setting("app-settings-open", false);
 
+        // Emit signal to notify changes made to view (and thus reload required)
+        let modification_window_container: RefMut<ParentContainer> =
+            self.parent_window.borrow_mut();
+        let _result = modification_window_container
+            .window
+            .as_ref()
+            .unwrap()
+            .emit_by_name::<i32>("update-all-views", &[]);
+
         // Pass close request on to the parent
         self.parent_close_request(window)
     }

src/resources/main-window.ui

@@ -25,9 +25,10 @@ use adwaita::{gio, glib, prelude::*, subclass::prelude::*};
 use gio::Settings;
 use glib::{clone, Object};
 use gtk::{Adjustment, CheckButton, StringList};
+use std::cell::RefMut;
 
 // Modules
-use crate::APP_ID;
+use crate::{mainwindow::MainWindow, settingswindow::imp::ParentContainer, APP_ID};
 
 // GObject wrapper for Property
 glib::wrapper! {
@@ -70,9 +71,26 @@ impl SettingsWindow {
      * Notes:
      *
      */
-    pub fn new(app: &adwaita::Application) -> Self {
+    pub fn new(app: &adwaita::Application, parent_window: &MainWindow) -> Self {
         // Create new window
-        Object::new(&[("application", app)]).expect("`SettingsWindow` should be  instantiable.")
+        let obj: SettingsWindow = Object::new(&[("application", app)])
+            .expect("`SettingsWindow` should be  instantiable.");
+
+        // Set custom properties
+        //
+
+        // Set ref to parent
+        {
+            let mut modification_window_container: RefMut<ParentContainer> =
+                obj.imp().parent_window.borrow_mut();
+            modification_window_container.window = Some(parent_window.to_owned());
+        }
+
+        // Apply any setup actions that need the above properties
+        //
+
+        // Return final object
+        obj
     }
 
     /**