Merge remote-tracking branch 'origin/main' into pr-6083

This commit is contained in:
David Mann committed 2026-11-07 15:45:09 +01:00
commit 58b9630bec
2 files changed
+130 -8

No files matched your search

@@ -220,10 +220,11 @@ fn recorded_jpeg_saves_keep_their_options_and_replay_without_asking() {
steps,
&[
("file.saveAs".into(), json!({"path": "p.jpg", "quality": 10, "jpegFormat": "optimized"})),
("file.saveACopy".into(), json!({"path": "copy.jpg", "quality": 6, "jpegFormat": "baseline"})),
// The Save a Copy prompt starts at the format just chosen (it is remembered).
("file.saveACopy".into(), json!({"path": "copy.jpg", "quality": 6, "jpegFormat": "optimized"})),
]
);
let expected = [("p.jpg".to_string(), asked(pct(10), JpegFormat::Optimized)), ("copy.jpg".to_string(), asked(pct(6), JpegFormat::Baseline))];
let expected = [("p.jpg".to_string(), asked(pct(10), JpegFormat::Optimized)), ("copy.jpg".to_string(), asked(pct(6), JpegFormat::Optimized))];
assert_eq!(writes.borrow().as_slice(), &expected);
writes.borrow_mut().clear();
let played = h.state_mut().run("actions.play", json!({"action": 0})).unwrap();
@@ -270,3 +271,77 @@ fn a_save_can_choose_where_the_prompt_starts() {
assert_eq!(writes.borrow().as_slice(), &[("s.jpg".to_string(), asked(Some(70), JpegFormat::Progressive))]);
assert_eq!(h.state().session.actions.list[0].steps, [("file.saveAs".into(), json!({"path": "s.jpg", "jpegFormat": "progressive"}))]);
}
/// The JPEG Options dialog starts at what it was last answered with (#9631): the quality and the
/// format, for a document that isn't an opened JPEG. Cancel remembers nothing.
#[test]
fn the_next_dialog_starts_at_the_last_answer() {
let (mut h, writes) = jpeg_app("unused.jpg");
let ctx = h.ctx.clone();
h.state_mut().save_as(Some("a.jpg".into())).unwrap();
h.run_steps(2);
h.state_mut().jpeg_options.as_mut().unwrap().quality = 6;
h.run_steps(2);
h.get_by_label("Progressive").click();
h.run_steps(2);
h.get_by_label("Cancel").click();
h.run_steps(3);
assert!(writes.borrow().is_empty());
h.state_mut().save_as(Some("b.jpg".into())).unwrap();
h.run_steps(2);
assert_eq!(h.state().jpeg_options.as_ref().map(|p| (p.quality, p.format)), Some((10, JpegFormat::Baseline)), "a cancelled dialog is not an answer");
h.state_mut().jpeg_options.as_mut().unwrap().quality = 6;
h.run_steps(2);
h.get_by_label("Progressive").click();
h.run_steps(2);
h.get_by_label("OK").click();
h.run_steps(3);
crate::menus::invoke(h.state_mut(), &ctx, "file.saveACopy", json!({})).unwrap();
h.run_steps(3);
assert_eq!(h.state().jpeg_options.as_ref().map(|p| (p.quality, p.format, p.own_quality)), Some((6, JpegFormat::Progressive, None)));
h.key_press(Key::Enter);
h.run_steps(3);
let expected = [("b.jpg".to_string(), asked(pct(6), JpegFormat::Progressive)), ("unused.jpg".to_string(), asked(pct(6), JpegFormat::Progressive))];
assert_eq!(writes.borrow().as_slice(), &expected);
}
/// An opened JPEG still starts at its own quality (File › Save keeps it, #4032) but at the last
/// format; left on its own quality, the answer doesn't replace the quality remembered for other
/// documents.
#[test]
fn an_opened_jpeg_starts_at_its_own_quality_and_the_last_format() {
let (mut h, _writes) = jpeg_app("unused.jpg");
h.state_mut().session.prefs.edit(|p| {
p.dialogs.insert("file.jpegOptions".into(), json!({"quality": 3, "jpegFormat": "progressive"}));
});
std::sync::Arc::make_mut(&mut h.state_mut().session.active_mut().unwrap().doc).file_encoding.jpeg_quality = Some(95);
h.state_mut().save_as(Some("p.jpg".into())).unwrap();
h.run_steps(2);
assert_eq!(h.state().jpeg_options.as_ref().map(|p| (p.quality, p.format, p.own_quality)), Some((11, JpegFormat::Progressive, Some(95))));
h.key_press(Key::Enter);
h.run_steps(3);
let saved = h.state().session.prefs().dialogs.get("file.jpegOptions").cloned();
assert_eq!(saved, Some(json!({"quality": 3, "jpegFormat": "progressive"})), "the own quality is not an answer");
}
/// A remembered answer that no longer fits (a hand-edited preferences file) is ignored, value by
/// value.
#[test]
fn a_bad_remembered_answer_is_ignored() {
for (saved, expected) in [
(json!({"quality": 13, "jpegFormat": "progressive"}), (10, JpegFormat::Progressive)),
(json!({"quality": "8", "jpegFormat": "fast"}), (10, JpegFormat::Baseline)),
(json!({"quality": -1}), (10, JpegFormat::Baseline)),
(json!({"quality": 2.5, "jpegFormat": 1}), (10, JpegFormat::Baseline)),
(json!("not an object"), (10, JpegFormat::Baseline)),
(json!({"quality": 0, "jpegFormat": "optimized"}), (0, JpegFormat::Optimized)),
] {
let (mut h, _writes) = jpeg_app("unused.jpg");
h.state_mut().session.prefs.edit(|p| {
p.dialogs.insert("file.jpegOptions".into(), saved.clone());
});
h.state_mut().save_as(Some("p.jpg".into())).unwrap();
h.run_steps(2);
assert_eq!(h.state().jpeg_options.as_ref().map(|p| (p.quality, p.format)), Some(expected), "{saved}");
}
}
+53 -6
View File
@@ -3,7 +3,9 @@
//! 5–7, High 8–9, Maximum 10–12), mapped to the encoder's 1–100 by
//! `photocraft_engine::file_cmds::jpeg_quality`; Format Options are Baseline ("Standard"), Baseline
//! Optimized and Progressive. Matte, Scans and the size preview aren't offered yet. Re-saving an
//! opened JPEG starts at the file's own quality, as File › Save keeps it (#4032).
//! opened JPEG starts at the file's own quality, as File › Save keeps it (#4032). Otherwise the
//! dialog starts at the quality and format it was last answered with, also after a restart, as
//! Photoshop's does (see [`Start::for_active`]).
//!
//! The save is parked in [`Prompt`] while the modal is up (egui is immediate-mode) and written
//! once answered. Cancel drops the save. Scripts skip the prompt by passing `quality` or
@@ -135,16 +137,60 @@ impl Start {
Start { quality: quality_from_percent(quality), own_quality: None, format: JpegFormat::Baseline }
}
/// For the active document: its opened JPEG's own quality (`Document::file_encoding`), or
/// else the Export preferences' JPEG quality (the one Quick Export uses).
/// For the active document: the Format Options the dialog was last answered with, else
/// Baseline; and the quality of its opened JPEG (`Document::file_encoding`, which File › Save
/// keeps, #4032), else the quality last answered, else the Export preferences' JPEG quality
/// (the one Quick Export uses).
pub fn for_active(app: &PhotocraftApp) -> Self {
match app.session.active().and_then(|st| st.doc.file_encoding.jpeg_quality) {
let remembered = remembered(app);
let start = match app.session.active().and_then(|st| st.doc.file_encoding.jpeg_quality) {
Some(q) => Start::own(q),
None => Start::percent(app.session.prefs().export.jpeg_quality),
}
None => match remembered.quality {
Some(quality) => Start { quality, own_quality: None, format: JpegFormat::Baseline },
None => Start::percent(app.session.prefs().export.jpeg_quality),
},
};
Start { format: remembered.format.unwrap_or(start.format), ..start }
}
}
/// Preferences ▸ remembered dialog settings: JPEG Options writes its last answer under this key
/// and starts the next dialog from it, as Photoshop does (it keeps it across restarts). There is
/// no command of this id; the key only names the dialog among the others.
const REMEMBER_KEY: &str = "file.jpegOptions";
/// What the dialog was last answered with; a value that no longer fits (a hand-edited
/// preferences file) is left out.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct Remembered {
quality: Option<u8>,
format: Option<JpegFormat>,
}
fn remembered(app: &PhotocraftApp) -> Remembered {
let Some(Value::Object(saved)) = app.session.prefs().dialogs.get(REMEMBER_KEY) else { return Remembered::default() };
Remembered {
quality: saved.get("quality").and_then(Value::as_u64).and_then(|q| u8::try_from(q).ok()).filter(|&q| q <= MAX_QUALITY),
format: saved.get("jpegFormat").and_then(Value::as_str).and_then(JpegFormat::parse),
}
}
/// Records an answered dialog for the next one. A quality left on the opened file's own is not
/// an answer: the earlier one stays, so saving a series of opened JPEGs doesn't forget what a
/// new document was last saved at.
fn remember(app: &mut PhotocraftApp, choice: JpegChoice) {
let before = remembered(app);
let quality = choice.quality.or(before.quality);
let mut saved = serde_json::Map::new();
if let Some(q) = quality {
saved.insert("quality".into(), q.into());
}
saved.insert("jpegFormat".into(), choice.format.name().into());
app.session.prefs.edit(|p| {
p.dialogs.insert(REMEMBER_KEY.into(), Value::Object(saved));
});
}
/// A save waiting on the JPEG Options answer.
pub struct Prompt {
/// The document that requested the save, even if tabs change while this is open.
@@ -250,6 +296,7 @@ pub fn confirm(app: &mut PhotocraftApp, ctx: &egui::Context) {
// quality out, so a replay keeps the file's own quality too, as File › Save does (#4032).
let own = p.own_quality.filter(|&q| quality_from_percent(u32::from(q)) == p.quality);
let choice = JpegChoice { quality: own.is_none().then_some(p.quality), format: p.format };
remember(app, choice);
let step = if p.record == "file.save" {
// A plain Save writes whichever file the action is played on (#3531), with the answer.
plain_save_step(Some(choice))