258 lines
9.0 KiB
Rust
258 lines
9.0 KiB
Rust
//! Export to PDF and print (DOC-15).
|
||
|
||
use std::path::PathBuf;
|
||
|
||
use ely_gpui_component::{
|
||
buttons::{Button, ButtonVariant, SegmentedControl},
|
||
data_display::DescriptionList,
|
||
forms::{NumberInput, Switch},
|
||
overlays::Dialog as Card,
|
||
primitives::Severity,
|
||
theme::ControlSize,
|
||
};
|
||
use ely_lok::Pdf;
|
||
use ely_ui::commands::{Export, Print};
|
||
use gpui::{App, Context, Entity, ParentElement as _, Styled as _, TaskExt as _, Window, div};
|
||
|
||
use crate::actions::Dialog;
|
||
use ely_office::in_window;
|
||
use ely_office::prelude::*;
|
||
|
||
use crate::docs::Docs;
|
||
|
||
impl Docs {
|
||
pub fn on_export(&mut self, _: &Export, _: &mut Window, cx: &mut Context<Self>) {
|
||
self.ask_output(false, cx);
|
||
}
|
||
|
||
pub fn on_print(&mut self, _: &Print, _: &mut Window, cx: &mut Context<Self>) {
|
||
self.ask_output(true, cx);
|
||
}
|
||
|
||
pub(crate) fn ask_output(&mut self, print: bool, cx: &mut Context<Self>) {
|
||
let Some(tab) = self.active_tab() else {
|
||
let text = Docs::text(cx, "command.blocked.no_document", &[]);
|
||
return self.toast(text, Severity::Warning, cx);
|
||
};
|
||
let last = u32::try_from(tab.view.read(cx).pages().len()).expect("a page count");
|
||
self.dialog = Some(Dialog::Output {
|
||
tab: tab.id,
|
||
print,
|
||
all: true,
|
||
pdf: Pdf {
|
||
pages: Some((1, last)),
|
||
comments: false,
|
||
changes: true,
|
||
handouts: 0,
|
||
},
|
||
});
|
||
cx.notify();
|
||
}
|
||
|
||
/// Writes the asked PDF, then saves or prints it.
|
||
pub(crate) fn output(&mut self, cx: &mut Context<Self>) {
|
||
let Some(Dialog::Output {
|
||
tab,
|
||
print,
|
||
all,
|
||
pdf,
|
||
}) = self.dialog.take()
|
||
else {
|
||
return;
|
||
};
|
||
cx.notify();
|
||
let pdf = Pdf {
|
||
pages: pdf.pages.filter(|_| !all),
|
||
..pdf
|
||
};
|
||
if !self.settled(tab, cx) {
|
||
self.dialog = Some(Dialog::Output {
|
||
tab,
|
||
print,
|
||
all,
|
||
pdf,
|
||
});
|
||
return self.when_settled(tab, |docs, _, cx| docs.output(cx));
|
||
}
|
||
let Some(source) = self.tab(tab) else {
|
||
return;
|
||
};
|
||
if print {
|
||
let path = source.work.join("print.pdf");
|
||
let printing = path.clone();
|
||
return self.write_pdf(tab, path, pdf, cx, move |docs, written, cx| match written {
|
||
Ok(()) => ely_office::print_later(printing, cx),
|
||
Err(error) => docs.print_failed(&error.to_string(), cx),
|
||
});
|
||
}
|
||
let Some(dir) = ely_office::folder(source) else {
|
||
return self.panel_failed("no documents folder", cx);
|
||
};
|
||
let stem = source
|
||
.name
|
||
.rsplit_once('.')
|
||
.map_or(source.name.as_ref(), |(stem, _)| stem);
|
||
let chosen = cx.prompt_for_new_path(&dir, Some(&format!("{stem}.pdf")));
|
||
cx.spawn(async move |this, cx| {
|
||
let chosen = match chosen.await {
|
||
Ok(Ok(path)) => Ok(path),
|
||
Ok(Err(error)) => Err(error.to_string()),
|
||
Err(error) => Err(error.to_string()),
|
||
};
|
||
in_window(&this, cx, |docs, _, cx| match chosen {
|
||
Ok(Some(path)) => docs.export_to(tab, path, pdf, cx),
|
||
Ok(None) => log::info!("doc: the export panel was cancelled"),
|
||
Err(error) => docs.panel_failed(&error, cx),
|
||
})
|
||
})
|
||
.detach_and_log_err(cx);
|
||
}
|
||
|
||
pub(crate) fn export_to(&mut self, tab: u64, path: PathBuf, pdf: Pdf, cx: &mut Context<Self>) {
|
||
match self.holder(&path) {
|
||
Ok(None) => {}
|
||
Ok(Some(_)) => {
|
||
log::info!("doc: the export target is an open document");
|
||
let name = ely_office::files::file_name(&path);
|
||
let text = Docs::text(cx, "doc.output.open", &[("name", &name)]);
|
||
return self.toast(text, Severity::Danger, cx);
|
||
}
|
||
Err(error) => return self.output_failed(&error.to_string(), cx),
|
||
}
|
||
let (name, opened) = (ely_office::files::file_name(&path), path.clone());
|
||
self.write_pdf(tab, path, pdf, cx, move |docs, written, cx| match written {
|
||
Ok(()) => {
|
||
let text = Docs::text(cx, "doc.output.exported", &[("name", &name)]);
|
||
docs.toast_output(text, opened.clone(), cx);
|
||
}
|
||
Err(error) => docs.output_failed(&error.to_string(), cx),
|
||
});
|
||
}
|
||
|
||
/// Writes the PDF in the background; `then` takes the outcome.
|
||
fn write_pdf(
|
||
&mut self,
|
||
tab: u64,
|
||
path: PathBuf,
|
||
pdf: Pdf,
|
||
cx: &mut Context<Self>,
|
||
then: impl FnOnce(&mut Self, std::io::Result<()>, &mut Context<Self>) + 'static,
|
||
) {
|
||
let Some(name) = self.tab(tab).map(|tab| tab.name.clone()) else {
|
||
return self.output_failed("the document closed", cx);
|
||
};
|
||
log::info!("doc: writing a PDF of {name} ({pdf:?})");
|
||
let url = ely_lok::file_url(&path);
|
||
self.read_in(
|
||
tab,
|
||
move |worker, doc| doc.export_pdf(worker, &url, &pdf),
|
||
move |docs, written, _, cx| then(docs, written, cx),
|
||
cx,
|
||
);
|
||
}
|
||
|
||
fn output_failed(&self, error: &str, cx: &mut Context<Self>) {
|
||
let text = Docs::text(cx, "doc.output.failed", &[("error", error)]);
|
||
self.toast(text, Severity::Danger, cx);
|
||
}
|
||
}
|
||
|
||
/// Edits the open output dialog.
|
||
fn change(this: &Entity<Docs>, cx: &mut App, edit: impl FnOnce(&mut bool, &mut Pdf)) {
|
||
this.update(cx, |docs, cx| {
|
||
if let Some(Dialog::Output { all, pdf, .. }) = &mut docs.dialog {
|
||
edit(all, pdf);
|
||
}
|
||
cx.notify();
|
||
})
|
||
}
|
||
|
||
/// The dialog before a PDF goes out: pages, comments, changes.
|
||
pub fn output_dialog(
|
||
this: Entity<Docs>,
|
||
(print, all, pdf, last): (bool, bool, Pdf, u32),
|
||
dismiss: impl Fn(&mut Window, &mut App) + 'static,
|
||
cx: &App,
|
||
) -> Card {
|
||
let text = |key: &str| Docs::text(cx, key, &[]);
|
||
let (from, to) = pdf.pages.unwrap_or((1, last));
|
||
let pages = {
|
||
let this = this.clone();
|
||
SegmentedControl::new("doc-output-pages", if all { "all" } else { "range" })
|
||
.size(ControlSize::Sm)
|
||
.segment("all", text("doc.output.all"), None)
|
||
.segment("range", text("doc.output.range"), None)
|
||
.on_change(move |value, _, cx| {
|
||
change(&this, cx, |all, _| *all = value.as_ref() == "all")
|
||
})
|
||
};
|
||
let bound = |id: &'static str, value: u32, first: bool| {
|
||
let this = this.clone();
|
||
NumberInput::new(id, f64::from(value))
|
||
.range(1.0, f64::from(last))
|
||
.on_commit(move |value, _, cx| {
|
||
let value = value.round() as u32;
|
||
change(&this, cx, |_, pdf| {
|
||
let (from, to) = pdf.pages.unwrap_or((1, value));
|
||
pdf.pages = Some(if first {
|
||
(value, to.max(value))
|
||
} else {
|
||
(from.min(value), value)
|
||
});
|
||
})
|
||
})
|
||
};
|
||
let range = (!all).then(|| {
|
||
div()
|
||
.flex()
|
||
.items_center()
|
||
.gap_2()
|
||
.child(div().w_full().max_w_24().child(bound("doc-output-from", from, true)))
|
||
.child("–")
|
||
.child(div().w_full().max_w_24().child(bound("doc-output-to", to, false)))
|
||
});
|
||
let toggle = |id: &'static str, key: &str, on: bool, set: fn(&mut Pdf, bool)| {
|
||
let this = this.clone();
|
||
Switch::new(id, on)
|
||
.label(text(key))
|
||
.on_change(move |on, _, cx| change(&this, cx, |_, pdf| set(pdf, on)))
|
||
};
|
||
let fields = DescriptionList::new()
|
||
.item(
|
||
text("doc.output.pages"),
|
||
div().flex().flex_col().gap_2().child(pages).children(range),
|
||
)
|
||
.item(
|
||
text("doc.output.marks"),
|
||
div()
|
||
.flex()
|
||
.flex_col()
|
||
.gap_2()
|
||
.child(toggle(
|
||
"doc-output-comments",
|
||
"doc.output.comments",
|
||
pdf.comments,
|
||
|pdf, on| pdf.comments = on,
|
||
))
|
||
.child(toggle(
|
||
"doc-output-changes",
|
||
"doc.output.changes",
|
||
pdf.changes,
|
||
|pdf, on| pdf.changes = on,
|
||
)),
|
||
);
|
||
let (title, go) = match print {
|
||
true => ("doc.output.print_title", "doc.output.print"),
|
||
false => ("doc.output.export_title", "doc.output.export"),
|
||
};
|
||
let label = text(go);
|
||
Card::new("doc-output", text(title), dismiss)
|
||
.child(fields)
|
||
.action(ely_office::cancel(cx))
|
||
.action(move |_| {
|
||
Button::new("doc-output-go", label)
|
||
.variant(ButtonVariant::Primary)
|
||
.on_click(move |_, _, cx| this.update(cx, |docs, cx| docs.output(cx)))
|
||
})
|
||
}
|