2bc41aeb8602
document_setup.rs
//! File → Document Setup: General (units, bleed, Edit Artboards, outline images, the substituted
//! glyphs highlight), Transparency (grid size and colours, simulated paper, flattener preset, white
//! overprint), Type (language, quotes, superscript/subscript/small caps, text export) and Color
//! (document color mode and assigned profiles) tabs.
//!
//! Fields: what `document.setup` reports (and takes back), plus `tab`, `bleedLinked` and the Color
//! tab's `colorMode`, `convertColors`, `rgbProfile` and `cmykProfile` (null: the working space).
//! OK runs `document.setup` with them: one undo step. When the Color tab changed something, OK runs
//! `document.setup`, `edit.assignProfile` and `file.documentColorMode` in one `command.batch`,
//! and the document's changes are still one undo step. On an error the dialog stays open. When OK
//! raises the bleed on a side, the status bar counts the objects that reach an artboard's trim edge
//! on a side OK raised but stop short of the new bleed there.
use serde_json::{Map, Value, json};
use vectorcraft_color::cms::ProfileKind;
use vectorcraft_doc::setup::{GRID_COLOR_PRESETS, LANGUAGES, bleed_in_range};
use vectorcraft_doc::{ColorMode, GridSize, Quotes, Unit};
use vectorcraft_engine::cmd::colormgmt::doc_profiles;
use vectorcraft_engine::cmd::fileio::pdf;
use super::{DialogSpec, form};
use crate::state::Dialog;
use crate::theme::Tokens;
use crate::{VectorcraftApp, widgets};
pub(super) const KIND: &str = "documentSetup";
const TABS: [&str; 4] = ["General", "Transparency", "Type", "Color"];
/// Dialog-only fields `document.setup` doesn't take.
const UI_ONLY: [&str; 6] = ["tab", "bleedLinked", "colorMode", "convertColors", "rgbProfile", "cmykProfile"];
pub(super) const LABEL: f32 = 130.0;
/// The profile rows' entry for no assigned profile: the document uses the working space.
const WORKING_RGB: &str = "Working RGB (don't tag)";
const WORKING_CMYK: &str = "Working CMYK (don't tag)";
pub(super) const SPEC: DialogSpec =
DialogSpec { heading: |_| tl!("Document Setup").into(), body, confirm, min_width: 540.0, max_width: Some(540.0), ..DialogSpec::FORM };
/// Open Document Setup on the active document's settings.
pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
let mut fields = app.session.execute("document.setup", &json!({})).map_err(|e| e.to_string())?;
let linked = fields["bleed"].as_array().is_some_and(|b| b.windows(2).all(|w| w[0] == w[1]));
fields["bleedLinked"] = json!(linked);
fields["tab"] = json!(TABS[0]);
if let Some(st) = app.session.active() {
fields["gridColors"] = json!(st.doc.setup.grid_colors.map(|c| grid_color_entry(&c)));
let (rgb, cmyk) = doc_profiles(&st.doc);
fields["colorMode"] = json!(mode_id(st.doc.color_mode));
fields["rgbProfile"] = json!(rgb);
fields["cmykProfile"] = json!(cmyk);
}
fields["convertColors"] = json!(true);
app.ui.dialog = Some(Dialog::new(KIND, fields));
Ok(Value::Null)
}
/// The `mode` param of `file.documentColorMode` for `m`.
fn mode_id(m: ColorMode) -> &'static str {
match m {
ColorMode::Rgb => "rgb",
ColorMode::Cmyk => "cmyk",
}
}
/// The commands the Color tab's changes run, as `command.batch` steps, in the order OK runs them:
/// Edit › Assign Profile first, so that a mode change converts through the profiles it assigns,
/// then File › Document Color Mode. Empty when the tab matches the active document. A field the
/// dialog holds with a value of the wrong kind is an error, and then nothing runs; an omitted
/// field leaves its setting as it is (`convertColors`: converts).
fn color_commands(app: &VectorcraftApp, d: &Dialog) -> Result<Vec<Value>, String> {
let Some(st) = app.session.active() else { return Ok(vec![]) };
let mut out = vec![];
let (rgb, cmyk) = doc_profiles(&st.doc);
let mut assign = Map::new();
for (key, param, current) in [("rgbProfile", "rgb", rgb), ("cmykProfile", "cmyk", cmyk)] {
let chosen = match d.fields.get(key) {
None => continue,
Some(Value::Null) => None,
Some(Value::String(n)) => Some(n.clone()),
Some(_) => return Err(format!("`{key}` must be a profile name or null")),
};
if chosen != current {
assign.insert(param.into(), json!(chosen));
}
}
let mode = match d.fields.get("colorMode") {
None => None,
Some(Value::String(m)) if m.eq_ignore_ascii_case("rgb") => Some(ColorMode::Rgb),
Some(Value::String(m)) if m.eq_ignore_ascii_case("cmyk") => Some(ColorMode::Cmyk),
Some(_) => return Err("`colorMode` must be one of rgb, cmyk".into()),
};
let key = "convertColors";
let convert = match d.fields.get(key) {
None => true,
Some(Value::Bool(b)) => *b,
Some(_) => return Err(format!("`{key}` must be true or false")),
};
if !assign.is_empty() {
out.push(json!({"command": "edit.assignProfile", "params": assign}));
}
if let Some(mode) = mode.filter(|m| *m != st.doc.color_mode) {
out.push(json!({"command": "file.documentColorMode", "params": {"mode": mode_id(mode), "convert": convert}}));
}
Ok(out)
}
fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
let params: Map<String, Value> = d.fields.iter().filter(|(k, _)| !UI_ONLY.contains(&k.as_str())).map(|(k, v)| (k.clone(), v.clone())).collect();
let color = color_commands(app, d)?;
let before = app.session.active().map(|st| st.doc.setup.bleed);
let r = if color.is_empty() {
app.run("document.setup", Value::Object(params))
} else {
let commands: Vec<Value> = std::iter::once(json!({"command": "document.setup", "params": params})).chain(color).collect();
app.run("command.batch", json!({"label": "Document Setup", "commands": commands}))
};
if r.is_ok() {
app.ui.dialog = None;
if let Some(note) = before.and_then(|b| short_of_bleed_note(app, b)) {
app.status(note);
}
}
r
}
/// The status note after OK raised the bleed on a side from `before`: how many objects reach an
/// artboard's trim edge on a side whose bleed grew but stop short of the new bleed there. `None`
/// when no side grew or no object stops short.
fn short_of_bleed_note(app: &VectorcraftApp, before: [f64; 4]) -> Option<String> {
let doc = &app.session.active()?.doc;
// In the range the PDF pages keep the document's bleed to.
let (bleed, before) = (bleed_in_range(doc.setup.bleed), bleed_in_range(before));
let raised: [f64; 4] = std::array::from_fn(|i| if bleed[i] > before[i] { bleed[i] } else { 0.0 });
pdf::short_of_bleed_warning(pdf::short_of_bleed(doc, raised, None, false))
}
fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
let tab = TABS.iter().position(|t| *t == d.str("tab")).unwrap_or(0);
if let Some(i) = widgets::tab_bar(ui, &TABS, tab) {
d.fields.insert("tab".into(), json!(TABS[i]));
}
ui.add_space(12.0);
let mut close = false;
ui.vertical(|ui| {
ui.set_min_height(330.0);
match tab {
0 => close = general(app, ui, d),
1 => transparency(app, ui, d),
2 => typography(ui, d),
_ => color(app, ui, d),
}
});
close
}
/// A dropdown row bound to the string `d.fields[key]`; `options` are (value, label).
pub(super) fn choice(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str, options: &[(&str, &str)]) {
form::choice(ui, d, key, label, (LABEL, 220.0), options);
}
/// A checkbox bound to `d.fields[key]`.
pub(super) fn check(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str) {
let on = d.bool(key);
if widgets::check(ui, label, on, true) {
d.fields.insert(key.into(), json!(!on));
}
}
/// The units the dialog shows lengths in.
fn unit(d: &Dialog) -> Unit {
Unit::named(&d.str("units")).unwrap_or_default()
}
/// The General tab of Document Setup (units, bleed, artboard editing, options).
fn general(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
let units: Vec<(&str, &str)> = Unit::ALL.iter().map(|u| (u.label(), u.label())).collect();
choice(ui, d, "units", tl!("Units:"), &units);
ui.add_space(6.0);
let unit = unit(d);
widgets::label_row(ui, tl!("Bleed:"), LABEL, |ui| form::bleed(ui, d, unit, 64.0));
ui.add_space(6.0);
let mut close = false;
widgets::label_row(ui, "", LABEL, |ui| {
// Applies the settings, then edits the artboards with the Artboard tool.
if widgets::flat_button_fit(ui, tl!("Edit Artboards"), 120.0).clicked() && confirm(app, d).is_ok() {
app.select_tool("artboard");
// The shared frame restores its working copy after drawing the body. Tell it to
// close too, otherwise it reopens the dialog that confirm just closed.
close = true;
}
});
ui.add_space(12.0);
check(ui, d, "outlineImages", tl!("Show Images in Outline Mode"));
check(ui, d, "highlightSubstitutedGlyphs", tl!("Highlight Substituted Glyphs"));
close
}
/// The id of the Transparency tab's box that shows grid color `index` (0 or 1).
fn grid_color_box_id(index: usize) -> egui::Id {
egui::Id::unique(("grid-color-box", index))
}
/// The size of the Transparency tab's grid preview, in points.
const GRID_PREVIEW: egui::Vec2 = egui::vec2(112.0, 72.0);
/// The grid size and the two colors the grid preview shows for the dialog's fields `fields`, read
/// as `document.setup` reads them (a preset name or two colors): a field that is missing or not a
/// valid value shows as `setup`, the document's setting.
fn preview_grid(fields: &Map<String, Value>, setup: &vectorcraft_doc::DocSetup) -> (GridSize, [vectorcraft_color::Color; 2]) {
let size = fields.get("gridSize").and_then(Value::as_str).and_then(GridSize::parse).unwrap_or(setup.grid_size);
(size, grid_colors(fields, setup))
}
/// The two grid colors the dialog's fields `fields` hold, read as `document.setup` reads
/// `gridColors` (a preset name, in any letter case, or two colors): a field that is missing or not
/// a valid value gives `setup`'s colors, the document's setting.
fn grid_colors(fields: &Map<String, Value>, setup: &vectorcraft_doc::DocSetup) -> [vectorcraft_color::Color; 2] {
let colors = match fields.get("gridColors") {
Some(Value::String(name)) => GRID_COLOR_PRESETS.iter().find(|(n, _)| n.eq_ignore_ascii_case(name)).map(|(_, pair)| *pair),
Some(Value::Array(a)) if a.len() == 2 => a.iter().map(vectorcraft_engine::cmd::color_value).collect::<Option<Vec<_>>>().map(|c| [c[0], c[1]]),
_ => None,
};
colors.unwrap_or(setup.grid_colors)
}
/// The dialog's `gridColors` when it is a list of two colors `document.setup` reads, entries as
/// they are.
fn pending_grid_pair(fields: &Map<String, Value>) -> Option<Vec<Value>> {
let entries = fields.get("gridColors").and_then(Value::as_array)?;
(entries.len() == 2 && entries.iter().all(|c| vectorcraft_engine::cmd::color_value(c).is_some())).then(|| entries.clone())
}
/// Color `c` as an entry of the dialog's `gridColors` that `document.setup` reads back as `c`: its
/// hex code when that reads back as `c`, else the color in its own model (a Lab or CMYK color, or
/// an RGB color whose hex code is converted to display RGB or rounded).
fn grid_color_entry(c: &vectorcraft_color::Color) -> Value {
let hex = json!(c.to_hex());
if vectorcraft_engine::cmd::color_value(&hex) == Some(*c) { hex } else { serde_json::to_value(c).unwrap_or(hex) }
}
/// The checkered preview of the grid the dialog's Grid Size and Grid Colors hold, drawn with the
/// canvas's transparency grid tile and cell size: the first color in the top-left cell. It goes
/// beside the rows that start at `top`, against the right edge, or below them when they leave no
/// room. It shows the grid whatever Simulate Colored Paper and View › Show Transparency Grid are,
/// and changes nothing in the document.
fn grid_preview(app: &VectorcraftApp, ui: &mut egui::Ui, d: &Dialog, top: f32) {
let t = Tokens::get(ui.ctx());
let fallback = vectorcraft_doc::DocSetup::default();
let setup = app.session.active().map_or(&fallback, |st| &st.doc.setup);
let (size, colors) = preview_grid(&d.fields, setup);
let right = ui.max_rect().right();
let rect = if ui.min_rect().right() + 16.0 + GRID_PREVIEW.x <= right {
egui::Rect::from_min_size(egui::pos2(right - GRID_PREVIEW.x, top), GRID_PREVIEW)
} else {
ui.add_space(4.0);
ui.allocate_exact_size(GRID_PREVIEW, egui::Sense::hover()).0
};
let resp = ui.interact(rect, grid_preview_id(), egui::Sense::hover());
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Image, true, tl!("Transparency Grid")));
let display = app.display_profile.transform(app.session.prefs.monitor_profile_display);
let id = egui::Id::unique("document-setup-grid-preview").with(display.is_some());
let tile = crate::canvas::checker_tile(ui.ctx(), colors, display.as_deref(), id);
let uv = egui::Rect::from_min_max(egui::Pos2::ZERO, (rect.size() / (2.0 * size.cell())).to_pos2());
ui.painter().image(tile.id(), rect, uv, egui::Color32::WHITE);
ui.painter().rect_stroke(rect, 0.0, egui::Stroke::new(1.0, t.input_border), egui::StrokeKind::Outside);
}
/// The id of the Transparency tab's grid preview.
fn grid_preview_id() -> egui::Id {
egui::Id::unique("grid-preview")
}
fn transparency(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
let t = Tokens::get(ui.ctx());
widgets::subheader(ui, tl!("Transparency Grid"));
let top = ui.cursor().top();
let sizes: Vec<(&str, &str)> = GridSize::ALL.iter().map(|g| (g.id(), g.label())).collect();
choice(ui, d, "gridSize", tl!("Grid Size:"), &sizes);
// A preset name in the fields (any case, as `document.setup` takes it) becomes the preset's two
// colors, which the hex fields and the Color Picker edit one at a time.
if let Some((_, pair)) =
d.fields.get("gridColors").and_then(Value::as_str).and_then(|n| GRID_COLOR_PRESETS.iter().find(|(p, _)| p.eq_ignore_ascii_case(n)))
{
d.fields.insert("gridColors".into(), json!(pair.map(|c| grid_color_entry(&c))));
}
// The pair the field holds, or the document's pair when it holds no two colors, so each box and
// hex field shows a color and the picker and hex fields set an entry of a two-color list. The
// menu names the preset whose colors the pair is, as `document.setup` names it.
let fallback = vectorcraft_doc::DocSetup::default();
let setup = app.session.active().map_or(&fallback, |st| &st.doc.setup);
let resolved = grid_colors(&d.fields, setup);
let colors: Vec<String> = resolved.iter().map(vectorcraft_color::Color::to_hex).collect();
let preset = GRID_COLOR_PRESETS.iter().find(|(_, pair)| *pair == resolved).map_or("Custom", |(n, _)| n);
let names: Vec<&str> = GRID_COLOR_PRESETS.iter().map(|(n, _)| *n).chain(["Custom"]).collect();
widgets::label_row(ui, tl!("Grid Colors:"), LABEL, |ui| {
if let Some((_, pair)) = widgets::dropdown(ui, "gridColors", preset, &names, 220.0).and_then(|i| GRID_COLOR_PRESETS.get(i)) {
d.fields.insert("gridColors".into(), json!(pair.map(|c| grid_color_entry(&c))));
}
});
// The two colours (the first is also the paper colour): editing either makes them Custom. A
// click on a color's box, or Space or Enter with the keyboard on it, opens the Color Picker on
// that color, and the picker's OK sets that color. The picker opens after the row, on the color
// Document Setup holds then: a press on a box ends a hex field's editing in the same frame, and
// that field's edit is the color the picker opens on. A hex field's edit replaces its own color
// in the pair Document Setup holds when it commits, and the other entry stays as it is.
let mut pick = None;
widgets::label_row(ui, "", LABEL, |ui| {
for i in 0..2 {
let hex = colors.get(i).map_or("", |h| h.trim_start_matches('#'));
let colour = vectorcraft_color::Color::from_hex(hex);
let name = format!("{} {}", tl!("Grid Colors:"), i + 1);
let (chip, _) = ui.allocate_exact_size(egui::vec2(18.0, 18.0), egui::Sense::hover());
let resp = ui.interact(chip, grid_color_box_id(i), egui::Sense::click());
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, &name));
let keyed = resp.has_focus()
&& ui.input_mut(|inp| {
inp.consume_key(egui::Modifiers::NONE, egui::Key::Space) | inp.consume_key(egui::Modifiers::NONE, egui::Key::Enter)
});
if resp.clicked() || keyed {
pick = Some(i);
}
if resp.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
}
if let Some(c) = colour {
ui.painter().rect_filled(chip, 2.0, crate::panels::c32(&c));
}
ui.painter().rect_stroke(chip, 2.0, egui::Stroke::new(1.0, t.input_border), egui::StrokeKind::Inside);
if resp.has_focus() {
ui.painter().rect_stroke(chip.expand(2.0), 3.0, ui.visuals().selection.stroke, egui::StrokeKind::Outside);
}
if let Some(c) = widgets::hex_field_named(ui, ("grid-color", i), Some(&name), hex).and_then(|h| vectorcraft_color::Color::from_hex(&h)) {
let mut v = pending_grid_pair(&d.fields).unwrap_or_else(|| grid_colors(&d.fields, setup).iter().map(grid_color_entry).collect());
v[i] = grid_color_entry(&c);
d.fields.insert("gridColors".into(), json!(v));
}
ui.add_space(10.0);
}
});
grid_preview(app, ui, d, top);
if let Some(i) = pick {
// A field that is not two colors becomes the pair the boxes show when the picker's OK sets
// its entry; its Cancel goes back to the field as it was.
let pair = grid_colors(&d.fields, setup);
let fill = pending_grid_pair(&d.fields).is_none().then(|| json!(pair.map(|c| grid_color_entry(&c))));
let c = pair.get(i).copied().unwrap_or(vectorcraft_color::Color::WHITE);
*d = super::color_picker::over_list_entry(d, "gridColors", i, c, fill);
}
ui.add_space(4.0);
check(ui, d, "simulatePaper", tl!("Simulate Colored Paper"));
ui.add_space(14.0);
widgets::subheader(ui, tl!("Export and Clipboard Transparency Flattener Settings"));
let presets: Vec<String> = app.session.flattener_presets().into_iter().map(|p| p.name).collect();
let options: Vec<(&str, &str)> = presets.iter().map(|p| (p.as_str(), p.as_str())).collect();
choice(ui, d, "flattenerPreset", tl!("Preset:"), &options);
check(ui, d, "discardWhiteOverprint", tl!("Discard White Overprint in Output"));
}
fn typography(ui: &mut egui::Ui, d: &mut Dialog) {
let t = Tokens::get(ui.ctx());
let langs: Vec<(&str, &str)> = LANGUAGES.iter().map(|(l, _, _)| (*l, *l)).collect();
let before = d.str("language");
choice(ui, d, "language", tl!("Language:"), &langs);
// A language brings its quotes.
if d.str("language") != before
&& let Some(q) = vectorcraft_doc::setup::language_quotes(&d.str("language"))
{
d.fields.insert("quotes".into(), json!({"double": q.double.iter().collect::<String>(), "single": q.single.iter().collect::<String>()}));
}
for (key, label, choices) in
[("double", tl!("Double Quotes:"), Quotes::DOUBLE_CHOICES), ("single", tl!("Single Quotes:"), Quotes::SINGLE_CHOICES)]
{
let pairs: Vec<String> = choices.iter().map(|p| p.iter().collect()).collect();
let labels: Vec<&str> = pairs.iter().map(String::as_str).collect();
let cur = d.fields.get("quotes").and_then(|q| q.get(key)).and_then(Value::as_str).unwrap_or("").to_string();
widgets::label_row(ui, label, LABEL, |ui| {
if let Some(pair) = widgets::dropdown(ui, ("quotes", key), &cur, &labels, 90.0).and_then(|i| pairs.get(i)) {
let mut q = d.fields.get("quotes").cloned().unwrap_or_else(|| json!({}));
q[key] = json!(pair);
d.fields.insert("quotes".into(), q);
}
});
}
check(ui, d, "typographersQuotes", tl!("Use Typographer's Quotes"));
ui.add_space(14.0);
widgets::subheader(ui, tl!("Options"));
egui::Grid::new("docsetup-scripts").num_columns(3).spacing([16.0, 6.0]).show(ui, |ui| {
ui.label("");
for h in [tl!("Size"), tl!("Position")] {
ui.label(egui::RichText::new(h).size(11.0).color(t.text_dim));
}
ui.end_row();
for (key, label) in [("superscript", tl!("Superscript:")), ("subscript", tl!("Subscript:"))] {
widgets::field_label(ui, egui::RichText::new(label).color(t.text));
for part in ["size", "position"] {
let v = d.fields.get(key).and_then(|m| m.get(part)).and_then(Value::as_f64).unwrap_or(0.0);
if let Some(n) = widgets::plain_field(ui, (key, part), v, "%", 1, 70.0) {
let mut m = d.fields.get(key).cloned().unwrap_or_else(|| json!({}));
m[part] = json!(n);
d.fields.insert(key.into(), m);
}
}
ui.end_row();
}
widgets::field_label(ui, egui::RichText::new(tl!("Small Caps:")).color(t.text));
if let Some(n) = widgets::plain_field(ui, "smallCaps", d.f64("smallCapsSize", 70.0), "%", 1, 70.0) {
d.fields.insert("smallCapsSize".into(), json!(n));
}
ui.end_row();
});
ui.add_space(6.0);
choice(ui, d, "exportText", tl!("Export:"), &[("editable", tl!("Preserve Text Editability")), ("appearance", tl!("Preserve Text Appearance"))]);
}
/// The Color tab: the document color mode, whether a mode change converts the colors (unchecked:
/// they keep their numbers), and the RGB and CMYK profiles assigned to the document.
fn color(app: &VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
widgets::subheader(ui, tl!("Document Color Mode"));
choice(ui, d, "colorMode", tl!("Color Mode:"), &[("rgb", "RGB Color"), ("cmyk", "CMYK Color")]);
let mode = d.str("colorMode");
let changes = app.session.active().is_some_and(|st| mode_id(st.doc.color_mode) != mode);
let label = if mode == "cmyk" { tl!("Convert to CMYK") } else { tl!("Convert to RGB") };
widgets::label_row(ui, "", LABEL, |ui| {
let on = d.bool("convertColors");
if widgets::check(ui, label, on, changes) {
d.fields.insert("convertColors".into(), json!(!on));
}
});
ui.add_space(14.0);
widgets::subheader(ui, tl!("Assign Profile"));
for (key, label, kind, working) in
[("rgbProfile", tl!("RGB:"), ProfileKind::Rgb, WORKING_RGB), ("cmykProfile", tl!("CMYK:"), ProfileKind::Cmyk, WORKING_CMYK)]
{
let current = d.fields.get(key).and_then(Value::as_str).unwrap_or(working).to_string();
widgets::label_row(ui, label, LABEL, |ui| {
if let Some(n) = crate::panels::separations::profile_dropdown(ui, key, ¤t, kind, Some(working)) {
d.fields.insert(key.into(), if n == working { Value::Null } else { json!(n) });
}
});
}
}
#[cfg(test)]
mod tests {
use egui::{Event, PointerButton, Pos2, Rect, vec2};
use serde_json::{Value, json};
use vectorcraft_color::{Color, Paint, cms};
use vectorcraft_doc::{ColorMode, NodeId};
use vectorcraft_engine::Session;
use crate::VectorcraftApp;
fn dialog_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<Event>) -> Vec<(String, Rect)> {
let raw = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 900.0))), events, ..Default::default() };
let mut out = ctx.run_ui(raw, |ui| crate::dialogs::show(app, ui.ctx()));
out.textures_delta.clear();
out.shapes
.iter()
.filter_map(|s| match &s.shape {
egui::Shape::Text(t) => Some((t.galley.text().to_string(), Rect::from_min_size(t.pos, t.galley.size()))),
_ => None,
})
.collect()
}
fn click_dialog_button(app: &mut VectorcraftApp, label: &str) {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
crate::theme::apply(&ctx, Default::default());
dialog_frame(app, &ctx, vec![]);
let texts = dialog_frame(app, &ctx, vec![]);
let at = texts.iter().find(|(text, _)| text == label).unwrap_or_else(|| panic!("missing {label}: {texts:?}")).1.center();
let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
dialog_frame(app, &ctx, vec![Event::PointerMoved(at), button(true)]);
dialog_frame(app, &ctx, vec![button(false)]);
dialog_frame(app, &ctx, vec![]);
}
#[test]
fn edit_artboards_applies_settings_and_closes_the_dialog() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("bleed".into(), json!([9, 9, 9, 9]));
click_dialog_button(&mut app, "Edit Artboards");
assert!(app.ui.dialog.is_none(), "Edit Artboards must leave the canvas accessible");
assert_eq!(app.session.tool_id(), "artboard");
let st = app.session.active().unwrap();
assert_eq!(st.doc.setup.bleed, [9.0; 4]);
assert_eq!(st.history.undo.len(), 1);
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc.setup.bleed, [0.0; 4]);
}
#[test]
fn edit_artboards_with_invalid_settings_keeps_the_dialog_and_tool() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("bleed".into(), json!(500));
click_dialog_button(&mut app, "Edit Artboards");
assert!(app.ui.dialog.is_some());
assert_eq!(app.session.tool_id(), "selection");
let st = app.session.active().unwrap();
assert_eq!(st.doc.setup.bleed, [0.0; 4]);
assert!(st.history.undo.is_empty());
}
#[test]
fn ok_and_cancel_close_without_switching_tools() {
for (button, expected_bleed, undo_steps) in [("OK", [9.0; 4], 1), ("Cancel", [0.0; 4], 0)] {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("bleed".into(), json!([9, 9, 9, 9]));
click_dialog_button(&mut app, button);
assert!(app.ui.dialog.is_none(), "{button}");
assert_eq!(app.session.tool_id(), "selection");
let st = app.session.active().unwrap();
assert_eq!(st.doc.setup.bleed, expected_bleed);
assert_eq!(st.history.undo.len(), undo_steps);
}
}
fn frame(app: &mut VectorcraftApp) {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
crate::theme::apply(&ctx, Default::default());
let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 900.0))), ..Default::default() };
let mut out = ctx.run_ui(raw, |ui| crate::dialogs::show(app, ui.ctx()));
out.textures_delta.clear();
}
#[test]
fn every_tab_draws_and_ok_is_one_undo_step() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
for tab in ["General", "Transparency", "Type", "Color"] {
app.ui.dialog.as_mut().unwrap().fields.insert("tab".into(), json!(tab));
frame(&mut app);
}
let d = app.ui.dialog.as_mut().unwrap();
assert_eq!((d.fields["flattenerPreset"].as_str(), d.fields["bleedLinked"].as_bool()), (Some("Medium Resolution"), Some(true)));
for (k, v) in [("bleed", json!([9, 9, 9, 9])), ("gridColors", json!("Blue")), ("language", json!("German")), ("units", json!("Millimeters"))]
{
d.fields.insert(k.into(), v);
}
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
let st = app.session.active().unwrap();
assert_eq!((st.doc.setup.bleed, st.doc.setup.grid_colors_name()), ([9.0; 4], "Blue"));
assert_eq!((st.doc.setup.quotes.double, st.doc.units), (['„', '“'], vectorcraft_doc::Unit::Millimeters));
assert_eq!(st.history.undo.len(), 1);
// A bad value keeps the dialog open.
app.run("file.documentSetup", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("bleed".into(), json!(500));
assert!(crate::dialogs::confirm(&mut app).is_err());
assert!(app.ui.dialog.is_some());
}
/// OK with a larger bleed shows how many objects reach the trim edge but stop short of it; a
/// smaller bleed, or a larger one that no object falls short of, shows no such note.
#[test]
fn ok_with_a_larger_bleed_counts_the_art_short_of_it() {
let short = |app: &VectorcraftApp| app.ui.status.contains("short of the bleed");
let ok_with_sides = |app: &mut VectorcraftApp, bleed: [f64; 4]| {
app.status("");
app.run("file.documentSetup", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("bleed".into(), json!(bleed));
crate::dialogs::confirm(app).unwrap();
};
let ok_with_bleed = |app: &mut VectorcraftApp, bleed: f64| ok_with_sides(app, [bleed; 4]);
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
// A background that fills a 4 pt bleed on the top, left and right.
let id = app.run("shape.rectangle", json!({"x": -4, "y": -4, "width": 208, "height": 50})).unwrap()["id"].clone();
app.run("paint.setStroke", json!({"ids": [id], "none": true})).unwrap();
ok_with_bleed(&mut app, 4.0);
assert!(!short(&app), "{}", app.ui.status);
ok_with_bleed(&mut app, 9.0);
assert_eq!(app.ui.status, "1 object reaches the trim edge but stops short of the bleed");
ok_with_bleed(&mut app, 6.0);
assert!(!short(&app), "{}", app.ui.status);
// Only the sides whose bleed grows count: the background stops short at the top, left and
// right, so a larger bottom bleed alone shows no note, and a larger top bleed does.
ok_with_sides(&mut app, [6.0, 12.0, 6.0, 6.0]);
assert!(!short(&app), "{}", app.ui.status);
ok_with_sides(&mut app, [12.0, 12.0, 6.0, 6.0]);
assert!(short(&app), "{}", app.ui.status);
// Art inside the trim falls short of no bleed.
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
ok_with_bleed(&mut app, 9.0);
assert!(!short(&app), "{}", app.ui.status);
assert_eq!(app.session.active().unwrap().doc.setup.bleed, [9.0; 4]);
// A bleed that isn't a number, as a file can hold, counts as none before OK, as in the PDF.
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 200, "height": 50})).unwrap();
std::sync::Arc::make_mut(&mut app.session.doc_mut().unwrap().doc).setup.bleed = [f64::NAN; 4];
ok_with_bleed(&mut app, 9.0);
assert_eq!(app.ui.status, "1 object reaches the trim edge but stops short of the bleed");
}
/// Highlight Substituted Fonts is in Preferences › Type, so the General tab shows only the
/// substituted glyphs highlight, and OK still applies.
#[test]
fn general_tab_has_no_substituted_fonts_checkbox() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
assert!(app.ui.dialog.as_ref().unwrap().fields.get("highlightSubstitutedFonts").is_none());
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
crate::theme::apply(&ctx, Default::default());
dialog_frame(&mut app, &ctx, vec![]);
let texts: Vec<String> = dialog_frame(&mut app, &ctx, vec![]).into_iter().map(|(t, _)| t).collect();
assert!(texts.iter().any(|t| t == "Highlight Substituted Glyphs"), "{texts:?}");
assert!(!texts.iter().any(|t| t == "Highlight Substituted Fonts"), "{texts:?}");
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
}
/// A new document with a red square → the app and the square.
fn red_square() -> (VectorcraftApp, NodeId) {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
app.run("paint.setFill", json!({"ids": [id], "color": "#ff0000"})).unwrap();
(app, NodeId(id))
}
fn fill(app: &VectorcraftApp, id: NodeId) -> Paint {
app.session.active().unwrap().doc.node(id).unwrap().appearance.fill().unwrap().paint.clone()
}
fn undo_steps(app: &VectorcraftApp) -> usize {
app.session.active().unwrap().history.undo.len()
}
/// Opens Document Setup on the Color tab and sets `fields` in it.
fn color_tab(app: &mut VectorcraftApp, fields: serde_json::Value) {
app.run("file.documentSetup", json!({})).unwrap();
let d = app.ui.dialog.as_mut().unwrap();
d.fields.insert("tab".into(), json!("Color"));
for (k, v) in fields.as_object().unwrap() {
d.fields.insert(k.clone(), v.clone());
}
}
/// The Color tab opens on the document's color mode and assigned profiles, and shows them.
/// The CMYK profile assigned is the working one, so the process-wide color settings stay as
/// they are for the other tests.
#[test]
fn color_tab_shows_the_color_mode_and_profiles() {
let (mut app, _) = red_square();
let working = cms::active_settings().cmyk;
app.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
app.run("edit.assignProfile", json!({"cmyk": working})).unwrap();
let steps = undo_steps(&app);
color_tab(&mut app, json!({}));
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.str("colorMode"), d.str("cmykProfile"), d.fields["rgbProfile"].clone()), ("cmyk".into(), working.clone(), json!(null)));
assert!(d.bool("convertColors"));
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
crate::theme::apply(&ctx, Default::default());
dialog_frame(&mut app, &ctx, vec![]);
let texts: Vec<String> = dialog_frame(&mut app, &ctx, vec![]).into_iter().map(|(t, _)| t).collect();
for shown in ["CMYK Color", "Convert to CMYK", "Working RGB (don't tag)", working.as_str()] {
assert!(texts.iter().any(|t| t == shown), "no {shown} in {texts:?}");
}
// Picking the other mode names the conversion OK makes.
app.ui.dialog.as_mut().unwrap().fields.insert("colorMode".into(), json!("rgb"));
let texts: Vec<String> = dialog_frame(&mut app, &ctx, vec![]).into_iter().map(|(t, _)| t).collect();
assert!(texts.iter().any(|t| t == "Convert to RGB"), "{texts:?}");
app.ui.dialog.as_mut().unwrap().fields.insert("colorMode".into(), json!("cmyk"));
// OK with nothing changed records nothing.
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
assert_eq!(undo_steps(&app), steps);
}
/// OK with a new mode converts the colors as File › Document Color Mode does, together with the
/// dialog's other changes, in one undo step.
#[test]
fn ok_converts_the_color_mode_with_the_other_changes_in_one_undo_step() {
let (mut app, id) = red_square();
let (mut menu, menu_id) = red_square();
menu.run("file.documentColorMode", json!({"mode": "cmyk"})).unwrap();
let steps = undo_steps(&app);
color_tab(&mut app, json!({"colorMode": "cmyk", "bleed": [9, 9, 9, 9]}));
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
let st = app.session.active().unwrap();
assert_eq!((st.doc.color_mode, st.doc.setup.bleed), (ColorMode::Cmyk, [9.0; 4]));
assert_eq!(fill(&app, id), fill(&menu, menu_id));
assert!(matches!(fill(&app, id), Paint::Solid { color: Color::Cmyk { .. }, .. }), "{:?}", fill(&app, id));
assert_eq!(undo_steps(&app), steps + 1);
app.run("edit.undo", json!({})).unwrap();
let st = app.session.active().unwrap();
assert_eq!((st.doc.color_mode, st.doc.setup.bleed), (ColorMode::Rgb, [0.0; 4]));
assert_eq!(fill(&app, id), Paint::solid(Color::from_hex("ff0000").unwrap()));
}
/// With Convert unchecked the mode changes and the colors keep their numbers.
#[test]
fn ok_without_convert_keeps_the_color_numbers() {
let (mut app, id) = red_square();
let before = fill(&app, id);
let steps = undo_steps(&app);
color_tab(&mut app, json!({"colorMode": "cmyk", "convertColors": false}));
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!(app.session.active().unwrap().doc.color_mode, ColorMode::Cmyk);
assert_eq!(fill(&app, id), before);
assert_eq!(undo_steps(&app), steps + 1);
}
/// OK assigns the profiles picked, with the dialog's other changes, in one undo step; the
/// working-space entry assigns none.
#[test]
fn ok_assigns_the_profiles_with_the_other_changes_in_one_undo_step() {
let (mut app, _) = red_square();
let working = cms::active_settings().cmyk;
let steps = undo_steps(&app);
color_tab(&mut app, json!({"cmykProfile": working, "bleed": [9, 9, 9, 9]}));
crate::dialogs::confirm(&mut app).unwrap();
let st = app.session.active().unwrap();
assert_eq!((st.doc.color_profiles.cmyk.clone(), st.doc.color_profiles.rgb.clone()), (Some(working.clone()), None));
assert_eq!((st.doc.setup.bleed, st.doc.color_mode), ([9.0; 4], ColorMode::Rgb));
assert_eq!(undo_steps(&app), steps + 1);
// Back to the working space: no profile assigned.
color_tab(&mut app, json!({"cmykProfile": null}));
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!(app.session.active().unwrap().doc.color_profiles.cmyk, None);
app.run("edit.undo", json!({})).unwrap();
app.run("edit.undo", json!({})).unwrap();
let st = app.session.active().unwrap();
assert_eq!((st.doc.color_profiles.cmyk.clone(), st.doc.setup.bleed), (None, [0.0; 4]));
}
/// OK assigns the RGB profile picked, in one undo step.
#[test]
fn ok_assigns_the_rgb_profile() {
let (mut app, _) = red_square();
let working = cms::active_settings().rgb;
let steps = undo_steps(&app);
color_tab(&mut app, json!({"rgbProfile": working}));
crate::dialogs::confirm(&mut app).unwrap();
let st = app.session.active().unwrap();
assert_eq!((st.doc.color_profiles.rgb.clone(), st.doc.color_profiles.cmyk.clone()), (Some(working), None));
assert_eq!(undo_steps(&app), steps + 1);
}
/// A profile and a mode changed in one OK: Assign Profile runs before Document Color Mode, so
/// the conversion goes through the profile picked.
#[test]
fn a_profile_and_a_mode_change_assign_the_profile_first() {
let (mut app, _) = red_square();
color_tab(&mut app, json!({"colorMode": "cmyk", "cmykProfile": cms::DEVICE_CMYK}));
let commands = super::color_commands(&app, app.ui.dialog.as_ref().unwrap()).unwrap();
assert_eq!(
commands,
vec![
json!({"command": "edit.assignProfile", "params": {"cmyk": cms::DEVICE_CMYK}}),
json!({"command": "file.documentColorMode", "params": {"mode": "cmyk", "convert": true}}),
]
);
}
/// A Color tab field with a value of the wrong kind is an error: the dialog stays open and
/// nothing changes, the profile picked with it included.
#[test]
fn a_bad_color_field_is_an_error_and_changes_nothing() {
let bad = [
("colorMode", json!("lab")),
("colorMode", json!(null)),
("rgbProfile", json!(5)),
("cmykProfile", json!(true)),
("convertColors", json!("no")),
];
for (key, value) in bad {
let (mut app, id) = red_square();
let before = fill(&app, id);
let steps = undo_steps(&app);
color_tab(&mut app, json!({"colorMode": "cmyk", "cmykProfile": cms::active_settings().cmyk}));
app.ui.dialog.as_mut().unwrap().fields.insert(key.into(), value.clone());
assert!(super::color_commands(&app, app.ui.dialog.as_ref().unwrap()).is_err(), "{key}: {value}");
assert!(crate::dialogs::confirm(&mut app).is_err(), "{key}: {value}");
assert!(app.ui.dialog.is_some());
let st = app.session.active().unwrap();
assert_eq!((st.doc.color_mode, st.doc.color_profiles.cmyk.clone()), (ColorMode::Rgb, None), "{key}: {value}");
assert_eq!(fill(&app, id), before);
assert_eq!(undo_steps(&app), steps);
}
}
/// Cancel leaves the color mode, the colors and the history as they were.
#[test]
fn cancel_changes_no_color_setting() {
let (mut app, id) = red_square();
let before = fill(&app, id);
let steps = undo_steps(&app);
color_tab(&mut app, json!({"colorMode": "cmyk", "cmykProfile": cms::active_settings().cmyk}));
click_dialog_button(&mut app, "Cancel");
assert!(app.ui.dialog.is_none());
let st = app.session.active().unwrap();
assert_eq!((st.doc.color_mode, st.doc.color_profiles.cmyk.clone()), (ColorMode::Rgb, None));
assert_eq!(fill(&app, id), before);
assert_eq!(undo_steps(&app), steps);
}
/// The Light pair a new document's transparency grid starts with.
const LIGHT: [&str; 2] = ["#ffffff", "#cccccc"];
fn hex(h: &str) -> Color {
Color::from_hex(h).unwrap_or_else(|| panic!("bad hex {h}"))
}
/// The grid colors Document Setup `d` holds.
fn dialog_grid(d: &crate::state::Dialog) -> Vec<Color> {
d.fields["gridColors"].as_array().unwrap().iter().map(|c| vectorcraft_engine::cmd::color_value(c).unwrap()).collect()
}
/// A new document with Document Setup open on its Transparency tab, drawn in the context returned.
fn transparency_tab() -> (VectorcraftApp, egui::Context) {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("tab".into(), json!("Transparency"));
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
crate::theme::apply(&ctx, Default::default());
for _ in 0..4 {
dialog_frame(&mut app, &ctx, vec![]);
}
(app, ctx)
}
/// Clicks the box of grid color `index`.
fn click_grid_box(app: &mut VectorcraftApp, ctx: &egui::Context, index: usize) {
let at = ctx.read_response(super::grid_color_box_id(index)).unwrap_or_else(|| panic!("no box {index}")).rect.center();
let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
dialog_frame(app, ctx, vec![Event::PointerMoved(at), button(true)]);
dialog_frame(app, ctx, vec![button(false)]);
}
/// The Color Picker is open over Document Setup, on `color`, and Document Setup's OK has not run.
fn assert_picker_over_setup(app: &VectorcraftApp, color: &str, case: &str) {
let d = app.ui.dialog.as_ref().unwrap_or_else(|| panic!("{case}: no dialog"));
assert_eq!(d.kind, "colorPicker", "{case}");
assert_eq!(d.fields.get("color").and_then(vectorcraft_engine::cmd::color_value), Some(hex(color)), "{case}");
assert_eq!(crate::dialogs::parent(d).map(|p| p.kind), Some(super::KIND.to_string()), "{case}");
assert_eq!(undo_steps(app), 0, "{case}: Document Setup's OK has not run");
}
/// A click on either grid color's box opens the Color Picker over Document Setup on that
/// color. Its OK sets only that color, the Grid Colors menu names the pair (Custom, or the
/// preset it matches), and Document Setup's OK applies the pair in one undo step.
#[test]
fn a_grid_color_box_opens_the_color_picker_and_its_ok_sets_that_color() {
for (index, picked, pair, name) in [(0, "#00ff00", ["#00ff00", "#cccccc"], "Custom"), (1, "#c4dcff", ["#ffffff", "#c4dcff"], "Blue")] {
let (mut app, ctx) = transparency_tab();
click_grid_box(&mut app, &ctx, index);
assert_picker_over_setup(&app, LIGHT[index], name);
app.ui.dialog.as_mut().unwrap().fields.insert("color".into(), json!(picked));
crate::dialogs::confirm(&mut app).unwrap();
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), dialog_grid(d)), (super::KIND, pair.map(hex).to_vec()), "{name}");
assert_eq!(undo_steps(&app), 0, "{name}: the picker's OK leaves the document as it is");
dialog_frame(&mut app, &ctx, vec![]);
let texts: Vec<String> = dialog_frame(&mut app, &ctx, vec![]).into_iter().map(|(t, _)| t).collect();
assert!(texts.iter().any(|t| t == name), "{name}: {texts:?}");
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
let st = app.session.active().unwrap();
assert_eq!((st.doc.setup.grid_colors, st.doc.setup.grid_colors_name()), (pair.map(hex), name));
assert_eq!(undo_steps(&app), 1, "{name}");
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors, LIGHT.map(hex), "{name}");
}
}
/// With the keyboard on a grid color's box, Enter or Space opens the Color Picker on that
/// color instead of pressing Document Setup's OK.
#[test]
fn enter_or_space_on_a_grid_color_box_opens_the_color_picker() {
for (index, key) in [(0, egui::Key::Enter), (1, egui::Key::Space)] {
let (mut app, ctx) = transparency_tab();
ctx.memory_mut(|m| m.request_focus(super::grid_color_box_id(index)));
dialog_frame(&mut app, &ctx, vec![]);
let press = Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
dialog_frame(&mut app, &ctx, vec![press]);
assert_picker_over_setup(&app, LIGHT[index], &format!("{key:?}"));
}
}
/// Cancel in the Color Picker goes back to Document Setup with the grid colors as they were,
/// and so does its OK on the color it opened on; Document Setup's OK then records no undo step.
#[test]
fn grid_color_picker_cancel_or_an_unchanged_ok_changes_nothing() {
for cancel in [true, false] {
let (mut app, ctx) = transparency_tab();
click_grid_box(&mut app, &ctx, 1);
assert_picker_over_setup(&app, LIGHT[1], &format!("cancel {cancel}"));
if cancel {
app.ui.dialog.as_mut().unwrap().fields.insert("color".into(), json!("#ff0000"));
crate::dialogs::cancel(&mut app);
} else {
crate::dialogs::confirm(&mut app).unwrap();
}
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), dialog_grid(d)), (super::KIND, LIGHT.map(hex).to_vec()), "cancel {cancel}");
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors_name(), "Light");
assert_eq!(undo_steps(&app), 0, "cancel {cancel}");
}
}
/// When Grid Colors holds a preset name (in any letter case) or a list that is not two colors,
/// the boxes and hex fields show the preset's pair or the document's, a box opens the Color
/// Picker on its color, and the picker's OK sets only that entry of a two-color list.
#[test]
fn a_grid_color_box_opens_on_a_preset_name_or_a_short_list() {
for (field, index, opens, kept, name) in [
(json!("Blue"), 1, "#c4dcff", "#ffffff", "Blue"),
(json!("purple"), 0, "#ffffff", "#e2c9ff", "Purple"),
(json!(["#ff0000"]), 1, "#cccccc", "#ffffff", "Light"),
] {
let (mut app, ctx) = transparency_tab();
app.ui.dialog.as_mut().unwrap().fields.insert("gridColors".into(), field.clone());
dialog_frame(&mut app, &ctx, vec![]);
let texts: Vec<String> = dialog_frame(&mut app, &ctx, vec![]).into_iter().map(|(t, _)| t).collect();
for shown in [name, opens.trim_start_matches('#'), kept.trim_start_matches('#')] {
assert!(texts.iter().any(|t| t.eq_ignore_ascii_case(shown)), "{field}: no {shown} in {texts:?}");
}
click_grid_box(&mut app, &ctx, index);
assert_picker_over_setup(&app, opens, &field.to_string());
app.ui.dialog.as_mut().unwrap().fields.insert("color".into(), json!("#00ff00"));
crate::dialogs::confirm(&mut app).unwrap();
let d = app.ui.dialog.as_ref().unwrap();
let mut pair = [hex(kept); 2];
pair[index] = hex("#00ff00");
assert_eq!((d.kind.as_str(), dialog_grid(d)), (super::KIND, pair.to_vec()), "{field}");
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors, pair, "{field}");
}
}
/// With a preset name in Document Setup's `gridColors` field, the grid color boxes show the
/// preset's colors, and the Color Picker opens on the clicked one; its OK sets that color and
/// keeps the preset's other one.
#[test]
fn a_grid_color_box_opens_the_picker_when_the_field_names_a_preset() {
let (mut app, ctx) = transparency_tab();
app.ui.dialog.as_mut().unwrap().fields.insert("gridColors".into(), json!("blue"));
dialog_frame(&mut app, &ctx, vec![]);
click_grid_box(&mut app, &ctx, 1);
assert_picker_over_setup(&app, "#c4dcff", "blue");
app.ui.dialog.as_mut().unwrap().fields.insert("color".into(), json!("#00ff00"));
crate::dialogs::confirm(&mut app).unwrap();
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), dialog_grid(d)), (super::KIND, ["#ffffff", "#00ff00"].map(hex).to_vec()));
}
/// The screen color sampler works in the Color Picker of a grid color: the color sampled goes
/// to that picker, and its OK sets the grid color.
#[test]
fn the_grid_color_picker_takes_a_screen_sampled_color() {
let (mut app, ctx) = transparency_tab();
let (tx, rx) = std::sync::mpsc::channel::<crate::screen_color::Answer>();
let mut rx = Some(rx);
app.services.screen_color = Some(Box::new(move || rx.take().ok_or_else(|| "shown twice".to_string())));
click_grid_box(&mut app, &ctx, 0);
assert_picker_over_setup(&app, LIGHT[0], "before sampling");
app.run("ui.sampleScreenColor", json!({"picker": true})).unwrap();
tx.send(Ok(Some([0.0, 0.5, 1.0]))).unwrap();
crate::screen_color::poll(&mut app, &ctx);
let sampled = app.ui.dialog.as_ref().unwrap().fields.get("color").and_then(vectorcraft_engine::cmd::color_value).unwrap();
assert_ne!(sampled.to_hex(), LIGHT[0]);
crate::dialogs::confirm(&mut app).unwrap();
let d = app.ui.dialog.as_ref().unwrap();
let grid: Vec<String> = dialog_grid(d).iter().map(Color::to_hex).collect();
assert_eq!((d.kind.as_str(), grid), (super::KIND, vec![sampled.to_hex(), LIGHT[1].to_string()]));
}
/// Clicks the hex field that shows `digits` and types `typed` over its text, leaving the edit
/// pending; returns the field's id.
fn type_into_hex_field(app: &mut VectorcraftApp, ctx: &egui::Context, digits: &str, typed: &str) -> egui::Id {
let texts = dialog_frame(app, ctx, vec![]);
let at = texts.iter().find(|(t, _)| t == digits).unwrap_or_else(|| panic!("no field {digits}: {texts:?}")).1.center();
let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
dialog_frame(app, ctx, vec![Event::PointerMoved(at), button(true)]);
dialog_frame(app, ctx, vec![button(false)]);
let field = ctx.memory(|m| m.focused()).unwrap_or_else(|| panic!("field {digits} has no focus"));
dialog_frame(app, ctx, vec![Event::Text(typed.into())]);
assert_eq!(ctx.memory(|m| m.focused()), Some(field), "the edit in {digits} is pending");
field
}
/// A click on a grid color's box whose press and release come in one frame, while that
/// color's hex field holds an edit, opens the Color Picker on the edited color: the press
/// commits the edit before the picker opens. The picker's unchanged OK keeps the edit, and the
/// other color stays as it was.
#[test]
fn a_grid_color_box_clicked_during_a_hex_edit_opens_the_picker_on_the_edit() {
for index in [0, 1] {
let (mut app, ctx) = transparency_tab();
type_into_hex_field(&mut app, &ctx, LIGHT[index].trim_start_matches('#'), "123456");
let at = ctx.read_response(super::grid_color_box_id(index)).unwrap_or_else(|| panic!("no box {index}")).rect.center();
let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
dialog_frame(&mut app, &ctx, vec![Event::PointerMoved(at), button(true), button(false)]);
let case = format!("box {index}");
assert_picker_over_setup(&app, "#123456", &case);
let mut pair = LIGHT;
pair[index] = "#123456";
assert_eq!(dialog_grid(&crate::dialogs::parent(app.ui.dialog.as_ref().unwrap()).unwrap()), pair.map(hex).to_vec(), "{case}");
crate::dialogs::confirm(&mut app).unwrap();
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), dialog_grid(d)), (super::KIND, pair.map(hex).to_vec()), "{case}");
}
}
/// A hex field's edit that commits in the frame a Grid Colors preset is chosen replaces only
/// its own color in the preset's pair: the other color is the preset's. The test gives the
/// field the focus while the Grid Colors menu is open, then chooses a preset with a click whose
/// press and release come in one frame.
#[test]
fn a_hex_edit_committed_with_a_preset_choice_keeps_the_presets_other_color() {
let field = {
let (mut app, ctx) = transparency_tab();
type_into_hex_field(&mut app, &ctx, "ffffff", "123456")
};
let (mut app, ctx) = transparency_tab();
let click = |app: &mut VectorcraftApp, label: &str, frames: usize| {
let texts = dialog_frame(app, &ctx, vec![]);
let at = texts.iter().find(|(t, _)| t == label).unwrap_or_else(|| panic!("no {label}: {texts:?}")).1.center();
let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
if frames == 1 {
dialog_frame(app, &ctx, vec![Event::PointerMoved(at), button(true), button(false)]);
} else {
dialog_frame(app, &ctx, vec![Event::PointerMoved(at), button(true)]);
dialog_frame(app, &ctx, vec![button(false)]);
}
};
click(&mut app, "Light", 2);
ctx.memory_mut(|m| m.request_focus(field));
dialog_frame(&mut app, &ctx, vec![]);
let select_all = Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::COMMAND };
dialog_frame(&mut app, &ctx, vec![select_all, Event::Text("123456".into())]);
assert_eq!(ctx.memory(|m| m.focused()), Some(field), "the edit is pending");
let texts: Vec<String> = dialog_frame(&mut app, &ctx, vec![]).into_iter().map(|(t, _)| t).collect();
assert!(texts.iter().any(|t| t == "123456") && texts.iter().any(|t| t == "Blue"), "{texts:?}");
click(&mut app, "Blue", 1);
assert_eq!(dialog_grid(app.ui.dialog.as_ref().unwrap()), ["#123456", "#c4dcff"].map(hex).to_vec());
}
/// The picker's OK sets nothing when the dialog under it has no such color or is gone: it is
/// an error, and the picker stays open.
#[test]
fn grid_color_picker_without_its_color_or_its_dialog_is_an_error() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
let setup = app.ui.dialog.clone().unwrap();
let mut short = setup.clone();
short.fields.insert("gridColors".into(), json!(["#ffffff"]));
let mut orphan = crate::dialogs::color_picker::over_list_entry(&setup, "gridColors", 0, Color::WHITE, None);
orphan.fields.remove(crate::dialogs::PARENT);
for picker in [crate::dialogs::color_picker::over_list_entry(&short, "gridColors", 1, Color::WHITE, None), orphan] {
app.ui.dialog = Some(picker);
app.ui.dialog.as_mut().unwrap().fields.insert("color".into(), json!("#ff0000"));
assert!(crate::dialogs::confirm(&mut app).is_err());
assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some("colorPicker"));
}
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors, LIGHT.map(hex));
assert_eq!(undo_steps(&app), 0);
}
/// [`transparency_tab`] on a document whose grid colors `document.setup` set to `grid` first.
fn transparency_tab_on(grid: Value) -> (VectorcraftApp, egui::Context) {
let (mut app, ctx) = transparency_tab();
app.ui.dialog = None;
app.run("document.setup", json!({"gridColors": grid})).unwrap();
app.run("file.documentSetup", json!({})).unwrap();
app.ui.dialog.as_mut().unwrap().fields.insert("tab".into(), json!("Transparency"));
for _ in 0..4 {
dialog_frame(&mut app, &ctx, vec![]);
}
(app, ctx)
}
/// Document Setup opens on the document's own grid colors, a Lab color included: the grid
/// preview reads them as the document holds them, and an unchanged OK keeps them.
#[test]
fn document_setup_opens_on_the_documents_own_grid_colors() {
let (mut app, _ctx) = transparency_tab_on(json!(["lab 55 60 40", "#cccccc"]));
let grid = app.session.active().unwrap().doc.setup.grid_colors;
assert!(matches!(grid[0], Color::Lab { .. }), "{grid:?}");
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!(super::preview_grid(&d.fields, &app.session.active().unwrap().doc.setup).1, grid);
crate::dialogs::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors, grid);
}
/// A hex field's edit replaces only its own entry of the pair Document Setup holds: the other
/// entry stays as it is, a Lab color in its own model.
#[test]
fn a_grid_color_hex_edit_keeps_the_other_entry_as_it_is() {
let (mut app, ctx) = transparency_tab();
app.ui.dialog.as_mut().unwrap().fields.insert("gridColors".into(), json!(["lab 55 60 40", "#cccccc"]));
type_into_hex_field(&mut app, &ctx, "cccccc", "123456");
// A click on the grid preview ends the edit.
let at = ctx.read_response(super::grid_preview_id()).expect("no grid preview").rect.center();
let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
dialog_frame(&mut app, &ctx, vec![Event::PointerMoved(at), button(true)]);
dialog_frame(&mut app, &ctx, vec![button(false)]);
assert_eq!(app.ui.dialog.as_ref().unwrap().fields["gridColors"], json!(["lab 55 60 40", "#123456"]));
}
/// The Grid Colors menu names a preset only when the pair is that preset's colors, as
/// `document.setup` names it: a color that rounds to the preset's hex code makes it Custom.
#[test]
fn the_grid_colors_menu_names_a_preset_only_for_its_own_colors() {
let (mut app, ctx) = transparency_tab();
app.ui.dialog.as_mut().unwrap().fields.insert("gridColors".into(), json!(["#ffffff", [0.801, 0.8, 0.8]]));
dialog_frame(&mut app, &ctx, vec![]);
let texts: Vec<String> = dialog_frame(&mut app, &ctx, vec![]).into_iter().map(|(t, _)| t).collect();
assert!(texts.iter().any(|t| t == "Custom") && !texts.iter().any(|t| t == "Light"), "{texts:?}");
crate::dialogs::confirm(&mut app).unwrap();
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors_name(), "Custom");
}
/// With a list in Grid Colors that is not two colors, Cancel in a grid color's Color Picker
/// goes back to that list as it was, and Document Setup's OK still refuses it.
#[test]
fn grid_color_picker_cancel_keeps_a_short_list() {
let (mut app, ctx) = transparency_tab();
app.ui.dialog.as_mut().unwrap().fields.insert("gridColors".into(), json!(["#ff0000"]));
dialog_frame(&mut app, &ctx, vec![]);
click_grid_box(&mut app, &ctx, 1);
assert_picker_over_setup(&app, LIGHT[1], "short list");
crate::dialogs::cancel(&mut app);
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!((d.kind.as_str(), &d.fields["gridColors"]), (super::KIND, &json!(["#ff0000"])));
assert!(crate::dialogs::confirm(&mut app).is_err());
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors, LIGHT.map(hex));
}
/// The grid preview Document Setup draws, in a fresh context: its rect, the texture
/// coordinates of its bottom-right corner (two cells per unit) and the tile's four pixels.
fn grid_preview(app: &mut VectorcraftApp) -> (Rect, egui::Vec2, Vec<egui::Color32>) {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
crate::theme::apply(&ctx, Default::default());
let (mut mesh, mut pixels) = (None, None);
for _ in 0..3 {
let raw = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 900.0))), ..Default::default() };
let mut out = ctx.run_ui(raw, |ui| crate::dialogs::show(app, ui.ctx()));
let tiles: Vec<egui::TextureId> =
ctx.tex_manager().read().allocated().filter(|(_, m)| m.name == crate::canvas::TRANSPARENCY_GRID).map(|(id, _)| *id).collect();
for (id, deltas) in &out.textures_delta.set {
if tiles.contains(id)
&& let Some(d) = deltas.last()
{
let egui::ImageData::Color(img) = &d.image;
pixels = Some(img.pixels.clone());
}
}
out.textures_delta.clear();
mesh = out.shapes.iter().find_map(|c| match &c.shape {
egui::Shape::Mesh(m) if tiles.contains(&m.texture_id) => Some(m.clone()),
_ => None,
});
}
let mesh = mesh.unwrap_or_else(|| panic!("no grid preview"));
let uv = mesh.vertices.iter().fold(vec2(0.0, 0.0), |a, v| a.max(v.uv.to_vec2()));
(mesh.calc_bounds(), uv, pixels.unwrap_or_else(|| panic!("no tile")))
}
/// The tile's pixels for the grid colors `a` and `b`: `a` in the top-left and bottom-right cells.
fn tile(a: &str, b: &str) -> Vec<egui::Color32> {
let c = |h| crate::panels::c32(&hex(h));
vec![c(a), c(b), c(b), c(a)]
}
/// The Transparency tab shows a checkered preview of the grid its Grid Size and Grid Colors
/// hold before OK: the canvas's cells, the first color in the top-left cell. Simulate Colored
/// Paper leaves it checkered, and neither it nor Cancel changes the document.
#[test]
fn the_transparency_tab_previews_the_pending_grid_size_and_colors() {
let (mut app, _) = transparency_tab();
let (rect, uv, pixels) = grid_preview(&mut app);
assert_eq!(rect.size(), super::GRID_PREVIEW);
assert_eq!((uv, pixels), (rect.size() / 16.0, tile(LIGHT[0], LIGHT[1])), "Medium, Light");
for (size, cell) in [("small", 4.0), ("large", 16.0)] {
let d = app.ui.dialog.as_mut().unwrap();
d.fields.insert("gridSize".into(), json!(size));
d.fields.insert("gridColors".into(), json!(["#ff0000", "#0000ff"]));
let (rect, uv, pixels) = grid_preview(&mut app);
assert_eq!((uv, pixels), (rect.size() / (2.0 * cell), tile("#ff0000", "#0000ff")), "{size}");
}
app.ui.dialog.as_mut().unwrap().fields.insert("simulatePaper".into(), json!(true));
let (rect, uv, pixels) = grid_preview(&mut app);
assert_eq!((uv, pixels), (rect.size() / 32.0, tile("#ff0000", "#0000ff")), "Simulate Colored Paper");
let st = app.session.active().unwrap();
assert_eq!((st.doc.setup.grid_size, st.doc.setup.grid_colors), (vectorcraft_doc::GridSize::Medium, LIGHT.map(hex)));
assert_eq!(undo_steps(&app), 0);
crate::dialogs::cancel(&mut app);
assert!(app.ui.dialog.is_none());
let st = app.session.active().unwrap();
assert_eq!(
(st.doc.setup.grid_size, st.doc.setup.grid_colors, st.doc.setup.simulate_paper),
(vectorcraft_doc::GridSize::Medium, LIGHT.map(hex), false)
);
assert_eq!(undo_steps(&app), 0);
}
/// The grid preview sits beside Grid Size, Grid Colors and the color boxes, inside the dialog,
/// and covers none of the tab's text or color boxes.
#[test]
fn the_grid_preview_sits_beside_the_grid_rows() {
let (mut app, ctx) = transparency_tab();
let texts = dialog_frame(&mut app, &ctx, vec![]);
let (rect, _, _) = grid_preview(&mut app);
let label = texts.iter().find(|(t, _)| t == "Grid Size:").unwrap_or_else(|| panic!("no Grid Size: {texts:?}")).1;
assert!(rect.top() <= label.bottom() && rect.left() > label.right(), "{rect:?} beside {label:?}");
for (text, r) in &texts {
assert!(!r.intersects(rect), "{text:?} at {r:?} under the preview {rect:?}");
}
for i in 0..2 {
let r = ctx.read_response(super::grid_color_box_id(i)).unwrap().rect;
assert!(!r.intersects(rect), "box {i} at {r:?} under the preview {rect:?}");
}
// The dialog's content is 540 points wide from its heading's left edge.
let left = texts.iter().find(|(t, _)| t == "Document Setup").unwrap_or_else(|| panic!("no heading: {texts:?}")).1.left();
assert!(rect.right() <= left + 540.0 + 0.5, "{rect:?} inside the dialog from {left}");
}
/// A grid size or color pair the dialog holds that is not a valid value shows as the
/// document's setting.
#[test]
fn the_grid_preview_shows_the_document_setting_for_a_bad_field() {
let setup = vectorcraft_doc::DocSetup {
grid_size: vectorcraft_doc::GridSize::Large,
grid_colors: [hex("#111111"), hex("#222222")],
..Default::default()
};
let fields = |v: serde_json::Value| v.as_object().unwrap().clone();
for bad in [
json!({}),
json!({"gridSize": "huge", "gridColors": ["#ff0000"]}),
json!({"gridSize": 3, "gridColors": ["#ff0000", "zz"]}),
json!({"gridColors": "Plaid"}),
json!({"gridColors": ["#ff0000", "#00ff00", "#0000ff"]}),
] {
assert_eq!(super::preview_grid(&fields(bad.clone()), &setup), (setup.grid_size, setup.grid_colors), "{bad}");
}
let good = fields(json!({"gridSize": "small", "gridColors": ["#ff0000", "#0000ff"]}));
assert_eq!(super::preview_grid(&good, &setup), (vectorcraft_doc::GridSize::Small, [hex("#ff0000"), hex("#0000ff")]));
let preset = fields(json!({"gridColors": "blue"}));
assert_eq!(super::preview_grid(&preset, &setup), (vectorcraft_doc::GridSize::Large, [hex("#ffffff"), hex("#c4dcff")]));
}
}
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.