GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Headless UI tests of the M12.7 Project panel and Media Browser: List view (columns, sorting,
//! resizing, inline rename), Icon view (hover scrub sets In / Out, thumbnail size), Freeform view
//! (dragging places a card, stacks), the panel menu and Metadata Display… dialog, view presets,
//! bins opened in place / in a tab / in a window, and the Media Browser (navigation, Favorites,
//! Edit Columns…, import, drag to the Project panel, Open In Source Monitor).
//!
//! Set `FILMCRAFT_UI_SNAPSHOT_DIR=<dir>` to also render offscreen with wgpu and write
//! `project-*.png` / `media-browser-*.png`.

#![allow(dead_code)]

use std::sync::mpsc::{Sender, channel};

use egui_kittest::Harness;
use egui_kittest::kittest::Queryable;
use filmcraft_engine::Session;
use filmcraft_engine::project_panel::{FREEFORM_POS, FREEFORM_STACK, ViewMode};
use filmcraft_project::{BinEntry, ItemId};
use filmcraft_ui_egui::FilmcraftApp;
use filmcraft_ui_egui::control::ControlRequest;
use serde_json::{Value, json};

struct Driver {
    harness: Harness<'static, FilmcraftApp>,
    tx: Sender<ControlRequest>,
    snapshots: Option<std::path::PathBuf>,
}

impl Driver {
    fn with(session: Session) -> Self {
        let (tx, rx) = channel();
        let app = FilmcraftApp::new(session).with_control(rx);
        let snapshots = std::env::var_os("FILMCRAFT_UI_SNAPSHOT_DIR").map(std::path::PathBuf::from);
        let mut b = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_max_steps(10_000);
        if snapshots.is_some() {
            b = b.wgpu();
        }
        let harness = b.build_eframe(move |_cc| app);
        let mut d = Driver { harness, tx, snapshots };
        d.frames(4);
        d
    }

    fn demo() -> Self {
        let mut session = Session::default();
        session.execute("file.openDemoProject", json!({})).expect("demo project");
        Self::with(session)
    }

    fn frames(&mut self, n: usize) {
        for _ in 0..n {
            let ctx = self.harness.ctx.clone();
            let mut raw = std::mem::take(self.harness.input_mut());
            eframe::App::raw_input_hook(self.harness.state_mut(), &ctx, &mut raw);
            *self.harness.input_mut() = raw;
            self.harness.step();
        }
    }

    fn call(&mut self, method: &str, params: Value) -> Value {
        let (req, reply) = ControlRequest::new(method, params.clone());
        self.tx.send(req).unwrap();
        for _ in 0..600 {
            self.frames(1);
            if let Ok(v) = reply.try_recv() {
                return v;
            }
        }
        panic!("no reply to {method} {params}");
    }

    fn ok(&mut self, method: &str, params: Value) -> Value {
        let v = self.call(method, params.clone());
        assert_eq!(v["ok"], json!(true), "{method} {params} failed: {v}");
        v["result"].clone()
    }

    fn exec(&mut self, command: &str, params: Value) -> Value {
        self.ok("engine.execute", json!({"command": command, "params": params}))
    }

    fn click(&mut self, id: &str) {
        self.ok("ui.click", json!({"id": id}));
        self.frames(2);
    }

    fn ids(&mut self, prefix: &str) -> Vec<String> {
        let v = self.ok("ui.elements", json!({"prefix": prefix}));
        v.as_array().unwrap().iter().filter_map(|e| e["id"].as_str().map(str::to_string)).collect()
    }

    fn has(&mut self, id: &str) -> bool {
        self.ids(id).iter().any(|i| i == id)
    }

    fn rect(&mut self, id: &str) -> [f32; 4] {
        let v = self.ok("ui.elements", json!({"prefix": id}));
        let e = v.as_array().unwrap().iter().find(|e| e["id"] == json!(id)).unwrap_or_else(|| panic!("no element {id}")).clone();
        let r = &e["rect"];
        [r[0].as_f64().unwrap() as f32, r[1].as_f64().unwrap() as f32, r[2].as_f64().unwrap() as f32, r[3].as_f64().unwrap() as f32]
    }

    fn label(&mut self, id: &str) -> String {
        let v = self.ok("ui.elements", json!({"prefix": id}));
        v.as_array().unwrap().iter().find(|e| e["id"] == json!(id)).and_then(|e| e["label"].as_str().map(str::to_string)).unwrap_or_default()
    }

    /// Step frames until `id` is registered, for at most two minutes of wall-clock time.
    fn wait_for(&mut self, id: &str) {
        let t0 = std::time::Instant::now();
        while t0.elapsed().as_secs() < 120 {
            if self.has(id) {
                return;
            }
            std::thread::sleep(std::time::Duration::from_millis(5));
            self.frames(1);
        }
        panic!("{id} never appeared: {:?}", self.ids(id.split('.').next().unwrap()));
    }

    fn key(&mut self, key: &str) {
        self.ok("ui.key", json!({"key": key}));
        self.frames(2);
    }

    fn app(&mut self) -> &mut FilmcraftApp {
        self.harness.state_mut()
    }

    /// The demo's Footage bin and its media items.
    fn footage(&mut self) -> (u64, Vec<u64>) {
        let p = &self.app().session.project;
        let bin = p
            .root
            .children
            .iter()
            .find_map(|e| match e {
                BinEntry::Bin(b) if b.name == "Footage" => Some(b.clone()),
                _ => None,
            })
            .expect("Footage bin");
        let items = bin.children.iter().filter_map(|e| if let BinEntry::Item(i) = e { Some(i.0) } else { None }).collect();
        (bin.id.0, items)
    }

    fn snapshot(&mut self, name: &str, prefix: Option<&str>) {
        let Some(dir) = self.snapshots.clone() else { return };
        let crop = prefix.map(|p| self.rect(p));
        self.frames(2);
        let img = match self.harness.render() {
            Ok(i) => i,
            Err(e) => {
                eprintln!("snapshot {name} skipped: {e}");
                return;
            }
        };
        let ppp = img.width() as f32 / 1600.0;
        let img = match crop {
            Some([x, y, w, h]) => {
                let (x0, y0) = ((x * ppp).max(0.0) as u32, (y * ppp).max(0.0) as u32);
                let (x1, y1) = ((((x + w) * ppp) as u32).min(img.width()), (((y + h) * ppp) as u32).min(img.height()));
                image::imageops::crop_imm(&img, x0, y0, x1 - x0, y1 - y0).to_image()
            }
            None => img,
        };
        std::fs::create_dir_all(&dir).unwrap();
        let path = dir.join(format!("{name}.png"));
        img.save(&path).unwrap();
        eprintln!("snapshot: {}", path.display());
    }
}

/// The demo project with the Project panel maximized (room for the List view's columns).
fn project_driver() -> Driver {
    let mut d = Driver::demo();
    d.ok("ui.panel.show", json!({"panel": "Project"}));
    d.ok("ui.set", json!({"focused": "Project"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.frames(3);
    d
}

/// Double-click a bin (synthetic input runs one event per frame, too slow for a double-click, so
/// this sends what the double-click does: open as Settings ▸ General ▸ Bins says).
fn double_click_bin(d: &mut Driver, bin: u64, alt: bool) {
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "alt": alt}}));
    d.frames(3);
}

