mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 09:26:43 +00:00
Use whole-edge transform handles and consistent rotate cursors
This commit is contained in:
1 parent
37a01ca874
commit
d630efdce2
4 files changed
+304
-78
No files matched your search
@@ -58,50 +58,40 @@ pub(super) fn transform_controls_rect(app: &PhotocraftApp, xf: &ViewXform) -> Op
|
||||
Some(Rect::from_two_pos(xf.to_screen(b.x0 as f32, b.y0 as f32), xf.to_screen(b.x1 as f32, b.y1 as f32)))
|
||||
}
|
||||
|
||||
/// The Move tool shows transform handles even before a Free Transform session exists.
|
||||
/// Use the same hit areas for pointer-down and hover, so a control never behaves like
|
||||
/// resize/rotate while showing the ordinary four-arrow Move cursor (#2871).
|
||||
fn controls_quad(r: Rect) -> [[f64; 2]; 4] {
|
||||
[r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()].map(|p| [f64::from(p.x), f64::from(p.y)])
|
||||
}
|
||||
|
||||
fn controls_zone(r: Rect, p: Pos2) -> crate::transform_tool::Hit {
|
||||
crate::state::TransformSession::box_hit(&controls_quad(r), [f64::from(p.x), f64::from(p.y)], crate::transform_tool::HANDLE_PX)
|
||||
}
|
||||
|
||||
/// Share the open session's screen-sized zones before the first interaction (#11097).
|
||||
pub(super) fn transform_controls_cursor(r: Rect, p: Pos2) -> Option<egui::CursorIcon> {
|
||||
let handles = [r.left_top(), r.center_top(), r.right_top(), r.right_center(), r.right_bottom(), r.center_bottom(), r.left_bottom(), r.left_center()];
|
||||
let grab = crate::transform_tool::HANDLE_PX as f32;
|
||||
for (i, handle) in handles.into_iter().enumerate() {
|
||||
if handle.distance(p) <= grab {
|
||||
return Some(match i {
|
||||
0 | 4 => egui::CursorIcon::ResizeNwSe,
|
||||
2 | 6 => egui::CursorIcon::ResizeNeSw,
|
||||
1 | 5 => egui::CursorIcon::ResizeVertical,
|
||||
_ => egui::CursorIcon::ResizeHorizontal,
|
||||
});
|
||||
}
|
||||
}
|
||||
// The rotation band: the pointer gives way to the curved rotate arrow (`transform_controls_turn`).
|
||||
in_rotation_band(r, p).then_some(egui::CursorIcon::None)
|
||||
use crate::transform_tool::Hit;
|
||||
Some(match controls_zone(r, p) {
|
||||
Hit::Corner(0 | 2) => egui::CursorIcon::ResizeNwSe,
|
||||
Hit::Corner(_) => egui::CursorIcon::ResizeNeSw,
|
||||
Hit::Edge(0 | 2) => egui::CursorIcon::ResizeVertical,
|
||||
Hit::Edge(_) => egui::CursorIcon::ResizeHorizontal,
|
||||
Hit::Outside => egui::CursorIcon::None,
|
||||
Hit::Inside | Hit::Pivot => egui::CursorIcon::Default,
|
||||
})
|
||||
}
|
||||
|
||||
fn in_rotation_band(r: Rect, p: Pos2) -> bool {
|
||||
r.expand(18.0).contains(p) && !r.expand(5.0).contains(p)
|
||||
}
|
||||
|
||||
/// In the rotation band just outside the Move tool's transform controls, the screen direction the
|
||||
/// curved rotate arrow bends round: into the box along the nearest corner's bisector, as Free
|
||||
/// Transform draws it (#4658). Before, the band showed a plain alias pointer, so nothing said a
|
||||
/// drag there rotates.
|
||||
/// At any distance outside the controls, the same edge/corner direction as Free Transform.
|
||||
pub(super) fn transform_controls_turn(r: Rect, p: Pos2) -> Option<Vec2> {
|
||||
if !in_rotation_band(r, p)
|
||||
|| [r.left_top(), r.center_top(), r.right_top(), r.right_center(), r.right_bottom(), r.center_bottom(), r.left_bottom(), r.left_center()]
|
||||
.into_iter()
|
||||
.any(|h| h.distance(p) <= crate::transform_tool::HANDLE_PX as f32)
|
||||
{
|
||||
if controls_zone(r, p) != crate::transform_tool::Hit::Outside {
|
||||
return None;
|
||||
}
|
||||
let corner = pos2(if p.x < r.center().x { r.left() } else { r.right() }, if p.y < r.center().y { r.top() } else { r.bottom() });
|
||||
Some(vec2((r.center().x - corner.x).signum(), (r.center().y - corner.y).signum()).normalized() * 16.0)
|
||||
let k = crate::state::TransformSession::box_turn_direction(&controls_quad(r), [f64::from(p.x), f64::from(p.y)])?;
|
||||
Some(vec2(k[0] as f32, k[1] as f32) * 16.0)
|
||||
}
|
||||
|
||||
/// A visible handle starts scaling; the narrow band just outside the box starts rotation.
|
||||
/// A visible handle starts scaling; any point outside the box starts rotation.
|
||||
/// The interior stays the normal Move-tool drag target.
|
||||
pub(super) fn transform_controls_hit(r: Rect, p: Pos2) -> bool {
|
||||
transform_controls_cursor(r, p).is_some()
|
||||
!matches!(controls_zone(r, p), crate::transform_tool::Hit::Inside | crate::transform_tool::Hit::Pivot)
|
||||
}
|
||||
|
||||
/// Enter the existing Free Transform session when a Move-tool transform control is pressed: on
|
||||
@@ -138,3 +128,7 @@ pub(super) fn draw_transform_controls(app: &mut PhotocraftApp, painter: &egui::P
|
||||
painter.rect_stroke(h, 0.0, Stroke::new(1.0, accent), egui::StrokeKind::Inside);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../transform_hit_zone_tests.rs"]
|
||||
mod hit_zone_tests;
|
||||
@@ -1,11 +1,11 @@
|
||||
use super::begin::warps_type;
|
||||
use super::drag_modes::{HandleIndicator, handle_indicator};
|
||||
use super::options_bar::{quad_scale, readout};
|
||||
use super::pointer::{Hit, handle_at, rotate_dir, rotation_degrees};
|
||||
use super::pointer::{Hit, handle_at, rotation_degrees};
|
||||
use super::warp::{on_section_edge, quick_split_kind, single_patch};
|
||||
use super::{
|
||||
BezierMesh, Color32, DocId, HANDLE_PX, Homography, LayerId, PhotocraftApp, Pos2, SplitTool, Stroke, TransformPreview, TransformSession, ViewXform, Warp,
|
||||
WarpDrag, WarpStyle, corners, pos2, vec2,
|
||||
BezierMesh, Color32, DocId, Homography, LayerId, PhotocraftApp, Pos2, SplitTool, Stroke, TransformPreview, TransformSession, ViewXform, Warp, WarpDrag,
|
||||
WarpStyle, corners, pos2, vec2,
|
||||
};
|
||||
|
||||
/// The distort or skew pointer at screen point `at`, where [`super::cursor`] hid the system
|
||||
@@ -212,14 +212,6 @@ pub fn draw_overlay(app: &PhotocraftApp, painter: &egui::Painter, xf: &ViewXform
|
||||
painter.line_segment([c - vec2(8.0, 0.0), c + vec2(8.0, 0.0)], Stroke::new(1.0, Color32::WHITE));
|
||||
painter.line_segment([c - vec2(0.0, 8.0), c + vec2(0.0, 8.0)], Stroke::new(1.0, Color32::WHITE));
|
||||
if let Some(at) = painter.ctx().pointer_hover_pos().filter(|p| xf.rect.contains(*p)) {
|
||||
let p = xf.to_doc(at);
|
||||
let tol = HANDLE_PX / f64::from(xf.zoom.max(0.01));
|
||||
if let Some(k) = rotate_dir(t, Some(pv), p, tol) {
|
||||
// Through the view, so the arc bends round the corner as it shows under a turned or
|
||||
// flipped view.
|
||||
let toward = xf.to_screen((p[0] + k[0] * 16.0) as f32, (p[1] + k[1] * 16.0) as f32) - at;
|
||||
crate::crop_ui::draw_turn_cursor(painter.ctx(), at, toward);
|
||||
}
|
||||
// Preferences › Tools › Show Transformation Values off hides it, as in Photoshop (#204).
|
||||
if let Some(r) = live_readout(app).filter(|_| app.session.prefs().tools.show_transformation_values) {
|
||||
draw_live_readout(app, painter.ctx(), at, r);
|
||||
|
||||
@@ -17,21 +17,91 @@ pub(crate) enum Hit {
|
||||
Outside,
|
||||
}
|
||||
|
||||
/// The nearest handle within `tol` (on a small box their grab areas overlap), else inside or
|
||||
/// outside the box.
|
||||
/// Screen-sized corner and outward edge bands, shared with Move's unopened controls.
|
||||
impl TransformSession {
|
||||
pub(crate) fn box_hit(quad: &[[f64; 2]; 4], p: [f64; 2], tol: f64) -> Hit {
|
||||
// `tol` is the existing 12 pt handle tolerance, divided by the view zoom.
|
||||
let corner_radius = tol * (8.0 / HANDLE_PX);
|
||||
let edge_width = tol * (11.0 / HANDLE_PX);
|
||||
let distance = |q: [f64; 2]| (p[0] - q[0]).hypot(p[1] - q[1]);
|
||||
if let Some((i, _)) = quad.iter().enumerate().map(|(i, &q)| (i, distance(q))).filter(|(_, d)| *d <= corner_radius).min_by(|a, b| a.1.total_cmp(&b.1)) {
|
||||
return Hit::Corner(i);
|
||||
}
|
||||
let interior = inside(quad, p);
|
||||
let edge = (0..4)
|
||||
.filter_map(|i| {
|
||||
let (_, q) = edge_projection(quad, i, p)?;
|
||||
let d = distance(q);
|
||||
// One pixel inside is interior, not a scale handle. The line itself is a handle.
|
||||
(d <= edge_width && (!interior || d <= tol.abs() * 1e-9)).then_some((i, d))
|
||||
})
|
||||
.min_by(|a, b| a.1.total_cmp(&b.1));
|
||||
match edge {
|
||||
Some((i, _)) => Hit::Edge(i),
|
||||
None if interior => Hit::Inside,
|
||||
None => Hit::Outside,
|
||||
}
|
||||
}
|
||||
|
||||
/// Into the nearest edge or corner: eight orientations for an upright rectangle, following
|
||||
/// the actual quad when it is rotated, flipped or distorted.
|
||||
pub(crate) fn box_turn_direction(quad: &[[f64; 2]; 4], p: [f64; 2]) -> Option<[f64; 2]> {
|
||||
if p.iter().chain(quad.iter().flatten()).any(|v| !v.is_finite()) {
|
||||
return None;
|
||||
}
|
||||
let (i, u, _) = (0..4)
|
||||
.filter_map(|i| {
|
||||
let (u, q) = edge_projection(quad, i, p)?;
|
||||
Some((i, u, (p[0] - q[0]).hypot(p[1] - q[1])))
|
||||
})
|
||||
.min_by(|a, b| a.2.total_cmp(&b.2))?;
|
||||
let unit = |v: [f64; 2]| {
|
||||
let len = v[0].hypot(v[1]);
|
||||
(len.is_finite() && len > 1e-9).then(|| [v[0] / len, v[1] / len])
|
||||
};
|
||||
let toward = if u <= 0.0 || u >= 1.0 {
|
||||
let i = if u >= 1.0 { (i + 1) % 4 } else { i };
|
||||
let direction = |j: usize| unit([quad[j][0] - quad[i][0], quad[j][1] - quad[i][1]]);
|
||||
let (a, b) = (direction((i + 1) % 4)?, direction((i + 3) % 4)?);
|
||||
[a[0] + b[0], a[1] + b[1]]
|
||||
} else {
|
||||
let (a, b) = (quad[i], quad[(i + 1) % 4]);
|
||||
let normal = [a[1] - b[1], b[0] - a[0]];
|
||||
let center = quad.iter().fold([0.0; 2], |c, q| [c[0] + q[0] / 4.0, c[1] + q[1] / 4.0]);
|
||||
let sign = (normal[0] * (center[0] - a[0]) + normal[1] * (center[1] - a[1])).signum();
|
||||
normal.map(|v| v * sign)
|
||||
};
|
||||
unit(toward)
|
||||
}
|
||||
}
|
||||
|
||||
/// The nearest point on an edge segment and its clamped parameter. Degenerate edges have no
|
||||
/// band or normal; the other edges and corner handles remain usable.
|
||||
fn edge_projection(quad: &[[f64; 2]; 4], i: usize, p: [f64; 2]) -> Option<(f64, [f64; 2])> {
|
||||
let (a, b) = (quad[i], quad[(i + 1) % 4]);
|
||||
let d = [b[0] - a[0], b[1] - a[1]];
|
||||
let len2 = d[0] * d[0] + d[1] * d[1];
|
||||
if !len2.is_finite() || len2 <= 1e-18 {
|
||||
return None;
|
||||
}
|
||||
let u = (((p[0] - a[0]) * d[0] + (p[1] - a[1]) * d[1]) / len2).clamp(0.0, 1.0);
|
||||
Some((u, [a[0] + u * d[0], a[1] + u * d[1]]))
|
||||
}
|
||||
|
||||
/// The shared box zones, retaining the nearest pivot's existing grab priority on small boxes.
|
||||
pub(crate) fn hit(t: &TransformSession, p: [f64; 2], tol: f64) -> Hit {
|
||||
let d = |a: [f64; 2]| ((a[0] - p[0]).powi(2) + (a[1] - p[1]).powi(2)).sqrt();
|
||||
let mid = |i: usize| {
|
||||
let (a, b) = (t.quad[i], t.quad[(i + 1) % 4]);
|
||||
[(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0]
|
||||
};
|
||||
let handles = (0..4).map(|i| (t.quad[i], Hit::Corner(i))).chain((0..4).map(|i| (mid(i), Hit::Edge(i)))).chain([(t.pivot, Hit::Pivot)]);
|
||||
let nearest = handles.map(|(q, h)| (d(q), h)).filter(|(dist, _)| *dist < tol).min_by(|a, b| a.0.total_cmp(&b.0));
|
||||
match nearest {
|
||||
Some((_, h)) => h,
|
||||
None if inside(&t.quad, p) => Hit::Inside,
|
||||
None => Hit::Outside,
|
||||
}
|
||||
let h = TransformSession::box_hit(&t.quad, p, tol);
|
||||
let handle_distance = match h {
|
||||
Hit::Corner(i) => d(t.quad[i]),
|
||||
Hit::Edge(i) => d(mid(i)),
|
||||
_ => f64::INFINITY,
|
||||
};
|
||||
if d(t.pivot) < tol && d(t.pivot) < handle_distance { Hit::Pivot } else { h }
|
||||
}
|
||||
|
||||
fn inside(q: &[[f64; 2]; 4], p: [f64; 2]) -> bool {
|
||||
@@ -208,16 +278,12 @@ pub(super) fn carry_pivot(quad0: [[f64; 2]; 4], quad: [[f64; 2]; 4], pivot0: [f6
|
||||
if x.is_finite() && y.is_finite() { [x, y] } else { pivot0 }
|
||||
}
|
||||
|
||||
/// True just outside a corner: rotate handle feedback lives here, not over the entire
|
||||
/// empty canvas. The actual rotation gesture continues to work farther away.
|
||||
/// Rotate feedback covers every outside point where a rotation gesture can start.
|
||||
pub(super) fn near_rotate_corner(t: &TransformSession, p: [f64; 2], tol: f64) -> bool {
|
||||
t.warp.is_none()
|
||||
&& t.mode != TransformMode::Distort
|
||||
&& {
|
||||
let h = hit(t, p, tol);
|
||||
h == Hit::Outside || (t.mode == TransformMode::Rotate && matches!(h, Hit::Corner(_) | Hit::Edge(_)))
|
||||
}
|
||||
&& t.quad.iter().any(|q| (p[0] - q[0]).hypot(p[1] - q[1]) <= tol * 3.0)
|
||||
t.warp.is_none() && t.mode != TransformMode::Distort && {
|
||||
let h = hit(t, p, tol);
|
||||
h == Hit::Outside || (t.mode == TransformMode::Rotate && matches!(h, Hit::Corner(_) | Hit::Edge(_)))
|
||||
}
|
||||
}
|
||||
|
||||
/// Clockwise degrees in canvas coordinates (positive Y points down).
|
||||
@@ -228,8 +294,7 @@ pub(super) fn rotation_degrees(quad: [[f64; 2]; 4]) -> f64 {
|
||||
}
|
||||
|
||||
/// Where the rotate cursor's arc bends at document point `p`, or `None` outside the rotate zone:
|
||||
/// just outside a corner, or anywhere while a rotate drag is on. It points into the box along the
|
||||
/// bisector of the nearest corner, so each corner gets its own arrow and they turn with the box.
|
||||
/// anywhere outside, or while a rotate drag is on. It follows the nearest edge or corner.
|
||||
pub(crate) fn rotate_cursor_dir(app: &PhotocraftApp, p: [f64; 2]) -> Option<[f64; 2]> {
|
||||
rotate_dir(app.ui.transform.as_ref()?, app.transform_preview.as_ref(), p, handle_tolerance(app))
|
||||
}
|
||||
@@ -251,17 +316,7 @@ pub(super) fn rotate_dir(t: &TransformSession, pv: Option<&TransformPreview>, p:
|
||||
None if !near_rotate_corner(t, p, tol) => return None,
|
||||
None => {}
|
||||
}
|
||||
let dist = |q: [f64; 2]| (p[0] - q[0]).hypot(p[1] - q[1]);
|
||||
let i = (0..4).min_by(|&a, &b| dist(t.quad[a]).total_cmp(&dist(t.quad[b])))?;
|
||||
let unit = |to: [f64; 2]| {
|
||||
let d = [to[0] - t.quad[i][0], to[1] - t.quad[i][1]];
|
||||
let l = d[0].hypot(d[1]);
|
||||
(l.is_finite() && l > 1e-9).then(|| [d[0] / l, d[1] / l])
|
||||
};
|
||||
let (a, b) = (unit(t.quad[(i + 1) % 4])?, unit(t.quad[(i + 3) % 4])?);
|
||||
let s = [a[0] + b[0], a[1] + b[1]];
|
||||
let l = s[0].hypot(s[1]);
|
||||
(l.is_finite() && l > 1e-9).then(|| [s[0] / l, s[1] / l])
|
||||
TransformSession::box_turn_direction(&t.quad, p)
|
||||
}
|
||||
|
||||
/// The handle a drag in progress holds, else the one under document point `p`.
|
||||
@@ -317,7 +372,6 @@ pub fn cursor(app: &PhotocraftApp, xf: &ViewXform, p: [f64; 2], mods: egui::Modi
|
||||
Hit::Corner(i) => crate::tool_cursor::corner_resize(&t.quad, i, xf),
|
||||
Hit::Edge(i) => resize(edge_mid(i + 2), edge_mid(i)),
|
||||
Hit::Pivot => CursorIcon::Crosshair,
|
||||
Hit::Inside => CursorIcon::Move,
|
||||
Hit::Outside => CursorIcon::Alias,
|
||||
Hit::Inside | Hit::Outside => CursorIcon::Default,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
use super::*;
|
||||
use crate::state::{ContentAwareOptions, TransformMode, TransformSession};
|
||||
use crate::transform_tool::{Hit, cursor, hit, rotate_cursor_dir};
|
||||
use egui::{CursorIcon, Modifiers};
|
||||
|
||||
const QUAD: [[f64; 2]; 4] = [[100.0, 100.0], [500.0, 100.0], [500.0, 300.0], [100.0, 300.0]];
|
||||
|
||||
fn session(quad: [[f64; 2]; 4]) -> TransformSession {
|
||||
TransformSession {
|
||||
session: 1,
|
||||
layer: 1,
|
||||
rect: [100.0, 100.0, 500.0, 300.0],
|
||||
quad,
|
||||
pivot: quad.iter().fold([0.0; 2], |c, p| [c[0] + p[0] / 4.0, c[1] + p[1] / 4.0]),
|
||||
interpolation: "bicubic".into(),
|
||||
warp: None,
|
||||
selection: false,
|
||||
target: None,
|
||||
path: None,
|
||||
made: None,
|
||||
mode: TransformMode::Free,
|
||||
content_aware: None,
|
||||
skew_v: 0.0,
|
||||
layers: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn app(quad: [[f64; 2]; 4], zoom: f32) -> PhotocraftApp {
|
||||
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
|
||||
app.session.execute("file.new", serde_json::json!({"width": 32, "height": 32})).unwrap();
|
||||
app.sync_views();
|
||||
app.ui.views[0].zoom = zoom;
|
||||
app.ui.transform = Some(session(quad));
|
||||
app
|
||||
}
|
||||
|
||||
fn view(zoom: f32) -> ViewXform {
|
||||
ViewXform { rect: Rect::from_min_size(Pos2::ZERO, vec2(1000.0, 800.0)), zoom, center: [300.0, 200.0], flip: false, rotation: 0.0, aspect: 1.0 }
|
||||
}
|
||||
|
||||
fn near(actual: Option<[f64; 2]>, expected: [f64; 2]) {
|
||||
let actual = actual.expect("rotate direction");
|
||||
assert!((actual[0] - expected[0]).hypot(actual[1] - expected[1]) < 1e-6, "{actual:?} != {expected:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn whole_edge_and_corner_priority_table_at_100_and_200_percent() {
|
||||
for zoom in [1.0, 2.0] {
|
||||
let q = QUAD.map(|p| p.map(|v| v / zoom));
|
||||
let t = session(q);
|
||||
// Coordinates are screen pixels, so the same table must hold at both document zooms.
|
||||
for (p, expected) in [
|
||||
([100.0, 100.0], Hit::Corner(0)),
|
||||
([105.0, 105.0], Hit::Corner(0)),
|
||||
([95.0, 95.0], Hit::Corner(0)),
|
||||
([500.0, 300.0], Hit::Corner(2)),
|
||||
([180.0, 100.0], Hit::Edge(0)),
|
||||
([180.0, 89.0], Hit::Edge(0)),
|
||||
([500.0, 150.0], Hit::Edge(1)),
|
||||
([511.0, 150.0], Hit::Edge(1)),
|
||||
([420.0, 311.0], Hit::Edge(2)),
|
||||
([89.0, 250.0], Hit::Edge(3)),
|
||||
([180.0, 101.0], Hit::Inside),
|
||||
([499.0, 150.0], Hit::Inside),
|
||||
([180.0, 180.0], Hit::Inside),
|
||||
([180.0, 88.0], Hit::Outside),
|
||||
([620.0, 200.0], Hit::Outside),
|
||||
] {
|
||||
assert_eq!(hit(&t, p.map(|v| v / zoom), 12.0 / zoom), expected, "zoom {zoom}, screen {p:?}");
|
||||
}
|
||||
let tiny = session([[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0]]);
|
||||
assert_eq!(TransformSession::box_hit(&tiny.quad, [5.0, -1.0], 12.0), Hit::Corner(0), "corners beat overlapping edge bands");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn turned_box_zones_and_resize_cursors_follow_the_quad() {
|
||||
let turn = |p: [f64; 2]| {
|
||||
let (x, y) = (p[0] - 300.0, p[1] - 200.0);
|
||||
let k = std::f64::consts::FRAC_1_SQRT_2;
|
||||
[300.0 + (x - y) * k, 200.0 + (x + y) * k]
|
||||
};
|
||||
for zoom in [1.0_f32, 2.0] {
|
||||
let scale = |p: [f64; 2]| turn(p).map(|v| v / f64::from(zoom));
|
||||
let q = QUAD.map(scale);
|
||||
let app = app(q, zoom);
|
||||
let xf = view(zoom);
|
||||
let t = app.ui.transform.as_ref().unwrap();
|
||||
for (p, expected, icon) in [
|
||||
([180.0, 95.0], Hit::Edge(0), CursorIcon::ResizeNeSw),
|
||||
([505.0, 150.0], Hit::Edge(1), CursorIcon::ResizeNwSe),
|
||||
([180.0, 101.0], Hit::Inside, CursorIcon::Default),
|
||||
([180.0, -20.0], Hit::Outside, CursorIcon::None),
|
||||
] {
|
||||
assert_eq!(hit(t, scale(p), 12.0 / f64::from(zoom)), expected);
|
||||
assert_eq!(cursor(&app, &xf, scale(p), Modifiers::NONE), Some(icon), "zoom {zoom}, {p:?}");
|
||||
}
|
||||
assert_eq!(hit(t, scale([100.0, 100.0]), 12.0 / f64::from(zoom)), Hit::Corner(0));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn distorted_and_flipped_quads_use_their_edges_not_an_axis_aligned_box() {
|
||||
let q = [[100.0, 100.0], [500.0, 140.0], [460.0, 300.0], [80.0, 260.0]];
|
||||
for q in [q, [q[1], q[0], q[3], q[2]]] {
|
||||
let t = session(q);
|
||||
assert_eq!(hit(&t, [220.0, 112.0], 12.0), Hit::Edge(0));
|
||||
assert_eq!(hit(&t, [220.0, 107.0], 12.0), Hit::Edge(0));
|
||||
assert_eq!(hit(&t, [220.0, 113.0], 12.0), Hit::Inside);
|
||||
assert_eq!(hit(&t, [220.0, 90.0], 12.0), Hit::Outside);
|
||||
near(TransformSession::box_turn_direction(&q, [220.0, 90.0]), [-0.1 / 1.01_f64.sqrt(), 1.0 / 1.01_f64.sqrt()]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn outside_rotation_has_eight_edge_and_corner_orientations() {
|
||||
let app = app(QUAD, 1.0);
|
||||
let h = std::f64::consts::FRAC_1_SQRT_2;
|
||||
for (p, direction) in [
|
||||
([300.0, -20.0], [0.0, 1.0]),
|
||||
([620.0, -20.0], [-h, h]),
|
||||
([620.0, 200.0], [-1.0, 0.0]),
|
||||
([620.0, 420.0], [-h, -h]),
|
||||
([300.0, 420.0], [0.0, -1.0]),
|
||||
([-20.0, 420.0], [h, -h]),
|
||||
([-20.0, 200.0], [1.0, 0.0]),
|
||||
([-20.0, -20.0], [h, h]),
|
||||
] {
|
||||
near(rotate_cursor_dir(&app, p), direction);
|
||||
assert_eq!(cursor(&app, &view(1.0), p, Modifiers::NONE), Some(CursorIcon::None));
|
||||
assert_eq!(cursor(&app, &view(1.0), p, Modifiers::COMMAND), Some(CursorIcon::None));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unopened_move_controls_share_the_open_sessions_zones_and_cursors() {
|
||||
let app = app(QUAD, 1.0);
|
||||
let r = Rect::from_min_max(pos2(100.0, 100.0), pos2(500.0, 300.0));
|
||||
for p in [pos2(100.0, 100.0), pos2(180.0, 95.0), pos2(505.0, 150.0), pos2(180.0, 101.0), pos2(620.0, 200.0), pos2(-20.0, -20.0)] {
|
||||
let d = [f64::from(p.x), f64::from(p.y)];
|
||||
assert_eq!(transform_controls_cursor(r, p), cursor(&app, &view(1.0), d, Modifiers::NONE), "{p:?}");
|
||||
assert_eq!(transform_controls_hit(r, p), hit(app.ui.transform.as_ref().unwrap(), d, 12.0) != Hit::Inside);
|
||||
match (transform_controls_turn(r, p), rotate_cursor_dir(&app, d)) {
|
||||
(None, None) => {}
|
||||
(Some(a), Some(b)) => near(Some([f64::from(a.x) / 16.0, f64::from(a.y) / 16.0]), b),
|
||||
pair => panic!("unopened/open rotation disagreement: {pair:?}"),
|
||||
}
|
||||
}
|
||||
assert_eq!(transform_controls_cursor(r, r.center()), Some(CursorIcon::Default));
|
||||
assert!(!transform_controls_hit(r, r.center()), "inside remains an ordinary Move drag");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn modes_that_do_not_rotate_and_invalid_points_do_not_hide_the_pointer() {
|
||||
let mut app = app(QUAD, 1.0);
|
||||
for mode in [TransformMode::Distort, TransformMode::Skew] {
|
||||
app.ui.transform.as_mut().unwrap().mode = mode;
|
||||
assert_eq!(rotate_cursor_dir(&app, [620.0, 200.0]), None);
|
||||
assert_eq!(cursor(&app, &view(1.0), [620.0, 200.0], Modifiers::NONE), Some(CursorIcon::Default));
|
||||
}
|
||||
app.ui.transform.as_mut().unwrap().mode = TransformMode::Free;
|
||||
app.ui.transform.as_mut().unwrap().content_aware = Some(ContentAwareOptions::default());
|
||||
assert_eq!(rotate_cursor_dir(&app, [620.0, 200.0]), None);
|
||||
assert_eq!(cursor(&app, &view(1.0), [620.0, 200.0], Modifiers::NONE), Some(CursorIcon::Default));
|
||||
app.ui.transform.as_mut().unwrap().content_aware = None;
|
||||
let t = app.ui.transform.as_mut().unwrap();
|
||||
t.warp = Some(photocraft_geom::warp::Warp::none(t.rect));
|
||||
assert_eq!(rotate_cursor_dir(&app, [620.0, 200.0]), None);
|
||||
assert_eq!(cursor(&app, &view(1.0), [620.0, 200.0], Modifiers::NONE), Some(CursorIcon::Crosshair), "Warp retains its own cursor");
|
||||
app.ui.transform.as_mut().unwrap().warp = None;
|
||||
assert_eq!(rotate_cursor_dir(&app, [f64::NAN, 200.0]), None);
|
||||
assert_eq!(TransformSession::box_turn_direction(&[[0.0, 0.0]; 4], [20.0, 20.0]), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rotate_drag_keeps_the_arrow_when_the_pointer_enters_the_box() {
|
||||
let mut app = app(QUAD, 1.0);
|
||||
app.ui.transform = None;
|
||||
app.session.execute("shape.create", serde_json::json!({"kind": "rect", "rect": [4, 4, 16, 16], "fill": "#ff0000"})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
crate::transform_tool::begin(&mut app, &ctx).unwrap();
|
||||
crate::transform_tool::pointer(&mut app, crate::canvas::ToolEvent::Down { x: 80.0, y: 40.0, pressure: 1.0 }, Modifiers::NONE);
|
||||
crate::transform_tool::pointer(&mut app, crate::canvas::ToolEvent::Move { x: 10.0, y: 10.0, pressure: 1.0 }, Modifiers::NONE);
|
||||
assert!(rotate_cursor_dir(&app, [10.0, 10.0]).is_some(), "the held rotation gesture owns the arrow even inside");
|
||||
assert_eq!(cursor(&app, &view(1.0), [10.0, 10.0], Modifiers::NONE), Some(CursorIcon::None));
|
||||
}
|
||||
Reference in new issue
Block a user