Struct App

pub struct App {

    project: Project,
    project_path: Option<PathBuf>,
    dirty: bool,
    undo: Vec<String>,
    redo: Vec<String>,
    settings: Settings,
    hotkeys: Hotkeys,
    text: Arc<Mutex<TextRasterizer>>,
    fonts: Vec<String>,
    player: Player,
    waveforms: WaveformCache,
    thumbs: ThumbCache,
    layout: Layout,
    layout_json: String,
    layout_dirty: bool,
    timeline: TimelineState,
    preview: PreviewState,
    library: LibraryState,
    settings_ui: SettingsUi,
    transitions_ui: TransitionsState,
    curves: CurvesState,
    subtitles_ui: SubtitlesState,
    planner: PlannerState,
    presets: PresetsState,
    autocut: AutoCutState,
    tracking: TrackState,
    retime: RetimeUi,
    export_ui: ExportUi,
    template_name: Option<String>,
    profile_name: Option<String>,
    fullscreen: bool,
    selection: Vec<u64>,
    sel_transitions: Vec<u64>,
    playhead: f64,
    export: Option<(Arc<Progress>, ExportKind)>,
    encoders: Vec<String>,
    toasts: Vec<(String, Instant)>,
    screenshot: Option<PathBuf>,
    started: Instant,
    window_shown: bool,
    first_frame_at: Option<Instant>,
    screenshot_requested: bool,
    close_confirmed: bool,
    close_after_export: bool,
    was_playing: bool,
    last_title: String,
    palette: Palette,
    pending_frame: Option<Arc<Frame>>,
    pending_actions: Vec<Action>,
    mcp: Option<(Server, Receiver<ToolCall>)>,
    mcp_port_running: u16,
    mcp_jobs: Vec<McpJob>,
    convert_jobs: Vec<(Arc<Progress>, PathBuf)>,
    convert_dialog: Option<(u64, String)>,
    compress: Option<Compress>,
    ytdlp_available: Arc<AtomicBool>,
    url_dialog: Option<(String, bool)>,
    downloads: Vec<Download>,
    probes: Vec<Receiver<Probed>>,
    autocut_shown: bool,
    autocut_drawing: bool,
    tracking_shown: bool,
    tracking_drawing: bool,
    loaded_fonts: usize,
    gl: Option<Arc<Context>>,
    gpu_name: String,
    gpu: Option<GpuRenderer>,
    gpu_export: (Sender<GpuFrameRequest>, Receiver<GpuFrameRequest>),
    gpu_tex: Option<(TextureId, [u32; 2])>,
    gpu_tex_ids: HashMap<Texture, TextureId>,
    effect_thumbs: Vec<TextureHandle>,
    effect_thumbs_key: Option<(String, u32)>,
    gpu_failed: bool,
    gpu_prev: Option<Arc<Frame>>,
    tools: ToolsState,
    nodes: NodesState,
    mixer: MixerState,
    markers: MarkersState,
    buses: BusGraph,
    capture_ui: CaptureUi,
    frame_ui: FrameUi,
    shader_ui: ShaderUi,
    import_ui: ImportUi,
    paste_ui: PasteUi,
    screen_rec: Option<(Capture, PathBuf)>,
    voice_rec: Option<(Capture, PathBuf, f64)>,
    draw_rec: Option<(u64, f64)>,
    was_focused: bool,
    attrs: Option<Clip>,
    clipboard: Option<Template>,
    os_clipboard: Option<String>,
    lib_preview: Option<LibPreview>,
    lib_preview_tex: Option<TextureHandle>,
    lib_preview_live: Option<PreviewFrame>,
    prerender: PreRender,
    movie_stall: bool,
    buffer_stall: bool,
    run_script_path: Option<PathBuf>,
    proxy_job: Option<(String, PathBuf, Arc<Progress>)>,
    proxy_map: HashMap<String, String>,
    proxy_scan_at: Option<Instant>,
    canvas: (u32, u32),
    audio_inputs: Option<Vec<(String, bool)>>,
    failed_panes: Vec<Pane>,
}

Fields

project: Project

project_path: Option<PathBuf>

dirty: bool

undo: Vec<String>

redo: Vec<String>

settings: Settings