#[test]
fn list_view_columns_sort_resize_and_rename() {
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    let (bin, items) = d.footage();
    d.frames(2);
    // expand the Footage bin
    d.click(&format!("project.bin.{bin}.toggle"));
    assert!(d.app().ui.expanded_bins.contains(&bin));
    d.wait_for(&format!("project.item.{}", items[0]));
    for c in ["Name", "Frame Rate", "Media Start", "Media Duration"] {
        assert!(d.has(&format!("project.list.header.{c}")), "{c} header");
    }
    assert!(d.has(&format!("project.item.{}.label", items[0])), "label chip");
    let y = |d: &mut Driver, i: u64| d.rect(&format!("project.item.{i}"))[1];
    // Name ascending: rows ordered by name
    let mut by_name: Vec<(String, u64)> = items.iter().map(|i| (d.app().session.project.item(ItemId(*i)).unwrap().name.to_lowercase(), *i)).collect();
    by_name.sort();
    let (first, last) = (by_name[0].1, by_name.last().unwrap().1);
    assert!(y(&mut d, first) < y(&mut d, last));
    d.snapshot("project-list", Some("panel.Project"));
    // clicking the Name header reverses the order
    d.click("project.list.header.Name");
    assert!(d.app().session.prefs.project_panel.view.sort.descending);
    d.frames(2);
    assert!(y(&mut d, first) > y(&mut d, last));
    // drag the Frame Rate column wider (saved in preferences)
    let w0 = d.app().session.prefs.project_panel.view.columns.iter().find(|c| c.name == "Frame Rate").unwrap().width;
    let r = d.rect("project.list.resize.Frame Rate");
    let (cx, cy) = (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
    d.ok("ui.drag", json!({"from": {"x": cx, "y": cy}, "to": {"x": cx + 60.0, "y": cy}}));
    d.frames(3);
    let w1 = d.app().session.prefs.project_panel.view.columns.iter().find(|c| c.name == "Frame Rate").unwrap().width;
    assert!(w1 > w0 + 30.0, "{w0} → {w1}");
    // inline rename: Rename, type, Enter (one undo step)
    d.exec("project.select", json!({"items": [items[0]]}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.rename"}));
    d.frames(3);
    assert!(d.has("project.rename"));
    d.ok("ui.type", json!({"text": "Hero shot"}));
    d.frames(2);
    d.key("Enter");
    d.frames(2);
    assert_eq!(d.app().session.project.item(ItemId(items[0])).unwrap().name, "Hero shot");
    assert!(d.app().ui.project_panel.rename.is_none());
    d.exec("edit.undo", json!({}));
    assert_ne!(d.app().session.project.item(ItemId(items[0])).unwrap().name, "Hero shot");
}

#[test]
fn a_right_button_drag_does_not_resize_a_list_column() {
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    d.frames(3);
    let width = |d: &mut Driver| d.app().session.prefs.project_panel.view.columns.iter().find(|c| c.name == "Frame Rate").unwrap().width;
    let w0 = width(&mut d);
    let r = d.rect("project.list.resize.Frame Rate");
    let from = egui::pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
    let button = egui::PointerButton::Secondary;
    let to = from + egui::vec2(60.0, 0.0);
    let send = |d: &mut Driver, event| {
        d.harness.input_mut().events.push(event);
        d.frames(1);
    };
    send(&mut d, egui::Event::PointerMoved(from));
    send(&mut d, egui::Event::PointerButton { pos: from, button, pressed: true, modifiers: egui::Modifiers::NONE });
    send(&mut d, egui::Event::PointerMoved(from + egui::vec2(20.0, 0.0)));
    send(&mut d, egui::Event::PointerMoved(to));
    send(&mut d, egui::Event::PointerButton { pos: to, button, pressed: false, modifiers: egui::Modifiers::NONE });
    d.frames(3);
    assert_eq!(width(&mut d), w0);
}

// Regression test for #1295: in a narrow List-view column the sort arrow was painted over the end of
// the (clipped) column name; the name must be clipped to the left of the arrow.
#[test]
fn sorted_column_header_name_is_clipped_clear_of_the_sort_arrow() {
    fn collect<'a>(shapes: &'a [egui::Shape], clip: egui::Rect, out: &mut Vec<(&'a egui::Shape, egui::Rect)>) {
        for s in shapes {
            match s {
                egui::Shape::Vec(v) => collect(v, clip, out),
                other => out.push((other, clip)),
            }
        }
    }
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    d.frames(2);
    // the default sort is by Name; make that column narrow enough that its name is clipped
    for c in &mut d.app().session.prefs.project_panel.view.columns {
        if c.name == "Name" {
            c.width = 40.0;
        }
    }
    d.frames(3);
    assert_eq!(d.app().session.prefs.project_panel.view.sort.column, "Name");
    let [hx, hy, hw, hh] = d.rect("project.list.header.Name");
    let header = egui::Rect::from_min_size(egui::pos2(hx, hy), egui::vec2(hw, hh));
    let mut all = Vec::new();
    let clipped: Vec<_> = d.harness.output().shapes.iter().map(|c| (c.shape.clone(), c.clip_rect)).collect();
    for (shape, clip) in &clipped {
        collect(std::slice::from_ref(shape), *clip, &mut all);
    }
    // the visible part of the name: the clip rect of the header's "Name" text
    let name_clip = all
        .iter()
        .find_map(|(s, clip)| match s {
            egui::Shape::Text(t) if t.galley.text() == "Name" && header.contains(t.pos) => Some(*clip),
            _ => None,
        })
        .expect("the Name header text is drawn");
    // the arrow: the 1.3 px strokes drawn inside the header
    let arrow_x: Vec<f32> = all
        .iter()
        .filter_map(|(s, _)| match s {
            egui::Shape::LineSegment { points, stroke } if (stroke.width - 1.3).abs() < 1e-3 && header.contains(points[0]) && header.contains(points[1]) => {
                Some(points[0].x.min(points[1].x))
            }
            _ => None,
        })
        .collect();
    assert!(!arrow_x.is_empty(), "the sort arrow is drawn in the sorted column's header");
    let arrow_left = arrow_x.into_iter().fold(f32::MAX, f32::min);
    assert!(name_clip.max.x <= arrow_left, "the name is visible up to x={} but the sort arrow starts at x={arrow_left}", name_clip.max.x);
}

#[test]
fn icon_view_hover_scrub_sets_in_and_out() {
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "icon"}));
    let (bin, items) = d.footage();
    // open the Footage bin in place (Settings ▸ Bins ▸ Double-click: Open in place)
    d.click(&format!("project.bin.{bin}"));
    double_click_bin(&mut d, bin, false);
    assert_eq!(d.app().ui.project_panel.bin, Some(bin));
    assert!(d.label("project.breadcrumb").ends_with("/ Footage"));
    let card = format!("project.item.{}", items[0]);
    d.wait_for(&card);
    d.ok("ui.set", json!({"focused": "Project"}));
    // hover a quarter in, press I; three quarters in, press O
    d.ok("ui.move", json!({"id": card, "fx": 0.25, "fy": 0.5}));
    d.frames(2);
    let h = d.app().ui.project_panel.hover.expect("hover scrub");
    assert_eq!(h.item, items[0]);
    d.key("I");
    d.ok("ui.move", json!({"id": card, "fx": 0.75, "fy": 0.5}));
    d.frames(2);
    d.key("O");
    let it = d.app().session.project.item(ItemId(items[0])).unwrap().clone();
    let m = it.as_media().unwrap();
    let (i, o) = (m.mark_in.expect("In set"), m.mark_out.expect("Out set"));
    let dur = it.duration().0 as f64;
    assert!((i.0 as f64 / dur - 0.25).abs() < 0.05, "In at {}", i.0 as f64 / dur);
    assert!((o.0 as f64 / dur - 0.75).abs() < 0.05, "Out at {}", o.0 as f64 / dur);
    d.frames(2);
    assert!(d.has(&format!("project.item.{}.inOut", items[0])), "In/Out bar on the card");
    // the sequence's marks are untouched
    assert!(d.app().session.active_sequence().unwrap().mark_in.is_none());
    d.snapshot("project-icon", Some("panel.Project"));
    // Shift+] / Shift+[ change the thumbnail size
    let s0 = d.app().session.prefs.project_panel.view.icon_size;
    d.key("Shift+]");
    assert!(d.app().session.prefs.project_panel.view.icon_size > s0);
    d.key("Shift+[");
    assert!((d.app().session.prefs.project_panel.view.icon_size - s0).abs() < 1.0);
    // Hover Scrub off: no hover, I marks the sequence again
    d.key("Shift+H");
    assert!(!d.app().session.prefs.project_panel.hover_scrub);
    d.ok("ui.move", json!({"id": card, "fx": 0.5, "fy": 0.5}));
    d.frames(4);
    d.key("I");
    assert!(d.app().session.active_sequence().unwrap().mark_in.is_some());
    // up one level: a full-size button, not a 16 px glyph
    let [_, _, w, h] = d.rect("project.up");
    assert!(w >= 24.0 && h >= 22.0, "Up one level is {w}×{h}");
    d.click("project.up");
    assert_eq!(d.app().ui.project_panel.bin, None);
}

/// Drag with the middle button from `from` to `to`, a frame per step.
fn middle_drag(d: &mut Driver, from: egui::Pos2, to: egui::Pos2) {
    let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Middle, pressed, modifiers: egui::Modifiers::NONE };
    let send = |d: &mut Driver, e| {
        d.harness.input_mut().events.push(e);
        d.frames(1);
    };
    send(d, egui::Event::PointerMoved(from));
    send(d, button(from, true));
    for k in 1..=8 {
        send(d, egui::Event::PointerMoved(from.lerp(to, k as f32 / 8.0)));
    }
    send(d, button(to, false));
    d.frames(2);
}

#[test]
fn freeform_middle_drag_pans_and_never_moves_a_card() {
    // #579: a middle-button drag pans the canvas, on a card as on the background
    let mut d = project_driver();
    let (bin, items) = d.footage();
    d.exec("project.view.set", json!({"view": "freeform"}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    // one card in view, one far out so the canvas is larger than the panel
    d.exec("project.freeform.move", json!({"items": [items[0]], "x": 40, "y": 40}));
    d.exec("project.freeform.move", json!({"items": [items[1]], "x": 4000, "y": 3000}));
    let card = format!("project.item.{}", items[0]);
    d.wait_for(&card);
    d.frames(2);
    let pos = |d: &mut Driver| d.app().session.project.item(ItemId(items[0])).unwrap().metadata.get(FREEFORM_POS).cloned();
    let (before, selection) = (pos(&mut d), d.app().session.state.project_selection.clone());
    let canvas = d.rect("project.freeform");
    let r = d.rect(&card);
    let from = egui::pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
    middle_drag(&mut d, from, from - egui::vec2(120.0, 80.0));
    let moved = d.rect("project.freeform");
    assert!((canvas[0] - moved[0] - 120.0).abs() < 4.0 && (canvas[1] - moved[1] - 80.0).abs() < 4.0, "panned {canvas:?} -> {moved:?}");
    assert_eq!(pos(&mut d), before, "the card stayed put");
    assert_eq!(d.app().session.state.project_selection, selection);
}

#[test]
fn icon_view_cuts_long_names_and_shows_them_on_hover() {
    // a bin name too long for its card ends in "…" before the item count and is shown in full on hover
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "icon"}));
    let long = "Home Video Editing Summer 2026 — Family Trip to the Coast";
    let bin = d.exec("file.newBin", json!({"name": long}))["bin"].as_u64().expect("bin id");
    let card = format!("project.bin.{bin}");
    d.wait_for(&card);
    // the card names itself in full for assistive technology; the tooltip is a second node
    let shown = |d: &Driver| d.harness.query_all_by_label(long).count();
    let before = shown(&d);
    d.ok("ui.move", json!({"id": card, "fx": 0.5, "fy": 0.5}));
    for _ in 0..60 {
        if shown(&d) > before {
            break;
        }
        std::thread::sleep(std::time::Duration::from_millis(10));
        d.frames(1);
    }
    assert!(shown(&d) > before, "hovering a cut-off name shows it in full");
    d.snapshot("project-icon-long-name", Some("panel.Project"));
}

