GitCorner

Code

ossartcrafteffectcraft🌐
665bfac0b339
//! The Composition viewer: pasteboard + comp frame, magnification and resolution, transparency
//! grid, guides, layer bounding boxes with handles, anchor points, motion paths and masks, and
//! direct manipulation (move, scale, rotate, pan behind, shape/type creation, hand and zoom),
//! 3D views (Active Camera / Front / … / Custom View 3), camera tools (orbit, pan, dolly) and
//! camera/light wireframes.

use effectcraft_engine::commands::shape_tool::PaintKind;
use effectcraft_engine::effects::puppet::PinKind;
use effectcraft_engine::geom::{Mat3, vec2 as gv2};
use effectcraft_engine::project::{Comp, Layer, LayerId, LayerSource};
use effectcraft_engine::render::EvalCtx;
use effectcraft_engine::render::three_d::{self, CameraState, View3D};
use effectcraft_engine::time::Tick;
use egui::{Align2, Color32, Pos2, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
use serde_json::json;

use crate::state::Tool;
use crate::theme::Tokens;
use crate::{EffectcraftApp, widgets};

/// A 3D view's name in the interface's language: the View menu's row for its `view.3d.*` command,
/// else the panel catalog, else the English source. The menu's rows carry After Effects' words —
/// フロントビュー rather than フロント — so the viewer's dropdown and the comp's view label read
/// the same names as View ▸ Switch 3D View.
pub(crate) fn view3d_label(v: View3D) -> &'static str {
    let id = match v {
        View3D::ActiveCamera => "view.3d.activeCamera",
        View3D::Default => "view.3d.default",
        View3D::Front => "view.3d.front",
        View3D::Left => "view.3d.left",
        View3D::Top => "view.3d.top",
        View3D::Back => "view.3d.back",
        View3D::Right => "view.3d.right",
        View3D::Bottom => "view.3d.bottom",
        View3D::Custom1 => "view.3d.custom1",
        View3D::Custom2 => "view.3d.custom2",
        View3D::Custom3 => "view.3d.custom3",
    };
    crate::i18n::command_label(id, v.label())
}

/// Viewer mapping published each frame (for the control channel and other panels).
#[derive(Clone, Copy, Debug)]
pub struct ViewerMap {
    pub origin: Pos2,
    /// Points per comp pixel.
    pub zoom: f32,
    pub comp: [f32; 2],
    pub area: Rect,
}

impl ViewerMap {
    pub fn to_screen(&self, p: [f64; 2]) -> Pos2 {
        pos2(self.origin.x + p[0] as f32 * self.zoom, self.origin.y + p[1] as f32 * self.zoom)
    }
    pub fn to_comp(&self, p: Pos2) -> [f64; 2] {
        [((p.x - self.origin.x) / self.zoom) as f64, ((p.y - self.origin.y) / self.zoom) as f64]
    }
}

/// The `egui::Id` under which the last pass's `ViewerMap` is published.
fn map_id() -> egui::Id {
    egui::Id::unique("viewer-map")
}

/// The egui data key (an `egui::Pos2`) of a right-click on the viewer that an overlay sensed:
/// the viewer opens its context menu there on the next pass.
pub(crate) const FORWARDED_SECONDARY: &str = "viewer-forwarded-secondary";

/// The egui data key (`(egui::Pos2, egui::Modifiers, u64)`: point, keys, egui pass) of a primary
/// press an overlay sensed but does not want (the Selection tool's Cryptomatte picking, #2839, when
/// the pointer left the layer in the pass of the press): the viewer clicks there on the next pass.
pub(crate) const FORWARDED_PRIMARY: &str = "viewer-forwarded-primary";

/// The egui data key (`()`) of a primary press an overlay claimed although egui handed it to the
/// viewer (the Selection tool's Cryptomatte picking, #2839, when the pointer arrived on the layer
/// and pressed in one pass, as a touch or a pen without hover does): the viewer neither clicks
/// nor drags with it, and lets go of the claim once the button is up.
pub(crate) const CLAIMED_PRIMARY: &str = "viewer-claimed-primary";

/// Whether an overlay claimed the primary press in progress ([`CLAIMED_PRIMARY`]).
fn press_claimed(ctx: &egui::Context) -> bool {
    ctx.data(|d| d.get_temp::<()>(egui::Id::unique(CLAIMED_PRIMARY))).is_some()
}

/// What the viewer's own handles reach this pass, for overlays drawn on top of it.
#[derive(Clone, Default)]
struct Grabs {
    handles: Vec<Pos2>,
    vertices: Vec<Pos2>,
    keys: Vec<Pos2>,
    axes: Vec<(LayerId, [Pos2; 2], [f64; 3], [f64; 3])>,
    /// Region-of-interest handles.
    roi: Vec<Pos2>,
    /// Visible, unlocked guides on screen: (x or y, vertical).
    guides: Vec<(f32, bool)>,
}

/// The egui data key of the viewer's [`Grabs`] for the current pass.
fn grabs_id() -> egui::Id {
    egui::Id::unique("viewer-grabs")
}

/// Whether a Selection-tool press at `pos` grabs one of the viewer's own controls (a layer's
/// bounding-box handle or gizmo arrow, a mask vertex or tangent, a motion-path key, a guide, a
/// region-of-interest handle) instead of the layer under it, with the reach the viewer gives
/// them. An overlay that takes presses on a layer leaves these to the viewer.
pub(crate) fn grabs_at(ctx: &egui::Context, pos: Pos2) -> bool {
    ctx.data(|d| {
        let Some(g) = d.get_temp::<Grabs>(grabs_id()) else { return false };
        let reach = vertex_grab_radius(pos, g.handles.iter().copied());
        g.handles.iter().any(|h| h.distance(pos) < HANDLE + 2.0)
            || g.vertices.iter().any(|v| v.distance(pos) < reach)
            || g.keys.iter().any(|k| k.distance(pos) < 6.0)
            || axis_at(&g.axes, pos).is_some()
            || g.roi.iter().any(|h| h.distance(pos) < 6.0)
            || g.guides.iter().any(|&(at, vertical)| (if vertical { pos.x } else { pos.y } - at).abs() < 4.0)
    })
}

pub fn comp_to_screen(ctx: &egui::Context, p: [f32; 2]) -> Option<Pos2> {
    let m: ViewerMap = ctx.data(|d| d.get_temp(map_id()))?;
    Some(m.to_screen([p[0] as f64, p[1] as f64]))
}

pub fn screen_to_comp(ctx: &egui::Context, p: Pos2) -> Option<[f64; 2]> {
    let m: ViewerMap = ctx.data(|d| d.get_temp(map_id()))?;
    Some(m.to_comp(p))
}

/// The fit magnification from the last frame.
pub fn last_fit(ctx: &egui::Context) -> f32 {
    ctx.data(|d| d.get_temp::<f32>(egui::Id::unique("viewer-fit"))).unwrap_or(0.5)
}

use super::viewer_overlays::{self as ov, VertexHit};
use super::viewer_tools as vt;

thread_local! {
    /// The 3D view camera of the viewer being drawn (None = the comp's active camera).
    static VIEW_CAM: std::cell::Cell<Option<CameraState>> = const { std::cell::Cell::new(None) };
}

/// Draw the Composition viewer in `rect` and handle its input for one pass.
/// Publishes the fit magnification and `ViewerMap`, requests and draws the frame, then paints the nav breadcrumbs,
/// view layout, guides/grid, layer boxes, handles, anchors, 3D gizmos, motion paths, masks, puppet pins and tracker
/// overlays and records their automation regions. Pointer and drop gestures run engine commands
/// (move/scale/rotate/anchor/camera/shape/mask/guide edits, picks, marquees); failures worth showing go to
/// `app.ui.status`, while per-frame drag updates ignore errors so a gesture is not aborted mid-drag. With no active
/// composition it draws `empty_state` and returns.
/// What the passes of one viewer frame share (see [`show`]).
struct Vw<'a> {
    t: Tokens,
    cid: effectcraft_engine::project::ItemId,
    nav: Rect,
    bar: Rect,
    err_bar: Rect,
    err_h: f32,
    pasteboard: Color32,
    area: Rect,
    outer: Rect,
    comp_rect: Rect,
    zoom: f32,
    ppp: f32,
    cw: f32,
    ch: f32,
    map: ViewerMap,
    time: Tick,
    overlays: bool,
    mods: egui::Modifiers,
    space_pan: bool,
    text_owns: bool,
    gid: egui::Id,
    track_cur: Option<(LayerId, effectcraft_engine::project::Uid)>,
    has_3d: bool,
    ctx: egui::Context,
    comp_name: String,
    p: egui::Painter,
    painter: egui::Painter,
    selected: Vec<LayerId>,
    sel_vertices: Vec<effectcraft_engine::VertexRef>,
    ft: Option<ov::FtBox>,
    comp: &'a Comp,
    gesture: Option<Gesture>,
    handle_hits: Vec<(LayerId, usize, Pos2, egui::CursorIcon)>,
    axis_hits: Vec<(LayerId, [Pos2; 2], [f64; 3], [f64; 3])>,
    vertex_hits: Vec<VertexHit>,
    vertex_marks: Vec<ov::VertexMark>,
    key_hits: Vec<ov::KeyHit>,
    motion_frames: Vec<ov::PathFrame>,
    paths: Vec<ov::PathInfo>,
    track_hits: Vec<super::tracker::Hit>,
    pin_hits: Vec<super::puppet_tool::PinHit>,
    puppet_layers: Vec<(&'a Layer, super::puppet_tool::Overlay)>,
}

/// Draws the viewer panel in `rect` for the active comp and handles its input.
pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
    let t = app.tokens;
    let ctx = ui.ctx().clone();
    let Some(cid) = app.session.active_comp_id() else {
        empty_state(app, ui, rect);
        return;
    };
    let comp = app.session.project.comp_arc(cid).unwrap_or_else(|| effectcraft_engine::project::Comp::new(1920, 1080, Default::default(), Tick::ZERO).into());
    let comp_name = app.session.project.item(cid).map(|i| i.name.clone()).unwrap_or_default();
    let p = ui.painter().clone();
    VIEW_CAM.with(|c| c.set(app.session.view_camera(cid)));
    let mut v = Vw {
        t,
        cid,
        nav: Rect::NOTHING,
        bar: Rect::NOTHING,
        err_bar: Rect::NOTHING,
        err_h: 0.0,
        pasteboard: Color32::BLACK,
        area: Rect::NOTHING,
        outer: Rect::NOTHING,
        comp_rect: Rect::NOTHING,
        zoom: 1.0,
        ppp: 1.0,
        cw: 0.0,
        ch: 0.0,
        map: ViewerMap { origin: Pos2::ZERO, zoom: 1.0, comp: [0.0; 2], area: Rect::NOTHING },
        time: Tick::ZERO,
        overlays: false,
        mods: egui::Modifiers::NONE,
        space_pan: false,
        text_owns: false,
        gid: egui::Id::unique("viewer-gesture"),
        track_cur: None,
        has_3d: false,
        ctx: ctx.clone(),
        comp_name,
        painter: p.clone(),
        p,
        selected: vec![],
        sel_vertices: vec![],
        ft: None,
        comp: &comp,
        gesture: None,
        handle_hits: vec![],
        axis_hits: vec![],
        vertex_hits: vec![],
        vertex_marks: vec![],
        key_hits: vec![],
        motion_frames: vec![],
        paths: vec![],
        track_hits: vec![],
        pin_hits: vec![],
        puppet_layers: vec![],
    };
    phase_nav(app, ui, rect, &mut v);
    phase_layout(app, ui, rect, &mut v);
    phase_frame(app, &mut v);
    let snap_project = app.session.project.clone();
    let snap_expr = app.session.expr.clone();
    let ectx = EvalCtx {
        project: &snap_project,
        comp_id: cid,
        comp: &comp,
        time: v.time,
        expr: snap_expr.as_deref(),
        footage: None,
        property_overrides: &[],
        media_overrides: &[],
        reads: None,
    };
    phase_guides(app, &ectx, &mut v);
    phase_layers(app, ui, &ectx, &mut v);
    phase_scene(app, &ectx, &mut v);
    phase_rigs(app, ui, &ectx, &mut v);
    let resp = phase_menu(app, ui, &ectx, &mut v);
    phase_hover(app, ui, &ectx, &resp, &mut v);
    phase_press(app, ui, &ectx, &resp, &mut v);
    if !middle_pan(app, ui, &resp, &v) {
        phase_dragstart(app, ui, &ectx, &resp, &mut v);
        phase_drag(app, ui, &ectx, &resp, &mut v);
        phase_stopped(app, ui, &ectx, &resp, &mut v);
        phase_clicked(app, &ectx, &resp, &mut v);
        phase_dblclick(app, &ectx, &resp, &mut v);
    }
    phase_tail(app, ui, &ectx, &mut v);
}

fn phase_nav(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, v: &mut Vw<'_>) {
    let t = v.t;
    let cid = v.cid;
    let p = v.p.clone();
    // Navigator bar (open comps as breadcrumbs). After Effects shows a single breadcrumb row:
    // when the Composition Navigator (nested comp flow) is above the viewer, this row is left
    // out.
    let nav_h = if super::precomp::has_flow(app) { 0.0 } else { 24.0 };
    let nav = Rect::from_min_size(rect.min, vec2(rect.width(), nav_h));
    p.rect_filled(nav, 0.0, t.panel_bg);
    let mut x = nav.min.x + 10.0;
    let open = if nav_h > 0.0 { app.session.state.open_comps.clone() } else { vec![] };
    for oc in open {
        let name = app.session.project.item(oc).map(|i| i.name.clone()).unwrap_or_default();
        let g = p.layout_no_wrap(name.clone(), Tokens::ui(11.5), t.text);
        let r = Rect::from_min_size(pos2(x, nav.min.y + 3.0), vec2(g.size().x + 16.0, 18.0));
        let resp = ui.interact(r, egui::Id::unique(("nav", oc.0)), Sense::click());
        let active = oc == cid;
        p.rect_filled(
            r,
            9.0,
            if active {
                t.row_selected
            } else if resp.hovered() {
                t.hover
            } else {
                Color32::TRANSPARENT
            },
        );
        p.galley_with_override_text_color(pos2(r.min.x + 8.0, r.center().y - g.size().y / 2.0), g, if active { t.tab_text_active } else { t.text_dim });
        app.auto.add(&format!("viewer.nav.{}", oc.0), r, &name);
        if resp.clicked() {
            app.session.open_comp(oc);
        }
        x = r.max.x + 4.0;
    }
    v.nav = nav;
}

