Merge pull request #8463 from dotCooCoo/feat/document-setup-grid-preview

Document Setup: the Transparency tab previews the grid
This commit is contained in:
BFlat authored and GitHub committed 2026-11-19 00:42:49 +07:00
commit 08e419aa62
4 files changed
+237 -18

No files matched your search

+1 -1
View File
@@ -52,7 +52,7 @@ use fill::{fill_view, polygon_area};
#[cfg(test)]
use grid::ruler_rects;
use grid::{LineLook, PIXEL_GRID, PIXEL_GRID_ZOOM, checker, clip_segment, grid, ruler_input, rulers, rulers_hidden, textured_quad, view_bounds};
pub(crate) use grid::{RulerScale, checker_texture, ruler_label, ruler_origin_dragging};
pub(crate) use grid::{RulerScale, checker_texture, checker_tile, ruler_label, ruler_origin_dragging};
#[cfg(test)]
pub(crate) use grid::{TRANSPARENCY_GRID, vertical_label_height};
use home::home;
+15 -4
View File
@@ -11,20 +11,31 @@ pub(crate) fn checker_texture(
setup: &vectorcraft_doc::DocSetup,
display: Option<&vectorcraft_color::cms::display::DisplayTransform>,
) -> (egui::TextureHandle, f32) {
let colors = setup.grid_colors.map(|c| crate::display_profile::color32(display, crate::panels::c32(&c)));
// A tile of its own with a display profile, so a preview drawn in sRGB beside the canvas
// doesn't make the canvas's tile again each frame.
let id = egui::Id::unique("transparency-grid-tile").with(display.is_some());
(checker_tile(ctx, setup.grid_colors, display, id), setup.grid_size.cell())
}
/// The transparency grid's 2 × 2-cell tile in the colors `grid_colors` (the first in the top-left
/// and bottom-right cells), converted into the display profile `display` when there is one, and
/// cached under `id` until the colors change.
pub(crate) fn checker_tile(
ctx: &egui::Context,
grid_colors: [vectorcraft_color::Color; 2],
display: Option<&vectorcraft_color::cms::display::DisplayTransform>,
id: egui::Id,
) -> egui::TextureHandle {
let colors = grid_colors.map(|c| crate::display_profile::color32(display, crate::panels::c32(&c)));
let cached = ctx.data(|d| d.get_temp::<([Color32; 2], egui::TextureHandle)>(id)).filter(|(c, _)| *c == colors);
let tex = cached.map(|(_, t)| t).unwrap_or_else(|| {
cached.map(|(_, t)| t).unwrap_or_else(|| {
let [a, b] = colors;
let img = egui::ColorImage::new([2, 2], vec![a, b, b, a]);
let opts = egui::TextureOptions { wrap_mode: egui::TextureWrapMode::Repeat, ..egui::TextureOptions::NEAREST };
let t = ctx.load_texture(TRANSPARENCY_GRID, img, opts);
ctx.data_mut(|d| d.insert_temp(id, (colors, t.clone())));
t
});
(tex, setup.grid_size.cell())
})
}
/// Name of the transparency grid's texture.
+220 -13
View File
@@ -180,15 +180,65 @@ fn grid_color_box_id(index: usize) -> egui::Id {
egui::Id::unique(("grid-color-box", index))
}
/// The grid colors' hex codes that Document Setup `d` holds now (empty strings for entries that are
/// not strings).
fn grid_colors(d: &Dialog) -> Vec<String> {
d.fields.get("gridColors").and_then(Value::as_array).map(|a| a.iter().map(|c| c.as_str().unwrap_or("").to_string()).collect()).unwrap_or_default()
/// 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 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
@@ -198,10 +248,15 @@ fn transparency(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
{
d.fields.insert("gridColors".into(), json!(pair.map(|c| c.to_hex())));
}
let colors = grid_colors(d);
// 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.
let fallback = vectorcraft_doc::DocSetup::default();
let setup = app.session.active().map_or(&fallback, |st| &st.doc.setup);
let pair = |d: &Dialog| -> Vec<String> { grid_colors(&d.fields, setup).iter().map(vectorcraft_color::Color::to_hex).collect() };
let colors = pair(d);
let preset = GRID_COLOR_PRESETS
.iter()
.find(|(_, pair)| colors.len() == 2 && colors.iter().zip(pair).all(|(h, c)| h.eq_ignore_ascii_case(&c.to_hex())))
.find(|(_, pair)| colors.iter().zip(pair).all(|(h, c)| h.eq_ignore_ascii_case(&c.to_hex())))
.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| {
@@ -211,10 +266,10 @@ fn transparency(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
});
// 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 (white when its hex is not a 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.
// 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.
let mut pick = None;
widgets::label_row(ui, "", LABEL, |ui| {
for i in 0..2 {
@@ -242,16 +297,23 @@ fn transparency(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
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 = grid_colors(d);
v.resize(2, "#ffffff".into());
let mut v = pair(d);
v[i] = c.to_hex();
d.fields.insert("gridColors".into(), json!(v));
}
ui.add_space(10.0);
}
});
grid_preview(app, ui, d, top);
if let Some(i) = pick {
let c = grid_colors(d).get(i).and_then(|h| vectorcraft_color::Color::from_hex(h.trim_start_matches('#')));
// A field that is not two colors becomes the pair the boxes show, so the picker's OK has an
// entry to set.
let v = pair(d);
let entries = d.fields.get("gridColors").and_then(Value::as_array);
if !entries.is_some_and(|a| a.len() == 2 && a.iter().all(|c| vectorcraft_engine::cmd::color_value(c).is_some())) {
d.fields.insert("gridColors".into(), json!(v));
}
let c = v.get(i).and_then(|h| vectorcraft_color::Color::from_hex(h.trim_start_matches('#')));
*d = super::color_picker::over_list_entry(d, "gridColors", i, c.unwrap_or(vectorcraft_color::Color::WHITE));
}
ui.add_space(4.0);
@@ -783,6 +845,36 @@ mod tests {
}
}
/// 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.
@@ -912,4 +1004,119 @@ mod tests {
assert_eq!(app.session.active().unwrap().doc.setup.grid_colors, LIGHT.map(hex));
assert_eq!(undo_steps(&app), 0);
}
/// 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")]));
}
}
+1
View File
@@ -842,6 +842,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- **Document Setup modal handoff:** Document Setup → Edit Artboards applies valid settings, closes the dialog and activates the Artboard tool. Pointer-click tests cover successful handoff, invalid settings, OK, Cancel and Undo in `dialogs/document_setup.rs`.
- **Document Setup › Transparency grid color boxes:** a click on either color box beside Grid Colors opens the Color Picker on that color, as [the help page](https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/view-transparency-in-artworks.html) describes choosing a custom color for each of the grid's two alternating squares. The picker's OK sets only that color in the dialog, Grid Colors then names the pair (Custom unless it matches one of VectorCraft's presets), and Document Setup's OK applies it in one undo step; the picker's Cancel leaves both colors as they were. With the keyboard on a box, Enter or Space opens the picker. The keyboard handling and staging the color until Document Setup's OK are VectorCraft's own. Tests: `a_grid_color_box_opens_the_color_picker_and_its_ok_sets_that_color` and the other grid color tests in `dialogs/document_setup.rs`.
- **Document Setup › Transparency grid preview:** a checkered box to the right of Grid Size and Grid Colors shows the grid they hold before OK, as [the help page](https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/view-transparency-in-artworks.html) describes a larger sample of the chosen square size and colors beside those settings. It is drawn with the canvas's transparency grid tile and cell size, through the same display profile, with the first color in the top-left square, and it changes nothing in the document. Its 112 × 72 point size, showing the grid whatever Simulate Colored Paper and View › Show Transparency Grid are, and showing the document's setting for a value the dialog cannot read are VectorCraft's own. Tests: `the_transparency_tab_previews_the_pending_grid_size_and_colors` and the other grid preview tests in `dialogs/document_setup.rs`.
- **Document Setup › Color:** a Color tab shows the document color mode (RGB Color or CMYK Color), a Convert to CMYK or Convert to RGB box for a mode change (cleared: the colors keep their numbers), and the RGB and CMYK profiles assigned to the document, with a working-space entry for none. OK runs `edit.assignProfile` and then `file.documentColorMode` with the dialog's other changes in one `command.batch`, and the document's changes are one undo step. An unchanged Color tab adds no color commands, and Cancel, or OK with nothing changed, records no undo step. A Color tab field with a value of the wrong kind is an error, and the dialog stays open. The tab is VectorCraft's own layout; File › Document Color Mode and Edit › Assign Profile… stay as they are. Tests in `dialogs/document_setup.rs`.
- **Assign Profile's three choices:** the Assign rows of Edit › Assign Profile… (the Separations panel's Color Settings section) offer Don't Color Manage This Document, the working space of the document's color mode (Working RGB or Working CMYK, with its name) and Profile with the other profiles of that kind, as [Assign or remove a color profile](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=150) lists them. They act on the profile of the document's color mode: an RGB document's RGB profile, a CMYK document's CMYK profile; the other model's profile stays as it is (VectorCraft's own rule; Document Setup › Color sets both). Picking the working space assigns its profile, which stays when the working space changes later. A choice the document already has runs nothing. Tests in `panels/separations.rs`.
- **Canvas through the display's profile on Windows and X11:** Preferences › Performance › Use Monitor Profile for Canvas (on by default) converts the canvas's art, artboard paper and transparency grid from sRGB into the ICC profile of the display that shows most of the main window, after any proof, as the help page describes the monitor's profile translating the document's colors for the monitor ([the help page](https://help.adobe.com/archive/en_US/illustrator/cs4/illustrator_cs4_help.pdf#page=151)). Windows gives the display's default profile, and a display with Advanced Color on is left to Windows ([Microsoft Learn](https://learn.microsoft.com/en-us/windows/win32/wcs/advanced-color-icc-profiles)); X11 gives colord's profile for the output or the `_ICC_PROFILE` property. macOS converts the window itself, and a Wayland session stays sRGB. `ui.inspect` reports `displayProfile`. Tests in `color/src/cms/display.rs`, `ui-egui/src/display_profile.rs` and `canvas::tests::the_canvas_is_drawn_through_the_display_profile_while_the_preference_is_on`.