PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
refactor(edit): fold duplicated image scope and arrange helpers
FredAppseb0d5e64c700
diff --git a/crates/edit/src/images.rs b/crates/edit/src/images.rsindex 9be1568c9..37ca089fe 100644--- a/crates/edit/src/images.rs+++ b/crates/edit/src/images.rs@@ -547,88 +547,46 @@ pub(crate) fn is_entire_page_wrapped(ops: &[Op]) -> bool {depth == 0}+/// The end (exclusive) of the sequence opened at `i`: just past the `close` that matches it,+/// counting the nested `opens`, or `end` when it never closes.+fn sequence_end(ops: &[Op], i: usize, end: usize, opens: &[&str], close: &str) -> usize {+ let mut depth: usize = 1;+ for (j, op) in ops.iter().enumerate().take(end).skip(i.saturating_add(1)) {+ if opens.iter().any(|o| op.is(o)) {+ depth = depth.saturating_add(1);+ } else if op.is(close) {+ depth = depth.saturating_sub(1);+ if depth == 0 {+ return j.saturating_add(1);+ }+ }+ }+ end+}+pub(crate) fn content_units(ops: &[Op], scan_start: usize, scan_end: usize) -> Vec<std::ops::Range<usize>> {let mut units = Vec::new();let mut i = scan_start;while i < scan_end {- let op = match ops.get(i) {- Some(o) => o,- None => break,- };- if op.is("BDC") || op.is("BMC") {+ let Some(op) = ops.get(i) else { break };+ let j = if op.is("BDC") || op.is("BMC") {// A marked-content sequence is one unit up to its matching EMC (#3145), so Arrange moves// it whole and never inserts into another one: its content belongs to its tag (ISO 32000-2// § 14.6). An unbalanced sequence runs to the end of the scan.- let mut depth: usize = 1;- let mut j = i.saturating_add(1);- while j < scan_end {- if let Some(next) = ops.get(j) {- if next.is("BDC") || next.is("BMC") {- depth = depth.saturating_add(1);- } else if next.is("EMC") {- depth = depth.saturating_sub(1);- if depth == 0 {- j = j.saturating_add(1);- break;- }- }- }- j = j.saturating_add(1);- }- units.push(i..j);- i = j;+ sequence_end(ops, i, scan_end, &["BDC", "BMC"], "EMC")} else if op.is("q") {- let mut depth: usize = 1;- let mut j = i.saturating_add(1);- while j < scan_end {- if let Some(next) = ops.get(j) {- if next.is("q") {- depth = depth.saturating_add(1);- } else if next.is("Q") {- depth = depth.saturating_sub(1);- if depth == 0 {- j = j.saturating_add(1);- break;- }- }- }- j = j.saturating_add(1);- }- units.push(i..j);- i = j;+ sequence_end(ops, i, scan_end, &["q"], "Q")} else if op.is("BT") {- let mut j = i.saturating_add(1);- while j < scan_end {- if ops.get(j).is_some_and(|o| o.is("ET")) {- j = j.saturating_add(1);- break;- }- j = j.saturating_add(1);- }- units.push(i..j);- i = j;+ sequence_end(ops, i, scan_end, &[], "ET")} else if op.is("BI") {- let mut j = i.saturating_add(1);- while j < scan_end {- if ops.get(j).is_some_and(|o| o.is("EI")) {- j = j.saturating_add(1);- break;- }- j = j.saturating_add(1);- }- units.push(i..j);- i = j;+ sequence_end(ops, i, scan_end, &[], "EI")} else if op.is("Do") || op.is("sh") {- units.push(i..i.saturating_add(1));- i = i.saturating_add(1);+ i.saturating_add(1)} else {let mut j = i;let mut found_end = false;while j < scan_end {- let next = match ops.get(j) {- Some(o) => o,- None => break,- };+ let Some(next) = ops.get(j) else { break };if matches!(next.op.as_slice(), b"S" | b"s" | b"f" | b"F" | b"f*" | b"B" | b"B*" | b"b" | b"b*" | b"n") {j = j.saturating_add(1);found_end = true;@@ -644,10 +602,10 @@ pub(crate) fn content_units(ops: &[Op], scan_start: usize, scan_end: usize) -> V}j = j.saturating_add(1);}- let u_end = if found_end { j } else { scan_end.max(i.saturating_add(1)) };- units.push(i..u_end);- i = u_end;- }+ if found_end { j } else { scan_end.max(i.saturating_add(1)) }+ };+ units.push(i..j);+ i = j;}units.retain(|u| {ops.get(u.clone()).is_some_and(|slice| {@@ -778,17 +736,26 @@ impl ExtendedGStateTracker {}}+/// The drawing-state operators besides colour that a moved unit restores, in the order it writes them.+const DRAWING_PARAMS: [&str; 7] = ["w", "J", "j", "M", "d", "ri", "i"];+#[derive(Clone, Default, Debug, PartialEq)]struct DrawingState {non_stroking_color: Option<Vec<Op>>,stroking_color: Option<Vec<Op>>,- line_width: Option<Op>,- line_cap: Option<Op>,- line_join: Option<Op>,- miter_limit: Option<Op>,- dash_pattern: Option<Op>,- rendering_intent: Option<Op>,- flatness: Option<Op>,+ /// The last operator of each of [`DRAWING_PARAMS`].+ params: [Option<Op>; 7],+}++/// `sc`/`scn` (or `SC`/`SCN`) after the colour space operator `space` keep that space.+fn set_color(slot: &mut Option<Vec<Op>>, op: &Op, space: &str) {+ match slot {+ Some(ops) if ops.first().is_some_and(|o| o.is(space)) => {+ ops.truncate(1);+ ops.push(op.clone());+ }+ _ => *slot = Some(vec![op.clone()]),+ }}#[derive(Clone, Default, Debug)]@@ -811,224 +778,78 @@ impl DrawingStateTracker {self.current = prev;}}- b"g" | b"rg" | b"k" => {- self.current.non_stroking_color = Some(vec![op.clone()]);- }- b"cs" => {- self.current.non_stroking_color = Some(vec![op.clone()]);- }- b"sc" | b"scn" => {- if let Some(ref mut ops) = self.current.non_stroking_color {- if ops.first().is_some_and(|o| o.is("cs")) {- ops.truncate(1);- ops.push(op.clone());- } else {- *ops = vec![op.clone()];- }- } else {- self.current.non_stroking_color = Some(vec![op.clone()]);- }- }- b"G" | b"RG" | b"K" => {- self.current.stroking_color = Some(vec![op.clone()]);- }- b"CS" => {- self.current.stroking_color = Some(vec![op.clone()]);- }- b"SC" | b"SCN" => {- if let Some(ref mut ops) = self.current.stroking_color {- if ops.first().is_some_and(|o| o.is("CS")) {- ops.truncate(1);- ops.push(op.clone());- } else {- *ops = vec![op.clone()];- }- } else {- self.current.stroking_color = Some(vec![op.clone()]);+ b"g" | b"rg" | b"k" | b"cs" => self.current.non_stroking_color = Some(vec![op.clone()]),+ b"sc" | b"scn" => set_color(&mut self.current.non_stroking_color, op, "cs"),+ b"G" | b"RG" | b"K" | b"CS" => self.current.stroking_color = Some(vec![op.clone()]),+ b"SC" | b"SCN" => set_color(&mut self.current.stroking_color, op, "CS"),+ _ => {+ if let Some(slot) = DRAWING_PARAMS.iter().position(|p| op.is(p)).and_then(|k| self.current.params.get_mut(k)) {+ *slot = Some(op.clone());}}- b"w" => {- self.current.line_width = Some(op.clone());- }- b"J" => {- self.current.line_cap = Some(op.clone());- }- b"j" => {- self.current.line_join = Some(op.clone());- }- b"M" => {- self.current.miter_limit = Some(op.clone());- }- b"d" => {- self.current.dash_pattern = Some(op.clone());- }- b"ri" => {- self.current.rendering_intent = Some(op.clone());- }- b"i" => {- self.current.flatness = Some(op.clone());- }- _ => {}}Ok(())}}+/// The value a line-style parameter has when a page starts (ISO 32000-2 Table 51). The rendering+/// intent and flatness have none to restore here.+fn initial_param(name: &str) -> Option<Op> {+ use pdfcraft_content::num;+ let operands = match name {+ "w" => vec![num(1.0)],+ "J" | "j" => vec![num(0.0)],+ "M" => vec![num(10.0)],+ "d" => vec![Object::Array(vec![]), num(0.0)],+ _ => return None,+ };+ Some(Op::new(name, operands))+}++/// The drawing state the image had at `source` that differs at `dest`, unless the moved unit's own+/// state operators (`extracted_state_ops`) set it.fn compute_inherited_drawing_ops(source: &DrawingState, dest: &DrawingState, extracted_state_ops: &[Op]) -> Vec<Op> {+ let sets = |names: &[&str]| extracted_state_ops.iter().any(|o| names.iter().any(|n| o.is(n)));let mut ops = Vec::new();-- // 1. Non-stroking color- let has_non_stroking = extracted_state_ops.iter().any(|o| matches!(o.op.as_slice(), b"g" | b"rg" | b"k" | b"sc" | b"scn"));- if !has_non_stroking {- if let Some(ref color_ops) = source.non_stroking_color {- ops.extend(color_ops.iter().cloned());- } else if dest.non_stroking_color.is_some() {- ops.push(Op::new("g", vec![pdfcraft_content::num(0.0)]));+ for (own, source, dest, black) in [+ (sets(&["g", "rg", "k", "sc", "scn"]), &source.non_stroking_color, &dest.non_stroking_color, "g"),+ (sets(&["G", "RG", "K", "SC", "SCN"]), &source.stroking_color, &dest.stroking_color, "G"),+ ] {+ match (own, source, dest) {+ (true, _, _) | (false, None, None) => {}+ (false, Some(color), _) => ops.extend(color.iter().cloned()),+ (false, None, Some(_)) => ops.push(Op::new(black, vec![pdfcraft_content::num(0.0)])),}}-- // 2. Stroking color- let has_stroking = extracted_state_ops.iter().any(|o| matches!(o.op.as_slice(), b"G" | b"RG" | b"K" | b"SC" | b"SCN"));- if !has_stroking {- if let Some(ref color_ops) = source.stroking_color {- ops.extend(color_ops.iter().cloned());- } else if dest.stroking_color.is_some() {- ops.push(Op::new("G", vec![pdfcraft_content::num(0.0)]));+ for ((name, source), dest) in DRAWING_PARAMS.iter().zip(&source.params).zip(&dest.params) {+ match (sets(&[name]), source, dest) {+ (true, _, _) | (false, None, None) => {}+ (false, Some(op), _) => ops.push(op.clone()),+ (false, None, Some(_)) => ops.extend(initial_param(name)),}}-- // 3. Line width- if !extracted_state_ops.iter().any(|o| o.is("w")) {- if let Some(ref op) = source.line_width {- ops.push(op.clone());- } else if dest.line_width.is_some() {- ops.push(Op::new("w", vec![pdfcraft_content::num(1.0)]));- }- }-- // 4. Line cap- if !extracted_state_ops.iter().any(|o| o.is("J")) {- if let Some(ref op) = source.line_cap {- ops.push(op.clone());- } else if dest.line_cap.is_some() {- ops.push(Op::new("J", vec![pdfcraft_content::num(0.0)]));- }- }-- // 5. Line join- if !extracted_state_ops.iter().any(|o| o.is("j")) {- if let Some(ref op) = source.line_join {- ops.push(op.clone());- } else if dest.line_join.is_some() {- ops.push(Op::new("j", vec![pdfcraft_content::num(0.0)]));- }- }-- // 6. Miter limit- if !extracted_state_ops.iter().any(|o| o.is("M")) {- if let Some(ref op) = source.miter_limit {- ops.push(op.clone());- } else if dest.miter_limit.is_some() {- ops.push(Op::new("M", vec![pdfcraft_content::num(10.0)]));- }- }-- // 7. Dash pattern- if !extracted_state_ops.iter().any(|o| o.is("d")) {- if let Some(ref op) = source.dash_pattern {- ops.push(op.clone());- } else if dest.dash_pattern.is_some() {- ops.push(Op::new("d", vec![Object::Array(vec![]), pdfcraft_content::num(0.0)]));- }- }-- // 8. Rendering intent- if !extracted_state_ops.iter().any(|o| o.is("ri"))- && let Some(ref op) = source.rendering_intent- {- ops.push(op.clone());- }-- // 9. Flatness- if !extracted_state_ops.iter().any(|o| o.is("i"))- && let Some(ref op) = source.flatness- {- ops.push(op.clone());- }-ops}-fn clip_path_to_ops(clip: &ClipPath) -> Vec<Op> {+/// The operators that set `clip` again, in user space. [`ImageState`] builds clips only from+/// finite points with `m`, `l`, `c` and `h`, so `None` (a quadratic segment) does not happen.+fn clip_path_to_ops(clip: &ClipPath) -> Option<Vec<Op>> {let mut ops = Vec::new();- let mut current_pt = Point::ZERO;for el in clip.path.elements() {- match el {- kurbo::PathEl::MoveTo(p) => {- if !p.x.is_finite() || !p.y.is_finite() {- return Vec::new();- }- current_pt = *p;- ops.push(Op::new("m", vec![pdfcraft_content::num(p.x), pdfcraft_content::num(p.y)]));- }- kurbo::PathEl::LineTo(p) => {- if !p.x.is_finite() || !p.y.is_finite() {- return Vec::new();- }- current_pt = *p;- ops.push(Op::new("l", vec![pdfcraft_content::num(p.x), pdfcraft_content::num(p.y)]));- }- kurbo::PathEl::QuadTo(p1, p2) => {- if !p1.x.is_finite() || !p1.y.is_finite() || !p2.x.is_finite() || !p2.y.is_finite() {- return Vec::new();- }- let c1_x = current_pt.x + (p1.x - current_pt.x) * (2.0 / 3.0);- let c1_y = current_pt.y + (p1.y - current_pt.y) * (2.0 / 3.0);- let c2_x = p2.x + (p1.x - p2.x) * (2.0 / 3.0);- let c2_y = p2.y + (p1.y - p2.y) * (2.0 / 3.0);- if !c1_x.is_finite() || !c1_y.is_finite() || !c2_x.is_finite() || !c2_y.is_finite() {- return Vec::new();- }- current_pt = *p2;- ops.push(Op::new(- "c",- vec![- pdfcraft_content::num(c1_x),- pdfcraft_content::num(c1_y),- pdfcraft_content::num(c2_x),- pdfcraft_content::num(c2_y),- pdfcraft_content::num(p2.x),- pdfcraft_content::num(p2.y),- ],- ));- }- kurbo::PathEl::CurveTo(p1, p2, p3) => {- if !p1.x.is_finite() || !p1.y.is_finite() || !p2.x.is_finite() || !p2.y.is_finite() || !p3.x.is_finite() || !p3.y.is_finite() {- return Vec::new();- }- current_pt = *p3;- ops.push(Op::new(- "c",- vec![- pdfcraft_content::num(p1.x),- pdfcraft_content::num(p1.y),- pdfcraft_content::num(p2.x),- pdfcraft_content::num(p2.y),- pdfcraft_content::num(p3.x),- pdfcraft_content::num(p3.y),- ],- ));- }- kurbo::PathEl::ClosePath => {- ops.push(Op::new("h", vec![]));- }- }+ let (name, points) = match el {+ kurbo::PathEl::MoveTo(p) => ("m", vec![*p]),+ kurbo::PathEl::LineTo(p) => ("l", vec![*p]),+ kurbo::PathEl::CurveTo(p1, p2, p3) => ("c", vec![*p1, *p2, *p3]),+ kurbo::PathEl::ClosePath => ("h", Vec::new()),+ kurbo::PathEl::QuadTo(..) => return None,+ };+ ops.push(Op::new(name, points.iter().flat_map(|p| [pdfcraft_content::num(p.x), pdfcraft_content::num(p.y)]).collect()));}if !ops.is_empty() {ops.push(Op::new(if clip.even_odd { "W*" } else { "W" }, vec![]));ops.push(Op::new("n", vec![]));}- ops+ Some(ops)}pub(crate) fn extract_scope_state(ops: &[Op], start: usize, target: usize, initial_ctm: Matrix) -> Result<Option<ExtractedScopeState>, EditError> {@@ -1131,7 +952,8 @@ pub(crate) fn extract_scope_state(ops: &[Op], start: usize, target: usize, initiOk(Some(ExtractedScopeState { clip_ops, state_ops, do_op: target_op }))}-/// Change the stacking order of image `index` on `page`.+/// The unit `order` puts the image's unit `target_idx` next to, and whether after it. An image that+/// shares its unit with other paint at the limit moves within that unit, past or behind the paint.fn target_destination_unit<'a>(units: &'a [std::ops::Range<usize>],target_idx: usize,@@ -1139,83 +961,48 @@ fn target_destination_unit<'a>(order: ArrangeOrder,has_other_paint: bool,) -> Result<(&'a std::ops::Range<usize>, bool), EditError> {- match order {- ArrangeOrder::BringToFront => {- if target_idx == units.len().saturating_sub(1) {- if has_other_paint { Ok((target_unit, true)) } else { Err(EditError::Invalid("the image is already in front".into())) }- } else {- let u = units.last().ok_or_else(|| EditError::Invalid("the image is already in front".into()))?;- Ok((u, true))- }- }- ArrangeOrder::SendToBack => {- if target_idx == 0 {- if has_other_paint { Ok((target_unit, false)) } else { Err(EditError::Invalid("the image is already at the back".into())) }- } else {- let u = units.first().ok_or_else(|| EditError::Invalid("the image is already at the back".into()))?;- Ok((u, false))- }- }- ArrangeOrder::BringForward => {- if target_idx == units.len().saturating_sub(1) {- if has_other_paint { Ok((target_unit, true)) } else { Err(EditError::Invalid("the image is already in front".into())) }- } else {- let u = units.get(target_idx.saturating_add(1)).ok_or_else(|| EditError::Invalid("the image is already in front".into()))?;- Ok((u, true))- }- }- ArrangeOrder::SendBackward => {- if target_idx == 0 {- if has_other_paint { Ok((target_unit, false)) } else { Err(EditError::Invalid("the image is already at the back".into())) }- } else {- let u = target_idx- .checked_sub(1)- .and_then(|i| units.get(i))- .ok_or_else(|| EditError::Invalid("the image is already at the back".into()))?;- Ok((u, false))- }- }- }+ let forward = matches!(order, ArrangeOrder::BringToFront | ArrangeOrder::BringForward);+ let refused = || EditError::Invalid(if forward { "the image is already in front" } else { "the image is already at the back" }.into());+ let at_limit = if forward { target_idx.saturating_add(1) >= units.len() } else { target_idx == 0 };+ if at_limit {+ return if has_other_paint { Ok((target_unit, forward)) } else { Err(refused()) };+ }+ let dest = match order {+ ArrangeOrder::BringToFront => units.last(),+ ArrangeOrder::SendToBack => units.first(),+ ArrangeOrder::BringForward => units.get(target_idx.saturating_add(1)),+ ArrangeOrder::SendBackward => target_idx.checked_sub(1).and_then(|i| units.get(i)),+ };+ dest.map(|u| (u, forward)).ok_or_else(refused)}+/// What Arrange takes out: the byte span, the op where the image's own scope state starts, and the+/// ops `start..end` removed. That is the image's own `q … Q` scope inside its unit, else the `Do`+/// alone when the unit paints something else too, else the whole unit.fn determine_arrange_spans(ops: &[Op],target: usize,target_unit: &std::ops::Range<usize>,- target_op: &Op,has_other_paint: bool,marked_unit: bool,-) -> Option<(std::ops::Range<usize>, usize, usize, usize)> {- if has_other_paint {- if let Ok(Some((sub_start, sub_end, _))) = image_exclusive_scope(ops, target)- && sub_start >= target_unit.start- && sub_end < target_unit.end- {- let start_op = ops.get(sub_start).unwrap_or(target_op);- let end_op = ops.get(sub_end).unwrap_or(target_op);- Some((start_op.span.start..end_op.span.end, sub_start, sub_start, sub_end.saturating_add(1)))- } else {- Some((target_op.span.start..target_op.span.end, target, target, target.saturating_add(1)))- }- } else if let Ok(Some((sub_start, sub_end, _))) = image_exclusive_scope(ops, target)- && sub_start >= target_unit.start- && sub_end < target_unit.end- && !marked_unit- {- let start_op = ops.get(sub_start).unwrap_or(target_op);- let end_op = ops.get(sub_end).unwrap_or(target_op);- Some((start_op.span.start..end_op.span.end, sub_start, sub_start, sub_end.saturating_add(1)))- } else if marked_unit {+) -> Result<(std::ops::Range<usize>, usize, usize, usize), EditError> {+ let scope = image_scopes(ops, target, "arranged")+ .ok()+ .and_then(|s| s.isolated)+ .filter(|&(start, end, _)| start >= target_unit.start && end < target_unit.end);+ let unit_last = target_unit.end.saturating_sub(1);+ let (first, scope_start, last) = match scope {+ Some((start, end, _)) if has_other_paint || !marked_unit => (start, start, end),+ _ if has_other_paint => (target, target, target),// A marked-content unit holding only this image moves whole, with its BDC…EMC.// The whole sequence is removed; the image's state is rebuilt from the ops inside it.- let first_op = ops.get(target_unit.start)?;- let last_op = target_unit.end.checked_sub(1).and_then(|i| ops.get(i))?;- Some((first_op.span.start..last_op.span.end, target_unit.start.saturating_add(1).min(target), target_unit.start, target_unit.end))- } else {- let first_op = ops.get(target_unit.start)?;- let last_op = target_unit.end.checked_sub(1).and_then(|i| ops.get(i))?;- Some((first_op.span.start..last_op.span.end, target_unit.start, target_unit.start, target_unit.end))- }+ _ if marked_unit => (target_unit.start, target_unit.start.saturating_add(1).min(target), unit_last),+ _ => (target_unit.start, target_unit.start, unit_last),+ };+ let missing = || EditError::Invalid("the image content unit could not be located".into());+ let start = ops.get(first).ok_or_else(missing)?.span.start;+ let end = ops.get(last).ok_or_else(missing)?.span.end;+ Ok((start..end, scope_start, first, last.saturating_add(1)))}fn scan_leaking_ops(ops: &[Op], rem_start: usize, rem_end: usize) -> (Vec<Op>, bool) {@@ -1329,26 +1116,25 @@ fn build_relocated_unit_ops(Ok(unit_ops)}-/// Change the stacking order of image `index` on `page`.-pub fn arrange_image(doc: &mut Document, page: usize, index: usize, order: ArrangeOrder) -> Result<(), EditError> {- let images = page_images(doc, page)?;- let img = images.get(index).cloned().ok_or_else(|| EditError::Invalid(format!("page {} has no image {}", page + 1, index + 1)))?;- let p = page_of(doc, page)?;- let all = content_streams(doc, &p.dict)?;- let pieces = pdfcraft_content::Pieces::join(&all.iter().map(|(_, data)| data.as_slice()).collect::<Vec<_>>());+/// Change the stacking order of `img`, drawn on page `p` by its content streams `all`.+fn arrange_image(+ doc: &mut Document,+ p: &pdfcraft_model::Page,+ all: &[(Object, Vec<u8>)],+ img: &PageImage,+ order: ArrangeOrder,+) -> Result<(), EditError> {+ let pieces = joined(all);let ops = pieces.parse().ops;let target = img.op;- if !ops.get(target).is_some_and(|op| op.is("Do")) {- return Err(EditError::Invalid("the image operation could not be located".into()));- }+ let target_op = ops.get(target).filter(|op| op.is("Do")).ok_or_else(|| EditError::Invalid("the image operation could not be located".into()))?;let is_wrapped = is_entire_page_wrapped(&ops);let (scan_start, scan_end) = if is_wrapped { (1, ops.len().saturating_sub(1)) } else { (0, ops.len()) };let units = content_units(&ops, scan_start, scan_end);- let Some(target_idx) = units.iter().position(|u| u.start <= target && target < u.end) else {+ let Some((target_idx, target_unit)) = units.iter().enumerate().find(|(_, u)| u.contains(&target)) else {return Err(EditError::Invalid("the image content unit could not be located".into()));};- let Some(target_unit) = units.get(target_idx) else { return Ok(()) };let has_other_paint = ops.iter().enumerate().any(|(i, op)| {i >= target_unit.start&& i < target_unit.end@@ -1372,19 +1158,13 @@ pub fn arrange_image(doc: &mut Document, page: usize, index: usize, order: Arranreturn Err(EditError::Invalid("cannot rearrange an image that shares a marked-content sequence with other content".into()));}- let target_op = ops.get(target).ok_or_else(|| EditError::Invalid("the image operation could not be located".into()))?;- let Some((mut target_span, scope_start, rem_start, rem_end)) =- determine_arrange_spans(&ops, target, target_unit, target_op, has_other_paint, marked_unit)- else {- return Ok(());- };+ let (mut target_span, scope_start, rem_start, rem_end) = determine_arrange_spans(&ops, target, target_unit, has_other_paint, marked_unit)?;+ let missing = || EditError::Invalid("the destination content unit could not be located".into());let (dest_pos, scan_target) = if insert_after {- let Some(op) = dest_unit.end.checked_sub(1).and_then(|i| ops.get(i)) else { return Ok(()) };- (op.span.end, dest_unit.end)+ (dest_unit.end.checked_sub(1).and_then(|i| ops.get(i)).ok_or_else(missing)?.span.end, dest_unit.end)} else {- let Some(op) = ops.get(dest_unit.start) else { return Ok(()) };- (op.span.start, dest_unit.start)+ (ops.get(dest_unit.start).ok_or_else(missing)?.span.start, dest_unit.start)};let (leaking_ops, has_leaking_clip) = scan_leaking_ops(&ops, rem_start, rem_end);@@ -1450,9 +1230,8 @@ pub fn arrange_image(doc: &mut Document, page: usize, index: usize, order: Arranlet mut extracted = match extract_scope_state(&ops, scope_start, target, scope_start_ctm)? {Some(ext) => ext,None if scope_start != target => {- let target_op = ops.get(target).cloned().ok_or_else(|| EditError::Invalid("the image operation is missing".into()))?;if !marked_unit || has_other_paint {- target_span = target_op.span.start..target_op.span.end;+ target_span = target_op.span.clone();}extract_scope_state(&ops, target, target, Matrix(img.draw_matrix))?.ok_or_else(|| EditError::Invalid("unsupported graphics state: unable to cleanly extract image scope state".into()))?@@ -1480,12 +1259,11 @@ pub fn arrange_image(doc: &mut Document, page: usize, index: usize, order: Arran));}- if all_clips && !img.clips.is_empty() {+ if all_clips {for clip in &img.clips {- let ops = clip_path_to_ops(clip);- if !ops.is_empty() {- extracted.clip_ops.extend(ops);- }+ let ops = clip_path_to_ops(clip)+ .ok_or_else(|| EditError::Invalid("unsupported graphics state: the image clipping path cannot be cleanly preserved".into()))?;+ extracted.clip_ops.extend(ops);}}@@ -1550,15 +1328,42 @@ pub fn arrange_image(doc: &mut Document, page: usize, index: usize, order: Arran}let changed = pieces.splice(edits);- let contents = crate::text::rewritten_contents(doc, &all, changed);+ let contents = crate::text::rewritten_contents(doc, all, changed);doc.update_dict(p.obj, |d| d.set(b"Contents".to_vec(), contents))?;Ok(())}-/// Locate the innermost graphics state scope enclosing only `target` (with no other painting operations).-/// Returns `Some((start, end, scope_matrix))` where `start` is the index of `q`, `end` is the index of `Q`,-/// and `scope_matrix` is the CTM in effect immediately before entering that `q`.-fn image_exclusive_scope(ops: &[Op], target: usize) -> Result<Option<(usize, usize, Matrix)>, EditError> {+/// The saved graphics-state scopes (`q … Q`) around the `Do` at `target` that paint nothing else,+/// each as `(q, Q, CTM before the q)`.+struct ImageScopes {+ /// The innermost one inside which every clip on the image is set.+ isolated: Option<(usize, usize, Matrix)>,+ /// The outermost one. It holds all of the image's private clips, but not a clip set outside it.+ outermost: Option<(usize, usize, Matrix)>,+ /// The CTM at the `Do`, and whether a clip applies there.+ placement: Matrix,+ clipped: bool,+}++impl ImageScopes {+ /// The saved graphics-state scope containing just this image and its crop, or the `Do` alone+ /// when nothing clips it. Applying a transform before that scope moves the actual clipping path+ /// as well as the pixels. A shared clip must never be moved along with unrelated artwork or text.+ ///+ /// Under a clip set outside every scope that holds only this image (a report or table drawing+ /// each picture as `q re W n cm Do Q` inside a section's clip), no scope contains every active+ /// clip. The outermost scope holding only the image is used then: it contains all of the+ /// image's private clips, which move with it, while the outer clip is shared and stays.+ fn transform_scope(&self, target: usize) -> Option<(usize, usize, Matrix)> {+ if !self.clipped {+ return Some((target, target, self.placement));+ }+ self.isolated.or(self.outermost)+ }+}++/// [`ImageScopes`] of the `Do` at `target`. An image inside a text object cannot be `done`.+fn image_scopes(ops: &[Op], target: usize, done: &str) -> Result<ImageScopes, EditError> {struct Scope {start: usize,matrix: Matrix,@@ -1575,6 +1380,7 @@ fn image_exclusive_scope(ops: &[Op], target: usize) -> Result<Option<(usize, usilet mut text = false;let mut at_image = None;let mut isolated = None;+ let mut outermost = None;for (index, op) in ops.iter().enumerate() {match op.op.as_slice() {b"q" => {@@ -1585,8 +1391,13 @@ fn image_exclusive_scope(ops: &[Op], target: usize) -> Result<Option<(usize, usi}b"Q" => {if let Some(scope) = stack.pop() {- if scope.selected && !scope.other_paint && !scope.inherited_clip && !scope.inherited_path {- isolated.get_or_insert((scope.start, index, scope.matrix));+ if scope.selected && !scope.other_paint && !scope.inherited_path {+ let found = (scope.start, index, scope.matrix);+ if !scope.inherited_clip {+ isolated.get_or_insert(found);+ }+ // Scopes close inner first, so the last one recorded is the outermost.+ outermost = Some(found);}matrix = scope.matrix;clipped = scope.inherited_clip;@@ -1607,9 +1418,9 @@ fn image_exclusive_scope(ops: &[Op], target: usize) -> Result<Option<(usize, usi}if index == target {if text {- return Err(EditError::Invalid("an image inside a text object cannot be cropped".into()));+ return Err(EditError::Invalid(format!("an image inside a text object cannot be {done}")));}- at_image = Some(matrix);+ at_image = Some((matrix, clipped));for scope in &mut stack {scope.selected = true;}@@ -1627,10 +1438,8 @@ fn image_exclusive_scope(ops: &[Op], target: usize) -> Result<Option<(usize, usipath = false;}}- if at_image.is_none() {- return Err(EditError::Invalid("the image operation is missing".into()));- }- Ok(isolated)+ let (placement, clipped) = at_image.ok_or_else(|| EditError::Invalid("the image operation is missing".into()))?;+ Ok(ImageScopes { isolated, outermost, placement, clipped })}/// The scope `start..=end` without its private clipping paths and clipping `W n` sequences.@@ -1658,19 +1467,15 @@ fn extract_image_drawing_ops(ops: &[Op], start: usize, end: usize) -> Result<(VeOk((drawing, removed_clip))}-/// Remove any private clipping path / crop on image `index` on `page`.-pub fn remove_image_crop(doc: &mut Document, page: usize, index: usize) -> Result<(), EditError> {- let images = page_images(doc, page)?;- let img = images.get(index).cloned().ok_or_else(|| EditError::Invalid(format!("page {} has no image {}", page + 1, index + 1)))?;- let p = page_of(doc, page)?;- let all = content_streams(doc, &p.dict)?;- let pieces = pdfcraft_content::Pieces::join(&all.iter().map(|(_, data)| data.as_slice()).collect::<Vec<_>>());+/// Remove any private clipping path / crop on `img`, drawn on page `p` by its content streams `all`.+fn remove_image_crop(doc: &mut Document, p: &pdfcraft_model::Page, all: &[(Object, Vec<u8>)], img: &PageImage) -> Result<(), EditError> {+ let pieces = joined(all);let ops = pieces.parse().ops;let target = img.op;if !ops.get(target).is_some_and(|op| op.is("Do")) {return Err(EditError::Invalid("the image operation could not be located".into()));}- let Some((start, end, _)) = image_exclusive_scope(&ops, target)? else {+ let Some((start, end, _)) = image_scopes(&ops, target, "cropped")?.isolated else {return Err(EditError::Invalid("the image has no crop to remove".into()));};let (drawing_ops, removed_clip) = extract_image_drawing_ops(&ops, start, end)?;@@ -1686,7 +1491,7 @@ pub fn remove_image_crop(doc: &mut Document, page: usize, index: usize) -> Resulunit_ops.push(Op::new("Q", vec![]));let serialized = serialize_ops(&unit_ops);let changed = pieces.splice([(range, serialized)]);- let contents = crate::text::rewritten_contents(doc, &all, changed);+ let contents = crate::text::rewritten_contents(doc, all, changed);doc.update_dict(p.obj, |d| d.set(b"Contents".to_vec(), contents))?;Ok(())}@@ -1709,10 +1514,10 @@ pub fn change_image(doc: &mut Document, page: usize, index: usize, change: &Imagreturn transform_image(doc, &p, &all, &img, *t);}ImageChange::Arrange(order) => {- return arrange_image(doc, page, index, *order);+ return arrange_image(doc, &p, &all, &img, *order);}ImageChange::RemoveCrop => {- return remove_image_crop(doc, page, index);+ return remove_image_crop(doc, &p, &all, &img);}ImageChange::Crop(keep) => {return crop_image_impl(doc, &p, &all, &img, *keep);@@ -1758,94 +1563,6 @@ pub(crate) fn selectable_images(.collect())}-/// Find the saved graphics-state scope containing just this image and its crop. Applying-/// the transform before that scope moves the actual clipping path as well as the pixels.-/// A shared clip must never be moved along with unrelated artwork or text.-///-/// Under a clip set outside every scope that holds only this image (a report or table drawing-/// each picture as `q re W n cm Do Q` inside a section's clip), no scope contains every active-/// clip. The outermost scope holding only the image is used then: it contains all of the-/// image's private clips, which move with it, while the outer clip is shared and stays.-fn image_transform_scope(ops: &[Op], target: usize) -> Result<Option<(usize, usize, Matrix)>, EditError> {- struct Scope {- start: usize,- matrix: Matrix,- inherited_clip: bool,- inherited_path: bool,- selected: bool,- other_paint: bool,- }- let mut stack: Vec<Scope> = Vec::new();- let mut matrix = Matrix::IDENTITY;- let mut clipped = false;- let mut path = false;- let mut pending_clip = false;- let mut text = false;- let mut at_image = None;- let mut isolated = None;- let mut outermost = None;- for (index, op) in ops.iter().enumerate() {- match op.op.as_slice() {- b"q" => {- if stack.len() >= 256 {- return Err(EditError::Invalid("the image graphics state is too deeply nested to transform".into()));- }- stack.push(Scope { start: index, matrix, inherited_clip: clipped, inherited_path: path, selected: false, other_paint: false });- }- b"Q" => {- if let Some(scope) = stack.pop() {- if scope.selected && !scope.other_paint && !scope.inherited_path {- if !scope.inherited_clip {- // Prefer the innermost scope that contains every active clipping path.- isolated.get_or_insert((scope.start, index, scope.matrix));- }- // Scopes close inner first, so the last one recorded is the outermost.- outermost = Some((scope.start, index, scope.matrix));- }- matrix = scope.matrix;- clipped = scope.inherited_clip;- }- }- b"cm" => {- if let Some(m) = op.nums::<6>() {- matrix = Matrix(m).then(&matrix);- }- }- b"BT" => text = true,- b"ET" => text = false,- b"m" | b"l" | b"c" | b"v" | b"y" | b"re" => path = true,- b"W" | b"W*" => pending_clip = true,- _ => {}- }- if index == target {- if text {- return Err(EditError::Invalid("an image inside a text object cannot be transformed".into()));- }- at_image = Some((matrix, clipped));- for scope in &mut stack {- scope.selected = true;- }- } else if matches!(- op.op.as_slice(),- b"Do" | b"Tj" | b"TJ" | b"'" | b"\"" | b"sh" | b"BI" | b"S" | b"s" | b"f" | b"F" | b"f*" | b"B" | b"B*" | b"b" | b"b*"- ) {- for scope in &mut stack {- scope.other_paint = true;- }- }- if matches!(op.op.as_slice(), b"n" | b"S" | b"s" | b"f" | b"F" | b"f*" | b"B" | b"B*" | b"b" | b"b*") {- clipped |= pending_clip;- pending_clip = false;- path = false;- }- }- let (placement, clipped) = at_image.ok_or_else(|| EditError::Invalid("the image operation is missing".into()))?;- if !clipped {- return Ok(Some((target, target, placement)));- }- Ok(isolated.or(outermost))-}-fn transform_image(doc: &mut Document,page: &pdfcraft_model::Page,@@ -1864,7 +1581,8 @@ fn transform_image(}// A private path crop moves with its image regardless of intervening state operators.// Shared crops retain the existing fixed-clip behavior, preserving neighbouring paint.- let (start, end, placement) = image_transform_scope(&ops, target)?.unwrap_or((target, target, Matrix(image.draw_matrix)));+ let (start, end, placement) =+ image_scopes(&ops, target, "transformed")?.transform_scope(target).unwrap_or((target, target, Matrix(image.draw_matrix)));let inverse = placement.invert().ok_or_else(|| EditError::Invalid("the image has no area".into()))?;let local = placement.then(&Matrix(transform)).then(&inverse);if !local.0.iter().all(|v| v.is_finite() && v.abs() <= 1e12) {@@ -1938,7 +1656,8 @@ fn crop_image_impl(if !ops.get(target).is_some_and(|op| op.is("Do")) {return Err(EditError::Invalid("the image operation could not be located".into()));}- let (start, end, placement) = image_transform_scope(&ops, target)?.unwrap_or((target, target, Matrix(image.draw_matrix)));+ let (start, end, placement) =+ image_scopes(&ops, target, "cropped")?.transform_scope(target).unwrap_or((target, target, Matrix(image.draw_matrix)));let inverse = placement.invert().ok_or_else(|| EditError::Invalid("the image has no area".into()))?;let corners = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)].map(|(x, y)| inverse.apply(x, y));if !corners.iter().all(|(x, y)| x.is_finite() && y.is_finite() && x.abs() <= 1e12 && y.abs() <= 1e12) {