f67d38b35cc5
media_browser.rs
//! Media Browser panel (M12.7): a directory tree (Favorites, Local Drives, Network, Recent
//! Directories) beside the media list (List or Thumbnails view with hover scrub), back / forward /
//! up navigation, the path field, the file-type filter, Ingest and Import as Image Sequence, Edit
//! Columns…, Import / Open In Source Monitor and dragging files to the Project panel or Timeline.
//!
//! Listing, navigation, Favorites, settings and import are engine commands
//! (`filmcraft_engine::media_browser`, `mediaBrowser.*`); this module draws them and keeps only view
//! state ([`MediaBrowserUi`], `ui.set {"mediaBrowser": …}`).
use std::collections::BTreeMap;
use std::sync::Arc;
use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
use filmcraft_engine::media_browser::{self as mb, Entry};
use filmcraft_project::{ItemId, ItemKind, Label, MediaClip, MediaRef, Project, ProjectItem};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::FilmcraftApp;
use crate::frames::{FrameKey, Target};
use crate::icons::{self, Icon};
use crate::theme::Tokens;
/// Frontend state of the Media Browser (`UiState::media_browser`).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct MediaBrowserUi {
/// Expanded directories in the tree.
pub expanded: Vec<String>,
/// The path field being edited (None = shows the current directory).
pub path_edit: Option<String>,
/// Edit Columns… dialog: the columns being chosen (open when Some).
pub edit_columns: Option<Vec<String>>,
/// The thumbnail size while its slider is dragged; the preference is written on release.
#[serde(skip)]
pub thumbnail_drag: Option<f32>,
/// Width of the directory tree (points).
pub tree_width: f32,
/// The thumbnail under the pointer and the hovered fraction of its duration.
pub hover: Option<(String, f32)>,
/// List view column being resized and its width so far; the preference is written on release.
#[serde(skip)]
pub column_drag: Option<(String, f32)>,
}
/// Cached directory listings (refreshed every few seconds or on Refresh).
#[derive(Clone, Default)]
struct Cache {
lists: BTreeMap<(String, String), (f64, Arc<Vec<Entry>>)>,
/// Preview items for thumbnails of files not in the project: path → id.
preview_ids: BTreeMap<String, u64>,
preview: Arc<Project>,
/// Item imported for a drag in progress (undone when it is dropped nowhere): items, history
/// length after the import, last pointer position.
drag: Option<(Vec<u64>, usize, egui::Pos2)>,
}
const PREVIEW_BASE: u64 = 1 << 44;
const CACHE_SECS: f64 = 3.0;
const ROW_H: f32 = 22.0;
/// How often to look for background probe results.
const PROBE_POLL: std::time::Duration = std::time::Duration::from_millis(100);
/// Temp-store key for the Media Browser cache: listings stay fresh for 3 s and preview texture ids start at `PREVIEW_BASE`.
fn cache_id() -> egui::Id {
egui::Id::unique("media-browser-cache")
}
fn with_cache<R>(ctx: &egui::Context, f: impl FnOnce(&mut Cache) -> R) -> R {
ctx.data_mut(|d| {
let c = d.get_temp_mut_or_default::<Cache>(cache_id());
f(c)
})
}
/// Drop cached listings (Refresh, after navigation).
pub fn refresh(ctx: &egui::Context) {
with_cache(ctx, |c| c.lists.clear());
}
fn listing(app: &FilmcraftApp, ctx: &egui::Context, dir: &str, filter: &str) -> Result<Arc<Vec<Entry>>, String> {
let now = ctx.input(|i| i.time);
let key = (dir.to_string(), filter.to_string());
if let Some(v) = with_cache(ctx, |c| c.lists.get(&key).filter(|(t, _)| now - *t < CACHE_SECS).map(|(_, v)| v.clone())) {
return Ok(v);
}
let v = Arc::new(mb::list(&*app.session.services, dir, filter).map_err(|e| e.to_string())?);
with_cache(ctx, |c| c.lists.insert(key, (now, v.clone())));
Ok(v)
}
fn exec(app: &mut FilmcraftApp, ctx: &egui::Context, cmd: &str, p: Value) -> Option<Value> {
match crate::menus::invoke(app, ctx, cmd, p) {
Ok(v) => Some(v),
Err(e) => {
app.ui.status = e;
None
}
}
}
pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
let t = app.tokens;
let ctx = ui.ctx().clone();
finish_drag(app, ui);
let dir = mb::current_dir(&app.session);
let prefs = app.session.prefs.media_browser.clone();
// ---- toolbar: back, forward, up, path, file types, view, Ingest, Import as Image Sequence
let bar = Rect::from_min_size(rect.min + vec2(6.0, 4.0), vec2(rect.width() - 12.0, 24.0));
let mut x = bar.min.x;
let nav = [
(Icon::ChevronLeft, "back", tl!("Go Back"), !app.session.browser.back.is_empty()),
(Icon::ChevronRight, "forward", tl!("Go Forward"), !app.session.browser.forward.is_empty()),
(Icon::ArrowUp, "up", tl!("Up One Level"), mb::parent(&dir).is_some()),
];
for (icon, id, tip, enabled) in nav {
let r = Rect::from_min_size(pos2(x, bar.min.y), vec2(24.0, 24.0));
let resp = ui.interact(r, egui::Id::unique(("mb-nav", id)), Sense::click()).on_hover_text(tip);
app.auto.add(&format!("mediaBrowser.{id}"), r, tip);
if resp.hovered() && enabled {
ui.painter().rect_filled(r, 3.0, t.hover);
}
icons::paint(ui.painter(), r.shrink(5.0), icon, if enabled { t.icon } else { t.text_faint });
if resp.clicked() && enabled {
exec(app, &ctx, "mediaBrowser.navigate", json!({id: true}));
refresh(&ctx);
}
x += 26.0;
}
// path field: type a directory and press Enter
let pw = (bar.max.x - x - 290.0).max(80.0);
let pr = Rect::from_min_size(pos2(x + 4.0, bar.min.y + 1.0), vec2(pw, 22.0));
let mut path = app.ui.media_browser.path_edit.clone().unwrap_or_else(|| dir.clone());
let resp = crate::widgets::accessible_name(
ui.put(pr, egui::TextEdit::singleline(&mut path).id(egui::Id::unique("mb-path")).font(egui::FontId::proportional(11.5))),
"Path",
);
app.auto.add("mediaBrowser.path", pr, "Path");
if resp.changed() {
app.ui.media_browser.path_edit = Some(path.clone());
}
if resp.lost_focus() {
if ui.input(|i| i.key_pressed(egui::Key::Enter)) && path != dir {
exec(app, &ctx, "mediaBrowser.navigate", json!({"path": path}));
refresh(&ctx);
}
app.ui.media_browser.path_edit = None;
}
x = pr.max.x + 6.0;
// file types
let fr = Rect::from_min_size(pos2(x, bar.min.y + 1.0), vec2(150.0, 22.0));
let label = mb::FILE_TYPES.iter().find(|f| f.0 == prefs.file_types).map(|f| f.1.to_string()).unwrap_or_else(|| format!(".{}", prefs.file_types));
let fresp = crate::widgets::dropdown_text(ui, fr, &label, &t, egui::Id::unique("mb-types")).on_hover_text(tl!("File Types Displayed"));
app.auto.add("mediaBrowser.fileTypes", fr, "File Types Displayed");
egui::Popup::menu(&fresp).show(|ui| {
for (k, l) in mb::FILE_TYPES {
let r = ui.selectable_label(prefs.file_types == k, l);
app.auto.add(&format!("mediaBrowser.fileTypes.{k}"), r.rect, l);
if r.clicked() {
exec(app, &ctx, "mediaBrowser.settings", json!({"fileTypes": k}));
ui.close();
}
}
ui.separator();
ui.menu_button(tl!("File Extension"), |ui| {
for e in mb::extensions() {
if ui.selectable_label(prefs.file_types == e, format!(".{e}")).clicked() {
exec(app, &ctx, "mediaBrowser.settings", json!({"fileTypes": e}));
ui.close();
}
}
});
});
x = fr.max.x + 6.0;
for (icon, v, tip) in [(Icon::ListView, "list", tl!("List View")), (Icon::IconView, "thumbnails", tl!("Thumbnail View"))] {
let r = Rect::from_min_size(pos2(x, bar.min.y), vec2(24.0, 24.0));
let resp = ui.interact(r, egui::Id::unique(("mb-view", v)), Sense::click()).on_hover_text(tip);
app.auto.add(&format!("mediaBrowser.view.{v}"), r, tip);
if prefs.view == v {
ui.painter().rect_filled(r, 3.0, t.pressed);
} else if resp.hovered() {
ui.painter().rect_filled(r, 3.0, t.hover);
}
icons::paint(ui.painter(), r.shrink(5.0), icon, if prefs.view == v { t.icon_active } else { t.icon });
if resp.clicked() {
exec(app, &ctx, "mediaBrowser.settings", json!({"view": v}));
}
x += 26.0;
}
// second row: Ingest (Project ▸ Ingest Settings) and Import as Image Sequence
let row2 = Rect::from_min_size(pos2(bar.min.x, bar.max.y + 4.0), vec2(bar.width(), 20.0));
let mut ingest = app.session.project.settings.ingest.enabled;
let mut c = ui.new_child(egui::UiBuilder::new().max_rect(row2).id_salt("mb-row2").layout(egui::Layout::left_to_right(egui::Align::Center)));
let r = c.checkbox(&mut ingest, tl!("Ingest"));
app.auto.add("mediaBrowser.ingest", r.rect, "Ingest");
if r.changed() {
exec(app, &ctx, "project.ingestSettings", json!({"enabled": ingest}));
}
let w = c.add(egui::Button::new(egui::RichText::new("⚙").size(12.0)).frame(false)).on_hover_text(tl!("Open Ingest Settings"));
app.auto.add("mediaBrowser.ingestSettings", w.rect, "Open Ingest Settings");
if w.clicked() {
exec(app, &ctx, "project.ingestSettings", json!({}));
}
c.add_space(12.0);
let mut seq = prefs.import_as_image_sequence;
let r = c.checkbox(&mut seq, tl!("Import as Image Sequence"));
app.auto.add("mediaBrowser.importAsImageSequence", r.rect, "Import as Image Sequence");
if r.changed() {
exec(app, &ctx, "mediaBrowser.settings", json!({"importAsImageSequence": seq}));
}
// ---- tree | list
let body = Rect::from_min_max(pos2(rect.min.x, row2.max.y + 4.0), pos2(rect.max.x, rect.max.y - 24.0));
let tw = if app.ui.media_browser.tree_width <= 0.0 { (rect.width() * 0.32).clamp(140.0, 260.0) } else { app.ui.media_browser.tree_width };
let tree_r = Rect::from_min_max(body.min, pos2(body.min.x + tw, body.max.y));
let list_r = Rect::from_min_max(pos2(tree_r.max.x + 4.0, body.min.y), body.max);
// splitter
let split = Rect::from_min_max(pos2(tree_r.max.x, body.min.y), pos2(tree_r.max.x + 4.0, body.max.y));
let sresp = ui.interact(split, egui::Id::unique("mb-split"), Sense::drag()).on_hover_cursor(egui::CursorIcon::ResizeHorizontal);
if sresp.dragged() {
app.ui.media_browser.tree_width = (tw + sresp.drag_delta().x).clamp(100.0, (rect.width() * 0.7).max(100.0));
}
ui.painter().line_segment([split.center_top(), split.center_bottom()], Stroke::new(1.0, t.separator));
tree(app, ui, tree_r, &dir);
let entries = listing(app, &ctx, &dir, &prefs.file_types);
match entries {
Ok(entries) => {
if prefs.view == "thumbnails" {
thumbnails(app, ui, list_r, &entries);
} else {
list(app, ui, list_r, &entries, &prefs.columns);
}
let n = entries.iter().filter(|e| !e.is_dir).count();
let sel = app.session.browser.selection.len();
let status = if sel > 0 { tlf!("{sel} of {total} items selected", sel, total = n) } else { tlf!("{total} items", total = n) };
ui.painter().text(pos2(list_r.min.x + 6.0, rect.max.y - 12.0), Align2::LEFT_CENTER, &status, Tokens::ui(11.0), t.text_dim);
app.auto.add("mediaBrowser.count", Rect::from_min_size(pos2(list_r.min.x, rect.max.y - 22.0), vec2(160.0, 20.0)), &status);
}
Err(e) => {
ui.painter().text(list_r.center(), Align2::CENTER_CENTER, tlf!("Cannot open {dir}: {e}", dir, e), Tokens::ui(11.5), t.text_dim);
}
}
if prefs.view == "thumbnails" {
let sr = Rect::from_min_size(pos2(rect.max.x - 130.0, rect.max.y - 20.0), vec2(120.0, 16.0));
let shown = app.ui.media_browser.thumbnail_drag.unwrap_or(prefs.thumbnail_size);
let mut sz = shown;
let resp = ui.put(sr, egui::Slider::new(&mut sz, 60.0..=320.0).show_value(false));
app.auto.add("mediaBrowser.thumbnailSize", sr, "Thumbnail size");
// a drag ended by Escape goes back to the size it started from (#580)
let orig_id = egui::Id::unique("media-browser-thumbnail-size-before-drag");
if resp.drag_started() {
ui.data_mut(|d| d.insert_temp(orig_id, prefs.thumbnail_size));
}
let escaped = resp.drag_stopped() && ui.input(|i| i.key_pressed(egui::Key::Escape));
if resp.drag_stopped()
&& let Some(before) = ui.data_mut(|d| d.remove_temp(orig_id))
&& escaped
{
sz = before;
}
// in UI state while dragging: had the drag changed the preferences already, the command
// would see nothing new and not write preferences.json
if sz != shown {
app.ui.media_browser.thumbnail_drag = Some(sz);
}
if resp.drag_stopped() || (resp.changed() && !resp.dragged()) {
app.ui.media_browser.thumbnail_drag = None;
if !escaped {
exec(app, &ctx, "mediaBrowser.settings", json!({"thumbnailSize": sz}));
}
}
}
}
// ------------------------------------------------------------------------------------ tree
fn tree(app: &mut FilmcraftApp, ui: &mut egui::Ui, r: Rect, dir: &str) {
let ctx = ui.ctx().clone();
let roots = app.session.execute("mediaBrowser.roots", json!({})).unwrap_or_default();
let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r.shrink2(vec2(4.0, 0.0))).id_salt("mb-tree"));
child.set_clip_rect(r.intersect(ui.clip_rect()));
let mut go: Option<String> = None;
egui::ScrollArea::vertical().id_salt("mb-tree-scroll").auto_shrink([false, false]).show(&mut child, |ui| {
let sections: [(&str, &str, Icon); 4] = [
("favorites", tl!("Favorites"), Icon::Star),
("localDrives", tl!("Local Drives"), Icon::Drive),
("network", tl!("Network"), Icon::Network),
("recent", tl!("Recent Directories"), Icon::Clock),
];
for (key, title, icon) in sections {
let list: Vec<(String, String)> = roots[key]
.as_array()
.map(|a| a.iter().filter_map(|v| Some((v["name"].as_str()?.to_string(), v["path"].as_str()?.to_string()))).collect())
.unwrap_or_default();
let hr = ui.label(egui::RichText::new(title).size(11.0).color(app.tokens.text_dim).strong());
app.auto.add(&format!("mediaBrowser.tree.{key}"), hr.rect, title);
if list.is_empty() {
ui.label(egui::RichText::new(tl!(" (none)")).size(10.5).color(app.tokens.text_faint));
}
for (name, path) in list {
let expandable = matches!(key, "localDrives" | "network" | "favorites");
node(app, ui, &ctx, &name, &path, icon, 0, expandable, dir, key, &mut go);
}
ui.add_space(6.0);
}
});
if let Some(p) = go {
exec(app, &ctx, "mediaBrowser.navigate", json!({"path": p}));
refresh(&ctx);
}
}
#[allow(clippy::too_many_arguments)]
fn node(
app: &mut FilmcraftApp,
ui: &mut egui::Ui,
ctx: &egui::Context,
name: &str,
path: &str,
icon: Icon,
depth: usize,
expandable: bool,
cur: &str,
section: &str,
go: &mut Option<String>,
) {
let t = app.tokens;
let open = app.ui.media_browser.expanded.iter().any(|p| p == path);
let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 20.0), Sense::click());
if path == cur {
ui.painter().rect_filled(r, 2.0, t.row_selected);
} else if resp.hovered() {
ui.painter().rect_filled(r, 2.0, t.hover);
}
let x = r.min.x + 2.0 + depth as f32 * 12.0;
let tri = Rect::from_center_size(pos2(x + 5.0, r.center().y), vec2(12.0, 12.0));
if expandable {
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 + 19.0, r.center().y), vec2(13.0, 13.0)),
icon,
if icon == Icon::Folder { Color32::from_rgb(237, 150, 58) } else { t.icon },
);
ui.painter().with_clip_rect(r).text(pos2(x + 30.0, r.center().y), Align2::LEFT_CENTER, name, Tokens::ui(11.5), t.text);
let id = if depth == 0 { format!("mediaBrowser.tree.{section}.{name}") } else { format!("mediaBrowser.tree.dir.{path}") };
app.auto.add(&id, r, name);
if resp.clicked() {
let on_tri = expandable && resp.interact_pointer_pos().is_some_and(|p| p.x < x + 11.0);
if on_tri {
toggle(app, path, open);
} else {
*go = Some(path.to_string());
}
}
if resp.double_clicked() && expandable {
toggle(app, path, open);
}
resp.context_menu(|ui| {
let fav = app.session.prefs.media_browser.favorites.iter().any(|f| f == path);
let label = if fav { tl!("Remove from Favorites") } else { tl!("Add to Favorites") };
let b = ui.button(label);
app.auto.add("mediaBrowser.treeMenu.favorite", b.rect, label);
if b.clicked() {
exec(app, ctx, "mediaBrowser.favorite", json!({"path": path, "remove": fav}));
ui.close();
}
if ui.button(tl!("Import")).clicked() {
exec(app, ctx, "mediaBrowser.import", json!({"paths": [path]}));
ui.close();
}
if section == "recent" && ui.button(tl!("Clear Recent Directories")).clicked() {
exec(app, ctx, "mediaBrowser.clearRecent", json!({}));
ui.close();
}
});
if expandable && open {
let subs: Vec<Entry> = listing(app, ctx, path, "all").map(|v| v.iter().filter(|e| e.is_dir).cloned().collect()).unwrap_or_default();
for s in subs {
node(app, ui, ctx, &s.name, &s.path, Icon::Folder, depth + 1, true, cur, section, go);
}
}
}
fn toggle(app: &mut FilmcraftApp, path: &str, open: bool) {
let e = &mut app.ui.media_browser.expanded;
if open {
e.retain(|p| p != path);
} else {
e.push(path.to_string());
}
}
// ------------------------------------------------------------------------------------ entries
/// Click / double-click / drag / context menu of an entry.
fn entry_interactions(app: &mut FilmcraftApp, ui: &egui::Ui, resp: &egui::Response, e: &Entry, entries: &[Entry]) {
let ctx = ui.ctx().clone();
if resp.clicked() {
let mods = crate::panels::project_views::click_modifiers(ui);
let mut sel = app.session.browser.selection.clone();
if mods.command {
if let Some(p) = sel.iter().position(|x| *x == e.path) {
sel.remove(p);
} else {
sel.push(e.path.clone());
}
} else if mods.shift && !sel.is_empty() {
let a = entries.iter().position(|x| Some(&x.path) == sel.first()).unwrap_or(0);
let b = entries.iter().position(|x| x.path == e.path).unwrap_or(0);
sel = entries[a.min(b)..=a.max(b)].iter().map(|x| x.path.clone()).collect();
} else {
sel = vec![e.path.clone()];
}
exec(app, &ctx, "mediaBrowser.select", json!({"paths": sel}));
}
if resp.double_clicked() {
if e.is_dir {
exec(app, &ctx, "mediaBrowser.navigate", json!({"path": e.path}));
refresh(&ctx);
} else if matches!(e.kind, "project" | "caption") {
exec(app, &ctx, "mediaBrowser.import", json!({"paths": [e.path]}));
} else {
exec(app, &ctx, "mediaBrowser.openInSource", json!({"path": e.path}));
}
}
if resp.drag_started_by(egui::PointerButton::Primary) && !e.is_dir {
start_file_drag(app, ui, e);
}
resp.context_menu(|ui| {
let paths: Vec<String> = if app.session.browser.selection.contains(&e.path) { app.session.browser.selection.clone() } else { vec![e.path.clone()] };
let b = ui.button(tl!("Import"));
app.auto.add("mediaBrowser.entryMenu.import", b.rect, "Import");
if b.clicked() {
exec(app, &ctx, "mediaBrowser.import", json!({"paths": paths, "imageSequence": false}));
ui.close();
}
if !e.is_dir {
let b = ui.button(tl!("Open In Source Monitor"));
app.auto.add("mediaBrowser.entryMenu.openInSource", b.rect, "Open In Source Monitor");
if b.clicked() {
exec(app, &ctx, "mediaBrowser.openInSource", json!({"path": e.path}));
ui.close();
}
}
if e.numbered {
let b = ui.button(tl!("Import as Image Sequence"));
app.auto.add("mediaBrowser.entryMenu.importSequence", b.rect, "Import as Image Sequence");
if b.clicked() {
exec(app, &ctx, "mediaBrowser.import", json!({"paths": [e.path], "imageSequence": true}));
ui.close();
}
}
if e.is_dir {
let fav = app.session.prefs.media_browser.favorites.contains(&e.path);
if ui.button(if fav { tl!("Remove from Favorites") } else { tl!("Add to Favorites") }).clicked() {
exec(app, &ctx, "mediaBrowser.favorite", json!({"path": e.path, "remove": fav}));
ui.close();
}
}
if ui.button(tl!("Reveal in Finder")).clicked() {
let _ = crate::panels::menu_dialogs::open_path(app, &ctx, &e.path, true);
ui.close();
}
});
}
/// Dragging a file imports it (the selection when the file is in it) and carries its items, so
/// the Project panel, Timeline and monitors accept them; a drop elsewhere undoes the import.
fn start_file_drag(app: &mut FilmcraftApp, ui: &egui::Ui, e: &Entry) {
let paths: Vec<String> = if app.session.browser.selection.contains(&e.path) { app.session.browser.selection.clone() } else { vec![e.path.clone()] };
// files already in the project are dragged as they are; only the others are imported
let known: Vec<ItemId> = paths.iter().filter_map(|p| mb::item_for_path(&app.session, p)).collect();
let fresh: Vec<String> = paths.iter().filter(|p| mb::item_for_path(&app.session, p).is_none()).cloned().collect();
let before = app.session.history.undo.len();
let mut items: Vec<u64> = Vec::new();
if !fresh.is_empty() {
let Ok(r) = app.session.execute("mediaBrowser.import", json!({"paths": fresh})) else { return };
items = r["items"].as_array().map(|a| a.iter().filter_map(Value::as_u64).collect()).unwrap_or_default();
}
let all = file_drag_items(&known, &items);
let Some(first) = all.first().copied() else { return };
// the drop targets place the whole Project selection when the dragged item is one of it
if all.len() > 1 {
app.session.state.project_selection = all;
}
crate::panels::start_drag_item(ui, first);
if !items.is_empty() {
let pos = ui.ctx().pointer_latest_pos().unwrap_or_default();
let after = app.session.history.undo.len();
with_cache(ui.ctx(), |c| c.drag = Some((items, after.max(before), pos)));
}
}
/// Every item a Media Browser drag carries: the selected files already in the project, then the newly imported ones.
fn file_drag_items(known: &[ItemId], imported: &[u64]) -> Vec<ItemId> {
known.iter().copied().chain(imported.iter().map(|i| ItemId(*i))).collect()
}
/// After a file drag ends: keep the import when it landed on a panel that takes items.
fn finish_drag(app: &mut FilmcraftApp, ui: &egui::Ui) {
let Some((items, hist, _)) = with_cache(ui.ctx(), |c| c.drag.clone()) else { return };
if crate::panels::dragged_project_item(ui).is_some() {
if let Some(p) = ui.ctx().pointer_latest_pos() {
with_cache(ui.ctx(), |c| {
if let Some(d) = c.drag.as_mut() {
d.2 = p;
}
});
}
return;
}
let pos = with_cache(ui.ctx(), |c| c.drag.take().map(|d| d.2)).unwrap_or_default();
let targets = ["panel.Project", "panel.Timeline", "panel.Source", "panel.Program"];
// a drag cancelled with Escape (#580) landed nowhere, wherever the pointer is
let landed = !crate::panels::drag_cancelled(ui)
&& targets.iter().any(|t| app.auto.find(t).is_some_and(|e| Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3])).contains(pos)));
let used_elsewhere = app.session.history.undo.len() > hist;
if !landed && !used_elsewhere && items.iter().all(|i| app.session.project.item(ItemId(*i)).is_some()) {
// dropped nowhere: take the import back
let _ = app.session.execute("edit.undo", json!({}));
}
}
fn list(app: &mut FilmcraftApp, ui: &mut egui::Ui, r: Rect, entries: &[Entry], columns: &[String]) {
let t = app.tokens;
let ctx = ui.ctx().clone();
let saved = &app.session.prefs.media_browser.column_widths;
let drag = &app.ui.media_browser.column_drag;
// clamped here too: a hand-edited preferences file never went through the command's clamp
let widths: Vec<f32> = columns
.iter()
.map(|c| match drag {
Some((d, w)) if d == c => *w,
_ => saved.get(c).map_or(if c == "Name" { 220.0 } else { 110.0 }, |w| w.clamp(30.0, 800.0)),
})
.collect();
let total: f32 = widths.iter().sum::<f32>() + 8.0;
let header = Rect::from_min_size(r.min, vec2(r.width(), 20.0));
let body = Rect::from_min_max(pos2(r.min.x, header.max.y), r.max);
let mut child = ui.new_child(egui::UiBuilder::new().max_rect(body).id_salt("mb-list"));
child.set_clip_rect(body.intersect(ui.clip_rect()));
let needs_probe =
columns.iter().any(|c| matches!(c.as_str(), "Frame Rate" | "Media Duration" | "Video Info" | "Audio Info" | "Video Codec" | "Audio Codec"));
let out = egui::ScrollArea::both().id_salt("mb-list-scroll").auto_shrink([false, false]).show(&mut child, |ui| {
ui.set_min_width(total.max(body.width()));
for (i, e) in entries.iter().enumerate() {
let (rr, resp) = ui.allocate_exact_size(vec2(total.max(body.width()), ROW_H), Sense::click_and_drag());
let sel = app.session.browser.selection.contains(&e.path);
if sel {
ui.painter().rect_filled(rr, 0.0, t.row_selected);
} else if i % 2 == 1 {
ui.painter().rect_filled(rr, 0.0, t.row_alt);
}
let info = if needs_probe && !e.is_dir {
mb::probe_background(&mut app.session, &e.path).unwrap_or_else(|| {
ctx.request_repaint_after(PROBE_POLL);
None
})
} else {
None
};
let mut x = rr.min.x + 4.0;
for (c, w) in columns.iter().zip(&widths) {
let cr = Rect::from_min_size(pos2(x, rr.min.y), vec2(*w, ROW_H));
let p = ui.painter().with_clip_rect(cr.shrink2(vec2(2.0, 0.0)).intersect(ui.clip_rect()));
if c == "Name" {
let icon = match e.kind {
"folder" => Icon::Folder,
"audio" => Icon::Audio,
"image" => Icon::Image,
"video" => Icon::Film,
"caption" => Icon::Captions,
_ => Icon::Sequence,
};
let col = if e.is_dir { Color32::from_rgb(237, 150, 58) } else { t.icon };
icons::paint(&p, Rect::from_center_size(pos2(cr.min.x + 9.0, cr.center().y), vec2(14.0, 14.0)), icon, col);
p.text(pos2(cr.min.x + 22.0, cr.center().y), Align2::LEFT_CENTER, &e.name, Tokens::ui(12.0), t.text);
} else {
p.text(pos2(cr.min.x + 4.0, cr.center().y), Align2::LEFT_CENTER, mb::column_text(e, c, info.as_ref()), Tokens::ui(11.5), t.text_dim);
}
x += w;
}
app.auto.add(&format!("mediaBrowser.entry.{}", e.name), rr.intersect(ui.clip_rect()), &e.name);
entry_interactions(app, ui, &resp, e, entries);
}
let rest = ui.available_rect_before_wrap();
let resp = ui.allocate_rect(Rect::from_min_size(rest.min, vec2(rest.width(), rest.height().max(30.0))), Sense::click());
if resp.clicked() {
exec(app, &ctx, "mediaBrowser.select", json!({"paths": []}));
}
});
let hp = ui.painter().with_clip_rect(header.intersect(ui.clip_rect()));
hp.rect_filled(header, 0.0, t.panel_bg);
hp.line_segment([header.left_bottom(), header.right_bottom()], Stroke::new(1.0, t.separator));
let mut x = header.min.x + 4.0 - out.state.clamped_offset().x;
for (c, w) in columns.iter().zip(&widths) {
let cr = Rect::from_min_size(pos2(x, header.min.y), vec2(*w, 20.0));
hp.text(pos2(cr.min.x + 4.0, cr.center().y), Align2::LEFT_CENTER, crate::i18n::t(c), Tokens::ui(11.0), t.text_dim);
if cr.intersects(header) {
let resp = ui.interact(cr.intersect(header), egui::Id::unique(("mb-col", c)), Sense::click());
app.auto.add(&format!("mediaBrowser.header.{c}"), cr.intersect(header), c);
resp.context_menu(|ui| {
if ui.button(tl!("Edit Columns…")).clicked() {
app.ui.media_browser.edit_columns = Some(columns.to_vec());
ui.close();
}
});
}
// resize handle on the column's right edge, as in the Project panel's List view
let hr = Rect::from_center_size(pos2(cr.max.x, header.center().y), vec2(8.0, 20.0));
let visible = hr.intersects(header);
// a handle dragged past the header's end stays registered, or its release would be missed
let dragging = app.ui.media_browser.column_drag.as_ref().is_some_and(|(d, _)| d == c);
if visible || dragging {
let resp = ui
.interact(if visible { hr.intersect(header) } else { hr }, egui::Id::unique(("mb-colsize", c)), Sense::drag())
.on_hover_cursor(egui::CursorIcon::ResizeColumn);
if visible {
app.auto.add(&format!("mediaBrowser.resize.{c}"), hr.intersect(header), "Resize column");
hp.line_segment([pos2(cr.max.x, header.min.y + 4.0), pos2(cr.max.x, header.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() {
app.ui.media_browser.column_drag = Some((c.clone(), (w + resp.drag_delta().x).clamp(30.0, 800.0)));
}
if resp.drag_stopped() {
let w = app.ui.media_browser.column_drag.take().filter(|(d, _)| d == c).map_or(*w, |(_, w)| w);
exec(app, &ctx, "mediaBrowser.settings", json!({"columnWidths": {c: w}}));
}
}
x += w;
}
}
/// A preview item for a file's thumbnail (files not in the project), or the project item.
fn preview_item(
app: &mut FilmcraftApp,
ctx: &egui::Context,
e: &Entry,
) -> Option<(Arc<Project>, ItemId, filmcraft_time::Tick, filmcraft_time::FrameRate, u32)> {
if let Some(i) = mb::item_for_path(&app.session, &e.path) {
let it = app.session.project.item(i)?;
let w = it.as_media()?.info.video.as_ref()?.width;
return Some((app.session.project.clone(), i, it.duration(), it.frame_rate(), w));
}
let info = app.session.browser.probes.get(&e.path).cloned().flatten()?;
let v = info.video.as_ref()?;
let (rate, w, dur) = (v.frame_rate, v.width, info.duration);
let (proj, id) = with_cache(ctx, |c| {
let n = c.preview_ids.len() as u64;
let id = *c.preview_ids.entry(e.path.clone()).or_insert(PREVIEW_BASE + n);
if c.preview.item(ItemId(id)).is_none() {
let mut p = (*c.preview).clone();
p.items.insert(
ItemId(id),
ProjectItem {
custom_label_color: None,
id: ItemId(id),
name: e.name.clone(),
label: Label::Iris,
kind: ItemKind::Media(Box::new(MediaClip {
media: MediaRef::File { path: e.path.clone() },
info: info.clone(),
interpret: Default::default(),
mark_in: None,
mark_out: None,
markers: vec![],
offline: false,
proxy: None,
identity: None,
})),
metadata: Default::default(),
created: 0,
split: Default::default(),
},
);
c.preview = Arc::new(p);
}
(c.preview.clone(), ItemId(id))
});
Some((proj, id, dur, rate, w))
}
fn thumbnails(app: &mut FilmcraftApp, ui: &mut egui::Ui, r: Rect, entries: &[Entry]) {
let t = app.tokens;
let ctx = ui.ctx().clone();
let size = app.ui.media_browser.thumbnail_drag.unwrap_or(app.session.prefs.media_browser.thumbnail_size);
let hover_scrub = app.session.prefs.media_browser.hover_scrub;
let th_h = size * 9.0 / 16.0;
let cell = vec2(size + 16.0, th_h + 30.0);
let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r).id_salt("mb-thumbs"));
child.set_clip_rect(r.intersect(ui.clip_rect()));
let per_row = ((r.width() - 8.0) / cell.x).floor().max(1.0) as usize;
app.ui.media_browser.hover = None;
egui::ScrollArea::vertical().id_salt("mb-thumb-scroll").auto_shrink([false, false]).show(&mut child, |ui| {
for chunk in entries.chunks(per_row) {
let (row, _) = ui.allocate_exact_size(vec2(ui.available_width(), cell.y), Sense::hover());
for (k, e) in chunk.iter().enumerate() {
let tr = Rect::from_min_size(pos2(row.min.x + 8.0 + k as f32 * cell.x, row.min.y + 6.0), vec2(size, th_h));
let resp = ui.interact(tr.expand(2.0), egui::Id::unique(("mb-thumb", &e.path)), Sense::click_and_drag());
let sel = app.session.browser.selection.contains(&e.path);
ui.painter().rect_filled(tr, 3.0, Color32::from_gray(14));
if sel {
ui.painter().rect_stroke(tr, 3.0, Stroke::new(2.0, t.accent), StrokeKind::Outside);
}
if e.is_dir {
icons::paint(
ui.painter(),
Rect::from_center_size(tr.center(), vec2(th_h * 0.6, th_h * 0.6)),
Icon::Folder,
Color32::from_rgb(237, 150, 58),
);
} else {
let visible = ui.is_rect_visible(tr);
if visible && matches!(e.kind, "video" | "image") && mb::probe_background(&mut app.session, &e.path).is_none() {
ctx.request_repaint_after(PROBE_POLL);
}
let frac = if hover_scrub && resp.hovered() {
ctx.pointer_hover_pos().map(|p| ((p.x - tr.min.x) / tr.width()).clamp(0.0, 1.0)).unwrap_or(0.3)
} else {
0.3
};
if resp.hovered() {
app.ui.media_browser.hover = Some((e.path.clone(), frac));
}
let drawn = visible && draw_preview(app, ui, &ctx, e, tr, frac);
if !drawn {
let icon = match e.kind {
"audio" => Icon::Audio,
"image" => Icon::Image,
"caption" => Icon::Captions,
"project" => Icon::Sequence,
_ => Icon::Film,
};
icons::paint(ui.painter(), Rect::from_center_size(tr.center(), vec2(26.0, 26.0)), icon, t.text_faint);
}
if hover_scrub && resp.hovered() {
let x = tr.min.x + tr.width() * frac;
ui.painter().line_segment([pos2(x, tr.min.y), pos2(x, tr.max.y)], Stroke::new(1.0, Color32::from_rgb(0x5a, 0x9b, 0xf0)));
}
}
ui.painter().with_clip_rect(Rect::from_min_max(pos2(tr.min.x, tr.max.y), pos2(tr.max.x, tr.max.y + 22.0))).text(
pos2(tr.min.x, tr.max.y + 11.0),
Align2::LEFT_CENTER,
&e.name,
Tokens::ui(11.5),
t.text,
);
app.auto.add(&format!("mediaBrowser.entry.{}", e.name), tr, &e.name);
entry_interactions(app, ui, &resp, e, entries);
}
}
});
}
fn draw_preview(app: &mut FilmcraftApp, ui: &egui::Ui, ctx: &egui::Context, e: &Entry, r: Rect, frac: f32) -> bool {
let Some((proj, id, dur, rate, src_w)) = preview_item(app, ctx, e) else { return false };
let t = filmcraft_time::Tick((dur.0 as f64 * frac as f64) as i64);
let frame = rate.frame_at(crate::panels::project::quantize(t));
let width = (r.width() as u32).clamp(96, 320);
let rev = if proj.item(id).is_some() && id.0 < PREVIEW_BASE { app.item_revision(id) } else { 0 };
let key = FrameKey { target: Target::Item(id), frame, size: width, revision: rev, draft: false };
let name = format!("mbthumb-{}-{}-{}", id.0, frame, width);
let tex = if let Some(img) = app.frames.get(&key) {
let tid = app.texture_for(ctx, &name, key, &img);
Some((tid, vec2(img.w as f32, img.h as f32)))
} else {
app.frames.request(key, rate.tick_of(frame), width as f32 / src_w.max(1) as f32, &proj, 40);
app.texture_existing(&name)
};
match tex {
Some((tid, sz)) => {
ui.painter().image(tid, 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);
true
}
None => false,
}
}
// ------------------------------------------------------------------------------------ menu, dialog
/// The Media Browser's ≡ menu. Returns true to close it.
pub fn panel_menu(app: &mut FilmcraftApp, ui: &mut egui::Ui) -> bool {
let ctx = ui.ctx().clone();
let prefs = app.session.prefs.media_browser.clone();
let dir = mb::current_dir(&app.session);
let has_sel = !app.session.browser.selection.is_empty();
let mut close = false;
let item = |app: &mut FilmcraftApp, ui: &mut egui::Ui, id: &str, label: &str, enabled: bool, checked: Option<bool>, shortcut: &str| -> bool {
let b = match checked {
Some(c) => egui::Button::selectable(c, label),
None => egui::Button::new(label),
};
let r = ui.add_enabled(enabled, b.shortcut_text(shortcut));
app.auto.add(&format!("mediaBrowser.menu.{id}"), r.rect, label);
r.clicked()
};
if item(app, ui, "editColumns", tl!("Edit Columns…"), true, None, "") {
app.ui.media_browser.edit_columns = Some(prefs.columns.clone());
close = true;
}
if item(app, ui, "importAsImageSequence", tl!("Import as Image Sequence"), true, Some(prefs.import_as_image_sequence), "") {
exec(app, &ctx, "mediaBrowser.settings", json!({"importAsImageSequence": !prefs.import_as_image_sequence}));
close = true;
}
if item(app, ui, "hoverScrub", tl!("Hover Scrub"), true, Some(prefs.hover_scrub), "") {
exec(app, &ctx, "mediaBrowser.settings", json!({"hoverScrub": !prefs.hover_scrub}));
close = true;
}
item(app, ui, "newPanel", tl!("New Media Browser Panel"), false, None, "");
let mprefs = app.session.prefs.media.clone();
if item(app, ui, "createFolderForImportedProjects", tl!("Create Folder For Imported Projects"), true, Some(mprefs.create_folder_for_imported_projects), "")
{
let mut p = app.session.prefs.clone();
p.media.create_folder_for_imported_projects = !mprefs.create_folder_for_imported_projects;
let _ = app.session.set_prefs(p);
close = true;
}
if item(app, ui, "allowDuplicateMedia", tl!("Allow Duplicate Media During Project Import"), true, Some(mprefs.allow_duplicate_media), "") {
let mut p = app.session.prefs.clone();
p.media.allow_duplicate_media = !mprefs.allow_duplicate_media;
let _ = app.session.set_prefs(p);
close = true;
}
if item(app, ui, "refresh", tl!("Refresh"), true, None, "") {
refresh(&ctx);
app.session.browser.probes.clear();
close = true;
}
ui.separator();
let fav = prefs.favorites.contains(&dir);
if item(app, ui, "favorite", if fav { tl!("Remove from Favorites") } else { tl!("Add to Favorites") }, true, None, "") {
exec(app, &ctx, "mediaBrowser.favorite", json!({"remove": fav}));
close = true;
}
if item(app, ui, "clearRecent", tl!("Clear Recent Directories"), !prefs.recent.is_empty(), None, "") {
exec(app, &ctx, "mediaBrowser.clearRecent", json!({}));
close = true;
}
if item(app, ui, "import", tl!("Import"), has_sel, None, "") {
exec(app, &ctx, "mediaBrowser.import", json!({}));
close = true;
}
if item(app, ui, "openInSource", tl!("Open In Source Monitor"), has_sel, None, "Shift+O") {
exec(app, &ctx, "mediaBrowser.openInSource", json!({}));
close = true;
}
close
}
/// Edit Columns… dialog.
pub fn dialogs(app: &mut FilmcraftApp, ctx: &egui::Context) {
let Some(mut cols) = app.ui.media_browser.edit_columns.clone() else { return };
let mut close = false;
let mut ok = false;
egui::Window::new(tl!("Edit Columns"))
.id(egui::Id::unique("mb-edit-columns"))
.collapsible(false)
.resizable(false)
.pivot(Align2::CENTER_CENTER)
.default_pos(crate::widgets::dialog_center(ctx))
.show(ctx, |ui| {
let mut mv: Option<(usize, isize)> = None;
for c in mb::ALL_COLUMNS {
ui.horizontal(|ui| {
let mut on = cols.iter().any(|x| x == c);
let r = ui.add_enabled(c != "Name", egui::Checkbox::new(&mut on, crate::i18n::t(c)));
app.auto.add(&format!("mediaBrowser.columns.{c}"), r.rect, c);
if r.changed() {
if on {
cols.push(c.to_string());
} else {
cols.retain(|x| x != c);
}
}
if let Some(i) = cols.iter().position(|x| x == c).filter(|i| *i > 0) {
if ui.add_enabled(i > 1, egui::Button::new("▲").small()).clicked() {
mv = Some((i, -1));
}
if ui.add_enabled(i + 1 < cols.len(), egui::Button::new("▼").small()).clicked() {
mv = Some((i, 1));
}
}
});
}
if let Some((i, d)) = mv {
cols.swap(i, (i as isize + d) as usize);
}
ui.separator();
ui.horizontal(|ui| {
let r = ui.button(tl!("Cancel"));
app.auto.add("mediaBrowser.columns.cancel", r.rect, "Cancel");
close |= r.clicked();
let r = ui.button(tl!("OK"));
app.auto.add("mediaBrowser.columns.ok", r.rect, "OK");
ok = r.clicked();
});
});
if ok {
let r = app.session.execute("mediaBrowser.settings", json!({"columns": cols}));
if let Err(e) = r {
app.ui.status = e.to_string();
}
close = true;
}
app.ui.media_browser.edit_columns = if close || crate::widgets::escape_closes(ctx) { None } else { Some(cols) };
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dragging_several_files_carries_all_of_them() {
let all = file_drag_items(&[ItemId(7)], &[11, 12]);
assert_eq!(all, vec![ItemId(7), ItemId(11), ItemId(12)]);
assert_eq!(file_drag_items(&[], &[3]), vec![ItemId(3)]);
assert!(file_drag_items(&[], &[]).is_empty());
}
}
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.