Struct Project

pub struct Project {

    pub version: u32,
    pub name: String,
    pub width: u32,
    pub height: u32,
    pub fps: f64,
    pub assets: Vec<Asset>,
    pub folders: Vec<String>,
    pub linked_folders: Vec<String>,
    pub tracks: Vec<Track>,
    pub in_point: Option<f64>,
    pub out_point: Option<f64>,
    pub source_video: Option<String>,
    pub subtitles: Vec<Cue>,
    pub subtitle_style: TextStyle,
    pub subtitle_margin: f32,
    pub show_subtitles: bool,
    pub subtitle_cont_prefix: String,
    pub subtitle_cont_suffix: String,
    pub scaler: Scaler,
    pub labels: Vec<Label>,
    pub markers: Vec<Marker>,
    pub buses: Vec<Bus>,
    pub sequences: Vec<Sequence>,
    pub editing: Option<u64>,
    pub main_stash: Option<Stash>,
    pub plan: Vec<PlanItem>,
    pub notes: String,
    pub paths: Vec<PathAsset>,
    next_id: u64,
}

Fields

version: u32

name: String

width: u32

height: u32

fps: f64

assets: Vec<Asset>

folders: Vec<String>

Library folders that exist even while empty (“A/B” nesting by ‘/’).

linked_folders: Vec<String>

Folders on disk browsed directly from the library (files are imported on drop).

tracks: Vec<Track>

Order: all video tracks (V1, V2, …) then all audio tracks (A1, A2, …). While editing is Some(seq), these are that sequence’s tracks (the main timeline is in main_stash).

in_point: Option<f64>

out_point: Option<f64>

source_video: Option<String>

Set when the project was created by opening a video file directly; enables “Save” (overwrite).

subtitles: Vec<Cue>

Subtitle cues (kept sorted by start). Rendered bottom-centre by the compositor when show_subtitles.

subtitle_style: TextStyle

subtitle_margin: f32

Distance from the bottom edge in project pixels.

show_subtitles: bool

subtitle_cont_prefix: String

Prepended/appended to a generated cue where a sentence continues across the cue split (e.g. “…” / “ —“). Applied by “Regenerate cues”, not retroactively.

subtitle_cont_suffix: String

scaler: Scaler

Compositor resampling quality.

labels: Vec<Label>

Colour labels (name + colour), editable by the user.

markers: Vec<Marker>

Timeline markers (sorted by time).

buses: Vec<Bus>

Mixer buses; buses[0] is Main and always exists.

sequences: Vec<Sequence>

Nested timelines (usable as footage via ClipKind::Sequence).

editing: Option<u64>

The sequence currently swapped into tracks for editing (None = main timeline).

main_stash: Option<Stash>

plan: Vec<PlanItem>

Planner (nested tasks with moodboards) and free-form notes (process / ideas / style).

notes: String

paths: Vec<PathAsset>

Saved drawing / polygon outlines, reusable as motion paths (see PathAsset).

next_id: u64

Implementations

impl Project

pub fn new() -> Self

pub fn from_media(asset: Asset) -> Self

New project sized from a media asset, with the asset laid out at t=0 (video + one audio track per stream).

pub fn new_id(&mut self) -> u64

pub fn asset(&self, id: u64) -> Option<&Asset>

pub fn asset_mut(&mut self, id: u64) -> Option<&mut Asset>

pub fn asset_by_path(&self, path: &str) -> Option<&Asset>

pub fn add_asset(&mut self, a: Asset) -> u64

Adds an asset (de-duplicated by path) and returns its id.

pub fn remove_asset(&mut self, id: u64)

Removes an asset and every clip using it. Removes an asset and every clip using it — in the live timeline, the stashed main timeline and every nested sequence (a leftover clip would render black / silent).

pub fn folder_names(&self) -> Vec<String>

All folder names (explicit + used by assets), sorted.

pub fn add_folder(&mut self, name: &str) -> bool

Create (or ensure) a folder; returns false if the name is empty.

pub fn remove_folder(&mut self, name: &str)

Remove a folder (and sub-folders); assets inside move to the root.

pub fn duration(&self) -> f64

pub fn is_empty(&self) -> bool

pub fn frame_dur(&self) -> f64

pub fn snap_frame(&self, t: f64) -> f64

pub fn find(&self, id: u64) -> Option<(usize, usize)>

(track index, clip index) of a clip.

pub fn clip(&self, id: u64) -> Option<&Clip>

pub fn clip_mut(&mut self, id: u64) -> Option<&mut Clip>

pub fn track_of(&self, clip: u64) -> Option<usize>

pub fn all_clips(&self) -> impl Iterator<Item = (usize, &Clip)>

pub fn linked(&self, id: u64) -> Vec<u64>

All clip ids linked with id (including itself).

