88f5a00e389b
new.rs
#[cfg(test)]
use super::bytes::base64_encode;
use super::{Arc, DocState, Document, NewDocument, Result, Session, Value, bad, f64_or, json, str_param};
/// The longest saved preset name, and how many presets are kept.
const MAX_PRESET_NAME: usize = 100;
const MAX_PRESETS: usize = 500;
/// A built-in document preset or a saved one, by name (case ignored).
fn find_preset(s: &Session, name: &str) -> Option<NewDocument> {
NewDocument::from_preset(name).or_else(|| s.prefs.document_presets.iter().find(|p| p.title.eq_ignore_ascii_case(name.trim())).cloned())
}
/// The settings `file.new` makes a document with for `p`: its preset, then the settings over it.
/// Without a preset or `units`, it is in the default units (Preferences with no document).
fn new_document_settings(s: &Session, p: &Value) -> Result<NewDocument> {
let mut nd = match str_param(p, "preset") {
Some(name) => find_preset(s, name).ok_or_else(|| bad("file.new", format!("unknown preset `{name}`")))?,
None => s.default_new_document(),
};
apply_settings(&mut nd, p);
check_size("file.new", &nd)?;
Ok(nd)
}
/// A document as `file.new` makes it. Its Basic Paragraph doesn't hyphenate capitalized words, a
/// paragraph's last word or across a column. Opened and imported files keep their own values,
/// which is why `ParaProps` keeps the IDML defaults (on).
fn new_document(nd: &NewDocument) -> Document {
let mut d = Document::new(nd);
if let Some(st) = Arc::make_mut(&mut d.styles).para_mut(designcraft_doc::BASIC_PARAGRAPH) {
st.para.hyph_capitalized = Some(false);
st.para.hyph_last_word = Some(false);
st.para.hyph_across_column = Some(false);
}
d
}
pub(super) fn file_new(s: &mut Session, p: &Value) -> Result<Value> {
let mut nd = new_document_settings(s, p)?;
s.untitled += 1;
nd.title = str_param(p, "title").map(str::to_string).unwrap_or_else(|| format!("Untitled-{}", s.untitled));
let mut d = new_document(&nd);
s.prefs.default_units.apply(&mut d.settings, p.get("preset").is_some_and(|v| !v.is_null()));
let i = s.add_document(DocState::new(d, None));
Ok(json!({"index": i}))
}
impl Session {
/// What New Document starts with: the factory settings, in the default units (Preferences
/// with no document open).
pub fn default_new_document(&self) -> NewDocument {
NewDocument { units: self.prefs.default_units.horizontal_units, ..NewDocument::default() }
}
/// New Document's Preview: a document made as `file.new` would make it with `p`, shown while
/// the New Document window is open. It replaces the previous preview document in its tab and
/// takes no Untitled number, no undo step and no recovery entry. Settings `file.new` refuses
/// leave the previous preview as it was. Returns the preview document's uid.
pub fn preview_new_document(&mut self, p: &Value) -> Result<u64> {
let mut nd = new_document_settings(self, p)?;
let previous = match self.new_document_preview {
Some((_, previous)) => previous,
None => self.active().map(|d| d.uid),
};
let shown = self.new_document_preview.and_then(|(old, _)| self.docs.iter().position(|d| d.uid == old));
// A preview edited or saved by a menu or script while the window is open has become a
// document of its own: it stays, and the preview gets a tab of its own.
let replace = shown.filter(|&i| self.docs.get(i).is_some_and(|d| !d.is_dirty() && d.path.is_none()));
if replace.is_none() && shown.is_some() {
self.untitled += 1;
}
nd.title = str_param(p, "title").map(str::to_string).unwrap_or_else(|| self.next_untitled_title());
let mut d = new_document(&nd);
self.prefs.default_units.apply(&mut d.settings, p.get("preset").is_some_and(|v| !v.is_null()));
let st = DocState::new(d, None);
let uid = st.uid;
match replace.and_then(|i| self.docs.get_mut(i).map(|d| (i, d))) {
Some((i, d)) => {
*d = st;
self.active = Some(i);
}
None => {
// Pushed without `add_document`: the document that was active stays as it is.
self.docs.push(st);
self.active = Some(self.docs.len() - 1);
}
}
self.new_document_preview = Some((uid, previous));
Ok(uid)
}
/// The uid of New Document's preview document, while one is shown.
pub fn new_document_preview(&self) -> Option<u64> {
self.new_document_preview.map(|(uid, _)| uid)
}
/// End New Document's preview. Its document goes, and if it was still the active document,
/// the one that was active before it is active again. A preview that a menu or script has
/// edited or saved stays open as a document, with an Untitled number. Returns the uid of the
/// document removed. Without a preview it does nothing.
pub fn end_new_document_preview(&mut self) -> Option<u64> {
let (uid, previous) = self.new_document_preview.take()?;
let i = self.docs.iter().position(|d| d.uid == uid)?;
let d = self.docs.get(i)?;
if d.is_dirty() || d.path.is_some() {
self.untitled += 1;
return None;
}
self.docs.remove(i);
self.active = match self.active {
Some(a) if a == i => previous.and_then(|p| self.docs.iter().position(|d| d.uid == p)).or_else(|| self.docs.len().checked_sub(1)),
Some(a) if a > i => Some(a - 1),
a => a,
};
Some(uid)
}
/// Create in the New Document window, with the settings the preview shows: the preview
/// document becomes the new document, as `file.new` would make it (the next Untitled number,
/// no undo history). Returns its index, or `None` when there is no unedited preview to keep.
pub fn keep_new_document_preview(&mut self) -> Option<usize> {
let (uid, _) = self.new_document_preview?;
let i = self.docs.iter().position(|d| d.uid == uid && !d.is_dirty() && d.path.is_none())?;
self.new_document_preview = None;
self.untitled += 1;
if let Some(d) = self.docs.get_mut(i) {
d.history.undo.clear();
d.history.redo.clear();
}
self.active = Some(i);
Some(i)
}
}
pub(super) fn save_preset(s: &mut Session, p: &Value) -> Result<Value> {
let name = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad("file.savePreset", "missing `name`"))?.to_string();
if name.chars().count() > MAX_PRESET_NAME {
return Err(bad("file.savePreset", format!("a preset name has at most {MAX_PRESET_NAME} characters")));
}
if NewDocument::from_preset(&name).is_some() {
return Err(bad("file.savePreset", format!("`{name}` is a built-in preset")));
}
let mut nd = NewDocument::default();
apply_settings(&mut nd, p);
check_size("file.savePreset", &nd)?;
nd.title = name.clone();
let presets = &mut s.prefs.document_presets;
presets.retain(|x| !x.title.eq_ignore_ascii_case(&name));
if presets.len() >= MAX_PRESETS {
return Err(bad("file.savePreset", format!("at most {MAX_PRESETS} saved presets")));
}
presets.push(nd);
Ok(json!({"name": name}))
}
fn check_size(cmd: &str, nd: &NewDocument) -> Result<()> {
if !(nd.width > 0.0 && nd.height > 0.0 && nd.width <= 15552.0 && nd.height <= 15552.0) {
return Err(bad(cmd, "page size out of range (0 < size ≤ 216 in)"));
}
Ok(())
}
/// The document settings in `p` (as file.new takes them) over `nd`.
fn apply_settings(nd: &mut NewDocument, p: &Value) {
if let Some(intent) = p.get("intent").and_then(|v| serde_json::from_value(v.clone()).ok()) {
nd.intent = intent;
}
if let Some(units) = p.get("units").and_then(|v| serde_json::from_value(v.clone()).ok()) {
nd.units = units;
}
nd.width = f64_or(p, "width", nd.width);
nd.height = f64_or(p, "height", nd.height);
nd.pages = p.get("pages").and_then(Value::as_u64).map(|v| v as usize).unwrap_or(nd.pages).clamp(1, 9999);
nd.start_page = p.get("startPage").and_then(Value::as_u64).map(|v| v.clamp(1, 99_999) as u32).unwrap_or(nd.start_page);
nd.facing_pages = p.get("facingPages").and_then(Value::as_bool).unwrap_or(nd.facing_pages);
nd.columns = p.get("columns").and_then(Value::as_u64).map(|v| v.clamp(1, 216) as u32).unwrap_or(nd.columns);
nd.gutter = p.get("gutter").and_then(Value::as_f64).filter(|g| g.is_finite()).unwrap_or(nd.gutter).max(0.0);
nd.primary_text_frame = p.get("primaryTextFrame").and_then(Value::as_bool).unwrap_or(nd.primary_text_frame);
match p.get("margins") {
Some(Value::Number(n)) => nd.margins = designcraft_doc::Margins::uniform(n.as_f64().unwrap_or(36.0)),
Some(v @ Value::Object(_)) => {
if let Ok(m) = serde_json::from_value(v.clone()) {
nd.margins = m;
}
}
_ => {}
}
if let Some(b) = edges(p, "bleed") {
nd.bleed = b;
}
if let Some(b) = edges(p, "slug") {
nd.slug = b;
}
}
/// A bleed or slug parameter: one width for every edge, or [top, bottom, inside, outside].
fn edges(p: &Value, key: &str) -> Option<[f64; 4]> {
let clean = |v: f64| if v.is_finite() { v.clamp(0.0, 1296.0) } else { 0.0 };
match p.get(key)? {
Value::Array(a) => match a.iter().map(Value::as_f64).collect::<Option<Vec<f64>>>()?.as_slice() {
[t, b, i, o] => Some([clean(*t), clean(*b), clean(*i), clean(*o)]),
_ => None,
},
v => v.as_f64().map(|b| [clean(b); 4]),
}
}
pub(super) fn file_sample(s: &mut Session, _p: &Value) -> Result<Value> {
let d = crate::sample::magazine();
let i = s.add_document(DocState::new(d, None));
Ok(json!({"index": i}))
}
#[cfg(test)]
mod new_document_tests {
use serde_json::json;
use crate::Session;
#[test]
fn saved_presets_make_documents_by_name() {
let mut s = Session::new();
let newsletter = json!({"name": "Newsletter", "units": "millimeters", "width": 595.2755905511812, "height": 841.8897637795277,
"pages": 8, "facingPages": false, "columns": 3, "margins": {"top": 20, "bottom": 30, "inside": 40, "outside": 50},
"bleed": [9, 9, 0, 9], "primaryTextFrame": true});
assert_eq!(s.execute("file.savePreset", &newsletter).unwrap()["name"], "Newsletter");
let listed = s.execute("file.presets", &json!({})).unwrap();
let saved: Vec<_> = listed.as_array().unwrap().iter().filter(|p| p["saved"] == true).collect();
assert_eq!(saved.len(), 1);
assert_eq!((&saved[0]["name"], &saved[0]["units"]), (&json!("Newsletter"), &json!("millimeters")));
// By name, case ignored; parameters still override the preset.
s.execute("file.new", &json!({"preset": "newsletter", "pages": 4})).unwrap();
let d = &s.doc().unwrap().doc;
assert_eq!(d.page_count(), 4);
assert!(!d.settings.facing_pages && d.settings.primary_text_frame);
assert_eq!(d.settings.horizontal_units, designcraft_geom::Unit::Millimeters);
assert_eq!(d.settings.bleed, [9.0, 9.0, 0.0, 9.0]);
assert_eq!(d.page(0).unwrap().margins.outside, 50.0);
assert!(d.title.starts_with("Untitled-"), "the preset's name isn't the document's");
// The same name replaces it.
s.execute("file.savePreset", &json!({"name": "NEWSLETTER", "pages": 2})).unwrap();
assert_eq!(s.prefs.document_presets.len(), 1);
s.execute("file.new", &json!({"preset": "Newsletter"})).unwrap();
assert_eq!(s.doc().unwrap().doc.page_count(), 2);
// Built-in names, empty and overlong names and impossible sizes are refused.
for bad in [json!({"name": "a4"}), json!({"name": " "}), json!({}), json!({"name": "x".repeat(101)}), json!({"name": "Huge", "width": 1e9})]
{
assert!(s.execute("file.savePreset", &bad).is_err(), "{bad}");
}
s.execute("file.deletePreset", &json!({"name": "newsletter"})).unwrap();
assert!(s.execute("file.deletePreset", &json!({"name": "newsletter"})).is_err());
assert!(s.execute("file.new", &json!({"preset": "Newsletter"})).is_err());
}
#[test]
fn negative_gutter_is_clamped_to_zero() {
let mut s = Session::new();
s.execute("file.new", &json!({"gutter": -50, "columns": 2})).unwrap();
let d = &s.doc().unwrap().doc;
assert_eq!(d.page(0).unwrap().columns.gutter, 0.0);
s.execute("file.savePreset", &json!({"name": "Tight", "gutter": -50, "columns": 2})).unwrap();
assert_eq!(s.prefs.document_presets[0].gutter, 0.0);
}
#[test]
fn new_document_takes_intent_units_start_page_bleed_and_slug() {
let mut s = Session::new();
let p = json!({"preset": "A4", "intent": "web", "units": "pixels", "startPage": 4, "bleed": [9, 0, 3, 6], "slug": 18});
s.execute("file.new", &p).unwrap();
let d = &s.doc().unwrap().doc;
assert_eq!(d.settings.intent, designcraft_doc::Intent::Web);
assert_eq!(d.settings.horizontal_units, designcraft_geom::Unit::Pixels);
assert_eq!(d.settings.bleed, [9.0, 0.0, 3.0, 6.0]);
assert_eq!(d.settings.slug, [18.0; 4]);
assert_eq!(d.page_name(0), "4");
// Malformed edges are ignored, hostile ones bounded.
s.execute("file.new", &json!({"bleed": [1, 2], "slug": [-5, 1e12, 0, 0]})).unwrap();
let d = &s.doc().unwrap().doc;
assert_eq!(d.settings.bleed, [0.0; 4]);
assert_eq!(d.settings.slug, [0.0, 1296.0, 0.0, 0.0]);
}
#[test]
fn a_new_document_preview_replaces_itself_and_leaves_the_session_as_it_was() {
let dir = std::env::temp_dir().join(format!("dc-new-doc-preview-{}", std::process::id()));
let mut s = Session::new();
s.recovery_dir = Some(dir.clone());
s.execute("file.new", &json!({})).unwrap();
let first = s.doc().unwrap().uid;
let a = s.preview_new_document(&json!({"width": 300})).unwrap();
assert_eq!((s.doc().unwrap().uid, s.doc().unwrap().doc.title.as_str()), (a, "Untitled-2"));
let b = s.preview_new_document(&json!({"width": 400, "columns": 3})).unwrap();
assert_eq!(s.documents().len(), 2, "the preview replaces itself");
assert!(s.preview_new_document(&json!({"width": 0})).is_err());
let d = s.doc().unwrap();
assert_eq!((d.uid, d.doc.settings.page_width, d.doc.page(0).unwrap().columns.count), (b, 400.0, 3), "a refused size keeps it");
let listed = s.execute("document.list", &json!({})).unwrap();
assert_eq!((listed[0].get("preview"), &listed[1]["preview"]), (None, &json!(true)));
assert_eq!(s.end_new_document_preview(), Some(b));
let d = s.doc().unwrap();
assert_eq!((s.documents().len(), d.uid, d.is_dirty(), d.history.undo.len()), (1, first, false, 0));
assert_eq!(s.end_new_document_preview(), None, "without a preview it does nothing");
// Edited by a script while shown, it writes no recovery data while it is a preview, and
// stays as a document when the window closes, with its Untitled number.
let c = s.preview_new_document(&json!({})).unwrap();
s.execute("frame.create", &json!({"rect": [10, 10, 100, 100]})).unwrap();
assert_eq!(crate::recovery::save(&s, &dir).unwrap(), 0);
// The app's timer saves through the command.
assert_eq!(s.execute("file.recovery.save", &json!({})).unwrap()["saved"], 0);
assert!(crate::recovery::list(&dir).is_empty());
assert_eq!(s.end_new_document_preview(), None);
assert_eq!((s.documents().len(), s.doc().unwrap().uid, s.doc().unwrap().doc.title.as_str()), (2, c, "Untitled-2"));
s.execute("file.new", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().doc.title, "Untitled-3");
// Create with the previewed settings keeps the preview as the document.
let d = s.preview_new_document(&json!({"pages": 2})).unwrap();
assert_eq!(s.keep_new_document_preview(), Some(3));
let st = s.doc().unwrap();
assert_eq!((st.uid, st.doc.title.as_str(), s.new_document_preview()), (d, "Untitled-4", None));
s.execute("file.new", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().doc.title, "Untitled-5");
let _ = std::fs::remove_dir_all(&dir);
}
}
#[cfg(test)]
mod hyphenation_default_tests {
use std::sync::Arc;
use designcraft_doc::BASIC_PARAGRAPH;
use designcraft_doc::build::NewDocument;
use serde_json::json;
use crate::Session;
fn hyph_flags(d: &designcraft_doc::Document) -> (bool, bool, bool) {
let (pp, _) = d.styles.resolve_para(&designcraft_doc::ParaFormat::default());
(pp.hyph_capitalized, pp.hyph_last_word, pp.hyph_across_column)
}
#[test]
fn new_documents_hyphenate_no_capitalized_last_or_column_end_words_and_imports_keep_theirs() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
assert_eq!(hyph_flags(&s.doc().unwrap().doc), (false, false, false));
let mut d = designcraft_doc::Document::new(&NewDocument::default());
let st = Arc::make_mut(&mut d.styles).para_mut(BASIC_PARAGRAPH).unwrap();
st.para.hyph_capitalized = Some(true);
st.para.hyph_last_word = Some(true);
st.para.hyph_across_column = Some(true);
let b64 = super::base64_encode(&designcraft_idml::export_idml(&d));
s.execute("file.openIdml", &json!({"base64": b64, "name": "in.idml"})).unwrap();
assert_eq!(hyph_flags(&s.doc().unwrap().doc), (true, true, true));
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.