separate handler, begin Titan input integration

src/app/browser/window/tab/item/client.rs

@@ -3,16 +3,14 @@ mod feature;
 mod subject;
 
 use super::Page;
-use crate::tool::format_bytes;
 use adw::TabPage;
 use driver::Driver;
 use feature::Feature;
 use gtk::{
     gio::Cancellable,
     glib::{Uri, UriFlags},
-    prelude::{CancellableExt, EditableExt, EntryExt, WidgetExt},
+    prelude::{CancellableExt, EditableExt, EntryExt},
 };
-use plurify::ns as plural;
 use std::{cell::Cell, rc::Rc};
 use subject::Subject;
 
@@ -86,26 +84,7 @@ impl Client {
                 match result {
                     // route by scheme
                     Ok(uri) => match uri.scheme().as_str() {
-                        "gemini" => driver.gemini.handle(uri, feature, cancellable),
+                        "gemini" | "titan" => driver.gemini.handle(uri, feature, cancellable),
-                        "titan" => subject.page.input.set_new_titan(|data, label| {
-                            // init data to send
-                            const CHUNK: usize = 0x400;
-                            let bytes_sent = 0;
-                            let bytes_total = data.len();
-
-                            // send by chunks for large content size
-                            if bytes_total > CHUNK {
-                                label.set_label(&format!(
-                                    "sent {}/{} {}",
-                                    format_bytes(bytes_sent),
-                                    format_bytes(bytes_total),
-                                    plural(bytes_sent, &["byte", "bytes", "bytes"])
-                                ));
-                            } else {
-                                label.set_visible(false);
-                            }
-                            todo!()
-                        }),
                         scheme => {
                             // no scheme match driver, complete with failure message
                             let status = subject.page.content.to_status_failure();
@@ -155,7 +134,7 @@ impl Client {
 fn lookup(
     query: &str,
     cancellable: Cancellable,
-    callback: impl FnOnce(Feature, Cancellable, Result<Uri, Uri>) + 'static,
+    callback: impl FnOnce(Rc<Feature>, Cancellable, Result<Uri, Uri>) + 'static,
 ) {
     use gtk::{
         gio::{NetworkAddress, Resolver},
@@ -167,6 +146,7 @@ fn lookup(
     const TIMEOUT: u32 = 250; // ms
 
     let (feature, query) = Feature::parse(query.trim());
+    let feature = Rc::new(feature);
 
     match Uri::parse(query, UriFlags::NONE) {
         Ok(uri) => callback(feature, cancellable, Ok(uri)),

src/app/browser/window/tab/item/client/driver/gemini.rs

@@ -1,10 +1,9 @@
 use super::{Feature, Subject};
 use ggemini::client::{
     connection::response::{data::Text, meta::Status},
-    Request,
+    Client, Request,
 };
 use gtk::glib::{GString, UriFlags};
-use gtk::prelude::{EditableExt, FileExt};
 use gtk::{
     gdk::Texture,
     gdk_pixbuf::Pixbuf,
@@ -12,12 +11,16 @@ use gtk::{
     glib::{Priority, Uri},
     prelude::{EntryExt, SocketClientExt},
 };
+use gtk::{
+    glib::Bytes,
+    prelude::{EditableExt, FileExt},
+};
 use std::{cell::Cell, path::MAIN_SEPARATOR, rc::Rc, time::Duration};
 
 /// Multi-protocol client API for `Page` object
 pub struct Gemini {
     /// Should be initiated once
-    client: Rc<ggemini::Client>,
+    client: Rc<Client>,
     /// Validate redirection count by Gemini protocol specification
     redirects: Rc<Cell<usize>>,
     /// Handle target
@@ -72,15 +75,81 @@ impl Gemini {
 
     // Actions
 
-    pub fn handle(&self, uri: Uri, feature: Feature, cancellable: Cancellable) {
+    pub fn handle(&self, uri: Uri, feature: Rc<Feature>, cancellable: Cancellable) {
-        self.client.request_async(
+        use ggemini::client::connection::request::*;
-            Request::gemini(uri.clone()),
+
+        match uri.scheme().as_str() {
+            "gemini" => handle(
+                Request::Gemini(Gemini { uri }),
+                self.client.clone(),
+                self.subject.clone(),
+                self.redirects.clone(),
+                feature,
+                cancellable,
+            ),
+            "titan" => self.subject.page.input.set_new_titan({
+                let client = self.client.clone();
+                let subject = self.subject.clone();
+                let redirects = self.redirects.clone();
+                move |data, _label| {
+                    handle(
+                        Request::Titan(Titan {
+                            uri: uri.clone(),
+                            data: Bytes::from(data),
+                            mime: None,  // @TODO
+                            token: None, // @TODO
+                        }),
+                        client.clone(),
+                        subject.clone(),
+                        redirects.clone(),
+                        feature.clone(),
+                        cancellable.clone(),
+                    )
+                    // init data to send
+                    /* @TODO
+                    use crate::tool::format_bytes;
+                    use plurify::ns as plural;
+
+                    const CHUNK: usize = 0x400;
+                    let bytes_sent = 0;
+                    let bytes_total = data.len();
+
+                    // send by chunks for large content size
+                    if bytes_total > CHUNK {
+                        label.set_label(&format!(
+                            "sent {}/{} {}",
+                            format_bytes(bytes_sent),
+                            format_bytes(bytes_total),
+                            plural(bytes_sent, &["byte", "bytes", "bytes"])
+                        ));
+                    } else {
+                        label.set_visible(false);
+                    }
+                    todo!()*/
+                }
+            }),
+            _ => panic!(), // unexpected
+        }
+    }
+}
+
+fn handle(
+    request: Request,
+    client: Rc<Client>,
+    subject: Rc<Subject>,
+    redirects: Rc<Cell<usize>>,
+    feature: Rc<Feature>,
+    cancellable: Cancellable,
+) {
+    let uri = request.uri().clone();
+    client.request_async(
+        request,
         Priority::DEFAULT,
         cancellable.clone(),
         // Search for user certificate match request
         // * @TODO this feature does not support multi-protocol yet
-            match self
+        match subject
-                .subject.page
+            .page
             .profile
             .identity
             .gemini
@@ -93,9 +162,8 @@ impl Gemini {
             None => None,
         },
         {
-                let uri = uri.clone();
+            let subject = subject.clone();
-                let subject = self.subject.clone();
+            let redirects = redirects.clone();
-                let redirects = self.redirects.clone();
             move |result|     match result {
                 Ok(response) => {
                     match response.meta.status {
@@ -125,7 +193,7 @@ impl Gemini {
                             subject.tab_page.set_loading(false);
                         }
                         // https://geminiprotocol.net/docs/protocol-specification.gmi#status-20
-                            Status::Success => match feature {
+                        Status::Success => match *feature {
                             Feature::Download => {
                                 // Init download widget
                                 let status = subject.page.content.to_status_download(
@@ -203,7 +271,7 @@ impl Gemini {
                                         cancellable.clone(),
                                         move |result| match result {
                                             Ok(text) => {
-                                                    let widget = if matches!(feature, Feature::Source) {
+                                                let widget = if matches!(*feature, Feature::Source) {
                                                     subject.page.content.to_text_source(&text.to_string())
                                                 } else {
                                                     subject.page.content.to_text_gemini(&uri, &text.to_string())
@@ -399,12 +467,11 @@ impl Gemini {
                     let status = subject.page.content.to_status_failure();
                     status.set_description(Some(&e.to_string()));
                     subject.page.title.replace(status.title());
-                    },
+                }
             }
         },
     )
 }
-}
 
 /// Helper function, extract readable title from [Uri](https://docs.gtk.org/glib/struct.Uri.html)
 /// * useful as common placeholder when page title could not be detected