fn phase_layout(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, v: &mut Vw<'_>) {
    let t = v.t;
    let cid = v.cid;
    let nav = v.nav;
    let ctx = v.ctx.clone();
    let p = v.p.clone();
    let comp = v.comp;
    // Bottom control bar.
    let bar_h = 36.0;
    let bar = Rect::from_min_max(pos2(rect.min.x, rect.max.y - bar_h), rect.max);
    // The expression error bar sits above the control bar while expressions fail.
    let err_h = super::expr_bar::height(app, &ctx, cid);
    let err_bar = Rect::from_min_max(pos2(rect.min.x, bar.min.y - err_h), pos2(rect.max.x, bar.min.y));
    let full = Rect::from_min_max(pos2(rect.min.x, nav.max.y), pos2(rect.max.x, err_bar.min.y));
    let pasteboard = app.ui.viewer.pasteboard.map(|[r, g, b]| Color32::from_rgb(r, g, b)).unwrap_or(t.pasteboard);
    // View ▸ Switch View Layout: extra views (Top / Front / Right) beside the main view, which
    // keeps the overlays and the interaction.
    let full = locked_pane(app, ui, full, pasteboard);
    let area = aux_views(app, ui, comp, cid, full, pasteboard);
    p.rect_filled(area, 0.0, pasteboard);
    // View ▸ Show Rulers takes a strip on the top and left.
    let outer = area;
    let area = vt::inset(app, area);

    let (cw, ch) = (comp.width as f32, comp.height as f32);
    let fit = ((area.width() - 40.0) / cw).min((area.height() - 40.0) / ch).max(0.01);
    // Fit up to 100% follows the panel's size like Fit does, and stops at 100%.
    let fit = if app.ui.viewer.fit_up_to_100 { fit.min(1.0 / ctx.pixels_per_point()) } else { fit };
    ctx.data_mut(|d| d.insert_temp(egui::Id::unique("viewer-fit"), fit));
    let zoom = app.ui.viewer.zoom.unwrap_or(fit);
    let center = area.center() + vec2(app.ui.viewer.pan[0], app.ui.viewer.pan[1]);
    // On the physical pixel grid, so at 100 % every comp pixel covers exactly one screen pixel
    // instead of being blended with its neighbour (#882).
    let ppp = ctx.pixels_per_point();
    let origin = snap_to_pixels(center - vec2(cw * zoom / 2.0, ch * zoom / 2.0), ppp);
    let map = ViewerMap { origin, zoom, comp: [cw, ch], area };
    ctx.data_mut(|d| d.insert_temp(map_id(), map));
    let comp_rect = Rect::from_min_size(origin, vec2(cw * zoom, ch * zoom));
    let painter = p.with_clip_rect(area);
    // Settings ▸ 3D ▸ Extended Viewer: custom 3D views (and Draft 3D) render the visible
    // pasteboard too, so 3D layers reaching past the comp frame stay visible there.
    app.ui.viewer.extended = extended_region(app, comp, cid, map);
    v.bar = bar;
    v.err_bar = err_bar;
    v.err_h = err_h;
    v.pasteboard = pasteboard;
    v.area = area;
    v.outer = outer;
    v.comp_rect = comp_rect;
    v.zoom = zoom;
    v.ppp = ppp;
    v.cw = cw;
    v.ch = ch;
    v.map = map;
    v.painter = painter;
}

fn phase_frame(app: &mut EffectcraftApp, v: &mut Vw<'_>) {
    let cid = v.cid;
    let comp_rect = v.comp_rect;
    let zoom = v.zoom;
    let ppp = v.ppp;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let comp = v.comp;
    // Frame.
    let scale = app.viewer_scale(zoom, ppp);
    if !app.playback.playing {
        // Queue the frame on screen before any prefetch.
        app.request_frame_urgent(cid, comp.frame_rate.frame_at(app.session.time()), scale);
    }
    crate::note_viewer_scale(app, scale);
    let time = app.session.time();
    let frame = comp.frame_rate.frame_at(time);
    let key = app.frame_key(cid, frame, scale);
    app.request_frame_urgent(cid, frame, scale);
    // The frame on screen. While a drag or a property scrub is rendering, the exact key changes
    // with every edit and its render is still in flight; the newest completed revision of the
    // same frame keeps the picture following the pointer instead of freezing until it stops.
    if let Some((k, img)) = app.frames.get_for_viewer(&key, app.viewer_shown.as_ref().map(|(_, s)| s)) {
        let stale = app.viewer_shown.as_ref().is_none_or(|(_, s)| *s != k);
        // A CPU frame goes up again when the magnification calls for another factor.
        let minify = minify_factor(app.session.prefs.viewer_zoom_smooth(), scale, (zoom * ppp) as f64);
        // (Half-float frames have no such texture: the display pass makes mips.)
        let refit = !app.viewer_on_gpu() && app.viewer_tex.as_ref().is_some_and(|(_, _, m)| *m != minify);
        if stale || refit {
            show_frame(app, &ctx, k, img, minify);
        } else if let Some((_, s)) = app.viewer_shown.as_mut() {
            // The same frame at a later revision (an edit elsewhere, an undo): it shows that one.
            s.revision = k.revision;
        }
    }
    if app.ui.viewer.transparency_grid {
        checker(&painter, comp_rect);
    } else {
        let bg = comp.background;
        painter.rect_filled(comp_rect, 0.0, Color32::from_rgb((bg[0] * 255.0) as u8, (bg[1] * 255.0) as u8, (bg[2] * 255.0) as u8));
    }
    v.time = time;
}

fn phase_guides(app: &mut EffectcraftApp, ectx: &EvalCtx, v: &mut Vw<'_>) {
    let cid = v.cid;
    let area = v.area;
    let comp_rect = v.comp_rect;
    let zoom = v.zoom;
    let map = v.map;
    let ctx = v.ctx.clone();
    let comp_name = v.comp_name.clone();
    let painter = v.painter.clone();
    let comp = v.comp;
    // The frame (or snapshot) through Show Channel and exposure; ROI frames cover the region.
    vt::draw_frame(app, &ctx, &painter, comp_rect, cid, ectx);
    if app.ui.viewer.extended.is_some() {
        // The comp frame outlined over the extended render.
        painter.rect_stroke(comp_rect, 0.0, Stroke::new(1.0, Color32::from_gray(150)), StrokeKind::Outside);
        app.auto.add("viewer.extendedArea", rect_of(&map, app.ui.viewer.extended), "Extended Viewer area");
    } else {
        painter.rect_stroke(comp_rect, 0.0, Stroke::new(1.0, Color32::from_black_alpha(160)), StrokeKind::Outside);
    }
    app.auto.add("viewer.comp", comp_rect, &comp_name);
    app.auto.add("viewer.area", area, "Composition viewer");

    // Guides.
    let overlays = app.overlays_visible();
    if overlays && app.ui.viewer.safe_margins {
        let g = &app.session.prefs.grids;
        let (act, title) = (1.0 - g.action_safe as f32 / 100.0, 1.0 - g.title_safe as f32 / 100.0);
        for (k, a) in [(act, 120u8), (title, 160)] {
            let r = Rect::from_center_size(comp_rect.center(), comp_rect.size() * k);
            painter.rect_stroke(r, 0.0, Stroke::new(1.0, Color32::from_white_alpha(a)), StrokeKind::Middle);
        }
        let c = comp_rect.center();
        painter.line_segment([c - vec2(10.0, 0.0), c + vec2(10.0, 0.0)], Stroke::new(1.0, Color32::from_white_alpha(140)));
        painter.line_segment([c - vec2(0.0, 10.0), c + vec2(0.0, 10.0)], Stroke::new(1.0, Color32::from_white_alpha(140)));
    }
    if overlays && app.ui.viewer.grid {
        // Settings ▸ Grids & Guides: gridline spacing, subdivisions and colour.
        let g = &app.session.prefs.grids;
        let [r, gg, b] = hex_rgb(&g.grid_color).unwrap_or([120, 160, 255]);
        let major = Stroke::new(1.0, Color32::from_rgba_unmultiplied(r, gg, b, 90));
        let minor = Stroke::new(1.0, Color32::from_rgba_unmultiplied(r, gg, b, 35));
        let step = (g.grid_spacing as f32 * zoom).max(2.0);
        let sub = g.grid_subdivisions.max(1) as f32;
        let sstep = step / sub;
        let draw_minor = sstep >= 4.0;
        // Settings ▸ Grids & Guides ▸ Grid Style (lines, dashed lines or dots).
        let style = g.grid_style.clone();
        let mut i = 0u32;
        let mut gx = comp_rect.min.x;
        while gx <= comp_rect.max.x {
            let is_major = i.is_multiple_of(g.grid_subdivisions.max(1));
            if is_major || draw_minor {
                styled_line(&painter, [pos2(gx, comp_rect.min.y), pos2(gx, comp_rect.max.y)], if is_major { major } else { minor }, &style);
            }
            gx += sstep;
            i += 1;
        }
        let mut i = 0u32;
        let mut gy = comp_rect.min.y;
        while gy <= comp_rect.max.y {
            let is_major = i.is_multiple_of(g.grid_subdivisions.max(1));
            if is_major || draw_minor {
                styled_line(&painter, [pos2(comp_rect.min.x, gy), pos2(comp_rect.max.x, gy)], if is_major { major } else { minor }, &style);
            }
            gy += sstep;
            i += 1;
        }
    }

    vt::proportional_grid(app, &painter, comp_rect);

    // Comp guides (View ▸ Show Guides) and the region of interest.
    if overlays && app.ui.viewer.guides {
        let [r, gg, b] = hex_rgb(&app.session.prefs.grids.guide_color).unwrap_or([0x3c, 0xc8, 0xf0]);
        let stroke = Stroke::new(1.0, Color32::from_rgb(r, gg, b));
        // Settings ▸ Grids & Guides ▸ Guide Style.
        let style = app.session.prefs.grids.guide_style.clone();
        for g in &comp.guides {
            if g.vertical {
                let x = comp_rect.min.x + g.px(comp.width, comp.height) as f32 * zoom;
                styled_line(&painter, [pos2(x, area.min.y), pos2(x, area.max.y)], stroke, &style);
            } else {
                let y = comp_rect.min.y + g.px(comp.width, comp.height) as f32 * zoom;
                styled_line(&painter, [pos2(area.min.x, y), pos2(area.max.x, y)], stroke, &style);
            }
        }
    }
    if let Some([rx, ry, rw, rh]) = app.session.state.region_of_interest {
        let r = Rect::from_min_size(comp_rect.min + vec2(rx as f32 * zoom, ry as f32 * zoom), vec2(rw as f32 * zoom, rh as f32 * zoom));
        painter.rect_stroke(r, 0.0, Stroke::new(1.0, Color32::WHITE), StrokeKind::Middle);
        // Resize handles: corners and edge midpoints (drag with any tool).
        for (i, c) in roi_handles(r).iter().enumerate() {
            painter.rect_filled(Rect::from_center_size(*c, vec2(5.0, 5.0)), 0.0, Color32::WHITE);
            app.auto.add(&format!("viewer.regionOfInterest.handle.{i}"), Rect::from_center_size(*c, vec2(8.0, 8.0)), "Resize the region of interest");
        }
        app.auto.add("viewer.regionOfInterest", r, "Region of interest");
    }
    v.overlays = overlays;
}

