PhotoCraft: An open-source, photo editor written by scratch in pure Rust
//! Multi-layer selection and the commands that act on it: ⌘/⇧-click selection, Select › All /
//! Deselect / Find Layers, Layer › Align and Distribute, Link Layers, Merge Layers, Group from
//! Layers, Arrange › Reverse, Lock Layers and Rename Layer.
//!
//! The selection itself lives in [`DocState::selected_layers`] (UI state, like the active layer):
//! changing it never adds a history step. Every structural change below is one history step.
use photocraft_color::PixelFormat;
use photocraft_doc::{Document, Layer, LayerContent, LayerId, VideoData};
use photocraft_geom::Rect;
use serde_json::{Value, json};
use crate::commands::{CommandSpec, int_i32};
use crate::{DocState, EngineError, Result, Session};
// ---------- selection state ----------
fn doc_state(s: &Session) -> std::result::Result<&DocState, String> {
s.active().ok_or_else(|| "no document open".into())
}
/// Selected layers of the active document, bottom-to-top.
pub fn selected(s: &Session) -> Vec<LayerId> {
s.active().map(DocState::selected_layers).unwrap_or_default()
}
/// The layers a layer command acts on: the `layer` param when given, else every selected layer
/// (bottom-to-top), else the active layer. A single layer behaves exactly as before.
pub(crate) fn targets(s: &Session, p: &serde_json::Value) -> Result<Vec<LayerId>> {
if p.get("layer").is_some() {
return Ok(vec![crate::commands::layer_param(s, p)?]);
}
match selected(s) {
sel if sel.is_empty() => Ok(vec![crate::commands::layer_param(s, p)?]),
sel => Ok(sel),
}
}
/// [`targets`] for a command that adds a layer mask: with several layers selected, those that can
/// take one (no layer mask yet, not the Background); one layer is taken as given.
pub(crate) fn mask_targets(s: &Session, p: &serde_json::Value) -> Result<Vec<LayerId>> {
let ids = targets(s, p)?;
if ids.len() < 2 {
return Ok(ids);
}
let d = s.active().ok_or(EngineError::NoDocument)?;
let ids: Vec<LayerId> = ids.into_iter().filter(|id| d.doc.layer(*id).is_some_and(|l| l.mask.is_none() && !d.doc.is_background(l.id))).collect();
if ids.is_empty() {
return Err(EngineError::Other("none of the selected layers can take a layer mask".into()));
}
Ok(ids)
}
/// Ids in `ids` that have no ancestor also in `ids` (a selected group already carries its
/// selected children), bottom-to-top.
pub(crate) fn top_level(doc: &Document, ids: &[LayerId]) -> Vec<LayerId> {
let walk = doc.walk();
let paths: Vec<_> = walk.iter().filter(|(_, _, l)| ids.contains(&l.id)).map(|(p, _, l)| (p.clone(), l.id)).collect();
paths.iter().filter(|(p, _)| !paths.iter().any(|(q, _)| q.len() < p.len() && p.starts_with(q))).map(|(_, id)| *id).collect()
}
/// Replace the layer selection without a history step (like [`Session::select_layer`]).
pub fn set_selection(s: &mut Session, ids: Vec<LayerId>, active: Option<LayerId>, anchor: Option<LayerId>) -> Result<()> {
let st = s.active_mut().ok_or(EngineError::NoDocument)?;
if let Some(bad) = ids.iter().chain(active.iter()).find(|id| st.doc.layer(**id).is_none()) {
return Err(EngineError::NoLayer(*bad));
}
let active = active.or_else(|| ids.last().copied());
st.selected_layers = ids;
if let Some(a) = active
&& !st.selected_layers.contains(&a)
{
st.selected_layers.push(a);
}
st.active_layer = active;
st.layer_anchor = anchor.or(active);
crate::fix_selection(st);
// Selecting layers is not an edit: keep a clean document clean.
let clean = st.saved_revision == st.revision;
st.revision += 1;
if clean {
st.saved_revision = st.revision;
}
st.last_damage = Some(Rect::EMPTY);
Ok(())
}
/// After a structural edit, make `ids` the selection (dropping any that no longer exist), which
/// is also what the edit's history state targets.
pub(crate) fn reselect(s: &mut Session, ids: Vec<LayerId>, active: Option<LayerId>) {
if let Some(st) = s.active_mut() {
st.selected_layers = ids;
if let Some(a) = active {
st.active_layer = Some(a);
st.layer_anchor = Some(a);
}
crate::fix_selection(st);
let layers = st.layer_target();
st.history.set_current_layers(layers);
}
}
/// Capture a selection target while its name is still known. Later renames/deletions must not
/// change an earlier recorded selection. Direct, non-recording calls retain their numeric IDs.
pub(crate) fn recorded_selection(s: &Session, mut p: Value) -> Value {
let Some(id) = p.get("layer").and_then(Value::as_u64).map(LayerId) else { return p };
let Some(st) = s.active() else { return p };
let Some(layer) = st.doc.layer(id) else { return p };
let matches: Vec<_> = st.doc.walk().into_iter().filter(|(_, _, l)| l.name == layer.name).map(|(_, _, l)| l.id).collect();
let Some(occurrence) = matches.iter().position(|candidate| *candidate == id) else { return p };
if let Some(fields) = p.as_object_mut() {
fields.remove("layer");
fields.insert("name".into(), json!(layer.name));
if matches.len() > 1 {
fields.insert("occurrence".into(), json!(occurrence));
}
}
p
}
/// The layers named `name`, in document order, other than the ones being moved and (groups) their
/// contents. Moving layers never changes the others' order, so an occurrence counted among these
/// means the same layer before the move (when an action replays it) and after it (when the step
/// is recorded).
fn same_named_targets(doc: &photocraft_doc::Document, name: &str, moved: &[LayerId]) -> Vec<LayerId> {
fn subtree(l: &Layer, out: &mut Vec<LayerId>, depth: usize) {
out.push(l.id);
if depth < 256
&& let Some(children) = l.children()
{
children.iter().for_each(|c| subtree(c, out, depth + 1));
}
}
let mut skip = Vec::new();
for l in moved.iter().filter_map(|id| doc.layer(*id)) {
subtree(l, &mut skip, 0);
}
doc.walk().into_iter().filter(|(_, _, l)| l.name == name && !skip.contains(&l.id)).map(|(_, _, l)| l.id).collect()
}
/// A Layers-panel drag of the selected layer records its drop target by name (and which of
/// several same-named layers it is), as [`recorded_selection`] does: the id means nothing in the
/// document the action plays in later, so playback failed with "no such layer" (#7845). Drags of
/// several layers, or of a layer that isn't the selected one, keep their ids.
fn recorded_move(s: &Session, mut p: Value, pre_selected: Option<&[LayerId]>) -> Value {
if p.get("layers").is_some() {
return p;
}
let Some(st) = s.active() else { return p };
let moved = match p.get("layer") {
None => st.active_layer,
Some(v) => match v.as_u64().map(LayerId) {
Some(id) if pre_selected.map_or_else(|| st.selected_layers().as_slice() == [id], |sel| sel == [id]) => Some(id),
_ => return p,
},
};
if let Some(fields) = p.as_object_mut() {
fields.remove("layer");
}
let Some(id) = p.get("target").and_then(Value::as_u64).map(LayerId) else { return p };
let Some(layer) = st.doc.layer(id) else { return p };
// A copy leaves its source where it is (it may even land beside it), so the source stays a
// candidate; the new copy (the active layer once the step has run, which is when it is
// recorded) is left out instead, as it doesn't exist yet when the step replays.
let copy = p.get("copy").and_then(Value::as_bool).unwrap_or(false);
let skip = if copy { st.active_layer.filter(|a| Some(*a) != moved) } else { moved };
let matches = same_named_targets(&st.doc, &layer.name, skip.as_slice());
let Some(occurrence) = matches.iter().position(|candidate| *candidate == id) else { return p };
if let Some(fields) = p.as_object_mut() {
fields.insert("target".into(), json!(layer.name));
if matches.len() > 1 {
fields.insert("targetOccurrence".into(), json!(occurrence));
}
}
p
}
/// `layer.moveTo`'s drop target: an id, or a name with `targetOccurrence` choosing among layers
/// that share it (in document order, the `moved` layers aside; required when several do).
fn move_target(s: &Session, p: &Value, moved: &[LayerId]) -> Result<LayerId> {
const CMD: &str = "layer.moveTo";
match p.get("target") {
Some(Value::String(name)) => {
let occurrence = p
.get("targetOccurrence")
.map(|v| v.as_u64().and_then(|n| usize::try_from(n).ok()).ok_or_else(|| bad(CMD, "`targetOccurrence` must be a non-negative integer")))
.transpose()?;
let st = s.active().ok_or(EngineError::NoDocument)?;
let matches = same_named_targets(&st.doc, name, moved);
if matches.len() > 1 && occurrence.is_none() {
return Err(bad(CMD, format!("multiple layers named `{name}`; specify `targetOccurrence`")));
}
let index = occurrence.unwrap_or(0);
matches.get(index).copied().ok_or_else(|| bad(CMD, format!("no layer named `{name}` at occurrence {index}")))
}
Some(v) => v.as_u64().map(LayerId).ok_or_else(|| bad(CMD, "`target` must be a layer id or name")),
None => Err(bad(CMD, "missing `target`")),
}
}
/// Normalise parameters when recording an action step.
///
/// For `layer.select`, captures the layer by name. For other commands, if a numeric `layer`
/// parameter references the document's sole selected layer, normalises it to the target form
/// (omitting `layer`) so that the recorded step applies to whatever layer is targeted when
/// replayed or exported to `.atn` (#7248).
pub(crate) fn recorded_step(s: &Session, id: &str, p: Value, pre_selected: Option<&[LayerId]>) -> Value {
if id == "layer.select" {
return recorded_selection(s, p);
}
if id == "layer.moveTo" {
return recorded_move(s, p, pre_selected);
}
let Some(layer_id) = p.get("layer").and_then(Value::as_u64).map(LayerId) else { return p };
let is_sole_selected = match pre_selected {
Some(sel) => sel == [layer_id],
None => s.active().is_some_and(|st| st.selected_layers().as_slice() == [layer_id]),
};
if is_sole_selected {
let mut p = p;
if let Some(fields) = p.as_object_mut() {
fields.remove("layer");
}
return p;
}
p
}
fn selection_target(s: &Session, p: &Value) -> Result<LayerId> {
let Some(name) = p.get("name") else {
if p.get("occurrence").is_some() {
return Err(bad("layer.select", "`occurrence` requires `name`"));
}
return crate::commands::explicit_layer(s, p)?.ok_or_else(|| bad("layer.select", "needs `layer` or `name`"));
};
if p.get("layer").is_some() {
return Err(bad("layer.select", "use either `layer` or `name`, not both"));
}
let name = name.as_str().ok_or_else(|| bad("layer.select", "`name` must be a string"))?;
let occurrence = p
.get("occurrence")
.map(|v| v.as_u64().and_then(|n| usize::try_from(n).ok()).ok_or_else(|| bad("layer.select", "`occurrence` must be a non-negative integer")))
.transpose()?;
let st = s.active().ok_or(EngineError::NoDocument)?;
let matches: Vec<_> = st.doc.walk().into_iter().filter(|(_, _, l)| l.name == name).map(|(_, _, l)| l.id).collect();
if matches.len() > 1 && occurrence.is_none() {
return Err(bad("layer.select", format!("multiple layers named `{name}`; specify `occurrence`")));
}
let index = occurrence.unwrap_or(0);
matches.get(index).copied().ok_or_else(|| bad("layer.select", format!("no layer named `{name}` at occurrence {index}")))
}
/// Layer rows follow the Layers panel's visual order, not Document::walk's storage order.
/// Closed groups hide their children unless both endpoints were selected programmatically.
fn range_order(layers: &[Layer], include_collapsed: bool, out: &mut Vec<LayerId>) {
for layer in layers.iter().rev() {
out.push(layer.id);
if let LayerContent::Group(group) = &layer.content
&& (group.expanded || include_collapsed)
{
range_order(&group.children, include_collapsed, out);
}
}
}
/// `layer.select`: `{"layer": id, "mode": "replace|toggle|range|add|remove"}`.
pub fn select(s: &mut Session, p: &Value) -> Result<Value> {
let id = selection_target(s, p)?;
let mode = p.get("mode").and_then(Value::as_str).unwrap_or("replace");
let st = s.active().ok_or(EngineError::NoDocument)?;
if st.doc.layer(id).is_none() {
return Err(EngineError::NoLayer(id));
}
let mut sel = st.selected_layers();
match mode {
"replace" => s.select_layer(id)?,
"add" => {
if !sel.contains(&id) {
sel.push(id);
}
set_selection(s, sel, Some(id), Some(id))?;
}
"toggle" => {
if sel.contains(&id) {
if sel.len() == 1 {
// Photoshop keeps at least the clicked layer targeted.
return Ok(json!({"selected": [id.0]}));
}
sel.retain(|x| *x != id);
let active = if st.active_layer == Some(id) { sel.last().copied() } else { st.active_layer };
set_selection(s, sel, active, active)?;
} else {
sel.push(id);
set_selection(s, sel, Some(id), Some(id))?;
}
}
// Toggle's removing half: a layer that isn't selected stays unselected (Photoshop's
// `removeFromSelection`, recorded by actions).
"remove" => {
if sel.contains(&id) && sel.len() > 1 {
sel.retain(|x| *x != id);
let active = if st.active_layer == Some(id) { sel.last().copied() } else { st.active_layer };
set_selection(s, sel, active, active)?;
}
}
"range" => {
let anchor = st.layer_anchor.filter(|a| st.doc.layer(*a).is_some()).or(st.active_layer).unwrap_or(id);
let mut order = Vec::new();
range_order(&st.doc.layers, false, &mut order);
// Engine clients may target a child of a collapsed group that the panel cannot
// click. Retain that capability by using expanded visual order for such calls.
if !order.contains(&anchor) || !order.contains(&id) {
order.clear();
range_order(&st.doc.layers, true, &mut order);
}
let (a, b) = (order.iter().position(|x| *x == anchor).unwrap_or(0), order.iter().position(|x| *x == id).unwrap_or(0));
let range = order[a.min(b)..=a.max(b)].to_vec();
set_selection(s, range, Some(id), Some(anchor))?;
}
other => return Err(bad("layer.select", format!("unknown mode `{other}`"))),
}
Ok(json!({"selected": selected(s).iter().map(|l| l.0).collect::<Vec<_>>()}))
}
fn select_all_layers(s: &mut Session) -> Result<Value> {
let d = s.active().ok_or(EngineError::NoDocument)?;
let ids: Vec<LayerId> = d.doc.walk().into_iter().filter(|(_, _, l)| !d.doc.is_background(l.id)).map(|(_, _, l)| l.id).collect();
if ids.is_empty() {
return Err(EngineError::Other("there are no layers to select".into()));
}
let active = d.active_layer.filter(|a| ids.contains(a)).or(ids.last().copied());
let n = ids.len();
set_selection(s, ids, active, None)?;
Ok(json!({"selected": n}))
}
fn find_layers(s: &mut Session, p: &Value) -> Result<Value> {
let needle = p.get("name").and_then(Value::as_str).ok_or_else(|| bad("select.findLayers", "missing `name`"))?.to_lowercase();
let d = s.active().ok_or(EngineError::NoDocument)?;
let ids: Vec<LayerId> = d.doc.walk().into_iter().filter(|(_, _, l)| l.name.to_lowercase().contains(&needle)).map(|(_, _, l)| l.id).collect();
if ids.is_empty() {
return Err(EngineError::Other(format!("no layer name contains \"{needle}\"")));
}
let out = ids.iter().map(|l| l.0).collect::<Vec<_>>();
set_selection(s, ids, None, None)?;
Ok(json!({"selected": out}))
}
fn select_linked(s: &mut Session) -> Result<Value> {
let d = s.active().ok_or(EngineError::NoDocument)?;
let groups = link_groups(&d.doc, &d.selected_layers());
let ids: Vec<LayerId> = d.doc.walk().into_iter().filter(|(_, _, l)| l.link_group.is_some_and(|g| groups.contains(&g))).map(|(_, _, l)| l.id).collect();
let active = d.active_layer.filter(|a| ids.contains(a)).or(ids.last().copied());
let n = ids.len();
set_selection(s, ids, active, active)?;
Ok(json!({"selected": n}))
}
// ---------- enabled predicates ----------
fn has_layer(s: &Session) -> std::result::Result<(), String> {
if selected(s).is_empty() { Err("no layer selected".into()) } else { Ok(()) }
}
fn has_doc(s: &Session) -> std::result::Result<(), String> {
doc_state(s).map(|_| ())
}
fn two_plus(s: &Session) -> std::result::Result<(), String> {
if selected(s).len() >= 2 { Ok(()) } else { Err("select two or more layers".into()) }
}
fn can_align(s: &Session) -> std::result::Result<(), String> {
let d = doc_state(s)?;
match d.selected_layers().len() {
0 => Err("no layer selected".into()),
// Photoshop aligns to an active selection however many layers are selected; without one,
// a single layer aligns to the canvas and 2+ align to each other.
_ => Ok(()),
}
}
fn can_distribute(s: &Session) -> std::result::Result<(), String> {
if selected(s).len() >= 3 { Ok(()) } else { Err("select three or more layers to distribute".into()) }
}
fn can_link(s: &Session) -> std::result::Result<(), String> {
let d = doc_state(s)?;
let sel = d.selected_layers();
match sel.len() {
0 => Err("no layer selected".into()),
1 if d.doc.layer(sel[0]).is_none_or(|l| l.link_group.is_none()) => Err("select two or more layers to link".into()),
_ => Ok(()),
}
}
fn has_linked(s: &Session) -> std::result::Result<(), String> {
let d = doc_state(s)?;
if link_groups(&d.doc, &d.selected_layers()).is_empty() { Err("the selected layers are not linked".into()) } else { Ok(()) }
}
fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
EngineError::BadParams { cmd: cmd.into(), msg: msg.into() }
}
// ---------- moving layers ----------
fn link_groups(doc: &Document, ids: &[LayerId]) -> Vec<u64> {
let mut g: Vec<u64> = ids.iter().filter_map(|id| doc.layer(*id)?.link_group).collect();
g.sort_unstable();
g.dedup();
g
}
/// `ids` plus every layer linked to one of them.
pub(crate) fn with_links(doc: &Document, ids: &[LayerId]) -> Vec<LayerId> {
let groups = link_groups(doc, ids);
let mut out = ids.to_vec();
if !groups.is_empty() {
for (_, _, l) in doc.walk() {
if l.link_group.is_some_and(|g| groups.contains(&g)) && !out.contains(&l.id) {
out.push(l.id);
}
}
}
out
}
/// Move layers by whole pixels the way the Move tool does: pixels, linked masks, type and
/// vector content (shapes, linked vector masks) all move together. `before` is `doc` as it was
/// before any of the moves (the edit's starting document), read when type and shapes re-render.
pub(crate) fn move_layers(doc: &mut Document, before: &Document, moves: &[(LayerId, i32, i32)]) -> Result<()> {
for &(id, dx, dy) in moves {
if dx == 0 && dy == 0 {
continue;
}
let locks = doc.effective_locks(id);
let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
if locks.position || locks.all {
return Err(EngineError::Other(format!("layer \"{}\" is position-locked", l.name)));
}
crate::commands::translate_layer(before, l, dx, dy);
crate::vector_cmds::translate_vectors(before, l, dx as f64, dy as f64);
}
Ok(())
}
/// Does a move aimed at the layer mask (`"target":"mask"`) move `l`'s mask alone? Only an
/// unlinked mask does (the chain off); a linked one moves with its layer, as in Photoshop.
pub fn moves_mask_alone(l: &Layer) -> bool {
l.mask.as_ref().is_some_and(|m| !m.linked)
}
/// `layer.translate`: the explicit layer, or every selected layer, plus their linked layers.
/// With `"target":"mask"` a layer whose mask is unlinked moves that mask alone.
pub fn translate(s: &mut Session, p: &Value) -> Result<Value> {
let (dx, dy) = match p.get("units").and_then(Value::as_str) {
None | Some("px") => (int_i32("layer.translate", p, "dx")?.unwrap_or(0), int_i32("layer.translate", p, "dy")?.unwrap_or(0)),
// Points (1/72 in), as a Photoshop action records a nudge: whole pixels at this
// document's resolution.
Some("pt") => {
let dpi = s.active().map_or(72.0, |d| f64::from(d.doc.resolution_dpi));
let to_px = |key: &str| -> Result<i32> {
let pt = match p.get(key) {
None => 0.0,
Some(v) => v.as_f64().filter(|f| f.is_finite()).ok_or_else(|| bad("layer.translate", format!("`{key}` must be a number")))?,
};
let px = (pt * dpi / 72.0).round();
if px.abs() > f64::from(i32::MAX) {
return Err(bad("layer.translate", format!("`{key}` = {pt} pt is outside the 32-bit coordinate range")));
}
Ok(px as i32)
};
(to_px("dx")?, to_px("dy")?)
}
Some(other) => return Err(bad("layer.translate", format!("unknown units `{other}` (px|pt)"))),
};
let carry = match p.get("selection") {
None | Some(Value::Null) => false,
Some(v) => v.as_bool().ok_or_else(|| bad("layer.translate", "`selection` must be a boolean"))?,
};
if dx == 0 && dy == 0 {
return Ok(Value::Null);
}
let roots = match crate::commands::explicit_layer(s, p)? {
Some(id) => vec![id],
None => selected(s),
};
if roots.is_empty() {
return Err(EngineError::Other("no active layer".into()));
}
let mask_target = p.get("target").and_then(Value::as_str) == Some("mask");
let before = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
let ids = s.edit("Move", |doc, _| {
let (alone, rest): (Vec<LayerId>, Vec<LayerId>) = roots.iter().partition(|id| mask_target && doc.layer(**id).is_some_and(moves_mask_alone));
let mut ids = move_targets(doc, &rest);
if ids.is_empty() && alone.is_empty() {
return Err(EngineError::NoLayer(roots[0]));
}
let moves: Vec<_> = ids.iter().map(|&id| (id, dx, dy)).collect();
move_layers(doc, &before, &moves)?;
for id in alone {
let locks = doc.effective_locks(id);
let l = doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
if locks.position || locks.all {
return Err(EngineError::Other(format!("layer \"{}\" is position-locked", l.name)));
}
if let Some(m) = &mut l.mask {
m.surface = shift_surface(&m.surface, dx, dy);
}
ids.push(id);
}
// A board moved past any canvas edge grows the canvas, as a new one does (#1531, #3070).
if ids.iter().any(|id| doc.layer(*id).is_some_and(|l| l.artboard().is_some())) {
crate::artboard_cmds::fit_canvas(doc);
}
// The Move tool carries the selection along when it moves several layers whole, as
// Photoshop does (#7538): one step, so Undo takes both back.
if carry {
doc.selection = doc.selection.as_ref().map(|sel| shift_surface(sel, dx, dy));
}
Ok(ids)
})?;
note_damage(s, &before, &ids);
Ok(Value::Null)
}
/// The layers a move of `roots` takes along: their linked layers, without layers whose group
/// is also moving (the group carries them).
pub fn move_targets(doc: &Document, roots: &[LayerId]) -> Vec<LayerId> {
top_level(doc, &with_links(doc, roots))
}
/// `doc` with the layers `ids` ([`move_targets`]) moved by whole pixels, as `layer.translate`
/// leaves them: the Move tool's live preview while it drags. Type, shape and smart-object pixels
/// shift as they are instead of re-rendering (the commit re-renders them), so a drag frame costs
/// copying the moving pixels only.
pub fn moved(doc: &Document, ids: &[LayerId], dx: i32, dy: i32) -> Result<Document> {
moved_target(doc, ids, dx, dy, false)
}
/// [`moved`] for a drag aimed at the layer mask (`mask_target`): unlinked masks move alone.
pub fn moved_target(doc: &Document, ids: &[LayerId], dx: i32, dy: i32, mask_target: bool) -> Result<Document> {
let mut out = doc.clone();
for &id in ids {
let locks = doc.effective_locks(id);
let l = out.layer_mut(id).ok_or(EngineError::NoLayer(id))?;
if locks.position || locks.all {
return Err(EngineError::Other(format!("layer \"{}\" is position-locked", l.name)));
}
if mask_target && moves_mask_alone(l) {
if let Some(m) = &mut l.mask {
m.surface = shift_surface(&m.surface, dx, dy);
}
continue;
}
shift_shown(doc, l, dx, dy);
}
Ok(out)
}
/// `photocraft_algo::resample::translate_surface` with the content scan cached per tile (a Move
/// drag shifts the same layers every frame; scanning them each time cost more than the copy).
pub(crate) fn shift_surface(s: &photocraft_raster::Surface, dx: i32, dy: i32) -> photocraft_raster::Surface {
s.translated(dx, dy, photocraft_compose::bounds::content_bounds(s))
}
/// [`crate::commands::translate_layer`] plus the vector side, without re-rendering anything.
fn shift_shown(doc: &Document, l: &mut Layer, dx: i32, dy: i32) {
use self::shift_surface as translate_surface;
let a = photocraft_geom::Affine::translate(f64::from(dx), f64::from(dy));
if let Some(r) = &mut l.effects.reference {
*r = (r.0 + f64::from(dx), r.1 + f64::from(dy));
}
if let Some(m) = l.mask.as_mut().filter(|m| m.linked) {
m.surface = translate_surface(&m.surface, dx, dy);
}
if let Some(vm) = l.vector_mask.as_mut().filter(|v| v.linked) {
vm.path = vm.path.transform(&a);
}
match &mut l.content {
LayerContent::Raster(s) => *s = translate_surface(s, dx, dy),
LayerContent::Text(t) => {
t.transform = a.mul(&t.transform);
if let Some(c) = &mut t.cache {
*c = translate_surface(c, dx, dy);
}
}
LayerContent::Shape(sh) => crate::vector_cmds::shift_shape(doc, sh, f64::from(dx), f64::from(dy)),
LayerContent::Smart(sm) => crate::smart_cmds::shift_smart(sm, dx, dy),
LayerContent::Group(g) => {
if let Some(ab) = &mut g.artboard {
ab.rect = ab.rect.translate(dx, dy);
}
g.children.iter_mut().for_each(|c| shift_shown(doc, c, dx, dy));
}
LayerContent::Adjustment(_) | LayerContent::Fill(_) => {}
}
}
/// The document pixels an edit of the layers `ids` (moved, shown, hidden or restyled; contents
/// otherwise as they were) can have changed from `before` to `after`, or `None` for anywhere.
pub fn layers_damage(before: &Document, after: &Document, ids: &[LayerId]) -> Option<Rect> {
let mut out = Rect::EMPTY;
for d in [before, after] {
let canvas = d.bounds();
for id in ids {
// A layer gone from one side (never for a move) changes who knows what.
let (siblings, k, outer) = siblings_of(d, *id)?;
let b = photocraft_compose::change_bounds_in(siblings, k, outer, canvas)?;
if !b.is_empty() {
out = if out.is_empty() { b } else { out.union(&b) };
}
}
}
Some(out)
}
/// The sibling list holding layer `id` in `doc` (bottom→top), its index there, and the list
/// holding its parent group with the group's index (`None` at the top level).
type Siblings<'d> = (&'d [Layer], usize, Option<(&'d [Layer], usize)>);
fn siblings_of(doc: &Document, id: LayerId) -> Option<Siblings<'_>> {
let path = doc.path_of(id)?;
let (&k, parent) = path.split_last()?;
let Some((&g, grand)) = parent.split_last() else { return Some((doc.layers.as_slice(), k, None)) };
let outer = if grand.is_empty() { doc.layers.as_slice() } else { doc.layer_at(grand)?.children()? };
Some((outer.get(g)?.children()?, k, Some((outer, g))))
}
/// Report [`layers_damage`] as the active document's last change, so the canvas recomposites
/// only that (grown by the effect reach around it) instead of everything.
pub(crate) fn note_damage(s: &mut Session, before: &Document, ids: &[LayerId]) {
let Some(st) = s.active_mut() else { return };
if before.size != st.doc.size {
return;
}
st.last_damage = layers_damage(before, &st.doc, ids);
}
/// Whether two surfaces hold identical pixels: same format and default pixel, and the same
/// copy-on-write tile pointers at the same coordinates. Both documents stay alive during the
/// comparison, so tile addresses cannot be reused under it.
fn surfaces_equal(a: &photocraft_raster::Surface, b: &photocraft_raster::Surface) -> bool {
a.format() == b.format()
&& a.default_pixel() == b.default_pixel()
&& a.tile_count() == b.tile_count()
&& a.tiles().zip(b.tiles()).all(|((ca, ta), (cb, tb))| ca == cb && std::sync::Arc::ptr_eq(ta, tb))
}
/// Byte blobs kept in `Arc`s (PSD raw blocks, embedded smart-object sources): pointer-identical
/// or content-equal (they are small compared to pixels, and undo steps rarely re-parse them).
fn blob_equal(x: &std::sync::Arc<Vec<u8>>, y: &std::sync::Arc<Vec<u8>>) -> bool {
std::sync::Arc::ptr_eq(x, y) || (x.len() == y.len() && x.as_slice() == y.as_slice())
}
fn blobs_equal(a: &Option<std::sync::Arc<Vec<u8>>>, b: &Option<std::sync::Arc<Vec<u8>>>) -> bool {
match (a, b) {
(None, None) => true,
(Some(x), Some(y)) => blob_equal(x, y),
_ => false,
}
}
/// Layer masks (also the smart-filter mask): scalars plus tile-pointer surface identity.
fn masks_equal(a: &Option<photocraft_doc::LayerMask>, b: &Option<photocraft_doc::LayerMask>) -> bool {
match (a, b) {
(None, None) => true,
(Some(x), Some(y)) => {
x.enabled == y.enabled && x.linked == y.linked && x.density == y.density && x.feather == y.feather && surfaces_equal(&x.surface, &y.surface)
}
_ => false,
}
}
fn texts_equal(a: &photocraft_doc::TextLayer, b: &photocraft_doc::TextLayer) -> bool {
a.text == b.text
&& a.font_family == b.font_family
&& a.size_pt == b.size_pt
&& a.color == b.color
&& a.transform == b.transform
&& a.runs == b.runs
&& a.paragraphs == b.paragraphs
&& a.shape == b.shape
&& a.orientation == b.orientation
&& a.antialias == b.antialias
&& a.warp == b.warp
&& match (&a.cache, &b.cache) {
(None, None) => true,
(Some(x), Some(y)) => surfaces_equal(x, y),
_ => false,
}
&& blobs_equal(&a.psd_raw, &b.psd_raw)
}
fn smarts_equal(a: &photocraft_doc::SmartObject, b: &photocraft_doc::SmartObject) -> bool {
a.filters_enabled == b.filters_enabled
&& a.transform == b.transform
&& a.smart_filters == b.smart_filters
&& a.stack_mode == b.stack_mode
&& a.perspective == b.perspective
&& a.warp == b.warp
&& match (&a.source, &b.source) {
(photocraft_doc::SmartSource::Embedded { file_name: x, bytes: xb }, photocraft_doc::SmartSource::Embedded { file_name: y, bytes: yb }) => {
x == y && blob_equal(xb, yb)
}
(photocraft_doc::SmartSource::Linked { path: x }, photocraft_doc::SmartSource::Linked { path: y }) => x == y,
_ => false,
}
&& match (&a.cache, &b.cache) {
(None, None) => true,
(Some(x), Some(y)) => surfaces_equal(x, y),
_ => false,
}
&& blobs_equal(&a.psd_raw, &b.psd_raw)
&& masks_equal(&a.filter_mask, &b.filter_mask)
}
/// Extra alpha/spot channels (the image itself in Multichannel mode).
fn alpha_channels_equal(a: &photocraft_doc::AlphaChannel, b: &photocraft_doc::AlphaChannel) -> bool {
a.name == b.name && a.spot == b.spot && a.color == b.color && a.opacity == b.opacity && a.indicates == b.indicates && surfaces_equal(&a.surface, &b.surface)
}
/// Whether two layers render to identical pixels in place. Everything the compositor reads is
/// compared structurally — no hashing, a hash collision would under-report damage; pixels are
/// identified by their copy-on-write tile pointers. Group children are deliberately *not*
/// compared here: the caller walks into them, so an edit inside a group damages only the
/// edited child's extent, not the whole group's. The destructure is exhaustive, so a new
/// `Layer` field fails to compile until it is classified: compared, or explicitly ignored
/// (name, locks, label, `psd_blocks`, `psd_id`, link group, XMP — none of them composite; video
/// bails out earlier in the walk).
fn layer_pixels_equal(a: &Layer, b: &Layer) -> bool {
let Layer {
id,
name: _,
visible,
locks: _,
blend,
opacity,
fill_opacity,
clipped,
mask,
vector_mask,
effects,
label: _,
content,
psd_blocks: _,
psd_id: _,
fill_cache,
link_group: _,
excluded_channels,
blend_if,
advanced,
video: _,
xmp: _,
} = a;
*id == b.id
&& *visible == b.visible
&& *blend == b.blend
&& *opacity == b.opacity
&& *fill_opacity == b.fill_opacity
&& *clipped == b.clipped
&& masks_equal(mask, &b.mask)
&& *vector_mask == b.vector_mask
&& *effects == b.effects
&& *excluded_channels == b.excluded_channels
&& *blend_if == b.blend_if
&& *advanced == b.advanced
&& match (content, &b.content) {
(LayerContent::Raster(x), LayerContent::Raster(y)) => surfaces_equal(x, y),
// Children are walked separately; only the group's own clipping frame counts.
(LayerContent::Group(x), LayerContent::Group(y)) => x.artboard == y.artboard,
(LayerContent::Fill(x), LayerContent::Fill(y)) => x == y,
(LayerContent::Adjustment(x), LayerContent::Adjustment(y)) => x == y,
(LayerContent::Text(x), LayerContent::Text(y)) => texts_equal(x, y),
(LayerContent::Shape(x), LayerContent::Shape(y)) => x == y,
(LayerContent::Smart(x), LayerContent::Smart(y)) => smarts_equal(x, y),
_ => false,
}
&& match (fill_cache, &b.fill_cache) {
(None, None) => true,
(Some(x), Some(y)) => x.fill == y.fill && surfaces_equal(&x.surface, &y.surface),
_ => false,
}
}
/// Document-level fields the compositor reads: all must match for a bounded damage claim. The
/// destructure is exhaustive, so a new `Document` field fails to compile until it is classified
/// here — compared when it composites, or explicitly ignored (the pixel-irrelevant allowlist:
/// identity, name, selection, guides, paths, layer comps, annotations, automation state).
fn doc_pixels_equal(a: &Document, b: &Document) -> bool {
let Document {
id: _,
name: _,
size,
resolution_dpi,
mode,
depth,
icc_profile,
layers: _,
channels,
guides: _,
ruler_origin: _,
selection: _,
metadata: _,
global_light,
paths: _,
work_path: _,
clipping_path: _,
quick_mask,
quick_mask_unselected: _,
patterns,
color_table,
duotone,
layer_comps: _,
last_applied_comp: _,
last_document_state: _,
measurement: _,
notes: _,
text_styles: _,
slices: _,
variables: _,
timeline: _,
file_encoding: _,
} = a;
*size == b.size
&& resolution_dpi.to_bits() == b.resolution_dpi.to_bits()
&& *mode == b.mode
&& *depth == b.depth
&& icc_profile.as_deref() == b.icc_profile.as_deref()
&& channels.len() == b.channels.len()
&& channels.iter().zip(&b.channels).all(|(x, y)| alpha_channels_equal(x, y))
&& *global_light == b.global_light
&& match (quick_mask, &b.quick_mask) {
(None, None) => true,
(Some(x), Some(y)) => alpha_channels_equal(x, y),
_ => false,
}
&& *patterns == b.patterns
&& *color_table == b.color_table
&& *duotone == b.duotone
}
/// Whether `a` and `b` composite to the same pixels: they differ at most in fields the
/// compositor never reads (selection, guides, paths, names, …), by the same classification as
/// [`step_damage`] but without computing any bounds. Cheap: pixels compare by tile pointer.
/// Conservative (`false`) past a nesting depth no real document reaches.
pub fn same_pixels(a: &Document, b: &Document) -> bool {
pixels_equal_with(a, b, |_, _| false)
}
/// [`same_pixels`], with video layers equal when `video_equal` says their frame stacks are.
fn pixels_equal_with(a: &Document, b: &Document, video_equal: fn(&VideoData, &VideoData) -> bool) -> bool {
fn walk(xs: &[Layer], ys: &[Layer], depth: usize, video_equal: fn(&VideoData, &VideoData) -> bool) -> bool {
depth < 256
&& xs.len() == ys.len()
&& xs.iter().zip(ys).all(|(x, y)| {
layer_pixels_equal(x, y)
&& match (&x.video, &y.video) {
(None, None) => true,
(Some(vx), Some(vy)) => video_equal(vx, vy),
_ => false,
}
&& match (x.children(), y.children()) {
(Some(xc), Some(yc)) => walk(xc, yc, depth + 1, video_equal),
(None, None) => true,
_ => false,
}
})
}
doc_pixels_equal(a, b) && walk(&a.layers, &b.layers, 0, video_equal)
}
/// Whether two video layers hold the same frames: the same settings and stack shape
/// (`VideoData`'s own, shallow equality) and the same tile pointers in every frame, painted and
/// original. Pointer compares only, like [`surfaces_equal`].
fn video_frames_equal(a: &VideoData, b: &VideoData) -> bool {
let frames = |x: &[photocraft_raster::Surface], y: &[photocraft_raster::Surface]| x.len() == y.len() && x.iter().zip(y).all(|(f, g)| surfaces_equal(f, g));
*a == *b
&& frames(&a.frames, &b.frames)
&& match (&a.original_frames, &b.original_frames) {
(Some(x), Some(y)) => frames(x, y),
(None, None) => true,
_ => false,
}
}
/// Whether `a` and `b` differ at most in their selection (#6865): a selection step, which must
/// not mark a clean document modified. Pixels compare by tile pointer (as in [`same_pixels`],
/// plus every frame of a video layer, whose own equality is shallow); every other field compares
/// structurally, where copy-on-write `Arc`s of `Eq` data short-circuit on pointer identity. The
/// destructure is exhaustive, so a new `Document` field fails to compile until it is classified.
pub fn selection_only_change(a: &Document, b: &Document) -> bool {
let Document {
id,
name,
size: _,
resolution_dpi: _,
mode: _,
depth: _,
icc_profile: _,
layers,
channels: _,
guides,
ruler_origin,
selection: _,
metadata,
global_light: _,
paths,
work_path,
clipping_path,
quick_mask: _,
quick_mask_unselected,
patterns: _,
color_table: _,
duotone: _,
layer_comps,
last_applied_comp,
last_document_state,
measurement,
notes,
text_styles,
slices,
variables,
timeline,
file_encoding,
} = a;
// The ignored fields above are the pixel ones `pixels_equal_with` already compares.
pixels_equal_with(a, b, video_frames_equal)
&& *id == b.id
&& *name == b.name
&& *layers == b.layers
&& *guides == b.guides
&& *ruler_origin == b.ruler_origin
&& *metadata == b.metadata
&& *paths == b.paths
&& *work_path == b.work_path
&& *clipping_path == b.clipping_path
&& *quick_mask_unselected == b.quick_mask_unselected
&& *layer_comps == b.layer_comps
&& *last_applied_comp == b.last_applied_comp
&& *last_document_state == b.last_document_state
&& *measurement == b.measurement
&& *notes == b.notes
&& *text_styles == b.text_styles
&& *slices == b.slices
&& *variables == b.variables
&& *timeline == b.timeline
&& *file_encoding == b.file_encoding
}
/// Pixels a single history step can have changed between `a` and `b` (the documents on either
/// side of an edit, its undo or its redo): the union of the change bounds of every layer whose
/// pixels differ, so a local edit recomposites only that area instead of the whole canvas. A
/// layer only one side has (a duplicate, a paste, a deleted layer) counts where it draws (see
/// [`one_sided_bounds`]); one that draws nothing ([`inert_at`]) changes nothing. `None`
/// (composite everything) when the step touched anything the layer walk cannot bound:
/// document-level fields the compositor reads (canvas size, mode, depth, profile, global light,
/// patterns, channels, palettes), layer order and kind changes, layers added or removed that
/// reach outside their own bounds, layer properties that do (clipping, excluded channels —
/// what `layer.setProps` already reports as unbounded), and video layers. Inserting a copy of a
/// 12 MP layer used to recomposite every layer of the document (#2883, P8/P9 in
/// `perf/budgets.toml`).
pub fn step_damage(a: &Document, b: &Document) -> Option<Rect> {
if !doc_pixels_equal(a, b) {
return None;
}
/// The list holding a sibling list's parent group, and the group's index there.
type Outer<'d> = Option<(&'d [Layer], usize)>;
fn walk(xs: &[Layer], ys: &[Layer], (ox, oy): (Outer, Outer), a: &Document, b: &Document, out: &mut Rect) -> bool {
// Pair the layers by id, stepping over layers only one side has: one that draws nothing
// changes no pixels (a new empty layer or group, #1771), any other only where it draws.
let one_sided = |layers: &[Layer], k: usize, outer: Outer, canvas: Rect, out: &mut Rect| {
let Some(r) = one_sided_bounds(layers, k, outer, canvas) else { return false };
if !r.is_empty() {
*out = if out.is_empty() { r } else { out.union(&r) };
}
true
};
let (mut i, mut j) = (0, 0);
loop {
let (x, y) = match (xs.get(i), ys.get(j)) {
(None, None) => return true,
(Some(x), Some(y)) if x.id == y.id => (x, y),
_ if inert_at(ys, j) => {
j += 1;
continue;
}
_ if inert_at(xs, i) => {
i += 1;
continue;
}
(_, Some(y)) if xs.iter().all(|x| x.id != y.id) => {
if !one_sided(ys, j, oy, b.bounds(), out) {
return false;
}
j += 1;
continue;
}
(Some(x), _) if ys.iter().all(|y| y.id != x.id) => {
if !one_sided(xs, i, ox, a.bounds(), out) {
return false;
}
i += 1;
continue;
}
// Both sides have the layer, in another order.
_ => return false,
};
let (xk, yk) = (i, j);
i += 1;
j += 1;
if x.video.is_some() || y.video.is_some() {
return false;
}
// Clipping and channel exclusion change how *other* layers render, outside this
// layer's own bounds; they have no bounded damage.
if x.clipped != y.clipped || x.excluded_channels != y.excluded_channels {
return false;
}
if !layer_pixels_equal(x, y) {
// Both sides' extents: a move changes pixels where it left and where it landed.
// A clipped adjustment reaches as far as its base (#6535).
let (Some(bx), Some(by)) =
(photocraft_compose::change_bounds_in(xs, xk, ox, a.bounds()), photocraft_compose::change_bounds_in(ys, yk, oy, b.bounds()))
else {
return false;
};
*out = if out.is_empty() { bx.union(&by) } else { out.union(&bx).union(&by) };
}
match (x.children(), y.children()) {
(Some(xc), Some(yc)) => {
if !walk(xc, yc, (Some((xs, xk)), Some((ys, yk))), a, b, out) {
return false;
}
}
(None, None) => {}
_ => return false,
}
}
}
let mut out = Rect::EMPTY;
if walk(&a.layers, &b.layers, (None, None), a, b, &mut out) { Some(out) } else { None }
}
/// The pixels adding or removing `layers[k]` can change, when that is bounded: its change bounds
/// (`photocraft_compose::change_bounds_in`: not for an unclipped adjustment, or a pass-through
/// group holding one; a clipped adjustment's are its base's), provided it isn't the clipping base
/// of clipped layers above it (they would change base), and neither it nor anything inside it is
/// a video layer or excludes channels (both reach outside the layer's bounds, see
/// [`step_damage`]).
fn one_sided_bounds(layers: &[Layer], k: usize, outer: Option<(&[Layer], usize)>, canvas: Rect) -> Option<Rect> {
fn contained(l: &Layer, depth: usize) -> bool {
depth < 256 && l.video.is_none() && l.excluded_channels == 0 && l.children().is_none_or(|c| c.iter().all(|c| contained(c, depth + 1)))
}
let l = layers.get(k)?;
let new_base = !l.clipped && layers.get(k + 1).is_some_and(|above| above.clipped);
if new_base || !contained(l, 0) {
return None;
}
photocraft_compose::change_bounds_in(layers, k, outer, canvas)
}
/// Whether `layers[k]` draws nothing wherever it sits, so adding or removing it leaves the
/// composite as it was: an empty pixel layer (no tiles, transparent default) or an empty group,
/// in a Normal or Pass Through blend with no mask, vector mask, effects or Advanced Blending.
/// A clipping base that would gain or lose the clipped layers above it is not inert.
fn inert_at(layers: &[Layer], k: usize) -> bool {
let Some(l) = layers.get(k) else { return false };
let empty = match &l.content {
LayerContent::Raster(s) => s.tile_count() == 0 && s.format().alpha && s.default_bytes().iter().all(|b| *b == 0),
LayerContent::Group(g) => g.children.is_empty() && g.artboard.is_none(),
_ => false,
};
empty
&& matches!(l.blend, photocraft_doc::BlendMode::Normal | photocraft_doc::BlendMode::PassThrough)
&& l.mask.is_none()
&& l.vector_mask.is_none()
&& !photocraft_compose::effects::has_effects(l)
&& l.fill_cache.is_none()
&& l.video.is_none()
&& l.advanced == photocraft_doc::AdvancedBlending::default()
&& (l.clipped || layers.get(k + 1).is_none_or(|above| !above.clipped))
}
/// Report that adding layer `id` to the active document changed no pixels when it draws
/// nothing ([`inert_at`]), so the canvas doesn't recomposite every layer for it (#1771). Looks
/// only at the new layer and its neighbour, never at other layers' tiles.
pub(crate) fn note_inert_insert(s: &mut Session, id: LayerId) {
let Some(st) = s.active_mut() else { return };
let Some(path) = st.doc.path_of(id) else { return };
let Some((&k, parent)) = path.split_last() else { return };
let siblings = if parent.is_empty() { Some(st.doc.layers.as_slice()) } else { st.doc.layer_at(parent).and_then(Layer::children) };
if siblings.is_some_and(|sib| inert_at(sib, k)) {
st.last_damage = Some(Rect::EMPTY);
}
}
/// Report the pixels a command made of more than one edit changed since `before` ([`step_damage`]),
/// so the canvas recomposites only where its new layers draw instead of the whole document.
/// A single [`Session::edit`] already reports its own damage: don't call this after one (#5695).
pub(crate) fn note_insert(s: &mut Session, before: &Document) {
let Some(st) = s.active_mut() else { return };
st.last_damage = step_damage(before, &st.doc);
}
/// Content bounds used by Align/Distribute: the layer's pixels (type and shape layers use their
/// rendered pixels), or the union of a group's children. Fill and adjustment layers have none.
pub fn layer_bounds(l: &Layer) -> Option<Rect> {
let r = match &l.content {
LayerContent::Group(g) => g.children.iter().filter_map(layer_bounds).fold(Rect::EMPTY, |a, b| a.union(&b)),
_ => l.surface().map(|s| s.content_bounds()).unwrap_or(Rect::EMPTY),
};
(!r.is_empty()).then_some(r)
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Edge {
Top,
VCenter,
Bottom,
Left,
HCenter,
Right,
}
impl Edge {
fn parse(k: &str) -> Option<Edge> {
Some(match k {
"topEdges" => Edge::Top,
"verticalCenters" => Edge::VCenter,
"bottomEdges" => Edge::Bottom,
"leftEdges" => Edge::Left,
"horizontalCenters" => Edge::HCenter,
"rightEdges" => Edge::Right,
_ => return None,
})
}
fn vertical(self) -> bool {
matches!(self, Edge::Top | Edge::VCenter | Edge::Bottom)
}
/// The edge's coordinate, doubled so centres stay integral.
fn value2(self, r: &Rect) -> i64 {
let (a, b) = if self.vertical() { (r.y0, r.y1) } else { (r.x0, r.x1) };
match self {
Edge::Top | Edge::Left => 2 * a as i64,
Edge::Bottom | Edge::Right => 2 * b as i64,
Edge::VCenter | Edge::HCenter => a as i64 + b as i64,
}
}
fn delta(self, d: i32) -> (i32, i32) {
if self.vertical() { (0, d) } else { (d, 0) }
}
}
/// Selected top-level layers that have content bounds, bottom-to-top.
fn bounded_selection(doc: &Document, sel: &[LayerId]) -> Vec<(LayerId, Rect)> {
top_level(doc, sel).into_iter().filter_map(|id| Some((id, layer_bounds(doc.layer(id)?)?))).collect()
}
fn align(s: &mut Session, p: &Value, kind: &str) -> Result<Value> {
let cmd = format!("layer.align.{kind}");
let edge = Edge::parse(kind).ok_or_else(|| bad(&cmd, "unknown edge"))?;
let sel = selected(s);
let to = p.get("to").and_then(Value::as_str).unwrap_or("auto").to_string();
let before = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
let moved = s.edit("Align", |doc, _| {
let items = bounded_selection(doc, &sel);
if items.is_empty() {
return Err(EngineError::Other("the selected layers have no content to align".into()));
}
let target = match to.as_str() {
"canvas" => doc.bounds(),
"selection" => doc.selection.as_ref().map(|m| m.content_bounds()).ok_or_else(|| EngineError::Other("there is no selection to align to".into()))?,
"auto" | "layers" => match (&doc.selection, sel.len()) {
// Photoshop: with an active selection, the layers align to its bounds (Layer › Align
// Layers to Selection), however many are selected.
(Some(m), _) if to == "auto" && !m.content_bounds().is_empty() => m.content_bounds(),
// One layer with no selection aligns to the canvas (otherwise it would align to
// itself), or to the artboard it sits in, as in Photoshop (#7945).
(None, 1) if to == "auto" => items.first().map_or_else(|| doc.bounds(), |(id, _)| board_or_canvas(doc, *id)),
_ => items.iter().fold(Rect::EMPTY, |a, (_, b)| a.union(b)),
},
other => return Err(bad(&cmd, format!("`to` must be auto|layers|selection|canvas, not `{other}`"))),
};
if target.is_empty() {
return Err(EngineError::Other("nothing to align to".into()));
}
let t2 = edge.value2(&target);
let moves: Vec<(LayerId, i32, i32)> = items
.iter()
.flat_map(|(id, r)| {
let d = (t2 - edge.value2(r)).div_euclid(2) as i32;
let (dx, dy) = edge.delta(d);
// Linked layers travel with the layer they are linked to.
with_links(doc, &[*id]).into_iter().map(move |l| (l, dx, dy))
})
.collect();
let moves = dedup_moves(doc, moves);
move_layers(doc, &before, &moves)?;
Ok(moves.iter().filter(|m| m.1 != 0 || m.2 != 0).count())
})?;
Ok(json!({"moved": moved}))
}
/// The bounds a lone layer aligns to: the artboard holding it, else the canvas. An artboard
/// itself aligns to the canvas.
fn board_or_canvas(doc: &Document, id: LayerId) -> Rect {
doc.artboard_of(id).filter(|board| *board != id).and_then(|board| doc.layer(board)?.artboard().map(|a| a.rect)).unwrap_or_else(|| doc.bounds())
}
/// One move per layer (first wins), skipping layers nested in another moved layer.
fn dedup_moves(doc: &Document, moves: Vec<(LayerId, i32, i32)>) -> Vec<(LayerId, i32, i32)> {
let mut out: Vec<(LayerId, i32, i32)> = Vec::new();
for m in moves {
if !out.iter().any(|o| o.0 == m.0) {
out.push(m);
}
}
let ids: Vec<LayerId> = out.iter().map(|m| m.0).collect();
let keep = top_level(doc, &ids);
out.retain(|m| keep.contains(&m.0));
out
}
fn distribute(s: &mut Session, kind: &str) -> Result<Value> {
let sel = selected(s);
let kind = kind.to_string();
let before = s.active().ok_or(EngineError::NoDocument)?.doc.clone();
let moved = s.edit("Distribute", |doc, _| {
let mut items = bounded_selection(doc, &sel);
if items.len() < 3 {
return Err(EngineError::Other("distributing needs three or more layers with content".into()));
}
let n = items.len();
let mut moves = Vec::new();
match kind.as_str() {
"horizontally" | "vertically" => {
// Equal gaps between neighbours; the outermost layers stay put.
let v = kind == "vertically";
let lo = |r: &Rect| if v { r.y0 } else { r.x0 } as i64;
let hi = |r: &Rect| if v { r.y1 } else { r.x1 } as i64;
items.sort_by_key(|(_, r)| (lo(r) + hi(r), lo(r)));
let span = hi(&items[n - 1].1) - lo(&items[0].1);
let total: i64 = items.iter().map(|(_, r)| hi(r) - lo(r)).sum();
let gap = (span - total) as f64 / (n - 1) as f64;
let mut cursor = lo(&items[0].1) as f64;
for (id, r) in &items {
let want = cursor.round() as i64;
let d = (want - lo(r)) as i32;
moves.push(if v { (*id, 0, d) } else { (*id, d, 0) });
cursor += (hi(r) - lo(r)) as f64 + gap;
}
}
k => {
let edge = Edge::parse(k).ok_or_else(|| bad("layer.distribute", format!("unknown kind `{k}`")))?;
items.sort_by_key(|(_, r)| edge.value2(r));
let (first, last) = (edge.value2(&items[0].1) as f64, edge.value2(&items[n - 1].1) as f64);
for (i, (id, r)) in items.iter().enumerate() {
let want2 = first + (last - first) * i as f64 / (n - 1) as f64;
let d = ((want2 - edge.value2(r) as f64) / 2.0).round() as i32;
let (dx, dy) = edge.delta(d);
moves.push((*id, dx, dy));
}
}
}
let moves: Vec<_> = moves.into_iter().flat_map(|(id, dx, dy)| with_links(doc, &[id]).into_iter().map(move |l| (l, dx, dy))).collect();
let moves = dedup_moves(doc, moves);
move_layers(doc, &before, &moves)?;
Ok(moves.iter().filter(|m| m.1 != 0 || m.2 != 0).count())
})?;
Ok(json!({"moved": moved}))
}
/// Reorder one or multiple layers to a single destination in one undoable edit.
///
/// Explicit `layers` are ordered according to the source document, not caller ordering.
/// A transient snapshot for the Layers panel's "Preview on canvas when reordering layers".
/// Uses the same source ordering and insertion semantics as `move_to`, but never edits history.
/// Invalid/self-referential hover targets return None (the committed image stays visible).
pub fn preview_move(doc: &Document, p: &Value, add_copy: bool) -> Option<Document> {
let target = LayerId(p.get("target")?.as_u64()?);
let position = p.get("position")?.as_str()?;
if !matches!(position, "above" | "below" | "into") {
return None;
}
let copy = p.get("copy").and_then(Value::as_bool).unwrap_or(false);
let ids = if let Some(ids) = p.get("layers") {
ids.as_array()?.iter().map(|v| v.as_u64().map(LayerId)).collect::<Option<Vec<_>>>()?
} else {
vec![LayerId(p.get("layer")?.as_u64()?)]
};
if ids.is_empty() || doc.layer(target).is_none() {
return None;
}
let moved_ids = top_level(doc, &ids);
if moved_ids.is_empty() || moved_ids.iter().any(|id| doc.layer(*id).is_none()) {
return None;
}
if moved_ids.len() == 1 && moved_ids[0] == target && !copy {
return None;
}
let target_path = doc.path_of(target)?;
for id in &moved_ids {
let path = doc.path_of(*id)?;
if target_path.starts_with(&path) && !(copy && *id == target && position != "into") {
return None;
}
}
if position == "into" && !doc.layer(target)?.is_group() {
return None;
}
// The very structural move the drop commits, so the preview shows the same clip groups,
// Background handling and group-depth refusals; a drop `move_to` would refuse has no preview.
let mut preview = doc.clone();
apply_move(&mut preview, &moved_ids, target, position, copy, add_copy).ok()?;
Some(preview)
}
/// The document-only part of `move_to`, shared with [`preview_move`] so the Layers panel's hover
/// preview cannot drift from what the drop commits. Moves (or, with `copy`, duplicates) the
/// top-level `moved_ids` to `pos` (`above`, `below` or `into`) `target`, then applies the
/// group-depth cap, the Background-stays-at-the-bottom rule and the clip-group rules
/// (`clip_group::settle`). Returns the ids of the new copies (empty for a move). On `Err` `doc` is
/// half edited: run it inside `Session::edit` or on a scratch copy.
fn apply_move(doc: &mut Document, moved_ids: &[LayerId], target: LayerId, pos: &str, copy: bool, add_copy: bool) -> Result<Vec<LayerId>> {
const CMD: &str = "layer.moveTo";
let background = crate::background_cmds::background_id(doc);
let before = if copy { Default::default() } else { crate::clip_group::Before::read(doc, moved_ids) };
let mut moved = Vec::with_capacity(moved_ids.len());
for &id in moved_ids {
moved.push(if copy { crate::commands::layer_copy(doc, id, add_copy)? } else { doc.remove(id).ok_or(EngineError::NoLayer(id))? });
}
let copies: Vec<LayerId> = if copy { moved.iter().map(|l| l.id).collect() } else { Vec::new() };
// Look up the destination AFTER removing every source: its indices may have shifted.
let path = doc.path_of(target).ok_or(EngineError::NoLayer(target))?;
if pos == "into" {
let children = doc.layer_at_mut(&path).and_then(Layer::children_mut).ok_or_else(|| bad(CMD, "target is not a group"))?;
children.extend(moved);
} else {
let (&idx, parent) = path.split_last().ok_or(EngineError::NoLayer(target))?;
let siblings = if parent.is_empty() {
&mut doc.layers
} else {
doc.layer_at_mut(parent).and_then(Layer::children_mut).ok_or_else(|| bad(CMD, "target's parent is not a group"))?
};
let at = if pos == "below" { idx } else { idx + 1 };
siblings.splice(at..at, moved);
}
check_group_depth(doc, "Reorder Layer")?;
crate::background_cmds::keep_background_at_bottom(background, doc)?;
crate::clip_group::settle(doc, if copy { &copies } else { moved_ids }, &before, false);
Ok(copies)
}
/// Selected descendants of a moved group remain inside their parent; only top-level
/// selected nodes are detached, and every reference is validated before editing.
pub fn move_to(s: &mut Session, p: &Value) -> Result<Value> {
const CMD: &str = "layer.moveTo";
let pos = p.get("position").and_then(Value::as_str).unwrap_or("above");
if !matches!(pos, "above" | "below" | "into") {
return Err(bad(CMD, "position must be above, below, or into"));
}
// ⌥-drag in the Layers panel: duplicates land at the target and the layers stay put.
let copy = p.get("copy").and_then(Value::as_bool).unwrap_or(false);
let batch = p.get("layers");
if batch.is_some() && p.get("layer").is_some() {
return Err(bad(CMD, "give either `layer` or `layers`, not both"));
}
let requested = if let Some(raw) = batch {
let arr = raw.as_array().filter(|a| !a.is_empty()).ok_or_else(|| bad(CMD, "`layers` must be a nonempty array of ids"))?;
let mut ids = Vec::with_capacity(arr.len());
for item in arr {
let id = LayerId(item.as_u64().ok_or_else(|| bad(CMD, "every layer id must be an unsigned integer"))?);
if ids.contains(&id) {
return Err(bad(CMD, "duplicate layer id"));
}
ids.push(id);
}
ids
} else {
vec![crate::commands::layer_param(s, p)?]
};
// A copy moves nothing, so its source stays a candidate (⌥-dragging a layer beside itself).
let target = move_target(s, p, if copy { &[] } else { &requested })?;
let st = s.active().ok_or(EngineError::NoDocument)?;
let doc = &st.doc;
let target_path = doc.path_of(target).ok_or(EngineError::NoLayer(target))?;
for &id in &requested {
if doc.layer(id).is_none() {
return Err(EngineError::NoLayer(id));
}
}
let moved_ids = top_level(doc, &requested);
if moved_ids.len() == 1 && moved_ids[0] == target && batch.is_none() && !copy {
// Preserve single-layer drag-to-self semantics.
return Ok(Value::Null);
}
// Also rejects dragging a selected group onto any of its descendants.
for id in &moved_ids {
let path = doc.path_of(*id).ok_or(EngineError::NoLayer(*id))?;
// A copy may land beside its own source (not inside it).
let beside_itself = copy && *id == target && pos != "into";
if target_path.starts_with(&path) && !beside_itself {
return Err(bad(CMD, "target cannot be one of the moved layers or its descendant"));
}
}
if pos == "into" && doc.layer(target).is_none_or(|l| !l.is_group()) {
return Err(bad(CMD, "target is not a group"));
}
let original_active = st.active_layer;
let add_copy = crate::commands::layer_panel_option(s, "addCopyToCopiedLayersAndGroups", true);
let (count, copies) = s.edit(if copy { "Duplicate Layer" } else { "Reorder Layers" }, |doc, active| {
let copies = apply_move(doc, &moved_ids, target, pos, copy, add_copy)?;
*active = if copy {
copies.last().copied()
} else if batch.is_some() {
original_active.filter(|id| requested.contains(id)).or_else(|| requested.last().copied())
} else {
moved_ids.first().copied()
};
Ok((moved_ids.len(), copies))
})?;
if copy {
let ids: Vec<u64> = copies.iter().map(|id| id.0).collect();
if batch.is_some() {
let active = copies.last().copied();
reselect(s, copies, active);
return Ok(json!({"moved": count, "layers": ids}));
}
return Ok(json!({"layer": ids.first()}));
}
if batch.is_some() {
let active = original_active.filter(|id| requested.contains(id)).or_else(|| requested.last().copied());
reselect(s, requested, active);
Ok(json!({"moved": count}))
} else {
Ok(Value::Null)
}
}
// ---------- structural commands ----------
fn link_layers(s: &mut Session) -> Result<Value> {
let sel = selected(s);
let linked = s.edit("Link Layers", |doc, _| {
let groups: Vec<Option<u64>> = sel.iter().map(|id| doc.layer(*id).and_then(|l| l.link_group)).collect();
// Already one link group (or a single linked layer): unlink, like Photoshop's toggle.
let first = groups.first().copied().flatten();
let unlink = first.is_some() && groups.iter().all(|g| *g == first);
// A loaded file can store any id up to u64::MAX, so the new id must not be a bare
// max + 1 (#961). Unlinking needs no new id at all.
let next = if unlink { None } else { Some(doc.unused_link_group().ok_or_else(|| bad("layer.linkLayers", "no free link group id is left"))?) };
for id in &sel {
let l = doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?;
l.link_group = next;
}
// A group left with a single member is no longer a link.
let mut counts = std::collections::HashMap::<u64, usize>::new();
for (_, _, l) in doc.walk() {
if let Some(g) = l.link_group {
*counts.entry(g).or_default() += 1;
}
}
let lonely: Vec<LayerId> =
doc.walk().iter().filter(|(_, _, l)| l.link_group.is_some_and(|g| counts.get(&g).is_some_and(|&c| c < 2))).map(|(_, _, l)| l.id).collect();
for id in lonely {
if let Some(l) = doc.layer_mut(id) {
l.link_group = None;
}
}
Ok(!unlink)
})?;
Ok(json!({"linked": linked}))
}
fn lock_layers(s: &mut Session, p: &Value) -> Result<Value> {
let sel = selected(s);
let keys = ["transparency", "pixels", "position", "artboard", "all"];
let given: Vec<(&str, bool)> = keys.iter().filter_map(|k| Some((*k, p.get(*k)?.as_bool()?))).collect();
s.edit("Lock Layers", |doc, _| {
// No explicit locks: toggle "lock all" (on unless every selected layer is already locked).
let all_locked = sel.iter().all(|id| doc.layer(*id).is_some_and(|l| l.locks.all));
let given: Vec<(&str, bool)> = if given.is_empty() { vec![("all", !all_locked)] } else { given.clone() };
for id in &sel {
let l = doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?;
for (k, v) in &given {
l.locks.set(k, *v);
}
}
Ok(())
})?;
Ok(json!({"layers": sel.len()}))
}
fn rename_layer(s: &mut Session, p: &Value) -> Result<Value> {
let name = p.get("name").and_then(Value::as_str).filter(|n| !n.trim().is_empty()).ok_or_else(|| bad("layer.renameLayer", "missing `name`"))?.to_string();
let id = crate::commands::layer_param(s, p)?;
s.edit("Rename Layer", |doc, _| {
doc.layer_mut(id).ok_or(EngineError::NoLayer(id))?.name = name;
Ok(())
})?;
Ok(Value::Null)
}
fn reverse(s: &mut Session) -> Result<Value> {
let sel = selected(s);
s.edit("Reverse", |doc, _| {
let background = crate::background_cmds::background_id(doc);
let ids = top_level(doc, &sel);
if ids.len() < 2 {
return Err(EngineError::Other("select two or more layers to reverse".into()));
}
let paths: Vec<Vec<usize>> = ids.iter().map(|id| doc.path_of(*id).ok_or(EngineError::NoLayer(*id))).collect::<Result<_>>()?;
let layers: Vec<Layer> = ids.iter().map(|id| doc.layer(*id).cloned().ok_or(EngineError::NoLayer(*id))).collect::<Result<_>>()?;
// Slots are disjoint (no layer is nested in another), so writing whole layers back to the
// same paths never shifts another slot.
for (path, l) in paths.iter().zip(layers.into_iter().rev()) {
*doc.layer_at_mut(path).ok_or_else(|| EngineError::Other("layer tree changed".into()))? = l;
}
crate::background_cmds::keep_background_at_bottom(background, doc)
})?;
Ok(Value::Null)
}
/// Refuses an edit that left `doc` nested deeper than [`photocraft_doc::MAX_GROUP_DEPTH`]
/// groups. Called at the end of a `Session::edit` closure, so an `Err` leaves the document and
/// history untouched.
pub(crate) fn check_group_depth(doc: &Document, what: &str) -> Result<()> {
if doc.max_group_depth() > photocraft_doc::MAX_GROUP_DEPTH {
return Err(EngineError::Other(format!("{what} would nest layers deeper than {} groups", photocraft_doc::MAX_GROUP_DEPTH)));
}
Ok(())
}
/// Group Layers (⌘G) / Group from Layers: the explicit layer, or every selected layer, moves
/// into a new, collapsed group placed where the top-most of them was. Bottom-to-top order is
/// preserved.
pub fn group_layers(s: &mut Session, p: &Value) -> Result<Value> {
let ids = match crate::commands::explicit_layer(s, p)? {
Some(id) => vec![id],
None => selected(s),
};
if ids.is_empty() {
return Err(EngineError::Other("no layer selected".into()));
}
let name = p.get("name").and_then(Value::as_str).map(str::to_string);
let gid = s.edit("Group Layers", |doc, active| {
let ids = top_level(doc, &ids);
let top = *ids.last().ok_or(EngineError::NoLayer(LayerId(0)))?;
let name = name.unwrap_or_else(|| doc.next_layer_name("Group"));
// Photoshop creates the group collapsed, so the panel shows one row in place of the layers.
let mut group = Layer::group(name, vec![]);
if let LayerContent::Group(g) = &mut group.content {
g.expanded = false;
}
let gid = doc.insert_above(Some(top), group);
let mut children = Vec::with_capacity(ids.len());
for id in &ids {
children.push(doc.remove(*id).ok_or(EngineError::NoLayer(*id))?);
}
*doc.layer_mut(gid).and_then(Layer::children_mut).ok_or(EngineError::NoLayer(gid))? = children;
check_group_depth(doc, "Group Layers")?;
*active = Some(gid);
Ok(gid)
})?;
reselect(s, vec![gid], Some(gid));
Ok(json!({ "layer": gid.0 }))
}
fn merge_layers(s: &mut Session) -> Result<Value> {
let sel = selected(s);
if sel.len() < 2 {
// ⌘E on a lone group is Photoshop's Merge Group (#3832); on a layer, Merge Down.
if let Some(&id) = sel.first()
&& s.active().and_then(|d| d.doc.layer(id)).is_some_and(|l| matches!(l.content, LayerContent::Group(_)))
{
return s.execute("layer.mergeGroup", json!({ "layer": id.0 }));
}
return s.execute("layer.mergeDown", json!({}));
}
let mid = s.edit("Merge Layers", |doc, active| {
let ids = top_level(doc, &sel);
let lowest_id = *ids.first().ok_or_else(|| EngineError::Other("Merge Layers needs two or more layers".into()))?;
let is_background = doc.is_background(lowest_id);
let mut solo = doc.clone();
solo.layers = ids.iter().filter_map(|id| doc.layer(*id)).filter(|l| l.visible).cloned().collect();
if solo.layers.is_empty() {
return Err(EngineError::Other("the selected layers are all hidden".into()));
}
if is_background {
let base = doc.layer(lowest_id).ok_or(EngineError::NoLayer(lowest_id))?.clone();
let fmt = doc.pixel_format();
let mut merged = Layer::raster(base.name.clone(), fmt);
merged.locks = base.locks;
merged.label = base.label;
merged.id = lowest_id;
merged.blend = base.blend;
merged.opacity = 1.0;
*crate::pixels_mut(&mut merged)? = crate::pixels::composite_layers(&solo, fmt, None);
for id in &ids[1..] {
doc.remove(*id);
}
*doc.layer_mut(lowest_id).ok_or(EngineError::NoLayer(lowest_id))? = merged;
*active = Some(lowest_id);
Ok(lowest_id)
} else {
let top_id = *ids.last().ok_or_else(|| EngineError::Other("Merge Layers needs two or more layers".into()))?;
let top = doc.layer(top_id).ok_or(EngineError::NoLayer(top_id))?.clone();
let fmt = doc.pixel_format();
let fmt = PixelFormat::new(fmt.mode, fmt.sample, true);
let mut merged = Layer::raster(top.name.clone(), fmt);
merged.locks = top.locks;
merged.label = top.label;
// Clipped layers of one chain merge into a layer still clipped to their base. Clipped
// layers of different chains don't: the result, at the top one's slot, would clip the
// lower chain's pixels to the upper chain's base.
let base = crate::clip_group::base_of(doc, top_id);
merged.clipped = base.is_some() && solo.layers.iter().all(|l| l.clipped && crate::clip_group::base_of(doc, l.id) == base);
*crate::pixels_mut(&mut merged)? = crate::pixels::composite_layers_uncropped(&solo, fmt);
let mid = merged.id;
// Hidden selected layers are discarded, as in Photoshop.
for id in &ids[..ids.len() - 1] {
doc.remove(*id);
}
*doc.layer_mut(top_id).ok_or(EngineError::NoLayer(top_id))? = merged;
*active = Some(mid);
Ok(mid)
}
})?;
reselect(s, vec![mid], Some(mid));
Ok(json!({ "layer": mid.0 }))
}
/// Next visible layer row below the deleted target, then rows above in reverse order.
/// Group headers precede their children in the UI, unlike Document::walk's storage order.
pub(crate) fn deletion_neighbours(doc: &Document, target: LayerId) -> Vec<LayerId> {
let rows = |expand_all: bool| {
let mut stack: Vec<&Layer> = doc.layers.iter().collect();
let mut order = Vec::new();
while let Some(layer) = stack.pop() {
order.push(layer.id);
if let LayerContent::Group(group) = &layer.content
&& (expand_all || group.expanded)
{
stack.extend(group.children.iter());
}
}
order
};
let mut order = rows(false);
if !order.contains(&target) {
order = rows(true);
}
let Some(index) = order.iter().position(|id| *id == target) else {
return Vec::new();
};
order.iter().skip(index + 1).chain(order.iter().take(index).rev()).copied().collect()
}
/// Delete Layer with several layers selected.
pub fn delete_selected(s: &mut Session) -> Result<Value> {
let sel = selected(s);
s.edit("Delete Layers", |doc, active| {
let ids = top_level(doc, &sel);
let neighbours = active.map(|id| deletion_neighbours(doc, id)).unwrap_or_default();
let before = crate::clip_group::Before::read(doc, &ids);
for id in &ids {
doc.remove(*id).ok_or(EngineError::NoLayer(*id))?;
}
crate::clip_group::settle(doc, &[], &before, false);
if doc.layers.is_empty() {
return Err(EngineError::Other("a document must keep at least one layer".into()));
}
*active = neighbours.into_iter().find(|candidate| doc.layer(*candidate).is_some());
Ok(())
})?;
Ok(json!({"deleted": sel.len()}))
}
/// Duplicate Layer with several layers selected: each copy goes above its original and the
/// copies become the selection. Artboard copies go beside their boards unless `in_place`
/// ([`crate::artboard_cmds::place_copy`]). `label` names the history step (Layer via Copy reuses
/// this path, #2777).
pub fn duplicate_selected(s: &mut Session, in_place: bool, label: &str) -> Result<Value> {
let sel = selected(s);
let old_active = s.active().and_then(|d| d.active_layer);
let add_copy = crate::commands::layer_panel_option(s, "addCopyToCopiedLayersAndGroups", true);
let (copies, active) = s.edit(label, |doc, active| {
let mut copies = Vec::new();
let mut new_active = None;
for id in top_level(doc, &sel) {
// Match the single-layer duplicate path: Background copies become
// ordinary layers, while normal copies retain their original locks.
let dup = crate::commands::layer_copy(doc, id, add_copy)?;
let nid = doc.insert_above(Some(id), dup);
if !in_place {
crate::artboard_cmds::place_copy(doc, nid)?;
}
if Some(id) == old_active {
new_active = Some(nid);
}
copies.push(nid);
}
let a = new_active.or(copies.last().copied());
*active = a;
Ok((copies, a))
})?;
let out = copies.iter().map(|l| l.0).collect::<Vec<_>>();
reselect(s, copies, active);
Ok(json!({"layers": out, "layer": active.map(|l| l.0)}))
}
/// Show/hide every selected layer in one step.
pub fn set_visible_selected(s: &mut Session, visible: bool) -> Result<Value> {
let sel = selected(s);
s.edit(if visible { "Show Layers" } else { "Hide Layers" }, |doc, _| {
for id in &sel {
doc.layer_mut(*id).ok_or(EngineError::NoLayer(*id))?.visible = visible;
}
Ok(())
})?;
Ok(Value::Null)
}
/// Is more than one layer selected (so single-layer commands should act on the whole set)?
pub fn multi(s: &Session, p: &Value) -> bool {
p.get("layer").is_none() && selected(s).len() > 1
}
// ---------- registry ----------
pub fn specs() -> Vec<CommandSpec> {
macro_rules! spec {
($id:expr, $label:expr, $menu:expr, $sc:expr, $params:expr, $enabled:expr, $run:expr) => {
CommandSpec { id: $id, label: $label, menu: $menu, shortcut: $sc, params: $params, enabled: $enabled, journal: true, run: $run }
};
}
const ALIGN: &str = r##"{"to":"auto|layers|selection|canvas"="auto"} (auto: the active selection's bounds when there is one, however many layers are selected; else one layer aligns to the canvas and several to their combined bounds)"##;
vec![
spec!("select.allLayers", "All Layers", &["Select"], Some("Cmd+Alt+A"), "{}", has_doc, |s, _| select_all_layers(s)),
spec!("select.deselectLayers", "Deselect Layers", &["Select"], None, "{}", has_doc, |s, _| {
set_selection(s, Vec::new(), None, None)?;
if let Some(st) = s.active_mut() {
st.active_layer = None;
st.selected_layers.clear();
}
Ok(Value::Null)
}),
spec!("select.findLayers", "Find Layers", &["Select"], Some("Cmd+Alt+Shift+F"), r##"{"name":str (case-insensitive substring)}"##, has_doc, find_layers),
spec!("layer.selectLinkedLayers", "Select Linked Layers", &["Layer"], None, "{}", has_linked, |s, _| select_linked(s)),
spec!("layer.align.topEdges", "Top Edges", &["Layer", "Align"], None, ALIGN, can_align, |s, p| align(s, p, "topEdges")),
spec!("layer.align.verticalCenters", "Vertical Centers", &["Layer", "Align"], None, ALIGN, can_align, |s, p| align(s, p, "verticalCenters")),
spec!("layer.align.bottomEdges", "Bottom Edges", &["Layer", "Align"], None, ALIGN, can_align, |s, p| align(s, p, "bottomEdges")),
spec!("layer.align.leftEdges", "Left Edges", &["Layer", "Align"], None, ALIGN, can_align, |s, p| align(s, p, "leftEdges")),
spec!("layer.align.horizontalCenters", "Horizontal Centers", &["Layer", "Align"], None, ALIGN, can_align, |s, p| align(s, p, "horizontalCenters")),
spec!("layer.align.rightEdges", "Right Edges", &["Layer", "Align"], None, ALIGN, can_align, |s, p| align(s, p, "rightEdges")),
spec!("layer.distribute.topEdges", "Top Edges", &["Layer", "Distribute"], None, "{}", can_distribute, |s, _| distribute(s, "topEdges")),
spec!("layer.distribute.verticalCenters", "Vertical Centers", &["Layer", "Distribute"], None, "{}", can_distribute, |s, _| distribute(
s,
"verticalCenters"
)),
spec!("layer.distribute.bottomEdges", "Bottom Edges", &["Layer", "Distribute"], None, "{}", can_distribute, |s, _| distribute(s, "bottomEdges")),
spec!("layer.distribute.leftEdges", "Left Edges", &["Layer", "Distribute"], None, "{}", can_distribute, |s, _| distribute(s, "leftEdges")),
spec!("layer.distribute.horizontalCenters", "Horizontal Centers", &["Layer", "Distribute"], None, "{}", can_distribute, |s, _| distribute(
s,
"horizontalCenters"
)),
spec!("layer.distribute.rightEdges", "Right Edges", &["Layer", "Distribute"], None, "{}", can_distribute, |s, _| distribute(s, "rightEdges")),
spec!(
"layer.distribute.horizontally",
"Horizontally",
&["Layer", "Distribute"],
None,
"{} (equal horizontal gaps)",
can_distribute,
|s, _| distribute(s, "horizontally")
),
spec!("layer.distribute.vertically", "Vertically", &["Layer", "Distribute"], None, "{} (equal vertical gaps)", can_distribute, |s, _| distribute(
s,
"vertically"
)),
spec!("layer.linkLayers", "Link Layers", &["Layer"], None, "{} (toggles: unlinks when the selection is already one link group)", can_link, |s, _| {
link_layers(s)
}),
spec!("layer.mergeLayers", "Merge Layers", &["Layer"], Some("Cmd+E"), "{} (one layer selected: Merge Down)", has_layer, |s, _| merge_layers(s)),
spec!(
"layer.new.groupFromLayers",
"Group from Layers…",
&["Layer", "New"],
None,
r##"{"layer":id?,"name":str?} (no layer: every selected layer)"##,
has_layer,
group_layers
),
spec!("layer.arrange.reverse", "Reverse", &["Layer", "Arrange"], None, "{}", two_plus, |s, _| reverse(s)),
spec!(
"layer.lockLayers",
"Lock Layers…",
&["Layer"],
None,
r##"{"transparency":bool?,"pixels":bool?,"position":bool?,"artboard":bool?,"all":bool?} (none given: toggle lock all)"##,
has_layer,
lock_layers
),
spec!("layer.renameLayer", "Rename Layer", &["Layer"], None, r##"{"layer":id?,"name":str}"##, has_layer, rename_layer),
]
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn merge_with_background_preserves_background() {
let mut s = Session::new();
s.execute("file.new", json!({"width": 20, "height": 20})).unwrap();
let bg_id = s.active().unwrap().doc.layers[0].id;
assert!(s.active().unwrap().doc.is_background(bg_id));
let l1 = LayerId(s.execute("layer.new.layer", json!({"name": "Generative Fill"})).unwrap()["layer"].as_u64().unwrap());
set_selection(&mut s, vec![bg_id, l1], Some(l1), Some(bg_id)).unwrap();
let res = s.execute("layer.mergeLayers", json!({})).unwrap();
let mid = LayerId(res["layer"].as_u64().unwrap());
assert_eq!(mid, bg_id);
let doc = &s.active().unwrap().doc;
assert_eq!(doc.layers.len(), 1);
assert!(doc.is_background(mid));
assert_eq!(doc.layers[0].name, "Background");
}
#[test]
fn duplicates_are_numbered_not_stacked() {
let mut s = Session::new();
s.execute("file.new", json!({"width": 20, "height": 20})).unwrap();
s.execute("layer.new.layer", json!({"name": "Layer 1"})).unwrap();
let name = |s: &Session| {
let st = s.active().unwrap();
st.doc.layer(st.active_layer.unwrap()).unwrap().name.clone()
};
s.execute("layer.duplicate", json!({})).unwrap();
assert_eq!(name(&s), "Layer 1 copy");
// Duplicating the copy (the active layer) numbers it rather than adding "copy" again.
s.execute("layer.duplicate", json!({})).unwrap();
assert_eq!(name(&s), "Layer 1 copy 2");
s.execute("layer.duplicate", json!({})).unwrap();
assert_eq!(name(&s), "Layer 1 copy 3");
let doc = &s.active().unwrap().doc;
assert_eq!(doc.copy_name("Layer 1"), "Layer 1 copy 4");
// Names that merely contain "copy" keep it.
assert_eq!(doc.copy_name("Copywriting"), "Copywriting copy");
assert_eq!(doc.copy_name("A copyedit"), "A copyedit copy");
}
fn session(depth: u32) -> Session {
let mut s = Session::new();
s.execute("file.new", json!({"width": 100, "height": 80, "depth": depth})).unwrap();
s
}
fn doc(s: &Session) -> &Document {
&s.active().unwrap().doc
}
/// New pixel layer with an opaque red rectangle.
fn rect_layer(s: &mut Session, r: Rect) -> LayerId {
let id = LayerId(s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap());
s.edit("paint", |doc, _| {
doc.layer_mut(id).unwrap().surface_mut().unwrap().fill_rect(r, &[1.0, 0.0, 0.0, 1.0]);
Ok(())
})
.unwrap();
id
}
fn bounds(s: &Session, id: LayerId) -> Rect {
layer_bounds(doc(s).layer(id).unwrap()).unwrap()
}
fn sel(s: &Session) -> Vec<LayerId> {
selected(s)
}
fn damage(s: &Session) -> Option<Rect> {
s.active().unwrap().last_damage
}
/// A Photoshop action's nudge in points moves whole pixels at the document's resolution:
/// 0.36 pt is 1 px at 200 ppi and 1.5 → 2 px at 300 ppi.
#[test]
fn translate_in_points_follows_the_resolution() {
for (res, moved) in [(200, 1), (300, 2), (72, 0)] {
let mut s = Session::new();
s.execute("file.new", json!({"width": 100, "height": 80, "resolution": res})).unwrap();
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
s.execute("layer.translate", json!({"dx": 0.36, "dy": -0.36, "units": "pt"})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(10 + moved, 10 - moved, 20 + moved, 20 - moved), "{res} ppi");
}
let mut s = session(8);
rect_layer(&mut s, Rect::new(10, 10, 20, 20));
for bad in [json!({"dx": 1, "units": "in"}), json!({"dx": "x", "units": "pt"}), json!({"dx": 1e300, "units": "pt"})] {
assert!(s.execute("layer.translate", bad.clone()).is_err(), "{bad}");
}
}
/// `remove` deselects a selected layer, leaves an unselected one alone and never empties the
/// selection.
#[test]
fn select_remove_takes_a_layer_out_of_the_selection() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
let b = rect_layer(&mut s, Rect::new(30, 10, 40, 20));
let c = rect_layer(&mut s, Rect::new(50, 10, 60, 20));
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.select", json!({"layer": b.0, "mode": "add"})).unwrap();
s.execute("layer.select", json!({"layer": c.0, "mode": "remove"})).unwrap();
assert_eq!(sel(&s).len(), 2, "an unselected layer stays out");
s.execute("layer.select", json!({"layer": b.0, "mode": "remove"})).unwrap();
assert_eq!(sel(&s), vec![a]);
s.execute("layer.select", json!({"layer": a.0, "mode": "remove"})).unwrap();
assert_eq!(sel(&s), vec![a], "the last selected layer stays");
}
/// A mask with its chain off stays put while the layer moves; a linked one moves along.
#[test]
fn translate_leaves_an_unlinked_mask_in_place() {
for depth in [8, 16] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.layerMask.hideAll", json!({})).unwrap();
s.edit("mask", |doc, _| {
doc.layer_mut(a).unwrap().mask.as_mut().unwrap().surface.fill_rect(Rect::new(12, 12, 18, 18), &[1.0]);
Ok(())
})
.unwrap();
let mval = |s: &Session, x, y| doc(s).layer(a).unwrap().mask.as_ref().unwrap().surface.sample_channel(x, y, 0);
s.execute("layer.layerMask.linked", json!({"linked": false})).unwrap();
s.execute("layer.translate", json!({"dx": 30, "dy": 0})).unwrap();
assert!(mval(&s, 14, 14) > 0.9, "{depth}-bit: unlinked mask stays");
assert!(mval(&s, 44, 14) < 0.1);
s.execute("edit.undo", json!({})).unwrap();
s.execute("layer.layerMask.linked", json!({"linked": true})).unwrap();
s.execute("layer.translate", json!({"dx": 30, "dy": 0})).unwrap();
assert!(mval(&s, 44, 14) > 0.9, "{depth}-bit: linked mask moves");
}
}
/// Aimed at the mask, a move shifts an unlinked mask alone and leaves a linked one with its layer.
#[test]
fn translate_with_the_mask_targeted_moves_an_unlinked_mask_alone() {
for depth in [8, 16] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.layerMask.hideAll", json!({})).unwrap();
s.edit("mask", |doc, _| {
doc.layer_mut(a).unwrap().mask.as_mut().unwrap().surface.fill_rect(Rect::new(12, 12, 18, 18), &[1.0]);
Ok(())
})
.unwrap();
let mval = |s: &Session, x, y| doc(s).layer(a).unwrap().mask.as_ref().unwrap().surface.sample_channel(x, y, 0);
// Linked: the layer and its mask move together.
s.execute("layer.translate", json!({"dx": 30, "dy": 0, "target": "mask"})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(40, 10, 50, 20), "{depth}-bit");
assert!(mval(&s, 44, 14) > 0.9);
s.execute("layer.layerMask.linked", json!({"linked": false})).unwrap();
s.execute("layer.translate", json!({"dx": -30, "dy": 0, "target": "mask"})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(40, 10, 50, 20), "{depth}-bit: the layer stays");
assert!(mval(&s, 14, 14) > 0.9, "the mask moved");
assert!(mval(&s, 44, 14) < 0.1);
s.execute("edit.undo", json!({})).unwrap();
assert!(mval(&s, 44, 14) > 0.9, "undo puts the mask back");
}
}
#[test]
fn moves_and_layer_props_report_only_their_area() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.translate", json!({"dx": 5, "dy": -3})).unwrap();
assert_eq!(damage(&s), Some(Rect::new(10, 7, 25, 20)), "where the layer was and is");
s.execute("layer.setProps", json!({"layer": a.0, "visible": false})).unwrap();
assert_eq!(damage(&s), Some(Rect::new(15, 7, 25, 17)));
s.execute("layer.setProps", json!({"layer": a.0, "opacity": 0.5, "blend": "Multiply"})).unwrap();
assert_eq!(damage(&s), Some(Rect::new(15, 7, 25, 17)));
// Clipping changes reach the layers around: everything.
s.execute("layer.setProps", json!({"layer": a.0, "clipped": true})).unwrap();
assert_eq!(damage(&s), None);
// An adjustment layer changes everything beneath it.
let adj = s.execute("layer.newAdjustmentLayer.invert", json!({})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.setProps", json!({"layer": adj, "visible": false})).unwrap();
assert_eq!(damage(&s), None);
// The Background (opaque everywhere): everything.
let bg = doc(&s).layers[0].id;
s.execute("layer.setProps", json!({"layer": bg.0, "opacity": 0.5})).unwrap();
let all = doc(&s).bounds();
assert!(damage(&s).is_none_or(|r| r.contains_rect(&all)), "{:?}", damage(&s));
// Bad params still fail cleanly.
assert!(s.execute("layer.setProps", json!({"layer": u64::MAX, "visible": true})).is_err());
assert!(s.execute("layer.translate", json!({"layer": u64::MAX, "dx": 1})).is_err());
}
/// #1771: a new empty layer or group changes no pixels, so it (and undoing or redoing it)
/// must not make the canvas recomposite every layer of the document.
#[test]
fn new_empty_layers_and_groups_damage_nothing() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
let composite = |s: &Session| photocraft_compose::render(doc(s), doc(s).bounds());
let shown = composite(&s);
s.execute("layer.new.layer", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::EMPTY), "{depth}-bit new layer");
assert_eq!(composite(&s), shown, "an empty layer changes no pixels");
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::EMPTY), "{depth}-bit undo New Layer");
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::EMPTY), "{depth}-bit redo New Layer");
s.execute("layer.new.group", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::EMPTY), "{depth}-bit new group");
// Inside a group too.
let child = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
let g = s.execute("layer.groupLayers", json!({})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.select", json!({"layer": child})).unwrap();
s.execute("layer.new.layer", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::EMPTY), "{depth}-bit new layer in a group");
assert!(doc(&s).layer(LayerId(g)).and_then(Layer::children).is_some_and(|c| c.len() == 2));
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::EMPTY));
// Undoing a step that painted still reports that area, not nothing.
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.translate", json!({"dx": 5, "dy": 0})).unwrap();
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::new(10, 10, 25, 20)));
}
}
#[test]
fn new_layers_that_change_clipping_recomposite_everything() {
let mut s = session(8);
let base = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
let clipped = rect_layer(&mut s, Rect::new(0, 0, 100, 80));
s.edit("green", |doc, _| {
doc.layer_mut(clipped).unwrap().surface_mut().unwrap().fill_rect(Rect::new(0, 0, 100, 80), &[0.0, 1.0, 0.0, 1.0]);
Ok(())
})
.unwrap();
s.execute("layer.setProps", json!({"layer": clipped.0, "clipped": true})).unwrap();
// New Layer between a clipping base and its clipped layer joins their clip group (#2203),
// so it draws nothing; an empty layer there that stayed unclipped would become their base.
s.execute("layer.select", json!({"layer": base.0})).unwrap();
let shown = photocraft_compose::render(doc(&s), doc(&s).bounds());
let before = doc(&s).clone();
s.execute("layer.new.layer", json!({})).unwrap();
assert_eq!(damage(&s), Some(Rect::EMPTY));
assert_eq!(photocraft_compose::render(doc(&s), doc(&s).bounds()), shown);
let mut split = before.clone();
split.insert_above(Some(base), Layer::raster("split", split.pixel_format()));
assert_ne!(photocraft_compose::render(&split, split.bounds()), shown);
assert_eq!(step_damage(&before, &split), None);
assert_eq!(step_damage(&split, &before), None);
s.execute("edit.undo", json!({})).unwrap();
// A step that adds a layer with pixels (Layer via Copy, paste…) changes where it draws.
let before = doc(&s).clone();
let mut after = before.clone();
let mut l = Layer::raster("painted", after.pixel_format());
l.surface_mut().unwrap().fill_rect(Rect::new(1, 1, 2, 2), &[0.0, 1.0, 0.0, 1.0]);
after.insert_above(None, l);
assert_eq!(step_damage(&before, &after), Some(Rect::new(1, 1, 2, 2)));
assert_eq!(step_damage(&after, &before), Some(Rect::new(1, 1, 2, 2)));
// Unless it becomes the base of clipped layers above it.
let mut based = before.clone();
let mut l = Layer::raster("base", based.pixel_format());
l.surface_mut().unwrap().fill_rect(Rect::new(1, 1, 2, 2), &[0.0, 1.0, 0.0, 1.0]);
let under = based.layers.iter().position(|l| l.id == clipped).unwrap();
based.layers.insert(under, l);
assert_eq!(step_damage(&before, &based), None);
assert_eq!(step_damage(&based, &before), None);
// An adjustment reaches every pixel below it.
let mut adjusted = before.clone();
adjusted.insert_above(None, Layer::new("inv", LayerContent::Adjustment(photocraft_doc::Adjustment::Invert)));
assert_eq!(step_damage(&before, &adjusted), None);
assert_eq!(step_damage(&adjusted, &before), None);
// Empty layers draw nothing, in any blend mode.
let mut styled = before.clone();
let mut l = Layer::raster("styled", styled.pixel_format());
l.blend = photocraft_doc::BlendMode::Multiply;
styled.insert_above(None, l);
assert_eq!(step_damage(&before, &styled), Some(Rect::EMPTY));
let mut plain = before.clone();
plain.insert_above(None, Layer::raster("plain", plain.pixel_format()));
assert_eq!(step_damage(&before, &plain), Some(Rect::EMPTY));
assert_eq!(step_damage(&plain, &before), Some(Rect::EMPTY));
}
/// #6535: hiding or showing an adjustment clipped to a layer recomposites only that base's
/// area, also on undo and redo and inside a group, and recompositing just that area gives
/// the same canvas as a full recomposite.
#[test]
fn toggling_a_clipped_adjustment_damages_only_its_base() {
let all = |s: &Session| photocraft_compose::render(doc(s), doc(s).bounds());
// Recomposite only the reported damage over the previous canvas, as the view does.
let patched = |s: &Session, prev: &photocraft_compose::Buffer| {
let r = damage(s).expect("bounded damage");
let mut out = prev.clone();
if r.is_empty() {
return out;
}
let part = photocraft_compose::render(doc(s), r);
let w = out.rect.width() as usize;
for y in r.y0..r.y1 {
for x in r.x0..r.x1 {
let i = (y - out.rect.y0) as usize * w + (x - out.rect.x0) as usize;
let k = (y - r.y0) as usize * r.width() as usize + (x - r.x0) as usize;
out.px[i] = part.px[k];
}
}
out
};
for grouped in [false, true] {
let mut s = session(16);
let base_rect = Rect::new(10, 10, 30, 25);
let base = rect_layer(&mut s, base_rect);
let adj = LayerId(s.execute("layer.newAdjustmentLayer.invert", json!({})).unwrap()["layer"].as_u64().unwrap());
s.execute("layer.createClippingMask", json!({"layer": adj.0})).unwrap();
assert!(doc(&s).layer(adj).unwrap().clipped);
if grouped {
s.execute("layer.select", json!({"layer": base.0})).unwrap();
s.execute("layer.select", json!({"layer": adj.0, "mode": "toggle"})).unwrap();
s.execute("layer.groupLayers", json!({})).unwrap();
assert!(doc(&s).path_of(adj).unwrap().len() == 2, "the pair sits in a group");
}
let shown = all(&s);
s.execute("layer.hideLayers", json!({"layer": adj.0})).unwrap();
assert!(!doc(&s).layer(adj).unwrap().visible);
assert_eq!(damage(&s), Some(base_rect), "grouped: {grouped}");
let hidden = all(&s);
assert_ne!(hidden, shown);
assert_eq!(patched(&s, &shown), hidden);
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(damage(&s), Some(base_rect));
assert_eq!(patched(&s, &hidden), shown);
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(damage(&s), Some(base_rect));
assert_eq!(patched(&s, &shown), hidden);
s.execute("layer.showLayers", json!({"layer": adj.0})).unwrap();
assert_eq!(damage(&s), Some(base_rect));
assert_eq!(patched(&s, &hidden), shown);
// layer.setProps reports its own damage.
s.execute("layer.setProps", json!({"layer": adj.0, "visible": false})).unwrap();
assert_eq!(damage(&s), Some(base_rect));
assert_eq!(patched(&s, &shown), hidden);
// Unclipped, the adjustment still reaches the whole canvas.
s.execute("layer.setProps", json!({"layer": adj.0, "visible": true})).unwrap();
s.execute("layer.releaseClippingMask", json!({"layer": adj.0})).unwrap();
s.execute("layer.hideLayers", json!({"layer": adj.0})).unwrap();
assert_eq!(damage(&s), None);
}
}
/// #6535: hiding a clipped adjustment inside a pass-through group that is itself a clip base
/// can switch the group between isolated and pass-through rendering, so the step damages the
/// whole group, on undo, redo and when the adjustment is deleted too.
#[test]
fn clipped_adjustment_in_pass_through_clip_base_damages_its_group() {
use photocraft_doc::{Adjustment, BlendMode};
let solid = |name: &str, r: Rect, blend: BlendMode| {
let mut l = Layer::raster(name, PixelFormat::RGBA8);
l.surface_mut().unwrap().fill_rect(r, &[0.5, 0.5, 0.5, 1.0]);
l.blend = blend;
l
};
let mut before = Document::with_background(
"t",
photocraft_geom::Size::new(10, 8),
photocraft_doc::ColorMode::Rgb,
photocraft_doc::SampleType::U8,
photocraft_color::Color::WHITE,
);
before.layers.push(solid("bg", before.bounds(), BlendMode::Normal));
let mut a = Layer::new("A", LayerContent::Adjustment(Adjustment::Invert));
a.clipped = true;
let mut g = Layer::group("G", vec![solid("P", Rect::new(2, 1, 4, 3), BlendMode::Normal), a, solid("Q", Rect::new(6, 4, 8, 6), BlendMode::Multiply)]);
g.blend = BlendMode::PassThrough;
before.layers.push(g);
let mut x = solid("X", Rect::new(2, 1, 3, 2), BlendMode::Normal);
x.clipped = true;
before.layers.push(x);
let mut after = before.clone();
let LayerContent::Group(g) = &mut after.layers[2].content else { panic!("group") };
g.children[1].visible = false;
let group = Some(Rect::new(2, 1, 8, 6));
assert_eq!(step_damage(&before, &after), group);
assert_eq!(step_damage(&after, &before), group);
let mut deleted = before.clone();
let LayerContent::Group(g) = &mut deleted.layers[2].content else { panic!("group") };
g.children.remove(1);
assert_eq!(step_damage(&before, &deleted), group);
let LayerContent::Group(g) = &before.layers[2].content else { panic!("group") };
let ids = [g.children[1].id];
assert_eq!(layers_damage(&before, &after, &ids), group);
// Without the layer clipped to the group it stays pass-through: just A's base.
before.layers.truncate(3);
after.layers.truncate(3);
assert_eq!(step_damage(&before, &after), Some(Rect::new(2, 1, 4, 3)));
}
/// #2883 (P8/P9): a duplicate shares the source's tiles (no pixel copy) and recomposites only
/// where it draws; undo brings back exactly the old pixels. A copy that becomes the clipping
/// base of the layers above still recomposites everything.
#[test]
fn duplicate_shares_tiles_and_damages_only_the_copy() {
let render = |s: &Session| photocraft_compose::render(doc(s), doc(s).bounds());
let tiles =
|s: &Session, id: LayerId| doc(s).layer(id).unwrap().surface().unwrap().tiles().map(|(c, t)| (*c, std::sync::Arc::as_ptr(t))).collect::<Vec<_>>();
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
s.execute("layer.setProps", json!({"layer": a.0, "opacity": 0.5})).unwrap();
let shown = render(&s);
let copy = LayerId(s.execute("layer.duplicate", json!({"layer": a.0})).unwrap()["layer"].as_u64().unwrap());
assert_eq!(damage(&s), Some(Rect::new(10, 10, 20, 20)), "{depth}-bit: only where the copy draws");
assert!(!tiles(&s, a).is_empty());
assert_eq!(tiles(&s, copy), tiles(&s, a), "{depth}-bit: the copy shares the source's tiles");
let now = render(&s);
assert_ne!(now, shown, "the half-transparent copy darkens its area");
let w = shown.rect.width() as usize;
for (i, (p, q)) in shown.px.iter().zip(&now.px).enumerate() {
if !Rect::new(10, 10, 20, 20).contains((i % w) as i32, (i / w) as i32) {
assert_eq!(p, q, "{depth}-bit: pixel {i} outside the damage changed");
}
}
s.execute("edit.undo", json!({})).unwrap();
assert!(doc(&s).layer(copy).is_none());
assert_eq!(render(&s), shown);
// A clipping base's copy goes between it and its clipped layer and becomes their base.
let clipped = rect_layer(&mut s, Rect::new(0, 0, 50, 50));
s.execute("layer.setProps", json!({"layer": clipped.0, "clipped": true})).unwrap();
s.execute("layer.duplicate", json!({"layer": a.0})).unwrap();
assert_eq!(damage(&s), None, "{depth}-bit: a new clipping base");
}
}
/// The composite of `after` equals `before`'s outside `damage`.
fn unchanged_outside(before: &Document, after: &Document, damage: Rect) -> bool {
let (x, y) = (photocraft_compose::render(before, before.bounds()), photocraft_compose::render(after, after.bounds()));
let w = before.bounds().width() as i32;
x.px.iter().zip(&y.px).enumerate().all(|(i, (p, q))| p == q || damage.contains(i as i32 % w, i as i32 / w))
}
/// Duplicate (one layer or several), paste and delete, and their undo and redo, recomposite
/// only where the layers draw; undoing a duplicate used to recomposite the whole document.
#[test]
fn duplicate_paste_and_delete_report_where_the_layer_draws() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
let full = doc(&s).bounds();
let step = |s: &mut Session, id: &str, p: serde_json::Value| {
let before = doc(s).clone();
s.execute(id, p).unwrap();
let d = damage(s).unwrap_or_else(|| panic!("{id}: unbounded damage"));
assert!(d.width() < full.width(), "{id}: {d:?}");
assert!(unchanged_outside(&before, doc(s), d), "{id}: pixels changed outside {d:?}");
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(damage(s), Some(d), "undo {id}");
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(damage(s), Some(d), "redo {id}");
};
step(&mut s, "layer.duplicate", json!({"layer": a.0}));
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("select.rect", json!({"x": 12, "y": 12, "width": 4, "height": 4})).unwrap();
s.execute("edit.copy", json!({})).unwrap();
s.execute("select.deselect", json!({})).unwrap();
step(&mut s, "edit.paste", json!({}));
// Duplicating several selected layers reports where the copies draw, too.
let b = rect_layer(&mut s, Rect::new(30, 30, 40, 40));
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.select", json!({"layer": b.0, "mode": "add"})).unwrap();
step(&mut s, "layer.duplicate", json!({}));
assert_eq!(damage(&s), Some(Rect::new(10, 10, 40, 40)), "both copies, nothing else");
step(&mut s, "layer.delete", json!({"layer": a.0}));
}
#[test]
fn the_move_preview_matches_the_move() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
let before = s.active().unwrap().doc.clone();
let ids = move_targets(&before, &[a]);
let shown = moved(&before, &ids, 7, 4).unwrap();
s.execute("layer.translate", json!({"layer": a.0, "dx": 7, "dy": 4})).unwrap();
assert_eq!(layer_bounds(shown.layer(a).unwrap()), Some(bounds(&s, a)));
// Locked layers don't move in the preview either.
let mut locked = (*before).clone();
locked.layer_mut(a).unwrap().locks.position = true;
assert!(moved(&locked, &ids, 1, 1).is_err());
assert!(moved(&before, &[LayerId(u64::MAX)], 1, 1).is_err());
}
#[test]
fn move_stroked_shape_across_canvas_edge_matches_fresh_render() {
let mut s = session(8);
let id = LayerId(
s.execute("shape.create", json!({"kind": "rect", "rect": [10, 10, 30, 30], "stroke": {"width": 4, "color": "#ff0000"}})).unwrap()["layer"]
.as_u64()
.unwrap(),
);
let before = doc(&s).clone();
let ids = move_targets(&before, &[id]);
// Drag the stroked shape across the left canvas boundary:
let moved_doc = moved(&before, &ids, -25, 0).unwrap();
let moved_layer = moved_doc.layer(id).unwrap();
let LayerContent::Shape(sh) = &moved_layer.content else { panic!("not a shape") };
let cached = sh.cache.as_ref().expect("cached render");
let mut fresh_sh = sh.clone();
crate::vector_cmds::refresh_shape(&moved_doc, &mut fresh_sh);
let fresh = fresh_sh.cache.as_ref().expect("fresh render");
assert_eq!(cached, fresh, "dragged shape cached render must match fresh render across canvas edge");
// Drag it back inside the canvas:
let moved_back = moved(&moved_doc, &ids, 30, 0).unwrap();
let back_layer = moved_back.layer(id).unwrap();
let LayerContent::Shape(back_sh) = &back_layer.content else { panic!("not a shape") };
let back_cached = back_sh.cache.as_ref().expect("cached render");
let mut fresh_back = back_sh.clone();
crate::vector_cmds::refresh_shape(&moved_back, &mut fresh_back);
let fresh_back_render = fresh_back.cache.as_ref().expect("fresh render");
assert_eq!(back_cached, fresh_back_render, "cached render must match fresh render when dragged back");
}
fn select_all(s: &mut Session, ids: &[LayerId]) {
s.execute("layer.select", json!({"layer": ids[0].0})).unwrap();
for id in &ids[1..] {
s.execute("layer.select", json!({"layer": id.0, "mode": "toggle"})).unwrap();
}
}
#[test]
fn toggle_and_range_selection() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let c = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let d = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
assert_eq!(sel(&s), vec![d]);
s.execute("layer.select", json!({"layer": b.0, "mode": "toggle"})).unwrap();
assert_eq!(sel(&s), vec![b, d]);
assert_eq!(s.active().unwrap().active_layer, Some(b));
// Toggling the active layer off hands "active" to a remaining member.
s.execute("layer.select", json!({"layer": b.0, "mode": "toggle"})).unwrap();
assert_eq!(sel(&s), vec![d]);
assert_eq!(s.active().unwrap().active_layer, Some(d));
// The last selected layer can't be toggled off.
s.execute("layer.select", json!({"layer": d.0, "mode": "toggle"})).unwrap();
assert_eq!(sel(&s), vec![d]);
// Range from the anchor (a) to c.
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.select", json!({"layer": c.0, "mode": "range"})).unwrap();
assert_eq!(sel(&s), vec![a, b, c]);
// A second ⇧-click re-ranges from the same anchor.
s.execute("layer.select", json!({"layer": b.0, "mode": "range"})).unwrap();
assert_eq!(sel(&s), vec![a, b]);
assert!(s.execute("layer.select", json!({"layer": b.0, "mode": "bogus"})).is_err());
// Selection changes are not edits.
let history = s.active().unwrap().history.entries().len();
s.execute("select.allLayers", json!({})).unwrap();
assert_eq!(sel(&s), vec![a, b, c, d], "Select All Layers skips the locked Background");
s.execute("select.deselectLayers", json!({})).unwrap();
assert!(sel(&s).is_empty());
assert_eq!(s.active().unwrap().history.entries().len(), history);
// Nothing selected: a no-op, not an error (#2457).
s.execute("select.deselectLayers", json!({})).unwrap();
assert_eq!(s.active().unwrap().history.entries().len(), history);
// An explicit layer needs no active layer.
s.execute("layer.hideLayers", json!({"layer": a.0})).unwrap();
assert!(!s.active().unwrap().doc.layer(a).unwrap().visible);
s.execute("layer.renameLayer", json!({"layer": a.0, "name": "x"})).unwrap();
assert_eq!(s.active().unwrap().doc.layer(a).unwrap().name, "x");
s.execute("layer.showLayers", json!({"layer": a.0})).unwrap();
assert!(s.active().unwrap().doc.layer(a).unwrap().visible);
assert!(s.execute("layer.hideLayers", json!({"layer": u64::MAX})).is_err());
assert!(s.execute("layer.hideLayers", json!({})).is_err());
assert!(!s.is_enabled("layer.align.topEdges"));
}
#[test]
fn find_layers_by_name() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
s.execute("layer.renameLayer", json!({"layer": a.0, "name": "Sky photo"})).unwrap();
s.execute("layer.renameLayer", json!({"layer": b.0, "name": "Photo of sea"})).unwrap();
assert_eq!(doc(&s).layer(a).unwrap().name, "Sky photo");
let r = s.execute("select.findLayers", json!({"name": "PHOTO"})).unwrap();
assert_eq!(r["selected"], json!([a.0, b.0]));
assert!(s.execute("select.findLayers", json!({"name": "nothing"})).is_err());
assert!(s.execute("layer.renameLayer", json!({})).is_err());
}
#[test]
fn rename_layer_keeps_surrounding_spaces() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
s.execute("layer.renameLayer", json!({"layer": a.0, "name": " black skin bw "})).unwrap();
assert_eq!(doc(&s).layer(a).unwrap().name, " black skin bw ");
assert!(s.execute("layer.renameLayer", json!({"layer": a.0, "name": " "})).is_err());
assert_eq!(doc(&s).layer(a).unwrap().name, " black skin bw ");
}
#[test]
fn align_each_edge() {
for depth in [8, 16, 32] {
let cases: [(&str, [Rect; 2]); 6] = [
("topEdges", [Rect::new(10, 5, 20, 15), Rect::new(40, 5, 50, 25)]),
("bottomEdges", [Rect::new(10, 20, 20, 30), Rect::new(40, 10, 50, 30)]),
// Union 5..30: centre 17.5; half-pixel offsets round towards the top.
("verticalCenters", [Rect::new(10, 12, 20, 22), Rect::new(40, 7, 50, 27)]),
("leftEdges", [Rect::new(10, 5, 20, 15), Rect::new(10, 10, 50, 30)]),
("rightEdges", [Rect::new(40, 5, 50, 15), Rect::new(10, 10, 50, 30)]),
("horizontalCenters", [Rect::new(25, 5, 35, 15), Rect::new(10, 10, 50, 30)]),
];
for (kind, want) in cases {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(10, 5, 20, 15));
let b = rect_layer(&mut s, Rect::new(40, 10, 50, 30));
// For the horizontal cases make b wide so it defines the target bounds.
if !matches!(kind, "topEdges" | "bottomEdges" | "verticalCenters") {
s.edit("wide", |doc, _| {
doc.layer_mut(b).unwrap().surface_mut().unwrap().fill_rect(Rect::new(10, 10, 50, 30), &[0.0, 1.0, 0.0, 1.0]);
Ok(())
})
.unwrap();
}
select_all(&mut s, &[a, b]);
s.execute(&format!("layer.align.{kind}"), json!({})).unwrap();
assert_eq!([bounds(&s, a), bounds(&s, b)], want, "{kind} at {depth}-bit");
// Pixels moved, not just bounds.
let r = want[0];
assert_eq!(doc(&s).layer(a).unwrap().surface().unwrap().pixel(r.x0, r.y0)[..4], [1.0, 0.0, 0.0, 1.0]);
// One undo restores the original positions.
s.undo();
assert_eq!(bounds(&s, a), Rect::new(10, 5, 20, 15));
}
}
}
#[test]
fn align_single_layer_to_selection() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
assert!(s.is_enabled("layer.align.leftEdges"), "one layer aligns to the canvas");
s.execute("select.rect", json!({"x": 50, "y": 40, "width": 30, "height": 30})).unwrap();
assert!(s.is_enabled("layer.align.leftEdges"));
s.execute("layer.align.rightEdges", json!({})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(70, 10, 80, 20));
s.execute("layer.align.verticalCenters", json!({})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(70, 50, 80, 60));
s.execute("layer.align.topEdges", json!({"to": "canvas"})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(70, 0, 80, 10));
}
}
#[test]
fn align_single_layer_to_canvas() {
// Photoshop: a single selected layer with no active selection aligns to the canvas.
let mut s = session(8); // 100 x 80
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20)); // 10 x 10
assert!(s.is_enabled("layer.align.horizontalCenters"));
s.execute("layer.align.horizontalCenters", json!({})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(45, 10, 55, 20), "centred on the 100px-wide canvas");
s.execute("layer.align.verticalCenters", json!({})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(45, 35, 55, 45), "centred on the 80px-tall canvas");
s.execute("layer.align.leftEdges", json!({})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(0, 35, 10, 45), "left edge to the canvas");
}
#[test]
fn distribute_uneven_layers() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(0, 0, 10, 10));
let b = rect_layer(&mut s, Rect::new(12, 0, 32, 10)); // 20 wide
let c = rect_layer(&mut s, Rect::new(70, 0, 100, 10)); // 30 wide
select_all(&mut s, &[a, b, c]);
// Undo targets the layers its state had when it was created (#495): reselect.
assert!(s.is_enabled("layer.distribute.leftEdges"));
s.execute("layer.distribute.leftEdges", json!({})).unwrap();
assert_eq!(bounds(&s, b), Rect::new(35, 0, 55, 10), "left edges 0, 35, 70");
s.undo();
select_all(&mut s, &[a, b, c]);
s.execute("layer.distribute.horizontalCenters", json!({})).unwrap();
// centres 5 and 85 → middle centre 45
assert_eq!(bounds(&s, b), Rect::new(35, 0, 55, 10));
s.undo();
select_all(&mut s, &[a, b, c]);
s.execute("layer.distribute.rightEdges", json!({})).unwrap();
// right edges 10 and 100 → 55
assert_eq!(bounds(&s, b), Rect::new(35, 0, 55, 10));
s.undo();
select_all(&mut s, &[a, b, c]);
s.execute("layer.distribute.horizontally", json!({})).unwrap();
// span 100, widths 60 → gaps of 20: b at 30..50
assert_eq!(bounds(&s, b), Rect::new(30, 0, 50, 10));
assert_eq!(bounds(&s, a), Rect::new(0, 0, 10, 10));
assert_eq!(bounds(&s, c), Rect::new(70, 0, 100, 10));
s.undo();
assert_eq!(bounds(&s, b), Rect::new(12, 0, 32, 10));
}
// Vertical: tall layers with uneven heights.
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 10, 10));
let b = rect_layer(&mut s, Rect::new(0, 50, 10, 54));
let c = rect_layer(&mut s, Rect::new(0, 60, 10, 80));
select_all(&mut s, &[a, b, c]);
s.execute("layer.distribute.vertically", json!({})).unwrap();
// span 80, heights 34 → gaps 23: b at 33..37
assert_eq!(bounds(&s, b), Rect::new(0, 33, 10, 37));
s.undo();
select_all(&mut s, &[a, b, c]);
s.execute("layer.distribute.topEdges", json!({})).unwrap();
assert_eq!(bounds(&s, b), Rect::new(0, 30, 10, 34));
s.undo();
select_all(&mut s, &[a, b, c]);
s.execute("layer.distribute.bottomEdges", json!({})).unwrap();
assert_eq!(bounds(&s, b), Rect::new(0, 41, 10, 45));
s.undo();
select_all(&mut s, &[a, b, c]);
s.execute("layer.distribute.verticalCenters", json!({})).unwrap();
// centres 5 and 70 → 37.5, b is 4 tall → top 35.5 → rounds to 36 (35 for ties down)
let y0 = bounds(&s, b).y0;
assert!((35..=36).contains(&y0), "{y0}");
// Two layers can't be distributed.
select_all(&mut s, &[a, b]);
assert!(!s.is_enabled("layer.distribute.leftEdges"));
}
#[test]
fn merge_keeps_pixels_outside_the_canvas() {
// #5067: the merged layer was cropped to the 100x80 canvas.
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(-30, -20, 10, 10));
let b = rect_layer(&mut s, Rect::new(90, 70, 140, 120));
select_all(&mut s, &[a, b]);
let m = LayerId(s.execute("layer.mergeLayers", json!({})).unwrap()["layer"].as_u64().unwrap());
let ml = doc(&s).layer(m).unwrap();
assert_eq!(layer_bounds(ml).unwrap(), Rect::new(-30, -20, 140, 120));
assert_eq!(ml.surface().unwrap().pixel(-10, -5)[3], 1.0);
assert_eq!(ml.surface().unwrap().pixel(130, 110)[3], 1.0);
}
#[test]
fn merge_down_and_merge_group_keep_pixels_outside_the_canvas() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(-30, -20, 10, 10));
let b = rect_layer(&mut s, Rect::new(90, 70, 140, 120));
s.execute("layer.mergeDown", json!({"layer": b.0})).unwrap();
assert_eq!(layer_bounds(doc(&s).layer(a).unwrap()).unwrap(), Rect::new(-30, -20, 140, 120));
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(-30, -20, 10, 10));
let b = rect_layer(&mut s, Rect::new(90, 70, 140, 120));
select_all(&mut s, &[a, b]);
let g = LayerId(s.execute("layer.groupLayers", json!({})).unwrap()["layer"].as_u64().unwrap());
s.execute("layer.mergeGroup", json!({"layer": g.0})).unwrap();
assert_eq!(layer_bounds(doc(&s).layer(g).unwrap()).unwrap(), Rect::new(-30, -20, 140, 120));
}
#[test]
fn merge_selected_into_top_most() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(0, 0, 10, 10));
let b = rect_layer(&mut s, Rect::new(20, 0, 30, 10));
let c = rect_layer(&mut s, Rect::new(40, 0, 50, 10));
s.execute("layer.renameLayer", json!({"layer": c.0, "name": "Top"})).unwrap();
select_all(&mut s, &[a, c]);
let before = doc(&s).layer_count();
let m = LayerId(s.execute("layer.mergeLayers", json!({})).unwrap()["layer"].as_u64().unwrap());
let d = doc(&s);
assert_eq!(d.layer_count(), before - 1);
let ml = d.layer(m).unwrap();
assert_eq!(ml.name, "Top");
assert_eq!(layer_bounds(ml).unwrap(), Rect::new(0, 0, 50, 10));
assert_eq!(ml.surface().unwrap().pixel(5, 5)[..4], [1.0, 0.0, 0.0, 1.0]);
assert_eq!(ml.surface().unwrap().pixel(25, 5)[3], 0.0, "b was not merged");
assert!(d.layer(b).is_some() && d.layer(a).is_none());
assert_eq!(d.layers.last().unwrap().id, m, "merged layer sits where the top-most was");
assert_eq!(sel(&s), vec![m]);
s.undo();
assert_eq!(doc(&s).layer_count(), before);
assert_eq!(sel(&s), vec![a, c], "undo selects the layers that were merged");
// One layer selected: Merge Down.
s.execute("layer.select", json!({"layer": c.0})).unwrap();
s.execute("layer.mergeLayers", json!({})).unwrap();
assert_eq!(doc(&s).layer_count(), before - 1);
}
}
#[test]
fn merging_group_children_preserves_their_composite() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let lower = rect_layer(&mut s, Rect::new(10, 12, 40, 42));
let upper = rect_layer(&mut s, Rect::new(25, 20, 55, 50));
select_all(&mut s, &[lower, upper]);
let group = LayerId(s.execute("layer.groupLayers", json!({"name": "Merge test group"})).unwrap()["layer"].as_u64().unwrap());
let doc_before = doc(&s);
let expected = photocraft_compose::render(doc_before, doc_before.bounds());
let children = doc_before.layer(group).unwrap().children().unwrap().iter().map(|layer| layer.id).collect::<Vec<_>>();
select_all(&mut s, &children);
s.execute("layer.mergeLayers", json!({})).unwrap();
let doc_after = doc(&s);
let actual = photocraft_compose::render(doc_after, doc_after.bounds());
assert_eq!(actual, expected, "depth {depth}: group merge changed rendered pixels");
assert_eq!(doc_after.layer(group).unwrap().children().unwrap().len(), 1);
}
}
#[test]
fn merging_keeps_layer_effects_outside_the_pixels() {
// A drop shadow reaches past the layer's pixels; the merge must render that far.
for depth in [8, 16, 32] {
let mut s = session(depth);
let lower = rect_layer(&mut s, Rect::new(10, 10, 30, 30));
let upper = rect_layer(&mut s, Rect::new(40, 20, 60, 40));
s.execute("layer.layerStyle.dropShadow", json!({"layer": upper.0, "blend": "normal", "distance": 12, "size": 4})).unwrap();
let before = photocraft_compose::render(doc(&s), doc(&s).bounds());
select_all(&mut s, &[lower, upper]);
s.execute("layer.mergeLayers", json!({})).unwrap();
let after = photocraft_compose::render(doc(&s), doc(&s).bounds());
let worst = before.px.iter().zip(&after.px).map(|(a, b)| a.iter().zip(b).map(|(x, y)| (x - y).abs()).fold(0.0f32, f32::max)).fold(0.0f32, f32::max);
assert!(worst <= 1.5 / 255.0, "depth {depth}: merge layers dropped the shadow (off by {worst})");
}
}
#[test]
fn merging_a_group_down_preserves_the_composite() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let lower = rect_layer(&mut s, Rect::new(10, 12, 50, 52));
let child_a = rect_layer(&mut s, Rect::new(24, 20, 64, 60));
let child_b = rect_layer(&mut s, Rect::new(35, 28, 75, 68));
select_all(&mut s, &[child_a, child_b]);
let group = LayerId(s.execute("layer.groupLayers", json!({"name": "Merge down group"})).unwrap()["layer"].as_u64().unwrap());
let doc_before = doc(&s);
let expected = photocraft_compose::render(doc_before, doc_before.bounds());
s.execute("layer.mergeDown", json!({"layer": group.0})).unwrap();
let doc_after = doc(&s);
let actual = photocraft_compose::render(doc_after, doc_after.bounds());
assert_eq!(actual, expected, "depth {depth}: group merge down changed rendered pixels");
assert!(doc_after.layer(lower).is_some());
assert!(doc_after.layer(group).is_none());
}
}
#[test]
fn a_locked_group_locks_its_contents() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let g = s.execute("layer.new.groupFromLayers", json!({})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.setProps", json!({"layer": g, "locked": true})).unwrap();
s.execute("layer.select", json!({"layer": a.0})).unwrap();
for (cmd, p) in [
("layer.translate", json!({"dx": 1})),
("paint.stroke", json!({"points": [[2, 2], [4, 4]]})),
("edit.fill", json!({"color": "#00ff00"})),
("edit.transform.flipHorizontal", json!({})),
] {
assert!(s.execute(cmd, p).is_err(), "{cmd} edited a layer in a locked group");
}
// Unlocking the group releases its contents.
s.execute("layer.setProps", json!({"layer": g, "locked": false})).unwrap();
s.execute("layer.translate", json!({"dx": 1})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(1, 0, 6, 5));
}
#[test]
fn a_locked_group_keeps_a_grouped_background_locked() {
let mut s = session(8);
let bg = doc(&s).layers[0].id;
s.execute("layer.select", json!({"layer": bg.0})).unwrap();
let g = s.execute("layer.new.groupFromLayers", json!({})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.setProps", json!({"layer": g, "locked": true})).unwrap();
s.execute("layer.select", json!({"layer": bg.0})).unwrap();
for (cmd, p) in [
("edit.transform.flipHorizontal", json!({})),
("edit.transform.warp", json!({"style": "flag", "bend": 50})),
("edit.puppetWarp", json!({"pins": [{"src": [30, 25], "dst": [36, 29]}]})),
] {
let e = s.execute(cmd, p).unwrap_err().to_string();
assert!(e.contains("locked"), "{cmd}: {e}");
assert_eq!(doc(&s).layer(bg).unwrap().name, "Background", "{cmd}");
}
}
#[test]
fn group_from_layers_preserves_order() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let c = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let d = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
select_all(&mut s, &[c, a]);
let g = LayerId(s.execute("layer.new.groupFromLayers", json!({"name": "Pair"})).unwrap()["layer"].as_u64().unwrap());
let docu = doc(&s);
let gl = docu.layer(g).unwrap();
assert_eq!(gl.name, "Pair");
assert!(matches!(&gl.content, LayerContent::Group(gr) if !gr.expanded), "created collapsed");
assert_eq!(gl.children().unwrap().iter().map(|l| l.id).collect::<Vec<_>>(), vec![a, c]);
// Root (bottom-to-top): Background, b, Pair (where c was), d.
assert_eq!(docu.layers.iter().map(|l| l.id).skip(1).collect::<Vec<_>>(), vec![b, g, d]);
assert_eq!(sel(&s), vec![g]);
s.undo();
assert_eq!(doc(&s).layers.len(), 5);
// ⌘G with several selected groups them too.
select_all(&mut s, &[b, d]);
let g = LayerId(s.execute("layer.groupLayers", json!({})).unwrap()["layer"].as_u64().unwrap());
assert_eq!(doc(&s).layers.len(), 4);
// Both create the group collapsed, as Photoshop does (#5571).
assert!(matches!(&doc(&s).layer(g).unwrap().content, LayerContent::Group(gr) if !gr.expanded));
}
#[test]
fn grouping_is_capped_at_the_document_nesting_limit() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
select_all(&mut s, &[a]);
for _ in 0..photocraft_doc::MAX_GROUP_DEPTH {
s.execute("layer.groupLayers", json!({})).unwrap();
}
assert_eq!(doc(&s).max_group_depth(), photocraft_doc::MAX_GROUP_DEPTH);
// One more wrapping group would pass the cap: rejected, document untouched.
let err = s.execute("layer.groupLayers", json!({})).unwrap_err();
assert!(err.to_string().contains("deeper than 100"), "{err}");
assert_eq!(doc(&s).max_group_depth(), photocraft_doc::MAX_GROUP_DEPTH);
// The rejected call recorded no history step: undo still lands one grouping earlier.
s.undo();
assert_eq!(doc(&s).max_group_depth(), photocraft_doc::MAX_GROUP_DEPTH - 1);
}
#[test]
fn select_linked_layers_excludes_an_unlinked_active_layer() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(0, 0, 10, 10));
let b = rect_layer(&mut s, Rect::new(20, 20, 30, 30));
let other = rect_layer(&mut s, Rect::new(50, 50, 60, 60));
select_all(&mut s, &[a, b]);
s.execute("layer.linkLayers", json!({})).unwrap();
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.select", json!({"layer": other.0, "mode": "toggle"})).unwrap();
assert_eq!(sel(&s), vec![a, other]);
assert_eq!(s.active().unwrap().active_layer, Some(other));
let past = s.active().unwrap().history.past_len();
let dirty = s.active().unwrap().is_dirty();
let result = s.execute("layer.selectLinkedLayers", json!({})).unwrap();
assert_eq!(sel(&s), vec![a, b]);
assert_eq!(result["selected"], sel(&s).len());
assert_eq!(s.active().unwrap().active_layer, Some(b));
assert_eq!(s.active().unwrap().layer_anchor, Some(b));
assert_eq!(s.active().unwrap().history.past_len(), past);
assert_eq!(s.active().unwrap().is_dirty(), dirty);
// A following multi-layer delete must leave the unrelated layer intact.
s.execute("layer.delete", json!({})).unwrap();
assert!(doc(&s).layer(a).is_none() && doc(&s).layer(b).is_none());
assert!(doc(&s).layer(other).is_some());
s.undo();
assert!(doc(&s).layer(a).is_some() && doc(&s).layer(b).is_some());
assert!(doc(&s).layer(other).is_some());
}
}
#[test]
fn select_linked_layers_preserves_a_linked_active_layer() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(0, 0, 10, 10));
let b = rect_layer(&mut s, Rect::new(20, 20, 30, 30));
select_all(&mut s, &[a, b]);
s.execute("layer.linkLayers", json!({})).unwrap();
for active in [a, b] {
s.execute("layer.select", json!({"layer": active.0})).unwrap();
let st = s.active_mut().unwrap();
st.saved_revision = st.revision;
let past = st.history.past_len();
for _ in 0..2 {
let result = s.execute("layer.selectLinkedLayers", json!({})).unwrap();
assert_eq!(sel(&s), vec![a, b]);
assert_eq!(result["selected"], sel(&s).len());
assert_eq!(s.active().unwrap().active_layer, Some(active));
assert_eq!(s.active().unwrap().layer_anchor, Some(active));
assert_eq!(s.active().unwrap().history.past_len(), past);
assert!(!s.active().unwrap().is_dirty());
}
}
}
}
#[test]
fn select_linked_layers_requires_a_linked_selection() {
let mut s = Session::new();
assert!(!s.is_enabled("layer.selectLinkedLayers"));
assert!(s.execute("layer.selectLinkedLayers", json!({})).is_err());
let mut s = session(8);
let before = sel(&s);
assert!(!s.is_enabled("layer.selectLinkedLayers"));
assert!(s.execute("layer.selectLinkedLayers", json!({})).is_err());
assert_eq!(sel(&s), before);
}
#[test]
fn translate_rejects_offsets_that_would_wrap() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
select_all(&mut s, &[a]);
// 2^32 + 50 wrapped to `dx = 50` and 3e9 to a negative offset through `as i32`.
for dx in [4_294_967_346_i64, 3_000_000_000_i64] {
let err = s.execute("layer.translate", json!({"dx": dx, "dy": 0})).unwrap_err();
assert!(err.to_string().contains("32-bit"), "{err}");
}
assert_eq!(bounds(&s, a), Rect::new(0, 0, 5, 5), "the layer never moved");
// Large in-range offsets still work.
s.execute("layer.translate", json!({"dx": -200_000, "dy": 200_000})).unwrap();
}
#[test]
fn link_layers_never_reuses_a_group_when_the_largest_id_is_u64_max() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 10, 10));
let b = rect_layer(&mut s, Rect::new(20, 20, 30, 30));
let c = rect_layer(&mut s, Rect::new(50, 50, 60, 60));
let d = rect_layer(&mut s, Rect::new(70, 70, 80, 80));
// A stored document can carry any id; `max + 1` once overflowed here.
let st = s.active_mut().unwrap();
for id in [c, d] {
std::sync::Arc::make_mut(&mut st.doc).layer_mut(id).unwrap().link_group = Some(u64::MAX);
}
select_all(&mut s, &[a, b]);
assert_eq!(s.execute("layer.linkLayers", json!({})).unwrap()["linked"], true);
let g = doc(&s).layer(a).unwrap().link_group;
assert_eq!(g, Some(1));
assert_eq!(doc(&s).layer(b).unwrap().link_group, g);
for id in [c, d] {
assert_eq!(doc(&s).layer(id).unwrap().link_group, Some(u64::MAX), "the existing group is untouched");
}
}
#[test]
fn undo_and_redo_report_only_the_edited_area() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
select_all(&mut s, &[a]);
// A pixel edit on one layer is bounded by that layer's extent on both sides.
s.edit("paint", |doc, _| {
doc.layer_mut(a).unwrap().surface_mut().unwrap().fill_rect(Rect::new(12, 12, 14, 14), &[0.0, 0.0, 1.0, 1.0]);
Ok(())
})
.unwrap();
s.undo();
assert_eq!(damage(&s), Some(Rect::new(10, 10, 20, 20)));
s.redo();
assert_eq!(damage(&s), Some(Rect::new(10, 10, 20, 20)));
// A move reports where the layer was and where it landed.
s.execute("layer.translate", json!({"dx": 5, "dy": 0})).unwrap();
s.undo();
assert_eq!(damage(&s), Some(Rect::new(10, 10, 25, 20)), "union of where the layer was and is");
s.redo();
assert_eq!(damage(&s), Some(Rect::new(10, 10, 25, 20)));
}
#[test]
fn undo_of_document_wide_steps_still_composites_everything() {
let mut s = session(8);
let _ = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
// A canvas change has no bounded damage.
s.execute("image.crop", json!({"x": 0, "y": 0, "width": 30, "height": 25})).unwrap();
assert_ne!(doc(&s).size, photocraft_doc::Size::new(100, 80));
s.undo();
assert_eq!(damage(&s), None, "a size change recomposites the whole canvas");
// A layer removed and restored changes only where it draws.
let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
select_all(&mut s, &[b]);
s.execute("layer.delete", json!({})).unwrap();
s.undo();
assert_eq!(damage(&s), Some(Rect::new(0, 0, 5, 5)));
}
#[test]
fn undo_of_compositor_read_document_fields_composites_everything() {
let mut s = session(8);
let _ = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
// Global Light changes every effect's angle across the document.
s.execute("layer.layerStyle.globalLight", json!({"angle": 90.0})).unwrap();
s.undo();
assert_eq!(damage(&s), None, "a global-light change recomposites everything");
// A mode change that keeps the pixel format (RGB → Indexed maps to RGB) neither.
s.execute("image.mode.indexedColor", json!({})).unwrap();
s.undo();
assert_eq!(damage(&s), None, "a mode change recomposites everything");
}
#[test]
fn undo_of_clipping_or_channel_exclusion_composites_everything() {
let mut s = session(8);
let _ = rect_layer(&mut s, Rect::new(10, 10, 20, 20));
let b = rect_layer(&mut s, Rect::new(12, 12, 30, 30));
select_all(&mut s, &[b]);
// Clipping reaches the layers clipped above, outside this layer's bounds.
s.execute("layer.setProps", json!({"clipped": true})).unwrap();
s.undo();
assert_eq!(damage(&s), None, "a clipping change recomposites everything");
s.execute("layer.setProps", json!({"channels": [true, false, true]})).unwrap();
s.undo();
assert_eq!(damage(&s), None, "an excluded-channel change recomposites everything");
}
#[test]
fn linked_layers_move_together_and_undo() {
for depth in [8, 16, 32] {
let mut s = session(depth);
let a = rect_layer(&mut s, Rect::new(0, 0, 10, 10));
let b = rect_layer(&mut s, Rect::new(20, 20, 30, 30));
let c = rect_layer(&mut s, Rect::new(50, 50, 60, 60));
assert!(!s.is_enabled("layer.linkLayers"));
select_all(&mut s, &[a, b]);
assert_eq!(s.execute("layer.linkLayers", json!({})).unwrap()["linked"], true);
let g = doc(&s).layer(a).unwrap().link_group;
assert!(g.is_some() && doc(&s).layer(b).unwrap().link_group == g);
// Move only a: b follows, c stays.
s.execute("layer.select", json!({"layer": a.0})).unwrap();
s.execute("layer.translate", json!({"dx": 5, "dy": 3})).unwrap();
assert_eq!(bounds(&s, a), Rect::new(5, 3, 15, 13));
assert_eq!(bounds(&s, b), Rect::new(25, 23, 35, 33));
assert_eq!(bounds(&s, c), Rect::new(50, 50, 60, 60));
s.undo();
assert_eq!(bounds(&s, a), Rect::new(0, 0, 10, 10));
assert_eq!(bounds(&s, b), Rect::new(20, 20, 30, 30));
// Select Linked Layers from just a.
s.execute("layer.selectLinkedLayers", json!({})).unwrap();
assert_eq!(sel(&s), vec![a, b]);
// Multi-selection translate moves all selected (c added, unlinked).
s.execute("layer.select", json!({"layer": c.0, "mode": "toggle"})).unwrap();
s.execute("layer.translate", json!({"dx": -1, "dy": 0})).unwrap();
assert_eq!(bounds(&s, c), Rect::new(49, 50, 59, 60));
assert_eq!(bounds(&s, a), Rect::new(-1, 0, 9, 10));
// Toggle: linking the same group again unlinks.
select_all(&mut s, &[a, b]);
assert_eq!(s.execute("layer.linkLayers", json!({})).unwrap()["linked"], false);
assert!(doc(&s).layer(a).unwrap().link_group.is_none());
}
}
/// Plain layers carrying stored link groups, as a loaded `.pcraft` or PSD can hold (#961).
fn stored_groups(s: &mut Session, groups: &[Option<u64>]) -> Vec<LayerId> {
let ids: Vec<LayerId> = groups.iter().map(|_| rect_layer(s, Rect::new(0, 0, 4, 4))).collect();
s.edit("load groups", |doc, _| {
for (id, g) in ids.iter().zip(groups) {
doc.layer_mut(*id).unwrap().link_group = *g;
}
Ok(())
})
.unwrap();
ids
}
fn group(s: &Session, id: LayerId) -> Option<u64> {
doc(s).layer(id).unwrap().link_group
}
/// Links `ids`, then checks they share one group no other layer uses (#961).
fn link_fresh(s: &mut Session, ids: &[LayerId]) -> u64 {
select_all(s, ids);
let past = s.active().unwrap().history.past_len();
assert_eq!(s.execute("layer.linkLayers", json!({})).unwrap()["linked"], true);
assert_eq!(s.active().unwrap().history.past_len(), past + 1);
let g = group(s, ids[0]).expect("linked");
assert!(ids.iter().all(|id| group(s, *id) == Some(g)));
let members = doc(s).walk().iter().filter(|(_, _, l)| l.link_group == Some(g)).count();
assert_eq!(members, ids.len(), "group {g} is shared with unselected layers");
g
}
#[test]
fn link_layers_beside_a_maximal_stored_group() {
// The issue's repro: one layer stored at u64::MAX, link it with an unlinked one.
let mut s = session(8);
let ids = stored_groups(&mut s, &[Some(u64::MAX), None]);
assert_ne!(link_fresh(&mut s, &ids), u64::MAX);
// Unlink and relink the pair: with no groups left, numbering starts over at 1.
assert_eq!(s.execute("layer.linkLayers", json!({})).unwrap()["linked"], false);
assert!(ids.iter().all(|id| group(&s, *id).is_none()));
assert_eq!(link_fresh(&mut s, &ids), 1);
// Two other layers linked beside an untouched maximal pair.
let mut s = session(8);
let ids = stored_groups(&mut s, &[Some(u64::MAX), Some(u64::MAX), None, None]);
let g = link_fresh(&mut s, &ids[2..]);
assert_ne!(g, u64::MAX);
assert_eq!((group(&s, ids[0]), group(&s, ids[1])), (Some(u64::MAX), Some(u64::MAX)));
}
#[test]
fn unlink_a_maximal_stored_group() {
let mut s = session(8);
let ids = stored_groups(&mut s, &[Some(u64::MAX), Some(u64::MAX), None]);
select_all(&mut s, &ids[..2]);
assert_eq!(s.execute("layer.linkLayers", json!({})).unwrap()["linked"], false);
assert!(ids.iter().all(|id| group(&s, *id).is_none()));
s.undo();
assert_eq!((group(&s, ids[0]), group(&s, ids[1])), (Some(u64::MAX), Some(u64::MAX)));
// Relinking all three gets a working group.
link_fresh(&mut s, &ids);
}
#[test]
fn link_layers_when_every_group_is_huge() {
// Unselected groups at the top of the range, including the 0 a wrapped id would join.
let top = [u64::MAX, u64::MAX - 1, u64::MAX - 2, 0, 1, 2];
let stored: Vec<Option<u64>> = top.iter().flat_map(|g| [Some(*g), Some(*g)]).chain([None, None, None, None]).collect();
let mut s = session(8);
let ids = stored_groups(&mut s, &stored);
let n = top.len() * 2;
let g = link_fresh(&mut s, &ids[n..n + 2]);
assert!(!top.contains(&g), "{g} collides with a stored group");
// A second link gets yet another group, and existing groups never change.
let h = link_fresh(&mut s, &ids[n + 2..]);
assert!(!top.contains(&h) && h != g);
for (i, t) in top.iter().enumerate() {
assert_eq!((group(&s, ids[2 * i]), group(&s, ids[2 * i + 1])), (Some(*t), Some(*t)));
}
// Moving a newly linked layer leaves the group-0 pair alone.
assert_eq!(with_links(doc(&s), &[ids[n]]), vec![ids[n], ids[n + 1]]);
}
#[test]
fn link_layers_near_the_maximum() {
// max + 1 still fits: the new group is u64::MAX itself.
let mut s = session(8);
let ids = stored_groups(&mut s, &[Some(u64::MAX - 1), Some(u64::MAX - 1), None, None, None, None]);
assert_eq!(link_fresh(&mut s, &ids[2..4]), u64::MAX);
// The next link no longer fits above the maximum and takes a free id instead.
let g = link_fresh(&mut s, &ids[4..]);
assert!(g != u64::MAX && g != u64::MAX - 1);
}
#[test]
fn link_layers_assigns_working_groups() {
// Control: ordinary documents keep getting max + 1, starting at 1.
let mut s = session(8);
let ids = stored_groups(&mut s, &[None, None, None, None]);
assert_eq!(link_fresh(&mut s, &ids[..2]), 1);
assert_eq!(link_fresh(&mut s, &ids[2..]), 2);
assert_eq!(s.execute("layer.linkLayers", json!({})).unwrap()["linked"], false);
assert_eq!((group(&s, ids[2]), group(&s, ids[3])), (None, None));
assert_eq!((group(&s, ids[0]), group(&s, ids[1])), (Some(1), Some(1)));
}
#[test]
fn selection_pruned_after_delete_and_undo() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let c = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
select_all(&mut s, &[a, c]);
// Deleting one layer explicitly prunes it from the set.
s.execute("layer.delete", json!({"layer": a.0})).unwrap();
assert_eq!(sel(&s), vec![c]);
s.undo();
assert!(sel(&s).iter().all(|id| doc(&s).layer(*id).is_some()));
// Deleting with several selected removes them all, then selects the layer below.
select_all(&mut s, &[a, c]);
s.execute("layer.delete", json!({})).unwrap();
assert!(doc(&s).layer(a).is_none() && doc(&s).layer(c).is_none());
assert_eq!(doc(&s).layer_count(), 2);
assert_eq!(sel(&s).len(), 1);
assert!(s.active().unwrap().selected_layers.iter().all(|id| doc(&s).layer(*id).is_some()));
s.undo();
assert_eq!(doc(&s).layer_count(), 4);
let _ = b;
// Redo then undo again keeps the set valid.
s.redo();
assert!(sel(&s).iter().all(|id| doc(&s).layer(*id).is_some()));
}
#[test]
fn duplicate_hide_lock_and_reverse_selected() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let c = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
select_all(&mut s, &[a, c]);
let r = s.execute("layer.duplicate", json!({})).unwrap();
assert_eq!(r["layers"].as_array().unwrap().len(), 2);
assert_eq!(doc(&s).layer_count(), 6);
assert_eq!(sel(&s).len(), 2);
assert!(sel(&s).iter().all(|id| *id != a && *id != c));
s.undo();
select_all(&mut s, &[a, b]);
s.execute("layer.hideLayers", json!({})).unwrap();
assert!(!doc(&s).layer(a).unwrap().visible && !doc(&s).layer(b).unwrap().visible && doc(&s).layer(c).unwrap().visible);
s.execute("layer.showLayers", json!({})).unwrap();
assert!(doc(&s).layer(a).unwrap().visible);
s.execute("layer.lockLayers", json!({})).unwrap();
assert!(doc(&s).layer(a).unwrap().locks.all && doc(&s).layer(b).unwrap().locks.all);
assert!(s.execute("layer.translate", json!({"dx": 1})).is_err(), "locked layers don't move");
s.execute("layer.lockLayers", json!({})).unwrap();
assert!(!doc(&s).layer(a).unwrap().locks.all);
s.execute("layer.lockLayers", json!({"position": true})).unwrap();
assert!(doc(&s).layer(b).unwrap().locks.position && !doc(&s).layer(c).unwrap().locks.position);
// Reverse a, b, c.
select_all(&mut s, &[a, b, c]);
s.execute("layer.arrange.reverse", json!({})).unwrap();
assert_eq!(doc(&s).layers.iter().skip(1).map(|l| l.id).collect::<Vec<_>>(), vec![c, b, a]);
assert_eq!(s.active().unwrap().history.entries().last().map(|e| e.as_str()), Some("Reverse"));
}
/// #4892: Lock Image Pixels includes Lock Transparent Pixels, so the two are never both on:
/// locking the pixels clears the transparency lock, which stays off while they are locked,
/// through both `layer.setProps` and `layer.lockLayers`.
#[test]
fn locking_pixels_clears_and_holds_off_the_transparency_lock() {
let mut s = Session::new();
s.execute("file.new", json!({"width": 8, "height": 8})).unwrap();
let id = LayerId(s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap());
let locks = |s: &Session| doc(s).layer(id).unwrap().locks;
s.execute("layer.setProps", json!({"locks": {"transparency": true}})).unwrap();
assert!(locks(&s).transparency);
s.execute("layer.setProps", json!({"locks": {"pixels": true}})).unwrap();
assert!(locks(&s).pixels && !locks(&s).transparency, "locking the pixels clears the transparency lock");
s.execute("layer.setProps", json!({"locks": {"transparency": true}})).unwrap();
assert!(!locks(&s).transparency, "and it stays off while the pixels are locked");
s.execute("layer.setProps", json!({"locks": {"transparency": true, "pixels": true}})).unwrap();
assert!(locks(&s).pixels && !locks(&s).transparency, "both at once: the pixel lock wins");
s.execute("layer.lockLayers", json!({"pixels": false})).unwrap();
s.execute("layer.lockLayers", json!({"transparency": true})).unwrap();
assert!(locks(&s).transparency && !locks(&s).pixels, "with the pixels unlocked it can be set again");
s.execute("layer.lockLayers", json!({"pixels": true})).unwrap();
assert!(locks(&s).pixels && !locks(&s).transparency);
assert!(s.execute("layer.setProps", json!({"locks": {"nope": true}})).is_err());
}
/// `document.inspect` lists the selected layers and marks them in the layer list.
#[test]
fn inspect_reports_selection() {
let mut s = session(8);
let a = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
let b = rect_layer(&mut s, Rect::new(0, 0, 5, 5));
select_all(&mut s, &[a, b]);
let v = s.execute("document.inspect", json!({})).unwrap();
assert_eq!(v["selectedLayers"], json!([a.0, b.0]));
assert_eq!(v["layers"][0]["selected"], true);
}
/// #7538: `selection: true` moves the selection with the layers in the same step, as the Move
/// tool does with several layers selected; without it the selection stays.
#[test]
fn translate_can_carry_the_selection_in_the_same_step() {
let mut s = Session::new();
s.execute("file.new", json!({"width": 100, "height": 100, "background": "transparent"})).unwrap();
let a = s.active().unwrap().active_layer.unwrap();
s.execute("select.rect", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
let b = LayerId(s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap());
s.execute("select.rect", json!({"x": 50, "y": 10, "width": 20, "height": 20})).unwrap();
s.execute("edit.fill", json!({"color": "#0000ff"})).unwrap();
s.execute("layer.select", json!({"layer": a.0, "mode": "add"})).unwrap();
s.execute("select.rect", json!({"x": 5, "y": 5, "width": 70, "height": 30})).unwrap();
let sel = |s: &Session| s.active().unwrap().doc.selection.as_ref().map(|m| m.content_bounds());
let bounds = |s: &Session, id: LayerId| s.active().unwrap().doc.layer(id).unwrap().surface().unwrap().content_bounds();
let steps = s.active().unwrap().history.past_len();
s.execute("layer.translate", json!({"dx": 7, "dy": 20, "selection": true})).unwrap();
assert_eq!((bounds(&s, a), bounds(&s, b)), (Rect::new(17, 30, 37, 50), Rect::new(57, 30, 77, 50)));
assert_eq!(sel(&s), Some(Rect::new(12, 25, 82, 55)), "the selection came along");
assert_eq!(s.active().unwrap().history.past_len(), steps + 1, "one step");
s.undo();
assert_eq!((sel(&s), bounds(&s, a)), (Some(Rect::new(5, 5, 75, 35)), Rect::new(10, 10, 30, 30)), "undone together");
s.execute("layer.translate", json!({"dx": 7, "dy": 20})).unwrap();
assert_eq!(sel(&s), Some(Rect::new(5, 5, 75, 35)), "without it the selection stays");
let state = |s: &Session| (bounds(s, a), bounds(s, b), sel(s), s.active().unwrap().history.past_len());
let before = state(&s);
for dx in [1, 0] {
assert!(s.execute("layer.translate", json!({"dx": dx, "selection": "yes"})).is_err(), "dx {dx}: a bad `selection` is an error");
assert_eq!(state(&s), before, "dx {dx}: and changes nothing");
}
}
}
#[cfg(test)]
mod layers_panel_parity_tests {
use super::*;
/// A 24×16 document with three layers, "Test 0" to "Test 2", above the Background; the last one is active.
fn new_session() -> (Session, Vec<LayerId>) {
let mut s = Session::new();
s.execute("file.new", json!({"width": 24, "height": 16})).unwrap();
let ids = (0..3).map(|n| LayerId(s.execute("layer.new.layer", json!({"name": format!("Test {n}")})).unwrap()["layer"].as_u64().unwrap())).collect();
(s, ids)
}
/// Set one Layers panel option in the preferences, as the Panel Options dialog does.
fn option(s: &mut Session, key: &str, enabled: bool) {
s.prefs.edit(|p| {
let val = p.dialogs.entry("ui.layersPanelOptions".into()).or_insert_with(|| json!({}));
if let Some(o) = val.as_object_mut() {
o.insert(key.to_owned(), json!(enabled));
}
});
}
/// The drag preview equals the committed `layer.moveTo` result and never touches the document or its history.
#[test]
fn preview_matches_real_move_and_never_edits_document_or_history() {
let (mut s, ids) = new_session();
let params = json!({"layer": ids[0].0, "target": ids[2].0, "position": "above"});
let before = s.active().unwrap().doc.clone();
let undo_before = s.active().unwrap().history.entries().len();
let candidate = preview_move(&before, ¶ms, true).unwrap();
assert_eq!(*before, *s.active().unwrap().doc);
assert_eq!(s.active().unwrap().history.entries().len(), undo_before);
s.execute("layer.moveTo", params).unwrap();
assert_eq!(candidate, *s.active().unwrap().doc, "visual preview must match committed layer order");
}
/// A previewed ⌥-drag copy names its layers like the committed copy, with and without the "copy" suffix option.
#[test]
fn preview_copy_and_no_copy_suffix_option_match_committed_layers() {
let (mut s, ids) = new_session();
option(&mut s, "addCopyToCopiedLayersAndGroups", false);
let params = json!({"layer": ids[0].0, "target": ids[2].0, "position": "below", "copy": true});
let before = s.active().unwrap().doc.clone();
let candidate = preview_move(&before, ¶ms, false).unwrap();
s.execute("layer.moveTo", params).unwrap();
let actual = &s.active().unwrap().doc;
assert_eq!(candidate.layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), actual.layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>());
assert_eq!(actual.layer_count(), before.layer_count() + 1);
assert_eq!(actual.layers.iter().filter(|l| l.name == "Test 0").count(), 2);
let d = s.execute("layer.duplicate", json!({"layer": ids[1].0})).unwrap();
let duplicate = LayerId(d["layer"].as_u64().unwrap());
assert_eq!(s.active().unwrap().doc.layer(duplicate).unwrap().name, "Test 1");
option(&mut s, "addCopyToCopiedLayersAndGroups", true);
let d = s.execute("layer.duplicate", json!({"layer": ids[1].0})).unwrap();
assert!(s.active().unwrap().doc.layer(LayerId(d["layer"].as_u64().unwrap())).unwrap().name.contains("copy"));
}
/// Drops the command refuses (or ignores) give no preview and leave the document alone; a multi-layer preview follows the committed stack order.
#[test]
fn preview_rejects_invalid_drop_unchanged() {
let (mut s, ids) = new_session();
let before = s.active().unwrap().doc.clone();
// Dropping a layer on itself is a no-op for the command, the others are errors.
for (p, command_rejects) in [
(json!({"layer": ids[1].0, "target": ids[1].0, "position": "above"}), false),
(json!({"layer": ids[1].0, "target": 999999, "position": "below"}), true),
(json!({"layer": ids[1].0, "target": ids[2].0, "position": "into"}), true),
(json!({"layer": ids[1].0, "target": ids[2].0, "position": "invalid"}), true),
] {
assert!(preview_move(&before, &p, true).is_none(), "{p}");
let result = s.execute("layer.moveTo", p.clone());
if command_rejects {
assert!(result.is_err(), "{p}");
} else {
assert_eq!(result.unwrap(), Value::Null, "{p}");
}
assert_eq!(*before, *s.active().unwrap().doc, "{p}");
}
// Multi-layer preview and commit follow the same stack order regardless of params order.
let p = json!({"layers": [ids[2].0, ids[0].0], "target": ids[1].0, "position": "below"});
let candidate = preview_move(&before, &p, true).unwrap();
s.execute("layer.moveTo", p).unwrap();
assert_eq!(candidate, *s.active().unwrap().doc);
}
/// A 16×16 document holding `spec` (bottom to top, `*` = clipped) above its Background. Every
/// layer is a translucent, differently placed rectangle, so the stack order and the clip
/// groups both show in the composite.
fn clip_stack(spec: &str) -> Session {
let mut s = Session::new();
s.execute("file.new", json!({"width": 16, "height": 16})).unwrap();
for (n, name) in spec.split_whitespace().enumerate() {
let id = LayerId(s.execute("layer.new.layer", json!({"name": name.trim_end_matches('*')})).unwrap()["layer"].as_u64().unwrap());
let n = n as i32;
let colour = [(n % 3) as f32 * 0.5, ((n + 1) % 3) as f32 * 0.5, ((n + 2) % 3) as f32 * 0.5, 0.6];
s.edit("paint", |doc, _| {
let layer = doc.layer_mut(id).unwrap();
layer.clipped = name.ends_with('*');
layer.surface_mut().unwrap().fill_rect(Rect::new(n * 2, 0, n * 2 + 10, 16), &colour);
Ok(())
})
.unwrap();
}
s
}
/// Every layer of `doc` from the bottom, `*` marking the clipped ones.
fn stack_text(doc: &Document) -> String {
doc.layers.iter().map(|l| format!("{}{}", l.name, if l.clipped { "*" } else { "" })).collect::<Vec<_>>().join(" ")
}
/// The id of the layer called `name`, searching the whole layer tree.
fn id_of(s: &Session, name: &str) -> u64 {
s.active().unwrap().doc.walk().into_iter().find(|(_, _, l)| l.name == name).unwrap().2.id.0
}
/// The preview of `params` and the committed `layer.moveTo` show the same stack (names, clip
/// flags) and the same composite, and both are `want`.
fn assert_preview_is_commit(mut s: Session, params: Value, want: &str) {
let before = s.active().unwrap().doc.clone();
let preview = preview_move(&before, ¶ms, true).expect("the drop has a preview");
s.execute("layer.moveTo", params.clone()).unwrap();
let committed = &s.active().unwrap().doc;
assert_eq!(stack_text(&preview), want, "preview of {params}");
assert_eq!(stack_text(committed), want, "commit of {params}");
assert_eq!(photocraft_compose::flatten(&preview).px, photocraft_compose::flatten(committed).px, "composite of {params}");
}
/// Previewed moves join and release clipping groups exactly as the committed reorder does, copies included.
#[test]
fn preview_follows_clip_groups_like_the_committed_reorder() {
// The fixtures of `clip_group::reorder_joins_and_leaves_groups`.
for (spec, layers, target, pos, want) in [
// A layer dropped into a clip group joins it.
("B C1* C2* U", vec!["U"], "C1", "above", "Background B C1* U* C2*"),
("B C1* C2* U V", vec!["U", "V"], "C1", "above", "Background B C1* U* V* C2*"),
// A clipped layer dropped off its group is released.
("B C1* C2* U", vec!["C1"], "U", "above", "Background B C2* U C1"),
// A base moved away releases the layers clipped to it.
("B C1* C2* U", vec!["B"], "U", "above", "Background C1 C2 U B"),
// A base moved up into its own group joins it, and the layers it left are released.
("B C1* C2*", vec!["B"], "C1", "above", "Background C1 B* C2"),
("X B C1* C2* U", vec!["B", "C1"], "U", "above", "Background X C2 U B C1*"),
] {
let s = clip_stack(spec);
let ids: Vec<u64> = layers.iter().map(|n| id_of(&s, n)).collect();
let t = id_of(&s, target);
assert_preview_is_commit(s, json!({"layers": ids, "target": t, "position": pos}), want);
}
// An option-drag copy joins the clip group it lands in too.
let s = clip_stack("B C1* C2* U");
let (u, c1) = (id_of(&s, "U"), id_of(&s, "C1"));
assert_preview_is_commit(s, json!({"layer": u, "target": c1, "position": "above", "copy": true}), "Background B C1* U copy* C2* U");
}
/// Copying the locked Background in a preview gives the same unlocked copy, joining the clip group it lands in, as the command.
#[test]
fn preview_copies_the_background_like_the_committed_copy() {
let mut s = clip_stack("A B*");
let (bg, a) = (s.active().unwrap().doc.background().unwrap().id, id_of(&s, "A"));
let before = s.active().unwrap().doc.clone();
assert_ne!(before.layer(bg).unwrap().locks, Default::default(), "the Background is locked");
let p = json!({"layer": bg.0, "target": a, "position": "above", "copy": true});
let preview = preview_move(&before, &p, true).unwrap();
s.execute("layer.moveTo", p).unwrap();
let committed = &s.active().unwrap().doc;
// The copy is an ordinary, unlocked layer that joins the clip group it lands in.
assert_eq!(stack_text(committed), "Background A Background copy* B*");
assert_eq!(stack_text(&preview), stack_text(committed));
for doc in [&preview, committed] {
assert_eq!(doc.layers.get(2).unwrap().locks, Default::default());
assert!(doc.layers.first().unwrap().locks != Default::default());
}
assert_eq!(photocraft_compose::flatten(&preview).px, photocraft_compose::flatten(committed).px);
}
/// A drop that would move the Background off the bottom has no preview, as the command refuses it.
#[test]
fn preview_refuses_what_would_leave_the_background_off_the_bottom() {
let mut s = clip_stack("A B");
let (bg, a) = (s.active().unwrap().doc.background().unwrap().id, id_of(&s, "A"));
let before = s.active().unwrap().doc.clone();
for p in [
json!({"layer": a, "target": bg.0, "position": "below"}),
json!({"layer": bg.0, "target": bg.0, "position": "below", "copy": true}),
json!({"layer": a, "target": bg.0, "position": "below", "copy": true}),
] {
assert!(preview_move(&before, &p, true).is_none(), "{p}");
assert!(s.execute("layer.moveTo", p.clone()).is_err(), "{p}");
assert_eq!(*before, *s.active().unwrap().doc, "{p}");
}
}
/// The UI runs commands through `start`; Expand New Effects applies there as well as to `execute`.
#[test]
fn expand_new_effects_applies_to_ui_start_dispatch_too() {
let (mut s, ids) = new_session();
option(&mut s, "expandNewEffects", false);
let target = ids[0];
let started = s.start("layer.layerStyle.dropShadow", json!({"layer": target.0})).unwrap();
assert!(matches!(started, crate::jobs::Started::Done(_)));
assert!(s.active().unwrap().fx_collapsed.contains(&target));
}
/// New Solid Color and Gradient fill layers get the default mask only while Use Default Masks on Fill Layers is on.
#[test]
fn fill_layers_respect_use_default_masks_option() {
let (mut s, _) = new_session();
option(&mut s, "useDefaultMasksOnFillLayers", false);
let new = s.execute("layer.newFillLayer.solidColor", json!({"color": "#112233"})).unwrap();
let id = LayerId(new["layer"].as_u64().unwrap());
assert!(s.active().unwrap().doc.layer(id).unwrap().mask.is_none());
option(&mut s, "useDefaultMasksOnFillLayers", true);
let new = s.execute("layer.newFillLayer.gradient", json!({})).unwrap();
let id = LayerId(new["layer"].as_u64().unwrap());
assert!(s.active().unwrap().doc.layer(id).unwrap().mask.is_some());
}
/// With the option off only the default reveal-all mask goes away: an active selection still
/// becomes the layer mask and an explicit path still becomes the vector mask (path first).
#[test]
fn fill_layers_without_default_masks_keep_selection_and_explicit_path_masks() {
const KINDS: [(&str, &str); 3] = [
("layer.newFillLayer.solidColor", r##"{"color": "#112233"}"##),
("layer.newFillLayer.gradient", "{}"),
("layer.newFillLayer.pattern", r#"{"pattern": "Checkerboard"}"#),
];
let path = json!({"subpaths": [{"closed": true, "knots": [[2, 2], [10, 2], [10, 10], [2, 10]]}]});
let (mut s, _) = new_session();
option(&mut s, "useDefaultMasksOnFillLayers", false);
// Creates the fill layer; returns its raster mask and whether it has a vector mask.
let create = |s: &mut Session, cmd: &str, params: &str, path: Option<&Value>| {
let mut p: Value = serde_json::from_str(params).unwrap();
if let Some(path) = path {
p["path"] = path.clone();
}
let id = LayerId(s.execute(cmd, p).unwrap()["layer"].as_u64().unwrap());
let l = s.active().unwrap().doc.layer(id).unwrap();
(l.mask.clone(), l.vector_mask.is_some())
};
for (cmd, params) in KINDS {
let (mask, vector) = create(&mut s, cmd, params, None);
assert!(mask.is_none() && !vector, "{cmd}: no selection, no path: no mask at all");
}
s.execute("select.rect", json!({"x": 4, "y": 4, "width": 8, "height": 6})).unwrap();
for (cmd, params) in KINDS {
let (mask, vector) = create(&mut s, cmd, params, None);
let mask = mask.unwrap_or_else(|| panic!("{cmd}: the selection still becomes the layer mask"));
assert!(!vector, "{cmd}");
assert!(mask.surface.pixel(6, 6)[0] > 0.99, "{cmd}: inside the selection reveals");
assert!(mask.surface.pixel(20, 12)[0] < 0.01, "{cmd}: outside the selection hides");
}
// An explicit path wins over the selection, as with the option on.
for selected in [true, false] {
if !selected {
s.execute("select.deselect", json!({})).unwrap();
}
for (cmd, params) in KINDS {
let (mask, vector) = create(&mut s, cmd, params, Some(&path));
assert!(vector, "{cmd}: the explicit path becomes the vector mask (selection: {selected})");
assert!(mask.is_none(), "{cmd}: no raster mask next to the vector mask (selection: {selected})");
}
}
}
/// Whether new effects start expanded is view state: it adds no history step, and editing an existing effect keeps its disclosure.
#[test]
fn expand_new_effects_is_view_state_and_keeps_edit_history_clean() {
let (mut s, ids) = new_session();
option(&mut s, "expandNewEffects", false);
let target = ids[0];
let history = s.active().unwrap().history.entries().len();
s.execute("layer.layerStyle.dropShadow", json!({"layer": target.0, "size": 2})).unwrap();
assert_eq!(s.active().unwrap().history.entries().len(), history + 1);
assert!(s.active().unwrap().fx_collapsed.contains(&target));
option(&mut s, "expandNewEffects", true);
let other = ids[1];
s.execute("layer.layerStyle.stroke", json!({"layer": other.0, "size": 2})).unwrap();
assert!(!s.active().unwrap().fx_collapsed.contains(&other));
// Editing the existing effect must not unexpectedly change its disclosure.
s.execute("layer.layerStyle.dropShadow", json!({"layer": target.0, "size": 5})).unwrap();
assert!(s.active().unwrap().fx_collapsed.contains(&target));
}
/// The disclosure follows the layer the command changes, however the command names it: a
/// layer given by name is not the active one.
#[test]
fn expand_new_effects_follows_a_layer_named_by_its_name() {
let (mut s, ids) = new_session();
option(&mut s, "expandNewEffects", false);
let (named, active) = (ids[0], ids[2]);
assert_eq!(s.active().unwrap().active_layer, Some(active));
s.execute("layer.layerStyle.dropShadow", json!({"layer": "Test 0", "size": 2})).unwrap();
assert!(s.active().unwrap().doc.layer(named).is_some_and(|l| !l.effects.items.is_empty()));
assert!(s.active().unwrap().fx_collapsed.contains(&named), "the named layer's new effects start collapsed");
assert!(!s.active().unwrap().fx_collapsed.contains(&active), "the active layer is not the one changed");
}
/// Transfer Effects changes the layer it moves the effects to, so that is the layer whose
/// disclosure follows the option, not the active layer or the one the effects came from.
#[test]
fn expand_new_effects_follows_the_transfer_destination() {
let (mut s, ids) = new_session();
let (from, to, active) = (ids[0], ids[1], ids[2]);
s.execute("layer.layerStyle.dropShadow", json!({"layer": from.0, "size": 2})).unwrap();
option(&mut s, "expandNewEffects", false);
assert_eq!(s.active().unwrap().active_layer, Some(active));
s.execute("layer.layerStyle.transferEffects", json!({"from": from.0, "to": to.0, "copy": true})).unwrap();
assert!(s.active().unwrap().doc.layer(to).is_some_and(|l| !l.effects.items.is_empty()));
assert!(s.active().unwrap().fx_collapsed.contains(&to), "the destination's new effects start collapsed");
assert!(!s.active().unwrap().fx_collapsed.contains(&active), "the active layer is not the one changed");
}
}