Merge PR #692 from NikitkaRa: UI: Format Background picture fill sets transparency and tiling

# Conflicts:
#	crates/engine/src/cmd/design.rs
#	crates/ui-egui/src/panes.rs

crates/engine/src/cmd/design.rs

@@ -41,7 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Format Background",
             ["Design", "Customize"],
             None,
-            "{color? | gradient? | picture?: base64 | style?: 1..12 | reset?, all?: bool (apply to all), index?}",
+            "{color? | gradient? | picture?: base64 | pattern? | style?: 1..12 | reset?, all?: bool, index?, transparency?: 0..1, pictureProps?: {tile?, offsetX?, offsetY?: pt, scaleX?, scaleY?: 0.01..10, align?, mirror?, stretch?: [l,t,r,b], rotateWithShape?}, copy?: bool}",
             has_slide,
             background
         ),
@@ -452,70 +452,256 @@ fn effects(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn background(s: &mut Session, p: &Value) -> Result<Value> {
-    let bg: Option<Background> = if bool_or(p, "reset", false) {
-        None
-    } else if let Some(c) = color_param(p, "color") {
-        Some(Background::Fill { fill: Fill::solid(c) })
-    } else if let Some(i) = usize_param(p, "style") {
+    if bool_or(p, "copy", false) {
+        return copy_slide_background(s);
+    }
+    let props = p.get("pictureProps").filter(|v| v.is_object()).cloned();
+    let transparency = f64_param(p, "transparency");
+    let reset = bool_or(p, "reset", false);
+    let color = color_param(p, "color");
+    let style = usize_param(p, "style");
+    let op = if reset {
+        BgOp::Set(None)
+    } else if let Some(mut c) = color {
+        if let Some(t) = transparency {
+            set_solid_transparency(&mut c, t);
+        }
+        BgOp::Set(Some(Background::Fill { fill: Fill::solid(c) }))
+    } else if let Some(i) = style {
         // Background styles: 3 theme bg fills × 4 colours (bg1, bg2, tx1, tx2).
         let slots =
             [deckcraft_color::SchemeSlot::Bg1, deckcraft_color::SchemeSlot::Bg2, deckcraft_color::SchemeSlot::Tx2, deckcraft_color::SchemeSlot::Tx1];
         let i = i.clamp(1, 12) - 1;
-        Some(Background::Ref {
+        BgOp::Set(Some(Background::Ref {
             idx: 1001 + (i / 4) as u32,
             color: deckcraft_model::ColorRef::scheme(slots.get(i % 4).copied().unwrap_or(deckcraft_color::SchemeSlot::Bg1)),
-        })
+        }))
     } else if let Some(g) = p.get("gradient") {
         let mut g = super::shape::gradient_param(g).ok_or_else(|| bad("design.background", "gradient needs two or more `stops`"))?;
         g.rotate_with_shape = false;
-        Some(Background::Fill { fill: Fill::Gradient(g) })
+        BgOp::Set(Some(Background::Fill { fill: Fill::Gradient(g) }))
     } else if let Some(pt) = p.get("pattern") {
-        Some(Background::Fill {
+        BgOp::Set(Some(Background::Fill {
             fill: Fill::Pattern(deckcraft_model::style::PatternFill {
                 preset: pt.get("preset").and_then(Value::as_str).unwrap_or("pct50").to_string(),
                 fg: pt.get("fg").and_then(color_value).unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent1)),
                 bg: pt.get("bg").and_then(color_value).unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Bg1)),
             }),
-        })
+        }))
     } else if p.get("picture").is_some() {
         let (name, bytes) = super::insert::media_bytes(&with_param(p, "data", p.get("picture").cloned().unwrap_or_default()), "design.background")?;
         let ct = super::insert::content_type(&name, &bytes);
         let media = s.edit(|doc, _| Ok(doc.add_media(&name, ct, bytes)))?;
-        Some(Background::Fill { fill: Fill::Picture(deckcraft_model::style::PictureFill { media, ..Default::default() }) })
+        let mut pf = deckcraft_model::style::PictureFill { media, ..Default::default() };
+        if let Some(pp) = &props {
+            apply_picture_props(&mut pf, pp);
+        }
+        if let Some(t) = transparency {
+            set_picture_transparency(&mut pf, t);
+        }
+        BgOp::Set(Some(Background::Fill { fill: Fill::Picture(pf) }))
+    } else if props.is_some() || transparency.is_some() {
+        BgOp::Adjust
     } else {
-        return Err(bad("design.background", "give `color`, `gradient`, `pattern`, `picture`, `style` or `reset`"));
+        return Err(bad(
+            "design.background",
+            "give `color`, `gradient`, `pattern`, `picture`, `style`, `reset`, `pictureProps`, `transparency` or `copy`",
+        ));
     };
     let all = bool_or(p, "all", false);
     let index = usize_param(p, "index");