fn phase_layers(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) {
    let t = v.t;
    let zoom = v.zoom;
    let cw = v.cw;
    let ch = v.ch;
    let map = v.map;
    let time = v.time;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let mut handle_hits = std::mem::take(&mut v.handle_hits);
    let mut axis_hits = std::mem::take(&mut v.axis_hits);
    let mut vertex_hits = std::mem::take(&mut v.vertex_hits);
    let mut vertex_marks = std::mem::take(&mut v.vertex_marks);
    let mut key_hits = std::mem::take(&mut v.key_hits);
    let mut motion_frames = std::mem::take(&mut v.motion_frames);
    let mut paths = std::mem::take(&mut v.paths);
    let comp = v.comp;
    // Overlays + interaction.
    let selected = app.session.state.selected_layers.clone();
    // Bounding-box handles: (layer, handle, screen point, its resize cursor).
    // 3D gizmo arrows: (layer, grabbable screen segment, position change per comp px in x and y).
    let sel_vertices = app.session.state.selected_vertices.clone();
    // Pen path in progress ends when the tool changes or its mask is gone; Esc / Enter also end
    // free transform.
    let finish = ui.input(|i| i.key_pressed(egui::Key::Escape) || i.key_pressed(egui::Key::Enter)) && !ctx.egui_wants_keyboard_input();
    if app.ui.tool != Tool::Pen || finish {
        ui.data_mut(|d| d.remove::<(LayerId, u64)>(pen_id()));
    }
    if finish || app.ui.tool != Tool::Selection {
        ov::end_free_transform(&ctx);
    }
    if app.layer_controls_visible() {
        // Settings ▸ General ▸ Path Point and Handle Size; Appearance ▸ Use Label Color for
        // Layer Handles and Paths.
        let hs = app.session.prefs.general.path_point_size as f32 + 2.0;
        let label_handles = app.session.prefs.appearance.use_label_color_for_handles;
        // Nulls are rig controls: their outlines remain visible without selection (#1642).
        // Keep this separate from selected layers so they gain no handles, anchors or paths. Solo
        // scope matches picking (`selectable_layers`), so a null that can't be clicked isn't drawn.
        let any_solo = comp.layers.iter().any(|l| l.switches.solo && l.source.is_av());
        for l in comp.layers.iter().filter(|l| {
            matches!(l.source, LayerSource::Null) && !selected.contains(&l.id) && l.is_active_at(time) && l.switches.video && (!any_solo || l.switches.solo)
        }) {
            let outline = layer_outline(ectx, l);
            if outline.len() > 2 {
                let col = if label_handles { t.label(l.label) } else { t.accent };
                painter.add(egui::Shape::closed_line(outline.into_iter().map(|p| map.to_screen(p)).collect(), Stroke::new(1.0, col)));
            }
        }
        // The eye hides a layer's pixels, not its controls: a selected AV layer keeps its box,
        // handles, anchor, motion path and mask/shape paths so it stays editable over the visible
        // artwork (#1769). Nulls, cameras and lights have no pixels and disappear from the viewer
        // when hidden (#1332/#1642). Picking still uses `selectable_layers`, so a hidden layer is
        // selected from the Timeline; its controls are interactive once selected.
        for l in comp.layers.iter().filter(|l| selected.contains(&l.id) && l.is_active_at(time) && (l.switches.video || l.source.is_av())) {
            let col = if label_handles { t.label(l.label) } else { t.accent };
            // Motion path of animated position (keyframes and spatial tangents are draggable).
            ov::motion_path(app, &painter, &map, ectx, l, col, &mut key_hits, &mut motion_frames);
            // Masks and shape paths.
            if app.ui.viewer.show_masks {
                let pen = ui.data(|d| d.get_temp::<(LayerId, u64)>(pen_id()));
                let hover = ui.input(|i| i.pointer.hover_pos());
                ov::draw_paths(app, &painter, &map, ectx, l, col, &sel_vertices, pen, hover, &mut vertex_hits, &mut vertex_marks, &mut paths);
            }
            // Settings ▸ Previews ▸ Show Internal Wireframes: outlines of the layers inside a
            // selected collapsed precomp.
            if app.session.prefs.previews.show_internal_wireframes
                && l.switches.collapse
                && let effectcraft_engine::project::LayerSource::Comp { item } = &l.source
                && let Some(nc) = app.session.project.comp(*item)
            {
                let (outer, _) = l2c(ectx, l);
                let nctx = EvalCtx::new(&app.session.project, *item, nc, ectx.nested_time(l));
                for nl in nc.layers.iter().filter(|nl| nl.is_active_at(nctx.time) && !nl.is_3d()) {
                    if let Some((_, q, _)) = layer_quad(&nctx, nl) {
                        let sq: Vec<Pos2> = q
                            .iter()
                            .map(|p| {
                                let c = outer.apply(gv2(p[0], p[1]));
                                map.to_screen([c.x, c.y])
                            })
                            .collect();
                        painter.add(egui::Shape::closed_line(sq, Stroke::new(1.0, col.gamma_multiply(0.6))));
                    }
                }
            }
            // Path editing keeps vertices and tangents visible without the layer's transform
            // box competing with them (#1220). The path's own free-transform box is separate.
            let editing_path = paths.iter().any(|p| {
                p.layer == l.id && (app.ui.tool.is_pen() || (app.ui.tool == Tool::Selection && sel_vertices.iter().any(|v| v.layer == l.id && v.mask == p.uid)))
            });
            if editing_path {
                continue;
            }
            let Some((m, q, _)) = layer_quad(ectx, l) else {
                // A 3D layer reaching past the camera: the part of its box in front of it.
                let outline = layer_outline(ectx, l);
                if outline.len() > 2 {
                    painter.add(egui::Shape::closed_line(outline.iter().map(|p| map.to_screen(*p)).collect(), Stroke::new(1.0, col)));
                    continue;
                }
                // Cameras, lights, empty layers: just the anchor.
                if let Some(tr) = l.transform() {
                    let pos = ectx.v3(l, tr, "position", [0.0; 3]);
                    let s = map.to_screen([pos[0], pos[1]]);
                    painter.circle_stroke(s, 6.0, Stroke::new(1.0, col));
                }
                continue;
            };
            let sq: Vec<Pos2> = q.iter().map(|p| map.to_screen(*p)).collect();
            painter.add(egui::Shape::closed_line(sq.clone(), Stroke::new(1.0, col)));
            for i in 0..8 {
                let hp = if i < 4 { sq[i] } else { sq[i - 4] + (sq[(i - 3) % 4] - sq[i - 4]) * 0.5 };
                let hr = Rect::from_center_size(hp, vec2(hs, hs));
                painter.rect_filled(hr, 0.0, col);
                painter.rect_stroke(hr, 0.0, Stroke::new(1.0, Color32::from_black_alpha(120)), StrokeKind::Outside);
                handle_hits.push((l.id, i, hp, handle_cursor(&sq, i)));
                app.auto.add(&format!("viewer.handle.{}.{i}", l.id.0), hr, "handle");
            }
            // Anchor point.
            if let Some(tr) = l.transform() {
                let a = ectx.v3(l, tr, "anchor", [0.0; 3]);
                let c = m.apply(gv2(a[0], a[1]));
                let s = map.to_screen([c.x, c.y]);
                painter.circle_stroke(s, 5.0, Stroke::new(1.0, Color32::WHITE));
                painter.line_segment([s - vec2(9.0, 0.0), s + vec2(9.0, 0.0)], Stroke::new(1.0, Color32::WHITE));
                painter.line_segment([s - vec2(0.0, 9.0), s + vec2(0.0, 9.0)], Stroke::new(1.0, Color32::WHITE));
                app.auto.add(&format!("viewer.anchor.{}", l.id.0), Rect::from_center_size(s, vec2(12.0, 12.0)), "anchor point");
                // 3D axis gizmo.
                if l.is_3d() {
                    let w = ectx.world_matrix(l);
                    let pc = cam_state(ectx).projection(cw as f64, ch as f64) * w;
                    let a3 = effectcraft_engine::geom::vec3(a[0], a[1], a[2]);
                    let len = 60.0 / zoom as f64;
                    let pinv = parent_world_inverse(ectx, l);
                    for (axis, col, name) in [
                        (effectcraft_engine::geom::vec3(len, 0.0, 0.0), Color32::from_rgb(0xe0, 0x50, 0x50), "x"),
                        (effectcraft_engine::geom::vec3(0.0, len, 0.0), Color32::from_rgb(0x60, 0xd0, 0x60), "y"),
                        (effectcraft_engine::geom::vec3(0.0, 0.0, len), Color32::from_rgb(0x50, 0x8c, 0xf0), "z"),
                    ] {
                        // (clipped at the camera's near plane, #572)
                        let Some([o, e]) = project_segment(&pc, a3, a3 + axis) else { continue };
                        // An axis pointing at the camera (Z in the default front view) projects to
                        // a dot: draw it as a short diagonal stub so it can still be grabbed.
                        let mut s = [e[0] - o[0], e[1] - o[1]];
                        if (s[0] * s[0] + s[1] * s[1]).sqrt() * (zoom as f64) < 12.0 {
                            let k = 24.0 / zoom as f64;
                            s = [k, -k];
                        }
                        let (so, se) = (map.to_screen(o), map.to_screen([o[0] + s[0], o[1] + s[1]]));
                        painter.arrow(so, se - so, Stroke::new(2.0, col));
                        if !l.switches.locked {
                            let dir = pinv.apply_vec(w.apply_vec(axis));
                            let (ax, ay) = axis_drag([dir.x, dir.y, dir.z], s);
                            // The inner part stays on the anchor point, which drags the layer freely.
                            axis_hits.push((l.id, [so + (se - so) * 0.35, se], ax, ay));
                            app.auto.add(&format!("viewer.gizmo.{}.{name}", l.id.0), Rect::from_center_size(se, vec2(12.0, 12.0)), "3D axis");
                        }
                    }
                }
            }
        }
    }
    v.handle_hits = handle_hits;
    v.axis_hits = axis_hits;
    v.vertex_hits = vertex_hits;
    v.vertex_marks = vertex_marks;
    v.key_hits = key_hits;
    v.motion_frames = motion_frames;
    v.paths = paths;
    v.selected = selected;
    v.sel_vertices = sel_vertices;
}

fn phase_scene(app: &mut EffectcraftApp, ectx: &EvalCtx, v: &mut Vw<'_>) {
    let t = v.t;
    let cid = v.cid;
    let area = v.area;
    let comp_rect = v.comp_rect;
    let cw = v.cw;
    let ch = v.ch;
    let map = v.map;
    let time = v.time;
    let painter = v.painter.clone();
    let selected = v.selected.clone();
    let vertex_marks = std::mem::take(&mut v.vertex_marks);
    let mut track_hits = std::mem::take(&mut v.track_hits);
    let comp = v.comp;
    // Path points last, over the boxes' handles (#1042).
    ov::draw_vertex_marks(&painter, &vertex_marks, app.session.prefs.general.path_point_size as f32 + 1.0);

    // Settings ▸ 3D: Extended Viewer (3D layers outlined beyond the comp frame) and Show 3D
    // Reference Axes (world X/Y/Z in the corner, turning with the view).
    let has_3d = comp.layers.iter().any(|l| l.is_3d() && l.is_active_at(time));
    if has_3d && app.session.prefs.three_d.extended_viewer {
        for l in comp.layers.iter().filter(|l| l.is_3d() && l.is_active_at(time) && l.has_video()) {
            let q = layer_outline(ectx, l);
            if q.len() > 2 {
                let sq: Vec<Pos2> = q.iter().map(|p| map.to_screen(*p)).collect();
                let outside = sq.iter().any(|p| !comp_rect.contains(*p));
                if outside {
                    painter.add(egui::Shape::closed_line(sq, Stroke::new(1.0, t.label(l.label).gamma_multiply(0.55))));
                }
            }
        }
    }
    if has_3d && app.session.prefs.three_d.show_reference_axes {
        let pc = cam_state(ectx).projection(cw as f64, ch as f64);
        let o3 = effectcraft_engine::geom::vec3(cw as f64 / 2.0, ch as f64 / 2.0, 0.0);
        let o = pc.apply(o3);
        let corner = pos2(area.min.x + 34.0, area.max.y - 34.0);
        for (axis, col, name) in [
            (effectcraft_engine::geom::vec3(1.0, 0.0, 0.0), Color32::from_rgb(0xe0, 0x50, 0x50), "X"),
            (effectcraft_engine::geom::vec3(0.0, 1.0, 0.0), Color32::from_rgb(0x60, 0xd0, 0x60), "Y"),
            (effectcraft_engine::geom::vec3(0.0, 0.0, 1.0), Color32::from_rgb(0x50, 0x8c, 0xf0), "Z"),
        ] {
            let e = pc.apply(o3 + axis * 10.0);
            let d = vec2((e.x - o.x) as f32, (e.y - o.y) as f32);
            let d = if d.length() > 1e-4 { d.normalized() * 22.0 } else { vec2(0.0, 0.0) };
            painter.arrow(corner, d, Stroke::new(1.5, col));
            painter.text(corner + d * 1.25, Align2::CENTER_CENTER, name, Tokens::ui(10.0), col);
        }
        app.auto.add("viewer.referenceAxes", Rect::from_center_size(corner, vec2(56.0, 56.0)), "3D reference axes");
    }

    // Track points of the current track (Tracker panel) on its layer, while that layer is selected.
    let track_cur = super::tracker::viewer_track(app);
    if app.layer_controls_visible()
        && let Some((tl, tu)) = track_cur
        && selected.contains(&tl)
        && let Some(layer) = comp.layer(tl)
        && layer.is_active_at(time)
    {
        let (m, _) = l2c(ectx, layer);
        track_hits = super::tracker::draw_overlay(app, &painter, &map, &m, layer, tu, time);
    }

    // Warp Stabilizer banner over the layer being analysed ("Analyzing in background (step 1
    // of 2)…" / "Stabilizing…").
    if let Some((wc, wl, _)) = app.session.warp_target()
        && wc == cid
        && let Some(pr) = app.session.warp_progress()
        && let Some(layer) = comp.layer(wl)
        && layer.is_active_at(time)
    {
        let (m, _) = l2c(ectx, layer);
        let (w, h) = effectcraft_engine::render::source_size(&app.session.project, layer);
        let c = m.apply(effectcraft_engine::geom::vec2(w as f64 / 2.0, h as f64 / 2.0));
        let at = map.to_screen([c.x, c.y]);
        let text = pr.banner();
        let galley = painter.layout_no_wrap(text.clone(), Tokens::medium(13.0), Color32::WHITE);
        let r = Rect::from_center_size(at, galley.size() + vec2(28.0, 14.0)).intersect(map.area);
        painter.rect_filled(r, 3.0, Color32::from_rgba_unmultiplied(0x1d, 0x4f, 0x9c, 0xe0));
        painter.galley(pos2(r.center().x - galley.size().x / 2.0, r.center().y - galley.size().y / 2.0), galley, Color32::WHITE);
        app.auto.add("viewer.warpBanner", r, &text);
    }

    // Footage (or the proxy in use for footage or a precomp) that can't be decoded (no decoder
    // for its codec / profile): say why on the layer instead of leaving a black picture.
    for (notices, (layer, why)) in footage_problems(app, ectx, comp, time).into_iter().enumerate() {
        let (m, _) = l2c(ectx, layer);
        let (w, h) = effectcraft_engine::render::source_size(&app.session.project, layer);
        let c = m.apply(effectcraft_engine::geom::vec2(w as f64 / 2.0, h as f64 / 2.0));
        let at = map.to_screen([c.x, c.y]);
        let text = format!("{}: {}", layer.name, why);
        let galley = painter.layout(text.clone(), Tokens::medium(12.0), Color32::WHITE, (map.area.width() - 40.0).clamp(80.0, 420.0));
        let r = Rect::from_center_size(at + vec2(0.0, notices as f32 * 4.0), galley.size() + vec2(24.0, 16.0)).intersect(map.area);
        painter.rect_filled(r, 3.0, Color32::from_rgba_unmultiplied(0x4a, 0x1a, 0x14, 0xe6));
        painter.rect_stroke(r, 3.0, Stroke::new(1.0, t.warning), StrokeKind::Inside);
        painter.galley(pos2(r.min.x + 12.0, r.center().y - galley.size().y / 2.0), galley, Color32::WHITE);
        app.auto.add(&format!("viewer.footageProblem.{}", layer.id.0), r, &text);
    }
    v.vertex_marks = vertex_marks;
    v.track_hits = track_hits;
    v.track_cur = track_cur;
    v.has_3d = has_3d;
}

/// Up to three layers active at `time` whose footage, or the proxy in use for footage or a
/// precomp, can't be decoded, each with the reason.
fn footage_problems<'c>(app: &EffectcraftApp, ectx: &EvalCtx, comp: &'c Comp, time: Tick) -> Vec<(&'c Layer, String)> {
    comp.layers
        .iter()
        .filter(|l| l.is_active_at(time) && l.switches.video)
        .filter_map(|layer| {
            let (LayerSource::Footage { item } | LayerSource::Comp { item }) = &layer.source else { return None };
            Some((layer, ectx.project.item(*item).and_then(|i| app.session.footage.item_problem(i))?))
        })
        .take(3)
        .collect()
}

