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.
This commit is contained in:
817 files changed
+143101
No files matched your search
@@ -0,0 +1,183 @@
|
||||
//! Page images, text, optimized and repaired copies (PDF-13, PDF-14).
|
||||
|
||||
use std::{
|
||||
ffi::{CStr, c_char, c_int},
|
||||
io,
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
|
||||
use ely_ipc::{Pack, Unpack};
|
||||
use ely_pdf_engine::proto::{may, tag};
|
||||
|
||||
use crate::edit::{clean, raw, utf8};
|
||||
use crate::ffi::{Context, Document, Mupdf, Open, checked, page, text};
|
||||
use crate::secure::refuse;
|
||||
|
||||
unsafe extern "C" {
|
||||
fn ely_export_image(ctx: *mut Context, doc: *mut Document, number: c_int, dpi: f32, path: *const c_char) -> c_int;
|
||||
fn ely_export_text(ctx: *mut Context, doc: *mut Document, path: *const c_char) -> c_int;
|
||||
fn ely_optimize(
|
||||
ctx: *mut Context,
|
||||
doc: *mut Document,
|
||||
raw: *const c_char,
|
||||
out: *const c_char,
|
||||
password: *const c_char,
|
||||
compress: c_int,
|
||||
from: c_int,
|
||||
to: c_int,
|
||||
) -> c_int;
|
||||
fn ely_repaired(ctx: *mut Context, doc: *mut Document) -> c_int;
|
||||
fn ely_write_repaired(ctx: *mut Context, doc: *mut Document, path: *const c_char) -> c_int;
|
||||
fn ely_open_warnings() -> *const c_char;
|
||||
fn ely_scan(ctx: *mut Context, doc: *mut Document) -> c_int;
|
||||
fn ely_watch_begin(ctx: *mut Context);
|
||||
fn ely_watch_end(ctx: *mut Context) -> c_int;
|
||||
fn ely_check_pictures(ctx: *mut Context, doc: *mut Document) -> c_int;
|
||||
fn ely_print_copy(ctx: *mut Context, doc: *mut Document, raw: *const c_char, out: *const c_char, password: *const c_char) -> c_int;
|
||||
}
|
||||
|
||||
/// What MuPDF warned while opening the last file.
|
||||
pub fn open_warnings() -> String {
|
||||
unsafe { CStr::from_ptr(ely_open_warnings()) }.to_string_lossy().into_owned()
|
||||
}
|
||||
|
||||
impl Mupdf {
|
||||
fn optimize(&self, doc: &Open, out: &Path, password: &str, compress: bool, (from, to): (u32, u32)) -> io::Result<()> {
|
||||
let scratch = raw(out);
|
||||
let (raw_c, out_c, password) = (text(utf8(&scratch)?)?, text(utf8(out)?)?, text(password)?);
|
||||
let (from, to) = (c_int::try_from(from).map_err(io::Error::other)?, c_int::try_from(to).map_err(io::Error::other)?);
|
||||
let done = checked(unsafe {
|
||||
ely_optimize(self.ctx, doc.0, raw_c.as_ptr(), out_c.as_ptr(), password.as_ptr(), c_int::from(compress), from, to)
|
||||
});
|
||||
clean(&scratch);
|
||||
if done.is_err() {
|
||||
clean(out);
|
||||
}
|
||||
done.map(|_| ())
|
||||
}
|
||||
|
||||
pub fn repaired(&self, doc: &Open) -> io::Result<bool> {
|
||||
checked(unsafe { ely_repaired(self.ctx, doc.0) }).map(|repaired| repaired != 0)
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::Worker {
|
||||
/// MuPDF warned on reading: the file is damaged.
|
||||
fn note_damage(&mut self, id: u64) -> io::Result<()> {
|
||||
let doc = self.docs.get_mut(&id).ok_or_else(|| io::Error::other(format!("no document {id}")))?;
|
||||
let report = doc.repair.get_or_insert_with(String::new);
|
||||
report.push_str(&open_warnings());
|
||||
log::warn!("pdf-worker: document {id} is damaged");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A tile, and whether drawing it met damage.
|
||||
pub(crate) fn drawn(&mut self, id: u64, page: usize, view: (f32, i32), tile: [i32; 4], dark: bool) -> io::Result<Vec<u8>> {
|
||||
unsafe { ely_watch_begin(self.mupdf.ctx) };
|
||||
let pixels = self.mupdf.render(self.doc(id)?, page, view, tile, dark);
|
||||
let warned = unsafe { ely_watch_end(self.mupdf.ctx) } != 0;
|
||||
if warned {
|
||||
self.note_damage(id)?;
|
||||
}
|
||||
Ok(Pack::new().u64(u64::from(warned)).blob(&pixels?).bytes())
|
||||
}
|
||||
|
||||
/// Every picture decoded before an overwrite; true if any failed.
|
||||
pub(crate) fn check_pictures(&mut self, id: u64) -> io::Result<Vec<u8>> {
|
||||
let failed = checked(unsafe { ely_check_pictures(self.mupdf.ctx, self.doc(id)?.0) })? != 0;
|
||||
if failed {
|
||||
self.note_damage(id)?;
|
||||
}
|
||||
Ok(Pack::new().u64(u64::from(failed)).bytes())
|
||||
}
|
||||
|
||||
/// A repaired file gives way to a whole copy.
|
||||
pub(crate) fn repair(&mut self, id: u64) -> io::Result<()> {
|
||||
let doc = self.docs.get_mut(&id).ok_or_else(|| io::Error::other(format!("no document {id}")))?;
|
||||
if doc.repair.is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
// Late repairs and broken streams show only on reading.
|
||||
let warned = checked(unsafe { ely_scan(self.mupdf.ctx, doc.open.0) })? != 0;
|
||||
doc.warnings.push_str(&open_warnings());
|
||||
if !warned && !self.mupdf.repaired(&doc.open)? {
|
||||
return Ok(());
|
||||
}
|
||||
let copy: PathBuf = std::env::temp_dir().join(format!("ely-pdf-{}-{id}.pdf", std::process::id()));
|
||||
let path = text(utf8(©)?)?;
|
||||
// Any failure here removes the copy and what was opened.
|
||||
let mupdf = &self.mupdf;
|
||||
let fresh = (|| {
|
||||
checked(unsafe { ely_write_repaired(mupdf.ctx, doc.open.0, path.as_ptr()) })?;
|
||||
let fresh = mupdf.open(utf8(©)?)?;
|
||||
let ready = (|| {
|
||||
if mupdf.locked(&fresh)? && mupdf.unlock(&fresh, &doc.password)? == 0 {
|
||||
return Err(io::Error::other("the repaired copy refused the password"));
|
||||
}
|
||||
mupdf.journal(&fresh)
|
||||
})();
|
||||
match ready {
|
||||
Ok(()) => Ok(fresh),
|
||||
Err(error) => {
|
||||
mupdf.close(fresh);
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
})();
|
||||
let fresh = match fresh {
|
||||
Ok(fresh) => fresh,
|
||||
Err(error) => {
|
||||
clean(©);
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let broken = std::mem::replace(&mut doc.open, fresh);
|
||||
self.mupdf.close(broken);
|
||||
doc.repair = Some(std::mem::take(&mut doc.warnings));
|
||||
doc.copy = Some(copy);
|
||||
log::info!("pdf-worker: document {id} was damaged; a repaired copy stands in");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn output(&mut self, kind: u8, id: u64, ask: &mut Unpack) -> io::Result<Vec<u8>> {
|
||||
let has = self.allowed(id)?;
|
||||
let doc = self.record(id)?;
|
||||
match kind {
|
||||
tag::EXPORT_IMAGE => {
|
||||
refuse(may::COPY, has)?;
|
||||
let (at, dpi, path) = (ask.u64()? as usize, f32::from_bits(ask.u64()? as u32), ask.str()?);
|
||||
let path_c = text(&path)?;
|
||||
checked(unsafe { ely_export_image(self.mupdf.ctx, doc.open.0, page(at)?, dpi, path_c.as_ptr()) })?;
|
||||
}
|
||||
tag::EXPORT_TEXT => {
|
||||
refuse(may::COPY, has)?;
|
||||
let path = text(&ask.str()?)?;
|
||||
checked(unsafe { ely_export_text(self.mupdf.ctx, doc.open.0, path.as_ptr()) })?;
|
||||
}
|
||||
tag::OPTIMIZE => {
|
||||
refuse(may::EDIT, has)?;
|
||||
let (out, compress) = (ask.str()?, ask.u64()? != 0);
|
||||
let (from, to) = (ask.u64()? as u32, ask.u64()? as u32);
|
||||
self.mupdf.optimize(&doc.open, out.as_ref(), &doc.password, compress, (from, to))?;
|
||||
}
|
||||
tag::PRINT_COPY => {
|
||||
refuse(may::PRINT, has)?;
|
||||
let out = ask.str()?;
|
||||
let scratch = raw(out.as_ref());
|
||||
let (raw_c, out_c, password) = (text(utf8(&scratch)?)?, text(&out)?, text(&doc.password)?);
|
||||
let done = checked(unsafe { ely_print_copy(self.mupdf.ctx, doc.open.0, raw_c.as_ptr(), out_c.as_ptr(), password.as_ptr()) });
|
||||
clean(&scratch);
|
||||
done?;
|
||||
}
|
||||
tag::REPAIR_REPORT => {
|
||||
return Ok(match &doc.repair {
|
||||
Some(report) => Pack::new().u64(1).str(report).bytes(),
|
||||
None => Pack::new().u64(0).bytes(),
|
||||
});
|
||||
}
|
||||
other => return Err(io::Error::other(format!("no request {other}"))),
|
||||
}
|
||||
log::info!("pdf-worker: request {kind} done for document {id}");
|
||||
Ok(Vec::new())
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user