+    if matches!(op, BgOp::Adjust) {
+        let next = {
+            let st = s.doc()?;
+            let current = background_of(&st.doc, &st.selection, index);
+            let picture = matches!(current, Some(Background::Fill { fill: Fill::Picture(_) }));
+            let solid = matches!(current, Some(Background::Fill { fill: Fill::Solid { .. } }));
+            if props.is_some() && !picture {
+                return Err(bad("design.background", "picture options need a picture background"));
+            }
+            if transparency.is_some() && !picture && !solid {
+                return Err(bad("design.background", "transparency needs a solid or picture background"));
+            }
+            let mut next = current.clone();
+            if let Some(bg) = next.as_mut() {
+                adjust_background(bg, props.as_ref(), transparency);
+            }
+            if next == current { None } else { Some(next) }
+        };
+        let Some(next) = next else { return ok() };
+        s.edit(|doc, sel| {
+            write_background(doc, sel, index, false, next);
+            Ok(())
+        })?;
+        return ok();
+    }
+    let BgOp::Set(bg) = op else { return ok() };
+    let unchanged = {
+        let st = s.doc()?;
+        backgrounds_already(&st.doc, &st.selection, index, all, &bg)
+    };
+    if unchanged {
+        return ok();
+    }
     s.edit(|doc, sel| {
-        match sel.target {
-            Target::Master { master } => {
-                if let Some(m) = doc.masters.get_mut(master) {
-                    Arc::make_mut(m).background = bg.clone();
+        write_background(doc, sel, index, all, bg);
+        Ok(())
+    })?;
+    ok()
+}
+
+enum BgOp {
+    Set(Option<Background>),
+    Adjust,
+}
+
+fn background_of(doc: &Presentation, sel: &crate::Selection, index: Option<usize>) -> Option<Background> {
+    match sel.target {
+        Target::Master { master } => doc.masters.get(master).and_then(|m| m.background.clone()),
+        Target::Layout { master, layout } => doc.masters.get(master).and_then(|m| m.layouts.get(layout)).and_then(|l| l.background.clone()),
+        t @ (Target::Handout | Target::NotesMaster) => crate::page_master(doc, t).and_then(|m| m.background.clone()),
+        Target::Slides => doc.slides.get(index.unwrap_or(sel.slide)).and_then(|sl| sl.background.clone()),
+    }
+}
+
+fn backgrounds_already(doc: &Presentation, sel: &crate::Selection, index: Option<usize>, all: bool, bg: &Option<Background>) -> bool {
+    match sel.target {
+        Target::Master { master } => doc.masters.get(master).is_some_and(|m| m.background == *bg),
+        Target::Layout { master, layout } => doc.masters.get(master).and_then(|m| m.layouts.get(layout)).is_some_and(|l| l.background == *bg),
+        t @ (Target::Handout | Target::NotesMaster) => crate::page_master(doc, t).is_some_and(|m| m.background == *bg),
+        Target::Slides => {
+            let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
+            !list.is_empty() && list.iter().all(|i| doc.slides.get(*i).is_some_and(|sl| sl.background == *bg))
+        }
+    }
+}
+
+fn write_background(doc: &mut Presentation, sel: &crate::Selection, index: Option<usize>, all: bool, bg: Option<Background>) {
+    match sel.target {
+        Target::Master { master } => {
+            if let Some(m) = doc.masters.get_mut(master) {
+                Arc::make_mut(m).background = bg;
+            }
+        }
+        Target::Layout { master, layout } => {
+            if let Some(l) = doc.masters.get_mut(master).and_then(|m| Arc::make_mut(m).layouts.get_mut(layout)) {
+                l.background = bg;
+            }
+        }
+        t @ (Target::Handout | Target::NotesMaster) => {
+            if let Some(m) = crate::page_master_mut(doc, t) {
+                Arc::make_mut(m).background = bg;
+            }
+        }
+        Target::Slides => {
+            let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
+            for i in list {
+                if let Some(sl) = doc.slides.get_mut(i) {
+                    Arc::make_mut(sl).background = bg.clone();
                 }
             }
-            Target::Layout { master, layout } => {
-                if let Some(l) = doc.masters.get_mut(master).and_then(|m| Arc::make_mut(m).layouts.get_mut(layout)) {
-                    l.background = bg.clone();
-                }
+        }
+    }
+}
+
+fn copy_slide_background(s: &mut Session) -> Result<Value> {
+    let bg = {
+        let st = s.doc()?;
+        if !matches!(st.selection.target, Target::Slides) {
+            return Err(bad("design.background", "copy applies to slides"));
+        }
+        let bg = st.doc.slides.get(st.selection.slide).and_then(|sl| sl.background.clone());
+        if st.doc.slides.iter().all(|sl| sl.background == bg) {
+            return ok();
+        }
+        bg
+    };
+    s.edit(|doc, sel| {
+        write_background(doc, sel, None, true, bg);
+        Ok(())
+    })?;
+    ok()
+}
+
+fn adjust_background(bg: &mut Background, props: Option<&Value>, transparency: Option<f64>) {
+    match bg {
+        Background::Fill { fill: Fill::Picture(pf) } => {
+            if let Some(pp) = props {
+                apply_picture_props(pf, pp);
             }
-            t @ (Target::Handout | Target::NotesMaster) => {
-                if let Some(m) = crate::page_master_mut(doc, t) {
-                    Arc::make_mut(m).background = bg.clone();
-                }
+            if let Some(t) = transparency {
+                set_picture_transparency(pf, t);
             }
-            Target::Slides => {
-                let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
-                for i in list {
-                    if let Some(sl) = doc.slides.get_mut(i) {
-                        Arc::make_mut(sl).background = bg.clone();
+        }
+        Background::Fill { fill: Fill::Solid { color } } => {
+            if let Some(t) = transparency {
+                set_solid_transparency(color, t);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn set_picture_transparency(pf: &mut deckcraft_model::style::PictureFill, t: f64) {
+    let a = 1.0 - t.clamp(0.0, 1.0);
+    pf.alpha = (a < 1.0).then_some(a);
+}
+
+fn set_solid_transparency(color: &mut deckcraft_model::ColorRef, t: f64) {
+    color.mods.retain(|m| !matches!(m, deckcraft_color::ColorTransform::Alpha(_)));
+    let t = t.clamp(0.0, 1.0);
+    if t > 0.0 {
+        color.mods.push(deckcraft_color::ColorTransform::Alpha(((1.0 - t) * 100_000.0).round() as i32));
+    }
+}
+
+/// Picture-fill options for Format Background (tile, offsets, scale, alignment, mirror, stretch).
+fn apply_picture_props(pf: &mut deckcraft_model::style::PictureFill, pp: &Value) {
+    use deckcraft_model::style::PictureMode;
+    let f = |k: &str| pp.get(k).and_then(Value::as_f64).filter(|v| v.is_finite());
+    if let Some(up) = pp.get("rotateWithShape").and_then(Value::as_bool) {
+        pf.upright = !up;
+    }
+    match pp.get("tile").and_then(Value::as_bool) {
+        Some(true) if !matches!(pf.mode, PictureMode::Tile { .. }) => {
+            pf.mode = PictureMode::Tile { tx: 0.0, ty: 0.0, sx: 1.0, sy: 1.0, flip: "none".into(), align: "tl".into() };
+        }
+        Some(false) if !matches!(pf.mode, PictureMode::Stretch { .. }) => pf.mode = PictureMode::default(),
+        _ => {}
+    }
+    match &mut pf.mode {
+        PictureMode::Tile { tx, ty, sx, sy, flip, align } => {
+            if let Some(v) = f("offsetX") {
+                *tx = v.clamp(-4000.0, 4000.0);
+            }
+            if let Some(v) = f("offsetY") {
+                *ty = v.clamp(-4000.0, 4000.0);
+            }
+            if let Some(v) = f("scaleX") {
+                *sx = v.clamp(0.01, 10.0);
+            }
+            if let Some(v) = f("scaleY") {
+                *sy = v.clamp(0.01, 10.0);
+            }
+            if let Some(m) = pp.get("mirror").and_then(Value::as_str).filter(|m| matches!(*m, "none" | "x" | "y" | "xy")) {
+                *flip = m.to_string();
+            }
+            if let Some(a) =
+                pp.get("align").and_then(Value::as_str).filter(|a| matches!(*a, "tl" | "t" | "tr" | "l" | "ctr" | "r" | "bl" | "b" | "br"))
+            {
+                *align = a.to_string();
+            }
+        }
+        PictureMode::Stretch { fill_rect } => {
+            if let Some(arr) = pp.get("stretch").and_then(Value::as_array) {
+                for (slot, v) in fill_rect.iter_mut().zip(arr) {
+                    if let Some(v) = v.as_f64().filter(|v| v.is_finite()) {
+                        *slot = v.clamp(-10.0, 0.99);
                     }
                 }
             }
         }
-        Ok(())
-    })?;
-    ok()
+    }
 }
 
 fn hide_bg_graphics(s: &mut Session, p: &Value) -> Result<Value> {
@@ -1238,7 +1424,9 @@ fn slide_number_paragraph() -> deckcraft_model::Paragraph {
 #[cfg(test)]
 mod tests {
     use deckcraft_color::SchemeSlot;
+    use deckcraft_model::style::PictureMode;
     use deckcraft_model::theme::{FontScheme, ScriptFont, builtin_color_schemes, builtin_font_schemes};
+    use deckcraft_model::{Background, Fill};
     use serde_json::{Value, json};
 
     use crate::{Session, UiRequest};
@@ -1255,6 +1443,21 @@ mod tests {
         s.doc().unwrap().history.undo.len()
     }
 
+    fn png() -> String {
+        let mut img = image::RgbaImage::new(2, 2);
+        img.put_pixel(0, 0, image::Rgba([10, 20, 30, 255]));
+        let mut bytes = Vec::new();
+        image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut bytes), image::ImageFormat::Png).unwrap();
+        crate::cmd::base64_encode(&bytes)
+    }
+
+    fn picture(s: &Session) -> deckcraft_model::style::PictureFill {
+        match &s.doc().unwrap().doc.slides[0].background {
+            Some(Background::Fill { fill: Fill::Picture(pf) }) => pf.clone(),
+            other => panic!("expected a picture background, got {other:?}"),
+        }
+    }
+
     #[test]
     fn civil_dates() {
         assert_eq!(super::civil(0), (1970, 1, 1));
@@ -1425,6 +1628,72 @@ mod tests {
         assert_eq!(font_scheme(&s).major.ea, "Kept");
         assert_eq!(font_scheme(&s).minor.latin, "Open Sans");
     }
+
+    #[test]
+    fn background_picture_options_tile_transparency_and_copy() {
+        let mut s = Session::with_new();
+        let n = undo_len(&s);
+        let err = s.execute("design.background", &json!({"pictureProps": {"tile": true}})).unwrap_err().to_string();
+        assert!(err.contains("picture background"), "{err}");
+        assert!(s.execute("design.background", &json!({"transparency": 0.2})).is_err());
+        assert_eq!(undo_len(&s), n);
+
+        s.execute("design.background", &json!({"color": "accent1", "transparency": 0.25})).unwrap();
+        match &s.doc().unwrap().doc.slides[0].background {
+            Some(Background::Fill { fill: Fill::Solid { color } }) => assert!((color.alpha() - 0.75).abs() < 1e-4, "{}", color.alpha()),
+            other => panic!("expected a solid background, got {other:?}"),
+        }
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"transparency": 0.25})).unwrap();
+        assert_eq!(undo_len(&s), n, "the same transparency is not an undo step");
+
+        s.execute("design.background", &json!({"picture": png(), "name": "dot.png", "transparency": 0.4, "pictureProps": {"tile": true}})).unwrap();
+        let pf = picture(&s);
+        assert!((pf.alpha.unwrap_or(1.0) - 0.6).abs() < 1e-6);
+        assert!(matches!(pf.mode, PictureMode::Tile { .. }));
+        let n = undo_len(&s);
+
+        s.execute(
+            "design.background",
+            &json!({"pictureProps": {"offsetX": 12.0, "offsetY": -3.0, "scaleX": 0.5, "scaleY": 50.0, "align": "ctr", "mirror": "xy", "rotateWithShape": false}}),
+        )
+        .unwrap();
+        match picture(&s).mode {
+            PictureMode::Tile { tx, ty, sx, sy, flip, align } => {
+                assert_eq!((tx, ty, sx, sy), (12.0, -3.0, 0.5, 10.0));
+                assert_eq!(flip, "xy");
+                assert_eq!(align, "ctr");
+            }
+            other => panic!("expected a tile, got {other:?}"),
+        }
+        assert!(picture(&s).upright);
+        s.execute("design.background", &json!({"pictureProps": {"align": "bogus", "offsetX": "nope"}})).unwrap();
+        match picture(&s).mode {
+            PictureMode::Tile { tx, align, .. } => {
+                assert_eq!(tx, 12.0);
+                assert_eq!(align, "ctr");
+            }
+            other => panic!("expected the tile to stay, got {other:?}"),
+        }
+        assert_eq!(undo_len(&s), n + 1, "ignored options are not an undo step");
+
+        s.execute("design.background", &json!({"pictureProps": {"tile": false, "stretch": [0.1, 0.2, 0.0, 0.0]}})).unwrap();
+        match picture(&s).mode {
+            PictureMode::Stretch { fill_rect } => assert_eq!(fill_rect, [0.1, 0.2, 0.0, 0.0]),
+            other => panic!("expected a stretch, got {other:?}"),
+        }
+
+        s.execute("slide.new", &json!({})).unwrap();
+        assert!(s.doc().unwrap().doc.slides[1].background.is_none());
+        s.execute("slide.go", &json!({"index": 0})).unwrap();
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"copy": true})).unwrap();
+        assert_eq!(s.doc().unwrap().doc.slides[1].background, s.doc().unwrap().doc.slides[0].background);
+        assert_eq!(undo_len(&s), n + 1);
+        assert_eq!(s.doc().unwrap().history.undo.last().unwrap().label, "Format Background");
+        s.execute("design.background", &json!({"copy": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1, "copying an already shared background is not an undo step");
+    }
 }
 
 #[cfg(test)]