fn phase_rigs(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) {
    let t = v.t;
    let cid = v.cid;
    let area = v.area;
    let map = v.map;
    let time = v.time;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let selected = v.selected.clone();
    let paths = std::mem::take(&mut v.paths);
    let mut pin_hits = std::mem::take(&mut v.pin_hits);
    let mut puppet_layers = std::mem::take(&mut v.puppet_layers);
    let comp = v.comp;
    // Free transform box of a path (double-click a path with the Selection tool).
    let ft = ov::draw_free_transform(app, &ctx, &painter, &map, &paths);

    // Cameras and lights (wireframes) and the 3D view name.
    if comp.has_3d() {
        let through_active = VIEW_CAM.with(|c| c.get()).is_none();
        draw_rigs(app, &painter, &map, ectx, &selected, cam_state(ectx), through_active, None);
        let view = app.session.state.views3d.get(&cid).map(|v| v.current).unwrap_or_default();
        let label = match (view, comp.active_camera(time)) {
            (View3D::ActiveCamera, Some(c)) => crate::i18n::tr_args("Active Camera ({})", &[&c.name]),
            (v, _) => view3d_label(v).to_string(),
        };
        painter.text(area.left_top() + vec2(12.0, 10.0), Align2::LEFT_TOP, label, Tokens::ui(12.0), t.text_dim);
    }

    // Puppet pins and meshes of the selected layers (Puppet tools).
    // The selected layers with a Puppet effect, top of the stack first (the layers the Puppet
    // tools work on).
    if app.ui.tool.puppet_kind().is_some() {
        let sel_props: Vec<u64> = app.session.state.selected_props.iter().map(|(_, u)| *u).collect();
        for lid in &selected {
            if let Some(l) = comp.layer(*lid)
                && let Some(ov) = super::puppet_tool::overlay(app, &ctx, cid, l, time)
            {
                let hover = ui.input(|i| i.pointer.hover_pos());
                pin_hits.extend(super::puppet_tool::draw(&painter, &map, ectx, l, &ov, app.session.state.puppet.show_mesh, &sel_props, hover));
                puppet_layers.push((l, ov));
            }
        }
        puppet_layers.sort_by_key(|(l, _)| comp.index_of(l.id));
        for h in &pin_hits {
            app.auto.add(&format!("viewer.puppetPin.{}", h.pin), Rect::from_center_size(h.pos, vec2(10.0, 10.0)), "Puppet pin");
            if let Some(hp) = h.handle {
                let ring = h.pos + (h.pos - hp);
                app.auto.add(&format!("viewer.puppetPin.{}.rotate", h.pin), Rect::from_center_size(ring, vec2(6.0, 6.0)), "Rotate puppet pin");
                app.auto.add(&format!("viewer.puppetPin.{}.scale", h.pin), Rect::from_center_size(hp, vec2(6.0, 6.0)), "Scale puppet pin");
            }
        }
    }
    v.paths = paths;
    v.pin_hits = pin_hits;
    v.puppet_layers = puppet_layers;
    v.ft = ft;
}

fn phase_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) -> egui::Response {
    let cid = v.cid;
    let area = v.area;
    let map = v.map;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let comp = v.comp;
    // Project items, files and effects dropped on the viewer.
    super::viewer_drop::show(app, ui, &painter, &map, ectx);

    // Interaction.
    let resp = ui.interact(area, egui::Id::unique("viewer-interact"), Sense::click_and_drag());
    let menu_hits_id = egui::Id::unique(("viewer-menu-hits", cid.0));
    // A right-click an overlay took (the Cryptomatte eyedropper's) opens the menu too.
    let forwarded = ui.data_mut(|d| d.remove_temp::<egui::Pos2>(egui::Id::unique(FORWARDED_SECONDARY)));
    if let Some(pos) = resp.interact_pointer_pos().filter(|_| resp.secondary_clicked()).or(forwarded) {
        // The layer a left click there would select: the topmost one, keeping the group when it
        // is already selected (#1535), or the selected layer whose shown path is under the
        // pointer. The menu's list reaches the layers under it.
        if ov::segment_at(&v.paths, &map, pos, 6.0).is_none() {
            click_pick(app, ectx, map.to_comp(pos), false);
        }
        let point = map.to_comp(pos);
        let hits: Vec<(u64, String)> = layers_at(ectx, point).map(|l| (l.id.0, l.name.clone())).collect();
        ui.data_mut(|d| d.insert_temp(menu_hits_id, hits));
    }
    let context_layers: Vec<u64> =
        app.session.state.selected_layers.iter().filter(|id| comp.layer(**id).is_some_and(|l| !l.switches.locked)).map(|id| id.0).collect();
    let mut context_actions = Vec::new();
    let copy_frame = crate::i18n::label(app, "comp.copyFrame", "Copy Frame to Clipboard");
    let menu = egui::Popup::context_menu(&resp).style(crate::widgets::menu_style);
    let open = forwarded.map(|_| egui::containers::SetOpenCommand::Bool(true));
    if open.is_some() { menu.open_memory(open) } else { menu }.show(|ui| {
        let hits = ui.data(|d| d.get_temp::<Vec<(u64, String)>>(menu_hits_id)).unwrap_or_default();
        if !hits.is_empty() {
            ui.menu_button(crate::i18n::tr("Select"), |ui| {
                crate::widgets::menu_scroll(ui, false, |ui| {
                    for (id, name) in &hits {
                        if ui.button(name).clicked() {
                            context_actions.push(("layer.select".to_owned(), serde_json::json!({"layers":[id]})));
                            ui.close();
                        }
                    }
                })
            });
            ui.separator();
        }
        if context_layers.is_empty() {
            ui.label(crate::i18n::tr("No unlocked layer selected"));
        } else {
            let caps = context_layers.iter().filter_map(|id| comp.layer(effectcraft_engine::project::LayerId(*id))).fold(
                super::timeline::LayerMenuCaps::default(),
                |mut caps, layer| {
                    let c = super::timeline::LayerMenuCaps::of(&app.session.project, layer);
                    caps.vector |= c.vector;
                    caps.text |= c.text;
                    caps.source |= c.source;
                    caps
                },
            );
            super::timeline::layer_menu(ui, &context_layers, caps, (&mut app.auto, "viewer.layerMenu"), &mut context_actions);
        }
        ui.separator();
        if ui.button(copy_frame).clicked() {
            context_actions.push(("comp.copyFrame".to_owned(), serde_json::json!({"comp": cid.0})));
            ui.close();
        }
        // The comp this viewer shows, which is not always the active one.
        let settings = ui.button(crate::i18n::tr("Composition Settings…"));
        app.auto.add("viewer.context.settings", settings.rect, "Composition Settings…");
        if settings.clicked() {
            context_actions.push(("comp.settings".to_owned(), serde_json::json!({"comp": cid.0})));
            ui.close();
        }
    });
    for (id, params) in context_actions {
        if let Err(e) = crate::menus::invoke(app, &ctx, &id, params) {
            app.ui.status = e;
        }
    }
    resp
}

/// Frames to step when wheel scrubbing is on, or `None` when this gesture should zoom or pan.
/// A scrub notch's smoothed tail stays a scrub after the wheel event itself is gone, so that
/// tail does not zoom or pan (#1218).
fn wheel_scrub_frames(ctx: &egui::Context, pref: bool, scroll: &super::ViewerScroll) -> Option<i64> {
    let tail_id = egui::Id::unique("viewer-wheel-scrub-tail");
    let was_tail: bool = ctx.data(|d| d.get_temp(tail_id)).unwrap_or(false);
    let moving = scroll.pan != egui::Vec2::ZERO || (scroll.zoom - 1.0).abs() > 3e-4;
    let scrub = pref && !scroll.trackpad && !scroll.wheel_modified && (scroll.wheel_lines.abs() >= 0.01 || (was_tail && moving));
    ctx.data_mut(|d| {
        if scrub {
            d.insert_temp(tail_id, true);
        } else {
            d.remove::<bool>(tail_id);
        }
    });
    scrub.then_some((scroll.wheel_lines.round() as i64).clamp(-30, 30))
}

fn phase_hover(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
    let area = v.area;
    let zoom = v.zoom;
    let cw = v.cw;
    let ch = v.ch;
    let map = v.map;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let handle_hits = std::mem::take(&mut v.handle_hits);
    let axis_hits = std::mem::take(&mut v.axis_hits);
    let vertex_hits = std::mem::take(&mut v.vertex_hits);
    let key_hits = std::mem::take(&mut v.key_hits);
    let motion_frames = std::mem::take(&mut v.motion_frames);
    let paths = std::mem::take(&mut v.paths);
    let track_hits = std::mem::take(&mut v.track_hits);
    let pin_hits = std::mem::take(&mut v.pin_hits);
    let comp = v.comp;
    // Path vertices and tangent handles take the press before the bounding-box handles (#1042).
    let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
        let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
        vertex_hits.iter().rev().filter(|h| h.tangent.is_some() == tangents).find(|h| h.pos.distance(pos) < reach).copied()
    };
    let gid = egui::Id::unique("viewer-gesture");
    // An overlay on top of the viewer (e.g. the camera tracker points) takes the hover, but the pointer is still over the viewer: keep wheel zoom working.
    let hover_pos = resp.hover_pos().or_else(|| if resp.contains_pointer() { ui.input(|i| i.pointer.hover_pos()) } else { None });
    if let Some(hp) = hover_pos {
        app.pointer_comp = Some({
            let c = map.to_comp(hp);
            [c[0] as f32, c[1] as f32]
        });
        let cursor = match app.ui.tool {
            Tool::Hand => egui::CursorIcon::Grab,
            Tool::Zoom => egui::CursorIcon::ZoomIn,
            Tool::Type | Tool::TypeVertical => egui::CursorIcon::Text,
            Tool::Orbit => egui::CursorIcon::Alias,
            Tool::PanCamera => egui::CursorIcon::Move,
            Tool::Dolly => egui::CursorIcon::ResizeVertical,
            t if t.is_pen() => {
                pen_cursor(
                    &ctx,
                    hp,
                    pen_cursor_icon(t, ov::segment_at(&paths, &map, hp, 5.0).is_some() || ov::motion_frame_at(&motion_frames, &key_hits, hp).is_some()),
                );
                egui::CursorIcon::None
            }
            t if t.is_shape() => egui::CursorIcon::Crosshair,
            _ if app.ui.viewer.roi_draw => egui::CursorIcon::Crosshair,
            Tool::ObjectMatte => {
                // The tool draws its own crosshair (and the layer it would matte) while no box
                // is being dragged.
                if ui.data(|d| d.get_temp::<Gesture>(egui::Id::unique("viewer-gesture"))).is_none() {
                    super::object_matte_tool::hover(app, &painter, &map, ectx, hp);
                }
                egui::CursorIcon::None
            }
            t if t.puppet_kind().is_some() => match super::puppet_tool::hit(&pin_hits, hp) {
                Some((_, super::puppet_tool::PinPart::Ring)) => egui::CursorIcon::Alias,
                Some((_, super::puppet_tool::PinPart::Scale)) => egui::CursorIcon::ResizeNwSe,
                Some((h, _)) if h.kind == PinKind::Bend => egui::CursorIcon::PointingHand,
                Some(_) => egui::CursorIcon::Move,
                None => egui::CursorIcon::Crosshair,
            },
            _ => {
                if super::tracker::hit_at(&track_hits, hp).is_some() || key_hits.iter().any(|h| h.pos.distance(hp) < 6.0) {
                    egui::CursorIcon::Move
                } else if let Some((_, vertical)) = vt::guide_at(app, comp, &map, hp) {
                    if vertical { egui::CursorIcon::ResizeHorizontal } else { egui::CursorIcon::ResizeVertical }
                } else if vertex_at(hp, true).or_else(|| vertex_at(hp, false)).is_some() {
                    // A path point under a box handle is grabbed first: no resize cursor.
                    egui::CursorIcon::PointingHand
                } else if axis_at(&axis_hits, hp).is_some() {
                    egui::CursorIcon::Move
                } else if let Some((.., cursor)) = handle_hits.iter().find(|(_, _, h, _)| h.distance(hp) < HANDLE) {
                    *cursor
                } else {
                    egui::CursorIcon::Default
                }
            }
        };
        ctx.set_cursor_icon(cursor);
        // The mouse wheel and a trackpad pinch zoom around the pointer; a two-finger trackpad
        // scroll pans. With general.viewerWheelScrubbing, an unmodified wheel steps frames
        // instead, including the smoothed tail of that notch so it does not zoom or pan (#1218).
        let scroll = super::viewer_scroll(&ctx);
        let scrub = wheel_scrub_frames(&ctx, app.session.prefs.general.viewer_wheel_scrubbing, &scroll);
        if let Some(frames) = scrub {
            if frames != 0 && area.contains(hp) {
                if app.playback.playing {
                    let _ = crate::menus::invoke(app, &ctx, "playback.stop", json!({}));
                }
                let _ = app.session.execute("time.step", json!({"frames": frames}));
            }
        } else if scroll.pan != egui::Vec2::ZERO && area.contains(hp) {
            app.ui.viewer.pan = [app.ui.viewer.pan[0] + scroll.pan.x, app.ui.viewer.pan[1] + scroll.pan.y];
        }
        if scrub.is_none() && (scroll.zoom - 1.0).abs() > 3e-4 && area.contains(hp) {
            let nz = (zoom * scroll.zoom).clamp(0.01, 32.0);
            let before = map.to_comp(hp);
            let new_origin = hp - vec2(before[0] as f32 * nz, before[1] as f32 * nz);
            let new_center = new_origin + vec2(cw * nz / 2.0, ch * nz / 2.0);
            let pan = new_center - area.center();
            app.ui.viewer.zoom = Some(nz);
            app.ui.viewer.pan = [pan.x, pan.y];
        }
    } else {
        app.pointer_comp = None;
    }
    v.handle_hits = handle_hits;
    v.axis_hits = axis_hits;
    v.vertex_hits = vertex_hits;
    v.key_hits = key_hits;
    v.motion_frames = motion_frames;
    v.paths = paths;
    v.track_hits = track_hits;
    v.pin_hits = pin_hits;
    v.gid = gid;
}

