GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! The Project panel's three views: List (columns from Metadata Display, sortable and resizable
//! headers, inline rename, label column, optional thumbnails), Icon (thumbnail cards with hover
//! scrub, In/Out bar, poster frames, Sort Icons) and Freeform (clip cards placed freely, stacks,
//! grid).

use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
use filmcraft_engine::project_panel::{self as pp, Card, SortSpec, ViewMode};
use filmcraft_project::{Bin, BinEntry, BinId, ItemId, ItemKind};
use filmcraft_time::Tick;
use serde_json::json;

use crate::FilmcraftApp;
use crate::icons::{self, Icon};
use crate::panels::project::{Actions, Hover, Inst, View, commit_rename, font, open_bin, quantize};
use crate::theme::Tokens;

const OFFLINE: Color32 = Color32::from_rgb(0xe8, 0x5c, 0x5c);
const BIN_COLOR: Color32 = Color32::from_rgb(237, 150, 58);
/// Width of the label chip lead-in before the Name column.
const LEAD: f32 = 26.0;

pub fn item_icon(k: &ItemKind) -> Icon {
    match k {
        ItemKind::Media(m) => match m.info.kind {
            filmcraft_media::MediaKind::AudioOnly => Icon::Audio,
            filmcraft_media::MediaKind::Still | filmcraft_media::MediaKind::ImageSequence => Icon::Image,
            _ => Icon::Film,
        },
        ItemKind::Sequence(_) => Icon::Sequence,
        ItemKind::Subclip { .. } => Icon::Film,
        ItemKind::AdjustmentLayer { .. } | ItemKind::Graphic { .. } => Icon::Adjust,
    }
}

/// Offline / proxy state of a project item for the badges.
pub struct Badge {
    pub offline: bool,
    pub offline_text: &'static str,
    /// Why an Unreadable item cannot be read: the error the media pool recorded, shown on hover.
    pub offline_reason: Option<String>,
    pub proxy: bool,
    /// Proxies are enabled (the badge is lit).
    pub proxy_on: bool,
}

/// An item's badges in the Project panel, read from its media (a subclip reads its parent's):
/// offline, with the word the badge shows and, for an Unreadable file, the error the media pool
/// recorded; then whether a proxy is attached and whether proxies are on.
pub fn media_badge(app: &FilmcraftApp, it: &filmcraft_project::ProjectItem) -> Badge {
    let mut b = Badge { offline: false, offline_text: "", offline_reason: None, proxy: false, proxy_on: false };
    let target = match &it.kind {
        ItemKind::Subclip { parent, .. } => app.session.project.item(*parent),
        _ => Some(it),
    };
    let Some(m) = target.and_then(|t| t.as_media()) else { return b };
    let id = target.map(|t| t.id).unwrap_or(it.id);
    if m.offline {
        (b.offline, b.offline_text) = (true, tl!("Offline"));
    } else if app.session.offline.missing.contains(&id) {
        (b.offline, b.offline_text) = (true, tl!("Media missing"));
    } else if let Some(st) = app.session.media.offline_status(id) {
        b.offline = true;
        if st.reason == filmcraft_render::offline::OfflineReason::Unreadable {
            b.offline_text = tl!("Unreadable");
            b.offline_reason = Some(st.error).filter(|e| !e.is_empty());
        } else {
            b.offline_text = tl!("Media missing");
        }
    }
    b.proxy = m.proxy.is_some();
    b.proxy_on = app.session.media.use_proxies();
    b
}

/// Paint the List view's offline icon and proxy chip from `at`, and register the offline badge.
fn paint_badges(app: &mut FilmcraftApp, ui: &egui::Ui, b: &Badge, at: egui::Pos2, pre: &str, id: ItemId) {
    let t = app.tokens;
    let mut x = at.x;
    if b.offline {
        let r = Rect::from_center_size(pos2(x + 7.0, at.y), vec2(13.0, 13.0));
        icons::paint(ui.painter(), r, Icon::Offline, OFFLINE);
        offline_badge(app, ui, r, pre, id, b);
        x += 18.0;
    }
    if b.proxy {
        let pr = Rect::from_min_size(pos2(x, at.y - 7.0), vec2(16.0, 14.0));
        ui.painter().rect_filled(pr, 2.0, if b.proxy_on { t.accent } else { Color32::from_gray(70) });
        ui.painter().text(pr.center(), Align2::CENTER_CENTER, "P", Tokens::ui(10.0), Color32::WHITE);
    }
}

/// The part of a List-view name column `name_r` the item's name may use, and whether its badges
/// get the rest. The badges (6 px after the name, then the offline icon's 18 px and the proxy chip's
/// 16 px, as [`paint_badges`] draws them) keep their room at the column's end and a long name is cut
/// short before them, so the name never hides an Unreadable badge and its reason. Only a column too
/// narrow for the badges leaves them out.
fn name_room(b: &Badge, name_r: Rect) -> (Rect, bool) {
    let mut w = 6.0;
    if b.offline {
        w += 18.0;
    }
    if b.proxy {
        w += 16.0;
    }
    // the name starts 2 px into the column
    let fits = (b.offline || b.proxy) && name_r.width() >= w + 2.0;
    let text_r = if fits { Rect::from_min_max(name_r.min, pos2(name_r.max.x - w, name_r.max.y)) } else { name_r };
    (text_r, fits)
}

/// Register the offline badge drawn at `rect`. An Unreadable badge shows on hover why the file
/// cannot be read, such as "no decoder for Apple Intermediate Codec video" (#3646).
fn offline_badge(app: &mut FilmcraftApp, ui: &egui::Ui, rect: Rect, pre: &str, id: ItemId, badge: &Badge) {
    app.auto.add(&format!("{pre}.item.{}.offline", id.0), rect, badge.offline_text);
    if let Some(why) = &badge.offline_reason {
        ui.interact(rect, egui::Id::unique((pre, "offline", id.0)), Sense::hover()).on_hover_text(why);
    }
}

fn matches_filter(app: &FilmcraftApp, id: ItemId, filter: &str) -> bool {
    app.session.project.item(id).is_some_and(|i| pp::listed(&app.session.project, i) && name_matches(&i.name, filter))
}

/// The search finds a name holding every word typed, in any order: "comedy manager smiling" finds
/// "Comedy manager · medium · smiling", where the typed text as one run of letters would not.
/// `filter` is already lowercase.
fn name_matches(name: &str, filter: &str) -> bool {
    let name = name.to_ascii_lowercase();
    filter.split_whitespace().all(|word| name.contains(word))
}

fn label_color(app: &FilmcraftApp, l: filmcraft_project::Label, custom: Option<filmcraft_project::HexColor>) -> Color32 {
    let c = custom.map_or_else(|| app.session.prefs.labels.rgb(l), |c| c.0);
    Color32::from_rgb(c[0], c[1], c[2])
}

/// Items in display order for a view (keyboard navigation): the list's expanded rows, or the icon
/// / freeform cards.
pub fn items_in_view(app: &FilmcraftApp, v: &View, filter: &str) -> Vec<ItemId> {
    let p = &app.session.project;
    let Some(bin) = p.root.find_bin(v.bin) else { return Vec::new() };
    match v.mode {
        ViewMode::List => {
            let sort = &app.session.prefs.project_panel.view.sort;
            let mut out = Vec::new();
            fn walk(app: &FilmcraftApp, b: &Bin, sort: &SortSpec, filter: &str, out: &mut Vec<ItemId>) {
                let (bins, items) = pp::bin_children(&app.session.project, b, sort);
                for bid in bins {
                    if (app.ui.expanded_bins.contains(&bid.0) || !filter.is_empty())
                        && let Some(sub) = app.session.project.root.find_bin(bid)
                    {
                        walk(app, sub, sort, filter, out);
                    }
                }
                out.extend(items.into_iter().filter(|i| matches_filter(app, *i, filter)));
            }
            walk(app, bin, sort, filter, &mut out);
            out
        }
        ViewMode::Icon => icon_order(app, bin, filter),
        ViewMode::Freeform => {
            let mut ids: Vec<ItemId> = Vec::new();
            for e in &bin.children {
                if let BinEntry::Item(i) = e
                    && matches_filter(app, *i, filter)
                {
                    ids.push(*i);
                }
            }
            ids
        }
    }
}

/// Icon view order: Sort Icons column, else the bin's order (User Order). A search shows matches
/// from sub-bins too.
fn icon_order(app: &FilmcraftApp, bin: &Bin, filter: &str) -> Vec<ItemId> {
    let mut ids = Vec::new();
    if filter.is_empty() {
        for e in &bin.children {
            if let BinEntry::Item(i) = e {
                ids.push(*i);
            }
        }
    } else {
        bin.all_items(&mut ids);
    }
    ids.retain(|i| matches_filter(app, *i, filter));
    pp::sort_items(&app.session.project, &mut ids, &app.session.prefs.project_panel.view.icon_sort);
    ids
}

// ------------------------------------------------------------------------------------ shared

/// Modifiers of this frame's click (the pointer event's own, so synthetic Cmd-clicks count too).
pub fn click_modifiers(ui: &egui::Ui) -> egui::Modifiers {
    ui.input(|i| {
        i.events
            .iter()
            .rev()
            .find_map(|e| match e {
                egui::Event::PointerButton { pressed: false, modifiers, .. } => Some(*modifiers),
                _ => None,
            })
            .unwrap_or(i.modifiers)
    })
}

/// The selection after a click on `id`. Shift selects the range from `anchor` to `id` in the
/// shown `order` (plus the current selection with Ctrl/Cmd too), Ctrl/Cmd toggles `id`, a plain
/// click selects only `id`. Without a usable anchor Shift acts like a plain click.
fn click_selection(current: &[ItemId], order: &[ItemId], anchor: Option<ItemId>, id: ItemId, shift: bool, command: bool) -> Vec<ItemId> {
    if shift {
        let pos = |x: ItemId| order.iter().position(|o| *o == x);
        if let (Some(a), Some(b)) = (anchor.and_then(pos), pos(id)) {
            let mut sel = if command { current.to_vec() } else { Vec::new() };
            for i in order.get(a.min(b)..=a.max(b)).unwrap_or_default() {
                if !sel.contains(i) {
                    sel.push(*i);
                }
            }
            return sel;
        }
    } else if command {
        let mut sel = current.to_vec();
        match sel.iter().position(|x| *x == id) {
            Some(p) => {
                sel.remove(p);
            }
            None => sel.push(id),
        }
        return sel;
    }
    vec![id]
}