pub fn expand_links(&self, ids: &[u64]) -> Vec<u64>

Expand a selection to include linked clips.

pub fn video_tracks(&self) -> Vec<usize>

pub fn audio_tracks(&self) -> Vec<usize>

pub fn cut_points(&self) -> Vec<f64>

Sorted distinct clip boundaries (plus 0) for prev/next-cut navigation.

pub fn active(&self, tidx: usize) -> bool

Mute/solo resolution: a track is audible/visible if (no solo among its kind && !muted) || solo.

pub fn head_room(&self, clip: &Clip) -> f64

Source seconds available before the clip’s left edge (for Clip::trim_start).

pub fn max_clip_duration(&self, clip: &Clip) -> f64

Longest duration the clip may have (right edge), given its source window, speed and direction.

pub fn add_track(&mut self, kind: TrackKind) -> usize

Adds a track of kind (video tracks stay before audio tracks) and returns its index.

pub fn remove_track(&mut self, idx: usize)

fn rename_tracks(&mut self)

pub fn find_free_track( &mut self, kind: TrackKind, start: f64, dur: f64, prefer: Option<usize>, ) -> usize

First track of kind (preferring prefer) where [start,start+dur) is free; adds one if needed.

pub fn tidy(&mut self)

Re-sort clips and drop transitions whose cuts no longer exist. Call after any layout change.

pub fn insert_asset_clips( &mut self, asset_id: u64, at: f64, video_track: Option<usize>, ) -> Vec<u64>

Place an asset on the timeline at at: video/image clip on a video track (preferring video_track) plus one linked audio clip per audio stream (stream N preferring track A(N+1)). Returns new clip ids.

pub fn add_text_clip(&mut self, at: f64, dur: f64) -> u64

Add a text clip on the topmost video track that has room (or a new one).

pub fn split_at(&mut self, t: f64, only: Option<&[u64]>) -> Vec<u64>

Split every clip crossing t (or only the given ids). Right halves of a linked group stay linked to each other under a fresh link id. Returns the new (right-half) ids.

pub fn freeze_at(&mut self, t: f64, ids: &[u64]) -> Vec<u64>

Freeze-frame the clips at timeline time t: each clip is split at t and its right part becomes a still of the frame at t (linked clips of the same time too). Returns the frozen clip ids.

pub fn delete_clips(&mut self, ids: &[u64], ripple: bool)

Delete clips. With ripple, later clips close the gap (per track, only where no other clip overlaps the gap).

fn close_gap(&mut self, a: f64, b: f64)

Shift clips starting at/after b left by (b-a) on every track where [a,b) is free.

pub fn ripple_delete_range(&mut self, a: f64, b: f64)

Remove everything in [a,b) on all tracks and close the gap.

pub fn ripple_open(&mut self, at: f64, span: f64)

Open a gap of span seconds at at: split anything crossing it, then slide every clip from there on to the right. The inverse of ripple_delete_range, used by Paste Insert.

pub fn trim_to_range(&mut self, a: f64, b: f64)

Keep only [a,b), moving it to start at 0. Clears in/out points.

pub fn move_clips( &mut self, ids: &[u64], dt: f64, dtrack: i32, track_kind: Option<TrackKind>, ) -> bool

Move clips by dt seconds; clips on tracks of track_kind also move by dtrack tracks within their kind. All-or-nothing: returns false (and changes nothing) if any destination is blocked or out of range.

pub fn set_enabled(&mut self, ids: &[u64], enabled: bool)

Set enabled on the clips (linked clips too).

pub fn toggle_link(&mut self, ids: &[u64])

Unlink the clips if any is linked; otherwise link them together.

pub fn set_speed(&mut self, ids: &[u64], speed: f64, reverse: bool) -> bool

Apply speed/reverse to the clips and their linked clips (keeps source windows; durations follow). Returns false if the new lengths would collide with neighbours (nothing changed).

pub fn add_transition( &mut self, right: u64, kind: TransitionKind, duration: f64, ) -> Option<u64>

Add (or replace) a transition at the cut on the left of clip right. Linked audio clips whose left neighbour is linked with the video’s left neighbour get an audio CrossFade of the same length. Returns the new transition id, or None if right has no abutting left neighbour.

pub fn add_edge_transition( &mut self, clip: u64, kind: TransitionKind, duration: f64, out: bool, ) -> Option<u64>

Add (or replace) an edge transition at the start (out false) or end (out true) of clip: the clip blends from/to nothing, no neighbour needed. Mirrors on linked clips like add_transition.

fn add_transition_at( &mut self, right: u64, kind: TransitionKind, duration: f64, edge: TransitionEdge, ) -> Option<u64>

fn clear_transition_slot(track: &mut Track, c: &Clip, edge: TransitionEdge)