fn phase_press(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
    let map = v.map;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let key_hits = std::mem::take(&mut v.key_hits);
    let motion_frames = std::mem::take(&mut v.motion_frames);
    let paths = std::mem::take(&mut v.paths);
    app.ui.viewer.interacting = resp.dragged();
    let mods = ui.input(|i| i.modifiers);
    let space_pan = super::space_hand(&ctx);
    // Pen tool: each press places a vertex (dragging pulls Bezier tangents); pressing on the
    // first vertex closes the path, pressing an open path's last vertex resumes it.
    if app.ui.tool == Tool::Pen
        && !space_pan
        && resp.hovered()
        && ui.input(|i| i.pointer.primary_pressed())
        && let Some(pos) = ui.input(|i| i.pointer.press_origin())
    {
        pen_press(app, ui, ectx, &map, &paths, ov::motion_frame_at(&motion_frames, &key_hits, pos), pos, mods);
    }
    // A pen click (press + release without a drag) ends its tangent gesture on release.
    if ui.input(|i| i.pointer.primary_released())
        && matches!(ui.data(|d| d.get_temp::<Gesture>(egui::Id::unique("viewer-gesture"))), Some(Gesture::Pen { .. }))
        && !resp.drag_stopped()
    {
        ui.data_mut(|d| d.remove::<Gesture>(egui::Id::unique("viewer-gesture")));
    }
    // On-canvas text editing (Type tool, double-click a text layer) owns its clicks and drags.
    let text_owns = super::viewer_text::hook(app, ui, &painter, &map, ectx, resp, space_pan);
    v.key_hits = key_hits;
    v.motion_frames = motion_frames;
    v.paths = paths;
    v.mods = mods;
    v.space_pan = space_pan;
    v.text_owns = text_owns;
}

/// A middle-drag pans with any tool and doesn't enter the gesture phases, so nothing else can
/// happen under it (#2854). A left-button gesture already running keeps going until it ends.
fn middle_pan(app: &mut EffectcraftApp, ui: &egui::Ui, resp: &egui::Response, v: &Vw<'_>) -> bool {
    let (middle, primary) = ui.input(|i| (i.pointer.middle_down(), i.pointer.primary_down() || i.pointer.primary_released()));
    if !middle || !resp.is_pointer_button_down_on() || (primary && ui.data(|d| d.get_temp::<Gesture>(v.gid)).is_some()) {
        return false;
    }
    // No left button: a stored gesture is one whose release the viewer missed.
    ui.data_mut(|d| d.remove::<Gesture>(v.gid));
    // Movement from before the press (in its frame) is not part of the drag.
    let d = ui.input(|i| if i.pointer.button_pressed(egui::PointerButton::Middle) { egui::Vec2::ZERO } else { i.pointer.delta() });
    if d != egui::Vec2::ZERO && d.x.is_finite() && d.y.is_finite() {
        app.ui.viewer.pan = [app.ui.viewer.pan[0] + d.x, app.ui.viewer.pan[1] + d.y];
    }
    v.ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
    true
}

/// One layer of a Move: its id, start Position and the Position's per-comp-axis weights.
type MoveLayer = (LayerId, [f64; 3], [f64; 3], [f64; 3]);

/// The merge key of the drag in progress: every step it writes folds into one undo step.
fn drag_merge_key(ui: &egui::Ui) -> String {
    format!("viewer-drag-{}", ui.data(|d| d.get_temp::<u64>(egui::Id::unique("viewer-drag-n")).unwrap_or(0)))
}

/// Duplicate the layers of an Alt-drag (`edit.duplicate`, selecting the copies) and return the move
/// entries re-pointed at the copies. If the duplicate fails the originals are dragged as they were.
fn alt_duplicate(app: &mut EffectcraftApp, ui: &egui::Ui, layers: Vec<MoveLayer>) -> Vec<MoveLayer> {
    let ids: Vec<u64> = layers.iter().map(|l| l.0.0).collect();
    // A key left over from the previous drag would fold this copy into that drag's undo step.
    app.session.history.merge_key = None;
    let made = app.session.execute("edit.duplicate", json!({"layers": ids, "merge": drag_merge_key(ui)}));
    let Ok(copies) = made.map(|v| serde_json::from_value::<Vec<u64>>(v).unwrap_or_default()) else { return layers };
    layers.into_iter().zip(copies).map(|((_, p0, ax, ay), copy)| (LayerId(copy), p0, ax, ay)).collect()
}

/// For each layer of a Move, whether one of its ancestors is in the Move as well: it follows that
/// parent, so its own Position must not get the drag too. The copies `alt_duplicate` makes keep
/// this order and are parented to each other the same way.
fn led_by_a_moved_ancestor(comp: &Comp, layers: &[MoveLayer]) -> Vec<bool> {
    let moved: std::collections::HashSet<LayerId> = layers.iter().map(|l| l.0).collect();
    let led = |id: LayerId| {
        let mut up = comp.layer(id).and_then(|l| l.parent);
        // (bounded: a parent cycle in a broken file must not hang the viewer)
        for _ in 0..comp.layers.len() {
            let Some(p) = up else { return false };
            if moved.contains(&p) {
                return true;
            }
            up = comp.layer(p).and_then(|l| l.parent);
        }
        false
    };
    layers.iter().map(|l| led(l.0)).collect()
}

/// Starts the gesture a new primary drag begins (pan, move, scale, a handle, a vertex, a marquee),
/// unless an overlay claimed the press.
fn phase_dragstart(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
    let comp_rect = v.comp_rect;
    let zoom = v.zoom;
    let map = v.map;
    let time = v.time;
    let mods = v.mods;
    let space_pan = v.space_pan;
    let text_owns = v.text_owns;
    let gid = v.gid;
    let track_cur = v.track_cur;
    let ft = std::mem::take(&mut v.ft);
    let handle_hits = std::mem::take(&mut v.handle_hits);
    let axis_hits = std::mem::take(&mut v.axis_hits);
    let vertex_hits = std::mem::take(&mut v.vertex_hits);
    let key_hits = std::mem::take(&mut v.key_hits);
    let paths = std::mem::take(&mut v.paths);
    let track_hits = std::mem::take(&mut v.track_hits);
    let pin_hits = std::mem::take(&mut v.pin_hits);
    let puppet_layers = std::mem::take(&mut v.puppet_layers);
    let comp = v.comp;
    let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
        let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
        vertex_hits.iter().rev().filter(|h| h.tangent.is_some() == tangents).find(|h| h.pos.distance(pos) < reach).copied()
    };
    let puppet_layer = |app: &mut EffectcraftApp, cpt: [f64; 2]| -> Option<LayerId> {
        if puppet_layers.is_empty() {
            return pick(app, ectx, cpt, false);
        }
        super::puppet_tool::target(ectx, &puppet_layers, cpt, |l| {
            layers_at(ectx, cpt).any(|h| h.id == l.id) && super::puppet_tool::takes_pin(app, ectx, l, cpt)
        })
    };
    if resp.drag_started()
        && !text_owns
        && !press_claimed(ui.ctx())
        && let Some(pos) = resp.interact_pointer_pos()
    {
        let cpt = map.to_comp(pos);
        let press = ui.input(|i| i.pointer.press_origin()).unwrap_or(pos);
        let tool = if space_pan { Tool::Hand } else { app.ui.tool };
        let g = match tool {
            Tool::Hand => Some(Gesture::Pan { start_pan: app.ui.viewer.pan }),
            // Region of Interest armed: the drag draws it.
            _ if app.ui.viewer.roi_draw => Some(Gesture::Overlay(ov::Drag::Roi { start: map.to_comp(press), keep: [None, None] })),
            // A region of interest handle: resize it from the opposite corner / edge.
            _ if roi_drag(app, &map, comp_rect, zoom, press).is_some() => roi_drag(app, &map, comp_rect, zoom, press).map(Gesture::Overlay),
            Tool::Selection if ft.as_ref().and_then(|f| ov::begin_ft_drag(f, press, &map)).is_some() => {
                ft.as_ref().and_then(|f| ov::begin_ft_drag(f, press, &map)).map(Gesture::Overlay)
            }
            Tool::Selection if key_hits.iter().any(|h| h.pos.distance(press) < 6.0) => {
                ov::begin_key_drag(app, &key_hits, press, map.to_comp(press), mods.shift).map(Gesture::Overlay)
            }
            Tool::Selection if vt::guide_at(app, comp, &map, press).is_some() => {
                vt::guide_at(app, comp, &map, press).map(|(index, vertical)| Gesture::Overlay(ov::Drag::Guide { index, vertical }))
            }
            // Alt-drag a vertex with the Selection tool (or drag one with Convert Vertex): pull
            // new tangents out of it.
            Tool::Selection | Tool::PenConvert if (mods.alt || tool == Tool::PenConvert) && vertex_at(press, false).is_some() => {
                vertex_at(press, false).map(|h| {
                    let inv = h.l2c.inverse().unwrap_or(Mat3::IDENTITY);
                    Gesture::Pen { layer: h.layer, mask: h.mask, index: h.index, vertex: h.vertex, inv, press }
                })
            }
            Tool::MaskFeather => ov::begin_feather(app, ectx, &paths, &map, press).map(Gesture::Overlay),
            // The layer under the press is the one that turns.
            Tool::Rotate => pick(app, ectx, map.to_comp(press), mods.shift).map(|l| {
                let layer = comp.layer(l).cloned();
                let sign = layer.as_ref().map_or(1.0, |l| rotation_sign(ectx, l));
                let others = selected_others(app, comp, l)
                    .into_iter()
                    .filter_map(|o| Some((o.id, ectx.f(o, o.transform()?, "rotation", 0.0), rotation_sign(ectx, o) * sign)))
                    .collect();
                let anchor = layer.as_ref().and_then(|l| anchor_in_comp(ectx, l));
                let pivot = anchor.unwrap_or(cpt);
                let rot = layer.as_ref().and_then(|l| l.transform().map(|tr| ectx.f(l, tr, "rotation", 0.0))).unwrap_or(0.0);
                // The turn counts from where the button went down, as in After Effects: by the
                // time the drag registers the pointer has already swept some way round the anchor.
                // A press on the anchor (or with no anchor to turn about) has no direction, so
                // the turn then counts from where the drag registered.
                let seed = if anchor.is_some() && press.distance(map.to_screen(pivot)) > 3.0 { map.to_comp(press) } else { cpt };
                let last_angle = (seed[1] - pivot[1]).atan2(seed[0] - pivot[0]).to_degrees();
                Gesture::Rotate { layer: l, pivot, sign, last_angle, turned: 0.0, start_rot: rot, others }
            }),
            Tool::PanBehind => pick(app, ectx, cpt, false).and_then(|l| {
                let layer = comp.layer(l)?;
                let tr = layer.transform()?;
                let (l2c, _) = l2c(ectx, layer);
                let l2p = ectx.local_matrix(layer);
                let l2p = Mat3([[l2p.0[0][0], l2p.0[0][1], 0.0], [l2p.0[1][0], l2p.0[1][1], 0.0], [0.0, 0.0, 1.0]]);
                Some(Gesture::Anchor {
                    layer: l,
                    start_anchor: ectx.v3(layer, tr, "anchor", [0.0; 3]),
                    start_pos: ectx.v3(layer, tr, "position", [0.0; 3]),
                    // From where the button went down (the drag starts a few points later).
                    start: map.to_comp(press),
                    inv: l2c.inverse().unwrap_or(Mat3::IDENTITY),
                    l2p,
                    own: effectcraft_engine::viewer::layer_targets(ectx, layer, false, app.session.state.snap_features),
                    anchor_only: mods.alt,
                })
            }),
            // From where the button went down: by the time the pointer has moved far enough to
            // count as a drag it has already left the press point, and the shape is drawn there.
            t if t.is_shape() => Some(Gesture::Create { tool: t, start: map.to_comp(press) }),
            Tool::ObjectMatte => Some(Gesture::ObjectMatteBox { start: press }),
            t if t.puppet_kind().is_some() && super::puppet_tool::hit(&pin_hits, press).is_none() => {
                // Off the pins: Alt or a press outside the art drags a marquee that selects pins. Asked
                // of where the button went down: the pointer may be over the art by the time this is a drag.
                (mods.alt || puppet_layer(app, map.to_comp(press)).is_none()).then_some(Gesture::PinMarquee { start: press })
            }
            t if t.puppet_kind().is_some() => super::puppet_tool::hit(&pin_hits, press).and_then(|(h, part)| {
                use super::puppet_tool::PinPart;
                let angle = (press - h.pos).angle();
                match part {
                    PinPart::Ring => return Some(Gesture::PuppetRotate { layer: h.layer, pin: h.pin, center: h.pos, last: angle, rotation: h.rotation }),
                    PinPart::Scale => {
                        let start = h.pos.distance(press).max(1.0);
                        return Some(Gesture::PuppetScale { layer: h.layer, pin: h.pin, center: h.pos, start, scale: h.scale });
                    }
                    // A Bend pin has no position: it turns and scales by its ring only.
                    PinPart::Center if h.kind == PinKind::Bend => return None,
                    PinPart::Center => {}
                }
                let l = comp.layer(h.layer)?;
                let inv = fx2c(ectx, l).inverse()?;
                if mods.command {
                    let lp = inv.apply(gv2(cpt[0], cpt[1]));
                    let began = ui.input(|i| i.time);
                    // Dragging one of several selected pins records them all.
                    let sel = &app.session.state.selected_props;
                    let others: Vec<u64> = if sel.contains(&(h.layer, h.pin)) {
                        pin_hits.iter().filter(|o| o.layer == h.layer && o.pin != h.pin && sel.contains(&(o.layer, o.pin))).map(|o| o.pin).collect()
                    } else {
                        vec![]
                    };
                    return Some(Gesture::PuppetRecord { layer: h.layer, pin: h.pin, others, inv, began, cti: time, samples: vec![(0.0, [lp.x, lp.y])] });
                }
                Some(Gesture::PuppetPin { layer: h.layer, pin: h.pin, inv })
            }),
            Tool::Orbit | Tool::PanCamera | Tool::Dolly => Some(Gesture::Camera { tool }),
            Tool::Selection if super::tracker::hit_at(&track_hits, press).is_some() => {
                let hit = super::tracker::hit_at(&track_hits, press);
                track_cur.zip(hit).and_then(|((tl, tu), hit)| {
                    let layer = comp.layer(tl)?;
                    let (m, _) = l2c(ectx, layer);
                    super::tracker::begin_drag(layer, tu, time, &m, hit, map.to_comp(press)).map(|drag| Gesture::Track { layer: tl, tracker: tu, drag })
                })
            }
            Tool::Selection if vertex_at(press, true).is_some() => vertex_at(press, true).map(|h| Gesture::Tangent {
                layer: h.layer,
                mask: h.mask,
                index: h.index,
                out: h.tangent == Some(true),
                vertex: h.vertex,
                inv: h.l2c.inverse().unwrap_or(Mat3::IDENTITY),
            }),
            Tool::Selection if vertex_at(press, false).is_some() => vertex_at(press, false).map(|h| {
                let me = json!({"layer": h.layer.0, "mask": h.mask, "index": h.index});
                let selected = app.session.state.selected_vertices.iter().any(|v| v.layer == h.layer && v.mask == h.mask && v.index == h.index);
                if !selected {
                    let _ = app.session.execute("mask.selectVertices", json!({"vertices": [me], "add": mods.shift}));
                }
                let src = h.l2c.apply(gv2(h.vertex[0], h.vertex[1]));
                Gesture::Vertices {
                    start: map.to_comp(press),
                    src: [src.x, src.y],
                    applied: [0.0; 2],
                    inv: h.l2c.inverse().unwrap_or(Mat3::IDENTITY),
                    layer: h.layer,
                }
            }),
            // Everything starts where the button went down: by the time the pointer has moved
            // far enough to count as a drag it may have left a small handle.
            Tool::Selection => {
                let cpt = map.to_comp(press);
                // A gizmo arrow is drawn over the box handles, so it is grabbed first: move along
                // that axis only, without snapping.
                if let Some((lid, _, ax, ay)) = axis_at(&axis_hits, press) {
                    let p0 = comp.layer(lid).and_then(|l| Some(ectx.v3(l, l.transform()?, "position", [0.0; 3])));
                    p0.map(|p0| {
                        // Alt duplicates the layer and moves the copy along the axis.
                        let layers = vec![(lid, p0, ax, ay)];
                        let layers = if mods.alt { alt_duplicate(app, ui, layers) } else { layers };
                        Gesture::Move { layers, start: cpt, snap_src: None }
                    })
                } else if let Some((lid, hi, ..)) = handle_hits.iter().find(|(_, _, h, _)| h.distance(press) < HANDLE + 2.0).cloned() {
                    let layer = comp.layer(lid).cloned();
                    layer.and_then(|layer| {
                        let tr = layer.transform()?;
                        let (l2c, _) = l2c(ectx, &layer);
                        let inv = l2c.inverse()?;
                        let a = ectx.v3(&layer, tr, "anchor", [0.0; 3]);
                        let lp = inv.apply(gv2(cpt[0], cpt[1]));
                        let hp = handle_point(effectcraft_engine::render::content_bounds(ectx, &layer)?, hi);
                        Some(Gesture::Scale {
                            layer: lid,
                            start_scale: ectx.v3(&layer, tr, "scale", [100.0; 3]),
                            start_local: [lp.x - a[0], lp.y - a[1]],
                            handle: [hp[0] - a[0], hp[1] - a[1]],
                            anchor: [a[0], a[1]],
                            axes: handle_axes(hi),
                            l2c,
                            inv,
                            others: selected_others(app, comp, lid)
                                .into_iter()
                                .filter_map(|o| Some((o.id, ectx.v3(o, o.transform()?, "scale", [100.0; 3]))))
                                .collect(),
                        })
                    })
                } else if let Some(l) = pick(app, ectx, cpt, mods.shift) {
                    let layers: Vec<MoveLayer> = app
                        .session
                        .state
                        .selected_layers
                        .iter()
                        .filter_map(|id| comp.layer(*id))
                        .filter(|l| !l.switches.locked)
                        .filter_map(|l| {
                            let p0 = ectx.v3(l, l.transform()?, "position", [0.0; 3]);
                            let (ax, ay) = drag_axes(ectx, l);
                            Some((l.id, p0, ax, ay))
                        })
                        .collect();
                    // Snap the grabbed layer's feature nearest the pointer (AE's snap handle).
                    let snap_src = comp.layer(l).map(|layer| effectcraft_engine::viewer::layer_features(ectx, layer)).and_then(|f| {
                        let c = map.to_comp(press);
                        f.into_iter().min_by(|a, b| {
                            let da = (a[0] - c[0]).powi(2) + (a[1] - c[1]).powi(2);
                            let db = (b[0] - c[0]).powi(2) + (b[1] - c[1]).powi(2);
                            da.total_cmp(&db)
                        })
                    });
                    // A layer whose parent (or grandparent…) is dragged too rides along with it:
                    // moving it as well would add the drag twice. It is still duplicated.
                    let led = led_by_a_moved_ancestor(comp, &layers);
                    // Alt-drag duplicates the dragged layers and moves the copies; the copy and the
                    // drag are one undo step.
                    let layers = if mods.alt && !layers.is_empty() { alt_duplicate(app, ui, layers) } else { layers };
                    let layers: Vec<MoveLayer> = layers.into_iter().zip(led).filter(|(_, led)| !led).map(|(l, _)| l).collect();
                    (!layers.is_empty()).then_some(Gesture::Move { layers, start: map.to_comp(press), snap_src })
                } else {
                    // With path vertices on screen the marquee selects vertices (layers stay
                    // selected); otherwise it starts from a clean selection.
                    if !mods.shift && !vertex_hits.iter().any(|h| h.tangent.is_none()) {
                        let _ = app.session.execute("edit.deselectAll", json!({}));
                    }
                    Some(Gesture::Marquee { start: press })
                }
            }
            // The Roto Brush paints in the Layer panel only: say so instead of doing nothing.
            rt if rt.roto_kind(false).is_some() => {
                app.ui.status = crate::i18n::tr(ROTO_HINT).to_string();
                None
            }
            _ => None,
        };
        if let Some(g) = g {
            ui.data_mut(|d| d.insert_temp(gid, g));
        }
    }
    v.ft = ft;
    v.handle_hits = handle_hits;
    v.axis_hits = axis_hits;
    v.vertex_hits = vertex_hits;
    v.key_hits = key_hits;
    v.paths = paths;
    v.track_hits = track_hits;
    v.pin_hits = pin_hits;
    v.puppet_layers = puppet_layers;
}

