Files
AniCraft/src/dialogs.rs
T

1180 lines
64 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Modal and floating dialogs: destructive-action confirmation (ADR 0004), the unsaved-changes
//! guard on close, the command palette (Ctrl+K) and the keyboard-shortcut sheet (F1).
use crate::app::{App, Tool};
use crate::prefs::{FontChoice, RenderMode, StageRenderer};
use crate::theme::{T, Type, text, with_type};
use anicraft_engine::confirm::Confirmation;
use anicraft_engine::{CommandSpec, commands};
use crate::a11y::{self, Named};
use egui::Key;
use serde_json::{Value, json};
/// A command waiting for the user's yes/no.
pub struct PendingConfirm {
pub id: String,
pub params: Value,
pub conf: Confirmation,
pub dont_ask: bool,
}
#[derive(Default)]
pub struct Palette {
pub query: String,
pub selected: usize,
/// What F1 opens the guide at: the chosen entry (ADR 0096), as of the last frame.
pub help: Option<crate::context_help::Subject>,
}
pub fn show_all(app: &mut App, ctx: &egui::Context) {
preferences(app, ctx);
licenses(app, ctx);
confirm_modal(app, ctx);
close_modal(app, ctx);
palette(app, ctx);
shortcut_sheet(app, ctx);
}
fn danger_button(label: &str) -> egui::Button<'static> {
egui::Button::new(text(Type::Body, label).color(T.on_fill).strong()).fill(T.danger).min_size(egui::vec2(120.0, crate::theme::TARGET + 4.0))
}
fn confirm_modal(app: &mut App, ctx: &egui::Context) {
let Some(p) = &mut app.confirm else { return };
let mut decision: Option<bool> = None;
let irreversible = p.conf.irreversible;
egui::Modal::new(egui::Id::new("confirm")).show(ctx, |ui| {
ui.set_width(420.0);
ui.add_space(4.0);
// The engine's English, translated when a catalog has that exact text.
ui.label(text(Type::Title, crate::i18n::t_dyn(&p.conf.title)));
ui.add_space(6.0);
ui.label(text(Type::Body, crate::i18n::t_dyn(&p.conf.message)).color(T.text_dim));
ui.add_space(4.0);
if irreversible {
ui.label(text(Type::Caption, tr!("This cannot be undone.")).color(T.error));
} else {
crate::theme::checkbox(ui, &mut p.dont_ask, text(Type::Caption, tr!("Don't ask again this session")).color(T.text_dim));
}
ui.add_space(10.0);
ui.horizontal(|ui| {
if ui.add(egui::Button::new(tr!("Cancel")).min_size(egui::vec2(96.0, crate::theme::TARGET + 4.0))).clicked() {
decision = Some(false);
}
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(danger_button(&crate::i18n::t_dyn(&p.conf.action))).clicked() {
decision = Some(true);
}
});
});
ui.add_space(2.0);
let hint = if irreversible { tr!("Esc cancels · click the red button to proceed") } else { tr!("Enter confirms · Esc cancels") };
ui.label(text(Type::Caption, hint));
});
// Irreversible actions are never one keystroke away: Enter does not confirm them.
let (esc, enter) = ctx.input_mut(|i| (i.consume_key(egui::Modifiers::NONE, Key::Escape), i.consume_key(egui::Modifiers::NONE, Key::Enter)));
if esc {
decision = Some(false);
} else if enter && !irreversible {
decision = Some(true);
}
match decision {
Some(true) => {
if let Some(p) = app.confirm.take() {
if p.dont_ask {
app.skip_confirm.insert(p.id.clone());
}
let mut params = p.params;
if let Some(obj) = params.as_object_mut() {
obj.insert("confirm".into(), json!(true));
}
app.perform(&p.id, params);
}
}
Some(false) => {
app.confirm = None;
app.status_ok(tr!("Cancelled"));
}
None => {}
}
}
fn close_modal(app: &mut App, ctx: &egui::Context) {
if !app.tabs.asking() || app.prompt.is_some() || app.confirm.is_some() {
return;
}
use crate::tabs::Answer as Choice;
// The document a closing tab asks about, or every unsaved one when the window closes: one
// question for all of them (ADR 0112).
let names = crate::tabs::asked_about(app);
let Some(name) = names.first().cloned() else { return };
let several = names.len() > 1;
let mut choice = None;
egui::Modal::new(egui::Id::new("close_guard")).show(ctx, |ui| {
ui.set_width(440.0);
if several {
ui.label(text(Type::Title, trn!("Save changes to {n} document before closing?", "Save changes to {n} documents before closing?", names.len())));
ui.add_space(6.0);
// Their own names, as on their tabs (the first few of a long list).
for n in names.iter().take(8) {
ui.label(text(Type::Body, format!("• {n}")));
}
if names.len() > 8 {
ui.label(text(Type::Body, trn!("and {n} more", "and {n} more", names.len() - 8)).color(T.text_dim));
}
} else {
ui.label(text(Type::Title, tr!("Save changes to “{name}” before closing?", name = name)));
}
ui.add_space(6.0);
ui.label(text(Type::Body, tr!("If you don't save, your changes since the last save will be lost.")).color(T.text_dim));
ui.add_space(12.0);
ui.horizontal(|ui| {
if ui.add(danger_button(tr!("Don't Save"))).clicked() {
choice = Some(Choice::Discard);
}
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(egui::Button::new(text(Type::Body, if several { tr!("Save All") } else { tr!("Save") }).strong().color(T.on_fill)).fill(T.accent).min_size(egui::vec2(96.0, crate::theme::TARGET + 4.0))).clicked() {
choice = Some(Choice::Save);
}
if ui.add(egui::Button::new(tr!("Cancel")).min_size(egui::vec2(96.0, crate::theme::TARGET + 4.0))).clicked() {
choice = Some(Choice::Cancel);
}
});
});
ui.label(text(Type::Caption, tr!("Enter saves · Esc cancels")));
});
let (esc, enter) = ctx.input_mut(|i| (i.consume_key(egui::Modifiers::NONE, Key::Escape), i.consume_key(egui::Modifiers::NONE, Key::Enter)));
if esc {
choice = Some(Choice::Cancel);
} else if enter {
choice = Some(Choice::Save);
}
// Save saves each (a document without a file asks for a name); Don't Save gives the changes
// up; Cancel leaves everything open (`tabs::tick` does the rest).
if let Some(choice) = choice {
crate::tabs::answer(app, choice);
}
}
// ----- command palette --------------------------------------------------------------------------
#[derive(Clone)]
enum Entry {
Command(CommandSpec),
Tool(Tool),
View(&'static str, &'static str, fn(&mut App)),
/// An installed plug-in: `(id, menu label)`.
Plugin(String, String),
}
impl Entry {
/// What F1 on it opens in the guide (ADR 0096); view entries have no section of their own.
fn help(&self) -> Option<crate::context_help::Subject> {
use crate::context_help::Subject;
match self {
Entry::Command(c) => Some(Subject::Command(c.id.to_string())),
Entry::Tool(t) => Some(Subject::Tool(*t)),
Entry::View(..) => None,
Entry::Plugin(..) => Some(Subject::Topic("plugins.md#running-a-plug-in")),
}
}
/// The menu path to the entry, in the interface language (`local`) or in English, so
/// either finds it.
fn title(&self, local: bool) -> String {
let t = |s: &'static str| if local { crate::i18n::t(s) } else { s };
let path = |parts: &[&'static str], last: &str| {
let mut v: Vec<&str> = parts.iter().map(|p| t(p)).collect();
v.push(last);
v.join(" › ")
};
match self {
Entry::Command(c) => {
let label = if local { crate::i18n::t_cmd(c.id, c.label) } else { c.label };
path(&c.menu.split('/').filter(|m| !m.is_empty()).collect::<Vec<_>>(), label)
}
Entry::Tool(tool) => path(&[tr_noop!("Tool")], t(tool.label())),
Entry::View(name, _, _) => path(&[tr_noop!("View")], t(name)),
// The plug-in's own name: not ours to translate.
Entry::Plugin(_, label) => path(&[tr_noop!("Commands"), tr_noop!("Plug-ins")], label),
}
}
fn shortcut(&self, km: &crate::keymap::Keymap) -> String {
match self {
Entry::Command(c) => km.primary(c.id).unwrap_or("").to_string(),
Entry::Tool(t) => km.primary(crate::keymap::tool_id(*t)).unwrap_or("").to_string(),
Entry::View(_, sc, _) => (*sc).to_string(),
Entry::Plugin(..) => String::new(),
}
}
}
/// Commands the palette can run without extra input (everything optional, or prompted).
fn runnable(c: &CommandSpec) -> bool {
if matches!(c.id, "file.open" | "file.recovery_list" | "file.save_as" | "file.import" | "file.export_png" | "file.export_gif" | "file.export_apng" | "file.export_webp" | "file.export_svg" | "file.export_sprite_sheet" | "file.export_video" | "file.export_lottie" | "file.export_html" | "file.export_png_sequence" | "modify.convert_to_symbol" | "layer.rename" | "scene.rename" | "plugin.install") {
return true;
}
let inner = c.params.trim().trim_start_matches('{').trim_end_matches('}');
inner.split(',').map(str::trim).filter(|k| !k.is_empty()).all(|k| k.split(':').next().is_some_and(|name| name.trim().ends_with('?')))
}
fn entries() -> Vec<Entry> {
let mut v: Vec<Entry> = commands().into_iter().filter(runnable).map(Entry::Command).collect();
v.extend(Tool::ALL.iter().map(|t| Entry::Tool(*t)));
// English keys, translated where they are drawn (`Entry::title`).
v.push(Entry::View(tr_noop!("Play / Stop"), "Enter", App::toggle_play));
v.push(Entry::View(tr_noop!("Onion Skin"), "", crate::onion::toggle_ghosts));
v.push(Entry::View(tr_noop!("Preview Through Camera"), "", App::toggle_camera_preview));
v.push(Entry::View(tr_noop!("Fit Stage in Window"), "Ctrl+0", |a| a.view.fit = true));
v.push(Entry::View(tr_noop!("Keyboard Shortcuts"), "Ctrl+Alt+Shift+K", |a| a.show_shortcuts = true));
v.push(Entry::View(tr_noop!("User Guide"), "", App::open_user_guide));
v.push(Entry::View(tr_noop!("Search the User Guide"), "", App::open_guide_search));
v.push(Entry::View(tr_noop!("Project Files & Docs"), "", |a| a.show_files = true));
v.push(Entry::View(tr_noop!("Licenses & Notices"), "", |a| a.show_licenses = true));
v.push(Entry::View(tr_noop!("Preferences"), "Ctrl+U", App::open_prefs));
v
}
/// Subsequence match score (higher is better); `None` when not all query chars appear in order.
fn fuzzy(query: &str, text: &str) -> Option<i32> {
let text = text.to_lowercase();
let mut score = 0;
let mut last = 0usize;
let mut chars = text.char_indices();
for q in query.to_lowercase().chars().filter(|c| !c.is_whitespace()) {
let (i, _) = chars.by_ref().find(|(_, c)| *c == q)?;
score += if i == last { 3 } else { 1 };
if i == 0 || text[..i].ends_with([' ', '›', '.', '_']) {
score += 4;
}
last = i + q.len_utf8();
}
Some(score - (text.len() as i32) / 16)
}
fn palette(app: &mut App, ctx: &egui::Context) {
let km = &app.keymap;
let Some(p) = &mut app.palette else { return };
let mut all = entries();
all.extend(app.s.plugins.list().filter(|p| crate::plugins_ui::is_command(p)).map(|p| Entry::Plugin(p.id().to_string(), crate::plugins_ui::label(p))));
// Found by its name in the interface language or in English, whichever matches better.
let mut matches: Vec<(i32, Entry, String)> =
all.into_iter().filter_map(|e| {
let key = e.shortcut(km);
let local = fuzzy(&p.query, &format!("{} {key}", e.title(true)));
let english = if crate::i18n::code() == crate::i18n::ENGLISH { None } else { fuzzy(&p.query, &format!("{} {key}", e.title(false))) };
local.max(english).map(|s| (s, e, key))
}).collect();
matches.sort_by_key(|m| std::cmp::Reverse(m.0));
matches.truncate(14);
p.selected = p.selected.min(matches.len().saturating_sub(1));
let (up, down, enter, esc) = ctx.input_mut(|i| {
(
i.consume_key(egui::Modifiers::NONE, Key::ArrowUp),
i.consume_key(egui::Modifiers::NONE, Key::ArrowDown),
i.consume_key(egui::Modifiers::NONE, Key::Enter),
i.consume_key(egui::Modifiers::NONE, Key::Escape),
)
});
if up {
p.selected = p.selected.saturating_sub(1);
}
if down && p.selected + 1 < matches.len() {
p.selected += 1;
}
let mut run: Option<Entry> = None;
let mut close = esc;
let selected = p.selected;
p.help = matches.get(selected).and_then(|(_, e, _)| e.help());
egui::Area::new(egui::Id::new("palette")).order(egui::Order::Foreground).anchor(egui::Align2::CENTER_TOP, [0.0, 70.0]).show(ctx, |ui| {
egui::Frame::popup(ui.style()).fill(T.panel_alt).inner_margin(egui::Margin::same(10)).show(ui, |ui| {
ui.set_width(560.0);
let r = ui.add(egui::TextEdit::singleline(&mut p.query).hint_text(tr!("Type a command, tool or setting…")).desired_width(f32::INFINITY).font(egui::TextStyle::Heading)).named(tr!("Command palette"));
r.request_focus();
if r.changed() {
p.selected = 0;
}
ui.add_space(6.0);
if matches.is_empty() {
ui.label(text(Type::Caption, tr!("No matching commands")));
}
for (i, (_, e, key)) in matches.iter().enumerate() {
let sel = i == selected;
let resp = ui
.horizontal(|ui| {
let lab = ui.selectable_label(sel, e.title(true));
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
ui.label(text(Type::Key, crate::platform::shortcut_label(key)));
});
lab
})
.inner;
if resp.clicked() {
run = Some(e.clone());
}
}
ui.add_space(4.0);
ui.label(text(Type::Caption, tr!("Up/Down choose · Enter run · Esc close")));
});
});
if enter {
run = matches.get(selected).map(|(_, e, _)| e.clone());
}
if run.is_some() {
close = true;
}
if close {
app.palette = None;
}
match run {
Some(Entry::Command(c)) => app.invoke(c.id),
Some(Entry::Tool(t)) => app.tool = t,
Some(Entry::View(_, _, f)) => f(app),
Some(Entry::Plugin(id, _)) => crate::plugins_ui::run_or_ask(app, &id),
None => {}
}
}
// ----- preferences ------------------------------------------------------------------------------
/// A font picker: the bundled default plus every installed family, filterable.
fn font_picker(ui: &mut egui::Ui, id: &str, name: &str, current: &FontChoice, families: Option<&[String]>, bundled: &str) -> Option<FontChoice> {
let mut picked = None;
let filter_id = egui::Id::new(("font_filter", id));
let shown = match current {
FontChoice::Bundled => tr!("Default ({font})", font = bundled),
FontChoice::System(name) => name.clone(),
};
egui::ComboBox::from_id_salt(id).width(260.0).selected_text(text(Type::Body, shown)).show_ui(ui, |ui| {
if ui.selectable_label(*current == FontChoice::Bundled, text(Type::Body, tr!("Default (bundled: {font})", font = bundled))).clicked() {
picked = Some(FontChoice::Bundled);
}
ui.separator();
match families {
None => {
ui.label(text(Type::Caption, tr!("Scanning installed fonts…")));
}
Some(list) => {
let mut filter: String = ui.ctx().data_mut(|d| d.get_temp(filter_id).unwrap_or_default());
ui.add(egui::TextEdit::singleline(&mut filter).hint_text(tr!("Filter fonts…")).desired_width(240.0)).set_name(tr!("Filter fonts"));
let f = filter.to_lowercase();
egui::ScrollArea::vertical().max_height(320.0).show(ui, |ui| {
for fam in list.iter().filter(|n| f.is_empty() || n.to_lowercase().contains(&f)) {
let on = matches!(current, FontChoice::System(n) if n == fam);
if ui.selectable_label(on, text(Type::Body, fam.as_str())).clicked() {
picked = Some(FontChoice::System(fam.clone()));
}
}
});
ui.ctx().data_mut(|d| d.insert_temp(filter_id, filter));
}
}
})
.response
.set_name(name);
picked
}
fn preferences(app: &mut App, ctx: &egui::Context) {
if !app.show_prefs {
return;
}
let mut open = true;
let mut p = app.prefs.clone();
let sys = app.system_fonts.clone();
let (bundled_ui, bundled_mono) = crate::theme::bundled_names();
let mut reset_confirms = false;
let mut about_act: Option<crate::desktop_ui::Act> = None;
let mut theme_act: Option<ThemeAct> = None;
let to_about = std::mem::take(&mut app.prefs_to_about);
let title = if crate::platform::OS == crate::platform::Os::Mac { tr!("Settings") } else { tr!("Preferences") };
let shown = crate::windows::new(ctx, title)
// An id of its own: the window keeps its place when the language changes.
.id(egui::Id::new("prefs_window"))
.open(&mut open)
.collapsible(false)
.resizable(false)
.pivot(egui::Align2::CENTER_CENTER)
.default_pos(ctx.content_rect().center())
.default_width(560.0)
.show(ctx, |ui| {
// Taller than small windows: the sections scroll, the footer stays.
let max_h = (ctx.content_rect().height() - 160.0).max(200.0);
egui::ScrollArea::vertical().max_height(max_h).auto_shrink([false, true]).show(ui, |ui| {
// A two-column form: labels in a fixed left column, controls and the notes that
// explain them in the right one.
use crate::theme::{FORM_LABEL_DIALOG as LW, Section, form_note, form_row, section};
// Under a radio button or checkbox, notes line up with its text, not its box.
// (`form_note` adds one item spacing after its indent, like a row's label column.)
let toggle_indent = (ui.spacing().icon_width + ui.spacing().icon_spacing - ui.spacing().item_spacing.x).max(0.0);
section(ui, "prefs_appearance", Section::Rule, tr!("Appearance"), None, |ui| {
// The interface language (ADR 0040): first, so someone who can't read the
// current one finds it at the top. Each language is named in itself.
form_row(ui, LW, tr!("Language"), |ui| {
let auto = crate::i18n::AUTO;
let current = if p.language == auto { tr!("System language ({name})", name = crate::i18n::system_choice()) } else { crate::i18n::name_of(&p.language).into_owned() };
egui::ComboBox::from_id_salt("pref_language").width(260.0).selected_text(text(Type::Body, current)).show_ui(ui, |ui| {
ui.selectable_value(&mut p.language, auto.to_string(), text(Type::Body, tr!("System language ({name})", name = crate::i18n::system_choice())));
ui.separator();
for (code, name) in crate::i18n::offered() {
ui.selectable_value(&mut p.language, code.to_string(), text(Type::Body, name));
}
})
.response
.set_name(tr!("Interface language"));
});
let note = if crate::i18n::offered().len() <= 2 {
tr!("This build has the interface in English only. Builds with translations list their languages here.")
} else {
tr!("Menus, panels and dialogs. Your documents, layer names and the command line stay as they are.")
};
form_note(ui, LW, text(Type::Caption, note));
ui.add_space(4.0);
form_row(ui, LW, tr!("Theme"), |ui| {
ui.vertical(|ui| {
// Follow system (ADR 0064), then each palette by hand, then your own
// themes (ADR 0117).
let was = if p.follows_system() {
ThemeChoice::System
} else {
match p.user_theme() {
Some(id) => ThemeChoice::Mine(id.to_string()),
None => ThemeChoice::BuiltIn(p.theme),
}
};
let mut choice = was.clone();
crate::theme::radio_value(ui, &mut choice, ThemeChoice::System, text(Type::Body, tr!("Follow system")));
// What following would show now, and why (ADR 0064, ADR 0077).
let look = app.system_look;
let says = match (look.high_contrast, look.dark) {
(Some(true), _) => tr!("Light or dark as your system's apps are, and high contrast while it asks for more contrast. It does now, so it is high contrast."),
(_, Some(false)) => tr!("Light or dark as your system's apps are, and high contrast while it asks for more contrast. Your system is light now."),
(_, Some(true)) => tr!("Light or dark as your system's apps are, and high contrast while it asks for more contrast. Your system is dark now."),
(_, None) => tr!("Light or dark as your system's apps are, and high contrast while it asks for more contrast. This system doesn't say whether it is light, so it is dark."),
};
form_note(ui, toggle_indent, text(Type::Caption, says));
ui.add_space(2.0);
for (palette, name, tip) in crate::theme::Palette::ALL {
crate::theme::radio_value(ui, &mut choice, ThemeChoice::BuiltIn(palette), text(Type::Body, crate::i18n::t(name)));
form_note(ui, toggle_indent, text(Type::Caption, crate::i18n::t(tip)));
ui.add_space(2.0);
}
// Yours, from the themes folder: the ones that pass their checks can
// be chosen; a refused one says why, naming what is at fault.
for entry in &app.themes.entries {
let file = entry.path.file_name().map(|f| f.to_string_lossy().into_owned()).unwrap_or_default();
match &entry.theme {
Ok(t) => {
crate::theme::radio_value(ui, &mut choice, ThemeChoice::Mine(entry.id.clone()), text(Type::Body, entry.name()));
let from = match &t.author {
Some(author) => tr!("Your theme, by {author}, from {file}.", author = author, file = file),
None => tr!("Your theme, from {file}.", file = file),
};
form_note(ui, toggle_indent, text(Type::Caption, from));
if let Some(first) = t.notes.first() {
let low = trn!("Low contrast in {n} place: {pair} is {ratio}:1.", "Low contrast in {n} places, such as {pair}, which is {ratio}:1.", t.notes.len(), pair = first.pair, ratio = format!("{:.1}", first.ratio));
form_note(ui, toggle_indent, text(Type::Caption, low));
}
}
Err(why) => {
ui.add_enabled_ui(false, |ui| {
let mut off = false;
crate::theme::radio_value(ui, &mut off, true, text(Type::Body, entry.name())).set_name(&tr!("{name} (refused)", name = entry.name()));
});
form_note(ui, toggle_indent, text(Type::Caption, tr!("{file} is not used. {why}", file = file, why = why.message())).color(T.error));
}
}
ui.add_space(2.0);
}
if app.themes.left_out > 0 {
form_note(ui, toggle_indent, text(Type::Caption, trn!("{n} more theme file in the folder is not listed.", "{n} more theme files in the folder are not listed.", app.themes.left_out)));
}
if choice != was {
p.theme_follows_system = Some(choice == ThemeChoice::System);
match choice {
ThemeChoice::System => {}
ThemeChoice::BuiltIn(palette) => {
p.theme = palette;
p.theme_file = None;
}
ThemeChoice::Mine(id) => {
// The palette it is based on: what shows if its file goes.
p.theme = app.themes.get(&id).and_then(|e| e.theme.as_ref().ok()).map_or(p.theme, |t| t.base);
p.theme_file = Some(id);
}
}
}
// Your themes folder: small files that name colours for the roles.
if app.themes_dir.is_some() {
ui.add_space(2.0);
ui.horizontal_wrapped(|ui| {
if ui.button(text(Type::Body, tr!("Open Themes Folder"))).on_hover_text(tr!("Shows the folder your own themes are kept in.")).clicked() {
theme_act = Some(ThemeAct::OpenFolder);
}
if ui.button(text(Type::Body, tr!("Reload"))).on_hover_text(tr!("Reads the themes folder again, so a file you changed shows at once.")).clicked() {
theme_act = Some(ThemeAct::Reload);
}
if ui.button(text(Type::Body, tr!("Export Current Theme"))).on_hover_text(tr!("Writes the look in use to the themes folder as a file to start your own from.")).clicked() {
theme_act = Some(ThemeAct::Export);
}
});
ui.add(egui::Label::new(text(Type::Caption, tr!("A theme is a small file that names colours for the interface's roles. A theme whose text would be hard to read is not used, and says which colours to change."))).wrap());
}
});
});
ui.add_space(4.0);
form_row(ui, LW, tr!("Interface font"), |ui| {
if let Some(c) = font_picker(ui, "pref_ui_font", tr!("Interface font"), &p.ui_font, sys.as_ref().map(|s| s.families.as_slice()), bundled_ui) {
p.ui_font = c;
}
});
form_row(ui, LW, tr!("Data font"), |ui| {
let list = sys.as_ref().map(|s| s.monospace.as_slice());
if let Some(c) = font_picker(ui, "pref_data_font", tr!("Data font"), &p.data_font, list, bundled_mono) {
p.data_font = c;
}
});
form_note(ui, LW, text(Type::Caption, tr!("The data font shows numbers, timecode, rulers and shortcuts; only monospaced families are listed so digits stay aligned.")));
ui.add_space(4.0);
form_row(ui, LW, tr!("Preview"), |ui| {
ui.vertical(|ui| {
ui.label(text(Type::Body, tr!("Layer names, menus and dialog text read like this.")));
ui.label(text(Type::Data, tr!("Frame {frame} · {seconds} s · X {x} Y {y} · {keys}", frame = "0042", seconds = "1.75", x = "1280.5", y = "720.0", keys = crate::platform::shortcut_label("Ctrl+Shift+S"))));
});
});
ui.add_space(4.0);
form_row(ui, LW, tr!("Interface scale"), |ui| {
let mut pct = p.ui_scale * 100.0;
let r = with_type(ui, Type::Data, |ui| {
a11y::slider(ui, &mut pct, (crate::prefs::SCALE_RANGE.start() * 100.0)..=(crate::prefs::SCALE_RANGE.end() * 100.0), tr!("Interface scale"), a11y::SliderLook { suffix: " %", step: Some(5.0), max_decimals: Some(0), ..Default::default() })
});
// Apply on release so the slider doesn't move under the pointer while dragging.
if r.drag_stopped() || (r.changed() && !r.dragged()) {
p.ui_scale = pct / 100.0;
}
});
});
section(ui, "prefs_stage", Section::Rule, tr!("Stage"), None, |ui| {
form_row(ui, LW, tr!("Rendering"), |ui| {
ui.vertical(|ui| {
for (mode, name, tip) in RenderMode::ALL {
crate::theme::radio_value(ui, &mut p.render_mode, mode, text(Type::Body, crate::i18n::t(name)));
form_note(ui, toggle_indent, text(Type::Caption, crate::i18n::t(tip)));
ui.add_space(2.0);
}
});
});
if crate::gpu_stage::AVAILABLE {
ui.add_space(4.0);
form_row(ui, LW, tr!("Renderer"), |ui| {
ui.vertical(|ui| {
for (choice, name, tip) in StageRenderer::ALL {
crate::theme::radio_value(ui, &mut p.stage_renderer, choice, text(Type::Body, crate::i18n::t(name)));
form_note(ui, toggle_indent, text(Type::Caption, crate::i18n::t(tip)));
ui.add_space(2.0);
}
});
});
use crate::gpu_stage::State;
let status = match app.stage_cache.gpu.state() {
State::Off => None,
State::Starting => Some(tr!("Starting the graphics card…").to_string()),
State::Running { adapter, direct: true } => Some(tr!("Drawing on {adapter}, straight into the window.", adapter = adapter)),
State::Running { adapter, direct: false } => Some(tr!("Drawing on {adapter}, then copied to the window (slower: the window's graphics device can't be shared).", adapter = adapter)),
State::Failed(why) => Some(tr!("The graphics card can't draw the stage, so the CPU does: {why}", why = why)),
State::Stopped { why, retry_at: Some(_) } => Some(tr!("The graphics card stopped drawing the stage, so the CPU does for now; AniCraft tries the graphics card again soon. It said: {why}", why = why)),
State::Stopped { why, retry_at: None } => Some(tr!("The graphics card stopped drawing the stage, so the CPU does for the rest of this session. It said: {why}", why = why)),
};
if crate::gpu_stage::wanted(p.stage_renderer) != p.stage_renderer {
form_note(ui, LW, text(Type::Caption, tr!("ANICRAFT_STAGE_RENDERER is set, and it takes precedence over this choice.")));
}
if let Some(s) = status {
form_note(ui, LW, text(Type::Caption, s));
}
}
// How the window itself is drawn (#207, #255): read when AniCraft starts.
let backends = crate::platform::window_backends(crate::platform::OS);
if !backends.is_empty() {
ui.add_space(4.0);
form_row(ui, LW, tr!("Window graphics"), |ui| {
ui.vertical(|ui| {
for &choice in backends {
let (name, tip) = choice.describe();
crate::theme::radio_value(ui, &mut p.window_backend, choice, text(Type::Body, crate::i18n::t(name)));
form_note(ui, toggle_indent, text(Type::Caption, crate::i18n::t(tip)));
ui.add_space(2.0);
}
});
});
form_note(ui, LW, text(Type::Caption, tr!("A change takes effect the next time AniCraft starts. If a way doesn't work, AniCraft starts with the next one.")));
if let Some(log) = crate::startup::log_path() {
form_note(ui, LW, text(Type::Caption, tr!("If AniCraft has trouble starting, this start-up log says why (attach it to a bug report):")));
form_note(ui, LW, text(Type::Path, log.display().to_string()));
}
}
});
section(ui, "prefs_timeline", Section::Rule, tr!("Timeline"), None, |ui| {
form_row(ui, LW, tr!("Extra start gap"), |ui| {
with_type(ui, Type::Data, |ui| {
ui.add(egui::DragValue::new(&mut p.timeline_start_gap).range(crate::prefs::GAP_RANGE).speed(0.5).max_decimals(0).suffix(" pt")).set_name(tr!("Extra start gap"));
});
});
form_note(ui, LW, text(Type::Caption, tr!("The timeline always leaves room before frame 1 for the playhead; this adds more. It stays the same at every zoom.")));
});
// Sound while you work (ADR 0095): the listener's, never the document's.
section(ui, "prefs_sound", Section::Rule, tr!("Sound"), None, |ui| {
form_row(ui, LW, tr!("Playback volume"), |ui| {
let mut pct = (p.sound_volume * 100.0).round();
if crate::a11y::slider(ui, &mut pct, 0.0..=100.0, tr!("Playback volume"), crate::a11y::SliderLook { suffix: " %", max_decimals: Some(0), step: Some(1.0), logarithmic: false }).changed() {
p.sound_volume = pct / 100.0;
}
});
form_row(ui, LW, tr!("Sounds"), |ui| {
ui.vertical(|ui| {
crate::theme::checkbox(ui, &mut p.sound_muted, text(Type::Body, tr!("Mute sounds")));
crate::theme::checkbox(ui, &mut p.audio_scrubbing, text(Type::Body, tr!("Audio scrubbing")));
form_note(ui, toggle_indent, text(Type::Caption, tr!("Dragging the playhead plays a short slice of the stream sounds under it. Volume and mute are for playback only: exports keep their sound.")));
});
});
});
// Test Movie in a window of its own, or inside the editor (ADR 0062).
section(ui, "prefs_test_movie", Section::Rule, tr!("Test Movie"), None, |ui| {
form_row(ui, LW, tr!("Window"), |ui| {
ui.vertical(|ui| {
crate::theme::checkbox(ui, &mut p.test_movie_window, text(Type::Body, tr!("Play Test Movie in a window of its own")));
let note = match crate::platform::movie_host(ui.ctx().embed_viewports(), true) {
crate::platform::MovieHost::Inside(why) => why.note().map(crate::i18n::t),
crate::platform::MovieHost::Window if !crate::platform::window_positions() => Some(tr!("Off: it floats inside the editor. On Wayland the desktop places the window, so it can't open where it was last.")),
crate::platform::MovieHost::Window => Some(tr!("Off: it floats inside the editor. The window opens where it was last.")),
};
if let Some(note) = note {
form_note(ui, toggle_indent, text(Type::Caption, note));
}
});
});
});
section(ui, "prefs_files", Section::Rule, tr!("Files"), None, |ui| {
form_row(ui, LW, tr!("File dialogs"), |ui| {
ui.vertical(|ui| {
crate::theme::checkbox(ui, &mut p.native_dialogs, text(Type::Body, tr!("Use the system's open and save dialogs")));
form_note(ui, toggle_indent, text(Type::Caption, tr!("Turn off on Linux desktops without an XDG desktop portal; AniCraft then asks for a path instead.")));
});
});
ui.add_space(4.0);
form_row(ui, LW, tr!("Autosave"), |ui| {
ui.vertical(|ui| {
crate::theme::checkbox(ui, &mut p.autosave, text(Type::Body, tr!("Keep a recovery copy of unsaved work")));
form_note(
ui,
toggle_indent,
text(Type::Caption, tr!("If AniCraft closes unexpectedly, the next start offers to restore it. Copies stay in the settings folder, never over your files, and go away when you save.")),
);
});
});
ui.add_enabled_ui(p.autosave, |ui| {
form_row(ui, LW, tr!("Every"), |ui| {
let shown = crate::prefs::AUTOSAVE_INTERVALS.iter().find(|(s, _)| *s == p.autosave_secs).map_or_else(|| trn!("{n} second", "{n} seconds", p.autosave_secs), |(_, l)| crate::i18n::t(l).to_string());
egui::ComboBox::from_id_salt("pref_autosave_secs").width(160.0).selected_text(text(Type::Body, shown)).show_ui(ui, |ui| {
for (secs, label) in crate::prefs::AUTOSAVE_INTERVALS {
ui.selectable_value(&mut p.autosave_secs, secs, text(Type::Body, crate::i18n::t(label)));
}
})
.response
.set_name(tr!("Autosave every"));
});
form_row(ui, LW, tr!("Or after"), |ui| {
with_type(ui, Type::Data, |ui| {
ui.add(egui::DragValue::new(&mut p.autosave_edits).range(crate::prefs::AUTOSAVE_EDITS_RANGE).speed(0.5).suffix(format!(" {}", tr!("changes")))).set_name(tr!("Autosave after this many changes"));
});
});
form_note(ui, LW, text(Type::Caption, tr!("Whichever comes first. 0 changes: by time only. Copies are written in the background, so drawing never waits.")));
});
});
section(ui, "prefs_safety", Section::Rule, tr!("Safety"), None, |ui| {
form_row(ui, LW, tr!("Confirmations"), |ui| {
let n = app.skip_confirm.len();
if ui.add_enabled(n > 0, egui::Button::new(text(Type::Body, tr!("Show all again")))).clicked() {
reset_confirms = true;
}
ui.label(text(Type::Caption, trn!("{n} silenced this session", "{n} silenced this session", n)));
});
});
// Where this copy keeps its things, portable or installed, and an AppImage's
// applications menu entry (ADR 0094).
let (head, _) = crate::theme::section_with_header(ui, "prefs_about", Section::Rule, tr!("About"), None, |ui| {
about_act = crate::desktop_ui::about(app, ui, LW);
});
if to_about {
head.scroll_to_me(Some(egui::Align::TOP));
}
});
ui.separator();
ui.label(text(Type::Caption, tr!("{os} · settings stored in {place}", os = crate::platform::OS.name(), place = crate::platform::settings_place())));
});
a11y::name_title_bar(&shown, title);
if reset_confirms {
app.skip_confirm.clear();
}
if let Some(a) = about_act {
crate::desktop_ui::apply(app, a);
}
if p != app.prefs {
app.set_prefs(ctx, p);
}
match theme_act {
Some(ThemeAct::OpenFolder) => app.open_themes_folder(),
Some(ThemeAct::Reload) => app.reload_themes(ctx),
Some(ThemeAct::Export) => app.export_theme(ctx),
None => {}
}
if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::Escape)) {
open = false;
}
app.show_prefs = open;
}
/// What Preferences › Theme has picked: following the system, a built-in palette, or a theme
/// of the user's own by its file's name (ADR 0117).
#[derive(Clone, Debug, PartialEq)]
enum ThemeChoice {
System,
BuiltIn(crate::theme::Palette),
Mine(String),
}
/// The buttons under the themes (ADR 0117), run once the window is drawn.
#[derive(Clone, Copy)]
enum ThemeAct {
OpenFolder,
Reload,
Export,
}
// ----- licences ---------------------------------------------------------------------------------
/// Licence texts compiled into the binary, so every copy of the app carries its notices.
/// Titles are English keys, translated where they are drawn; the licence texts stay as written.
const NOTICES: &[(&str, &str)] = &[
(tr_noop!("NOTICE"), include_str!("../NOTICE")),
(tr_noop!("AniCraft: MIT License"), include_str!("../LICENSE-MIT")),
(tr_noop!("AniCraft: Apache License 2.0"), include_str!("../LICENSE-APACHE")),
(tr_noop!("Font: Ubuntu Light (Ubuntu Font Licence 1.0)"), include_str!("../licenses/fonts/UFL-1.0-Ubuntu-font.txt")),
(tr_noop!("Font: Hack (MIT, Bitstream Vera)"), include_str!("../licenses/fonts/LICENSE-Hack.txt")),
(tr_noop!("Font: Noto Emoji (SIL OFL 1.1)"), include_str!("../licenses/fonts/OFL-1.1-NotoEmoji.txt")),
(tr_noop!("Font: emoji-icon-font (MIT)"), include_str!("../licenses/fonts/LICENSE-emoji-icon-font.txt")),
(tr_noop!("Icons: Lucide (ISC)"), include_str!("../licenses/icons/LICENSE-lucide.txt")),
(tr_noop!("Rust crates: licence inventory"), include_str!("../docs/legal/third-party-inventory.txt")),
];
fn licenses(app: &mut App, ctx: &egui::Context) {
if !app.show_licenses {
return;
}
let mut open = true;
let title = tr!("Licenses & Notices");
let shown = crate::windows::new(ctx, title)
.id(egui::Id::new("licenses_window"))
.open(&mut open)
.collapsible(false)
.pivot(egui::Align2::CENTER_CENTER)
.default_pos(ctx.content_rect().center())
.default_width(680.0)
.default_height(560.0)
.show(ctx, |ui| {
ui.label(text(Type::Body, tr!("AniCraft is free software: MIT OR Apache-2.0, at your option.")).strong());
ui.label(
text(Type::Body, tr!("It is an independent project, not affiliated with or endorsed by Adobe. Bundled fonts and Rust crates keep their own permissive licences, listed below."))
.color(T.text_dim),
);
ui.add_space(6.0);
egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
for (title, body) in NOTICES {
egui::CollapsingHeader::new(crate::i18n::t(title)).id_salt(("notice", *title)).default_open(*title == "NOTICE").show(ui, |ui| {
ui.add(egui::Label::new(text(Type::Path, *body)).wrap());
});
}
});
});
a11y::name_title_bar(&shown, title);
if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::Escape)) {
open = false;
}
app.show_licenses = open;
}
// ----- keyboard shortcuts (editor) ----------------------------------------------------------------
/// The shortcut editor is recording a key for `id`: replacing its key at `replace`, or adding.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct KeyCapture {
pub id: &'static str,
pub replace: Option<usize>,
}
/// Editor state between frames: the last message, a key waiting to be moved here from another
/// action, and the reset-all confirmation.
#[derive(Clone, Default)]
struct SheetState {
filter: String,
notice: Option<(String, bool)>,
/// The capture, the chord, and the id of the action that has it now.
steal: Option<(KeyCapture, String, &'static str)>,
confirm_reset_all: bool,
}
enum SheetAct {
Capture(KeyCapture),
Remove(&'static str, usize),
Reset(&'static str),
ResetAll,
Steal,
Dismiss,
}
/// Fixed keys: handled before the shortcut map, shown read-only. Groups and names are English
/// keys (groups match [`GROUP_ORDER`]), translated where they are drawn.
pub(crate) fn fixed_rows() -> Vec<(&'static str, &'static str, Vec<&'static str>)> {
let quit = if crate::platform::OS == crate::platform::Os::Mac { tr_noop!("Quit") } else { tr_noop!("Exit") };
let (essentials, view, editing) = (tr_noop!("Essentials"), tr_noop!("View"), tr_noop!("Editing"));
// Keys in registry notation; the words among them are translated by `fixed_key`.
vec![
(essentials, tr_noop!("Command palette"), vec!["Ctrl+K"]),
(essentials, tr_noop!("Help for what you are pointing at"), vec!["F1"]),
(essentials, tr_noop!("Keyboard shortcuts (this editor)"), vec!["Ctrl+Alt+Shift+K"]),
(essentials, tr_noop!("Play / Stop"), vec!["Enter"]),
(essentials, tr_noop!("Preferences"), vec!["Ctrl+U", "Ctrl+,"]),
(essentials, quit, vec!["Ctrl+Q"]),
(view, tr_noop!("Zoom in / out"), vec!["Ctrl+=", "Ctrl+-"]),
(view, tr_noop!("Fit stage in window"), vec!["Ctrl+0"]),
(view, tr_noop!("Actual size (100%)"), vec!["Ctrl+1"]),
(view, tr_noop!("Zoom at the cursor"), vec!["Ctrl+Wheel"]),
(view, tr_noop!("Pan with any tool"), vec!["Space+Drag", "Middle-drag"]), // i18n-exempt: keys, see fixed_key
(editing, tr_noop!("Nudge selection 1 px"), vec!["Arrow keys"]), // i18n-exempt: keys, see fixed_key
(editing, tr_noop!("Nudge selection 10 px"), vec!["Shift+Arrow keys"]),
(editing, tr_noop!("Add to / remove from selection"), vec!["Shift+Click"]),
(editing, tr_noop!("Constrain shape / 45° line"), vec!["Shift+Drag"]),
(editing, tr_noop!("Context actions"), vec!["Right-click"]), // i18n-exempt: keys, see fixed_key
]
}
/// A fixed key as shown: the platform's modifier names, and the pointer gestures and key
/// groups that are words (not key names) in the interface language.
fn fixed_key(k: &str) -> String {
let (mods, last) = k.rsplit_once('+').unwrap_or(("", k));
let word = match last {
"Wheel" => tr!("Wheel"),
"Drag" => tr!("Drag"),
"Middle-drag" => tr!("Middle-drag"),
"Arrow keys" => tr!("Arrow keys"),
"Click" => tr!("Click"),
"Right-click" => tr!("Right-click"),
other => other,
};
crate::platform::shortcut_label(&if mods.is_empty() { word.to_string() } else { format!("{mods}+{word}") })
}
/// Section order, by group key (English; the titles are translated where they are drawn).
pub(crate) const GROUP_ORDER: [&str; 13] = [
tr_noop!("Essentials"),
tr_noop!("Tools"),
tr_noop!("File"),
tr_noop!("Edit"),
tr_noop!("View"),
tr_noop!("Insert"),
tr_noop!("Modify"),
tr_noop!("Commands"),
tr_noop!("Control"),
tr_noop!("Window"),
tr_noop!("Help"),
tr_noop!("Other"),
tr_noop!("Editing"),
];
/// The action-name column: left-aligned, one row tall, cut off with an ellipsis when long.
fn name_cell(ui: &mut egui::Ui, label: &str) {
ui.allocate_ui_with_layout(egui::vec2(240.0, crate::theme::TARGET), egui::Layout::left_to_right(egui::Align::Center), |ui| {
ui.set_min_width(240.0);
ui.add(egui::Label::new(label).truncate());
});
}
/// An action's name in the interface language (a command's as in the menus).
fn action_name(a: &crate::keymap::Action) -> &'static str {
crate::i18n::t_cmd(a.id, a.label)
}
fn action_label(km: &crate::keymap::Keymap, id: &str) -> &'static str {
km.actions.iter().find(|a| a.id == id).map_or_else(|| tr!("this action"), action_name)
}
/// The next key press while recording, with every other key event taken out of the frame.
fn take_key_press(ctx: &egui::Context) -> Option<(egui::Modifiers, Key)> {
ctx.input_mut(|i| {
let mut got = None;
i.events.retain(|e| match e {
egui::Event::Key { key, pressed, modifiers, .. } => {
if *pressed && got.is_none() {
got = Some((*modifiers, *key));
}
false
}
egui::Event::Text(_) => false,
_ => true,
});
got
})
}
/// Opens the shortcut editor filtered to `filter` and waiting for a new key for `id` (Manage
/// Saved Commands' Shortcut…, ADR 0097).
pub(crate) fn shortcuts_for(app: &mut App, ctx: &egui::Context, filter: &str, id: &'static str) {
let state_id = egui::Id::new("shortcut_editor");
let mut st: SheetState = ctx.data_mut(|d| d.get_temp(state_id).unwrap_or_default());
st.filter = filter.to_string();
st.notice = None;
st.steal = None;
ctx.data_mut(|d| d.insert_temp(state_id, st));
app.show_shortcuts = true;
let replace = (!app.keymap.keys(id).is_empty()).then_some(0);
app.key_capture = Some(KeyCapture { id, replace });
}
fn shortcut_sheet(app: &mut App, ctx: &egui::Context) {
if !app.show_shortcuts {
app.key_capture = None;
return;
}
let state_id = egui::Id::new("shortcut_editor");
let mut st: SheetState = ctx.data_mut(|d| d.get_temp(state_id).unwrap_or_default());
let key = crate::platform::shortcut_label;
// Recording: the next key press becomes the shortcut (Esc cancels).
if let Some(cap) = app.key_capture
&& let Some((m, k)) = take_key_press(ctx)
{
app.key_capture = None;
if k == Key::Escape && !m.any() {
st.notice = None;
} else {
let chord = crate::keymap::chord(m, k);
match crate::keymap::assign(&app.prefs.shortcuts, cap.id, cap.replace, &chord, false) {
Ok(o) => {
st.notice = Some((tr!("{action}: {key}", action = action_label(&app.keymap, cap.id), key = key(&chord)), false));
let mut p = app.prefs.clone();
p.shortcuts = o;
app.set_prefs(ctx, p);
}
Err(crate::keymap::Refusal::Taken { id, label }) => {
st.notice = Some((tr!("{key} is already used by {action}.", key = key(&chord), action = crate::i18n::t_cmd(id, label)), true));
st.steal = Some((cap, chord, id));
}
Err(crate::keymap::Refusal::Reserved(why)) => st.notice = Some((tr!("{key} is kept for {purpose}; choose another key.", key = key(&chord), purpose = crate::i18n::t(why)), true)),
Err(crate::keymap::Refusal::TooMany) => st.notice = Some((trn!("An action can have up to {n} key.", "An action can have up to {n} keys.", crate::keymap::MAX_KEYS), true)),
}
}
}
let mut open = true;
let mut acts: Vec<SheetAct> = Vec::new();
let capture = app.key_capture;
let changed = app.prefs.shortcuts.len();
let title = tr!("Keyboard Shortcuts");
let shown = crate::windows::new(ctx, title)
.id(egui::Id::new("shortcuts_window"))
.open(&mut open)
.collapsible(false)
.pivot(egui::Align2::CENTER_CENTER)
.default_pos(ctx.content_rect().center())
.default_width(660.0)
.default_height(600.0)
.show(ctx, |ui| {
ui.horizontal(|ui| {
ui.add(egui::TextEdit::singleline(&mut st.filter).hint_text(tr!("Filter by name or key…")).desired_width(ui.available_width() - 120.0)).set_name(tr!("Filter shortcuts"));
let reset_all = ui.add_enabled(changed > 0, egui::Button::new(tr!("Reset all…"))).on_hover_text(tr!("Put every shortcut back to the defaults"));
if reset_all.clicked() {
st.confirm_reset_all = true;
}
});
// One message line: what is happening, what just happened, or what needs a decision.
if let Some(cap) = capture {
ui.label(text(Type::Label, tr!("Press the new keys for {action}. Esc cancels.", action = action_label(&app.keymap, cap.id))).color(T.accent_text));
} else if st.confirm_reset_all {
ui.horizontal(|ui| {
ui.label(text(Type::Label, trn!("Reset {n} changed shortcut to the defaults?", "Reset {n} changed shortcuts to the defaults?", changed)));
if ui.add(danger_button(tr!("Reset all"))).clicked() {
acts.push(SheetAct::ResetAll);
}
if ui.button(tr!("Cancel")).clicked() {
acts.push(SheetAct::Dismiss);
}
});
} else if let Some((msg, err)) = &st.notice {
ui.horizontal(|ui| {
ui.label(text(Type::Label, msg.clone()).color(if *err { T.error } else { T.ok }));
if let Some((cap, _, _)) = &st.steal {
if ui.button(tr!("Use it for {action}", action = action_label(&app.keymap, cap.id))).clicked() {
acts.push(SheetAct::Steal);
}
if ui.button(tr!("Cancel")).clicked() {
acts.push(SheetAct::Dismiss);
}
}
});
} else {
ui.label(text(Type::Caption, tr!("Click a key to change it or + to add one; right-click a key to remove it. Changes save as you go.")));
}
ui.add_space(4.0);
// Names match in the interface language and in English.
let f = st.filter.to_lowercase();
let hit = |s: &str| f.is_empty() || s.to_lowercase().contains(&f);
let named = |s: &'static str| hit(s) || hit(crate::i18n::t(s));
let fixed = fixed_rows();
egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
for group in GROUP_ORDER {
let actions: Vec<&crate::keymap::Action> = app
.keymap
.actions
.iter()
.filter(|a| a.group == group || (group == "Other" && !GROUP_ORDER.contains(&a.group)))
.filter(|a| hit(a.label) || hit(action_name(a)) || named(group) || app.keymap.keys(a.id).iter().any(|k| hit(k) || hit(&key(k))))
.collect();
let fixed: Vec<_> = fixed.iter().filter(|(g, l, ks)| *g == group && (named(l) || named(g) || ks.iter().any(|k| hit(k) || hit(&fixed_key(k))))).collect();
if actions.is_empty() && fixed.is_empty() {
continue;
}
let count = (actions.len() + fixed.len()).to_string();
crate::theme::section(ui, &format!("sheet_{group}"), crate::theme::Section::Rule, crate::i18n::t(group), Some(&count), |ui| {
egui::Grid::new(("sc", group)).num_columns(3).striped(true).min_col_width(60.0).show(ui, |ui| {
for (_, label, keys) in &fixed {
name_cell(ui, crate::i18n::t(label));
ui.horizontal(|ui| {
ui.label(text(Type::Key, keys.iter().map(|k| fixed_key(k)).collect::<Vec<_>>().join(" · ")).color(T.text_dim));
ui.add_space(6.0);
ui.label(text(Type::Caption, tr!("fixed")));
});
// An empty cell (an empty label would be an empty, clickable node for screen readers).
ui.allocate_space(egui::Vec2::ZERO);
ui.end_row();
}
for a in actions {
let name = action_name(a);
name_cell(ui, name);
ui.horizontal(|ui| {
let keys = app.keymap.keys(a.id);
for (i, k) in keys.iter().enumerate() {
let recording = capture == Some(KeyCapture { id: a.id, replace: Some(i) });
let chip = if recording {
egui::Button::new(text(Type::Key, tr!("Press keys…")).color(T.on_fill)).fill(T.accent)
} else {
egui::Button::new(text(Type::Key, key(k)).color(T.text))
};
let r = ui.add(chip).named(&tr!("{action} shortcut {key}", action = name, key = key(k))).on_hover_text(tr!("Click to change · right-click to remove"));
if r.clicked() {
acts.push(SheetAct::Capture(KeyCapture { id: a.id, replace: Some(i) }));
}
r.context_menu(|ui| {
if ui.button(tr!("Change…")).clicked() {
acts.push(SheetAct::Capture(KeyCapture { id: a.id, replace: Some(i) }));
ui.close();
}
if ui.button(tr!("Remove")).clicked() {
acts.push(SheetAct::Remove(a.id, i));
ui.close();
}
});
}
if capture == Some(KeyCapture { id: a.id, replace: None }) {
ui.add(egui::Button::new(text(Type::Key, tr!("Press keys…")).color(T.on_fill)).fill(T.accent));
} else if keys.len() < crate::keymap::MAX_KEYS {
let (tip, a11y_name) = if keys.is_empty() {
(tr!("Add a shortcut"), tr!("Add a shortcut for {action}", action = name))
} else {
(tr!("Add another shortcut"), tr!("Add another shortcut for {action}", action = name))
};
if ui.add(egui::Button::new("+").min_size(egui::vec2(crate::theme::TARGET, crate::theme::TARGET))).named(&a11y_name).on_hover_text(tip).clicked() {
acts.push(SheetAct::Capture(KeyCapture { id: a.id, replace: None }));
}
}
});
if app.keymap.is_default(a.id) {
// An empty cell (an empty label would be an empty, clickable node for screen readers).
ui.allocate_space(egui::Vec2::ZERO);
} else {
let defaults = if a.defaults.is_empty() { tr!("none").to_string() } else { a.defaults.iter().map(|k| key(k)).collect::<Vec<_>>().join(" · ") };
if ui.button(tr!("Reset")).named(&tr!("Reset {action}", action = name)).on_hover_text(tr!("Back to the default ({keys})", keys = defaults)).clicked() {
acts.push(SheetAct::Reset(a.id));
}
}
ui.end_row();
}
});
});
}
});
});
a11y::name_title_bar(&shown, title);
for act in acts {
let mut p = app.prefs.clone();
match act {
SheetAct::Capture(c) => {
app.key_capture = Some(c);
st.notice = None;
st.steal = None;
st.confirm_reset_all = false;
continue;
}
SheetAct::Remove(id, i) => {
p.shortcuts = crate::keymap::remove(&p.shortcuts, id, i);
st.notice = Some((tr!("{action}: key removed", action = action_label(&app.keymap, id)), false));
}
SheetAct::Reset(id) => {
p.shortcuts = crate::keymap::reset(&p.shortcuts, id);
st.notice = Some((tr!("{action}: back to the default", action = action_label(&app.keymap, id)), false));
}
SheetAct::ResetAll => {
p.shortcuts.clear();
st.confirm_reset_all = false;
st.notice = Some((tr!("Every shortcut is back to the defaults.").into(), false));
}
SheetAct::Steal => {
let Some((cap, chord, from)) = st.steal.take() else { continue };
match crate::keymap::assign(&p.shortcuts, cap.id, cap.replace, &chord, true) {
Ok(o) => {
p.shortcuts = o;
st.notice = Some((tr!("{action}: {key} (removed from {other})", action = action_label(&app.keymap, cap.id), key = key(&chord), other = action_label(&app.keymap, from)), false));
}
Err(_) => st.notice = Some((tr!("{key} could not be moved.", key = key(&chord)), true)),
}
}
SheetAct::Dismiss => {
st.steal = None;
st.notice = None;
st.confirm_reset_all = false;
continue;
}
}
app.set_prefs(ctx, p);
}
if app.key_capture.is_none() && ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, Key::Escape)) {
open = false;
}
if !open {
app.key_capture = None;
st.steal = None;
st.confirm_reset_all = false;
}
ctx.data_mut(|d| d.insert_temp(state_id, st));
app.show_shortcuts = open;
}