diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml index 8f118327..97cdfdf9 100644 --- a/.github/workflows/nix.yml +++ b/.github/workflows/nix.yml @@ -23,43 +23,5 @@ jobs: uses: storytold/craft-common-actions/.github/workflows/nix.yml@main git-sources: - name: Git dependencies come from storytold - runs-on: ubuntu-latest - timeout-minutes: 5 - steps: - - name: Harden runner - uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4 - with: - egress-policy: audit - - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - - name: Git dependencies come from storytold - run: | - set -euo pipefail - test -f Cargo.lock || { echo "Cargo.lock is missing"; exit 1; } - # Source replacement, patches and path overrides in cargo config never show up - # in Cargo.lock. Parsed rather than grepped: TOML has many spellings of one key. - # Cargo still reads the legacy .cargo/config. - python3 - <<'PY' - import os, sys, tomllib - for path in (".cargo/config", ".cargo/config.toml"): - if not os.path.exists(path): - continue - config = tomllib.load(open(path, "rb")) - replaced = [name for name, source in config.get("source", {}).items() - if isinstance(source, dict) and "replace-with" in source] - if replaced or "patch" in config or "paths" in config: - print(f"{path} replaces, patches or overrides a source") - sys.exit(1) - PY - # Fails when Cargo.lock is out of date with the manifests. - cargo metadata --locked --format-version 1 > /dev/null - python3 - <<'PY' - import sys, tomllib - lock = tomllib.load(open("Cargo.lock", "rb")) - bad = sorted({p["source"] for p in lock.get("package", []) - if p.get("source", "").startswith("git+") - and not p["source"].startswith("git+https://github.com/storytold/")}) - if bad: - print("Git dependencies outside github.com/storytold:", *bad, sep="\n") - sys.exit(1) - PY + # Tracks @main so suite-wide CI fixes reach every app without a PR in each repository. + uses: storytold/craft-common-actions/.github/workflows/git-sources.yml@main diff --git a/AGENTS.md b/AGENTS.md index e842724d..b3fcb022 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -109,9 +109,16 @@ Parity is measured, not guessed: `crates/engine/catalog/menus.txt` lists the inc - Drive it: JSON lines over TCP, e.g. `{"id":1,"method":"engine.execute","params":{"command":"track.new","params":{"count":2,"format":"stereo"}}}`, then `{"id":2,"method":"ui.screenshot","params":{"path":"/tmp/shot.png"}}`. Methods: `crates/ui-egui/src/control.rs`, docs: `docs/control-protocol.md`. - Offscreen UI render (no window, no focus stealing): `cargo run -p soundcraft-ui-egui --example ui_shot -- out.png [script.jsonl]`. - Headless: `soundcraft-cli run --demo --cmd 'mix.volume={"track":"Kick","db":-6}' --bounce out.wav`; MCP: `soundcraft-cli mcp [--connect PORT]`. -- **For UI work, look at the result** (render, read the PNG) and compare with `plan/protools/screenshots/`. +- **Language / localization:** the interface is English by default; Brazilian Portuguese + (`pt-BR`) is selected under `Setup › Appearance › Language` (or the `ui.language` command with + `{"language":"pt-BR"}`). The pt-BR catalog is complete for every fixed UI string — tests cover + placeholder parity, unique keys and source coverage, and the `cargo test` suite passes. +- Commands: build `cargo build -p soundcraft --bin soundcraft`; test + `cargo test -p soundcraft --bin soundcraft`; run `DISPLAY=:0 ./target/debug/soundcraft`. The + `cargo xtask ci` gate runs formatting, clippy, tests, assets, layering and the WebAssembly build. +- Parallel agents: separate `CARGO_TARGET_DIR` per agent; edit only the crates you own; write + manifests atomically; delete your target dir when done (disk). - Shell gotcha: `mv`/`cp` are aliased interactive here — use `/bin/mv -f` / `/bin/cp -f`. -- Parallel agents: separate `CARGO_TARGET_DIR` per agent; edit only the crates you own; write manifests atomically; delete your target dir when done (disk). ## Quality gates (before every commit) `cargo xtask ci` = fmt check, `clippy --workspace --all-targets -D warnings`, tests, assets, layers, wasm check. Commit after each arc of work that builds; one topic per commit. diff --git a/Cargo.lock b/Cargo.lock index 43717def..bdf8af71 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1064,7 +1064,7 @@ dependencies = [ [[package]] name = "craft-audio" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10" +source = "git+https://github.com/storytold/craft-libs?rev=45a8e16669e70dadb780dfbc759c882dd5b7ea1c#45a8e16669e70dadb780dfbc759c882dd5b7ea1c" dependencies = [ "craft-media", "log", @@ -1073,6 +1073,11 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-codepage" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10" + [[package]] name = "craft-docpath" version = "0.1.0" @@ -1109,7 +1114,7 @@ dependencies = [ [[package]] name = "craft-media" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10" +source = "git+https://github.com/storytold/craft-libs?rev=45a8e16669e70dadb780dfbc759c882dd5b7ea1c#45a8e16669e70dadb780dfbc759c882dd5b7ea1c" dependencies = [ "serde", "thiserror 2.0.21", @@ -1118,7 +1123,40 @@ dependencies = [ [[package]] name = "craft-midi" version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=45a8e16669e70dadb780dfbc759c882dd5b7ea1c#45a8e16669e70dadb780dfbc759c882dd5b7ea1c" +dependencies = [ + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-mime" +version = "0.1.0" source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10" +dependencies = [ + "chrono", + "craft-codepage", + "encoding_rs", +] + +[[package]] +name = "craft-scraft-format" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=45a8e16669e70dadb780dfbc759c882dd5b7ea1c#45a8e16669e70dadb780dfbc759c882dd5b7ea1c" +dependencies = [ + "craft-audio", + "craft-midi", + "craft-time", + "craft-zip", + "serde", + "serde_json", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-time" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=45a8e16669e70dadb780dfbc759c882dd5b7ea1c#45a8e16669e70dadb780dfbc759c882dd5b7ea1c" dependencies = [ "serde", "thiserror 2.0.21", @@ -1175,13 +1213,23 @@ dependencies = [ [[package]] name = "craft-video" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10" +source = "git+https://github.com/storytold/craft-libs?rev=45a8e16669e70dadb780dfbc759c882dd5b7ea1c#45a8e16669e70dadb780dfbc759c882dd5b7ea1c" dependencies = [ "craft-media", "rayon", "thiserror 2.0.21", ] +[[package]] +name = "craft-zip" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=45a8e16669e70dadb780dfbc759c882dd5b7ea1c#45a8e16669e70dadb780dfbc759c882dd5b7ea1c" +dependencies = [ + "flate2", + "thiserror 2.0.21", + "zip", +] + [[package]] name = "crc32fast" version = "1.5.3" @@ -1515,6 +1563,20 @@ dependencies = [ "bytemuck", ] +[[package]] +name = "encoding_rs" +version = "0.8.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89253175e704ab869b04f9db224d38630e0211a53841a79181deae0889e169f5" +dependencies = [ + "cfg-if", + "core_detect", + "multiversion_no_op", + "rustversion", + "scopeguard", + "simdutf8", +] + [[package]] name = "endi" version = "1.1.1" @@ -2718,6 +2780,12 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "multiversion_no_op" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d" + [[package]] name = "naga" version = "30.0.1" @@ -4456,6 +4524,7 @@ version = "0.20.1" dependencies = [ "craft-audio", "craft-docpath", + "craft-scraft-format", "log", "proptest", "serde", @@ -4502,13 +4571,7 @@ dependencies = [ name = "soundcraft-model" version = "0.20.1" dependencies = [ - "craft-audio", - "proptest", - "serde", - "serde_json", - "soundcraft-midi", - "soundcraft-time", - "thiserror 2.0.21", + "craft-scraft-format", ] [[package]] @@ -4530,10 +4593,7 @@ dependencies = [ name = "soundcraft-time" version = "0.20.1" dependencies = [ - "proptest", - "serde", - "serde_json", - "thiserror 2.0.21", + "craft-time", ] [[package]] @@ -4541,6 +4601,7 @@ name = "soundcraft-ui-egui" version = "0.20.1" dependencies = [ "craft-audio", + "craft-mime", "craft-ui", "craft-update", "egui", diff --git a/Cargo.toml b/Cargo.toml index 625c145b..192fde9c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,7 @@ rust-version = "1.95" repository = "https://github.com/storytold/soundcraft" [workspace.dependencies] +craft-mime = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10" } # internal soundcraft-time = { path = "crates/time" } soundcraft-midi = { path = "crates/midi" } @@ -51,14 +52,16 @@ cpal = "0.18" craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10" } # Video containers and bitstreams, shared with the other craft apps. -craft-media = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10" } +craft-media = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "45a8e16669e70dadb780dfbc759c882dd5b7ea1c" } # H.264 and ProRes codecs shared with the other Craft apps. -craft-video = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", default-features = false, features = ["h264-decode", "prores"] } +craft-video = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "45a8e16669e70dadb780dfbc759c882dd5b7ea1c", default-features = false, features = ["h264-decode", "prores"] } # Audio file formats, codecs and waveform overviews, shared with the other craft apps. It shares # types with craft-media, so both stay on one rev. # Standard MIDI Files and the note/controller model, shared with the other craft apps. -craft-midi = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", features = ["serde"] } -craft-audio = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", features = ["decode", "lossless-encode", "peaks", "serde"] } +craft-midi = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "45a8e16669e70dadb780dfbc759c882dd5b7ea1c", features = ["serde"] } +craft-audio = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "45a8e16669e70dadb780dfbc759c882dd5b7ea1c", features = ["decode", "lossless-encode", "peaks", "serde"] } +craft-time = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "45a8e16669e70dadb780dfbc759c882dd5b7ea1c" } +craft-scraft-format = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "45a8e16669e70dadb780dfbc759c882dd5b7ea1c" } # craft-update: app-specific pretend versions apply to startup and manual checks. craft-update = { version = "=0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", features = ["egui"] } diff --git a/README.md b/README.md index 0b7dfdb8..7d518d66 100644 --- a/README.md +++ b/README.md @@ -243,10 +243,10 @@ about egui, so the interface could be swapped for another one. | Crate | What it does | |---|---| -| `soundcraft-time` | Timebases, tempo and meter maps, timecode, grid | +| `soundcraft-time` | Compatibility re-export of `craft-time`'s SoundCraft sample-index API | | `soundcraft-midi` | Standard MIDI Files and MIDI operations | | `soundcraft-dsp` | Plugins, offline processing, meters, loudness, FFT | -| `soundcraft-model` | The session document | +| `soundcraft-model` | Compatibility re-export of `craft-scraft-format`'s schema, validation and JSON API | | `soundcraft-mix` | The mix engine (realtime and offline share it) | | `soundcraft-engine` | Commands, undo, editing, import/export, bounce | | `soundcraft-playback` | Audio devices (CoreAudio, WASAPI, ALSA, WebAudio) and recording | @@ -263,8 +263,18 @@ SoundCraft is **pre-alpha**: it covers 94 % of the incumbent's menu items (measu its features by presence, and is roughly 40 % of the way to replacing it for real work: record, edit, mix and bounce work end to end, but choosing an audio interface and buffer size, recording MIDI from a controller and session interchange (AAF/OMF) are still missing, and those -are the alpha checklist. Translations are missing too. The status, the stage and our effort -estimates are in [`ROADMAP.md`](ROADMAP.md); the full assessment is in +are the alpha checklist. + +**Translations:** the Brazilian Portuguese (`pt-BR`) catalog is **100 % complete** for every fixed +UI string found in the current source — menus, dialogs and buttons, tooltips (including those +localized inside buttons and toggles), accessibility names, the Edit-window status bar, the +remove-session question, formatted messages, engine error templates and engine error text at display +time. All these entries are covered by a test, placeholders match, keys are unique, and the +`pt-BR` catalog is chosen automatically when `ui.language` is `pt-BR` (or "Portuguese (Brazil)") +under `Setup › Appearance`. Engine errors keep their run-time values and a decimal comma in +`pt-BR`. The remaining localization work is a native-speaker (human) review of wording plus CJK / +Devanagari / Arabic font fallbacks and RTL layout — not new UI translation. The status, the stage +and our effort estimates are in [`ROADMAP.md`](ROADMAP.md); the full assessment is in [`docs/target-app-parity.md`](docs/target-app-parity.md), the ranked list of what's missing in [`docs/gaps.md`](docs/gaps.md), and the menu-by-menu comparison in [`docs/parity-checklist.md`](docs/parity-checklist.md). Bug reports and wish lists are diff --git a/ROADMAP.md b/ROADMAP.md index 749918c6..a25a45ba 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -50,7 +50,7 @@ measures readiness and adds hardware, localization and field bug reports. | UI/UX fidelity | ~55 % | 60–100 | [ui-parity.md](docs/ui-parity.md) | | File formats | ~40 % | 70–120 | [file-format-parity.md](docs/file-format-parity.md) | | Hardware (interfaces, MIDI, surfaces, sync) | ~12 % | 110–180 | [hardware-parity.md](docs/hardware-parity.md) | -| Localization | ~12 % (1 of Pro Tools' 8 languages) | 70–110 | [localization-parity.md](docs/localization-parity.md) | +| Localization | ~12 % (1 of Pro Tools' 8 languages; English and pt-BR fixed UI strings, no CJK/RTL font fallback or native review) | 70–110 | [localization-parity.md](docs/localization-parity.md) | | Performance | ~35 % (unmeasured) | 40–70 | [hardware-parity.md](docs/hardware-parity.md#performance) | | Stability | ~45 % | 50–80 | [gaps.md](docs/gaps.md) | | Platforms | ~65 % (5 platforms built, macOS exercised) | 20–40 | [gaps.md](docs/gaps.md) | @@ -89,14 +89,14 @@ Weights and evidence per row: [target-app-parity.md](docs/target-app-parity.md#f | Hindi | hi | none | 0 % | | Arabic | ar | none | 0 % | | French | fr | none (PR #143 open) | 0 % | -| Portuguese | pt | none | 0 % | +| Portuguese (Brazil) | pt-BR | full — 100 % of fixed UI strings; tests pass | 100 % (native-speaker review pending) | | Indonesian | id | none | 0 % | | Japanese | ja | none | 0 % | | German | de | none | 0 % | | Korean | ko | none | 0 % | | Vietnamese | vi | none | 0 % | -Other languages shipped: 0. Detail: [localization-parity.md](docs/localization-parity.md). +Other languages shipped: 0 complete. Brazilian Portuguese covers the fixed UI strings (100 %), with native-speaker review, CJK/RTL font fallbacks and script shaping still pending. Detail: [localization-parity.md](docs/localization-parity.md). ## Upcoming @@ -180,6 +180,7 @@ mutated and truncated movies. Field reports from the first public week are track | Date | Change | Summary | |---|---|---| +| 2026-11-05 | trivial | Languages table: Brazilian Portuguese (pt-BR) near complete for fixed UI strings via PR #1346; needs native review. Estimates unchanged | | 2026-10-25 | trivial | Progress log: Cancel Zoom Toggle; readiness estimates unchanged | | 2026-10-25 | trivial | Progress log: side panels in dock columns; readiness estimates unchanged | | 2026-10-25 | trivial | Progress log: Auto Pan stereo balance; readiness estimates unchanged | diff --git a/apps/soundcraft-web/src/web.rs b/apps/soundcraft-web/src/web.rs index aac7cef6..d7208883 100644 --- a/apps/soundcraft-web/src/web.rs +++ b/apps/soundcraft-web/src/web.rs @@ -2,6 +2,8 @@ use soundcraft_engine::{Engine, io}; use soundcraft_ui_egui::dialogs::Dialog; +use soundcraft_ui_egui::localization::{self, Language}; +use soundcraft_ui_egui::localized_format; use soundcraft_ui_egui::sampler_window::SampleRead; use soundcraft_ui_egui::{Services, SoundApp}; use std::cell::RefCell; @@ -12,10 +14,19 @@ use wasm_bindgen::JsCast as _; const CANVAS_ID: &str = "soundcraft_canvas"; const LOADING_ID: &str = "soundcraft_loading"; +/// The language the browser asks for, for text shown before or outside a running app. +fn browser_language() -> Language { + web_sys::window().and_then(|w| w.navigator().language()).and_then(|tag| Language::parse(&tag)).unwrap_or_default() +} + pub fn start() { eframe::WebLogger::init(log::LevelFilter::Info).ok(); io::set_deliver(download); wasm_bindgen_futures::spawn_local(async { + let _language = localization::enter(browser_language()); + if let Some(el) = web_sys::window().and_then(|w| w.document()).and_then(|d| d.get_element_by_id(LOADING_ID)) { + el.set_text_content(Some(localization::text("Loading SoundCraft…"))); + } let Some(document) = web_sys::window().and_then(|w| w.document()) else { log::error!("no document"); return; @@ -48,7 +59,11 @@ pub fn start() { if let Some(el) = document.get_element_by_id(LOADING_ID) { match result { Ok(()) => el.remove(), - Err(e) => el.set_inner_html(&format!("

SoundCraft failed to start: {e:?}

A browser with WebGPU or WebGL2 is required.

")), + Err(e) => el.set_text_content(Some(&format!( + "{} {}", + localized_format!("SoundCraft failed to start: {}", format!("{e:?}")), + localization::text("A browser with WebGPU or WebGL2 is required.") + ))), } } }); @@ -92,11 +107,11 @@ impl Purpose { } } - fn filter(self) -> (&'static str, Vec<&'static str>) { + fn filter(self) -> (String, Vec<&'static str>) { match self { - Self::Session => ("SoundCraft Session", SESSION_EXTS.to_vec()), - Self::Audio => ("Audio", craft_audio::DECODE_EXTENSIONS.to_vec()), - Self::Midi => ("MIDI", MIDI_EXTS.to_vec()), + Self::Session => (localization::text("SoundCraft Session").to_owned(), SESSION_EXTS.to_vec()), + Self::Audio => (localization::text("Audio").to_owned(), craft_audio::DECODE_EXTENSIONS.to_vec()), + Self::Midi => (localization::text("MIDI").to_owned(), MIDI_EXTS.to_vec()), } } } @@ -126,9 +141,12 @@ impl WebShell { let Some(purpose) = purpose else { return }; self.app.dialogs.open = None; let (inbox, ctx) = (self.inbox.clone(), ctx.clone()); + let (label, exts) = { + let _language = localization::enter(self.app.ui.language); + purpose.filter() + }; wasm_bindgen_futures::spawn_local(async move { - let (label, exts) = purpose.filter(); - let Some(file) = rfd::AsyncFileDialog::new().add_filter(label, &exts).pick_file().await else { return }; + let Some(file) = rfd::AsyncFileDialog::new().add_filter(&label, &exts).pick_file().await else { return }; let bytes = file.read().await; inbox.borrow_mut().push((purpose, file.file_name(), bytes)); ctx.request_repaint(); @@ -165,6 +183,7 @@ impl WebShell { } fn handle(&mut self, purpose: Purpose, name: String, bytes: Vec) { + let _language = localization::enter(self.app.ui.language); let e = &mut self.app.engine; let at = e.session().edit.selection.start.max(0); let result = match purpose { @@ -174,15 +193,15 @@ impl WebShell { Purpose::Audio => { let before = e.session_arc(); io::import_audio_bytes(e, &name, &bytes, None, None, at).map(|_| { - e.push_undo("Import Audio", before); - format!("Imported {name}") + e.push_undo(localization::text("Import Audio"), before); + localized_format!("Imported {name}", name = name) }) } Purpose::Midi => { let before = e.session_arc(); io::import_midi_bytes(e, &bytes, at, true).map(|_| { - e.push_undo("Import MIDI", before); - format!("Imported {name}") + e.push_undo(localization::text("Import MIDI"), before); + localized_format!("Imported {name}", name = name) }) } }; @@ -221,7 +240,8 @@ impl eframe::App for WebShell { /// Hand a saved or exported file to the person as a download named `name` (the engine's delivery /// hook on the web). fn download(name: &str, bytes: &[u8]) -> Result<(), String> { - let js = |e: wasm_bindgen::JsValue| format!("download failed: {e:?}"); + let _language = localization::enter(browser_language()); + let js = |e: wasm_bindgen::JsValue| localized_format!("Download failed: {}", format!("{e:?}")); let window = web_sys::window().ok_or("no window")?; let document = window.document().ok_or("no document")?; let parts = js_sys::Array::of1(&js_sys::Uint8Array::from(bytes)); diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml index d6e8b85b..f9f1e2df 100644 --- a/crates/engine/Cargo.toml +++ b/crates/engine/Cargo.toml @@ -10,6 +10,7 @@ repository.workspace = true [dependencies] soundcraft-time.workspace = true craft-audio.workspace = true +craft-scraft-format.workspace = true soundcraft-midi.workspace = true soundcraft-dsp.workspace = true soundcraft-clap-host.workspace = true @@ -22,7 +23,6 @@ serde.workspace = true serde_json.workspace = true thiserror.workspace = true log.workspace = true -zip.workspace = true craft-docpath.workspace = true [target.'cfg(windows)'.dependencies] @@ -30,6 +30,7 @@ winsafe = { version = "0.0.29", features = ["kernel"] } [dev-dependencies] proptest.workspace = true +zip.workspace = true [lints] workspace = true diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index 90979672..1880cc8c 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -182,46 +182,20 @@ impl Drop for SessionLimit { /// Refuses the session `name` of `len` bytes when it is larger than [`session_limit`]: too large /// to open, or, when `saving`, to save. pub(crate) fn session_size(name: impl std::fmt::Display, len: u64, saving: bool) -> Result<()> { - let limit = session_limit(); - if len <= limit { - return Ok(()); - } - let most = if limit >= 1 << 20 { format!("{} MiB", limit >> 20) } else { format!("{limit} bytes") }; - Err(EngineError::Io(if saving { - format!("{name} is too large to save: over {most}, more than SoundCraft opens") - } else { - format!("{name} is too large to open (over {most})") - })) + craft_scraft_format::check_session_size(&name.to_string(), len, session_limit(), saving).map_err(|error| EngineError::Io(error.to_string())) } /// [`read_text`] for a session file: refused, unread, past [`session_limit`]. pub(crate) fn read_session_text(path: impl AsRef) -> Result { let path = path.as_ref(); - utf8(path, read_file_within(path, true)?) + craft_scraft_format::read_session_data(&path.display().to_string(), read_file_within(path, true)?, session_limit()) + .map_err(|error| EngineError::Io(error.to_string())) } /// A bare `.scraft` handed over as bytes (the browser) as text: refused, uncopied, past /// [`session_limit`]. pub(crate) fn session_bytes_text(name: &str, bytes: &[u8]) -> Result { - session_size(name, bytes.len() as u64, false)?; - String::from_utf8(bytes.to_vec()).map_err(|_| EngineError::Io(format!("{name}: not a SoundCraft session"))) -} - -/// How many bytes [`Session::to_json`] makes of `s`, counted without keeping them. -fn json_len(s: &Session) -> u64 { - struct Count(u64); - impl std::io::Write for Count { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.0 = self.0.saturating_add(buf.len() as u64); - Ok(buf.len()) - } - fn flush(&mut self) -> std::io::Result<()> { - Ok(()) - } - } - let mut n = Count(0); - // A session that cannot be written counts as nothing here: `to_json` reports that error. - serde_json::to_writer_pretty(&mut n, s).map_or(0, |()| n.0) + craft_scraft_format::read_session_bytes(name, bytes, session_limit()).map_err(|error| EngineError::Io(error.to_string())) } /// Is there a file at `path` the automation read root lets us see? A path outside the root is @@ -795,11 +769,12 @@ fn write_session(session: &Session, path: &str, overwrite: bool) -> Result<(Sess // Before any audio is written: a session too large to open again is not saved (#892). With no // audio to write, the text checked is the text saved. let checked = if pending.is_empty() { - let text = s.to_json().map_err(|err| EngineError::Io(err.to_string()))?; - session_size(p.display(), text.len() as u64, true)?; + let label = p.display().to_string(); + let text = craft_scraft_format::write_session_named(&s, &label, session_limit()).map_err(|error| EngineError::Io(error.to_string()))?; Some(text) } else { - session_size(p.display(), json_len(&s), true)?; + let size = craft_scraft_format::session_json_len(&s).map_err(|error| EngineError::Io(error.to_string()))?; + session_size(p.display(), size, true)?; None }; let mut written = 0; @@ -820,7 +795,10 @@ fn write_session(session: &Session, path: &str, overwrite: bool) -> Result<(Sess } let text = match checked { Some(text) => text, - None => s.to_json().map_err(|err| EngineError::Io(err.to_string()))?, + None => { + let label = p.display().to_string(); + craft_scraft_format::write_session_named(&s, &label, session_limit()).map_err(|error| EngineError::Io(error.to_string()))? + } }; make_dir(&dir)?; // Atomic-ish write: temp file then rename. @@ -1107,45 +1085,11 @@ fn write_export_checked(path: &Path, mut bytes: &[u8]) -> std::io::Result<()> { /// Unpack a bundle: the one `.scraft` at its top level and the files beside it, by relative path. fn read_bundle(bytes: &[u8], limits: BundleLimits) -> Result<(String, std::collections::HashMap>)> { - use std::io::Read as _; - let zerr = |err: zip::result::ZipError| EngineError::Io(format!("bundle: {err}")); - let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).map_err(zerr)?; - if z.len() > limits.entries { - return Err(EngineError::Io("bundle: too many files".into())); - } - // Entries are stored, so the files we keep can only outgrow the bundle when several entries - // point at the same bytes: a small bundle naming one payload thousands of times would be - // copied out once per name. - if z.has_overlapping_files().map_err(zerr)? { - return Err(EngineError::Io("bundle: files share data".into())); - } - let (mut text, mut files, mut total) = (None, std::collections::HashMap::new(), 0u64); - for i in 0..z.len() { - let mut f = z.by_index(i).map_err(zerr)?; - if f.is_dir() { - continue; - } - let rel = f.name().map_err(zerr)?.to_string(); - let size = f.size(); - total = total.saturating_add(size); - if total > limits.bytes { - return Err(EngineError::Io("bundle: too large".into())); - } - let is_session = !rel.contains('/') && Path::new(&rel).extension().and_then(OsStr::to_str) == Some(soundcraft_model::SESSION_EXTENSION); - if is_session && text.is_none() { - session_size(format_args!("bundle: {rel}"), size, false)?; - } - let mut data = Vec::new(); - // The declared size is hostile too: never read past it. - f.by_ref().take(size).read_to_end(&mut data).map_err(|err| EngineError::Io(format!("bundle: {rel}: {err}")))?; - if is_session && text.is_none() { - text = Some(String::from_utf8(data).map_err(|_| EngineError::Io(format!("bundle: {rel} is not text")))?); - } else { - files.insert(rel, data); - } - } - let text = text.ok_or_else(|| EngineError::Io("bundle: no .scraft session inside".into()))?; - Ok((text, files)) + craft_scraft_format::read_bundle( + bytes, + craft_scraft_format::BundleLimits { entries: limits.entries, bytes: limits.bytes, session_bytes: session_limit() }, + ) + .map_err(|error| EngineError::Io(error.to_string())) } /// The record-enabled audio tracks, each with the input channels it records (those its input diff --git a/crates/engine/src/io/bundle.rs b/crates/engine/src/io/bundle.rs index 47467b23..566a77c8 100644 --- a/crates/engine/src/io/bundle.rs +++ b/crates/engine/src/io/bundle.rs @@ -1,13 +1,13 @@ use super::render::sanitize_name; use super::session::decode_source; -use super::{Arc, EncodeOptions, Engine, EngineError, FileFormat, OsStr, Path, Result, Session, SourceAudio, read_bundle, write_file}; +use super::{Arc, Engine, EngineError, OsStr, Path, Result, Session, SourceAudio, read_bundle, session_limit, write_file}; // ─── Hosts without a filesystem (the browser) ───────────────────────────────────────────────── /// Extension of a session bundle: one zip file holding the `.scraft` session and its /// `Audio Files/`, the same layout as a saved session folder. The browser has no folders, so it /// saves and opens sessions as bundles. -pub const BUNDLE_EXTENSION: &str = "scraftz"; +pub const BUNDLE_EXTENSION: &str = craft_scraft_format::BUNDLE_EXTENSION; /// Most entries and bytes a bundle may unpack to (bundles are hostile input). The writer keeps to /// them too, so a bundle it saves always opens again (#433). @@ -28,54 +28,8 @@ pub fn session_bundle(session: &Session) -> Result<(Vec, Session)> { /// [`session_bundle`], refused when it would hold more than `limits` allows. fn session_bundle_within(session: &Session, limits: BundleLimits) -> Result<(Vec, Session)> { - use std::io::Write as _; - let zerr = |err: zip::result::ZipError| EngineError::Io(format!("bundle: {err}")); - let ioerr = |err: std::io::Error| EngineError::Io(format!("bundle: {err}")); - let mut s = session.clone(); - let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new())); - let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored).large_file(true); - let mut taken = std::collections::HashSet::new(); - let (mut entries, mut total) = (0usize, 0u64); - // Counted as the reader counts them: files, and the bytes they unpack to. - let mut fits = |len: usize| { - entries += 1; - total = total.saturating_add(len as u64); - if entries > limits.entries || total > limits.bytes { - return Err(EngineError::Io(format!( - "bundle: too large to save (a bundle holds at most {} files and {} MiB, or it can't be opened again)", - limits.entries, - limits.bytes >> 20 - ))); - } - Ok(()) - }; - for src in &mut s.sources { - let Some(audio) = s.pool.get(src.id) else { continue }; - let base = sanitize_name(&src.name); - let mut target = format!("Audio Files/{base}.wav"); - let mut k = 1; - while taken.contains(&target) && k <= 9_999 { - target = format!("Audio Files/{base}_{k:02}.wav"); - k += 1; - } - let opts_wav = EncodeOptions::new(craft_audio::EncodeFormat::Wav).with_bit_depth(craft_audio::BitDepth::Float32); - let bytes = craft_audio::encode(&audio.buffer, &opts_wav).map_err(|err| EngineError::Io(err.to_string()))?; - fits(bytes.len())?; - w.start_file(target.as_str(), opts).map_err(zerr)?; - w.write_all(&bytes).map_err(ioerr)?; - taken.insert(target.clone()); - src.path = target; - src.unsaved = false; - src.format = FileFormat::Wav; - } - let text = s.to_json().map_err(|err| EngineError::Io(err.to_string()))?; - // Its session too: one the reader would refuse is not saved (#892). - super::session_size("the session", text.len() as u64, true)?; - fits(text.len())?; - w.start_file(format!("{}.{}", sanitize_name(&s.name), soundcraft_model::SESSION_EXTENSION), opts).map_err(zerr)?; - w.write_all(text.as_bytes()).map_err(ioerr)?; - let bytes = w.finish().map_err(zerr)?.into_inner(); - Ok((bytes, s)) + let shared = craft_scraft_format::BundleLimits { entries: limits.entries, bytes: limits.bytes, session_bytes: session_limit() }; + craft_scraft_format::write_bundle(session, shared).map_err(|error| EngineError::Io(error.to_string())) } /// Save as a bundle named after `path`'s file name, delivered through the host ([`write_file`]). @@ -200,6 +154,48 @@ mod bundle_tests { assert_eq!(r.path.as_deref(), Some("Midnight Groove.scraftz")); } + #[test] + fn legacy_zip64_bundle_opens_with_shared_reader() { + use craft_audio::{AudioBuffer, EncodeFormat, EncodeOptions, encode}; + use soundcraft_model::{FileFormat, Source, SourceId}; + use std::io::Write as _; + + let id = SourceId(7); + let samples = [0.125, -0.75, 1.25, -1.5]; + let mut audio = AudioBuffer::new(48_000, 1, samples.len()); + audio.channels[0].copy_from_slice(&samples); + + let mut session = Session::default(); + session.sources.push(Source { + id, + name: "Legacy Lead".into(), + path: "Audio Files/Legacy Lead.wav".into(), + channels: 1, + frames: samples.len() as u64, + sample_rate: 48_000, + format: FileFormat::Wav, + time_reference: 0, + unsaved: false, + }); + session.pool.insert(id, Arc::new(SourceAudio::new(audio))); + + let wav = + encode(&session.pool.get(id).unwrap().buffer, &EncodeOptions::new(EncodeFormat::Wav).with_bit_depth(craft_audio::BitDepth::Float32)) + .unwrap(); + let mut zip = zip::ZipWriter::new(std::io::Cursor::new(Vec::new())); + let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored).large_file(true); + zip.start_file("Audio Files/Legacy Lead.wav", opts).unwrap(); + zip.write_all(&wav).unwrap(); + zip.start_file("Legacy.scraft", opts).unwrap(); + zip.write_all(session.to_json().unwrap().as_bytes()).unwrap(); + let legacy = zip.finish().unwrap().into_inner(); + + let mut opened = Engine::default(); + let missing = open_session_bytes(&mut opened, "Legacy.scraftz", &legacy).unwrap(); + assert!(missing.is_empty(), "{missing:?}"); + assert_eq!(opened.session().pool.get(id).unwrap().buffer.channels[0], samples); + } + #[test] fn sources_sharing_one_file_all_load_from_a_bundle() { use std::io::Write as _; diff --git a/crates/engine/src/io/midi.rs b/crates/engine/src/io/midi.rs index bced021f..d3042665 100644 --- a/crates/engine/src/io/midi.rs +++ b/crates/engine/src/io/midi.rs @@ -12,8 +12,35 @@ pub(super) const MAX_MIDI_TRACKS: usize = 512; /// The file is checked in full before the session changes, so a refused file (too many tempo or /// meter changes or tracks, a track longer than a day) leaves the session as it was: callers that /// keep their own undo step, like the web shell, never see a half-applied import. +/// +/// A sound file is read strictly. A damaged one is read leniently, as other MIDI readers do: with +/// stray bytes after the last track (#1528), a track length its End of Track contradicts or a +/// track cut short, what can be read is imported and what could not is logged. A file past the +/// reader's event or track limit is still refused, also when other damage comes first: read +/// leniently it would lose the rest without saying so. Something that is not a Standard MIDI File +/// is refused. pub fn import_midi_bytes(e: &mut Engine, bytes: &[u8], at: Samples, tempo_map: bool) -> Result> { - let smf = soundcraft_midi::read_smf(bytes).map_err(|err| EngineError::Io(err.to_string()))?; + let smf = match soundcraft_midi::read_smf(bytes) { + Ok(smf) => smf, + Err(err @ (soundcraft_midi::MidiError::TooManyEvents(_) | soundcraft_midi::MidiError::TooManyTracks(_))) => { + return Err(EngineError::Io(err.to_string())); + } + Err(_) => { + let read = soundcraft_midi::read_smf_lenient(bytes).map_err(|err| EngineError::Io(err.to_string()))?; + // The strict reader stops at the first damage, so a limit further on shows only here. + if read.over_limit { + return Err(EngineError::Io(format!( + "MIDI file: more than {} events or {} tracks", + soundcraft_midi::MAX_EVENTS, + soundcraft_midi::MAX_TRACKS + ))); + } + for warning in &read.warnings { + log::warn!("MIDI import: {warning}"); + } + read.smf + } + }; if tempo_map { // Each meter is placed by walking the ones before it. if smf.meters.len() > MAX_MIDI_METERS { diff --git a/crates/engine/src/io/render.rs b/crates/engine/src/io/render.rs index 39eed648..bcd3dbec 100644 --- a/crates/engine/src/io/render.rs +++ b/crates/engine/src/io/render.rs @@ -177,6 +177,71 @@ mod name_tests { } } + #[test] + fn a_midi_file_with_stray_bytes_after_its_last_track_is_imported() { + // #1528: a complete format-0 file followed by two line feeds, too short to be a chunk. + let note = soundcraft_midi::Note { pitch: 60, velocity: 100, release_velocity: 64, channel: 0, start: 0, length: 960 }; + let sequence = soundcraft_midi::Sequence { notes: vec![note], ..Default::default() }; + let smf = soundcraft_midi::Smf { format: 0, tracks: vec![soundcraft_midi::SmfTrack { name: String::new(), sequence }], ..Default::default() }; + let mut bytes = soundcraft_midi::write_smf(&smf).unwrap(); + bytes.extend_from_slice(b"\n\n"); + let mut e = Engine::default(); + let ids = import_midi_bytes(&mut e, &bytes, 0, true).unwrap(); + assert_eq!(ids.len(), 1); + match &e.session().track(ids[0]).unwrap().clips()[0].content { + ClipContent::Midi { sequence } => assert_eq!(sequence.notes, vec![note]), + _ => panic!("expected a MIDI clip"), + } + // Something that is no MIDI file is still refused, and leaves the session as it was. + let mut e = Engine::default(); + assert!(import_midi_bytes(&mut e, b"RIFF\0\0\0\0WAVE", 0, true).is_err()); + assert!(e.session().tracks.is_empty()); + } + + #[test] + fn a_midi_file_past_the_track_limit_is_refused_even_with_stray_bytes() { + // Read leniently, the tracks past the limit would be left out without a word: the note in + // the last one would be lost. The file stays refused, and the session as it was. + let tracks = soundcraft_midi::MAX_TRACKS + 1; + let mut bytes = b"MThd\0\0\0\x06\0\x01".to_vec(); + bytes.extend_from_slice(&u16::try_from(tracks).unwrap().to_be_bytes()); + bytes.extend_from_slice(&960u16.to_be_bytes()); + for _ in 1..tracks { + bytes.extend_from_slice(b"MTrk\0\0\0\x04\0\xFF\x2F\0"); + } + // A note on, a quarter note later its note off, then End of Track. + bytes.extend_from_slice(b"MTrk\0\0\0\x0D\0\x90\x3C\x64\x87\x40\x80\x3C\x40\0\xFF\x2F\0"); + bytes.extend_from_slice(b"\n\n"); + let mut e = Engine::default(); + let err = import_midi_bytes(&mut e, &bytes, 0, true).unwrap_err(); + assert!(err.to_string().contains("too many tracks"), "{err}"); + assert!(e.session().tracks.is_empty()); + } + + #[test] + fn a_midi_file_past_the_event_limit_is_refused_after_a_damaged_track() { + // The strict reader stops at track 1's damage, before track 2 reaches the event limit; read + // leniently, track 2's note after the limit (pitch 72) would be lost without a word. + let mut damaged = b"\0\x3C\x40".to_vec(); // a data byte with no status before it + damaged.extend_from_slice(b"\0\xFF\x2F\0"); + let mut long = b"\0\x90\x3C\x64".to_vec(); + for _ in 0..soundcraft_midi::MAX_EVENTS { + long.extend_from_slice(b"\0\x3C\0"); // running status: note off + } + long.extend_from_slice(b"\0\x90\x48\x64\x87\x40\x80\x48\x40\0\xFF\x2F\0"); + let mut bytes = b"MThd\0\0\0\x06\0\x01\0\x02\x03\xC0".to_vec(); + for body in [&damaged, &long] { + bytes.extend_from_slice(b"MTrk"); + bytes.extend_from_slice(&u32::try_from(body.len()).unwrap().to_be_bytes()); + bytes.extend_from_slice(body); + } + assert!(!matches!(soundcraft_midi::read_smf(&bytes), Err(soundcraft_midi::MidiError::TooManyEvents(_)) | Ok(_))); + let mut e = Engine::default(); + let err = import_midi_bytes(&mut e, &bytes, 0, true).unwrap_err(); + assert!(err.to_string().contains("events"), "{err}"); + assert!(e.session().tracks.is_empty()); + } + #[test] fn midi_longer_than_a_day_is_refused() { let held = soundcraft_midi::Note { pitch: 60, velocity: 100, release_velocity: 64, channel: 0, start: 0, length: (1 << 28) - 1 }; diff --git a/crates/midi/src/lib.rs b/crates/midi/src/lib.rs index 8ab5243f..aff14495 100644 --- a/crates/midi/src/lib.rs +++ b/crates/midi/src/lib.rs @@ -2,8 +2,9 @@ //! //! - [`Note`], [`CtrlEvent`] and [`Sequence`]: the MIDI content of a region / track, in ticks at //! [`PPQ`] (960) ticks per quarter note; [`read_smf`] / [`write_smf`]: Standard MIDI File import -//! and export. These come from `craft-midi` in craft-libs, shared with the other Craft apps, and -//! are re-exported so the rest of SoundCraft names them from here. +//! and export, and [`read_smf_lenient`] for files that are slightly damaged. These come from +//! `craft-midi` in craft-libs, shared with the other Craft apps, and are re-exported so the rest +//! of SoundCraft names them from here. //! - [`ops`]: MIDI editing operations (quantize, transpose, velocity, duration, split). //! - [`note_name`], [`gm_drum_name`], [`gm_program_name`]: display names. #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] @@ -12,6 +13,8 @@ mod names; pub mod ops; mod rng; -pub use craft_midi::{CtrlEvent, CtrlKind, MAX_EVENTS, MAX_TRACKS, MidiError, Note, PPQ, Sequence, Smf, SmfTrack, read_smf, write_smf}; +pub use craft_midi::{ + CtrlEvent, CtrlKind, LenientRead, MAX_EVENTS, MAX_TRACKS, MidiError, Note, PPQ, Sequence, Smf, SmfTrack, read_smf, read_smf_lenient, write_smf, +}; pub use names::{gm_drum_name, gm_program_name, note_name}; pub use rng::XorShift; diff --git a/crates/model/Cargo.toml b/crates/model/Cargo.toml index 9422710a..b5d3157d 100644 --- a/crates/model/Cargo.toml +++ b/crates/model/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "soundcraft-model" -description = "SoundCraft session document: tracks, playlists, clips, mixer, routing, automation, markers" +description = "Compatibility facade for SoundCraft's shared native session format" version.workspace = true edition.workspace = true license.workspace = true @@ -8,15 +8,7 @@ rust-version.workspace = true repository.workspace = true [dependencies] -soundcraft-time.workspace = true -craft-audio.workspace = true -soundcraft-midi.workspace = true -serde.workspace = true -serde_json.workspace = true -thiserror.workspace = true - -[dev-dependencies] -proptest.workspace = true +craft-scraft-format.workspace = true [lints] workspace = true diff --git a/crates/model/src/automation.rs b/crates/model/src/automation.rs deleted file mode 100644 index 7bf7d2bd..00000000 --- a/crates/model/src/automation.rs +++ /dev/null @@ -1,394 +0,0 @@ -//! Automation lanes and modes. - -use soundcraft_time::Samples; - -/// Automation modes (per track). -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum AutomationMode { - Off, - #[default] - Read, - Touch, - Latch, - TouchLatch, - Write, - Trim, -} - -impl AutomationMode { - pub const ALL: [AutomationMode; 7] = [ - AutomationMode::Off, - AutomationMode::Read, - AutomationMode::Touch, - AutomationMode::Latch, - AutomationMode::TouchLatch, - AutomationMode::Write, - AutomationMode::Trim, - ]; - pub fn label(self) -> &'static str { - match self { - AutomationMode::Off => "off", - AutomationMode::Read => "read", - AutomationMode::Touch => "touch", - AutomationMode::Latch => "latch", - AutomationMode::TouchLatch => "touch/latch", - AutomationMode::Write => "write", - AutomationMode::Trim => "trim", - } - } - pub fn from_id(s: &str) -> Option { - let s = s.to_ascii_lowercase(); - AutomationMode::ALL.into_iter().find(|m| m.label() == s || m.label().replace('/', "_") == s || format!("{m:?}").to_ascii_lowercase() == s) - } - pub fn reads(self) -> bool { - !matches!(self, AutomationMode::Off) - } -} - -/// Which parameter an automation lane controls. -#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize, serde::Deserialize)] -pub enum AutoParam { - /// Fader level, dB. - Volume, - /// Pan, -1..1 (index = which panner of a stereo track: 0 left, 1 right). - Pan(u8), - /// Mute (0/1). - Mute, - /// Send level, dB. - SendLevel(u8), - SendPan(u8), - SendMute(u8), - /// Insert slot + parameter id. - Plugin { - slot: u8, - param: String, - }, -} - -impl AutoParam { - pub fn label(&self) -> String { - match self { - AutoParam::Volume => "volume".into(), - AutoParam::Pan(0) => "pan".into(), - AutoParam::Pan(i) => format!("pan {}", u16::from(*i) + 1), - AutoParam::Mute => "mute".into(), - AutoParam::SendLevel(i) => format!("send {} level", slot_letter(*i)), - AutoParam::SendPan(i) => format!("send {} pan", slot_letter(*i)), - AutoParam::SendMute(i) => format!("send {} mute", slot_letter(*i)), - AutoParam::Plugin { slot, param } => format!("insert {} {param}", slot_letter(*slot)), - } - } - /// Parse ids like `volume`, `pan`, `pan2`, `mute`, `send_a_level`, `plugin:a:threshold`. - pub fn parse(s: &str) -> Option { - let orig = s.trim(); - let s = orig.to_ascii_lowercase(); - match s.as_str() { - "volume" | "vol" => return Some(AutoParam::Volume), - "pan" | "pan1" => return Some(AutoParam::Pan(0)), - "pan2" => return Some(AutoParam::Pan(1)), - "mute" => return Some(AutoParam::Mute), - _ => {} - } - if let Some(rest) = s.strip_prefix("send_") { - let mut it = rest.splitn(2, '_'); - let slot = letter_slot(it.next()?)?; - return match it.next()? { - "level" => Some(AutoParam::SendLevel(slot)), - "pan" => Some(AutoParam::SendPan(slot)), - "mute" => Some(AutoParam::SendMute(slot)), - _ => None, - }; - } - if let Some(rest) = s.strip_prefix("plugin:") { - let (slot, param) = rest.split_once(':')?; - // ASCII lowercasing keeps byte offsets, so take the param from the original. - let param = orig.get(orig.len() - param.len()..)?; - return Some(AutoParam::Plugin { slot: letter_slot(slot)?, param: param.to_string() }); - } - None - } - /// Value range and default. - pub fn range(&self) -> (f32, f32, f32) { - match self { - AutoParam::Volume | AutoParam::SendLevel(_) => (-144.0, 12.0, 0.0), - AutoParam::Pan(_) | AutoParam::SendPan(_) => (-1.0, 1.0, 0.0), - AutoParam::Mute | AutoParam::SendMute(_) => (0.0, 1.0, 0.0), - AutoParam::Plugin { .. } => (f32::MIN, f32::MAX, 0.0), - } - } -} - -pub fn slot_letter(i: u8) -> char { - char::from(b'A'.saturating_add(i.min(25))) -} - -fn letter_slot(s: &str) -> Option { - let c = s.chars().next()?.to_ascii_uppercase(); - if s.len() == 1 && c.is_ascii_uppercase() { Some(c as u8 - b'A') } else { s.parse().ok() } -} - -#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct AutomationPoint { - pub at: Samples, - pub value: f32, -} - -/// A breakpoint automation lane. Points are kept sorted by time. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct AutomationLane { - pub param: AutoParam, - pub points: Vec, - #[serde(default)] - pub enabled: bool, -} - -impl AutomationLane { - pub fn new(param: AutoParam) -> Self { - AutomationLane { param, points: Vec::new(), enabled: true } - } - - /// Value at `at` (linear interpolation; `default` when empty). - pub fn value_at(&self, at: Samples, default: f32) -> f32 { - let pts = &self.points; - let Some(first) = pts.first() else { return default }; - if at <= first.at { - return first.value; - } - let idx = pts.partition_point(|p| p.at <= at); - match (pts.get(idx.wrapping_sub(1)), pts.get(idx)) { - (Some(a), Some(b)) if b.at > a.at => { - // Mute-like lanes step instead of ramping. - if matches!(self.param, AutoParam::Mute | AutoParam::SendMute(_)) { - return a.value; - } - // Widen so far-apart breakpoints cannot overflow i64. - let span = i128::from(b.at) - i128::from(a.at); - let off = i128::from(at) - i128::from(a.at); - // Interpolate in f64: the f32 difference overflows for - // opposite-sign values near f32::MAX. - let (av, bv) = (f64::from(a.value), f64::from(b.value)); - (av + (bv - av) * (off as f64 / span as f64)) as f32 - } - (Some(a), _) => a.value, - _ => default, - } - } - - /// Insert or replace a breakpoint. - pub fn set_point(&mut self, at: Samples, value: f32) { - let (lo, hi, _) = self.param.range(); - let value = if value.is_nan() { 0.0 } else { value.clamp(lo, hi) }; - match self.points.binary_search_by(|p| p.at.cmp(&at)) { - Ok(i) => { - if let Some(p) = self.points.get_mut(i) { - p.value = value; - } - } - Err(i) => self.points.insert(i, AutomationPoint { at, value }), - } - } - - /// Remove points in `[start, end)`. - pub fn clear_range(&mut self, start: Samples, end: Samples) -> usize { - let before = self.points.len(); - self.points.retain(|p| p.at < start || p.at >= end); - before - self.points.len() - } - - /// Write a constant value over a range, keeping the surrounding curve intact with anchor points. - pub fn write_range(&mut self, start: Samples, end: Samples, value: f32, default: f32) { - if end <= start { - return; - } - let before = self.value_at(start.saturating_sub(1), default); - let after = self.value_at(end, default); - self.clear_range(start, end.saturating_add(1)); - if start > 0 { - self.set_point(start - 1, before); - } - self.set_point(start, value); - self.set_point(end, value); - let anchor = end.saturating_add(1); - // A real breakpoint already at `end + 1` keeps its own value. - if self.points.binary_search_by(|p| p.at.cmp(&anchor)).is_err() { - self.set_point(anchor, after); - } - } - - /// Thin: remove points whose removal changes the curve by less than `tolerance`. - pub fn thin(&mut self, tolerance: f32) -> usize { - // Linear thinning would move the transitions of step lanes. - if matches!(self.param, AutoParam::Mute | AutoParam::SendMute(_)) || self.points.len() < 3 || tolerance.is_nan() { - return 0; - } - let tolerance = f64::from(tolerance); - let mut keep = vec![true; self.points.len()]; - let mut last = 0usize; - // Slopes from the last kept point that keep every point removed since then within `tolerance`. - let (mut lo, mut hi) = (f64::NEG_INFINITY, f64::INFINITY); - for i in 1..self.points.len() - 1 { - let (Some(a), Some(b), Some(c)) = (self.points.get(last), self.points.get(i), self.points.get(i + 1)) else { continue }; - let dt = b.at.saturating_sub(a.at) as f64; - let rise = f64::from(b.value) - f64::from(a.value); - lo = lo.max((rise - tolerance) / dt); - hi = hi.min((rise + tolerance) / dt); - let slope = (f64::from(c.value) - f64::from(a.value)) / c.at.saturating_sub(a.at) as f64; - if (lo..=hi).contains(&slope) { - if let Some(k) = keep.get_mut(i) { - *k = false; - } - } else { - last = i; - (lo, hi) = (f64::NEG_INFINITY, f64::INFINITY); - } - } - let before = self.points.len(); - let mut it = keep.iter(); - self.points.retain(|_| it.next().copied().unwrap_or(true)); - before - self.points.len() - } - - /// Shift points at or after `from` by `delta` (Shuffle edits, Insert Time). - pub fn shift_from(&mut self, from: Samples, delta: Samples) { - for p in &mut self.points { - if p.at >= from { - p.at = p.at.saturating_add(delta).max(0); - } - } - self.points.sort_by_key(|p| p.at); - self.points.dedup_by_key(|p| p.at); - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn parse_keeps_plugin_param_case() { - let p = AutoParam::Plugin { slot: 0, param: "Cutoff".into() }; - assert_eq!(AutoParam::parse("plugin:a:Cutoff"), Some(p)); - assert_eq!(AutoParam::parse("Plugin:B:Mix"), Some(AutoParam::Plugin { slot: 1, param: "Mix".into() })); - assert_eq!(AutoParam::parse("Volume"), Some(AutoParam::Volume)); - assert_eq!(AutoParam::parse("SEND_B_LEVEL"), Some(AutoParam::SendLevel(1))); - } - - #[test] - fn value_at_far_apart_points_does_not_overflow() { - let mut l = AutomationLane::new(AutoParam::Volume); - l.set_point(-1, 0.0); - l.set_point(i64::MAX, -10.0); - let v = l.value_at(5, 0.0); - assert!(v.is_finite() && (-10.0..=0.0).contains(&v)); - let w = l.value_at(i64::MAX - 1, 0.0); - assert!(w.is_finite() && (-10.0..=0.0).contains(&w)); - } - - #[test] - fn value_at_opposite_sign_extremes_stays_finite() { - let mut l = AutomationLane::new(AutoParam::Plugin { slot: 0, param: "Cutoff".into() }); - l.set_point(0, -3.0e38); - l.set_point(1000, 3.0e38); - let v = l.value_at(500, 0.0); - assert!(v.is_finite() && v.abs() < 1.0e32, "mid value {v}"); - let w = l.value_at(1, 0.0); - assert!(w.is_finite() && w < -2.9e38, "early value {w}"); - } - - #[test] - fn pan_label_max_does_not_overflow() { - assert_eq!(AutoParam::Pan(255).label(), "pan 256"); - } - - #[test] - fn interpolation_and_steps() { - let mut l = AutomationLane::new(AutoParam::Volume); - assert_eq!(l.value_at(10, -3.0), -3.0); - l.set_point(0, 0.0); - l.set_point(100, -10.0); - assert!((l.value_at(50, 0.0) + 5.0).abs() < 1e-6); - assert_eq!(l.value_at(1000, 0.0), -10.0); - let mut m = AutomationLane::new(AutoParam::Mute); - m.set_point(0, 0.0); - m.set_point(100, 1.0); - assert_eq!(m.value_at(99, 0.0), 0.0); - assert_eq!(m.value_at(100, 0.0), 1.0); - } - - #[test] - fn write_range_keeps_point_right_after_end() { - let mut l = AutomationLane::new(AutoParam::Volume); - l.set_point(0, 0.0); - l.set_point(11, -100.0); - l.write_range(2, 10, -20.0, 0.0); - assert_eq!(l.value_at(11, 0.0), -100.0); - } - - #[test] - fn write_range_preserves_outside() { - let mut l = AutomationLane::new(AutoParam::Volume); - l.set_point(0, 0.0); - l.set_point(1000, 0.0); - l.write_range(200, 400, -20.0, 0.0); - assert_eq!(l.value_at(100, 0.0), 0.0); - assert_eq!(l.value_at(300, 0.0), -20.0); - assert_eq!(l.value_at(600, 0.0), 0.0); - } - - #[test] - fn thin_removes_collinear() { - let mut l = AutomationLane::new(AutoParam::Volume); - for i in 0..=10 { - l.set_point(i * 10, -(i as f32)); - } - assert_eq!(l.thin(0.01), 9); - assert_eq!(l.points.len(), 2); - } - - #[test] - fn thin_keeps_removed_points_within_tolerance() { - for direction in [1.0, -1.0] { - let mut lane = AutomationLane::new(AutoParam::Volume); - for (at, value) in [(0, 0.0), (100, 0.0), (200, 0.0), (300, 0.12), (400, 0.26)] { - lane.set_point(at, value * direction); - } - let original = lane.points.clone(); - let tolerance = 0.1; - assert!(lane.thin(tolerance) > 0); - for point in original { - let error = (lane.value_at(point.at, 0.0) - point.value).abs(); - assert!(error <= tolerance, "at {}: error {error} exceeds {tolerance}", point.at); - } - } - } - - #[test] - fn thin_keeps_mute_changes_in_place() { - for param in [AutoParam::Mute, AutoParam::SendMute(0)] { - let mut lane = AutomationLane::new(param); - for (at, value) in [(0, 0.0), (9000, 1.0), (10000, 1.0)] { - lane.set_point(at, value); - } - lane.thin(0.1); - assert_eq!(lane.value_at(8999, 0.0), 0.0); - assert_eq!(lane.value_at(9000, 0.0), 1.0); - } - } - - #[test] - fn param_ids() { - assert_eq!(AutoParam::parse("send_b_level"), Some(AutoParam::SendLevel(1))); - assert_eq!(AutoParam::parse("plugin:a:threshold"), Some(AutoParam::Plugin { slot: 0, param: "threshold".into() })); - assert_eq!(AutoParam::parse("nope"), None); - assert_eq!(AutomationMode::from_id("touch/latch"), Some(AutomationMode::TouchLatch)); - } - - #[test] - fn set_point_clamps_nan() { - let mut l = AutomationLane::new(AutoParam::Pan(0)); - l.set_point(0, f32::NAN); - l.set_point(1, 5.0); - assert_eq!(l.points[0].value, 0.0); - assert_eq!(l.points[1].value, 1.0); - } -} diff --git a/crates/model/src/b64.rs b/crates/model/src/b64.rs deleted file mode 100644 index 1435d313..00000000 --- a/crates/model/src/b64.rs +++ /dev/null @@ -1,101 +0,0 @@ -//! Standard base64 (RFC 4648, `+/` alphabet, `=` padding), used to keep opaque plugin state -//! blobs in the JSON session file. Decoding treats its input as hostile: it rejects bad -//! characters and bad padding, ignores ASCII whitespace, and caps the output size. - -/// Largest blob [`decode`] will produce (64 MiB): bigger session fields are rejected. -pub const MAX_DECODED_BYTES: usize = 64 << 20; - -const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - -/// Encodes bytes as padded standard base64. -pub fn encode(data: &[u8]) -> String { - let mut out = String::with_capacity(data.len().div_ceil(3).saturating_mul(4)); - for chunk in data.chunks(3) { - let b = [chunk.first().copied().unwrap_or(0), chunk.get(1).copied().unwrap_or(0), chunk.get(2).copied().unwrap_or(0)]; - let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]); - let sym = |shift: u32| char::from(ALPHABET.get(((n >> shift) & 63) as usize).copied().unwrap_or(b'A')); - out.push(sym(18)); - out.push(sym(12)); - out.push(if chunk.len() > 1 { sym(6) } else { '=' }); - out.push(if chunk.len() > 2 { sym(0) } else { '=' }); - } - out -} - -fn value(c: u8) -> Option { - let v = match c { - b'A'..=b'Z' => c - b'A', - b'a'..=b'z' => c - b'a' + 26, - b'0'..=b'9' => c - b'0' + 52, - b'+' => 62, - b'/' => 63, - _ => return None, - }; - Some(u32::from(v)) -} - -/// Decodes padded (or unpadded) standard base64. `None` for malformed input or a result larger -/// than [`MAX_DECODED_BYTES`]. -pub fn decode(text: &str) -> Option> { - if text.bytes().filter(|c| !c.is_ascii_whitespace()).count() > MAX_DECODED_BYTES.div_ceil(3).saturating_mul(4) { - return None; - } - let syms: Vec = text.bytes().filter(|c| !c.is_ascii_whitespace()).collect(); - let body = syms.strip_suffix(b"==").or_else(|| syms.strip_suffix(b"=")).unwrap_or(&syms); - if body.contains(&b'=') || (syms.len() != body.len() && !syms.len().is_multiple_of(4)) || body.len() % 4 == 1 { - return None; - } - let decoded_len = body.len() / 4 * 3 + body.len() % 4 * 3 / 4; - if decoded_len > MAX_DECODED_BYTES { - return None; - } - let mut out = Vec::with_capacity(decoded_len); - for chunk in body.chunks(4) { - let mut n = 0u32; - for (i, &c) in chunk.iter().enumerate() { - n |= value(c)? << (18 - 6 * i as u32); - } - let bytes = [(n >> 16) as u8, (n >> 8) as u8, n as u8]; - out.extend_from_slice(bytes.get(..chunk.len() - 1)?); - } - Some(out) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn rfc4648_vectors_round_trip() { - for (plain, enc) in - [("", ""), ("f", "Zg=="), ("fo", "Zm8="), ("foo", "Zm9v"), ("foob", "Zm9vYg=="), ("fooba", "Zm9vYmE="), ("foobar", "Zm9vYmFy")] - { - assert_eq!(encode(plain.as_bytes()), enc); - assert_eq!(decode(enc).unwrap(), plain.as_bytes()); - } - let all: Vec = (0..=255).collect(); - assert_eq!(decode(&encode(&all)).unwrap(), all); - assert_eq!(decode("Zm9v\nYmE=").unwrap(), b"fooba", "whitespace is ignored"); - assert_eq!(decode("Zm9vYmE").unwrap(), b"fooba", "padding is optional"); - } - - #[test] - fn hostile_input_is_rejected() { - for bad in ["Z", "Zm9=v", "Zm9v!", "====", "Zg=", "é", "Zg===", "Z==="] { - assert!(decode(bad).is_none(), "{bad}"); - } - } - - #[test] - fn size_cap_counts_the_partial_quartet() { - for (extra, ok) in [(-1, true), (0, true), (1, false), (2, false)] { - let data = vec![7u8; MAX_DECODED_BYTES.saturating_add_signed(extra)]; - let padded = encode(&data); - let unpadded = padded.trim_end_matches('='); - assert_eq!(decode(&padded).is_some(), ok, "padded, {extra}"); - assert_eq!(decode(unpadded).is_some(), ok, "unpadded, {extra}"); - let spaced = format!("{}\n {}", &padded[..8], &padded[8..]); - assert_eq!(decode(&spaced).is_some(), ok, "whitespace, {extra}"); - } - } -} diff --git a/crates/model/src/clip.rs b/crates/model/src/clip.rs deleted file mode 100644 index 5b191424..00000000 --- a/crates/model/src/clip.rs +++ /dev/null @@ -1,544 +0,0 @@ -//! Clips: windows onto audio sources or MIDI sequences, placed on a playlist. - -use crate::{ClipId, MAX_NAME_CHARS, SourceId, truncate_chars}; -use soundcraft_midi::Sequence; -use soundcraft_time::{MAX_POSITION, Range, Samples}; - -/// Fade curve shapes (Pro Tools offers standard, equal-power, S-curve and custom presets). -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum FadeShape { - Linear, - #[default] - EqualPower, - SCurve, - Exponential, - Logarithmic, -} - -impl FadeShape { - pub const ALL: [FadeShape; 5] = [FadeShape::Linear, FadeShape::EqualPower, FadeShape::SCurve, FadeShape::Exponential, FadeShape::Logarithmic]; - - /// Fade-in gain at `t` ∈ [0,1] (fade-outs use `gain(1 - t)`). - pub fn gain(self, t: f32) -> f32 { - let t = if t.is_nan() { 0.0 } else { t.clamp(0.0, 1.0) }; - match self { - FadeShape::Linear => t, - FadeShape::EqualPower => (t * std::f32::consts::FRAC_PI_2).sin(), - FadeShape::SCurve => 0.5 - 0.5 * (t * std::f32::consts::PI).cos(), - FadeShape::Exponential => t * t * t, - FadeShape::Logarithmic => 1.0 - (1.0 - t) * (1.0 - t) * (1.0 - t), - } - } - - pub fn label(self) -> &'static str { - match self { - FadeShape::Linear => "Linear", - FadeShape::EqualPower => "Equal Power", - FadeShape::SCurve => "S-Curve", - FadeShape::Exponential => "Exponential", - FadeShape::Logarithmic => "Logarithmic", - } - } - - pub fn from_id(s: &str) -> Option { - let s = s.to_ascii_lowercase().replace(['-', '_', ' '], ""); - FadeShape::ALL.into_iter().find(|f| f.label().to_ascii_lowercase().replace(['-', ' '], "") == s) - } -} - -/// A fade at a clip boundary, `len` samples long. -#[derive(Debug, Clone, Copy, PartialEq, Default, serde::Serialize, serde::Deserialize)] -pub struct Fade { - pub len: Samples, - pub shape: FadeShape, - /// Continuous bend (-1..1); zero preserves the original shape exactly. - #[serde(default)] - pub curvature: f32, -} - -impl Fade { - /// The envelope used by both rendering and audio, with fixed zero/unity endpoints. - pub fn gain(self, t: f32) -> f32 { - let base = self.shape.gain(t); - let curvature = if self.curvature.is_finite() { self.curvature.clamp(-1.0, 1.0) } else { 0.0 }; - if curvature == 0.0 || base <= 0.0 || base >= 1.0 { - return base; - } - let weighted = base * (curvature * 4.0).exp2(); - weighted / (weighted + 1.0 - base) - } - - /// Invert the bend at the midpoint so a vertical drag follows the pointer. - pub fn curvature_for_midpoint_gain(self, gain: f32) -> f32 { - let gain = if gain.is_finite() { gain.clamp(0.001, 0.999) } else { self.gain(0.5) }; - let base = self.shape.gain(0.5); - (((gain / (1.0 - gain)).log2() - (base / (1.0 - base)).log2()) / 4.0).clamp(-1.0, 1.0) - } - - pub fn sanitize(&mut self) { - self.curvature = if self.curvature.is_finite() { self.curvature.clamp(-1.0, 1.0) } else { 0.0 }; - } -} - -/// What a clip plays. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub enum ClipContent { - /// Audio from `source`, starting `offset` samples into the file. - Audio { source: SourceId, offset: Samples }, - /// MIDI notes, with ticks relative to the clip start. - Midi { sequence: Sequence }, - /// Picture from the movie `source` ([`crate::VideoSource`], `Session::videos`), starting - /// `offset` samples into the movie. Video clips carry no audio. - Video { source: SourceId, offset: Samples }, -} - -/// A clip on a playlist. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Clip { - pub id: ClipId, - pub name: String, - /// Timeline start (samples). - pub start: Samples, - /// Length (samples, > 0). - pub length: Samples, - pub content: ClipContent, - /// Static clip gain in dB. - #[serde(default)] - pub gain_db: f32, - /// Clip gain envelope breakpoints: (offset from clip start, dB). Empty = flat `gain_db`. - #[serde(default)] - pub gain_env: Vec<(Samples, f32)>, - #[serde(default)] - pub fade_in: Fade, - #[serde(default)] - pub fade_out: Fade, - #[serde(default)] - pub muted: bool, - #[serde(default)] - pub edit_locked: bool, - #[serde(default)] - pub time_locked: bool, - #[serde(default)] - pub rating: u8, - /// Sync point offset from clip start. - #[serde(default)] - pub sync_point: Samples, - /// Optional colour override (RGB). - #[serde(default)] - pub color: Option<[u8; 3]>, - /// The key in [`crate::Session::auto_names`] of the names that editing gives the clips it - /// separates from this one (Clip List › Auto Rename). `None` keeps the clip's name. - #[serde(default)] - pub auto_name: Option, - /// Elastic / Vari-speed ratio (1.0 = none) — applied by rendered processing. - #[serde(default = "one")] - pub stretch: f64, - /// Reversed playback (AudioSuite Reverse renders into a new source; this is for previews). - #[serde(default)] - pub group: Option, - /// Marks the clips made by `clip.loop` (the origin and its copies share one id), so - /// `clip.unloop` still recognises the loop after the source's content is edited. - #[serde(default)] - pub loop_id: Option, -} - -fn one() -> f64 { - 1.0 -} - -impl Clip { - pub fn audio(id: ClipId, name: impl Into, source: SourceId, offset: Samples, start: Samples, length: Samples) -> Clip { - Clip { - id, - name: name.into(), - start, - length: length.max(1), - content: ClipContent::Audio { source, offset }, - gain_db: 0.0, - gain_env: Vec::new(), - fade_in: Fade::default(), - fade_out: Fade::default(), - muted: false, - edit_locked: false, - time_locked: false, - rating: 0, - sync_point: 0, - color: None, - auto_name: None, - stretch: 1.0, - group: None, - loop_id: None, - } - } - - pub fn midi(id: ClipId, name: impl Into, start: Samples, length: Samples, sequence: Sequence) -> Clip { - let mut c = Clip::audio(id, name, SourceId(0), 0, start, length); - c.content = ClipContent::Midi { sequence }; - c - } - - /// A clip showing the movie `source` from `offset` samples into it. - pub fn video(id: ClipId, name: impl Into, source: SourceId, offset: Samples, start: Samples, length: Samples) -> Clip { - let mut c = Clip::audio(id, name, SourceId(0), 0, start, length); - c.content = ClipContent::Video { source, offset }; - c - } - - pub fn end(&self) -> Samples { - self.start.saturating_add(self.length) - } - - pub fn range(&self) -> Range { - Range { start: self.start, end: self.end() } - } - - pub fn is_audio(&self) -> bool { - matches!(self.content, ClipContent::Audio { .. }) - } - - pub fn is_video(&self) -> bool { - matches!(self.content, ClipContent::Video { .. }) - } - - /// The audio source this clip plays (None for MIDI and video clips). - pub fn source(&self) -> Option { - match self.content { - ClipContent::Audio { source, .. } => Some(source), - ClipContent::Midi { .. } | ClipContent::Video { .. } => None, - } - } - - /// The movie this clip shows (video clips only). - pub fn video_source(&self) -> Option { - match self.content { - ClipContent::Video { source, .. } => Some(source), - ClipContent::Audio { .. } | ClipContent::Midi { .. } => None, - } - } - - /// Offset into the audio file or movie (0 for MIDI). - pub fn source_offset(&self) -> Samples { - match self.content { - ClipContent::Audio { offset, .. } | ClipContent::Video { offset, .. } => offset, - ClipContent::Midi { .. } => 0, - } - } - - /// Gain (linear) at `rel` samples from the clip start: clip gain × envelope × fades. - pub fn gain_at(&self, rel: Samples) -> f32 { - self.gain_at_with_fades(rel, self.fade_in, self.fade_out) - } - - /// Evaluate temporary fades while retaining clip gain and its envelope. - /// UI previews can use this without modifying the clip or rebuilding media. - pub fn gain_at_with_fades(&self, rel: Samples, fade_in: Fade, fade_out: Fade) -> f32 { - let mut db = self.gain_db; - if !self.gain_env.is_empty() { - db += env_value(&self.gain_env, rel); - } - let mut g = db_to_gain(db); - if fade_in.len > 0 && rel < fade_in.len { - g *= fade_in.gain(rel as f32 / fade_in.len as f32); - } - let from_end = self.length.saturating_sub(rel); - if fade_out.len > 0 && from_end <= fade_out.len { - g *= fade_out.gain(from_end as f32 / fade_out.len as f32); - } - g - } - - /// Gain envelope value in dB at `rel` samples from the clip start (0 without an envelope). - pub fn env_db_at(&self, rel: Samples) -> f32 { - env_value(&self.gain_env, rel) - } - - /// Move the start edge to `new_start` keeping material anchored (trim start). - pub fn trim_start_to(&mut self, new_start: Samples) { - // #907: these are public APIs, so they have to survive arguments a command would never - // pass (commands clamp to `MAX_POSITION` first). `Samples` is `i64`, so an extreme - // `new_start` against an extreme `start` wrapped in release and panicked in debug. - // Never so far back that the length would pass `MAX_POSITION`: trimming the start keeps the end. - let end = self.end(); - let new_start = new_start.max(end.saturating_sub(MAX_POSITION)).clamp(-MAX_POSITION, MAX_POSITION).min(end.saturating_sub(1)); - let delta = new_start.saturating_sub(self.start); - // The mixer plays a stretched audio clip from `offset + rel / stretch`. - let stretch = if self.stretch.is_finite() && self.stretch > 0.0 { self.stretch } else { 1.0 }; - match &mut self.content { - ClipContent::Audio { offset, .. } if (stretch - 1.0).abs() >= 1e-9 => { - *offset = offset.saturating_add((delta as f64 / stretch).round() as Samples); - } - ClipContent::Audio { offset, .. } | ClipContent::Video { offset, .. } => { - *offset = offset.saturating_add(delta); - } - ClipContent::Midi { .. } => {} - } - // MIDI note ticks are re-anchored by the engine, which knows the tempo map. - self.length = self.length.saturating_sub(delta).clamp(1, MAX_POSITION); - self.start = new_start; - if self.sync_point != 0 { - self.sync_point = self.sync_point.saturating_sub(delta); - } - self.drop_stray_sync(); - self.clamp_fades(); - // Keep the gain at the cut when earlier breakpoints are dropped. - if self.gain_env.iter().any(|&(t, _)| t < delta) && self.gain_env.iter().all(|&(t, _)| t != delta) { - self.gain_env.insert(0, (delta, env_value(&self.gain_env, delta))); - } - self.gain_env.retain(|&(t, _)| t >= delta); - self.gain_env.iter_mut().for_each(|(t, _)| *t = t.saturating_sub(delta)); - } - - /// Move the end edge to `new_end`. - pub fn trim_end_to(&mut self, new_end: Samples) { - // #907: saturating, like `trim_start_to`. - let new_end = new_end.clamp(-MAX_POSITION, MAX_POSITION).max(self.start.saturating_add(1)); - self.length = new_end.saturating_sub(self.start).clamp(1, MAX_POSITION); - self.drop_stray_sync(); - self.clamp_fades(); - } - - /// Keep both fades within the clip. - pub fn clamp_fades(&mut self) { - self.fade_in.len = self.fade_in.len.clamp(0, self.length); - self.fade_out.len = self.fade_out.len.clamp(0, self.length); - } - - /// A sync point (0 means none) that a trim left outside the clip no longer marks anything. - fn drop_stray_sync(&mut self) { - if !(0..self.length).contains(&self.sync_point) { - self.sync_point = 0; - } - } - - /// Repair a clip read from a file: positions and lengths within ±[`MAX_POSITION`], as commands - /// keep theirs, fades within the clip, a name that can be drawn, and a usable gain and stretch. - pub fn sanitize(&mut self) { - bound(&mut self.start); - self.length = self.length.clamp(1, MAX_POSITION); - bound(&mut self.sync_point); - self.gain_env.iter_mut().for_each(|(at, _)| bound(at)); - match &mut self.content { - ClipContent::Audio { offset, .. } | ClipContent::Video { offset, .. } => bound(offset), - ClipContent::Midi { sequence } => bound_sequence(sequence), - } - self.clamp_fades(); - self.fade_in.sanitize(); - self.fade_out.sanitize(); - truncate_chars(&mut self.name, MAX_NAME_CHARS); - if !self.gain_db.is_finite() { - self.gain_db = 0.0; - } - if !self.stretch.is_finite() || self.stretch <= 0.0 { - self.stretch = 1.0; - } - } -} - -pub(crate) fn bound(at: &mut Samples) { - *at = (*at).clamp(-MAX_POSITION, MAX_POSITION); -} - -pub(crate) fn bound_sequence(s: &mut Sequence) { - for n in &mut s.notes { - bound(&mut n.start); - n.length = n.length.clamp(1, MAX_POSITION); - } - s.ctrls.iter_mut().for_each(|c| bound(&mut c.tick)); -} - -fn env_value(env: &[(Samples, f32)], at: Samples) -> f32 { - let mut prev: Option<(Samples, f32)> = None; - for &(t, v) in env { - if t >= at { - return match prev { - Some((pt, pv)) if t > pt => { - let elapsed = i128::from(at).saturating_sub(i128::from(pt)); - let span = i128::from(t).saturating_sub(i128::from(pt)); - pv + (v - pv) * (elapsed as f32 / span as f32) - } - _ => v, - }; - } - prev = Some((t, v)); - } - prev.map_or(0.0, |(_, v)| v) -} - -pub(crate) fn db_to_gain(db: f32) -> f32 { - if db.is_nan() || db <= -144.0 { 0.0 } else { 10f32.powf(db.min(48.0) / 20.0) } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn fade_shapes_hit_endpoints() { - for s in FadeShape::ALL { - assert!(s.gain(0.0).abs() < 1e-6, "{s:?}"); - assert!((s.gain(1.0) - 1.0).abs() < 1e-6, "{s:?}"); - assert_eq!(s.gain(f32::NAN), 0.0); - assert_eq!(FadeShape::from_id(s.label()), Some(s)); - } - } - - #[test] - fn fade_curvature_is_bounded_monotonic_and_inverts_at_the_midpoint() { - for shape in FadeShape::ALL { - let original = Fade { len: 1000, shape, curvature: 0.0 }; - for i in 0..=128 { - let t = i as f32 / 128.0; - assert_eq!(original.gain(t), shape.gain(t), "legacy curves must be unchanged"); - } - for curvature in [-1.0, -0.5, 0.0, 0.5, 1.0] { - let fade = Fade { curvature, ..original }; - assert_eq!(fade.gain(0.0), 0.0); - assert_eq!(fade.gain(1.0), 1.0); - let mut previous = 0.0; - for i in 0..=128 { - let gain = fade.gain(i as f32 / 128.0); - assert!(gain.is_finite() && (0.0..=1.0).contains(&gain)); - assert!(gain >= previous, "{shape:?}, {curvature}"); - previous = gain; - } - assert!((fade.curvature_for_midpoint_gain(fade.gain(0.5)) - curvature).abs() < 1e-5); - } - assert!((Fade { curvature: 0.5, ..original }).gain(0.5) > original.gain(0.5)); - assert!((Fade { curvature: -0.5, ..original }).gain(0.5) < original.gain(0.5)); - } - } - - #[test] - fn fade_curvature_loads_legacy_data_and_sanitizes_hostile_values() { - let fade: Fade = serde_json::from_str(r#"{"len":100,"shape":"SCurve"}"#).unwrap(); - assert_eq!(fade.curvature, 0.0); - for curvature in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -10.0, 10.0] { - let mut fade = Fade { curvature, ..fade }; - assert!(fade.gain(0.5).is_finite()); - fade.sanitize(); - assert!(fade.curvature.is_finite() && (-1.0..=1.0).contains(&fade.curvature)); - let roundtrip: Fade = serde_json::from_str(&serde_json::to_string(&fade).unwrap()).unwrap(); - assert_eq!(roundtrip, fade); - } - } - - #[test] - fn temporary_fades_keep_clip_gain_and_envelope_without_mutating_the_clip() { - let mut clip = Clip::audio(ClipId(1), "preview", SourceId(1), 0, 0, 1000); - clip.gain_db = -6.0; - clip.gain_env = vec![(0, 0.0), (1000, 6.0)]; - clip.fade_in = Fade { len: 100, shape: FadeShape::SCurve, curvature: 0.25 }; - clip.fade_out = Fade { len: 100, shape: FadeShape::Logarithmic, curvature: -0.1 }; - let before = clip.clone(); - let fade_in = Fade { len: 1000, shape: FadeShape::Linear, curvature: 0.5 }; - let fade_out = Fade { len: 1000, shape: FadeShape::Linear, curvature: -0.5 }; - assert!((clip.gain_at_with_fades(500, fade_in, fade_out) - db_to_gain(-3.0) * 0.16).abs() < 1e-6); - let mut committed = clip.clone(); - committed.fade_in = fade_in; - committed.fade_out = fade_out; - for rel in [0, 50, 500, 999, 1000] { - assert_eq!(clip.gain_at_with_fades(rel, fade_in, fade_out), committed.gain_at(rel)); - } - for rel in [i64::MIN, i64::MAX] { - assert!(clip.gain_at(rel).is_finite()); - assert!(clip.gain_at_with_fades(rel, fade_in, fade_out).is_finite()); - } - assert_eq!(clip, before); - clip.gain_env = vec![(i64::MIN, 0.0), (i64::MAX, 6.0)]; - assert!((clip.gain_at(500) - db_to_gain(-3.0)).abs() < 1e-6); - assert!((clip.gain_at_with_fades(500, fade_in, fade_out) - db_to_gain(-3.0) * 0.16).abs() < 1e-6); - } - - #[test] - fn gain_with_fades() { - let mut c = Clip::audio(ClipId(1), "a", SourceId(1), 0, 100, 1000); - c.fade_in = Fade { len: 100, shape: FadeShape::Linear, curvature: 0.0 }; - c.fade_out = Fade { len: 100, shape: FadeShape::Linear, curvature: 0.0 }; - assert!(c.gain_at(0).abs() < 1e-6); - assert!((c.gain_at(50) - 0.5).abs() < 1e-6); - assert!((c.gain_at(500) - 1.0).abs() < 1e-6); - assert!((c.gain_at(950) - 0.5).abs() < 1e-6); - } - - #[test] - fn gain_envelope_interpolates() { - let mut c = Clip::audio(ClipId(1), "a", SourceId(1), 0, 0, 1000); - c.gain_env = vec![(0, 0.0), (1000, -20.0)]; - assert!((c.gain_at(500) - db_to_gain(-10.0)).abs() < 1e-4); - } - - #[test] - fn trim_start_keeps_gain_envelope_at_cut() { - for (env, cut, expected) in [ - (vec![(0, 0.0), (1000, -20.0)], 500, vec![(0, -10.0), (500, -20.0)]), - (vec![(0, 0.0), (100, -20.0)], 500, vec![(0, -20.0)]), - (vec![(0, 0.0), (500, -10.0), (1000, -20.0)], 500, vec![(0, -10.0), (500, -20.0)]), - (vec![], 500, vec![]), - (vec![(100, -3.0)], 0, vec![(100, -3.0)]), - (vec![(100, -3.0)], -100, vec![(200, -3.0)]), - ] { - let mut clip = Clip::audio(ClipId(1), "a", SourceId(1), 100, 0, 1000); - clip.gain_env = env; - let gain_at_cut = clip.gain_at(cut); - clip.trim_start_to(cut); - assert_eq!(clip.gain_env, expected); - if cut > 0 { - assert!((clip.gain_at(0) - gain_at_cut).abs() < 1e-6); - } - } - } - - #[test] - fn trims_keep_material_anchored() { - let mut c = Clip::audio(ClipId(1), "a", SourceId(1), 1000, 100, 1000); - c.trim_start_to(300); - assert_eq!((c.start, c.length, c.source_offset()), (300, 800, 1200)); - c.trim_end_to(500); - assert_eq!(c.length, 200); - c.trim_end_to(-50); - assert_eq!(c.length, 1); - // Regression: trimming the start must not leave a fade-out longer than the clip. - let mut c = Clip::audio(ClipId(2), "b", SourceId(1), 0, 0, 1000); - c.fade_out = Fade { len: 800, shape: FadeShape::Linear, curvature: 0.0 }; - c.trim_start_to(900); - assert!(c.fade_out.len <= c.length); - } - - /// #907: `trim_start_to` / `trim_end_to` are public APIs, so they have to survive arguments a - /// command would never pass. `Samples` is `i64`, so an extreme `new_start` against an extreme - /// `start` wrapped in release and panicked in debug. Every position stays within - /// `±MAX_POSITION` and every length within `1..=MAX_POSITION`. - #[test] - fn trims_saturate_on_extreme_arguments() { - for &new_start in &[Samples::MIN, -(MAX_POSITION * 2), -1, 0, MAX_POSITION, MAX_POSITION * 2, Samples::MAX] { - let mut c = Clip::audio(ClipId(1), "a", SourceId(1), 1000, MAX_POSITION / 2, 1000); - c.trim_start_to(new_start); - assert!((-(MAX_POSITION as i128)..=(MAX_POSITION as i128)).contains(&(c.start as i128)), "start {new_start}: {}", c.start); - assert!((1..=MAX_POSITION).contains(&c.length), "start {new_start}: length {}", c.length); - assert_eq!(c.end(), MAX_POSITION / 2 + 1000, "start {new_start} moved the end"); - } - for &new_end in &[Samples::MIN, -(MAX_POSITION * 2), -1, 0, MAX_POSITION, MAX_POSITION * 2, Samples::MAX] { - let mut c = Clip::audio(ClipId(2), "b", SourceId(1), 1000, -(MAX_POSITION / 2), 1000); - c.trim_end_to(new_end); - assert!((1..=MAX_POSITION).contains(&c.length), "end {new_end}: length {}", c.length); - assert!(c.end() - c.start == c.length, "end {new_end}: start {} end {}", c.start, c.end()); - } - } - - #[test] - fn trim_start_of_stretched_audio_advances_offset_by_source_time() { - // The mixer plays source `offset + rel / stretch`, so a split at timeline 1000 of a 2x clip - // must start the right half at source sample 500. - let mut c = Clip::audio(ClipId(1), "a", SourceId(1), 0, 0, 2000); - c.stretch = 2.0; - c.trim_start_to(1000); - assert_eq!(c.source_offset(), 500); - let mut c = Clip::audio(ClipId(2), "b", SourceId(1), 0, 0, 2000); - c.stretch = 0.5; - c.trim_start_to(1000); - assert_eq!(c.source_offset(), 2000); - let mut c = Clip::audio(ClipId(3), "c", SourceId(1), 0, 0, 2000); - c.trim_start_to(1000); - assert_eq!(c.source_offset(), 1000); - } -} diff --git a/crates/model/src/ids.rs b/crates/model/src/ids.rs deleted file mode 100644 index 441ced1a..00000000 --- a/crates/model/src/ids.rs +++ /dev/null @@ -1,21 +0,0 @@ -//! Typed ids. All ids come from one session-wide counter so they never collide across kinds. - -macro_rules! id_type { - ($name:ident) => { - #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default, serde::Serialize, serde::Deserialize)] - #[serde(transparent)] - pub struct $name(pub u64); - impl std::fmt::Display for $name { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.0) - } - } - }; -} - -id_type!(TrackId); -id_type!(ClipId); -id_type!(SourceId); -id_type!(BusId); -id_type!(GroupId); -id_type!(MarkerId); diff --git a/crates/model/src/lib.rs b/crates/model/src/lib.rs index b5d225c6..1cf02589 100644 --- a/crates/model/src/lib.rs +++ b/crates/model/src/lib.rs @@ -1,32 +1,7 @@ -//! The SoundCraft session document. +//! Compatibility facade for SoundCraft's shared session document crate. //! -//! A [`Session`] is pure data: tracks with playlists of clips, the mixer (inserts, sends, routing, -//! automation), tempo/meter, memory locations and groups. Audio sample data lives in -//! [`SourcePool`] behind `Arc`s, so cloning a session for undo is cheap. +//! Engine and UI adapters depend on this name, while the wire schema, JSON reader/writer, +//! validation, and bundle format live in `craft-scraft-format`. #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] -mod automation; -pub mod b64; -mod clip; -mod ids; -mod markers; -mod mixer; -mod session; -mod source; -mod track; - -pub use automation::{AutoParam, AutomationLane, AutomationMode, AutomationPoint}; -pub use clip::{Clip, ClipContent, Fade, FadeShape}; -pub use ids::{BusId, ClipId, GroupId, MarkerId, SourceId, TrackId}; -pub use markers::{Group, MarkerKind, MemoryLocation}; -pub use mixer::{ - Bus, ChannelFormat, INSERT_SLOTS, Insert, Mixer, OutputPath, Route, SEND_SLOTS, SendSlot, Speaker, SurroundPan, fader_db_to_pos, fader_pos_to_db, -}; -pub use session::{ - AutoName, BitDepthSetting, EditMode, EditState, FEET_FRAMES_START, MAX_COMMENT_CHARS, MAX_NAME_CHARS, SESSION_EXTENSION, Session, SessionError, - Tool, TrackView, ZoomState, ZoomToggle, truncate_chars, -}; -pub use source::{FileFormat, Source, SourceAudio, SourcePool, VideoSource}; -pub use track::{Playlist, TRACK_COLORS, Track, TrackHeight, TrackKind}; - -pub use soundcraft_time as time; +pub use craft_scraft_format::*; diff --git a/crates/model/src/markers.rs b/crates/model/src/markers.rs deleted file mode 100644 index 4441ebca..00000000 --- a/crates/model/src/markers.rs +++ /dev/null @@ -1,58 +0,0 @@ -//! Memory locations (markers and stored selections) and mix/edit groups. - -use crate::{GroupId, MarkerId, TrackId}; -use soundcraft_time::Samples; - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum MarkerKind { - /// A point marker on a ruler. - #[default] - Marker, - /// A stored selection range. - Selection, - /// A location that only recalls view settings. - None, -} - -/// A memory location (Window › Memory Locations). -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct MemoryLocation { - pub id: MarkerId, - /// User-visible number (1-based, unique). - pub number: u32, - pub name: String, - pub kind: MarkerKind, - pub start: Samples, - pub end: Samples, - #[serde(default)] - pub comments: String, - #[serde(default)] - pub color: Option<[u8; 3]>, - /// Marker ruler lane 1..5. - #[serde(default = "one")] - pub ruler: u8, - /// Track-lane marker on this track, if any. - #[serde(default)] - pub track: Option, -} - -fn one() -> u8 { - 1 -} - -/// A track group (Track › Group…). -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Group { - pub id: GroupId, - pub name: String, - /// Group letter id shown in the Groups list ("a", "b", …). - pub letter: char, - pub members: Vec, - pub edit: bool, - pub mix: bool, - pub active: bool, - pub color: [u8; 3], - /// Shared attributes linked by the group (volume, mute, solo, rec, etc.). - #[serde(default)] - pub attributes: Vec, -} diff --git a/crates/model/src/mixer.rs b/crates/model/src/mixer.rs deleted file mode 100644 index efdaf2d1..00000000 --- a/crates/model/src/mixer.rs +++ /dev/null @@ -1,714 +0,0 @@ -//! Per-track mixer state: inserts, sends, routing, fader, pan, mute/solo. - -use crate::{AutomationMode, BusId, SourceId}; -use std::collections::BTreeMap; - -pub const INSERT_SLOTS: usize = 10; -pub const SEND_SLOTS: usize = 10; - -/// Channel formats (track widths). -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum ChannelFormat { - #[default] - Mono, - Stereo, - Lcr, - Quad, - Lcrs, - Surround50, - Surround51, - Surround60, - Surround61, - Sdds70, - Sdds71, - Surround70, - Surround71, - Atmos702, - Atmos712, - Atmos502, - Atmos512, - Atmos504, - Atmos514, - Atmos704, - Atmos714, - Atmos706, - Atmos716, - Atmos904, - Atmos914, - Atmos906, - Atmos916, - /// Ambisonics of order 1..=7 ((n+1)² channels). - Ambisonics(u8), -} - -impl ChannelFormat { - pub const ALL: [ChannelFormat; 34] = [ - ChannelFormat::Mono, - ChannelFormat::Stereo, - ChannelFormat::Lcr, - ChannelFormat::Quad, - ChannelFormat::Lcrs, - ChannelFormat::Surround50, - ChannelFormat::Surround51, - ChannelFormat::Surround60, - ChannelFormat::Surround61, - ChannelFormat::Sdds70, - ChannelFormat::Sdds71, - ChannelFormat::Surround70, - ChannelFormat::Surround71, - ChannelFormat::Atmos702, - ChannelFormat::Atmos712, - ChannelFormat::Ambisonics(1), - ChannelFormat::Ambisonics(2), - ChannelFormat::Ambisonics(3), - ChannelFormat::Ambisonics(4), - ChannelFormat::Ambisonics(5), - ChannelFormat::Ambisonics(6), - ChannelFormat::Ambisonics(7), - ChannelFormat::Atmos502, - ChannelFormat::Atmos512, - ChannelFormat::Atmos504, - ChannelFormat::Atmos514, - ChannelFormat::Atmos704, - ChannelFormat::Atmos714, - ChannelFormat::Atmos706, - ChannelFormat::Atmos716, - ChannelFormat::Atmos904, - ChannelFormat::Atmos914, - ChannelFormat::Atmos906, - ChannelFormat::Atmos916, - ]; - pub fn channels(self) -> usize { - match self { - ChannelFormat::Mono => 1, - ChannelFormat::Stereo => 2, - ChannelFormat::Lcr => 3, - ChannelFormat::Quad | ChannelFormat::Lcrs => 4, - ChannelFormat::Surround50 => 5, - ChannelFormat::Surround51 | ChannelFormat::Surround60 => 6, - ChannelFormat::Surround61 | ChannelFormat::Sdds70 | ChannelFormat::Surround70 | ChannelFormat::Atmos502 => 7, - ChannelFormat::Sdds71 | ChannelFormat::Surround71 | ChannelFormat::Atmos512 => 8, - ChannelFormat::Atmos702 | ChannelFormat::Atmos504 => 9, - ChannelFormat::Atmos712 | ChannelFormat::Atmos514 => 10, - ChannelFormat::Atmos704 => 11, - ChannelFormat::Atmos714 => 12, - ChannelFormat::Atmos706 | ChannelFormat::Atmos904 => 13, - ChannelFormat::Atmos716 | ChannelFormat::Atmos914 => 14, - ChannelFormat::Atmos906 => 15, - ChannelFormat::Atmos916 => 16, - ChannelFormat::Ambisonics(n) => { - let n = usize::from(n.clamp(1, 7)) + 1; - n * n - } - } - } - pub fn label(self) -> &'static str { - match self { - ChannelFormat::Mono => "Mono", - ChannelFormat::Stereo => "Stereo", - ChannelFormat::Lcr => "LCR", - ChannelFormat::Quad => "Quad", - ChannelFormat::Lcrs => "LCRS", - ChannelFormat::Surround50 => "5.0", - ChannelFormat::Surround51 => "5.1", - ChannelFormat::Surround60 => "6.0", - ChannelFormat::Surround61 => "6.1", - ChannelFormat::Sdds70 => "7.0 SDDS", - ChannelFormat::Sdds71 => "7.1 SDDS", - ChannelFormat::Surround70 => "7.0", - ChannelFormat::Surround71 => "7.1", - ChannelFormat::Atmos702 => "7.0.2", - ChannelFormat::Atmos712 => "7.1.2", - ChannelFormat::Atmos502 => "5.0.2", - ChannelFormat::Atmos512 => "5.1.2", - ChannelFormat::Atmos504 => "5.0.4", - ChannelFormat::Atmos514 => "5.1.4", - ChannelFormat::Atmos704 => "7.0.4", - ChannelFormat::Atmos714 => "7.1.4", - ChannelFormat::Atmos706 => "7.0.6", - ChannelFormat::Atmos716 => "7.1.6", - ChannelFormat::Atmos904 => "9.0.4", - ChannelFormat::Atmos914 => "9.1.4", - ChannelFormat::Atmos906 => "9.0.6", - ChannelFormat::Atmos916 => "9.1.6", - ChannelFormat::Ambisonics(1) => "1st Order Ambisonics", - ChannelFormat::Ambisonics(2) => "2nd Order Ambisonics", - ChannelFormat::Ambisonics(3) => "3rd Order Ambisonics", - ChannelFormat::Ambisonics(4) => "4th Order Ambisonics", - ChannelFormat::Ambisonics(5) => "5th Order Ambisonics", - ChannelFormat::Ambisonics(6) => "6th Order Ambisonics", - ChannelFormat::Ambisonics(_) => "7th Order Ambisonics", - } - } - pub fn from_id(s: &str) -> Option { - ChannelFormat::ALL.into_iter().find(|f| f.label().eq_ignore_ascii_case(s.trim())) - } - /// Speakers in channel order, or empty for Ambisonics (ACN order, SN3D). - /// - /// Channel order is SMPTE / WAV order: speakers with a WAVE_FORMAT_EXTENSIBLE mask bit come in - /// ascending bit order (L R C LFE Ls Rs Lc Rc Cs Lss Rss Ltf Rtf Ltr Rtr; 7.x puts the rear - /// surrounds Lrs/Rrs on the "back" bits before the sides Lss/Rss), followed by speakers WAV - /// cannot name (the top-middle pair of .6 layouts). E.g. 5.1 = L R C LFE Ls Rs, - /// 7.1 = L R C LFE Lrs Rrs Lss Rss, 7.1.4 = L R C LFE Lrs Rrs Lss Rss Ltf Rtf Ltr Rtr. - pub fn speakers(self) -> &'static [Speaker] { - use Speaker::*; - match self { - ChannelFormat::Mono => &[C], - ChannelFormat::Stereo => &[L, R], - ChannelFormat::Lcr => &[L, R, C], - ChannelFormat::Quad => &[L, R, Ls, Rs], - ChannelFormat::Lcrs => &[L, R, C, Cs], - ChannelFormat::Surround50 => &[L, R, C, Ls, Rs], - ChannelFormat::Surround51 => &[L, R, C, Lfe, Ls, Rs], - ChannelFormat::Surround60 => &[L, R, C, Ls, Rs, Cs], - ChannelFormat::Surround61 => &[L, R, C, Lfe, Ls, Rs, Cs], - ChannelFormat::Sdds70 => &[L, R, C, Ls, Rs, Lc, Rc], - ChannelFormat::Sdds71 => &[L, R, C, Lfe, Ls, Rs, Lc, Rc], - ChannelFormat::Surround70 => &[L, R, C, Lrs, Rrs, Lss, Rss], - ChannelFormat::Surround71 => &[L, R, C, Lfe, Lrs, Rrs, Lss, Rss], - ChannelFormat::Atmos702 => &[L, R, C, Lrs, Rrs, Lss, Rss, Ltm, Rtm], - ChannelFormat::Atmos712 => &[L, R, C, Lfe, Lrs, Rrs, Lss, Rss, Ltm, Rtm], - ChannelFormat::Atmos502 => &[L, R, C, Ls, Rs, Ltm, Rtm], - ChannelFormat::Atmos512 => &[L, R, C, Lfe, Ls, Rs, Ltm, Rtm], - ChannelFormat::Atmos504 => &[L, R, C, Ls, Rs, Ltf, Rtf, Ltr, Rtr], - ChannelFormat::Atmos514 => &[L, R, C, Lfe, Ls, Rs, Ltf, Rtf, Ltr, Rtr], - ChannelFormat::Atmos704 => &[L, R, C, Lrs, Rrs, Lss, Rss, Ltf, Rtf, Ltr, Rtr], - ChannelFormat::Atmos714 => &[L, R, C, Lfe, Lrs, Rrs, Lss, Rss, Ltf, Rtf, Ltr, Rtr], - ChannelFormat::Atmos706 => &[L, R, C, Lrs, Rrs, Lss, Rss, Ltf, Rtf, Ltr, Rtr, Ltm, Rtm], - ChannelFormat::Atmos716 => &[L, R, C, Lfe, Lrs, Rrs, Lss, Rss, Ltf, Rtf, Ltr, Rtr, Ltm, Rtm], - ChannelFormat::Atmos904 => &[L, R, C, Lrs, Rrs, Lw, Rw, Lss, Rss, Ltf, Rtf, Ltr, Rtr], - ChannelFormat::Atmos914 => &[L, R, C, Lfe, Lrs, Rrs, Lw, Rw, Lss, Rss, Ltf, Rtf, Ltr, Rtr], - ChannelFormat::Atmos906 => &[L, R, C, Lrs, Rrs, Lw, Rw, Lss, Rss, Ltf, Rtf, Ltr, Rtr, Ltm, Rtm], - ChannelFormat::Atmos916 => &[L, R, C, Lfe, Lrs, Rrs, Lw, Rw, Lss, Rss, Ltf, Rtf, Ltr, Rtr, Ltm, Rtm], - ChannelFormat::Ambisonics(_) => &[], - } - } - pub fn is_ambisonic(self) -> bool { - matches!(self, ChannelFormat::Ambisonics(_)) - } - pub fn has_lfe(self) -> bool { - self.speakers().contains(&Speaker::Lfe) - } - pub fn has_height(self) -> bool { - self.speakers().iter().any(|s| s.is_height()) - } - /// Short per-channel labels for meters (`W Y Z X 5…` for Ambisonics). - pub fn channel_label(self, ch: usize) -> String { - match self.speakers().get(ch) { - Some(s) => s.label().to_string(), - None if self.is_ambisonic() => ["W", "Y", "Z", "X"].get(ch).map_or_else(|| format!("{}", ch + 1), ToString::to_string), - None => format!("{}", ch + 1), - } - } - /// WAVE_FORMAT_EXTENSIBLE channel mask (0 = no positions, e.g. Ambisonics). Speakers that WAV - /// cannot name (top middle) borrow the top-front bits when the layout has no top fronts. - pub fn channel_mask(self) -> u32 { - let sp = self.speakers(); - let has_tf = sp.contains(&Speaker::Ltf); - sp.iter().fold(0u32, |m, s| match s { - Speaker::Ltm if !has_tf => m | 0x1000, - Speaker::Rtm if !has_tf => m | 0x4000, - s => m | s.wave_bit(), - }) - } - /// Best format for a channel count. - pub fn for_channels(n: usize) -> ChannelFormat { - [ - ChannelFormat::Mono, - ChannelFormat::Stereo, - ChannelFormat::Lcr, - ChannelFormat::Quad, - ChannelFormat::Surround50, - ChannelFormat::Surround51, - ChannelFormat::Surround70, - ChannelFormat::Surround71, - ] - .into_iter() - .find(|f| f.channels() == n) - .unwrap_or(if n <= 1 { ChannelFormat::Mono } else { ChannelFormat::Stereo }) - } -} - -/// A loudspeaker position in a channel format. -/// -/// Angles follow ITU-R BS.775 / Dolby conventions: azimuth in degrees, 0 = front centre, positive -/// = to the right; elevation in degrees above the listener plane. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum Speaker { - L, - R, - C, - Lfe, - /// 5.x surrounds (±110°). - Ls, - Rs, - /// SDDS inner fronts (±15°). - Lc, - Rc, - /// Centre surround (180°). - Cs, - /// 7.x side surrounds (±90°). - Lss, - Rss, - /// 7.x rear surrounds (±150°). - Lrs, - Rrs, - /// 9.x front wides (±60°). - Lw, - Rw, - /// Top front (±45°, elevation 45°). - Ltf, - Rtf, - /// Top middle (±90°, elevation 45°). - Ltm, - Rtm, - /// Top rear (±135°, elevation 45°). - Ltr, - Rtr, -} - -impl Speaker { - pub fn azimuth(self) -> f32 { - match self { - Speaker::L => -30.0, - Speaker::R => 30.0, - Speaker::C | Speaker::Lfe => 0.0, - Speaker::Ls => -110.0, - Speaker::Rs => 110.0, - Speaker::Lc => -15.0, - Speaker::Rc => 15.0, - Speaker::Cs => 180.0, - Speaker::Lss => -90.0, - Speaker::Rss => 90.0, - Speaker::Lrs => -150.0, - Speaker::Rrs => 150.0, - Speaker::Lw => -60.0, - Speaker::Rw => 60.0, - Speaker::Ltf => -45.0, - Speaker::Rtf => 45.0, - Speaker::Ltm => -90.0, - Speaker::Rtm => 90.0, - Speaker::Ltr => -135.0, - Speaker::Rtr => 135.0, - } - } - pub fn elevation(self) -> f32 { - if self.is_height() { 45.0 } else { 0.0 } - } - pub fn is_height(self) -> bool { - matches!(self, Speaker::Ltf | Speaker::Rtf | Speaker::Ltm | Speaker::Rtm | Speaker::Ltr | Speaker::Rtr) - } - pub fn is_lfe(self) -> bool { - self == Speaker::Lfe - } - pub fn label(self) -> &'static str { - match self { - Speaker::L => "L", - Speaker::R => "R", - Speaker::C => "C", - Speaker::Lfe => "LFE", - Speaker::Ls => "Ls", - Speaker::Rs => "Rs", - Speaker::Lc => "Lc", - Speaker::Rc => "Rc", - Speaker::Cs => "Cs", - Speaker::Lss => "Lss", - Speaker::Rss => "Rss", - Speaker::Lrs => "Lrs", - Speaker::Rrs => "Rrs", - Speaker::Lw => "Lw", - Speaker::Rw => "Rw", - Speaker::Ltf => "Ltf", - Speaker::Rtf => "Rtf", - Speaker::Ltm => "Ltm", - Speaker::Rtm => "Rtm", - Speaker::Ltr => "Ltr", - Speaker::Rtr => "Rtr", - } - } - /// WAVE_FORMAT_EXTENSIBLE `dwChannelMask` bit (0 for speakers WAV cannot name). - pub fn wave_bit(self) -> u32 { - match self { - Speaker::L => 0x1, - Speaker::R => 0x2, - Speaker::C => 0x4, - Speaker::Lfe => 0x8, - Speaker::Ls | Speaker::Lrs => 0x10, - Speaker::Rs | Speaker::Rrs => 0x20, - Speaker::Lc | Speaker::Lw => 0x40, - Speaker::Rc | Speaker::Rw => 0x80, - Speaker::Cs => 0x100, - Speaker::Lss => 0x200, - Speaker::Rss => 0x400, - Speaker::Ltf => 0x1000, - Speaker::Rtf => 0x4000, - Speaker::Ltr => 0x8000, - Speaker::Rtr => 0x2_0000, - Speaker::Ltm | Speaker::Rtm => 0, - } - } -} - -/// Surround panner position (Pro Tools-style X/Y puck). `None` on a mixer means "use the stereo -/// pan", which keeps sessions made before surround mixing sounding exactly as they did. -#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)] -#[serde(default)] -pub struct SurroundPan { - /// -1 (left) ..= 1 (right). - pub x: f32, - /// -1 (back) ..= 1 (front). - pub y: f32, - /// Elevation 0 (ear level) ..= 1 (overhead), used by height formats. - pub z: f32, - /// 0 = point source ..= 1 = spread over every speaker. - pub divergence: f32, - /// Centre speaker share of front-centre images, 0..=100 % (0 = phantom centre on L/R). - pub center: f32, - /// LFE send level, dB (-144 = off). - pub lfe_db: f32, -} - -impl Default for SurroundPan { - fn default() -> Self { - SurroundPan { x: 0.0, y: 1.0, z: 0.0, divergence: 0.0, center: 100.0, lfe_db: -144.0 } - } -} - -impl SurroundPan { - /// Puck at the stereo pan position (front edge). - pub fn from_stereo(pan: f32) -> Self { - SurroundPan { x: finite_or(pan, 0.0).clamp(-1.0, 1.0), ..SurroundPan::default() } - } - /// Clamp into range (NaN → defaults). - pub fn sanitize(&mut self) { - let d = SurroundPan::default(); - self.x = finite_or(self.x, d.x).clamp(-1.0, 1.0); - self.y = finite_or(self.y, d.y).clamp(-1.0, 1.0); - self.z = finite_or(self.z, d.z).clamp(0.0, 1.0); - self.divergence = finite_or(self.divergence, d.divergence).clamp(0.0, 1.0); - self.center = finite_or(self.center, d.center).clamp(0.0, 100.0); - self.lfe_db = finite_or(self.lfe_db, d.lfe_db).clamp(-144.0, 12.0); - } -} - -/// An internal mix bus (Pro Tools "bus" paths). -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Bus { - pub id: BusId, - pub name: String, - pub format: ChannelFormat, -} - -/// Physical output paths (from the I/O setup). -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct OutputPath { - pub name: String, - /// First hardware channel (0-based). - pub first_channel: u16, - pub format: ChannelFormat, -} - -/// Where a signal goes or comes from. -#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum Route { - #[default] - None, - /// The main output (hardware outputs 1-2, or the bounce source). - Main, - Bus(BusId), - /// Hardware input/output by path name. - Hardware(String), -} - -/// A plugin instance on an insert slot. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Insert { - /// Registry id from `soundcraft-dsp` (e.g. `eq7`, `comp`). - pub plugin: String, - #[serde(default, deserialize_with = "finite_params")] - pub params: BTreeMap, - #[serde(default)] - pub bypass: bool, - #[serde(default = "yes")] - pub active: bool, - /// Preset name shown in the plugin window header. - #[serde(default)] - pub preset: String, - /// Opaque plugin state (third-party plugins: CLAP state / VST3 component + controller - /// state), standard base64. Restored into a new instance before it first processes. - #[serde(default, skip_serializing_if = "Option::is_none")] - pub state: Option, - /// The session audio source a sample-playing instrument (the built-in Sampler) plays. - #[serde(default, skip_serializing_if = "Option::is_none")] - pub sample: Option, -} - -fn yes() -> bool { - true -} - -impl Insert { - pub fn new(plugin: impl Into) -> Self { - Insert { - plugin: plugin.into(), - params: BTreeMap::new(), - bypass: false, - active: true, - preset: String::from(""), - state: None, - sample: None, - } - } - - /// The decoded plugin state (`None` when absent or malformed). - pub fn state_bytes(&self) -> Option> { - self.state.as_deref().and_then(crate::b64::decode) - } - - /// Stores a plugin state blob (base64-encoded); an empty blob clears it. - pub fn set_state_bytes(&mut self, data: &[u8]) { - self.state = (!data.is_empty()).then(|| crate::b64::encode(data)); - } -} - -/// A send to a bus. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct SendSlot { - pub target: Route, - pub level_db: f32, - pub pan: f32, - pub mute: bool, - pub pre_fader: bool, - #[serde(default = "yes")] - pub follow_main_pan: bool, - /// Surround position into a multichannel bus (None = follow the track / stereo pan). - #[serde(default)] - pub surround: Option, -} - -impl SendSlot { - pub fn new(target: Route) -> Self { - SendSlot { target, level_db: -144.0, pan: 0.0, mute: false, pre_fader: false, follow_main_pan: true, surround: None } - } -} - -/// The channel strip. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Mixer { - pub volume_db: f32, - /// One panner per source channel for mono/stereo (stereo tracks: two panners, default hard L/R). - pub pan: Vec, - pub mute: bool, - pub solo: bool, - #[serde(default)] - pub solo_safe: bool, - /// Live record-enable state. Runtime-only: opening a session must never arm an input. - #[serde(skip)] - pub record_arm: bool, - /// Live input-monitor state. Runtime-only: opening a session must never enable monitoring. - #[serde(skip)] - pub input_monitor: bool, - #[serde(default)] - pub phase_invert: bool, - pub input: Route, - pub output: Route, - pub inserts: Vec>, - pub sends: Vec>, - pub automation_mode: AutomationMode, - /// Input gain / trim, dB. - #[serde(default)] - pub trim_db: f32, - /// VCA master that controls this track, if any (track id of the VCA). - #[serde(default)] - pub vca: Option, - /// Surround panner, used when the output is multichannel (None = the stereo pan to L/R). - #[serde(default)] - pub surround: Option, -} - -impl Mixer { - pub fn new(format: ChannelFormat) -> Self { - let pan = match format { - ChannelFormat::Mono => vec![0.0], - ChannelFormat::Stereo => vec![-1.0, 1.0], - _ => Vec::new(), - }; - Mixer { - volume_db: 0.0, - pan, - mute: false, - solo: false, - solo_safe: false, - record_arm: false, - input_monitor: false, - phase_invert: false, - input: Route::None, - output: Route::Main, - inserts: vec![None; INSERT_SLOTS], - sends: vec![None; SEND_SLOTS], - automation_mode: AutomationMode::Read, - trim_db: 0.0, - vca: None, - surround: None, - } - } - - /// Clamp everything into range (after deserialising untrusted files). - pub fn sanitize(&mut self) { - self.volume_db = finite_or(self.volume_db, 0.0).clamp(-144.0, 12.0); - for p in &mut self.pan { - *p = finite_or(*p, 0.0).clamp(-1.0, 1.0); - } - self.inserts.resize(INSERT_SLOTS, None); - self.sends.resize(SEND_SLOTS, None); - for s in self.sends.iter_mut().flatten() { - s.level_db = finite_or(s.level_db, -144.0).clamp(-144.0, 12.0); - s.pan = finite_or(s.pan, 0.0).clamp(-1.0, 1.0); - if let Some(sp) = &mut s.surround { - sp.sanitize(); - } - } - if let Some(sp) = &mut self.surround { - sp.sanitize(); - } - self.trim_db = finite_or(self.trim_db, 0.0).clamp(-144.0, 24.0); - } -} - -impl crate::Session { - /// The main mix format: the format of the first (main) output path, at least stereo and at - /// most 16 channels (wider formats fall back to stereo). - pub fn main_format(&self) -> ChannelFormat { - match self.outputs.first().map(|o| o.format) { - Some(f) if (2..=16).contains(&f.channels()) => f, - _ => ChannelFormat::Stereo, - } - } -} - -pub(crate) fn finite_or(v: f32, d: f32) -> f32 { - if v.is_finite() { v } else { d } -} - -/// Parameters saved as `null` (how JSON writes NaN and infinity) or beyond `f32` are dropped, so -/// they keep their defaults instead of failing the whole session. -fn finite_params<'de, D: serde::Deserializer<'de>>(d: D) -> Result, D::Error> { - let params: BTreeMap> = serde::Deserialize::deserialize(d)?; - Ok(params.into_iter().filter_map(|(k, v)| Some((k, v.map(|v| v as f32).filter(|v| v.is_finite())?))).collect()) -} - -/// Fader taper used by Pro Tools-style faders: position 0..1 ↔ dB (-inf..+12). -pub fn fader_pos_to_db(pos: f32) -> f32 { - let p = finite_or(pos, 0.0).clamp(0.0, 1.0); - if p <= 0.0 { - return -144.0; - } - // Piecewise: top 75 % covers -24..+12 linearly-ish, the bottom compresses to -inf. - if p >= 0.25 { -24.0 + (p - 0.25) / 0.75 * 36.0 } else { -24.0 - (1.0 - p / 0.25).powf(1.5) * 120.0 } -} - -pub fn fader_db_to_pos(db: f32) -> f32 { - let db = finite_or(db, -144.0); - if db <= -144.0 { - return 0.0; - } - if db >= -24.0 { - (0.25 + (db.min(12.0) + 24.0) / 36.0 * 0.75).min(1.0) - } else { - let x = ((-24.0 - db) / 120.0).clamp(0.0, 1.0).powf(1.0 / 1.5); - ((1.0 - x) * 0.25).max(0.0) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn insert_state_round_trips_through_json() { - let mut i = Insert::new("vst3:00"); - assert_eq!(i.state_bytes(), None); - let blob: Vec = (0..=255u8).cycle().take(1000).collect(); - i.set_state_bytes(&blob); - let json = serde_json::to_string(&i).unwrap(); - let back: Insert = serde_json::from_str(&json).unwrap(); - assert_eq!(back.state_bytes().unwrap(), blob); - i.set_state_bytes(&[]); - assert_eq!(i.state, None); - // Old sessions have no `state`; stateless inserts don't write one. - let old: Insert = serde_json::from_str(r#"{"plugin":"eq_7band"}"#).unwrap(); - assert_eq!(old.state, None); - assert!(!serde_json::to_string(&old).unwrap().contains("state")); - // A hostile state string decodes to nothing rather than failing the load. - let bad: Insert = serde_json::from_str(r#"{"plugin":"x","state":"!!!"}"#).unwrap(); - assert_eq!(bad.state_bytes(), None); - } - - #[test] - fn params_saved_as_null_or_out_of_range_are_dropped() { - let mut i = Insert::new("eq_7band"); - i.params.extend([("gain".to_string(), f32::NAN), ("q".to_string(), 0.7)]); - let back: Insert = serde_json::from_str(&serde_json::to_string(&i).unwrap()).unwrap(); - assert_eq!(back.params, BTreeMap::from([("q".to_string(), 0.7)])); - let big: Insert = serde_json::from_str(r#"{"plugin":"x","params":{"gain":1e39,"q":0.5}}"#).unwrap(); - assert_eq!(big.params, BTreeMap::from([("q".to_string(), 0.5)])); - } - - #[test] - fn fader_taper_round_trips() { - for db in [-100.0f32, -60.0, -24.0, -10.0, 0.0, 6.0, 12.0] { - let p = fader_db_to_pos(db); - assert!((fader_pos_to_db(p) - db).abs() < 0.05, "{db} → {p}"); - } - assert_eq!(fader_pos_to_db(0.0), -144.0); - assert_eq!(fader_db_to_pos(f32::NAN), 0.0); - } - - #[test] - fn mixer_defaults_and_sanitize() { - let mut m = Mixer::new(ChannelFormat::Stereo); - assert_eq!(m.pan, vec![-1.0, 1.0]); - m.volume_db = f32::INFINITY; - m.inserts.truncate(2); - m.sanitize(); - assert_eq!(m.volume_db, 0.0); - assert_eq!(m.inserts.len(), INSERT_SLOTS); - } - - #[test] - fn speaker_layouts_match_channel_counts_and_masks() { - for f in ChannelFormat::ALL { - if !f.is_ambisonic() { - assert_eq!(f.speakers().len(), f.channels(), "{f:?}"); - // Mask bits are unique and in ascending channel order. - let bits: Vec = f.speakers().iter().map(|s| s.wave_bit()).filter(|b| *b != 0).collect(); - assert!(bits.windows(2).all(|w| w[0] < w[1]), "{f:?} not in WAV order"); - } - } - assert_eq!(ChannelFormat::Surround51.channel_mask(), 0x3F); - assert_eq!(ChannelFormat::Surround71.channel_mask(), 0x63F); - assert_eq!(ChannelFormat::Atmos714.channel_mask(), 0x2_D63F); - assert_eq!(ChannelFormat::Ambisonics(1).channel_mask(), 0); - } - - #[test] - fn surround_pan_defaults_and_old_sessions() { - let m = Mixer::new(ChannelFormat::Mono); - assert_eq!(m.surround, None); - // A mixer saved before surround existed still loads. - let mut v = serde_json::to_value(&m).unwrap(); - v.as_object_mut().unwrap().remove("surround"); - let back: Mixer = serde_json::from_value(v).unwrap(); - assert_eq!(back.surround, None); - let mut sp: SurroundPan = serde_json::from_str(r#"{"x": 5.0}"#).unwrap(); - sp.sanitize(); - assert_eq!(sp.x, 1.0); - assert_eq!(sp.center, 100.0); - } - - #[test] - fn formats() { - assert_eq!(ChannelFormat::for_channels(6), ChannelFormat::Surround51); - assert_eq!(ChannelFormat::from_id("stereo"), Some(ChannelFormat::Stereo)); - } -} diff --git a/crates/model/src/session.rs b/crates/model/src/session.rs deleted file mode 100644 index a489d28b..00000000 --- a/crates/model/src/session.rs +++ /dev/null @@ -1,1303 +0,0 @@ -//! The session: the whole document. - -use crate::clip::{bound, bound_sequence}; -use crate::{ - Bus, BusId, ChannelFormat, Clip, ClipId, Group, GroupId, MarkerId, MarkerKind, MemoryLocation, OutputPath, Source, SourceId, SourcePool, - TRACK_COLORS, Track, TrackId, TrackKind, VideoSource, -}; -use soundcraft_time::{FrameRate, GridScale, GridValue, Range, SampleRate, Samples, TempoMap, TimeFormat}; - -/// Native session file extension. -pub const SESSION_EXTENSION: &str = "scraft"; - -/// `EditState::values` key holding the feet+frames reading of sample 0, in frames. -pub const FEET_FRAMES_START: &str = "feet_frames.start"; - -#[derive(Debug, Clone, PartialEq, thiserror::Error)] -pub enum SessionError { - #[error("not a SoundCraft session: {0}")] - Format(String), - #[error("session file version {0} is newer than this SoundCraft supports")] - Version(u32), - #[error("{0}")] - Invalid(String), -} - -/// Session bit depth for recording/rendering. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum BitDepthSetting { - Int16, - #[default] - Int24, - Float32, -} - -/// Edit modes. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum EditMode { - Shuffle, - #[default] - Slip, - Spot, - Grid, - /// Relative grid: moves keep their offset from the grid. - GridRelative, -} - -impl EditMode { - pub fn label(self) -> &'static str { - match self { - EditMode::Shuffle => "SHUFFLE", - EditMode::Slip => "SLIP", - EditMode::Spot => "SPOT", - EditMode::Grid => "GRID", - EditMode::GridRelative => "REL GRID", - } - } - pub fn from_id(s: &str) -> Option { - match s.to_ascii_lowercase().as_str() { - "shuffle" => Some(EditMode::Shuffle), - "slip" => Some(EditMode::Slip), - "spot" => Some(EditMode::Spot), - "grid" | "absolute_grid" => Some(EditMode::Grid), - "relative_grid" | "rel_grid" | "grid_relative" => Some(EditMode::GridRelative), - _ => None, - } - } - pub fn is_grid(self) -> bool { - matches!(self, EditMode::Grid | EditMode::GridRelative) - } -} - -/// Edit tools. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum Tool { - Zoom, - Trim, - #[default] - Selector, - Grabber, - Scrubber, - Pencil, - Smart, -} - -impl Tool { - pub const ALL: [Tool; 7] = [Tool::Zoom, Tool::Trim, Tool::Selector, Tool::Grabber, Tool::Scrubber, Tool::Pencil, Tool::Smart]; - pub fn id(self) -> &'static str { - match self { - Tool::Zoom => "zoom", - Tool::Trim => "trim", - Tool::Selector => "selector", - Tool::Grabber => "grabber", - Tool::Scrubber => "scrubber", - Tool::Pencil => "pencil", - Tool::Smart => "smart", - } - } - pub fn label(self) -> &'static str { - match self { - Tool::Zoom => "Zoomer", - Tool::Trim => "Trim", - Tool::Selector => "Selector", - Tool::Grabber => "Grabber", - Tool::Scrubber => "Scrubber", - Tool::Pencil => "Pencil", - Tool::Smart => "Smart Tool", - } - } - pub fn from_id(s: &str) -> Option { - Tool::ALL.into_iter().find(|t| t.id() == s.to_ascii_lowercase()) - } - /// F-key shortcut (F5..F10) like the incumbent. - pub fn fkey(self) -> Option<&'static str> { - match self { - Tool::Zoom => Some("F5"), - Tool::Trim => Some("F6"), - Tool::Selector => Some("F7"), - Tool::Grabber => Some("F8"), - Tool::Scrubber => Some("F9"), - Tool::Pencil => Some("F10"), - Tool::Smart => None, - } - } -} - -/// Track view lanes. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum TrackView { - Waveform, - Blocks, - Volume, - Pan, - Mute, -} - -/// Horizontal zoom + scroll. -#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct ZoomState { - /// Samples per pixel (point). - pub samples_per_px: f64, - /// Left edge of the visible timeline. - pub scroll: Samples, - /// Waveform vertical zoom factor. - pub waveform_zoom: f32, - /// Zoom preset memories 1..5. - pub presets: [f64; 5], -} - -impl Default for ZoomState { - /// Starts with a practical overview zoom and five reusable preset levels. - fn default() -> Self { - ZoomState { samples_per_px: 1024.0, scroll: 0, waveform_zoom: 1.0, presets: [64.0, 256.0, 1024.0, 4096.0, 16384.0] } - } -} - -/// The view Zoom Toggle goes back to. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct ZoomToggle { - pub samples_per_px: f64, - pub scroll: Samples, - pub heights: Vec<(TrackId, crate::TrackHeight)>, -} - -/// Edit-window state saved with the session (selection, tools, modes, view settings). -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct EditState { - pub tool: Tool, - pub edit_mode: EditMode, - /// The edit selection (a point = insertion position). - pub selection: Range, - /// Tracks in the edit selection. - pub selected_tracks: Vec, - /// Clips explicitly selected (Grabber selection). - #[serde(default)] - pub selected_clips: Vec, - /// Audio files selected in the Clip List. - #[serde(default)] - pub selected_sources: Vec, - /// Playhead position when stopped. - pub playhead: Samples, - pub grid: GridValue, - pub nudge: GridValue, - /// Grid/Nudge time scales follow the main counter when enabled. - #[serde(default)] - pub grid_follow_main: bool, - #[serde(default)] - pub nudge_follow_main: bool, - /// Grid lines and snapping use visible clip boundaries and memory locations while the numeric - /// Grid value is retained for when this mode is left. - #[serde(default)] - pub grid_clips_markers: bool, - #[serde(default = "yes")] - pub grid_lines: bool, - pub main_counter: TimeFormat, - pub sub_counter: Option, - pub zoom: ZoomState, - /// Set while Zoom Toggle is on. - pub zoom_toggle: Option, - /// Visible rulers. - pub rulers: Vec, - pub link_timeline_edit: bool, - pub link_track_edit: bool, - pub insertion_follows_playback: bool, - pub loop_playback: bool, - pub pre_post_roll: bool, - pub pre_roll: Samples, - pub post_roll: Samples, - pub tab_to_transient: bool, - pub automation_follows_edit: bool, - pub markers_follow_edit: bool, - pub layered_editing: bool, - pub mirrored_midi: bool, - pub click: bool, - pub countoff: bool, - pub countoff_bars: u32, - pub midi_merge: bool, - pub record_mode: String, - pub loop_record: bool, - pub quickpunch: bool, - pub scrolling: String, - pub solo_mode: String, - pub pre_fader_metering: bool, - pub delay_compensation: bool, - pub keyboard_focus: String, - /// Timeline selection when it is unlinked from the edit selection. - pub timeline_selection: Range, - /// Generic on/off view and option flags keyed by id (e.g. `view.clip.name`, `waveform.rectified`, - /// `options.midi_thru`). Saved with the session so every view setting persists. - #[serde(default)] - pub flags: std::collections::BTreeSet, - /// Numeric settings keyed by id (e.g. `click.volume_db`, `engine.buffer_size`). - #[serde(default)] - pub values: std::collections::BTreeMap, -} - -impl EditState { - pub fn flag(&self, id: &str) -> bool { - self.flags.contains(id) - } - pub fn set_flag(&mut self, id: &str, on: bool) { - if on { - self.flags.insert(id.to_string()); - } else { - self.flags.remove(id); - } - } - pub fn value(&self, id: &str, default: f64) -> f64 { - self.values.get(id).copied().filter(|v| v.is_finite()).unwrap_or(default) - } -} - -fn yes() -> bool { - true -} - -impl Default for EditState { - /// Starts the Edit window in Slip mode with independent Grid and Nudge scales. - fn default() -> Self { - EditState { - tool: Tool::Smart, - edit_mode: EditMode::Slip, - selection: Range::default(), - selected_tracks: Vec::new(), - selected_clips: Vec::new(), - selected_sources: Vec::new(), - playhead: 0, - grid: GridValue::default(), - nudge: GridValue::Seconds(1.0), - grid_follow_main: false, - nudge_follow_main: false, - grid_clips_markers: false, - grid_lines: true, - main_counter: TimeFormat::MinSecs, - sub_counter: Some(TimeFormat::Samples), - zoom: ZoomState::default(), - zoom_toggle: None, - rulers: vec!["bars_beats".into(), "min_secs".into(), "tempo".into(), "meter".into(), "markers".into()], - link_timeline_edit: true, - link_track_edit: false, - insertion_follows_playback: false, - loop_playback: false, - pre_post_roll: false, - pre_roll: 96_000, - post_roll: 96_000, - tab_to_transient: false, - automation_follows_edit: true, - markers_follow_edit: false, - layered_editing: false, - mirrored_midi: false, - click: false, - countoff: false, - countoff_bars: 2, - midi_merge: false, - record_mode: "normal".into(), - loop_record: false, - quickpunch: false, - scrolling: "page".into(), - solo_mode: "sip".into(), - pre_fader_metering: false, - delay_compensation: true, - keyboard_focus: "commands".into(), - timeline_selection: Range::default(), - flags: ["view.clip.name", "view.clip.gain_line", "waveform.peak", "view.clip.overlap_shadows", "view.marker.ruler_lines"] - .iter() - .map(ToString::to_string) - .collect(), - values: std::collections::BTreeMap::new(), - } - } -} - -/// Clip List › Auto Rename: the names that editing gives the clips it separates from a clip. -/// Each new clip is named `name`, then `zeros` zeros, then `number`, then `suffix`, and `number` -/// counts up by one for the next clip. -#[derive(Debug, Clone, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)] -pub struct AutoName { - pub name: String, - /// The number the next new clip gets. - pub number: u64, - pub zeros: usize, - pub suffix: String, - /// Tells this scheme from another one under the same key after an undo or in another session, - /// for pastes from the clipboard. 0 matches no scheme. - #[serde(default)] - pub id: u64, -} - -impl AutoName { - /// The largest starting number. - pub const MAX_NUMBER: u64 = 999_999_999; - /// The most zeros before the number. - pub const MAX_ZEROS: usize = 9; - - /// Room for `name` and `suffix` together: 29 characters stay free for 9 zeros and the 20 - /// digits of a u64, so a clip name never loses its number to [`MAX_NAME_CHARS`]. - pub const MAX_TEXT_CHARS: usize = MAX_NAME_CHARS - 29; - - /// Repair a scheme read from a file: names that can be drawn and at most [`Self::MAX_ZEROS`] zeros. - pub fn sanitize(&mut self) { - truncate_chars(&mut self.name, Self::MAX_TEXT_CHARS); - truncate_chars(&mut self.suffix, Self::MAX_TEXT_CHARS - self.name.chars().count()); - self.zeros = self.zeros.min(Self::MAX_ZEROS); - } -} - -/// The document. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Session { - pub format_version: u32, - pub name: String, - pub sample_rate: SampleRate, - pub bit_depth: BitDepthSetting, - pub frame_rate: FrameRate, - /// Timecode of sample 0 (session start), as a sample count. - pub timecode_start: Samples, - pub tempo: TempoMap, - #[serde(default)] - pub key_signatures: Vec<(Samples, String)>, - pub tracks: Vec, - pub sources: Vec, - /// Movies referenced by Video track clips. - #[serde(default)] - pub videos: Vec, - pub busses: Vec, - pub outputs: Vec, - pub markers: Vec, - pub groups: Vec, - /// Clip List › Auto Rename schemes, keyed by the ids in [`Clip::auto_name`]. The clips separated - /// from one clip share its scheme, so they count up one number sequence. - #[serde(default)] - pub auto_names: std::collections::BTreeMap, - pub edit: EditState, - pub next_id: u64, - #[serde(default)] - pub comments: String, - /// Original MIDI performances keyed by clip id (Event › MIDI Operations › Restore/Flatten - /// Performance). Independent of undo so a restore survives later edits. - #[serde(default)] - pub midi_originals: std::collections::BTreeMap, - #[serde(skip)] - pub pool: SourcePool, - /// The folder relative source paths point into: where the session was opened or last saved. - #[serde(skip)] - pub folder: Option, -} - -impl Default for Session { - fn default() -> Self { - Session::new("Untitled", SampleRate::HZ_48000) - } -} - -impl Session { - pub const FORMAT_VERSION: u32 = 1; - - pub fn new(name: impl Into, sample_rate: SampleRate) -> Self { - let mut s = Session { - format_version: Self::FORMAT_VERSION, - name: name.into(), - sample_rate, - bit_depth: BitDepthSetting::Int24, - frame_rate: FrameRate::Fps30, - timecode_start: 0, - tempo: TempoMap::default(), - key_signatures: Vec::new(), - tracks: Vec::new(), - sources: Vec::new(), - videos: Vec::new(), - busses: Vec::new(), - outputs: vec![OutputPath { name: "Out 1-2".into(), first_channel: 0, format: ChannelFormat::Stereo }], - markers: Vec::new(), - groups: Vec::new(), - auto_names: std::collections::BTreeMap::new(), - edit: EditState::default(), - next_id: 1, - comments: String::new(), - midi_originals: std::collections::BTreeMap::new(), - pool: SourcePool::default(), - folder: None, - }; - s.edit.pre_roll = sample_rate.samples(2.0); - s.edit.post_roll = sample_rate.samples(2.0); - s - } - - /// Allocate a fresh id. - pub fn alloc(&mut self) -> u64 { - let id = self.next_id.max(1); - self.next_id = id.saturating_add(1); - id - } - - // ---- lookups ------------------------------------------------------------------------- - - pub fn track(&self, id: TrackId) -> Option<&Track> { - self.tracks.iter().find(|t| t.id == id) - } - pub fn track_mut(&mut self, id: TrackId) -> Option<&mut Track> { - self.tracks.iter_mut().find(|t| t.id == id) - } - pub fn track_index(&self, id: TrackId) -> Option { - self.tracks.iter().position(|t| t.id == id) - } - pub fn track_by_name(&self, name: &str) -> Option<&Track> { - self.tracks.iter().find(|t| t.name == name).or_else(|| self.tracks.iter().find(|t| t.name.eq_ignore_ascii_case(name))) - } - pub fn master(&self) -> Option<&Track> { - self.tracks.iter().find(|t| t.kind == TrackKind::Master) - } - pub fn source(&self, id: SourceId) -> Option<&Source> { - self.sources.iter().find(|s| s.id == id) - } - pub fn video(&self, id: SourceId) -> Option<&VideoSource> { - self.videos.iter().find(|v| v.id == id) - } - pub fn bus(&self, id: BusId) -> Option<&Bus> { - self.busses.iter().find(|b| b.id == id) - } - pub fn bus_by_name(&self, name: &str) -> Option<&Bus> { - self.busses.iter().find(|b| b.name.eq_ignore_ascii_case(name)) - } - pub fn group(&self, id: GroupId) -> Option<&Group> { - self.groups.iter().find(|g| g.id == id) - } - pub fn marker(&self, id: MarkerId) -> Option<&MemoryLocation> { - self.markers.iter().find(|m| m.id == id) - } - - /// Find a clip anywhere (active playlists). - pub fn find_clip(&self, id: ClipId) -> Option<(TrackId, &Clip)> { - self.tracks.iter().find_map(|t| t.clips().iter().find(|c| c.id == id).map(|c| (t.id, c))) - } - - pub fn find_clip_mut(&mut self, id: ClipId) -> Option<&mut Clip> { - self.tracks.iter_mut().find_map(|t| t.playlist_mut().and_then(|p| p.clip_mut(id))) - } - - /// Clips on every playlist, alternates included. - pub fn all_clips(&self) -> impl Iterator { - self.tracks.iter().flat_map(|t| t.playlists.iter().flat_map(|p| &p.clips)) - } - - pub fn clips_using(&self, src: SourceId) -> impl Iterator { - self.all_clips().filter(move |c| c.source() == Some(src)) - } - - /// End of the last clip on any track (session length). - pub fn content_end(&self) -> Samples { - self.tracks.iter().filter_map(|t| t.playlist().map(|p| p.end())).max().unwrap_or(0) - } - - /// Feet+frames reading of sample 0, in frames (Setup › Current Feet+Frames Position). - pub fn feet_frames_start(&self) -> i64 { - self.edit.value(FEET_FRAMES_START, 0.0) as i64 - } - - /// Format a position against this session's timecode and feet+frames references. - pub fn format_position(&self, at: Samples, fmt: TimeFormat) -> String { - soundcraft_time::format_position(at, fmt, self.sample_rate, &self.tempo, self.frame_rate, self.timecode_start, self.feet_frames_start()) - } - - /// Parse a position typed in `fmt` against this session's references. - pub fn parse_position(&self, text: &str, fmt: TimeFormat) -> Result { - soundcraft_time::parse_position(text, fmt, self.sample_rate, &self.tempo, self.frame_rate, self.timecode_start, self.feet_frames_start()) - } - - /// Whether the Edit window shows a track: unhidden, with every parent folder open. - pub fn track_shown(&self, track: &Track) -> bool { - if track.hidden { - return false; - } - let mut folder = track.folder; - for _ in 0..64 { - let Some(parent) = folder.and_then(|id| self.track(id)) else { return true }; - if !parent.folder_open { - return false; - } - folder = parent.folder; - } - false - } - - /// Collects unique visible active-playlist clip boundaries and memory-location boundaries. - fn clip_marker_grid_points(&self, keep: impl Fn(Samples) -> bool, excluded: &[ClipId], include_zero: bool) -> Vec { - let mut points = Vec::new(); - let excluded: std::collections::HashSet = excluded.iter().copied().collect(); - if include_zero && keep(0) { - points.push(0); - } - for clip in - self.tracks.iter().filter(|track| self.track_shown(track)).flat_map(|track| track.clips()).filter(|clip| !excluded.contains(&clip.id)) - { - points.extend([clip.start, clip.end()].into_iter().filter(|point| keep(*point))); - } - for marker in &self.markers { - if keep(marker.start) { - points.push(marker.start); - } - if marker.end != marker.start && keep(marker.end) { - points.push(marker.end); - } - } - points.sort_unstable(); - points.dedup(); - points - } - - /// Sample-domain Timecode reference; Feet+Frames applies its origin in frames separately. - fn grid_origin(&self) -> Samples { - match self.edit.grid.scale() { - GridScale::Timecode => self.timecode_start, - _ => 0, - } - } - - /// Grid lines for the current Grid value, including clip and marker boundaries. - pub fn grid_lines(&self, start: Samples, end: Samples, max: usize) -> Vec { - if !self.edit.grid_clips_markers { - if let GridValue::FeetFrames(value) = self.edit.grid { - return value.lines(start, end, self.sample_rate, self.frame_rate, self.feet_frames_start(), max); - } - let origin = self.grid_origin(); - return self - .edit - .grid - .lines(start.saturating_add(origin), end.saturating_add(origin), self.sample_rate, &self.tempo, self.frame_rate, max) - .into_iter() - .map(|point| point.saturating_sub(origin)) - .collect(); - } - let points = self.clip_marker_grid_points(|point| point >= start && point < end, &[], true); - if points.len() <= max { - return points; - } - match max { - 0 => Vec::new(), - 1 => points.first().copied().into_iter().collect(), - _ => { - let span = i128::from(end).saturating_sub(i128::from(start)).max(1); - let mut bucket = None; - points - .into_iter() - .filter(|point| { - let next = i128::from(*point).saturating_sub(i128::from(start)).saturating_mul(max as i128) / span; - if bucket == Some(next) { - false - } else { - bucket = Some(next); - true - } - }) - .collect() - } - } - } - - /// The current Grid line at or before `position`. - pub fn grid_line_at_or_before(&self, position: Samples) -> Samples { - self.grid_line_at_or_before_excluding(position, &[]) - } - - /// Find the current Grid line at or before `position` without boundaries of `excluded` clips. - pub fn grid_line_at_or_before_excluding(&self, position: Samples, excluded: &[ClipId]) -> Samples { - if !self.edit.grid_clips_markers { - if let GridValue::FeetFrames(value) = self.edit.grid { - return value.line_at_or_before(position, self.sample_rate, self.frame_rate, self.feet_frames_start()); - } - let origin = self.grid_origin(); - return self - .edit - .grid - .line_at_or_before(position.saturating_add(origin), self.sample_rate, &self.tempo, self.frame_rate) - .saturating_sub(origin); - } - self.clip_marker_grid_points(|_| true, excluded, true).into_iter().take_while(|point| *point <= position).last().unwrap_or(position) - } - - /// Snap to the nearest line in the current Grid. - pub fn snap_to_grid(&self, position: Samples) -> Samples { - self.snap_to_grid_excluding(position, &[]) - } - - /// Snap to the nearest current Grid line without using boundaries of `excluded` clips. - pub fn snap_to_grid_excluding(&self, position: Samples, excluded: &[ClipId]) -> Samples { - if !self.edit.grid_clips_markers { - if let GridValue::FeetFrames(value) = self.edit.grid { - return value.snap(position, self.sample_rate, self.frame_rate, self.feet_frames_start()); - } - let origin = self.grid_origin(); - return self.edit.grid.snap(position.saturating_add(origin), self.sample_rate, &self.tempo, self.frame_rate).saturating_sub(origin); - } - let mut points = self.clip_marker_grid_points(|_| true, excluded, false); - if !points.is_empty() { - points.push(0); - } - points.into_iter().min_by_key(|point| i128::from(*point).saturating_sub(i128::from(position)).abs()).unwrap_or(position) - } - - pub fn next_track_color(&self) -> [u8; 3] { - let n = self.tracks.iter().filter(|t| t.kind != TrackKind::Master).count(); - TRACK_COLORS.get(n % TRACK_COLORS.len()).copied().unwrap_or([128, 128, 128]) - } - - /// A unique track name: `base`, or `base 1`, `base 2` … like the incumbent ("Audio 1"). - pub fn unique_track_name(&self, base: &str) -> String { - let taken = |n: &str| self.tracks.iter().any(|t| t.name == n); - if !base.is_empty() && !taken(base) && !matches!(base, "Audio" | "Aux" | "MIDI" | "Inst" | "VCA" | "Folder" | "Master") { - return base.to_string(); - } - let prefix = format!("{base} "); - let used: std::collections::HashSet = self - .tracks - .iter() - .filter_map(|t| t.name.strip_prefix(&prefix)) - .filter_map(|n| n.parse().ok().filter(|i: &u64| i.to_string() == n)) - .collect(); - let i = (1..).find(|i| !used.contains(i)).unwrap_or(1); - format!("{base} {i}") - } - - /// Add a track with defaults; returns its id. - pub fn add_track(&mut self, kind: TrackKind, format: ChannelFormat, name: Option<&str>) -> TrackId { - let id = TrackId(self.alloc()); - let name = self.unique_track_name(name.unwrap_or(kind.default_name())); - let color = if kind == TrackKind::Master { [140, 140, 140] } else { self.next_track_color() }; - let mut t = Track::new(id, name, kind, format, color); - if kind == TrackKind::Master { - t.mixer.output = crate::Route::Main; - t.mixer.input = crate::Route::Main; - } - // Master faders sit at the bottom like the incumbent; others go before any master. - let pos = if kind == TrackKind::Master { - self.tracks.len() - } else { - self.tracks.iter().position(|t| t.kind == TrackKind::Master).unwrap_or(self.tracks.len()) - }; - self.tracks.insert(pos, t); - id - } - - pub fn add_bus(&mut self, name: &str, format: ChannelFormat) -> BusId { - if let Some(b) = self.bus_by_name(name) { - return b.id; - } - let id = BusId(self.alloc()); - self.busses.push(Bus { id, name: name.to_string(), format }); - id - } - - /// Add a memory location; returns its id. - pub fn add_marker(&mut self, name: &str, kind: MarkerKind, start: Samples, end: Samples) -> MarkerId { - let id = MarkerId(self.alloc()); - let number = self.markers.iter().map(|m| m.number).max().unwrap_or(0).saturating_add(1); - self.markers.push(MemoryLocation { - id, - number, - name: name.to_string(), - kind, - start, - end: end.max(start), - comments: String::new(), - color: None, - ruler: 1, - track: None, - }); - self.markers.sort_by_key(|m| m.start); - id - } - - pub fn new_clip_id(&mut self) -> ClipId { - ClipId(self.alloc()) - } - - /// Drop the Auto Rename schemes that no clip on any playlist uses. - pub fn prune_auto_names(&mut self) { - let used: std::collections::BTreeSet = self.all_clips().filter_map(|c| c.auto_name).collect(); - self.auto_names.retain(|k, _| used.contains(k)); - } - - // ---- persistence --------------------------------------------------------------------- - - pub fn to_json(&self) -> Result { - serde_json::to_string_pretty(self).map_err(|e| SessionError::Format(e.to_string())) - } - - /// Parse a session; decoded audio must be attached separately (`pool`). - /// - /// The text is parsed straight into the document, never into a `serde_json::Value` tree - /// first (which takes many times the file's size). Only the version is read before that. - /// A field of the document given twice in one object is refused (`duplicate field`), as no - /// writer repeats one. Keys of maps (plugin params, edit values, Auto Rename schemes, MIDI - /// originals) and unknown keys keep the last value given, as before. - pub fn from_json(text: &str) -> Result { - /// The version alone: every other field is skipped, not kept. - #[derive(serde::Deserialize)] - struct Head { - format_version: Option, - } - // `Head` would also take a JSON array as its fields in order: only an object has a version. - let object = text.trim_start_matches([' ', '\t', '\n', '\r']).starts_with('{'); - let version = match object.then(|| serde_json::from_str::(text)) { - Some(Ok(head)) => head.format_version, - // A version given twice is that error, not a missing version. - Some(Err(e)) if e.to_string().starts_with("duplicate field") => return Err(SessionError::Format(e.to_string())), - // Valid JSON of another shape (not an object, or a version that is not a number) - // has no version; anything else is not JSON. - _ => { - serde_json::from_str::(text).map_err(|e| SessionError::Format(e.to_string()))?; - None - } - }; - let ver = version.and_then(|v| v.as_u64()).ok_or_else(|| SessionError::Format("missing format_version".into()))?; - if ver > u64::from(Self::FORMAT_VERSION) { - return Err(SessionError::Version(u32::try_from(ver).unwrap_or(u32::MAX))); - } - let mut s: Session = serde_json::from_str(text).map_err(|e| SessionError::Format(e.to_string()))?; - s.sanitize(); - s.validate()?; - Ok(s) - } - - /// Repair invariants after loading untrusted data. - pub fn sanitize(&mut self) { - let max_id = self - .tracks - .iter() - .map(|t| t.id.0) - .chain(self.tracks.iter().flat_map(|t| t.playlists.iter().flat_map(|p| p.clips.iter().map(|c| c.id.0)))) - .chain(self.sources.iter().map(|s| s.id.0)) - .chain(self.auto_names.keys().copied()) - .chain(self.videos.iter().map(|v| v.id.0)) - .chain(self.busses.iter().map(|b| b.id.0)) - .chain(self.markers.iter().map(|m| m.id.0)) - .chain(self.groups.iter().map(|g| g.id.0)) - .max() - .unwrap_or(0); - self.next_id = self.next_id.max(max_id.saturating_add(1)); - truncate_chars(&mut self.name, MAX_NAME_CHARS); - truncate_chars(&mut self.comments, MAX_COMMENT_CHARS); - for t in &mut self.tracks { - t.mixer.sanitize(); - truncate_chars(&mut t.name, MAX_NAME_CHARS); - truncate_chars(&mut t.comments, MAX_COMMENT_CHARS); - if t.playlists.is_empty() { - t.playlists.push(crate::Playlist::new(t.name.clone())); - } - if t.active_playlist >= t.playlists.len() { - t.active_playlist = 0; - } - for p in &mut t.playlists { - truncate_chars(&mut p.name, MAX_NAME_CHARS); - p.clips.retain(|c| c.length > 0); - p.clips.iter_mut().for_each(Clip::sanitize); - p.sort(); - } - for l in &mut t.automation { - l.points.retain(|p| p.value.is_finite()); - let (lo, hi, _) = l.param.range(); - l.points.iter_mut().for_each(|p| p.value = p.value.clamp(lo, hi)); - l.points.iter_mut().for_each(|p| bound(&mut p.at)); - l.points.sort_by_key(|p| p.at); - } - } - for m in &mut self.markers { - bound(&mut m.start); - bound(&mut m.end); - truncate_chars(&mut m.name, MAX_NAME_CHARS); - truncate_chars(&mut m.comments, MAX_COMMENT_CHARS); - } - for (at, key) in &mut self.key_signatures { - bound(at); - truncate_chars(key, MAX_NAME_CHARS); - } - self.midi_originals.values_mut().for_each(bound_sequence); - let e = &mut self.edit; - for at in [ - &mut e.selection.start, - &mut e.selection.end, - &mut e.timeline_selection.start, - &mut e.timeline_selection.end, - &mut e.playhead, - &mut e.pre_roll, - &mut e.post_roll, - &mut e.zoom.scroll, - &mut self.timecode_start, - ] { - bound(at); - } - for v in &mut self.videos { - if !v.frame_rate.is_finite() || v.frame_rate < 0.0 { - v.frame_rate = 0.0; - } - if !v.duration.is_finite() || v.duration < 0.0 { - v.duration = 0.0; - } - truncate_chars(&mut v.name, MAX_NAME_CHARS); - } - self.busses.iter_mut().for_each(|b| truncate_chars(&mut b.name, MAX_NAME_CHARS)); - self.outputs.iter_mut().for_each(|o| truncate_chars(&mut o.name, MAX_NAME_CHARS)); - self.groups.iter_mut().for_each(|g| truncate_chars(&mut g.name, MAX_NAME_CHARS)); - self.sources.iter_mut().for_each(|s| truncate_chars(&mut s.name, MAX_NAME_CHARS)); - // Drop performances whose clip no longer exists anywhere (any playlist). - let clip_ids: std::collections::BTreeSet = - self.tracks.iter().flat_map(|t| t.playlists.iter().flat_map(|p| p.clips.iter().map(|c| c.id.0))).collect(); - self.midi_originals.retain(|id, _| clip_ids.contains(id)); - self.prune_auto_names(); - self.auto_names.values_mut().for_each(crate::AutoName::sanitize); - if !self.edit.zoom.samples_per_px.is_finite() || self.edit.zoom.samples_per_px <= 0.0 { - self.edit.zoom.samples_per_px = 1024.0; - } - if SampleRate::new(self.sample_rate.hz()).is_err() { - self.sample_rate = SampleRate::default(); - } - self.tempo.sanitize(); - } - - /// Reject a document whose ids are ambiguous or exhausted, run after [`Session::sanitize`] on - /// untrusted data. Duplicate ids in a namespace make commands, selections and source - /// associations act on an arbitrary one of the objects; a maximal `next_id` -- or a maximal - /// existing id, which `sanitize` folds into `next_id` -- makes every later allocation return - /// `u64::MAX` and repeat itself. - fn validate(&self) -> Result<(), SessionError> { - if self.next_id == u64::MAX { - return Err(SessionError::Invalid("the session id space is exhausted".into())); - } - distinct("track", self.tracks.iter().map(|t| t.id.0))?; - distinct("clip", self.tracks.iter().flat_map(|t| t.playlists.iter().flat_map(|p| p.clips.iter().map(|c| c.id.0))))?; - distinct("source", self.sources.iter().map(|s| s.id.0))?; - distinct("video", self.videos.iter().map(|v| v.id.0))?; - distinct("bus", self.busses.iter().map(|b| b.id.0))?; - distinct("marker", self.markers.iter().map(|m| m.id.0))?; - distinct("group", self.groups.iter().map(|g| g.id.0))?; - Ok(()) - } -} - -/// The most characters kept of a name read from a file: longer ones can't be shown, and drawing -/// a name of a million characters overflows the renderer's buffers. -pub const MAX_NAME_CHARS: usize = 256; -/// The most characters kept of a comment read from a file. -pub const MAX_COMMENT_CHARS: usize = 4096; - -/// Cut `s` to at most `max` characters. -pub fn truncate_chars(s: &mut String, max: usize) { - if let Some((end, _)) = s.char_indices().nth(max) { - s.truncate(end); - } -} - -/// Every id in `ids` distinct, or an error naming the namespace and the repeated id. -fn distinct(kind: &str, ids: impl Iterator) -> Result<(), SessionError> { - let mut seen = std::collections::HashSet::new(); - for id in ids { - if !seen.insert(id) { - return Err(SessionError::Invalid(format!("duplicate {kind} id {id}"))); - } - } - Ok(()) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn add_tracks_names_and_order() { - let mut s = Session::default(); - let m = s.add_track(TrackKind::Master, ChannelFormat::Stereo, None); - let a = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - let b = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - let v = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, Some("Vocal")); - assert_eq!(s.track(a).map(|t| t.name.as_str()), Some("Audio 1")); - assert_eq!(s.track(b).map(|t| t.name.as_str()), Some("Audio 2")); - assert_eq!(s.track(v).map(|t| t.name.as_str()), Some("Vocal")); - assert_eq!(s.tracks.last().map(|t| t.id), Some(m)); - let v2 = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, Some("Vocal")); - assert_eq!(s.track(v2).map(|t| t.name.as_str()), Some("Vocal 1")); - } - - #[test] - fn json_round_trip() { - let mut s = Session::default(); - let t = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None); - let cid = s.new_clip_id(); - if let Some(p) = s.track_mut(t).and_then(Track::playlist_mut) { - p.clips.push(Clip::audio(cid, "c", SourceId(99), 0, 10, 100)); - } - s.add_marker("Verse", MarkerKind::Marker, 48_000, 48_000); - let text = s.to_json().unwrap(); - let back = Session::from_json(&text).unwrap(); - assert_eq!(back, s); - } - - /// Clips/Markers mode snaps and draws at clip and memory-location boundaries. - #[test] - fn clips_markers_grid_uses_visible_clip_edges_and_memory_locations() { - let mut s = Session::default(); - let track = s.add_track(TrackKind::Midi, ChannelFormat::Mono, None); - let clip = Clip::midi(s.new_clip_id(), "Notes", 1_000, 2_000, soundcraft_midi::Sequence::default()); - let clip_id = clip.id; - s.track_mut(track).and_then(Track::playlist_mut).unwrap().clips.push(clip); - let hidden = s.add_track(TrackKind::Midi, ChannelFormat::Mono, None); - let hidden_clip = Clip::midi(s.new_clip_id(), "Hidden", 3_200, 100, soundcraft_midi::Sequence::default()); - if let Some(track) = s.track_mut(hidden) { - track.hidden = true; - track.playlist_mut().unwrap().clips.push(hidden_clip); - } - s.add_marker("Cue", MarkerKind::Marker, 2_500, 2_500); - s.add_marker("Selection", MarkerKind::Selection, 4_000, 4_500); - s.edit.grid_clips_markers = true; - - assert_eq!(s.grid_lines(0, 5_000, 20), [0, 1_000, 2_500, 3_000, 4_000, 4_500]); - assert_eq!(s.grid_line_at_or_before(2_800), 2_500); - assert_eq!(s.snap_to_grid(2_800), 3_000); - assert_eq!(s.snap_to_grid(3_700), 4_000); - assert_eq!(s.grid_lines(2_400, 4_100, 2), [2_500, 4_000]); - assert_eq!(s.snap_to_grid(3_200), 3_000); - assert_eq!(s.snap_to_grid_excluding(2_800, &[clip_id]), 2_500); - - let folder = s.add_track(TrackKind::Folder, ChannelFormat::Stereo, None); - s.track_mut(track).unwrap().folder = Some(folder); - s.track_mut(folder).unwrap().folder_open = false; - assert_eq!(s.grid_lines(0, 5_000, 20), [0, 2_500, 4_000, 4_500]); - } - - /// Open hidden folders keep their visible descendants eligible for lines and snapping. - #[test] - fn clips_markers_grid_keeps_visible_children_of_hidden_open_folders() { - let mut s = Session::default(); - let outer = s.add_track(TrackKind::Folder, ChannelFormat::Stereo, None); - let inner = s.add_track(TrackKind::Folder, ChannelFormat::Stereo, None); - let child = s.add_track(TrackKind::Midi, ChannelFormat::Mono, None); - let clip = Clip::midi(s.new_clip_id(), "Visible", 1_000, 2_000, soundcraft_midi::Sequence::default()); - s.track_mut(inner).unwrap().folder = Some(outer); - s.track_mut(inner).unwrap().hidden = true; - s.track_mut(child).unwrap().folder = Some(inner); - s.track_mut(child).unwrap().playlist_mut().unwrap().clips.push(clip); - s.edit.grid_clips_markers = true; - - assert_eq!(s.grid_lines(0, 5_000, 20), [0, 1_000, 3_000]); - assert_eq!(s.snap_to_grid(2_800), 3_000); - assert_eq!(s.grid_line_at_or_before(2_800), 1_000); - - s.track_mut(child).unwrap().hidden = true; - assert_eq!(s.grid_lines(0, 5_000, 20), [0]); - assert_eq!(s.snap_to_grid(2_800), 2_800); - s.track_mut(child).unwrap().hidden = false; - s.track_mut(inner).unwrap().folder_open = false; - assert_eq!(s.grid_lines(0, 5_000, 20), [0]); - s.track_mut(inner).unwrap().folder_open = true; - s.track_mut(outer).unwrap().folder_open = false; - assert_eq!(s.grid_lines(0, 5_000, 20), [0]); - } - - /// With no real Clips/Markers boundaries, snapping leaves the position alone while drawing - /// retains the session-start line. - #[test] - fn empty_clips_markers_grid_does_not_snap_everything_to_zero() { - let mut s = Session::default(); - s.edit.grid_clips_markers = true; - assert_eq!(s.grid_lines(0, 1_000, 10), [0]); - assert_eq!(s.snap_to_grid(678), 678); - } - - /// Frame-based grids share the same references as their displayed counters. - #[test] - fn frame_grids_apply_session_counter_origins() { - let mut s = Session { sample_rate: SampleRate::HZ_48000, frame_rate: FrameRate::Fps30, timecode_start: 1_600, ..Session::default() }; - s.edit.grid = GridValue::Timecode(soundcraft_time::TimecodeValue::Second); - assert_eq!(s.grid_line_at_or_before(47_000), 46_400); - assert_eq!(s.snap_to_grid(46_400), 46_400); - - s.edit.grid = GridValue::FeetFrames(soundcraft_time::FeetFramesValue::Foot); - s.edit.values.insert(FEET_FRAMES_START.into(), 1.0); - assert_eq!(s.grid_line_at_or_before(25_000), 24_000); - assert_eq!(s.snap_to_grid(24_000), 24_000); - } - - /// Every Feet+Frames increment shares the parser's single rounding at fractional frame rates. - #[test] - fn feet_frames_grid_matches_parsed_positions_with_signed_frame_origins() { - use soundcraft_time::FeetFramesValue; - for rate in [FrameRate::Fps23_976, FrameRate::Fps29_97, FrameRate::Fps29_97Drop, FrameRate::Fps59_94Drop] { - let mut s = Session { sample_rate: SampleRate::HZ_48000, frame_rate: rate, ..Session::default() }; - for origin in [-17, -1, 1, 17] { - s.edit.values.insert(FEET_FRAMES_START.into(), origin as f64); - for value in FeetFramesValue::ALL { - s.edit.grid = GridValue::FeetFrames(value); - for feet in [-64, -2, 0, 1, 2, 4, 7, 12, 128] { - let at = s.parse_position(&format!("{feet}+00"), TimeFormat::FeetFrames).unwrap(); - assert_eq!(s.grid_line_at_or_before(at), at, "{rate:?} {value:?} origin {origin}, foot {feet}"); - assert_eq!(s.snap_to_grid(at), at); - assert_eq!(s.grid_lines(at - 1, at + 2, 4), [at]); - } - } - } - } - let mut s = Session { sample_rate: SampleRate::HZ_48000, frame_rate: FrameRate::Fps29_97, ..Session::default() }; - s.edit.values.insert(FEET_FRAMES_START.into(), 1.0); - s.edit.grid = GridValue::FeetFrames(FeetFramesValue::Foot); - assert_eq!(s.snap_to_grid(49_649), 49_650); - assert_eq!(s.format_position(49_650, TimeFormat::FeetFrames), "2+00"); - } - - /// Drop-frame minute boundaries keep their counter alignment with signed session origins. - #[test] - fn drop_frame_grids_apply_session_origins_at_minute_boundaries() { - for (rate, minute_frame) in [(FrameRate::Fps29_97Drop, 1_800), (FrameRate::Fps59_94Drop, 3_600)] { - for origin_frame in [-1, 1] { - let sr = SampleRate::HZ_48000; - let origin = rate.samples_at_frame(origin_frame, sr); - let mut s = Session { sample_rate: sr, frame_rate: rate, timecode_start: origin, ..Session::default() }; - s.edit.grid = GridValue::Timecode(soundcraft_time::TimecodeValue::Second); - for boundary in [-minute_frame, minute_frame] { - let at = rate.samples_at_frame(boundary, sr) - origin; - assert_eq!(s.grid_line_at_or_before(at), at, "{rate:?}, origin {origin_frame}"); - assert_eq!(s.snap_to_grid(at + 1), at, "{rate:?}, origin {origin_frame}"); - assert_eq!(s.grid_lines(at - 1, at + 2, 10), [at]); - } - } - } - } - - #[test] - fn session_with_legacy_fit_height_loads() { - let mut s = Session::default(); - let t = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None); - if let Some(track) = s.track_mut(t) { - track.height = crate::TrackHeight::Large; - } - let text = s.to_json().unwrap().replace("\"height\": \"Large\"", "\"height\": \"Fit\""); - assert!(text.contains("\"height\": \"Fit\"")); - let back = Session::from_json(&text).unwrap(); - assert_eq!(back.track(t).map(|tr| tr.height), Some(crate::TrackHeight::Medium)); - } - - /// Session JSON omits live flags and ignores their values in legacy documents. - #[test] - fn live_input_states_are_never_saved_or_restored() { - let mut s = Session::default(); - let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - let track = s.track_mut(t).unwrap(); - track.mixer.mute = true; - track.mixer.record_arm = true; - track.mixer.input_monitor = true; - - let mut value = serde_json::to_value(&s).unwrap(); - let mixer = value["tracks"][0]["mixer"].as_object_mut().unwrap(); - assert!(!mixer.contains_key("record_arm")); - assert!(!mixer.contains_key("input_monitor")); - - // Files written by older versions may still contain these keys; ignore them on input. - mixer.insert("record_arm".into(), serde_json::Value::Bool(true)); - mixer.insert("input_monitor".into(), serde_json::Value::Bool(true)); - let loaded = Session::from_json(&value.to_string()).unwrap(); - let track = loaded.track(t).unwrap(); - assert!(track.mixer.mute, "persistent mixer state still loads"); - assert!(!track.mixer.record_arm); - assert!(!track.mixer.input_monitor); - } - - #[test] - fn video_clip_round_trips_and_old_sessions_load() { - let mut s = Session::default(); - let t = s.add_track(TrackKind::Video, ChannelFormat::Mono, None); - let vid = SourceId(s.alloc()); - s.videos.push(VideoSource { - id: vid, - name: "cut.mov".into(), - path: "/films/cut.mov".into(), - width: 1920, - height: 1080, - frame_rate: 23.976, - duration: 12.5, - codec: "prores".into(), - offline: None, - }); - let cid = s.new_clip_id(); - if let Some(p) = s.track_mut(t).and_then(Track::playlist_mut) { - p.clips.push(Clip::video(cid, "cut", vid, 480, 0, 600_000)); - } - let back = Session::from_json(&s.to_json().unwrap()).unwrap(); - assert_eq!(back, s); - let c = &back.track(t).unwrap().clips()[0]; - assert_eq!((c.video_source(), c.source(), c.source_offset(), c.is_audio()), (Some(vid), None, 480, false)); - assert_eq!(back.track(t).unwrap().kind.label(), "Video Track"); - assert!(back.video(vid).is_some()); - // A session written before video support has no `videos` key. - let mut v = serde_json::to_value(Session::default()).unwrap(); - v.as_object_mut().unwrap().remove("videos"); - assert!(Session::from_json(&v.to_string()).unwrap().videos.is_empty()); - // Trimming the start keeps the picture anchored. - let mut c = c.clone(); - c.trim_start_to(100); - assert_eq!(c.source_offset(), 580); - } - - #[test] - fn unique_track_names_take_the_first_free_number() { - let mut s = Session::default(); - for name in ["Piano", "Piano 1", "Piano 3", "Piano 02", "Pianos 2"] { - s.add_track(TrackKind::Audio, ChannelFormat::Mono, Some(name)); - } - assert_eq!(s.unique_track_name("Piano"), "Piano 2"); - assert_eq!(s.unique_track_name("Organ"), "Organ"); - assert_eq!(s.unique_track_name("Audio"), "Audio 1"); - } - - #[test] - fn names_from_a_file_are_cut_to_a_length_that_can_be_drawn() { - let mut s = Session::default(); - let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - if let Some(tr) = s.track_mut(t) { - tr.name = "é".repeat(1_000); - } - s.comments = "c".repeat(10_000); - let back = Session::from_json(&s.to_json().unwrap()).unwrap(); - assert_eq!(back.track(t).map(|tr| tr.name.chars().count()), Some(MAX_NAME_CHARS)); - assert_eq!(back.comments.len(), MAX_COMMENT_CHARS); - } - - #[test] - fn a_bad_sample_rate_or_tempo_is_repaired_on_load() { - let mut v = serde_json::to_value(Session::default()).unwrap(); - v["sample_rate"] = serde_json::json!(0); - v["tempo"]["tempos"] = serde_json::json!([{"tick": 0, "bpm": 4e9}]); - let s = Session::from_json(&v.to_string()).unwrap(); - assert_eq!((s.sample_rate, s.tempo), (SampleRate::HZ_48000, TempoMap::default())); - } - - #[test] - fn a_meter_change_far_beyond_the_position_range_is_dropped_on_load() { - let mut v = serde_json::to_value(Session::default()).unwrap(); - v["tempo"]["meters"] = serde_json::json!([ - {"tick": 0, "numerator": 4, "denominator": 4}, - {"tick": i64::MAX, "numerator": 3, "denominator": 4} - ]); - let s = Session::from_json(&v.to_string()).unwrap(); - assert_eq!(s.parse_position("2|1|000", TimeFormat::BarsBeats), Ok(96_000)); - } - - #[test] - fn rejects_garbage_and_future_versions() { - assert!(Session::from_json("not json").is_err()); - assert!(Session::from_json("{}").is_err()); - let mut v = serde_json::to_value(Session::default()).unwrap(); - v["format_version"] = serde_json::json!(999); - assert!(matches!(Session::from_json(&v.to_string()), Err(SessionError::Version(999)))); - } - - #[test] - fn the_version_is_checked_as_before() { - // #892: the version is read without building the whole document as a tree; the errors - // stay what they were. - let format = |t: &str| match Session::from_json(t) { - Err(SessionError::Format(m)) => m, - other => panic!("{t}: {other:?}"), - }; - for t in [ - "{}", - "[]", - "[5]", - " \n[1, {}]", - "\"x\"", - "5", - "null", - r#"{"format_version":"1"}"#, - r#"{"format_version":-1}"#, - r#"{"format_version":1.5}"#, - r#"{"format_version":null}"#, - r#"{"format_version":[0,0,0]}"#, - r#"{"name":"x","other":{"format_version":1}}"#, - ] { - assert_eq!(format(t), "missing format_version", "{t}"); - } - for t in ["not json", r#"{"format_version":1"#, r#"{"format_version":1} x"#, r#"{"format_version":"1", ]"#] { - let want = serde_json::from_str::(t).unwrap_err().to_string(); - assert_eq!(format(t), want, "{t}"); - } - let mut v = serde_json::to_value(Session::default()).unwrap(); - for (ver, want) in [(serde_json::json!(2), 2), (serde_json::json!(1u64 << 40), u32::MAX)] { - v["format_version"] = ver; - assert_eq!(Session::from_json(&v.to_string()), Err(SessionError::Version(want))); - } - // A field given twice is refused by name, the version too. - let twice = |key: &str| format(&format!(r#"{{"format_version":1,"{key}":"a","{key}":"b"}}"#)); - assert!(twice("name").starts_with("duplicate field `name` at line 1 column "), "{}", twice("name")); - assert!(twice("format_version").starts_with("duplicate field `format_version` at line 1 column "), "{}", twice("format_version")); - // A newer version is refused even when the rest would not parse. - assert_eq!(Session::from_json(r#"{"format_version":7,"tracks":5}"#), Err(SessionError::Version(7))); - // An older or the current version loads as it did. - for ver in [0, 1] { - v["format_version"] = serde_json::json!(ver); - assert_eq!(Session::from_json(&v.to_string()).map(|s| s.format_version), Ok(ver)); - } - } - - #[test] - fn duplicate_ids_are_rejected_on_load() { - let mut s = Session::default(); - s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - let mut v = serde_json::to_value(&s).unwrap(); - v["tracks"][1]["id"] = v["tracks"][0]["id"].clone(); - let err = Session::from_json(&v.to_string()).unwrap_err(); - assert!(matches!(&err, SessionError::Invalid(m) if m.contains("duplicate track id")), "{err}"); - } - - #[test] - fn an_exhausted_id_space_is_rejected_on_load() { - let mut s = Session::default(); - s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - let mut v = serde_json::to_value(&s).unwrap(); - v["next_id"] = serde_json::json!(u64::MAX); - let err = Session::from_json(&v.to_string()).unwrap_err(); - assert!(matches!(&err, SessionError::Invalid(m) if m.contains("exhausted")), "{err}"); - // A maximal existing id is exhausted too, however `next_id` was written: every later - // allocation would return `u64::MAX` again. - let mut v = serde_json::to_value(&s).unwrap(); - v["tracks"][0]["id"] = serde_json::json!(u64::MAX); - let err = Session::from_json(&v.to_string()).unwrap_err(); - assert!(matches!(&err, SessionError::Invalid(m) if m.contains("exhausted")), "{err}"); - } - - #[test] - fn sanitize_repairs() { - let mut s = Session::default(); - let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - if let Some(tr) = s.track_mut(t) { - tr.active_playlist = 7; - tr.mixer.volume_db = f32::NAN; - } - s.next_id = 0; - s.sanitize(); - let tr = s.track(t).unwrap(); - assert_eq!(tr.active_playlist, 0); - assert_eq!(tr.mixer.volume_db, 0.0); - assert!(s.next_id > t.0); - } - - #[test] - fn loaded_automation_is_clamped_to_its_range() { - // #884: a session file can carry points outside a lane's range; load clamps them. - let mut s = Session::default(); - let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None); - let tr = s.track_mut(t).unwrap(); - for p in [crate::AutoParam::Volume, crate::AutoParam::SendLevel(0)] { - tr.lane_mut(&p).points.push(crate::AutomationPoint { at: 0, value: 500.0 }); - } - let s = Session::from_json(&serde_json::to_string(&s).unwrap()).unwrap(); - let tr = s.track(t).unwrap(); - for p in [crate::AutoParam::Volume, crate::AutoParam::SendLevel(0)] { - assert_eq!(tr.lane(&p).unwrap().points[0].value, 12.0, "{p:?}"); - } - } - - #[test] - fn a_loaded_auto_name_scheme_leaves_room_for_its_number() { - let mut scheme = crate::AutoName { name: "n".repeat(300), suffix: "s".repeat(300), ..Default::default() }; - scheme.sanitize(); - assert_eq!(scheme.name.chars().count() + scheme.suffix.chars().count(), crate::AutoName::MAX_TEXT_CHARS); - } -} diff --git a/crates/model/src/source.rs b/crates/model/src/source.rs deleted file mode 100644 index 7013d003..00000000 --- a/crates/model/src/source.rs +++ /dev/null @@ -1,204 +0,0 @@ -//! Audio sources (files in the session's Audio Files folder) and their decoded data, and the -//! movies video clips reference. - -use crate::SourceId; -use craft_audio::{AudioBuffer, AudioInfo, CodecId, Container, peaks::Peaks}; -use std::collections::BTreeMap; -use std::sync::Arc; - -/// The kind of file a source came from, as session files store it in [`Source::format`]. The -/// variant names are part of the session format: craft-audio's `Container` and `CodecId` name -/// more formats under other names, so this stays here and maps from them. -#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] -pub enum FileFormat { - Wav, - Aiff, - Flac, - Mp3, - Ogg, - Aac, - Alac, - Caf, - /// Anything else that decodes: Matroska, WebM, raw AC-3. - Other, -} - -impl FileFormat { - /// The kind of the file `info` describes. - pub fn of(info: &AudioInfo) -> FileFormat { - match info.container { - Container::Wav => FileFormat::Wav, - Container::Aiff => FileFormat::Aiff, - Container::Flac => FileFormat::Flac, - Container::MpegAudio => FileFormat::Mp3, - Container::Ogg => FileFormat::Ogg, - Container::Caf => FileFormat::Caf, - Container::Adts => FileFormat::Aac, - // MP4 and QuickTime hold many codecs: the codec names the kind. - Container::Mp4 | Container::QuickTime => match info.codec { - CodecId::Alac => FileFormat::Alac, - CodecId::Aac | CodecId::HeAac => FileFormat::Aac, - _ => FileFormat::Other, - }, - _ => FileFormat::Other, - } - } -} - -/// Metadata for an audio file used by the session (serialised). -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Source { - pub id: SourceId, - pub name: String, - /// Path relative to the session folder (or absolute for referenced media). - pub path: String, - pub channels: u16, - pub frames: u64, - pub sample_rate: u32, - pub format: FileFormat, - /// Original BWF time stamp (samples), if any. - #[serde(default)] - pub time_reference: u64, - /// True when the file has not been written to disk yet (recorded/rendered this session). - #[serde(default)] - pub unsaved: bool, -} - -/// A movie used by Video track clips (serialised). The pictures themselves are never stored in -/// the session: the UI opens the movie from `path` and decodes frames on demand. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct VideoSource { - pub id: SourceId, - pub name: String, - /// Absolute path of the movie (referenced, never copied into the session folder). - pub path: String, - #[serde(default)] - pub width: u32, - #[serde(default)] - pub height: u32, - /// Frames per second (0 = unknown). - #[serde(default)] - pub frame_rate: f64, - /// Picture length in seconds. - #[serde(default)] - pub duration: f64, - /// Codec id (`h264`, `prores`, `mjpeg`, `hevc`, …). - #[serde(default)] - pub codec: String, - /// Why the movie is not opened, when its stored path was refused on opening the session. - #[serde(skip)] - pub offline: Option, -} - -impl VideoSource { - /// Display aspect ratio (width / height), 16:9 when unknown. - pub fn aspect(&self) -> f64 { - if self.width == 0 || self.height == 0 { 16.0 / 9.0 } else { f64::from(self.width) / f64::from(self.height) } - } -} - -/// Decoded audio plus waveform overviews (not serialised). -#[derive(Debug)] -pub struct SourceAudio { - pub buffer: AudioBuffer, - pub peaks: Vec, -} - -impl SourceAudio { - pub fn new(buffer: AudioBuffer) -> Self { - let peaks = buffer.channels.iter().map(|c| Peaks::build(c)).collect(); - SourceAudio { buffer, peaks } - } - pub fn frames(&self) -> usize { - self.buffer.frames() - } - pub fn channel(&self, ch: usize) -> Option<&[f32]> { - self.buffer.channels.get(ch).map(Vec::as_slice) - } -} - -/// Shared decoded audio, keyed by source id. -#[derive(Debug, Clone, Default)] -pub struct SourcePool { - map: BTreeMap>, -} - -impl SourcePool { - pub fn insert(&mut self, id: SourceId, audio: Arc) { - self.map.insert(id, audio); - } - pub fn get(&self, id: SourceId) -> Option<&Arc> { - self.map.get(&id) - } - pub fn remove(&mut self, id: SourceId) -> Option> { - self.map.remove(&id) - } - pub fn contains(&self, id: SourceId) -> bool { - self.map.contains_key(&id) - } - pub fn len(&self) -> usize { - self.map.len() - } - pub fn is_empty(&self) -> bool { - self.map.is_empty() - } - pub fn ids(&self) -> impl Iterator + '_ { - self.map.keys().copied() - } -} - -impl PartialEq for SourcePool { - fn eq(&self, other: &Self) -> bool { - self.map.len() == other.map.len() && self.map.iter().zip(other.map.iter()).all(|((a, x), (b, y))| a == b && Arc::ptr_eq(x, y)) - } -} - -#[cfg(test)] -mod tests { - use super::FileFormat; - use craft_audio::{AudioBuffer, EncodeFormat, EncodeOptions, encode, probe}; - - /// Sessions written before the format code moved to craft-audio name a source's format with - /// these words; they must keep reading, and new sessions must keep writing them. - #[test] - fn the_format_names_in_session_files_do_not_change() { - use FileFormat::{Aac, Aiff, Alac, Caf, Flac, Mp3, Ogg, Other, Wav}; - let names = ["Wav", "Aiff", "Flac", "Mp3", "Ogg", "Aac", "Alac", "Caf", "Other"]; - for (format, name) in [Wav, Aiff, Flac, Mp3, Ogg, Aac, Alac, Caf, Other].into_iter().zip(names) { - assert_eq!(serde_json::to_string(&format).unwrap(), format!("\"{name}\"")); - assert_eq!(serde_json::from_str::(&format!("\"{name}\"")).unwrap(), format); - } - } - - /// An MP4 is AAC only when its audio is: Opus, AC-3 or PCM in MP4 is not. - #[test] - fn an_mp4_is_named_by_its_codec() { - let wav = encode(&AudioBuffer::new(48_000, 1, 480), &EncodeOptions::default()).unwrap(); - let mut info = serde_json::to_value(probe(&wav, None).unwrap()).unwrap(); - for (container, codec, format) in [ - ("Mp4", "Aac", FileFormat::Aac), - ("Mp4", "HeAac", FileFormat::Aac), - ("QuickTime", "Alac", FileFormat::Alac), - ("Mp4", "Opus", FileFormat::Other), - ("Mp4", "Ac3", FileFormat::Other), - ("QuickTime", "Pcm", FileFormat::Other), - ("Adts", "Aac", FileFormat::Aac), - ] { - info["container"] = container.into(); - info["codec"] = codec.into(); - let info: craft_audio::AudioInfo = serde_json::from_value(info.clone()).unwrap(); - assert_eq!(FileFormat::of(&info), format, "{codec} in {container}"); - } - } - - #[test] - fn a_probed_file_maps_to_its_format() { - let buf = AudioBuffer::new(48_000, 1, 480); - for (written, format) in - [(EncodeFormat::Wav, FileFormat::Wav), (EncodeFormat::Aiff, FileFormat::Aiff), (EncodeFormat::Flac, FileFormat::Flac)] - { - let info = probe(&encode(&buf, &EncodeOptions::new(written)).unwrap(), None).unwrap(); - assert_eq!(FileFormat::of(&info), format); - } - } -} diff --git a/crates/model/src/track.rs b/crates/model/src/track.rs deleted file mode 100644 index 38f35b1b..00000000 --- a/crates/model/src/track.rs +++ /dev/null @@ -1,477 +0,0 @@ -//! Tracks and playlists. - -use crate::{AutoParam, AutomationLane, ChannelFormat, Clip, ClipId, Mixer, TrackId}; -use soundcraft_time::{Range, Samples}; - -/// Track types (Track › New). -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum TrackKind { - #[default] - Audio, - Aux, - Master, - Midi, - Instrument, - Vca, - Folder, - /// Picture: clips reference a movie ([`crate::VideoSource`]); no audio path. - Video, -} - -impl TrackKind { - pub const ALL: [TrackKind; 8] = [ - TrackKind::Audio, - TrackKind::Aux, - TrackKind::Master, - TrackKind::Midi, - TrackKind::Instrument, - TrackKind::Vca, - TrackKind::Folder, - TrackKind::Video, - ]; - pub fn label(self) -> &'static str { - match self { - TrackKind::Audio => "Audio Track", - TrackKind::Aux => "Aux Input", - TrackKind::Master => "Master Fader", - TrackKind::Midi => "MIDI Track", - TrackKind::Instrument => "Instrument Track", - TrackKind::Vca => "VCA Master", - TrackKind::Folder => "Routing Folder Track", - TrackKind::Video => "Video Track", - } - } - pub fn default_name(self) -> &'static str { - match self { - TrackKind::Audio => "Audio", - TrackKind::Aux => "Aux", - TrackKind::Master => "Master", - TrackKind::Midi => "MIDI", - TrackKind::Instrument => "Inst", - TrackKind::Vca => "VCA", - TrackKind::Folder => "Folder", - TrackKind::Video => "Video", - } - } - pub fn id(self) -> &'static str { - match self { - TrackKind::Audio => "audio", - TrackKind::Aux => "aux", - TrackKind::Master => "master", - TrackKind::Midi => "midi", - TrackKind::Instrument => "instrument", - TrackKind::Vca => "vca", - TrackKind::Folder => "folder", - TrackKind::Video => "video", - } - } - pub fn from_id(s: &str) -> Option { - let s = s.to_ascii_lowercase(); - TrackKind::ALL.into_iter().find(|k| k.id() == s || k.label().eq_ignore_ascii_case(&s)) - } - /// Track kinds that hold clips on a timeline. - pub fn has_playlist(self) -> bool { - matches!(self, TrackKind::Audio | TrackKind::Midi | TrackKind::Instrument | TrackKind::Video) - } - pub fn is_midi(self) -> bool { - matches!(self, TrackKind::Midi | TrackKind::Instrument) - } - /// Kinds that pass audio through the mixer. - pub fn is_audio_path(self) -> bool { - matches!(self, TrackKind::Audio | TrackKind::Aux | TrackKind::Master | TrackKind::Instrument | TrackKind::Folder) - } -} - -/// Track heights (View › Track Height presets). -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize)] -pub enum TrackHeight { - /// Any height from Micro to Extreme, in points. - Custom(u16), - Micro, - Mini, - Small, - #[default] - Medium, - Large, - Jumbo, - Extreme, - /// Fit To Window: this many points. - Fit(u16), -} - -/// A saved track height: `"Micro"` … `"Extreme"` (or `{"Micro": null}` …), `{"Custom": points}`, -/// `{"Fit": points}`, or the bare `"Fit"` older sessions used. Read as it comes, never buffered (as an -/// untagged enum would), so anything else in a session file is refused at its first token. -impl<'de> serde::Deserialize<'de> for TrackHeight { - fn deserialize>(d: D) -> Result { - d.deserialize_any(HeightVisitor) - } -} - -const HEIGHT_VARIANTS: &[&str] = &["Custom", "Micro", "Mini", "Small", "Medium", "Large", "Jumbo", "Extreme", "Fit"]; - -struct HeightVisitor; - -impl HeightVisitor { - /// The height a variant without a size names. - fn preset(name: &str) -> Option { - Some(match name { - "Micro" => TrackHeight::Micro, - "Mini" => TrackHeight::Mini, - "Small" => TrackHeight::Small, - "Medium" => TrackHeight::Medium, - "Large" => TrackHeight::Large, - "Jumbo" => TrackHeight::Jumbo, - "Extreme" => TrackHeight::Extreme, - _ => return None, - }) - } -} - -impl<'de> serde::de::Visitor<'de> for HeightVisitor { - type Value = TrackHeight; - - fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - f.write_str("a track height") - } - - fn visit_str(self, v: &str) -> Result { - match v { - // Older sessions stored Fit with no size, drawn 88 points tall: the default Medium height. - "Fit" => Ok(TrackHeight::Medium), - "Custom" => Err(E::invalid_type(serde::de::Unexpected::UnitVariant, &"a height in points")), - other => Self::preset(other).ok_or_else(|| E::unknown_variant(other, HEIGHT_VARIANTS)), - } - } - - fn visit_map>(self, mut map: A) -> Result { - use serde::de::Error as _; - let Some(key) = map.next_key::()? else { return Err(A::Error::invalid_length(0, &"one variant")) }; - let h = match key.as_str() { - "Custom" => TrackHeight::Custom(map.next_value()?), - // `{"Fit": null}` is the old size-less Fit too, as above. - "Fit" => map.next_value::>()?.map_or(TrackHeight::Medium, TrackHeight::Fit), - other => { - let h = Self::preset(other).ok_or_else(|| A::Error::unknown_variant(other, HEIGHT_VARIANTS))?; - map.next_value::<()>()?; - h - } - }; - if map.next_key::()?.is_some() { - return Err(A::Error::invalid_length(2, &"one variant")); - } - Ok(h) - } -} - -impl TrackHeight { - pub const ALL: [TrackHeight; 7] = [ - TrackHeight::Micro, - TrackHeight::Mini, - TrackHeight::Small, - TrackHeight::Medium, - TrackHeight::Large, - TrackHeight::Jumbo, - TrackHeight::Extreme, - ]; - pub fn points(self) -> f32 { - match self { - TrackHeight::Custom(points) => f32::from(points).clamp(TrackHeight::Micro.points(), TrackHeight::Extreme.points()), - TrackHeight::Micro => 16.0, - TrackHeight::Mini => 24.0, - TrackHeight::Small => 46.0, - TrackHeight::Medium => 88.0, - TrackHeight::Large => 132.0, - TrackHeight::Jumbo => 220.0, - TrackHeight::Extreme => 440.0, - TrackHeight::Fit(points) => f32::from(points.max(16)), - } - } - pub fn label(self) -> &'static str { - match self { - TrackHeight::Custom(_) => "custom", - TrackHeight::Micro => "micro", - TrackHeight::Mini => "mini", - TrackHeight::Small => "small", - TrackHeight::Medium => "medium", - TrackHeight::Large => "large", - TrackHeight::Jumbo => "jumbo", - TrackHeight::Extreme => "extreme", - TrackHeight::Fit(_) => "fit to window", - } - } - pub fn from_id(s: &str) -> Option { - TrackHeight::ALL.into_iter().find(|h| h.label().eq_ignore_ascii_case(s)) - } - /// The preset this many points tall, else a custom height clamped to Micro..Extreme. - pub fn from_points(points: f32) -> TrackHeight { - let p = points.max(TrackHeight::Micro.points()).min(TrackHeight::Extreme.points()).round() as u16; - TrackHeight::ALL.into_iter().find(|h| h.points() == f32::from(p)).unwrap_or(TrackHeight::Custom(p)) - } - /// The next preset taller (or shorter) than this height; Extreme (or Micro) stays. - pub fn step(self, taller: bool) -> TrackHeight { - let p = self.points(); - let next = - if taller { TrackHeight::ALL.into_iter().find(|h| h.points() > p) } else { TrackHeight::ALL.into_iter().rev().find(|h| h.points() < p) }; - next.unwrap_or(self) - } -} - -/// The default track colour palette (original, chosen for SoundCraft). -pub const TRACK_COLORS: [[u8; 3]; 16] = [ - [86, 132, 214], - [94, 170, 214], - [80, 190, 168], - [104, 186, 98], - [168, 196, 76], - [222, 196, 72], - [230, 152, 62], - [222, 104, 72], - [214, 82, 110], - [196, 86, 168], - [150, 98, 206], - [110, 104, 214], - [130, 150, 170], - [178, 140, 110], - [120, 170, 140], - [190, 120, 150], -]; - -/// A playlist: an alternative take of a track's clips. -#[derive(Debug, Clone, PartialEq, Default, serde::Serialize, serde::Deserialize)] -pub struct Playlist { - pub name: String, - /// Clips sorted by start; non-overlapping except at crossfades. - pub clips: Vec, -} - -impl Playlist { - pub fn new(name: impl Into) -> Self { - Playlist { name: name.into(), clips: Vec::new() } - } - pub fn sort(&mut self) { - self.clips.sort_by_key(|c| (c.start, c.id.0)); - } - pub fn clip(&self, id: ClipId) -> Option<&Clip> { - self.clips.iter().find(|c| c.id == id) - } - pub fn clip_mut(&mut self, id: ClipId) -> Option<&mut Clip> { - self.clips.iter_mut().find(|c| c.id == id) - } - pub fn clips_in(&self, r: Range) -> impl Iterator { - self.clips.iter().filter(move |c| c.range().overlaps(&r)) - } - pub fn clip_at(&self, at: Samples) -> Option<&Clip> { - self.clips.iter().rev().find(|c| c.range().contains(at)) - } - pub fn end(&self) -> Samples { - self.clips.iter().map(Clip::end).max().unwrap_or(0) - } -} - -/// A track. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct Track { - pub id: TrackId, - pub name: String, - pub kind: TrackKind, - pub format: ChannelFormat, - pub color: [u8; 3], - pub height: TrackHeight, - pub playlists: Vec, - pub active_playlist: usize, - pub mixer: Mixer, - pub automation: Vec, - /// Which lane the track shows: `waveform`/`blocks`/`notes`/`regions` or an automation param id. - pub view: String, - #[serde(default)] - pub hidden: bool, - #[serde(default)] - pub inactive: bool, - #[serde(default)] - pub frozen: bool, - #[serde(default)] - pub comments: String, - /// Folder that contains this track. - #[serde(default)] - pub folder: Option, - #[serde(default = "yes")] - pub folder_open: bool, - /// Instrument plugin (instrument tracks) — registry id. - #[serde(default)] - pub instrument: Option, - /// Ticks (musical) or samples timebase for clips. - #[serde(default)] - pub ticks_timebase: bool, - /// Elastic Audio algorithm, if enabled. - #[serde(default)] - pub elastic: Option, - /// Pinned to top in the Edit window. - #[serde(default)] - pub pinned: bool, -} - -fn yes() -> bool { - true -} - -impl Track { - pub fn new(id: TrackId, name: impl Into, kind: TrackKind, format: ChannelFormat, color: [u8; 3]) -> Self { - let name = name.into(); - let format = if kind.is_midi() && kind == TrackKind::Midi { ChannelFormat::Mono } else { format }; - let view = if kind.is_midi() { - "notes" - } else if kind.has_playlist() { - "waveform" - } else { - "volume" - }; - Track { - id, - playlists: vec![Playlist::new(name.clone())], - name, - kind, - format, - color, - height: TrackHeight::Medium, - active_playlist: 0, - mixer: Mixer::new(format), - automation: Vec::new(), - view: view.into(), - hidden: false, - inactive: false, - frozen: false, - comments: String::new(), - folder: None, - folder_open: true, - instrument: None, - ticks_timebase: kind.is_midi(), - elastic: None, - pinned: false, - } - } - - pub fn channels(&self) -> usize { - self.format.channels() - } - - pub fn playlist(&self) -> Option<&Playlist> { - self.playlists.get(self.active_playlist) - } - - pub fn playlist_mut(&mut self) -> Option<&mut Playlist> { - self.playlists.get_mut(self.active_playlist) - } - - pub fn clips(&self) -> &[Clip] { - self.playlist().map_or(&[], |p| p.clips.as_slice()) - } - - pub fn lane(&self, p: &AutoParam) -> Option<&AutomationLane> { - self.automation.iter().find(|l| &l.param == p) - } - - pub fn lane_mut(&mut self, p: &AutoParam) -> &mut AutomationLane { - let idx = match self.automation.iter().position(|l| &l.param == p) { - Some(i) => i, - None => { - self.automation.push(AutomationLane::new(p.clone())); - self.automation.len() - 1 - } - }; - let len = self.automation.len(); - // `idx` is in range: it came from `position` or is the index of the element just pushed. - &mut self.automation[idx.min(len - 1)] - } - - pub fn is_folder(&self) -> bool { - self.kind == TrackKind::Folder - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn legacy_fit_string_loads_as_default_height() { - assert_eq!(serde_json::from_str::("\"Fit\"").unwrap(), TrackHeight::Medium); - assert_eq!(serde_json::from_str::("{\"Fit\":120}").unwrap(), TrackHeight::Fit(120)); - assert_eq!(serde_json::to_string(&TrackHeight::Fit(120)).unwrap(), "{\"Fit\":120}"); - assert_eq!(serde_json::from_str::("\"Large\"").unwrap(), TrackHeight::Large); - assert_eq!(serde_json::from_str::("{\"Custom\":50}").unwrap(), TrackHeight::Custom(50)); - } - - #[test] - fn every_saved_height_form_loads_and_nothing_else() { - for h in TrackHeight::ALL.into_iter().chain([TrackHeight::Custom(50), TrackHeight::Fit(120)]) { - assert_eq!(serde_json::from_str::(&serde_json::to_string(&h).unwrap()).unwrap(), h); - assert_eq!(serde_json::from_value::(serde_json::to_value(h).unwrap()).unwrap(), h); - } - for h in TrackHeight::ALL { - let null = format!("{{{}:null}}", serde_json::to_string(&h).unwrap()); - assert_eq!(serde_json::from_str::(&null).unwrap(), h, "{null}"); - } - assert_eq!(serde_json::from_str::(r#"{"Fit":null}"#).unwrap(), TrackHeight::Medium); - assert!(serde_json::from_str::(r#"{"Custom":null}"#).is_err()); - for bad in - [r#""Custom""#, r#""Huge""#, "7", "[]", "null", "{}", r#"{"Fit":"x"}"#, r#"{"Fit":70000}"#, r#"{"Large":1}"#, r#"{"Fit":1,"Fit":2}"#] - { - assert!(serde_json::from_str::(bad).is_err(), "{bad}"); - } - } - - #[test] - fn a_huge_height_is_refused_at_its_first_token() { - // #892: the height was read through an untagged enum, which buffers the whole value - // first; a session could hold a huge array there. It is refused where it starts. - for (open, rest) in [("[", "0,".repeat(100_000) + "0]"), (r#"{"Fit":["#, "0,".repeat(100_000) + "0]}")] { - let text = format!("{open}{rest}"); - let err = serde_json::from_str::(&text).unwrap_err(); - assert!(err.is_data() && err.line() == 1 && err.column() <= open.len() + 1, "{open}: {err}"); - } - } - - #[test] - fn new_track_defaults() { - let t = Track::new(TrackId(1), "Gtr", TrackKind::Audio, ChannelFormat::Stereo, TRACK_COLORS[0]); - assert_eq!(t.channels(), 2); - assert_eq!(t.view, "waveform"); - assert_eq!(t.playlists.len(), 1); - let m = Track::new(TrackId(2), "Keys", TrackKind::Midi, ChannelFormat::Stereo, TRACK_COLORS[0]); - assert_eq!(m.format, ChannelFormat::Mono); - assert_eq!(m.view, "notes"); - } - - #[test] - fn lane_mut_creates_once() { - let mut t = Track::new(TrackId(1), "Gtr", TrackKind::Audio, ChannelFormat::Mono, TRACK_COLORS[0]); - t.lane_mut(&AutoParam::Volume).set_point(0, -3.0); - t.lane_mut(&AutoParam::Volume).set_point(10, -6.0); - assert_eq!(t.automation.len(), 1); - assert_eq!(t.lane(&AutoParam::Volume).map(|l| l.points.len()), Some(2)); - } - - #[test] - fn kind_ids() { - for k in TrackKind::ALL { - assert_eq!(TrackKind::from_id(k.id()), Some(k)); - } - } - - #[test] - fn custom_heights_round_to_presets_and_step_through_them() { - assert_eq!(TrackHeight::from_points(88.0), TrackHeight::Medium); - assert_eq!(TrackHeight::from_points(57.4), TrackHeight::Custom(57)); - assert_eq!(TrackHeight::from_points(9999.0), TrackHeight::Extreme); - assert_eq!(TrackHeight::from_points(f32::NAN), TrackHeight::Micro); - assert_eq!(TrackHeight::Custom(u16::MAX).points(), 440.0); - assert_eq!(TrackHeight::Custom(57).step(true), TrackHeight::Medium); - assert_eq!(TrackHeight::Custom(57).step(false), TrackHeight::Small); - assert_eq!(TrackHeight::Extreme.step(true), TrackHeight::Extreme); - assert_eq!(TrackHeight::Micro.step(false), TrackHeight::Micro); - let json = serde_json::to_string(&TrackHeight::Custom(57)).unwrap(); - assert_eq!(serde_json::from_str::(&json).unwrap(), TrackHeight::Custom(57)); - assert_eq!(serde_json::from_str::("\"Large\"").unwrap(), TrackHeight::Large); - } -} diff --git a/crates/time/Cargo.toml b/crates/time/Cargo.toml index df5dc4e1..2efa9780 100644 --- a/crates/time/Cargo.toml +++ b/crates/time/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "soundcraft-time" -description = "SoundCraft timebases: samples, Bars|Beats, Min:Secs, Timecode, Feet+Frames, tempo and meter maps, grid" +description = "Compatibility facade for SoundCraft's shared sample-index time API" version.workspace = true edition.workspace = true license.workspace = true @@ -8,12 +8,7 @@ rust-version.workspace = true repository.workspace = true [dependencies] -serde.workspace = true -thiserror.workspace = true - -[dev-dependencies] -proptest.workspace = true -serde_json.workspace = true +craft-time.workspace = true [lints] workspace = true diff --git a/crates/time/src/format.rs b/crates/time/src/format.rs deleted file mode 100644 index 3268ef0f..00000000 --- a/crates/time/src/format.rs +++ /dev/null @@ -1,241 +0,0 @@ -//! Formatting and parsing positions in the five timebases. - -use crate::{BarBeat, FrameRate, SampleRate, Samples, TempoMap, TimeError, Timecode, timecode::feet_frames}; - -/// The counters' and rulers' timebases. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum TimeFormat { - BarsBeats, - #[default] - MinSecs, - Timecode, - FeetFrames, - Samples, -} - -impl TimeFormat { - pub const ALL: [TimeFormat; 5] = [TimeFormat::BarsBeats, TimeFormat::MinSecs, TimeFormat::Timecode, TimeFormat::FeetFrames, TimeFormat::Samples]; - - pub fn label(self) -> &'static str { - match self { - TimeFormat::BarsBeats => "Bars|Beats", - TimeFormat::MinSecs => "Min:Secs", - TimeFormat::Timecode => "Timecode", - TimeFormat::FeetFrames => "Feet+Frames", - TimeFormat::Samples => "Samples", - } - } - - pub fn id(self) -> &'static str { - match self { - TimeFormat::BarsBeats => "bars_beats", - TimeFormat::MinSecs => "min_secs", - TimeFormat::Timecode => "timecode", - TimeFormat::FeetFrames => "feet_frames", - TimeFormat::Samples => "samples", - } - } - - pub fn from_id(id: &str) -> Option { - TimeFormat::ALL.into_iter().find(|f| f.id() == id || f.label().eq_ignore_ascii_case(id)) - } -} - -fn min_secs(s: Samples, sr: SampleRate) -> String { - let neg = s < 0; - // Integer maths: a float `seconds * 1000` lands just below exact millisecond positions. - let ms_total = i64::try_from(i128::from(s).abs() * 1000 / i128::from(sr.hz().max(1))).unwrap_or(i64::MAX); - let mins = ms_total / 60_000; - let secs = (ms_total / 1000) % 60; - let ms = ms_total % 1000; - format!("{}{mins}:{secs:02}.{ms:03}", if neg { "-" } else { "" }) -} - -/// Format an absolute position. `tc_start` is the timecode of sample 0 in samples, `ff_start` the -/// feet+frames reading of sample 0 in frames. -pub fn format_position(s: Samples, fmt: TimeFormat, sr: SampleRate, map: &TempoMap, rate: FrameRate, tc_start: Samples, ff_start: i64) -> String { - match fmt { - TimeFormat::Samples => s.to_string(), - TimeFormat::MinSecs => min_secs(s, sr), - TimeFormat::Timecode => Timecode::from_samples(s.saturating_add(tc_start), rate, sr).format(rate), - TimeFormat::FeetFrames => { - let (ft, fr) = feet_frames(s, rate, sr, ff_start); - format!("{ft}+{fr:02}") - } - TimeFormat::BarsBeats => { - let bb = map.bar_beat_at(s, sr); - format!("{}| {}| {:03}", bb.bar, bb.beat, bb.tick) - } - } -} - -/// Format a length starting at `start` (Bars|Beats lengths count from 0|0|000). -pub fn format_length(start: Samples, len: Samples, fmt: TimeFormat, sr: SampleRate, map: &TempoMap, rate: FrameRate) -> String { - match fmt { - TimeFormat::BarsBeats => { - let t0 = map.samples_to_ticks(start, sr); - let t1 = map.samples_to_ticks(start.saturating_add(len), sr); - let m = map.meter_at_tick(t0); - let d = (t1 - t0).max(0); - let bars = d / m.ticks_per_bar().max(1); - let rem = d % m.ticks_per_bar().max(1); - format!("{bars}| {}| {:03}", rem / m.ticks_per_beat().max(1), rem % m.ticks_per_beat().max(1)) - } - TimeFormat::Timecode => Timecode::from_samples(len, rate, sr).format(rate), - other => format_position(len, other, sr, map, rate, 0, 0), - } -} - -/// Parse a position typed into a counter or dialog. -pub fn parse_position( - text: &str, - fmt: TimeFormat, - sr: SampleRate, - map: &TempoMap, - rate: FrameRate, - tc_start: Samples, - ff_start: i64, -) -> Result { - let t = text.trim(); - let err = || TimeError::Parse(t.to_string(), fmt.label()); - match fmt { - TimeFormat::Samples => t.replace([',', '_'], "").parse::().map_err(|_| err()), - TimeFormat::MinSecs => { - let (neg, body) = match t.strip_prefix('-') { - Some(r) => (true, r), - None => (false, t), - }; - let (m, s) = match body.split_once(':') { - Some((m, s)) => (m.trim().parse::().map_err(|_| err())?, s.trim().parse::().map_err(|_| err())?), - None => (0.0, body.parse::().map_err(|_| err())?), - }; - if !m.is_finite() || !s.is_finite() || m < 0.0 || s < 0.0 { - return Err(err()); - } - let v = sr.samples(m * 60.0 + s); - Ok(if neg { -v } else { v }) - } - TimeFormat::Timecode => { - let tc = Timecode::parse(t)?; - if tc.minutes >= 60 || tc.seconds >= 60 || tc.frames >= rate.nominal().max(1) { - return Err(err()); - } - if rate.is_drop() && tc.seconds == 0 && tc.minutes % 10 != 0 { - let dropped = if rate.nominal() >= 60 { 4 } else { 2 }; - if tc.frames < dropped { - return Err(err()); - } - } - Ok(tc.to_samples(rate, sr).saturating_sub(tc_start)) - } - TimeFormat::FeetFrames => { - let (ft, fr) = t.split_once('+').ok_or_else(err)?; - let ft: i64 = ft.trim().parse().map_err(|_| err())?; - let fr: i64 = fr.trim().parse().map_err(|_| err())?; - Ok(rate.samples_at_frame(ft.saturating_mul(16).saturating_add(fr).saturating_sub(ff_start), sr)) - } - TimeFormat::BarsBeats => { - let parts: Vec = - t.split(['|', '.', ' ']).filter(|p| !p.is_empty()).map(str::parse::).collect::>().map_err(|_| err())?; - let bb = BarBeat { - bar: *parts.first().ok_or_else(err)?, - beat: parts.get(1).copied().unwrap_or(1).max(1), - tick: parts.get(2).copied().unwrap_or(0).max(0), - }; - Ok(map.samples_at_bar_beat(bb, sr)) - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn ctx() -> (SampleRate, TempoMap, FrameRate) { - (SampleRate::HZ_48000, TempoMap::default(), FrameRate::Fps30) - } - - #[test] - fn huge_typed_positions_parse_without_overflowing() { - let (sr, map, rate) = ctx(); - for (text, fmt) in [ - ("999999999999999999:0", TimeFormat::Timecode), - ("100000000000000:00:00:00", TimeFormat::Timecode), - ("-9223372036854775808", TimeFormat::BarsBeats), - ] { - let _ = parse_position(text, fmt, sr, &map, rate, 0, 0); - } - } - - #[test] - fn formats_like_pro_tools_counters() { - let (sr, map, rate) = ctx(); - assert_eq!(format_position(0, TimeFormat::MinSecs, sr, &map, rate, 0, 0), "0:00.000"); - assert_eq!(format_position(48_000 * 75 + 24_000, TimeFormat::MinSecs, sr, &map, rate, 0, 0), "1:15.500"); - assert_eq!(format_position(0, TimeFormat::BarsBeats, sr, &map, rate, 0, 0), "1| 1| 000"); - assert_eq!(format_position(48_000, TimeFormat::Timecode, sr, &map, rate, 0, 0), "00:00:01:00"); - assert_eq!(format_position(12345, TimeFormat::Samples, sr, &map, rate, 0, 0), "12345"); - } - - #[test] - fn minimum_bar_parses_without_overflow() { - let (sr, map, rate) = ctx(); - let p = |t: &str| parse_position(t, TimeFormat::BarsBeats, sr, &map, rate, 0, 0); - assert!(p("-9223372036854775808|01|000").is_ok_and(|s| s < 0)); - assert_eq!(p("2|3|000").ok(), Some(144_000)); - assert_eq!(p("0|1|000").ok(), Some(-96_000)); - } - - #[test] - fn parse_round_trips() { - let (sr, map, rate) = ctx(); - for fmt in TimeFormat::ALL { - for s in [0i64, 48_000, 96_000 * 3, 1_440_000] { - let text = format_position(s, fmt, sr, &map, rate, 0, 0); - let back = parse_position(&text, fmt, sr, &map, rate, 0, 0).unwrap(); - assert!((back - s).abs() <= 48, "{fmt:?} {s} → {text} → {back}"); - } - } - } - - #[test] - fn parse_round_trips_timecode_negative() { - let (sr, map, _) = ctx(); - let rate = FrameRate::Fps25; - for fmt in [TimeFormat::Timecode, TimeFormat::FeetFrames] { - for s in [-48_000i64, -96_000 * 3, -1_440_000] { - let text = format_position(s, fmt, sr, &map, rate, 0, 0); - let back = parse_position(&text, fmt, sr, &map, rate, 0, 0).unwrap(); - assert_eq!(back, s, "{fmt:?} {s} → {text} → {back}"); - } - } - } - - #[test] - fn parse_rejects_garbage() { - let (sr, map, rate) = ctx(); - assert!(parse_position("abc", TimeFormat::Samples, sr, &map, rate, 0, 0).is_err()); - assert!(parse_position("1:x", TimeFormat::MinSecs, sr, &map, rate, 0, 0).is_err()); - assert!(parse_position("", TimeFormat::BarsBeats, sr, &map, rate, 0, 0).is_err()); - } - - #[test] - fn drop_frame_skipped_labels_are_rejected() { - let (sr, map, _) = ctx(); - for (rate, skipped) in [ - (FrameRate::Fps29_97Drop, &["00:01:00;00", "00:01:00;01"][..]), - (FrameRate::Fps59_94Drop, &["00:01:00;00", "00:01:00;01", "00:01:00;02", "00:01:00;03"][..]), - ] { - for text in skipped { - assert!(parse_position(text, TimeFormat::Timecode, sr, &map, rate, 0, 0).is_err(), "accepted skipped label {text} at {rate:?}"); - } - assert!(parse_position("00:10:00;00", TimeFormat::Timecode, sr, &map, rate, 0, 0).is_ok()); - } - } - - #[test] - fn bar_lengths() { - let (sr, map, rate) = ctx(); - assert_eq!(format_length(0, 96_000 + 24_000, TimeFormat::BarsBeats, sr, &map, rate), "1| 1| 000"); - } -} diff --git a/crates/time/src/grid.rs b/crates/time/src/grid.rs deleted file mode 100644 index 0b0cc8ae..00000000 --- a/crates/time/src/grid.rs +++ /dev/null @@ -1,809 +0,0 @@ -//! Grid and Nudge values: musical or absolute step sizes, grid lines and snapping. - -use crate::{FrameRate, SampleRate, Samples, TICKS_PER_QUARTER, TempoMap, Timecode, to_samples}; - -/// Note values for Bars|Beats grids. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum NoteValue { - Bar, - Whole, - Half, - Quarter, - Eighth, - Sixteenth, - ThirtySecond, - SixtyFourth, -} - -impl NoteValue { - /// Every musical increment in menu order, from largest to smallest. - pub const ALL: [NoteValue; 8] = [ - NoteValue::Bar, - NoteValue::Whole, - NoteValue::Half, - NoteValue::Quarter, - NoteValue::Eighth, - NoteValue::Sixteenth, - NoteValue::ThirtySecond, - NoteValue::SixtyFourth, - ]; - /// Returns the nominal tick length; bars are adjusted for the active meter when used. - pub fn ticks(self) -> i64 { - match self { - NoteValue::Bar => TICKS_PER_QUARTER * 4, - NoteValue::Whole => TICKS_PER_QUARTER * 4, - NoteValue::Half => TICKS_PER_QUARTER * 2, - NoteValue::Quarter => TICKS_PER_QUARTER, - NoteValue::Eighth => TICKS_PER_QUARTER / 2, - NoteValue::Sixteenth => TICKS_PER_QUARTER / 4, - NoteValue::ThirtySecond => TICKS_PER_QUARTER / 8, - NoteValue::SixtyFourth => TICKS_PER_QUARTER / 16, - } - } - /// Returns the menu label for this musical increment. - pub fn label(self) -> &'static str { - match self { - NoteValue::Bar => "1 bar", - NoteValue::Whole => "Whole note", - NoteValue::Half => "1/2 note", - NoteValue::Quarter => "1/4 note", - NoteValue::Eighth => "1/8 note", - NoteValue::Sixteenth => "1/16 note", - NoteValue::ThirtySecond => "1/32 note", - NoteValue::SixtyFourth => "1/64 note", - } - } -} - -/// The time scale used by a Grid or Nudge value. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum GridScale { - BarsBeats, - MinSecs, - Timecode, - FeetFrames, - Samples, - ClipsMarkers, -} - -impl GridScale { - /// Numeric time scales shared by Grid and Nudge. - pub const TIME: [GridScale; 5] = [GridScale::BarsBeats, GridScale::MinSecs, GridScale::Timecode, GridScale::FeetFrames, GridScale::Samples]; - - /// Returns the user-facing scale label. - pub fn label(self) -> &'static str { - match self { - GridScale::BarsBeats => "Bars|Beats", - GridScale::MinSecs => "Min:Secs", - GridScale::Timecode => "Timecode", - GridScale::FeetFrames => "Feet+Frames", - GridScale::Samples => "Samples", - GridScale::ClipsMarkers => "Clips/Markers", - } - } - - /// Returns the stable command and session identifier. - pub fn id(self) -> &'static str { - match self { - GridScale::BarsBeats => "bars_beats", - GridScale::MinSecs => "min_secs", - GridScale::Timecode => "timecode", - GridScale::FeetFrames => "feet_frames", - GridScale::Samples => "samples", - GridScale::ClipsMarkers => "clips_markers", - } - } - - /// Parses a stable identifier or user-facing label. - pub fn from_id(id: &str) -> Option { - Self::TIME.into_iter().chain([GridScale::ClipsMarkers]).find(|scale| scale.id() == id || scale.label().eq_ignore_ascii_case(id)) - } -} - -/// Timecode Grid/Nudge increments, ordered independently of the session frame rate. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum TimecodeValue { - Second, - /// Five physical frames, independent of skipped drop-frame labels. - FiveFrames, - Frame, - HalfFrame, - QuarterFrame, - SubFrame, -} - -impl TimecodeValue { - /// Every Timecode increment in menu order, from largest to smallest. - pub const ALL: [TimecodeValue; 6] = [ - TimecodeValue::Second, - TimecodeValue::FiveFrames, - TimecodeValue::Frame, - TimecodeValue::HalfFrame, - TimecodeValue::QuarterFrame, - TimecodeValue::SubFrame, - ]; - - /// Returns the user-facing increment label. - pub fn label(self) -> &'static str { - match self { - TimecodeValue::Second => "1 second", - TimecodeValue::FiveFrames => "5 frames", - TimecodeValue::Frame => "1 frame", - TimecodeValue::HalfFrame => "1/2 frame", - TimecodeValue::QuarterFrame => "1/4 frame", - TimecodeValue::SubFrame => "1 subframe", - } - } - - /// Returns the stable command and session identifier. - pub fn id(self) -> &'static str { - match self { - TimecodeValue::Second => "second", - TimecodeValue::FiveFrames => "5_frames", - TimecodeValue::Frame => "frame", - TimecodeValue::HalfFrame => "half_frame", - TimecodeValue::QuarterFrame => "quarter_frame", - TimecodeValue::SubFrame => "subframe", - } - } - - /// Parses a stable identifier or user-facing label. - pub fn from_id(id: &str) -> Option { - Self::ALL.into_iter().find(|value| value.id() == id || value.label().eq_ignore_ascii_case(id)) - } - - /// Returns the increment length in frames at the session rate. - fn frames(self, rate: FrameRate) -> f64 { - match self { - TimecodeValue::Second => rate.nominal() as f64, - TimecodeValue::FiveFrames => 5.0, - TimecodeValue::Frame => 1.0, - TimecodeValue::HalfFrame => 0.5, - TimecodeValue::QuarterFrame => 0.25, - TimecodeValue::SubFrame => 0.01, - } - } -} - -/// Feet+Frames Grid/Nudge increments in physical frames, independent of drop-frame label skips. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum FeetFramesValue { - Foot, - Frame, - QuarterFrame, - SubFrame, -} - -impl FeetFramesValue { - /// Every Feet+Frames increment in menu order, from largest to smallest. - pub const ALL: [FeetFramesValue; 4] = [FeetFramesValue::Foot, FeetFramesValue::Frame, FeetFramesValue::QuarterFrame, FeetFramesValue::SubFrame]; - - /// Returns the user-facing increment label. - pub fn label(self) -> &'static str { - match self { - FeetFramesValue::Foot => "1 foot", - FeetFramesValue::Frame => "1 frame", - FeetFramesValue::QuarterFrame => "1/4 frame", - FeetFramesValue::SubFrame => "1 subframe", - } - } - - /// Returns the stable command and session identifier. - pub fn id(self) -> &'static str { - match self { - FeetFramesValue::Foot => "foot", - FeetFramesValue::Frame => "frame", - FeetFramesValue::QuarterFrame => "quarter_frame", - FeetFramesValue::SubFrame => "subframe", - } - } - - /// Parses a stable identifier or user-facing label. - pub fn from_id(id: &str) -> Option { - Self::ALL.into_iter().find(|value| value.id() == id || value.label().eq_ignore_ascii_case(id)) - } - - /// Returns the increment length in frames. - fn frames(self) -> f64 { - let (num, den) = self.frame_ratio(); - num as f64 / den as f64 - } - - /// Exact numerator and denominator of the increment in physical frames. - fn frame_ratio(self) -> (i128, i128) { - match self { - Self::Foot => (16, 1), - Self::Frame => (1, 1), - Self::QuarterFrame => (1, 4), - Self::SubFrame => (1, 100), - } - } - - /// Apply the counter origin in frames before rounding once to the nearest sample. - fn sample_line(self, index: i128, sr: SampleRate, rate: FrameRate, origin: i64) -> Samples { - let (num, den) = self.frame_ratio(); - let (rate_num, rate_den) = rate.rational(); - let frames = index * num - i128::from(origin) * den; - let samples = frames * i128::from(sr.hz().max(1)) * i128::from(rate_den); - let divisor = den * i128::from(rate_num); - let magnitude = (samples.abs() + divisor / 2) / divisor; - let rounded = if samples < 0 { -magnitude } else { magnitude }; - i64::try_from(rounded).unwrap_or(if rounded < 0 { i64::MIN } else { i64::MAX }) - } - - /// Find a line index using exact frame arithmetic, allowing for whole-sample rounding. - fn line_index(self, position: Samples, sr: SampleRate, rate: FrameRate, origin: i64) -> i128 { - let (num, den) = self.frame_ratio(); - let (rate_num, rate_den) = rate.rational(); - let scale = i128::from(sr.hz().max(1)) * i128::from(rate_den); - let frames = i128::from(position) * i128::from(rate_num) + i128::from(origin) * scale; - let mut index = (frames * den).div_euclid(scale * num); - if self.sample_line(index + 1, sr, rate, origin) <= position { - index += 1; - } - index - } - - /// The Feet+Frames line at or before a sample, relative to the counter's frame origin. - pub fn line_at_or_before(self, position: Samples, sr: SampleRate, rate: FrameRate, origin: i64) -> Samples { - self.sample_line(self.line_index(position, sr, rate, origin), sr, rate, origin) - } - - /// The next distinct sample line; subframe increments may share a sample at low sample rates. - fn next_line(self, position: Samples, sr: SampleRate, rate: FrameRate, origin: i64) -> Samples { - self.sample_line(self.line_index(position, sr, rate, origin) + 1, sr, rate, origin).max(position.saturating_add(1)) - } - - /// Snap against frame-origin lines, choosing the earlier line when distances are equal. - pub fn snap(self, position: Samples, sr: SampleRate, rate: FrameRate, origin: i64) -> Samples { - let lo = self.line_at_or_before(position, sr, rate, origin); - let hi = self.next_line(lo, sr, rate, origin); - if i128::from(position) - i128::from(lo) <= i128::from(hi) - i128::from(position) { lo } else { hi } - } - - /// Distinct Feet+Frames sample lines within `[start, end)`, capped at `max`. - pub fn lines(self, start: Samples, end: Samples, sr: SampleRate, rate: FrameRate, origin: i64, max: usize) -> Vec { - let mut out = Vec::new(); - let mut line = self.line_at_or_before(start, sr, rate, origin); - while line < end && out.len() < max { - if line >= start { - out.push(line); - } - let next = self.next_line(line, sr, rate, origin); - if next <= line { - break; - } - line = next; - } - out - } -} - -/// A grid or nudge step. -#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)] -pub enum GridValue { - /// Musical: note value, optionally dotted or triplet. - Note { value: NoteValue, dotted: bool, triplet: bool }, - /// Absolute seconds (Min:Secs grids: 0.001 … 1 s). - Seconds(f64), - /// Frames at the session timecode rate. - /// Kept for sessions and commands written before named timecode increments were added. - Frames(i64), - /// A named Timecode increment, including fractional frames and one second. - Timecode(TimecodeValue), - /// A Feet+Frames increment (one foot is 16 frames). - FeetFrames(FeetFramesValue), - /// Raw samples. - Samples(i64), -} - -impl Default for GridValue { - /// Starts on a straight sixteenth-note Bars|Beats grid. - fn default() -> Self { - GridValue::Note { value: NoteValue::Sixteenth, dotted: false, triplet: false } - } -} - -impl GridValue { - /// Returns the user-facing label for this increment. - pub fn label(&self) -> String { - match self { - GridValue::Note { value, dotted, triplet } => { - let mut s = value.label().to_string(); - if *dotted { - s.push_str(" dotted"); - } - if *triplet { - s.push_str(" triplet"); - } - s - } - GridValue::Seconds(s) => { - if *s >= 1.0 { - format!("{s} second{}", if *s == 1.0 { "" } else { "s" }) - } else { - format!("{} ms", (s * 1000.0).round() as i64) - } - } - GridValue::Frames(f) => format!("{f} frame{}", if *f == 1 { "" } else { "s" }), - GridValue::Timecode(value) => value.label().to_string(), - GridValue::FeetFrames(value) => value.label().to_string(), - GridValue::Samples(n) => format!("{n} sample{}", if *n == 1 { "" } else { "s" }), - } - } - - /// Returns the time scale to which this increment belongs. - pub fn scale(self) -> GridScale { - match self { - GridValue::Note { .. } => GridScale::BarsBeats, - GridValue::Seconds(_) => GridScale::MinSecs, - GridValue::Frames(_) | GridValue::Timecode(_) => GridScale::Timecode, - GridValue::FeetFrames(_) => GridScale::FeetFrames, - GridValue::Samples(_) => GridScale::Samples, - } - } - - /// Returns the default increment for a newly selected time scale. - pub fn for_scale(scale: GridScale) -> GridValue { - match scale { - GridScale::BarsBeats => GridValue::default(), - GridScale::MinSecs => GridValue::Seconds(1.0), - GridScale::Timecode => GridValue::Timecode(TimecodeValue::Frame), - GridScale::FeetFrames => GridValue::FeetFrames(FeetFramesValue::Frame), - GridScale::Samples => GridValue::Samples(100), - GridScale::ClipsMarkers => GridValue::default(), - } - } - - /// The next larger or smaller menu value of the same kind, or `self` at either end. Note values keep - /// their dot or triplet modifier. - pub fn stepped(self, larger: bool) -> GridValue { - /// Finds the next value in a numeric increment ladder without wrapping. - fn next(ladder: &[T], v: T, larger: bool) -> Option { - if larger { ladder.iter().copied().find(|x| *x > v) } else { ladder.iter().rev().copied().find(|x| *x < v) } - } - match self { - GridValue::Note { value, dotted, triplet } => { - let i = NoteValue::ALL.iter().position(|v| *v == value).unwrap_or(0); - let j = if larger { i.checked_sub(1) } else { i.checked_add(1) }; - j.and_then(|j| NoteValue::ALL.get(j)).map_or(self, |&value| GridValue::Note { value, dotted, triplet }) - } - GridValue::Seconds(s) => next(&[0.001, 0.01, 0.1, 0.5, 1.0], s, larger).map_or(self, GridValue::Seconds), - GridValue::Frames(f) => next(&[1, 10, 100], f, larger).map_or(self, GridValue::Frames), - GridValue::Timecode(value) => step_enum(&TimecodeValue::ALL, value, larger).map_or(self, GridValue::Timecode), - GridValue::FeetFrames(value) => step_enum(&FeetFramesValue::ALL, value, larger).map_or(self, GridValue::FeetFrames), - GridValue::Samples(n) => next(&[1, 2, 10, 100, 1_000, 10_000], n, larger).map_or(self, GridValue::Samples), - } - } - - fn note_ticks(value: NoteValue, dotted: bool, triplet: bool, map: &TempoMap, at_tick: i64) -> i64 { - let base = if value == NoteValue::Bar { map.meter_at_tick(at_tick).ticks_per_bar() } else { value.ticks() }; - let mut t = base; - if dotted { - t = t * 3 / 2; - } - if triplet { - t = t * 2 / 3; - } - t.max(1) - } - - /// The step in samples at position `at` (musical steps depend on tempo). - pub fn step_samples(&self, at: Samples, sr: SampleRate, map: &TempoMap, rate: FrameRate) -> Samples { - match *self { - GridValue::Note { value, dotted, triplet } => { - let t0 = map.samples_to_ticks(at, sr); - let dt = Self::note_ticks(value, dotted, triplet, map, t0); - (map.tick_to_samples(t0.saturating_add(dt), sr).saturating_sub(map.tick_to_samples(t0, sr))).max(1) - } - GridValue::Seconds(s) => sr.samples(s.clamp(0.000_01, 3600.0)).max(1), - GridValue::Frames(f) => to_samples(rate.samples_per_frame(sr) * f.clamp(1, 1_000_000) as f64).max(1), - GridValue::Timecode(value) => to_samples(rate.samples_per_frame(sr) * value.frames(rate)).max(1), - GridValue::FeetFrames(value) => to_samples(rate.samples_per_frame(sr) * value.frames()).max(1), - GridValue::Samples(n) => n.max(1), - } - } - - /// Nearest grid line to `pos`. - pub fn snap(&self, pos: Samples, sr: SampleRate, map: &TempoMap, rate: FrameRate) -> Samples { - if let Self::FeetFrames(value) = *self { - return value.snap(pos, sr, rate, 0); - } - let lo = self.line_at_or_before(pos, sr, map, rate); - let hi = self.next_line(lo, sr, map, rate); - if (pos - lo) <= (hi - pos) { lo } else { hi } - } - - /// The grid line at or before `pos`. - pub fn line_at_or_before(&self, pos: Samples, sr: SampleRate, map: &TempoMap, rate: FrameRate) -> Samples { - match *self { - Self::FeetFrames(value) => value.line_at_or_before(pos, sr, rate, 0), - GridValue::Note { value, dotted, triplet } => { - // Float ticks can land a hair either side of a line's own tick. - let mut t = map.samples_to_ticks_f(pos, sr).floor() as i64; - if map.tick_to_samples(t, sr) > pos { - t = t.saturating_sub(1); - } else if map.tick_to_samples(t.saturating_add(1), sr) <= pos { - t = t.saturating_add(1); - } - // Sub-bar values restart at each bar so odd meters stay aligned. A whole note is - // always four quarter notes and therefore keeps a continuous tick origin. - let bb = map.bar_beat_at_tick(t); - let bar_tick = map.bar_start_tick(bb.bar); - let origin = if value == NoteValue::Whole { 0 } else { bar_tick }; - let step = Self::note_ticks(value, dotted, triplet, map, origin); - let k = (t - origin).div_euclid(step); - map.tick_to_samples(origin + k * step, sr) - } - _ => self.abs_line(self.abs_index_at_or_before(pos, sr, rate), sr, rate), - } - } - - /// Position of absolute grid line `k` (Seconds, Frames, Samples), at an exact multiple of the step - /// rounded once, so rounding never accumulates from line to line. - fn abs_line(&self, k: i64, sr: SampleRate, rate: FrameRate) -> Samples { - if let Self::FeetFrames(value) = *self { - return value.sample_line(i128::from(k), sr, rate, 0); - } - if matches!(self, GridValue::Timecode(TimecodeValue::Second)) && rate.is_drop() { - return rate.samples_at_frame(Self::drop_second_frame(k, rate), sr); - } - if let Some(frames) = self.frame_step(rate) { - let whole = frames.round(); - if frames == whole { - return rate.samples_at_frame(k.saturating_mul(whole as i64), sr); - } - let step = (rate.samples_per_frame(sr) * frames).max(1.0); - return to_samples(k as f64 * step); - } - match *self { - GridValue::Seconds(s) => to_samples(k as f64 * Self::seconds_step(s, sr)), - GridValue::Samples(n) => k.saturating_mul(n.max(1)), - GridValue::Note { .. } => 0, - GridValue::Frames(_) | GridValue::Timecode(_) | GridValue::FeetFrames(_) => 0, - } - } - - /// Index of the absolute grid line at or before `pos`. - fn abs_index_at_or_before(&self, pos: Samples, sr: SampleRate, rate: FrameRate) -> i64 { - if matches!(self, GridValue::Timecode(TimecodeValue::Second)) && rate.is_drop() { - let tc = Timecode::from_frames(rate.frames_at(pos, sr), rate); - let magnitude = tc.hours.saturating_mul(3600).saturating_add(tc.minutes.saturating_mul(60)).saturating_add(tc.seconds); - let mut k = if tc.negative { magnitude.saturating_neg() } else { magnitude }; - while self.abs_line(k, sr, rate) > pos { - let previous = k.saturating_sub(1); - if previous == k { - break; - } - k = previous; - } - while self.abs_line(k.saturating_add(1), sr, rate) <= pos { - let next = k.saturating_add(1); - if next == k { - break; - } - k = next; - } - return k; - } - let mut k = if let Some(frames) = self.frame_step(rate) { - let step = (rate.samples_per_frame(sr) * frames).max(1.0); - (pos as f64 / step).floor() as i64 - } else { - match *self { - GridValue::Seconds(s) => (pos as f64 / Self::seconds_step(s, sr)).floor() as i64, - GridValue::Samples(n) => return pos.div_euclid(n.max(1)), - GridValue::Note { .. } => return 0, - GridValue::Frames(_) | GridValue::Timecode(_) | GridValue::FeetFrames(_) => return 0, - } - }; - // Lines are rounded to whole samples, so the floored index can be one off either way. - if self.abs_line(k, sr, rate) > pos { - k = k.saturating_sub(1); - } else if self.abs_line(k.saturating_add(1), sr, rate) <= pos { - k = k.saturating_add(1); - } - k - } - - /// The exact (fractional) Seconds step in samples, at least one sample. - fn seconds_step(s: f64, sr: SampleRate) -> f64 { - (s.clamp(0.000_01, 3600.0) * sr.as_f64()).max(1.0) - } - - /// Maps a signed whole-second timecode label to its physical frame at a drop-frame rate. - fn drop_second_frame(index: i64, rate: FrameRate) -> i64 { - let seconds = index.unsigned_abs(); - let total_minutes = seconds / 60; - let frames = if seconds.is_multiple_of(60) && !total_minutes.is_multiple_of(10) { if rate.nominal() >= 60 { 4 } else { 2 } } else { 0 }; - Timecode { - negative: index < 0, - hours: i64::try_from(seconds / 3600).unwrap_or(i64::MAX), - minutes: i64::try_from((seconds / 60) % 60).unwrap_or(0), - seconds: i64::try_from(seconds % 60).unwrap_or(0), - frames, - } - .to_frames(rate) - } - - /// A frame-based increment as a possibly fractional number of frames. - fn frame_step(&self, rate: FrameRate) -> Option { - match *self { - GridValue::Frames(frames) => Some(frames.clamp(1, 1_000_000) as f64), - GridValue::Timecode(value) => Some(value.frames(rate)), - GridValue::FeetFrames(value) => Some(value.frames()), - _ => None, - } - } - - /// The first grid line strictly after `line`. - pub fn next_line(&self, line: Samples, sr: SampleRate, map: &TempoMap, rate: FrameRate) -> Samples { - if let Self::FeetFrames(value) = *self { - return value.next_line(line, sr, rate, 0); - } - if !matches!(self, GridValue::Note { .. }) { - let next = self.abs_line(self.abs_index_at_or_before(line, sr, rate).saturating_add(1), sr, rate); - return if next > line { next } else { line.saturating_add(1) }; - } - let step = self.step_samples(line, sr, map, rate); - let candidate = self.line_at_or_before(line.saturating_add(step), sr, map, rate); - if candidate > line { candidate } else { line.saturating_add(step) } - } - - /// All grid lines within `[start, end)`, capped at `max` lines. - pub fn lines(&self, start: Samples, end: Samples, sr: SampleRate, map: &TempoMap, rate: FrameRate, max: usize) -> Vec { - if let Self::FeetFrames(value) = *self { - return value.lines(start, end, sr, rate, 0, max); - } - let mut out = Vec::new(); - let mut p = self.line_at_or_before(start, sr, map, rate); - while p < end && out.len() < max { - if p >= start { - out.push(p); - } - let n = self.next_line(p, sr, map, rate); - if n <= p { - break; - } - p = n; - } - out - } -} - -/// Moves one position through an ordered increment menu without wrapping. -fn step_enum(values: &[T], value: T, larger: bool) -> Option { - let index = values.iter().position(|candidate| *candidate == value)?; - let next = if larger { index.checked_sub(1) } else { index.checked_add(1) }?; - values.get(next).copied() -} - -#[cfg(test)] -mod tests { - use super::*; - - /// Frame origins are subtracted before rounding whole frames, quarter frames and subframes. - #[test] - fn feet_frames_origins_round_only_after_applying_the_frame_offset() { - let (sr, rate) = (SampleRate::HZ_48000, FrameRate::Fps29_97); - for at in [49_650, 100_901, 177_778] { - assert_eq!(FeetFramesValue::Foot.line_at_or_before(at, sr, rate, 1), at); - assert_eq!(FeetFramesValue::Foot.snap(at - 1, sr, rate, 1), at); - } - assert_eq!(FeetFramesValue::QuarterFrame.snap(50_049, sr, rate, 1), 50_050); - assert_eq!(FeetFramesValue::SubFrame.lines(49_665, 49_667, sr, rate, 1, 4), [49_666]); - } - - /// Dense subframes retain distinct sample lines and remain bounded with extreme signed origins. - #[test] - fn feet_frames_subframes_handle_dense_steps_and_extreme_origins() { - let sr = SampleRate::new(8_000).unwrap(); - let rate = FrameRate::Fps120; - for origin in [i64::MIN, -1, 0, 1, i64::MAX] { - assert_eq!(FeetFramesValue::SubFrame.lines(-3, 4, sr, rate, origin, 20), [-3, -2, -1, 0, 1, 2, 3]); - for at in [i64::MIN, -1, 0, 1, i64::MAX] { - assert_eq!(FeetFramesValue::SubFrame.line_at_or_before(at, sr, rate, origin), at); - assert_eq!(FeetFramesValue::SubFrame.snap(at, sr, rate, origin), at); - } - } - } - - #[test] - fn grid_lines_are_their_own_line_at_odd_tempos() { - let (g, sr, rate) = (GridValue::default(), SampleRate::HZ_48000, FrameRate::Fps30); - for bpm in [90.0, 95.0, 110.0, 130.0, 140.0] { - let map = TempoMap::new(bpm, 4, 4).unwrap(); - let mut line = 0; - for _ in 0..64 { - assert_eq!(g.line_at_or_before(line, sr, &map, rate), line, "{bpm} bpm"); - line = g.next_line(line, sr, &map, rate); - } - } - } - - /// Musical boundaries stay exact across a tempo change while absolute scales remain - /// independent of the tempo map. - #[test] - fn grids_stay_aligned_across_a_tempo_change() { - let (sr, rate) = (SampleRate::HZ_48000, FrameRate::Fps29_97Drop); - let mut map = TempoMap::default(); - map.set_tempo(TICKS_PER_QUARTER * 4, 90.0).unwrap(); - let musical = GridValue::Note { value: NoteValue::Quarter, dotted: false, triplet: false }; - for tick in [0, TICKS_PER_QUARTER * 3, TICKS_PER_QUARTER * 4, TICKS_PER_QUARTER * 5] { - let line = map.tick_to_samples(tick, sr); - assert_eq!(musical.line_at_or_before(line, sr, &map, rate), line); - } - for absolute in [ - GridValue::Seconds(0.5), - GridValue::Timecode(TimecodeValue::Second), - GridValue::FeetFrames(FeetFramesValue::Foot), - GridValue::Samples(1_000), - ] { - let line = absolute.next_line(absolute.line_at_or_before(100_000, sr, &map, rate), sr, &map, rate); - assert_eq!(absolute.line_at_or_before(line, sr, &map, rate), line, "{absolute:?}"); - } - } - - #[test] - fn sixteenth_grid_at_120() { - let g = GridValue::default(); - let (sr, map, rate) = (SampleRate::HZ_48000, TempoMap::default(), FrameRate::Fps30); - assert_eq!(g.step_samples(0, sr, &map, rate), 6000); - assert_eq!(g.snap(2900, sr, &map, rate), 0); - assert_eq!(g.snap(3100, sr, &map, rate), 6000); - assert_eq!(g.lines(0, 24_000, sr, &map, rate, 100), vec![0, 6000, 12000, 18000]); - } - - /// Absolute increments report their expected sample lengths at a fixed rate. - #[test] - fn absolute_grids() { - let (sr, map, rate) = (SampleRate::HZ_48000, TempoMap::default(), FrameRate::Fps25); - assert_eq!(GridValue::Seconds(1.0).snap(70_000, sr, &map, rate), 48_000); - assert_eq!(GridValue::Frames(1).step_samples(0, sr, &map, rate), 1920); - assert_eq!(GridValue::Timecode(TimecodeValue::Second).step_samples(0, sr, &map, rate), 48_000); - assert_eq!(GridValue::Timecode(TimecodeValue::FiveFrames).step_samples(0, sr, &map, rate), 9_600); - assert_eq!(GridValue::Timecode(TimecodeValue::HalfFrame).step_samples(0, sr, &map, rate), 960); - assert_eq!(GridValue::Timecode(TimecodeValue::QuarterFrame).step_samples(0, sr, &map, rate), 480); - assert_eq!(GridValue::Timecode(TimecodeValue::SubFrame).step_samples(0, sr, &map, rate), 19); - assert_eq!(GridValue::FeetFrames(FeetFramesValue::Foot).step_samples(0, sr, &map, rate), 30_720); - assert_eq!(GridValue::Samples(0).step_samples(0, sr, &map, rate), 1); - } - - /// Bar length follows the meter while a whole note always spans four quarter notes. - #[test] - fn a_bar_and_a_whole_note_differ_in_three_four() { - let (sr, map, rate) = (SampleRate::HZ_48000, TempoMap::new(120.0, 3, 4).unwrap(), FrameRate::Fps25); - let note = |value| GridValue::Note { value, dotted: false, triplet: false }; - assert_eq!(note(NoteValue::Bar).step_samples(0, sr, &map, rate), 72_000); - assert_eq!(note(NoteValue::Whole).step_samples(0, sr, &map, rate), 96_000); - assert_eq!(note(NoteValue::Bar).line_at_or_before(96_000, sr, &map, rate), 72_000); - assert_eq!(note(NoteValue::Whole).line_at_or_before(96_000, sr, &map, rate), 96_000); - assert_eq!(note(NoteValue::Half).lines(0, 150_000, sr, &map, rate, 10), [0, 48_000, 72_000, 120_000, 144_000]); - } - - #[test] - fn seconds_grid_lines_land_on_whole_seconds() { - let (sr, map, rate) = (SampleRate::HZ_44100, TempoMap::default(), FrameRate::Fps30); - for g in [GridValue::Seconds(0.001), GridValue::Seconds(0.01)] { - for n in 0..20 { - let s = n * 44_100; - assert_eq!(g.snap(s, sr, &map, rate), s, "{g:?} at {n} s"); - assert_eq!(g.line_at_or_before(s, sr, &map, rate), s, "{g:?} at {n} s"); - } - } - } - - /// Legacy frame grids stay aligned to exact frame starts at fractional rates. - #[test] - fn frame_grid_lines_land_on_frame_starts() { - let sr = SampleRate::HZ_48000; - let map = TempoMap::default(); - for rate in [FrameRate::Fps29_97, FrameRate::Fps23_976] { - for f in [1, 10] { - let g = GridValue::Frames(f); - for k in (0..5000).step_by(37) { - let s = rate.samples_at_frame(k, sr); - let line = rate.samples_at_frame(k.div_euclid(f) * f, sr); - assert_eq!(g.line_at_or_before(s, sr, &map, rate), line, "{rate:?} {f} frames at frame {k}"); - if k % f == 0 { - assert_eq!(g.snap(s, sr, &map, rate), s, "{rate:?} {f} frames at frame {k}"); - } - } - let start = rate.samples_at_frame(4000, sr); - let end = rate.samples_at_frame(4000 + 20 * f, sr); - let want: Vec<_> = (0..20).map(|i| rate.samples_at_frame(4000 + i * f, sr)).collect(); - assert_eq!(g.lines(start, end, sr, &map, rate, 100), want, "{rate:?} {f} frames"); - } - } - } - - /// Named whole- and sub-frame grids retain the exact-multiple calculation used by legacy frame grids. - #[test] - fn named_frame_grids_land_on_exact_subdivisions() { - let sr = SampleRate::HZ_48000; - let map = TempoMap::default(); - let grids = TimecodeValue::ALL.into_iter().map(GridValue::Timecode).chain(FeetFramesValue::ALL.into_iter().map(GridValue::FeetFrames)); - for rate in [FrameRate::Fps29_97, FrameRate::Fps23_976] { - for grid in grids.clone() { - for index in 0..200 { - let line = grid.abs_line(index, sr, rate); - assert_eq!(grid.line_at_or_before(line, sr, &map, rate), line, "{grid:?} {rate:?} line {index}"); - assert_eq!(grid.next_line(line, sr, &map, rate), grid.abs_line(index + 1, sr, rate), "{grid:?} {rate:?} line {index}"); - } - } - } - } - - /// Drop-frame second grids follow labelled second boundaries in both timeline directions. - #[test] - fn drop_frame_second_grids_follow_timecode_labels() { - let sr = SampleRate::HZ_48000; - let map = TempoMap::default(); - let grid = GridValue::Timecode(TimecodeValue::Second); - for rate in [FrameRate::Fps29_97Drop, FrameRate::Fps59_94Drop] { - for seconds in [0, 59, 60, 61, 600, 601, 3600] { - let frame = GridValue::drop_second_frame(seconds, rate); - let line = rate.samples_at_frame(frame, sr); - assert_eq!(grid.line_at_or_before(line, sr, &map, rate), line, "{rate:?} second {seconds}"); - assert_eq!(grid.line_at_or_before(-line, sr, &map, rate), -line, "{rate:?} second -{seconds}"); - for offset in -2..=rate.nominal() + 2 { - let position = rate.samples_at_frame(frame.saturating_add(offset), sr); - let before = grid.line_at_or_before(position, sr, &map, rate); - assert!(before <= position, "{rate:?} second {seconds}, frame offset {offset}"); - assert!(grid.next_line(before, sr, &map, rate) > position, "{rate:?} second {seconds}, frame offset {offset}"); - } - } - let labelled = Timecode { negative: false, hours: 0, minutes: 1, seconds: 1, frames: 0 }.to_samples(rate, sr); - assert_eq!(grid.snap(labelled, sr, &map, rate), labelled); - } - - for (rate, minute_frame) in [(FrameRate::Fps29_97Drop, 1800), (FrameRate::Fps59_94Drop, 3600)] { - let boundary = rate.samples_at_frame(minute_frame, sr); - assert_eq!(grid.line_at_or_before(boundary, sr, &map, rate), boundary, "{rate:?} positive minute boundary"); - assert_eq!(grid.snap(boundary, sr, &map, rate), boundary, "{rate:?} positive minute snap"); - assert_eq!(grid.line_at_or_before(-boundary, sr, &map, rate), -boundary, "{rate:?} negative minute boundary"); - assert_eq!(grid.snap(-boundary, sr, &map, rate), -boundary, "{rate:?} negative minute snap"); - } - } - - #[test] - fn lines_are_capped() { - let (sr, map, rate) = (SampleRate::HZ_48000, TempoMap::default(), FrameRate::Fps25); - assert_eq!(GridValue::Samples(1).lines(0, 1_000_000, sr, &map, rate, 50).len(), 50); - } - - #[test] - fn triplets_and_dots() { - let (sr, map, rate) = (SampleRate::HZ_48000, TempoMap::default(), FrameRate::Fps25); - let t = GridValue::Note { value: NoteValue::Quarter, dotted: false, triplet: true }; - assert_eq!(t.step_samples(0, sr, &map, rate), 16_000); - let d = GridValue::Note { value: NoteValue::Quarter, dotted: true, triplet: false }; - assert_eq!(d.step_samples(0, sr, &map, rate), 36_000); - } - - /// Stepping follows each menu ladder and stops at its endpoints. - #[test] - fn values_step_to_the_next_larger_or_smaller() { - let note = |value, triplet| GridValue::Note { value, dotted: false, triplet }; - assert_eq!(note(NoteValue::Sixteenth, false).stepped(true), note(NoteValue::Eighth, false)); - assert_eq!(note(NoteValue::Eighth, true).stepped(false), note(NoteValue::Sixteenth, true)); - assert_eq!(note(NoteValue::Bar, false).stepped(true), note(NoteValue::Bar, false)); - assert_eq!(note(NoteValue::SixtyFourth, false).stepped(false), note(NoteValue::SixtyFourth, false)); - assert_eq!(GridValue::Seconds(0.01).stepped(true), GridValue::Seconds(0.1)); - assert_eq!(GridValue::Seconds(0.5).stepped(false), GridValue::Seconds(0.1)); - assert_eq!(GridValue::Seconds(1.0).stepped(true), GridValue::Seconds(1.0)); - assert_eq!(GridValue::Frames(1).stepped(true), GridValue::Frames(10)); - assert_eq!(GridValue::Timecode(TimecodeValue::Frame).stepped(false), GridValue::Timecode(TimecodeValue::HalfFrame)); - assert_eq!(GridValue::FeetFrames(FeetFramesValue::Frame).stepped(true), GridValue::FeetFrames(FeetFramesValue::Foot)); - assert_eq!(GridValue::Samples(100).stepped(false), GridValue::Samples(10)); - assert_eq!(GridValue::Samples(1).stepped(true), GridValue::Samples(2)); - assert_eq!(GridValue::Samples(1).stepped(false), GridValue::Samples(1)); - } - - #[test] - fn snap_at_extreme_position_does_not_overflow() { - let sr = SampleRate::new(8000).unwrap(); - let map = TempoMap::new(1000.0, 4, 4).unwrap(); - let _ = GridValue::default().snap(i64::MAX, sr, &map, FrameRate::Fps30); - } -} diff --git a/crates/time/src/lib.rs b/crates/time/src/lib.rs index bd4df3aa..7b641b98 100644 --- a/crates/time/src/lib.rs +++ b/crates/time/src/lib.rs @@ -1,155 +1,4 @@ -//! SoundCraft timebases. -//! -//! Every position in a session is an absolute sample index (`i64`) at the session sample rate. -//! This crate converts those positions to and from the five Pro Tools-style timebases -//! (Bars|Beats, Min:Secs, Timecode, Feet+Frames, Samples) through a [`TempoMap`], and computes -//! grid lines and snapping for the Grid / Nudge values. +//! Compatibility facade for SoundCraft's sample-index time API in shared `craft-time`. #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] -mod format; -mod grid; -mod tempo; -mod timecode; - -pub use format::{TimeFormat, format_length, format_position, parse_position}; -pub use grid::{FeetFramesValue, GridScale, GridValue, NoteValue, TimecodeValue}; -pub use tempo::{BarBeat, MeterEvent, TICKS_PER_QUARTER, TempoEvent, TempoMap}; -pub use timecode::{FrameRate, Timecode}; - -/// A position or length in samples. -pub type Samples = i64; - -/// Largest position accepted from parameters and files: 2^40 samples (about 265 days at 48 kHz). -/// Clamping there keeps every later addition and subtraction on positions far away from overflow. -pub const MAX_POSITION: Samples = 1 << 40; - -/// Errors from parsing or converting time values. -#[derive(Debug, Clone, PartialEq, thiserror::Error)] -pub enum TimeError { - #[error("cannot parse `{0}` as a {1} value")] - Parse(String, &'static str), - #[error("invalid sample rate {0}")] - SampleRate(u32), - #[error("invalid tempo {0}")] - Tempo(f64), - #[error("invalid meter {0}/{1}")] - Meter(u32, u32), -} - -/// Sample rates supported by sessions (Pro Tools offers 44.1 k – 192 k; we accept 8 k – 768 k). -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub struct SampleRate(u32); - -impl SampleRate { - pub const HZ_44100: SampleRate = SampleRate(44_100); - pub const HZ_48000: SampleRate = SampleRate(48_000); - pub const COMMON: [u32; 8] = [44_100, 48_000, 88_200, 96_000, 176_400, 192_000, 352_800, 384_000]; - - pub fn new(hz: u32) -> Result { - if (8_000..=768_000).contains(&hz) { Ok(SampleRate(hz)) } else { Err(TimeError::SampleRate(hz)) } - } - pub fn hz(self) -> u32 { - self.0 - } - pub fn as_f64(self) -> f64 { - f64::from(self.0) - } - /// Samples → seconds. - pub fn seconds(self, s: Samples) -> f64 { - s as f64 / self.as_f64() - } - /// Seconds → samples, rounded to nearest and saturated. - pub fn samples(self, seconds: f64) -> Samples { - to_samples(seconds * self.as_f64()) - } -} - -impl Default for SampleRate { - fn default() -> Self { - SampleRate::HZ_48000 - } -} - -/// Round a float sample count to `i64`, mapping NaN to 0 and saturating infinities. -pub fn to_samples(v: f64) -> Samples { - if v.is_nan() { - 0 - } else if v >= i64::MAX as f64 { - i64::MAX - } else if v <= i64::MIN as f64 { - i64::MIN - } else { - v.round() as i64 - } -} - -/// A half-open sample range `[start, end)`. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub struct Range { - pub start: Samples, - pub end: Samples, -} - -impl Range { - pub fn new(a: Samples, b: Samples) -> Self { - if a <= b { Range { start: a, end: b } } else { Range { start: b, end: a } } - } - pub fn point(at: Samples) -> Self { - Range { start: at, end: at } - } - pub fn len(&self) -> Samples { - self.end.saturating_sub(self.start) - } - pub fn is_empty(&self) -> bool { - self.end <= self.start - } - pub fn contains(&self, s: Samples) -> bool { - s >= self.start && s < self.end - } - pub fn overlaps(&self, o: &Range) -> bool { - self.start < o.end && o.start < self.end - } - pub fn intersect(&self, o: &Range) -> Option { - let s = self.start.max(o.start); - let e = self.end.min(o.end); - (s < e).then_some(Range { start: s, end: e }) - } - pub fn shifted(&self, by: Samples) -> Range { - Range { start: self.start.saturating_add(by), end: self.end.saturating_add(by) } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn sample_rate_bounds() { - assert!(SampleRate::new(48_000).is_ok()); - assert!(SampleRate::new(0).is_err()); - assert!(SampleRate::new(10_000_000).is_err()); - } - - #[test] - fn seconds_round_trip() { - let sr = SampleRate::HZ_44100; - assert_eq!(sr.samples(1.0), 44_100); - assert!((sr.seconds(22_050) - 0.5).abs() < 1e-12); - } - - #[test] - fn to_samples_is_total() { - assert_eq!(to_samples(f64::NAN), 0); - assert_eq!(to_samples(f64::INFINITY), i64::MAX); - assert_eq!(to_samples(f64::NEG_INFINITY), i64::MIN); - } - - #[test] - fn range_ops() { - let a = Range::new(10, 0); - assert_eq!(a, Range { start: 0, end: 10 }); - assert_eq!(a.intersect(&Range::new(5, 20)), Some(Range::new(5, 10))); - assert_eq!(a.intersect(&Range::new(10, 20)), None); - assert!(a.contains(9) && !a.contains(10)); - } -} +pub use craft_time::soundcraft::*; diff --git a/crates/time/src/tempo.rs b/crates/time/src/tempo.rs deleted file mode 100644 index 5debdebd..00000000 --- a/crates/time/src/tempo.rs +++ /dev/null @@ -1,622 +0,0 @@ -//! Tempo and meter maps: the conversion between musical time (ticks) and samples. - -use crate::{MAX_POSITION, SampleRate, Samples, TimeError, to_samples}; - -/// Ticks per quarter note (Pro Tools' resolution). -pub const TICKS_PER_QUARTER: i64 = 960; - -/// A tempo change at a tick position. `bpm` is quarter notes per minute. -#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct TempoEvent { - pub tick: i64, - pub bpm: f64, -} - -/// A meter (time signature) change at a tick position, which must fall on a bar line. -#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] -pub struct MeterEvent { - pub tick: i64, - pub numerator: u32, - pub denominator: u32, -} - -impl MeterEvent { - pub fn ticks_per_beat(&self) -> i64 { - let d = i64::from(self.denominator.max(1)); - (TICKS_PER_QUARTER * 4 / d).max(1) - } - pub fn ticks_per_bar(&self) -> i64 { - self.ticks_per_beat().saturating_mul(i64::from(self.numerator.max(1))) - } -} - -/// A musical position: 1-based bar and beat plus ticks within the beat. -#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] -pub struct BarBeat { - pub bar: i64, - pub beat: i64, - pub tick: i64, -} - -/// Tempo and meter changes for a session. Always has at least one of each, at tick 0. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -#[serde(from = "TempoMapData")] -pub struct TempoMap { - tempos: Vec, - meters: Vec, - /// For each tempo event, the elapsed time at its tick in quarter-note minutes (ticks / bpm, - /// summed over the earlier segments). Lets tick/sample conversions binary-search the segment - /// instead of walking every earlier tempo change, so converting many positions against a large - /// tempo map stays O(log n) each. Rebuilt whenever `tempos` changes. - #[serde(skip)] - elapsed: Vec, -} - -/// The serialized form of [`TempoMap`], without the derived lookup table. -#[derive(serde::Deserialize)] -struct TempoMapData { - tempos: Vec, - meters: Vec, -} - -impl From for TempoMap { - fn from(d: TempoMapData) -> Self { - TempoMap::from_parts(d.tempos, d.meters) - } -} - -impl Default for TempoMap { - fn default() -> Self { - TempoMap::from_parts(vec![TempoEvent { tick: 0, bpm: 120.0 }], vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }]) - } -} - -fn valid_bpm(bpm: f64) -> Result { - if bpm.is_finite() && (5.0..=1000.0).contains(&bpm) { Ok(bpm) } else { Err(TimeError::Tempo(bpm)) } -} - -fn valid_meter(numerator: u32, denominator: u32) -> bool { - (1..=64).contains(&numerator) && [1, 2, 4, 8, 16, 32, 64].contains(&denominator) -} - -impl TempoMap { - fn from_parts(tempos: Vec, meters: Vec) -> Self { - let mut m = TempoMap { tempos, meters, elapsed: Vec::new() }; - m.reindex(); - m - } - - /// Rebuild `elapsed` from `tempos`. The first segment runs from tick 0 at the first tempo. - fn reindex(&mut self) { - let mut elapsed = Vec::with_capacity(self.tempos.len()); - let mut acc = 0.0; - let mut seg_tick = 0i64; - let mut bpm = self.tempos.first().map_or(120.0, |e| e.bpm); - for (i, e) in self.tempos.iter().enumerate() { - if i > 0 { - // Saturating: a file's ticks are indexed before `sanitize` orders them. - acc += e.tick.saturating_sub(seg_tick) as f64 / bpm; - seg_tick = e.tick; - bpm = e.bpm; - } - elapsed.push(acc); - } - self.elapsed = elapsed; - } - - /// Samples per quarter-note minute (the unit of `elapsed`) at `sr`. - fn samples_per_elapsed(sr: SampleRate) -> f64 { - sr.as_f64() * 60.0 / TICKS_PER_QUARTER as f64 - } - - /// The tempo segment `i` (an index into `tempos`, 0 when it is empty): its start tick (0 for - /// the first), bpm and elapsed time at its start. - fn segment(&self, i: usize) -> (i64, f64, f64) { - let bpm = self.tempos.get(i).or(self.tempos.first()).map_or(120.0, |e| e.bpm); - let tick = if i == 0 { 0 } else { self.tempos.get(i).map_or(0, |e| e.tick) }; - (tick, bpm, self.elapsed.get(i).copied().unwrap_or(0.0)) - } - - pub fn new(bpm: f64, numerator: u32, denominator: u32) -> Result { - let mut m = TempoMap::default(); - m.set_tempo(0, bpm)?; - m.set_meter(0, numerator, denominator)?; - Ok(m) - } - - pub fn tempos(&self) -> &[TempoEvent] { - &self.tempos - } - pub fn meters(&self) -> &[MeterEvent] { - &self.meters - } - - /// Repair a map read from a file: only valid tempos and meters within `0..=MAX_POSITION` ticks, in - /// tick order, with one of each at tick 0. - pub fn sanitize(&mut self) { - self.tempos.retain(|e| (0..=MAX_POSITION).contains(&e.tick) && valid_bpm(e.bpm).is_ok()); - self.tempos.sort_by_key(|e| e.tick); - self.tempos.dedup_by_key(|e| e.tick); - if self.tempos.first().is_none_or(|e| e.tick > 0) { - let bpm = self.tempos.first().map_or(120.0, |e| e.bpm); - self.tempos.insert(0, TempoEvent { tick: 0, bpm }); - } - self.meters.retain(|m| (0..=MAX_POSITION).contains(&m.tick) && valid_meter(m.numerator, m.denominator)); - self.meters.sort_by_key(|m| m.tick); - self.meters.dedup_by_key(|m| m.tick); - if self.meters.first().is_none_or(|m| m.tick > 0) { - let (numerator, denominator) = self.meters.first().map_or((4, 4), |m| (m.numerator, m.denominator)); - self.meters.insert(0, MeterEvent { tick: 0, numerator, denominator }); - } - self.reindex(); - } - - /// Insert or replace the tempo at `tick`. - pub fn set_tempo(&mut self, tick: i64, bpm: f64) -> Result<(), TimeError> { - let bpm = valid_bpm(bpm)?; - let tick = tick.max(0); - match self.tempos.binary_search_by(|e| e.tick.cmp(&tick)) { - Ok(i) => { - if let Some(e) = self.tempos.get_mut(i) { - e.bpm = bpm; - } - } - Err(i) => self.tempos.insert(i, TempoEvent { tick, bpm }), - } - self.reindex(); - Ok(()) - } - - /// Remove a tempo event (the one at tick 0 is kept). - pub fn remove_tempo(&mut self, tick: i64) -> bool { - if tick == 0 { - return false; - } - let before = self.tempos.len(); - self.tempos.retain(|e| e.tick != tick); - self.reindex(); - before != self.tempos.len() - } - - /// Insert or replace the meter at `tick` (snapped to the bar line at or before it). - /// Later meter changes keep their bar numbers, so they stay on bar lines. - pub fn set_meter(&mut self, tick: i64, numerator: u32, denominator: u32) -> Result<(), TimeError> { - if !valid_meter(numerator, denominator) { - return Err(TimeError::Meter(numerator, denominator)); - } - let tick = if tick <= 0 { 0 } else { self.bar_start_tick(self.bar_beat_at_tick(tick).bar) }; - let later = self.take_meters_after(tick); - self.put_meter(MeterEvent { tick, numerator, denominator }); - self.restore_meters_at_bars(later); - Ok(()) - } - - /// Remove a meter event (the one at tick 0 is kept). Later meter changes keep their bar numbers. - pub fn remove_meter(&mut self, tick: i64) -> bool { - if tick == 0 || !self.meters.iter().any(|e| e.tick == tick) { - return false; - } - let later = self.take_meters_after(tick); - self.meters.retain(|e| e.tick != tick); - self.restore_meters_at_bars(later); - true - } - - fn put_meter(&mut self, ev: MeterEvent) { - match self.meters.binary_search_by(|e| e.tick.cmp(&ev.tick)) { - Ok(i) => { - if let Some(e) = self.meters.get_mut(i) { - *e = ev; - } - } - Err(i) => self.meters.insert(i, ev), - } - } - - /// Remove the meters after `tick`, returning each with the bar it starts: the bar - /// [`Self::bar_beat_at_tick`] gives its tick, counted in one pass over the map rather than one - /// walk per meter, so a session with many meter changes edits in linear time. - fn take_meters_after(&mut self, tick: i64) -> Vec<(i64, MeterEvent)> { - let mut later = Vec::new(); - let (mut bar, mut seg_tick) = (1i64, 0i64); - for (i, m) in self.meters.iter().enumerate() { - let tpb = m.ticks_per_bar(); - if m.tick > tick { - later.push((bar.saturating_add(m.tick.saturating_sub(seg_tick) / tpb), *m)); - } - if let Some(n) = self.meters.get(i + 1) { - bar = bar.saturating_add(ceil_div(n.tick.saturating_sub(seg_tick), tpb)); - seg_tick = n.tick; - } - } - self.meters.retain(|e| e.tick <= tick); - later - } - - /// The bar and tick of the last meter's segment, where [`Self::bar_start_tick`]'s walk ends. - fn last_segment(&self) -> (i64, i64) { - let (mut cur_bar, mut cur_tick) = (1i64, 0i64); - for (i, m) in self.meters.iter().enumerate() { - if let Some(n) = self.meters.get(i + 1) { - cur_bar = cur_bar.saturating_add(ceil_div(n.tick.saturating_sub(cur_tick), m.ticks_per_bar())); - cur_tick = n.tick; - } - } - (cur_bar, cur_tick) - } - - /// Put meters back at the start of their bars under the current earlier meters, in bar order. - /// Each lands at or past the last meter, so the walk to its bar resumes from there; a bar - /// before it (meters off their bar lines) takes the full walk. - fn restore_meters_at_bars(&mut self, later: Vec<(i64, MeterEvent)>) { - let (mut cur_bar, mut cur_tick) = self.last_segment(); - for (bar, ev) in later { - let tick = if bar >= cur_bar { - let tpb = self.meters.last().map_or(MeterEvent { tick: 0, numerator: 4, denominator: 4 }, |m| *m).ticks_per_bar(); - cur_tick.saturating_add(bar.saturating_sub(cur_bar).saturating_mul(tpb)) - } else { - self.bar_start_tick(bar) - }; - self.put_meter(MeterEvent { tick, ..ev }); - (cur_bar, cur_tick) = if bar >= cur_bar { (bar, tick) } else { self.last_segment() }; - } - } - - /// Tempo in effect at `tick`. - pub fn tempo_at_tick(&self, tick: i64) -> f64 { - let mut bpm = self.tempos.first().map_or(120.0, |e| e.bpm); - for e in &self.tempos { - if e.tick <= tick { - bpm = e.bpm; - } else { - break; - } - } - bpm - } - - /// Meter in effect at `tick`. - pub fn meter_at_tick(&self, tick: i64) -> MeterEvent { - let mut m = self.meters.first().copied().unwrap_or(MeterEvent { tick: 0, numerator: 4, denominator: 4 }); - for e in &self.meters { - if e.tick <= tick { - m = *e; - } else { - break; - } - } - m - } - - fn samples_per_tick(bpm: f64, sr: SampleRate) -> f64 { - sr.as_f64() * 60.0 / (bpm * TICKS_PER_QUARTER as f64) - } - - /// Ticks → samples (exact for constant-tempo segments). - pub fn tick_to_samples(&self, tick: i64, sr: SampleRate) -> Samples { - to_samples(self.tick_to_samples_f(tick, sr)) - } - - fn tick_to_samples_f(&self, tick: i64, sr: SampleRate) -> f64 { - // Tempo events after the first that start before `tick` (the segments it has passed). - let passed = self.tempos.get(1..).map_or(0, |rest| rest.partition_point(|e| e.tick < tick)); - let (seg_tick, bpm, elapsed) = self.segment(passed); - elapsed * Self::samples_per_elapsed(sr) + (tick - seg_tick) as f64 * Self::samples_per_tick(bpm, sr) - } - - /// Samples → ticks (fractional). - pub fn samples_to_ticks_f(&self, s: Samples, sr: SampleRate) -> f64 { - let s = s as f64; - let scale = Self::samples_per_elapsed(sr); - // Tempo events after the first that start at or before `s`. - let passed = self.elapsed.get(1..).map_or(0, |rest| rest.partition_point(|e| e * scale <= s)); - let (seg_tick, bpm, elapsed) = self.segment(passed); - seg_tick as f64 + (s - elapsed * scale) / Self::samples_per_tick(bpm, sr) - } - - pub fn samples_to_ticks(&self, s: Samples, sr: SampleRate) -> i64 { - to_samples(self.samples_to_ticks_f(s, sr)) - } - - /// Tick of the first beat of `bar` (1-based; bars before 1 extend the first meter backwards). - pub fn bar_start_tick(&self, bar: i64) -> i64 { - let mut cur_bar = 1i64; - let mut cur_tick = 0i64; - let first = self.meter_at_tick(0); - if bar < 1 { - return bar.saturating_sub(1).saturating_mul(first.ticks_per_bar()); - } - for (i, m) in self.meters.iter().enumerate() { - let next_tick = self.meters.get(i + 1).map(|n| n.tick); - let tpb = m.ticks_per_bar(); - let bars_in_seg = next_tick.map(|nt| ceil_div(nt.saturating_sub(cur_tick), tpb)); - match bars_in_seg { - Some(n) if bar >= cur_bar.saturating_add(n) => { - cur_bar = cur_bar.saturating_add(n); - cur_tick = next_tick.unwrap_or(cur_tick); - } - _ => return cur_tick.saturating_add((bar - cur_bar).saturating_mul(tpb)), - } - } - cur_tick - } - - /// Bar|beat|tick at `tick`. - pub fn bar_beat_at_tick(&self, tick: i64) -> BarBeat { - let first = self.meter_at_tick(0); - if tick < 0 { - let tpb = first.ticks_per_bar(); - let abs = tick.unsigned_abs(); - let tpb_u = tpb.unsigned_abs(); - let bars_back_u = abs / tpb_u + u64::from(!abs.is_multiple_of(tpb_u)); - let bars_back = i64::try_from(bars_back_u).unwrap_or(i64::MAX); - // Offset of `tick` inside its bar, without negating `i64::MIN`. - let within = ((tpb_u - abs % tpb_u) % tpb_u) as i64; - let beat_t = first.ticks_per_beat(); - return BarBeat { bar: 1 - bars_back, beat: within / beat_t + 1, tick: within % beat_t }; - } - let mut bar = 1i64; - let mut seg_tick = 0i64; - for (i, m) in self.meters.iter().enumerate() { - let tpb = m.ticks_per_bar(); - if let Some(n) = self.meters.get(i + 1) - && tick >= n.tick - { - bar = bar.saturating_add(ceil_div(n.tick.saturating_sub(seg_tick), tpb)); - seg_tick = n.tick; - continue; - } - let rel = tick - seg_tick; - let bars = rel / tpb; - let within = rel % tpb; - let beat_t = m.ticks_per_beat(); - return BarBeat { bar: bar + bars, beat: within / beat_t + 1, tick: within % beat_t }; - } - BarBeat { bar, beat: 1, tick: 0 } - } - - /// Bar|beat|tick → tick. - pub fn tick_at_bar_beat(&self, bb: BarBeat) -> i64 { - let start = self.bar_start_tick(bb.bar); - let m = self.meter_at_tick(start); - start.saturating_add(bb.beat.saturating_sub(1).max(0).saturating_mul(m.ticks_per_beat())).saturating_add(bb.tick) - } - - pub fn bar_beat_at(&self, s: Samples, sr: SampleRate) -> BarBeat { - self.bar_beat_at_tick(self.samples_to_ticks(s, sr)) - } - - pub fn samples_at_bar_beat(&self, bb: BarBeat, sr: SampleRate) -> Samples { - self.tick_to_samples(self.tick_at_bar_beat(bb), sr) - } - - /// Scale every tempo by `factor` (Tempo Operations › Scale). - pub fn scale_tempos(&mut self, factor: f64) -> Result<(), TimeError> { - let mut out = self.tempos.clone(); - for e in &mut out { - e.bpm = valid_bpm(e.bpm * factor)?; - } - self.tempos = out; - self.reindex(); - Ok(()) - } -} - -/// Ceiling division for a non-negative `num` and positive `den`, without overflow. -fn ceil_div(num: i64, den: i64) -> i64 { - num / den + i64::from(num % den != 0) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn default_map_is_120_4_4() { - let m = TempoMap::default(); - let sr = SampleRate::HZ_48000; - // One bar of 4/4 at 120 bpm = 2 seconds. - assert_eq!(m.samples_at_bar_beat(BarBeat { bar: 2, beat: 1, tick: 0 }, sr), 96_000); - assert_eq!(m.bar_beat_at(96_000, sr), BarBeat { bar: 2, beat: 1, tick: 0 }); - assert_eq!(m.bar_beat_at(24_000, sr), BarBeat { bar: 1, beat: 2, tick: 0 }); - } - - #[test] - fn meter_near_max_tick_does_not_overflow() { - let mut m = TempoMap::default(); - m.set_meter(i64::MAX, 7, 8).unwrap(); - let bb = m.bar_beat_at_tick(i64::MAX); - assert!(bb.bar > 1); - assert!(m.bar_start_tick(bb.bar) > 0); - assert!(m.bar_start_tick(i64::MAX) > 0); - } - - #[test] - fn minimum_bar_saturates_instead_of_overflowing() { - let m = TempoMap::default(); - assert_eq!(m.bar_start_tick(i64::MIN), i64::MIN); - assert_eq!(m.bar_start_tick(0), -TICKS_PER_QUARTER * 4); - } - - #[test] - fn minimum_beat_is_clamped_without_overflow() { - let m = TempoMap::default(); - assert_eq!(m.tick_at_bar_beat(BarBeat { bar: 1, beat: i64::MIN, tick: 0 }), 0); - } - - #[test] - fn bar_beat_at_min_tick_does_not_overflow() { - let m = TempoMap::default(); - let bb = m.bar_beat_at_tick(i64::MIN); - assert!(bb.bar < 1); - assert!(bb.beat >= 1 && bb.tick >= 0); - assert_eq!(m.bar_beat_at_tick(-1).bar, 0); - } - - #[test] - fn tempo_change_is_integrated() { - let mut m = TempoMap::default(); - let sr = SampleRate::HZ_48000; - m.set_tempo(TICKS_PER_QUARTER * 4, 60.0).unwrap(); - // Bar 1 at 120 = 96000 samples; bar 2 at 60 = 192000 samples. - assert_eq!(m.tick_to_samples(TICKS_PER_QUARTER * 8, sr), 96_000 + 192_000); - assert_eq!(m.samples_to_ticks(96_000 + 192_000, sr), TICKS_PER_QUARTER * 8); - } - - #[test] - fn meter_change_counts_bars() { - let mut m = TempoMap::default(); - // 2 bars of 4/4 then 3/4. - m.set_meter(TICKS_PER_QUARTER * 8, 3, 4).unwrap(); - assert_eq!(m.bar_beat_at_tick(TICKS_PER_QUARTER * 8), BarBeat { bar: 3, beat: 1, tick: 0 }); - assert_eq!(m.bar_beat_at_tick(TICKS_PER_QUARTER * 11), BarBeat { bar: 4, beat: 1, tick: 0 }); - assert_eq!(m.bar_start_tick(4), TICKS_PER_QUARTER * 11); - let bb = BarBeat { bar: 4, beat: 2, tick: 10 }; - assert_eq!(m.bar_beat_at_tick(m.tick_at_bar_beat(bb)), bb); - } - - #[test] - fn editing_an_early_meter_keeps_later_bars_and_scales_linearly() { - // 200 000 meter changes, one per bar, built directly: a walk per meter would take - // minutes to edit here, and even to build through `set_meter`. - let mut m = TempoMap::new(120.0, 4, 4).unwrap(); - let mut tick = 0; - for bar in 1..200_000i64 { - let numerator = 3 + (bar % 2) as u32; - tick += m.meters.last().map_or(0, MeterEvent::ticks_per_bar); - m.meters.push(MeterEvent { tick, numerator, denominator: 4 }); - } - let sample = [1usize, 1_000, 199_998]; - let bars = |m: &TempoMap| sample.map(|i| m.bar_beat_at_tick(m.meters[i].tick).bar); - assert_eq!(bars(&m), [2, 1_001, 199_999]); - m.set_meter(0, 7, 8).unwrap(); - assert_eq!(bars(&m), [2, 1_001, 199_999], "later meters keep their bar numbers"); - assert_eq!(m.meters.len(), 200_000); - assert!(m.meters.windows(2).all(|w| w[0].tick < w[1].tick)); - assert!(m.remove_meter(m.meters[1].tick)); - assert_eq!([1usize, 999, 199_997].map(|i| m.bar_beat_at_tick(m.meters[i].tick).bar), [3, 1_001, 199_999]); - // Meters off their bar lines (counted as bars 2 and 4) land where they always did: on - // bar 2 of the new meter, then two bars of their own later. - let mut off = TempoMap::new(120.0, 4, 4).unwrap(); - off.meters.push(MeterEvent { tick: 100, numerator: 3, denominator: 4 }); - off.meters.push(MeterEvent { tick: 5_000, numerator: 5, denominator: 4 }); - off.set_meter(0, 2, 4).unwrap(); - let placed: Vec<(i64, u32)> = off.meters.iter().map(|e| (e.tick, e.numerator)).collect(); - assert_eq!(placed, vec![(0, 2), (2 * TICKS_PER_QUARTER, 3), (8 * TICKS_PER_QUARTER, 5)]); - } - - #[test] - fn eighth_note_meters() { - let m = TempoMap::new(120.0, 6, 8).unwrap(); - assert_eq!(m.bar_beat_at_tick(TICKS_PER_QUARTER * 3), BarBeat { bar: 2, beat: 1, tick: 0 }); - assert_eq!(m.bar_beat_at_tick(TICKS_PER_QUARTER / 2), BarBeat { bar: 1, beat: 2, tick: 0 }); - } - - #[test] - fn sanitize_keeps_what_the_setters_accept() { - let tempo = |tick, bpm| TempoEvent { tick, bpm }; - let meter = |tick, numerator, denominator| MeterEvent { tick, numerator, denominator }; - let mut m = TempoMap::from_parts( - vec![tempo(960, 4e9), tempo(3840, 90.0), tempo(-5, 100.0), tempo(1920, 60.0), tempo(1920, 70.0)], - vec![meter(0, 0, 4), meter(3840, 3, 4)], - ); - m.sanitize(); - assert_eq!(m.tempos(), [tempo(0, 60.0), tempo(1920, 60.0), tempo(3840, 90.0)]); - assert_eq!(m.meters(), [meter(0, 3, 4), meter(3840, 3, 4)]); - let mut empty = TempoMap::from_parts(Vec::new(), Vec::new()); - empty.sanitize(); - assert_eq!(empty, TempoMap::default()); - } - - #[test] - fn sanitize_drops_events_beyond_the_position_range() { - let mut m = TempoMap::from_parts( - vec![TempoEvent { tick: 0, bpm: 120.0 }, TempoEvent { tick: i64::MAX, bpm: 90.0 }], - vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }, MeterEvent { tick: i64::MAX, numerator: 3, denominator: 4 }], - ); - m.sanitize(); - assert_eq!(m, TempoMap::default()); - assert_eq!(m.bar_start_tick(2), TICKS_PER_QUARTER * 4); - } - - #[test] - fn rejects_bad_values() { - let mut m = TempoMap::default(); - assert!(m.set_tempo(0, f64::NAN).is_err()); - assert!(m.set_tempo(0, 0.0).is_err()); - assert!(m.set_meter(0, 0, 4).is_err()); - assert!(m.set_meter(0, 4, 3).is_err()); - assert!(!m.remove_tempo(0)); - } - - #[test] - fn negative_positions() { - let m = TempoMap::default(); - assert_eq!(m.bar_beat_at_tick(-TICKS_PER_QUARTER * 4), BarBeat { bar: 0, beat: 1, tick: 0 }); - assert_eq!(m.bar_beat_at_tick(-TICKS_PER_QUARTER), BarBeat { bar: 0, beat: 4, tick: 0 }); - } - - /// The segment walk the indexed conversions replaced, kept as the reference they must match. - fn linear_tick_to_samples(m: &TempoMap, tick: i64, sr: SampleRate) -> i64 { - let mut acc = 0.0; - let mut seg_tick = 0i64; - let mut bpm = m.tempos[0].bpm; - for e in m.tempos.iter().skip(1) { - if e.tick >= tick { - break; - } - acc += (e.tick - seg_tick) as f64 * TempoMap::samples_per_tick(bpm, sr); - seg_tick = e.tick; - bpm = e.bpm; - } - to_samples(acc + (tick - seg_tick) as f64 * TempoMap::samples_per_tick(bpm, sr)) - } - - #[test] - fn indexed_conversions_match_the_segment_walk() { - let sr = SampleRate::HZ_48000; - let mut m = TempoMap::default(); - for i in 1..200i64 { - m.set_tempo(i * 487, 40.0 + ((i * 37) % 300) as f64).unwrap(); - } - assert!(m.remove_tempo(487 * 50)); - for tick in (-1000..200 * 487 + 5000).step_by(113) { - let s = m.tick_to_samples(tick, sr); - assert_eq!(s, linear_tick_to_samples(&m, tick, sr), "tick {tick}"); - assert!((m.samples_to_ticks(s, sr) - tick).abs() <= 1, "tick {tick}"); - } - let json = serde_json::to_string(&m).unwrap(); - assert!(!json.contains("elapsed")); - let back: TempoMap = serde_json::from_str(&json).unwrap(); - assert_eq!(back, m); - assert_eq!(back.tick_to_samples(150 * 487 + 3, sr), m.tick_to_samples(150 * 487 + 3, sr)); - } - - #[test] - fn a_file_with_wild_ticks_is_indexed_without_overflow() { - let json = r#"{"tempos":[{"tick":0,"bpm":120.0},{"tick":-9223372036854775808,"bpm":100.0},{"tick":9223372036854775807,"bpm":90.0}],"meters":[{"tick":0,"numerator":4,"denominator":4}]}"#; - let mut m: TempoMap = serde_json::from_str(json).unwrap(); - m.sanitize(); - assert_eq!(m.tempos().first().map(|e| e.tick), Some(0)); - assert_eq!(m.elapsed.len(), m.tempos().len()); - } - - #[test] - fn conversions_against_a_large_tempo_map_stay_fast() { - // 200k tempo changes, then 200k conversions each way: quadratic if every conversion walks - // the earlier segments, well under a second when it binary-searches them. - let sr = SampleRate::HZ_48000; - let n = 200_000i64; - let tempos = (0..n).map(|i| TempoEvent { tick: i * 10, bpm: 60.0 + (i % 7) as f64 }).collect(); - let mut m = TempoMap::from_parts(tempos, vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }]); - m.sanitize(); - let start = std::time::Instant::now(); - let mut sum = 0i64; - for i in 0..n { - let s = m.tick_to_samples(i * 10 + 5, sr); - sum = sum.wrapping_add(s).wrapping_add(m.samples_to_ticks(s, sr)); - } - assert!(sum != 0); - assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed()); - } -} diff --git a/crates/time/src/timecode.rs b/crates/time/src/timecode.rs deleted file mode 100644 index 144dde00..00000000 --- a/crates/time/src/timecode.rs +++ /dev/null @@ -1,309 +0,0 @@ -//! SMPTE timecode and Feet+Frames. - -use crate::{SampleRate, Samples, TimeError}; - -/// Session timecode rates. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)] -pub enum FrameRate { - Fps23_976, - #[default] - Fps24, - Fps25, - Fps29_97, - Fps29_97Drop, - Fps30, - Fps47_952, - Fps48, - Fps50, - Fps59_94, - Fps59_94Drop, - Fps60, - Fps100, - Fps119_88, - Fps120, -} - -impl FrameRate { - pub const ALL: [FrameRate; 15] = [ - FrameRate::Fps23_976, - FrameRate::Fps24, - FrameRate::Fps25, - FrameRate::Fps29_97, - FrameRate::Fps29_97Drop, - FrameRate::Fps30, - FrameRate::Fps47_952, - FrameRate::Fps48, - FrameRate::Fps50, - FrameRate::Fps59_94, - FrameRate::Fps59_94Drop, - FrameRate::Fps60, - FrameRate::Fps100, - FrameRate::Fps119_88, - FrameRate::Fps120, - ]; - - /// Real frames per second as a rational (num, den). - pub fn rational(self) -> (i64, i64) { - match self { - FrameRate::Fps23_976 => (24_000, 1001), - FrameRate::Fps24 => (24, 1), - FrameRate::Fps25 => (25, 1), - FrameRate::Fps29_97 | FrameRate::Fps29_97Drop => (30_000, 1001), - FrameRate::Fps30 => (30, 1), - FrameRate::Fps47_952 => (48_000, 1001), - FrameRate::Fps48 => (48, 1), - FrameRate::Fps50 => (50, 1), - FrameRate::Fps59_94 | FrameRate::Fps59_94Drop => (60_000, 1001), - FrameRate::Fps60 => (60, 1), - FrameRate::Fps100 => (100, 1), - FrameRate::Fps119_88 => (120_000, 1001), - FrameRate::Fps120 => (120, 1), - } - } - - /// Frames per labelled second (the counting base). - pub fn nominal(self) -> i64 { - let (n, d) = self.rational(); - (n + d / 2) / d - } - - pub fn is_drop(self) -> bool { - matches!(self, FrameRate::Fps29_97Drop | FrameRate::Fps59_94Drop) - } - - pub fn label(self) -> &'static str { - match self { - FrameRate::Fps23_976 => "23.976", - FrameRate::Fps24 => "24", - FrameRate::Fps25 => "25", - FrameRate::Fps29_97 => "29.97", - FrameRate::Fps29_97Drop => "29.97 Drop", - FrameRate::Fps30 => "30", - FrameRate::Fps47_952 => "47.952", - FrameRate::Fps48 => "48", - FrameRate::Fps50 => "50", - FrameRate::Fps59_94 => "59.94", - FrameRate::Fps59_94Drop => "59.94 Drop", - FrameRate::Fps60 => "60", - FrameRate::Fps100 => "100", - FrameRate::Fps119_88 => "119.88", - FrameRate::Fps120 => "120", - } - } - - /// Whole frame index at a sample position (floored). - pub fn frames_at(self, s: Samples, sr: SampleRate) -> i64 { - let (n, d) = self.rational(); - let num = i128::from(s) * i128::from(n); - let den = i128::from(sr.hz()) * i128::from(d); - if den == 0 { - return 0; - } - i64::try_from(num.div_euclid(den)).unwrap_or(0) - } - - /// Sample position of the start of frame `f`. - pub fn samples_at_frame(self, f: i64, sr: SampleRate) -> Samples { - let (n, d) = self.rational(); - if n == 0 { - return 0; - } - // Round half away from zero so negative frames mirror positive ones. - let mag = (i128::from(f.unsigned_abs()) * i128::from(sr.hz()) * i128::from(d) + i128::from(n) / 2) / i128::from(n); - let v = if f < 0 { -mag } else { mag }; - i64::try_from(v).unwrap_or(if v < 0 { i64::MIN } else { i64::MAX }) - } - - /// Samples per frame (fractional). - pub fn samples_per_frame(self, sr: SampleRate) -> f64 { - let (n, d) = self.rational(); - sr.as_f64() * d as f64 / n as f64 - } -} - -/// A timecode label. -#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] -pub struct Timecode { - pub negative: bool, - pub hours: i64, - pub minutes: i64, - pub seconds: i64, - pub frames: i64, -} - -impl Timecode { - /// Label for an absolute frame count. - pub fn from_frames(frames: i64, rate: FrameRate) -> Timecode { - let negative = frames < 0; - // Drop-frame labels can exceed i64::MAX even when the frame count fits. Widen before - // taking the magnitude so i64::MIN is represented exactly too. - let mut f = i128::from(frames).abs(); - let base = i128::from(rate.nominal().max(1)); - if rate.is_drop() { - // Drop 2 (or 4) labels each minute except every tenth. - let drop = if base >= 60 { 4 } else { 2 }; - let per_10min = base * 600 - drop * 9; - let per_min = base * 60 - drop; - let tens = f / per_10min; - let rem = f % per_10min; - let extra = if rem > drop { drop * 9 * tens + drop * ((rem - drop) / per_min) } else { drop * 9 * tens }; - f += extra; - } - let frames_l = f % base; - let total_secs = f / base; - Timecode { - negative, - hours: i64::try_from(total_secs / 3600).unwrap_or(i64::MAX), - minutes: i64::try_from((total_secs / 60) % 60).unwrap_or(0), - seconds: i64::try_from(total_secs % 60).unwrap_or(0), - frames: i64::try_from(frames_l).unwrap_or(0), - } - } - - /// Absolute frame count of this label. - pub fn to_frames(&self, rate: FrameRate) -> i64 { - let base = rate.nominal().max(1); - let total_min = i128::from(self.hours) * 60 + i128::from(self.minutes); - let mut f = (total_min * 60 + i128::from(self.seconds)) * i128::from(base) + i128::from(self.frames); - if rate.is_drop() { - let drop = if base >= 60 { 4 } else { 2 }; - f -= drop * (total_min - total_min / 10); - } - let f = if self.negative { -f } else { f }; - i64::try_from(f).unwrap_or(if f < 0 { i64::MIN } else { i64::MAX }) - } - - pub fn from_samples(s: Samples, rate: FrameRate, sr: SampleRate) -> Timecode { - Timecode::from_frames(rate.frames_at(s, sr), rate) - } - - pub fn to_samples(&self, rate: FrameRate, sr: SampleRate) -> Samples { - rate.samples_at_frame(self.to_frames(rate), sr) - } - - pub fn format(&self, rate: FrameRate) -> String { - let sep = if rate.is_drop() { ';' } else { ':' }; - let sign = if self.negative { "-" } else { "" }; - format!("{sign}{:02}:{:02}:{:02}{sep}{:02}", self.hours, self.minutes, self.seconds, self.frames) - } - - /// Parse `HH:MM:SS:FF` (also `;` / `.` separators and fewer fields, right-aligned). - pub fn parse(text: &str) -> Result { - let t = text.trim(); - let (negative, t) = match t.strip_prefix('-') { - Some(r) => (true, r), - None => (false, t), - }; - let parts: Vec<&str> = t.split([':', ';', '.']).collect(); - if parts.is_empty() || parts.len() > 4 { - return Err(TimeError::Parse(text.to_string(), "timecode")); - } - let mut nums = [0i64; 4]; - let offset = 4 - parts.len(); - for (i, p) in parts.iter().enumerate() { - let v: i64 = p.trim().parse().map_err(|_| TimeError::Parse(text.to_string(), "timecode"))?; - if v < 0 { - return Err(TimeError::Parse(text.to_string(), "timecode")); - } - if let Some(slot) = nums.get_mut(offset + i) { - *slot = v; - } - } - Ok(Timecode { negative, hours: nums[0], minutes: nums[1], seconds: nums[2], frames: nums[3] }) - } -} - -/// Feet+Frames for 35 mm film (16 frames per foot), `start` frames in at sample 0. -pub fn feet_frames(s: Samples, rate: FrameRate, sr: SampleRate, start: i64) -> (i64, i64) { - let f = rate.frames_at(s, sr).saturating_add(start); - (f.div_euclid(16), f.rem_euclid(16)) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn non_drop_round_trip() { - let sr = SampleRate::HZ_48000; - let tc = Timecode::from_samples(48_000 * 3661, FrameRate::Fps25, sr); - assert_eq!(tc.format(FrameRate::Fps25), "01:01:01:00"); - assert_eq!(tc.to_samples(FrameRate::Fps25, sr), 48_000 * 3661); - } - - #[test] - fn negative_timecode_rounds_symmetrically() { - let sr = SampleRate::HZ_48000; - let tc = Timecode::parse("-00:00:01:00").unwrap(); - assert_eq!(tc.to_samples(FrameRate::Fps25, sr), -48_000); - for r in [FrameRate::Fps25, FrameRate::Fps29_97, FrameRate::Fps29_97Drop, FrameRate::Fps23_976] { - for f in [1i64, 7, 25, 1799, 107_892] { - assert_eq!(r.samples_at_frame(-f, sr), -r.samples_at_frame(f, sr), "{r:?} frame {f}"); - } - } - } - - #[test] - fn drop_frame_labels() { - let r = FrameRate::Fps29_97Drop; - // Frame 1800 is the first frame of minute 1 → labelled 00:01:00;02. - assert_eq!(Timecode::from_frames(1800, r).format(r), "00:01:00;02"); - assert_eq!(Timecode::from_frames(1799, r).format(r), "00:00:59;29"); - // Minute 10 keeps its labels. - assert_eq!(Timecode::from_frames(17_982, r).format(r), "00:10:00;00"); - for f in [0, 1, 1799, 1800, 1801, 17_981, 17_982, 107_892, 500_000] { - assert_eq!(Timecode::from_frames(f, r).to_frames(r), f, "frame {f}"); - } - } - - #[test] - fn huge_timecode_saturates_instead_of_overflowing() { - let sr = SampleRate::HZ_48000; - for r in [FrameRate::Fps30, FrameRate::Fps29_97Drop] { - let tc = Timecode::parse("9223372036854775807:00:00:00").unwrap(); - assert_eq!(tc.to_samples(r, sr), i64::MAX); - let tc = Timecode::parse("-9223372036854775807:00:00:00").unwrap(); - assert_eq!(tc.to_samples(r, sr), i64::MIN); - } - let tc = Timecode::parse("01:02:03:04").unwrap(); - assert_eq!(tc.to_samples(FrameRate::Fps30, sr), 178_710_400); - } - - #[test] - fn extreme_frame_counts_round_trip_at_every_rate() { - for rate in FrameRate::ALL { - for frames in [i64::MIN, i64::MIN + 1, -1, 0, 1, i64::MAX - 1, i64::MAX] { - let tc = Timecode::from_frames(frames, rate); - assert_eq!(tc.to_frames(rate), frames, "{rate:?}: {frames}"); - assert_eq!(tc.negative, frames < 0); - assert!((0..60).contains(&tc.minutes)); - assert!((0..60).contains(&tc.seconds)); - assert!((0..rate.nominal()).contains(&tc.frames)); - assert_eq!(Timecode::parse(&tc.format(rate)).unwrap(), tc); - } - } - } - - #[test] - fn extreme_drop_frame_labels_do_not_overflow() { - for rate in [FrameRate::Fps29_97Drop, FrameRate::Fps59_94Drop] { - assert_eq!(Timecode::from_frames(i64::MAX, rate).to_frames(rate), i64::MAX); - } - } - - #[test] - fn parse_variants() { - let tc = Timecode::parse("01:02:03:04").unwrap(); - assert_eq!((tc.hours, tc.minutes, tc.seconds, tc.frames), (1, 2, 3, 4)); - let tc = Timecode::parse("3:04").unwrap(); - assert_eq!((tc.seconds, tc.frames), (3, 4)); - assert!(Timecode::parse("a:b").is_err()); - assert!(Timecode::parse("1:2:3:4:5").is_err()); - } - - #[test] - fn feet_and_frames() { - let sr = SampleRate::HZ_48000; - assert_eq!(feet_frames(48_000, FrameRate::Fps24, sr, 0), (1, 8)); - } -} diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml index 51d9e6bd..971c7fad 100644 --- a/crates/ui-egui/Cargo.toml +++ b/crates/ui-egui/Cargo.toml @@ -8,6 +8,7 @@ rust-version = "1.95" repository.workspace = true [dependencies] +craft-mime.workspace = true craft-ui.workspace = true soundcraft-time.workspace = true craft-audio.workspace = true diff --git a/crates/ui-egui/locales/pt-BR/mod.rs b/crates/ui-egui/locales/pt-BR/mod.rs new file mode 100644 index 00000000..392fa071 --- /dev/null +++ b/crates/ui-egui/locales/pt-BR/mod.rs @@ -0,0 +1,2317 @@ +/// Returns the Brazilian Portuguese translation for a source-language UI string. +pub(super) fn translate(source: &str) -> Option<&'static str> { + Some(match source { + "+ Marker" => "+ Marcador", + "+ Selection" => "+ Seleção", + "+" => "+", + "/" => "/", + "0 dB" => "0 dB", + "CLAP" => "CLAP", + "VST3" => "VST3", + "bpm" => "BPM", + "·" => "·", + "−" => "−", + "−∞" => "−∞", + "⬆" => "⬆", + "" => "", + "About SoundCraft" => "Sobre o SoundCraft", + "Add" => "Adicionar", + "Add a row below" => "Adicionar uma linha abaixo", + "Adds ±1 LSB triangular dither when writing 16- or 24-bit files. Leave it off when the master chain already dithers." => { + "Adiciona dither triangular de ±1 LSB ao gravar arquivos de 16 ou 24 bits. Deixe desativado se a cadeia master já aplicar dither." + } + "All" => "Tudo", + "All audio clips checked" => "Todos os clipes de áudio verificados", + "All audio clips have loaded media within source bounds." => "Todos os clipes de áudio têm mídia carregada dentro dos limites da origem.", + "An open-source digital audio workstation from the ArtCraft team." => { + "Uma estação de trabalho de áudio digital de código aberto da equipe ArtCraft." + } + "Analyses the edit selection on the selected tracks." => "Analisa a seleção de edição nas faixas selecionadas.", + "Analyze" => "Analisar", + "Appearance" => "Aparência", + "Applies across the edit selection (constant: at the insertion point; scale: factor = end / start; stretch: factor = start / end)." => { + "Aplica-se à seleção de edição (constante: no ponto de inserção; escala: fator = fim / início; alongamento: fator = início / fim)." + } + "Applies to the selected MIDI clips (or those under the selection)." => { + "Aplica-se aos clipes MIDI selecionados (ou aos que estão sob a seleção)." + } + "Apply" => "Aplicar", + "Apply to selected tracks (Shift: selected clips)" => "Aplicar às faixas selecionadas (Shift: clipes selecionados)", + "Audio system" => "Sistema de áudio", + "Audio Track" => "Faixa de áudio", + "Audio Units" => "Unidades de áudio", + "Auto Rename…" => "Renomear automaticamente…", + "Auto-update configuration" => "Atualizar configuração automaticamente", + "bar(s)" => "compasso(s)", + "Bars per system" => "Compassos por sistema", + "Beat Analysis" => "Análise de batidas", + "Beat Detective" => "Detecção de batidas", + "BED" => "CAMADA BASE", + "Big Counter" => "Contador grande", + "Bit Depth" => "Profundidade de bits", + "Bounces the edit selection, or the whole session when nothing is selected." => { + "Renderiza a seleção de edição ou a sessão inteira quando nada está selecionado." + } + "Browse…" => "Procurar…", + "Buffer size" => "Tamanho do buffer", + "Built-in" => "Integrados", + "Busses" => "Buses", + "Bypass" => "Ignorar", + "Cancel" => "Cancelar", + "Check for Updates" => "Verificar atualizações", + "Check for Updates…" => "Verificar atualizações…", + "Company" => "Empresa", + "Commits" => "Commits", + "Lines +/−" => "Linhas +/−", + "% of all commits" => "% de todos os commits", + "Checks loaded media only, not files on disk, signal levels, plugins or routing." => { + "Verifica apenas a mídia carregada, não os arquivos no disco, níveis de sinal, plugins ou roteamento." + } + "Clear" => "Limpar", + "Clear Recent" => "Limpar recentes", + "Clear…" => "Limpar…", + "Click" => "Clique", + "Click a take (or the selection) to promote it to the main playlist" => { + "Clique em uma tomada (ou na seleção) para promovê-la à playlist principal" + } + "Click keys to step-enter notes into the selected MIDI clip at the insertion point." => { + "Clique nas teclas para inserir notas passo a passo no clipe MIDI selecionado, no ponto de inserção." + } + "Click: open instrument · right-click: change" => "Clique: abrir instrumento · botão direito: alterar", + "Clip effects gain (dB)" => "Ganho dos efeitos do clipe (dB)", + "Clip end pad ms" => "Margem no fim do clipe (ms)", + "Clip start pad ms" => "Margem no início do clipe (ms)", + "Close Plugin Editor" => "Fechar editor do plugin", + "Columns beside the track headers: inserts, sends, I/O…" => "Colunas ao lado dos cabeçalhos das faixas: inserts, envios, E/S…", + "Composer" => "Compositor", + "Create" => "Criar", + "Curve" => "Curva", + "Delay (ticks)" => "Atraso (ticks)", + "Delay compensation" => "Compensação de atraso", + "Delete" => "Excluir", + "Delete Group" => "Excluir grupo", + "Delete Unused..." => "Excluir não usados...", + "DESTINATION" => "DESTINO", + "Discard" => "Descartar", + "Dither (TPDF)" => "Dither (TPDF)", + "Don't Save" => "Não salvar", + "Double-click to import audio/MIDI at the insertion point or open a session." => { + "Clique duas vezes para importar áudio/MIDI no ponto de inserção ou abrir uma sessão." + } + "Drag to change the tempo (Shift: fine steps), or click to type it" => { + "Arraste para alterar o andamento (Shift: ajustes finos) ou clique para digitá-lo" + } + "Drop an audio file here" => "Solte um arquivo de áudio aqui", + "Drop an audio file on this window" => "Solte um arquivo de áudio nesta janela", + "Dual-licensed MIT OR Apache-2.0. Made with Rust and egui." => "Licença dupla MIT ou Apache-2.0. Feito com Rust e egui.", + "Duplicate..." => "Duplicar...", + "Duration" => "Duração", + "Duration %" => "Duração %", + "Edit group" => "Editar grupo", + "Edit Parameters…" => "Editar parâmetros…", + "Elastic Audio" => "Áudio elástico", + "Enabled parameters" => "Parâmetros habilitados", + "End" => "Fim", + "Extract" => "Extrair", + "File" => "Arquivo", + "Format" => "Formato", + "Grab bag" => "Diversos", + "Grid" => "Grade", + "Identify Beat: selection is" => "Identificar batida: a seleção tem", + "in" => "em", + "Includes alternate takes and muted clips. Refresh after editing." => { + "Inclui tomadas alternativas e clipes silenciados. Atualize após editar." + } + "Input" => "Entrada", + "Input device" => "Dispositivo de entrada", + "Instrument" => "Instrumento", + "Interface scale" => "Escala da interface", + "Language" => "Idioma", + "Never" => "Nunca", + "Only During Playback" => "Apenas durante a reprodução", + "Always" => "Sempre", + "Reduce visual effects" => "Reduzir efeitos visuais", + "Legato" => "Legato", + "Length ratio" => "Proporção de duração", + "Level" => "Nível", + "Load and edit sounds in the plugin's own editor." => "Carregue e edite sons no editor próprio do plugin.", + "Load Sample…" => "Carregar amostra…", + "Loop Length" => "Duração do loop", + "Loop Until End of Session or Next Clip" => "Repetir até o fim da sessão ou o próximo clipe", + "Main output" => "Saída principal", + "MIDI Operations" => "Operações MIDI", + "MIDI Real-Time Properties" => "Propriedades MIDI em tempo real", + "Min strip duration ms" => "Duração mínima do trecho (ms)", + "Minimal" => "Mínimo", + "Mix group" => "Grupo de mixagem", + "Mix in Separate Window" => "Mixagem em janela separada", + "Modify Group…" => "Modificar grupo…", + "Move to Folder" => "Mover para pasta", + "Name" => "Nome", + "Name:" => "Nome:", + "new" => "novo", + "New Bus" => "Novo bus", + "new bus..." => "novo bus...", + "New Configuration…" => "Nova configuração…", + "New Group…" => "Novo grupo…", + "New..." => "Novo...", + "No background tasks are running." => "Nenhuma tarefa em segundo plano está em execução.", + "No contributor data was built into this copy." => "Esta versão não inclui dados de colaboradores.", + "no insert" => "sem insert", + "No model credits were built into this copy." => "Esta versão não inclui créditos dos modelos.", + "No object tracks. Use the Object view in the Mix window to route tracks as objects." => { + "Não há faixas de objetos. Use a visualização Objeto na janela Mix para rotear faixas como objetos." + } + "No parameters." => "Nenhum parâmetro.", + "No Recent Sessions" => "Nenhuma sessão recente", + "Non-destructive, applied at playback to the selected MIDI tracks." => { + "Não destrutivo; aplicado durante a reprodução às faixas MIDI selecionadas." + } + "Normalize to -0.1 dBFS" => "Normalizar para -0,1 dBFS", + "Notation view of the MIDI clip; edit notes in the MIDI Editor or Event List." => { + "Visualização em partitura do clipe MIDI; edite as notas no Editor MIDI ou na Lista de eventos." + } + "Number of Loops" => "Número de repetições", + "Open Plugin Editor" => "Abrir editor do plugin", + "Open Recent" => "Abrir recentes", + "Operation" => "Operação", + "Original Time Stamp" => "Registro de data e hora original", + "Output" => "Saída", + "Output device" => "Dispositivo de saída", + "Output window" => "Janela de saída", + "OK" => "OK", + "Outputs" => "Saídas", + "Pan" => "Panorama", + "Parent folder" => "Pasta superior", + "Paste" => "Colar", + "Peak dB" => "Pico (dB)", + "Place on New Track" => "Colocar em nova faixa", + "Place on Selected Track" => "Colocar na faixa selecionada", + "Play (Space)" => "Reproduzir (Espaço)", + "Playlists" => "Playlists", + "Post-roll" => "Pós-roll", + "Pre-fader" => "Pré-fader", + "Pre-roll" => "Pré-roll", + "Presets v" => "Predefinições v", + "Processes selected clips offline" => "Processa os clipes selecionados offline", + "Quantize" => "Quantizar", + "Quantize to the grid" => "Quantizar para a grade", + "Quit" => "Sair", + "Recall" => "Recuperar", + "Reconnect audio device" => "Reconectar dispositivo de áudio", + "Record (F12 or Cmd+Space)" => "Gravar (F12 ou Cmd+Espaço)", + "Recover" => "Recuperar", + "Recover Unsaved Work" => "Recuperar trabalho não salvo", + "Reduce motion" => "Reduzir animações", + "Refresh devices" => "Atualizar dispositivos", + "Refresh Report" => "Atualizar relatório", + "Remove from Folder" => "Remover da pasta", + "Remove send" => "Remover envio", + "Remove this row" => "Remover esta linha", + "Rename bus…" => "Renomear bus…", + "Rename..." => "Renomear...", + "Rename…" => "Renomear…", + "Render" => "Renderizar", + "Renderer" => "Renderizador", + "Replace" => "Substituir", + "Renders and AudioSuite processes run to completion before returning." => { + "Renderizações e processos do AudioSuite são concluídos antes de retornar." + } + "Reopen the audio devices with these settings" => "Reabrir os dispositivos de áudio com estas configurações", + "Reset" => "Redefinir", + "Reverse the order" => "Inverter a ordem", + "Revert" => "Reverter", + "Route as an immersive object or to the bed" => "Rotear como objeto imersivo ou para a camada base", + "Sample rate" => "Taxa de amostragem", + "Sample Rate" => "Taxa de amostragem", + "Save" => "Salvar", + "Scan CLAP" => "Procurar CLAP", + "Scan VST3" => "Procurar VST3", + "Score Editor" => "Editor de partitura", + "Scroll Into View" => "Rolar até a faixa", + "Search" => "Pesquisar", + "Search commands…" => "Pesquisar comandos…", + "Select a MIDI clip or MIDI track." => "Selecione um clipe ou uma faixa MIDI.", + "Select a MIDI clip." => "Selecione um clipe MIDI.", + "Select an audio clip." => "Selecione um clipe de áudio.", + "Select an instrument track" => "Selecione uma faixa de instrumento", + "Select Tracks in Group" => "Selecionar faixas do grupo", + "Semitones" => "Semitons", + "Sensitivity" => "Sensibilidade", + "Separate" => "Separar", + "Separate clips at detected beats" => "Separar clipes nas batidas detectadas", + "Session Audio Health" => "Integridade do áudio da sessão", + "Session comments" => "Comentários da sessão", + "Session Info" => "Informações da sessão", + "Session rate" => "Taxa da sessão", + "Set Tempo" => "Definir andamento", + "Set the session tempo from the beats" => "Definir o andamento da sessão com base nas batidas", + "Show" => "Mostrar", + "Show Edit and Mix at once, e.g. one per monitor" => "Mostrar Edit e Mix ao mesmo tempo, por exemplo, uma em cada monitor", + "Show grid lines" => "Mostrar linhas da grade", + "Show in the Mix window" => "Mostrar na janela Mix", + "Show track names" => "Mostrar nomes das faixas", + "Smart Tool (F6+F7 / F7+F8)" => "Ferramenta inteligente (F6+F7 / F7+F8)", + "Sort" => "Ordenar", + "SoundCraft" => "SoundCraft", + "Spot to where it was recorded" => "Posicionar no ponto em que foi gravado", + "Start" => "Início", + "Start from the demo session" => "Começar pela sessão de demonstração", + "Stop (Space)" => "Parar (Espaço)", + "Stop recording first" => "Pare a gravação primeiro", + "Strength %" => "Intensidade %", + "Suffix" => "Sufixo", + "Swing %" => "Swing %", + "Table" => "Tabela", + "Tempo Operations" => "Operações de andamento", + "Text for naming the clips that editing makes from the selected clips:" => { + "Texto para nomear os clipes criados ao editar os clipes selecionados:" + } + "The mix runs in 512-sample blocks; the buffer size sets the device's own latency." => { + "A mixagem é processada em blocos de 512 amostras; o tamanho do buffer define a latência do dispositivo." + } + "Theme" => "Tema", + "Thin All" => "Simplificar tudo", + "This plugin has no editor of its own, or it is not loaded" => "Este plugin não tem editor próprio ou não está carregado", + "Threshold dB" => "Limiar (dB)", + "Time Operations" => "Operações de tempo", + "Time Scale" => "Escala de tempo", + "Timecode burn-in" => "Sobreposição de timecode", + "Timecode Rate" => "Taxa de timecode", + "Title" => "Título", + "Track Color" => "Cor da faixa", + "Track Height" => "Altura da faixa", + "Track options" => "Opções da faixa", + "Track tint in the Edit window" => "Tonalidade das faixas na janela Edit", + "Tracks" => "Faixas", + "Transport" => "Transporte", + "Transpose" => "Transpor", + "Unknown label" => "Rótulo desconhecido", + "Update check is not supported in the web browser." => "A verificação de atualizações não é compatível com o navegador.", + "Use" => "Usar", + "User presets need the desktop app." => "As predefinições do usuário exigem o aplicativo para desktop.", + "Uses the edit selection." => "Usa a seleção de edição.", + "Vel +10" => "Velocidade +10", + "Vel −10" => "Velocidade −10", + "Velocity +" => "Velocidade +", + "Video" => "Vídeo", + "Video Universe" => "Universo de vídeo", + "Voice: dyn plays the track, off makes it inactive" => "Voz: dyn reproduz a faixa; off a desativa", + "Workspace" => "Área de trabalho", + "Write automation for the selected tracks:" => "Gravar automação nas faixas selecionadas:", + "Write to Current" => "Gravar na atual", + "Write to Notes" => "Gravar nas notas", + "front" => "frente", + "Sub" => "Sub", + "Nudge" => "Deslocamento", + "Count Off" => "Contagem inicial", + "Meter" => "Compasso", + "Tempo" => "Andamento", + "MIDI in: all" => "Entrada MIDI: todas", + "MIDI EDITOR" => "EDITOR MIDI", + "Velocity" => "Velocidade", + "movie missing from session" => "vídeo ausente da sessão", + "Video Track Offline" => "Faixa de vídeo indisponível", + "media offline" => "mídia indisponível", + "No Video track — File › Import › Video…" => "Nenhuma faixa de vídeo — Arquivo › Importar › Vídeo…", + "" => "", + " (alternate playlist)" => " (playlist alternativa)", + "Active audio end time is unknown (invalid session sample rate)" => { + "O fim do áudio ativo é desconhecido (taxa de amostragem da sessão inválida)" + } + "No engine" => "Sem mecanismo de áudio", + "default buffer" => "buffer padrão", + "Bus name: {name}" => "Nome do bus: {name}", + "Model" => "Modelo", + "Version" => "Versão", + "🔍 Find clips" => "🔍 Localizar clipes", + "Not available yet." => "Ainda não disponível.", + "no instrument" => "sem instrumento", + "Search inputs…" => "Buscar entradas…", + "Search outputs…" => "Buscar saídas…", + "Zoom preset (click to recall, Cmd-click to store)" => "Predefinição de zoom (clique para recuperar, Cmd-clique para gravar)", + "Commands Keyboard Focus (single-key editing)" => "Foco do teclado nos comandos (edição com uma tecla)", + "16-bit" => "16 bits", + "24-bit" => "24 bits", + "32-bit float" => "32 bits (ponto flutuante)", + "clip" => "clipe", + "file" => "arquivo", + _ => return menu_translate(source), + }) +} + +/// Translates the formatted messages, whose templates are chosen at run time. +fn menu_translate(source: &str) -> Option<&'static str> { + Some(match source { + "1" => "1", + "1st Order Ambisonics" => "Ambissonia de 1ª ordem", + "2" => "2", + "2nd Order Ambisonics" => "Ambissonia de 2ª ordem", + "3" => "3", + "3rd Order Ambisonics" => "Ambissonia de 3ª ordem", + "4" => "4", + "4th Order Ambisonics" => "Ambissonia de 4ª ordem", + "5" => "5", + "5.0" => "5.0", + "5.0.2" => "5.0.2", + "5.0.4" => "5.0.4", + "5.1" => "5.1", + "5.1.2" => "5.1.2", + "5.1.4" => "5.1.4", + "5th Order Ambisonics" => "Ambissonia de 5ª ordem", + "6.0" => "6.0", + "6.1" => "6.1", + "6th Order Ambisonics" => "Ambissonia de 6ª ordem", + "7.0" => "7.0", + "7.0 SDDS" => "7.0 SDDS", + "7.0.2" => "7.0.2", + "7.0.4" => "7.0.4", + "7.0.6" => "7.0.6", + "7.1" => "7.1", + "7.1 SDDS" => "7.1 SDDS", + "7.1.2" => "7.1.2", + "7.1.4" => "7.1.4", + "7.1.6" => "7.1.6", + "7th Order Ambisonics" => "Ambissonia de 7ª ordem", + "9.0.4" => "9.0.4", + "9.0.6" => "9.0.6", + "9.1.4" => "9.1.4", + "9.1.6" => "9.1.6", + "AFL (After Fader Listen)" => "AFL (escuta pós-fader)", + "ARA Note Overlay" => "Sobreposição de notas ARA", + "ARA Plugins" => "Plugins ARA", + "Ableton Link" => "Ableton Link", + "Activate HEAT" => "Ativar HEAT", + "Add Key Change..." => "Adicionar mudança de tonalidade...", + "After Playback" => "Após a reprodução", + "All Automation" => "Toda a automação", + "All MIDI Notes Off" => "Desligar todas as notas MIDI", + "All Marker Rulers" => "Todas as réguas de marcadores", + "Arrange" => "Organizar", + "At Selection" => "Na seleção", + "At Transients" => "Nos transientes", + "Audio as MIDI" => "Áudio como MIDI", + "Audio..." => "Áudio...", + "AudioSuite" => "AudioSuite", + "Auto-Spot Clips" => "Posicionar clipes automaticamente", + "Auto-Update Active Configuration" => "Atualizar configuração ativa automaticamente", + "Automation" => "Automação", + "Automation Follows Edit" => "Automação acompanha a edição", + "BF-76" => "BF-76", + "Bars|Beats" => "Compassos|Tempos", + "Bounce Mix..." => "Renderizar mixagem...", + "Bounce..." => "Renderizar...", + "Bring to Front" => "Trazer para frente", + "Bypass Inserts" => "Ignorar inserts", + "Calibration Mode" => "Modo de calibração", + "Can't Redo" => "Não é possível refazer", + "Can't Undo" => "Não é possível desfazer", + "Capture..." => "Capturar...", + "Cascade" => "Em cascata", + "Center Playhead" => "Centralizar cursor de reprodução", + "Change Duration..." => "Alterar duração...", + "Change Edit to Match Timeline" => "Alterar edição para corresponder à linha do tempo", + "Change Meter..." => "Alterar compasso...", + "Change Timeline to Match Edit" => "Alterar linha do tempo para corresponder à edição", + "Change Track Width" => "Alterar largura da faixa", + "Change Velocity..." => "Alterar velocidade...", + "Channel Name" => "Nome do canal", + "Channel Strip" => "Canal de mixagem", + "Chord Symbols" => "Símbolos de acordes", + "Clear All Clip Indicators" => "Limpar todos os indicadores de clipe", + "Clear Special" => "Limpar especial", + "Clear Trim Automation" => "Limpar automação de trim", + "Click/Countoff..." => "Metrônomo/contagem inicial...", + "Clip" => "Clipe", + "Clip Effects" => "Efeitos do clipe", + "Clip Effects Status" => "Status dos efeitos do clipe", + "Clip Gain" => "Ganho do clipe", + "Clip Gain Info" => "Informações do ganho do clipe", + "Clip Gain Line" => "Linha de ganho do clipe", + "Clip Groups..." => "Grupos de clipes...", + "Clip List" => "Lista de clipes", + "Close All Workspaces" => "Fechar todas as áreas de trabalho", + "Close Session" => "Fechar sessão", + "Close Window" => "Fechar janela", + "Coalesce Clip Gain to Volume Automation" => "Converter ganho do clipe em automação de volume", + "Coalesce Pan Guide Automation" => "Consolidar automação-guia de panorama", + "Coalesce Trim Automation" => "Consolidar automação de trim", + "Coalesce VCA Controller Automation" => "Consolidar automação do controlador VCA", + "Coalesce Volume Automation to Clip Gain" => "Converter automação de volume em ganho do clipe", + "Collaboration" => "Colaboração", + "Color Palette" => "Paleta de cores", + "Comments" => "Comentários", + "comments" => "comentários", + "Commit..." => "Consolidar...", + "Composite Playlist" => "Playlist composta", + "Configurations" => "Configurações", + "Conform to Tempo" => "Ajustar ao andamento", + "Consolidate" => "Consolidar", + "Constant..." => "Constante...", + "Continuous" => "Contínuo", + "Convert Aux to Routing Folder" => "Converter auxiliar em pasta de roteamento", + "Convert Clip Gain to Volume Automation" => "Converter ganho do clipe em automação de volume", + "Convert Volume Automation to Clip Gain" => "Converter automação de volume em ganho do clipe", + "Copy" => "Copiar", + "Copy Selection to..." => "Copiar seleção para...", + "Copy Special" => "Copiar especial", + "Copy to Send..." => "Copiar para envio...", + "Copy/Move Indicators" => "Indicadores de cópia/movimentação", + "Counters" => "Contadores", + "Create Click Track" => "Criar faixa de metrônomo", + "Create..." => "Criar...", + "Current Feet+Frames Position..." => "Posição atual em pés e quadros...", + "Current Time" => "Tempo atual", + "Current Timecode Position..." => "Posição atual do timecode...", + "Cut" => "Recortar", + "Cut Special" => "Recortar especial", + "Cut Time..." => "Recortar tempo...", + "D-Verb" => "D-Verb", + "DC Offset Removal" => "Remoção de deslocamento DC", + "Dashboard..." => "Painel...", + "Default" => "Padrão", + "Delay" => "Atraso", + "Delay Compensation" => "Compensação de atraso", + "Designate as Target Playlist" => "Definir como playlist de destino", + "Destructive Record" => "Gravação destrutiva", + "DestructivePunch" => "Punch destrutivo", + "Disk Allocation..." => "Alocação de disco...", + "Disk Usage" => "Uso do disco", + "Display on All Channels" => "Exibir em todos os canais", + "Double Edit" => "Edição dupla", + "Dropped Video Frame Indicator" => "Indicador de quadros de vídeo perdidos", + "Duplicate" => "Duplicar", + "Duplicate Dolby Atmos Plugin Automation to Pan Automation" => "Duplicar automação do plugin Dolby Atmos para automação de panorama", + "Duplicate Pan Automation to Dolby Atmos Plugin Automation" => "Duplicar automação de panorama para automação do plugin Dolby Atmos", + "Duplicate and Extend Edit" => "Duplicar e estender edição", + "Duplicate of Main Playlist" => "Duplicata da playlist principal", + "Dyn3 Compressor/Limiter" => "Dyn3 Compressor/Limiter", + "Dyn3 De-Esser" => "Dyn3 De-Esser", + "Dyn3 Expander/Gate" => "Dyn3 Expander/Gate", + "Dynamic Transport" => "Transporte dinâmico", + "Dynamics" => "Dinâmica", + "EQ" => "Equalização", + "EQ Curve" => "Curva de equalização", + "EQ3 1-Band" => "EQ3 de 1 banda", + "EQ3 7-Band" => "EQ3 de 7 bandas", + "Edit" => "Edição", + "Edit Lock/Unlock" => "Bloquear/desbloquear edição", + "Edit Window Scrolling" => "Rolagem da janela de edição", + "Edit Window Views" => "Visualizações da janela de edição", + "Edit/Tool Mode Keyboard Lock" => "Bloqueio do teclado no modo edição/ferramenta", + "Elastic Properties" => "Propriedades elásticas", + "Eleven Lite" => "Eleven Lite", + "End to Fill Selection" => "Do fim até preencher a seleção", + "End to Insertion" => "Do fim até o ponto de inserção", + "Event" => "Evento", + "Expanded" => "Expandido", + "Expanded Sends" => "Envios expandidos", + "Export" => "Exportar", + "Extend Edit Down" => "Estender edição para baixo", + "Extend Edit Down to Members" => "Estender edição para baixo até os membros", + "Extend Edit Selection To Marker Lane Above" => "Estender seleção de edição até a faixa de marcadores acima", + "Extend Edit Selection To Marker Lane Below" => "Estender seleção de edição até a faixa de marcadores abaixo", + "Extend Edit Up" => "Estender edição para cima", + "Extend Edit Up to Members" => "Estender edição para cima até os membros", + "External Timecode Offset..." => "Deslocamento externo de timecode...", + "Extract Chords from Selection" => "Extrair acordes da seleção", + "Extract MIDI to New Track" => "Extrair MIDI para uma nova faixa", + "Fade to End" => "Fade até o fim", + "Fade to Start" => "Fade até o início", + "Fades" => "Fades", + "Feet+Frames" => "Pés e quadros", + "Find Talent" => "Localizar talento", + "Flatten Performance..." => "Consolidar execução...", + "Folder Lines" => "Linhas das pastas", + "Freeze" => "Congelar", + "Gain" => "Ganho", + "Get Info..." => "Obter informações...", + "Glide Pan Only" => "Deslizar apenas o panorama", + "Glide to All Enabled" => "Deslizar para todos os habilitados", + "Glide to Current" => "Deslizar para o atual", + "Group" => "Grupo", + "Group..." => "Agrupar...", + "HEAT" => "HEAT", + "Halve Edit" => "Reduzir edição pela metade", + "Hardware..." => "Hardware...", + "Harmonic" => "Harmônico", + "Heal Separation" => "Reparar separação", + "Hide All Floating Windows" => "Ocultar todas as janelas flutuantes", + "I/O" => "E/S", + "I/O..." => "E/S...", + "Identify Beat..." => "Identificar batida...", + "Identify Sync Point" => "Identificar ponto de sincronização", + "Import" => "Importar", + "Input Quantize..." => "Quantização de entrada...", + "Insert Silence" => "Inserir silêncio", + "Insert Time..." => "Inserir tempo...", + "Insertion Follows Playback" => "Ponto de inserção acompanha a reprodução", + "Inserts A-E" => "Inserts A-E", + "Inserts F-J" => "Inserts F-J", + "Instruments" => "Instrumentos", + "Invert" => "Inverter", + "Key Signature" => "Armadura de clave", + "Key Signature Staff" => "Pauta da armadura de clave", + "Keyboard Shortcuts..." => "Atalhos de teclado...", + "LCR" => "LCR", + "LCRS" => "LCRS", + "Latch" => "Latch", + "Layered Editing" => "Edição em camadas", + "Learn" => "Aprender", + "Linear..." => "Linear...", + "Link Timeline and Edit Selection" => "Vincular linha do tempo e seleção de edição", + "Link Track and Edit Selection" => "Vincular faixa e seleção de edição", + "Lo-Fi" => "Lo-Fi", + "Loop Playback" => "Reprodução em loop", + "Loop Record" => "Gravação em loop", + "Loop..." => "Loop...", + "Low Latency Monitoring" => "Monitoramento de baixa latência", + "Lower Dock" => "Painel inferior", + "MIDI" => "MIDI", + "Audio" => "Áudio", + "SoundCraft Session" => "Sessão do SoundCraft", + "Loading SoundCraft…" => "Carregando o SoundCraft…", + "SoundCraft failed to start: {}" => "Falha ao iniciar o SoundCraft: {}", + "A browser with WebGPU or WebGL2 is required." => "É necessário um navegador com WebGPU ou WebGL2.", + "Download failed: {}" => "Falha no download: {}", + "MIDI Beat Clock..." => "Relógio de batida MIDI...", + "MIDI Controls" => "Controles MIDI", + "MIDI Editor" => "Editor MIDI", + "MIDI Editors" => "Editores MIDI", + "MIDI Event List" => "Lista de eventos MIDI", + "MIDI Input Devices..." => "Dispositivos de entrada MIDI...", + "MIDI Input Display" => "Exibição da entrada MIDI", + "MIDI Input Filter..." => "Filtro de entrada MIDI...", + "MIDI Keyboard" => "Teclado MIDI", + "MIDI Live Mode" => "Modo MIDI ao vivo", + "MIDI Operations Window" => "Janela de operações MIDI", + "MIDI Studio..." => "Estúdio MIDI...", + "MIDI Thru" => "MIDI Thru", + "MIDI Track Offsets" => "Deslocamentos de faixa MIDI", + "MIDI..." => "MIDI...", + "Machine Track Arming" => "Armar faixa da máquina", + "Machine Track Arming Profiles..." => "Perfis de armação de faixa da máquina...", + "Main Counter" => "Contador principal", + "Make Inactive" => "Desativar", + "Marker Controls" => "Controles de marcadores", + "Marker Displays" => "Exibições de marcadores", + "Marker Target Follows First Selected Track" => "Alvo do marcador acompanha a primeira faixa selecionada", + "Markers" => "Marcadores", + "Markers 2" => "Marcadores 2", + "Markers 3" => "Marcadores 3", + "Markers 4" => "Marcadores 4", + "Markers 5" => "Marcadores 5", + "Markers Follow Edit" => "Marcadores acompanham a edição", + "Maxim" => "Maxim", + "Melodyne" => "Melodyne", + "Memory Locations" => "Localizações de memória", + "Merge MIDI" => "Mesclar MIDI", + "Merge Markers" => "Mesclar marcadores", + "Messages" => "Mensagens", + "Metadata Inspector" => "Inspetor de metadados", + "Meters and Faders" => "Medidores e faders", + "Mic Preamps" => "Pré-amplificadores de microfone", + "Min:Secs" => "Minutos:segundos", + "Mirrored MIDI Editing" => "Edição MIDI espelhada", + "Mix" => "Mixagem", + "Mix Window Views" => "Visualizações da janela de mixagem", + "Mod Delay III" => "Mod Delay III", + "Modulation" => "Modulação", + "Momentary" => "Momentâneo", + "Mono" => "Mono", + "Move Edit Left" => "Mover edição para a esquerda", + "Move Edit Right" => "Mover edição para a direita", + "Move Edit Selection To Marker Lane Above" => "Mover seleção de edição para a faixa de marcadores acima", + "Move Edit Selection To Marker Lane Below" => "Mover seleção de edição para a faixa de marcadores abaixo", + "Move Selection to..." => "Mover seleção para...", + "Move Song Start..." => "Mover início da música...", + "Move to New Folder..." => "Mover para uma nova pasta...", + "Mute Sends" => "Silenciar envios", + "Narrow Mix" => "Mixagem compacta", + "New Configuration..." => "Nova configuração...", + "New Playlist" => "Nova playlist", + "New Workspace" => "Nova área de trabalho", + "Next" => "Próximo", + "No Scrolling" => "Sem rolagem", + "No Time" => "Sem tempo", + "None" => "Nenhum", + "Normalize" => "Normalizar", + "Object" => "Objeto", + "On Grid" => "Na grade", + "Open" => "Abrir", + "Options" => "Opções", + "Other" => "Outro", + "Other Displays" => "Outras exibições", + "Outlines" => "Contornos", + "Output Meters" => "Medidores de saída", + "Overlap Shadows" => "Sombras de sobreposição", + "Overlapped Crossfades" => "Fades cruzados sobrepostos", + "Overwrite Indicator" => "Indicador de sobrescrita", + "PFL (Pre Fader Listen)" => "PFL (escuta pré-fader)", + "Page" => "Página", + "Pan Automation" => "Automação de panorama", + "Parabolic..." => "Parabólico...", + "Paste Special" => "Colar especial", + "Peak" => "Pico", + "Peripherals..." => "Periféricos...", + "Pinned Tracks" => "Faixas fixadas", + "Pitch II" => "Pitch II", + "Pitch Shift" => "Alteração de tom", + "Pitch Shift Legacy" => "Alteração de tom (legado)", + "Play Edit" => "Reproduzir edição", + "Play Timeline" => "Reproduzir linha do tempo", + "Playback Engine..." => "Mecanismo de reprodução...", + "Plugin Automation" => "Automação de plugin", + "Power" => "Energia", + "Pre-Fader Metering" => "Medição pré-fader", + "Pre/Post-Roll" => "Pré-roll/pós-roll", + "Preferences..." => "Preferências...", + "Prepare DPE Tracks" => "Preparar faixas DPE", + "Previous" => "Anterior", + "Print Score..." => "Imprimir partitura...", + "Pro Tools Projects" => "Projetos Pro Tools", + "Pro Tools Search" => "Busca do Pro Tools", + "Processing State" => "Estado do processamento", + "Project..." => "Projeto...", + "Quad" => "Quad", + "Quantize to Grid" => "Quantizar para a grade", + "Quantize..." => "Quantizar...", + "QuickPunch" => "QuickPunch", + "Rating" => "Classificação", + "Real-Time Properties" => "Propriedades em tempo real", + "Recti-Fi" => "Recti-Fi", + "Rectified" => "Retificado", + "Regroup" => "Reagrupar", + "Remove Duplicate Notes" => "Remover notas duplicadas", + "Remove Edit from Bottom" => "Remover edição da parte inferior", + "Remove Edit from Top" => "Remover edição da parte superior", + "Remove Pitch Shift" => "Remover alteração de tom", + "Remove Warp" => "Remover deformação", + "Renumber Bars..." => "Renumerar compassos...", + "Repeat to Fill Selection" => "Repetir até preencher a seleção", + "Repeat..." => "Repetir...", + "Restore Last Selection" => "Restaurar última seleção", + "Restore Performance..." => "Restaurar execução...", + "Retrospective Record" => "Gravação retrospectiva", + "Reverb" => "Reverberação", + "Reverse" => "Inverter", + "Revert Session to Saved..." => "Reverter sessão para a versão salva...", + "Ruler Lane Color" => "Cor da faixa de régua", + "Ruler Lines" => "Linhas da régua", + "Rulers" => "Réguas", + "S-Curve..." => "Curva em S...", + "SIP (Solo In Place)" => "SIP (solo no local)", + "Samples" => "Amostras", + "SansAmp PSA-1" => "SansAmp PSA-1", + "Save As Template..." => "Salvar como modelo...", + "Save Session" => "Salvar sessão", + "Save Session As..." => "Salvar sessão como...", + "Save Session Copy In..." => "Salvar cópia da sessão em...", + "Save Track Preset..." => "Salvar predefinição de faixa...", + "Scale..." => "Escala...", + "Scene And Take" => "Cena e tomada", + "Sci-Fi" => "Sci-Fi", + "Score Setup..." => "Configuração da partitura...", + "Scroll to Track..." => "Rolar até a faixa...", + "Select All" => "Selecionar tudo", + "Select/Split Notes..." => "Selecionar/dividir notas...", + "Selected Tracks as New AAF/OMF..." => "Faixas selecionadas como novo AAF/OMF...", + "Selected Tracks as New Media Composer Compatible Session..." => "Faixas selecionadas como nova sessão compatível com Media Composer...", + "Selected Tracks as New Session..." => "Faixas selecionadas como nova sessão...", + "Selection" => "Seleção", + "Send A" => "Envio A", + "Send B" => "Envio B", + "Send C" => "Envio C", + "Send D" => "Envio D", + "Send E" => "Envio E", + "Send F" => "Envio F", + "Send G" => "Envio G", + "Send H" => "Envio H", + "Send I" => "Envio I", + "Send J" => "Envio J", + "Send To..." => "Enviar para...", + "Send to Back" => "Enviar para trás", + "Sends A-E" => "Envios A-E", + "Sends F-J" => "Envios F-J", + "Session" => "Sessão", + "Session Data..." => "Dados da sessão...", + "Session Info as Text..." => "Informações da sessão como texto...", + "Session..." => "Sessão...", + "Set Record Tracks to Input Only" => "Definir faixas de gravação apenas para entrada", + "Setup" => "Configuração", + "Shift..." => "Deslocar...", + "Show / Hide..." => "Mostrar/ocultar...", + "Show Target Playlist" => "Mostrar playlist de destino", + "Sibelius" => "Sibelius", + "Sibelius..." => "Sibelius...", + "Sign In" => "Entrar", + "Signal Generator" => "Gerador de sinal", + "Sketch to Front" => "Trazer Sketch para frente", + "Sketch..." => "Sketch...", + "Snap to" => "Ajustar a", + "Solo Mode" => "Modo solo", + "SoundFlow" => "SoundFlow", + "Soundbase" => "Soundbase", + "Space Clips…" => "Espaçar clipes…", + "Splice" => "Emenda", + "Split into Mono" => "Dividir em mono", + "Start Collaboration..." => "Iniciar colaboração...", + "Start to Fill Selection" => "Do início até preencher a seleção", + "Start to Insertion" => "Do início até o ponto de inserção", + "Step Input..." => "Entrada passo a passo...", + "Stretch..." => "Alongar...", + "Strip Silence" => "Remover silêncio", + "Sync Point" => "Ponto de sincronização", + "Synchronization" => "Sincronização", + "System Usage" => "Uso do sistema", + "TCE Edit to Timeline Selection" => "Edição TCE para seleção da linha do tempo", + "Tab to Transient" => "Tabulação até o transiente", + "Target Playlist" => "Playlist de destino", + "Task Manager" => "Gerenciador de tarefas", + "Tempo Editor" => "Editor de andamento", + "Tempo Operations Window" => "Janela de operações de andamento", + "Thin" => "Compactar", + "Tile" => "Organizar em mosaico", + "Tile Horizontal" => "Mosaico horizontal", + "Tile Vertical" => "Mosaico vertical", + "Time Compression Expansion" => "Compressão e expansão de tempo", + "Time Lock/Unlock" => "Bloquear/desbloquear tempo", + "Time Operations Window" => "Janela de operações de tempo", + "Time Shift" => "Deslocamento de tempo", + "Timecode" => "Timecode", + "Timecode 2" => "Timecode 2", + "To Current Automation Type" => "Para o tipo de automação atual", + "To File Boundaries" => "Até os limites do arquivo", + "To File End" => "Até o fim do arquivo", + "To File Start" => "Até o início do arquivo", + "To Fill Selection" => "Até preencher a seleção", + "To Selection" => "Até a seleção", + "Toggle Recent Playlist" => "Alternar playlist recente", + "Track" => "Faixa", + "Track Lane" => "Faixa de trilhas", + "Track Lane Color" => "Cor da faixa de trilhas", + "Track List" => "Lista de faixas", + "Track Number" => "Número da faixa", + "Track Presets" => "Predefinições de faixa", + "Track Transcription Lane" => "Faixa de transcrição", + "TrackPunch" => "TrackPunch", + "Transcript" => "Transcrição", + "Transcription Settings..." => "Configurações de transcrição...", + "Transparency" => "Transparência", + "Transport Online" => "Transporte conectado", + "Transpose..." => "Transpor...", + "Trim" => "Ajustar", + "Trim Playlist" => "Ajustar playlist", + "Trim and Downmix" => "Ajustar e reduzir canais", + "Trim to All Enabled" => "Ajustar a todos os habilitados", + "Trim to Current" => "Ajustar ao atual", + "UI Customization" => "Personalização da interface", + "Undo History" => "Histórico de desfazer", + "Ungroup" => "Desagrupar", + "Ungroup All" => "Desagrupar tudo", + "Universe" => "Visão geral", + "Unloop..." => "Desativar loop...", + "Update Active Configuration" => "Atualizar configuração ativa", + "User Time Stamp" => "Registro de data e hora do usuário", + "VENUE Channel Names as Track Names" => "Usar nomes de canais VENUE como nomes de faixas", + "Vari-Fi" => "Vari-Fi", + "Video Sync Offset..." => "Deslocamento de sincronização de vídeo...", + "Video Track Online" => "Faixa de vídeo conectada", + "Video..." => "Vídeo...", + "View" => "Visualizar", + "Waveforms" => "Formas de onda", + "Window" => "Janela", + "Window Configuration List" => "Lista de configurações de janela", + "Workspaces" => "Áreas de trabalho", + "Write MIDI Real-Time Properties" => "Gravar propriedades MIDI em tempo real", + "Write to All Enabled" => "Gravar em todos os habilitados", + "X-OR (Cancels Previous Solo)" => "X-OR (cancela o solo anterior)", + "About" => "Sobre", + "Contributors" => "Colaboradores", + "Models" => "Modelos", + "Join us on Discord" => "Participe no Discord", + "C major" => "Dó maior", + "Channel format" => "Formato de canal", + "Create up to 128 tracks at a time." => "Crie até 128 faixas por vez.", + "Input trim (dB)" => "Trim de entrada (dB)", + "Score composer" => "Compositor da partitura", + "Score title" => "Título da partitura", + "Send level" => "Nível do envio", + "Surround pan: drag the puck · double-click: front centre · Alt-drag: divergence" => { + "Panorama surround: arraste o controle · clique duplo: centro frontal · Alt+arraste: divergência" + } + "Tempo (BPM)" => "Andamento (BPM)", + "Ticks" => "Ticks", + "Timebase" => "Base de tempo", + "Track kind" => "Tipo de faixa", + "Views" => "Visualizações", + "Automation mode for {}" => "Modo de automação da faixa {}", + "Track view for {}" => "Visualização da faixa {}", + "BYPASSED" => "IGNORADO", + "OBJECT" => "OBJETO", + "Disable" => "Desativar", + "Enable" => "Ativar", + "Name (A–Z)" => "Nome (A–Z)", + "Merged PRs" => "PRs mesclados", + "Lines added" => "Linhas adicionadas", + "Lines deleted" => "Linhas removidas", + "Line delta" => "Variação de linhas", + "Binary assets added" => "Recursos binários adicionados", + "Binary assets removed" => "Recursos binários removidos", + "First commit" => "Primeiro commit", + "Last commit" => "Último commit", + "PRs" => "PRs", + "+LOC" => "+LOC", + "−LOC" => "−LOC", + "ΔLOC" => "ΔLOC", + "+Bin" => "+Bin", + "−Bin" => "−Bin", + "Username" => "Nome de usuário", + "Display name" => "Nome de exibição", + "Real name" => "Nome real", + "no input" => "sem entrada", + "no output" => "sem saída", + "Out 1-2" => "Saída 1-2", + "Bus" => "Bus", + "Search buses…" => "Pesquisar buses…", + "In {}" => "Entrada {}", + "Read" => "Leitura", + "Write" => "Gravação", + "Touch" => "Toque", + "Touch/Latch" => "Toque/Retenção", + "Off" => "Desativado", + "read" => "leitura", + "write" => "gravação", + "touch" => "toque", + "latch" => "retenção", + "touch/latch" => "toque/retenção", + "off" => "desativado", + "trim" => "trim", + "Stereo" => "Estéreo", + "Aux Input" => "Entrada auxiliar", + "Master Fader" => "Fader master", + "MIDI Track" => "Faixa MIDI", + "Instrument Track" => "Faixa de instrumento", + "VCA Master" => "Master VCA", + "Routing Folder Track" => "Faixa de pasta de roteamento", + "Video Track" => "Faixa de vídeo", + "Zoomer" => "Zoom", + "Selector" => "Seletor", + "Grabber" => "Capturador", + "Scrubber" => "Varredura", + "Pencil" => "Lápis", + "micro" => "micro", + "mini" => "mini", + "small" => "pequena", + "medium" => "média", + "large" => "grande", + "jumbo" => "extra grande", + "extreme" => "máxima", + "fit to window" => "ajustar à janela", + "custom" => "personalizada", + "Voice for {}" => "Voz da faixa {}", + "Input for {}" => "Entrada da faixa {}", + "Output for {}" => "Saída da faixa {}", + "Record enable" => "Habilitação de gravação", + "Input monitoring" => "Monitoramento de entrada", + "Solo" => "Solo", + "Mute" => "Silenciar", + "Record enable for {}" => "Habilitação de gravação para {}", + "Input monitoring for {}" => "Monitoramento de entrada para {}", + "Solo for {}" => "Solo para {}", + "Mute for {}" => "Silenciar {}", + "auto {}" => "Automação: {}", + "constant" => "constante", + "linear" => "linear", + "parabolic" => "parabólico", + "s-curve" => "curva em S", + "scale" => "escala", + "stretch" => "alongamento", + "insert" => "inserir", + "cut" => "recortar", + "change meter" => "alterar compasso", + "move song start" => "mover início da música", + "quantize" => "quantizar", + "transpose" => "transpor", + "change velocity" => "alterar velocidade", + "flatten performance" => "consolidar execução", + "restore performance" => "restaurar execução", + "start bpm " => "andamento inicial ", + "end bpm " => "andamento final ", + "Identify beat bars" => "Compassos para identificar a batida", + "Start tempo (BPM)" => "Andamento inicial (BPM)", + "End tempo (BPM)" => "Andamento final (BPM)", + "Meter numerator" => "Numerador do compasso", + "Meter denominator" => "Denominador do compasso", + "Time (seconds)" => "Tempo (segundos)", + "no device (silent clock)" => "sem dispositivo (relógio silencioso)", + "opened on first record or monitor" => "aberto na primeira gravação ou monitoração", + " (resampled to the device rate)" => " (reamostrado para a taxa do dispositivo)", + "No sample" => "Nenhuma amostra", + "{}: missing" => "{}: ausente", + "none" => "nenhum", + // Formatted messages. Placeholders mirror the English source so the same arguments fill + // them; `localized_format!` selects the template at run time. + "Active audio ends at {seconds:.2} seconds" => "O áudio ativo termina em {seconds:.2} segundos", + "Active plugin instances: {plugins}" => "Instâncias de plugins ativas: {plugins}", + "Audio: {}" => "Áudio: {}", + "AudioSuite · {title}" => "AudioSuite · {title}", + "Bouncing {name}" => "Renderizando {name}", + "Bouncing {} ({:.0}%)" => "Renderizando {} ({:.0}%)", + "Configuration {n}" => "Configuração {n}", + "Default ({default})" => "Padrão ({default})", + "Device default" => "Padrão do dispositivo", + "Importing {name}{more}" => "Importando {name}{more}", + "Main output: {}" => "Saída principal: {}", + "Recording at 24-bit uses {per_min:.1} MB per mono track-minute" => "A gravação em 24 bits usa {per_min:.1} MB por minuto de faixa mono", + "Revert “{name}” to its last saved version?" => "Reverter “{name}” para a última versão salva?", + "Close “{name}” without saving?" => "Fechar “{name}” sem salvar?", + "Save changes to “{name}” before closing?" => "Salvar as alterações em “{name}” antes de fechar?", + "Session file: {p}" => "Arquivo da sessão: {p}", + "Session media: {} files, {:.1} MB in memory (32-bit float)" => { + "Mídia da sessão: {} arquivos, {:.1} MB na memória (ponto flutuante de 32 bits)" + } + "Tracks: {}" => "Faixas: {}", + "UI frame time: {:.1} ms" => "Tempo do quadro da interface: {:.1} ms", + "Undo steps: {}" => "Etapas para desfazer: {}", + "Value in {suffix}" => "Valor em {suffix}", + "Version {}" => "Versão {}", + "{bars} bars" => "{bars} compassos", + "{} contributors · {} commits" => "{} colaboradores · {} commits", + "@{}: {} PRs, {} commits, +{} / −{} lines (Δ {}), +{} / −{} binary assets, {} – {}" => { + "@{}: {} PRs, {} commits, +{} / −{} linhas (Δ {}), +{} / −{} recursos binários, {} – {}" + } + "Instrument for {}" => "Instrumento de {}", + "Insert {} for {}" => "Insert {} para {}", + "Group for {}" => "Grupo da faixa {}", + "In 1-{}" => "Entradas 1-{}", + "Send {} for {}" => "Envio {} de {}", + "Send {} · {}" => "Envio {} · {}", + "Send {which} level for {track}" => "Nível do envio {which} da faixa {track}", + "(redo) {r}" => "(refazer) {r}", + "{} / {} / {}{}" => "Faixa: {} / Playlist: {} / Clipe: {}{}", + "{} (missing)" => "{} (ausente)", + "{} for {}" => "{} para {}", + "{} @ {} Hz" => "{} a {} Hz", + "{} samples" => "{} amostras", + "{} · {} Hz · {} ch · {}" => "{} · {} Hz · {} canais · {}", + "{} · {} Hz · {} ch" => "{} · {} Hz · {} canais", + "{} audio clips checked · {} issues" => "{} clipes de áudio verificados · {} problemas", + "{} ch" => "{} canais", + "{} object track(s)" => "{} faixa(s) de objeto", + "{} — {} from channel {}" => "{} — {} do canal {}", + "“{}” already exists. Do you want to replace it?" => "“{}” já existe. Deseja substituí-lo?", + "“{name}” has {what} from an earlier run, autosaved {age}." => { + "“{name}” tem {what} de uma execução anterior, salvo automaticamente {age}." + } + "{question} Your changes will be lost." => "{question} Suas alterações serão perdidas.", + "{path}\nnot found" => "{path}\nnão encontrado", + "media offline: {why}" => "mídia indisponível: {why}", + "media offline: {e}" => "mídia indisponível: {e}", + "Window configuration could not be restored: {error}" => "Não foi possível restaurar a configuração da janela: {error}", + "unsaved changes and an unfinished recording" => "alterações não salvas e uma gravação inacabada", + "unsaved changes" => "alterações não salvas", + "recently" => "recentemente", + "less than a minute ago" => "há menos de um minuto", + "minute" => "minuto", + "hour" => "hora", + "day" => "dia", + "{n} {unit} ago" => "há {n} {unit}", + "{n} {unit}s ago" => "há {n} {unit}s", + // Command, menu and dialog labels. The menus, the command palette and the Keyboard + // Shortcuts window all read these, so one entry serves every surface. + "Add Automation Breakpoint" => "Adicionar ponto de automação", + "Add MIDI Note" => "Adicionar nota MIDI", + "Add Note" => "Adicionar nota", + "Arrange Panel" => "Organizar painel", + "Assign Send" => "Atribuir envio", + "Assign to VCA" => "Atribuir ao VCA", + "Audio Device" => "Dispositivo de áudio", + "AudioSuite Process" => "Processar no AudioSuite", + "Auto Rename..." => "Renomear automaticamente...", + "Automation Mode" => "Modo de automação", + "Bounce Mix" => "Renderizar mixagem", + "Bounce Mix…" => "Renderizar mixagem…", + "Bounce Stems..." => "Renderizar stems...", + "Bypass Insert" => "Desativar insert", + "Cancel Zoom Toggle" => "Cancelar alternância de zoom", + "Clear All Mutes" => "Limpar todos os mutes", + "Clear All Solos" => "Limpar todos os solos", + "Clear Automation" => "Limpar automação", + "Clear Clips" => "Limpar clipes", + "Clear Sampler Sample" => "Limpar amostra do sampler", + "Clip Color" => "Cor do clipe", + "Clip Looping" => "Loop de clipe", + "Create Group" => "Criar grupo", + "Decrease Track Height" => "Diminuir altura da faixa", + "Delete Memory Location" => "Excluir localização de memória", + "Delete Notes" => "Excluir notas", + "Delete Unused Playlists" => "Excluir playlists não usadas", + "Deselect All" => "Desmarcar tudo", + "Duplicate Playlist" => "Duplicar playlist", + "Edit Memory Location" => "Editar localização de memória", + "Edit Mode" => "Modo de edição", + "Edit Note" => "Editar nota", + "Edit Tool" => "Ferramenta de edição", + "Export Clip Groups..." => "Exportar grupos de clipes...", + "Export Clips as Files..." => "Exportar clipes como arquivos...", + "Fast Forward" => "Avançar rapidamente", + "Fill Window With Session" => "Preencher janela com a sessão", + "Format Time" => "Formatar tempo", + "Go to End" => "Ir para o fim", + "Go to Next Marker" => "Ir para o próximo marcador", + "Go to Previous Marker" => "Ir para o marcador anterior", + "Grid Value" => "Valor da grade", + "Half-Speed Playback" => "Reprodução em meia velocidade", + "Hide Track" => "Ocultar faixa", + "I/O Setup" => "Configuração de E/S", + "Increase Track Height" => "Aumentar altura da faixa", + "Input Monitoring" => "Monitoração de entrada", + "Input Trim" => "Ajuste de entrada", + "Insert Plugin" => "Inserir plugin", + "Inspect Clip" => "Inspecionar clipe", + "Inspect Session" => "Inspecionar sessão", + "Inspect Track" => "Inspecionar faixa", + "Keyboard Focus" => "Foco do teclado", + "Keyboard Shortcuts" => "Atalhos de teclado", + "List CLAP Plugins" => "Listar plugins CLAP", + "List Commands" => "Listar comandos", + "List MIDI Notes" => "Listar notas MIDI", + "List Plugins" => "Listar plugins", + "List VST3 Plugins" => "Listar plugins VST3", + "Load Sampler Sample" => "Carregar amostra do sampler", + "Load Track Preset" => "Carregar predefinição de faixa", + "Locate" => "Localizar", + "MIDI Editors to Back" => "Editores MIDI para trás", + "MIDI Editors to Front" => "Editores MIDI para frente", + "Main Output Format" => "Formato da saída principal", + "Mix Window View" => "Visualização da janela de mixagem", + "Modify Group" => "Modificar grupo", + "Move Clips" => "Mover clipes", + "Move Insert" => "Mover insert", + "Move Notes" => "Mover notas", + "Move Track" => "Mover faixa", + "Movies" => "Filmes", + "New Configuration" => "Nova configuração", + "New MIDI Clip" => "Novo clipe MIDI", + "New Memory Location" => "Nova localização de memória", + "New Session" => "Nova sessão", + "New Tracks" => "Novas faixas", + "New Tracks…" => "Novas faixas…", + "Nudge Clip Gain Down" => "Reduzir ganho do clipe por deslocamento", + "Nudge Clip Gain Up" => "Aumentar ganho do clipe por deslocamento", + "Nudge Value" => "Valor do deslocamento", + "Object / Bed" => "Objeto / leito", + "Open Session..." => "Abrir sessão...", + "Open/Close Folder" => "Abrir/fechar pasta", + "Parity Report" => "Relatório de paridade", + "Paste Clip Effects" => "Colar efeitos do clipe", + "Paste Clip Gain" => "Colar ganho do clipe", + "Pause" => "Pausar", + "Phase Invert" => "Inverter fase", + "Pin Track" => "Fixar faixa", + "Place Audio File" => "Posicionar arquivo de áudio", + "Play" => "Reproduzir", + "Play/Stop" => "Reproduzir/parar", + "Playback Engine" => "Mecanismo de reprodução", + "Post-Roll Amount" => "Duração do pós-roll", + "Pre-Roll Amount" => "Duração do pré-roll", + "Promote to Main Playlist" => "Promover à playlist principal", + "Recall Memory Location" => "Reativar localização de memória", + "Record" => "Gravar", + "Record Enable" => "Ativar gravação", + "Redo" => "Refazer", + "Remove Insert" => "Remover insert", + "Remove Send" => "Remover envio", + "Remove Sync Point" => "Remover ponto de sincronia", + "Remove Tempo Change" => "Remover mudança de andamento", + "Rename Clip" => "Renomear clipe", + "Rename Marker" => "Renomear marcador", + "Rename Selected Clips" => "Renomear clipes selecionados", + "Rename Track" => "Renomear faixa", + "Reset Edit Settings" => "Redefinir configurações de edição", + "Reset Panel Layout" => "Redefinir layout dos painéis", + "Return to Zero" => "Voltar ao zero", + "Revert to Saved" => "Reverter para salvo", + "Rewind" => "Retroceder", + "Score Setup" => "Configuração da partitura", + "Scroll Timeline" => "Rolar linha do tempo", + "Select Playlist" => "Selecionar playlist", + "Send Level" => "Nível do envio", + "Session Setup" => "Configuração da sessão", + "Set Clip Effects" => "Definir efeitos do clipe", + "Set Edit Selection" => "Definir seleção de edição", + "Set Instrument" => "Definir instrumento", + "Set Instrument Parameter" => "Definir parâmetro do instrumento", + "Set Pan" => "Definir panorama", + "Set Plugin Parameter" => "Definir parâmetro do plugin", + "Set Plugin Parameters" => "Definir parâmetros do plugin", + "Set Send Surround Pan" => "Definir panorama surround do envio", + "Set Surround Pan" => "Definir panorama surround", + "Set UI State" => "Definir estado da interface", + "Set Video Start" => "Definir início do vídeo", + "Set Volume" => "Definir volume", + "Set Zoom" => "Definir zoom", + "Show Grid Lines" => "Mostrar linhas da grade", + "Shuffle Lock" => "Bloquear modo Shuffle", + "Snap to Grid" => "Ajustar à grade", + "Solo Safe" => "Solo seguro", + "Spot" => "Posicionar", + "Stop" => "Parar", + "Strip Silence Rectangles" => "Retângulos de remoção de silêncio", + "Sub Counter" => "Subcontador", + "Tab" => "Tab", + "Tempo Change" => "Mudança de andamento", + "Tempo Change (BPM)" => "Mudança de andamento (BPM)", + "Toggle Group Active" => "Alternar grupo ativo", + "Toggle Mix/Edit" => "Alternar mixagem/edição", + "Track Comments" => "Comentários da faixa", + "Track Input" => "Entrada da faixa", + "Track Output" => "Saída da faixa", + "Track Timebase" => "Base de tempo da faixa", + "Track View" => "Visualização da faixa", + "Transport Status" => "Status do transporte", + "Trim Clip" => "Aparar clipe", + "Undo" => "Desfazer", + "Unsaved Changes" => "Alterações não salvas", + "View Flags" => "Indicadores de visualização", + "Waveform Zoom" => "Zoom da forma de onda", + "Workspaces to Front" => "Áreas de trabalho para frente", + "Write Automation" => "Gravar automação", + "Write Trim Automation" => "Gravar automação de ajuste", + "Zoom By" => "Zoom em", + "Zoom In" => "Aumentar zoom", + "Zoom Out" => "Diminuir zoom", + "Zoom Preset" => "Predefinição de zoom", + "Zoom Toggle" => "Alternar zoom", + "Zoom to Selection" => "Zoom na seleção", + "Close folder" => "Fechar pasta", + "Divergence (0 = point source)" => "Divergência (0 = fonte pontual)", + "Elevation (height speakers)" => "Elevação (alto-falantes de altura)", + "Follow Main Time Scale" => "Acompanhar escala de tempo principal", + "Hide automation" => "Ocultar automação", + "Open folder" => "Abrir pasta", + "Send {which}" => "Envio {which}", + "Send {which} · Choose destination" => "Envio {which} · Escolher destino", + "Show volume automation" => "Mostrar automação de volume", + "Unfreeze" => "Descongelar", + "Unknown vendor" => "Fabricante desconhecido", + "samples" => "amostras", + "{v} {unit}" => "{v} {unit}", + "Loop Rec" => "Gravação em loop", + "MIDI Merge" => "Mesclagem MIDI", + "Pre/Post" => "Pré/Pós", + "0.5 seconds" => "0,5 segundos", + "Path" => "Caminho", + "1 bar" => "1 compasso", + "1 foot" => "1 pé", + "1 frame" => "1 frame", + "1 ms" => "1 ms", + "1 sample" => "1 amostra", + "1 second" => "1 segundo", + "1 subframe" => "1 subframe", + "1/16 note" => "1/16 nota", + "1/2 frame" => "1/2 frame", + "1/2 note" => "1/2 nota", + "1/32 note" => "1/32 nota", + "1/4 frame" => "1/4 frame", + "1/4 note" => "1/4 nota", + "1/64 note" => "1/64 nota", + "1/8 note" => "1/8 nota", + "10 ms" => "10 ms", + "10 samples" => "10 amostras", + "100 ms" => "100 ms", + "100 samples" => "100 amostras", + "1000 samples" => "1000 amostras", + "10000 samples" => "10000 amostras", + "2 samples" => "2 amostras", + "29.97 Drop" => "29,97 Drop", + "5 frames" => "5 frames", + "59.94 Drop" => "59,94 Drop", + "A bounce is already running" => "Já há um bounce em execução", + "Audio files" => "Arquivos de áudio", + "Audio input: {what} {then}" => "Entrada de áudio: {what} {then}", + "Audio output: {cause} {then}" => "Saída de áudio: {cause} {then}", + "Automation mode" => "Modo de automação", + "Bit depth" => "Profundidade de bits", + "Bounce cancelled" => "Bounce cancelado", + "CLIPS" => "CLIPES", + "COMMENTS" => "COMENTÁRIOS", + "Change" => "Alterar", + "Check the audio device, then use Reconnect audio device in Setup › Playback Engine." => { + "Verifique o dispositivo de áudio e use Reconectar dispositivo de áudio em Configurar › Mecanismo de reprodução." + } + "Check the disk, then record again." => "Verifique o disco e grave novamente.", + "Chords" => "Acordes", + "Clips" => "Clipes", + "Clips/Markers" => "Clipes/marcadores", + "Could not save the preset" => "Não foi possível salvar o preset", + "Delete marker" => "Excluir marcador", + "Delete note" => "Excluir nota", + "Dotted" => "Pontilhado", + "Extend" => "Estender", + "Fills the selection on the selected tracks with a new clip." => "Preenche a seleção nas faixas selecionadas com um novo clipe.", + "Finish or cancel the bounce first" => "Termine ou cancele o bounce primeiro", + "First" => "Primeiro", + "First clip: {}" => "Primeiro clipe: {}", + "Fit To" => "Ajustar para", + "G major" => "Sol maior", + "GRID" => "GRADE", + "GROUPS" => "GRUPOS", + "Hide" => "Ocultar", + "INSERTS A-E" => "INSERÇÕES A-E", + "INSERTS F-J" => "INSERÇÕES F-J", + "INSTRUMENT" => "INSTRUMENTO", + "Last" => "Último", + "Length" => "Duração", + "Location" => "Localização", + "Mute send" => "Silenciar envio", + "No Audio Units found" => "Nenhum plugin Audio Units encontrado", + "No CLAP plugins found" => "Nenhum plugin CLAP encontrado", + "No VST3 plugins found" => "Nenhum plugin VST3 encontrado", + "No audio input: {e}" => "Sem entrada de áudio: {e}", + "No matches" => "Nenhuma correspondência", + "No track is record-enabled: click the R button on the track to record." => { + "Nenhuma faixa ativada para gravação: clique no botão R da faixa." + } + "Note" => "Nota", + "Note velocity" => "Velocidade da nota", + "Nothing to record on yet: add a track with Track › New…, then click its R button." => { + "Nada para gravar ainda: crie uma faixa em Faixa › Novo… e clique no botão R." + } + "Number" => "Número", + "Number of Places" => "Número de casas", + "On" => "Ativado", + "PREAMP" => "PRÉ-AMP", + "Playback stopped: {cause} {then}" => "Reprodução interrompida: {cause} {then}", + "Preset name" => "Nome do preset", + "Processes the selected clips and replaces them with rendered audio." => { + "Processa os clipes selecionados e os substitui por áudio renderizado." + } + "REL GRID" => "REL GRADE", + "Reconnect it, then use Reconnect audio device in Setup › Playback Engine." => { + "Reconecte-o e use Reconectar dispositivo de áudio em Configurar › Mecanismo de reprodução." + } + "Recording stopped: {cause} The take is kept up to there. {then}" => "Gravação interrompida: {cause} A gravação foi mantida até aqui. {then}", + "Recording stopped: {what} The take is kept up to there. {then}" => "Gravação interrompida: {what} A gravação foi mantida até aqui. {then}", + "Remove configuration" => "Remover configuração", + "Render Clip Gain" => "Renderizar ganho do clipe", + "SENDS A-E" => "ENVIOS A-E", + "SENDS F-J" => "ENVIOS F-J", + "Search instruments…" => "Buscar instrumentos…", + "Search plugins…" => "Buscar plugins…", + "Send level fader" => "Fader de nível do envio", + "Slow Down" => "Diminuir velocidade", + "Speed Up" => "Aumentar velocidade", + "Start (ticks)" => "Início (ticks)", + "Starting Number" => "Número inicial", + "Stop recording before recovering other work." => "Pare a gravação antes de recuperar outro trabalho.", + "TRACKS" => "FAIXAS", + "The disk is too slow: this take has lost {lost} ms of input so far." => { + "O disco está muito lento: esta gravação perdeu {lost} ms de entrada." + } + "Timebase: samples" => "Base de tempo: amostras", + "Timebase: ticks" => "Base de tempo: ticks", + "Timecode rate" => "Taxa de timecode", + "Triplet" => "Tercina", + "Type" => "Tipo", + "Use Reconnect audio device in Setup › Playback Engine, or restart SoundCraft." => { + "Use Reconectar dispositivo de áudio em Configurar › Mecanismo de reprodução, ou reinicie o SoundCraft." + } + "Use Reconnect audio device in Setup › Playback Engine." => "Use Reconectar dispositivo de áudio em Configurar › Mecanismo de reprodução.", + "Whole note" => "Nota inteira", + "Window Configurations" => "Configurações de janela", + "Without a name, the clips keep their names." => "Sem nome, os clipes mantêm seus nomes.", + "audio on" => "áudio ativado", + "is unavailable" => "está indisponível", + "marker" => "marcador", + "modified" => "modificado", + "movie offline" => "filme indisponível", + "no audio engine" => "sem mecanismo de áudio", + "no audio input device" => "sem dispositivo de entrada de áudio", + "no audio track is record-enabled" => "nenhuma faixa de áudio ativada para gravação", + "saved" => "salvo", + "selection" => "seleção", + "send level" => "Nível do envio", + "send mute" => "Mute do envio", + "send pan" => "Panorama do envio", + "silent clock" => "relógio silencioso", + "stop recording before changing the audio device" => "pare a gravação antes de alterar o dispositivo de áudio", + "stopped asking for audio" => "parou de solicitar áudio", + "the audio engine hit an internal error (see the log)" => "o mecanismo de áudio encontrou um erro interno (veja o registro)", + "Equal Power" => "Potência igual", + "Exponential" => "Exponencial", + "Linear" => "Linear", + "Logarithmic" => "Logarítmica", + "S-Curve" => "Curva S", + "Smart Tool" => "Ferramenta inteligente", + "blocks" => "Blocos", + "clip_gain" => "Ganho do clipe", + "notes" => "Notas", + "regions" => "Regiões", + "waveform" => "Forma de onda", + "mute" => "Mute", + "pan" => "Panorama", + "volume" => "Volume", + "Amp Attack" => "Ataque do amplificador", + "Amp Decay" => "Decaimento do amplificador", + "Amp Release" => "Liberação do amplificador", + "Amp Sustain" => "Sustentação do amplificador", + "Asymmetry" => "Assimetria", + "Attack" => "Ataque", + "Auto Pan" => "Pan automático", + "Ceiling" => "Teto", + "Center" => "Centro", + "Chorus" => "Chorus", + "Closed Hat Decay" => "Decaimento do chimbal fechado", + "Comp" => "Comp", + "Comp Attack" => "Ataque do comp", + "Comp Makeup" => "Ganho do comp", + "Comp Ratio" => "Razão do comp", + "Comp Release" => "Liberação do comp", + "Comp Thresh" => "Limiar do comp", + "Compressor/Limiter" => "Compressor/Limitador", + "Cutoff" => "Frequência de corte", + "Cymbal Decay" => "Decaimento do prato", + "DC Rmv" => "Rem. CC", + "De-Esser" => "De-Esser", + "DeEss" => "DeEss", + "Decay" => "Decaimento", + "Depth" => "Profundidade", + "Diffusion" => "Difusão", + "Direct Gain" => "Ganho direto", + "Direct Solo" => "Solo direto", + "Dither" => "Dither", + "Drive" => "Drive", + "Drum Synth" => "Sintetizador de bateria", + "Drums" => "Bateria", + "EQ 1-Band" => "EQ de 1 banda", + "EQ 7-Band" => "EQ de 7 bandas", + "EQ1" => "EQ1", + "EQ7" => "EQ7", + "Expander/Gate" => "Expansor/Gate", + "Feedback" => "Realimentação", + "Filter Attack" => "Ataque do filtro", + "Filter Decay" => "Decaimento do filtro", + "Filter Env" => "Envelope do filtro", + "Filter Release" => "Liberação do filtro", + "Filter Sustain" => "Sustentação do filtro", + "Fine" => "Fino", + "Fine Tune" => "Afinação fina", + "Flanger" => "Flanger", + "Freq" => "Freq", + "Frequency" => "Frequência", + "Gate" => "Gate", + "Gate Range" => "Alcance do gate", + "Gate Release" => "Liberação do gate", + "Gate Thresh" => "Limiar do gate", + "Glide" => "Portamento", + "HF Damping" => "Amortecimento de agudos", + "HF Freq" => "Freq agudos", + "HF Gain" => "Ganho agudos", + "HF Q" => "Q agudos", + "HMF Freq" => "Freq médio-agudos", + "HMF Gain" => "Ganho médio-agudos", + "HMF Q" => "Q médio-agudos", + "HP Freq" => "Freq HP", + "HP Q" => "Q HP", + "HPF" => "HPF", + "HPF Freq" => "Freq HPF", + "High Freq" => "Freq agudos", + "High Gain" => "Ganho agudos", + "Highest Key" => "Tecla mais aguda", + "Highest Velocity" => "Velocidade mais alta", + "Hold" => "Sustentação", + "Key Tracking" => "Seguimento de tecla", + "Kick Decay" => "Decaimento do bumbo", + "Kick Tune" => "Ajuste do bumbo", + "Knee" => "Joelho", + "LF Freq" => "Freq graves", + "LF Gain" => "Ganho graves", + "LF Q" => "Q graves", + "LMF Freq" => "Freq médio-graves", + "LMF Gain" => "Ganho médio-graves", + "LMF Q" => "Q médio-graves", + "LP Freq" => "Freq LP", + "LP Q" => "Q LP", + "LPF" => "LPF", + "LPF Freq" => "Freq LPF", + "Limit" => "Limite", + "Link to Tempo" => "Sincronizar com o andamento", + "Listen" => "Escuta", + "LoFi" => "LoFi", + "Lookahead" => "Antecipação", + "Loop End" => "Fim do loop", + "Loop Start" => "Início do loop", + "Low Cut" => "Corte grave", + "Low Freq" => "Freq grave", + "Low Gain" => "Ganho grave", + "Lower Gain" => "Ganho inferior", + "Lower Solo" => "Solo inferior", + "Lowest Key" => "Tecla mais grave", + "Lowest Velocity" => "Velocidade mais baixa", + "MF Freq" => "Freq médios", + "MF Gain" => "Ganho médios", + "MF Q" => "Q médios", + "Makeup" => "Ganho de compensação", + "Manual" => "Manual", + "Manual Trigger" => "Acionador manual", + "Max" => "Máx.", + "Maximizer" => "Maximizador", + "Mid Freq" => "Freq médios", + "Mid Gain" => "Ganho médios", + "Mid Q" => "Q médios", + "Mod Delay" => "Atraso modulado", + "Mod Depth" => "Profundidade da modulação", + "Mod Rate" => "Taxa da modulação", + "ModDly" => "ModDly", + "Noise" => "Ruído", + "Noise Shaping" => "Modelagem do ruído", + "Open Hat Decay" => "Decaimento do chimbal aberto", + "Osc 2 Detune" => "Desafinação do osc 2", + "Osc 2 Pitch" => "Altura do osc 2", + "Osc Mix" => "Mix do osc", + "Phaser" => "Phaser", + "Pitch" => "Tom", + "Pitch Shifter" => "Deslocador de tom", + "Plate" => "Placa", + "Plate Reverb" => "Reverb de placas", + "Pre-Delay" => "Pré-atraso", + "Q" => "Q", + "Range" => "Alcance", + "Rate" => "Taxa", + "Rate (BPM)" => "Taxa (BPM)", + "Ratio" => "Razão", + "Rectifier" => "Retificador", + "Rectify" => "Retificar", + "Release" => "Liberação", + "Resonance" => "Ressonância", + "Ring Modulator" => "Modulador em anel", + "RingMod" => "RingMod", + "Room" => "Sala", + "Room Reverb" => "Reverb de sala", + "Root Note" => "Nota fundamental", + "SC HPF" => "HPF SC", + "SC HPF Freq" => "Freq HPF SC", + "Sample Start" => "Início da amostra", + "Sampler" => "Sampler", + "Satur" => "Satur", + "Saturator" => "Saturador", + "SigGen" => "Ger. sin.", + "Size" => "Tamanho", + "Snare Decay" => "Decaimento da caixa", + "Snare Snappy" => "Estalo da caixa", + "Snare Tune" => "Ajuste da caixa", + "Spread" => "Espalhamento", + "Strip" => "Canal", + "SubHarm" => "SubHarm", + "SubSynth" => "SubSynth", + "Subharmonic" => "Subharmônico", + "Subtractive Synth" => "Sintetizador subtrativo", + "Sustain" => "Sustentação", + "TShift" => "TShift", + "Threshold" => "Limiar", + "Time" => "Tempo", + "Tom Decay" => "Decaimento do tom", + "Tom Tune" => "Ajuste do tom", + "Tone" => "Tom", + "Upper Gain" => "Ganho superior", + "Upper Solo" => "Solo superior", + "Velocity Sens" => "Sensibilidade à velocidade", + "Wet Solo" => "Solo wet", + "Width" => "Largura", + "invert" => "Inverter", + "{sr} Hz{note}" => "{sr} Hz{note}", + "Autosave failed: {e}" => "Falha ao salvar automaticamente: {e}", + "Bounced {} (peak {:.1} dBFS, {:.1} LUFS)" => "Bounce concluído: {} (pico {:.1} dBFS, {:.1} LUFS)", + "Cannot record: {err}" => "Não foi possível gravar: {err}", + "Click to add a MIDI clip to {name} at the insertion point." => "Clique para adicionar um clipe MIDI a {name} no ponto de inserção.", + "Could not open {path}: {e}" => "Não foi possível abrir {path}: {e}", + "Couldn't recover “{name}”: {e}" => "Não foi possível recuperar “{name}”: {e}", + "Exported {} clip(s) to {}" => "Exportados {} clipe(s) para {}", + "Imported {name}" => "Importado: {name}", + "Opened {name}" => "Aberto: {name}", + "Opened {name} ({missing} missing media)" => "Aberto: {name} ({missing} mídias ausentes)", + "Redo {l}" => "Refazer: {l}", + "Saved preset {clean}" => "Preset salvo: {clean}", + "Undo {l}" => "Desfazer: {l}", + "automation filesystem access is not granted: read authority is absent: {shown_path}" => { + "acesso ao sistema de arquivos de automação não concedido: autoridade de leitura ausente: {shown_path}" + } + "automation filesystem access is not granted: write authority is absent: {shown_path}" => { + "acesso ao sistema de arquivos de automação não concedido: autoridade de escrita ausente: {shown_path}" + } + "automation path rejected: a link that leads nowhere: {}" => "caminho de automação rejeitado: link que não leva a lugar algum: {}", + "automation path rejected: cannot resolve {}: {e}" => "caminho de automação rejeitado: não foi possível resolver {}: {e}", + "automation path rejected: outside the read root {root}: {shown_path}" => { + "caminho de automação rejeitado: fora do diretório de leitura {root}: {shown_path}" + } + "automation path rejected: outside the read roots {}: {shown_path}" => { + "caminho de automação rejeitado: fora dos diretórios de leitura {}: {shown_path}" + } + "automation path rejected: outside the write root {root}: {shown_path}" => { + "caminho de automação rejeitado: fora do diretório de escrita {root}: {shown_path}" + } + "automation path rejected: outside the write roots {}: {shown_path}" => { + "caminho de automação rejeitado: fora dos diretórios de escrita {}: {shown_path}" + } + "automation path rejected: parent traversal below a folder that doesn't exist: {}" => { + "caminho de automação rejeitado: travessia acima de uma pasta que não existe: {}" + } + "automation path rejected: path is empty" => "caminho de automação rejeitado: o caminho está vazio", + "automation path rejected: reserved device names are not allowed: {}" => { + "caminho de automação rejeitado: nomes de dispositivo reservados não são permitidos: {}" + } + "internal error (see the log)" => "erro interno (consulte o registro)", + "make an edit selection first" => "faça uma seleção de edição primeiro", + "no automation has been copied" => "nenhuma automação foi copiada", + "no clip effects have been copied" => "nenhum efeito de clipe foi copiado", + "no clip gain has been copied" => "nenhum ganho de clipe foi copiado", + "no markers on the clipboard" => "não há marcadores na área de transferência", + "no previous selection to restore" => "nenhuma seleção anterior para restaurar", + "no selected clip has a sync point" => "nenhum clipe selecionado tem um ponto de sincronia", + "not opened: the path is not valid" => "não aberto: o caminho não é válido", + "nothing is selected" => "nada está selecionado", + "nothing to redo" => "nada para refazer", + "nothing to undo" => "nada para desfazer", + "score too large: over {} bytes" => "partitura muito grande: excedendo {} bytes", + "select a clip in the Clip List" => "selecione um clipe na Lista de clipes", + "select clips or files in the Clip List" => "selecione clipes ou arquivos na Lista de clipes", + "the clipboard is empty" => "a área de transferência está vazia", + "the session has no tracks" => "a sessão não tem faixas", + "the session has not been saved" => "a sessão não foi salva", + "Loop-recorded {} take(s)" => "Gravadas em loop: {} tomada(s)", + "Recorded {} clip(s)" => "{} clipe(s) gravado(s)", + "Recovered “{name}”. Save it to keep the changes." => "Recuperada “{name}”. Salve para manter as alterações.", + "Recovered “{name}”, but {n} audio file(s) are missing. Save it to keep the changes." => { + "Recuperada “{name}”, mas {n} arquivo(s) de áudio estão ausentes. Salve para manter as alterações." + } + "SoundCraft hit an internal error (see the log). Your changes were autosaved: save them, then restart SoundCraft." => { + "O SoundCraft encontrou um erro interno (consulte o registro). Suas alterações foram salvas automaticamente: salve-as e reinicie o SoundCraft." + } + "SoundCraft hit an internal error (see the log). Restart SoundCraft to be safe." => { + "O SoundCraft encontrou um erro interno (consulte o registro). Reinicie o SoundCraft para garantir." + } + "Panel layout could not be restored: {error}" => "Não foi possível restaurar o layout dos painéis: {error}", + "Panel move was not applied: {error}" => "Não foi possível aplicar a movimentação do painel: {error}", + "Panel windows could not be arranged: {error}" => "Não foi possível organizar as janelas de painéis: {error}", + "{name} on {track} put out invalid audio, so it is bypassed until playback stops or starts again." => { + "{name} em {track} produziu áudio inválido, então foi desativado até a reprodução parar ou começar novamente." + } + "{} pan {}" => "{} pan {}", + "Comments for {}" => "Comentários de {}", + "{} volume" => "Volume de {}", + "{name} · Send {letter}" => "{name} · Envio {letter}", + "{name} send level" => "Nível de envio de {name}", + "Type to search preferences" => "Digite para pesquisar as preferências", + "{name} loaded into the sampler" => "{name} carregado no sampler", + "SoundCraft Preferences" => "Preferências do SoundCraft", + "This preference is not available yet." => "Esta preferência ainda não está disponível.", + "Additional Empty Bars in the Score Editor" => "Compassos vazios adicionais no editor de partitura", + "Add New Playlists" => "Adicionar novas playlists", + "Adjusting Pinned Area Resizes Tracks" => "Ajustar a área fixada redimensiona as pistas", + "Advanced Meter Type Settings" => "Configurações avançadas do tipo de medidor", + "Advanced Video Logging" => "Registro avançado de vídeo", + "After Every Pass" => "Após cada passagem", + "After Write Pass, Switch To" => "Após a passagem de gravação, mudar para", + "All Files" => "Todos os arquivos", + "Allow External Track-Arm Commands in Local Mode" => "Permitir comandos externos de armar pista no modo local", + "Allow External Transport Commands in Local Mode" => "Permitir comandos externos de transporte no modo local", + "Allow Latch Prime in Stop" => "Permitir preparar o Latch com a reprodução parada", + "Allow Sends to Persist During Low-Latency Monitoring" => "Manter os envios durante o monitoramento de baixa latência", + "All — Summed" => "Todos — somados", + "Always Fill Channel Strips when Banking" => "Sempre preencher os canais ao trocar de banco", + "Always On" => "Sempre ativado", + "Always Show Assignable Knob Highlight" => "Sempre mostrar o destaque do botão atribuível", + "Always Use 32-bit" => "Sempre usar 32 bits", + "Anonymous Usage Data" => "Dados de uso anônimos", + "ARA" => "ARA", + "At Bottom" => "Na parte inferior", + "At Insertion or Selection" => "Na inserção ou seleção", + "At Timecode Lock" => "Ao travar no timecode", + "Audio During Fast Forward and Rewind" => "Áudio durante avanço e retrocesso rápidos", + "Audio Engine Errors Stop All Linked Systems" => "Erros do motor de áudio param todos os sistemas vinculados", + "Audio Track Record Lock" => "Bloqueio de gravação das pistas de áudio", + "Auto Accept Adjust Bounds" => "Aceitar automaticamente o ajuste de limites", + "Auto-Adjust Pinned Area for Tracks" => "Ajustar automaticamente a área fixada das pistas", + "Auto Backup" => "Backup automático", + "Auto Insert Default Plugins from Control Surfaces" => "Inserir automaticamente plugins padrão a partir de superfícies de controle", + "Automatically Copy Files on Import" => "Copiar arquivos automaticamente ao importar", + "Automatically Create Click Track in New Sessions" => "Criar automaticamente a pista de clique em novas sessões", + "Automatically Create Fades" => "Criar fades automaticamente", + "Automatically Download New Shared Tracks" => "Baixar automaticamente novas pistas compartilhadas", + "Automatic Analysis on Tick-Based Tracks" => "Análise automática em pistas baseadas em ticks", + "Automation Glide Time" => "Tempo de deslizamento da automação", + "Automation Match Time" => "Tempo de igualação da automação", + "Auto-Name Memory Locations when Playing" => "Nomear locais de memória automaticamente durante a reprodução", + "Auto-Name Separated Clips" => "Nomear automaticamente os clipes separados", + "Auto-Switch Input Language" => "Alternar automaticamente o idioma de entrada", + "Back/Forward Amount" => "Quantidade de voltar/avançar", + "Back/Forward Time Scale" => "Escala de tempo de voltar/avançar", + "Backup Every" => "Fazer backup a cada", + "Basics" => "Básico", + "C3" => "C3", + "C4" => "C4", + "Calibration Reference Level" => "Nível de referência de calibração", + "Category & Manufacturer" => "Categoria e fabricante", + "Change Documentation and Settings Location" => "Alterar o local da documentação e das configurações", + "Change Project Media Cache Location" => "Alterar o local do cache de mídia do projeto", + "Change Sound Libraries Location" => "Alterar o local das bibliotecas de sons", + "Classic" => "Clássico", + "Clip Auto Fade In/Out Length" => "Duração do fade automático de entrada/saída do clipe", + "Clip Gain Nudge Value" => "Valor de ajuste fino do ganho do clipe", + "Clip Indication" => "Indicação de clipe", + "Clip List Selection Follows Edit Selection" => "A seleção da lista de clipes acompanha a seleção de edição", + "Cloud Storage Services" => "Serviços de armazenamento em nuvem", + "Coalesce when Removing Members from a VCA Group" => "Mesclar ao remover membros de um grupo VCA", + "Color Break High" => "Quebra de cor alta", + "Color Break Low" => "Quebra de cor baixa", + "Commit" => "Confirmar", + "Compensate Hardware Inputs" => "Compensar entradas de hardware", + "Compensate Side Chains" => "Compensar side chains", + "Compressor/Limiter Only" => "Somente compressor/limitador", + "Console-Style Input Monitoring Indicators" => "Indicadores de monitoramento de entrada no estilo console", + "Controlled Device Type" => "Tipo de dispositivo controlado", + "Controllers" => "Controladores", + "Convert Copied Files to Session Format" => "Converter arquivos copiados para o formato da sessão", + "Convert Imported WAV Files to Broadcast Wave" => "Converter arquivos WAV importados para Broadcast Wave", + "Create New Playlists when Loop Recording" => "Criar novas playlists na gravação em loop", + "Current Session 5.x to 7.x/9.x" => "Sessão atual 5.x para 7.x/9.x", + "Current Session 7.x/9.x to 5.x" => "Sessão atual 7.x/9.x para 5.x", + "Current Session Fold Down" => "Downmix da sessão atual", + "Current Session Includes LFE in Fold Down" => "A sessão atual inclui o LFE no downmix", + "Current Session Surround to Stereo" => "Surround para estéreo da sessão atual", + "Custom Fast Forward/Rewind Speed" => "Velocidade personalizada de avanço/retrocesso rápido", + "Custom Shuttle Lock Speed" => "Velocidade personalizada de travamento do shuttle", + "Data Collection and Personalization" => "Coleta de dados e personalização", + "Default Automatic Naming to English" => "Nomeação automática padrão em inglês", + "Default Clip Color Coding" => "Codificação de cores padrão dos clipes", + "Default Crossfade" => "Crossfade padrão", + "Default Dynamics" => "Dinâmica padrão", + "Default Dynamics Insert Slot" => "Slot de inserção da dinâmica padrão", + "Default EQ" => "EQ padrão", + "Default EQ Insert Slot" => "Slot de inserção do EQ padrão", + "Default Fade In" => "Fade de entrada padrão", + "Default Fade Out" => "Fade de saída padrão", + "Default Handle Length" => "Duração padrão da margem", + "Default Input Gain" => "Ganho de entrada padrão", + "Default Plugin" => "Plugin padrão", + "Default Settings" => "Configurações padrão", + "Default Sliced-Loop Fade" => "Fade padrão de loop fatiado", + "Default Track Color Coding" => "Codificação de cores padrão das pistas", + "Degree of Thinning" => "Grau de simplificação", + "Delay after Play Command" => "Atraso após o comando de reprodução", + "Delay before Locking to Longitudinal Timecode" => "Atraso antes de travar no timecode longitudinal", + "Delay before Locking to Serial Timecode" => "Atraso antes de travar no timecode serial", + "Delay Compensation for External Devices" => "Compensação de atraso para dispositivos externos", + "Desktop Drag-and-Drop Conforms to Session Tempo" => "Arrastar e soltar da área de trabalho ajusta ao andamento da sessão", + "Destructive Punch File Length" => "Duração do arquivo de punch destrutivo", + "Detailed Tool Tips" => "Dicas de ferramenta detalhadas", + "Digital VU" => "VU digital", + "Direct to Rear Surrounds" => "Direto para os surrounds traseiros", + "Disable DSP Mode when Disabling Record and Input" => "Desativar o modo DSP ao desativar gravação e entrada", + "Disabled While Looping" => "Desativado durante o loop", + "Disable Input Monitoring when Disarming a Stopped Track" => "Desativar o monitoramento de entrada ao desarmar uma pista parada", + "Display" => "Exibição", + "Display Events as Modified by Real-Time Properties" => "Exibir eventos conforme modificados pelas propriedades em tempo real", + "Display Waveforms in Low Resolution While Loading" => "Exibir formas de onda em baixa resolução durante o carregamento", + "Docked MIDI Editor" => "Editor MIDI acoplado", + "Do Not Convert Sample Rate on Import" => "Não converter a taxa de amostragem ao importar", + "Double-Clicking a MIDI Clip Opens" => "Clicar duas vezes em um clipe MIDI abre", + "Double-Clicking an Audio Clip Opens" => "Clicar duas vezes em um clipe de áudio abre", + "Double-Click Selects Automation Breakpoints" => "Clique duplo seleciona pontos de automação", + "Downmix to Surrounds" => "Downmix para os surrounds", + "DSP Management" => "Gerenciamento de DSP", + "Dynamic Transport Follows Selection During Playback" => "O transporte dinâmico acompanha a seleção durante a reprodução", + "Editing" => "Edição", + "Edit Insertion Follows Scrub and Shuttle" => "A inserção de edição acompanha scrub e shuttle", + "Edit Selection Follows Clip List Selection" => "A seleção de edição acompanha a seleção da lista de clipes", + "Edit Window Default Length" => "Duração padrão da janela de edição", + "Edit Window Follows Banking" => "A janela de edição acompanha a troca de banco", + "Edit Window Follows Selection" => "A janela de edição acompanha a seleção", + "Enable Analog Console Processing in New Sessions" => "Ativar o processamento de console analógico em novas sessões", + "Enable Automation in Record" => "Ativar a automação na gravação", + "Enable DSP Mode for Record-Armed or Input-Monitored Tracks" => "Ativar o modo DSP para pistas armadas ou com entrada monitorada", + "Enable Elastic Audio on New Tracks" => "Ativar o Elastic Audio em novas pistas", + "Enable GPU Processing" => "Ativar o processamento por GPU", + "Enable Session File Auto Backup" => "Ativar o backup automático do arquivo da sessão", + "Enable Track Notes Dialog" => "Ativar o diálogo de notas da pista", + "English" => "Inglês", + "Portuguese (Brazil)" => "Português (Brasil)", + "key:Space" => "Espaço", + "key:Up" => "Cima", + "key:Down" => "Baixo", + "key:Left" => "Esquerda", + "key:Right" => "Direita", + "SHUFFLE" => "EMBARALHAR", + "SLIP" => "DESLIZAR", + "SPOT" => "POSICIONAR", + "Shuffle is locked ({cmd}-click to unlock)" => "Embaralhar está bloqueado (clique com {cmd} para desbloquear)", + "Shuffle mode ({fkey}); {cmd}-click locks it out" => "Modo Embaralhar ({fkey}); clique com {cmd} para bloquear", + "Grid mode ({fkey}; again for Relative); Shift-click: Snap to Grid in the other modes" => { + "Modo Grade ({fkey}; novamente para Relativo); Shift+clique: Alinhar à grade nos outros modos" + } + "Slip mode ({fkey}); Shift-click adds Snap to Grid" => "Modo Deslizar ({fkey}); Shift+clique adiciona Alinhar à grade", + "Spot mode ({fkey}); Shift-click adds Snap to Grid" => "Modo Posicionar ({fkey}); Shift+clique adiciona Alinhar à grade", + "New Tracks… ({})" => "Novas pistas… ({})", + "EQ and Dynamics Cycling Starts at Insert" => "A alternância de EQ e dinâmica começa na inserção", + "Expander/Gate Only" => "Somente expansor/gate", + "Factory Default" => "Padrão de fábrica", + "Fades Dialog Preview Post-Roll" => "Post-roll da prévia do diálogo de fades", + "Fades Dialog Preview Pre-Roll" => "Pre-roll da prévia do diálogo de fades", + "First Invite Shares All Tracks" => "O primeiro convite compartilha todas as pistas", + "Fit to Window" => "Ajustar à janela", + "Follow Session Settings" => "Seguir as configurações da sessão", + "Function Tool Tips" => "Dicas de função das ferramentas", + "Gain Reduction Meter Type" => "Tipo de medidor de redução de ganho", + "General Color" => "Cor geral", + "Global MIDI Playback Offset" => "Deslocamento global da reprodução MIDI", + "Handle Length" => "Duração da margem", + "High" => "Alta", + "Highest" => "Mais alta", + "Horizontal Zoom" => "Zoom horizontal", + "Ignore Track Arming" => "Ignorar o armamento de pista", + "Import Sliced Loops as Clip Groups" => "Importar loops fatiados como grupos de clipes", + "Include Control Changes in Undo Queue" => "Incluir mudanças de controle na fila de desfazer", + "Include Sends in Trim Mode" => "Incluir envios no modo Trim", + "Infinite" => "Infinito", + "Integration Time" => "Tempo de integração", + "Joining a Project Downloads All Shared Tracks" => "Entrar em um projeto baixa todas as pistas compartilhadas", + "K-12" => "K-12", + "K-14" => "K-14", + "K-20" => "K-20", + "Keep Most Recent Session Backups" => "Manter os backups de sessão mais recentes", + "Keep Unused Folders on Session Close" => "Manter pastas não usadas ao fechar a sessão", + "Latch Audio Tracks" => "Latch nas pistas de áudio", + "Latch Fast Forward and Rewind" => "Latch no avanço e retrocesso rápidos", + "Latch Switch Controls in Touch Mode" => "Latch nos controles de chave no modo Touch", + "Latch Until Next Event" => "Latch até o próximo evento", + "Levels of Undo" => "Níveis de desfazer", + "Linear Extended" => "Linear estendido", + "Linked Systems" => "Sistemas vinculados", + "Link Object and Audio Recording" => "Vincular objeto e gravação de áudio", + "Link Record and Play Faders" => "Vincular faders de gravação e reprodução", + "Live Peak" => "Pico ao vivo", + "Live RMS" => "RMS ao vivo", + "Local Waveform Cache Versions" => "Versões do cache local de formas de onda", + "Lock File Extension" => "Extensão do arquivo de bloqueio", + "Logging" => "Registro", + "Machine Chases Memory Location" => "A máquina persegue o local de memória", + "Machine Control" => "Controle de máquina", + "Machine Cues Intelligently" => "A máquina posiciona de forma inteligente", + "Machine Follows Edit Insertion and Scrub" => "A máquina acompanha a inserção de edição e o scrub", + "Manually" => "Manualmente", + "Marker Colors" => "Cores dos marcadores", + "Master Meters" => "Medidores master", + "Metering" => "Medição", + "Meter Type" => "Tipo de medidor", + "Middle C" => "Dó central", + "MIDI Beat Clock" => "Clock de batida MIDI", + "MIDI Input Monitoring Follows Selected Track" => "O monitoramento de entrada MIDI acompanha a pista selecionada", + "MIDI Merge Release Mode" => "Modo de liberação da mesclagem MIDI", + "MIDI Note 60" => "Nota MIDI 60", + "MIDI Note Color Shows Velocity" => "A cor das notas MIDI mostra a velocity", + "MIDI Notes and Controllers" => "Notas e controladores MIDI", + "MIDI / Score Editor Display" => "Exibição do editor MIDI / partitura", + "MIDI Timecode" => "Timecode MIDI", + "Minimum Sync Delay" => "Atraso mínimo de sincronização", + "Miscellaneous" => "Diversos", + "Mixing" => "Mixagem", + "Mix Window Follows Banking" => "A janela de mixagem acompanha a troca de banco", + "Mix Window Follows Selection" => "A janela de mixagem acompanha a seleção", + "Modern" => "Moderno", + "Mouse Wheel Scrolling Snaps to Track" => "A rolagem da roda do mouse se ajusta à pista", + "Mute Record-Armed Tracks While Stopped" => "Silenciar pistas armadas para gravação enquanto parado", + "Name Dialog" => "Diálogo de nome", + "New Session 5.x to 7.x/9.x" => "Nova sessão 5.x para 7.x/9.x", + "New Session 7.x/9.x to 5.x" => "Nova sessão 7.x/9.x para 5.x", + "New Session Fold Down" => "Downmix da nova sessão", + "New Session Includes LFE in Fold Down" => "A nova sessão inclui o LFE no downmix", + "New Session Surround to Stereo" => "Surround para estéreo da nova sessão", + "New Tracks Are Shared" => "Novas pistas são compartilhadas", + "New Tracks Default to Tick Timebase" => "Novas pistas usam base de tempo em ticks por padrão", + "No Change" => "Sem alteração", + "No Files" => "Nenhum arquivo", + "Noise Burst Peak Protection" => "Proteção de pico contra rajadas de ruído", + "Non-Linear Device" => "Dispositivo não linear", + "Non-Linear Transport Error Suppression" => "Supressão de erros de transporte não linear", + "Note Display" => "Exibição de notas", + "Number Keys 1–5 Control" => "Controle das teclas numéricas 1–5", + "Numeric Keypad" => "Teclado numérico", + "Offline Processing" => "Processamento offline", + "On Exiting Trim Mode" => "Ao sair do modo Trim", + "Online Recording Starts" => "A gravação online começa", + "Open Unresourced DSP Plugins as Native" => "Abrir plugins DSP sem recursos como nativos", + "Organize Plugin Menus By" => "Organizar os menus de plugins por", + "Organize Track I/O Menus By" => "Organizar os menus de E/S de pista por", + "Original Track Height While Pinned" => "Altura original da pista quando fixada", + "Parallel Task Optimization" => "Otimização de tarefas paralelas", + "Peak / Clip" => "Pico / clipe", + "Peak Hold" => "Retenção de pico", + "Pencil Resolution for Controller Data" => "Resolução do lápis para dados de controlador", + "Personalize the Experience" => "Personalizar a experiência", + "Play Start Follows Timeline Selection" => "O início da reprodução acompanha a seleção da linha do tempo", + "Play Start Latency" => "Latência de início da reprodução", + "Plugin Controls Default to Auto-Enabled" => "Controles de plugin ativados automaticamente por padrão", + "Polyphonic" => "Polifônico", + "PPM BBC" => "PPM BBC", + "PPM Digital" => "PPM digital", + "PPM DIN" => "PPM DIN", + "PPM EBU" => "PPM EBU", + "PPM Nordic" => "PPM nórdico", + "Preserve Fades when Editing" => "Preservar fades ao editar", + "Prevent Others from Overwriting an Open Session" => "Impedir que outros sobrescrevam uma sessão aberta", + "Prevent Tearing" => "Evitar rasgos de imagem", + "Priority Compressor/Limiter" => "Prioridade ao compressor/limitador", + "Priority Expander/Gate" => "Prioridade ao expansor/gate", + "Processing" => "Processamento", + "Processor" => "Processador", + "Punch In Frame Offset" => "Deslocamento de quadros do punch in", + "Punch Out Frame Offset" => "Deslocamento de quadros do punch out", + "Punch Recording Crossfade Length" => "Duração do crossfade da gravação punch", + "Randomize Marker Color Upon Creation" => "Sortear a cor do marcador ao criá-lo", + "Recall Memory Location at Original Track" => "Recuperar o local de memória na pista original", + "Receive Play Selections" => "Receber seleções de reprodução", + "Receive Solos" => "Receber solos", + "Record Enable Buttons" => "Botões de armar gravação", + "Reduce Visual Effects" => "Reduzir efeitos visuais", + "Remote Mode" => "Modo remoto", + "Remove Range Selection after Opening a MIDI or Score Editor" => "Remover a seleção de intervalo após abrir um editor MIDI ou de partitura", + "Remove Range Selection after Zooming In" => "Remover a seleção de intervalo após aumentar o zoom", + "Rendered File Bit Depth" => "Profundidade de bits do arquivo renderizado", + "Reserve Voices for Preview in Context" => "Reservar vozes para a prévia em contexto", + "Reset Advanced Meter Settings" => "Redefinir as configurações avançadas de medidores", + "Reset “Don’t Show This Again” Settings" => "Redefinir as configurações de “Não mostrar novamente”", + "Reset Logging" => "Redefinir o registro", + "RMS" => "RMS", + "Routing Coefficients" => "Coeficientes de roteamento", + "Sample Peak" => "Pico de amostra", + "Sample Rate Conversion Quality" => "Qualidade da conversão de taxa de amostragem", + "Save Logs" => "Salvar registros", + "Scroll to Track Banks Controllers" => "Rolar até o banco de pistas dos controladores", + "Send Fully Overlapped Clips to a Playlist While Editing" => "Enviar clipes totalmente sobrepostos para uma playlist ao editar", + "Send Fully Overlapped Clips to a Playlist While Recording" => "Enviar clipes totalmente sobrepostos para uma playlist ao gravar", + "Send Pans Default to Follow Main Pan" => "Pan dos envios segue o pan principal por padrão", + "Sends Default to" => "Envios padrão para", + "Separate Clip Operates on All Related Takes" => "Separar clipe atua em todos os takes relacionados", + "Separate Grid Settings when Zoomed In" => "Configurações de grade separadas com zoom aproximado", + "Set Servo Lock at Play" => "Definir o servo lock ao reproduzir", + "Show Dashboard After Closing a Session" => "Mostrar o painel inicial após fechar uma sessão", + "Show Dashboard Window at Startup" => "Mostrar a janela do painel inicial ao iniciar", + "Show Insert Assignment Gain Reduction Meter" => "Mostrar o medidor de redução de ganho na atribuição de inserts", + "Show Marker Lane Colors in Timeline Rulers" => "Mostrar as cores das faixas de marcadores nas réguas da linha do tempo", + "Show Marker Lane Colors in Tracks" => "Mostrar as cores das faixas de marcadores nas pistas", + "Show Send Assignment Level Meter" => "Mostrar o medidor de nível na atribuição de envios", + "Show Sound Libraries in Workspace Locations" => "Mostrar bibliotecas de sons nos locais do espaço de trabalho", + "Show Target Playlists after Sending a Clip Selection" => "Mostrar playlists de destino após enviar uma seleção de clipes", + "Show Track Gain Reduction Meter" => "Mostrar o medidor de redução de ganho da pista", + "Shuttle" => "Shuttle", + "Slewing" => "Slewing", + "Small" => "Pequena", + "Smart Tool Fade Adjustment" => "Ajuste de fade da ferramenta inteligente", + "Smooth and Thin Data after Pass" => "Suavizar e simplificar dados após a passagem", + "Solo Independent of Linked State" => "Solo independente do estado vinculado", + "Some" => "Alguns", + "Standard VCA Logic for Group Attributes" => "Lógica VCA padrão para atributos de grupo", + "Steep Breakpoint Smoothing Time" => "Tempo de suavização de pontos íngremes", + "Stop at Shuttle Speed Zero" => "Parar na velocidade zero do shuttle", + "Suppress Automation Write-To Warnings" => "Suprimir avisos de gravação de automação", + "Suppress Name Dialog when Creating New Playlists" => "Suprimir o diálogo de nome ao criar novas playlists", + "Tab Respects Breakpoints in Automation Lanes" => "Tab respeita os pontos nas faixas de automação", + "Tagged Loop Files Only" => "Somente arquivos de loop com marcação", + "Time Compression / Expansion" => "Compressão / expansão de tempo", + "Timeline Insertion and Play Start Follow Playback" => "A inserção na linha do tempo e o início da reprodução acompanham a reprodução", + "Time Mode" => "Modo de tempo", + "Time Stretch" => "Time stretch", + "Touch Timeout" => "Tempo limite do Touch", + "Track and Master Meter Types" => "Tipos de medidor de pista e master", + "Track and Master Meter Types Linked" => "Tipos de medidor de pista e master vinculados", + "Track Collaboration" => "Colaboração de pistas", + "Track Meters" => "Medidores de pista", + "Track Position Numbers Stay with Hidden Tracks" => "Os números de posição das pistas permanecem com as pistas ocultas", + "Track Type" => "Tipo de pista", + "Transmit Play Selections" => "Transmitir seleções de reprodução", + "Transmit Solos" => "Transmitir solos", + "Transport Record Lock" => "Bloqueio de gravação do transporte", + "UI Theme" => "Tema da interface", + "Use Absolute Pan Linking" => "Usar vinculação de pan absoluta", + "Use F11 for Wait for Note" => "Usar F11 para Aguardar nota", + "Use MIDI to Tap Tempo" => "Usar MIDI para marcar o andamento", + "User Media and Settings Location" => "Local da mídia e das configurações do usuário", + "Use Separate Play and Stop Keys" => "Usar teclas separadas de reproduzir e parar", + "Vertical MIDI Zoom" => "Zoom vertical MIDI", + "VU" => "VU", + "Warnings & Dialogs" => "Avisos e diálogos", + "Whole File" => "Arquivo inteiro", + "Zoom Presets" => "Predefinições de zoom", + "Zoom Toggle Follows Edit Selection" => "A alternância de zoom acompanha a seleção de edição", + "System" => "Sistema", + "Light" => "Claro", + "Dark" => "Escuro", + "Tracks and Groups" => "Pistas e grupos", + "MEMORY LOCATIONS" => "LOCAIS DE MEMÓRIA", + "UNDO HISTORY" => "HISTÓRICO DE DESFAZER", + "Import Audio" => "Importar áudio", + "Import MIDI" => "Importar MIDI", + "Open Session" => "Abrir sessão", + "Save Session As" => "Salvar sessão como", + "Repeat" => "Repetir", + "Quantize strength" => "Intensidade da quantização", + "Bounce" => "Bounce", + "Remove" => "Remover", + "Zeros" => "Zeros", + "Key" => "Tonalidade", + "Speed Ramp" => "Rampa de velocidade", + "times" => "vezes", + "Hz" => "Hz", + "Untitled" => "Sem título", + "Readout" => "Leitura", + "5 minutes" => "5 minutos", + "25 minutes" => "25 minutos", + "2.00 seconds" => "2,00 segundos", + "3 Seconds" => "3 segundos", + "1 — Shortest" => "1 — Mais curto", + "0 frames" => "0 quadros", + "30 frames" => "30 quadros", + "0 samples" => "0 amostras", + "100 dB in 1.00 s" => "100 dB em 1,00 s", + "Effect" => "Efeito", + "Mode" => "Modo", + "Mod Source" => "Fonte de modulação", + "HPF Slope" => "Inclinação do HPF", + "LPF Slope" => "Inclinação do LPF", + "Punch Recording" => "Gravação punch", + "Shift (seconds)" => "Deslocamento (segundos)", + "Store Plugin State" => "Armazenar estado do plugin", + "Tempo Sync" => "Sincronia de andamento", + "Waveform" => "Forma de onda", + "MusicXML" => "MusicXML", + "MusicXML..." => "MusicXML...", + "Export — MIDI" => "Exportar — MIDI", + "Export — MusicXML" => "Exportar — MusicXML", + "Export — Selected Tracks as New Session" => "Exportar — Pistas selecionadas como nova sessão", + "File — Print Score" => "Arquivo — Imprimir partitura", + "File — Save As Template" => "Arquivo — Salvar como modelo", + "Import — Clip Groups" => "Importar — Grupos de clipes", + "Import — Session Data" => "Importar — Dados de sessão", + "Import — Video" => "Importar — Vídeo", + "Track — Save Track Preset" => "Pista — Salvar predefinição de pista", + "Fill window with session (Alt+A)" => "Preencher a janela com a sessão (Alt+A)", + "Go to End (End)" => "Ir para o fim (End)", + "Loop Playback (Cmd+Shift+L)" => "Reproduzir em loop (Cmd+Shift+L)", + "Return to Zero (Home)" => "Voltar ao zero (Home)", + "Waveform zoom in (Cmd+Alt+])" => "Aumentar zoom da forma de onda (Cmd+Alt+])", + "Zoom in (Cmd+])" => "Aumentar zoom (Cmd+])", + "Zoom out (Cmd+[)" => "Diminuir zoom (Cmd+[)", + "Zoom Toggle (E)" => "Alternar zoom (E)", + "no group" => "sem grupo", + "nogrp" => "sgrp", + "aux" => "aux", + "master" => "master", + "audio" => "áudio", + "midi" => "midi", + "inst" => "inst", + "vca" => "vca", + "folder" => "pasta", + "video" => "vídeo", + "Select a MIDI clip (or a MIDI track) to edit its notes." => "Selecione um clipe MIDI (ou uma pista MIDI) para editar suas notas.", + "{} · {} Hz · {} · {} · {}" => "{} · {} Hz · {} · {} · {}", + "1 track" => "1 faixa", + "{n} tracks" => "{n} faixas", + "{undo} {ms:.1} ms/frame" => "{undo} {ms:.1} ms/quadro", + "{seconds:.2} s" => "{seconds:.2} s", + "♩ = {bpm:.2} {n}/{d}" => "♩ = {bpm:.2} {n}/{d}", + "{n} ch" => "{n} canais", + "{b}-bit" => "{b} bits", + "Send {which} to {name}: {db} dB\nClick for the send fader · drag vertically to adjust · Shift-drag for fine control · Alt-click for 0 dB · right-click for options" => { + "Envio {which} para {name}: {db} dB\nClique para abrir o fader do envio · arraste na vertical para ajustar · Shift-arraste para controle fino · Alt-clique para 0 dB · clique com o botão direito para opções" + } + "1 {what}" => "1 {what}", + "{n} {what}s" => "{n} {what}s", + "the clip \"{name}\"" => "o clipe \"{name}\"", + "the file \"{name}\"" => "o arquivo \"{name}\"", + "{clips} and {files}" => "{clips} e {files}", + "Remove {what} from the session?" => "Remover {what} da sessão?", + "a clip on the timeline, which is removed too." => "um clipe na linha do tempo, que também será removido.", + "{n} clips on the timeline, which are removed too." => "{n} clipes na linha do tempo, que também serão removidos.", + " It is used by {users}" => " Ele é usado por {users}", + " They are used by {users}" => " Eles são usados por {users}", + " \"{name}\" is used by {users}" => " \"{name}\" é usado por {users}", + " {n} of the files are used by {users}" => " {n} dos arquivos são usados por {users}", + " The file stays on disk." => " O arquivo permanece no disco.", + " The files stay on disk." => " Os arquivos permanecem no disco.", + _ => return error_translation(source), + }) +} + +macro_rules! error_templates { + ($($source:literal => $translation:literal,)*) => { + fn error_translation(source: &str) -> Option<&'static str> { + match source { + $($source => Some($translation),)* + _ => None, + } + } + + /// Engine error messages with `{name}` placeholders standing for the values they embed. The + /// UI matches a message against these templates and fills the translation with the values. + pub(super) const ERROR_TEMPLATES: &[(&str, &str)] = &[$(($source, $translation)),*]; + }; +} + +error_templates! { + "{path} is not valid Unicode" => "{path} não é Unicode válido", + "unknown command `{c}`" => "comando desconhecido `{c}`", + "`{c}` is not available: {why}" => "`{c}` não está disponível: {why}", + "bad parameters for `{c}`: {why}" => "parâmetros inválidos para `{c}`: {why}", + "unsupported: {why}" => "não suportado: {why}", + "internal error in `{c}`: {why}" => "erro interno em `{c}`: {why}", + "stop recording first" => "pare a gravação primeiro", + "journal entry cap" => "limite de entradas do diário atingido", + "MIDI file: more than {n} meter changes" => "arquivo MIDI: mais de {n} mudanças de compasso", + "MIDI file: more than {n} tempo changes" => "arquivo MIDI: mais de {n} mudanças de andamento", + "MIDI file: more than {n} tracks" => "arquivo MIDI: mais de {n} pistas", + "MIDI track {n}: longer than 24 hours" => "pista MIDI {n}: mais longa que 24 horas", + "none of the requested tracks hold MIDI" => "nenhuma das pistas pedidas contém MIDI", + "Clips/Markers is available only for Grid" => "Clipes/Marcadores só está disponível para Grade", + "Grid mode always snaps" => "o modo Grade sempre alinha", + "Shuffle is locked" => "o Shuffle está bloqueado", + "leave Shuffle mode before locking it" => "saia do modo Shuffle antes de bloqueá-lo", + "`at` required" => "`at` é obrigatório", + "`bars`/`beats` must describe a positive length" => "`bars`/`beats` devem descrever um comprimento positivo", + "`buffer_size` must be a number in 16..=8192 or null" => "`buffer_size` deve ser um número entre 16 e 8192 ou nulo", + "`bus` required" => "`bus` é obrigatório", + "`by` is required" => "`by` é obrigatório", + "`clip` id required" => "o id de `clip` é obrigatório", + "`clip` required" => "`clip` é obrigatório", + "`clips` must be an array of ids" => "`clips` deve ser uma lista de ids", + "`color` components must be integers 0..=255" => "os componentes de `color` devem ser inteiros de 0 a 255", + "`color` must be [r,g,b] or a palette index" => "`color` deve ser [r,g,b] ou um índice da paleta", + "`color` must be [r,g,b] or null" => "`color` deve ser [r,g,b] ou nulo", + "`db` (number) required" => "`db` (número) é obrigatório", + "`db` or `delta_db` required" => "`db` ou `delta_db` é obrigatório", + "`db` required" => "`db` é obrigatório", + "`device` must be a string or null" => "`device` deve ser texto ou nulo", + "`dir` required" => "`dir` é obrigatório", + "`end_bpm` required" => "`end_bpm` é obrigatório", + "`feet_frames` required (F+FF)" => "`feet_frames` é obrigatório (F+FF)", + "`folder` is not a folder track" => "`folder` não é uma pista de pasta", + "`folder` required" => "`folder` é obrigatório", + "`format` required" => "`format` é obrigatório", + "`from` slot" => "slot `from`", + "`to` slot" => "slot `to`", + "`index` required" => "`index` é obrigatório", + "`name` and `suffix` together must be at most {n} characters" => "`name` e `suffix` juntos devem ter no máximo {n} caracteres", + "`name` must not be empty" => "`name` não pode ficar vazio", + "`name` required" => "`name` é obrigatório", + "`new_name` required" => "`new_name` é obrigatório", + "`new_tracks: false` needs `track` or a selected audio track" => "`new_tracks: false` precisa de `track` ou de uma pista de áudio selecionada", + "`number`, `zeros` and `suffix` need a `name`" => "`number`, `zeros` e `suffix` precisam de um `name`", + "`pan` (number) required" => "`pan` (número) é obrigatório", + "`param` required" => "`param` é obrigatório", + "`params` must be an object" => "`params` deve ser um objeto", + "`params` must be an object of numbers" => "`params` deve ser um objeto de números", + "`path` or `paths` required" => "`path` ou `paths` é obrigatório", + "`path` required" => "`path` é obrigatório", + "`playlist` index required" => "o índice de `playlist` é obrigatório", + "`plugin` required" => "`plugin` é obrigatório", + "`process` required" => "`process` é obrigatório", + "`rows` must be an array" => "`rows` deve ser uma lista", + "`rows` must contain 1–128 rows" => "`rows` deve conter de 1 a 128 linhas", + "`slot` must be 0..{n} or a..j" => "`slot` deve ser de 0 a {n} ou de a a j", + "`slot` must be 0..{n} or a..{m}" => "`slot` deve ser de 0 a {n} ou de a a {m}", + "`slot` must be a number or a letter" => "`slot` deve ser um número ou uma letra", + "`slot` required" => "`slot` é obrigatório", + "`source` id required" => "o id de `source` é obrigatório", + "`state` is not valid base64 (or is too large)" => "`state` não é base64 válido (ou é grande demais)", + "`state` must be a base64 string or null" => "`state` deve ser texto base64 ou nulo", + "`timecode` required (HH:MM:SS:FF)" => "`timecode` é obrigatório (HH:MM:SS:FF)", + "`to` required" => "`to` é obrigatório", + "`track` is not a MIDI or instrument track" => "`track` não é uma pista MIDI ou de instrumento", + "`track` required" => "`track` é obrigatório", + "`tracks` must be an array of track ids or names" => "`tracks` deve ser uma lista de ids ou nomes de pistas", + "`value` must be a number" => "`value` deve ser um número", + "`value` required" => "`value` é obrigatório", + "`vca` must be a VCA Master track" => "`vca` deve ser uma pista VCA Master", + "`view` required" => "`view` é obrigatório", + "`{k}` must be an array of ids" => "`{k}` deve ser uma lista de ids", + "`{k}` required" => "`{k}` é obrigatório", + "`{k}` must be a number" => "`{k}` deve ser um número", + "`{k}` must be a whole number from 0 to {max}" => "`{k}` deve ser um número inteiro de 0 a {max}", + "`{k}` must be text" => "`{k}` deve ser texto", + "`{name}` is a hosted plugin; AudioSuite runs built-in plugins only (engine.plugins)" => "`{name}` é um plugin hospedado; o AudioSuite só executa plugins internos (engine.plugins)", + "`{path}` has no track named `{n}`" => "`{path}` não tem uma pista chamada `{n}`", + "`{plugin}` has no parameter `{k}`" => "`{plugin}` não tem o parâmetro `{k}`", + "`{plugin}` is not an instrument" => "`{plugin}` não é um instrumento", + "`{name}` has more than a day of clips to scan" => "`{name}` tem mais de um dia de clipes para analisar", + "`{name}` has no parameter `{param}`" => "`{name}` não tem o parâmetro `{param}`", + "`{name}` has no parameter(s): {list}" => "`{name}` não tem o(s) parâmetro(s): {list}", + "`{name}` is not a Video track" => "`{name}` não é uma pista de vídeo", + "`{name}` is not a built-in instrument" => "`{name}` não é um instrumento interno", + "`{name}` is used by {n} clip{plural} on the timeline; pass `with_clips: true` to remove them too" => "`{name}` é usado por {n} clipe{plural} na linha do tempo; passe `with_clips: true` para removê-los também", + "a bus named `{name}` exists" => "já existe um bus chamado `{name}`", + "a group named `{name}` already exists" => "já existe um grupo chamado `{name}`", + "a group needs at least one track" => "um grupo precisa de pelo menos uma pista", + "a single creation is limited to 128 tracks" => "uma única criação é limitada a 128 pistas", + "a track named `{name}` already exists" => "já existe uma pista chamada `{name}`", + "all insert slots are in use" => "todos os slots de inserção estão em uso", + "all send slots are in use" => "todos os slots de envio estão em uso", + "an output named `{name}` exists" => "já existe uma saída chamada `{name}`", + "analyse at most 20 minutes at a time" => "analise no máximo 20 minutos por vez", + "audio files go on audio tracks" => "arquivos de áudio vão em pistas de áudio", + "audio has no channels for clip `{name}`" => "o áudio não tem canais para o clipe `{name}`", + "audio unavailable for clip `{name}`" => "áudio indisponível para o clipe `{name}`", + "audio path escapes the group folder: {path}" => "o caminho do áudio sai da pasta do grupo: {path}", + "automation filesystem access is not granted: read authority is absent: {path}" => "o acesso do sistema de arquivos à automação não foi concedido: falta autorização de leitura: {path}", + "automation filesystem access is not granted: write authority is absent: {path}" => "o acesso do sistema de arquivos à automação não foi concedido: falta autorização de escrita: {path}", + "automation path rejected: a link that leads nowhere: {path}" => "caminho de automação rejeitado: um link que não leva a lugar nenhum: {path}", + "automation path rejected: cannot resolve {path}: {why}" => "caminho de automação rejeitado: não foi possível resolver {path}: {why}", + "automation path rejected: outside the read root {root}: {path}" => "caminho de automação rejeitado: fora da raiz de leitura {root}: {path}", + "automation path rejected: outside the read roots {root}: {path}" => "caminho de automação rejeitado: fora das raízes de leitura {root}: {path}", + "automation path rejected: outside the write root {root}: {path}" => "caminho de automação rejeitado: fora da raiz de escrita {root}: {path}", + "automation path rejected: outside the write roots {root}: {path}" => "caminho de automação rejeitado: fora das raízes de escrita {root}: {path}", + "automation path rejected: parent traversal below a folder that doesn't exist: {path}" => "caminho de automação rejeitado: navegação para o diretório pai abaixo de uma pasta que não existe: {path}", + "automation path rejected: reserved device names are not allowed: {path}" => "caminho de automação rejeitado: nomes de dispositivo reservados não são permitidos: {path}", + "bad feet" => "pés inválidos", + "bad frames" => "quadros inválidos", + "bit_depth must be 16, 24 or 32f" => "bit_depth deve ser 16, 24 ou 32f", + "bundle: {why}" => "pacote: {why}", + "cannot create `{id}`" => "não foi possível criar `{id}`", + "cannot write `{name}` files (supported: {list})" => "não é possível gravar arquivos `{name}` (suportados: {list})", + "clip fades cannot also specify tracks or an edit range" => "os fades de clipe não podem especificar também pistas ou um intervalo de edição", + "clip group file has too many clips" => "o arquivo de grupo de clipes tem clipes demais", + "clip has no length" => "o clipe não tem comprimento", + "clip must be an id" => "clip deve ser um id", + "clip not found" => "clipe não encontrado", + "curvature must be a finite number from -1 to 1" => "a curvatura deve ser um número finito de -1 a 1", + "curvature requires a clip and side" => "a curvatura exige um clipe e um lado", + "designate a target playlist first (Track › Designate as Target Playlist)" => "designe primeiro uma playlist de destino (Pista › Designar como playlist de destino)", + "each note needs `start` or `start_ticks`" => "cada nota precisa de `start` ou `start_ticks`", + "each row must be an object without nested rows" => "cada linha deve ser um objeto sem linhas aninhadas", + "empty send slot" => "slot de envio vazio", + "empty slot" => "slot vazio", + "factor must be a positive number" => "o fator deve ser um número positivo", + "feet must be 0.. and frames 0..15" => "os pés devem ser 0 ou mais e os quadros de 0 a 15", + "give `factor` (0.05..20) or a new `length`" => "informe `factor` (0,05 a 20) ou um novo `length`", + "give `start` and `end`" => "informe `start` e `end`", + "give `start` and `length` or `end`" => "informe `start` e `length` ou `end`", + "index out of range" => "índice fora do intervalo", + "length must be a positive sample count" => "o comprimento deve ser uma quantidade positiva de amostras", + "make a timeline selection first" => "faça primeiro uma seleção na linha do tempo", + "missing media: {list}" => "mídia ausente: {list}", + "mode must be shuffle|slip|spot|grid|relative_grid" => "o modo deve ser shuffle|slip|spot|grid|relative_grid", + "mode must be strip, extract or separate" => "o modo deve ser strip, extract ou separate", + "no MIDI or instrument tracks to notate" => "não há pistas MIDI ou de instrumento para notar", + "no audio file with id {id}" => "nenhum arquivo de áudio com o id {id}", + "no bus `{name}`" => "nenhum bus `{name}`", + "no bus named \"{name}\"" => "nenhum bus chamado \"{name}\"", + "no clip with id {id}" => "nenhum clipe com o id {id}", + "no clips" => "nenhum clipe", + "no clips selected" => "nenhum clipe selecionado", + "no clips to export" => "não há clipes para exportar", + "no markers on the clipboard (copy a range that contains markers)" => "não há marcadores na área de transferência (copie um intervalo que contenha marcadores)", + "no output `{name}`" => "nenhuma saída `{name}`", + "no path yet: pass `path` (Save As)" => "ainda não há caminho: informe `path` (Salvar como)", + "no such audio file" => "arquivo de áudio inexistente", + "no such clip" => "clipe inexistente", + "no such clip, or it is edit-locked" => "clipe inexistente ou bloqueado para edição", + "no such playlist" => "playlist inexistente", + "no such track" => "pista inexistente", + "no track" => "nenhuma pista", + "not a MIDI clip" => "não é um clipe MIDI", + "not a MIDI or instrument track" => "não é uma pista MIDI ou de instrumento", + "not a SoundCraft clip group file" => "não é um arquivo de grupo de clipes do SoundCraft", + "not a clip group file: {why}" => "não é um arquivo de grupo de clipes: {why}", + "not a regular file" => "não é um arquivo comum", + "not a take SoundCraft recorded" => "não é uma tomada gravada pelo SoundCraft", + "not in a folder SoundCraft records into" => "não está em uma pasta em que o SoundCraft grava", + "nothing to clear: pass `clips` or `sources`, or select them in the Clip List" => "nada para limpar: informe `clips` ou `sources`, ou selecione-os na Lista de clipes", + "nothing to import" => "nada para importar", + "nothing to move into that folder" => "nada para mover para essa pasta", + "only instrument tracks have a sampler" => "apenas pistas de instrumento têm sampler", + "only instrument tracks have an instrument" => "apenas pistas de instrumento têm instrumento", + "parameter(s) need a numeric value: {list}" => "o(s) parâmetro(s) precisam de um valor numérico: {list}", + "pass `start` and/or `end`" => "informe `start` e/ou `end`", + "read {a}; write {b}" => "leitura {a}; escrita {b}", + "record-enable (or pass) the audio tracks to prepare" => "habilite a gravação (ou informe) as pistas de áudio a preparar", + "score too large: over {n} bytes" => "partitura grande demais: mais de {n} bytes", + "select MIDI clips" => "selecione clipes MIDI", + "select a MIDI or instrument track" => "selecione uma pista MIDI ou de instrumento", + "select a VCA master" => "selecione um VCA master", + "select a clip" => "selecione um clipe", + "select a clip in the Clip List, or pass `clips`" => "selecione um clipe na Lista de clipes ou informe `clips`", + "select a range on the timeline" => "selecione um intervalo na linha do tempo", + "select a range to analyse" => "selecione um intervalo para analisar", + "select an audio clip" => "selecione um clipe de áudio", + "select an audio track to generate on" => "selecione uma pista de áudio para gerar", + "select audio clips first" => "selecione clipes de áudio primeiro", + "select audio on an audio track" => "selecione áudio em uma pista de áudio", + "select one or more aux input tracks" => "selecione uma ou mais pistas de entrada auxiliar", + "select some audio first" => "selecione algum áudio primeiro", + "select two or more clips" => "selecione dois ou mais clipes", + "selection is empty" => "a seleção está vazia", + "shape must be linear|equal power|s-curve|exponential|logarithmic" => "a forma deve ser linear|equal power|s-curve|exponential|logarithmic", + "side must be in or out" => "o lado deve ser in ou out", + "slot out of range" => "slot fora do intervalo", + "source channel unavailable" => "canal de origem indisponível", + "source_bpm must be 5..1000" => "source_bpm deve estar entre 5 e 1000", + "split would copy too much audio" => "a divisão copiaria áudio demais", + "stretch ratio {ratio} is outside 0.1..10" => "a razão de esticamento {ratio} está fora de 0,1 a 10", + "that playlist is already active" => "essa playlist já está ativa", + "the Video track has no clips" => "a pista de vídeo não tem clipes", + "the clip has no clip effects" => "o clipe não tem efeitos de clipe", + "the clip is locked" => "o clipe está bloqueado", + "the clip is too long to stretch: one render holds at most {secs} s of {channels}-channel audio" => "o clipe é longo demais para esticar: uma renderização comporta no máximo {secs} s de áudio de {channels} canais", + "the clip's audio is not loaded" => "o áudio do clipe não está carregado", + "the clips can't land there: past the last track, or on a track that can't hold them" => "os clipes não podem ficar ali: além da última pista ou em uma pista que não os comporta", + "the range contains more than 10,000 grid boundaries" => "o intervalo contém mais de 10.000 limites de grade", + "the sampler has no parameter `{k}`" => "o sampler não tem o parâmetro `{k}`", + "the sampler is not available" => "o sampler não está disponível", + "the scan was stopped" => "a análise foi interrompida", + "the selection is empty" => "a seleção está vazia", + "the selection is not a looped clip" => "a seleção não é um clipe em loop", + "the selection is too short" => "a seleção é curta demais", + "the selection must cover a clip start, end or the boundary between two clips" => "a seleção deve cobrir o início ou o fim de um clipe, ou o limite entre dois clipes", + "the session has no Video track" => "a sessão não tem pista de vídeo", + "the target length must be between 1 sample and {secs} s" => "o comprimento de destino deve ficar entre 1 amostra e {secs} s", + "the target playlist is the main playlist" => "a playlist de destino é a playlist principal", + "the track has no instrument" => "a pista não tem instrumento", + "the track has no playlist" => "a pista não tem playlist", + "the track's instrument is not the sampler" => "o instrumento da pista não é o sampler", + "there is no audio to prepare" => "não há áudio a preparar", + "too many tempo events: use a coarser resolution" => "eventos de andamento demais: use uma resolução mais grossa", + "too much audio to generate in one command" => "áudio demais para gerar em um único comando", + "unknown `group`" => "`group` desconhecido", + "unknown action `{name}`" => "ação desconhecida `{name}`", + "unknown automation param `{name}`" => "parâmetro de automação desconhecido `{name}`", + "unknown bus `{name}`" => "bus desconhecido `{name}`", + "unknown field `{k}`: an instrument's parameters go in `params` ({{id: value}}), or one at a time in mix.instrument_param" => "campo desconhecido `{k}`: os parâmetros de um instrumento vão em `params` ({{id: valor}}), ou um de cada vez em mix.instrument_param", + "unknown focus `{name}`" => "foco desconhecido `{name}`", + "unknown fold_down `{name}` (use \"stereo\")" => "fold_down desconhecido `{name}` (use \"stereo\")", + "unknown format" => "formato desconhecido", + "unknown format `{name}`" => "formato desconhecido `{name}`", + "unknown grid value or format" => "valor ou formato de grade desconhecido", + "unknown height" => "altura desconhecida", + "unknown kind `{name}`" => "tipo desconhecido `{name}`", + "unknown memory location (give `number`, `id` or `name`)" => "local de memória desconhecido (informe `number`, `id` ou `name`)", + "unknown mode" => "modo desconhecido", + "unknown mode `{name}`" => "modo desconhecido `{name}`", + "unknown nudge value or format" => "valor ou formato de nudge desconhecido", + "unknown plugin" => "plugin desconhecido", + "unknown plugin `{name}`" => "plugin desconhecido `{name}`", + "unknown process `{name}`" => "processo desconhecido `{name}`", + "unknown ruler" => "régua desconhecida", + "unknown tool" => "ferramenta desconhecida", + "unknown track" => "pista desconhecida", + "unknown view `{name}`" => "visualização desconhecida `{name}`", + "use F+FF, e.g. 12+08" => "use F+FF, por exemplo 12+08", + "{name}: file is too large to import" => "{name}: o arquivo é grande demais para importar", + "{name}: no audio" => "{name}: sem áudio", + "{name}: too long for a sample (ten minutes of 192 kHz stereo at most)" => "{name}: longo demais para um sample (no máximo dez minutos de estéreo a 192 kHz)", + "{path}: not a SoundCraft track preset" => "{path}: não é um preset de pista do SoundCraft", + "{path}: not a regular file" => "{path}: não é um arquivo comum", + "{path}: too large to import" => "{path}: grande demais para importar", + "{name} (video): {why}" => "{name} (vídeo): {why}", + "{path} already exists: pass `replace: true` to replace it" => "{path} já existe: passe `replace: true` para substituí-lo", + "“{name}” would need {reps} loops to fill that; a clip loops at most {max} times" => "“{name}” precisaria de {reps} repetições para preencher isso; um clipe repete no máximo {max} vezes", +} diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index 28268906..295b5d5d 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -139,6 +139,7 @@ impl SoundApp { /// Each host iteration starts with `raw_input_hook`; its editor-poll admission prevents an /// empty queue on a discarded pass from ending a still-active plugin gesture. pub fn logic(&mut self, ctx: &egui::Context) { + let _language = crate::localization::enter(self.ui.language); self.ui.undo_levels = self.ui.undo_levels.clamp(1, 64); self.engine.set_history_limit(self.ui.undo_levels); // Fonts set now take effect next frame, so draw only from the frame after. @@ -244,6 +245,7 @@ impl SoundApp { /// Lay out the whole window. pub fn ui(&mut self, ui: &mut egui::Ui) { + let _language = crate::localization::enter(self.ui.language); let ctx = ui.ctx().clone(); // egui just processed the scripted key events. A scripted release while the host still // physically holds the key would report it up; put the host-only state back before any diff --git a/crates/ui-egui/src/app/audio.rs b/crates/ui-egui/src/app/audio.rs index 3ec92849..75ef5012 100644 --- a/crates/ui-egui/src/app/audio.rs +++ b/crates/ui-egui/src/app/audio.rs @@ -13,7 +13,7 @@ impl SoundApp { /// then stays the configuration of the open device. pub fn apply_audio_config(&mut self, cfg: soundcraft_playback::AudioConfig) -> Result<(), String> { if self.engine.transport.recording { - return Err("stop recording before changing the audio device".into()); + return Err(crate::localization::text("stop recording before changing the audio device").into()); } self.ui.audio = cfg; let at = self.position(); @@ -46,7 +46,7 @@ impl SoundApp { } Err(e) => { self.recorder_failed = true; - self.ui.status = format!("No audio input: {e}"); + self.ui.status = crate::localized_format!("No audio input: {e}", e = e); } } } @@ -58,24 +58,28 @@ impl SoundApp { let name = p.device_name.clone(); let (cause, then) = match trouble { OutputTrouble::Bug => ( - "the audio engine hit an internal error (see the log)".to_string(), - "Use Reconnect audio device in Setup › Playback Engine, or restart SoundCraft.", + crate::localization::text("the audio engine hit an internal error (see the log)").to_string(), + crate::localization::text("Use Reconnect audio device in Setup › Playback Engine, or restart SoundCraft."), + ), + OutputTrouble::Gone => ( + format!("“{}” {}", name, crate::localization::text("is unavailable")), + crate::localization::text("Check the audio device, then use Reconnect audio device in Setup › Playback Engine."), + ), + OutputTrouble::Stalled => ( + format!("“{}” {}", name, crate::localization::text("stopped asking for audio")), + crate::localization::text("Use Reconnect audio device in Setup › Playback Engine."), ), - OutputTrouble::Gone => { - (format!("“{name}” is unavailable"), "Check the audio device, then use Reconnect audio device in Setup › Playback Engine.") - } - OutputTrouble::Stalled => (format!("“{name}” stopped asking for audio"), "Use Reconnect audio device in Setup › Playback Engine."), }; let (recording, playing) = (self.engine.transport.recording, self.engine.transport.playing); if recording || playing { self.stop_play(); } self.ui.status = if recording { - format!("Recording stopped: {cause}. The take is kept up to there. {then}") + crate::localized_format!("Recording stopped: {cause} The take is kept up to there. {then}", cause = cause, then = then) } else if playing { - format!("Playback stopped: {cause}. {then}") + crate::localized_format!("Playback stopped: {cause} {then}", cause = cause, then = then) } else { - format!("Audio output: {cause}. {then}") + crate::localized_format!("Audio output: {cause} {then}", cause = cause, then = then) }; } @@ -88,7 +92,7 @@ impl SoundApp { let lost = r.lost_ms(); if recording && lost > self.lost_shown { self.lost_shown = lost; - self.ui.status = format!("The disk is too slow: this take has lost {lost} ms of input so far."); + self.ui.status = crate::localized_format!("The disk is too slow: this take has lost {lost} ms of input so far.", lost = lost); } return; }; @@ -99,14 +103,14 @@ impl SoundApp { Trouble::Device(what) => { self.recorder = None; self.recorder_failed = true; - (what, "Reconnect it, then use Reconnect audio device in Setup › Playback Engine.") + (what, crate::localization::text("Reconnect it, then use Reconnect audio device in Setup › Playback Engine.")) } - Trouble::Disk(what) => (what, "Check the disk, then record again."), + Trouble::Disk(what) => (what, crate::localization::text("Check the disk, then record again.")), }; self.ui.status = if recording { - format!("Recording stopped: {what}. The take is kept up to there. {then}") + crate::localized_format!("Recording stopped: {what} The take is kept up to there. {then}", what = what, then = then) } else { - format!("Audio input: {what}. {then}") + crate::localized_format!("Audio input: {what} {then}", what = what, then = then) }; } diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index 42a74ce8..8442457c 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -3,6 +3,7 @@ use super::{SoundApp, Value, bounce, menus}; impl SoundApp { /// Run a command; errors go to the status line. Returns the result. pub fn run(&mut self, id: &str, params: Value) -> Result { + let _language = crate::localization::enter(self.ui.language); if matches!(id, "session.new" | "session.open" | "session.close" | "session.revert") && bounce::refuses_session_switch(self) { return Err(self.ui.status.clone()); } @@ -39,7 +40,7 @@ impl SoundApp { Ok(v) } Err(e) => { - self.ui.status = e.to_string(); + self.ui.status = crate::localization::error_text(&e.to_string()); log::warn!("{id}: {e}"); Err(e.to_string()) } diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs index 56dcf873..6caa4137 100644 --- a/crates/ui-egui/src/app/files.rs +++ b/crates/ui-egui/src/app/files.rs @@ -37,7 +37,7 @@ impl SoundApp { /// plugins' own state reaches the session every two minutes (`autosave`). pub(super) fn autosave_changes(&mut self) { if let Some(e) = self.autosaver.as_ref().and_then(soundcraft_engine::autosave::Autosaver::failure) { - self.ui.status = format!("Autosave failed: {e}"); + self.ui.status = crate::localized_format!("Autosave failed: {e}", e = e); } if self.autosave_dir.is_none() || self.engine.revision == self.autosaved_rev { return; @@ -63,7 +63,7 @@ impl SoundApp { let Some(w) = &self.autosaver else { return false }; let written = w.flush(); if let Err(e) = &written { - self.ui.status = format!("Autosave failed: {e}"); + self.ui.status = crate::localized_format!("Autosave failed: {e}", e = e); } written.is_ok() } @@ -108,16 +108,19 @@ impl SoundApp { self.panic_rev = self.engine.revision; let saved = self.engine.is_dirty() && self.write_autosave(); self.ui.status = if saved { - "SoundCraft hit an internal error (see the log). Your changes were autosaved: save them, then restart SoundCraft.".into() + crate::localization::text( + "SoundCraft hit an internal error (see the log). Your changes were autosaved: save them, then restart SoundCraft.", + ) + .into() } else { - "SoundCraft hit an internal error (see the log). Restart SoundCraft to be safe.".into() + crate::localization::text("SoundCraft hit an internal error (see the log). Restart SoundCraft to be safe.").into() }; } /// Replace the open session with unsaved work an earlier run left behind. pub fn recover(&mut self, left: &soundcraft_engine::autosave::Leftover) { if self.engine.transport.recording { - self.ui.status = "Stop recording before recovering other work.".into(); + self.ui.status = crate::localization::text("Stop recording before recovering other work.").into(); return; } self.close_autosave(); @@ -128,11 +131,15 @@ impl SoundApp { soundcraft_engine::autosave::discard(left); } self.ui.status = match missing.len() { - 0 => format!("Recovered “{}”. Save it to keep the changes.", left.name), - n => format!("Recovered “{}”, but {n} audio file(s) are missing. Save it to keep the changes.", left.name), + 0 => crate::localized_format!("Recovered “{name}”. Save it to keep the changes.", name = left.name), + n => crate::localized_format!( + "Recovered “{name}”, but {n} audio file(s) are missing. Save it to keep the changes.", + name = left.name, + n = n + ), }; } - Err(e) => self.ui.status = format!("Couldn't recover “{}”: {e}", left.name), + Err(e) => self.ui.status = crate::localized_format!("Couldn't recover “{name}”: {e}", name = left.name, e = e), } } diff --git a/crates/ui-egui/src/app/input.rs b/crates/ui-egui/src/app/input.rs index c6167d5a..2827aad3 100644 --- a/crates/ui-egui/src/app/input.rs +++ b/crates/ui-egui/src/app/input.rs @@ -153,7 +153,7 @@ impl SoundApp { let r = self.run("mix.sampler_load", json!({"track": track.0, "path": path})); self.sample_loaded(track, path, r); } - Err(e) => self.ui.status = e.to_string(), + Err(e) => self.ui.status = crate::localization::error_text(&e.to_string()), } } else { self.sample_reads.push(sampler_window::SampleRead { track, file }); diff --git a/crates/ui-egui/src/app/playback.rs b/crates/ui-egui/src/app/playback.rs index 645a0d5f..35d79630 100644 --- a/crates/ui-egui/src/app/playback.rs +++ b/crates/ui-egui/src/app/playback.rs @@ -92,9 +92,9 @@ impl SoundApp { let armed = self.engine.session().tracks.iter().any(|t| t.mixer.record_arm); if !armed { let why = if self.engine.session().tracks.is_empty() { - "Nothing to record on yet: add a track with Track › New…, then click its R button." + crate::localization::text("Nothing to record on yet: add a track with Track › New…, then click its R button.") } else { - "No track is record-enabled: click the R button on the track to record." + crate::localization::text("No track is record-enabled: click the R button on the track to record.") }; self.ui.status = why.into(); self.record_hint = Some((self.last_frame.unwrap_or_default(), why)); @@ -104,7 +104,7 @@ impl SoundApp { let takes = match self.arm_recorder() { Ok(takes) => takes, Err(err) => { - self.ui.status = format!("Cannot record: {err}"); + self.ui.status = crate::localized_format!("Cannot record: {err}", err = err); return; } }; @@ -163,10 +163,10 @@ impl SoundApp { None if self.engine.path.is_some() => std::path::PathBuf::new(), None => self.fallback_take_dir()?, }; - let Some(r) = &mut self.recorder else { return Err("no audio input device".into()) }; + let Some(r) = &mut self.recorder else { return Err(crate::localization::text("no audio input device").into()) }; let plan = soundcraft_engine::io::plan_takes(&self.engine, &unsaved_dir, r.channels); if plan.is_empty() { - return Err("no audio track is record-enabled".into()); + return Err(crate::localization::text("no audio track is record-enabled").into()); } // The takes are unsaved work: on Unix the folder they go into is owner-only, like the // autosaves, before the recorder makes anything in it (other systems get the folder's @@ -216,8 +216,11 @@ impl SoundApp { self.punch = None; self.autosaved_rev = 0; let ids = soundcraft_engine::io::place_recording(&mut self.engine, &plan, takes); - self.ui.status = - if plan.pass.is_some() { format!("Loop-recorded {} take(s)", ids.len() / tracks) } else { format!("Recorded {} clip(s)", ids.len()) }; + self.ui.status = if plan.pass.is_some() { + crate::localized_format!("Loop-recorded {} take(s)", ids.len() / tracks) + } else { + crate::localized_format!("Recorded {} clip(s)", ids.len()) + }; if let Some(p) = problem { log::warn!("recording: {p}"); self.ui.status = format!("{} ({p})", self.ui.status); diff --git a/crates/ui-egui/src/app/plugins.rs b/crates/ui-egui/src/app/plugins.rs index 19feaee7..d7f8ac17 100644 --- a/crates/ui-egui/src/app/plugins.rs +++ b/crates/ui-egui/src/app/plugins.rs @@ -75,7 +75,11 @@ impl SoundApp { { match p.open_editor(track, slot) { Ok(()) => return, - Err(e) => self.ui.status = format!("{}: {e}", mix_window::plugin_info(&plugin).map_or(plugin.as_str(), |i| i.name)), + Err(e) => { + let name = mix_window::plugin_info(&plugin).map_or(plugin.as_str(), |i| i.name); + let reason = crate::localization::error_text(&e.to_string()); + self.ui.status = format!("{name}: {reason}"); + } } } if !self.ui.plugin_windows.contains(&(track, slot)) { @@ -130,5 +134,9 @@ pub(crate) fn failed_plugin_status(s: &soundcraft_model::Session, track: TrackId let t = s.track(track)?; let ins = if slot == soundcraft_mix::INSTRUMENT_SLOT { t.instrument.as_ref() } else { t.mixer.inserts.get(slot)?.as_ref() }?; let name = crate::mix_window::plugin_info(&ins.plugin).map_or(ins.plugin.as_str(), |p| p.name); - Some(format!("{name} on {} put out invalid audio, so it is bypassed until playback stops or starts again.", t.name)) + Some(crate::localized_format!( + "{name} on {track} put out invalid audio, so it is bypassed until playback stops or starts again.", + name = name, + track = t.name + )) } diff --git a/crates/ui-egui/src/bounce.rs b/crates/ui-egui/src/bounce.rs index 480c2a02..04e75ecf 100644 --- a/crates/ui-egui/src/bounce.rs +++ b/crates/ui-egui/src/bounce.rs @@ -8,14 +8,14 @@ use serde_json::Value; /// Starts the bounce `file.bounce_mix` runs for `params`; [`step`] renders it. pub fn start(app: &mut SoundApp, params: &Value) { if app.bounce.is_some() { - app.ui.status = "A bounce is already running".into(); + app.ui.status = crate::localization::text("A bounce is already running").into(); return; } // Third-party plugins keep state the session can't see: store it first. app.capture_plugin_states(); match soundcraft_engine::cmd::bounce_job(&app.engine, params) { Ok(job) => app.bounce = Some(job), - Err(e) => app.ui.status = e.to_string(), + Err(e) => app.ui.status = crate::localization::error_text(&e.to_string()), } } @@ -29,9 +29,14 @@ pub fn step(app: &mut SoundApp, ctx: &egui::Context) { return; } Ok(Some(done)) => { - format!("Bounced {} (peak {:.1} dBFS, {:.1} LUFS)", job.path().file_name().unwrap_or_default().to_string_lossy(), done.peak_db, done.lufs) + crate::localized_format!( + "Bounced {} (peak {:.1} dBFS, {:.1} LUFS)", + job.path().file_name().unwrap_or_default().to_string_lossy(), + done.peak_db, + done.lufs + ) } - Err(e) => e.to_string(), + Err(e) => crate::localization::error_text(&e.to_string()), }; app.bounce = None; } @@ -40,7 +45,7 @@ pub fn step(app: &mut SoundApp, ctx: &egui::Context) { /// out of memory. True when refused; the status line says why. pub fn refuses_session_switch(app: &mut SoundApp) -> bool { if app.bounce.is_some() { - app.ui.status = "Finish or cancel the bounce first".into(); + app.ui.status = crate::localization::text("Finish or cancel the bounce first").into(); } app.bounce.is_some() } @@ -70,15 +75,15 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { ui.spacing_mut().item_spacing = egui::vec2(8.0, 8.0); ui.set_width(320.0); let name = job.path().file_name().unwrap_or_default().to_string_lossy(); - ui.label(egui::RichText::new(format!("Bouncing {name}")).font(bold(13.0))); + ui.label(egui::RichText::new(crate::localized_format!("Bouncing {name}", name = name)).font(bold(13.0))); ui.add(egui::ProgressBar::new(job.progress())); ui.horizontal(|ui| { - cancel |= ui.button("Cancel").clicked(); + cancel |= ui.button(crate::localization::text("Cancel")).clicked(); ui.label(egui::RichText::new(format!("{:.0}%", job.progress() * 100.0)).color(Tokens::current().text_dim)); }); }); if cancel { app.bounce = None; - app.ui.status = "Bounce cancelled".into(); + app.ui.status = crate::localization::text("Bounce cancelled").into(); } } diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index e61a02ef..fa180245 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -824,24 +824,8 @@ fn encode(img: &egui::ColorImage, path: Option<&str>, token: u64) -> Value { } } -/// Minimal base64 (standard alphabet) to avoid another dependency. -pub fn base64(data: &[u8]) -> String { - const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - let mut out = String::with_capacity(data.len().div_ceil(3) * 4); - for chunk in data.chunks(3) { - let b = [chunk.first().copied().unwrap_or(0), chunk.get(1).copied().unwrap_or(0), chunk.get(2).copied().unwrap_or(0)]; - let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]); - for i in 0..4 { - if i <= chunk.len() { - let idx = ((n >> (18 - 6 * i)) & 63) as usize; - out.push(char::from(T.get(idx).copied().unwrap_or(b'A'))); - } else { - out.push('='); - } - } - } - out -} +/// Standard padded Base64 without line wrapping, shared across Craft apps. +pub use craft_mime::transfer::base64; #[cfg(test)] mod tests; diff --git a/crates/ui-egui/src/control/tests.rs b/crates/ui-egui/src/control/tests.rs index 1f188327..e12545ff 100644 --- a/crates/ui-egui/src/control/tests.rs +++ b/crates/ui-egui/src/control/tests.rs @@ -899,3 +899,19 @@ fn scroll_reports_the_wheel_and_trackpad_sources_after_delivery() { let v = reply.try_recv().expect("trackpad scroll replies after its events were applied"); assert_eq!(v["result"]["source"], "trackpad"); } + +#[test] +fn shared_base64_retains_control_wire_bytes() { + assert_eq!(super::base64(b""), ""); + assert_eq!(super::base64(b"f"), "Zg=="); + assert_eq!(super::base64(b"fo"), "Zm8="); + assert_eq!(super::base64(b"foo"), "Zm9v"); + assert_eq!(super::base64(&[251, 255, 255]), "+///"); + let bytes: Vec = (0..=255).cycle().take(513).collect(); + for len in 0..=bytes.len() { + let encoded = super::base64(&bytes[..len]); + assert_eq!(encoded.len(), len.div_ceil(3) * 4); + assert!(!encoded.contains(['\r', '\n'])); + assert_eq!(craft_mime::base64::STANDARD.decode(&encoded).unwrap(), bytes[..len]); + } +} diff --git a/crates/ui-egui/src/credits.rs b/crates/ui-egui/src/credits.rs index f8d9a507..9feb73a3 100644 --- a/crates/ui-egui/src/credits.rs +++ b/crates/ui-egui/src/credits.rs @@ -123,7 +123,7 @@ impl Contributor { /// One line with everything we know, for tooltips. pub fn summary(&self) -> String { - format!( + crate::localized_format!( "@{}: {} PRs, {} commits, +{} / −{} lines (Δ {}), +{} / −{} binary assets, {} – {}", self.login, self.prs, @@ -213,31 +213,31 @@ impl Default for View { /// Controls for name style, sort key and sort direction above the contributor table. fn contributors_toolbar(ui: &mut egui::Ui, v: &mut View) { ui.horizontal_wrapped(|ui| { - ui.label("Show"); + ui.label(crate::localization::text("Show")); for m in NameMode::ALL { - if ui.selectable_label(v.names == m, m.label()).clicked() { + if ui.selectable_label(v.names == m, crate::localization::text(m.label())).clicked() { v.names = m; } } ui.separator(); - let sort = ui.label("Sort"); - let combo = craft_ui::ComboBox::from_id_salt("credits_sort").selected_text(v.key.label().0).show_ui(ui, |ui| { + let sort = ui.label(crate::localization::text("Sort")); + let combo = craft_ui::ComboBox::from_id_salt("credits_sort").selected_text(crate::localization::text(v.key.label().0)).show_ui(ui, |ui| { for k in SortKey::ALL { - if ui.selectable_label(v.key == k, k.label().0).clicked() { + if ui.selectable_label(v.key == k, crate::localization::text(k.label().0)).clicked() { v.key = k; v.ascending = k.default_ascending(); } } }); combo.response.labelled_by(sort.id); - if ui.button(if v.ascending { "⏶" } else { "⏷" }).on_hover_text("Reverse the order").clicked() { + if ui.button(if v.ascending { "⏶" } else { "⏷" }).on_hover_text(crate::localization::text("Reverse the order")).clicked() { v.ascending = !v.ascending; } ui.separator(); - if ui.selectable_label(!v.table, "Grab bag").clicked() { + if ui.selectable_label(!v.table, crate::localization::text("Grab bag")).clicked() { v.table = false; } - if ui.selectable_label(v.table, "Table").clicked() { + if ui.selectable_label(v.table, crate::localization::text("Table")).clicked() { v.table = true; } }); @@ -247,7 +247,7 @@ fn contributors_grab_bag(ui: &mut egui::Ui, list: &[&Contributor], names: NameMo ui.horizontal_wrapped(|ui| { for (i, c) in list.iter().enumerate() { if i > 0 { - ui.label(RichText::new("·").weak()); + ui.label(RichText::new(crate::localization::text("·")).weak()); } ui.hyperlink_to(c.name(names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary()); } @@ -260,10 +260,10 @@ pub fn contributors_ui(ui: &mut egui::Ui) { let mut v = ui.data_mut(|d| d.get_temp::(id)).unwrap_or_default(); contributors_toolbar(ui, &mut v); let list = sorted(CONTRIBUTORS, v.names, v.key, v.ascending); - ui.label(RichText::new(format!("{} contributors · {} commits", list.len(), group(TOTAL_COMMITS))).small().weak()); + ui.label(RichText::new(crate::localized_format!("{} contributors · {} commits", list.len(), group(TOTAL_COMMITS))).small().weak()); ui.separator(); if list.is_empty() { - ui.label("No contributor data was built into this copy."); + ui.label(crate::localization::text("No contributor data was built into this copy.")); } else if v.table { // The table scrolls vertically itself, under a fixed header; it only scrolls sideways // once its columns are dragged wider than the dialog. @@ -372,7 +372,7 @@ fn cells(c: &Contributor) -> [String; 9] { /// A contributor-table header. The sorted column is highlighted; its direction shows on the /// toolbar's sort-order button, so no arrow widens the column. fn header_text(k: SortKey) -> RichText { - RichText::new(k.label().1).strong() + RichText::new(crate::localization::text(k.label().1)).strong() } fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) { @@ -390,7 +390,8 @@ fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) { .header(h + 4.0, |mut header| { for k in SortKey::ALL { header.col(|ui| { - let r = aligned(ui, k != SortKey::Name, |ui| ui.selectable_label(v.key == k, header_text(k))).on_hover_text(k.label().0); + let r = aligned(ui, k != SortKey::Name, |ui| ui.selectable_label(v.key == k, header_text(k))) + .on_hover_text(crate::localization::text(k.label().0)); if r.clicked() { if v.key == k { @@ -423,7 +424,7 @@ fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) { /// About ▸ Models: AI models credited in Co-Authored-By trailers. pub fn models_ui(ui: &mut egui::Ui) { if MODELS.is_empty() { - ui.label("No model credits were built into this copy."); + ui.label(crate::localization::text("No model credits were built into this copy.")); return; } let assisted: u64 = MODELS.iter().map(|m| m.commits).max().unwrap_or(0).max(1); @@ -447,14 +448,14 @@ pub fn models_ui(ui: &mut egui::Ui) { let widths: Vec = titles .iter() .enumerate() - .map(|(i, title)| natural(ui, RichText::new(*title).strong(), rows.iter().filter_map(|r| r.get(i).cloned()))) + .map(|(i, title)| natural(ui, RichText::new(crate::localization::text(title)).strong(), rows.iter().filter_map(|r| r.get(i).cloned()))) .collect(); egui::ScrollArea::horizontal().id_salt("credits_models").auto_shrink([false, false]).show(ui, |ui| { fitted_table(ui, "credits_models", &widths, &MODEL_GROW) .header(h + 4.0, |mut header| { for (title, r) in titles.into_iter().zip(right) { header.col(|ui| { - aligned(ui, r, |ui| ui.label(RichText::new(title).strong())); + aligned(ui, r, |ui| ui.label(RichText::new(crate::localization::text(title)).strong())); }); } }) diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 360bb0ab..832e5b51 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -268,33 +268,43 @@ fn clear_message(s: &Session, clips: &[ClipId], sources: &[SourceId]) -> Option< let listed: std::collections::BTreeSet = clips.iter().copied().collect(); let names: Vec<&str> = s.tracks.iter().flat_map(|t| t.clips()).filter(|c| listed.contains(&c.id)).map(|c| c.name.as_str()).collect(); let files: Vec<_> = sources.iter().filter_map(|id| s.source(*id)).collect(); - let count = |n: usize, what: &str| if n == 1 { format!("1 {what}") } else { format!("{n} {what}s") }; + let count = |n: usize, what: &str| { + if n == 1 { crate::localized_format!("1 {what}", what = what) } else { crate::localized_format!("{n} {what}s", n = n, what = what) } + }; let what = match (names.as_slice(), files.as_slice()) { ([], []) => return None, - ([name], []) => format!("the clip \"{name}\""), - ([], [f]) => format!("the file \"{}\"", f.name), - (c, []) => count(c.len(), "clip"), - ([], f) => count(f.len(), "file"), - (c, f) => format!("{} and {}", count(c.len(), "clip"), count(f.len(), "file")), + ([name], []) => crate::localized_format!("the clip \"{name}\"", name = name), + ([], [f]) => crate::localized_format!("the file \"{name}\"", name = f.name), + (c, []) => count(c.len(), crate::localization::text("clip")), + ([], f) => count(f.len(), crate::localization::text("file")), + (c, f) => crate::localized_format!( + "{clips} and {files}", + clips = count(c.len(), crate::localization::text("clip")), + files = count(f.len(), crate::localization::text("file")) + ), }; - let mut text = format!("Remove {what} from the session?"); + let mut text = crate::localized_format!("Remove {what} from the session?", what = what); let used: Vec<(&str, usize)> = files.iter().map(|f| (f.name.as_str(), s.clips_using(f.id).filter(|c| !listed.contains(&c.id)).count())).filter(|(_, n)| *n > 0).collect(); let n: usize = used.iter().map(|u| u.1).sum(); let users = if n == 1 { - "a clip on the timeline, which is removed too.".to_string() + crate::localization::text("a clip on the timeline, which is removed too.").to_owned() } else { - format!("{n} clips on the timeline, which are removed too.") + crate::localized_format!("{n} clips on the timeline, which are removed too.", n = n) }; match used.as_slice() { [] => {} - [_] if files.len() == 1 => text += &format!(" It is used by {users}"), - u if u.len() == files.len() => text += &format!(" They are used by {users}"), - [(name, _)] => text += &format!(" \"{name}\" is used by {users}"), - many => text += &format!(" {} of the files are used by {users}", many.len()), + [_] if files.len() == 1 => text += &crate::localized_format!(" It is used by {users}", users = users), + u if u.len() == files.len() => text += &crate::localized_format!(" They are used by {users}", users = users), + [(name, _)] => text += &crate::localized_format!(" \"{name}\" is used by {users}", name = name, users = users), + many => text += &crate::localized_format!(" {n} of the files are used by {users}", n = many.len(), users = users), } if !files.is_empty() && files.iter().all(|f| !f.unsaved) { - text += if files.len() == 1 { " The file stays on disk." } else { " The files stay on disk." }; + text += if files.len() == 1 { + crate::localization::text(" The file stays on disk.") + } else { + crate::localization::text(" The files stay on disk.") + }; } Some(text) } @@ -311,10 +321,10 @@ pub fn bounce_path(path: &str, format: EncodeFormat) -> std::path::PathBuf { /// The Bounce form's file row: a path field and a Browse button that also picks the format. fn bounce_file_row(app: &mut SoundApp, ui: &mut egui::Ui, path: &mut String, format: &mut EncodeFormat) { ui.horizontal(|ui| { - ui.label("File"); - crate::widgets::named_text_field(ui.add(egui::TextEdit::singleline(path).desired_width(420.0)), "File"); + ui.label(crate::localization::text("File")); + crate::widgets::named_text_field(ui.add(egui::TextEdit::singleline(path).desired_width(420.0)), crate::localization::text("File")); if let Some(pick) = &app.services.pick_save - && ui.button("Browse…").clicked() + && ui.button(crate::localization::text("Browse…")).clicked() && let Some(p) = pick("file.bounce_mix", std::path::Path::new(path.as_str())) { match unicode(&p) { @@ -324,7 +334,7 @@ fn bounce_file_row(app: &mut SoundApp, ui: &mut egui::Ui, path: &mut String, for *format = picked; } } - Err(e) => app.ui.status = e.to_string(), + Err(e) => app.ui.status = crate::localization::error_text(&e.to_string()), } } }); @@ -332,20 +342,20 @@ fn bounce_file_row(app: &mut SoundApp, ui: &mut egui::Ui, path: &mut String, for /// The path prompt's form; the command to run once it is confirmed. fn path_prompt_form(app: &mut SoundApp, ui: &mut egui::Ui, cmd: &str, path: &mut String, key: &str, enter: bool) -> Option<(String, Value)> { - crate::widgets::named_text_field(ui.add(egui::TextEdit::singleline(path).desired_width(420.0)), "Path"); + crate::widgets::named_text_field(ui.add(egui::TextEdit::singleline(path).desired_width(420.0)), crate::localization::text("Path")); let mut picked = None; // Import Audio picks several files at once; every other open dialog takes one. let multi = cmd == "file.import_audio" && app.services.pick_open_many.is_some(); if multi && let Some(pick) = &app.services.pick_open_many - && ui.button("Browse…").clicked() + && ui.button(crate::localization::text("Browse…")).clicked() { let mut files = pick(cmd); if files.len() > 1 { let texts: Result, _> = files.iter().map(|f| unicode(f)).collect(); match texts { Ok(texts) => return Some((cmd.to_string(), json!({"paths": texts}))), - Err(e) => app.ui.status = e.to_string(), + Err(e) => app.ui.status = crate::localization::error_text(&e.to_string()), } } else { picked = files.pop(); @@ -356,36 +366,36 @@ fn path_prompt_form(app: &mut SoundApp, ui: &mut egui::Ui, cmd: &str, path: &mut && cmd != "session.save_as" && cmd != "session.save_copy" && key != "dir" - && ui.button("Browse…").clicked() + && ui.button(crate::localization::text("Browse…")).clicked() && let Some(p) = pick(cmd, &[]) { picked = Some(p); } if let Some(pick) = &app.services.pick_folder && key == "dir" - && ui.button("Browse…").clicked() + && ui.button(crate::localization::text("Browse…")).clicked() && let Some(p) = pick(std::path::Path::new(path.as_str())) { picked = Some(p); } if let Some(pick) = &app.services.pick_save && (cmd == "session.save_as" || cmd == "session.save_copy") - && ui.button("Browse…").clicked() + && ui.button(crate::localization::text("Browse…")).clicked() && let Some(p) = pick(cmd, std::path::Path::new(path.as_str())) { picked = Some(p); } match picked.as_deref().map(unicode) { Some(Ok(text)) => *path = text.to_owned(), - Some(Err(e)) => app.ui.status = e.to_string(), + Some(Err(e)) => app.ui.status = crate::localization::error_text(&e.to_string()), None => {} } let file = soundcraft_engine::io::session_file(path); let replaces = soundcraft_engine::io::replaces(&app.engine, cmd, &file); if replaces { - ui.label(format!("“{}” already exists. Do you want to replace it?", file.file_name().unwrap_or_default().to_string_lossy())); + ui.label(crate::localized_format!("“{}” already exists. Do you want to replace it?", file.file_name().unwrap_or_default().to_string_lossy())); } - if buttons(ui, if replaces { "Replace" } else { "OK" }, enter && !replaces) { + if buttons(ui, crate::localization::text(if replaces { "Replace" } else { "OK" }), enter && !replaces) { let mut v = json!({}); v[key] = json!(path); if replaces { @@ -407,10 +417,10 @@ fn strip_silence_form( let mut rename_from = None; let [threshold, min_ms, pre_ms, post_ms] = values; let before = [*threshold, *min_ms, *pre_ms, *post_ms]; - crate::widgets::fine_slider(ui, threshold, -96.0..=0.0, "Threshold dB"); - crate::widgets::fine_slider(ui, min_ms, 0.0..=4000.0, "Min strip duration ms"); - crate::widgets::fine_slider(ui, pre_ms, 0.0..=500.0, "Clip start pad ms"); - crate::widgets::fine_slider(ui, post_ms, 0.0..=2000.0, "Clip end pad ms"); + crate::widgets::fine_slider(ui, threshold, -96.0..=0.0, crate::localization::text("Threshold dB")); + crate::widgets::fine_slider(ui, min_ms, 0.0..=4000.0, crate::localization::text("Min strip duration ms")); + crate::widgets::fine_slider(ui, pre_ms, 0.0..=500.0, crate::localization::text("Clip start pad ms")); + crate::widgets::fine_slider(ui, post_ms, 0.0..=2000.0, crate::localization::text("Clip end pad ms")); let values = [*threshold, *min_ms, *pre_ms, *post_ms]; // The Edit window is drawn before this window, so it draws the rectangles for new values in the next frame. if values != before { @@ -424,13 +434,13 @@ fn strip_silence_form( ui.horizontal(|ui| { let mut mode = None; let mut rename = false; - if ui.button("Extract").clicked() { + if ui.button(crate::localization::text("Extract")).clicked() { mode = Some("extract"); } - if ui.button("Rename…").clicked() { + if ui.button(crate::localization::text("Rename…")).clicked() { rename = true; } - if ui.button("Separate").clicked() { + if ui.button(crate::localization::text("Separate")).clicked() { mode = Some("separate"); } // Enter on a focused Extract or Separate clicks that button, so Enter presses Strip only when neither was clicked. @@ -504,7 +514,8 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { |i: &egui::InputState| i.events.iter().any(|e| matches!(e, egui::Event::Key { key: egui::Key::Enter, pressed: true, repeat: false, .. })); let enter = !first_frame && ctx.input(fresh_enter) && (ctx.memory(|m| m.focused().is_none()) || ctx.text_edit_focused()); let esc = ctx.input(|i| i.key_pressed(egui::Key::Escape)); - egui::Window::new(egui::RichText::new(&title).font(bold(13.0))) + egui::Window::new(egui::RichText::new(crate::localization::text(&title)).font(bold(13.0))) + .id(egui::Id::unique(&title)) .collapsible(false) .resizable(false) .anchor(Align2::CENTER_CENTER, vec2(0.0, -80.0)) @@ -522,15 +533,15 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } Dialog::NewSession { name, sample_rate, demo } => { ui.horizontal(|ui| { - ui.label("Name"); - crate::widgets::named_text_field(ui.text_edit_singleline(name), "Name"); + ui.label(crate::localization::text("Name")); + crate::widgets::named_text_field(ui.text_edit_singleline(name), crate::localization::text("Name")); }); - craft_ui::ComboBox::from_label("Sample Rate").selected_text(format!("{sample_rate} Hz")).show_ui(ui, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Sample Rate")).selected_text(format!("{sample_rate} Hz")).show_ui(ui, |ui| { for r in soundcraft_time::SampleRate::COMMON { ui.selectable_value(sample_rate, r, format!("{r} Hz")); } }); - crate::widgets::checkbox(ui, demo, "Start from the demo session"); + crate::widgets::checkbox(ui, demo, crate::localization::text("Start from the demo session")); if buttons(ui, "Create", enter) { action = Some(( "session.new".into(), @@ -541,25 +552,25 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { Dialog::Bounce { path, format, bit_depth, normalize, dither } => { bounce_file_row(app, ui, path, format); ui.horizontal(|ui| { - craft_ui::ComboBox::from_label("Format").selected_text(format.container().name()).show_ui(ui, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Format")).selected_text(format.container().name()).show_ui(ui, |ui| { for &f in EncodeFormat::ALL { ui.selectable_value(format, f, f.container().name()); } }); - craft_ui::ComboBox::from_label("Bit Depth").selected_text(format!("{bit_depth}-bit")).show_ui(ui, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Bit Depth")).selected_text(format!("{bit_depth}-bit")).show_ui(ui, |ui| { for b in ["16", "24", "32f"] { - ui.selectable_value(bit_depth, b.to_string(), format!("{b}-bit")); + ui.selectable_value(bit_depth, b.to_string(), crate::localized_format!("{b}-bit", b = b)); } }); }); - crate::widgets::checkbox(ui, normalize, "Normalize to -0.1 dBFS"); + crate::widgets::checkbox(ui, normalize, crate::localization::text("Normalize to -0.1 dBFS")); // 32-bit float keeps every sample as it is: there is nothing to dither. ui.add_enabled_ui(bit_depth.as_str() != "32f", |ui| { - crate::widgets::checkbox(ui, dither, "Dither (TPDF)") - .on_hover_text("Adds ±1 LSB triangular dither when writing 16- or 24-bit files. Leave it off when the master chain already dithers."); + crate::widgets::checkbox(ui, dither, crate::localization::text("Dither (TPDF)")) + .on_hover_text(crate::localization::text("Adds ±1 LSB triangular dither when writing 16- or 24-bit files. Leave it off when the master chain already dithers.")); }); ui.label( - egui::RichText::new("Bounces the edit selection, or the whole session when nothing is selected.") + egui::RichText::new(crate::localization::text("Bounces the edit selection, or the whole session when nothing is selected.")) .small() .color(Tokens::current().text_dim), ); @@ -602,7 +613,7 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } Dialog::Number { cmd, key, value, suffix, .. } => { ui.horizontal(|ui| { - ui.add(egui::DragValue::new(value).speed(0.1)).accessible_name(format!("Value in {suffix}")); + ui.add(egui::DragValue::new(value).speed(0.1)).accessible_name(crate::localized_format!("Value in {suffix}", suffix = suffix)); ui.label(suffix.as_str()); }); if buttons(ui, "OK", enter) { @@ -613,8 +624,8 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { Dialog::TempoChange { at, bpm } => { ui.horizontal(|ui| { // Same limits the engine enforces (time crate `valid_bpm`). - ui.add(egui::DragValue::new(bpm).speed(0.1).range(5.0..=1000.0)).accessible_name("Tempo (BPM)"); - ui.label("bpm"); + ui.add(egui::DragValue::new(bpm).speed(0.1).range(5.0..=1000.0)).accessible_name(crate::localization::text("Tempo (BPM)")); + ui.label(crate::localization::text("bpm")); }); if buttons(ui, "OK", enter) { action = Some(tempo_change_action(*at, *bpm)); @@ -629,7 +640,7 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } Dialog::Fades { shape } => { for s in soundcraft_model::FadeShape::ALL { - ui.radio_value(shape, s.label().to_lowercase(), s.label()); + ui.radio_value(shape, s.label().to_lowercase(), crate::localization::text(s.label())); } if buttons(ui, "OK", enter) { action = Some(("edit.fades_create".into(), json!({"shape": shape}))); @@ -644,7 +655,7 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } Dialog::StripSilenceRename { names, .. } => { strip_name_fields(ui, names, STRIP_NAME_LABELS); - let cleared = ui.button("Clear").clicked(); + let cleared = ui.button(crate::localization::text("Clear")).clicked(); if cleared { *names = StripNames::default(); } @@ -654,7 +665,7 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } } Dialog::AutoRename { clips, names } => { - ui.label("Text for naming the clips that editing makes from the selected clips:"); + ui.label(crate::localization::text("Text for naming the clips that editing makes from the selected clips:")); strip_name_fields(ui, names, AUTO_NAME_LABELS); if buttons(ui, "OK", enter) { action = Some(auto_rename_action(clips, names)); @@ -662,14 +673,14 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } Dialog::Group { id, name, edit, mix, members } => { ui.horizontal(|ui| { - ui.label("Name"); - crate::widgets::named_text_field(ui.text_edit_singleline(name), "Name"); + ui.label(crate::localization::text("Name")); + crate::widgets::named_text_field(ui.text_edit_singleline(name), crate::localization::text("Name")); }); ui.horizontal(|ui| { - crate::widgets::checkbox(ui, edit, "Edit group"); - crate::widgets::checkbox(ui, mix, "Mix group"); + crate::widgets::checkbox(ui, edit, crate::localization::text("Edit group")); + crate::widgets::checkbox(ui, mix, crate::localization::text("Mix group")); }); - ui.label("Tracks"); + ui.label(crate::localization::text("Tracks")); egui::ScrollArea::vertical().max_height(180.0).show(ui, |ui| { for (_, n, on) in members.iter_mut() { crate::widgets::checkbox(ui, on, n.as_str()); @@ -690,14 +701,14 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } } Dialog::Session { frame_rate, bit_depth } => { - craft_ui::ComboBox::from_label("Timecode Rate").selected_text(frame_rate.as_str()).show_ui(ui, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Timecode Rate")).selected_text(crate::localization::text(frame_rate.as_str())).show_ui(ui, |ui| { for r in soundcraft_time::FrameRate::ALL { - ui.selectable_value(frame_rate, r.label().to_string(), r.label()); + ui.selectable_value(frame_rate, r.label().to_string(), crate::localization::text(r.label())); } }); - craft_ui::ComboBox::from_label("Bit Depth").selected_text(bit_depth.as_str()).show_ui(ui, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Bit Depth")).selected_text(crate::localization::text(bit_depth.as_str())).show_ui(ui, |ui| { for b in ["16", "24", "32f"] { - ui.selectable_value(bit_depth, b.to_string(), b); + ui.selectable_value(bit_depth, b.to_string(), crate::localization::text(b)); } }); if buttons(ui, "OK", enter) { @@ -707,15 +718,15 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { Dialog::Loop { by, count, length, format, start, filled } => { let s = app.engine.session(); ui.horizontal(|ui| { - let count_label = ui.radio_value(by, LoopBy::Count, "Number of Loops"); + let count_label = ui.radio_value(by, LoopBy::Count, crate::localization::text("Number of Loops")); ui.add_enabled(*by == LoopBy::Count, egui::DragValue::new(count).range(1..=512)).labelled_by(count_label.id); }); ui.horizontal(|ui| { - let length_label = ui.radio_value(by, LoopBy::Length, "Loop Length"); + let length_label = ui.radio_value(by, LoopBy::Length, crate::localization::text("Loop Length")); ui.add_enabled(*by == LoopBy::Length, egui::TextEdit::singleline(length).desired_width(140.0)).labelled_by(length_label.id); - ui.label(format.label()); + ui.label(crate::localization::text(format.label())); }); - ui.radio_value(by, LoopBy::Fill, "Loop Until End of Session or Next Clip"); + ui.radio_value(by, LoopBy::Fill, crate::localization::text("Loop Until End of Session or Next Clip")); let params = loop_params(s, *by, *count, length, *format, *start, filled); if buttons_enabled(ui, "OK", enter, params.is_some()) { action = params.map(|p| ("clip.loop".into(), p)); @@ -723,18 +734,18 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } Dialog::ScoreSetup { title, composer, bars_per_system, show_track_names } => { egui::Grid::new("score_setup").num_columns(2).spacing(vec2(10.0, 8.0)).show(ui, |ui| { - ui.label("Title"); + ui.label(crate::localization::text("Title")); // The painted label is not an accesskit name; name the field itself. - crate::widgets::named_text_field(ui.text_edit_singleline(title), "Score title"); + crate::widgets::named_text_field(ui.text_edit_singleline(title), crate::localization::text("Score title")); ui.end_row(); - ui.label("Composer"); - crate::widgets::named_text_field(ui.text_edit_singleline(composer), "Score composer"); + ui.label(crate::localization::text("Composer")); + crate::widgets::named_text_field(ui.text_edit_singleline(composer), crate::localization::text("Score composer")); ui.end_row(); - ui.label("Bars per system"); - ui.add(egui::DragValue::new(bars_per_system).range(1..=16)).accessible_name("Bars per system"); + ui.label(crate::localization::text("Bars per system")); + ui.add(egui::DragValue::new(bars_per_system).range(1..=16)).accessible_name(crate::localization::text("Bars per system")); ui.end_row(); }); - crate::widgets::checkbox(ui, show_track_names, "Show track names"); + crate::widgets::checkbox(ui, show_track_names, crate::localization::text("Show track names")); if buttons(ui, "OK", enter) { action = Some(( "file.score_setup".into(), @@ -747,19 +758,19 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { let revert = then.0 == "session.revert"; if revert || cfg!(target_arch = "wasm32") { let (question, ok) = if revert { - (format!("Revert “{name}” to its last saved version?"), "Revert") + (crate::localized_format!("Revert “{name}” to its last saved version?", name = name), "Revert") } else { - (format!("Close “{name}” without saving?"), "Don't Save") + (crate::localized_format!("Close “{name}” without saving?", name = name), "Don't Save") }; - ui.label(format!("{question} Your changes will be lost.")); + ui.label(crate::localized_format!("{question} Your changes will be lost.", question = question)); if buttons(ui, ok, false) { action = Some(then.clone()); } } else { - ui.label(format!("Save changes to “{name}” before closing?")); + ui.label(crate::localized_format!("Save changes to “{name}” before closing?", name = name)); ui.separator(); ui.horizontal(|ui| { - if ui.button("Don't Save").clicked() { + if ui.button(crate::localization::text("Don't Save")).clicked() { action = Some(then.clone()); } if buttons(ui, "Save", enter) { @@ -834,7 +845,7 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { } else { match run_then(app, &cmd, params) { Ok(v) if cmd == "file.export_clips" => { - app.ui.status = format!("Exported {} clip(s) to {}", v["written"], v["dir"].as_str().unwrap_or_default()); + app.ui.status = crate::localized_format!("Exported {} clip(s) to {}", v["written"], v["dir"].as_str().unwrap_or_default()); } Ok(_) => {} Err(e) => app.ui.status = e, @@ -873,11 +884,11 @@ pub(crate) fn buttons_enabled(ui: &mut egui::Ui, ok: &str, enter: bool, ready: b let mut canceled = false; ui.separator(); ui.horizontal(|ui| { - if ui.button("Cancel").clicked() { + if ui.button(crate::localization::text("Cancel")).clicked() { canceled = true; ui.ctx().memory_mut(|m| m.data.insert_temp(egui::Id::unique("dlg_cancel"), true)); } - let b = egui::Button::new(egui::RichText::new(ok).strong()).fill(Tokens::current().accent); + let b = egui::Button::new(egui::RichText::new(crate::localization::text(ok)).strong()).fill(Tokens::current().accent); if ui.add_enabled(ready, b).clicked() { pressed = true; } @@ -888,7 +899,7 @@ pub(crate) fn buttons_enabled(ui: &mut egui::Ui, ok: &str, enter: bool, ready: b /// A name field that takes the focus with its text selected, so typing replaces the old name. fn name_field(ui: &mut egui::Ui, name: &mut String) { let mut out = egui::TextEdit::singleline(name).show(ui); - let _ = crate::widgets::named_text_field(out.response.response.clone(), "Name"); + let _ = crate::widgets::named_text_field(out.response.response.clone(), crate::localization::text("Name")); if !out.response.has_focus() { out.response.request_focus(); let all = egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(name.chars().count())); @@ -1305,6 +1316,28 @@ mod tests { assert_eq!(named[..2], ["SFX023.Reel1", "SFX024.Reel1"]); } + #[test] + fn clear_question_is_assembled_in_portuguese() { + let _scope = crate::localization::enter(crate::localization::Language::PortugueseBrazil); + let mut e = soundcraft_engine::demo::demo_engine(); + let kick = e.session().sources.iter().find(|f| f.name == "Kick").map(|f| f.id).unwrap(); + let kick_clips: Vec = e.session().clips_using(kick).map(|c| c.id).collect(); + let message = |d: &Dialogs| match &d.open { + Some(Dialog::ClearClips { message, .. }) => message.clone(), + other => panic!("{other:?}"), + }; + let mut d = Dialogs::default(); + assert!(d.open_clear(&e, kick_clips, vec![kick])); + let combined = message(&d); + assert_eq!(combined, "Remover 3 clipes e 1 arquivo da sessão?"); + e.session_mut().sources.iter_mut().for_each(|f| f.unsaved = false); + assert!(d.open_clear(&e, vec![], vec![kick])); + assert_eq!( + message(&d), + "Remover o arquivo \"Kick\" da sessão? Ele é usado por 3 clipes na linha do tempo, que também serão removidos. O arquivo permanece no disco." + ); + } + #[test] fn clear_always_asks_and_names_the_timeline_clips_that_go_too() { let mut e = soundcraft_engine::demo::demo_engine(); diff --git a/crates/ui-egui/src/dialogs/audiosuite.rs b/crates/ui-egui/src/dialogs/audiosuite.rs index eeba0a09..1771b3de 100644 --- a/crates/ui-egui/src/dialogs/audiosuite.rs +++ b/crates/ui-egui/src/dialogs/audiosuite.rs @@ -20,7 +20,7 @@ pub(super) fn audiosuite_window(app: &mut SoundApp, ctx: &egui::Context) { let v = params.entry(p.id.to_string()).or_insert(p.default); let mut wide = f64::from(*v); crate::widgets::FineSlider::new(&mut wide, f64::from(p.min)..=f64::from(p.max)) - .text(p.name) + .text(crate::localization::text(p.name)) .default_value(f64::from(p.default)) .show(ui); *v = wide as f32; @@ -30,45 +30,48 @@ pub(super) fn audiosuite_window(app: &mut SoundApp, ctx: &egui::Context) { "normalize" => { let v = params.entry("target_db".into()).or_insert(-0.1); let mut wide = f64::from(*v); - crate::widgets::FineSlider::new(&mut wide, -24.0..=0.0).text("Peak dB").default_value(-0.1).show(ui); + crate::widgets::FineSlider::new(&mut wide, -24.0..=0.0).text(crate::localization::text("Peak dB")).default_value(-0.1).show(ui); *v = wide as f32; } "time_stretch" => { let v = params.entry("ratio".into()).or_insert(1.0); let mut wide = f64::from(*v); - crate::widgets::FineSlider::new(&mut wide, 0.25..=4.0).text("Length ratio").default_value(1.0).show(ui); + crate::widgets::FineSlider::new(&mut wide, 0.25..=4.0) + .text(crate::localization::text("Length ratio")) + .default_value(1.0) + .show(ui); *v = wide as f32; } "pitch_shift" => { let v = params.entry("semitones".into()).or_insert(0.0); let mut wide = f64::from(*v); - crate::widgets::FineSlider::new(&mut wide, -24.0..=24.0).text("Semitones").default_value(0.0).show(ui); + crate::widgets::FineSlider::new(&mut wide, -24.0..=24.0).text(crate::localization::text("Semitones")).default_value(0.0).show(ui); *v = wide as f32; } "speed_ramp" => { for (id, label, default, choices) in SPEED_RAMP_CHOICES { let v = params.entry(id.to_string()).or_insert(default); ui.horizontal(|ui| { - ui.label(label); + ui.label(crate::localization::text(label)); for &(value, name) in choices { - ui.radio_value(v, value, name); + ui.radio_value(v, value, crate::localization::text(name)); } }); } } _ => { - ui.label("No parameters."); + ui.label(crate::localization::text("No parameters.")); } } } ui.ctx().memory_mut(|m| m.data.insert_temp(key, params.clone())); let hint = if soundcraft_dsp::is_generator(&process) { - "Fills the selection on the selected tracks with a new clip." + crate::localization::text("Fills the selection on the selected tracks with a new clip.") } else { - "Processes the selected clips and replaces them with rendered audio." + crate::localization::text("Processes the selected clips and replaces them with rendered audio.") }; ui.label(egui::RichText::new(hint).small()); - if ui.button(egui::RichText::new("Render").strong()).clicked() { + if ui.button(egui::RichText::new(crate::localization::text("Render")).strong()).clicked() { let p: serde_json::Map = params.iter().map(|(k, v)| (k.clone(), json!(v))).collect(); let _ = app.run("audiosuite.process", json!({"process": process, "params": p})); } diff --git a/crates/ui-egui/src/dialogs/files.rs b/crates/ui-egui/src/dialogs/files.rs index a6c107c4..c029f330 100644 --- a/crates/ui-egui/src/dialogs/files.rs +++ b/crates/ui-egui/src/dialogs/files.rs @@ -52,7 +52,7 @@ pub fn open_path(app: &mut SoundApp, path: &std::path::Path) { Ok(p) => p, Err(e) => { log::warn!("{e}"); - app.ui.status = e.to_string(); + app.ui.status = crate::localization::error_text(&e.to_string()); return; } }; @@ -98,9 +98,13 @@ pub(super) fn open_pending_session(app: &mut SoundApp) { Ok(missing) => { // This path replaces the document without going through `SoundApp::run`. app.document_replaced(); - if missing.is_empty() { format!("Opened {name}") } else { format!("Opened {name} ({} missing media)", missing.len()) } + if missing.is_empty() { + crate::localized_format!("Opened {name}", name = name) + } else { + crate::localized_format!("Opened {name} ({missing} missing media)", name = name, missing = missing.len()) + } } - Err(e) => e.to_string(), + Err(e) => crate::localization::error_text(&e.to_string()), }; } diff --git a/crates/ui-egui/src/dialogs/new_tracks.rs b/crates/ui-egui/src/dialogs/new_tracks.rs index f7fc75e1..80865a7b 100644 --- a/crates/ui-egui/src/dialogs/new_tracks.rs +++ b/crates/ui-egui/src/dialogs/new_tracks.rs @@ -162,7 +162,7 @@ impl NewTracks { let id = egui::Id::unique(("new_tracks_row", row.key)); let rect = egui::Rect::from_min_size(ui.available_rect_before_wrap().min, vec2(ui.available_width(), ui.spacing().interact_size.y)); ui.scope_builder(egui::UiBuilder::new().scope_id(id).max_rect(rect).layout(egui::Layout::left_to_right(egui::Align::Center)), |ui| { - let label = ui.label("Create"); + let label = ui.label(crate::localization::text("Create")); let counter = ui .scope_builder(egui::UiBuilder::new().scope_id(id.with("count")), |ui| { ui.spacing_mut().interact_size.x = widths.count; @@ -180,19 +180,19 @@ impl NewTracks { if counter.gained_focus() { counter.scroll_to_me(Some(egui::Align::Center)); } - ui.label("new"); + ui.label(crate::localization::text("new")); let format = if has_format(&row.kind) { Some( craft_ui::ComboBox::from_id_salt("nt_fmt") .width(widths.format) - .selected_text(&row.format) + .selected_text(crate::localization::text(&row.format)) .show_ui(ui, |ui| { for f in ChannelFormat::ALL { - ui.selectable_value(&mut row.format, f.label().to_string(), f.label()); + ui.selectable_value(&mut row.format, f.label().to_string(), crate::localization::text(f.label())); } }) .response - .accessible_name("Channel format"), + .accessible_name(crate::localization::text("Channel format")), ) } else { ui.allocate_space(vec2(widths.format, ui.spacing().interact_size.y)); @@ -200,47 +200,55 @@ impl NewTracks { }; let kind = craft_ui::ComboBox::from_id_salt("nt_kind") .width(widths.kind) - .selected_text(TrackKind::from_id(&row.kind).map_or("Audio Track", |k| k.label())) + .selected_text(crate::localization::text(TrackKind::from_id(&row.kind).map_or("Audio Track", |k| k.label()))) .show_ui(ui, |ui| { for k in TrackKind::ALL { - if ui.selectable_label(row.kind == k.id(), k.label()).clicked() { + if ui.selectable_label(row.kind == k.id(), crate::localization::text(k.label())).clicked() { set_new_track_kind(&mut row.kind, &mut row.name, k); } } }) .response - .accessible_name("Track kind"); + .accessible_name(crate::localization::text("Track kind")); let timebase = if has_timebase(&row.kind) { - ui.label("in"); + ui.label(crate::localization::text("in")); Some( craft_ui::ComboBox::from_id_salt("nt_tb") .width(widths.timebase) - .selected_text(if row.timebase == "ticks" { "Ticks" } else { "Samples" }) + .selected_text(crate::localization::text(if row.timebase == "ticks" { "Ticks" } else { "Samples" })) .show_ui(ui, |ui| { - ui.selectable_value(&mut row.timebase, "samples".to_string(), "Samples"); - ui.selectable_value(&mut row.timebase, "ticks".to_string(), "Ticks"); + ui.selectable_value(&mut row.timebase, "samples".to_string(), crate::localization::text("Samples")); + ui.selectable_value(&mut row.timebase, "ticks".to_string(), crate::localization::text("Ticks")); }) .response - .accessible_name("Timebase"), + .accessible_name(crate::localization::text("Timebase")), ) } else { - ui.allocate_space(vec2(text_width(ui, "in"), ui.spacing().interact_size.y)); + ui.allocate_space(vec2(text_width(ui, crate::localization::text("in")), ui.spacing().interact_size.y)); ui.allocate_space(vec2(widths.timebase, ui.spacing().interact_size.y)); None }; - let label = ui.label("Name:"); + let label = ui.label(crate::localization::text("Name:")); let name = crate::widgets::named_text_field( ui.add(egui::TextEdit::singleline(&mut row.name).id(id.with("name")).desired_width(NAME_WIDTH)).labelled_by(label.id), - "Name:", + crate::localization::text("Name:"), ); if format.iter().chain(timebase.iter()).chain([&kind, &name]).any(|r| r.clicked() || r.has_focus()) { self.active = index; } let size = vec2(ROW_BUTTON_WIDTH, ui.spacing().interact_size.y); - if ui.add_enabled(len > 1, egui::Button::new("−").min_size(size)).on_hover_text("Remove this row").clicked() { + if ui + .add_enabled(len > 1, egui::Button::new(crate::localization::text("−")).min_size(size)) + .on_hover_text(crate::localization::text("Remove this row")) + .clicked() + { remove = Some(index); } - if ui.add_enabled(len < MAX_TRACKS, egui::Button::new("+").min_size(size)).on_hover_text("Add a row below").clicked() { + if ui + .add_enabled(len < MAX_TRACKS, egui::Button::new(crate::localization::text("+")).min_size(size)) + .on_hover_text(crate::localization::text("Add a row below")) + .clicked() + { insert = Some(index); } }); @@ -258,7 +266,7 @@ impl NewTracks { let total = self.rows.iter().fold(0_u32, |total, row| total.saturating_add(row.count)); let can_create = !self.rows.is_empty() && total <= MAX_TRACKS as u32; if !can_create { - ui.colored_label(ui.visuals().error_fg_color, "Create up to 128 tracks at a time."); + ui.colored_label(ui.visuals().error_fg_color, crate::localization::text("Create up to 128 tracks at a time.")); } // Enter on a focused row button changes that row only; it must not also submit the dialog. if crate::dialogs::buttons_enabled(ui, "Create", enter && !row_action, can_create) && !row_action { diff --git a/crates/ui-egui/src/dialogs/ops_windows.rs b/crates/ui-egui/src/dialogs/ops_windows.rs index 6b41a4f0..430eac2e 100644 --- a/crates/ui-egui/src/dialogs/ops_windows.rs +++ b/crates/ui-egui/src/dialogs/ops_windows.rs @@ -94,39 +94,44 @@ fn beat_detective(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("Beat Analysis").open(&mut open).default_size(vec2(360.0, 220.0)).show(ctx, |ui| { - ui.label("Analyses the edit selection on the selected tracks."); - ui.add(egui::Slider::new(&mut app.ops.beat_sensitivity, 0.0..=1.0).text("Sensitivity")); - crate::widgets::checkbox(ui, &mut app.ops.beat_separate, "Separate clips at detected beats"); - crate::widgets::checkbox(ui, &mut app.ops.beat_set_tempo, "Set the session tempo from the beats"); - ui.horizontal(|ui| { - if ui.button("Analyze").clicked() { - let r = app.run("event.beat_detective", json!({"sensitivity": app.ops.beat_sensitivity, "separate": false, "set_tempo": false})); - app.ops.beat_result = r.map_or_else(|e| e, |v| v.to_string()); - } - if ui.button(egui::RichText::new("Apply").strong()).clicked() { - let r = app.run( - "event.beat_detective", - json!({"sensitivity": app.ops.beat_sensitivity, "separate": app.ops.beat_separate, "set_tempo": app.ops.beat_set_tempo}), - ); - app.ops.beat_result = r.map_or_else(|e| e, |v| v.to_string()); + egui::Window::new(crate::localization::text("Beat Analysis")) + .id(egui::Id::unique("Beat Analysis")) + .open(&mut open) + .default_size(vec2(360.0, 220.0)) + .show(ctx, |ui| { + ui.label(crate::localization::text("Analyses the edit selection on the selected tracks.")); + ui.add(egui::Slider::new(&mut app.ops.beat_sensitivity, 0.0..=1.0).text(crate::localization::text("Sensitivity"))); + crate::widgets::checkbox(ui, &mut app.ops.beat_separate, crate::localization::text("Separate clips at detected beats")); + crate::widgets::checkbox(ui, &mut app.ops.beat_set_tempo, crate::localization::text("Set the session tempo from the beats")); + ui.horizontal(|ui| { + if ui.button(crate::localization::text("Analyze")).clicked() { + let r = app.run("event.beat_detective", json!({"sensitivity": app.ops.beat_sensitivity, "separate": false, "set_tempo": false})); + app.ops.beat_result = r.map_or_else(|e| e, |v| v.to_string()); + } + if ui.button(egui::RichText::new(crate::localization::text("Apply")).strong()).clicked() { + let r = app.run( + "event.beat_detective", + json!({"sensitivity": app.ops.beat_sensitivity, "separate": app.ops.beat_separate, "set_tempo": app.ops.beat_set_tempo}), + ); + app.ops.beat_result = r.map_or_else(|e| e, |v| v.to_string()); + } + }); + ui.separator(); + ui.horizontal(|ui| { + ui.label(crate::localization::text("Identify Beat: selection is")); + ui.add(egui::DragValue::new(&mut app.ops.identify_bars).range(1..=64)) + .accessible_name(crate::localization::text("Identify beat bars")); + ui.label(crate::localization::text("bar(s)")); + if ui.button(crate::localization::text("Set Tempo")).clicked() { + let r = app.run("event.identify_beat", json!({"bars": app.ops.identify_bars})); + app.ops.beat_result = r.map_or_else(|e| e, |v| v.to_string()); + } + }); + if !app.ops.beat_result.is_empty() { + let s = app.ops.beat_result.clone(); + ui.label(egui::RichText::new(if s.len() > 300 { format!("{}…", &s[..300]) } else { s }).small()); } }); - ui.separator(); - ui.horizontal(|ui| { - ui.label("Identify Beat: selection is"); - ui.add(egui::DragValue::new(&mut app.ops.identify_bars).range(1..=64)).accessible_name("Identify beat bars"); - ui.label("bar(s)"); - if ui.button("Set Tempo").clicked() { - let r = app.run("event.identify_beat", json!({"bars": app.ops.identify_bars})); - app.ops.beat_result = r.map_or_else(|e| e, |v| v.to_string()); - } - }); - if !app.ops.beat_result.is_empty() { - let s = app.ops.beat_result.clone(); - ui.label(egui::RichText::new(if s.len() > 300 { format!("{}…", &s[..300]) } else { s }).small()); - } - }); app.ui.show_beat_detective = open; } @@ -152,26 +157,34 @@ fn tempo_ops(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("Tempo Operations").open(&mut open).default_size(vec2(360.0, 200.0)).show(ctx, |ui| { - craft_ui::ComboBox::from_label("Curve").selected_text(app.ops.tempo_curve.clone()).show_ui(ui, |ui| { - for c in ["constant", "linear", "parabolic", "s-curve", "scale", "stretch"] { - ui.selectable_value(&mut app.ops.tempo_curve, c.to_string(), c); - } - }); - ui.add(egui::DragValue::new(&mut app.ops.tempo_start).range(5.0..=999.0).prefix("start bpm ")).accessible_name("Start tempo (BPM)"); - ui.add(egui::DragValue::new(&mut app.ops.tempo_end).range(5.0..=999.0).prefix("end bpm ")).accessible_name("End tempo (BPM)"); - ui.label( - egui::RichText::new( + egui::Window::new(crate::localization::text("Tempo Operations")) + .id(egui::Id::unique("Tempo Operations")) + .open(&mut open) + .default_size(vec2(360.0, 200.0)) + .show(ctx, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Curve")) + .selected_text(crate::localization::text(&app.ops.tempo_curve)) + .show_ui(ui, |ui| { + for c in ["constant", "linear", "parabolic", "s-curve", "scale", "stretch"] { + ui.selectable_value(&mut app.ops.tempo_curve, c.to_string(), crate::localization::text(c)); + } + }); + ui.add(egui::DragValue::new(&mut app.ops.tempo_start).range(5.0..=999.0).prefix(crate::localization::text("start bpm "))) + .accessible_name(crate::localization::text("Start tempo (BPM)")); + ui.add(egui::DragValue::new(&mut app.ops.tempo_end).range(5.0..=999.0).prefix(crate::localization::text("end bpm "))) + .accessible_name(crate::localization::text("End tempo (BPM)")); + ui.label( + egui::RichText::new(crate::localization::text( "Applies across the edit selection (constant: at the insertion point; scale: factor = end / start; stretch: factor = start / end).", - ) + )) .small(), ); - if ui.button(egui::RichText::new("Apply").strong()).clicked() { - let (id, p) = tempo_ops_apply(&app.ops.tempo_curve, app.ops.tempo_start, app.ops.tempo_end); - let r = app.run(id, p); - result_line(ui, &r); - } - }); + if ui.button(egui::RichText::new(crate::localization::text("Apply")).strong()).clicked() { + let (id, p) = tempo_ops_apply(&app.ops.tempo_curve, app.ops.tempo_start, app.ops.tempo_end); + let r = app.run(id, p); + result_line(ui, &r); + } + }); app.ui.show_tempo_ops = open; } @@ -182,43 +195,51 @@ fn time_ops(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("Time Operations").open(&mut open).default_size(vec2(360.0, 200.0)).show(ctx, |ui| { - craft_ui::ComboBox::from_label("Operation").selected_text(app.ops.time_op.clone()).show_ui(ui, |ui| { - for c in ["insert", "cut", "change meter", "move song start"] { - ui.selectable_value(&mut app.ops.time_op, c.to_string(), c); + egui::Window::new(crate::localization::text("Time Operations")) + .id(egui::Id::unique("Time Operations")) + .open(&mut open) + .default_size(vec2(360.0, 200.0)) + .show(ctx, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Operation")) + .selected_text(crate::localization::text(&app.ops.time_op)) + .show_ui(ui, |ui| { + for c in ["insert", "cut", "change meter", "move song start"] { + ui.selectable_value(&mut app.ops.time_op, c.to_string(), crate::localization::text(c)); + } + }); + match app.ops.time_op.as_str() { + "change meter" => { + ui.horizontal(|ui| { + ui.add(egui::DragValue::new(&mut app.ops.meter_num).range(1..=64)) + .accessible_name(crate::localization::text("Meter numerator")); + ui.label(crate::localization::text("/")); + let den = craft_ui::ComboBox::from_id_salt("den").selected_text(app.ops.meter_den.to_string()).show_ui(ui, |ui| { + for d in [2u32, 4, 8, 16] { + ui.selectable_value(&mut app.ops.meter_den, d, d.to_string()); + } + }); + den.response.accessible_name(crate::localization::text("Meter denominator")); + }); + } + "insert" => { + ui.add(egui::DragValue::new(&mut app.ops.time_seconds).range(0.0..=3600.0).suffix(" s")) + .accessible_name(crate::localization::text("Time (seconds)")); + } + _ => { + ui.label(egui::RichText::new(crate::localization::text("Uses the edit selection.")).small()); + } + } + if ui.button(egui::RichText::new(crate::localization::text("Apply")).strong()).clicked() { + let at = app.engine.session().edit.selection.start; + let r = match app.ops.time_op.as_str() { + "insert" => app.run("event.insert_time", json!({"start": at, "length": {"seconds": app.ops.time_seconds}})), + "cut" => app.run("event.cut_time", json!({})), + "change meter" => app.run("event.meter", json!({"numerator": app.ops.meter_num, "denominator": app.ops.meter_den, "at": at})), + _ => app.run("event.move_song_start", json!({"to": at})), + }; + result_line(ui, &r); } }); - match app.ops.time_op.as_str() { - "change meter" => { - ui.horizontal(|ui| { - ui.add(egui::DragValue::new(&mut app.ops.meter_num).range(1..=64)).accessible_name("Meter numerator"); - ui.label("/"); - let den = craft_ui::ComboBox::from_id_salt("den").selected_text(app.ops.meter_den.to_string()).show_ui(ui, |ui| { - for d in [2u32, 4, 8, 16] { - ui.selectable_value(&mut app.ops.meter_den, d, d.to_string()); - } - }); - den.response.accessible_name("Meter denominator"); - }); - } - "insert" => { - ui.add(egui::DragValue::new(&mut app.ops.time_seconds).range(0.0..=3600.0).suffix(" s")).accessible_name("Time (seconds)"); - } - _ => { - ui.label(egui::RichText::new("Uses the edit selection.").small()); - } - } - if ui.button(egui::RichText::new("Apply").strong()).clicked() { - let at = app.engine.session().edit.selection.start; - let r = match app.ops.time_op.as_str() { - "insert" => app.run("event.insert_time", json!({"start": at, "length": {"seconds": app.ops.time_seconds}})), - "cut" => app.run("event.cut_time", json!({})), - "change meter" => app.run("event.meter", json!({"numerator": app.ops.meter_num, "denominator": app.ops.meter_den, "at": at})), - _ => app.run("event.move_song_start", json!({"to": at})), - }; - result_line(ui, &r); - } - }); app.ui.show_time_ops = open; } @@ -227,44 +248,49 @@ fn midi_ops(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("MIDI Operations").open(&mut open).default_size(vec2(360.0, 220.0)).show(ctx, |ui| { - craft_ui::ComboBox::from_label("Operation").selected_text(app.ops.midi_op.clone()).show_ui(ui, |ui| { - for c in ["quantize", "transpose", "change velocity", "flatten performance", "restore performance"] { - ui.selectable_value(&mut app.ops.midi_op, c.to_string(), c); - } - }); - match app.ops.midi_op.as_str() { - "quantize" => { - craft_ui::ComboBox::from_label("Grid").selected_text(app.ops.quant_grid.clone()).show_ui(ui, |ui| { - for g in ["1/4", "1/8", "1/8t", "1/16", "1/16t", "1/32"] { - ui.selectable_value(&mut app.ops.quant_grid, g.to_string(), g); + egui::Window::new(crate::localization::text("MIDI Operations")) + .id(egui::Id::unique("MIDI Operations")) + .open(&mut open) + .default_size(vec2(360.0, 220.0)) + .show(ctx, |ui| { + craft_ui::ComboBox::from_label(crate::localization::text("Operation")) + .selected_text(crate::localization::text(&app.ops.midi_op)) + .show_ui(ui, |ui| { + for c in ["quantize", "transpose", "change velocity", "flatten performance", "restore performance"] { + ui.selectable_value(&mut app.ops.midi_op, c.to_string(), crate::localization::text(c)); } }); - ui.add(egui::Slider::new(&mut app.ops.quant_strength, 0.0..=100.0).text("Strength %")); - ui.add(egui::Slider::new(&mut app.ops.quant_swing, 0.0..=100.0).text("Swing %")); - } - "transpose" => { - ui.add(egui::Slider::new(&mut app.ops.transpose, -48..=48).text("Semitones")); - } - "change velocity" => { - ui.add(egui::Slider::new(&mut app.ops.velocity_add, -127..=127).text("Add")); - } - _ => {} - } - ui.label(egui::RichText::new("Applies to the selected MIDI clips (or those under the selection).").small()); - if ui.button(egui::RichText::new("Apply").strong()).clicked() { - let r = match app.ops.midi_op.as_str() { + match app.ops.midi_op.as_str() { "quantize" => { - app.run("event.quantize", json!({"grid": app.ops.quant_grid, "strength": app.ops.quant_strength, "swing": app.ops.quant_swing})) + craft_ui::ComboBox::from_label(crate::localization::text("Grid")).selected_text(app.ops.quant_grid.clone()).show_ui(ui, |ui| { + for g in ["1/4", "1/8", "1/8t", "1/16", "1/16t", "1/32"] { + ui.selectable_value(&mut app.ops.quant_grid, g.to_string(), g); + } + }); + ui.add(egui::Slider::new(&mut app.ops.quant_strength, 0.0..=100.0).text(crate::localization::text("Strength %"))); + ui.add(egui::Slider::new(&mut app.ops.quant_swing, 0.0..=100.0).text(crate::localization::text("Swing %"))); } - "transpose" => app.run("event.transpose", json!({"semitones": app.ops.transpose})), - "change velocity" => app.run("event.change_velocity", json!({"add": app.ops.velocity_add})), - "flatten performance" => app.run("event.flatten_performance", json!({})), - _ => app.run("event.restore_performance", json!({})), - }; - result_line(ui, &r); - } - }); + "transpose" => { + ui.add(egui::Slider::new(&mut app.ops.transpose, -48..=48).text(crate::localization::text("Semitones"))); + } + "change velocity" => { + ui.add(egui::Slider::new(&mut app.ops.velocity_add, -127..=127).text(crate::localization::text("Add"))); + } + _ => {} + } + ui.label(egui::RichText::new(crate::localization::text("Applies to the selected MIDI clips (or those under the selection).")).small()); + if ui.button(egui::RichText::new(crate::localization::text("Apply")).strong()).clicked() { + let r = match app.ops.midi_op.as_str() { + "quantize" => app + .run("event.quantize", json!({"grid": app.ops.quant_grid, "strength": app.ops.quant_strength, "swing": app.ops.quant_swing})), + "transpose" => app.run("event.transpose", json!({"semitones": app.ops.transpose})), + "change velocity" => app.run("event.change_velocity", json!({"add": app.ops.velocity_add})), + "flatten performance" => app.run("event.flatten_performance", json!({})), + _ => app.run("event.restore_performance", json!({})), + }; + result_line(ui, &r); + } + }); app.ui.show_midi_ops = open; } @@ -275,29 +301,36 @@ fn rtp(app: &mut SoundApp, ctx: &egui::Context) { } let targets = app.engine.target_tracks(); sync_rtp_form(&mut app.ops, app.engine.session(), targets, ctx.dragged_id().is_some()); - egui::Window::new("MIDI Real-Time Properties").open(&mut open).default_size(vec2(340.0, 200.0)).show(ctx, |ui| { - ui.label("Non-destructive, applied at playback to the selected MIDI tracks."); - let mut changed = RtpChanged::default(); - changed.velocity = ui.add(egui::Slider::new(&mut app.ops.rtp_velocity, -127..=127).text("Velocity +")).changed(); - changed.transpose = ui.add(egui::Slider::new(&mut app.ops.rtp_transpose, -48..=48).text("Transpose")).changed(); - changed.duration = ui.add(egui::Slider::new(&mut app.ops.rtp_duration, 1.0..=400.0).text("Duration %")).changed(); - changed.delay = ui.add(egui::Slider::new(&mut app.ops.rtp_delay, -960..=960).text("Delay (ticks)")).changed(); - if let Some(p) = rtp_params(changed, &app.ops) { - let _ = app.engine.execute_merged("event.midi_rtp", &p, "rtp"); - } - ui.horizontal(|ui| { - if ui.button("Write to Notes").clicked() { - let _ = app.run("track.write_midi_rtp", json!({})); - } - if ui.button("Clear").clicked() { - let _ = app.run("event.midi_rtp", json!({"clear": true})); - app.ops.rtp_velocity = 0; - app.ops.rtp_transpose = 0; - app.ops.rtp_duration = 100.0; - app.ops.rtp_delay = 0; + egui::Window::new(crate::localization::text("MIDI Real-Time Properties")) + .id(egui::Id::unique("MIDI Real-Time Properties")) + .open(&mut open) + .default_size(vec2(340.0, 200.0)) + .show(ctx, |ui| { + ui.label(crate::localization::text("Non-destructive, applied at playback to the selected MIDI tracks.")); + let mut changed = RtpChanged::default(); + changed.velocity = + ui.add(egui::Slider::new(&mut app.ops.rtp_velocity, -127..=127).text(crate::localization::text("Velocity +"))).changed(); + changed.transpose = + ui.add(egui::Slider::new(&mut app.ops.rtp_transpose, -48..=48).text(crate::localization::text("Transpose"))).changed(); + changed.duration = + ui.add(egui::Slider::new(&mut app.ops.rtp_duration, 1.0..=400.0).text(crate::localization::text("Duration %"))).changed(); + changed.delay = ui.add(egui::Slider::new(&mut app.ops.rtp_delay, -960..=960).text(crate::localization::text("Delay (ticks)"))).changed(); + if let Some(p) = rtp_params(changed, &app.ops) { + let _ = app.engine.execute_merged("event.midi_rtp", &p, "rtp"); } + ui.horizontal(|ui| { + if ui.button(crate::localization::text("Write to Notes")).clicked() { + let _ = app.run("track.write_midi_rtp", json!({})); + } + if ui.button(crate::localization::text("Clear")).clicked() { + let _ = app.run("event.midi_rtp", json!({"clear": true})); + app.ops.rtp_velocity = 0; + app.ops.rtp_transpose = 0; + app.ops.rtp_duration = 100.0; + app.ops.rtp_delay = 0; + } + }); }); - }); app.ui.show_rtp = open; } diff --git a/crates/ui-egui/src/dialogs/recent.rs b/crates/ui-egui/src/dialogs/recent.rs index 597cc99c..221880f7 100644 --- a/crates/ui-egui/src/dialogs/recent.rs +++ b/crates/ui-egui/src/dialogs/recent.rs @@ -85,9 +85,9 @@ impl SoundApp { /// The File › Open Recent submenu. pub fn menu(app: &mut SoundApp, ui: &mut egui::Ui) { - ui.menu_button("Open Recent", |ui| { + ui.menu_button(crate::localization::text("Open Recent"), |ui| { if app.ui.recent_sessions.is_empty() { - ui.add_enabled(false, egui::Button::new("No Recent Sessions")); + ui.add_enabled(false, egui::Button::new(crate::localization::text("No Recent Sessions"))); return; } let now = ui.ctx().input(|i| i.time); @@ -95,14 +95,17 @@ pub fn menu(app: &mut SoundApp, ui: &mut egui::Ui) { let mut open = None; for (i, path) in app.ui.recent_sessions.iter().enumerate() { let here = exists.get(i).copied().unwrap_or(true); - let text = if here { label(path) } else { format!("{} (missing)", label(path)) }; - let r = ui.add_enabled(here, egui::Button::new(text)).on_hover_text(path.as_str()).on_disabled_hover_text(format!("{path}\nnot found")); + let text = if here { label(path) } else { crate::localized_format!("{} (missing)", label(path)) }; + let r = ui + .add_enabled(here, egui::Button::new(text)) + .on_hover_text(path.as_str()) + .on_disabled_hover_text(crate::localized_format!("{path}\nnot found", path = path)); if r.clicked() { open = Some(path.clone()); } } ui.separator(); - if ui.button("Clear Recent").clicked() { + if ui.button(crate::localization::text("Clear Recent")).clicked() { app.ui.recent_sessions.clear(); app.recent_changed = true; ui.close(); @@ -112,7 +115,7 @@ pub fn menu(app: &mut SoundApp, ui: &mut egui::Ui) { // Through the dialog layer, so unsaved changes are asked about first. if let Err(e) = crate::dialogs::run_or_ask(app, "session.open", json!({"path": path})) { log::warn!("{path}: {e}"); - app.ui.status = format!("Could not open {path}: {e}"); + app.ui.status = crate::localized_format!("Could not open {path}: {e}", path = path, e = e); } } }); diff --git a/crates/ui-egui/src/dialogs/recovery.rs b/crates/ui-egui/src/dialogs/recovery.rs index bd66e297..6b8782a2 100644 --- a/crates/ui-egui/src/dialogs/recovery.rs +++ b/crates/ui-egui/src/dialogs/recovery.rs @@ -9,22 +9,28 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { let Some(left) = app.leftovers.first().cloned() else { return }; let mut open = true; let mut recover = None; - egui::Window::new(egui::RichText::new("Recover Unsaved Work").font(bold(13.0))) + egui::Window::new(egui::RichText::new(crate::localization::text("Recover Unsaved Work")).font(bold(13.0))) + .id(egui::Id::unique("Recover Unsaved Work")) .open(&mut open) .collapsible(false) .resizable(false) .anchor(Align2::CENTER_CENTER, vec2(0.0, -80.0)) .show(ctx, |ui| { - let age = left.saved.elapsed().map_or_else(|_| "recently".into(), |d| ago(d.as_secs())); - let what = if left.recording { "unsaved changes and an unfinished recording" } else { "unsaved changes" }; - ui.label(format!("“{}” has {what} from an earlier run, autosaved {age}.", left.name)); + let age = left.saved.elapsed().map_or_else(|_| crate::localization::text("recently").to_owned(), |d| ago(d.as_secs())); + let what = crate::localization::text(if left.recording { "unsaved changes and an unfinished recording" } else { "unsaved changes" }); + ui.label(crate::localized_format!("“{name}” has {what} from an earlier run, autosaved {age}.", name = left.name, what = what, age = age)); ui.separator(); ui.horizontal(|ui| { - if ui.button("Discard").clicked() { + if ui.button(crate::localization::text("Discard")).clicked() { recover = Some(false); } - let recover_button = egui::Button::new(egui::RichText::new("Recover").strong()).fill(Tokens::current().accent); - if ui.add_enabled(!app.engine.transport.recording, recover_button).on_disabled_hover_text("Stop recording first").clicked() { + let recover_button = + egui::Button::new(egui::RichText::new(crate::localization::text("Recover")).strong()).fill(Tokens::current().accent); + if ui + .add_enabled(!app.engine.transport.recording, recover_button) + .on_disabled_hover_text(crate::localization::text("Stop recording first")) + .clicked() + { recover = Some(true); } }); @@ -41,10 +47,15 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { fn ago(secs: u64) -> String { let (n, unit) = match secs { - 0..60 => return "less than a minute ago".into(), + 0..60 => return crate::localization::text("less than a minute ago").to_owned(), 60..3_600 => (secs / 60, "minute"), 3_600..86_400 => (secs / 3_600, "hour"), _ => (secs / 86_400, "day"), }; - format!("{n} {unit}{} ago", if n == 1 { "" } else { "s" }) + let unit = crate::localization::text(unit); + if n == 1 { + crate::localized_format!("{n} {unit} ago", n = n, unit = unit) + } else { + crate::localized_format!("{n} {unit}s ago", n = n, unit = unit) + } } diff --git a/crates/ui-egui/src/dialogs/spot.rs b/crates/ui-egui/src/dialogs/spot.rs index 88f361c2..b28f2995 100644 --- a/crates/ui-egui/src/dialogs/spot.rs +++ b/crates/ui-egui/src/dialogs/spot.rs @@ -141,10 +141,10 @@ fn spot_field_row(ui: &mut Ui, s: &Session, d: &mut Spot, i: usize, label: &str) } fn original_time_stamp_row(ui: &mut Ui, s: &Session, d: &mut Spot, at: Samples) { - ui.label("Original Time Stamp"); + ui.label(crate::localization::text("Original Time Stamp")); ui.horizontal(|ui| { ui.label(RichText::new(s.format_position(at, TimeFormat::Timecode)).font(mono(13.0))); - if ui.button("Use").on_hover_text("Spot to where it was recorded").clicked() { + if ui.button(crate::localization::text("Use")).on_hover_text(crate::localization::text("Spot to where it was recorded")).clicked() { d.start = at; } }); @@ -154,12 +154,13 @@ fn original_time_stamp_row(ui: &mut Ui, s: &Session, d: &mut Spot, at: Samples) /// The dialog's fields; the caller adds OK and Cancel. pub fn fields(ui: &mut Ui, s: &Session, d: &mut Spot) { egui::Grid::new("spot").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| { - let scale = ui.label("Time Scale"); - let time_scale = craft_ui::ComboBox::from_id_salt("spot_scale").selected_text(d.format.label()).show_ui(ui, |ui| { - for f in TimeFormat::ALL { - ui.selectable_value(&mut d.format, f, f.label()); - } - }); + let scale = ui.label(crate::localization::text("Time Scale")); + let time_scale = + craft_ui::ComboBox::from_id_salt("spot_scale").selected_text(crate::localization::text(d.format.label())).show_ui(ui, |ui| { + for f in TimeFormat::ALL { + ui.selectable_value(&mut d.format, f, crate::localization::text(f.label())); + } + }); time_scale.response.labelled_by(scale.id); ui.end_row(); for (i, label) in FIELDS.into_iter().enumerate() { @@ -168,7 +169,7 @@ pub fn fields(ui: &mut Ui, s: &Session, d: &mut Spot) { } spot_field_row(ui, s, d, i, label); } - ui.label("Duration"); + ui.label(crate::localization::text("Duration")); ui.label(RichText::new(format_length(d.start, d.len, d.format, s.sample_rate, &s.tempo, s.frame_rate)).font(mono(13.0))); ui.end_row(); if let Some(at) = d.stamp { diff --git a/crates/ui-egui/src/dialogs/strip_silence.rs b/crates/ui-egui/src/dialogs/strip_silence.rs index ae50a572..2b78bfa6 100644 --- a/crates/ui-egui/src/dialogs/strip_silence.rs +++ b/crates/ui-egui/src/dialogs/strip_silence.rs @@ -150,23 +150,23 @@ pub(super) const AUTO_NAME_LABELS: [&str; 2] = ["Starting Number", "Number of Pl pub(super) fn strip_name_fields(ui: &mut egui::Ui, names: &mut StripNames, labels: [&str; 2]) { let [number, zeros] = labels; egui::Grid::new("strip_names").num_columns(2).spacing(vec2(10.0, 8.0)).show(ui, |ui| { - let name = ui.label("Name"); + let name = ui.label(crate::localization::text("Name")); ui.text_edit_singleline(&mut names.name).labelled_by(name.id); ui.end_row(); - let number = ui.label(number); + let number = ui.label(crate::localization::text(number)); ui.add(egui::DragValue::new(&mut names.number).range(0..=StripNames::MAX_NUMBER)).labelled_by(number.id); ui.end_row(); - let zeros = ui.label(zeros); + let zeros = ui.label(crate::localization::text(zeros)); ui.add(egui::DragValue::new(&mut names.zeros).range(0..=StripNames::MAX_ZEROS)).labelled_by(zeros.id); ui.end_row(); - let suffix = ui.label("Suffix"); + let suffix = ui.label(crate::localization::text("Suffix")); ui.text_edit_singleline(&mut names.suffix).labelled_by(suffix.id); ui.end_row(); }); let example = if names.name.trim().is_empty() { - "Without a name, the clips keep their names.".to_string() + crate::localization::text("Without a name, the clips keep their names.").to_string() } else { - format!("First clip: {}", names.clip_name(0)) + crate::localized_format!("First clip: {}", names.clip_name(0)) }; ui.label(egui::RichText::new(example).small().color(Tokens::current().text_dim)); } diff --git a/crates/ui-egui/src/docking.rs b/crates/ui-egui/src/docking.rs index 91276156..705d61a1 100644 --- a/crates/ui-egui/src/docking.rs +++ b/crates/ui-egui/src/docking.rs @@ -452,7 +452,7 @@ pub fn show(app: &mut crate::SoundApp, ui: &mut egui::Ui, window: crate::MainWin if edit { std::mem::replace(&mut app.ui.docking, edit_default()) } else { std::mem::replace(&mut app.ui.mix_docking, mix_default()) }; let before_sync = workspace.clone(); if let Err(error) = (if edit { validate(&workspace) } else { validate_mix(&workspace) }).and_then(|()| sync(&mut workspace, app, edit)) { - app.ui.status = format!("Panel layout could not be restored: {error}"); + app.ui.status = crate::localized_format!("Panel layout could not be restored: {error}", error = error); workspace = if edit { edit_default() } else { mix_default() }; let _ = sync(&mut workspace, app, edit); } @@ -481,7 +481,7 @@ pub fn show(app: &mut crate::SoundApp, ui: &mut egui::Ui, window: crate::MainWin ui, &workspace.layout, &style, - |panel| panel.label().into(), + |panel| crate::localization::text(panel.label()).into(), permissions, panel_limits, |ui, panel| match panel { @@ -508,7 +508,7 @@ pub fn show(app: &mut crate::SoundApp, ui: &mut egui::Ui, window: crate::MainWin store(app, workspace, edit); for action in output.actions { if let Err(error) = command_for(app, &DockCommand::Layout { action }, edit) { - app.ui.status = format!("Panel move was not applied: {error}"); + app.ui.status = crate::localized_format!("Panel move was not applied: {error}", error = error); } } } diff --git a/crates/ui-egui/src/edit_window.rs b/crates/ui-egui/src/edit_window.rs index 6bcbfd42..7db88e68 100644 --- a/crates/ui-egui/src/edit_window.rs +++ b/crates/ui-egui/src/edit_window.rs @@ -81,7 +81,7 @@ fn dock_tabs(app: &mut SoundApp, ui: &mut Ui) { ("MEMORY LOCATIONS", app.ui.show_memory_locations, "window.memory_locations"), ("UNDO HISTORY", app.ui.show_undo_history, "window.undo_history"), ] { - let g = ui.painter().layout_no_wrap(label.to_string(), bold(10.5), if on { Color32::WHITE } else { t.text_dim }); + let g = ui.painter().layout_no_wrap(crate::localization::text(label).to_string(), bold(10.5), if on { Color32::WHITE } else { t.text_dim }); let tr = Rect::from_min_size(pos2(x, r.min.y + 2.0), vec2(g.size().x + 16.0, r.height() - 4.0)); if on { ui.painter().rect_filled(tr, 3.0, t.accent_dark); @@ -98,25 +98,20 @@ fn status_bar(app: &mut SoundApp, ui: &mut Ui) { let t = Tokens::current(); let r = ui.max_rect(); let s = app.engine.session(); - let mut left = format!( - "{} · {} Hz · {} · {} tracks · {}", - s.name, - s.sample_rate.hz(), - match s.bit_depth { - soundcraft_model::BitDepthSetting::Int16 => "16-bit", - soundcraft_model::BitDepthSetting::Int24 => "24-bit", - soundcraft_model::BitDepthSetting::Float32 => "32-bit float", - }, - s.tracks.len(), - app.ui.status - ); + let depth = match s.bit_depth { + soundcraft_model::BitDepthSetting::Int16 => crate::localization::text("16-bit"), + soundcraft_model::BitDepthSetting::Int24 => crate::localization::text("24-bit"), + soundcraft_model::BitDepthSetting::Float32 => crate::localization::text("32-bit float"), + }; + let tracks = if s.tracks.len() == 1 { crate::localized_format!("1 track") } else { crate::localized_format!("{n} tracks", n = s.tracks.len()) }; + let mut left = crate::localized_format!("{} · {} Hz · {} · {} · {}", s.name, s.sample_rate.hz(), depth, tracks, app.ui.status); soundcraft_model::truncate_chars(&mut left, 4 * soundcraft_model::MAX_NAME_CHARS); ui.painter().text(pos2(r.min.x + 10.0, r.center().y), Align2::LEFT_CENTER, left, regular(11.0), t.text_dim); - let undo = app.engine.undo_label().map_or(String::new(), |l| format!("Undo {l}")); + let undo = app.engine.undo_label().map_or(String::new(), |l| crate::localized_format!("Undo {l}", l = crate::localization::text(l))); ui.painter().text( pos2(r.max.x - 10.0, r.center().y), Align2::RIGHT_CENTER, - if app.frame_ms < 50.0 { format!("{undo} {:.1} ms/frame", app.frame_ms) } else { undo }, + if app.frame_ms < 50.0 { crate::localized_format!("{undo} {ms:.1} ms/frame", undo = undo, ms = app.frame_ms) } else { undo }, regular(11.0), t.text_dim, ); diff --git a/crates/ui-egui/src/edit_window/clips.rs b/crates/ui-egui/src/edit_window/clips.rs index 9e455564..6fe384a0 100644 --- a/crates/ui-egui/src/edit_window/clips.rs +++ b/crates/ui-egui/src/edit_window/clips.rs @@ -263,7 +263,13 @@ fn draw_clip_content(cl: &ClipLane<'_>, clip: &Clip, g: &ClipGeom<'_>) { } } } else { - painter.text(body_r.center(), Align2::CENTER_CENTER, "media offline", regular(10.0), Color32::from_rgb(220, 120, 120)); + painter.text( + body_r.center(), + Align2::CENTER_CENTER, + crate::localization::text("media offline"), + regular(10.0), + Color32::from_rgb(220, 120, 120), + ); } } ClipContent::Video { .. } => {} // thumbnails: video_track::draw_lane @@ -482,7 +488,7 @@ pub(super) fn clip_marks(clip: &Clip, show_rating: bool) -> String { /// Gap between a pill and the clip outline's inner edge (so the pill sits 1 pt inside the outline). pub(super) const PILL_INSET: f32 = 2.0; -pub(super) const PILL_HEIGHT: f32 = 13.0; +pub(super) const PILL_HEIGHT: f32 = 14.0; /// Horizontal padding between a pill's edge and its text. pub(super) const PILL_PAD: f32 = 3.0; /// The narrowest name pill worth drawing: its padding plus about one letter. diff --git a/crates/ui-egui/src/edit_window/header.rs b/crates/ui-egui/src/edit_window/header.rs index 176d425b..07b0eba2 100644 --- a/crates/ui-egui/src/edit_window/header.rs +++ b/crates/ui-egui/src/edit_window/header.rs @@ -94,11 +94,11 @@ fn strip_buttons(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) { ui.painter().circle_filled(round.center(), 5.0, shade(strip, if rresp.hovered() { 0.6 } else { 0.45 })); arrow(ui.painter(), round.center(), !track.is_folder() || track.folder_open, ink); if track.is_folder() { - if rresp.on_hover_text(if track.folder_open { "Close folder" } else { "Open folder" }).clicked() { + if rresp.on_hover_text(crate::localization::text(if track.folder_open { "Close folder" } else { "Open folder" })).clicked() { let _ = app.run("track.folder_toggle", json!({"track": id.0})); } } else { - egui::Popup::menu(&rresp.on_hover_text("Track options")).show(|ui| track_context_menu(app, ui, id)); + egui::Popup::menu(&rresp.on_hover_text(crate::localization::text("Track options"))).show(|ui| track_context_menu(app, ui, id)); } if h >= 40.0 && track.kind.has_playlist() { let ar = at(3.0, h - 12.0, 9.0, 9.0); @@ -109,7 +109,7 @@ fn strip_buttons(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) { ui.painter().line_segment([a, b], Stroke::new(1.0, ink)); ui.painter().circle_filled(a, 1.3, ink); ui.painter().circle_filled(b, 1.3, ink); - if aresp.on_hover_text(if showing { "Hide automation" } else { "Show volume automation" }).clicked() { + if aresp.on_hover_text(crate::localization::text(if showing { "Hide automation" } else { "Show volume automation" })).clicked() { let view = if !showing { "volume" } else if track.kind.is_midi() { @@ -199,14 +199,14 @@ fn playlist_menu(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect, hea let presp = ui.interact(pl_r, ui.scope_id().with(("pl", id.0)), Sense::click()); ui.painter().rect_filled(pl_r, 1.5, shade(head_bg, if presp.hovered() { -0.2 } else { -0.35 })); arrow(ui.painter(), pos2(pl_r.center().x, pl_r.min.y + 5.75), true, t.text); - egui::Popup::menu(&presp.on_hover_text("Playlists")).show(|ui| { - if ui.button("New...").clicked() { + egui::Popup::menu(&presp.on_hover_text(crate::localization::text("Playlists"))).show(|ui| { + if ui.button(crate::localization::text("New...")).clicked() { let _ = app.run("track.playlist_new", json!({"track": id.0})); } - if ui.button("Duplicate...").clicked() { + if ui.button(crate::localization::text("Duplicate...")).clicked() { let _ = app.run("track.playlist_duplicate", json!({"track": id.0})); } - if ui.button("Delete Unused...").clicked() { + if ui.button(crate::localization::text("Delete Unused...")).clicked() { let _ = app.run("track.playlist_delete_unused", json!({"track": id.0})); } ui.separator(); @@ -256,10 +256,10 @@ fn view_selector(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) { ui, at(17.0, view_y, 105.0, 17.0), ui.scope_id().with(("view", id.0)), - &view_label(&track.view), + crate::localization::text(&view_label(&track.view)), t.text, true, - &format!("Track view for {}", track.name), + &crate::localized_format!("Track view for {}", track.name), ); egui::Popup::menu(&vresp).show(|ui| view_menu(app, ui, track)); } @@ -272,11 +272,19 @@ fn view_selector(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) { soundcraft_model::AutomationMode::Latch => t.auto_latch, _ => t.text_dim, }; - let mode_name = format!("Automation mode for {}", track.name); - let aresp = header_selector(ui, at(17.0, 39.0, 105.0, 17.0), ui.scope_id().with(("auto_mode", id.0)), mode.label(), col, true, &mode_name); + let mode_name = crate::localized_format!("Automation mode for {}", track.name); + let aresp = header_selector( + ui, + at(17.0, 39.0, 105.0, 17.0), + ui.scope_id().with(("auto_mode", id.0)), + crate::localization::text(mode.label()), + col, + true, + &mode_name, + ); egui::Popup::menu(&aresp).show(|ui| { for m in soundcraft_model::AutomationMode::ALL { - if ui.selectable_label(m == mode, m.label()).clicked() { + if ui.selectable_label(m == mode, crate::localization::text(m.label())).clicked() { let _ = app.run("mix.automation_mode", json!({"track": id.0, "mode": m.label()})); } } @@ -303,17 +311,25 @@ fn voice_row(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) { let d = vec2(a.to_radians().sin(), a.to_radians().cos()) * 3.5; ui.painter().line_segment([r.center() - d, r.center() + d], Stroke::new(1.5, t.text)); } - if resp.on_hover_text(if track.frozen { "Unfreeze" } else { "Freeze" }).clicked() { + if resp.on_hover_text(crate::localization::text(if track.frozen { "Unfreeze" } else { "Freeze" })).clicked() { let _ = app.run("track.freeze", json!({"tracks": [id.0]})); } } if !matches!(track.kind, TrackKind::Master | TrackKind::Vca | TrackKind::Folder) { let (voice, color) = if track.inactive { ("off", t.text_dim) } else { ("dyn", t.text) }; - let voice_name = format!("Voice for {}", track.name); - let resp = header_selector(ui, at(31.0, 57.0, 31.0, 17.0), ui.scope_id().with(("voice", id.0)), voice, color, false, &voice_name); - egui::Popup::menu(&resp.on_hover_text("Voice: dyn plays the track, off makes it inactive")).show(|ui| { + let voice_name = crate::localized_format!("Voice for {}", track.name); + let resp = header_selector( + ui, + at(31.0, 57.0, 31.0, 17.0), + ui.scope_id().with(("voice", id.0)), + crate::localization::text(voice), + color, + false, + &voice_name, + ); + egui::Popup::menu(&resp.on_hover_text(crate::localization::text("Voice: dyn plays the track, off makes it inactive"))).show(|ui| { for (label, inactive) in [("dyn", false), ("off", true)] { - if ui.selectable_label(track.inactive == inactive, label).clicked() { + if ui.selectable_label(track.inactive == inactive, crate::localization::text(label)).clicked() { let _ = app.run("track.make_inactive", json!({"tracks": [id.0], "inactive": inactive})); } } @@ -327,11 +343,19 @@ fn voice_row(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) { soundcraft_model::AutomationMode::Latch => t.auto_latch, _ => t.text_dim, }; - let mode_name = format!("Automation mode for {}", track.name); - let aresp = header_selector(ui, at(63.0, 57.0, 59.0, 17.0), ui.scope_id().with(("auto_mode", id.0)), mode.label(), col, true, &mode_name); + let mode_name = crate::localized_format!("Automation mode for {}", track.name); + let aresp = header_selector( + ui, + at(63.0, 57.0, 59.0, 17.0), + ui.scope_id().with(("auto_mode", id.0)), + crate::localization::text(mode.label()), + col, + true, + &mode_name, + ); egui::Popup::menu(&aresp).show(|ui| { for m in soundcraft_model::AutomationMode::ALL { - if ui.selectable_label(m == mode, m.label()).clicked() { + if ui.selectable_label(m == mode, crate::localization::text(m.label())).clicked() { let _ = app.run("mix.automation_mode", json!({"track": id.0, "mode": m.label()})); } } @@ -378,10 +402,13 @@ fn field_row(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect, head_bg let resp = ui.interact(field, ui.scope_id().with(("field", id.0)), Sense::click()); ui.painter().rect_filled(field, 2.0, shade(head_bg, if resp.hovered() { -0.02 } else { -0.1 })); if track.kind == TrackKind::Instrument { - let name = - track.instrument.as_ref().and_then(|i| crate::mix_window::plugin_info(&i.plugin)).map_or("no instrument", |p| p.short_name); + let name = track + .instrument + .as_ref() + .and_then(|i| crate::mix_window::plugin_info(&i.plugin)) + .map_or_else(|| crate::localization::text("no instrument"), |p| p.short_name); ui.painter().with_clip_rect(field).text(pos2(field.min.x + 5.0, field.center().y), Align2::LEFT_CENTER, name, bold(10.0), t.text); - egui::Popup::menu(&resp.on_hover_text("Instrument")) + egui::Popup::menu(&resp.on_hover_text(crate::localization::text("Instrument"))) .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside) .show(|ui| crate::mix_window::instrument_menu(app, ui, id)); } else { @@ -397,7 +424,7 @@ fn field_row(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect, head_bg t.text, ); } - egui::Popup::menu(&resp.on_hover_text("Elastic Audio")).show(|ui| { + egui::Popup::menu(&resp.on_hover_text(crate::localization::text("Elastic Audio"))).show(|ui| { for alg in ["none", "polyphonic", "rhythmic", "monophonic", "varispeed", "x-form"] { let current = track.elastic.as_deref().unwrap_or("none") == alg; if ui.selectable_label(current, soundcraft_engine::feature_names::display_label(alg)).clicked() { @@ -427,6 +454,7 @@ pub(super) fn header_selector(ui: &Ui, r: Rect, id: egui::Id, text: &str, color: let resp = ui.interact(r, id, Sense::click()); resp.widget_info(|| { let mut info = egui::WidgetInfo::labeled(egui::accesskit::Role::ComboBox, ui.is_enabled(), name); + // `text` can be a user-defined route name (a bus called "File"), so show it unchanged. info.current_text_value = Some(text.to_string()); info }); @@ -451,14 +479,23 @@ enum HeaderKey { /// mute that another track's solo implies). Record keys stay dark red when off, as in Pro Tools. fn header_toggle(ui: &Ui, r: Rect, track: TrackId, track_name: &str, key: HeaderKey, lit: bool, implied: bool) -> egui::Response { let t = Tokens::current(); - let (label, color) = match key { + let (source_label, color) = match key { HeaderKey::Rec => ("Record enable", t.rec), HeaderKey::Input => ("Input monitoring", t.input), HeaderKey::Solo => ("Solo", t.solo), HeaderKey::Mute => ("Mute", t.mute), }; - let name = format!("{label} for {track_name}"); - let resp = ui.interact(r, ui.scope_id().with((label, track.0)), Sense::click()); + let label = crate::localization::text(source_label); + // Fixed badges, independent of the translated label: in some languages the translated + // labels for two different buttons would otherwise start with the same letter. + let badge = match key { + HeaderKey::Rec => "", + HeaderKey::Input => "I", + HeaderKey::Solo => "S", + HeaderKey::Mute => "M", + }; + let name = crate::localized_format!("{} for {}", label, track_name); + let resp = ui.interact(r, ui.scope_id().with((source_label, track.0)), Sense::click()); resp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), lit, &name)); let rec = key == HeaderKey::Rec; let (tint, k) = if lit { @@ -482,7 +519,7 @@ fn header_toggle(ui: &Ui, r: Rect, track: TrackId, track_name: &str, key: Header if rec { ui.painter().circle_filled(r.center(), 4.0, if lit { Color32::WHITE } else { t.text.lerp_to_gamma(color, 0.3) }); } else { - ui.painter().text(r.center(), Align2::CENTER_CENTER, label.get(..1).unwrap_or_default(), bold(11.0), ink); + ui.painter().text(r.center(), Align2::CENTER_CENTER, badge, bold(11.0), ink); } resp.on_hover_text(label) } @@ -532,7 +569,7 @@ pub(super) fn header_column(app: &mut SoundApp, ui: &mut Ui, track: &Track, col: let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r.shrink(3.0))); let field = crate::widgets::named_text_field( child.add(egui::TextEdit::multiline(&mut c).desired_width(r.width() - 6.0).font(regular(10.0))), - &format!("Comments for {}", track.name), + &crate::localized_format!("Comments for {}", track.name), ); if field.changed() { let _ = @@ -552,8 +589,9 @@ fn io_column(app: &mut SoundApp, ui: &mut Ui, track: &Track, r: Rect) { let row = |y: f32, h: f32| (r.height() >= y + h + 1.0).then_some(Rect::from_min_size(r.min + vec2(7.0, y), vec2(r.width() - 14.0, h))); if let Some(input) = row(4.0, 15.0).filter(|_| crate::mix_window::has_input_selector(track.kind)) { let input_name = crate::mix_window::input_name(app, track); - let resp = header_selector(&ui, input, ui.scope_id().with(("in", id.0)), &input_name, t.text, true, &format!("Input for {}", track.name)); - crate::mix_window::route_popup(app, &resp.on_hover_text("Input"), id, true); + let name = crate::localized_format!("Input for {}", track.name); + let resp = header_selector(&ui, input, ui.scope_id().with(("in", id.0)), &input_name, t.text, true, &name); + crate::mix_window::route_popup(app, &resp.on_hover_text(crate::localization::text("Input")), id, true); } if let Some(out) = row(21.0, 17.0) { let (sel, fader) = (out.with_max_x(out.max.x - 11.0), out.with_min_x(out.max.x - 11.0)); @@ -578,9 +616,9 @@ fn io_column(app: &mut SoundApp, ui: &mut Ui, track: &Track, r: Rect) { if shown { ui.painter().rect_stroke(fader.shrink(0.5), 1.0, Stroke::new(1.5, t.accent), StrokeKind::Inside); } - crate::mix_window::route_popup(app, &resp.on_hover_text("Output"), id, false); + crate::mix_window::route_popup(app, &resp.on_hover_text(crate::localization::text("Output")), id, false); // As in Pro Tools, the fader button opens the track's Output window, not the Mix window (#1392). - if fresp.on_hover_text("Output window").clicked() { + if fresp.on_hover_text(crate::localization::text("Output window")).clicked() { crate::mix_window::toggle_output_window(app, id); } } diff --git a/crates/ui-egui/src/edit_window/input.rs b/crates/ui-egui/src/edit_window/input.rs index 15bf71a3..54d16b70 100644 --- a/crates/ui-egui/src/edit_window/input.rs +++ b/crates/ui-egui/src/edit_window/input.rs @@ -513,7 +513,7 @@ pub(super) fn new_midi_clip(app: &mut SoundApp, s: &Session, track: TrackId, fro fn clip_context_menu(app: &mut SoundApp, ui: &mut Ui, clip: Option) { let Some(c) = clip else { - if ui.button("Paste").clicked() { + if ui.button(crate::localization::text("Paste")).clicked() { let _ = app.run("edit.paste", json!({})); } return; @@ -535,11 +535,11 @@ fn clip_context_menu(app: &mut SoundApp, ui: &mut Ui, clip: Option) { } } ui.separator(); - if ui.button("Rename...").clicked() { + if ui.button(crate::localization::text("Rename...")).clicked() { let name = app.engine.session().find_clip(c).map(|(_, x)| x.name.clone()).unwrap_or_default(); app.dialogs.open_rename_clip(c, &name); } - if ui.button("Delete").clicked() { + if ui.button(crate::localization::text("Delete")).clicked() { let s = app.engine.session(); let selected: Vec = s.edit.selected_clips.iter().map(|id| id.0).collect(); let track: Vec = s.find_clip(c).map(|(t, _)| t.0).into_iter().collect(); diff --git a/crates/ui-egui/src/edit_window/rulers.rs b/crates/ui-egui/src/edit_window/rulers.rs index a9b7a647..7ea3b566 100644 --- a/crates/ui-egui/src/edit_window/rulers.rs +++ b/crates/ui-egui/src/edit_window/rulers.rs @@ -99,7 +99,13 @@ pub(super) fn draw_rulers(app: &mut SoundApp, ui: &mut Ui, area: Rect, tl: Rect, let lab = Rect::from_min_max(pos2(area.min.x, y0), pos2(area.min.x + HEADER_W, y0 + h)); y0 += h; let painter = ui.painter().with_clip_rect(row); - ui.painter().text(pos2(lab.max.x - 12.0, lab.center().y), Align2::RIGHT_CENTER, ruler_label(id), bold(11.0), t.ruler_text); + ui.painter().text( + pos2(lab.max.x - 12.0, lab.center().y), + Align2::RIGHT_CENTER, + crate::localization::text(ruler_label(id)), + bold(11.0), + t.ruler_text, + ); let fmt = TimeFormat::from_id(id); match id.as_str() { "tempo" => { @@ -151,7 +157,13 @@ pub(super) fn draw_rulers(app: &mut SoundApp, ui: &mut Ui, area: Rect, tl: Rect, "key" => { painter.rect_filled(row, 0.0, Color32::from_rgb(64, 52, 88)); if s.key_signatures.is_empty() { - painter.text(pos2(tl.min.x + 6.0, row.center().y), Align2::LEFT_CENTER, "C major", bold(11.0), Color32::from_rgb(220, 214, 236)); + painter.text( + pos2(tl.min.x + 6.0, row.center().y), + Align2::LEFT_CENTER, + crate::localization::text("C major"), + bold(11.0), + Color32::from_rgb(220, 214, 236), + ); } for (at, k) in &s.key_signatures { let x = x_of(&s, tl, *at); @@ -374,7 +386,7 @@ pub(super) fn column_titles(ui: &Ui, rulers: Rect, cols: &[Column]) { ui.painter().vline(end - 0.5, row.y_range(), line); for &(_, _, title, w) in cols { ui.painter().vline(x + 0.5, row.y_range(), line); - ui.painter().text(pos2(x + w / 2.0, row.center().y), Align2::CENTER_CENTER, title, bold(10.0), t.section_label); + ui.painter().text(pos2(x + w / 2.0, row.center().y), Align2::CENTER_CENTER, crate::localization::text(title), bold(10.0), t.section_label); x += w; } } @@ -383,9 +395,9 @@ pub(super) fn column_titles(ui: &Ui, rulers: Rect, cols: &[Column]) { pub(super) fn views_button(app: &mut SoundApp, ui: &mut Ui, rulers: Rect) { let r = Rect::from_min_size(rulers.min + vec2(6.0, 5.0), vec2(50.0, 18.0)); let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r)); - let resp = crate::widgets::selector_box(&mut child, r.width(), r.height(), "Views", Tokens::current().text); - resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::ComboBox, child.is_enabled(), "Views")); - let resp = resp.on_hover_text("Columns beside the track headers: inserts, sends, I/O…"); + let resp = crate::widgets::selector_box(&mut child, r.width(), r.height(), crate::localization::text("Views"), Tokens::current().text); + resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::ComboBox, child.is_enabled(), crate::localization::text("Views"))); + let resp = resp.on_hover_text(crate::localization::text("Columns beside the track headers: inserts, sends, I/O…")); egui::Popup::menu(&resp).close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside).show(|ui| { let shown = edit_columns(app.engine.session()); for (id, label, _, _) in COLUMNS { @@ -394,10 +406,10 @@ pub(super) fn views_button(app: &mut SoundApp, ui: &mut Ui, rulers: Rect) { } } ui.separator(); - if ui.button("All").clicked() { + if ui.button(crate::localization::text("All")).clicked() { let _ = app.run("view.edit_all", json!({})); } - if ui.button("Minimal").clicked() { + if ui.button(crate::localization::text("Minimal")).clicked() { let _ = app.run("view.edit_minimal", json!({})); } }); diff --git a/crates/ui-egui/src/edit_window/tracks.rs b/crates/ui-egui/src/edit_window/tracks.rs index b495da28..1f9813fd 100644 --- a/crates/ui-egui/src/edit_window/tracks.rs +++ b/crates/ui-egui/src/edit_window/tracks.rs @@ -163,7 +163,7 @@ fn playlist_lanes(app: &mut SoundApp, ui: &mut Ui, track: &Track, row: Rect, mai let _ = app.run("track.playlist_promote", json!({"track": track.id.0, "playlist": i, "start": a, "end": b})); } } - resp.on_hover_text("Click a take (or the selection) to promote it to the main playlist"); + resp.on_hover_text(crate::localization::text("Click a take (or the selection) to promote it to the main playlist")); y += LANE_H; } } @@ -185,7 +185,7 @@ pub(super) fn view_menu(app: &mut SoundApp, ui: &mut Ui, track: &Track) { } opts.extend(["volume", "pan", "mute"]); for o in opts { - if ui.selectable_label(track.view == o, view_label(o)).clicked() { + if ui.selectable_label(track.view == o, crate::localization::text(&view_label(o))).clicked() { let _ = app.run("track.view", json!({"track": id, "view": o})); } } @@ -240,7 +240,7 @@ pub(crate) fn track_context_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId) { .map(|track| (track.id.0, track.name.clone())) .collect(); if !folders.is_empty() { - ui.menu_button("Move to Folder", |ui| { + ui.menu_button(crate::localization::text("Move to Folder"), |ui| { for (folder, name) in &folders { if ui.button(name).clicked() { let _ = app.run("track.move_to_folder", json!({"tracks": selection, "folder": folder})); @@ -248,24 +248,26 @@ pub(crate) fn track_context_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId) { } }); } - if app.engine.session().track(id).is_some_and(|track| track.folder.is_some()) && ui.button("Remove from Folder").clicked() { + if app.engine.session().track(id).is_some_and(|track| track.folder.is_some()) + && ui.button(crate::localization::text("Remove from Folder")).clicked() + { let _ = app.run("track.remove_from_folder", json!({"tracks": selection})); } // Only the track clicked: the command has one target, and the selection stays as it is. - if ui.button("Scroll Into View").clicked() { + if ui.button(crate::localization::text("Scroll Into View")).clicked() { let _ = app.run("view.scroll_into_view", json!({"track": id.0})); } ui.separator(); - ui.menu_button("Track Height", |ui| { + ui.menu_button(crate::localization::text("Track Height"), |ui| { for h in TrackHeight::ALL { - if ui.button(h.label()).clicked() { + if ui.button(crate::localization::text(h.label())).clicked() { let own: Vec = selection.iter().map(|&t| TrackId(t)).collect(); let tracks = height_targets(app.engine.session(), ui.input(|i| i.modifiers), &own); let _ = app.run("track.height", json!({"tracks": tracks, "height": h.label()})); } } }); - ui.menu_button("Track Color", |ui| { + ui.menu_button(crate::localization::text("Track Color"), |ui| { for (i, c) in soundcraft_model::TRACK_COLORS.iter().enumerate() { let (r, resp) = ui.allocate_exact_size(vec2(120.0, 14.0), Sense::click()); ui.painter().rect_filled(r, 2.0, rgb(*c)); diff --git a/crates/ui-egui/src/import.rs b/crates/ui-egui/src/import.rs index f17a041b..ef242682 100644 --- a/crates/ui-egui/src/import.rs +++ b/crates/ui-egui/src/import.rs @@ -137,7 +137,7 @@ fn finish(app: &mut SoundApp) { Ok(decoded) => { app.engine.offer_import(decoded); if run_now(app, params) { - app.ui.status = format!("Imported {name}"); + app.ui.status = crate::localized_format!("Imported {name}", name = name); } app.engine.drop_offered_imports(); } @@ -166,7 +166,7 @@ pub fn show(app: &SoundApp, ctx: &egui::Context) { ui.horizontal(|ui| { ui.add(egui::Spinner::new()); let more = if waiting > 0 { format!(" ({waiting} more)") } else { String::new() }; - ui.label(format!("Importing {name}{more}")); + ui.label(crate::localized_format!("Importing {name}{more}", name = name, more = more)); }); }); }, diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 0b0ec265..15a0a4d7 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -23,6 +23,7 @@ pub mod edit_window; pub mod fonts; pub mod icons; pub mod import; +pub mod localization; pub mod menus; pub mod mix_window; pub mod palette; @@ -146,6 +147,8 @@ pub struct UiState { pub video_burn_in: bool, pub workspace_dir: String, pub configurations: Vec<(String, Value)>, + /// Interface language (`ui.language`). + pub language: localization::Language, /// Appearance (`ui.theme`): dark by default, light or follow the system on request. pub theme: theme::ThemeMode, /// The main window's size (logical points) and maximized state, and the interface scale, as @@ -216,6 +219,7 @@ impl Default for UiState { video_burn_in: false, workspace_dir: String::new(), configurations: Vec::new(), + language: localization::Language::default(), theme: theme::ThemeMode::Dark, window_size: [1600.0, 1000.0], window_maximized: false, diff --git a/crates/ui-egui/src/localization.rs b/crates/ui-egui/src/localization.rs new file mode 100644 index 00000000..fabbf924 --- /dev/null +++ b/crates/ui-egui/src/localization.rs @@ -0,0 +1,542 @@ +//! Language selection and source-language fallback for UI strings. + +#[path = "../locales/pt-BR/mod.rs"] +mod pt_br; + +use std::cell::Cell; + +thread_local! { + static CURRENT_LANGUAGE: Cell = const { Cell::new(Language::English) }; +} + +/// A language supported by the UI. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub enum Language { + #[default] + #[serde(rename = "en")] + English, + #[serde(rename = "pt-BR")] + PortugueseBrazil, +} + +impl Language { + /// All supported languages, in the order they are shown in the language menu. + pub const ALL: [Self; 2] = [Self::English, Self::PortugueseBrazil]; + + /// Stable language tag used in preferences and control commands. + pub const fn id(self) -> &'static str { + match self { + Self::English => "en", + Self::PortugueseBrazil => "pt-BR", + } + } + + /// English source name of the language; translate it with `text` for display. + pub const fn native_name(self) -> &'static str { + match self { + Self::English => "English", + Self::PortugueseBrazil => "Portuguese (Brazil)", + } + } + + pub fn parse(tag: &str) -> Option { + Self::ALL.into_iter().find(|language| language.id().eq_ignore_ascii_case(tag.trim())) + } + + /// Rewrites the decimal point of a rendered number for this language. + pub fn localize_decimal(self, number: &str) -> String { + match self { + Self::English => number.to_owned(), + Self::PortugueseBrazil => number.replace('.', ","), + } + } + + /// Translates a UI string, falling back to its English source when no translation exists. + pub fn text(self, source: &str) -> &str { + match self { + Self::English => source, + Self::PortugueseBrazil => pt_br::translate(source).unwrap_or(source), + } + } +} + +/// Sets the language used by text widgets on this thread for the duration of a UI frame. +pub fn enter(language: Language) -> LanguageScope { + let previous = CURRENT_LANGUAGE.with(|current| current.replace(language)); + LanguageScope(previous) +} + +/// The language selected for the current UI frame. +pub fn current_language() -> Language { + CURRENT_LANGUAGE.with(Cell::get) +} + +/// Translates a source string using the language selected for the current UI frame. +pub fn text(source: &str) -> &str { + current_language().text(source) +} + +/// Translates an engine error message for display. Messages are matched against the catalog's +/// error templates and their embedded values are carried over; text that matches no template is +/// returned unchanged, so low-level library errors stay in English. +pub fn error_text(message: &str) -> String { + error_text_in(current_language(), message, 0) +} + +const MAX_ERROR_DEPTH: usize = 4; + +fn error_text_in(language: Language, message: &str, depth: usize) -> String { + let templates: &[(&str, &str)] = match language { + Language::English => &[], + Language::PortugueseBrazil => pt_br::ERROR_TEMPLATES, + }; + let mut best: Option<(usize, &str, Vec<(String, String)>)> = None; + for (template, translation) in templates { + if let Some((weight, captures)) = match_template(template, message) + && best.as_ref().is_none_or(|(w, ..)| weight > *w) + { + best = Some((weight, translation, captures)); + } + } + let Some((_, translation, captures)) = best else { return message.to_owned() }; + let captures: Vec<(String, String)> = captures + .into_iter() + .map(|(name, value)| { + let value = if depth < MAX_ERROR_DEPTH { error_text_in(language, &value, depth + 1) } else { value }; + (name, value) + }) + .collect(); + fill_captures(language, translation, &captures) +} + +enum Piece<'a> { + Literal(String), + Field(&'a str), +} + +fn split_template(template: &str) -> Vec> { + let mut pieces = Vec::new(); + let mut literal = String::new(); + let mut rest = template; + while let Some(ch) = rest.chars().next() { + if let Some(after) = rest.strip_prefix("{{") { + literal.push('{'); + rest = after; + } else if let Some(after) = rest.strip_prefix("}}") { + literal.push('}'); + rest = after; + } else if ch == '{' + && let Some(end) = rest.find('}') + { + if !literal.is_empty() { + pieces.push(Piece::Literal(std::mem::take(&mut literal))); + } + pieces.push(Piece::Field(rest.get(1..end).unwrap_or_default())); + rest = rest.get(end + 1..).unwrap_or_default(); + } else { + literal.push(ch); + rest = rest.get(ch.len_utf8()..).unwrap_or_default(); + } + } + if !literal.is_empty() { + pieces.push(Piece::Literal(literal)); + } + pieces +} + +/// Matches `message` against `template`. Returns the template's literal length, used to prefer +/// the most specific template, and the captured values by placeholder name. +fn match_template(template: &str, message: &str) -> Option<(usize, Vec<(String, String)>)> { + let pieces = split_template(template); + let mut captures = Vec::new(); + let mut pos = 0usize; + let mut weight = 0usize; + let mut index = 0usize; + while let Some(piece) = pieces.get(index) { + match piece { + Piece::Literal(text) => { + if !message.get(pos..)?.starts_with(text.as_str()) { + return None; + } + pos += text.len(); + weight += text.len(); + } + Piece::Field(name) => { + let rest = message.get(pos..)?; + let end = match pieces.get(index + 1) { + None => rest.len(), + Some(Piece::Literal(next)) if pieces.len() == index + 2 => { + if rest.len() < next.len() || !rest.ends_with(next.as_str()) { + return None; + } + rest.len() - next.len() + } + Some(Piece::Literal(next)) => rest.find(next.as_str())?, + Some(Piece::Field(_)) => return None, + }; + if end == 0 { + return None; + } + let name = name.split(':').next().unwrap_or_default(); + captures.push((name.to_owned(), rest.get(..end)?.to_owned())); + pos += end; + } + } + index += 1; + } + (pos == message.len() && weight > 0).then_some((weight, captures)) +} + +fn fill_captures(language: Language, translation: &str, captures: &[(String, String)]) -> String { + let mut out = String::with_capacity(translation.len()); + for piece in split_template(translation) { + match piece { + Piece::Literal(text) => out.push_str(&text), + Piece::Field(field) => { + let name = field.split(':').next().unwrap_or_default(); + match captures.iter().find(|(captured, _)| captured == name) { + Some((_, value)) if value.parse::().is_ok() => out.push_str(&language.localize_decimal(value)), + Some((_, value)) => out.push_str(value), + None => { + out.push('{'); + out.push_str(field); + out.push('}'); + } + } + } + } + } + out +} + +/// Whether the Brazilian Portuguese catalog has an entry for `source`, even an identical one. +#[cfg(test)] +pub(crate) fn has_pt_br_entry(source: &str) -> bool { + pt_br::translate(source).is_some() +} + +/// Guard that restores the previously active language when dropped. +pub struct LanguageScope(Language); + +impl Drop for LanguageScope { + /// Restores the language that was active when the scope was created. + fn drop(&mut self) { + CURRENT_LANGUAGE.with(|language| language.set(self.0)); + } +} + +/// One formatting argument, kept as a reference and rendered only when the template asks for it. +/// +/// The template is only known at run time, so the format specifier is too: the formatter reads a +/// `:.N` precision from it and renders the value with that precision. +pub struct Arg<'a> { + value: &'a dyn std::fmt::Display, +} + +impl<'a> Arg<'a> { + /// Wraps the argument without rendering it. + pub fn new(value: &'a T) -> Self { + Self { value } + } + + /// Renders the argument for the given precision specifier (`.0` to `.3`), if any. A number + /// given a precision uses the active language's decimal separator. + fn render(&self, spec: Option<&str>) -> String { + let precision = spec.and_then(|spec| spec.strip_prefix('.')).and_then(|digits| digits.parse::().ok()).filter(|n| *n <= 3); + match precision { + Some(n) => { + let text = format!("{:.*}", n, self.value); + if text.parse::().is_ok() { current_language().localize_decimal(&text) } else { text } + } + None => self.value.to_string(), + } + } +} + +/// Formats the translated `source` with positional arguments. Placeholders may carry a `:.N` +/// precision, as in `format!`; other specifiers are ignored. +pub fn format_positional(source: &str, args: &[Arg<'_>]) -> String { + format_template(source, args, &[], true) +} + +/// Formats the translated `source` with named arguments (`name = value`). +pub fn format_named(source: &str, args: &[(&str, Arg<'_>)]) -> String { + format_template(source, &[], args, false) +} + +/// Shared implementation behind `format_positional` and `format_named`. +fn format_template(source: &str, positional: &[Arg<'_>], named: &[(&str, Arg<'_>)], positional_mode: bool) -> String { + let template = text(source); + let mut out = String::with_capacity(template.len()); + let mut next = 0usize; + let mut chars = template.chars().peekable(); + while let Some(ch) = chars.next() { + match ch { + '{' if chars.peek() == Some(&'{') => { + chars.next(); + out.push('{'); + } + '}' if chars.peek() == Some(&'}') => { + chars.next(); + out.push('}'); + } + '{' => { + let mut field = String::new(); + let mut closed = false; + for ch in chars.by_ref() { + if ch == '}' { + closed = true; + break; + } + field.push(ch); + } + if !closed { + out.push('{'); + out.push_str(&field); + break; + } + let (key, spec) = match field.split_once(':') { + Some((key, spec)) => (key, Some(spec)), + None => (field.as_str(), None), + }; + let value = if positional_mode { + let value = positional.get(next); + next += 1; + value + } else { + named.iter().find(|(name, _)| *name == key).map(|(_, value)| value) + }; + match value { + Some(value) => out.push_str(&value.render(spec)), + None => { + out.push('{'); + out.push_str(&field); + out.push('}'); + } + } + } + '}' => out.push('}'), + ch => out.push(ch), + } + } + out +} + +#[macro_export] +macro_rules! localized_format { + ($source:literal) => { + $crate::localization::text($source).to_owned() + }; + ($source:literal, $($name:ident = $value:expr),+ $(,)?) => {{ + $crate::localization::format_named( + $source, + &[$( (stringify!($name), $crate::localization::Arg::new(&$value)) ),+], + ) + }}; + ($source:literal, $($value:expr),+ $(,)?) => {{ + $crate::localization::format_positional( + $source, + &[$($crate::localization::Arg::new(&$value)),+], + ) + }}; +} + +#[cfg(test)] +mod tests { + use super::{Arg, Language, enter, error_text, format_named, format_positional, text}; + + #[test] + fn language_tags_are_stable_and_round_trip() { + for language in Language::ALL { + assert_eq!(Language::parse(language.id()), Some(language)); + let encoded = serde_json::to_value(language).unwrap_or_default(); + let decoded: Language = serde_json::from_value(encoded).unwrap_or_default(); + assert_eq!(decoded, language); + } + assert_eq!(Language::parse(" PT-br "), Some(Language::PortugueseBrazil)); + assert_eq!(Language::parse("fr"), None); + } + + #[test] + fn language_translations_fall_back_to_the_english_source() { + assert_ne!(Language::PortugueseBrazil.text("Appearance"), "Appearance"); + assert_eq!(Language::PortugueseBrazil.text("A source string with no catalog entry"), "A source string with no catalog entry"); + assert_eq!(Language::English.text("Appearance"), "Appearance"); + } + + #[test] + fn language_scope_restores_the_previous_language() { + assert_eq!(text("Appearance"), "Appearance"); + { + let _scope = enter(Language::PortugueseBrazil); + assert_ne!(text("Appearance"), "Appearance"); + { + let _inner = enter(Language::English); + assert_eq!(text("Appearance"), "Appearance"); + } + assert_ne!(text("Appearance"), "Appearance"); + } + assert_eq!(text("Appearance"), "Appearance"); + } + + #[test] + fn portuguese_catalog_covers_every_menu_label() { + for path in include_str!("../../engine/catalog/menus.txt").lines() { + for label in path.split(" > ").map(str::trim).filter(|label| !label.is_empty()) { + assert!(super::pt_br::translate(label).is_some(), "missing pt-BR menu label: {label}"); + } + } + } + + #[test] + fn engine_errors_are_translated_with_their_values() { + assert_eq!(error_text("select a clip"), "select a clip"); + let _scope = enter(Language::PortugueseBrazil); + assert_ne!(error_text("select a clip"), "select a clip"); + assert_ne!(error_text("no track"), "no track"); + let wrapped = error_text("bad parameters for `track.new`: `name` required"); + assert!(wrapped.contains("`track.new`") && wrapped.contains("`name`"), "{wrapped}"); + assert!(!wrapped.contains("bad parameters") && !wrapped.contains("required"), "{wrapped}"); + let ratio = error_text("stretch ratio 12.500 is outside 0.1..10"); + assert!(ratio.contains("12,500"), "{ratio}"); + assert_eq!(error_text("some unknown library failure"), "some unknown library failure"); + } + + #[test] + fn positional_templates_fill_in_order() { + assert_eq!(format_positional("{} of {}", &[Arg::new(&1), Arg::new(&"two")]), "1 of two"); + assert_eq!(format_positional("no fields", &[Arg::new(&1)]), "no fields"); + } + + #[test] + fn named_templates_fill_by_name_in_any_order() { + assert_eq!(format_named("{b}-{a}-{b}", &[("a", Arg::new(&1)), ("b", Arg::new(&2))]), "2-1-2"); + } + + #[test] + fn precision_specifiers_are_honoured() { + let value = 3.14259_f64; + for (template, expected) in [("{:.0}", "3"), ("{:.1}", "3.1"), ("{:.2}", "3.14"), ("{:.3}", "3.143"), ("{}", "3.14259")] { + assert_eq!(format_positional(template, &[Arg::new(&value)]), expected, "{template}"); + } + } + + #[test] + fn braces_can_be_escaped() { + assert_eq!(format_positional("{{{}}}", &[Arg::new(&5)]), "{5}"); + } + + #[test] + fn missing_unknown_and_unclosed_fields_are_kept_verbatim() { + assert_eq!(format_positional("{} {}", &[Arg::new(&1)]), "1 {}"); + assert_eq!(format_named("{nope}", &[("a", Arg::new(&1))]), "{nope}"); + assert_eq!(format_positional("open {", &[]), "open {"); + assert_eq!(format_positional("tail {abc", &[]), "tail {abc"); + } + + #[test] + fn portuguese_numbers_use_a_decimal_comma_only_with_a_precision() { + let _scope = enter(Language::PortugueseBrazil); + assert_eq!(format_positional("{:.1} dB", &[Arg::new(&-6.04_f64)]), "-6,0 dB"); + assert_eq!(format_positional("{}", &[Arg::new(&"v1.2")]), "v1.2"); + let _english = enter(Language::English); + assert_eq!(format_positional("{:.1}", &[Arg::new(&2.5_f64)]), "2.5"); + } + + /// Parses a Rust string literal at the start of `s`; returns its value and the rest. + fn literal(s: &str) -> Option<(String, &str)> { + let mut chars = s.strip_prefix('"')?.char_indices(); + let mut out = String::new(); + while let Some((i, c)) = chars.next() { + match c { + '"' => return Some((out, &s[i + 2..])), + '\\' => match chars.next()?.1 { + 'n' => out.push('\n'), + other => out.push(other), + }, + c => out.push(c), + } + } + None + } + + /// Every `"source" => "translation"` pair of the catalog, read from its source file. + fn catalog_entries() -> Vec<(String, String)> { + let text = include_str!("../locales/pt-BR/mod.rs"); + let mut lines = text.lines().map(str::trim); + let mut entries = Vec::new(); + while let Some(line) = lines.next() { + let Some((key, rest)) = literal(line) else { continue }; + let Some(rest) = rest.trim_start().strip_prefix("=>") else { continue }; + let rest = rest.trim(); + let value = + if rest.starts_with('{') { lines.next().and_then(|next| literal(next).map(|(v, _)| v)) } else { literal(rest).map(|(v, _)| v) }; + if let Some(value) = value { + entries.push((key, value)); + } + } + entries + } + + fn placeholders(template: &str) -> Vec { + let mut found = Vec::new(); + let mut chars = template.chars().peekable(); + while let Some(c) = chars.next() { + if c == '{' && chars.peek() == Some(&'{') { + chars.next(); + } else if c == '{' { + let field: String = chars.by_ref().take_while(|c| *c != '}').collect(); + found.push(field); + } + } + found.sort(); + found + } + + #[test] + fn catalog_entries_are_parsed_and_unique() { + let entries = catalog_entries(); + assert!(entries.len() > 1000, "parsed only {} catalog entries", entries.len()); + let mut keys: Vec<&str> = entries.iter().map(|(key, _)| key.as_str()).collect(); + keys.sort_unstable(); + let before = keys.len(); + keys.dedup(); + assert_eq!(before, keys.len(), "duplicate catalog keys"); + } + + #[test] + fn catalog_translations_keep_the_english_placeholders() { + for (source, translation) in catalog_entries() { + assert_eq!(placeholders(&source), placeholders(&translation), "placeholders differ for {source:?}"); + assert_eq!(super::pt_br::translate(&source), Some(translation.as_str()), "lookup differs for {source:?}"); + } + } + + #[test] + fn every_localized_source_string_has_a_catalog_entry() { + fn visit(dir: &std::path::Path, missing: &mut Vec) { + let Ok(read) = std::fs::read_dir(dir) else { return }; + for entry in read.flatten() { + let path = entry.path(); + if path.is_dir() { + visit(&path, missing); + } else if path.extension().is_some_and(|e| e == "rs") && !path.ends_with("localization.rs") { + let Ok(text) = std::fs::read_to_string(&path) else { continue }; + for marker in ["localization::text(\"", "localized_format!(\""] { + for (at, _) in text.match_indices(marker) { + let start = at + marker.len() - 1; + if let Some((source, _)) = literal(&text[start..]) + && super::pt_br::translate(&source).is_none() + { + missing.push(format!("{}: {source:?}", path.display())); + } + } + } + } + } + } + let mut missing = Vec::new(); + visit(&std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src"), &mut missing); + assert!(missing.is_empty(), "strings without a pt-BR entry:\n{}", missing.join("\n")); + } +} diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index 9da4e331..d9105645 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -77,6 +77,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, Option<&str>)] = &[ ("ui.new_tracks_dialog", "New Tracks…", "", None), ("ui.bounce_dialog", "Bounce Mix…", "", None), ("ui.set", "Set UI State", "", None), + ("ui.language", "Language", "", None), ("ui.theme", "Appearance", "", None), ("ui.reduce_visual_effects", "Reduce Visual Effects", "", None), ("ui.undo_levels", "Levels of Undo", "", None), @@ -272,32 +273,32 @@ pub fn menu_bar(app: &mut SoundApp, ui: &mut egui::Ui) { ui, |ui| { egui::MenuBar::new().ui(ui, |ui| { - ui.menu_button("SoundCraft", |ui| { + ui.menu_button(crate::localization::text("SoundCraft"), |ui| { ui.add_enabled_ui(menu_entries_enabled, |ui| { - if ui.button("About SoundCraft").clicked() { + if ui.button(crate::localization::text("About SoundCraft")).clicked() { app.ui.show_about = true; } - if ui.add_enabled(preferences_enabled, egui::Button::new("Preferences...")).clicked() { + if ui.add_enabled(preferences_enabled, egui::Button::new(crate::localization::text("Preferences..."))).clicked() { let _ = app.run("setup.preferences", json!({"value": true})); } - if ui.button("Check for Updates…").clicked() { + if ui.button(crate::localization::text("Check for Updates…")).clicked() { let _ = app.run("app.checkForUpdates", json!({})); } - if ui.button("Session Info").clicked() { + if ui.button(crate::localization::text("Session Info")).clicked() { app.ui.show_session_info = true; } - if ui.button("Session Audio Health").clicked() { + if ui.button(crate::localization::text("Session Audio Health")).clicked() { let _ = app.run("window.audio_health", json!({"value": true})); } ui.separator(); - if ui.button("Quit").clicked() { + if ui.button(crate::localization::text("Quit")).clicked() { let _ = crate::dialogs::run_or_ask(app, "app.quit", json!({})); } }); }); let extra = ui_aliases(); for root in tree() { - ui.menu_button(&root.label, |ui| { + ui.menu_button(crate::localization::text(&root.label), |ui| { scrolling(ui, |ui| { ui.add_enabled_ui(menu_entries_enabled, |ui| { for c in &root.children { @@ -311,14 +312,16 @@ pub fn menu_bar(app: &mut SoundApp, ui: &mut egui::Ui) { } if root.path == "AudioSuite" { ui.separator(); - ui.label(egui::RichText::new("Processes selected clips offline").small().color(t.text_dim)); + ui.label( + egui::RichText::new(crate::localization::text("Processes selected clips offline")).small().color(t.text_dim), + ); } if root.path == "Window" { ui.separator(); let mut separate = app.ui.mix_separate; if ui - .checkbox(&mut separate, "Mix in Separate Window") - .on_hover_text("Show Edit and Mix at once, e.g. one per monitor") + .checkbox(&mut separate, crate::localization::text("Mix in Separate Window")) + .on_hover_text(crate::localization::text("Show Edit and Mix at once, e.g. one per monitor")) .changed() { let _ = run_ui_command(app, "window.mix_separate", &json!({"value": separate})); @@ -333,7 +336,11 @@ pub fn menu_bar(app: &mut SoundApp, ui: &mut egui::Ui) { "{}{} — {}", app.engine.session().name, if app.engine.is_dirty() { " *" } else { "" }, - if app.ui.window == MainWindow::Edit || app.ui.mix_separate { "Edit" } else { "Mix" } + if app.ui.window == MainWindow::Edit || app.ui.mix_separate { + crate::localization::text("Edit") + } else { + crate::localization::text("Mix") + } ); ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { ui.label(egui::RichText::new(title).color(t.text_dim)); @@ -353,10 +360,11 @@ fn scrolling(ui: &mut egui::Ui, add: impl FnOnce(&mut egui::Ui) -> R) -> R { fn instrument_menu(app: &mut SoundApp, ui: &mut egui::Ui) { match instrument_track(app.engine.session()) { Some(id) => { - ui.menu_button("Instrument", |ui| crate::mix_window::instrument_menu(app, ui, id)); + ui.menu_button(crate::localization::text("Instrument"), |ui| crate::mix_window::instrument_menu(app, ui, id)); } None => { - ui.add_enabled(false, egui::Button::new("Instrument")).on_disabled_hover_text("Select an instrument track"); + ui.add_enabled(false, egui::Button::new(crate::localization::text("Instrument"))) + .on_disabled_hover_text(crate::localization::text("Select an instrument track")); } } } @@ -368,7 +376,7 @@ fn instrument_track(s: &soundcraft_model::Session) -> Option Option<&'static str> { pub fn live_label(app: &SoundApp, id: Option<&str>) -> Option { let e = &app.engine; match id? { - "edit.undo" => Some(e.undo_label().map_or_else(|| "Can't Undo".into(), |l| format!("Undo {l}"))), - "edit.redo" => Some(e.redo_label().map_or_else(|| "Can't Redo".into(), |l| format!("Redo {l}"))), + "edit.undo" => Some(e.undo_label().map_or_else( + || crate::localization::text("Can't Undo").into(), + |l| crate::localized_format!("Undo {l}", l = crate::localization::text(l)), + )), + "edit.redo" => Some(e.redo_label().map_or_else( + || crate::localization::text("Can't Redo").into(), + |l| crate::localized_format!("Redo {l}", l = crate::localization::text(l)), + )), _ => None, } } @@ -607,6 +622,16 @@ pub fn run_ui_command(app: &mut SoundApp, id: &str, p: &Value) -> Option { + let Some(tag) = p.get("language").and_then(Value::as_str) else { + return Some(Ok(json!({"language": app.ui.language.id()}))); + }; + let Some(language) = crate::localization::Language::parse(tag) else { + return Some(Err(format!("unknown language `{tag}` (en or pt-BR)"))); + }; + app.ui.language = language; + json!({"language": language.id()}) + } "app.checkForUpdates" | "help.checkForUpdates" => { crate::updates_ui::check(app); json!({}) @@ -713,7 +738,7 @@ pub fn run_ui_command(app: &mut SoundApp, id: &str, p: &Value) -> Option { if let Err(error) = crate::docking::arrange(app) { - app.ui.status = format!("Panel windows could not be arranged: {error}"); + app.ui.status = crate::localized_format!("Panel windows could not be arranged: {error}", error = error); } app.arrange_request = true; json!({}) diff --git a/crates/ui-egui/src/mix_window.rs b/crates/ui-egui/src/mix_window.rs index 08cb77d7..d1767649 100644 --- a/crates/ui-egui/src/mix_window.rs +++ b/crates/ui-egui/src/mix_window.rs @@ -38,7 +38,7 @@ pub fn show(app: &mut SoundApp, ui: &mut Ui) { /// be seen at once, e.g. one per monitor. Closing that window brings Mix back into the main one. /// Backends without multiple windows show it as a floating egui window instead. pub fn show_separate(app: &mut SoundApp, ctx: &egui::Context) { - let title = format!("{} — Mix", app.engine.session().name); + let title = format!("{} — {}", app.engine.session().name, crate::localization::text("Mix")); let builder = egui::ViewportBuilder::default().with_title(title).with_inner_size([1100.0, 720.0]).with_min_inner_size([480.0, 320.0]); ctx.show_viewport_immediate(egui::ViewportId::from_hash_of("soundcraft.mix"), builder, |ui, _class| { ui.set_style(ui.ctx().global_style()); @@ -149,10 +149,13 @@ fn short_label(text: &str) -> &str { fn section_label(ui: &Ui, r: Rect, text: &str, narrow: bool) { let p = ui.painter(); let color = Tokens::current().section_label; - let text = if narrow { short_label(text) } else { text }; - let mut galley = p.layout_no_wrap(text.to_owned(), bold(10.0), color); + let source = text; + let short = crate::localization::text(short_label(source)); + let text = crate::localization::text(source); + let label = if narrow { short } else { text }; + let mut galley = p.layout_no_wrap(label.to_owned(), bold(10.0), color); if galley.size().x > r.width() - 8.0 { - galley = p.layout_no_wrap(short_label(text).to_owned(), bold(10.0), color); + galley = p.layout_no_wrap(short.to_owned(), bold(10.0), color); } p.galley(Align2::CENTER_CENTER.anchor_size(pos2(r.center().x, r.min.y + 7.0), galley.size()).min, galley, color); } @@ -239,7 +242,7 @@ fn preamp_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32 let mut c = ui.new_child(egui::UiBuilder::new().max_rect(kr)); let resp = c .add_sized(kr.size(), egui::DragValue::new(&mut db).range(-24.0..=24.0).speed(0.1).suffix(" dB").max_decimals(1)) - .accessible_name("Input trim (dB)"); + .accessible_name(crate::localization::text("Input trim (dB)")); if resp.changed() { let _ = app.engine.execute_merged("mix.trim", &json!({"tracks": [id.0], "db": db}), &format!("trim:{}", id.0)); } @@ -266,7 +269,7 @@ fn instrument_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: _ if track.kind == TrackKind::Instrument => instrument_slot(app, ui, track, sr), Some(k) => insert_slot(app, ui, track, k, sr), None if track.kind == TrackKind::Midi => { - ui.painter().text(sr.center(), Align2::CENTER_CENTER, "MIDI in: all", regular(9.0), t.text_dim); + ui.painter().text(sr.center(), Align2::CENTER_CENTER, crate::localization::text("MIDI in: all"), regular(9.0), t.text_dim); } None => {} } @@ -284,8 +287,11 @@ fn object_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32 if has_input { let on = app.engine.session().edit.flag(&format!("object.{}", id.0)); let mut c = ui.new_child(egui::UiBuilder::new().max_rect(sec)); - let label = egui::RichText::new(if on { "OBJECT" } else { "BED" }).font(bold(9.0)); - if c.add_sized(sec.size(), egui::Button::new(label).selected(on)).on_hover_text("Route as an immersive object or to the bed").clicked() { + let label = egui::RichText::new(crate::localization::text(if on { "OBJECT" } else { "BED" })).font(bold(9.0)); + if c.add_sized(sec.size(), egui::Button::new(label).selected(on)) + .on_hover_text(crate::localization::text("Route as an immersive object or to the bed")) + .clicked() + { let _ = app.run("track.object", json!({"tracks": [id.0], "object": !on})); } } @@ -366,10 +372,10 @@ fn comments_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f let sec = Rect::from_min_size(pos2(x0, y), vec2(inner_w, 44.0)); let mut c = track.comments.clone(); let mut child = ui.new_child(egui::UiBuilder::new().max_rect(sec)); - let hint = if narrow { "" } else { "comments" }; + let hint = if narrow { "" } else { crate::localization::text("comments") }; let field = crate::widgets::named_text_field( child.add(egui::TextEdit::multiline(&mut c).desired_width(inner_w).desired_rows(2).hint_text(hint).font(regular(10.0))), - &format!("Comments for {}", track.name), + &crate::localized_format!("Comments for {}", track.name), ); if field.changed() { let _ = app.engine.execute_merged("track.comments", &json!({"track": id.0, "comments": c}), &format!("comments:{}", id.0)); @@ -405,7 +411,11 @@ fn io_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32) -> in_r.height(), &input, t.text, - SelectorLabels { name: &format!("Input for {}", track.name), value: &input, tooltip: "Input" }, + SelectorLabels { + name: &crate::localized_format!("Input for {}", track.name), + value: &input, + tooltip: crate::localization::text("Input"), + }, ); route_popup(app, &resp, id, true); } @@ -417,7 +427,11 @@ fn io_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32) -> out_r.height(), &output, t.text, - SelectorLabels { name: &format!("Output for {}", track.name), value: &output, tooltip: "Output" }, + SelectorLabels { + name: &crate::localized_format!("Output for {}", track.name), + value: &output, + tooltip: crate::localization::text("Output"), + }, ); route_popup(app, &resp, id, false); // Automation mode. @@ -432,11 +446,11 @@ fn io_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32) -> } else { t.auto_write }; - let full_label = format!("auto {}", mode.label()); + let full_label = crate::localized_format!("auto {}", crate::localization::text(mode.label())); let label = if mode == soundcraft_model::AutomationMode::TouchLatch { - if narrow { "t/l" } else { mode.label() } + if narrow { "t/l" } else { crate::localization::text(mode.label()) } } else if narrow { - mode.label() + crate::localization::text(mode.label()) } else { &full_label }; @@ -446,11 +460,11 @@ fn io_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32) -> am_r.height(), label, col, - SelectorLabels { name: &format!("Automation mode for {}", track.name), value: &full_label, tooltip: &full_label }, + SelectorLabels { name: &crate::localized_format!("Automation mode for {}", track.name), value: &full_label, tooltip: &full_label }, ); egui::Popup::menu(&resp).show(|ui| { for m in soundcraft_model::AutomationMode::ALL { - if ui.selectable_label(m == mode, m.label()).clicked() { + if ui.selectable_label(m == mode, crate::localization::text(m.label())).clicked() { let _ = app.run("mix.automation_mode", json!({"track": id.0, "mode": m.label()})); } } @@ -466,7 +480,13 @@ fn group_selector(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32 let t = Tokens::current(); // Group selector. let no_group = if narrow { "nogrp" } else { "no group" }; - let gname = app.engine.session().groups.iter().find(|g| g.members.contains(&id)).map_or(no_group.to_string(), |g| g.name.clone()); + let gname = app + .engine + .session() + .groups + .iter() + .find(|g| g.members.contains(&id)) + .map_or(crate::localization::text(no_group).to_string(), |g| g.name.clone()); let gr = Rect::from_min_size(pos2(x0 + 2.0, y), vec2(inner_w - 4.0, 16.0)); let mut c = ui.new_child(egui::UiBuilder::new().max_rect(gr)); let _ = selector_box_named( @@ -475,7 +495,7 @@ fn group_selector(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32 gr.height(), &gname, t.text_dim, - SelectorLabels { name: &format!("Group for {}", track.name), value: &gname, tooltip: "Group" }, + SelectorLabels { name: &crate::localized_format!("Group for {}", track.name), value: &gname, tooltip: crate::localization::text("Group") }, ); y += 22.0; y @@ -528,7 +548,7 @@ fn pan_section(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32) - pr, ui.scope_id().with(("pan-value", id.0, i)), Readout { - name: &format!("{} pan {}", track.name, i + 1), + name: &crate::localized_format!("{} pan {}", track.name, i + 1), display: &pan_text(v), edit_initial: &format!("{:.0}", v * 100.0), parse: parse_pan, @@ -555,11 +575,11 @@ fn toggle_rows(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32) - ); row.spacing_mut().item_spacing.x = 6.0; if track.kind.has_playlist() { - let input_label = format!("Input monitoring for {}", track.name); + let input_label = crate::localized_format!("Input monitoring for {}", track.name); if text_toggle(&mut row, vec2(bw, 18.0), "I", track.mixer.input_monitor, t.input, &input_label).clicked() { let _ = app.run("mix.input_monitor", json!({"track": id.0})); } - let record_label = format!("Record enable for {}", track.name); + let record_label = crate::localized_format!("Record enable for {}", track.name); if rec_toggle(&mut row, vec2(bw, 18.0), track.mixer.record_arm, &record_label).clicked() { let _ = app.run("mix.record_arm", json!({"track": id.0})); } @@ -570,11 +590,11 @@ fn toggle_rows(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>, mut y: f32) - ); row.spacing_mut().item_spacing.x = 6.0; if track.kind != TrackKind::Master { - let solo_label = format!("Solo for {}", track.name); + let solo_label = crate::localized_format!("Solo for {}", track.name); if text_toggle(&mut row, vec2(bw, 18.0), "S", track.mixer.solo, t.solo, &solo_label).clicked() { let _ = app.run("mix.solo", json!({"track": id.0})); } - let mute_label = format!("Mute for {}", track.name); + let mute_label = crate::localized_format!("Mute for {}", track.name); if text_toggle(&mut row, vec2(bw, 18.0), "M", track.mixer.mute, t.mute, &mute_label).clicked() { let _ = app.run("mix.mute", json!({"track": id.0})); } @@ -634,7 +654,7 @@ fn name_and_readout(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>) { vr, ui.scope_id().with(("volume-value", id.0)), Readout { - name: &format!("{} volume", track.name), + name: &crate::localized_format!("{} volume", track.name), display: &db_text(track.mixer.volume_db), edit_initial: &format!("{:.1}", track.mixer.volume_db), parse: parse_db, @@ -654,7 +674,7 @@ fn name_and_readout(app: &mut SoundApp, ui: &mut Ui, cx: &StripCtx<'_>) { TrackKind::Folder => "folder", TrackKind::Video => "video", }; - ui.painter().text(pos2(vr.center().x, vr.max.y + 9.0), Align2::CENTER_CENTER, kind, regular(9.5), t.text_dim); + ui.painter().text(pos2(vr.center().x, vr.max.y + 9.0), Align2::CENTER_CENTER, crate::localization::text(kind), regular(9.5), t.text_dim); let nr = Rect::from_min_size(pos2(x0, r.max.y - 26.0), vec2(inner_w, 18.0)); ui.painter().rect( nr, diff --git a/crates/ui-egui/src/mix_window/plugin_menu.rs b/crates/ui-egui/src/mix_window/plugin_menu.rs index ea077887..a37d9f4c 100644 --- a/crates/ui-egui/src/mix_window/plugin_menu.rs +++ b/crates/ui-egui/src/mix_window/plugin_menu.rs @@ -3,7 +3,7 @@ use super::{Color32, Rect, SoundApp, TrackId, Ui, json, pos2, vec2}; /// An insert's menu: a search field that takes typing at once, then (until something is typed) /// Bypass and removal and the plugins by category and format. pub fn plugin_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, slot: usize, occupied: bool) { - let search = MenuSearch::show(ui, egui::Id::unique(("plugin-search", id.0, slot)), "Search plugins…"); + let search = MenuSearch::show(ui, egui::Id::unique(("plugin-search", id.0, slot)), crate::localization::text("Search plugins…")); if search.typing() { if let Some(plugin) = plugin_search(ui, &search, false) { pick_insert(app, ui, id, slot, &plugin); @@ -11,10 +11,10 @@ pub fn plugin_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, slot: usize, oc return; } if occupied { - if ui.button("Bypass").clicked() { + if ui.button(crate::localization::text("Bypass")).clicked() { run_pick(app, ui, "mix.insert_bypass", json!({"track": id.0, "slot": slot})); } - if ui.button("no insert").clicked() { + if ui.button(crate::localization::text("no insert")).clicked() { run_pick(app, ui, "mix.insert_remove", json!({"track": id.0, "slot": slot})); } ui.separator(); @@ -44,7 +44,7 @@ pub fn plugin_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, slot: usize, oc /// instruments. pub fn instrument_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId) { let slot = soundcraft_mix::INSTRUMENT_SLOT; - let search = MenuSearch::show(ui, egui::Id::unique(("instrument-search", id.0)), "Search instruments…"); + let search = MenuSearch::show(ui, egui::Id::unique(("instrument-search", id.0)), crate::localization::text("Search instruments…")); if search.typing() { if let Some(plugin) = plugin_search(ui, &search, true) { run_pick(app, ui, "mix.instrument", json!({"track": id.0, "plugin": plugin})); @@ -54,7 +54,9 @@ pub fn instrument_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId) { let current = app.engine.session().track(id).and_then(|t| t.instrument.clone()); if let Some(info) = current.as_ref().and_then(|i| plugin_info(&i.plugin)) { ui.label(egui::RichText::new(info.name).strong()); - if current.as_ref().is_some_and(|i| !soundcraft_mix::is_third_party(&i.plugin)) && ui.button("Edit Parameters…").clicked() { + if current.as_ref().is_some_and(|i| !soundcraft_mix::is_third_party(&i.plugin)) + && ui.button(crate::localization::text("Edit Parameters…")).clicked() + { if !app.ui.plugin_windows.contains(&(id, slot)) { app.ui.plugin_windows.push((id, slot)); } @@ -64,13 +66,13 @@ pub fn instrument_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId) { && p.has_editor(id, slot) { if p.editor_open(id, slot) { - if ui.button("Close Plugin Editor").clicked() { + if ui.button(crate::localization::text("Close Plugin Editor")).clicked() { p.close_editor(id, slot); ui.close(); } - } else if ui.button("Open Plugin Editor").clicked() { + } else if ui.button(crate::localization::text("Open Plugin Editor")).clicked() { if let Err(e) = p.open_editor(id, slot) { - app.ui.status = format!("{}: {e}", info.name); + app.ui.status = format!("{}: {}", info.name, crate::localization::error_text(&e.to_string())); } ui.close(); } @@ -78,7 +80,7 @@ pub fn instrument_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId) { ui.separator(); } let mut picked = None; - ui.menu_button("Built-in", |ui| { + ui.menu_button(crate::localization::text("Built-in"), |ui| { for p in soundcraft_dsp::plugins().iter().filter(|p| p.is_instrument) { if ui.button(p.name).clicked() { picked = Some(p.id.to_string()); @@ -141,15 +143,15 @@ fn plugin_search(ui: &mut Ui, search: &MenuSearch, instruments: bool) -> Option< } }); if n == 0 { - ui.weak("No matches"); + ui.weak(crate::localization::text("No matches")); } if clap.is_none() || vst3.is_none() { ui.separator(); ui.horizontal(|ui| { - if clap.is_none() && ui.small_button("Scan CLAP").clicked() { + if clap.is_none() && ui.small_button(crate::localization::text("Scan CLAP")).clicked() { soundcraft_clap_host::scan(); } - if vst3.is_none() && ui.small_button("Scan VST3").clicked() { + if vst3.is_none() && ui.small_button(crate::localization::text("Scan VST3")).clicked() { soundcraft_vst3_host::scan(); } }); @@ -256,20 +258,20 @@ struct MenuPlugin { /// id picked. Each format is scanned the first time its submenu opens, then cached by its host. fn hosted_menus(ui: &mut Ui, instruments: bool) -> Option { let mut picked = None; - ui.menu_button("CLAP", |ui| { + ui.menu_button(crate::localization::text("CLAP"), |ui| { let list = soundcraft_clap_host::scan().into_iter().filter(|d| d.is_instrument == instruments); if let Some(p) = vendor_menus(ui, list.map(|d| MenuPlugin { id: d.id, name: d.name, vendor: d.vendor }).collect(), "No CLAP plugins found") { picked = Some(p); } }); - ui.menu_button("VST3", |ui| { + ui.menu_button(crate::localization::text("VST3"), |ui| { let list = soundcraft_vst3_host::scan().into_iter().filter(|d| d.is_instrument == instruments); if let Some(p) = vendor_menus(ui, list.map(|d| MenuPlugin { id: d.id, name: d.name, vendor: d.vendor }).collect(), "No VST3 plugins found") { picked = Some(p); } }); if cfg!(target_os = "macos") { - ui.menu_button("Audio Units", |ui| { + ui.menu_button(crate::localization::text("Audio Units"), |ui| { let list = soundcraft_au_host::scan().into_iter().filter(|d| d.is_instrument == instruments); if let Some(p) = vendor_menus(ui, list.map(|d| MenuPlugin { id: d.id, name: d.name, vendor: d.vendor }).collect(), "No Audio Units found") { @@ -284,7 +286,7 @@ fn hosted_menus(ui: &mut Ui, instruments: bool) -> Option { /// within the screen so that every plugin stays reachable however many are installed. fn vendor_menus(ui: &mut Ui, mut list: Vec, none: &str) -> Option { if list.is_empty() { - ui.label(none); + ui.label(crate::localization::text(none)); return None; } list.sort_by_cached_key(|p| (p.vendor.to_lowercase(), p.name.to_lowercase())); @@ -294,7 +296,7 @@ fn vendor_menus(ui: &mut Ui, mut list: Vec, none: &str) -> Option String { match r { - Route::None => "no output".into(), - Route::Main => app.engine.session().outputs.first().map_or_else(|| "Out 1-2".into(), |o| o.name.clone()), + Route::None => crate::localization::text("no output").to_string(), + Route::Main => app.engine.session().outputs.first().map_or_else(|| crate::localization::text("Out 1-2").to_string(), |o| o.name.clone()), Route::Bus(b) => app.engine.session().bus(*b).map_or_else(|| "bus?".into(), |b| b.name.clone()), Route::Hardware(h) => h.clone(), } @@ -13,7 +13,7 @@ pub(crate) fn route_name(app: &SoundApp, r: &Route) -> String { pub(crate) fn input_name(app: &SoundApp, track: &Track) -> String { if track.kind.has_playlist() && track.mixer.input == Route::None { let channels = track.format.channels(); - if channels == 1 { "In 1".to_string() } else { format!("In 1-{channels}") } + if channels == 1 { crate::localized_format!("In {}", 1) } else { crate::localized_format!("In 1-{}", channels) } } else { route_name(app, &track.mixer.input) } @@ -30,14 +30,14 @@ pub(crate) fn route_popup(app: &mut SoundApp, resp: &egui::Response, id: TrackId fn route_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, input: bool) { let key = if input { "input" } else { "output" }; let cmd = if input { "track.input" } else { "track.output" }; - let hint = if input { "Search inputs…" } else { "Search outputs…" }; + let hint = crate::localization::text(if input { "Search inputs…" } else { "Search outputs…" }); let search = MenuSearch::show(ui, egui::Id::unique(("route-search", id.0, input)), hint); let busses: Vec = app.engine.session().busses.iter().map(|b| b.name.clone()).collect(); let main_name = app.engine.session().outputs.first().map_or_else(|| "Out 1-2".to_string(), |o| o.name.clone()); // (label, the route the command is given) - let mut fixed = vec![(if input { "no input" } else { "no output" }.to_string(), "none".to_string())]; + let mut fixed = vec![(crate::localization::text(if input { "no input" } else { "no output" }).to_string(), "none".to_string())]; if input { - fixed.extend((1..=8).map(|i| (format!("In {i}"), format!("In {i}")))); + fixed.extend((1..=8).map(|i| (crate::localized_format!("In {}", i), format!("In {i}")))); } else { fixed.push((main_name, "main".to_string())); } @@ -58,7 +58,7 @@ fn route_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, input: bool) { } } ui.separator(); - ui.strong("Bus"); + ui.strong(crate::localization::text("Bus")); if let Some(bus) = search .rows(ui, busses.len(), 420.0, |ui, i, highlighted| busses.get(i).is_some_and(|b| menu_row(ui, highlighted, b))) .and_then(|i| busses.get(i)) @@ -66,7 +66,7 @@ fn route_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, input: bool) { let _ = app.run(cmd, json!({"track": id.0, key: bus})); ui.close(); } - if ui.button("new bus...").clicked() { + if ui.button(crate::localization::text("new bus...")).clicked() { let mut n = busses.len() + 1; while busses.contains(&format!("Bus {n}")) || app.engine.session().track_by_name(&format!("Bus {n}")).is_some() { n += 1; diff --git a/crates/ui-egui/src/mix_window/sends.rs b/crates/ui-egui/src/mix_window/sends.rs index f235a6ad..8383b4ab 100644 --- a/crates/ui-egui/src/mix_window/sends.rs +++ b/crates/ui-egui/src/mix_window/sends.rs @@ -18,8 +18,9 @@ pub(crate) fn send_slot(app: &mut SoundApp, ui: &mut Ui, track: &Track, slot: us let level_r = if compact { r } else { level_icon(r).expand2(vec2(3.0, 0.0)).with_min_y(r.min.y).with_max_y(r.max.y) }; let route_r = Rect::from_min_max(r.min, pos2((level_r.min.x - 1.0).max(r.min.x), r.max.y)); let route_resp = ui.interact(if snd.is_some() { route_r } else { r }, ui.scope_id().with(("snd-route", id.0, slot)), Sense::click()); - route_resp - .widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, format!("Send {} for {}", (b'A' + slot as u8) as char, track.name))); + route_resp.widget_info(|| { + egui::WidgetInfo::labeled(egui::Role::Button, true, crate::localized_format!("Send {} for {}", (b'A' + slot as u8) as char, track.name)) + }); let mark = if compact { Mark::Arrow } else { Mark::Letter((b'a' + slot as u8) as char) }; match &snd { Some(s) => { @@ -30,7 +31,13 @@ pub(crate) fn send_slot(app: &mut SoundApp, ui: &mut Ui, track: &Track, slot: us let which = (b'A' + slot as u8) as char; let shown = app.ui.send_window == Some((id, slot)); let level_resp = ui.interact(level_r, ui.scope_id().with(("send-value", id.0, slot)), Sense::click_and_drag()); - level_resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, format!("Send {which} level for {}", track.name))); + level_resp.widget_info(|| { + egui::WidgetInfo::labeled( + egui::Role::Button, + true, + crate::localized_format!("Send {which} level for {track}", which = which, track = track.name), + ) + }); if shown { ui.painter().rect_stroke(level_r.shrink(0.5), 1.0, Stroke::new(1.5, t.accent), StrokeKind::Inside); } @@ -50,9 +57,11 @@ pub(crate) fn send_slot(app: &mut SoundApp, ui: &mut Ui, track: &Track, slot: us let _ = app.engine.execute_merged("mix.send_level", &json!({"track": id.0, "slot": slot, "db": db}), &format!("send:{}:{slot}", id.0)); } - let _ = level_resp.clone().on_hover_text(format!( - "Send {which} to {name}: {} dB\nClick for the send fader · drag vertically to adjust · Shift-drag for fine control · Alt-click for 0 dB · right-click for options", - db_text(s.level_db) + let _ = level_resp.clone().on_hover_text(crate::localized_format!( + "Send {which} to {name}: {db} dB\nClick for the send fader · drag vertically to adjust · Shift-drag for fine control · Alt-click for 0 dB · right-click for options", + which = which, + name = name, + db = db_text(s.level_db) )); level_resp.context_menu(|ui| send_options_menu(app, ui, id, slot, s)); } @@ -86,7 +95,7 @@ fn send_window_contents(app: &mut SoundApp, ctx: &egui::Context) { }; let t = Tokens::current(); let mut open = true; - egui::Window::new(format!("{name} · Send {}", (b'A' + slot as u8) as char)) + egui::Window::new(crate::localized_format!("{name} · Send {letter}", name = name, letter = (b'A' + slot as u8) as char)) .id(egui::Id::unique("send_window")) .open(&mut open) .auto_sized() @@ -117,7 +126,7 @@ fn send_window_contents(app: &mut SoundApp, ctx: &egui::Context) { } ui.label(egui::RichText::new(pan_text(send.pan)).color(t.counter_text).small()); let (fr, fresp) = ui.allocate_exact_size(vec2(56.0, 220.0), Sense::hover()); - fresp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Slider, true, "Send level")); + fresp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Slider, true, crate::localization::text("Send level"))); // Distinct from the strip's "Send A level for " icon and from the slot's "Send level", so a // label query while the window is open still picks one node. if let Some(db) = fader(ui, fr, send.level_db, ui.scope_id().with("send_fader"), "Send level fader") { @@ -136,7 +145,7 @@ fn send_window_contents(app: &mut SoundApp, ctx: &egui::Context) { rr, ui.scope_id().with("send_level_value"), Readout { - name: &format!("{name} send level"), + name: &crate::localized_format!("{name} send level", name = name), display: &shown, edit_initial: &format!("{:.1}", send.level_db), parse: parse_db, @@ -156,9 +165,9 @@ fn send_window_contents(app: &mut SoundApp, ctx: &egui::Context) { /// Secondary controls live behind the amount readout, separate from the bus selector like Logic. fn send_options_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, slot: usize, send: &soundcraft_model::SendSlot) { ui.set_min_width(230.0); - ui.strong(format!("Send {} · {}", (b'A' + slot as u8) as char, route_name(app, &send.target))); + ui.strong(crate::localized_format!("Send {} · {}", (b'A' + slot as u8) as char, route_name(app, &send.target))); let mut db = send.level_db.max(-60.0); - if ui.add(egui::Slider::new(&mut db, -60.0..=12.0).text("Level").suffix(" dB")).changed() { + if ui.add(egui::Slider::new(&mut db, -60.0..=12.0).text(crate::localization::text("Level")).suffix(" dB")).changed() { let _ = app.engine.execute_merged("mix.send_level", &json!({"track": id.0, "slot": slot, "db": db}), &format!("send:{}:{slot}", id.0)); } send_level_scale(ui, send.level_db); @@ -169,31 +178,31 @@ fn send_options_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, slot: usize, let _ = app.run("mix.send_level", json!({"track": id.0, "slot": slot, "db": db})); } } - if ui.small_button("0 dB").clicked() { + if ui.small_button(crate::localization::text("0 dB")).clicked() { let _ = app.run("mix.send_level", json!({"track": id.0, "slot": slot, "db": 0.0})); } - if ui.small_button("−∞").clicked() { + if ui.small_button(crate::localization::text("−∞")).clicked() { let _ = app.run("mix.send_level", json!({"track": id.0, "slot": slot, "db": -144.0})); } }); let mut pan = send.pan; - if ui.add(egui::Slider::new(&mut pan, -1.0..=1.0).text("Pan")).changed() { + if ui.add(egui::Slider::new(&mut pan, -1.0..=1.0).text(crate::localization::text("Pan"))).changed() { let _ = app.engine.execute_merged("mix.send_level", &json!({"track": id.0, "slot": slot, "pan": pan}), &format!("send-pan:{}:{slot}", id.0)); } ui.horizontal(|ui| { let mut mute = send.mute; - if crate::widgets::checkbox(ui, &mut mute, "Mute").changed() { + if crate::widgets::checkbox(ui, &mut mute, crate::localization::text("Mute")).changed() { let _ = app.run("mix.send_level", json!({"track": id.0, "slot": slot, "mute": mute})); } let mut pre = send.pre_fader; - if crate::widgets::checkbox(ui, &mut pre, "Pre-fader").changed() { + if crate::widgets::checkbox(ui, &mut pre, crate::localization::text("Pre-fader")).changed() { let _ = app.run("mix.send_level", json!({"track": id.0, "slot": slot, "pre_fader": pre})); } }); if let Route::Bus(bus) = send.target && let Some(aux) = app.engine.session().tracks.iter().find(|t| t.kind == TrackKind::Aux && t.mixer.input == Route::Bus(bus)).map(|t| (t.id, t.name.clone())) - && ui.button("Rename bus…").clicked() + && ui.button(crate::localization::text("Rename bus…")).clicked() { app.dialogs.open_rename_track(aux.0, &aux.1); ui.close(); @@ -342,18 +351,18 @@ fn send_route_menu(app: &mut SoundApp, ui: &Ui, field: &egui::Response, id: Trac match ¤t { Some((_, name)) => { ui.horizontal(|ui| { - ui.strong(format!("Send {which}")); + ui.strong(crate::localized_format!("Send {which}", which = which)); ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { ui.label(egui::RichText::new(name).color(Tokens::current().counter_text)); }); }); - ui.label(egui::RichText::new("DESTINATION").size(8.0).color(Tokens::current().text_dim)); + ui.label(egui::RichText::new(crate::localization::text("DESTINATION")).size(8.0).color(Tokens::current().text_dim)); } None => { - ui.strong(format!("Send {which} · Choose destination")); + ui.strong(crate::localized_format!("Send {which} · Choose destination", which = which)); } } - let search = MenuSearch::show(ui, egui::Id::unique(("send-bus-search", id.0, slot)), "Search buses…"); + let search = MenuSearch::show(ui, egui::Id::unique(("send-bus-search", id.0, slot)), crate::localization::text("Search buses…")); let busses = &app.engine.session().busses; let visible: Vec<_> = busses.iter().filter(|bus| search.matches(&bus.name)).collect(); (search, visible) @@ -376,11 +385,11 @@ fn send_route_menu(app: &mut SoundApp, ui: &Ui, field: &egui::Response, id: Trac }) }, |ui| { - if ui.button("new bus...").clicked() { + if ui.button(crate::localization::text("new bus...")).clicked() { ui.close(); return Some(SendFooter::NewBus); } - if has_send && ui.button("Remove send").clicked() { + if has_send && ui.button(crate::localization::text("Remove send")).clicked() { ui.close(); return Some(SendFooter::RemoveSend); } diff --git a/crates/ui-egui/src/mix_window/slots.rs b/crates/ui-egui/src/mix_window/slots.rs index 866b60eb..b1f73f76 100644 --- a/crates/ui-egui/src/mix_window/slots.rs +++ b/crates/ui-egui/src/mix_window/slots.rs @@ -10,7 +10,7 @@ pub(crate) fn instrument_slot(app: &mut SoundApp, ui: &mut Ui, track: &Track, r: let ins = track.instrument.as_ref(); let info = ins.and_then(|i| plugin_info(&i.plugin)); let resp = ui.interact(r, ui.scope_id().with(("instrument", id.0)), Sense::click()); - resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, format!("Instrument for {}", track.name))); + resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, crate::localized_format!("Instrument for {}", track.name))); match info { Some(info) => used_slot(ui.painter(), r, t.slot_face, Mark::Dot, info.short_name, t.text, None), None => empty_slot(ui.painter(), r, resp.hovered(), Mark::Dot), @@ -19,7 +19,8 @@ pub(crate) fn instrument_slot(app: &mut SoundApp, ui: &mut Ui, track: &Track, r: if resp.clicked() && hosted && !app.ui.plugin_windows.contains(&(id, slot)) { app.ui.plugin_windows.push((id, slot)); } - let menu_resp = if hosted { resp.clone().on_hover_text("Click: open instrument · right-click: change") } else { resp.clone() }; + let menu_resp = + if hosted { resp.clone().on_hover_text(crate::localization::text("Click: open instrument · right-click: change")) } else { resp.clone() }; let popup = if hosted { egui::Popup::context_menu(&menu_resp) } else { egui::Popup::menu(&menu_resp) }; let popup = popup.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside); popup.show(|ui| instrument_menu(app, ui, id)); @@ -103,7 +104,9 @@ pub(crate) fn insert_slot(app: &mut SoundApp, ui: &mut Ui, track: &Track, slot: let id = track.id; let ins = track.mixer.inserts.get(slot).cloned().flatten(); let resp = ui.interact(r, ui.scope_id().with(("ins", id.0, slot)), Sense::click()); - resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, format!("Insert {} for {}", (b'A' + slot as u8) as char, track.name))); + resp.widget_info(|| { + egui::WidgetInfo::labeled(egui::Role::Button, true, crate::localized_format!("Insert {} for {}", (b'A' + slot as u8) as char, track.name)) + }); let info = ins.as_ref().and_then(|i| plugin_info(&i.plugin)); let name = ins.as_ref().map(|i| info.map_or(i.plugin.as_str(), |p| p.short_name)).unwrap_or_default(); match &ins { diff --git a/crates/ui-egui/src/palette.rs b/crates/ui-egui/src/palette.rs index 916087b0..b4331dc9 100644 --- a/crates/ui-egui/src/palette.rs +++ b/crates/ui-egui/src/palette.rs @@ -65,19 +65,30 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { let t = Tokens::current(); let mut run: Option = None; let mut close = ctx.input(|i| i.key_pressed(Key::Escape)); - egui::Window::new("Search") + egui::Window::new(crate::localization::text("Search")) + .id(egui::Id::unique("Search")) .collapsible(false) .resizable(false) .title_bar(false) .anchor(Align2::CENTER_TOP, vec2(0.0, 90.0)) .fixed_size(vec2(560.0, 380.0)) .show(ctx, |ui| { - let r = ui - .add(egui::TextEdit::singleline(&mut app.palette.query).hint_text("Search commands…").desired_width(f32::INFINITY).font(mono(15.0))); + let r = ui.add( + egui::TextEdit::singleline(&mut app.palette.query) + .hint_text(crate::localization::text("Search commands…")) + .desired_width(f32::INFINITY) + .font(mono(15.0)), + ); r.request_focus(); let q = app.palette.query.trim().to_string(); - let mut hits: Vec<(i32, Entry)> = - entries().into_iter().filter_map(|e| score(&format!("{} {} {}", e.label, e.path, e.id), &q).map(|s| (s, e))).collect(); + let mut hits: Vec<(i32, Entry)> = entries() + .into_iter() + .filter_map(|e| { + let label = crate::localization::text(&e.label); + let path = e.path.split(" › ").map(crate::localization::text).collect::>().join(" › "); + score(&format!("{label} {path} {} {} {}", e.label, e.path, e.id), &q).map(|s| (s, e)) + }) + .collect(); hits.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.label.cmp(&b.1.label))); hits.truncate(14); let (down, up, enter) = ctx.input(|i| (i.key_pressed(Key::ArrowDown), i.key_pressed(Key::ArrowUp), i.key_pressed(Key::Enter))); @@ -92,10 +103,11 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { for (i, (_, e)) in hits.iter().enumerate() { let sel = i == app.palette.selected; let resp = ui.horizontal(|ui| { - let l = ui.selectable_label(sel, &e.label); - ui.label(egui::RichText::new(&e.path).small().color(t.text_dim)); + let l = ui.selectable_label(sel, crate::localization::text(&e.label)); + let path = e.path.split(" › ").map(crate::localization::text).collect::>().join(" › "); + ui.label(egui::RichText::new(path).small().color(t.text_dim)); ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { - let sc = crate::shortcuts::shortcut_label(&e.shortcut, ctx.os().is_mac()); + let sc = crate::shortcuts::display_shortcut(&e.shortcut, ctx.os().is_mac()); ui.label(egui::RichText::new(sc).font(mono(10.0)).color(t.text_dim)); }); l diff --git a/crates/ui-egui/src/panels.rs b/crates/ui-egui/src/panels.rs index 932597b8..bf5cf459 100644 --- a/crates/ui-egui/src/panels.rs +++ b/crates/ui-egui/src/panels.rs @@ -33,7 +33,7 @@ fn panel_header(ui: &mut Ui, title: &str) { let t = Tokens::current(); let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::hover()); ui.painter().rect_filled(r, 0.0, t.panel_bg2); - ui.painter().text(pos2(r.min.x + 8.0, r.center().y), Align2::LEFT_CENTER, title, bold(11.5), t.header_text); + ui.painter().text(pos2(r.min.x + 8.0, r.center().y), Align2::LEFT_CENTER, crate::localization::text(title), bold(11.5), t.header_text); ui.painter().line_segment([pos2(r.min.x, r.max.y), pos2(r.max.x, r.max.y)], Stroke::new(1.0, t.border)); } diff --git a/crates/ui-egui/src/panels/about.rs b/crates/ui-egui/src/panels/about.rs index 2aaa5475..118f0147 100644 --- a/crates/ui-egui/src/panels/about.rs +++ b/crates/ui-egui/src/panels/about.rs @@ -7,30 +7,35 @@ pub(super) fn about(app: &mut SoundApp, ctx: &egui::Context) { return; } let tab_id = egui::Id::unique("about_tab"); - egui::Window::new("About SoundCraft").open(&mut open).default_size(vec2(820.0, 420.0)).collapsible(false).show(ctx, |ui| { - let mut tab = ui.data_mut(|d| d.get_temp::(tab_id)).unwrap_or(0); - ui.horizontal(|ui| { - for (i, l) in (0u8..).zip(["About", "Contributors", "Models"]) { - if ui.selectable_label(tab == i, l).clicked() { - tab = i; + egui::Window::new(crate::localization::text("About SoundCraft")) + .id(egui::Id::unique("About SoundCraft")) + .open(&mut open) + .default_size(vec2(820.0, 420.0)) + .collapsible(false) + .show(ctx, |ui| { + let mut tab = ui.data_mut(|d| d.get_temp::(tab_id)).unwrap_or(0); + ui.horizontal(|ui| { + for (i, l) in (0u8..).zip(["About", "Contributors", "Models"]) { + if ui.selectable_label(tab == i, crate::localization::text(l)).clicked() { + tab = i; + } + } + }); + ui.data_mut(|d| d.insert_temp(tab_id, tab)); + ui.separator(); + match tab { + 1 => crate::credits::contributors_ui(ui), + 2 => crate::credits::models_ui(ui), + _ => { + ui.label(egui::RichText::new(crate::localization::text("SoundCraft")).font(bold(22.0))); + ui.label(crate::localized_format!("Version {}", env!("CARGO_PKG_VERSION"))); + ui.label(crate::localization::text("An open-source digital audio workstation from the ArtCraft team.")); + ui.label(crate::localization::text("Dual-licensed MIT OR Apache-2.0. Made with Rust and egui.")); + ui.hyperlink_to("getartcraft.com/apps/soundcraft", "https://getartcraft.com/apps/soundcraft"); + ui.hyperlink_to(crate::localization::text("Join us on Discord"), "https://discord.gg/artcraft"); } } }); - ui.data_mut(|d| d.insert_temp(tab_id, tab)); - ui.separator(); - match tab { - 1 => crate::credits::contributors_ui(ui), - 2 => crate::credits::models_ui(ui), - _ => { - ui.label(egui::RichText::new("SoundCraft").font(bold(22.0))); - ui.label(format!("Version {}", env!("CARGO_PKG_VERSION"))); - ui.label("An open-source digital audio workstation from the ArtCraft team."); - ui.label("Dual-licensed MIT OR Apache-2.0. Made with Rust and egui."); - ui.hyperlink_to("getartcraft.com/apps/soundcraft", "https://getartcraft.com/apps/soundcraft"); - ui.hyperlink_to("Join us on Discord", "https://discord.gg/artcraft"); - } - } - }); app.ui.show_about = open; } @@ -39,11 +44,15 @@ pub(super) fn session_info(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("Session Info").open(&mut open).default_size(vec2(480.0, 360.0)).show(ctx, |ui| { - let text = soundcraft_engine::inspect::session_text(&app.engine); - egui::ScrollArea::vertical().show(ui, |ui| { - ui.label(egui::RichText::new(text).font(mono(11.0))); + egui::Window::new(crate::localization::text("Session Info")) + .id(egui::Id::unique("Session Info")) + .open(&mut open) + .default_size(vec2(480.0, 360.0)) + .show(ctx, |ui| { + let text = soundcraft_engine::inspect::session_text(&app.engine); + egui::ScrollArea::vertical().show(ui, |ui| { + ui.label(egui::RichText::new(text).font(mono(11.0))); + }); }); - }); app.ui.show_session_info = open; } diff --git a/crates/ui-egui/src/panels/clips.rs b/crates/ui-egui/src/panels/clips.rs index cbdd28d5..6cfc33d7 100644 --- a/crates/ui-egui/src/panels/clips.rs +++ b/crates/ui-egui/src/panels/clips.rs @@ -34,7 +34,7 @@ pub fn clip_list(app: &mut SoundApp, ui: &mut Ui) { panel_header(ui, "CLIPS"); let fkey = egui::Id::unique("clip_filter"); let mut filter: String = ui.ctx().memory(|m| m.data.get_temp(fkey)).unwrap_or_default(); - ui.add(egui::TextEdit::singleline(&mut filter).hint_text("🔍 Find clips").desired_width(f32::INFINITY)); + ui.add(egui::TextEdit::singleline(&mut filter).hint_text(crate::localization::text("🔍 Find clips")).desired_width(f32::INFINITY)); ui.ctx().memory_mut(|m| m.data.insert_temp(fkey, filter.clone())); let needle = filter.to_lowercase(); let rkey = egui::Id::unique("clip_rows"); @@ -73,26 +73,26 @@ pub fn clip_list(app: &mut SoundApp, ui: &mut Ui) { let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), row_h), if whole { Sense::click_and_drag() } else { Sense::click() }); resp.context_menu(|ui| { if whole { - if ui.button("Place on New Track").clicked() { + if ui.button(crate::localization::text("Place on New Track")).clicked() { let _ = app.run("clip.place_source", json!({"source": id})); ui.close(); } let sel_track = app.engine.session().edit.selected_tracks.first().map(|t| t.0); if let Some(t) = sel_track - && ui.button("Place on Selected Track").clicked() + && ui.button(crate::localization::text("Place on Selected Track")).clicked() { let _ = app.run("clip.place_source", json!({"source": id, "track": t})); ui.close(); } ui.separator(); } - if !whole && ui.button("Auto Rename…").clicked() { + if !whole && ui.button(crate::localization::text("Auto Rename…")).clicked() { // The selected clips when the row is one of them, otherwise the row's clip. let clips = if selected { app.engine.session().edit.selected_clips.clone() } else { vec![ClipId(id)] }; app.dialogs.open_auto_rename(&app.engine, clips); ui.close(); } - if ui.button("Clear…").clicked() { + if ui.button(crate::localization::text("Clear…")).clicked() { let (clips, sources) = if whole { (vec![], vec![SourceId(id)]) } else { (vec![ClipId(id)], vec![]) }; app.dialogs.open_clear(&app.engine, clips, sources); ui.close(); diff --git a/crates/ui-egui/src/panels/extra_windows.rs b/crates/ui-egui/src/panels/extra_windows.rs index 767e7e74..b4119bb0 100644 --- a/crates/ui-egui/src/panels/extra_windows.rs +++ b/crates/ui-egui/src/panels/extra_windows.rs @@ -105,10 +105,13 @@ fn renderer(app: &mut SoundApp, ctx: &egui::Context) { (tr.name.clone(), sp.x, sp.y, sp.z) }) .collect(); - egui::Window::new(egui::RichText::new("Renderer").font(bold(13.0))).open(&mut open).default_size(vec2(380.0, 440.0)).resizable(true).show( - ctx, - |ui| { - ui.label(egui::RichText::new(format!("Main output: {}", fmt.label())).font(regular(11.0)).color(t.text)); + egui::Window::new(egui::RichText::new(crate::localization::text("Renderer")).font(bold(13.0))) + .id(egui::Id::unique("Renderer")) + .open(&mut open) + .default_size(vec2(380.0, 440.0)) + .resizable(true) + .show(ctx, |ui| { + ui.label(egui::RichText::new(crate::localized_format!("Main output: {}", fmt.label())).font(regular(11.0)).color(t.text)); let side = ui.available_width().min(360.0); let (r, _) = ui.allocate_exact_size(vec2(side, side), Sense::hover()); let p = ui.painter_at(r); @@ -117,7 +120,7 @@ fn renderer(app: &mut SoundApp, ctx: &egui::Context) { let rad = side * 0.40; p.circle_stroke(c, rad, Stroke::new(1.0, Color32::from_rgb(60, 68, 78))); p.circle_stroke(c, rad * 0.55, Stroke::new(1.0, Color32::from_rgb(44, 50, 58))); - p.text(pos2(c.x, r.min.y + 8.0), Align2::CENTER_TOP, "front", regular(9.0), t.text_dim); + p.text(pos2(c.x, r.min.y + 8.0), Align2::CENTER_TOP, crate::localization::text("front"), regular(9.0), t.text_dim); for (i, sp) in fmt.speakers().iter().enumerate() { let level = peaks.get(i).copied().unwrap_or(0.0).clamp(0.0, 1.0); let ring = if sp.is_height() { rad * 0.55 } else { rad }; @@ -136,27 +139,32 @@ fn renderer(app: &mut SoundApp, ctx: &egui::Context) { ui.add_space(4.0); if objects.is_empty() { ui.label( - egui::RichText::new("No object tracks. Use the Object view in the Mix window to route tracks as objects.") - .small() - .color(t.text_dim), + egui::RichText::new(crate::localization::text( + "No object tracks. Use the Object view in the Mix window to route tracks as objects.", + )) + .small() + .color(t.text_dim), ); } else { - ui.label(egui::RichText::new(format!("{} object track(s)", objects.len())).small().color(t.text_dim)); + ui.label(egui::RichText::new(crate::localized_format!("{} object track(s)", objects.len())).small().color(t.text_dim)); } - }, - ); + }); app.extra.show_renderer = open; } -/// Appearance window: interface scale, reduce-motion, theme, auto-update configuration and Reset. +/// Appearance window: interface scale, reduce visual effects, theme, language, auto-update configuration and Reset. fn ui_customization(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.extra.show_ui_customization; if !open { return; } - egui::Window::new(egui::RichText::new("Appearance").font(bold(13.0))).open(&mut open).default_size(vec2(320.0, 180.0)).resizable(false).show( - ctx, - |ui| { + let language = app.ui.language; + egui::Window::new(egui::RichText::new(crate::localization::text("Appearance")).font(bold(13.0))) + .id(egui::Id::unique("Appearance")) + .open(&mut open) + .default_size(vec2(320.0, 210.0)) + .resizable(false) + .show(ctx, |ui| { // Each control carries its own visible label, which is also its accessible name. A // label in a neighbouring grid cell is only painted text: a screen reader (and the // kittest accessibility check) would see an unnamed slider, checkbox or combo box. @@ -164,38 +172,54 @@ fn ui_customization(app: &mut SoundApp, ctx: &egui::Context) { egui::Slider::new(&mut app.extra.ui_scale, 0.75..=1.5) .step_by(0.05) .custom_formatter(|v, _| format!("{:.0} %", v * 100.0)) - .text("Interface scale"), + .text(crate::localization::text("Interface scale")), ); let mut chosen_effects = None; - craft_ui::ComboBox::from_label("Reduce visual effects").selected_text(app.ui.reduce_visual_effects.label()).show_ui(ui, |ui| { - for mode in crate::preferences::ReduceVisualEffects::ALL { - if ui.selectable_label(app.ui.reduce_visual_effects == mode, mode.label()).clicked() { - chosen_effects = Some(mode); + craft_ui::ComboBox::from_label(crate::localization::text("Reduce visual effects")) + .selected_text(crate::localization::text(app.ui.reduce_visual_effects.label())) + .show_ui(ui, |ui| { + for mode in crate::preferences::ReduceVisualEffects::ALL { + if ui.selectable_label(app.ui.reduce_visual_effects == mode, crate::localization::text(mode.label())).clicked() { + chosen_effects = Some(mode); + } } - } - }); + }); if let Some(mode) = chosen_effects { let _ = app.run("ui.reduce_visual_effects", json!({"mode": mode.id()})); } - let mut chosen = None; - craft_ui::ComboBox::from_label("Theme").selected_text(app.ui.theme.label()).show_ui(ui, |ui| { - for mode in crate::theme::ThemeMode::ALL { - if ui.selectable_label(app.ui.theme == mode, mode.label()).clicked() { - chosen = Some(mode); + let mut selected_language = None; + craft_ui::ComboBox::from_label(crate::localization::text("Language")) + .selected_text(crate::localization::text(language.native_name())) + .show_ui(ui, |ui| { + for choice in crate::localization::Language::ALL { + if ui.selectable_label(language == choice, crate::localization::text(choice.native_name())).clicked() { + selected_language = Some(choice); + } } - } - }); + }); + if let Some(choice) = selected_language { + let _ = app.run("ui.language", json!({"language": choice.id()})); + } + let mut chosen = None; + craft_ui::ComboBox::from_label(crate::localization::text("Theme")) + .selected_text(crate::localization::text(app.ui.theme.label())) + .show_ui(ui, |ui| { + for mode in crate::theme::ThemeMode::ALL { + if ui.selectable_label(app.ui.theme == mode, crate::localization::text(mode.label())).clicked() { + chosen = Some(mode); + } + } + }); if let Some(mode) = chosen { let _ = app.run("ui.theme", json!({"mode": mode.id()})); } - crate::widgets::checkbox(ui, &mut app.extra.auto_update_config, "Auto-update configuration"); + crate::widgets::checkbox(ui, &mut app.extra.auto_update_config, crate::localization::text("Auto-update configuration")); ui.add_space(4.0); - if ui.button("Reset").clicked() { + if ui.button(crate::localization::text("Reset")).clicked() { app.extra.ui_scale = 1.0; let _ = app.run("ui.reduce_visual_effects", json!({"mode": "never"})); let _ = app.run("ui.theme", json!({"mode": crate::theme::ThemeMode::default().id()})); } - }, - ); + }); app.extra.show_ui_customization = open; } diff --git a/crates/ui-egui/src/panels/history.rs b/crates/ui-egui/src/panels/history.rs index 3d284f75..8d8c9e5f 100644 --- a/crates/ui-egui/src/panels/history.rs +++ b/crates/ui-egui/src/panels/history.rs @@ -5,14 +5,18 @@ pub(crate) fn undo_history(app: &mut SoundApp, ui: &mut Ui) { let n = hist.len(); egui::ScrollArea::vertical().show(ui, |ui| { for (i, h) in hist.iter().enumerate() { - if ui.selectable_label(i + 1 == n, format!("{} {h}", i + 1)).clicked() { + if ui.selectable_label(i + 1 == n, format!("{} {}", i + 1, crate::localization::text(h))).clicked() { for _ in 0..(n - i - 1) { let _ = app.run("edit.undo", json!({})); } } } if let Some(r) = app.engine.redo_label() { - ui.label(egui::RichText::new(format!("(redo) {r}")).italics().color(Tokens::current().text_dim)); + ui.label( + egui::RichText::new(crate::localized_format!("(redo) {r}", r = crate::localization::text(r))) + .italics() + .color(Tokens::current().text_dim), + ); } }); } diff --git a/crates/ui-egui/src/panels/memory.rs b/crates/ui-egui/src/panels/memory.rs index d849e382..52fc671a 100644 --- a/crates/ui-egui/src/panels/memory.rs +++ b/crates/ui-egui/src/panels/memory.rs @@ -2,12 +2,12 @@ use super::{SoundApp, Ui, json, mono}; /// One recallable memory-location row: number button, editable name, time, length, kind and delete. fn memory_location_row(app: &mut SoundApp, ui: &mut Ui, n: u32, name: &str, loc: &str, len: &str, kind: &str) { - if ui.button(n.to_string()).on_hover_text("Recall").clicked() { + if ui.button(n.to_string()).on_hover_text(crate::localization::text("Recall")).clicked() { let _ = app.run("markers.recall", json!({"number": n})); } let key = egui::Id::unique(("mem_name", n)); let mut edit: String = ui.ctx().memory(|m| m.data.get_temp(key)).unwrap_or_else(|| name.to_string()); - let r = crate::widgets::named_text_field(ui.add(egui::TextEdit::singleline(&mut edit).desired_width(140.0)), "Name"); + let r = crate::widgets::named_text_field(ui.add(egui::TextEdit::singleline(&mut edit).desired_width(140.0)), crate::localization::text("Name")); if r.changed() { ui.ctx().memory_mut(|m| m.data.insert_temp(key, edit.clone())); } @@ -17,7 +17,7 @@ fn memory_location_row(app: &mut SoundApp, ui: &mut Ui, n: u32, name: &str, loc: } ui.label(egui::RichText::new(loc).font(mono(11.0))); ui.label(egui::RichText::new(len).font(mono(11.0))); - ui.label(kind); + ui.label(crate::localization::text(kind)); if crate::widgets::close_button(ui, "Delete marker").clicked() { let _ = app.run("markers.delete", json!({"number": n})); } @@ -26,10 +26,10 @@ fn memory_location_row(app: &mut SoundApp, ui: &mut Ui, n: u32, name: &str, loc: pub(crate) fn memory_locations(app: &mut SoundApp, ui: &mut Ui) { ui.horizontal(|ui| { - if ui.button("+ Marker").clicked() { + if ui.button(crate::localization::text("+ Marker")).clicked() { let _ = app.run("markers.add", json!({})); } - if ui.button("+ Selection").clicked() { + if ui.button(crate::localization::text("+ Selection")).clicked() { let _ = app.run("markers.add", json!({"kind": "selection"})); } }); @@ -52,7 +52,7 @@ pub(crate) fn memory_locations(app: &mut SoundApp, ui: &mut Ui) { egui::ScrollArea::vertical().show(ui, |ui| { egui::Grid::new("mem_grid").striped(true).num_columns(6).show(ui, |ui| { for h in ["#", "Name", "Location", "Length", "Type", ""] { - ui.label(egui::RichText::new(h).strong()); + ui.label(egui::RichText::new(crate::localization::text(h)).strong()); } ui.end_row(); for (n, name, loc, len, kind) in &rows { diff --git a/crates/ui-egui/src/panels/midi_editor.rs b/crates/ui-egui/src/panels/midi_editor.rs index 77d81df6..df87c72d 100644 --- a/crates/ui-egui/src/panels/midi_editor.rs +++ b/crates/ui-egui/src/panels/midi_editor.rs @@ -122,7 +122,13 @@ pub fn show(app: &mut SoundApp, ui: &mut Ui) { ui.painter().rect_filled(full, 0.0, t.panel_bg); let header = Rect::from_min_size(full.min, vec2(full.width(), 22.0)); ui.painter().rect_filled(header, 0.0, t.panel_bg2); - ui.painter().text(pos2(header.min.x + 8.0, header.center().y), Align2::LEFT_CENTER, "MIDI EDITOR", bold(11.5), t.header_text); + ui.painter().text( + pos2(header.min.x + 8.0, header.center().y), + Align2::LEFT_CENTER, + crate::localization::text("MIDI EDITOR"), + bold(11.5), + t.header_text, + ); let Some(cid) = target_clip(app) else { empty_state(app, ui, full, header); return; @@ -184,8 +190,8 @@ fn empty_state(app: &mut SoundApp, ui: &mut Ui, full: Rect, header: Rect) { s.tracks.iter().find(|t| t.kind.is_midi() && s.edit.selected_tracks.contains(&t.id)).map(|t| (t.id, t.name.clone())) }; let msg = match &track { - Some((_, name)) => format!("Click to add a MIDI clip to {name} at the insertion point."), - None => "Select a MIDI clip (or a MIDI track) to edit its notes.".into(), + Some((_, name)) => crate::localized_format!("Click to add a MIDI clip to {name} at the insertion point.", name = name), + None => crate::localization::text("Select a MIDI clip (or a MIDI track) to edit its notes.").into(), }; ui.painter().text(full.center(), Align2::CENTER_CENTER, msg, regular(13.0), t.text_dim); let body = Rect::from_min_max(pos2(full.min.x, header.max.y), full.max); @@ -223,16 +229,16 @@ fn midi_toolbar(app: &mut SoundApp, ui: &mut Ui, header: Rect, cid: ClipId, grid let mut tb = ui.new_child(egui::UiBuilder::new().max_rect(bar).layout(egui::Layout::right_to_left(egui::Align::Center))); tb.spacing_mut().item_spacing.x = 4.0; let mut op: Option<(&str, serde_json::Value)> = None; - if tb.small_button("Legato").clicked() { + if tb.small_button(crate::localization::text("Legato")).clicked() { op = Some(("event.change_duration", json!({"legato": 0}))); } - if tb.small_button("Vel −10").clicked() { + if tb.small_button(crate::localization::text("Vel −10")).clicked() { op = Some(("event.change_velocity", json!({"add": -10}))); } - if tb.small_button("Vel +10").clicked() { + if tb.small_button(crate::localization::text("Vel +10")).clicked() { op = Some(("event.change_velocity", json!({"add": 10}))); } - if tb.small_button("Quantize").on_hover_text("Quantize to the grid").clicked() { + if tb.small_button(crate::localization::text("Quantize")).on_hover_text(crate::localization::text("Quantize to the grid")).clicked() { op = Some(("event.quantize", json!({"grid": grid_ticks, "strength": 100}))); } if let Some((id, mut p)) = op { @@ -477,7 +483,7 @@ fn velocity_lane(app: &mut SoundApp, ui: &mut Ui, g: &Roll<'_>, cid: ClipId, bas let t = Tokens::current(); // Velocity lane. ui.painter().rect_filled(vel, 0.0, Color32::from_rgb(28, 28, 30)); - ui.painter().text(pos2(label_x, vel.center().y), Align2::LEFT_CENTER, "Velocity", regular(10.0), t.text_dim); + ui.painter().text(pos2(label_x, vel.center().y), Align2::LEFT_CENTER, crate::localization::text("Velocity"), regular(10.0), t.text_dim); let vresp = ui.interact(vel, ui.scope_id().with(("vel", cid.0)), Sense::click_and_drag()); for (i, n) in sequence.notes.iter().enumerate() { let x = g.x_of(n.start); diff --git a/crates/ui-egui/src/panels/plugins.rs b/crates/ui-egui/src/panels/plugins.rs index 2495c142..6eae707b 100644 --- a/crates/ui-egui/src/panels/plugins.rs +++ b/crates/ui-egui/src/panels/plugins.rs @@ -26,33 +26,39 @@ pub(super) fn plugin_windows(app: &mut SoundApp, ctx: &egui::Context) { // Bypass and presets act on insert slots. if !instrument { ui.label(egui::RichText::new(&ins.preset).color(Tokens::current().text_dim)); - let label = if ins.bypass { "BYPASSED" } else { "Bypass" }; + let label = crate::localization::text(if ins.bypass { "BYPASSED" } else { "Bypass" }); if ui.button(label).clicked() { let _ = app.run("mix.insert_bypass", json!({"track": tid.0, "slot": slot})); } - ui.menu_button("Presets v", |ui| preset_menu(app, ui, tid, slot, info, &ins)); + ui.menu_button(crate::localization::text("Presets v"), |ui| preset_menu(app, ui, tid, slot, info, &ins)); } if soundcraft_mix::is_third_party(&ins.plugin) { let open = app.player.as_ref().is_some_and(|p| p.editor_open(tid, slot)); let available = app.player.as_ref().is_some_and(|p| p.has_editor(tid, slot)); - let label = if open { "Close Plugin Editor" } else { "Open Plugin Editor" }; + let label = crate::localization::text(if open { "Close Plugin Editor" } else { "Open Plugin Editor" }); let resp = ui.add_enabled(available, egui::Button::new(label)); - let resp = - if available { resp } else { resp.on_disabled_hover_text("This plugin has no editor of its own, or it is not loaded") }; + let resp = if available { + resp + } else { + resp.on_disabled_hover_text(crate::localization::text("This plugin has no editor of its own, or it is not loaded")) + }; if resp.clicked() && let Some(p) = &app.player { if open { p.close_editor(tid, slot); } else if let Err(e) = p.open_editor(tid, slot) { - app.ui.status = format!("{}: {e}", info.name); + app.ui.status = format!("{}: {}", info.name, crate::localization::error_text(&e.to_string())); } } } }); if instrument && soundcraft_mix::is_third_party(&ins.plugin) { // A hosted instrument keeps its sounds and settings in its own editor. - ui.label(egui::RichText::new("Load and edit sounds in the plugin's own editor.").color(Tokens::current().text_dim)); + ui.label( + egui::RichText::new(crate::localization::text("Load and edit sounds in the plugin's own editor.")) + .color(Tokens::current().text_dim), + ); return; } if instrument && ins.plugin == crate::sampler_window::SAMPLER { @@ -64,19 +70,23 @@ pub(super) fn plugin_windows(app: &mut SoundApp, ctx: &egui::Context) { } egui::ScrollArea::vertical().show(ui, |ui| { egui::Grid::new(("pg", tid.0, slot)).num_columns(3).show(ui, |ui| { + // Built-in parameters are translated; a third-party plugin supplies its own names. + let localize_params = !soundcraft_mix::is_third_party(&ins.plugin); for p in info.params { let v = ins.params.get(p.id).copied().unwrap_or(p.default); - let label = ui.label(p.name); + let label_text = if localize_params { crate::localization::text(p.name) } else { p.name }; + let label = ui.label(label_text); let mut x = v; let resp = if !p.choices.is_empty() { let mut idx = x.round().max(0.0) as usize; - let r = craft_ui::ComboBox::from_id_salt(("pc", tid.0, slot, p.id)) - .selected_text(p.choices.get(idx).copied().unwrap_or("?")) - .show_ui(ui, |ui| { - for (i, c) in p.choices.iter().enumerate() { - ui.selectable_value(&mut idx, i, *c); - } - }); + let selected = p.choices.get(idx).copied().unwrap_or("?"); + let selected_text = if localize_params { crate::localization::text(selected) } else { selected }; + let r = craft_ui::ComboBox::from_id_salt(("pc", tid.0, slot, p.id)).selected_text(selected_text).show_ui(ui, |ui| { + for (i, c) in p.choices.iter().enumerate() { + let choice_text = if localize_params { crate::localization::text(c) } else { c }; + ui.selectable_value(&mut idx, i, choice_text); + } + }); x = idx as f32; if r.response.clicked() && ui.input(|i| i.modifiers.alt) { x = p.default; @@ -182,13 +192,13 @@ fn preset_menu( info: &soundcraft_dsp::PluginInfo, ins: &soundcraft_model::Insert, ) { - if ui.button("").clicked() { + if ui.button(crate::localization::text("")).clicked() { let defaults: serde_json::Map = info.params.iter().map(|p| (p.id.to_string(), json!(p.default))).collect(); let _ = app.run("mix.insert_params", json!({"track": tid.0, "slot": slot, "params": defaults, "preset": ""})); ui.close(); } let Some(dir) = preset_dir(app, info.id) else { - ui.label("User presets need the desktop app."); + ui.label(crate::localization::text("User presets need the desktop app.")); return; }; let mut names: Vec = std::fs::read_dir(&dir) @@ -218,12 +228,19 @@ fn preset_menu( let key = egui::Id::unique(("preset_name", tid.0, slot)); let mut name: String = ui.ctx().memory(|m| m.data.get_temp(key)).unwrap_or_else(|| format!("{} preset", info.name)); ui.horizontal(|ui| { - crate::widgets::named_text_field(ui.add(egui::TextEdit::singleline(&mut name).desired_width(140.0)), "Preset name"); - if ui.button("Save").clicked() { + crate::widgets::named_text_field( + ui.add(egui::TextEdit::singleline(&mut name).desired_width(140.0)), + crate::localization::text("Preset name"), + ); + if ui.button(crate::localization::text("Save")).clicked() { let clean = soundcraft_engine::io::sanitize_name(&name); let body = json!({"format": "soundcraft-plugin-preset", "plugin": info.id, "params": ins.params}); let ok = std::fs::create_dir_all(&dir).is_ok() && std::fs::write(dir.join(format!("{clean}.json")), body.to_string()).is_ok(); - app.ui.status = if ok { format!("Saved preset {clean}") } else { "Could not save the preset".into() }; + app.ui.status = if ok { + crate::localized_format!("Saved preset {clean}", clean = clean) + } else { + crate::localization::text("Could not save the preset").into() + }; if ok { let _ = app.run("mix.insert_params", json!({"track": tid.0, "slot": slot, "params": {}, "preset": clean})); } diff --git a/crates/ui-egui/src/panels/sampler_window.rs b/crates/ui-egui/src/panels/sampler_window.rs index 2368edf5..b3c4eece 100644 --- a/crates/ui-egui/src/panels/sampler_window.rs +++ b/crates/ui-egui/src/panels/sampler_window.rs @@ -122,9 +122,9 @@ impl SoundApp { self.ui.plugin_windows.push((track, soundcraft_mix::INSTRUMENT_SLOT)); } let name = v.get("name").and_then(|n| n.as_str()).unwrap_or(what); - self.ui.status = format!("{name} loaded into the sampler"); + self.ui.status = crate::localized_format!("{name} loaded into the sampler", name = name); } - Err(e) => self.ui.status = format!("{what}: {e}"), + Err(e) => self.ui.status = format!("{}: {}", what, crate::localization::error_text(&e.to_string())), } } } @@ -137,8 +137,8 @@ pub fn sample_strip(app: &mut SoundApp, ui: &mut Ui, tid: TrackId, ins: &Insert) let audio = ins.sample.and_then(|id| s.pool.get(id)).cloned(); ui.horizontal(|ui| { let can_pick = app.services.pick_open.is_some(); - let load = ui.add_enabled(can_pick, egui::Button::new("Load Sample…")); - let load = if can_pick { load } else { load.on_disabled_hover_text("Drop an audio file on this window") }; + let load = ui.add_enabled(can_pick, egui::Button::new(crate::localization::text("Load Sample…"))); + let load = if can_pick { load } else { load.on_disabled_hover_text(crate::localization::text("Drop an audio file on this window")) }; if load.clicked() && let Some(pick) = &app.services.pick_open && let Some(path) = pick("mix.sampler_load", craft_audio::DECODE_EXTENSIONS) @@ -147,10 +147,10 @@ pub fn sample_strip(app: &mut SoundApp, ui: &mut Ui, tid: TrackId, ins: &Insert) Ok(path) => { let _ = app.run("mix.sampler_load", json!({"track": tid.0, "path": path})); } - Err(e) => app.ui.status = e.to_string(), + Err(e) => app.ui.status = crate::localization::error_text(&e.to_string()), } } - if ins.sample.is_some() && ui.button("Clear").clicked() { + if ins.sample.is_some() && ui.button(crate::localization::text("Clear")).clicked() { let _ = app.run("mix.sampler_clear", json!({"track": tid.0})); } }); @@ -174,7 +174,7 @@ pub fn sample_strip(app: &mut SoundApp, ui: &mut Ui, tid: TrackId, ins: &Insert) p.rect_filled(r, 4.0, t.playlist_bg); p.rect_stroke(r, 4.0, Stroke::new(1.0, t.border), StrokeKind::Inside); let Some(audio) = audio else { - p.text(r.center(), Align2::CENTER_CENTER, "Drop an audio file here", regular(12.0), t.text_dim); + p.text(r.center(), Align2::CENTER_CENTER, crate::localization::text("Drop an audio file here"), regular(12.0), t.text_dim); return; }; let frames = audio.frames().max(1); diff --git a/crates/ui-egui/src/panels/score_editor.rs b/crates/ui-egui/src/panels/score_editor.rs index 043b1ee4..cc1c945e 100644 --- a/crates/ui-egui/src/panels/score_editor.rs +++ b/crates/ui-egui/src/panels/score_editor.rs @@ -40,118 +40,125 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("Score Editor").open(&mut open).default_size(vec2(900.0, 340.0)).show(ctx, |ui| { - let Some(cid) = crate::midi_editor::target_clip(app) else { - ui.label("Select a MIDI clip or MIDI track."); - return; - }; - let s = app.engine.session(); - let Some((tid, clip)) = s.find_clip(cid).map(|(t, c)| (t, c.clone())) else { return }; - let ClipContent::Midi { sequence } = &clip.content else { return }; - let title = s.track(tid).map_or(String::new(), |t| t.name.clone()); - ui.label(egui::RichText::new(format!("{title} — {}", clip.name)).font(bold(13.0))); - let len_ticks = (s.tempo.samples_to_ticks(clip.end(), s.sample_rate) - s.tempo.samples_to_ticks(clip.start, s.sample_rate)).max(1); - let px_per_tick = 0.07f32; - let width = (len_ticks as f32 * px_per_tick + 120.0).max(ui.available_width()); - egui::ScrollArea::horizontal().show(ui, |ui| { - let (r, _) = ui.allocate_exact_size(vec2(width, 230.0), Sense::hover()); - let p = ui.painter_at(r); - p.rect_filled(r, 4.0, Color32::from_rgb(246, 243, 236)); - let ink = Color32::from_rgb(20, 20, 24); - let left = r.min.x + 70.0; - // Treble staff: E4..F5 (steps 2..10 above C4); bass: G2..A3 (steps -10..-2). - let c4_y = r.min.y + 115.0; - let y_of = |step: i32| c4_y - step as f32 * STEP; - for line in [2, 4, 6, 8, 10, -2, -4, -6, -8, -10] { - let y = y_of(line); - p.line_segment([pos2(r.min.x + 10.0, y), pos2(r.max.x - 10.0, y)], Stroke::new(1.0, ink)); - } - p.text(pos2(r.min.x + 22.0, y_of(6)), Align2::CENTER_CENTER, "𝄞", regular(36.0), ink); - // Bass clef, drawn: a curl from the F line plus two dots around it. - let f = pos2(r.min.x + 18.0, y_of(-4)); - let curl: Vec = (0..=20) - .map(|i| { - let a = -2.6 + i as f32 * 0.19; - let rad = 7.0 + i as f32 * 0.35; - pos2(f.x + a.cos() * rad * 0.9 + 2.0, f.y + a.sin() * rad + 4.0) - }) - .collect(); - p.circle_filled(pos2(f.x - 4.0, f.y), 3.0, ink); - p.add(Shape::line(curl, Stroke::new(2.2, ink))); - p.circle_filled(pos2(f.x + 14.0, y_of(-3)), 1.8, ink); - p.circle_filled(pos2(f.x + 14.0, y_of(-5)), 1.8, ink); - p.line_segment([pos2(r.min.x + 10.0, y_of(10)), pos2(r.min.x + 10.0, y_of(-10))], Stroke::new(2.0, ink)); - // Bar lines. - let base = s.tempo.samples_to_ticks(clip.start, s.sample_rate); - let mut bar_tick = 0i64; - let mut guard = 0; - while bar_tick <= len_ticks && guard < 2000 { - let x = left + bar_tick as f32 * px_per_tick; - p.line_segment([pos2(x - 8.0, y_of(10)), pos2(x - 8.0, y_of(-10))], Stroke::new(1.0, ink)); - let m = s.tempo.meter_at_tick(base + bar_tick); - let bb = s.tempo.bar_beat_at_tick(base + bar_tick); - p.text(pos2(x - 6.0, y_of(12)), Align2::LEFT_BOTTOM, bb.bar.to_string(), regular(9.0), Color32::from_rgb(120, 110, 100)); - bar_tick += m.ticks_per_bar().max(1); - guard += 1; - } - // Notes. - for n in &sequence.notes { - let x = left + n.start as f32 * px_per_tick; - let (step, sharp) = diatonic(n.pitch); - let y = y_of(step); - // Ledger lines. - let ledgers: Vec = if step >= 12 { - (12..=step).step_by(2).collect() - } else if step <= -12 { - (step..=-12).filter(|s| s % 2 == 0).collect() - } else if step == 0 || step == 1 { - vec![0] - } else { - Vec::new() - }; - for l in ledgers { - p.line_segment([pos2(x - 7.0, y_of(l)), pos2(x + 7.0, y_of(l))], Stroke::new(1.0, ink)); + egui::Window::new(crate::localization::text("Score Editor")) + .id(egui::Id::unique("Score Editor")) + .open(&mut open) + .default_size(vec2(900.0, 340.0)) + .show(ctx, |ui| { + let Some(cid) = crate::midi_editor::target_clip(app) else { + ui.label(crate::localization::text("Select a MIDI clip or MIDI track.")); + return; + }; + let s = app.engine.session(); + let Some((tid, clip)) = s.find_clip(cid).map(|(t, c)| (t, c.clone())) else { return }; + let ClipContent::Midi { sequence } = &clip.content else { return }; + let title = s.track(tid).map_or(String::new(), |t| t.name.clone()); + ui.label(egui::RichText::new(format!("{title} — {}", clip.name)).font(bold(13.0))); + let len_ticks = (s.tempo.samples_to_ticks(clip.end(), s.sample_rate) - s.tempo.samples_to_ticks(clip.start, s.sample_rate)).max(1); + let px_per_tick = 0.07f32; + let width = (len_ticks as f32 * px_per_tick + 120.0).max(ui.available_width()); + egui::ScrollArea::horizontal().show(ui, |ui| { + let (r, _) = ui.allocate_exact_size(vec2(width, 230.0), Sense::hover()); + let p = ui.painter_at(r); + p.rect_filled(r, 4.0, Color32::from_rgb(246, 243, 236)); + let ink = Color32::from_rgb(20, 20, 24); + let left = r.min.x + 70.0; + // Treble staff: E4..F5 (steps 2..10 above C4); bass: G2..A3 (steps -10..-2). + let c4_y = r.min.y + 115.0; + let y_of = |step: i32| c4_y - step as f32 * STEP; + for line in [2, 4, 6, 8, 10, -2, -4, -6, -8, -10] { + let y = y_of(line); + p.line_segment([pos2(r.min.x + 10.0, y), pos2(r.max.x - 10.0, y)], Stroke::new(1.0, ink)); } - let q = n.length as f32 / TICKS_PER_QUARTER as f32; - let hollow = q >= 1.75; - let head = Rect::from_center_size(pos2(x, y), vec2(10.0, 7.5)); - if hollow { - p.add(Shape::ellipse_stroke(head.center(), head.size() * 0.5, Stroke::new(1.6, ink))); - } else { - p.add(Shape::ellipse_filled(head.center(), head.size() * 0.5, ink)); + p.text(pos2(r.min.x + 22.0, y_of(6)), Align2::CENTER_CENTER, "𝄞", regular(36.0), ink); + // Bass clef, drawn: a curl from the F line plus two dots around it. + let f = pos2(r.min.x + 18.0, y_of(-4)); + let curl: Vec = (0..=20) + .map(|i| { + let a = -2.6 + i as f32 * 0.19; + let rad = 7.0 + i as f32 * 0.35; + pos2(f.x + a.cos() * rad * 0.9 + 2.0, f.y + a.sin() * rad + 4.0) + }) + .collect(); + p.circle_filled(pos2(f.x - 4.0, f.y), 3.0, ink); + p.add(Shape::line(curl, Stroke::new(2.2, ink))); + p.circle_filled(pos2(f.x + 14.0, y_of(-3)), 1.8, ink); + p.circle_filled(pos2(f.x + 14.0, y_of(-5)), 1.8, ink); + p.line_segment([pos2(r.min.x + 10.0, y_of(10)), pos2(r.min.x + 10.0, y_of(-10))], Stroke::new(2.0, ink)); + // Bar lines. + let base = s.tempo.samples_to_ticks(clip.start, s.sample_rate); + let mut bar_tick = 0i64; + let mut guard = 0; + while bar_tick <= len_ticks && guard < 2000 { + let x = left + bar_tick as f32 * px_per_tick; + p.line_segment([pos2(x - 8.0, y_of(10)), pos2(x - 8.0, y_of(-10))], Stroke::new(1.0, ink)); + let m = s.tempo.meter_at_tick(base + bar_tick); + let bb = s.tempo.bar_beat_at_tick(base + bar_tick); + p.text(pos2(x - 6.0, y_of(12)), Align2::LEFT_BOTTOM, bb.bar.to_string(), regular(9.0), Color32::from_rgb(120, 110, 100)); + bar_tick += m.ticks_per_bar().max(1); + guard += 1; } - if sharp { - // An original drawn sharp sign: no bundled family covers U+266F. - let cx = x - 12.0; - for dx in [-2.6, 1.2] { - p.line_segment([pos2(cx + dx - 1.0, y - 5.0), pos2(cx + dx + 1.0, y + 5.0)], Stroke::new(1.1, ink)); - } - for dy in [-1.8, 1.8] { - p.line_segment([pos2(cx - 5.0, y + dy), pos2(cx + 5.0, y + dy - 1.0)], Stroke::new(1.1, ink)); - } - } - if q < 3.5 { - // Stems up below the middle line of each staff, down above it. - let up = if step >= 0 { step < 6 } else { step < -6 }; - let (sx, sy0, sy1): (f32, f32, f32) = if up { (x + 4.5, y, y - 26.0) } else { (x - 4.5, y, y + 26.0) }; - p.line_segment([pos2(sx, sy0), pos2(sx, sy1)], Stroke::new(1.2, ink)); - let flags = if q <= 0.3 { - 2 - } else if q <= 0.6 { - 1 + // Notes. + for n in &sequence.notes { + let x = left + n.start as f32 * px_per_tick; + let (step, sharp) = diatonic(n.pitch); + let y = y_of(step); + // Ledger lines. + let ledgers: Vec = if step >= 12 { + (12..=step).step_by(2).collect() + } else if step <= -12 { + (step..=-12).filter(|s| s % 2 == 0).collect() + } else if step == 0 || step == 1 { + vec![0] } else { - 0 + Vec::new() }; - for f in 0..flags { - let fy = sy1 + if up { f as f32 * 6.0 } else { -(f as f32) * 6.0 }; - let tip: Pos2 = pos2(sx + 8.0, fy + if up { 10.0 } else { -10.0 }); - p.line_segment([pos2(sx, fy), tip], Stroke::new(1.6, ink)); + for l in ledgers { + p.line_segment([pos2(x - 7.0, y_of(l)), pos2(x + 7.0, y_of(l))], Stroke::new(1.0, ink)); + } + let q = n.length as f32 / TICKS_PER_QUARTER as f32; + let hollow = q >= 1.75; + let head = Rect::from_center_size(pos2(x, y), vec2(10.0, 7.5)); + if hollow { + p.add(Shape::ellipse_stroke(head.center(), head.size() * 0.5, Stroke::new(1.6, ink))); + } else { + p.add(Shape::ellipse_filled(head.center(), head.size() * 0.5, ink)); + } + if sharp { + // An original drawn sharp sign: no bundled family covers U+266F. + let cx = x - 12.0; + for dx in [-2.6, 1.2] { + p.line_segment([pos2(cx + dx - 1.0, y - 5.0), pos2(cx + dx + 1.0, y + 5.0)], Stroke::new(1.1, ink)); + } + for dy in [-1.8, 1.8] { + p.line_segment([pos2(cx - 5.0, y + dy), pos2(cx + 5.0, y + dy - 1.0)], Stroke::new(1.1, ink)); + } + } + if q < 3.5 { + // Stems up below the middle line of each staff, down above it. + let up = if step >= 0 { step < 6 } else { step < -6 }; + let (sx, sy0, sy1): (f32, f32, f32) = if up { (x + 4.5, y, y - 26.0) } else { (x - 4.5, y, y + 26.0) }; + p.line_segment([pos2(sx, sy0), pos2(sx, sy1)], Stroke::new(1.2, ink)); + let flags = if q <= 0.3 { + 2 + } else if q <= 0.6 { + 1 + } else { + 0 + }; + for f in 0..flags { + let fy = sy1 + if up { f as f32 * 6.0 } else { -(f as f32) * 6.0 }; + let tip: Pos2 = pos2(sx + 8.0, fy + if up { 10.0 } else { -10.0 }); + p.line_segment([pos2(sx, fy), tip], Stroke::new(1.6, ink)); + } } } - } + }); + ui.label( + egui::RichText::new(crate::localization::text("Notation view of the MIDI clip; edit notes in the MIDI Editor or Event List.")) + .small(), + ); }); - ui.label(egui::RichText::new("Notation view of the MIDI clip; edit notes in the MIDI Editor or Event List.").small()); - }); app.ui.show_score = open; } diff --git a/crates/ui-egui/src/panels/tracks.rs b/crates/ui-egui/src/panels/tracks.rs index 1be81dd0..7a1820e4 100644 --- a/crates/ui-egui/src/panels/tracks.rs +++ b/crates/ui-egui/src/panels/tracks.rs @@ -42,7 +42,7 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) { let header = Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), 22.0)); panel_header(ui, "TRACKS"); let plus = Rect::from_center_size(pos2(header.max.x - 13.0, header.center().y), vec2(18.0, 18.0)); - let tip = format!("New Tracks… ({})", crate::shortcuts::shortcut_label("Cmd+Shift+N", ui.ctx().os().is_mac())); + let tip = crate::localized_format!("New Tracks… ({})", crate::shortcuts::display_shortcut("Cmd+Shift+N", ui.ctx().os().is_mac())); if crate::widgets::icon_button(&mut ui.new_child(egui::UiBuilder::new().max_rect(plus)), plus.size(), "plus", false, &tip).clicked() { let _ = app.dialogs.open_for_command(&app.engine, "track.new"); } @@ -112,14 +112,14 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) { let groups_area = with_pending_offset(egui::ScrollArea::vertical().id_salt("groups_scroll"), ui, "groups_scroll"); let out = groups_area.auto_shrink([false, false]).scroll_bar_visibility(hidden).show(ui, |ui| { let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 17.0), Sense::hover()); - ui.painter().text(pos2(r.min.x + 30.0, r.center().y), Align2::LEFT_CENTER, "", regular(11.5).clone(), t.text); + ui.painter().text(pos2(r.min.x + 30.0, r.center().y), Align2::LEFT_CENTER, crate::localization::text(""), regular(11.5).clone(), t.text); let all = ui.interact(r, ui.scope_id().with("group_all"), Sense::click()); - all.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, "")); + all.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, crate::localization::text(""))); if all.double_clicked() { let _ = app.run("edit.select_all", json!({})); } all.context_menu(|ui| { - if ui.button("New Group…").clicked() { + if ui.button(crate::localization::text("New Group…")).clicked() { let _ = app.dialogs.open_for_command(&app.engine, "track.group"); ui.close(); } @@ -147,19 +147,19 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) { let _ = app.run("edit.select", json!({"tracks": members, "exact": true})); } resp.context_menu(|ui| { - if ui.button("Select Tracks in Group").clicked() { + if ui.button(crate::localization::text("Select Tracks in Group")).clicked() { let _ = app.run("edit.select", json!({"tracks": members, "exact": true})); ui.close(); } - if ui.button(if active { "Disable" } else { "Enable" }).clicked() { + if ui.button(crate::localization::text(if active { "Disable" } else { "Enable" })).clicked() { let _ = app.run("track.group_toggle", json!({"group": id})); ui.close(); } - if ui.button("Modify Group…").clicked() { + if ui.button(crate::localization::text("Modify Group…")).clicked() { let _ = app.dialogs.open_modify_group(&app.engine, soundcraft_model::GroupId(id)); ui.close(); } - if ui.button("Delete Group").clicked() { + if ui.button(crate::localization::text("Delete Group")).clicked() { let _ = app.run("track.ungroup", json!({"group": id})); ui.close(); } diff --git a/crates/ui-egui/src/panels/transport.rs b/crates/ui-egui/src/panels/transport.rs index 9451c1d6..1474290b 100644 --- a/crates/ui-egui/src/panels/transport.rs +++ b/crates/ui-egui/src/panels/transport.rs @@ -6,86 +6,100 @@ pub(super) fn transport_window(app: &mut SoundApp, ctx: &egui::Context) { return; } let t = Tokens::current(); - egui::Window::new("Transport").open(&mut open).resizable(false).default_pos(pos2(400.0, 500.0)).show(ctx, |ui| { - let flags = app.engine.session().edit.flags.clone(); - let expanded = flags.contains("view.transport.expanded"); - ui.horizontal(|ui| { - for (icon, cmd) in [ - ("rtz", "transport.rtz"), - ("rewind", "transport.rewind"), - ("stop", "transport.stop"), - ("play", "transport.play"), - ("ffwd", "transport.fast_forward"), - ("end", "transport.go_to_end"), - ("record", "transport.record"), - ] { - let resp = crate::widgets::icon_button( - ui, - vec2(34.0, 26.0), - icon, - (cmd == "transport.play" && app.is_playing()) || (cmd == "transport.record" && app.engine.transport.recording), - cmd, - ); - if cmd == "transport.record" - && let Some(why) = app.record_hint() - { - egui::Tooltip::for_widget(&resp).show(|ui| ui.label(why)); - } - if resp.clicked() { - let _ = app.run(cmd, json!({})); - } - } - if flags.contains("view.transport.output_meters") { - let (r, _) = ui.allocate_exact_size(vec2(22.0, 26.0), Sense::hover()); - let m = app.main_meter; - crate::widgets::meter(ui, Rect::from_min_size(r.min, vec2(10.0, 26.0)), m.level[0], m.hold[0], m.clip); - crate::widgets::meter(ui, Rect::from_min_size(pos2(r.min.x + 12.0, r.min.y), vec2(10.0, 26.0)), m.level[1], m.hold[1], m.clip); - } - }); - let s = app.engine.session(); - let fmt = |x: i64| s.format_position(x, s.edit.main_counter); - if flags.contains("view.transport.counters") || expanded || flags.is_empty() { - ui.label(egui::RichText::new(fmt(app.position())).font(mono(20.0)).color(t.counter_text)); - } - if expanded { - let e = s.edit.clone(); - egui::Grid::new("tx_exp").num_columns(4).show(ui, |ui| { - ui.label("Start"); - ui.label(egui::RichText::new(fmt(e.selection.start)).font(mono(11.0))); - ui.label("Pre-roll"); - ui.label(egui::RichText::new(format!("{:.2} s", s.sample_rate.seconds(e.pre_roll))).font(mono(11.0))); - ui.end_row(); - ui.label("End"); - ui.label(egui::RichText::new(fmt(e.selection.end)).font(mono(11.0))); - ui.label("Post-roll"); - ui.label(egui::RichText::new(format!("{:.2} s", s.sample_rate.seconds(e.post_roll))).font(mono(11.0))); - ui.end_row(); - }); - } - if flags.contains("view.transport.midi_controls") || expanded { - let (click, countoff, merge, loop_rec, prepost) = { - let e = &app.engine.session().edit; - (e.click, e.countoff, e.midi_merge, e.loop_record, e.pre_post_roll) - }; + egui::Window::new(crate::localization::text("Transport")) + .id(egui::Id::unique("Transport")) + .open(&mut open) + .resizable(false) + .default_pos(pos2(400.0, 500.0)) + .show(ctx, |ui| { + let flags = app.engine.session().edit.flags.clone(); + let expanded = flags.contains("view.transport.expanded"); ui.horizontal(|ui| { - for (label, on, cmd) in [ - ("Click", click, "options.click"), - ("Count Off", countoff, "options.countoff"), - ("MIDI Merge", merge, "options.midi_merge"), - ("Loop Rec", loop_rec, "options.loop_record"), - ("Pre/Post", prepost, "options.pre_post_roll"), + for (icon, cmd) in [ + ("rtz", "transport.rtz"), + ("rewind", "transport.rewind"), + ("stop", "transport.stop"), + ("play", "transport.play"), + ("ffwd", "transport.fast_forward"), + ("end", "transport.go_to_end"), + ("record", "transport.record"), ] { - if ui.selectable_label(on, label).clicked() { + let resp = crate::widgets::icon_button( + ui, + vec2(34.0, 26.0), + icon, + (cmd == "transport.play" && app.is_playing()) || (cmd == "transport.record" && app.engine.transport.recording), + cmd, + ); + if cmd == "transport.record" + && let Some(why) = app.record_hint() + { + egui::Tooltip::for_widget(&resp).show(|ui| ui.label(why)); + } + if resp.clicked() { let _ = app.run(cmd, json!({})); } } + if flags.contains("view.transport.output_meters") { + let (r, _) = ui.allocate_exact_size(vec2(22.0, 26.0), Sense::hover()); + let m = app.main_meter; + crate::widgets::meter(ui, Rect::from_min_size(r.min, vec2(10.0, 26.0)), m.level[0], m.hold[0], m.clip); + crate::widgets::meter(ui, Rect::from_min_size(pos2(r.min.x + 12.0, r.min.y), vec2(10.0, 26.0)), m.level[1], m.hold[1], m.clip); + } }); - let tick = app.engine.session().tempo.samples_to_ticks(app.position(), app.engine.session().sample_rate); - let bpm = app.engine.session().tempo.tempo_at_tick(tick); - let m = app.engine.session().tempo.meter_at_tick(tick); - ui.label(egui::RichText::new(format!("♩ = {bpm:.2} {}/{}", m.numerator, m.denominator)).font(mono(12.0)).color(t.counter_text)); - } - }); + let s = app.engine.session(); + let fmt = |x: i64| s.format_position(x, s.edit.main_counter); + if flags.contains("view.transport.counters") || expanded || flags.is_empty() { + ui.label(egui::RichText::new(fmt(app.position())).font(mono(20.0)).color(t.counter_text)); + } + if expanded { + let e = s.edit.clone(); + egui::Grid::new("tx_exp").num_columns(4).show(ui, |ui| { + ui.label(crate::localization::text("Start")); + ui.label(egui::RichText::new(fmt(e.selection.start)).font(mono(11.0))); + ui.label(crate::localization::text("Pre-roll")); + ui.label( + egui::RichText::new(crate::localized_format!("{seconds:.2} s", seconds = s.sample_rate.seconds(e.pre_roll))).font(mono(11.0)), + ); + ui.end_row(); + ui.label(crate::localization::text("End")); + ui.label(egui::RichText::new(fmt(e.selection.end)).font(mono(11.0))); + ui.label(crate::localization::text("Post-roll")); + ui.label( + egui::RichText::new(crate::localized_format!("{seconds:.2} s", seconds = s.sample_rate.seconds(e.post_roll))) + .font(mono(11.0)), + ); + ui.end_row(); + }); + } + if flags.contains("view.transport.midi_controls") || expanded { + let (click, countoff, merge, loop_rec, prepost) = { + let e = &app.engine.session().edit; + (e.click, e.countoff, e.midi_merge, e.loop_record, e.pre_post_roll) + }; + ui.horizontal(|ui| { + for (label, on, cmd) in [ + ("Click", click, "options.click"), + ("Count Off", countoff, "options.countoff"), + ("MIDI Merge", merge, "options.midi_merge"), + ("Loop Rec", loop_rec, "options.loop_record"), + ("Pre/Post", prepost, "options.pre_post_roll"), + ] { + if ui.selectable_label(on, crate::localization::text(label)).clicked() { + let _ = app.run(cmd, json!({})); + } + } + }); + let tick = app.engine.session().tempo.samples_to_ticks(app.position(), app.engine.session().sample_rate); + let bpm = app.engine.session().tempo.tempo_at_tick(tick); + let m = app.engine.session().tempo.meter_at_tick(tick); + ui.label( + egui::RichText::new(crate::localized_format!("♩ = {bpm:.2} {n}/{d}", bpm = bpm, n = m.numerator, d = m.denominator)) + .font(mono(12.0)) + .color(t.counter_text), + ); + } + }); app.ui.show_transport = open; } @@ -94,13 +108,17 @@ pub(super) fn big_counter(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("Big Counter").open(&mut open).default_size(vec2(520.0, 110.0)).show(ctx, |ui| { - let s = app.engine.session(); - let txt = s.format_position(app.position(), s.edit.main_counter); - let r = ui.available_rect_before_wrap(); - let t = Tokens::current(); - ui.painter().rect_filled(r, 4.0, t.big_counter_bg); - ui.painter().text(r.center(), Align2::CENTER_CENTER, txt, mono((r.height() * 0.6).clamp(20.0, 120.0)), t.counter_text); - }); + egui::Window::new(crate::localization::text("Big Counter")) + .id(egui::Id::unique("Big Counter")) + .open(&mut open) + .default_size(vec2(520.0, 110.0)) + .show(ctx, |ui| { + let s = app.engine.session(); + let txt = s.format_position(app.position(), s.edit.main_counter); + let r = ui.available_rect_before_wrap(); + let t = Tokens::current(); + ui.painter().rect_filled(r, 4.0, t.big_counter_bg); + ui.painter().text(r.center(), Align2::CENTER_CENTER, txt, mono((r.height() * 0.6).clamp(20.0, 120.0)), t.counter_text); + }); app.ui.show_big_counter = open; } diff --git a/crates/ui-egui/src/panels/video_window.rs b/crates/ui-egui/src/panels/video_window.rs index a6ca6751..4e500872 100644 --- a/crates/ui-egui/src/panels/video_window.rs +++ b/crates/ui-egui/src/panels/video_window.rs @@ -32,19 +32,19 @@ fn video_status_text(app: &SoundApp, pic: Option<&(MovieKey, Result, f64, f64)>, on: bool) { let msg = if !on { - Some("Video Track Offline".to_string()) + Some(crate::localization::text("Video Track Offline").to_string()) } else { match pic { None => None, - Some((_, Err(why), ..)) => Some(why.clone()), + Some((_, Err(why), ..)) => Some(crate::localization::text(why).to_string()), Some((k, ..)) => match (app.video.current(*k), app.video.current_error(*k)) { (Some(tex), _) => { painter.image(tex.id(), img, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE); None } - (None, Some(e)) => Some(e.to_string()), + (None, Some(e)) => Some(crate::localization::text(e).to_string()), (None, None) => match app.video.info(*k) { - Some(Err(e)) => Some(e.clone()), + Some(Err(e)) => Some(crate::localization::text(e).to_string()), _ => None, }, }, @@ -72,33 +72,38 @@ fn video(app: &mut SoundApp, ctx: &egui::Context) { .clamp(0.2, 5.0); let mut open = true; let mut burn = app.ui.video_burn_in; - egui::Window::new("Video").open(&mut open).default_size(vec2(480.0, 480.0 / aspect + 28.0)).resizable(true).show(ctx, |ui| { - ui.horizontal(|ui| { - crate::widgets::checkbox(ui, &mut burn, "Timecode burn-in"); - let text = video_status_text(app, pic.as_ref()); - ui.label(egui::RichText::new(text).font(regular(10.5)).color(Color32::from_gray(150))); + egui::Window::new(crate::localization::text("Video")) + .id(egui::Id::unique("Video")) + .open(&mut open) + .default_size(vec2(480.0, 480.0 / aspect + 28.0)) + .resizable(true) + .show(ctx, |ui| { + ui.horizontal(|ui| { + crate::widgets::checkbox(ui, &mut burn, crate::localization::text("Timecode burn-in")); + let text = video_status_text(app, pic.as_ref()); + ui.label(egui::RichText::new(text).font(regular(10.5)).color(Color32::from_gray(150))); + }); + let avail = ui.available_rect_before_wrap(); + let (r, _) = ui.allocate_exact_size(avail.size().max(vec2(64.0, 36.0)), Sense::hover()); + let painter = ui.painter_at(r); + painter.rect_filled(r, 0.0, Color32::BLACK); + // Fit the picture inside the area, keeping its aspect. + let (mut w, mut h) = (r.width(), r.width() / aspect); + if h > r.height() { + h = r.height(); + w = h * aspect; + } + let img = Rect::from_center_size(r.center(), vec2(w, h)); + draw_video_surface(app, &painter, img, pic.as_ref(), on); + if burn { + let tc = s.format_position(pos, TimeFormat::Timecode); + let size = (h / 12.0).clamp(10.0, 36.0); + let galley = painter.layout_no_wrap(tc, mono(size), Color32::WHITE); + let at = pos2(img.center().x - galley.size().x / 2.0, img.max.y - galley.size().y - size * 0.6); + painter.rect_filled(Rect::from_min_size(at, galley.size()).expand2(vec2(6.0, 2.0)), 2.0, Color32::from_black_alpha(200)); + painter.galley(at, galley, Color32::WHITE); + } }); - let avail = ui.available_rect_before_wrap(); - let (r, _) = ui.allocate_exact_size(avail.size().max(vec2(64.0, 36.0)), Sense::hover()); - let painter = ui.painter_at(r); - painter.rect_filled(r, 0.0, Color32::BLACK); - // Fit the picture inside the area, keeping its aspect. - let (mut w, mut h) = (r.width(), r.width() / aspect); - if h > r.height() { - h = r.height(); - w = h * aspect; - } - let img = Rect::from_center_size(r.center(), vec2(w, h)); - draw_video_surface(app, &painter, img, pic.as_ref(), on); - if burn { - let tc = s.format_position(pos, TimeFormat::Timecode); - let size = (h / 12.0).clamp(10.0, 36.0); - let galley = painter.layout_no_wrap(tc, mono(size), Color32::WHITE); - let at = pos2(img.center().x - galley.size().x / 2.0, img.max.y - galley.size().y - size * 0.6); - painter.rect_filled(Rect::from_min_size(at, galley.size()).expand2(vec2(6.0, 2.0)), 2.0, Color32::from_black_alpha(200)); - painter.galley(at, galley, Color32::WHITE); - } - }); app.ui.video_burn_in = burn; if !open { app.ui.show_video = false; @@ -137,57 +142,68 @@ fn universe(app: &mut SoundApp, ctx: &egui::Context) { let pos = app.position(); let mut open = true; let mut locate = None; - egui::Window::new("Video Universe").open(&mut open).default_size(vec2(640.0, 90.0)).resizable(true).show(ctx, |ui| { - let avail = ui.available_rect_before_wrap(); - let (r, resp) = ui.allocate_exact_size(vec2(avail.width().max(120.0), 64.0), Sense::click_and_drag()); - let painter = ui.painter_at(r); - painter.rect_filled(r, 0.0, Color32::from_rgb(14, 14, 15)); - let end = s.content_end().max(s.sample_rate.samples(10.0)).max(1); - let x_at = |at: i64| r.min.x + r.width() * (at as f32 / end as f32); - let on = online(&s); - let Some(track) = s.tracks.iter().find(|t| t.kind == TrackKind::Video) else { - painter.text(r.center(), Align2::CENTER_CENTER, "No Video track — File › Import › Video…", regular(11.0), Color32::from_gray(150)); - return; - }; - let ppp = ctx.pixels_per_point(); - for c in track.clips() { - let ClipContent::Video { source, offset } = c.content else { continue }; - let Some(v) = s.video(source) else { continue }; - let key = MovieKey::new(source, &v.path); - let cr = Rect::from_min_max(pos2(x_at(c.start), r.min.y + 4.0), pos2(x_at(c.end()).max(x_at(c.start) + 2.0), r.max.y - 4.0)); - painter.rect_filled(cr, 0.0, Color32::from_rgb(30, 30, 34)); - if !on || v.offline.is_some() { - continue; - } - let tw = (cr.height() * v.aspect() as f32).max(8.0); - let hpx = ((cr.height() * ppp / 16.0).ceil() * 16.0).clamp(16.0, 256.0) as u32; - // Only the thumbnails inside the strip, counted rather than stepped: a clip starting - // far left of it has an edge so large that adding a thumbnail's width wouldn't move it. - let shown = cr.intersect(r); - for x in thumb_xs(cr.min.x, shown.min.x, shown.max.x, tw) { - let secs = movie_secs(&s, c.start, offset, strip_position(x, r.min.x, r.width(), end, c.start)).max(0.0); - if let Some(tex) = app.video.thumb(ctx, key, &v.path, secs, hpx) { - let tr = Rect::from_min_size(pos2(x, cr.min.y), vec2(tw, cr.height())); - let vis = tr.intersect(cr); - let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2((vis.width() / tw).clamp(0.0, 1.0), 1.0)); - painter.image(tex.id(), vis, uv, Color32::WHITE); + egui::Window::new(crate::localization::text("Video Universe")) + .id(egui::Id::unique("Video Universe")) + .open(&mut open) + .default_size(vec2(640.0, 90.0)) + .resizable(true) + .show(ctx, |ui| { + let avail = ui.available_rect_before_wrap(); + let (r, resp) = ui.allocate_exact_size(vec2(avail.width().max(120.0), 64.0), Sense::click_and_drag()); + let painter = ui.painter_at(r); + painter.rect_filled(r, 0.0, Color32::from_rgb(14, 14, 15)); + let end = s.content_end().max(s.sample_rate.samples(10.0)).max(1); + let x_at = |at: i64| r.min.x + r.width() * (at as f32 / end as f32); + let on = online(&s); + let Some(track) = s.tracks.iter().find(|t| t.kind == TrackKind::Video) else { + painter.text( + r.center(), + Align2::CENTER_CENTER, + crate::localization::text("No Video track — File › Import › Video…"), + regular(11.0), + Color32::from_gray(150), + ); + return; + }; + let ppp = ctx.pixels_per_point(); + for c in track.clips() { + let ClipContent::Video { source, offset } = c.content else { continue }; + let Some(v) = s.video(source) else { continue }; + let key = MovieKey::new(source, &v.path); + let cr = Rect::from_min_max(pos2(x_at(c.start), r.min.y + 4.0), pos2(x_at(c.end()).max(x_at(c.start) + 2.0), r.max.y - 4.0)); + painter.rect_filled(cr, 0.0, Color32::from_rgb(30, 30, 34)); + if !on || v.offline.is_some() { + continue; + } + let tw = (cr.height() * v.aspect() as f32).max(8.0); + let hpx = ((cr.height() * ppp / 16.0).ceil() * 16.0).clamp(16.0, 256.0) as u32; + // Only the thumbnails inside the strip, counted rather than stepped: a clip starting + // far left of it has an edge so large that adding a thumbnail's width wouldn't move it. + let shown = cr.intersect(r); + for x in thumb_xs(cr.min.x, shown.min.x, shown.max.x, tw) { + let secs = movie_secs(&s, c.start, offset, strip_position(x, r.min.x, r.width(), end, c.start)).max(0.0); + if let Some(tex) = app.video.thumb(ctx, key, &v.path, secs, hpx) { + let tr = Rect::from_min_size(pos2(x, cr.min.y), vec2(tw, cr.height())); + let vis = tr.intersect(cr); + let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2((vis.width() / tw).clamp(0.0, 1.0), 1.0)); + painter.image(tex.id(), vis, uv, Color32::WHITE); + } } } - } - // The Edit window's visible range and the playhead. - let spp = s.edit.zoom.samples_per_px.max(1e-6); - let vs = s.edit.zoom.scroll.max(0); - let ve = vs.saturating_add((spp * f64::from(ui.ctx().content_rect().width())) as i64); - let view = Rect::from_min_max(pos2(x_at(vs), r.min.y + 1.0), pos2(x_at(ve).min(r.max.x), r.max.y - 1.0)); - painter.rect_stroke(view, 0.0, egui::Stroke::new(1.0, Color32::from_rgb(230, 200, 80)), egui::StrokeKind::Inside); - let px = x_at(pos); - painter.line_segment([pos2(px, r.min.y), pos2(px, r.max.y)], egui::Stroke::new(1.5, Color32::from_rgb(240, 240, 240))); - if (resp.clicked() || resp.dragged()) - && let Some(p) = resp.interact_pointer_pos() - { - locate = Some((((p.x - r.min.x) / r.width()).clamp(0.0, 1.0) * end as f32) as i64); - } - }); + // The Edit window's visible range and the playhead. + let spp = s.edit.zoom.samples_per_px.max(1e-6); + let vs = s.edit.zoom.scroll.max(0); + let ve = vs.saturating_add((spp * f64::from(ui.ctx().content_rect().width())) as i64); + let view = Rect::from_min_max(pos2(x_at(vs), r.min.y + 1.0), pos2(x_at(ve).min(r.max.x), r.max.y - 1.0)); + painter.rect_stroke(view, 0.0, egui::Stroke::new(1.0, Color32::from_rgb(230, 200, 80)), egui::StrokeKind::Inside); + let px = x_at(pos); + painter.line_segment([pos2(px, r.min.y), pos2(px, r.max.y)], egui::Stroke::new(1.5, Color32::from_rgb(240, 240, 240))); + if (resp.clicked() || resp.dragged()) + && let Some(p) = resp.interact_pointer_pos() + { + locate = Some((((p.x - r.min.x) / r.width()).clamp(0.0, 1.0) * end as f32) as i64); + } + }); if let Some(at) = locate { let _ = app.run("transport.locate", json!({"at": at})); let _ = app.run("edit.select", json!({"start": at, "end": at})); diff --git a/crates/ui-egui/src/panels/windows.rs b/crates/ui-egui/src/panels/windows.rs index df2db0c7..c52b82a9 100644 --- a/crates/ui-egui/src/panels/windows.rs +++ b/crates/ui-egui/src/panels/windows.rs @@ -30,34 +30,34 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { fn audio_health(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.ui.show_audio_health; win(ctx, &mut open, "Session Audio Health", vec2(620.0, 360.0), |ui| { - let refresh = ui.button("Refresh Report").clicked(); + let refresh = ui.button(crate::localization::text("Refresh Report")).clicked(); if app.audio_health_report.is_none() || refresh { app.audio_health_report = Some(app.engine.execute("session.audio_health", &json!({})).map_err(|error| error.to_string())); } let Some(result) = &app.audio_health_report else { return }; match result { Ok(report) => { - ui.label(format!("{} audio clips checked · {} issues", report["audio_clips"], report["issue_count"])); + ui.label(crate::localized_format!("{} audio clips checked · {} issues", report["audio_clips"], report["issue_count"])); ui.label(match report["active_audio_end_seconds"].as_f64() { - Some(seconds) => format!("Active audio ends at {seconds:.2} seconds"), - None => "Active audio end time is unknown (invalid session sample rate)".into(), + Some(seconds) => crate::localized_format!("Active audio ends at {seconds:.2} seconds", seconds = seconds), + None => crate::localization::text("Active audio end time is unknown (invalid session sample rate)").to_owned(), }); - ui.label("Includes alternate takes and muted clips. Refresh after editing."); + ui.label(crate::localization::text("Includes alternate takes and muted clips. Refresh after editing.")); ui.separator(); if report["healthy"] == true { - ui.label("All audio clips have loaded media within source bounds."); + ui.label(crate::localization::text("All audio clips have loaded media within source bounds.")); } egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| { if let Some(issues) = report["issues"].as_array() { for issue in issues { ui.group(|ui| { let text = |key: &str| issue[key].as_str().unwrap_or(""); - ui.label(format!( + ui.label(crate::localized_format!( "{} / {} / {}{}", text("track"), text("playlist"), text("clip"), - if issue["active"] == true { "" } else { " (alternate playlist)" } + if issue["active"] == true { "" } else { crate::localization::text(" (alternate playlist)") } )); ui.label(text("message")); if let Some(path) = issue["path"].as_str() { @@ -68,10 +68,10 @@ fn audio_health(app: &mut SoundApp, ctx: &egui::Context) { } }); ui.separator(); - ui.label("Checks loaded media only, not files on disk, signal levels, plugins or routing."); + ui.label(crate::localization::text("Checks loaded media only, not files on disk, signal levels, plugins or routing.")); } Err(error) => { - ui.label(error.to_string()); + ui.label(crate::localization::error_text(&error.to_string())); } } }); @@ -85,13 +85,15 @@ fn win(ctx: &egui::Context, open: &mut bool, title: &str, size: egui::Vec2, body if !*open { return; } - egui::Window::new(title).open(open).default_size(size).show(ctx, body); + // The title is translated for display, but the id keeps the English source so a language + // switch does not move or resize the window. + egui::Window::new(crate::localization::text(title)).id(egui::Id::unique(title)).open(open).default_size(size).show(ctx, body); } fn automation(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.ui.show_automation; win(ctx, &mut open, "Automation", vec2(260.0, 260.0), |ui| { - ui.label("Write automation for the selected tracks:"); + ui.label(crate::localization::text("Write automation for the selected tracks:")); let tracks = app.engine.session().edit.selected_tracks.clone(); ui.horizontal_wrapped(|ui| { for m in [ @@ -103,14 +105,14 @@ fn automation(app: &mut SoundApp, ctx: &egui::Context) { AutomationMode::Write, AutomationMode::Trim, ] { - if ui.button(m.label()).clicked() { + if ui.button(crate::localization::text(m.label())).clicked() { let ids: Vec = tracks.iter().map(|t| t.0).collect(); let _ = app.run("mix.automation_mode", json!({"tracks": ids, "mode": m.label()})); } } }); ui.separator(); - ui.label("Enabled parameters"); + ui.label(crate::localization::text("Enabled parameters")); for f in ["volume", "pan", "mute", "send level", "send pan", "send mute", "plugin"] { let id = format!("automation.enable.{}", f.replace(' ', "_")); let mut on = !app.engine.session().edit.flag(&format!("{id}.off")); @@ -119,10 +121,10 @@ fn automation(app: &mut SoundApp, ctx: &egui::Context) { } } ui.separator(); - if ui.button("Write to Current").clicked() { + if ui.button(crate::localization::text("Write to Current")).clicked() { let _ = app.run("automation.write_to_current", json!({})); } - if ui.button("Thin All").clicked() { + if ui.button(crate::localization::text("Thin All")).clicked() { let _ = app.run("automation.thin_all", json!({})); } }); @@ -132,7 +134,7 @@ fn automation(app: &mut SoundApp, ctx: &egui::Context) { fn color_palette(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.ui.show_color_palette; win(ctx, &mut open, "Color Palette", vec2(300.0, 140.0), |ui| { - ui.label("Apply to selected tracks (Shift: selected clips)"); + ui.label(crate::localization::text("Apply to selected tracks (Shift: selected clips)")); ui.horizontal_wrapped(|ui| { for (i, c) in soundcraft_model::TRACK_COLORS.iter().enumerate() { let (r, resp) = ui.allocate_exact_size(vec2(28.0, 28.0), Sense::click()); @@ -147,7 +149,9 @@ fn color_palette(app: &mut SoundApp, ctx: &egui::Context) { } }); ui.separator(); - ui.add(egui::Slider::new(&mut app.ui.track_tint, 0.0..=1.0).show_value(false).text("Track tint in the Edit window")); + ui.add( + egui::Slider::new(&mut app.ui.track_tint, 0.0..=1.0).show_value(false).text(crate::localization::text("Track tint in the Edit window")), + ); }); app.ui.show_color_palette = open; } @@ -157,11 +161,11 @@ fn disk_usage(app: &mut SoundApp, ctx: &egui::Context) { win(ctx, &mut open, "Disk Usage", vec2(360.0, 160.0), |ui| { let s = app.engine.session(); let bytes: u64 = s.sources.iter().map(|x| x.frames * u64::from(x.channels) * 4).sum(); - ui.label(format!("Session media: {} files, {:.1} MB in memory (32-bit float)", s.sources.len(), bytes as f64 / 1_048_576.0)); + ui.label(crate::localized_format!("Session media: {} files, {:.1} MB in memory (32-bit float)", s.sources.len(), bytes as f64 / 1_048_576.0)); let per_min = f64::from(s.sample_rate.hz()) * 60.0 * 3.0 / 1_048_576.0; - ui.label(format!("Recording at 24-bit uses {per_min:.1} MB per mono track-minute")); + ui.label(crate::localized_format!("Recording at 24-bit uses {per_min:.1} MB per mono track-minute", per_min = per_min)); if let Some(p) = &app.engine.path { - ui.label(format!("Session file: {p}")); + ui.label(crate::localized_format!("Session file: {p}", p = p)); } }); app.ui.show_disk_usage = open; @@ -170,12 +174,18 @@ fn disk_usage(app: &mut SoundApp, ctx: &egui::Context) { fn system_usage(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.ui.show_system_usage; win(ctx, &mut open, "System Usage", vec2(320.0, 140.0), |ui| { - ui.label(format!("UI frame time: {:.1} ms", app.frame_ms)); - ui.label(format!("Audio: {}", app.player.as_ref().map_or("no engine".to_string(), |p| format!("{} @ {} Hz", p.device_name, p.device_rate)))); + ui.label(crate::localized_format!("UI frame time: {:.1} ms", app.frame_ms)); + ui.label(crate::localized_format!( + "Audio: {}", + app.player.as_ref().map_or_else( + || crate::localization::text("No engine").to_owned(), + |p| crate::localized_format!("{} @ {} Hz", p.device_name, p.device_rate) + ) + )); let plugins: usize = app.engine.session().tracks.iter().map(|t| t.mixer.inserts.iter().flatten().count()).sum(); - ui.label(format!("Active plugin instances: {plugins}")); - ui.label(format!("Tracks: {}", app.engine.session().tracks.len())); - ui.label(format!("Undo steps: {}", app.engine.undo_history().len())); + ui.label(crate::localized_format!("Active plugin instances: {plugins}", plugins = plugins)); + ui.label(crate::localized_format!("Tracks: {}", app.engine.session().tracks.len())); + ui.label(crate::localized_format!("Undo steps: {}", app.engine.undo_history().len())); }); app.ui.show_system_usage = open; } @@ -185,15 +195,17 @@ fn task_manager(app: &mut SoundApp, ctx: &egui::Context) { win(ctx, &mut open, "Task Manager", vec2(320.0, 120.0), |ui| { match &app.bounce { Some(b) => { - ui.label(format!("Bouncing {} ({:.0}%)", b.path().display(), b.progress() * 100.0)); + ui.label(crate::localized_format!("Bouncing {} ({:.0}%)", b.path().display(), b.progress() * 100.0)); ui.add(egui::ProgressBar::new(b.progress())); } None => { - ui.label("No background tasks are running."); + ui.label(crate::localization::text("No background tasks are running.")); } } ui.label( - egui::RichText::new("Renders and AudioSuite processes run to completion before returning.").small().color(Tokens::current().text_dim), + egui::RichText::new(crate::localization::text("Renders and AudioSuite processes run to completion before returning.")) + .small() + .color(Tokens::current().text_dim), ); }); app.ui.show_task_manager = open; @@ -215,14 +227,14 @@ fn metadata(app: &mut SoundApp, ctx: &egui::Context) { ("Markers", s.markers.len().to_string()), ("Length", s.format_position(s.content_end(), soundcraft_time::TimeFormat::MinSecs)), ] { - ui.label(k); + ui.label(crate::localization::text(k)); ui.label(v); ui.end_row(); } }); ui.separator(); let mut c = s.comments.clone(); - ui.label("Session comments"); + ui.label(crate::localization::text("Session comments")); if ui.text_edit_multiline(&mut c).changed() { app.engine.session_mut().comments = c; } @@ -236,7 +248,7 @@ fn event_list(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.ui.show_event_list; win(ctx, &mut open, "MIDI Event List", vec2(420.0, 360.0), |ui| { let Some(cid) = crate::midi_editor::target_clip(app) else { - ui.label("Select a MIDI clip."); + ui.label(crate::localization::text("Select a MIDI clip.")); return; }; let notes = match app.engine.session().find_clip(cid).map(|(_, c)| c.content.clone()) { @@ -246,14 +258,14 @@ fn event_list(app: &mut SoundApp, ctx: &egui::Context) { egui::ScrollArea::vertical().show(ui, |ui| { egui::Grid::new("evl").num_columns(5).striped(true).show(ui, |ui| { for h in ["Start (ticks)", "Note", "Vel", "Length", ""] { - ui.label(egui::RichText::new(h).strong()); + ui.label(egui::RichText::new(crate::localization::text(h)).strong()); } ui.end_row(); for (i, n) in notes.iter().enumerate() { ui.label(egui::RichText::new(n.start.to_string()).font(mono(11.0))); ui.label(soundcraft_midi::note_name(n.pitch)); let mut v = i64::from(n.velocity); - if ui.add(egui::DragValue::new(&mut v).range(1..=127)).accessible_name("Note velocity").changed() { + if ui.add(egui::DragValue::new(&mut v).range(1..=127)).accessible_name(crate::localization::text("Note velocity")).changed() { let _ = app.engine.execute("midi.note_edit", &json!({"clip": cid.0, "index": i, "velocity": v})); } ui.label(n.length.to_string()); @@ -313,7 +325,10 @@ fn midi_keyboard(app: &mut SoundApp, ctx: &egui::Context) { let next = s.tempo.tick_to_samples(s.tempo.samples_to_ticks(at, s.sample_rate) + len, s.sample_rate); let _ = app.run("transport.locate", json!({"at": next})); } - ui.label(egui::RichText::new("Click keys to step-enter notes into the selected MIDI clip at the insertion point.").small()); + ui.label( + egui::RichText::new(crate::localization::text("Click keys to step-enter notes into the selected MIDI clip at the insertion point.")) + .small(), + ); }); app.ui.show_midi_keyboard = open; } @@ -323,57 +338,64 @@ fn workspace(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } - egui::Window::new("Workspace").open(&mut open).default_size(vec2(460.0, 420.0)).show(ctx, |ui| { - let dir = if app.ui.workspace_dir.is_empty() { std::env::var("HOME").unwrap_or_else(|_| ".".into()) } else { app.ui.workspace_dir.clone() }; - ui.horizontal(|ui| { - if ui.button("⬆").on_hover_text("Parent folder").clicked() - && let Some(p) = std::path::Path::new(&dir).parent() - { - app.ui.workspace_dir = p.to_string_lossy().into_owned(); - } - ui.label(egui::RichText::new(&dir).small()); - }); - ui.separator(); - // Names stay paths: a name that is not valid Unicode is shown lossily, and opening it says so. - let mut entries: Vec<(std::path::PathBuf, String, bool)> = std::fs::read_dir(&dir) - .map(|rd| { - rd.flatten() - .filter_map(|e| { - let path = e.path(); - let name = e.file_name().to_string_lossy().into_owned(); - if name.starts_with('.') { - return None; + egui::Window::new(crate::localization::text("Workspace")) + .id(egui::Id::unique("Workspace")) + .open(&mut open) + .default_size(vec2(460.0, 420.0)) + .show(ctx, |ui| { + let dir = + if app.ui.workspace_dir.is_empty() { std::env::var("HOME").unwrap_or_else(|_| ".".into()) } else { app.ui.workspace_dir.clone() }; + ui.horizontal(|ui| { + if ui.button(crate::localization::text("⬆")).on_hover_text(crate::localization::text("Parent folder")).clicked() + && let Some(p) = std::path::Path::new(&dir).parent() + { + app.ui.workspace_dir = p.to_string_lossy().into_owned(); + } + ui.label(egui::RichText::new(&dir).small()); + }); + ui.separator(); + // Names stay paths: a name that is not valid Unicode is shown lossily, and opening it says so. + let mut entries: Vec<(std::path::PathBuf, String, bool)> = std::fs::read_dir(&dir) + .map(|rd| { + rd.flatten() + .filter_map(|e| { + let path = e.path(); + let name = e.file_name().to_string_lossy().into_owned(); + if name.starts_with('.') { + return None; + } + let is_dir = e.file_type().is_ok_and(|t| t.is_dir()); + let ext = path.extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase(); + (is_dir + || craft_audio::DECODE_EXTENSIONS.contains(&ext.as_str()) + || ["mid", "midi", SESSION_EXTENSION].contains(&ext.as_str())) + .then_some((path, name, is_dir)) + }) + .collect() + }) + .unwrap_or_default(); + entries.sort_by(|a, b| b.2.cmp(&a.2).then(a.1.to_lowercase().cmp(&b.1.to_lowercase()))); + egui::ScrollArea::vertical().show(ui, |ui| { + for (path, name, is_dir) in entries.into_iter().take(2000) { + let label = if is_dir { format!("📁 {name}") } else { format!("🔊 {name}") }; + let r = ui.selectable_label(false, label); + if r.double_clicked() { + if is_dir { + // The folder is kept as text in the preferences. + match crate::dialogs::unicode(&path) { + Ok(p) => app.ui.workspace_dir = p.to_owned(), + Err(e) => app.ui.status = crate::localization::error_text(&e.to_string()), + } + } else { + crate::dialogs::open_path(app, &path); } - let is_dir = e.file_type().is_ok_and(|t| t.is_dir()); - let ext = path.extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase(); - (is_dir - || craft_audio::DECODE_EXTENSIONS.contains(&ext.as_str()) - || ["mid", "midi", SESSION_EXTENSION].contains(&ext.as_str())) - .then_some((path, name, is_dir)) - }) - .collect() - }) - .unwrap_or_default(); - entries.sort_by(|a, b| b.2.cmp(&a.2).then(a.1.to_lowercase().cmp(&b.1.to_lowercase()))); - egui::ScrollArea::vertical().show(ui, |ui| { - for (path, name, is_dir) in entries.into_iter().take(2000) { - let label = if is_dir { format!("📁 {name}") } else { format!("🔊 {name}") }; - let r = ui.selectable_label(false, label); - if r.double_clicked() { - if is_dir { - // The folder is kept as text in the preferences. - match crate::dialogs::unicode(&path) { - Ok(p) => app.ui.workspace_dir = p.to_owned(), - Err(e) => app.ui.status = e.to_string(), - } - } else { - crate::dialogs::open_path(app, &path); } } - } + }); + ui.label( + egui::RichText::new(crate::localization::text("Double-click to import audio/MIDI at the insertion point or open a session.")).small(), + ); }); - ui.label(egui::RichText::new("Double-click to import audio/MIDI at the insertion point or open a session.").small()); - }); app.ui.show_workspace = open; } @@ -382,7 +404,7 @@ fn workspace(app: &mut SoundApp, ctx: &egui::Context) { fn configurations(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.ui.show_configurations; win(ctx, &mut open, "Window Configurations", vec2(320.0, 240.0), |ui| { - if ui.button("New Configuration…").clicked() { + if ui.button(crate::localization::text("New Configuration…")).clicked() { let n = app.ui.configurations.len() + 1; let mut snap = app.ui.clone(); snap.configurations.clear(); @@ -398,7 +420,7 @@ fn configurations(app: &mut SoundApp, ctx: &egui::Context) { if ui.button(format!("{} {name}", i + 1)).clicked() && let Err(error) = recall_configuration(app, v) { - app.ui.status = format!("Window configuration could not be restored: {error}"); + app.ui.status = crate::localized_format!("Window configuration could not be restored: {error}", error = error); } if crate::widgets::close_button(ui, "Remove configuration").clicked() { app.ui.configurations.remove(i); @@ -418,6 +440,8 @@ pub fn recall_configuration(app: &mut SoundApp, saved: &Value) -> Result<(), Str crate::docking::validate(&st.docking).and_then(|()| crate::docking::validate_mix(&st.mix_docking))?; st.configurations = app.ui.configurations.clone(); st.theme = app.ui.theme; + // Language is a global preference like the theme: recalling a configuration keeps the current one. + st.language = app.ui.language; st.show_preferences = app.ui.show_preferences; st.preferences_page = app.ui.preferences_page; st.preferences_window_pos = app.ui.preferences_window_pos; @@ -458,27 +482,30 @@ fn chosen_device<'a>(devices: &'a [DeviceInfo], name: Option<&str>) -> Option<&' /// Device picker with a Default entry and channel counts, labelled for accessibility. fn device_combo(ui: &mut egui::Ui, id: &str, name: &str, value: &mut Option, devices: &[DeviceInfo]) { - let default = devices.iter().find(|d| d.is_default).map_or("none".to_string(), |d| d.name.clone()); - let shown = value.clone().unwrap_or_else(|| format!("Default ({default})")); + let default = devices.iter().find(|d| d.is_default).map_or_else(|| crate::localization::text("none").to_string(), |d| d.name.clone()); + let shown = value.clone().unwrap_or_else(|| crate::localized_format!("Default ({default})", default = default)); let combo = craft_ui::ComboBox::from_id_salt(id).width(300.0).selected_text(shown).show_ui(ui, |ui| { - ui.selectable_value(value, None, format!("Default ({default})")); + ui.selectable_value(value, None, crate::localized_format!("Default ({default})", default = default)); for d in devices { ui.selectable_value(value, Some(d.name.clone()), format!("{} ({} ch)", d.name, d.max_channels)); } }); - combo.response.accessible_name(name); + combo.response.accessible_name(crate::localization::text(name)); } /// Optional-number picker with a Device default entry and a unit, labelled for accessibility. fn number_combo(ui: &mut egui::Ui, id: &str, name: &str, value: &mut Option, options: &[u32], unit: &str) { - let shown = value.map_or("Device default".to_string(), |v| format!("{v} {unit}")); + let shown = value.map_or_else( + || crate::localization::text("Device default").to_string(), + |v| crate::localized_format!("{v} {unit}", v = v, unit = crate::localization::text(unit)), + ); let combo = craft_ui::ComboBox::from_id_salt(id).width(300.0).selected_text(shown).show_ui(ui, |ui| { - ui.selectable_value(value, None, "Device default"); + ui.selectable_value(value, None, crate::localization::text("Device default")); for v in options { - ui.selectable_value(value, Some(*v), format!("{v} {unit}")); + ui.selectable_value(value, Some(*v), crate::localized_format!("{v} {unit}", v = v, unit = crate::localization::text(unit))); } }); - combo.response.accessible_name(name); + combo.response.accessible_name(crate::localization::text(name)); } /// Setup › Playback Engine / Hardware: choose the audio system, devices, rate and buffer size. @@ -495,12 +522,12 @@ pub fn playback_engine(app: &mut SoundApp, ctx: &egui::Context) { win(ctx, &mut open, "Playback Engine", vec2(460.0, 360.0), |ui| { let t = Tokens::current(); egui::Grid::new("pe").num_columns(2).spacing(vec2(12.0, 6.0)).show(ui, |ui| { - let system_label = ui.label("Audio system"); + let system_label = ui.label(crate::localization::text("Audio system")); let def = systems.iter().find(|s| s.is_default).map_or("none".to_string(), |s| s.name.clone()); - let shown = draft.system.clone().unwrap_or_else(|| format!("Default ({def})")); + let shown = draft.system.clone().unwrap_or_else(|| crate::localized_format!("Default ({default})", default = def)); let system = craft_ui::ComboBox::from_id_salt("pe-system").width(300.0).selected_text(shown).show_ui(ui, |ui| { let before = draft.system.clone(); - ui.selectable_value(&mut draft.system, None, format!("Default ({def})")); + ui.selectable_value(&mut draft.system, None, crate::localized_format!("Default ({default})", default = def)); for s in systems.iter() { ui.selectable_value(&mut draft.system, Some(s.name.clone()), &s.name); } @@ -513,17 +540,17 @@ pub fn playback_engine(app: &mut SoundApp, ctx: &egui::Context) { system.response.labelled_by(system_label.id); ui.end_row(); let sys = chosen_system(&systems, &draft); - ui.label("Output device"); + ui.label(crate::localization::text("Output device")); device_combo(ui, "pe-out", "Output device", &mut draft.output, sys.map_or(&[][..], |s| &s.outputs)); ui.end_row(); - ui.label("Input device"); + ui.label(crate::localization::text("Input device")); device_combo(ui, "pe-in", "Input device", &mut draft.input, sys.map_or(&[][..], |s| &s.inputs)); ui.end_row(); let out = sys.and_then(|s| chosen_device(&s.outputs, draft.output.as_deref())); - ui.label("Sample rate"); + ui.label(crate::localization::text("Sample rate")); number_combo(ui, "pe-rate", "Sample rate", &mut draft.sample_rate, out.map_or(&[][..], |d| &d.sample_rates), "Hz"); ui.end_row(); - ui.label("Buffer size"); + ui.label(crate::localization::text("Buffer size")); // The combo lists standard power-of-two sizes. `setup.playback_engine` does not round // onto this list: it keeps any integer 16..=8192, the same as `ui.audio_device`. let buffers = out.map(DeviceInfo::buffer_sizes).unwrap_or_else(|| soundcraft_playback::devices::STANDARD_BUFFERS.to_vec()); @@ -532,50 +559,60 @@ pub fn playback_engine(app: &mut SoundApp, ctx: &egui::Context) { }); ui.add_space(4.0); ui.horizontal(|ui| { - if ui.button("Refresh devices").clicked() { + if ui.button(crate::localization::text("Refresh devices")).clicked() { refresh = true; } let changed = draft != app.ui.audio; - if ui.add_enabled(changed, egui::Button::new("Apply")).on_hover_text("Reopen the audio devices with these settings").clicked() { + if ui + .add_enabled(changed, egui::Button::new(crate::localization::text("Apply"))) + .on_hover_text(crate::localization::text("Reopen the audio devices with these settings")) + .clicked() + { apply = true; } - if changed && ui.button("Revert").clicked() { + if changed && ui.button(crate::localization::text("Revert")).clicked() { draft = app.ui.audio.clone(); } }); ui.separator(); egui::Grid::new("pe-state").num_columns(2).show(ui, |ui| { - ui.label("Output"); - ui.label(app.player.as_ref().map_or("none".to_string(), |p| { + ui.label(crate::localization::text("Output")); + ui.label(app.player.as_ref().map_or(crate::localization::text("none").to_string(), |p| { if p.silent { - "no device (silent clock)".to_string() + crate::localization::text("no device (silent clock)").to_string() } else { - let buf = p.device_buffer.map_or("default buffer".to_string(), |b| format!("{b} samples")); - format!("{} · {} Hz · {} ch · {buf}", p.device_name, p.device_rate, p.device_channels) + let buf = p + .device_buffer + .map_or(crate::localization::text("default buffer").to_string(), |b| crate::localized_format!("{} samples", b)); + crate::localized_format!("{} · {} Hz · {} ch · {}", p.device_name, p.device_rate, p.device_channels, buf) } })); ui.end_row(); - ui.label("Input"); - ui.label(app.recorder.as_ref().map_or("opened on first record or monitor".to_string(), |r| { - format!("{} · {} Hz · {} ch", r.device_name, r.sample_rate, r.channels) + ui.label(crate::localization::text("Input")); + ui.label(app.recorder.as_ref().map_or(crate::localization::text("opened on first record or monitor").to_string(), |r| { + crate::localized_format!("{} · {} Hz · {} ch", r.device_name, r.sample_rate, r.channels) })); ui.end_row(); - ui.label("Session rate"); + ui.label(crate::localization::text("Session rate")); let sr = app.engine.session().sample_rate.hz(); let note = app .player .as_ref() .filter(|p| !p.silent && p.device_rate != sr) - .map_or(String::new(), |_| " (resampled to the device rate)".to_string()); - ui.label(format!("{sr} Hz{note}")); + .map_or(String::new(), |_| crate::localization::text(" (resampled to the device rate)").to_string()); + ui.label(crate::localized_format!("{sr} Hz{note}", sr = sr, note = note)); ui.end_row(); }); - ui.label(egui::RichText::new("The mix runs in 512-sample blocks; the buffer size sets the device's own latency.").small().color(t.text_dim)); + ui.label( + egui::RichText::new(crate::localization::text("The mix runs in 512-sample blocks; the buffer size sets the device's own latency.")) + .small() + .color(t.text_dim), + ); let mut dc = app.engine.session().edit.delay_compensation; - if crate::widgets::checkbox(ui, &mut dc, "Delay compensation").changed() { + if crate::widgets::checkbox(ui, &mut dc, crate::localization::text("Delay compensation")).changed() { let _ = app.run("options.delay_compensation", json!({"value": dc})); } - if ui.button("Reconnect audio device").clicked() { + if ui.button(crate::localization::text("Reconnect audio device")).clicked() { app.reconnect_audio(); } }); @@ -683,46 +720,48 @@ pub fn setup_audio_command(app: &mut SoundApp, id: &str, p: &serde_json::Value) pub fn io_setup(app: &mut SoundApp, ctx: &egui::Context) { let mut open = app.ui.show_io_setup; win(ctx, &mut open, "I/O Setup", vec2(420.0, 300.0), |ui| { - ui.label(egui::RichText::new("Busses").strong()); + ui.label(egui::RichText::new(crate::localization::text("Busses")).strong()); let busses: Vec<(String, String)> = app.engine.session().busses.iter().map(|b| (b.name.clone(), b.format.label().to_string())).collect(); egui::Grid::new("busses").num_columns(3).striped(true).show(ui, |ui| { for (name, fmt) in busses { let key = egui::Id::unique(("bus_name", name.clone())); let mut edit: String = ui.ctx().memory(|m| m.data.get_temp(key)).unwrap_or_else(|| name.clone()); - let r = crate::widgets::named_text_field(ui.text_edit_singleline(&mut edit), &format!("Bus name: {name}")); + let r = + crate::widgets::named_text_field(ui.text_edit_singleline(&mut edit), &crate::localized_format!("Bus name: {name}", name = name)); ui.ctx().memory_mut(|m| m.data.insert_temp(key, edit.clone())); if r.lost_focus() && edit != name { let _ = app.run("setup.io", json!({"action": "rename_bus", "name": name, "new_name": edit})); } ui.label(fmt); - if ui.small_button("Delete").clicked() { + if ui.small_button(crate::localization::text("Delete")).clicked() { let _ = app.run("setup.io", json!({"action": "delete_bus", "name": name})); } ui.end_row(); } }); - if ui.button("New Bus").clicked() { + if ui.button(crate::localization::text("New Bus")).clicked() { let n = app.engine.session().busses.len() + 1; let _ = app.run("mix.new_bus", json!({"name": format!("Bus {n}")})); } ui.separator(); - ui.label(egui::RichText::new("Outputs").strong()); + ui.label(egui::RichText::new(crate::localization::text("Outputs")).strong()); // Main output format: stereo, or a surround format (the mix and master faders follow). let main = app.engine.session().main_format(); ui.horizontal(|ui| { - let main_label = ui.label("Main output"); - let format = craft_ui::ComboBox::from_id_salt("main_output_format").selected_text(main.label()).show_ui(ui, |ui| { - for f in soundcraft_model::ChannelFormat::ALL.into_iter().filter(|f| (2..=16).contains(&f.channels())) { - if ui.selectable_label(f == main, f.label()).clicked() && f != main { - let _ = app.run("setup.main_format", json!({"format": f.label()})); + let main_label = ui.label(crate::localization::text("Main output")); + let format = + craft_ui::ComboBox::from_id_salt("main_output_format").selected_text(crate::localization::text(main.label())).show_ui(ui, |ui| { + for f in soundcraft_model::ChannelFormat::ALL.into_iter().filter(|f| (2..=16).contains(&f.channels())) { + if ui.selectable_label(f == main, crate::localization::text(f.label())).clicked() && f != main { + let _ = app.run("setup.main_format", json!({"format": f.label()})); + } } - } - }); + }); format.response.labelled_by(main_label.id); - ui.label(egui::RichText::new(format!("{} ch", main.channels())).small()); + ui.label(egui::RichText::new(crate::localized_format!("{n} ch", n = main.channels())).small()); }); for o in app.engine.session().outputs.clone() { - ui.label(format!("{} — {} from channel {}", o.name, o.format.label(), o.first_channel + 1)); + ui.label(crate::localized_format!("{} — {} from channel {}", o.name, o.format.label(), o.first_channel + 1)); } }); app.ui.show_io_setup = open; @@ -739,8 +778,9 @@ pub fn shortcuts_window(app: &mut SoundApp, ctx: &egui::Context) { let windows = crate::menus::UI_COMMANDS.iter().map(|c| (c.3, c.1, c.2.replace(" > ", " › "))); for (shortcut, label, menu) in engine.chain(windows) { let Some(shortcut) = shortcut else { continue }; - ui.label(egui::RichText::new(crate::shortcuts::shortcut_label(shortcut, mac)).font(mono(11.0))); - ui.label(label); + ui.label(egui::RichText::new(crate::shortcuts::display_shortcut(shortcut, mac)).font(mono(11.0))); + ui.label(crate::localization::text(label)); + let menu = menu.split(" › ").map(crate::localization::text).collect::>().join(" › "); ui.label(egui::RichText::new(menu).small()); ui.end_row(); } @@ -764,20 +804,20 @@ pub fn clip_effects(app: &mut SoundApp, ctx: &egui::Context) { .map(|c| c.id) }); let Some(cid) = clip else { - ui.label("Select an audio clip."); + ui.label(crate::localization::text("Select an audio clip.")); return; }; let name = app.engine.session().find_clip(cid).map(|(_, c)| c.name.clone()).unwrap_or_default(); let bypass = app.engine.session().edit.flag(&format!("clip_fx.bypass.{}", cid.0)); ui.horizontal(|ui| { ui.label(egui::RichText::new(&name).strong()); - if ui.selectable_label(bypass, "Bypass").clicked() { + if ui.selectable_label(bypass, crate::localization::text("Bypass")).clicked() { let _ = app.run("clip.effects_bypass", json!({"clips": [cid.0]})); } - if ui.button("Render").clicked() { + if ui.button(crate::localization::text("Render")).clicked() { let _ = app.run("clip.effects_render", json!({"clips": [cid.0]})); } - if ui.button("Clear").clicked() { + if ui.button(crate::localization::text("Clear")).clicked() { let _ = app.run("edit.clear_clip_effects", json!({"clips": [cid.0]})); } }); @@ -813,7 +853,10 @@ pub fn clip_effects(app: &mut SoundApp, ctx: &egui::Context) { let mut g = get(app, "gain", 0.0); let before = g; let mut wide = f64::from(g); - crate::widgets::FineSlider::new(&mut wide, -36.0..=24.0).text("Clip effects gain (dB)").default_value(0.0).show(ui); + crate::widgets::FineSlider::new(&mut wide, -36.0..=24.0) + .text(crate::localization::text("Clip effects gain (dB)")) + .default_value(0.0) + .show(ui); g = wide as f32; if (g - before).abs() > f32::EPSILON { let _ = diff --git a/crates/ui-egui/src/preferences.rs b/crates/ui-egui/src/preferences.rs index a7ce36c2..7f47d7a4 100644 --- a/crates/ui-egui/src/preferences.rs +++ b/crates/ui-egui/src/preferences.rs @@ -209,12 +209,18 @@ impl Control { /// Builds the searchable text from a control's label, value and available choices. fn search_text(self) -> String { + let both = bilingual; match self { - Self::Choice(label, value) | Self::Value(label, value) => format!("{label} {value}"), - Self::ChoiceOptions(label, value, values) => format!("{label} {value} {}", values.join(" ")), - Self::Radios(label, values) => format!("{label} {}", values.join(" ")), - Self::ReduceVisualEffects => format!("{} Never Only During Playback Always", self.label()), - _ => self.label().to_string(), + Self::Choice(label, value) | Self::Value(label, value) => format!("{} {}", both(label), both(value)), + Self::ChoiceOptions(label, value, values) => { + format!("{} {} {}", both(label), both(value), values.iter().map(|value| both(value)).collect::>().join(" ")) + } + Self::Radios(label, values) => format!("{} {}", both(label), values.iter().map(|value| both(value)).collect::>().join(" ")), + Self::ReduceVisualEffects => { + let modes = ReduceVisualEffects::ALL.map(|mode| both(mode.label())).join(" "); + format!("{} {modes}", both(self.label())) + } + _ => both(self.label()), } } } @@ -728,7 +734,7 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { ui.allocate_exact_size(screen.size(), egui::Sense::click_and_drag()); }); - let mut window = egui::Window::new("SoundCraft Preferences") + let mut window = egui::Window::new(crate::localization::text("SoundCraft Preferences")) .id(egui::Id::unique("preferences_window")) .open(&mut open) .order(egui::Order::Foreground) @@ -743,13 +749,13 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { ui.horizontal(|ui| { let (icon_rect, _) = ui.allocate_exact_size(vec2(18.0, 18.0), egui::Sense::hover()); crate::icons::draw(ui.painter(), icon_rect.shrink(1.0), "zoom", Tokens::current().text_dim); - let search_label = ui.label("Search"); + let search_label = ui.label(crate::localization::text("Search")); let edit = egui::TextEdit::singleline(&mut search) .id(egui::Id::unique("preferences_search")) - .hint_text("Type to search preferences") + .hint_text(crate::localization::text("Type to search preferences")) .desired_width(f32::INFINITY); ui.add(edit).labelled_by(search_label.id); - if !search.is_empty() && ui.small_button("Clear").clicked() { + if !search.is_empty() && ui.small_button(crate::localization::text("Clear")).clicked() { search.clear(); } }); @@ -777,10 +783,10 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { ui.separator(); ui.horizontal(|ui| { ui.add_space(ui.available_width() - 176.0); - if ui.add_sized([80.0, 24.0], egui::Button::new("Cancel")).clicked() { + if ui.add_sized([80.0, 24.0], egui::Button::new(crate::localization::text("Cancel"))).clicked() { action = Some(Action::Cancel); } - if ui.add_sized([80.0, 24.0], egui::Button::new("OK").fill(Tokens::current().accent_dark)).clicked() { + if ui.add_sized([80.0, 24.0], egui::Button::new(crate::localization::text("OK")).fill(Tokens::current().accent_dark)).clicked() { action = Some(Action::Apply); } }); @@ -836,8 +842,11 @@ fn tabs(ui: &mut egui::Ui, page: &mut PreferencesPage, search: &str) { ui.horizontal(|ui| { for candidate in PreferencesPage::ALL { let hit = page_matches(candidate, search); - let text = - if !search.is_empty() && hit { RichText::new(candidate.label()).color(t.meter_yellow) } else { RichText::new(candidate.label()) }; + let text = if !search.is_empty() && hit { + RichText::new(crate::localization::text(candidate.label())).color(t.meter_yellow) + } else { + RichText::new(crate::localization::text(candidate.label())) + }; if ui.selectable_label(*page == candidate, text).clicked() { *page = candidate; } @@ -889,15 +898,15 @@ fn section_ui(ui: &mut egui::Ui, page: PreferencesPage, section: Section, search /// Draws a section's title and border, including search-match highlighting. fn section_frame(ui: &mut egui::Ui, section: Section, search: &str, add_contents: impl FnOnce(&mut egui::Ui)) { let t = Tokens::current(); - let section_hit = text_matches(section.title, search); + let section_hit = text_matches(&bilingual(section.title), search); let stroke = if !search.is_empty() && section_hit { Stroke::new(1.5, t.meter_yellow) } else { Stroke::new(1.0, t.border) }; egui::Frame::new().fill(t.panel_bg2).stroke(stroke).corner_radius(3.0).inner_margin(egui::Margin::same(6)).show(ui, |ui| { ui.set_min_width((ui.available_width() - 12.0).max(280.0)); egui::Frame::new().fill(t.toolbar_group).inner_margin(egui::Margin::symmetric(6, 3)).show(ui, |ui| { let title = if !search.is_empty() && section_hit { - RichText::new(section.title).strong().color(t.meter_yellow) + RichText::new(crate::localization::text(section.title)).strong().color(t.meter_yellow) } else { - RichText::new(section.title).strong() + RichText::new(crate::localization::text(section.title)).strong() }; ui.label(title); }); @@ -926,23 +935,26 @@ fn control_ui(ui: &mut egui::Ui, page: PreferencesPage, section: &str, index: us let t = Tokens::current(); let hit = text_matches(&control.search_text(), search); let label = |text: &'static str| { + let text = crate::localization::text(text); if !search.is_empty() && hit { RichText::new(text).color(t.meter_yellow) } else { RichText::new(text) } }; let id = ("preference", page, section, index); match control { Control::Theme => { - craft_ui::ComboBox::new(id, label("UI Theme")).selected_text(draft.theme.label()).show_ui(ui, |ui| { + craft_ui::ComboBox::new(id, label("UI Theme")).selected_text(crate::localization::text(draft.theme.label())).show_ui(ui, |ui| { for mode in ThemeMode::ALL { - ui.selectable_value(&mut draft.theme, mode, mode.label()); + ui.selectable_value(&mut draft.theme, mode, crate::localization::text(mode.label())); } }); } Control::ReduceVisualEffects => { - craft_ui::ComboBox::new(id, label("Reduce Visual Effects")).selected_text(draft.reduce_visual_effects.label()).show_ui(ui, |ui| { - for mode in ReduceVisualEffects::ALL { - ui.selectable_value(&mut draft.reduce_visual_effects, mode, mode.label()); - } - }); + craft_ui::ComboBox::new(id, label("Reduce Visual Effects")) + .selected_text(crate::localization::text(draft.reduce_visual_effects.label())) + .show_ui(ui, |ui| { + for mode in ReduceVisualEffects::ALL { + ui.selectable_value(&mut draft.reduce_visual_effects, mode, crate::localization::text(mode.label())); + } + }); } Control::UndoLevels => { ui.horizontal(|ui| { @@ -952,28 +964,30 @@ fn control_ui(ui: &mut egui::Ui, page: PreferencesPage, section: &str, index: us } Control::Check(text) => { let mut value = false; - ui.add_enabled(false, egui::Checkbox::new(&mut value, label(text))).on_disabled_hover_text("This preference is not available yet."); + ui.add_enabled(false, egui::Checkbox::new(&mut value, label(text))) + .on_disabled_hover_text(crate::localization::text("This preference is not available yet.")); } Control::Choice(text, value) | Control::ChoiceOptions(text, value, _) => { ui.add_enabled_ui(false, |ui| { - craft_ui::ComboBox::new(id, label(text)).selected_text(value).show_ui(ui, |_| {}); + craft_ui::ComboBox::new(id, label(text)).selected_text(crate::localization::text(value)).show_ui(ui, |_| {}); }) .response - .on_disabled_hover_text("This preference is not available yet."); + .on_disabled_hover_text(crate::localization::text("This preference is not available yet.")); } Control::Value(text, value) => { ui.add_enabled_ui(false, |ui| { ui.horizontal(|ui| { let caption = ui.label(label(text)); - let mut shown = value.to_string(); + let mut shown = crate::localization::text(value).to_string(); ui.add(egui::TextEdit::singleline(&mut shown).desired_width(96.0)).labelled_by(caption.id); }); }) .response - .on_disabled_hover_text("This preference is not available yet."); + .on_disabled_hover_text(crate::localization::text("This preference is not available yet.")); } Control::Button(text) => { - ui.add_enabled(false, egui::Button::new(label(text))).on_disabled_hover_text("This preference is not available yet."); + ui.add_enabled(false, egui::Button::new(label(text))) + .on_disabled_hover_text(crate::localization::text("This preference is not available yet.")); } Control::Radios(text, values) => { ui.add_enabled_ui(false, |ui| { @@ -981,12 +995,12 @@ fn control_ui(ui: &mut egui::Ui, page: PreferencesPage, section: &str, index: us let mut selected = 0usize; ui.indent(id, |ui| { for (value_index, value) in values.iter().enumerate() { - ui.radio_value(&mut selected, value_index, *value); + ui.radio_value(&mut selected, value_index, crate::localization::text(value)); } }); }) .response - .on_disabled_hover_text("This preference is not available yet."); + .on_disabled_hover_text(crate::localization::text("This preference is not available yet.")); } } } @@ -1015,12 +1029,19 @@ fn page_modifiers(modifiers: Modifiers, mac: bool) -> bool { /// Reports whether a page title, section or control matches the search terms. fn page_matches(page: PreferencesPage, search: &str) -> bool { - text_matches(page.label(), search) + text_matches(&bilingual(page.label()), search) || page.sections().iter().any(|section| { - text_matches(section.title, search) || section.controls.iter().copied().any(|control| text_matches(&control.search_text(), search)) + text_matches(&bilingual(section.title), search) + || section.controls.iter().copied().any(|control| text_matches(&control.search_text(), search)) }) } +/// A source string followed by its translation, so a search finds either language. +fn bilingual(source: &str) -> String { + let translated = crate::localization::text(source); + if translated == source { source.to_owned() } else { format!("{source} {translated}") } +} + /// Performs a case-insensitive AND match over whitespace-separated search terms. fn text_matches(text: &str, search: &str) -> bool { let search = search.trim(); @@ -1038,6 +1059,50 @@ mod tests { use egui_kittest::kittest::{NodeT, Queryable}; use soundcraft_engine::Engine; + /// Whether a preference value is a plain number or unit amount that needs no translation. + fn is_numeric(value: &str) -> bool { + value.chars().next().is_none_or(|c| c.is_ascii_digit() || matches!(c, '−' | '-' | '—' | '.' | ' ' | '|')) + } + + #[test] + fn every_preference_text_has_a_portuguese_translation() { + let mut missing = Vec::new(); + let mut check = |text: &str| { + if !is_numeric(text) && !crate::localization::has_pt_br_entry(text) { + missing.push(text.to_owned()); + } + }; + for page in PreferencesPage::ALL { + check(page.label()); + for section in page.sections() { + check(section.title); + for control in section.controls { + check(control.label()); + match *control { + Control::Choice(_, value) | Control::Value(_, value) => check(value), + Control::ChoiceOptions(_, value, values) => { + check(value); + values.iter().for_each(|v| check(v)); + } + Control::Radios(_, values) => values.iter().for_each(|v| check(v)), + _ => {} + } + } + } + } + // Names that are the same in both languages are listed by the catalog as identity entries. + assert!(missing.is_empty(), "preference texts without a pt-BR entry: {missing:?}"); + } + + #[test] + fn preference_search_matches_both_languages() { + let _scope = crate::localization::enter(crate::localization::Language::PortugueseBrazil); + let control = Control::Check("Auto Backup"); + assert!(text_matches(&control.search_text(), crate::localization::Language::PortugueseBrazil.text("Auto Backup"))); + assert!(text_matches(&control.search_text(), "auto backup")); + assert!(!text_matches(&control.search_text(), "mixagem")); + } + /// Creates a complete application harness with Preferences already open. fn preferences_harness(size: egui::Vec2) -> Harness<'static, SoundApp> { let mut app = SoundApp::new(Engine::default(), None, crate::Services::default()); diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs index c92c8094..eb044b9c 100644 --- a/crates/ui-egui/src/shortcuts.rs +++ b/crates/ui-egui/src/shortcuts.rs @@ -475,6 +475,20 @@ pub fn shortcut_label(s: &str, mac: bool) -> String { s.split('+').map(|p| if p == "Cmd" { "Ctrl" } else { p }).collect::>().join("+") } +/// The label shown for a shortcut: the key names are translated, so "Space" can read as the +/// local name of that key. +pub fn display_shortcut(s: &str, mac: bool) -> String { + shortcut_label(s, mac) + .split('+') + .map(|part| { + let key = format!("key:{part}"); + let translated = crate::localization::text(&key); + if translated == key { part.to_owned() } else { translated.to_owned() } + }) + .collect::>() + .join("+") +} + /// Mac Control chords that `fixed` also maps to Ctrl off macOS. const PC_CTRL_CHORDS: [&str; 4] = ["Ctrl+Up", "Ctrl+Down", "Ctrl+Shift+Up", "Ctrl+Shift+Down"]; diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs index 6590716f..60914472 100644 --- a/crates/ui-egui/src/theme.rs +++ b/crates/ui-egui/src/theme.rs @@ -547,9 +547,12 @@ mod tests { fn dark_is_the_default() { assert_eq!(ThemeMode::default(), ThemeMode::Dark); assert_eq!(UiState::default().theme, ThemeMode::Dark); + assert_eq!(UiState::default().language, crate::localization::Language::English); // Prefs saved before the setting existed load as Dark. - let old: UiState = serde_json::from_value(json!({"show_tracks_list": true})).unwrap_or_default(); + let old: UiState = serde_json::from_value(json!({"show_tracks_list": false})).unwrap(); assert_eq!(old.theme, ThemeMode::Dark); + assert_eq!(old.language, crate::localization::Language::English); + assert!(!old.show_tracks_list); } #[test] @@ -582,6 +585,32 @@ mod tests { assert!(crate::menus::UI_COMMANDS.iter().any(|c| c.0 == "ui.theme")); } + #[test] + fn language_command_sets_reports_and_validates_the_language() { + let mut app = SoundApp::new(soundcraft_engine::Engine::default(), None, Services::default()); + assert_eq!(app.run("ui.language", json!({})), Ok(json!({"language": "en"}))); + assert_eq!(app.run("ui.language", json!({"language": "pt-BR"})), Ok(json!({"language": "pt-BR"}))); + assert_eq!(app.ui.language, crate::localization::Language::PortugueseBrazil); + assert!(app.run("ui.language", json!({"language": "fr"})).is_err()); + assert_eq!(app.ui.language, crate::localization::Language::PortugueseBrazil); + assert!(crate::menus::UI_COMMANDS.iter().any(|command| command.0 == "ui.language")); + } + + #[test] + fn language_survives_state_round_trip_and_configuration_recall() { + let mut app = SoundApp::new(soundcraft_engine::Engine::default(), None, Services::default()); + let _ = app.run("ui.language", json!({"language": "pt-BR"})); + let saved = serde_json::to_value(&app.ui).unwrap_or_default(); + assert_eq!(saved["language"], "pt-BR"); + let restored: crate::UiState = serde_json::from_value(saved.clone()).unwrap_or_default(); + assert_eq!(restored.language, crate::localization::Language::PortugueseBrazil); + // Language is a global preference like the theme: a saved configuration never changes it. + let mut snapshot = saved; + snapshot["language"] = json!("en"); + assert_eq!(crate::panels::windows::recall_configuration(&mut app, &snapshot), Ok(())); + assert_eq!(app.ui.language, crate::localization::Language::PortugueseBrazil); + } + #[test] fn application_frames_follow_system_appearance_and_preserve_manual_palettes() { // Mixer rendering tests also change the process-wide custom-painted palette. diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs index 17c9a1b3..545c984c 100644 --- a/crates/ui-egui/src/toolbar.rs +++ b/crates/ui-egui/src/toolbar.rs @@ -51,10 +51,13 @@ struct ModeCellState { fn edit_mode_tooltip(m: EditMode, locked: bool, cmd: &str, fkey: &str) -> String { match m { - EditMode::Shuffle if locked => format!("Shuffle is locked ({cmd}-click to unlock)"), - EditMode::Shuffle => format!("Shuffle mode ({fkey}); {cmd}-click locks it out"), - EditMode::Grid => format!("Grid mode ({fkey}; again for Relative); Shift-click: Snap to Grid in the other modes"), - _ => format!("{} mode ({fkey}); Shift-click adds Snap to Grid", if m == EditMode::Slip { "Slip" } else { "Spot" }), + EditMode::Shuffle if locked => crate::localized_format!("Shuffle is locked ({cmd}-click to unlock)", cmd = cmd), + EditMode::Shuffle => crate::localized_format!("Shuffle mode ({fkey}); {cmd}-click locks it out", fkey = fkey, cmd = cmd), + EditMode::Grid => { + crate::localized_format!("Grid mode ({fkey}; again for Relative); Shift-click: Snap to Grid in the other modes", fkey = fkey) + } + EditMode::Slip => crate::localized_format!("Slip mode ({fkey}); Shift-click adds Snap to Grid", fkey = fkey), + _ => crate::localized_format!("Spot mode ({fkey}); Shift-click adds Snap to Grid", fkey = fkey), } } @@ -72,7 +75,7 @@ fn draw_mode_cell(p: &egui::Painter, cell: Rect, resp: &egui::Response, t: &Toke icons::draw(p, Rect::from_center_size(cell.center(), vec2(15.0, 15.0)), "lock", fg); } else { let txt = if m == EditMode::Grid && state.cur == EditMode::GridRelative { "REL GRID" } else { label }; - p.text(cell.center(), Align2::CENTER_CENTER, txt, bold(10.5), fg); + p.text(cell.center(), Align2::CENTER_CENTER, crate::localization::text(txt), bold(10.5), fg); } } @@ -88,8 +91,12 @@ fn edit_modes(app: &mut SoundApp, ui: &mut Ui) { (EditMode::Slip, 0, 1, "SLIP", "F2"), (EditMode::Grid, 1, 1, "GRID", "F4"), ]; - let widest = - modes.iter().map(|m| m.3).chain(["REL GRID"]).map(|l| ui.painter().layout_no_wrap(l.into(), bold(10.5), t.text).size().x).fold(0.0, f32::max); + let widest = modes + .iter() + .map(|m| m.3) + .chain(["REL GRID"]) + .map(|l| ui.painter().layout_no_wrap(crate::localization::text(l).into(), bold(10.5), t.text).size().x) + .fold(0.0, f32::max); group(ui, 2.0 * widest + 44.0, 52.0, |ui, r| { let inner = r.shrink(6.0); let cw = inner.width() / 2.0; @@ -156,7 +163,7 @@ fn zoom_group(app: &mut SoundApp, ui: &mut Ui) { &i.to_string(), false, Color32::GRAY, - "Zoom preset (click to recall, Cmd-click to store)", + crate::localization::text("Zoom preset (click to recall, Cmd-click to store)"), ); if r.clicked() { let store = ui.input(|x| x.modifiers.command); @@ -189,7 +196,7 @@ fn tools(app: &mut SoundApp, ui: &mut Ui) { (Tool::Pencil, "pencil"), ] { let smart_member = cur == Tool::Smart && matches!(tool, Tool::Trim | Tool::Selector | Tool::Grabber); - let tip = format!("{}{}", tool.label(), tool.fkey().map(|k| format!(" ({k})")).unwrap_or_default()); + let tip = format!("{}{}", crate::localization::text(tool.label()), tool.fkey().map(|k| format!(" ({k})")).unwrap_or_default()); if icon_button(ui, vec2(36.0, 26.0), icon, cur == tool || smart_member, &tip).clicked() { let _ = app.run("edit.tool", json!({"tool": tool.id()})); } @@ -202,7 +209,7 @@ fn tools(app: &mut SoundApp, ui: &mut Ui) { let bracket = Rect::from_min_max(pos2(bx0 - 2.0, r.min.y + 1.0), pos2(bx1 + 2.0, r.min.y + 5.0)); let resp = ui.interact(bracket.expand2(vec2(0.0, 2.0)), ui.scope_id().with("smart"), Sense::click()); ui.painter().rect_filled(bracket, 1.0, if cur == Tool::Smart { t.accent } else { t.tool_bracket_off }); - if resp.on_hover_text("Smart Tool (F6+F7 / F7+F8)").clicked() { + if resp.on_hover_text(crate::localization::text("Smart Tool (F6+F7 / F7+F8)")).clicked() { let _ = app.run("edit.tool", json!({"tool": "smart"})); } ui.horizontal(|ui| { @@ -214,7 +221,15 @@ fn tools(app: &mut SoundApp, ui: &mut Ui) { } } let focus = e.keyboard_focus == "commands"; - if crate::widgets::text_toggle(ui, vec2(36.0, 18.0), "a-z", focus, t.accent, "Commands Keyboard Focus (single-key editing)").clicked() + if crate::widgets::text_toggle( + ui, + vec2(36.0, 18.0), + "a-z", + focus, + t.accent, + crate::localization::text("Commands Keyboard Focus (single-key editing)"), + ) + .clicked() { let _ = app.run("options.keyboard_focus", json!({})); } @@ -265,13 +280,13 @@ fn counters(app: &mut SoundApp, ui: &mut Ui) { ]; for (i, (label, val)) in rows.iter().enumerate() { let y = r.min.y + 10.0 + i as f32 * 13.0; - ui.painter().text(pos2(r.min.x + 214.0, y), Align2::RIGHT_CENTER, *label, regular(11.0), t.counter_label); + ui.painter().text(pos2(r.min.x + 214.0, y), Align2::RIGHT_CENTER, crate::localization::text(label), regular(11.0), t.counter_label); ui.painter().text(pos2(r.max.x - 8.0, y), Align2::RIGHT_CENTER, val, mono(11.0), t.counter_text); } // Sub counter row. let y = r.max.y - 11.0; ui.painter().line_segment([pos2(r.min.x + 6.0, r.max.y - 21.0), pos2(r.max.x - 6.0, r.max.y - 21.0)], Stroke::new(1.0, t.counter_rule)); - ui.painter().text(pos2(r.min.x + 10.0, y), Align2::LEFT_CENTER, "Sub", regular(11.0), t.counter_label); + ui.painter().text(pos2(r.min.x + 10.0, y), Align2::LEFT_CENTER, crate::localization::text("Sub"), regular(11.0), t.counter_label); ui.painter().text(pos2(r.min.x + 150.0, y), Align2::RIGHT_CENTER, fmt_pos(app, pos, sub_fmt), mono(11.0), t.counter_text); let sub_r = Rect::from_min_max(pos2(r.min.x + 6.0, r.max.y - 20.0), pos2(r.min.x + 164.0, r.max.y - 2.0)); let sub_resp = ui.interact(sub_r, ui.scope_id().with("sub_counter"), Sense::click()); @@ -279,7 +294,13 @@ fn counters(app: &mut SoundApp, ui: &mut Ui) { format_menu(app, &sub_resp, sub_fmt, "view.sub_counter"); let st = if app.engine.is_dirty() { "modified" } else { "saved" }; let dev = app.player.as_ref().map_or("no audio engine", |p| if p.silent { "silent clock" } else { "audio on" }); - ui.painter().text(pos2(r.max.x - 8.0, y), Align2::RIGHT_CENTER, format!("{st} · {dev}"), regular(10.0), t.text_dim); + ui.painter().text( + pos2(r.max.x - 8.0, y), + Align2::RIGHT_CENTER, + format!("{} · {}", crate::localization::text(st), crate::localization::text(dev)), + regular(10.0), + t.text_dim, + ); } /// A counter's time-format menu: picking a format runs `command` (`view.main_counter` or @@ -287,7 +308,7 @@ fn counters(app: &mut SoundApp, ui: &mut Ui) { fn format_menu(app: &mut SoundApp, resp: &egui::Response, current: TimeFormat, command: &str) { egui::Popup::menu(resp).show(|ui| { for f in TimeFormat::ALL { - if ui.selectable_label(current == f, f.label()).clicked() { + if ui.selectable_label(current == f, crate::localization::text(f.label())).clicked() { let _ = app.run(command, json!({"format": f.id()})); } } @@ -306,8 +327,14 @@ fn grid_nudge(app: &mut SoundApp, ui: &mut Ui) { let gl = Rect::from_min_size(pos2(r.min.x + 6.0, r.min.y + 8.0), vec2(48.0, 16.0)); let resp = ui.interact(gl, ui.scope_id().with("grid_lines"), Sense::click()); key(ui.painter(), gl, &resp, if lines { t.mode_on } else { t.counter_off }); - ui.painter().text(gl.center(), Align2::CENTER_CENTER, "Grid", bold(11.0), if lines { t.mode_on_text } else { t.mode_off_text }); - if resp.on_hover_text("Show grid lines").clicked() { + ui.painter().text( + gl.center(), + Align2::CENTER_CENTER, + crate::localization::text("Grid"), + bold(11.0), + if lines { t.mode_on_text } else { t.mode_off_text }, + ); + if resp.on_hover_text(crate::localization::text("Show grid lines")).clicked() { let _ = app.run("view.grid_lines", json!({})); } let gr = Rect::from_min_max(pos2(r.min.x + 60.0, r.min.y + 6.0), pos2(r.max.x - 4.0, r.min.y + 26.0)); @@ -315,10 +342,10 @@ fn grid_nudge(app: &mut SoundApp, ui: &mut Ui) { if !clips_markers { draw_compact_note_icon(ui.painter(), gr, grid, t.counter_text); } - ui.painter().text(pos2(gr.max.x - 14.0, gr.center().y), Align2::RIGHT_CENTER, grid_label, mono(11.0), t.counter_text); + ui.painter().text(pos2(gr.max.x - 14.0, gr.center().y), Align2::RIGHT_CENTER, crate::localization::text(&grid_label), mono(11.0), t.counter_text); let gresp = ui.interact(gr, ui.scope_id().with("grid_value"), Sense::click()); value_menu(app, &gresp, "view.grid", grid, grid_follow, clips_markers, true); - ui.painter().text(pos2(r.min.x + 10.0, r.min.y + 44.0), Align2::LEFT_CENTER, "Nudge", regular(11.0), t.counter_label); + ui.painter().text(pos2(r.min.x + 10.0, r.min.y + 44.0), Align2::LEFT_CENTER, crate::localization::text("Nudge"), regular(11.0), t.counter_label); let nr = Rect::from_min_max(pos2(r.min.x + 60.0, r.min.y + 34.0), pos2(r.max.x - 4.0, r.min.y + 54.0)); draw_compact_note_icon(ui.painter(), nr, nudge, t.counter_text); ui.painter().text( @@ -508,17 +535,17 @@ fn value_menu(app: &mut SoundApp, resp: &egui::Response, cmd: &str, current: Gri ui.separator(); for scale in GridScale::TIME { let selected = !clips_markers && current.scale() == scale; - if ui.selectable_label(selected, scale.label()).clicked() { + if ui.selectable_label(selected, crate::localization::text(scale.label())).clicked() { let _ = app.run(cmd, json!({"format": scale.id(), "follow_main": false})); ui.close(); } } - if allow_clips && ui.selectable_label(clips_markers, GridScale::ClipsMarkers.label()).clicked() { + if allow_clips && ui.selectable_label(clips_markers, crate::localization::text(GridScale::ClipsMarkers.label())).clicked() { let _ = app.run(cmd, json!({"format": GridScale::ClipsMarkers.id(), "follow_main": false})); ui.close(); } ui.separator(); - if ui.selectable_label(follow_main, "Follow Main Time Scale").clicked() { + if ui.selectable_label(follow_main, crate::localization::text("Follow Main Time Scale")).clicked() { let _ = app.run(cmd, json!({"follow_main": !follow_main})); ui.close(); } @@ -527,7 +554,7 @@ fn value_menu(app: &mut SoundApp, resp: &egui::Response, cmd: &str, current: Gri /// Adds one text menu value and dispatches its command when selected. fn menu_value(ui: &mut Ui, app: &mut SoundApp, cmd: &str, selected: bool, label: &str, value: serde_json::Value) { - if ui.selectable_label(selected, label).clicked() { + if ui.selectable_label(selected, crate::localization::text(label)).clicked() { let _ = app.run(cmd, json!({"value": value})); ui.close(); } @@ -567,20 +594,20 @@ fn transport(app: &mut SoundApp, ui: &mut Ui) { let (r, resp) = ui.allocate_exact_size(vec2(38.0, 28.0), Sense::click()); key(ui.painter(), r, &resp, key_fill(&resp)); icons::draw(ui.painter(), r.shrink(5.0), "stop", if playing { t.text } else { t.accent }); - if resp.on_hover_text("Stop (Space)").clicked() { + if resp.on_hover_text(crate::localization::text("Stop (Space)")).clicked() { let _ = app.run("transport.stop", json!({})); } let (r, resp) = ui.allocate_exact_size(vec2(38.0, 28.0), Sense::click()); key(ui.painter(), r, &resp, if playing { Color32::from_rgb(40, 90, 50) } else { key_fill(&resp) }); icons::draw(ui.painter(), r.shrink(5.0), "play", if playing { Color32::from_rgb(120, 255, 140) } else { t.counter_text }); - if resp.on_hover_text("Play (Space)").clicked() { + if resp.on_hover_text(crate::localization::text("Play (Space)")).clicked() { let _ = app.run("transport.play", json!({})); } let (r, resp) = ui.allocate_exact_size(vec2(38.0, 28.0), Sense::click()); key(ui.painter(), r, &resp, if recording { Color32::from_rgb(110, 30, 30) } else { key_fill(&resp) }); icons::draw(ui.painter(), r.shrink(5.0), "record", t.rec); // macOS gives Cmd+Space to Spotlight unless the user frees it, so name F12 first. - let resp = resp.on_hover_text("Record (F12 or Cmd+Space)"); + let resp = resp.on_hover_text(crate::localization::text("Record (F12 or Cmd+Space)")); if let Some(why) = app.record_hint() { // Below the whole group, so the hint covers none of its buttons. let below = Rect::from_min_max(r.min, pos2(r.max.x, g.max.y)); @@ -621,19 +648,31 @@ fn tempo_meter(app: &mut SoundApp, ui: &mut Ui) { let co = Rect::from_min_size(pos2(r.min.x + 6.0, r.min.y + 6.0), vec2(64.0, 15.0)); let resp = ui.interact(co, ui.scope_id().with("countoff"), Sense::click()); key(ui.painter(), co, &resp, if countoff { t.mode_on } else { t.counter_off }); - ui.painter().text(co.center(), Align2::CENTER_CENTER, "Count Off", bold(10.0), if countoff { t.mode_on_text } else { t.mode_off_text }); + ui.painter().text( + co.center(), + Align2::CENTER_CENTER, + crate::localization::text("Count Off"), + bold(10.0), + if countoff { t.mode_on_text } else { t.mode_off_text }, + ); if resp.clicked() { let _ = app.run("options.countoff", json!({})); } - ui.painter().text(pos2(r.max.x - 8.0, co.center().y), Align2::RIGHT_CENTER, format!("{bars} bars"), mono(11.0), t.counter_text); - ui.painter().text(pos2(r.min.x + 70.0, r.min.y + 32.0), Align2::RIGHT_CENTER, "Meter", regular(11.0), t.counter_label); + ui.painter().text( + pos2(r.max.x - 8.0, co.center().y), + Align2::RIGHT_CENTER, + crate::localized_format!("{bars} bars", bars = bars), + mono(11.0), + t.counter_text, + ); + ui.painter().text(pos2(r.min.x + 70.0, r.min.y + 32.0), Align2::RIGHT_CENTER, crate::localization::text("Meter"), regular(11.0), t.counter_label); ui.painter().text(pos2(r.max.x - 8.0, r.min.y + 32.0), Align2::RIGHT_CENTER, meter, mono(11.0), t.counter_text); - ui.painter().text(pos2(r.min.x + 70.0, r.min.y + 48.0), Align2::RIGHT_CENTER, "Tempo", regular(11.0), t.counter_label); + ui.painter().text(pos2(r.min.x + 70.0, r.min.y + 48.0), Align2::RIGHT_CENTER, crate::localization::text("Tempo"), regular(11.0), t.counter_label); icons::draw(ui.painter(), Rect::from_center_size(pos2(r.min.x + 82.0, r.min.y + 48.0), vec2(13.0, 13.0)), "note", t.counter_text); tempo_value(app, ui, r.max.x - 8.0, r.min.y + 48.0, bpm); let clk = Rect::from_min_size(pos2(r.min.x + 6.0, r.min.y + 40.0), vec2(18.0, 18.0)); icons::draw(ui.painter(), clk, "click", if click { t.counter_text } else { t.text_dim }); - if ui.interact(clk, ui.scope_id().with("click"), Sense::click()).on_hover_text("Click").clicked() { + if ui.interact(clk, ui.scope_id().with("click"), Sense::click()).on_hover_text(crate::localization::text("Click")).clicked() { let _ = app.run("options.click", json!({})); } } @@ -654,8 +693,9 @@ fn tempo_value(app: &mut SoundApp, ui: &mut Ui, right: f32, y: f32, bpm: f64) { } v.widgets.hovered.bg_stroke = Stroke::new(1.0, t.counter_border); let mut value = bpm; - let resp = - c.add_sized(rect.size(), egui::DragValue::new(&mut value).speed(0.1).range(5.0..=1000.0).fixed_decimals(4)).accessible_name("Tempo (BPM)"); + let resp = c + .add_sized(rect.size(), egui::DragValue::new(&mut value).speed(0.1).range(5.0..=1000.0).fixed_decimals(4)) + .accessible_name(crate::localization::text("Tempo (BPM)")); if resp.changed() { let s = app.engine.session(); let tick = s.tempo.samples_to_ticks(app.position(), s.sample_rate); @@ -666,7 +706,7 @@ fn tempo_value(app: &mut SoundApp, ui: &mut Ui, right: f32, y: f32, bpm: f64) { if resp.drag_stopped() || resp.lost_focus() { app.engine.end_merge(); } - resp.on_hover_text("Drag to change the tempo (Shift: fine steps), or click to type it"); + resp.on_hover_text(crate::localization::text("Drag to change the tempo (Shift: fine steps), or click to type it")); } /// Draws the compact stereo main-output meter. diff --git a/crates/ui-egui/src/updates_ui.rs b/crates/ui-egui/src/updates_ui.rs index 821ad596..7e7fa462 100644 --- a/crates/ui-egui/src/updates_ui.rs +++ b/crates/ui-egui/src/updates_ui.rs @@ -115,13 +115,14 @@ pub(crate) fn show(app: &mut SoundApp, ctx: &egui::Context) { #[cfg(target_arch = "wasm32")] if app.updates_rt.manual_window_open { let mut open = true; - egui::Window::new("Check for Updates") + egui::Window::new(crate::localization::text("Check for Updates")) + .id(egui::Id::unique("Check for Updates")) .open(&mut open) .resizable(false) .collapsible(false) .anchor(egui::Align2::CENTER_CENTER, egui::vec2(0.0, 0.0)) .show(ctx, |ui| { - ui.label("Update check is not supported in the web browser."); + ui.label(crate::localization::text("Update check is not supported in the web browser.")); }); app.updates_rt.manual_window_open = open; } diff --git a/crates/ui-egui/src/video_track.rs b/crates/ui-egui/src/video_track.rs index 0b7c2282..7b818edc 100644 --- a/crates/ui-egui/src/video_track.rs +++ b/crates/ui-egui/src/video_track.rs @@ -452,20 +452,44 @@ pub fn draw_lane(app: &mut SoundApp, painter: &Painter, s: &Session, track: &Tra } let p = painter.with_clip_rect(vis); let Some(v) = s.video(source) else { - p.text(vis.center(), egui::Align2::CENTER_CENTER, "movie missing from session", regular(10.0), Color32::from_rgb(220, 120, 120)); + p.text( + vis.center(), + egui::Align2::CENTER_CENTER, + crate::localization::text("movie missing from session"), + regular(10.0), + Color32::from_rgb(220, 120, 120), + ); break 'thumbs; }; if !on { - p.text(vis.center(), egui::Align2::CENTER_CENTER, "Video Track Offline", regular(10.0), Color32::from_gray(170)); + p.text( + vis.center(), + egui::Align2::CENTER_CENTER, + crate::localization::text("Video Track Offline"), + regular(10.0), + Color32::from_gray(170), + ); break 'thumbs; } if let Some(why) = &v.offline { - p.text(vis.center(), egui::Align2::CENTER_CENTER, format!("media offline: {why}"), regular(10.0), Color32::from_rgb(220, 120, 120)); + p.text( + vis.center(), + egui::Align2::CENTER_CENTER, + crate::localized_format!("media offline: {why}", why = crate::localization::text(why)), + regular(10.0), + Color32::from_rgb(220, 120, 120), + ); break 'thumbs; } let key = MovieKey::new(source, &v.path); if let Some(Err(e)) = app.video.info(key) { - p.text(vis.center(), egui::Align2::CENTER_CENTER, format!("media offline: {e}"), regular(10.0), Color32::from_rgb(220, 120, 120)); + p.text( + vis.center(), + egui::Align2::CENTER_CENTER, + crate::localized_format!("media offline: {e}", e = crate::localization::text(e)), + regular(10.0), + Color32::from_rgb(220, 120, 120), + ); break 'thumbs; } let aspect = app.video.info(key).and_then(|i| i.as_ref().ok()).map_or(v.aspect(), MovieInfo::display_aspect) as f32; diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs index ceadf074..cef5c572 100644 --- a/crates/ui-egui/src/widgets.rs +++ b/crates/ui-egui/src/widgets.rs @@ -118,6 +118,7 @@ pub(crate) fn named_text_field(resp: egui::Response, name: &str) -> egui::Respon /// A toolbar button with an icon; `on` draws the blue selected state. pub fn icon_button(ui: &mut Ui, size: egui::Vec2, icon: &str, on: bool, tip: &str) -> Response { let t = Tokens::current(); + let tip = crate::localization::text(tip); let style = button_style(t.accent, t.text, 3); let resp = IconButton::new(tip, size, &style).selected(on).single_shape_frame().show(ui, |ui, r, tint| { key_light(ui.painter(), r.shrink(1.0)); @@ -134,6 +135,7 @@ pub fn icon_button(ui: &mut Ui, size: egui::Vec2, icon: &str, on: bool, tip: &st /// the accessible name and the tooltip. pub fn close_button(ui: &mut Ui, label: &str) -> Response { let t = Tokens::current(); + let label = crate::localization::text(label); let size = Vec2::splat(ui.spacing().interact_size.y.max(14.0)); let style = IconButtonStyle { normal: ButtonVisuals { fill: Color32::TRANSPARENT, stroke: Stroke::NONE, icon: t.text_dim }, @@ -204,12 +206,15 @@ pub(crate) struct SelectorLabels<'a> { /// published separately in the accessibility tree. pub(crate) fn selector_box_named(ui: &mut Ui, width: f32, height: f32, text: &str, color: Color32, labels: SelectorLabels<'_>) -> Response { let t = Tokens::current(); + // `text` and `value` can be user-defined route or group names (a bus called "Read"), so they + // are shown unchanged. Callers pass every label already translated. + let SelectorLabels { name, value, tooltip } = labels; let (r, resp) = ui.allocate_exact_size(vec2(width, height), Sense::click()); // The compact visible text can be an abbreviation ("t/l"); the full meaning on hover is the // accessible name, not the tooltip. `current_text_value` tells a screen reader the selection. resp.widget_info(|| { - let mut info = egui::WidgetInfo::labeled(egui::Role::ComboBox, ui.is_enabled(), labels.name); - info.current_text_value = Some(labels.value.to_string()); + let mut info = egui::WidgetInfo::labeled(egui::Role::ComboBox, ui.is_enabled(), name); + info.current_text_value = Some(value.to_string()); info }); key(ui.painter(), r, &resp, key_fill(&resp)); @@ -223,7 +228,7 @@ pub(crate) fn selector_box_named(ui: &mut Ui, width: f32, height: f32, text: &st let galley = ui.painter().layout_job(job); let pos = text_rect.center() - galley.size() * 0.5; ui.painter().with_clip_rect(r.shrink(1.0)).galley(pos, galley, color); - resp.on_hover_text(labels.tooltip) + resp.on_hover_text(tooltip) } /// Rotary knob for pan / send pan (-1..1). Drag vertically; double-click resets. @@ -675,7 +680,7 @@ pub fn surround_panner(ui: &mut Ui, size: f32, speakers: &[PannerSpeaker], puck: painter.circle(pp, 5.0 + div * half, Color32::from_rgba_unmultiplied(80, 160, 230, 28), Stroke::new(1.0, Color32::from_rgb(70, 130, 190))); } painter.circle(pp, 5.0, t.counter_text, Stroke::new(1.0, Color32::BLACK)); - let tip = "Surround pan: drag the puck · double-click: front centre · Alt-drag: divergence"; + let tip = crate::localization::text("Surround pan: drag the puck · double-click: front centre · Alt-drag: divergence"); let _ = resp.on_hover_text(tip); // Sliders below: divergence, then elevation for height formats. let mut sliders: Vec<(&str, f32, u8)> = vec![("div", div, 0)]; @@ -701,7 +706,8 @@ pub fn surround_panner(ui: &mut Ui, size: f32, speakers: &[PannerSpeaker], puck: if sresp.double_clicked() { edit = Some(if kind == 0 { PannerEdit::Divergence(0.0) } else { PannerEdit::Height(0.0) }); } - let _ = sresp.on_hover_text(if kind == 0 { "Divergence (0 = point source)" } else { "Elevation (height speakers)" }); + let _ = + sresp.on_hover_text(crate::localization::text(if kind == 0 { "Divergence (0 = point source)" } else { "Elevation (height speakers)" })); } edit } diff --git a/docs/gaps.md b/docs/gaps.md index 25d5f8e2..51a56cee 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -1,6 +1,6 @@ # Where SoundCraft falls short of Pro Tools -> **Last reviewed:** 2026-10-25 · **Last updated:** 2026-11-04 · **Change:** trivial (G-04: volume automation read at every sample, #1354; previously trivial: G-01: `setup.playback_engine` applies the device buffer in the desktop app; G-04: Clip Looping crossfade and loop count) · **Target:** Avid Pro Tools Ultimate 2026.4.1 +> **Last reviewed:** 2026-10-25 · **Last updated:** 2026-11-13 · **Change:** trivial (G-09: the pt-BR catalog now covers helper-passed tooltips, the status bar, the remove-session prompt and engine error text; previously trivial: G-04: volume automation read at every sample, #1354; G-01: `setup.playback_engine` applies the device buffer in the desktop app; G-04: Clip Looping crossfade and loop count) · **Target:** Avid Pro Tools Ultimate 2026.4.1 Every known shortfall, one entry each, ranked by how much it stops a Pro Tools user from doing real work in SoundCraft. This is the work list: pick from the top. Rows marked **alpha blocker** @@ -23,7 +23,7 @@ When you close a gap, delete its entry (or shrink it) in the same PR, and bump t | G-06 | (Record-to-disk part: alpha blocker for the tracking row) Sources decoded whole into RAM; recording into RAM | Performance | [hardware-parity.md](hardware-parity.md) | 15–25 | | G-07 | Nothing is compared against Pro Tools' output (no fidelity harness) | Features | this file | 20–30 | | G-08 | Built-in plugin catalogue thin and unverified | Features | [plugin-parity.md](plugin-parity.md) | 80–120 | -| G-09 | English only, no string catalog, no CJK/RTL rendering | Localization | [localization-parity.md](localization-parity.md) | 70–110 | +| G-09 | English-first UI with a pt-BR catalog (not native-reviewed); all fixed UI strings covered, no CJK/RTL rendering | Localization | [localization-parity.md](localization-parity.md) | 20–40 | | G-10 | No control surfaces (HUI/MCU, EUCON) | Hardware | [hardware-parity.md](hardware-parity.md) | 40–70 | | G-11 | No external sync (MTC, LTC, MIDI clock, video reference) | Hardware | [hardware-parity.md](hardware-parity.md) | 15–25 | | G-12 | Immersive delivery: no Dolby Atmos/ADM BWF, MPEG-H, binaural | Features | [file-format-parity.md](file-format-parity.md) | 50–80 | @@ -154,8 +154,14 @@ parametric request #139. ≈ 80–120 h. ### G-09. Localization -See [`localization-parity.md`](localization-parity.md): no catalog, every string literal in code; -egui has no complex-script shaping or RTL; no CJK font fallback (PR #141 open). ≈ 70–110 h plus +See [`localization-parity.md`](localization-parity.md): a pt-BR catalog covers the menu labels and +every fixed UI string passed to `text` / `localized_format!` or localized inside a button, toggle or +close button (test-checked), including the Edit-window status bar, the remove-session question and +the send help text; engine errors are matched against catalog templates at display time by +`error_text`. What remains is independent native-speaker review plus egui's lack of complex-script +shaping and RTL, and the missing other Pro Tools languages; values built at run time (file, track +and device names) and engine command parameter documentation stay untranslated. egui has no +complex-script shaping or RTL; no CJK font fallback (PR #141 open). ≈ 70–110 h plus native-speaker review. ### G-10. Control surfaces @@ -232,6 +238,7 @@ missing. Out of scope unless the owner decides otherwise. | Date | Change | Summary | |---|---|---| +| 2026-11-13 | trivial | G-09: the pt-BR catalog now covers tooltips localized inside buttons and toggles, the Edit-window status bar, the remove-session question, the send help text and engine errors shown in the status line; estimates unchanged | | 2026-11-04 | trivial | G-04: track and master volume automation read at every sample, so breakpoints act on their own sample in any block size (#1354); estimates unchanged | | 2026-10-25 | trivial | G-04: Clip Looping (#1030) lacks the loop crossfade option, and Number of Loops stops at 512 while length and fill make up to 1000 loops | | 2026-10-25 | trivial | G-01: `setup.playback_engine` and `setup.hardware` apply the device and buffer in the desktop app; headless returns `applied: false` | diff --git a/docs/localization-parity.md b/docs/localization-parity.md index fe832d40..7b846d0b 100644 --- a/docs/localization-parity.md +++ b/docs/localization-parity.md @@ -1,11 +1,18 @@ # Localization parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** major (first per-language status) · **Target:** Avid Pro Tools Ultimate 2026.4.1 +> **Last reviewed:** 2026-11-13 · **Last updated:** 2026-11-13 · **Change:** minor (pt-BR catalog completed: all fixed UI strings translated and covered by tests; native-speaker review, CJK/RTL font fallbacks and RTL script shaping still pending) · **Target:** Avid Pro Tools Ultimate 2026.4.1 -SoundCraft is English only. There is no string catalog: every menu label, dialog and tooltip is a -literal in Rust (`crates/engine/src/cmd/*`, `crates/ui-egui/src/*`). Pro Tools ships its UI in -**8 languages** (bundle `.lproj` folders: English, German, Spanish, French, Japanese, Korean, -Simplified Chinese, Traditional Chinese). +SoundCraft defaults to English and supports selecting Brazilian Portuguese. The pt-BR catalog +covers all fixed UI strings found in the current source: command labels, menus, Appearance, +About/Credits, Audio Health, Playback Engine, System Usage, Workspace, plugin parameter and display +names, dialogs and buttons, tooltips (including those localized inside buttons and toggles), +accessibility names, the Edit-window status bar, the remove-session question and formatted +messages. Engine errors are matched against catalog templates at display time by +`localization::error_text`. Values built at run time (file, track and device names), engine command +parameter documentation and third-party plugin names stay as they are, and the catalog has not been +independently or native-speaker reviewed. Pro Tools ships its UI in **8 languages** (bundle +`.lproj` folders: English, German, Spanish, French, Japanese, Korean, Simplified Chinese, +Traditional Chinese). **Localization: ~12 %** (measured: 1 of the target's 8 UI languages, and English is the only one complete). Remaining ≈ 70–110 h: a catalog and extraction pass (≈ 15–25 h), a font fallback for @@ -13,8 +20,8 @@ CJK/Devanagari/Arabic (PR #141 open), RTL layout and complex-script shaping (egu ≈ 25–40 h, or ship Arabic/Hindi menus-only), then ≈ 3–5 h of agent translation per language, plus native-speaker review (human). -Open work: PR #143 (French and Spanish, a Language setting), PR #141 (bundled multilingual font -fallbacks), issue #67 (Ukrainian). +Open work: PR #143 (French and Spanish, a +Language setting), PR #141 (bundled multilingual font fallbacks), issue #67 (Ukrainian). | Language | Code | UI strings translated | Dialogs / tooltips / help | Script support | Native review | Status | Est. to full (h) | In Pro Tools | |---|---|---|---|---|---|---|---:|---| @@ -24,7 +31,7 @@ fallbacks), issue #67 (Ukrainian). | Hindi | hi | 0 (0 %) | ❌ | ❌ no Devanagari font or shaping | no | none | 8–15 | ❌ | | Arabic | ar | 0 (0 %) | ❌ | ❌ no RTL layout, no shaping | no | none | 15–25 | ❌ | | French | fr | 0 (0 %) — PR #143 pending | ❌ | Latin ✅ | no | none | 3–5 | ✅ | -| Portuguese | pt | 0 (0 %) | ❌ | Latin ✅ | no | none | 3–5 | ❌ | +|| Portuguese (Brazil) | pt-BR | ✅ 100 % of fixed UI strings: menus, dialogs, buttons, tooltips, accessibility names, status bar, formatted messages and engine errors; catalog tests pass | 🟡 partial | Latin ✅ | no (native review pending) | full | 0–4 | ❌ | | Indonesian | id | 0 (0 %) | ❌ | Latin ✅ | no | none | 3–5 | ❌ | | Japanese | ja | 0 (0 %) | ❌ | ❌ no CJK font fallback, no IME testing | no | none | 6–10 | ✅ | | German | de | 0 (0 %) | ❌ | Latin ✅ | no | none | 3–5 | ✅ | @@ -35,8 +42,21 @@ Other languages shipped: **0**. (Pro Tools also ships Traditional Chinese, zh-Ha Per-language hours exclude the shared catalog and script work above. +## Usage + +- Pick the language in Appearance ▸ Language, or run the `ui.language` command with + `{"language": "pt-BR"}` (or `"en"`); with no parameter it reports the current language. + Example: `soundcraft-cli run --demo --cmd 'ui.language={"language":"pt-BR"}'`. +- The choice is a global preference saved with the UI state (like the theme); recalling a saved + window configuration does not change it. +- Strings missing from the catalog fall back to English. Add one with a `"English text" => "translated text"` + arm in `crates/ui-egui/locales/pt-BR/mod.rs`; tests check placeholder parity, duplicates and that every + string passed to `text` / `localized_format!` has an entry. + ## Revision history | Date | Change | Summary | |---|---|---| +| 2026-11-13 | minor | Completed the pt-BR catalog: tooltips passed to buttons and toggles, `Not available yet.`, the send hover help, `no instrument`, the search placeholders, the Edit-window status bar (bit depth, track count, undo, ms/frame), the remove-session question and the transport/sample-rate readouts; engine errors now reach the status line through `error_text` | +| 2026-11-05 | minor | Added persisted language selection, the `ui.language` command, English fallback and a pt-BR catalog (menus, dialogs, tooltips, accessibility text, formatted messages); added a Usage section and catalog tests | | 2026-10-10 | major | Created: English only, no catalog; the twelve key languages at 0 %; Pro Tools' 8 languages listed from its bundle | diff --git a/docs/roadmap.md b/docs/roadmap.md index 2e7eeeeb..c74d50bc 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -1,6 +1,6 @@ # SoundCraft roadmap: milestones and what's next -> **Last reviewed:** 2026-10-25 · **Last updated:** 2026-10-25 · **Change:** trivial (`setup.playback_engine` applies the device buffer in the desktop app) · **Target:** Avid Pro Tools Ultimate 2026.4.1 +> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-05 · **Change:** trivial (M15: partial pt-BR catalog in PR #1346) · **Target:** Avid Pro Tools Ultimate 2026.4.1 Forward-looking plan. Status and numbers: [`../ROADMAP.md`](../ROADMAP.md) and [`target-app-parity.md`](target-app-parity.md); the ranked work list: [`gaps.md`](gaps.md). @@ -49,7 +49,7 @@ Status: ✅ done · 🟡 in progress · ⬜ not started. | M12 | **Hardware**: audio interfaces, MIDI devices, sync, control surfaces | ⬜ | 110–180 | | M13 | **Interchange**: AAF/OMF import/export, disk streaming, record to disk | ⬜ | 65–115 | | M14 | **Fidelity harness** against Pro Tools (null tests, plugin responses) | ⬜ | 20–30 | -| M15 | **Localization**: catalog, fonts/RTL, the 8 Pro Tools languages first | ⬜ (PRs #141, #143 open) | 70–110 | +| M15 | **Localization**: catalog, fonts/RTL, the 8 Pro Tools languages first | 🟡 partial (pt-BR catalog; needs native review; PRs #141, #143 open) | 45–80 | | M16 | Built-in plugin depth, sidechain, ARA | ⬜ | 110–170 | | M17 | Immersive delivery (ADM BWF, object renderer, binaural) and video depth | ⬜ | 80–130 | @@ -88,6 +88,7 @@ There is no `cargo xtask scorecard` in this repo; the measured number is `cargo | Date | Change | Summary | |---|---|---| +| 2026-11-05 | trivial | M15: a pt-BR catalog covers menus and `text`/`localized_format!` strings; remains native review, CJK/RTL and the other languages. Estimates unchanged | | 2026-10-25 | trivial | Record-workflow evidence: `setup.playback_engine` applies the device and buffer in the desktop app; headless returns `applied: false` | | 2026-10-24 | trivial | 27 built-in processors, as the plugin registry holds; the sampler (#108) is no longer listed under plugin essentials | | 2026-10-14 | trivial | M8: reject oversized MCP batches before execution (#460) | diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 2992d93e..7b4cb690 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1,6 +1,6 @@ # Target-app parity: SoundCraft vs Avid Pro Tools -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-24 · **Change:** trivial (built-in plugin counts; the sampler shipped; previously minor: hours to ~95 % for each audience; full number confirmed as an additive weighted sum) · **Target:** Avid Pro Tools Ultimate 2026.4.1 (bundle 26.4.1.179, macOS) +> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-05 · **Change:** trivial (G-09/localization: pt-BR catalog; percentages unchanged) · **Target:** Avid Pro Tools Ultimate 2026.4.1 (bundle 26.4.1.179, macOS) The authoritative assessment of how close SoundCraft is to Pro Tools. [`ROADMAP.md`](../ROADMAP.md) summarizes it, [`gaps.md`](gaps.md) itemizes every shortfall, and the per-dimension docs go deeper: @@ -87,7 +87,7 @@ post-production, tracking) can switch. "Ready" is depth, correctness and fidelit | Performance | 5 % | **~35 %** | estimated (unmeasured) | 40–70 | [hardware-parity.md](hardware-parity.md) | Parallel strip rendering and PDC exist; whole files decoded into RAM, recording into RAM (#84 open), no track-count or latency benchmarks | | Ecosystem / plugins | 4 % | **~30 %** | estimated | in Features + Hardware | [plugin-parity.md](plugin-parity.md) | CLAP/VST3/AU hosting; no AAX (Pro Tools' only format), no ARA, no sidechain, no control-surface ecosystem, no content library | | Platforms | 3 % | **~65 %** | estimated | 20–40 | [ROADMAP.md](../ROADMAP.md) | Builds for macOS, Windows x64/x86/arm64, Linux, FreeBSD, Web (Pro Tools: macOS, Windows), but only macOS is exercised at runtime; Web lacks file pickers (#63, #64) | -| Localization | 2 % | **~12 %** | measured (catalog count) | 70–110 | [localization-parity.md](localization-parity.md) | English only, no string catalog; Pro Tools ships 8 UI languages; FR/ES PR #143 open | +| Localization | 2 % | **~12 %** | measured (catalog count) | 70–110 | [localization-parity.md](localization-parity.md) | English plus a pt-BR catalog (not native-reviewed); Pro Tools ships 8 UI languages; FR/ES PR #143 open | | AI features | 1 % | **~5 %** | estimated | 30–50 | [gaps.md](gaps.md) | Pro Tools has speech-to-text transcription (upgraded in 2026.4); we have only an audio-to-MIDI pitch tracker | | **Weighted** | 100 % | **~40 %** | | **~950–1,450** (overlaps removed) | | | @@ -245,6 +245,7 @@ serializes more, because it needs hands-on testing. | Date | Change | Summary | |---|---|---| +| 2026-11-05 | trivial | Localization row: English plus a near-complete pt-BR catalog for fixed UI strings (PR #1346), not native-reviewed. Percentages and hours unchanged | | 2026-10-24 | trivial | Built-in plugin counts: 27 processors + 3 instruments on `main`, and 24 + 2 in the 3bc2d92 code snapshot; the sampler (#108) is no longer listed as missing. Percentages unchanged | | 2026-10-10 | minor | Readiness-by-audience table: hours to ~95 % for full (950–1,450 h), mainstream (380–600 h) and essentials (110–200 h). The full number is already the additive weighted sum over the written dimension table (40.6 %); method unchanged | | 2026-10-10 | minor | Added the mainstream-practitioner (~36 %) and essentials-user (~57 %) numbers with written weights, discounts and user evidence. Checked the full ~40 %: it is the written dimension weights × values (40.6 %), so it doesn't move |