Use whole-edge transform handles and consistent rotate cursors

This commit is contained in:
yoriswind committed 2026-11-03 19:22:40 -08:00
1 parent 37a01ca874
commit d630efdce2
4 files changed
+304 -78

No files matched your search

+28 -34
View File
@@ -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));
}