Remove whatever transition already occupies the spot a new one is going to: a Cut or In at the start of c share the start slot (plus the previous clip’s Out); an Out at the end of c shares the end slot with the next clip’s Cut / In.

pub fn remove_transition(&mut self, id: u64)

pub fn transition_mut(&mut self, id: u64) -> Option<&mut Transition>

pub fn transitions_of(&self, clip: u64) -> Vec<(usize, &Transition)>

Transitions touching a clip (as left or right side): (track index, transition).

pub fn cue_at(&self, t: f64) -> Option<&Cue>

pub fn add_cue(&mut self, start: f64, end: f64, text: impl Into<String>) -> u64

pub fn remove_cue(&mut self, id: u64)

pub fn split_cue(&mut self, id: u64, t: f64) -> Option<u64>

Split cue id at t (both halves keep the text, like splitting a clip); the new right-half id, or None when t is outside the cue or too close to an edge for two readable halves.

pub fn cues_to_text_clips(&mut self, only: Option<&[u64]>) -> usize

Convert cues into editable Text clips on a topmost “Subtitles” video track, styled and placed like the burn-in. only limits it to those cue ids; converted cues are removed. Returns how many.

pub fn sort_cues(&mut self)

pub fn sequence(&self, id: u64) -> Option<&Sequence>

pub fn sequence_mut(&mut self, id: u64) -> Option<&mut Sequence>

pub fn new_sequence( &mut self, name: impl Into<String>, width: u32, height: u32, fps: f64, ) -> u64

New empty sequence (V1 + A1) with the given format; returns its id.

pub fn sequence_duration(&self, id: u64) -> f64

Duration of a sequence (the live tracks when it is the one being edited).

pub fn sequence_tracks(&self, id: u64) -> Option<&[Track]>

Tracks of a sequence for rendering (its own, or the live tracks while it is being edited).

pub fn sequence_contains(&self, outer: u64, inner: u64) -> bool

True if sequence outer contains inner directly or through nested sequence clips.

pub fn open_sequence(&mut self, id: u64) -> bool

Swap sequence id into tracks for editing (closing any other open sequence first).

pub fn close_sequence(&mut self)

Put the edited sequence back and restore the main timeline.

pub fn insert_sequence_clip( &mut self, seq: u64, at: f64, video_track: Option<usize>, ) -> Option<u64>

Place a sequence as a clip at at (video track video_track preferred). None on cycles / unknown id.

pub fn nest_selection( &mut self, ids: &[u64], name: impl Into<String>, ) -> Option<u64>

Move the selected clips (+ linked) into a new sequence and replace them with one Sequence clip. Returns the new sequence id.

pub fn clip_label(&self, clip: &Clip) -> u8

Effective colour label of a clip (its own, else its asset’s). 0 = none.

fn plan_find_in(items: &mut [PlanItem], id: u64) -> Option<&mut PlanItem>

pub fn plan_item_mut(&mut self, id: u64) -> Option<&mut PlanItem>

pub fn plan_add(&mut self, parent: Option<u64>, title: impl Into<String>) -> u64

Add an item (under parent or at the top level); returns its id.

pub fn plan_remove(&mut self, id: u64)

pub fn plan_assets(&self) -> HashSet<u64>

All asset ids referenced by moodboards (never counted as “unused”).

pub fn used_assets(&self) -> HashSet<u64>

Asset ids referenced by any clip (main timeline, stash, every sequence).

pub fn remove_unused_assets(&mut self) -> usize

Remove assets no clip uses (planner moodboard assets are kept). Returns how many were removed.

pub fn auto_cut( &mut self, ids: &[u64], cuts: &[f64], remove: &[(f64, f64)], ripple: bool, ) -> usize

Split the clips (+ linked) at every time in cuts, then delete the pieces lying inside any of the remove ranges (timeline times, half-open), optionally closing the gaps (ripple). Returns the number of pieces removed.

pub fn place_clips( &mut self, clips: Vec<Clip>, assets: Vec<Asset>, at: f64, ) -> Vec<u64>

Place a saved group of clips (times relative to the group start) at at. Assets are re-added by path (ids remapped); clip/link ids are fresh; tracks chosen by kind in order (new ones when blocked).

pub fn flow_clips(&mut self, a: u64, b: u64) -> bool

Make two abutting clips “flow”: for every visual property animated on either clip, the outgoing value/velocity of a continues into b (a gets an ease-in to the cut, b an ease-out from it, and both meet at the same value at the cut). Returns false if the clips don’t abut.

pub fn label_color(&self, idx: u8) -> Option<[u8; 3]>

Colour of label index idx (1-based; 0 or unknown = None).

pub fn label_name(&self, idx: u8) -> &str

pub fn add_label(&mut self, name: impl Into<String>, color: [u8; 3]) -> u8

Add a label; returns its 1-based index.