/// What a right-click menu command acts on: the whole selection when the item right-clicked is
/// part of it, else just that item (Premiere's rule).
fn menu_targets(selection: &[ItemId], id: ItemId) -> Vec<ItemId> {
    if selection.contains(&id) { selection.to_vec() } else { vec![id] }
}

/// Click / double-click / drag / context menu of an item (row, card).
pub(super) struct ItemInteraction<'a> {
    view: &'a View,
    response: &'a egui::Response,
    item: ItemId,
    kind: &'a ItemKind,
    allow_drag: bool,
    allow_menu: bool,
}

pub(super) fn item_interactions(app: &mut FilmcraftApp, ui: &egui::Ui, actions: &mut Actions, interaction: ItemInteraction<'_>) {
    let ItemInteraction { view: v, response: resp, item: id, kind, allow_drag: drag, allow_menu: menu } = interaction;
    if resp.clicked() {
        let mods = click_modifiers(ui);
        let order = if mods.shift { items_in_view(app, v, &app.ui.project_search.to_ascii_lowercase()) } else { Vec::new() };
        let anchor = app.ui.project_panel.anchor.map(ItemId);
        let sel = click_selection(&app.session.state.project_selection, &order, anchor, id, mods.shift, mods.command);
        // a Shift-click keeps the anchor; a plain or Ctrl/Cmd click sets it
        if !mods.shift {
            app.ui.project_panel.anchor = Some(id.0);
        }
        app.ui.project_panel.selected_bin = None;
        actions.push(("project.select".into(), json!({"items": sel.iter().map(|i| i.0).collect::<Vec<_>>()})));
    }
    if resp.double_clicked() {
        let matte = matches!(kind, ItemKind::Media(m) if matches!(m.media, filmcraft_engine::project::MediaRef::Generator(filmcraft_media::Generator::ColorMatte { .. })));
        if matte {
            // like Premiere: double-clicking a Color Matte opens its color picker
            actions.push(("project.select".into(), json!({"items": [id.0]})));
            actions.push(("project.matteColor".into(), json!({})));
        } else {
            let cmd = if matches!(kind, ItemKind::Sequence(_)) { "sequence.open" } else { "source.open" };
            actions.push((cmd.into(), json!({"item": id.0})));
        }
    }
    if drag && resp.drag_started_by(egui::PointerButton::Primary) {
        crate::panels::start_drag_item(ui, id);
    }
    if menu {
        resp.context_menu(|ui| item_menu(app, ui, id, kind, actions));
    }
}

fn item_menu(app: &mut FilmcraftApp, ui: &mut egui::Ui, id: ItemId, kind: &ItemKind, actions: &mut Actions) {
    let sel = || json!({"items": [id.0]});
    if ui.button(tl!("Rename")).clicked() {
        actions.push(("projectPanel.rename".into(), json!({"item": id.0})));
        ui.close();
    }
    if ui.button(tl!("Open in Source Monitor")).clicked() {
        actions.push(("source.open".into(), json!({"item": id.0})));
        ui.close();
    }
    if matches!(kind, ItemKind::Sequence(_)) && ui.button(tl!("Open in Timeline")).clicked() {
        actions.push(("sequence.open".into(), json!({"item": id.0})));
        ui.close();
    }
    if matches!(kind, ItemKind::Sequence(_)) {
        let b = ui.button(tl!("Sequence Settings…"));
        app.auto.add("project.itemMenu.sequenceSettings", b.rect, "Sequence Settings…");
        if b.clicked() {
            // the dialog edits the active sequence: open the clicked one first, as Premiere does
            actions.push(("sequence.open".into(), json!({"item": id.0})));
            actions.push(("sequence.settings".into(), json!({})));
            ui.close();
        }
    }
    if ui.button(tl!("New Sequence From Clip")).clicked() {
        actions.push(("file.newSequence".into(), json!({"fromItem": id.0})));
        ui.close();
    }
    if ui.button(tl!("Duplicate")).clicked() {
        actions.push(("project.select".into(), sel()));
        actions.push(("edit.duplicate".into(), json!({})));
        ui.close();
    }
    if ui.button(tl!("Set Poster Frame")).clicked() {
        // the hover-scrubbed time when there is one
        let h = app.ui.project_panel.hover.filter(|h| h.item == id.0);
        actions.push(("project.select".into(), sel()));
        actions.push(("clip.setPosterFrame".into(), h.map(|h| json!({"item": id.0, "time": h.time})).unwrap_or(json!({}))));
        ui.close();
    }
    let b = ui.button(tl!("Interpret Footage…"));
    app.auto.add("project.itemMenu.interpretFootage", b.rect, tl!("Interpret Footage…"));
    if b.clicked() {
        let items = menu_targets(&app.session.state.project_selection, id);
        actions.push(("clip.interpretFootage".into(), json!({"items": items.iter().map(|i| i.0).collect::<Vec<_>>()})));
        ui.close();
    }
    // subclips: Make Subclip (media), Edit Subclip and Convert to Master Clip (subclips)
    let subclip_items: Vec<(&str, &str, &str)> = match kind {
        ItemKind::Media(_) => vec![("makeSubclip", tl!("Make Subclip…"), "clip.makeSubclip")],
        ItemKind::Subclip { .. } => {
            vec![("editSubclip", tl!("Edit Subclip…"), "clip.editSubclip"), ("convertToMaster", tl!("Convert to Master Clip"), "clip.editSubclip")]
        }
        _ => Vec::new(),
    };
    for (key, label, cmd) in &subclip_items {
        let b = ui.button(*label);
        app.auto.add(&format!("project.itemMenu.{key}"), b.rect, label);
        if b.clicked() {
            actions.push(("project.select".into(), sel()));
            let p = if *key == "convertToMaster" { json!({"item": id.0, "convertToMaster": true}) } else { json!({}) };
            actions.push((cmd.to_string(), p));
            ui.close();
        }
    }
    let r = ui.menu_button(tl!("Label"), |ui| {
        // the user's label names and colours, as in Edit ▸ Label (#786)
        let labels = app.session.prefs.labels.clone();
        for l in filmcraft_project::Label::ALL {
            if crate::menus::label_choice(ui, &mut app.auto, &labels, l, "project.itemMenu.label").clicked() {
                actions.push(("project.select".into(), json!({"items": [id.0]})));
                actions.push(("edit.label".into(), json!({"label": l.name()})));
                ui.close();
            }
        }
        super::custom_colors::menu(app, ui, json!({"items":[id.0]}), "project.itemMenu.label");
    });
    app.auto.add("project.itemMenu.label", r.response.rect, tl!("Label"));
    let can_reveal = app.session.project.resolve_media(id).is_some_and(|(_, m, _)| matches!(m.media, filmcraft_project::MediaRef::File { .. }));
    let b = ui.add_enabled(can_reveal, egui::Button::new(tl!("Reveal in Finder")));
    app.auto.add("project.itemMenu.file.reveal", b.rect, "Reveal in Finder");
    if b.clicked() {
        actions.push(("file.reveal".into(), json!({"items": [id.0]})));
        ui.close();
    }
    if matches!(kind, ItemKind::Media(m) if matches!(m.media, filmcraft_project::MediaRef::File { .. })) {
        ui.separator();
        for (label, cmd) in [(tl!("Link Media…"), "media.linkMedia"), (tl!("Make Offline…"), "media.makeOffline")] {
            if ui.button(label).clicked() {
                actions.push(("project.select".into(), sel()));
                actions.push((cmd.into(), json!({})));
                ui.close();
            }
        }
        // Create and Detach act on every selected clip when the one right-clicked is among them, as
        // in Premiere (#1885); Attach and Reconnect pick a file for one clip.
        let many: Vec<u64> = menu_targets(&app.session.state.project_selection, id).iter().map(|i| i.0).collect();
        let r = ui.menu_button(tl!("Proxy"), |ui| {
            for (key, label, cmd, items) in [
                ("create", tl!("Create Proxies…"), "media.createProxies", many.clone()),
                ("attach", tl!("Attach Proxies…"), "media.attachProxies", vec![id.0]),
                ("reconnect", tl!("Reconnect Full Resolution Media…"), "media.reconnectFullRes", vec![id.0]),
                ("detach", tl!("Detach Proxies"), "media.detachProxies", many.clone()),
            ] {
                let b = ui.button(label);
                app.auto.add(&format!("project.itemMenu.proxy.{key}"), b.rect, label);
                if b.clicked() {
                    actions.push(("project.select".into(), json!({"items": items})));
                    actions.push((cmd.into(), json!({})));
                    ui.close();
                }
            }
        });
        app.auto.add("project.itemMenu.proxy", r.response.rect, tl!("Proxy"));
    }
    ui.separator();
    if ui.button(tl!("Clear")).clicked() {
        actions.push(("project.delete".into(), json!({"items": [id.0]})));
        ui.close();
    }
}

fn bin_menu(app: &mut FilmcraftApp, ui: &mut egui::Ui, v: &View, bin: u64, actions: &mut Actions) {
    for (label, how) in [(tl!("Open in Place"), "inPlace"), (tl!("Open in New Tab"), "newTab"), (tl!("Open in New Window"), "newWindow")] {
        let b = ui.button(label);
        app.auto.add(&format!("{}.binMenu.{how}", v.prefix), b.rect, label);
        if b.clicked() {
            let r = open_bin(app, v.inst, bin, Some(&format!("open{}{}", how[..1].to_uppercase(), &how[1..])), egui::Modifiers::NONE);
            if let Err(e) = r {
                app.ui.status = e;
            }
            ui.close();
        }
    }
    ui.separator();
    if ui.button(tl!("Rename")).clicked() {
        actions.push(("projectPanel.rename".into(), json!({"bin": bin})));
        ui.close();
    }
    if ui.button(tl!("New Bin")).clicked() {
        actions.push(("file.newBin".into(), json!({"parent": bin, "panel": v.prefix})));
        ui.close();
    }
    ui.separator();
    if ui.button(tl!("Clear")).clicked() {
        actions.push(("project.delete".into(), json!({"items": [bin]})));
        ui.close();
    }
}

