refactor(ui-egui): split adjust_editors.rs into adjust_editors/

This commit is contained in:
aiongg committed 2026-10-26 22:54:55 +00:00
1 parent 0a45d8d79b
commit 17a3dd3204
7 files changed
+1546 -1503

No files matched your search

File diff suppressed because it is too large. Load diff
+287
View File
@@ -0,0 +1,287 @@
use super::hue_saturation::RANGE_LABELS;
use super::*;
/// Labelled slider rows over top-level keys: (key, label, min, max, default, unit).
/// A row of [`sliders`]: params key, label, range, default, unit, and its decimal places (None:
/// two for a range of 10 or less, else whole numbers).
type SliderRow<'a> = (&'a str, &'a str, f32, f32, f32, &'a str, Option<u32>);
/// The value a [`sliders`] row stores for `x`: rounded to `decimals` places, or by its range.
pub(crate) fn row_value(x: f32, min: f32, max: f32, decimals: Option<u32>) -> f32 {
match decimals {
Some(d) => {
let scale = 10f32.powi(d.min(6) as i32);
(x * scale).round() / scale
}
None if max - min <= 10.0 => round(x, 0.01),
None => x.round(),
}
}
pub(super) fn sliders(ui: &mut egui::Ui, v: &mut Value, rows: &[SliderRow]) -> Edit {
let mut e = Edit::default();
for &(key, text, min, max, default, unit, decimals) in rows {
let mut x = num(v, key, default).clamp(min, max);
// A double-click on the slider puts it back to its default (Photoshop).
let gestures = widgets::RowGestures { reset: Some(default), wheel_step: None, ..Default::default() };
let r = widgets::slider_row_prec(ui, text, &mut x, min..=max, unit, None, gestures, decimals);
if r.changed() {
v[key] = json!(row_value(x, min, max, decimals));
}
e.add(Edit::of(&r));
}
e
}
fn gradient_slider(ui: &mut egui::Ui, text: &str, x: &mut f32, range: std::ops::RangeInclusive<f32>, unit: &str, stops: [Color32; 2], dynamic: bool) -> Edit {
let r = widgets::slider_row(ui, text, x, range, unit, dynamic.then_some(&stops));
Edit::of(&r)
}
/// Preferences ▸ Interface ▸ Dynamic Color Sliders: the colour track for a slider, or the plain
/// track when it is off.
pub(super) fn track_stops<'a>(cx: &EditorCx, stops: &'a [Color32]) -> Option<&'a [Color32]> {
cx.dynamic_color_sliders.then_some(stops)
}
// ---------------------------------------------------------------------------------------------
// Brightness/Contrast
pub(super) fn brightness_contrast(ui: &mut egui::Ui, v: &mut Value) -> Edit {
let legacy = flag(v, "legacy", false);
let lo = if legacy { -100.0 } else { -50.0 };
let mut e = sliders(ui, v, &[("brightness", tl!("Brightness"), -150.0, 150.0, 0.0, "", None), ("contrast", tl!("Contrast"), lo, 100.0, 0.0, "", None)]);
let mut l = legacy;
if widgets::checkbox(ui, &mut l, tl!("Use Legacy")).changed() {
v["legacy"] = json!(l);
if !l {
v["contrast"] = json!(num(v, "contrast", 0.0).max(-50.0));
}
e.add(Edit::discrete(true));
}
e
}
// ---------------------------------------------------------------------------------------------
// Threshold
pub(super) fn threshold(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let t = Tokens::get(ui.ctx());
let w = ui.available_width().min(300.0);
let (hr, _) = ui.allocate_exact_size(vec2(w, 90.0), Sense::hover());
let hr = hr.shrink2(vec2(6.0, 0.0));
let p = ui.painter_at(hr.expand(1.0));
p.rect_filled(hr, 0.0, t.field);
if let Some(h) = &cx.hist {
tone::draw_histogram(&p, hr, &h[0], Color32::from_gray(if t.pro { 150 } else { 110 }));
}
let level = num(v, "level", 128.0);
let x = hr.left() + level / 255.0 * hr.width();
p.line_segment([pos2(x, hr.top()), pos2(x, hr.bottom())], Stroke::new(1.0, t.accent));
p.rect_stroke(hr, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Inside);
ui.add_space(4.0);
sliders(ui, v, &[("level", tl!("Threshold Level"), 1.0, 255.0, 128.0, "", None)])
}
// ---------------------------------------------------------------------------------------------
// Color Balance
/// Where the Color Balance editor rooted at `mem` keeps its Tone choice.
fn color_balance_tone_id(mem: egui::Id) -> egui::Id {
mem.with("cb-tone")
}
/// Photoshop's Color Balance reset to defaults (Alt+Cancel in the dialog; the Properties panel's
/// Reset once the layer is as the panel found it): every tone back to 0 and the Tone choice back
/// to Midtones; Preserve Luminosity stays as it is.
pub fn reset_color_balance(ctx: &egui::Context, mem: egui::Id, v: &mut Value) {
for key in ["shadows", "midtones", "highlights"] {
v[key] = json!([0.0, 0.0, 0.0]);
}
ctx.data_mut(|d| d.insert_temp(color_balance_tone_id(mem), 1usize));
}
/// Kind-specific editor memory after Alt+Reset (or Properties Reset to defaults). Color Balance
/// shows Midtones; other kinds have no dialog-local temp to clear yet.
pub fn reset_adjustment_editor(ctx: &egui::Context, kind: &str, mem: egui::Id, v: &mut Value) {
if kind == "colorBalance" {
reset_color_balance(ctx, mem, v);
}
}
pub(super) fn color_balance(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let tone_id = color_balance_tone_id(cx.mem);
let mut tone_ix: usize = ui.data(|d| d.get_temp(tone_id)).unwrap_or(1);
ui.horizontal(|ui| {
label(ui, tl!("Tone:"));
for (i, l) in [tl!("Shadows"), tl!("Midtones"), tl!("Highlights")].iter().enumerate() {
if ui.radio(tone_ix == i, *l).clicked() {
tone_ix = i;
}
}
});
ui.data_mut(|d| d.insert_temp(tone_id, tone_ix));
let key = ["shadows", "midtones", "highlights"][tone_ix.min(2)];
let mut vals = nums(v, key, [0.0; 3]);
let mut e = Edit::default();
let rows = [
(tl!("Cyan · Red"), Color32::from_rgb(0, 190, 210), Color32::from_rgb(225, 40, 40)),
(tl!("Magenta · Green"), Color32::from_rgb(210, 40, 190), Color32::from_rgb(40, 190, 60)),
(tl!("Yellow · Blue"), Color32::from_rgb(230, 210, 30), Color32::from_rgb(40, 80, 230)),
];
// Photoshop: a double-click on a slider zeroes it (this tone only); the dialog's sliders step
// with the wheel; Up/Down step the fields; Shift makes those steps 10.
let gestures = widgets::RowGestures { reset: Some(0.0), wheel_step: cx.dialog.then_some(1.0), ..Default::default() };
let mut changed = false;
for (i, (text, a, b)) in rows.iter().enumerate() {
let r = Edit::of(&widgets::slider_row_with(ui, text, &mut vals[i], -100.0..=100.0, "", Some(&[*a, *b]), gestures));
changed |= r.changed;
e.add(r);
}
if changed {
v[key] = json!(vals.map(f32::round));
}
let mut pl = flag(v, "preserveLuminosity", true);
if widgets::checkbox(ui, &mut pl, tl!("Preserve Luminosity")).changed() {
v["preserveLuminosity"] = json!(pl);
e.add(Edit::discrete(true));
}
e
}
// ---------------------------------------------------------------------------------------------
// Black & White
pub(super) fn black_white(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let mut e = Edit::default();
let colors = [[230, 50, 50], [235, 215, 40], [50, 200, 70], [40, 200, 220], [50, 90, 235], [220, 50, 210]];
for (i, key) in HUE_RANGES.iter().enumerate() {
let mut x = num(v, key, adjust_params::BW_DEFAULTS[i]).clamp(-200.0, 300.0);
let c = colors[i];
let r =
gradient_slider(ui, RANGE_LABELS[i], &mut x, -200.0..=300.0, "%", [Color32::BLACK, Color32::from_rgb(c[0], c[1], c[2])], cx.dynamic_color_sliders);
if r.changed {
v[*key] = json!(x.round());
}
e.add(r);
}
ui.add_space(2.0);
ui.horizontal(|ui| {
let mut on = flag(v, "tint", false);
if widgets::checkbox(ui, &mut on, tl!("Tint")).changed() {
v["tint"] = json!(on);
e.add(Edit::discrete(true));
}
let mut c = rgb_of(v, "tintColor", [0.882, 0.827, 0.702]);
let r = ui.add_enabled_ui(on, |ui| color_button(ui, &mut c)).inner;
if r.changed {
v["tintColor"] = json!(adjust_params::hex(c));
}
e.add(r);
if widgets::secondary_button(ui, tl!("Default"), 0.0).clicked() {
for (i, key) in HUE_RANGES.iter().enumerate() {
v[*key] = json!(adjust_params::BW_DEFAULTS[i]);
}
e.add(Edit::discrete(true));
}
});
e
}
// ---------------------------------------------------------------------------------------------
// Photo Filter
pub(super) fn photo_filter(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let mut e = Edit::default();
let mut c = rgb_of(v, "color", [236.0 / 255.0, 138.0 / 255.0, 0.0]);
let hex = adjust_params::hex(c);
let preset = PHOTO_FILTERS.iter().find(|f| adjust_params::hex(f.2.map(|x| f32::from(x) / 255.0)) == hex).map(|f| f.0);
let mode_id = cx.mem.with("pf-mode");
let mut use_color: bool = ui.data(|d| d.get_temp(mode_id)).unwrap_or(preset.is_none());
ui.horizontal(|ui| {
if ui.radio(!use_color, tl!("Filter:")).clicked() {
use_color = false;
}
let mut sel = preset.unwrap_or("custom").to_string();
let mut opts: Vec<(String, &str)> = PHOTO_FILTERS.iter().map(|f| (f.0.to_string(), f.1)).collect();
if preset.is_none() {
opts.insert(0, ("custom".into(), "Custom"));
}
let changed = ui.add_enabled_ui(!use_color, |ui| widgets::dropdown(ui, &format!("{mode_id:?}-filter"), tl!("Filter:"), &mut sel, &opts, 170.0)).inner;
if changed && let Some(f) = PHOTO_FILTERS.iter().find(|f| f.0 == sel) {
c = f.2.map(|x| f32::from(x) / 255.0);
v["color"] = json!(adjust_params::hex(c));
e.add(Edit::discrete(true));
}
});
ui.horizontal(|ui| {
if ui.radio(use_color, tl!("Color:")).clicked() {
use_color = true;
}
let r = ui.add_enabled_ui(use_color, |ui| color_button(ui, &mut c)).inner;
if r.changed {
v["color"] = json!(adjust_params::hex(c));
}
e.add(r);
});
ui.data_mut(|d| d.insert_temp(mode_id, use_color));
e.add(sliders(ui, v, &[("density", tl!("Density"), 0.0, 100.0, 25.0, "%", None)]));
let mut pl = flag(v, "preserveLuminosity", true);
if widgets::checkbox(ui, &mut pl, tl!("Preserve Luminosity")).changed() {
v["preserveLuminosity"] = json!(pl);
e.add(Edit::discrete(true));
}
e
}
// ---------------------------------------------------------------------------------------------
// Channel Mixer
pub(super) fn channel_mixer(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let t = Tokens::get(ui.ctx());
let mono = flag(v, "monochrome", false);
let out_id = cx.mem.with("cm-out");
let mut out: usize = ui.data(|d| d.get_temp(out_id)).unwrap_or(0);
let outs: &[(usize, &str)] = if mono { &[(0, tl!("Gray"))] } else { &[(0, tl!("Red")), (1, tl!("Green")), (2, tl!("Blue"))] };
if out >= outs.len() {
out = 0;
}
ui.horizontal(|ui| {
label(ui, tl!("Output Channel:"));
widgets::dropdown(ui, &format!("{out_id:?}"), tl!("Output Channel:"), &mut out, outs, 110.0);
});
ui.data_mut(|d| d.insert_temp(out_id, out));
let key = if mono { "gray" } else { ["red", "green", "blue"][out] };
let identity: [f32; 4] = if mono { [40.0, 40.0, 20.0, 0.0] } else { std::array::from_fn(|i| if i == out { 100.0 } else { 0.0 }) };
let mut row = nums(v, key, if mono { nums(v, "red", identity) } else { identity });
let mut e = Edit::default();
let mut changed = false;
for (i, (text, c)) in [(tl!("Red"), [225, 50, 50]), (tl!("Green"), [50, 190, 70]), (tl!("Blue"), [60, 100, 235])].iter().enumerate() {
let r = gradient_slider(ui, text, &mut row[i], -200.0..=200.0, "%", [Color32::BLACK, Color32::from_rgb(c[0], c[1], c[2])], cx.dynamic_color_sliders);
changed |= r.changed;
e.add(r);
}
let total = row[0] + row[1] + row[2];
ui.horizontal(|ui| {
label(ui, tl!("Total:"));
let warn = total > 100.0;
ui.label(RichText::new(format!("{total:+.0}%")).font(crate::theme::mono(12.0)).color(if warn { t.warning } else { t.text }));
});
let r = widgets::slider_row(ui, tl!("Constant"), &mut row[3], -200.0..=200.0, "%", None);
changed |= r.changed();
e.add(Edit::of(&r));
if changed {
v[key] = json!(row.map(f32::round));
}
let mut m = mono;
if widgets::checkbox(ui, &mut m, tl!("Monochrome")).changed() {
v["monochrome"] = json!(m);
if m {
v["gray"] = json!([40.0, 40.0, 20.0, 0.0]);
} else if let Some(o) = v.as_object_mut() {
o.remove("gray");
}
e.add(Edit::discrete(true));
}
e
}
+385
View File
@@ -0,0 +1,385 @@
use super::*;
// ---------------------------------------------------------------------------------------------
// Channels of Levels / Curves
/// A channel of a tone editor: the params key (None = the top-level / composite keys for Levels;
/// Curves uses "points"), its label, and its colour name.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ToneChannel {
pub key: &'static str,
pub label: &'static str,
}
/// The channels a tone editor lists for `space` (histogram index = position).
pub fn tone_channels(space: ToneSpace, gray: bool) -> &'static [ToneChannel] {
const RGB: [ToneChannel; 4] = [
ToneChannel { key: "", label: "RGB" },
ToneChannel { key: "red", label: "Red" },
ToneChannel { key: "green", label: "Green" },
ToneChannel { key: "blue", label: "Blue" },
];
const GRAY: [ToneChannel; 1] = [ToneChannel { key: "", label: "Gray" }];
const CMYK: [ToneChannel; 5] = [
ToneChannel { key: "", label: "CMYK" },
ToneChannel { key: "cyan", label: "Cyan" },
ToneChannel { key: "magenta", label: "Magenta" },
ToneChannel { key: "yellow", label: "Yellow" },
ToneChannel { key: "black", label: "Black" },
];
const LAB: [ToneChannel; 3] =
[ToneChannel { key: "lightness", label: "Lightness" }, ToneChannel { key: "a", label: "a" }, ToneChannel { key: "b", label: "b" }];
match space {
ToneSpace::Rgb if gray => &GRAY,
ToneSpace::Rgb => &RGB,
ToneSpace::Cmyk => &CMYK,
ToneSpace::Lab => &LAB,
}
}
pub(super) fn channel_picker(ui: &mut egui::Ui, id: egui::Id, chans: &[ToneChannel], text: &str) -> usize {
let opts: Vec<(usize, &str)> = chans.iter().enumerate().map(|(i, c)| (i, c.label)).collect();
channel_picker_opts(ui, id, &opts, text, true)
}
/// The popup, with `translate` for whether the built-in labels follow the interface language;
/// a user-typed channel name is shown exactly as entered (#5335).
fn channel_picker_opts(ui: &mut egui::Ui, id: egui::Id, opts: &[(usize, &str)], text: &str, translate: bool) -> usize {
let mut ch: usize = ui.data(|d| d.get_temp(id)).unwrap_or(0);
if ch >= opts.len() {
ch = 0;
}
ui.horizontal(|ui| {
label(ui, text);
let width = if opts.len() == 1 { 160.0 } else { 110.0 };
let key = format!("{id:?}-ch");
if translate {
widgets::dropdown(ui, &key, text, &mut ch, opts, width);
} else {
widgets::dropdown_literal(ui, &key, text, &mut ch, opts, width);
}
});
ui.data_mut(|d| d.insert_temp(id, ch));
ch
}
pub(super) fn hist_color(ch: &ToneChannel, t: &Tokens) -> Color32 {
match ch.key {
"" | "lightness" | "black" => Color32::from_gray(if t.pro { 150 } else { 110 }),
k => tone::channel_color(k, t),
}
}
pub(super) fn bar_color(ch: &ToneChannel, t: &Tokens) -> Color32 {
match ch.key {
"" | "lightness" | "black" => Color32::WHITE,
k => tone::channel_color(k, t),
}
}
/// Horizontal (or vertical) black → `to` gradient bar.
pub(super) fn gradient_bar(p: &egui::Painter, r: Rect, from: Color32, to: Color32, vertical: bool) {
let mut mesh = egui::Mesh::default();
let (a, b, c, d) = if vertical {
(r.left_bottom(), r.right_bottom(), r.right_top(), r.left_top())
} else {
(r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom())
};
let (ca, cb) = if vertical { (from, from) } else { (from, to) };
let (cc, cd) = if vertical { (to, to) } else { (to, from) };
mesh.colored_vertex(a, ca);
mesh.colored_vertex(b, cb);
mesh.colored_vertex(c, cc);
mesh.colored_vertex(d, cd);
mesh.add_triangle(0, 1, 2);
mesh.add_triangle(0, 2, 3);
p.add(mesh);
}
// ---------------------------------------------------------------------------------------------
// Curves
pub(super) const CURVE_HANDLE_SIZE: f32 = 7.0;
const CURVE_GRAPH_PADDING: f32 = 5.0;
/// The room left on screen for the Curves dialog's other rows (title, channel and mode, Input and
/// Output, eyedroppers, buttons) when its graph is as tall as it can be.
const CURVES_CHROME: f32 = 360.0;
/// The smallest and the default largest side of the Curves graph: 300 points was the fixed
/// size until #8984.
const CURVE_SIDE: (f32, f32) = (120.0, 300.0);
/// The Curves graph's side (#8984): the width it is given, in the Properties panel and in the
/// resizable dialog, and no taller than the window leaves room for beside the other rows.
fn curve_side(ui: &egui::Ui) -> f32 {
let tallest = curve_side_max(ui.ctx());
let width = ui.available_width();
if width.is_finite() { width.clamp(CURVE_SIDE.0, tallest) } else { CURVE_SIDE.1 }
}
/// The largest the Curves graph gets in this window: as tall as the window leaves room for beside
/// the dialog's other rows, and never under the old 300 points. The Curves dialog is no wider.
pub(crate) fn curve_side_max(ctx: &egui::Context) -> f32 {
(ctx.content_rect().height() - CURVES_CHROME).max(CURVE_SIDE.1)
}
pub(super) fn curve_graph(full: Rect, side: f32) -> Rect {
let base = Rect::from_min_size(full.min + vec2(14.0, 0.0), vec2(side - 14.0, side - 14.0));
Rect::from_min_max(base.min + vec2(CURVE_GRAPH_PADDING, CURVE_GRAPH_PADDING), base.max - vec2(CURVE_GRAPH_PADDING, CURVE_GRAPH_PADDING))
}
pub(crate) fn read_curve(v: &Value, key: &str) -> Vec<[f32; 2]> {
let pts: Vec<[f32; 2]> = v
.get(key)
.and_then(Value::as_array)
.map(|a| {
a.iter()
.filter_map(|q| {
let q = q.as_array()?;
Some([q.first()?.as_f64()? as f32, q.get(1)?.as_f64()? as f32])
})
.collect()
})
.unwrap_or_default();
if pts.len() < 2 { vec![[0.0, 0.0], [255.0, 255.0]] } else { pts }
}
fn curve_key(ch: &ToneChannel) -> &'static str {
if ch.key.is_empty() { "points" } else { ch.key }
}
/// A pencil-drawn channel: its 256 output levels (identity when absent or not a map).
fn read_map(v: &Value, key: &str) -> Vec<f32> {
let map: Option<Vec<f32>> = v
.get(key)
.and_then(Value::as_array)
.filter(|a| a.len() == photocraft_doc::adjust::CURVE_MAP_LEN)
.and_then(|a| a.iter().map(|o| o.as_f64().map(|o| o as f32)).collect());
map.unwrap_or_else(|| (0..photocraft_doc::adjust::CURVE_MAP_LEN).map(|k| k as f32).collect())
}
fn write_map(v: &mut Value, key: &str, map: &[f32]) {
v[key] = json!(map.iter().map(|o| (o * 100.0).round() / 100.0).collect::<Vec<_>>());
}
/// Switches the Curves values between point editing and the pencil: the engine draws the point
/// curves into maps, or fits points to the drawn maps (Photoshop's two curve buttons).
fn set_pencil(v: &mut Value, pencil: bool, gray: bool) -> bool {
let mut p = v.clone();
p["pencil"] = json!(pencil);
let mode = if gray { photocraft_doc::ColorMode::Grayscale } else { photocraft_doc::ColorMode::Rgb };
let Ok(a) = adjust_params::from_params("curves", &p, None, mode) else { return false };
*v = adjust_params::to_params(&a);
// Explicit, so an update over a pencil-drawn layer leaves the pencil.
v["pencil"] = json!(pencil);
true
}
/// Mode buttons above the graph: points, pencil, and Smooth for the shown channel's drawing.
fn curves_mode_row(ui: &mut egui::Ui, v: &mut Value, key: &str, gray: bool) -> Edit {
let pencil = v.get("pencil").and_then(Value::as_bool).unwrap_or(false);
let mut e = Edit::default();
ui.horizontal(|ui| {
if crate::icons::button(ui, "spline", 24.0, !pencil, tl!("Edit points to modify the curve")).clicked() && pencil {
e.add(Edit::discrete(set_pencil(v, false, gray)));
}
if crate::icons::button(ui, "pencil", 24.0, pencil, tl!("Draw to modify the curve")).clicked() && !pencil {
e.add(Edit::discrete(set_pencil(v, true, gray)));
}
let label = crate::i18n::tr_ctx(crate::i18n::current(), "curves", "Smooth");
let smooth = ui
.add_enabled_ui(pencil, |ui| widgets::secondary_button(ui, label, 0.0))
.inner
.on_hover_text(tl!("Smooth the curve values"))
.on_disabled_hover_text(tl!("Smooth the curve values"));
if smooth.clicked() {
let mut map = read_map(v, key);
adjust_params::smooth_curve_map(&mut map);
write_map(v, key, &map);
e.add(Edit::discrete(true));
}
});
e
}
pub(super) fn curves(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let t = Tokens::get(ui.ctx());
let space = space_of(v);
let chans = tone_channels(space, cx.gray);
let state_id = cx.mem.with("curves");
let mut st: CurveUi = ui.data(|d| d.get_temp(state_id)).unwrap_or_default();
let isolated = cx.isolated_curve.as_ref();
let ch = if let Some(iso) = isolated {
channel_picker_opts(ui, cx.mem.with("curves-ch"), &[(0, iso.name.as_str())], tl!("Channel:"), iso.translate)
} else {
channel_picker(ui, cx.mem.with("curves-ch"), chans, tl!("Channel:"))
};
if ch != st.channel {
st = CurveUi { channel: ch, ..Default::default() };
}
let chan =
if let Some(iso) = isolated { ToneChannel { key: iso.key, label: "" } } else { chans.get(ch).copied().unwrap_or(ToneChannel { key: "", label: "" }) };
let overlay_others = isolated.is_none();
let tinted = isolated.is_some_and(|c| c.tint) || (isolated.is_none() && ch != 0);
let hist_i = isolated.map_or(ch, |c| c.hist);
let key = curve_key(&chan);
let mut e = curves_mode_row(ui, v, key, cx.gray);
let pencil = v.get("pencil").and_then(Value::as_bool).unwrap_or(false);
let mut pts = read_curve(v, key);
let mut map = read_map(v, key);
let side = curve_side(ui);
ui.add_space(4.0);
let (full, resp) = ui.allocate_exact_size(vec2(side, side + 14.0), Sense::click_and_drag());
let graph = curve_graph(full, side);
ui.data_mut(|d| d.insert_temp(cx.mem.with("curves-graph"), graph));
let to_scr = |q: [f32; 2]| pos2(graph.left() + q[0] / 255.0 * graph.width(), graph.bottom() - q[1] / 255.0 * graph.height());
let mut changed = false;
let mut drawn = false;
if pencil {
// Pencil: a stroke draws while the button is down and commits on release; Shift
// continues from the previous stroke's end in a straight line.
let stroke_id = cx.mem.with("curves-pencil");
let (mut active, mut last): (bool, Option<[f32; 2]>) = ui.data(|d| d.get_temp(stroke_id)).unwrap_or_default();
if resp.is_pointer_button_down_on()
&& let Some(pos) = resp.interact_pointer_pos()
{
let q = [
((pos.x - graph.left()) / graph.width().max(1.0) * 255.0).clamp(0.0, 255.0),
((graph.bottom() - pos.y) / graph.height().max(1.0) * 255.0).clamp(0.0, 255.0),
];
let from = if active || ui.input(|i| i.modifiers.shift) { last.unwrap_or(q) } else { q };
drawn = curve_edit::pencil_line(&mut map, from, q);
active = true;
last = Some(q);
} else if active {
active = false;
e.commit = true;
}
ui.data_mut(|d| d.insert_temp(stroke_id, (active, last)));
} else {
let interaction = crate::point_curve::interact(ui, &resp, graph, &mut pts, &mut st.gesture);
changed = interaction.changed;
e.commit |= interaction.commit;
}
// Draw: histogram, quarter grid, baseline, gradient bars, other channels, the curve, points.
let p = ui.painter_at(full.expand(2.0));
p.rect_filled(graph, 0.0, t.field);
if let Some(h) = &cx.hist {
tone::draw_histogram(&p, graph, &h[hist_i], Color32::from_gray(if t.pro { 88 } else { 190 }).gamma_multiply(0.75));
}
for i in 1..4 {
let f = i as f32 / 4.0;
let g = Stroke::new(1.0, t.separator);
p.line_segment([pos2(graph.left() + f * graph.width(), graph.top()), pos2(graph.left() + f * graph.width(), graph.bottom())], g);
p.line_segment([pos2(graph.left(), graph.top() + f * graph.height()), pos2(graph.right(), graph.top() + f * graph.height())], g);
}
p.line_segment([graph.left_bottom(), graph.right_top()], Stroke::new(1.0, t.separator.gamma_multiply(1.6)));
p.rect_stroke(
graph,
0.0,
Stroke::new(if resp.has_focus() { 1.5 } else { 1.0 }, if resp.has_focus() { t.accent } else { t.field_border }),
StrokeKind::Outside,
);
let hbar = Rect::from_min_max(pos2(graph.left(), graph.bottom() + 4.0), pos2(graph.right(), graph.bottom() + 12.0));
let vbar = Rect::from_min_max(pos2(full.left(), graph.top()), pos2(full.left() + 8.0, graph.bottom()));
gradient_bar(&p, hbar, Color32::BLACK, bar_color(&chan, &t), false);
gradient_bar(&p, vbar, Color32::BLACK, bar_color(&chan, &t), true);
let draw_curve = |pts: &[[f32; 2]], color: Color32, width: f32| {
let cp: Vec<photocraft_doc::adjust::CurvePoint> =
pts.iter().map(|q| photocraft_doc::adjust::CurvePoint { input: q[0] / 255.0, output: q[1] / 255.0 }).collect();
let lut = photocraft_compose::adjust::curve_lut(&cp);
let n = lut.len().max(2);
let line: Vec<Pos2> =
(0..n).step_by((n / 256).max(1)).map(|i| to_scr([i as f32 / (n - 1) as f32 * 255.0, lut.get(i).copied().unwrap_or(0.0) * 255.0])).collect();
p.add(egui::Shape::line(line, Stroke::new(width, color)));
};
let draw_map = |map: &[f32], color: Color32, width: f32| {
let last = map.len().saturating_sub(1).max(1) as f32;
let line: Vec<Pos2> = map.iter().enumerate().map(|(k, o)| to_scr([k as f32 / last * 255.0, *o])).collect();
p.add(egui::Shape::line(line, Stroke::new(width, color)));
};
if overlay_others && ch == 0 {
// Photoshop overlays the edited channel curves on the composite.
for c in chans.iter().skip(1) {
if pencil {
let m = read_map(v, c.key);
if m.iter().enumerate().any(|(k, o)| (o - k as f32).abs() > 0.5) {
draw_map(&m, bar_color(c, &t).gamma_multiply(0.8), 1.0);
}
continue;
}
let cp = read_curve(v, c.key);
if cp.len() > 2 || cp.first().is_some_and(|q| q[1] != 0.0) || cp.last().is_some_and(|q| q[1] != 255.0) {
draw_curve(&cp, bar_color(c, &t).gamma_multiply(0.8), 1.0);
}
}
}
let color = if tinted { bar_color(&chan, &t) } else { t.text };
if pencil {
draw_map(&map, color, 1.5);
} else {
draw_curve(&pts, color, 1.5);
}
for (i, q) in pts.iter().enumerate().filter(|_| !pencil) {
let r = Rect::from_center_size(to_scr(*q), vec2(CURVE_HANDLE_SIZE, CURVE_HANDLE_SIZE));
if Some(i) == st.gesture.selected {
p.rect_filled(r, 0.0, t.text);
p.rect_stroke(r, 0.0, Stroke::new(1.0, Color32::BLACK), StrokeKind::Outside);
} else {
p.rect_filled(r, 0.0, t.field);
p.rect_stroke(r, 0.0, Stroke::new(1.0, t.text), StrokeKind::Inside);
}
}
// Input / Output of the selected point.
ui.add_space(6.0);
ui.horizontal(|ui| {
let i = st.gesture.selected.filter(|i| *i < pts.len() && !pencil);
let (mut vi, mut vo) = i.map_or((0.0, 0.0), |i| (pts[i][0], pts[i][1]));
label(ui, tl!("Input:"));
let ri = ui.add_enabled_ui(i.is_some(), |ui| widgets::value_field(ui, &mut vi, 0.0..=255.0, "", 52.0).accessible_name(tl!("Input:"))).inner;
label(ui, tl!("Output:"));
let ro = ui.add_enabled_ui(i.is_some(), |ui| widgets::value_field(ui, &mut vo, 0.0..=255.0, "", 52.0).accessible_name(tl!("Output:"))).inner;
if let Some(i) = i
&& (ri.changed() || ro.changed())
&& curve_edit::move_to(&mut pts, i, [vi, vo])
{
changed = true;
e.commit |= !(ri.dragged() || ro.dragged());
}
if ri.drag_stopped() || ro.drag_stopped() {
e.commit = true;
}
});
let t2 = Tokens::get(ui.ctx());
let hint = if pencil {
crate::i18n::fmt(tl!("Drag to draw the curve · {key}-click draws a straight line"), &[("key", &crate::shortcuts::pretty("Shift"))])
} else {
crate::i18n::fmt(tl!("Click to add a point · drag off or {key}-click or Delete to remove"), &[("key", &crate::shortcuts::pretty("Cmd"))])
};
ui.label(RichText::new(hint).color(t2.text_faint).size(11.0));
ui.data_mut(|d| d.insert_temp(state_id, st));
if drawn {
write_map(v, key, &map);
if space == ToneSpace::Lab
&& let Some(o) = v.as_object_mut()
{
o.remove("points");
}
e.changed = true;
}
if changed && !pencil {
v[key] = json!(pts.iter().map(|q| [q[0].round(), q[1].round()]).collect::<Vec<_>>());
if space == ToneSpace::Lab {
// Lab has no composite: "points" would alias lightness.
if let Some(o) = v.as_object_mut() {
o.remove("points");
}
}
e.changed = true;
}
e
}
@@ -0,0 +1,284 @@
use super::hue_saturation::spectrum_bar;
use super::*;
// ---------------------------------------------------------------------------------------------
// Gradient Map
type Stop = (f32, [f32; 3]);
fn read_stops(v: &Value) -> Vec<Stop> {
let mut s: Vec<Stop> = v
.get("stops")
.and_then(Value::as_array)
.map(|a| {
a.iter()
.filter_map(|s| {
let p = s.as_array()?;
let t = p.first()?.as_f64()? as f32;
let c = rgb_of(&json!({"c": p.get(1)?.clone()}), "c", [0.0; 3]);
Some((t.clamp(0.0, 1.0), c))
})
.collect()
})
.unwrap_or_default();
if s.len() < 2 {
s = vec![(0.0, [0.0; 3]), (1.0, [1.0; 3])];
}
s
}
fn write_stops(v: &mut Value, s: &[Stop]) {
let mut s = s.to_vec();
s.sort_by(|a, b| a.0.total_cmp(&b.0));
v["stops"] = json!(s.iter().map(|(t, c)| json!([round(*t, 0.001), adjust_params::hex(*c)])).collect::<Vec<_>>());
}
fn sample_stops(s: &[Stop], t: f32) -> [f32; 3] {
let mut sorted = s.to_vec();
sorted.sort_by(|a, b| a.0.total_cmp(&b.0));
let Some(first) = sorted.first() else { return [t; 3] };
if t <= first.0 {
return first.1;
}
for w in sorted.windows(2) {
if t <= w[1].0 {
let k = if w[1].0 > w[0].0 { (t - w[0].0) / (w[1].0 - w[0].0) } else { 0.0 };
return std::array::from_fn(|i| w[0].1[i] + (w[1].1[i] - w[0].1[i]) * k);
}
}
sorted.last().map_or([t; 3], |l| l.1)
}
#[derive(Clone, Copy)]
struct MapStopDrag {
index: usize,
offset: f32,
changed: bool,
}
/// Keep selection on the same stop when it crosses another stop (including coincident stops).
fn move_map_stop(stops: &mut [Stop], index: usize, location: f32) -> Option<usize> {
let stop = stops.get_mut(index)?;
stop.0 = round(location.clamp(0.0, 1.0), 0.001);
let location = stop.0;
let rank = stops.iter().enumerate().filter(|(i, s)| *i != index && (s.0 < location || (s.0 == location && *i < index))).count();
stops.sort_by(|a, b| a.0.total_cmp(&b.0));
Some(rank)
}
fn gradient_map_strip(ui: &mut egui::Ui, stops: &mut Vec<Stop>, cx: &EditorCx, selected: &mut usize) -> Edit {
let t = Tokens::get(ui.ctx());
let key = cx.mem.with("gm-stop-drag");
let mut edit = Edit::default();
let w = ui.available_width().min(300.0);
let (outer, resp) = ui.allocate_exact_size(vec2(w, 44.0), Sense::click_and_drag());
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, ui.is_enabled(), tl!("Gradient stops")));
let bar = Rect::from_min_max(outer.min + vec2(8.0, 2.0), pos2(outer.right() - 8.0, outer.top() + 26.0));
let x_of = |loc: f32| bar.left() + loc * bar.width();
let loc_of = |x: f32| ((x - bar.left()) / bar.width().max(1.0)).clamp(0.0, 1.0);
let hit =
|pos: Pos2, stops: &[Stop]| stops.iter().enumerate().rev().find(|(_, s)| pos.y >= bar.bottom() && (x_of(s.0) - pos.x).abs() <= 6.0).map(|(i, _)| i);
if resp.drag_started()
&& let Some(pos) = ui.input(|i| i.pointer.press_origin())
&& let Some(index) = hit(pos, stops)
{
*selected = index;
let offset = stops.get(index).map_or(0.0, |s| pos.x - x_of(s.0));
ui.data_mut(|d| d.insert_temp(key, MapStopDrag { index, offset, changed: false }));
}
if let Some(mut drag) = ui.data(|d| d.get_temp::<MapStopDrag>(key)) {
if (resp.dragged() || resp.drag_stopped())
&& let Some(pos) = resp.interact_pointer_pos()
{
let location = round(loc_of(pos.x - drag.offset), 0.001);
let changed = stops.get(drag.index).is_some_and(|s| s.0 != location);
if let Some(index) = move_map_stop(stops, drag.index, location) {
drag.index = index;
drag.changed |= changed;
*selected = index;
edit.changed |= changed;
}
}
if resp.drag_stopped() {
edit.commit = drag.changed;
ui.data_mut(|d| d.remove::<MapStopDrag>(key));
} else if ui.input(|i| i.pointer.primary_down()) {
ui.data_mut(|d| d.insert_temp(key, drag));
} else {
ui.data_mut(|d| d.remove::<MapStopDrag>(key));
}
}
if resp.clicked()
&& let Some(pos) = resp.interact_pointer_pos()
{
resp.request_focus();
if let Some(index) = hit(pos, stops) {
*selected = index;
} else if stops.len() < 64 {
let at = round(loc_of(pos.x), 0.001);
let color = sample_stops(stops, at);
stops.push((at, color));
let index = stops.len() - 1;
*selected = move_map_stop(stops, index, at).unwrap_or(0);
edit.add(Edit::discrete(true));
}
}
if resp.hovered() && ui.input(|i| i.pointer.hover_pos()).is_some_and(|pos| hit(pos, stops).is_some()) || resp.dragged() {
ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
}
// Markers address un-reversed locations, as in the Gradient Tool; Reverse changes the image.
let cols: Vec<Color32> = (0..=48).map(|i| color32(sample_stops(stops, i as f32 / 48.0))).collect();
spectrum_bar(ui.painter(), bar, &cols);
ui.painter().rect_stroke(bar, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Outside);
for (i, (at, color)) in stops.iter().enumerate() {
let x = x_of(*at);
let border = if i == *selected { t.accent } else { t.text_dim };
let body = Rect::from_center_size(pos2(x, bar.bottom() + 10.0), vec2(10.0, 10.0));
ui.painter().add(egui::Shape::convex_polygon(
vec![pos2(x, bar.bottom() + 1.0), pos2(x + 5.0, body.top()), pos2(x - 5.0, body.top())],
border,
Stroke::NONE,
));
ui.painter().rect_filled(body, 1.0, color32(*color));
ui.painter().rect_stroke(body, 1.0, Stroke::new(1.0, border), StrokeKind::Outside);
}
edit
}
pub(super) fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let t = Tokens::get(ui.ctx());
let mut e = Edit::default();
let mut stops = read_stops(v);
let selection = cx.mem.with("gm-stop-selection");
let mut selected = ui.data(|d| d.get_temp::<usize>(selection)).unwrap_or(0).min(stops.len().saturating_sub(1));
// Photoshop's gradient picker: the same library as the Gradient tool and Gradients panel
// (built-in groups and the user's own), Foreground/Background resolved to the current colours.
let [fg, bg] = cx.swatches.map(|c| [c[0], c[1], c[2], 1.0]);
ui.horizontal(|ui| {
label(ui, tl!("Preset:"));
let mut picked = None;
let (press, close) = crate::press_menu::PressCombo::before(ui, cx.mem.with("gm-preset"));
let combo = egui::ComboBox::from_id_salt(cx.mem.with("gm-preset"))
.selected_text(tl!("Custom"))
.width(ui.available_width().min(190.0))
.height(420.0)
.icon(widgets::chevron_icon)
.close_behavior(close)
.show_ui(ui, |ui| {
let gear = crate::icons::button(ui, "settings", 24.0, false, tl!("Gradient Preset Options"));
egui::containers::menu::SubMenu::new().show(ui, &gear, |ui| {
if ui.button(tl!("Import .GRD")).clicked() {
e.import_gradients = true;
ui.close();
}
});
ui.separator();
for g in &cx.gradients {
ui.label(RichText::new(&g.name).color(t.text_faint));
for p in &g.items {
ui.horizontal(|ui| {
// A map has no transparency: colour stops only, shown opaque.
let rgba: Vec<(f32, [f32; 4])> = p.resolve(fg, bg).into_iter().map(|(at, c)| (at, [c[0], c[1], c[2], 1.0])).collect();
let (r, swatch) = ui.allocate_exact_size(vec2(48.0, 16.0), Sense::click());
crate::preset_panels::paint_gradient(ui, r, &rgba);
// Both, not short-circuited: the name is drawn either way.
let name = ui.selectable_label(false, &p.name);
if press.chosen(ui, &swatch) | press.chosen(ui, &name) {
picked = Some(rgba.iter().map(|(at, c)| (*at, [c[0], c[1], c[2]])).collect::<Vec<Stop>>());
}
});
}
}
});
press.after(&combo.response);
let _ = combo.response.accessible_name(tl!("Preset:"));
if let Some(p) = picked {
stops = p;
selected = 0;
ui.data_mut(|d| d.remove::<MapStopDrag>(cx.mem.with("gm-stop-drag")));
write_stops(v, &stops);
e.add(Edit::discrete(true));
}
});
let strip = gradient_map_strip(ui, &mut stops, cx, &mut selected);
let mut changed = strip.changed;
e.add(strip);
// The selected stop's colour and location, like the Gradient Tool's compact stop editor.
let mut location = None;
let mut remove = false;
let can_remove = stops.len() > 2;
if let Some(s) = stops.get_mut(selected) {
ui.horizontal(|ui| {
label(ui, tl!("Color:"));
let r = color_button(ui, &mut s.1);
changed |= r.changed;
e.add(r);
ui.add_enabled_ui(can_remove, |ui| {
remove = crate::icons::button(ui, "x", 20.0, false, tl!("Remove stop")).clicked();
});
});
ui.horizontal(|ui| {
label(ui, tl!("Location:"));
let mut loc = s.0 * 100.0;
let rl = widgets::value_field(ui, &mut loc, 0.0..=100.0, "%", 70.0).accessible_name(tl!("Location:"));
if rl.changed() {
location = Some(loc / 100.0);
changed = true;
}
e.add(Edit::of(&rl));
});
}
if let Some(loc) = location {
selected = move_map_stop(&mut stops, selected, loc).unwrap_or(0);
}
if remove && can_remove {
stops.remove(selected);
selected = selected.min(stops.len() - 1);
changed = true;
e.add(Edit::discrete(true));
}
if stops.len() < 64 && widgets::secondary_button(ui, tl!("Add Stop"), 0.0).clicked() {
// Halfway along the widest gap, in the gradient's colour there.
let mut sorted = stops.clone();
sorted.sort_by(|a, b| a.0.total_cmp(&b.0));
let at = sorted.windows(2).max_by(|a, b| (a[1].0 - a[0].0).total_cmp(&(b[1].0 - b[0].0))).map_or(0.5, |w| (w[0].0 + w[1].0) / 2.0);
stops.push((at, sample_stops(&stops, at)));
let index = stops.len() - 1;
selected = move_map_stop(&mut stops, index, at).unwrap_or(0);
changed = true;
e.add(Edit::discrete(true));
}
if changed {
write_stops(v, &stops);
e.changed = true;
}
ui.data_mut(|d| d.insert_temp(selection, selected));
ui.horizontal(|ui| {
for (key, text) in [("reverse", tl!("Reverse")), ("dither", tl!("Dither"))] {
let mut b = flag(v, key, false);
if widgets::checkbox(ui, &mut b, text).changed() {
v[key] = json!(b);
e.add(Edit::discrete(true));
}
}
});
e
}
// ---------------------------------------------------------------------------------------------
// Hosts
/// Whether a document of this mode edits Levels/Curves through a single Gray channel.
pub fn is_gray(mode: photocraft_doc::ColorMode) -> bool {
matches!(mode, photocraft_doc::ColorMode::Grayscale | photocraft_doc::ColorMode::Duotone | photocraft_doc::ColorMode::Bitmap)
}
/// The gradient preset library for a `kind` editor's picker (Gradient Map only; empty otherwise).
pub fn gradient_presets(app: &PhotocraftApp, kind: &str) -> Vec<Group<GradientPreset>> {
if kind == "gradientMap" { app.session.presets.gradients.clone() } else { Vec::new() }
}
pub fn swatches(app: &PhotocraftApp) -> [[f32; 3]; 2] {
let c = |x: [f32; 4]| [x[0], x[1], x[2]];
[c(app.session.tools.foreground), c(app.session.tools.background)]
}
@@ -0,0 +1,207 @@
use super::basic::{sliders, track_stops};
use super::curves::gradient_bar;
use super::levels::nearest;
use super::*;
// ---------------------------------------------------------------------------------------------
// Hue/Saturation
pub(super) const RANGE_LABELS: [&str; 6] = ["Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"];
/// The Saturation slider's track: grey to the hue at full saturation (UI-217-16).
pub(super) fn saturation_track(hue_deg: f32) -> [Color32; 2] {
[Color32::from_gray(128), hue_color(hue_deg)]
}
/// The Lightness slider's track: black, mid grey, white, whatever the hue, as in Photoshop
/// (UI-217-16, #6539).
pub(super) fn lightness_track() -> [Color32; 3] {
[Color32::BLACK, Color32::from_gray(128), Color32::WHITE]
}
pub(super) fn move_hue_range_handle(bounds: [f32; 4], k: usize, deg: f32) -> [f32; 4] {
let mut b = HueRange::canonical_bounds(bounds);
if k >= b.len() {
return b;
}
if k == 0 {
let delta = (deg - b[0] + 180.0).rem_euclid(360.0) - 180.0;
b[0] = (b[0] + delta).min(b[1]).max(b[1] - 180.0);
} else {
let rel = (deg - b[0]).rem_euclid(360.0);
let hi = if k == 3 { b[0] + 359.0 } else { b[k + 1] };
b[k] = (b[0] + rel).clamp(b[k - 1], hi);
}
b
}
/// The spectrum bar after the adjustment (what each hue becomes), sampled at `n` hues.
fn adjusted_spectrum(v: &Value, n: usize) -> Vec<Color32> {
let adj = photocraft_engine::commands::adjustment_from_params("hueSaturation", v);
let rect = photocraft_geom::Rect::new(0, 0, n as i32, 1);
let px = (0..n)
.map(|i| {
let c = photocraft_color::convert::hsb_to_rgb([i as f32 / (n - 1).max(1) as f32 * 360.0, 1.0, 1.0]);
[c[0], c[1], c[2], 1.0]
})
.collect();
let mut buf = photocraft_compose::Buffer { rect, px };
photocraft_compose::adjust::apply(&adj, &mut buf);
buf.px.iter().map(|p| color32([p[0], p[1], p[2]])).collect()
}
pub(super) fn spectrum_bar(p: &egui::Painter, r: Rect, colors: &[Color32]) {
let n = colors.len().saturating_sub(1).max(1);
for (i, w) in colors.windows(2).enumerate() {
let x0 = r.left() + r.width() * i as f32 / n as f32;
let x1 = r.left() + r.width() * (i + 1) as f32 / n as f32;
gradient_bar(p, Rect::from_min_max(pos2(x0, r.top()), pos2(x1, r.bottom())), w[0], w[1], false);
}
}
pub(super) fn hue_saturation(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let t = Tokens::get(ui.ctx());
let range_id = cx.mem.with("hs-range");
let mut range: usize = ui.data(|d| d.get_temp(range_id)).unwrap_or(0);
let colorize = flag(v, "colorize", false);
if colorize {
range = 0;
}
ui.horizontal(|ui| {
let opts: Vec<(usize, &str)> = std::iter::once((0, tl!("Master"))).chain(RANGE_LABELS.iter().enumerate().map(|(i, l)| (i + 1, *l))).collect();
ui.add_enabled_ui(!colorize, |ui| widgets::dropdown(ui, &format!("{range_id:?}"), tl!("Range"), &mut range, &opts, 120.0));
});
ui.data_mut(|d| d.insert_temp(range_id, range));
let mut e = Edit::default();
let hue_grad = widgets::hue_stops();
if range == 0 {
let (hlo, hhi, slo) = if colorize { (0.0, 360.0, 0.0) } else { (-180.0, 180.0, -100.0) };
let mut h = num(v, "hue", 0.0).clamp(hlo, hhi);
let r = widgets::slider_row(ui, tl!("Hue"), &mut h, hlo..=hhi, "°", track_stops(cx, &hue_grad));
if r.changed() {
v["hue"] = json!(h.round());
}
e.add(Edit::of(&r));
// The Saturation track follows the current hue; the Lightness track is a fixed
// black-grey-white ramp, as in Photoshop (UI-217-16).
let sat_track = saturation_track(h);
let mut s = num(v, "saturation", 0.0).clamp(slo, 100.0);
let r = widgets::slider_row(ui, tl!("Saturation"), &mut s, slo..=100.0, "%", track_stops(cx, &sat_track));
if r.changed() {
v["saturation"] = json!(s.round());
}
e.add(Edit::of(&r));
let light_track = lightness_track();
let mut l = num(v, "lightness", 0.0).clamp(-100.0, 100.0);
let r = widgets::slider_row(ui, tl!("Lightness"), &mut l, -100.0..=100.0, "%", track_stops(cx, &light_track));
if r.changed() {
v["lightness"] = json!(l.round());
}
e.add(Edit::of(&r));
} else {
let key = HUE_RANGES[range - 1];
if !v.get(key).is_some_and(Value::is_object) {
v[key] = json!({});
}
let mut o = v[key].clone();
let mut sub = Edit::default();
let mut h = num(&o, "hue", 0.0);
let r = widgets::slider_row(ui, tl!("Hue"), &mut h, -180.0..=180.0, "°", track_stops(cx, &hue_grad));
if r.changed() {
o["hue"] = json!(h.round());
}
sub.add(Edit::of(&r));
sub.add(sliders(
ui,
&mut o,
&[("saturation", tl!("Saturation"), -100.0, 100.0, 0.0, "%", None), ("lightness", tl!("Lightness"), -100.0, 100.0, 0.0, "%", None)],
));
if sub.changed {
v[key] = o;
}
e.add(sub);
}
let mut c = colorize;
if widgets::checkbox(ui, &mut c, tl!("Colorize")).changed() {
v["colorize"] = json!(c);
let h = num(v, "hue", 0.0);
v["hue"] = json!(if c {
h.rem_euclid(360.0)
} else if h > 180.0 {
h - 360.0
} else {
h
});
if c {
v["saturation"] = json!(num(v, "saturation", 25.0).max(0.0).max(25.0));
}
e.add(Edit::discrete(true));
}
// Spectrum bars: input hues above, adjusted below; the selected range's sliders between.
ui.add_space(6.0);
// As wide as the sliders above, whatever the panel's width (#9242).
let w = ui.available_width();
let (bars, bresp) = ui.allocate_exact_size(vec2(w, 40.0), Sense::click_and_drag());
ui.data_mut(|d| d.insert_temp(cx.mem.with("hs-bars"), bars));
let top = Rect::from_min_size(bars.min, vec2(w, 10.0));
let bottom = Rect::from_min_size(pos2(bars.left(), bars.bottom() - 10.0), vec2(w, 10.0));
let p = ui.painter_at(bars.expand(4.0));
let input: Vec<Color32> = (0..=36).map(|i| hue_color(i as f32 * 10.0)).collect();
spectrum_bar(&p, top, &input);
spectrum_bar(&p, bottom, &adjusted_spectrum(v, 37));
if range > 0 {
let key = HUE_RANGES[range - 1];
let neutral = photocraft_doc::adjust::HueRange::neutral(range - 1).bounds;
let mut b = HueRange::canonical_bounds(nums(&v[key], "range", neutral));
let xof = |deg: f32| bars.left() + deg.rem_euclid(360.0) / 360.0 * w;
let deg_of = |x: f32| ((x - bars.left()) / w * 360.0).clamp(0.0, 360.0);
let mid = bars.center().y;
// Range band (fully affected) and fall-off.
let band = |a: f32, z: f32, color: Color32| {
let (xa, xz) = (xof(a), xof(z));
if xa <= xz {
p.rect_filled(Rect::from_min_max(pos2(xa, mid - 3.0), pos2(xz, mid + 3.0)), 0.0, color);
} else {
p.rect_filled(Rect::from_min_max(pos2(xa, mid - 3.0), pos2(bars.right(), mid + 3.0)), 0.0, color);
p.rect_filled(Rect::from_min_max(pos2(bars.left(), mid - 3.0), pos2(xz, mid + 3.0)), 0.0, color);
}
};
band(b[0], b[3], t.text_faint);
band(b[1], b[2], t.text_dim);
for (k, d) in b.iter().enumerate() {
let x = xof(*d);
let fill = if k == 1 || k == 2 { t.text } else { t.field };
p.rect_filled(Rect::from_center_size(pos2(x, mid), vec2(5.0, 12.0)), 1.0, fill);
p.rect_stroke(Rect::from_center_size(pos2(x, mid), vec2(5.0, 12.0)), 1.0, Stroke::new(1.0, t.text_dim), StrokeKind::Inside);
}
let drag_id = cx.mem.with("hs-range-drag");
let mut which: Option<u8> = ui.data(|d| d.get_temp(drag_id)).flatten();
if bresp.is_pointer_button_down_on()
&& ui.input(|i| i.pointer.primary_pressed())
&& let Some(pos) = ui.input(|i| i.pointer.press_origin())
{
which = nearest(&b.map(xof), pos.x).filter(|k| (xof(b[*k as usize]) - pos.x).abs() < 10.0);
}
if bresp.is_pointer_button_down_on()
&& let (Some(k), Some(pos)) = (which, ui.input(|i| i.pointer.interact_pos()))
{
let k = k as usize;
let deg = deg_of(pos.x);
let before = b;
b = move_hue_range_handle(b, k, deg);
if b != before {
v[key]["range"] = json!(b.map(|x| x.round()));
e.changed = true;
}
}
if which.is_some() && !bresp.is_pointer_button_down_on() {
which = None;
e.commit = true;
}
ui.data_mut(|d| d.insert_temp(drag_id, which));
let lab =
format!("{:.0}° / {:.0}° · {:.0}° \\ {:.0}°", b[0].rem_euclid(360.0), b[1].rem_euclid(360.0), b[2].rem_euclid(360.0), b[3].rem_euclid(360.0));
ui.label(RichText::new(lab).font(crate::theme::mono(11.0)).color(t.text_faint));
}
e
}
+208
View File
@@ -0,0 +1,208 @@
use super::curves::{ToneChannel, bar_color, channel_picker, gradient_bar, hist_color, tone_channels};
use super::*;
// ---------------------------------------------------------------------------------------------
// Levels
type Lv = [f32; 5]; // in_black, gamma, in_white, out_black, out_white (0–255, gamma as is)
fn read_levels(v: &Value, key: &str) -> Lv {
let o = if key.is_empty() { Some(v) } else { v.get(key) };
let g = |k: &str, d: f32| o.and_then(|o| o.get(k)).and_then(Value::as_f64).map_or(d, |x| x as f32);
[g("inBlack", 0.0), g("gamma", 1.0), g("inWhite", 255.0), g("outBlack", 0.0), g("outWhite", 255.0)]
}
fn write_levels(v: &mut Value, key: &str, l: &Lv) {
let obj = json!({"inBlack": l[0].round(), "gamma": round(l[1], 0.01), "inWhite": l[2].round(), "outBlack": l[3].round(), "outWhite": l[4].round()});
if key.is_empty() {
if let (Some(dst), Value::Object(src)) = (v.as_object_mut(), obj) {
dst.extend(src);
}
} else {
v[key] = obj;
}
}
/// A triangular slider handle below a bar.
fn handle(p: &egui::Painter, x: f32, y: f32, fill: Color32, stroke: Color32) {
p.add(egui::Shape::convex_polygon(vec![pos2(x, y), pos2(x + 5.5, y + 9.0), pos2(x - 5.5, y + 9.0)], fill, Stroke::new(1.0, stroke)));
}
/// Input level (0–255) where the gamma slider sits: the input that maps to 50% grey.
pub fn gamma_pos(black: f32, white: f32, gamma: f32) -> f32 {
black + (white - black) * 0.5f32.powf(gamma)
}
pub fn gamma_from_pos(black: f32, white: f32, x: f32) -> f32 {
let t = ((x - black) / (white - black).max(1.0)).clamp(0.01, 0.99);
(t.ln() / 0.5f32.ln()).clamp(0.01, 9.99)
}
/// Black and white input levels clipping 0.1 % at each end of `h` (Photoshop's Auto).
pub fn auto_levels(h: &[u32; 256]) -> (f32, f32) {
let total: u64 = h.iter().map(|x| u64::from(*x)).sum();
let clip = total / 1000;
let (mut acc, mut lo) = (0u64, 0usize);
while lo < 253 && acc + u64::from(h[lo]) <= clip {
acc += u64::from(h[lo]);
lo += 1;
}
let (mut acc, mut hi) = (0u64, 255usize);
while hi > lo + 2 && acc + u64::from(h[hi]) <= clip {
acc += u64::from(h[hi]);
hi -= 1;
}
(lo as f32, hi as f32)
}
/// Which handle of a slider row a press at `x` grabs (nearest), among `xs`.
pub(super) fn nearest(xs: &[f32], x: f32) -> Option<u8> {
xs.iter().enumerate().min_by(|a, b| (a.1 - x).abs().total_cmp(&(b.1 - x).abs())).map(|(i, _)| i as u8)
}
pub(super) fn levels(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
let t = Tokens::get(ui.ctx());
let chans = tone_channels(space_of(v), cx.gray);
let mut ch = 0;
let mut auto = false;
ui.horizontal(|ui| {
ch = channel_picker(ui, cx.mem.with("levels-ch"), chans, tl!("Channel:"));
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
auto = widgets::secondary_button(ui, tl!("Auto"), 0.0).clicked();
});
});
let chan = chans.get(ch).copied().unwrap_or(ToneChannel { key: "", label: "" });
let mut l = read_levels(v, chan.key);
let mut e = Edit::default();
let mut changed = false;
if auto && let Some(h) = &cx.hist {
let (lo, hi) = auto_levels(&h[ch]);
l[0] = lo;
l[2] = hi;
l[1] = 1.0;
changed = true;
e.commit = true;
}
let w = ui.available_width().min(300.0);
// Histogram.
let (hr, _) = ui.allocate_exact_size(vec2(w, 110.0), Sense::hover());
let hr = hr.shrink2(vec2(6.0, 0.0));
let p = ui.painter_at(hr.expand(1.0));
p.rect_filled(hr, 0.0, t.field);
if let Some(h) = &cx.hist {
tone::draw_histogram(&p, hr, &h[ch], hist_color(&chan, &t));
}
p.rect_stroke(hr, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Inside);
// Input sliders: black, gamma, white.
let (sr, sresp) = ui.allocate_exact_size(vec2(w, 14.0), Sense::click_and_drag());
let track = sr.shrink2(vec2(6.0, 0.0));
let xpos = |val: f32| track.left() + val / 255.0 * track.width();
let xval = |x: f32| ((x - track.left()) / track.width() * 255.0).clamp(0.0, 255.0);
let drag_id = cx.mem.with("levels-drag");
let mut which: Option<u8> = ui.data(|d| d.get_temp(drag_id)).flatten();
let ctx = ui.ctx().clone();
let pressed = |r: &egui::Response| r.is_pointer_button_down_on() && ctx.input(|i| i.pointer.primary_pressed());
if pressed(&sresp)
&& let Some(pos) = ui.input(|i| i.pointer.press_origin())
{
which = nearest(&[xpos(l[0]), xpos(gamma_pos(l[0], l[2], l[1])), xpos(l[2])], pos.x);
}
if sresp.is_pointer_button_down_on()
&& let (Some(k), Some(pos)) = (which, ui.input(|i| i.pointer.interact_pos()))
{
let x = xval(pos.x);
let before = l;
match k {
0 => l[0] = x.min(l[2] - 2.0).round(),
2 => l[2] = x.max(l[0] + 2.0).round(),
_ => l[1] = round(gamma_from_pos(l[0], l[2], x), 0.01),
}
changed |= l != before;
}
if which.is_some() && !sresp.is_pointer_button_down_on() {
which = None;
e.commit = true;
}
ui.data_mut(|d| d.insert_temp(drag_id, which));
let sp = ui.painter_at(sr.expand(6.0));
handle(&sp, xpos(l[0]), sr.top() + 2.0, Color32::BLACK, t.text_dim);
handle(&sp, xpos(gamma_pos(l[0], l[2], l[1])), sr.top() + 2.0, Color32::from_gray(128), t.text_dim);
handle(&sp, xpos(l[2]), sr.top() + 2.0, Color32::WHITE, t.text_dim);
ui.horizontal(|ui| {
let fw = ((w - 16.0) / 3.0).min(70.0);
let (mut nb, mut ng, mut nw) = (l[0], l[1], l[2]);
let gap = ((w - 3.0 * fw) / 2.0 - 12.0).max(0.0);
let r0 = widgets::value_field(ui, &mut nb, 0.0..=253.0, "", fw).accessible_name(tl!("Black"));
ui.add_space(gap);
let r1 = widgets::value_field(ui, &mut ng, 0.01..=9.99, "", fw).accessible_name(tl!("Gamma"));
ui.add_space(gap);
let r2 = widgets::value_field(ui, &mut nw, 2.0..=255.0, "", fw).accessible_name(tl!("White"));
if r0.changed() {
l[0] = nb.round().min(l[2] - 2.0);
}
if r1.changed() {
l[1] = round(ng.clamp(0.01, 9.99), 0.01);
}
if r2.changed() {
l[2] = nw.round().max(l[0] + 2.0);
}
for r in [&r0, &r1, &r2] {
changed |= r.changed();
e.add(Edit::of(r));
}
});
// Output levels.
ui.add_space(6.0);
label(ui, tl!("Output Levels:"));
let (ob_r, _) = ui.allocate_exact_size(vec2(w, 10.0), Sense::hover());
gradient_bar(ui.painter(), ob_r.shrink2(vec2(6.0, 0.0)), Color32::BLACK, bar_color(&chan, &t), false);
let (or, oresp) = ui.allocate_exact_size(vec2(w, 14.0), Sense::click_and_drag());
let otrack = or.shrink2(vec2(6.0, 0.0));
let oxpos = |val: f32| otrack.left() + val / 255.0 * otrack.width();
let oval = |x: f32| ((x - otrack.left()) / otrack.width() * 255.0).clamp(0.0, 255.0);
let odrag_id = cx.mem.with("levels-odrag");
let mut owhich: Option<u8> = ui.data(|d| d.get_temp(odrag_id)).flatten();
if pressed(&oresp)
&& let Some(pos) = ui.input(|i| i.pointer.press_origin())
{
owhich = nearest(&[oxpos(l[3]), oxpos(l[4])], pos.x);
}
if oresp.is_pointer_button_down_on()
&& let (Some(k), Some(pos)) = (owhich, ui.input(|i| i.pointer.interact_pos()))
{
let slot = if k == 0 { 3 } else { 4 };
let nv = oval(pos.x).round();
changed |= l[slot] != nv;
l[slot] = nv;
}
if owhich.is_some() && !oresp.is_pointer_button_down_on() {
owhich = None;
e.commit = true;
}
ui.data_mut(|d| d.insert_temp(odrag_id, owhich));
let op = ui.painter_at(or.expand(6.0));
handle(&op, oxpos(l[3]), or.top() + 2.0, Color32::BLACK, t.text_dim);
handle(&op, oxpos(l[4]), or.top() + 2.0, Color32::WHITE, t.text_dim);
ui.horizontal(|ui| {
let fw = ((w - 16.0) / 3.0).min(70.0);
let (mut a, mut c) = (l[3], l[4]);
let ra = widgets::value_field(ui, &mut a, 0.0..=255.0, "", fw).accessible_name(tl!("Black"));
ui.add_space((w - 2.0 * fw - 16.0).max(0.0));
let rc = widgets::value_field(ui, &mut c, 0.0..=255.0, "", fw).accessible_name(tl!("White"));
if ra.changed() {
l[3] = a.round();
}
if rc.changed() {
l[4] = c.round();
}
for r in [&ra, &rc] {
changed |= r.changed();
e.add(Edit::of(r));
}
});
if changed {
write_levels(v, chan.key, &l);
e.changed = true;
}
e
}
@@ -0,0 +1,148 @@
use super::basic::reset_color_balance;
use super::gradient_map::{gradient_presets, is_gray, swatches};
use super::*;
/// Root of an adjustment layer's Properties editor view state in egui memory.
pub fn layer_mem(id: LayerId) -> egui::Id {
egui::Id::unique(("adjust-layer", id.0))
}
/// Kinds whose Properties edits follow Photoshop's history and Reset (measured for Color Balance,
/// Photoshop 25.4): consecutive edits of the layer make one history step, and Reset first returns
/// to the settings the layer had when the panel started showing it.
fn photoshop_session(kind: &str) -> bool {
kind == "colorBalance"
}
/// The `coalesce` key of a layer's Properties edits (one history step while they follow each
/// other, like Photoshop's "Modify … Layer").
pub fn properties_coalesce(id: LayerId) -> String {
format!("properties-adjustment:{}", id.0)
}
/// A layer's Properties session: document, last pass drawn, the settings the panel found, and
/// whether the panel edited them since (or since the last Reset).
type Session = (u64, u64, Value, bool);
fn session_key(id: LayerId) -> egui::Id {
layer_mem(id).with("session")
}
/// Remember the settings `id` (in document `doc`) had when the panel started showing it: kept
/// while it is drawn pass after pass, taken anew after a pass without it (another layer,
/// document or panel state shown).
fn track_session(ctx: &egui::Context, doc: u64, id: LayerId, committed: &Value) {
let pass = ctx.cumulative_pass_nr();
let kept: Option<Session> = ctx.data(|d| d.get_temp(session_key(id)));
let (start, edited) = match kept {
Some((d, last, v, e)) if d == doc && last.saturating_add(1) >= pass => (v, e),
_ => (committed.clone(), false),
};
ctx.data_mut(|d| d.insert_temp(session_key(id), (doc, pass, start, edited)));
}
fn set_edited(ctx: &egui::Context, id: LayerId, edited: bool) {
let kept: Option<Session> = ctx.data(|d| d.get_temp(session_key(id)));
if let Some((doc, pass, start, _)) = kept {
ctx.data_mut(|d| d.insert_temp(session_key(id), (doc, pass, start, edited)));
}
}
/// The settings layer `id` of document `doc` had when the Properties panel started showing it,
/// if the panel has edited them since (or since the last Reset).
pub fn session_start(ctx: &egui::Context, doc: u64, id: LayerId) -> Option<Value> {
let kept: Option<Session> = ctx.data(|d| d.get_temp(session_key(id)));
kept.filter(|k| k.0 == doc && k.3).map(|k| k.2)
}
/// The Properties panel's Reset for an adjustment layer whose kind follows Photoshop's session
/// ([`photoshop_session`]): the `layer.setAdjustment` params, or None for other kinds. Edited in
/// the panel since it started showing the layer (or since the last Reset): back to the settings it
/// found (Tone choice kept); otherwise the defaults (Color Balance: [`reset_color_balance`]).
/// Either way part of the layer's edit step.
pub fn properties_reset(ctx: &egui::Context, doc: u64, id: LayerId, adj: &Adjustment) -> Option<Value> {
let kind = photocraft_engine::commands::adjustment_kind(adj);
if !photoshop_session(kind) {
return None;
}
let mut v = match session_start(ctx, doc, id) {
Some(start) => start,
None => {
let mut v = adjust_params::to_params(adj);
reset_color_balance(ctx, layer_mem(id), &mut v);
v
}
};
set_edited(ctx, id, false);
v["layer"] = json!(id.0);
v["coalesce"] = json!(properties_coalesce(id));
Some(v)
}
/// The Properties-panel editor of an adjustment layer: previews live (`app.live_adjust`) while a
/// control moves and commits one `layer.setAdjustment` per gesture.
pub fn layer_editor(app: &mut PhotocraftApp, ui: &mut egui::Ui, id: LayerId, adj: &Adjustment) {
let t = Tokens::get(ui.ctx());
let kind = photocraft_engine::commands::adjustment_kind(adj);
match adj {
Adjustment::SelectiveColor { .. } => return crate::adjust_ui::selective_color_editor(app, ui, id, adj),
Adjustment::ColorLookup { .. } => return crate::adjust_ui::color_lookup_editor(app, ui, id, adj),
Adjustment::Invert => {
ui.label(RichText::new(tl!("Invert has no settings.")).color(t.text_faint));
return;
}
Adjustment::Unsupported { psd_key, .. } => {
let template = "This adjustment ({key}) is kept as imported and can't be edited yet.";
ui.label(RichText::new(crate::i18n::fmt(tl!(template), &[("key", psd_key)])).color(t.text_faint));
return;
}
_ => {}
}
let committed = adjust_params::to_params(adj);
let session = photoshop_session(kind);
if session && let Some(doc) = app.session.active().map(|s| s.doc.id.0) {
track_session(ui.ctx(), doc, id, &committed);
}
let mut values = match &app.live_adjust {
Some((l, v)) if *l == id => v.clone(),
_ => committed.clone(),
};
let gray = app.session.active().is_some_and(|s| is_gray(s.doc.mode));
let hist = needs_histogram(kind).then(|| tone::histograms(app, HistSource::BelowLayer(id), space_of(&values)));
let cx = EditorCx {
mem: layer_mem(id),
hist,
gray,
swatches: swatches(app),
gradients: gradient_presets(app, kind),
dialog: false,
dynamic_color_sliders: app.session.prefs().interface.dynamic_color_sliders,
isolated_curve: None,
};
if matches!(kind, "levels" | "curves") {
crate::layer_picker::controls(app, ui, id);
}
let e = editor(ui, kind, &mut values, &cx);
if e.import_gradients {
crate::preset_files_ui::import_gradients_dialog(app);
}
if e.changed {
app.live_adjust = Some((id, values.clone()));
}
if e.commit {
if values != committed {
let rev = app.session.active().map(|s| s.revision);
let mut p = values;
p["layer"] = json!(id.0);
if session {
p["coalesce"] = json!(properties_coalesce(id));
set_edited(ui.ctx(), id, true);
}
if let Err(err) = app.run("layer.setAdjustment", p) {
app.ui.status = err;
}
tone::keep_after_commit(app, id, rev);
}
app.live_adjust = None;
}
}