pub fn remove_label(&mut self, idx: u8)

Remove a label; clips/assets/markers using it fall back to “none”, higher indices shift down.

pub fn add_marker(&mut self, t: f64, name: impl Into<String>) -> u64

pub fn remove_marker(&mut self, id: u64)

pub fn marker_mut(&mut self, id: u64) -> Option<&mut Marker>

pub fn sort_markers(&mut self)

pub fn add_clip_marker( &mut self, clip: u64, local_t: f64, name: impl Into<String>, ) -> Option<u64>

Add a marker on a clip (time is clip-local).

pub fn markers_in_timeline(&self) -> Vec<(u64, f64, f64, String, u8)>

Every marker in timeline time: project markers plus clip markers offset by their clip.

pub fn main_bus(&mut self) -> u64

The Main bus id, creating the default bus set on first use.

pub fn bus(&self, id: u64) -> Option<&Bus>

pub fn bus_mut(&mut self, id: u64) -> Option<&mut Bus>

pub fn add_bus(&mut self, name: impl Into<String>) -> u64

pub fn remove_bus(&mut self, id: u64)

Remove a bus (never Main); tracks/clips and sends fall back to Main.

pub fn bus_of(&self, track: usize, clip: &Clip) -> u64

Which bus a clip feeds: its own override, else its track’s, else Main.

pub fn add_shape_clip(&mut self, kind: ShapeKind, at: f64, dur: f64) -> u64

Add a shape clip on the topmost video track that has room.

pub fn add_adjustment_clip(&mut self, at: f64, dur: f64) -> u64

Add an adjustment (automation) layer above everything at at.

pub fn add_container_clip(&mut self, at: f64, dur: f64) -> (u64, u64)

Add a container clip pair (video slot + audio slot linked together) at at.

pub fn add_container_from_asset( &mut self, asset_id: u64, at: f64, video_track: Option<usize>, ) -> Vec<u64>

Insert asset clips marked as containers (slots).

pub fn replace_container_media( &mut self, clip_id: u64, new_asset_id: u64, ) -> bool

Replace the media of a container clip. Effects, transforms, keyframes, transitions and timeline duration are kept.

pub fn replace_container_pair( &mut self, video_id: u64, new_asset_id: u64, ) -> bool

Replace a video container clip and any linked audio container clips with the new asset.

pub fn make_container(&mut self, clip_ids: &[u64])

Convert clips to containers (slots). Linked clips are included.

pub fn unmake_container(&mut self, clip_ids: &[u64])

Remove container flag from clips. Linked clips are included.

pub fn path(&self, id: u64) -> Option<&PathAsset>

pub fn add_path(&mut self, name: String, points: Vec<(f32, f32, f32)>) -> u64

Keep a path on the project. An empty name gets a numbered one.

pub fn path_from_clip(&self, clip: u64) -> Vec<(f32, f32, f32)>

A clip’s drawing / polygon outline in canvas coordinates — the clip’s own position is folded in, so the path lands where the sketch is on screen.

pub fn apply_path(&mut self, clip: u64, points: &[(f32, f32, f32)]) -> bool

Drive a clip’s X/Y along a path over the clip’s own length. False when the path is too short to animate anything.

pub fn ensure_graph(&mut self, clip: u64) -> bool

Give the clip a node graph built from its current effect stack (idempotent).

pub fn unlink_graph(&mut self, clip: u64) -> Result<usize, String>

Drop a clip’s node graph back onto its linear effect stack; returns how many effects landed. Err when the graph is more than a chain (the caller toasts it) — nothing is touched then. Drop a clip’s node graph entirely, keeping whatever of it can be expressed as an effect chain. A graph that will not linearise (a branch, a cycle) still goes: “unlink” means the graph is gone and the clip is back on its effect list, so leaving the nodes in place would be the one outcome the user did not ask for. Err only when there was no graph to begin with.

pub fn add_node( &mut self, clip: u64, kind: NodeKind, x: f32, y: f32, ) -> Option<u64>

Add a node to a clip’s graph at editor position (x, y); returns its id.

pub fn copy_attributes(&self, clip: u64) -> Option<Clip>

Snapshot of a clip to paste attributes from (Ctrl+Alt+C).

pub fn paste_attributes( &mut self, src: &Clip, ids: &[u64], set: AttrSet, ) -> usize

Apply the selected attributes of src onto ids (timing and media are never touched). Returns how many clips changed.

pub fn to_json(&self) -> String

pub fn from_json(s: &str) -> Result<Self, String>

pub fn save(&self, path: &Path) -> Result<()>

Writes beside the target then renames, so a failed write can’t destroy the previous save.

pub fn load(path: &Path) -> Result<Self, String>

Trait Implementations

impl Clone for Project

fn clone(&self) -> Project

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Project

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Project

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Project

where Project: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Project

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.