#[test]
fn freeform_view_places_and_stacks_cards() {
    let mut d = project_driver();
    let (bin, items) = d.footage();
    d.exec("project.view.set", json!({"view": "freeform"}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    let card = format!("project.item.{}", items[0]);
    d.wait_for(&card);
    assert!(d.has("project.freeform"));
    let r = d.rect(&card);
    let canvas = d.rect("project.freeform");
    let from = (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
    let to = (from.0 + 140.0, from.1 + 90.0);
    d.ok("ui.drag", json!({"from": {"x": from.0, "y": from.1}, "to": {"x": to.0, "y": to.1}, "steps": 16}));
    d.frames(4);
    let pos = d.app().session.project.item(ItemId(items[0])).unwrap().metadata.get(FREEFORM_POS).cloned().expect("card placed");
    let (x, y, _) = filmcraft_engine::project_panel::parse_pos(&pos).unwrap();
    let (ex, ey) = (r[0] - canvas[0] + 140.0, r[1] - canvas[1] + 90.0);
    assert!((x - ex).abs() < 4.0 && (y - ey).abs() < 4.0, "placed at {x},{y}, expected {ex},{ey}");
    d.frames(2);
    let r2 = d.rect(&card);
    assert!((r2[0] - r[0] - 140.0).abs() < 4.0, "card drawn where it was dropped");
    d.snapshot("project-freeform", Some("panel.Project"));
    // the move is one undo step
    d.exec("edit.undo", json!({}));
    assert!(!d.app().session.project.item(ItemId(items[0])).unwrap().metadata.contains_key(FREEFORM_POS));
    // stack two cards from the card menu
    d.exec("project.select", json!({"items": [items[0], items[1]]}));
    d.ok("ui.click", json!({"id": card, "button": "right"}));
    d.frames(2);
    d.click("project.cardMenu.stack");
    assert_eq!(d.app().session.project.item(ItemId(items[1])).unwrap().metadata.get(FREEFORM_STACK).map(String::as_str), Some(items[0].to_string().as_str()));
    d.frames(2);
    assert!(d.has(&format!("project.stack.{}", items[0])), "×2 badge");
    // Freeform View Options… from the panel menu
    d.click("panel.menu.Project");
    d.ok("ui.scroll", json!({"id": "panel.menu.scroll", "dy": -1200}));
    d.frames(4);
    let item_rect = d.rect("project.menu.freeformOptions");
    let ctx = d.harness.ctx.clone();
    let at = egui::pos2(item_rect[0] + item_rect[2] / 2.0, item_rect[1] + item_rect[3] / 2.0);
    assert!(ctx.content_rect().contains(at), "bottom menu action must be reachable: {item_rect:?}");
    d.snapshot("project-freeform-menu", None);
    d.click("project.menu.freeformOptions");
    let app = d.app();
    let diagnostic = format!(
        "dialog={:?}, controls={:?}",
        app.ui.project_panel.dialog,
        app.auto.elements.iter().filter(|element| element.id.starts_with("projectDialog.")).map(|element| (&element.id, element.rect)).collect::<Vec<_>>()
    );
    assert!(d.has("projectDialog.snap"), "{diagnostic}");
    d.click("projectDialog.snap");
    d.click("projectDialog.ok");
    assert!(d.app().session.prefs.project_panel.freeform.snap);
    assert!(d.app().ui.project_panel.dialog.is_none());
}

#[test]
fn metadata_display_dialog_and_view_presets() {
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    let (bin, _) = d.footage();
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    d.frames(2);
    // the panel menu lists Premiere's items
    d.click("panel.menu.Project");
    for id in [
        "project.menu.closeProject",
        "project.menu.newBin",
        "project.menu.newSearchBin",
        "project.menu.rename",
        "project.menu.automateToSequence",
        "project.menu.view.List",
        "project.menu.view.Freeform",
        "project.menu.previewArea",
        "project.menu.hoverScrub",
        "project.menu.fontSize",
        "project.menu.refreshSortOrder",
        "project.menu.metadataDisplay",
        "project.menu.saveViewPresetAs",
        "project.menu.restoreViewPreset",
        "project.menu.freeformOptions",
    ] {
        assert!(d.has(id), "{id}");
    }
    d.ok("ui.scroll", json!({"id": "panel.menu.scroll", "dy": -1200}));
    d.frames(4);
    d.click("project.menu.metadataDisplay");
    d.frames(4);
    assert!(matches!(d.app().ui.project_panel.dialog, Some(filmcraft_ui_egui::panels::project::ProjectDialog::MetadataDisplay { .. })));
    d.click("projectDialog.field.Label");
    // fields further down: narrow the list with the search box
    d.click("projectDialog.filter");
    d.ok("ui.type", json!({"text": "usage"}));
    d.frames(2);
    d.click("projectDialog.field.Video Usage");
    d.click("projectDialog.filter");
    d.key("Cmd+A");
    d.ok("ui.type", json!({"text": "tape"}));
    d.frames(2);
    d.click("projectDialog.field.Tape Name");
    // move Label up next to Name
    for _ in 0..12 {
        if !d.has("projectDialog.up.Label") {
            break;
        }
        d.click("projectDialog.up.Label");
    }
    d.snapshot("project-metadata-display", None);
    d.click("projectDialog.ok");
    let cols: Vec<String> = d.app().session.prefs.project_panel.view.columns.iter().map(|c| c.name.clone()).collect();
    assert_eq!(cols[0], "Name");
    assert_eq!(cols[1], "Label", "{cols:?}");
    assert!(cols.contains(&"Video Usage".to_string()) && !cols.contains(&"Tape Name".to_string()));
    d.frames(2);
    assert!(d.has("project.list.header.Label") && d.has("project.list.header.Video Usage"));

    // Save As New View Preset (named), change the view, restore it from Manage
    d.click("panel.menu.Project");
    d.click("project.menu.saveViewPresetAs");
    d.ok("ui.set", json!({"projectPanel": {"dialog": {"savePresetAs": {"name": "Logging"}}}}));
    d.frames(2);
    d.click("projectDialog.ok");
    assert_eq!(d.app().session.prefs.project_panel.presets[0].as_ref().unwrap().name, "Logging");
    d.exec("project.view.set", json!({"view": "icon", "fontSize": "large"}));
    d.click("panel.menu.Project");
    d.click("project.menu.manageViewPresets");
    d.click("projectDialog.preset.1");
    d.click("projectDialog.restore");
    assert_eq!(d.app().session.prefs.project_panel.view.mode, ViewMode::List);
    d.click("projectDialog.ok");
    assert!(d.app().ui.project_panel.dialog.is_none());
    // Font Size and Preview Area
    d.exec("project.view.set", json!({"fontSize": "extraLarge", "previewArea": true}));
    let first = d.footage().1[0];
    d.exec("project.select", json!({"items": [first]}));
    d.frames(3);
    assert!(d.has("project.previewArea"));
    d.snapshot("project-list-preview-xl", Some("panel.Project"));
}

#[test]
fn bins_open_in_place_in_a_tab_or_in_a_window() {
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    let (bin, items) = d.footage();
    d.app().session.prefs.general.bins_double_click = "openNewTab".into();
    d.frames(2);
    double_click_bin(&mut d, bin, false);
    assert_eq!(d.app().ui.project_panel.tabs.len(), 1);
    assert!(d.has("project.tab.0") && d.has("project.tab.project"));
    // the tab shows the bin's items under its own ids
    d.wait_for(&format!("projectBin.0.item.{}", items[0]));
    d.click("project.tab.project");
    assert_eq!(d.app().ui.project_panel.active_tab, None);
    d.click("project.tab.0.close");
    assert!(d.app().ui.project_panel.tabs.is_empty());
    // Opt+double-click: Open in New Window (a floating bin panel)
    double_click_bin(&mut d, bin, true);
    assert!(d.app().ui.project_panel.tabs.first().is_some_and(|t| t.floating), "{:?}", d.app().ui.project_panel.tabs);
    d.wait_for("projectBin.0.window");
    // a second Project panel on the project
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.newPanel"}));
    d.frames(3);
    assert!(d.has("projectBin.1.window"));
    d.snapshot("project-bin-windows", None);
    // inline rename of a bin
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.rename", "params": {"bin": bin}}));
    d.frames(3);
    d.ok("ui.type", json!({"text": "Camera A"}));
    d.key("Enter");
    let name = d.app().session.project.root.find_bin(filmcraft_project::BinId(bin)).unwrap().name.clone();
    assert_eq!(name, "Camera A");
}

#[test]
fn select_all_takes_only_the_shown_bin() {
    // #456: Cmd+A selected every item in the project, closed bins and other tabs included
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    let (bin, items) = d.footage();
    assert!(!items.is_empty());
    let sorted = |v: &[ItemId]| {
        let mut v: Vec<u64> = v.iter().map(|i| i.0).collect();
        v.sort();
        v
    };
    let mut footage = items.clone();
    footage.sort();
    // the root with the Footage bin closed: none of its items
    d.app().ui.expanded_bins.clear();
    d.frames(2);
    d.key("Cmd+A");
    let sel = d.app().session.state.project_selection.clone();
    assert!(sel.iter().all(|i| !items.contains(&i.0)), "{sel:?}");
    assert!(sel.iter().all(|i| d.app().session.project.root.children.contains(&BinEntry::Item(*i))), "{sel:?}");
    // twirled open in List view, its items are shown and count
    d.app().ui.expanded_bins.push(bin);
    d.frames(2);
    d.key("Cmd+A");
    let sel = d.app().session.state.project_selection.clone();
    assert!(items.iter().all(|i| sel.contains(&ItemId(*i))), "{sel:?}");
    d.key("Cmd+Shift+A");
    assert!(d.app().session.state.project_selection.is_empty());
    // the bin opened in its own tab: exactly its items
    d.app().ui.expanded_bins.clear();
    d.app().session.prefs.general.bins_double_click = "openNewTab".into();
    double_click_bin(&mut d, bin, false);
    assert_eq!(d.app().ui.project_panel.active_tab, Some(0));
    d.key("Cmd+A");
    assert_eq!(sorted(&d.app().session.state.project_selection), footage);
}

/// With a sequence open, the native macOS menu has Select All enabled and takes Cmd+A (and
/// Cmd+Shift+A) before the window sees the key: with the Project panel focused they still act on
/// its items, not on the Timeline's clips (#1752).
#[test]
fn native_menu_select_all_acts_on_the_focused_project_panel() {
    let mut d = Driver::demo();
    assert!(d.app().session.active_sequence().is_some());
    d.ok("ui.panel.show", json!({"panel": "Project"}));
    d.exec("project.view.set", json!({"view": "list"}));
    let (bin, shown) = d.footage();
    d.app().ui.expanded_bins = vec![bin];
    d.frames(2);
    let clip = d.app().session.active_sequence().and_then(|q| q.all_tracks().find_map(|t| t.items.first().map(|i| i.id))).unwrap();
    d.exec("timeline.select", json!({"clips": [clip.0]}));
    let timeline = d.app().session.state.selection.clone();
    assert!(shown.len() > 1, "{shown:?}");
    let item = shown[0];
    d.wait_for(&format!("project.item.{item}"));
    d.click(&format!("project.item.{item}"));
    assert_eq!(d.app().ui.focused, filmcraft_ui_egui::dock::PanelKind::Project);
    assert_eq!(selection(&mut d), vec![item]);
    let (tx, rx) = channel();
    d.app().command_inbox = Some(rx);
    tx.send("edit.selectAll".to_string()).unwrap();
    d.frames(2);
    assert_eq!(selection(&mut d), sorted(shown), "Select All selects the panel's items");
    assert_eq!(d.app().session.state.selection, timeline, "and leaves the timeline selection alone");
    tx.send("edit.deselectAll".to_string()).unwrap();
    d.frames(2);
    assert!(selection(&mut d).is_empty(), "Deselect All clears the panel's selection");
    assert_eq!(d.app().session.state.selection, timeline, "and leaves the timeline selection alone");
}

/// Select All while typing in the Project panel's search selects the typed text, not the clips: on
/// macOS the native menu takes Cmd+A before the field sees the key and sent Edit ▸ Select All,
/// which selected every clip on the timeline. Typing after it replaces the search.
#[test]
fn select_all_in_the_search_box_selects_its_text() {
    let mut d = project_driver();
    d.click("project.search");
    d.ok("ui.type", json!({"text": "comedy manager"}));
    d.frames(2);
    let (timeline, items) = (d.app().session.state.selection.clone(), d.app().session.state.project_selection.clone());
    let (tx, rx) = channel();
    d.app().command_inbox = Some(rx);
    tx.send("edit.selectAll".to_string()).unwrap();
    d.frames(2);
    assert_eq!(d.app().session.state.selection, timeline, "the timeline selection is left alone");
    assert_eq!(d.app().session.state.project_selection, items, "and so are the Project panel's items");
    d.ok("ui.type", json!({"text": "club"}));
    d.frames(2);
    assert_eq!(d.app().ui.project_search, "club", "the typed text replaced the selected search");
    // the same from the control channel, which runs after the field has been laid out
    d.ok("ui.menu.invoke", json!({"id": "edit.selectAll"}));
    d.frames(2);
    assert_eq!(d.app().session.state.selection, timeline);
    d.ok("ui.type", json!({"text": "stool"}));
    d.frames(2);
    assert_eq!(d.app().ui.project_search, "stool");
}

#[test]
fn a_dragged_bin_nests_in_another_and_back_out() {
    // #456: a bin stayed wherever it was created; dragging it onto another bin did nothing
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    let outer = d.exec("file.newBin", json!({"name": "Outer"}))["bin"].as_u64().unwrap();
    let inner = d.exec("file.newBin", json!({"name": "Inner"}))["bin"].as_u64().unwrap();
    d.app().ui.expanded_bins.clear();
    d.frames(3);
    let parent =
        |d: &mut Driver, b: u64| filmcraft_ui_egui::panels::project::parent_bin(&d.app().session.project.root, filmcraft_project::BinId(b)).map(|p| p.0);
    let root = d.app().session.project.root.id.0;
    let drag = |d: &mut Driver, from: [f32; 4], to: (f32, f32)| {
        let start = (from[0] + 80.0, from[1] + from[3] / 2.0);
        d.ok("ui.drag", json!({"from": {"x": start.0, "y": start.1}, "to": {"x": to.0, "y": to.1}, "steps": 12}));
        d.frames(3);
    };
    // onto the Outer row: Inner nests in it
    let (from, to) = (d.rect(&format!("project.bin.{inner}")), d.rect(&format!("project.bin.{outer}")));
    drag(&mut d, from, (to[0] + 80.0, to[1] + to[3] / 2.0));
    assert_eq!(parent(&mut d, inner), Some(outer));
    // a bin never goes into itself
    d.app().ui.expanded_bins.push(outer);
    d.frames(3);
    let (from, to) = (d.rect(&format!("project.bin.{outer}")), d.rect(&format!("project.bin.{inner}")));
    drag(&mut d, from, (to[0] + 80.0, to[1] + to[3] / 2.0));
    assert_eq!(parent(&mut d, outer), Some(root));
    assert_eq!(parent(&mut d, inner), Some(outer));
    // onto empty space: back to the bin the view shows
    let from = d.rect(&format!("project.bin.{inner}"));
    let to = centre(d.rect("project.empty"));
    drag(&mut d, from, to);
    assert_eq!(parent(&mut d, inner), Some(root));
}

#[test]
fn footer_buttons_are_wired() {
    let mut d = project_driver();
    let bins0 = d.app().session.project.root.children.len();
    d.click("project.button.file.newBin");
    assert_eq!(d.app().session.project.root.children.len(), bins0 + 1);
    d.click("project.button.find");
    assert!(d.app().ui.extras.dialog.is_some(), "Find… dialog");
    d.app().ui.extras.dialog = None;
    d.click("project.button.new-item");
    d.wait_for("project.newItem.file.newColorMatte");
    let n0 = d.app().session.project.items.len();
    d.click("project.newItem.file.newColorMatte");
    // the New Color Matte dialog asks for the color first (#29)
    assert!(d.app().ui.extras.dialog.is_some(), "New Color Matte dialog");
    d.click("colorMatte.ok");
    assert_eq!(d.app().session.project.items.len(), n0 + 1);
    d.click("project.button.project.delete");
    assert_eq!(d.app().session.project.items.len(), n0, "Clear removes the selected new matte");
    for v in ["List", "Icon", "Freeform"] {
        d.click(&format!("project.view.{v}"));
        assert_eq!(format!("{:?}", d.app().session.prefs.project_panel.view.mode), v);
    }
    d.click("project.view.Icon");
    assert!(d.has("project.sortIcons"));
    d.click("project.sortIcons");
    d.click("project.sortIcons.Name");
    assert_eq!(d.app().session.prefs.project_panel.view.icon_sort.column, "Name");
}

#[test]
fn new_bin_asks_for_its_name() {
    // #456: New Bin opens the name field of the new bin instead of leaving it "New Bin"
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    d.click("project.button.file.newBin");
    d.frames(2);
    let bin = d.app().ui.project_panel.rename.as_ref().and_then(|r| r.bin).expect("the new bin's name is being edited");
    assert!(d.has("project.rename"), "the name field is shown");
    d.ok("ui.type", json!({"text": "Interviews"}));
    d.key("Enter");
    let name = d.app().session.project.root.find_bin(filmcraft_project::BinId(bin)).unwrap().name.clone();
    assert_eq!(name, "Interviews");
    // with a name (agents) the bin is named directly and nothing is edited
    let r = d.ok("ui.menu.invoke", json!({"id": "file.newBin", "params": {"name": "B-roll"}}));
    assert!(r["bin"].as_u64().is_some(), "{r}");
    assert!(d.app().ui.project_panel.rename.is_none());
}

#[test]
fn new_bin_then_clear_removes_the_bin() {
    // leftover Project item selection must not keep Clear from removing the new bin
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    d.click("project.button.new-item");
    d.wait_for("project.newItem.file.newColorMatte");
    d.click("project.newItem.file.newColorMatte");
    d.click("colorMatte.ok");
    let items0 = d.app().session.project.items.len();
    let bins0 = d.app().session.project.root.children.len();
    assert!(!d.app().session.state.project_selection.is_empty());
    d.click("project.button.file.newBin");
    d.frames(2);
    let bin = d.app().ui.project_panel.selected_bin.expect("the new bin is selected");
    assert!(d.app().session.state.project_selection.is_empty(), "New Bin clears leftover item selection");
    d.click("project.button.project.delete");
    d.frames(2);
    assert!(d.app().session.project.root.find_bin(filmcraft_project::BinId(bin)).is_none(), "Clear removes the new bin");
    assert_eq!(d.app().session.project.root.children.len(), bins0);
    assert_eq!(d.app().session.project.items.len(), items0, "clips already in the project stay");
}

/// #2106: with nothing selected, Clear and Automate to Sequence are disabled, as in the ≡ menu: a
/// click does nothing (it used to only put "Select items to clear" / "select an item" in the
/// status bar). With an item selected both act.
#[test]
fn clear_and_automate_buttons_need_a_selection() {
    let mut d = project_driver();
    d.exec("project.view.set", json!({"view": "list"}));
    d.exec("project.select", json!({"items": []}));
    d.app().ui.project_panel.selected_bin = None;
    d.frames(2);
    let project = d.app().session.project.clone();
    d.app().ui.status.clear();
    for id in ["project.button.project.delete", "project.button.clip.automateToSequence"] {
        d.click(id);
        assert!(d.app().ui.status.is_empty(), "{id}: no message: {}", d.app().ui.status);
        assert!(std::sync::Arc::ptr_eq(&project, &d.app().session.project), "{id}: nothing changed");
        assert!(!d.has("automate.ok"), "{id}: no dialog");
    }
    // an item selected: Automate to Sequence opens its dialog, Clear removes the item
    let item = d.app().session.project.items.values().find(|i| i.as_media().is_some()).map(|i| i.id).unwrap();
    d.exec("project.select", json!({"items": [item.0]}));
    d.frames(2);
    d.click("project.button.clip.automateToSequence");
    assert!(d.has("automate.ok"), "the Automate To Sequence dialog");
    d.click("automate.cancel");
    // with no sequence open, Automate to Sequence has nowhere to go: disabled, as its command is
    let seq = d.app().session.state.active_sequence.take();
    d.frames(2);
    d.click("project.button.clip.automateToSequence");
    assert!(!d.has("automate.ok"), "no sequence: no dialog");
    assert!(d.app().ui.status.is_empty(), "no sequence: no message: {}", d.app().ui.status);
    d.app().session.state.active_sequence = seq;
    d.frames(2);
    d.click("project.button.project.delete");
    assert!(d.app().session.project.item(item).is_none(), "Clear removes the selected item");
}

// ------------------------------------------------------------------------------------ Media Browser

fn media_dir(tag: &str) -> std::path::PathBuf {
    let dir = std::env::temp_dir().join(format!("fc-mb-ui-{tag}-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(dir.join("Selects")).unwrap();
    let wav = filmcraft_media::wav::write_wav16(&[0.0; 9600], 2, 48_000);
    for n in ["a-interview.wav", "b-roll.wav"] {
        std::fs::write(dir.join(n), &wav).unwrap();
    }
    std::fs::write(dir.join("Selects").join("pick.wav"), &wav).unwrap();
    std::fs::write(dir.join("readme.txt"), b"not media").unwrap();
    dir
}

#[test]
fn file_dialog_import_uses_shown_bin_unless_explicit() {
    let dir = media_dir("import-bin");
    let path = dir.join("a-interview.wav").to_string_lossy().into_owned();
    let mut app = FilmcraftApp::new(Session::default());
    app.hooks.pick_files = Some(Box::new(move |_| vec![path.clone()]));
    let parent = app.session.execute("file.newBin", json!({"name": "Footage"})).unwrap()["bin"].as_u64().unwrap();
    let child = app.session.execute("file.newBin", json!({"name": "Selects", "parent": parent})).unwrap()["bin"].as_u64().unwrap();
    let root = app.session.project.root.id.0;
    app.ui.project_panel.tabs.push(filmcraft_ui_egui::panels::project::BinTab { bin: parent, ..Default::default() });
    for (shown, tab, params, expected) in [
        (None, None, json!({}), root),
        (Some(child), None, json!({}), child),
        (Some(child), Some(0), json!({}), parent),
        (Some(child), None, json!({"bin": null}), root),
        (Some(parent), None, json!({"bin": child}), child),
    ] {
        app.ui.project_panel.bin = shown;
        app.ui.project_panel.active_tab = tab;
        let result = app.file_dialog("file.import", &params).unwrap();
        assert!(result["errors"].as_array().unwrap().is_empty(), "{result}");
        let item = ItemId(result["items"][0].as_u64().unwrap());
        let bin = app.session.project.root.find_bin(filmcraft_project::BinId(expected)).unwrap();
        assert!(bin.children.contains(&BinEntry::Item(item)), "shown={shown:?}, tab={tab:?}, params={params}: expected bin {expected}");
    }
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn media_browser_navigation_import_and_columns() {
    let dir = media_dir("nav");
    let d0 = dir.to_string_lossy().to_string();
    let mut d = Driver::with(Session::default());
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.ok("ui.set", json!({"focused": "MediaBrowser"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.exec("mediaBrowser.navigate", json!({"path": d0}));
    d.frames(3);
    d.wait_for("mediaBrowser.entry.a-interview.wav");
    assert!(d.has("mediaBrowser.entry.Selects") && !d.has("mediaBrowser.entry.readme.txt"));
    for id in [
        "mediaBrowser.back",
        "mediaBrowser.forward",
        "mediaBrowser.up",
        "mediaBrowser.path",
        "mediaBrowser.fileTypes",
        "mediaBrowser.ingest",
        "mediaBrowser.importAsImageSequence",
        "mediaBrowser.tree.localDrives",
    ] {
        assert!(d.has(id), "{id}");
    }
    // double-click a folder, then Back / Forward
    // type a directory into the path field
    d.click("mediaBrowser.path");
    d.key("Cmd+A");
    d.ok("ui.type", json!({"text": format!("{d0}/Selects")}));
    d.key("Enter");
    d.wait_for("mediaBrowser.entry.pick.wav");
    d.click("mediaBrowser.back");
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    d.click("mediaBrowser.forward");
    d.wait_for("mediaBrowser.entry.pick.wav");
    d.click("mediaBrowser.up");
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    // Favorites and Recent Directories in the tree
    d.click("panel.menu.MediaBrowser");
    d.click("mediaBrowser.menu.favorite");
    assert_eq!(d.app().session.prefs.media_browser.favorites, std::slice::from_ref(&d0));
    d.frames(2);
    let fav_name = dir.file_name().unwrap().to_string_lossy().to_string();
    assert!(d.has(&format!("mediaBrowser.tree.favorites.{fav_name}")));
    assert!(d.has("mediaBrowser.tree.recent"));
    // select two files and Import from the panel menu
    d.click("mediaBrowser.entry.a-interview.wav");
    d.ok("ui.click", json!({"id": "mediaBrowser.entry.b-roll.wav", "command": true}));
    d.frames(2);
    assert_eq!(d.app().session.browser.selection.len(), 2);
    assert!(d.label("mediaBrowser.count").starts_with("2 of 2"));
    d.snapshot("media-browser-list", Some("panel.MediaBrowser"));
    d.click("panel.menu.MediaBrowser");
    d.ok("ui.scroll", json!({"id": "panel.menu.scroll", "dy": -1200}));
    d.frames(4);
    d.click("mediaBrowser.menu.import");
    assert_eq!(d.app().session.project.items.len(), 2);
    // Shift+O opens the selection in the Source monitor (already imported: no duplicate)
    d.click("mediaBrowser.entry.b-roll.wav");
    d.ok("ui.set", json!({"focused": "MediaBrowser"}));
    d.key("Shift+O");
    assert!(d.app().session.state.source_item.is_some());
    assert_eq!(d.app().session.project.items.len(), 2);
    // opening a clip in Source shows Source, so the Media Browser is no longer maximized (#3669)
    assert_ne!(d.app().ui.keys.maximized, Some(filmcraft_ui_egui::dock::PanelKind::MediaBrowser));
    d.ok("ui.set", json!({"focused": "MediaBrowser"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.frames(2);
    // Edit Columns…
    d.click("panel.menu.MediaBrowser");
    d.click("mediaBrowser.menu.editColumns");
    d.click("mediaBrowser.columns.Audio Info");
    d.click("mediaBrowser.columns.ok");
    assert!(d.app().session.prefs.media_browser.columns.contains(&"Audio Info".to_string()));
    d.frames(6);
    assert!(d.has("mediaBrowser.header.Audio Info"));
    // thumbnails view and the file-type filter
    d.click("mediaBrowser.view.thumbnails");
    assert_eq!(d.app().session.prefs.media_browser.view, "thumbnails");
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    d.snapshot("media-browser-thumbnails", Some("panel.MediaBrowser"));
    d.exec("mediaBrowser.settings", json!({"fileTypes": "image", "view": "list"}));
    d.frames(3);
    assert!(!d.has("mediaBrowser.entry.b-roll.wav") && d.has("mediaBrowser.entry.Selects"));
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn media_browser_list_columns_resize_by_their_right_edge() {
    let dir = media_dir("resize");
    let prefs_path = dir.join("preferences.json");
    let mut session = Session::default();
    session.prefs_path = Some(prefs_path.clone());
    let mut d = Driver::with(session);
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.ok("ui.set", json!({"focused": "MediaBrowser"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.exec("mediaBrowser.navigate", json!({"path": dir.to_string_lossy()}));
    d.frames(3);
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    let name0 = d.rect("mediaBrowser.header.Name");
    let next0 = d.rect("mediaBrowser.header.Frame Rate");
    // drag the Name header's right edge 60 points to the right (saved in preferences)
    let (ex, ey) = (name0[0] + name0[2] - 1.0, name0[1] + name0[3] / 2.0);
    d.ok("ui.drag", json!({"from": {"x": ex, "y": ey}, "to": {"x": ex + 60.0, "y": ey}}));
    d.frames(3);
    let name1 = d.rect("mediaBrowser.header.Name");
    let next1 = d.rect("mediaBrowser.header.Frame Rate");
    assert!(name1[2] > name0[2] + 30.0, "Name {} → {}", name0[2], name1[2]);
    assert!(next1[0] > next0[0] + 30.0, "Frame Rate starts at {} → {}", next0[0], next1[0]);
    let saved = d.app().session.prefs.media_browser.column_widths.get("Name").copied().unwrap_or_default();
    assert!((saved - name1[2]).abs() < 1.0, "saved {saved}, drawn {}", name1[2]);
    // and written to preferences.json, so it survives a restart
    let on_disk = filmcraft_engine::autosave::Preferences::load(&prefs_path).media_browser.column_widths.get("Name").copied();
    assert_eq!(on_disk, Some(saved), "preferences.json");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn media_browser_column_dragged_past_the_header_is_still_saved() {
    let dir = media_dir("resize-out");
    let prefs_path = dir.join("preferences.json");
    let mut session = Session::default();
    session.prefs_path = Some(prefs_path.clone());
    let mut d = Driver::with(session);
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.ok("ui.set", json!({"focused": "MediaBrowser"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.exec("mediaBrowser.navigate", json!({"path": dir.to_string_lossy()}));
    d.frames(3);
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    // the last column's edge, dragged until it (and its handle) is past the header's right end
    let size = d.rect("mediaBrowser.header.Size");
    let (ex, ey) = (size[0] + size[2] - 1.0, size[1] + size[3] / 2.0);
    d.ok("ui.drag", json!({"from": {"x": ex, "y": ey}, "to": {"x": ex + 800.0, "y": ey}}));
    d.frames(3);
    assert_eq!(d.app().ui.media_browser.column_drag, None, "the drag ended");
    let on_disk = filmcraft_engine::autosave::Preferences::load(&prefs_path).media_browser.column_widths.get("Size").copied();
    assert_eq!(on_disk, Some(800.0), "preferences.json");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn media_browser_list_clamps_a_hand_edited_column_width() {
    let dir = media_dir("clamp");
    let mut session = Session::default();
    // a preferences file edited by hand never went through the command's clamp
    session.prefs.media_browser.column_widths.insert("Name".into(), 1e30);
    let mut d = Driver::with(session);
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.ok("ui.set", json!({"focused": "MediaBrowser"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.exec("mediaBrowser.navigate", json!({"path": dir.to_string_lossy()}));
    d.frames(3);
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    let name = d.rect("mediaBrowser.header.Name");
    assert!((name[2] - 800.0).abs() < 1.0, "Name is {} wide", name[2]);
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn media_browser_drag_imports_into_the_project_panel() {
    let dir = media_dir("drag");
    let mut session = Session::default();
    session.execute("file.openDemoProject", json!({})).unwrap();
    let mut d = Driver::with(session);
    // the Editing workspace has Project and Media Browser in one group: put the browser beside it
    d.ok("ui.set", json!({"workspace": "Editing"}));
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.exec("mediaBrowser.navigate", json!({"path": dir.to_string_lossy()}));
    d.frames(3);
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    let n0 = d.app().session.project.items.len();
    // dropped on the Media Browser itself: the import is taken back
    let e = d.rect("mediaBrowser.entry.b-roll.wav");
    let from = (e[0] + 40.0, e[1] + e[3] / 2.0);
    d.ok("ui.drag", json!({"from": {"x": from.0, "y": from.1}, "to": {"x": from.0 + 30.0, "y": from.1 + 60.0}}));
    d.frames(6);
    assert_eq!(d.app().session.project.items.len(), n0, "dropped nowhere");
    // dropped on the Timeline: imported and placed
    let tl = d.rect("panel.Timeline");
    d.ok("ui.drag", json!({"from": {"x": from.0, "y": from.1}, "to": {"x": tl[0] + tl[2] * 0.6, "y": tl[1] + tl[3] * 0.75}, "steps": 20}));
    d.frames(6);
    assert_eq!(d.app().session.project.items.len(), n0 + 1, "kept after a drop on the Timeline");
    let _ = std::fs::remove_dir_all(&dir);
}

/// Dragging several selected Media Browser files onto the Timeline (#1360) places every one of
/// them, whether it was already in the project or is imported by the drag.
#[test]
fn media_browser_drag_places_every_selected_file() {
    let dir = media_dir("drag-many");
    let mut session = Session::default();
    session.execute("file.openDemoProject", json!({})).unwrap();
    let mut d = Driver::with(session);
    d.ok("ui.set", json!({"workspace": "Editing"}));
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.exec("mediaBrowser.navigate", json!({"path": dir.to_string_lossy()}));
    d.frames(3);
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    let listed = d.exec("mediaBrowser.list", json!({}));
    let path = |name: &str| listed["entries"].as_array().unwrap().iter().find(|e| e["name"] == json!(name)).unwrap()["path"].clone();
    let (a, b) = (path("a-interview.wav"), path("b-roll.wav"));
    // one file is already in the project, the other is imported by the drag
    d.exec("mediaBrowser.import", json!({"paths": [a]}));
    d.exec("mediaBrowser.select", json!({"paths": [a, b]}));
    d.frames(2);
    let n0 = d.app().session.project.items.len();
    // clips named after each dragged file (a drop inside a long clip also splits that one)
    let placed = |d: &mut Driver, name: &str| {
        d.app().session.active_sequence().map_or(0, |q| q.video_tracks.iter().chain(&q.audio_tracks).flat_map(|t| &t.items).filter(|i| i.name == name).count())
    };
    assert_eq!((placed(&mut d, "a-interview.wav"), placed(&mut d, "b-roll.wav")), (0, 0));
    let e = d.rect("mediaBrowser.entry.b-roll.wav");
    let tl = d.rect("panel.Timeline");
    d.ok("ui.drag", json!({"from": {"x": e[0] + 40.0, "y": e[1] + e[3] / 2.0}, "to": {"x": tl[0] + tl[2] * 0.6, "y": tl[1] + tl[3] * 0.75}, "steps": 20}));
    d.frames(6);
    assert_eq!(d.app().session.project.items.len(), n0 + 1, "only the new file is imported");
    let status = d.app().ui.status.clone();
    assert_eq!((placed(&mut d, "a-interview.wav"), placed(&mut d, "b-roll.wav")), (1, 1), "both files are placed; status: {status}");
    let _ = std::fs::remove_dir_all(&dir);
}

/// Dragging one of several selected Project items onto the Timeline places all of them, back to
/// back, as one undo step; an item outside the selection goes alone.
#[test]
fn dragging_a_selection_to_the_timeline_places_every_item() {
    let mut d = Driver::demo();
    let (bin, items) = d.footage();
    assert!(items.len() >= 3);
    d.exec("file.newSequence", json!({"name": "Drop", "video": 2, "audio": 2}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    let card = |i: u64| format!("project.item.{i}");
    d.wait_for(&card(items[0]));
    let clips = |d: &mut Driver| d.app().session.active_sequence().map(|q| q.video_tracks.iter().map(|t| t.items.len()).sum::<usize>()).unwrap_or(0);
    let steps = d.app().session.history.undo.len();
    let drop = json!({"id": "timeline.tracks", "fx": 0.3, "fy": 0.1});

    // an item that is not selected: one clip
    d.exec("project.select", json!({"items": [items[2]]}));
    d.ok("ui.drag", json!({"from": {"id": card(items[0])}, "to": drop, "steps": 16}));
    d.frames(4);
    assert_eq!(clips(&mut d), 1, "an unselected item goes alone");
    d.exec("edit.undo", json!({}));

    // two of the selection: both, back to back, in one undo step
    d.exec("project.select", json!({"items": [items[0], items[1]]}));
    d.frames(2);
    d.ok("ui.drag", json!({"from": {"id": card(items[0])}, "to": drop, "steps": 16}));
    d.frames(4);
    assert_eq!(clips(&mut d), 2, "the whole selection is placed");
    let mut v1: Vec<(i64, i64)> =
        d.app().session.active_sequence().unwrap().video_tracks.iter().flat_map(|t| t.items.iter()).map(|i| (i.start.0, i.end().0)).collect();
    v1.sort();
    assert_eq!(v1[0].1, v1[1].0, "back to back");
    assert_eq!(d.app().session.history.undo.len(), steps + 1, "the drag is one undo step");
    d.exec("edit.undo", json!({}));
    assert_eq!(clips(&mut d), 0);
}

/// Double-clicking empty space in the Project panel opens Import, also between and beside the
/// Icon view's cards once the project has some. Only the strip under the last row used to answer,
/// so with a project loaded a double-click in the visible blank space did nothing. Real pointer
/// input at 60 frames per second, so the two clicks are a real double-click.
#[test]
fn double_click_empty_area_imports_with_a_project_loaded() {
    fn driver(demo: bool) -> (Driver, std::sync::Arc<std::sync::atomic::AtomicUsize>) {
        let mut session = Session::default();
        if demo {
            session.execute("file.openDemoProject", json!({})).expect("demo project");
        }
        let (tx, rx) = channel();
        let mut app = FilmcraftApp::new(session).with_control(rx);
        let picks = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
        let seen = picks.clone();
        app.hooks.pick_files = Some(Box::new(move |_| {
            seen.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
            Vec::new()
        }));
        let harness = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_step_dt(1.0 / 60.0).with_max_steps(10_000).build_eframe(move |_cc| app);
        let mut d = Driver { harness, tx, snapshots: None };
        d.frames(10);
        (d, picks)
    }
    fn double_click(d: &mut Driver, at: egui::Pos2) {
        let push = |d: &mut Driver, e: egui::Event| d.harness.input_mut().events.push(e);
        // a pause first, as a person makes: clicks closer together continue the last gesture
        // (a triple click) instead of starting a double-click
        d.frames(60);
        push(d, egui::Event::PointerMoved(at));
        d.frames(1);
        for _ in 0..2 {
            for pressed in [true, false] {
                push(d, egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() });
                d.frames(1);
            }
        }
        d.frames(3);
    }
    let count = |p: &std::sync::Arc<std::sync::atomic::AtomicUsize>| p.load(std::sync::atomic::Ordering::SeqCst);

    // an empty project: the whole panel is the empty area
    let (mut d, picks) = driver(false);
    let r = d.rect("project.empty");
    double_click(&mut d, egui::pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0));
    assert_eq!(count(&picks), 1, "empty project");

    // the demo project, Icon view: the gap between the first two bins, and the space right of the
    // last card in the first row
    let (mut d, picks) = driver(true);
    d.ok("ui.set", json!({}));
    let (a, b) = (d.rect("project.bin.1"), d.rect("project.bin.2"));
    assert!((a[1] - b[1]).abs() < 1.0 && b[0] > a[0] + a[2], "bins 1 and 2 share a row: {a:?} {b:?}");
    double_click(&mut d, egui::pos2((a[0] + a[2] + b[0]) / 2.0, a[1] + a[3] / 2.0));
    assert_eq!(count(&picks), 1, "between two bins");
    let row: Vec<[f32; 4]> = d.ids("project.bin.").iter().map(|id| d.rect(id)).filter(|r| (r[1] - a[1]).abs() < 1.0).collect();
    let last = row.iter().fold(a, |m, r| if r[0] > m[0] { *r } else { m });
    let panel = d.rect("project.count");
    if last[0] + last[2] + 30.0 < panel[0] + panel[2] {
        double_click(&mut d, egui::pos2(last[0] + last[2] + 20.0, last[1] + last[3] / 2.0));
        assert_eq!(count(&picks), 2, "right of the last card");
    }
    // a card still takes its own double-click: the bin opens, Import does not
    double_click(&mut d, egui::pos2(a[0] + a[2] / 2.0, a[1] + a[3] / 2.0));
    let picked = count(&picks);
    assert!(picked <= 2, "double-clicking a bin must not open Import");
}

/// The report: with audio placed in the timeline, double-clicking the Project panel's empty space
/// no longer opened Import. A new sequence with a tone on A1 (so the panel shows the sequence and
/// the audio clip as cards); every empty spot opens Import: the strip under the cards and the space
/// beside them.
#[test]
fn double_click_imports_with_audio_in_the_timeline() {
    let mut session = Session::default();
    session.execute("file.newSequence", json!({"name": "Mix", "audio": 2, "video": 1})).unwrap();
    let inter: Vec<f32> = (0..48_000).flat_map(|i| [(i as f32 * 0.0576).sin() * 0.5; 2]).collect();
    let bytes: std::sync::Arc<[u8]> = filmcraft_engine::previews::write_wav_f32(&inter, 48_000).into();
    let item = filmcraft_engine::commands::import_bytes(&mut session, "/tone.wav", bytes, None).unwrap();
    session.execute("timeline.place", json!({"item": item.0, "audioTrack": "A1", "seconds": 0.0})).unwrap();
    let (tx, rx) = channel();
    let mut app = FilmcraftApp::new(session).with_control(rx);
    let picks = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
    let seen = picks.clone();
    app.hooks.pick_files = Some(Box::new(move |_| {
        seen.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        Vec::new()
    }));
    let harness = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_step_dt(1.0 / 60.0).with_max_steps(10_000).build_eframe(move |_cc| app);
    let mut d = Driver { harness, tx, snapshots: None };
    d.frames(10);
    let double_click = |d: &mut Driver, at: egui::Pos2| {
        let push = |d: &mut Driver, e: egui::Event| d.harness.input_mut().events.push(e);
        d.frames(60);
        push(d, egui::Event::PointerMoved(at));
        d.frames(1);
        for _ in 0..2 {
            for pressed in [true, false] {
                push(d, egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() });
                d.frames(1);
            }
        }
        d.frames(3);
    };
    let count = || picks.load(std::sync::atomic::Ordering::SeqCst);
    let cards: Vec<[f32; 4]> = d.ids("project.item.").iter().filter(|id| id.matches('.').count() == 2).map(|id| d.rect(id)).collect();
    assert!(!cards.is_empty(), "the sequence and the tone show as cards");
    let empty = d.rect("project.empty");
    eprintln!("cards {cards:?}, empty strip {empty:?}");
    double_click(&mut d, egui::pos2(empty[0] + empty[2] / 2.0, empty[1] + empty[3] / 2.0));
    let strip = count();
    let last = cards.iter().fold(cards[0], |m, r| if r[0] > m[0] { *r } else { m });
    double_click(&mut d, egui::pos2(last[0] + last[2] + 40.0, last[1] + last[3] / 2.0));
    let beside = count() - strip;
    assert_eq!((strip, beside), (1, 1), "double-click on (the strip under the cards, the space beside them)");
}

// ---- marquee selection (#578)

/// The Footage bin open in place in `view`, with its items' rects (row by row, left to right).
fn footage_in(d: &mut Driver, view: &str) -> Vec<(u64, [f32; 4])> {
    let (bin, items) = d.footage();
    d.exec("project.view.set", json!({"view": view}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    d.wait_for(&format!("project.item.{}", items[0]));
    let mut rects: Vec<(u64, [f32; 4])> = items.iter().map(|i| (*i, d.rect(&format!("project.item.{i}")))).collect();
    rects.sort_by(|a, b| (a.1[1], a.1[0]).partial_cmp(&(b.1[1], b.1[0])).unwrap());
    rects
}

fn selection(d: &mut Driver) -> Vec<u64> {
    let mut s: Vec<u64> = d.app().session.state.project_selection.iter().map(|i| i.0).collect();
    s.sort_unstable();
    s
}

fn sorted(mut v: Vec<u64>) -> Vec<u64> {
    v.sort_unstable();
    v
}

fn centre(r: [f32; 4]) -> (f32, f32) {
    (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0)
}

fn marquee(d: &mut Driver, from: (f32, f32), to: (f32, f32), shift: bool) {
    d.ok("ui.drag", json!({"from": {"x": from.0, "y": from.1}, "to": {"x": to.0, "y": to.1}, "steps": 12, "modifiers": {"shift": shift}}));
    d.frames(3);
}

#[test]
fn marquee_selects_cards_in_icon_view() {
    let mut d = project_driver();
    let cards = footage_in(&mut d, "icon");
    let [(i0, a), (i1, b), (i2, c)] = [cards[0], cards[1], cards[2]];
    assert!((a[1] - c[1]).abs() < 1.0, "the first three cards share a row");
    // from the gap above-left of the first card to the middle of the second
    marquee(&mut d, (a[0] - 4.0, a[1] - 4.0), centre(b), false);
    assert_eq!(selection(&mut d), sorted(vec![i0, i1]));
    // Shift adds
    marquee(&mut d, (c[0] + 4.0, c[1] - 4.0), centre(c), true);
    assert_eq!(selection(&mut d), sorted(vec![i0, i1, i2]));
    // a plain drag replaces
    marquee(&mut d, (a[0] - 4.0, a[1] - 4.0), centre(a), false);
    assert_eq!(selection(&mut d), vec![i0]);
    // the gaps between cards are empty space: a click there deselects
    d.ok("ui.click", json!({"x": a[0] - 4.0, "y": a[1] - 4.0}));
    d.frames(2);
    assert!(selection(&mut d).is_empty());
}

#[test]
fn escape_cancels_a_marquee_and_keeps_the_selection() {
    let mut d = project_driver();
    let cards = footage_in(&mut d, "icon");
    let [(i0, a), (i1, b), (i2, c)] = [cards[0], cards[1], cards[2]];
    d.exec("project.select", json!({"items": [i2]}));
    let send = |d: &mut Driver, e: egui::Event| {
        d.harness.input_mut().events.push(e);
        d.frames(1);
    };
    let (from, to) = (egui::pos2(a[0] - 4.0, a[1] - 4.0), egui::pos2(centre(b).0, centre(b).1));
    send(&mut d, egui::Event::PointerMoved(from));
    send(&mut d, egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
    for k in 1..=10 {
        send(&mut d, egui::Event::PointerMoved(from.lerp(to, k as f32 / 10.0)));
    }
    assert_eq!(selection(&mut d), sorted(vec![i0, i1]), "the selection follows the rectangle");
    send(&mut d, egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() });
    let end = egui::pos2(centre(c).0, centre(c).1);
    send(&mut d, egui::Event::PointerMoved(end));
    send(&mut d, egui::Event::PointerButton { pos: end, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
    d.frames(2);
    assert_eq!(selection(&mut d), vec![i2], "Escape restored the selection the drag began with");
}

#[test]
fn only_the_left_button_draws_a_marquee() {
    let mut d = project_driver();
    let cards = footage_in(&mut d, "icon");
    let [(i0, a), (_, b)] = [cards[0], cards[1]];
    d.exec("project.select", json!({"items": [i0]}));
    let (from, to) = (egui::pos2(a[0] - 4.0, a[1] - 4.0), egui::pos2(centre(b).0, centre(b).1));
    for button in [egui::PointerButton::Middle, egui::PointerButton::Secondary] {
        let mut send = |e: egui::Event| {
            d.harness.input_mut().events.push(e);
            d.frames(1);
        };
        send(egui::Event::PointerMoved(from));
        send(egui::Event::PointerButton { pos: from, button, pressed: true, modifiers: Default::default() });
        for k in 1..=10 {
            send(egui::Event::PointerMoved(from.lerp(to, k as f32 / 10.0)));
        }
        send(egui::Event::PointerButton { pos: to, button, pressed: false, modifiers: Default::default() });
        d.key("Escape");
        assert_eq!(selection(&mut d), vec![i0], "{button:?} drag left the selection alone");
        assert!(!d.has("project.marquee"));
    }
}

#[test]
fn marquee_selects_rows_in_list_view() {
    let mut d = project_driver();
    let rows = footage_in(&mut d, "list");
    let n = rows.len();
    let (last, before_last) = (rows[n - 1], rows[n - 2]);
    let empty = d.rect("project.empty");
    // from the empty space under the rows up into the second-to-last row
    marquee(&mut d, (empty[0] + 60.0, empty[1] + 20.0), (empty[0] + 60.0, centre(before_last.1).1), false);
    assert_eq!(selection(&mut d), sorted(vec![last.0, before_last.0]));
}

#[test]
fn marquee_selects_cards_in_freeform_view() {
    let mut d = project_driver();
    let cards = footage_in(&mut d, "freeform");
    let [(i0, a), (i1, b)] = [cards[0], cards[1]];
    assert!((a[1] - b[1]).abs() < 1.0, "the first two cards share a row");
    marquee(&mut d, (a[0] - 6.0, a[1] - 6.0), centre(b), false);
    assert_eq!(selection(&mut d), sorted(vec![i0, i1]));
    assert!(!d.app().session.project.item(ItemId(i0)).unwrap().metadata.contains_key(FREEFORM_POS), "the marquee moved no card");
}

/// The Project selection can hold a bin beside items (one id space). Dragging the items still
/// places them: the bin is left out instead of failing the whole drop.
#[test]
fn a_bin_in_the_selection_does_not_stop_the_items_being_placed() {
    let mut d = Driver::demo();
    let (bin, items) = d.footage();
    d.exec("file.newSequence", json!({"name": "Drop", "video": 2, "audio": 2}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    d.wait_for(&format!("project.item.{}", items[0]));
    d.exec("project.select", json!({"items": [items[0], bin, items[1]]}));
    d.frames(2);
    d.ok("ui.drag", json!({"from": {"id": format!("project.item.{}", items[0])}, "to": {"id": "timeline.tracks", "fx": 0.3, "fy": 0.1}, "steps": 16}));
    d.frames(4);
    let clips = d.app().session.active_sequence().map(|q| q.video_tracks.iter().map(|t| t.items.len()).sum::<usize>()).unwrap_or(0);
    assert_eq!(clips, 2, "status: {}", d.app().ui.status);
}

/// Escape during a Media Browser drag (#580) takes the import back, even over the Timeline.
#[test]
fn escape_takes_back_a_media_browser_drag() {
    let dir = media_dir("drag-escape");
    let mut session = Session::default();
    session.execute("file.openDemoProject", json!({})).unwrap();
    let mut d = Driver::with(session);
    d.ok("ui.set", json!({"workspace": "Editing"}));
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.exec("mediaBrowser.navigate", json!({"path": dir.to_string_lossy()}));
    d.frames(3);
    d.wait_for("mediaBrowser.entry.b-roll.wav");
    let (n0, before) = (d.app().session.project.items.len(), d.app().session.project.to_json());
    let e = d.rect("mediaBrowser.entry.b-roll.wav");
    let tl = d.rect("panel.Timeline");
    let (from, to) = (egui::pos2(e[0] + 40.0, e[1] + e[3] / 2.0), egui::pos2(tl[0] + tl[2] * 0.6, tl[1] + tl[3] * 0.75));
    let mut send = |e: egui::Event| {
        d.harness.input_mut().events.push(e);
        d.frames(1);
    };
    let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
    send(egui::Event::PointerMoved(from));
    send(button(from, true));
    for k in 1..=20 {
        send(egui::Event::PointerMoved(from.lerp(to, k as f32 / 20.0)));
        if k == 10 {
            send(egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() });
        }
    }
    send(button(to, false));
    d.frames(6);
    assert_eq!(d.app().session.project.items.len(), n0, "the import was taken back");
    assert_eq!(d.app().session.project.to_json(), before, "nothing was placed on the Timeline");
    let _ = std::fs::remove_dir_all(&dir);
}

/// A clip dragged onto the New Item button makes a sequence from it, as File ▸ New ▸ Sequence
/// From Clip does (#2855): named after the clip, with its frame size and rate, the clip on the
/// timeline and the sequence open. One of several selected items brings the whole selection.
#[test]
fn dragging_clips_onto_new_item_makes_a_matching_sequence() {
    let mut d = Driver::demo();
    let (bin, items) = d.footage();
    assert!(items.len() >= 3);
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    let card = |i: u64| format!("project.item.{i}");
    d.wait_for(&card(items[0]));
    let sequences = |d: &mut Driver| d.app().session.project.items.values().filter(|i| matches!(i.kind, filmcraft_project::ItemKind::Sequence(_))).count();
    let clips = |d: &mut Driver| d.app().session.active_sequence().map(|q| q.video_tracks.iter().map(|t| t.items.len()).sum::<usize>()).unwrap_or(0);
    let drop = json!({"id": "project.button.new-item"});
    // footage that differs from a new sequence's defaults, so matching it shows
    if let Some(filmcraft_project::ItemKind::Media(m)) = std::sync::Arc::make_mut(&mut d.app().session.project).item_mut(ItemId(items[0])).map(|i| &mut i.kind)
        && let Some(v) = m.info.video.as_mut()
    {
        (v.width, v.height, v.frame_rate) = (1280, 720, filmcraft_time::FrameRate::FPS_25);
    }
    let def = filmcraft_project::SequenceSettings::default();
    assert_ne!((def.width, def.height, def.frame_rate), (1280, 720, filmcraft_time::FrameRate::FPS_25));
    let n0 = sequences(&mut d);

    // a drop on another footer button, or a Source Monitor drag, makes nothing
    d.ok("ui.drag", json!({"from": {"id": card(items[0])}, "to": {"id": "project.button.file.newBin"}, "steps": 16}));
    d.frames(4);
    assert_eq!(sequences(&mut d), n0, "New Bin is not a drop target");
    d.exec("source.open", json!({"item": items[0]}));
    d.wait_for("source.drag.both");
    d.ok("ui.drag", json!({"from": {"id": "source.drag.both"}, "to": drop, "steps": 16}));
    d.frames(4);
    assert_eq!(sequences(&mut d), n0, "a Source Monitor drag is not taken");

    // an item that is not selected: a sequence of that clip alone
    d.exec("project.select", json!({"items": [items[2]]}));
    let steps = d.app().session.history.undo.len();
    d.ok("ui.drag", json!({"from": {"id": card(items[0])}, "to": drop, "steps": 16}));
    d.frames(4);
    assert_eq!(sequences(&mut d), n0 + 1, "the drop makes one sequence");
    assert!(!d.has("project.newItem.file.newSequence"), "the drop does not open the New Item menu");
    let app = d.app();
    let clip = app.session.project.item(ItemId(items[0])).unwrap().clone();
    let filmcraft_project::ItemKind::Media(m) = &clip.kind else { panic!("footage is media") };
    let v = m.info.video.clone().expect("footage has video");
    let q = app.session.active_sequence().expect("the new sequence is active");
    let seq = app.session.state.active_sequence.unwrap();
    assert_eq!(app.session.project.item(seq).unwrap().name, clip.name, "named after the clip");
    assert_eq!((q.settings.width, q.settings.height, q.settings.frame_rate), (v.width, v.height, v.frame_rate), "the clip's frame size and rate");
    assert_eq!(q.video_tracks[0].items.first().map(|c| c.item), Some(ItemId(items[0])), "the clip is on the timeline");
    assert_eq!(app.session.history.undo.len(), steps + 1, "one undo step");
    assert_eq!(clips(&mut d), 1, "an unselected item goes alone");

    // two of the selection: both, back to back, in one sequence
    d.exec("project.select", json!({"items": [items[0], items[1]]}));
    d.frames(2);
    d.ok("ui.drag", json!({"from": {"id": card(items[1])}, "to": drop, "steps": 16}));
    d.frames(4);
    assert_eq!(sequences(&mut d), n0 + 2);
    assert_eq!(clips(&mut d), 2, "the whole selection is placed");
}

// ---- a dragged size or width is written to preferences.json on release

/// A session that saves its preferences in a fresh temporary directory, and that file's path.
fn session_saving_prefs(tag: &str, demo: bool) -> (Session, std::path::PathBuf) {
    let dir = std::env::temp_dir().join(format!("fc-prefs-drag-{tag}-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let mut session = Session::default();
    if demo {
        session.execute("file.openDemoProject", json!({})).unwrap();
    }
    session.prefs_path = Some(dir.join("preferences.json"));
    (session, dir.join("preferences.json"))
}

fn saved_prefs(path: &std::path::Path) -> filmcraft_engine::autosave::Preferences {
    filmcraft_engine::autosave::Preferences::load(path)
}

#[test]
fn a_dragged_list_column_width_is_written_to_preferences() {
    let (session, path) = session_saving_prefs("column", true);
    let mut d = Driver::with(session);
    d.ok("ui.panel.show", json!({"panel": "Project"}));
    d.ok("ui.set", json!({"focused": "Project"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    footage_in(&mut d, "list");
    let width = |p: &filmcraft_engine::autosave::Preferences| p.project_panel.view.columns.iter().find(|c| c.name == "Frame Rate").map(|c| c.width);
    let w0 = width(&d.app().session.prefs).unwrap();
    let r = d.rect("project.list.resize.Frame Rate");
    let (cx, cy) = centre(r);
    d.ok("ui.drag", json!({"from": {"x": cx, "y": cy}, "to": {"x": cx + 60.0, "y": cy}}));
    d.frames(3);
    let w1 = width(&d.app().session.prefs).unwrap();
    assert!(w1 > w0 + 30.0, "{w0} → {w1}");
    assert_eq!(width(&saved_prefs(&path)), Some(w1), "preferences.json");
    let _ = std::fs::remove_dir_all(path.parent().unwrap());
}

#[test]
fn a_list_column_dragged_past_the_header_is_still_written_to_preferences() {
    let (session, path) = session_saving_prefs("column-out", true);
    let mut d = Driver::with(session);
    d.ok("ui.panel.show", json!({"panel": "Project"}));
    d.ok("ui.set", json!({"focused": "Project"}));
    footage_in(&mut d, "list");
    // in the docked panel, 800 points of drag take the edge (and its handle) past the header's end
    let r = d.rect("project.list.resize.Frame Rate");
    let (cx, cy) = centre(r);
    d.ok("ui.drag", json!({"from": {"x": cx, "y": cy}, "to": {"x": cx + 800.0, "y": cy}}));
    d.frames(3);
    assert_eq!(d.app().ui.project_panel.column_drag, None, "the drag ended");
    let width = saved_prefs(&path).project_panel.view.columns.iter().find(|c| c.name == "Frame Rate").map(|c| c.width);
    assert_eq!(width, Some(800.0), "preferences.json");
    let _ = std::fs::remove_dir_all(path.parent().unwrap());
}

#[test]
fn a_dragged_icon_size_is_written_to_preferences() {
    let (session, path) = session_saving_prefs("icon-size", true);
    let mut d = Driver::with(session);
    d.ok("ui.panel.show", json!({"panel": "Project"}));
    footage_in(&mut d, "icon");
    let s0 = d.app().session.prefs.project_panel.view.icon_size;
    let r = d.rect("project.iconSize");
    let y = r[1] + r[3] / 2.0;
    d.ok("ui.drag", json!({"from": {"x": r[0] + r[2] * 0.3, "y": y}, "to": {"x": r[0] + r[2] * 0.9, "y": y}}));
    d.frames(3);
    let s1 = d.app().session.prefs.project_panel.view.icon_size;
    assert!(s1 > s0 + 20.0, "{s0} → {s1}");
    assert_eq!(saved_prefs(&path).project_panel.view.icon_size, s1, "preferences.json");
    let _ = std::fs::remove_dir_all(path.parent().unwrap());
}

#[test]
fn a_dragged_media_browser_thumbnail_size_is_written_to_preferences() {
    let dir = media_dir("thumbnail-size");
    let (session, path) = session_saving_prefs("thumbnail-size", false);
    let mut d = Driver::with(session);
    d.ok("ui.panel.show", json!({"panel": "MediaBrowser"}));
    d.ok("ui.set", json!({"focused": "MediaBrowser"}));
    d.ok("ui.menu.invoke", json!({"id": "window.maximizeFrame"}));
    d.exec("mediaBrowser.navigate", json!({"path": dir.to_string_lossy()}));
    d.exec("mediaBrowser.settings", json!({"view": "thumbnails", "thumbnailSize": 100.0}));
    d.wait_for("mediaBrowser.thumbnailSize");
    let r = d.rect("mediaBrowser.thumbnailSize");
    let y = r[1] + r[3] / 2.0;
    d.ok("ui.drag", json!({"from": {"x": r[0] + r[2] * 0.2, "y": y}, "to": {"x": r[0] + r[2] * 0.9, "y": y}}));
    d.frames(3);
    let s1 = d.app().session.prefs.media_browser.thumbnail_size;
    assert!(s1 > 150.0, "100 → {s1}");
    assert_eq!(saved_prefs(&path).media_browser.thumbnail_size, s1, "preferences.json");
    let _ = std::fs::remove_dir_all(path.parent().unwrap());
    let _ = std::fs::remove_dir_all(&dir);
}

/// #3774: the footer's Zoom sizes List view's thumbnails and scales the Freeform canvas, not
/// only Icon view's cards. A List without thumbnails has nothing for it to size, so its rows stay.
#[test]
fn zoom_sizes_list_thumbnails_and_the_freeform_canvas() {
    let mut d = project_driver();
    let items: Vec<u64> = footage_in(&mut d, "list").iter().map(|(i, _)| *i).collect();
    let row = |d: &mut Driver| {
        d.frames(3);
        d.rect(&format!("project.item.{}", items[0]))[3]
    };
    // List without thumbnails: the rows do not change
    let plain = row(&mut d);
    d.exec("project.view.set", json!({"iconSize": 300.0}));
    assert_eq!(row(&mut d), plain, "no thumbnails, nothing to size");
    // List with thumbnails: the row follows the thumbnail size
    d.exec("project.view.set", json!({"thumbnails": true, "iconSize": 110.0}));
    let small = row(&mut d);
    d.exec("project.view.set", json!({"iconSize": 300.0}));
    let big = row(&mut d);
    assert!(small > plain && (big - 120.0).abs() < 1.0, "rows {plain} / {small} / {big}");
    // the bigger thumbnail does not cover the name or the next column: the Name column widens
    let name = d.rect("project.list.header.Name");
    let next = d.rect("project.list.header.Frame Rate");
    let thumb_w = (big - 6.0) * 16.0 / 9.0;
    assert!(name[2] >= thumb_w + 120.0 && next[0] >= name[0] + name[2] - 1.0, "Name {name:?}, Frame Rate {next:?}");
    let saved = d.app().session.prefs.project_panel.view.columns.first().map(|c| c.width);
    assert!(saved.is_some_and(|w| w < name[2]), "the saved width is unchanged: {saved:?}");

    // Freeform: twice the size draws every card twice as big and twice as far from the origin
    d.exec("project.view.set", json!({"iconSize": 110.0}));
    d.exec("project.freeform.move", json!({"items": [items[0]], "x": 40, "y": 40}));
    d.exec("project.freeform.move", json!({"items": [items[1]], "x": 240, "y": 40}));
    d.exec("project.view.set", json!({"view": "freeform"}));
    let card = |d: &mut Driver, i: u64| {
        d.frames(3);
        let (r, c) = (d.rect(&format!("project.item.{i}")), d.rect("project.freeform"));
        (r[0] - c[0], r[2])
    };
    let ((x0, w0), (x1, _)) = (card(&mut d, items[0]), card(&mut d, items[1]));
    d.exec("project.view.set", json!({"iconSize": 220.0}));
    let ((x0z, w0z), (x1z, _)) = (card(&mut d, items[0]), card(&mut d, items[1]));
    assert!((w0z - 2.0 * w0).abs() < 1.0, "card width {w0} → {w0z}");
    assert!(((x1z - x0z) - 2.0 * (x1 - x0)).abs() < 1.0, "spacing {} → {}", x1 - x0, x1z - x0z);
    // a drag at that zoom moves the card by its on-canvas distance: 100 points on screen are 50
    let r = d.rect(&format!("project.item.{}", items[0]));
    let from = (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
    d.ok("ui.drag", json!({"from": {"x": from.0, "y": from.1}, "to": {"x": from.0 + 100.0, "y": from.1}, "steps": 16}));
    d.frames(4);
    let pos = d.app().session.project.item(ItemId(items[0])).unwrap().metadata.get(FREEFORM_POS).cloned().expect("card placed");
    let (x, y, _) = filmcraft_engine::project_panel::parse_pos(&pos).unwrap();
    assert!((x - 90.0).abs() < 3.0 && (y - 40.0).abs() < 3.0, "moved to {x},{y}");
}

/// #3774 review: zoomed in, the Freeform commands get the width the cards are drawn at, so
/// Align to Grid keeps the cards in the rows shown instead of an 800-point layout's.
#[test]
fn a_zoomed_freeform_canvas_aligns_the_cards_it_shows() {
    let mut d = project_driver();
    let (bin, items) = d.footage();
    d.exec("project.view.set", json!({"view": "freeform", "iconSize": 396.0}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    d.wait_for(&format!("project.item.{}", items[0]));
    d.frames(3);
    let canvas = d.rect("project.freeform");
    let z = 396.0 / 110.0;
    // where each card is drawn, on the unscaled canvas
    let shown: Vec<(f32, f32)> = items
        .iter()
        .map(|i| {
            let r = d.rect(&format!("project.item.{i}"));
            ((r[0] - canvas[0]) / z, (r[1] - canvas[1]) / z)
        })
        .collect();
    assert!(shown.iter().any(|s| s.1 > shown[0].1 + 1.0), "the zoomed canvas wraps the cards into rows: {shown:?}");
    // the canvas menu, on empty canvas to the right of the cards
    let panel = d.rect("panel.Project");
    d.ok("ui.click", json!({"x": panel[0] + panel[2] - 30.0, "y": canvas[1] + 20.0, "button": "right"}));
    d.frames(2);
    d.click("project.canvasMenu.alignToGrid");
    d.frames(2);
    for (i, (sx, sy)) in items.iter().zip(&shown) {
        let pos = d.app().session.project.item(ItemId(*i)).unwrap().metadata.get(FREEFORM_POS).cloned().expect("aligned");
        let (x, y, _) = filmcraft_engine::project_panel::parse_pos(&pos).unwrap();
        assert!((x - sx).abs() <= 20.0 && (y - sy).abs() <= 20.0, "item {i}: aligned to {x},{y}, shown at {sx},{sy}");
    }
}

/// #3774 review: a card's menu acts on the selected cards of its own bin. A selection that also
/// holds an item of another bin stacks only this bin's cards (laid out at this canvas's width).
#[test]
fn a_card_menu_stacks_only_the_selected_cards_of_its_bin() {
    let mut d = project_driver();
    let (bin, items) = d.footage();
    let project = d.app().session.project.clone();
    let other =
        project.items.values().map(|i| i.id).find(|i| project.root.parent_of(*i).map(|b| b.0) != Some(bin)).map(|i| i.0).expect("an item outside Footage");
    d.exec("project.view.set", json!({"view": "freeform"}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    let card = format!("project.item.{}", items[0]);
    d.wait_for(&card);
    d.exec("project.select", json!({"items": [other, items[0], items[1]]}));
    d.ok("ui.click", json!({"id": card, "button": "right"}));
    d.frames(2);
    d.click("project.cardMenu.stack");
    let stack = |d: &mut Driver, i: u64| d.app().session.project.item(ItemId(i)).unwrap().metadata.get(FREEFORM_STACK).cloned();
    assert!(stack(&mut d, items[0]).is_some() && stack(&mut d, items[1]).is_some(), "this bin's cards are stacked");
    assert_eq!(stack(&mut d, other), None, "the other bin's item is left alone");
}

/// #3774 review: Save Arrangement takes the bin of the canvas it was opened on; an unknown bin
/// is refused instead of saving to the root bin.
#[test]
fn save_arrangement_refuses_an_unknown_bin() {
    let mut d = project_driver();
    let (bin, _) = d.footage();
    for bad in [json!(987_654), json!(-1), json!("footage"), json!(1.5)] {
        let r = d.call("ui.menu.invoke", json!({"id": "projectPanel.saveArrangement", "params": {"bin": bad, "width": 400.0}}));
        assert_eq!(r["ok"], json!(false), "bin {bad}: {r}");
        assert!(d.app().ui.project_panel.dialog.is_none(), "no dialog for bin {bad}");
    }
    let root = d.app().session.project.root.id.0;
    let saved = d.exec("project.freeform.arrangements", json!({"bin": root}));
    assert_eq!(saved["arrangements"].as_array().map(Vec::len), Some(0), "nothing saved to the root: {saved}");
    // a bin that exists opens the dialog
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.saveArrangement", "params": {"bin": bin, "width": 400.0}}));
    assert!(d.app().ui.project_panel.dialog.is_some());
}

#[test]
fn new_items_land_in_the_bin_the_panel_shows() {
    // #4093: New Item, File > New and the New Sequence and Color Matte dialogs make their item in
    // the open bin, not the project root
    let mut d = project_driver();
    let (bin, _) = d.footage();
    let root = d.app().session.project.root.id;
    let parent = |d: &mut Driver, id: u64| d.app().session.project.root.parent_of(filmcraft_project::ItemId(id));
    let newest = |d: &mut Driver| d.app().session.project.items.keys().map(|i| i.0).max().unwrap();
    let in_root = |d: &mut Driver| d.app().session.project.root.children.len();
    // at the root: still the root
    d.ok("ui.menu.invoke", json!({"id": "file.newBarsAndTone"}));
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(root), "no bin open");
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin, "how": "inPlace"}}));
    d.frames(3);
    let root_children = in_root(&mut d);
    // the footer's New Item menu
    d.click("project.button.new-item");
    d.wait_for("project.newItem.file.newBlackVideo");
    d.click("project.newItem.file.newBlackVideo");
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(bin)), "New Item > Black Video");
    // File > New
    d.ok("ui.menu.invoke", json!({"id": "file.newAdjustmentLayer"}));
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(bin)), "File > New > Adjustment Layer");
    // the Color Matte dialog
    d.ok("ui.menu.invoke", json!({"id": "file.newColorMatte"}));
    d.click("colorMatte.ok");
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(bin)), "Color Matte dialog");
    // the New Sequence dialog
    d.ok("ui.menu.invoke", json!({"id": "file.newSequence"}));
    d.frames(10);
    d.click("sequenceSettings.ok");
    let id = d.app().session.state.active_sequence.unwrap().0;
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(bin)), "New Sequence dialog");
    assert_eq!(in_root(&mut d), root_children, "nothing new in the root");
}

#[test]
fn new_items_land_in_the_bin_of_the_panel_they_were_made_in() {
    // #4093: a floating bin panel makes its items in its own bin while the Project panel shows
    // another one; an explicit `bin: null` is the root, not the shown bin
    let mut d = project_driver();
    let (footage, _) = d.footage();
    let other = d.exec("file.newBin", json!({"name": "Other"}))["bin"].as_u64().unwrap();
    let root = d.app().session.project.root.id;
    let parent = |d: &mut Driver, id: u64| d.app().session.project.root.parent_of(filmcraft_project::ItemId(id));
    let newest = |d: &mut Driver| d.app().session.project.items.keys().map(|i| i.0).max().unwrap();
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": footage, "how": "newWindow"}}));
    d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": other, "how": "inPlace"}}));
    d.frames(3);
    assert!(d.app().ui.project_panel.tabs.first().is_some_and(|t| t.floating && t.bin == footage));
    // the floating panel's New Item menu: a generator, then the Color Matte dialog
    d.click("projectBin.0.button.new-item");
    d.wait_for("projectBin.0.newItem.file.newBlackVideo");
    d.click("projectBin.0.newItem.file.newBlackVideo");
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(footage)), "floating panel > New Item > Black Video");
    d.click("projectBin.0.button.new-item");
    d.wait_for("projectBin.0.newItem.file.newColorMatte");
    d.click("projectBin.0.newItem.file.newColorMatte");
    d.click("colorMatte.ok");
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(footage)), "floating panel > New Item > Color Matte");
    // the New Sequence dialog keeps the bin of the panel it was opened from
    d.click("projectBin.0.button.new-item");
    d.wait_for("projectBin.0.newItem.file.newSequence");
    d.click("projectBin.0.newItem.file.newSequence");
    d.frames(10);
    d.click("sequenceSettings.ok");
    let id = d.app().session.state.active_sequence.unwrap().0;
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(footage)), "floating panel > New Item > Sequence");
    // an explicit null is the root even though the main panel shows a bin
    d.ok("ui.menu.invoke", json!({"id": "file.newBarsAndTone", "params": {"bin": null}}));
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(root), "explicit null bin");
    d.ok("ui.menu.invoke", json!({"id": "file.newBarsAndTone"}));
    let id = newest(&mut d);
    assert_eq!(parent(&mut d, id), Some(filmcraft_project::BinId(other)), "no bin: the shown one");
}