Ely Office: six offline-first desktop apps in Rust and GPUI

ElyDoc, ElyTable, ElyShow (LibreOfficeKit), ElyPDF (MuPDF), ElyTree (Git),
ElyMark (Milkdown and CodeMirror in CEF). ElyMail and ElyAgent follow.

apps/ely-pdf/src/view.rs

@@ -0,0 +1,338 @@
+//! One open PDF: its pages, tiles, text and picks (PDF-01).
+
+use std::{
+    collections::{BTreeSet, HashMap, HashSet, VecDeque},
+    io,
+    sync::{Arc, Mutex},
+};
+
+use ely_pdf_engine::{Bookmark, Char, Doc, Worker};
+use gpui::{
+    Context, EventEmitter, FocusHandle, InteractiveElement as _, IntoElement, ParentElement as _,
+    Render, RenderImage, ScrollHandle, Styled as _, Window, div,
+};
+
+use crate::engine::{Loaded, MEASURE, Mupdf};
+use crate::layout::{Mode, Zoom};
+use crate::pages::{TileKey, rect_on};
+use crate::select::Selection;
+
+/// A failure to show; the window toasts it.
+pub struct Failed(pub String);
+
+/// The document changed what it shows.
+pub struct Reported;
+
+pub struct PdfView {
+    worker: Arc<Mutex<Mupdf>>,
+    pub doc: Doc,
+    /// Page sizes in points; unmeasured ones copy the first.
+    pub sizes: Vec<(f32, f32)>,
+    pub mode: Mode,
+    pub zoom: Zoom,
+    pub rotate: i32,
+    /// The page at the top, or the one shown.
+    pub current: usize,
+    pub scroll: ScrollHandle,
+    pub tiles: HashMap<TileKey, Arc<RenderImage>>,
+    /// Images no longer drawn, freed at the next render.
+    pub retired: ely_gpui_component::primitives::Retired,
+    /// Tiles the worker could not draw; not asked again.
+    pub failed: HashSet<TileKey>,
+    pub text: HashMap<usize, Arc<Vec<Char>>>,
+    pub asking_text: HashSet<usize>,
+    pub marks: Vec<Bookmark>,
+    pub selection: Option<Selection>,
+    /// Found words by page, each with its quads.
+    pub found: Vec<(usize, Vec<[f32; 8]>)>,
+    /// The found word chosen.
+    pub chosen: Option<usize>,
+    /// Where to scroll once laid out, (x, y) content pixels.
+    pub go_to: Option<(f32, f32)>,
+    /// A tile is on its way from the worker.
+    pub painting: bool,
+    /// The view's size and place, as last painted.
+    pub room: gpui::Bounds<gpui::Pixels>,
+    pub focus: FocusHandle,
+    /// Counts edits; replies from before one are dropped.
+    pub version: u64,
+    /// Edits landed so far.
+    pub edited: u64,
+    /// Edits waiting their turn, and whether one runs.
+    pub queue: VecDeque<crate::edits::Queued>,
+    pub editing: bool,
+    /// History marks: now, and at the last load or save.
+    pub mark: String,
+    pub saved: String,
+    /// Page pictures for the side panel, by page and darkness.
+    pub thumbs: HashMap<(usize, bool), Arc<RenderImage>>,
+    pub thumbs_failed: HashSet<usize>,
+    /// A picture is on its way from the worker.
+    pub thumbing: bool,
+    /// Pages picked in the side panel, and the anchor.
+    pub picked: BTreeSet<usize>,
+    pub anchor: Option<usize>,
+    pub tool: crate::content::Tool,
+    /// What pages hold, read while editing.
+    pub layers: crate::content::Layers,
+    pub reading_layer: bool,
+    pub aim: Option<crate::content::Aim>,
+    pub drag: Option<crate::content::Drag>,
+    /// The gesture's page, its window origin and scale.
+    pub grip: Option<(usize, gpui::Point<gpui::Pixels>, f32)>,
+    /// The aim when a gesture began; the panel keeps it.
+    pub held: Option<crate::content::Aim>,
+    /// Annotations and fields by page, for every tool.
+    pub notes: crate::annotate::Notes,
+    pub reading_notes: bool,
+    /// Links by page, read with the notes.
+    pub links: HashMap<usize, Vec<ely_pdf_engine::Link>>,
+    /// Every field name in the form, read for new fields.
+    pub form_names: Option<Vec<String>>,
+    pub reading_names: bool,
+    /// The bookmark picked in the side panel, depth first.
+    pub mark_pick: Option<usize>,
+    /// Attachments, read when listed, and the one picked.
+    pub files: Option<Vec<ely_pdf_engine::Attachment>>,
+    pub reading_files: bool,
+    pub file_pick: Option<String>,
+    /// Regions marked to remove; never in the document.
+    pub redactions: Vec<ely_pdf_engine::Region>,
+    pub sketch: Option<crate::annotate::Sketch>,
+    /// A pick to mark once its text is read.
+    pub marking: Option<crate::select::Selection>,
+    /// Where the last text pick was pressed, in the window.
+    pub pressed: Option<gpui::Point<gpui::Pixels>>,
+    /// What the document allows, `proto::may` bits.
+    pub allowed: u32,
+    /// The file read, and its checked signature fields.
+    pub signatures: Option<(std::path::PathBuf, Vec<crate::sign::Checked>)>,
+    pub reading_signatures: bool,
+    pub sign_at: Option<crate::sign::SignAt>,
+    /// A visible signature waiting for its place.
+    pub stamp: Option<crate::visible::Stamp>,
+    /// MuPDF's words, when it repaired the file.
+    pub repair: Option<String>,
+    /// A draw met damage; the tab hears once.
+    pub damage_seen: bool,
+}
+
+/// Why a request was refused, by what it needs.
+pub fn restricted(needed: &str, cx: &gpui::App) -> gpui::SharedString {
+    let what = ely_ui::i18n::text(cx, &format!("pdf.may.{needed}"), &[]);
+    ely_ui::i18n::text(cx, "pdf.restricted", &[("what", &what)])
+}
+
+/// Page sizes in points; unmeasured pages copy the first.
+pub fn sizes(pages: usize, first: &[[f32; 4]]) -> Vec<(f32, f32)> {
+    let size = |b: &[f32; 4]| (b[2] - b[0], b[3] - b[1]);
+    let mut sizes = vec![size(&first[0]); pages];
+    for (at, bounds) in first.iter().enumerate() {
+        sizes[at] = size(bounds);
+    }
+    sizes
+}
+
+impl EventEmitter<Failed> for PdfView {}
+impl EventEmitter<Reported> for PdfView {}
+
+impl PdfView {
+    /// All its images, for a closing tab to free.
+    pub fn retire_all(&mut self) -> ely_gpui_component::primitives::Retired {
+        let mut images = std::mem::take(&mut self.retired);
+        let tiles = self.tiles.drain().map(|(_, image)| image);
+        for image in tiles.chain(self.thumbs.drain().map(|(_, image)| image)) {
+            images.push(image);
+        }
+        images
+    }
+
+    pub fn new(worker: Arc<Mutex<Mupdf>>, loaded: Loaded, cx: &mut Context<Self>) -> Self {
+        let sizes = sizes(loaded.pages, &loaded.first);
+        log::info!("pdf: a view of {} pages", loaded.pages);
+        let measured = loaded.first.len();
+        let mut view = PdfView {
+            worker,
+            doc: loaded.doc,
+            sizes,
+            mode: Mode::Continuous,
+            zoom: Zoom::Width,
+            rotate: 0,
+            current: 0,
+            scroll: ScrollHandle::new(),
+            tiles: HashMap::new(),
+            retired: Default::default(),
+            failed: HashSet::new(),
+            text: HashMap::new(),
+            asking_text: HashSet::new(),
+            marks: loaded.marks,
+            selection: None,
+            found: Vec::new(),
+            chosen: None,
+            go_to: None,
+            painting: false,
+            room: gpui::Bounds::default(),
+            focus: cx.focus_handle(),
+            version: 0,
+            edited: 0,
+            queue: VecDeque::new(),
+            editing: false,
+            saved: loaded.mark.clone(),
+            mark: loaded.mark,
+            thumbs: HashMap::new(),
+            thumbs_failed: HashSet::new(),
+            thumbing: false,
+            picked: BTreeSet::new(),
+            anchor: None,
+            tool: crate::content::Tool::Read,
+            layers: HashMap::new(),
+            reading_layer: false,
+            aim: None,
+            drag: None,
+            held: None,
+            grip: None,
+            notes: HashMap::new(),
+            reading_notes: false,
+            links: HashMap::new(),
+            form_names: None,
+            reading_names: false,
+            mark_pick: None,
+            files: None,
+            reading_files: false,
+            file_pick: None,
+            redactions: Vec::new(),
+            sketch: None,
+            marking: None,
+            pressed: None,
+            allowed: loaded.allowed,
+            signatures: None,
+            reading_signatures: false,
+            sign_at: None,
+            stamp: None,
+            repair: loaded.repaired.clone(),
+            damage_seen: false,
+        };
+        view.measure(measured, cx);
+        view
+    }
+
+    /// Says `what` failed; the window shows it.
+    pub fn fail(&self, what: &str, error: &io::Error, cx: &mut Context<Self>) {
+        // Engine text may quote the document: the user sees it.
+        log::error!("pdf: {what} failed ({:?})", error.kind());
+        let text = match error.kind() {
+            _ if ely_pdf_engine::is_stale(error) => ely_ui::i18n::text(cx, "pdf.object.changed", &[]),
+            io::ErrorKind::PermissionDenied => restricted(&error.to_string(), cx),
+            _ => ely_ui::i18n::text(cx, "pdf.failed", &[("what", what), ("error", &error.to_string())]),
+        };
+        cx.emit(Failed(text.to_string()));
+    }
+
+    /// Runs `work` off the window; edits between drop `then`.
+    pub fn read<T: Send + 'static>(
+        &self,
+        work: impl FnOnce(&mut Worker) -> io::Result<T> + Send + 'static,
+        then: impl FnOnce(&mut Self, io::Result<T>, &mut Context<Self>) + 'static,
+        cx: &mut Context<Self>,
+    ) {
+        let version = self.version;
+        self.off(
+            work,
+            move |view, done, cx| match view.version == version {
+                true => then(view, done, cx),
+                false => log::info!("pdf: a read from before an edit is dropped"),
+            },
+            cx,
+        );
+    }
+
+    /// Runs `work` off the window, then `then` here.
+    pub fn off<T: Send + 'static>(
+        &self,
+        work: impl FnOnce(&mut Worker) -> io::Result<T> + Send + 'static,
+        then: impl FnOnce(&mut Self, io::Result<T>, &mut Context<Self>) + 'static,
+        cx: &mut Context<Self>,
+    ) {
+        let worker = self.worker.clone();
+        cx.spawn(async move |this, cx| {
+            let done = cx
+                .background_executor()
+                .spawn(async move { work(worker.lock().expect("the worker lock").get()?) })
+                .await;
+            if this.update(cx, |view, cx| then(view, done, cx)).is_err() {
+                log::info!("pdf: a reply outlived its view");
+            }
+        })
+        .detach();
+    }
+
+    /// Measures the other pages, a batch at a time.
+    pub fn measure(&mut self, from: usize, cx: &mut Context<Self>) {
+        let (doc, count) = (self.doc, (self.sizes.len() - from).min(MEASURE));
+        if count == 0 {
+            return;
+        }
+        self.read(
+            move |worker| worker.bounds(doc, from, count),
+            move |view, read, cx| match read {
+                Ok(boxes) => {
+                    for (at, b) in boxes.iter().enumerate() {
+                        view.sizes[from + at] = (b[2] - b[0], b[3] - b[1]);
+                    }
+                    cx.emit(Reported);
+                    cx.notify();
+                    view.measure(from + count, cx);
+                }
+                Err(error) => view.fail("page sizes", &error, cx),
+            },
+            cx,
+        );
+    }
+
+    /// Scrolls `page` into view, `y` points near the top.
+    pub fn show(&mut self, page: usize, y: f32, cx: &mut Context<Self>) {
+        self.current = page;
+        let laid = self.laid_out();
+        if let Some(place) = laid.placed.iter().find(|place| place.page == page) {
+            let (_, top, _, _) = rect_on([0.0, y, 0.0, y], self.sizes[page], self.rotate, laid.scale);
+            // Across: stay unless the page's left is out of view.
+            let (left, wide) = (-f32::from(self.scroll.offset().x), f32::from(self.room.size.width));
+            let x = match place.x >= left && place.x < left + wide {
+                true => left,
+                false => (place.x - crate::layout::GAP).max(0.0),
+            };
+            self.go_to = Some((x, (place.y + top - crate::layout::GAP * 2.0).max(0.0)));
+        }
+        cx.notify();
+    }
+
+    /// Every page tile goes; images are freed next render.
+    pub fn retire_tiles(&mut self) {
+        for (_, image) in self.tiles.drain() {
+            self.retired.push(image);
+        }
+    }
+
+    /// Changes how pages show; the page read stays in view.
+    pub fn change(&mut self, change: impl FnOnce(&mut Self, f32), cx: &mut Context<Self>) {
+        let scale = self.laid_out().scale;
+        change(self, scale);
+        self.retire_tiles();
+        self.show(self.current, 0.0, cx);
+    }
+
+    /// Moves `by` pages; continuous views scroll there.
+    pub fn turn(&mut self, by: isize, cx: &mut Context<Self>) {
+        let last = self.sizes.len().saturating_sub(1) as isize;
+        let page = (self.current as isize + by).clamp(0, last) as usize;
+        self.show(page, 0.0, cx);
+    }
+}
+
+impl Render for PdfView {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        self.retired.release(window);
+        let pages = self.page_view(window, cx);
+        div().size_full().track_focus(&self.focus).child(pages)
+    }
+}