hotkeys: Hotkeys

text: Arc<Mutex<TextRasterizer>>

fonts: Vec<String>

player: Player

waveforms: WaveformCache

thumbs: ThumbCache

layout: Layout

layout_json: String

Last layout JSON written to settings (persist only on change, debounced to gesture end).

layout_dirty: bool

timeline: TimelineState

preview: PreviewState

library: LibraryState

settings_ui: SettingsUi

transitions_ui: TransitionsState

curves: CurvesState

subtitles_ui: SubtitlesState

planner: PlannerState

presets: PresetsState

autocut: AutoCutState

tracking: TrackState

retime: RetimeUi

export_ui: ExportUi

template_name: Option<String>

Some = the “Save Template” / “Save Profile” name windows are open (the String is the name field).

profile_name: Option<String>

fullscreen: bool

selection: Vec<u64>

sel_transitions: Vec<u64>

Selected transitions (timeline bands) — separate from the clip selection.

playhead: f64

export: Option<(Arc<Progress>, ExportKind)>

encoders: Vec<String>

toasts: Vec<(String, Instant)>

screenshot: Option<PathBuf>

started: Instant

window_shown: bool

Window starts hidden (see main.rs); shown once the first frame has been painted.

first_frame_at: Option<Instant>

screenshot_requested: bool

close_confirmed: bool

close_after_export: bool

Close was requested during an export: cancel it, then re-request the close once it has finished.

was_playing: bool

last_title: String

Last title sent to the OS — send_viewport_cmd forces a repaint, so only send on change.

palette: Palette

pending_frame: Option<Arc<Frame>>

Newest rendered frame, handed to the preview pane when it draws.

pending_actions: Vec<Action>

Actions requested by panels this frame (transport, context menus, breadcrumb).

mcp: Option<(Server, Receiver<ToolCall>)>

mcp_port_running: u16

mcp_jobs: Vec<McpJob>

convert_jobs: Vec<(Arc<Progress>, PathBuf)>

Library “Convert To…” jobs: (progress, output path) — polled each frame, imported when done.

convert_dialog: Option<(u64, String)>

Asset id + target extension for the Convert To… options window.

compress: Option<Compress>

Compress… window state (None = closed).

ytdlp_available: Arc<AtomicBool>

A working yt-dlp was found — gates the Library’s URL import. Detected on a background thread (it spawns yt-dlp --version) at start-up and again when the setting changes.

url_dialog: Option<(String, bool)>

Import-URL window state: (url, audio only).

downloads: Vec<Download>

Running URL downloads — polled each frame, imported into the library when they finish.

probes: Vec<Receiver<Probed>>

One receiver per import batch: ffprobe runs on a worker, poll_probes adopts the results.

autocut_shown: bool

Was the Auto-cut pane drawn last frame? (its keep-range shading is only valid while it is open). autocut_drawing accumulates this frame; the timeline reads autocut_shown so the shading does not depend on which pane the tile tree draws first.

autocut_drawing: bool

tracking_shown: bool

Same trick for the Tracking pane: the preview only draws its box while the pane is on screen.

tracking_drawing: bool

loaded_fonts: usize

Fonts already handed to the rasterizer (so we only reload when the list grows).

gl: Option<Arc<Context>>

The eframe glow context (None when eframe runs without one) and the renderer it reports.

gpu_name: String

gpu: Option<GpuRenderer>

GPU renderer, built lazily from gl while settings.gpu is on; None = CPU compositor.

gpu_export: (Sender<GpuFrameRequest>, Receiver<GpuFrameRequest>)

Effect catalogue thumbnails: the egui textures (kept alive while the panel shows them) and the key set they were built from, so they are re-rendered only when the stock image or size changes. GPU frame requests from export threads and movie-mode prerender workers (they decode; we composite on the GL context) — shared, since both are served identically.

gpu_tex: Option<(TextureId, [u32; 2])>

The GPU canvas the preview paints (zero-copy): id + pixel size. Stays valid until the next GPU render, which is also when it is replaced.

gpu_tex_ids: HashMap<Texture, TextureId>

glow texture -> egui id. The renderer’s pool reuses a handful of textures, so registering each one once keeps eframe’s texture map small (registering per frame would grow it forever).

