f67d38b35cc5
trim_monitor.rs
//! The Trim Monitor: while edit points are selected (trim mode) the Program monitor shows the
//! outgoing clip's last frame and the incoming clip's first frame side by side, with their
//! timecodes, the Out/In shift counters and the trim buttons (−N, −1, Apply Default Transitions,
//! +1, +N; N = Preferences ▸ Trim ▸ Large Trim Offset). Dragging in the outgoing picture trims the
//! outgoing side, in the incoming picture the incoming side, between them rolls.
//!
//! J/K/L and Space are routed to dynamic trimming / loop playback in `menus::invoke`; the engine
//! state machine (`filmcraft_engine::trim`) is advanced from logic with the monotonic host clock.
//!
//! Automation ids: `trimMonitor.outgoing`, `trimMonitor.incoming`, `trimMonitor.roll`,
//! `trimMonitor.outTimecode`, `trimMonitor.inTimecode`, `trimMonitor.outShift`,
//! `trimMonitor.inShift`, `trimMonitor.backwardMany`, `trimMonitor.backward`,
//! `trimMonitor.applyTransition`, `trimMonitor.forward`, `trimMonitor.forwardMany`,
//! `trimMonitor.playAround`, `trimMonitor.exit`.
use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
use filmcraft_edit::Edge;
use filmcraft_project::{ClipId, ItemKind, Sequence, Track, TrackId};
use filmcraft_time::{Tick, TimeDisplay, format_time};
use serde_json::{Value, json};
use crate::FilmcraftApp;
use crate::frames::{FrameKey, Target};
use crate::icons::{self, Icon};
use crate::panels::timeline::{Layout, Row};
use crate::panels::timeline_hit::EdgeKind;
use crate::theme::Tokens;
/// Ripple edit points are red, roll / regular trims yellow (as in Premiere's timeline).
pub const RIPPLE_RED: Color32 = Color32::from_rgb(0xe5, 0x3e, 0x3e);
pub const ROLL_YELLOW: Color32 = Color32::from_rgb(0xf2, 0xc4, 0x3d);
/// True when J/K/L/Space should drive trim mode instead of normal playback.
pub fn trim_mode(app: &FilmcraftApp) -> bool {
!app.session.state.edit_points.is_empty() && app.ui.focused != crate::dock::PanelKind::Source
}
/// Advance dynamic trimming / loop playback to a monotonic host time. Called from logic; a
/// repeated call at the same time is idempotent because `trim.tick` receives an absolute clock.
pub fn advance_at(app: &mut FilmcraftApp, clock: f64) {
if !app.session.trim_play.active() {
return;
}
if let Err(e) = app.session.execute("trim.tick", json!({"clock": clock})) {
app.ui.status = e.to_string();
}
}
/// Route a transport command in trim mode (J/K/L/Space/Shift+K). `None` = not handled.
pub fn route_transport(app: &mut FilmcraftApp, ctx: &egui::Context, id: &str) -> Option<Result<Value, String>> {
let _ = ctx;
let clock = app.now();
let trimming = trim_mode(app);
let (cmd, params) = match id {
"playback.forward" if trimming => ("trim.shuttle", json!({"direction": "forward", "clock": clock})),
"playback.reverse" if trimming => ("trim.shuttle", json!({"direction": "reverse", "clock": clock})),
"playback.slowForward" if trimming => ("trim.shuttle", json!({"direction": "forward", "slow": true, "clock": clock})),
"playback.slowReverse" if trimming => ("trim.shuttle", json!({"direction": "reverse", "slow": true, "clock": clock})),
"playback.stop" if app.session.trim_play.active() => ("trim.shuttleStop", json!({"clock": clock})),
"playback.toggle" if trimming || app.session.trim_play.around.is_some() => ("trim.playAround", json!({"clock": clock, "toggle": true})),
"playback.playAround" => ("trim.playAround", json!({"clock": clock, "loop": false})),
_ => return None,
};
app.stop();
Some(app.session.execute(cmd, params).map_err(|e| e.to_string()))
}
/// Paint the selected edit points that sit on `tr` as brackets at the clip edges.
pub fn paint_edit_points(app: &FilmcraftApp, p: &egui::Painter, seq: &Sequence, tr: &Track, row: &Row, layout: &Layout) {
use filmcraft_engine::trim::{TrimKind, roll_pair};
for ep in &app.session.state.edit_points {
let mut marks = Vec::new(); // (clip on this track, out edge)
if ep.kind == TrimKind::Roll
&& let Some((l, r)) = roll_pair(seq, ep)
{
marks.push((l, true));
marks.push((r, false));
} else {
marks.push((ep.clip, ep.out));
}
let col = if ep.kind == TrimKind::Ripple { RIPPLE_RED } else { ROLL_YELLOW };
for (clip, out) in marks {
let Some(it) = tr.item(clip) else { continue };
paint_bracket(p, layout.x_of(if out { it.end() } else { it.start }), row, out, col);
}
}
}
/// A trim bracket at `x` on `row`, its arms pointing into the clip (left for an Out edge).
pub fn paint_bracket(p: &egui::Painter, x: f32, row: &Row, out: bool, col: Color32) {
let (y0, y1) = (row.rect.min.y + 2.0, row.rect.max.y - 2.0);
let dir = if out { -1.0 } else { 1.0 };
let xi = x + dir * 1.5;
let w = 6.0 * dir;
let s = Stroke::new(3.0, col);
p.line_segment([pos2(xi, y0), pos2(xi, y1)], s);
p.line_segment([pos2(xi, y0 + 1.0), pos2(xi + w, y0 + 1.0)], s);
p.line_segment([pos2(xi, y1 - 1.0), pos2(xi + w, y1 - 1.0)], s);
}
/// The bracket on the edge a press would grab (#259): an edit point's bracket at half strength,
/// red for a ripple and yellow otherwise; a roll marks both sides of the cut.
pub fn paint_hover_bracket(p: &egui::Painter, seq: &Sequence, layout: &Layout, track: TrackId, clip: ClipId, edge: Edge, kind: EdgeKind) {
let Some(row) = layout.rows.iter().find(|r| r.track == track) else { return };
let Some(tr) = seq.track(track) else { return };
let full = if kind == EdgeKind::Ripple { RIPPLE_RED } else { ROLL_YELLOW };
let col = full.gamma_multiply(0.5);
let marks = match kind {
EdgeKind::Roll { left, right } => vec![(left, true), (right, false)],
_ => vec![(clip, edge == Edge::Out)],
};
for (c, out) in marks {
let Some(it) = tr.item(c) else { continue };
paint_bracket(p, layout.x_of(if out { it.end() } else { it.start }), row, out, col);
}
}
/// Fit a w×h picture into `area`.
fn fit(area: Rect, w: f32, h: f32) -> Rect {
let s = (area.width() / w.max(1.0)).min(area.height() / h.max(1.0));
Rect::from_center_size(area.center(), vec2(w * s, h * s))
}
/// Draw one side's frame (the clip's media at `media_time`).
fn picture(app: &mut FilmcraftApp, ui: &mut egui::Ui, area: Rect, side: &Value, tex_name: &str) -> Rect {
let t = app.tokens;
let item = filmcraft_project::ItemId(side["item"].as_u64().unwrap_or(0));
let Some(pi) = app.session.project.item(item) else { return area };
let size = match &pi.kind {
ItemKind::Media(m) => m.info.video.as_ref().map(|v| (v.width, v.height)).unwrap_or((0, 0)),
ItemKind::Sequence(s) => (s.settings.width, s.settings.height),
_ => (1920, 1080),
};
let seq_size = app.session.active_sequence().map(|q| (q.settings.width, q.settings.height)).unwrap_or((1920, 1080));
let pic = fit(area, seq_size.0 as f32, seq_size.1 as f32);
ui.painter().rect_filled(pic, 0.0, t.monitor_bg);
if size.0 == 0 || !side["video"].as_bool().unwrap_or(false) {
ui.painter().text(pic.center(), Align2::CENTER_CENTER, format!("♪ {}", side["name"].as_str().unwrap_or("")), Tokens::ui(13.0), t.text_dim);
return pic;
}
let img_rect = fit(pic, size.0 as f32, size.1 as f32);
let rate = pi.frame_rate();
let media_time = Tick(side["mediaTime"].as_i64().unwrap_or(0));
let frame = rate.frame_at(media_time);
let ppp = ui.ctx().pixels_per_point();
let want = (img_rect.width() * ppp / size.0 as f32).clamp(1.0 / 32.0, 1.0);
let buckets = [1.0 / 32.0, 1.0 / 16.0, 1.0 / 8.0, 0.1875, 0.25, 0.375, 0.5, 0.75, 1.0];
let scale = *buckets.iter().find(|b| **b >= want - 1e-4).unwrap_or(&1.0);
let scale = scale.min(app.ui.program.res.scale());
let size_key = (scale * 1000.0) as u32;
let rev = app.item_revision(item);
let key = FrameKey { target: Target::Item(item), frame, size: size_key, revision: rev, draft: false };
let project = app.session.project.clone();
app.frames.request(key, rate.tick_of(frame), scale, &project, 0);
let ctx = ui.ctx().clone();
let tex = if let Some(img) = app.frames.get(&key) {
Some(app.texture_for(&ctx, tex_name, key, &img))
} else {
match app.frames.nearest(Target::Item(item), frame, size_key, rev, 48) {
Some(img) => Some(app.texture_for(&ctx, tex_name, FrameKey { frame: frame - 1, ..key }, &img)),
None => app.texture_existing(tex_name).map(|(id, _)| id),
}
};
if let Some(tex) = tex {
ui.painter().image(tex, img_rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
}
pic
}
fn shift_text(frames: i64) -> String {
if frames > 0 { format!("+{frames}") } else { frames.to_string() }
}
/// The two-up Trim Monitor in the Program monitor's `rect`.
pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
let t = app.tokens;
let info = filmcraft_engine::trim::monitor_info(&app.session);
let Some(seq) = app.session.active_sequence() else { return };
let rate = seq.settings.frame_rate;
let df = seq.settings.drop_frame;
ui.painter().rect_filled(rect, 0.0, t.panel_bg);
let controls_h = 26.0 + 40.0;
let header_h = 22.0;
let gap = 14.0;
let area = Rect::from_min_max(rect.min + vec2(6.0, 4.0 + header_h), pos2(rect.max.x - 6.0, rect.max.y - controls_h));
let half = (area.width() - gap) / 2.0;
let left = Rect::from_min_size(area.min, vec2(half, area.height()));
let right = Rect::from_min_size(pos2(left.max.x + gap, area.min.y), vec2(half, area.height()));
let kind = info["kind"].as_str().unwrap_or("trim").to_string();
let out_edge = info["edge"] == json!("out");
// which sides move: roll = both; otherwise the side the edit point belongs to
let (hot_out, hot_in) = match kind.as_str() {
"roll" => (true, true),
_ => (out_edge, !out_edge),
};
let col = if kind == "ripple" { RIPPLE_RED } else { ROLL_YELLOW };
// headers: clip names
for (side, r, key) in [(&info["outgoing"], left, "outgoing"), (&info["incoming"], right, "incoming")] {
let name = side["name"].as_str().map(|n| format!("{} ({})", n, side["track"].as_str().unwrap_or(""))).unwrap_or_else(|| tl!("(gap)").into());
let label = if key == "outgoing" { tlf!("Out: {name}", name) } else { tlf!("In: {name}", name) };
ui.painter().text(pos2(r.min.x + 2.0, rect.min.y + 4.0 + header_h / 2.0), Align2::LEFT_CENTER, label, Tokens::ui(11.5), t.text_dim);
}
let mut pics = [left, right];
for (i, (side, r)) in [(&info["outgoing"], left), (&info["incoming"], right)].into_iter().enumerate() {
if side.is_null() {
let p = fit(r, 16.0, 9.0);
ui.painter().rect_filled(p, 0.0, Color32::BLACK);
ui.painter().text(p.center(), Align2::CENTER_CENTER, tl!("(gap)"), Tokens::ui(12.0), t.text_faint);
pics[i] = p;
} else {
pics[i] = picture(app, ui, r, side, if i == 0 { "trim-outgoing" } else { "trim-incoming" });
}
}
let [lp, rp] = pics;
let hot = [hot_out, hot_in];
for (i, p) in pics.iter().enumerate() {
if hot[i] {
ui.painter().rect_stroke(*p, 0.0, Stroke::new(2.0, col), StrokeKind::Outside);
}
}
// dynamic trim indicator
if let Some(d) = info["dynamic"].as_object() {
let sp = d.get("speed").and_then(Value::as_f64).unwrap_or(0.0);
let txt = if sp == 0.0 {
"TRIM ■".to_string()
} else if sp > 0.0 {
format!("TRIM ▶ {sp}×")
} else {
format!("TRIM ◀ {}×", -sp)
};
let at = pos2((lp.max.x + rp.min.x) / 2.0, area.min.y + 12.0);
ui.painter().text(at, Align2::CENTER_CENTER, txt, Tokens::semibold(11.0), col);
}
app.auto.add("trimMonitor.outgoing", lp, "Outgoing clip (drag to trim the Out point)");
app.auto.add("trimMonitor.incoming", rp, "Incoming clip (drag to trim the In point)");
let mid = Rect::from_min_max(pos2(lp.max.x, area.min.y), pos2(rp.min.x, area.max.y));
app.auto.add("trimMonitor.roll", mid, "Drag to roll the edit");
// drag to trim: px → frames (6 px per frame), applied on release as one trim
let fpp = 1.0 / 6.0;
for (r, which) in [(lp, "out"), (rp, "in"), (mid, "roll")] {
let resp = ui.interact(r, egui::Id::unique(("trim-monitor-drag", which)), Sense::drag());
if resp.dragged() || resp.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeColumn);
}
if resp.dragged() {
// read the delta before locking: drag_delta() takes the context's write lock,
// the same one data_mut() holds, and that lock is not reentrant (deadlock)
let dx = resp.drag_delta().x;
let total = ui.ctx().data_mut(|d| {
let v = d.get_temp_mut_or_default::<f32>(egui::Id::unique("trim-monitor-dx"));
*v += dx;
*v
});
let n = (total * fpp).round() as i64;
ui.painter().text(pos2(r.center().x, r.max.y - 14.0), Align2::CENTER_CENTER, shift_text(n), Tokens::semibold(14.0), col);
}
if resp.drag_stopped() {
let total = ui.ctx().data_mut(|d| d.remove_temp::<f32>(egui::Id::unique("trim-monitor-dx")).unwrap_or(0.0));
let n = (total * fpp).round() as i64;
// egui ends a drag on Escape: that stop abandons it (#580)
if n != 0 && !ui.input(|i| i.key_pressed(egui::Key::Escape)) {
drag_trim(app, which, n);
}
}
}
// ---- counters row: outgoing Out timecode + shift | incoming In timecode + shift
let row = Rect::from_min_size(pos2(rect.min.x + 10.0, area.max.y + 2.0), vec2(rect.width() - 20.0, 24.0));
let tc = |v: &Value, k: &str| v[k].as_i64().map(|x| format_time(Tick(x), rate, df, TimeDisplay::Timecode, 48000)).unwrap_or_else(|| "--:--:--:--".into());
let out_tc = tc(&info["outgoing"], "time");
let in_tc = tc(&info["incoming"], "time");
let out_shift = shift_text(info["outShift"].as_i64().unwrap_or(0));
let in_shift = shift_text(info["inShift"].as_i64().unwrap_or(0));
let p = ui.painter();
let tcr = p.text(pos2(lp.min.x, row.center().y), Align2::LEFT_CENTER, &out_tc, Tokens::semibold(14.0), t.hot_text);
app.auto.add("trimMonitor.outTimecode", tcr, &out_tc);
let sr = p.text(pos2(lp.max.x, row.center().y), Align2::RIGHT_CENTER, &out_shift, Tokens::semibold(14.0), if hot_out { col } else { t.text_dim });
app.auto.add("trimMonitor.outShift", sr, &out_shift);
let sr = p.text(pos2(rp.min.x, row.center().y), Align2::LEFT_CENTER, &in_shift, Tokens::semibold(14.0), if hot_in { col } else { t.text_dim });
app.auto.add("trimMonitor.inShift", sr, &in_shift);
let tcr = p.text(pos2(rp.max.x, row.center().y), Align2::RIGHT_CENTER, &in_tc, Tokens::semibold(14.0), t.hot_text);
app.auto.add("trimMonitor.inTimecode", tcr, &in_tc);
// ---- trim buttons
let n = info["largeTrimOffset"].as_i64().unwrap_or(5);
let bar = Rect::from_min_size(pos2(rect.min.x, row.max.y + 6.0), vec2(rect.width(), 28.0));
let buttons: [(&str, String, &str, f32); 6] = [
("trimMonitor.playAround", String::new(), tl!("Play Around Edit (Space loops, Shift+K once)"), 30.0),
("trimMonitor.backwardMany", format!("−{n}"), tl!("Trim Backward Many"), 40.0),
("trimMonitor.backward", "−1".into(), tl!("Trim Backward"), 40.0),
("trimMonitor.applyTransition", tl!("Apply Default Transitions").into(), tl!("Apply Default Transitions to Selection (Shift+D)"), 176.0),
("trimMonitor.forward", "+1".into(), tl!("Trim Forward"), 40.0),
("trimMonitor.forwardMany", format!("+{n}"), tl!("Trim Forward Many"), 40.0),
];
let total: f32 = buttons.iter().map(|b| b.3 + 4.0).sum();
let mut x = bar.center().x - total / 2.0;
for (id, label, tip, w) in buttons {
let r = Rect::from_min_size(pos2(x, bar.min.y), vec2(w, bar.height()));
let resp = ui.interact(r, egui::Id::unique(id), Sense::click()).on_hover_text(tip);
let bg = if resp.is_pointer_button_down_on() {
t.pressed
} else if resp.hovered() {
t.hover
} else {
t.field_bg
};
ui.painter().rect_filled(r, 4.0, bg);
if label.is_empty() {
let playing = app.session.trim_play.around.is_some();
icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(14.0, 14.0)), if playing { Icon::Pause } else { Icon::Loop }, t.icon);
} else {
ui.painter().text(r.center(), Align2::CENTER_CENTER, &label, Tokens::ui(12.0), t.text);
}
app.auto.add(id, r, tip);
if resp.clicked() {
let res = match id {
"trimMonitor.playAround" => app.session.execute("trim.playAround", json!({"clock": app.now(), "toggle": true})),
"trimMonitor.backwardMany" => app.session.execute("trim.backwardMany", json!({})),
"trimMonitor.backward" => app.session.execute("trim.backward", json!({})),
"trimMonitor.forward" => app.session.execute("trim.forward", json!({})),
"trimMonitor.forwardMany" => app.session.execute("trim.forwardMany", json!({})),
_ => app.session.execute("trim.applyDefaultTransition", json!({})),
};
if let Err(e) = res {
app.ui.status = e.to_string();
}
}
x += w + 4.0;
}
// exit trim mode
let r = Rect::from_min_size(pos2(rect.max.x - 30.0, bar.min.y + 3.0), vec2(22.0, 22.0));
let resp = ui.interact(r, egui::Id::unique("trimMonitor.exit"), Sense::click()).on_hover_text(tl!("Exit Trim Mode"));
let c = if resp.hovered() { t.tab_text_active } else { t.text_dim };
ui.painter().line_segment([r.min + vec2(6.0, 6.0), r.max - vec2(6.0, 6.0)], Stroke::new(1.5, c));
ui.painter().line_segment([pos2(r.max.x - 6.0, r.min.y + 6.0), pos2(r.min.x + 6.0, r.max.y - 6.0)], Stroke::new(1.5, c));
app.auto.add("trimMonitor.exit", r, "Exit Trim Mode");
if resp.clicked() {
let _ = app.session.execute("trim.clear", json!({}));
}
}
/// A drag in the Trim Monitor: re-target the primary edit point to the dragged side, then trim.
fn drag_trim(app: &mut FilmcraftApp, which: &str, frames: i64) {
use filmcraft_engine::trim::{TrimKind, sides};
let Some(seq) = app.session.active_sequence() else { return };
let Some(ep) = app.session.state.edit_points.first().copied() else { return };
let (out_c, in_c) = sides(seq, &ep);
let target = match which {
"out" => out_c.map(|c| (c, "out", if ep.kind == TrimKind::Roll { TrimKind::Ripple } else { ep.kind })),
"in" => in_c.map(|c| (c, "in", if ep.kind == TrimKind::Roll { TrimKind::Ripple } else { ep.kind })),
_ => out_c.or(in_c).map(|c| (c, if out_c.is_some() { "out" } else { "in" }, TrimKind::Roll)),
};
let Some((clip, edge, kind)) = target else { return };
let multi = app.session.state.edit_points.len() > 1;
if !multi && (clip != ep.clip || (edge == "out") != ep.out || kind != ep.kind) {
let kind = serde_json::to_value(kind).unwrap_or(json!("trim"));
let _ = app.session.execute("trim.selectEditPoint", json!({"clip": clip.0, "edge": edge, "kind": kind}));
}
if let Err(e) = app.session.execute("trim.nudge", json!({"frames": frames})) {
app.ui.status = e.to_string();
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.