/// Parameters for `project.delete`: the selected items, else the selected bin by id (the engine
/// deletes a named bin with everything in it). `None` when nothing is selected.
pub fn clear_params(selection: &[filmcraft_project::ItemId], selected_bin: Option<u64>) -> Option<serde_json::Value> {
    if !selection.is_empty() {
        return Some(json!({}));
    }
    selected_bin.map(|b| json!({"items": [b]}))
}

/// Drop project items dragged onto a bin: move them (the selection when the dragged item is in it).
/// A dragged bin nests in it, unless that would put the bin inside itself.
fn accept_bin_drop(app: &FilmcraftApp, ui: &egui::Ui, r: Rect, bin: u64, actions: &mut Actions) -> bool {
    let items: Vec<u64> = if let Some(item) = crate::panels::dragged_project_item(ui) {
        let sel = &app.session.state.project_selection;
        if sel.contains(&item) { sel.iter().map(|i| i.0).collect() } else { vec![item.0] }
    } else if let Some(dragged) = crate::panels::dragged_bin(ui) {
        let root = &app.session.project.root;
        if root.find_bin(BinId(dragged)).is_none_or(|d| d.find_bin(BinId(bin)).is_some()) {
            return false;
        }
        vec![dragged]
    } else {
        return false;
    };
    if !ui.rect_contains_pointer(r) {
        return false;
    }
    ui.painter().rect_stroke(r, 3.0, Stroke::new(1.5, app.tokens.accent), StrokeKind::Inside);
    if ui.input(|i| i.pointer.any_released()) {
        actions.push(("project.moveToBin".into(), json!({"items": items, "bin": bin})));
        crate::panels::clear_drag(ui);
    }
    true
}

/// A bin dropped on empty space moves into the bin the view shows (out of the bin it was nested in).
fn accept_view_drop(app: &FilmcraftApp, ui: &egui::Ui, r: Rect, v: &View, actions: &mut Actions) {
    let Some(dragged) = crate::panels::dragged_bin(ui) else { return };
    let root = &app.session.project.root;
    // already shown here, or the view is inside the dragged bin
    let here = root.find_bin(v.bin).is_some_and(|b| b.children.iter().any(|c| matches!(c, BinEntry::Bin(x) if x.id.0 == dragged)));
    let inside = root.find_bin(BinId(dragged)).is_none_or(|d| d.find_bin(v.bin).is_some());
    if here || inside || !ui.rect_contains_pointer(r) || !ui.input(|i| i.pointer.any_released()) {
        return;
    }
    let bin = (v.bin != root.id).then_some(v.bin.0);
    actions.push(("project.moveToBin".into(), json!({"items": [dragged], "bin": bin})));
    crate::panels::clear_drag(ui);
}

/// The inline rename field at `r`; true while it is shown.
fn rename_field(app: &mut FilmcraftApp, ui: &mut egui::Ui, r: Rect, item: Option<u64>, bin: Option<u64>, pre: &str) -> bool {
    let Some(rn) = app.ui.project_panel.rename.clone() else { return false };
    if rn.item != item || rn.bin != bin || item.is_none() && bin.is_none() || (!rn.panel.is_empty() && rn.panel != pre) {
        return false;
    }
    let mut text = rn.text;
    let id = egui::Id::unique(("rename-field", pre, item, bin));
    let resp = crate::widgets::accessible_name(
        ui.put(r, egui::TextEdit::singleline(&mut text).id(id).font(egui::FontId::proportional(font(app))).margin(vec2(3.0, 1.0))),
        "Rename",
    );
    app.auto.add(&format!("{pre}.rename"), r, "Rename");
    // take keyboard focus the first frame the field is shown, then select its current name
    let shown = egui::Id::unique("project-rename-shown");
    if ui.ctx().data(|d| d.get_temp::<egui::Id>(shown)) != Some(id) {
        ui.ctx().data_mut(|d| d.insert_temp(shown, id));
        ui.ctx().data_mut(|d| d.insert_temp(id.with("select-all"), true));
        resp.request_focus();
    }
    let select_all = resp.has_focus() && ui.ctx().data_mut(|d| d.remove_temp::<bool>(id.with("select-all")).is_some());
    if select_all {
        let mut state = egui::text_edit::TextEditState::load(ui.ctx(), id).unwrap_or_default();
        state.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(text.chars().count()))));
        state.store(ui.ctx(), id);
        ui.ctx().request_repaint();
    }
    if let Some(rn) = app.ui.project_panel.rename.as_mut() {
        rn.text = text;
    }
    let done = if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
        app.ui.project_panel.rename = None;
        true
    } else if resp.lost_focus() {
        commit_rename(app);
        true
    } else {
        false
    };
    if done {
        ui.ctx().data_mut(|d| d.remove::<egui::Id>(shown));
    }
    true
}

/// A second click on the name of the only selected item starts renaming it (after the
/// double-click interval, so a double-click still opens it).
fn slow_click_rename(app: &mut FilmcraftApp, ui: &egui::Ui, resp: &egui::Response, name_rect: Rect, id: ItemId, was_selected: bool) {
    let key = egui::Id::unique("project-rename-pending");
    let now = ui.input(|i| i.time);
    if resp.double_clicked() {
        ui.ctx().data_mut(|d| d.remove::<(u64, f64)>(key));
        return;
    }
    if resp.clicked()
        && was_selected
        && app.session.state.project_selection.len() == 1
        && ui.input(|i| i.modifiers.is_none())
        && resp.interact_pointer_pos().is_some_and(|p| name_rect.contains(p))
    {
        ui.ctx().data_mut(|d| d.insert_temp(key, (id.0, now + 0.5)));
    }
    if let Some((pid, at)) = ui.ctx().data(|d| d.get_temp::<(u64, f64)>(key))
        && pid == id.0
    {
        if now >= at {
            ui.ctx().data_mut(|d| d.remove::<(u64, f64)>(key));
            if app.session.state.project_selection == [id] {
                let name = app.session.project.item(id).map(|i| i.name.clone()).unwrap_or_default();
                app.ui.project_panel.rename = Some(crate::panels::project::Rename { item: Some(id.0), bin: None, text: name, panel: String::new() });
            }
        } else {
            ui.ctx().request_repaint();
        }
    }
}

// ------------------------------------------------------------------------------------ list view

struct ListCtx {
    cols: Vec<pp::Column>,
    row_h: f32,
    font: f32,
    thumbs: bool,
    width: f32,
}

pub fn list_view(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect, v: &View, filter: &str, actions: &mut Actions) {
    let t = app.tokens;
    let f = font(app);
    let thumbs = app.session.prefs.project_panel.thumbnails;
    let mut cols = app.session.prefs.project_panel.view.columns.clone();
    if let Some((name, w)) = &app.ui.project_panel.column_drag
        && let Some(c) = cols.iter_mut().find(|c| c.name == *name)
    {
        c.width = *w;
    }
    let row_h = if thumbs { list_thumb_row_height(v.icon_size, f) } else { (f * 2.0).max(22.0) };
    // a zoomed thumbnail keeps room for the name beside it: the Name column is drawn wide enough
    // (its saved width is unchanged)
    if thumbs && let Some(name) = cols.first_mut() {
        name.width = name.width.max(list_name_width(row_h));
    }
    let width = LEAD + cols.iter().map(|c| c.width).sum::<f32>() + 8.0;
    let lc = ListCtx { row_h, font: f, thumbs, width: width.max(rect.width()), cols };
    let header_h = (f * 1.8).max(20.0);
    let body = Rect::from_min_max(pos2(rect.min.x, rect.min.y + header_h), rect.max);
    let mut bui = ui.new_child(egui::UiBuilder::new().max_rect(body).id_salt((&v.prefix, "list-body")));
    bui.set_clip_rect(body.intersect(ui.clip_rect()));
    let root = app.session.project.root.find_bin(v.bin).cloned().unwrap_or_default();
    let out = egui::ScrollArea::both().id_salt((&v.prefix, "list-scroll")).auto_shrink([false, false]).show(&mut bui, |ui| {
        ui.set_min_width(lc.width);
        let bg = background(ui, v);
        let mut row = 0usize;
        list_bin(app, ui, &root, 0, filter, &mut row, actions, v, &lc);
        if v.inst == Inst::Main && v.bin == app.session.project.root.id {
            let mut draw = |app: &mut FilmcraftApp, ui: &mut egui::Ui, bin: &Bin, row: &mut usize, actions: &mut Actions| {
                list_bin(app, ui, bin, 1, "", row, actions, v, &lc);
            };
            crate::panels::menu_dialogs::search_bin_rows(app, ui, &mut row, actions, &mut draw);
        }
        empty_space(app, ui, v, &bg, actions);
    });
    // pinned header, scrolled horizontally with the rows
    let hr = Rect::from_min_size(rect.min, vec2(rect.width(), header_h));
    let hp = ui.painter().with_clip_rect(hr.intersect(ui.clip_rect()));
    hp.rect_filled(hr, 0.0, t.panel_bg);
    hp.line_segment([hr.left_bottom(), hr.right_bottom()], Stroke::new(1.0, t.separator));
    let mut x = rect.min.x + LEAD - out.state.clamped_offset().x;
    let sort = app.session.prefs.project_panel.view.sort.clone();
    for c in &lc.cols {
        let cr = Rect::from_min_size(pos2(x, hr.min.y), vec2(c.width, header_h));
        let vis = cr.intersect(hr);
        if vis.width() > 1.0 {
            let id = egui::Id::unique((&v.prefix, "col", &c.name));
            let resp = ui.interact(vis, id, Sense::click()).on_hover_text(crate::i18n::t(&c.name));
            app.auto.add(&format!("{}.list.header.{}", v.prefix, c.name), vis, &c.name);
            if resp.hovered() {
                hp.rect_filled(cr, 0.0, t.hover);
            }
            let g = hp.layout_no_wrap(crate::i18n::t(&c.name).to_string(), Tokens::ui(f - 0.5), t.text_dim);
            // The sort arrow sits in the right of the header. Leave it a gap so it does not cover the name (#1295).
            let arrow = if sort.column == c.name { 14.0 } else { 0.0 };
            let label = cr.shrink2(vec2(4.0, 0.0));
            let label = egui::Rect::from_min_max(label.min, pos2((label.max.x - arrow).max(label.min.x), label.max.y)).intersect(hr);
            hp.with_clip_rect(label).galley(pos2(cr.min.x + 6.0, cr.center().y - g.size().y / 2.0), g, t.text_dim);
            if sort.column == c.name {
                let ax = cr.max.x - 8.0;
                let (a, b) = if sort.descending { (cr.center().y + 4.0, cr.center().y - 4.0) } else { (cr.center().y - 4.0, cr.center().y + 4.0) };
                hp.line_segment([pos2(ax, b), pos2(ax, a)], Stroke::new(1.3, t.text_dim));
                hp.line_segment([pos2(ax - 3.0, a + (b - a).signum() * 3.0), pos2(ax, a)], Stroke::new(1.3, t.text_dim));
                hp.line_segment([pos2(ax + 3.0, a + (b - a).signum() * 3.0), pos2(ax, a)], Stroke::new(1.3, t.text_dim));
            }
            if resp.clicked() {
                actions.push(("project.sort".into(), json!({"column": c.name})));
            }
            resp.context_menu(|ui| {
                if ui.button(tl!("Metadata Display…")).clicked() {
                    actions.push(("projectPanel.metadataDisplay".into(), json!({})));
                    ui.close();
                }
            });
        }
        // resize handle on the column's right edge
        let hr2 = Rect::from_center_size(pos2(cr.max.x, hr.center().y), vec2(8.0, header_h));
        let visible = hr2.intersects(hr);
        // a handle dragged past the header's end stays registered, or its release would be missed
        let dragging = app.ui.project_panel.column_drag.as_ref().is_some_and(|(d, _)| *d == c.name);
        if visible || dragging {
            let id = egui::Id::unique((&v.prefix, "colsize", &c.name));
            let resp = ui.interact(if visible { hr2.intersect(hr) } else { hr2 }, id, Sense::drag()).on_hover_cursor(egui::CursorIcon::ResizeColumn);
            if visible {
                app.auto.add(&format!("{}.list.resize.{}", v.prefix, c.name), hr2.intersect(hr), "Resize column");
                hp.line_segment([pos2(cr.max.x, hr.min.y + 4.0), pos2(cr.max.x, hr.max.y - 4.0)], Stroke::new(1.0, t.separator));
            }
            // the width lives in UI state while dragging: had the drag changed the preferences
            // already, the command would see nothing new and not write preferences.json
            if resp.dragged_by(egui::PointerButton::Primary) {
                app.ui.project_panel.column_drag = Some((c.name.clone(), (c.width + resp.drag_delta().x).clamp(30.0, 800.0)));
            }
            if resp.drag_stopped_by(egui::PointerButton::Primary) {
                let w = app.ui.project_panel.column_drag.take().filter(|(d, _)| *d == c.name).map_or(c.width, |(_, w)| w);
                actions.push(("project.columns.resize".into(), json!({"column": c.name, "width": w})));
            }
        }
        x += c.width;
    }
}