effect_thumbs: Vec<TextureHandle>

effect_thumbs_key: Option<(String, u32)>

gpu_failed: bool

The GPU path failed once — do not retry until the setting is switched off and on again.

gpu_prev: Option<Arc<Frame>>

The frame the GPU rendered last: its buffer is reused once the preview released it.

tools: ToolsState

nodes: NodesState

mixer: MixerState

markers: MarkersState

buses: BusGraph

capture_ui: CaptureUi

frame_ui: FrameUi

shader_ui: ShaderUi

import_ui: ImportUi

paste_ui: PasteUi

screen_rec: Option<(Capture, PathBuf)>

Running screen recording / voiceover (voiceover remembers the timeline time it started at).

voice_rec: Option<(Capture, PathBuf, f64)>

draw_rec: Option<(u64, f64)>

Running Draw take: the drawing every stroke joins, and the timeline time it started at.

was_focused: bool

Viewport focus last frame (record-on-blur watches this).

attrs: Option<Clip>

Ctrl+Alt+C clipboard for Paste Attributes.

clipboard: Option<Template>

Ctrl+C / Ctrl+X clip clipboard — a template (clips + the assets they use), so paste reuses Project::place_clips and its fresh clip / link ids.

os_clipboard: Option<String>

Text to hand the OS clipboard at the end of the frame. egui-winit only emits Event::Paste when the system clipboard holds text (egui-winit-0.33.3 src/lib.rs:823 returns without pushing the key event either way), so a Ctrl+V after an internal-only copy produced NO event at all and could never be bound. Copying clips therefore also writes them out as text.

lib_preview: Option<LibPreview>

The library’s own preview: a player of its own so it never disturbs the program monitor or the timeline playhead, and the texture the pane paints this frame. While it is Some, the Preview pane shows this instead of the timeline (see draw_lib_preview).

lib_preview_tex: Option<TextureHandle>

lib_preview_live: Option<PreviewFrame>

This update’s uploaded frame, computed once (Player::take_frame consumes the buffered frame, so pulling it twice in one update would starve whichever call came second). Both the library pane’s own preview box and the viewport override read this same value.

prerender: PreRender

Movie mode pre-render cache.

movie_stall: bool

Movie mode paused the clock because the frame under the playhead was not rendered yet.

buffer_stall: bool

True while playback is held because the player reported buffering (spinner shown).

run_script_path: Option<PathBuf>

A script picked from the Scripts menu, run on the next update (outside menu layout).

proxy_job: Option<(String, PathBuf, Arc<Progress>)>

Proxy build in flight: (source path, proxy file, job). One transcode at a time.

proxy_map: HashMap<String, String>

source path -> proxy file, as last pushed to the player.

proxy_scan_at: Option<Instant>

Next time the asset list is rescanned for missing proxies.

canvas: (u32, u32)

Preview canvas size in px, as the pane last reported it (the GPU renders at this size).

audio_inputs: Option<Vec<(String, bool)>>

dshow audio inputs, listed once when the Settings / capture windows first need them.

failed_panes: Vec<Pane>

Panes whose draw panicked: shown as a message instead of taking the whole editor down.

Implementations

impl App

