f67d38b35cc5
tools.rs
//! The Tools panel. The buttons run along the panel's longer side and wrap onto further lines when
//! it is too short to hold them. Grouped tools show a small flyout triangle; right-click, a long
//! press or pressing and dragging opens the group to pick another tool.
use egui::{Rect, Sense, pos2, vec2};
use crate::FilmcraftApp;
use crate::icons;
use crate::state::Tool;
const SIZE: f32 = 32.0;
const GAP: f32 = 4.0;
/// Where the `i`th of `n` buttons goes: in a line along the longer side of `rect`, wrapping onto
/// further lines as the panel's length needs, the lines centred across it. `None` when the panel
/// has no room for it.
fn button_pos(rect: Rect, i: usize, n: usize) -> Option<egui::Pos2> {
let step = SIZE + GAP;
let horizontal = rect.width() > rect.height();
let (along, across) = if horizontal { (rect.width(), rect.height()) } else { (rect.height(), rect.width()) };
let per_line = (along / step).floor() as usize;
// `n` lines take `n * step - GAP`
let room = ((across + GAP) / step).floor() as usize;
if per_line == 0 || room == 0 {
return None;
}
let line = i / per_line;
if line >= room {
return None;
}
let lines = n.div_ceil(per_line).min(room);
let start = (across - (lines as f32 * step - GAP)) / 2.0;
let (a, c) = (GAP + (i % per_line) as f32 * step, start + line as f32 * step);
Some(if horizontal { pos2(rect.min.x + a, rect.min.y + c) } else { pos2(rect.min.x + c, rect.min.y + a) })
}
fn shortcut_text(app: &FilmcraftApp, tool: Tool) -> Option<String> {
tool.command_id().and_then(|id| app.session.shortcuts.primary(id)).map(|keys| crate::menus::shortcut_text(&keys))
}
fn tooltip(app: &FilmcraftApp, tool: Tool) -> String {
let label = app.ui.language.tr(tool.label());
match shortcut_text(app, tool) {
Some(keys) => format!("{label} ({keys})"),
None => label.to_owned(),
}
}
fn flyout_label(app: &FilmcraftApp, tool: Tool) -> String {
let label = app.ui.language.tr(tool.label());
match shortcut_text(app, tool) {
Some(keys) => format!("{label} {keys}"),
None => label.to_owned(),
}
}
pub fn show(app: &mut FilmcraftApp, ui: &mut egui::Ui, rect: Rect) {
let t = app.tokens;
let held_id = egui::Id::unique("tools-held");
if ui.input(|i| i.pointer.any_pressed()) {
ui.data_mut(|d| d.remove::<egui::Id>(held_id));
}
let groups = Tool::groups();
let count = groups.len();
for (i, group) in groups.into_iter().enumerate() {
let Some(at) = button_pos(rect, i, count) else { break };
let current = if group.contains(&app.ui.tool) { app.ui.tool } else { group[0] };
let r = Rect::from_min_size(at, vec2(SIZE, SIZE));
let tip = tooltip(app, current);
let resp = ui.interact(r, egui::Id::unique(("tool", format!("{:?}", group[0]))), Sense::click_and_drag()).on_hover_text(tip);
resp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, resp.enabled(), app.ui.tool == current, current.label()));
for tl in &group {
if *tl == current {
app.auto.add_response(&format!("tools.{tl:?}"), &resp, tl.label());
} else {
// Hidden group alternatives remain click aliases, not separate focus targets.
app.auto.add(&format!("tools.{tl:?}"), r, tl.label());
}
}
let active = group.contains(&app.ui.tool);
if active {
ui.painter().rect_filled(Rect::from_center_size(r.center(), vec2(26.0, 26.0)), 4.0, t.accent);
} else if resp.hovered() {
ui.painter().rect_filled(r, 4.0, t.hover);
}
icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(17.0, 17.0)), current.icon(), if active { egui::Color32::WHITE } else { t.icon });
if resp.has_focus() {
ui.painter().rect_stroke(r.shrink(2.0), 4.0, egui::Stroke::new(1.5, t.focus), egui::StrokeKind::Inside);
}
if group.len() > 1 {
let c = r.right_bottom() - vec2(3.0, 3.0);
ui.painter().add(egui::Shape::convex_polygon(vec![c, c - vec2(5.0, 0.0), c - vec2(0.0, 5.0)], t.text_dim, egui::Stroke::NONE));
}
let held = ui.data(|d| d.get_temp::<egui::Id>(held_id)) == Some(resp.id);
if resp.clicked() && !held {
app.ui.tool = current;
}
if group.len() > 1 {
let held_for = resp.is_pointer_button_down_on().then(|| ui.input(|i| i.pointer.press_start_time().map(|s| i.time - s))).flatten();
if let Some(seconds) = held_for
&& seconds < 0.35
{
ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(0.35 - seconds));
}
// dragging off the press (egui's few-point drag threshold) opens it at once, without
// waiting for the long press
let long_press = (held_for.is_some_and(|seconds| seconds >= 0.35) || resp.drag_started()) && !held;
let command = if resp.secondary_clicked() || long_press {
if long_press {
ui.data_mut(|d| d.insert_temp(held_id, resp.id));
}
Some(egui::SetOpenCommand::Bool(true))
} else if resp.clicked() && !held {
Some(egui::SetOpenCommand::Bool(false))
} else {
None
};
let close_behavior = if held && resp.clicked() { egui::PopupCloseBehavior::IgnoreClicks } else { egui::PopupCloseBehavior::CloseOnClickOutside };
egui::Popup::menu(&resp).open_memory(command).close_behavior(close_behavior).show(|ui| {
for tl in &group {
let row = ui.selectable_label(app.ui.tool == *tl, flyout_label(app, *tl));
app.auto.add_response(&format!("tools.select.{tl:?}"), &row, tl.label());
// letting go over a row of a flyout this press opened picks that tool
let released_on = held && ui.input(|i| i.pointer.primary_released() && i.pointer.interact_pos().is_some_and(|p| row.rect.contains(p)));
if row.clicked() || released_on {
app.ui.tool = *tl;
ui.close();
}
}
});
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tool_hints_follow_the_active_shortcut_and_hide_cleared_keys() {
let mut app = FilmcraftApp::new(filmcraft_engine::Session::default());
let modified = if cfg!(target_os = "macos") { "⇧⌘K" } else { "Ctrl+Shift+K" };
for (tool, command, default, keys, display) in
[(Tool::Razor, "tool.razor", "C", "S", "S"), (Tool::TrackSelectBackward, "tool.trackSelectBackward", "Shift+A", "Cmd+Shift+K", modified)]
{
let label = app.ui.language.tr(tool.label()).to_owned();
assert_eq!(tooltip(&app, tool), format!("{label} ({})", crate::menus::shortcut_text(default)));
app.session.execute("shortcuts.set", serde_json::json!({"command": command, "keys": keys})).unwrap();
assert_eq!(tooltip(&app, tool), format!("{label} ({display})"));
assert_eq!(flyout_label(&app, tool), format!("{label} {display}"));
app.session.execute("shortcuts.clear", serde_json::json!({"command": command})).unwrap();
assert_eq!(tooltip(&app, tool), label);
assert_eq!(flyout_label(&app, tool), label);
}
}
fn frame(app: &mut FilmcraftApp, ctx: &egui::Context, time: f64, events: Vec<egui::Event>) {
app.auto.begin_frame();
let mut out = ctx.run_ui(
egui::RawInput { time: Some(time), events, screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(1000.0, 800.0))), ..Default::default() },
|ui| show(app, ui, Rect::from_min_size(egui::Pos2::ZERO, vec2(42.0, 700.0))),
);
out.textures_delta.clear();
}
fn center_of(app: &FilmcraftApp, id: &str) -> Option<egui::Pos2> {
let [x, y, w, h] = app.auto.elements.iter().find(|w| w.id == id)?.rect;
Some(egui::pos2(x + w / 2.0, y + h / 2.0))
}
fn primary(pos: egui::Pos2, pressed: bool) -> egui::Event {
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }
}
/// The panel shown twice, then the button pressed on the Type tool group and dragged by `by`
/// within 0.1 s, well before a long press.
fn press_and_drag_type(by: egui::Vec2) -> (FilmcraftApp, egui::Context) {
let mut app = FilmcraftApp::new(filmcraft_engine::Session::default());
let ctx = egui::Context::default();
crate::theme::install(&ctx, &app.tokens);
frame(&mut app, &ctx, 0.0, vec![]);
frame(&mut app, &ctx, 0.1, vec![]);
let at = center_of(&app, "tools.Type").unwrap();
frame(&mut app, &ctx, 1.0, vec![egui::Event::PointerMoved(at), primary(at, true)]);
frame(&mut app, &ctx, 1.05, vec![egui::Event::PointerMoved(at + by)]);
frame(&mut app, &ctx, 1.1, vec![]);
(app, ctx)
}
fn positions(width: f32, height: f32) -> Vec<Option<egui::Pos2>> {
let rect = Rect::from_min_size(egui::Pos2::ZERO, vec2(width, height));
(0..8).map(|i| button_pos(rect, i, 8)).collect()
}
#[test]
fn a_tall_panel_is_one_column_and_a_wide_one_is_one_row() {
let column = positions(42.0, 700.0);
assert!(column.iter().all(|p| p.is_some_and(|p| p.x == 5.0)), "centred across a 42 wide panel: {column:?}");
assert_eq!(column[1].map(|p| p.y), Some(40.0));
let row = positions(700.0, 42.0);
assert!(row.iter().all(|p| p.is_some_and(|p| p.y == 5.0)), "{row:?}");
assert_eq!(row[1].map(|p| p.x), Some(40.0));
}
#[test]
fn a_short_panel_wraps_onto_further_lines_and_every_button_is_reachable() {
// 150 wide by 80 tall: four to a line, and room for two lines
let rect = Rect::from_min_size(egui::Pos2::ZERO, vec2(150.0, 80.0));
let all: Vec<_> = (0..8).filter_map(|i| button_pos(rect, i, 8)).collect();
assert_eq!(all.len(), 8);
for p in &all {
assert!(rect.contains_rect(Rect::from_min_size(*p, vec2(SIZE, SIZE))), "{p:?} is outside {rect:?}");
}
let distinct: std::collections::HashSet<_> = all.iter().map(|p| (p.x as i32, p.y as i32)).collect();
assert_eq!(distinct.len(), 8, "no two buttons overlap");
}
#[test]
fn a_narrow_panel_holds_a_second_column_when_the_buttons_fit_across_it() {
// 68 wide by 150 tall: two columns of 32 with a 4 gap fit, four buttons to a column
let rect = Rect::from_min_size(egui::Pos2::ZERO, vec2(68.0, 150.0));
let all: Vec<_> = (0..8).filter_map(|i| button_pos(rect, i, 8)).collect();
assert_eq!(all.len(), 8);
for p in &all {
assert!(rect.contains_rect(Rect::from_min_size(*p, vec2(SIZE, SIZE))), "{p:?} is outside {rect:?}");
}
let distinct: std::collections::HashSet<_> = all.iter().map(|p| (p.x as i32, p.y as i32)).collect();
assert_eq!(distinct.len(), 8, "no two buttons overlap");
assert_eq!(all.iter().map(|p| p.x as i32).collect::<std::collections::BTreeSet<_>>().len(), 2);
}
#[test]
fn a_panel_with_no_room_for_a_button_gives_none_and_never_panics() {
assert!(button_pos(Rect::from_min_size(egui::Pos2::ZERO, vec2(0.0, 0.0)), 0, 8).is_none());
assert!(button_pos(Rect::from_min_size(egui::Pos2::ZERO, vec2(30.0, 30.0)), 5, 8).is_none());
let _ = button_pos(Rect::from_min_size(egui::Pos2::ZERO, vec2(f32::NAN, 50.0)), 1, 8);
}
#[test]
fn dragging_off_a_grouped_tool_opens_its_flyout_and_letting_go_on_a_row_picks_it() {
let (mut app, ctx) = press_and_drag_type(vec2(-6.0, 3.0));
let row = center_of(&app, "tools.select.VerticalType").expect("the drag opened the flyout before a long press");
frame(&mut app, &ctx, 1.15, vec![egui::Event::PointerMoved(row)]);
frame(&mut app, &ctx, 1.2, vec![primary(row, false)]);
frame(&mut app, &ctx, 1.25, vec![]);
assert_eq!(app.ui.tool, Tool::VerticalType);
assert!(center_of(&app, "tools.select.VerticalType").is_none(), "picking a tool closes the flyout");
}
#[test]
fn letting_go_of_a_dragged_open_flyout_elsewhere_leaves_it_open() {
let (mut app, ctx) = press_and_drag_type(vec2(5.0, 5.0));
let away = pos2(600.0, 700.0);
frame(&mut app, &ctx, 1.15, vec![egui::Event::PointerMoved(away)]);
frame(&mut app, &ctx, 1.2, vec![primary(away, false)]);
frame(&mut app, &ctx, 1.25, vec![]);
assert_eq!(app.ui.tool, Tool::Selection);
let row = center_of(&app, "tools.select.VerticalType").expect("the flyout stays open, as after a long press");
// and a click on one of its rows still picks it
frame(&mut app, &ctx, 2.0, vec![egui::Event::PointerMoved(row), primary(row, true)]);
frame(&mut app, &ctx, 2.05, vec![primary(row, false)]);
assert_eq!(app.ui.tool, Tool::VerticalType);
}
#[test]
fn a_right_click_on_a_grouped_tool_still_opens_its_flyout() {
let mut app = FilmcraftApp::new(filmcraft_engine::Session::default());
let ctx = egui::Context::default();
crate::theme::install(&ctx, &app.tokens);
frame(&mut app, &ctx, 0.0, vec![]);
frame(&mut app, &ctx, 0.1, vec![]);
let at = center_of(&app, "tools.Type").unwrap();
let secondary = |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Secondary, pressed, modifiers: Default::default() };
frame(&mut app, &ctx, 1.0, vec![egui::Event::PointerMoved(at), secondary(true)]);
frame(&mut app, &ctx, 1.05, vec![secondary(false)]);
frame(&mut app, &ctx, 1.1, vec![]);
assert!(center_of(&app, "tools.select.VerticalType").is_some());
assert_eq!(app.ui.tool, Tool::Selection);
}
#[test]
fn long_press_type_selects_vertical_without_selecting_on_release() {
let mut app = FilmcraftApp::new(filmcraft_engine::Session::default());
let ctx = egui::Context::default();
crate::theme::install(&ctx, &app.tokens);
frame(&mut app, &ctx, 0.0, vec![]);
frame(&mut app, &ctx, 0.1, vec![]);
let center = |element: &crate::automation::Element| {
let [x, y, w, h] = element.rect;
egui::pos2(x + w / 2.0, y + h / 2.0)
};
let at = center(app.auto.elements.iter().find(|w| w.id == "tools.Type").unwrap());
let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
frame(&mut app, &ctx, 1.0, vec![egui::Event::PointerMoved(at), pointer(at, true)]);
frame(&mut app, &ctx, 1.36, vec![]);
frame(&mut app, &ctx, 1.4, vec![pointer(at, false)]);
frame(&mut app, &ctx, 1.45, vec![]);
assert_eq!(app.ui.tool, Tool::Selection);
let row = center(app.auto.elements.iter().find(|w| w.id == "tools.select.VerticalType").unwrap());
frame(&mut app, &ctx, 2.0, vec![egui::Event::PointerMoved(row), pointer(row, true)]);
frame(&mut app, &ctx, 2.05, vec![pointer(row, false)]);
assert_eq!(app.ui.tool, Tool::VerticalType);
frame(&mut app, &ctx, 2.1, vec![]);
assert!(!app.auto.elements.iter().any(|w| w.id == "tools.select.VerticalType"));
app.session.execute("file.openDemoProject", serde_json::json!({})).unwrap();
let pic = Rect::from_min_size(pos2(100.0, 100.0), vec2(480.0, 270.0));
for (time, pressed) in [(2.5, None), (2.6, None), (3.0, Some(true)), (3.05, Some(false))] {
let mut out = ctx.run_ui(
egui::RawInput {
time: Some(time),
events: pressed.map(|pressed| vec![egui::Event::PointerMoved(pic.center()), pointer(pic.center(), pressed)]).unwrap_or_default(),
screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(1000.0, 800.0))),
..Default::default()
},
|ui| {
crate::panels::graphics::monitor_overlay(&mut app, ui, pic, (1920, 1080));
},
);
out.textures_delta.clear();
}
let edit = app.ui.gfx_edit.as_ref().unwrap();
let sequence = app.session.active_sequence().unwrap();
let (_, item) = sequence.find_item(filmcraft_project::ClipId(edit.clip)).unwrap();
let effect_index = filmcraft_project::graphic::layer_indices(&item.effects)[edit.layer];
let layer = filmcraft_project::graphic::eval_layer(&item.effects[effect_index], filmcraft_time::Tick::ZERO, (1920, 1080)).unwrap();
let filmcraft_project::graphic::LayerContent::Text(text) = layer.content else { panic!("text layer expected") };
assert!(text.vertical, "the actual monitor click dispatches the existing vertical text command");
}
}
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.