2bc41aeb8602
layer_options.rs
//! Layer Options (double-click a layer row, or ≡ › Options for Selection…) and the same dialog for
//! a new layer or sublayer (≡ › New Layer…, Alt-click Create New Layer). Objects' rows get Name,
//! Show and Lock only.
//!
//! Fields: `ids` (the rows edited; none for a new layer), `mode` (`edit`, `new` or `newSublayer`),
//! `layer` (the rows are layers), `name`, `color` (a preset's name such as "Light Blue", or
//! `#rrggbb`), `template`, `locked`, `visible`, `printable`, `preview`, `dimImages` and
//! `dimPercent`. OK runs `layer.setProps`, `layer.new` or `layer.newSublayer`. For several rows
//! the dialog shows the first row's settings, and OK sends only the ones set in the dialog.
use serde_json::{Value, json};
use vectorcraft_doc::{LAYER_COLORS, LayerColor, Node, NodeId, NodeKind};
use super::swatch_options::{grid, label};
use super::{DialogSpec, form, run_and_close};
use crate::state::Dialog;
use crate::{VectorcraftApp, widgets};
/// The dialog kind of Layer Options.
pub const KIND: &str = "layerOptions";
/// The field listing the fields set in the dialog, by its controls or `ui.dialog.set`.
const SET: &str = "__set";
/// The field holding, for several rows, the first row's Template, Lock, Dim Images and its
/// percentage as the dialog opened.
const OPENED: &str = "__opened";
/// Records that `field` was set.
fn mark(d: &mut Dialog, field: &str) {
match d.fields.get_mut(SET) {
Some(Value::Array(a)) => {
if !a.iter().any(|k| k == field) {
a.push(json!(field));
}
}
_ => {
d.fields.insert(SET.into(), json!([field]));
}
}
}
/// Records that `ui.dialog.set` sets `field` to `value`. Template also sets Lock and Dim Images,
/// as its checkbox does.
pub(super) fn note_set(d: &mut Dialog, field: &str, value: &Value) {
if field.starts_with("__") {
return;
}
match value.as_bool() {
Some(on) if field == "template" && on != d.bool("template") => set_template(d, on),
_ => mark(d, field),
}
}
/// Turns Template on or off. A template is locked and dims its images, and turning Template off
/// unlocks it and turns Dim Images off; a Dim Images that was set in the dialog keeps its value.
/// For several rows, OK sends Lock and Dim Images only when they are set in the dialog. `layer.setProps` then locks each row that becomes a template and
/// dims it to 50%, unless a percentage is set in the dialog, so the dialog shows 50%; it unlocks
/// each row that stops being a template and stops dimming it.
/// When Template is set back to the first row's value, Lock and Dim Images that were not set in
/// the dialog show the first row's values again.
fn set_template(d: &mut Dialog, on: bool) {
choose(d, "template", json!(on));
d.fields.insert("locked".into(), json!(on));
if !is_set(d, "dimImages") {
d.fields.insert("dimImages".into(), json!(on));
}
let Some(opened) = d.fields.get(OPENED).cloned() else {
return;
};
if opened.get("template") == Some(&json!(on)) {
for key in ["locked", "dimImages", "dimPercent"] {
if let Some(v) = opened.get(key).filter(|_| !is_set(d, key)) {
d.fields.insert(key.into(), v.clone());
}
}
} else if on && !is_set(d, "dimPercent") {
d.fields.insert("dimPercent".into(), json!(50));
}
}
/// Whether `field` was set in the dialog.
fn is_set(d: &Dialog, field: &str) -> bool {
d.fields.get(SET).and_then(Value::as_array).is_some_and(|a| a.iter().any(|k| k == field))
}
/// Sets `key` to `value` from one of the dialog's controls.
fn choose(d: &mut Dialog, key: &str, value: Value) {
d.fields.insert(key.into(), value);
mark(d, key);
}
pub(super) const SPEC: DialogSpec = DialogSpec { heading, body, confirm, min_width: 320.0, ..DialogSpec::FORM };
fn heading(d: &Dialog) -> String {
if d.bool("layer") || d.str("mode") != "edit" { tl!("Layer Options").into() } else { tl!("Options").into() }
}
/// A layer colour as the dialog shows it: a preset's name, else `#rrggbb`.
fn color_field(c: LayerColor) -> String {
match c {
LayerColor::Preset(i) => LAYER_COLORS.get(i as usize).map_or("Light Blue", |(n, _)| *n).to_string(),
LayerColor::Custom([r, g, b]) => format!("#{r:02x}{g:02x}{b:02x}"),
}
}
/// The fields for `n` (a layer or any other row).
/// `xml_id`: Preferences › Units › Identify Objects By › XML ID.
fn fields_of(n: &Node, xml_id: bool) -> serde_json::Map<String, Value> {
let mut f = serde_json::Map::new();
f.insert("name".into(), json!(n.identify_label(xml_id)));
f.insert("visible".into(), json!(n.visible));
f.insert("locked".into(), json!(n.locked));
f.insert("layer".into(), json!(n.is_layer()));
if let NodeKind::Layer { color, template, printable, preview, dim_images, .. } = &n.kind {
f.insert("color".into(), json!(color_field(*color)));
f.insert("template".into(), json!(template));
f.insert("printable".into(), json!(printable));
f.insert("preview".into(), json!(preview));
f.insert("dimImages".into(), json!(dim_images.is_some()));
f.insert("dimPercent".into(), json!(dim_images.unwrap_or(50)));
}
f
}
/// `ui.layerOptions {ids?|id?}`: open Layer Options for rows (default: the highlighted rows, else
/// the current layer), filled in from the first.
pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
let st = app.session.active().ok_or("no document open")?;
// Rows given are used as given: a malformed or unknown id fails rather than being skipped or
// the dialog opening on the highlighted rows instead.
let row = |v: &Value| -> Result<NodeId, String> {
let id = NodeId(v.as_u64().ok_or_else(|| format!("object ids are non-negative integers, not {v}"))?);
st.doc.node(id).map(|_| id).ok_or_else(|| "no such layer or object".to_string())
};
let ids: Vec<NodeId> = match (p.get("ids"), p.get("id")) {
(Some(Value::Array(a)), _) => a.iter().map(row).collect::<Result<_, _>>()?,
(Some(v), _) => return Err(format!("`ids` must be an array of object ids, not {v}")),
(None, Some(v)) => vec![row(v)?],
(None, None) => {
let rows = st.highlighted_rows();
if rows.is_empty() { st.current_layer().into_iter().collect() } else { rows }
}
};
let first = ids.first().and_then(|id| st.doc.node(*id)).ok_or("no such layer or object")?;
let xml_id = app.session.prefs.identify_objects_by == "xmlId";
let mut f = fields_of(first, xml_id);
if ids.len() > 1 {
let opened: serde_json::Map<_, _> =
["template", "locked", "dimImages", "dimPercent"].iter().filter_map(|k| Some((k.to_string(), f.get(*k)?.clone()))).collect();
f.insert(OPENED.into(), Value::Object(opened));
}
f.insert("ids".into(), json!(ids.iter().map(|i| i.0).collect::<Vec<_>>()));
f.insert("mode".into(), json!("edit"));
app.ui.dialog = Some(Dialog { kind: KIND.into(), fields: f });
Ok(Value::Null)
}
/// `ui.newLayer {sublayer?}`: Layer Options for a new layer (or sublayer), with the name and
/// colour it would get. In isolation mode a layer that would be outside the isolated art, where the
/// Layers panel does not list it, is an error.
pub fn open_new(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
let st = app.session.active().ok_or("no document open")?;
let sublayer = crate::menus::opt_bool(p, "sublayer")?.unwrap_or(false);
if crate::panels::layers::new_layer_unlisted(st, sublayer, false) {
return Err("exit isolation mode first".into());
}
let mut layers = vec![];
st.doc.walk(|n| {
if n.is_layer() {
layers.push(n.display_name());
}
});
let mut i = layers.len() + 1;
while layers.contains(&format!("Layer {i}")) {
i += 1;
}
let color = LayerColor::Preset((layers.len() % LAYER_COLORS.len()) as u8);
let name = format!("Layer {i}");
let name = if app.session.prefs.identify_objects_by == "xmlId" { vectorcraft_doc::xml_id::from_object_name(&name) } else { name };
let fields = json!({
"mode": if sublayer { "newSublayer" } else { "new" }, "layer": true, "name": name, "color": color_field(color),
"template": false, "locked": false, "visible": true, "printable": true, "preview": true, "dimImages": false, "dimPercent": 50,
});
app.ui.dialog = Some(Dialog::new(KIND, fields));
Ok(Value::Null)
}
fn toggle(ui: &mut egui::Ui, d: &mut Dialog, key: &str, text: &str, enabled: bool) -> bool {
let v = d.bool(key);
let changed = widgets::check(ui, text, v, enabled);
if changed {
choose(d, key, json!(!v));
}
changed
}
/// The size of the colour chip before each name in the Color list.
const CHIP: egui::Vec2 = egui::vec2(16.0, 10.0);
/// The Color list: each preset's name after a chip of its colour, then Custom (no chip, its
/// name aligned with the others). Returns the chosen row; Custom is `LAYER_COLORS.len()`.
fn color_dropdown(ui: &mut egui::Ui, shown: &str) -> Option<usize> {
let border = crate::theme::Tokens::get(ui.ctx()).input_border;
let rows = LAYER_COLORS.iter().map(|(n, c)| (*n, Some(*c))).chain([("Custom", None)]);
widgets::combo(ui, "layer-color", tl!(shown), 140.0, |ui| {
let mut chosen = None;
for (i, (name, rgb)) in rows.enumerate() {
let chip = egui::IdSalt::new(("layer-color-chip", i));
let r = egui::Button::selectable(name == shown, (egui::Atom::custom(chip, CHIP), tl!(name))).atom_ui(ui);
if let (Some(rect), Some([cr, cg, cb])) = (r.rect(chip), rgb) {
ui.painter().rect_filled(rect, 1.0, egui::Color32::from_rgb(cr, cg, cb));
ui.painter().rect_stroke(rect, 1.0, egui::Stroke::new(1.0, border), egui::StrokeKind::Inside);
}
if r.response.clicked() {
chosen = Some(i);
}
}
chosen
})
}
fn body(_: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
let layer = d.bool("layer");
let many = d.fields.get("ids").and_then(Value::as_array).is_some_and(|a| a.len() > 1);
grid(ui, |ui| {
if !many {
label(ui, tl!("Name:"));
form::text(ui, d, "name", 190.0);
ui.end_row();
}
if layer {
label(ui, tl!("Color:"));
ui.horizontal(|ui| {
let cur = d.str("color");
let shown = LAYER_COLORS.iter().map(|(n, _)| *n).find(|n| n.eq_ignore_ascii_case(&cur)).unwrap_or("Custom");
if let Some((n, _)) = color_dropdown(ui, shown).and_then(|i| LAYER_COLORS.get(i)) {
choose(d, "color", json!(n));
}
let [r, g, b] = LAYER_COLORS
.iter()
.find(|(n, _)| n.eq_ignore_ascii_case(&cur))
.map(|(_, c)| *c)
.or_else(|| {
vectorcraft_color::Color::from_hex(&cur).map(|c| {
let [r, g, b, _] = c.to_rgba8(1.0);
[r, g, b]
})
})
.unwrap_or(LAYER_COLORS[0].1);
let mut rgb = [r, g, b];
if ui.color_edit_button_srgb(&mut rgb).changed() {
choose(d, "color", json!(format!("#{:02x}{:02x}{:02x}", rgb[0], rgb[1], rgb[2])));
}
});
ui.end_row();
}
});
ui.add_space(8.0);
if layer {
ui.horizontal(|ui| {
ui.vertical(|ui| {
let template = d.bool("template");
if widgets::check(ui, tl!("Template"), template, true) {
set_template(d, !template);
}
toggle(ui, d, "visible", tl!("Show"), true);
toggle(ui, d, "preview", tl!("Preview"), true);
ui.horizontal(|ui| {
toggle(ui, d, "dimImages", tl!("Dim Images to:"), true);
let v = d.f64("dimPercent", 50.0);
let dim = d.bool("dimImages");
if let Some(v) = ui
.add_enabled_ui(dim, |ui| {
crate::widgets::range_field_named(ui, "dimPercent", Some(tl!("Dim Images to:")), v, 0.0..=100.0, "%", 0, 52.0)
})
.inner
{
choose(d, "dimPercent", json!(v));
}
});
});
ui.add_space(24.0);
ui.vertical(|ui| {
let template = d.bool("template");
toggle(ui, d, "locked", tl!("Lock"), !template);
toggle(ui, d, "printable", tl!("Print"), !template);
});
});
} else {
toggle(ui, d, "visible", tl!("Show"), true);
toggle(ui, d, "locked", tl!("Lock"), true);
}
false
}
/// The command and params OK runs. For several rows only the settings set in the dialog are sent,
/// so each row keeps its own values for the rest.
pub(crate) fn params(d: &Dialog) -> (&'static str, Value) {
let mut p = serde_json::Map::new();
let many = d.fields.get("ids").and_then(Value::as_array).is_some_and(|a| a.len() > 1);
if !many {
p.insert("name".into(), json!(d.str("name")));
}
p.insert("visible".into(), json!(d.bool("visible")));
p.insert("locked".into(), json!(d.bool("locked")));
if d.bool("layer") {
p.insert("color".into(), json!(d.str("color")));
p.insert("template".into(), json!(d.bool("template")));
p.insert("printable".into(), json!(d.bool("printable")));
p.insert("preview".into(), json!(d.bool("preview")));
p.insert("dimImages".into(), if d.bool("dimImages") { json!(d.f64("dimPercent", 50.0).clamp(0.0, 100.0)) } else { json!(false) });
}
if many {
// A percentage set in the dialog is sent whenever Dim Images is on, also when Dim Images
// was turned on by Template.
let percent = d.bool("dimImages") && is_set(d, "dimPercent");
p.retain(|k, _| is_set(d, k) || (k == "dimImages" && percent));
}
match d.str("mode").as_str() {
"new" => ("layer.new", Value::Object(p)),
"newSublayer" => ("layer.newSublayer", Value::Object(p)),
_ => {
p.insert("ids".into(), d.fields.get("ids").cloned().unwrap_or(json!([])));
("layer.setProps", Value::Object(p))
}
}
}
fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
let (cmd, p) = params(d);
// Isolation mode can start while the dialog is open.
let sublayer = match cmd {
"layer.new" => Some(false),
"layer.newSublayer" => Some(true),
_ => None,
};
if let Some(sublayer) = sublayer
&& app.session.active().is_some_and(|st| crate::panels::layers::new_layer_unlisted(st, sublayer, false))
{
return Err("exit isolation mode first".into());
}
run_and_close(app, cmd, p)
}
#[cfg(test)]
mod tests {
use super::*;
use vectorcraft_engine::Session;
fn app() -> VectorcraftApp {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
app
}
fn draw(app: &mut VectorcraftApp) {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let mut out = ctx.run_ui(Default::default(), |ui| super::super::show(app, ui.ctx()));
out.textures_delta.clear();
}
/// Sets a field as `ui.dialog.set` does.
fn set(app: &mut VectorcraftApp, k: &str, v: Value) {
super::super::set_field(app.ui.dialog.as_mut().unwrap(), k.into(), v);
}
/// Explicit object ids must not silently disappear or fall back to the highlighted row.
#[test]
fn invalid_layer_options_targets_do_not_open_a_partial_dialog() {
let mut app = app();
let id = app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
for params in
[json!({"ids": [id, "invalid"]}), json!({"ids": [id, 999999]}), json!({"ids": "invalid"}), json!({"id": "invalid"}), json!({"id": null})]
{
assert!(app.run("ui.layerOptions", params.clone()).is_err(), "accepted {params}");
assert!(app.ui.dialog.is_none(), "opened partial options for {params}");
}
app.run("ui.layerOptions", json!({"ids": [id]})).unwrap();
assert_eq!(app.ui.dialog.as_ref().unwrap().fields["ids"], json!([id]));
}
#[test]
fn layer_options_edit_the_layer_and_ok_is_one_undo_step() {
let mut app = app();
let layer = app.session.doc().unwrap().doc.layers[0].id;
app.run("ui.layerOptions", json!({})).unwrap();
let d = app.ui.dialog.clone().unwrap();
assert_eq!((d.kind.as_str(), d.str("name"), d.str("color")), (KIND, "Layer 1".to_string(), "Light Blue".to_string()));
draw(&mut app);
set(&mut app, "name", json!("Sky"));
set(&mut app, "color", json!("#00ff00"));
set(&mut app, "dimImages", json!(true));
set(&mut app, "dimPercent", json!(30));
set(&mut app, "preview", json!(false));
let undo = app.session.doc().unwrap().history.undo.len();
super::super::confirm(&mut app).unwrap();
assert!(app.ui.dialog.is_none());
let n = app.session.doc().unwrap().doc.node(layer).unwrap().clone();
assert_eq!(n.display_name(), "Sky");
assert!(matches!(n.kind, NodeKind::Layer { color: LayerColor::Custom([0, 255, 0]), dim_images: Some(30), preview: false, .. }));
assert_eq!(app.session.doc().unwrap().history.undo.len(), undo + 1);
}
/// Two layers with different options, the first plain and the second green, locked, in
/// outline view and dimmed to 30%.
fn two_layers(app: &mut VectorcraftApp) -> (NodeId, NodeId) {
let first = app.session.doc().unwrap().doc.layers[0].id;
let p = json!({"color": "#00ff00", "locked": true, "preview": false, "dimImages": 30});
let second = NodeId(app.session.execute("layer.new", &p).unwrap()["id"].as_u64().unwrap());
app.run("ui.layerOptions", json!({"ids": [first.0, second.0]})).unwrap();
draw(app);
(first, second)
}
fn layer(app: &VectorcraftApp, id: NodeId) -> Node {
app.session.doc().unwrap().doc.node(id).unwrap().clone()
}
/// A setting set to the first layer's own value still goes to every layer.
#[test]
fn layer_options_for_several_layers_send_only_the_settings_set() {
let mut app = app();
let (first, second) = two_layers(&mut app);
set(&mut app, "printable", json!(false));
set(&mut app, "color", json!("Light Blue"));
let (_, p) = params(app.ui.dialog.as_ref().unwrap());
assert_eq!(p, json!({"printable": false, "color": "Light Blue", "ids": [first.0, second.0]}));
super::super::confirm(&mut app).unwrap();
let (a, b) = (layer(&app, first), layer(&app, second));
assert!(matches!(a.kind, NodeKind::Layer { color: LayerColor::Preset(0), printable: false, preview: true, dim_images: None, .. }));
assert!(!a.locked);
let NodeKind::Layer { color, printable, preview, dim_images, .. } = b.kind else { panic!("not a layer") };
assert_eq!((color, printable, preview, dim_images, b.locked), (LayerColor::Preset(0), false, false, Some(30), true));
}
/// Template locks and dims to 50% each layer whose Template it changes; a Dim Images
/// percentage set as well goes to every layer.
#[test]
fn template_for_several_layers_leaves_lock_and_dimming_to_each_layer() {
let mut app = app();
let (first, second) = two_layers(&mut app);
app.run("layer.setProps", json!({"ids": [second.0], "template": true, "dimImages": 30})).unwrap();
app.run("ui.layerOptions", json!({"ids": [first.0, second.0]})).unwrap();
set(&mut app, "template", json!(true));
let (_, p) = params(app.ui.dialog.as_ref().unwrap());
assert_eq!(p, json!({"template": true, "ids": [first.0, second.0]}));
super::super::confirm(&mut app).unwrap();
let (a, b) = (layer(&app, first), layer(&app, second));
assert!(a.is_template() && a.locked && matches!(a.kind, NodeKind::Layer { dim_images: Some(50), .. }));
assert!(b.is_template() && b.locked && matches!(b.kind, NodeKind::Layer { dim_images: Some(30), .. }));
// The first layer is dimmed to 50% now; 50% set again goes to both.
app.run("ui.layerOptions", json!({"ids": [first.0, second.0]})).unwrap();
set(&mut app, "dimPercent", json!(50));
let (_, p) = params(app.ui.dialog.as_ref().unwrap());
assert_eq!(p, json!({"dimImages": 50.0, "ids": [first.0, second.0]}));
super::super::confirm(&mut app).unwrap();
assert!(matches!(layer(&app, second).kind, NodeKind::Layer { dim_images: Some(50), .. }));
// A percentage set while Dim Images is off is sent once Dim Images is on.
app.run("layer.setProps", json!({"ids": [first.0], "template": false, "dimImages": false})).unwrap();
app.run("ui.layerOptions", json!({"ids": [first.0, second.0]})).unwrap();
set(&mut app, "dimPercent", json!(20));
assert_eq!(params(app.ui.dialog.as_ref().unwrap()).1, json!({"ids": [first.0, second.0]}));
set(&mut app, "dimImages", json!(true));
assert_eq!(params(app.ui.dialog.as_ref().unwrap()).1, json!({"dimImages": 20.0, "ids": [first.0, second.0]}));
}
/// A percentage set while Dim Images is off is sent when Template turns Dim Images on.
#[test]
fn a_percentage_set_before_template_turns_dimming_on_goes_to_every_layer() {
let mut app = app();
let (first, second) = two_layers(&mut app);
set(&mut app, "dimPercent", json!(20));
set(&mut app, "template", json!(true));
let (_, p) = params(app.ui.dialog.as_ref().unwrap());
assert_eq!(p, json!({"template": true, "dimImages": 20.0, "ids": [first.0, second.0]}));
super::super::confirm(&mut app).unwrap();
for id in [first, second] {
assert!(matches!(layer(&app, id).kind, NodeKind::Layer { template: true, dim_images: Some(20), .. }));
}
}
/// The open dialog of `app` in a test harness, drawn and ready for clicks.
fn harness(app: VectorcraftApp) -> egui_kittest::Harness<'static, VectorcraftApp> {
let mut fonts = false;
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(900.0, 700.0)).build_ui_state(
move |ui, app: &mut VectorcraftApp| {
if !std::mem::replace(&mut fonts, true) {
crate::theme::install_fonts(ui.ctx());
return;
}
super::super::show(app, ui.ctx());
},
app,
);
h.run_steps(4);
h
}
/// Clicking Template ticks Lock and Dim Images and leaves them to each layer; clicking Dim
/// Images off afterwards sends that to every layer.
#[test]
fn dim_images_clicked_after_template_goes_to_every_layer() {
use egui_kittest::kittest::Queryable;
let mut app = app();
let (first, second) = two_layers(&mut app);
let mut h = harness(app);
h.get_by_role_and_label(egui::accesskit::Role::CheckBox, "Template").click();
h.run_steps(3);
let d = h.state().ui.dialog.as_ref().unwrap();
assert!(d.bool("template") && d.bool("locked") && d.bool("dimImages"));
assert_eq!(params(d).1, json!({"template": true, "ids": [first.0, second.0]}));
h.get_by_role_and_label(egui::accesskit::Role::CheckBox, "Dim Images to:").click();
h.run_steps(3);
let (_, p) = params(h.state().ui.dialog.as_ref().unwrap());
assert_eq!(p, json!({"template": true, "dimImages": false, "ids": [first.0, second.0]}));
let app = h.state_mut();
super::super::confirm(app).unwrap();
for id in [first, second] {
let n = layer(app, id);
assert!(n.locked && matches!(n.kind, NodeKind::Layer { template: true, dim_images: None, .. }));
}
}
/// Template set through `ui.dialog.set` locks and dims as its checkbox does, and set back it
/// shows the first layer's Lock and Dim Images again and sends neither.
#[test]
fn template_set_and_set_back_leaves_lock_and_dimming_alone() {
let mut app = app();
let (first, second) = two_layers(&mut app);
app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap();
app.run("ui.layerOptions", json!({"ids": [first.0, second.0]})).unwrap();
set(&mut app, "template", json!(true));
let d = app.ui.dialog.as_ref().unwrap();
assert!(d.bool("locked") && d.bool("dimImages"));
assert_eq!(params(d).1, json!({"template": true, "ids": [first.0, second.0]}));
set(&mut app, "template", json!(false));
let d = app.ui.dialog.as_ref().unwrap();
assert!(d.bool("locked") && !d.bool("dimImages"));
assert_eq!(params(d).1, json!({"template": false, "ids": [first.0, second.0]}));
super::super::confirm(&mut app).unwrap();
assert!(layer(&app, first).locked && layer(&app, second).locked);
assert!(matches!(layer(&app, second).kind, NodeKind::Layer { dim_images: Some(30), .. }));
}
/// Template turned on shows the 50% that `layer.setProps` dims each new template to, and
/// turned back off shows the first layer's own percentage again.
#[test]
fn template_shows_the_percentage_it_dims_to() {
let mut app = app();
let (first, second) = two_layers(&mut app);
app.run("layer.setProps", json!({"ids": [first.0], "dimImages": 30})).unwrap();
app.run("ui.layerOptions", json!({"ids": [first.0, second.0]})).unwrap();
set(&mut app, "template", json!(true));
let d = app.ui.dialog.as_ref().unwrap();
assert_eq!(d.f64("dimPercent", 0.0), 50.0);
set(&mut app, "template", json!(false));
let d = app.ui.dialog.as_ref().unwrap();
assert!(d.bool("dimImages"));
assert_eq!(d.f64("dimPercent", 0.0), 30.0);
assert_eq!(params(d).1, json!({"template": false, "ids": [first.0, second.0]}));
set(&mut app, "template", json!(true));
super::super::confirm(&mut app).unwrap();
assert!(matches!(layer(&app, first).kind, NodeKind::Layer { template: true, dim_images: Some(50), .. }));
}
/// Template set through `ui.dialog.set` for one layer locks it and dims its images, as the
/// checkbox does.
#[test]
fn template_set_for_one_layer_locks_and_dims_it() {
let mut app = app();
let id = app.session.doc().unwrap().doc.layers[0].id;
app.run("ui.layerOptions", json!({"ids": [id.0]})).unwrap();
set(&mut app, "template", json!(true));
super::super::confirm(&mut app).unwrap();
let n = layer(&app, id);
assert!(n.locked && matches!(n.kind, NodeKind::Layer { template: true, dim_images: Some(50), .. }));
}
/// A percentage typed in while Dim Images is on stays set when Template is then clicked on,
/// since Template leaves Dim Images on.
#[test]
fn a_percentage_typed_before_template_goes_to_every_layer() {
use egui_kittest::kittest::Queryable;
let mut app = app();
let (first, second) = two_layers(&mut app);
app.run("layer.setProps", json!({"ids": [first.0], "dimImages": 30})).unwrap();
app.run("ui.layerOptions", json!({"ids": [first.0, second.0]})).unwrap();
set(&mut app, "dimPercent", json!(40));
let mut h = harness(app);
h.get_by_role_and_label(egui::accesskit::Role::CheckBox, "Template").click();
h.run_steps(3);
let (_, p) = params(h.state().ui.dialog.as_ref().unwrap());
assert_eq!(p, json!({"template": true, "dimImages": 40.0, "ids": [first.0, second.0]}));
// Template off again shows the first layer's Dim Images, on, and the percentage still
// goes to every layer.
h.get_by_role_and_label(egui::accesskit::Role::CheckBox, "Template").click();
h.run_steps(3);
let (_, p) = params(h.state().ui.dialog.as_ref().unwrap());
assert_eq!(p, json!({"template": false, "dimImages": 40.0, "ids": [first.0, second.0]}));
}
/// A Dim Images set in the dialog stays as set when Template is set after it, so
/// `ui.dialog.set` gives the same result in either order. Template still locks the layers.
#[test]
fn template_keeps_dim_images_that_was_set() {
for dim_first in [true, false] {
let mut app = app();
let (first, second) = two_layers(&mut app);
if dim_first {
set(&mut app, "dimImages", json!(false));
set(&mut app, "template", json!(true));
} else {
set(&mut app, "template", json!(true));
set(&mut app, "dimImages", json!(false));
}
let d = app.ui.dialog.as_ref().unwrap();
assert!(d.bool("template") && d.bool("locked") && !d.bool("dimImages"), "dim first: {dim_first}");
assert_eq!(params(d).1, json!({"template": true, "dimImages": false, "ids": [first.0, second.0]}), "dim first: {dim_first}");
super::super::confirm(&mut app).unwrap();
for id in [first, second] {
let n = layer(&app, id);
assert!(n.locked && matches!(n.kind, NodeKind::Layer { template: true, dim_images: None, .. }), "{id:?}, dim first: {dim_first}");
}
}
}
/// OK in New Layer Options makes no layer outside the isolated art when isolation mode started
/// while the dialog was open.
#[test]
fn new_layer_options_ok_checks_isolation_again() {
let mut app = app();
let id = |v: Value| v["id"].as_u64().unwrap();
let rect = id(app.session.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap());
app.session.execute("select.set", &json!({"ids": [rect]})).unwrap();
let group = id(app.session.execute("object.group", &json!({})).unwrap());
app.run("ui.newLayer", json!({})).unwrap();
app.session.execute("object.isolate", &json!({"id": group})).unwrap();
draw(&mut app);
let err = super::super::confirm(&mut app).unwrap_err();
assert!(err.contains("exit isolation mode first"), "{err}");
assert_eq!(app.session.doc().unwrap().doc.layers.len(), 1);
}
#[test]
fn new_layer_options_make_a_layer_and_objects_get_name_show_and_lock() {
let mut app = app();
app.run("ui.newLayer", json!({})).unwrap();
assert_eq!(app.ui.dialog.as_ref().unwrap().str("name"), "Layer 2");
set(&mut app, "name", json!("Ink"));
set(&mut app, "template", json!(true));
set(&mut app, "locked", json!(true));
draw(&mut app);
super::super::confirm(&mut app).unwrap();
let d = &app.session.doc().unwrap().doc;
let top = d.layers.last().unwrap();
assert_eq!(top.display_name(), "Ink");
assert!(top.is_template() && top.locked);
// An object's row: Name, Show and Lock.
let r = app.session.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10}));
assert!(r.is_ok());
app.session.execute("layer.setCurrent", &json!({"id": app.session.doc().unwrap().doc.layers[0].id.0})).unwrap();
let rect = app.session.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
app.run("ui.layerOptions", json!({"id": rect})).unwrap();
assert!(!app.ui.dialog.as_ref().unwrap().bool("layer"));
draw(&mut app);
set(&mut app, "name", json!("Box"));
set(&mut app, "locked", json!(true));
let (cmd, p) = params(app.ui.dialog.as_ref().unwrap());
assert_eq!(cmd, "layer.setProps");
assert!(p.get("template").is_none());
super::super::confirm(&mut app).unwrap();
let n = app.session.doc().unwrap().doc.node(NodeId(rect)).unwrap().clone();
assert_eq!((n.display_name(), n.locked), ("Box".to_string(), 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.