implement separated dialogs for the Bookmarks and History menu items

Author: yggverse

Cargo.toml

@@ -34,7 +34,6 @@ anyhow = "1.0.97"
 async-channel = "2.5.0"
 ggemini = "0.19.0"
 ggemtext = "0.7.0"
-indexmap = "2.7.0"
 itertools = "0.14.0"
 # libspelling = "0.4.0"
 maxminddb = "0.26.0"

src/app/browser.rs

@@ -1,12 +1,16 @@
 mod about;
 mod action;
+mod bookmarks;
 mod database;
+mod history;
 mod proxy;
 mod widget;
 pub mod window;
 
 use about::About;
 use action::Action;
+use bookmarks::Bookmarks;
+use history::History;
 use proxy::Proxy;
 use widget::Widget;
 use window::Window;
@@ -93,6 +97,22 @@ impl Browser {
             }
         });
 
+        action.history.connect_activate({
+            let profile = profile.clone();
+            let window = window.clone();
+            move || {
+                PreferencesDialog::history(&window.action, &profile).present(Some(&window.g_box))
+            }
+        });
+
+        action.bookmarks.connect_activate({
+            let profile = profile.clone();
+            let window = window.clone();
+            move || {
+                PreferencesDialog::bookmarks(&window.action, &profile).present(Some(&window.g_box))
+            }
+        });
+
         action.proxy.connect_activate({
             let profile = profile.clone();
             let window = window.clone();

src/app/browser/action.rs

@@ -1,12 +1,16 @@
 mod about;
+mod bookmarks;
 mod close;
 mod debug;
+mod history;
 mod profile;
 mod proxy;
 
 use about::About;
+use bookmarks::Bookmarks;
 use close::Close;
 use debug::Debug;
+use history::History;
 use profile::Profile;
 use proxy::Proxy;
 
@@ -21,8 +25,10 @@ use std::rc::Rc;
 pub struct Action {
     // Actions
     pub about: Rc<About>,
+    pub bookmarks: Rc<Bookmarks>,
     pub close: Rc<Close>,
     pub debug: Rc<Debug>,
+    pub history: Rc<History>,
     pub profile: Rc<Profile>,
     pub proxy: Rc<Proxy>,
     // Group
@@ -43,8 +49,10 @@ impl Action {
     pub fn new() -> Self {
         // Init actions
         let about = Rc::new(About::new());
+        let bookmarks = Rc::new(Bookmarks::new());
         let close = Rc::new(Close::new());
         let debug = Rc::new(Debug::new());
+        let history = Rc::new(History::new());
         let profile = Rc::new(Profile::new());
         let proxy = Rc::new(Proxy::new());
 
@@ -56,18 +64,22 @@ impl Action {
 
         // Add action to given group
         simple_action_group.add_action(&about.simple_action);
+        simple_action_group.add_action(&bookmarks.simple_action);
         simple_action_group.add_action(&close.simple_action);
         simple_action_group.add_action(&debug.simple_action);
+        simple_action_group.add_action(&history.simple_action);
         simple_action_group.add_action(&profile.simple_action);
         simple_action_group.add_action(&proxy.simple_action);
 
         // Done
         Self {
             about,
+            bookmarks,
             close,
             debug,
             profile,
             proxy,
+            history,
             id,
             simple_action_group,
         }

src/app/browser/action/bookmarks.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 Bookmarks {
+    pub simple_action: SimpleAction,
+}
+
+impl Default for Bookmarks {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Bookmarks {
+    // 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/action/history.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 History {
+    pub simple_action: SimpleAction,
+}
+
+impl Default for History {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl History {
+    // 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/bookmarks.rs

@@ -0,0 +1,117 @@
+//! Browser bookmarks dialog
+
+use super::Profile;
+use crate::app::browser::window::action::{Action as WindowAction, Position};
+use adw::{
+    ActionRow, PreferencesGroup, PreferencesPage,
+    prelude::{
+        ActionRowExt, AdwDialogExt, ExpanderRowExt, PreferencesDialogExt, PreferencesGroupExt,
+        PreferencesPageExt,
+    },
+};
+use gtk::glib::{DateTime, GString, Uri, UriFlags};
+use std::{collections::HashMap, rc::Rc};
+
+struct Record {
+    time: DateTime,
+    request: String,
+    title: Option<String>,
+}
+
+pub trait Bookmarks {
+    fn bookmarks(window_action: &Rc<WindowAction>, profile: &Rc<Profile>) -> Self;
+}
+
+impl Bookmarks for adw::PreferencesDialog {
+    fn bookmarks(window_action: &Rc<WindowAction>, profile: &Rc<Profile>) -> Self {
+        let mut index: HashMap<GString, Vec<Record>> = HashMap::new();
+        for bookmark in profile.bookmark.recent(None) {
+            match Uri::parse(&bookmark.request, UriFlags::NONE) {
+                Ok(uri) => index
+                    .entry(match uri.host() {
+                        Some(host) => host,
+                        None => uri.to_str(),
+                    })
+                    .or_default()
+                    .push(Record {
+                        request: bookmark.request,
+                        time: bookmark.time,
+                        title: bookmark.title,
+                    }),
+                Err(_) => continue, // @TODO
+            }
+        }
+
+        let d = adw::PreferencesDialog::builder()
+            .search_enabled(true)
+            .title("Bookmarks")
+            .build();
+
+        d.add(&{
+            let p = PreferencesPage::builder()
+                .icon_name("document-open-recent-symbolic")
+                .title("All")
+                .build();
+
+            for (group, records) in index {
+                p.add(&{
+                    let g = PreferencesGroup::new();
+                    g.add(&{
+                        let e = adw::ExpanderRow::builder()
+                            .enable_expansion(true)
+                            .expanded(false)
+                            .subtitle(
+                                records
+                                    .iter()
+                                    .max_by_key(|r| r.time.to_unix())
+                                    .unwrap()
+                                    .time
+                                    .format_iso8601()
+                                    .unwrap(),
+                            )
+                            .title_selectable(true)
+                            .title(group)
+                            .build();
+
+                        for record in records {
+                            e.add_row(&{
+                                let a = ActionRow::builder()
+                                    .activatable(true)
+                                    // @TODO use button widget to open the links on click
+                                    //.title_selectable(true)
+                                    .title(match record.title {
+                                        Some(title) => title,
+                                        None => record.time.format_iso8601().unwrap().to_string(),
+                                    })
+                                    .subtitle_selectable(true)
+                                    .subtitle(&record.request)
+                                    .build();
+
+                                a.connect_activated({
+                                    let a = window_action.clone();
+                                    let d = d.clone();
+                                    move |_| {
+                                        a.append.activate_stateful_once(
+                                            Position::After,
+                                            Some(record.request.clone()),
+                                            false,
+                                            true,
+                                            true,
+                                            true,
+                                        );
+                                        d.close();
+                                    }
+                                });
+                                a
+                            })
+                        }
+                        e
+                    });
+                    g
+                });
+            }
+            p
+        });
+        d
+    }
+}