Keep an edit under a name, not just on the clipboard
FR-DEV-6 asks for three things — named presets, copy/paste between images, and batch-apply to a selection. The last two have been here for a while; this is the first. The format is the sidecar's, deliberately. A preset *is* the non-default half of a version, so the lines are the same lines keyed the same way, which makes the two files diffable against each other and lets someone debugging an edit paste a block from one into the other. One file rather than one per preset: a preset per file makes the name a path, and every name then has to survive a filesystem — a `/` becomes a directory, a name differing only in case collides on one platform and not another, and renaming becomes two operations that can half-fail. As a key in a document it is none of those. Unknown *parameters* needed no machinery. `Preset` already holds whatever keys it is given and resolves them against the descriptors only at apply time, so one written by a newer build survives by being stored. Only lines that are not `op.param = float` at all are preserved verbatim, which is the sidecar's version-skew promise made here too. Applying is the paste path with a different source, so a preset reaches a selection through the sidecar read-modify-write that was already there: no graph, no decode, no GPU, forty files or one. Two smaller decisions worth the record. A library that fails to parse is held empty in memory and *not* written back over — settings regenerate themselves and this is work, so a parse failure must not be the moment it is destroyed. And every save persists immediately and rolls the in-memory copy back if the write fails, so the sheet never lists a preset the file does not have. The grid's "Presets" button is gated on the selection alone, unlike the "Paste to 40" beside it. That button needs a clipboard armed this session; the preset list is whatever was saved last month, and hiding it behind an unrelated action is what makes a feature only its author knows about. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5
@@ -39,6 +39,7 @@ mod library_ui;
|
||||
mod live_style;
|
||||
mod masks_ui;
|
||||
mod net_runtime;
|
||||
mod preset_store;
|
||||
mod presets;
|
||||
mod remote;
|
||||
mod segmentation;
|
||||
@@ -2021,6 +2022,24 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
|
||||
collections.clone(),
|
||||
);
|
||||
|
||||
// TRACES: FR-DEV-6
|
||||
// The saved half of the same requirement, wired from the same bundle:
|
||||
// applying a named preset to the open image is the paste path with a
|
||||
// different source.
|
||||
presets::wire_named(
|
||||
&window,
|
||||
presets::NamedPresets::open(),
|
||||
presets::Develop {
|
||||
session: session.clone(),
|
||||
rows: rows.clone(),
|
||||
redraw: redraw.clone(),
|
||||
open: open_image.clone(),
|
||||
},
|
||||
settings.clone(),
|
||||
library.clone(),
|
||||
collections.clone(),
|
||||
);
|
||||
|
||||
// Close the knot left open beside `open_from_library`: the grid's
|
||||
// "‹ Library" button was wired before there was a session to save.
|
||||
let weak = window.as_weak();
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
//! TRACES: FR-DEV-6 | FR-PLAT-LIN-1
|
||||
//! Reads and writes the named preset library beside the other config.
|
||||
//!
|
||||
//! A near-twin of [`SettingsStore`](crate::settings_store::SettingsStore), and
|
||||
//! separate from it for the reason that one is: two files, two lifetimes.
|
||||
//! Resetting preferences must not destroy a photographer's presets, and a
|
||||
//! preset library is the one file here that represents work rather than
|
||||
//! configuration — it is what someone would carry to another machine.
|
||||
//!
|
||||
//! # Why the library is loaded whole and saved whole
|
||||
//!
|
||||
//! There is no incremental path. The document is kilobytes (see
|
||||
//! [`PresetLibrary`]), the caller is holding the copy the user just edited,
|
||||
//! and a merge would let a preset the window has not drawn yet resurrect
|
||||
//! after a delete. The same argument the settings store makes about fields,
|
||||
//! made about entries.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use dr_pipeline::PresetLibrary;
|
||||
|
||||
/// Loads and saves the named preset library.
|
||||
pub struct PresetStore {
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
impl PresetStore {
|
||||
/// Open the store at the platform config location.
|
||||
///
|
||||
/// Linux: `$XDG_CONFIG_HOME/darkroom/presets.drpl`, falling back to
|
||||
/// `~/.config` — the same resolution `SettingsStore` does, so the files sit
|
||||
/// together and a user backing up one takes all of them.
|
||||
pub fn open() -> Self {
|
||||
let dir = std::env::var_os("XDG_CONFIG_HOME")
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| {
|
||||
PathBuf::from(std::env::var("HOME").unwrap_or_default()).join(".config")
|
||||
})
|
||||
.join("darkroom");
|
||||
Self::open_at(dir.join(format!(
|
||||
"presets.{}",
|
||||
dr_pipeline::preset::LIBRARY_EXTENSION
|
||||
)))
|
||||
}
|
||||
|
||||
/// Open at an explicit path — for tests, and for a non-default location.
|
||||
pub fn open_at(path: PathBuf) -> Self {
|
||||
Self { path }
|
||||
}
|
||||
|
||||
pub fn path(&self) -> &Path {
|
||||
&self.path
|
||||
}
|
||||
|
||||
/// The stored library, or an empty one.
|
||||
///
|
||||
/// A missing file is a first run. An unparseable one is answered with an
|
||||
/// empty library rather than an error, on the same reasoning the settings
|
||||
/// store gives — the alternative is an app that will not start until the
|
||||
/// user hand-edits a file.
|
||||
///
|
||||
/// The difference worth stating: settings are regenerated on the next
|
||||
/// save, where a preset library is *work*, and rewriting it whole would
|
||||
/// destroy whatever was in there. So a library that failed to parse is
|
||||
/// held empty in memory and **not** written back over until the user saves
|
||||
/// a preset, at which point they have chosen to. Nothing here deletes the
|
||||
/// file, and the warning names the path so it can be recovered by hand.
|
||||
pub fn load(&self) -> PresetLibrary {
|
||||
match std::fs::read_to_string(&self.path) {
|
||||
Ok(text) => match PresetLibrary::parse(&text) {
|
||||
Ok(library) => library,
|
||||
Err(e) => {
|
||||
log::warn!(
|
||||
"{} is not a readable preset library ({e}); \
|
||||
starting empty, the file is left alone",
|
||||
self.path.display()
|
||||
);
|
||||
PresetLibrary::default()
|
||||
}
|
||||
},
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => PresetLibrary::default(),
|
||||
Err(e) => {
|
||||
log::warn!("reading {}: {e}; starting empty", self.path.display());
|
||||
PresetLibrary::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Persist the library, replacing whatever was there.
|
||||
pub fn save(&self, library: &PresetLibrary) -> Result<(), PresetStoreError> {
|
||||
if let Some(parent) = self.path.parent() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
|
||||
// Write and rename, so an interrupted save cannot truncate the
|
||||
// existing file — the same discipline the settings and session stores
|
||||
// use, and it matters more here because what would be truncated is
|
||||
// every preset the user has ever made rather than a set of
|
||||
// preferences that rebuild themselves.
|
||||
let tmp = self.path.with_extension("tmp");
|
||||
std::fs::write(&tmp, library.to_text())?;
|
||||
std::fs::rename(&tmp, &self.path)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum PresetStoreError {
|
||||
#[error("preset library io: {0}")]
|
||||
Io(#[from] std::io::Error),
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use dr_pipeline::Preset;
|
||||
|
||||
/// The same hand-rolled temp directory the settings store's tests use —
|
||||
/// unique per process and thread, so a parallel run cannot collide.
|
||||
fn tempdir(name: &str) -> PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!(
|
||||
"dr-presets-test-{name}-{}-{:?}",
|
||||
std::process::id(),
|
||||
std::thread::current().id()
|
||||
));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
fn store(name: &str) -> (PresetStore, PathBuf) {
|
||||
let dir = tempdir(name);
|
||||
(
|
||||
PresetStore::open_at(dir.join("nested").join("presets.drpl")),
|
||||
dir,
|
||||
)
|
||||
}
|
||||
|
||||
fn library() -> PresetLibrary {
|
||||
let mut lib = PresetLibrary::default();
|
||||
let mut params = std::collections::BTreeMap::new();
|
||||
params.insert(("exposure".to_string(), "exposure".to_string()), 0.75);
|
||||
lib.insert("Warm", Preset::from_params(params)).unwrap();
|
||||
lib.insert("Neutral", Preset::default()).unwrap();
|
||||
lib
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_library_round_trips_through_the_store() {
|
||||
let (store, _dir) = store("a-library-round-trips-through-the-store");
|
||||
store.save(&library()).unwrap();
|
||||
assert_eq!(store.load(), library());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_first_run_loads_an_empty_library() {
|
||||
let (store, _dir) = store("a-first-run-loads-an-empty-library");
|
||||
assert!(!store.path().exists());
|
||||
assert!(store.load().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn saving_creates_the_config_directory() {
|
||||
let (store, _dir) = store("saving-creates-the-config-directory");
|
||||
store.save(&library()).unwrap();
|
||||
assert!(store.path().exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unreadable_file_is_left_alone_rather_than_overwritten() {
|
||||
// The difference from the settings store, and the reason this test
|
||||
// exists: what is on disk is work, so a parse failure must not be the
|
||||
// moment it is destroyed.
|
||||
let (store, _dir) = store("an-unreadable-file-is-left-alone-rather-than-overwritten");
|
||||
std::fs::create_dir_all(store.path().parent().unwrap()).unwrap();
|
||||
std::fs::write(store.path(), "this is not a preset library").unwrap();
|
||||
|
||||
assert!(store.load().is_empty());
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(store.path()).unwrap(),
|
||||
"this is not a preset library"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_neutral_preset_survives_a_save_and_load() {
|
||||
// It is a real entry, not an absence — see `PresetLibrary::insert`.
|
||||
let (store, _dir) = store("a-neutral-preset-survives-a-save-and-load");
|
||||
store.save(&library()).unwrap();
|
||||
assert_eq!(store.load().get("Neutral"), Some(&Preset::default()));
|
||||
}
|
||||
}
|
||||
+421
-6
@@ -35,10 +35,11 @@ use std::cell::RefCell;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::rc::Rc;
|
||||
|
||||
use dr_pipeline::{Preset, Scope, Sidecar};
|
||||
use dr_pipeline::{NameError, Preset, PresetLibrary, Scope, Sidecar};
|
||||
use slint::ComponentHandle;
|
||||
|
||||
use crate::develop::DevelopSession;
|
||||
use crate::preset_store::PresetStore;
|
||||
use crate::{library, library_ui, settings_ui, AppWindow, ParamRow};
|
||||
|
||||
/// Where the develop view's current edit is stored.
|
||||
@@ -121,11 +122,21 @@ impl Clipboard {
|
||||
let Some(preset) = self.preset.borrow().clone() else {
|
||||
return String::new();
|
||||
};
|
||||
match preset.op_count(scope) {
|
||||
0 => "Neutral".to_string(),
|
||||
1 => "1 adjustment".to_string(),
|
||||
n => format!("{n} adjustments"),
|
||||
}
|
||||
describe(&preset, scope)
|
||||
}
|
||||
}
|
||||
|
||||
/// A short description of a preset's contents, for a label.
|
||||
///
|
||||
/// Free rather than a method on [`Clipboard`] because the named-preset sheet
|
||||
/// describes what *saving* would capture, and a second phrasing of the same
|
||||
/// count is a second thing to keep in step — the sheet saying "3 settings"
|
||||
/// beside a panel saying "3 adjustments" would read as two different numbers.
|
||||
pub fn describe(preset: &Preset, scope: Scope) -> String {
|
||||
match preset.op_count(scope) {
|
||||
0 => "Neutral".to_string(),
|
||||
1 => "1 adjustment".to_string(),
|
||||
n => format!("{n} adjustments"),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -528,6 +539,308 @@ pub fn wire(
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Named presets (FR-DEV-6)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// TRACES: FR-DEV-6
|
||||
/// The saved preset library, and the file it lives in.
|
||||
///
|
||||
/// # Why the library is held in memory as well as on disk
|
||||
///
|
||||
/// Every change writes the whole file (see [`PresetStore`]), so the in-memory
|
||||
/// copy is what the sheet is drawn from and what the next edit is applied to.
|
||||
/// Reading the file back after each change would be the same bytes and one
|
||||
/// more chance for a failed read to empty a list the user is looking at.
|
||||
///
|
||||
/// # A failed save is reported, not swallowed
|
||||
///
|
||||
/// The clipboard cannot fail — it is memory. This can: a full disk, a config
|
||||
/// directory that is not writable. Losing a preset the user just named, with
|
||||
/// the sheet cheerfully listing it, would be discovered at the worst possible
|
||||
/// moment, so the write's result reaches the window.
|
||||
pub struct NamedPresets {
|
||||
store: PresetStore,
|
||||
library: RefCell<PresetLibrary>,
|
||||
}
|
||||
|
||||
impl NamedPresets {
|
||||
/// Load the library from its usual place.
|
||||
pub fn open() -> Rc<Self> {
|
||||
Self::at(PresetStore::open())
|
||||
}
|
||||
|
||||
/// Load from an explicit store — for tests, and for a non-default location.
|
||||
#[cfg(test)]
|
||||
pub fn open_at(path: PathBuf) -> Rc<Self> {
|
||||
Self::at(PresetStore::open_at(path))
|
||||
}
|
||||
|
||||
fn at(store: PresetStore) -> Rc<Self> {
|
||||
let library = RefCell::new(store.load());
|
||||
Rc::new(Self { store, library })
|
||||
}
|
||||
|
||||
/// The stored names, in the order they are written.
|
||||
pub fn names(&self) -> Vec<String> {
|
||||
self.library.borrow().names().map(String::from).collect()
|
||||
}
|
||||
|
||||
/// The preset stored under `name`.
|
||||
pub fn get(&self, name: &str) -> Option<Preset> {
|
||||
self.library.borrow().get(name).cloned()
|
||||
}
|
||||
|
||||
/// Store `preset` under `name` and persist.
|
||||
///
|
||||
/// The in-memory library is updated first and rolled back if the write
|
||||
/// fails, so what the sheet lists is always what is on disk. The
|
||||
/// alternative — writing first — would mean holding a preset the file does
|
||||
/// not have on every failure path.
|
||||
fn insert(&self, name: &str, preset: Preset) -> Result<(), SaveError> {
|
||||
let previous = {
|
||||
let mut library = self.library.borrow_mut();
|
||||
let existing = library.get(name.trim()).cloned();
|
||||
library.insert(name, preset).map_err(SaveError::Name)?;
|
||||
existing
|
||||
};
|
||||
self.persist(|library| match previous {
|
||||
Some(p) => {
|
||||
let _ = library.insert(name, p);
|
||||
}
|
||||
None => {
|
||||
library.remove(name.trim());
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Save the library, undoing the in-memory change if the write fails.
|
||||
fn persist(&self, rollback: impl FnOnce(&mut PresetLibrary)) -> Result<(), SaveError> {
|
||||
let result = self.store.save(&self.library.borrow());
|
||||
match result {
|
||||
Ok(()) => Ok(()),
|
||||
Err(e) => {
|
||||
rollback(&mut self.library.borrow_mut());
|
||||
// Named, the way the settings page names its file: "could not
|
||||
// save" without saying where leaves the user nothing to check
|
||||
// and nothing to fix.
|
||||
Err(SaveError::Write(format!(
|
||||
"{}: {e}",
|
||||
self.store.path().display()
|
||||
)))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Why a preset could not be saved.
|
||||
enum SaveError {
|
||||
/// The name itself was refused.
|
||||
Name(NameError),
|
||||
/// The library could not be written.
|
||||
Write(String),
|
||||
}
|
||||
|
||||
impl SaveError {
|
||||
/// What to put in front of the user.
|
||||
///
|
||||
/// The prose lives here rather than in `dr-pipeline`, which depends on
|
||||
/// nothing and has no business holding user-facing strings.
|
||||
fn message(&self) -> String {
|
||||
match self {
|
||||
Self::Name(NameError::Empty) => "Give the preset a name.".to_string(),
|
||||
Self::Name(NameError::Unrepresentable) => {
|
||||
"A preset name cannot contain brackets or line breaks.".to_string()
|
||||
}
|
||||
Self::Write(e) => format!("Could not save presets: {e}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Push the stored names onto the window.
|
||||
pub fn render_named(window: &AppWindow, named: &Rc<NamedPresets>) {
|
||||
let names: Vec<slint::SharedString> = named.names().into_iter().map(Into::into).collect();
|
||||
window.set_preset_names(slint::ModelRc::new(slint::VecModel::from(names)));
|
||||
}
|
||||
|
||||
/// Wire saving, applying, renaming and deleting named presets.
|
||||
///
|
||||
/// Takes the same [`Develop`] bundle the clipboard wiring does, and for the
|
||||
/// same reason: applying a preset to the open image changes the graph, so it
|
||||
/// has to rebuild the panel, redraw the canvas and know where to save.
|
||||
pub fn wire_named(
|
||||
window: &AppWindow,
|
||||
named: Rc<NamedPresets>,
|
||||
develop: Develop,
|
||||
settings: Rc<settings_ui::SettingsController>,
|
||||
library: Rc<library_ui::LibraryController>,
|
||||
collections: Rc<crate::collections_ui::CollectionsController>,
|
||||
) {
|
||||
let Develop {
|
||||
session,
|
||||
rows,
|
||||
redraw,
|
||||
open,
|
||||
} = develop;
|
||||
|
||||
render_named(window, &named);
|
||||
|
||||
// --- save the open edit under a name ---------------------------------
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
let named = named.clone();
|
||||
let session = session.clone();
|
||||
window.on_save_preset(move |name| {
|
||||
let Some(w) = weak.upgrade() else { return };
|
||||
let Some(preset) = session.borrow().as_ref().map(|s| s.copy_settings()) else {
|
||||
w.set_preset_name_error("Open a photograph first.".into());
|
||||
return;
|
||||
};
|
||||
// Captured at full scope, exactly as a copy is: the scope is a
|
||||
// decision about applying, and a preset that had already discarded
|
||||
// the crop could never grow it back (see `Preset::capture`).
|
||||
match named.insert(&name, preset) {
|
||||
Ok(()) => {
|
||||
w.set_preset_name_error(Default::default());
|
||||
render_named(&w, &named);
|
||||
}
|
||||
Err(e) => w.set_preset_name_error(e.message().into()),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// A refusal the user has started correcting is stale, and a message that
|
||||
// outlives its cause is one the user learns to ignore.
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
window.on_preset_name_edited(move |_| {
|
||||
if let Some(w) = weak.upgrade() {
|
||||
w.set_preset_name_error(Default::default());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// --- what saving would capture ----------------------------------------
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
let session = session.clone();
|
||||
window.on_presets_opened(move || {
|
||||
let Some(w) = weak.upgrade() else { return };
|
||||
// At the scope a save would use, which is full: a preset keeps
|
||||
// the framing it was captured with and drops it at apply time.
|
||||
let summary = session
|
||||
.borrow()
|
||||
.as_ref()
|
||||
.map(|s| describe(&s.copy_settings(), Scope::Everything))
|
||||
.unwrap_or_default();
|
||||
w.set_preset_capture_summary(summary.into());
|
||||
});
|
||||
}
|
||||
|
||||
// --- apply ------------------------------------------------------------
|
||||
//
|
||||
// One callback for both targets. Which one is meant is not a guess: the
|
||||
// sheet was opened from a view that set `preset-apply-count`, and the
|
||||
// label the user just read said "Applies to 12 selected photographs" or
|
||||
// said nothing. Deciding here from the same number keeps the promise.
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
let named = named.clone();
|
||||
let settings = settings.clone();
|
||||
let library = library.clone();
|
||||
let collections = collections.clone();
|
||||
let session = session.clone();
|
||||
let rows = rows.clone();
|
||||
let redraw = redraw.clone();
|
||||
let open = open.clone();
|
||||
window.on_apply_preset(move |name| {
|
||||
let Some(w) = weak.upgrade() else { return };
|
||||
let Some(preset) = named.get(&name) else {
|
||||
// Another window may have deleted it since this list was drawn.
|
||||
render_named(&w, &named);
|
||||
return;
|
||||
};
|
||||
let scope = scope_for(&settings.snapshot());
|
||||
|
||||
if w.get_preset_apply_count() > 0 {
|
||||
library_ui::paste_settings_to_selection(
|
||||
&w,
|
||||
&library,
|
||||
&collections.selected(),
|
||||
&preset,
|
||||
scope,
|
||||
);
|
||||
} else {
|
||||
{
|
||||
let mut slot = session.borrow_mut();
|
||||
let Some(s) = slot.as_mut() else { return };
|
||||
s.apply_settings(&preset, scope);
|
||||
}
|
||||
// The same three steps a paste takes, for the same reasons:
|
||||
// many controls moved without any of them being touched, and
|
||||
// a deliberate discrete action is saved immediately.
|
||||
crate::sync_rows(&w, &rows, &session);
|
||||
redraw(&w);
|
||||
save_open_edit(&w, &open.borrow(), &session, &library);
|
||||
}
|
||||
|
||||
w.set_presets_open(false);
|
||||
});
|
||||
}
|
||||
|
||||
// --- rename -----------------------------------------------------------
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
let named = named.clone();
|
||||
window.on_rename_preset(move |from, to| {
|
||||
let Some(w) = weak.upgrade() else { return };
|
||||
let renamed = {
|
||||
let mut library = named.library.borrow_mut();
|
||||
library.rename(&from, &to)
|
||||
};
|
||||
match renamed {
|
||||
Ok(_) => {
|
||||
// Nothing to roll back to on a failed write beyond the
|
||||
// name it had, which is what this restores.
|
||||
let from = from.to_string();
|
||||
let to = to.to_string();
|
||||
if let Err(e) = named.persist(move |library| {
|
||||
let _ = library.rename(&to, &from);
|
||||
}) {
|
||||
w.set_preset_name_error(e.message().into());
|
||||
}
|
||||
}
|
||||
Err(e) => w.set_preset_name_error(SaveError::Name(e).message().into()),
|
||||
}
|
||||
render_named(&w, &named);
|
||||
});
|
||||
}
|
||||
|
||||
// --- delete -----------------------------------------------------------
|
||||
{
|
||||
let weak = window.as_weak();
|
||||
let named = named.clone();
|
||||
window.on_delete_preset(move |name| {
|
||||
let Some(w) = weak.upgrade() else { return };
|
||||
let removed = {
|
||||
let mut library = named.library.borrow_mut();
|
||||
let previous = library.get(&name).cloned();
|
||||
library.remove(&name);
|
||||
previous
|
||||
};
|
||||
if let Some(previous) = removed {
|
||||
let name = name.to_string();
|
||||
if let Err(e) = named.persist(move |library| {
|
||||
let _ = library.insert(&name, previous);
|
||||
}) {
|
||||
w.set_preset_name_error(e.message().into());
|
||||
}
|
||||
}
|
||||
render_named(&w, &named);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// Seconds since the epoch, or zero if the clock is before it.
|
||||
///
|
||||
/// Zero rather than a panic: a wrong timestamp costs a tie-break in the merge,
|
||||
@@ -804,4 +1117,106 @@ mod tests {
|
||||
assert!(clipboard.is_armed());
|
||||
assert_eq!(clipboard.describe(Scope::Adjustments), "Neutral");
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// Named presets
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
fn named(name: &str) -> (Rc<NamedPresets>, PathBuf) {
|
||||
let dir = tempdir(name);
|
||||
(NamedPresets::open_at(dir.join("presets.drpl")), dir)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_saved_preset_is_on_disk_before_the_call_returns() {
|
||||
// Not on the way out, and not on a timer: a preset the user named and
|
||||
// then lost to a crash is the one failure this feature cannot have.
|
||||
let (presets, dir) = named("saved-immediately");
|
||||
presets
|
||||
.insert("Warm", Preset::capture(&edited()))
|
||||
.ok()
|
||||
.expect("saved");
|
||||
|
||||
let reloaded = NamedPresets::open_at(dir.join("presets.drpl"));
|
||||
assert_eq!(reloaded.names(), vec!["Warm".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_saved_preset_carries_the_edit_it_captured() {
|
||||
let (presets, _dir) = named("carries-the-edit");
|
||||
presets.insert("Warm", Preset::capture(&edited())).ok();
|
||||
|
||||
let preset = presets.get("Warm").expect("stored");
|
||||
let mut target = EditGraph::default_chain();
|
||||
preset.apply(&mut target, Scope::Adjustments);
|
||||
assert_eq!(
|
||||
target.param(
|
||||
dr_pipeline::ops::exposure::ID,
|
||||
dr_pipeline::ops::exposure::EXPOSURE
|
||||
),
|
||||
Some(1.5)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_name_that_cannot_be_stored_is_refused_rather_than_mangled() {
|
||||
let (presets, _dir) = named("refused-name");
|
||||
assert!(presets.insert("", Preset::default()).is_err());
|
||||
assert!(presets.insert("bracket]", Preset::default()).is_err());
|
||||
assert!(presets.names().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_write_that_fails_leaves_the_list_showing_what_is_on_disk() {
|
||||
// The rollback. A sheet listing a preset the file does not have is a
|
||||
// loss the user discovers later, at the moment they reach for it.
|
||||
let dir = tempdir("failed-write");
|
||||
// A *file* where the store wants a directory, so `create_dir_all`
|
||||
// fails and the save cannot succeed.
|
||||
let blocked = dir.join("blocked");
|
||||
std::fs::write(&blocked, b"not a directory").unwrap();
|
||||
|
||||
let presets = NamedPresets::open_at(blocked.join("presets.drpl"));
|
||||
assert!(presets.insert("Warm", Preset::default()).is_err());
|
||||
assert!(
|
||||
presets.names().is_empty(),
|
||||
"the failed save left a preset behind"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failed_overwrite_puts_the_original_back() {
|
||||
// The other half of the rollback, and the one that loses work if it is
|
||||
// wrong: overwriting is destructive, so a failed overwrite has to
|
||||
// restore what was there rather than leave the name holding the new
|
||||
// value the file never received.
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let dir = tempdir("failed-overwrite");
|
||||
let path = dir.join("presets.drpl");
|
||||
let presets = NamedPresets::open_at(path.clone());
|
||||
presets.insert("Warm", Preset::capture(&edited())).ok();
|
||||
let original = presets.get("Warm").expect("stored");
|
||||
|
||||
// The directory exists, so `create_dir_all` still succeeds and it is
|
||||
// the write of the temporary file that fails — which is the path a
|
||||
// full disk takes.
|
||||
let mut perms = std::fs::metadata(&dir).unwrap().permissions();
|
||||
perms.set_mode(0o500);
|
||||
std::fs::set_permissions(&dir, perms.clone()).unwrap();
|
||||
|
||||
let failed = presets.insert("Warm", Preset::default()).is_err();
|
||||
|
||||
// Restore the permissions before asserting, so a failure here does not
|
||||
// leave an undeletable directory behind for the next run.
|
||||
perms.set_mode(0o700);
|
||||
std::fs::set_permissions(&dir, perms).unwrap();
|
||||
|
||||
assert!(failed, "the write should have failed");
|
||||
assert_eq!(
|
||||
presets.get("Warm"),
|
||||
Some(original),
|
||||
"the failed overwrite kept the new value"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -733,6 +733,10 @@ export component TransferPanel inherits VerticalLayout {
|
||||
|
||||
callback copy();
|
||||
callback paste();
|
||||
/// TRACES: FR-DEV-6
|
||||
/// Open the named-preset sheet. Beside copy and paste because it is the
|
||||
/// same thought given a name — this edit, kept.
|
||||
callback open-presets();
|
||||
|
||||
/// TRACES: FR-UI-2
|
||||
/// How wide this panel has to be before it starts clipping itself — the
|
||||
@@ -772,6 +776,16 @@ export component TransferPanel inherits VerticalLayout {
|
||||
}
|
||||
}
|
||||
|
||||
// TRACES: FR-DEV-6
|
||||
// The saved half. On its own row rather than a third of the one above,
|
||||
// because copy and paste are a pair — one arms the other — and a button
|
||||
// that does neither sitting between them would read as part of that pair.
|
||||
Button {
|
||||
text: "Presets…";
|
||||
enabled: root.enabled;
|
||||
clicked => { root.open-presets(); }
|
||||
}
|
||||
|
||||
if root.armed: Caption {
|
||||
text: root.summary + (root.framing-withheld ? " · crop not included" : "");
|
||||
}
|
||||
|
||||
@@ -10,6 +10,7 @@ import { LibraryGrid, LibraryCell, TimelineBar, PhotoRoll, KeywordRow, PersonChi
|
||||
import { Button, PanelHeading, Label, Value, Caption, Panel, EmptyState, ProgressBar, ActivityRow } from "widgets.slint";
|
||||
import { CollectionsPanel, CollectionRow, OfflinePrompt } from "collections.slint";
|
||||
import { HistogramPanel, HistogramView } from "histogram.slint";
|
||||
import { PresetSheet } from "presets.slint";
|
||||
import { SettingsPage } from "settings.slint";
|
||||
import { ImportPage } from "import.slint";
|
||||
import { StatusBar, InfoPanel } from "develop.slint";
|
||||
@@ -639,6 +640,35 @@ export component AppWindow inherits Window {
|
||||
/// Apply the clipboard to every selected image in the grid.
|
||||
callback paste-settings-to-selection();
|
||||
|
||||
// --- named presets (FR-DEV-6) ---
|
||||
//
|
||||
// The saved half of the same requirement. On the window rather than in a
|
||||
// view for the reason the clipboard is: a preset is saved in develop,
|
||||
// where there is an edit to capture, and applied most often in the grid,
|
||||
// where there is a selection to apply it to.
|
||||
in-out property <bool> presets-open: false;
|
||||
in property <[string]> preset-names;
|
||||
/// Whether there is an edit in hand to save, set by whichever view opened
|
||||
/// the sheet. `in-out` because that is where the answer is known.
|
||||
in-out property <bool> preset-can-save: false;
|
||||
/// What applying would act on: 0 is the open photograph, higher is that
|
||||
/// many selected. Set at open, and read back by Rust when one is picked —
|
||||
/// so the action matches the count the user read on the way in.
|
||||
in-out property <int> preset-apply-count: 0;
|
||||
/// What saving would capture, from the routine the clipboard summary uses.
|
||||
in property <string> preset-capture-summary;
|
||||
/// Why the last name was refused, cleared by the next keystroke.
|
||||
in property <string> preset-name-error;
|
||||
callback save-preset(string);
|
||||
callback apply-preset(string);
|
||||
callback rename-preset(string, string);
|
||||
callback delete-preset(string);
|
||||
callback preset-name-edited(string);
|
||||
/// Raised as the sheet opens over an open photograph, so Rust can say what
|
||||
/// saving would capture. A property refreshed on every slider drag would
|
||||
/// be recomputing a string nobody is looking at.
|
||||
callback presets-opened();
|
||||
|
||||
// --- settings (FR-EXP-1, FR-EXP-3, FR-NC-6a) ---
|
||||
//
|
||||
// A page rather than an overlay, and the outermost of the view conditions
|
||||
@@ -1410,6 +1440,15 @@ in property <bool> panel-visible: true;
|
||||
paste-settings-to-selection => {
|
||||
root.paste-settings-to-selection();
|
||||
}
|
||||
// TRACES: FR-DEV-6
|
||||
// Opened with the selection's size, which is both what the
|
||||
// sheet says it would act on and what the apply handler
|
||||
// reads back to decide it means the batch.
|
||||
open-presets => {
|
||||
root.preset-apply-count = root.library-selected-count;
|
||||
root.preset-can-save = false;
|
||||
root.presets-open = true;
|
||||
}
|
||||
|
||||
// TRACES: FR-EXP-7
|
||||
exporting: root.library-exporting;
|
||||
@@ -2203,6 +2242,15 @@ in property <bool> panel-visible: true;
|
||||
framing-withheld: root.settings-framing-withheld;
|
||||
copy => { root.copy-settings(); }
|
||||
paste => { root.paste-settings(); }
|
||||
// Opened with no count, which is what tells
|
||||
// the apply handler this means the open
|
||||
// photograph rather than a selection.
|
||||
open-presets => {
|
||||
root.preset-apply-count = 0;
|
||||
root.preset-can-save = root.adjust-enabled;
|
||||
root.presets-opened();
|
||||
root.presets-open = true;
|
||||
}
|
||||
}
|
||||
|
||||
Rectangle {
|
||||
@@ -2402,6 +2450,26 @@ in property <bool> panel-visible: true;
|
||||
// Below the load bar, above everything else: a download started from
|
||||
// here shows its progress in that bar, and the bar must not be the
|
||||
// thing the dialogue covers.
|
||||
// TRACES: FR-DEV-6
|
||||
// Over the shell rather than inside a view, because both views open
|
||||
// it — and because the develop column is 320px wide, which is not
|
||||
// enough to list presets and rename one in.
|
||||
if root.presets-open: PresetSheet {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
names: root.preset-names;
|
||||
can-save: root.preset-can-save;
|
||||
apply-count: root.preset-apply-count;
|
||||
capture-summary: root.preset-capture-summary;
|
||||
name-error: root.preset-name-error;
|
||||
save(name) => { root.save-preset(name); }
|
||||
apply(name) => { root.apply-preset(name); }
|
||||
rename(from, to) => { root.rename-preset(from, to); }
|
||||
remove(name) => { root.delete-preset(name); }
|
||||
name-edited(text) => { root.preset-name-edited(text); }
|
||||
dismiss => { root.presets-open = false; }
|
||||
}
|
||||
|
||||
OfflinePrompt {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
|
||||
@@ -850,6 +850,9 @@ component HeaderActions inherits HorizontalLayout {
|
||||
callback export-selection();
|
||||
callback cancel-export();
|
||||
callback paste-settings-to-selection();
|
||||
/// TRACES: FR-DEV-6
|
||||
/// Open the named-preset sheet over the selection.
|
||||
callback open-presets();
|
||||
callback remove-from-collection();
|
||||
/// Open the sheet that files the selection in a collection.
|
||||
callback add-to-collection();
|
||||
@@ -931,6 +934,20 @@ component HeaderActions inherits HorizontalLayout {
|
||||
clicked => { root.paste-settings-to-selection(); }
|
||||
}
|
||||
|
||||
// TRACES: FR-DEV-6
|
||||
// The saved settings, beside the copied ones.
|
||||
//
|
||||
// Gated on the selection alone, unlike the paste beside it: that button
|
||||
// needs a clipboard *this session*, where the preset list is whatever the
|
||||
// photographer saved last month. Requiring an armed clipboard here would
|
||||
// hide the saved presets behind an unrelated action — which is the shape
|
||||
// of bug that makes a feature only its author knows about (FR-UI-4).
|
||||
if root.selected-count > 0: Button {
|
||||
text: "Presets";
|
||||
y: root.centred ? (root.row-height - self.height) / 2 : 0;
|
||||
clicked => { root.open-presets(); }
|
||||
}
|
||||
|
||||
// TRACES: FR-EXP-7 | NFR-ARCH-3
|
||||
// Export the selection, and stop the batch that is running.
|
||||
//
|
||||
@@ -1332,6 +1349,8 @@ export component LibraryGrid inherits Rectangle {
|
||||
in property <bool> settings-armed: false;
|
||||
in property <string> settings-summary;
|
||||
callback paste-settings-to-selection();
|
||||
/// TRACES: FR-DEV-6
|
||||
callback open-presets();
|
||||
|
||||
// TRACES: FR-EXP-7
|
||||
// Exporting the selection. The grid owns neither the settings that decide
|
||||
@@ -1698,6 +1717,7 @@ export component LibraryGrid inherits Rectangle {
|
||||
export-selection => { root.export-selection(); }
|
||||
cancel-export => { root.cancel-export(); }
|
||||
paste-settings-to-selection => { root.paste-settings-to-selection(); }
|
||||
open-presets => { root.open-presets(); }
|
||||
remove-from-collection => { root.remove-from-collection(); }
|
||||
select-mode: root.select-mode;
|
||||
toggle-select-mode => { root.toggle-select-mode(); }
|
||||
@@ -1783,6 +1803,7 @@ export component LibraryGrid inherits Rectangle {
|
||||
export-selection => { root.export-selection(); }
|
||||
cancel-export => { root.cancel-export(); }
|
||||
paste-settings-to-selection => { root.paste-settings-to-selection(); }
|
||||
open-presets => { root.open-presets(); }
|
||||
remove-from-collection => { root.remove-from-collection(); }
|
||||
select-mode: root.select-mode;
|
||||
toggle-select-mode => { root.toggle-select-mode(); }
|
||||
|
||||
@@ -0,0 +1,210 @@
|
||||
import { Theme } from "theme.slint";
|
||||
import { Button, Field, Caption } from "widgets.slint";
|
||||
|
||||
// TRACES: FR-DEV-6
|
||||
// The named preset sheet: save the edit in hand, and apply a saved one.
|
||||
//
|
||||
// # One sheet for both views
|
||||
//
|
||||
// A preset is saved in develop, where there is an edit to capture, and applied
|
||||
// most often in the library, where there is a selection to apply it to. Those
|
||||
// are two different moments and it is the same list, so this is one component
|
||||
// mounted at the shell rather than a panel in each view — the same reasoning
|
||||
// the clipboard's properties are declared on the window for.
|
||||
//
|
||||
// What differs between the two is not the sheet but its *answers*: `can-save`
|
||||
// is false with nothing open, and `apply-count` says whether applying means
|
||||
// this photograph or those forty. Both are facts the shell already holds.
|
||||
//
|
||||
// # The same card, scrim and dismissal as the filing and keywording sheets
|
||||
//
|
||||
// Deliberately. A user who has filed a selection knows how this works, and a
|
||||
// second idiom for the same gesture would be a second thing to learn for no
|
||||
// gain.
|
||||
export component PresetSheet inherits Rectangle {
|
||||
/// The saved names, in the order they are stored.
|
||||
in property <[string]> names;
|
||||
/// Whether there is an edit in hand to save. False in the library, where
|
||||
/// nothing is open, and with an image that failed to decode.
|
||||
in property <bool> can-save: false;
|
||||
/// What a preset would be applied to: 0 means the open photograph, and
|
||||
/// anything higher means that many selected ones.
|
||||
in property <int> apply-count: 0;
|
||||
/// What saving would capture — "3 adjustments" — from the same routine the
|
||||
/// clipboard's summary comes from, so the two cannot disagree.
|
||||
in property <string> capture-summary;
|
||||
/// Set while a name is refused, and cleared by the next keystroke. Prose
|
||||
/// rather than a code, because the shell knows why and this does not.
|
||||
in property <string> name-error;
|
||||
|
||||
callback save(string);
|
||||
callback apply(string);
|
||||
callback rename(string, string);
|
||||
callback remove(string);
|
||||
callback dismiss();
|
||||
/// Every keystroke in the name field, so the shell can clear a refusal the
|
||||
/// user has started correcting.
|
||||
callback name-edited(string);
|
||||
|
||||
background: #000000CC;
|
||||
|
||||
// Swallows the taps that miss the card, and closes. First, so the card's
|
||||
// own controls sit above it.
|
||||
TouchArea {
|
||||
clicked => { root.dismiss(); }
|
||||
}
|
||||
|
||||
// Which row is being renamed, by name. Empty means none.
|
||||
//
|
||||
// A name rather than an index: the list is rebuilt from Rust after every
|
||||
// change, and an index would point at whatever moved into that slot.
|
||||
property <string> renaming: "";
|
||||
|
||||
Rectangle {
|
||||
width: min(420px, parent.width - 2 * Theme.gap-lg);
|
||||
height: min(sheet.preferred-height, parent.height - 2 * Theme.gap-lg);
|
||||
x: (parent.width - self.width) / 2;
|
||||
y: (parent.height - self.height) / 2;
|
||||
background: Theme.surface;
|
||||
border-radius: Theme.radius;
|
||||
border-width: 1px;
|
||||
border-color: Theme.rule;
|
||||
|
||||
// Stops a press on the card reaching the scrim behind it.
|
||||
TouchArea { }
|
||||
|
||||
sheet := VerticalLayout {
|
||||
padding: Theme.gap-lg;
|
||||
spacing: Theme.gap;
|
||||
|
||||
Text {
|
||||
text: "Presets";
|
||||
color: Theme.ink;
|
||||
font-size: Theme.text-lg;
|
||||
font-weight: 600;
|
||||
}
|
||||
|
||||
// Saving, first: it is the half that has something to say about
|
||||
// the photograph currently open, and it disappears entirely in the
|
||||
// library rather than sitting there disabled — a permanently dead
|
||||
// control teaches the reader that the sheet lies.
|
||||
if root.can-save: VerticalLayout {
|
||||
spacing: Theme.gap-sm;
|
||||
|
||||
name := Field {
|
||||
placeholder: "Name this edit and press return";
|
||||
accepted(text) => {
|
||||
root.save(text);
|
||||
// Cleared only once the shell has accepted it. A
|
||||
// refused name the user has to retype is a refusal
|
||||
// that costs more than the mistake did, so the field
|
||||
// keeps the text and `name-error` says why.
|
||||
if (root.name-error == "") {
|
||||
self.text = "";
|
||||
}
|
||||
}
|
||||
edited(text) => { root.name-edited(text); }
|
||||
}
|
||||
|
||||
if root.name-error != "": Caption {
|
||||
text: root.name-error;
|
||||
warn: true;
|
||||
}
|
||||
|
||||
// The bare summary, phrased exactly as the develop panel
|
||||
// phrases the clipboard's — same routine, same words, so the
|
||||
// two cannot appear to disagree about one edit.
|
||||
if root.name-error == "": Caption {
|
||||
text: root.capture-summary;
|
||||
}
|
||||
}
|
||||
|
||||
if root.can-save: Rectangle { height: 1px; background: Theme.rule; }
|
||||
|
||||
Flickable {
|
||||
vertical-stretch: 1;
|
||||
// A floor, so the list is not squeezed out of existence by the
|
||||
// field and the button around it on a short window.
|
||||
min-height: 120px;
|
||||
viewport-height: root.names.length * (Theme.touch-target + 2px);
|
||||
|
||||
for entry[i] in root.names: Rectangle {
|
||||
y: i * (Theme.touch-target + 2px);
|
||||
width: parent.width;
|
||||
height: Theme.touch-target;
|
||||
|
||||
if root.renaming != entry: HorizontalLayout {
|
||||
spacing: Theme.gap-sm;
|
||||
|
||||
// The name is the apply button rather than a label
|
||||
// beside one. Applying is what this list is for, and a
|
||||
// row whose largest target does nothing is a row that
|
||||
// gets pressed by accident and then distrusted.
|
||||
Button {
|
||||
text: entry;
|
||||
horizontal-stretch: 1;
|
||||
clicked => { root.apply(entry); }
|
||||
}
|
||||
|
||||
Button {
|
||||
text: "Rename";
|
||||
clicked => { root.renaming = entry; }
|
||||
}
|
||||
|
||||
Button {
|
||||
text: "Delete";
|
||||
clicked => { root.remove(entry); }
|
||||
}
|
||||
}
|
||||
|
||||
// Renaming in place rather than in a second sheet: a
|
||||
// dialogue over a dialogue is where a user loses track of
|
||||
// which one Escape closes.
|
||||
if root.renaming == entry: HorizontalLayout {
|
||||
spacing: Theme.gap-sm;
|
||||
|
||||
rename-field := Field {
|
||||
text: entry;
|
||||
horizontal-stretch: 1;
|
||||
accepted(text) => {
|
||||
root.rename(entry, text);
|
||||
root.renaming = "";
|
||||
}
|
||||
}
|
||||
|
||||
Button {
|
||||
text: "Cancel";
|
||||
clicked => { root.renaming = ""; }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if root.names.length == 0: Text {
|
||||
text: root.can-save
|
||||
? "No presets yet. Name the edit above to make the first."
|
||||
: "No presets yet. Open a photograph and save one from the develop panel.";
|
||||
color: Theme.ink-faint;
|
||||
font-size: Theme.text-sm;
|
||||
wrap: word-wrap;
|
||||
width: parent.width;
|
||||
}
|
||||
|
||||
// Says what applying would do *before* it is done, the same way
|
||||
// the grid's "Paste to 40" does — a count in the label is worth
|
||||
// more than a confirmation asking the same question afterwards.
|
||||
if root.names.length > 0 && root.apply-count > 0: Caption {
|
||||
text: root.apply-count == 1
|
||||
? "Applies to 1 selected photograph"
|
||||
: "Applies to " + root.apply-count + " selected photographs";
|
||||
}
|
||||
|
||||
Rectangle { height: 1px; background: Theme.rule; }
|
||||
|
||||
Button {
|
||||
text: "Done";
|
||||
clicked => { root.dismiss(); }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user