/// The List / Icon view background, under the rows and cards (call it before drawing them, so they
/// sit on top). Starts the frame's [`note_hit`] list.
fn background(ui: &egui::Ui, v: &View) -> egui::Response {
    ui.data_mut(|d| d.remove::<Vec<(u64, Rect)>>(hits_id(v)));
    ui.interact(ui.clip_rect(), egui::Id::unique((&v.prefix, "background")), Sense::click_and_drag())
}

/// Empty space under the rows / cards, and the gaps between them (`bg`): click deselects,
/// double-click imports, right-click menu, drag selects with a marquee.
fn empty_space(app: &mut FilmcraftApp, ui: &mut egui::Ui, v: &View, bg: &egui::Response, actions: &mut Actions) {
    let rest = ui.available_rect_before_wrap();
    let r = Rect::from_min_size(rest.min, vec2(rest.width(), rest.height().max(40.0)));
    ui.allocate_rect(r, Sense::hover());
    app.auto.add(&format!("{}.empty", v.prefix), r.intersect(ui.clip_rect()), "Empty area");
    marquee(app, ui, v, bg, ui.max_rect().min, actions);
    accept_view_drop(app, ui, r, v, actions);
    if bg.clicked() {
        app.ui.project_panel.selected_bin = None;
        actions.push(("project.select".into(), json!({"items": []})));
    }
    if bg.double_clicked() {
        actions.push(("file.import".into(), json!({})));
    }
    let bin = (v.bin != app.session.project.root.id).then_some(v.bin.0);
    bg.context_menu(|ui| background_menu(app, ui, v, bin, actions));
}

/// Reveal in Project: scroll the revealed item's Name cell (List) or card (`r`, drawn this frame
/// inside the view's scroll area) into view, once. Only as far as needed: a row already on show
/// stays put.
fn scroll_to_revealed(app: &mut FilmcraftApp, ui: &egui::Ui, v: &View, id: ItemId, r: Rect) {
    if v.inst == Inst::Main && app.ui.project_panel.reveal == Some(id.0) {
        app.ui.project_panel.reveal = None;
        ui.scroll_to_rect(r, None);
    }
}

fn hits_id(v: &View) -> egui::Id {
    egui::Id::unique((&v.prefix, "marquee-hits"))
}

/// Remember where an item's row or card was drawn this frame, for [`marquee`].
fn note_hit(ui: &egui::Ui, v: &View, id: ItemId, r: Rect) {
    ui.data_mut(|d| d.get_temp_mut_or_default::<Vec<(u64, Rect)>>(hits_id(v)).push((id.0, r)));
}

/// Marquee selection: dragging `bg` (empty space) selects every item drawn this frame whose rect
/// the rectangle touches, live. Shift/Ctrl add to the selection the drag started with; Escape
/// cancels and restores it. `origin` is the content's top-left, so scrolling keeps the anchor.
fn marquee(app: &mut FilmcraftApp, ui: &egui::Ui, v: &View, bg: &egui::Response, origin: egui::Pos2, actions: &mut Actions) {
    // (press point relative to `origin`, selection when the drag began, adds to it)
    type Drag = (egui::Vec2, Vec<u64>, bool);
    let key = egui::Id::unique((&v.prefix, "marquee"));
    let hits: Vec<(u64, Rect)> = ui.data_mut(|d| d.remove_temp(hits_id(v))).unwrap_or_default();
    let current: Vec<u64> = app.session.state.project_selection.iter().map(|i| i.0).collect();
    // the left button only: right-click opens the menu, the middle button is not a selection
    let primary = egui::PointerButton::Primary;
    if bg.drag_started_by(primary) {
        let press = ui.input(|i| i.pointer.press_origin()).unwrap_or(origin);
        let m = ui.input(|i| i.modifiers);
        let add = m.shift || m.command;
        if !add {
            app.ui.project_panel.selected_bin = None;
        }
        ui.data_mut(|d| d.insert_temp::<Drag>(key, (press - origin, current.clone(), add)));
    }
    let Some((anchor, before, add)) = ui.data(|d| d.get_temp::<Drag>(key)) else { return };
    let cancel = ui.input(|i| i.key_pressed(egui::Key::Escape));
    if cancel || !(bg.dragged_by(primary) || bg.drag_stopped_by(primary)) {
        ui.data_mut(|d| d.remove::<Drag>(key));
        if cancel && before != current {
            actions.push(("project.select".into(), json!({"items": before})));
        }
        return;
    }
    let Some(now) = ui.ctx().pointer_latest_pos() else { return };
    let r = Rect::from_two_pos(origin + anchor, now);
    let mut sel = if add { before } else { Vec::new() };
    for (id, hr) in &hits {
        if hr.intersects(r) && !sel.contains(id) {
            sel.push(*id);
        }
    }
    if sel != current {
        actions.push(("project.select".into(), json!({"items": sel})));
    }
    let t = app.tokens;
    ui.painter().rect_filled(r, 0.0, t.accent.gamma_multiply(0.18));
    ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Inside);
    app.auto.add(&format!("{}.marquee", v.prefix), r, "Marquee");
    if bg.drag_stopped_by(primary) {
        ui.data_mut(|d| d.remove::<Drag>(key));
    }
}

fn background_menu(app: &mut FilmcraftApp, ui: &mut egui::Ui, v: &View, bin: Option<u64>, actions: &mut Actions) {
    for (label, cmd) in [
        (tl!("New Bin"), "file.newBin"),
        (tl!("New Search Bin"), "file.newSearchBin"),
        (tl!("Find…"), "edit.find"),
        (tl!("Automate to Sequence…"), "clip.automateToSequence"),
        (tl!("Import…"), "file.import"),
    ] {
        if ui.button(label).clicked() {
            let p = if cmd == "file.newBin" { json!({"parent": bin, "panel": v.prefix}) } else { json!({}) };
            actions.push((cmd.into(), p));
            ui.close();
        }
    }
    let new_bin = (v.bin != app.session.project.root.id).then_some(v.bin.0);
    ui.menu_button(tl!("New Item"), |ui| crate::panels::project::new_item_menu(app, ui, &v.prefix, new_bin, actions));
}

