implement proxy settings dialog (rules tab)

Author: yggverse

src/app/browser.rs

@@ -1,16 +1,18 @@
 mod about;
 mod action;
 mod database;
+mod proxy;
 mod widget;
 pub mod window;
 
 use about::About;
 use action::Action;
+use proxy::Proxy;
 use widget::Widget;
 use window::Window;
 
 use crate::Profile;
-use adw::{AboutDialog, Application, prelude::AdwDialogExt};
+use adw::{AboutDialog, Application, PreferencesDialog, prelude::AdwDialogExt};
 use anyhow::Result;
 use gtk::{
     FileLauncher,
@@ -91,6 +93,12 @@ impl Browser {
             }
         });
 
+        action.proxy.connect_activate({
+            let profile = profile.clone();
+            let window = window.clone();
+            move || PreferencesDialog::proxy(&profile).present(Some(&window.g_box))
+        });
+
         // Return new activated `Self`
         Self {
             action,

src/app/browser/action.rs

@@ -2,11 +2,13 @@ mod about;
 mod close;
 mod debug;
 mod profile;
+mod proxy;
 
 use about::About;
 use close::Close;
 use debug::Debug;
 use profile::Profile;
+use proxy::Proxy;
 
 use gtk::{
     gio::SimpleActionGroup,
@@ -22,6 +24,7 @@ pub struct Action {
     pub close: Rc<Close>,
     pub debug: Rc<Debug>,
     pub profile: Rc<Profile>,
+    pub proxy: Rc<Proxy>,
     // Group
     pub id: GString,
     pub simple_action_group: SimpleActionGroup,
@@ -43,6 +46,7 @@ impl Action {
         let close = Rc::new(Close::new());
         let debug = Rc::new(Debug::new());
         let profile = Rc::new(Profile::new());
+        let proxy = Rc::new(Proxy::new());
 
         // Generate unique group ID
         let id = uuid_string_random();
@@ -55,13 +59,15 @@ impl Action {
         simple_action_group.add_action(&close.simple_action);
         simple_action_group.add_action(&debug.simple_action);
         simple_action_group.add_action(&profile.simple_action);
+        simple_action_group.add_action(&proxy.simple_action);
 
         // Done
         Self {
             about,
             close,
             debug,
             profile,
+            proxy,
             id,
             simple_action_group,
         }

src/app/browser/action/proxy.rs

@@ -0,0 +1,31 @@
+use gtk::{gio::SimpleAction, glib::uuid_string_random};
+
+/// [SimpleAction](https://docs.gtk.org/gio/class.SimpleAction.html) wrapper for `Profile` action of `Browser` group
+pub struct Proxy {
+    pub simple_action: SimpleAction,
+}
+
+impl Default for Proxy {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Proxy {
+    // Constructors
+
+    /// Create new `Self`
+    pub fn new() -> Self {
+        Self {
+            simple_action: SimpleAction::new(&uuid_string_random(), None),
+        }
+    }
+
+    // Events
+
+    /// Define callback function for
+    /// [SimpleAction::activate](https://docs.gtk.org/gio/signal.SimpleAction.activate.html) signal
+    pub fn connect_activate(&self, callback: impl Fn() + 'static) {
+        self.simple_action.connect_activate(move |_, _| callback());
+    }
+}

src/app/browser/proxy.rs

@@ -0,0 +1,80 @@
+//! Proxy settings dialog
+
+mod rules;
+
+use super::Profile;
+use adw::{
+    PreferencesGroup, PreferencesPage,
+    prelude::{AdwDialogExt, PreferencesDialogExt, PreferencesGroupExt, PreferencesPageExt},
+};
+use rules::Rules;
+use std::rc::Rc;
+
+pub trait Proxy {
+    fn proxy(profile: &Rc<Profile>) -> Self;
+}
+
+impl Proxy for adw::PreferencesDialog {
+    fn proxy(profile: &Rc<Profile>) -> Self {
+        // Init components
+        let rules = Rules::build(profile);
+
+        // Init widget
+        let d = adw::PreferencesDialog::builder()
+            .search_enabled(true)
+            .title("Proxy")
+            .build();
+
+        d.add(&{
+            let p = PreferencesPage::builder()
+                .title("Rules")
+                .icon_name("system-run-symbolic")
+                .build();
+            p.add(&{
+                let g = PreferencesGroup::new();
+                g.add(&rules.widget);
+                g
+            });
+            /* @TODO URL entry p.add(&{
+                let g = PreferencesGroup::builder().title("Test").build();
+                //g.add(&Box::rules(profile));
+                g
+            });*/
+            p
+        });
+
+        d.add(
+            &PreferencesPage::builder()
+                .title("Exceptions")
+                .icon_name("action-unavailable-symbolic")
+                .build(),
+        );
+
+        d.add(
+            &PreferencesPage::builder()
+                .title("Interface")
+                .icon_name("preferences-desktop-display-symbolic")
+                .build(),
+        );
+
+        d.connect_closed({
+            let profile = profile.clone();
+            move |_| {
+                profile.proxy.clear();
+                for rule in rules.take() {
+                    if rule.validate() {
+                        profile.proxy.add_rule(
+                            rule.id,
+                            rule.is_enabled(),
+                            rule.priority(),
+                            rule.request().to_string(),
+                            rule.url().to_string(),
+                            rule.time,
+                        )
+                    }
+                }
+            }
+        });
+        d
+    }
+}

src/app/browser/proxy/rules.rs

@@ -0,0 +1,93 @@
+mod rule;
+
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
+
+use super::Profile;
+use gtk::{
+    Box,
+    glib::{GString, uuid_string_random},
+    prelude::BoxExt,
+};
+use rule::Rule;
+
+pub struct Rules {
+    pub widget: Box,
+    rules: Rc<RefCell<HashMap<GString, Rule>>>,
+}
+
+impl Rules {
+    pub fn build(profile: &Rc<Profile>) -> Self {
+        let config = profile.proxy.rules();
+
+        let rules: Rc<RefCell<HashMap<GString, Rule>>> =
+            Rc::new(RefCell::new(HashMap::with_capacity(config.len())));
+
+        let form = Box::builder()
+            .orientation(gtk::Orientation::Vertical)
+            .spacing(8)
+            .build();
+
+        {
+            let mut r = rules.borrow_mut();
+
+            for proxy in config {
+                let key = uuid_string_random();
+                let rule = Rule::build(
+                    proxy.id,
+                    Some(&proxy.time),
+                    Some(&proxy.request),
+                    Some(&proxy.url),
+                    Some(proxy.priority),
+                    proxy.is_enabled,
+                    {
+                        let rules = rules.clone();
+                        let key = key.clone();
+                        let form = form.clone();
+                        move || form.remove(&rules.borrow_mut().remove(&key).unwrap().widget)
+                    },
+                );
+                rule.validate();
+                form.append(&rule.widget);
+                assert!(r.insert(key, rule).is_none())
+            }
+        }
+
+        let add = {
+            let b = Box::builder()
+                .orientation(gtk::Orientation::Vertical)
+                .spacing(8)
+                .build();
+
+            b.append(&rule::new({
+                let rules = rules.clone();
+                let form = form.clone();
+                move || {
+                    let key = uuid_string_random();
+                    let rule = Rule::build(None, None, None, None, None, false, {
+                        let rules = rules.clone();
+                        let key = key.clone();
+                        let form = form.clone();
+                        move || form.remove(&rules.borrow_mut().remove(&key).unwrap().widget)
+                    });
+                    form.append(&rule.widget);
+                    assert!(rules.borrow_mut().insert(key, rule).is_none())
+                }
+            }));
+            b
+        };
+
+        let widget = Box::builder()
+            .orientation(gtk::Orientation::Vertical)
+            .spacing(8)
+            .build();
+
+        widget.append(&form);
+        widget.append(&add);
+
+        Self { rules, widget }
+    }
+
+    pub fn take(&self) -> Vec<Rule> {
+        self.rules.take().into_values().collect()
+    }
+}