Add support for adding new article URLs from the reader

Author: aykevl

crates/core/src/articles/mod.rs

@@ -25,12 +25,16 @@ pub const ARTICLES_DIR: &str = ".articles";
 #[derive(Serialize, Deserialize)]
 pub struct ArticleIndex {
     pub articles: BTreeMap<String, Article>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[serde(default)]
+    pub queued: Vec<String>,
 }
 
 impl Default for ArticleIndex {
     fn default() -> Self {
         ArticleIndex {
             articles: BTreeMap::new(),
+            queued: Vec::new(),
         }
     }
 }
@@ -131,3 +135,8 @@ pub fn load(auth: settings::ArticleAuth) -> Box<dyn Service> {
         _ => Box::new(dummy::Dummy::new()),
     }
 }
+
+pub fn queue_link(service: &mut Box<dyn Service>, link: String) {
+    service.index().lock().unwrap().queued.push(link);
+    service.save_index();
+}

crates/core/src/articles/wallabag.rs

@@ -526,6 +526,36 @@ fn update(hub: &Hub, auth: ArticleAuth, index: Arc<Mutex<ArticleIndex>>) -> Resu
         hub.send(Event::ArticlesAuth(Ok(auth.clone()))).ok();
     }
 
+    // Submit new URLs.
+    let queued = index.lock().unwrap().queued.clone();
+    if !queued.is_empty() {
+        // Send the list of URLs via a GET parameter, because for some reason
+        // the Wallabag server only accepts those (and not a form in the POST
+        // request).
+        // See: https://github.com/wallabag/wallabag/issues/8353
+        match agent
+            .post(format!("{url}api/entries/lists"))
+            .query("urls", serde_json::to_string(&queued).unwrap())
+            .header("Authorization", "Bearer ".to_owned() + &auth.access_token)
+            .send_empty()
+        {
+            Ok(_) => {
+                let index = &mut index.lock().unwrap();
+                if index.queued.len() > queued.len() {
+                    // New URLs were added in the meantime, so keep those.
+                    // (Unlikely, but possible).
+                    index.queued = index.queued.split_off(queued.len());
+                } else {
+                    // No new URLs were added, so we can clear the queue.
+                    index.queued.clear();
+                }
+            }
+            Err(err) => {
+                return Err(Error::other(format!("submitting article failed: {err}")));
+            }
+        };
+    }
+
     // Sync local changes.
     let mut changes: BTreeMap<String, Vec<(&str, &str)>> = BTreeMap::new();
     let mut deleted: BTreeSet<String> = BTreeSet::new();

crates/core/src/view/mod.rs

