feat: animate zoom changes (#566)

This commit is contained in:
Gustavo Ziger committed 2026-10-11 17:53:22 -03:00
1 parent 3674ed62bd
commit aa57cc80b9
16 files changed
+493 -19

No files matched your search

+3
View File
@@ -106,3 +106,6 @@ display_name = "SyntaxError"
[people.axlecoffee]
sync_github_name = true
[people.zi-ger]
sync_github_name = true
+8 -1
View File
@@ -142,21 +142,28 @@ pub(crate) fn run_view(app: &mut PhotocraftApp, id: &str, params: Value) -> Resu
let v = app.ui.views.get_mut(i).ok_or("no document view")?;
v.fill_pending = false;
match id {
"view.fitOnScreen" => v.fit_pending = true,
"view.fitOnScreen" => {
v.fit_pending = true;
v.zoom_animating = true;
}
"view.zoomIn" => {
v.fit_pending = false;
v.zoom = crate::zoom_levels::step(v.zoom, 1, v.doc_size);
v.zoom_animating = true;
}
"view.zoomOut" => {
v.fit_pending = false;
v.zoom = crate::zoom_levels::step(v.zoom, -1, v.doc_size);
v.zoom_animating = true;
}
"view.actualPixels" => {
v.fit_pending = false;
v.zoom = 1.0;
v.zoom_animating = true;
}
_ => return Err(format!("unsupported view command: {id}")),
}
v.zoom_anchor = None;
app.session.journal.push((id.into(), params));
Ok(Value::Null)
}
+2
View File
@@ -73,6 +73,8 @@ pub fn fit_artboard(app: &mut PhotocraftApp) -> Result<Value, String> {
// overflows an i32 sum (#981).
v.center = [((f64::from(b.x0) + f64::from(b.x1)) / 2.0) as f32, ((f64::from(b.y0) + f64::from(b.y1)) / 2.0) as f32];
v.fit_pending = false;
v.zoom_animating = true;
v.zoom_anchor = None;
Ok(json!({"zoom": v.zoom, "artboard": id.0, "bounds": [b.x0, b.y0, b.x1, b.y1]}))
}
+171 -10
View File
@@ -787,10 +787,11 @@ impl ViewXform {
/// The main canvas's mapping for the active document as last laid out (inside the rulers).
pub fn active(app: &PhotocraftApp) -> Option<Self> {
let v = app.ui.views.get(app.session.active_index()?)?;
let (zoom, center) = if v.zoom_animating { v.display_camera.unwrap_or((v.zoom, v.center)) } else { (v.zoom, v.center) };
Some(Self {
rect: crate::rulers::content_rect(app, app.last_canvas_rect),
zoom: v.zoom / app.canvas_ppp(),
center: v.center,
zoom: zoom / app.canvas_ppp(),
center,
flip: app.ui.view.flip_horizontal,
rotation: v.rotation,
aspect: app.ui.view.display_aspect(),
@@ -878,6 +879,119 @@ pub fn fit_view(view: &mut View, doc: &Document, area: Vec2, ppp: f32, aspect: f
view.fill_pending = false;
}
/// Ease a transient presentation camera over 220 ms without changing the requested camera.
fn animated_view(view: &mut View, xf: ViewXform, ppp: f32, time: f64) -> View {
let target = (view.zoom, view.center);
// Clamping, a canvas resize, or another camera command can make the original anchor
// incompatible with the requested camera. The target must always win.
if let Some((doc, screen)) = view.zoom_anchor {
let offset = xf.unmap_vec((pos2(screen[0], screen[1]) - xf.rect.center()) / (view.zoom / ppp));
if (doc[0] as f32 - offset.x - view.center[0]).abs() > 0.01 || (doc[1] as f32 - offset.y - view.center[1]).abs() > 0.01 {
view.zoom_anchor = None;
}
}
let mut shown = view.clone();
if view.zoom_animating {
if view.zoom_transition.is_none_or(|a| a.target != target) {
view.zoom_transition = Some(crate::state::ZoomTransition { from: view.display_camera.unwrap_or(target), target, started: time });
}
if let Some(a) = view.zoom_transition {
let elapsed = (time - a.started) / 0.22;
let t = if elapsed.is_finite() { elapsed.clamp(0.0, 1.0) as f32 } else { 1.0 };
let ease = t * t * (3.0 - 2.0 * t);
let lerp = |from: f32, to: f32| from + (to - from) * ease;
shown.zoom = lerp(a.from.0, target.0);
shown.center = [lerp(a.from.1[0], target.1[0]), lerp(a.from.1[1], target.1[1])];
if let Some((doc, screen)) = view.zoom_anchor {
let zoom = shown.zoom / ppp;
if zoom.is_finite() && zoom > 0.0 {
let offset = xf.unmap_vec((pos2(screen[0], screen[1]) - xf.rect.center()) / zoom);
shown.center = [doc[0] as f32 - offset.x, doc[1] as f32 - offset.y];
}
}
if t >= 1.0 {
view.zoom_animating = false;
}
}
}
if !view.zoom_animating {
shown.zoom = target.0;
shown.center = target.1;
view.zoom_anchor = None;
view.zoom_transition = None;
}
view.display_camera = Some((shown.zoom, shown.center));
shown
}
#[cfg(test)]
mod zoom_animation_tests {
use super::*;
fn camera(view: &View) -> ViewXform {
ViewXform { rect: Rect::from_min_size(Pos2::ZERO, vec2(1000.0, 700.0)), zoom: view.zoom, center: view.center, flip: false, rotation: 0.0, aspect: 1.0 }
}
fn view() -> View {
View { zoom: 1.0, center: [200.0, 150.0], doc_size: [400, 300], fit_pending: false, ..Default::default() }
}
#[test]
fn zoom_animation_obeys_clamped_targets_and_eases_recentering() {
let mut v = view();
let xf = camera(&v);
animated_view(&mut v, xf, 1.0, 0.0);
let pointer = xf.to_screen(390.0, 150.0);
zoom_about(&mut v, &xf, pointer, 2.0, false, 1.0);
v.zoom_anchor = Some(([390.0, 150.0], [pointer.x, pointer.y]));
v.zoom_animating = true;
crate::scrollbars::clamp_view(&mut v, xf.rect.size(), 1.0);
let xf = camera(&v);
animated_view(&mut v, xf, 1.0, 0.0);
assert!(v.zoom_anchor.is_none());
let done = animated_view(&mut v, xf, 1.0, 0.22);
assert_eq!((done.zoom, done.center), (v.zoom, v.center));
assert!(!v.zoom_animating);
let mut v = view();
let xf = camera(&v);
animated_view(&mut v, xf, 1.0, 0.0);
zoom_about(&mut v, &xf, pointer, 2.0, true, 1.0);
v.zoom_animating = true;
let target = v.center;
let xf = camera(&v);
let start = animated_view(&mut v, xf, 1.0, 0.0);
assert_eq!(start.center, [200.0, 150.0], "recentering must not teleport");
let halfway = animated_view(&mut v, xf, 1.0, 0.11);
assert!(halfway.center[0] > start.center[0] && halfway.center[0] < target[0]);
assert_eq!(animated_view(&mut v, xf, 1.0, 0.22).center, target);
}
#[test]
fn zoom_animation_views_are_independent_and_direct_navigation_snaps() {
let mut a = view();
let mut b = view();
let xf = camera(&a);
animated_view(&mut a, xf, 1.0, 0.0);
animated_view(&mut b, xf, 1.0, 0.0);
a.zoom = 2.0;
a.zoom_animating = true;
animated_view(&mut a, xf, 1.0, 0.0);
b.zoom = 3.0;
b.zoom_animating = true;
animated_view(&mut b, xf, 1.0, 0.11);
assert_eq!(animated_view(&mut a, xf, 1.0, 0.22).zoom, 2.0);
let shown = animated_view(&mut b, xf, 1.0, 0.22);
assert!(shown.zoom > 1.0 && shown.zoom < 3.0);
assert!(b.zoom_animating && !a.zoom_animating);
b.zoom_animating = false;
b.center = [220.0, 170.0];
let shown = animated_view(&mut b, xf, 1.0, 0.23);
assert_eq!((shown.zoom, shown.center), (b.zoom, b.center));
assert!(b.zoom_transition.is_none() && b.zoom_anchor.is_none());
}
}
/// Centre the document and zoom until it fills the canvas. One axis can extend beyond the
/// viewport, matching the Hand tool's Fill Screen action.
pub fn fill_view(view: &mut View, doc: &Document, area: Vec2, ppp: f32, aspect: f32) {
@@ -2470,6 +2584,26 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
}
let full = rect;
let rect = if primary { crate::rulers::content_rect(app, rect) } else { rect };
// Direct navigation starts from the authoritative camera. This also means a click or drag
// never maps through a camera that is still moving under the pointer.
let (pointer_here, hover_here) = ctx.input(|i| {
(
(i.pointer.any_pressed() || i.pointer.any_down()) && i.pointer.press_origin().is_some_and(|p| rect.contains(p)),
i.pointer.hover_pos().is_some_and(|p| rect.contains(p)),
)
});
let direct_input = pointer_here
|| (hover_here
&& crate::wheel_nav::read(
&ctx,
app.session.prefs().general.zoom_with_scroll_wheel,
app.session.prefs().enhanced_controls.zoom_with_trackpad_pinch,
)
.is_some());
if direct_input {
view.zoom_animating = false;
view.zoom_anchor = None;
}
let doc = app.session.documents()[idx].doc.clone();
let size = [doc.size.width, doc.size.height];
if view.doc_size != size {
@@ -2489,12 +2623,23 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
}
// Preferences › Tools › Overscroll off: clamp before anything is drawn (scrollbars.rs).
if !app.session.prefs().tools.overscroll && crate::scrollbars::clamp_view(&mut view, rect.size() / vec2(aspect, 1.0), ppp) {
view.zoom_anchor = None;
ctx.request_repaint();
}
let flip = app.ui.view.flip_horizontal;
// Canvas geometry (ViewXform, ViewParams, painter rects) is in egui points.
let point_zoom = view.zoom / ppp;
let xf = ViewXform { rect, zoom: point_zoom, center: view.center, flip, rotation: view.rotation, aspect };
// Document rendering follows the target; only shader uniforms and overlay geometry ease.
let target_xf = ViewXform { rect, zoom: view.zoom / ppp, center: view.center, flip, rotation: view.rotation, aspect };
let render_zoom = view.zoom;
let render_visible = visible_doc_rect(&target_xf);
let mut display_view = animated_view(&mut view, target_xf, ppp, ctx.input(|i| i.time));
if primary && let Some(stored) = app.ui.views.get_mut(idx) {
stored.zoom_animating = view.zoom_animating;
stored.display_camera = view.display_camera;
}
if view.zoom_animating {
ctx.request_repaint();
}
let xf = ViewXform { zoom: display_view.zoom / ppp, center: display_view.center, ..target_xf };
let pixel_grid = app.ui.view.shows(app.ui.view.show.pixel_grid);
let response = ui.allocate_rect(rect, Sense::click_and_drag());
let stroke_dismissal = primary && crate::shape_stroke_ui::dismiss_from_canvas(app, &response);
@@ -2535,7 +2680,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
if app.gpu.is_some()
&& gpu_ok
&& let Some((k, key, preview_size)) =
ensure_adjust_proxy(app, idx, view.zoom).or_else(|| ensure_filter_preview(app, idx, &ctx)).or_else(|| ensure_proxy_preview(app, idx))
ensure_adjust_proxy(app, idx, render_zoom).or_else(|| ensure_filter_preview(app, idx, &ctx)).or_else(|| ensure_proxy_preview(app, idx))
{
on_gpu = true;
let original_size = [doc.size.width.div_ceil(k), doc.size.height.div_ceil(k)];
@@ -2561,7 +2706,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
offset: [0.0, 0.0],
};
paint_gpu_view(&painter, rect, params, &pattern);
} else if gpu_ok && ensure_gpu(app, idx, visible_doc_rect(&xf)) {
} else if gpu_ok && ensure_gpu(app, idx, render_visible) {
on_gpu = true;
app.perf.gpu = true;
// Shadow, checkerboard, document and pixel grid in one custom shader (gpu_canvas.rs).
@@ -2727,7 +2872,7 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
(img_rect, beyond, layer_edges)
};
let painted = if crop_camera { None } else { Some(paint_canvas(app, ui, &view, xf)) };
let painted = if crop_camera { None } else { Some(paint_canvas(app, ui, &display_view, xf)) };
let img_rect = xf.doc_rect(doc.bounds());
// Under an open dialog the canvas widget is inert, but the image still pans and zooms.
@@ -2759,6 +2904,8 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
}
let rotate_trackpad = app.session.prefs().enhanced_controls.rotate_view_with_trackpad;
if let Some(delta) = crate::rotate_view::trackpad_delta(&ctx, rotate_trackpad) {
view.zoom_animating = false;
view.zoom_anchor = None;
let next = view.rotation + delta;
if next.is_finite() {
view.rotation = crate::rotate_view::wrap_deg(next);
@@ -2871,6 +3018,8 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
if let Some(d) = crate::flick_pan::frame(&ctx, flick_id, hand_pan && response.dragged() && !stroke_dismissal, response.drag_delta(), flick_on) {
let d = xf.unmap_vec(d) / (view.zoom / ppp);
if d.is_finite() {
view.zoom_animating = false;
view.zoom_anchor = None;
view.center[0] -= d.x;
view.center[1] -= d.y;
}
@@ -3121,7 +3270,11 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
Tool::Zoom => {
let nz = crate::zoom_levels::step(view.zoom, if zoom_out(click_mods.alt) { -1 } else { 1 }, view.doc_size);
let center = app.session.prefs().tools.zoom_clicked_point_to_center;
let doc_anchor = xf.to_doc(p);
let screen_anchor = p;
zoom_about(&mut view, &xf, p, nz, center, ppp);
view.zoom_animating = nz != display_view.zoom;
view.zoom_anchor = (view.zoom_animating && !center).then_some((doc_anchor, [screen_anchor.x, screen_anchor.y]));
}
// A click with the (temporary) Hand does nothing, never the tool underneath.
Tool::Hand | Tool::RotateView => {}
@@ -3189,8 +3342,16 @@ pub fn canvas_view(app: &mut PhotocraftApp, ui: &mut egui::Ui, idx: usize, rect:
ctx.request_repaint();
}
}
let xf = if crop_camera { ViewXform { center: view.center, rotation: view.rotation, ..xf } } else { xf };
let (img_rect, beyond, layer_edges) = painted.unwrap_or_else(|| paint_canvas(app, ui, &view, xf));
let xf = if crop_camera {
if view.center != target_xf.center {
display_view.center = view.center;
}
display_view.rotation = view.rotation;
ViewXform { center: display_view.center, rotation: display_view.rotation, ..xf }
} else {
xf
};
let (img_rect, beyond, layer_edges) = painted.unwrap_or_else(|| paint_canvas(app, ui, &display_view, xf));
if primary && !(hand_pan && response.dragged()) {
if app.ui.extras.grid && app.ui.view.extras {
crate::rulers::draw_grid(app, &painter, &xf, &doc);
+26
View File
@@ -480,6 +480,8 @@ fn choose_view(app: &mut PhotocraftApp, ctx: &Context, menu: &CanvasToolMenu, co
let v = app.ui.views.get_mut(i).ok_or("no document view")?;
v.fit_pending = false;
v.fill_pending = true;
v.zoom_animating = true;
v.zoom_anchor = None;
return Ok(());
}
let before = app.ui.views.get(i).map(|v| (v.zoom, v.center));
@@ -495,6 +497,7 @@ fn choose_view(app: &mut PhotocraftApp, ctx: &Context, menu: &CanvasToolMenu, co
// from the centre shrinks (or grows) by the zoom ratio, whatever the rotation or flip.
let ratio = zoom0 / v.zoom;
v.center = if center_on_point || !ratio.is_finite() { d } else { [d[0] - (d[0] - c[0]) * ratio, d[1] - (d[1] - c[1]) * ratio] };
v.zoom_anchor = (!center_on_point).then_some(([d[0] as f64, d[1] as f64], menu.pos));
Ok(())
}
@@ -1124,6 +1127,29 @@ mod tests {
assert!((screen_of(h.state(), doc) - p).length() < 1.0);
}
#[test]
fn view_menu_zoom_keeps_its_anchor_during_the_animation() {
let mut app = zoom_app(400, 300);
app.ui.tool = Tool::Zoom;
let mut h = harness(app);
let zoom = h.state().ui.views[0].zoom;
let doc = [300.0, 100.0];
let p = screen_of(h.state(), doc);
right_click(&mut h, p, Modifiers::NONE);
let ctx = h.ctx.clone();
// Choose without the widget click helper, which runs repaint frames until settled.
choose(h.state_mut(), &ctx, "view.zoomIn");
h.step();
h.input_mut().time = Some(ctx.input(|i| i.time) + 0.11);
h.step();
let displayed = crate::canvas::ViewXform::active(h.state()).unwrap();
assert!(displayed.zoom > zoom && displayed.zoom < h.state().ui.views[0].zoom);
assert!(displayed.to_screen(doc[0], doc[1]).distance(p) < 1.0);
h.input_mut().time = Some(ctx.input(|i| i.time) + 0.3);
h.step();
assert!(!h.state().ui.views[0].zoom_animating);
}
#[test]
fn view_menu_zoom_in_centres_the_clicked_point_with_the_preference() {
let mut app = zoom_app(400, 300);
+2
View File
@@ -151,6 +151,8 @@ pub fn status_bar_pro(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
let control_h = crate::panels::status_bar_heights(&t).1;
if widgets::compact_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", 64.0, control_h).changed() {
app.ui.views[i].zoom = crate::zoom_levels::clamp(pct / 100.0, app.ui.views[i].doc_size);
app.ui.views[i].zoom_animating = false;
app.ui.views[i].zoom_anchor = None;
app.ui.views[i].fit_pending = false;
}
ui.add_space(12.0);
+4
View File
@@ -651,6 +651,10 @@ fn dispatch(app: &mut PhotocraftApp, ctx: &egui::Context, req: &ControlRequest)
crate::panels::request_dock_width(ctx, w as f32);
}
if let Some(i) = app.session.active_index() {
if zoom.is_some() || center.is_some() || rotation.is_some() || fit {
app.ui.views[i].zoom_animating = false;
app.ui.views[i].zoom_anchor = None;
}
if let Some(z) = zoom {
let size = app.session.documents().get(i).map_or([0, 0], |st| [st.doc.size.width, st.doc.size.height]);
app.ui.views[i].zoom = crate::zoom_levels::clamp(z as f32, size);
+12 -1
View File
@@ -1231,7 +1231,18 @@ mod tests {
fn space_on_the_canvas_moves_the_frame_not_the_view() {
use egui::{Event, Key, PointerButton, pos2};
let mut a = app(SampleType::U8);
let view = crate::state::View { zoom: 2.0, center: [100.0, 50.0], fit_pending: false, fill_pending: false, doc_size: [200, 100], rotation: 0.0 };
let view = crate::state::View {
zoom: 2.0,
center: [100.0, 50.0],
fit_pending: false,
fill_pending: false,
doc_size: [200, 100],
rotation: 0.0,
zoom_animating: false,
zoom_anchor: None,
display_camera: None,
zoom_transition: None,
};
a.ui.views = vec![view.clone()];
let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(600.0, 400.0)).build_ui_state(
|ui, app: &mut PhotocraftApp| {
+12 -1
View File
@@ -38,7 +38,18 @@ fn app() -> (PhotocraftApp, LayerId, LayerId) {
app.ui.view.extras = true;
app.ui.view.show.layer_edges = true;
// 4 screen px per document px, the document centred.
app.ui.views = vec![View { zoom: 4.0, center: [32.0, 32.0], fit_pending: false, fill_pending: false, doc_size: [64, 64], rotation: 0.0 }];
app.ui.views = vec![View {
zoom: 4.0,
center: [32.0, 32.0],
fit_pending: false,
fill_pending: false,
doc_size: [64, 64],
rotation: 0.0,
zoom_animating: false,
zoom_anchor: None,
display_camera: None,
zoom_transition: None,
}];
(app, ids[0], ids[1])
}
+24
View File
@@ -1332,11 +1332,17 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
&& let Some(i) = app.session.active_index()
{
app.ui.views[i].fit_pending = true;
app.ui.views[i].zoom_animating = true;
app.ui.views[i].zoom_anchor = None;
}
if widgets::secondary_button(ui, "100%", 0.0).clicked()
&& let Some(i) = app.session.active_index()
{
app.ui.views[i].zoom = 1.0;
app.ui.views[i].zoom_animating = true;
app.ui.views[i].zoom_anchor = None;
app.ui.views[i].fit_pending = false;
app.ui.views[i].fill_pending = false;
}
}
Tool::RotateView => {
@@ -1362,6 +1368,8 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
&& let Some(i) = app.session.active_index()
{
app.ui.views[i].zoom = 1.0;
app.ui.views[i].zoom_animating = true;
app.ui.views[i].zoom_anchor = None;
app.ui.views[i].fit_pending = false;
app.ui.views[i].fill_pending = false;
}
@@ -1369,12 +1377,16 @@ pub fn options_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
&& let Some(i) = app.session.active_index()
{
app.ui.views[i].fit_pending = true;
app.ui.views[i].zoom_animating = true;
app.ui.views[i].zoom_anchor = None;
app.ui.views[i].fill_pending = false;
}
if widgets::secondary_button(ui, tl!("Fill Screen"), 0.0).clicked()
&& let Some(i) = app.session.active_index()
{
app.ui.views[i].fill_pending = true;
app.ui.views[i].zoom_animating = true;
app.ui.views[i].zoom_anchor = None;
app.ui.views[i].fit_pending = false;
}
}
@@ -1531,6 +1543,8 @@ pub fn status_bar(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
let mut pct = app.ui.views[i].zoom * 100.0;
if widgets::compact_value_field(ui, &mut pct, crate::zoom_levels::percent_range(&app.ui.views[i]), "%", 78.0, control_h).changed() {
app.ui.views[i].zoom = crate::zoom_levels::clamp(pct / 100.0, app.ui.views[i].doc_size);
app.ui.views[i].zoom_animating = false;
app.ui.views[i].zoom_anchor = None;
app.ui.views[i].fit_pending = false;
}
widgets::vline(ui, 16.0);
@@ -1808,6 +1822,8 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
{
let d = (pp - rect.min) / s;
app.ui.views[idx].center = [d.x.clamp(0.0, size.width as f32), d.y.clamp(0.0, size.height as f32)];
app.ui.views[idx].zoom_animating = false;
app.ui.views[idx].zoom_anchor = None;
app.ui.views[idx].fit_pending = false;
}
// The Navigator has its own zoom target: an unmodified wheel over the preview
@@ -1822,6 +1838,8 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
let next = crate::zoom_levels::clamp(view.zoom * factor, view.doc_size);
if next != view.zoom {
view.zoom = next;
view.zoom_animating = false;
view.zoom_anchor = None;
view.fit_pending = false;
}
}
@@ -1843,11 +1861,15 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
for (lbl, z) in [("200%", 2.0), ("100%", 1.0)] {
if widgets::pill_tab(ui, lbl, (v.zoom - z).abs() < 1e-3).clicked() {
app.ui.views[idx].zoom = z;
app.ui.views[idx].zoom_animating = true;
app.ui.views[idx].zoom_anchor = None;
app.ui.views[idx].fit_pending = false;
}
}
if widgets::pill_tab(ui, tl!("Fit"), false).clicked() {
app.ui.views[idx].fit_pending = true;
app.ui.views[idx].zoom_animating = true;
app.ui.views[idx].zoom_anchor = None;
}
});
});
@@ -1856,6 +1878,8 @@ fn navigator(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
let mut lz = v.zoom.log2();
if lz.is_finite() && widgets::slider(ui, &mut lz, lo..=hi, None).changed() {
app.ui.views[idx].zoom = crate::zoom_levels::clamp(2f32.powf(lz), v.doc_size);
app.ui.views[idx].zoom_animating = false;
app.ui.views[idx].zoom_anchor = None;
app.ui.views[idx].fit_pending = false;
}
});
+12 -1
View File
@@ -1171,7 +1171,18 @@ mod tests {
fn preset_drops_map_through_the_ruler_inset() {
let (mut app, _) = app();
app.last_canvas_rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));
app.ui.views[0] = crate::state::View { zoom: 2.0, center: [32.0, 24.0], fit_pending: false, fill_pending: false, doc_size: [64, 48], rotation: 0.0 };
app.ui.views[0] = crate::state::View {
zoom: 2.0,
center: [32.0, 24.0],
fit_pending: false,
fill_pending: false,
doc_size: [64, 48],
rotation: 0.0,
zoom_animating: false,
zoom_anchor: None,
display_camera: None,
zoom_transition: None,
};
let p = egui::pos2(400.0, 300.0);
let off = crate::canvas::doc_point_at(&app, p).unwrap();
assert_eq!(off, [32.0, 24.0], "without rulers the widget rect is the whole mapping");
+24 -2
View File
@@ -289,7 +289,18 @@ mod tests {
assert_eq!(clamp_axis(-400.0, 1000.0, 500.0, 0.2), -250.0, "the image's right edge on the view's");
assert_eq!(clamp_axis(1400.0, 1000.0, 500.0, 0.2), 1250.0, "its left edge on the view's");
assert_eq!(clamp_axis(500.0, 1000.0, 1000.0, 1.0), 500.0, "exactly the view's size: centred");
let mut v = View { zoom: 1.0, center: [-500.0, 20.0], fit_pending: false, fill_pending: false, doc_size: [1000, 800], rotation: 0.0 };
let mut v = View {
zoom: 1.0,
center: [-500.0, 20.0],
fit_pending: false,
fill_pending: false,
doc_size: [1000, 800],
rotation: 0.0,
zoom_animating: false,
zoom_anchor: None,
display_camera: None,
zoom_transition: None,
};
assert!(clamp_view(&mut v, vec2(500.0, 400.0), 1.0));
assert_eq!(v.center, [250.0, 200.0]);
assert!(!clamp_view(&mut v, vec2(500.0, 400.0), 1.0), "stable: no repaint loop");
@@ -308,7 +319,18 @@ mod tests {
let (at, len) = s.thumb((0.0, 1000.0), 0.0);
assert!(at.is_finite() && len.is_finite());
assert_eq!(s.doc_per_point((0.0, 1000.0), 0.0), 0.0);
let mut v = View { zoom: 1.0, center: [0.0, 0.0], fit_pending: false, fill_pending: false, doc_size: [0, 0], rotation: 0.0 };
let mut v = View {
zoom: 1.0,
center: [0.0, 0.0],
fit_pending: false,
fill_pending: false,
doc_size: [0, 0],
rotation: 0.0,
zoom_animating: false,
zoom_anchor: None,
display_camera: None,
zoom_transition: None,
};
assert!(!clamp_view(&mut v, vec2(500.0, 400.0), 1.0));
}
+30 -1
View File
@@ -479,11 +479,40 @@ pub struct View {
/// Canvas camera rotation in degrees, wrapped to (−180, 180]. Turns the view, not the pixels.
#[serde(default)]
pub rotation: f32,
/// Transient presentation state for a discrete zoom command; the target camera above remains
/// authoritative and this flag is never persisted.
#[serde(skip)]
pub(crate) zoom_animating: bool,
/// Optional document/screen anchor for a pointer-centred Zoom-tool transition.
#[serde(skip)]
pub(crate) zoom_anchor: Option<([f64; 2], [f32; 2])>,
#[serde(skip)]
pub(crate) display_camera: Option<(f32, [f32; 2])>,
#[serde(skip)]
pub(crate) zoom_transition: Option<ZoomTransition>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct ZoomTransition {
pub from: (f32, [f32; 2]),
pub target: (f32, [f32; 2]),
pub started: f64,
}
impl Default for View {
fn default() -> Self {
Self { zoom: 1.0, center: [0.0, 0.0], fit_pending: true, fill_pending: false, doc_size: [0, 0], rotation: 0.0 }
Self {
zoom: 1.0,
center: [0.0, 0.0],
fit_pending: true,
fill_pending: false,
doc_size: [0, 0],
rotation: 0.0,
zoom_animating: false,
zoom_anchor: None,
display_camera: None,
zoom_transition: None,
}
}
}
+10
View File
@@ -607,6 +607,8 @@ fn run(app: &mut PhotocraftApp, ctx: &egui::Context, id: &str, p: &Value) -> Res
let screen = app.session.prefs().units_and_rulers.screen_resolution.max(1.0) as f32;
let z = if id == "view.twoHundredPercent" { 2.0 } else { screen / dpi };
app.ui.views[i].zoom = crate::zoom_levels::clamp(z, size);
app.ui.views[i].zoom_animating = true;
app.ui.views[i].zoom_anchor = None;
Ok(json!({"zoom": app.ui.views[i].zoom}))
}
"view.fitLayersOnScreen" => fit_layers(app),
@@ -638,12 +640,18 @@ fn fit_layers(app: &mut PhotocraftApp) -> Result<Value, String> {
v.zoom = crate::zoom_levels::clamp(points * ppp, size);
v.center = [(b.x0 + b.x1) as f32 / 2.0, (b.y0 + b.y1) as f32 / 2.0];
v.fit_pending = false;
v.zoom_animating = true;
v.zoom_anchor = None;
Ok(json!({"zoom": v.zoom, "bounds": [b.x0, b.y0, b.x1, b.y1]}))
}
pub(crate) fn float_window(app: &mut PhotocraftApp, doc: usize, offset: usize) -> u64 {
let wid = app.ui.alloc_id();
let mut view = app.ui.views.get(doc).cloned().unwrap_or_default();
view.zoom_animating = false;
view.zoom_anchor = None;
view.zoom_transition = None;
view.display_camera = None;
view.fit_pending = offset > 0 || view.fit_pending;
app.ui.windows.push(crate::state::DocWindow { id: wid, document: doc, view, open: true });
wid
@@ -679,6 +687,8 @@ fn arrange(app: &mut PhotocraftApp, k: &str) -> Result<Value, String> {
let apply = |v: &mut crate::state::View| {
if zoom {
v.zoom = src.zoom;
v.zoom_animating = true;
v.zoom_anchor = None;
}
if loc {
v.center = src.center;
+150
View File
@@ -42,6 +42,8 @@ pub fn scrub_zoom(zoom0: f32, dx: f32, size: [u32; 2]) -> f32 {
/// Set `view` to `zoom` (device pixels per document pixel) with document point `doc` shown at
/// screen point `screen` (egui points) on a display with `ppp` physical pixels per point.
pub fn anchor_view(view: &mut View, xf: &ViewXform, screen: Pos2, doc: [f64; 2], zoom: f32, ppp: f32) {
view.zoom_animating = false;
view.zoom_anchor = None;
view.zoom = zoom;
let ppp = if ppp.is_finite() && ppp > 0.0 { ppp } else { 1.0 };
let d = xf.unmap_vec((screen - xf.rect.center()) / (zoom / ppp));
@@ -194,6 +196,154 @@ mod tests {
assert_eq!(h.state().current_zoom(), crate::zoom_levels::step(zc, 1, h.state().ui.views[0].doc_size));
}
#[test]
fn discrete_zoom_animates_and_keeps_its_document_anchor_fixed() {
let mut h = harness(true, 1.0);
let r = h.state().last_canvas_rect;
let pointer = r.center() + vec2(90.0, -45.0);
let anchor_doc = view_xf(&h).to_doc(pointer);
let anchor_screen = if h.state().session.prefs().tools.zoom_clicked_point_to_center { r.center() } else { pointer };
let start = h.state().current_zoom();
h.event(Event::PointerMoved(pointer));
h.step();
press(&mut h, pointer, true);
press(&mut h, pointer, false);
let target = crate::zoom_levels::step(start, 1, h.state().ui.views[0].doc_size);
assert_eq!(h.state().current_zoom(), target, "the model keeps the requested zoom as its target");
assert!(h.state().ui.views[0].zoom_animating);
let mut time = h.ctx.input(|i| i.time) + 0.05;
for _ in 0..5 {
time += 0.01;
h.input_mut().time = Some(time);
h.step();
}
let displayed_xf = view_xf(&h);
let displayed = displayed_xf.to_screen(anchor_doc[0] as f32, anchor_doc[1] as f32);
assert!(displayed.distance(anchor_screen) < 0.5, "anchor moved to {displayed:?}");
let intermediate = displayed_xf.zoom;
assert!(intermediate > start && intermediate < target, "expected an intermediate zoom, got {intermediate}");
for _ in 0..30 {
time += 0.01;
h.input_mut().time = Some(time);
h.step();
}
assert!(!h.state().ui.views[0].zoom_animating);
assert_eq!(view_xf(&h).zoom, target);
assert_eq!(h.state().current_zoom(), target);
}
#[test]
fn gpu_zoom_animation_reuses_the_document_composite() {
let Ok(rs) = std::panic::catch_unwind(|| egui_kittest::wgpu::create_render_state(crate::gpu_canvas::wgpu_setup(), Default::default())) else {
eprintln!("skipping: no GPU adapter");
return;
};
let renderer = egui_kittest::wgpu::WgpuTestRenderer::from_render_state(rs);
let mut h = Harness::builder().with_size(vec2(1000.0, 700.0)).with_pixels_per_point(1.0).renderer(renderer).build_eframe(|cc| {
PhotocraftApp::setup_context(&cc.egui_ctx, crate::theme::ThemeKind::ALL[0]);
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
app.set_wgpu(cc.wgpu_render_state.clone().unwrap());
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("edit.fill", json!({"color": "#2060c0"})).unwrap();
app
});
h.run_steps(4);
h.state_mut().run("view.actualPixels", json!({})).unwrap();
h.step();
let time = h.ctx.input(|i| i.time) + 0.3;
h.input_mut().time = Some(time);
h.step();
let id = h.state().session.documents()[0].doc.id;
assert!(h.state().canvases[&(id, crate::canvas::GPU_OUTPUT)].on_gpu);
let directory = std::env::var_os("CRAFT_UI_ZOOM_FIXTURES").map(std::path::PathBuf::from);
if let Some(directory) = &directory {
std::fs::create_dir_all(directory).unwrap();
}
h.state_mut().run("view.zoomIn", json!({})).unwrap();
let target = h.state().current_zoom();
for (name, elapsed) in [("start", 0.0), ("midpoint", 0.11), ("finished", 0.23)] {
h.state_mut().perf.last_refresh = "";
h.input_mut().time = Some(time + elapsed);
h.step();
assert!(h.state().perf.gpu, "{name}: keep the GPU canvas");
assert_eq!(h.state().perf.last_refresh, "", "{name}: reuse the composite");
assert!(h.state().canvases.values().all(|cache| cache.texture.is_none()), "{name}: no CPU texture fallback");
let xf = view_xf(&h);
if name == "midpoint" {
assert!(xf.zoom > 1.0 && xf.zoom < target);
}
let image = h.render().unwrap();
let center = xf.to_screen(200.0, 150.0);
let pixel = image.get_pixel(center.x as u32, center.y as u32);
assert!(pixel[2] > pixel[0] * 2, "{name}: document remains visible: {pixel:?}");
if let Some(directory) = &directory {
image.save(directory.join(format!("photocraft-zoom-{name}.png"))).unwrap();
}
}
assert!(!h.state().ui.views[0].zoom_animating);
assert_eq!(view_xf(&h).zoom, target);
}
#[test]
fn view_commands_retarget_a_zoom_click_without_retaining_its_anchor() {
for command in ["view.zoomIn", "view.actualPixels", "view.fitOnScreen"] {
let mut h = harness(true, 1.0);
let pointer = h.state().last_canvas_rect.center() + vec2(90.0, -45.0);
h.event(Event::PointerMoved(pointer));
h.step();
press(&mut h, pointer, true);
press(&mut h, pointer, false);
assert!(h.state().ui.views[0].zoom_anchor.is_some());
h.step();
h.state_mut().run(command, json!({})).unwrap();
assert!(h.state().ui.views[0].zoom_anchor.is_none(), "{command}");
h.step();
let time = h.ctx.input(|i| i.time) + 0.3;
h.input_mut().time = Some(time);
h.step();
let target = &h.state().ui.views[0];
assert!(!target.zoom_animating, "{command}");
assert_eq!(view_xf(&h).zoom, target.zoom);
assert_eq!(view_xf(&h).center, target.center);
}
}
#[test]
fn wheel_pinch_pan_and_scrubby_zoom_interrupt_a_transition() {
for gesture in 0..5 {
let mut h = harness(true, 1.0);
let pointer = h.state().last_canvas_rect.center();
h.event(Event::PointerMoved(pointer));
h.step();
h.state_mut().run("view.zoomIn", json!({})).unwrap();
h.step();
assert!(h.state().ui.views[0].zoom_animating);
match gesture {
0 => h.event(Event::Zoom(1.25)),
1 | 2 => h.event(Event::MouseWheel {
unit: egui::MouseWheelUnit::Line,
delta: vec2(0.0, 1.0),
phase: egui::TouchPhase::Move,
modifiers: egui::Modifiers { alt: gesture == 1, ..Default::default() },
}),
_ => {
h.state_mut().ui.tool = if gesture == 3 { crate::state::Tool::Hand } else { crate::state::Tool::Zoom };
press(&mut h, pointer, true);
h.event(Event::PointerMoved(pointer + vec2(120.0, 0.0)));
}
}
h.step();
assert!(!h.state().ui.views[0].zoom_animating, "gesture {gesture}");
h.step();
let target = &h.state().ui.views[0];
assert_eq!(view_xf(&h).zoom, target.zoom, "gesture {gesture}");
assert_eq!(view_xf(&h).center, target.center, "gesture {gesture}");
}
}
#[test]
fn zoom_drags_keep_the_press_point_in_rotated_and_flipped_views() {
for (scrubby, out, rotation, flip, ppp) in [
+3 -2
View File
@@ -1,6 +1,6 @@
# UI parity: tools, handles, modifiers and feel
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Hand-tool flick panning) · **Target:** Adobe Photoshop 2026
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Hand-tool flick panning and animated zoom) · **Target:** Adobe Photoshop 2026
How PhotoCraft's direct manipulation compares with Photoshop 2026 (27.11.0): the toolbox, the
handles and modifier keys of each gesture, nudging, snapping, numeric precision, navigation,
@@ -163,7 +163,7 @@ Triangle and Curvature Pen (minus legacy Rounded Rectangle and Targeted Adjustme
| Hold any tool letter for a temporary tool | missing | #2672 |
| Scrubby zoom | done | `zoom_tool.rs` |
| Flick panning | done | `flick_pan.rs` (Preferences › Tools › Enable Flick Panning) |
| Animated zoom | missing | unread pref; #566 |
| Animated zoom | done | `canvas.rs`, `zoom_tool.rs`; #566; discrete Zoom clicks and View zoom controls ease over 220 ms by default, with anchored transitions and immediate direct navigation; the existing preference remains hidden |
| Double-click Zoom tool = 100%, double-click Hand = fit | partial | Zoom missing (#2508) |
| ⌥-wheel zoom in gentle steps | missing | UI-217-18 |
| Wheel, smooth scrolling and pinch as in Photoshop | partial | #2485, #2463, #1989 |
@@ -210,3 +210,4 @@ Paragraph; the rest open as in-app floating windows.
| 2026-10-10 | major | First version, from a source audit against Photoshop 2026 27.11.0's shortcuts file and the open issues |
| 2026-10-10 | minor | Fixed Crop live resize snapping feedback and outdated-camera rendering, applied ratios immediately to centred inscribed previews, and removed two-point options-bar overflow; added pointer, rendering, dropdown/Enter, Swap/X and scrolling regressions |
| 2026-10-11 | minor | Flick panning done: releasing a moving Hand drag (tool, Space or middle button) glides and decays, gated by Enable Flick Panning |
| 2026-10-11 | minor | Animated zoom done: 220 ms transitions per view for discrete Zoom clicks and View controls; GPU composites are reused, coordinates follow the displayed camera, and direct navigation interrupts immediately |