Background dialog: adjust an image's offset and scale; visual style names

- The Image tab gains an Adjust card: X/Y offset in pixels (-2000..2000)
  and X/Y scale (-10..10, tenth steps, a negative scale mirrors, zero keeps
  the image's scale) with spinners and Reset, inactive while the image is
  stretched; Keep aspect ratio is a switch and makes both scales follow.
- The preview shows the image at its offset and scale, tiled when tiled,
  and a stretched image kept to its aspect ratio covers the view.
- Automation: step=<field>,+1|-1 and reset; offset/scale take any numbers.
- Shaded with edges, Shades of Gray and Sketchy have catalog entries in
  every language.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/ui/window/pdf_dialogs.rs

@@ -122,9 +122,13 @@ pub enum PdfDialogMsg {
     BgBrowse,
     BgPosition(BgPosition),
     BgAspect(bool),
-    /// An image background's offset (pixels) and scale.
-    BgOffset([f64; 2]),
-    BgScale([f64; 2]),
+    /// An image background's offset (pixels, x and y) and scale, as typed.
+    BgOffset([String; 2]),
+    BgScale([String; 2]),
+    /// A spinner step on offset x / y (0, 1) or scale x / y (2, 3).
+    BgStep(u8, i8),
+    /// Offset 0, scale 1.
+    BgReset,
     BgApply,
 }
 
@@ -2181,19 +2185,23 @@ impl fmt::Display for BgPosition {
     }
 }
 
-/// How an image background is scaled: to the screen, or keeping its
-/// aspect ratio.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct BgAspect(pub bool);
+/// Image offsets the reference's Adjust Image sliders reach, in pixels.
+pub const BG_OFFSET_LIMIT: f64 = 2000.0;
+/// Image scales the reference's sliders reach (slider value / 10).
+pub const BG_SCALE_LIMIT: f64 = 10.0;
 
-impl fmt::Display for BgAspect {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&if self.0 {
-            crate::tr!("view-background", "aspect")
-        } else {
-            crate::tr!("view-background", "fit")
-        })
+/// One spinner step on an image background field: a pixel for an offset, a
+/// tenth for a scale, which skips 0 (the reference ignores a zero scale).
+pub fn bg_step(field: u8, value: f64, dir: i8) -> f64 {
+    let dir = f64::from(dir.signum());
+    if field < 2 {
+        return (value.round() + dir).clamp(-BG_OFFSET_LIMIT, BG_OFFSET_LIMIT);
     }
+    let mut next = ((value * 10.0).round() + dir) / 10.0;
+    if next.abs() < 0.05 {
+        next += dir / 10.0;
+    }
+    next.clamp(-BG_SCALE_LIMIT, BG_SCALE_LIMIT)
 }
 
 /// The Background dialog's fields for one named view.
@@ -2209,9 +2217,15 @@ pub struct ViewBackgroundState {
     pub image: String,
     pub position: BgPosition,
     pub aspect: bool,
-    /// The image's offset (pixels) and scale, kept from the view's image.
-    pub offset: [f64; 2],
-    pub scale: [f64; 2],
+    /// The image's offset (pixels) and scale as typed, and the scale the
+    /// view's image had (kept for a zero scale).
+    pub offset: [String; 2],
+    pub scale: [String; 2],
+    pub scale_base: [f64; 2],
+    /// The chosen image's size in pixels, for the preview.
+    pub image_size: Option<[u32; 2]>,
+    /// The drawing viewport's size, which the preview stands for.
+    pub viewport: [f32; 2],
     /// The drawing area colour, shown for no background.
     pub canvas: [u8; 3],
 }