#[allow(clippy::too_many_arguments)]
fn list_bin(app: &mut FilmcraftApp, ui: &mut egui::Ui, bin: &Bin, depth: usize, filter: &str, row: &mut usize, actions: &mut Actions, v: &View, lc: &ListCtx) {
    let t = app.tokens;
    let (bins, items) = pp::bin_children(&app.session.project, bin, &app.session.prefs.project_panel.view.sort);
    for bid in bins {
        let Some(b) = app.session.project.root.find_bin(bid).cloned() else { continue };
        let open = app.ui.expanded_bins.contains(&b.id.0) || !filter.is_empty();
        let (r, resp) = ui.allocate_exact_size(vec2(lc.width, lc.row_h), Sense::click_and_drag());
        let selected = app.ui.project_panel.selected_bin == Some(b.id.0);
        if selected {
            ui.painter().rect_filled(r, 0.0, t.row_selected);
        } else if *row % 2 == 1 {
            ui.painter().rect_filled(r, 0.0, t.row_alt);
        }
        *row += 1;
        let x = r.min.x + LEAD + depth as f32 * 14.0;
        let tri = Rect::from_center_size(pos2(x + 5.0, r.center().y), vec2(14.0, 14.0));
        icons::paint(ui.painter(), tri.shrink(2.0), if open { Icon::ChevronDown } else { Icon::ChevronRight }, t.text_dim);
        icons::paint(ui.painter(), Rect::from_center_size(pos2(x + 20.0, r.center().y), vec2(14.0, 14.0)), Icon::Folder, BIN_COLOR);
        let name_r = Rect::from_min_max(pos2(x + 30.0, r.min.y + 2.0), pos2((r.min.x + LEAD + lc.cols[0].width - 4.0).max(x + 80.0), r.max.y - 2.0));
        if !rename_field(app, ui, name_r, None, Some(b.id.0), &v.prefix) {
            ui.painter().with_clip_rect(name_r).text(pos2(name_r.min.x + 2.0, r.center().y), Align2::LEFT_CENTER, &b.name, Tokens::ui(lc.font), t.text);
        }
        app.auto.add(&format!("{}.bin.{}", v.prefix, b.id.0), r.intersect(ui.clip_rect()), &b.name);
        app.auto.add(&format!("{}.bin.{}.toggle", v.prefix, b.id.0), tri, "Expand");
        accept_bin_drop(app, ui, r, b.id.0, actions);
        if resp.drag_started_by(egui::PointerButton::Primary) {
            crate::panels::start_drag_bin(ui, b.id.0);
        }
        if resp.clicked() {
            let on_tri = resp.interact_pointer_pos().is_some_and(|p| p.x < x + 12.0);
            if on_tri || app.ui.project_panel.selected_bin == Some(b.id.0) && !resp.double_clicked() {
                if open {
                    app.ui.expanded_bins.retain(|x| *x != b.id.0);
                } else {
                    app.ui.expanded_bins.push(b.id.0);
                }
            }
            app.ui.project_panel.selected_bin = Some(b.id.0);
            actions.push(("project.select".into(), json!({"items": []})));
        }
        if resp.double_clicked() {
            let mods = click_modifiers(ui);
            if let Err(e) = open_bin(app, v.inst, b.id.0, None, mods) {
                app.ui.status = e;
            }
        }
        resp.context_menu(|ui| bin_menu(app, ui, v, b.id.0, actions));
        if open {
            list_bin(app, ui, &b, depth + 1, filter, row, actions, v, lc);
        }
    }
    for id in items {
        if !matches_filter(app, id, filter) {
            continue;
        }
        let Some(it) = app.session.project.item(id).cloned() else { continue };
        let (r, resp) = ui.allocate_exact_size(vec2(lc.width, lc.row_h), Sense::click_and_drag());
        note_hit(ui, v, id, r);
        let name_w = lc.cols.first().map(|c| c.width).unwrap_or(200.0);
        // The Name cell, not the whole row: a row as wide as the view would leave the list scrolled
        // sideways past the name.
        scroll_to_revealed(app, ui, v, id, Rect::from_min_max(r.min, pos2(r.min.x + LEAD + name_w, r.max.y)));
        let selected = app.session.state.project_selection.contains(&id);
        if selected {
            ui.painter().rect_filled(r, 0.0, t.row_selected);
            ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Inside);
        } else if *row % 2 == 1 {
            ui.painter().rect_filled(r, 0.0, t.row_alt);
        }
        *row += 1;
        // label chip
        let chip = Rect::from_center_size(pos2(r.min.x + 13.0, r.center().y), vec2(12.0, 12.0));
        ui.painter().rect_filled(chip, 2.5, label_color(app, it.label, it.custom_label_color));
        app.auto.add(&format!("{}.item.{}.label", v.prefix, id.0), chip, &it.label_value());
        let mut x = r.min.x + LEAD;
        let nx = x + depth as f32 * 14.0 + 14.0;
        let mut icon_x = nx;
        if lc.thumbs {
            let th = Rect::from_min_size(pos2(nx, r.min.y + 3.0), vec2((lc.row_h - 6.0) * 16.0 / 9.0, lc.row_h - 6.0));
            thumb(app, ui, th, &it, None);
            icon_x = th.max.x + 4.0;
        }
        icons::paint(ui.painter(), Rect::from_center_size(pos2(icon_x + 7.0, r.center().y), vec2(14.0, 14.0)), item_icon(&it.kind), t.icon);
        let name_r = Rect::from_min_max(pos2(icon_x + 18.0, r.min.y + 2.0), pos2(x + name_w - 4.0, r.max.y - 2.0));
        let badge = media_badge(app, &it);
        if !rename_field(app, ui, name_r, Some(id.0), None, &v.prefix) {
            let (text_r, badges) = name_room(&badge, name_r);
            // a name cut short ends in "…" and shows in full on hover, as on the cards
            let color = if badge.offline { OFFLINE } else { t.text };
            let g = elided_name(ui, &it.name, Tokens::ui(lc.font), color, text_r.max.x - name_r.min.x - 2.0);
            let elided = g.elided;
            let at = pos2(name_r.min.x + 2.0, r.center().y - g.size().y / 2.0);
            let end = at.x + g.size().x;
            ui.painter().with_clip_rect(text_r).galley(at, g, color);
            if elided && ui.rect_contains_pointer(text_r) {
                resp.clone().on_hover_text(&it.name);
            }
            if badges {
                paint_badges(app, ui, &badge, pos2(end.min(text_r.max.x) + 6.0, r.center().y), &v.prefix, id);
            }
        }
        x += name_w;
        for c in lc.cols.iter().skip(1) {
            let cr = Rect::from_min_size(pos2(x, r.min.y), vec2(c.width, r.height()));
            let p = ui.painter().with_clip_rect(cr.shrink2(vec2(2.0, 0.0)).intersect(ui.clip_rect()));
            if c.name == "Label" {
                p.rect_filled(
                    Rect::from_center_size(pos2(cr.min.x + 12.0, cr.center().y), vec2(10.0, 10.0)),
                    2.0,
                    label_color(app, it.label, it.custom_label_color),
                );
                p.text(pos2(cr.min.x + 22.0, cr.center().y), Align2::LEFT_CENTER, crate::i18n::t(&it.label_value()), Tokens::ui(lc.font - 0.5), t.text_dim);
            } else {
                let (text, _) = pp::cell(&app.session.project, &it, &c.name);
                let text = if c.name == "Media Type" { crate::i18n::t(&text).to_string() } else { text };
                p.text(pos2(cr.min.x + 6.0, cr.center().y), Align2::LEFT_CENTER, text, Tokens::ui(lc.font - 0.5), t.text_dim);
            }
            x += c.width;
        }
        app.auto.add(&format!("{}.item.{}", v.prefix, id.0), r.intersect(ui.clip_rect()), &it.name);
        if selected {
            app.auto.add(&format!("{}.item.{}.selected", v.prefix, id.0), r.intersect(ui.clip_rect()), "Selected");
        }
        slow_click_rename(app, ui, &resp, name_r, id, selected);
        item_interactions(app, ui, actions, ItemInteraction { view: v, response: &resp, item: id, kind: &it.kind, allow_drag: true, allow_menu: true });
    }
}