/// Auto-pan (#999): a mask vertex, tangent or Pen drag held at (or past) the edge of the view
/// pans it, as in After Effects, so the point moves on past what was visible. Returns the map
/// of the panned view.
fn edge_pan(app: &mut EffectcraftApp, ctx: &egui::Context, g: &Gesture, map: ViewerMap, pos: Pos2) -> ViewerMap {
    if !matches!(g, Gesture::Vertices { .. } | Gesture::Tangent { .. } | Gesture::Pen { .. }) {
        return map;
    }
    let d = edge_pan_speed(map.area, pos) * ctx.input(|i| i.stable_dt).min(0.1);
    if d == egui::Vec2::ZERO {
        return map;
    }
    app.ui.viewer.pan = [app.ui.viewer.pan[0] + d.x, app.ui.viewer.pan[1] + d.y];
    ctx.request_repaint();
    ViewerMap { origin: map.origin + d, ..map }
}

/// How fast (points per second, per axis) the view pans under a drag at `pos`: within 24 points
/// of an edge of `area`, or past it, toward that edge and faster the further out.
fn edge_pan_speed(area: Rect, pos: Pos2) -> egui::Vec2 {
    const ZONE: f32 = 24.0;
    let axis = |p: f32, lo: f32, hi: f32| {
        let depth = if p < lo + ZONE {
            lo + ZONE - p
        } else if p > hi - ZONE {
            hi - ZONE - p
        } else {
            0.0
        };
        (depth / ZONE).clamp(-3.0, 3.0) * 400.0
    };
    vec2(axis(pos.x, area.min.x, area.max.x), axis(pos.y, area.min.y, area.max.y))
}