pub fn new( cc: &CreationContext<'_>, open: Option<PathBuf>, screenshot: Option<PathBuf>, ) -> Self

fn toast(&mut self, msg: impl Into<String>)

fn push_undo(&mut self)

fn insert_at(&mut self, ids: Vec<u64>, t: f64, vt: Option<usize>)

Insert each asset’s clips at t (video on vt if given), chaining them end to end.

fn open_or_import(&mut self, paths: &[PathBuf]) -> Vec<u64>

Empty project + one media file: open it as the project (returns empty); otherwise import into the library. ponytail: that single file is still probed on this thread — it settles the project format, size and zoom before anything is drawn; give it a placeholder too if opening ever feels slow.

fn after_edit(&mut self)

After any project mutation.

fn set_project(&mut self, project: Project, path: Option<PathBuf>)

fn title(&self) -> String

fn seek(&mut self, t: f64)

fn backend(&self) -> Backend

fn timeline_is_empty(&self) -> bool

fn export_project(&self) -> Project

The project with any open sequence closed — exports always render the MAIN timeline.

fn open_path(&mut self, path: &Path)

fn open_media(&mut self, path: &Path)

fn open_project(&mut self, path: &Path)

fn import_files(&mut self, paths: &[PathBuf]) -> Vec<u64>

Import media files into the library. Probing spawns ffprobe per file (~100 ms), so each path lands as a placeholder asset now and poll_probes folds in the real metadata a few frames later — dropping ten files costs this thread nothing. Returns the asset ids. ponytail: an MCP media.import reply therefore quotes duration 0 until the probe lands; blocking the tool call on it is the fix if an agent ever needs the number in the same reply.

fn poll_probes(&mut self, ctx: &Context)

Import probes that finished on their worker: fill the placeholder in, drop it if the file turned out to be unreadable, and re-place any clip that was laid down from the placeholder.

fn media_dialog() -> FileDialog

fn act_open_file(&mut self)

fn act_open_project(&mut self)

fn act_import(&mut self)

fn replace_container_dialog(&mut self, clip_id: u64, pair: bool)

fn save_project_as(&mut self) -> bool

fn save_project(&mut self) -> bool

fn open_subtitle_folder(&mut self)

“Open folder” in the subtitles panel: write the current cues as an .srt sidecar into <project dir>\<name> subtitles\ and open that folder in Explorer.

fn act_save(&mut self)

Ctrl+S: project file if there is one; otherwise overwrite the opened video; otherwise Save As.

fn confirm_discard(&mut self) -> bool

Ask to save unsaved changes. Returns false if the user cancelled.

fn ffmpeg_missing(&mut self) -> bool

fn export_opts(&self, out_path: PathBuf) -> ExportOptions

fn detect_encoders_once(&mut self)

fn act_export(&mut self)

Open the (non-blocking) Export window.

fn start_export_choice(&mut self, choice: ExportChoice)

The Export window confirmed: start the export (options include the chosen output path).

fn act_export_lossless(&mut self)

fn act_export_xml(&mut self)

fn act_export_style(&mut self)

fn act_overwrite(&mut self)

Re-encode the timeline over the opened video file (temp file in the same folder, then replace).

fn finish_export(&mut self)

fn act(&mut self, a: Action)

fn toggle_pane(&mut self, p: Pane)

fn draw_pane(&mut self, ui: &mut Ui, pane: Pane)

Draw one pane, containing a panic in its widget so the rest of the editor keeps working (same policy as the decoder threads). A pane that panicked once is not drawn again this session.

fn draw_pane_inner(&mut self, ui: &mut Ui, pane: Pane)

fn refresh_presets(&self)

Place a saved template (by name) on the timeline at t. Hand the saved curve/motion presets (built-ins first) to the curve editor. Called on start and whenever the lists change — never per frame.

fn add_shape( &mut self, kind: ShapeKind, place: Option<(f32, f32, f32, f32)>, ) -> u64

Add a shape clip at the playhead, styled from the tool strip. place = (centre x, centre y, half width, half height) in project px when the shape was dragged out in the viewport (Action::AddShape passes None and keeps the default size). For ShapeKind::Draw the playhead/5s here are only a placeholder — add_stroke / toggle_draw_recording re-pin start and duration to the strokes actually recorded once there is ink to measure.

fn toggle_draw_recording(&mut self, on: bool)

The Draw tool’s play/record button: the video plays and every stroke joins one drawing until the take is stopped (button, video stopped, or the tool put away). A voiceover running at the same time owns the transport, so it is left playing and its take is not cut short.

fn add_stroke(&mut self, stroke: Stroke)

A stroke drawn in the viewport: append it to the take (or the selected drawing), or start a new one.

fn poll_panels(&mut self)

Per-frame hand-offs from panels that can’t reach Settings, plus background convert jobs.

fn enter_sequence(&mut self, id: u64)

Open a nested timeline for editing (keeps the player/preview in sync).

fn sequence_view_changed(&mut self, t: f64)

Navigating in/out of a nested sequence is a view change, not an edit: re-sync the player, but no undo step and no dirty flag (that made “just looking” prompt to save on exit).

fn url_window(&mut self, ctx: &Context)

Import URL window (non-blocking): paste a link, pick a folder, download with yt-dlp, and the finished file is imported into the library like any other media.

fn download_dir(&self) -> PathBuf

Configured download folder, or the user’s Videos folder.

fn detect_ytdlp(&self, ctx: &Context)

Look for a working yt-dlp on a background thread (it spawns yt-dlp --version, and a candidate that hangs must not hang the editor); the Library button appears once it reports success.

fn start_download(&mut self, url: &str, audio_only: bool)

fn start_asset_convert(&mut self, asset: u64, ext: &str)

“Convert To…” on a library asset: transcode next to the source, then import the result.

fn save_preset(&mut self, name: &str)

“Save from selection” in the Presets pane: one clip’s node graph or effect stack becomes an effect preset, anything else (adjustment layers, several clips) becomes a clip template — that is the only flavour that can be placed rather than applied.

fn apply_effect_preset(&mut self, i: usize)

Apply a saved effect chain / node graph to every selected clip (one undo entry).

fn place_template(&mut self, name: &str, t: f64)

fn sync_gpu(&mut self)

Build / drop the GPU renderer to match settings.gpu, and tell the player which kind of output the UI wants (decoded layers for the GPU, a composited frame for the CPU compositor).

fn build_effect_thumbnails(&mut self, ctx: &Context)

Render one catalogue thumbnail per EffectKind over the stock image and hand them to the effects panel. Runs once per (stock image, size) — the GPU renderer owns the GL context, so this happens on the UI thread. Without a GPU the panel keeps its neutral named cards.

fn export_frames(&self) -> FrameSource

Where a new export should get its pictures: the GPU renderer when it is running (so the file matches the preview), otherwise the export thread’s own CPU compositor.

fn serve_gpu_exports(&mut self) -> bool

Serve the frames export threads and movie-mode prerender workers are waiting on. Called every frame; each request is answered on the GL context, so both run the same shaders as the preview. Returns true if any were served (the caller keeps repainting so a background export is never starved; prerender already repaints on its own while busy).

fn gpu_off(&mut self, why: &str)

Fall back to the CPU compositor and say why, once.

fn gpu_preview_texture( &mut self, layers: &LayerSet, t: f64, w: u32, h: u32, frame: &mut Frame, ) -> Option<(TextureId, [u32; 2])>

Render the timeline into a GL texture and register it with egui, so the preview paints the GPU’s own canvas — no glReadPixels, no re-upload. None when there is no GPU (the caller falls back to gpu_frame). The texture is only valid for this frame, which is exactly how long it is painted.

fn gpu_frame( &mut self, layers: &LayerSet, t: f64, w: u32, h: u32, ) -> Option<Arc<Frame>>

Render decoded layers with the GPU into a frame the preview can upload. None = the GPU path died (already switched off).

fn render_frame_now(&mut self, t: f64, w: u32) -> Option<Arc<Frame>>

One frame at t, w px wide, through the same path the preview uses (GPU when it is on, the player’s compositor otherwise) — export-frame and the MCP tools.

fn request_prerender(&mut self)

Movie mode: ask for the in/out range, or the whole timeline when there is none.

fn export_frame(&mut self, opts: FrameExport)

“Export Frame…” confirmed: render at the chosen size and write the image with ffmpeg.

fn source_frame(&mut self, t: f64, w: u32, h: u32) -> Option<Arc<Frame>>

The decoded frame of the top-most visual clip under the playhead (“source frame only”).

fn act_import_timeline(&mut self)

Import a timeline from another editor (FCP7 XML / EDL / .prproj) and show the report.

fn start_screen_capture(&mut self, opts: ScreenCaptureOptions)

Start / stop the screen recorder with the options the window built (also driven by focus when capture_on_blur is on, which rebuilds them from settings + the window’s region).

fn stop_screen_capture(&mut self)

fn start_voiceover(&mut self, opts: VoiceoverOptions)

fn stop_voiceover(&mut self)

fn import_recording(&mut self, out: PathBuf, at: Option<f64>)

A finished recording: import it and (for a voiceover) drop it on the timeline at at.

fn audio_inputs(&mut self) -> Vec<(String, bool)>

dshow audio inputs, asked for once (the ffmpeg device probe takes ~a second).

fn blur_capture_options(&self) -> ScreenCaptureOptions

Screen-capture options for the record-on-blur path, which has no window response to take them from. Same folder the Screen Recording window shows (capture_ui::capture_dir).

fn glyph_for(&self, a: Action) -> Option<Glyph>

Icon shown next to a menu action: the user’s pick from Settings → Appearance → Icons wins, then the built-in defaults below. Abstract actions stay text-only.

fn menu_item( &mut self, ui: &mut Ui, a: Action, enabled: bool, out: &mut Vec<Action>, )

fn pane_glyph(&self, p: Pane) -> Option<Glyph>

Icon shown next to a pane (View menu, icon picker), with the user’s Settings override first.

fn view_menu(&mut self, ui: &mut Ui, out: &mut Vec<Action>)

fn menu_bar(&mut self, ui: &mut Ui) -> Vec<Action>

fn handle_drops(&mut self, ctx: &Context)

fn compress_window(&mut self, ctx: &Context)

Compress… — re-encode one file smaller, either by quality (CRF) or to a size target, writing a copy or replacing the original.

fn start_compress(&mut self, c: &Compress)

fn start_lib_preview(&mut self, ctx: &Context, path: PathBuf)

Point the library’s preview player at path and roll it. A file already playing is left alone, so re-clicking the selected row does not restart it. Pauses the timeline: previewing a source and the program monitor should not both be making sound at once.

fn lib_preview_frame(&mut self, ctx: &Context) -> Option<PreviewFrame>

The library preview’s current frame, uploaded for the pane to paint. None = nothing is previewing. Called exactly once per update (see self.lib_preview_live) - Player::take_frame consumes the buffered frame, so a second call in the same frame would come back empty.

fn draw_lib_preview(&mut self, ui: &mut Ui)

The Preview pane while a library asset is being previewed: the timeline’s player and project are left untouched underneath (still decoding in the background, so resuming is instant), and this draws the previewed file’s own frame with a transport bound to its own Player instead.

fn screenshot_tick(&mut self, ctx: &Context)

fn sync_proxies(&mut self)

Proxy media: keep an all-intra low-res proxy built for every video asset and hand the map to the player. Rescans every 2 s (a handful of stat calls); one ffmpeg transcode at a time. ponytail: no per-asset badge yet — the preview shows one aggregate “Building proxy” line.

fn run_script(&mut self, path: &Path)

Run one Luau script against the live project. The whole run is a single undo step; a tool that fails mid-script rolls its own mutation back (same policy as MCP) and stops the script.

fn sync_mcp(&mut self, ctx: &Context)

Start/stop/restart the MCP server to match the settings; runs every frame (cheap when in sync).

fn poll_mcp(&mut self, ctx: &Context)

fn handle_tool(&mut self, call: ToolCall)

fn start_tool_job( &mut self, name: &str, args: &Value, ) -> Result<(Arc<Progress>, PathBuf), String>

fn run_tool(&mut self, name: &str, args: &Value) -> Result<Value, String>

Execute one (non-job) MCP tool by name. The caller handles undo/after_edit for mutating tools.

fn name_window( ctx: &Context, title: &str, field: &mut Option<String>, ) -> Option<String>

A small egui::Window asking for a name. Returns Some(name) once confirmed.

fn windows(&mut self, ctx: &Context)

Trait Implementations

impl App for App

fn update(&mut self, ctx: &Context, _frame: &mut Frame)

Called each time the UI needs repainting, which may be many times per second.

fn save(&mut self, _storage: &mut dyn Storage)

Called on shutdown, and perhaps at regular intervals. Allows you to save state.

fn on_exit(&mut self, _gl: Option<&Context>)

Called once on shutdown, after [Self::save].

fn auto_save_interval(&self) -> Duration

Time between automatic calls to [Self::save]

fn clear_color(&self, _visuals: &Visuals) -> [f32; 4]

Background color values for the app, e.g. what is sent to gl.clearColor.

fn persist_egui_memory(&self) -> bool

Controls whether or not the egui memory (window positions etc) will be persisted (only if the “persistence” feature is enabled).

fn raw_input_hook(&mut self, _ctx: &Context, _raw_input: &mut RawInput)

A hook for manipulating or filtering raw input before it is processed by [Self::update].