@@ -357,6 +357,8 @@ pub enum Event {
     Authenticate,
     ArticlesAuth(Result<ArticleAuth, String>),
     ArticleUpdateProgress(ArticleUpdateProgress),
+    QueueLink(String),
+    AddArticleLink(String),
     CheckBattery,
     SetWifi(bool),
     MightSuspend,
@@ -416,6 +418,7 @@ pub enum ViewId {
     ArticleInputServer,
     ArticleInputUsername,
     ArticleInputPassword,
+    ExternalLink,
     PageMenu,
     PresetMenu,
     MarginCropperMenu,

crates/core/src/view/reader/external_link.rs

@@ -0,0 +1,192 @@
+use crate::color::{BLACK, WHITE};
+use crate::context::Context;
+use crate::device::CURRENT_DEVICE;
+use crate::font::{font_from_style, Fonts, NORMAL_STYLE};
+use crate::framebuffer::Framebuffer;
+use crate::geom::{BorderSpec, CornerSpec, Rectangle};
+use crate::gesture::GestureEvent;
+use crate::unit::scale_by_dpi;
+use crate::view::button::Button;
+use crate::view::icon::Icon;
+use crate::view::label::Label;
+use crate::view::{Align, Bus, Event, Hub, Id, RenderQueue, View, ViewId, ID_FEEDER};
+use crate::view::{BORDER_RADIUS_MEDIUM, SMALL_BAR_HEIGHT, THICKNESS_LARGE};
+
+const LABEL_QUEUE: &str = "Queue";
+const LABEL_ADD_ARTICLE: &str = "Add article";
+
+pub struct ExternalLink {
+    id: Id,
+    rect: Rectangle,
+    children: Vec<Box<dyn View>>,
+}
+
+impl ExternalLink {
+    pub fn new(context: &mut Context, link: String) -> ExternalLink {
+        let id = ID_FEEDER.next();
+        let fonts = &mut context.fonts;
+        let mut children = Vec::new();
+        let dpi = CURRENT_DEVICE.dpi;
+        let (width, height) = context.display.dims;
+        let small_height = scale_by_dpi(SMALL_BAR_HEIGHT, dpi) as i32;
+        let thickness = scale_by_dpi(THICKNESS_LARGE, dpi) as i32;
+        let border_radius = scale_by_dpi(BORDER_RADIUS_MEDIUM, dpi) as i32;
+
+        let (x_height, padding) = {
+            let font = font_from_style(fonts, &NORMAL_STYLE, dpi);
+            (font.x_heights.0 as i32, font.em() as i32)
+        };
+
+        let window_width = width as i32 - 2 * padding;
+        let window_height = small_height * 4 + 2 * padding;
+
+        let dx = (width as i32 - window_width) / 2;
+        let dy = (height as i32 - window_height) / 4;
+
+        let rect = rect![dx, dy, dx + window_width, dy + window_height];
+
+        let close_icon = Icon::new(
+            "close",
+            rect![
+                rect.max.x - small_height,
+                rect.min.y + thickness,
+                rect.max.x - thickness,
+                rect.min.y + small_height
+            ],
+            Event::Close(ViewId::ExternalLink),
+        )
+        .corners(Some(CornerSpec::Detailed {
+            north_west: 0,
+            north_east: border_radius - thickness,
+            south_east: 0,
+            south_west: 0,
+        }));
+        children.push(Box::new(close_icon) as Box<dyn View>);
+
+        let label = Label::new(
+            rect![
+                rect.min.x + small_height,
+                rect.min.y + thickness,
+                rect.max.x - small_height,
+                rect.min.y + small_height
+            ],
+            "External link".to_string(),
+            Align::Center,
+        );
+        children.push(Box::new(label) as Box<dyn View>);
+
+        // TODO: wrap the URL if needed.
+        let link_label = Label::new(
+            rect![
+                rect.min.x + small_height,
+                rect.min.y + thickness + small_height,
+                rect.max.x - small_height,
+                rect.min.y + 2 * small_height
+            ],
+            link.clone(),
+            Align::Left(0),
+        );
+        children.push(Box::new(link_label) as Box<dyn View>);
+
+        let max_button_label_width = {
+            let font = font_from_style(fonts, &NORMAL_STYLE, dpi);
+            [LABEL_QUEUE, LABEL_ADD_ARTICLE]
+                .iter()
+                .map(|t| font.plan(t, None, None).width)
+                .max()
+                .unwrap() as i32
+        };
+
+        let button_y = rect.min.y + small_height * 3;
+        let button_height = 4 * x_height;
+
+        let button_queue = Button::new(
+            rect![
+                rect.min.x + 3 * padding,
+                button_y + small_height - button_height,
+                rect.min.x + 5 * padding + max_button_label_width,
+                button_y + small_height
+            ],
+            Event::QueueLink(link.clone()),
+            LABEL_QUEUE.to_string(),
+        )
+        .disabled(context.settings.external_urls_queue.is_none());
+        children.push(Box::new(button_queue) as Box<dyn View>);
+
+        let button_add_article = Button::new(
+            rect![
+                rect.max.x - 5 * padding - max_button_label_width,
+                button_y + small_height - button_height,
+                rect.max.x - 3 * padding,
+                button_y + small_height
+            ],
+            Event::AddArticleLink(link),
+            LABEL_ADD_ARTICLE.to_string(),
+        )
+        .disabled(context.settings.article_auth.api == "");
+        children.push(Box::new(button_add_article) as Box<dyn View>);
+
+        ExternalLink { id, rect, children }
+    }
+}
+
+impl View for ExternalLink {
+    fn handle_event(
+        &mut self,
+        evt: &Event,
+        _hub: &Hub,
+        bus: &mut Bus,
+        _rq: &mut RenderQueue,
+        _context: &mut Context,
+    ) -> bool {
+        match *evt {
+            Event::Gesture(GestureEvent::Tap(center)) if !self.rect.includes(center) => {
+                bus.push_back(Event::Close(ViewId::ExternalLink));
+                true
+            }
+            Event::Gesture(..) => true,
+            _ => false,
+        }
+    }
+
+    fn render(&self, fb: &mut dyn Framebuffer, _rect: Rectangle, _fonts: &mut Fonts) {
+        let dpi = CURRENT_DEVICE.dpi;
+
+        let border_radius = scale_by_dpi(BORDER_RADIUS_MEDIUM, dpi) as i32;
+        let border_thickness = scale_by_dpi(THICKNESS_LARGE, dpi) as u16;
+
+        fb.draw_rounded_rectangle_with_border(
+            &self.rect,
+            &CornerSpec::Uniform(border_radius),
+            &BorderSpec {
+                thickness: border_thickness,
+                color: BLACK,
+            },
+            &WHITE,
+        );
+    }
+
+    fn is_background(&self) -> bool {
+        true
+    }
+
+    fn rect(&self) -> &Rectangle {
+        &self.rect
+    }
+
+    fn rect_mut(&mut self) -> &mut Rectangle {
+        &mut self.rect
+    }
+
+    fn children(&self) -> &Vec<Box<dyn View>> {
+        &self.children
+    }
+
+    fn children_mut(&mut self) -> &mut Vec<Box<dyn View>> {
+        &mut self.children
+    }
+
+    fn id(&self) -> Id {
+        self.id
+    }
+}

crates/core/src/view/reader/mod.rs

@@ -4,6 +4,7 @@ mod results_bar;
 mod margin_cropper;
 mod chapter_label;
 mod results_label;
+mod external_link;
 
 use std::thread;
 use std::sync::{Arc, Mutex};
@@ -19,8 +20,10 @@ use regex::Regex;
 use septem::prelude::*;
 use septem::{Roman, Digit};
 use rand_core::RngCore;
+use crate::articles;
 use crate::input::{DeviceEvent, FingerStatus, ButtonCode, ButtonStatus};
 use crate::framebuffer::{Framebuffer, UpdateMode, Pixmap};
+use crate::view::reader::external_link::ExternalLink;
 use crate::view::{View, Event, AppCmd, Hub, Bus, RenderQueue, RenderData};
 use crate::view::{ViewId, Id, ID_FEEDER, EntryKind, EntryId, SliderId};
 use crate::view::{SMALL_BAR_HEIGHT, BIG_BAR_HEIGHT, THICKNESS_MEDIUM};
@@ -2173,6 +2176,13 @@ impl Reader {
         }
     }
 
+    fn close_external_link_popup(&mut self, rq: &mut RenderQueue) {
+        if let Some(index) = locate::<ExternalLink>(self) {
+            self.children.remove(index);
+            rq.add(RenderData::expose(self.rect, UpdateMode::Gui));
+        }
+    }
+
     fn set_font_size(&mut self, font_size: f32, hub: &Hub, rq: &mut RenderQueue, context: &mut Context) {
         if Arc::strong_count(&self.doc) > 1 {
             return;
@@ -3139,19 +3149,9 @@ impl View for Reader {
                             hub.send(Event::GoTo(location)).ok();
                         } else {
                             if link.text.starts_with("https:") || link.text.starts_with("http:") {
-                                if let Some(path) = context.settings.external_urls_queue.as_ref() {
-                                    if let Ok(mut file) = OpenOptions::new().create(true)
-                                                                            .append(true)
-                                                                            .open(path) {
-                                        if let Err(e) = writeln!(file, "{}", link.text) {
-                                            eprintln!("Couldn't write to {}: {:#}.", path.display(), e);
-                                        } else {
-                                            let message = format!("Queued {}.", link.text);
-                                            let notif = Notification::new(message, hub, rq, context);
-                                            self.children.push(Box::new(notif) as Box<dyn View>);
-                                        }
-                                    }
-                                }
+                                let view = ExternalLink::new(context, link.text);
+                                rq.add(RenderData::new(view.id(), *view.rect(), UpdateMode::Gui));
+                                self.children.push(Box::new(view) as Box<dyn View>);
                             } else {
                                 eprintln!("Can't resolve URI: {}.", link.text);
                             }
@@ -3593,6 +3593,10 @@ impl View for Reader {
                 self.toggle_keyboard(false, None, hub, rq, context);
                 false
             },
+            Event::Close(ViewId::ExternalLink) => {
+                self.close_external_link_popup(rq);
+                true
+            }
             Event::Show(ViewId::TableOfContents) => {
                 {
                     self.toggle_bars(Some(false), hub, rq, context);
@@ -3926,6 +3930,28 @@ impl View for Reader {
                 }
                 true
             },
+            Event::QueueLink(ref link) => {
+                self.close_external_link_popup(rq);
+                if let Some(path) = context.settings.external_urls_queue.as_ref() {
+                    if let Ok(mut file) = OpenOptions::new().create(true)
+                                                            .append(true)
+                                                            .open(path) {
+                        if let Err(e) = writeln!(file, "{}", link) {
+                            eprintln!("Couldn't write to {}: {:#}.", path.display(), e);
+                        } else {
+                            let message = format!("Queued {}.", link);
+                            let notif = Notification::new(message, hub, rq, context);
+                            self.children.push(Box::new(notif) as Box<dyn View>);
+                        }
+                    }
+                }
+                true
+            },
+            Event::AddArticleLink(ref link) => {
+                self.close_external_link_popup(rq);
+                articles::queue_link(&mut context.article_service, link.clone());
+                true
+            }
             _ => false,
         }
     }