fn phase_drag(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
    let t = v.t;
    let zoom = v.zoom;
    let map = v.map;
    let mods = v.mods;
    let gid = v.gid;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let gesture: Option<Gesture> = ui.data(|d| d.get_temp(gid));
    if let (Some(g), Some(pos)) = (gesture.clone(), resp.interact_pointer_pos()) {
        let map = edge_pan(app, &ctx, &g, map, pos);
        let cpt = map.to_comp(pos);
        let merge = drag_merge_key(ui);
        match g {
            Gesture::Pan { start_pan } => {
                // No total drag on the release frame: keep the pan reached so far (it used to
                // snap back to where the drag began).
                if let Some(d) = resp.total_drag_delta() {
                    app.ui.viewer.pan = [start_pan[0] + d.x, start_pan[1] + d.y];
                }
            }
            Gesture::Move { layers, start, snap_src } => {
                let raw = [cpt[0] - start[0], cpt[1] - start[1]];
                let mut d = one_axis(raw, mods.shift);
                if let Some(src) = snap_src {
                    let ids: Vec<LayerId> = layers.iter().map(|x| x.0).collect();
                    // Shift: only the coordinate along the axis snaps, so the layer stays on it (#3229).
                    let q = vt::SnapQuery { exclude: &ids, sources: &[[src[0] + d[0], src[1] + d[1]]], mods, extra: &[], along_x: drag_axis(raw, mods.shift) };
                    let c = vt::snap_with(app, &ctx, ectx, &map, &q);
                    d = [d[0] + c[0], d[1] + c[1]];
                    if vt::snapping_on(app, mods) {
                        vt::draw_handle(&painter, map.to_screen([src[0] + d[0], src[1] + d[1]]));
                    }
                }
                for (lid, p0, ax, ay) in layers {
                    let v = json!([p0[0] + ax[0] * d[0] + ay[0] * d[1], p0[1] + ax[1] * d[0] + ay[1] * d[1], p0[2] + ax[2] * d[0] + ay[2] * d[1]]);
                    let _ = app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/position", "value": v, "merge": merge}));
                }
            }
            Gesture::Scale { layer, start_scale, start_local, handle, anchor, axes, l2c, inv, others } => {
                let lp = inv.apply(gv2(cpt[0], cpt[1]));
                let uniform = mods.shift && axes == [true, true];
                let f = drag_ratio(start_local, [lp.x - anchor[0], lp.y - anchor[1]], axes, uniform);
                // The handle snaps (to the comp's and other layers' edges, corners and centres),
                // so a layer scales exactly to them, e.g. to the comp's size.
                let f = snap_handle(f, handle, anchor, &l2c, axes, uniform, |p| vt::snap(app, &ctx, ectx, &map, &[layer], &[p], mods));
                for (lid, s0) in std::iter::once((layer, start_scale)).chain(others) {
                    let v = [s0[0] * f[0], s0[1] * f[1], s0[2]];
                    let _ = app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/scale", "value": v, "merge": merge}));
                }
            }
            Gesture::Rotate { layer, pivot, sign, last_angle, turned, start_rot, others } => {
                // Count the turn incrementally: the absolute angle wraps at ±180°, so writing it
                // straight would jump a revolution back each time the pointer went round.
                let ang = (cpt[1] - pivot[1]).atan2(cpt[0] - pivot[0]).to_degrees();
                let turned = turned + sign * turn_delta(last_angle, ang);
                ui.data_mut(|dd| dd.insert_temp(gid, Gesture::Rotate { layer, pivot, sign, last_angle: ang, turned, start_rot, others: others.clone() }));
                // Shift snaps the accumulated value (so 405° snaps to 1x +45°, not to 45°).
                let r = rotate_value(start_rot, turned, mods.shift);
                let _ = app.session.execute("prop.set", json!({"layer": layer.0, "path": "transform/rotation", "value": r, "merge": merge}));
                for (lid, r0, other) in others {
                    let v = r0 + other * (r - start_rot);
                    let _ = app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/rotation", "value": v, "merge": merge}));
                }
            }
            Gesture::Anchor { layer, start_anchor, start_pos, start, inv, l2p, own, anchor_only } => {
                // Pan Behind snaps the anchor point (to its own layer's box, other layers' features,
                // guides and the grid); Shift keeps the move to one axis.
                let raw = [cpt[0] - start[0], cpt[1] - start[1]];
                let d = one_axis(raw, mods.shift);
                let anchor_c = inv.inverse().map(|m| m.apply(gv2(start_anchor[0], start_anchor[1]))).unwrap_or(gv2(start[0], start[1]));
                let want = [anchor_c.x + d[0], anchor_c.y + d[1]];
                let q = vt::SnapQuery { exclude: &[layer], sources: &[want], mods, extra: &own, along_x: drag_axis(raw, mods.shift) };
                let sc = vt::snap_with(app, &ctx, ectx, &map, &q);
                let a = inv.apply(gv2(start[0], start[1]));
                let b = inv.apply(gv2(start[0] + d[0] + sc[0], start[1] + d[1] + sc[1]));
                let dl = gv2(b.x - a.x, b.y - a.y);
                let na = [start_anchor[0] + dl.x, start_anchor[1] + dl.y, start_anchor[2]];
                let _ = app.session.execute("prop.set", json!({"layer": layer.0, "path": "transform/anchor", "value": na, "merge": merge}));
                // Position follows so the layer stays put, unless Alt moves the anchor point alone.
                if !anchor_only {
                    let dp = l2p.apply_vec(dl);
                    let np = [start_pos[0] + dp.x, start_pos[1] + dp.y, start_pos[2]];
                    let _ = app.session.execute("prop.set", json!({"layer": layer.0, "path": "transform/position", "value": np, "merge": merge}));
                }
            }
            Gesture::Camera { tool } => {
                let d = resp.drag_delta();
                if d != egui::Vec2::ZERO {
                    let (dx, dy) = ((d.x / zoom) as f64, (d.y / zoom) as f64);
                    let (id, params) = match tool {
                        Tool::Orbit => ("camera.orbit", json!({"yaw": -d.x as f64 * 0.4, "pitch": d.y as f64 * 0.4, "merge": merge})),
                        Tool::PanCamera => ("camera.pan", json!({"dx": dx, "dy": dy, "merge": merge})),
                        _ => ("camera.dolly", json!({"amount": -dy * 2.0, "merge": merge})),
                    };
                    if let Err(e) = app.session.execute(id, params) {
                        app.ui.status = e.to_string();
                    }
                }
            }
            Gesture::Create { tool, start } => {
                if let Some(d) = shape_drag(app, tool, start, cpt, mods) {
                    draw_shape_ghost(&painter, &map, app, &d, &t);
                }
            }
            Gesture::Vertices { start, src, applied, inv, layer } => {
                // The grabbed vertex snaps (to other layers' vertices and features, guides, grid);
                // Shift keeps it to one axis, as a layer move does (#1964), snapping too (#3229).
                let raw = [cpt[0] - start[0], cpt[1] - start[1]];
                let want = one_axis(raw, mods.shift);
                let at = [src[0] + want[0], src[1] + want[1]];
                let q = vt::SnapQuery { exclude: &[layer], sources: &[at], mods, extra: &[], along_x: drag_axis(raw, mods.shift) };
                let c = vt::snap_with(app, &ctx, ectx, &map, &q);
                let total = [want[0] + c[0], want[1] + c[1]];
                let d = inv.apply_vec(gv2(total[0] - applied[0], total[1] - applied[1]));
                if d.x != 0.0 || d.y != 0.0 {
                    let _ = app.session.execute("mask.moveVertices", json!({"delta": [d.x, d.y], "merge": merge}));
                }
                ui.data_mut(|dd| dd.insert_temp(gid, Gesture::Vertices { start, src, applied: total, inv, layer }));
            }
            Gesture::Overlay(d) => match d {
                ov::Drag::Guide { index, vertical } => {
                    let pos_v = if vertical { cpt[0] } else { cpt[1] }.round();
                    let _ = app.session.execute("view.moveGuide", json!({"index": index, "position": pos_v, "merge": merge}));
                }
                ov::Drag::Roi { start, keep } => {
                    let e = [keep[0].unwrap_or(cpt[0]), keep[1].unwrap_or(cpt[1])];
                    let r = Rect::from_two_pos(map.to_screen(start), map.to_screen(e));
                    painter.rect_stroke(r, 0.0, Stroke::new(1.0, Color32::WHITE), StrokeKind::Middle);
                }
                d => {
                    let mut snapper = |a: &EffectcraftApp, p: [f64; 2], l: LayerId| vt::snap(a, &ctx, ectx, &map, &[l], &[p], mods);
                    if let Some(nd) = ov::update(app, &d, cpt, pos, mods, &merge, zoom, &mut snapper) {
                        ui.data_mut(|dd| dd.insert_temp(gid, Gesture::Overlay(nd)));
                    }
                }
            },
            Gesture::Tangent { layer, mask, index, out, vertex, inv } => {
                let lp = inv.apply(gv2(cpt[0], cpt[1]));
                let t = [lp.x - vertex[0], lp.y - vertex[1]];
                let mut params = json!({"layer": layer.0, "mask": mask, "index": index, "merge": merge});
                params[if out { "out" } else { "in" }] = json!(t);
                if !mods.alt {
                    params[if out { "in" } else { "out" }] = json!([-t[0], -t[1]]);
                }
                let _ = app.session.execute("mask.setVertex", params);
            }
            Gesture::PuppetRecord { layer, pin, others, inv, began, cti, mut samples } => {
                let lp = inv.apply(gv2(cpt[0], cpt[1]));
                let now = ui.input(|i| i.time) - began;
                if samples.last().is_none_or(|s| now > s.0) {
                    samples.push((now, [lp.x, lp.y]));
                }
                // The current time runs with the recording (Record Options ▸ Speed).
                let speed = app.session.state.puppet.record_speed.max(1.0) / 100.0;
                app.session.set_time(cti + Tick::from_seconds_f64(now / speed));
                painter.circle_filled(pos, 6.0, Color32::from_rgb(0xe0, 0x30, 0x30));
                painter.text(pos + vec2(10.0, -10.0), Align2::LEFT_BOTTOM, crate::i18n::tr("Recording"), Tokens::ui(11.0), Color32::from_rgb(0xff, 0x60, 0x60));
                ui.data_mut(|dd| dd.insert_temp(gid, Gesture::PuppetRecord { layer, pin, others, inv, began, cti, samples }));
                ui.ctx().request_repaint();
            }
            Gesture::PuppetRotate { layer, pin, center, last, rotation } => {
                // Accumulate the turn since the last frame (wrapped to ±180°) so a drag can go
                // past a full revolution; Shift snaps to 15°.
                let a = (pos - center).angle();
                let mut d = (a - last) as f64;
                d = (d + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI;
                let rotation = rotation + d.to_degrees();
                let deg = if mods.shift { (rotation / 15.0).round() * 15.0 } else { rotation };
                ui.data_mut(|dd| dd.insert_temp(gid, Gesture::PuppetRotate { layer, pin, center, last: a, rotation }));
                if let Err(e) = app.session.execute("puppet.setPin", json!({"layer": layer.0, "pin": pin, "rotation": deg, "merge": merge})) {
                    app.ui.status = e.to_string();
                }
            }
            Gesture::PuppetScale { layer, pin, center, start, scale } => {
                // Shift snaps the scale to 5 % steps.
                let pct = scale * (pos.distance(center) / start) as f64 * 100.0;
                let pct = if mods.shift { (pct / 5.0).round() * 5.0 } else { pct }.max(1.0);
                if let Err(e) = app.session.execute("puppet.setPin", json!({"layer": layer.0, "pin": pin, "scale": pct, "merge": merge})) {
                    app.ui.status = e.to_string();
                }
            }
            Gesture::PuppetPin { layer, pin, inv } => {
                let lp = inv.apply(gv2(cpt[0], cpt[1]));
                if let Err(e) = app.session.execute("puppet.movePin", json!({"layer": layer.0, "pin": pin, "position": [lp.x, lp.y], "merge": merge})) {
                    app.ui.status = e.to_string();
                }
            }
            Gesture::Pen { layer, mask, index, vertex, inv, press } => {
                if pos.distance(press) > 3.0 {
                    let lp = inv.apply(gv2(cpt[0], cpt[1]));
                    let t = [lp.x - vertex[0], lp.y - vertex[1]];
                    let _ = app
                        .session
                        .execute("mask.setVertex", json!({"layer": layer.0, "mask": mask, "index": index, "out": t, "in": [-t[0], -t[1]], "merge": merge}));
                }
            }
            Gesture::Track { layer, tracker, drag } => {
                let mut q = super::tracker::drag_params(&drag, cpt);
                q["layer"] = json!(layer.0);
                q["tracker"] = json!(tracker);
                q["merge"] = json!(merge);
                let _ = app.session.execute("track.setPoint", q);
            }
            Gesture::ObjectMatteBox { start } => super::object_matte_tool::draw_box(app, &painter, start, pos),
            Gesture::Marquee { start } | Gesture::PinMarquee { start } => {
                let r = Rect::from_two_pos(start, pos);
                painter.rect_filled(r, 0.0, t.accent.gamma_multiply(0.12));
                painter.rect_stroke(r, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Middle);
            }
        }
    }
    v.gesture = gesture;
}

fn phase_stopped(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
    let area = v.area;
    let comp_rect = v.comp_rect;
    let map = v.map;
    let time = v.time;
    let mods = v.mods;
    let gid = v.gid;
    let vertex_hits = std::mem::take(&mut v.vertex_hits);
    let pin_hits = std::mem::take(&mut v.pin_hits);
    let gesture = v.gesture.clone();
    let comp = v.comp;
    if resp.drag_stopped() {
        if let (Some(g), Some(pos)) = (gesture, resp.interact_pointer_pos()) {
            match g {
                Gesture::PinMarquee { start } => {
                    // Pins inside the box, per layer; Shift adds to the selection.
                    let r = Rect::from_two_pos(start, pos);
                    let mut first = !mods.shift;
                    let mut layers: Vec<LayerId> = pin_hits.iter().map(|h| h.layer).collect();
                    layers.dedup();
                    if first && pin_hits.iter().all(|h| !r.contains(h.pos)) {
                        let _ = app.session.execute("puppet.selectPins", json!({"pins": []}));
                    }
                    for l in layers {
                        let pins: Vec<u64> = pin_hits.iter().filter(|h| h.layer == l && r.contains(h.pos)).map(|h| h.pin).collect();
                        if !pins.is_empty() {
                            let _ = app.session.execute("puppet.selectPins", json!({"layer": l.0, "pins": pins, "add": !first}));
                            first = false;
                        }
                    }
                }
                Gesture::PuppetRecord { layer, pin, others, cti, samples, .. } => {
                    let pts: Vec<serde_json::Value> = samples.iter().map(|(t, p)| json!([t, p[0], p[1]])).collect();
                    let q = json!({"layer": layer.0, "pin": pin, "pins": others, "samples": pts, "start": cti.seconds()});
                    match app.session.execute("puppet.recordPin", q) {
                        Ok(_) => {
                            for p in std::iter::once(pin).chain(others) {
                                super::puppet_tool::reveal_pin(app, layer, p);
                            }
                        }
                        Err(e) => app.ui.status = e.to_string(),
                    }
                }
                Gesture::PuppetPin { layer, pin, .. } => super::puppet_tool::reveal_pin(app, layer, pin),
                Gesture::ObjectMatteBox { start } => super::object_matte_tool::apply(app, ectx, &map, start, Some(pos), mods.shift),
                Gesture::Create { tool, start } => {
                    let end = map.to_comp(pos);
                    create_shape(app, tool, start, end, mods);
                }
                Gesture::Overlay(ov::Drag::Roi { start, keep }) => {
                    let c = map.to_comp(pos);
                    let end = [keep[0].unwrap_or(c[0]), keep[1].unwrap_or(c[1])];
                    let (x0, y0) = (start[0].min(end[0]).max(0.0), start[1].min(end[1]).max(0.0));
                    let (x1, y1) = (start[0].max(end[0]).min(comp.width as f64), start[1].max(end[1]).min(comp.height as f64));
                    if x1 - x0 >= 2.0 && y1 - y0 >= 2.0 {
                        let rect = [x0.round(), y0.round(), (x1 - x0).round(), (y1 - y0).round()];
                        let _ = app.session.execute("view.setRegionOfInterest", json!({"rect": rect}));
                    }
                    app.ui.viewer.roi_draw = false;
                }
                // A guide dragged off the image (back to the rulers) is removed.
                Gesture::Overlay(ov::Drag::Guide { index, .. }) if !area.contains(pos) || !comp_rect.expand(40.0).contains(pos) => {
                    let _ = app.session.execute("view.removeGuide", json!({"index": index}));
                }
                Gesture::Marquee { start } if vertex_hits.iter().any(|h| h.tangent.is_none() && Rect::from_two_pos(start, pos).contains(h.pos)) => {
                    // Marquee over path vertices selects them.
                    let r = Rect::from_two_pos(start, pos);
                    let v: Vec<serde_json::Value> = vertex_hits
                        .iter()
                        .filter(|h| h.tangent.is_none() && r.contains(h.pos))
                        .map(|h| json!({"layer": h.layer.0, "mask": h.mask, "index": h.index}))
                        .collect();
                    let _ = app.session.execute("mask.selectVertices", json!({"vertices": v, "add": mods.shift}));
                }
                Gesture::Marquee { start } => {
                    let a = map.to_comp(start);
                    let b = map.to_comp(pos);
                    let hits: Vec<u64> = selectable_layers(comp, time)
                        .filter(|l| layer_quad(ectx, l).is_some_and(|(_, q, _)| quad_intersects_box(&q, a, b)))
                        .map(|l| l.id.0)
                        .collect();
                    let _ = app.session.execute("layer.select", json!({"layers": hits, "toggle": mods.shift}));
                }
                _ => {}
            }
        }
        ui.data_mut(|d| {
            d.remove::<Gesture>(gid);
            let n: u64 = d.get_temp(egui::Id::unique("viewer-drag-n")).unwrap_or(0);
            d.insert_temp(egui::Id::unique("viewer-drag-n"), n + 1);
        });
    }
    v.vertex_hits = vertex_hits;
    v.pin_hits = pin_hits;
}

/// Acts on a click in the viewer for the active tool (select, zoom, add or delete vertices),
/// including a click an overlay passed on, and not one an overlay claimed.
fn phase_clicked(app: &mut EffectcraftApp, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
    let area = v.area;
    let zoom = v.zoom;
    let cw = v.cw;
    let ch = v.ch;
    let map = v.map;
    let mods = v.mods;
    let text_owns = v.text_owns;
    let ctx = v.ctx.clone();
    let ft = std::mem::take(&mut v.ft);
    let handle_hits = std::mem::take(&mut v.handle_hits);
    let vertex_hits = std::mem::take(&mut v.vertex_hits);
    let key_hits = std::mem::take(&mut v.key_hits);
    let motion_frames = std::mem::take(&mut v.motion_frames);
    let paths = std::mem::take(&mut v.paths);
    let pin_hits = std::mem::take(&mut v.pin_hits);
    let puppet_layers = std::mem::take(&mut v.puppet_layers);
    let comp = v.comp;
    let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
        let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
        vertex_hits.iter().rev().filter(|h| h.tangent.is_some() == tangents).find(|h| h.pos.distance(pos) < reach).copied()
    };
    let puppet_layer = |app: &mut EffectcraftApp, cpt: [f64; 2]| -> Option<LayerId> {
        if puppet_layers.is_empty() {
            return pick(app, ectx, cpt, false);
        }
        super::puppet_tool::target(ectx, &puppet_layers, cpt, |l| {
            layers_at(ectx, cpt).any(|h| h.id == l.id) && super::puppet_tool::takes_pin(app, ectx, l, cpt)
        })
    };
    // A press an overlay passed on in the pass before (FORWARDED_PRIMARY) is a click here.
    let pass = ctx.cumulative_pass_nr();
    let forwarded = ctx
        .data_mut(|d| d.remove_temp::<(Pos2, egui::Modifiers, u64)>(egui::Id::unique(FORWARDED_PRIMARY)))
        .filter(|f| f.2.saturating_add(1) == pass)
        .map(|f| (f.0, f.1));
    // A press an overlay claimed (CLAIMED_PRIMARY) is not a click here.
    let claimed = press_claimed(&ctx);
    let clicked = if resp.clicked() && !text_owns && !claimed { resp.interact_pointer_pos().map(|p| (p, mods)) } else { None };
    if let Some((pos, mods)) = clicked.or(forwarded) {
        let cpt = map.to_comp(pos);
        match app.ui.tool {
            Tool::Zoom => {
                let k = if mods.alt { 0.5 } else { 2.0 };
                let nz = (zoom * k).clamp(0.01, 32.0);
                let new_origin = pos - vec2(cpt[0] as f32 * nz, cpt[1] as f32 * nz);
                let pan = new_origin + vec2(cw * nz / 2.0, ch * nz / 2.0) - area.center();
                app.ui.viewer.zoom = Some(nz);
                app.ui.viewer.pan = [pan.x, pan.y];
            }
            Tool::Type | Tool::TypeVertical => {}
            Tool::Pen | Tool::MaskFeather => {}
            // On a motion path (After Effects): Add Vertex adds a keyframe where it is clicked,
            // Delete Vertex removes the keyframe, Convert Vertex switches it between Linear and
            // Auto Bezier spatial interpolation.
            Tool::PenAdd => {
                if let Some((l, m, seg, tt)) = ov::segment_at(&paths, &map, pos, 6.0) {
                    let _ = app.session.execute("mask.insertVertex", json!({"layer": l.0, "mask": m, "segment": seg, "t": tt}));
                } else if let Some(f) = ov::motion_frame_at(&motion_frames, &key_hits, pos) {
                    add_motion_key(app, f);
                }
            }
            Tool::PenDelete => {
                if let Some(h) = vertex_at(pos, false) {
                    let _ = app.session.execute("mask.deleteVertices", json!({"vertices": [{"layer": h.layer.0, "mask": h.mask, "index": h.index}]}));
                } else if let Some(k) = ov::motion_key_at(&key_hits, pos)
                    && select_motion_key(app, &k)
                {
                    let _ = app.session.execute("keys.delete", json!({}));
                }
            }
            Tool::PenConvert => {
                if let Some(h) = vertex_at(pos, false) {
                    let _ = app.session.execute("mask.convertVertex", json!({"layer": h.layer.0, "mask": h.mask, "index": h.index}));
                } else if let Some(k) = ov::motion_key_at(&key_hits, pos) {
                    // A key showing direction handles becomes Linear; one without, Auto Bezier.
                    // Separated X / Y Position have no spatial interpolation to convert.
                    let curved = key_hits.iter().any(|h| h.tangent.is_some() && h.layer == k.layer && h.prop == k.prop && h.time == k.time);
                    if k.axes.is_none() && select_motion_key(app, &k) {
                        let spatial = if curved { "linear" } else { "autoBezier" };
                        let _ = app.session.execute("keys.interpolation", json!({"spatial": spatial}));
                    }
                }
            }
            Tool::Selection if mods.alt && vertex_at(pos, false).is_some() => {
                if let Some(h) = vertex_at(pos, false) {
                    let _ = app.session.execute("mask.convertVertex", json!({"layer": h.layer.0, "mask": h.mask, "index": h.index}));
                }
            }
            Tool::Selection if ft.is_some() && ft.as_ref().and_then(|f| ov::begin_ft_drag(f, pos, &map)).is_none() => {
                // Clicking away from the free-transform box ends it.
                ov::end_free_transform(&ctx);
            }
            Tool::ObjectMatte => super::object_matte_tool::apply(app, ectx, &map, pos, None, mods.shift),
            t if t.puppet_kind().is_some() => {
                if let Some((h, _)) = super::puppet_tool::hit(&pin_hits, pos) {
                    // Click selects the pin; Shift-click adds or removes it.
                    let _ = app.session.execute("puppet.selectPins", json!({"layer": h.layer.0, "pins": [h.pin], "toggle": mods.shift}));
                } else if let Some(l) = puppet_layer(app, cpt).and_then(|l| comp.layer(l))
                    && let Some(inv) = fx2c(ectx, l).inverse()
                {
                    let lp = inv.apply(gv2(cpt[0], cpt[1]));
                    match app.session.execute("puppet.addPin", json!({"layer": l.id.0, "kind": t.puppet_kind(), "position": [lp.x, lp.y]})) {
                        Ok(r) => {
                            if let Some(pin) = r["pin"].as_u64() {
                                super::puppet_tool::reveal_pin(app, l.id, pin);
                            }
                        }
                        Err(e) => app.ui.status = e.to_string(),
                    }
                }
            }
            Tool::Selection if vertex_at(pos, false).is_some() => {
                if let Some(h) = vertex_at(pos, false) {
                    let me = json!({"layer": h.layer.0, "mask": h.mask, "index": h.index});
                    let _ = app.session.execute("mask.selectVertices", json!({"vertices": [me], "add": mods.shift, "toggle": mods.shift}));
                }
            }
            // The Roto Brush paints in the Layer panel only: select as usual and say so.
            rt if rt.roto_kind(false).is_some() => {
                if click_pick(app, ectx, cpt, mods.shift).is_none() {
                    let _ = app.session.execute("edit.deselectAll", json!({}));
                }
                app.ui.status = crate::i18n::tr(ROTO_HINT).to_string();
            }
            _ => {
                let on_path = ov::segment_at(&paths, &map, pos, 6.0).is_some();
                if on_path && !mods.shift {
                    // A click on a path of a selected layer stays on that layer, even where a
                    // layer in front covers it, so a double-click there free-transforms the path.
                } else if click_pick(app, ectx, cpt, mods.shift).is_none() {
                    let _ = app.session.execute("edit.deselectAll", json!({}));
                } else if !mods.shift && !app.session.state.selected_vertices.is_empty() && !on_path {
                    // A click away from the paths, even on their layer, deselects the mask
                    // points (the layer stays selected), as in After Effects (#513).
                    let _ = app.session.execute("mask.selectVertices", json!({"vertices": []}));
                }
            }
        }
    }
    v.ft = ft;
    v.handle_hits = handle_hits;
    v.vertex_hits = vertex_hits;
    v.key_hits = key_hits;
    v.motion_frames = motion_frames;
    v.paths = paths;
    v.pin_hits = pin_hits;
    v.puppet_layers = puppet_layers;
}

