mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 01:18:43 +00:00
Merge upstream/main into fix/vp-stamp-tearoff
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
commit
cdb9854550
11 files changed
+475
-126
No files matched your search
@@ -3,12 +3,14 @@
|
||||
//! modify (expand, contract, border, smooth, feather), anti-aliased lasso,
|
||||
//! and combining with an existing selection.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use photocraft_color::PixelFormat;
|
||||
use photocraft_geom::{Rect, TILE_SIZE, TileCoord};
|
||||
use photocraft_raster::Surface;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::photo_util::par_rows;
|
||||
use crate::photo_util::{par_map, par_rows};
|
||||
|
||||
/// How a new selection combines with the current one.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
@@ -79,49 +81,57 @@ fn coverage8(v: f32) -> u8 {
|
||||
(v.clamp(0.0, 1.0) * 255.0 + 0.5) as u8
|
||||
}
|
||||
|
||||
/// Builds a GRAY8 selection surface from 8-bit coverage over `area`, allocating only the tiles
|
||||
/// that hold something (as [`Surface::prune`] would leave them).
|
||||
fn surface_from_coverage8(bytes: &[u8], area: Rect) -> Surface {
|
||||
/// Builds a GRAY8 selection surface over `area` (masks row-major over it) whose coverage at
|
||||
/// each sample is `f(prev, new)`, `prev` reading 0 without a `prev` mask and missing samples
|
||||
/// reading 0. Tiles are filled in parallel straight from the masks, a row at a time (no
|
||||
/// full-canvas byte buffer); only the tiles that hold something are kept (as [`Surface::prune`]
|
||||
/// would leave them), and fully selected tiles share one tile (copy-on-write), so the inside of a
|
||||
/// large selection costs no memory per tile (#211).
|
||||
fn surface_from_masks(area: Rect, new: &[f32], prev: Option<&[f32]>, f: impl Fn(f32, f32) -> f32 + Sync + Send) -> Surface {
|
||||
let mut s = Surface::new(PixelFormat::GRAY8);
|
||||
if area.is_empty() {
|
||||
return s;
|
||||
}
|
||||
let w = area.width() as usize;
|
||||
let ts = TILE_SIZE as usize;
|
||||
for tc in area.tiles() {
|
||||
let tr = tc.rect().intersect(&area);
|
||||
let (lx, span) = ((tr.x0 - area.x0) as usize, tr.width() as usize);
|
||||
let row = |y: i32| bytes.get((y - area.y0) as usize * w + lx..(y - area.y0) as usize * w + lx + span);
|
||||
if !(tr.y0..tr.y1).any(|y| row(y).is_some_and(|r| r.iter().any(|b| *b != 0))) {
|
||||
continue;
|
||||
}
|
||||
let data = s.tile_mut(tc).bytes_mut();
|
||||
for y in tr.y0..tr.y1 {
|
||||
let o = (y - tc.ty * TILE_SIZE) as usize * ts + (tr.x0 - tc.tx * TILE_SIZE) as usize;
|
||||
if let (Some(src), Some(dst)) = (row(y), data.get_mut(o..o + span)) {
|
||||
dst.copy_from_slice(src);
|
||||
let full = s.solid_tile(&[1.0]);
|
||||
let row = |i0: usize, dst: &mut [u8]| {
|
||||
let n = dst.len();
|
||||
match (new.get(i0..i0 + n), prev.map(|p| p.get(i0..i0 + n))) {
|
||||
(Some(sn), None) => dst.iter_mut().zip(sn).for_each(|(d, v)| *d = coverage8(f(0.0, *v))),
|
||||
(Some(sn), Some(Some(sp))) => dst.iter_mut().zip(sn.iter().zip(sp)).for_each(|(d, (v, p))| *d = coverage8(f(*p, *v))),
|
||||
_ => {
|
||||
let at = |m: &[f32], i: usize| m.get(i).copied().unwrap_or(0.0);
|
||||
for (i, d) in (i0..).zip(dst.iter_mut()) {
|
||||
*d = coverage8(f(prev.map_or(0.0, |p| at(p, i)), at(new, i)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
// Every tile starts as one shared blank tile; `Arc::make_mut` gives each task its own copy.
|
||||
let blanks = s.take_tiles(area);
|
||||
let built = par_map(blanks.len(), |k| {
|
||||
let (tc, blank) = blanks.get(k)?;
|
||||
let tr = tc.rect().intersect(&area);
|
||||
let (lx, span) = ((tr.x0 - area.x0) as usize, tr.width() as usize);
|
||||
let mut tile = Arc::clone(blank);
|
||||
let data = Arc::make_mut(&mut tile).bytes_mut();
|
||||
let (mut lo, mut hi) = (if tr == tc.rect() { u8::MAX } else { 0 }, 0u8);
|
||||
for y in tr.y0..tr.y1 {
|
||||
let o = (y - tc.ty * TILE_SIZE) as usize * ts + (tr.x0 - tc.tx * TILE_SIZE) as usize;
|
||||
let Some(dst) = data.get_mut(o..o + span) else { continue };
|
||||
row((y - area.y0) as usize * w + lx, dst);
|
||||
(lo, hi) = dst.iter().fold((lo, hi), |(lo, hi), b| (lo.min(*b), hi.max(*b)));
|
||||
}
|
||||
(hi > 0).then(|| (*tc, if lo == u8::MAX { Arc::clone(&full) } else { tile }))
|
||||
});
|
||||
s.put_tiles(built.into_iter().flatten());
|
||||
s
|
||||
}
|
||||
|
||||
/// 8-bit coverage of `m` (missing samples are 0), computed in parallel.
|
||||
fn to_coverage8(m: &[f32], area: Rect, f: impl Fn(usize, f32) -> f32 + Sync + Send) -> Vec<u8> {
|
||||
let w = area.width() as usize;
|
||||
let mut bytes = vec![0u8; w * area.height() as usize];
|
||||
par_rows(&mut bytes, w, 1, |y, row| {
|
||||
for (x, b) in row.iter_mut().enumerate() {
|
||||
let i = y * w + x;
|
||||
*b = coverage8(f(i, m.get(i).copied().unwrap_or(0.0)));
|
||||
}
|
||||
});
|
||||
bytes
|
||||
}
|
||||
|
||||
/// Builds a GRAY8 selection surface from a mask over `area`.
|
||||
/// Builds a GRAY8 selection surface from a mask over `area` (missing samples are 0).
|
||||
pub fn mask_to_surface(m: &[f32], area: Rect) -> Surface {
|
||||
if area.is_empty() {
|
||||
return Surface::new(PixelFormat::GRAY8);
|
||||
}
|
||||
surface_from_coverage8(&to_coverage8(m, area, |_, v| v), area)
|
||||
surface_from_masks(area, m, None, |_, v| v)
|
||||
}
|
||||
|
||||
/// Combines `new` with `old` by `mode`. Returns `None` when nothing is selected.
|
||||
@@ -132,22 +142,18 @@ pub fn combine(old: Option<&Surface>, new: &[f32], area: Rect, mode: SelectionMo
|
||||
// Quantize to the 8-bit grid selections are stored on, so combining a mask with itself is
|
||||
// exact. Below half an 8-bit step is nothing.
|
||||
let q = |v: f32| f32::from(coverage8(v)) / 255.0;
|
||||
let bytes = match mode {
|
||||
SelectionMode::Replace => to_coverage8(new, area, |_, v| v),
|
||||
let s = match mode {
|
||||
SelectionMode::Replace => surface_from_masks(area, new, None, |_, v| v),
|
||||
_ => {
|
||||
let prev = mask_from_surface(old, area);
|
||||
let at = |i: usize| prev.get(i).copied().unwrap_or(0.0);
|
||||
match mode {
|
||||
SelectionMode::Add => to_coverage8(new, area, |i, v| at(i).max(q(v))),
|
||||
SelectionMode::Subtract => to_coverage8(new, area, |i, v| (at(i) - q(v)).max(0.0)),
|
||||
_ => to_coverage8(new, area, |i, v| at(i).min(q(v))),
|
||||
SelectionMode::Add => surface_from_masks(area, new, Some(&prev), |p, v| p.max(q(v))),
|
||||
SelectionMode::Subtract => surface_from_masks(area, new, Some(&prev), |p, v| (p - q(v)).max(0.0)),
|
||||
_ => surface_from_masks(area, new, Some(&prev), |p, v| p.min(q(v))),
|
||||
}
|
||||
}
|
||||
};
|
||||
if bytes.iter().all(|b| *b == 0) {
|
||||
return None;
|
||||
}
|
||||
Some(surface_from_coverage8(&bytes, area))
|
||||
(s.tile_count() > 0).then_some(s)
|
||||
}
|
||||
|
||||
fn close(a: [f32; 4], b: [f32; 4], tol: f32) -> bool {
|
||||
@@ -1202,7 +1208,10 @@ mod tests {
|
||||
let mut rng = crate::photo_util::Rng(7);
|
||||
let mut u = move || (rng.next() >> 11) as f32 / (1u64 << 53) as f32;
|
||||
// Off-grid areas spanning several tiles, including negative origins.
|
||||
for area in [Rect::new(0, 0, 300, 20), Rect::new(-37, 250, 530, 263), Rect::new(255, -3, 258, 600), Rect::new(5, 5, 6, 6)] {
|
||||
// The last one holds whole tiles, which fully selected masks fill (shared tiles).
|
||||
for area in
|
||||
[Rect::new(0, 0, 300, 20), Rect::new(-37, 250, 530, 263), Rect::new(255, -3, 258, 600), Rect::new(5, 5, 6, 6), Rect::new(-37, -300, 530, 263)]
|
||||
{
|
||||
let n = area.width() as usize * area.height() as usize;
|
||||
let old_m: Vec<f32> = (0..n).map(|i| if i % 97 < 40 { u() } else { 0.0 }).collect();
|
||||
let old = old_mask_to_surface(&old_m, area);
|
||||
@@ -1211,7 +1220,7 @@ mod tests {
|
||||
let mut slow_read = Vec::new();
|
||||
old.read_region_into(area, &mut slow_read);
|
||||
assert_eq!(mask_from_surface(Some(&old), area), slow_read);
|
||||
for kind in 0..3 {
|
||||
for kind in 0..4 {
|
||||
let new: Vec<f32> = (0..n)
|
||||
.map(|i| match kind {
|
||||
0 => u() * 1.2 - 0.1,
|
||||
@@ -1222,7 +1231,8 @@ mod tests {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
_ => 0.001,
|
||||
2 => 0.001,
|
||||
_ => f32::from(u8::from(i >= 1000)),
|
||||
})
|
||||
.collect();
|
||||
for mode in [SelectionMode::Replace, SelectionMode::Add, SelectionMode::Subtract, SelectionMode::Intersect] {
|
||||
|
||||
@@ -398,7 +398,9 @@ fn modify(s: &mut Session, p: &Value, op: &str) -> Result<Value> {
|
||||
if pw.checked_mul(ph).is_none_or(|n| n > MAX_MODIFY_PIXELS) {
|
||||
return Err(EngineError::BadParams { cmd: format!("select.modify.{op}"), msg: "the selection is too large to modify".into() });
|
||||
}
|
||||
let padded = pad_mask(&m, w, h, pad, at_bounds);
|
||||
// Unpadded (the usual case) the mask is used as it is: two serial full-canvas copies were
|
||||
// most of a 24 MP Feather or Smooth (#211).
|
||||
let padded = if pad == 0 { m } else { pad_mask(&m, w, h, pad, at_bounds) };
|
||||
let out = match op {
|
||||
"expand" => sel::expand(&padded, pw, ph, r),
|
||||
"contract" => sel::contract(&padded, pw, ph, r),
|
||||
@@ -406,7 +408,7 @@ fn modify(s: &mut Session, p: &Value, op: &str) -> Result<Value> {
|
||||
"smooth" => sel::smooth(&padded, pw, ph, r),
|
||||
_ => sel::feather(&padded, pw, ph, r),
|
||||
};
|
||||
let out = crop_mask(&out, pw, pad, w, h);
|
||||
let out = if pad == 0 { out } else { crop_mask(&out, pw, pad, w, h) };
|
||||
let label = match op {
|
||||
"expand" => "Expand Selection",
|
||||
"contract" => "Contract Selection",
|
||||
@@ -435,19 +437,18 @@ fn pad_mask(m: &[f32], w: usize, h: usize, pad: usize, outside_empty: bool) -> V
|
||||
if w == 0 || h == 0 {
|
||||
return out;
|
||||
}
|
||||
// Row by row (a copy and two fills), not sample by sample (#211).
|
||||
for (py, row) in out.chunks_exact_mut(pw).enumerate() {
|
||||
let inside_y = (pad..pad + h).contains(&py);
|
||||
if outside_empty && !inside_y {
|
||||
if outside_empty && !(pad..pad + h).contains(&py) {
|
||||
continue;
|
||||
}
|
||||
let y = py.saturating_sub(pad).min(h - 1);
|
||||
for (px, v) in row.iter_mut().enumerate() {
|
||||
let inside_x = (pad..pad + w).contains(&px);
|
||||
if outside_empty && !inside_x {
|
||||
continue;
|
||||
}
|
||||
let x = px.saturating_sub(pad).min(w - 1);
|
||||
*v = m.get(y * w + x).copied().unwrap_or(0.0);
|
||||
let (Some(src), Some((left, rest))) = (m.get(y * w..(y + 1) * w), row.split_at_mut_checked(pad)) else { continue };
|
||||
let Some((mid, right)) = rest.split_at_mut_checked(w) else { continue };
|
||||
mid.copy_from_slice(src);
|
||||
if !outside_empty {
|
||||
left.fill(src.first().copied().unwrap_or(0.0));
|
||||
right.fill(src.last().copied().unwrap_or(0.0));
|
||||
}
|
||||
}
|
||||
out
|
||||
@@ -455,7 +456,11 @@ fn pad_mask(m: &[f32], w: usize, h: usize, pad: usize, outside_empty: bool) -> V
|
||||
|
||||
/// The `w`×`h` centre of a mask padded by `pad_mask`.
|
||||
fn crop_mask(m: &[f32], pw: usize, pad: usize, w: usize, h: usize) -> Vec<f32> {
|
||||
m.chunks_exact(pw).skip(pad).take(h).flat_map(|row| row.iter().skip(pad).take(w).copied()).collect()
|
||||
let mut out = Vec::with_capacity(w.saturating_mul(h));
|
||||
for row in m.chunks_exact(pw.max(1)).skip(pad).take(h) {
|
||||
out.extend_from_slice(row.get(pad..pad + w).unwrap_or_default());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Grow (contiguous) / Similar (anywhere): pixels whose colour lies within
|
||||
@@ -1007,4 +1012,45 @@ mod tests {
|
||||
s.execute("edit.undo", json!({})).unwrap();
|
||||
assert_eq!(coverage(&s, 2, 2), 1.0);
|
||||
}
|
||||
|
||||
/// The previous per-sample padding and cropping, kept as the oracle for the row-wise ones.
|
||||
fn old_pad_mask(m: &[f32], w: usize, h: usize, pad: usize, outside_empty: bool) -> Vec<f32> {
|
||||
let pw = w + 2 * pad;
|
||||
let mut out = vec![0.0f32; pw * (h + 2 * pad)];
|
||||
for (py, row) in out.chunks_exact_mut(pw).enumerate() {
|
||||
let inside_y = (pad..pad + h).contains(&py);
|
||||
if outside_empty && !inside_y {
|
||||
continue;
|
||||
}
|
||||
let y = py.saturating_sub(pad).min(h - 1);
|
||||
for (px, v) in row.iter_mut().enumerate() {
|
||||
if outside_empty && !(pad..pad + w).contains(&px) {
|
||||
continue;
|
||||
}
|
||||
*v = m.get(y * w + px.saturating_sub(pad).min(w - 1)).copied().unwrap_or(0.0);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn row_wise_pad_and_crop_match_per_sample_ones() {
|
||||
let mut seed = 0x2545_f491_4f6c_dd1du64;
|
||||
let (w, h) = (37, 23);
|
||||
let m: Vec<f32> = (0..w * h)
|
||||
.map(|_| {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 7;
|
||||
seed ^= seed << 17;
|
||||
(seed % 1000) as f32 / 999.0
|
||||
})
|
||||
.collect();
|
||||
for pad in [0, 1, 5, 40] {
|
||||
for outside_empty in [false, true] {
|
||||
let padded = pad_mask(&m, w, h, pad, outside_empty);
|
||||
assert_eq!(padded, old_pad_mask(&m, w, h, pad, outside_empty), "pad {pad} {outside_empty}");
|
||||
assert_eq!(crop_mask(&padded, w + 2 * pad, pad, w, h), m, "pad {pad}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1147,9 +1147,14 @@ fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
|
||||
ui.horizontal(|ui| {
|
||||
label(ui, tl!("Preset:"));
|
||||
let mut picked = None;
|
||||
egui::ComboBox::from_id_salt(cx.mem.with("gm-preset")).selected_text(tl!("Custom")).width(190.0).height(420.0).icon(widgets::chevron_icon).show_ui(
|
||||
ui,
|
||||
|ui| {
|
||||
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(190.0)
|
||||
.height(420.0)
|
||||
.icon(widgets::chevron_icon)
|
||||
.close_behavior(close)
|
||||
.show_ui(ui, |ui| {
|
||||
for g in &cx.gradients {
|
||||
ui.label(RichText::new(&g.name).color(t.text_faint));
|
||||
for p in &g.items {
|
||||
@@ -1159,14 +1164,15 @@ fn gradient_map(ui: &mut egui::Ui, v: &mut Value, cx: &EditorCx) -> Edit {
|
||||
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.
|
||||
if swatch.clicked() | ui.selectable_label(false, &p.name).clicked() {
|
||||
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);
|
||||
if let Some(p) = picked {
|
||||
stops = p;
|
||||
write_stops(v, &stops);
|
||||
|
||||
@@ -265,14 +265,17 @@ fn contributors_in(app: &mut PhotocraftApp, ui: &mut egui::Ui, contributors: &[C
|
||||
}
|
||||
ui.separator();
|
||||
ui.label(tl!("Sort"));
|
||||
egui::ComboBox::from_id_salt("credits_sort").selected_text(v.key.label().0).show_ui(ui, |ui| {
|
||||
let (press, close) = crate::press_menu::PressCombo::before(ui, "credits_sort");
|
||||
let sort = egui::ComboBox::from_id_salt("credits_sort").selected_text(v.key.label().0).close_behavior(close).show_ui(ui, |ui| {
|
||||
for k in SortKey::ALL {
|
||||
if ui.selectable_label(v.key == k, k.label().0).clicked() {
|
||||
let item = ui.selectable_label(v.key == k, k.label().0);
|
||||
if press.chosen(ui, &item) {
|
||||
v.key = k;
|
||||
v.ascending = k.default_ascending();
|
||||
}
|
||||
}
|
||||
});
|
||||
press.after(&sort.response);
|
||||
if ui.button(if v.ascending { "▲" } else { "▼" }).on_hover_text(tl!("Reverse the order")).clicked() {
|
||||
v.ascending = !v.ascending;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
//! #2735: a dropdown takes one press-drag-release, like the menus (#775): press the box, drag onto
|
||||
//! an option, release to choose it.
|
||||
|
||||
use egui::accesskit::Role;
|
||||
use egui_kittest::Harness;
|
||||
use egui_kittest::kittest::{NodeT, Queryable};
|
||||
use photocraft_doc::BlendMode;
|
||||
use serde_json::json;
|
||||
|
||||
use crate::PhotocraftApp;
|
||||
use crate::state::Tool;
|
||||
|
||||
fn app_with_a_layer() -> Harness<'static, PhotocraftApp> {
|
||||
let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_max_steps(64).build_eframe(|cc| {
|
||||
PhotocraftApp::setup_context(&cc.egui_ctx, Default::default());
|
||||
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
|
||||
app.run("file.new", json!({"width": 64, "height": 64})).unwrap();
|
||||
app.run("layer.new.layer", json!({})).unwrap();
|
||||
// No tool options bar Mode dropdown showing "Normal" too.
|
||||
app.ui.tool = Tool::Move;
|
||||
app
|
||||
});
|
||||
h.run_steps(6);
|
||||
h
|
||||
}
|
||||
|
||||
fn blend(h: &Harness<'_, PhotocraftApp>) -> BlendMode {
|
||||
let st = h.state().session.active().unwrap();
|
||||
st.doc.layer(st.active_layer.unwrap()).unwrap().blend
|
||||
}
|
||||
|
||||
/// The Layers panel's Blend Mode dropdown (showing `value`).
|
||||
fn blend_box(h: &Harness<'_, PhotocraftApp>, value: &str) -> egui::Rect {
|
||||
let named = |n: &egui_kittest::Node<'_>| {
|
||||
let a = n.accesskit_node();
|
||||
a.value().as_deref() == Some(value) || a.label().as_deref() == Some(value)
|
||||
};
|
||||
h.query_all_by_role(Role::ComboBox).find(|n| named(n)).expect("the Layers panel's Blend Mode dropdown").rect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn press_drag_release_picks_a_blend_mode() {
|
||||
let mut h = app_with_a_layer();
|
||||
assert_eq!(blend(&h), BlendMode::Normal);
|
||||
let at = blend_box(&h, "Normal").center();
|
||||
h.hover_at(at);
|
||||
h.run_steps(1);
|
||||
h.drag_at(at);
|
||||
h.run_steps(3);
|
||||
let multiply = h.query_by_label("Multiply").expect("the list opened on the press").rect().center();
|
||||
for k in 1..=6 {
|
||||
h.hover_at(at + (multiply - at) * (k as f32 / 6.0));
|
||||
h.run_steps(1);
|
||||
}
|
||||
h.drop_at(multiply);
|
||||
h.run_steps(3);
|
||||
assert_eq!(blend(&h), BlendMode::Multiply, "releasing on Multiply picked it");
|
||||
assert!(h.query_by_label("Color Burn").is_none(), "and closed the list");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_click_still_opens_the_list_for_a_second_click() {
|
||||
let mut h = app_with_a_layer();
|
||||
let at = blend_box(&h, "Normal").center();
|
||||
h.hover_at(at);
|
||||
h.run_steps(1);
|
||||
h.drag_at(at);
|
||||
h.run_steps(1);
|
||||
h.drop_at(at);
|
||||
h.run_steps(3);
|
||||
assert_eq!(blend(&h), BlendMode::Normal, "the click chose nothing");
|
||||
let screen = h.query_by_label("Screen").expect("the list stays open after a click");
|
||||
screen.click();
|
||||
h.run_steps(3);
|
||||
assert_eq!(blend(&h), BlendMode::Screen, "a second click picks");
|
||||
}
|
||||
@@ -2160,6 +2160,9 @@ mod warp_text_dialog_tests;
|
||||
#[cfg(test)]
|
||||
mod blend_dropdown_wheel_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
mod dropdown_press_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
mod marquee_tests;
|
||||
|
||||
|
||||
@@ -84,6 +84,63 @@ pub fn show<R>(button: &Response, content: impl FnOnce(&mut Ui, &PressMenu) -> R
|
||||
shown
|
||||
}
|
||||
|
||||
/// The same press-drag-release for an `egui::ComboBox` (#2735): the list opens on the press, so one
|
||||
/// gesture can press the box, drag onto an option and release to choose it, and a plain click
|
||||
/// still opens the list for a second click. egui's combo box shows its own list and toggles it on
|
||||
/// a whole click, so this works around it: [`PressCombo::before`] runs before the box (and gives
|
||||
/// it its close behaviour), [`PressCombo::chosen`] picks its options, [`PressCombo::after`] runs
|
||||
/// after it.
|
||||
pub struct PressCombo {
|
||||
popup: egui::Id,
|
||||
}
|
||||
|
||||
impl PressCombo {
|
||||
/// Before showing the combo box made with `ComboBox::from_id_salt(salt)` in `ui`; returns the
|
||||
/// close behaviour to give it.
|
||||
pub fn before(ui: &Ui, salt: impl egui::AsIdSalt) -> (Self, PopupCloseBehavior) {
|
||||
// egui's ids for the box (`ComboBox::show_ui`) and its list (`widget_to_popup_id`).
|
||||
let combo = PressCombo { popup: ui.make_persistent_id(egui::IdSalt::new(salt)).with("popup") };
|
||||
let ctx = ui.ctx();
|
||||
// The click ending the press that opened the list (the pointer didn't leave the box): egui
|
||||
// toggles the list on it, so close it first and the toggle leaves it open, drawn this
|
||||
// frame. No click may close it either.
|
||||
if combo.owns_gesture(ctx) && ctx.input(|i| i.pointer.primary_clicked()) {
|
||||
Popup::close_id(ctx, combo.popup);
|
||||
return (combo, PopupCloseBehavior::IgnoreClicks);
|
||||
}
|
||||
(combo, PopupCloseBehavior::CloseOnClick)
|
||||
}
|
||||
|
||||
fn owns_gesture(&self, ctx: &egui::Context) -> bool {
|
||||
gesture_owner(ctx) == Some(self.popup)
|
||||
}
|
||||
|
||||
/// Was option `item` (in the open list `ui`) chosen this frame: clicked, or the press-drag
|
||||
/// gesture that opened the list released on it? The list closes when it was.
|
||||
pub fn chosen(&self, ui: &Ui, item: &Response) -> bool {
|
||||
let released_on = item.enabled() && item.contains_pointer() && ui.input(|i| i.pointer.primary_released()) && self.owns_gesture(ui.ctx());
|
||||
if released_on {
|
||||
ui.close();
|
||||
}
|
||||
item.clicked() || released_on
|
||||
}
|
||||
|
||||
/// After the combo box (`button`: its response). A primary press on the box opens a closed
|
||||
/// list, starting a press-drag gesture; the gesture ends with the button.
|
||||
pub fn after(&self, button: &Response) {
|
||||
let ctx = &button.ctx;
|
||||
let pressed = ctx.input(|i| i.pointer.primary_pressed()) && button.is_pointer_button_down_on();
|
||||
if pressed && !Popup::is_id_open(ctx, self.popup) {
|
||||
// Opened now, the list counts as open this frame and egui shows it from the next.
|
||||
Popup::open_id(ctx, self.popup);
|
||||
ctx.data_mut(|d| d.insert_temp(gesture_id(), self.popup));
|
||||
ctx.request_repaint();
|
||||
} else if self.owns_gesture(ctx) && ctx.input(|i| i.pointer.primary_released() || !i.pointer.primary_down()) {
|
||||
ctx.data_mut(|d| d.remove::<egui::Id>(gesture_id()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -241,4 +298,126 @@ mod tests {
|
||||
assert_eq!(rig.press(stroke, false).chosen, Some("Stroke"), "releasing on Stroke chose it");
|
||||
assert!(!rig.frame(Vec::new()).open, "and closed the menu");
|
||||
}
|
||||
|
||||
/// A bare context with one `egui::ComboBox` of three options, driven with [`PressCombo`].
|
||||
struct ComboRig {
|
||||
ctx: egui::Context,
|
||||
value: usize,
|
||||
button: Rect,
|
||||
options: Vec<Rect>,
|
||||
}
|
||||
|
||||
const OPTIONS: [&str; 3] = ["RGB", "Red", "Green"];
|
||||
|
||||
impl ComboRig {
|
||||
fn new() -> Self {
|
||||
let mut rig = ComboRig { ctx: egui::Context::default(), value: 0, button: Rect::NOTHING, options: Vec::new() };
|
||||
rig.frame(Vec::new());
|
||||
rig
|
||||
}
|
||||
|
||||
fn frame(&mut self, events: Vec<Event>) -> Frame {
|
||||
let mut out = Frame::default();
|
||||
let mut options = Vec::new();
|
||||
let rect = Rect::from_min_size(Pos2::ZERO, vec2(400.0, 400.0));
|
||||
let mut value = self.value;
|
||||
let mut button = Rect::NOTHING;
|
||||
let mut output = self.ctx.run_ui(egui::RawInput { screen_rect: Some(rect), events, ..Default::default() }, |ui| {
|
||||
ui.add_space(20.0);
|
||||
let (combo, close) = PressCombo::before(ui, "channel");
|
||||
let shown = egui::ComboBox::from_id_salt("channel").selected_text(OPTIONS[value]).close_behavior(close).show_ui(ui, |ui| {
|
||||
out.open = true;
|
||||
for (i, label) in OPTIONS.into_iter().enumerate() {
|
||||
let item = ui.selectable_label(value == i, label);
|
||||
options.push(item.rect);
|
||||
if combo.chosen(ui, &item) {
|
||||
value = i;
|
||||
out.chosen = Some(label);
|
||||
}
|
||||
}
|
||||
});
|
||||
combo.after(&shown.response);
|
||||
button = shown.response.rect;
|
||||
});
|
||||
output.textures_delta.clear();
|
||||
self.value = value;
|
||||
self.button = button;
|
||||
if !options.is_empty() {
|
||||
self.options = options;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn press(&mut self, pos: Pos2, pressed: bool) -> Frame {
|
||||
self.frame(vec![Event::PointerMoved(pos), Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }])
|
||||
}
|
||||
|
||||
fn drag_to(&mut self, from: Pos2, to: Pos2) {
|
||||
for k in 1..=8 {
|
||||
self.frame(vec![Event::PointerMoved(from + (to - from) * (k as f32 / 8.0))]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn press_drag_release_on_a_combo_box_chooses_an_option() {
|
||||
let mut rig = ComboRig::new();
|
||||
let at = rig.button.center();
|
||||
rig.frame(vec![Event::PointerMoved(at)]);
|
||||
rig.press(at, true);
|
||||
assert!(rig.frame(Vec::new()).open, "the list opens on the press");
|
||||
// its first frame only sizes it: the options are where they are drawn from the next
|
||||
rig.frame(Vec::new());
|
||||
let red = rig.options[1].center();
|
||||
rig.drag_to(at, red);
|
||||
let f = rig.press(red, false);
|
||||
assert_eq!((f.chosen, rig.value), (Some("Red"), 1), "releasing on Red chose it");
|
||||
assert!(!rig.frame(Vec::new()).open, "and closed the list");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_click_on_a_combo_box_leaves_its_list_open_for_a_second_click() {
|
||||
let mut rig = ComboRig::new();
|
||||
let at = rig.button.center();
|
||||
rig.frame(vec![Event::PointerMoved(at)]);
|
||||
rig.press(at, true);
|
||||
let f = rig.press(at, false);
|
||||
assert!(f.open && f.chosen.is_none(), "the click's release keeps the list drawn and chooses nothing");
|
||||
assert!(rig.frame(Vec::new()).open, "the list stays open");
|
||||
let green = rig.options[2].center();
|
||||
rig.frame(vec![Event::PointerMoved(green)]);
|
||||
rig.press(green, true);
|
||||
assert_eq!(rig.press(green, false).chosen, Some("Green"), "a second click chooses");
|
||||
assert_eq!(rig.value, 2);
|
||||
assert!(!rig.frame(Vec::new()).open);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn releasing_off_a_combo_box_list_chooses_nothing() {
|
||||
let mut rig = ComboRig::new();
|
||||
let at = rig.button.center();
|
||||
rig.frame(vec![Event::PointerMoved(at)]);
|
||||
rig.press(at, true);
|
||||
rig.frame(Vec::new());
|
||||
rig.frame(Vec::new());
|
||||
let away = pos2(380.0, 380.0);
|
||||
rig.drag_to(at, away);
|
||||
let f = rig.press(away, false);
|
||||
assert!(f.chosen.is_none() && rig.value == 0, "a release off the options chooses nothing");
|
||||
assert!(rig.frame(Vec::new()).open, "and keeps the list open");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clicking_a_combo_box_again_closes_its_list() {
|
||||
let mut rig = ComboRig::new();
|
||||
let at = rig.button.center();
|
||||
rig.frame(vec![Event::PointerMoved(at)]);
|
||||
rig.press(at, true);
|
||||
rig.press(at, false);
|
||||
assert!(rig.frame(Vec::new()).open);
|
||||
rig.press(at, true);
|
||||
rig.press(at, false);
|
||||
assert!(!rig.frame(Vec::new()).open, "a second click on the box closes the list");
|
||||
assert_eq!(rig.value, 0);
|
||||
}
|
||||
}
|
||||
@@ -311,14 +311,20 @@ pub fn button(
|
||||
fn choice<T: Copy + PartialEq>(ui: &mut egui::Ui, label: &str, value: &mut T, choices: &[(T, &str)]) {
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(tl!(label));
|
||||
egui::ComboBox::from_id_salt(label).width(140.0).selected_text(choices.iter().find(|(v, _)| v == value).map_or("", |(_, n)| tl!(*n))).show_ui(
|
||||
ui,
|
||||
|ui| {
|
||||
let (press, close) = crate::press_menu::PressCombo::before(ui, label);
|
||||
let combo = egui::ComboBox::from_id_salt(label)
|
||||
.width(140.0)
|
||||
.selected_text(choices.iter().find(|(v, _)| v == value).map_or("", |(_, n)| tl!(*n)))
|
||||
.close_behavior(close)
|
||||
.show_ui(ui, |ui| {
|
||||
for (v, n) in choices {
|
||||
ui.selectable_value(value, *v, tl!(*n));
|
||||
let item = ui.selectable_label(*value == *v, tl!(*n));
|
||||
if press.chosen(ui, &item) {
|
||||
*value = *v;
|
||||
}
|
||||
}
|
||||
},
|
||||
);
|
||||
});
|
||||
press.after(&combo.response);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -977,6 +977,8 @@ pub(crate) fn family_picker_in(
|
||||
) -> bool {
|
||||
let mut changed = false;
|
||||
let search_id = ui.id().with(("font-search", salt));
|
||||
// The list opens on the press, so a press-drag-release picks a font too (#2735).
|
||||
let (press, close) = crate::press_menu::PressCombo::before(ui, salt);
|
||||
let combo = egui::ComboBox::from_id_salt(salt)
|
||||
.selected_text(current.as_str())
|
||||
.width(width)
|
||||
@@ -984,7 +986,7 @@ pub(crate) fn family_picker_in(
|
||||
.icon(crate::widgets::chevron_icon)
|
||||
// Clicks inside the menu (the search field, the scroll bar) must not close it (#1369);
|
||||
// picking a font closes it explicitly below.
|
||||
.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside);
|
||||
.close_behavior(if matches!(close, egui::PopupCloseBehavior::IgnoreClicks) { close } else { egui::PopupCloseBehavior::CloseOnClickOutside });
|
||||
|
||||
let response = combo.show_ui(ui, |ui| {
|
||||
let (pass_id, focus_id, height_id) = (search_id.with("pass"), search_id.with("focus"), search_id.with("height"));
|
||||
@@ -1054,7 +1056,7 @@ pub(crate) fn family_picker_in(
|
||||
if response.hovered() {
|
||||
hovered = Some(f.clone());
|
||||
}
|
||||
if response.clicked() {
|
||||
if press.chosen(ui, &response) {
|
||||
*current = f.clone();
|
||||
// A served family not fetched yet: start now, before any text needs it.
|
||||
photocraft_text::served::request(f);
|
||||
@@ -1075,6 +1077,7 @@ pub(crate) fn family_picker_in(
|
||||
}
|
||||
if accept { None } else { hovered }
|
||||
});
|
||||
press.after(&response.response);
|
||||
let hovered_font = response.inner.unwrap_or_default();
|
||||
|
||||
if salt == "type-font" {
|
||||
@@ -1397,13 +1400,22 @@ fn kerning_field(ui: &mut egui::Ui, shown: &str, width: f32) -> Option<serde_jso
|
||||
out = parse_kerning(&buf);
|
||||
}
|
||||
let presets = ["Metrics", "Optical", "0", "-100", "-75", "-50", "-25", "-10", "-5", "5", "10", "25", "50", "75", "100", "200"];
|
||||
egui::ComboBox::from_id_salt("props-kern-presets").selected_text("").width(16.0).height(420.0).icon(crate::widgets::chevron_icon).show_ui(ui, |ui| {
|
||||
for p in presets {
|
||||
if ui.selectable_label(p == shown, p).clicked() {
|
||||
out = parse_kerning(p);
|
||||
let (press, close) = crate::press_menu::PressCombo::before(ui, "props-kern-presets");
|
||||
let combo = egui::ComboBox::from_id_salt("props-kern-presets")
|
||||
.selected_text("")
|
||||
.width(16.0)
|
||||
.height(420.0)
|
||||
.icon(crate::widgets::chevron_icon)
|
||||
.close_behavior(close)
|
||||
.show_ui(ui, |ui| {
|
||||
for p in presets {
|
||||
let item = ui.selectable_label(p == shown, p);
|
||||
if press.chosen(ui, &item) {
|
||||
out = parse_kerning(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
press.after(&combo.response);
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
@@ -956,44 +956,48 @@ fn dropdown_with<T: PartialEq + Clone>(ui: &mut Ui, id: &str, current: &mut T, o
|
||||
// after a step over the button.
|
||||
let reveal_id = wheel_id.with("reveal");
|
||||
let mut reveal = wheel && ui.data_mut(|d| d.remove_temp::<bool>(reveal_id)).unwrap_or(false);
|
||||
let response = egui::ComboBox::from_id_salt(id).selected_text(label).width(width).height(420.0).icon(chevron_icon).show_ui(ui, |ui| {
|
||||
fit_widest_option(ui, options.iter().map(|(_, l)| tl!(l)));
|
||||
// Over the open list the wheel steps the value too, instead of scrolling the list.
|
||||
over_list = wheel && ui.rect_contains_pointer(ui.clip_rect());
|
||||
if over_list {
|
||||
let stepped = wheel_steps(ui, wheel_id, true, current, options);
|
||||
wheeled = !stepped.is_empty();
|
||||
reveal |= wheeled;
|
||||
chosen.extend(stepped);
|
||||
}
|
||||
// The row nearest the pointer, by its distance to each row.
|
||||
let pointer = ui.ctx().pointer_hover_pos().filter(|_| ui.rect_contains_pointer(ui.clip_rect()));
|
||||
let mut nearest: Option<(f32, &T)> = None;
|
||||
for (v, l) in options {
|
||||
let item = ui.selectable_label(v == current, tl!(l));
|
||||
if reveal && v == current {
|
||||
item.scroll_to_me(None);
|
||||
// The list opens on the press: press, drag onto an option and release to choose it (#2735).
|
||||
let (press, close) = crate::press_menu::PressCombo::before(ui, id);
|
||||
let response =
|
||||
egui::ComboBox::from_id_salt(id).selected_text(label).width(width).height(420.0).icon(chevron_icon).close_behavior(close).show_ui(ui, |ui| {
|
||||
fit_widest_option(ui, options.iter().map(|(_, l)| tl!(l)));
|
||||
// Over the open list the wheel steps the value too, instead of scrolling the list.
|
||||
over_list = wheel && ui.rect_contains_pointer(ui.clip_rect());
|
||||
if over_list {
|
||||
let stepped = wheel_steps(ui, wheel_id, true, current, options);
|
||||
wheeled = !stepped.is_empty();
|
||||
reveal |= wheeled;
|
||||
chosen.extend(stepped);
|
||||
}
|
||||
if item.hovered() {
|
||||
hovered = Some(v.clone());
|
||||
}
|
||||
if let Some(p) = pointer {
|
||||
let d = (item.rect.top() - p.y).max(p.y - item.rect.bottom()).max(0.0);
|
||||
if nearest.is_none_or(|(n, _)| d < n) {
|
||||
nearest = Some((d, v));
|
||||
// The row nearest the pointer, by its distance to each row.
|
||||
let pointer = ui.ctx().pointer_hover_pos().filter(|_| ui.rect_contains_pointer(ui.clip_rect()));
|
||||
let mut nearest: Option<(f32, &T)> = None;
|
||||
for (v, l) in options {
|
||||
let item = ui.selectable_label(v == current, tl!(l));
|
||||
if reveal && v == current {
|
||||
item.scroll_to_me(None);
|
||||
}
|
||||
if item.hovered() {
|
||||
hovered = Some(v.clone());
|
||||
}
|
||||
if let Some(p) = pointer {
|
||||
let d = (item.rect.top() - p.y).max(p.y - item.rect.bottom()).max(0.0);
|
||||
if nearest.is_none_or(|(n, _)| d < n) {
|
||||
nearest = Some((d, v));
|
||||
}
|
||||
}
|
||||
if press.chosen(ui, &item) {
|
||||
*current = v.clone();
|
||||
chosen.push(v.clone());
|
||||
}
|
||||
}
|
||||
if item.clicked() {
|
||||
*current = v.clone();
|
||||
chosen.push(v.clone());
|
||||
// Between two rows (item spacing) the pointer hovers neither; it is still over the list,
|
||||
// so keep previewing the nearest row instead of flashing the current value back (#2553).
|
||||
if hovered.is_none() {
|
||||
hovered = nearest.map(|(_, v)| v.clone());
|
||||
}
|
||||
}
|
||||
// Between two rows (item spacing) the pointer hovers neither; it is still over the list,
|
||||
// so keep previewing the nearest row instead of flashing the current value back (#2553).
|
||||
if hovered.is_none() {
|
||||
hovered = nearest.map(|(_, v)| v.clone());
|
||||
}
|
||||
});
|
||||
});
|
||||
press.after(&response.response);
|
||||
if combo_box_arrow_keys(ui, &response.response, current, options) {
|
||||
chosen.push(current.clone());
|
||||
}
|
||||
@@ -1140,15 +1144,19 @@ pub fn swatch_popup(swatch: &Response) -> egui::Popup<'static> {
|
||||
pub fn dropdown_with_tooltips<T: PartialEq + Clone>(ui: &mut Ui, id: &str, current: &mut T, options: &[(T, &str, &str)], width: f32) -> bool {
|
||||
let label = options.iter().find(|(v, _, _)| v == current).map(|(_, l, _)| tl!(l)).unwrap_or("—");
|
||||
let mut changed = false;
|
||||
let response = egui::ComboBox::from_id_salt(id).selected_text(label).width(width).height(420.0).icon(chevron_icon).show_ui(ui, |ui| {
|
||||
fit_widest_option(ui, options.iter().map(|(_, l, _)| tl!(l)));
|
||||
for (v, l, tip) in options {
|
||||
if ui.selectable_label(v == current, tl!(l)).on_hover_text(tl!(tip)).clicked() {
|
||||
*current = v.clone();
|
||||
changed = true;
|
||||
let (press, close) = crate::press_menu::PressCombo::before(ui, id);
|
||||
let response =
|
||||
egui::ComboBox::from_id_salt(id).selected_text(label).width(width).height(420.0).icon(chevron_icon).close_behavior(close).show_ui(ui, |ui| {
|
||||
fit_widest_option(ui, options.iter().map(|(_, l, _)| tl!(l)));
|
||||
for (v, l, tip) in options {
|
||||
let item = ui.selectable_label(v == current, tl!(l)).on_hover_text(tl!(tip));
|
||||
if press.chosen(ui, &item) {
|
||||
*current = v.clone();
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
press.after(&response.response);
|
||||
if let Some((_, _, tip)) = options.iter().find(|(v, _, _)| v == current) {
|
||||
let _ = response.response.on_hover_text(tl!(tip));
|
||||
}
|
||||
|
||||
+2
-2
@@ -324,7 +324,7 @@ issue = 211
|
||||
bench = "perf_scenarios"
|
||||
row = "Select > Modify > Smooth r 50 on 24 MP"
|
||||
budget_ms = 100
|
||||
enforce = false # #211: fastest samples 30-33 ms; p95 still over budget at load avg > 100
|
||||
enforce = false # #2873: p95 20-45 ms on 16 cores (load up to ~15), over 100 ms only at load avg > 20; CI cores unmeasured
|
||||
|
||||
[[scenario]]
|
||||
id = "P27"
|
||||
@@ -333,7 +333,7 @@ issue = 211
|
||||
bench = "perf_scenarios"
|
||||
row = "Select > Modify > Feather r 50 on 24 MP"
|
||||
budget_ms = 100
|
||||
enforce = false # #211: fastest samples 30-33 ms; p95 still over budget at load avg > 100
|
||||
enforce = false # #2873: p95 20-45 ms on 16 cores (load up to ~15), over 100 ms only at load avg > 20; CI cores unmeasured
|
||||
|
||||
[[scenario]]
|
||||
id = "P28"
|
||||
|
||||
Reference in new issue
Block a user