@@ -2271,20 +2285,68 @@ pub fn view_background<'a>(
         }
         BgKind::Image => {
             if std::path::Path::new(state.image.trim()).is_file() {
-                let fit = match (state.position, state.aspect) {
-                    (BgPosition::Stretch, false) => iced::ContentFit::Fill,
-                    (BgPosition::Stretch, true) => iced::ContentFit::Contain,
-                    _ => iced::ContentFit::None,
-                };
-                container(
-                    image(image::Handle::from_path(state.image.trim()))
-                        .content_fit(fit)
-                        .width(Fill)
-                        .height(Fill),
-                )
-                .center(Fill)
-                .style(fill(Background::Color(rgb(state.canvas))))
-                .into()
+                let handle = image::Handle::from_path(state.image.trim());
+                let canvas = Background::Color(rgb(state.canvas));
+                if state.position == BgPosition::Stretch {
+                    // Filling the view; keeping the aspect ratio it covers
+                    // the view and the overflow is cut off.
+                    let fit = if state.aspect { iced::ContentFit::Cover } else { iced::ContentFit::Fill };
+                    container(image(handle).content_fit(fit).width(Fill).height(Fill))
+                        .center(Fill)
+                        .clip(true)
+                        .style(fill(canvas))
+                        .into()
+                } else {
+                    // The image at its size times its scale, moved by its
+                    // offset, in a view of the drawing viewport's shape.
+                    let parse = |v: &String, d: f64| v.trim().parse::<f64>().ok().filter(|v| v.is_finite()).unwrap_or(d);
+                    let offset = [parse(&state.offset[0], 0.0), parse(&state.offset[1], 0.0)];
+                    let scale = [0, 1].map(|k| {
+                        let v = parse(&state.scale[k], state.scale_base[k]);
+                        if v.abs() < 1e-9 { state.scale_base[k] } else { v }
+                    });
+                    let [iw, ih] = state.image_size.unwrap_or([1, 1]);
+                    let viewport = state.viewport;
+                    let tile = state.position == BgPosition::Tile;
+                    container(iced::widget::responsive(move |size| {
+                        let factor = size.height / viewport[1].max(1.0);
+                        let w = (iw as f32 * scale[0].abs() as f32 * factor).max(1.0);
+                        let h = (ih as f32 * scale[1].abs() as f32 * factor).max(1.0);
+                        let x = size.width / 2.0 + offset[0] as f32 * factor - w / 2.0;
+                        let y = size.height / 2.0 + offset[1] as f32 * factor - h / 2.0;
+                        let (cols, rows) = if tile {
+                            ((size.width / w).ceil() as i32 + 1, (size.height / h).ceil() as i32 + 1)
+                        } else {
+                            (0, 0)
+                        };
+                        let mut layers = iced::widget::Stack::new()
+                            .width(Fill)
+                            .height(Fill)
+                            .push(container(Space::new()).width(Fill).height(Fill));
+                        let x0 = if tile { x - (x / w).ceil() * w } else { x };
+                        let y0 = if tile { y - (y / h).ceil() * h } else { y };
+                        for row_index in 0..=rows.min(60) {
+                            for col_index in 0..=cols.min(60) {
+                                let at = iced::Point::new(x0 + col_index as f32 * w, y0 + row_index as f32 * h);
+                                layers = layers.push(
+                                    iced::widget::pin(
+                                        image(handle.clone())
+                                            .content_fit(iced::ContentFit::Fill)
+                                            .width(Length::Fixed(w))
+                                            .height(Length::Fixed(h)),
+                                    )
+                                    .position(at),
+                                );
+                            }
+                        }
+                        Element::<Message>::from(layers)
+                    }))
+                    .width(Fill)
+                    .height(Fill)
+                    .clip(true)
+                    .style(fill(canvas))
+                    .into()
+                }
             } else {
                 container(note(crate::tr!("view-background", "no-image")))
                     .center(Fill)
@@ -2397,28 +2459,22 @@ pub fn view_background<'a>(
                 ]
                 .spacing(8)
                 .align_y(iced::Center),
-                row![
-                    label(crate::tr!("view-background", "scale"), true),
-                    pick_list(
-                        Some(BgAspect(state.aspect)),
-                        vec![BgAspect(false), BgAspect(true)],
-                        |a: &BgAspect| a.to_string()
-                    )
-                    .on_select(|a: BgAspect| msg(PdfDialogMsg::BgAspect(a.0)))
-                    .text_size(12)
-                    .padding([4, 8])
-                    .width(Fill),
-                ]
-                .spacing(8)
-                .align_y(iced::Center),
+                chip(
+                    crate::tr!("view-background", "aspect"),
+                    state.aspect,
+                    msg(PdfDialogMsg::BgAspect(!state.aspect))
+                ),
             ]
             .spacing(8),
         ),
     };