/// Acts on a double-click: a path's points into a Free Transform box, or a precomp opened; lets
/// go of an overlay's claim on the press once the button is up.
fn phase_dblclick(app: &mut EffectcraftApp, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
    let map = v.map;
    let ctx = v.ctx.clone();
    // A press an overlay claimed (CLAIMED_PRIMARY) is no double-click here either; the claim
    // ends with the button up (after this pass's click and double-click).
    let claimed = press_claimed(&ctx);
    if claimed && !ctx.input(|i| i.pointer.primary_down()) {
        ctx.data_mut(|d| d.remove::<()>(egui::Id::unique(CLAIMED_PRIMARY)));
    }
    let text_owns = v.text_owns || claimed;
    let handle_hits = std::mem::take(&mut v.handle_hits);
    let vertex_hits = std::mem::take(&mut v.vertex_hits);
    let paths = std::mem::take(&mut v.paths);
    let comp = v.comp;
    let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
        let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
        vertex_hits.iter().rev().filter(|h| h.tangent.is_some() == tangents).find(|h| h.pos.distance(pos) < reach).copied()
    };
    if resp.double_clicked()
        && !text_owns
        && app.ui.tool == Tool::Selection
        && let Some(pos) = resp.interact_pointer_pos()
        && let Some((l, m)) = vertex_at(pos, false).map(|h| (h.layer, h.mask)).or_else(|| ov::segment_at(&paths, &map, pos, 6.0).map(|s| (s.0, s.1)))
    {
        // Double-click a path: all its points selected in a free-transform box (Layer ▸ Mask and
        // Shape Path ▸ Free Transform Points), so dragging any of them, or inside the box, moves
        // the whole path (After Effects).
        if let Some(p) = paths.iter().find(|p| p.layer == l && p.uid == m) {
            let all: Vec<serde_json::Value> = (0..p.sp.vertices.len()).map(|index| json!({"layer": l.0, "mask": m, "index": index})).collect();
            let _ = app.session.execute("mask.selectVertices", json!({"vertices": all}));
        }
        ov::begin_free_transform(&ctx, l, m);
    } else if resp.double_clicked()
        && !text_owns
        && !app.ui.tool.is_pen()
        && let Some(pos) = resp.interact_pointer_pos()
    {
        let cpt = map.to_comp(pos);
        let roto = app.ui.tool.roto_kind(false).is_some();
        // The topmost layer, as the double-click's first click selected it (#1535).
        if let Some(l) = click_pick(app, ectx, cpt, false).and_then(|l| comp.layer(l)) {
            match &l.source {
                effectcraft_engine::project::LayerSource::Comp { item } => app.session.open_comp(*item),
                // With a Roto Brush tool, double-clicking a layer opens it in the Layer panel,
                // where the brush works (After Effects).
                _ if roto => {
                    let id = l.id.0;
                    match crate::menus::invoke(app, &ctx, "layer.openLayer", json!({"layer": id})) {
                        Ok(_) => app.ui.status.clear(),
                        Err(e) => app.ui.status = e,
                    }
                }
                _ => {}
            }
        }
    }
    v.handle_hits = handle_hits;
    v.vertex_hits = vertex_hits;
    v.paths = paths;
}

/// Runs the overlays drawn on top of the viewer (effect, gradient and text handles), after
/// recording the viewer's own controls for them, and draws the status chips.
fn phase_tail(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) {
    let t = v.t;
    let cid = v.cid;
    let bar = v.bar;
    let err_bar = v.err_bar;
    let err_h = v.err_h;
    let area = v.area;
    let outer = v.outer;
    let zoom = v.zoom;
    let map = v.map;
    let time = v.time;
    let ctx = v.ctx.clone();
    let painter = v.painter.clone();
    let comp = v.comp;
    // The viewer's own controls, which overlays on top leave to it (#2839).
    let roi = app.session.state.region_of_interest.map(|[rx, ry, rw, rh]| {
        let r = Rect::from_min_size(v.comp_rect.min + vec2(rx as f32 * zoom, ry as f32 * zoom), vec2(rw as f32 * zoom, rh as f32 * zoom));
        roi_handles(r).to_vec()
    });
    let guides = if app.ui.viewer.guides && !app.ui.viewer.lock_guides {
        comp.guides
            .iter()
            .map(|g| {
                let px = g.px(comp.width, comp.height);
                let s = map.to_screen([px, px]);
                (if g.vertical { s.x } else { s.y }, g.vertical)
            })
            .collect()
    } else {
        vec![]
    };
    let grabs = Grabs {
        handles: v.handle_hits.iter().map(|h| h.2).collect(),
        vertices: v.vertex_hits.iter().map(|h| h.pos).collect(),
        keys: v.key_hits.iter().map(|h| h.pos).collect(),
        axes: v.axis_hits.clone(),
        roi: roi.unwrap_or_default(),
        guides,
    };
    ctx.data_mut(|d| d.insert_temp(grabs_id(), grabs));
    // 3D Camera Tracker points, targets and their menu (on top of the viewer's gestures while
    // the effect is selected), and its analysis banner.
    super::camera_tracker_ui::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);
    // Effect point controls and crosshair/eyedropper picks (on top of the viewer's gestures).
    crate::panels::effect_controls::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);
    // Selected shape gradients' start and end points (#612).
    crate::panels::gradient_handles::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);
    // Selected text Range Selectors' Start and End bars (#1011).
    crate::panels::text_range_handles::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);

    // Status chips (render time / caching).
    // The caching chip stays up a moment after the last wait, so gaps between uncached frames
    // don't make it flicker.
    // ponytail: fixed 0.6 s hold; tie it to the prefetch queue being empty if gaps outlast it.
    let chip_id = egui::Id::unique("viewer-caching-chip");
    let now = ctx.input(|i| i.time);
    if app.playback.playing && app.playback.waiting {
        ctx.data_mut(|d| d.insert_temp(chip_id, now + 0.6));
    }
    let until = ctx.data(|d| d.get_temp::<f64>(chip_id)).unwrap_or(0.0);
    if app.playback.playing && now < until {
        if !app.playback.waiting {
            ctx.request_repaint_after(std::time::Duration::from_secs_f64(until - now));
        }
        let text = painter.layout_no_wrap(crate::i18n::tr("Caching frames").to_string(), Tokens::ui(10.5), t.text_dim);
        let r = Rect::from_min_size(area.min + vec2(8.0, 8.0), vec2(text.size().x + 30.0, 18.0));
        painter.rect_filled(r, 9.0, Color32::from_black_alpha(140));
        ui.put(Rect::from_center_size(pos2(r.min.x + 12.0, r.center().y), vec2(10.0, 10.0)), egui::Spinner::new().size(10.0).color(t.cache_green));
        painter.galley(pos2(r.min.x + 22.0, r.center().y - text.size().y / 2.0), text, t.text_dim);
    }
    if app.video_preview_off().is_some() {
        let r = Rect::from_min_size(area.min + vec2(10.0, 10.0), vec2(330.0, 22.0));
        painter.rect_filled(r, 11.0, Color32::from_black_alpha(190));
        painter.text(r.center(), Align2::CENTER_CENTER, crate::i18n::tr("Video preview is off (Preview panel): audio only"), Tokens::ui(11.5), t.timecode);
        ui.ctx().data_mut(|d| d.insert_temp(egui::Id::unique("viewer-video-off-chip"), r));
    }

    vt::draw_snap(&ctx, &painter, &map, ectx);
    vt::rulers(app, ui, &map, outer, area);
    vt::bottom_bar(app, ui, bar, zoom, time, comp);
    if err_h > 0.0 {
        super::expr_bar::draw(app, ui, err_bar, cid);
    }
}
pub(crate) use crate::widgets::hex_rgb;

mod frame;
mod geometry;
mod gesture;
mod shapes;
mod tools;
mod view;

use frame::{empty_state, rect_of, show_frame};
pub(crate) use frame::{extended_region, minify_factor, snap_to_pixels, styled_line, zoom_sampler, zoom_texture_options};
use geometry::{
    anchor_in_comp, cam_state, drag_axis, drag_ratio, handle_axes, handle_cursor, handle_point, one_axis, project_segment, quad_intersects_box, rotate_value,
    rotation_sign, selected_others, snap_handle, turn_delta,
};
#[cfg(test)]
use geometry::{box_corners, project_clipped};
pub(crate) use geometry::{from_effect_space, fx2c, l2c, layer_outline, layer_quad};
use gesture::{Gesture, HANDLE, ROTO_HINT, pen_id, roi_drag, roi_handles, vertex_grab_radius};
pub(crate) use shapes::{click_pick, layer_at, layer_at_including_locked, layer_hit, layers_at, pick, selectable_layers};
use shapes::{create_shape, draw_shape_ghost, shape_drag};
#[cfg(test)]
use tools::constrain_45;
use tools::{add_motion_key, axis_at, axis_drag, drag_axes, draw_rigs, parent_world_inverse, pen_cursor, pen_cursor_icon, pen_press, select_motion_key};
pub(crate) use view::checker;
use view::{aux_views, locked_pane};

#[cfg(test)]
mod tests;