f67d38b35cc5
keyboard.rs
//! Keyboard-only UI commands from Premiere's default keyboard (M3.12): frame maximize / full
//! screen, panel cycling, monitor zoom, track heights, Project panel and Text panel keyboard
//! navigation, play-to-Out variants. The project-changing keyboard commands are engine commands
//! (`filmcraft_engine::keyboard`); these only change what the UI shows.
//!
//! | Id | Premiere command | Default key (scope) |
//! |---|---|---|
//! | `window.maximizeFrame` / `window.maximizeFrameUnderCursor` | Maximize or Restore Active Frame / Frame Under Cursor | Shift+` / ` |
//! | `window.toggleFullScreen` | Toggle Full Screen | Ctrl+` |
//! | `view.fullScreenProgram` | Full Screen Program Monitor | |
//! | `window.nextPanel` / `window.prevPanel` | Select Next / Previous Panel | Ctrl+Shift+. / Ctrl+Shift+, |
//! | `window.toggleMonitorFocus` | Toggle Source/Program Monitor Focus | |
//! | `window.openSearch` / `panel.selectFindBox` | Open Search / Select Find Box | Cmd+Shift+F / Shift+F |
//! | `view.programZoom100` / `view.programZoomFit` | Zoom Program Monitor to 100% / Fit | Cmd+Shift+1 / Cmd+Shift+0 |
//! | `view.sourceZoom100` / `view.sourceZoomFit` | Zoom Source Monitor to 100% / Fit | Cmd+Alt+Shift+1 / Cmd+Alt+Shift+0 |
//! | `playback.inToOutPreroll` / `playback.toOut` | Play In to Out with Preroll/Postroll / Play from Playhead to Out Point | Shift+Space / Ctrl+Space |
//! | `timeline.expandAllTracks` / `timeline.minimizeAllTracks` | Expand / Minimize All Tracks | Shift+= / Shift+- |
//! | `timeline.increaseVideoHeight` … `timeline.decreaseAudioHeight` | Increase / Decrease Video / Audio Tracks Height | Cmd+= / Cmd+- / Alt+= / Alt+- (Timeline) |
//! | `timeline.nextScreen` / `timeline.prevScreen` | Show Next / Previous Screen | PageDown / PageUp (Timeline) |
//! | `projectPanel.*` | Project panel: List / Icon / Toggle View, Hover Scrub, thumbnail size, Move / Extend Selection | (Project) |
//! | `textPanel.*` | Text panel transcript: word / line / segment navigation and selection, Delete, Ripple Delete, Show Program Transcript | (Text) |
//! | `mixer.showHideTracks` / `mixer.meterInputOnly` | Audio Track Mixer: Show/Hide Tracks / Meter Input(s) Only | Cmd+Alt+T / Ctrl+Shift+I (Audio Track Mixer) |
//! | `graphics.beginTextEditing` | Begin Text Editing for a Graphic Layer | Cmd+Alt+' |
//! | `help.filmcraftHelp` | Help (Premiere Help…) | F1 |
//! | `app.quit` | Quit | Cmd+Q |
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::FilmcraftApp;
use crate::dock::PanelKind;
use crate::menus::UiCommand;
use filmcraft_engine::project_panel::ViewMode;
/// Keyboard-only view state.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct KeysState {
/// The maximized frame (Maximize or Restore Frame); None = the normal layout.
pub maximized: Option<PanelKind>,
/// Track heights before Expand / Minimize All Tracks (pressing again restores them).
pub saved_heights: Option<[f32; 2]>,
/// Icon view columns in the last frame (Move Selection Up / Down step).
pub icon_columns: usize,
}
impl Default for KeysState {
fn default() -> Self {
Self { maximized: None, saved_heights: None, icon_columns: 1 }
}
}
macro_rules! uic {
($id:literal, $label:literal, [$($m:literal),*], $sc:expr) => {
UiCommand { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc }
};
}
/// Frontend commands added for keyboard parity. Panel-scoped keys are in the shortcut tables
/// (`FILMCRAFT_PANEL`), so they have no application-wide default here.
pub const COMMANDS: &[UiCommand] = &[
uic!("window.maximizeFrame", "Maximize or Restore Active Frame", [], Some("Shift+`")),
uic!("window.maximizeFrameUnderCursor", "Maximize or Restore Frame Under Cursor", [], Some("`")),
uic!("window.toggleFullScreen", "Toggle Full Screen", [], Some("Ctrl+`")),
uic!("view.fullScreenProgram", "Full Screen Program Monitor", [], None),
uic!("window.nextPanel", "Select Next Panel", [], Some("Ctrl+Shift+.")),
uic!("window.prevPanel", "Select Previous Panel", [], Some("Ctrl+Shift+,")),
uic!("window.toggleMonitorFocus", "Toggle Source/Program Monitor Focus", [], None),
uic!("window.openSearch", "Open Search", [], Some("Cmd+Shift+F")),
uic!("panel.selectFindBox", "Select Find Box", [], Some("Shift+F")),
uic!("window.workspace.learning", "Learning", ["Window", "Workspaces"], Some("Alt+Shift+7")),
uic!("window.workspace.review", "Review", ["Window", "Workspaces"], Some("Alt+Shift+8")),
uic!("view.programZoom100", "Zoom Program Monitor to 100%", [], Some("Cmd+Shift+1")),
uic!("view.programZoomFit", "Zoom Program Monitor to Fit", [], Some("Cmd+Shift+0")),
uic!("view.sourceZoom100", "Zoom Source Monitor to 100%", [], Some("Cmd+Alt+Shift+1")),
uic!("view.sourceZoomFit", "Zoom Source Monitor to Fit", [], Some("Cmd+Alt+Shift+0")),
uic!("playback.inToOutPreroll", "Play In to Out with Preroll/Postroll", [], Some("Shift+Space")),
uic!("playback.toOut", "Play from Playhead to Out Point", [], Some("Ctrl+Space")),
uic!("timeline.expandAllTracks", "Expand All Tracks", [], Some("Shift+=")),
uic!("timeline.minimizeAllTracks", "Minimize All Tracks", [], Some("Shift+-")),
uic!("timeline.increaseVideoHeight", "Increase Video Tracks Height", [], None),
uic!("timeline.decreaseVideoHeight", "Decrease Video Tracks Height", [], None),
uic!("timeline.increaseAudioHeight", "Increase Audio Tracks Height", [], None),
uic!("timeline.decreaseAudioHeight", "Decrease Audio Tracks Height", [], None),
uic!("timeline.nextScreen", "Show Next Screen", [], None),
uic!("timeline.prevScreen", "Show Previous Screen", [], None),
uic!("projectPanel.viewList", "List", [], None),
uic!("projectPanel.viewIcon", "Icon", [], None),
uic!("projectPanel.toggleView", "Toggle View", [], None),
uic!("projectPanel.hoverScrub", "Hover Scrub", [], None),
uic!("projectPanel.thumbnailLarger", "Thumbnail Size Next", [], None),
uic!("projectPanel.thumbnailSmaller", "Thumbnail Size Previous", [], None),
uic!("projectPanel.moveUp", "Move Selection Up", [], None),
uic!("projectPanel.moveDown", "Move Selection Down", [], None),
uic!("projectPanel.moveLeft", "Move Selection Left", [], None),
uic!("projectPanel.moveRight", "Move Selection Right", [], None),
uic!("projectPanel.moveHome", "Move Selection Home", [], None),
uic!("projectPanel.moveEnd", "Move Selection End", [], None),
uic!("projectPanel.movePageUp", "Move Selection Page Up", [], None),
uic!("projectPanel.movePageDown", "Move Selection Page Down", [], None),
uic!("projectPanel.extendUp", "Extend Selection Up", [], None),
uic!("projectPanel.extendDown", "Extend Selection Down", [], None),
uic!("projectPanel.extendLeft", "Extend Selection Left", [], None),
uic!("projectPanel.extendRight", "Extend Selection Right", [], None),
uic!("projectPanel.markIn", "Mark In (Hover Scrub)", [], None),
uic!("projectPanel.markOut", "Mark Out (Hover Scrub)", [], None),
uic!("projectPanel.rename", "Rename", [], None),
uic!("projectPanel.openBin", "Open Bin", [], None),
uic!("projectPanel.up", "Up One Level", [], None),
uic!("projectPanel.closeBinTab", "Close Bin", [], None),
uic!("projectPanel.metadataDisplay", "Metadata Display…", [], None),
uic!("projectPanel.saveViewPresetAs", "Save As New View Preset", [], None),
uic!("projectPanel.manageViewPresets", "Manage Saved View Presets", [], None),
uic!("projectPanel.freeformOptions", "Freeform View Options…", [], None),
uic!("projectPanel.saveArrangement", "Save Arrangement…", [], None),
uic!("projectPanel.revealProject", "Reveal Project in Finder…", [], None),
uic!("projectPanel.newPanel", "New Project Panel", ["Window"], None),
uic!("textPanel.prevWord", "Navigate to Previous Word", [], None),
uic!("textPanel.nextWord", "Navigate to Next Word", [], None),
uic!("textPanel.selectPrevWord", "Select to Previous Word", [], None),
uic!("textPanel.selectNextWord", "Select to Next Word", [], None),
uic!("textPanel.prevLine", "Navigate to Previous Line", [], None),
uic!("textPanel.nextLine", "Navigate to Next Line", [], None),
uic!("textPanel.selectPrevLine", "Select to Previous Line", [], None),
uic!("textPanel.selectNextLine", "Select to Next Line", [], None),
uic!("textPanel.segmentStart", "Navigate to Start of Segment", [], None),
uic!("textPanel.segmentEnd", "Navigate to End of Segment", [], None),
uic!("textPanel.selectToSegmentStart", "Select to Segment Start", [], None),
uic!("textPanel.selectToSegmentEnd", "Select to Segment End", [], None),
uic!("textPanel.delete", "Delete", [], None),
uic!("textPanel.rippleDelete", "Ripple Delete", [], None),
uic!("textPanel.showProgramTranscript", "Show Program Transcript", [], None),
uic!("mixer.showHideTracks", "Show/Hide Tracks…", [], None),
uic!("mixer.meterInputOnly", "Meter Input(s) Only", [], None),
uic!("graphics.beginTextEditing", "Begin Text Editing for a Graphic Layer", [], Some("Cmd+Alt+'")),
uic!("help.filmcraftHelp", "FilmCraft Help…", ["Help"], Some("F1")),
uic!("app.quit", "Quit FilmCraft", [], Some("Cmd+Q")),
];
/// FilmCraft's documentation (Help ▸ FilmCraft Help…, F1).
pub const HELP_URL: &str = "https://github.com/storytold/filmcraft/tree/main/docs";
const HEIGHT_STEP: f32 = 12.0;
const MIN_TRACK_H: f32 = 24.0;
const MAX_TRACK_H: f32 = 240.0;
/// Run a keyboard UI command; None when `id` is not one of them.
pub fn route(app: &mut FilmcraftApp, ctx: &egui::Context, id: &str, params: &Value) -> Option<Result<Value, String>> {
if !COMMANDS.iter().any(|c| c.id == id) {
return None;
}
let r = match id {
"window.maximizeFrame" => Ok(toggle_maximize(app, app.ui.focused)),
"window.maximizeFrameUnderCursor" => {
let p =
params.get("panel").and_then(Value::as_str).and_then(PanelKind::from_name).or_else(|| panel_under_pointer(app, ctx)).unwrap_or(app.ui.focused);
Ok(toggle_maximize(app, p))
}
"window.toggleFullScreen" => {
let fs = !ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(fs));
Ok(json!({"fullScreen": fs}))
}
"view.fullScreenProgram" => {
let entering = !app.ui.fullscreen_program;
if entering {
app.ui.cinema_was_fullscreen = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
app.ui.cinema_prev_focus = Some(app.ui.focused);
app.ui.focused = PanelKind::Program;
ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(true));
} else {
let restore = app.ui.cinema_was_fullscreen;
if let Some(prev) = app.ui.cinema_prev_focus.take() {
app.ui.focused = prev;
}
ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(restore));
}
app.ui.fullscreen_program = entering;
Ok(json!({"fullScreenProgram": entering}))
}
"window.nextPanel" | "window.prevPanel" => Ok(cycle_panel(app, id == "window.nextPanel")),
"window.toggleMonitorFocus" => {
let p = if app.ui.focused == PanelKind::Program { PanelKind::Source } else { PanelKind::Program };
app.show_panel(p);
Ok(json!({"focused": p.title()}))
}
"window.openSearch" => {
app.show_panel(PanelKind::Project);
Ok(focus_find_box(app, ctx))
}
"panel.selectFindBox" => Ok(focus_find_box(app, ctx)),
"window.workspace.learning" | "window.workspace.review" => {
let name = if id.ends_with("learning") { "Learning" } else { "Review" };
app.set_workspace(name);
Ok(json!({"workspace": name}))
}
"view.programZoom100" | "view.programZoomFit" | "view.sourceZoom100" | "view.sourceZoomFit" => {
let v = if id.starts_with("view.program") { &mut app.ui.program } else { &mut app.ui.source };
v.zoom = id.ends_with("100").then_some(1.0);
v.pan = [0.0, 0.0];
Ok(json!({"zoom": v.zoom}))
}
"playback.inToOutPreroll" => {
if crate::menus::targets_source(app, params) {
app.play_source_range(false, true).map(|_| Value::Null)
} else {
play_range(app, true)
}
}
"playback.toOut" => {
if crate::menus::targets_source(app, params) {
app.play_source_range(true, false).map(|_| Value::Null)
} else {
play_range(app, false)
}
}
"timeline.expandAllTracks" | "timeline.minimizeAllTracks" => Ok(all_heights(app, id == "timeline.expandAllTracks")),
"timeline.increaseVideoHeight" | "timeline.decreaseVideoHeight" | "timeline.increaseAudioHeight" | "timeline.decreaseAudioHeight" => {
let d = if id.contains("increase") { HEIGHT_STEP } else { -HEIGHT_STEP };
let tv = &mut app.ui.timeline;
let h = if id.contains("Video") { &mut tv.video_track_h } else { &mut tv.audio_track_h };
*h = (*h + d).clamp(MIN_TRACK_H, MAX_TRACK_H);
Ok(json!({"videoTrackHeight": tv.video_track_h, "audioTrackHeight": tv.audio_track_h}))
}
"timeline.nextScreen" | "timeline.prevScreen" => {
let tv = &mut app.ui.timeline;
let w = (app.last_timeline_width.max(200.0) - tv.header_w) as f64;
let page = w / tv.pps.max(1e-6);
let d = if id == "timeline.nextScreen" { page } else { -page };
tv.target_scroll = (tv.target_scroll + d).max(0.0);
Ok(json!({"scroll": tv.target_scroll}))
}
"mixer.showHideTracks" => Ok(crate::panels::mixer::open_show_hide_tracks(app, ctx)),
"mixer.meterInputOnly" => crate::panels::mixer::set_meter_input_only(app, params),
"graphics.beginTextEditing" => begin_text_editing(app),
"help.filmcraftHelp" => {
crate::links::open(app, ctx, HELP_URL);
Ok(json!({"url": HELP_URL}))
}
"app.quit" => {
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
Ok(Value::Null)
}
_ if id.starts_with("projectPanel.") => match crate::panels::project::route(app, ctx, &id["projectPanel.".len()..], params) {
Some(r) => r,
None => project_panel(app, &id["projectPanel.".len()..]),
},
_ if id.starts_with("textPanel.") => text_panel(app, &id["textPanel.".len()..]),
_ => return None,
};
if let Err(e) = &r {
app.ui.status = e.clone();
}
Some(r)
}
// ------------------------------------------------------------------ frames and panels
/// Maximize `p`, or restore the layout when a panel is maximized (also the panel menu's Maximize /
/// Restore Frame). Only a docked panel maximizes; a maximized panel that has since been closed or
/// floated counts as restored.
pub(crate) fn toggle_maximize(app: &mut FilmcraftApp, p: PanelKind) -> Value {
use crate::dock::LayoutExt as _;
let current = app.ui.keys.maximized.filter(|q| app.ui.dock.is_docked(*q));
app.ui.keys.maximized = if current.is_some() || !app.ui.dock.is_docked(p) { None } else { Some(p) };
if let Some(p) = app.ui.keys.maximized {
let _ = app.apply_dock(craft_ui::docking::Action::Activate { panel: p });
app.ui.focused = p;
}
json!({"maximized": app.ui.keys.maximized.map(|p| p.title())})
}
/// The visible panel under the pointer (from last frame's automation rects). Each native
/// floating window has its own coordinates, so only rects of the window holding the pointer
/// count.
fn panel_under_pointer(app: &FilmcraftApp, ctx: &egui::Context) -> Option<PanelKind> {
let panels = app.auto.query("panel.");
let pointer = |viewport| ctx.input_for(viewport, |i| i.pointer.latest_pos()).map(|pos| (viewport, pos));
let (viewport, pos) =
pointer(egui::ViewportId::ROOT).or_else(|| panels.iter().map(|e| e.viewport).filter(|v| *v != egui::ViewportId::ROOT).find_map(pointer))?;
panels.into_iter().rev().filter(|e| e.viewport == viewport).find_map(|e| {
let r = egui::Rect::from_min_size(egui::pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3]));
r.contains(pos).then(|| PanelKind::from_name(&e.id["panel.".len()..])).flatten()
})
}
/// Visible panels in layout order (the active tab of each frame), without the narrow Tools and
/// Audio Meters strips, which panel cycling skips.
fn visible_panels(app: &FilmcraftApp) -> Vec<PanelKind> {
use crate::dock::LayoutExt as _;
let mut v = app.ui.dock.visible_panels();
v.retain(|p| !matches!(p, PanelKind::Tools | PanelKind::AudioMeters));
v
}
fn cycle_panel(app: &mut FilmcraftApp, next: bool) -> Value {
let v = visible_panels(app);
if v.is_empty() {
return Value::Null;
}
let i = v.iter().position(|p| *p == app.ui.focused).unwrap_or(0);
let j = if next { (i + 1) % v.len() } else { (i + v.len() - 1) % v.len() };
app.ui.focused = v[j];
json!({"focused": v[j].title()})
}
/// Ask the focused panel's search field for keyboard focus (`widgets::search_field` takes it).
fn focus_find_box(app: &mut FilmcraftApp, ctx: &egui::Context) -> Value {
let p = app.ui.focused;
let rect =
app.auto.find(&format!("panel.{}", p.id())).map(|e| egui::Rect::from_min_size(egui::pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3])));
ctx.data_mut(|d| d.insert_temp(egui::Id::unique(FOCUS_SEARCH), rect.unwrap_or(egui::Rect::EVERYTHING)));
json!({"panel": p.title()})
}
/// egui temp-data key: the panel rect whose search field should take focus.
pub const FOCUS_SEARCH: &str = "fc-focus-search";
/// Called by search fields: take focus when Select Find Box targets the panel they sit in.
pub fn take_search_focus(ui: &egui::Ui, field: egui::Rect, resp: &egui::Response) {
let id = egui::Id::unique(FOCUS_SEARCH);
let Some(panel) = ui.ctx().data(|d| d.get_temp::<egui::Rect>(id)) else { return };
if panel.contains(field.center()) {
resp.request_focus();
ui.ctx().data_mut(|d| d.remove::<egui::Rect>(id));
}
}
// ------------------------------------------------------------------ playback and timeline
fn play_range(app: &mut FilmcraftApp, preroll: bool) -> Result<Value, String> {
let seq = app.session.active_sequence().ok_or("no sequence is open")?;
let fd = seq.settings.frame_rate.frame_duration();
let end = seq.mark_out.map(|o| o + fd).unwrap_or(seq.duration());
let start = if preroll {
let i = seq.mark_in.unwrap_or(filmcraft_time::Tick::ZERO);
let pre = filmcraft_time::Tick::from_seconds_f64(app.session.prefs.playback.preroll_seconds);
(i - pre).max(filmcraft_time::Tick::ZERO)
} else {
app.session.playhead()
};
let stop = if preroll { end + filmcraft_time::Tick::from_seconds_f64(app.session.prefs.playback.postroll_seconds) } else { end };
// Plain marked playback includes Out but stops after its frame. Extended
// preroll/postroll playback retains its existing boundary behavior.
let rest_at = if preroll { None } else { Some(seq.mark_out.unwrap_or((end - fd).max(filmcraft_time::Tick::ZERO))) };
app.session.set_playhead(start);
app.play(1.0);
app.playback.stop_at = Some(stop);
app.playback.rest_at = rest_at;
Ok(json!({"from": start.0, "to": stop.0}))
}
fn all_heights(app: &mut FilmcraftApp, expand: bool) -> Value {
let tv = &mut app.ui.timeline;
let target = if expand { 120.0 } else { MIN_TRACK_H };
let at_target = tv.video_track_h == target && tv.audio_track_h == target;
match (at_target, app.ui.keys.saved_heights) {
// pressing again restores the heights from before
(true, Some([v, a])) => {
tv.video_track_h = v;
tv.audio_track_h = a;
app.ui.keys.saved_heights = None;
}
_ => {
app.ui.keys.saved_heights = Some([tv.video_track_h, tv.audio_track_h]);
tv.video_track_h = target;
tv.audio_track_h = target;
}
}
json!({"videoTrackHeight": tv.video_track_h, "audioTrackHeight": tv.audio_track_h})
}
fn begin_text_editing(app: &mut FilmcraftApp) -> Result<Value, String> {
let list = app.session.execute("graphics.list", json!({})).map_err(|e| e.to_string())?;
let layers = list["layers"].as_array().cloned().unwrap_or_default();
let is_text = |l: &Value| l["kind"] == json!("text");
let pick = app
.session
.state
.graphic_layers
.first()
.and_then(|i| layers.iter().find(|l| l["layer"].as_u64() == Some(*i as u64) && is_text(l)))
.or_else(|| layers.iter().rev().find(|l| is_text(l)))
.ok_or("the graphic has no text layer")?;
let (clip, layer) = (list["clip"].as_u64().unwrap_or(0), pick["layer"].as_u64().unwrap_or(0) as usize);
let len = pick["text"].as_str().map_or(0, str::len);
app.session.execute("graphics.selectLayer", json!({"clip": clip, "layers": [layer]})).map_err(|e| e.to_string())?;
// like Premiere, the whole text is selected so typing replaces it
app.restart_ime_target();
app.ui.gfx_edit = Some(crate::state::GfxEdit { clip, layer, caret: len, anchor: 0, ..Default::default() });
app.show_panel(PanelKind::Program);
Ok(json!({"clip": clip, "layer": layer}))
}
// ------------------------------------------------------------------ Project panel
/// Items as the Project panel lists them (its shown tab, in display order).
fn panel_items(app: &FilmcraftApp) -> Vec<filmcraft_project::ItemId> {
crate::panels::project::visible_items(app, crate::panels::project::shown_inst(app))
}
fn project_panel(app: &mut FilmcraftApp, op: &str) -> Result<Value, String> {
match op {
"viewList" | "viewIcon" | "toggleView" => {
let inst = crate::panels::project::shown_inst(app);
let cur = crate::panels::project::view_of(app, inst).mode;
let mode = match op {
"viewList" => ViewMode::List,
"viewIcon" => ViewMode::Icon,
_ if cur == ViewMode::List => ViewMode::Icon,
_ => ViewMode::List,
};
let mut acts = Vec::new();
crate::panels::project::set_mode(app, inst, mode, &mut acts);
for (c, p) in acts {
app.session.execute(&c, p).map_err(|e| e.to_string())?;
}
return Ok(json!({"view": mode}));
}
"hoverScrub" => {
let on = !app.session.prefs.project_panel.hover_scrub;
app.session.execute("project.view.set", json!({"hoverScrub": on})).map_err(|e| e.to_string())?;
return Ok(json!({"hoverScrub": on}));
}
"thumbnailLarger" | "thumbnailSmaller" => {
let f = if op == "thumbnailLarger" { 1.25 } else { 0.8 };
let inst = crate::panels::project::shown_inst(app);
let v = crate::panels::project::view_of(app, inst);
let size = (v.icon_size * f).clamp(48.0, 400.0);
match inst {
crate::panels::project::Inst::Main => {
app.session.execute("project.view.set", json!({"iconSize": size})).map_err(|e| e.to_string())?;
}
crate::panels::project::Inst::Tab(k) => app.ui.project_panel.tabs[k].icon_size = size,
}
return Ok(json!({"iconSize": size}));
}
_ => {}
}
let items = panel_items(app);
if items.is_empty() {
return Ok(json!({"items": []}));
}
let sel = app.session.state.project_selection.clone();
let last = sel.last().and_then(|s| items.iter().position(|i| i == s));
let icon = crate::panels::project::view_of(app, crate::panels::project::shown_inst(app)).mode != ViewMode::List;
let cols = if icon { app.ui.keys.icon_columns.max(1) as i64 } else { 1 };
let page = 10i64;
let n = items.len() as i64;
let (step, extend): (Option<i64>, bool) = match op {
"moveUp" => (Some(-cols), false),
"moveDown" => (Some(cols), false),
"moveLeft" => (Some(if icon { -1 } else { 0 }), false),
"moveRight" => (Some(if icon { 1 } else { 0 }), false),
"movePageUp" => (Some(-page * cols), false),
"movePageDown" => (Some(page * cols), false),
"extendUp" => (Some(-cols), true),
"extendDown" => (Some(cols), true),
"extendLeft" => (Some(if icon { -1 } else { 0 }), true),
"extendRight" => (Some(if icon { 1 } else { 0 }), true),
"moveHome" | "moveEnd" => (None, false),
_ => return Err(format!("unknown Project panel command `{op}`")),
};
let target = match (step, last) {
(None, _) => {
if op == "moveHome" {
0
} else {
n - 1
}
}
(Some(d), Some(i)) => (i as i64 + d).clamp(0, n - 1),
(Some(d), None) => {
if d < 0 {
n - 1
} else {
0
}
}
} as usize;
let mut new_sel: Vec<filmcraft_project::ItemId> = if extend {
let anchor = sel.first().and_then(|s| items.iter().position(|i| i == s)).unwrap_or(target);
let (a, b) = (anchor.min(target), anchor.max(target));
let mut v: Vec<_> = items[a..=b].to_vec();
// keep the anchor first and the moving end last
if target < anchor {
v.reverse();
}
v
} else {
vec![items[target]]
};
new_sel.dedup();
let ids: Vec<u64> = new_sel.iter().map(|i| i.0).collect();
app.session.execute("project.select", json!({"items": ids})).map_err(|e| e.to_string())?;
Ok(json!({"items": ids}))
}
// ------------------------------------------------------------------ Text panel (transcript)
fn text_panel(app: &mut FilmcraftApp, op: &str) -> Result<Value, String> {
if op == "showProgramTranscript" {
app.show_panel(PanelKind::Text);
app.ui.text_tab = "Transcript".into();
return Ok(json!({"tab": "Transcript"}));
}
if app.ui.text_tab != "Transcript" {
// the Captions tab: Delete / Ripple Delete act on the selected captions
return match op {
"delete" => app.session.execute("edit.clear", json!({})).map_err(|e| e.to_string()),
"rippleDelete" => app.session.execute("edit.rippleDelete", json!({})).map_err(|e| e.to_string()),
_ => Ok(Value::Null),
};
}
let words = filmcraft_engine::transcript::sequence_words(&app.session);
if words.is_empty() {
return Err("the sequence has no transcript".into());
}
let n = words.len();
let paras = filmcraft_edit::transcript::paragraphs(&words, filmcraft_time::Tick::from_seconds_f64(1.5));
let para_of = |i: usize| paras.iter().position(|p| p.contains(&i)).unwrap_or(0);
// a selection left over from a longer transcript (e.g. after `transcript.extract` over the control channel) counts as none, as when drawing
let (anchor, cur) = app.ui.transcript_sel.filter(|(a, b)| *a < n && *b < n).unwrap_or_else(|| {
let i = filmcraft_edit::transcript::word_at(&words, app.session.playhead()).unwrap_or(0);
(i, i)
});
let line = |i: usize, d: i64| -> usize {
let p = para_of(i) as i64 + d;
if p < 0 { 0 } else { paras.get(p as usize).map_or(n - 1, |r| r.start) }
};
let (to, extend) = match op {
"prevWord" => (cur.saturating_sub(1), false),
"nextWord" => ((cur + 1).min(n - 1), false),
"selectPrevWord" => (cur.saturating_sub(1), true),
"selectNextWord" => ((cur + 1).min(n - 1), true),
"prevLine" => (line(cur, -1), false),
"nextLine" => (line(cur, 1), false),
"selectPrevLine" => (line(cur, -1), true),
"selectNextLine" => (line(cur, 1), true),
"segmentStart" => (paras[para_of(cur)].start, false),
"segmentEnd" => (paras[para_of(cur)].end - 1, false),
"selectToSegmentStart" => (paras[para_of(cur)].start, true),
"selectToSegmentEnd" => (paras[para_of(cur)].end - 1, true),
"delete" | "rippleDelete" => {
let Some((a, b)) = app.ui.transcript_sel else { return Err("select text in the transcript".into()) };
let cmd = if op == "delete" { "transcript.lift" } else { "transcript.extract" };
let r = app.session.execute(cmd, json!({"from": a.min(b), "to": a.max(b)})).map_err(|e| e.to_string())?;
app.ui.transcript_sel = None;
return Ok(r);
}
_ => return Err(format!("unknown Text panel command `{op}`")),
};
app.ui.transcript_sel = Some(if extend { (anchor, to) } else { (to, to) });
// the playhead follows the caret
app.session.set_playhead(words[to].start);
Ok(json!({"selection": [anchor.min(to), anchor.max(to)], "word": to}))
}
#[cfg(test)]
mod transcript_selection_tests {
use serde_json::{Value, json};
#[test]
fn prev_word_after_the_transcript_shrank_under_the_selection_does_not_panic() {
let mut session = filmcraft_engine::Session::default();
session.execute("file.openDemoProject", json!({})).unwrap();
let a = session.active_sequence().unwrap().audio_tracks[0].items[0].clone();
let tk = |s: f64| a.source_in.0 + (s * filmcraft_time::TICKS_PER_SECOND as f64) as i64;
let words: Vec<Value> = ["one", "two", "three", "four"]
.iter()
.enumerate()
.map(|(i, w)| json!({"text": w, "start": tk(0.5 + i as f64 * 0.5), "end": tk(0.9 + i as f64 * 0.5)}))
.collect();
session.execute("transcript.set", json!({"item": a.item.0, "transcript": {"language": "en", "words": words}})).unwrap();
let mut app = crate::FilmcraftApp::new(session);
app.ui.text_tab = "Transcript".into();
app.ui.transcript_sel = Some((3, 3));
// the transcript shrinks behind the panel's back, as with `transcript.extract` over the control channel
app.session.execute("transcript.extract", json!({"from": 0, "to": 1})).unwrap();
assert_eq!(filmcraft_engine::transcript::sequence_words(&app.session).len(), 2);
let r = super::text_panel(&mut app, "prevWord").unwrap();
let (sa, sb) = app.ui.transcript_sel.unwrap();
assert!(sa < 2 && sb < 2, "selection {sa}..{sb} outside the 2-word transcript");
assert_eq!(r["word"], json!(sb));
}
}
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.