+    let adjust = (state.kind == BgKind::Image).then(|| adjust_card(state));
+    let mut body = column![kind, preview, options].spacing(10);
+    if let Some(adjust) = adjust {
+        body = body.push(adjust);
+    }
     column![
-        kind,
-        preview,
-        options,
+        body,
         footer(
             "background",
             None,
@@ -2431,3 +2487,85 @@ pub fn view_background<'a>(
     .width(sizing.width)
     .into()
 }
+
+/// The image's offset and scale (the reference's Adjust Image): pixel offsets
+/// and scales with spinners and a reset; inactive while the image is
+/// stretched over the view, where the reference ignores them.
+fn adjust_card<'a>(state: &'a ViewBackgroundState) -> Element<'a, Message> {
+    let enabled = state.position != BgPosition::Stretch;
+    let dim = move |theme: &Theme| {
+        if enabled {
+            muted_style(theme)
+        } else {
+            text::Style { color: Some(theme.palette().background.strong.color) }
+        }
+    };
+    let spin = |field: u8| -> Element<'a, Message> {
+        let value = if field < 2 { &state.offset[field as usize] } else { &state.scale[field as usize - 2] };
+        let mut input = text_input("", value).size(11).padding([4, 8]).width(Length::Fixed(64.0)).style(field_style);
+        if enabled {
+            input = input.on_input(move |v| {
+                if field < 2 {
+                    let mut pair = state.offset.clone();
+                    pair[field as usize] = v;
+                    msg(PdfDialogMsg::BgOffset(pair))
+                } else {
+                    let mut pair = state.scale.clone();
+                    pair[field as usize - 2] = v;
+                    msg(PdfDialogMsg::BgScale(pair))
+                }
+            });
+        }
+        let arrow = |up: bool| {
+            let mut b = button(crate::ui::icons::themed_arrow_toggle(up, 7.0))
+                .style(button_style(false))
+                .padding([1, 4]);
+            if enabled {
+                b = b.on_press(msg(PdfDialogMsg::BgStep(field, if up { 1 } else { -1 })));
+            }
+            b
+        };
+        row![input, column![arrow(true), arrow(false)].spacing(1)].spacing(2).align_y(iced::Center).into()
+    };
+    let axis = |name: &'static str| text(name).size(11).style(dim);
+    let line = |label: String, a: u8, b: u8, unit: bool| -> Element<'a, Message> {
+        let mut r = row![
+            text(label).size(11).style(dim).width(Length::Fixed(72.0)),
+            axis("X"),
+            spin(a),
+            axis("Y"),
+            spin(b),
+        ]
+        .spacing(6)
+        .align_y(iced::Center);
+        if unit {
+            r = r.push(text(crate::tr!("view-background", "pixels")).size(11).style(dim));
+        }
+        r.into()
+    };
+    let mut reset = button(text(crate::tr!("view-background", "reset")).size(11))
+        .style(button_style(false))
+        .padding([3, 10]);
+    if enabled {
+        reset = reset.on_press(msg(PdfDialogMsg::BgReset));
+    }
+    container(
+        column![
+            row![
+                text(crate::tr!("view-background", "adjust").to_uppercase()).size(10).style(move |theme: &Theme| {
+                    if enabled { accent_text(theme) } else { dim(theme) }
+                }),
+                Space::new().width(Fill),
+                reset,
+            ]
+            .align_y(iced::Center),
+            line(crate::tr!("view-background", "offset"), 0, 1, true),
+            line(crate::tr!("view-background", "scale"), 2, 3, false),
+        ]
+        .spacing(8),
+    )
+    .padding([10, 12])
+    .width(Fill)
+    .style(card_style)
+    .into()
+}