/// An item's thumbnail at `t` (None: the poster frame or a third in) fitted into `r`.
fn thumb(app: &mut FilmcraftApp, ui: &egui::Ui, r: Rect, it: &filmcraft_project::ProjectItem, at: Option<Tick>) {
    ui.painter().rect_filled(r, 2.0, Color32::from_rgb(12, 12, 12));
    let tt = at.or_else(|| filmcraft_engine::keyboard::poster_frame(it)).unwrap_or(Tick(it.duration().0 * 3 / 10));
    let ctx = ui.ctx().clone();
    let w = (r.width() as u32).clamp(96, 320);
    if let Some((tex, sz)) = app.thumbnail(&ctx, it.id, quantize(tt), w) {
        ui.painter().image(tex, crate::panels::monitor::fit(r, sz.x, sz.y), Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
    } else {
        icons::paint(
            ui.painter(),
            Rect::from_center_size(r.center(), vec2(r.height().min(28.0) * 0.8, r.height().min(28.0) * 0.8)),
            item_icon(&it.kind),
            app.tokens.text_faint,
        );
    }
}

// ------------------------------------------------------------------------------------ icon view

/// Hover scrub over a thumbnail: the media time under the pointer (recorded for I / O).
fn hover_time(app: &mut FilmcraftApp, ui: &egui::Ui, resp: &egui::Response, r: Rect, it: &filmcraft_project::ProjectItem) -> Option<Tick> {
    if !(resp.hovered() && app.session.prefs.project_panel.hover_scrub) || it.duration().0 <= 0 {
        return None;
    }
    let p = ui.ctx().pointer_hover_pos()?;
    let f = ((p.x - r.min.x) / r.width()).clamp(0.0, 1.0) as f64;
    let rate = it.frame_rate();
    let t = rate.snap(Tick((it.duration().0 as f64 * f) as i64)).min(Tick((it.duration().0 - rate.frame_duration().0).max(0)));
    app.ui.project_panel.hover = Some(Hover { item: it.id.0, time: t.0, frame: ui.ctx().cumulative_frame_nr() });
    Some(t)
}

/// A clip card: thumbnail (hover scrub, poster frame), In/Out bar, badges, name and duration.
#[allow(clippy::too_many_arguments)]
fn card(app: &mut FilmcraftApp, ui: &mut egui::Ui, r: Rect, id: ItemId, pre: &str, show_name: bool, show_dur: bool, sense: Sense) -> Option<egui::Response> {
    let t = app.tokens;
    let it = app.session.project.item(id).cloned()?;
    let mut resp = ui.interact(r.expand(2.0), egui::Id::unique((pre, "card", id.0)), sense);
    let th = Rect::from_min_size(r.min, vec2(r.width(), r.width() * 9.0 / 16.0));
    let selected = app.session.state.project_selection.contains(&id);
    let card_bg = Rect::from_min_max(th.min - vec2(6.0, 6.0), pos2(th.max.x + 6.0, r.max.y + 2.0));
    ui.painter().rect_filled(card_bg, 4.0, if selected { t.row_selected } else { t.panel_bg });
    if selected {
        ui.painter().rect_stroke(card_bg, 4.0, Stroke::new(1.5, t.accent), StrokeKind::Inside);
        app.auto.add(&format!("{pre}.item.{}.selected", id.0), card_bg.intersect(ui.clip_rect()), "Selected");
    }
    let at = hover_time(app, ui, &resp, th, &it);
    thumb(app, ui, th, &it, at);
    let dur = it.duration();
    // In/Out range bar along the bottom of the thumbnail
    let marks = match &it.kind {
        ItemKind::Media(m) => (m.mark_in, m.mark_out),
        ItemKind::Sequence(q) => (q.mark_in, q.mark_out),
        _ => (None, None),
    };
    if (marks.0.is_some() || marks.1.is_some()) && dur.0 > 0 {
        let fx = |t: Tick| th.min.x + th.width() * (t.0 as f32 / dur.0 as f32).clamp(0.0, 1.0);
        let a = fx(marks.0.unwrap_or(Tick::ZERO));
        let b = fx(marks.1.map(|o| o + it.frame_rate().frame_duration()).unwrap_or(dur));
        let bar = Rect::from_min_max(pos2(a, th.max.y - 4.0), pos2(b.max(a + 2.0), th.max.y));
        ui.painter().rect_filled(bar, 0.0, Color32::from_rgb(0x5a, 0x9b, 0xf0));
        app.auto.add(&format!("{pre}.item.{}.inOut", id.0), bar, "In/Out");
    }
    // hover scrub playhead
    if let Some(ht) = at
        && dur.0 > 0
    {
        let x = th.min.x + th.width() * (ht.0 as f32 / dur.0 as f32);
        ui.painter().line_segment([pos2(x, th.min.y), pos2(x, th.max.y)], Stroke::new(1.0, Color32::from_rgb(0x5a, 0x9b, 0xf0)));
    }
    // video / audio badges
    let mut bx = th.max.x - 4.0;
    for (has, icon) in [
        (it.has_audio(), Icon::Audio),
        (it.has_video() && !matches!(it.kind, ItemKind::Sequence(_)), Icon::Film),
        (matches!(it.kind, ItemKind::Sequence(_)), Icon::Sequence),
    ] {
        if has {
            let br = Rect::from_min_max(pos2(bx - 15.0, th.max.y - 17.0), pos2(bx, th.max.y - 5.0));
            ui.painter().rect_filled(br, 2.0, Color32::from_black_alpha(160));
            icons::paint(ui.painter(), br.shrink(1.5), icon, Color32::from_rgb(0x8f, 0xb8, 0xf5));
            bx -= 17.0;
        }
    }
    let badge = media_badge(app, &it);
    if badge.offline {
        let band = Rect::from_min_max(pos2(th.min.x, th.max.y - 20.0), th.max);
        ui.painter().rect_filled(band, 0.0, Color32::from_rgba_unmultiplied(0x5c, 0x10, 0x16, 230));
        icons::paint(ui.painter(), Rect::from_center_size(pos2(band.min.x + 12.0, band.center().y), vec2(13.0, 13.0)), Icon::Offline, Color32::WHITE);
        ui.painter().text(pos2(band.min.x + 24.0, band.center().y), Align2::LEFT_CENTER, badge.offline_text, Tokens::ui(10.5), Color32::WHITE);
        offline_badge(app, ui, band, pre, id, &badge);
    }
    if badge.proxy {
        let pr = Rect::from_min_size(pos2(th.max.x - 22.0, th.min.y + 4.0), vec2(18.0, 14.0));
        ui.painter().rect_filled(pr, 2.0, if badge.proxy_on { t.accent } else { Color32::from_gray(70) });
        ui.painter().text(pr.center(), Align2::CENTER_CENTER, "P", Tokens::ui(10.0), Color32::WHITE);
        app.auto.add(&format!("{pre}.item.{}.proxy", id.0), pr, "Proxy attached");
    }
    let f = font(app);
    let ty = th.max.y + 11.0;
    let mut dw = 0.0;
    if show_dur {
        let secs = dur.seconds().max(0.0) as u64;
        let dtext = if secs >= 3600 { format!("{}:{:02}:{:02}", secs / 3600, (secs / 60) % 60, secs % 60) } else { format!("{}:{:02}", secs / 60, secs % 60) };
        let dg = ui.painter().layout_no_wrap(dtext, Tokens::ui(f - 1.0), t.text_dim);
        dw = dg.size().x;
        ui.painter().galley(pos2(th.max.x - dw, ty - dg.size().y / 2.0), dg, t.text_dim);
    }
    let nr = Rect::from_min_max(pos2(th.min.x, th.max.y + 2.0), pos2(th.max.x - dw - 6.0, th.max.y + 20.0));
    if show_name && !rename_field(app, ui, nr, Some(id.0), None, pre) {
        ui.painter().rect_filled(Rect::from_min_size(pos2(th.min.x, ty - 5.0), vec2(8.0, 10.0)), 1.5, label_color(app, it.label, it.custom_label_color));
        let g = elided_name(ui, &it.name, Tokens::ui(f - 0.5), if badge.offline { OFFLINE } else { t.text }, nr.max.x - th.min.x - 12.0);
        let elided = g.elided;
        ui.painter().galley(pos2(th.min.x + 12.0, ty - g.size().y / 2.0), g, t.text);
        if elided {
            resp = resp.on_hover_text(&it.name);
        }
    }
    app.auto.add(&format!("{pre}.item.{}", id.0), th, &it.name);
    Some(resp)
}

/// A one-line item name cut to `max_width` with a trailing "…"; `elided` says whether it was cut,
/// so the caller can show the full name on hover.
fn elided_name(ui: &egui::Ui, name: &str, font: egui::FontId, color: Color32, max_width: f32) -> std::sync::Arc<egui::Galley> {
    let mut job = egui::text::LayoutJob::single_section(name.to_owned(), egui::TextFormat::simple(font, color));
    job.wrap.max_width = max_width.max(0.0);
    job.wrap.max_rows = 1;
    job.wrap.break_anywhere = true;
    job.wrap.overflow_character = Some('…');
    ui.fonts_mut(|f| f.layout_job(job))
}

fn bin_card(app: &mut FilmcraftApp, ui: &mut egui::Ui, r: Rect, b: &Bin, v: &View, actions: &mut Actions) {
    let t = app.tokens;
    let th = Rect::from_min_size(r.min, vec2(r.width(), r.width() * 9.0 / 16.0));
    let mut resp = ui.interact(r.expand(2.0), egui::Id::unique((&v.prefix, "bincard", b.id.0)), Sense::click_and_drag());
    let selected = app.ui.project_panel.selected_bin == Some(b.id.0);
    let bg = Rect::from_min_max(th.min - vec2(6.0, 6.0), pos2(th.max.x + 6.0, r.max.y + 2.0));
    ui.painter().rect_filled(bg, 4.0, if selected { t.row_selected } else { t.panel_bg });
    if selected {
        ui.painter().rect_stroke(bg, 4.0, Stroke::new(1.5, t.accent), StrokeKind::Inside);
    }
    ui.painter().rect_filled(th, 2.0, Color32::from_gray(26));
    icons::paint(ui.painter(), Rect::from_center_size(th.center(), vec2(th.height() * 0.6, th.height() * 0.6)), Icon::Folder, BIN_COLOR);
    let mut n = Vec::new();
    b.all_items(&mut n);
    let f = font(app);
    let nr = Rect::from_min_max(pos2(th.min.x, th.max.y + 2.0), pos2(th.max.x, th.max.y + 20.0));
    if !rename_field(app, ui, nr, None, Some(b.id.0), &v.prefix) {
        let cg = ui.painter().layout_no_wrap(tlf!("{n} items", n = n.len()), Tokens::ui(f - 1.5), t.text_dim);
        let cw = cg.size().x;
        ui.painter().galley(pos2(th.max.x - cw, th.max.y + 11.0 - cg.size().y / 2.0), cg, t.text_dim);
        // The name gets only what is left beside the count. At the smallest icon sizes that can be
        // narrower than one letter and "…", which the layout still emits, so the name is also
        // clipped to its slot and never runs into the count (#2632).
        let slot = Rect::from_min_max(nr.min, pos2((nr.max.x - cw - 6.0).max(nr.min.x), nr.max.y));
        let g = elided_name(ui, &b.name, Tokens::ui(f - 0.5), t.text, slot.width());
        let elided = g.elided || g.size().x > slot.width();
        ui.painter().with_clip_rect(slot).galley(pos2(th.min.x, th.max.y + 11.0 - g.size().y / 2.0), g, t.text);
        if elided {
            resp = resp.on_hover_text(&b.name);
        }
    }
    app.auto.add(&format!("{}.bin.{}", v.prefix, b.id.0), th, &b.name);
    accept_bin_drop(app, ui, th, b.id.0, actions);
    if resp.drag_started_by(egui::PointerButton::Primary) {
        crate::panels::start_drag_bin(ui, b.id.0);
    }
    if resp.clicked() {
        app.ui.project_panel.selected_bin = Some(b.id.0);
        actions.push(("project.select".into(), json!({"items": []})));
    }
    if resp.double_clicked() {
        let mods = click_modifiers(ui);
        if let Err(e) = open_bin(app, v.inst, b.id.0, None, mods) {
            app.ui.status = e;
        }
    }
    resp.context_menu(|ui| bin_menu(app, ui, v, b.id.0, actions));
}

pub fn icon_view(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect, v: &View, filter: &str, actions: &mut Actions) {
    let Some(bin) = app.session.project.root.find_bin(v.bin).cloned() else { return };
    let size = v.icon_size;
    let th_h = size * 9.0 / 16.0;
    let cell = vec2(size + 20.0, th_h + 34.0);
    let ids = icon_order(app, &bin, filter);
    let bins: Vec<Bin> = if filter.is_empty() {
        bin.children.iter().filter_map(|e| if let BinEntry::Bin(b) = e { Some(b.clone()) } else { None }).collect()
    } else {
        Vec::new()
    };
    let n = bins.len() + ids.len();
    egui::ScrollArea::vertical().id_salt((&v.prefix, "icon-scroll")).auto_shrink([false, false]).show(ui, |ui| {
        let bg = background(ui, v);
        let per_row = ((rect.width() - 12.0) / cell.x).floor().max(1.0) as usize;
        if v.inst == Inst::Main {
            app.ui.keys.icon_columns = per_row;
        }
        let rows = n.div_ceil(per_row);
        for rr in 0..rows {
            let (row, _) = ui.allocate_exact_size(vec2(ui.available_width(), cell.y), Sense::hover());
            for k in 0..per_row {
                let i = rr * per_row + k;
                if i >= n {
                    break;
                }
                let r = Rect::from_min_size(pos2(row.min.x + 12.0 + k as f32 * cell.x, row.min.y + 8.0), vec2(size, th_h + 20.0));
                if i < bins.len() {
                    bin_card(app, ui, r, &bins[i], v, actions);
                    continue;
                }
                let id = ids[i - bins.len()];
                let Some(kind) = app.session.project.item(id).map(|x| x.kind.clone()) else { continue };
                let was_selected = app.session.state.project_selection.contains(&id);
                if let Some(resp) = card(app, ui, r, id, &v.prefix, true, true, Sense::click_and_drag()) {
                    note_hit(ui, v, id, r);
                    scroll_to_revealed(app, ui, v, id, r.expand(8.0));
                    let name_r = Rect::from_min_max(pos2(r.min.x, r.min.y + th_h), r.max);
                    slow_click_rename(app, ui, &resp, name_r, id, was_selected);
                    item_interactions(
                        app,
                        ui,
                        actions,
                        ItemInteraction { view: v, response: &resp, item: id, kind: &kind, allow_drag: true, allow_menu: true },
                    );
                }
            }
        }
        empty_space(app, ui, v, &bg, actions);
    });
}

// ------------------------------------------------------------------------------------ freeform

pub fn freeform_view(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect, v: &View, filter: &str, actions: &mut Actions) {
    let t = app.tokens;
    let opts = app.session.prefs.project_panel.freeform.clone();
    // the footer's Zoom scales the canvas (#3774); cards keep their positions and sizes unscaled
    let z = freeform_zoom(v.icon_size);
    // the canvas width the cards wrap at, unscaled: the layout commands below get the same one
    let width = rect.width() / z;
    let mut cards: Vec<Card> = pp::freeform_layout(&app.session.project, Some(v.bin), &opts, width);
    cards.retain(|c| matches_filter(app, ItemId(c.item), filter));
    let drag_key = egui::Id::unique((&v.prefix, "ff-drag"));
    // (dragged item, offset so far)
    let dragging: Option<(u64, egui::Vec2)> = ui.ctx().data(|d| d.get_temp(drag_key));
    let sel: Vec<u64> = app.session.state.project_selection.iter().map(|i| i.0).collect();
    let moving = |c: &Card| -> bool {
        dragging.is_some_and(|(d, _)| {
            let stack_of_d = cards_stack(&cards, d);
            c.item == d || (sel.contains(&d) && sel.contains(&c.item)) || (stack_of_d.is_some() && c.stack == stack_of_d)
        })
    };
    let extent =
        cards.iter().fold(vec2(rect.width(), rect.height()), |e, c| vec2(e.x.max((c.x + c.size + 40.0) * z), e.y.max((c.y + c.size * 9.0 / 16.0 + 60.0) * z)));
    // a middle-button drag anywhere on the canvas pans it, the content following the pointer, as in
    // the Timeline and the monitors (#579); cards move only with the primary button
    let (offset_key, pan_key) = (egui::Id::unique((&v.prefix, "ff-offset")), egui::Id::unique((&v.prefix, "ff-pan")));
    let view = ui.max_rect();
    let (middle, origin, pos) = ui.input(|i| (i.pointer.middle_down(), i.pointer.press_origin(), i.pointer.latest_pos()));
    let mut area = egui::ScrollArea::both().id_salt((&v.prefix, "ff-scroll")).auto_shrink([false, false]);
    // (where the middle button went down, the scroll offset then)
    let pan: Option<(egui::Pos2, egui::Vec2)> = ui.ctx().data(|d| d.get_temp(pan_key));
    match (middle, pan, origin, pos) {
        (true, Some((from, start)), _, Some(p)) => area = area.scroll_offset((start - (p - from)).max(egui::Vec2::ZERO)),
        (true, None, Some(o), _) if view.contains(o) => {
            let start: egui::Vec2 = ui.ctx().data(|d| d.get_temp(offset_key)).unwrap_or_default();
            ui.ctx().data_mut(|d| d.insert_temp(pan_key, (o, start)));
        }
        (false, Some(_), _, _) => ui.ctx().data_mut(|d| d.remove::<(egui::Pos2, egui::Vec2)>(pan_key)),
        _ => {}
    }
    let out = area.show(ui, |ui| {
        ui.data_mut(|d| d.remove::<Vec<(u64, Rect)>>(hits_id(v)));
        let (canvas, bg) = ui.allocate_exact_size(extent, Sense::click_and_drag());
        app.auto.add(&format!("{}.freeform", v.prefix), canvas, "Freeform canvas");
        if opts.snap {
            let g = opts.grid.max(4.0) * z;
            let mut x = canvas.min.x;
            while x < canvas.max.x {
                ui.painter().line_segment([pos2(x, canvas.min.y), pos2(x, canvas.max.y)], Stroke::new(0.5, t.separator.gamma_multiply(0.5)));
                x += g;
            }
            let mut y = canvas.min.y;
            while y < canvas.max.y {
                ui.painter().line_segment([pos2(canvas.min.x, y), pos2(canvas.max.x, y)], Stroke::new(0.5, t.separator.gamma_multiply(0.5)));
                y += g;
            }
        }
        // stack sizes for the "×N" badge
        let mut stack_n: std::collections::BTreeMap<u64, usize> = Default::default();
        for c in &cards {
            if let Some(s) = c.stack {
                *stack_n.entry(s).or_default() += 1;
            }
        }
        // stacked cards behind their stack's first card: draw deeper cards first
        let mut order: Vec<usize> = (0..cards.len()).collect();
        order.sort_by_key(|i| cards[*i].stack == Some(cards[*i].item));
        let mut released: Option<(u64, egui::Vec2)> = None;
        for i in order {
            let c = cards[i].clone();
            let off = if moving(&c) { dragging.map(|d| d.1).unwrap_or_default() } else { egui::Vec2::ZERO };
            let r = Rect::from_min_size(canvas.min + vec2(c.x, c.y) * z + off, vec2(c.size * z, c.size * z * 9.0 / 16.0 + 20.0));
            let Some(kind) = app.session.project.item(ItemId(c.item)).map(|x| x.kind.clone()) else { continue };
            let Some(resp) = card(app, ui, r, ItemId(c.item), &v.prefix, opts.show_names, opts.show_durations, Sense::click_and_drag()) else { continue };
            note_hit(ui, v, ItemId(c.item), r);
            scroll_to_revealed(app, ui, v, ItemId(c.item), r.expand(8.0));
            if let Some(s) = c.stack
                && s == c.item
                && let Some(n) = stack_n.get(&s)
            {
                let br = Rect::from_min_size(r.min + vec2(4.0, 4.0), vec2(26.0, 16.0));
                ui.painter().rect_filled(br, 3.0, t.accent);
                ui.painter().text(br.center(), Align2::CENTER_CENTER, format!("×{n}"), Tokens::ui(10.0), Color32::WHITE);
                app.auto.add(&format!("{}.stack.{s}", v.prefix), br, &format!("Stack of {n}"));
            }
            item_interactions(
                app,
                ui,
                actions,
                ItemInteraction { view: v, response: &resp, item: ItemId(c.item), kind: &kind, allow_drag: false, allow_menu: false },
            );
            // Escape puts the cards back and drops nothing until the button comes up (#580); egui
            // also ends the drag on Escape, so it arrives as a stop as often as during the drag
            let escape = ui.input(|i| i.key_pressed(egui::Key::Escape));
            // only the primary button moves cards: a middle-button drag pans the canvas (#579)
            let (dragged, stopped) = (resp.dragged_by(egui::PointerButton::Primary), resp.drag_stopped_by(egui::PointerButton::Primary));
            if (dragged || stopped) && (escape || crate::panels::drag_cancelled(ui)) {
                ui.ctx().data_mut(|d| d.remove::<(u64, egui::Vec2)>(drag_key));
                crate::panels::cancel_drag(ui);
            } else if dragged {
                let total = dragging.filter(|d| d.0 == c.item).map(|d| d.1).unwrap_or_default() + resp.drag_delta();
                ui.ctx().data_mut(|d| d.insert_temp(drag_key, (c.item, total)));
                // leaving the panel turns the move into an item drag (to the Timeline, a monitor)
                if let Some(p) = ui.ctx().pointer_latest_pos()
                    && !rect.contains(p)
                    && crate::panels::dragged_project_item(ui).is_none()
                {
                    crate::panels::start_drag_item(ui, ItemId(c.item));
                }
            }
            if stopped && !crate::panels::drag_cancelled(ui) {
                released = dragging.filter(|d| d.0 == c.item).map(|d| (d.0, d.1 + resp.drag_delta()));
            }
            resp.context_menu(|ui| card_menu(app, ui, v, c.item, width, actions));
        }
        marquee(app, ui, v, &bg, canvas.min, actions);
        if let Some((item, off)) = released {
            ui.ctx().data_mut(|d| d.remove::<(u64, egui::Vec2)>(drag_key));
            let inside = ui.ctx().pointer_latest_pos().is_some_and(|p| rect.contains(p));
            if inside && off.length() > 1.0 {
                let c = cards.iter().find(|c| c.item == item).cloned();
                if let Some(c) = c {
                    // the dragged card and the selection (or its stack) move together
                    let mut items = vec![item];
                    if sel.contains(&item) {
                        items.extend(sel.iter().filter(|i| **i != item));
                    }
                    if let Some(s) = cards_stack(&cards, item) {
                        let more: Vec<u64> = cards.iter().filter(|x| x.stack == Some(s) && !items.contains(&x.item)).map(|x| x.item).collect();
                        items.extend(more);
                        // the stack's first card leads so the others keep their offsets
                        items.retain(|i| *i != s);
                        items.insert(0, s);
                    }
                    let lead = cards.iter().find(|x| x.item == items[0]).cloned().unwrap_or(c);
                    // the drag moved on screen, the cards live on the unscaled canvas
                    actions.push((
                        "project.freeform.move".into(),
                        json!({"items": items, "x": (lead.x + off.x / z).max(0.0), "y": (lead.y + off.y / z).max(0.0), "width": width}),
                    ));
                }
            }
        }
        if bg.clicked() {
            app.ui.project_panel.selected_bin = None;
            actions.push(("project.select".into(), json!({"items": []})));
        }
        if bg.double_clicked() {
            actions.push(("file.import".into(), json!({})));
        }
        let bin = Some(v.bin.0);
        bg.context_menu(|ui| canvas_menu(app, ui, v, bin, width, actions));
    });
    ui.ctx().data_mut(|d| d.insert_temp(offset_key, out.state.unclamped_offset()));
}

/// The Freeform canvas scale for the footer's Zoom: 1 at the default size, as Icon view's card size.
pub(crate) fn freeform_zoom(icon_size: f32) -> f32 {
    if icon_size.is_finite() { (icon_size / pp::ViewSettings::default().icon_size).clamp(0.25, 4.0) } else { 1.0 }
}

/// The List view row height with thumbnails for the footer's Zoom: the thumbnail follows it
/// (#3774), never smaller than a row without one.
fn list_thumb_row_height(icon_size: f32, font: f32) -> f32 {
    let plain = (font * 2.0).max(22.0);
    if icon_size.is_finite() { (icon_size * 0.4).max(plain) } else { (font * 3.6).max(44.0) }
}

/// The narrowest Name column that shows a row's thumbnail and still 120 points of its name, for
/// items one bin deep (the row draws the thumbnail 16:9 at the row height less 6).
fn list_name_width(row_h: f32) -> f32 {
    (row_h - 6.0).max(0.0) * 16.0 / 9.0 + 14.0 * 2.0 + 18.0 + 120.0
}

fn cards_stack(cards: &[Card], item: u64) -> Option<u64> {
    cards.iter().find(|c| c.item == item).and_then(|c| c.stack)
}

fn card_menu(app: &mut FilmcraftApp, ui: &mut egui::Ui, v: &View, item: u64, width: f32, actions: &mut Actions) {
    let sel: Vec<u64> = app.session.state.project_selection.iter().map(|i| i.0).collect();
    // the selection's cards in this bin: its width lays them out, not another bin's cards
    let here = |i: &u64| app.session.project.root.parent_of(ItemId(*i)) == Some(v.bin);
    let items: Vec<u64> = if sel.contains(&item) { sel.iter().copied().filter(here).collect() } else { vec![item] };
    let b = ui.add_enabled(items.len() > 1, egui::Button::new(tl!("Stack")));
    app.auto.add(&format!("{}.cardMenu.stack", v.prefix), b.rect, "Stack");
    if b.clicked() {
        actions.push(("project.freeform.stack".into(), json!({"items": items, "width": width})));
        ui.close();
    }
    let stacked = app.session.project.item(ItemId(item)).is_some_and(|i| i.metadata.contains_key(pp::FREEFORM_STACK));
    let b = ui.add_enabled(stacked, egui::Button::new(tl!("Unstack")));
    app.auto.add(&format!("{}.cardMenu.unstack", v.prefix), b.rect, "Unstack");
    if b.clicked() {
        actions.push(("project.freeform.unstack".into(), json!({"items": items, "width": width})));
        ui.close();
    }
    ui.menu_button(tl!("Clip Size"), |ui| {
        for (label, step) in [(tl!("Larger"), 1), (tl!("Smaller"), -1)] {
            if ui.button(label).clicked() {
                actions.push(("project.freeform.resize".into(), json!({"items": items, "step": step, "width": width})));
                ui.close();
            }
        }
        if ui.button(tl!("Default")).clicked() {
            actions
                .push(("project.freeform.resize".into(), json!({"items": items, "size": app.session.prefs.project_panel.freeform.card_size, "width": width})));
            ui.close();
        }
    });
    ui.separator();
    let kind = app.session.project.item(ItemId(item)).map(|x| x.kind.clone());
    if let Some(kind) = kind {
        item_menu(app, ui, ItemId(item), &kind, actions);
    }
}

fn canvas_menu(app: &mut FilmcraftApp, ui: &mut egui::Ui, v: &View, bin: Option<u64>, width: f32, actions: &mut Actions) {
    fn entry(app: &mut FilmcraftApp, ui: &mut egui::Ui, v: &View, actions: &mut Actions, id: &str, label: &str, (cmd, p): (&str, serde_json::Value)) {
        let b = ui.button(label);
        app.auto.add(&format!("{}.canvasMenu.{id}", v.prefix), b.rect, label);
        if b.clicked() {
            actions.push((cmd.into(), p));
            ui.close();
        }
    }
    entry(app, ui, v, actions, "alignToGrid", tl!("Align to Grid"), ("project.freeform.alignToGrid", json!({"bin": bin, "width": width})));
    entry(app, ui, v, actions, "resetToGrid", tl!("Reset to Grid"), ("project.freeform.reset", json!({"bin": bin})));
    ui.separator();
    entry(app, ui, v, actions, "saveArrangement", tl!("Save Arrangement…"), ("projectPanel.saveArrangement", json!({"bin": bin, "width": width})));
    let names: Vec<String> = app
        .session
        .execute("project.freeform.arrangements", json!({"bin": bin}))
        .ok()
        .and_then(|v| serde_json::from_value(v["arrangements"].clone()).ok())
        .unwrap_or_default();
    ui.add_enabled_ui(!names.is_empty(), |ui| {
        ui.menu_button(tl!("Restore Arrangement"), |ui| {
            for n in &names {
                if ui.button(n).clicked() {
                    actions.push(("project.freeform.restoreArrangement".into(), json!({"name": n, "bin": bin})));
                    ui.close();
                }
            }
        });
        ui.menu_button(tl!("Delete Arrangement"), |ui| {
            for n in &names {
                if ui.button(n).clicked() {
                    actions.push(("project.freeform.deleteArrangement".into(), json!({"name": n, "bin": bin})));
                    ui.close();
                }
            }
        });
    });
    ui.separator();
    entry(app, ui, v, actions, "options", "Freeform View Options…", ("projectPanel.freeformOptions", json!({})));
    ui.separator();
    background_menu(app, ui, v, bin.filter(|b| *b != app.session.project.root.id.0), actions);
}

#[cfg(test)]
mod clear_tests {
    use super::{clear_params, click_selection, menu_targets};
    use filmcraft_project::ItemId;
    use serde_json::json;

    #[test]
    fn clear_falls_back_to_the_selected_bin() {
        assert_eq!(clear_params(&[], Some(7)), Some(json!({"items": [7]})));
        assert_eq!(clear_params(&[ItemId(3)], Some(7)), Some(json!({})));
        assert_eq!(clear_params(&[], None), None);
    }

    fn ids(v: &[u64]) -> Vec<ItemId> {
        v.iter().map(|i| ItemId(*i)).collect()
    }

    #[test]
    fn shift_click_selects_the_range_from_the_anchor() {
        let order = ids(&[1, 2, 3, 4, 5]);
        let sel = click_selection(&ids(&[2]), &order, Some(ItemId(2)), ItemId(4), true, false);
        assert_eq!(sel, ids(&[2, 3, 4]));
        // backwards, and replacing a different selection
        let sel = click_selection(&ids(&[5]), &order, Some(ItemId(4)), ItemId(2), true, false);
        assert_eq!(sel, ids(&[2, 3, 4]));
        // Ctrl/Cmd+Shift extends the selection
        let sel = click_selection(&ids(&[1]), &order, Some(ItemId(3)), ItemId(4), true, true);
        assert_eq!(sel, ids(&[1, 3, 4]));
        // no anchor in the shown items: like a plain click
        assert_eq!(click_selection(&ids(&[1]), &order, Some(ItemId(9)), ItemId(4), true, false), ids(&[4]));
    }

    #[test]
    fn a_right_click_inside_the_selection_acts_on_all_of_it() {
        assert_eq!(menu_targets(&ids(&[1, 2, 3]), ItemId(2)), ids(&[1, 2, 3]));
        // outside the selection: only the item right-clicked
        assert_eq!(menu_targets(&ids(&[1, 2, 3]), ItemId(9)), ids(&[9]));
        assert_eq!(menu_targets(&[], ItemId(4)), ids(&[4]));
    }

    #[test]
    fn command_click_toggles_and_plain_click_replaces() {
        let order = ids(&[1, 2, 3]);
        assert_eq!(click_selection(&ids(&[1]), &order, None, ItemId(3), false, true), ids(&[1, 3]));
        assert_eq!(click_selection(&ids(&[1, 3]), &order, None, ItemId(3), false, true), ids(&[1]));
        assert_eq!(click_selection(&ids(&[1, 3]), &order, None, ItemId(2), false, false), ids(&[2]));
    }
}

#[cfg(test)]
mod search_tests {
    use super::name_matches;

    #[test]
    fn every_typed_word_must_appear_in_any_order() {
        let name = "Comedy manager · medium · smiling · enjoys the show · img385 · A";
        assert!(name_matches(name, ""));
        assert!(name_matches(name, "comedy manager"));
        assert!(name_matches(name, "comedy manager s"));
        assert!(name_matches(name, "comedy manager smiling"));
        assert!(name_matches(name, "smiling  comedy "));
        assert!(!name_matches(name, "comedy manager laughing"));
        assert!(!name_matches("Comedy club", "comedy manager"));
    }
}