Skip to content

armgit / nota

Public Imported from GitHub
0

Nota — a free DAW for macOS, Windows and Linux. No subscription, no account — just open it and make music.

(refactor) Look interface texts up by stable keys (#476) (#479)

Egor Khindikaynen31c2efdac4f6
diff --git a/.gitignore b/.gitignore
index 3a7e17fe..590f1551 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,6 @@ dist/
src/managed/Nota.Remote/wwwroot/
.netcoredbg_hist
+
+# spec 077 migration working file (scripts/loc-migrate.py --plan)
+keymap.tsv
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 25d5f151..42776a8c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -119,30 +119,50 @@ Give it the issue number up front; don't override that check.
## Translating Nota
-The desktop app's interface is translated through one mechanism (spec
-[068](specs/068-ui-language/)): the English text in the code is the key, and each language is one
-JSON file, `src/managed/Nota.App/Languages/<code>.json`, embedded in the app. English needs no
-file of strings; French is `fr.json`.
-
-- **Every new user-visible text goes through `Loc`.** Write `Loc.T("Save")` for a text,
- `Loc.F("Delete {0} clips?", n)` for a text with values (the whole sentence is the key, never
- a piece of it) and `Loc.Plural(n, "{0} clip", "{0} clips")` for a counted text; in XAML write
- `{app:T 'Save'}`. The smoke test fails on a new plain literal that reads as interface text, and
- on a `Loc` text that French does not cover. Text that is not translated on purpose — user
- content, device and parameter names, proper nouns, units, logs, the Remote web page and MCP
- — is listed with its reason as `# data:` in `tests/Nota.SmokeTest/LocalizationAllowList.txt`.
-- **Add a language**: copy `fr.json` to `<code>.json` (two lowercase letters), set `code` and
- `name` (the language's own name, shown in Preferences → Appearance → Language), translate
- the strings you can and delete the rest — anything missing shows in English. Plural rules
- live in `UiLanguage.Plural`; a language without a rule counts like English. Also list the code in
- `CFBundleLocalizations` of `scripts/bundle-mac.sh` and `scripts/package-dmg.sh` (the smoke test checks it), so
- macOS shows its own text — Hide, Quit, the open panels — in that language too. The file format
- is in [specs/068-ui-language/contracts/translation-file.md](specs/068-ui-language/contracts/translation-file.md).
-- **Translate or fix a string**: edit its value in the language file. Keep the placeholders
- (`{0}`, `{1}`) and give a counted text both forms (`one`, `other`; French counts 0 and 1 as
- one). Follow the glossary in [specs/068-ui-language/glossary.md](specs/068-ui-language/glossary.md)
- (infinitive for actions, sentence case, a narrow no-break space before `:` `;` `?` `!`).
- Device and parameter names stay in English.
+The desktop app's interface is translated through one mechanism (specs
+[068](specs/068-ui-language/) and [077](specs/077-key-based-localization/)): every text is asked
+for by a **key**, and its English lives in one file, the English reference
+`src/managed/Nota.Application/Localization/en.json`. Each other language is one JSON file of the
+same keys, `src/managed/Nota.App/Languages/<code>.json` (French is `fr.json`); the languages are
+moving to their own repository, [nota-daw/nota-translations](https://github.com/nota-daw/nota-translations),
+from the next release.
+
+- **Every new user-visible text goes through `Loc`, by key.** Add the key and its English to
+ `en.json`, then write `Loc.T("preferences.language.restart")` for a text,
+ `Loc.F("arrangement.delete_clips", n)` for a text with values (`"Delete {0} clips?"` — the whole
+ sentence, never a piece of it) and `Loc.Plural("arrangement.clips", n)` for a counted text
+ (`{ "one": "{0} clip", "other": "{0} clips" }` in `en.json`); in XAML write
+ `{app:T 'main.save_as'}`. The key is always a plain literal.
+- **Keys**: lower-case, dot-separated, area first, then what the text says —
+ `<area>[.<sub-area>].<what>`, segments of `a-z 0-9 _`, up to 80 characters. The area is the
+ window or view the text belongs to (`preferences`, `arrangement`, `main.menu`,
+ `device.reverb`); a text used the same way in three or more areas is `common.<what>`
+ (`common.cancel`). Two meanings of one English word are two keys (`menu.open`, `clip.open`) —
+ there are no contexts.
+- **Changing English**: edit the text in `en.json` only; no call site and no translation file
+ changes, and every translation stays attached. If the *meaning* or the placeholders change,
+ make a new key instead and delete the old one, so translators see a new text rather than a
+ stale one.
+- The smoke test fails on a key used in the code that is not in `en.json`, an `en.json` key
+ nothing uses, a key used against its shape (a counted text through `Loc.T`, a pattern with
+ `{0}` through `Loc.T`), a new plain literal that reads as interface text, and a key French does
+ not cover. Text that is not translated on purpose — user content, device and parameter names,
+ proper nouns, units, logs, the Remote web page and MCP — is listed with its reason as `# data:`
+ in `tests/Nota.SmokeTest/LocalizationAllowList.txt`.
+- **Add a language**: copy `fr.json` to `<code>.json` (two lowercase letters), set `code`,
+ `name` (the language's own name, shown in Preferences → Appearance → Language) and `plural`
+ (`one_is_1` when only 1 is singular, as in English; `one_is_0_1` when 0 and 1 are, as in
+ French), translate the strings you can and delete the rest — anything missing shows in
+ English. Also list the code in `CFBundleLocalizations` of `scripts/bundle-mac.sh` and
+ `scripts/package-dmg.sh` (the smoke test checks it), so macOS shows its own text — Hide, Quit,
+ the open panels — in that language too. The file format is in
+ [specs/077-key-based-localization/contracts/language-file.md](specs/077-key-based-localization/contracts/language-file.md).
+- **Translate or fix a string**: edit its value in the language file; the English it stands for
+ is the same key in `en.json`. Keep the placeholders (`{0}`, `{1}`) and give a counted text
+ both forms (`one`, `other`). Follow the glossary in
+ [specs/068-ui-language/glossary.md](specs/068-ui-language/glossary.md) (infinitive for
+ actions, sentence case, a narrow no-break space before `:` `;` `?` `!`). Device and parameter
+ names stay in English.
- **Look at it**: run `NOTA_UI_LANGUAGE=fr` to start in a language for that run without
touching the saved setting, and check that nothing is clipped or overlaps at each interface
scale. `NOTA_LOC_WRITE_BASELINE=1` rewrites the allow-list after you wrap or add text.
diff --git a/scripts/loc-migrate.py b/scripts/loc-migrate.py
new file mode 100755
index 00000000..8bedb112
--- /dev/null
+++ b/scripts/loc-migrate.py
@@ -0,0 +1,590 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
+"""
+One-off migration of interface texts from English-text-as-key to stable keys (spec 077,
+research R2 / R4). Standard library only.
+
+ --plan scan the source, build the text -> key map, write keymap.tsv (repo root,
+ git-ignored). An existing keymap.tsv is read back first, so keys renamed
+ by hand in it stick on the next run.
+ --apply write src/managed/Nota.Application/Localization/en.json, convert
+ src/managed/Nota.App/Languages/fr.json to format 2 and rewrite every
+ Loc.T / Loc.F / Loc.Plural call and every {app:T ...} in place.
+ --verify COMMIT compare the tree with COMMIT (before the migration): every call site, in
+ order, must now use the key its old text maps to, and en.json / fr.json
+ must give that key exactly the old English / French. Exit 1 on any
+ difference.
+
+The scanner mirrors tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs (LocT, LocF,
+LocPlural, LocXaml), so it sees exactly the keys the smoke test checks. It fails on any Loc
+call it cannot read rather than guess. Deleted again once spec 077 is done (PR 3).
+"""
+
+import argparse
+import html
+import collections
+import json
+import os
+import re
+import subprocess
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MANAGED = os.path.join(ROOT, "src", "managed")
+EN_PATH = os.path.join(MANAGED, "Nota.Application", "Localization", "en.json")
+FR_PATH = os.path.join(MANAGED, "Nota.App", "Languages", "fr.json")
+KEYMAP = os.path.join(ROOT, "keymap.tsv")
+
+LIT = r'"(?:[^"\\\n]|\\.)*"'
+RE_T = re.compile(r'\bLoc\.T\(\s*(?P<t>' + LIT + r')(?:\s*,\s*(?:context:\s*)?(?P<c>' + LIT + r'))?')
+RE_F = re.compile(r'\bLoc\.F\(\s*(?P<t>' + LIT + r')')
+RE_PLURAL = re.compile(r'\bLoc\.Plural\((?P<n>[^"]*?),\s*(?P<one>' + LIT + r')\s*,\s*(?P<t>' + LIT + r')'
+ r'(?:\s*,\s*(?:context:\s*)?(?P<c>' + LIT + r'))?')
+RE_PLURAL_NEW = re.compile(r'\bLoc\.Plural\(\s*(?P<t>' + LIT + r')\s*,')
+RE_ANY = re.compile(r'\bLoc\.(?:T|F|FC|Plural)\(')
+RE_XAML = re.compile(r"\{app:T\s+(?:'(?P<q>(?:[^'\\]|\\.)*)'|(?P<t>[^\s'},][^},]*?))\s*(?:,\s*Context=(?P<c>[^}\s]+))?\s*\}")
+KEY_RE = re.compile(r'^[a-z0-9_]+(\.[a-z0-9_]+)+$')
+MAX_KEY = 80
+
+SKIP_PREFIXES = ("Nota.Application/Localization/",)
+SKIP_FILES = {"Nota.App/TExtension.cs"}
+
+
+# ---- C# reading ---------------------------------------------------------------------------
+
+def code_of(line):
+ """The line without its // comment (a // inside a string stays), as the smoke test's
+ CodeOf; returned blank-padded so offsets keep matching the original line."""
+ i, n = 0, len(line)
+ while i < n:
+ ch = line[i]
+ if ch == '/' and i + 1 < n and line[i + 1] == '/':
+ return line[:i] + ' ' * (n - i)
+ if ch in '"\'':
+ q = ch
+ i += 1
+ while i < n and line[i] != q:
+ i += 2 if line[i] == '\\' else 1
+ i += 1
+ continue
+ if ch in '@$' and i + 1 < n and line[i + 1] in '"@$':
+ # verbatim / interpolated: skip to the closing quote, "" is an escaped quote
+ j = i
+ while j < n and line[j] != '"':
+ j += 1
+ verbatim = '@' in line[i:j]
+ j += 1
+ while j < n:
+ if line[j] == '"':
+ if verbatim and j + 1 < n and line[j + 1] == '"':
+ j += 2
+ continue
+ break
+ j += 2 if (not verbatim and line[j] == '\\') else 1
+ i = j + 1
+ continue
+ i += 1
+ return line
+
+
+def blank_code(text):
+ return '\n'.join(code_of(l) for l in text.split('\n'))
+
+
+def blank_xml_comments(text):
+ return re.sub(r'<!--.*?-->', lambda m: re.sub(r'[^\n]', ' ', m.group(0)), text, flags=re.S)
+
+
+_ESC = {'n': '\n', 't': '\t', 'r': '\r', '0': '\0', '\\': '\\', '"': '"', "'": "'", 'a': '\a',
+ 'b': '\b', 'f': '\f', 'v': '\v'}
+
+
+def unescape(body):
+ """A C# regular literal body to its text, as .NET Regex.Unescape does for these."""
+ out, i = [], 0
+ while i < len(body):
+ c = body[i]
+ if c != '\\' or i + 1 >= len(body):
+ out.append(c)
+ i += 1
+ continue
+ e = body[i + 1]
+ if e == 'u' and re.match(r'[0-9a-fA-F]{4}', body[i + 2:i + 6]):
+ out.append(chr(int(body[i + 2:i + 6], 16)))
+ i += 6
+ elif e == 'x' and re.match(r'[0-9a-fA-F]{2}', body[i + 2:i + 4]):
+ out.append(chr(int(body[i + 2:i + 4], 16)))
+ i += 4
+ else:
+ out.append(_ESC.get(e, e))
+ i += 2
+ return ''.join(out)
+
+
+def lit(m, g):
+ v = m.group(g)
+ return None if v is None else unescape(v[1:-1])
+
+
+# ---- scanning -----------------------------------------------------------------------------
+
+Site = collections.namedtuple("Site", "rel line start end kind text ctx one n")
+# kind: T, F, P (plural), X (xaml). start/end: the span to replace in the original text.
+
+
+def source_files():
+ for d, dirs, files in os.walk(MANAGED):
+ dirs[:] = sorted(x for x in dirs if x not in ("bin", "obj"))
+ for f in sorted(files):
+ if f.endswith(".cs") or f.endswith(".axaml"):
+ p = os.path.join(d, f)
+ yield os.path.relpath(p, MANAGED).replace(os.sep, "/"), p
+
+
+def line_of(text, index):
+ return text.count('\n', 0, index) + 1
+
+
+def scan_text(rel, text):
+ """All Loc sites of one file, in source order, plus problems."""
+ sites, problems = [], []
+ if rel.endswith(".axaml"):
+ b = blank_xml_comments(text)
+ for m in RE_XAML.finditer(b):
+ t = m.group('q') if m.group('q') is not None else m.group('t')
+ t = html.unescape(t).replace("\\'", "'")
+ sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "X", t, m.group('c'), None, None))
+ return sites, problems
+ b = blank_code(text)
+ taken = []
+ for m in RE_PLURAL.finditer(b):
+ sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "P", lit(m, 't'), lit(m, 'c'),
+ lit(m, 'one'), m.group('n').strip()))
+ taken.append(m.start())
+ for m in RE_PLURAL_NEW.finditer(b): # the migrated form, Loc.Plural("key", n) — for --verify
+ depth, j = 1, m.end()
+ while j < len(b) and depth:
+ depth += {'(': 1, ')': -1}.get(b[j], 0)
+ j += 1
+ sites.append(Site(rel, line_of(b, m.start()), m.start(), j - 1, "P", lit(m, 't'), None, None,
+ b[m.end():j - 1].strip()))
+ taken.append(m.start())
+ for m in RE_T.finditer(b):
+ sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "T", lit(m, 't'), lit(m, 'c'), None, None))
+ taken.append(m.start())
+ rest = b[m.end():].lstrip()
+ if not rest.startswith(')'):
+ problems.append(f"{rel}:{line_of(b, m.start())}: Loc.T text is not the whole argument")
+ for m in RE_F.finditer(b):
+ sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "F", lit(m, 't'), None, None, None))
+ taken.append(m.start())
+ rest = b[m.end():].lstrip()
+ if not (rest.startswith(',') or rest.startswith(')')):
+ problems.append(f"{rel}:{line_of(b, m.start())}: Loc.F pattern is not the whole first argument")
+ for m in RE_ANY.finditer(b):
+ if m.start() not in taken:
+ problems.append(f"{rel}:{line_of(b, m.start())}: Loc call not readable: {b[m.start():m.start() + 70]!r}")
+ sites.sort(key=lambda s: s.start)
+ return sites, problems
+
+
+def scan_tree(read=None):
+ """Sites per file. `read(rel)` returns a file's text (for a git commit), else the working tree."""
+ out, problems = collections.OrderedDict(), []
+ if read is None:
+ files = [(rel, open(p, encoding='utf-8').read()) for rel, p in source_files()]
+ else:
+ files = read()
+ for rel, text in files:
+ if rel in SKIP_FILES or rel.startswith(SKIP_PREFIXES):
+ continue
+ if "Loc." not in text and "app:T" not in text:
+ continue
+ s, p = scan_text(rel, text)
+ problems += p
+ if s:
+ out[rel] = s
+ return out, problems
+
+
+# ---- keys ---------------------------------------------------------------------------------
+
+def snake(name):
+ s = re.sub(r'(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])', '_', name)
+ return re.sub(r'[^a-z0-9]+', '_', s.lower()).strip('_')
+
+
+STEM_SUFFIXES = ("InstrumentCard", "DeviceBody", "MidiBody", "ViewModel", "Views", "View", "Window",
+ "Service", "Card", "Kit", "Viz", "Graph", "Curve", "Scope")
+
+
+def strip_suffix(stem):
+ for suf in STEM_SUFFIXES:
+ if stem.endswith(suf) and len(stem) > len(suf):
+ return stem[:-len(suf)]
+ return stem
+
+
+AREA_OVERRIDES = {
+ "Nota.App/MainWindow": "main", "Nota.App/App": "app", "Nota.App/MenuKit": "menu",
+ "Nota.App/MacAppMenu": "menu.mac", "Nota.App/TextBoxMenu": "menu.text_box",
+ "Nota.Presentation/ViewModels/MainWindowViewModel": "main",
+ "Nota.App/DeviceCards/PluginCard": "device.plugin",
+ "Nota.App/DeviceCards/SidechainSourcePicker": "device.sidechain",
+ "Nota.App/DeviceCards/Midi/MidiCardHeader": "device.midi",
+ "Nota.App/DeviceCards/Rack/MacroPanel": "device.rack.macros",
+ "Nota.App/DeviceCards/Rack/RackKindProfile": "device.rack",
+ "Nota.App/DeviceCards/Rack/RackCardView": "device.rack",
+ "Nota.App/DeviceCards/Sampler/SamplerViews": "device.sampler",
+ "Nota.App/DeviceCardKit": "device.card",
+ "Nota.App/Remote/ConnectPhoneView": "remote.connect", "Nota.App/Remote/RemoteService": "remote",
+ "Nota.Application/Palette/BuiltinDeviceCatalog": "palette.devices",
+ "Nota.Application/Palette/CommandCatalog": "commands",
+ "Nota.Application/Palette/ModularCatalog": "palette.modular",
+ "Nota.Application/Palette/DeviceCategories": "palette.categories",
+}
+
+CONTROL_DEVICES = ("AutoFilter", "AutoShift", "BeatRepeat", "Ceiling", "Comp", "Consort", "Crush",
+ "DynamicEq", "Eq8", "FluxReact", "Keys", "OperatorAlgo", "Pendulum", "Reverb",
+ "Rhythm", "Shutter", "Synth", "Utility", "Vocoder")
+
+
+def area_of(rel):
+ """Key prefix for a file: area[.sub-area from the partial-file suffix] (research R2)."""
+ path = rel.rsplit('.', 1)[0] if rel.endswith(".cs") or rel.endswith(".axaml") else rel
+ if path.endswith(".axaml"):
+ path = path[:-6]
+ d, _, fname = path.rpartition('/')
+ parts = fname.split('.')
+ stem, sub = parts[0], (parts[1] if len(parts) > 1 else None)
+ base = f"{d}/{stem}"
+ if base in AREA_OVERRIDES:
+ area = AREA_OVERRIDES[base]
+ elif d == "Nota.App/Controls":
+ s = strip_suffix(stem)
+ area = ("device." + snake(s)) if any(stem.startswith(c) for c in CONTROL_DEVICES) else "control." + snake(s)
+ elif d.startswith("Nota.App/DeviceCards/Rack"):
+ area = "device.rack"
+ elif d.startswith("Nota.App/DeviceCards"):
+ area = "device." + snake(strip_suffix(stem))
+ elif d == "Nota.App" or d == "Nota.Presentation" or d == "Nota.Presentation/ViewModels":
+ area = snake(strip_suffix(stem))
+ elif d.startswith("Nota.Application/") or d.startswith("Nota.Infrastructure/"):
+ area = snake(d.split('/')[1])
+ rest = snake(strip_suffix(stem))
+ if rest.startswith(area + "_"): # Midi/MidiTransforms -> midi.transforms
+ rest = rest[len(area) + 1:]
+ if rest != area:
+ area += "." + rest
+ else:
+ raise SystemExit(f"loc-migrate: no area for {rel} — extend area_of()")
+ if sub:
+ sub = snake(sub)
+ if not area.endswith("." + sub) and area.split('.')[-1] != sub:
+ area += "." + sub
+ return area
+
+
+def slug(text, limit):
+ words = re.findall(r"[A-Za-z0-9]+", re.sub(r"\{\d+[^}]*\}", " ", text.replace("’", "").replace("'", "")))
+ words = [w.lower() for w in words][:5]
+ s = "_".join(words) or "pattern" # "{0} · {1}": punctuation only
+ s = s[:limit].rstrip('_') or "pattern"
+ if re.search(r"[A-Z]{2}", text) and not re.search(r"[a-z]", text):
+ s += "_caps" # "TRACK" beside "Track"
+ return s
+
+
+def ident(site):
+ """What a key stands for: English text (other form), singular form, context, kind."""
+ return (site.text, site.one if site.kind == "P" else None, site.ctx or "", "P" if site.kind == "P" else "T")
+
+
+def old_key(text, ctx):
+ return text if not ctx else text + "|" + ctx
+
+
+def top_area(area):
+ """The group a text is shared within: the first segment, or device.<name> for devices."""
+ parts = area.split('.')
+ return '.'.join(parts[:2]) if parts[0] == "device" and len(parts) > 1 else parts[0]
+
+
+def groups_of(tree):
+ """ident -> {top area -> {full areas}} over the whole tree."""
+ g = collections.defaultdict(lambda: collections.defaultdict(set))
+ for rel, sites in tree.items():
+ a = area_of(rel)
+ for s in sites:
+ g[ident(s)][top_area(a)].add(a)
+ return g
+
+
+def slot(site, rel, groups):
+ """What one key stands for: a text (ident) in one group — "common" when three or more
+ groups use it (research R2), else the group of the file it is used in."""
+ idt = ident(site)
+ return (idt, "common" if len(groups[idt]) >= 3 else top_area(area_of(rel)))
+
+
+def build_map(tree, previous):
+ """slot -> key. `previous` (from keymap.tsv) wins for slots it knows."""
+ groups = groups_of(tree)
+ slots = {}
+ for rel, sites in tree.items():
+ for s in sites:
+ sl = slot(s, rel, groups)
+ idt, grp = sl
+ slots[sl] = "common" if grp == "common" else (
+ next(iter(groups[idt][grp])) if len(groups[idt][grp]) == 1 else grp)
+ out, taken = {}, set()
+ for sl, key in previous.items():
+ if sl in slots:
+ out[sl] = key
+ taken.add(key)
+ for sl in sorted(slots, key=lambda x: (bool(re.search(r"\{\d", x[0][0])), slots[x], x)):
+ if sl in out:
+ continue
+ (text, one, ctx, kind), prefix = sl[0], slots[sl]
+ base = slug(text, MAX_KEY - len(prefix) - 9 - (len(ctx) + 1 if ctx else 0))
+ if ctx:
+ base += "_" + snake(ctx)
+ key, n = f"{prefix}.{base}", 2
+ if key in taken and re.search(r"\{\d", text):
+ key = f"{prefix}.{base}_n" # "Audio" beside "Audio {0}"
+ while key in taken:
+ key, n = f"{prefix}.{base}_{n}", n + 1
+ out[sl] = key
+ taken.add(key)
+ return out
+
+
+def read_keymap():
+ prev = {}
+ if not os.path.exists(KEYMAP):
+ return prev
+ with open(KEYMAP, encoding='utf-8') as f:
+ next(f, None)
+ for line in f:
+ p = line.rstrip('\n').split('\t')
+ if len(p) < 7:
+ continue
+ key, group, kind, ctx, text, one = p[0], p[1], p[2], p[3], json.loads(p[4]), (json.loads(p[5]) if p[5] else None)
+ prev[((text, one, ctx, kind), group)] = key
+ return prev
+
+
+def write_keymap(m, tree):
+ groups = groups_of(tree)
+ files = collections.defaultdict(set)
+ for rel, sites in tree.items():
+ for s in sites:
+ files[slot(s, rel, groups)].add(rel)
+ with open(KEYMAP, 'w', encoding='utf-8') as f:
+ f.write("key\tgroup\tkind\tcontext\ttext\tone\tfiles\n")
+ for sl, key in sorted(m.items(), key=lambda kv: kv[1]):
+ (text, one, ctx, kind), group = sl
+ f.write(f"{key}\t{group}\t{kind}\t{ctx}\t{json.dumps(text, ensure_ascii=False)}\t"
+ f"{json.dumps(one, ensure_ascii=False) if one is not None else ''}\t{','.join(sorted(files[sl]))}\n")
+
+
+def check_map(m):
+ bad, seen = [], {}
+ for idt, key in m.items():
+ if not KEY_RE.match(key) or len(key) > MAX_KEY:
+ bad.append(f"bad key {key!r}")
+ if key in seen:
+ bad.append(f"key {key!r} used for two texts: {seen[key][0][0]!r} and {idt[0][0]!r}")
+ seen[key] = idt
+ return bad
+
+
+# ---- writing ------------------------------------------------------------------------------
+
+def dump_table(header, strings):
+ """A language file: header fields, then strings one per line, keys in order given."""
+ out = ["{"]
+ for k, v in header.items():
+ out.append(f" {json.dumps(k)}: {json.dumps(v, ensure_ascii=False)},")
+ out.append(' "strings": {')
+ items = list(strings.items())
+ for i, (k, v) in enumerate(items):
+ comma = "," if i + 1 < len(items) else ""
+ if isinstance(v, dict):
+ inner = ", ".join(f"{json.dumps(a)}: {json.dumps(b, ensure_ascii=False)}" for a, b in v.items())
+ out.append(f" {json.dumps(k)}: {{ {inner} }}{comma}")
+ else:
+ out.append(f" {json.dumps(k)}: {json.dumps(v, ensure_ascii=False)}{comma}")
+ out.append(" }")
+ out.append("}")
+ return "\n".join(out) + "\n"
+
+
+def en_strings(m):
+ strings = {}
+ for (idt, _), key in sorted(m.items(), key=lambda kv: kv[1]):
+ text, one, ctx, kind = idt
+ strings[key] = {"one": one, "other": text} if kind == "P" else text
+ return strings
+
+
+def fr_strings(m, fr_old):
+ strings, used = {}, set()
+ for (idt, _), key in sorted(m.items(), key=lambda kv: kv[1]):
+ text, one, ctx, kind = idt
+ ok = old_key(text, ctx)
+ if ok in fr_old:
+ strings[key] = fr_old[ok]
+ used.add(ok)
+ orphans = sorted(set(fr_old) - used)
+ return strings, orphans
+
+
+def rewrite(rel, text, sites, m, groups):
+ out, pos = [], 0
+ for s in sites:
+ key = m[slot(s, rel, groups)]
+ out.append(text[pos:s.start])
+ if s.kind == "X":
+ out.append("{app:T '" + key + "'}")
+ elif s.kind == "P":
+ out.append(f'Loc.Plural("{key}", {s.n}')
+ else:
+ out.append(f'Loc.{s.kind}("{key}"')
+ pos = s.end
+ out.append(text[pos:])
+ return "".join(out)
+
+
+# ---- commands -----------------------------------------------------------------------------
+
+def cmd_plan():
+ tree, problems = scan_tree()
+ if problems:
+ print("\n".join(problems), file=sys.stderr)
+ return 1
+ m = build_map(tree, read_keymap())
+ bad = check_map(m)
+ write_keymap(m, tree)
+ n_sites = sum(len(s) for s in tree.values())
+ commons = sum(1 for k in m.values() if k.startswith("common."))
+ print(f"{n_sites} call sites in {len(tree)} files -> {len(m)} keys ({commons} common.*); keymap.tsv written")
+ if bad:
+ print("\n".join(bad), file=sys.stderr)
+ return 1
+ return 0
+
+
+def cmd_apply():
+ tree, problems = scan_tree()
+ if problems:
+ print("\n".join(problems), file=sys.stderr)
+ return 1
+ if not os.path.exists(KEYMAP):
+ print("run --plan first", file=sys.stderr)
+ return 1
+ m = build_map(tree, read_keymap())
+ bad = check_map(m)
+ if bad:
+ print("\n".join(bad), file=sys.stderr)
+ return 1
+ fr = json.load(open(FR_PATH, encoding='utf-8'))
+ if fr.get("formatVersion") != 1:
+ print("fr.json is not format 1 — already migrated?", file=sys.stderr)
+ return 1
+ with open(EN_PATH, 'w', encoding='utf-8') as f:
+ f.write(dump_table({"formatVersion": 2, "code": "en", "name": "English", "plural": "one_is_1",
+ "notes": "The English reference: every interface text of Nota by key (spec 077). "
+ "Change a text here; a new meaning or new placeholders get a new key."},
+ en_strings(m)))
+ frs, orphans = fr_strings(m, fr["strings"])
+ notes = fr.get("notes", "")
+ notes = re.sub(r" A key is the English text.*?French counts 0 and 1 as one\.",
+ " Keys are the English reference's keys (Nota.Application/Localization/en.json); counted texts "
+ "take {\"one\", \"other\"} and French counts 0 and 1 as one.", notes)
+ with open(FR_PATH, 'w', encoding='utf-8') as f:
+ f.write(dump_table({"formatVersion": 2, "code": "fr", "name": fr.get("name", "Français"),
+ "plural": "one_is_0_1", "notes": notes}, frs))
+ groups = groups_of(tree)
+ for rel, sites in tree.items():
+ p = os.path.join(MANAGED, rel)
+ text = open(p, encoding='utf-8').read()
+ new = rewrite(rel, text, sites, m, groups)
+ if new != text:
+ with open(p, 'w', encoding='utf-8') as f:
+ f.write(new)
+ print(f"en.json: {len(m)} keys; fr.json: {len(frs)} entries, {len(orphans)} orphans dropped; "
+ f"{sum(len(s) for s in tree.values())} call sites rewritten in {len(tree)} files")
+ for o in orphans:
+ print(" orphan:", o)
+ return 0
+
+
+def git_files(commit):
+ names = subprocess.run(["git", "-C", ROOT, "ls-tree", "-r", "--name-only", commit, "src/managed"],
+ capture_output=True, text=True, check=True).stdout.split()
+ for n in names:
+ if not (n.endswith(".cs") or n.endswith(".axaml")) or "/bin/" in n or "/obj/" in n:
+ continue
+ text = subprocess.run(["git", "-C", ROOT, "show", f"{commit}:{n}"], capture_output=True, check=True).stdout
+ yield n[len("src/managed/"):], text.decode('utf-8')
+
+
+def cmd_verify(commit):
+ old_tree, p1 = scan_tree(lambda: list(git_files(commit)))
+ new_tree, p2 = scan_tree()
+ fr_old = json.loads(subprocess.run(["git", "-C", ROOT, "show", f"{commit}:src/managed/Nota.App/Languages/fr.json"],
+ capture_output=True, check=True).stdout)["strings"]
+ en = json.load(open(EN_PATH, encoding='utf-8'))["strings"]
+ fr = json.load(open(FR_PATH, encoding='utf-8'))["strings"]
+ diffs = list(p1) + list(p2)
+ if set(old_tree) != set(new_tree):
+ diffs.append(f"files differ: {sorted(set(old_tree) ^ set(new_tree))}")
+ for rel in old_tree:
+ olds, news = old_tree[rel], new_tree.get(rel, [])
+ if len(olds) != len(news):
+ diffs.append(f"{rel}: {len(olds)} sites before, {len(news)} now")
+ continue
+ for o, n in zip(olds, news):
+ key = n.text # the literal now is the key
+ where = f"{rel}:{n.line}"
+ if (o.kind == "P") != (n.kind == "P"):
+ diffs.append(f"{where}: plural changed")
+ continue
+ e = en.get(key)
+ want = {"one": o.one, "other": o.text} if o.kind == "P" else o.text
+ if e != want:
+ diffs.append(f"{where}: en[{key}] = {e!r}, was {want!r}")
+ ok = old_key(o.text, o.ctx)
+ if ok in fr_old and fr.get(key) != fr_old[ok]:
+ diffs.append(f"{where}: fr[{key}] = {fr.get(key)!r}, was {fr_old[ok]!r}")
+ if ok not in fr_old and key in fr:
+ diffs.append(f"{where}: fr[{key}] appeared")
+ if o.kind == "P" and n.n != o.n:
+ diffs.append(f"{where}: count expression {n.n!r}, was {o.n!r}")
+ n = sum(len(s) for s in old_tree.values())
+ if diffs:
+ print("\n".join(diffs[:200]), file=sys.stderr)
+ print(f"{len(diffs)} differences over {n} call sites", file=sys.stderr)
+ return 1
+ print(f"verified {n} call sites in {len(old_tree)} files: English and French unchanged")
+ return 0
+
+
+def main():
+ ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+ g = ap.add_mutually_exclusive_group(required=True)
+ g.add_argument("--plan", action="store_true")
+ g.add_argument("--apply", action="store_true")
+ g.add_argument("--verify", metavar="COMMIT")
+ a = ap.parse_args()
+ if a.plan:
+ return cmd_plan()
+ if a.apply:
+ return cmd_apply()
+ return cmd_verify(a.verify)
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/specs/077-key-based-localization/checklists/requirements.md b/specs/077-key-based-localization/checklists/requirements.md
new file mode 100644
index 00000000..400e68c0
--- /dev/null
+++ b/specs/077-key-based-localization/checklists/requirements.md
@@ -0,0 +1,42 @@
+# Specification Quality Checklist: Key-Based Interface Texts and Downloadable Languages
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning
+**Created**: 2026-11-04
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- The feature is itself about a file format and a repository, so the spec names them
+ (JSON language files, `nota-translations`, the smoke test, a checksum) — the same level
+ of detail as spec 068. Code structure, APIs and class names are left to the plan.
+- The format decision (key-based JSON vs `.resx`) is recorded as an assumption with its
+ reasons rather than a clarification marker; `/speckit-clarify` should confirm it.
+- Points worth confirming in `/speckit-clarify`: the three-PR delivery and shipping steps 2
+ and 3 in one release; how a language "fits" a Nota version (release workflow publishes
+ the English reference); same-launch vs after-restart for the automatic French download
+ of existing users (story 5).
diff --git a/specs/077-key-based-localization/contracts/index.md b/specs/077-key-based-localization/contracts/index.md
new file mode 100644
index 00000000..063dbd61
--- /dev/null
+++ b/specs/077-key-based-localization/contracts/index.md
@@ -0,0 +1,45 @@
+# Contract: `index.json` (nota-translations)
+
+Generated by `publish.yml` on every push to `main`; never edited by hand. The app reads
+`<base>/main/index.json`, `<base>` = `https://raw.githubusercontent.com/nota-daw/nota-translations`
+(overridable with `NOTA_LANGUAGES_URL`).
+
+```json
+{
+ "formatVersion": 1,
+ "generated": "2026-11-20T10:00:00Z",
+ "references": {
+ "0.43.0": "3f9a1c0d7e2b4a51",
+ "0.44.0": "3f9a1c0d7e2b4a51",
+ "develop": "b81e09f2c4d3a677"
+ },
+ "languages": [
+ {
+ "code": "fr",
+ "name": "Français",
+ "version": 12,
+ "commit": "a1b2c3d…(40 hex)",
+ "path": "languages/fr.json",
+ "size": 214533,
+ "sha256": "…64 hex…",
+ "coverage": { "3f9a1c0d7e2b4a51": 100, "b81e09f2c4d3a677": 97 }
+ }
+ ]
+}
+```
+
+| Field | Meaning |
+|---|---|
+| `formatVersion` | Index shape. The app ignores an index with a higher major and says "update Nota to see more languages". |
+| `references` | Nota version → key-set hash of its `en.json`. Versions with the same keys share a hash. |
+| `languages[].version` | Integer, +1 each time the file's content changes on `main`. Shown as "update available" when greater than the installed one. |
+| `commit` | The commit whose `path` has exactly `size` / `sha256`; the app downloads `<base>/<commit>/<path>`. |
+| `coverage` | Per key-set hash, percent (see language-file contract). Only languages that pass validation are listed. |
+
+## App behaviour
+
+- Own hash in `coverage` → show that coverage.
+- Own hash absent → use the newest `references` entry with a version ≤ the app's and show its
+ coverage; none → show the language without coverage.
+- Fetch failure, malformed index → installed languages only, "More languages are available
+ online" (or the error) in the row; no dialog.
diff --git a/specs/077-key-based-localization/contracts/language-file.md b/specs/077-key-based-localization/contracts/language-file.md
new file mode 100644
index 00000000..9535af3a
--- /dev/null
+++ b/specs/077-key-based-localization/contracts/language-file.md
@@ -0,0 +1,55 @@
+# Contract: language file (format version 2)
+
+Replaces [068 translation-file](../../068-ui-language/contracts/translation-file.md). One
+shape for the English reference (`Nota.Application/Localization/en.json`, embedded in `Nota.Application`), repository files
+(`nota-translations/languages/<code>.json`, `reference/<version>.json`) and local files.
+UTF-8, no BOM, no SPDX header (licence stated by the repository).
+
+## Shape
+
+```json
+{
+ "formatVersion": 2,
+ "code": "fr",
+ "name": "Français",
+ "plural": "one_is_0_1",
+ "notes": "Glossary, register, conventions for translators.",
+ "strings": {
+ "common.save": "Enregistrer",
+ "menu.file.open": "Ouvrir",
+ "clip.open": "Ouvrir le clip",
+ "arrangement.selection.tracks": {
+ "one": "{0} piste sélectionnée",
+ "other": "{0} pistes sélectionnées"
+ }
+ }
+}
+```
+
+## Rules
+
+| Rule | Detail |
+|---|---|
+| `formatVersion` | `2`. `1` (text-keyed) and anything higher are rejected with a logged error; the language is not offered. |
+| `code` | Lower-case BCP-47 primary tag (`fr`, `de`, `pt-br` allowed); equals the file name. `en` only for the reference. |
+| `name` | The language's own name, shown in the picker. |
+| `plural` | A rule id the app knows: `one_is_1`, `one_is_0_1`. Unknown → file rejected. Required except in `en.json` (`one_is_1` implied). |
+| Keys | Match `^[a-z0-9_]+(\.[a-z0-9_]+)+$`, ≤ 80 chars, unique. |
+| Values | A non-empty string, or a plural object with `other` required; `one` optional (missing → `other`). Unknown categories ignored. An empty string counts as missing (English shown). |
+| Shape | A key that is a plural object in the reference must be one here, and the other way round; mismatch → entry invalid (English shown), reported. |
+| Placeholders | `{0}` … `{9}` with optional format (`{0:0.0}`). `other` uses exactly the reference's placeholders, any order; `one` may drop but not add. `{{` `}}` literal. Every form must format (no stray brace, no `{0,abc}`, no index past 9); one that does not is an invalid entry, not counted in coverage. |
+| Missing key | Run time: English. Coverage: counted missing. |
+| Unknown key (not in the reference checked against) | Run time: ignored. Repository check: error if the key is in **no** reference, warning if only in older ones. |
+| Malformed file | Language skipped, error logged, English kept; Nota always starts. |
+| `en.json` extra rule | Every value present; `code` = `en`; this file *is* the reference. |
+
+## Coverage
+
+`translated valid entries of reference keys ÷ reference keys`, per reference, rounded down
+to a whole percent.
+
+## Key-set hash
+
+SHA-256 (lower-case hex, first 16 chars) of the UTF-8 lines, sorted ordinally and joined with
+`\n`: `key \t (text|plural) \t sorted placeholder indices joined by ","`. Computed
+identically by the app, the smoke test and `tools/validate.py`.
diff --git a/specs/077-key-based-localization/contracts/language-row.md b/specs/077-key-based-localization/contracts/language-row.md
new file mode 100644
index 00000000..ef806015
--- /dev/null
+++ b/specs/077-key-based-localization/contracts/language-row.md
@@ -0,0 +1,34 @@
+# Contract: Preferences → Appearance → Language row
+
+Extends the 068 row (combo + "Applies after restart" + **Restart**). Studio design: neutral
+greys, orange only for the selected / live item, sentence case, no dialogs.
+
+## Combo items
+
+| Item | Shown as | Picking it |
+|---|---|---|
+| English | `English` | as today |
+| Installed (repository) | `Français` · `97%` (muted) | as today (restart note) |
+| Installed (local file) | `Français` · `local file` | as today |
+| Available, not installed | `Deutsch` · `82%` · download glyph | downloads; row shows `Downloading…` + progress; then the restart note; on failure `Couldn't download Deutsch — <reason>` and the combo returns to the running language |
+
+Order: English, installed by code, a separator, available by code.
+
+## Row actions (beside the combo, only when relevant)
+
+| Condition | Shows |
+|---|---|
+| Stored language newer in the index | `Update available` + **Update** (downloads, then restart note if it is the running one) |
+| Selected item is an installed non-English language | **Remove** (a running one keeps working until restart, then English) |
+| Always | **Load file…** (opens a JSON file; problems listed below the row) |
+| Index unreachable | `More languages are available online` (muted) |
+| `CheckForUpdates` off and index not fetched this run | **Show available languages** |
+| Stored language missing, checks on | `Downloading Français…`, then `Français is ready` + **Restart** (story 5) |
+| Stored language missing, checks off or offline | `Français will be downloaded when Nota is online` / **Download Français** |
+
+The status bar shows the story-5 "ready — Restart" notice once per run, the same way the app
+update notice appears (`MainWindow.Updates.cs`).
+
+## Problems list (local file)
+
+Up to 10 lines `key — problem`, then `…and N more (see the log)`.
diff --git a/specs/077-key-based-localization/contracts/loc-api.md b/specs/077-key-based-localization/contracts/loc-api.md
new file mode 100644
index 00000000..550b1acc
--- /dev/null
+++ b/specs/077-key-based-localization/contracts/loc-api.md
@@ -0,0 +1,37 @@
+# Contract: `Loc` API (after this feature)
+
+Replaces [068 loc-api](../../068-ui-language/contracts/loc-api.md).
+
+```csharp
+public static class Loc
+{
+ string Language { get; } // running code
+ TranslationTable English { get; } // embedded en.json, loaded once
+ void Install(TranslationTable? table, string code);
+ string T(string key); // text
+ string F(string key, params object?[] args); // pattern, {0}…
+ string Plural(string key, long n); // n is {0}
+}
+```
+
+```xml
+<MenuItem Header="{app:T menu.file.save_as}" />
+```
+
+| Rule | Detail |
+|---|---|
+| Argument | Always a string literal key (the smoke test reads keys from source; a computed key is a failure). |
+| Lookup | running language entry (valid) → English entry → the key itself + one log line per key (unreachable past the smoke test). |
+| `F` | `string.Format(CurrentCulture, …)`; a pattern that fails formatting falls back to English, then to the bare English text (068 behaviour). |
+| `Plural` | Form chosen by the running language's `plural` rule; English uses `one_is_1`. |
+| Removed | `FC`, every `context` parameter, `Plural(n, one, other)`. |
+| Before `Install` | As 068: English is returned and `UsedBeforeInstall` is set. English comes from the embedded `en.json` and is available before `Install`. |
+
+## Language sources at start-up (`NotaLanguages`)
+
+1. `NOTA_UI_LANGUAGE` — a code, or a path to a language file (this run only, never saved).
+2. `Settings.Language` code → `<data>/languages/<code>.meta.json`:
+ `source: repository` → `<data>/languages/<code>.json`; `source: local` → the stored path.
+3. Missing / invalid → English; reason logged and shown in the Language row.
+
+No network access at start-up on this path.
diff --git a/specs/077-key-based-localization/data-model.md b/specs/077-key-based-localization/data-model.md
new file mode 100644
index 00000000..52bfb8f9
--- /dev/null
+++ b/specs/077-key-based-localization/data-model.md
@@ -0,0 +1,57 @@
+# Data Model: Key-Based Interface Texts and Downloadable Languages
+
+File shapes are in [contracts/](contracts/); this page is the entities and their states.
+
+## Key
+
+- `string`, regex `^[a-z0-9_]+(\.[a-z0-9_]+)+$`, ≤ 80 chars ([research R2](research.md)).
+- Shape: `text` or `plural`; placeholder set `{0}…`.
+- Identity is the string; it never changes when the English text changes. Changing shape or
+ placeholders ⇒ a new key (the old one is removed).
+
+## English reference (`en.json`, embedded)
+
+- All keys with English text / plural object.
+- Derived: **key-set hash** (contract language-file § Key-set hash).
+- Published per Nota release into `nota-translations/reference/<version>.json` by pull.
+
+## TranslationTable (in memory)
+
+- From any language file: `Code`, `Name`, `PluralRule`, `Notes`, `Entries: key → Translation(Other, One?)`,
+ `Problems: list<(key, problem)>` (invalid entries are dropped, not fatal).
+- Load errors (whole file rejected): bad JSON, `formatVersion ≠ 2`, bad `code`, unknown
+ `plural`, duplicate key.
+
+## Installed language (`<data>/languages/`)
+
+| File | Content |
+|---|---|
+| `<code>.json` | The downloaded language file (repository source only) |
+| `<code>.meta.json` | `{ "source": "repository" \| "local", "path"?: "<abs path>", "version"?: 12, "commit"?: "…", "sha256"?: "…", "installed": "<ISO time>" }` |
+| `.staging-<code>.json` | Transient during download; removed on start if left over |
+
+State per code:
+
+```
+not installed ──download ok──▶ installed(repository, v)
+installed(repository, v) ──update ok──▶ installed(repository, v')
+installed(*) ──remove──▶ not installed (a running one stays loaded until restart)
+not installed / installed ──load file──▶ installed(local, path)
+installed(local) ──file missing/invalid at start──▶ English this run, problem shown
+download / update failure ──▶ previous state unchanged
+```
+
+## Catalog entry (from `index.json`)
+
+`Code`, `Name`, `Version`, `Commit`, `Path`, `Size`, `Sha256`, `Coverage: hash → %`.
+Combined with installed state into the row's items ([contracts/language-row.md](contracts/language-row.md)).
+
+## Settings
+
+Unchanged: `Settings.Language` (code), `Settings.CheckForUpdates` (drives R10). No new setting.
+
+## Pending start-up download (story 5)
+
+Not persisted. At start: stored code ≠ `en`, no valid installed file, `CheckForUpdates` on →
+background fetch of index + file after the main window is shown; on success the row and the
+status bar offer **Restart**.
diff --git a/specs/077-key-based-localization/plan.md b/specs/077-key-based-localization/plan.md
new file mode 100644
index 00000000..5fd5d33d
--- /dev/null
+++ b/specs/077-key-based-localization/plan.md
@@ -0,0 +1,160 @@
+# Implementation Plan: Key-Based Interface Texts and Downloadable Languages
+
+**Branch**: `feat/key-based-localization` | **Date**: 2026-11-04 | **Spec**: [spec.md](spec.md)
+
+**Issue**: [nota-daw/nota#476](https://github.com/nota-daw/nota/issues/476)
+
+**Input**: Feature specification from `specs/077-key-based-localization/spec.md`
+
+## Summary
+
+Switch every interface text from English-text-as-key to stable keys (`Loc.T("settings.title")`),
+with an embedded `en.json` as the single English source, using a repeatable migration
+script over the ~4,630 call sites and the French file. Then move translations to
+`nota-daw/nota-translations` (validated by its own CI, with an index of languages,
+coverage per Nota key set, and references pulled from Nota releases), and let the app
+download, update, remove and preview languages from Preferences while shipping English
+only. Format stays JSON (version 2, keyed); the downloader, staging/swap and checksum
+pattern of `ModelStore` are reused. Details: [research.md](research.md).
+
+## Nota: Read Before Planning
+
+- **UI work** → [`DESIGN.md`](../../DESIGN.md) (Studio): the Language row grows
+ ([contracts/language-row.md](contracts/language-row.md)); sentence case, no dialogs,
+ orange only for the selected item.
+- **Anything** → [`CONTRIBUTING.md`](../../CONTRIBUTING.md): no new dependency; the
+ "Translating Nota" section is rewritten (keys, `en.json`, link to nota-translations).
+- **Release** → the `release` skill gains "sync references in nota-translations".
+- Engine, instruments, plugin hosting: not touched.
+
+## Technical Context
+
+**Language/Version**: C# / .NET 10 (managed app, smoke test); Python 3 stdlib (migration
+script in nota, validator and publisher in nota-translations); GitHub Actions YAML.
+
+**Primary Dependencies**: Avalonia (existing). No new dependency in either repository.
+
+**Storage**: `Nota.Application/Localization/en.json` embedded in `Nota.Application` (English built into `Loc`); `<data>/languages/<code>.json` +
+`<code>.meta.json` under the Nota data root (`NOTA_DATA_DIR` in tests); `Settings.Language`
+unchanged.
+
+**Audio-Thread Impact**: None — UI text and file/network I/O on non-audio threads only.
+
+**Testing**: `tests/Nota.SmokeTest` (localization checks move to keys; catalog checks on a
+local fixture index); `scripts/loc-migrate.py --verify` for SC-002; `tools/validate.py`
++ shared fixtures in nota-translations.
+
+**Target Platform**: macOS, Windows, Linux desktop (all builds).
+
+**Project Type**: desktop app + a data repository with CI.
+
+**Performance Goals**: start-up unchanged (no network on the start path; loading two JSON
+tables of ~4k entries ≤ 30 ms, as today); a language download < 10 s on a typical
+connection (files ~200 KB).
+
+**Constraints**: offline-capable; nothing fetched is executed; a bad file never stops Nota
+starting; English output byte-identical after PR 1.
+
+**Scale/Scope**: ~3,650 keys, ~4,630 call sites in 243 `.cs` files + 118 XAML uses, 1
+translated language (French).
+
+## Constitution Check
+
+*GATE: before Phase 0 — re-checked after Phase 1.*
+
+| Principle | Status |
+|---|---|
+| 0. Approved issue | ✅ #476 carries `approved` |
+| I. Real-time audio safety | ✅ no engine / audio-thread code |
+| II. Boundary discipline | ✅ no C ABI change, no JUCE |
+| III. Licensing hygiene | ✅ no dependency; new `.cs` / `.py` files carry SPDX headers; nota-translations is AGPL-3.0-only (LICENSE file) |
+| IV. Verification gate | ✅ smoke test extended (R12); `scripts/build.sh` before each PR |
+| V. One logical change per PR | ✅ three PRs (Clarifications Q5); PR 1 is mechanical and reviewable via `keymap.tsv` |
+| VI. Docs in sync | ✅ CHANGELOG (PR 3: user-visible; PR 1: Changed/dev note), FEATURES.md, nota-docs page (choose / preview a language), CONTRIBUTING |
+| VII. Spec first | ✅ this spec |
+| VIII. No weakened rules | ✅ |
+
+Post-design re-check: unchanged — no violation, Complexity Tracking empty.
+
+## Delivery
+
+| PR | Repository | Content | User-visible |
+|---|---|---|---|
+| 1 | nota | `loc-migrate.py`; `en.json` v2 + `fr.json` v2 (still embedded); `Loc` / `TExtension` / `TranslationTable` / `UiLanguage` on keys and plural rules; call sites rewritten; smoke test on keys; CONTRIBUTING keys section | No |
+| 2 | nota-translations | README, LICENSE, `languages/fr.json` (moved with `git log` attribution in the commit), `tools/validate.py`, `tools/sync_references.py`, fixtures, `check.yml`, `publish.yml`, first `reference/develop.json`; ruleset bypass for GitHub Actions + required check `check` | No |
+| 3 | nota | `LanguageCatalog` + installed-language store; `NotaLanguages` reads `<data>/languages` and local files; Language row and status-bar notice; story-5 background download; `NOTA_UI_LANGUAGE` path; remove embedded `fr.json`; smoke catalog checks; delete `loc-migrate.py`; CHANGELOG / FEATURES / nota-docs; `release` skill step | Yes |
+
+PR 2 can merge any time after PR 1; PR 3 merges after PR 2 and both ship in the same
+release.
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/077-key-based-localization/
+├── spec.md
+├── plan.md
+├── research.md
+├── data-model.md
+├── quickstart.md
+├── contracts/
+│ ├── language-file.md
+│ ├── index.md
+│ ├── loc-api.md
+│ └── language-row.md
+└── tasks.md # /speckit-tasks
+```
+
+### Source Code
+
+```text
+src/managed/
+├── Nota.Application/Localization/
+│ ├── en.json # PR1: new, the English reference, embedded here
+│ ├── Loc.cs # PR1: key API, built-in English fallback
+│ ├── TranslationTable.cs # PR1: format v2, key regex, plural rule, problems, key-set hash
+│ └── UiLanguage.cs # PR1: plural rules by id
+├── Nota.App/
+│ ├── Languages/fr.json # PR1: converted; PR3: removed
+│ ├── Languages/NotaLanguages.cs # PR1: en first; PR3: installed + local sources
+│ ├── TExtension.cs # PR1: key only
+│ ├── App.axaml.cs # PR3: InstallLanguage sources, story-5 trigger
+│ ├── PreferencesWindow.Language.cs # PR3: the row (contracts/language-row.md)
+│ ├── MainWindow.Updates.cs # PR3: "ready — Restart" notice
+│ └── (243 files) # PR1: call sites rewritten by the script
+└── Nota.Infrastructure/
+ └── Languages/ # PR3: new
+ ├── LanguageCatalog.cs # index fetch, download (RegistryClient), fit
+ └── InstalledLanguages.cs # <data>/languages, meta, staging, remove, local
+
+tests/Nota.SmokeTest/
+├── DesignTokenCheck.Localization.cs # PR1: key checks; PR3: drop fr coverage
+├── LanguageCatalogTests.cs # PR3: fixture index, install/update/offline/mismatch/local/story 5
+├── LanguageProjectTests.cs # PR3: xx fixture instead of fr.json
+├── Fixtures/Languages/ # PR1: v2 fixtures (valid, broken, plural mismatch); PR3: index fixture
+└── LocalizationAllowList.txt # unchanged entries; paths unchanged
+
+scripts/loc-migrate.py # PR1: new; PR3: deleted
+
+nota-translations/ # PR2 (layout: research R7)
+```
+
+**Structure Decision**: localization core stays in `Nota.Application/Localization`
+(pure, testable); network and disk for languages go to `Nota.Infrastructure/Languages`,
+beside `ModelStore`, reusing `RegistryClient`; UI stays in `Nota.App`.
+
+## Risks
+
+| Risk | Mitigation |
+|---|---|
+| PR 1 touches 243 files: merge conflicts with open branches | land it in a quiet window; the script is re-runnable on a rebased tree (`--plan` reuses `keymap.tsv`) |
+| Regex rewrite misses or mangles a call | the script fails on any unparsed `Loc.` call; `--verify` compares old vs new texts for every site; smoke test unused/missing key checks |
+| Key names poor after auto-generation | `keymap.tsv` review before `--apply`; renames are cheap until PR 2 publishes keys |
+| C# and Python validators drift | shared fixture verdicts (R11) |
+| Actions bot bypass on `main` misused | only `publish.yml` writes; it only changes `reference/` and `index.json` |
+| Users offline after the update lose French temporarily | accepted (Clarifications Q2, Q4); row and status bar explain |
+
+## Complexity Tracking
+
+None.
diff --git a/specs/077-key-based-localization/quickstart.md b/specs/077-key-based-localization/quickstart.md
new file mode 100644
index 00000000..e149bf10
--- /dev/null
+++ b/specs/077-key-based-localization/quickstart.md
@@ -0,0 +1,52 @@
+# Quickstart: validating key-based texts and downloadable languages
+
+Prerequisites: a Release build (`scripts/build.sh`), `gh` signed in, Python 3.
+Use a throw-away data root: `export NOTA_DATA_DIR=$(mktemp -d)`.
+
+## PR 1 — keys, no visible change (story 1, SC-001…003)
+
+Baseline (pre-migration) commit: `7b58fe881bc6503e0ff7508dc1bd4c180dc909bd` (`origin/develop`, 2026-11-04).
+
+1. Before migrating, capture reference screens in English and French with the headless shots
+ harness (`NOTA_UI_LANGUAGE=en` / `fr`), every window of the nota-docs shot list.
+2. `python3 scripts/loc-migrate.py --plan` → review `keymap.tsv`; then
+ `python3 scripts/loc-migrate.py --apply`.
+3. `scripts/build.sh` → green; the localization block of the smoke test reports keys used =
+ keys in `en.json`, 0 contexts, 0 text-keyed calls.
+4. `python3 scripts/loc-migrate.py --verify <pre-migration commit>` → for every old call
+ site, `en[new key]` equals the old English text and `fr[new key]` the old French value:
+ 0 differences. Re-capture the screens and compare with step 1 as a spot check (SC-002).
+5. Change one English value in `en.json`, rebuild, run in French → same French text; smoke
+ test green (SC-001).
+6. Add `Loc.T("nope.missing")` → smoke test fails naming the key; add an unused key to
+ `en.json` → fails naming it.
+
+## PR 2 — nota-translations (story 2, SC-004)
+
+1. `gh workflow run publish.yml --repo nota-daw/nota-translations` → `reference/develop.json`
+ and `index.json` appear on `main`, committed by the bot.
+2. Open a PR that breaks a placeholder in `languages/fr.json` → `check.yml` fails naming the
+ key, in < 5 min; fix it → passes and reports French coverage.
+3. Run `tools/validate.py --fixtures` and the app smoke test's fixture parity check → same
+ verdicts.
+
+## PR 3 — downloading (stories 3–5, SC-005…008)
+
+Serve a test copy: `python3 -m http.server -d <nota-translations checkout>` and
+`export NOTA_LANGUAGES_URL=http://127.0.0.1:8000` (layout `<base>/main/index.json`,
+`<base>/<commit>/<path>` reproduced by the smoke fixture builder).
+
+1. Clean data dir, open Preferences → Language: English + Français · 100% (available).
+ Pick it → `Downloading…` → restart note; restart → French (SC-005).
+2. Stop the server, restart → French (SC-006); open the row → `More languages are available online`.
+3. Bump `version` and content of `fr` in the copy, restart with the server up → `Update available`.
+4. Corrupt the served file (checksum mismatch) → `Couldn't download…`, installed copy kept.
+5. Settings with `"Language": "fr"`, empty `languages/`, server up → starts in English,
+ status bar `Français is ready` + Restart → French after restart (SC-007). Server down →
+ English, row says it will download when online.
+6. **Load file…** with `tests/Nota.SmokeTest/Fixtures/Languages/xx-broken.json` → restart →
+ valid entries translated, broken ones English, problems listed.
+7. `CheckForUpdates` off → no request at start (watch the server log); **Show available
+ languages** fetches on click.
+8. Inspect the package (`.app` / installer / AppImage): only `en.json` embedded (SC-008).
+9. `scripts/build.sh` → green, including the catalog smoke checks on the local fixture.
diff --git a/specs/077-key-based-localization/research.md b/specs/077-key-based-localization/research.md
new file mode 100644
index 00000000..c18ab128
--- /dev/null
+++ b/specs/077-key-based-localization/research.md
@@ -0,0 +1,211 @@
+# Research: Key-Based Interface Texts and Downloadable Languages
+
+Decisions behind [plan.md](plan.md). Spec: [spec.md](spec.md). Builds on spec 068
+([research](../068-ui-language/research.md)); where nothing is said here, 068 stands.
+
+## What the code looks like today (measured 2026-11-04)
+
+| Fact | Value | Consequence |
+|---|---|---|
+| `Loc.T` / `F` / `Plural` calls in `src/managed` | ~4,630 in 243 files | migration must be a tool, not hand edits |
+| `Loc.FC` calls | 0 | `FC` is removed, not migrated |
+| `Loc.T(text, context)` calls / `\|` keys in `fr.json` | 3 / 4 | contexts become distinct keys by hand-checked rule |
+| Calls whose text argument is not a literal | 1 (`TExtension.ProvideValue`) | every key is statically visible; the smoke test's regexes already find all of them |
+| `{app:T …}` uses in `.axaml` | 118 | XAML is migrated by the same tool |
+| `Loc.Plural` calls / plural entries in `fr.json` | ~60 / 53 | plural keys need a plural object in `en.json` |
+| Interpolated text inside `Loc.T/F` | 0 (smoke test forbids it) | no call needs restructuring |
+| Plural rules | hard-coded per code in `UiLanguage.Plural` (`fr` ⇒ 0 and 1 are one) | a downloaded language must bring its rule (R6) |
+| Existing downloader | `RegistryClient.DownloadAsync(url, size, sha256, …)`, used by `ModelStore` with staging + swap | reused for languages (R8) |
+| Update-check setting | `Settings.CheckForUpdates` (default on) | language checks follow it (R10) |
+
+## R1 — File format: key-based JSON
+
+**Decision**: JSON, `formatVersion: 2`, `strings` keyed by stable keys; a value is a string or
+`{ "one": …, "other": … }` (more categories later). The same shape for `en.json` (embedded),
+repository files and local files. `TranslationTable` keeps its validation and gains
+key-format and plural-rule checks. *(Confirmed in spec Clarifications Q1.)*
+
+**Rationale**: the app downloads files at run time, which JSON already does; plurals already
+work; JSON key/value with plural objects is a first-class format in Weblate and Crowdin
+("i18next JSON v4"-like); diffs stay clean; no dependency.
+
+**Alternatives**: `.resx` + `ResourceManager` — compiled into satellite assemblies, a
+downloaded `.resx` needs an extra reader (`System.Resources.Extensions`), no plurals, noisy
+XML. gettext `.po` — good tooling but a parser dependency or a hand-written one, and
+msgid-as-key is the very scheme being left. Avalonia resource dictionaries — XAML only.
+
+## R2 — Key naming
+
+**Decision**: `area.segment[.segment…]`, each segment `[a-z0-9_]+`, at least two segments,
+≤ 80 characters: regex `^[a-z0-9_]+(\.[a-z0-9_]+)+$`.
+
+- First segment = area, from the file that uses it: `PreferencesWindow*.cs` → `preferences`,
+ `ArrangementView*.cs` → `arrangement`, `Controls/<Device>Views.cs` → `device.<device>`,
+ `MainWindow*.cs` → `main`, `*Menu*` → `menu`, etc. The mapping is a table in the
+ migration tool, reviewed once.
+- Optional second segment = sub-area from the partial-file suffix
+ (`PreferencesWindow.Language.cs` → `preferences.language`).
+- Last segment = a slug of the English text: lower-case, ASCII words joined by `_`,
+ first ≤ 6 words, punctuation and `{n}` dropped (`"Applies after restart"` →
+ `applies_after_restart`, `"Delete {0} clips?"` → `delete_clips`).
+- Suffixes for roles where one text has several: `.tooltip`, `.title`, `.placeholder`.
+- **Shared texts**: an identical English text (same plural shape) used in ≥ 3 areas gets
+ `common.<slug>` (`common.cancel`, `common.save`), so translators translate "Cancel" once.
+ Used in 2 areas → two keys (cheap, and the meanings often drift).
+- Collisions after slugging get `_2`, `_3`, which the review step renames.
+- The 3 context calls / 4 `|` keys become separate keys named by their context
+ (`menu.file.open` vs `clip.open`).
+
+**Rationale**: readable at the call site (the slug carries the English meaning), groupable
+by translators, stable when English text changes. A key is never derived again after the
+migration: renaming English text keeps its key.
+
+**Alternatives**: purely semantic hand-chosen keys for 3,600 texts — weeks of naming;
+hash keys — unreadable; keeping English as key plus a separate id — the problem not solved.
+
+## R3 — Call-site API
+
+**Decision**:
+
+```csharp
+Loc.T("preferences.language.restart")
+Loc.F("arrangement.delete_clips_confirm", count)
+Loc.Plural("arrangement.selection.tracks", n) // n is {0}; key holds { one, other }
+{app:T preferences.language.title} // XAML
+```
+
+`FC` and every `context` parameter are removed. The English one/other strings disappear
+from `Plural` calls (they live in `en.json`). English is built into `Loc`: `en.json` is embedded in
+`Nota.Application` next to `Loc`, so English is there before `Install`, in every test
+that never installs a language, and in projects that do not reference `Nota.App` (the smoke
+test does not); `Install(table, code)` keeps its 068 signature. A key missing even from English (cannot happen past
+the smoke test) shows the key and logs once.
+
+**No generated constants / source generator** in this feature: it needs a Roslyn generator
+project (build-time dependency, `Microsoft.CodeAnalysis`), and the smoke test already
+proves every key exists. Can be added later without touching `en.json`.
+
+## R4 — Migration tool
+
+**Decision**: `scripts/loc-migrate.py` (Python 3 standard library only, like the other
+`scripts/*.py`). Steps, each re-runnable on a clean tree:
+
+1. Scan `src/managed/**/*.cs` and `*.axaml` with the same patterns as
+ `DesignTokenCheck.Localization.cs` (`LocT`, `LocF`, `LocPlural`, `LocXaml`); fail on any
+ call it cannot parse (there are none today).
+2. Build the text → key map (R2), write `keymap.tsv` (text, context, plural, files, key)
+ for review; a hand-edited `keymap.tsv` is read back on the next run, so reviewed names
+ stick.
+3. Write `Nota.Application/Localization/en.json` (`formatVersion: 2`, keys sorted by area) and convert
+ `Languages/fr.json` through the map (orphans reported, not carried).
+4. Rewrite call sites in place, keeping formatting; rewrite `Plural(n, "one", "other")` to
+ `Plural("key", n)`.
+
+The tool lives in the repository for the length of this feature (PR 1 and review fixes) and
+is deleted in PR 3; `keymap.tsv` is not committed.
+
+**Alternatives**: a Roslyn-based C# tool — exact but adds `Microsoft.CodeAnalysis` for a
+one-off; hand edits — not reviewable.
+
+## R5 — English as the reference
+
+**Decision**: `src/managed/Nota.Application/Localization/en.json` is embedded in `Nota.Application` and loaded by `Loc` itself; it holds every key,
+English text, plural shape. Its **key-set hash** = SHA-256 (hex, first 16 chars) over the
+sorted lines `key \t shape \t placeholders` (`shape` = `text` or `plural`, `placeholders` =
+sorted `{n}` indices). Changing only English wording keeps the hash; adding / removing a
+key, switching text↔plural or changing placeholders changes it. Contributor rule (in
+`CONTRIBUTING.md`): changing a text's placeholders or meaning ⇒ new key.
+
+## R6 — Plural rules travel with the file
+
+**Decision**: a language file names its rule: `"plural": "one_is_1"` (English, German…),
+`"one_is_0_1"` (French). The app implements the named rules (`UiLanguage.Plural(rule, n)`);
+an unknown rule is a load error for that file (language not offered). New languages that
+need `few` / `many` add a rule id in a later app version and say so in the README.
+
+**Alternatives**: a CLDR rule expression in the file — needs an expression evaluator;
+per-code rules in the app (today) — breaks "add a language without an app release".
+
+## R7 — Repository layout and publication
+
+**Decision** for `nota-daw/nota-translations` (`main`):
+
+```
+README.md translator guide
+LICENSE AGPL-3.0-only text
+languages/<code>.json one file per language (formatVersion 2), never English
+reference/<ver>.json en.json of Nota release <ver>; reference/develop.json = develop head
+index.json generated — what the app reads
+tools/validate.py the checks (stdlib Python)
+tools/sync_references.py
+.github/workflows/check.yml PRs: validate every language against every reference
+.github/workflows/publish.yml push to main / schedule / dispatch: sync references, regenerate index.json, commit
+```
+
+- **References are pulled, not pushed**: `publish.yml` lists `nota` tags `v*` and the
+ `develop` branch through the public API and fetches `src/managed/Nota.Application/Localization/en.json`
+ at each one lacking a reference (daily schedule + `workflow_dispatch`). No cross-repository
+ secret. The nota release workflow is unchanged; the `release` skill gains a step "run
+ publish in nota-translations" for an immediate sync.
+- `publish.yml` commits to `main` as `github-actions[bot]`: the ruleset `main: PR, squash`
+ gets the GitHub Actions integration as a bypass actor.
+- `develop.json` lets translators work on keys before they ship; the app uses it only in dev
+ builds (version `0.0.0-dev`).
+
+## R8 — How the app downloads
+
+**Decision**: `LanguageCatalog` (Infrastructure, next to `ModelStore`):
+
+- Reads `https://raw.githubusercontent.com/nota-daw/nota-translations/main/index.json`
+ (`NOTA_LANGUAGES_URL` overrides the base, for tests and staging).
+- Each language entry pins `commit`, `path`, `size`, `sha256`; the file URL is
+ `…/nota-translations/<commit>/<path>`, so the hash always matches what is fetched (no race
+ with a newer `main`).
+- `RegistryClient.DownloadAsync` with size + sha256; staging file + atomic move into
+ `<data>/languages/<code>.json`, with `<code>.meta.json` (`source: repository`, `commit`,
+ `sha256`, `version`). A failed download leaves the installed copy.
+- Fit: the app computes its own key-set hash from embedded `en.json` (R5); it picks the
+ entry's coverage for that hash; if the hash is not in `index.json`, the coverage of the
+ newest older reference is shown (Clarifications Q3). The file is the same either way —
+ unknown keys are ignored, missing ones are English.
+
+## R9 — Local files
+
+**Decision**: "Load file…" stores the path in `<data>/languages/<code>.meta.json` with
+`source: local` (the file is read in place at each start, so a translator edits and
+restarts). Problems are listed in the Language row and the log. `NOTA_UI_LANGUAGE` accepts
+a code or a path to a language file (screenshots in nota-docs and nota-site use French
+without installing it).
+
+## R10 — Network policy
+
+**Decision**:
+
+- Listing available languages fetches `index.json` when the Language row is shown (at most
+ once per run, cached), and at launch with the daily update check when
+ `CheckForUpdates` is on.
+- `CheckForUpdates = false` ⇒ no request Nota starts on its own: the row shows installed
+ languages and a **Show available languages** button that fetches on click; the automatic
+ download of a stored but missing language (story 5) becomes a **Download French** button.
+- Downloads only on a user choice, or for story 5 when checks are on. Nothing is executed;
+ files are parsed and validated as data.
+
+## R11 — Validation in two places
+
+**Decision**: `tools/validate.py` in nota-translations and `TranslationTable` in the app
+implement [contracts/language-file.md](contracts/language-file.md). Drift is caught by
+shared fixtures: `tests/Nota.SmokeTest/Fixtures/Languages/` holds valid and invalid files
+with the expected verdict; the same fixture set is copied into `nota-translations/tools/fixtures`
+and both checks must agree.
+
+**Alternatives**: running a .NET tool from the app repo in the translations CI — one
+implementation, but every translator PR builds .NET and checks out nota.
+
+## R12 — What the smoke test checks after each PR
+
+| PR | Checks |
+|---|---|
+| 1 | every key used in `.cs` / `.axaml` exists in `en.json`; no unused `en.json` key; key regex; `Plural` keys are plural objects, `T`/`F` keys are not; `F` placeholders consistent; embedded `fr.json` (v2) coverage + placeholders as today; raw-literal ratchet unchanged |
+| 3 | the same minus embedded `fr`; catalog against a local fixture index (install, checksum mismatch, offline, update offered, remove, local file with errors, stored-but-missing language); fixture parity (R11) |
+
+`LanguageProjectTests` switches from `fr.json` to the `xx` fixture in PR 3.
diff --git a/specs/077-key-based-localization/spec.md b/specs/077-key-based-localization/spec.md
new file mode 100644
index 00000000..776dc328
--- /dev/null
+++ b/specs/077-key-based-localization/spec.md
@@ -0,0 +1,385 @@
+# Feature Specification: Key-Based Interface Texts and Downloadable Languages
+
+**Feature Branch**: `feat/key-based-localization`
+
+**Created**: 2026-11-04
+
+**Status**: Draft
+
+**Issue**: [nota-daw/nota#476](https://github.com/nota-daw/nota/issues/476) (approved)
+
+**Input**: User description: "Implement GitHub issue nota-daw/nota#476 (approved): rework interface localization. (1) Priority: migrate from English-text-as-key to stable key-based strings with en.json embedded in the app as the source of truth, a key naming convention, a migration script that generates keys, rewrites the call sites and converts fr.json; smoke-test checks move to keys. (2) Translations move to the new repository nota-daw/nota-translations (default branch main, AGPL-3.0-only, index.json listing languages with coverage and the app versions they fit, one file per language, CI there validating each language against the matching en.json); fr moves there. (3) The app ships English only; Preferences → Language lists languages from the repository and downloads the chosen one into the user data directory, works offline with installed languages, offers updates, verifies a checksum, lets a translator load a local file, falls back to English for any missing key, applies after restart. Decide resx vs key-based JSON. Out of scope: new languages, number culture, RTL, live language switch. Builds on spec 068-ui-language."
+
+## Nota Context *(fill in — drives plan and tasks)*
+
+**Feature area** *(pick the main one)*:
+
+- [ ] Engine (C++, `src/native/nota.engine`) — real-time audio rules apply, see `ARCHITECTURE.md` AR table
+- [x] Managed app (C#, `src/managed/*`) — domain, application, infrastructure, presentation
+- [ ] UI (Avalonia, `src/managed/Nota.Presentation`) — follow `DESIGN.md` (Studio)
+- [ ] Plugin hosting (`pluginhost/`) — the only place JUCE is allowed
+- [x] Build / packaging / CI (`scripts/`, `.github/`) — see `BUILD.md`
+- [ ] Docs only
+
+**Nota docs to keep in mind** *(links relative to `specs/<slug>/`, where this file lands)*:
+[`ARCHITECTURE.md`](../../ARCHITECTURE.md) (AR rules),
+[`CONTRIBUTING.md`](../../CONTRIBUTING.md) (licensing, dependency policy, PR
+expectations), [`BUILD.md`](../../BUILD.md), [`DESIGN.md`](../../DESIGN.md),
+[`FEATURES.md`](../../FEATURES.md).
+
+**Current state (for reference)** — spec [`068-ui-language`](../068-ui-language/spec.md):
+
+- Every interface text goes through one lookup (`Loc.T` / `F` / `FC` / `Plural`), about
+ 4,600 calls in 243 files. **The key is the English text itself**; a word with two
+ meanings gets a `"text|context"` suffix.
+- English needs no file: it is written at the call site. French lives in
+ `Nota.App/Languages/fr.json` (~3,650 entries), embedded into the app. The picker in
+ Preferences → Appearance → Language lists whatever files are embedded; a change applies
+ after a restart.
+- The smoke test checks that every key used in the source has a French entry, that none
+ is orphaned, that placeholders match, and keeps a shrink-only ratchet of raw literals
+ (`LocalizationAllowList.txt`).
+- Consequence: rewording, fixing a typo in or re-punctuating any English text silently
+ detaches it from every translation; adding or fixing a translation needs a pull request
+ to the app and a release.
+- The repository `nota-daw/nota-translations` exists (empty; `main`, squash-only, PR
+ required). Translations there are AGPL-3.0-only, like the app.
+
+## Clarifications
+
+### Session 2026-11-04
+
+- Q: Which format do language files use — key-based JSON (current parser adapted), `.resx` + `ResourceManager`, or gettext `.po`? → A: Key-based JSON with plural objects; the current parser moves to keys. `.resx` and `.po` are rejected.
+- Q: Once the app stops embedding French, does it keep any embedded copy as an offline fallback? → A: No. The app embeds English only; every other language, French included, is downloaded. A user offline on the first launch after updating runs in English until the language arrives (story 5).
+- Q: How does the app know which translation version fits its own version? → A: Each Nota release publishes its English reference to `nota-translations` as `reference/<version>.json` with a hash of its key set. The repository's checks validate each language against the references of every supported version. The app takes the translation checked against a reference with its own key-set hash, else the one checked against the nearest older reference.
+- Q: When a stored language is not installed yet (an update from a version with embedded French), is the downloaded language applied on the same launch or after a restart? → A: After a restart. Nota starts in English without waiting for the network, downloads the language in the background, and the Language row and a quiet status-bar notice say it is ready, with a Restart button.
+- Q: How is the work split into pull requests and releases? → A: Three pull requests. (1) nota: keys and `en.json`, French still embedded, no visible change. (2) nota-translations: README, LICENSE, checks, language list, `fr`, the first reference. (3) nota: downloading, the Language row, removing the embedded `fr.json`, publishing the reference from the release workflow. Pull requests 2 and 3 ship in the same release.
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Change an English text without breaking translations (Priority: P1)
+
+A contributor rewords a button ("Bounce in place" → "Bounce to new track") or fixes a
+typo in a tooltip. They edit the English text in one place. Every translation of that
+text stays attached to it; nothing in the smoke test turns red; the French screen still
+shows the (now possibly outdated) French text until a translator updates it.
+
+**Why this priority**: This is the maintenance cost the issue is about, and it grows with
+every release. It is also the prerequisite of stories 2–4: a translation kept outside
+the app needs a stable key to refer to.
+
+**Independent Test**: After the migration, change the English text of a translated entry,
+build, run the smoke test and the app in French: the build is green and the entry still
+shows its French text.
+
+**Acceptance Scenarios**:
+
+1. **Given** the migrated source, **When** a contributor changes the English text of a
+ key, **Then** only the English reference file changes, no call site changes, and every
+ language keeps its entry for that key.
+2. **Given** a new interface text, **When** a contributor adds it, **Then** they add one
+ key to the English reference file and use the key at the call site; the smoke test
+ fails if they use a key that is not in the reference file, or leave a key in it that
+ nothing uses.
+3. **Given** two places where one English word means different things ("Open" a file,
+ "Open" a clip), **When** they are migrated, **Then** they are two keys and need no
+ separate context marker.
+4. **Given** the migration is done, **When** Nota runs in English or in French, **Then**
+ every screen shows exactly the text it showed before the migration (no visible change).
+
+---
+
+### User Story 2 - Translate Nota without touching the app (Priority: P2)
+
+A translator wants to fix a French wording or start German. They open the
+`nota-translations` repository, edit or add one language file following its README and
+open a pull request. Its checks tell them, without building Nota, whether the file is
+valid against the current English reference: unknown keys, wrong placeholders, broken
+plurals, and how complete the language is.
+
+**Why this priority**: Opens translation to people who will never build a DAW, and stops
+translation fixes from waiting for an app release.
+
+**Independent Test**: Open a pull request in `nota-translations` that breaks a placeholder
+in `fr`: the check fails and names the key. Fix it: the check passes and reports French
+coverage.
+
+**Acceptance Scenarios**:
+
+1. **Given** the repository, **When** a translator reads its README, **Then** it explains
+ the file shape, the key/English reference, plurals, placeholders, how coverage is
+ counted and how to preview a file in Nota (story 4).
+2. **Given** a pull request changing a language file, **When** its checks run, **Then**
+ they validate it against the English reference of every app version the language
+ claims to fit and report coverage per language.
+3. **Given** a merge to `main`, **When** the checks pass, **Then** the language list the
+ app reads is updated (coverage, checksum) without manual edits.
+4. **Given** the French translation that lived in the app, **When** this feature ships,
+ **Then** it lives in `nota-translations` and no longer in the app repository.
+
+---
+
+### User Story 3 - Get a language from Preferences (Priority: P2)
+
+A user opens Preferences → Appearance → Language. Besides English they see the languages
+available for their Nota version, each with its own name and how complete it is. They
+pick Français: Nota downloads it, the row says it applies after a restart (as today), and
+after the restart the interface is in French. Later, offline, Nota still starts in French.
+When a better French translation is published, Nota offers to update it.
+
+**Why this priority**: The user-facing half of moving translations out of the app; until
+it ships, users of non-English languages must not lose them (see story 5).
+
+**Independent Test**: With a clean data directory, choose Français, restart, check the
+interface is French; disconnect the network, restart, still French; publish a newer `fr`
+in a test copy of the repository, check Nota offers the update.
+
+**Acceptance Scenarios**:
+
+1. **Given** Nota online, **When** the user opens the Language setting, **Then** it lists
+ English plus every language available for this Nota version, with name and coverage,
+ and marks which are already installed.
+2. **Given** the user picks a language not installed, **When** the download succeeds and
+ the file checks out, **Then** it is stored in the user data directory and the restart
+ prompt appears as it does today; **When** the download fails or the file does not check
+ out, **Then** the row says so in place, nothing is stored and the running language is
+ unchanged.
+3. **Given** a language installed, **When** Nota starts offline, **Then** it starts in that
+ language; the setting still lists installed languages.
+4. **Given** Nota offline or the repository unreachable, **When** the user opens the
+ setting, **Then** it lists English and the installed languages and says that more are
+ available online — never an error dialog.
+5. **Given** a newer version of an installed language that fits this Nota version, **When**
+ Nota learns of it, **Then** the Language row offers an update; nothing is downloaded
+ until the user agrees.
+6. **Given** any text missing from the installed language, **When** it is shown, **Then**
+ it is shown in English — never blank, never as a key.
+
+---
+
+### User Story 4 - Preview a translation in progress (Priority: P3)
+
+A translator working on a language file wants to see it in Nota before publishing. In the
+Language setting they load a local file; after a restart Nota runs in it. Problems in the
+file (unknown keys, bad placeholders) are listed so they can fix them.
+
+**Why this priority**: Makes translation work verifiable without a pull request or a
+build; needed by few users.
+
+**Independent Test**: Load a local file with one broken placeholder and one valid entry:
+Nota starts in it, the valid entry shows translated, the broken one in English, and the
+problem is reported.
+
+**Acceptance Scenarios**:
+
+1. **Given** a local language file, **When** the user loads it, **Then** it becomes the
+ running language after a restart and is marked as local (not updated from the
+ repository).
+2. **Given** a local file with errors, **When** it is loaded, **Then** each problem is
+ reported with its key, the broken entries fall back to English and Nota still starts.
+
+---
+
+### User Story 5 - Existing French users keep French after updating (Priority: P1)
+
+A user who chose Français before this feature updates Nota. Nota gets French from the
+repository on the first launch and keeps showing French. If it cannot, it says so in
+place and runs in English until it can.
+
+**Why this priority**: Shipping English only must not take the interface language away
+from people who already use it.
+
+**Independent Test**: With settings saying `fr` and no installed language, start the new
+build online: it starts in English, offers a restart once French is installed, and runs
+in French after it. Offline: it runs in
+English and the Language row explains why.
+
+**Acceptance Scenarios**:
+
+1. **Given** a stored language that is not installed, **When** Nota starts online, **Then**
+ it starts in English without waiting, downloads that language in the background and,
+ once it is installed, the Language row and a quiet status-bar notice say it is ready
+ with a **Restart** button (the usual save prompt for unsaved work); after the restart
+ Nota runs in it.
+2. **Given** the same offline, **When** Nota starts, **Then** it runs in English, keeps the
+ stored choice, and the Language row says the language will be downloaded when online.
+
+---
+
+### Edge Cases
+
+- A language file published for an older Nota version: keys that no longer exist are
+ ignored, new keys show in English; the coverage shown is for the running version.
+- A language whose file does not fit the running version at all (format too new): it is
+ not offered, and an installed copy is not used; Nota runs in English and says why.
+- The download is interrupted, truncated or its checksum does not match: nothing replaces
+ the installed copy.
+- Two Nota instances or versions sharing one data directory: an installed language never
+ breaks the version that did not download it.
+- The repository list is unreachable or malformed: the setting falls back to installed
+ languages, with no dialog.
+- A key used in the source is missing from the English reference: the build (smoke test)
+ fails, so this never reaches a user.
+- A translated value uses a placeholder its English text does not have: the entry shows
+ in English and the problem is reported (smoke test for published languages, CI in the
+ repository, the in-app report for local files).
+- The user removes an installed language while it runs: it stays in use until restart,
+ then English.
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+**Keys (story 1)**
+
+- **FR-001**: Every interface text MUST be looked up by a stable key, not by its English
+ text. Contexts (`"text|context"`) MUST disappear; two meanings are two keys.
+- **FR-002**: The English text of every key MUST live in one English reference file in the
+ app repository, embedded in the app; it is the only place English interface text is
+ written.
+- **FR-003**: Keys MUST follow a documented naming convention (lower-case, dot-separated,
+ area first, e.g. `settings.audio.buffer_size`, `mixer.track.mute.tooltip`), described in
+ `CONTRIBUTING.md`.
+- **FR-004**: The switch MUST be done by a repeatable migration tool that generates keys,
+ rewrites the call sites and converts the French file, so the change is mechanical and
+ reviewable; generated keys MUST be unique and follow FR-003.
+- **FR-005**: After the migration every screen MUST show, in English and in French, the
+ same text as before it (no visible change).
+- **FR-006**: The smoke test MUST fail when a key used in the source is missing from the
+ English reference, when the reference has a key nothing uses, when a reference entry's
+ plural shape does not match how it is used, or when the raw-literal ratchet grows.
+- **FR-007**: Plurals and placeholders MUST keep today's behaviour: one whole pattern per
+ text, the language's plural rule picks the form, a value that cannot be formatted falls
+ back to English.
+
+**Translations repository (story 2)**
+
+- **FR-008**: `nota-daw/nota-translations` MUST hold one file per language (not English),
+ a language list (code, own name, coverage, checksum, the Nota versions it fits) and a
+ README for translators.
+- **FR-009**: Each pull request in that repository MUST be checked against the English
+ reference of the Nota versions the language fits: valid shape, unknown keys reported,
+ placeholders and plural forms valid, coverage computed. Failures MUST name the key.
+- **FR-010**: Each Nota release MUST publish its English reference to the repository as
+ `reference/<version>.json` together with a hash of its key set, without a manual copy
+ step. A language fits a Nota version when it passed the checks against a reference with
+ that version's key-set hash; versions whose keys did not change share one hash and need
+ no new publication.
+- **FR-011**: The language list MUST be produced from the files by the repository's checks,
+ not edited by hand.
+- **FR-012**: The French translation MUST move to that repository and leave the app
+ repository; its history of who translated it SHOULD be kept in the move.
+- **FR-013**: Files in the repository MUST be AGPL-3.0-only, stated in the repository.
+
+**Getting languages (stories 3, 5)**
+
+- **FR-014**: The app MUST ship with English only — no embedded copy of any other
+ language, not even as an offline fallback.
+- **FR-015**: Preferences → Appearance → Language MUST list English, installed languages
+ and, when reachable, the languages available for the running Nota version, with own
+ name, coverage and installed / update-available state.
+- **FR-016**: Choosing a language not installed MUST download it only on that choice,
+ verify its checksum and fit, store it in the user data directory, and keep today's
+ "applies after a restart" behaviour.
+- **FR-017**: An installed language MUST work offline; Nota MUST never need the network to
+ start.
+- **FR-018**: Nota MUST offer, not perform, an update when a newer fitting version of an
+ installed language exists; checking for one MUST follow the existing update-check
+ setting (no network request when the user has turned checks off, beyond one the user
+ triggers).
+- **FR-019**: A failed list, download or check MUST be reported in place in the Language
+ row; it MUST NOT change the running language or replace an installed copy.
+- **FR-020**: Any key missing or broken in the running language MUST show in English.
+- **FR-021**: A user whose stored language is not installed (an update from a version with
+ embedded French) MUST get it automatically when online, in the background, without
+ delaying start-up; it applies after a restart offered in the Language row and the status
+ bar (story 5). Offline — or with update checks turned off, where the row offers a
+ **Download** button instead (FR-018) — Nota runs in English, keeps the stored choice and
+ says why.
+- **FR-022**: The user MUST be able to remove an installed language.
+
+**Local files (story 4)**
+
+- **FR-023**: The user MUST be able to load a local language file as the running language;
+ it is marked local and never replaced by a download.
+- **FR-024**: Problems in a loaded file MUST be reported per key; Nota MUST still start.
+
+**Format**
+
+- **FR-025**: Language files MUST use one format for the English reference, the
+ repository and local files, readable by common translation tools: key/value JSON (`"settings.title": "Settings…"`) with plural objects
+ (`{ "one": …, "other": … }`). `.resx` and gettext `.po` are not used.
+
+### Key Entities
+
+- **Key**: stable identifier of one interface text (`settings.title`); never shown.
+- **English reference**: every key with its English text and plural shape; embedded in the
+ app; published per release as `reference/<version>.json` with its key-set hash.
+- **Language file**: one language's translations of keys, plus code, own name, format
+ version and translator notes; may be partial.
+- **Language list**: what the repository offers — per language: code, own name, coverage,
+ checksum, version, the key-set hashes (English references) it was checked against.
+- **Installed language**: a language file in the user data directory with where it came
+ from (repository version or local) — what Nota loads at start.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: Changing the English text of any key touches exactly one file and leaves 100%
+ of the existing translations of that key attached.
+- **SC-002**: After the migration, a screen-by-screen comparison in English and French
+ shows zero changed texts.
+- **SC-003**: Zero interface texts are looked up by their English text; zero contexts
+ remain.
+- **SC-004**: A translator can fix a French entry and see the check result on their pull
+ request without building Nota, in under 5 minutes of check time.
+- **SC-005**: A user picks a language and has it running after one restart, with the
+ download taking under 10 seconds on a typical connection.
+- **SC-006**: Nota starts in an installed language with the network off, every time.
+- **SC-007**: 100% of users who ran Nota in French before updating run it in French after
+ updating, after being online once and one restart.
+- **SC-008**: The app package contains no translation other than English.
+
+## Assumptions
+
+- **Format — key-based JSON, not `.resx`.** Spec 068 research R3 already chose JSON over
+ `.resx`. Downloadable languages tip it further: `.resx` is compiled into satellite
+ assemblies, so a file fetched at run time needs an extra reader; it has no plurals;
+ its XML diffs badly. Key/value JSON with plural objects is read by Weblate and Crowdin
+ as is. The current parser is kept and adapted rather than replaced (confirmed in
+ Clarifications).
+- **Delivery in three pull requests** (confirmed in Clarifications): (1) nota — keys and
+ the English reference, French still embedded, no user-visible change (story 1);
+ (2) nota-translations — README, licence, checks, language list, French, the first
+ English reference (story 2); (3) nota — downloading, the Language row, local files,
+ removing the embedded French, publishing the reference from the release workflow
+ (stories 3–5). Pull requests 2 and 3 ship in the same release, so no release lacks
+ French.
+- **Versions** (confirmed in Clarifications): the release workflow publishes the English
+ reference and its key-set hash (FR-010). The app asks for the newest language version
+ that fits its key-set hash; if none does, the newest one checked against the nearest
+ older reference (unknown keys ignored, new keys in English).
+- **Download source**: the app reads the language list and files over HTTPS from GitHub
+ (raw files or release assets of `nota-translations`), like the existing update check
+ reads GitHub releases. Integrity is a SHA-256 checksum in the list; signing is out of
+ scope.
+- The user data directory is the existing Nota data root (`NOTA_DATA_DIR` in tests), under
+ a `languages` folder.
+- Key naming is generated by the migration from the file/area and the English text, then
+ reviewed; renaming keys later is a normal change (it does orphan translations, which the
+ checks report).
+- `nota-docs` (EN + RU) gets a short page on choosing and previewing a language; the
+ translator guide lives in the repository README.
+- Out of scope: new languages, number culture (spec 068 R4 stays), right-to-left layout,
+ switching language without a restart, a translation platform hook-up, signing.
+
+## Nota Compliance Checklist *(review before implementation; re-check in tasks.md)*
+
+- [ ] Every new source file will carry the AGPL-3.0-only SPDX header (two lines, see CONTRIBUTING.md)
+- [x] No new dependency — or: license checked, AGPL-compatible, `LICENSES/third-party.md` row planned
+- [x] Audio-thread impact considered: no alloc / lock / I/O on the audio thread (AR-6), command queue for data in (AR-4), immutable snapshots for structural edits (AR-5) — managed UI text only; the engine is untouched
+- [x] Managed/native crossings go through the pure C ABI in `nota_engine.h` only (AR-7); no JUCE outside `pluginhost/` — no crossing
+- [ ] Smoke-test impact assessed: engine behaviour change → extend `tests/Nota.SmokeTest` — localization checks move to keys; download/install covered by smoke checks on a local fixture
+- [ ] User-visible change → `CHANGELOG.md` `[Unreleased]` entry planned (and FEATURES.md / user docs via the nota-features / nota-docs skills when working with an agent that has them)
+- [ ] UI change → follows `DESIGN.md` (Studio design language) — the Language row grows (list, coverage, download/update/remove, load local file)
diff --git a/specs/077-key-based-localization/tasks.md b/specs/077-key-based-localization/tasks.md
new file mode 100644
index 00000000..22645ac6
--- /dev/null
+++ b/specs/077-key-based-localization/tasks.md
@@ -0,0 +1,226 @@
+---
+
+description: "Tasks for 077 key-based interface texts and downloadable languages"
+---
+
+# Tasks: Key-Based Interface Texts and Downloadable Languages
+
+**Input**: Design documents from `specs/077-key-based-localization/`
+
+**Prerequisites**: [plan.md](plan.md), [spec.md](spec.md), [research.md](research.md),
+[data-model.md](data-model.md), [contracts/](contracts/), [quickstart.md](quickstart.md)
+
+**Tests**: Included. The spec makes the smoke test part of the feature (FR-006, research
+R12), and the constitution makes it the PR gate.
+
+**Organization**: by user story; the stories map onto the three pull requests of the plan
+(US1 → PR 1 in nota, US2 → PR 2 in nota-translations, US3 + US5 + US4 → PR 3 in nota).
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: can run in parallel (different files, no dependency on an unfinished task)
+- **[Story]**: US1…US5 from spec.md
+- Paths: nota paths are relative to the nota repository root; `nota-translations/…` paths
+ are relative to a checkout of `nota-daw/nota-translations`.
+
+---
+
+## Phase 1: Setup
+
+**Purpose**: baseline for the "no visible change" proof and the migration tool skeleton.
+
+- [X] T001 Record the pre-migration commit SHA of `develop` in `specs/077-key-based-localization/quickstart.md` § PR 1 (the `--verify` baseline), and capture English + French reference screens with the headless shots harness (`NOTA_UI_LANGUAGE=en` / `fr`) into `/tmp/nota-077-before/` (not committed)
+- [X] T002 Create `scripts/loc-migrate.py` (SPDX header; Python 3 stdlib only) with the CLI `--plan`, `--apply`, `--verify <commit>` and a module docstring citing research R4; no logic yet
+
+---
+
+## Phase 2: Foundational (blocks every story)
+
+**Purpose**: the format-v2 language layer the app, the migration and the repository checks all share.
+
+- [X] T003 Rework `src/managed/Nota.Application/Localization/TranslationTable.cs` to contract `contracts/language-file.md`: `formatVersion` must be `2` (1 and higher rejected with the message "language file format N is not supported"); `code` lower-case BCP-47 primary tag equal to the file name; keys must match `^[a-z0-9_]+(\.[a-z0-9_]+)+$` and be ≤ 80 chars; required `plural` (except `en`); values a non-empty string or `{ "other" required, "one" optional }`; invalid entries go to a `Problems` list `(key, problem)` instead of failing the file; remove `KeyOf(text, context)`
+- [X] T004 Add key-shape and placeholder validation against a reference table to `TranslationTable` (`ValidateAgainst(TranslationTable english)`): shape mismatch (text vs plural), `other` must use exactly the reference's placeholders, `one` may drop but not add, unknown keys reported; returns problems and coverage percent (`translated valid entries of reference keys ÷ reference keys`, rounded down)
+- [X] T005 Add `KeySetHash` to `TranslationTable`: SHA-256, lower-case hex, first 16 chars, over the ordinally sorted lines `key \t (text|plural) \t sorted placeholder indices joined by ","` joined with `\n` (contract language-file § Key-set hash)
+- [X] T006 [P] Replace per-code plural rules in `src/managed/Nota.Application/Localization/UiLanguage.cs` with rule ids: `Plural(string rule, long n)` for `one_is_1` and `one_is_0_1`, `IsKnownRule(string)`; keep `Normalize` / `IsPending`
+- [X] T007 Rework `src/managed/Nota.Application/Localization/Loc.cs` to `contracts/loc-api.md`: English built in: `en.json` embedded in `Nota.Application` (logical name `Nota.Localization.en.json`) and loaded lazily by `Loc`; `Install(TranslationTable? table, string code)` unchanged; `T(key)`, `F(key, args)`, `Plural(key, n)` with lookup running → English → key (+ one log line per key via a `MissingKey` event); plural form by the running table's `PluralRule`; remove `FC` and every `context` parameter; keep the format fallback and `UsedBeforeInstall`
+- [X] T008 [P] Update `src/managed/Nota.App/TExtension.cs` to a key-only markup extension (`{app:T menu.file.save_as}`), removing `Context`; update its header comment
+- [X] T009 [P] Write v2 fixtures in `tests/Nota.SmokeTest/Fixtures/Languages/`: `en-ref.json` (small reference), `xx.json` (valid, `one_is_1`), `xx-broken.json` (bad placeholder, shape mismatch, unknown key, empty value), `xx-v1.json` (format 1, rejected), `xx-badrule.json` (unknown `plural`), plus `verdicts.json` listing each file's expected load result, problems and coverage (shared with nota-translations, research R11)
+- [X] T010 Rewrite `DesignTokenCheck.RunLanguage` in `tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs` for v2: fixture verdicts from `verdicts.json`, plural rules by id, key-set hash stable under English wording change and changed by key add/remove/shape/placeholder change, lookup fallback running → English → key
+
+**Implementation notes (PR 1)**: English moved to `src/managed/Nota.Application/Localization/en.json`, embedded beside `Loc` (the smoke test and other projects that do not reference `Nota.App` need English too). Keys shared by exactly two groups get a key per group; `common.*` from three groups (research R2). T001: before-screens were not captured; instead `--verify` proves text equality per call site, and a headless harness (main window, native menu, 10 Preferences pages, mixer, EN + FR) found no key shown and no missing-key event. T021: the allow-list did not change (2644 entries, none stale). T020 also accepts `string.Format(culture, Loc.T(key), …)` (4 call sites format with `NotaNum.Culture`). The render-pool "overloaded" smoke checks flaked while the machine was busy; an idle rerun passed.
+
+**Checkpoint**: the language layer builds and its smoke checks pass on fixtures; call sites are not migrated yet (the build is red until US1's rewrite lands — do Phase 2 and US1 on one branch).
+
+---
+
+## Phase 3: User Story 1 — Change an English text without breaking translations (P1) 🎯 MVP · PR 1
+
+**Goal**: every interface text is looked up by a stable key; `en.json` is the only English source; French still embedded; nothing visible changes.
+
+**Independent test**: quickstart § PR 1 steps 3–6.
+
+### Migration tool
+
+- [X] T011 [US1] Implement scanning in `scripts/loc-migrate.py`: port the `LocT`, `LocF`, `LocPlural`, `LocXaml` patterns from `tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs` (lines ~196–203) over `src/managed/**/*.cs` and `src/managed/**/*.axaml`; collect (text, context, plural one/other, file, line); exit non-zero listing any `Loc.` call it cannot parse (excluding `TExtension.cs`)
+- [X] T012 [US1] Implement key generation (research R2) in `scripts/loc-migrate.py`: area table from file name (`PreferencesWindow*` → `preferences`, `ArrangementView*` → `arrangement`, `Controls/<X>Views.cs` → `device.<x>`, `MainWindow*` → `main`, menus → `menu`, … — unknown file → fail with the file name so the table is extended); sub-area from the partial suffix; slug = first ≤ 6 ASCII words of the English text, lower-case, `_`-joined, punctuation and `{n}` dropped; `common.<slug>` when the same text and shape is used in ≥ 3 areas; the 3 context calls / 4 `|` keys get distinct keys by context; collisions `_2`, `_3`; every key validated against `^[a-z0-9_]+(\.[a-z0-9_]+)+$`, ≤ 80 chars
+- [X] T013 [US1] Implement `--plan` in `scripts/loc-migrate.py`: write `keymap.tsv` (text, context, plural, files, key) at the repo root (git-ignored via `.gitignore`); read an existing `keymap.tsv` back so hand-renamed keys stick; validate uniqueness after edits
+- [X] T014 [US1] Implement `--apply` in `scripts/loc-migrate.py`: write `src/managed/Nota.Application/Localization/en.json` (`formatVersion: 2`, `code: en`, `name: English`, keys grouped by area, sorted), convert `src/managed/Nota.App/Languages/fr.json` to v2 (`plural: one_is_0_1`, keys via the map, `notes` updated, orphans printed not carried), rewrite call sites in place (`Loc.T("text"[, "ctx"])` → `Loc.T("key")`, `Loc.F("text", …)` → `Loc.F("key", …)`, `Loc.Plural(n, "one", "other"[, ctx])` → `Loc.Plural("key", n)`, `{app:T 'text'[, Context=c]}` → `{app:T key}`), preserving surrounding formatting
+- [X] T015 [US1] Implement `--verify <commit>` in `scripts/loc-migrate.py`: for every call site at `<commit>` and its migrated counterpart, assert `en[key]` equals the old English (and plural one/other) and `fr[key]` equals the old French value; print differences and exit non-zero if any
+
+### Run the migration
+
+- [X] T016 [US1] Run `python3 scripts/loc-migrate.py --plan`, review `keymap.tsv` area by area (rename unclear keys, merge true duplicates into `common.*`), re-run `--plan` until clean
+- [X] T017 [US1] Run `python3 scripts/loc-migrate.py --apply`; build; fix any call site the rewrite left uncompilable by hand (list them in the PR description)
+- [X] T018 [US1] Update `src/managed/Nota.App/Languages/NotaLanguages.cs` to offer English from `Loc.English` (no `en.json` in `Nota.App/Languages` any more) plus the embedded `fr.json`, log an English load error if any; and `src/managed/Nota.App/App.axaml.cs` `TranslateAppMenu` to look the macOS app-menu texts up by key; add the `EmbeddedResource` for `Localization/en.json` to `src/managed/Nota.Application/Nota.Application.csproj`
+- [X] T019 [US1] Run `python3 scripts/loc-migrate.py --verify <T001 SHA>` → 0 differences; spot-check screens against `/tmp/nota-077-before/` (SC-002)
+
+### Smoke checks on keys
+
+- [X] T020 [US1] Rewrite `DesignTokenCheck.RunLocalization` in `tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs`: extract key literals from `Loc.T/F/Plural` and `{app:T key}`; fail on a computed (non-literal) key, a key missing from `en.json`, an `en.json` key used nowhere, a `Plural` key that is not a plural object or a `T`/`F` key that is one, `F` placeholders not matching the English pattern; keep French coverage / orphan / placeholder checks against the embedded `fr.json` (until US3); keep the raw-literal ratchet
+- [X] T021 [US1] Regenerate `tests/Nota.SmokeTest/LocalizationAllowList.txt` with `NOTA_LOC_WRITE_BASELINE=1` only if line matching changed; the list must not grow (diff reviewed)
+- [X] T022 [P] [US1] Update `tests/Nota.SmokeTest/LanguageProjectTests.cs` to parse the v2 `fr.json` with the new `TranslationTable.Parse`
+
+### Contributor docs
+
+- [X] T023 [P] [US1] Rewrite `CONTRIBUTING.md` § Translating Nota (or the interface-text section): keys and the naming convention (research R2), adding a text = one `en.json` entry + `Loc.T("key")`, changing wording edits only `en.json`, changing meaning or placeholders = new key, plurals, no contexts; mention `nota-translations` as "coming in the next release" (finalised in T053)
+- [X] T024 [P] [US1] Update the header comments of `Loc.cs`, `TranslationTable.cs`, `NotaLanguages.cs`, `TExtension.cs` to cite spec 077 (keys) instead of "the English source text is the key"
+
+**Checkpoint (PR 1)**: `scripts/build.sh` green; quickstart § PR 1 passes; open PR 1 (`Closes` not yet — `Part of #476`).
+
+---
+
+## Phase 4: User Story 2 — Translate Nota without touching the app (P2) · PR 2 (nota-translations)
+
+**Goal**: the repository validates languages against Nota's references and publishes `index.json`.
+
+**Independent test**: quickstart § PR 2.
+
+- [ ] T025 [P] [US2] Add `nota-translations/LICENSE` (full AGPL-3.0 text, same as nota's `LICENSE`)
+- [ ] T026 [P] [US2] Write `nota-translations/README.md`: what the repo is, file shape (link to a copy of the contract in `nota-translations/FORMAT.md`), keys and the English reference (`reference/<version>.json`, `develop.json`), plurals and rule ids, placeholders, coverage, how to open a PR, how to preview a file in Nota (Load file…), licence
+- [ ] T027 [P] [US2] Copy `specs/077-key-based-localization/contracts/language-file.md` and `contracts/index.md` into `nota-translations/FORMAT.md` (translator-facing wording, same rules)
+- [ ] T028 [US2] Write `nota-translations/tools/validate.py` (stdlib; SPDX header): implements `contracts/language-file.md` exactly as `TranslationTable` (T003–T005): parse, key regex, plural rule ids, shape/placeholder checks against each `reference/*.json`, unknown key = error when in no reference / warning when only in older ones, coverage per key-set hash; `--fixtures tools/fixtures` mode compares against `verdicts.json`; exit non-zero with `languages/<code>.json: <key> — <problem>` lines
+- [ ] T029 [P] [US2] Copy the fixtures and `verdicts.json` from `tests/Nota.SmokeTest/Fixtures/Languages/` (T009) into `nota-translations/tools/fixtures/`
+- [ ] T030 [US2] Write `nota-translations/tools/sync_references.py` (stdlib): list `nota-daw/nota` tags `v*` and the `develop` head via the public GitHub API, fetch `src/managed/Nota.Application/Localization/en.json` at each tag lacking `reference/<version>.json` (skip tags whose file is missing or format < 2), always refresh `reference/develop.json`
+- [ ] T031 [US2] Add index generation to `nota-translations/tools/validate.py` (`--write-index`): `index.json` per `contracts/index.md` — `formatVersion: 1`, `generated`, `references` (version → key-set hash), per valid language `code`, `name`, `version` (previous index version + 1 when the file's sha256 changed, else kept), `commit` (the `HEAD` being indexed), `path`, `size`, `sha256`, `coverage` per hash
+- [ ] T032 [US2] Add `nota-translations/.github/workflows/check.yml`: on pull_request → `python3 tools/validate.py --fixtures tools/fixtures` and `python3 tools/validate.py languages/*.json`; job name `check`
+- [ ] T033 [US2] Add `nota-translations/.github/workflows/publish.yml`: on push to `main`, daily schedule, `workflow_dispatch` → sync references, validate, write index, commit `reference/` + `index.json` as `github-actions[bot]` only if changed; the commit's own SHA is not the indexed one, so index `commit` = the content commit before the bot commit (document in the workflow)
+- [ ] T034 [US2] Move French: `git mv`-equivalent import of `src/managed/Nota.App/Languages/fr.json` (v2, from PR 1) into `nota-translations/languages/fr.json`, with the commit message crediting its translators from `git log --format='%an' -- src/managed/Nota.App/Languages/fr.json` in nota (FR-012)
+- [ ] T035 [US2] Repository settings via `gh api`: add the GitHub Actions integration (id 15368) as a bypass actor to ruleset `main: PR, squash` (id 26514643); after the first green `check` run, add `check` as a required status check
+- [ ] T036 [US2] Push the initial content (README, LICENSE, FORMAT, tools, workflows, `languages/fr.json`) as the first commit on `main` (sets the default branch), run `gh workflow run publish.yml`, confirm `reference/develop.json` and `index.json` land; then open a test PR breaking a placeholder → `check` fails naming the key; close it
+
+**Checkpoint (PR 2)**: quickstart § PR 2 passes.
+
+---
+
+## Phase 5: User Story 3 — Get a language from Preferences (P2) · PR 3
+
+**Goal**: the app lists, downloads, updates and removes languages; ships English only.
+
+**Independent test**: quickstart § PR 3 steps 1–4, 7–8.
+
+- [ ] T037 [P] [US3] Create `src/managed/Nota.Infrastructure/Languages/InstalledLanguages.cs`: root `<data>/languages` (from `NotaPaths`); per code `<code>.json` + `<code>.meta.json` `{ "source": "repository" | "local", "path"?, "version"?, "commit"?, "sha256"?, "installed" }`; `List()`, `Load(code)` (repository → file, local → stored path), `InstallFrom(stagingFile, meta)` with atomic move, `Remove(code)`, cleanup of leftover `.staging-<code>.json` on start
+- [ ] T038 [US3] Create `src/managed/Nota.Infrastructure/Languages/LanguageCatalog.cs`: fetch `<base>/main/index.json` (`<base>` = `https://raw.githubusercontent.com/nota-daw/nota-translations`, `NOTA_LANGUAGES_URL` overrides) once per run (cached); ignore an index with a higher `formatVersion` major ("update Nota to see more languages"); fit by own key-set hash, else the newest reference with version ≤ the app's (contracts/index.md § App behaviour); `DownloadAsync(entry)` via `RegistryClient.DownloadAsync(<base>/<commit>/<path>, size, sha256, staging, …)`, then parse + validate before `InstalledLanguages.InstallFrom`; any failure leaves the installed copy
+- [ ] T039 [US3] Register `LanguageCatalog` and `InstalledLanguages` in the app's service setup (where `ModelStore` is registered) and expose `UpdateAvailable(code)` comparing installed `version` with the index
+- [ ] T040 [US3] Update `src/managed/Nota.App/Languages/NotaLanguages.cs`: offered languages = embedded English + `InstalledLanguages.List()`; `Find(code)` loads installed files through `TranslationTable.Parse` + `ValidateAgainst(english)` (problems logged); no network on this path
+- [ ] T041 [US3] Rebuild `src/managed/Nota.App/PreferencesWindow.Language.cs` per `contracts/language-row.md`: combo items English / installed (`· 97%` muted, or `· local file`) / separator / available (`· 82%` + download glyph); picking an available one downloads with inline `Downloading…` progress, then the existing restart note; failure `Couldn't download <Name> — <reason>` and the combo returns to the running language; `Update available` + **Update**; **Remove**; `More languages are available online` when the index is unreachable; follows `DESIGN.md` (Studio) — every new text via `Loc.T` with new keys in `en.json`
+- [ ] T042 [US3] Network policy (research R10) in `PreferencesWindow.Language.cs` and the launch path: fetch the index when the row is shown, and at launch with the daily update check only when `Settings.CheckForUpdates` is on; when off, show **Show available languages** (fetch on click) and never request on Nota's own initiative
+- [ ] T043 [US3] Remove `src/managed/Nota.App/Languages/fr.json` and its embedding: `src/managed/Nota.App/Nota.App.csproj` embeds no language file (remove the `Languages\*.json` item and its comment at line ~56)
+- [ ] T044 [US3] Smoke: create `tests/Nota.SmokeTest/LanguageCatalogTests.cs` with an in-process `HttpMessageHandler` serving a fixture index + files (`tests/Nota.SmokeTest/Fixtures/Languages/index/`): list + fit + coverage, install, checksum mismatch keeps the old copy, higher index `formatVersion` ignored, offline → installed only, update offered when `version` grows, remove, `CheckForUpdates` off → zero requests at start; wire into `tests/Nota.SmokeTest/Program.cs`
+- [ ] T045 [US3] Smoke: in `DesignTokenCheck.RunLocalization` drop the embedded-French coverage checks (French is validated in nota-translations) and add "the app embeds only `en.json`" (SC-008); switch `tests/Nota.SmokeTest/LanguageProjectTests.cs` from `fr.json` to the `xx.json` fixture
+
+**Checkpoint**: quickstart § PR 3 steps 1–4, 7–8 pass.
+
+---
+
+## Phase 6: User Story 5 — Existing French users keep French after updating (P1) · PR 3
+
+**Goal**: a stored but missing language is fetched in the background and applied after a restart.
+
+**Independent test**: quickstart § PR 3 step 5.
+
+*P1 but placed after US3: it is built on the catalog and installed store from US3.*
+
+- [ ] T046 [US5] In `src/managed/Nota.App/App.axaml.cs` after the main window is shown: if `Settings.Language` ≠ `en`, has no valid installed file and `CheckForUpdates` is on, download it in the background through `LanguageCatalog` (start-up never waits); on success raise a "language ready" state shared with the Language row
+- [ ] T047 [US5] Show the "<Name> is ready" + **Restart** notice once per run in the status bar in `src/managed/Nota.App/MainWindow.Updates.cs` (same pattern as the app update notice), and in the Language row; offline / checks off → row text `<Name> will be downloaded when Nota is online` or **Download <Name>** (contracts/language-row.md)
+- [ ] T048 [US5] Smoke in `tests/Nota.SmokeTest/LanguageCatalogTests.cs`: stored `fr`, empty `languages/` → English this run, background install, ready state set; handler offline → English, stored choice kept, no install
+
+---
+
+## Phase 7: User Story 4 — Preview a translation in progress (P3) · PR 3
+
+**Goal**: load a local file as the running language and see its problems.
+
+**Independent test**: quickstart § PR 3 step 6.
+
+- [ ] T049 [US4] Add **Load file…** to `src/managed/Nota.App/PreferencesWindow.Language.cs`: file picker for `.json`, parse + validate against English, store `source: local` + path through `InstalledLanguages`, select it, restart note; list up to 10 `key — problem` lines then `…and N more (see the log)`; a local language is never replaced by a download
+- [ ] T050 [US4] `NOTA_UI_LANGUAGE` accepts a path to a language file as well as a code (this run only, never saved) in `App.axaml.cs` `InstallLanguage`; update its doc comment
+- [ ] T051 [US4] Smoke in `tests/Nota.SmokeTest/LanguageCatalogTests.cs`: local `xx-broken.json` → loads, valid entries translated, broken ones English, problems match `verdicts.json`; missing local path at start → English + problem
+
+---
+
+## Phase 8: Polish & Cross-Cutting
+
+- [ ] T052 Delete `scripts/loc-migrate.py` and the `keymap.tsv` ignore line in `.gitignore` (research R4)
+- [ ] T053 [P] Finalise `CONTRIBUTING.md` § Translating Nota: translations live in `nota-daw/nota-translations`; adding a text in the app = `en.json` only
+- [ ] T054 [P] Add the "sync references" step (`gh workflow run publish.yml --repo nota-daw/nota-translations` after the tag build) to `.claude/skills/release/SKILL.md`, then run `scripts/sync-agent-skills.sh`
+- [ ] T055 [P] Fixture parity: confirm `tests/Nota.SmokeTest/Fixtures/Languages/verdicts.json` and `nota-translations/tools/fixtures/verdicts.json` are identical and both checks agree (R11)
+- [ ] T056 Run every step of `specs/077-key-based-localization/quickstart.md` and note results in the PR descriptions
+
+### Nota closing tasks *(PR gates — run for each nota PR)*
+
+- [X] T057 Run `scripts/build.sh` (and `scripts/build-linux.sh` / `scripts/build-win.ps1` via CI) until native + managed + smoke test are green
+- [X] T058 AGPL-3.0-only SPDX two-line header on every new source file (`scripts/loc-migrate.py`, `LanguageCatalog.cs`, `InstalledLanguages.cs`, `LanguageCatalogTests.cs`, nota-translations `tools/*.py`)
+- [X] T059 New dependency: none → N/A
+- [ ] T060 `CHANGELOG.md` `[Unreleased]`: PR 1 → none (no user-visible change; mention in the PR); PR 3 → Changed "Languages other than English are downloaded from Preferences → Language and kept up to date; the app ships with English only" + Added "Load a language file to preview a translation"
+- [ ] T061 FEATURES.md via the `nota-features` skill and the user manual via `nota-docs` (EN + RU page on choosing, updating and previewing a language; shots harness uses `NOTA_UI_LANGUAGE=<path>` for French); `nota-docs/scripts/shortcuts.mjs` reads `PreferencesWindow.ShortcutGroups` by literal text — make it resolve `Loc.T("key")` through `src/managed/Nota.Application/Localization/en.json` (needed as soon as PR 1 is on `develop`); shortcuts: N/A
+- [X] T062 Engine behaviour change: none → N/A
+
+---
+
+## Dependencies & Execution Order
+
+### Phase dependencies
+
+- **Setup (1)** → **Foundational (2)** → **US1 (3)**. Phase 2 and US1 share a branch: the build is red between T007 and T017.
+- **US2 (4)** needs US1 merged (it publishes v2 keys from `develop`).
+- **US3 (5)** needs US2's `index.json` to exist (tests use fixtures, but the release needs the real repo).
+- **US5 (6)** needs US3 (T037–T040). **US4 (7)** needs T037 and T040.
+- **Polish (8)** after the stories of each PR; T052–T054 in PR 3.
+
+### Pull requests
+
+| PR | Tasks |
+|---|---|
+| 1 (nota) | T001–T024, T057–T059, T062 |
+| 2 (nota-translations) | T025–T036 |
+| 3 (nota) | T037–T056, T057–T062 |
+
+### Within each story
+
+Language layer before call sites; store before catalog; catalog before UI; smoke checks
+written with the code they cover.
+
+### Parallel opportunities
+
+- Phase 2: T006, T008, T009 alongside T003–T005.
+- US1: T022, T023, T024 alongside the migration run (different files).
+- US2: T025, T026, T027, T029 together; T028/T030/T031 sequential (same tool files).
+- US3: T037 alongside T038's design; T044 can be written against the contracts before T041.
+- PR 2 can be built while PR 1 is in review (on a v2 `fr.json` produced by the script).
+
+## Parallel example: User Story 2
+
+```bash
+Task: "Add nota-translations/LICENSE"
+Task: "Write nota-translations/README.md"
+Task: "Write nota-translations/FORMAT.md from the contracts"
+Task: "Copy fixtures into nota-translations/tools/fixtures/"
+```
+
+## Implementation strategy
+
+1. **MVP = PR 1 (US1)**: keys everywhere, `en.json` as source, French still embedded. It
+ delivers the issue's priority and stands alone — stop and validate with quickstart § PR 1.
+2. **PR 2 (US2)**: repository and checks; no app change, safe to merge any time after PR 1.
+3. **PR 3 (US3 + US5 + US4)**: downloads, then the upgrade path, then local preview; merge
+ only with PR 2 live, and ship PR 2's content and PR 3 in the same release.
diff --git a/src/managed/Nota.App/AboutWindow.cs b/src/managed/Nota.App/AboutWindow.cs
index aa89bd1f..3c4cc845 100644
--- a/src/managed/Nota.App/AboutWindow.cs
+++ b/src/managed/Nota.App/AboutWindow.cs
@@ -19,7 +19,7 @@ public sealed class AboutWindow : NotaWindow
public AboutWindow()
{
var build = App.Services.GetRequiredService<EngineBuildInfo>();
- Title = Loc.T("About Nota");
+ Title = Loc.T("common.about_nota");
Width = 380;
Height = 348; // + title-bar band
CanResize = false;
@@ -56,18 +56,18 @@ public sealed class AboutWindow : NotaWindow
};
brand.Children.Add(new TextBlock
{
- Text = Loc.T("Nota"), FontSize = 26, FontWeight = FontWeight.SemiBold,
+ Text = Loc.T("common.nota"), FontSize = 26, FontWeight = FontWeight.SemiBold,
Foreground = Brush("Brush.TextPrimary"),
});
brand.Children.Add(new TextBlock
{
Classes = { "Caption" },
- Text = Loc.F("Version {0}", AppInfo.Version),
+ Text = Loc.F("common.version", AppInfo.Version),
});
brand.Children.Add(new TextBlock
{
Classes = { "Caption" },
- Text = Loc.F("Engine {0}", build.Version),
+ Text = Loc.F("about.engine", build.Version),
});
Grid.SetColumn(brand, 1);
header.Children.Add(brand);
@@ -75,24 +75,24 @@ public sealed class AboutWindow : NotaWindow
panel.Children.Add(new TextBlock
{
Classes = { "Caption" },
- Text = Loc.T("Desktop DAW · AGPLv3"),
+ Text = Loc.T("about.desktop_daw_agplv3"),
});
panel.Children.Add(new TextBlock
{
Classes = { "Caption" },
Margin = new Thickness(0, 8, 0, 0),
- Text = Loc.T("© 2026 Egor Khindikaynen (Ambertape)"),
+ Text = Loc.T("about.2026_egor_khindikaynen_ambertape"),
});
panel.Children.Add(new TextBlock
{
Classes = { "Caption" },
- Text = Loc.T("Free software under the GNU AGPLv3."),
+ Text = Loc.T("about.free_software_under_the_gnu"),
});
panel.Children.Add(new TextBlock
{
Classes = { "Caption" },
TextWrapping = TextWrapping.Wrap,
- Text = Loc.T("Includes third-party software (JUCE, Avalonia, miniaudio, RtMidi, dr_libs, Signalsmith, HIIR). See LICENSES/THIRD-PARTY-NOTICES.md for copyright and attribution notices."),
+ Text = Loc.T("about.includes_third_party_software_juce"),
});
SetBody(panel);
}
diff --git a/src/managed/Nota.App/App.axaml.cs b/src/managed/Nota.App/App.axaml.cs
index 27193ed2..c5c2d183 100644
--- a/src/managed/Nota.App/App.axaml.cs
+++ b/src/managed/Nota.App/App.axaml.cs
@@ -207,7 +207,9 @@ public partial class App : Avalonia.Application
/// is the default everywhere (spec 068). An unknown code reads as English.</summary>
private static void InstallLanguage(Settings settings, ILogSink log)
{
- foreach (var err in NotaLanguages.LoadErrors) log.Error($"Language skipped — {err}", null);
+ foreach (var err in NotaLanguages.LoadErrors) log.Error($"Interface language — {err}", null);
+ // A key in no table, not even English, shows as itself: the smoke test rules it out.
+ Loc.MissingKey += key => log.Warn($"Interface text key not found: {key}");
var wanted = Environment.GetEnvironmentVariable("NOTA_UI_LANGUAGE");
var code = UiLanguage.Normalize(string.IsNullOrWhiteSpace(wanted) ? settings.Language : wanted, NotaLanguages.Codes);
// A text asked for before this point was built in English and will not follow the language.
@@ -220,16 +222,17 @@ public partial class App : Avalonia.Application
}
// App.axaml is loaded in Initialize(), before the language is installed, so the macOS
- // application menu's few texts are set here, once it is. Keyed by their English text.
+ // application menu's few texts are set here, once it is: each item is found by its English
+ // header in App.axaml and given the text of its key.
private void TranslateAppMenu()
{
if (NativeMenu.GetMenu(this) is not { } menu) return;
foreach (var item in menu.Items.OfType<NativeMenuItem>())
item.Header = item.Header switch
{
- "About Nota" => Loc.T("About Nota"),
- "Check for updates…" => Loc.T("Check for updates…"),
- "Settings…" => Loc.T("Settings…"),
+ "About Nota" => Loc.T("common.about_nota"),
+ "Check for updates…" => Loc.T("common.check_for_updates"),
+ "Settings…" => Loc.T("app.settings"),
var other => other,
};
}
diff --git a/src/managed/Nota.App/AppUpdates.cs b/src/managed/Nota.App/AppUpdates.cs
index 905e4c50..5488fd5e 100644
--- a/src/managed/Nota.App/AppUpdates.cs
+++ b/src/managed/Nota.App/AppUpdates.cs
@@ -153,7 +153,7 @@ internal sealed class AppUpdates
State = Stage.Downloading;
Dismissed = false;
Error = null;
- Progress = new StoreProgress(0, Loc.F("Downloading Nota {0}…", release.Version));
+ Progress = new StoreProgress(0, Loc.F("common.downloading_nota", release.Version));
Changed?.Invoke();
var progress = new Progress<StoreProgress>(p =>
{
@@ -171,7 +171,7 @@ internal sealed class AppUpdates
catch (Exception e)
{
App.Services.GetRequiredService<ILogSink>().Error("Update download failed", e);
- Fail(Loc.F("Couldn't download the update: {0}", e.Message));
+ Fail(Loc.F("app_updates.couldnt_download_the_update", e.Message));
}
finally
{
diff --git a/src/managed/Nota.App/ArrangementView.AutoEditor.cs b/src/managed/Nota.App/ArrangementView.AutoEditor.cs
index d55725e2..4e8636f1 100644
--- a/src/managed/Nota.App/ArrangementView.AutoEditor.cs
+++ b/src/managed/Nota.App/ArrangementView.AutoEditor.cs
@@ -326,10 +326,10 @@ public sealed partial class ArrangementView
{
bool hasSel = _o.HasAutoSelection && ReferenceEquals(_o._autoSelTrack, t);
var flyout = new MenuFlyout();
- var copy = MenuKit.Item(Loc.T("Copy automation"), GlyphKind.Copy, () => _o.CopyAutoSelection(), MenuKit.CopyKey, hasSel);
- var cut = MenuKit.Item(Loc.T("Cut automation"), GlyphKind.Cut, () => _o.CutAutoSelection(), MenuKit.CutKey, hasSel);
- var paste = MenuKit.Item(Loc.T("Paste automation"), GlyphKind.Paste, () => _o.PasteAutoAt(t, _o.Snap(beat)), MenuKit.PasteKey, _o.HasAutoClip);
- var del = MenuKit.Danger(Loc.T("Delete automation"), GlyphKind.Trash, () => _o.DeleteAutoSelection(), MenuKit.DeleteKey, hasSel);
+ var copy = MenuKit.Item(Loc.T("arrangement.auto_editor.copy_automation"), GlyphKind.Copy, () => _o.CopyAutoSelection(), MenuKit.CopyKey, hasSel);
+ var cut = MenuKit.Item(Loc.T("arrangement.auto_editor.cut_automation"), GlyphKind.Cut, () => _o.CutAutoSelection(), MenuKit.CutKey, hasSel);
+ var paste = MenuKit.Item(Loc.T("arrangement.auto_editor.paste_automation"), GlyphKind.Paste, () => _o.PasteAutoAt(t, _o.Snap(beat)), MenuKit.PasteKey, _o.HasAutoClip);
+ var del = MenuKit.Danger(Loc.T("arrangement.auto_editor.delete_automation"), GlyphKind.Trash, () => _o.DeleteAutoSelection(), MenuKit.DeleteKey, hasSel);
MenuKit.AddGroups(flyout.Items, new Control[] { copy, cut, paste }, new Control[] { del });
flyout.ShowAt(_owner, showAtPointer: true);
}
diff --git a/src/managed/Nota.App/ArrangementView.Automation.cs b/src/managed/Nota.App/ArrangementView.Automation.cs
index 797236c2..ccecc9dd 100644
--- a/src/managed/Nota.App/ArrangementView.Automation.cs
+++ b/src/managed/Nota.App/ArrangementView.Automation.cs
@@ -25,14 +25,14 @@ public sealed partial class ArrangementView
private string AutoLabelFor(TrackVM t) => t.AutoChain >= 0 && _engine is { } ne ? Short(NestedParam(ne, t).Name) : t.AutoTarget switch
{
- AutomationTarget.Volume => Loc.T("Vol"),
- AutomationTarget.Pan => Loc.T("Pan"),
- AutomationTarget.Send => Loc.F("Send {0} · {1}", SendLetter(t.AutoDeviceIndex), Short(SendBusName(t.AutoDeviceIndex))),
+ AutomationTarget.Volume => Loc.T("arrangement.vol"),
+ AutomationTarget.Pan => Loc.T("common.pan"),
+ AutomationTarget.Send => Loc.F("arrangement.send", SendLetter(t.AutoDeviceIndex), Short(SendBusName(t.AutoDeviceIndex))),
AutomationTarget.PluginParam => _engine is { } e
- ? Short(e.PluginParamName(t.Id, t.AutoDeviceIndex, ResolvePluginParamIndex(t))) : Loc.T("Param"),
+ ? Short(e.PluginParamName(t.Id, t.AutoDeviceIndex, ResolvePluginParamIndex(t))) : Loc.T("arrangement.automation.param"),
AutomationTarget.MidiDeviceParam => _engine is { } e
- ? Short(e.MidiEffectParamName(t.Id, t.AutoDeviceIndex, t.AutoParamIndex)) : Loc.T("Param"),
- _ => _engine is { } e ? Short(e.DeviceParamName(t.Id, t.AutoDeviceIndex, t.AutoParamIndex)) : Loc.T("Param"),
+ ? Short(e.MidiEffectParamName(t.Id, t.AutoDeviceIndex, t.AutoParamIndex)) : Loc.T("arrangement.automation.param"),
+ _ => _engine is { } e ? Short(e.DeviceParamName(t.Id, t.AutoDeviceIndex, t.AutoParamIndex)) : Loc.T("arrangement.automation.param"),
};
private static string Short(string s) => s.Length <= 10 ? s : s.Substring(0, 10);
@@ -435,12 +435,12 @@ public sealed partial class ArrangementView
if (top.Count > 0) flyout.Items.Add(new Separator());
}
- flyout.Items.Add(Leaf(Loc.T("Volume"), "V", () => SetAutoTarget(t, AutomationTarget.Volume, -1, -1), automated));
- flyout.Items.Add(Leaf(Loc.T("Pan"), "PAN", () => SetAutoTarget(t, AutomationTarget.Pan, -1, -1), automated));
+ flyout.Items.Add(Leaf(Loc.T("common.volume"), "V", () => SetAutoTarget(t, AutomationTarget.Volume, -1, -1), automated));
+ flyout.Items.Add(Leaf(Loc.T("common.pan"), "PAN", () => SetAutoTarget(t, AutomationTarget.Pan, -1, -1), automated));
// One send per return (specs/072); returns themselves send nowhere.
if (!t.IsReturn)
foreach (var (bus, name) in SendBuses())
- flyout.Items.Add(Leaf(Loc.F("Send {0} · {1}", SendLetter(bus), name), $"S:{bus}",
+ flyout.Items.Add(Leaf(Loc.F("arrangement.send", SendLetter(bus), name), $"S:{bus}",
() => SetAutoTarget(t, AutomationTarget.Send, bus, -1), automated));
if (_engine is { } e)
{
@@ -454,7 +454,7 @@ public sealed partial class ArrangementView
// filterable picker + Learn.
flyout.Items.Add(e.TrackInstrumentKind(t.Id) >= 0
? BuildBuiltinInstrumentAutoMenu(e, t, automated)
- : BuildPluginTargetMenu(e, t, -1, Loc.T("Instrument")));
+ : BuildPluginTargetMenu(e, t, -1, Loc.T("common.instrument")));
}
int devCount = e.TrackDeviceCount(t.Id);
bool sepAdded = false;
@@ -500,8 +500,8 @@ public sealed partial class ArrangementView
{
g = new MenuItem
{
- Header = bkind is 0 or 13 && int.TryParse(head, out _) ? Loc.F("Band {0}", head)
- : bkind == 17 && head.Length == 2 && head[0] == 'S' && char.IsDigit(head[1]) ? Loc.F("Stage {0}", head[1])
+ Header = bkind is 0 or 13 && int.TryParse(head, out _) ? Loc.F("arrangement.automation.band", head)
+ : bkind == 17 && head.Length == 2 && head[0] == 'S' && char.IsDigit(head[1]) ? Loc.F("arrangement.automation.stage", head[1])
: head,
};
groups[head] = g; devMenu.Items.Add(g);
@@ -668,9 +668,9 @@ public sealed partial class ArrangementView
private string AutoLaneLabelTop(IAudioEngine e, TrackVM t, AutomationLaneInfo info, int laneIndex) => info.Target switch
{
- AutomationTarget.Volume => Loc.T("Volume"),
- AutomationTarget.Pan => Loc.T("Pan"),
- AutomationTarget.Send => Loc.F("Send {0} · {1}", SendLetter(info.DeviceIndex), SendBusName(info.DeviceIndex)),
+ AutomationTarget.Volume => Loc.T("common.volume"),
+ AutomationTarget.Pan => Loc.T("common.pan"),
+ AutomationTarget.Send => Loc.F("arrangement.send", SendLetter(info.DeviceIndex), SendBusName(info.DeviceIndex)),
AutomationTarget.MidiDeviceParam => $"{e.MidiEffectName(t.Id, info.DeviceIndex)} · {e.MidiEffectParamName(t.Id, info.DeviceIndex, info.ParamIndex)}",
AutomationTarget.PluginParam => $"{e.DeviceName(t.Id, info.DeviceIndex)} · {PluginParamNameById(e, t, info.DeviceIndex, e.AutomationLaneParamId(t.Id, laneIndex))}",
_ => $"{e.DeviceName(t.Id, info.DeviceIndex)} · {e.DeviceParamName(t.Id, info.DeviceIndex, info.ParamIndex)}",
@@ -801,9 +801,9 @@ public sealed partial class ArrangementView
private MenuItem BuildPluginTargetMenu(IAudioEngine e, TrackVM t, int deviceIndex, string name)
{
var menu = new MenuItem { Header = name };
- var choose = new MenuItem { Header = Loc.T("Choose parameter…") };
+ var choose = new MenuItem { Header = Loc.T("arrangement.automation.choose_parameter") };
choose.Click += (_, _) => ShowPluginParamPicker(t, deviceIndex, name);
- var learn = new MenuItem { Header = Loc.T("Learn (touch a control in the plugin)") };
+ var learn = new MenuItem { Header = Loc.T("arrangement.automation.learn_touch_a_control_in") };
learn.Click += (_, _) => StartLearn(t, deviceIndex);
menu.Items.Add(choose);
menu.Items.Add(learn);
@@ -819,7 +819,7 @@ public sealed partial class ArrangementView
for (int i = 0; i < n; i++)
all.Add((e.PluginParamId(t.Id, deviceIndex, i), e.PluginParamName(t.Id, deviceIndex, i)));
- var filter = new TextBox { PlaceholderText = Loc.T("Filter parameters…"), Margin = new Thickness(0, 0, 0, 6) };
+ var filter = new TextBox { PlaceholderText = Loc.T("arrangement.automation.filter_parameters"), Margin = new Thickness(0, 0, 0, 6) };
var list = new ListBox { MaxHeight = 260, Width = 260 };
void Rebuild(string q)
{
diff --git a/src/managed/Nota.App/ArrangementView.Controls.cs b/src/managed/Nota.App/ArrangementView.Controls.cs
index e89fc2d1..85fe3d58 100644
--- a/src/managed/Nota.App/ArrangementView.Controls.cs
+++ b/src/managed/Nota.App/ArrangementView.Controls.cs
@@ -127,11 +127,11 @@ public sealed partial class ArrangementView
{
var flyout = new MenuFlyout();
bool has = _o._loopE > _o._loopS;
- var toggle = new MenuItem { Header = _o._loopActive ? Loc.T("Turn loop off") : Loc.T("Turn loop on"), Icon = MenuKit.Icon(GlyphKind.Cycle), InputGesture = MenuKit.LoopKey };
+ var toggle = new MenuItem { Header = _o._loopActive ? Loc.T("arrangement.controls.turn_loop_off") : Loc.T("arrangement.controls.turn_loop_on"), Icon = MenuKit.Icon(GlyphKind.Cycle), InputGesture = MenuKit.LoopKey };
toggle.Click += (_, _) => _o.SetLoopOn(!_o._loopActive);
- var sel = new MenuItem { Header = Loc.T("Loop selection"), Icon = MenuKit.Icon(GlyphKind.Select), IsEnabled = _o.SelectionLoopRange() is not null };
+ var sel = new MenuItem { Header = Loc.T("arrangement.loop_selection"), Icon = MenuKit.Icon(GlyphKind.Select), IsEnabled = _o.SelectionLoopRange() is not null };
sel.Click += (_, _) => { if (_o.SelectionLoopRange() is { } r) _o.SetLoopRegion(r.Start, r.End); };
- var clear = MenuKit.Danger(Loc.T("Clear loop region"), GlyphKind.Trash, () => _o.ClearLoopRegion(), enabled: has);
+ var clear = MenuKit.Danger(Loc.T("arrangement.controls.clear_loop_region"), GlyphKind.Trash, () => _o.ClearLoopRegion(), enabled: has);
flyout.Items.Add(toggle);
flyout.Items.Add(sel);
flyout.Items.Add(new Separator());
@@ -449,7 +449,7 @@ public sealed partial class ArrangementView
var pts = _o._masterAuto;
if (pts.Count == 0)
{
- var hint = new FormattedText(Loc.T("click to add master volume points"), CultureInfo.InvariantCulture,
+ var hint = new FormattedText(Loc.T("arrangement.controls.click_to_add_master_volume"), CultureInfo.InvariantCulture,
FlowDirection.LeftToRight, Typeface.Default, 9, AutomationText);
ctx.DrawText(hint, new Point(12, my + (mh - hint.Height) / 2));
}
diff --git a/src/managed/Nota.App/ArrangementView.KeyMoves.cs b/src/managed/Nota.App/ArrangementView.KeyMoves.cs
index c2b804ef..2236b7b9 100644
--- a/src/managed/Nota.App/ArrangementView.KeyMoves.cs
+++ b/src/managed/Nota.App/ArrangementView.KeyMoves.cs
@@ -47,19 +47,19 @@ public partial class ArrangementView
{
// Rows are what ⌥↑/⌥↓ step through, and a folded group's children have none: moving
// only the shown clips would split the block, so the whole move is refused.
- StatusMessage?.Invoke(Loc.T("Unfold the group to move these clips across tracks"));
+ StatusMessage?.Invoke(Loc.T("arrangement.key_moves.unfold_the_group_to_move"));
return true;
}
int shift = ArrangementMoves.RowShift(block.Select(b => b.row).Distinct().ToList(), _tracks.Count, dir, TakesClipsFrom);
if (shift == 0)
{
- StatusMessage?.Invoke(dir < 0 ? Loc.T("No track above takes these clips") : Loc.T("No track below takes these clips"));
+ StatusMessage?.Invoke(dir < 0 ? Loc.T("arrangement.key_moves.no_track_above_takes_these") : Loc.T("arrangement.key_moves.no_track_below_takes_these"));
return true;
}
var moves = block.Select(b => (b.track, b.clip, _tracks[b.row + shift].Id, b.start)).ToArray();
if (MoveBlock(moves) is not { } move) return true;
if (_engine.LastMoveKeptDeviceAutomation())
- StatusMessage?.Invoke(Loc.T("Moved across tracks — device automation stayed on the source"));
+ StatusMessage?.Invoke(Loc.T("arrangement.moved_across_tracks_device_automation"));
Refresh();
ReselectPlaced(move);
ClipsMoved?.Invoke(move);
diff --git a/src/managed/Nota.App/ArrangementView.LaneControl.cs b/src/managed/Nota.App/ArrangementView.LaneControl.cs
index f0deaaa8..17ea10f0 100644
--- a/src/managed/Nota.App/ArrangementView.LaneControl.cs
+++ b/src/managed/Nota.App/ArrangementView.LaneControl.cs
@@ -721,7 +721,7 @@ public sealed partial class ArrangementView
move = _o.MoveBlock(moves.ToArray());
committed = move is not null;
if (committed && eng.LastMoveKeptDeviceAutomation()) // explicit hint: only Volume/Pan followed across tracks (req 8.3.4)
- _o.StatusMessage?.Invoke(Loc.T("Moved across tracks — device automation stayed on the source"));
+ _o.StatusMessage?.Invoke(Loc.T("arrangement.moved_across_tracks_device_automation"));
}
_groupMove = null; _drag = Drag.None; _moveRowDelta = 0;
e.Pointer.Capture(null);
@@ -800,7 +800,7 @@ public sealed partial class ArrangementView
_loadRow = row;
_o.SetDropTrack(row);
_o.DwellOverTrack(row >= 0 ? _o._tracks[row].Id : -1);
- if (row >= 0) _o.StatusMessage?.Invoke(Loc.F("Release to load the clip into {0}", _o._tracks[row].Name));
+ if (row >= 0) _o.StatusMessage?.Invoke(Loc.F("arrangement.lane_control.release_to_load_the_clip", _o._tracks[row].Name));
}
// The grabbed clip's audio as a sample file (null + a status line when it can't be).
@@ -808,7 +808,7 @@ public sealed partial class ArrangementView
{
string name = clip.Name.Length > 0 ? clip.Name : _o._tracks.Find(t => t.Id == _grabTrackId)?.Name ?? "";
try { return ClipAudioExport.AsSample(eng, _grabTrackId, clip.ClipIndex, name); }
- catch (Exception ex) { _o.StatusMessage?.Invoke(Loc.F("Couldn't take the clip's audio: {0}", ex.Message)); return null; }
+ catch (Exception ex) { _o.StatusMessage?.Invoke(Loc.F("arrangement.lane_control.couldnt_take_the_clips_audio", ex.Message)); return null; }
}
// Hands the move over to a sample drag: the clip snaps back home and its audio rides
@@ -957,7 +957,7 @@ public sealed partial class ArrangementView
private MenuItem? PasteBouncedItem(int trackId, double at)
{
if (!_o.CanPasteBouncedOnto(trackId)) return null;
- var mi = new MenuItem { Header = Loc.T("Paste bounced audio"), Icon = MenuKit.Icon(GlyphKind.Paste), InputGesture = MenuKit.PasteBouncedKey };
+ var mi = new MenuItem { Header = Loc.T("common.paste_bounced_audio"), Icon = MenuKit.Icon(GlyphKind.Paste), InputGesture = MenuKit.PasteBouncedKey };
mi.Click += (_, _) => _o.RequestPasteBounced(trackId, at);
return mi;
}
@@ -985,18 +985,18 @@ public sealed partial class ArrangementView
foreach (var mi in clipboard) flyout.Items.Add(mi);
if (track.IsInstrument)
{
- var insert = new MenuItem { Header = Loc.T("Insert MIDI clip"), Icon = MenuKit.Icon(GlyphKind.Plus) };
+ var insert = new MenuItem { Header = Loc.T("arrangement.lane_control.insert_midi_clip"), Icon = MenuKit.Icon(GlyphKind.Plus) };
insert.Click += (_, _) => _o.AddMidiClipAt(trackId, beat);
flyout.Items.Add(new Separator());
flyout.Items.Add(insert);
}
if (inRange)
{
- var consolidate = new MenuItem { Header = Loc.T("Consolidate selection"), Icon = MenuKit.Icon(GlyphKind.Consolidate), InputGesture = MenuKit.ConsolidateKey };
+ var consolidate = new MenuItem { Header = Loc.T("arrangement.lane_control.consolidate_selection"), Icon = MenuKit.Icon(GlyphKind.Consolidate), InputGesture = MenuKit.ConsolidateKey };
consolidate.Click += (_, _) => _o.ConsolidateSelection();
- var dupTime = new MenuItem { Header = Loc.T("Duplicate time"), Icon = MenuKit.Icon(GlyphKind.Duplicate), InputGesture = MenuKit.DuplicateTimeKey };
+ var dupTime = new MenuItem { Header = Loc.T("common.duplicate_time"), Icon = MenuKit.Icon(GlyphKind.Duplicate), InputGesture = MenuKit.DuplicateTimeKey };
dupTime.Click += (_, _) => _o.DuplicateTimeInsert();
- var silence = new MenuItem { Header = Loc.T("Insert silence"), Icon = MenuKit.Icon(GlyphKind.Plus), InputGesture = MenuKit.InsertSilenceKey };
+ var silence = new MenuItem { Header = Loc.T("common.insert_silence"), Icon = MenuKit.Icon(GlyphKind.Plus), InputGesture = MenuKit.InsertSilenceKey };
silence.Click += (_, _) => _o.InsertSilenceAtTimeSelection();
flyout.Items.Add(new Separator());
flyout.Items.Add(consolidate);
@@ -1023,45 +1023,45 @@ public sealed partial class ArrangementView
var track = _o._tracks.FirstOrDefault(v => v.Id == trackId);
var header = inGroup
- ? MenuKit.Header(Loc.Plural(_o.Selection.Count, "{0} clip", "{0} clips"), null, "")
- : MenuKit.Header(clip.Name.Length > 0 ? clip.Name : Loc.T("Clip"),
- track is null ? null : TrackBrush(track.ColorIndex), clip.IsMidi ? Loc.T("MIDI clip") : Loc.T("Audio clip"));
+ ? MenuKit.Header(Loc.Plural("arrangement.lane_control.clips", _o.Selection.Count), null, "")
+ : MenuKit.Header(clip.Name.Length > 0 ? clip.Name : Loc.T("common.clip"),
+ track is null ? null : TrackBrush(track.ColorIndex), clip.IsMidi ? Loc.T("arrangement.lane_control.midi_clip") : Loc.T("arrangement.lane_control.audio_clip"));
- var rename = MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit,
+ var rename = MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit,
() => PromptRename(clip.Name, s => { _o._engine?.SetClipName(trackId, idx, s); _o.Refresh(); }));
var edits = new List<Control>
{
- MenuKit.Item(Loc.T("Split here"), GlyphKind.Split, () => { if (_o.SplitLinkedAt(new[] { (trackId, idx) }, at)) { _o.Refresh(); _o.ClipsSplit?.Invoke(); } }, MenuKit.SplitKey),
+ MenuKit.Item(Loc.T("arrangement.lane_control.split_here"), GlyphKind.Split, () => { if (_o.SplitLinkedAt(new[] { (trackId, idx) }, at)) { _o.Refresh(); _o.ClipsSplit?.Invoke(); } }, MenuKit.SplitKey),
};
// Reverse (audio only): non-destructive, so the label reflects the clicked clip.
if (!clip.IsMidi && _o._engine is { } rev && rev.TryGetAudioClipInfo(trackId, idx, out var rai))
- edits.Add(MenuKit.Item(rai.Reversed != 0 ? "Un-reverse" : Loc.T("Reverse"), GlyphKind.Reverse,
+ edits.Add(MenuKit.Item(rai.Reversed != 0 ? "Un-reverse" : Loc.T("common.reverse"), GlyphKind.Reverse,
() => { EnsureSelected(); _o.ToggleSelectedClipsReverse(); }));
// Consolidate: a right-click inside the time selection acts on that range; otherwise
// on the multi-selection's span, or just this clip (bakes its edits into one clip).
bool inRange = _o.TimeSelectionCovers(trackId, beat);
- edits.Add(MenuKit.Item(inRange ? Loc.T("Consolidate selection") : Loc.T("Consolidate"), GlyphKind.Consolidate,
+ edits.Add(MenuKit.Item(inRange ? Loc.T("arrangement.lane_control.consolidate_selection") : Loc.T("common.consolidate"), GlyphKind.Consolidate,
() => { if (!inRange) EnsureSelected(); _o.ConsolidateSelection(); }, MenuKit.ConsolidateKey));
// Clip deactivate (key 0): the label reflects the clicked clip's current state.
- edits.Add(MenuKit.Item(clip.Active ? Loc.T("Deactivate") : Loc.T("Activate"), GlyphKind.Bypass,
+ edits.Add(MenuKit.Item(clip.Active ? Loc.T("arrangement.lane_control.deactivate") : Loc.T("arrangement.lane_control.activate"), GlyphKind.Bypass,
() => { EnsureSelected(); _o.ToggleSelectedClipsActive(); }, MenuKit.ActivateKey));
// Loop the current selection (or just this clip if nothing is selected).
- edits.Add(MenuKit.Item(Loc.T("Loop selection"), GlyphKind.Cycle, () =>
+ edits.Add(MenuKit.Item(Loc.T("arrangement.loop_selection"), GlyphKind.Cycle, () =>
{
if (!_o.LoopSelection())
_o.SetLoopRegion(clip.StartBeat, clip.StartBeat + clip.LengthBeats);
}, MenuKit.LoopKey));
// Several MIDI clips selected: open them together in the Clip editor (specs/029).
if (clip.IsMidi && inGroup && _o.SelectedMidiClips().Count >= 2)
- edits.Add(MenuKit.Item(Loc.T("Edit selected clips together"), GlyphKind.Edit, () => _o.EditSelectedClipsRequested?.Invoke()));
+ edits.Add(MenuKit.Item(Loc.T("arrangement.lane_control.edit_selected_clips_together"), GlyphKind.Edit, () => _o.EditSelectedClipsRequested?.Invoke()));
// Audio clip → stems (AI model) and → MIDI: Convert / Slice to a new MIDI track.
var audio = new List<Control>();
if (!clip.IsMidi)
{
- audio.Add(MenuKit.Item(Loc.T("Separate stems…"), GlyphKind.Stems, () => _o.SeparateStemsRequested?.Invoke(trackId, idx)));
- var convert = MenuKit.Item(Loc.T("Convert"), GlyphKind.Arrow);
+ audio.Add(MenuKit.Item(Loc.T("arrangement.lane_control.separate_stems"), GlyphKind.Stems, () => _o.SeparateStemsRequested?.Invoke(trackId, idx)));
+ var convert = MenuKit.Item(Loc.T("arrangement.lane_control.convert"), GlyphKind.Arrow);
MenuItem ConvItem(string header, ClipConvertMode mode)
=> MenuKit.Item(header, null, () => _o.ConvertClipRequested?.Invoke(trackId, idx, mode));
// Melody / Harmony are only offered on the AI model: the DSP fallback's results
@@ -1071,15 +1071,15 @@ public sealed partial class ArrangementView
bool canTranscribe = _o.CanTranscribe?.Invoke() != false;
if (canTranscribe)
{
- convert.Items.Add(ConvItem(Loc.T("Melody to new MIDI track"), ClipConvertMode.Melody));
- convert.Items.Add(ConvItem(Loc.T("Harmony to new MIDI track"), ClipConvertMode.Harmony));
+ convert.Items.Add(ConvItem(Loc.T("arrangement.lane_control.melody_to_new_midi_track"), ClipConvertMode.Melody));
+ convert.Items.Add(ConvItem(Loc.T("arrangement.lane_control.harmony_to_new_midi_track"), ClipConvertMode.Harmony));
}
- convert.Items.Add(ConvItem(Loc.T("Drums to new MIDI track"), ClipConvertMode.Drums));
- convert.Items.Add(ConvItem(Loc.T("Slice to new MIDI track"), ClipConvertMode.Slice));
+ convert.Items.Add(ConvItem(Loc.T("arrangement.lane_control.drums_to_new_midi_track"), ClipConvertMode.Drums));
+ convert.Items.Add(ConvItem(Loc.T("arrangement.lane_control.slice_to_new_midi_track"), ClipConvertMode.Slice));
if (!canTranscribe)
{
convert.Items.Add(new Separator());
- convert.Items.Add(MenuKit.Item(Loc.T("Get the AI model for melody and harmony…"), null, () => _o.TranscriptionModelRequested?.Invoke()));
+ convert.Items.Add(MenuKit.Item(Loc.T("arrangement.lane_control.get_the_ai_model_for"), null, () => _o.TranscriptionModelRequested?.Invoke()));
}
audio.Add(convert);
}
@@ -1089,13 +1089,13 @@ public sealed partial class ArrangementView
var session = new List<Control>();
if (_o._engine is { } eng)
{
- session.Add(MenuKit.Item(Loc.T("Copy to Session"), GlyphKind.Grid, () => { EnsureSelected(); _o.CopySelectionToSession(); }, MenuKit.CopyToOtherViewKey));
- var toScene = MenuKit.Item(Loc.T("Copy to scene"), GlyphKind.Grid);
+ session.Add(MenuKit.Item(Loc.T("arrangement.lane_control.copy_to_session"), GlyphKind.Grid, () => { EnsureSelected(); _o.CopySelectionToSession(); }, MenuKit.CopyToOtherViewKey));
+ var toScene = MenuKit.Item(Loc.T("arrangement.lane_control.copy_to_scene"), GlyphKind.Grid);
for (int s = 0; s < eng.SceneCount; s++)
{
int sc = s;
string name = eng.GetSceneName(sc);
- toScene.Items.Add(MenuKit.Item(name.Length > 0 ? $"{sc + 1} · {name}" : Loc.F("Scene {0}", sc + 1), null,
+ toScene.Items.Add(MenuKit.Item(name.Length > 0 ? $"{sc + 1} · {name}" : Loc.F("arrangement.lane_control.scene", sc + 1), null,
() => { EnsureSelected(); _o.CopySelectionToSession(sc); }));
}
session.Add(toScene);
@@ -1110,7 +1110,7 @@ public sealed partial class ArrangementView
_o.HasClipClipboard).Cast<Control>().ToList();
if (PasteBouncedItem(trackId, at) is { } bounced) clipboard.Insert(3, bounced);
- var del = MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () =>
+ var del = MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () =>
{
if (inGroup) _o.DeleteSelectedClips();
else { _o._engine?.DeleteClip(trackId, idx); _o.Select(-1, -1); _o.Refresh(); }
@@ -1233,7 +1233,7 @@ public sealed partial class ArrangementView
DrawRecPeaks(ctx, re, rr);
if (rr.Width > 34)
{
- var ft = new FormattedText(Loc.T("Rec"), CultureInfo.InvariantCulture,
+ var ft = new FormattedText(Loc.T("arrangement.lane_control.rec"), CultureInfo.InvariantCulture,
FlowDirection.LeftToRight, NotaFonts.SansBold, 9, RecText);
Glyph.Draw(ctx, GlyphKind.Record, new Rect(rr.X + 5, rr.Y + 3 + (ft.Height - 7) / 2, 7, 7), RecText);
ctx.DrawText(ft, new Point(rr.X + 16, rr.Y + 3));
@@ -1315,7 +1315,7 @@ public sealed partial class ArrangementView
// Empty-state hint.
if (_o._tracks.Count == 0)
{
- var ft = new FormattedText(Loc.T("Add an instrument from the browser"),
+ var ft = new FormattedText(Loc.T("arrangement.lane_control.add_an_instrument_from_the"),
CultureInfo.InvariantCulture, FlowDirection.LeftToRight, Typeface.Default, 12, RulerText);
ctx.DrawText(ft, new Point(Math.Max(12, (w - ft.Width) / 2), h / 2 - 10));
}
@@ -1487,7 +1487,7 @@ public sealed partial class ArrangementView
var r = new Rect(0, top + k * DefaultRowHeight, w, DefaultRowHeight);
ctx.FillRectangle(DropWash, r);
ctx.DrawRectangle(null, DropEdgePen, r.Deflate(1));
- var ft = new FormattedText(Loc.T("New track"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight,
+ var ft = new FormattedText(Loc.T("arrangement.lane_control.new_track"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight,
Typeface.Default, 11, RulerText);
ctx.DrawText(ft, new Point(Math.Max(8, w - ft.Width - 12), r.Y + 4)); // clear of clips at the song start
}
diff --git a/src/managed/Nota.App/ArrangementView.Link.cs b/src/managed/Nota.App/ArrangementView.Link.cs
index ee7d727e..f729162e 100644
--- a/src/managed/Nota.App/ArrangementView.Link.cs
+++ b/src/managed/Nota.App/ArrangementView.Link.cs
@@ -171,7 +171,7 @@ public sealed partial class ArrangementView
}
/// <summary>The tooltip of every Link key (Arrangement and Mixer).</summary>
- internal static string LinkTip => MenuKit.Keys(Loc.T("Link tracks — arming and clip edits act on every track of the group · ⌥-click a clip or an arm to act on one track"));
+ internal static string LinkTip => MenuKit.Keys(Loc.T("arrangement.link.link_tracks_arming_and_clip"));
/// <summary>Turns a group's Link on or off (one undo step) and says so.</summary>
internal void SetGroupLink(int groupId, bool on)
@@ -180,7 +180,7 @@ public sealed partial class ArrangementView
_ = Link; // what the selection was linked by, so Refresh can reconcile it with the new sets
if (!_engine.SetTrackEditLink(groupId, on)) return;
Refresh();
- if (on) StatusMessage?.Invoke(Loc.T("The group's tracks are linked"));
+ if (on) StatusMessage?.Invoke(Loc.T("arrangement.link.the_groups_tracks_are_linked"));
}
/// <summary>The group header's Link key: a chain-link chip, accent-filled while on.</summary>
@@ -219,7 +219,7 @@ public sealed partial class ArrangementView
Foreground = NotaPalette.TextSecondary, Margin = new Thickness(0, 0, 4, 0), VerticalAlignment = VerticalAlignment.Center,
};
string group = _engine is { } eng ? eng.GetTrackName(Link.RootOf(t.Id)) : "";
- ToolTip.SetTip(mark, Loc.F("Linked with {0}", group.Length > 0 ? group : Loc.T("Group")));
+ ToolTip.SetTip(mark, Loc.F("arrangement.link.linked_with", group.Length > 0 ? group : Loc.T("common.group")));
return mark;
}
diff --git a/src/managed/Nota.App/ArrangementView.NewTrackDrop.cs b/src/managed/Nota.App/ArrangementView.NewTrackDrop.cs
index 2b74a929..c163963c 100644
--- a/src/managed/Nota.App/ArrangementView.NewTrackDrop.cs
+++ b/src/managed/Nota.App/ArrangementView.NewTrackDrop.cs
@@ -34,9 +34,9 @@ public partial class ArrangementView
// Half-done (a source the engine wouldn't copy, or a refused move): take the tracks back.
if (!ok && newIds.Count > 0) _engine.Undo();
Refresh();
- if (!ok) { StatusMessage?.Invoke(Loc.T("Couldn't move the clips to new tracks")); return; }
+ if (!ok) { StatusMessage?.Invoke(Loc.T("arrangement.new_track_drop.couldnt_move_the_clips_to")); return; }
if (_engine.LastMoveKeptDeviceAutomation())
- StatusMessage?.Invoke(Loc.T("Moved to new tracks — device automation stayed on the source"));
+ StatusMessage?.Invoke(Loc.T("arrangement.new_track_drop.moved_to_new_tracks_device"));
ReselectPlaced();
ClipsMoved?.Invoke(move!);
RevealTrack(newIds[sourceTracks[^1]]);
diff --git a/src/managed/Nota.App/ArrangementView.Overview.cs b/src/managed/Nota.App/ArrangementView.Overview.cs
index e16ce83c..3fdf45e8 100644
--- a/src/managed/Nota.App/ArrangementView.Overview.cs
+++ b/src/managed/Nota.App/ArrangementView.Overview.cs
@@ -48,7 +48,7 @@ public sealed partial class ArrangementView
{
var label = new TextBlock
{
- Text = Loc.T("Overview"), Classes = { "SectionLabel" },
+ Text = Loc.T("arrangement.overview.overview"), Classes = { "SectionLabel" },
VerticalAlignment = VerticalAlignment.Center,
};
_overviewRange = new TextBlock
@@ -117,7 +117,7 @@ public sealed partial class ArrangementView
int first = (int)Math.Floor(_scrollBeats / bpb) + 1;
int last = Math.Max(first, (int)Math.Ceiling((_scrollBeats + ViewportBeats) / bpb));
int total = Math.Max(last, (int)Math.Ceiling(OverviewSpan / bpb));
- _overviewRange.Text = Loc.F("bar {0}–{1} / {2}", first, last, total);
+ _overviewRange.Text = Loc.F("arrangement.overview.bar", first, last, total);
}
// Repaint the strip when the playhead crossed into another of its pixels (called from
@@ -302,7 +302,7 @@ public sealed partial class ArrangementView
int n = _o._tracks.Count;
if (n == 0)
{
- var hint = new FormattedText(Loc.T("the project appears here"), CultureInfo.InvariantCulture,
+ var hint = new FormattedText(Loc.T("arrangement.overview.the_project_appears_here"), CultureInfo.InvariantCulture,
FlowDirection.LeftToRight, Typeface.Default, 10, OvEmptyText);
ctx.DrawText(hint, new Point(10, (h - hint.Height) / 2));
}
diff --git a/src/managed/Nota.App/ArrangementView.Sections.cs b/src/managed/Nota.App/ArrangementView.Sections.cs
index 7f957351..0c71b3a2 100644
--- a/src/managed/Nota.App/ArrangementView.Sections.cs
+++ b/src/managed/Nota.App/ArrangementView.Sections.cs
@@ -60,7 +60,7 @@ public sealed partial class ArrangementView
{
var label = new TextBlock
{
- Text = Loc.T("Sections"), Classes = { "SectionLabel" },
+ Text = Loc.T("arrangement.sections.sections"), Classes = { "SectionLabel" },
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Center,
Margin = new Thickness(8, 0, 0, 0),
@@ -169,12 +169,12 @@ public sealed partial class ArrangementView
string automaticName = SectionNames.Automatic(SectionIndex(s));
var box = new TextBox { Text = automatic ? "" : s.Name, PlaceholderText = automaticName, Width = 180, FontSize = 12 };
var caption = new TextBlock { Classes = { "Caption" }, VerticalAlignment = VerticalAlignment.Center };
- void Caption() => caption.Text = SectionNames.IsAutomatic(box.Text) ? Loc.T("Automatic name") : Loc.T("Custom name");
+ void Caption() => caption.Text = SectionNames.IsAutomatic(box.Text) ? Loc.T("arrangement.sections.automatic_name") : Loc.T("arrangement.sections.custom_name");
Caption();
box.TextChanged += (_, _) => Caption();
- var reset = new Button { Content = Loc.T("Reset to default"), Classes = { "ghost" }, FontSize = 11, Height = 22, Padding = new Thickness(6, 0), IsEnabled = !automatic };
- ToolTip.SetTip(reset, Loc.F("Back to the automatic name ({0}), which follows the section's position", automaticName));
+ var reset = new Button { Content = Loc.T("arrangement.sections.reset_to_default"), Classes = { "ghost" }, FontSize = 11, Height = 22, Padding = new Thickness(6, 0), IsEnabled = !automatic };
+ ToolTip.SetTip(reset, Loc.F("arrangement.sections.back_to_the_automatic_name", automaticName));
var footer = new DockPanel { Margin = new Thickness(0, 6, 0, 0) };
DockPanel.SetDock(reset, Dock.Right);
footer.Children.Add(reset);
@@ -209,11 +209,11 @@ public sealed partial class ArrangementView
public string ResetSectionNameAtPlayhead()
{
var s = SectionList.LastOrDefault(x => x.StartBeat <= _playheadBeats && _playheadBeats < x.StartBeat + x.LengthBeats);
- if (s is null) return Loc.T("No section at the playhead");
- if (SectionNames.IsAutomatic(s.Name)) return Loc.F("{0} already has its automatic name", SectionDisplayName(s));
+ if (s is null) return Loc.T("arrangement.sections.no_section_at_the_playhead");
+ if (SectionNames.IsAutomatic(s.Name)) return Loc.F("arrangement.sections.already_has_its_automatic_name", SectionDisplayName(s));
string was = s.Name, now = SectionNames.Automatic(SectionIndex(s));
ResetSectionName(s);
- return Loc.F("\u201C{0}\u201D is {1} again", was, now);
+ return Loc.F("arrangement.sections.is_again", was, now);
}
// ---- edits that carry the arrangement (specs/073) ---------------------
@@ -225,7 +225,7 @@ public sealed partial class ArrangementView
private bool SectionOverlapsAt(int index) => _engine is { } eng && index >= 0 && eng.SectionOverlaps(index);
private string OverlapNote(ArrangementSection s)
- => Loc.F("{0} overlaps another section \u2014 separate them to move its content with it", SectionDisplayName(s));
+ => Loc.F("arrangement.sections.overlaps_another_section_separate_them", SectionDisplayName(s));
// Run an edit that carries content with a section. Afterwards a time selection no longer
// covers the music it did, and cuts and removals re-index the clips, so a clip selection
@@ -264,32 +264,32 @@ public sealed partial class ArrangementView
/// and all. Returns what happened, for the status bar.</summary>
public string MoveSectionAtPlayhead(bool later)
{
- if (SectionAtPlayhead() is not { } s) return Loc.T("No section at the playhead");
+ if (SectionAtPlayhead() is not { } s) return Loc.T("arrangement.sections.no_section_at_the_playhead");
int i = SectionIndex(s);
string name = SectionDisplayName(s);
if (SectionOverlapsAt(i)) return OverlapNote(s);
- if (later && i >= _sections.Count - 1) return Loc.F("{0} is already the last section", name);
- if (!later && i == 0) return Loc.F("{0} is already the first section", name);
- if (!MoveSectionWithContent(i, later ? i + 2 : i - 1)) return Loc.F("Couldn't move {0} there", name);
- return later ? Loc.F("Moved {0} later", name) : Loc.F("Moved {0} earlier", name);
+ if (later && i >= _sections.Count - 1) return Loc.F("arrangement.sections.is_already_the_last_section", name);
+ if (!later && i == 0) return Loc.F("arrangement.sections.is_already_the_first_section", name);
+ if (!MoveSectionWithContent(i, later ? i + 2 : i - 1)) return Loc.F("arrangement.sections.couldnt_move_there", name);
+ return later ? Loc.F("arrangement.sections.moved_later", name) : Loc.F("arrangement.sections.moved_earlier", name);
}
/// <summary>Command palette: duplicate the section under the playhead with its content.</summary>
public string DuplicateSectionWithContentAtPlayhead()
{
- if (SectionAtPlayhead() is not { } s) return Loc.T("No section at the playhead");
+ if (SectionAtPlayhead() is not { } s) return Loc.T("arrangement.sections.no_section_at_the_playhead");
if (SectionOverlapsAt(SectionIndex(s))) return OverlapNote(s);
string name = SectionDisplayName(s);
- return DuplicateSectionWithContent(s) ? Loc.F("Duplicated {0} with its content", name) : Loc.F("Couldn't duplicate {0}", name);
+ return DuplicateSectionWithContent(s) ? Loc.F("arrangement.sections.duplicated_with_its_content", name) : Loc.F("arrangement.sections.couldnt_duplicate", name);
}
/// <summary>Command palette: delete the section under the playhead with its content.</summary>
public string DeleteSectionWithContentAtPlayhead()
{
- if (SectionAtPlayhead() is not { } s) return Loc.T("No section at the playhead");
+ if (SectionAtPlayhead() is not { } s) return Loc.T("arrangement.sections.no_section_at_the_playhead");
if (SectionOverlapsAt(SectionIndex(s))) return OverlapNote(s);
string name = SectionDisplayName(s);
- return DeleteSectionWithContent(s) ? Loc.F("Deleted {0} with its content", name) : Loc.F("Couldn't delete {0}", name);
+ return DeleteSectionWithContent(s) ? Loc.F("arrangement.sections.deleted_with_its_content", name) : Loc.F("arrangement.sections.couldnt_delete", name);
}
/// <summary>Esc / lost focus: abandon a drag in the Sections lane. True when one was active.</summary>
@@ -568,7 +568,7 @@ public sealed partial class ArrangementView
if (s is not null)
{
int bars = (int)Math.Round(s.LengthBeats / Math.Max(1, _o._beatsPerBar));
- var dup = MenuKit.Item(Loc.T("Duplicate"), GlyphKind.Duplicate, () =>
+ var dup = MenuKit.Item(Loc.T("common.duplicate"), GlyphKind.Duplicate, () =>
{
if (_o.Live(s) is null) return;
var copy = _o.AddSection(s.StartBeat + s.LengthBeats, s.LengthBeats);
@@ -577,42 +577,42 @@ public sealed partial class ArrangementView
});
int idx = _o.SectionIndex(s), n = _o._sections.Count;
bool free = !_o.SectionOverlapsAt(idx); // overlapping spans keep their content where it is
- var earlier = MenuKit.Item(Loc.T("Move earlier"), GlyphKind.ChevronLeft,
+ var earlier = MenuKit.Item(Loc.T("arrangement.sections.move_earlier"), GlyphKind.ChevronLeft,
() => { if (_o.Live(s) is { } l) _o.MoveSectionWithContent(_o.SectionIndex(l), _o.SectionIndex(l) - 1); },
enabled: free && idx > 0);
- var later = MenuKit.Item(Loc.T("Move later"), GlyphKind.ChevronRight,
+ var later = MenuKit.Item(Loc.T("arrangement.sections.move_later"), GlyphKind.ChevronRight,
() => { if (_o.Live(s) is { } l) _o.MoveSectionWithContent(_o.SectionIndex(l), _o.SectionIndex(l) + 2); },
enabled: free && idx < n - 1);
- var dupContent = MenuKit.Item(Loc.T("Duplicate with content"), GlyphKind.Duplicate,
+ var dupContent = MenuKit.Item(Loc.T("arrangement.sections.duplicate_with_content"), GlyphKind.Duplicate,
() => _o.DuplicateSectionWithContent(s), enabled: free);
MenuKit.AddGroups(flyout.Items,
- new Control[] { MenuKit.Header(_o.SectionDisplayName(s), null, Loc.Plural(bars, "Section · {0} bar", "Section · {0} bars")) },
+ new Control[] { MenuKit.Header(_o.SectionDisplayName(s), null, Loc.Plural("arrangement.sections.section_bars", bars)) },
new Control[]
{
- MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit, () => _o.RenameSection(this, s)),
- MenuKit.Item(Loc.T("Reset to default name"), GlyphKind.Cycle, () => _o.ResetSectionName(s), enabled: !SectionNames.IsAutomatic(s.Name)),
+ MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit, () => _o.RenameSection(this, s)),
+ MenuKit.Item(Loc.T("arrangement.sections.reset_to_default_name"), GlyphKind.Cycle, () => _o.ResetSectionName(s), enabled: !SectionNames.IsAutomatic(s.Name)),
},
new Control[]
{
- MenuKit.Item(Loc.T("Loop section"), GlyphKind.Cycle, () => _o.SetLoopRegion(s.StartBeat, s.StartBeat + s.LengthBeats)), // raises LoopChanged itself
- MenuKit.Item(Loc.T("Select section"), GlyphKind.Select, () => _o.SelectSectionRange(s)),
+ MenuKit.Item(Loc.T("arrangement.sections.loop_section"), GlyphKind.Cycle, () => _o.SetLoopRegion(s.StartBeat, s.StartBeat + s.LengthBeats)), // raises LoopChanged itself
+ MenuKit.Item(Loc.T("arrangement.sections.select_section"), GlyphKind.Select, () => _o.SelectSectionRange(s)),
},
new Control[] { earlier, later },
new Control[] { dup, dupContent },
new Control[]
{
- MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () => _o.RemoveSection(s)),
- MenuKit.Danger(Loc.T("Delete with content"), GlyphKind.Trash, () => _o.DeleteSectionWithContent(s), enabled: free),
+ MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () => _o.RemoveSection(s)),
+ MenuKit.Danger(Loc.T("arrangement.sections.delete_with_content"), GlyphKind.Trash, () => _o.DeleteSectionWithContent(s), enabled: free),
});
}
else
{
- flyout.Items.Add(MenuKit.Item(Loc.T("Add section here"), GlyphKind.Plus,
+ flyout.Items.Add(MenuKit.Item(Loc.T("arrangement.sections.add_section_here"), GlyphKind.Plus,
() => { _o.AddSection(_o.SnapBar(beat), _o._beatsPerBar * 8); _o.SectionsEdited(); }));
if (_o._sections.Count > 0)
{
flyout.Items.Add(new Separator());
- flyout.Items.Add(MenuKit.Danger(Loc.T("Delete all sections"), GlyphKind.Trash,
+ flyout.Items.Add(MenuKit.Danger(Loc.T("arrangement.sections.delete_all_sections"), GlyphKind.Trash,
() => { _o._sections.Clear(); _o.SectionsEdited(); }));
}
}
@@ -640,7 +640,7 @@ public sealed partial class ArrangementView
IReadOnlyList<ArrangementSection> list = _mode == Mode.Reorder ? _o.SectionList : _o._sections;
if (list.Count == 0 && _mode != Mode.Draft)
{
- var hint = new FormattedText(Loc.T("drag here to mark a section"), CultureInfo.InvariantCulture,
+ var hint = new FormattedText(Loc.T("arrangement.sections.drag_here_to_mark_a"), CultureInfo.InvariantCulture,
FlowDirection.LeftToRight, Typeface.Default, 9, HintInk);
ctx.DrawText(hint, new Point(8, (h - hint.Height) / 2));
}
diff --git a/src/managed/Nota.App/ArrangementView.Sends.cs b/src/managed/Nota.App/ArrangementView.Sends.cs
index 9b06086d..74b34373 100644
--- a/src/managed/Nota.App/ArrangementView.Sends.cs
+++ b/src/managed/Nota.App/ArrangementView.Sends.cs
@@ -101,7 +101,7 @@ public sealed partial class ArrangementView
return "";
}
private static string SendLevelText(double v) => v <= 0.005 ? "–" : NotaNum.Str(v * 100, "0");
- private static string SendTip(int bus, string name, double v) => Loc.F("Send {0} · {1}", SendLetter(bus), name) + " · " + NotaNum.Pct(v);
+ private static string SendTip(int bus, string name, double v) => Loc.F("arrangement.send", SendLetter(bus), name) + " · " + NotaNum.Pct(v);
/// <summary>The send row for a track card: one inline knob per return. <paramref name="contentW"/>
/// is the width the card's controls have; cells drop their letter and level below it.</summary>
@@ -136,7 +136,7 @@ public sealed partial class ArrangementView
if (shown is not null) shown.Text = SendLevelText(v);
ToolTip.SetTip(cell, SendTip(b, name, v));
});
- ValueEntry.Attach(knob, Loc.F("Send {0}", SendLetter(bus)), value);
+ ValueEntry.Attach(knob, Loc.F("common.send", SendLetter(bus)), value);
_sendKnobs.Add((t.Id, bus, knob, value, cell, name));
Grid.SetColumn(cell, i);
row.Children.Add(cell);
@@ -161,14 +161,14 @@ public sealed partial class ArrangementView
// The "Sends" key at the right end of the header column's top strip: on = a solid accent key.
private Border BuildSendsToggle()
{
- var text = new TextBlock { Text = Loc.T("Sends"), FontSize = 9, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center };
+ var text = new TextBlock { Text = Loc.T("common.sends"), FontSize = 9, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center };
var key = new Border
{
Height = 18, Padding = new Thickness(7, 0), CornerRadius = NotaRadius.Control, BorderThickness = new Thickness(1),
VerticalAlignment = VerticalAlignment.Center, Cursor = new Cursor(StandardCursorType.Hand), Child = text,
IsVisible = false,
};
- ToolTip.SetTip(key, Loc.T("Show sends in track headers"));
+ ToolTip.SetTip(key, Loc.T("arrangement.sends.show_sends_in_track_headers"));
key.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(key).Properties.IsLeftButtonPressed) return;
diff --git a/src/managed/Nota.App/ArrangementView.Takes.cs b/src/managed/Nota.App/ArrangementView.Takes.cs
index 6c08aba8..3a8fbfe4 100644
--- a/src/managed/Nota.App/ArrangementView.Takes.cs
+++ b/src/managed/Nota.App/ArrangementView.Takes.cs
@@ -93,12 +93,12 @@ public sealed partial class ArrangementView
private MenuFlyout BuildTakeMenu(int trackId, TakeVM take)
{
var flyout = new MenuFlyout();
- var header = MenuKit.Header(Loc.F("Take {0}", take.Number), null, "");
- var use = MenuKit.Item(Loc.T("Use whole take"), GlyphKind.Check,
+ var header = MenuKit.Header(Loc.F("arrangement.takes.take", take.Number), null, "");
+ var use = MenuKit.Item(Loc.T("arrangement.takes.use_whole_take"), GlyphKind.Check,
() => CompTake(trackId, take.Id, take.StartBeat, take.StartBeat + take.LengthBeats));
- var flatten = MenuKit.Danger(Loc.T("Flatten takes"), GlyphKind.Flatten,
+ var flatten = MenuKit.Danger(Loc.T("arrangement.takes.flatten_takes"), GlyphKind.Flatten,
() => { if (_engine?.FlattenTakes(trackId) == true) { _takesOpen.Remove(trackId); Refresh(); } });
- var del = MenuKit.Danger(Loc.T("Delete take"), GlyphKind.Trash,
+ var del = MenuKit.Danger(Loc.T("arrangement.takes.delete_take"), GlyphKind.Trash,
() => { if (_engine?.DeleteTake(trackId, take.Id) == true) Refresh(); });
MenuKit.AddGroups(flyout.Items, new Control[] { header }, new Control[] { use, flatten }, new Control[] { del });
return flyout;
@@ -128,7 +128,7 @@ public sealed partial class ArrangementView
},
},
};
- ToolTip.SetTip(toggle, open ? Loc.T("Hide takes") : Loc.F("Show {0} takes", t.Takes.Count));
+ ToolTip.SetTip(toggle, open ? Loc.T("arrangement.takes.hide_takes") : Loc.F("arrangement.takes.show_takes", t.Takes.Count));
toggle.PointerPressed += (_, e) => { e.Handled = true; ToggleTakes(t.Id); };
return toggle;
}
@@ -151,7 +151,7 @@ public sealed partial class ArrangementView
Padding = new Thickness(22, 0, 8, 0),
Child = new TextBlock
{
- Text = Loc.F("Take {0}", take.Number), FontSize = 11, Foreground = Brush("Brush.TextSecondary"),
+ Text = Loc.F("arrangement.takes.take", take.Number), FontSize = 11, Foreground = Brush("Brush.TextSecondary"),
VerticalAlignment = VerticalAlignment.Center,
},
};
@@ -279,7 +279,7 @@ public sealed partial class ArrangementView
}
// The lane's name stays at the left edge while the take scrolls past.
- var ft = new FormattedText(Loc.F("Take {0}", take.Number), CultureInfo.InvariantCulture,
+ var ft = new FormattedText(Loc.F("arrangement.takes.take", take.Number), CultureInfo.InvariantCulture,
FlowDirection.LeftToRight, NotaFonts.SansSemiBold, 9.5, RulerText);
double lx = Math.Max(4, Math.Min(x0 + 4, w - ft.Width - 8));
var plate = new Rect(lx - 3, y + 4, ft.Width + 6, ft.Height + 1);
diff --git a/src/managed/Nota.App/ArrangementView.Tracks.cs b/src/managed/Nota.App/ArrangementView.Tracks.cs
index 2ed2b487..8e63ac29 100644
--- a/src/managed/Nota.App/ArrangementView.Tracks.cs
+++ b/src/managed/Nota.App/ArrangementView.Tracks.cs
@@ -204,13 +204,13 @@ public sealed partial class ArrangementView
var flyout = new MenuFlyout();
flyout.FlyoutPresenterClasses.Add("rows");
MenuKit.AddGroups(flyout.Items,
- new Control[] { MenuKit.Header(Loc.F("{0} tracks", ids.Count), null, "") },
+ new Control[] { MenuKit.Header(Loc.F("arrangement.tracks.tracks", ids.Count), null, "") },
new Control[] { TrackColourRow(ids), TrackHeightRow(ids) },
FreezeTracksMenuItems?.Invoke(ids),
- new Control[] { MenuKit.Item(Loc.T("Group tracks"), GlyphKind.Folder, () => GroupTracks(-1), MenuKit.GroupKey) },
+ new Control[] { MenuKit.Item(Loc.T("arrangement.group_tracks"), GlyphKind.Folder, () => GroupTracks(-1), MenuKit.GroupKey) },
MenuKit.ClipboardGroup(() => CopyTracksToClipboard(ids), () => CutTracks(ids),
() => PasteTracksAfter(ids[^1]), () => DuplicateTracks(ids), _engine.HasTrackClipboard()),
- new Control[] { MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () => DeleteTracks(ids), MenuKit.DeleteKey) });
+ new Control[] { MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () => DeleteTracks(ids), MenuKit.DeleteKey) });
return flyout;
}
@@ -221,7 +221,7 @@ public sealed partial class ArrangementView
{
int pos = _tracks.FindIndex(v => v.Id == trackId);
var vm = pos >= 0 ? _tracks[pos] : null;
- string kind = vm is null ? Loc.T("Track") : vm.IsGroup ? Loc.T("Group") : vm.IsReturn ? Loc.T("Return") : vm.IsInstrument ? Loc.T("Instrument") : Loc.T("Audio");
+ string kind = vm is null ? Loc.T("common.track") : vm.IsGroup ? Loc.T("common.group") : vm.IsReturn ? Loc.T("common.return") : vm.IsInstrument ? Loc.T("common.instrument") : Loc.T("common.audio");
return pos >= 0 ? $"{kind} · {pos + 1}" : kind;
}
@@ -255,28 +255,28 @@ public sealed partial class ArrangementView
internal List<(RecordInputPick Pick, string Label)> RecordInputChoices(int trackId)
{
var list = RecordInputPick.Hardware.Select(h => (h.Pick, h.Label)).ToList();
- list.Add((RecordInputPick.Track(-1), Loc.T("Master")));
+ list.Add((RecordInputPick.Track(-1), Loc.T("common.master")));
foreach (var v in _tracks)
- if (v.Id != trackId) list.Add((RecordInputPick.Track(v.Id), v.Name.Length > 0 ? v.Name : Loc.F("Track {0}", v.Id)));
+ if (v.Id != trackId) list.Add((RecordInputPick.Track(v.Id), v.Name.Length > 0 ? v.Name : Loc.F("common.track_n", v.Id)));
foreach (var v in _returns)
- list.Add((RecordInputPick.Track(v.Id), v.Name.Length > 0 ? v.Name : Loc.F("Return {0}", v.Id)));
+ list.Add((RecordInputPick.Track(v.Id), v.Name.Length > 0 ? v.Name : Loc.F("common.return_n", v.Id)));
return list;
}
/// <summary>The instrument tracks another instrument track can take its MIDI from.</summary>
internal List<(int Id, string Name)> MidiSourceChoices(int trackId)
=> _tracks.Where(v => v.Id != trackId && v.IsInstrument)
- .Select(v => (v.Id, v.Name.Length > 0 ? v.Name : Loc.F("Track {0}", v.Id))).ToList();
+ .Select(v => (v.Id, v.Name.Length > 0 ? v.Name : Loc.F("common.track_n", v.Id))).ToList();
// Compact / Standard / Large for one or more tracks (the chosen key when they all sit on
// that preset); Option / Alt applies the height to every track.
private MenuItem TrackHeightRow(IReadOnlyList<int> ids)
{
- (string, double)[] presets = { (Loc.T("Compact"), CompactRowHeight), (Loc.T("Standard"), StandardRowHeight), (Loc.T("Large"), LargeRowHeight) };
+ (string, double)[] presets = { (Loc.T("common.compact"), CompactRowHeight), (Loc.T("arrangement.tracks.standard"), StandardRowHeight), (Loc.T("arrangement.tracks.large"), LargeRowHeight) };
double? chosen = presets.Select(p => p.Item2)
.Where(h => ids.Count > 0 && ids.All(id => Math.Abs(StoredRowHeight(id) - h) < 0.5))
.Select(h => (double?)h).FirstOrDefault();
- return MenuKit.Segments(Loc.T("Height"), presets, chosen, (h, all) =>
+ return MenuKit.Segments(Loc.T("arrangement.tracks.height"), presets, chosen, (h, all) =>
{
if (all) SetAllTrackHeights(h); else SetTrackHeights(ids, h);
});
@@ -286,13 +286,13 @@ public sealed partial class ArrangementView
// selected returns it belongs to — or the master. Never "all tracks", so Alt/Option is ignored.
private MenuItem FooterHeightRow(int footerRow)
{
- (string, double)[] presets = { (Loc.T("Compact"), CompactRowHeight), (Loc.T("Standard"), StandardRowHeight), (Loc.T("Large"), LargeRowHeight) };
+ (string, double)[] presets = { (Loc.T("common.compact"), CompactRowHeight), (Loc.T("arrangement.tracks.standard"), StandardRowHeight), (Loc.T("arrangement.tracks.large"), LargeRowHeight) };
var (returns, master) = FooterResizeTargets(footerRow);
var current = returns.Select(StoredRowHeight).Concat(master ? new[] { _masterHeight } : Array.Empty<double>()).ToList();
double? chosen = presets.Select(p => p.Item2)
.Where(h => current.Count > 0 && current.All(c => Math.Abs(c - h) < 0.5))
.Select(h => (double?)h).FirstOrDefault();
- return MenuKit.Segments(Loc.T("Height"), presets, chosen, (h, _) => SetFooterHeights(returns, master, h));
+ return MenuKit.Segments(Loc.T("arrangement.tracks.height"), presets, chosen, (h, _) => SetFooterHeights(returns, master, h));
}
// "Recent" instruments under Add track (spec 034 US5): the host (MainWindow) builds the
diff --git a/src/managed/Nota.App/ArrangementView.Vms.cs b/src/managed/Nota.App/ArrangementView.Vms.cs
index ce154924..f46c0efd 100644
--- a/src/managed/Nota.App/ArrangementView.Vms.cs
+++ b/src/managed/Nota.App/ArrangementView.Vms.cs
@@ -51,7 +51,7 @@ public sealed partial class ArrangementView
// these the chain index and slot of the child the lane drives; -1 = track level.
public int AutoChain = -1, AutoSlot = -1;
public int AutoLane = -1; // the nested lane itself: rack edits move its (chain, slot)
- public string AutoLabel = Loc.T("Vol");
+ public string AutoLabel = Loc.T("arrangement.vol");
public List<AutoPt> AutoPoints = new();
// Group lane summary (M-groups): descendant clips aggregated for the lane preview —
// a stacked mini-clip per child sub-lane when collapsed, a thin span strip when
diff --git a/src/managed/Nota.App/ArrangementView.cs b/src/managed/Nota.App/ArrangementView.cs
index 28822b9d..3edd4691 100644
--- a/src/managed/Nota.App/ArrangementView.cs
+++ b/src/managed/Nota.App/ArrangementView.cs
@@ -380,7 +380,7 @@ public sealed partial class ArrangementView : UserControl
VerticalAlignment = VerticalAlignment.Center,
Children =
{
- new TextBlock { Text = Loc.T("Zoom"), Classes = { "SectionLabel" }, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0, 2, 0) },
+ new TextBlock { Text = Loc.T("arrangement.zoom"), Classes = { "SectionLabel" }, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0, 2, 0) },
zoomOut, zoomIn,
},
};
@@ -845,8 +845,8 @@ public sealed partial class ArrangementView : UserControl
}
double len = _loopE - _loopS, bars = len / _beatsPerBar;
string l = Math.Abs(bars - Math.Round(bars)) < 1e-6
- ? Loc.Plural((long)Math.Round(bars), "{0} bar", "{0} bars")
- : Loc.F("{0:0.##} beats", len);
+ ? Loc.Plural("arrangement.bars", (long)Math.Round(bars))
+ : Loc.F("arrangement.beats", len);
return $"{Pos(_loopS)} – {Pos(_loopE)} · {l}";
}
@@ -1098,7 +1098,7 @@ public sealed partial class ArrangementView : UserControl
LiveRole = FreezeRole?.Invoke(ti.Id) ?? 0, // live-freeze (v1.1)
Player = PlayerBadge?.Invoke(ti.Id), // Nota Remote
// A stored name (set via the header menu) wins; otherwise the derived default.
- Name = IsProcessingTrack(ti.Id) ? Loc.T("Processing…") : TrackNames.Of(eng, ti),
+ Name = IsProcessingTrack(ti.Id) ? Loc.T("arrangement.processing") : TrackNames.Of(eng, ti),
Volume = ti.Volume,
Pan = ti.Pan,
EditLink = ti.IsGroup && eng.GetTrackEditLink(ti.Id), // group Link (specs/076)
@@ -1451,7 +1451,7 @@ public sealed partial class ArrangementView : UserControl
if (_engine.PasteClipBlock(at, dest) <= 0)
{
if (dest <= 0) return false;
- StatusMessage?.Invoke(Loc.T("Paste a MIDI clip onto a MIDI track, audio onto audio."));
+ StatusMessage?.Invoke(Loc.T("arrangement.paste_a_midi_clip_onto"));
return true;
}
Refresh();
@@ -1488,7 +1488,7 @@ public sealed partial class ArrangementView : UserControl
finally { _engine.EndUndoGroup(); }
if (placed <= 0)
{
- StatusMessage?.Invoke(Loc.T("Paste a MIDI clip onto a MIDI track, audio onto audio."));
+ StatusMessage?.Invoke(Loc.T("arrangement.paste_a_midi_clip_onto"));
return true;
}
if (src.Cut) { ClipTransfer.SlotMoved(null); SessionChanged?.Invoke(); }
@@ -1512,8 +1512,8 @@ public sealed partial class ArrangementView : UserControl
int scene = _engine.ArrangementClipsToSession(sel, startScene);
if (scene < 0) return -1;
SessionChanged?.Invoke();
- StatusMessage?.Invoke(sel.Length == 1 ? Loc.F("Copied clip to session scene {0}", scene + 1)
- : Loc.F("Copied {0} clips to the session from scene {1}", sel.Length, scene + 1));
+ StatusMessage?.Invoke(sel.Length == 1 ? Loc.F("arrangement.copied_clip_to_session_scene", scene + 1)
+ : Loc.F("arrangement.copied_clips_to_the_session", sel.Length, scene + 1));
return scene;
}
@@ -2248,7 +2248,7 @@ public sealed partial class ArrangementView : UserControl
Grid.SetColumn(tri, 0);
Grid.SetColumn(name, 1);
Grid.SetColumn(chips, 2);
- var kind = TypeTag(Loc.T("Group"));
+ var kind = TypeTag(Loc.T("common.group"));
Grid.SetColumn(kind, 3);
row.Children.Add(tri);
row.Children.Add(name);
@@ -2427,7 +2427,7 @@ public sealed partial class ArrangementView : UserControl
fader.GestureBegin += () => _engine?.BeginAutomationWrite(volTrackId, AutomationTarget.Volume, -1, -1, "");
fader.GestureEnd += () => _engine?.EndAutomationWrite(volTrackId, AutomationTarget.Volume, -1, -1, "");
fader.GestureEnd += () => volUndo?.End();
- ValueEntry.Attach(fader, fader.EntryField(Loc.T("Volume"), VolumeDbText), db);
+ ValueEntry.Attach(fader, fader.EntryField(Loc.T("common.volume"), VolumeDbText), db);
_volFaders[t.Id] = fader; _volDb[t.Id] = db;
var volCell = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
@@ -2444,7 +2444,7 @@ public sealed partial class ArrangementView : UserControl
pan.GestureBegin += () => _engine?.BeginAutomationWrite(volTrackId, AutomationTarget.Pan, -1, -1, "");
pan.GestureEnd += () => _engine?.EndAutomationWrite(volTrackId, AutomationTarget.Pan, -1, -1, "");
pan.GestureEnd += () => panUndo?.End();
- ValueEntry.Attach(pan, pan.EntryField(Loc.T("Pan")));
+ ValueEntry.Attach(pan, pan.EntryField(Loc.T("common.pan")));
_panBars[t.Id] = pan;
var volRow = new Grid { ColumnDefinitions = new ColumnDefinitions("2*,*"), ColumnSpacing = 6, Margin = new Thickness(0, 6, 0, 0) };
@@ -2635,9 +2635,9 @@ public sealed partial class ArrangementView : UserControl
{
MenuItem Item(string full, string brief, NewTrackKind kind)
=> MenuKit.Item(inSubmenu ? brief : full, GlyphKind.Plus, () => AddTrackRequested?.Invoke(kind, anchorTrackId));
- yield return Item(Loc.T("Add instrument track"), Loc.T("Instrument"), NewTrackKind.Instrument);
- yield return Item(Loc.T("Add audio track"), Loc.T("Audio"), NewTrackKind.Audio);
- yield return Item(Loc.T("Add return track"), Loc.T("Return"), NewTrackKind.Return);
+ yield return Item(Loc.T("arrangement.add_instrument_track"), Loc.T("common.instrument"), NewTrackKind.Instrument);
+ yield return Item(Loc.T("arrangement.add_audio_track"), Loc.T("common.audio"), NewTrackKind.Audio);
+ yield return Item(Loc.T("arrangement.add_return_track"), Loc.T("common.return"), NewTrackKind.Return);
}
// Right-click on the empty space below the tracks: add a track (the main thing to do
@@ -2648,7 +2648,7 @@ public sealed partial class ArrangementView : UserControl
var flyout = new MenuFlyout();
foreach (var mi in AddTrackItems()) flyout.Items.Add(mi);
flyout.Items.Add(new Separator());
- var paste = new MenuItem { Header = Loc.T("Paste track"), IsEnabled = _engine.HasTrackClipboard(), Icon = MenuKit.Icon(GlyphKind.Paste), InputGesture = MenuKit.PasteKey };
+ var paste = new MenuItem { Header = Loc.T("arrangement.paste_track"), IsEnabled = _engine.HasTrackClipboard(), Icon = MenuKit.Icon(GlyphKind.Paste), InputGesture = MenuKit.PasteKey };
paste.Click += (_, _) => PasteTracksAfter(-1);
flyout.Items.Add(paste);
flyout.ShowAt(anchor, showAtPointer: true);
@@ -2673,7 +2673,7 @@ public sealed partial class ArrangementView : UserControl
var one = new[] { trackId };
var vm = _tracks.FirstOrDefault(v => v.Id == trackId);
- var rename = MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit, () => PromptRenameTrack(anchor, trackId));
+ var rename = MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit, () => PromptRenameTrack(anchor, trackId));
// Record input ▸ (audio tracks only): hardware, master, or another track's output
// (internal resampling). The active source is ticked and shown on the item.
@@ -2682,7 +2682,7 @@ public sealed partial class ArrangementView : UserControl
if (isAudio)
{
var cur = RecordInputPick.Of(_engine, trackId);
- string curName = Loc.T("Ext");
+ string curName = Loc.T("arrangement.ext");
var choices = new List<MenuItem>();
void Src(string label, string shortName, RecordInputPick pick)
{
@@ -2695,12 +2695,12 @@ public sealed partial class ArrangementView : UserControl
}
foreach (var (pick, label, shortName) in RecordInputPick.Hardware) Src(label, shortName, pick);
int fixedCount = RecordInputPick.Hardware.Length + 1; // the hardware entries + Master
- Src(Loc.T("Master"), Loc.T("Master"), RecordInputPick.Track(-1));
+ Src(Loc.T("common.master"), Loc.T("common.master"), RecordInputPick.Track(-1));
foreach (var v in _tracks)
- if (v.Id != trackId) { string n = v.Name.Length > 0 ? v.Name : Loc.F("Track {0}", v.Id); Src(n, n, RecordInputPick.Track(v.Id)); }
+ if (v.Id != trackId) { string n = v.Name.Length > 0 ? v.Name : Loc.F("common.track_n", v.Id); Src(n, n, RecordInputPick.Track(v.Id)); }
foreach (var v in _returns)
- { string n = v.Name.Length > 0 ? v.Name : Loc.F("Return {0}", v.Id); Src(n, n, RecordInputPick.Track(v.Id)); }
- recInput = MenuKit.ValueItem(Loc.T("Record input"), GlyphKind.Input, curName);
+ { string n = v.Name.Length > 0 ? v.Name : Loc.F("common.return_n", v.Id); Src(n, n, RecordInputPick.Track(v.Id)); }
+ recInput = MenuKit.ValueItem(Loc.T("common.record_input"), GlyphKind.Input, curName);
foreach (var c in choices.Take(fixedCount)) recInput.Items.Add(c);
if (choices.Count > fixedCount) recInput.Items.Add(new Separator());
foreach (var c in choices.Skip(fixedCount)) recInput.Items.Add(c);
@@ -2712,35 +2712,35 @@ public sealed partial class ArrangementView : UserControl
if (vm is { IsInstrument: true })
{
int curSrc = _engine.GetTrackMidiSource(trackId);
- string curName = Loc.T("None");
+ string curName = Loc.T("common.none");
var others = _tracks.Where(v => v.Id != trackId && v.IsInstrument).ToList();
- foreach (var v in others) if (v.Id == curSrc) curName = v.Name.Length > 0 ? v.Name : Loc.F("Track {0}", v.Id);
- midiFrom = MenuKit.ValueItem(Loc.T("MIDI from"), GlyphKind.Note, curName);
+ foreach (var v in others) if (v.Id == curSrc) curName = v.Name.Length > 0 ? v.Name : Loc.F("common.track_n", v.Id);
+ midiFrom = MenuKit.ValueItem(Loc.T("arrangement.midi_from"), GlyphKind.Note, curName);
MenuItem Src(string label, int src)
{
var mi = new MenuItem { Header = label, ToggleType = MenuItemToggleType.Radio, IsChecked = curSrc == src };
mi.Click += (_, _) => _engine.SetTrackMidiSource(trackId, src);
return mi;
}
- midiFrom.Items.Add(Src(Loc.T("None"), -1));
+ midiFrom.Items.Add(Src(Loc.T("common.none"), -1));
if (others.Count > 0) midiFrom.Items.Add(new Separator());
foreach (var v in others)
- midiFrom.Items.Add(Src(v.Name.Length > 0 ? v.Name : Loc.F("Track {0}", v.Id), v.Id));
+ midiFrom.Items.Add(Src(v.Name.Length > 0 ? v.Name : Loc.F("common.track_n", v.Id), v.Id));
}
// Group / Ungroup (submix). "Group" folds the multi-selection (or this track) into a
// new group; "Ungroup" dissolves the group this track is/belongs to.
var create = new List<Control>();
- var addTrack = MenuKit.Item(Loc.T("Add track"), GlyphKind.Plus);
+ var addTrack = MenuKit.Item(Loc.T("arrangement.add_track"), GlyphKind.Plus);
foreach (var mi in AddTrackItems(trackId, inSubmenu: true)) addTrack.Items.Add(mi);
AddRecentInstruments(addTrack, trackId);
create.Add(addTrack);
- create.Add(MenuKit.Item(Loc.T("Group tracks"), GlyphKind.Folder, () => GroupTracks(trackId), MenuKit.GroupKey));
+ create.Add(MenuKit.Item(Loc.T("arrangement.group_tracks"), GlyphKind.Folder, () => GroupTracks(trackId), MenuKit.GroupKey));
int ungroupId = GroupToUngroupFor(trackId);
if (ungroupId > 0)
- create.Add(MenuKit.Item(Loc.T("Ungroup"), GlyphKind.Ungroup, () => UngroupGroup(ungroupId), MenuKit.UngroupKey));
+ create.Add(MenuKit.Item(Loc.T("arrangement.ungroup"), GlyphKind.Ungroup, () => UngroupGroup(ungroupId), MenuKit.UngroupKey));
if (vm is { IsGroup: true } gvm) // group Link (specs/076)
- create.Add(MenuKit.SwitchItem(Loc.T("Link tracks"), GlyphKind.ChainLink, gvm.EditLink, () => SetGroupLink(gvm.Id, !gvm.EditLink)));
+ create.Add(MenuKit.SwitchItem(Loc.T("arrangement.link_tracks"), GlyphKind.ChainLink, gvm.EditLink, () => SetGroupLink(gvm.Id, !gvm.EditLink)));
// Clipboard + lifecycle go through the same set commands as the keys (a group carries
// its children); paste lands right after this track.
@@ -2754,7 +2754,7 @@ public sealed partial class ArrangementView : UserControl
FreezeMenuItems?.Invoke(trackId),
create,
clipboard,
- new Control[] { MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () => DeleteTracks(one), MenuKit.DeleteKey) });
+ new Control[] { MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () => DeleteTracks(one), MenuKit.DeleteKey) });
return flyout;
}
@@ -2772,7 +2772,7 @@ public sealed partial class ArrangementView : UserControl
// "In" pinned left (faded), the source name pinned right, so the name stands out.
void Add(string value, RecordInputPick src)
{
- var inTb = new TextBlock { Text = Loc.T("In"), FontSize = 9, Foreground = Brush("Brush.TextDisabled"), VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(monitor is null ? 6 : 4, 0) };
+ var inTb = new TextBlock { Text = Loc.T("arrangement.in"), FontSize = 9, Foreground = Brush("Brush.TextDisabled"), VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(monitor is null ? 6 : 4, 0) };
var valTb = new TextBlock { Text = value, FontSize = 9, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Right, TextTrimming = TextTrimming.CharacterEllipsis, Margin = new Thickness(monitor is null ? 6 : 4, 0) };
// The closed box hoists this content out of its item, where it stops following the
// theme foreground and keeps whatever it was built with — so on the paper variant
@@ -2788,9 +2788,9 @@ public sealed partial class ArrangementView : UserControl
sources.Add(src);
}
foreach (var (pick, _, shortName) in RecordInputPick.Hardware) Add(shortName, pick);
- Add(Loc.T("Master"), RecordInputPick.Track(-1));
- foreach (var v in _tracks) if (v.Id != trackId) Add(v.Name.Length > 0 ? v.Name : Loc.F("Track {0}", v.Id), RecordInputPick.Track(v.Id));
- foreach (var v in _returns) Add(v.Name.Length > 0 ? v.Name : Loc.F("Return {0}", v.Id), RecordInputPick.Track(v.Id));
+ Add(Loc.T("common.master"), RecordInputPick.Track(-1));
+ foreach (var v in _tracks) if (v.Id != trackId) Add(v.Name.Length > 0 ? v.Name : Loc.F("common.track_n", v.Id), RecordInputPick.Track(v.Id));
+ foreach (var v in _returns) Add(v.Name.Length > 0 ? v.Name : Loc.F("common.return_n", v.Id), RecordInputPick.Track(v.Id));
var cur = _engine is null ? RecordInputPick.Hardware[0].Pick : RecordInputPick.Of(_engine, trackId);
int sel = sources.FindIndex(p => p.Matches(cur));
cb.SelectedIndex = sel >= 0 ? sel : 0;
@@ -2832,8 +2832,8 @@ public sealed partial class ArrangementView : UserControl
glyph.Foreground = Brush(state ? "Brush.TextOnAccent" : "Brush.TextSecondary");
chip.Opacity = usable ? 1.0 : 0.4;
ToolTip.SetTip(chip, usable
- ? (state ? Loc.T("Monitoring input — click to stop") : Loc.T("Monitor input: hear it live through this track"))
- : Loc.T("Master can't be monitored (it would feed back)"));
+ ? (state ? Loc.T("arrangement.monitoring_input_click_to_stop") : Loc.T("arrangement.monitor_input_hear_it_live"))
+ : Loc.T("arrangement.master_cant_be_monitored_it"));
}
Paint();
chip.PointerPressed += (_, e) =>
@@ -2860,7 +2860,7 @@ public sealed partial class ArrangementView : UserControl
// "In" pinned left (faded), the source name pinned right.
void Add(string value, int src)
{
- var inTb = new TextBlock { Text = Loc.T("In"), FontSize = 9, Foreground = Brush("Brush.TextDisabled"), VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0) };
+ var inTb = new TextBlock { Text = Loc.T("arrangement.in"), FontSize = 9, Foreground = Brush("Brush.TextDisabled"), VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0) };
var valTb = new TextBlock { Text = value, FontSize = 9, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Right, TextTrimming = TextTrimming.CharacterEllipsis, Margin = new Thickness(6, 0) };
// The closed box hoists this content out of its item, where it stops following the
// theme foreground and keeps whatever it was built with — so on the paper variant
@@ -2872,8 +2872,8 @@ public sealed partial class ArrangementView : UserControl
cb.Items.Add(new ComboBoxItem { Content = content, Padding = new Thickness(6, 2), MinHeight = 0, HorizontalContentAlignment = HorizontalAlignment.Stretch });
sources.Add(src);
}
- Add(Loc.T("None"), -1);
- foreach (var v in _tracks) if (v.Id != trackId && v.IsInstrument) Add(v.Name.Length > 0 ? v.Name : Loc.F("Track {0}", v.Id), v.Id);
+ Add(Loc.T("common.none"), -1);
+ foreach (var v in _tracks) if (v.Id != trackId && v.IsInstrument) Add(v.Name.Length > 0 ? v.Name : Loc.F("common.track_n", v.Id), v.Id);
int cur = _engine?.GetTrackMidiSource(trackId) ?? -1;
int sel = sources.IndexOf(cur);
cb.SelectedIndex = sel >= 0 ? sel : 0;
@@ -2936,7 +2936,7 @@ public sealed partial class ArrangementView : UserControl
VerticalAlignment = VerticalAlignment.Center,
Child = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, Children = { phone, name } },
};
- ToolTip.SetTip(pill, Loc.F("Played from a phone: {0}", who));
+ ToolTip.SetTip(pill, Loc.F("arrangement.played_from_a_phone", who));
return pill;
}
@@ -3076,7 +3076,7 @@ public sealed partial class ArrangementView : UserControl
}
// Master row: selectable (opens the master effect chain) via the reserved id.
int masterId = _engine?.MasterTrackId ?? -1;
- string masterName = _engine is { } me2 && me2.GetTrackName(masterId) is { Length: > 0 } mn ? mn : Loc.T("Master");
+ string masterName = _engine is { } me2 && me2.GetTrackName(masterId) is { Length: > 0 } mn ? mn : Loc.T("common.master");
return BuildSlimRow(masterName, -1, masterId, "Brush.SurfaceRaised", GetMasterVolume?.Invoke() ?? 1f, h,
v => SetMasterVolume?.Invoke((float)v), out _masterRowMeter, out _masterRowFader, out _masterRowDb,
masterSpine: true);
@@ -3151,7 +3151,7 @@ public sealed partial class ArrangementView : UserControl
}
fader.GestureEnd += () => undo?.End();
fader.ValueChanged += v => { Change(undo, v, setVolume); dbText.Text = VolumeDbText(v); };
- ValueEntry.Attach(fader, fader.EntryField(Loc.T("Volume"), VolumeDbText), dbText);
+ ValueEntry.Attach(fader, fader.EntryField(Loc.T("common.volume"), VolumeDbText), dbText);
Control? mute = ret is null ? null
: ChipToggle("M", ret.Muted, NotaPalette.Mute, v => { ret.Muted = v; _engine?.SetTrackMute(trackId, v); });
@@ -3203,7 +3203,7 @@ public sealed partial class ArrangementView : UserControl
pan.GestureBegin += () => _engine?.BeginAutomationWrite(trackId, AutomationTarget.Pan, -1, -1, "");
pan.GestureEnd += () => _engine?.EndAutomationWrite(trackId, AutomationTarget.Pan, -1, -1, "");
pan.GestureEnd += () => panUndo?.End();
- ValueEntry.Attach(pan, pan.EntryField(Loc.T("Pan")));
+ ValueEntry.Attach(pan, pan.EntryField(Loc.T("common.pan")));
_footerPans[trackId] = pan;
stack.Children.Add(pan);
}
@@ -3272,12 +3272,12 @@ public sealed partial class ArrangementView : UserControl
bool isReturn = _returns.Any(r => r.Id == trackId);
string name = _engine.GetTrackName(trackId);
MenuKit.AddGroups(flyout.Items,
- new Control[] { MenuKit.Header(name.Length > 0 ? name : isReturn ? Loc.T("Return") : Loc.T("Master"),
- TrackBrush(EffectiveColorIndex(_engine, trackId)), isReturn ? Loc.T("Return") : Loc.T("Master")) },
+ new Control[] { MenuKit.Header(name.Length > 0 ? name : isReturn ? Loc.T("common.return") : Loc.T("common.master"),
+ TrackBrush(EffectiveColorIndex(_engine, trackId)), isReturn ? Loc.T("common.return") : Loc.T("common.master")) },
new Control[] { TrackColourRow(new[] { trackId }) },
new Control[] { FooterHeightRow(isReturn ? _returns.FindIndex(r => r.Id == trackId) : _returns.Count) },
- new Control[] { MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit, () => PromptRenameTrack(anchor, trackId)) },
- isReturn ? new Control[] { MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () => DeleteTracks(new[] { trackId }), MenuKit.DeleteKey) } : null);
+ new Control[] { MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit, () => PromptRenameTrack(anchor, trackId)) },
+ isReturn ? new Control[] { MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () => DeleteTracks(new[] { trackId }), MenuKit.DeleteKey) } : null);
flyout.ShowAt(anchor, showAtPointer: true);
}
diff --git a/src/managed/Nota.App/AudioClipEditorView.cs b/src/managed/Nota.App/AudioClipEditorView.cs
index 27b422ad..ad015846 100644
--- a/src/managed/Nota.App/AudioClipEditorView.cs
+++ b/src/managed/Nota.App/AudioClipEditorView.cs
@@ -41,7 +41,7 @@ public sealed class AudioClipEditorView : UserControl
private readonly TextBlock _warpModeText = new() { FontSize = NotaType.Body };
private readonly TextBlock _detectedText = Mono("—");
private readonly TextBlock _markerCount = Meta("");
- private readonly TextBlock _envTargetText = new() { Text = Loc.T("Volume"), FontSize = NotaType.Body, Foreground = NotaPalette.TextPrimary };
+ private readonly TextBlock _envTargetText = new() { Text = Loc.T("common.volume"), FontSize = NotaType.Body, Foreground = NotaPalette.TextPrimary };
private readonly TextBlock _hint = Hint("");
private readonly Border _envTargetDrop;
private Action _syncGain = () => { }, _syncReverse = () => { }, _syncWarp = () => { };
@@ -71,8 +71,8 @@ public sealed class AudioClipEditorView : UserControl
private long _srcFrames; // the whole sample's frames (unwarped detail peaks)
private bool _envMode;
private int _envTarget; // 0 = Volume (0..1), 1 = Pan (-1..1)
- private static readonly string[] WarpModes = { Loc.T("Beats"), Loc.T("Tones"), Loc.T("Texture"), Loc.T("Complex"), Loc.T("Complex Pro"), "Re-Pitch" };
- private static readonly string[] EnvTargets = { Loc.T("Volume"), Loc.T("Pan") };
+ private static readonly string[] WarpModes = { Loc.T("audio_clip_editor.beats"), Loc.T("audio_clip_editor.tones"), Loc.T("audio_clip_editor.texture"), Loc.T("audio_clip_editor.complex"), Loc.T("audio_clip_editor.complex_pro"), "Re-Pitch" };
+ private static readonly string[] EnvTargets = { Loc.T("common.volume"), Loc.T("common.pan") };
public AudioClipEditorView(IAudioEngine engine, int trackId, int clipIndex, IBrush clipColor, Action onChanged)
{
@@ -126,55 +126,55 @@ public sealed class AudioClipEditorView : UserControl
_wave.AdsrCommitted = SetAdsr;
// CLIP — where it sits, and its length (± one beat).
- var clip = Section(Loc.T("Clip"),
- Pair(Labeled(Loc.T("Start"), Field(_startText)), Labeled(Loc.T("Length"), Stepper(_lengthText, () => Resize(-1), () => Resize(1)))));
+ var clip = Section(Loc.T("common.clip"),
+ Pair(Labeled(Loc.T("common.start"), Field(_startText)), Labeled(Loc.T("common.length"), Stepper(_lengthText, () => Resize(-1), () => Resize(1)))));
// PLAYBACK — gain, varispeed pitch, direction.
- var gain = SliderRow(Loc.T("Gain"), 44, () => _gain / 2.0, v => SetGain(v * 2.0), GainText, out _syncGain,
+ var gain = SliderRow(Loc.T("audio_clip_editor.gain"), 44, () => _gain / 2.0, v => SetGain(v * 2.0), GainText, out _syncGain,
reset: () => SetGain(1.0), valueW: 44);
var pitchRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 10 };
pitchRow.Children.Add(new TextBlock
{
- Text = Loc.T("Pitch"), Width = 44, FontSize = 9, FontWeight = FontWeight.Medium,
+ Text = Loc.T("common.pitch"), Width = 44, FontSize = 9, FontWeight = FontWeight.Medium,
Foreground = NotaPalette.TextTertiary, VerticalAlignment = VerticalAlignment.Center,
});
var pitch = Stepper(_pitchText, () => Pitch(-1), () => Pitch(1), zone: 24);
Grid.SetColumn(pitch, 1); pitchRow.Children.Add(pitch);
// Reverse is non-destructive (the file is untouched) and free to toggle, so it
// doubles as an audition switch; the wave mirrors so it always reads in playing order.
- var reverse = SwitchRow(Loc.T("Reverse"), () => _reversed, ToggleReverse, out _syncReverse, height: 22);
- var playback = Section(SectionTitle(Loc.T("Playback")), 10, gain, pitchRow, reverse);
+ var reverse = SwitchRow(Loc.T("common.reverse"), () => _reversed, ToggleReverse, out _syncReverse, height: 22);
+ var playback = Section(SectionTitle(Loc.T("audio_clip_editor.playback")), 10, gain, pitchRow, reverse);
// WARP — on/off and the stretch mode, the two detectors, what they found.
- var warpSwitch = SwitchRow(Loc.T("Warp"), () => _warpEnabled, ToggleWarp, out _syncWarp);
+ var warpSwitch = SwitchRow(Loc.T("audio_clip_editor.warp"), () => _warpEnabled, ToggleWarp, out _syncWarp);
var mode = Dropdown(_warpModeText, a => ShowMenu(a, WarpModes, _warpMode, SetWarpMode));
mode.Width = 104;
var warpRow = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 8 };
warpRow.Children.Add(warpSwitch);
Grid.SetColumn(mode, 1); warpRow.Children.Add(mode);
- var detect = ClipEditorKit.Button(Loc.T("Detect tempo"), AutoWarp);
- ToolTip.SetTip(detect, Loc.T("Detect the file's tempo and conform it to the project"));
- var transients = ClipEditorKit.Button(Loc.T("To transients"), TransientWarp);
- ToolTip.SetTip(transients, Loc.T("Pin a marker on every hit so drums lock to the grid"));
- var warp = Section(SectionTitle(Loc.T("Warp"), _markerCount), 8,
- warpRow, TempoRow(), Pair(detect, transients), Card(KeyValue(Loc.T("Detected"), _detectedText)));
+ var detect = ClipEditorKit.Button(Loc.T("audio_clip_editor.detect_tempo"), AutoWarp);
+ ToolTip.SetTip(detect, Loc.T("audio_clip_editor.detect_the_files_tempo_and"));
+ var transients = ClipEditorKit.Button(Loc.T("audio_clip_editor.to_transients"), TransientWarp);
+ ToolTip.SetTip(transients, Loc.T("audio_clip_editor.pin_a_marker_on_every"));
+ var warp = Section(SectionTitle(Loc.T("audio_clip_editor.warp"), _markerCount), 8,
+ warpRow, TempoRow(), Pair(detect, transients), Card(KeyValue(Loc.T("audio_clip_editor.detected"), _detectedText)));
// ADSR — the clip's amplitude shape (the ADSR tab swaps the inspector to it). Times
// run on a square-law slider over the clip length, so short attacks stay fine-grained.
- var attack = SliderRow(Loc.T("Attack"), 52, () => TimeNorm(_adsr.AttackBeats),
+ var attack = SliderRow(Loc.T("common.attack"), 52, () => TimeNorm(_adsr.AttackBeats),
v => SetAdsrStage(AdsrHandle.Attack, NormTime(v), _adsr.Sustain), () => AdsrTime(_adsr.AttackBeats), out _syncAttack,
reset: () => SetAdsr(ClipAdsrKit.Reset(AdsrHandle.Attack, _adsr)), valueW: 52);
- var decay = SliderRow(Loc.T("Decay"), 52, () => TimeNorm(_adsr.DecayBeats),
+ var decay = SliderRow(Loc.T("common.decay"), 52, () => TimeNorm(_adsr.DecayBeats),
v => SetAdsrStage(AdsrHandle.DecaySustain, _adsr.AttackBeats + NormTime(v), _adsr.Sustain), () => AdsrTime(_adsr.DecayBeats), out _syncDecay,
reset: () => { var a = _adsr; a.DecayBeats = 0; SetAdsr(a); }, valueW: 52);
- var sustain = SliderRow(Loc.T("Sustain"), 52, () => _adsr.Sustain,
+ var sustain = SliderRow(Loc.T("common.sustain"), 52, () => _adsr.Sustain,
v => SetAdsrStage(AdsrHandle.DecaySustain, _adsr.AttackBeats + _adsr.DecayBeats, v), () => ClipAdsrKit.SustainText(_adsr.Sustain), out _syncSustain,
reset: () => { var a = _adsr; a.Sustain = 1f; SetAdsr(a); }, valueW: 52);
- var release = SliderRow(Loc.T("Release"), 52, () => TimeNorm(_adsr.ReleaseBeats),
+ var release = SliderRow(Loc.T("common.release"), 52, () => TimeNorm(_adsr.ReleaseBeats),
v => SetAdsrStage(AdsrHandle.Release, _lengthBeats - NormTime(v), _adsr.Sustain), () => AdsrTime(_adsr.ReleaseBeats), out _syncRelease,
reset: () => SetAdsr(ClipAdsrKit.Reset(AdsrHandle.Release, _adsr)), valueW: 52);
- var resetAll = ClipEditorKit.Button(Loc.T("Reset"), () => SetAdsr(ClipAdsr.Identity));
- ToolTip.SetTip(resetAll, Loc.T("Play the whole sample at full level"));
+ var resetAll = ClipEditorKit.Button(Loc.T("audio_clip_editor.reset"), () => SetAdsr(ClipAdsr.Identity));
+ ToolTip.SetTip(resetAll, Loc.T("audio_clip_editor.play_the_whole_sample_at"));
var adsr = Section(SectionTitle("ADSR"), 10, attack, decay, sustain, release, resetAll);
_sampleSections = Sections(clip, playback, warp);
@@ -211,7 +211,7 @@ public sealed class AudioClipEditorView : UserControl
var grid = new DockPanel { Children = { inspector, col1 } };
// Header: Sample | Envelope | ADSR, the target while editing an envelope, Snap, the format.
- var tabs = Segments(new[] { Loc.T("Sample"), Loc.T("Envelope"), "ADSR" }, 0, SetMode, out _);
+ var tabs = Segments(new[] { Loc.T("common.sample"), Loc.T("audio_clip_editor.envelope"), "ADSR" }, 0, SetMode, out _);
_envTargetDrop = Dropdown(_envTargetText, a => ShowMenu(a, EnvTargets, _envTarget, SetEnvTarget));
_envTargetDrop.IsVisible = false;
// The clip editors' snap grid (shared with the piano roll): trim brackets, warp markers
@@ -220,7 +220,7 @@ public sealed class AudioClipEditorView : UserControl
_wave.GridChanged += chip.Refresh;
var right = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 12, Children = { snap, HeaderDivider(), _fileText } };
var name = engine.GetClipName(trackId, clipIndex);
- var header = Header(clipColor, string.IsNullOrWhiteSpace(name) ? Loc.F("Audio {0}", trackId) : name, "AUDIO", tabs, _envTargetDrop, right, inspector, _inspectorFlow);
+ var header = Header(clipColor, string.IsNullOrWhiteSpace(name) ? Loc.F("common.audio_n", trackId) : name, "AUDIO", tabs, _envTargetDrop, right, inspector, _inspectorFlow);
DockPanel.SetDock(header, Dock.Top);
Content = new DockPanel { Background = NotaPalette.Gutter, Children = { header, grid } };
@@ -323,7 +323,7 @@ public sealed class AudioClipEditorView : UserControl
if (ai.SampleId != 0 && _engine.TryGetSampleInfo(ai.SampleId, out var si) && si.SampleRate > 0)
{
double secs = si.Frames / si.SampleRate;
- string ch = si.Channels == 1 ? Loc.T("Mono") : si.Channels == 2 ? Loc.T("Stereo") : $"{si.Channels} ch";
+ string ch = si.Channels == 1 ? Loc.T("audio_clip_editor.mono") : si.Channels == 2 ? Loc.T("audio_clip_editor.stereo") : $"{si.Channels} ch";
_fileText.Text = string.Format(NotaNum.Culture,
"{0} · {1:0.0}\u2009kHz · {2:0.00}\u2009s", ch, si.SampleRate / 1000.0, secs);
}
@@ -372,7 +372,7 @@ public sealed class AudioClipEditorView : UserControl
}
else _wave.SetSourceRegion(0, 0, 0);
}
- _markerCount.Text = _warpEnabled ? Loc.Plural(markers, "{0} marker", "{0} markers") : Loc.T("off");
+ _markerCount.Text = _warpEnabled ? Loc.Plural("audio_clip_editor.markers", markers) : Loc.T("audio_clip_editor.off");
_clipBpm = _warpEnabled ? ClipTempo.Bpm(_mkSrc, _mkBeat, _playStart, _playEnd, srcSR) : 0;
SyncTempo();
@@ -404,14 +404,14 @@ public sealed class AudioClipEditorView : UserControl
}
// ---- warp tempo (#248) -----------------------------------------------------
- private static readonly string TempoTip = Loc.T("The tempo the audio was recorded at. Nota stretches it to the project tempo. ×2 / ÷2 fix a half- or double-time detection.");
+ private static readonly string TempoTip = Loc.T("audio_clip_editor.the_tempo_the_audio_was");
// "Tempo [ 87.00 BPM ] ÷2 ×2" under the Warp switch: drag the value, double-click to type.
private Control TempoRow()
{
var label = new TextBlock
{
- Text = Loc.T("Tempo"), Width = 44, FontSize = 9, FontWeight = FontWeight.Medium,
+ Text = Loc.T("audio_clip_editor.tempo"), Width = 44, FontSize = 9, FontWeight = FontWeight.Medium,
Foreground = NotaPalette.TextTertiary, VerticalAlignment = VerticalAlignment.Center,
};
_tempo = new DragNumber(120, ClipTempo.MinBpm, ClipTempo.MaxBpm, 0.5, "0.00", fontSize: NotaType.Body)
@@ -444,8 +444,8 @@ public sealed class AudioClipEditorView : UserControl
_tempoDouble = ClipEditorKit.Button("×2", () => StepTempo(ClipTempo.Double));
foreach (var b in new[] { _tempoHalf, _tempoDouble }) { b.Padding = new Thickness(0); b.Width = 30; }
ToolTip.SetTip(label, TempoTip); ToolTip.SetTip(field, TempoTip);
- ToolTip.SetTip(_tempoHalf, Loc.T("Half the tempo — the clip spans half as many beats"));
- ToolTip.SetTip(_tempoDouble, Loc.T("Double the tempo — the clip spans twice as many beats"));
+ ToolTip.SetTip(_tempoHalf, Loc.T("audio_clip_editor.half_the_tempo_the_clip"));
+ ToolTip.SetTip(_tempoDouble, Loc.T("audio_clip_editor.double_the_tempo_the_clip"));
var row = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto,Auto"), ColumnSpacing = 6 };
row.Children.Add(label);
Grid.SetColumn(field, 1); row.Children.Add(field);
@@ -652,11 +652,11 @@ public sealed class AudioClipEditorView : UserControl
{
_hint.Text = _mode switch
{
- 1 => Loc.T("Click — point · drag — move · right-click — delete"),
- 2 => Loc.T("Drag a handle · double-click — reset"),
+ 1 => Loc.T("audio_clip_editor.click_point_drag_move_right"),
+ 2 => Loc.T("audio_clip_editor.drag_a_handle_double_click"),
// An unwarped clip has no beat grid, so nothing in Sample mode snaps (#269).
- _ when !_warpEnabled => Loc.T("Snap needs Warp — turn on Warp to see the grid and snap to it"),
- _ => Loc.T("Double-click the wave — marker · drag — align"),
+ _ when !_warpEnabled => Loc.T("audio_clip_editor.snap_needs_warp_turn_on"),
+ _ => Loc.T("audio_clip_editor.double_click_the_wave_marker"),
};
}
@@ -730,7 +730,7 @@ public sealed class AudioClipEditorView : UserControl
private bool _seekDrag; // a ruler / playhead-line scrub in progress
private double _lastSeek = double.NaN;
private const double PlayheadGrabPx = 4;
- private static readonly string SlotSeekTip = Loc.T("A Session slot plays on its own loop clock — launch it to play from the start");
+ private static readonly string SlotSeekTip = Loc.T("audio_clip_editor.a_session_slot_plays_on");
public void SetPlacement(double startBeat, double lengthBeats, bool isSlot)
{
_placeStart = startBeat; _placeLen = Math.Max(1e-6, lengthBeats); _slot = isSlot;
diff --git a/src/managed/Nota.App/BrowserView.cs b/src/managed/Nota.App/BrowserView.cs
index 489e6892..34c21a8a 100644
--- a/src/managed/Nota.App/BrowserView.cs
+++ b/src/managed/Nota.App/BrowserView.cs
@@ -115,7 +115,7 @@ public sealed class BrowserView : UserControl
}
if (paths.Count == 0)
App.Services.GetService<ILogSink>()?.Info(
- Loc.F("External drop named no files Nota can read. Formats: {0}", string.Join(", ", data.Formats.Select(f => $"{f.Kind}:{f.Identifier}"))));
+ Loc.F("browser.external_drop_named_no_files", string.Join(", ", data.Formats.Select(f => $"{f.Kind}:{f.Identifier}"))));
return paths;
}
@@ -262,15 +262,15 @@ public sealed class BrowserView : UserControl
_tabs = new[]
{
- RailTab(0, Loc.T("Instruments"), GlyphKind.Keyboard),
- RailTab(1, Loc.T("Audio effects"), GlyphKind.Sliders),
- RailTab(2, Loc.T("MIDI effects"), GlyphKind.Midi),
- RailTab(3, Loc.T("Files"), GlyphKind.Folder),
- RailTab(4, Loc.T("Presets"), GlyphKind.Bookmark),
- RailTab(5, Loc.T("Projects"), GlyphKind.Doc),
- RailTab(6, Loc.T("MIDI map"), GlyphKind.Map),
- RailTab(7, Loc.T("History"), GlyphKind.History),
- RailTab(InspectorTab, Loc.T("Track inspector"), GlyphKind.Track),
+ RailTab(0, Loc.T("common.instruments"), GlyphKind.Keyboard),
+ RailTab(1, Loc.T("browser.audio_effects_2"), GlyphKind.Sliders),
+ RailTab(2, Loc.T("browser.midi_effects_2"), GlyphKind.Midi),
+ RailTab(3, Loc.T("browser.files"), GlyphKind.Folder),
+ RailTab(4, Loc.T("browser.presets"), GlyphKind.Bookmark),
+ RailTab(5, Loc.T("browser.projects"), GlyphKind.Doc),
+ RailTab(6, Loc.T("browser.midi_map"), GlyphKind.Map),
+ RailTab(7, Loc.T("browser.history"), GlyphKind.History),
+ RailTab(InspectorTab, Loc.T("browser.track_inspector"), GlyphKind.Track),
};
// A hairline above Files, Map and the inspector: devices · library · mappings · track.
foreach (int i in new[] { 3, 6, InspectorTab })
@@ -280,7 +280,7 @@ public sealed class BrowserView : UserControl
}
var tabStack = new StackPanel();
foreach (var t in _tabs) tabStack.Children.Add(t);
- _collapseBtn = RailButton(GlyphKind.Sidebar, Loc.T("Collapse browser"), () => SetCollapsed(!_collapsed, persist: true));
+ _collapseBtn = RailButton(GlyphKind.Sidebar, Loc.T("browser.collapse_browser"), () => SetCollapsed(!_collapsed, persist: true));
_collapseBtn.BorderThickness = new Thickness(0, 1, 0, 0);
_collapseBtn.BindResource(Border.BorderBrushProperty, "Brush.BorderDefault");
var rail = new DockPanel { Width = 40 };
@@ -291,7 +291,7 @@ public sealed class BrowserView : UserControl
// --- Search (26h): accent border on focus, match count on the right ---
_search = new TextBox
{
- Watermark = Loc.T("Search"),
+ Watermark = Loc.T("browser.search"),
BorderThickness = new Thickness(0),
Background = Brushes.Transparent,
FontSize = 11,
@@ -492,7 +492,7 @@ public sealed class BrowserView : UserControl
// Nothing is open while folded, so no tab is marked active.
for (int i = 0; i < _tabs.Length; i++)
_tabs[i].Classes.Set("active", !collapsed && i == _active);
- ToolTip.SetTip(_collapseBtn, collapsed ? Loc.T("Expand browser") : Loc.T("Collapse browser"));
+ ToolTip.SetTip(_collapseBtn, collapsed ? Loc.T("browser.expand_browser") : Loc.T("browser.collapse_browser"));
if (persist && _settings is not null)
{
_settings.Current.BrowserCollapsed = collapsed;
@@ -635,16 +635,16 @@ public sealed class BrowserView : UserControl
&& (_vm.FilterMode != BrowserFilter.None || _vm.CategoryFilter(tab).Length > 0);
bool sampleFilter = tab == FilesTab && _vm is not null && (!_vm.SampleFilter.IsEmpty || _vm.SimilarAnchor is not null);
if (sampleFilter && _vm!.IndexProgress.Total > 0)
- return (Loc.T("No matches yet"), Loc.T("Nota is still analysing your samples — more matches appear as it goes."));
- if (searching || filtering || sampleFilter) return (Loc.T("No matches"), Loc.T("Try a different search or clear the filters."));
+ return (Loc.T("browser.no_matches_yet"), Loc.T("browser.nota_is_still_analysing_your"));
+ if (searching || filtering || sampleFilter) return (Loc.T("browser.no_matches"), Loc.T("browser.try_a_different_search_or"));
return tab switch
{
- 0 => (Loc.T("No instruments yet"), Loc.T("Nota's built-in synths plus your VST/AU plug-ins. Scan your plug-ins in Settings → Plug-ins to add more.")),
- 1 => (Loc.T("No audio effects yet"), Loc.T("Nota's built-in effects plus your VST/AU plug-ins. Scan your plug-ins in Settings → Plug-ins to add more.")),
- 2 => (Loc.T("No MIDI effects yet"), Loc.T("Arpeggiator, chord, scale and more — they process notes before an instrument; drop one to the left of an instrument in a track.")),
- 3 => (Loc.T("No samples yet"), Loc.T("Add audio files to your Samples folder (Settings → Library) or install free packs from Settings → Downloads → Sample packs, then browse them here as a folder tree. You can also drag files in from Finder.")),
- 4 => (Loc.T("No presets yet"), Loc.T("Right-click a device header and choose Save preset; it appears here grouped by category and device.")),
- _ => (Loc.T("No projects yet"), MenuKit.Keys(Loc.T("Save a project (⌘S) into your Projects folder (Settings → Library) and it shows up here."))),
+ 0 => (Loc.T("browser.no_instruments_yet"), Loc.T("browser.notas_built_in_synths_plus")),
+ 1 => (Loc.T("browser.no_audio_effects_yet"), Loc.T("browser.notas_built_in_effects_plus")),
+ 2 => (Loc.T("browser.no_midi_effects_yet"), Loc.T("browser.arpeggiator_chord_scale_and_more")),
+ 3 => (Loc.T("browser.no_samples_yet"), Loc.T("browser.add_audio_files_to_your")),
+ 4 => (Loc.T("browser.no_presets_yet"), Loc.T("browser.right_click_a_device_header")),
+ _ => (Loc.T("browser.no_projects_yet"), MenuKit.Keys(Loc.T("browser.save_a_project_s_into"))),
};
}
@@ -667,7 +667,7 @@ public sealed class BrowserView : UserControl
var (bi, pl) = _vm.VisibleDeviceCounts(tab);
// The total is already in the search box, so spend the line on the split — it is
// the thing the sections exist to show, and it fits a narrow panel.
- return Loc.F("{0} built-in · {1}", bi, Loc.Plural(pl, "{0} plug-in", "{0} plug-ins"));
+ return Loc.F("browser.built_in", bi, Loc.Plural("browser.plug_ins", pl));
}
int n = VisibleCount(tab);
// Filtered, the folders on screen are only there to hold the matches: count those.
@@ -675,9 +675,9 @@ public sealed class BrowserView : UserControl
n = System.Linq.Enumerable.Count(_vm.Samples, s => s.Kind != BrowserItemKind.Folder);
return tab switch
{
- 3 => Loc.Plural(n, "{0} sample", "{0} samples") + AnalysingSuffix(),
- 4 => Loc.Plural(n, "{0} preset", "{0} presets"),
- _ => Loc.Plural(n, "{0} project", "{0} projects"),
+ 3 => Loc.Plural("browser.samples", n) + AnalysingSuffix(),
+ 4 => Loc.Plural("browser.presets_n", n),
+ _ => Loc.Plural("browser.projects_n", n),
};
}
@@ -685,7 +685,7 @@ public sealed class BrowserView : UserControl
private string AnalysingSuffix()
{
var (done, total) = _vm?.IndexProgress ?? (0, 0);
- return total > 0 ? Loc.F(" · analysing {0}\u2009%", done * 100 / total) : "";
+ return total > 0 ? Loc.F("browser.analysing", done * 100 / total) : "";
}
private void SelectTab(int index)
@@ -811,7 +811,7 @@ public sealed class BrowserView : UserControl
if (foldable)
{
grid.Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(grid, item.IsExpanded ? Loc.T("Collapse") : Loc.T("Expand"));
+ ToolTip.SetTip(grid, item.IsExpanded ? Loc.T("browser.collapse") : Loc.T("browser.expand"));
grid.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(grid).Properties.IsLeftButtonPressed) return;
@@ -1064,7 +1064,7 @@ public sealed class BrowserView : UserControl
};
btn.BindResource(Border.BackgroundProperty, "Brush.BgSunken");
btn.BindResource(Border.BorderBrushProperty, "Brush.BorderDefault");
- ToolTip.SetTip(btn, Loc.T("Sort and view"));
+ ToolTip.SetTip(btn, Loc.T("browser.sort_and_view"));
btn.PointerPressed += (_, e) => { ShowOptionsMenu(btn); e.Handled = true; };
return btn;
}
@@ -1072,14 +1072,14 @@ public sealed class BrowserView : UserControl
private void ShowOptionsMenu(Control anchor)
{
var flyout = new MenuFlyout();
- flyout.Items.Add(CheckItem(Loc.T("Show type tags"), _settings?.Current.BrowserShowTypeTags ?? true, v =>
+ flyout.Items.Add(CheckItem(Loc.T("browser.show_type_tags"), _settings?.Current.BrowserShowTypeTags ?? true, v =>
{
if (_settings is null) return;
_settings.Current.BrowserShowTypeTags = v;
_settings.Save();
RefreshRows();
}));
- flyout.Items.Add(CheckItem(Loc.T("Category chips"), CategoryChipsOn, v =>
+ flyout.Items.Add(CheckItem(Loc.T("browser.category_chips"), CategoryChipsOn, v =>
{
if (_settings is not null) { _settings.Current.BrowserCategoryChips = v; _settings.Save(); }
// A hidden chip must not keep narrowing the list.
@@ -1087,13 +1087,13 @@ public sealed class BrowserView : UserControl
RebuildCategoryChips();
RefreshCounts();
}));
- flyout.Items.Add(CheckItem(Loc.T("Group by source"), _vm?.GroupBySource ?? true, v =>
+ flyout.Items.Add(CheckItem(Loc.T("browser.group_by_source"), _vm?.GroupBySource ?? true, v =>
{
if (_vm is not null) _vm.GroupBySource = v;
if (_settings is not null) { _settings.Current.BrowserGroupBySource = v; _settings.Save(); }
RefreshCounts();
}));
- flyout.Items.Add(CheckItem(Loc.T("Favorites first"), _vm?.FavoritesFirst ?? true, v =>
+ flyout.Items.Add(CheckItem(Loc.T("browser.favorites_first"), _vm?.FavoritesFirst ?? true, v =>
{
if (_vm is not null) _vm.FavoritesFirst = v;
if (_settings is not null) { _settings.Current.BrowserFavoritesFirst = v; _settings.Save(); }
@@ -1104,11 +1104,11 @@ public sealed class BrowserView : UserControl
// What happens when a sample lands on the arrangement.
var s = _settings;
flyout.Items.Add(new Separator());
- flyout.Items.Add(CheckItem(Loc.T("Warp loops to project tempo"), s.Current.SamplesWarpLoops, v => { s.Current.SamplesWarpLoops = v; s.Save(); }));
- flyout.Items.Add(CheckItem(Loc.T("Transpose to project key"), s.Current.SamplesMatchKey, v => { s.Current.SamplesMatchKey = v; s.Save(); }));
+ flyout.Items.Add(CheckItem(Loc.T("browser.warp_loops_to_project_tempo"), s.Current.SamplesWarpLoops, v => { s.Current.SamplesWarpLoops = v; s.Save(); }));
+ flyout.Items.Add(CheckItem(Loc.T("browser.transpose_to_project_key"), s.Current.SamplesMatchKey, v => { s.Current.SamplesMatchKey = v; s.Save(); }));
}
flyout.Items.Add(new Separator());
- var editTags = new MenuItem { Header = Loc.T("Edit tags…") };
+ var editTags = new MenuItem { Header = Loc.T("browser.edit_tags") };
editTags.Click += (_, _) => EditTagsRequested?.Invoke(null);
flyout.Items.Add(editTags);
flyout.ShowAt(anchor);
@@ -1248,7 +1248,7 @@ public sealed class BrowserView : UserControl
{
_chipsPanel.ClearChips(); // the "+N" is a permanent child, not one of the chips
if (_vm is null) return;
- _chipsPanel.Children.Add(MakeChip(Loc.T("Favorites"), null,
+ _chipsPanel.Children.Add(MakeChip(Loc.T("browser.favorites"), null,
_vm.FilterMode == BrowserFilter.Favorites, () => ToggleFilter(BrowserFilter.Favorites, "")));
foreach (var t in _vm.Tags)
{
@@ -1317,19 +1317,19 @@ public sealed class BrowserView : UserControl
{
string stem = System.IO.Path.GetFileNameWithoutExtension(anchor.Name);
if (stem.Length > 18) stem = stem[..17] + "…";
- var like = MakeChip(Loc.F("Like {0}", stem), null, true, () => { _vm.ClearSimilar(); RebuildSampleChips(); RefreshCounts(); });
- ToolTip.SetTip(like, Loc.F("Sounds like {0}, closest first — click to go back to all samples", anchor.Name));
+ var like = MakeChip(Loc.F("browser.like", stem), null, true, () => { _vm.ClearSimilar(); RebuildSampleChips(); RefreshCounts(); });
+ ToolTip.SetTip(like, Loc.F("browser.sounds_like_closest_first_click", anchor.Name));
_sampleChips.Children.Add(like);
}
- _sampleChips.Children.Add(MakeChip(Loc.T("Loops"), null, f.Kind == SampleKind.Loop,
+ _sampleChips.Children.Add(MakeChip(Loc.T("browser.loops"), null, f.Kind == SampleKind.Loop,
() => SetSampleFilter(f with { Kind = f.Kind == SampleKind.Loop ? SampleKind.Unknown : SampleKind.Loop })));
- _sampleChips.Children.Add(MakeChip(Loc.T("One-shots"), null, f.Kind == SampleKind.OneShot,
+ _sampleChips.Children.Add(MakeChip(Loc.T("browser.one_shots"), null, f.Kind == SampleKind.OneShot,
() => SetSampleFilter(f with { Kind = f.Kind == SampleKind.OneShot ? SampleKind.Unknown : SampleKind.OneShot })));
ChipBorder? bpm = null, key = null;
bpm = MakeChip(f.HasBpm ? f.BpmCaption + "\u2009BPM" : "BPM", null, f.HasBpm, () => ShowBpmFilter(bpm!));
- key = MakeChip(f.Key?.Long ?? Loc.T("Key"), null, f.Key is not null, () => ShowKeyFilter(key!));
- ToolTip.SetTip(bpm, Loc.T("Filter by tempo"));
- ToolTip.SetTip(key, Loc.T("Filter by key — a key also shows its relative (A minor ↔ C major)"));
+ key = MakeChip(f.Key?.Long ?? Loc.T("browser.key"), null, f.Key is not null, () => ShowKeyFilter(key!));
+ ToolTip.SetTip(bpm, Loc.T("browser.filter_by_tempo"));
+ ToolTip.SetTip(key, Loc.T("browser.filter_by_key_a_key"));
_sampleChips.Children.Add(bpm);
_sampleChips.Children.Add(key);
}
@@ -1364,14 +1364,14 @@ public sealed class BrowserView : UserControl
max.TextChanged += (_, _) => Apply();
var dash = new TextBlock { Text = "–", VerticalAlignment = VerticalAlignment.Center };
dash.BindResource(TextBlock.ForegroundProperty, "Brush.TextTertiary");
- var unit = new TextBlock { Text = Loc.T("BPM"), Classes = { "Caption" }, VerticalAlignment = VerticalAlignment.Center };
+ var unit = new TextBlock { Text = Loc.T("browser.bpm_caps"), Classes = { "Caption" }, VerticalAlignment = VerticalAlignment.Center };
var fields = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, Children = { min, dash, max, unit } };
var actions = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6 };
if (ProjectTempo?.Invoke() is > 0 and var tempo)
{
- var near = new Button { Content = Loc.F("Project tempo ±5\u2009%"), Classes = { "ghost" } };
- ToolTip.SetTip(near, Loc.F("Loops within 5\u2009% of {0}\u2009BPM warp to it cleanly", SampleInfo.FormatBpm(tempo)));
+ var near = new Button { Content = Loc.F("browser.project_tempo_5"), Classes = { "ghost" } };
+ ToolTip.SetTip(near, Loc.F("browser.loops_within_5_of_bpm", SampleInfo.FormatBpm(tempo)));
near.Click += (_, _) =>
{
min.Text = SampleInfo.FormatBpm(Math.Floor(tempo * 0.95));
@@ -1379,7 +1379,7 @@ public sealed class BrowserView : UserControl
};
actions.Children.Add(near);
}
- var any = new Button { Content = Loc.T("Any tempo"), Classes = { "ghost" } };
+ var any = new Button { Content = Loc.T("browser.any_tempo"), Classes = { "ghost" } };
any.Click += (_, _) => { flyout.Hide(); SetSampleFilter(_vm.SampleFilter with { BpmMin = 0, BpmMax = 0 }); };
actions.Children.Add(any);
@@ -1391,18 +1391,18 @@ public sealed class BrowserView : UserControl
{
if (_vm is null) return;
var extras = new List<(string, MusicalKey)>();
- if (ProjectKey?.Invoke() is { } pk) extras.Add((Loc.F("Project key · {0}", pk.Short), pk));
- KeyPicker.Show(anchor, _vm.SampleFilter.Key, Loc.T("Any key"), k => SetSampleFilter(_vm.SampleFilter with { Key = k }), extras);
+ if (ProjectKey?.Invoke() is { } pk) extras.Add((Loc.F("browser.project_key", pk.Short), pk));
+ KeyPicker.Show(anchor, _vm.SampleFilter.Key, Loc.T("browser.any_key"), k => SetSampleFilter(_vm.SampleFilter with { Key = k }), extras);
}
private async void ShowSimilar(BrowserItem item)
{
if (_vm is null) return;
- _statusText.Text = Loc.F("Finding sounds like {0}…", item.Name);
+ _statusText.Text = Loc.F("browser.finding_sounds_like", item.Name);
int n = await _vm.ShowSimilarAsync(item);
RebuildSampleChips();
RefreshCounts();
- if (n == 0) _statusText.Text = Loc.T("Couldn't analyse that sample");
+ if (n == 0) _statusText.Text = Loc.T("browser.couldnt_analyse_that_sample");
}
private void ToggleFilter(BrowserFilter mode, string tagId)
@@ -1570,14 +1570,14 @@ public sealed class BrowserView : UserControl
private static string ItemKindLabel(BrowserItem item) => item.Kind switch
{
- BrowserItemKind.BuiltinInstrument or BrowserItemKind.PluginInstrument => Loc.T("Instrument"),
- BrowserItemKind.BuiltinEffect or BrowserItemKind.PluginEffect => Loc.T("Audio effect"),
- BrowserItemKind.BuiltinMidiEffect => Loc.T("MIDI effect"),
- BrowserItemKind.Sample => Loc.T("Sample"),
- BrowserItemKind.MidiFile => Loc.T("MIDI file"),
- BrowserItemKind.Project => Loc.T("Project"),
- BrowserItemKind.Preset => Loc.T("Preset"),
- BrowserItemKind.Folder => Loc.T("Folder"),
+ BrowserItemKind.BuiltinInstrument or BrowserItemKind.PluginInstrument => Loc.T("common.instrument"),
+ BrowserItemKind.BuiltinEffect or BrowserItemKind.PluginEffect => Loc.T("browser.audio_effect"),
+ BrowserItemKind.BuiltinMidiEffect => Loc.T("browser.midi_effect"),
+ BrowserItemKind.Sample => Loc.T("common.sample"),
+ BrowserItemKind.MidiFile => Loc.T("browser.midi_file"),
+ BrowserItemKind.Project => Loc.T("browser.project"),
+ BrowserItemKind.Preset => Loc.T("browser.preset"),
+ BrowserItemKind.Folder => Loc.T("browser.folder"),
_ => "",
};
@@ -1589,11 +1589,11 @@ public sealed class BrowserView : UserControl
if (item.LibraryKey.Length > 0 && _vm is not null)
{
bool fav = _vm.IsFavorite(item);
- var favItem = new MenuItem { Header = fav ? Loc.T("Remove from favorites") : Loc.T("Add to favorites") };
+ var favItem = new MenuItem { Header = fav ? Loc.T("browser.remove_from_favorites") : Loc.T("browser.add_to_favorites") };
favItem.Click += (_, _) => _vm.ToggleFavorite(item);
flyout.Items.Add(favItem);
- var tagsMenu = new MenuItem { Header = Loc.T("Tags") };
+ var tagsMenu = new MenuItem { Header = Loc.T("browser.tags") };
foreach (var t in _vm.Tags)
{
var tag = t;
@@ -1604,9 +1604,9 @@ public sealed class BrowserView : UserControl
tagsMenu.Items.Add(mi);
}
if (_vm.Tags.Count > 0) tagsMenu.Items.Add(new Separator());
- var newTag = new MenuItem { Header = Loc.T("New tag…") };
+ var newTag = new MenuItem { Header = Loc.T("browser.new_tag") };
newTag.Click += (_, _) => EditTagsRequested?.Invoke(item); // create + assign to this device
- var editTags = new MenuItem { Header = Loc.T("Edit tags…") };
+ var editTags = new MenuItem { Header = Loc.T("browser.edit_tags") };
editTags.Click += (_, _) => EditTagsRequested?.Invoke(null); // manage all
tagsMenu.Items.Add(newTag);
tagsMenu.Items.Add(editTags);
@@ -1618,7 +1618,7 @@ public sealed class BrowserView : UserControl
{
case BrowserItemKind.Sample when _vm?.HasSampleIndex == true:
{
- var similar = new MenuItem { Header = Loc.T("Show similar sounds") };
+ var similar = new MenuItem { Header = Loc.T("browser.show_similar_sounds") };
similar.Click += (_, _) => ShowSimilar(item);
var reveal = new MenuItem { Header = MenuKit.RevealLabel };
reveal.Click += (_, _) => RevealRequested?.Invoke(item);
@@ -1634,7 +1634,7 @@ public sealed class BrowserView : UserControl
reveal.Click += (_, _) => RevealRequested?.Invoke(item);
flyout.Items.Add(reveal);
flyout.Items.Add(new Separator());
- flyout.Items.Add(MenuKit.Danger(Loc.T("Delete…"), GlyphKind.Trash, () => DeletePresetRequested?.Invoke(item)));
+ flyout.Items.Add(MenuKit.Danger(Loc.T("browser.delete"), GlyphKind.Trash, () => DeletePresetRequested?.Invoke(item)));
return flyout;
}
// The Presets tab's category / device rows group by what a preset holds; the files
@@ -1656,9 +1656,9 @@ public sealed class BrowserView : UserControl
}
case BrowserItemKind.Folder when _active == FilesTab: // real sample folders (preset folders are synthetic)
{
- var multi = new MenuItem { Header = Loc.T("Create multisample…") };
+ var multi = new MenuItem { Header = Loc.T("browser.create_multisample") };
multi.Click += (_, _) => CreateMultisampleRequested?.Invoke(item);
- ToolTip.SetTip(multi, Loc.T("Map the folder's samples by their names into Nota Mosaic presets"));
+ ToolTip.SetTip(multi, Loc.T("browser.map_the_folders_samples_by"));
var reveal = new MenuItem { Header = MenuKit.RevealLabel };
reveal.Click += (_, _) => RevealRequested?.Invoke(item);
flyout.Items.Add(multi);
@@ -1667,11 +1667,11 @@ public sealed class BrowserView : UserControl
}
case BrowserItemKind.Project:
{
- var open = new MenuItem { Header = Loc.T("Open") };
+ var open = new MenuItem { Header = Loc.T("common.open") };
open.Click += (_, _) => ItemActivated?.Invoke(item, KeyModifiers.None);
var reveal = new MenuItem { Header = MenuKit.RevealLabel };
reveal.Click += (_, _) => RevealRequested?.Invoke(item);
- var del = MenuKit.Danger(Loc.T("Delete…"), GlyphKind.Trash, () => DeleteProjectRequested?.Invoke(item));
+ var del = MenuKit.Danger(Loc.T("browser.delete"), GlyphKind.Trash, () => DeleteProjectRequested?.Invoke(item));
flyout.Items.Add(open);
flyout.Items.Add(reveal);
flyout.Items.Add(new Separator());
diff --git a/src/managed/Nota.App/ClipAdsrKit.cs b/src/managed/Nota.App/ClipAdsrKit.cs
index 6442698d..22041efd 100644
--- a/src/managed/Nota.App/ClipAdsrKit.cs
+++ b/src/managed/Nota.App/ClipAdsrKit.cs
@@ -147,9 +147,9 @@ internal static class ClipAdsrKit
string T(double beats) => NotaNum.Time(beats * 60.0 / Math.Max(1, bpm));
return h switch
{
- AdsrHandle.Attack => Loc.F("Attack {0}", T(a.AttackBeats)),
- AdsrHandle.DecaySustain => Loc.F("Decay {0} · Sustain {1}", T(a.DecayBeats), SustainText(a.Sustain)),
- AdsrHandle.Release => Loc.F("Release {0}", T(a.ReleaseBeats)),
+ AdsrHandle.Attack => Loc.F("clip_adsr.attack", T(a.AttackBeats)),
+ AdsrHandle.DecaySustain => Loc.F("clip_adsr.decay_sustain", T(a.DecayBeats), SustainText(a.Sustain)),
+ AdsrHandle.Release => Loc.F("clip_adsr.release", T(a.ReleaseBeats)),
_ => "",
};
}
@@ -173,20 +173,20 @@ internal static class ClipAdsrKit
switch (h)
{
case AdsrHandle.Attack:
- list.Add(Time(Loc.T("Attack"), a => a.DecayBeats + a.ReleaseBeats, a => a.AttackBeats, (a, b) => { a.AttackBeats = b; return a; }, AdsrHandle.Attack));
+ list.Add(Time(Loc.T("common.attack"), a => a.DecayBeats + a.ReleaseBeats, a => a.AttackBeats, (a, b) => { a.AttackBeats = b; return a; }, AdsrHandle.Attack));
break;
case AdsrHandle.DecaySustain:
- list.Add(Time(Loc.T("Decay"), a => a.AttackBeats + a.ReleaseBeats, a => a.DecayBeats, (a, b) => { a.DecayBeats = b; return a; }, AdsrHandle.DecaySustain));
- list.Add(new ValueField(Loc.T("Sustain"), () => A().Sustain, SustainText, n => { var a = A(); a.Sustain = (float)n; commit(a); }));
+ list.Add(Time(Loc.T("common.decay"), a => a.AttackBeats + a.ReleaseBeats, a => a.DecayBeats, (a, b) => { a.DecayBeats = b; return a; }, AdsrHandle.DecaySustain));
+ list.Add(new ValueField(Loc.T("common.sustain"), () => A().Sustain, SustainText, n => { var a = A(); a.Sustain = (float)n; commit(a); }));
break;
case AdsrHandle.AttackOrSustain: // the shared corner: attack, decay and sustain; one combined reset
- list.Add(Time(Loc.T("Attack"), a => a.DecayBeats + a.ReleaseBeats, a => a.AttackBeats, (a, b) => { a.AttackBeats = b; return a; }, AdsrHandle.AttackOrSustain));
- list.Add(Time(Loc.T("Decay"), a => a.AttackBeats + a.ReleaseBeats, a => a.DecayBeats, (a, b) => { a.DecayBeats = b; return a; }, AdsrHandle.DecaySustain)
+ list.Add(Time(Loc.T("common.attack"), a => a.DecayBeats + a.ReleaseBeats, a => a.AttackBeats, (a, b) => { a.AttackBeats = b; return a; }, AdsrHandle.AttackOrSustain));
+ list.Add(Time(Loc.T("common.decay"), a => a.AttackBeats + a.ReleaseBeats, a => a.DecayBeats, (a, b) => { a.DecayBeats = b; return a; }, AdsrHandle.DecaySustain)
with { Reset = null });
- list.Add(new ValueField(Loc.T("Sustain"), () => A().Sustain, SustainText, n => { var a = A(); a.Sustain = (float)n; commit(a); }));
+ list.Add(new ValueField(Loc.T("common.sustain"), () => A().Sustain, SustainText, n => { var a = A(); a.Sustain = (float)n; commit(a); }));
break;
case AdsrHandle.Release:
- list.Add(Time(Loc.T("Release"), a => a.AttackBeats + a.DecayBeats, a => a.ReleaseBeats, (a, b) => { a.ReleaseBeats = b; return a; }, AdsrHandle.Release));
+ list.Add(Time(Loc.T("common.release"), a => a.AttackBeats + a.DecayBeats, a => a.ReleaseBeats, (a, b) => { a.ReleaseBeats = b; return a; }, AdsrHandle.Release));
break;
}
return list;
diff --git a/src/managed/Nota.App/ClipEditorView.cs b/src/managed/Nota.App/ClipEditorView.cs
index 3074c7d9..031bd0ec 100644
--- a/src/managed/Nota.App/ClipEditorView.cs
+++ b/src/managed/Nota.App/ClipEditorView.cs
@@ -58,10 +58,10 @@ public sealed class ClipEditorView : UserControl
DockPanel.SetDock(_tools, Dock.Right);
var body = new DockPanel { Children = { _props, _tools, roll } };
- _toolsToggle = new ToggleButton { Content = Loc.T("Tools"), Padding = new Thickness(12, 0), Classes = { "chip" } };
+ _toolsToggle = new ToggleButton { Content = Loc.T("clip_editor.tools"), Padding = new Thickness(12, 0), Classes = { "chip" } };
_toolsToggle.Click += (_, _) => SetTools(_toolsToggle.IsChecked == true);
- var tabs = Segments(new[] { Loc.T("Notes"), Loc.T("Envelopes") }, 0, i => ShowTab(i == 1), out _setTab);
+ var tabs = Segments(new[] { Loc.T("clip_editor.notes"), Loc.T("clip_editor.envelopes") }, 0, i => ShowTab(i == 1), out _setTab);
if (_envOverlay is null) Inactive.Set(tabs, true); // session slots carry no clip envelope
var right = new StackPanel
{
@@ -91,8 +91,8 @@ public sealed class ClipEditorView : UserControl
private static Control? ModeControl(PianoRollView roll, Action<bool>? setTrackMode)
{
if (setTrackMode is null) return null;
- var seg = Segments(new[] { Loc.T("Clip"), Loc.T("Track") }, roll.Clips.TrackMode ? 1 : 0, i => setTrackMode(i == 1), out _, fill: true);
- ToolTip.SetTip(seg, Loc.T("Clip: the selected clip · Track: every clip on the track"));
+ var seg = Segments(new[] { Loc.T("common.clip"), Loc.T("common.track") }, roll.Clips.TrackMode ? 1 : 0, i => setTrackMode(i == 1), out _, fill: true);
+ ToolTip.SetTip(seg, Loc.T("clip_editor.clip_the_selected_clip_track"));
return seg;
}
@@ -102,7 +102,7 @@ public sealed class ClipEditorView : UserControl
if (_engine is null) return;
var a = Roll.ActiveClip;
if (a.TrackId <= 0) return;
- _nameText.Text = HeaderName(ClipName(a.TrackId, a.ClipIndex, Loc.F("Track {0} clip", a.TrackId)));
+ _nameText.Text = HeaderName(ClipName(a.TrackId, a.ClipIndex, Loc.F("clip_editor.track_clip", a.TrackId)));
_colorBar.Background = Roll.TrackBrush;
_props.SetStart(a.StartBeat);
_envOverlay = new EnvOverlay(Roll, _engine, a.TrackId, a.ClipIndex, a.LengthBeats)
@@ -122,7 +122,7 @@ public sealed class ClipEditorView : UserControl
Content = new Glyph(GlyphKind.Speaker, 14), Padding = new Thickness(8, 0), Classes = { "chip" },
IsChecked = PianoRollView.AuditionEnabled,
};
- ToolTip.SetTip(b, Loc.T("Hear notes as you place, click or drag them"));
+ ToolTip.SetTip(b, Loc.T("clip_editor.hear_notes_as_you_place"));
b.Click += (_, _) => PianoRollView.SetAuditionEnabled(b.IsChecked == true);
void Sync() => b.IsChecked = PianoRollView.AuditionEnabled;
b.AttachedToVisualTree += (_, _) => { Sync(); PianoRollView.AuditionToggled += Sync; };
@@ -133,8 +133,8 @@ public sealed class ClipEditorView : UserControl
// Fit to notes (⇧F): rows zoom so every note of the clip is in view.
private static Control FitControl(PianoRollView roll)
{
- var b = new Button { Content = Loc.T("Fit"), Padding = new Thickness(10, 0), Classes = { "chip" } };
- ToolTip.SetTip(b, Loc.T("Fit to notes (⇧F)"));
+ var b = new Button { Content = Loc.T("clip_editor.fit"), Padding = new Thickness(10, 0), Classes = { "chip" } };
+ ToolTip.SetTip(b, Loc.T("clip_editor.fit_to_notes_f"));
b.Click += (_, _) => roll.FitToNotes();
return b;
}
@@ -185,19 +185,19 @@ public sealed class ClipEditorView : UserControl
{
_keyText = Mono("");
_modeText = new TextBlock { FontSize = NotaType.Body };
- var sw = SwitchRow(Loc.T("Scale"), () => Roll.ScaleOn, () => { Roll.SetScale(!Roll.ScaleOn, Roll.ScaleRoot, Roll.ScaleIndex); PaintScale(); }, out _syncScale);
+ var sw = SwitchRow(Loc.T("clip_editor.scale"), () => Roll.ScaleOn, () => { Roll.SetScale(!Roll.ScaleOn, Roll.ScaleRoot, Roll.ScaleIndex); PaintScale(); }, out _syncScale);
var key = Dropdown(_keyText, a => ShowMenu(a, PianoRollView.KeyNames, Roll.ScaleRoot, i => { Roll.SetScale(true, i, Roll.ScaleIndex); PaintScale(); }));
var mode = Dropdown(_modeText, a => ShowMenu(a, PianoRollView.ScaleNames, Roll.ScaleIndex, i => { Roll.SetScale(true, Roll.ScaleRoot, i); PaintScale(); }));
// Deletes the notes the overlay dims; live only while some note is out of scale.
- _dropOutOfScale = ClipEditorKit.Button(Loc.T("Remove out of scale"), () => Roll.RemoveOutOfScaleNotes());
+ _dropOutOfScale = ClipEditorKit.Button(Loc.T("clip_editor.remove_out_of_scale"), () => Roll.RemoveOutOfScaleNotes());
_dropOutOfScale.HorizontalAlignment = HorizontalAlignment.Left;
_dropOutOfScale.VerticalAlignment = VerticalAlignment.Center;
- ToolTip.SetTip(_dropOutOfScale, Loc.T("Delete every note outside the scale"));
+ ToolTip.SetTip(_dropOutOfScale, Loc.T("clip_editor.delete_every_note_outside_the"));
Roll.Changed += () => _dropOutOfScale.IsEnabled = Roll.HasOutOfScaleNotes;
Roll.FoldToggled += _ => PaintScale(); // ⌥⇧F flips it from the keyboard too
Roll.FoldChanged += PaintFold; // …and the host switches it with the active clip's track
// Fold (specs/045): the scale's rows, or a Drum Rack's pads, and nothing else.
- _fold = SwitchRow(Loc.T("Fold"), () => Roll.Folded, () => { Roll.SetFold(!Roll.Folded, user: true); PaintScale(); }, out _syncFold);
+ _fold = SwitchRow(Loc.T("clip_editor.fold"), () => Roll.Folded, () => { Roll.SetFold(!Roll.Folded, user: true); PaintScale(); }, out _syncFold);
PaintScale();
return new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { sw, key, mode, _fold, _dropOutOfScale } };
}
@@ -208,8 +208,8 @@ public sealed class ClipEditorView : UserControl
private void PaintFold()
{
_syncFold();
- string what = Roll.FoldShowsPads ? Loc.T("only the pads") : Roll.ScaleOn ? Loc.T("only the scale's notes") : Loc.T("only the notes in use");
- string tip = MenuKit.Keys(Loc.F("Fold: show {0} (⌥⇧F)", what));
+ string what = Roll.FoldShowsPads ? Loc.T("clip_editor.only_the_pads") : Roll.ScaleOn ? Loc.T("clip_editor.only_the_scales_notes") : Loc.T("clip_editor.only_the_notes_in_use");
+ string tip = MenuKit.Keys(Loc.F("clip_editor.fold_show_f", what));
if (Roll.FoldHasNothing) tip += Roll.FoldShowsPads ? "\nThe rack has no pads yet" : "\nSet a scale or add notes to fold";
ToolTip.SetTip(_fold, tip);
}
@@ -229,7 +229,7 @@ public sealed class ClipEditorView : UserControl
// ---- envelope overlay: a wash over the notes, the curve, a target picker ----------
private sealed class EnvOverlay : UserControl
{
- private static readonly string[] Targets = { Loc.T("Velocity"), Loc.T("Volume") };
+ private static readonly string[] Targets = { Loc.T("common.velocity"), Loc.T("common.volume") };
private readonly IAudioEngine _engine;
private readonly int _trackId, _clipIndex;
private readonly EnvCanvas _canvas;
@@ -255,7 +255,7 @@ public sealed class ClipEditorView : UserControl
{
new TextBlock
{
- Text = Loc.T("Env"), FontSize = 9, FontWeight = FontWeight.Medium,
+ Text = Loc.T("clip_editor.env"), FontSize = 9, FontWeight = FontWeight.Medium,
Foreground = NotaPalette.TextTertiary, VerticalAlignment = VerticalAlignment.Center,
},
_targetText,
@@ -274,7 +274,7 @@ public sealed class ClipEditorView : UserControl
Load();
});
};
- ToolTip.SetTip(chip, Loc.T("Click to add a point · drag to move · right-click to delete"));
+ ToolTip.SetTip(chip, Loc.T("clip_editor.click_to_add_a_point_2"));
Content = new Grid
{
Children =
@@ -477,7 +477,7 @@ public sealed class ClipEditorView : UserControl
if (Background is not null) ctx.FillRectangle(Background, new Rect(0, 0, w, h));
if (_pts.Count == 0) // empty state: one Ink 5 line
{
- var ft = new FormattedText(Loc.T("Click to add a point"), NotaNum.Culture, FlowDirection.LeftToRight, NotaFonts.Sans, NotaType.Body, EmptyInk);
+ var ft = new FormattedText(Loc.T("clip_editor.click_to_add_a_point"), NotaNum.Culture, FlowDirection.LeftToRight, NotaFonts.Sans, NotaType.Body, EmptyInk);
ctx.DrawText(ft, new Point((w - ft.Width) / 2, (h - ft.Height) / 2));
return;
}
diff --git a/src/managed/Nota.App/ClipPropsView.cs b/src/managed/Nota.App/ClipPropsView.cs
index 90a44902..87478a55 100644
--- a/src/managed/Nota.App/ClipPropsView.cs
+++ b/src/managed/Nota.App/ClipPropsView.cs
@@ -53,23 +53,23 @@ public sealed class ClipPropsView : UserControl
_gridText.Text = roll.Grids.Quantize.Label;
// CLIP — clips always loop in this model; the switch waits for a per-clip loop.
- var loop = SwitchRow(Loc.T("Loop"), () => true, () => { }, out _, _loopText);
+ var loop = SwitchRow(Loc.T("common.loop"), () => true, () => { }, out _, _loopText);
loop.IsEnabled = false;
- ToolTip.SetTip(loop, Loc.T("Clips always loop"));
- var pair = Pair(Labeled(Loc.T("Start"), Field(_startText)), Labeled(Loc.T("Length"), Field(_lengthText)));
- var clip = mode is null ? Section(Loc.T("Clip"), pair, loop) : Section(Loc.T("Clip"), mode, pair, loop);
+ ToolTip.SetTip(loop, Loc.T("clip_props.clips_always_loop"));
+ var pair = Pair(Labeled(Loc.T("common.start"), Field(_startText)), Labeled(Loc.T("common.length"), Field(_lengthText)));
+ var clip = mode is null ? Section(Loc.T("common.clip"), pair, loop) : Section(Loc.T("common.clip"), mode, pair, loop);
// QUANTIZE — its own step (not the snap grid, which follows the zoom), one-tap
// Quantize at the strength below.
- var grid = Section(Loc.T("Quantize"),
+ var grid = Section(Loc.T("common.quantize"),
Pair(Dropdown(_gridText, a => ShowMenu(a, Array.ConvertAll(QuantizeSteps, q => q.Label),
Array.IndexOf(QuantizeSteps, _roll.Grids.Quantize), i =>
{
_roll.Grids.SetQuantize(QuantizeSteps[i]);
_gridText.Text = QuantizeSteps[i].Label;
})),
- ClipEditorKit.Button(Loc.T("Quantize"), () => _roll.Quantize(_strength))),
- SliderRow(Loc.T("Strength"), 64, () => _strength, v => _strength = v,
+ ClipEditorKit.Button(Loc.T("common.quantize"), () => _roll.Quantize(_strength))),
+ SliderRow(Loc.T("clip_props.strength"), 64, () => _strength, v => _strength = v,
() => string.Format(NotaNum.Culture, "{0:0}\u2009%", _strength * 100), out _, reset: () => _strength = 0.8, valueW: 34));
// TRANSPOSE — − value +; the value turns Brass Light while it is off zero.
@@ -80,7 +80,7 @@ public sealed class ClipPropsView : UserControl
Grid.SetColumn(tField, 1); tRow.Children.Add(tField);
var plus = GlyphButton(GlyphKind.Plus, () => Transpose(1));
Grid.SetColumn(plus, 2); tRow.Children.Add(plus);
- var transpose = Section(Loc.T("Transpose"), tRow);
+ var transpose = Section(Loc.T("clip_props.transpose"), tRow);
// SELECTION — a card of read-outs, or one empty-state line in the same frame.
_selCard = Card(_selRows);
@@ -90,14 +90,14 @@ public sealed class ClipPropsView : UserControl
Height = 104, BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Control,
Child = new TextBlock
{
- Text = Loc.T("No notes selected"), FontSize = NotaType.Body, Foreground = NotaPalette.TextTertiary,
+ Text = Loc.T("clip_props.no_notes_selected"), FontSize = NotaType.Body, Foreground = NotaPalette.TextTertiary,
HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center, VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
},
};
- var selection = Section(SectionTitle(Loc.T("Selection"), _selCount), 8, _selCard, _selEmpty);
+ var selection = Section(SectionTitle(Loc.T("clip_props.selection"), _selCount), 8, _selCard, _selEmpty);
Content = Inspector(Sections(clip, grid, transpose, selection),
- Hint(Loc.T("Double-click — add or delete · edge — length · Shift — add to selection")), out var flow);
+ Hint(Loc.T("clip_props.double_click_add_or_delete")), out var flow);
Flow = flow;
PaintTranspose();
@@ -113,7 +113,7 @@ public sealed class ClipPropsView : UserControl
{
double len = _roll.ActiveLengthBeats; // the active clip's own length, several clips open or one
_lengthText.Text = Duration(len);
- _loopText.Text = string.Format(NotaNum.Culture, "{0:0.##} {1}", len, Math.Abs(len - 1) < 1e-9 ? Loc.T("beat") : Loc.T("beats"));
+ _loopText.Text = string.Format(NotaNum.Culture, "{0:0.##} {1}", len, Math.Abs(len - 1) < 1e-9 ? Loc.T("clip_props.beat") : Loc.T("clip_props.beats"));
PaintSelection();
}
@@ -140,18 +140,18 @@ public sealed class ClipPropsView : UserControl
if (sel.Count == 1)
{
var n = sel[0];
- Row(Loc.T("Pitch"), PianoRollView.NoteName(n.Pitch));
- Row(Loc.T("Start"), Position(n.StartBeat));
- Row(Loc.T("Length"), string.Format(NotaNum.Culture, "{0:0.##}/16", n.LengthBeats * 4));
- Row(Loc.T("Velocity"), Vel(n.Velocity).ToString(NotaNum.Culture), last: true);
+ Row(Loc.T("common.pitch"), PianoRollView.NoteName(n.Pitch));
+ Row(Loc.T("common.start"), Position(n.StartBeat));
+ Row(Loc.T("common.length"), string.Format(NotaNum.Culture, "{0:0.##}/16", n.LengthBeats * 4));
+ Row(Loc.T("common.velocity"), Vel(n.Velocity).ToString(NotaNum.Culture), last: true);
}
else if (sel.Count > 1)
{
int lo = sel.Min(n => n.Pitch), hi = sel.Max(n => n.Pitch);
int vLo = sel.Min(n => Vel(n.Velocity)), vHi = sel.Max(n => Vel(n.Velocity));
- Row(Loc.T("Notes"), sel.Count.ToString(NotaNum.Culture));
- Row(Loc.T("Range"), lo == hi ? PianoRollView.NoteName(lo) : $"{PianoRollView.NoteName(lo)}–{PianoRollView.NoteName(hi)}");
- Row(Loc.T("Velocity"), vLo == vHi ? vLo.ToString(NotaNum.Culture) : $"{vLo}–{vHi}", last: true);
+ Row(Loc.T("clip_props.notes"), sel.Count.ToString(NotaNum.Culture));
+ Row(Loc.T("common.range"), lo == hi ? PianoRollView.NoteName(lo) : $"{PianoRollView.NoteName(lo)}–{PianoRollView.NoteName(hi)}");
+ Row(Loc.T("common.velocity"), vLo == vHi ? vLo.ToString(NotaNum.Culture) : $"{vLo}–{vHi}", last: true);
}
void Row(string key, string value, bool last = false)
diff --git a/src/managed/Nota.App/CommandPaletteView.cs b/src/managed/Nota.App/CommandPaletteView.cs
index 2b1694a4..9cd65a13 100644
--- a/src/managed/Nota.App/CommandPaletteView.cs
+++ b/src/managed/Nota.App/CommandPaletteView.cs
@@ -72,7 +72,7 @@ internal sealed class CommandPaletteView : UserControl
_input = new TextBox
{
- Classes = { "search" }, FontSize = 14, PlaceholderText = Loc.T("Search actions, tracks, devices, presets…"),
+ Classes = { "search" }, FontSize = 14, PlaceholderText = Loc.T("command_palette.search_actions_tracks_devices_presets"),
VerticalAlignment = VerticalAlignment.Center, AcceptsReturn = false, AcceptsTab = false,
Foreground = NotaPalette.TextPrimary,
};
@@ -201,15 +201,15 @@ internal sealed class CommandPaletteView : UserControl
_sel = Math.Clamp(_sel, 0, Math.Max(0, _results.Items.Count - 1));
BuildChips(_results.Query);
BuildRows();
- _count.Text = _results.Query.IsEmpty ? "" : _results.Items.Count == 1 ? Loc.T("1 result") : Loc.F("{0} results", _results.Items.Count);
+ _count.Text = _results.Query.IsEmpty ? "" : _results.Items.Count == 1 ? Loc.T("command_palette.1_result") : Loc.F("command_palette.results", _results.Items.Count);
_layoutRow.IsVisible = _results.LayoutHint.Length > 0;
if (_layoutRow.IsVisible)
{
_layoutText.Inlines = new InlineCollection
{
- new Run(Loc.T("Showing results for ")),
+ new Run(Loc.T("command_palette.showing_results_for")),
new Run(_results.LayoutHint) { FontFamily = NotaFonts.MonoFamily, Foreground = NotaPalette.TextPrimary },
- new Run(Loc.T(" · typed in the other keyboard layout")),
+ new Run(Loc.T("command_palette.typed_in_the_other_keyboard")),
};
}
_status.Text = _index.Status;
@@ -246,7 +246,7 @@ internal sealed class CommandPaletteView : UserControl
private IEnumerable<(string Label, string Prefix)> ChipList()
{
- yield return (Loc.T("All"), "");
+ yield return (Loc.T("command_palette.all"), "");
foreach (var (p, k, label) in ParsedQuery.Prefixes)
if (k != PaletteKind.Modular || _ctx.Origin == PaletteOrigin.Modular) yield return (label, p.ToString());
}
@@ -269,7 +269,7 @@ internal sealed class CommandPaletteView : UserControl
{
_list.Children.Add(new TextBlock
{
- Text = Loc.T("Nothing matches. Try a role (reverb, comp), a character (warm, dark) or a source (vocals, drums)."),
+ Text = Loc.T("command_palette.nothing_matches_try_a_role"),
FontSize = 12, Foreground = NotaPalette.TextMuted, Margin = new Thickness(14, 18), TextWrapping = TextWrapping.Wrap,
});
return;
@@ -415,16 +415,16 @@ internal sealed class CommandPaletteView : UserControl
var hints = new List<(string Caps, string Label)>();
switch (cur.Kind)
{
- case PaletteKind.Action: hints.Add(("↵", Loc.T("run"))); break;
- case PaletteKind.Track: hints.Add(("↵", Loc.T("select"))); hints.Add(("⌘↵", Loc.T("open in Devices"))); break;
- case PaletteKind.Modular: hints.Add(("↵", Loc.T("add to canvas"))); hints.Add(("⇧↵", Loc.T("add & stay"))); break;
+ case PaletteKind.Action: hints.Add(("↵", Loc.T("command_palette.run"))); break;
+ case PaletteKind.Track: hints.Add(("↵", Loc.T("command_palette.select"))); hints.Add(("⌘↵", Loc.T("command_palette.open_in_devices"))); break;
+ case PaletteKind.Modular: hints.Add(("↵", Loc.T("command_palette.add_to_canvas"))); hints.Add(("⇧↵", Loc.T("command_palette.add_stay"))); break;
default:
- if (cur.Role == PaletteDeviceRole.Instrument) { hints.Add(("↵", Loc.T("load"))); hints.Add(("⌘↵", Loc.T("new track"))); }
- else { hints.Add(("↵", Loc.T("insert"))); hints.Add(("⌥↵", Loc.T("replace"))); }
- hints.Add(("⇧↵", Loc.T("add & stay")));
+ if (cur.Role == PaletteDeviceRole.Instrument) { hints.Add(("↵", Loc.T("command_palette.load"))); hints.Add(("⌘↵", Loc.T("command_palette.new_track"))); }
+ else { hints.Add(("↵", Loc.T("command_palette.insert"))); hints.Add(("⌥↵", Loc.T("command_palette.replace"))); }
+ hints.Add(("⇧↵", Loc.T("command_palette.add_stay")));
break;
}
- hints.Add(("Tab", Loc.T("filter")));
+ hints.Add(("Tab", Loc.T("command_palette.filter")));
foreach (var (caps, label) in hints)
{
var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5, VerticalAlignment = VerticalAlignment.Center };
@@ -550,7 +550,7 @@ internal sealed class PaletteToast : Border
Orientation = Orientation.Horizontal, Spacing = 6, VerticalAlignment = VerticalAlignment.Center,
Children =
{
- new TextBlock { Text = Loc.T("Undo"), FontSize = 11, Foreground = NotaPalette.Accent, VerticalAlignment = VerticalAlignment.Center },
+ new TextBlock { Text = Loc.T("common.undo"), FontSize = 11, Foreground = NotaPalette.Accent, VerticalAlignment = VerticalAlignment.Center },
new TextBlock { Text = MenuKit.Keys("⌘Z"), FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = NotaPalette.TextSecondary, VerticalAlignment = VerticalAlignment.Center },
},
};
diff --git a/src/managed/Nota.App/Controls/AutoFilterViews.cs b/src/managed/Nota.App/Controls/AutoFilterViews.cs
index c1c73da7..75e3bd1c 100644
--- a/src/managed/Nota.App/Controls/AutoFilterViews.cs
+++ b/src/managed/Nota.App/Controls/AutoFilterViews.cs
@@ -205,7 +205,7 @@ internal sealed class AfEnvView : AfWindowBase
ctx.DrawGeometry(null, NotaGraph.PrimaryPen, Line(_cut, v => YCut(v)));
}
- NotaGraph.Title(ctx, frame, Loc.T("Cutoff over time"));
+ NotaGraph.Title(ctx, frame, Loc.T("device.auto_filter.cutoff_over_time"));
string pk = NotaNum.Hz(_peakHz);
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.TopRight, pk, Dragging ? NotaPalette.AccentBright : NotaPalette.TextSecondary);
NotaGraph.Legend(ctx, w - 5, 16, ("input", NotaPalette.TealBright, NotaGraph.Mark.Line));
diff --git a/src/managed/Nota.App/Controls/AutoShiftViews.cs b/src/managed/Nota.App/Controls/AutoShiftViews.cs
index e8558108..358c7dfd 100644
--- a/src/managed/Nota.App/Controls/AutoShiftViews.cs
+++ b/src/managed/Nota.App/Controls/AutoShiftViews.cs
@@ -271,6 +271,6 @@ internal sealed class AsHistView : Control
}
var title = new FormattedText("Sung notes", System.Globalization.CultureInfo.InvariantCulture, FlowDirection.LeftToRight, NotaFonts.SansSemiBold, 7, NotaGraph.TitleInk);
ctx.DrawText(title, new Point(5, 3));
- NotaGraph.Legend(ctx, w - 5, 2, ("in scale", NotaPalette.VizInk, NotaGraph.Mark.Area), (Loc.T("out of scale") + _outName, NotaPalette.TealBright, NotaGraph.Mark.Area));
+ NotaGraph.Legend(ctx, w - 5, 2, ("in scale", NotaPalette.VizInk, NotaGraph.Mark.Area), (Loc.T("device.auto_shift.out_of_scale") + _outName, NotaPalette.TealBright, NotaGraph.Mark.Area));
}
}
diff --git a/src/managed/Nota.App/Controls/BeatRepeatViews.cs b/src/managed/Nota.App/Controls/BeatRepeatViews.cs
index 9e0cfbb2..1fa436cf 100644
--- a/src/managed/Nota.App/Controls/BeatRepeatViews.cs
+++ b/src/managed/Nota.App/Controls/BeatRepeatViews.cs
@@ -30,7 +30,7 @@ internal sealed class BrTimelineView : Control
private int _n;
private double _winBeats = 8, _intervalBeats = 4, _gridBeats = 0.25, _barBeats = 4, _offset, _phase;
private bool _playing;
- private string _title = Loc.T("Capture and repeat");
+ private string _title = Loc.T("device.beat_repeat.capture_and_repeat");
public BrTimelineView() { ClipToBounds = true; MinHeight = 36; }
@@ -206,7 +206,7 @@ internal sealed class BrSlicesView : ShDragView
ctx.DrawLine(new Pen(hotG ? NotaPalette.Accent : NotaPalette.TextSecondary, hotG ? 1.6 : 1.1, new DashStyle(new double[] { 3, 3 }, 0)),
new Point(Xf(GateEnd), 0), new Point(Xf(GateEnd), h));
- NotaGraph.Title(ctx, frame, _repeating ? Loc.T("Captured sound · repeating") : "Captured sound");
+ NotaGraph.Title(ctx, frame, _repeating ? Loc.T("device.beat_repeat.captured_sound_repeating") : "Captured sound");
NotaGraph.Legend(ctx, w - 6, 3, ("slice", NotaPalette.VizInk, NotaGraph.Mark.Line), ("input", NotaPalette.TealBright, NotaGraph.Mark.Line));
int off = (int)Math.Round(_offset * 16), gate = (int)Math.Round(_gate * 16);
double ox = Math.Clamp(Xf(_offset) + 3, 4, w - 110);
@@ -312,7 +312,7 @@ internal sealed class BrFilterView : ShDragView
NotaGraph.Node(ctx, node, Active == HFreq);
}
- NotaGraph.Title(ctx, frame, _on ? "Repeat filter" : Loc.T("Repeat filter · off"));
+ NotaGraph.Title(ctx, frame, _on ? "Repeat filter" : Loc.T("device.beat_repeat.repeat_filter_off"));
if (_on && _laterRepeat > 1)
NotaGraph.Legend(ctx, w - 6, 3, ("repeat 1", NotaPalette.VizInk, NotaGraph.Mark.Line),
(NotaNum.F($"repeat {_laterRepeat}"), NotaPalette.TealBright, NotaGraph.Mark.Dashed));
diff --git a/src/managed/Nota.App/Controls/CeilingViews.cs b/src/managed/Nota.App/Controls/CeilingViews.cs
index 023880d7..d0236bd4 100644
--- a/src/managed/Nota.App/Controls/CeilingViews.cs
+++ b/src/managed/Nota.App/Controls/CeilingViews.cs
@@ -31,7 +31,7 @@ internal sealed class CeLevelView : ShDragView
/// <summary>Maps a ceiling (dB) to the handle's 0..1 value and back — set by the card.</summary>
public Func<double, double> CeilToNorm { get; set; } = db => (db + 12) / 12;
public Func<double, double> NormToCeil { get; set; } = n => -12 + 12 * n;
- public string Title { get; set; } = Loc.T("Level and reduction");
+ public string Title { get; set; } = Loc.T("device.ceiling.level_and_reduction");
/// <summary>The level cells (input, output, max GR — each <paramref name="n"/> long from
/// <paramref name="inAt"/>, <paramref name="outAt"/>, <paramref name="grAt"/>) and the ceiling in dB.</summary>
diff --git a/src/managed/Nota.App/Controls/CompViews.cs b/src/managed/Nota.App/Controls/CompViews.cs
index cc97c808..30490001 100644
--- a/src/managed/Nota.App/Controls/CompViews.cs
+++ b/src/managed/Nota.App/Controls/CompViews.cs
@@ -571,7 +571,7 @@ internal sealed class CompKeyView : Control, IValueHandles
NotaGraph.Legend(ctx, w - 6, 3, ("key", NotaPalette.VizInk, NotaGraph.Mark.Line), ("key filter", NotaPalette.TealBright, NotaGraph.Mark.Dashed));
if (!_has)
{
- var ft = CompDraw.Text(Loc.T("no key signal"), NotaPalette.TextTertiary, 8);
+ var ft = CompDraw.Text(Loc.T("device.comp.no_key_signal"), NotaPalette.TextTertiary, 8);
ctx.DrawText(ft, new Point((w - ft.Width) / 2, (top + bot - ft.Height) / 2));
}
}
diff --git a/src/managed/Nota.App/Controls/ConsortViews.cs b/src/managed/Nota.App/Controls/ConsortViews.cs
index 8a082a3e..fff7eaec 100644
--- a/src/managed/Nota.App/Controls/ConsortViews.cs
+++ b/src/managed/Nota.App/Controls/ConsortViews.cs
@@ -414,7 +414,7 @@ internal sealed class ConsortPitchLane : Control
double w = Bounds.Width, h = Bounds.Height;
if (w < 16 || h < Top + 6) return;
ctx.FillRectangle(Brushes.Transparent, new Rect(0, 0, w, h));
- var cap = new FormattedText(_arp ? Loc.T("Pitch · arp (step types shape the rhythm)") : Loc.T("Pitch · step offsets from the key"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, Sans, 7, NotaPalette.TextTertiary);
+ var cap = new FormattedText(_arp ? Loc.T("device.consort.pitch_arp_step_types_shape") : Loc.T("device.consort.pitch_step_offsets_from_the"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, Sans, 7, NotaPalette.TextTertiary);
ctx.DrawText(cap, new Point(6, 3));
double hh = h - Top - 4, cw = w / 16;
double Y(int p) => Top + (1 - (p + 24) / 48.0) * hh;
diff --git a/src/managed/Nota.App/Controls/CrushViews.cs b/src/managed/Nota.App/Controls/CrushViews.cs
index b4cee771..a6159788 100644
--- a/src/managed/Nota.App/Controls/CrushViews.cs
+++ b/src/managed/Nota.App/Controls/CrushViews.cs
@@ -180,7 +180,7 @@ internal sealed class CrQuantView : Control
double rate = _sr / _hold;
NotaGraph.Legend(ctx, w - 6, 3, ("source", NotaPalette.TextSecondary, NotaGraph.Mark.Dashed),
(NotaNum.F($"{_bits:0.0} bit @ {CrushMath.Hz(rate)}"), NotaPalette.VizInk, NotaGraph.Mark.Line));
- if (enlarged) NotaGraph.Axis(ctx, frame, NotaGraph.Corner.BottomLeft, Loc.T("level step shown enlarged"));
+ if (enlarged) NotaGraph.Axis(ctx, frame, NotaGraph.Corner.BottomLeft, Loc.T("device.crush.level_step_shown_enlarged"));
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.BottomRight, "10\u2009ms");
}
}
diff --git a/src/managed/Nota.App/Controls/DynamicEqCurve.cs b/src/managed/Nota.App/Controls/DynamicEqCurve.cs
index e15474f9..9a8f08c6 100644
--- a/src/managed/Nota.App/Controls/DynamicEqCurve.cs
+++ b/src/managed/Nota.App/Controls/DynamicEqCurve.cs
@@ -365,7 +365,7 @@ public sealed class DynamicEqCurve : Control, IValueEntryHost
}
fly.Items.Add(new Separator());
int curM = BandMode(b);
- string[] modeWords = { "Static", Loc.T("Duck — acts above the threshold"), Loc.T("Lift — acts below the threshold") };
+ string[] modeWords = { "Static", Loc.T("device.dynamic_eq.duck_acts_above_the_threshold"), Loc.T("device.dynamic_eq.lift_acts_below_the_threshold") };
for (int m = 0; m < 3; m++)
{
int mm = m;
@@ -374,7 +374,7 @@ public sealed class DynamicEqCurve : Control, IValueEntryHost
fly.Items.Add(mi);
}
fly.Items.Add(new Separator());
- var on = new MenuItem { Header = Loc.T("Band on"), ToggleType = MenuItemToggleType.CheckBox, IsChecked = BandOn(b) };
+ var on = new MenuItem { Header = Loc.T("device.dynamic_eq.band_on"), ToggleType = MenuItemToggleType.CheckBox, IsChecked = BandOn(b) };
on.Click += (_, _) => { Gesture(DynEq.P(b, DynEq.On), () => SetP(b, DynEq.On, BandOn(b) ? 0 : 1)); Edited?.Invoke(); InvalidateVisual(); };
fly.Items.Add(on);
var solo = new MenuItem { Header = "Solo", ToggleType = MenuItemToggleType.CheckBox, IsChecked = SoloBand == b };
@@ -386,7 +386,7 @@ public sealed class DynamicEqCurve : Control, IValueEntryHost
};
fly.Items.Add(solo);
fly.Items.Add(new Separator());
- fly.Items.Add(MenuKit.Item(Loc.T("Type value…"), GlyphKind.Edit, () => ValueEntry.Open(this, BandFields(b)[0])));
+ fly.Items.Add(MenuKit.Item(Loc.T("common.type_value"), GlyphKind.Edit, () => ValueEntry.Open(this, BandFields(b)[0])));
fly.ShowAt(this, showAtPointer: true);
}
diff --git a/src/managed/Nota.App/Controls/Eq8Views.cs b/src/managed/Nota.App/Controls/Eq8Views.cs
index a7a41d6a..d808888d 100644
--- a/src/managed/Nota.App/Controls/Eq8Views.cs
+++ b/src/managed/Nota.App/Controls/Eq8Views.cs
@@ -438,11 +438,11 @@ public sealed class Eq8Curve : Control, IValueEntryHost
fly.Items.Add(chan);
}
fly.Items.Add(new Separator());
- var on = new MenuItem { Header = Loc.T("Band on"), ToggleType = MenuItemToggleType.CheckBox, IsChecked = BandOn(b) };
+ var on = new MenuItem { Header = Loc.T("device.eq8.band_on"), ToggleType = MenuItemToggleType.CheckBox, IsChecked = BandOn(b) };
on.Click += (_, _) => { Gesture(Eq8.P(b, Eq8.On), () => SetP(b, Eq8.On, BandOn(b) ? 0 : 1)); Edited?.Invoke(); InvalidateVisual(); };
fly.Items.Add(on);
fly.Items.Add(new Separator());
- fly.Items.Add(MenuKit.Item(Loc.T("Type value…"), GlyphKind.Edit, () => ValueEntry.Open(this, BandFields(b)[0])));
+ fly.Items.Add(MenuKit.Item(Loc.T("common.type_value"), GlyphKind.Edit, () => ValueEntry.Open(this, BandFields(b)[0])));
fly.ShowAt(this, showAtPointer: true);
}
diff --git a/src/managed/Nota.App/Controls/FluxReactScope.cs b/src/managed/Nota.App/Controls/FluxReactScope.cs
index 7e226ad9..7cc8a5d8 100644
--- a/src/managed/Nota.App/Controls/FluxReactScope.cs
+++ b/src/managed/Nota.App/Controls/FluxReactScope.cs
@@ -99,7 +99,7 @@ internal sealed class FluxReactScope : Control
NotaGraph.Axis(ctx, plot, NotaGraph.Corner.TopRight, "env · transients · tilt", _live ? NotaPalette.TealBright : NotaPalette.TextAxis);
if (!_live)
{
- var none = new FormattedText(Loc.T("no source assigned"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, NotaFonts.Sans,
+ var none = new FormattedText(Loc.T("device.flux_react.no_source_assigned"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, NotaFonts.Sans,
NotaType.KnobLabel, NotaPalette.TextDisabled);
ctx.DrawText(none, new Point((plot.Width - none.Width) / 2, h - 8 - none.Height));
}
diff --git a/src/managed/Nota.App/Controls/GrMeter.cs b/src/managed/Nota.App/Controls/GrMeter.cs
index b59a28ed..b5b71b19 100644
--- a/src/managed/Nota.App/Controls/GrMeter.cs
+++ b/src/managed/Nota.App/Controls/GrMeter.cs
@@ -19,7 +19,7 @@ namespace Nota.App;
private const double MaxDb = 24.0; // full-scale reduction
private double _gr, _hold;
- public GrMeter() => ToolTip.SetTip(this, Loc.T("Clear the peak hold"));
+ public GrMeter() => ToolTip.SetTip(this, Loc.T("control.clear_the_peak_hold"));
public double GrDb
{
diff --git a/src/managed/Nota.App/Controls/KeysViews.cs b/src/managed/Nota.App/Controls/KeysViews.cs
index 2e6c0e55..242e4ab1 100644
--- a/src/managed/Nota.App/Controls/KeysViews.cs
+++ b/src/managed/Nota.App/Controls/KeysViews.cs
@@ -242,7 +242,7 @@ internal sealed class KeysPickupView : Control, IMidiLearnRegions, IValueEntryHo
}
Pickup(0.2, "Up", pos != 2);
Pickup(0.34, "Lo", pos != 0);
- ctx.DrawText(Mono(Loc.T("String · 2 pickups"), NotaPalette.TextTertiary), new Point(6, 4));
+ ctx.DrawText(Mono(Loc.T("device.keys.string_2_pickups"), NotaPalette.TextTertiary), new Point(6, 4));
var read = Mono(KeysModel.PickupPositions[pos], NotaPalette.TextPrimary);
if (Mini) ctx.DrawText(read, new Point(frame.Right - 6 - read.Width, 4));
else ctx.DrawText(read, new Point(6, 15));
diff --git a/src/managed/Nota.App/Controls/MeterBar.cs b/src/managed/Nota.App/Controls/MeterBar.cs
index 7be1ab25..34bdb42e 100644
--- a/src/managed/Nota.App/Controls/MeterBar.cs
+++ b/src/managed/Nota.App/Controls/MeterBar.cs
@@ -33,7 +33,7 @@ public sealed class MeterBar : Control
_horizontal = horizontal;
if (horizontal) { Height = 12; MinWidth = 80; }
else { Width = MeterScale.StereoWidth; MinHeight = 40; }
- ToolTip.SetTip(this, Loc.T("Clear the peak hold"));
+ ToolTip.SetTip(this, Loc.T("control.clear_the_peak_hold"));
}
/// <summary>Feed a fresh reading. The bar takes the value at once; the hold keeps the maximum.</summary>
diff --git a/src/managed/Nota.App/Controls/MeterFader.cs b/src/managed/Nota.App/Controls/MeterFader.cs
index caa5ff07..8a3b9337 100644
--- a/src/managed/Nota.App/Controls/MeterFader.cs
+++ b/src/managed/Nota.App/Controls/MeterFader.cs
@@ -46,7 +46,7 @@ internal sealed class MeterFader : Control
Width = NaturalWidth;
MinHeight = 40;
Cursor = new Cursor(StandardCursorType.SizeNorthSouth);
- ToolTip.SetTip(this, Loc.T("Drag to set the volume · click to clear the peak hold"));
+ ToolTip.SetTip(this, Loc.T("control.meter_fader.drag_to_set_the_volume"));
}
/// <summary>Sets the value without raising ValueChanged (external sync, the dB field).</summary>
diff --git a/src/managed/Nota.App/Controls/NaBadge.cs b/src/managed/Nota.App/Controls/NaBadge.cs
index c209c47d..6c5addb0 100644
--- a/src/managed/Nota.App/Controls/NaBadge.cs
+++ b/src/managed/Nota.App/Controls/NaBadge.cs
@@ -61,14 +61,14 @@ public sealed class NaBadge : Border
// Neutral: "not built yet" is not active, selected or changed, so it takes no brass.
this.BindResource(BackgroundProperty, "Brush.SurfaceRaised");
_label.BindResource(TextBlock.ForegroundProperty, "Brush.TextTertiary");
- ToolTip.SetTip(this, Loc.T("Not available yet"));
+ ToolTip.SetTip(this, Loc.T("control.na_badge.not_available_yet"));
}
else
{
_label.Text = "N/A";
this.BindResource(BackgroundProperty, "Brush.SurfaceRaised");
_label.BindResource(TextBlock.ForegroundProperty, "Brush.TextTertiary");
- ToolTip.SetTip(this, Loc.T("Not available yet"));
+ ToolTip.SetTip(this, Loc.T("control.na_badge.not_available_yet"));
}
}
}
diff --git a/src/managed/Nota.App/Controls/OperatorAlgoViz.cs b/src/managed/Nota.App/Controls/OperatorAlgoViz.cs
index d9249510..f6a4eaeb 100644
--- a/src/managed/Nota.App/Controls/OperatorAlgoViz.cs
+++ b/src/managed/Nota.App/Controls/OperatorAlgoViz.cs
@@ -229,7 +229,7 @@ internal sealed class OperatorRoutingViz : Control
// Header caption.
ctx.DrawText(new FormattedText("Routing", CultureInfo.InvariantCulture, FlowDirection.LeftToRight, Semi, 8, TextTertiary), new Point(padX, 2));
- var hint = new FormattedText(Loc.T("drag an operator onto another to re-route"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, Mono, 8, TextTertiary);
+ var hint = new FormattedText(Loc.T("device.operator_algo.drag_an_operator_onto_another"), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, Mono, 8, TextTertiary);
ctx.DrawText(hint, new Point(gx1 - hint.Width, 2));
// Connection lines (under the boxes).
diff --git a/src/managed/Nota.App/Controls/PendulumViews.cs b/src/managed/Nota.App/Controls/PendulumViews.cs
index 0c4dd92b..ccf29493 100644
--- a/src/managed/Nota.App/Controls/PendulumViews.cs
+++ b/src/managed/Nota.App/Controls/PendulumViews.cs
@@ -179,7 +179,7 @@ internal sealed class PendulumBarView : Control
const double padX = 6;
var cap = new FormattedText("Notes", NotaNum.Culture, FlowDirection.LeftToRight, NotaFonts.SansSemiBold, 7, NotaPalette.TextTertiary);
ctx.DrawText(cap, new Point(padX, 3));
- var sub = PendulumInk.Mono(Loc.F("bar · quantize {0}", _quant.ToLowerInvariant()), NotaPalette.TextAxis);
+ var sub = PendulumInk.Mono(Loc.F("device.pendulum.bar_quantize", _quant.ToLowerInvariant()), NotaPalette.TextAxis);
ctx.DrawText(sub, new Point(padX + cap.Width + 6, 3));
int shown = Visible(_s);
var right = PendulumInk.Mono($"{_sort} · {shown} {(shown == 1 ? "note" : "notes")}", NotaPalette.TealBright);
diff --git a/src/managed/Nota.App/Controls/ReverbViews.cs b/src/managed/Nota.App/Controls/ReverbViews.cs
index 724a7a81..45e0c708 100644
--- a/src/managed/Nota.App/Controls/ReverbViews.cs
+++ b/src/managed/Nota.App/Controls/ReverbViews.cs
@@ -218,7 +218,7 @@ internal sealed class ReverbTailView : Control, IValueHandles
}
// ---- labels ------------------------------------------------------------------
- var title = _freeze ? Text(Loc.T("Tail held · no decay"), NotaPalette.AccentBright) : Text("Decay tail", NotaGraph.TitleInk);
+ var title = _freeze ? Text(Loc.T("device.reverb.tail_held_no_decay"), NotaPalette.AccentBright) : Text("Decay tail", NotaGraph.TitleInk);
ctx.DrawText(title, new Point(x0 - 3, 3));
var rt = Text(_freeze ? "RT60 ∞" : NotaNum.F($"RT60 {_rt60:0.00} s"), _freeze ? NotaPalette.AccentBright : NotaPalette.TextSecondary);
ctx.DrawText(rt, new Point(x1 + 3 - rt.Width, 3));
diff --git a/src/managed/Nota.App/Controls/RhythmViews.cs b/src/managed/Nota.App/Controls/RhythmViews.cs
index eaf9a47c..23b89414 100644
--- a/src/managed/Nota.App/Controls/RhythmViews.cs
+++ b/src/managed/Nota.App/Controls/RhythmViews.cs
@@ -316,7 +316,7 @@ internal sealed class RhythmStepStrip : Control
public RhythmStepStrip()
{
Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(this, Loc.T("Click: step on / off · Shift-click: accent · Alt-click: quiet step\nDrag across to paint · drag up / down or scroll to set the velocity · right-click for more"));
+ ToolTip.SetTip(this, Loc.T("device.rhythm.click_step_on_off_shift"));
}
public void SetHead(int head) { if (head != _head) { _head = head; InvalidateVisual(); } }
diff --git a/src/managed/Nota.App/Controls/ShutterViews.cs b/src/managed/Nota.App/Controls/ShutterViews.cs
index 0d8d78d9..ef6e2ae2 100644
--- a/src/managed/Nota.App/Controls/ShutterViews.cs
+++ b/src/managed/Nota.App/Controls/ShutterViews.cs
@@ -226,7 +226,7 @@ internal sealed class ShSignalView : ShDragView
ctx.DrawLine(new Pen(hotT ? NotaPalette.Accent : NotaPalette.VizInk, hotT ? 1.4 : 1, new DashStyle(new double[] { 4, 4 }, 0)), new Point(0, Y(_thr)), new Point(w, Y(_thr)));
ctx.DrawLine(new Pen(hotR ? NotaPalette.Accent : NotaPalette.BorderStrong, 1, new DashStyle(new double[] { 2, 4 }, 0)), new Point(0, Y(_ret)), new Point(w, Y(_ret)));
- NotaGraph.Title(ctx, frame, _duck ? Loc.T("Signal and duck") : Loc.T("Signal and gate"));
+ NotaGraph.Title(ctx, frame, _duck ? Loc.T("device.shutter.signal_and_duck") : Loc.T("device.shutter.signal_and_gate"));
NotaGraph.Legend(ctx, w - 6, 3, ("input", NotaPalette.TealBright, NotaGraph.Mark.Area), ("output", NotaPalette.VizInk, NotaGraph.Mark.Line));
var thrTxt = NotaNum.F($"threshold {_thr:0.0}");
double ty = Y(_thr) - 11;
@@ -357,7 +357,7 @@ internal sealed class ShEnvelopeView : ShDragView
for (int k = 0; k < 3; k++) { var n = Node(k); if (n.X < w - 2) NotaGraph.Node(ctx, n, Active == k); }
NotaGraph.Node(ctx, Node(HFloor), Active == HFloor, NotaPalette.Teal);
- NotaGraph.Title(ctx, frame, _duck ? "Duck envelope" : _retrig ? Loc.T("Gate envelope · trigger") : "Gate envelope");
+ NotaGraph.Title(ctx, frame, _duck ? "Duck envelope" : _retrig ? Loc.T("device.shutter.gate_envelope_trigger") : "Gate envelope");
TextR(ctx, "open 0\u2009dB", w - 6, 3, NotaPalette.TextSecondary);
double fy = _duck ? yf + 2 : yf - 11;
if (fy > h - 24) fy = yf - 11;
@@ -453,7 +453,7 @@ internal sealed class ShKeyView : ShDragView
NotaGraph.Node(ctx, new Point(X(_lpHz), Yd(Mag(_lpHz))), Active == HLp, NotaPalette.Teal);
}
- NotaGraph.Title(ctx, frame, _on ? "Detector filter" : Loc.T("Detector · full band"));
+ NotaGraph.Title(ctx, frame, _on ? "Detector filter" : Loc.T("device.shutter.detector_full_band"));
NotaGraph.Legend(ctx, w - 6, 3, ("key", NotaPalette.TealBright, NotaGraph.Mark.Line), (_legend, NotaPalette.VizInk, NotaGraph.Mark.Line));
static string Hz(double f) => f >= 1000 ? NotaNum.F($"{f / 1000:0.0}\u2009k") : NotaNum.F($"{f:0}");
Text(ctx, "20", 4, h - 11);
diff --git a/src/managed/Nota.App/Controls/StereoMeter.cs b/src/managed/Nota.App/Controls/StereoMeter.cs
index 0ecf54ed..6c58a270 100644
--- a/src/managed/Nota.App/Controls/StereoMeter.cs
+++ b/src/managed/Nota.App/Controls/StereoMeter.cs
@@ -18,7 +18,7 @@ internal sealed class StereoMeter : Control
{
private double _l, _r, _pkL, _pkR;
- public StereoMeter() => ToolTip.SetTip(this, Loc.T("Clear the peak hold"));
+ public StereoMeter() => ToolTip.SetTip(this, Loc.T("control.clear_the_peak_hold"));
// Push the block's linear peak amplitudes (0..1+).
public void Set(float peakL, float peakR)
diff --git a/src/managed/Nota.App/Controls/SynthViz.cs b/src/managed/Nota.App/Controls/SynthViz.cs
index 66539e39..fb479c78 100644
--- a/src/managed/Nota.App/Controls/SynthViz.cs
+++ b/src/managed/Nota.App/Controls/SynthViz.cs
@@ -304,7 +304,7 @@ internal sealed class SynthViz : Control, IMidiLearnRegions, IValueEntryHost
}
Curve(1.0, new Pen(Ink, NotaGraph.PrimaryWidth, lineJoin: PenLineJoin.Round));
- string left = Loc.F("{0} · {1} cycles · unison {2}", WaveWords[wave], cycles, uni);
+ string left = Loc.F("device.synth.cycles_unison", WaveWords[wave], cycles, uni);
if (wave == 1) left += $" · pw {(pw * 100).ToString("0", NotaNum.Culture)} %";
Text(ctx, left, x0 + 1, Pad - 3, TextTertiary);
string right = uni == 1 && Math.Abs(cents) < 0.5 ? "one shape, no detune"
diff --git a/src/managed/Nota.App/Controls/UtilityViews.cs b/src/managed/Nota.App/Controls/UtilityViews.cs
index 72cee415..ddc3830c 100644
--- a/src/managed/Nota.App/Controls/UtilityViews.cs
+++ b/src/managed/Nota.App/Controls/UtilityViews.cs
@@ -138,7 +138,7 @@ internal sealed class UtFieldView : VtWindowBase
}
else
{
- var hint = NotaGraph.AxisText(Loc.T("lows at the bottom · highs at the top"), NotaPalette.TealBright);
+ var hint = NotaGraph.AxisText(Loc.T("device.utility.lows_at_the_bottom_highs"), NotaPalette.TealBright);
ctx.DrawText(hint, new Point(w - hint.Width - 5, h - hint.Height - 14));
}
}
@@ -240,7 +240,7 @@ internal sealed class UtWidthView : VtWindowBase
if (!double.IsNaN(_monoHz)) NotaGraph.Node(ctx, new Point(X(_monoHz), Y(At(_resp, _nr, _rLo, _rHi, _monoHz))), Dragging);
}
- NotaGraph.Title(ctx, frame, Loc.T("Width by frequency"));
+ NotaGraph.Title(ctx, frame, Loc.T("device.utility.width_by_frequency"));
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.TopRight, _legend, NotaPalette.VizInk);
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.BottomLeft, "20");
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.BottomRight, "18 k");
@@ -315,7 +315,7 @@ internal sealed class UtLevelView : VtWindowBase
}
}
- NotaGraph.Title(ctx, frame, Loc.T("Input and output"));
+ NotaGraph.Title(ctx, frame, Loc.T("device.utility.input_and_output"));
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.TopRight, _legend, NotaPalette.VizInk);
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.BottomLeft, NotaNum.F($"−{_sec:0} s"));
NotaGraph.Axis(ctx, frame, NotaGraph.Corner.BottomRight, "now");
diff --git a/src/managed/Nota.App/Controls/ValueEntry.cs b/src/managed/Nota.App/Controls/ValueEntry.cs
index 0e2a68a9..27592af2 100644
--- a/src/managed/Nota.App/Controls/ValueEntry.cs
+++ b/src/managed/Nota.App/Controls/ValueEntry.cs
@@ -204,7 +204,7 @@ internal static partial class ValueEntry
/// <paramref name="reset"/> — by default the slider's own Reset — is what a double-click and the menu run.</summary>
public static void Attach(TextBlock readout, Func<double> norm, Action<double> setNorm, Func<string> text,
Action? begin = null, Action? end = null, Action? after = null, Action? reset = null, Control? control = null, string? name = null)
- => Attach(control ?? readout, Probing(name ?? Loc.T("Value"), norm, setNorm, text, begin, end, after, reset ?? (control as SliderTrack)?.Reset), readout);
+ => Attach(control ?? readout, Probing(name ?? Loc.T("control.value_entry.value"), norm, setNorm, text, begin, end, after, reset ?? (control as SliderTrack)?.Reset), readout);
/// <summary>A field typed by probing <paramref name="setNorm"/> + <paramref name="text"/>.</summary>
public static ValueField Probing(string name, Func<double> norm, Action<double> setNorm, Func<string> text,
@@ -295,10 +295,10 @@ internal static partial class ValueEntry
private static IEnumerable<Control> MenuItems(ValueField field, Action open, IReadOnlyList<ValueField>? all = null)
{
- yield return MenuKit.Item(Loc.T("Type value…"), GlyphKind.Edit, open);
+ yield return MenuKit.Item(Loc.T("common.type_value"), GlyphKind.Edit, open);
var fs = all ?? [field];
- if (field.Clear is not null) yield return MenuKit.Danger(Loc.T("Clear"), GlyphKind.Trash, () => Clear(field));
- else yield return MenuKit.Item(Loc.T("Reset to default"), GlyphKind.Cycle, () => ResetAll(fs),
+ if (field.Clear is not null) yield return MenuKit.Danger(Loc.T("common.clear"), GlyphKind.Trash, () => Clear(field));
+ else yield return MenuKit.Item(Loc.T("control.value_entry.reset_to_default"), GlyphKind.Cycle, () => ResetAll(fs),
enabled: fs.Any(f => f.CanReset && !AtDefault(f)));
}
@@ -312,7 +312,7 @@ internal static partial class ValueEntry
private static void ShowMenu(Control control, ValueField field, Action open, IReadOnlyList<ValueField>? all = null)
{
var fly = new MenuFlyout();
- fly.Items.Add(MenuKit.Header(field.Name, null, Loc.T("Parameter")));
+ fly.Items.Add(MenuKit.Header(field.Name, null, Loc.T("control.value_entry.parameter")));
fly.Items.Add(new Separator());
foreach (var c in MenuItems(field, open, all)) fly.Items.Add(c);
fly.ShowAt(control, showAtPointer: true);
diff --git a/src/managed/Nota.App/Controls/VocoderGraph.cs b/src/managed/Nota.App/Controls/VocoderGraph.cs
index 3e9ad417..4aa33dbc 100644
--- a/src/managed/Nota.App/Controls/VocoderGraph.cs
+++ b/src/managed/Nota.App/Controls/VocoderGraph.cs
@@ -148,7 +148,7 @@ internal sealed class VocoderGraph : Control, IValueHandles
}
else
{
- var ft = new FormattedText(Loc.T("Pick a carrier track · until then the sound passes through"), System.Globalization.CultureInfo.InvariantCulture,
+ var ft = new FormattedText(Loc.T("device.vocoder.pick_a_carrier_track_until"), System.Globalization.CultureInfo.InvariantCulture,
FlowDirection.LeftToRight, NotaFonts.Sans, 10, NotaPalette.TextDisabled);
ctx.DrawText(ft, new Point((w - ft.Width) / 2, y0 + 14));
}
diff --git a/src/managed/Nota.App/DetailWindow.cs b/src/managed/Nota.App/DetailWindow.cs
index ca92ddaf..50d70d10 100644
--- a/src/managed/Nota.App/DetailWindow.cs
+++ b/src/managed/Nota.App/DetailWindow.cs
@@ -36,7 +36,7 @@ internal sealed class DetailWindow : NotaWindow
// can't steal them, exactly like the main window does.
AddHandler(KeyDownEvent, (_, e) => _owner.HandleTransportKeyTunnel(e), RoutingStrategies.Tunnel);
- Title = Loc.T("Devices / Clip");
+ Title = Loc.T("detail.devices_clip");
Width = 900;
Height = 760;
MinWidth = 520;
diff --git a/src/managed/Nota.App/DeviceCardKit.cs b/src/managed/Nota.App/DeviceCardKit.cs
index 922ed0cf..dd20a9b0 100644
--- a/src/managed/Nota.App/DeviceCardKit.cs
+++ b/src/managed/Nota.App/DeviceCardKit.cs
@@ -235,7 +235,7 @@ internal static class DeviceCardKit
}
repaint = Paint;
track.Changed += v => { setNorm(v); val.Text = text(); };
- string name = label.Length > 0 ? label : Loc.T("Value");
+ string name = label.Length > 0 ? label : Loc.T("device.card.value");
Action? rowReset = reset is null ? null : () => { reset(); Paint(); };
var field = textAt is null
? ValueEntry.Probing(name, norm, setNorm, text, begin, end, Paint, rowReset)
@@ -308,7 +308,7 @@ internal static class DeviceCardKit
{
BorderBrush = NotaPalette.Rule, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Badge,
Padding = new Thickness(4, 0), VerticalAlignment = VerticalAlignment.Center,
- Child = new TextBlock { Text = Loc.T("Bypassed"), FontSize = NotaType.RowLabel, FontWeight = FontWeight.Medium, Foreground = TextSecondary },
+ Child = new TextBlock { Text = Loc.T("device.card.bypassed"), FontSize = NotaType.RowLabel, FontWeight = FontWeight.Medium, Foreground = TextSecondary },
};
// A caption above a control (centered, sentence case, secondary ink).
@@ -335,7 +335,7 @@ internal static class DeviceCardKit
double H = height; // 18 in a card header, 22 in the device window's title bar
var label = new TextBlock
{
- Text = string.IsNullOrEmpty(current) ? Loc.T("Init") : current, FontSize = NotaType.Value + 1, FontWeight = FontWeight.Medium,
+ Text = string.IsNullOrEmpty(current) ? Loc.T("device.card.init") : current, FontSize = NotaType.Value + 1, FontWeight = FontWeight.Medium,
Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis,
};
var chevron = new Glyph(GlyphKind.ChevronDown, 8) { Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0, 0, 0) };
@@ -346,7 +346,7 @@ internal static class DeviceCardKit
Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), // the whole field is clickable, not just the text
Child = new DockPanel { Children = { chevron, label } },
};
- ToolTip.SetTip(name, Loc.T("Choose a preset"));
+ ToolTip.SetTip(name, Loc.T("device.card.choose_a_preset"));
// A sound parameter moved away from the loaded preset (specs/048): "Name *", read live.
if (modified != null && !string.IsNullOrEmpty(current))
{
@@ -357,7 +357,7 @@ internal static class DeviceCardKit
if (m == shown) return;
shown = m;
label.Text = m ? current + " *" : current;
- ToolTip.SetTip(name, m ? Loc.F("Changed since you loaded {0} · choose a preset", current) : Loc.T("Choose a preset"));
+ ToolTip.SetTip(name, m ? Loc.F("device.card.changed_since_you_loaded_choose", current) : Loc.T("device.card.choose_a_preset"));
}
Mark();
addLive?.Invoke(Mark);
@@ -369,7 +369,7 @@ internal static class DeviceCardKit
var flyout = new MenuFlyout();
if (init != null)
{
- var mi = new MenuItem { Header = Loc.T("Init"), ToggleType = MenuItemToggleType.Radio, IsChecked = cur < 0 && string.IsNullOrEmpty(current) };
+ var mi = new MenuItem { Header = Loc.T("device.card.init"), ToggleType = MenuItemToggleType.Radio, IsChecked = cur < 0 && string.IsNullOrEmpty(current) };
mi.Click += (_, _) => init();
flyout.Items.Add(mi);
flyout.Items.Add(new Separator());
@@ -389,7 +389,7 @@ internal static class DeviceCardKit
var g = new Glyph(dir < 0 ? GlyphKind.ChevronLeft : GlyphKind.ChevronRight, 8)
{ Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
var b = new Border { Width = H, Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = g };
- ToolTip.SetTip(b, dir < 0 ? Loc.T("Previous preset") : Loc.T("Next preset"));
+ ToolTip.SetTip(b, dir < 0 ? Loc.T("device.card.previous_preset") : Loc.T("device.card.next_preset"));
b.PointerEntered += (_, _) => g.Foreground = TextPrimary;
b.PointerExited += (_, _) => g.Foreground = TextTertiary;
b.PointerPressed += (_, e) =>
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/AutoFilterDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/AutoFilterDeviceBody.cs
index 6c01672f..ab5e29a8 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/AutoFilterDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/AutoFilterDeviceBody.cs
@@ -284,8 +284,8 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
shapeTitle.Foreground = Assigned() && scN > 0 && Math.Abs(Sc(S_Cut) - P(Freq)) > 0.01 ? AccentBright : TextTertiary;
});
var faders = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto"), ColumnSpacing = 9, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 4, 0, 4) };
- faders.Children.Add(ShapeFader(Freq, "FRQ", NotaPalette.VizInk, S_Cut, Loc.T("Cutoff — the base the modulation moves from; the dashed mark is where it is now. Double-click resets, ⌥-click types a value.")));
- faders.Children.Add(Col(ShapeFader(Res, "RES", Teal, S_Res, Loc.T("Resonance — the peak at the cutoff; the dashed mark is where it is now. Double-click resets, ⌥-click types a value.")), 1));
+ faders.Children.Add(ShapeFader(Freq, "FRQ", NotaPalette.VizInk, S_Cut, Loc.T("device.auto_filter.cutoff_the_base_the_modulation")));
+ faders.Children.Add(Col(ShapeFader(Res, "RES", Teal, S_Res, Loc.T("device.auto_filter.resonance_the_peak_at_the")), 1));
var shapeCol = new RuleSection
{
Width = 56, Padding = new Thickness(0, 5, 0, 4),
@@ -304,7 +304,7 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
curve.GestureEnd += () => { End(Freq); End(Res); };
curve.CutoffChanged += v => Raw(Freq, (float)v);
curve.ResChanged += v => Raw(Res, (float)v);
- ToolTip.SetTip(curve, Loc.T("Drag sideways for the cutoff, up and down for the resonance. The teal band is how far the envelope and LFO can move the cutoff; the dashed curve is where they have it now."));
+ ToolTip.SetTip(curve, Loc.T("device.auto_filter.drag_sideways_for_the_cutoff"));
Learn(curve, Freq);
ValueEntry.AttachAll(curve, F(Freq, "Cutoff", v => Hz(HzOf(v))), F(Res, "Resonance", Pct));
@@ -345,7 +345,7 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
envView.DragV += v => Raw(EnvAmt, (float)v);
envView.GestureBegin += () => Begin(EnvAmt);
envView.GestureEnd += () => End(EnvAmt);
- ToolTip.SetTip(envView, Loc.T("The input's envelope (teal) and the cutoff it drives (neutral ink), the base cutoff dashed. Drag up or down for the amount."));
+ ToolTip.SetTip(envView, Loc.T("device.auto_filter.the_inputs_envelope_teal_and"));
Learn(envView, EnvAmt);
ValueEntry.AttachAll(envView, F(EnvAmt, "Env amount", Bip));
@@ -368,11 +368,11 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
}, out var dirSync, padX: 6);
readouts.Add(dirSync);
Learn(dir, EnvAmt);
- var hold = Latch(EnvHold, () => NotaNum.F($"Hold {HoldF(P(EnvHoldTime))}"), Loc.T("Hold — keep the envelope at its peak for the HOLD time before it releases (∞ freezes it)"));
+ var hold = Latch(EnvHold, () => NotaNum.F($"Hold {HoldF(P(EnvHoldTime))}"), Loc.T("device.auto_filter.hold_keep_the_envelope_at"));
var amt = Mono("", 7, TextPrimary);
readouts.Add(() => { amt.Text = NotaNum.F($"amount {Bip(P(EnvAmt))}"); amt.Foreground = EnvAssigned() ? TextPrimary : TextTertiary; });
var envSw = Toggle(EnvOn, "ENV");
- ToolTip.SetTip(envSw, Loc.T("Envelope follower on / off"));
+ ToolTip.SetTip(envSw, Loc.T("device.auto_filter.envelope_follower_on_off"));
var head = HeadRow(Row(6, envSw, target, dir, hold), amt);
var knobs = KnobRow(new[]
@@ -423,7 +423,7 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
lfoView.DragH += v => Raw(LfoOffset, (float)v);
lfoView.GestureBegin += () => { Begin(LfoAmt); Begin(LfoOffset); };
lfoView.GestureEnd += () => { End(LfoAmt); End(LfoOffset); };
- ToolTip.SetTip(lfoView, Loc.T("The LFO's movement over the window — raw shape dashed, what the filter follows (after Smooth) in neutral ink, the right channel in rose when stereo is on. Drag up or down for the amount, sideways for the start phase."));
+ ToolTip.SetTip(lfoView, Loc.T("device.auto_filter.the_lfos_movement_over_the"));
Learn(lfoView, LfoAmt);
ValueEntry.AttachAll(lfoView, F(LfoAmt, "LFO amount", Pct), F(LfoOffset, "LFO phase", v => Deg(v, 360)));
@@ -431,7 +431,7 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
var rate = Mono("", 7, TextSecondary);
readouts.Add(() => rate.Text = LfoHzF(LfoHz()));
var lfoSw = Toggle(LfoOn, "LFO");
- ToolTip.SetTip(lfoSw, Loc.T("LFO on / off"));
+ ToolTip.SetTip(lfoSw, Loc.T("device.auto_filter.lfo_on_off"));
var head = HeadRow(Row(6, lfoSw, waves, Seg(LfoSync, new[] { "Free", "Sync" })), rate);
var knobs = KnobRow(new[]
@@ -491,14 +491,14 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
b.PointerPressed += (_, e) => { SidechainSourcePicker.SetDeviceKey(engine, track, di, k); ctx.NotifyChanged(); RefreshAll(); fly.Hide(); e.Handled = true; };
list.Children.Add(b);
}
- Item(Loc.T("None — this track's input"), SidechainKey.None);
+ Item(Loc.T("device.auto_filter.none_this_tracks_input"), SidechainKey.None);
foreach (var en in SidechainSourcePicker.Entries(engine, track, Key()))
Item(en.Label, en.Key, en.IsPart, en.Enabled, en.Tip);
var gain = DeviceCardKit.SliderRow("KEY GAIN", () => (engine.DeviceSidechainGain(track, di) + 24) / 48.0,
v => engine.SetDeviceSidechainGain(track, di, (float)(v * 48 - 24)),
() => NotaNum.F($"{engine.DeviceSidechainGain(track, di):+0.0;−0.0;0.0} dB"), out _, bipolar: true,
reset: () => engine.SetDeviceSidechainGain(track, di, 0), valueWidth: 46);
- fly.Content = new StackPanel { Width = 200, Spacing = 6, Children = { Caps(Loc.T("SIDECHAIN KEY — ENVELOPE SOURCE"), null, 8), list, new Border { Height = 1, Background = BorderDef }, gain } };
+ fly.Content = new StackPanel { Width = 200, Spacing = 6, Children = { Caps(Loc.T("device.auto_filter.sidechain_key_envelope_source_caps"), null, 8), list, new Border { Height = 1, Background = BorderDef }, gain } };
fly.ShowAt(host!);
}
var sw = Switch("", () => engine.DeviceSidechainSource(track, di) >= 0, () =>
@@ -513,7 +513,7 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
readouts.Add(sync);
// a right-click (or a click on the name while on) re-opens the picker
sw.PointerReleased += (_, e) => { if (e.InitialPressMouseButton == MouseButton.Right) { ShowPicker(); e.Handled = true; } };
- ToolTip.SetTip(sw, Loc.T("Sidechain key — the envelope follows another track instead of this one. Switch on to pick the source and the key gain; right-click to change it."));
+ ToolTip.SetTip(sw, Loc.T("device.auto_filter.sidechain_key_the_envelope_follows"));
return sw;
}
@@ -547,7 +547,7 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
boxHz.Text = NotaNum.F($"{HzLong(live)} · {NoteOf(live)}");
box.BorderBrush = moving ? NotaPalette.BorderBrass : NotaPalette.GraphBorder;
boxTitle.Foreground = moving ? AccentBright : TextTertiary;
- if (!Assigned()) boxSub.Text = Loc.T("no modulation assigned");
+ if (!Assigned()) boxSub.Text = Loc.T("device.auto_filter.no_modulation_assigned");
else
{
var parts = new List<string> { NotaNum.F($"base {Hz(BaseHz())}") };
@@ -607,8 +607,8 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
SliderRow("DRY/WET", DryWet, Pct),
SliderRow("GAIN", Gain, GainF, bipolar: true) } };
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
- btns.Children.Add(Latch(LfoRetrig, () => "Retrig", Loc.T("Retrig — restart the LFO on each input onset (−24 dBFS) and when play starts"), fill: true));
- btns.Children.Add(Col(Latch(Circuit, () => "Analog", Loc.T("Analog — a gentle saturation after the filter, like an analog circuit"), fill: true), 1));
+ btns.Children.Add(Latch(LfoRetrig, () => "Retrig", Loc.T("device.auto_filter.retrig_restart_the_lfo_on"), fill: true));
+ btns.Children.Add(Col(Latch(Circuit, () => "Analog", Loc.T("device.auto_filter.analog_a_gentle_saturation_after"), fill: true), 1));
var tempo = Toggle(LfoSync, "Tempo sync");
// Stereo phase: on sets 90°, a click on the value steps 45° → 180°.
var stereo = Switch("", () => P(LfoPhase) > 0.001f, () => SetP(LfoPhase, P(LfoPhase) > 0.001f ? 0f : 0.5f), out var stSync,
@@ -621,7 +621,7 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
float nx = P(LfoPhase) + 0.25f; if (nx > 1.001f) nx = 0.25f;
SetP(LfoPhase, nx); RefreshAll(); e.Handled = true;
};
- ToolTip.SetTip(stereo, Loc.T("Stereo phase — the right channel's LFO runs ahead of the left (90° when switched on; right-click steps 45° … 180°)"));
+ ToolTip.SetTip(stereo, Loc.T("device.auto_filter.stereo_phase_the_right_channels"));
var body = new DockPanel { LastChildFill = false, Children = {
Docked(box, Dock.Top),
@@ -676,8 +676,8 @@ internal sealed class AutoFilterDeviceBody : IDeviceBody
var parts = new List<string>();
switch (centreTab)
{
- case 1: parts.Add(filter); parts.Add(baseHz); parts.Add(env.Length > 0 ? env : Loc.T("envelope not assigned")); break;
- case 2: parts.Add(lfo.Length > 0 ? lfo : Loc.T("LFO not assigned")); parts.Add(NotaNum.F($"cutoff {HzLong(LiveHz())}")); if (P(Drive) > 0.004f) parts.Add(NotaNum.F($"drive {Pct(P(Drive))}")); break;
+ case 1: parts.Add(filter); parts.Add(baseHz); parts.Add(env.Length > 0 ? env : Loc.T("device.auto_filter.envelope_not_assigned")); break;
+ case 2: parts.Add(lfo.Length > 0 ? lfo : Loc.T("device.auto_filter.lfo_not_assigned")); parts.Add(NotaNum.F($"cutoff {HzLong(LiveHz())}")); if (P(Drive) > 0.004f) parts.Add(NotaNum.F($"drive {Pct(P(Drive))}")); break;
default:
parts.Add(filter); parts.Add(baseHz); parts.Add(NotaNum.F($"Q {Q(P(Res)):0.00}"));
if (env.Length > 0) parts.Add(NotaNum.F($"ENV {Bip(P(EnvAmt))}"));
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/AutoGainDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/AutoGainDeviceBody.cs
index 5ba7c7ac..61aa932f 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/AutoGainDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/AutoGainDeviceBody.cs
@@ -189,7 +189,7 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
}));
}
list.Add(null);
- list.Add((Loc.T("Fixed target — no reference"), !HasRef(), () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); }));
+ list.Add((Loc.T("device.auto_gain.fixed_target_no_reference"), !HasRef(), () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); }));
Menu(at, list, SidechainSourcePicker.MenuRows(engine, track, di, ctx.NotifyChanged, "Match track: "));
}
@@ -206,7 +206,7 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
SetP(Auto, 0);
}
else if (i == 1) SetP(Auto, 1);
- }, Auto, Loc.T("Auto rides the gain to the target over Window; Manual holds the fader where you put it (Match sets it to the distance to the target)"), 84);
+ }, Auto, Loc.T("device.auto_gain.auto_rides_the_gain_to"), 84);
var corrHead = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
corrHead.Children.Add(Caps("CORRECTION")); corrHead.Children.Add(Col(modeSeg, 1));
@@ -216,7 +216,7 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
fader.Changed += db => { Raw(Gain, GainNorm(db)); RefreshAll(); };
fader.ResetRequested += () => { Reset(Gain); RefreshAll(); };
Learn(fader, Gain);
- ToolTip.SetTip(fader, MenuKit.Keys(Loc.T("The correction around 0\u2009dB, ±Max Gain. In Manual drag it (Shift for fine steps); ⌥-click types, double-click resets to 0\u2009dB. In Auto it shows the ride")));
+ ToolTip.SetTip(fader, MenuKit.Keys(Loc.T("device.auto_gain.the_correction_around_0_db")));
ValueEntry.Attach(fader, ValueEntry.DeviceParam(engine, track, di, Gain, "Gain", v => Sgn(GainDb(v)) + "\u2009dB", RefreshAll));
var maxTop = Mono("", 7, TextDisabled);
@@ -248,8 +248,8 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
{
matchTxt.Text = Manual() ? "Match" : "Reset";
ToolTip.SetTip(match, Manual()
- ? Loc.T("Match — set the manual gain to the distance between the measured input and the target")
- : Loc.T("Reset — restart the measurement from the loudness now, so the ride catches up at once"));
+ ? Loc.T("device.auto_gain.match_set_the_manual_gain")
+ : Loc.T("device.auto_gain.reset_restart_the_measurement_from"));
});
var topLine = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
@@ -265,11 +265,11 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
gainArea.Children.Add(fader); gainArea.Children.Add(Col(numCol, 1));
var targetRow = Slider("TARGET", Target, TargetF,
- Loc.T("Target loudness, −36 … 0 LUFS. Click the value for the standards or to match another track's loudness (a reference); drag the dashed line in the graph for the same"),
+ Loc.T("device.auto_gain.target_loudness_36_0_lufs"),
38, 50, dim: HasRef,
valueOverride: () => HasRef() ? ("REF " + RefName(), TextSecondary) : ("", null),
valueClick: TargetMenu);
- var trimRow = Slider("TRIM", Trim, TrimF, Loc.T("Trim — a fixed offset after the correction, −12 … +12\u2009dB (the output then sits that far off the target)"), 38, 50, bipolar: true);
+ var trimRow = Slider("TRIM", Trim, TrimF, Loc.T("device.auto_gain.trim_a_fixed_offset_after"), 38, 50, bipolar: true);
var leftBody = new DockPanel { Margin = new Thickness(8, 6), LastChildFill = true };
leftBody.Children.Add(Docked(new StackPanel { Spacing = 5, Margin = new Thickness(0, 6, 0, 0), Children = { targetRow, trimRow } }, Dock.Bottom));
@@ -281,7 +281,7 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
// CENTRE — scale + loudness history
// ======================================================================
var scaleSeg = Seg(ScaleNames, () => ScaleIndex(P(Scale)), i => SetP(Scale, i / 2.0), Scale,
- Loc.T("Scale — what the correction reads: Momentary (400\u2009ms, fast and nervous), Short-term (3\u2009s) or Integrated (12\u2009s with BS.1770 gating, the steadiest)"), 118);
+ Loc.T("device.auto_gain.scale_what_the_correction_reads"), 118);
var legend = new LvLegend { HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Center };
var centreHead = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 8 };
centreHead.Children.Add(Caps("SCALE")); centreHead.Children.Add(Col(scaleSeg, 1)); centreHead.Children.Add(Col(legend, 2));
@@ -292,7 +292,7 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
hist.Changed += v => { Raw(Target, v); RefreshAll(); };
hist.ResetRequested += () => { Reset(Target); RefreshAll(); };
Learn(hist, Target);
- ToolTip.SetTip(hist, MenuKit.Keys(Loc.T("The last 8\u2009s: input, output and the target with its ±1\u2009LU band (momentary loudness). Drag up / down to move the target; ⌥-click types, double-click resets it")));
+ ToolTip.SetTip(hist, MenuKit.Keys(Loc.T("device.auto_gain.the_last_8_s_input")));
ValueEntry.Attach(hist, ValueEntry.DeviceParam(engine, track, di, Target, "Target", TargetF, RefreshAll));
IBrush Dim() => TextDisabled;
@@ -325,22 +325,22 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
ToolTip.SetTip(g, tip);
return (g, m, v);
}
- var mIn = MeterRow("IN", Loc.T("Input loudness on the chosen scale (LUFS); the teal mark is the target"));
- var mOut = MeterRow("OUT", Loc.T("Output loudness on the chosen scale (LUFS); the teal mark is the target"));
- var mTp = MeterRow("TP", Loc.T("Output true peak (dBTP); the teal mark is the ceiling while True-peak safe is on"));
- var mCor = MeterRow("COR", Loc.T("The correction applied, ±Max Gain around 0\u2009dB (trim not included)"));
+ var mIn = MeterRow("IN", Loc.T("device.auto_gain.input_loudness_on_the_chosen"));
+ var mOut = MeterRow("OUT", Loc.T("device.auto_gain.output_loudness_on_the_chosen"));
+ var mTp = MeterRow("TP", Loc.T("device.auto_gain.output_true_peak_dbtp_the"));
+ var mCor = MeterRow("COR", Loc.T("device.auto_gain.the_correction_applied_max_gain"));
var respSeg = Seg(new[] { "Fast", "Slow" }, () => On(Response) ? 1 : 0, i => SetP(Response, i), Response,
- Loc.T("Response — Slow glides over the whole Window with a 20\u2009ms look-ahead; Fast over a quarter of it with 5\u2009ms"), 76);
+ Loc.T("device.auto_gain.response_slow_glides_over_the"), 76);
var respRow = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
respRow.Children.Add(Caps("RESPONSE", Teal)); respRow.Children.Add(Col(respSeg, 1));
- var winRow = Slider("WINDOW", WindowP, WindowF, Loc.T("Window — how long the ride takes to reach the target, 0.4 … 10\u2009s (Fast: a quarter of it)"), 48, 36);
- var maxRow = Slider("MAX GAIN", MaxGain, MaxF, Loc.T("Max gain — the most the correction may boost or cut, 0 … 24\u2009dB"), 48, 36);
+ var winRow = Slider("WINDOW", WindowP, WindowF, Loc.T("device.auto_gain.window_how_long_the_ride"), 48, 36);
+ var maxRow = Slider("MAX GAIN", MaxGain, MaxF, Loc.T("device.auto_gain.max_gain_the_most_the"), 48, 36);
var safeSw = Switch("True-peak safe", () => On(Safe), () => { SetP(Safe, On(Safe) ? 0 : 1); RefreshAll(); }, out var safeSync);
readouts.Add(safeSync);
Learn(safeSw, Safe);
- ToolTip.SetTip(safeSw, Loc.T("True-peak safe — a look-ahead limiter keeps the output under the ceiling (adds 5 / 20\u2009ms of latency, compensated)"));
+ ToolTip.SetTip(safeSw, Loc.T("device.auto_gain.true_peak_safe_a_look"));
var ceilTxt = Mono("", 8, TextPrimary);
var ceilBox = new Border
{
@@ -365,7 +365,7 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
ceilBox.PointerReleased += (_, e) => { if (cd) { cd = false; End(Ceiling); e.Pointer.Capture(null); } };
ceilBox.PointerCaptureLost += (_, _) => { if (cd) { cd = false; End(Ceiling); } };
Learn(ceilBox, Ceiling);
- ToolTip.SetTip(ceilBox, MenuKit.Keys(Loc.T("Ceiling, −6 … 0\u2009dBTP — drag up / down (Shift for fine steps), ⌥-click to type, double-click resets to −1.0")));
+ ToolTip.SetTip(ceilBox, MenuKit.Keys(Loc.T("device.auto_gain.ceiling_6_0_dbtp_drag")));
ValueEntry.Attach(ceilBox, ValueEntry.DeviceParam(engine, track, di, Ceiling, "Ceiling", v => NotaNum.F($"{CeilingDb(v):0.0;−0.0;0.0}\u2009dBTP"), RefreshAll), ceilTxt);
readouts.Add(() =>
{
@@ -397,7 +397,7 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
statusGrid.Children.Add(Col(statusRight, 1));
var status = new Border { Height = 18, Background = Sunken, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(8, 0), Child = statusGrid };
DockPanel.SetDock(status, Dock.Bottom);
- ToolTip.SetTip(statusLeft, Loc.T("What the leveler is doing now"));
+ ToolTip.SetTip(statusLeft, Loc.T("device.auto_gain.what_the_leveler_is_doing"));
// ---- live state ---------------------------------------------------------------------
static double MeterX(double lufs) => Math.Clamp((lufs - LevelMath.LBot) / (LevelMath.LTop - LevelMath.LBot), 0, 1);
@@ -421,8 +421,8 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
modeTag.Text = manual ? "fader" : "auto";
big.Text = on ? Sgn(g) : "off";
big.Foreground = on ? TextPrimary : TextDisabled;
- string why = !on ? "" : !primed ? Loc.T("waiting for signal") : silent ? "silence · holding"
- : tpClamp ? Loc.T("limited by true-peak") : clamp == 1 && !manual ? Loc.T("limited by max gain") : clamp == 2 && !manual ? Loc.T("limited by max cut")
+ string why = !on ? "" : !primed ? Loc.T("device.auto_gain.waiting_for_signal") : silent ? "silence · holding"
+ : tpClamp ? Loc.T("device.auto_gain.limited_by_true_peak") : clamp == 1 && !manual ? Loc.T("device.auto_gain.limited_by_max_gain") : clamp == 2 && !manual ? Loc.T("device.auto_gain.limited_by_max_cut")
: manual ? "manual" : "auto · " + (On(Response) ? "slow" : "fast");
reason.Text = why;
reason.Foreground = on && (tpClamp || (clamp > 0 && !manual)) ? NotaPalette.Warning : TextTertiary;
@@ -452,10 +452,10 @@ internal sealed class AutoGainDeviceBody : IDeviceBody
// Status.
string foot; IBrush footInk = TextSecondary;
double matchG = Math.Clamp(target - measured - trim, -maxG, maxG);
- if (!on) foot = Loc.T("Leveler bypassed: the output equals the input");
- else if (!primed) foot = Loc.T("Waiting for signal — the gain holds until the input has been measured");
- else if (silent) foot = Loc.T("Input silent: the measurement and the gain hold");
- else if (manual && Math.Abs(delta) >= 1) { foot = Loc.F("Output {0}\u2009LU from the target · Match sets {1}\u2009dB", Sgn(delta), Sgn(matchG)); footInk = NotaPalette.Warning; }
+ if (!on) foot = Loc.T("device.auto_gain.leveler_bypassed_the_output_equals");
+ else if (!primed) foot = Loc.T("device.auto_gain.waiting_for_signal_the_gain");
+ else if (silent) foot = Loc.T("device.auto_gain.input_silent_the_measurement_and");
+ else if (manual && Math.Abs(delta) >= 1) { foot = Loc.F("device.auto_gain.output_lu_from_the_target", Sgn(delta), Sgn(matchG)); footInk = NotaPalette.Warning; }
else if (tpClamp) { foot = $"True-peak limits the gain to the {NotaNum.F($"{CeilingDb(P(Ceiling)):0.0;−0.0;0.0}")}\u2009dBTP ceiling"; footInk = NotaPalette.Warning; }
else if (clamp > 0 && !manual) { foot = NotaNum.F($"Needs more than {maxG:0} dB: raise Max gain or Trim"); footInk = NotaPalette.Warning; }
else
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/AutoPanDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/AutoPanDeviceBody.cs
index cb62cfc1..7b5f6bc5 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/AutoPanDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/AutoPanDeviceBody.cs
@@ -135,12 +135,12 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
syncSeg.Width = 76;
readouts.Add(syncSync);
Learn(syncSeg, Sync);
- ToolTip.SetTip(syncSeg, Loc.T("Hz runs the LFO free; Sync takes its rate from the tempo and locks it to the bar while the transport plays"));
+ ToolTip.SetTip(syncSeg, Loc.T("common.hz_runs_the_lfo_free"));
var waveSeg = Segments(OrbitMath.Waves, WaveI, i => { SetP(Waveform, i / 4.0); RefreshAll(); }, out var waveSync, fill: true, padX: 0);
readouts.Add(waveSync);
Learn(waveSeg, Waveform);
- ToolTip.SetTip(waveSeg, Loc.T("The LFO shape. S&H draws a random step every cycle; the right channel plays the same steps Phase later"));
+ ToolTip.SetTip(waveSeg, Loc.T("device.auto_pan.the_lfo_shape_s_h"));
var big = Mono("", 26, TextPrimary); big.FontWeight = FontWeight.Bold; big.LineHeight = 28;
var bigSub = new TextBlock { FontSize = 8, Foreground = TextSecondary };
@@ -163,14 +163,14 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
big.Foreground = On() ? TextPrimary : NotaPalette.TextAxis;
});
var bigBlock = new StackPanel { Spacing = 1, VerticalAlignment = VerticalAlignment.Center, Children = { big, bigSub, period } };
- ToolTip.SetTip(bigBlock, Loc.T("The LFO rate: in Hz, or the note value it takes from the tempo"));
+ ToolTip.SetTip(bigBlock, Loc.T("common.the_lfo_rate_in_hz"));
- var rateRow = Slider("RATE", Rate, v => HzF(OrbitMath.FreeHz(v)) + "\u2009Hz", Loc.T("Rate — the free LFO rate, 0.01 … 40\u2009Hz"), out _, 38, 46);
+ var rateRow = Slider("RATE", Rate, v => HzF(OrbitMath.FreeHz(v)) + "\u2009Hz", Loc.T("device.auto_pan.rate_the_free_lfo_rate"), out _, 38, 46);
var divRow = Slider("RATE", Division, v => OrbitMath.DivNames[OrbitMath.DivIndex(v)],
- Loc.T("Rate — the note value of one LFO cycle, 4/1 … 1/32 with dotted (D) and triplet (T) values"), out _, 38, 46,
+ Loc.T("device.auto_pan.rate_the_note_value_of"), out _, 38, 46,
snap: v => OrbitMath.DivNorm(OrbitMath.DivIndex(v)));
readouts.Add(() => { rateRow.IsVisible = !Synced(); divRow.IsVisible = Synced(); });
- var shapeRow = Slider("SHAPE", Shape, v => PctF(v), Loc.T("Shape — sharpens Sine, Tri and Saw toward a square; on S&H it is Glide, the slide from one step to the next"), out var shapeLbl, 38, 46);
+ var shapeRow = Slider("SHAPE", Shape, v => PctF(v), Loc.T("device.auto_pan.shape_sharpens_sine_tri_and"), out var shapeLbl, 38, 46);
readouts.Add(() => shapeLbl.Text = WaveI() == 4 ? "Glide" : "Shape");
var leftBody = new Grid { RowDefinitions = new RowDefinitions("Auto,*,Auto,Auto"), RowSpacing = 6, Margin = new Thickness(8, 6) };
@@ -197,7 +197,7 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
graph.Changed += (a, ph) => { Raw(Amount, a); Raw(Phase, ph); RefreshAll(); };
graph.ResetRequested += () => { Reset(Amount); Reset(Phase); RefreshAll(); };
Learn(graph, Amount);
- ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("Both channels' gain over two LFO cycles — L neutral, R teal, Phase later — with the floor the depth reaches. Drag up / down for Amount, left / right for Phase; ⌥-click types, double-click resets both.")));
+ ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("device.auto_pan.both_channels_gain_over_two")));
ValueEntry.AttachAll(graph, ValueEntry.DeviceParam(engine, track, di, Amount, "Amount", PctF, RefreshAll), ValueEntry.DeviceParam(engine, track, di, Phase, "Phase", v => NotaNum.F($"{v * 360:0}°"), RefreshAll));
var panBar = new OrbitPanBar { VerticalAlignment = VerticalAlignment.Center };
@@ -209,9 +209,9 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
panRow.Children.Add(Col(panBar, 1));
panRow.Children.Add(Col(rTag, 2));
panRow.Children.Add(Col(panTxt, 3));
- ToolTip.SetTip(panRow, Loc.T("Where the sound sits now between left and right, over the swing the LFO covers"));
+ ToolTip.SetTip(panRow, Loc.T("device.auto_pan.where_the_sound_sits_now"));
var centreBody = new DockPanel { LastChildFill = true, Margin = new Thickness(5), Children = { Docked(panRow, Dock.Bottom), graph } };
- var centre = Island(HeadRow(Caps(Loc.T("GAIN · 2 CYCLES")), legend), centreBody);
+ var centre = Island(HeadRow(Caps(Loc.T("device.auto_pan.gain_2_cycles_caps")), legend), centreBody);
centre.Margin = new Thickness(5, 0);
// ======================================================================
@@ -225,12 +225,12 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
modeWord.Text = m;
modeWord.Foreground = m == "auto-pan" ? TextPrimary : m == "tremolo" ? NotaPalette.TealBright : TextSecondary;
});
- ToolTip.SetTip(modeWord, Loc.T("What the phase makes: tremolo near 0°, auto-pan near 180°, an offset pan between"));
+ ToolTip.SetTip(modeWord, Loc.T("device.auto_pan.what_the_phase_makes_tremolo"));
- var amountRow = Slider("AMOUNT", Amount, v => PctF(v), Loc.T("Amount — the depth: each channel dips to 1 − Amount at the LFO's low point"), out _, 44, 36, modulation: true);
- var phaseRow = Slider("PHASE", Phase, v => NotaNum.F($"{v * 360:0}°"), Loc.T("Phase — the right LFO against the left: 0° tremolo, 90° a circling pan, 180° auto-pan"), out _, 44, 36, modulation: true,
+ var amountRow = Slider("AMOUNT", Amount, v => PctF(v), Loc.T("device.auto_pan.amount_the_depth_each_channel"), out _, 44, 36, modulation: true);
+ var phaseRow = Slider("PHASE", Phase, v => NotaNum.F($"{v * 360:0}°"), Loc.T("device.auto_pan.phase_the_right_lfo_against"), out _, 44, 36, modulation: true,
snap: v => Math.Round(v * 360) / 360);
- var mixRow = Slider("MIX", Mix, v => PctF(v), Loc.T("Mix — the moving signal against the dry one"), out _, 44, 36);
+ var mixRow = Slider("MIX", Mix, v => PctF(v), Loc.T("device.auto_pan.mix_the_moving_signal_against"), out _, 44, 36);
Border Snap(string text, double deg)
{
@@ -252,7 +252,7 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
tb.Foreground = on ? TextPrimary : TextTertiary;
});
Learn(b, Phase);
- ToolTip.SetTip(b, deg == 0 ? Loc.T("0° — tremolo: both channels together") : deg == 90 ? Loc.T("90° — a quarter cycle apart: the sound circles") : Loc.T("180° — auto-pan: one side up while the other is down"));
+ ToolTip.SetTip(b, deg == 0 ? Loc.T("device.auto_pan.0_tremolo_both_channels_together") : deg == 90 ? Loc.T("device.auto_pan.90_a_quarter_cycle_apart") : Loc.T("device.auto_pan.180_auto_pan_one_side"));
return b;
}
var snaps = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), ColumnSpacing = 1, Margin = new Thickness(44, 0, 0, 0) };
@@ -274,7 +274,7 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
g.Children.Add(Caps(label, labelInk));
g.Children.Add(Col(m, 1));
g.Children.Add(Col(new Border { Margin = new Thickness(6, 0, 0, 0), Child = v }, 2));
- ToolTip.SetTip(g, Loc.T("The channel's output peak, −60 … 0\u2009dBFS, and the gain the LFO gives it now, dB"));
+ ToolTip.SetTip(g, Loc.T("device.auto_pan.the_channels_output_peak_60"));
return g;
}
var meters = new Border
@@ -310,10 +310,10 @@ internal sealed class AutoPanDeviceBody : IDeviceBody
double hz = RateHz();
bool warn = false;
string foot;
- if (!On()) foot = Loc.T("Panner bypassed: the signal passes unchanged");
- else if (P(Amount) < 0.01f || P(Mix) < 0.01f) { foot = Loc.T("Amount or Mix at zero: nothing moves"); warn = true; }
- else if (hz > 8) { foot = Loc.T("Above 8\u2009Hz the movement reads as a flutter, not as panning"); warn = true; }
- else if (m == "tremolo") foot = Loc.T("Phase 0°: L and R move together, the level dips to ") + OrbitMath.Db(Floor()) + "\u2009dB";
+ if (!On()) foot = Loc.T("device.auto_pan.panner_bypassed_the_signal_passes");
+ else if (P(Amount) < 0.01f || P(Mix) < 0.01f) { foot = Loc.T("device.auto_pan.amount_or_mix_at_zero"); warn = true; }
+ else if (hz > 8) { foot = Loc.T("device.auto_pan.above_8_hz_the_movement"); warn = true; }
+ else if (m == "tremolo") foot = Loc.T("device.auto_pan.phase_0_l_and_r") + OrbitMath.Db(Floor()) + "\u2009dB";
else if (m == "auto-pan")
{
double mn = Sc(S_PanMin), mx = Sc(S_PanMax);
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/AutoShiftDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/AutoShiftDeviceBody.cs
index 50815ce6..d5f3e047 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/AutoShiftDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/AutoShiftDeviceBody.cs
@@ -249,7 +249,7 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
return seg;
}
Control SourceSeg() => Seg(KeySrc, new[] { "Auto", "Manual", "MIDI" },
- Loc.T("Key source — Auto follows the key you sing, Manual uses the key and scale you set, MIDI takes the target from another track's notes (MIDI tab)"),
+ Loc.T("device.auto_shift.key_source_auto_follows_the"),
iv => SetP(KeySrc, iv / 2f), Src);
// A latching chip: lit when `lit()`, a click runs `click`. `fill` = a full-width button.
@@ -283,7 +283,7 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
}
Border ToggleLatch(int p, string text, string tip) => Latch(p, () => On(p), () => SetP(p, On(p) ? 0f : 1f), () => text, tip);
Border LearnLatch() => Latch(-1, () => Sc(S_Learning) > 0.5, Learn, () => "Learn",
- Loc.T("Learn — listen to what is sung, then click again to set the key and scale that fit it best"), blink: () => Sc(S_Learning) > 0.5);
+ Loc.T("device.auto_shift.learn_listen_to_what_is"), blink: () => Sc(S_Learning) > 0.5);
// A dropdown box: [text ▾], opens a menu of items.
Border Drop(Func<string> text, Func<bool> lit, Action<MenuFlyout> fill, string tip, double minW = 0, bool stretch = false, int learnP = -1)
@@ -328,7 +328,7 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
Control KeyDrop(bool lit) => Drop(() => Keys[KeyOf()], () => lit, fly =>
{
for (int k = 0; k < 12; k++) { int kv = k; fly.Items.Add(Item(Keys[k], KeyOf() == k, () => { SetKey(kv); RefreshAll(); })); }
- }, Loc.T("Key — the tonic; the scale's notes are counted from it"), 0, false, Key);
+ }, Loc.T("device.auto_shift.key_the_tonic_the_scales"), 0, false, Key);
Control ScaleDrop() => Drop(ScaleName, () => false, fly =>
{
for (int s = 0; s < Scales.Length; s++) { int sv = s; fly.Items.Add(Item(Scales[s], !On(Custom) && ScaleOf() == s, () => { SetScale(sv); RefreshAll(); })); }
@@ -339,13 +339,13 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
fly.Items.Add(Item(m.Name, On(Custom) && CustomMask() == Rot(m.Mask, KeyOf()), () => { SetCustom(Rot(m.Mask, KeyOf())); RefreshAll(); }));
}
fly.Items.Add(new Separator());
- fly.Items.Add(Item(Loc.T("Custom — edit on the Scale tab"), On(Custom), () => { SetCustom(ActiveMask()); RefreshAll(); }));
- }, Loc.T("Scale — the notes the voice is pulled to"), 62, false, Scale);
+ fly.Items.Add(Item(Loc.T("device.auto_shift.custom_edit_on_the_scale"), On(Custom), () => { SetCustom(ActiveMask()); RefreshAll(); }));
+ }, Loc.T("device.auto_shift.scale_the_notes_the_voice"), 62, false, Scale);
// The MIDI source: [name ▾] lists the instrument tracks. Picking one switches Key Source to MIDI.
Control FromDrop() => Drop(MidiSrcName, () => MidiSrc() >= 0 && MidiOn(), fly =>
{
- fly.Items.Add(Item(Loc.T("None"), MidiSrc() < 0, () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); RefreshAll(); }));
+ fly.Items.Add(Item(Loc.T("common.none"), MidiSrc() < 0, () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); RefreshAll(); }));
for (int i = 0; i < engine.TrackCount; i++)
if (engine.TryGetTrackInfo(i, out var ti) && ti.Id != track && ti.IsInstrument)
{
@@ -357,7 +357,7 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
ctx.NotifyChanged(); RefreshAll();
}));
}
- }, Loc.T("From — the instrument track whose notes set the target (its MIDI clips and effects, even when muted)"), 74, false, KeySrc);
+ }, Loc.T("device.auto_shift.from_the_instrument_track_whose"), 74, false, KeySrc);
Control VoiceDrop() => Drop(VoiceName, () => false, fly =>
{
@@ -367,7 +367,7 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
fly.Items.Add(Item(NotaNum.F($"{vv.Name} ({Note(vv.Lo)}…{Note(vv.Hi)})"), LowNote() == vv.Lo && HighNote() == vv.Hi, () =>
{ SetP(DetLow, (vv.Lo - 24) / 72f); SetP(DetHigh, (vv.Hi - 24) / 72f); RefreshAll(); }));
}
- }, Loc.T("Source — sets the detection range for a voice type or an instrument"), 0, true);
+ }, Loc.T("device.auto_shift.source_sets_the_detection_range"), 0, true);
// Slider row: caps label · track · mono value.
Control SliderRow(string label, int p, Func<double, string> fmt, bool bipolar = false, bool modulation = false, IBrush? valueInk = null)
@@ -427,8 +427,8 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
var corrPill = new AsPill { Ink = Teal, Bipolar = true, VerticalAlignment = VerticalAlignment.Stretch };
var inLbl = Caps("IN"); inLbl.HorizontalAlignment = HorizontalAlignment.Center;
var corrLbl = Caps("CORR"); corrLbl.HorizontalAlignment = HorizontalAlignment.Center;
- ToolTip.SetTip(inPill, Loc.T("The detected pitch, low to high across the detection range (Detect tab)"));
- ToolTip.SetTip(corrPill, Loc.T("The correction now — up or down from the centre, full height = 2 semitones"));
+ ToolTip.SetTip(inPill, Loc.T("device.auto_shift.the_detected_pitch_low_to"));
+ ToolTip.SetTip(corrPill, Loc.T("device.auto_shift.the_correction_now_up_or"));
var pitchNote = Mono("—", 9, AccentBright); pitchNote.HorizontalAlignment = HorizontalAlignment.Center; pitchNote.FontWeight = FontWeight.Medium;
var pitchCents = Mono("", 7, TextPrimary); pitchCents.HorizontalAlignment = HorizontalAlignment.Center;
readouts.Add(() =>
@@ -460,14 +460,14 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
Control TraceTab()
{
trace = new AsTraceView();
- ToolTip.SetTip(trace, Loc.T("The detected pitch (teal dots) and the corrected output (neutral ink) over the last two seconds, on the scale's note lanes; the target lane is lit"));
+ ToolTip.SetTip(trace, Loc.T("device.auto_shift.the_detected_pitch_teal_dots"));
var head = HeadRow(Row(6, Caps("KEY"), KeyDrop(false), ScaleDrop(), SourceSeg(), LearnLatch()), RightInfo(() => TargetNote() >= 0 ? "target " + TargetText() : ""));
var knobs = KnobRow(new[]
{
- K(Amount, "AMOUNT", PctF, tip: Loc.T("Amount — how far the voice is pulled to the target note")),
- K(Speed, "SPEED", v => MsF(Exp(v, 2, 300)), tip: Loc.T("Speed — how fast the retune glides (2 ms = hard tune)")),
- K(Range, "RANGE", v => NotaNum.F($"±{1 + v * 11:0} st"), tip: Loc.T("Range — the largest correction; a note further off than this is only pulled this far")),
- K(Human, "HUMAN", PctF, Teal, Loc.T("Human — keeps vibrato and slow drift around the corrected note (0 = flat)")),
+ K(Amount, "AMOUNT", PctF, tip: Loc.T("device.auto_shift.amount_how_far_the_voice_2")),
+ K(Speed, "SPEED", v => MsF(Exp(v, 2, 300)), tip: Loc.T("device.auto_shift.speed_how_fast_the_retune")),
+ K(Range, "RANGE", v => NotaNum.F($"±{1 + v * 11:0} st"), tip: Loc.T("device.auto_shift.range_the_largest_correction_a")),
+ K(Human, "HUMAN", PctF, Teal, Loc.T("device.auto_shift.human_keeps_vibrato_and_slow")),
},
() => Voiced() ? NotaNum.F($"input {InputText()} → target {TargetText()}") : "no pitch",
() => (P(Amount) >= 0.95f && SpeedMs() < 12 ? "hard correction" : P(Amount) < 0.4f ? "light correction" : "natural correction")
@@ -483,10 +483,10 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
{
histView = new AsHistView();
histView.NoteClicked += ToggleNote;
- ToolTip.SetTip(histView, Loc.T("How long each note was sung (the last ~16 bars) over the scale's notes — neutral in the scale, teal outside it. Click a column to add or remove its note"));
+ ToolTip.SetTip(histView, Loc.T("device.auto_shift.how_long_each_note_was"));
LearnBind(histView, Custom);
var scaleSeg = Seg(Scale, new[] { "Chrom", "Major", "Minor", "Pent", "Custom" },
- Loc.T("Scale — Chromatic, Major, Minor, Pentatonic (major or minor — click again to swap) or Custom (the notes below)"),
+ Loc.T("device.auto_shift.scale_chromatic_major_minor_pentatonic"),
iv =>
{
if (iv == 4) SetCustom(ActiveMask());
@@ -549,23 +549,23 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
Control MidiTab()
{
midiView = new AsTraceView();
- ToolTip.SetTip(midiView, Loc.T("The source track's notes (neutral blocks, accent while sounding) and the voice (teal) over the last two seconds — with Key Source MIDI the voice is pulled to the notes"));
+ ToolTip.SetTip(midiView, Loc.T("device.auto_shift.the_source_tracks_notes_neutral"));
var head = HeadRow(Row(6, Caps("FROM"), FromDrop(),
- Seg(MidiMode, new[] { "Note", "Scale" }, Loc.T("Note — the voice goes to the last held note; Scale — the held notes form the scale")),
- ToggleLatch(MidiLatch, "Latch", Loc.T("Latch — keep the last target between notes (off = no correction while no note is held)")),
- ToggleLatch(MidiOct, "Oct lock", Loc.T("Oct lock — the note's own octave (off = whichever octave of it is nearest the voice)"))),
- RightInfo(() => MidiOn() ? NotaNum.F($"{Sc(S_MidiHeld):0} {(Math.Round(Sc(S_MidiHeld)) == 1 ? "note" : "notes")}") : Loc.T("Key Source is not MIDI")));
+ Seg(MidiMode, new[] { "Note", "Scale" }, Loc.T("device.auto_shift.note_the_voice_goes_to")),
+ ToggleLatch(MidiLatch, "Latch", Loc.T("device.auto_shift.latch_keep_the_last_target")),
+ ToggleLatch(MidiOct, "Oct lock", Loc.T("device.auto_shift.oct_lock_the_notes_own"))),
+ RightInfo(() => MidiOn() ? NotaNum.F($"{Sc(S_MidiHeld):0} {(Math.Round(Sc(S_MidiHeld)) == 1 ? "note" : "notes")}") : Loc.T("device.auto_shift.key_source_is_not_midi")));
var knobs = KnobRow(new[]
{
- K(Amount, "AMOUNT", PctF, tip: Loc.T("Amount — how far the voice is pulled to the note")),
- K(MidiGlide, "GLIDE", v => MsF(Exp(v, 5, 800)), tip: Loc.T("Glide — how long the target bends from one note to the next (Pitch bend from MIDI)")),
- K(Speed, "SPEED", v => MsF(Exp(v, 2, 300)), tip: Loc.T("Speed — how fast the voice follows the target")),
- K(MidiBendRange, "BEND", v => NotaNum.F($"±{v * 6:0.#} st"), Teal, Loc.T("Bend — the widest move between notes that bends over Glide; wider leaps jump")),
+ K(Amount, "AMOUNT", PctF, tip: Loc.T("device.auto_shift.amount_how_far_the_voice")),
+ K(MidiGlide, "GLIDE", v => MsF(Exp(v, 5, 800)), tip: Loc.T("device.auto_shift.glide_how_long_the_target")),
+ K(Speed, "SPEED", v => MsF(Exp(v, 2, 300)), tip: Loc.T("device.auto_shift.speed_how_fast_the_voice")),
+ K(MidiBendRange, "BEND", v => NotaNum.F($"±{v * 6:0.#} st"), Teal, Loc.T("device.auto_shift.bend_the_widest_move_between")),
},
() => !MidiOn() ? "set Key Source to MIDI to follow the notes"
- : Sc(S_MidiNote) < 0 ? (MidiSrc() < 0 ? Loc.T("pick a track in FROM") : Loc.T("no note held"))
+ : Sc(S_MidiNote) < 0 ? (MidiSrc() < 0 ? Loc.T("device.auto_shift.pick_a_track_in_from") : Loc.T("device.auto_shift.no_note_held"))
: Voiced() ? NotaNum.F($"input {InputText()} → clip note {TargetText()}") : NotaNum.F($"clip note {Note((int)Sc(S_MidiNote))}"),
- () => On(MidiLatch) ? Loc.T("latch holds the target between notes") : Loc.T("no correction between notes"));
+ () => On(MidiLatch) ? Loc.T("device.auto_shift.latch_holds_the_target_between") : Loc.T("device.auto_shift.no_correction_between_notes"));
return TabBody(head, midiView, knobs);
}
@@ -630,9 +630,9 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
return ("NOTE", false, v ? Success : BorderStrong, false,
v ? NotaNum.F($"{Note(DetNote())} · {Sc(S_Hz):0.0} Hz") : Sc(S_Sibilant) > 0.5 ? (On(SkipSib) ? "sibilant · passed" : "sibilant") : "no pitch",
v ? NotaNum.F($"correction {CentsF(Sc(S_CorrCents))} · conf {Sc(S_Conf) * 100:0} %") : NotaNum.F($"in {Sc(S_InDb):0} dB"));
- }, Loc.T("What the detector hears now and the correction applied — or, with Key Source MIDI, the note the voice is pulled to"));
- var follow = Toggle(Follow, Loc.T("Follow Scale device"), Loc.T("Follow — copy the key and scale of a Nota Scale MIDI effect (this track, the MIDI source, or the first one found)"));
- var bend = Toggle(MidiBend, Loc.T("Pitch bend from MIDI"), Loc.T("Pitch bend from MIDI — moves between notes bend over Glide when they are within Bend; off = the target steps"));
+ }, Loc.T("device.auto_shift.what_the_detector_hears_now"));
+ var follow = Toggle(Follow, Loc.T("device.auto_shift.follow_scale_device"), Loc.T("device.auto_shift.follow_copy_the_key_and_2"));
+ var bend = Toggle(MidiBend, Loc.T("device.auto_shift.pitch_bend_from_midi"), Loc.T("device.auto_shift.pitch_bend_from_midi_moves"));
readouts.Add(() => { follow.IsVisible = !MidiOn(); bend.IsVisible = MidiOn(); });
return Spread(
SliderRow("SHIFT", Shift, ShiftF, bipolar: true),
@@ -641,7 +641,7 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 0), Child = SliderRow("MIX", Mix, PctF) },
noteBox,
new StackPanel { Spacing = 5, Children = {
- Toggle(Formant, "Preserve formants", Loc.T("Preserve formants — the vowel colour stays put while the pitch moves (off = it moves with the pitch, like a tape speed-up)")),
+ Toggle(Formant, "Preserve formants", Loc.T("device.auto_shift.preserve_formants_the_vowel_colour")),
new Panel { Children = { follow, bend } } } });
}
@@ -651,12 +651,12 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
{
bool learning = Sc(S_Learning) > 0.5;
if (Sc(S_LearnKey) < 0)
- return ("LEARN", learning, learning ? Brass : BorderStrong, learning, learning ? "listening…" : "—", Loc.T("sing a few bars"));
+ return ("LEARN", learning, learning ? Brass : BorderStrong, learning, learning ? "listening…" : "—", Loc.T("device.auto_shift.sing_a_few_bars"));
string Ks(int k, double s) => $"{Keys[Math.Clamp(k, 0, 11)]} {(s > 1.5 ? "Minor" : "Major")}";
return ("LEARN", learning, learning ? Brass : Success, learning,
NotaNum.F($"{Ks((int)Sc(S_LearnKey), Sc(S_LearnScale))} · {Sc(S_LearnMatch) * 100:0} %"),
NotaNum.F($"next {Ks((int)Sc(S_Learn2Key), Sc(S_Learn2Scale))} · {Sc(S_Learn2Match) * 100:0} %"));
- }, Loc.T("The key that fits what was sung (Krumhansl profiles over the last ~16 bars), and the runner-up. Learn sets it; Auto follows it"));
+ }, Loc.T("device.auto_shift.the_key_that_fits_what"));
return Spread(
LabelRow("SOURCE", VoiceDrop()),
SliderRow("LOW", DetLow, NoteF, modulation: true),
@@ -664,8 +664,8 @@ internal sealed class AutoShiftDeviceBody : IDeviceBody
new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 0), Child = SliderRow("SENS", DetSens, PctF) },
learnBox,
new StackPanel { Spacing = 5, Children = {
- Toggle(Follow, Loc.T("Follow Scale device"), Loc.T("Follow — copy the key and scale of a Nota Scale MIDI effect")),
- Toggle(SkipSib, "Skip sibilants", Loc.T("Skip sibilants — s, sh, t and breath pass unshifted, so they don't turn metallic")) } });
+ Toggle(Follow, Loc.T("device.auto_shift.follow_scale_device"), Loc.T("device.auto_shift.follow_copy_the_key_and")),
+ Toggle(SkipSib, "Skip sibilants", Loc.T("device.auto_shift.skip_sibilants_s_sh_t")) } });
}
// ======================================================================
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/BeatRepeatDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/BeatRepeatDeviceBody.cs
index d7343823..58ee43c0 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/BeatRepeatDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/BeatRepeatDeviceBody.cs
@@ -172,9 +172,9 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
return seg;
}
Control ModeSeg() => Seg(ModeNames, () => Sel(Mode, 3), i => SetP(Mode, i / 2f), Mode,
- Loc.T("Mode — Mix: the repeats play over the dry; Insert: they replace it while they play; Gate: only the burst sounds"));
+ Loc.T("device.beat_repeat.mode_mix_the_repeats_play"));
Control IntervalSegC() => Seg(IntervalSeg, () => Sel(Interval, 6), i => SetP(Interval, i / 5f), Interval,
- Loc.T("Interval — how often it rolls Chance: 1/8, 1/4, 1/2 note, or every 1, 2, 4 bars"), 5);
+ Loc.T("device.beat_repeat.interval_how_often_it_rolls_2"), 5);
// Grid picks a straight value and keeps the triplet state (a legacy 1/8T / 1/16T turns into the Triplet switch).
void PickGrid(int baseIdx, bool trip)
{
@@ -182,7 +182,7 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
if (On(Triplet) != trip) SetP(Triplet, trip ? 1f : 0f);
}
Control GridSegC() => Seg(GridSeg, GridBase, i => PickGrid(i, Trip()), GridP,
- Loc.T("Grid — the length of the slice that repeats"), 5);
+ Loc.T("device.beat_repeat.grid_the_length_of_the"), 5);
// A latching chip: lit when `lit()`, a click runs `click`. `fill` = a full-width button.
Border Latch(int p, Func<bool> lit, Action click, Func<string> text, string tip, bool fill = false)
@@ -205,7 +205,7 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
readouts.Add(Hi); Hi();
return b;
}
- Control TripletChip() => Latch(Triplet, Trip, () => PickGrid(GridBase(), !Trip()), () => "Triplet", Loc.T("Triplet — the grid in triplets (a third shorter)"));
+ Control TripletChip() => Latch(Triplet, Trip, () => PickGrid(GridBase(), !Trip()), () => "Triplet", Loc.T("device.beat_repeat.triplet_the_grid_in_triplets"));
// Repeat: held while pressed; with Latch on, a click turns it on and the next one off.
Border RepeatButton(bool fill)
@@ -236,7 +236,7 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
}
b.PointerReleased += (_, e) => { if (held) { e.Pointer.Capture(null); Release(); } };
b.PointerCaptureLost += (_, _) => Release();
- ToolTip.SetTip(b, Loc.T("Repeat — repeat the current slice now, for as long as it is held (with Latch: click on, click off)"));
+ ToolTip.SetTip(b, Loc.T("device.beat_repeat.repeat_repeat_the_current_slice"));
Learn(b, RepeatP);
readouts.Add(Hi); Hi();
return b;
@@ -353,8 +353,8 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
var repPill = new ShPill { Ink = Teal, VerticalAlignment = VerticalAlignment.Stretch };
var inLbl = Caps("IN"); inLbl.HorizontalAlignment = HorizontalAlignment.Center;
var repLbl = Caps("REP"); repLbl.HorizontalAlignment = HorizontalAlignment.Center;
- ToolTip.SetTip(inPill, Loc.T("The input level"));
- ToolTip.SetTip(repPill, Loc.T("The repeats' level — after pitch, filter, decay and volume"));
+ ToolTip.SetTip(inPill, Loc.T("device.beat_repeat.the_input_level"));
+ ToolTip.SetTip(repPill, Loc.T("device.beat_repeat.the_repeats_level_after_pitch"));
var colIn = Mono("", 7, TextPrimary); colIn.HorizontalAlignment = HorizontalAlignment.Center;
var colRep = Mono("", 7, TextPrimary); colRep.HorizontalAlignment = HorizontalAlignment.Center;
static double Norm60(double db) => Math.Clamp((db + 60) / 60, 0, 1);
@@ -384,19 +384,19 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
Control TimelineTab()
{
timeline = new BrTimelineView();
- ToolTip.SetTip(timeline, Loc.T("Two intervals on the grid: each step is the input's level — dim when dry, full where the slice is captured, dimmer with every repeat as it decays. Ticks at the top mark where the interval fires."));
+ ToolTip.SetTip(timeline, Loc.T("device.beat_repeat.two_intervals_on_the_grid"));
var slice = Mono("", 7, TextSecondary);
readouts.Add(() => slice.Text = "slice " + MsF(SliceMs(GridBeats())));
var head = HeadRow(Row(6, ModeSeg(), new Border { Width = 2 }, Caps("INTERVAL"),
- Drop(Interval, IntervalName, () => Sel(Interval, 6), i => SetP(Interval, i / 5f), Loc.T("Interval — how often it rolls Chance")),
+ Drop(Interval, IntervalName, () => Sel(Interval, 6), i => SetP(Interval, i / 5f), Loc.T("device.beat_repeat.interval_how_often_it_rolls")),
Caps("GRID"),
- Drop(GridP, gridDropNames, GridDropIdx, i => PickGrid(i % 4, i >= 4), Loc.T("Grid — the length of the slice that repeats"))), slice);
+ Drop(GridP, gridDropNames, GridDropIdx, i => PickGrid(i % 4, i >= 4), Loc.T("device.beat_repeat.grid_the_length_of_the"))), slice);
var knobs = KnobRow(new[]
{
- K(Chance, "CHANCE", ChanceF, tip: Loc.T("Chance — how likely each interval fires a repeat"), lit: () => true),
- K(Gate, "GATE", GateF, steps: 17, tip: Loc.T("Gate — how long the burst lasts, in 16ths of the interval")),
- K(Offset, "OFFSET", OffsetF, steps: 17, tip: Loc.T("Offset — where in the interval it fires, in 16ths")),
- K(Variation, "VARIATION", VarF, Teal, tip: Loc.T("Variation — the grid floats up to this many steps (double / half) on each trigger")),
+ K(Chance, "CHANCE", ChanceF, tip: Loc.T("device.beat_repeat.chance_how_likely_each_interval"), lit: () => true),
+ K(Gate, "GATE", GateF, steps: 17, tip: Loc.T("device.beat_repeat.gate_how_long_the_burst")),
+ K(Offset, "OFFSET", OffsetF, steps: 17, tip: Loc.T("device.beat_repeat.offset_where_in_the_interval")),
+ K(Variation, "VARIATION", VarF, Teal, tip: Loc.T("device.beat_repeat.variation_the_grid_floats_up")),
},
() => NotaNum.F($"capture {GridName()} → {Passes() - 1} {(Passes() - 1 == 1 ? "repeat" : "repeats")}"),
() => NotaNum.F($"{IntervalEvery[Sel(Interval, 6)]} · decay {P(Decay) * 100:0}\u2009%"));
@@ -411,18 +411,18 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
{
slices = new BrSlicesView();
WireDrag(slices, h => h == BrSlicesView.HGate ? Gate : Offset, F(Offset, "Offset", OffsetF), F(Gate, "Gate", GateF));
- ToolTip.SetTip(slices, MenuKit.Keys(Loc.T("The last interval's sound (teal) on the grid: the gate from the offset is shaded and the captured slice is brass. Drag the offset line or the gate's end sideways; ⌥-click to type, double-click resets.")));
+ ToolTip.SetTip(slices, MenuKit.Keys(Loc.T("device.beat_repeat.the_last_intervals_sound_teal")));
Learn(slices, Offset);
var head = HeadRow(Row(6, Caps("INTERVAL"), IntervalSegC(), Caps("GRID"), GridSegC(), TripletChip()), new Border());
var knobs = KnobRow(new[]
{
- K(Offset, "OFFSET", OffsetF, steps: 17, tip: Loc.T("Offset — where in the interval it fires, in 16ths"), lit: () => true),
- K(Gate, "GATE", GateF, steps: 17, tip: Loc.T("Gate — how long the burst lasts, in 16ths of the interval"), lit: () => true),
- K(Chance, "CHANCE", ChanceF, tip: Loc.T("Chance — how likely each interval fires a repeat")),
- K(Variation, "VARIATION", VarF, Teal, tip: Loc.T("Variation — the grid floats up to this many steps (double / half) on each trigger")),
+ K(Offset, "OFFSET", OffsetF, steps: 17, tip: Loc.T("device.beat_repeat.offset_where_in_the_interval"), lit: () => true),
+ K(Gate, "GATE", GateF, steps: 17, tip: Loc.T("device.beat_repeat.gate_how_long_the_burst"), lit: () => true),
+ K(Chance, "CHANCE", ChanceF, tip: Loc.T("device.beat_repeat.chance_how_likely_each_interval")),
+ K(Variation, "VARIATION", VarF, Teal, tip: Loc.T("device.beat_repeat.variation_the_grid_floats_up")),
},
() => NotaNum.F($"takes {GridName()} at {OffSteps()}/16 · {Passes()} {(Passes() == 1 ? "step" : "steps")}"),
- () => VarSteps() == 0 ? Loc.T("the grid holds still") : NotaNum.F($"grid floats ±{VarSteps()} {(VarSteps() == 1 ? "step" : "steps")}"));
+ () => VarSteps() == 0 ? Loc.T("device.beat_repeat.the_grid_holds_still") : NotaNum.F($"grid floats ±{VarSteps()} {(VarSteps() == 1 ? "step" : "steps")}"));
return TabBody(head, slices, knobs);
}
@@ -437,30 +437,30 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
filter = new BrFilterView();
WireDrag(filter, h => h == BrFilterView.HFreq ? FilterFreq : FilterWidth,
F(FilterFreq, "Freq", FreqF), F(FilterWidth, "Width", WidthF), F(FilterWidth, "Width", WidthF));
- ToolTip.SetTip(filter, MenuKit.Keys(Loc.T("The repeat filter — only the repeats go through it. Solid: the first repeat; teal dashed: a later one when the band narrows and follows the pitch. Drag the node for the frequency, a band edge for the width; ⌥-click to type, double-click resets.")));
+ ToolTip.SetTip(filter, MenuKit.Keys(Loc.T("device.beat_repeat.the_repeat_filter_only_the")));
Learn(filter, FilterFreq);
var type = Seg(FilterNames, () => On(FilterOn) ? FType() + 1 : 0,
i => { if (i == 0) SetP(FilterOn, 0f); else { SetP(FilterType, (i - 1) / 2f); if (!On(FilterOn)) SetP(FilterOn, 1f); } },
- FilterType, Loc.T("Filter — Off, or a low-pass, band-pass or high-pass on the repeats"));
- var narrow = Latch(FilterNarrow, () => On(FilterNarrow), () => SetP(FilterNarrow, On(FilterNarrow) ? 0f : 1f), () => Loc.T("Narrow with repeats"),
- Loc.T("Narrow with repeats — each repeat narrows the band and moves it with the pitch"));
+ FilterType, Loc.T("device.beat_repeat.filter_off_or_a_low"));
+ var narrow = Latch(FilterNarrow, () => On(FilterNarrow), () => SetP(FilterNarrow, On(FilterNarrow) ? 0f : 1f), () => Loc.T("device.beat_repeat.narrow_with_repeats"),
+ Loc.T("device.beat_repeat.narrow_with_repeats_each_repeat"));
var drop = Mono("", 7, TextSecondary);
readouts.Add(() => drop.Text = PDecaySt() > 0.01 ? NotaNum.F($"{StF(PitchSt())} → {StF(LaterPitch())} by repeat {LaterRepeat()}") : "pitch " + StF(PitchSt()));
var head = HeadRow(Row(6, Caps("FILTER"), type, narrow), drop);
var knobs = KnobRow(new[]
{
- K(FilterFreq, "FREQ", FreqF, tip: Loc.T("Freq — the filter's frequency"), lit: () => On(FilterOn)),
- K(FilterWidth, "WIDTH", WidthF, tip: Loc.T("Width — the band in octaves (low- and high-pass: less is more resonant)"), lit: () => On(FilterOn)),
- K(Pitch, "PITCH", PitchF, Teal, tip: Loc.T("Pitch — the repeats transposed, ±12 semitones")),
- K(PitchDecay, "P. DECAY", PDecF, tip: Loc.T("Pitch decay — each repeat drops lower, up to 6 semitones a repeat")),
+ K(FilterFreq, "FREQ", FreqF, tip: Loc.T("device.beat_repeat.freq_the_filters_frequency"), lit: () => On(FilterOn)),
+ K(FilterWidth, "WIDTH", WidthF, tip: Loc.T("device.beat_repeat.width_the_band_in_octaves"), lit: () => On(FilterOn)),
+ K(Pitch, "PITCH", PitchF, Teal, tip: Loc.T("device.beat_repeat.pitch_the_repeats_transposed_12")),
+ K(PitchDecay, "P. DECAY", PDecF, tip: Loc.T("device.beat_repeat.pitch_decay_each_repeat_drops")),
},
() =>
{
- if (!On(FilterOn)) return Loc.T("the repeats pass unfiltered");
+ if (!On(FilterOn)) return Loc.T("device.beat_repeat.the_repeats_pass_unfiltered");
double lo = FreqHz() / Math.Pow(2, WidthOct() / 2), hi = FreqHz() * Math.Pow(2, WidthOct() / 2);
return FType() == 1 ? NotaNum.F($"band {HzF(lo)}…{HzF(hi)}") : NotaNum.F($"{(FType() == 0 ? "below" : "above")} {HzF(FreqHz())}");
},
- () => On(FilterNarrow) ? Loc.T("each repeat lower and narrower") : PDecaySt() > 0.01 ? Loc.T("each repeat lower, same band") : Loc.T("the same on every repeat"));
+ () => On(FilterNarrow) ? Loc.T("device.beat_repeat.each_repeat_lower_and_narrower") : PDecaySt() > 0.01 ? Loc.T("device.beat_repeat.each_repeat_lower_same_band") : Loc.T("device.beat_repeat.the_same_on_every_repeat"));
return TabBody(head, filter, knobs);
}
@@ -509,13 +509,13 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
b.BorderBrush = forced ? NotaPalette.BorderBrass : NotaPalette.GraphBorder;
t.Foreground = forced ? AccentBright : TextTertiary;
});
- ToolTip.SetTip(b, Loc.T("What the repeater is doing now — waiting for the interval, capturing the slice, or repeating it — and where the transport is"));
+ ToolTip.SetTip(b, Loc.T("device.beat_repeat.what_the_repeater_is_doing"));
return b;
}
Control Toggles() => new StackPanel { Spacing = 5, Children = {
- Toggle(FilterOn, "Repeat filter", Loc.T("Repeat filter — the repeats go through the filter (Filter tab)")),
- Toggle(LatchP, "Latch", Loc.T("Latch — the Repeat button stays on after a click instead of only while held")) } };
+ Toggle(FilterOn, "Repeat filter", Loc.T("device.beat_repeat.repeat_filter_the_repeats_go")),
+ Toggle(LatchP, "Latch", Loc.T("device.beat_repeat.latch_the_repeat_button_stays")) } };
Control CharacterTab()
{
@@ -556,7 +556,7 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
btns.Children.Add(RepeatButton(fill: true));
btns.Children.Add(Col(Latch(-1, () => false, () => engine.DeviceAction(track, di, A_Reset, 0, 0), () => "Reset",
- Loc.T("Reset — stop the repeat and clear the timeline and the meters"), fill: true), 1));
+ Loc.T("device.beat_repeat.reset_stop_the_repeat_and"), fill: true), 1));
var body = new DockPanel { LastChildFill = false, Children = {
Docked(box, Dock.Top),
Docked(new Border { Margin = new Thickness(0, 6, 0, 0), Child = sliders }, Dock.Top),
@@ -651,7 +651,7 @@ internal sealed class BeatRepeatDeviceBody : IDeviceBody
double ib = IntervalBeats();
if (centreTab == 0 && timeline is not null)
timeline.Set(scope, kCellAt, full ? kCells : 0, ib * 2, ib, GridBeats(), BarBeats(), OffSteps() / 16.0,
- Sc(S_WinPhase), Sc(S_Playing) > 0.5, State() == 2 ? NotaNum.F($"Capture and repeat · {RepeatNo()}") : Loc.T("Capture and repeat"));
+ Sc(S_WinPhase), Sc(S_Playing) > 0.5, State() == 2 ? NotaNum.F($"Capture and repeat · {RepeatNo()}") : Loc.T("device.beat_repeat.capture_and_repeat"));
if (centreTab == 1 && slices is not null)
{
double sliceBeats = Sc(S_SliceBeats) > 0 && State() > 0 ? Sc(S_SliceBeats) : GridBeats();
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/CeilingDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/CeilingDeviceBody.cs
index 70f8d2a6..e014007a 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/CeilingDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/CeilingDeviceBody.cs
@@ -43,7 +43,7 @@ internal sealed class CeilingDeviceBody : IDeviceBody
private const int A_ResetPeaks = 0, A_ResetLoudness = 1;
private static readonly string[] CharNames = { "Clean", "Punch", "Glue" };
- private static readonly string[] CharWords = { "transparent", Loc.T("lets the attack through"), Loc.T("slow and dense") };
+ private static readonly string[] CharWords = { "transparent", Loc.T("device.ceiling.lets_the_attack_through"), Loc.T("device.ceiling.slow_and_dense") };
private static readonly (string Name, float Lufs)[] Targets =
{
("−23\u2009LUFS · broadcast", -23), ("−18\u2009LUFS · audiobook", -18), ("−16\u2009LUFS · podcast", -16), ("−14\u2009LUFS · streaming", -14),
@@ -265,9 +265,9 @@ internal sealed class CeilingDeviceBody : IDeviceBody
{
return new List<(string, bool, Action)>
{
- (Loc.T("Internal — this track"), !ExtOn(), () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); }),
+ (Loc.T("device.ceiling.internal_this_track"), !ExtOn(), () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); }),
};
- }, Loc.T("Key source — Internal limits on this track's own peaks; pick another track to duck this one when that one peaks"),
+ }, Loc.T("device.ceiling.key_source_internal_limits_on"),
sources: () => SidechainSourcePicker.MenuRows(engine, track, di, ctx.NotifyChanged));
Control TargetDrop() => Drop("", () => TargetF(P(Target)), () => false, () =>
@@ -275,7 +275,7 @@ internal sealed class CeilingDeviceBody : IDeviceBody
var list = new List<(string, bool, Action)>();
foreach (var (label, v) in Targets) { float vv = v; list.Add((label, Math.Abs(P(Target) - vv) < 0.05f, () => SetP(Target, vv))); }
return list;
- }, Loc.T("Target — the loudness the meters compare against: −14 for streaming, −16 podcasts, −23 broadcast. It does not change the sound; drag the dashed line for any value"), Target);
+ }, Loc.T("device.ceiling.target_the_loudness_the_meters"), Target);
static Grid HeadRow(Control left, Control right)
{
@@ -288,7 +288,7 @@ internal sealed class CeilingDeviceBody : IDeviceBody
var seg = Segments(CharNames, CharI, i => { SetP(Character, i); RefreshAll(); }, out var sync, padX: 6);
readouts.Add(sync);
Learn(seg, Character);
- ToolTip.SetTip(seg, Loc.T("Character — Clean: transparent, the fastest attack; Punch: a slower attack lets the transient through to the clip; Glue: a slow release and a soft knee under the ceiling"));
+ ToolTip.SetTip(seg, Loc.T("device.ceiling.character_clean_transparent_the_fastest"));
var wordsTb = new TextBlock { FontSize = 7, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
readouts.Add(() => wordsTb.Text = CharWords[CharI()]);
return words ? Row(6, Caps("CHARACTER"), seg, wordsTb) : Row(6, Caps("CHARACTER"), seg);
@@ -312,14 +312,14 @@ internal sealed class CeilingDeviceBody : IDeviceBody
{
Spacing = 4, VerticalAlignment = VerticalAlignment.Center, Children =
{
- ParamChip(AutoRelease, "Auto rel", Loc.T("Auto release — the release slows as the reduction deepens (up to 5× at 7\u2009dB), so dense passages don't pump")),
- ParamChip(TruePeak, "True peak", Loc.T("True peak — the detector reads the inter-sample peak (4×), so the ceiling holds in dBTP after conversion")),
+ ParamChip(AutoRelease, "Auto rel", Loc.T("device.ceiling.auto_release_the_release_slows")),
+ ParamChip(TruePeak, "True peak", Loc.T("device.ceiling.true_peak_the_detector_reads")),
},
};
var knobs = Row(2,
- K(Gain, "GAIN", GainF, Loc.T("Gain — how hard the signal is driven into the ceiling"), lit: () => centreTab != 1),
- K(Ceil, "CEILING", v => NotaNum.F($"{v:0.0}\u2009dB"), Loc.T("Ceiling — the output never goes above it (in dBTP with True peak on)")),
- K(Release, "RELEASE", RelF, Loc.T("Release — how fast the gain comes back (the character scales it; Auto rel lets the signal decide)"),
+ K(Gain, "GAIN", GainF, Loc.T("device.ceiling.gain_how_hard_the_signal"), lit: () => centreTab != 1),
+ K(Ceil, "CEILING", v => NotaNum.F($"{v:0.0}\u2009dB"), Loc.T("device.ceiling.ceiling_the_output_never_goes")),
+ K(Release, "RELEASE", RelF, Loc.T("device.ceiling.release_how_fast_the_gain"),
lit: () => centreTab == 1, teal: () => On(AutoRelease)));
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), Height = 52, ColumnSpacing = 8 };
g.Children.Add(knobs);
@@ -364,8 +364,8 @@ internal sealed class CeilingDeviceBody : IDeviceBody
var inPill = new ShPill { Ink = Teal, VerticalAlignment = VerticalAlignment.Stretch, Width = 12 };
var grPill = new ShPill { Ink = NotaPalette.VizInk, FromTop = true, VerticalAlignment = VerticalAlignment.Stretch, Width = 12 };
var outPill = new ShPill { Ink = NotaPalette.VizInk, VerticalAlignment = VerticalAlignment.Stretch, Width = 12 };
- ToolTip.SetTip(inPill, Loc.T("The input after Gain, with the ceiling marked"));
- ToolTip.SetTip(grPill, Loc.T("Gain reduction, 0 … 24\u2009dB"));
+ ToolTip.SetTip(inPill, Loc.T("device.ceiling.the_input_after_gain_with"));
+ ToolTip.SetTip(grPill, Loc.T("device.ceiling.gain_reduction_0_24_db"));
ToolTip.SetTip(outPill, "The output");
var colGr = Mono("", 7, TextPrimary); colGr.HorizontalAlignment = HorizontalAlignment.Center;
var colOut = Mono("", 7, TextPrimary); colOut.HorizontalAlignment = HorizontalAlignment.Center;
@@ -403,7 +403,7 @@ internal sealed class CeilingDeviceBody : IDeviceBody
{
level = new CeLevelView { CeilToNorm = db => ToN(Ceil, db) };
WireDrag(level, Ceil, "Ceiling", CeilF);
- ToolTip.SetTip(level, MenuKit.Keys(Loc.T("The last 4 s: the input (teal), the part over the ceiling (red) and the output (neutral ink), with the reduction under it. Drag the ceiling line; ⌥-click to type, double-click resets.")));
+ ToolTip.SetTip(level, MenuKit.Keys(Loc.T("device.ceiling.the_last_4_s_the")));
var head = HeadRow(CharSeg(), Info(() => "ceiling " + CeilF(P(Ceil))));
var knobs = KnobRow(
() => ScDb(S_WinInPeak) <= -119 ? "no signal" : NotaNum.F($"in {Lvl(ScDb(S_WinInPeak))} → out {Lvl(ScDb(S_WinOutPeak))}"),
@@ -415,7 +415,7 @@ internal sealed class CeilingDeviceBody : IDeviceBody
Control ReductionTab()
{
reduction = new CeReductionView();
- ToolTip.SetTip(reduction, Loc.T("The gain reduction over the last 4 s: teal where a transient got through to the clip, the dashed line is the mean"));
+ ToolTip.SetTip(reduction, Loc.T("device.ceiling.the_gain_reduction_over_the"));
var head = HeadRow(CharSeg(), Info(() => NotaNum.F($"avg {GrF(Sc(S_AvgGr))} · max {GrF(Sc(S_WinMaxGr))}")));
var knobs = KnobRow(ReleaseRange, ClipText);
return TabBody(head, reduction, knobs);
@@ -426,7 +426,7 @@ internal sealed class CeilingDeviceBody : IDeviceBody
{
loudness = new CeLoudnessView { TargetToNorm = t => ToN(Target, t) };
WireDrag(loudness, Target, "Target", TargetF);
- ToolTip.SetTip(loudness, MenuKit.Keys(Loc.T("Momentary (teal), short-term (neutral ink) and integrated (rose) loudness over the last 60 s around the target, ±1 LU shaded. Drag the target line; ⌥-click to type, double-click resets.")));
+ ToolTip.SetTip(loudness, MenuKit.Keys(Loc.T("device.ceiling.momentary_teal_short_term_neutral")));
var head = HeadRow(Row(6, CharSeg(false), Caps("TARGET"), TargetDrop()),
Info(() => HaveI() ? NotaNum.F($"{FromTarget():+0.0;−0.0;0.0}\u2009LU from target") : "measuring…"));
var knobs = KnobRow(
@@ -466,14 +466,14 @@ internal sealed class CeilingDeviceBody : IDeviceBody
Control ResetRow(bool loud)
{
var reset = Chip(-1, () => false, () => engine.DeviceAction(track, di, loud ? A_ResetLoudness : A_ResetPeaks, 0, 0),
- loud ? "Reset" : "Reset peaks", loud ? Loc.T("Reset — start the integrated loudness, the range and the peaks again") : Loc.T("Reset peaks — clear the peak holds, the max reduction and the clip count"), fill: true);
+ loud ? "Reset" : "Reset peaks", loud ? Loc.T("device.ceiling.reset_start_the_integrated_loudness") : Loc.T("device.ceiling.reset_peaks_clear_the_peak"), fill: true);
reset.HorizontalAlignment = HorizontalAlignment.Right;
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 6 };
g.Children.Add(KeyDrop());
g.Children.Add(Col(reset, 1));
return new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 0), Child = g };
}
- Control DeltaSwitch() => Toggle(DeltaP, Loc.T("Delta · hear what it removes"), Loc.T("Delta — play the difference between the input and the output: what the limiter takes away"));
+ Control DeltaSwitch() => Toggle(DeltaP, Loc.T("device.ceiling.delta_hear_what_it_removes"), Loc.T("device.ceiling.delta_play_the_difference_between"));
Control LookRow() => SliderRow("LOOK", Lookahead, LookF, lit: () => false);
Control LinkRow() => SliderRow("LINK", StereoLink, LinkF);
@@ -505,7 +505,7 @@ internal sealed class CeilingDeviceBody : IDeviceBody
Background = Sunken, BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Badge, Padding = new Thickness(6, 4),
Child = new StackPanel { Spacing = 1, Children = { Caps("INTEGRATED"), line } },
};
- ToolTip.SetTip(box, Loc.T("Integrated loudness since the last Reset, gated (BS.1770), against the Target"));
+ ToolTip.SetTip(box, Loc.T("device.ceiling.integrated_loudness_since_the_last"));
return Spread(box,
MeterGrid(
("LUFS-S", () => Lufs(ScDb(S_LufsS)), () => TextPrimary),
@@ -532,13 +532,13 @@ internal sealed class CeilingDeviceBody : IDeviceBody
bool d = On(DeltaP);
t.Text = d ? "Delta" : "Detector";
t.Foreground = d ? AccentBright : TextTertiary;
- l1.Text = d ? Loc.T("hearing what it removes") : (Tp() ? Loc.T("true peak · 4×") : "sample peak") + (ExtOn() ? " · key" : "");
- l2.Text = d ? Loc.T("the difference in − out") : NotaNum.F($"{KeyName()} · HP {HpF(P(ScHp))} · latency {Sc(S_Latency):0} smp");
+ l1.Text = d ? Loc.T("device.ceiling.hearing_what_it_removes") : (Tp() ? Loc.T("device.ceiling.true_peak_4") : "sample peak") + (ExtOn() ? " · key" : "");
+ l2.Text = d ? Loc.T("device.ceiling.the_difference_in_out") : NotaNum.F($"{KeyName()} · HP {HpF(P(ScHp))} · latency {Sc(S_Latency):0} smp");
l1.Foreground = d ? AccentBright : TextPrimary;
dot.Background = d ? Brass : Sc(S_Gr) > 0.1 ? Success : NotaPalette.BorderStrong;
box.BorderBrush = d ? NotaPalette.BorderBrass : NotaPalette.GraphBorder;
});
- ToolTip.SetTip(box, Loc.T("What the limiter listens to — or, with Delta on, that you are hearing only what it takes away"));
+ ToolTip.SetTip(box, Loc.T("device.ceiling.what_the_limiter_listens_to"));
return Spread(
LookRow(), LinkRow(),
SliderRow("SC HP", ScHp, HpF, modulation: true, lit: () => P(ScHp) > 20.5f),
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/ChamberDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/ChamberDeviceBody.cs
index fdd0dff5..f6b2fcb6 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/ChamberDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/ChamberDeviceBody.cs
@@ -46,7 +46,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
// proxy); mirrors chamber::irSpec in Chamber.h — the engine list wins when present.
private static readonly (string Name, string Cat, string Len)[] IrFallback =
{
- (Loc.T("Concert Hall · Wide"), "HALL", "2.6"), ("Stone Vault", "HALL", "4.4"), ("Cathedral", "HALL", "7.5"), ("Scoring Stage", "HALL", "2.3"),
+ (Loc.T("device.chamber.concert_hall_wide"), "HALL", "2.6"), ("Stone Vault", "HALL", "4.4"), ("Cathedral", "HALL", "7.5"), ("Scoring Stage", "HALL", "2.3"),
("Wood Chamber", "ROOM", "1.6"), ("Live Room", "ROOM", "1.0"), ("Drum Room", "ROOM", "0.8"), ("Tiled Bathroom", "ROOM", "1.3"),
("Vocal Plate", "PLATE", "2.8"), ("Bright Plate", "PLATE", "2.0"), ("Spring Tank", "SPRING", "2.6"), ("Car Park", "SPACE", "3.6"),
("Stairwell", "SPACE", "3.2"), ("Forest Clearing", "OUTDOOR", "2.0"), ("Gated Room", "FX", "0.7"), ("Metal Tank", "FX", "3.4"),
@@ -275,7 +275,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
readouts.Add(() => f.Set(P(p)));
MidiLearn.Bind(f, MidiTarget.DeviceParam(track, di, p), engine.DeviceParamName(track, di, p));
ValueEntry.Attach(f, CF(p, split ? "Blend" : "Dry/wet", split ? v => NotaNum.F($"{v * 100:0}\u2009% algorithm") : Pct));
- ToolTip.SetTip(f, split ? Loc.T("Blend — convolution (slate, top) ⇄ algorithm (neutral, bottom). Double-click: 50 / 50") : Loc.T("Dry/Wet — double-click resets"));
+ ToolTip.SetTip(f, split ? Loc.T("device.chamber.blend_convolution_slate_top_algorithm") : Loc.T("device.chamber.dry_wet_double_click_resets"));
var lb = Caps(label); lb.HorizontalAlignment = HorizontalAlignment.Center;
if (!split) readouts.Add(() => lb.Foreground = P(DryWet) > 0.995f || On(WetOnly) ? TxtC : MutedC);
return new DockPanel { Children = { Docked(lb, Dock.Bottom), f } };
@@ -307,13 +307,13 @@ internal sealed class ChamberDeviceBody : IDeviceBody
var irInfo = Mono("", 7, MutedC);
var irBox = new Border { Height = 16, Background = Inset, BorderBrush = Border2, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Badge, Padding = new Thickness(6, 0), Cursor = new Cursor(StandardCursorType.Hand),
Child = new DockPanel { Children = { Docked(new Glyph(GlyphKind.ChevronDown, 8) { Foreground = MutedC, Margin = new Thickness(6, 0, 0, 0) }, Dock.Right), Docked(irInfo, Dock.Right), irName } } };
- ToolTip.SetTip(irBox, Loc.T("Impulse response — built-in rooms, or your own file (drop it on the waveform)"));
+ ToolTip.SetTip(irBox, Loc.T("device.chamber.impulse_response_built_in_rooms"));
MidiLearn.Bind(irBox, MidiTarget.DeviceParam(track, di, IrSelect), "IR");
readouts.Add(() =>
{
int ir = Sel(IrSelect, IrCount);
string user = ir == IrCount - 1 ? engine.DeviceText(track, di, 2) : "";
- irName.Text = ir < irList.Count ? irList[ir].Name : user.Length > 0 ? user : Loc.T("User IR — none loaded");
+ irName.Text = ir < irList.Count ? irList[ir].Name : user.Length > 0 ? user : Loc.T("device.chamber.user_ir_none_loaded_2");
double s = IrSecs(), sr = Sc(S_IrRate); int ch = (int)Sc(S_IrChannels);
irInfo.Text = s > 0 ? NotaNum.F($"{s:0.0}\u2009s · {sr / 1000:0.#}\u2009kHz · {(ch >= 4 ? "4-ch" : ch == 2 ? "stereo" : "mono")} ") : "";
});
@@ -340,11 +340,11 @@ internal sealed class ChamberDeviceBody : IDeviceBody
}
fly.Items.Add(new Separator());
string userName = engine.DeviceText(track, di, 2);
- var um = new MenuItem { Header = userName.Length > 0 ? NotaNum.F($"User · {userName}") : Loc.T("User IR (none loaded)"), IsEnabled = userName.Length > 0 };
+ var um = new MenuItem { Header = userName.Length > 0 ? NotaNum.F($"User · {userName}") : Loc.T("device.chamber.user_ir_none_loaded"), IsEnabled = userName.Length > 0 };
um.ToggleType = MenuItemToggleType.Radio; um.IsChecked = cur == IrCount - 1;
um.Click += (_, _) => SetP(IrSelect, 1f);
fly.Items.Add(um);
- var load = new MenuItem { Header = Loc.T("Load impulse response…") };
+ var load = new MenuItem { Header = Loc.T("device.chamber.load_impulse_response") };
load.Click += (_, _) => PickIr(irBox);
fly.Items.Add(load);
fly.ShowAt(irBox);
@@ -355,7 +355,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
irRow.Children.Add(Col(GlyphBtn(GlyphKind.ChevronLeft, () => StepIr(-1), "Previous IR"), 1));
irRow.Children.Add(Col(irBox, 2));
irRow.Children.Add(Col(GlyphBtn(GlyphKind.ChevronRight, () => StepIr(1), "Next IR"), 3));
- irRow.Children.Add(Col(Btn(Loc.T("Load…"), () => PickIr(irRow), Loc.T("Load an impulse response (WAV / FLAC / MP3 — mono, stereo or 4-ch true stereo)")), 4));
+ irRow.Children.Add(Col(Btn(Loc.T("device.chamber.load"), () => PickIr(irRow), Loc.T("device.chamber.load_an_impulse_response_wav")), 4));
// IR view: trims drive IR Start / IR Decay.
irView.TrimChanged += (s, e) => { Raw(IrStart, (float)s); Raw(IrDecay, (float)e); };
@@ -363,7 +363,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
irView.DragEnded += h => End(h == 1 ? IrStart : IrDecay);
ValueEntry.AttachHandles(irView, [CF(IrStart, "IR start", v => IrSecs() > 0 ? Secs(v * IrSecs()) : Pct(v))],
[CF(IrDecay, "IR decay", v => IrSecs() > 0 ? Secs(v * IrSecs()) : Pct(v))]);
- ToolTip.SetTip(irView, MenuKit.Keys(Loc.T("Drag the trim lines to trim the IR (Start · Decay); ⌥-click to type, double-click resets. Drop an audio file here to load it.")));
+ ToolTip.SetTip(irView, MenuKit.Keys(Loc.T("device.chamber.drag_the_trim_lines_to")));
readouts.Add(() =>
{
string sig = NotaNum.F($"{Sel(IrSelect, IrCount)}|{Sc(S_IrSeconds):0.000}|{Sc(S_IrChannels)}|{Sc(S_UserIr)}");
@@ -371,7 +371,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
int ir = Sel(IrSelect, IrCount);
bool noUser = ir == IrCount - 1 && Sc(S_UserIr) < 0.5;
irView.Set(IrSecs(), P(IrStart), P(IrDecay), 0.5 * P(IrAttack) * P(IrAttack), On(IrReverse), Sc(S_Building) > 0.5,
- noUser ? Loc.T("Drop an impulse response here (WAV / FLAC / MP3) or click Load…") : null);
+ noUser ? Loc.T("device.chamber.drop_an_impulse_response_here") : null);
FetchPreviews();
irView.SetResult(resEnv, Sc(S_ResultSeconds), PreSec(ConvPredelay, ConvSync));
});
@@ -421,7 +421,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
graph.DragEnded += b => End(b == 0 ? AlgoLowDecay : b == 1 ? AlgoDecay : AlgoHighDecay);
ValueEntry.AttachHandles(graph, [CF(AlgoLowDecay, "Low decay", v => Secs(RtMid() * Math.Pow(16, v - 0.5)))],
[CF(AlgoDecay, "Decay", v => Secs(Exp(v, 0.2, 20)))], [CF(AlgoHighDecay, "High decay", v => Secs(RtMid() * Math.Pow(16, v - 0.5)))]);
- ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("Drag a marker to set that band's RT60 (mid = Decay; low / high follow it as ratios). The Damping knob sets the high crossover. · ⌥-click to type")));
+ ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("device.chamber.drag_a_marker_to_set")));
readouts.Add(() =>
{
FetchPreviews();
@@ -460,7 +460,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
eq.DragEnded += h => { if (h == 0) { End(EqLowCut); End(EqLowGain); } else { End(EqHighCut); End(EqHighShelf); } };
ValueEntry.AttachHandles(eq, [CF(EqLowCut, "Low cut", LowCutF), CF(EqLowGain, "Low shelf", GainF)],
[CF(EqHighCut, "High cut", HighCutF), CF(EqHighShelf, "High shelf", GainF)]);
- ToolTip.SetTip(eq, MenuKit.Keys(Loc.T("Left handle: low cut (X) + low shelf (Y) · right handle: high cut (X) + high shelf (Y) · ⌥-click to type")));
+ ToolTip.SetTip(eq, MenuKit.Keys(Loc.T("device.chamber.left_handle_low_cut_x")));
readouts.Add(() => eq.Set(P(EqLowCut), P(EqLowGain), P(EqHighShelf), P(EqHighCut)));
var eqKnobs = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*,*"), Height = 50 };
eqKnobs.Children.Add(K(EqLowCut, "LOW-CUT", LowCutF, 30, 48));
@@ -482,12 +482,12 @@ internal sealed class ChamberDeviceBody : IDeviceBody
// Shimmer
bool ShimDim() => Sel(AlgoMode, 4) != 3;
- var shimCap = Caps(Loc.T("SHIMMER · PITCH SHIFT"));
- readouts.Add(() => { shimCap.Text = ShimDim() ? Loc.T("Shimmer · shimmer mode only") : Loc.T("Shimmer · pitch shift"); shimCap.Foreground = ShimDim() ? DimC : MutedC; });
+ var shimCap = Caps(Loc.T("device.chamber.shimmer_pitch_shift_caps"));
+ readouts.Add(() => { shimCap.Text = ShimDim() ? Loc.T("device.chamber.shimmer_shimmer_mode_only") : Loc.T("device.chamber.shimmer_pitch_shift"); shimCap.Foreground = ShimDim() ? DimC : MutedC; });
var interval = Row(5, Caps("INTERVAL"), Seg(ShimmerPitch, new[] { "−12", "+7", "+12" }));
var shimGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 6 };
shimGrid.Children.Add(K(ShimmerAmount, "AMOUNT", v => Pct(v), 28, 44, ChamberInk.Mauve));
- shimGrid.Children.Add(Col(new StackPanel { Spacing = 4, VerticalAlignment = VerticalAlignment.Center, Children = { interval, Toggle(ShimmerFeedback, Loc.T("Feed shimmer back"), ShimDim) } }, 1));
+ shimGrid.Children.Add(Col(new StackPanel { Spacing = 4, VerticalAlignment = VerticalAlignment.Center, Children = { interval, Toggle(ShimmerFeedback, Loc.T("device.chamber.feed_shimmer_back"), ShimDim) } }, 1));
var shim = Divider(new StackPanel { Spacing = 2, Children = { shimCap, shimGrid } }, 4);
shim.Margin = new Thickness(0, 3, 0, 0);
@@ -516,24 +516,24 @@ internal sealed class ChamberDeviceBody : IDeviceBody
g.Children.Add(Col(Caps(name), 1));
var bar = HBar(Blend, () => conv ? 1 - P(Blend) : P(Blend), v => Raw(Blend, (float)(conv ? 1 - v : v)),
v => ShortDb(ShareDb(v)), conv ? ChamberInk.Slate : NotaPalette.VizInk, () => !On(onP), 26);
- ToolTip.SetTip(bar, conv ? Loc.T("Convolution share of the blend (drags Blend)") : Loc.T("Algorithm share of the blend (drags Blend)"));
+ ToolTip.SetTip(bar, conv ? Loc.T("device.chamber.convolution_share_of_the_blend") : Loc.T("device.chamber.algorithm_share_of_the_blend"));
g.Children.Add(Col(bar, 2));
return g;
}
var route = new Grid { ColumnDefinitions = new ColumnDefinitions("48,*"), VerticalAlignment = VerticalAlignment.Center };
route.Children.Add(Caps("ROUTE"));
var rseg = Seg(Routing, new[] { "Parallel", "Serial" });
- ToolTip.SetTip(rseg, Loc.T("Parallel: both engines hear the input · Serial: the convolution feeds the algorithm"));
+ ToolTip.SetTip(rseg, Loc.T("device.chamber.parallel_both_engines_hear_the"));
route.Children.Add(Col(rseg, 1));
var dry = new Grid { ColumnDefinitions = new ColumnDefinitions("48,*"), VerticalAlignment = VerticalAlignment.Center };
dry.Children.Add(Caps("DRY"));
dry.Children.Add(Col(HBar(DryLevel, () => P(DryLevel), v => Raw(DryLevel, (float)v), v => ShortDb(DryDb(v)), NotaPalette.BorderStrong, () => On(WetOnly), 26), 1));
var duck = SliderRow("DUCKING", DuckAmount, v => NotaNum.F($"{v * 24:0.0}"));
var rel = SliderRow("RELEASE", DuckRelease, v => NotaNum.F($"{Exp(v, 20, 2000):0}"));
- ToolTip.SetTip(duck, Loc.T("Ducking — the wet dips (up to 24\u2009dB) while the input plays"));
+ ToolTip.SetTip(duck, Loc.T("device.chamber.ducking_the_wet_dips_up"));
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6, VerticalAlignment = VerticalAlignment.Center };
- btns.Children.Add(Latch(Freeze, "Freeze", Loc.T("Freeze — hold the algorithm tail forever; the input is muted")));
- btns.Children.Add(Col(Latch(FreezeIn, "Hold in", Loc.T("Hold in — keep feeding the input into the frozen tail (layering)")), 1));
+ btns.Children.Add(Latch(Freeze, "Freeze", Loc.T("device.chamber.freeze_hold_the_algorithm_tail")));
+ btns.Children.Add(Col(Latch(FreezeIn, "Hold in", Loc.T("device.chamber.hold_in_keep_feeding_the")), 1));
var wetBar = new PentadLevelBar { Height = 4, VerticalAlignment = VerticalAlignment.Center };
var wetDb = Mono("", 8, TxtC);
readouts.Add(() =>
@@ -569,16 +569,16 @@ internal sealed class ChamberDeviceBody : IDeviceBody
var qual = new Grid { ColumnDefinitions = new ColumnDefinitions("48,*"), VerticalAlignment = VerticalAlignment.Center };
qual.Children.Add(Caps("QUALITY"));
var qseg = Seg(Quality, new[] { "Eco", "Mid", "High" });
- ToolTip.SetTip(qseg, Loc.T("Eco: IR up to 3 s · Mid: 6 s · High: 10 s + cubic-interpolated algorithm modulation"));
+ ToolTip.SetTip(qseg, Loc.T("device.chamber.eco_ir_up_to_3"));
qual.Children.Add(Col(qseg, 1));
var mid = new StackPanel { Spacing = 6, Children = {
SliderRow("WIDTH", WidthP, v => NotaNum.F($"{v * 200:0}"), 48),
SliderRow("Mono f", BassMono, v => v <= 0.001 ? "off" : NotaNum.F($"{Exp(v, 30, 500):0}"), 48),
qual } };
- var wetOnly = Toggle(WetOnly, Loc.T("Wet only (send)"));
- ToolTip.SetTip(wetOnly, Loc.T("Wet only — 100\u2009% wet, no dry: for a return / send track"));
+ var wetOnly = Toggle(WetOnly, Loc.T("common.wet_only_send"));
+ ToolTip.SetTip(wetOnly, Loc.T("device.chamber.wet_only_100_wet_no"));
var zl = Toggle(ZeroLatency, "Zero latency");
- ToolTip.SetTip(zl, Loc.T("On: exact convolution timing at 0\u2009ms predelay (FIR head, more CPU). Off: lighter — the first block arrives late and is absorbed into the predelay."));
+ ToolTip.SetTip(zl, Loc.T("device.chamber.on_exact_convolution_timing_at"));
var bottom = new StackPanel { Spacing = 5, Children = { wetOnly, zl } };
var body = new DockPanel { LastChildFill = false, Children = {
Docked(top, Dock.Top),
@@ -608,7 +608,7 @@ internal sealed class ChamberDeviceBody : IDeviceBody
extras.Text = On(Freeze) ? "Freeze active" : On(Routing) && On(ConvOn) ? "fed by convolution" : "";
extras.Foreground = On(Freeze) ? AmberLit : MutedC; break;
default:
- extras.Text = Sel(EqPosition, 3) switch { 0 => Loc.T("at the input, before both engines"), 2 => Loc.T("at the output, dry + wet"), _ => Loc.T("on the tail, before Dry/Wet") };
+ extras.Text = Sel(EqPosition, 3) switch { 0 => Loc.T("device.chamber.at_the_input_before_both"), 2 => Loc.T("device.chamber.at_the_output_dry_wet"), _ => Loc.T("device.chamber.on_the_tail_before_dry") };
extras.Foreground = MutedC; break;
}
});
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/ChorusDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/ChorusDeviceBody.cs
index a00a9143..64a4817c 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/ChorusDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/ChorusDeviceBody.cs
@@ -147,12 +147,12 @@ internal sealed class ChorusDeviceBody : IDeviceBody
syncSeg.Width = 76;
readouts.Add(syncSync);
Learn(syncSeg, Sync);
- ToolTip.SetTip(syncSeg, Loc.T("Hz runs the LFO free; Sync takes its rate from the tempo and locks it to the bar while the transport plays"));
+ ToolTip.SetTip(syncSeg, Loc.T("common.hz_runs_the_lfo_free"));
var modeSeg = Segments(ChorusMath.Modes, ModeI, i => { SetP(Mode, i / 2.0); RefreshAll(); }, out var modeSync, fill: true, padX: 0);
readouts.Add(modeSync);
Learn(modeSeg, Mode);
- ToolTip.SetTip(modeSeg, Loc.T("Classic — two voices, left and right; Ensemble — three voices 120° apart, a string-machine shimmer; Vibrato — the pitch wobble alone, no dry signal"));
+ ToolTip.SetTip(modeSeg, Loc.T("device.chorus.classic_two_voices_left_and"));
var big = Mono("", 26, TextPrimary); big.FontWeight = FontWeight.Bold; big.LineHeight = 28;
var bigSub = new TextBlock { FontSize = 8, Foreground = TextSecondary };
@@ -175,18 +175,18 @@ internal sealed class ChorusDeviceBody : IDeviceBody
big.Foreground = On() ? TextPrimary : NotaPalette.TextAxis;
});
var bigBlock = new StackPanel { Spacing = 1, VerticalAlignment = VerticalAlignment.Center, Children = { big, bigSub, period } };
- ToolTip.SetTip(bigBlock, Loc.T("The LFO rate: in Hz, or the note value it takes from the tempo"));
+ ToolTip.SetTip(bigBlock, Loc.T("common.the_lfo_rate_in_hz"));
- var rateRow = Slider("RATE", Rate, v => HzF(ChorusMath.FreeHz(v)) + " Hz", Loc.T("Rate — the free LFO rate, 0.02 … 8 Hz"), 38, 46);
+ var rateRow = Slider("RATE", Rate, v => HzF(ChorusMath.FreeHz(v)) + " Hz", Loc.T("common.rate_the_free_lfo_rate"), 38, 46);
var divRow = Slider("RATE", Division, v => ChorusMath.DivNames[ChorusMath.DivIndex(v)],
- Loc.T("Rate — the note value of one LFO cycle, 4/1 … 1/16 with triplet (T) values"), 38, 46,
+ Loc.T("device.chorus.rate_the_note_value_of"), 38, 46,
snap: v => ChorusMath.DivNorm(ChorusMath.DivIndex(v)));
readouts.Add(() => { rateRow.IsVisible = !Synced(); divRow.IsVisible = Synced(); });
var offsetRow = Slider("OFFSET", Offset, v => Ens() ? "3 × 120°" : NotaNum.F($"{v * 180:0}°"),
- Loc.T("Offset — the right voice's LFO behind the left: 0° moves both together, 180° opposite. Ensemble spreads its three voices 120° apart on its own"),
+ Loc.T("device.chorus.offset_the_right_voices_lfo"),
38, 46, modulation: true, snap: v => Math.Round(v * 180) / 180, locked: Ens);
var hpfRow = Slider("HPF", Hpf, v => ChorusMath.HpHz(v) <= 0 ? "off" : ChorusMath.HzF(ChorusMath.HpHz(v)) + " Hz",
- Loc.T("HPF — a high-pass on the wet input (20 Hz … 2 kHz), so the lows stay dry and centred; far left is off"), 38, 46,
+ Loc.T("device.chorus.hpf_a_high_pass_on"), 38, 46,
modulation: true, snap: v => Math.Round(v / 0.005) * 0.005);
var leftBody = new Grid { RowDefinitions = new RowDefinitions("Auto,*,Auto,Auto,Auto"), RowSpacing = 6, Margin = new Thickness(8, 6) };
@@ -233,7 +233,7 @@ internal sealed class ChorusDeviceBody : IDeviceBody
var viewSeg = Segments(new[] { "τ", "ct" }, () => Cents() ? 1 : 0, i => { viewCents = i == 1; RefreshAll(); }, out var viewSync, fill: true, padX: 0);
viewSeg.Width = 52;
readouts.Add(viewSync);
- ToolTip.SetTip(viewSeg, Loc.T("τ draws each voice's delay; ct its detune — how far the moving delay bends the pitch"));
+ ToolTip.SetTip(viewSeg, Loc.T("device.chorus.draws_each_voices_delay_ct"));
var headRight = new StackPanel { Orientation = Orientation.Horizontal, VerticalAlignment = VerticalAlignment.Center, Children = { plotRead, viewSeg } };
var centreHead = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto"), VerticalAlignment = VerticalAlignment.Center };
centreHead.Children.Add(Caps("VOICES"));
@@ -246,11 +246,11 @@ internal sealed class ChorusDeviceBody : IDeviceBody
plot.Changed += a => { Raw(Amount, Math.Round(a * 100) / 100); RefreshAll(); };
plot.ResetRequested += () => { Reset(Amount); RefreshAll(); };
Learn(plot, Amount);
- ToolTip.SetTip(plot, MenuKit.Keys(Loc.T("Each voice over two LFO cycles — its delay (τ) or its detune (ct) — and where it is now. Drag up / down for Amount; ⌥-click types, double-click resets it.")));
+ ToolTip.SetTip(plot, MenuKit.Keys(Loc.T("device.chorus.each_voice_over_two_lfo")));
ValueEntry.AttachAll(plot, ValueEntry.DeviceParam(engine, track, di, Amount, "Amount", PctF, RefreshAll));
var field = new ChorusFieldView { Margin = new Thickness(0, 4, 0, 0) };
- ToolTip.SetTip(field, Loc.T("Where the voices sit in the stereo field (Width) and how far each is detuned right now"));
+ ToolTip.SetTip(field, Loc.T("device.chorus.where_the_voices_sit_in"));
var centreBody = new DockPanel { LastChildFill = true, Margin = new Thickness(5), Children = { Docked(field, Dock.Bottom), plot } };
var centre = Island(centreHead, centreBody);
centre.Margin = new Thickness(5, 0);
@@ -266,21 +266,21 @@ internal sealed class ChorusDeviceBody : IDeviceBody
stateWord.Text = s;
stateWord.Foreground = s == "resonant" ? TextPrimary : s == "bypass" ? NotaPalette.TextAxis : TextSecondary;
});
- ToolTip.SetTip(stateWord, Loc.T("How many voices sing, or that the feedback makes it ring (past 60 %), or that Vibrato plays wet only"));
+ ToolTip.SetTip(stateWord, Loc.T("device.chorus.how_many_voices_sing_or"));
const double LW = 46, VW = 36;
- var amountRow = Slider("AMOUNT", Amount, v => PctF(v), Loc.T("Amount — how far the LFO swings each voice's delay: more is wider detune"), LW, VW,
+ var amountRow = Slider("AMOUNT", Amount, v => PctF(v), Loc.T("device.chorus.amount_how_far_the_lfo"), LW, VW,
snap: v => Math.Round(v * 100) / 100);
var fbRow = Slider("FEEDBACK", Feedback, v => FbF(ChorusMath.Fb(v)),
- Loc.T("Feedback — the voices fed back into the line, ±90 %: a little thickens, past 60 % it rings metallic like a flanger"), LW, VW,
+ Loc.T("device.chorus.feedback_the_voices_fed_back"), LW, VW,
modulation: true, bipolar: true, snap: v => ChorusMath.FbNorm(Math.Round(ChorusMath.Fb(v) * 100) / 100));
var widthRow = Slider("WIDTH", Spread, v => NotaNum.F($"{ChorusMath.WidthPct(v):0} %"),
- Loc.T("Width — the voices' stereo spread: 0 % mono, 100 % as they are, 200 % lifts the side by +6 dB"), LW, VW,
+ Loc.T("device.chorus.width_the_voices_stereo_spread"), LW, VW,
modulation: true, snap: v => Math.Round(v * 200) / 200);
var warmRow = Slider("WARMTH", Warmth, v => PctF(v),
- Loc.T("Warmth — a bucket-brigade flavour on the delay line: darker (low-pass down to 2.5 kHz) and gently saturated"), LW, VW,
+ Loc.T("device.chorus.warmth_a_bucket_brigade_flavour"), LW, VW,
snap: v => Math.Round(v * 100) / 100, ink: NotaPalette.RoseBright);
- var mixRow = Slider("MIX", Mix, v => Vib() ? "wet" : PctF(v), Loc.T("Mix — 0 % dry, 50 % dry and wet equal, 100 % the voices alone. Vibrato is always wet"), LW, VW,
+ var mixRow = Slider("MIX", Mix, v => Vib() ? "wet" : PctF(v), Loc.T("device.chorus.mix_0_dry_50_dry"), LW, VW,
snap: v => Math.Round(v * 100) / 100, locked: Vib);
Control ReadRow(string label, FlangerBar bar, TextBlock value, string tip)
@@ -304,8 +304,8 @@ internal sealed class ChorusDeviceBody : IDeviceBody
{
Spacing = 4, Children =
{
- ReadRow("DETUNE", detuneBar, detuneVal, Loc.T("The largest detune the sweep reaches, ± cents (0 … 60 on the bar)")),
- ReadRow("DELAY", delayBar, delayVal, Loc.T("The range each voice's delay sweeps, ms (0 … 24 on the bar)")),
+ ReadRow("DETUNE", detuneBar, detuneVal, Loc.T("device.chorus.the_largest_detune_the_sweep")),
+ ReadRow("DELAY", delayBar, delayVal, Loc.T("device.chorus.the_range_each_voices_delay")),
},
},
};
@@ -330,14 +330,14 @@ internal sealed class ChorusDeviceBody : IDeviceBody
double fb = Fb(), afb = Math.Abs(fb);
bool warn = false;
string foot;
- if (!On()) foot = Loc.T("Chorus bypassed: the signal passes unchanged");
- else if (!Vib() && P(Mix) < 0.01f) { foot = Loc.T("Mix at zero: only the dry signal is heard"); warn = true; }
- else if (P(Amount) < 0.01f) foot = Loc.T("Amount at zero: the voices stand still, a static ") + ChorusMath.Ms(ChorusMath.BaseMs[ModeI()]) + " ms delay remains";
+ if (!On()) foot = Loc.T("device.chorus.chorus_bypassed_the_signal_passes");
+ else if (!Vib() && P(Mix) < 0.01f) { foot = Loc.T("common.mix_at_zero_only_the"); warn = true; }
+ else if (P(Amount) < 0.01f) foot = Loc.T("device.chorus.amount_at_zero_the_voices") + ChorusMath.Ms(ChorusMath.BaseMs[ModeI()]) + " ms delay remains";
else if (afb >= 0.6) { foot = "Feedback " + FbF(fb) + ": a metallic ring creeps in, like a flanger"; warn = true; }
- else if (Vib()) foot = Loc.T("Vibrato: no dry signal, the pitch swings ±") + ChorusMath.Ct(MaxCt()) + " ct at " + HzF(RateHz()) + " Hz";
- else if (WidthPct() < 1) foot = Loc.T("Width 0 %: the voices fold to mono, no space");
+ else if (Vib()) foot = Loc.T("device.chorus.vibrato_no_dry_signal_the") + ChorusMath.Ct(MaxCt()) + " ct at " + HzF(RateHz()) + " Hz";
+ else if (WidthPct() < 1) foot = Loc.T("device.chorus.width_0_the_voices_fold");
else
- foot = Loc.T("Detune up to ±") + ChorusMath.Ct(MaxCt()) + " ct · τ " + ChorusMath.Ms(TauMin()) + "–" + ChorusMath.Ms(TauMax())
+ foot = Loc.T("device.chorus.detune_up_to") + ChorusMath.Ct(MaxCt()) + " ct · τ " + ChorusMath.Ms(TauMin()) + "–" + ChorusMath.Ms(TauMax())
+ " ms · " + (Ens() ? "3" : "2") + " voices";
statusLeft.Text = foot;
statusLeft.Foreground = warn ? NotaPalette.Warning : TextSecondary;
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/CompressorDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/CompressorDeviceBody.cs
index d408fe18..a9ebabff 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/CompressorDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/CompressorDeviceBody.cs
@@ -237,7 +237,7 @@ internal sealed class CompressorDeviceBody : IDeviceBody
thrFader.GestureBegin += () => Begin(Threshold);
thrFader.GestureEnd += () => End(Threshold);
MidiLearn.Bind(thrFader, MidiTarget.DeviceParam(track, di, Threshold), "Thresh");
- ToolTip.SetTip(thrFader, MenuKit.Keys(Loc.T("Threshold — the tick is the key's level right now. ⌥-click types, double-click resets.")));
+ ToolTip.SetTip(thrFader, MenuKit.Keys(Loc.T("device.compressor.threshold_the_tick_is_the")));
// The second fader is make-up on Curve / Motion and the key's gain on Sidechain.
int F2() => centreTab == 2 ? ScGain : Makeup;
@@ -261,7 +261,7 @@ internal sealed class CompressorDeviceBody : IDeviceBody
thrVal.Text = Db(P(Threshold));
f2Val.Text = SDb(P(p2));
f2Lbl.Text = NotaText.Label(p2 == ScGain ? "SC IN" : "MKP");
- ToolTip.SetTip(f2, MenuKit.Keys(p2 == ScGain ? Loc.T("Key gain — drives the detector harder or softer. ⌥-click types, double-click resets.") : Loc.T("Make-up gain. ⌥-click types, double-click resets.")));
+ ToolTip.SetTip(f2, MenuKit.Keys(p2 == ScGain ? Loc.T("device.compressor.key_gain_drives_the_detector") : Loc.T("device.compressor.make_up_gain_click_types")));
});
ValueEntry.Attach(thrFader, F("Threshold", () => Threshold, Lin, Db), thrVal);
ValueEntry.Attach(f2, F("Make-up", F2, Lin, SDb), f2Val);
@@ -286,7 +286,7 @@ internal sealed class CompressorDeviceBody : IDeviceBody
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 6, Height = 18 };
g.Children.Add(Caps("CHAR"));
var seg = Seg(Character, Chars);
- ToolTip.SetTip(seg, Loc.T("Character — the voicing: Clean as set, Glue slower and softer, Punch faster, Opto slow and program-soft, FET very fast"));
+ ToolTip.SetTip(seg, Loc.T("device.compressor.character_the_voicing_clean_as"));
g.Children.Add(Col(seg, 1));
g.Children.Add(Col(info, 2));
return g;
@@ -310,11 +310,11 @@ internal sealed class CompressorDeviceBody : IDeviceBody
// CENTRE — Curve
// ======================================================================
var grHist = new CompGrHistoryView();
- ToolTip.SetTip(grHist, Loc.T("Gain reduction over the last four seconds; the dashed line is the peak. Click to clear it."));
+ ToolTip.SetTip(grHist, Loc.T("device.compressor.gain_reduction_over_the_last"));
Control CurveTab()
{
var transfer = new CompTransferView();
- ToolTip.SetTip(transfer, Loc.T("Drag sideways for the threshold, up / down for the ratio. Double-click resets both. The dot is the key level right now."));
+ ToolTip.SetTip(transfer, Loc.T("device.compressor.drag_sideways_for_the_threshold"));
transfer.GestureBegin += () => { Begin(Threshold); Begin(Ratio); };
transfer.GestureEnd += () => { End(Threshold); End(Ratio); };
transfer.Changed += (thr, ratio) => { Raw(Threshold, thr); Raw(Ratio, ratio); };
@@ -342,12 +342,12 @@ internal sealed class CompressorDeviceBody : IDeviceBody
Control MotionTab()
{
var motion = new CompMotionView();
- ToolTip.SetTip(motion, Loc.T("The reduction (neutral ink, hanging from 0 dB) against the input level (teal) — attack is the fall, release the climb back. The dashed line is the threshold."));
+ ToolTip.SetTip(motion, Loc.T("device.compressor.the_reduction_neutral_ink_hanging"));
readouts.Add(() => motion.Set(envIn, envGr, scN >= kScope + 2 * EnvN ? EnvN : 0, P(Threshold), WindowMs()));
string Measured()
{
var (tr, rec) = Timings((int)WindowMs());
- if (double.IsNaN(tr)) return Loc.T("no reduction to measure");
+ if (double.IsNaN(tr)) return Loc.T("device.compressor.no_reduction_to_measure");
return NotaNum.F($"transient {Ms(tr)} · recovery {(double.IsNaN(rec) ? "–" : Ms(rec))}");
}
return new DockPanel { LastChildFill = true, Margin = new Thickness(8, 5, 8, 4), Children = {
@@ -378,11 +378,11 @@ internal sealed class CompressorDeviceBody : IDeviceBody
if (k.Source >= 0 && !On(External)) SetP(External, 1);
ctx.NotifyChanged();
};
- ToolTip.SetTip(combo, Loc.T("Key source — Internal keys off this track; pick another track, or one pad or chain of it, to duck or pump against it"));
+ ToolTip.SetTip(combo, Loc.T("device.compressor.key_source_internal_keys_off"));
var tap = Segments(new[] { "Pre", "Post" }, () => engine.DeviceSidechainTapPre(track, di) ? 0 : 1,
i => { engine.SetDeviceSidechainTapPre(track, di, i == 0); ctx.NotifyChanged(); }, out var tapSync);
readouts.Add(tapSync);
- ToolTip.SetTip(tap, Loc.T("Where the source is tapped: before its effects and fader, or after — for a pad or chain, before its own effects, or after them and its level"));
+ ToolTip.SetTip(tap, Loc.T("device.compressor.where_the_source_is_tapped"));
var info = Mono("", 7, TextTertiary); info.HorizontalAlignment = HorizontalAlignment.Right;
readouts.Add(() => info.Text = NotaNum.F($"HP {HpF(P(ScHP))} · LP {LpF(P(ScLP))} · Q {P(ScQ):0.0}"));
var head = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,Auto,*"), ColumnSpacing = 6, Height = 18 };
@@ -392,7 +392,7 @@ internal sealed class CompressorDeviceBody : IDeviceBody
head.Children.Add(Col(info, 3));
var key = new CompKeyView();
- ToolTip.SetTip(key, MenuKit.Keys(Loc.T("The key's spectrum under its filters — drag a handle sideways to move HP / LP, up / down for Q. ⌥-click a handle to type it, double-click to open it.")));
+ ToolTip.SetTip(key, MenuKit.Keys(Loc.T("device.compressor.the_keys_spectrum_under_its")));
int KParam(int h) => h == 0 ? ScHP : h == 1 ? ScLP : ScQ;
key.GestureBegin += h => Begin(KParam(h));
key.GestureEnd += h => End(KParam(h));
@@ -474,7 +474,7 @@ internal sealed class CompressorDeviceBody : IDeviceBody
var det = new Grid { ColumnDefinitions = new ColumnDefinitions("40,*"), VerticalAlignment = VerticalAlignment.Center };
det.Children.Add(Caps("DETECT"));
var detSeg = Seg(Detection, Detects);
- ToolTip.SetTip(detSeg, Loc.T("Detector — Peak reacts to every transient, RMS to the body, Auto follows the body and still catches the spikes"));
+ ToolTip.SetTip(detSeg, Loc.T("device.compressor.detector_peak_reacts_to_every"));
det.Children.Add(Col(detSeg, 1));
var rows = new Control[]
{
@@ -485,8 +485,8 @@ internal sealed class CompressorDeviceBody : IDeviceBody
SliderRow("RANGE", Range, RangeF, RangeMap(), teal: true),
GrBox(false),
new StackPanel { Spacing = 5, VerticalAlignment = VerticalAlignment.Center, Children = {
- Toggle(AutoRelease, "Auto-release", Loc.T("Auto-release — a slower second release once the reduction runs deep, so sustained material does not pump")),
- Toggle(AutoGain, "Auto gain", Loc.T("Auto gain — make-up that follows the threshold and ratio")) } },
+ Toggle(AutoRelease, "Auto-release", Loc.T("device.compressor.auto_release_a_slower_second")),
+ Toggle(AutoGain, "Auto gain", Loc.T("device.compressor.auto_gain_make_up_that")) } },
};
var grid = new Grid { RowDefinitions = new RowDefinitions("*,*,*,Auto,*,Auto,*"), RowSpacing = 2 };
for (int r = 0; r < rows.Length; r++) grid.Children.Add(GRow(rows[r], r));
@@ -496,8 +496,8 @@ internal sealed class CompressorDeviceBody : IDeviceBody
Control OutputTab()
{
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6, VerticalAlignment = VerticalAlignment.Center };
- var listen = Latch(ScListen, "Listen", Loc.T("Listen — hear the filtered key instead of the output, to set HP / LP by ear"));
- var autoGain = Latch(AutoGain, "Auto gain", Loc.T("Auto gain — make-up that follows the threshold and ratio"));
+ var listen = Latch(ScListen, "Listen", Loc.T("device.compressor.listen_hear_the_filtered_key"));
+ var autoGain = Latch(AutoGain, "Auto gain", Loc.T("device.compressor.auto_gain_make_up_that"));
listen.HorizontalAlignment = HorizontalAlignment.Stretch; autoGain.HorizontalAlignment = HorizontalAlignment.Stretch;
btns.Children.Add(listen); btns.Children.Add(Col(autoGain, 1));
var rows = new Control[]
@@ -508,8 +508,8 @@ internal sealed class CompressorDeviceBody : IDeviceBody
SliderRow("RANGE", Range, RangeF, RangeMap(), teal: true),
new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 4, 0, 0), Child = btns },
new StackPanel { Spacing = 5, VerticalAlignment = VerticalAlignment.Center, Children = {
- Toggle(External, "External key", Loc.T("External key — key off the source picked on the Sidechain tab; off, the track keys itself")),
- Toggle(StereoLink, "Stereo link", Loc.T("Stereo link — one reduction for both channels; off, left and right compress on their own")) } },
+ Toggle(External, "External key", Loc.T("device.compressor.external_key_key_off_the")),
+ Toggle(StereoLink, "Stereo link", Loc.T("device.compressor.stereo_link_one_reduction_for")) } },
};
var grid = new Grid { RowDefinitions = new RowDefinitions("Auto,*,*,*,Auto,*"), RowSpacing = 3 };
for (int r = 0; r < rows.Length; r++) grid.Children.Add(GRow(rows[r], r));
@@ -532,7 +532,7 @@ internal sealed class CompressorDeviceBody : IDeviceBody
extras.Text = NotaNum.F($"window {Ms(WindowMs())} · {RatioF(P(Ratio))} · knee {P(Knee):0.0}");
extras.Foreground = TextTertiary; break;
case 2:
- extras.Text = On(ScListen) ? Loc.T("key audible · output muted") : ExtActive() ? NotaNum.F($"external key · {SourceName()}") : "internal key";
+ extras.Text = On(ScListen) ? Loc.T("device.compressor.key_audible_output_muted") : ExtActive() ? NotaNum.F($"external key · {SourceName()}") : "internal key";
extras.Foreground = On(ScListen) ? AccentBright : TextTertiary; break;
default:
extras.Text = NotaNum.F($"{RatioF(P(Ratio))} · knee {P(Knee):0.0} dB · {Detects[Sel(Detection, 3)].ToLowerInvariant()}");
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/CrushDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/CrushDeviceBody.cs
index 10abf63c..193aaf0e 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/CrushDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/CrushDeviceBody.cs
@@ -186,10 +186,10 @@ internal sealed class CrushDeviceBody : IDeviceBody
var seg = Segments(CrushMath.Modes, ModeI, i => { SetP(Mode, i / 2f); RefreshAll(); }, out var sync, padX: 6);
readouts.Add(sync);
Learn(seg, Mode);
- ToolTip.SetTip(seg, Loc.T("Mode — Digital: hard truncation to the levels; Analog: a soft tanh clip before them (+4\u2009dB, rounder); Fold: a wavefolder — more Drive folds the peaks back more times"));
+ ToolTip.SetTip(seg, Loc.T("device.crush.mode_digital_hard_truncation_to"));
var words = new TextBlock { FontSize = 7, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
readouts.Add(() => words.Text = ModeWords[ModeI()]);
- var aa = ParamChip(AntiAlias, "Anti-alias", Loc.T("Anti-alias — a 4th-order low-pass at the reduced rate's Nyquist before the hold, so less folds back as images"));
+ var aa = ParamChip(AntiAlias, "Anti-alias", Loc.T("device.crush.anti_alias_a_4th_order"));
return HeadRow(Row(6, Caps("MODE"), seg, words), aa);
}
@@ -202,10 +202,10 @@ internal sealed class CrushDeviceBody : IDeviceBody
i1.TextTrimming = i2.TextTrimming = TextTrimming.CharacterEllipsis;
readouts.Add(() => { i1.Text = info1(); i2.Text = info2(); });
var knobs = Row(2,
- K(Bits, "BITS", BitsF, Loc.T("Bits — the bit depth, 1 … 24: fewer bits, fewer levels, more grit"), lit: () => centreTab == 0),
- K(Rate, "RATE", RateF, Loc.T("Rate — the reduced sample rate, 500\u2009Hz … full: lower holds each value longer and adds images above its Nyquist"), lit: () => centreTab == 1),
- K(Drive, "DRIVE", DriveF, Loc.T("Drive — −12 … +24\u2009dB into the crusher: pushes the signal up the levels, into the Analog clip or into more folds"), lit: () => centreTab == 2),
- K(DryWet, "WET", v => Pct(v), Loc.T("Wet — the crushed signal against the dry one"), teal: true));
+ K(Bits, "BITS", BitsF, Loc.T("device.crush.bits_the_bit_depth_1"), lit: () => centreTab == 0),
+ K(Rate, "RATE", RateF, Loc.T("device.crush.rate_the_reduced_sample_rate"), lit: () => centreTab == 1),
+ K(Drive, "DRIVE", DriveF, Loc.T("device.crush.drive_12_24_db_into"), lit: () => centreTab == 2),
+ K(DryWet, "WET", v => Pct(v), Loc.T("device.crush.wet_the_crushed_signal_against"), teal: true));
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), Height = 52, ColumnSpacing = 8 };
g.Children.Add(knobs);
g.Children.Add(Col(new StackPanel { Spacing = 3, VerticalAlignment = VerticalAlignment.Center, Children = { i1, i2 } }, 1));
@@ -223,8 +223,8 @@ internal sealed class CrushDeviceBody : IDeviceBody
var colTitle = Caps("CRUSH"); colTitle.HorizontalAlignment = HorizontalAlignment.Center;
var inPill = new ShPill { Ink = Teal, VerticalAlignment = VerticalAlignment.Stretch, Width = 14 };
var outPill = new ShPill { Ink = NotaPalette.VizInk, VerticalAlignment = VerticalAlignment.Stretch, Width = 14 };
- ToolTip.SetTip(inPill, Loc.T("The input peak, −60 … 0\u2009dBFS"));
- ToolTip.SetTip(outPill, Loc.T("The output peak, −60 … 0\u2009dBFS"));
+ ToolTip.SetTip(inPill, Loc.T("device.crush.the_input_peak_60_0"));
+ ToolTip.SetTip(outPill, Loc.T("device.crush.the_output_peak_60_0"));
var colIn = Mono("", 7, TextPrimary); colIn.HorizontalAlignment = HorizontalAlignment.Center;
var colOut = Mono("", 7, TextPrimary); colOut.HorizontalAlignment = HorizontalAlignment.Center;
static double NormLvl(double db) => Math.Clamp((db + 60) / 60, 0, 1);
@@ -283,7 +283,7 @@ internal sealed class CrushDeviceBody : IDeviceBody
spectrum.GestureEnd += h => End(map[h]);
spectrum.ResetRequested += h => { Reset(map[h]); RefreshAll(); };
Learn(spectrum, Rate);
- ToolTip.SetTip(spectrum, MenuKit.Keys(Loc.T("The output spectrum: neutral ink is the signal, teal what the crush added — bright above the reduced Nyquist (the images). Drag the Nyquist line for Rate, the filter line for the post filter; ⌥-click types, double-click resets.")));
+ ToolTip.SetTip(spectrum, MenuKit.Keys(Loc.T("device.crush.the_output_spectrum_neutral_ink")));
ValueEntry.AttachHandles(spectrum, [F(Rate, "Rate", RateF)], [F(PostFilter, "Post filter", FiltF)]);
var knobs = KnobRow(
() => Sc(S_Analysed) < 0.5 ? "no signal" : ScDb(S_Images) <= -119 ? NotaNum.F($"no images above {KHz(Sc(S_Nyquist))}")
@@ -303,10 +303,10 @@ internal sealed class CrushDeviceBody : IDeviceBody
curve.GestureEnd += _ => End(Drive);
curve.ResetRequested += _ => { Reset(Drive); RefreshAll(); };
Learn(curve, Drive);
- ToolTip.SetTip(curve, MenuKit.Keys(Loc.T("Input → output through Drive, the mode and the levels; the dot is where the signal peaks. Drag up / down for Drive; ⌥-click types, double-click resets.")));
+ ToolTip.SetTip(curve, MenuKit.Keys(Loc.T("device.crush.input_output_through_drive_the")));
ValueEntry.AttachHandles(curve, [F(Drive, "Drive", DriveF)]);
wave = new CrWaveView();
- ToolTip.SetTip(wave, Loc.T("Two cycles of a sine at the driven level (dashed) and what comes out"));
+ ToolTip.SetTip(wave, Loc.T("device.crush.two_cycles_of_a_sine"));
var pair = new DockPanel { LastChildFill = true, Children = { Docked(curve, Dock.Left), new Border { Margin = new Thickness(5, 0, 0, 0), Child = wave } } };
string DriveX() => NotaNum.F($"×{Math.Pow(10, DriveDb(P(Drive)) / 20):0.0}");
var knobs = KnobRow(
@@ -316,7 +316,7 @@ internal sealed class CrushDeviceBody : IDeviceBody
1 => NotaNum.F($"drive {DriveX()} → soft clip"),
_ => NotaNum.F($"drive {DriveX()} · straight"),
},
- () => ModeI() == 2 ? LvF(Levels()) + Loc.T(" levels after the fold") : LvF(Levels()) + " levels");
+ () => ModeI() == 2 ? LvF(Levels()) + Loc.T("device.crush.levels_after_the_fold") : LvF(Levels()) + " levels");
return TabBody(ModeHead(), pair, knobs);
}
@@ -332,8 +332,8 @@ internal sealed class CrushDeviceBody : IDeviceBody
return new Border { Padding = new Thickness(8, 6), Child = g };
}
static Control Rule(Control c) => new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 0), Child = c };
- Control FilterRow() => SliderRow("FILTER", PostFilter, FiltF, Loc.T("Post filter — a low-pass after the crush, 200\u2009Hz … 20 kHz: under the Nyquist it smooths the steps"), modulation: true);
- Control GainRow() => SliderRow("GAIN", Output, GainF, Loc.T("Output gain, ±12\u2009dB"), bipolar: true);
+ Control FilterRow() => SliderRow("FILTER", PostFilter, FiltF, Loc.T("device.crush.post_filter_a_low_pass"), modulation: true);
+ Control GainRow() => SliderRow("GAIN", Output, GainF, Loc.T("device.crush.output_gain_12_db"), bipolar: true);
Control GritTab()
{
@@ -353,17 +353,17 @@ internal sealed class CrushDeviceBody : IDeviceBody
string tail = (ModeI() switch { 1 => " · soft", 2 => " · fold", _ => "" }) + (On(AntiAlias) ? " · AA" : "");
double rate = RateHz(P(Rate));
l1.Text = NotaNum.F($"{BitsOf(P(Bits)):0.0} bit · ") + (rate >= 1000 ? NotaNum.F($"{rate / 1000:0.0}\u2009kHz") : NotaNum.F($"{rate:0}\u2009Hz")) + tail;
- l2.Text = filt < nyq ? Loc.T("the filter cuts the images")
+ l2.Text = filt < nyq ? Loc.T("device.crush.the_filter_cuts_the_images")
: NotaNum.F($"Nyquist {Hz(nyq)} · filter above");
t.Foreground = hot ? AccentBright : TextTertiary;
l1.Foreground = hot ? AccentBright : TextPrimary;
box.BorderBrush = hot ? NotaPalette.BorderBrass : NotaPalette.GraphBorder;
});
- ToolTip.SetTip(box, Loc.T("What comes out: the bit depth and the rate, and whether the post filter cuts the images above the reduced Nyquist or lets them through"));
+ ToolTip.SetTip(box, Loc.T("device.crush.what_comes_out_the_bit"));
return Spread(
- SliderRow("DITHER", Dither, v => Pct(v), Loc.T("Dither — up to ±½ LSB of triangular noise before the levels: softens the steps into hiss")),
- SliderRow("JITTER", Jitter, v => Pct(v), Loc.T("Jitter — the hold length wanders up to ±50 %: an unsteady, broken clock")),
- SliderRow("NOISE", NoiseFloor, v => Pct(v), Loc.T("Noise — a white noise floor under the crush, up to −50\u2009dBFS")),
+ SliderRow("DITHER", Dither, v => Pct(v), Loc.T("device.crush.dither_up_to_lsb_of")),
+ SliderRow("JITTER", Jitter, v => Pct(v), Loc.T("device.crush.jitter_the_hold_length_wanders")),
+ SliderRow("NOISE", NoiseFloor, v => Pct(v), Loc.T("device.crush.noise_a_white_noise_floor")),
Rule(FilterRow()), GainRow(), box);
}
@@ -392,14 +392,14 @@ internal sealed class CrushDeviceBody : IDeviceBody
},
},
};
- ToolTip.SetTip(meters, Loc.T("Peaks in and out, and the output's crest factor (peak over RMS) — the crush flattens it"));
+ ToolTip.SetTip(meters, Loc.T("device.crush.peaks_in_and_out_and"));
var toggles = new StackPanel
{
Spacing = 5, Children =
{
- Toggle(AutoGain, "Auto gain", Loc.T("Auto gain — rides the output back to the input's loudness (300\u2009ms RMS, ±24\u2009dB), so turning Bits or Drive doesn't jump in level"),
+ Toggle(AutoGain, "Auto gain", Loc.T("device.crush.auto_gain_rides_the_output"),
() => On(AutoGain) ? "Auto gain " + Sgn(Sc(S_AutoGain)) + "\u2009dB" : "Auto gain"),
- Toggle(DcFilter, "DC filter", Loc.T("DC filter — a 10\u2009Hz high-pass on the crushed signal: takes out the offset a coarse, folded or noisy crush can leave")),
+ Toggle(DcFilter, "DC filter", Loc.T("device.crush.dc_filter_a_10_hz")),
},
};
return Spread(meters, FilterRow(), GainRow(), Rule(toggles));
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/DelayDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/DelayDeviceBody.cs
index 67ec3ac2..cbcf2d37 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/DelayDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/DelayDeviceBody.cs
@@ -197,7 +197,7 @@ internal sealed class DelayDeviceBody : IDeviceBody
DelayTaps NewTaps()
{
var t = new DelayTaps();
- ToolTip.SetTip(t, Loc.T("The repeat train — L above the axis, R below. Height is the level left after each pass; the repeat sounding now is lit."));
+ ToolTip.SetTip(t, Loc.T("device.delay.the_repeat_train_l_above"));
tapViews.Add(t);
return t;
}
@@ -228,7 +228,7 @@ internal sealed class DelayDeviceBody : IDeviceBody
ruler = "";
win = Window(windowSec);
}
- if (freeze) { title = Loc.T("LOOP HELD · no decay"); sub = NotaNum.F($"R {Ms(msr)}"); }
+ if (freeze) { title = Loc.T("device.delay.loop_held_no_decay"); sub = NotaNum.F($"R {Ms(msr)}"); }
foreach (var t in tapViews) t.Set(fracL, fracR, P(Feedback), On(PingPong), freeze, title, sub, ruler, win);
// Light the repeat that is sounding: the card counts them off the wall clock at the
@@ -274,10 +274,10 @@ internal sealed class DelayDeviceBody : IDeviceBody
var faders = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto"), ColumnSpacing = 4, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 4, 0, 2) };
faders.Children.Add(LoopFader(Feedback, "FEEDBACK", NotaPalette.VizInk, NotaPalette.VizInk,
v => On(Freeze) ? "Hold" : Pct(v),
- Loc.T("Feedback — how much of each repeat goes round again; Freeze pins it at 100 %. ⌥-click types, double-click resets.")));
+ Loc.T("device.delay.feedback_how_much_of_each")));
faders.Children.Add(Col(LoopFader(Spread, "SPREAD", NotaPalette.Rose, NotaPalette.RoseBright,
v => NotaNum.F($"{v * 50:0} ms"),
- Loc.T("Spread — pushes the right channel later, up to 50 ms. ⌥-click types, double-click resets.")), 1));
+ Loc.T("device.delay.spread_pushes_the_right_channel")), 1));
var loopCol = new RuleSection
{
Width = 96, Padding = new Thickness(0, 5, 0, 4),
@@ -331,9 +331,9 @@ internal sealed class DelayDeviceBody : IDeviceBody
var head = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,Auto,Auto,Auto,*"), ColumnSpacing = 5, Height = 20 };
head.Children.Add(Caps("MODE"));
head.Children.Add(Col(modeSeg, 1));
- head.Children.Add(Col(Latch(LinkLR, "Link", Loc.T("Link L/R — the right channel follows the left's time")), 2));
- head.Children.Add(Col(Latch(PingPong, "Ping", Loc.T("Ping-pong — each repeat crosses to the other channel")), 3));
- head.Children.Add(Col(Latch(FadeChange, "Fade", Loc.T("Fade on change — crossfade to a new delay time instead of gliding to it (which bends the pitch, tape style)")), 4));
+ head.Children.Add(Col(Latch(LinkLR, "Link", Loc.T("device.delay.link_l_r_the_right")), 2));
+ head.Children.Add(Col(Latch(PingPong, "Ping", Loc.T("device.delay.ping_pong_each_repeat_crosses")), 3));
+ head.Children.Add(Col(Latch(FadeChange, "Fade", Loc.T("device.delay.fade_on_change_crossfade_to")), 4));
head.Children.Add(Col(hint, 5));
var bottom = new Border { Child = host };
@@ -357,7 +357,7 @@ internal sealed class DelayDeviceBody : IDeviceBody
filter.Reset += h => Reset(h == 0 ? LowCut : HighCut);
ValueEntry.AttachHandles(filter, [ValueEntry.DeviceParam(engine, track, di, LowCut, "Low cut", v => Hz(LowHz(v)))],
[ValueEntry.DeviceParam(engine, track, di, HighCut, "High cut", v => Hz(HighHz(v)))]);
- ToolTip.SetTip(filter, MenuKit.Keys(Loc.T("The band the repeats live in — drag the left handle for the low cut, the right one for the high cut. ⌥-click a handle to type it, double-click to open it.")));
+ ToolTip.SetTip(filter, MenuKit.Keys(Loc.T("device.delay.the_band_the_repeats_live")));
MidiLearn.Bind(filter, MidiTarget.DeviceParam(track, di, LowCut), "Low Cut");
readouts.Add(() => { if (!filter.Dragging) filter.Set(P(LowCut), P(HighCut), LowHz(P(LowCut)), HighHz(P(HighCut))); });
@@ -410,7 +410,7 @@ internal sealed class DelayDeviceBody : IDeviceBody
wet.Children.Add(Caps("WET")); wet.Children.Add(Col(wetBar, 1)); wet.Children.Add(Col(wetDb, 2));
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6, VerticalAlignment = VerticalAlignment.Center };
- var freezeBtn = Btn("Freeze", () => { SetP(Freeze, On(Freeze) ? 0f : 1f); SyncTaps(); }, Loc.T("Freeze — hold the loop forever; the input is muted and the repeats stop decaying"));
+ var freezeBtn = Btn("Freeze", () => { SetP(Freeze, On(Freeze) ? 0f : 1f); SyncTaps(); }, Loc.T("device.delay.freeze_hold_the_loop_forever"));
var freezeTxt = (TextBlock)freezeBtn.Child!;
freezeBtn.BorderThickness = new Thickness(1);
readouts.Add(() =>
@@ -422,10 +422,10 @@ internal sealed class DelayDeviceBody : IDeviceBody
freezeTxt.FontWeight = on ? FontWeight.SemiBold : FontWeight.Normal;
});
btns.Children.Add(freezeBtn);
- btns.Children.Add(Col(Btn(Loc.T("Tap tempo"), TapTempo, Loc.T("Tap four times to set the delay time by ear (switches to free ms)")), 1));
+ btns.Children.Add(Col(Btn(Loc.T("device.delay.tap_tempo"), TapTempo, Loc.T("device.delay.tap_four_times_to_set")), 1));
var clear = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6, VerticalAlignment = VerticalAlignment.Center };
- clear.Children.Add(Btn(Loc.T("Clear loop"), () => engine.DeviceAction(track, di, A_ClearLoop, 0, 0), Loc.T("Empty the delay buffer — silences what is still circulating")));
+ clear.Children.Add(Btn(Loc.T("device.delay.clear_loop"), () => engine.DeviceAction(track, di, A_ClearLoop, 0, 0), Loc.T("device.delay.empty_the_delay_buffer_silences")));
clear.Children.Add(Col(Toggle(WetOnly, "Wet only"), 1));
var rows = new Control[]
@@ -463,10 +463,10 @@ internal sealed class DelayDeviceBody : IDeviceBody
SliderRow("WIDTH", WidthP, v => NotaNum.F($"{v * 200:0}"), 52),
SliderRow("Mono f", BassMono, v => v <= 0.001 ? "off" : NotaNum.F($"{Exp(v, 30, 500):0}"), 52) } };
- var wetOnly = Toggle(WetOnly, Loc.T("Wet only (send)"));
- ToolTip.SetTip(wetOnly, Loc.T("Wet only — repeats with no dry, for a return / send track"));
- var comp = Toggle(LatencyComp, Loc.T("Latency comp."));
- ToolTip.SetTip(comp, Loc.T("The diffuser lengthens the loop by a fixed group delay; on, the read pointer is pulled back by exactly that so each repeat lands on the set time."));
+ var wetOnly = Toggle(WetOnly, Loc.T("common.wet_only_send"));
+ ToolTip.SetTip(wetOnly, Loc.T("device.delay.wet_only_repeats_with_no"));
+ var comp = Toggle(LatencyComp, Loc.T("device.delay.latency_comp"));
+ ToolTip.SetTip(comp, Loc.T("device.delay.the_diffuser_lengthens_the_loop"));
var bottom = new StackPanel { Spacing = 5, Children = { wetOnly, comp } };
var body = new DockPanel { LastChildFill = false, Children = {
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/DynamicEqDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/DynamicEqDeviceBody.cs
index dfaf2852..6e212658 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/DynamicEqDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/DynamicEqDeviceBody.cs
@@ -146,7 +146,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
}
var chipStrip = new Border { Height = 20, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1), Child = chipRow };
DockPanel.SetDock(chipStrip, Dock.Top);
- ToolTip.SetTip(curve, Loc.T("Drag a node — frequency and gain · wheel over a node — Q · double-click a node — band on / off · ")
+ ToolTip.SetTip(curve, Loc.T("device.dynamic_eq.drag_a_node_frequency_and")
+ "double-click empty space — a new bell there · right-click a node — type, mode, solo");
var graphPanel = new RuleSection
{
@@ -181,7 +181,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
var name = new TextBlock { FontSize = 9, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0, 0, 0) };
var onSw = Switch("On", () => BandOn(b), () => { SetP(pOn, BandOn(b) ? 0 : 1); RefreshAll(); }, out var onSync);
Learn(onSw, pOn);
- ToolTip.SetTip(onSw, Loc.T("Band on — off leaves the band out of the signal (double-click its node does the same)"));
+ ToolTip.SetTip(onSw, Loc.T("device.dynamic_eq.band_on_off_leaves_the"));
bandReadouts.Add(onSync);
bandReadouts.Add(() =>
{
@@ -202,7 +202,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
RefreshAll();
}, out var typeSync, fill: true, padX: 0);
Learn(typeSeg, pType);
- ToolTip.SetTip(typeSeg, Loc.T("Type — high-pass, low shelf, bell, notch, high shelf, low-pass; only shelves and bells take gain and dynamics"));
+ ToolTip.SetTip(typeSeg, Loc.T("device.dynamic_eq.type_high_pass_low_shelf"));
bandReadouts.Add(typeSync);
// ---- knobs ----
@@ -231,10 +231,10 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
}
var knobs = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), Children =
{
- K(pF, "FREQ", () => DynEq.HzShort(B(b, DynEq.FreqF)) + (B(b, DynEq.FreqF) < 1000 ? " Hz" : ""), Loc.T("Frequency — or drag the node left / right")),
- Col(K(pG, "GAIN", () => Capable(b) ? DynEq.Db(B(b, DynEq.GainF)) + " dB" : "—", Loc.T("Gain — the static gain; or drag the node up / down"),
+ K(pF, "FREQ", () => DynEq.HzShort(B(b, DynEq.FreqF)) + (B(b, DynEq.FreqF) < 1000 ? " Hz" : ""), Loc.T("device.dynamic_eq.frequency_or_drag_the_node")),
+ Col(K(pG, "GAIN", () => Capable(b) ? DynEq.Db(B(b, DynEq.GainF)) + " dB" : "—", Loc.T("device.dynamic_eq.gain_the_static_gain_or"),
inactive: () => !Capable(b)), 1),
- Col(K(pQ, "Q", () => NotaNum.F($"{B(b, DynEq.QF):0.00}"), Loc.T("Q — the width (the resonance on the cuts); or the wheel over the node"),
+ Col(K(pQ, "Q", () => NotaNum.F($"{B(b, DynEq.QF):0.00}"), Loc.T("device.dynamic_eq.q_the_width_the_resonance"),
liveLabel: () => TypeOf(b) is DynEq.LowCut or DynEq.HighCut ? "Reso" : "Q"), 2),
} };
@@ -246,8 +246,8 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
RefreshAll(); curve.InvalidateVisual();
}, out var modeSync, padX: 6, dim: () => !Capable(b));
Learn(modeSeg, pMode);
- ToolTip.SetTip(modeSeg, Loc.T("Static — a plain EQ band · Duck — acts as the band's level rises above the threshold (a cut by default) · ")
- + Loc.T("Lift — acts as it falls below it (a boost by default)"));
+ ToolTip.SetTip(modeSeg, Loc.T("device.dynamic_eq.static_a_plain_eq_band")
+ + Loc.T("device.dynamic_eq.lift_acts_as_it_falls"));
bandReadouts.Add(modeSync);
var dynLabel = Caps("DYNAMICS");
bandReadouts.Add(() => dynLabel.Foreground = IsDyn(b) ? TextSecondary : TextTertiary);
@@ -300,7 +300,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
{
Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), HorizontalAlignment = HorizontalAlignment.Right,
};
- ToolTip.SetTip(flip, Loc.T("Flip — cut ↔ boost (a Duck that boosts is upward expansion, a Lift that cuts is downward expansion)"));
+ ToolTip.SetTip(flip, Loc.T("device.dynamic_eq.flip_cut_boost_a_duck"));
var flipPanel = new Panel();
flip.Child = flipPanel;
flip.PointerPressed += (_, e) =>
@@ -314,10 +314,10 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
Spacing = 5, Children =
{
SliderRow("THRESH", pThr, () => NotaNum.F($"{B(b, DynEq.ThrF):0} dB"),
- Loc.T("Threshold — where the band starts to act; the teal mark is the band's level now"),
+ Loc.T("device.dynamic_eq.threshold_where_the_band_starts"),
marker: () => ToN(pThr, Math.Max(mn[pThr], curve.Level(b)))),
SliderRow("RANGE", pRange, () => (Rng() >= 0 ? "↑ " : "↓ ") + NotaNum.F($"{Math.Abs(Rng()):0.0}"),
- Loc.T("Range — how far the gain can move at full engagement (6 dB past the threshold); click the arrow to flip cut / boost"),
+ Loc.T("device.dynamic_eq.range_how_far_the_gain"),
getN: () => Math.Abs(Rng()) / 18.0,
setN: n =>
{
@@ -327,8 +327,8 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
ink: () => DirInk(b),
reset: () => SetP(pRange, ModeOf(b) == DynEq.Lift ? 6 : -6),
valueCtl: flip),
- SliderRow("ATTACK", pAtk, () => DynEq.Ms(B(b, DynEq.AtkF)), Loc.T("Attack — how fast the band moves toward its range")),
- SliderRow("RELEASE", pRel, () => DynEq.Ms(B(b, DynEq.RelF)), Loc.T("Release — how fast it returns to its static gain")),
+ SliderRow("ATTACK", pAtk, () => DynEq.Ms(B(b, DynEq.AtkF)), Loc.T("device.dynamic_eq.attack_how_fast_the_band")),
+ SliderRow("RELEASE", pRel, () => DynEq.Ms(B(b, DynEq.RelF)), Loc.T("device.dynamic_eq.release_how_fast_it_returns")),
},
};
@@ -354,7 +354,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
RefreshAll();
}, out var keySync);
Learn(keySeg, pKey);
- ToolTip.SetTip(keySeg, Loc.T("Key — Self: the band listens to this track · Ext: to the key track (click Ext again to pick the track)"));
+ ToolTip.SetTip(keySeg, Loc.T("device.dynamic_eq.key_self_the_band_listens"));
bandReadouts.Add(keySync);
var soloTb = new TextBlock { Text = "Solo", FontSize = 8, VerticalAlignment = VerticalAlignment.Center };
var solo = new Border
@@ -368,7 +368,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
SetP(DynEq.SoloP, Solo() == b ? 0 : b + 1); RefreshAll(); curve.InvalidateVisual(); e.Handled = true;
};
Learn(solo, DynEq.SoloP);
- ToolTip.SetTip(solo, Loc.T("Solo — hear this band alone"));
+ ToolTip.SetTip(solo, Loc.T("device.dynamic_eq.solo_hear_this_band_alone"));
bandReadouts.Add(() =>
{
bool on = Solo() == b;
@@ -418,7 +418,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
return string.Join(" · ", parts);
}
var nowRead = Mono("", 8, TextTertiary);
- ToolTip.SetTip(nowRead, Loc.T("The selected band's dynamic gain right now"));
+ ToolTip.SetTip(nowRead, Loc.T("device.dynamic_eq.the_selected_bands_dynamic_gain"));
readouts.Add(() =>
{
int s = Sel();
@@ -436,7 +436,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
});
var dynSw = Switch("Dynamic", DynMaster, () => { SetP(DynEq.DynamicsP, DynMaster() ? 0 : 1); RefreshAll(); curve.InvalidateVisual(); }, out var dynSync);
Learn(dynSw, DynEq.DynamicsP);
- ToolTip.SetTip(dynSw, Loc.T("Dynamic — off parks every band on its static gain: hear what the dynamics do"));
+ ToolTip.SetTip(dynSw, Loc.T("device.dynamic_eq.dynamic_off_parks_every_band"));
readouts.Add(dynSync);
// OUT: a mono readout that drags vertically (±18 dB), double-click resets to 0.
@@ -461,7 +461,7 @@ internal sealed class DynamicEqDeviceBody : IDeviceBody
outBox.PointerReleased += (_, e) => { OutEnd(); e.Pointer.Capture(null); };
outBox.PointerCaptureLost += (_, _) => OutEnd();
Learn(outBox, DynEq.OutputP);
- ToolTip.SetTip(outBox, MenuKit.Keys(Loc.T("Output — drag up / down (Shift for fine), ⌥-click to type, double-click for 0 dB")));
+ ToolTip.SetTip(outBox, MenuKit.Keys(Loc.T("device.dynamic_eq.output_drag_up_down_shift")));
ValueEntry.Attach(outBox, ValueEntry.DeviceRaw(engine, track, di, DynEq.OutputP, "Output", -18, 18, v => "Out " + DynEq.Db(v) + " dB", RefreshAll), outTb);
readouts.Add(() =>
{
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/Eq3DeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/Eq3DeviceBody.cs
index 3bdedda6..c6306ce7 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/Eq3DeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/Eq3DeviceBody.cs
@@ -80,7 +80,7 @@ internal sealed class Eq3DeviceBody : IDeviceBody
ValueField BandField(int b) => new(NotaText.Label(Eq3Math.Names[b]) + " gain", () => P(Low + b),
v => Eq3Math.Db(Eq3Math.GainDb(v, Iso())) + "\u2009dB", v => Raw(Low + b, v), () => Begin(Low + b), () => End(Low + b))
{ Reset = () => ResetBand(b), After = RefreshAll };
- ValueField XoverField(int w) => new(w == 0 ? Loc.T("Low / mid crossover") : Loc.T("Mid / high crossover"), () => P(w == 0 ? FreqLo : FreqHi),
+ ValueField XoverField(int w) => new(w == 0 ? Loc.T("device.eq3.low_mid_crossover") : Loc.T("device.eq3.mid_high_crossover"), () => P(w == 0 ? FreqLo : FreqHi),
v => Eq3Math.Hz(w == 0 ? Eq3Math.LoHz(v) : Eq3Math.HiHz(v)),
v => { if (w == 0) Raw(FreqLo, Eq3Math.LoNorm(Math.Min(Eq3Math.LoHz(v), F2() / 2))); else Raw(FreqHi, Eq3Math.HiNorm(Math.Max(Eq3Math.HiHz(v), F1() * 2))); },
() => Begin(w == 0 ? FreqLo : FreqHi), () => End(w == 0 ? FreqLo : FreqHi))
@@ -128,7 +128,7 @@ internal sealed class Eq3DeviceBody : IDeviceBody
if (!e.GetCurrentPoint(btn).Properties.IsLeftButtonPressed) return; // right-click bubbles (MIDI learn)
SetP(LowKill + b, Killed(b) ? 0 : 1); RefreshAll(); e.Handled = true;
};
- ToolTip.SetTip(btn, Loc.F("Kill the {0} band — removes it outright, with a 5\u2009ms glide", Eq3Math.Names[b].ToLowerInvariant()));
+ ToolTip.SetTip(btn, Loc.F("device.eq3.kill_the_band_removes_it", Eq3Math.Names[b].ToLowerInvariant()));
Learn(btn, LowKill + b);
readouts.Add(Paint); Paint();
return btn;
@@ -145,7 +145,7 @@ internal sealed class Eq3DeviceBody : IDeviceBody
fader.GestureEnd += () => End(Low + b);
fader.Changed += db => { GainRaw(b, db); RefreshAll(); };
fader.ResetRequested += () => ResetBand(b);
- ToolTip.SetTip(fader, MenuKit.Keys(Loc.T("Drag up / down for the band's gain (Shift for fine steps); ⌥-click types it; double-click resets to 0\u2009dB and lifts the kill")));
+ ToolTip.SetTip(fader, MenuKit.Keys(Loc.T("device.eq3.drag_up_down_for_the")));
Learn(fader, Low + b);
ValueEntry.Attach(fader, BandField(b), val);
readouts.Add(() =>
@@ -190,7 +190,7 @@ internal sealed class Eq3DeviceBody : IDeviceBody
graph.GainReset += ResetBand;
Learn(graph, FreqLo);
ValueEntry.AttachHandles(graph, [XoverField(0)], [XoverField(1)], [BandField(0)], [BandField(1)], [BandField(2)]);
- ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("Each band in its colour, the sum in brass, the output spectrum behind. Drag a crossover handle left / right; drag anywhere else to ride that band's gain. Double-click resets, ⌥-click types.")));
+ ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("device.eq3.each_band_in_its_colour")));
// Header: crossover readouts · Output · Range · Slope.
Control XRead(string label, Func<string> text)
@@ -231,7 +231,7 @@ internal sealed class Eq3DeviceBody : IDeviceBody
v.Text = Eq3Math.Db(db) + "\u2009dB";
v.Foreground = Math.Abs(db) > 0.05 ? TextPrimary : TextSecondary;
});
- ToolTip.SetTip(box, MenuKit.Keys(Loc.T("Output gain, ±24\u2009dB — drag up / down (Shift for fine), ⌥-click types, double-click resets")));
+ ToolTip.SetTip(box, MenuKit.Keys(Loc.T("device.eq3.output_gain_24_db_drag")));
Learn(box, Gain);
ValueEntry.Attach(box, new ValueField("Output", () => P(Gain), x => Eq3Math.Db(OutDb(x)) + "\u2009dB", x => Raw(Gain, x),
() => Begin(Gain), () => End(Gain), 0.5) { After = RefreshAll }, v);
@@ -261,7 +261,7 @@ internal sealed class Eq3DeviceBody : IDeviceBody
var seg = Segments(new[] { "24\u2009dB", "48\u2009dB" }, () => Lr8() ? 1 : 0, i => { SetP(Slope, i); RefreshAll(); }, out var sync, padX: 4);
readouts.Add(sync);
Learn(seg, Slope);
- ToolTip.SetTip(seg, Loc.T("Crossover slope — Linkwitz-Riley 24 or 48\u2009dB/oct: steeper touches the neighbours less"));
+ ToolTip.SetTip(seg, Loc.T("device.eq3.crossover_slope_linkwitz_riley_24"));
return Row(4, Caps("SLOPE"), seg);
}
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/EqDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/EqDeviceBody.cs
index d391f2b9..9efdca06 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/EqDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/EqDeviceBody.cs
@@ -144,7 +144,7 @@ internal sealed class EqDeviceBody : IDeviceBody
}
var chipStrip = new Border { Height = 20, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1), Child = chipRow };
DockPanel.SetDock(chipStrip, Dock.Top);
- curve.DefaultTip = Loc.T("Drag a node — frequency and gain · wheel over a node — Q · double-click a node — band on / off · ")
+ curve.DefaultTip = Loc.T("device.eq.drag_a_node_frequency_and")
+ "double-click empty space — a new bell there · right-click a node — type, slope, channel · click a label — its note";
ToolTip.SetTip(curve, curve.DefaultTip);
@@ -152,24 +152,24 @@ internal sealed class EqDeviceBody : IDeviceBody
var anaSeg = Segments(Eq8.AnalyzerSeg, () => Math.Clamp((int)Math.Round(P(Eq8.AnalyzerP)), 0, 2),
i => { SetP(Eq8.AnalyzerP, i); RefreshAll(); }, out var anaSync, padX: 4);
Learn(anaSeg, Eq8.AnalyzerP);
- ToolTip.SetTip(anaSeg, Loc.T("Analyzer — Pre: the input spectrum · Post: the output over a dimmer input · Off"));
+ ToolTip.SetTip(anaSeg, Loc.T("device.eq.analyzer_pre_the_input_spectrum"));
readouts.Add(anaSync);
// Range (dB below 0 dBFS at the graph's bottom) and Peak hold, shown while the analyzer is on.
bool AnaOn() => Math.Clamp((int)Math.Round(P(Eq8.AnalyzerP)), 0, 2) != Eq8.AnaOff;
var rangeSeg = Segments(Eq8.RangeSeg, () => Math.Clamp((int)Math.Round(P(Eq8.AnaRangeP)), 0, 2),
i => { SetP(Eq8.AnaRangeP, i); RefreshAll(); curve.InvalidateVisual(); }, out var rangeSync, padX: 4);
Learn(rangeSeg, Eq8.AnaRangeP);
- ToolTip.SetTip(rangeSeg, Loc.T("Analyzer range — the graph's bottom edge, in dB below 0\u2009dBFS"));
+ ToolTip.SetTip(rangeSeg, Loc.T("device.eq.analyzer_range_the_graphs_bottom"));
bool PeakOn() => P(Eq8.AnaPeakP) >= 0.5f;
var peakSw = Switch("Peak", PeakOn, () => { SetP(Eq8.AnaPeakP, PeakOn() ? 0 : 1); RefreshAll(); }, out var peakSync);
Learn(peakSw, Eq8.AnaPeakP);
- ToolTip.SetTip(peakSw, Loc.T("Peak hold — a thin line at each frequency's highest level of the last moments"));
+ ToolTip.SetTip(peakSw, Loc.T("device.eq.peak_hold_a_thin_line"));
readouts.Add(() => { rangeSync(); peakSync(); rangeSeg.IsVisible = peakSw.IsVisible = AnaOn() && pc > Eq8.AnaPeakP; });
bool LabelsOn() => pc <= Eq8.LabelsP || P(Eq8.LabelsP) >= 0.5f;
var labelsSw = Switch("Labels", LabelsOn, () => { SetP(Eq8.LabelsP, LabelsOn() ? 0 : 1); RefreshAll(); }, out var labelsSync);
labelsSw.Margin = new Thickness(6, 0, 0, 0);
Learn(labelsSw, Eq8.LabelsP);
- ToolTip.SetTip(labelsSw, Loc.T("Labels — show the bands' labels and note marks in the graph (the chips and the band panel keep them)"));
+ ToolTip.SetTip(labelsSw, Loc.T("device.eq.labels_show_the_bands_labels"));
readouts.Add(() => { labelsSync(); labelsSw.IsVisible = textOk && pc > Eq8.LabelsP; });
var anaBar = new StackPanel
{
@@ -217,10 +217,10 @@ internal sealed class EqDeviceBody : IDeviceBody
var noteBox = new TextBox
{
Text = NoteOf(b), MaxLength = 2000, AcceptsReturn = true, TextWrapping = TextWrapping.Wrap, FontSize = 11,
- Height = 96, Watermark = Loc.T("What this band is for"),
+ Height = 96, Watermark = Loc.T("device.eq.what_this_band_is_for"),
};
var head = new TextBlock { Text = NotaNum.F($"BAND {b + 1} · {Eq8.TypeNames[TypeOf(b)]}"), FontSize = NotaType.KnobLabel, FontWeight = FontWeight.Medium, Foreground = TextTertiary };
- var hint = new TextBlock { Text = (OperatingSystem.IsMacOS() ? "⌘" : "Ctrl+") + Loc.T("Enter or Esc to close"), FontSize = 9, Foreground = TextTertiary };
+ var hint = new TextBlock { Text = (OperatingSystem.IsMacOS() ? "⌘" : "Ctrl+") + Loc.T("device.eq.enter_or_esc_to_close"), FontSize = 9, Foreground = TextTertiary };
var fly = new Flyout
{
Content = new StackPanel { Width = 230, Spacing = 5, Children = { head, labelBox, noteBox, hint } },
@@ -262,7 +262,7 @@ internal sealed class EqDeviceBody : IDeviceBody
var name = new TextBlock { FontSize = 9, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(6, 0, 0, 0) };
var onSw = Switch("On", () => BandOn(b), () => { SetP(pOn, BandOn(b) ? 0 : 1); RefreshAll(); }, out var onSync);
Learn(onSw, pOn);
- ToolTip.SetTip(onSw, Loc.T("Band on — off leaves the band out of the signal (double-click its node does the same)"));
+ ToolTip.SetTip(onSw, Loc.T("device.eq.band_on_off_leaves_the"));
bandReadouts.Add(onSync);
bandReadouts.Add(() =>
{
@@ -278,7 +278,7 @@ internal sealed class EqDeviceBody : IDeviceBody
// ---- type ----
var typeSeg = Segments(Eq8.TypeSeg, () => TypeOf(b), i => { SetP(pType, i); RefreshAll(); }, out var typeSync, fill: true, padX: 0);
Learn(typeSeg, pType);
- ToolTip.SetTip(typeSeg, Loc.T("Type — high-pass, low shelf, bell, notch, high shelf, low-pass; only shelves and bells take gain"));
+ ToolTip.SetTip(typeSeg, Loc.T("device.eq.type_high_pass_low_shelf"));
bandReadouts.Add(typeSync);
// ---- knobs ----
@@ -307,10 +307,10 @@ internal sealed class EqDeviceBody : IDeviceBody
}
var knobs = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), Children =
{
- K(pF, "FREQ", () => Eq8.HzShort(B(b, Eq8.FreqF)) + (B(b, Eq8.FreqF) < 1000 ? " Hz" : ""), Loc.T("Frequency — or drag the node left / right")),
- Col(K(pG, "GAIN", () => Capable(b) ? Eq8.Db(B(b, Eq8.GainF)) + " dB" : "—", Loc.T("Gain — or drag the node up / down (Scale multiplies it)"),
+ K(pF, "FREQ", () => Eq8.HzShort(B(b, Eq8.FreqF)) + (B(b, Eq8.FreqF) < 1000 ? " Hz" : ""), Loc.T("device.eq.frequency_or_drag_the_node")),
+ Col(K(pG, "GAIN", () => Capable(b) ? Eq8.Db(B(b, Eq8.GainF)) + " dB" : "—", Loc.T("device.eq.gain_or_drag_the_node"),
inactive: () => !Capable(b)), 1),
- Col(K(pQ, "Q", () => NotaNum.F($"{B(b, Eq8.QF):0.00}"), Loc.T("Q — the width (the resonance on the cuts); or the wheel over the node"),
+ Col(K(pQ, "Q", () => NotaNum.F($"{B(b, Eq8.QF):0.00}"), Loc.T("device.eq.q_the_width_the_resonance"),
liveLabel: () => Cut(b) ? "Reso" : "Q"), 2),
} };
@@ -319,7 +319,7 @@ internal sealed class EqDeviceBody : IDeviceBody
{
// AcceptsReturn and FlattenLabel, so a pasted multi-line text arrives whole; Enter commits.
Text = LabelOf(b), MaxLength = 24, AcceptsReturn = true, FontSize = 9, MinHeight = 18, Height = 18,
- Padding = new Thickness(4, 1), VerticalContentAlignment = VerticalAlignment.Center, Watermark = Loc.T("Name this band"),
+ Padding = new Thickness(4, 1), VerticalContentAlignment = VerticalAlignment.Center, Watermark = Loc.T("device.eq.name_this_band"),
};
void Unfocus() { curve.Focusable = true; curve.Focus(); } // hand the keys back to the card
void CommitLabel() { if ((labelField.Text ?? "") != LabelOf(b)) SetText(b, labelField.Text ?? "", NoteOf(b)); }
@@ -332,14 +332,14 @@ internal sealed class EqDeviceBody : IDeviceBody
else if (ke.Key == Avalonia.Input.Key.Escape) { labelField.Text = LabelOf(b); ke.Handled = true; Unfocus(); }
}, Avalonia.Interactivity.RoutingStrategies.Tunnel);
FlattenLabel(labelField);
- ToolTip.SetTip(labelField, Loc.T("Label — a short name shown next to the band's node (up to 24 characters)"));
+ ToolTip.SetTip(labelField, Loc.T("device.eq.label_a_short_name_shown"));
var noteBtn = new Button
{
Content = "Note", FontSize = 8, Height = 18, MinHeight = 18, Padding = new Thickness(6, 0), Margin = new Thickness(4, 0, 0, 0),
VerticalContentAlignment = VerticalAlignment.Center,
};
noteBtn.Click += (_, _) => { CommitLabel(); OpenNote(b, noteBtn, atPointer: false); };
- ToolTip.SetTip(noteBtn, Loc.T("Note — a longer note on what this band is for"));
+ ToolTip.SetTip(noteBtn, Loc.T("device.eq.note_a_longer_note_on"));
bandReadouts.Add(() =>
{
if (!labelField.IsFocused && (labelField.Text ?? "") != LabelOf(b)) labelField.Text = LabelOf(b);
@@ -364,17 +364,17 @@ internal sealed class EqDeviceBody : IDeviceBody
var slopeSeg = Segments(Eq8.SlopeSeg, () => SlopeOf(b), i => { if (Cut(b)) { SetP(pSlope, i); RefreshAll(); } },
out var slopeSync, fill: true, padX: 0, dim: () => !Cut(b));
Learn(slopeSeg, pSlope);
- ToolTip.SetTip(slopeSeg, Loc.T("Slope — how steep the high-pass / low-pass falls: 12, 24 or 48\u2009dB per octave"));
+ ToolTip.SetTip(slopeSeg, Loc.T("device.eq.slope_how_steep_the_high"));
bandReadouts.Add(slopeSync);
var chanSeg = Segments(Eq8.ChannelSeg, () => ChanOf(b), i => { SetP(pChan, i); RefreshAll(); }, out var chanSync, fill: true, padX: 0);
Learn(chanSeg, pChan);
- ToolTip.SetTip(chanSeg, Loc.T("Channel — St: both channels · Mid: the centre · Side: the edges · L / R: one channel alone"));
+ ToolTip.SetTip(chanSeg, Loc.T("device.eq.channel_st_both_channels_mid"));
bandReadouts.Add(chanSync);
// ---- global: Auto gain, Scale, Output ----
var autoSw = Switch("Auto gain", AutoOn, () => { SetP(Eq8.AutoGainP, AutoOn() ? 0 : 1); RefreshAll(); }, out var autoSync);
Learn(autoSw, Eq8.AutoGainP);
- ToolTip.SetTip(autoSw, Loc.T("Auto gain — adds the opposite of the shelves' and bells' average level, so edits are judged at the same loudness"));
+ ToolTip.SetTip(autoSw, Loc.T("device.eq.auto_gain_adds_the_opposite"));
bandReadouts.Add(autoSync);
var globalRow = new Border
{
@@ -409,8 +409,8 @@ internal sealed class EqDeviceBody : IDeviceBody
Spacing = 5, Children =
{
SliderRow("SCALE", Eq8.ScaleP, () => NotaNum.F($"{P(Eq8.ScaleP):0}\u2009%"),
- Loc.T("Scale — multiplies every shelf and bell gain: 100\u2009% as set, 0\u2009% flat, 200\u2009% twice as much"), 100),
- SliderRow("OUTPUT", Eq8.OutputP, () => Eq8.Db(P(Eq8.OutputP)) + " dB", Loc.T("Output — the level after the EQ, ±12\u2009dB"), 0),
+ Loc.T("device.eq.scale_multiplies_every_shelf_and"), 100),
+ SliderRow("OUTPUT", Eq8.OutputP, () => Eq8.Db(P(Eq8.OutputP)) + " dB", Loc.T("device.eq.output_the_level_after_the"), 0),
},
};
@@ -481,7 +481,7 @@ internal sealed class EqDeviceBody : IDeviceBody
outBox.PointerReleased += (_, e) => { OutEnd(); e.Pointer.Capture(null); };
outBox.PointerCaptureLost += (_, _) => OutEnd();
Learn(outBox, Eq8.OutputP);
- ToolTip.SetTip(outBox, MenuKit.Keys(Loc.T("Output (plus the auto gain in effect) — drag up / down (Shift for fine), ⌥-click to type, double-click for 0\u2009dB")));
+ ToolTip.SetTip(outBox, MenuKit.Keys(Loc.T("device.eq.output_plus_the_auto_gain")));
ValueEntry.Attach(outBox, ValueEntry.DeviceRaw(engine, track, di, Eq8.OutputP, "Output", -12, 12, v => "Out " + Eq8.Db(v) + " dB", RefreshAll), outTb);
readouts.Add(() =>
{
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/FlangerDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/FlangerDeviceBody.cs
index 2d13b5da..c55db9cf 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/FlangerDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/FlangerDeviceBody.cs
@@ -138,12 +138,12 @@ internal sealed class FlangerDeviceBody : IDeviceBody
syncSeg.Width = 76;
readouts.Add(syncSync);
Learn(syncSeg, Sync);
- ToolTip.SetTip(syncSeg, Loc.T("Hz runs the LFO free; Sync takes its rate from the tempo and locks it to the bar while the transport plays"));
+ ToolTip.SetTip(syncSeg, Loc.T("common.hz_runs_the_lfo_free"));
var waveSeg = Segments(FlangerMath.Waves, WaveI, i => { SetP(Waveform, i / 2.0); RefreshAll(); }, out var waveSync, fill: true, padX: 0);
readouts.Add(waveSync);
Learn(waveSeg, Waveform);
- ToolTip.SetTip(waveSeg, Loc.T("The LFO shape that sweeps the delay: Sine glides, Tri sweeps evenly, Saw rises and drops back"));
+ ToolTip.SetTip(waveSeg, Loc.T("device.flanger.the_lfo_shape_that_sweeps"));
var big = Mono("", 26, TextPrimary); big.FontWeight = FontWeight.Bold; big.LineHeight = 28;
var bigSub = new TextBlock { FontSize = 8, Foreground = TextSecondary };
@@ -166,15 +166,15 @@ internal sealed class FlangerDeviceBody : IDeviceBody
big.Foreground = On() ? TextPrimary : NotaPalette.TextAxis;
});
var bigBlock = new StackPanel { Spacing = 1, VerticalAlignment = VerticalAlignment.Center, Children = { big, bigSub, period } };
- ToolTip.SetTip(bigBlock, Loc.T("The LFO rate: in Hz, or the note value it takes from the tempo"));
+ ToolTip.SetTip(bigBlock, Loc.T("common.the_lfo_rate_in_hz"));
- var rateRow = Slider("RATE", Rate, v => HzF(FlangerMath.FreeHz(v)) + " Hz", Loc.T("Rate — the free LFO rate, 0.02 … 8 Hz"), 38, 46);
+ var rateRow = Slider("RATE", Rate, v => HzF(FlangerMath.FreeHz(v)) + " Hz", Loc.T("common.rate_the_free_lfo_rate"), 38, 46);
var divRow = Slider("RATE", Division, v => FlangerMath.DivNames[FlangerMath.DivIndex(v)],
- Loc.T("Rate — the note value of one LFO cycle, 2/1 … 1/16 with dotted (D) and triplet (T) values"), 38, 46,
+ Loc.T("device.flanger.rate_the_note_value_of"), 38, 46,
snap: v => FlangerMath.DivNorm(FlangerMath.DivIndex(v)));
readouts.Add(() => { rateRow.IsVisible = !Synced(); divRow.IsVisible = Synced(); });
var stereoRow = Slider("STEREO", Stereo, v => NotaNum.F($"{v * 180:0}°"),
- Loc.T("Stereo — the right LFO against the left: 0° sweeps both together, 90° spreads them, 180° moves them opposite"), 38, 46,
+ Loc.T("device.flanger.stereo_the_right_lfo_against"), 38, 46,
modulation: true, snap: v => Math.Round(v * 180) / 180);
var leftBody = new Grid { RowDefinitions = new RowDefinitions("Auto,*,Auto,Auto"), RowSpacing = 6, Margin = new Thickness(8, 6) };
@@ -200,11 +200,11 @@ internal sealed class FlangerDeviceBody : IDeviceBody
comb.Changed += (d, f) => { Raw(Delay, d); Raw(Feedback, f); RefreshAll(); };
comb.ResetRequested += () => { Reset(Delay); Reset(Feedback); RefreshAll(); };
Learn(comb, Delay);
- ToolTip.SetTip(comb, MenuKit.Keys(Loc.T("The comb the delay carves into the spectrum, L neutral and R teal, with the first notch dashed. Drag left / right to move the notch (Delay), up / down for Feedback; ⌥-click types, double-click resets both.")));
+ ToolTip.SetTip(comb, MenuKit.Keys(Loc.T("device.flanger.the_comb_the_delay_carves")));
ValueEntry.AttachAll(comb, ValueEntry.DeviceParam(engine, track, di, Delay, "Delay", v => FlangerMath.Ms(FlangerMath.BaseMs(v)) + " ms", RefreshAll), ValueEntry.DeviceParam(engine, track, di, Feedback, "Feedback", v => FbF(FlangerMath.Fb(v)), RefreshAll));
var sweep = new FlangerSweepView { Margin = new Thickness(0, 4, 0, 0) };
- ToolTip.SetTip(sweep, Loc.T("The delay τ of both channels over two LFO cycles, and where each is now"));
+ ToolTip.SetTip(sweep, Loc.T("device.flanger.the_delay_of_both_channels"));
var centreBody = new DockPanel { LastChildFill = true, Margin = new Thickness(5), Children = { Docked(sweep, Dock.Bottom), comb } };
var centre = Island(HeadRow(Caps("COMB RESPONSE"), legend), centreBody);
centre.Margin = new Thickness(5, 0);
@@ -220,14 +220,14 @@ internal sealed class FlangerDeviceBody : IDeviceBody
modeWord.Text = m;
modeWord.Foreground = m == "resonant" ? TextPrimary : m == "negative" ? NotaPalette.TealBright : TextSecondary;
});
- ToolTip.SetTip(modeWord, Loc.T("What the feedback makes: positive sharpens the peaks, negative hollows the tone, past 85\u2009% the comb rings"));
+ ToolTip.SetTip(modeWord, Loc.T("device.flanger.what_the_feedback_makes_positive"));
- var delayRow = Slider("DELAY", Delay, v => FlangerMath.Ms(FlangerMath.BaseMs(v)) + " ms", Loc.T("Delay — the centre of the sweep, 0.1 … 8 ms: shorter puts the notches higher"));
- var depthRow = Slider("DEPTH", Depth, v => PctF(v), Loc.T("Depth — how far the LFO swings the delay around its centre"));
+ var delayRow = Slider("DELAY", Delay, v => FlangerMath.Ms(FlangerMath.BaseMs(v)) + " ms", Loc.T("device.flanger.delay_the_centre_of_the"));
+ var depthRow = Slider("DEPTH", Depth, v => PctF(v), Loc.T("device.flanger.depth_how_far_the_lfo"));
var fbRow = Slider("FEEDBACK", Feedback, v => FbF(FlangerMath.Fb(v)),
- Loc.T("Feedback — the delayed signal fed back in, ±95 %: positive for the classic jet, negative for a hollow tone"), modulation: true, bipolar: true,
+ Loc.T("device.flanger.feedback_the_delayed_signal_fed"), modulation: true, bipolar: true,
snap: v => FlangerMath.FbNorm(Math.Round(FlangerMath.Fb(v) * 100) / 100));
- var mixRow = Slider("MIX", Mix, v => PctF(v), Loc.T("Mix — 50 % gives the deepest notches; 100 % is the delayed signal alone, a vibrato"));
+ var mixRow = Slider("MIX", Mix, v => PctF(v), Loc.T("device.flanger.mix_50_gives_the_deepest"));
Border Snap(string text, double fb)
{
@@ -249,7 +249,7 @@ internal sealed class FlangerDeviceBody : IDeviceBody
tb.Foreground = on ? TextPrimary : TextTertiary;
});
Learn(b, Feedback);
- ToolTip.SetTip(b, fb < 0 ? Loc.T("Feedback −70\u2009%: hollow") : fb > 0 ? Loc.T("Feedback +70\u2009%: the classic jet") : Loc.T("Feedback 0: a plain comb"));
+ ToolTip.SetTip(b, fb < 0 ? Loc.T("device.flanger.feedback_70_hollow") : fb > 0 ? Loc.T("device.flanger.feedback_70_the_classic_jet") : Loc.T("device.flanger.feedback_0_a_plain_comb"));
return b;
}
var snaps = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), ColumnSpacing = 1, Margin = new Thickness(46, 0, 0, 0) };
@@ -279,8 +279,8 @@ internal sealed class FlangerDeviceBody : IDeviceBody
{
Spacing = 4, Children =
{
- ReadRow("NOTCH", notchBar, notchVal, Loc.T("The first notch now, over the range the sweep moves it (20 Hz … 20 kHz)")),
- ReadRow("NULL", nullBar, nullVal, Loc.T("How deep the notches cut, dB (0 … −36 on the bar)")),
+ ReadRow("NOTCH", notchBar, notchVal, Loc.T("device.flanger.the_first_notch_now_over")),
+ ReadRow("NULL", nullBar, nullVal, Loc.T("device.flanger.how_deep_the_notches_cut")),
},
},
};
@@ -305,14 +305,14 @@ internal sealed class FlangerDeviceBody : IDeviceBody
double fb = Fb(), afb = Math.Abs(fb);
bool warn = false;
string foot;
- if (!On()) foot = Loc.T("Flanger bypassed: the signal passes unchanged");
- else if (P(Mix) < 0.01f) { foot = Loc.T("Mix at zero: only the dry signal is heard"); warn = true; }
+ if (!On()) foot = Loc.T("device.flanger.flanger_bypassed_the_signal_passes");
+ else if (P(Mix) < 0.01f) { foot = Loc.T("common.mix_at_zero_only_the"); warn = true; }
else if (afb >= 0.85)
{
foot = "Feedback " + FbF(fb) + NotaNum.F($": peaks up to +{FlangerMath.PeakDb(P(Mix), fb):0.0} dB, the comb rings");
warn = true;
}
- else if (P(Depth) < 0.01f) foot = Loc.T("Depth at zero: the comb stands still, a static effect");
+ else if (P(Depth) < 0.01f) foot = Loc.T("device.flanger.depth_at_zero_the_comb");
else
{
var (th, _) = FlangerMath.Notch(P(Mix), fb);
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/ForgeDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/ForgeDeviceBody.cs
index c2dde20f..3380d7f3 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/ForgeDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/ForgeDeviceBody.cs
@@ -154,7 +154,7 @@ internal sealed class ForgeDeviceBody : IDeviceBody
var routeSeg = Segments(RouteNames, RouteI, i => { SetP(Routing, i / 3f); Refresh(); }, out var routeSync, fill: true, padX: 2);
readouts.Add(routeSync);
Learn(routeSeg, Routing);
- ToolTip.SetTip(routeSeg, Loc.T("Routing — Serial: 1 → 2 → 3. Parallel: all three from the same input, averaged. M/S: stage 1 drives the Mid, stage 2 the Side, stage 3 the recombined stereo. Multi: stage 1 the lows (< 180 Hz), 2 the mids, 3 the highs (> 2.4 kHz)"));
+ ToolTip.SetTip(routeSeg, Loc.T("device.forge.routing_serial_1_2_3"));
Control StageTile(int s)
{
@@ -172,8 +172,8 @@ internal sealed class ForgeDeviceBody : IDeviceBody
head.Children.Add(dot); head.Children.Add(Col(num, 1)); head.Children.Add(Col(name, 2)); head.Children.Add(Col(role, 3)); head.Children.Add(Col(outBox, 4));
bool Lit() => On(OnP(s)) && Active();
- var drive = Slider("DRIVE", () => DriveP(s), PctF, Loc.F("Stage {0} drive — how hard the stage is pushed (gain 1 … ×21, the level made up)", s + 1), 42, 32);
- var fb = Slider("FEEDBACK", () => FbP(s), FbF, Loc.F("Stage {0} feedback — its output back into its input (0 … 85 %): thicker, and on the edge of ringing with Fold / Fuzz", s + 1), 44, 30, teal: true);
+ var drive = Slider("DRIVE", () => DriveP(s), PctF, Loc.F("device.forge.stage_drive_how_hard_the", s + 1), 42, 32);
+ var fb = Slider("FEEDBACK", () => FbP(s), FbF, Loc.F("device.forge.stage_feedback_its_output_back", s + 1), 44, 30, teal: true);
var rows = new StackPanel { Spacing = 1, Children = { drive, fb } };
var body = new DockPanel { Children = { Docked(head, Dock.Top), new Border { VerticalAlignment = VerticalAlignment.Bottom, Child = rows } } };
var tile = new Border
@@ -193,7 +193,7 @@ internal sealed class ForgeDeviceBody : IDeviceBody
SetP(OnP(s), On(OnP(s)) ? 0f : 1f); Refresh(); e.Handled = true;
};
Learn(dot, OnP(s));
- ToolTip.SetTip(dot, Loc.F("Stage {0} on / off", s + 1));
+ ToolTip.SetTip(dot, Loc.F("device.forge.stage_on_off", s + 1));
// Output trim: drag the dB up / down; double-click resets.
bool od = false; double oy = 0, ov = 0;
@@ -212,7 +212,7 @@ internal sealed class ForgeDeviceBody : IDeviceBody
outBox.PointerReleased += (_, e) => { if (od) { od = false; End(OutP(s)); e.Pointer.Capture(null); } };
outBox.PointerCaptureLost += (_, _) => { if (od) { od = false; End(OutP(s)); } };
Learn(outBox, OutP(s));
- ToolTip.SetTip(outBox, MenuKit.Keys(Loc.F("Stage {0} output, −12 … +12 dB — drag up / down, ⌥-click to type, double-click resets", s + 1)));
+ ToolTip.SetTip(outBox, MenuKit.Keys(Loc.F("device.forge.stage_output_12_12_db", s + 1)));
ValueEntry.Attach(outBox, ValueEntry.DeviceParam(engine, track, di, OutP(s), $"Stage {s + 1} output", OutF, Refresh), outTxt);
readouts.Add(() =>
@@ -242,9 +242,9 @@ internal sealed class ForgeDeviceBody : IDeviceBody
// CENTRE — Amount / Wet / Out over the transfer curve and the harmonics
// ======================================================================
var macros = new Grid { ColumnDefinitions = new ColumnDefinitions("13*,10*,10*"), ColumnSpacing = 8, VerticalAlignment = VerticalAlignment.Center };
- macros.Children.Add(Slider("AMOUNT", () => Amount, AmtF, Loc.T("Amount — 0 … +30 dB into the stages. Drag the curve up / down for the same"), 0, 0));
- macros.Children.Add(Col(Slider("WET", () => Wet, PctF, Loc.T("Wet — the forged signal against the dry one"), 0, 0), 1));
- macros.Children.Add(Col(Slider("OUT", () => Output, OutF, Loc.T("Output, −24 … +24 dB"), 0, 0, bipolar: true), 2));
+ macros.Children.Add(Slider("AMOUNT", () => Amount, AmtF, Loc.T("device.forge.amount_0_30_db_into"), 0, 0));
+ macros.Children.Add(Col(Slider("WET", () => Wet, PctF, Loc.T("device.forge.wet_the_forged_signal_against"), 0, 0), 1));
+ macros.Children.Add(Col(Slider("OUT", () => Output, OutF, Loc.T("device.forge.output_24_24_db"), 0, 0, bipolar: true), 2));
var transfer = new FgTransferView { Value = _ => P(Amount) };
transfer.GestureBegin += _ => Begin(Amount);
@@ -252,10 +252,10 @@ internal sealed class ForgeDeviceBody : IDeviceBody
transfer.Changed += (_, v) => { Raw(Amount, v); Refresh(); };
transfer.ResetRequested += _ => { Reset(Amount); Refresh(); };
Learn(transfer, Amount);
- ToolTip.SetTip(transfer, MenuKit.Keys(Loc.T("Input → output through the device (in M/S and Multi through the selected stage): each stage alone faint, the LFO-modulated curve dashed teal, the node where the input sits now. Drag up / down for Amount; ⌥-click to type, double-click resets.")));
+ ToolTip.SetTip(transfer, MenuKit.Keys(Loc.T("device.forge.input_output_through_the_device")));
ValueEntry.Attach(transfer, new ValueField("Amount", () => P(Amount), AmtF, v => Raw(Amount, v), () => Begin(Amount), () => End(Amount), engine.DeviceParamDefault(track, di, Amount)) { After = Refresh });
var harm = new FgHarmonicsView { Height = 50 };
- ToolTip.SetTip(harm, Loc.T("Harmonics 2 … 9 of a −6 dB sine through the curve: odd partials in full ink (hard, buzzy), even ones dimmer (warm, round), and the total harmonic distortion"));
+ ToolTip.SetTip(harm, Loc.T("device.forge.harmonics_2_9_of_a"));
var graphs = new DockPanel
{
Margin = new Thickness(5), LastChildFill = true,
@@ -284,7 +284,7 @@ internal sealed class ForgeDeviceBody : IDeviceBody
var typeSeg = Segments(ForgeMath.ChipNames, () => Array.IndexOf(ForgeMath.ChipAlgo, TypeI(sel)),
i => { SetP(TypeP(sel), ForgeMath.ChipAlgo[i] / 5f); Refresh(); }, out var typeSync, fill: true, padX: 1);
readouts.Add(typeSync);
- ToolTip.SetTip(typeSeg, Loc.T("The selected stage's type — Tube: soft, asymmetric, warm; Tape: soft and even; Diode: hard on one side; Fuzz: squared-off, dense; Fold: folds the peaks back, bright and metallic; Digital: a hard clip"));
+ ToolTip.SetTip(typeSeg, Loc.T("device.forge.the_selected_stages_type_tube"));
// Gauge knob on the selected stage's param.
Control StageKnob(Func<int> param, string label, Func<double, string> fmt, string tip)
@@ -310,16 +310,16 @@ internal sealed class ForgeDeviceBody : IDeviceBody
Rows = 1,
Children =
{
- StageKnob(() => BiasP(sel), "BIAS", BiasF, Loc.T("Bias — the stage's asymmetry, −100 … +100 %: pushes the curve off-centre, adding even harmonics")),
- StageKnob(() => ToneP(sel), "TONE", ToneF, Loc.T("Tone — a tilt after the stage, −12 … +12 dB around 800 Hz: darker or brighter distortion")),
- StageKnob(() => WidthSP(sel), "WIDTH", WidthF, Loc.T("Width — the stage's stereo image, 0 … 200 % (in M/S, stage 2's width scales the side)")),
+ StageKnob(() => BiasP(sel), "BIAS", BiasF, Loc.T("device.forge.bias_the_stages_asymmetry_100")),
+ StageKnob(() => ToneP(sel), "TONE", ToneF, Loc.T("device.forge.tone_a_tilt_after_the")),
+ StageKnob(() => WidthSP(sel), "WIDTH", WidthF, Loc.T("device.forge.width_the_stages_stereo_image")),
},
};
var syncSw = Switch("Sync", () => On(LfoSync), () => { SetP(LfoSync, On(LfoSync) ? 0f : 1f); Refresh(); }, out var syncSync);
readouts.Add(syncSync);
Learn(syncSw, LfoSync);
- ToolTip.SetTip(syncSw, Loc.T("Sync — the LFO rate as a note division locked to the song, or free in Hz"));
+ ToolTip.SetTip(syncSw, Loc.T("device.forge.sync_the_lfo_rate_as"));
var modHead = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
modHead.Children.Add(Caps("MODULATION", Teal)); modHead.Children.Add(Col(syncSw, 1));
var mods = new StackPanel
@@ -327,15 +327,15 @@ internal sealed class ForgeDeviceBody : IDeviceBody
Spacing = 2,
Children =
{
- Slider("LFO → DRIVE", () => LfoDrive, PctF, Loc.T("LFO → Drive — the LFO sweeps every stage's drive, up to ±30 %"), 50, 40, teal: true),
- Slider("ENV → TONE", () => EnvTone, PctF, Loc.T("Env → Tone — loud parts push the tone brighter"), 50, 40, teal: true),
- Slider("RATE", () => LfoRate, RateF, Loc.T("LFO rate — free 0.05 … 20 Hz, or with Sync a division from 2 bars to 1/64"), 50, 40, teal: true),
+ Slider("LFO → DRIVE", () => LfoDrive, PctF, Loc.T("device.forge.lfo_drive_the_lfo_sweeps"), 50, 40, teal: true),
+ Slider("ENV → TONE", () => EnvTone, PctF, Loc.T("device.forge.env_tone_loud_parts_push"), 50, 40, teal: true),
+ Slider("RATE", () => LfoRate, RateF, Loc.T("device.forge.lfo_rate_free_0_05"), 50, 40, teal: true),
},
};
var osSeg = Segments(OsNames, OsI, i => { SetP(OS, i / 3f); Refresh(); }, out var osSync, fill: true, padX: 2);
readouts.Add(osSync);
Learn(osSeg, OS);
- ToolTip.SetTip(osSeg, Loc.T("Oversampling — runs the stages at 2 / 4 / 8 × the rate so the harmonics above Nyquist don't fold back (minimum phase, no latency)"));
+ ToolTip.SetTip(osSeg, Loc.T("device.forge.oversampling_runs_the_stages_at"));
var osRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 6 };
osRow.Children.Add(Caps("OVERSAMPLE")); osRow.Children.Add(Col(osSeg, 1));
static Control Rule(Control c) => new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 4, 0, 0), Child = c };
@@ -356,16 +356,16 @@ internal sealed class ForgeDeviceBody : IDeviceBody
var statusRight = Mono("", 8, TextSecondary);
string StatusText()
{
- if (Sc(ForgeMath.S_Alias) > 0.5) return Loc.T("Digital / Fold without oversampling alias: switch on 2× or more");
+ if (Sc(ForgeMath.S_Alias) > 0.5) return Loc.T("device.forge.digital_fold_without_oversampling_alias");
int on = 0; for (int s = 0; s < 3; s++) if (On(OnP(s))) on++;
var parts = new List<string>
{
- Loc.F("{0} of 3 stages", on),
+ Loc.F("device.forge.of_3_stages", on),
new[] { "serial", "parallel", "mid/side", "multiband" }[RouteI()],
$"S{sel + 1} {ForgeMath.AlgoNames[TypeI(sel)]} {PctF(P(DriveP(sel)))}",
};
if (P(LfoDrive) > 0.005f) parts.Add($"LFO {PctF(P(LfoDrive))} {RateF(P(LfoRate))}");
- if (P(EnvTone) > 0.005f) parts.Add(Loc.F("env → tone {0}", PctF(P(EnvTone))));
+ if (P(EnvTone) > 0.005f) parts.Add(Loc.F("device.forge.env_tone", PctF(P(EnvTone))));
// The master offsets have no knob on the card (their per-stage successors do) — say so when set.
if (Math.Abs(P(Tone) - 0.5f) > 0.002f) parts.Add("master tone " + SgnI((P(Tone) - 0.5) * 200) + " %");
if (Math.Abs(P(Bias) - 0.5f) > 0.002f) parts.Add("master bias " + BiasF(P(Bias)));
@@ -382,7 +382,7 @@ internal sealed class ForgeDeviceBody : IDeviceBody
? NotaNum.F($"{sr / 1000:0.#} kHz · OS {(OsI() == 0 ? "off" : OsNames[OsI()])} · latency {Sc(ForgeMath.S_Latency):0} smp · CPU {Sc(ForgeMath.S_Cpu) * 100:0.0} %")
: "";
});
- ToolTip.SetTip(statusLeft, Loc.T("What the device is doing; the master Tone / Bias / Width offsets of older projects show here when set"));
+ ToolTip.SetTip(statusLeft, Loc.T("device.forge.what_the_device_is_doing"));
var statusGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 8 };
statusGrid.Children.Add(statusLeft);
statusGrid.Children.Add(Col(statusRight, 1));
@@ -399,7 +399,7 @@ internal sealed class ForgeDeviceBody : IDeviceBody
scN = engine.DeviceScope(track, di, scope, ForgeMath.kScope);
for (int s = 0; s < 3; s++) onArr[s] = On(OnP(s));
bool single = Single(), active = Active();
- string mainLbl = single ? Loc.F("stage {0} · {1}", sel + 1, ForgeMath.Role(RouteI(), sel).Split(' ')[0].ToLowerInvariant()) : "static";
+ string mainLbl = single ? Loc.F("device.forge.stage", sel + 1, ForgeMath.Role(RouteI(), sel).Split(' ')[0].ToLowerInvariant()) : "static";
transfer.Set(scope, scN, onArr, sel, single, active, P(LfoDrive) > 0.005f, mainLbl);
int set = single ? sel + 1 : 0;
int thdSlot = single ? ForgeMath.S_ThdS1 + sel : ForgeMath.S_ThdChain;
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/LensDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/LensDeviceBody.cs
index f8508d19..b46e22f0 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/LensDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/LensDeviceBody.cs
@@ -112,7 +112,7 @@ internal sealed class LensDeviceBody : IDeviceBody
static double KeyDb(double v) => -24 + 48 * Math.Clamp(v, 0, 1);
bool scOk = engine.DeviceAcceptsSidechain(track, di);
int KeySrc() => scOk ? engine.DeviceSidechainSource(track, di) : -1;
- string SrcName(int id) { string n = TrackNames.Of(engine, id); return n == "—" ? Loc.T("None") : n; }
+ string SrcName(int id) { string n = TrackNames.Of(engine, id); return n == "—" ? Loc.T("common.none") : n; }
static string Ms(double sec) => sec >= 1 ? Inv($"{sec:0.00} s") : sec >= 0.001 ? Inv($"{sec * 1000:0.00} ms") : Inv($"{sec * 1e6:0} µs");
static string Sec(double s) => s >= 1 ? Inv($"{s:0.0} s") : Inv($"{s * 1000:0} ms");
@@ -267,9 +267,9 @@ internal sealed class LensDeviceBody : IDeviceBody
Children = { Seg(TrigModeP, new[] { "Auto", "Normal", "Single" }), Seg(TrigEdgeP, new[] { "↑", "↓" }) },
};
var span = Seg(SpanP, SpanNames);
- ToolTip.SetTip(span, Loc.T("Span — how much of the song the scope shows, from a quarter beat to four bars"));
+ ToolTip.SetTip(span, Loc.T("device.lens.span_how_much_of_the"));
var sync = Toggle(SyncP, "Sync");
- ToolTip.SetTip(sync, Loc.T("Sync — line the scope up with the song's beats and bars"));
+ ToolTip.SetTip(sync, Loc.T("device.lens.sync_line_the_scope_up"));
var caps = Caps("TRIG");
readouts.Add(() =>
{
@@ -289,7 +289,7 @@ internal sealed class LensDeviceBody : IDeviceBody
var trigK = K(TrigLevelP, "Trig Lvl", v => Inv($"{(v - 0.5) * 2:+0.00;−0.00;0.00}"), 34, 48, TealC);
var holdK = K(HoldoffP, "Holdoff", v => Inv($"{v * 200:0} ms"), 34, 48, TealC);
var keyK = K(KeyGainP, "Key Gain", v => Inv($"{KeyDb(v):+0.#;−0.#;0} dB"), 34, 48, TealC);
- ToolTip.SetTip(keyK, Loc.T("Key gain — scales only the key's trace, for the eye (the sound is untouched)"));
+ ToolTip.SetTip(keyK, Loc.T("device.lens.key_gain_scales_only_the"));
readouts.Add(() =>
{
bool on = On(SyncP);
@@ -312,22 +312,22 @@ internal sealed class LensDeviceBody : IDeviceBody
wfNote.Ctl));
// ---- right panel --------------------------------------------------------------
- var cursorBox = ReadBox("CURSOR", "—", Loc.T("move over the graph"));
+ var cursorBox = ReadBox("CURSOR", "—", Loc.T("device.lens.move_over_the_graph"));
var captureBox = ReadBox("CAPTURE");
var measureBox = ReadBox("A → B");
- var wfCursorBox = ReadBox("CURSOR", "—", Loc.T("move over the graph"));
+ var wfCursorBox = ReadBox("CURSOR", "—", Loc.T("device.lens.move_over_the_graph"));
spectrum.CursorMoved += () =>
{
double hz = spectrum.CursorHz;
- if (hz <= 0) { cursorBox.A.Text = "—"; cursorBox.B.Text = Loc.T("move over the graph"); return; }
+ if (hz <= 0) { cursorBox.A.Text = "—"; cursorBox.B.Text = Loc.T("device.lens.move_over_the_graph"); return; }
cursorBox.A.Text = Inv($"{Hz(hz)} · {LensInk.Note(hz)}");
- cursorBox.B.Text = Loc.F("{0:0.0} dB · bin {1:0}", spectrum.CursorDb, (Sc(M_BinHz) > 0 ? hz / Sc(M_BinHz) : 0));
+ cursorBox.B.Text = Loc.F("device.lens.db_bin", spectrum.CursorDb, (Sc(M_BinHz) > 0 ? hz / Sc(M_BinHz) : 0));
};
waterfall.CursorMoved += () =>
{
double hz = waterfall.CursorHz;
- if (hz <= 0) { wfCursorBox.A.Text = "—"; wfCursorBox.B.Text = Loc.T("move over the graph"); return; }
+ if (hz <= 0) { wfCursorBox.A.Text = "—"; wfCursorBox.B.Text = Loc.T("device.lens.move_over_the_graph"); return; }
wfCursorBox.A.Text = Inv($"{Hz(hz)} · {LensInk.Note(hz)}");
wfCursorBox.B.Text = Inv($"−{waterfall.CursorAgeSec:0.0} s");
};
@@ -346,7 +346,7 @@ internal sealed class LensDeviceBody : IDeviceBody
Row("RATE", RateP, v => Inv($"{10 + v * 50:0} fps")),
cursorBox.Box,
Toggle(PeakHoldP, "Peak hold"),
- Toggle(MidSideP, Loc.T("Mid / Side")));
+ Toggle(MidSideP, Loc.T("device.lens.mid_side")));
// The sidechain key (specs/050): None, or any other track's post-FX audio.
Control KeyRow()
@@ -355,7 +355,7 @@ internal sealed class LensDeviceBody : IDeviceBody
readouts.Add(() =>
{
int src = KeySrc();
- name.Text = !scOk ? Loc.T("n/a in a rack") : src < 0 ? "no key" : SrcName(src);
+ name.Text = !scOk ? Loc.T("device.lens.n_a_in_a_rack") : src < 0 ? "no key" : SrcName(src);
name.Foreground = src >= 0 ? TxtC : Txt2;
});
var box = new Border
@@ -364,7 +364,7 @@ internal sealed class LensDeviceBody : IDeviceBody
Cursor = new Cursor(StandardCursorType.Hand), IsEnabled = scOk,
Child = new DockPanel { Children = { Docked(new Glyph(GlyphKind.ChevronDown, 8) { Foreground = MutedC, Margin = new Thickness(5, 0, 0, 0) }, Dock.Right), name } },
};
- ToolTip.SetTip(box, Loc.T("Key — draw another track's audio over this one, in teal"));
+ ToolTip.SetTip(box, Loc.T("device.lens.key_draw_another_tracks_audio"));
box.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(box).Properties.IsLeftButtonPressed || !scOk) return;
@@ -376,7 +376,7 @@ internal sealed class LensDeviceBody : IDeviceBody
mi.Click += (_, _) => { engine.SetDeviceSidechainSource(track, di, id); ctx.NotifyChanged(); foreach (var a in readouts) a(); };
fly.Items.Add(mi);
}
- Item(Loc.T("None"), -1);
+ Item(Loc.T("common.none"), -1);
fly.Items.Add(new Separator());
for (int i = 0; i < engine.TrackCount; i++)
if (engine.TryGetTrackInfo(i, out var ti) && ti.Id != track) Item(SrcName(ti.Id), ti.Id);
@@ -386,7 +386,7 @@ internal sealed class LensDeviceBody : IDeviceBody
var show = Switch("", () => On(KeyShowP), () => SetP(KeyShowP, On(KeyShowP) ? 0f : 1f), out var showSync);
readouts.Add(showSync);
Learn(show, KeyShowP);
- ToolTip.SetTip(show, Loc.T("Show the key's trace"));
+ ToolTip.SetTip(show, Loc.T("device.lens.show_the_keys_trace"));
show.Margin = new Thickness(5, 0, 0, 0);
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("48,*,Auto"), VerticalAlignment = VerticalAlignment.Center };
g.Children.Add(Caps("KEY")); g.Children.Add(Col(box, 1)); g.Children.Add(Col(show, 2));
@@ -419,11 +419,11 @@ internal sealed class LensDeviceBody : IDeviceBody
Orientation = Orientation.Horizontal, Spacing = 5,
Children =
{
- new Border { Width = 82, Child = Button("Re-arm", Loc.T("Arm the next Single capture"), () => { engine.DeviceAction(track, di, A_Rearm, 0, 0f); foreach (var a in readouts) a(); }) },
- new Border { Width = 82, Child = Button(Loc.T("Export WAV"), Loc.T("Write the captured scope window to a WAV file"), ExportWav) },
+ new Border { Width = 82, Child = Button("Re-arm", Loc.T("device.lens.arm_the_next_single_capture"), () => { engine.DeviceAction(track, di, A_Rearm, 0, 0f); foreach (var a in readouts) a(); }) },
+ new Border { Width = 82, Child = Button(Loc.T("device.lens.export_wav"), Loc.T("device.lens.write_the_captured_scope_window"), ExportWav) },
},
},
- Toggle(CursorSnapP, Loc.T("Snap to peaks")),
+ Toggle(CursorSnapP, Loc.T("device.lens.snap_to_peaks")),
Toggle(CursorsP, "Cursors"));
Control WaterfallAnalyze() => Stack(
@@ -440,7 +440,7 @@ internal sealed class LensDeviceBody : IDeviceBody
Row("TOP", ScaleTopP, v => Inv($"{24 - v * 60:0} dB")),
Row("RANGE", ScaleRangeP, v => Inv($"{30 + v * 90:0} dB")),
Row("RATE", RateP, v => Inv($"{10 + v * 50:0} fps")),
- Toggle(MidSideP, Loc.T("Mid / Side")),
+ Toggle(MidSideP, Loc.T("device.lens.mid_side")),
Toggle(LogFreqP, "Log frequency"),
Toggle(NoteGridP, "Note grid"),
Toggle(PeakHoldP, "Peak hold"));
@@ -529,7 +529,7 @@ internal sealed class LensDeviceBody : IDeviceBody
var freezeToggle = Switch("Freeze", () => On(FreezeP), () => SetP(FreezeP, On(FreezeP) ? 0f : 1f), out var freezeSync);
readouts.Add(freezeSync);
Learn(freezeToggle, FreezeP);
- ToolTip.SetTip(freezeToggle, Loc.T("Freeze — stop capturing and hold what is on screen"));
+ ToolTip.SetTip(freezeToggle, Loc.T("device.lens.freeze_stop_capturing_and_hold"));
var headNote = Mono("", 7, MutedC);
var extras = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center, Children = { freezeToggle, headNote } };
@@ -542,7 +542,7 @@ internal sealed class LensDeviceBody : IDeviceBody
Background = Brushes.Transparent, Padding = new Thickness(3), Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center,
Child = new Glyph(GlyphKind.PopOut, 10) { Foreground = MutedC },
};
- ToolTip.SetTip(pop, Loc.T("Open Lens in its own window"));
+ ToolTip.SetTip(pop, Loc.T("device.lens.open_lens_in_its_own"));
pop.PointerReleased += (_, e) => { LensWindow.Open(ctx, di, pop); e.Handled = true; };
pop.PointerPressed += (_, e) => e.Handled = true;
extras.Children.Add(pop);
@@ -639,7 +639,7 @@ internal sealed class LensDeviceBody : IDeviceBody
if (n <= 0) return;
var file = await top.PickSaveFileAsync(new FilePickerSaveOptions
{
- Title = Loc.T("Export the Lens capture to WAV"),
+ Title = Loc.T("device.lens.export_the_lens_capture_to"),
DefaultExtension = "wav",
SuggestedFileName = "Nota Lens capture.wav",
FileTypeChoices = new[] { new FilePickerFileType("WAV audio") { Patterns = new[] { "*.wav" } } },
@@ -743,18 +743,18 @@ internal sealed class LensDeviceBody : IDeviceBody
? (data.Held ? "Held" : data.SyncOn ? (synced ? "Sync" : "Free") : data.TrigOk ? "Trig’d" : "Free")
: centreTab == 2 ? Inv($"{LensData.WfBins} bins") : Inv($"FFT {fftN}");
- specInfo.Text = Loc.F("window {0:0} ms · slope {1:0.0} dB/oct", Sc(M_FftMs), P(TiltP) * 9);
+ specInfo.Text = Loc.F("device.lens.window_ms_slope_db_oct", Sc(M_FftMs), P(TiltP) * 9);
scopeInfo.Text = data.SyncOn
? Inv($"{LensScopeView.SpanName(data.Sync[LensData.S_SpanBeats], data.Sync[LensData.S_BeatsPerBar])} · {data.Sync[LensData.S_Bpm]:0.#} BPM{(synced ? "" : " · stopped")}")
- : Loc.F("level {0:0.00} · holdoff {1:0} ms", (P(TrigLevelP) - 0.5) * 2, P(HoldoffP) * 200);
+ : Loc.F("device.lens.level_holdoff_ms", (P(TrigLevelP) - 0.5) * 2, P(HoldoffP) * 200);
wfInfo.Text = Inv($"floor {-120 + P(WfFloorP) * 80:0} dB · {(On(LogFreqP) ? "log" : "linear")} freq");
specNote.A.Text = Inv($"peak {Sc(M_PeakDb):0.0} dB @ {Hz(Sc(M_PeakHz))}");
- specNote.B.Text = Loc.F("crest {0:0.0} dB · LUFS {1:0.0}", Sc(M_CrestDb), Sc(M_Lufs));
- scopeNote.A.Text = Sc(M_PeriodMs) > 0 ? Loc.F("period {0:0.000} ms · {1:0.0} Hz", Sc(M_PeriodMs), Sc(M_FreqHz)) : "period —";
- scopeNote.B.Text = Loc.F("Vpp {0:0.000} · RMS {1:0.000}", Sc(M_Vpp), Sc(M_Vrms));
- wfNote.A.Text = Loc.F("row {0:0} ms · {1} bins", WfSpan() / LensData.WfRows * 1000, LensData.WfBins);
- wfNote.B.Text = Loc.F("peak {0} · {1:0.0} dB", Hz(Sc(M_PeakHz)), Sc(M_PeakDb));
+ specNote.B.Text = Loc.F("device.lens.crest_db_lufs", Sc(M_CrestDb), Sc(M_Lufs));
+ scopeNote.A.Text = Sc(M_PeriodMs) > 0 ? Loc.F("device.lens.period_ms_hz", Sc(M_PeriodMs), Sc(M_FreqHz)) : "period —";
+ scopeNote.B.Text = Loc.F("device.lens.vpp_rms", Sc(M_Vpp), Sc(M_Vrms));
+ wfNote.A.Text = Loc.F("device.lens.row_ms_bins", WfSpan() / LensData.WfRows * 1000, LensData.WfBins);
+ wfNote.B.Text = Loc.F("device.lens.peak_db", Hz(Sc(M_PeakHz)), Sc(M_PeakDb));
captureBox.A.Text = data.Held ? "held" : data.TrigOk ? "stable" : "free-run";
captureBox.B.Text = Inv($"holdoff {P(HoldoffP) * 200:0} ms · edge {(On(TrigEdgeP) ? "↓" : "↑")}");
@@ -767,7 +767,7 @@ internal sealed class LensDeviceBody : IDeviceBody
{
1 when data.SyncOn => Inv($"Scope · sync {LensScopeView.SpanName(data.Sync[LensData.S_SpanBeats], data.Sync[LensData.S_BeatsPerBar])} · {VoltDiv():0.00}/div{(data.KeyOn ? " · key " + data.KeyName : "")}"),
1 => Inv($"Scope · {Ms(TimeDiv())}/div · {VoltDiv():0.00}/div · trig {(On(TrigEdgeP) ? "↓" : "↑")} {(P(TrigLevelP) - 0.5) * 2:0.00} {new[] { "auto", "normal", "single" }[Sel(TrigModeP, 3)]}{(On(PersistP) ? Inv($" · persist {Sec(PersistS())}") : "")}"),
- 2 => Loc.F("Waterfall · {0} bins · {1} · overlap {2:0.#} % · window {3:0} s · floor {4:0} dB", LensData.WfBins, winName, Overlaps[Sel(WfOverlapP, 4)], WfSpan(), -120 + P(WfFloorP) * 80),
+ 2 => Loc.F("device.lens.waterfall_bins_overlap_window_s", LensData.WfBins, winName, Overlaps[Sel(WfOverlapP, 4)], WfSpan(), -120 + P(WfFloorP) * 80),
_ => Inv($"Spectrum · FFT {fftN} · {winName} · avg {Avg()} · slope {P(TiltP) * 9:0.0} dB/oct{(On(MidSideP) ? " · Mid/Side" : "")}"),
};
statusLeft.Foreground = On(FreezeP) ? AmberLit : Txt2;
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/PhaserDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/PhaserDeviceBody.cs
index 8a2a3c43..e2a833f6 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/PhaserDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/PhaserDeviceBody.cs
@@ -141,12 +141,12 @@ internal sealed class PhaserDeviceBody : IDeviceBody
syncSeg.Width = 76;
readouts.Add(syncSync);
Learn(syncSeg, Sync);
- ToolTip.SetTip(syncSeg, Loc.T("Hz runs the LFO free; Sync takes its rate from the tempo and locks it to the bar while the transport plays"));
+ ToolTip.SetTip(syncSeg, Loc.T("common.hz_runs_the_lfo_free"));
var waveSeg = Segments(PhaserMath.Waves, WaveI, i => { SetP(Waveform, i / 2.0); RefreshAll(); }, out var waveSync, fill: true, padX: 0);
readouts.Add(waveSync);
Learn(waveSeg, Waveform);
- ToolTip.SetTip(waveSeg, Loc.T("The LFO shape that sweeps the stages: Sine glides, Tri sweeps evenly, Saw rises and drops back"));
+ ToolTip.SetTip(waveSeg, Loc.T("device.phaser.the_lfo_shape_that_sweeps"));
var big = Mono("", 26, TextPrimary); big.FontWeight = FontWeight.Bold; big.LineHeight = 28;
var bigSub = new TextBlock { FontSize = 8, Foreground = TextSecondary };
@@ -169,15 +169,15 @@ internal sealed class PhaserDeviceBody : IDeviceBody
big.Foreground = On() ? TextPrimary : NotaPalette.TextAxis;
});
var bigBlock = new StackPanel { Spacing = 1, VerticalAlignment = VerticalAlignment.Center, Children = { big, bigSub, period } };
- ToolTip.SetTip(bigBlock, Loc.T("The LFO rate: in Hz, or the note value it takes from the tempo"));
+ ToolTip.SetTip(bigBlock, Loc.T("common.the_lfo_rate_in_hz"));
- var rateRow = Slider("RATE", Rate, v => HzF(PhaserMath.FreeHz(v)) + " Hz", Loc.T("Rate — the free LFO rate, 0.02 … 8 Hz"), 38, 46);
+ var rateRow = Slider("RATE", Rate, v => HzF(PhaserMath.FreeHz(v)) + " Hz", Loc.T("common.rate_the_free_lfo_rate"), 38, 46);
var divRow = Slider("RATE", Division, v => PhaserMath.DivNames[PhaserMath.DivIndex(v)],
- Loc.T("Rate — the note value of one LFO cycle, 4/1 … 1/16 with dotted (D) and triplet (T) values"), 38, 46,
+ Loc.T("device.phaser.rate_the_note_value_of"), 38, 46,
snap: v => PhaserMath.DivNorm(PhaserMath.DivIndex(v)));
readouts.Add(() => { rateRow.IsVisible = !Synced(); divRow.IsVisible = Synced(); });
var stereoRow = Slider("STEREO", Stereo, v => NotaNum.F($"{v * 180:0}°"),
- Loc.T("Stereo — the right LFO against the left: 0° sweeps both together, 90° spreads them, 180° moves them opposite"), 38, 46,
+ Loc.T("device.phaser.stereo_the_right_lfo_against"), 38, 46,
modulation: true, snap: v => Math.Round(v * 180) / 180);
var leftBody = new Grid { RowDefinitions = new RowDefinitions("Auto,*,Auto,Auto"), RowSpacing = 6, Margin = new Thickness(8, 6) };
@@ -203,11 +203,11 @@ internal sealed class PhaserDeviceBody : IDeviceBody
response.Changed += (c, f) => { Raw(Center, c); Raw(Feedback, f); RefreshAll(); };
response.ResetRequested += () => { Reset(Center); Reset(Feedback); RefreshAll(); };
Learn(response, Center);
- ToolTip.SetTip(response, MenuKit.Keys(Loc.T("The notches the stages cut into the spectrum, L neutral and R teal, with the corner dashed and each notch ticked on top. Drag left / right to move Center, up / down for Feedback; ⌥-click types, double-click resets both.")));
+ ToolTip.SetTip(response, MenuKit.Keys(Loc.T("device.phaser.the_notches_the_stages_cut")));
ValueEntry.AttachAll(response, ValueEntry.DeviceParam(engine, track, di, Center, "Center", v => PhaserMath.HzF(PhaserMath.CenterHz(v)) + " Hz", RefreshAll), ValueEntry.DeviceParam(engine, track, di, Feedback, "Feedback", v => FbF(PhaserMath.Fb(v)), RefreshAll));
var sweep = new PhaserSweepView { Margin = new Thickness(0, 4, 0, 0) };
- ToolTip.SetTip(sweep, Loc.T("The corner frequency of both channels over two LFO cycles (20 Hz … 20 kHz), and where each is now"));
+ ToolTip.SetTip(sweep, Loc.T("device.phaser.the_corner_frequency_of_both"));
var centreBody = new DockPanel { LastChildFill = true, Margin = new Thickness(5), Children = { Docked(sweep, Dock.Bottom), response } };
var centre = Island(HeadRow(Caps("ALL-PASS RESPONSE"), legend), centreBody);
centre.Margin = new Thickness(5, 0);
@@ -223,23 +223,23 @@ internal sealed class PhaserDeviceBody : IDeviceBody
modeWord.Text = m;
modeWord.Foreground = m == "resonant" ? TextPrimary : m == "negative" ? NotaPalette.TealBright : TextSecondary;
});
- ToolTip.SetTip(modeWord, Loc.T("What the feedback makes: positive sharpens the peaks, negative moves and widens the notches, past 85 % the phaser whistles"));
+ ToolTip.SetTip(modeWord, Loc.T("device.phaser.what_the_feedback_makes_positive"));
var stageSeg = Segments(PhaserMath.StageCounts.Select(n => n.ToString()).ToArray(), () => PhaserMath.StageIndex(P(Stages)),
i => { SetP(Stages, i / (double)(PhaserMath.StageCounts.Length - 1)); RefreshAll(); }, out var stageSync, fill: true, padX: 0);
foreach (var tb in stageSeg.GetLogicalDescendants().OfType<TextBlock>()) tb.BindResource(TextBlock.FontFamilyProperty, "Font.Mono");
readouts.Add(stageSync);
Learn(stageSeg, Stages);
- ToolTip.SetTip(stageSeg, Loc.T("All-pass stages: every two cut one notch — 2 is a gentle swirl, 12 a deep, dense sweep"));
+ ToolTip.SetTip(stageSeg, Loc.T("device.phaser.all_pass_stages_every_two"));
var centerRow = Slider("CENTER", Center, v => PhaserMath.HzF(PhaserMath.CenterHz(v)) + " Hz",
- Loc.T("Center — the middle of the sweep, 50 Hz … 5 kHz: higher moves the notches up"));
+ Loc.T("device.phaser.center_the_middle_of_the"));
var depthRow = Slider("DEPTH", Depth, v => NotaNum.F($"±{v * PhaserMath.DepthOct:0.0} oct"),
- Loc.T("Depth — how far the LFO swings the stages around Center, up to ±3 octaves"));
+ Loc.T("device.phaser.depth_how_far_the_lfo"));
var fbRow = Slider("FEEDBACK", Feedback, v => FbF(PhaserMath.Fb(v)),
- Loc.T("Feedback — the chain's output fed back in, ±95 %: positive sharpens the peaks, negative moves and widens the notches"), modulation: true, bipolar: true,
+ Loc.T("device.phaser.feedback_the_chains_output_fed"), modulation: true, bipolar: true,
snap: v => PhaserMath.FbNorm(Math.Round(PhaserMath.Fb(v) * 100) / 100));
- var mixRow = Slider("MIX", Mix, v => PctF(v), Loc.T("Mix — 50 % gives the deepest notches; 100 % is the phase-shifted signal alone"));
+ var mixRow = Slider("MIX", Mix, v => PctF(v), Loc.T("device.phaser.mix_50_gives_the_deepest"));
double PctAxis(double f) => Math.Clamp(Math.Log(Math.Max(f, 1e-3) / 20) / Math.Log(1000), 0, 1);
Control ReadRow(string label, FlangerBar bar, TextBlock value, string tip)
@@ -263,8 +263,8 @@ internal sealed class PhaserDeviceBody : IDeviceBody
{
Spacing = 4, Children =
{
- ReadRow("SWEEP", sweepBar, sweepVal, Loc.T("The range the corner sweeps (20 Hz … 20 kHz on the bar), and the first notch now")),
- ReadRow("NULL", nullBar, nullVal, Loc.T("How deep the notches cut, dB (0 … −36 on the bar)")),
+ ReadRow("SWEEP", sweepBar, sweepVal, Loc.T("device.phaser.the_range_the_corner_sweeps")),
+ ReadRow("NULL", nullBar, nullVal, Loc.T("device.phaser.how_deep_the_notches_cut")),
},
},
};
@@ -289,14 +289,14 @@ internal sealed class PhaserDeviceBody : IDeviceBody
double fb = Fb(), afb = Math.Abs(fb);
bool warn = false;
string foot;
- if (!On()) foot = Loc.T("Phaser bypassed: the signal passes unchanged");
- else if (P(Mix) < 0.01f) { foot = Loc.T("Mix at zero: only the dry signal is heard"); warn = true; }
+ if (!On()) foot = Loc.T("device.phaser.phaser_bypassed_the_signal_passes");
+ else if (P(Mix) < 0.01f) { foot = Loc.T("common.mix_at_zero_only_the"); warn = true; }
else if (afb >= 0.85)
{
foot = "Feedback " + FbF(fb) + NotaNum.F($": peaks up to +{PhaserMath.PeakDb(P(Mix), fb):0.0} dB, the phaser whistles");
warn = true;
}
- else if (P(Depth) < 0.01f) foot = Loc.T("Depth at zero: the notches stand still");
+ else if (P(Depth) < 0.01f) foot = Loc.T("device.phaser.depth_at_zero_the_notches");
else
{
int n = StagesN();
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/PrismDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/PrismDeviceBody.cs
index 4b988962..ed0ef9bb 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/PrismDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/PrismDeviceBody.cs
@@ -245,8 +245,8 @@ internal sealed class PrismDeviceBody : IDeviceBody
readouts.Add(() => { amtTxt.Text = Pct(P(Amount)); outTxt.Text = DbShort((P(Output) - 0.5) * 48); });
var globTitle = Caps("GLOBAL"); globTitle.HorizontalAlignment = HorizontalAlignment.Center;
var faders = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto"), ColumnSpacing = 9, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 4, 0, 3) };
- faders.Children.Add(Fader(Amount, "AMOUNT", Loc.T("Amount — scales every band's compression and expansion (0\u2009% = none). Double-click: 100\u2009%")));
- faders.Children.Add(Col(Fader(Output, "OUT", Loc.T("Output gain ±24\u2009dB — double-click: 0\u2009dB")), 1));
+ faders.Children.Add(Fader(Amount, "AMOUNT", Loc.T("device.prism.amount_scales_every_bands_compression")));
+ faders.Children.Add(Col(Fader(Output, "OUT", Loc.T("device.prism.output_gain_24_db_double")), 1));
var globCol = new RuleSection { Width = 56, Padding = new Thickness(0, 5, 0, 4),
Child = new DockPanel { Children = { Docked(globTitle, Dock.Top), Docked(outTxt, Dock.Bottom), Docked(amtTxt, Dock.Bottom), faders } } };
DockPanel.SetDock(globCol, Dock.Left);
@@ -261,14 +261,14 @@ internal sealed class PrismDeviceBody : IDeviceBody
spec.DragStarted += h => Begin(h == 0 ? XoverLow : XoverHigh);
spec.DragEnded += h => End(h == 0 ? XoverLow : XoverHigh);
spec.BandClicked += SelectBand;
- ValueEntry.AttachHandles(spec, [PF(XoverLow, Loc.T("Low / mid crossover"), v => HzF(XHz(v)))], [PF(XoverHigh, Loc.T("Mid / high crossover"), v => HzF(XHz(v)))]);
- ToolTip.SetTip(spec, MenuKit.Keys(Loc.T("Input spectrum (fill) and output (line). Drag a crossover line to move it; ⌥-click to type, double-click resets. Click a band to select it.")));
+ ValueEntry.AttachHandles(spec, [PF(XoverLow, Loc.T("device.prism.low_mid_crossover"), v => HzF(XHz(v)))], [PF(XoverHigh, Loc.T("device.prism.mid_high_crossover"), v => HzF(XHz(v)))]);
+ ToolTip.SetTip(spec, MenuKit.Keys(Loc.T("device.prism.input_spectrum_fill_and_output")));
readouts.Add(() => { spec.Set(P(XoverLow), P(XoverHigh), BandCount(), band, Sc(S_SampleRate)); spec.Tick(); });
const string cols = "50,*,*,40,40";
var head = new Grid { ColumnDefinitions = new ColumnDefinitions(cols), Height = 11 };
- var hA = Caps(Loc.T("ABOVE — COMPRESS"), DimC); hA.HorizontalAlignment = HorizontalAlignment.Center;
- var hB = Caps(Loc.T("BELOW — EXPAND"), DimC); hB.HorizontalAlignment = HorizontalAlignment.Center;
+ var hA = Caps(Loc.T("device.prism.above_compress_caps"), DimC); hA.HorizontalAlignment = HorizontalAlignment.Center;
+ var hB = Caps(Loc.T("device.prism.below_expand_caps"), DimC); hB.HorizontalAlignment = HorizontalAlignment.Center;
var hG = Caps("GAIN", DimC); hG.HorizontalAlignment = HorizontalAlignment.Right;
var hR = Acr("GR", DimC); hR.HorizontalAlignment = HorizontalAlignment.Right;
head.Children.Add(Caps("BAND", DimC)); head.Children.Add(Col(hA, 1)); head.Children.Add(Col(hB, 2)); head.Children.Add(Col(hG, 3)); head.Children.Add(Col(hR, 4));
@@ -281,7 +281,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
var above = Bar(BP(bb, AboveThresh), v => Inv($"{ThrA(v):0;−0} · {RatioAShort(P(BP(bb, AboveRatio)))}"), () => PrismInk.Band[bb], null, 52,
() => band == bb ? PrismInk.BandLit[bb] : TxtC);
above.Margin = new Thickness(0, 0, 8, 0);
- ToolTip.SetTip(above, Loc.T("Compression threshold · ratio (set the ratio in Band detail)"));
+ ToolTip.SetTip(above, Loc.T("device.prism.compression_threshold_ratio_set_the"));
g.Children.Add(Col(above, 1));
bool BelowOff() => !On(BP(bb, BelowOn));
var below = Bar(BP(bb, BelowThresh), v => BelowOff() ? "off" : Inv($"{ThrB(v):0;−0} · {RatioBShort(P(BP(bb, BelowRatio)))}"), () => PrismInk.Band[bb], BelowOff, 52);
@@ -290,10 +290,10 @@ internal sealed class PrismDeviceBody : IDeviceBody
var belowVal = (TextBlock)((Grid)below).Children[1];
belowVal.Cursor = new Cursor(StandardCursorType.Hand);
belowVal.PointerPressed += (_, e) => { if (!e.GetCurrentPoint(belowVal).Properties.IsLeftButtonPressed) return; SetP(BP(bb, BelowOn), BelowOff() ? 1f : 0f); e.Handled = true; };
- ToolTip.SetTip(below, Loc.T("Expansion / upward-compression threshold · ratio — click the readout to switch it on or off"));
+ ToolTip.SetTip(below, Loc.T("device.prism.expansion_upward_compression_threshold_ratio"));
g.Children.Add(Col(below, 2));
var gain = DragVal(BP(bb, Gain), v => DbShort((v - 0.5) * 48), () => Math.Abs(P(BP(bb, Gain)) - 0.5f) < 0.001f ? Txt2 : TxtC);
- ToolTip.SetTip(gain, Loc.T("Band gain ±24\u2009dB — drag up / down, double-click resets"));
+ ToolTip.SetTip(gain, Loc.T("device.prism.band_gain_24_db_drag"));
g.Children.Add(Col(gain, 3));
var grTrack = new Border { Width = 32, Height = 4, CornerRadius = NotaRadius.Clip, Background = Inset, HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Center, ClipToBounds = true };
var grFill = new Border { Background = PrismInk.Band[bb], HorizontalAlignment = HorizontalAlignment.Right };
@@ -337,7 +337,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
int t = BP(b, h == 1 ? AboveThresh : BelowThresh), r = BP(b, h == 1 ? AboveRatio : BelowRatio);
SetP(t, Def(t)); SetP(r, Def(r));
};
- ToolTip.SetTip(tr, MenuKit.Keys(Loc.T("Drag a dot: ← → threshold, ↑ ↓ ratio (down = more). The bright dot is compression above, the grey one expansion below. Double-click a dot resets it. · ⌥-click to type")));
+ ToolTip.SetTip(tr, MenuKit.Keys(Loc.T("device.prism.drag_a_dot_threshold_ratio")));
readouts.Add(() =>
{
if (!tr.IsEffectivelyVisible) return;
@@ -353,7 +353,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
Child = new DockPanel { Children = { Docked(trCap, Dock.Top), Docked(kneeRow, Dock.Bottom), new Border { Margin = new Thickness(0, 4, 0, 0), Child = tr } } } };
// ABOVE — compression
- var aCap = Caps(Loc.T("ABOVE — COMPRESSION"), PrismInk.BandLit[b]);
+ var aCap = Caps(Loc.T("device.prism.above_compression_caps"), PrismInk.BandLit[b]);
var aGr = Mono("", 7, Txt2); aGr.HorizontalAlignment = HorizontalAlignment.Right;
readouts.Add(() => { double gr = Sc(S_Gr0 + b); aGr.Text = gr > 0.05 ? Inv($"GR −{gr:0.0}\u2009dB") : "GR 0.0\u2009dB"; });
var aHead = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), Height = 11 };
@@ -367,8 +367,8 @@ internal sealed class PrismDeviceBody : IDeviceBody
var aSec = new DockPanel { Children = { Docked(aHead, Dock.Top), aKnobs } };
// BELOW — expansion / upward compression
- var bCap = Caps(Loc.T("BELOW — EXPANSION"));
- readouts.Add(() => { bool up = RatioB(P(BP(b, BelowRatio))) < 0.99; bCap.Text = up ? Loc.T("Below — upward compression") : Loc.T("Below — expansion"); bCap.Foreground = On(BP(b, BelowOn)) ? Txt2 : MutedC; });
+ var bCap = Caps(Loc.T("device.prism.below_expansion_caps"));
+ readouts.Add(() => { bool up = RatioB(P(BP(b, BelowRatio))) < 0.99; bCap.Text = up ? Loc.T("device.prism.below_upward_compression") : Loc.T("device.prism.below_expansion"); bCap.Foreground = On(BP(b, BelowOn)) ? Txt2 : MutedC; });
var bToggle = Toggle(BP(b, BelowOn), "", () => On(BP(b, BelowOn)) ? "on" : "off");
var bHead = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), Height = 11 };
bHead.Children.Add(bCap); bHead.Children.Add(Col(bToggle, 1));
@@ -379,7 +379,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
bKnobs.Children.Add(K(BP(b, BelowRelease), "RELEASE", RelF, 36, 52, Mauve));
bKnobs.Children.Add(K(BP(b, Floor), "FLOOR", _ => FloorF(b), 36, 52, Mauve));
readouts.Add(() => Inactive.Set(bKnobs, !On(BP(b, BelowOn)), interactive: true));
- ToolTip.SetTip(bKnobs, Loc.T("Ratio above 1 : 1 expands (quiet parts get quieter); below 1 : 1 (↑) compresses upward (quiet parts are lifted). Floor limits either to ± that many dB."));
+ ToolTip.SetTip(bKnobs, Loc.T("device.prism.ratio_above_1_1_expands"));
var bSec = Divider(new DockPanel { Children = { Docked(bHead, Dock.Top), bKnobs } }, 4);
var right = new Grid { RowDefinitions = new RowDefinitions("*,*"), Margin = new Thickness(7, 5, 7, 3) };
@@ -412,7 +412,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
int m = engine.DeviceLayerWave(track, di, 3 + band * 2, tDet, TraceLen);
trace.Set(tIn, tDet, Math.Min(n, m), band, ThrA(P(BP(band, AboveThresh))), On(BP(band, BelowOn)), ThrB(P(BP(band, BelowThresh))));
});
- ToolTip.SetTip(trace, Loc.T("The selected band's input peaks (grey) and what its compressor's detector makes of them (the last ~1.5\u2009s), against the threshold."));
+ ToolTip.SetTip(trace, Loc.T("device.prism.the_selected_bands_input_peaks"));
const string cols = "50,*,*,40";
var head = new Grid { ColumnDefinitions = new ColumnDefinitions(cols), Height = 11 };
var hA = Caps("ATTACK", DimC); hA.HorizontalAlignment = HorizontalAlignment.Center;
@@ -430,7 +430,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
var rel = Bar(BP(bb, Release), RelF, () => PrismInk.Band[bb], null, 38, Lit); rel.Margin = new Thickness(0, 0, 8, 0);
g.Children.Add(Col(atk, 1)); g.Children.Add(Col(rel, 2));
var auto = Toggle(BP(bb, AutoRelease), ""); auto.HorizontalAlignment = HorizontalAlignment.Right;
- ToolTip.SetTip(auto, Loc.T("Auto release — short peaks recover fast, sustained compression recovers slowly"));
+ ToolTip.SetTip(auto, Loc.T("device.prism.auto_release_short_peaks_recover"));
g.Children.Add(Col(auto, 3));
rows.Children.Add(BandRow(bb, g, 18));
}
@@ -501,7 +501,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
soloCells[i] = c; soloRow.Children.Add(c);
}
Learn(soloRow, Solo);
- ToolTip.SetTip(soloRow, Loc.T("Solo a band — hear only that band (click again to clear)"));
+ ToolTip.SetTip(soloRow, Loc.T("device.prism.solo_a_band_hear_only"));
readouts.Add(HiSolo); HiSolo();
var soloGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 6 };
soloGrid.Children.Add(Caps("SOLO")); soloGrid.Children.Add(Col(soloRow, 1)); soloGrid.Children.Add(Col(soloTxt, 2));
@@ -528,13 +528,13 @@ internal sealed class PrismDeviceBody : IDeviceBody
readouts.Add(() =>
{
int src = scOk ? engine.DeviceSidechainSource(track, di) : -1;
- scName.Text = !scOk ? Loc.T("n/a in a rack") : src < 0 ? Loc.T("None — own input") : SidechainSourcePicker.Name(engine, engine.DeviceSidechainKey(track, di));
+ scName.Text = !scOk ? Loc.T("device.prism.n_a_in_a_rack") : src < 0 ? Loc.T("device.prism.none_own_input") : SidechainSourcePicker.Name(engine, engine.DeviceSidechainKey(track, di));
scName.Foreground = src >= 0 ? TxtC : Txt2;
});
var scBox = new Border { Height = 16, Background = Inset, BorderBrush = Border2, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Badge, Padding = new Thickness(6, 0),
Cursor = new Cursor(StandardCursorType.Hand), IsEnabled = scOk,
Child = new DockPanel { Children = { Docked(new Glyph(GlyphKind.ChevronDown, 8) { Foreground = MutedC, Margin = new Thickness(5, 0, 0, 0) }, Dock.Right), scName } } };
- ToolTip.SetTip(scBox, Loc.T("Sidechain — key every band's detector from another track (split into the same bands)"));
+ ToolTip.SetTip(scBox, Loc.T("device.prism.sidechain_key_every_bands_detector"));
scBox.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(scBox).Properties.IsLeftButtonPressed || !scOk) return;
@@ -547,7 +547,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
mi.Click += (_, _) => pick();
fly.Items.Add(mi);
}
- Item(Loc.T("None — own input"), engine.DeviceSidechainSource(track, di) < 0, () => { engine.SetDeviceSidechainSource(track, di, -1); Changed(); });
+ Item(Loc.T("device.prism.none_own_input"), engine.DeviceSidechainSource(track, di) < 0, () => { engine.SetDeviceSidechainSource(track, di, -1); Changed(); });
fly.Items.Add(new Separator());
foreach (var row in SidechainSourcePicker.MenuRows(engine, track, di, Changed)) fly.Items.Add(SidechainSourcePicker.MenuItemFor(row));
fly.ShowAt(scBox);
@@ -556,9 +556,9 @@ internal sealed class PrismDeviceBody : IDeviceBody
var scRow = new Grid { ColumnDefinitions = new ColumnDefinitions("50,*"), VerticalAlignment = VerticalAlignment.Center };
scRow.Children.Add(Caps("SIDECHAIN")); scRow.Children.Add(Col(scBox, 1));
var listen = Toggle(ScListen, "Listen");
- ToolTip.SetTip(listen, Loc.T("Listen — hear the detector's key signal (the sidechain, or the input), per solo band"));
+ ToolTip.SetTip(listen, Loc.T("device.prism.listen_hear_the_detectors_key"));
var mk = Toggle(AutoMakeup, "Auto makeup");
- ToolTip.SetTip(mk, Loc.T("Auto makeup — each band gets back about half of its compression at 0\u2009dBFS"));
+ ToolTip.SetTip(mk, Loc.T("device.prism.auto_makeup_each_band_gets"));
var toggles = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 10 };
toggles.Children.Add(listen); toggles.Children.Add(Col(mk, 1));
var mid = new StackPanel { Spacing = 5, Children = {
@@ -574,7 +574,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
});
var clipRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 6 };
var clipSeg = Seg(SoftClip, new[] { "Off", "On" });
- ToolTip.SetTip(clipSeg, Loc.T("Soft clip — a smooth ceiling at −0.3\u2009dBFS after the output gain"));
+ ToolTip.SetTip(clipSeg, Loc.T("device.prism.soft_clip_a_smooth_ceiling"));
clipRow.Children.Add(Caps("SOFT CLIP")); clipRow.Children.Add(Col(clipSeg, 1)); clipRow.Children.Add(Col(clipTxt, 2));
var midB = Divider(mid); midB.Margin = new Thickness(0, 4, 0, 0);
return new DockPanel { LastChildFill = false, Margin = new Thickness(8, 5, 8, 5), Children = {
@@ -591,7 +591,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
Control ModeExtras()
{
var seg = Seg(BandsP, new[] { "3", "2", "1" }, () => { if (!BandActive(band)) SelectBand(1); foreach (var a in readouts) a(); });
- ToolTip.SetTip(seg, Loc.T("Bands — 3: Low / Mid / High · 2: Low + Mid (Mid runs to 20\u2009kHz) · 1: Mid, full band"));
+ ToolTip.SetTip(seg, Loc.T("device.prism.bands_3_low_mid_high"));
return new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5, Children = { Caps("MODE"), seg } };
}
Control BandChips()
@@ -622,7 +622,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
Control DetectExtras()
{
var seg = Seg(Detect, new[] { "Peak", "RMS" });
- ToolTip.SetTip(seg, Loc.T("Detector — Peak follows every transient; RMS (10\u2009ms) follows loudness, smoother"));
+ ToolTip.SetTip(seg, Loc.T("device.prism.detector_peak_follows_every_transient"));
return new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5, Children = { Caps("DETECT"), seg } };
}
var extrasBodies = new Control?[3];
@@ -651,7 +651,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
{
int nb = BandCount();
int solo = Sel(Solo, 4) - 1;
- if (On(ScListen)) return Loc.T("Listening to the detector key") + (solo >= 0 ? Inv($" · {PrismInk.Names[solo]} band") : "");
+ if (On(ScListen)) return Loc.T("device.prism.listening_to_the_detector_key") + (solo >= 0 ? Inv($" · {PrismInk.Names[solo]} band") : "");
switch (centreTab)
{
case 1:
@@ -669,7 +669,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
return Inv($"{(On(Detect) ? "RMS" : "Peak")} detector · {(autos.Count > 0 ? "auto release on " + string.Join(", ", autos) : "fixed release")} · {sc}");
}
default:
- string xo = nb == 3 ? Loc.F("crossovers {0} / {1}", HzF(XHz(P(XoverLow))), HzF(XHz(P(XoverHigh)))) : nb == 2 ? Inv($"crossover {HzF(XHz(P(XoverLow)))}") : "full band";
+ string xo = nb == 3 ? Loc.F("device.prism.crossovers", HzF(XHz(P(XoverLow))), HzF(XHz(P(XoverHigh)))) : nb == 2 ? Inv($"crossover {HzF(XHz(P(XoverLow)))}") : "full band";
return Inv($"{nb} {(nb == 1 ? "band" : "bands")} · {xo} · amount {P(Amount) * 100:0} %{(solo >= 0 && BandActive(solo) ? " · " + PrismInk.Names[solo] + " solo" : "")}");
}
}
@@ -680,7 +680,7 @@ internal sealed class PrismDeviceBody : IDeviceBody
double sr = Sc(S_SampleRate), lat = Sc(S_Latency);
string la = lat > 0 && sr > 0 ? Inv($"lookahead {lat * 1000 / sr:0.#}\u2009ms") : "no lookahead";
string sc = Sc(S_ScActive) > 0.5 ? " · SC" : "";
- statusRight.Text = sr > 0 ? Loc.F("{0:0.#}\u2009kHz · {1}{2} · CPU {3:0}\u2009%", sr / 1000, la, sc, Sc(S_Cpu) * 100) : "";
+ statusRight.Text = sr > 0 ? Loc.F("device.prism.khz_cpu", sr / 1000, la, sc, Sc(S_Cpu) * 100) : "";
});
var statusGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 8 };
statusGrid.Children.Add(statusLeft); statusGrid.Children.Add(Col(statusRight, 1));
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/ReverbDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/ReverbDeviceBody.cs
index 1ac76a60..1891575b 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/ReverbDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/ReverbDeviceBody.cs
@@ -166,7 +166,7 @@ internal sealed class ReverbDeviceBody : IDeviceBody
t.GestureBegin += target => Begin(target == 0 ? Decay : PreDelay);
t.GestureEnd += target => End(target == 0 ? Decay : PreDelay);
t.Reset += target => { Reset(target == 0 ? Decay : PreDelay); SyncTail(); };
- ToolTip.SetTip(t, MenuKit.Keys(Loc.T("The decay tail — the impulse at the pre-delay (teal), the early reflections (drawn magnified), then the RT60 curve over 4 s. Drag the teal marker for the pre-delay, drag the tail for the decay; ⌥-click to type, double-click to reset.")));
+ ToolTip.SetTip(t, MenuKit.Keys(Loc.T("device.reverb.the_decay_tail_the_impulse")));
ValueEntry.AttachHandles(t, [ValueEntry.DeviceParam(engine, track, di, Decay, "Decay", DecayF, SyncTail)],
[ValueEntry.DeviceParam(engine, track, di, PreDelay, "Pre-delay", PreF, SyncTail)]);
MidiLearn.Bind(t, MidiTarget.DeviceParam(track, di, Decay), "Decay");
@@ -218,9 +218,9 @@ internal sealed class ReverbDeviceBody : IDeviceBody
var tailTitle = Caps("TAIL"); tailTitle.HorizontalAlignment = HorizontalAlignment.Center;
var faders = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto"), ColumnSpacing = 1, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 4, 0, 3) };
faders.Children.Add(TailFader(Decay, "DECAY", NotaPalette.VizInk, NotaPalette.VizInk,
- Loc.T("Decay — RT60, the time the tail takes to fall 60 dB (0.2 … 12 s); Freeze holds it forever. Double-click resets.")));
+ Loc.T("device.reverb.decay_rt60_the_time_the")));
faders.Children.Add(Col(TailFader(HFDamp, "DAMP", NotaPalette.Teal, NotaPalette.TealBright,
- Loc.T("HF Damp — how much faster the highs die than the lows. Double-click resets.")), 1));
+ Loc.T("device.reverb.hf_damp_how_much_faster")), 1));
var decVal = Mono("", 7, TextPrimary); decVal.HorizontalAlignment = HorizontalAlignment.Center;
var dmpVal = Mono("", 7, TextPrimary); dmpVal.HorizontalAlignment = HorizontalAlignment.Center;
readouts.Add(() =>
@@ -249,7 +249,7 @@ internal sealed class ReverbDeviceBody : IDeviceBody
var head = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 6, Height = 18 };
head.Children.Add(Caps("MODE"));
var seg = Seg(Algorithm, Algos);
- ToolTip.SetTip(seg, Loc.T("Algorithm — Hall (large, spaced reflections) · Room (small, close walls) · Plate (dense, no room at all) · Chamber (between)"));
+ ToolTip.SetTip(seg, Loc.T("device.reverb.algorithm_hall_large_spaced_reflections"));
head.Children.Add(Col(seg, 1));
head.Children.Add(Col(hint, 2));
return head;
@@ -272,9 +272,9 @@ internal sealed class ReverbDeviceBody : IDeviceBody
g.Children.Add(Col(K(Diffusion, "DIFFUSE", Pct), 2));
g.Children.Add(Col(K(Decay, "DECAY", DecayF), 3));
var er = Toggle(EarlyRefl, "Early reflections");
- ToolTip.SetTip(er, Loc.T("Early reflections — the first discrete echoes off the walls, spaced by the algorithm and the size"));
+ ToolTip.SetTip(er, Loc.T("device.reverb.early_reflections_the_first_discrete"));
var fr = Toggle(Freeze, "Freeze");
- ToolTip.SetTip(fr, Loc.T("Freeze — hold the tail forever; the input is muted and nothing decays"));
+ ToolTip.SetTip(fr, Loc.T("device.reverb.freeze_hold_the_tail_forever"));
g.Children.Add(Col(new StackPanel { Spacing = 5, VerticalAlignment = VerticalAlignment.Center, Children = { er, fr } }, 5));
return CentreTab(g);
}
@@ -288,9 +288,9 @@ internal sealed class ReverbDeviceBody : IDeviceBody
g.Children.Add(Col(K(ModRate, "MOD RATE", RateF, arc: NotaPalette.Rose), 3));
g.Children.Add(Col(K(ModDepth, "MOD DEPTH", Pct, arc: NotaPalette.Rose), 4));
var mt = Toggle(ModOnTail, "Mod on tail");
- ToolTip.SetTip(mt, Loc.T("Mod on tail — the modulation wobbles the tail itself (a chorused, evolving decay); off, it moves only the early part and the tail stays still"));
+ ToolTip.SetTip(mt, Loc.T("device.reverb.mod_on_tail_the_modulation"));
var vi = Toggle(Vintage, "Vintage");
- ToolTip.SetTip(vi, Loc.T("Vintage — an early-digital colour: a band-limited input, 12-bit wet and a deeper wobble"));
+ ToolTip.SetTip(vi, Loc.T("device.reverb.vintage_an_early_digital_colour"));
g.Children.Add(Col(new StackPanel { Spacing = 5, VerticalAlignment = VerticalAlignment.Center, Children = { mt, vi } }, 6));
return CentreTab(g);
}
@@ -314,7 +314,7 @@ internal sealed class ReverbDeviceBody : IDeviceBody
wet.Children.Add(Caps("WET")); wet.Children.Add(Col(wetBar, 1)); wet.Children.Add(Col(wetDb, 2));
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6, VerticalAlignment = VerticalAlignment.Center };
- var freezeBtn = Btn("Freeze", () => { SetP(Freeze, On(Freeze) ? 0f : 1f); SyncTail(); }, Loc.T("Freeze — hold the tail forever; the input is muted and nothing decays"));
+ var freezeBtn = Btn("Freeze", () => { SetP(Freeze, On(Freeze) ? 0f : 1f); SyncTail(); }, Loc.T("device.reverb.freeze_hold_the_tail_forever"));
var freezeTxt = (TextBlock)freezeBtn.Child!;
readouts.Add(() =>
{
@@ -326,7 +326,7 @@ internal sealed class ReverbDeviceBody : IDeviceBody
});
MidiLearn.Bind(freezeBtn, MidiTarget.DeviceParam(track, di, Freeze), "Freeze");
btns.Children.Add(freezeBtn);
- btns.Children.Add(Col(Btn("Kill tail", () => engine.DeviceAction(track, di, A_KillTail, 0, 0), Loc.T("Kill tail — empty the reverb at once; whatever is still ringing (or frozen) stops")), 1));
+ btns.Children.Add(Col(Btn("Kill tail", () => engine.DeviceAction(track, di, A_KillTail, 0, 0), Loc.T("device.reverb.kill_tail_empty_the_reverb")), 1));
var rows = new Control[]
{
@@ -362,12 +362,12 @@ internal sealed class ReverbDeviceBody : IDeviceBody
SliderRow("MIX", DryWet, Pct, () => On(WetOnly)),
SliderRow("WIDTH", WidthP, Pct),
SliderRow("Mono f", BassMono, v => v <= 0.001 ? "off" : NotaNum.F($"{Exp(v, 30, 500):0}")) } };
- ToolTip.SetTip(mid.Children[2], Loc.T("Bass mono — below this frequency the tail is mono, so a wide reverb does not smear the low end (off at the far left)"));
+ ToolTip.SetTip(mid.Children[2], Loc.T("device.reverb.bass_mono_below_this_frequency"));
- var wetOnly = Toggle(WetOnly, Loc.T("Wet only (send)"));
- ToolTip.SetTip(wetOnly, Loc.T("Wet only — the tail with no dry, for a return / send track"));
- var comp = Toggle(LatencyComp, Loc.T("Latency comp."));
- ToolTip.SetTip(comp, Loc.T("The input diffuser delays the tail by a fixed group delay; on, the pre-delay is shortened by exactly that so the tail starts on the set pre-delay (it cannot go below zero)."));
+ var wetOnly = Toggle(WetOnly, Loc.T("common.wet_only_send"));
+ ToolTip.SetTip(wetOnly, Loc.T("device.reverb.wet_only_the_tail_with"));
+ var comp = Toggle(LatencyComp, Loc.T("device.reverb.latency_comp"));
+ ToolTip.SetTip(comp, Loc.T("device.reverb.the_input_diffuser_delays_the"));
var bottom = new StackPanel { Spacing = 5, Children = { wetOnly, comp } };
var body = new DockPanel { LastChildFill = false, Children = {
@@ -389,7 +389,7 @@ internal sealed class ReverbDeviceBody : IDeviceBody
{
if (On(Freeze))
{
- extras.Text = Loc.T("input muted · tail held");
+ extras.Text = Loc.T("device.reverb.input_muted_tail_held");
extras.Foreground = AccentBright;
return;
}
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/ShutterDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/ShutterDeviceBody.cs
index 997af2b4..3d3ed788 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/ShutterDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/ShutterDeviceBody.cs
@@ -191,7 +191,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
ToolTip.SetTip(seg, tip);
return seg;
}
- Control ModeSeg() => Seg(Flip, new[] { "Gate", "Duck" }, Loc.T("Mode — Gate lets the signal through above the threshold; Duck turns it down while the key is above it"));
+ Control ModeSeg() => Seg(Flip, new[] { "Gate", "Duck" }, Loc.T("device.shutter.mode_gate_lets_the_signal"));
// Outlined chips: the chosen one = accent edge + wash.
Control Chips(string[] names, Func<int, bool> lit, Action<int> pick, int learnParam, string tip)
@@ -246,7 +246,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
}
Border ToggleLatch(int p, string text, string tip, bool fill = false)
=> Latch(p, () => On(p), () => SetP(p, On(p) ? 0f : 1f), () => text, tip, fill);
- Border ListenLatch(bool fill = false) => ToggleLatch(Listen, "Listen", Loc.T("Listen — hear the key as the detector hears it (after its filter), to tune the band"), fill);
+ Border ListenLatch(bool fill = false) => ToggleLatch(Listen, "Listen", Loc.T("device.shutter.listen_hear_the_key_as"), fill);
// Slider row: caps label · track · mono value.
Control SliderRow(string label, int p, Func<double, string> fmt, bool modulation = false, double labW = 40)
@@ -283,7 +283,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
box.BorderBrush = ext ? NotaPalette.BorderStrong : BorderDef;
chev.Foreground = ext ? TextSecondary : TextTertiary;
});
- ToolTip.SetTip(box, Loc.T("Key source — Internal keys off this track; pick another track, or one pad or chain of it, to gate or duck against it"));
+ ToolTip.SetTip(box, Loc.T("device.shutter.key_source_internal_keys_off"));
Learn(box, ExternalKey);
box.PointerPressed += (_, e) =>
{
@@ -296,7 +296,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
mi.Click += (_, _) => pick();
fly.Items.Add(mi);
}
- Item(Loc.T("Internal — this track"), !ExtOn(), () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); RefreshAll(); });
+ Item(Loc.T("device.shutter.internal_this_track"), !ExtOn(), () => { engine.SetDeviceSidechainSource(track, di, -1); ctx.NotifyChanged(); RefreshAll(); });
// Picking a source means using it.
void Picked()
{
@@ -329,7 +329,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
}, out var sync);
readouts.Add(sync);
Learn(sw, ExternalKey);
- ToolTip.SetTip(sw, Loc.T("External sidechain — the detector listens to the key source instead of this track"));
+ ToolTip.SetTip(sw, Loc.T("device.shutter.external_sidechain_the_detector_listens"));
return sw;
}
@@ -373,8 +373,8 @@ internal sealed class ShutterDeviceBody : IDeviceBody
var grPill = new ShPill { Ink = Teal, FromTop = true, VerticalAlignment = VerticalAlignment.Stretch };
var inLbl = Caps("IN"); inLbl.HorizontalAlignment = HorizontalAlignment.Center;
var grLbl = Acr("GR"); grLbl.HorizontalAlignment = HorizontalAlignment.Center;
- ToolTip.SetTip(inPill, Loc.T("The level the detector compares — this track's input, or the key when an external sidechain drives it; the dashed tick is the threshold"));
- ToolTip.SetTip(grPill, Loc.T("Gain reduction — how far the gate has turned the signal down now"));
+ ToolTip.SetTip(inPill, Loc.T("device.shutter.the_level_the_detector_compares"));
+ ToolTip.SetTip(grPill, Loc.T("device.shutter.gain_reduction_how_far_the"));
var stateIn = Mono("", 7, TextPrimary); stateIn.HorizontalAlignment = HorizontalAlignment.Center;
var stateGr = Mono("", 7, TextPrimary); stateGr.HorizontalAlignment = HorizontalAlignment.Center;
static double Norm60(double db) => Math.Clamp((db + 60) / 60, 0, 1);
@@ -409,15 +409,15 @@ internal sealed class ShutterDeviceBody : IDeviceBody
signal = new ShSignalView();
WireDrag(signal, h => h == ShSignalView.HThreshold ? Threshold : Return,
F(Threshold, "Threshold", v => ThrShort(v) + "\u2009dB"), F(Return, "Return", RetF));
- ToolTip.SetTip(signal, MenuKit.Keys(Loc.T("The input (teal) and what passes (neutral ink) over the window, with the threshold (dashed) and where the gate closes again (dashed). Drag a line up or down; double-click resets it, ⌥-click types it.")));
+ ToolTip.SetTip(signal, MenuKit.Keys(Loc.T("device.shutter.the_input_teal_and_what")));
Learn(signal, Threshold);
var liveBtn = Latch(-1, () => live, () => { live = !live; if (!live) Array.Copy(scope, frozen, kScope); }, () => live ? "Live" : "Frozen",
- Loc.T("Live — the graph follows the audio; click to freeze the picture"));
+ Loc.T("device.shutter.live_the_graph_follows_the"));
var ret = Mono("", 7, TextSecondary);
readouts.Add(() => ret.Text = NotaNum.F($"return {RetDb():0.0}\u2009dB"));
var head = HeadRow(Row(6, Caps("MODE"), ModeSeg(), new Border { Width = 2 }, Caps("LOOK"),
- Seg(Lookahead, new[] { "0", "1", "5\u2009ms" }, Loc.T("Lookahead — the gate opens this much before the transient arrives (the track is delayed by it)")), liveBtn), ret);
+ Seg(Lookahead, new[] { "0", "1", "5\u2009ms" }, Loc.T("device.shutter.lookahead_the_gate_opens_this")), liveBtn), ret);
var knobs = KnobRow(new[]
{
K(Threshold, "THRESH", ThrShort),
@@ -439,12 +439,12 @@ internal sealed class ShutterDeviceBody : IDeviceBody
envView = new ShEnvelopeView();
WireDrag(envView, h => h switch { ShEnvelopeView.HAttack => Attack, ShEnvelopeView.HHold => Hold, ShEnvelopeView.HRelease => Release, _ => Floor },
F(Attack, "Attack", AtkF), F(Hold, "Hold", HoldF), F(Release, "Release", RelF), F(Floor, "Floor", FloorF));
- ToolTip.SetTip(envView, MenuKit.Keys(Loc.T("One opening: attack, hold, release in the chosen shape, down to the floor (inverted for Duck). Drag a node sideways for its time, the teal floor up or down; double-click resets, ⌥-click types.")));
+ ToolTip.SetTip(envView, MenuKit.Keys(Loc.T("device.shutter.one_opening_attack_hold_release")));
Learn(envView, Release);
var shapes = Chips(Shapes, i => Sel(Shape, 3) == i, i => SetP(Shape, i / 2f), Shape,
- Loc.T("Shape — Linear: straight ramps over the times; Log: the classic one-pole curve; Snap: stays open, then shuts hard"));
- var retrig = ToggleLatch(Retrigger, "Retrig", Loc.T("Retrigger — trigger mode: each hit fires one attack → hold → release, however long the signal stays above the threshold"));
+ Loc.T("device.shutter.shape_linear_straight_ramps_over"));
+ var retrig = ToggleLatch(Retrigger, "Retrig", Loc.T("device.shutter.retrigger_trigger_mode_each_hit"));
var times = Mono("", 7, TextSecondary);
readouts.Add(() => times.Text = Times());
var head = HeadRow(Row(6, Caps("SHAPE"), shapes, new Border { Width = 2 }, ModeSeg(), retrig), times);
@@ -453,9 +453,9 @@ internal sealed class ShutterDeviceBody : IDeviceBody
K(Attack, "ATTACK", AtkF),
K(Hold, "HOLD", HoldF),
K(Release, "RELEASE", RelF),
- K(Floor, "FLOOR", FloorF, Teal, tip: Loc.T("Floor — the level when closed (−∞ = silence); in Duck, how far the signal goes down")),
+ K(Floor, "FLOOR", FloorF, Teal, tip: Loc.T("device.shutter.floor_the_level_when_closed")),
},
- () => P(Floor) <= 0.001f ? (Duck() ? Loc.T("ducks to silence") : Loc.T("closes to silence")) : NotaNum.F($"floor {FloorDb():0.0}\u2009dB instead of silence"),
+ () => P(Floor) <= 0.001f ? (Duck() ? Loc.T("device.shutter.ducks_to_silence") : Loc.T("device.shutter.closes_to_silence")) : NotaNum.F($"floor {FloorDb():0.0}\u2009dB instead of silence"),
() => NotaNum.F($"openings {Sc(S_TrigPerBar):0} / bar · {GrText()}"));
return TabBody(head, envView, knobs);
}
@@ -468,20 +468,20 @@ internal sealed class ShutterDeviceBody : IDeviceBody
{
keyView = new ShKeyView();
WireDrag(keyView, h => h == ShKeyView.HHp ? DetHP : DetLP, F(DetHP, "SC HP", HpF), F(DetLP, "SC LP", LpF));
- ToolTip.SetTip(keyView, MenuKit.Keys(Loc.T("The detector's band-pass (teal) — only this part of the key opens the gate — over the reduction in the window (neutral ink). Drag the nodes sideways; double-click resets, ⌥-click types.")));
+ ToolTip.SetTip(keyView, MenuKit.Keys(Loc.T("device.shutter.the_detectors_band_pass_teal")));
Learn(keyView, DetHP);
var eq = Latch(DetFilter, () => On(DetFilter), () => SetP(DetFilter, On(DetFilter) ? 0f : 1f), () => On(DetFilter) ? "SC EQ on" : "SC EQ off",
- Loc.T("SC EQ — the detector hears the key through its band-pass; off = the full band"));
+ Loc.T("device.shutter.sc_eq_the_detector_hears"));
var look = Mono("", 7, TextSecondary);
readouts.Add(() => look.Text = NotaNum.F($"look {LookMs()}\u2009ms"));
var head = HeadRow(Row(6, Caps("KEY"), KeyDrop(false), ModeSeg(), ListenLatch(), eq), look);
var knobs = KnobRow(new[]
{
K(Threshold, "THRESH", ThrShort),
- K(Floor, "RANGE", FloorF, tip: Loc.T("Range — how far the gate closes or the duck goes down (−∞ = all the way)")),
- K(Return, "RETURN", RetF, Teal, tip: Loc.T("Return — how far under the threshold the key must fall before the gate closes (stops chatter)")),
- K(Lookahead, "LOOK", LookF, Teal, steps: 3, tip: Loc.T("Lookahead — 0, 1 or 5\u2009ms")),
+ K(Floor, "RANGE", FloorF, tip: Loc.T("device.shutter.range_how_far_the_gate")),
+ K(Return, "RETURN", RetF, Teal, tip: Loc.T("device.shutter.return_how_far_under_the")),
+ K(Lookahead, "LOOK", LookF, Teal, steps: 3, tip: Loc.T("device.shutter.lookahead_0_1_or_5")),
},
() => NotaNum.F($"key {KeyName()} · {(On(DetFilter) ? "fires on " + HpF(P(DetHP)) + "…" + LpF(P(DetLP)) : "full band")}"),
() => NotaNum.F($"{(Duck() ? "ducks" : "closes")} to {(P(Floor) <= 0.001f ? "−∞\u2009dB" : NotaNum.F($"{FloorDb():0.0}\u2009dB"))} · {GrText()}"));
@@ -558,7 +558,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
grid.SizeChanged += (_, _) => Paint();
readouts.Add(() => { if (!drag) Paint(); });
Learn(host, p);
- ToolTip.SetTip(host, MenuKit.Keys(tip + Loc.T(" · ⌥-click to type")));
+ ToolTip.SetTip(host, MenuKit.Keys(tip + Loc.T("device.shutter.click_to_type")));
ValueEntry.Attach(host, F(p, name, fmt), tb);
return host;
}
@@ -616,11 +616,11 @@ internal sealed class ShutterDeviceBody : IDeviceBody
RefreshAll();
};
patView.GestureEnd += () => { foreach (int k in touched) End(Step1 + k); touched.Clear(); };
- ToolTip.SetTip(patView, Loc.T("The step pattern — each column is one step's level, the line is the gain it makes (smooth and swing bend it). Draw sets steps, Line draws a ramp, Erase clears, Flip toggles on / off."));
+ ToolTip.SetTip(patView, Loc.T("device.shutter.the_step_pattern_each_column"));
var tools = Segments(new[] { "Draw", "Line", "Erase", "Flip" }, () => patTool, i => { patTool = i; if (patView is not null) patView.Tool = i; }, out var toolSync, padX: 6);
readouts.Add(toolSync);
- ToolTip.SetTip(tools, Loc.T("Mouse tool for the grid"));
+ ToolTip.SetTip(tools, Loc.T("device.shutter.mouse_tool_for_the_grid"));
Border Arrow(GlyphKind kind, int dir)
{
@@ -635,14 +635,14 @@ internal sealed class ShutterDeviceBody : IDeviceBody
Height = 18, Background = Sunken, BorderBrush = BorderDef, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Badge,
Child = new DockPanel { Children = { Docked(Arrow(GlyphKind.ChevronLeft, -1), Dock.Left), Docked(Arrow(GlyphKind.ChevronRight, 1), Dock.Right), pname } },
};
- ToolTip.SetTip(browser, Loc.T("Pattern shapes — the arrows step through them (fitted to the grid)"));
- var rnd = Button("Rnd", Randomize, Loc.T("Roll a new pattern — Complexity sets how busy and how varied it is"));
- var cx = FillBar(PatComplexity, "Complexity", v => "Complexity " + Pct((float)v), Loc.T("Complexity — how busy and varied Rnd makes the pattern"));
+ ToolTip.SetTip(browser, Loc.T("device.shutter.pattern_shapes_the_arrows_step"));
+ var rnd = Button("Rnd", Randomize, Loc.T("device.shutter.roll_a_new_pattern_complexity"));
+ var cx = FillBar(PatComplexity, "Complexity", v => "Complexity " + Pct((float)v), Loc.T("device.shutter.complexity_how_busy_and_varied"));
var head = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto,110"), ColumnSpacing = 5, Height = 20 };
head.Children.Add(tools); head.Children.Add(Col(browser, 1)); head.Children.Add(Col(rnd, 2)); head.Children.Add(Col(cx, 3));
- var smooth = FillBar(PatSmooth, "Smooth", v => "Smooth " + Pct((float)v), Loc.T("Smooth — ramps into each step instead of jumping (up to half a step)"));
- var swing = FillBar(PatSwing, "Swing", v => NotaNum.F($"Swing {v * 75:0} %"), Loc.T("Swing — every second step comes late"));
+ var smooth = FillBar(PatSmooth, "Smooth", v => "Smooth " + Pct((float)v), Loc.T("device.shutter.smooth_ramps_into_each_step"));
+ var swing = FillBar(PatSwing, "Swing", v => NotaNum.F($"Swing {v * 75:0} %"), Loc.T("device.shutter.swing_every_second_step_comes"));
var nSt = Mono("", 9, TextPrimary); var nLv = Mono("", 9, TextPrimary);
readouts.Add(() => { nSt.Text = NSteps().ToString(); nLv.Text = NLevels().ToString(); });
Border Cycle(TextBlock t, Action a, string tip)
@@ -663,17 +663,17 @@ internal sealed class ShutterDeviceBody : IDeviceBody
var next = Resample(cur, StepCounts[si]);
SetP(PatSteps, si / 2f);
WriteSteps(next);
- }, Loc.T("Steps — 8, 16 or 32 (the pattern is stretched to fit)")),
+ }, Loc.T("device.shutter.steps_8_16_or_32")),
Mono("×", 8, TextTertiary),
Cycle(nLv, () =>
{
var cur = StepsNow();
SetP(PatLevels, (Sel(PatLevels, 3) + 1) % 3 / 2f);
WriteSteps(Array.ConvertAll(cur, v => Qz(v)));
- }, Loc.T("Levels — 4, 8 or 16 heights a step snaps to"))),
+ }, Loc.T("device.shutter.levels_4_8_or_16"))),
};
var target = Seg(PatTarget, new[] { "Off", "Volume", "Map" },
- Loc.T("Target — Off; Volume: the pattern gates the audio; Map: the audio is left alone and the pattern drives Pattern Out, a CV source in the Modular view"));
+ Loc.T("device.shutter.target_off_volume_the_pattern"));
var foot = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,Auto,Auto"), ColumnSpacing = 5, Height = 20 };
foot.Children.Add(smooth); foot.Children.Add(Col(swing, 1)); foot.Children.Add(Col(gridSize, 2)); foot.Children.Add(Col(target, 3));
@@ -686,25 +686,25 @@ internal sealed class ShutterDeviceBody : IDeviceBody
Control RhythmTab()
{
- var rate = K(PatRate, "RATE", _ => RateName(), steps: 5, size: 40, tip: Loc.T("Rate — how long the whole pattern takes: 1/4 … 4 bars in Sync, 4 … 0.25\u2009Hz in Free"));
- var depth = K(PatDepth, "DEPTH", v => Pct((float)v), Teal, size: 40, tip: Loc.T("Depth — how far an empty step turns the signal down"));
+ var rate = K(PatRate, "RATE", _ => RateName(), steps: 5, size: 40, tip: Loc.T("device.shutter.rate_how_long_the_whole"));
+ var depth = K(PatDepth, "DEPTH", v => Pct((float)v), Teal, size: 40, tip: Loc.T("device.shutter.depth_how_far_an_empty"));
var knobs = new UniformGrid { Columns = 2, Children = { rate, depth } };
var clock = Segments(new[] { "Sync", "Free" }, () => On(PatSync) ? 0 : 1, i => { SetP(PatSync, i == 0 ? 1f : 0f); RefreshAll(); }, out var clockSync, fill: true);
readouts.Add(clockSync);
Learn(clock, PatSync);
- ToolTip.SetTip(clock, Loc.T("Clock — Sync locks the pattern to the song's bars, Free runs it in Hz"));
+ ToolTip.SetTip(clock, Loc.T("device.shutter.clock_sync_locks_the_pattern"));
var clockRow = LabelRow("CLOCK", clock);
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), ColumnSpacing = 4 };
- btns.Children.Add(Button("Copy", () => _clipboard = StepsNow(), Loc.T("Copy the steps")));
- btns.Children.Add(Col(Button("Paste", () => { if (_clipboard is { } c) WriteSteps(Array.ConvertAll(Resample(c, NSteps()), v => Qz(v))); }, Loc.T("Paste copied steps (fitted to the grid)"), () => _clipboard is not null), 1));
- btns.Children.Add(Col(Button("Clear", () => WriteSteps(new float[NSteps()]), Loc.T("Clear every step")), 2));
+ btns.Children.Add(Button("Copy", () => _clipboard = StepsNow(), Loc.T("device.shutter.copy_the_steps")));
+ btns.Children.Add(Col(Button("Paste", () => { if (_clipboard is { } c) WriteSteps(Array.ConvertAll(Resample(c, NSteps()), v => Qz(v))); }, Loc.T("device.shutter.paste_copied_steps_fitted_to"), () => _clipboard is not null), 1));
+ btns.Children.Add(Col(Button("Clear", () => WriteSteps(new float[NSteps()]), Loc.T("device.shutter.clear_every_step")), 2));
return Spread(
knobs,
clockRow,
btns,
new StackPanel { Spacing = 5, Children = {
- Toggle(PatRetrig, Loc.T("Retrig on MIDI note"), Loc.T("Retrig — every MIDI note on this track (or the key track) restarts the pattern")),
- Toggle(PatGated, Loc.T("Only while gate open"), Loc.T("Gated — the pattern plays only while the threshold gate is open (gate × pattern)")) } });
+ Toggle(PatRetrig, Loc.T("device.shutter.retrig_on_midi_note"), Loc.T("device.shutter.retrig_every_midi_note_on")),
+ Toggle(PatGated, Loc.T("device.shutter.only_while_gate_open"), Loc.T("device.shutter.gated_the_pattern_plays_only")) } });
}
// ======================================================================
@@ -750,7 +750,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
b.BorderBrush = moving ? NotaPalette.BorderBrass : NotaPalette.GraphBorder;
t.Foreground = moving ? AccentBright : TextTertiary;
});
- ToolTip.SetTip(b, Loc.T("What the gate is doing now — closed, attack, open, hold or release — and its gain"));
+ ToolTip.SetTip(b, Loc.T("device.shutter.what_the_gate_is_doing"));
return b;
}
@@ -765,8 +765,8 @@ internal sealed class ShutterDeviceBody : IDeviceBody
StateBox(),
new StackPanel { Spacing = 5, Children = {
ExtSwitch(),
- Toggle(DetFilter, "Detector filter", Loc.T("Detector filter — the key goes through the band-pass (Sidechain tab) before the detector")),
- Toggle(PeakHold, "Peak hold", Loc.T("Peak hold — the detector holds each peak longer, so low notes and slow waves don't chatter the gate")) } });
+ Toggle(DetFilter, "Detector filter", Loc.T("device.shutter.detector_filter_the_key_goes")),
+ Toggle(PeakHold, "Peak hold", Loc.T("device.shutter.peak_hold_the_detector_holds")) } });
}
Control MetersTab()
@@ -797,13 +797,13 @@ internal sealed class ShutterDeviceBody : IDeviceBody
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
btns.Children.Add(ListenLatch(fill: true));
btns.Children.Add(Col(Latch(-1, () => false, () => engine.DeviceAction(track, di, A_ResetMeters, 0, 0), () => "Reset",
- Loc.T("Reset — clear the peak reduction, the opening count and the history"), fill: true), 1));
+ Loc.T("device.shutter.reset_clear_the_peak_reduction"), fill: true), 1));
var body = new DockPanel { LastChildFill = false, Children = {
Docked(box, Dock.Top),
Docked(new Border { Margin = new Thickness(0, 6, 0, 0), Child = sliders }, Dock.Top),
Docked(new StackPanel { Spacing = 5, Children = {
ExtSwitch(),
- Toggle(DetFilter, "Detector filter", Loc.T("Detector filter — the key goes through the band-pass before the detector")) } }, Dock.Bottom),
+ Toggle(DetFilter, "Detector filter", Loc.T("device.shutter.detector_filter_the_key_goes_2")) } }, Dock.Bottom),
Docked(new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 5), Child = btns }, Dock.Bottom) } };
return new Border { Padding = new Thickness(8, 6), Child = body };
}
@@ -837,7 +837,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
};
extrasHost.Cursor = centreTab == 0 ? new Cursor(StandardCursorType.Hand) : Cursor.Default;
});
- ToolTip.SetTip(extrasHost, Loc.T("Signal tab: click to change the window — ") + string.Join(" · ", WindowNames));
+ ToolTip.SetTip(extrasHost, Loc.T("device.shutter.signal_tab_click_to_change") + string.Join(" · ", WindowNames));
Control CentreBody(int t) => centreBodies[t] ??= t switch { 1 => EnvelopeTab(), 2 => SidechainTab(), 3 => PatternTab(), _ => SignalTab() };
Control RightBody(int t) => rightBodies[t] ??= t == 1 ? MetersTab() : DetectorTab();
Control RhythmBody(int t) => rhythmBodies[t] ??= t == 1 ? DetectorTab() : RhythmTab();
@@ -871,7 +871,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
{
tg == 0 ? "Pattern off" : "Pattern", PatternName(), RateName(), NotaNum.F($"{NSteps()} × {NLevels()}"),
"smooth " + Pct(P(PatSmooth)), "swing " + NotaNum.F($"{P(PatSwing) * 75:0}\u2009%"), "depth " + Pct(P(PatDepth)),
- }) + (tg == 0 ? "" : tg == 2 ? Loc.T(" → Map (Pattern Out)") : On(PatGated) ? Loc.T(" → Volume · gated") : " → Volume")
+ }) + (tg == 0 ? "" : tg == 2 ? Loc.T("device.shutter.map_pattern_out") : On(PatGated) ? Loc.T("device.shutter.volume_gated") : " → Volume")
+ (On(PatRetrig) ? " · MIDI retrig" : "");
}
switch (centreTab)
@@ -938,7 +938,7 @@ internal sealed class ShutterDeviceBody : IDeviceBody
bool on = tg > 0 && scN >= kScope;
patView.Set(patBuf, ns, NLevels(), on ? (int)Sc(kPatAt + P_Step) : -1, on ? Sc(kPatAt + P_Phase) : -1,
P(PatSmooth), P(PatSwing) * 0.375, P(PatDepth), tg == 2, tg > 0,
- tg == 2 ? Loc.T("Map → Pattern Out") : tg == 1 ? "gain" : "off");
+ tg == 2 ? Loc.T("device.shutter.map_pattern_out_2") : tg == 1 ? "gain" : "off");
}
if (centreTab == 2 && keyView is not null)
keyView.Set(Exp(P(DetHP), 20, 2000), Exp(P(DetLP), 200, 20000), On(DetFilter), h, H_Gate, n, Duck() ? "duck" : "reduction");
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/StrataDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/StrataDeviceBody.cs
index f9111b0d..599a403b 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/StrataDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/StrataDeviceBody.cs
@@ -90,7 +90,7 @@ internal sealed class StrataDeviceBody : IDeviceBody
new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center, Children = { barNum, tickRow, ofBars } } } } };
// ---------- layer stack ----------
- var layerHint = new TextBlock { Text = Loc.T("Press Record to lay down the first loop"), FontSize = 9, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
+ var layerHint = new TextBlock { Text = Loc.T("device.strata.press_record_to_lay_down"), FontSize = 9, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
var layerRows = new Border[MaxLayers]; var waves = new StrataWave[MaxLayers];
var stateTxts = new TextBlock[MaxLayers]; var dbTxts = new TextBlock[MaxLayers]; var muteBtns = new Border[MaxLayers]; var idxTxts = new TextBlock[MaxLayers];
var layerStack = new StackPanel { Spacing = 3 };
@@ -193,7 +193,7 @@ internal sealed class StrataDeviceBody : IDeviceBody
qRow,
new Border { Height = 1, Background = NotaPalette.SurfaceRaised },
Toggle(CountIn, "Count-in 1 bar", Teal),
- Toggle(SetTempo, Loc.T("Set tempo from loop"), Teal),
+ Toggle(SetTempo, Loc.T("device.strata.set_tempo_from_loop"), Teal),
Toggle(Reverse, "Reverse", NotaPalette.VizInk),
new StackPanel { VerticalAlignment = VerticalAlignment.Bottom, Children = { bottomActions } } } } };
DockPanel.SetDock(rail, Dock.Right);
@@ -215,17 +215,17 @@ internal sealed class StrataDeviceBody : IDeviceBody
barNum.Text = $"{barPos + 1} . {beat + 1}";
}
else barNum.Text = "–";
- ofBars.Text = Loc.Plural(loopBars > 0 ? loopBars : 0, "of {0} bar", "of {0} bars");
+ ofBars.Text = Loc.Plural("device.strata.of_bars", loopBars > 0 ? loopBars : 0);
int lit = (int)Math.Round(Math.Clamp(phase, 0, 1) * 16);
bool rolling = mode is M_Rec or M_Over or M_Play; // the progress is the playhead only while it runs
for (int i = 0; i < 16; i++) ticks[i].Background = (layers > 0 && i < lit) ? (rolling ? Brass : NotaPalette.VizInk) : Sunken;
- countLbl.Text = layers > 0 ? Loc.F("{0} of {1} · one cycle shown", layers, MaxLayers) : "";
+ countLbl.Text = layers > 0 ? Loc.F("device.strata.of_one_cycle_shown", layers, MaxLayers) : "";
// Action captions + active highlight.
actSub[0].Text = mode == M_Empty || layers == 0 ? "start loop" : "arm next";
- actSub[1].Text = layers < MaxLayers ? Loc.F("onto layer {0}", Math.Min(MaxLayers, layers + 1)) : "full";
+ actSub[1].Text = layers < MaxLayers ? Loc.F("device.strata.onto_layer", Math.Min(MaxLayers, layers + 1)) : "full";
actSub[2].Text = "all layers";
- actSub[3].Text = Loc.T("at bar end");
+ actSub[3].Text = Loc.T("device.strata.at_bar_end");
int active = mode switch { M_Rec => 0, M_Over => 1, M_Play => 2, M_Stop => 3, _ => -1 };
for (int i = 0; i < 4; i++)
{
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/UtilityDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/UtilityDeviceBody.cs
index ea374d98..af0c1863 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/UtilityDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/UtilityDeviceBody.cs
@@ -108,8 +108,8 @@ internal sealed class UtilityDeviceBody : IDeviceBody
int MeterI() => Idx(Meter);
string Unit() => Units[MeterI()];
string MonoF(double v) => On(MonoBelow) ? HzF(v) : "off";
- string PhaseText() => On(InvertL) && On(InvertR) ? Loc.T("both phases inverted") : On(InvertL) ? "phase L inverted" : On(InvertR) ? "phase R inverted" : "phase normal";
- string MonoText() => On(MonoBelow) ? NotaNum.F($"mono below {HzF(P(MonoFreq))}") : Loc.T("bass mono off");
+ string PhaseText() => On(InvertL) && On(InvertR) ? Loc.T("device.utility.both_phases_inverted") : On(InvertL) ? "phase L inverted" : On(InvertR) ? "phase R inverted" : "phase normal";
+ string MonoText() => On(MonoBelow) ? NotaNum.F($"mono below {HzF(P(MonoFreq))}") : Loc.T("device.utility.bass_mono_off");
string BalanceText()
{
double b = Sc(S_EnergyBal);
@@ -119,7 +119,7 @@ internal sealed class UtilityDeviceBody : IDeviceBody
{
double c = Sc(S_Corr);
if (Sc(S_OutPk) < 1e-4) return "no signal";
- if (c < 0) return Loc.T("out of phase — mono risk");
+ if (c < 0) return Loc.T("device.utility.out_of_phase_mono_risk");
if (c < 0.3) return "wide — check in mono";
return P(Width_) > 100.5 ? "wider, still in phase" : "in phase";
}
@@ -300,8 +300,8 @@ internal sealed class UtilityDeviceBody : IDeviceBody
SetP(Gain, 0f);
engine.DeviceAction(track, di, 1, 0, 0);
}
- string GainMatchTip = Loc.T("Gain match — moves Gain once so the output meets the reference (the input's level, or Target) over the last 3 s, in the meter's unit");
- string ResetTip = Loc.T("Reset — Gain back to 0 dB, and the meters, holds and the level history start over");
+ string GainMatchTip = Loc.T("device.utility.gain_match_moves_gain_once");
+ string ResetTip = Loc.T("device.utility.reset_gain_back_to_0");
// ======================================================================
// LEFT — Level column (input · output)
@@ -312,8 +312,8 @@ internal sealed class UtilityDeviceBody : IDeviceBody
var outMeter = MeterBar(Teal);
var levelIn = Mono("", 7, TextPrimary); levelIn.HorizontalAlignment = HorizontalAlignment.Center;
var levelOut = Mono("", 7, TextPrimary); levelOut.HorizontalAlignment = HorizontalAlignment.Center;
- ToolTip.SetTip(levelIn, Loc.T("The input's level in the meter's unit (LUFS-S, 1 s peak or 300 ms RMS)"));
- ToolTip.SetTip(levelOut, Loc.T("The output's level in the meter's unit"));
+ ToolTip.SetTip(levelIn, Loc.T("device.utility.the_inputs_level_in_the"));
+ ToolTip.SetTip(levelOut, Loc.T("device.utility.the_outputs_level_in_the"));
static double MeterN(double lin) => lin > 1e-6 ? Math.Clamp((20 * Math.Log10(lin) + 60) / 60, 0, 1) : 0;
readouts.Add(() =>
{
@@ -331,8 +331,8 @@ internal sealed class UtilityDeviceBody : IDeviceBody
return d;
}
var meters = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto"), ColumnSpacing = 9, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 4, 0, 4) };
- meters.Children.Add(MeterCell(inMeter, "IN", Loc.T("Input peak, −60 … 0 dBFS")));
- meters.Children.Add(Col(MeterCell(outMeter, "OUT", Loc.T("Output peak, −60 … 0 dBFS")), 1));
+ meters.Children.Add(MeterCell(inMeter, "IN", Loc.T("device.utility.input_peak_60_0_dbfs")));
+ meters.Children.Add(Col(MeterCell(outMeter, "OUT", Loc.T("device.utility.output_peak_60_0_dbfs")), 1));
var levelCol = new RuleSection
{
Width = 56, Padding = new Thickness(0, 5, 0, 4),
@@ -341,7 +341,7 @@ internal sealed class UtilityDeviceBody : IDeviceBody
DockPanel.SetDock(levelCol, Dock.Left);
Control WidthModeSeg() => Seg(WidthMode, new[] { "L/R", "M/S" },
- Loc.T("Width law — L/R: the side is scaled, so wider is louder; M/S: mid and side are traded, so the level holds (200 % = side only)"));
+ Loc.T("device.utility.width_law_l_r_the"));
// ======================================================================
// CENTRE — Field
@@ -356,12 +356,12 @@ internal sealed class UtilityDeviceBody : IDeviceBody
field.DragV += v => SetN(Width_, v);
field.GestureBegin += () => { Begin(Balance); Begin(Width_); };
field.GestureEnd += () => { End(Balance); End(Width_); };
- ToolTip.SetTip(field, Loc.T("The output's stereo field by frequency over the last second — lows at the bottom, highs at the top. Solid: where each band sits between L and R; teal: how far it spreads; dashed: how far the width setting spreads an uncorrelated band. Drag sideways for the balance, up or down for the width."));
+ ToolTip.SetTip(field, Loc.T("device.utility.the_outputs_stereo_field_by"));
Learn(field, Width_);
var corr = Mono("", 7, TextTertiary);
readouts.Add(() => corr.Text = "corr " + CorrF(Sc(S_Corr)));
- var chips = IndexChips(ChannelMode, Modes, Loc.T("Channel — Stereo; Left or Right on both sides; Swap the sides"));
+ var chips = IndexChips(ChannelMode, Modes, Loc.T("device.utility.channel_stereo_left_or_right"));
var head = HeadRow(Row(6, Caps("CHANNEL"), chips, WidthModeSeg()), corr);
var knobs = KnobRow(new[]
{
@@ -388,19 +388,19 @@ internal sealed class UtilityDeviceBody : IDeviceBody
widthView.DragV += v => SetN(Width_, v);
widthView.GestureBegin += () => { Begin(MonoFreq); Begin(Width_); };
widthView.GestureEnd += () => { End(MonoFreq); End(Width_); };
- ToolTip.SetTip(widthView, Loc.T("The width over frequency — solid: what the settings do (0 % = mono, 100 % = unchanged), the mono region shaded; teal dashed: the output's measured width (side against mid). Drag sideways for the mono cutoff, up or down for the width."));
+ ToolTip.SetTip(widthView, Loc.T("device.utility.the_width_over_frequency_solid"));
Learn(widthView, MonoFreq);
var wv = Mono("", 7, TextSecondary);
readouts.Add(() => wv.Text = NotaNum.F($"width {Sc(S_EffWidth):0}"));
- var onOff = ToggleLatch(MonoBelow, () => On(MonoBelow) ? "On" : "Off", Loc.T("Mono below — removes the side below the cutoff, so the low end is mono"));
+ var onOff = ToggleLatch(MonoBelow, () => On(MonoBelow) ? "On" : "Off", Loc.T("device.utility.mono_below_removes_the_side"));
float[] quick = { 60, 120, 240 };
var quickSeg = Segments(new[] { "60", "120", "240" }, () => NearestHz(P(MonoFreq), quick), iv => { SetP(MonoFreq, quick[iv]); if (!On(MonoBelow)) SetP(MonoBelow, 1f); RefreshAll(); }, out var qSync, padX: 6);
readouts.Add(qSync);
- ToolTip.SetTip(quickSeg, Loc.T("The usual cutoffs — 60, 120 or 240 Hz (turns Mono below on)"));
+ ToolTip.SetTip(quickSeg, Loc.T("device.utility.the_usual_cutoffs_60_120"));
Learn(quickSeg, MonoFreq);
var slope = Latch(MonoSlope, () => Idx(MonoSlope) > 0, () => SetP(MonoSlope, (Idx(MonoSlope) + 1) % 3),
- () => NotaNum.F($"Slope {Slopes[Idx(MonoSlope)]}"), Loc.T("Slope of the mono cutoff — 6, 12 or 24 dB/oct; click to step"));
+ () => NotaNum.F($"Slope {Slopes[Idx(MonoSlope)]}"), Loc.T("device.utility.slope_of_the_mono_cutoff"));
var head = HeadRow(Row(6, Caps("MONO"), onOff, quickSeg, WidthModeSeg(), slope), wv);
var knobs = KnobRow(new[]
{
@@ -425,12 +425,12 @@ internal sealed class UtilityDeviceBody : IDeviceBody
levelView.DragV += v => SetN(Target, v);
levelView.GestureBegin += () => Begin(Target);
levelView.GestureEnd += () => End(Target);
- ToolTip.SetTip(levelView, Loc.T("Input (teal) and output (neutral ink) over the last 8 s in the meter's unit; dashed: the target. Drag up or down for the target."));
+ ToolTip.SetTip(levelView, Loc.T("device.utility.input_teal_and_output_neutral"));
Learn(levelView, Target);
var delta = Mono("", 7, TextSecondary);
readouts.Add(() => delta.Text = DeltaText());
- var chips = IndexChips(Meter, Meters, Loc.T("Meter — LUFS-S: short-term loudness (3 s, K-weighted); Peak: sample peak; RMS: 300 ms"));
+ var chips = IndexChips(Meter, Meters, Loc.T("device.utility.meter_lufs_s_short_term"));
var head = HeadRow(Row(6, Caps("METER"), chips, Button("Gain match", GainMatch, GainMatchTip, true), Button("Reset", ResetLevels, ResetTip, false)), delta);
var knobs = KnobRow(new[]
{
@@ -467,9 +467,9 @@ internal sealed class UtilityDeviceBody : IDeviceBody
Control RoutingTab()
{
var phase = Row(3,
- ToggleLatch(InvertL, () => "Ø L", Loc.T("Invert the left channel's phase"), h: 15, padX: 6),
- ToggleLatch(InvertR, () => "Ø R", Loc.T("Invert the right channel's phase"), h: 15, padX: 6),
- ToggleLatch(Mute, () => "Mute", Loc.T("Mute the output"), h: 15, padX: 6));
+ ToggleLatch(InvertL, () => "Ø L", Loc.T("device.utility.invert_the_left_channels_phase"), h: 15, padX: 6),
+ ToggleLatch(InvertR, () => "Ø R", Loc.T("device.utility.invert_the_right_channels_phase"), h: 15, padX: 6),
+ ToggleLatch(Mute, () => "Mute", Loc.T("device.utility.mute_the_output"), h: 15, padX: 6));
// Mono on: WIDTH · MONO f | BALANCE; off: WIDTH · BALANCE | GAIN — the mockup's two states.
var monoRow = SliderRow("Mono f", MonoFreq, HzF);
var balA = SliderRow("BALANCE", Balance, v => NotaNum.F($"{v:+0.00;−0.00;0.00}"), bipolar: true);
@@ -485,7 +485,7 @@ internal sealed class UtilityDeviceBody : IDeviceBody
corrText.TextTrimming = TextTrimming.CharacterEllipsis;
var corrBox = new Border { Background = Sunken, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Badge, Padding = new Thickness(6, 4),
Child = new StackPanel { Spacing = 3, Children = { corrTitle, corrBar, corrText } } };
- ToolTip.SetTip(corrBox, Loc.T("Output correlation — +1 mono, 0 unrelated, below 0 out of phase (it cancels in mono)"));
+ ToolTip.SetTip(corrBox, Loc.T("device.utility.output_correlation_1_mono_0"));
readouts.Add(() =>
{
double c = Sc(S_Corr);
@@ -503,7 +503,7 @@ internal sealed class UtilityDeviceBody : IDeviceBody
Divided(slot3),
corrBox,
new StackPanel { Spacing = 5, Children = {
- Toggle(MonoBelow, Loc.T("Mono below freq"), () => On(MonoBelow) ? NotaNum.F($"Mono below {HzF(P(MonoFreq))}") : Loc.T("Mono below freq")),
+ Toggle(MonoBelow, Loc.T("device.utility.mono_below_freq"), () => On(MonoBelow) ? NotaNum.F($"Mono below {HzF(P(MonoFreq))}") : Loc.T("device.utility.mono_below_freq")),
Toggle(AutoMatch, "Level match", () => On(AutoMatch) ? NotaNum.F($"Level match {Sc(S_AutoDb):+0.0;−0.0;0.0} dB") : "Level match") } });
}
@@ -527,7 +527,7 @@ internal sealed class UtilityDeviceBody : IDeviceBody
Line("out", () => NotaNum.F($"{LvlF(ScDb(S_OutLevel))} {Unit()}")),
Line("true peak", () => NotaNum.F($"{LvlF(ScDb(S_TruePeak))} dBTP"), TextPrimary) } },
};
- var matchTo = Seg(MatchTo, new[] { "Input", "Target" }, Loc.T("What Gain match and Level match aim for — the input's level, or Target"));
+ var matchTo = Seg(MatchTo, new[] { "Input", "Target" }, Loc.T("device.utility.what_gain_match_and_level"));
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
var gm = Button("Gain match", GainMatch, GainMatchTip, false);
((TextBlock)gm.Child!).FontWeight = FontWeight.SemiBold;
@@ -560,7 +560,7 @@ internal sealed class UtilityDeviceBody : IDeviceBody
{
1 => NotaNum.F($"width by frequency · {(On(WidthMode) ? "M/S" : "L/R")}"),
2 => NotaNum.F($"{Sc(S_HistSec):0} s window · {Meters[MeterI()]}"),
- _ => Loc.T("pan by frequency · 1 s window"),
+ _ => Loc.T("device.utility.pan_by_frequency_1_s"),
};
});
Control CentreBody(int t) => centreBodies[t] ??= t switch { 1 => MonoTab(), 2 => LevelsTab(), _ => FieldTab() };
@@ -595,7 +595,7 @@ internal sealed class UtilityDeviceBody : IDeviceBody
parts.Add(Meters[MeterI()]);
parts.Add("in " + LvlF(ScDb(S_InLevel)));
parts.Add("out " + LvlF(ScDb(S_OutLevel)));
- parts.Add(On(MatchTo) ? NotaNum.F($"target {P(Target):0.0}") : Loc.T("match to input"));
+ parts.Add(On(MatchTo) ? NotaNum.F($"target {P(Target):0.0}") : Loc.T("device.utility.match_to_input"));
parts.Add("gain " + GainF(P(Gain)));
if (On(AutoMatch)) parts.Add(NotaNum.F($"auto {Sc(S_AutoDb):+0.0;−0.0;0.0} dB"));
if (On(TpLimit)) parts.Add("TP " + CeilF(P(TpCeiling)));
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/ValveDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/ValveDeviceBody.cs
index 80cc8eeb..fb5aa37e 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/ValveDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/ValveDeviceBody.cs
@@ -259,8 +259,8 @@ internal sealed class ValveDeviceBody : IDeviceBody
};
return box;
}
- Control ModelDrop() => Drop(Model, Models, Loc.T("Model — the amp's voicing: how hard the preamp drives, how many stages clip, how tight the low end is and which cabinet it matches. Scroll to step."));
- Control CabDrop() => Drop(CabType, Cabs, Loc.T("Cabinet — Match follows the model; the others bring their own low resonance and presence peak. Scroll to step."));
+ Control ModelDrop() => Drop(Model, Models, Loc.T("device.valve.model_the_amps_voicing_how"));
+ Control CabDrop() => Drop(CabType, Cabs, Loc.T("device.valve.cabinet_match_follows_the_model_2"));
static Grid HeadRow(Control left, Control right)
{
@@ -309,8 +309,8 @@ internal sealed class ValveDeviceBody : IDeviceBody
stageTitle.Foreground = Sc(S_InPk) > 0.01 ? AccentBright : TextTertiary; // lit while signal passes
});
var faders = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto"), ColumnSpacing = 9, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 4, 0, 4) };
- faders.Children.Add(StageFader(Gain, "GAIN", NotaPalette.VizInk, Loc.T("Gain — how hard the signal hits the preamp. Double-click resets.")));
- faders.Children.Add(Col(StageFader(Output, "OUT", Teal, Loc.T("Output — the master level after the cabinet, ±12 dB. Double-click resets.")), 1));
+ faders.Children.Add(StageFader(Gain, "GAIN", NotaPalette.VizInk, Loc.T("device.valve.gain_how_hard_the_signal")));
+ faders.Children.Add(Col(StageFader(Output, "OUT", Teal, Loc.T("device.valve.output_the_master_level_after")), 1));
var stageCol = new RuleSection
{
Width = 56, Padding = new Thickness(0, 5, 0, 4),
@@ -331,7 +331,7 @@ internal sealed class ValveDeviceBody : IDeviceBody
toneView.DragH += v => Raw(MidFreq, (float)v);
toneView.GestureBegin += () => { Begin(Middle); Begin(MidFreq); };
toneView.GestureEnd += () => { End(Middle); End(MidFreq); };
- ToolTip.SetTip(toneView, Loc.T("The tone stack before the cabinet — the pre-distortion tightness of the model, Bright, Bass / Middle / Treble / Presence and Deep; dashed is the stack flat. Drag sideways for the middle's frequency, up or down for the middle."));
+ ToolTip.SetTip(toneView, Loc.T("device.valve.the_tone_stack_before_the"));
Learn(toneView, Middle);
var thd = Mono("", 7, TextTertiary);
@@ -365,15 +365,15 @@ internal sealed class ValveDeviceBody : IDeviceBody
cabView.DragV += v => Raw(MicDistance, (float)(1 - v));
cabView.GestureBegin += () => { Begin(Axis); Begin(MicDistance); };
cabView.GestureEnd += () => { End(Axis); End(MicDistance); };
- ToolTip.SetTip(cabView, Loc.T("The cabinet as the mic hears it, with the low / high cuts — dashed is the same cab and mic on axis at the cap, 5 cm away. Drag sideways to move the mic off axis, up to bring it closer."));
+ ToolTip.SetTip(cabView, Loc.T("device.valve.the_cabinet_as_the_mic"));
Learn(cabView, Axis);
var loss = Mono("", 7, TextSecondary);
readouts.Add(() => loss.Text = On(CabOn) ? NotaNum.F($"{Sc(S_CabLossDb):+0.0;−0.0;0.0} dB @ 4 k") : "cabinet off");
var mics = IndexChips(Mic, Mics);
- ToolTip.SetTip(mics, Loc.T("Mic — Dynamic: the classic close mic; Condenser: brighter, less proximity bass; Ribbon: dark, the most proximity bass"));
+ ToolTip.SetTip(mics, Loc.T("device.valve.mic_dynamic_the_classic_close"));
var pos = Seg(MicPosition, new[] { "Cap", "Edge" });
- ToolTip.SetTip(pos, Loc.T("Mic position — at the cone's cap (bright) or its edge (darker)"));
+ ToolTip.SetTip(pos, Loc.T("device.valve.mic_position_at_the_cones"));
var head = HeadRow(Row(6, Caps("CAB"), CabDrop(), mics, pos), loss);
var knobs = KnobRow(new[]
{
@@ -398,12 +398,12 @@ internal sealed class ValveDeviceBody : IDeviceBody
harm.DragV += v => RawN(Gain, v);
harm.GestureBegin += () => Begin(Gain);
harm.GestureEnd += () => End(Gain);
- ToolTip.SetTip(harm, Loc.T("The harmonics the preamp adds at the input's level (the fundamental at the top). Drag up or down for the gain."));
+ ToolTip.SetTip(harm, Loc.T("device.valve.the_harmonics_the_preamp_adds"));
Learn(harm, Gain);
var peak = Mono("", 7, TextSecondary);
readouts.Add(() => peak.Text = DbfsF(Sc(S_OutPk)));
- var even = ToggleLatch(EvenOnly, () => "Even only", Loc.T("Even only — the preamp adds even harmonics only: warmth without the fizz of the odd ones"));
+ var even = ToggleLatch(EvenOnly, () => "Even only", Loc.T("device.valve.even_only_the_preamp_adds"));
var head = HeadRow(Row(6, Caps("MODEL"), ModelDrop(), new Border { Width = 4 }, Acr("OS"), Seg(OS, OsNames), even), peak);
var knobs = KnobRow(new[]
{
@@ -471,7 +471,7 @@ internal sealed class ValveDeviceBody : IDeviceBody
Control CabinetTab()
{
var cabs = IndexChips(CabType, CabShort, h: 15, padX: 3);
- ToolTip.SetTip(cabs, Loc.T("Cabinet — Match follows the model; 1×12 open, 2×12 combo, 4×12 closed, 1×15 bass"));
+ ToolTip.SetTip(cabs, Loc.T("device.valve.cabinet_match_follows_the_model"));
var mics = IndexChips(Mic, Mics, h: 15, padX: 6);
return Spread(
LabelRow("CAB", cabs, 26),
@@ -482,7 +482,7 @@ internal sealed class ValveDeviceBody : IDeviceBody
() => centreTab == 1 ? NotaNum.F($"{Cabs[Idx(CabType)]} · {Mics[Idx(Mic)]}") : NotaNum.F($"{ModelName()} · gain {Ten(P(Gain))}"),
() => centreTab == 1
? (On(CabOn) ? NotaNum.F($"{DistF(P(MicDistance))} · {AxisText()} · {(On(MicPosition) ? "edge" : "cap")}") : "cabinet off")
- : (On(CabOn) ? (Idx(CabType) == 0 ? Loc.T("cab by model · ") : CabShort[Idx(CabType)] + " · ") + NotaNum.F($"{Mics[Idx(Mic)].ToLowerInvariant()} {AxisText()}") : "no cabinet"),
+ : (On(CabOn) ? (Idx(CabType) == 0 ? Loc.T("device.valve.cab_by_model") : CabShort[Idx(CabType)] + " · ") + NotaNum.F($"{Mics[Idx(Mic)].ToLowerInvariant()} {AxisText()}") : "no cabinet"),
() => centreTab == 1 && On(CabOn)),
new StackPanel { Spacing = 5, Children = {
Toggle(CabOn, "Cabinet sim"),
@@ -514,12 +514,12 @@ internal sealed class ValveDeviceBody : IDeviceBody
SliderRow("GATE", Gate, GateF, modulation: true),
SliderRow("OUTPUT", Output, OutDb, bipolar: true) } };
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
- btns.Children.Add(ToggleLatch(Bright, () => "Bright", Loc.T("Bright — a treble lift before the preamp, strongest at low gain (the bright cap on a volume pot)"), fill: true));
- btns.Children.Add(Col(ToggleLatch(Deep, () => "Deep", Loc.T("Deep — a low resonance boost after the tone stack, for a fuller, tighter bottom"), fill: true), 1));
+ btns.Children.Add(ToggleLatch(Bright, () => "Bright", Loc.T("device.valve.bright_a_treble_lift_before"), fill: true));
+ btns.Children.Add(Col(ToggleLatch(Deep, () => "Deep", Loc.T("device.valve.deep_a_low_resonance_boost"), fill: true), 1));
var body = new DockPanel { LastChildFill = false, Children = {
Docked(box, Dock.Top),
Docked(new Border { Margin = new Thickness(0, 7, 0, 0), Child = sliders }, Dock.Top),
- Docked(new StackPanel { Spacing = 5, Children = { Toggle(AutoComp, "Auto-compensation", () => On(AutoComp) ? NotaNum.F($"Auto-comp {Sc(S_CompDb):+0.0;−0.0;0.0} dB") : "Auto-compensation"), Toggle(EvenOnly, Loc.T("Even harmonics only")) } }, Dock.Bottom),
+ Docked(new StackPanel { Spacing = 5, Children = { Toggle(AutoComp, "Auto-compensation", () => On(AutoComp) ? NotaNum.F($"Auto-comp {Sc(S_CompDb):+0.0;−0.0;0.0} dB") : "Auto-compensation"), Toggle(EvenOnly, Loc.T("device.valve.even_harmonics_only")) } }, Dock.Bottom),
Docked(new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 5), Child = btns }, Dock.Bottom) } };
return new Border { Padding = new Thickness(8, 6), Child = body };
}
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/VintageDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/VintageDeviceBody.cs
index b28ad338..019dfc66 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/VintageDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/VintageDeviceBody.cs
@@ -222,7 +222,7 @@ internal sealed class VintageDeviceBody : IDeviceBody
Child = new DockPanel { Children = { Docked(new Glyph(GlyphKind.ChevronDown, 7) { Foreground = TextTertiary, Margin = new Thickness(6, 0, 0, 0) }, Dock.Right), name } },
};
readouts.Add(() => name.Text = ModeName());
- ToolTip.SetTip(box, Loc.T("Character — the era the signal passes through: its saturation, tone, band-limit and how much hiss, crackle, wow and flutter it brings. Scroll to step."));
+ ToolTip.SetTip(box, Loc.T("device.vintage.character_the_era_the_signal"));
Learn(box, Mode);
box.PointerPressed += (_, e) =>
{
@@ -298,8 +298,8 @@ internal sealed class VintageDeviceBody : IDeviceBody
stateTitle.Foreground = Sc(S_InPk) > 0.01 ? AccentBright : TextTertiary; // lit while signal passes
});
var faders = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto"), ColumnSpacing = 9, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 4, 0, 4) };
- faders.Children.Add(StateFader(Drive, "DRV", NotaPalette.VizInk, Pct, Loc.T("Drive — how hard the signal hits the saturation. ⌥-click types, double-click resets.")));
- faders.Children.Add(Col(StateFader(Wear, "WEAR", Teal, Pct, Loc.T("Wear — the age of the medium: a narrower band, more hiss and crackle, a wandering flutter. ⌥-click types, double-click resets.")), 1));
+ faders.Children.Add(StateFader(Drive, "DRV", NotaPalette.VizInk, Pct, Loc.T("device.vintage.drive_how_hard_the_signal")));
+ faders.Children.Add(Col(StateFader(Wear, "WEAR", Teal, Pct, Loc.T("device.vintage.wear_the_age_of_the")), 1));
var stateCol = new RuleSection
{
Width = 56, Padding = new Thickness(0, 5, 0, 4),
@@ -318,7 +318,7 @@ internal sealed class VintageDeviceBody : IDeviceBody
curve.DragV += v => Raw(Drive, (float)v);
curve.GestureBegin += () => Begin(Drive);
curve.GestureEnd += () => End(Drive);
- ToolTip.SetTip(curve, MenuKit.Keys(Loc.T("The transfer curve the saturation runs — input level across, output up; dashed is the dry line, teal what you hear with Mix and Output, the dot where the input peak sits. Drag up or down for the drive, ⌥-click to type it.")));
+ ToolTip.SetTip(curve, MenuKit.Keys(Loc.T("device.vintage.the_transfer_curve_the_saturation")));
ValueEntry.AttachAll(curve, F(Drive, "Drive", Pct));
Learn(curve, Drive);
@@ -357,7 +357,7 @@ internal sealed class VintageDeviceBody : IDeviceBody
wearView.DragH += v => Raw(wearShow == 1 ? FlutterRate : WowRate, (float)v);
wearView.GestureBegin += () => { Begin(Wow); Begin(Flutter); Begin(WowRate); Begin(FlutterRate); };
wearView.GestureEnd += () => { End(Wow); End(Flutter); End(WowRate); End(FlutterRate); };
- ToolTip.SetTip(wearView, MenuKit.Keys(Loc.T("The pitch drift over the last four seconds — wow in neutral ink, flutter in teal. Drag up or down for the depth of what is picked above, sideways for its rate; ⌥-click to type them.")));
+ ToolTip.SetTip(wearView, MenuKit.Keys(Loc.T("device.vintage.the_pitch_drift_over_the")));
ValueEntry.AttachAll(wearView,
new ValueField("Depth", () => P(wearShow == 1 ? Flutter : Wow), Pct, v => Raw(wearShow == 1 ? Flutter : Wow, (float)v),
() => Begin(wearShow == 1 ? Flutter : Wow), () => End(wearShow == 1 ? Flutter : Wow)) { After = RefreshAll },
@@ -367,10 +367,10 @@ internal sealed class VintageDeviceBody : IDeviceBody
Learn(wearView, Wow);
var show = Chips(new[] { "Wow", "Flutter", "Both" }, i => wearShow == i, i => wearShow = i, -1);
- ToolTip.SetTip(show, Loc.T("What the window shows and a drag in it edits"));
+ ToolTip.SetTip(show, Loc.T("device.vintage.what_the_window_shows_and"));
var sync = Latch(WowSync, () => On(WowSync), () => SetP(WowSync, On(WowSync) ? 0f : 1f),
() => Synced() ? "Sync " + SyncNames[Sel(WowRate, 6)] : "Sync off",
- Loc.T("Sync — the wow follows the tempo: one sway every 4 bars … 1/8 (RATE picks it)"));
+ Loc.T("device.vintage.sync_the_wow_follows_the"));
var drift = Mono("", 7, TextSecondary);
readouts.Add(() => drift.Text = "drift " + HzF(WowHz()));
var head = HeadRow(Row(6, Caps("CHAR"), CharDrop(), show, sync), drift);
@@ -408,14 +408,14 @@ internal sealed class VintageDeviceBody : IDeviceBody
harm.DragV += v => Raw(Drive, (float)v);
harm.GestureBegin += () => Begin(Drive);
harm.GestureEnd += () => End(Drive);
- ToolTip.SetTip(harm, MenuKit.Keys(Loc.T("The harmonics the saturation adds at the input's level (the fundamental at the top), against the hiss floor in teal. Drag up or down for the drive, ⌥-click to type it.")));
+ ToolTip.SetTip(harm, MenuKit.Keys(Loc.T("device.vintage.the_harmonics_the_saturation_adds")));
ValueEntry.AttachAll(harm, F(Drive, "Drive", Pct));
Learn(harm, Drive);
var peak = Mono("", 7, TextSecondary);
readouts.Add(() => peak.Text = DbfsF(Sc(S_OutPk)));
var comp = ToggleLatch(AutoComp, () => Sc(S_CompDb) != 0 && On(AutoComp) ? NotaNum.F($"Auto-comp {Sc(S_CompDb):+0.0;−0.0;0.0}") : "Auto-comp",
- Loc.T("Auto-comp — the output level follows the input's, however hard the drive"));
+ Loc.T("device.vintage.auto_comp_the_output_level"));
var head = HeadRow(Row(6, Caps("CHAR"), CharDrop(), new Border { Width = 4 }, Acr("OS"), Seg(OS, OsNames), comp), peak);
var knobs = KnobRow(new[]
{
@@ -460,7 +460,7 @@ internal sealed class VintageDeviceBody : IDeviceBody
Control ModelRow()
{
var chips = Chips(new[] { "Warm", "Flat", "Dark" }, i => Sel(ToneModel, 3) == i, i => SetP(ToneModel, i / 2f), ToneModel, h: 15, padX: 6);
- ToolTip.SetTip(chips, Loc.T("Tone model — Warm: the era's own tilt and head bump; Flat: the TONE knob alone; Dark: a lower, darker tilt"));
+ ToolTip.SetTip(chips, Loc.T("device.vintage.tone_model_warm_the_eras"));
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("40,*") };
g.Children.Add(Caps("MODEL")); g.Children.Add(Col(chips, 1));
return g;
@@ -495,7 +495,7 @@ internal sealed class VintageDeviceBody : IDeviceBody
Box("WEAR", () => NotaNum.F($"{CentsF(Sc(S_WowCents) + Sc(S_FlutCents))} · peak drift"),
() => NotaNum.F($"wow {Pct(P(Wow))} + flutter {Pct(P(Flutter))}"), () => P(Wow) + P(Flutter) > 0.01f),
new StackPanel { Spacing = 5, Children = {
- Toggle(WearFollow, Loc.T("Wear follows input")),
+ Toggle(WearFollow, Loc.T("device.vintage.wear_follows_input")),
Toggle(StereoDrift, "Stereo drift") } });
Control ToneTab()
{
@@ -536,13 +536,13 @@ internal sealed class VintageDeviceBody : IDeviceBody
// Output stage: Tube / Analog, a click on the lit one switches the stage off.
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
btns.Children.Add(Latch(OutputStage, () => Sel(OutputStage, 3) == 1, () => SetP(OutputStage, Sel(OutputStage, 3) == 1 ? 0f : 0.5f), () => "Tube",
- Loc.T("Tube stage — a warm, asymmetric valve stage after the saturation (click again for none)"), fill: true));
+ Loc.T("device.vintage.tube_stage_a_warm_asymmetric"), fill: true));
btns.Children.Add(Col(Latch(OutputStage, () => Sel(OutputStage, 3) == 2, () => SetP(OutputStage, Sel(OutputStage, 3) == 2 ? 0f : 1f), () => "Analog",
- Loc.T("Analog stage — a console-style soft clip after the saturation (click again for none)"), fill: true), 1));
+ Loc.T("device.vintage.analog_stage_a_console_style"), fill: true), 1));
var body = new DockPanel { LastChildFill = false, Children = {
Docked(box, Dock.Top),
Docked(new Border { Margin = new Thickness(0, 7, 0, 0), Child = sliders }, Dock.Top),
- Docked(new StackPanel { Spacing = 5, Children = { Toggle(AutoComp, "Auto-compensation"), Toggle(EvenOnly, Loc.T("Even harmonics only")) } }, Dock.Bottom),
+ Docked(new StackPanel { Spacing = 5, Children = { Toggle(AutoComp, "Auto-compensation"), Toggle(EvenOnly, Loc.T("device.vintage.even_harmonics_only")) } }, Dock.Bottom),
Docked(new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 5), Child = btns }, Dock.Bottom) } };
return new Border { Padding = new Thickness(8, 6), Child = body };
}
diff --git a/src/managed/Nota.App/DeviceCards/Bodies/VocoderDeviceBody.cs b/src/managed/Nota.App/DeviceCards/Bodies/VocoderDeviceBody.cs
index 967c0c5a..8052a346 100644
--- a/src/managed/Nota.App/DeviceCards/Bodies/VocoderDeviceBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Bodies/VocoderDeviceBody.cs
@@ -162,16 +162,16 @@ internal sealed class VocoderDeviceBody : IDeviceBody
{
Text = "This track", FontSize = NotaType.RowLabel, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center,
};
- ToolTip.SetTip(modWhat, Loc.T("The modulator is the sound of the track the vocoder sits on — the voice"));
- var modGain = Slider("Gain", ModGain, v => DbF((v - 0.5) * 48), Loc.T("Mod gain — trims the voice before the bands hear it, ±24 dB"),
+ ToolTip.SetTip(modWhat, Loc.T("device.vocoder.the_modulator_is_the_sound"));
+ var modGain = Slider("Gain", ModGain, v => DbF((v - 0.5) * 48), Loc.T("device.vocoder.mod_gain_trims_the_voice"),
bipolar: true);
- var keyMeter = Meter("Key", out var keyRow, Loc.T("The voice's level after Mod gain"));
+ var keyMeter = Meter("Key", out var keyRow, Loc.T("device.vocoder.the_voices_level_after_mod"));
var carSeg = Segments(new[] { "Saw", "Noise", "Track" }, CarrierI,
i => { SetP(Carrier, i / 2.0); RefreshAll(); }, out var carSync, fill: true, padX: 0);
readouts.Add(carSync);
Learn(carSeg, Carrier);
- ToolTip.SetTip(carSeg, Loc.T("Carrier — what the voice shapes: an internal saw (at Pitch), noise, or another track picked below"));
+ ToolTip.SetTip(carSeg, Loc.T("device.vocoder.carrier_what_the_voice_shapes"));
// The tracks a carrier may come from: every other track and return, but not this track
// nor any group it sits in (their signal holds this vocoder's output — a loop).
@@ -241,20 +241,20 @@ internal sealed class VocoderDeviceBody : IDeviceBody
fly.ShowAt(picker);
e.Handled = true;
};
- ToolTip.SetTip(picker, Loc.T("Carrier track — the track the voice shapes when Carrier is Track; this track and its groups are not offered"));
+ ToolTip.SetTip(picker, Loc.T("device.vocoder.carrier_track_the_track_the"));
var tap = Segments(new[] { "Pre", "Post" }, () => engine.DeviceSidechainTapPre(track, di) ? 0 : 1,
i => { engine.SetDeviceSidechainTapPre(track, di, i == 0); ctx.NotifyChanged(); }, out var tapSync, padX: 3, fontSize: 8,
dim: () => CarrierI() != 2 || !HasTrack());
readouts.Add(tapSync);
- ToolTip.SetTip(tap, Loc.T("Where the carrier track is tapped: before its effects and fader, or after. Pre keeps feeding while the track is muted"));
+ ToolTip.SetTip(tap, Loc.T("device.vocoder.where_the_carrier_track_is"));
var trackRow = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 4 };
trackRow.Children.Add(picker);
trackRow.Children.Add(Col(tap, 1));
- var tilt = Slider("Tilt", Tilt, v => DbF((v - 0.5) * 24), Loc.T("Tilt — brightens (or darkens) the saw or the carrier track around 1 kHz before the bands, ±12 dB"),
+ var tilt = Slider("Tilt", Tilt, v => DbF((v - 0.5) * 24), Loc.T("device.vocoder.tilt_brightens_or_darkens_the"),
dim: () => CarrierI() == 1, bipolar: true);
- var pitch = Slider("Pitch", Pitch, v => NoteName(PitchOf(v) + 12), Loc.T("Pitch — the internal saw's note, C0 … C7"),
+ var pitch = Slider("Pitch", Pitch, v => NoteName(PitchOf(v) + 12), Loc.T("device.vocoder.pitch_the_internal_saws_note"),
dim: () => CarrierI() != 0, steps: 85);
var modHead = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
@@ -296,18 +296,18 @@ internal sealed class VocoderDeviceBody : IDeviceBody
};
graph.ResetRequested += edge => { Reset(edge == 0 ? Low : High); RefreshAll(); };
Learn(graph, Low);
- ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("The modulator's level in each band (bars) and the carrier's (teal). Drag an edge to move Low or High; ⌥-click an edge to type it, double-click resets it.")));
+ ToolTip.SetTip(graph, MenuKit.Keys(Loc.T("device.vocoder.the_modulators_level_in_each")));
ValueEntry.AttachHandles(graph, [ValueEntry.DeviceParam(engine, track, di, Low, "Low", v => HzF(LowHz(v)), RefreshAll)],
[ValueEntry.DeviceParam(engine, track, di, High, "High", v => HzF(HighHz(v)), RefreshAll)]);
var knobs = new UniformGrid { Rows = 1, Columns = 7, Margin = new Thickness(0, 4, 0, 0) };
- knobs.Children.Add(K(Bands, "Bands", v => BandsOf(v).ToString(NotaNum.Culture), Loc.T("Bands — how many bands, 8 … 32: fewer is more robotic, more is clearer"), steps: 25));
- knobs.Children.Add(K(Low, "Low", v => HzF(LowHz(v)), Loc.T("Low — the lowest band's edge, 20 Hz … 1 kHz")));
- knobs.Children.Add(K(High, "High", v => HzF(HighHz(v)), Loc.T("High — the highest band's edge, 2 … 20 kHz")));
- knobs.Children.Add(K(Q, "Q", v => NotaNum.F($"{1 + v * 9:0.0}"), Loc.T("Q — how narrow each band is, 1 … 10")));
- knobs.Children.Add(K(Formant, "Formant", v => StF(SemisOf(v)), Loc.T("Formant — moves the carrier's bands against the modulator's, ±12 st: up sounds smaller, down larger"), steps: 25));
- knobs.Children.Add(K(Attack, "Attack", v => MsF(ExpMap(v, 0.5, 100)), Loc.T("Attack — how fast a band opens, 0.5 … 100 ms")));
- knobs.Children.Add(K(Release, "Release", v => MsF(ExpMap(v, 5, 1000)), Loc.T("Release — how fast a band closes, 5 … 1000 ms")));
+ knobs.Children.Add(K(Bands, "Bands", v => BandsOf(v).ToString(NotaNum.Culture), Loc.T("device.vocoder.bands_how_many_bands_8"), steps: 25));
+ knobs.Children.Add(K(Low, "Low", v => HzF(LowHz(v)), Loc.T("device.vocoder.low_the_lowest_bands_edge")));
+ knobs.Children.Add(K(High, "High", v => HzF(HighHz(v)), Loc.T("device.vocoder.high_the_highest_bands_edge")));
+ knobs.Children.Add(K(Q, "Q", v => NotaNum.F($"{1 + v * 9:0.0}"), Loc.T("device.vocoder.q_how_narrow_each_band")));
+ knobs.Children.Add(K(Formant, "Formant", v => StF(SemisOf(v)), Loc.T("device.vocoder.formant_moves_the_carriers_bands"), steps: 25));
+ knobs.Children.Add(K(Attack, "Attack", v => MsF(ExpMap(v, 0.5, 100)), Loc.T("device.vocoder.attack_how_fast_a_band")));
+ knobs.Children.Add(K(Release, "Release", v => MsF(ExpMap(v, 5, 1000)), Loc.T("device.vocoder.release_how_fast_a_band")));
var centreBody = new DockPanel { LastChildFill = true };
DockPanel.SetDock(head, Dock.Top);
@@ -321,14 +321,14 @@ internal sealed class VocoderDeviceBody : IDeviceBody
// ======================================================================
// RIGHT — Output: Unvoiced · Mix · Gain · Hold · the output meter
// ======================================================================
- var unv = Slider("Unvoiced", Unvoiced, v => NotaNum.F($"{v * 100:0} %"), Loc.T("Unvoiced — adds noise where the modulator hisses, so consonants stay clear"));
- var mix = Slider("Mix", Mix, v => NotaNum.F($"{v * 100:0} %"), Loc.T("Mix — the carrier as it came in against the vocoded sound"));
- var gain = Slider("Gain", Gain, v => DbF((v - 0.5) * 24), Loc.T("Gain — the output level, ±12 dB"), bipolar: true);
+ var unv = Slider("Unvoiced", Unvoiced, v => NotaNum.F($"{v * 100:0} %"), Loc.T("device.vocoder.unvoiced_adds_noise_where_the"));
+ var mix = Slider("Mix", Mix, v => NotaNum.F($"{v * 100:0} %"), Loc.T("device.vocoder.mix_the_carrier_as_it"));
+ var gain = Slider("Gain", Gain, v => DbF((v - 0.5) * 24), Loc.T("device.vocoder.gain_the_output_level_12"), bipolar: true);
var hold = Switch("Hold", () => P(Hold) >= 0.5f, () => { SetP(Hold, P(Hold) >= 0.5f ? 0 : 1); RefreshAll(); }, out var holdSync);
readouts.Add(holdSync);
Learn(hold, Hold);
- ToolTip.SetTip(hold, Loc.T("Hold — freezes every band where it is; the carrier keeps sounding through it"));
- var outMeter = Meter("Out", out var outRow, Loc.T("The vocoder's output level"));
+ ToolTip.SetTip(hold, Loc.T("device.vocoder.hold_freezes_every_band_where"));
+ var outMeter = Meter("Out", out var outRow, Loc.T("device.vocoder.the_vocoders_output_level"));
var outBody = new Grid { RowDefinitions = new RowDefinitions("Auto,Auto,Auto,Auto,Auto,*,Auto"), RowSpacing = 6 };
outBody.Children.Add(Title("Output"));
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/AuroraInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/AuroraInstrumentCard.cs
index 02c57fd9..1912cc43 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/AuroraInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/AuroraInstrumentCard.cs
@@ -286,7 +286,7 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
bool moved = Math.Abs(G(id) - engine.InstrumentParamDefault(track, pi)) > 1e-4f;
cap.Foreground = moved && ink is null ? TextPrimary : TextTertiary;
});
- ToolTip.SetTip(cell, learn + Loc.T(" · drag to change, double-click to reset"));
+ ToolTip.SetTip(cell, learn + Loc.T("device.aurora.drag_to_change_double_click"));
MidiLearn.Bind(cell, MidiTarget.PluginParam(track, -1, pi), learn);
return cell;
}
@@ -432,7 +432,7 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
}
var oscPick = Segments(new[] { "1", "2" }, () => osel, iv => { osel = iv; Touch(); }, out var oscPickSync);
readouts.Add(oscPickSync);
- ToolTip.SetTip(oscPick, Loc.T("The oscillator whose table and warp mode this strip edits"));
+ ToolTip.SetTip(oscPick, Loc.T("device.aurora.the_oscillator_whose_table_and"));
var oscTableStack = new Panel();
foreach (var h in oscTableHosts) oscTableStack.Children.Add(h);
var oscWarpStack = new Panel();
@@ -693,7 +693,7 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
void Stop() { drag = false; if (began) { began = false; End(id); } }
cell.PointerReleased += (_, e) => { if (!drag) return; Stop(); e.Pointer.Capture(null); };
cell.PointerCaptureLost += (_, _) => { if (drag) Stop(); };
- ToolTip.SetTip(cell, Loc.F("{0} · drag or turn to change, double-click to type", field.Name));
+ ToolTip.SetTip(cell, Loc.F("device.aurora.drag_or_turn_to_change", field.Name));
}
Control EnvPanel(string title, Func<string> route, VoltEnv view, string[] ids, Func<string> summary)
@@ -791,14 +791,14 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
// The shape window follows whichever LFO you last touched — the pick doubles as
// the label, so the picture is never anonymous.
int lfoShown = 0;
- var lfoShapeCap = Cap(Loc.T("SHAPE · LFO 1"));
+ var lfoShapeCap = Cap(Loc.T("device.aurora.shape_lfo_1_caps"));
var lfoShapeSum = Mono("", TextSecondary, NotaType.Axis);
var lfoPick = Segments(new[] { "1", "2" }, () => lfoShown, iv => { lfoShown = iv; Touch(); }, out var lfoPickSync);
readouts.Add(lfoPickSync);
readouts.Add(() =>
{
string pre = lfoShown == 0 ? "lfo1" : "lfo2";
- lfoShapeCap.Text = Loc.F("Shape · LFO {0}", lfoShown + 1);
+ lfoShapeCap.Text = Loc.F("device.aurora.shape_lfo", lfoShown + 1);
lfoStrip.Set(Sel(pre + "shape", 4), LfoCycles(lfoShown), G(pre + "depth"));
lfoShapeSum.Text = $"{ShapeNames[Sel(pre + "shape", 4)]} · "
+ (SyncDiv(G(pre + "sync")) > 0 ? SyncText(G(pre + "sync")) : SlowHz(ExpMap(G(pre + "rate"), 0.05, 20)))
@@ -826,7 +826,7 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
readouts.Add(matrix.Refresh);
var modHint = new TextBlock
{
- Text = MenuKit.Keys(Loc.T("drag a cell — up adds, down subtracts · ⌥-click types · double-click clears")), FontSize = NotaType.Axis,
+ Text = MenuKit.Keys(Loc.T("device.aurora.drag_a_cell_up_adds")), FontSize = NotaType.Axis,
Foreground = TextDisabled, VerticalAlignment = VerticalAlignment.Center,
};
var modGrid = new Grid { RowDefinitions = new RowDefinitions("*,Auto"), RowSpacing = 1 };
@@ -887,9 +887,9 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
var bodies = new Control[] { oscBody, filtBody, envBody, lfoBody, modBody, fxBody };
var tabCells = new Border[TabNames.Length];
var tabTexts = new TextBlock[TabNames.Length];
- var clearAll = TextButton(Loc.T("Clear all"));
+ var clearAll = TextButton(Loc.T("common.clear_all"));
clearAll.Margin = new Thickness(0, 0, 6, 0);
- ToolTip.SetTip(clearAll, Loc.T("Zero every route in the matrix"));
+ ToolTip.SetTip(clearAll, Loc.T("device.aurora.zero_every_route_in_the"));
clearAll.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(clearAll).Properties.IsLeftButtonPressed) return;
@@ -1027,7 +1027,7 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
Cursor = new Cursor(StandardCursorType.Hand), TextTrimming = TextTrimming.CharacterEllipsis,
};
var nums = Mono("", TextSecondary, NotaType.Axis);
- ToolTip.SetTip(dest, Loc.T("Click for the next target, right-click for the previous"));
+ ToolTip.SetTip(dest, Loc.T("device.aurora.click_for_the_next_target"));
void Step(int dir)
{
int n = MacroDests.Length;
@@ -1092,7 +1092,7 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
pagerText,
},
};
- ToolTip.SetTip(pager, Loc.T("Click for the next macros, right-click for the previous"));
+ ToolTip.SetTip(pager, Loc.T("device.aurora.click_for_the_next_macros"));
pager.PointerPressed += (_, e) =>
{
var pt = e.GetCurrentPoint(pager).Properties;
@@ -1122,7 +1122,7 @@ internal sealed class AuroraInstrumentCard : IInstrumentCard
var railCount = Mono("", TextTertiary, NotaType.Axis);
railCount.HorizontalAlignment = HorizontalAlignment.Right;
railCount.Margin = new Thickness(0, 0, 7, 0);
- readouts.Add(() => railCount.Text = railTab == 1 ? Loc.F("{0} / 8 in use", MacroAssigned()) : "");
+ readouts.Add(() => railCount.Text = railTab == 1 ? Loc.F("device.aurora.8_in_use", MacroAssigned()) : "");
var railTabGrid = new Grid { Height = TabH, ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*") };
showRailTab = () =>
{
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/BassInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/BassInstrumentCard.cs
index 3c93d620..50ef5896 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/BassInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/BassInstrumentCard.cs
@@ -311,7 +311,7 @@ internal sealed class BassInstrumentCard : IInstrumentCard
bendVal.HorizontalAlignment = modVal.HorizontalAlignment = HorizontalAlignment.Center;
var pitchCap = Cap("PITCH"); pitchCap.HorizontalAlignment = HorizontalAlignment.Center;
var modCap = Cap("MOD"); modCap.HorizontalAlignment = HorizontalAlignment.Center;
- ToolTip.SetTip(modWheel, Loc.T("Mod wheel — opens the LFO onto the cutoff"));
+ ToolTip.SetTip(modWheel, Loc.T("device.bass.mod_wheel_opens_the_lfo"));
readouts.Add(() =>
{
int range = BendRange(G("bendrange"));
@@ -463,7 +463,7 @@ internal sealed class BassInstrumentCard : IInstrumentCard
// LFO: shape, rate and where it lands — cutoff and pitch — then the velocity amounts.
var lfoDest = Mono("", Teal, NotaType.Axis);
- readouts.Add(() => lfoDest.Text = G("modwheel") > 1e-3f ? Loc.T("→ cut/pitch · wheel") : "→ cut/pitch");
+ readouts.Add(() => lfoDest.Text = G("modwheel") > 1e-3f ? Loc.T("device.bass.cut_pitch_wheel") : "→ cut/pitch");
var lfoKnobs = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), VerticalAlignment = VerticalAlignment.Center };
{
var ks = new[]
@@ -568,7 +568,7 @@ internal sealed class BassInstrumentCard : IInstrumentCard
out var legatoSync, dim: () => !IsMono());
readouts.Add(legatoSync);
if (I("legato") is var lgi and >= 0) MidiLearn.Bind(legato, MidiTarget.PluginParam(track, -1, lgi), "Legato");
- ToolTip.SetTip(legato, Loc.T("Slide into a note played over a held one without a new attack"));
+ ToolTip.SetTip(legato, Loc.T("device.bass.slide_into_a_note_played"));
legato.HorizontalAlignment = HorizontalAlignment.Right;
var bendRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 5 };
bendRow.Children.Add(Cap("BEND"));
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/ConsortInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/ConsortInstrumentCard.cs
index a7ea3cca..7468db71 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/ConsortInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/ConsortInstrumentCard.cs
@@ -335,7 +335,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
foreach (var c in mine)
{
int slot = c.Slot;
- f.Items.Add(MenuKit.Danger(Loc.F("Remove {0} {1:+0;−0;0}", CableName(c), c.Depth * 100), GlyphKind.Trash, () => RemoveSlot(slot)));
+ f.Items.Add(MenuKit.Danger(Loc.F("device.consort.remove", CableName(c), c.Depth * 100), GlyphKind.Trash, () => RemoveSlot(slot)));
}
f.ShowAt(anchor, showAtPointer: true);
}
@@ -404,7 +404,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
g.Children.Add(n == 1 ? Cell(MonoText("master", 8, MutedC), 2, HorizontalAlignment.Left) : Cell(MiniKnob($"{p}freq", Freq, 38, TxtC), 2, HorizontalAlignment.Left));
g.Children.Add(Cell(WaveSel($"{p}wave"), 3));
var jd = new ConsortJackDot(11);
- ToolTip.SetTip(jd, Loc.F("Osc {0} pitch input (patch bay)", n));
+ ToolTip.SetTip(jd, Loc.F("device.consort.osc_pitch_input_patch_bay", n));
cur.Add(() => jd.Set(PatchedAt(false, 4 + n, 4)));
Control right = n == 2 ? SyncChip("o2sync", "sync→1") : n == 4 ? SyncChip("o4sync", "sync→3") : MonoText("—", 8, DimC);
g.Children.Add(Cell(Row(5, jd, right), 4, HorizontalAlignment.Right));
@@ -433,7 +433,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
mix.Children.Add(Col(MixCell("OSC 1", "mix1"), 1)); mix.Children.Add(RowAt(Col(MixCell("OSC 2", "mix2"), 1), 1));
mix.Children.Add(Col(MixCell("OSC 3", "mix3"), 2)); mix.Children.Add(RowAt(Col(MixCell("OSC 4", "mix4"), 2), 1));
mix.Children.Add(Col(MixCell("NOISE", "mixnoise"), 3)); mix.Children.Add(RowAt(Col(MixCell("EXT", "mixext"), 3), 1));
- var ext = mix.Children[^1]; ToolTip.SetTip(ext, Loc.T("EXT: normalled to the VCA output (Moog feedback) — patch Ext in to replace it"));
+ var ext = mix.Children[^1]; ToolTip.SetTip(ext, Loc.T("device.consort.ext_normalled_to_the_vca"));
mix.Children.Add(Col(Toggle("mixdrive", "Mixer drive"), 4));
mix.Children.Add(RowAt(Col(Chips("noisecolor", new[] { "White", "Pink" }), 4), 1));
return new DockPanel { LastChildFill = true, Margin = new Thickness(7, 0, 7, 3), Children = {
@@ -463,7 +463,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
knobs.Children.Add(Col(K("spacing", "SPACING", Space, false, Knob.SizeSecondary, 50), 2));
knobs.Children.Add(Col(K("fenvamt", "ENVELOPE", EnvAmt, true, Knob.SizeSecondary, 46), 3));
var j1 = new ConsortJackDot(11); var j2 = new ConsortJackDot(11);
- ToolTip.SetTip(j1, Loc.T("Filt 1 cutoff input")); ToolTip.SetTip(j2, Loc.T("Filt 2 cutoff input"));
+ ToolTip.SetTip(j1, Loc.T("device.consort.filt_1_cutoff_input")); ToolTip.SetTip(j2, Loc.T("device.consort.filt_2_cutoff_input"));
cur.Add(() => { j1.Set(PatchedAt(false, 10)); j2.Set(PatchedAt(false, 11)); });
var bottom = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto"), ColumnSpacing = 8, Height = 18 };
bottom.Children.Add(Row(5, Caps("KEYTRACK"), Chips("kbdtrk", new[] { "0", "½", "1" })));
@@ -519,7 +519,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
cur.Add(() => { int s = Sel("lfowave", 6); for (int i = 0; i < 6; i++) { bool on = i == s; chips[i].Background = on ? Amber : Brushes.Transparent; chips[i].BorderBrush = on ? Amber : NotaPalette.BorderStrong; icons[i].Stroke = on ? NotaPalette.TextOnAccent : MutedC; icons[i].InvalidateVisual(); } });
if (I("lfowave") is var pw and >= 0) MidiLearn.Bind(shapes, MidiTarget.PluginParam(track, -1, pw), "lfowave");
var jo = new ConsortJackDot(12); var jr = new ConsortJackDot(12);
- ToolTip.SetTip(jo, Loc.T("LFO out (patch bay)")); ToolTip.SetTip(jr, Loc.T("LFO rate input (patch bay)"));
+ ToolTip.SetTip(jo, Loc.T("device.consort.lfo_out_patch_bay")); ToolTip.SetTip(jr, Loc.T("device.consort.lfo_rate_input_patch_bay"));
cur.Add(() => { jo.Set(PatchedAt(true, 1)); jr.Set(PatchedAt(false, 1)); });
var head = new DockPanel { Height = 14, LastChildFill = false, Children = { Docked(Caps("LFO"), Avalonia.Controls.Dock.Left), Docked(Row(4, jo, jr), Avalonia.Controls.Dock.Right) } };
var knobs = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*,*"), Margin = new Thickness(0, 4, 0, 0) };
@@ -534,7 +534,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
if (I("lfosync") is var psync and >= 0) MidiLearn.Bind(syncT, MidiTarget.PluginParam(track, -1, psync), "Sync");
var bottom = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), Height = 18 };
bottom.Children.Add(syncT); bottom.Children.Add(Col(Chips("lfodest", new[] { "All osc", "2 + 4" }), 1));
- ToolTip.SetTip(bottom.Children[1], Loc.T("LFO pitch → all oscillators, or only 2 and 4"));
+ ToolTip.SetTip(bottom.Children[1], Loc.T("device.consort.lfo_pitch_all_oscillators_or"));
var body = new DockPanel { LastChildFill = false, Children = { Docked(head, Avalonia.Controls.Dock.Top), Docked(shapes, Avalonia.Controls.Dock.Top), Docked(knobs, Avalonia.Controls.Dock.Top), Docked(Divider(bottom, 4), Avalonia.Controls.Dock.Bottom) } };
return new Border { Width = 196, BorderBrush = BorderIn, BorderThickness = new Thickness(0, 0, 1, 0), Padding = new Thickness(7, 4), Child = body };
}
@@ -550,7 +550,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
});
var head = new DockPanel { Height = 14, LastChildFill = false, Children = { Docked(Caps(""), Avalonia.Controls.Dock.Left), Docked(times, Avalonia.Controls.Dock.Right) } };
var title = (TextBlock)head.Children[0];
- cur.Add(() => title.Text = On("dlydigital") ? "Delay · digital" : Loc.T("Analog delay · BBD"));
+ cur.Add(() => title.Text = On("dlydigital") ? "Delay · digital" : Loc.T("device.consort.analog_delay_bbd"));
var graph = new Border { Background = Inset, BorderBrush = BorderIn, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Control, Margin = new Thickness(0, 2, 0, 3), Child = view };
var knobs = Row(0, K("dlytime", "TIME", DlyMs, false, Knob.SizeSecondary, 44), K("dlyspacing", "SPACING", DlySpc, false, Knob.SizeSecondary, 44), K("dlyfb", "FEEDBACK", v => Pct(v), false, Knob.SizeSecondary, 46), K("dlymix", "MIX", v => Pct(v), false, Knob.SizeSecondary, 40));
var opts = new StackPanel { Spacing = 6, VerticalAlignment = VerticalAlignment.Center, Children = { Chips("dlyping", new[] { "Ping", "Stereo" }, new[] { 1f, 0f }), Toggle("dlydigital", "Digital") } };
@@ -578,7 +578,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
// length: a draggable number
var lenTxt = MonoText("", 9, TxtC);
var lenBox = new Border { Padding = new Thickness(3, 0), Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.SizeNorthSouth), Child = lenTxt };
- ToolTip.SetTip(lenBox, Loc.T("Sequence length — drag up / down"));
+ ToolTip.SetTip(lenBox, Loc.T("device.consort.sequence_length_drag_up_down"));
{ bool drag = false; double y0 = 0; float v0 = 0;
lenBox.PointerPressed += (_, e) => { if (!e.GetCurrentPoint(lenBox).Properties.IsLeftButtonPressed) return; drag = true; y0 = e.GetPosition(lenBox).Y; v0 = G("seqlen"); Begin("seqlen"); e.Pointer.Capture(lenBox); e.Handled = true; };
lenBox.PointerMoved += (_, e) => { if (!drag) return; float v = Math.Clamp(v0 + (float)(y0 - e.GetPosition(lenBox).Y) / 120f, 0, 1); v = (float)Math.Round(v * 15) / 15f; Raw("seqlen", v); Refresh(); };
@@ -595,14 +595,14 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
int bv = b;
var sw = new Border { Width = 9, Height = 9, CornerRadius = NotaRadius.Clip, BorderBrush = cols[b], BorderThickness = new Thickness(1), Background = b == 3 ? Inset : new SolidColorBrush(((ISolidColorBrush)cols[b]).Color, 0.35) };
var it = new Border { Background = Brushes.Transparent, Padding = new Thickness(3, 1), CornerRadius = NotaRadius.Badge, BorderThickness = new Thickness(1), Cursor = new Cursor(StandardCursorType.Hand), Child = Row(3, sw, new TextBlock { Text = names[b], FontSize = 8, Foreground = Txt2, VerticalAlignment = VerticalAlignment.Center }) };
- ToolTip.SetTip(it, Loc.F("Paint {0} steps (Alt-click a step: rest)", names[b]));
+ ToolTip.SetTip(it, Loc.F("device.consort.paint_steps_alt_click_a", names[b]));
it.PointerPressed += (_, e) => { vs.Brush = bv; Refresh(); e.Handled = true; };
legItems[b] = it; legend.Children.Add(it);
}
tabReadouts[3].Add(() => { for (int b = 0; b < 4; b++) legItems[b].BorderBrush = b == vs.Brush ? NotaPalette.AccentSubtle : Brushes.Transparent; });
List<Action> saved = cur; cur = tabReadouts[3];
var ratchet = Chips("seqratchet", new[] { "×2", "×3", "×4" });
- ToolTip.SetTip(ratchet, Loc.T("Ratchet repeats per step"));
+ ToolTip.SetTip(ratchet, Loc.T("device.consort.ratchet_repeats_per_step"));
var top = new DockPanel { Height = 16, LastChildFill = false };
top.Children.Add(Docked(Row(4, Caps("STEPS"), lenBox, MonoText("/ 16", 8, MutedC)), Avalonia.Controls.Dock.Left));
top.Children.Add(Docked(Row(8, legend, ratchet), Avalonia.Controls.Dock.Right));
@@ -631,12 +631,12 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
var laneBox = new Border { Background = Inset, BorderBrush = BorderIn, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Control, Child = lane };
var clkDot = new ConsortJackDot(12); var gateDot = new ConsortJackDot(12);
- ToolTip.SetTip(clkDot, Loc.T("Clock out (patch bay)")); ToolTip.SetTip(gateDot, Loc.T("Seq gate out (patch bay)"));
+ ToolTip.SetTip(clkDot, Loc.T("device.consort.clock_out_patch_bay")); ToolTip.SetTip(gateDot, Loc.T("device.consort.seq_gate_out_patch_bay"));
tabReadouts[3].Add(() => { clkDot.Set(PatchedAt(true, 12)); gateDot.Set(PatchedAt(true, 11, 10)); });
var swingSl = HSlider("seqswing", v => $"{50 + v * 25:0}\u2009%", 28); swingSl.Width = 84;
var rateTxt = MonoText("", 9, TxtC);
var rateBox = new Border { Background = Brushes.Transparent, Padding = new Thickness(2, 0), Cursor = new Cursor(StandardCursorType.Hand), Child = Glyph.WithChevron(rateTxt, 7) };
- ToolTip.SetTip(rateBox, Loc.T("Step rate (synced to the host tempo)"));
+ ToolTip.SetTip(rateBox, Loc.T("device.consort.step_rate_synced_to_the"));
tabReadouts[3].Add(() => rateTxt.Text = SeqRates[Sel("seqrate", SeqRates.Length)]);
rateBox.PointerPressed += (_, e) =>
{
@@ -712,7 +712,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
tabReadouts[4].Add(() => { si.Set(PatchedAt(false, 22)); so.Set(PatchedAt(true, 20)); });
var util = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 10, Height = 20, Children = {
Caps("UTIL"), Row(5, Caps("ATTEN 1"), a1), Row(5, Caps("ATTEN 2"), a2), Row(4, Caps("SUM"), si, so) } };
- ToolTip.SetTip(util, Loc.T("Attenuators scale whatever is patched into Atten 1/2 in; Sum adds its inputs"));
+ ToolTip.SetTip(util, Loc.T("device.consort.attenuators_scale_whatever_is_patched"));
return new DockPanel { LastChildFill = true, Children = { Docked(Divider(util, 3), Avalonia.Controls.Dock.Bottom), m } };
}
Control CableListView(List<Action> into)
@@ -771,7 +771,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
var field = StripField();
tabReadouts[4].Add(() => field.SetCables(CableList()));
var list = CableListView(tabReadouts[4]);
- var hint = new TextBlock { Text = Loc.T("Drag jack to jack · Alt-click to pull · right-click for a list"), FontSize = 8, Foreground = DimC, TextWrapping = TextWrapping.Wrap };
+ var hint = new TextBlock { Text = Loc.T("device.consort.drag_jack_to_jack_alt"), FontSize = 8, Foreground = DimC, TextWrapping = TextWrapping.Wrap };
var side = new DockPanel { LastChildFill = true, Children = { Docked(new Border { Margin = new Thickness(0, 0, 0, 3), Child = Caps("CABLES") }, Avalonia.Controls.Dock.Top), Docked(hint, Avalonia.Controls.Dock.Bottom), list } };
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("*,144") };
g.Children.Add(new Border { Padding = new Thickness(2, 2, 4, 0), Child = field });
@@ -800,7 +800,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
{
txt[i] = MonoText("—", 8, DimC); txt[i].HorizontalAlignment = HorizontalAlignment.Center;
cells[i] = new Border { Height = 18, Margin = new Thickness(1.5, 0), CornerRadius = NotaRadius.Badge, BorderThickness = new Thickness(1), Child = txt[i] };
- ToolTip.SetTip(cells[i], Loc.F("Oscillator {0}'s note (paraphonic) · the latest voices in true poly", i + 1));
+ ToolTip.SetTip(cells[i], Loc.F("device.consort.oscillator_s_note_paraphonic_the", i + 1));
cellRow.Children.Add(cells[i]);
}
rightReadouts[0].Add(() =>
@@ -817,7 +817,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
});
var gated = MonoText("gated", 8, DimC);
var gatedBox = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = gated, HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Center };
- ToolTip.SetTip(gatedBox, Loc.T("Gated glide: only between overlapping (legato) notes"));
+ ToolTip.SetTip(gatedBox, Loc.T("device.consort.gated_glide_only_between_overlapping"));
gatedBox.PointerPressed += (_, e) => { SetP("glidegated", On("glidegated") ? 0 : 1); Refresh(); e.Handled = true; };
rightReadouts[0].Add(() => gated.Foreground = On("glidegated") ? AmberLit : DimC);
Control Line(string cap, Control c, Control? right = null)
@@ -833,7 +833,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
Line("GLIDE", HSlider("glide", v => GlideF(v), 38)),
Line("TYPE", Chips("glidetype", new[] { "LCR", "LCT", "EXP" }), gatedBox),
new Border { Height = 1, Background = BorderIn, Margin = new Thickness(0, 3) },
- new StackPanel { Spacing = 4, Margin = new Thickness(0, 2), Children = { Toggle("multitrig", "Multi trig", Poly), Toggle("truepoly", Loc.T("True poly (16)")), Toggle("unison", "Unison detune") } },
+ new StackPanel { Spacing = 4, Margin = new Thickness(0, 2), Children = { Toggle("multitrig", "Multi trig", Poly), Toggle("truepoly", Loc.T("device.consort.true_poly_16")), Toggle("unison", "Unison detune") } },
new Border { Height = 1, Background = BorderIn, Margin = new Thickness(0, 3) },
Line("DRIFT", HSlider("drift", v => Pct(v), 30)) } };
return new Border { Padding = new Thickness(8, 5), Child = body };
@@ -875,7 +875,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
cur = tabReadouts[0];
var pwSl = HSlider("pw", v => Pct(v), 26); pwSl.Width = 84;
extras[0] = Row(6, Caps("PWM"), pwSl);
- ToolTip.SetTip(extras[0], Loc.T("Pulse width of the pulse wave (square stays 50\u2009%)"));
+ ToolTip.SetTip(extras[0], Loc.T("device.consort.pulse_width_of_the_pulse"));
cur = tabReadouts[1];
extras[1] = Chips("filtmode", new[] { "HP/LP ser", "LP/LP st", "HP/LP st" });
cur = tabReadouts[2];
@@ -884,7 +884,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
extras[2] = dlyTxt;
cur = tabReadouts[3];
extras[3] = Row(6, Chips("seqmode", new[] { "Off", "Seq", "Arp" }), Caps("OCT"), Chips("arpoct", new[] { "1", "2", "3" }, null, 7, () => Sel("seqmode", 3) != 2));
- ToolTip.SetTip(extras[3], Loc.T("Off · SEQ (steps transposed by the key) · ARP (the held chord over 1–3 octaves)"));
+ ToolTip.SetTip(extras[3], Loc.T("device.consort.off_seq_steps_transposed_by"));
cur = saved;
extras[4] = Row(6, ViewSeg(new[] { "Matrix", "Cables" }, () => vs.PatchView, v => { vs.PatchView = v; patchShow(); }), patchCountTxt);
common.Add(() => patchCountTxt.Text = $"{CableList().Count} / {Cables}");
@@ -922,7 +922,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
var countTxt = MonoText("", 8, TxtC);
var openTxt = new TextBlock { FontSize = 8, Foreground = TxtC, VerticalAlignment = VerticalAlignment.Center };
var openBtn = new Border { Height = 13, Padding = new Thickness(6, 0), CornerRadius = NotaRadius.Badge, Background = OffPill, BorderThickness = new Thickness(1), Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center, Child = openTxt };
- ToolTip.SetTip(openBtn, Loc.T("Open the full patch bay (all 42 points) · on the Patch tab: back to the last panel"));
+ ToolTip.SetTip(openBtn, Loc.T("device.consort.open_the_full_patch_bay"));
openBtn.PointerPressed += (_, e) =>
{
if (vs.Centre == 4) selectCentre(vs.LastNonPatch);
@@ -943,13 +943,13 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
var chip = Row(3, new Border { Width = 6, Height = 6, CornerRadius = NotaRadius.Badge, Background = ConsortJacks.ToneBrush(ConsortJacks.Src(c.Src).Tone), VerticalAlignment = VerticalAlignment.Center },
MonoText(CableChip(c), 8, Txt2));
chip.Background = Brushes.Transparent; chip.Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(chip, Loc.F("{0} · depth {1:+0;−0;0}", CableName(c), c.Depth * 100));
+ ToolTip.SetTip(chip, Loc.F("device.consort.depth", CableName(c), c.Depth * 100));
chip.PointerPressed += (_, e) => { selectCentre(4); e.Handled = true; };
chipsHost.Children.Add(chip);
}
if (cs.Count == 0) chipsHost.Children.Add(MonoText("no cables — the normals run the voice", 8, DimC));
}
- countTxt.Text = Loc.Plural(cs.Count, "{0} cable", "{0} cables");
+ countTxt.Text = Loc.Plural("device.consort.cables", cs.Count);
bool onPatch = vs.Centre == 4;
openTxt.Text = onPatch ? "Collapse ⌃" : "Open ⌄";
openBtn.BorderBrush = onPatch ? Amber : Brushes.Transparent;
@@ -977,7 +977,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
field.Context += JackMenu;
overlayReadouts.Add(() => field.SetCables(CableList()));
var info = MonoText("", 8, Txt2);
- overlayReadouts.Add(() => info.Text = Loc.F("{0} cables · {1} points", CableList().Count, ConsortJacks.Points));
+ overlayReadouts.Add(() => info.Text = Loc.F("device.consort.cables_points", CableList().Count, ConsortJacks.Points));
Border Btn(string t, Action a)
{
var b = new Border { Height = 16, Padding = new Thickness(7, 0), CornerRadius = NotaRadius.Badge, Background = OffPill, Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center, Child = new TextBlock { Text = t, FontSize = 9, Foreground = TxtC, VerticalAlignment = VerticalAlignment.Center } };
@@ -988,7 +988,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
var topGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,Auto,*,Auto,Auto"), ColumnSpacing = 10 };
topGrid.Children.Add(Lbl("Patch bay", 10, TxtC, FontWeight.SemiBold));
topGrid.Children.Add(Col(info, 1)); topGrid.Children.Add(Col(view, 2));
- topGrid.Children.Add(Col(Btn(Loc.T("Clear all"), ClearAll), 4)); topGrid.Children.Add(Col(Btn(Loc.T("Close"), () => OpenOverlay(false)), 5));
+ topGrid.Children.Add(Col(Btn(Loc.T("common.clear_all"), ClearAll), 4)); topGrid.Children.Add(Col(Btn(Loc.T("common.close"), () => OpenOverlay(false)), 5));
var top = new Border { Height = 26, BorderBrush = Border2, BorderThickness = new Thickness(0, 0, 0, 1), Padding = new Thickness(10, 0), Child = topGrid };
// bottom: cable list with draggable depths
var bottomHost = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 12, VerticalAlignment = VerticalAlignment.Center };
@@ -1005,7 +1005,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
var tone = ConsortJacks.ToneBrush(ConsortJacks.Src(c.Src).Tone);
var dep = MonoText($"{c.Depth * 100:+0;−0;0}", 8, tone);
var depBox = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.SizeNorthSouth), Child = dep };
- ToolTip.SetTip(depBox, MenuKit.Keys(Loc.T("Depth — drag up / down (⌥-click to type, double-click: +50)")));
+ ToolTip.SetTip(depBox, MenuKit.Keys(Loc.T("device.consort.depth_drag_up_down_click")));
if (I(AmtId(slot)) is var ai and >= 0) // ⌥-click types the depth (specs/035)
ValueEntry.Attach(depBox, ValueEntry.InstrumentParam(engine, track, ai, AmtId(slot), CableName(c), v => NotaNum.F($"{(v - 0.5) * 200:+0;−0;0}"), Refresh) with { Default = 0.75 }, dep);
bool drag = false; double y0 = 0; float v0 = 0;
@@ -1022,7 +1022,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
new TextBlock { Text = CableName(c), FontSize = 9, Foreground = TxtC, VerticalAlignment = VerticalAlignment.Center }, depBox));
}
});
- var note = new TextBlock { Text = Loc.T("A cable breaks the normal at Gate / Filt in / VCA in / Ext in · loops run with a one-sample delay"), FontSize = 8, Foreground = DimC, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis };
+ var note = new TextBlock { Text = Loc.T("device.consort.a_cable_breaks_the_normal"), FontSize = 8, Foreground = DimC, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis };
var botGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*") , ColumnSpacing = 12 };
botGrid.Children.Add(new ScrollViewer { HorizontalScrollBarVisibility = ScrollBarVisibility.Hidden, VerticalScrollBarVisibility = ScrollBarVisibility.Disabled, MaxWidth = 470, Content = bottomHost });
botGrid.Children.Add(Col(Right(note), 1));
@@ -1052,7 +1052,7 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
case 3:
{
int m = Sel("seqmode", 3);
- if (m == 0) return Loc.T("Sequencer off · pick SEQ or ARP, then hold a key");
+ if (m == 0) return Loc.T("device.consort.sequencer_off_pick_seq_or");
var types = StepTypes(); int len = SeqLen();
int rat = types.Take(len).Count(t => t == 1), ties = types.Take(len).Count(t => t == 2);
string swing = $"swing {50 + G("seqswing") * 25:0}\u2009%";
@@ -1063,8 +1063,8 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
case 4:
{
var broken = CableList().Where(c => ConsortJacks.Normalled.Contains(c.Dst)).Select(c => ConsortJacks.Dst(c.Dst).Name).Distinct().ToList();
- string nb = broken.Count == 0 ? Loc.T("all normals intact") : "normals broken at " + string.Join(" and ", broken);
- return (vs.PatchView == 0 ? MenuKit.Keys(Loc.T("Matrix view · drag a cell for depth, ⌥-click to type it, double-click to remove · ")) : Loc.F("Jack strip · {0} points · ", ConsortJacks.Points)) + nb;
+ string nb = broken.Count == 0 ? Loc.T("device.consort.all_normals_intact") : "normals broken at " + string.Join(" and ", broken);
+ return (vs.PatchView == 0 ? MenuKit.Keys(Loc.T("device.consort.matrix_view_drag_a_cell")) : Loc.F("device.consort.jack_strip_points", ConsortJacks.Points)) + nb;
}
default:
{
@@ -1082,8 +1082,8 @@ internal sealed class ConsortInstrumentCard : IInstrumentCard
if (scN > 8)
{
string rate = $"{scope[6] / 1000:0.#}\u2009kHz";
- statusRight.Text = vs.Centre == 3 ? Loc.F("{0} · sync to host {1:0}\u2009BPM · CPU {2:0}\u2009%", rate, scope[8], scope[4] * 100)
- : Loc.F("{0} · ×{1} OS · 0 smp · CPU {2:0}\u2009%", rate, (int)scope[5], scope[4] * 100);
+ statusRight.Text = vs.Centre == 3 ? Loc.F("device.consort.sync_to_host_bpm_cpu", rate, scope[8], scope[4] * 100)
+ : Loc.F("device.consort.os_0_smp_cpu", rate, (int)scope[5], scope[4] * 100);
}
});
var statusGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 8 };
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/FluxInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/FluxInstrumentCard.cs
index bce8f602..c12f50ad 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/FluxInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/FluxInstrumentCard.cs
@@ -185,7 +185,7 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
End("vecx"); End("vecy");
Refresh();
};
- ToolTip.SetTip(pad, MenuKit.Keys(Loc.T("Drag to blend the four timbres · ⌥-click to type · double-click to reset")));
+ ToolTip.SetTip(pad, MenuKit.Keys(Loc.T("device.flux.drag_to_blend_the_four")));
if (I("vecx") is var vxi and >= 0) MidiLearn.Bind(pad, MidiTarget.PluginParam(track, -1, vxi), "Vector X");
bool VectorPulled() => live && TargetIdx() == 3;
@@ -200,7 +200,7 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
vecReadout.Text = $"x {Coord(G("vecx"))} · y {Coord(G("vecy"))}";
vecReadout.Foreground = VectorPulled() ? NotaPalette.TealBright : TextSecondary; // teal: the reaction pulls it
bool pulled = VectorPulled();
- vecFoot.Text = pulled ? Loc.T("dashed — where the reaction pulls")
+ vecFoot.Text = pulled ? Loc.T("device.flux.dashed_where_the_reaction_pulls")
: Ghost() ? "dashed — where motion drifts" : "four timbres · drag the point";
vecFoot.Foreground = pulled ? NotaPalette.TealBright : TextTertiary;
});
@@ -237,7 +237,7 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
Padding = new Thickness(6, 0, 5, 0), Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center,
Child = new DockPanel { Children = { Docked(srcChevron, Dock.Right), srcText } },
};
- ToolTip.SetTip(srcField, Loc.T("Choose the track Flux listens to — or one pad, chain or voice of it"));
+ ToolTip.SetTip(srcField, Loc.T("device.flux.choose_the_track_flux_listens"));
// The source may be one pad / chain / voice of a track (specs/050); React always hears it
// after its effects (Post).
string KeyName()
@@ -279,7 +279,7 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
};
var reactCap = Cap("REACT");
- var reactSub = Note(Loc.T("the synth listens to a track"));
+ var reactSub = Note(Loc.T("device.flux.the_synth_listens_to_a"));
reactSub.Margin = new Thickness(6, 0, 0, 0);
var reactHead = new Grid { Height = HeadH, ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto"), Margin = new Thickness(8, 0) };
reactHead.Children.Add(reactCap);
@@ -297,14 +297,14 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
var targetStack = new StackPanel
{
Spacing = 5, VerticalAlignment = VerticalAlignment.Center,
- Children = { Cap(Loc.T("Target — what the reaction drives")), targetSeg, targetHint },
+ Children = { Cap(Loc.T("device.flux.target_what_the_reaction_drives")), targetSeg, targetHint },
};
- string TargetLine() => !live ? Loc.T("→ assign a source to turn the reaction on") : TargetIdx() switch
+ string TargetLine() => !live ? Loc.T("device.flux.assign_a_source_to_turn") : TargetIdx() switch
{
- 0 => Loc.T("→ the sidechain opens the filter"),
- 1 => Loc.T("→ the sidechain bends the pitch up"),
- 2 => Loc.T("→ the sidechain swells the space"),
- _ => Loc.T("→ the sidechain drags the vector in rhythm"),
+ 0 => Loc.T("device.flux.the_sidechain_opens_the_filter"),
+ 1 => Loc.T("device.flux.the_sidechain_bends_the_pitch"),
+ 2 => Loc.T("device.flux.the_sidechain_swells_the_space"),
+ _ => Loc.T("device.flux.the_sidechain_drags_the_vector"),
};
readouts.Add(() =>
{
@@ -341,7 +341,7 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
// Click the Motion readout to step its tempo-sync rate.
motion.Value.Cursor = new Cursor(StandardCursorType.Hand);
motion.Value.Background = Brushes.Transparent;
- ToolTip.SetTip(motion.Value, Loc.T("Click to change the Motion sync rate"));
+ ToolTip.SetTip(motion.Value, Loc.T("device.flux.click_to_change_the_motion"));
motion.Value.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(motion.Value).Properties.IsLeftButtonPressed) return;
@@ -391,7 +391,7 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
Grid.SetRow(macroFootHost, 2); macroBody.Children.Add(macroFootHost);
var macroGridHost = new Grid { RowDefinitions = new RowDefinitions($"{HeadH},*") };
- macroGridHost.Children.Add(HeaderStrip(Head(Cap("MACROS"), Note(Loc.T("one knob each")))));
+ macroGridHost.Children.Add(HeaderStrip(Head(Cap("MACROS"), Note(Loc.T("device.flux.one_knob_each")))));
Grid.SetRow(macroBody, 1); macroGridHost.Children.Add(macroBody);
var macroPanel = SectionBox(macroGridHost);
macroPanel.Width = SideW;
@@ -410,11 +410,11 @@ internal sealed class FluxInstrumentCard : IInstrumentCard
string what = TargetIdx() switch
{
3 => $"vector x {Coord(G("vecx"))} → {Coord(effX)}",
- 0 => Loc.F("cutoff +{0} of range", Pct(react * 0.45f)),
+ 0 => Loc.F("device.flux.cutoff_of_range", Pct(react * 0.45f)),
1 => NotaNum.Unit(react * 3, "+0.0;−0.0;0", "st"),
_ => $"space +{Pct(react * 0.5f)}",
};
- string hits = Loc.Plural(perBar, "{0} transient per bar", "{0} transients per bar");
+ string hits = Loc.Plural("device.flux.transients_per_bar", perBar);
return $"{src} → {Targets[TargetIdx()].ToLowerInvariant()} · listen {Pct(G("listen"))} · {hits} · {what}";
}
string Meta() => $"MOTION {RateNames[RateIdx()]} · TUNE {Cents(G("tune"))} · GAIN {Pct(G("gain"))}";
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/GenericInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/GenericInstrumentCard.cs
index 603c74ba..fd29e18b 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/GenericInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/GenericInstrumentCard.cs
@@ -19,7 +19,7 @@ internal sealed class GenericInstrumentCard : IInstrumentCard
var engine = ctx.Engine;
int track = ctx.TrackId;
- var gui = TextButton(Loc.T("Open GUI ↗"));
+ var gui = TextButton(Loc.T("device.generic.open_gui"));
gui.PointerPressed += (_, _) => { try { engine.OpenPluginEditor(track, -1); } catch { /* no-op */ } };
var body = new StackPanel { Spacing = 8, VerticalAlignment = VerticalAlignment.Center, Children = { gui } };
return new Border { Padding = new Thickness(10), Child = body };
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/GrainInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/GrainInstrumentCard.cs
index 9e643e33..fa9f430d 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/GrainInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/GrainInstrumentCard.cs
@@ -166,7 +166,7 @@ internal sealed class GrainInstrumentCard : IInstrumentCard
Begin("position"); SetP("position", engine.InstrumentParamDefault(track, pi)); End("position");
Refresh();
};
- ToolTip.SetTip(wave, MenuKit.Keys(Loc.T("Drag to move the read position · ⌥-click to type it · double-click to reset")));
+ ToolTip.SetTip(wave, MenuKit.Keys(Loc.T("device.grain.drag_to_move_the_read")));
// ⌥-click types the read position (specs/035); double-click keeps its own reset.
if (I("position") is var gpi and >= 0)
ValueEntry.AttachAll(wave, ValueEntry.InstrumentParam(engine, track, gpi, "position", "Position", v => Pct((float)v), Refresh) with { Default = null });
@@ -317,11 +317,11 @@ internal sealed class GrainInstrumentCard : IInstrumentCard
box.PointerWheelChanged += (wt, e) => { if (WheelInput.Step(e, wt) is not { } s) return; e.Handled = true; if (s != 0) SetRoot(rootNote + s); };
// Double-click: the note the file name names, else C4.
box.DoubleTapped += (_, e) => { SetRoot(SamplerModel.DetectRoot(sampleName) is var d and >= 0 ? d : 60); e.Handled = true; };
- ToolTip.SetTip(box, Loc.T("The root — the key that plays the sample as recorded. Scroll to step it · double-click takes it from the file name (C4 if none)"));
+ ToolTip.SetTip(box, Loc.T("device.grain.the_root_the_key_that"));
var stepper = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 4,
- Children = { Step(GlyphKind.Minus, -1, Loc.T("Root a semitone down")), box, Step(GlyphKind.Plus, +1, Loc.T("Root a semitone up")) },
+ Children = { Step(GlyphKind.Minus, -1, Loc.T("device.grain.root_a_semitone_down")), box, Step(GlyphKind.Plus, +1, Loc.T("device.grain.root_a_semitone_up")) },
};
var cap = Cap("ROOT"); cap.HorizontalAlignment = HorizontalAlignment.Center;
return new StackPanel { Spacing = 4, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 8, 0), Children = { cap, stepper } };
@@ -409,7 +409,7 @@ internal sealed class GrainInstrumentCard : IInstrumentCard
var modeChips = Chips("scanmode", ModeNames, "Scan Mode");
modeChips.HorizontalAlignment = HorizontalAlignment.Right;
modeChips.Margin = new Thickness(0, 0, 6, 0);
- ToolTip.SetTip(modeChips, Loc.T("Scan moves through the file · Freeze holds Position · Key moves it with the note"));
+ ToolTip.SetTip(modeChips, Loc.T("device.grain.scan_moves_through_the_file"));
var readCap = Cap("READ"); readCap.Margin = new Thickness(8, 0, 0, 0);
var readHead = new Grid { Height = TabH, ColumnDefinitions = new ColumnDefinitions("Auto,*") };
readHead.Children.Add(readCap);
@@ -450,7 +450,7 @@ internal sealed class GrainInstrumentCard : IInstrumentCard
var outRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), VerticalAlignment = VerticalAlignment.Stretch };
var volCell = PKnob("volume", "VOLUME", "Volume", Pct, NotaSize.KnobMain, 50);
var mixCell = PKnob("drywet", "DRY/WET", "Dry/Wet", Pct, NotaSize.KnobRegular, 46);
- ToolTip.SetTip(mixCell, Loc.T("Blend the sample itself (dry) with the grain cloud (wet)"));
+ ToolTip.SetTip(mixCell, Loc.T("device.grain.blend_the_sample_itself_dry"));
outRow.Children.Add(volCell);
Grid.SetColumn(mixCell, 1); outRow.Children.Add(mixCell);
Grid.SetColumn(meterBlock, 2); outRow.Children.Add(meterBlock);
@@ -484,7 +484,7 @@ internal sealed class GrainInstrumentCard : IInstrumentCard
{
0 => $"{ModeWord()} · {ShapeWords[Sel("grainshape", 4)]} · {Size(G("grainsize"))} · {Density(G("density"))}",
1 => $"{ModeWord()} · root {SamplerModel.NoteName(rootNote)} · {Coarse(G("coarse"))} · {Fine(G("fine"))}",
- 2 => Loc.F("{0} · position · pitch · pan", ModeWord()),
+ 2 => Loc.F("device.grain.position_pitch_pan", ModeWord()),
3 => $"{ModeWord()} · {FilterNames[Sel("filtype", 3)]} · {Hz(G("filfreq"))}",
_ => $"{ModeWord()} · a · d · s · r",
};
@@ -492,7 +492,7 @@ internal sealed class GrainInstrumentCard : IInstrumentCard
{
0 => $"Window {ShapeWords[Sel("grainshape", 4)]} · size {Size(G("grainsize"))} · density {Density(G("density"))} · spread {Pct(G("spread"))} · {Read()}{Mix()}",
1 => Math.Abs(G("coarse") - 0.5f) < 0.001f && Math.Abs(G("fine") - 0.5f) < 0.0026f
- ? Loc.F("Root {0} plays the sample as recorded · coarse 0 · fine 0", SamplerModel.NoteName(rootNote))
+ ? Loc.F("device.grain.root_plays_the_sample_as", SamplerModel.NoteName(rootNote))
: $"Root {SamplerModel.NoteName(rootNote)} · coarse {Coarse(G("coarse"))} · fine {Fine(G("fine"))} — every grain transposed by it",
2 => $"Variation: position {Pct(G("posrand"))} · pitch {PitchJitter(G("pitchrand"))} · pan {Pct(G("panrand"))} — per grain",
3 => $"Filter {FilterNames[Sel("filtype", 3)]} · {Hz(G("filfreq"))} · reso {Pct(G("filreso"))} — after the grain cloud",
@@ -502,7 +502,7 @@ internal sealed class GrainInstrumentCard : IInstrumentCard
{
string sample = sampleId == 0 ? "DEFAULT" : "SAMPLE";
string rate = sampleKHz > 0 ? " · " + NotaNum.Unit(sampleKHz, "0.#", "kHz") : "";
- return Loc.F("{0} {1}{2} · {3} VOICES · {4} GRAINS", sample, NotaNum.Time(sampleSec), rate, voices, grains);
+ return Loc.F("device.grain.voices_grains_caps", sample, NotaNum.Time(sampleSec), rate, voices, grains);
}
var statusBar = new Grid { Height = StatusH, ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 10 };
statusBar.Children.Add(status);
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/KeysInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/KeysInstrumentCard.cs
index ecf912c0..584eb7d1 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/KeysInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/KeysInstrumentCard.cs
@@ -207,7 +207,7 @@ internal sealed class KeysInstrumentCard : IInstrumentCard
double pk = Math.Max(mt.PeakL, mt.PeakR);
meterOut.Text = pk > 1e-6 ? $"out {NotaNum.Db(AudioMath.LinToDb((float)pk))}" : "out −∞\u2009dB";
}
- meta.Text = mini ? meterOut.Text : Loc.F("{0} · {1} voices", Rate(), VoicesText());
+ meta.Text = mini ? meterOut.Text : Loc.F("device.keys.voices_n", Rate(), VoicesText());
});
if (mini) return BuildMini(ctx, pickup, ModelChips(true), Knob, status, meta, Refresh);
@@ -290,7 +290,7 @@ internal sealed class KeysInstrumentCard : IInstrumentCard
SetP("pedal", On("pedal") ? 0f : 1f); Refresh(); e.Handled = true;
};
if (I("pedal") is var pedI and >= 0) MidiLearn.Bind(pedalPill, MidiTarget.PluginParam(track, -1, pedI), "Damper Pedal");
- ToolTip.SetTip(pedalPill, Loc.T("Sustain pedal — click to hold it down; a keyboard's CC64 works too"));
+ ToolTip.SetTip(pedalPill, Loc.T("device.keys.sustain_pedal_click_to_hold"));
ctx.AddDeviceRefresher(() =>
{
bool down = Sc(KeysModel.ScPedal) > 0 || On("pedal");
@@ -360,7 +360,7 @@ internal sealed class KeysInstrumentCard : IInstrumentCard
var chMix = Knob("chorusmix", "Mix", v => NotaNum.Pct(v));
DimWhen(() => !On("choruson"), chMix);
- var chNote = new TextBlock { Text = Loc.T("2 lines · BBD"), FontSize = 7, Foreground = NotaPalette.TextAxis, HorizontalAlignment = HorizontalAlignment.Center };
+ var chNote = new TextBlock { Text = Loc.T("device.keys.2_lines_bbd"), FontSize = 7, Foreground = NotaPalette.TextAxis, HorizontalAlignment = HorizontalAlignment.Center };
var chorus = Island("Chorus", VStack(chMix, chNote), "choruson", width: 62);
var cabList = new StackPanel { Spacing = 3, VerticalAlignment = VerticalAlignment.Center };
@@ -418,8 +418,8 @@ internal sealed class KeysInstrumentCard : IInstrumentCard
int limit = KeysModel.VoiceCounts[Sel("voices", 4)];
int held = Sc(KeysModel.ScHeld), sus = Sc(KeysModel.ScSustained), act = Sc(KeysModel.ScActive);
grid.Set(limit, held, Math.Max(0, act - held));
- voicesLine.Text = Loc.F("{0} / {1} voices", act, limit);
- pedalLine.Text = sus > 0 ? Loc.F("{0} held by the pedal", sus) : act > held ? Loc.F("{0} ringing out", act - held) : "";
+ voicesLine.Text = Loc.F("device.keys.voices", act, limit);
+ pedalLine.Text = sus > 0 ? Loc.F("device.keys.held_by_the_pedal", sus) : act > held ? Loc.F("device.keys.ringing_out", act - held) : "";
});
var railMeter = new MeterBar { VerticalAlignment = VerticalAlignment.Stretch, Width = MeterScale.StereoWidth };
ctx.AddDeviceRefresher(() => { if (engine.TryGetTrackMeter(track, out var m)) railMeter.Push(m); });
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/MonolithInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/MonolithInstrumentCard.cs
index 6e439387..146b3b71 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/MonolithInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/MonolithInstrumentCard.cs
@@ -351,7 +351,7 @@ internal sealed class MonolithInstrumentCard : IInstrumentCard
var drift = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, VerticalAlignment = VerticalAlignment.Center, Width = 96, Children = { new TextBlock { Text = "Drift", FontSize = 7, FontWeight = FontWeight.Medium, Foreground = MutedC, VerticalAlignment = VerticalAlignment.Center }, WithStretch(HSlider("drift", "", v => $"{v * 100:0}\u2009%", 0, 22)) } };
- var centre = TabPanel(new[] { Loc.T("Controllers · Osc Bank"), "Modifiers" }, drift, centreHost, CentreBody);
+ var centre = TabPanel(new[] { Loc.T("device.monolith.controllers_osc_bank"), "Modifiers" }, drift, centreHost, CentreBody);
var right = new RuleSection { Width = 186, Child = TabInner(new[] { "Mixer", "Output" }, null, rightHost, RightBody, true) };
DockPanel.SetDock(right, Dock.Right);
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/MosaicInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/MosaicInstrumentCard.cs
index c28d593d..3550d32c 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/MosaicInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/MosaicInstrumentCard.cs
@@ -74,7 +74,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
for (int i = 0; i < pc; i++) if (engine.PluginParamId(trackId, -1, i) == "polyphony") poly = MosaicModel.Poly(engine.PluginParamGet(trackId, -1, i));
if (InstrumentView.IsMini(engine, trackId)) return $"{Math.Max(0, active)}/{poly}";
if (!engine.TryGetMosaicStatus(trackId, out var st) || st.FilesTotal == 0) return $"{Math.Max(0, active)}/{poly}";
- if (st.State == 1) return Loc.F("Loading {0}\u2009%", (int)Math.Round(100.0 * st.DiskDone / Math.Max(1, st.DiskTotal)));
+ if (st.State == 1) return Loc.F("device.mosaic.loading_n", (int)Math.Round(100.0 * st.DiskDone / Math.Max(1, st.DiskTotal)));
var ui = Ui(trackId);
string tag = ui.SourceTag;
return $"{tag} · {NotaNum.Bytes(st.RamBytes)}";
@@ -351,7 +351,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
// ======================= the zone map (Zones tab, and S) =================================
var map = new MosaicZoneMap { Mini = mini, Interactive = !mini };
- string EmptyText() => mini ? "Empty" : Loc.T("Drop samples or a folder here · or pick a preset");
+ string EmptyText() => mini ? "Empty" : Loc.T("device.mosaic.drop_samples_or_a_folder");
void SetMap() => map.Set(prog.Zones, ui.ReleaseView, ui.Zone, EmptyText());
SetMap();
map.Selected += i => { ui.Zone = i; if (i >= 0 && i < prog.Zones.Count) ui.Group = prog.Zones[i].Group; Refresh(); };
@@ -392,14 +392,14 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
var zVel = ReadField("Vel", () => Zsel() is { } z ? $"{z.VelLo}–{z.VelHi}" : "—");
var zXf = ReadField("Xf vel", () => Zsel() is { } z && z.XVelInHi > z.XVelInLo ? NotaNum.Str(z.XVelInHi - z.XVelInLo, "0") : "—");
var zFine = Field("Fine", NumBox(() => Zsel() is { } z ? Cents(z.Tune) : "—", d => { if (Zsel() is { } z) z.Tune = Math.Clamp(z.Tune + d, -100, 100); },
- () => { if (Zsel() is { } z) z.Tune = 0; }, 40, Loc.T("The zone's fine tune — drag, wheel, double-click resets"), () => Commit()));
+ () => { if (Zsel() is { } z) z.Tune = 0; }, 40, Loc.T("device.mosaic.the_zones_fine_tune_drag"), () => Commit()));
var zGain = Field("Gain", NumBox(() => Zsel() is { } z ? DbS(z.GainDb) : "—", d => { if (Zsel() is { } z) z.GainDb = Math.Clamp(Math.Round(z.GainDb * 10 + d) / 10.0, -48, 24); },
- () => { if (Zsel() is { } z) z.GainDb = 0; }, 50, Loc.T("The zone's level"), () => Commit()));
+ () => { if (Zsel() is { } z) z.GainDb = 0; }, 50, Loc.T("device.mosaic.the_zones_level"), () => Commit()));
var zPan = Field("Pan", NumBox(() => Zsel() is { } z ? PanS(z.Pan) : "—", d => { if (Zsel() is { } z) z.Pan = Math.Clamp(Math.Round(z.Pan * 100 + d) / 100.0, -1, 1); },
- () => { if (Zsel() is { } z) z.Pan = 0; }, 32, Loc.T("The zone's pan"), () => Commit()));
+ () => { if (Zsel() is { } z) z.Pan = 0; }, 32, Loc.T("device.mosaic.the_zones_pan"), () => Commit()));
int tab = ui.Tab;
Action showTab = () => { };
- var openSample = Button(Loc.T("Open in Sample"), () => { tab = 1; showTab(); }, Loc.T("Edit this zone's start, end and loop"), enabled: () => Zsel() is not null);
+ var openSample = Button(Loc.T("device.mosaic.open_in_sample"), () => { tab = 1; showTab(); }, Loc.T("device.mosaic.edit_this_zones_start_end"), enabled: () => Zsel() is not null);
var zoneRow = Row(12, (zoneChip, "Auto"), (zKeys, "Auto"), (zVel, "Auto"), (zXf, "Auto"), (zFine, "Auto"), (zGain, "Auto"), (zPan, "Auto"), (new Panel(), "*"), (openSample, "Auto"));
// Loading: over the map, and the row says what still works.
@@ -414,14 +414,14 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
Width = 250, Padding = new Thickness(10, 8), CornerRadius = NotaRadius.Tile, BorderThickness = new Thickness(1), BorderBrush = BorderDef,
Background = NotaPalette.SurfaceCard, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center,
- Child = new StackPanel { Spacing = 5, Children = { loadHead, loadTrack, loadLine, new TextBlock { Text = Loc.T("Notes are silent until loading finishes"), FontSize = 7.5, Foreground = TextTertiary } } },
+ Child = new StackPanel { Spacing = 5, Children = { loadHead, loadTrack, loadLine, new TextBlock { Text = Loc.T("device.mosaic.notes_are_silent_until_loading"), FontSize = 7.5, Foreground = TextTertiary } } },
};
loadBox.BindResource(Border.BoxShadowProperty, "Shadow.Popover");
var loadScrim = new Border { Background = NotaPalette.Wash(NotaPalette.BgSunken, 0x99), IsHitTestVisible = false };
var loadLayer = new Panel { Children = { loadScrim, loadBox } };
loadTrack.SizeChanged += (_, _) => loadBar.Width = loadTrack.Bounds.Width * LoadFrac();
- var loadRow = Row(10, (new TextBlock { Text = Loc.T("Zones can already be selected and edited"), FontSize = 8, Foreground = TextTertiary }, "*"),
- (Button(Loc.T("Cancel"), () => { prog = new MosaicProgram { Name = prog.Name }; Commit(rebuild: true); }, Loc.T("Stop loading — the instrument empties (undo brings it back)")), "Auto"));
+ var loadRow = Row(10, (new TextBlock { Text = Loc.T("device.mosaic.zones_can_already_be_selected"), FontSize = 8, Foreground = TextTertiary }, "*"),
+ (Button(Loc.T("common.cancel"), () => { prog = new MosaicProgram { Name = prog.Name }; Commit(rebuild: true); }, Loc.T("device.mosaic.stop_loading_the_instrument_empties")), "Auto"));
// SFZ import banner over the map.
var bannerText = Mono("", TextPrimary, 8);
@@ -450,13 +450,13 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
Control MissingPanel()
{
bool pack = prog.PackId.Length > 0;
- string title = pack ? Loc.F("Pack “{0}” is not installed", prog.PackName.Length > 0 ? prog.PackName : prog.PackId) : Loc.T("The samples aren't where the program says");
+ string title = pack ? Loc.F("device.mosaic.pack_is_not_installed", prog.PackName.Length > 0 ? prog.PackName : prog.PackId) : Loc.T("device.mosaic.the_samples_arent_where_the");
string body = pack
- ? Loc.F("This preset uses {0} samples from the pack. Zone settings are kept, no sound until installed.", prog.Files.Count)
- : Loc.F("None of its {0} samples were found. Zone settings are kept — point Mosaic at the folder that holds them.", prog.Files.Count);
+ ? Loc.F("device.mosaic.this_preset_uses_samples_from", prog.Files.Count)
+ : Loc.F("device.mosaic.none_of_its_samples_were", prog.Files.Count);
var buttons = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, HorizontalAlignment = HorizontalAlignment.Center };
- if (pack) buttons.Children.Add(Button(Loc.T("Install pack"), () => InstallPackRequested?.Invoke(prog.PackId), Loc.T("Settings → Downloads → Sample packs"), primary: true));
- buttons.Children.Add(Button(Loc.T("Locate folder…"), () => _ = LocateAsync(), Loc.T("Pick the folder that holds the samples — Mosaic finds each file in it by its path or its name")));
+ if (pack) buttons.Children.Add(Button(Loc.T("device.mosaic.install_pack"), () => InstallPackRequested?.Invoke(prog.PackId), Loc.T("device.mosaic.settings_downloads_sample_packs"), primary: true));
+ buttons.Children.Add(Button(Loc.T("device.mosaic.locate_folder"), () => _ = LocateAsync(), Loc.T("device.mosaic.pick_the_folder_that_holds")));
return new Border
{
Background = NotaPalette.BgSunken, BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(1), CornerRadius = new CornerRadius(NotaRadius.ControlValue),
@@ -467,7 +467,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
new TextBlock { Text = title, FontSize = 11, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, HorizontalAlignment = HorizontalAlignment.Center, TextAlignment = TextAlignment.Center },
new TextBlock { Text = body, FontSize = 8, Foreground = TextSecondary, TextWrapping = TextWrapping.Wrap, TextAlignment = TextAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center },
- Mono(pack ? Loc.F("{0} · {1} zones", prog.PackId, prog.Zones.Count) : MosaicPaths.FileName(prog.Files.FirstOrDefault() ?? ""), TextTertiary, 8),
+ Mono(pack ? Loc.F("device.mosaic.zones_n", prog.PackId, prog.Zones.Count) : MosaicPaths.FileName(prog.Files.FirstOrDefault() ?? ""), TextTertiary, 8),
buttons,
},
},
@@ -479,7 +479,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
var top = TopLevel.GetTopLevel(map);
if (top is null) return;
- var picked = await top.PickFoldersAsync(new Avalonia.Platform.Storage.FolderPickerOpenOptions { Title = Loc.T("Locate the samples"), AllowMultiple = false });
+ var picked = await top.PickFoldersAsync(new Avalonia.Platform.Storage.FolderPickerOpenOptions { Title = Loc.T("device.mosaic.locate_the_samples"), AllowMultiple = false });
var dir = picked.FirstOrDefault()?.TryGetLocalPath();
if (dir is null) return;
var byName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
@@ -512,7 +512,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
// ======================= Sample tab ======================================================
var wave = new SamplerWaveView();
- wave.SetEmpty(Loc.T("Select a zone"));
+ wave.SetEmpty(Loc.T("device.mosaic.select_a_zone"));
long waveSampleId = 0; int waveZone = -1; float[] raw = Array.Empty<float>(); int wch = 1; long wframes = 0; double wsr = 0;
void LoadWave()
{
@@ -525,7 +525,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
raw = engine.ReadSample(sid); wch = Math.Max(1, si.Channels); wframes = si.Frames; wsr = si.SampleRate;
wave.SetPeaks(SamplerModel.Peaks(raw, wch, 1200), wsr > 0 ? wframes / wsr : 0);
}
- else wave.SetEmpty(Loading() ? "Loading…" : Zsel() is null ? Loc.T("Select a zone") : Loc.T("Sample not loaded"));
+ else wave.SetEmpty(Loading() ? "Loading…" : Zsel() is null ? Loc.T("device.mosaic.select_a_zone") : Loc.T("device.mosaic.sample_not_loaded"));
}
double FrameNorm(double frames, double def) => wframes > 1 ? (frames < 0 ? def : Math.Clamp(frames / wframes, 0, 1)) : def;
double ToFrames(double norm) => Math.Round(Math.Clamp(norm, 0, 1) * wframes);
@@ -564,11 +564,11 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
});
var loopSeg = Segments(MosaicModel.LoopNames, () => Zsel()?.LoopMode ?? 0, iv => { if (Zsel() is { } z) { z.LoopMode = iv; Commit(); } Refresh(); }, out var loopSync, padX: 7, fontSize: 8);
readouts.Add(loopSync);
- ToolTip.SetTip(loopSeg, Loc.T("Off plays once · Fwd loops · Ping bounces — this zone only"));
+ ToolTip.SetTip(loopSeg, Loc.T("device.mosaic.off_plays_once_fwd_loops"));
var xfKnob = VKnob("Crossfade", () => Math.Sqrt(Math.Clamp((Zsel()?.Crossfade ?? 0) / 0.5, 0, 1)), v => { if (Zsel() is { } z) z.Crossfade = v * v * 0.5; },
- () => NotaNum.Time(Zsel()?.Crossfade ?? 0), 0, tip: Loc.T("Blends the loop's end into its start (forward loops)"));
+ () => NotaNum.Time(Zsel()?.Crossfade ?? 0), 0, tip: Loc.T("device.mosaic.blends_the_loops_end_into"));
var zGainKnob = VKnob("Gain", () => ((Zsel()?.GainDb ?? 0) + 24) / 48.0, v => { if (Zsel() is { } z) z.GainDb = Math.Round((v * 48 - 24) * 10) / 10; },
- () => DbS(Zsel()?.GainDb ?? 0), 0.5, tip: Loc.T("This zone's level"));
+ () => DbS(Zsel()?.GainDb ?? 0), 0.5, tip: Loc.T("device.mosaic.this_zones_level"));
void SnapAll()
{
if (Zsel() is not { } z || wframes <= 1) return;
@@ -585,8 +585,8 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
z.Start = ToFrames(t.Start); z.End = ToFrames(t.End);
Commit();
}
- var snapBtn = Button(Loc.T("Snap to zero"), SnapAll, Loc.T("Move Start, End and the loop to the nearest zero crossing"), enabled: () => wframes > 1);
- var trimBtn = Button(Loc.T("Trim silence"), Trim, Loc.T("Move Start and End to where the sound begins and fades out (−48 dB)"), enabled: () => wframes > 1);
+ var snapBtn = Button(Loc.T("device.mosaic.snap_to_zero"), SnapAll, Loc.T("device.mosaic.move_start_end_and_the"), enabled: () => wframes > 1);
+ var trimBtn = Button(Loc.T("device.mosaic.trim_silence"), Trim, Loc.T("device.mosaic.move_start_and_end_to"), enabled: () => wframes > 1);
snapBtn.HorizontalAlignment = HorizontalAlignment.Stretch; trimBtn.HorizontalAlignment = HorizontalAlignment.Stretch;
var sampleChip = Mono("", TextPrimary, 9);
readouts.Add(() => sampleChip.Text = Zsel() is { } z ? ZoneChip(z) : "");
@@ -670,7 +670,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
var relSwitch = Switch("", () => G("relon") >= 0.5f, () => Write("relon", G("relon") >= 0.5f ? 0 : 1), out var relSync, liveLabel: () => G("relon") >= 0.5f ? "on" : "off");
readouts.Add(relSync);
if (I("relon") is var rli and >= 0) MidiLearn.Bind(relSwitch, MidiTarget.PluginParam(track, -1, rli), "Release Triggers");
- var relVolKnob = PKnob("relvol", "Rel vol", v => NotaNum.Db(MosaicModel.RelVolDb(v), signed: true), NotaSize.KnobMain, 52, tip: Loc.T("The release samples' level"));
+ var relVolKnob = PKnob("relvol", "Rel vol", v => NotaNum.Db(MosaicModel.RelVolDb(v), signed: true), NotaSize.KnobMain, 52, tip: Loc.T("device.mosaic.the_release_samples_level"));
var lenCurve = new MosaicCurveView
{
Width = 120, Height = 34,
@@ -678,7 +678,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
Get = () => G("rellen"), SetValue = v => { SetP("rellen", v); Refresh(); }, Begin = () => Begin("rellen"), End = () => End("rellen"),
Default = Def("rellen"), UpIsMore = false, Node = 0.5,
};
- ToolTip.SetTip(lenCurve, MenuKit.Keys(Loc.T("How much quieter a release sample gets the longer the key was held — drag up / down, ⌥-click to type")));
+ ToolTip.SetTip(lenCurve, MenuKit.Keys(Loc.T("device.mosaic.how_much_quieter_a_release")));
ValueEntry.Attach(lenCurve, lenCurve.EntryField("Release length", v => NotaNum.Db(MosaicModel.RelLenDb((float)v), signed: true)));
var lenWord = Mono("", TextSecondary, 7.5);
readouts.Add(() => { lenWord.Text = $"{NotaNum.Db(MosaicModel.RelLenDb(G("rellen")), signed: true)} after 2 s hold"; lenCurve.InvalidateVisual(); });
@@ -689,7 +689,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
Get = () => G("velcurve"), SetValue = v => { SetP("velcurve", v); Refresh(); }, Begin = () => Begin("velcurve"), End = () => End("velcurve"),
Default = Def("velcurve"), UpIsMore = false,
};
- ToolTip.SetTip(velCurve, MenuKit.Keys(Loc.T("Velocity → level: drag up for soft (quiet notes louder), down for hard; ⌥-click to type")));
+ ToolTip.SetTip(velCurve, MenuKit.Keys(Loc.T("device.mosaic.velocity_level_drag_up_for")));
ValueEntry.Attach(velCurve, velCurve.EntryField("Vel curve", v => { int c = MosaicModel.VelCurve((float)v); return c == 0 ? "0 linear" : c < 0 ? $"−{-c} soft" : $"+{c} hard"; }));
var velWord = Mono("", TextSecondary, 7.5);
string VelCurveWord() { int c = MosaicModel.VelCurve(G("velcurve")); return c == 0 ? "linear" : c < 0 ? $"soft +{-c}" : $"hard +{c}"; }
@@ -699,7 +699,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
prog.Groups.Add(new MosaicGroup { Name = $"Group {prog.Groups.Count + 1}" });
ui.Group = prog.Groups.Count - 1;
Commit(); rebuildGroups(); rebuildRail();
- }, Loc.T("A new, empty layer — move zones into it from the rail"));
+ }, Loc.T("device.mosaic.a_new_empty_layer_move"));
var groupBottom = Row(18,
(new StackPanel { Spacing = 4, Children = { Caps("Release triggers"), relSwitch } }, "Auto"),
(relVolKnob, "Auto"),
@@ -709,26 +709,26 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
// ======================= Pitch tab =======================================================
var keysView = new SamplerKeysView();
- ToolTip.SetTip(keysView, Loc.T("Click a key to make it the selected zone's root"));
+ ToolTip.SetTip(keysView, Loc.T("device.mosaic.click_a_key_to_make"));
keysView.RootPicked += k => { if (Zsel() is { } z) { z.Root = k; Commit(); SetMap(); } Refresh(); };
readouts.Add(() => keysView.Set(Zsel()?.Root ?? 60, -1, snap.Live ? snap.Note : -1, G("pitchtrack"), Zsel() is { } z ? ZoneChip(z) : ""));
var rootBox = Field("Root", NumBox(() => Zsel() is { } z ? MosaicNames.NoteName(z.Root) : "—", d => { if (Zsel() is { } z) z.Root = Math.Clamp(z.Root + d, 0, 127); },
- null, 40, Loc.T("The zone's root — drag or scroll"), () => { Commit(); SetMap(); }));
+ null, 40, Loc.T("device.mosaic.the_zones_root_drag_or"), () => { Commit(); SetMap(); }));
int Detected() => Zsel() is { } z ? SamplerModel.DetectRoot(prog.FileName(z.File)) : -1;
- var detectBtn = Button(Loc.T("Detect from file name"), () => { if (Zsel() is { } z && Detected() >= 0) { z.Root = Detected(); Commit(); SetMap(); } },
- Loc.T("Make the note in the zone's file name its root"), on: () => Zsel() is { } z && Detected() == z.Root, enabled: () => Detected() >= 0);
- var fineKnob = VKnob("Fine", () => ((Zsel()?.Tune ?? 0) + 100) / 200.0, v => { if (Zsel() is { } z) z.Tune = Math.Round(v * 200 - 100); }, () => Cents(Zsel()?.Tune ?? 0), 0.5, Teal, Loc.T("The zone's fine tune, ±100 cents"));
+ var detectBtn = Button(Loc.T("device.mosaic.detect_from_file_name"), () => { if (Zsel() is { } z && Detected() >= 0) { z.Root = Detected(); Commit(); SetMap(); } },
+ Loc.T("device.mosaic.make_the_note_in_the"), on: () => Zsel() is { } z && Detected() == z.Root, enabled: () => Detected() >= 0);
+ var fineKnob = VKnob("Fine", () => ((Zsel()?.Tune ?? 0) + 100) / 200.0, v => { if (Zsel() is { } z) z.Tune = Math.Round(v * 200 - 100); }, () => Cents(Zsel()?.Tune ?? 0), 0.5, Teal, Loc.T("device.mosaic.the_zones_fine_tune_100"));
var pitchRow = Row(12,
- (PKnob("transpose", "Transpose", St, tip: Loc.T("Shift every note, ±24 semitones")), "Auto"),
- (PKnob("detune", "Detune", v => Cents(MosaicModel.DetuneCents(v)), arc: Teal, tip: Loc.T("Fine tune of the whole instrument, ±50 cents")), "Auto"),
- (PKnob("pitchtrack", "Keytrack", v => NotaNum.Pct(v), tip: Loc.T("How far the key moves the pitch — 100 % chromatic, 0 % every key plays the root")), "Auto"),
+ (PKnob("transpose", "Transpose", St, tip: Loc.T("device.mosaic.shift_every_note_24_semitones")), "Auto"),
+ (PKnob("detune", "Detune", v => Cents(MosaicModel.DetuneCents(v)), arc: Teal, tip: Loc.T("device.mosaic.fine_tune_of_the_whole")), "Auto"),
+ (PKnob("pitchtrack", "Keytrack", v => NotaNum.Pct(v), tip: Loc.T("device.mosaic.how_far_the_key_moves")), "Auto"),
(rootBox, "Auto"), (fineKnob, "Auto"),
- (PKnob("bendrange", "Bend", v => NotaNum.Unit(MosaicModel.BendSemis(v), "0", "st"), arc: Teal, tip: Loc.T("The pitch wheel's range (MPE bends are per note)")), "Auto"),
+ (PKnob("bendrange", "Bend", v => NotaNum.Unit(MosaicModel.BendSemis(v), "0", "st"), arc: Teal, tip: Loc.T("device.mosaic.the_pitch_wheels_range_mpe")), "Auto"),
(new Panel(), "*"), (detectBtn, "Auto"));
// ======================= Env tab =========================================================
var env = new SamplerEnvView();
- ToolTip.SetTip(env, MenuKit.Keys(Loc.T("Drag the nodes: attack, decay and sustain (up / down), release · Shift for fine steps · ⌥-click to type · double-click resets")));
+ ToolTip.SetTip(env, MenuKit.Keys(Loc.T("device.mosaic.drag_the_nodes_attack_decay")));
env.DragBegin += Begin;
env.DragEnd += End;
env.Changed += (id, v) => { SetP(id, v); Refresh(); };
@@ -741,12 +741,12 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
(PKnob("sustain", "Sustain", DbLin, NotaSize.KnobMain, 56), "Auto"),
(PKnob("release", "Release", v => NotaNum.Time(MosaicModel.ReleaseSec(v))), "Auto"),
(new Panel(), "*"),
- (PKnob("velcurve", "Vel curve", v => { int c = MosaicModel.VelCurve(v); return c == 0 ? "linear" : c < 0 ? $"soft {-c}" : $"hard {c}"; }, arc: Teal, tip: Loc.T("Velocity → level curve")), "Auto"),
- (PKnob("mpepressure", "Pressure", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("MPE pressure (aftertouch) → level")), "Auto"));
+ (PKnob("velcurve", "Vel curve", v => { int c = MosaicModel.VelCurve(v); return c == 0 ? "linear" : c < 0 ? $"soft {-c}" : $"hard {c}"; }, arc: Teal, tip: Loc.T("device.mosaic.velocity_level_curve")), "Auto"),
+ (PKnob("mpepressure", "Pressure", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("device.mosaic.mpe_pressure_aftertouch_level")), "Auto"));
// ======================= Filter tab ======================================================
var filt = new SamplerFilterView();
- ToolTip.SetTip(filt, MenuKit.Keys(Loc.T("Drag: left / right for the cutoff, up / down for the resonance · Shift for fine steps · ⌥-click to type · double-click resets")));
+ ToolTip.SetTip(filt, MenuKit.Keys(Loc.T("device.mosaic.drag_left_right_for_the")));
filt.DragBegin += () => { Begin("cutoff"); Begin("resonance"); };
filt.DragEnd += () => { End("cutoff"); End("resonance"); };
filt.Changed += (id, v) => { SetP(id, v); Refresh(); };
@@ -766,15 +766,15 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
return $"{MosaicModel.FilterNames[t]} 12 dB/oct · {NotaNum.Hz(MosaicModel.CutoffHz(G("cutoff")))} · reso {NotaNum.Pct(G("resonance"))}";
}
readouts.Add(() => filt.Set(Sel("filtertype", 4), G("cutoff"), G("resonance"), snap.Live ? snap.CutoffHz : -1, FiltTl()));
- var envBtn = Button("Env → Cutoff", () => Write("envcutoff", G("envcutoff") >= 0.5f ? 0 : 1), Loc.T("Let the amp envelope open (or close) the filter"), on: () => G("envcutoff") >= 0.5f);
+ var envBtn = Button("Env → Cutoff", () => Write("envcutoff", G("envcutoff") >= 0.5f ? 0 : 1), Loc.T("device.mosaic.let_the_amp_envelope_open"), on: () => G("envcutoff") >= 0.5f);
var filterRow = Row(10,
(Field("Type", Chips("filtertype", MosaicModel.FilterNames, padX: 6)), "Auto"),
(PKnob("cutoff", "Cutoff", v => NotaNum.Hz(MosaicModel.CutoffHz(v)), NotaSize.KnobMain, 56), "Auto"),
(PKnob("resonance", "Reso", v => NotaNum.Pct(v)), "Auto"),
- (PKnob("keytrack", "Keytrack", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("The cutoff follows the key")), "Auto"),
+ (PKnob("keytrack", "Keytrack", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("device.mosaic.the_cutoff_follows_the_key")), "Auto"),
(new Panel(), "*"), (envBtn, "Auto"),
(PKnob("envamount", "Env", v => NotaNum.Unit(MosaicModel.EnvOctaves(v), "+0.0;−0.0;0.0", "oct"), arc: Teal), "Auto"),
- (PKnob("mpeslide", "Slide", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("MPE slide (CC74) → cutoff")), "Auto"));
+ (PKnob("mpeslide", "Slide", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("device.mosaic.mpe_slide_cc74_cutoff")), "Auto"));
// ======================= the tab panel ===================================================
const double RowH = 62;
@@ -868,7 +868,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
Background = NotaPalette.BgSunken, Cursor = new Cursor(StandardCursorType.Hand),
Child = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5, Children = { artLabel, sub, new Glyph(GlyphKind.ChevronDown, 6) { Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center } } },
};
- ToolTip.SetTip(box, Loc.T("The articulation — the SFZ's controller value its zones were chosen by"));
+ ToolTip.SetTip(box, Loc.T("device.mosaic.the_articulation_the_sfzs_controller"));
box.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(box).Properties.IsLeftButtonPressed) return;
@@ -969,7 +969,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
if (chevron is not null) chevron.Foreground = cur == 0 ? OnAccent : TextTertiary;
});
if (I("voicemode") is var vmi and >= 0) MidiLearn.Bind(row, MidiTarget.PluginParam(track, -1, vmi), "voicemode");
- ToolTip.SetTip(row, Loc.T("Poly: chords (click again for the voice settings) · Mono: one at a time, legato with Glide · Choke: a new note cuts the ringing ones"));
+ ToolTip.SetTip(row, Loc.T("device.mosaic.poly_chords_click_again_for"));
var host = new Border
{
Background = NotaPalette.BgSunken, BorderBrush = BorderDef, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Control,
@@ -990,23 +990,23 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
ps();
busyBar.Width = busyTrack.Bounds.Width * Math.Clamp(snap.Voices / (double)Math.Max(1, Poly()), 0, 1);
- busyText.Text = Loc.F("{0} busy · {1} on pedal · {2} release", snap.Held, snap.PedalHeld, snap.Release);
+ busyText.Text = Loc.F("device.mosaic.busy_on_pedal_release", snap.Held, snap.PedalHeld, snap.Release);
}
var order = new StackPanel { Spacing = 2 };
for (int i = 0; i < MosaicModel.StealOrder.Length; i++)
order.Children.Add(new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { Mono((i + 1).ToString(NotaNum.Culture), TextSecondary, 8), new TextBlock { Text = MosaicModel.StealOrder[i], FontSize = 8.5, Foreground = TextPrimary } } });
var perKey = NumBox(() => MosaicModel.PerKey(G("perkey")).ToString(NotaNum.Culture), d => SetP("perkey", (MosaicModel.PerKey(G("perkey")) - 1 + d) / 3.0),
- () => SetP("perkey", Def("perkey")), 30, Loc.T("How many strikes of one key may ring together"));
+ () => SetP("perkey", Def("perkey")), 30, Loc.T("device.mosaic.how_many_strikes_of_one"));
var fade = NumBox(() => NotaNum.Unit(MosaicModel.OldFadeMs(G("oldfade")), "0", "ms"), d => SetP("oldfade", MosaicModel.OldFadeNorm(MosaicModel.OldFadeMs(G("oldfade")) + d)),
- () => SetP("oldfade", Def("oldfade")), 44, Loc.T("How fast a stolen or superseded voice fades"));
+ () => SetP("oldfade", Def("oldfade")), 44, Loc.T("device.mosaic.how_fast_a_stolen_or"));
var bottom = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
bottom.Children.Add(new StackPanel { Spacing = 3, Children = { Caps("Per key"), perKey } });
- var fadeCol = new StackPanel { Spacing = 3, HorizontalAlignment = HorizontalAlignment.Right, Children = { Caps(Loc.T("Old voice fade")), fade } };
+ var fadeCol = new StackPanel { Spacing = 3, HorizontalAlignment = HorizontalAlignment.Right, Children = { Caps(Loc.T("device.mosaic.old_voice_fade")), fade } };
Grid.SetColumn(fadeCol, 1); bottom.Children.Add(fadeCol);
var panel = new StackPanel
{
Width = 196, Spacing = 6, Margin = new Thickness(4),
- Children = { Caps("Polyphony"), polySeg, busyTrack, busyText, Rule(), Caps(Loc.T("Voice stealing · order")), order, Rule(), bottom },
+ Children = { Caps("Polyphony"), polySeg, busyTrack, busyText, Rule(), Caps(Loc.T("device.mosaic.voice_stealing_order")), order, Rule(), bottom },
};
var timer = new Avalonia.Threading.DispatcherTimer { Interval = TimeSpan.FromMilliseconds(80) };
timer.Tick += (_, _) => PaintBusy();
@@ -1025,7 +1025,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
Slider("Volume", "volume", () => DbLin(G("volume"))),
Slider("Pan", "pan", () => PanS(G("pan") * 2 - 1), bipolar: true),
- Slider("Glide", "glide", () => GlideText(G("glide")), tip: Loc.T("Slide from the last note — in Mono, legato")),
+ Slider("Glide", "glide", () => GlideText(G("glide")), tip: Loc.T("device.mosaic.slide_from_the_last_note")),
},
};
// The pedal: on / off (CC64 heard), lit while it is down.
@@ -1038,7 +1038,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
};
pedalPill.PointerPressed += (_, e) => { if (!e.GetCurrentPoint(pedalPill).Properties.IsLeftButtonPressed) return; Write("pedal", G("pedal") >= 0.5f ? 0 : 1); Refresh(); e.Handled = true; };
if (I("pedal") is var pdi and >= 0) MidiLearn.Bind(pedalPill, MidiTarget.PluginParam(track, -1, pdi), "Voice Pedal");
- ToolTip.SetTip(pedalPill, Loc.T("The sustain pedal: a keyboard's CC64 holds released keys — click to stop listening to it"));
+ ToolTip.SetTip(pedalPill, Loc.T("device.mosaic.the_sustain_pedal_a_keyboards"));
var voicesTxt = Mono("", TextPrimary, 9);
readouts.Add(() =>
{
@@ -1056,8 +1056,8 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
Grid.SetColumn(voicesTxt, 2); pedalRow.Children.Add(voicesTxt);
sliders.Children.Add(pedalRow);
- var outKnob = PKnob("output", "Output", v => NotaNum.Pct(v), NotaSize.KnobMain, 50, tip: Loc.T("The level after everything"));
- var velKnob = PKnob("velamount", "Vel → Vol", v => NotaNum.Pct(v), cellW: 50, arc: Teal, tip: Loc.T("How much velocity sets the level"));
+ var outKnob = PKnob("output", "Output", v => NotaNum.Pct(v), NotaSize.KnobMain, 50, tip: Loc.T("device.mosaic.the_level_after_everything"));
+ var velKnob = PKnob("velamount", "Vel → Vol", v => NotaNum.Pct(v), cellW: 50, arc: Teal, tip: Loc.T("device.mosaic.how_much_velocity_sets_the"));
var meter = new MeterBar { VerticalAlignment = VerticalAlignment.Stretch, Width = MeterScale.StereoWidth };
ctx.AddDeviceRefresher(() => { if (engine.TryGetTrackMeter(track, out var m)) meter.Push(m); });
var outRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 4 };
@@ -1076,7 +1076,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
if (ui.Group < 0 || ui.Group >= prog.Groups.Count) return VoicesRail();
var gr = prog.Groups[ui.Group];
- string title = Loc.F("Group · {0}", gr.Name.Length > 0 ? gr.Name : (ui.Group + 1).ToString(NotaNum.Culture));
+ string title = Loc.F("device.mosaic.group", gr.Name.Length > 0 ? gr.Name : (ui.Group + 1).ToString(NotaNum.Culture));
Grid GSlider(string label, Func<double> get, Action<double> set, Func<string> text, bool bipolar, bool mod)
{
var row = SliderRow(label, get, v => { set(v); Refresh(); }, text, out var sync, end: () => { Commit(); rebuildGroups(); }, reset: () => { set(bipolar ? 0.5 : 24.0 / 36.0); Commit(); rebuildGroups(); },
@@ -1087,7 +1087,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
var gain = GSlider("Gain", () => (gr.GainDb + 24) / 36.0, v => gr.GainDb = Math.Round((v * 36 - 24) * 10) / 10, () => DbS(gr.GainDb), false, false);
var tune = GSlider("Tune", () => (gr.Tune + 100) / 200.0, v => gr.Tune = Math.Round(v * 200 - 100), () => Cents(gr.Tune), true, true);
var seq = NumBox(() => gr.SeqLen.ToString(NotaNum.Culture), d => gr.SeqLen = Math.Clamp(gr.SeqLen + d, 1, 16), () => gr.SeqLen = 1, 36,
- Loc.T("Round-robin steps: the group's zones take turns 1 … N (each zone's step is set by its file)"), () => { Commit(); rebuildGroups(); });
+ Loc.T("device.mosaic.round_robin_steps_the_groups"), () => { Commit(); rebuildGroups(); });
var seqRow = new Grid { ColumnDefinitions = new ColumnDefinitions("50,Auto") };
seqRow.Children.Add(new TextBlock { Text = "Seq len", FontSize = NotaType.RowLabel, FontWeight = FontWeight.Medium, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center });
Grid.SetColumn(seq, 1); seqRow.Children.Add(seq);
@@ -1096,17 +1096,17 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
int ExclVal(bool off) { var z = prog.Zones.FirstOrDefault(z => z.Group == ui.Group); return z is null ? 0 : off ? z.OffBy : z.Excl; }
void SetExcl(bool off, int v) { foreach (var z in prog.Zones.Where(z => z.Group == ui.Group)) { if (off) z.OffBy = v; else z.Excl = v; } }
var exG = NumBox(() => ExclVal(false) is var v && v > 0 ? $"group {v}" : "group —", d => SetExcl(false, Math.Clamp(ExclVal(false) + d, 0, 64)), () => SetExcl(false, 0), 70,
- Loc.T("This group's exclusive number"), () => { Commit(); rebuildGroups(); SetMap(); });
+ Loc.T("device.mosaic.this_groups_exclusive_number"), () => { Commit(); rebuildGroups(); SetMap(); });
var exO = NumBox(() => ExclVal(true) is var v && v > 0 ? $"off_by {v}" : "off_by —", d => SetExcl(true, Math.Clamp(ExclVal(true) + d, 0, 64)), () => SetExcl(true, 0), 70,
- Loc.T("Voices of this group stop when a note of that exclusive group starts"), () => { Commit(); rebuildGroups(); SetMap(); });
+ Loc.T("device.mosaic.voices_of_this_group_stop"), () => { Commit(); rebuildGroups(); SetMap(); });
var exRow = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, Children = { exG, exO } };
- var note = new TextBlock { Text = Loc.T("Exclusive is for hi-hats and valves: a new note chokes the off_by group."), FontSize = 7.5, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap };
+ var note = new TextBlock { Text = Loc.T("device.mosaic.exclusive_is_for_hi_hats"), FontSize = 7.5, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap };
var body = new StackPanel
{
Spacing = 6,
- Children = { gain, tune, seqRow, Caps("Round-robin"), rrSeg, Caps(Loc.T("Exclusive · group / off by")), exRow, note },
+ Children = { gain, tune, seqRow, Caps("Round-robin"), rrSeg, Caps(Loc.T("device.mosaic.exclusive_group_off_by")), exRow, note },
};
- return RailBody(RailHead(title, sub: Loc.Plural(ZonesIn(ui.Group), "{0} zone", "{0} zones")), body);
+ return RailBody(RailHead(title, sub: Loc.Plural("device.mosaic.zones", ZonesIn(ui.Group))), body);
}
Control ReportRail()
@@ -1141,7 +1141,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
KV("Files", () => $"{status.FilesDone} / {status.FilesTotal}"),
KV("Missing", () => status.Missing.ToString(NotaNum.Culture), status.Missing > 0 ? NotaPalette.DangerBright : null),
Rule(),
- KV(Loc.T("Total in RAM"), () => NotaNum.Bytes(status.State == 2 ? status.RamBytes : RamEstimate())),
+ KV(Loc.T("device.mosaic.total_in_ram"), () => NotaNum.Bytes(status.State == 2 ? status.RamBytes : RamEstimate())),
},
};
return RailBody(RailHead("Voices", VoiceSeg()), body);
@@ -1158,7 +1158,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
Caps("Source"),
new TextBlock { Text = where, FontSize = 8, Foreground = TextPrimary, FontFamily = NotaFonts.MonoFamily, TextWrapping = TextWrapping.Wrap },
- new TextBlock { Text = Loc.T("Samples are not copied into the project; the program keeps where they are."), FontSize = 7.5, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap },
+ new TextBlock { Text = Loc.T("device.mosaic.samples_are_not_copied_into"), FontSize = 7.5, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap },
},
};
return RailBody(RailHead("Voices", VoiceSeg()), body);
@@ -1179,9 +1179,9 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
// ======================= status ==========================================================
string Summary()
{
- if (AllMissing() && prog.Zones.Count > 0) return Loc.T("Samples unavailable · notes muted");
- if (Loading()) return Loc.F("Loading · {0} / {1} · notes muted", NotaNum.Bytes(status.RamBytes), NotaNum.Bytes(RamEstimate()));
- if (prog.IsEmpty) return Loc.T("Empty · drop samples or a folder, or pick a preset");
+ if (AllMissing() && prog.Zones.Count > 0) return Loc.T("device.mosaic.samples_unavailable_notes_muted");
+ if (Loading()) return Loc.F("device.mosaic.loading_notes_muted", NotaNum.Bytes(status.RamBytes), NotaNum.Bytes(RamEstimate()));
+ if (prog.IsEmpty) return Loc.T("device.mosaic.empty_drop_samples_or_a");
string name = prog.Name.Length > 0 ? prog.Name + " · " : "";
switch (tab)
{
@@ -1195,7 +1195,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
case 3:
{
string pedal = snap.Pedal ? " · pedal down" : "";
- string missing = status.Missing > 0 ? Loc.F(" · {0} missing", status.Missing) : "";
+ string missing = status.Missing > 0 ? Loc.F("device.mosaic.missing", status.Missing) : "";
return $"{name}{prog.Summary()}{pedal}{missing}";
}
case 2:
@@ -1203,13 +1203,13 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
string rel = G("relon") >= 0.5f ? $"release {NotaNum.Db(MosaicModel.RelVolDb(G("relvol")), signed: true)}" : "release off";
var rrg = prog.Groups.FirstOrDefault(g => g.SeqLen > 1);
string rr = rrg is null ? "no round-robin" : $"rr {rrg.SeqLen} {MosaicProgram.RrNames[rrg.RrMode].ToLowerInvariant()}";
- return Loc.F("{0} groups · {1} · {2}", prog.Groups.Count, rr, rel);
+ return Loc.F("device.mosaic.groups", prog.Groups.Count, rr, rel);
}
case 4: return $"Env {EnvTl()} · vel {NotaNum.Pct(G("velamount"))} · curve {VelCurveWord()}";
default:
{
int t = Sel("filtertype", 4);
- if (t == 0) return Loc.T("Filter off — the samples pass untouched");
+ if (t == 0) return Loc.T("device.mosaic.filter_off_the_samples_pass");
return $"Filter {MosaicModel.FilterNames[t]} · cutoff {NotaNum.Hz(MosaicModel.CutoffHz(G("cutoff")))} · reso {NotaNum.Pct(G("resonance"))}";
}
}
@@ -1260,7 +1260,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
double f = LoadFrac();
loadPct.Text = NotaNum.Pct(f);
- loadLine.Text = Loc.F("{0} / {1} · {2} / {3} files", NotaNum.Bytes(status.RamBytes), NotaNum.Bytes(RamEstimate()), status.FilesDone, status.FilesTotal);
+ loadLine.Text = Loc.F("device.mosaic.files", NotaNum.Bytes(status.RamBytes), NotaNum.Bytes(RamEstimate()), status.FilesDone, status.FilesTotal);
loadBar.Width = loadTrack.Bounds.Width * f;
}
};
@@ -1297,7 +1297,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
{
var title = new TextBlock { FontSize = 12, FontWeight = FontWeight.SemiBold, Foreground = AccentBright, HorizontalAlignment = HorizontalAlignment.Center };
var line = new TextBlock { FontSize = 8.5, Foreground = TextPrimary, HorizontalAlignment = HorizontalAlignment.Center, TextAlignment = TextAlignment.Center };
- var hint = new TextBlock { FontSize = 7.5, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, Text = Loc.T("Opens the mapping preview. A single file replaces the sample, as before.") };
+ var hint = new TextBlock { FontSize = 7.5, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, Text = Loc.T("device.mosaic.opens_the_mapping_preview_a") };
var dash = new Rectangle
{
Stroke = AccentBright, StrokeThickness = 1.2, StrokeDashArray = new Avalonia.Collections.AvaloniaList<double> { 4, 3 },
@@ -1330,17 +1330,17 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
e.DragEffects = DragDropEffects.Copy;
e.Handled = true;
ctx.HideDropGlow();
- if (sample) Show(true, Loc.T("Release to load the sample"), item!.Name);
+ if (sample) Show(true, Loc.T("device.mosaic.release_to_load_the_sample"), item!.Name);
else
{
var paths = folder ? new List<string> { item!.Path } : DroppedPaths(e);
var audio = ExpandAudio(paths);
- if (audio.Count == 1) Show(true, Loc.T("Release to load the sample"), Path.GetFileName(audio[0]));
+ if (audio.Count == 1) Show(true, Loc.T("device.mosaic.release_to_load_the_sample"), Path.GetFileName(audio[0]));
else
{
var stems = audio.Select(p => MultisampleMapper.ParseName(p).Stem).Distinct().ToList();
- Show(true, Loc.T("Release to build a multisample"),
- audio.Count == 0 ? Loc.T("a folder of samples") : Loc.F("{0} · {1} found by name: {2}", Loc.Plural(audio.Count, "{0} file", "{0} files"), Loc.Plural(stems.Count, "{0} instrument", "{0} instruments"), string.Join(", ", stems.Take(4))));
+ Show(true, Loc.T("device.mosaic.release_to_build_a_multisample"),
+ audio.Count == 0 ? Loc.T("device.mosaic.a_folder_of_samples") : Loc.F("device.mosaic.found_by_name", Loc.Plural("device.mosaic.files_n", audio.Count), Loc.Plural("device.mosaic.instruments", stems.Count), string.Join(", ", stems.Take(4))));
}
}
});
@@ -1396,7 +1396,7 @@ internal sealed class MosaicInstrumentCard : IInstrumentCard
bool ld = Loading();
miniTrack.IsVisible = ld;
miniBar.Width = miniTrack.Bounds.Width * LoadFrac();
- zonesTxt.Text = ld ? Loc.F("Loading {0}", NotaNum.Pct(LoadFrac())) : prog.IsEmpty ? Loc.T("Empty") : Loc.F("{0} · {1}", Loc.Plural(prog.Zones.Count, "{0} zone", "{0} zones"), Loc.Plural(prog.VelocityLayers, "{0} layer", "{0} layers"));
+ zonesTxt.Text = ld ? Loc.F("device.mosaic.loading", NotaNum.Pct(LoadFrac())) : prog.IsEmpty ? Loc.T("device.mosaic.empty") : Loc.F("common.pattern_n", Loc.Plural("device.mosaic.zones", prog.Zones.Count), Loc.Plural("device.mosaic.layers", prog.VelocityLayers));
zonesTxt.Foreground = ld ? AccentBright : AllMissing() && prog.Zones.Count > 0 ? NotaPalette.DangerBright : TextSecondary;
ramTxt.Text = ld ? $"{NotaNum.Bytes(status.RamBytes)} / {NotaNum.Bytes(RamEstimate())}" : NotaNum.Bytes(status.RamBytes);
}
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/OperatorInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/OperatorInstrumentCard.cs
index c0ebbaee..075ae70f 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/OperatorInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/OperatorInstrumentCard.cs
@@ -54,7 +54,7 @@ internal sealed class OperatorInstrumentCard : IInstrumentCard
private static readonly string[] TabHints =
{
"wave · ratio · fine · level",
- Loc.T("11 topologies · feedback on A"),
+ Loc.T("device.operator.11_topologies_feedback_on_a"),
"type · freq · reso · key track",
};
@@ -452,7 +452,7 @@ internal sealed class OperatorInstrumentCard : IInstrumentCard
var modeRow = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 12, VerticalAlignment = VerticalAlignment.Center,
- Children = { Toggle("Mono", "mono"), Toggle("Vel → FM", "veltofm", () => G("veltofm") >= 0.5f ? $"Vel → FM {NotaNum.Pct(G("veltofm"))}" : Loc.T("Vel → FM off")) },
+ Children = { Toggle("Mono", "mono"), Toggle("Vel → FM", "veltofm", () => G("veltofm") >= 0.5f ? $"Vel → FM {NotaNum.Pct(G("veltofm"))}" : Loc.T("device.operator.vel_fm_off")) },
};
var meter = new MeterBar { VerticalAlignment = VerticalAlignment.Stretch, Width = MeterScale.StereoWidth };
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/PendulumInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/PendulumInstrumentCard.cs
index b2d8fa93..1d4c291c 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/PendulumInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/PendulumInstrumentCard.cs
@@ -85,9 +85,9 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
int[] held = Array.Empty<int>();
var lanes = new PendulumLanesView { VerticalAlignment = VerticalAlignment.Stretch };
- ToolTip.SetTip(lanes, Loc.T("One lane per ball: x is pitch, low to high. Crossing a chord degree plays that note; teal shows the wall ahead"));
+ ToolTip.SetTip(lanes, Loc.T("device.pendulum.one_lane_per_ball_x"));
var bar = new PendulumBarView { Height = BarH };
- ToolTip.SetTip(bar, Loc.T("The bar: generated notes land on the 1/16 grid — this bar in neutral ink with the note just played in accent, the last bar dimmer ahead of the playhead"));
+ ToolTip.SetTip(bar, Loc.T("device.pendulum.the_bar_generated_notes_land"));
var ballList = new PendulumBallList();
var voiceBars = new PendulumVoiceBars { VerticalAlignment = VerticalAlignment.Center };
@@ -170,7 +170,7 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
ballList.Set(snap, count, DivLabel());
voiceBars.Set(snap.Levels);
int voices = snap.Live ? snap.Voices : Math.Max(0, engine.InstrumentVoiceCount(track));
- lastNote.Text = Loc.F("last note {0} · {1}", PendulumModel.NoteName(snap.LastPitch), Loc.Plural(voices, "{0} voice", "{0} voices"));
+ lastNote.Text = Loc.F("device.pendulum.last_note", PendulumModel.NoteName(snap.LastPitch), Loc.Plural("device.pendulum.voices", voices));
double sr = engine.SampleRate > 0 ? engine.SampleRate : 48000;
meta.Text = $"{voices}/{PendulumModel.Voices} voices · {NotaNum.Unit(sr / 1000, "0.#", "kHz")} · {NotaNum.Bpm(engine.Bpm)} BPM · DSP {NotaNum.Unit(engine.CpuLoad * 100, "0.0", "%")}";
status.Text = Summary();
@@ -266,18 +266,18 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
// ---- Balls tab ----------------------------------------------------------------
var syncSeg = Chips("sync", new[] { "Free", "Sync" }, padX: 5, fontSize: 7);
- ToolTip.SetTip(syncSeg, Loc.T("Sync: a swing takes a note division of the tempo · Free: it takes a time in seconds"));
+ ToolTip.SetTip(syncSeg, Loc.T("device.pendulum.sync_a_swing_takes_a"));
var divSeg = Chips("division", PendulumModel.DivNames, padX: 4, fontSize: 7);
- ToolTip.SetTip(divSeg, Loc.T("How long one swing (low → high → low) takes at +100\u2009%"));
+ ToolTip.SetTip(divSeg, Loc.T("device.pendulum.how_long_one_swing_low"));
var timeRow = Slider("TIME", "freerate", () => Secs(PendulumModel.FreeSeconds(G("freerate"))), labelWidth: 0, valueWidth: 32);
timeRow.Width = 100;
- ToolTip.SetTip(timeRow, Loc.T("Free: seconds per swing at +100\u2009%"));
+ ToolTip.SetTip(timeRow, Loc.T("device.pendulum.free_seconds_per_swing_at"));
var cycleHost = new Panel { VerticalAlignment = VerticalAlignment.Center, Children = { divSeg, timeRow } };
readouts.Add(() => { divSeg.IsVisible = Synced(); timeRow.IsVisible = !Synced(); });
var rateRow = Slider("RATE", "rate", () => NotaNum.Unit(PendulumModel.RateSigned(G("rate")) * 100, "+0;−0;0", "%"), bipolar: true, labelWidth: 0, valueWidth: 28);
- ToolTip.SetTip(rateRow, Loc.T("Swing speed — centre stops the balls, left of centre runs them in reverse"));
+ ToolTip.SetTip(rateRow, Loc.T("device.pendulum.swing_speed_centre_stops_the"));
var motionSeg = Chips("motion", PendulumModel.MotionNames, padX: 4, fontSize: 7);
- ToolTip.SetTip(motionSeg, Loc.T("The swing curve — Pendulum slows at the walls, Linear keeps one speed, Bounce settles with a ripple"));
+ ToolTip.SetTip(motionSeg, Loc.T("device.pendulum.the_swing_curve_pendulum_slows"));
var ballStrip = Row((syncSeg, "Auto"), (cycleHost, "Auto"), (rateRow, "*"), (Cap("MOTION"), "Auto"), (motionSeg, "Auto"));
ballStrip.ColumnSpacing = 7;
ballStrip.Margin = new Thickness(7, 0);
@@ -291,7 +291,7 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
// ---- Voice tab ----------------------------------------------------------------
var waveSeg = Chips("wave", PendulumModel.WaveNames, padX: 6, fontSize: 7);
- ToolTip.SetTip(waveSeg, Loc.T("The voice: soft Keys, bright Glass, Saw, hollow Square or inharmonic Bell"));
+ ToolTip.SetTip(waveSeg, Loc.T("device.pendulum.the_voice_soft_keys_bright"));
var voiceStrip = Row((waveSeg, "Auto"), (new Panel(), "*"), (lastNote, "Auto"), (voiceBars, "Auto"));
voiceStrip.ColumnSpacing = 7;
voiceStrip.Margin = new Thickness(7, 0);
@@ -385,23 +385,23 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
};
return b;
}
- var steppers = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 3, Children = { StepBtn(GlyphKind.Minus, -1, Loc.T("One ball fewer (2 at least)")), StepBtn(GlyphKind.Plus, +1, Loc.T("One ball more (6 at most)")) } };
+ var steppers = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 3, Children = { StepBtn(GlyphKind.Minus, -1, Loc.T("device.pendulum.one_ball_fewer_2_at")), StepBtn(GlyphKind.Plus, +1, Loc.T("device.pendulum.one_ball_more_6_at")) } };
var countRow = Row((Cap("BALLS"), "Auto"), (countText, "Auto"), (new Panel(), "*"), (steppers, "Auto"));
countRow.ColumnSpacing = 6;
if (I("balls") is var bi and >= 0) MidiLearn.Bind(countRow, MidiTarget.PluginParam(track, -1, bi), engine.PluginParamName(track, -1, bi));
var sortSeg = Chips("chordsort", new[] { "Up", "Down" }, padX: 4, fontSize: 7);
- ToolTip.SetTip(sortSeg, Loc.T("Up: the low wall plays the chord's lowest note · Down: its highest"));
+ ToolTip.SetTip(sortSeg, Loc.T("device.pendulum.up_the_low_wall_plays"));
var quantSeg = Chips("quantize", PendulumModel.QuantNames, padX: 3, fontSize: 7);
- ToolTip.SetTip(quantSeg, Loc.T("Quantize: a crossing waits for the next 1/16 or 1/8 before it plays"));
+ ToolTip.SetTip(quantSeg, Loc.T("device.pendulum.quantize_a_crossing_waits_for"));
var sortRow = Row((Cap("SORT"), "Auto"), (sortSeg, "Auto"), (new Panel(), "*"), (Cap("QUANT"), "Auto"), (quantSeg, "Auto"));
var holdBtn = RailButton("Hold", () => Write("hold", G("hold") >= 0.5f ? 0 : 1), () => G("hold") >= 0.5f, "hold");
- ToolTip.SetTip(holdBtn, Loc.T("Latch the chord — it keeps swinging after you let go; the next chord replaces it"));
+ ToolTip.SetTip(holdBtn, Loc.T("device.pendulum.latch_the_chord_it_keeps"));
var firstBtn = RailButton("First note", () => Write("firstnote", G("firstnote") >= 0.5f ? 0 : 1), () => G("firstnote") >= 0.5f, "firstnote");
- ToolTip.SetTip(firstBtn, Loc.T("Restart every ball from its start when a new chord begins"));
+ ToolTip.SetTip(firstBtn, Loc.T("device.pendulum.restart_every_ball_from_its"));
var resetBtn = RailButton("Reset", () => SetP("reset", 1), id: "reset");
- ToolTip.SetTip(resetBtn, Loc.T("Restart every ball's swing now"));
+ ToolTip.SetTip(resetBtn, Loc.T("device.pendulum.restart_every_balls_swing_now"));
var actionRow = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), ColumnSpacing = 4 };
actionRow.Children.Add(holdBtn);
Grid.SetColumn(firstBtn, 1); actionRow.Children.Add(firstBtn);
@@ -426,10 +426,10 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
Slider("HUMAN", "humanize", () => NotaNum.Pct(G("humanize")), modulation: true, labelWidth: 40),
},
};
- ToolTip.SetTip(spreadBlock.Children[1], Loc.T("How far the balls' rates drift apart — each ball a little faster than the one before"));
- ToolTip.SetTip(spreadBlock.Children[2], Loc.T("Detune of the chorus partner inside each voice"));
- ToolTip.SetTip(spreadBlock.Children[3], Loc.T("Fan the notes across the stereo field by where the ball is"));
- ToolTip.SetTip(spreadBlock.Children[4], Loc.T("Level and pitch jitter per note"));
+ ToolTip.SetTip(spreadBlock.Children[1], Loc.T("device.pendulum.how_far_the_balls_rates"));
+ ToolTip.SetTip(spreadBlock.Children[2], Loc.T("device.pendulum.detune_of_the_chorus_partner"));
+ ToolTip.SetTip(spreadBlock.Children[3], Loc.T("device.pendulum.fan_the_notes_across_the"));
+ ToolTip.SetTip(spreadBlock.Children[4], Loc.T("device.pendulum.level_and_pitch_jitter_per"));
var spreadHost = new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 3, 0, 0), Child = spreadBlock };
var scaleText = Mono("", TextPrimary);
@@ -447,7 +447,7 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
},
},
};
- ToolTip.SetTip(scaleBox, Loc.T("Snap the generated notes to a scale"));
+ ToolTip.SetTip(scaleBox, Loc.T("device.pendulum.snap_the_generated_notes_to"));
scaleBox.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(scaleBox).Properties.IsLeftButtonPressed) return;
@@ -493,12 +493,12 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
if (G("humanize") > 0.005f) { lastHuman = G("humanize"); Write("humanize", 0); }
else Write("humanize", lastHuman);
}, () => G("humanize") > 0.005f, "humanize", 14);
- ToolTip.SetTip(humanBtn, Loc.T("Humanize on / off — the amount is the HUMAN slider"));
+ ToolTip.SetTip(humanBtn, Loc.T("device.pendulum.humanize_on_off_the_amount"));
var spreadResetBtn = RailButton("Reset", () =>
{
foreach (var id in new[] { "spread", "detune", "panspread", "humanize", "root", "scalemode" }) Write(id, Def(id));
}, height: 14);
- ToolTip.SetTip(spreadResetBtn, Loc.T("Reset spread, humanize and scale to their defaults"));
+ ToolTip.SetTip(spreadResetBtn, Loc.T("device.pendulum.reset_spread_humanize_and_scale"));
var voiceBtns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 4 };
voiceBtns.Children.Add(humanBtn);
Grid.SetColumn(spreadResetBtn, 1); voiceBtns.Children.Add(spreadResetBtn);
@@ -555,7 +555,7 @@ internal sealed class PendulumInstrumentCard : IInstrumentCard
int n = Count();
var notes = new List<string>();
for (int b = 0; b < n; b++) notes.Add(PendulumModel.NoteName(snap.BallState[b].Pitch));
- string chord = held.Length == 0 ? Loc.T("hold a chord") : string.Join(" ", notes);
+ string chord = held.Length == 0 ? Loc.T("device.pendulum.hold_a_chord") : string.Join(" ", notes);
string s = $"{(Synced() ? "Sync " + PendulumModel.DivNames[Sel("division", 5)] : "Free " + Secs(PendulumModel.FreeSeconds(G("freerate"))))} · {MotionWord()} · rate {RateText()}"
+ $" · {n} balls → {chord} · sort {(G("chordsort") >= 0.5f ? "down" : "up")} · quantize {PendulumModel.QuantNames[Sel("quantize", 3)].ToLowerInvariant()}";
if (G("hold") >= 0.5f) s += " · hold";
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/PentadInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/PentadInstrumentCard.cs
index 8d599927..efa61d09 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/PentadInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/PentadInstrumentCard.cs
@@ -278,7 +278,7 @@ internal sealed class PentadInstrumentCard : IInstrumentCard
Control OscTab()
{
var hdr = new Grid { ColumnDefinitions = new ColumnDefinitions(OscCols), Height = 13 };
- string[] h = { "OSC", "OCT", "SEMI", "FINE", Loc.T("SHAPE · PULSE WIDTH"), "OPTIONS" };
+ string[] h = { "OSC", "OCT", "SEMI", "FINE", Loc.T("device.pentad.shape_pulse_width_caps"), "OPTIONS" };
for (int i = 0; i < h.Length; i++)
{
var t = new TextBlock { Text = NotaText.Label(h[i]), FontSize = 7, FontWeight = FontWeight.Medium, Foreground = DimC, VerticalAlignment = VerticalAlignment.Center,
@@ -406,12 +406,12 @@ internal sealed class PentadInstrumentCard : IInstrumentCard
W("wmpwa", "PW A", 1, 0); W("wmpwb", "PW B", 1, 1);
var mixRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto"), ColumnSpacing = 5, Children = {
Caps("SOURCE"), Col(Lbl("LFO", 7, DimC, FontWeight.Normal), 1), Col(HSlider("wmmix", v => Pct(v), 26), 2), Col(Lbl("NOISE", 7, DimC, FontWeight.Normal), 3) } };
- var wm = new StackPanel { Spacing = 3, Children = { Caps(Loc.T("WHEEL MOD — DESTINATIONS")), wmGrid, mixRow } };
+ var wm = new StackPanel { Spacing = 3, Children = { Caps(Loc.T("device.pentad.wheel_mod_destinations_caps")), wmGrid, mixRow } };
var wmBox = new Border { BorderBrush = BorderIn, BorderThickness = new Thickness(1, 0, 0, 0), Padding = new Thickness(10, 0, 0, 0), Child = wm };
var bottom = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 10, Children = { lfo, Col(wmBox, 1) } };
return new DockPanel { LastChildFill = true, Margin = new Thickness(8, 3, 8, 2), Children = {
- Docked(Caps(Loc.T("POLY MOD — SOURCE → DESTINATION")), Avalonia.Controls.Dock.Top),
+ Docked(Caps(Loc.T("device.pentad.poly_mod_source_destination_caps")), Avalonia.Controls.Dock.Top),
Docked(Divider(bottom, 4), Avalonia.Controls.Dock.Bottom),
new Border { Padding = new Thickness(0, 2, 0, 0), Child = routes } } };
}
@@ -478,14 +478,14 @@ internal sealed class PentadInstrumentCard : IInstrumentCard
// Drift slider + seed re-roll (Oscillators tab bar)
var reroll = new Border { Padding = new Thickness(3, 0), CornerRadius = NotaRadius.Badge, Background = OffPill, Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center,
Child = new Glyph(GlyphKind.Cycle, 9) { Foreground = Txt2 } };
- ToolTip.SetTip(reroll, Loc.T("Re-roll the vintage seed (new per-voice spread)"));
+ ToolTip.SetTip(reroll, Loc.T("device.pentad.re_roll_the_vintage_seed"));
reroll.PointerPressed += (_, e) => { SetP("seed", (float)Random.Shared.NextDouble()); Refresh(); e.Handled = true; };
var driftSl = HSlider("drift", v => $"{v * 100:0}\u2009%", 22); driftSl.Width = 76;
Control[] extras = {
Row(5, Caps("DRIFT"), driftSl, reroll),
MonoText("4-pole LP · 24\u2009dB/oct", 7, MutedC),
MonoText("", 7, MutedC) };
- readouts.Add(() => { if (extras[2] is TextBlock t) { int n = ActiveRoutes(); t.Text = Loc.Plural(n, "per voice · {0} active route", "per voice · {0} active routes"); } });
+ readouts.Add(() => { if (extras[2] is TextBlock t) { int n = ActiveRoutes(); t.Text = Loc.Plural("device.pentad.per_voice_active_routes", n); } });
Control CentreBody(int t) => tabBodies[t] ??= t switch { 1 => FilterAmpTab(), 2 => PolyModTab(), _ => OscTab() };
Control RightBody(int t) => rightBodies[t] ??= t == 1 ? OutputTab() : MixerTab();
@@ -523,7 +523,7 @@ internal sealed class PentadInstrumentCard : IInstrumentCard
readouts.Add(() =>
{
statusLeft.Text = StatusText();
- if (scN >= 8) statusRight.Text = Loc.F("{0:0.#}\u2009kHz · ×{1} OS · CPU {2:0}\u2009%", scope[7] / 1000, (int)scope[6], scope[5] * 100);
+ if (scN >= 8) statusRight.Text = Loc.F("device.pentad.khz_os_cpu", scope[7] / 1000, (int)scope[6], scope[5] * 100);
});
var flyReadouts = new List<Action>();
@@ -545,7 +545,7 @@ internal sealed class PentadInstrumentCard : IInstrumentCard
R("GLIDE", Chips("glidemode", new[] { "Off", "On", "Legato" }, null, flyReadouts, 8)),
R("RELEASE", Toggle("releaseon", "Release switch", flyReadouts)),
R("OVERSAMPLING", Chips("oversample", new[] { "×2", "×4" }, null, flyReadouts, 8)),
- R("BASS COMP", Toggle("lowcomp", Loc.T("Restore lows at high Q"), flyReadouts)),
+ R("BASS COMP", Toggle("lowcomp", Loc.T("device.pentad.restore_lows_at_high_q"), flyReadouts)),
R("NOISE FLOOR", Toggle("noisefloor", "−100\u2009dBFS hiss", flyReadouts)),
R("VINTAGE SEED", Row(8, seedTxt, rr)),
R("MASTER TUNE", tune),
@@ -554,7 +554,7 @@ internal sealed class PentadInstrumentCard : IInstrumentCard
}
var voiceBtn = new Border { Height = 14, Padding = new Thickness(6, 0), CornerRadius = NotaRadius.Badge, Background = OffPill, Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center,
Child = Glyph.WithChevron(new TextBlock { Text = "Voice", FontSize = 8, Foreground = TxtC, VerticalAlignment = VerticalAlignment.Center }, 7) };
- ToolTip.SetTip(voiceBtn, Loc.T("Voice setup: polyphony, allocation, glide mode, oversampling, vintage seed"));
+ ToolTip.SetTip(voiceBtn, Loc.T("device.pentad.voice_setup_polyphony_allocation_glide"));
voiceBtn.PointerPressed += (_, e) =>
{
setupFly ??= new Flyout { Content = SetupPanel(), Placement = PlacementMode.TopEdgeAlignedRight };
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/PhysicalInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/PhysicalInstrumentCard.cs
index fbcf7997..a12017b9 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/PhysicalInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/PhysicalInstrumentCard.cs
@@ -93,7 +93,7 @@ internal sealed class PhysicalInstrumentCard : IInstrumentCard
2 => Pct((float)n), _ => Secs(PhysicalModel.NoiseRelease((float)n)),
};
var partials = new PhysPartialsView { VerticalAlignment = VerticalAlignment.Stretch };
- ToolTip.SetTip(partials, Loc.T("Partials as the engine tunes them — drag ↔ to spread the series (Ratio), ↕ to tilt the highs (Bright)"));
+ ToolTip.SetTip(partials, Loc.T("device.physical.partials_as_the_engine_tunes"));
static TextBlock Cap(string t, IBrush? c = null) => new()
{
@@ -212,7 +212,7 @@ internal sealed class PhysicalInstrumentCard : IInstrumentCard
PKnob("malletstiff", "STIFF", Pct),
PKnob("malletnoise", "NOISE", Pct),
PKnob("malletcolor", "COLOR", Pct));
- ToolTip.SetTip(knobs, Loc.T("Stiffness sets the contact time: soft = long and dark, hard = short and bright"));
+ ToolTip.SetTip(knobs, Loc.T("device.physical.stiffness_sets_the_contact_time"));
malletGrid.Children.Add(Cap("MALLET"));
Grid.SetRow(knobs, 1); malletGrid.Children.Add(knobs);
}
@@ -224,7 +224,7 @@ internal sealed class PhysicalInstrumentCard : IInstrumentCard
readouts.Add(() =>
{
double oct = PhysicalModel.NoiseEnvOct(G("noiseenv"));
- envCap.Text = Math.Abs(oct) < 0.05 ? Loc.T("env → freq off") : "env → freq " + NotaNum.Unit(oct, "+0.0;−0.0;0", "oct");
+ envCap.Text = Math.Abs(oct) < 0.05 ? Loc.T("device.physical.env_freq_off") : "env → freq " + NotaNum.Unit(oct, "+0.0;−0.0;0", "oct");
});
var head = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 5 };
var typeChips = Chips("noisetype", PhysicalModel.NoiseTypes);
@@ -298,7 +298,7 @@ internal sealed class PhysicalInstrumentCard : IInstrumentCard
cap.Foreground = d ? TextDisabled : TextTertiary;
});
var cell = new StackPanel { Spacing = 3, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Children = { cap, trackC, val } };
- ToolTip.SetTip(cell, Loc.T("Res 1 against Res 2 — both at full level in the middle; in 1→2, res 1's own sound against the body it rings"));
+ ToolTip.SetTip(cell, Loc.T("device.physical.res_1_against_res_2"));
if (pi >= 0) MidiLearn.Bind(cell, MidiTarget.PluginParam(track, -1, pi), "Res Mix");
return cell;
}
@@ -330,13 +330,13 @@ internal sealed class PhysicalInstrumentCard : IInstrumentCard
var bankSeg = Segments(new[] { "1", "2" }, () => bank, iv => { bank = iv; showTab(); }, out var bankSync, padX: 5);
readouts.Add(bankSync);
- ToolTip.SetTip(bankSeg, Loc.T("Which resonator the controls below edit"));
+ ToolTip.SetTip(bankSeg, Loc.T("device.physical.which_resonator_the_controls_below"));
// On / Off belongs to the bank on screen: bank 1 always rings, bank 2 is switchable.
var onSeg = Chips("r2on", new[] { "Off", "On" }, () => bank == 0 || R2On() ? 1 : 0,
iv => { if (bank == 1) { Write("r2on", iv); Refresh(); } }, dim: () => bank == 0);
- ToolTip.SetTip(onSeg, Loc.T("Resonator 2 on / off — resonator 1 always rings"));
+ ToolTip.SetTip(onSeg, Loc.T("device.physical.resonator_2_on_off_resonator"));
var structSeg = Chips("structure", new[] { "1→2", "1+2" }, dim: () => !R2On(), padX: 4);
- ToolTip.SetTip(structSeg, Loc.T("1→2: resonator 1 rings into resonator 2 · 1+2: both struck, mixed"));
+ ToolTip.SetTip(structSeg, Loc.T("device.physical.1_2_resonator_1_rings"));
var typeHost = new Panel { Children = { typeHosts[0], typeHosts[1] } };
var resHead = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,Auto,*,Auto,Auto"), ColumnSpacing = 5, Margin = new Thickness(6, 0) };
@@ -407,14 +407,14 @@ internal sealed class PhysicalInstrumentCard : IInstrumentCard
var monoChips = Chips("mono", new[] { "Poly", "Mono" }, () => IsMono() ? 1 : 0, iv => { Write("mono", iv); Refresh(); });
monoChips.HorizontalAlignment = HorizontalAlignment.Right;
monoChips.Margin = new Thickness(0, 0, 6, 0);
- ToolTip.SetTip(monoChips, Loc.T("Poly: 8 voices ring over each other · Mono: a new strike chokes the sounding note"));
+ ToolTip.SetTip(monoChips, Loc.T("device.physical.poly_8_voices_ring_over"));
var outCap = Cap("OUTPUT"); outCap.Margin = new Thickness(8, 0, 0, 0);
var outHead = new Grid { Height = TabH, ColumnDefinitions = new ColumnDefinitions("Auto,*") };
outHead.Children.Add(outCap);
Grid.SetColumn(monoChips, 1); outHead.Children.Add(monoChips);
var noteOffRow = Slider("NOTE OFF", "noteoff", () => Pct(G("noteoff")));
- ToolTip.SetTip(noteOffRow, Loc.T("How hard a released key damps the body — at 0 it rings on, fully up it stops at once"));
+ ToolTip.SetTip(noteOffRow, Loc.T("device.physical.how_hard_a_released_key"));
var outTop = new StackPanel
{
Spacing = 6, Margin = new Thickness(8, 6, 8, 0),
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/RhythmInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/RhythmInstrumentCard.cs
index ef3a7a9f..be31e0b9 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/RhythmInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/RhythmInstrumentCard.cs
@@ -208,7 +208,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
if (topLevel is null) return;
var files = await topLevel.PickFilesAsync(new FilePickerOpenOptions
{
- Title = Loc.F("Load a sample into {0}", RM.VoiceNames[voice]), AllowMultiple = false,
+ Title = Loc.F("device.rhythm.load_a_sample_into", RM.VoiceNames[voice]), AllowMultiple = false,
FileTypeFilter = new[] { new FilePickerFileType("Audio") { Patterns = new[] { "*.wav", "*.flac", "*.mp3", "*.aif", "*.aiff", "*.ogg" } } },
});
if (files.Count > 0 && files[0].TryGetLocalPath() is { } p && engine.SetRhythmVoiceSample(track, voice, p))
@@ -266,7 +266,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
CornerRadius = NotaRadius.Badge, BorderThickness = new Thickness(1), Cursor = new Cursor(StandardCursorType.Hand),
Background = on ? NotaPalette.AccentSubtle : Brushes.Transparent, BorderBrush = restBorder, Child = row,
};
- ToolTip.SetTip(box, Loc.F("{0} · MIDI {1}\nClick: select and play · drop a file to load it · right-click for more", RM.VoiceNames[v], DeviceCardKit.NoteName(RM.MidiNotes[v])));
+ ToolTip.SetTip(box, Loc.F("device.rhythm.midi_click_select_and_play", RM.VoiceNames[v], DeviceCardKit.NoteName(RM.MidiNotes[v])));
AttachFxTip(fxTag, v);
box.PointerPressed += (_, e) =>
{
@@ -291,15 +291,15 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
void KitMenu(int v, Control anchor)
{
var fly = new MenuFlyout();
- var load = new MenuItem { Header = Loc.T("Load sample…") };
+ var load = new MenuItem { Header = Loc.T("device.rhythm.load_sample") };
load.Click += (_, _) => LoadSample(anchor, v);
fly.Items.Add(load);
bool has = engine.TryGetRhythmVoiceInfo(track, v, out var vi) && vi.SampleId != 0;
- var src = new MenuItem { Header = isSample[v] ? Loc.T("Play the synth engine") : Loc.T("Play the loaded sample"), IsEnabled = isSample[v] || has };
+ var src = new MenuItem { Header = isSample[v] ? Loc.T("device.rhythm.play_the_synth_engine") : Loc.T("device.rhythm.play_the_loaded_sample"), IsEnabled = isSample[v] || has };
src.Click += (_, _) => { Act(RM.A_SetSource, v, isSample[v] ? 0f : 1f); ctx.NotifyChanged(); ctx.RequestRebuild(); };
fly.Items.Add(src);
fly.Items.Add(new Separator());
- fly.Items.Add(MenuKit.Danger(Loc.F("Clear its steps in bank {0}", RM.BankNames[bank]), GlyphKind.Trash,
+ fly.Items.Add(MenuKit.Danger(Loc.F("device.rhythm.clear_its_steps_in_bank", RM.BankNames[bank]), GlyphKind.Trash,
() => { Act(RM.A_ClearVoice, v); ctx.NotifyChanged(); ReloadPattern(); }));
fly.ShowAt(anchor);
}
@@ -320,7 +320,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
}
else if (sampleMode) { Act(RM.A_SetSource, sel, 0f); ctx.NotifyChanged(); ctx.RequestRebuild(); }
}, out _, padX: 6, fontSize: 7);
- ToolTip.SetTip(srcSeg, Loc.T("Synth: the voice's own engine · Sample: a loaded one-shot (loads one if the voice has none)"));
+ ToolTip.SetTip(srcSeg, Loc.T("device.rhythm.synth_the_voices_own_engine"));
var folder = new Glyph(GlyphKind.Folder, 8) { Foreground = NotaPalette.TextStrong };
var fileText = new TextBlock
@@ -332,7 +332,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
var fileBtn = SmallButton(new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, Children = { folder, fileText } }, fileText,
() => LoadSample(kit, sel), () => sampleMode);
readouts.Add(() => folder.Foreground = sampleMode ? NotaPalette.TextPrimary : NotaPalette.TextStrong);
- ToolTip.SetTip(fileBtn, sampleMode ? Loc.F("{0} — click to load another file", sampleName) : Loc.T("Load a one-shot into this voice (or drop a file on the voice)"));
+ ToolTip.SetTip(fileBtn, sampleMode ? Loc.F("device.rhythm.click_to_load_another_file", sampleName) : Loc.T("device.rhythm.load_a_one_shot_into"));
var voiceHead = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, Margin = new Thickness(7, 0), VerticalAlignment = VerticalAlignment.Center };
// VOICE / MACRO: which the centre shows. The lit one is the one on screen.
@@ -341,7 +341,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
bool on = macro == _macroMode;
var c = Cap(text, on ? (macro ? AccentBright : NotaPalette.TextStrong) : NotaPalette.TextDisabled);
var host = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = c };
- ToolTip.SetTip(host, macro ? Loc.T("The kit's eight macros — knobs over every voice and its effects") : Loc.T("The selected voice's sound and effects"));
+ ToolTip.SetTip(host, macro ? Loc.T("device.rhythm.the_kits_eight_macros_knobs") : Loc.T("device.rhythm.the_selected_voices_sound_and"));
host.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(host).Properties.IsLeftButtonPressed) return;
@@ -359,17 +359,17 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
if (i == _voiceTab) return;
_voiceTab = i; ctx.RequestRebuild();
}, out _, padX: 6, fontSize: 7);
- ToolTip.SetTip(tabSeg, Loc.T("Sound: the voice's source and shape · FX: its own effects, before the kit bus"));
+ ToolTip.SetTip(tabSeg, Loc.T("device.rhythm.sound_the_voices_source_and"));
if (!_macroMode) voiceHead.Children.Add(tabSeg);
var voiceTools = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5, Margin = new Thickness(0, 0, 6, 0), VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Right };
var macros = new RhythmMacroSurface(engine, track, idx, isSample, Dots);
if (_macroMode)
{
- voiceTools.Children.Add(Mono(Loc.F("{0} slots · {1} assigned", MacroPanel.Count, MacroPanel.Assigned(macros))));
+ voiceTools.Children.Add(Mono(Loc.F("device.rhythm.slots_assigned", MacroPanel.Count, MacroPanel.Assigned(macros))));
Border map = null!;
map = MacroPanel.Button("Map", teal: true, () => MacroPanel.ShowMapMenu(ctx, macros, map, _macro));
map.Height = 14;
- ToolTip.SetTip(map, Loc.F("Add a receiver to {0}: a voice param, a kit setting or a voice's effect", macros.MacroName(_macro)));
+ ToolTip.SetTip(map, Loc.F("device.rhythm.add_a_receiver_to_a", macros.MacroName(_macro)));
voiceTools.Children.Add(map);
}
else if (_voiceTab == 0) { voiceTools.Children.Add(srcSeg); voiceTools.Children.Add(fileBtn); }
@@ -383,7 +383,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
var revText = new TextBlock { Text = "Reverse", FontSize = 7, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center };
var rev = SmallButton(revText, revText,
() => { Write(P("reverse"), G(P("reverse")) >= 0.5f ? 0f : 1f); Refresh(); }, () => G(P("reverse")) >= 0.5f);
- ToolTip.SetTip(rev, Loc.T("Play the region back to front"));
+ ToolTip.SetTip(rev, Loc.T("device.rhythm.play_the_region_back_to"));
if (I(P("reverse")) is var ri and >= 0) MidiLearn.Bind(rev, MidiTarget.PluginParam(track, -1, ri), engine.PluginParamName(track, -1, ri));
voiceTools.Children.Add(rev);
}
@@ -412,7 +412,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
string secs = sampleSecs > 0 ? " · " + NotaNum.Unit((en - st) * sampleSecs, "0.00", "s") : "";
sv.Set(sampleName, Hue(sel), st, en, G(P("reverse")) >= 0.5f, posSel, $"{RM.Pct(st)} → {RM.Pct(en)}{secs}");
});
- ToolTip.SetTip(sv, MenuKit.Keys(Loc.T("Drag the Start and End lines to set them · ⌥-click one to type it · double-click to load another file")));
+ ToolTip.SetTip(sv, MenuKit.Keys(Loc.T("device.rhythm.drag_the_start_and_end")));
{
// ⌥-click a line to type it (specs/035); double-click still loads a file, so no reset here.
string st = P("start"), ln = P("length");
@@ -441,7 +441,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
string cap = pit > 0 ? $"{RM.Ms(pit)} · {RM.Ms(dec)}" : RM.Ms(dec);
hv.Set(RM.VoiceNames[sel], dec, pit, RM.DecaySeconds(sel, 1, 0) * 0.8, pu, flashSel, cap);
});
- ToolTip.SetTip(hv, MenuKit.Keys(Loc.T("The hit: amp contour over the pitch drop · drag across for Decay, up / down for Tune (Shift = fine) · ⌥-click to type them")));
+ ToolTip.SetTip(hv, MenuKit.Keys(Loc.T("device.rhythm.the_hit_amp_contour_over")));
{
string dk = P("decay"), tn = P("tune");
ValueEntry.AttachAll(hv,
@@ -456,21 +456,21 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
Control[] cells = sampleMode
? new[]
{
- PKnob(P("start"), "START", v => RM.Pct(v), tip: Loc.T("Where in the file the hit starts")),
- PKnob(P("length"), "LENGTH", v => RM.Pct(v), tip: Loc.T("How much of the file plays, from Start")),
- PKnob(P("tune"), "TUNE", v => RM.Semis(RM.SampleSemis(v)), tip: Loc.T("Transpose, ±12 semitones")),
- PKnob(P("decay"), "DECAY", v => RM.Pct(v), tip: Loc.T("Amp decay — shortens the hit")),
+ PKnob(P("start"), "START", v => RM.Pct(v), tip: Loc.T("device.rhythm.where_in_the_file_the")),
+ PKnob(P("length"), "LENGTH", v => RM.Pct(v), tip: Loc.T("device.rhythm.how_much_of_the_file")),
+ PKnob(P("tune"), "TUNE", v => RM.Semis(RM.SampleSemis(v)), tip: Loc.T("device.rhythm.transpose_12_semitones")),
+ PKnob(P("decay"), "DECAY", v => RM.Pct(v), tip: Loc.T("device.rhythm.amp_decay_shortens_the_hit")),
PKnob(P("drive"), "DRIVE", v => RM.Pct(v), tip: "Saturation"),
- PKnob(P("level"), "LEVEL", v => RM.Pct(v), tip: Loc.T("The voice's level in the kit")),
+ PKnob(P("level"), "LEVEL", v => RM.Pct(v), tip: Loc.T("device.rhythm.the_voices_level_in_the")),
}
: new[]
{
- PKnob(P("tune"), "TUNE", v => RM.Pct(v), tip: Loc.T("Pitch (Kick, Snare, Tom, Hats, Perc) or noise colour (Clap, Rim)")),
+ PKnob(P("tune"), "TUNE", v => RM.Pct(v), tip: Loc.T("device.rhythm.pitch_kick_snare_tom_hats")),
PKnob(P("decay"), "DECAY", v => RM.Pct(v), tip: "Amp decay"),
- PKnob(P("punch"), "PUNCH", v => RM.Pct(v), tip: Loc.T("Attack click / snap")),
- PKnob(P("tone"), "TONE", v => RM.Pct(v), tip: Loc.T("Snare body ↔ noise · Hats metal ↔ noise · Perc ring ratio")),
+ PKnob(P("punch"), "PUNCH", v => RM.Pct(v), tip: Loc.T("device.rhythm.attack_click_snap")),
+ PKnob(P("tone"), "TONE", v => RM.Pct(v), tip: Loc.T("device.rhythm.snare_body_noise_hats_metal")),
PKnob(P("drive"), "DRIVE", v => RM.Pct(v), tip: "Saturation"),
- PKnob(P("level"), "LEVEL", v => RM.Pct(v), tip: Loc.T("The voice's level in the kit")),
+ PKnob(P("level"), "LEVEL", v => RM.Pct(v), tip: Loc.T("device.rhythm.the_voices_level_in_the")),
};
for (int i = 0; i < cells.Length; i++) { Grid.SetColumn(cells[i], i); knobs.Children.Add(cells[i]); }
@@ -494,7 +494,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
// ---- PERFORM --------------------------------------------------------------------------
var perfHead = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), Margin = new Thickness(8, 0) };
perfHead.Children.Add(Cap("PERFORM"));
- var perfSub = Mono(Loc.T("shift+step = accent"), NotaPalette.TextDisabled); perfSub.HorizontalAlignment = HorizontalAlignment.Right;
+ var perfSub = Mono(Loc.T("device.rhythm.shift_step_accent"), NotaPalette.TextDisabled); perfSub.HorizontalAlignment = HorizontalAlignment.Right;
Grid.SetColumn(perfSub, 1); perfHead.Children.Add(perfSub);
var sliders = new StackPanel
@@ -502,9 +502,9 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
Spacing = 6,
Children =
{
- Slider("SWING", "swing", Loc.T("Swing: delays every second 16th — at 100\u2009% by half a step")),
- Slider("HUMAN", "humanize", Loc.T("Humanize: a random nudge to every hit's velocity")),
- Slider("ACCENT", "accent", Loc.T("How much louder an accented step plays")),
+ Slider("SWING", "swing", Loc.T("device.rhythm.swing_delays_every_second_16th")),
+ Slider("HUMAN", "humanize", Loc.T("device.rhythm.humanize_a_random_nudge_to")),
+ Slider("ACCENT", "accent", Loc.T("device.rhythm.how_much_louder_an_accented")),
},
};
@@ -524,8 +524,8 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
meterBlock.Children.Add(meter);
Grid.SetColumn(meterScale, 1); meterBlock.Children.Add(meterScale);
- var master = PKnob("volume", "MASTER", v => RM.Pct(v), 40, 46, Loc.T("The kit's output level"));
- var glue = PKnob("glue", "GLUE", v => RM.Pct(v), 30, 40, Loc.T("Glue: a bus compressor on the whole kit — holds the hits together (0 = off)"));
+ var master = PKnob("volume", "MASTER", v => RM.Pct(v), 40, 46, Loc.T("device.rhythm.the_kits_output_level"));
+ var glue = PKnob("glue", "GLUE", v => RM.Pct(v), 30, 40, Loc.T("device.rhythm.glue_a_bus_compressor_on"));
var perfFoot = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*"), ColumnSpacing = 6 };
perfFoot.Children.Add(master);
Grid.SetColumn(glue, 1); perfFoot.Children.Add(glue);
@@ -582,8 +582,8 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
}
float cur = strip.Vel[s];
bool on = strip.On[s];
- Item(Loc.F("Step {0} accent", s + 1), () => { strip.On[s] = true; strip.Acc[s] = !(on && strip.Acc[s]); strip.Vel[s] = Math.Max(cur, RM.NormalVel); strip.Commit!(s); strip.Changed(); }, on && strip.Acc[s]);
- Item(Loc.F("Step {0} quiet", s + 1), () => { strip.On[s] = true; strip.Acc[s] = false; strip.Vel[s] = RM.QuietVel; strip.Commit!(s); strip.Changed(); }, on && !strip.Acc[s] && cur < RM.QuietBelow);
+ Item(Loc.F("device.rhythm.step_accent", s + 1), () => { strip.On[s] = true; strip.Acc[s] = !(on && strip.Acc[s]); strip.Vel[s] = Math.Max(cur, RM.NormalVel); strip.Commit!(s); strip.Changed(); }, on && strip.Acc[s]);
+ Item(Loc.F("device.rhythm.step_quiet", s + 1), () => { strip.On[s] = true; strip.Acc[s] = false; strip.Vel[s] = RM.QuietVel; strip.Commit!(s); strip.Changed(); }, on && !strip.Acc[s] && cur < RM.QuietBelow);
var velMenu = new MenuItem { Header = "Velocity" };
foreach (var pv in new[] { 1f, 0.75f, 0.5f, 0.25f })
{
@@ -594,17 +594,17 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
}
fly.Items.Add(velMenu);
fly.Items.Add(new Separator());
- Item(Loc.T("Fill every beat"), () => SetSteps(k => (k % 4 == 0, RM.NormalVel, false)));
- Item(Loc.T("Fill every 8th"), () => SetSteps(k => (k % 2 == 0, RM.NormalVel, false)));
- Item(Loc.T("Fill every 16th"), () => SetSteps(_ => (true, RM.NormalVel, false)));
- Item(Loc.T("Off-beats"), () => SetSteps(k => (k % 4 == 2, RM.NormalVel, false)));
+ Item(Loc.T("device.rhythm.fill_every_beat"), () => SetSteps(k => (k % 4 == 0, RM.NormalVel, false)));
+ Item(Loc.T("device.rhythm.fill_every_8th"), () => SetSteps(k => (k % 2 == 0, RM.NormalVel, false)));
+ Item(Loc.T("device.rhythm.fill_every_16th"), () => SetSteps(_ => (true, RM.NormalVel, false)));
+ Item(Loc.T("device.rhythm.off_beats"), () => SetSteps(k => (k % 4 == 2, RM.NormalVel, false)));
fly.Items.Add(new Separator());
(bool, float, bool)[] Snap() { var a = new (bool, float, bool)[RM.Steps]; for (int k = 0; k < RM.Steps; k++) a[k] = (strip.On[k], strip.Vel[k], strip.Acc[k]); return a; }
- Item(Loc.T("Shift left"), () => { var a = Snap(); SetSteps(k => a[(k + 1) % RM.Steps]); });
- Item(Loc.T("Shift right"), () => { var a = Snap(); SetSteps(k => a[(k + RM.Steps - 1) % RM.Steps]); });
- Item(Loc.T("Reverse"), () => { var a = Snap(); SetSteps(k => a[RM.Steps - 1 - k]); });
+ Item(Loc.T("device.rhythm.shift_left"), () => { var a = Snap(); SetSteps(k => a[(k + 1) % RM.Steps]); });
+ Item(Loc.T("device.rhythm.shift_right"), () => { var a = Snap(); SetSteps(k => a[(k + RM.Steps - 1) % RM.Steps]); });
+ Item(Loc.T("common.reverse"), () => { var a = Snap(); SetSteps(k => a[RM.Steps - 1 - k]); });
fly.Items.Add(new Separator());
- fly.Items.Add(MenuKit.Danger(Loc.F("Clear {0}", RM.VoiceNames[sel]), GlyphKind.Trash, () => SetSteps(k => (false, strip.Vel[k], false))));
+ fly.Items.Add(MenuKit.Danger(Loc.F("device.rhythm.clear", RM.VoiceNames[sel]), GlyphKind.Trash, () => SetSteps(k => (false, strip.Vel[k], false))));
fly.ShowAt(strip);
};
@@ -615,7 +615,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
int bb = b;
var tb = new TextBlock { Text = RM.BankNames[b], FontSize = 7, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center };
var cell = new Border { CornerRadius = NotaRadius.Badge, Padding = new Thickness(5, 0), Cursor = new Cursor(StandardCursorType.Hand), Child = tb };
- ToolTip.SetTip(cell, Loc.F("Bank {0} — play and edit this pattern · right-click to copy or clear it", RM.BankNames[b]));
+ ToolTip.SetTip(cell, Loc.F("device.rhythm.bank_play_and_edit_this", RM.BankNames[b]));
cell.PointerPressed += (_, e) =>
{
var pt = e.GetCurrentPoint(cell);
@@ -639,18 +639,18 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
void BankMenu(int b, Control anchor)
{
var fly = new MenuFlyout();
- var copy = new MenuItem { Header = Loc.F("Copy {0} to", RM.BankNames[b]) };
+ var copy = new MenuItem { Header = Loc.F("device.rhythm.copy_to", RM.BankNames[b]) };
for (int d = 0; d < RM.Banks; d++)
{
if (d == b) continue;
int dd = d;
- var mi = new MenuItem { Header = Loc.F("Bank {0}", RM.BankNames[d]) };
+ var mi = new MenuItem { Header = Loc.F("device.rhythm.bank", RM.BankNames[d]) };
mi.Click += (_, _) => { Act(RM.A_CopyBank, b * RM.Banks + dd); ctx.NotifyChanged(); ReloadPattern(); };
copy.Items.Add(mi);
}
fly.Items.Add(copy);
fly.Items.Add(new Separator());
- fly.Items.Add(MenuKit.Danger(Loc.F("Clear bank {0}", RM.BankNames[b]), GlyphKind.Trash,
+ fly.Items.Add(MenuKit.Danger(Loc.F("device.rhythm.clear_bank", RM.BankNames[b]), GlyphKind.Trash,
() => { Act(RM.A_ClearBank, b); ctx.NotifyChanged(); ReloadPattern(); }));
fly.ShowAt(anchor);
}
@@ -662,7 +662,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
var stepCount = Mono("", TextTertiary);
stepCount.HorizontalAlignment = HorizontalAlignment.Right;
- readouts.Add(() => stepCount.Text = Loc.F("{0} of {1} · 1/16 · bank {2}", pat.Count(bank, sel), RM.Steps, RM.BankNames[bank]));
+ readouts.Add(() => stepCount.Text = Loc.F("device.rhythm.of_1_16_bank", pat.Count(bank, sel), RM.Steps, RM.BankNames[bank]));
var stepHead = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,Auto,*"), ColumnSpacing = 6, Height = 12 };
stepHead.Children.Add(Cap("STEP"));
var stepName = new TextBlock { Text = RM.VoiceNames[sel], FontSize = 8, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center };
@@ -749,7 +749,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
public int MacroParamIndex(int m) => idx.TryGetValue(RM.MacroId(m), out int i) ? i : -1;
public string MacroName(int m) => e.RhythmMacroName(track, m);
public void SetMacroName(int m, string n) => e.RhythmSetMacroName(track, m, n);
- public string SlotCount(int n) => Loc.Plural(n, "{0} voice", "{0} voices");
+ public string SlotCount(int n) => Loc.Plural("device.rhythm.voices", n);
public IReadOnlyList<int> Slots() => new[] { 0, 1, 2, 3, 4, 5, 6, 7 };
public string SlotName(int v) => v < 0 ? "Kit" : VoiceLabel(e, track, v, isSample[v]);
public IBrush SlotHue(int v) => v < 0 ? TextTertiary : NotaPalette.Ink(dots[v]);
@@ -789,7 +789,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
int P(string id) => idx.TryGetValue(id, out int i) ? i : -1;
// Every voice at once: the same param, or the same effect on each voice that has it.
- var all = new MenuItem { Header = Loc.Plural(RM.Voices, "All {0} voice", "All {0} voices") };
+ var all = new MenuItem { Header = Loc.Plural("device.rhythm.all_voices", RM.Voices) };
foreach (var key in VoiceTargets)
{
var mi = new MenuItem { Header = Title(key) };
@@ -815,7 +815,7 @@ internal sealed class RhythmInstrumentCard : IInstrumentCard
for (int v = 0; v < RM.Voices; v++)
for (int d = 0; d < e.RhythmVoiceDeviceCount(track, v); d++)
if (e.RhythmVoiceDeviceBuiltinKind(track, v, d) == kind) { holders.Add((v, d)); break; }
- var fx = new MenuItem { Header = Loc.F("Every {0} ({1})", dname, Loc.Plural(holders.Count, "{0} voice", "{0} voices")) };
+ var fx = new MenuItem { Header = Loc.F("device.rhythm.every", dname, Loc.Plural("device.rhythm.voices", holders.Count)) };
for (int p = 0; p < e.RhythmVoiceDeviceParamCount(track, v0, d0); p++)
{
int pp = p;
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/SamplerInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/SamplerInstrumentCard.cs
index e5ae0ae5..b591a465 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/SamplerInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/SamplerInstrumentCard.cs
@@ -221,9 +221,9 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
// ================= Sample tab =================
var wave = new SamplerWaveView();
- wave.SetEmpty(Loc.T("Drop a sample here"));
+ wave.SetEmpty(Loc.T("device.sampler.drop_a_sample_here"));
if (hasSample) wave.SetPeaks(SamplerModel.Peaks(raw, ch, 1200), durSec);
- ToolTip.SetTip(wave, hasSample ? MenuKit.Keys(Loc.T("Drag Start / End (and the loop markers when looping) · ⌥-click a marker to type it · double-click to reset it")) : Loc.T("Drag a sample from the Files tab or the browser"));
+ ToolTip.SetTip(wave, hasSample ? MenuKit.Keys(Loc.T("device.sampler.drag_start_end_and_the")) : Loc.T("device.sampler.drag_a_sample_from_the"));
wave.DragBegin += hnd => Begin(SamplerWaveView.HandleId(hnd));
wave.DragEnd += hnd => End(SamplerWaveView.HandleId(hnd));
wave.Moved += (hnd, f) => { SetP(SamplerWaveView.HandleId(hnd), f); Refresh(); };
@@ -253,10 +253,10 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
var (lm, rev) = SamplerModel.LoopValues(iv);
Write("loopmode", lm); Write("reverse", rev);
}, padX: 7, learnId: "loopmode");
- ToolTip.SetTip(loopSeg, Loc.T("Off plays once · Fwd loops · Ping bounces · Rev loops backwards"));
- var xfadeKnob = PKnob("loopxfade", "CROSSFADE", v => NotaNum.Time(SamplerModel.CrossfadeSec(v)), tip: Loc.T("Blends the loop's end into its start (forward loops)"));
+ ToolTip.SetTip(loopSeg, Loc.T("device.sampler.off_plays_once_fwd_loops"));
+ var xfadeKnob = PKnob("loopxfade", "CROSSFADE", v => NotaNum.Time(SamplerModel.CrossfadeSec(v)), tip: Loc.T("device.sampler.blends_the_loops_end_into"));
DimWhen(xfadeKnob, () => LoopSel() != 1);
- var gainKnob = PKnob("gain", "GAIN", v => NotaNum.Db(SamplerModel.GainDb(v), signed: true), tip: Loc.T("The sample's level before the envelope"));
+ var gainKnob = PKnob("gain", "GAIN", v => NotaNum.Db(SamplerModel.GainDb(v), signed: true), tip: Loc.T("device.sampler.the_samples_level_before_the"));
void SnapAll()
{
foreach (var id in new[] { "start", "end", "loopstart", "loopend" }) Write(id, SamplerModel.SnapZero(raw, ch, frames, G(id)));
@@ -268,15 +268,15 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
if (G("loopstart") < t.Start) Write("loopstart", t.Start);
if (G("loopend") > t.End) Write("loopend", t.End);
}
- var snapBtn = Button(Loc.T("Snap to zero"), SnapAll, Loc.T("Move Start, End and the loop to the nearest zero crossing — no clicks"), enabled: () => hasSample);
- var trimBtn = Button(Loc.T("Trim silence"), Trim, Loc.T("Move Start and End to where the sound begins and fades out (−48\u2009dB)"), enabled: () => hasSample);
+ var snapBtn = Button(Loc.T("device.sampler.snap_to_zero"), SnapAll, Loc.T("device.sampler.move_start_end_and_the"), enabled: () => hasSample);
+ var trimBtn = Button(Loc.T("device.sampler.trim_silence"), Trim, Loc.T("device.sampler.move_start_and_end_to"), enabled: () => hasSample);
snapBtn.HorizontalAlignment = HorizontalAlignment.Stretch; trimBtn.HorizontalAlignment = HorizontalAlignment.Stretch;
var sampleBtns = new StackPanel { Spacing = 3, VerticalAlignment = VerticalAlignment.Center, Children = { snapBtn, trimBtn } };
var sampleRow = Row(14, (Labeled("LOOP", loopSeg), "Auto"), (xfadeKnob, "Auto"), (gainKnob, "Auto"), (new Panel(), "*"), (sampleBtns, "Auto"));
// ================= Pitch tab =================
var keys = new SamplerKeysView();
- ToolTip.SetTip(keys, Loc.T("Click a key to make it the root — the key that plays the sample as recorded"));
+ ToolTip.SetTip(keys, Loc.T("device.sampler.click_a_key_to_make"));
keys.RootPicked += k => { rootv = k; acc.SetRoot(k); Refresh(); };
int NaturalKey()
{
@@ -286,7 +286,7 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
double off = SamplerModel.TransposeSt(G("transpose")) + SamplerModel.DetuneCents(G("detune")) / 100.0;
return (int)Math.Round(rootv - off / tr);
}
- readouts.Add(() => keys.Set(rootv, NaturalKey(), snap.Live ? snap.Note : -1, G("pitchtrack"), Loc.T("the key sets the playback speed")));
+ readouts.Add(() => keys.Set(rootv, NaturalKey(), snap.Live ? snap.Note : -1, G("pitchtrack"), Loc.T("device.sampler.the_key_sets_the_playback")));
var rootText = Mono(SamplerModel.NoteName(rootv), TextPrimary, 9);
rootText.HorizontalAlignment = HorizontalAlignment.Center;
readouts.Add(() => rootText.Text = SamplerModel.NoteName(rootv));
@@ -317,24 +317,24 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
e.Handled = true; if (s == 0) return;
rootv = Math.Clamp(rootv + s, 0, 127); acc.SetRoot(rootv); Refresh();
};
- ToolTip.SetTip(rootBox, Loc.T("The root note — scroll to step it"));
- var rootStepper = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, Children = { StepBtn(GlyphKind.Minus, -1, Loc.T("Root a semitone down")), rootBox, StepBtn(GlyphKind.Plus, +1, Loc.T("Root a semitone up")) } };
+ ToolTip.SetTip(rootBox, Loc.T("device.sampler.the_root_note_scroll_to"));
+ var rootStepper = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, Children = { StepBtn(GlyphKind.Minus, -1, Loc.T("device.sampler.root_a_semitone_down")), rootBox, StepBtn(GlyphKind.Plus, +1, Loc.T("device.sampler.root_a_semitone_up")) } };
int detected = SamplerModel.DetectRoot(sampleName);
- var detectBtn = Button(Loc.T("Detect from file name"), () => { if (detected >= 0) { rootv = detected; acc.SetRoot(detected); } },
- detected >= 0 ? Loc.F("\"{0}\" names {1} — make it the root", sampleName, SamplerModel.NoteName(detected))
- : sampleName.Length > 0 ? $"\"{sampleName}\" names no note (e.g. C4, F#3, Eb2)" : Loc.T("The sample's file name isn't known"),
+ var detectBtn = Button(Loc.T("device.sampler.detect_from_file_name"), () => { if (detected >= 0) { rootv = detected; acc.SetRoot(detected); } },
+ detected >= 0 ? Loc.F("device.sampler.names_make_it_the_root", sampleName, SamplerModel.NoteName(detected))
+ : sampleName.Length > 0 ? $"\"{sampleName}\" names no note (e.g. C4, F#3, Eb2)" : Loc.T("device.sampler.the_samples_file_name_isnt"),
on: () => detected >= 0 && detected == rootv, enabled: () => detected >= 0);
var pitchRow = Row(16,
- (PKnob("transpose", "TRANSPOSE", St, tip: Loc.T("Shift every note, ±24 semitones")), "Auto"),
- (PKnob("detune", "DETUNE", Cents, arc: Teal, tip: Loc.T("Fine tune, ±50 cents")), "Auto"),
- (PKnob("pitchtrack", "KEYTRACK", v => NotaNum.Pct(v), tip: Loc.T("How far the key moves the pitch — 100\u2009% chromatic, 0\u2009% every key plays the root")), "Auto"),
+ (PKnob("transpose", "TRANSPOSE", St, tip: Loc.T("device.sampler.shift_every_note_24_semitones")), "Auto"),
+ (PKnob("detune", "DETUNE", Cents, arc: Teal, tip: Loc.T("device.sampler.fine_tune_50_cents")), "Auto"),
+ (PKnob("pitchtrack", "KEYTRACK", v => NotaNum.Pct(v), tip: Loc.T("device.sampler.how_far_the_key_moves")), "Auto"),
(Labeled("ROOT", rootStepper), "Auto"),
(new Panel(), "*"),
(detectBtn, "Auto"));
// ================= Env tab =================
var env = new SamplerEnvView();
- ToolTip.SetTip(env, MenuKit.Keys(Loc.T("Drag the nodes: attack, decay and sustain (up / down), release · Shift for fine steps · ⌥-click to type · double-click resets")));
+ ToolTip.SetTip(env, MenuKit.Keys(Loc.T("device.sampler.drag_the_nodes_attack_decay")));
env.DragBegin += Begin;
env.DragEnd += End;
env.Changed += (id, v) => { SetP(id, v); Refresh(); };
@@ -354,7 +354,7 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
var velWord = Mono("", TextSecondary, 8);
readouts.Add(() => velWord.Text = G("velamount") > 0.005f ? NotaNum.Pct(G("velamount")) : "off");
var velBlock = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { Cap("VEL → VOL"), velSwitch, velWord } };
- ToolTip.SetTip(velBlock, Loc.T("Velocity sets the level — the amount is the rail's VEL → VOL"));
+ ToolTip.SetTip(velBlock, Loc.T("device.sampler.velocity_sets_the_level_the"));
var envRow = Row(16,
(PKnob("attack", "ATTACK", v => NotaNum.Time(SamplerModel.AttackSec(v))), "Auto"),
(PKnob("decay", "DECAY", v => NotaNum.Time(SamplerModel.DecaySec(v))), "Auto"),
@@ -365,7 +365,7 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
// ================= Filter tab =================
var filt = new SamplerFilterView();
- ToolTip.SetTip(filt, MenuKit.Keys(Loc.T("Drag: left / right for the cutoff, up / down for the resonance · Shift for fine steps · ⌥-click to type · double-click resets")));
+ ToolTip.SetTip(filt, MenuKit.Keys(Loc.T("device.sampler.drag_left_right_for_the")));
filt.DragBegin += () => { Begin("cutoff"); Begin("resonance"); };
filt.DragEnd += () => { End("cutoff"); End("resonance"); };
filt.Changed += (id, v) => { SetP(id, v); Refresh(); };
@@ -386,13 +386,13 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
}
readouts.Add(() => filt.Set(Sel("filtertype", 4), G("cutoff"), G("resonance"), snap.Live ? snap.CutoffHz : -1, FiltTl()));
var typeSeg = ParamChips("filtertype", SamplerModel.FilterNames, padX: 7);
- ToolTip.SetTip(typeSeg, Loc.T("Off · low-pass · high-pass · band-pass (12\u2009dB/oct)"));
+ ToolTip.SetTip(typeSeg, Loc.T("device.sampler.off_low_pass_high_pass"));
var cutKnob = PKnob("cutoff", "CUTOFF", v => NotaNum.Hz(SamplerModel.CutoffHz(v)), NotaSize.KnobMain, 58, emphasised: true);
var resoKnob = PKnob("resonance", "RESO", v => NotaNum.Pct(v));
- var ktKnob = PKnob("keytrack", "KEYTRACK", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("The cutoff follows the key, 0 … 100\u2009%"));
+ var ktKnob = PKnob("keytrack", "KEYTRACK", v => NotaNum.Pct(v), arc: Teal, tip: Loc.T("device.sampler.the_cutoff_follows_the_key"));
var envBtn = Button("Env → Cutoff", () => Write("envcutoff", G("envcutoff") >= 0.5f ? 0 : 1),
- Loc.T("Let the amp envelope open (or close) the filter — the depth is ENV"), on: () => G("envcutoff") >= 0.5f, learnId: "envcutoff");
- var envAmt = PKnob("envamount", "ENV", Oct, arc: Teal, tip: Loc.T("How far the envelope moves the cutoff, ±6 octaves"));
+ Loc.T("device.sampler.let_the_amp_envelope_open"), on: () => G("envcutoff") >= 0.5f, learnId: "envcutoff");
+ var envAmt = PKnob("envamount", "ENV", Oct, arc: Teal, tip: Loc.T("device.sampler.how_far_the_envelope_moves"));
var filterBody = new[] { cutKnob, resoKnob, ktKnob };
foreach (var c in filterBody) DimWhen(c, () => Sel("filtertype", 4) == 0);
DimWhen(envAmt, () => Sel("filtertype", 4) == 0 || G("envcutoff") < 0.5f);
@@ -445,7 +445,7 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
// ---- the rail · voices and output -----------------------------------------------
var voiceSeg = ParamChips("voicemode", SamplerModel.VoiceNames, padX: 5);
- ToolTip.SetTip(voiceSeg, Loc.T("Poly: 16 voices · Mono: one at a time (legato with Glide) · Choke: a new note cuts the ringing ones"));
+ ToolTip.SetTip(voiceSeg, Loc.T("device.sampler.poly_16_voices_mono_one"));
var railHead = new Grid { Height = TabH, ColumnDefinitions = new ColumnDefinitions("Auto,*"), Margin = new Thickness(8, 0) };
var railCap = Cap("VOICES");
railHead.Children.Add(railCap);
@@ -457,13 +457,13 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
Spacing = 6,
Children =
{
- Slider("VOLUME", "volume", () => DbLin(G("volume")), tip: Loc.T("The voices' level")),
+ Slider("VOLUME", "volume", () => DbLin(G("volume")), tip: Loc.T("device.sampler.the_voices_level")),
Slider("PAN", "pan", () => PanText(G("pan")), bipolar: true),
- Slider("GLIDE", "glide", () => GlideText(G("glide")), tip: Loc.T("Slide from the last note — in Mono, legato: no retrigger")),
+ Slider("GLIDE", "glide", () => GlideText(G("glide")), tip: Loc.T("device.sampler.slide_from_the_last_note")),
},
};
- var outKnob = PKnob("output", "OUTPUT", v => NotaNum.Pct(v), NotaSize.KnobMain, 50, tip: Loc.T("The level after everything"));
- var velKnob = PKnob("velamount", "VEL → VOL", v => NotaNum.Pct(v), cellW: 50, arc: Teal, tip: Loc.T("How much velocity sets the level"));
+ var outKnob = PKnob("output", "OUTPUT", v => NotaNum.Pct(v), NotaSize.KnobMain, 50, tip: Loc.T("device.sampler.the_level_after_everything"));
+ var velKnob = PKnob("velamount", "VEL → VOL", v => NotaNum.Pct(v), cellW: 50, arc: Teal, tip: Loc.T("device.sampler.how_much_velocity_sets_the"));
Control meterBlock;
if (acc.TryMeter(out _))
@@ -504,14 +504,14 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
{
double a = SamplerModel.AttackSec(G("attack")), s = G("sustain"), rel = SamplerModel.ReleaseSec(G("release"));
if (s < 0.05) return "a pluck — it decays to silence while held";
- if (a < 0.01 && s > 0.89 && rel < 0.05) return Loc.T("almost a gate — the sample is heard whole");
- if (a > 0.3) return Loc.T("a slow swell");
- if (rel > 1.0) return Loc.T("a long tail after release");
- return Loc.T("held at the sustain level");
+ if (a < 0.01 && s > 0.89 && rel < 0.05) return Loc.T("device.sampler.almost_a_gate_the_sample");
+ if (a > 0.3) return Loc.T("device.sampler.a_slow_swell");
+ if (rel > 1.0) return Loc.T("device.sampler.a_long_tail_after_release");
+ return Loc.T("device.sampler.held_at_the_sustain_level");
}
string Summary()
{
- if (!hasSample) return Loc.T("No sample · drop one from the Files tab or the browser");
+ if (!hasSample) return Loc.T("device.sampler.no_sample_drop_one_from");
switch (tab)
{
case 0:
@@ -520,25 +520,25 @@ internal sealed class SamplerInstrumentCard : IInstrumentCard
int l = LoopSel();
string loop = l == 0 ? "loop off, crossfade not applied"
: l == 1 ? $"{LoopWord()} · crossfade {NotaNum.Time(SamplerModel.CrossfadeSec(G("loopxfade")))}"
- : Loc.F("{0} · no crossfade", LoopWord());
+ : Loc.F("device.sampler.no_crossfade", LoopWord());
string gain = Math.Abs(SamplerModel.GainDb(G("gain"))) > 0.05 ? $" · gain {NotaNum.Db(SamplerModel.GainDb(G("gain")), signed: true)}" : "";
return $"{name}{WindowText()} · {loop}{gain}";
}
case 1:
{
int nat = NaturalKey();
- string tail = nat == rootv ? Loc.T("the sample plays at its own pitch on the root")
- : nat < 0 ? Loc.T("every key plays the same pitch")
- : Loc.F("{0} plays the sample at its own pitch", SamplerModel.NoteName(nat));
+ string tail = nat == rootv ? Loc.T("device.sampler.the_sample_plays_at_its")
+ : nat < 0 ? Loc.T("device.sampler.every_key_plays_the_same")
+ : Loc.F("device.sampler.plays_the_sample_at_its", SamplerModel.NoteName(nat));
return $"Root {SamplerModel.NoteName(rootv)} · transpose {St(G("transpose"))} · detune {Cents(G("detune"))} · keytrack {NotaNum.Pct(G("pitchtrack"))} — {tail}";
}
case 2:
- return Loc.F("Env {0} — {1}", EnvTl(), EnvWord())
+ return Loc.F("device.sampler.env", EnvTl(), EnvWord())
+ (G("velamount") > 0.005f ? $" · velocity {NotaNum.Pct(G("velamount"))}" : " · velocity off");
default:
{
int t = Sel("filtertype", 4);
- if (t == 0) return Loc.T("Filter off — the sample passes untouched");
+ if (t == 0) return Loc.T("device.sampler.filter_off_the_sample_passes");
string kt = G("keytrack") > 0.005f ? $"keytrack {NotaNum.Pct(G("keytrack"))}" : "keytrack off";
string ev = G("envcutoff") >= 0.5f ? $" · env {Oct(G("envamount"))}" : "";
string live = snap.Live && snap.CutoffHz > 0 ? $" · now {NotaNum.Hz(snap.CutoffHz)}" : "";
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/SynthInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/SynthInstrumentCard.cs
index d671b06e..66de564b 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/SynthInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/SynthInstrumentCard.cs
@@ -179,7 +179,7 @@ internal sealed class SynthInstrumentCard : IInstrumentCard
() => G("velamp") > 1e-3f,
() => { if (G("velamp") > 1e-3f) { lastVel = G("velamp"); SetP("velamp", 0f); } else SetP("velamp", lastVel); Refresh(); },
out var velSync,
- liveLabel: () => G("velamp") > 1e-3f ? $"Vel → Vol {NotaNum.Pct(G("velamp"))}" : Loc.T("Vel → Vol off"));
+ liveLabel: () => G("velamp") > 1e-3f ? $"Vel → Vol {NotaNum.Pct(G("velamp"))}" : Loc.T("device.synth.vel_vol_off"));
readouts.Add(velSync);
if (I("velamp") is var vi and >= 0) MidiLearn.Bind(velSwitch, MidiTarget.PluginParam(track, -1, vi), "Vel → Vol");
@@ -363,7 +363,7 @@ internal sealed class SynthInstrumentCard : IInstrumentCard
+ (Sel("wave", 4) == 1 ? $" · pulse {NotaNum.Pct(0.05 + G("pulsewidth") * 0.90)}" : ""),
1 => $"Env {Secs(G("attack"), 0.001, 2.0)} · {Secs(G("decay"), 0.002, 2.0)} · {Db(G("sustain"))} · {Secs(G("release"), 0.002, 3.0)}",
_ => Sel("filtype", 4) == 0
- ? Loc.T("Filter off — the oscillator goes straight to the amplifier")
+ ? Loc.T("device.synth.filter_off_the_oscillator_goes")
: $"Filter {FilterNames[Sel("filtype", 4)]} · cutoff {KHz(G("cutoff"))} · Q {G("resonance").ToString("0.00", NotaNum.Culture)} · env {Bipolar(G("filenv"))}",
};
string Meta()
diff --git a/src/managed/Nota.App/DeviceCards/Instruments/VoltInstrumentCard.cs b/src/managed/Nota.App/DeviceCards/Instruments/VoltInstrumentCard.cs
index eabfa359..c79c0833 100644
--- a/src/managed/Nota.App/DeviceCards/Instruments/VoltInstrumentCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Instruments/VoltInstrumentCard.cs
@@ -596,7 +596,7 @@ internal sealed class VoltInstrumentCard : IInstrumentCard
LfoCell(PKnob("vibamt", "DEPTH", "Vibrato Depth", VibDepth, 28, 46, Teal), 2, 3);
var note = new TextBlock
{
- Text = Loc.T("vibrato always rides the pitch"), FontSize = NotaType.Axis, Foreground = TextDisabled,
+ Text = Loc.T("device.volt.vibrato_always_rides_the_pitch"), FontSize = NotaType.Axis, Foreground = TextDisabled,
VerticalAlignment = VerticalAlignment.Center, TextWrapping = TextWrapping.Wrap,
};
Grid.SetRow(note, 2); Grid.SetColumn(note, 4); Grid.SetColumnSpan(note, 2); lfoGrid.Children.Add(note);
@@ -620,7 +620,7 @@ internal sealed class VoltInstrumentCard : IInstrumentCard
}
var modHint = new TextBlock
{
- Text = MenuKit.Keys(Loc.T("drag a cell — up adds, down subtracts · ⌥-click types · double-click clears")), FontSize = NotaType.Axis,
+ Text = MenuKit.Keys(Loc.T("device.volt.drag_a_cell_up_adds")), FontSize = NotaType.Axis,
Foreground = TextDisabled, VerticalAlignment = VerticalAlignment.Center,
};
var modGrid = new Grid { RowDefinitions = new RowDefinitions("*,Auto"), RowSpacing = 3 };
@@ -650,7 +650,7 @@ internal sealed class VoltInstrumentCard : IInstrumentCard
FontSize = NotaType.Axis, Foreground = Teal, HorizontalAlignment = HorizontalAlignment.Center,
Cursor = new Cursor(StandardCursorType.Hand),
};
- ToolTip.SetTip(dest, Loc.T("Click for the next target, right-click for the previous"));
+ ToolTip.SetTip(dest, Loc.T("device.volt.click_for_the_next_target"));
void Step(int dir)
{
int n = MacroDests.Length;
@@ -693,7 +693,7 @@ internal sealed class VoltInstrumentCard : IInstrumentCard
{
bool on = MacroOn(mv);
int d = MacroDest(mv);
- name.Text = on ? Loc.F("Macro {0} · {1}", mv + 1, MacroWords[d]) : $"Macro {mv + 1}";
+ name.Text = on ? Loc.F("common.macro", mv + 1, MacroWords[d]) : $"Macro {mv + 1}";
name.Foreground = on ? NotaPalette.TextStrong : TextDisabled;
dest.Text = on ? "→ " + MacroDests[d] : "unassigned";
dest.Foreground = on ? Teal : TextDisabled;
@@ -709,9 +709,9 @@ internal sealed class VoltInstrumentCard : IInstrumentCard
var bodies = new Control[] { oscBody, filtBody, envBody, lfoBody, modBody, macroBody };
var tabCells = new Border[TabNames.Length];
var tabTexts = new TextBlock[TabNames.Length];
- var clearAll = TextButton(Loc.T("Clear all"));
+ var clearAll = TextButton(Loc.T("common.clear_all"));
clearAll.Margin = new Thickness(0, 0, 6, 0);
- ToolTip.SetTip(clearAll, Loc.T("Zero every route in the matrix"));
+ ToolTip.SetTip(clearAll, Loc.T("device.volt.zero_every_route_in_the"));
clearAll.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(clearAll).Properties.IsLeftButtonPressed) return;
@@ -938,7 +938,7 @@ internal sealed class VoltInstrumentCard : IInstrumentCard
2 => "amp · filter",
3 => $"{(SyncDiv(G("lfo1sync")) > 0 ? SyncText(G("lfo1sync")) : "free")} · {(SyncDiv(G("lfo2sync")) > 0 ? SyncText(G("lfo2sync")) : "free")} · vibrato {(G("vibamt") <= 1e-3f ? "off" : "on")}",
4 => Plural(RouteCount(), "route", "routes"),
- _ => Loc.F("8 slots · {0} assigned", MacroAssigned()),
+ _ => Loc.F("device.volt.8_slots_assigned", MacroAssigned()),
};
string Summary() => tab switch
{
@@ -954,7 +954,7 @@ internal sealed class VoltInstrumentCard : IInstrumentCard
+ $"LFO 2 {ShapeNames[Sel("lfo2shape", 4)]} {(SyncDiv(G("lfo2sync")) > 0 ? SyncText(G("lfo2sync")) : SlowHz(ExpMap(G("lfo2rate"), 0.05, 20)))} {LfoDest(3)} · "
+ $"vibrato {(G("vibamt") <= 1e-3f ? "off" : VibDepth(G("vibamt")) + (G("vibwheel") >= 0.5f ? " by wheel" : ""))}",
4 => RouteCount() == 0 ? "no routes — drag a cell to make one" : Plural(RouteCount(), "route", "routes") + " in the matrix",
- _ => Loc.F("8 slots · {0} assigned", MacroAssigned()),
+ _ => Loc.F("device.volt.8_slots_assigned", MacroAssigned()),
};
string Meta()
{
diff --git a/src/managed/Nota.App/DeviceCards/Midi/ArpMidiBody.cs b/src/managed/Nota.App/DeviceCards/Midi/ArpMidiBody.cs
index c0f0c9e3..a66c3483 100644
--- a/src/managed/Nota.App/DeviceCards/Midi/ArpMidiBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Midi/ArpMidiBody.cs
@@ -133,7 +133,7 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
string ChordText()
{
var c = grid.Chord;
- return c.Count == 0 ? Loc.T("no notes yet") : string.Join(" ", c.Select(DeviceCardKit.NoteName));
+ return c.Count == 0 ? Loc.T("device.arp.no_notes_yet") : string.Join(" ", c.Select(DeviceCardKit.NoteName));
}
string RetrigText() => RetrigNames[Math.Clamp(GI(GRetrig), 0, 2)].ToLowerInvariant();
@@ -145,12 +145,12 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
var lane = Lanes[grid.LaneIndex];
(int s, double v) = grid.LastEdit ?? (Math.Max(0, grid.Position), lane.ToDisp(G(lane.Base + Math.Max(0, grid.Position))));
v = Math.Clamp(v, lane.Min, lane.Max);
- return shortForm ? $"{s + 1} · {lane.Fmt(v)}" : Loc.F("step {0} · {1}", s + 1, lane.Fmt(v));
+ return shortForm ? $"{s + 1} · {lane.Fmt(v)}" : Loc.F("device.arp.step", s + 1, lane.Fmt(v));
}
int len = Math.Max(1, grid.CurrentSequence().Count);
if (shortForm) return $"{(grid.Position >= 0 ? grid.Position + 1 : 1)}/{grid.StepCount}";
if (grid.Chord.Count == 0) return "preview · play a chord";
- return Loc.F("{0} notes · {1} oct · cycle {2} steps", grid.Chord.Count, Math.Clamp(GI(GOctaves), 1, 8), len);
+ return Loc.F("device.arp.notes_oct_cycle_steps", grid.Chord.Count, Math.Clamp(GI(GOctaves), 1, 8), len);
}
Control root = mini ? BuildMini() : BuildLarge();
@@ -298,7 +298,7 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
Ruled(ButtonsRow()),
};
for (int i = 0; i < playRows.Count; i++) { Grid.SetRow(playRows[i], i * 2); play.Children.Add(playRows[i]); }
- var playHead = IslandHead(Caps("PLAY"), Mono(Loc.T("MIDI out · ch 1"), Cap, 7));
+ var playHead = IslandHead(Caps("PLAY"), Mono(Loc.T("device.arp.midi_out_ch_1"), Cap, 7));
var playIsland = IslandBox(playHead, new Border { Padding = new Thickness(8, 5), Child = play }, 176);
var islands = new DockPanel { Background = Ground, Children = { WithDock(orderIsland, Dock.Left), WithDock(playIsland, Dock.Right), centerIsland } };
@@ -310,7 +310,7 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
readouts.Add(() =>
{
statusL.Text = $"{ChordText()} · {OrderName(GI(GOrder))} · {Math.Clamp(GI(GOctaves), 1, 8)} oct · {RateLabel(engine, track, mi)} · {grid.StepCount} steps · retrig {RetrigText()}{(G(GHold) > 0.5f ? " · hold" : "")}";
- statusR.Text = engine.MidiEffectBypassed(track, mi) ? "bypassed" : grid.Running ? Loc.T("MIDI · latency 0 smp") : Loc.T("MIDI · waiting for notes");
+ statusR.Text = engine.MidiEffectBypassed(track, mi) ? "bypassed" : grid.Running ? Loc.T("common.midi_latency_0_smp") : Loc.T("device.arp.midi_waiting_for_notes");
});
return Framed(islands, statusL, statusR);
}
@@ -324,7 +324,7 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
var laneName = new TextBlock { FontSize = 8, Foreground = Txt, VerticalAlignment = VerticalAlignment.Center };
var laneBtn = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, Cursor = new Cursor(StandardCursorType.Hand), Background = Brushes.Transparent,
Children = { laneName, new Glyph { Kind = GlyphKind.ChevronDown, Width = 6, Height = 6, Foreground = Cap, VerticalAlignment = VerticalAlignment.Center } } };
- ToolTip.SetTip(laneBtn, Loc.T("Next Groove lane"));
+ ToolTip.SetTip(laneBtn, Loc.T("device.arp.next_groove_lane"));
laneBtn.PointerPressed += (_, ev) =>
{
if (!ev.GetCurrentPoint(laneBtn).Properties.IsLeftButtonPressed) return;
@@ -363,7 +363,7 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
var statusR = Mono("", Sub);
readouts.Add(() =>
{
- statusL.Text = Loc.F("{0} · {1} oct", ChordText(), Math.Clamp(GI(GOctaves), 1, 8));
+ statusL.Text = Loc.F("device.arp.oct", ChordText(), Math.Clamp(GI(GOctaves), 1, 8));
statusR.Text = engine.MidiEffectBypassed(track, mi) ? "bypassed" : RateLabel(engine, track, mi);
});
return Framed(new Border { Background = Ground, Child = island }, statusL, statusR);
@@ -469,7 +469,7 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
tb = t; return b;
}
var hold = Btn("Hold", () => { S(GHold, G(GHold) > 0.5f ? 0 : 1); Refresh(); }, out var holdTb);
- ToolTip.SetTip(hold, Loc.T("Hold: keep arpeggiating after the keys are released"));
+ ToolTip.SetTip(hold, Loc.T("device.arp.hold_keep_arpeggiating_after_the"));
Learn(hold, GHold, "Hold");
readouts.Add(() =>
{
@@ -482,7 +482,7 @@ internal sealed class ArpMidiBody : IMidiDeviceBody
var restart = Btn("Restart", () => engine.MidiEffectCommand(track, mi, 1), out var rTb);
restart.PointerEntered += (_, _) => restart.Background = NotaPalette.SurfaceHover;
restart.PointerExited += (_, _) => restart.Background = NotaPalette.TrackOff;
- ToolTip.SetTip(restart, Loc.T("Restart the pattern from step 1"));
+ ToolTip.SetTip(restart, Loc.T("device.arp.restart_the_pattern_from_step"));
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 6 };
Grid.SetColumn(restart, 1); g.Children.Add(hold); g.Children.Add(restart);
return g;
diff --git a/src/managed/Nota.App/DeviceCards/Midi/ChordMidiBody.cs b/src/managed/Nota.App/DeviceCards/Midi/ChordMidiBody.cs
index d435d1ee..fe510bf8 100644
--- a/src/managed/Nota.App/DeviceCards/Midi/ChordMidiBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Midi/ChordMidiBody.cs
@@ -202,7 +202,7 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
int KeyStart() { int lo = notes.Count > 0 ? Math.Min(root, notes[0].Pitch) : root; return (int)Math.Floor(lo / 12.0) * 12; }
string NoteList() => notes.Count == 0 ? "—" : string.Join(" ", notes.Select(n => DeviceCardKit.NoteName(n.Pitch)));
int RingPitch() => G(KeepRoot) >= 0.5f ? -1 : root;
- string StatusRight() => engine.MidiEffectBypassed(track, mi) ? "bypassed" : Loc.T("MIDI · latency 0 smp");
+ string StatusRight() => engine.MidiEffectBypassed(track, mi) ? "bypassed" : Loc.T("common.midi_latency_0_smp");
Poll();
Control rootView = mini ? BuildMini() : BuildLarge();
@@ -235,12 +235,12 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
rowB.PointerEntered += (_, _) => { hover = true; Paint(); };
rowB.PointerExited += (_, _) => { hover = false; Paint(); };
rowB.PointerPressed += (_, ev) => { if (!ev.GetCurrentPoint(rowB).Properties.IsLeftButtonPressed) return; ApplyType(ti); ev.Handled = true; };
- ToolTip.SetTip(rowB, Types[i].Shifts is null ? Loc.T("Custom: your own shifts") : Loc.F("{0}: set the shifts to {1}", Types[i].Name, hint.Text));
+ ToolTip.SetTip(rowB, Types[i].Shifts is null ? Loc.T("device.chord.custom_your_own_shifts") : Loc.F("device.chord.set_the_shifts_to", Types[i].Name, hint.Text));
readouts.Add(Paint);
list.Children.Add(rowB);
}
- var flags = new StackPanel { Spacing = 4, Children = { Flag(KeepRoot, "Keep root", Loc.T("Play the note you pressed as well as the added notes")),
- Flag(Fold, "Fold in scale", Loc.T("Drop added notes outside the scale a semitone into it")) } };
+ var flags = new StackPanel { Spacing = 4, Children = { Flag(KeepRoot, "Keep root", Loc.T("device.chord.play_the_note_you_pressed")),
+ Flag(Fold, "Fold in scale", Loc.T("device.chord.drop_added_notes_outside_the")) } };
flags.Children.Add(ScaleLabel());
var typeFoot = new Border { BorderBrush = Rule, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(8, 6), Child = flags };
var typeIsland = IslandBox(IslandHead(Caps("TYPE"), null), new DockPanel { Children = { WithDock(typeFoot, Dock.Bottom), list } }, 100);
@@ -287,7 +287,7 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
var statusR = Mono("", Sub);
readouts.Add(() =>
{
- statusL.Text = Loc.F("In {0} · {1} · {2} voices · strum {3}\u2009ms · spread {4}", DeviceCardKit.NoteName(root), Types[TypeIndex()].Name, voices, StrumMs(), SpreadText())
+ statusL.Text = Loc.F("device.chord.in_voices_strum_ms_spread", DeviceCardKit.NoteName(root), Types[TypeIndex()].Name, voices, StrumMs(), SpreadText())
+ (G(Fold) >= 0.5f ? $" · fold {ScaleName(G, true)}" : "");
statusR.Text = StatusRight();
});
@@ -314,8 +314,8 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
var spread = KnobCell("SPREAD", Spread, () => G(Spread) / 100, n => S(Spread, Math.Round(n * 100)), SpreadText);
var flags = new StackPanel { Spacing = 4, VerticalAlignment = VerticalAlignment.Center, Children =
{
- Flag(KeepRoot, "Keep root", Loc.T("Play the note you pressed as well as the added notes")),
- Flag(Fold, "Fold in scale", Loc.F("Drop added notes outside {0} a semitone into it", ScaleName(G, false))),
+ Flag(KeepRoot, "Keep root", Loc.T("device.chord.play_the_note_you_pressed")),
+ Flag(Fold, "Fold in scale", Loc.F("device.chord.drop_added_notes_outside_a", ScaleName(G, false))),
} };
Grid.SetColumn(spread, 1); Grid.SetColumn(flags, 2);
knobs.Children.Add(strum); knobs.Children.Add(spread); knobs.Children.Add(flags);
@@ -337,7 +337,7 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
var statusR = Mono("", Sub);
readouts.Add(() =>
{
- statusL.Text = Loc.F("In {0} · {1} · {2} voices", DeviceCardKit.NoteName(root), Types[TypeIndex()].Name, voices);
+ statusL.Text = Loc.F("device.chord.in_voices", DeviceCardKit.NoteName(root), Types[TypeIndex()].Name, voices);
statusR.Text = engine.MidiEffectBypassed(track, mi) ? "bypassed" : $"strum {StrumMs()}\u2009ms";
});
return Framed(island, statusL, statusR);
@@ -414,8 +414,8 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
if (!ev.GetCurrentPoint(modeTb).Properties.IsLeftButtonPressed) return;
S(FoldMode, G(FoldMode) >= 0.5f ? 0 : 1); Edited(); ev.Handled = true;
};
- ToolTip.SetTip(keyTb, Loc.T("Fold key — click for the next, Shift-click for the previous"));
- ToolTip.SetTip(modeTb, Loc.T("Fold scale — major / natural minor"));
+ ToolTip.SetTip(keyTb, Loc.T("device.chord.fold_key_click_for_the"));
+ ToolTip.SetTip(modeTb, Loc.T("device.chord.fold_scale_major_natural_minor"));
Learn(keyTb, FoldKey, "Fold Key"); Learn(modeTb, FoldMode, "Fold Mode");
readouts.Add(() =>
{
@@ -438,7 +438,7 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
if (!ev.GetCurrentPoint(dotHit).Properties.IsLeftButtonPressed) return;
S(pOn, G(pOn) >= 0.5f ? 0 : 1); ui.CustomPinned = false; Edited(); ev.Handled = true;
};
- ToolTip.SetTip(dotHit, Loc.F("Shift {0} on / off", s + 1));
+ ToolTip.SetTip(dotHit, Loc.F("device.chord.shift_on_off", s + 1));
Learn(dotHit, pOn, $"Shift {s + 1} on");
var st = Mono("", Txt, 9); st.FontWeight = FontWeight.SemiBold; st.Width = 24;
var ruler = new ChordShiftTrack { Height = 14, Margin = new Thickness(0, 0, 2, 0) };
@@ -488,7 +488,7 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
void Stop() { if (!drag) return; drag = false; End(p); Edited(); }
hit.PointerReleased += (_, ev) => { if (drag) ev.Pointer.Capture(null); Stop(); };
hit.PointerCaptureLost += (_, _) => Stop();
- ToolTip.SetTip(hit, MenuKit.Keys(Loc.F("Shift {0} velocity offset — drag sideways, ⌥-click to type, double-click resets", s + 1)));
+ ToolTip.SetTip(hit, MenuKit.Keys(Loc.F("device.chord.shift_velocity_offset_drag_sideways", s + 1)));
ValueEntry.Attach(hit, new ValueField($"Shift {s + 1} velocity", () => (GI(p) + 64) / 127.0, n => Sgn((int)Math.Round(-64 + n * 127)),
n => { S(p, (int)Math.Round(-64 + Math.Clamp(n, 0, 1) * 127)); ui.CustomPinned = true; Refresh(); }, () => Begin(p), () => End(p), 64 / 127.0) { After = Edited }, tb);
Learn(hit, p, $"Shift {s + 1} velocity");
@@ -504,7 +504,7 @@ internal sealed class ChordMidiBody : IMidiDeviceBody
bar.Changed += v => SetShift(s, v);
bar.GestureBegin += () => { Begin(pSt); Begin(pOn); }; bar.GestureEnd += () => { End(pSt); End(pOn); };
Learn(bar, pSt, $"Shift {s + 1}");
- ToolTip.SetTip(bar, Loc.F("Shift {0}: drag up / down (±12 semitones) · ⌥-click to type · double-click resets", s + 1));
+ ToolTip.SetTip(bar, Loc.F("device.chord.shift_drag_up_down_12", s + 1));
ValueEntry.Attach(bar, bar.EntryField($"Shift {s + 1}"));
var lbl = Mono("", Txt); lbl.HorizontalAlignment = HorizontalAlignment.Center;
var lblHit = new Border { Height = 11, Margin = new Thickness(0, 2, 0, 0), Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = lbl };
diff --git a/src/managed/Nota.App/DeviceCards/Midi/LengthMidiBody.cs b/src/managed/Nota.App/DeviceCards/Midi/LengthMidiBody.cs
index ff62c996..ea9fa132 100644
--- a/src/managed/Nota.App/DeviceCards/Midi/LengthMidiBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Midi/LengthMidiBody.cs
@@ -167,7 +167,7 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
fill: true, padX: 2, fontSize: 8);
readouts.Add(modeSync);
Learn(modeSeg, PMode, "Mode");
- ToolTip.SetTip(modeSeg, Loc.T("Sync: a tempo division · ms: a fixed time · Gate %: a share of how long each note was held"));
+ ToolTip.SetTip(modeSeg, Loc.T("device.length.sync_a_tempo_division_ms"));
var bigVal = Mono("", Txt, 18); bigVal.FontWeight = FontWeight.Medium; bigVal.LetterSpacing = -0.3;
var bigSub = Mono("", Cap, 7); bigSub.VerticalAlignment = VerticalAlignment.Bottom; bigSub.Margin = new Thickness(0, 0, 0, 4);
@@ -179,7 +179,7 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
lenTrack.Changed += n => { S(LenParam(G), LenFromNorm(G, n)); Refresh(); };
lenTrack.GestureBegin += () => { lenGesture = LenParam(G); Begin(lenGesture); };
lenTrack.GestureEnd += () => { if (lenGesture >= 0) End(lenGesture); lenGesture = -1; };
- ToolTip.SetTip(lenTrack, Loc.T("Length — drag up / down, double-click resets"));
+ ToolTip.SetTip(lenTrack, Loc.T("device.length.length_drag_up_down_double"));
ValueEntry.Attach(bigVal, () => LenNorm(G), n => S(LenParam(G), LenFromNorm(G, n)), () => LenValue(G),
() => { lenGesture = LenParam(G); Begin(lenGesture); }, () => { End(lenGesture); lenGesture = -1; }, Refresh, control: lenTrack);
readouts.Add(() =>
@@ -216,7 +216,7 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
i => { Begin(PTrigger); S(PTrigger, i); End(PTrigger); Refresh(); }, out var trigSync, fill: true, padX: 2, fontSize: 8);
readouts.Add(trigSync);
Learn(trigSeg, PTrigger, "Start From");
- ToolTip.SetTip(trigSeg, Loc.T("Count the length from the note-on, or from the note-off (the note fires when the key is released)"));
+ ToolTip.SetTip(trigSeg, Loc.T("device.length.count_the_length_from_the_2"));
var trigBox = new Border { BorderBrush = Rule, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 6, 0, 0),
Child = new StackPanel { Spacing = 4, Children = { Caps("START FROM"), trigSeg } } };
@@ -232,24 +232,24 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
var gateInfo = Mono("", Cap, 7);
readouts.Add(() =>
{
- gateInfo.Text = Loc.F("1 bar at {0:0} BPM · {1} notes", Bpm(), LengthGateViz.Input.Length);
+ gateInfo.Text = Loc.F("device.length.1_bar_at_bpm_notes", Bpm(), LengthGateViz.Input.Length);
gate.Set(notes, now, Bpm(), Bypassed());
});
- ToolTip.SetTip(gate, Loc.T("Outline — the note played in · fill — the note out · band — the range Random spreads it over. The shaded part is past the bar line."));
+ ToolTip.SetTip(gate, Loc.T("device.length.outline_the_note_played_in"));
var gateIsland = IslandBox(IslandHead(Caps("GATE"), gateInfo), new Border { Padding = new Thickness(8, 5, 8, 4), Child = gate }, double.NaN);
// ---- MODIFIERS ----
var mods = new StackPanel { Spacing = 9, Children =
{
- ModSlider("VEL → LEN", PVelToLen, true, Loc.T("loud notes longer at +")),
- ModSlider("KEY → LEN", PKeyToLen, true, Loc.T("low notes longer at +")),
- ModSlider("RANDOM", PRandom, false, Loc.T("spread per note")),
+ ModSlider("VEL → LEN", PVelToLen, true, Loc.T("device.length.loud_notes_longer_at")),
+ ModSlider("KEY → LEN", PKeyToLen, true, Loc.T("device.length.low_notes_longer_at")),
+ ModSlider("RANDOM", PRandom, false, Loc.T("device.length.spread_per_note")),
} };
var flags = new Border { BorderBrush = Rule, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 6, 0, 0),
Child = new StackPanel { Spacing = 5, Children =
{
- Flag(PLegato, Loc.T("Legato · retrigger held"), Loc.T("Each note lasts until the next one starts (at most to the bar line)")),
- Flag(PClipLimit, Loc.T("Clip length limit"), Loc.T("No note crosses the bar line it started in")),
+ Flag(PLegato, Loc.T("device.length.legato_retrigger_held"), Loc.T("device.length.each_note_lasts_until_the")),
+ Flag(PClipLimit, Loc.T("device.length.clip_length_limit"), Loc.T("device.length.no_note_crosses_the_bar")),
} } };
var modIsland = IslandBox(IslandHead(Caps("MODIFIERS"), null),
new DockPanel { Margin = new Thickness(8, 7), Children = { WithDock(flags, Dock.Bottom), mods } }, 172);
@@ -261,9 +261,9 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
var statusR = Mono("", Sub);
readouts.Add(() =>
{
- statusL.Text = Loc.F("{0} {1} · from {2} · avg out {3}", Modes[Mode(G)], LenValue(G), TrigName(), AvgOut())
+ statusL.Text = Loc.F("device.length.from_avg_out", Modes[Mode(G)], LenValue(G), TrigName(), AvgOut())
+ (G(PLegato) >= 0.5f ? " · legato" : "") + (G(PClipLimit) >= 0.5f ? " · clip" : "");
- statusR.Text = Bypassed() ? "bypassed" : Loc.T("MIDI · latency 0 smp");
+ statusR.Text = Bypassed() ? "bypassed" : Loc.T("common.midi_latency_0_smp");
});
return Framed(islands, statusL, statusR);
}
@@ -283,7 +283,7 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
int d = ev.KeyModifiers.HasFlag(KeyModifiers.Shift) ? 2 : 1;
Begin(PMode); S(PMode, (Mode(G) + d) % 3); End(PMode); Refresh(); ev.Handled = true;
};
- ToolTip.SetTip(modeChip, Loc.T("Length mode: Sync / ms / Gate % — click for the next, Shift-click for the previous"));
+ ToolTip.SetTip(modeChip, Loc.T("device.length.length_mode_sync_ms_gate"));
Learn(modeChip, PMode, "Mode");
var val = Mono("", Txt, 9); val.FontWeight = FontWeight.Medium;
@@ -291,7 +291,7 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
var head = new DockPanel { Height = 14, Children = { WithDock(modeChip, Dock.Left), WithDock(sub, Dock.Right), val } };
var gate = new LengthGateViz { Full = false };
- ToolTip.SetTip(gate, Loc.T("Outline — in · fill — out · band — Random's range"));
+ ToolTip.SetTip(gate, Loc.T("device.length.outline_in_fill_out_band"));
var knobs = new Grid { Height = 53, ColumnDefinitions = new ColumnDefinitions("*,*,*,*") };
var cells = new[]
@@ -324,7 +324,7 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
if (!ev.GetCurrentPoint(statusL).Properties.IsLeftButtonPressed) return;
Begin(PTrigger); S(PTrigger, G(PTrigger) >= 0.5f ? 0 : 1); End(PTrigger); Refresh(); ev.Handled = true;
};
- ToolTip.SetTip(statusL, Loc.T("Count the length from the note-on or the note-off — click to switch"));
+ ToolTip.SetTip(statusL, Loc.T("device.length.count_the_length_from_the"));
Learn(statusL, PTrigger, "Start From");
var statusR = Mono("", Sub);
readouts.Add(() =>
@@ -371,7 +371,7 @@ internal sealed class LengthMidiBody : IMidiDeviceBody
trk.GestureBegin += () => Begin(p);
trk.GestureEnd += () => End(p);
Learn(trk, p, label);
- ToolTip.SetTip(trk, Loc.F("{0} — drag up / down, double-click resets", label));
+ ToolTip.SetTip(trk, Loc.F("device.length.drag_up_down_double_click", label));
ValueEntry.Attach(v, toNorm, n => S(p, fromNorm(n)), () => bipolar ? Signed(G(p)) : $"±{Math.Round(G(p) * 100):0}\u2009%",
() => Begin(p), () => End(p), Refresh, control: trk);
readouts.Add(() =>
diff --git a/src/managed/Nota.App/DeviceCards/Midi/MidiCardHeader.cs b/src/managed/Nota.App/DeviceCards/Midi/MidiCardHeader.cs
index 6fa02279..a97bfe95 100644
--- a/src/managed/Nota.App/DeviceCards/Midi/MidiCardHeader.cs
+++ b/src/managed/Nota.App/DeviceCards/Midi/MidiCardHeader.cs
@@ -21,7 +21,7 @@ internal static class MidiCardHeader
{
var tb = new TextBlock { Text = "MIDI learn", FontSize = 8, VerticalAlignment = VerticalAlignment.Center };
var learn = new Border { Height = 16, CornerRadius = NotaRadius.Badge, Padding = new Thickness(6, 0), BorderThickness = new Thickness(1), Cursor = new Cursor(StandardCursorType.Hand), Child = tb };
- ToolTip.SetTip(learn, Loc.T("Map a hardware control: arm, touch a control on the card, move a knob or key"));
+ ToolTip.SetTip(learn, Loc.T("device.midi.map_a_hardware_control_arm"));
void Sync()
{
bool on = TopLevel.GetTopLevel(learn) is MainWindow w && w.MidiLearnArmed;
@@ -50,7 +50,7 @@ internal static class MidiCardHeader
{
var size = DeviceCardKit.Segments(new[] { "S", "L" }, () => isMini() ? 0 : 1,
i => { setMini(i == 0); ctx.RequestRebuild(); }, out _, padX: 0, minSegWidth: 16, fontSize: 8);
- ToolTip.SetTip(size, Loc.T("Card size: S (mini) / L (full)"));
+ ToolTip.SetTip(size, Loc.T("device.midi.card_size_s_mini_l"));
return size;
}
}
diff --git a/src/managed/Nota.App/DeviceCards/Midi/RandomMidiBody.cs b/src/managed/Nota.App/DeviceCards/Midi/RandomMidiBody.cs
index 7098bd66..86548e49 100644
--- a/src/managed/Nota.App/DeviceCards/Midi/RandomMidiBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Midi/RandomMidiBody.cs
@@ -154,11 +154,11 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
var rows = new Grid { Margin = new Thickness(8, 4, 8, 5), RowDefinitions = new RowDefinitions("*,*,*,*,*") };
var specs = new (string Label, int P, double Max, Func<double, string> Fmt, string Tip)[]
{
- ("Note", PNoteRange, 12, NoteText, Loc.T("Transpose up or down by up to this many semitones")),
- ("Velocity", PVelAmt, 1, VelText, Loc.T("Push the velocity up or down by up to this much")),
- ("Timing", PTimeAmt, 1, TimeText, Loc.T("Play late by up to this long (a live effect can't play early)")),
- ("Skip", PSkip, 1, SkipText, Loc.T("Chance that a varied note is dropped")),
- ("Octave", POctAmt, 1, OctText, Loc.T("Jump up or down by up to two octaves")),
+ ("Note", PNoteRange, 12, NoteText, Loc.T("device.random.transpose_up_or_down_by")),
+ ("Velocity", PVelAmt, 1, VelText, Loc.T("device.random.push_the_velocity_up_or")),
+ ("Timing", PTimeAmt, 1, TimeText, Loc.T("device.random.play_late_by_up_to")),
+ ("Skip", PSkip, 1, SkipText, Loc.T("device.random.chance_that_a_varied_note")),
+ ("Octave", POctAmt, 1, OctText, Loc.T("device.random.jump_up_or_down_by")),
};
for (int i = 0; i < specs.Length; i++)
{
@@ -170,11 +170,11 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
// ---- OUTPUT ----
var viz = new RandomOutputViz { Full = true };
- ToolTip.SetTip(viz, Loc.T("One bar of eight notes: dashed — the note in, filled — the note out (brightness = velocity, shifted right when delayed), × — skipped"));
+ ToolTip.SetTip(viz, Loc.T("device.random.one_bar_of_eight_notes"));
var outInfo = Mono("", Cap, 7);
readouts.Add(() =>
{
- outInfo.Text = Loc.F("bar {0} · {1} changed · {2} skipped", ShownBar() + 1, Changed(), Skipped()) + (Locked(G) ? " · held" : "");
+ outInfo.Text = Loc.F("device.random.bar_changed_skipped", ShownBar() + 1, Changed(), Skipped()) + (Locked(G) ? " · held" : "");
viz.Set(notes, now, Bypassed());
});
var legend = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 10, Height = 10, Margin = new Thickness(22, 3, 0, 0), Children =
@@ -197,12 +197,12 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
chanceVal.Foreground = Txt;
chanceVal.Text = ChanceText(G(PChance));
});
- ToolTip.SetTip(chanceTrk, Loc.T("Chance — how many notes get varied at all"));
+ ToolTip.SetTip(chanceTrk, Loc.T("device.random.chance_how_many_notes_get"));
var chanceRow = new DockPanel { Children = { WithDock(chanceLbl, Dock.Left), WithDock(chanceVal, Dock.Right), chanceTrk } };
- var distSeg = Seg(PDist, Dists, Loc.T("Distribution: Gauss — mostly small moves · Even — any amount equally · Walk — drifts from note to note"));
+ var distSeg = Seg(PDist, Dists, Loc.T("device.random.distribution_gauss_mostly_small_moves"));
var hist = new RandomHistViz();
- ToolTip.SetTip(hist, Loc.T("The shape of the roll — 1500 draws from the same generator"));
+ ToolTip.SetTip(hist, Loc.T("device.random.the_shape_of_the_roll"));
readouts.Add(() => hist.Set(Dist(G), Seed(G)));
var axis = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto") };
var ac = Mono("centre", Faint, 6); ac.HorizontalAlignment = HorizontalAlignment.Center; Grid.SetColumn(ac, 1);
@@ -211,13 +211,13 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
var histBox = new DockPanel { Children = { WithDock(axis, Dock.Bottom), hist } };
axis.Margin = new Thickness(0, 2, 0, 0);
- var rateSeg = Seg(PRate, Rates, Loc.T("Per note — every note rolls its own values · Per bar — one set of values for the whole bar"));
+ var rateSeg = Seg(PRate, Rates, Loc.T("device.random.per_note_every_note_rolls"));
var seedTb = Mono("", Txt);
readouts.Add(() => seedTb.Text = $"seed {Seed(G)}");
Learn(seedTb, PSeed, "Seed");
- var rerollBtn = Button("Reroll", Loc.T("Next seed — a new roll"), Reroll, out _);
- var lockBtn = Button("Lock", Loc.T("Hold the roll showing now — it repeats every bar"), ToggleLock, out var lockSync);
+ var rerollBtn = Button("Reroll", Loc.T("device.random.next_seed_a_new_roll"), Reroll, out _);
+ var lockBtn = Button("Lock", Loc.T("device.random.hold_the_roll_showing_now"), ToggleLock, out var lockSync);
Learn(lockBtn, PLocked, "Locked");
readouts.Add(() => lockSync(Locked(G)));
var seedRow = new DockPanel { Children =
@@ -226,7 +226,7 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
seedTb,
} };
- var scaleRow = SwitchRow(PStayInScale, Loc.T("Stay in scale · C maj"), Loc.T("Snap every varied note into C major"));
+ var scaleRow = SwitchRow(PStayInScale, Loc.T("device.random.stay_in_scale_c_maj"), Loc.T("device.random.snap_every_varied_note_into"));
var dice = new DockPanel { Margin = new Thickness(8, 6), Children =
{
@@ -245,7 +245,7 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
{
statusL.Text = $"Chance {ChanceText(G(PChance))} · {Dists[Dist(G)]} · {(G(PRate) >= 0.5f ? "per bar" : "per note")} · seed {Seed(G)}"
+ (Locked(G) ? " locked" : "") + (G(PStayInScale) >= 0.5f ? " · C maj" : "");
- statusR.Text = Bypassed() ? "bypassed" : Loc.T("MIDI · latency 0 smp");
+ statusR.Text = Bypassed() ? "bypassed" : Loc.T("common.midi_latency_0_smp");
});
return Framed(islands, statusL, statusR);
}
@@ -265,14 +265,14 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
int d = ev.KeyModifiers.HasFlag(KeyModifiers.Shift) ? 2 : 1;
Set(PDist, (Dist(G) + d) % 3); Refresh(); ev.Handled = true;
};
- ToolTip.SetTip(distChip, Loc.T("Distribution: Gauss / Even / Walk — click for the next, Shift-click for the previous"));
+ ToolTip.SetTip(distChip, Loc.T("device.random.distribution_gauss_even_walk_click"));
Learn(distChip, PDist, "Dist");
var barTb = Mono("", Cap, 7);
var head = new DockPanel { Height = 14, Children = { WithDock(distChip, Dock.Left), WithDock(barTb, Dock.Right) } };
barTb.HorizontalAlignment = HorizontalAlignment.Right;
var viz = new RandomOutputViz { Full = false };
- ToolTip.SetTip(viz, Loc.T("Dashed — in · filled — out (brightness = velocity) · × — skipped"));
+ ToolTip.SetTip(viz, Loc.T("device.random.dashed_in_filled_out_brightness"));
var knobs = new Grid { Height = 53, ColumnDefinitions = new ColumnDefinitions("*,*,*,*") };
var cells = new[]
@@ -297,9 +297,9 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
});
// Footer: "seed N" rerolls, "lock" holds the roll.
- var seedTb = FooterLink("", Loc.T("Reroll — the next seed"), Reroll);
+ var seedTb = FooterLink("", Loc.T("device.random.reroll_the_next_seed"), Reroll);
Learn(seedTb, PSeed, "Seed");
- var lockTb = FooterLink("", Loc.T("Lock — hold the roll showing now"), ToggleLock, mono: false);
+ var lockTb = FooterLink("", Loc.T("device.random.lock_hold_the_roll_showing"), ToggleLock, mono: false);
Learn(lockTb, PLocked, "Locked");
var left = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, VerticalAlignment = VerticalAlignment.Center, Children = { seedTb, lockTb } };
var statusR = Mono("", Sub);
@@ -311,7 +311,7 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
lockTb.FontWeight = on ? FontWeight.SemiBold : FontWeight.Normal;
lockTb.Tag = on ? NotaPalette.AccentHover : Sub;
if (!lockTb.IsPointerOver) lockTb.Foreground = (IBrush)lockTb.Tag;
- statusR.Text = Bypassed() ? "bypassed" : Loc.F("{0} changed · {1} skip", Changed(), Skipped());
+ statusR.Text = Bypassed() ? "bypassed" : Loc.F("device.random.changed_skip", Changed(), Skipped());
});
return Framed(island, left, statusR);
}
@@ -367,7 +367,7 @@ internal sealed class RandomMidiBody : IMidiDeviceBody
var l = new TextBlock { Text = label, FontSize = 9, VerticalAlignment = VerticalAlignment.Center };
var v = Mono("", Sub); v.HorizontalAlignment = HorizontalAlignment.Right;
var trk = Slider(p, max);
- ToolTip.SetTip(trk, Loc.F("{0} — drag up / down, double-click resets", tip));
+ ToolTip.SetTip(trk, Loc.F("device.random.drag_up_down_double_click", tip));
ValueEntry.Attach(v, () => G(p) / max, n => S(p, max > 1 ? Math.Round(n * max) : Math.Round(n * max, 3)), () => fmt(G(p)),
() => Begin(p), () => End(p), Refresh, control: trk);
readouts.Add(() =>
diff --git a/src/managed/Nota.App/DeviceCards/Midi/ScaleMidiBody.cs b/src/managed/Nota.App/DeviceCards/Midi/ScaleMidiBody.cs
index ac509f5e..8e973143 100644
--- a/src/managed/Nota.App/DeviceCards/Midi/ScaleMidiBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Midi/ScaleMidiBody.cs
@@ -82,7 +82,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
void Sync() => tag.Text = KeyTag(p => e.MidiEffectGetParam(t, index, p));
Sync();
ctx.AddDeviceRefresher(Sync);
- ToolTip.SetTip(tag, Loc.T("The key in effect: root and scale"));
+ ToolTip.SetTip(tag, Loc.T("device.scale.the_key_in_effect_root"));
row.Children.Add(tag); row.Children.Add(MidiCardHeader.LearnButton(ctx));
}
row.Children.Add(MidiCardHeader.SizeToggle(ctx, index, PView, () => IsMini(e, t, index)));
@@ -146,7 +146,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
int li = -1, lo = -1;
var map = new ScaleNoteMap { Mini = mini };
map.Toggled += ToggleNote;
- ToolTip.SetTip(map, Loc.T("Click a note to add it to or take it out of the scale (the scale turns Custom)"));
+ ToolTip.SetTip(map, Loc.T("device.scale.click_a_note_to_add"));
void Poll()
{
int n = engine.MidiEffectScope(track, mi, scope);
@@ -211,7 +211,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
if (!ev.GetCurrentPoint(rowB).Properties.IsLeftButtonPressed) return;
PickType(last ? Custom : sc); ev.Handled = true;
};
- ToolTip.SetTip(rowB, last ? Loc.T("Custom: your own notes — click the note map to edit") : Loc.F("{0} — {1} notes", ScaleNames[sc], Count(PresetMasks[sc])));
+ ToolTip.SetTip(rowB, last ? Loc.T("device.scale.custom_your_own_notes_click") : Loc.F("device.scale.notes_n", ScaleNames[sc], Count(PresetMasks[sc])));
Learn(rowB, PScale, "Scale");
readouts.Add(Paint);
list.Children.Add(rowB);
@@ -220,7 +220,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
// ---- NOTE MAP ----
var remapped = Mono("", Cap, 7);
- readouts.Add(() => remapped.Text = Mask() == 0 ? Loc.T("empty · notes pass") : Loc.F("{0} of 12 remapped", Remapped()));
+ readouts.Add(() => remapped.Text = Mask() == 0 ? Loc.T("device.scale.empty_notes_pass") : Loc.F("device.scale.of_12_remapped", Remapped()));
var mapIsland = IslandBox(IslandHead(Caps("NOTE MAP"), remapped), new Border { Padding = new Thickness(8, 6), Child = map }, double.NaN);
// ---- FOLD ----
@@ -232,9 +232,9 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
Child = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, HorizontalAlignment = HorizontalAlignment.Center,
Children = { ioIn, new TextBlock { Text = "→", FontSize = 10, Foreground = Cap, VerticalAlignment = VerticalAlignment.Center }, ioOut } },
};
- ToolTip.SetTip(ioBox, Loc.T("The last note played and what it came out as"));
+ ToolTip.SetTip(ioBox, Loc.T("device.scale.the_last_note_played_and"));
readouts.Add(() => { ioIn.Text = li >= 0 ? DeviceCardKit.NoteName(li) : "—"; ioOut.Text = lo >= 0 ? DeviceCardKit.NoteName(lo) : "—"; });
- var io = new StackPanel { Spacing = 3, Children = { Caps(Loc.T("LAST IN → OUT")), ioBox } };
+ var io = new StackPanel { Spacing = 3, Children = { Caps(Loc.T("device.scale.last_in_out_caps")), ioBox } };
var rangeLbl = Caps("RANGE"); rangeLbl.Width = 34;
var range = new Grid { ColumnDefinitions = new ColumnDefinitions("34,*,*"), ColumnSpacing = 6 };
@@ -244,7 +244,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
var follow = FollowSwitch();
var learnBtn = LearnButton();
- var clearBtn = Button("Clear", Clear, Loc.T("Clear the scale down to the root (Custom)"));
+ var clearBtn = Button("Clear", Clear, Loc.T("device.scale.clear_the_scale_down_to"));
var btns = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 4 };
Grid.SetColumn(clearBtn, 1); btns.Children.Add(learnBtn); btns.Children.Add(clearBtn);
@@ -263,12 +263,12 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
readouts.Add(() =>
{
int t = (int)Math.Round(G(PTranspose));
- statusL.Text = Loc.F("{0} {1} · {2} notes · fold {3} · ", Notes[Root()], TypeName(), Count(Mask()), Folds[Fold()].ToLowerInvariant())
+ statusL.Text = Loc.F("device.scale.notes_fold", Notes[Root()], TypeName(), Count(Mask()), Folds[Fold()].ToLowerInvariant())
+ $"{DeviceCardKit.NoteName(RangeLo())}–{DeviceCardKit.NoteName(RangeHi())}"
+ (t != 0 ? $" · transpose {(t > 0 ? "+" : "−")}{Math.Abs(t)}" : "")
+ (G(PFollowKey) >= 0.5f ? " · follow key" : "")
+ (G(PLearn) >= 0.5f ? " · learning" : "");
- statusR.Text = Bypassed() ? "bypassed" : Loc.T("MIDI · latency 0 smp");
+ statusR.Text = Bypassed() ? "bypassed" : Loc.T("common.midi_latency_0_smp");
});
return Framed(islands, statusL, statusR);
}
@@ -298,8 +298,8 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
var statusR = Mono("", Sub);
readouts.Add(() =>
{
- statusL.Text = Loc.F("{0} {1} · {2} notes", Notes[Root()], TypeName(), Count(Mask()));
- statusR.Text = Bypassed() ? "bypassed" : Mask() == 0 ? "empty" : Loc.F("{0} of 12 remapped", Remapped());
+ statusL.Text = Loc.F("device.scale.notes", Notes[Root()], TypeName(), Count(Mask()));
+ statusR.Text = Bypassed() ? "bypassed" : Mask() == 0 ? "empty" : Loc.F("device.scale.of_12_remapped", Remapped());
});
return Framed(island, statusL, statusR);
}
@@ -353,7 +353,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 2, VerticalAlignment = VerticalAlignment.Center, Background = Brushes.Transparent,
Children = { Arrow(GlyphKind.ChevronLeft, -1), name, Arrow(GlyphKind.ChevronRight, 1) } };
row.PointerWheelChanged += (wt, ev) => { if (WheelInput.Step(ev, wt) is not { } s) return; ev.Handled = true; if (s != 0) StepRoot(s); };
- ToolTip.SetTip(row, Loc.T("Root — click the arrows or scroll"));
+ ToolTip.SetTip(row, Loc.T("device.scale.root_click_the_arrows_or"));
Learn(row, PRoot, "Root");
return row;
}
@@ -363,7 +363,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
var seg = DeviceCardKit.Segments(Folds, Fold, i => { Set(PFold, i); Refresh(); }, out var sync, fill: true, padX: 2, fontSize: 8);
seg.Height = h + 4;
readouts.Add(sync);
- ToolTip.SetTip(seg, Loc.T("Fold — where an out-of-scale note goes: the nearest scale note (a tie goes up), the one below or the one above"));
+ ToolTip.SetTip(seg, Loc.T("device.scale.fold_where_an_out_of"));
Learn(seg, PFold, "Fold");
return seg;
}
@@ -441,7 +441,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
Height = 14, Background = Well, BorderBrush = Bd, BorderThickness = new Thickness(1), CornerRadius = NotaRadius.Badge,
Child = new DockPanel { Children = { WithDock(dec, Dock.Left), WithDock(inc, Dock.Right), valHit } },
};
- ToolTip.SetTip(box, MenuKit.Keys(Loc.F("{0} — ± an octave, drag or scroll the note for semitones, ⌥-click the note to type it, double-click resets. Notes outside the range pass through.", label)));
+ ToolTip.SetTip(box, MenuKit.Keys(Loc.F("device.scale.an_octave_drag_or_scroll", label)));
ValueEntry.Attach(valHit, new ValueField(label, () => Get() / 127.0, n => DeviceCardKit.NoteName((int)Math.Round(n * 127)),
n => Put((int)Math.Round(Math.Clamp(n, 0, 1) * 127)), () => Begin(p), () => End(p), p == PRangeLo ? 0 : 1), val);
Learn(box, p, label);
@@ -451,7 +451,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
Control FollowSwitch()
{
var sw = new SwitchTrack { Width = SwitchTrack.W, Height = SwitchTrack.H, VerticalAlignment = VerticalAlignment.Center };
- var lbl = new TextBlock { Text = Loc.T("Follow key · from input"), FontSize = 8, VerticalAlignment = VerticalAlignment.Center };
+ var lbl = new TextBlock { Text = Loc.T("device.scale.follow_key_from_input"), FontSize = 8, VerticalAlignment = VerticalAlignment.Center };
var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Children = { sw, lbl } };
row.PointerPressed += (_, ev) =>
{
@@ -459,7 +459,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
Set(PFollowKey, G(PFollowKey) >= 0.5f ? 0 : 1); Refresh(); ev.Handled = true;
};
readouts.Add(() => { bool on = G(PFollowKey) >= 0.5f; sw.IsOn = on; lbl.Foreground = on ? Txt : Muted; });
- ToolTip.SetTip(row, Loc.T("Follow key — the root moves to the key that best fits what you play (keeping the scale type)"));
+ ToolTip.SetTip(row, Loc.T("device.scale.follow_key_the_root_moves"));
Learn(row, PFollowKey, "Follow Key");
return row;
}
@@ -480,7 +480,7 @@ internal sealed class ScaleMidiBody : IMidiDeviceBody
Control LearnButton()
{
var b = Button("Learn", () => { Set(PLearn, G(PLearn) >= 0.5f ? 0 : 1); Refresh(); },
- Loc.T("Learn — play the notes of your scale; they pass through untouched and become the Custom scale. Click again to finish."));
+ Loc.T("device.scale.learn_play_the_notes_of"));
var tb = (TextBlock)b.Child!;
readouts.Add(() =>
{
diff --git a/src/managed/Nota.App/DeviceCards/Midi/VelocityMidiBody.cs b/src/managed/Nota.App/DeviceCards/Midi/VelocityMidiBody.cs
index eb869535..bb078816 100644
--- a/src/managed/Nota.App/DeviceCards/Midi/VelocityMidiBody.cs
+++ b/src/managed/Nota.App/DeviceCards/Midi/VelocityMidiBody.cs
@@ -97,10 +97,10 @@ internal static class VelocityModel
internal static string DriveHint(Func<int, float> g)
{
int mode = Mode(g); double d = Drive(g);
- if (mode == 2) return Loc.T("every note at this velocity");
+ if (mode == 2) return Loc.T("device.velocity.every_note_at_this_velocity");
if (Math.Abs(d - 1) < 0.005) return "linear";
- return mode == 0 ? (d > 1 ? Loc.T("soft notes louder") : Loc.T("soft notes quieter"))
- : (d > 1 ? Loc.T("stretched to the edges") : Loc.T("squeezed to the middle"));
+ return mode == 0 ? (d > 1 ? Loc.T("device.velocity.soft_notes_louder") : Loc.T("device.velocity.soft_notes_quieter"))
+ : (d > 1 ? Loc.T("device.velocity.stretched_to_the_edges") : Loc.T("device.velocity.squeezed_to_the_middle"));
}
}
@@ -239,9 +239,9 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
};
ToolTip.SetTip(rowB, m switch
{
- 0 => Loc.T("Curve — bend the response: Drive above 1 lifts soft notes, below 1 pushes them down"),
- 1 => Loc.T("Compand — the same around the middle: above 1 stretches to the edges, below 1 squeezes to the middle"),
- _ => Loc.T("Fixed — every note comes out at one velocity"),
+ 0 => Loc.T("device.velocity.curve_bend_the_response_drive"),
+ 1 => Loc.T("device.velocity.compand_the_same_around_the"),
+ _ => Loc.T("device.velocity.fixed_every_note_comes_out"),
});
Learn(rowB, PMode, "Mode");
readouts.Add(Paint);
@@ -255,7 +255,7 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
dTrack.Changed += n => { DriveSet(n); Refresh(); };
dTrack.GestureBegin += () => { dGesture = DriveParam(); Begin(dGesture); };
dTrack.GestureEnd += () => { if (dGesture >= 0) End(dGesture); dGesture = -1; };
- ToolTip.SetTip(dTrack, Loc.T("Drag up / down, Shift for fine, double-click resets"));
+ ToolTip.SetTip(dTrack, Loc.T("device.velocity.drag_up_down_shift_for"));
Learn(dTrack, PDrive, "Drive");
ValueEntry.Attach(dValue, DriveNorm, DriveSet, () => VelocityModel.DriveText(G),
() => { dGesture = DriveParam(); Begin(dGesture); }, () => { End(dGesture); dGesture = -1; }, Refresh, control: dTrack);
@@ -274,7 +274,7 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
// ---- TRANSFER ----
var viz = new VelocityTransferViz { Full = true };
- ToolTip.SetTip(viz, Loc.T("Input velocity across, output up. Dashed — the Out range; the band — where Random can put a note; dots — the last notes played"));
+ ToolTip.SetTip(viz, Loc.T("device.velocity.input_velocity_across_output_up"));
var plotInfo = Mono("", Sub, 7);
readouts.Add(() =>
{
@@ -300,7 +300,7 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
range.GestureBegin += h => Begin(h == 0 ? POutLo : POutHi);
range.GestureEnd += h => End(h == 0 ? POutLo : POutHi);
range.Changed += (h, n) => { if (h == 0) SetLo(1 + n * 126); else SetHi(1 + n * 126); Refresh(); };
- ToolTip.SetTip(range, MenuKit.Keys(Loc.T("Out range — drag a handle, ⌥-click to type it, double-click resets to 1–127")));
+ ToolTip.SetTip(range, MenuKit.Keys(Loc.T("device.velocity.out_range_drag_a_handle")));
{
string Vel(double n) => ((int)Math.Round(1 + Math.Clamp(n, 0, 1) * 126)).ToString(NotaNum.Culture);
ValueEntry.AttachHandles(range,
@@ -327,17 +327,17 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
if (!ev.GetCurrentPoint(rndRow).Properties.IsLeftButtonPressed) return;
Set1(PRandomOn, VelocityModel.RandomOn(G) ? 0 : 1); Refresh(); ev.Handled = true;
};
- ToolTip.SetTip(rndRow, Loc.T("Random — spread each note's velocity (the amount is kept while it is off)"));
+ ToolTip.SetTip(rndRow, Loc.T("device.velocity.random_spread_each_notes_velocity"));
Learn(rndRow, PRandomOn, "Random On");
var rndTrack = new SliderTrack { Height = 11, Reset = () => { Set1(PRandom, Def(PRandom)); Refresh(); } };
rndTrack.Changed += n => { S(PRandom, Math.Round(n * VelocityModel.RandomSpan) / VelocityModel.RandomSpan); Refresh(); };
rndTrack.GestureBegin += () => Begin(PRandom);
rndTrack.GestureEnd += () => End(PRandom);
- ToolTip.SetTip(rndTrack, Loc.T("Random amount, ±0–64 velocity — drag up / down, double-click resets"));
+ ToolTip.SetTip(rndTrack, Loc.T("device.velocity.random_amount_0_64_velocity"));
Learn(rndTrack, PRandom, "Random");
var dirSeg = DeviceCardKit.Segments(Dirs, () => VelocityModel.Dir(G), i => { Set1(PRandomDir, i); Refresh(); }, out var dirSync,
fill: true, padX: 2, fontSize: 8);
- ToolTip.SetTip(dirSeg, Loc.T("Random both ways, only up, or only down"));
+ ToolTip.SetTip(dirSeg, Loc.T("device.velocity.random_both_ways_only_up"));
Learn(dirSeg, PRandomDir, "Random Dir");
readouts.Add(() =>
{
@@ -354,7 +354,7 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
Child = new StackPanel { Spacing = 5, Children = { rndRow, rndTrack, dirSeg } } };
var hist = new VelocityHistoryViz();
- ToolTip.SetTip(hist, Loc.T("The last 12 notes: outline — velocity in, fill — velocity out"));
+ ToolTip.SetTip(hist, Loc.T("device.velocity.the_last_12_notes_outline"));
readouts.Add(() => hist.Set(notes, count, Bypassed()));
var histBox = new StackPanel { Spacing = 3, Children = { Caps("LAST 12 NOTES"), hist } };
@@ -375,7 +375,7 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
var (lo, hi) = VelocityModel.Range(G);
string rnd = VelocityModel.RandomOn(G) ? $"{VelocityModel.RandomText(G)} {Dirs[VelocityModel.Dir(G)].ToLowerInvariant()}" : "off";
statusL.Text = $"{Modes[Mode()]} · {(IsFixed() ? "value " + VelocityModel.Fixed(G) : $"drive {VelocityModel.Drive(G):0.00}")} · random {rnd} · out {lo}–{hi}";
- statusR.Text = Bypassed() ? "bypassed" : Last() is { } l ? Loc.F("last {0} → {1}", l.In, l.Out) : "MIDI";
+ statusR.Text = Bypassed() ? "bypassed" : Last() is { } l ? Loc.F("device.velocity.last", l.In, l.Out) : "MIDI";
});
return Framed(islands, statusL, statusR);
}
@@ -395,13 +395,13 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
int d = ev.KeyModifiers.HasFlag(KeyModifiers.Shift) ? 2 : 1;
Set1(PMode, (Mode() + d) % 3); Refresh(); ev.Handled = true;
};
- ToolTip.SetTip(modeChip, Loc.T("Velocity mode: Curve / Compand / Fixed — click for the next, Shift-click for the previous"));
+ ToolTip.SetTip(modeChip, Loc.T("device.velocity.velocity_mode_curve_compand_fixed"));
Learn(modeChip, PMode, "Mode");
var hint = Mono("", Cap, 7); hint.HorizontalAlignment = HorizontalAlignment.Right;
var head = new DockPanel { Height = 14, Children = { WithDock(modeChip, Dock.Left), hint } };
var viz = new VelocityTransferViz { Full = false };
- ToolTip.SetTip(viz, Loc.T("Input across, output up · dashed — the Out range · band — Random · dots — the last notes"));
+ ToolTip.SetTip(viz, Loc.T("device.velocity.input_across_output_up_dashed"));
var lastIO = Mono("", Sub, 7);
lastIO.HorizontalAlignment = HorizontalAlignment.Right; lastIO.VerticalAlignment = VerticalAlignment.Top; lastIO.Margin = new Thickness(0, 3, 5, 0);
lastIO.IsHitTestVisible = false;
@@ -445,7 +445,7 @@ internal sealed class VelocityMidiBody : IMidiDeviceBody
End(PRandomOn); End(PRandomDir);
Refresh(); ev.Handled = true;
};
- ToolTip.SetTip(statusL, Loc.T("Random: both ways → up → down → off — click to step, Shift-click back"));
+ ToolTip.SetTip(statusL, Loc.T("device.velocity.random_both_ways_up_down"));
Learn(statusL, PRandomDir, "Random Dir");
var statusR = Mono("", Sub);
readouts.Add(() =>
diff --git a/src/managed/Nota.App/DeviceCards/PluginCard.cs b/src/managed/Nota.App/DeviceCards/PluginCard.cs
index 0029b2fc..fae4145e 100644
--- a/src/managed/Nota.App/DeviceCards/PluginCard.cs
+++ b/src/managed/Nota.App/DeviceCards/PluginCard.cs
@@ -113,7 +113,7 @@ internal static class PluginCard
// Open editor toggles the plug-in's own window. Its close button only hides the
// window behind our back (and MCP can open or close it too), so the label re-reads
// the state a few times a second on the UI tick instead of trusting the last click.
- var open = ActionButton(Loc.T("Open editor"), GlyphKind.PopOut, primary: true);
+ var open = ActionButton(Loc.T("device.plugin.open_editor"), GlyphKind.PopOut, primary: true);
var openLabel = (TextBlock)((StackPanel)open.Content!).Children[1];
bool? shownLast = null;
void SyncOpen()
@@ -121,8 +121,8 @@ internal static class PluginCard
bool shown = EditorOpen(e, t, di);
if (shown == shownLast) return;
shownLast = shown;
- openLabel.Text = shown ? Loc.T("Close editor") : Loc.T("Open editor");
- ToolTip.SetTip(open, shown ? Loc.T("Close the plug-in's own window") : Loc.T("Open the plug-in's own window"));
+ openLabel.Text = shown ? Loc.T("device.plugin.close_editor") : Loc.T("device.plugin.open_editor");
+ ToolTip.SetTip(open, shown ? Loc.T("device.plugin.close_the_plug_ins_own") : Loc.T("device.plugin.open_the_plug_ins_own"));
}
SyncOpen();
// By elapsed time, not tick count: the tick's rate depends on where the card is shown.
@@ -142,14 +142,14 @@ internal static class PluginCard
else
{
e.OpenPluginEditor(t, di);
- if (!EditorOpen(e, t, di)) ctx.Status(Loc.F("Couldn't open the {0} window.", info.Name));
+ if (!EditorOpen(e, t, di)) ctx.Status(Loc.F("device.plugin.couldnt_open_the_window", info.Name));
}
}
- catch (Exception ex) { ctx.Status(Loc.F("Couldn't open the {0} window: {1}", info.Name, ex.Message)); }
+ catch (Exception ex) { ctx.Status(Loc.F("device.plugin.couldnt_open_the_window_n", info.Name, ex.Message)); }
SyncOpen();
};
- var save = ActionButton(Loc.T("Save preset"), GlyphKind.Save, primary: false);
- ToolTip.SetTip(save, Loc.T("Save the plug-in's state as a preset"));
+ var save = ActionButton(Loc.T("common.save_preset"), GlyphKind.Save, primary: false);
+ ToolTip.SetTip(save, Loc.T("device.plugin.save_the_plug_ins_state"));
save.Click += (_, _) => ctx.RequestPresetSave(di);
var top = new StackPanel { Spacing = 1, Children = { name, vendor, tags, facts } };
@@ -266,7 +266,7 @@ internal static class PluginCard
{
host.Content = new TextBlock
{
- Text = total == 0 ? Loc.T("This plug-in exposes no parameters") : Loc.T("No parameter matches"),
+ Text = total == 0 ? Loc.T("device.plugin.this_plug_in_exposes_no") : Loc.T("device.plugin.no_parameter_matches"),
FontSize = 9, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center,
};
return;
diff --git a/src/managed/Nota.App/DeviceCards/Rack/MacroPanel.cs b/src/managed/Nota.App/DeviceCards/Rack/MacroPanel.cs
index cde45eab..b93f0efe 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/MacroPanel.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/MacroPanel.cs
@@ -92,10 +92,10 @@ internal static class MacroPanel
if (maps.Count == 0) return "";
var labels = maps.Select(m => { var (p, d) = s.TargetLabel(m); return Short(d.Length > 0 ? d : p); }).Distinct().ToList();
var slots = maps.Select(m => m.Chain).Distinct().ToList();
- string what = labels.Count <= 2 ? string.Join(" + ", labels) : Loc.Plural(labels.Count, "{0} param", "{0} params");
+ string what = labels.Count <= 2 ? string.Join(" + ", labels) : Loc.Plural("device.rack.macros.params", labels.Count);
string where = slots.Count <= 2
? string.Join(", ", slots.Select(s.SlotName))
- : slots.Count == s.Slots().Count ? (compact ? Loc.T("all") : Loc.F("all {0}", s.SlotCount(slots.Count))) : s.SlotCount(slots.Count);
+ : slots.Count == s.Slots().Count ? (compact ? Loc.T("device.rack.macros.all") : Loc.F("device.rack.macros.all_n", s.SlotCount(slots.Count))) : s.SlotCount(slots.Count);
return $"→ {what} · {where}";
}
@@ -114,7 +114,7 @@ internal static class MacroPanel
if (Mappings(s, sel).Count > 0) parts.Add(One(sel));
for (int m = 0; m < Count && parts.Count < 2; m++) if (m != sel && Mappings(s, m).Count > 0) parts.Add(One(m));
int free = Count - Assigned(s);
- parts.Add(free == 0 ? Loc.T("every macro assigned") : Loc.F("{0} free", free));
+ parts.Add(free == 0 ? Loc.T("device.rack.macros.every_macro_assigned") : Loc.F("device.rack.macros.free", free));
return string.Join(" · ", parts);
}
@@ -171,13 +171,13 @@ internal static class MacroPanel
bool custom = name != $"Macro {m + 1}";
var title = new TextBlock
{
- Text = assigned || custom ? (stacked ? Loc.F("Macro {0} · {1}", m + 1, name) : $"{m + 1} · {name}") : (stacked ? $"Macro {m + 1}" : $"{m + 1}"),
+ Text = assigned || custom ? (stacked ? Loc.F("common.macro", m + 1, name) : $"{m + 1} · {name}") : (stacked ? $"Macro {m + 1}" : $"{m + 1}"),
FontSize = 7, FontWeight = FontWeight.Medium, TextTrimming = TextTrimming.CharacterEllipsis,
Foreground = !assigned ? TextDisabled : sel ? AccentBright : NotaPalette.TextStrong,
};
var recv = new TextBlock
{
- Text = assigned ? Receivers(s, m, compact: !stacked) : Loc.T("not assigned"), FontSize = 7, TextTrimming = TextTrimming.CharacterEllipsis,
+ Text = assigned ? Receivers(s, m, compact: !stacked) : Loc.T("device.rack.macros.not_assigned"), FontSize = 7, TextTrimming = TextTrimming.CharacterEllipsis,
Foreground = assigned ? NotaPalette.TealBright : TextDisabled,
};
@@ -221,8 +221,8 @@ internal static class MacroPanel
host = new Panel { Children = { cell, dash } };
}
ToolTip.SetTip(host, assigned
- ? Loc.F("{0} — {1}\nDrag to turn · click to show its receivers · right-click to map, rename or clear", name, Receivers(s, m))
- : Loc.F("Macro {0} is free — right-click (or Map) to give it a target", m + 1));
+ ? Loc.F("device.rack.macros.drag_to_turn_click_to", name, Receivers(s, m))
+ : Loc.F("device.rack.macros.macro_is_free_right_click", m + 1));
host.PointerPressed += (_, ev) =>
{
var pt = ev.GetCurrentPoint(host).Properties;
@@ -241,21 +241,21 @@ internal static class MacroPanel
if (receivers)
{
// Where the card has no receivers panel (Rhythm), they open in a flyout.
- var rc = new MenuItem { Header = Loc.T("Receivers and ranges…") };
+ var rc = new MenuItem { Header = Loc.T("device.rack.macros.receivers_and_ranges") };
rc.Click += (_, _) => Avalonia.Threading.Dispatcher.UIThread.Post(() => ShowReceivers(ctx, s, anchor, m));
f.Items.Add(rc);
}
var map = new MenuFlyout();
s.FillMapMenu(map, m, () => { ctx.NotifyChanged(); ctx.RequestRebuild(); });
- var mapItem = new MenuItem { Header = Loc.T("Map to") };
+ var mapItem = new MenuItem { Header = Loc.T("device.rack.macros.map_to") };
foreach (var it in map.Items.ToList()) { map.Items.Remove(it); mapItem.Items.Add(it); }
f.Items.Add(mapItem);
- f.Items.Add(MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit, () => Avalonia.Threading.Dispatcher.UIThread.Post(() => PromptRename(ctx, s, anchor, m))));
+ f.Items.Add(MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit, () => Avalonia.Threading.Dispatcher.UIThread.Post(() => PromptRename(ctx, s, anchor, m))));
int n = Mappings(s, m).Count;
if (n > 0)
{
f.Items.Add(new Separator());
- f.Items.Add(MenuKit.Danger(Loc.Plural(n, "Clear {0} mapping", "Clear {0} mappings"), GlyphKind.Trash,
+ f.Items.Add(MenuKit.Danger(Loc.Plural("device.rack.clear_mappings", n), GlyphKind.Trash,
() => { Clear(s, m); ctx.NotifyChanged(); ctx.RequestRebuild(); }));
}
f.ShowAt(anchor, showAtPointer: true);
@@ -324,18 +324,18 @@ internal static class MacroPanel
if (maps.Count == 0)
rows.Children.Add(new TextBlock
{
- Text = Loc.T("Nothing mapped yet. Map gives this knob a pad control, an instrument param or any of the kit's effects."),
+ Text = Loc.T("device.rack.macros.nothing_mapped_yet_map_gives"),
FontSize = 8, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap, Margin = new Thickness(0, 4, 0, 0),
});
var scroll = new ScrollViewer { Content = rows, VerticalScrollBarVisibility = ScrollBarVisibility.Auto, HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled };
Border mapBtn = null!;
- mapBtn = Button(Loc.T("Map"), teal: true, () => ShowMapMenu(ctx, s, mapBtn, m));
- ToolTip.SetTip(mapBtn, Loc.T("Add a receiver: a pad control, the pad's instrument or one of its effects"));
+ mapBtn = Button(Loc.T("device.rack.macros.map"), teal: true, () => ShowMapMenu(ctx, s, mapBtn, m));
+ ToolTip.SetTip(mapBtn, Loc.T("device.rack.macros.add_a_receiver_a_pad"));
Border renameBtn = null!;
- renameBtn = Button(Loc.T("Rename"), teal: false, () => PromptRename(ctx, s, renameBtn, m));
- var clearBtn = Button(Loc.T("Clear"), teal: false, () => { Clear(s, m); ctx.NotifyChanged(); ctx.RequestRebuild(); });
- ToolTip.SetTip(clearBtn, Loc.T("Remove every receiver of this macro"));
+ renameBtn = Button(Loc.T("device.rack.macros.rename"), teal: false, () => PromptRename(ctx, s, renameBtn, m));
+ var clearBtn = Button(Loc.T("common.clear"), teal: false, () => { Clear(s, m); ctx.NotifyChanged(); ctx.RequestRebuild(); });
+ ToolTip.SetTip(clearBtn, Loc.T("device.rack.macros.remove_every_receiver_of_this"));
var buttons = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), ColumnSpacing = 4 };
buttons.Children.Add(mapBtn);
Avalonia.Controls.Grid.SetColumn(renameBtn, 1); buttons.Children.Add(renameBtn);
@@ -429,7 +429,7 @@ internal static class MacroPanel
track.PointerMoved += (_, e) => { if (drag != 0) Apply(e.GetPosition(track).X); };
track.PointerReleased += (_, e) => { if (drag != 0) { drag = 0; e.Pointer.Capture(null); ctx.NotifyChanged(); } };
track.PointerCaptureLost += (_, _) => { if (drag != 0) { drag = 0; ctx.NotifyChanged(); } };
- ToolTip.SetTip(track, Loc.T("The range the macro sweeps: drag either end · the tick is where it is now"));
+ ToolTip.SetTip(track, Loc.T("device.rack.macros.the_range_the_macro_sweeps"));
var g = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto"), ColumnSpacing = 5 };
g.Children.Add(hue);
@@ -441,7 +441,7 @@ internal static class MacroPanel
if (!e.GetCurrentPoint(g).Properties.IsRightButtonPressed) return;
e.Handled = true;
var f = new MenuFlyout();
- f.Items.Add(MenuKit.Danger(Loc.T("Remove this receiver"), GlyphKind.Trash,
+ f.Items.Add(MenuKit.Danger(Loc.T("device.rack.macros.remove_this_receiver"), GlyphKind.Trash,
() => { s.RemoveMapping(index); ctx.NotifyChanged(); ctx.RequestRebuild(); }));
f.ShowAt(g, showAtPointer: true);
};
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Chains.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Chains.cs
index 89494e46..102672fa 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Chains.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Chains.cs
@@ -113,7 +113,7 @@ internal sealed partial class RackCardView
key.Children.Add(dash);
key.Children.Add(label);
bool full = _rp.Kind == RackKind.MidiEffect && _ra.ChainCount() >= RcMidiChainLimit;
- ToolTip.SetTip(key, full ? Loc.F("A MIDI Effect Rack holds up to {0} chains", RcMidiChainLimit) : Loc.T("Add a chain — or drop a device from the Browser on the list"));
+ ToolTip.SetTip(key, full ? Loc.F("device.rack.a_midi_effect_rack_holds", RcMidiChainLimit) : Loc.T("device.rack.chains.add_a_chain_or_drop"));
key.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(key).Properties.IsLeftButtonPressed || full) return;
@@ -194,9 +194,9 @@ internal sealed partial class RackCardView
var a = _ra;
if (_rp.Kind == RackKind.AudioEffect)
{
- if (a.RackMode() == RackKindProfile.Select) { a.SelectRange(c, out int lo, out int hi); return Loc.F("sel {0}–{1}", lo, hi); }
+ if (a.RackMode() == RackKindProfile.Select) { a.SelectRange(c, out int lo, out int hi); return Loc.F("device.rack.chains.sel", lo, hi); }
int n = a.ChainDeviceCount(c);
- return Loc.Plural(n, "{0} device", "{0} devices");
+ return Loc.Plural("device.rack.chains.devices", n);
}
a.ChainZone(c, out int kl, out int kh, out int vl, out int vh);
string s = $"{NoteName(kl)}–{NoteName(kh)}";
@@ -208,20 +208,20 @@ internal sealed partial class RackCardView
{
var a = _ra;
var f = new MenuFlyout();
- f.Items.Add(MenuKit.Header(RcChainName(c), null, Loc.F("Chain · {0}", c + 1)));
+ f.Items.Add(MenuKit.Header(RcChainName(c), null, Loc.F("device.rack.chains.chain", c + 1)));
f.Items.Add(new Separator());
- var rename = new MenuItem { Header = Loc.T("Rename…") };
+ var rename = new MenuItem { Header = Loc.T("common.rename") };
rename.Click += (_, _) => RcPromptRename(anchor, RcChainName(c), n => a.SetChainName(c, n));
f.Items.Add(rename);
bool full = _rp.Kind == RackKind.MidiEffect && a.ChainCount() >= RcMidiChainLimit;
- var dup = new MenuItem { Header = Loc.T("Duplicate"), IsEnabled = !full };
+ var dup = new MenuItem { Header = Loc.T("common.duplicate"), IsEnabled = !full };
dup.Click += (_, _) => { int d = a.DuplicateChain(c); if (d >= 0) Sel = d; DeferRebuild(); };
f.Items.Add(dup);
if (_ra.RackAddress is not null) { f.Items.Add(new Separator()); f.Items.Add(RcPasteItem(c)); }
if (a.ChainCount() > 1)
{
f.Items.Add(new Separator());
- f.Items.Add(MenuKit.Danger(Loc.T("Delete chain"), GlyphKind.Trash, () => RcDeleteChain(c)));
+ f.Items.Add(MenuKit.Danger(Loc.T("device.rack.chains.delete_chain"), GlyphKind.Trash, () => RcDeleteChain(c)));
}
f.ShowAt(anchor, showAtPointer: true);
}
@@ -305,39 +305,39 @@ internal sealed partial class RackCardView
var pr = RcResolvePreset(it);
switch (pr.For)
{
- case RcPresetFor.Plugin: why = Loc.T("Plug-in presets can't go in a rack chain yet."); return false;
- case RcPresetFor.None: why = Loc.T("This preset can't go in a rack."); return false;
+ case RcPresetFor.Plugin: why = Loc.T("device.rack.chains.plug_in_presets_cant_go"); return false;
+ case RcPresetFor.None: why = Loc.T("device.rack.chains.this_preset_cant_go_in"); return false;
case RcPresetFor.Instrument when !_rp.TakesInstrument:
- why = _rp.Kind == RackKind.MidiEffect ? Loc.T("A MIDI Effect Rack takes MIDI effects only.") : Loc.T("An Audio Effect Rack takes audio effects only."); return false;
- case RcPresetFor.Effect when !_rp.TakesAudioEffects: why = Loc.T("A MIDI Effect Rack takes MIDI effects only."); return false;
- case RcPresetFor.Effect when pr.Kind == 5: why = Loc.T("A rack can't go inside a rack."); return false;
- case RcPresetFor.Midi when !_rp.TakesMidiEffects: why = Loc.T("An Audio Effect Rack takes audio effects only."); return false;
- case RcPresetFor.Midi when pr.Kind is < 0 or > 5: why = Loc.T("A rack can't go inside a rack."); return false;
+ why = _rp.Kind == RackKind.MidiEffect ? Loc.T("device.rack.a_midi_effect_rack_takes") : Loc.T("device.rack.an_audio_effect_rack_takes"); return false;
+ case RcPresetFor.Effect when !_rp.TakesAudioEffects: why = Loc.T("device.rack.a_midi_effect_rack_takes"); return false;
+ case RcPresetFor.Effect when pr.Kind == 5: why = Loc.T("device.rack.a_rack_cant_go_inside"); return false;
+ case RcPresetFor.Midi when !_rp.TakesMidiEffects: why = Loc.T("device.rack.an_audio_effect_rack_takes"); return false;
+ case RcPresetFor.Midi when pr.Kind is < 0 or > 5: why = Loc.T("device.rack.a_rack_cant_go_inside"); return false;
}
return true;
}
if (RcIsInstrument(it))
{
// A Drum Rack may sit in an Instrument Rack chain; an Instrument Rack can't (specs/041).
- if (_rp.TakesInstrument && it.Kind == BrowserItemKind.BuiltinInstrument && it.BuiltinKind == 3) { why = Loc.T("An Instrument Rack can't go inside a rack — add its instruments as chains."); return false; }
+ if (_rp.TakesInstrument && it.Kind == BrowserItemKind.BuiltinInstrument && it.BuiltinKind == 3) { why = Loc.T("device.rack.chains.an_instrument_rack_cant_go"); return false; }
if (_rp.TakesInstrument) return true;
- why = _rp.Kind == RackKind.MidiEffect ? Loc.T("A MIDI Effect Rack takes MIDI effects only.") : Loc.T("An Audio Effect Rack takes audio effects only.");
+ why = _rp.Kind == RackKind.MidiEffect ? Loc.T("device.rack.a_midi_effect_rack_takes") : Loc.T("device.rack.an_audio_effect_rack_takes");
return false;
}
if (IsEffect(it))
{
- if (!_rp.TakesAudioEffects) { why = Loc.T("A MIDI Effect Rack takes MIDI effects only."); return false; }
- if (it.Kind == BrowserItemKind.PluginEffect && !_ra.HostsPlugins) { why = Loc.T("This rack can't host plug-ins."); return false; }
- if (it.Kind == BrowserItemKind.BuiltinEffect && it.BuiltinKind == 5) { why = Loc.T("A rack can't go inside a rack."); return false; }
+ if (!_rp.TakesAudioEffects) { why = Loc.T("device.rack.a_midi_effect_rack_takes"); return false; }
+ if (it.Kind == BrowserItemKind.PluginEffect && !_ra.HostsPlugins) { why = Loc.T("device.rack.chains.this_rack_cant_host_plug"); return false; }
+ if (it.Kind == BrowserItemKind.BuiltinEffect && it.BuiltinKind == 5) { why = Loc.T("device.rack.a_rack_cant_go_inside"); return false; }
return true;
}
if (it.Kind == BrowserItemKind.BuiltinMidiEffect)
{
- if (!_rp.TakesMidiEffects) { why = Loc.T("An Audio Effect Rack takes audio effects only."); return false; }
- if (it.BuiltinKind is < 0 or > 5) { why = Loc.T("A rack can't go inside a rack."); return false; }
+ if (!_rp.TakesMidiEffects) { why = Loc.T("device.rack.an_audio_effect_rack_takes"); return false; }
+ if (it.BuiltinKind is < 0 or > 5) { why = Loc.T("device.rack.a_rack_cant_go_inside"); return false; }
return true;
}
- why = Loc.T("Drop a device here.");
+ why = Loc.T("device.rack.chains.drop_a_device_here");
return false;
}
@@ -355,7 +355,7 @@ internal sealed partial class RackCardView
{
case RcPresetFor.Instrument:
// On a chain an instrument preset replaces the chain's instrument.
- if (!a.SetChainInstrument(c, pr.Kind)) { _ctx.Status(Loc.F("Couldn't load {0}.", it.Name)); return; }
+ if (!a.SetChainInstrument(c, pr.Kind)) { _ctx.Status(Loc.F("common.couldnt_load", it.Name)); return; }
RcApplyPreset(pr, c, -1);
break;
case RcPresetFor.Effect:
@@ -396,7 +396,7 @@ internal sealed partial class RackCardView
{
if (!RcAccepts(it, out var why)) { _ctx.Status(why); return; }
var a = _ra;
- if (_rp.Kind == RackKind.MidiEffect && a.ChainCount() >= RcMidiChainLimit) { _ctx.Status(Loc.F("A MIDI Effect Rack holds up to {0} chains.", RcMidiChainLimit)); return; }
+ if (_rp.Kind == RackKind.MidiEffect && a.ChainCount() >= RcMidiChainLimit) { _ctx.Status(Loc.F("device.rack.chains.a_midi_effect_rack_holds", RcMidiChainLimit)); return; }
int c = -1;
if (it.Kind == BrowserItemKind.Preset && RcResolvePreset(it) is { For: RcPresetFor.Instrument } pr)
{
@@ -405,7 +405,7 @@ internal sealed partial class RackCardView
{
c = a.AddChain(pr.Kind);
if (c >= 0 && a.ChainInstrumentKind(c) == pr.Kind) RcApplyPreset(pr, c, -1);
- else if (c >= 0) { a.RemoveChain(c); c = -1; _ctx.Status(Loc.F("Couldn't load {0}.", it.Name)); }
+ else if (c >= 0) { a.RemoveChain(c); c = -1; _ctx.Status(Loc.F("common.couldnt_load", it.Name)); }
}
finally { E.EndUndoGroup(); }
}
@@ -413,7 +413,7 @@ internal sealed partial class RackCardView
{
// An instrument the rack can't host would leave an empty chain: take it back.
c = a.AddChain(it.BuiltinKind);
- if (c >= 0 && a.ChainInstrumentKind(c) != it.BuiltinKind) { a.RemoveChain(c); c = -1; _ctx.Status(Loc.F("{0} can't go in a rack chain.", it.Name)); }
+ if (c >= 0 && a.ChainInstrumentKind(c) != it.BuiltinKind) { a.RemoveChain(c); c = -1; _ctx.Status(Loc.F("device.rack.chains.cant_go_in_a_rack", it.Name)); }
}
else if (it.Kind == BrowserItemKind.PluginInstrument) c = a.AddPluginInstrumentChain(it.CatalogIndex);
else
@@ -435,14 +435,14 @@ internal sealed partial class RackCardView
private Control RcDeviceLane()
{
var a = _ra;
- if (a.ChainCount() == 0) return new Border { Padding = new Thickness(4), Child = Hint(Loc.T("Add a chain to start.")) };
+ if (a.ChainCount() == 0) return new Border { Padding = new Thickness(4), Child = Hint(Loc.T("device.rack.chains.add_a_chain_to_start")) };
int c = Sel;
Control head;
if (_rs.Mapping)
{
var label = RcText("Mapping", NotaPalette.Teal, NotaType.KnobLabel, FontWeight.SemiBold);
- var macro = RcName(Loc.F("Macro {0} · {1}", _rs.MappingMacro + 1, a.MacroName(_rs.MappingMacro)), NotaPalette.TextPrimary, NotaType.KnobLabel);
- var how = RcText(Loc.T("Click to add or remove"), NotaPalette.TextSecondary, 7.5, FontWeight.Normal);
+ var macro = RcName(Loc.F("common.macro", _rs.MappingMacro + 1, a.MacroName(_rs.MappingMacro)), NotaPalette.TextPrimary, NotaType.KnobLabel);
+ var how = RcText(Loc.T("device.rack.chains.click_to_add_or_remove"), NotaPalette.TextSecondary, 7.5, FontWeight.Normal);
head = new Border
{
Height = 16, CornerRadius = NotaRadius.Badge, Padding = new Thickness(6, 0), BorderThickness = new Thickness(1),
@@ -460,7 +460,7 @@ internal sealed partial class RackCardView
Orientation = Orientation.Horizontal, Spacing = 6, Height = 16, Children =
{
dot, RcName(RcChainName(c), NotaPalette.TextPrimary, NotaType.RowLabel),
- RcMono(Loc.F("{0} · {1} left → right", Loc.Plural(n, "{0} device", "{0} devices"), flow), NotaPalette.TextTertiary, 7.5),
+ RcMono(Loc.F("device.rack.chains.left_right", Loc.Plural("device.rack.chains.devices", n), flow), NotaPalette.TextTertiary, 7.5),
},
};
}
@@ -500,7 +500,7 @@ internal sealed partial class RackCardView
Width = RcCompactWidth, CornerRadius = NotaRadius.Panel, BorderThickness = new Thickness(1), BorderBrush = NotaPalette.BorderDefault,
Background = NotaPalette.SurfaceRaised, Cursor = new Cursor(StandardCursorType.Hand), Child = new Border { Padding = new Thickness(6), Child = tb },
};
- ToolTip.SetTip(slot, Loc.T("Pick an instrument — or drop one from the Browser"));
+ ToolTip.SetTip(slot, Loc.T("device.rack.chains.pick_an_instrument_or_drop"));
slot.PointerPressed += (_, e) => { if (e.GetCurrentPoint(slot).Properties.IsLeftButtonPressed) { e.Handled = true; RcInstrumentMenu(slot, c); } };
return slot;
}
@@ -532,7 +532,7 @@ internal sealed partial class RackCardView
Width = 30, Cursor = new Cursor(StandardCursorType.Hand), Background = Brushes.Transparent,
Children = { dash, new StackPanel { VerticalAlignment = VerticalAlignment.Center, Spacing = 2, Children = { plus, word } } },
};
- ToolTip.SetTip(box, slot == RcSlot.Midi ? Loc.T("Add a MIDI effect — or drop one from the Browser") : Loc.T("Add an effect — or drop one from the Browser"));
+ ToolTip.SetTip(box, slot == RcSlot.Midi ? Loc.T("device.rack.chains.add_a_midi_effect_or") : Loc.T("device.rack.chains.add_an_effect_or_drop"));
box.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(box).Properties.IsLeftButtonPressed) return;
@@ -604,7 +604,7 @@ internal sealed partial class RackCardView
};
if (canBypass)
{
- ToolTip.SetTip(dot, bypassed ? Loc.T("Turn on") : Loc.T("Turn off"));
+ ToolTip.SetTip(dot, bypassed ? Loc.T("device.rack.chains.turn_on") : Loc.T("device.rack.chains.turn_off"));
dot.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(dot).Properties.IsLeftButtonPressed) return;
@@ -627,7 +627,7 @@ internal sealed partial class RackCardView
// replaced from its menu, not removed.
if (slot != RcSlot.Instrument)
{
- var remove = DeviceCardKit.RemoveButton(Loc.T("Remove device"), () =>
+ var remove = DeviceCardKit.RemoveButton(Loc.T("device.rack.remove_device"), () =>
{
if (RcSelOf(c, slot, idx) is { } sel) { RcDelete(sel); return; }
if (slot == RcSlot.Midi) a.RemoveChainMidi(c, idx); else a.RemoveChainDevice(c, idx);
@@ -657,8 +657,8 @@ internal sealed partial class RackCardView
: rows;
body.Margin = new Thickness(4, 3);
- var open = new TextBlock { Text = Loc.T("Open"), FontSize = 7.5, Foreground = NotaPalette.TextSecondary, Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center };
- ToolTip.SetTip(open, Loc.T("Open the full editor"));
+ var open = new TextBlock { Text = Loc.T("common.open"), FontSize = 7.5, Foreground = NotaPalette.TextSecondary, Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center };
+ ToolTip.SetTip(open, Loc.T("device.rack.chains.open_the_full_editor"));
var grip = new Glyph(GlyphKind.Grip, 8) { Foreground = NotaPalette.TextDisabled, Cursor = new Cursor(StandardCursorType.SizeWestEast), VerticalAlignment = VerticalAlignment.Center };
var foot = new Border
{
@@ -710,18 +710,18 @@ internal sealed partial class RackCardView
{
var a = _ra;
var f = new MenuFlyout();
- var o = new MenuItem { Header = Loc.T("Open") };
+ var o = new MenuItem { Header = Loc.T("common.open") };
o.Click += (_, _) => open();
f.Items.Add(o);
if (slot == RcSlot.Instrument)
{
- var replace = new MenuItem { Header = Loc.T("Replace instrument") };
+ var replace = new MenuItem { Header = Loc.T("device.rack.chains.replace_instrument") };
replace.Click += (_, _) => RcInstrumentMenu(anchor, c);
f.Items.Add(replace);
}
else
{
- var b = new MenuItem { Header = bypassed ? Loc.T("Turn on") : Loc.T("Turn off") };
+ var b = new MenuItem { Header = bypassed ? Loc.T("device.rack.chains.turn_on") : Loc.T("device.rack.chains.turn_off") };
b.Click += (_, _) =>
{
if (slot == RcSlot.Midi) a.SetChainMidiBypassed(c, idx, !bypassed); else a.SetChainDeviceBypassed(c, idx, !bypassed);
@@ -732,7 +732,7 @@ internal sealed partial class RackCardView
else
{
f.Items.Add(new Separator());
- f.Items.Add(MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () =>
+ f.Items.Add(MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () =>
{
if (slot == RcSlot.Midi) a.RemoveChainMidi(c, idx); else a.RemoveChainDevice(c, idx);
DeferRebuild();
@@ -795,7 +795,7 @@ internal sealed partial class RackCardView
if (mapping)
{
row.Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(row, onThis ? Loc.F("Unmap from {0}", a.MacroName(_rs.MappingMacro)) : Loc.F("Map to {0}", a.MacroName(_rs.MappingMacro)));
+ ToolTip.SetTip(row, onThis ? Loc.F("device.rack.chains.unmap_from", a.MacroName(_rs.MappingMacro)) : Loc.F("device.rack.chains.map_to", a.MacroName(_rs.MappingMacro)));
row.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(row).Properties.IsLeftButtonPressed) return;
@@ -806,7 +806,7 @@ internal sealed partial class RackCardView
else if (mapped)
{
row.Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(row, Loc.F("Controlled by {0} · click to open the macro", a.MacroName(macro)));
+ ToolTip.SetTip(row, Loc.F("device.rack.chains.controlled_by_click_to_open", a.MacroName(macro)));
row.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(row).Properties.IsLeftButtonPressed) return;
@@ -875,6 +875,6 @@ internal sealed partial class RackCardView
_ctx.AddRackParamRefresher(sync);
return row;
}
- OpenParamWindow(anchor, a.ChainMidiName(c, j), P.Count, Row, () => Loc.F("{0} · MIDI effect {1}", RcChainName(c), j + 1));
+ OpenParamWindow(anchor, a.ChainMidiName(c, j), P.Count, Row, () => Loc.F("device.rack.chains.midi_effect", RcChainName(c), j + 1));
}
}
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Clipboard.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Clipboard.cs
index ea968486..c73018c4 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Clipboard.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Clipboard.cs
@@ -68,7 +68,7 @@ internal sealed partial class RackCardView
private bool RcCopy(RackDeviceSel s)
{
bool ok = s.Midi ? E.RackDevChainMidiCopy(T, s.Rack, s.Chain, s.Index) : E.RackDevChainDeviceCopy(T, s.Rack, s.Chain, s.Index);
- if (ok) { _ctx.RackCopied(); _ctx.Status(Loc.F("Copied {0}", RcDeviceName(s))); }
+ if (ok) { _ctx.RackCopied(); _ctx.Status(Loc.F("device.rack.clipboard.copied", RcDeviceName(s))); }
return ok;
}
@@ -96,7 +96,7 @@ internal sealed partial class RackCardView
private void RcDuplicate(RackDeviceSel s)
{
int at = s.Midi ? E.RackDevChainMidiDuplicate(T, s.Rack, s.Chain, s.Index) : E.RackDevChainDeviceDuplicate(T, s.Rack, s.Chain, s.Index);
- if (at < 0) { _ctx.Status(Loc.T("This device can't be duplicated")); return; }
+ if (at < 0) { _ctx.Status(Loc.T("device.rack.clipboard.this_device_cant_be_duplicated")); return; }
RcSelect(s with { Index = at });
DeferRebuild();
}
@@ -119,7 +119,7 @@ internal sealed partial class RackCardView
{
if (_ra.RackAddress is not int rack) return;
int kind = E.DeviceClipboardKind();
- if (kind == 0) { _ctx.Status(Loc.T("Nothing to paste")); return; }
+ if (kind == 0) { _ctx.Status(Loc.T("device.rack.clipboard.nothing_to_paste")); return; }
if (kind == 4) { RcPasteMany(rack, c, after); return; }
bool midi = kind == 2;
int at = after is { Index: >= 0 } s && s.Chain == c && s.Midi == midi ? s.Index + 1 : -1;
@@ -127,7 +127,7 @@ internal sealed partial class RackCardView
int r = midi ? E.RackDevChainMidiPaste(T, rack, c, at) : E.RackDevChainDevicePaste(T, rack, c, at);
if (r < 0) { _ctx.Status(RcPasteRefusal(r, midi)); return; }
var pasted = new RackDeviceSel(rack, c, midi, r);
- _ctx.Status(Loc.F("Pasted {0}", RcDeviceName(pasted)) + (keyed ? Loc.T(" · sidechain dropped") : ""));
+ _ctx.Status(Loc.F("device.rack.clipboard.pasted", RcDeviceName(pasted)) + (keyed ? Loc.T("device.rack.clipboard.sidechain_dropped") : ""));
if (Sel != c) Sel = c;
RcSelect(pasted);
DeferRebuild();
@@ -140,9 +140,9 @@ internal sealed partial class RackCardView
int midiAt = after is { Index: >= 0, Midi: true } m && m.Chain == c ? m.Index + 1 : -1;
int fxAt = after is { Index: >= 0, Midi: false } d && d.Chain == c ? d.Index + 1 : -1;
int n = E.RackDevChainPasteDevices(T, rack, c, midiAt, fxAt, out int skipped, out int firstMidi, out int firstFx);
- if (n < 0) { _ctx.Status(n == -3 ? Loc.T("Couldn't paste: a device failed to load.") : Loc.T("Nothing to paste here.")); return; }
- if (n == 0) { _ctx.Status(Loc.T("This chain can't take the copied devices.")); return; }
- _ctx.Status(skipped > 0 ? Loc.F("Pasted {0} devices, skipped {1} this chain can't take", n, skipped) : Loc.F("Pasted {0} devices", n));
+ if (n < 0) { _ctx.Status(n == -3 ? Loc.T("device.rack.clipboard.couldnt_paste_a_device_failed") : Loc.T("device.rack.clipboard.nothing_to_paste_here")); return; }
+ if (n == 0) { _ctx.Status(Loc.T("device.rack.clipboard.this_chain_cant_take_the")); return; }
+ _ctx.Status(skipped > 0 ? Loc.F("device.rack.clipboard.pasted_devices_skipped_this_chain", n, skipped) : Loc.F("device.rack.clipboard.pasted_devices", n));
if (Sel != c) Sel = c;
RcSelect(firstFx >= 0 ? new RackDeviceSel(rack, c, false, firstFx) : new RackDeviceSel(rack, c, true, firstMidi));
DeferRebuild();
@@ -152,13 +152,13 @@ internal sealed partial class RackCardView
{
-2 => _rp.Kind switch
{
- RackKind.MidiEffect => Loc.T("A MIDI Effect Rack takes MIDI effects only."),
- RackKind.AudioEffect => Loc.T("An Audio Effect Rack takes audio effects only."),
- _ => midi ? Loc.T("This rack's chains take no MIDI effects.") : Loc.T("This rack's chains take no audio effects."),
+ RackKind.MidiEffect => Loc.T("device.rack.a_midi_effect_rack_takes"),
+ RackKind.AudioEffect => Loc.T("device.rack.an_audio_effect_rack_takes"),
+ _ => midi ? Loc.T("device.rack.clipboard.this_racks_chains_take_no") : Loc.T("device.rack.clipboard.this_racks_chains_take_no_2"),
},
- -3 => Loc.T("A rack can't go inside a rack."),
- -5 => Loc.T("MIDI effects run in the first 16 chains."),
- _ => Loc.T("Nothing to paste here."),
+ -3 => Loc.T("device.rack.a_rack_cant_go_inside"),
+ -5 => Loc.T("device.rack.clipboard.midi_effects_run_in_the"),
+ _ => Loc.T("device.rack.clipboard.nothing_to_paste_here"),
};
// ---- undo for the card's value controls -------------------------------------------
@@ -190,21 +190,21 @@ internal sealed partial class RackCardView
MenuKit.AddGroups(f.Items,
new Control[]
{
- MenuKit.Item(Loc.T("Move left"), GlyphKind.StepLeft, () => RcMove(s, idx - 1), null, idx > 0),
- MenuKit.Item(Loc.T("Move right"), GlyphKind.StepRight, () => RcMove(s, idx + 1), null, idx < n - 1),
+ MenuKit.Item(Loc.T("device.rack.clipboard.move_left"), GlyphKind.StepLeft, () => RcMove(s, idx - 1), null, idx > 0),
+ MenuKit.Item(Loc.T("device.rack.clipboard.move_right"), GlyphKind.StepRight, () => RcMove(s, idx + 1), null, idx < n - 1),
},
new Control[]
{
- MenuKit.Item(Loc.T("Copy"), GlyphKind.Copy, () => RcCopy(s), MenuKit.CopyKey),
- MenuKit.Item(Loc.T("Cut"), GlyphKind.Cut, () => RcCut(s), MenuKit.CutKey),
- MenuKit.Item(Loc.T("Paste"), GlyphKind.Paste, () => RcPaste(c, s), MenuKit.PasteKey, RcCanPaste(c)),
- MenuKit.Item(Loc.T("Duplicate"), GlyphKind.Duplicate, () => RcDuplicate(s), MenuKit.DuplicateKey),
+ MenuKit.Item(Loc.T("common.copy"), GlyphKind.Copy, () => RcCopy(s), MenuKit.CopyKey),
+ MenuKit.Item(Loc.T("common.cut"), GlyphKind.Cut, () => RcCut(s), MenuKit.CutKey),
+ MenuKit.Item(Loc.T("common.paste"), GlyphKind.Paste, () => RcPaste(c, s), MenuKit.PasteKey, RcCanPaste(c)),
+ MenuKit.Item(Loc.T("common.duplicate"), GlyphKind.Duplicate, () => RcDuplicate(s), MenuKit.DuplicateKey),
},
- new Control[] { MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () => RcDelete(s), MenuKit.DeleteKey) });
+ new Control[] { MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () => RcDelete(s), MenuKit.DeleteKey) });
}
// A Loc.T("Paste") item for a chain (its row menu, the lane's add menus): at the end of the section.
- private MenuItem RcPasteItem(int c) => MenuKit.Item(Loc.T("Paste"), GlyphKind.Paste, () => RcPaste(c), MenuKit.PasteKey, RcCanPaste(c));
+ private MenuItem RcPasteItem(int c) => MenuKit.Item(Loc.T("common.paste"), GlyphKind.Paste, () => RcPaste(c), MenuKit.PasteKey, RcCanPaste(c));
private void RcMove(RackDeviceSel s, int to)
{
@@ -331,7 +331,7 @@ internal sealed partial class RackCardView
if (_ra.RackAddress is not int rack) return;
bool midi = t.Slot == RcSlot.Midi;
int r = midi ? E.RackDevChainMidiMoveTo(T, rack, t.Chain, t.Index, to) : E.RackDevChainDeviceMoveTo(T, rack, t.Chain, t.Index, to);
- if (r < 0) { _ctx.Status(r == -5 ? Loc.T("MIDI effects run in the first 16 chains.") : Loc.T("The device can't go there.")); return; }
+ if (r < 0) { _ctx.Status(r == -5 ? Loc.T("device.rack.clipboard.midi_effects_run_in_the") : Loc.T("device.rack.clipboard.the_device_cant_go_there")); return; }
Sel = to;
RcSelect(new RackDeviceSel(rack, to, midi, r));
DeferRebuild();
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCard.MacroTab.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCard.MacroTab.cs
index d979a90c..5e8fd077 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCard.MacroTab.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCard.MacroTab.cs
@@ -41,7 +41,7 @@ internal sealed partial class RackCardView
var slot = RcText($"Macro {m + 1}", NotaPalette.TextTertiary, 7.5);
var nameTb = RcName(name, NotaPalette.TextPrimary, 10);
nameTb.Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(nameTb, Loc.T("Double-click to rename"));
+ ToolTip.SetTip(nameTb, Loc.T("device.rack.double_click_to_rename"));
nameTb.DoubleTapped += (_, _) => RcPromptRename(nameTb, name, s => a.SetMacroName(m, s));
var value = RcMono(NotaNum.Pct(a.MacroGet(m)), NotaPalette.TextPrimary, 9);
value.Margin = new Thickness(8, 0, 0, 0);
@@ -63,7 +63,7 @@ internal sealed partial class RackCardView
});
var curveLabel = RcText(mixed ? "Curve · mixed" : "Curve", NotaPalette.TextTertiary, 7.5);
var map = RcKey("Map", () => { _rs.MappingMacro = m; _rs.Centre = RackCentreTab.Chains; DeferRebuild(); },
- tip: Loc.T("Map this macro: click parameters on the Chains tab"));
+ tip: Loc.T("device.rack.macro_tab.map_this_macro_click_parameters"));
var right = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 6, VerticalAlignment = VerticalAlignment.Center,
@@ -79,14 +79,14 @@ internal sealed partial class RackCardView
if (targets.Count == 0)
{
- var empty = new Border { Padding = new Thickness(4, 8), Child = Hint(Loc.T("No targets yet. Press Map, then click parameters on the Chains tab.")) };
+ var empty = new Border { Padding = new Thickness(4, 8), Child = Hint(Loc.T("device.rack.macro_tab.no_targets_yet_press_map")) };
return new DockPanel { LastChildFill = true, Children = { head, empty } };
}
var cols = new Grid { ColumnDefinitions = new ColumnDefinitions("*,150,56,12"), ColumnSpacing = 6, Height = 12, Margin = new Thickness(0, 4, 0, 0) };
cols.Children.Add(RcText("Target", NotaPalette.TextTertiary, 7.5));
var rangeTitle = RcText("Range", NotaPalette.TextTertiary, 7.5);
- ToolTip.SetTip(rangeTitle, Loc.T("Drag the ends · min above max inverts"));
+ ToolTip.SetTip(rangeTitle, Loc.T("device.rack.macro_tab.drag_the_ends_min_above"));
Grid.SetColumn(rangeTitle, 1); cols.Children.Add(rangeTitle);
var rows = new StackPanel { Spacing = 2 };
rows.Children.Add(cols);
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Macros.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Macros.cs
index 2799e471..9ceb234a 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Macros.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Macros.cs
@@ -28,7 +28,7 @@ internal sealed partial class RackCardView
if (_rs.Mapping) _rs.MappingMacro = -1;
else { _rs.MappingMacro = _rs.SelectedMacro; _rs.Centre = RackCentreTab.Chains; }
DeferRebuild();
- }, on: mapping, tip: mapping ? Loc.T("Stop mapping (Esc)") : Loc.T("Map the chosen macro: click parameters in the chain"));
+ }, on: mapping, tip: mapping ? Loc.T("device.rack.macros.stop_mapping_esc") : Loc.T("device.rack.macros.map_the_chosen_macro_click"));
map.HorizontalAlignment = HorizontalAlignment.Right;
var title = RcText("Macros", NotaPalette.TextTertiary, NotaType.KnobLabel, FontWeight.SemiBold);
var head = new Grid { Height = RcTabHeight, ColumnDefinitions = new ColumnDefinitions("*,Auto"), Children = { title, map } };
@@ -128,8 +128,8 @@ internal sealed partial class RackCardView
Child = host,
};
ToolTip.SetTip(cell, has
- ? Loc.F("{0} → {1} · drag to turn · double-click resets", name, Loc.Plural(count, "{0} target", "{0} targets"))
- : Loc.T("Not mapped · pick it and press Map"));
+ ? Loc.F("device.rack.macros.drag_to_turn_double_click", name, Loc.Plural("device.rack.macros.targets", count))
+ : Loc.T("device.rack.macros.not_mapped_pick_it_and"));
cell.PointerPressed += (_, e) =>
{
var pt = e.GetCurrentPoint(cell).Properties;
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCard.RightPanel.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCard.RightPanel.cs
index 11f43e38..d2b03731 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCard.RightPanel.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCard.RightPanel.cs
@@ -27,7 +27,7 @@ internal sealed partial class RackCardView
{
var a = _ra;
int n = a.ChainCount();
- if (n == 0) return new Border { Padding = new Thickness(2), Child = Hint(Loc.T("No chain yet.")) };
+ if (n == 0) return new Border { Padding = new Thickness(2), Child = Hint(Loc.T("device.rack.right_panel.no_chain_yet")) };
int c = Sel;
var stack = new StackPanel { Spacing = 7 };
@@ -35,7 +35,7 @@ internal sealed partial class RackCardView
string name = RcChainName(c);
var nameTb = RcName(name, NotaPalette.TextPrimary, NotaType.RowLabel);
nameTb.Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(nameTb, Loc.T("Double-click to rename"));
+ ToolTip.SetTip(nameTb, Loc.T("device.rack.double_click_to_rename"));
nameTb.DoubleTapped += (_, _) => RcPromptRename(nameTb, name, s => a.SetChainName(c, s));
var idx = RcMono($"{c + 1} / {n}", NotaPalette.TextTertiary, 7.5);
stack.Children.Add(new DockPanel { LastChildFill = true, Children = { RcDock(dot, Dock.Left), RcDock(idx, Dock.Right), nameTb } });
@@ -75,8 +75,8 @@ internal sealed partial class RackCardView
bool full = _rp.Kind == RackKind.MidiEffect && n >= RcMidiChainLimit;
var dup = RcKey("Duplicate", () => { int d = a.DuplicateChain(c); if (d >= 0) Sel = d; DeferRebuild(); }, enabled: !full,
- tip: full ? Loc.F("A MIDI Effect Rack holds up to {0} chains", RcMidiChainLimit) : Loc.T("Copy this chain after itself"));
- var del = RcKey("Delete", () => RcDeleteChain(c), enabled: n > 1, tip: n > 1 ? Loc.T("Delete this chain") : Loc.T("A rack keeps at least one chain"));
+ tip: full ? Loc.F("device.rack.a_midi_effect_rack_holds", RcMidiChainLimit) : Loc.T("device.rack.right_panel.copy_this_chain_after_itself"));
+ var del = RcKey("Delete", () => RcDeleteChain(c), enabled: n > 1, tip: n > 1 ? Loc.T("device.rack.right_panel.delete_this_chain") : Loc.T("device.rack.right_panel.a_rack_keeps_at_least"));
dup.HorizontalAlignment = del.HorizontalAlignment = HorizontalAlignment.Stretch;
var buttons = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*"), ColumnSpacing = 4, Children = { dup, del } };
Grid.SetColumn(del, 1);
@@ -96,7 +96,7 @@ internal sealed partial class RackCardView
LastChildFill = true, Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand),
Children = { RcDock(k, Dock.Left), RcDock(chev, Dock.Right), v },
};
- ToolTip.SetTip(row, Loc.F("Edit on the {0} tab", _rp.ZoneTab));
+ ToolTip.SetTip(row, Loc.F("device.rack.right_panel.edit_on_the_tab", _rp.ZoneTab));
row.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(row).Properties.IsLeftButtonPressed) return;
@@ -142,11 +142,11 @@ internal sealed partial class RackCardView
MidiLearn.Bind(vol, MidiTarget.RackVolume(T, a.LearnDeviceIndex), "Rack Volume");
stack.Children.Add(vol);
var glide = RcSlider("Glide", () => a.RackGlide(), v => a.SetRackGlide((float)v), () => NotaNum.Unit(a.RackGlide() * 500, "0", "ms"), reset: () => a.SetRackGlide(0f));
- ToolTip.SetTip(glide, Loc.T("Glides between notes in mono mode"));
+ ToolTip.SetTip(glide, Loc.T("device.rack.right_panel.glides_between_notes_in_mono"));
stack.Children.Add(glide);
- toggles.Children.Add(Switch(Loc.T("Mono (last note)"), () => a.RackMono(), () => RcStep(() => a.SetRackMono(!a.RackMono())), out var monoSync));
+ toggles.Children.Add(Switch(Loc.T("device.rack.right_panel.mono_last_note"), () => a.RackMono(), () => RcStep(() => a.SetRackMono(!a.RackMono())), out var monoSync));
_irTick.Add(monoSync);
- ToolTip.SetTip(toggles.Children[^1], Loc.T("All chains share one voice, the last key wins"));
+ ToolTip.SetTip(toggles.Children[^1], Loc.T("device.rack.right_panel.all_chains_share_one_voice"));
break;
}
case RackKind.AudioEffect:
@@ -159,21 +159,21 @@ internal sealed partial class RackCardView
() => NotaNum.Db(20 * Math.Log10(Math.Max(1e-6, a.RackVolume())), signed: true), reset: () => a.SetRackVolume(1f), bipolar: true);
MidiLearn.Bind(gain, MidiTarget.RackVolume(T, a.LearnDeviceIndex), "Rack Gain");
stack.Children.Add(gain);
- toggles.Children.Add(Switch(Loc.T("Follow input level"), () => a.SelectorFollows(), () => RcStep(() => { a.SetSelectorFollows(!a.SelectorFollows()); DeferRebuild(); }), out var followSync));
+ toggles.Children.Add(Switch(Loc.T("device.rack.right_panel.follow_input_level"), () => a.SelectorFollows(), () => RcStep(() => { a.SetSelectorFollows(!a.SelectorFollows()); DeferRebuild(); }), out var followSync));
_irTick.Add(followSync);
- ToolTip.SetTip(toggles.Children[^1], Loc.T("In Select mode the selector follows the input level instead of its handle"));
+ ToolTip.SetTip(toggles.Children[^1], Loc.T("device.rack.right_panel.in_select_mode_the_selector"));
toggles.Children.Add(Switch("Latency compensation", () => a.RackPdc(), () => RcStep(() => a.SetRackPdc(!a.RackPdc())), out var pdcSync));
_irTick.Add(pdcSync);
- ToolTip.SetTip(toggles.Children[^1], Loc.T("Line up chains with different latency"));
+ ToolTip.SetTip(toggles.Children[^1], Loc.T("device.rack.right_panel.line_up_chains_with_different"));
break;
}
default:
- toggles.Children.Add(Switch(Loc.T("Merge duplicate notes"), () => a.RackMerge(), () => RcStep(() => a.SetRackMerge(!a.RackMerge())), out var mSync));
+ toggles.Children.Add(Switch(Loc.T("device.rack.right_panel.merge_duplicate_notes"), () => a.RackMerge(), () => RcStep(() => a.SetRackMerge(!a.RackMerge())), out var mSync));
_irTick.Add(mSync);
- ToolTip.SetTip(toggles.Children[^1], Loc.T("Two chains sending the same pitch play one note"));
- toggles.Children.Add(Switch(Loc.T("Pass through outside zones"), () => a.RackThru(), () => RcStep(() => a.SetRackThru(!a.RackThru())), out var tSync));
+ ToolTip.SetTip(toggles.Children[^1], Loc.T("device.rack.right_panel.two_chains_sending_the_same"));
+ toggles.Children.Add(Switch(Loc.T("device.rack.right_panel.pass_through_outside_zones"), () => a.RackThru(), () => RcStep(() => a.SetRackThru(!a.RackThru())), out var tSync));
_irTick.Add(tSync);
- ToolTip.SetTip(toggles.Children[^1], Loc.T("Notes no chain takes reach the instrument unchanged"));
+ ToolTip.SetTip(toggles.Children[^1], Loc.T("device.rack.right_panel.notes_no_chain_takes_reach"));
break;
}
var foot = Section(toggles, SectionEdge.Top);
@@ -187,8 +187,8 @@ internal sealed partial class RackCardView
{
var a = _ra;
int n = a.ChainCount(), mapped = RcMappedMacros();
- string chains = Loc.Plural(n, "{0} chain", "{0} chains");
- string macros = Loc.Plural(mapped, "{0} macro mapped", "{0} macros mapped");
+ string chains = Loc.Plural("device.rack.chains", n);
+ string macros = Loc.Plural("device.rack.right_panel.macros_mapped", mapped);
switch (_rp.Kind)
{
case RackKind.AudioEffect:
@@ -196,13 +196,13 @@ internal sealed partial class RackCardView
string mode = a.RackMode() switch
{
RackKindProfile.Serial => "Serial",
- RackKindProfile.Select => Loc.F("Select {0}", (int)Math.Round(a.LiveSelector() * 127)) + (a.SelectorFollows() ? Loc.T(" · follows input") : ""),
+ RackKindProfile.Select => Loc.F("device.rack.right_panel.select", (int)Math.Round(a.LiveSelector() * 127)) + (a.SelectorFollows() ? Loc.T("device.rack.right_panel.follows_input") : ""),
_ => "Parallel",
};
- return Loc.F("{0} · {1} · dry/wet {2} · {3}", mode, chains, NotaNum.Pct(a.RackDryWet()), macros);
+ return Loc.F("device.rack.right_panel.dry_wet", mode, chains, NotaNum.Pct(a.RackDryWet()), macros);
}
case RackKind.MidiEffect:
- return Loc.F("{0} · {1} → merged MIDI · {2}", a.RackMode() == RackKindProfile.Select ? "Select" : "Parallel", chains, macros);
+ return Loc.F("device.rack.right_panel.merged_midi", a.RackMode() == RackKindProfile.Select ? "Select" : "Parallel", chains, macros);
default:
{
var hits = RcProbeHits(_rs.ProbePitch);
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Zones.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Zones.cs
index c55db3b5..9eb8299c 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCard.Zones.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCard.Zones.cs
@@ -56,8 +56,8 @@ internal sealed partial class RackCardView
int sel = (int)Math.Round(a.LiveSelector() * 127);
var bar = new RackRangeBar { Single = true, Lo = sel, Hi = sel, Dim = !selectOn || follows, Height = 10, IsHitTestVisible = !follows };
ToolTip.SetTip(bar, follows
- ? Loc.T("The selector follows the input level · turn Follow input off on the Rack out tab to set it by hand")
- : Loc.T("Drag to choose which chains play · right-click to map it to a macro"));
+ ? Loc.T("device.rack.zones.the_selector_follows_the_input")
+ : Loc.T("device.rack.zones.drag_to_choose_which_chains"));
var barg = RcEditGesture();
bar.Changed += (lo, _) => { barg.Begin(); a.SetSelector(lo / 127f); RcProbeUpdate(); };
bar.Committed += () => { barg.End(); DeferRebuild(); };
@@ -91,7 +91,7 @@ internal sealed partial class RackCardView
kb.Changed += (lo, hi) => { kbg.Begin(); a.ChainZone(cc, out _, out _, out int l, out int h); a.SetChainZone(cc, lo, hi, l, h); RcProbeUpdate(); };
kb.Committed += () => { kbg.End(); Sel = cc; DeferRebuild(); };
kb.Hover += v => { _rs.ProbePitch = v; RcProbeUpdate(); };
- ToolTip.SetTip(kb, Loc.T("Drag the edges to set the key zone · hover to test a note"));
+ ToolTip.SetTip(kb, Loc.T("device.rack.zones.drag_the_edges_to_set"));
Grid.SetColumn(kb, 1); grid.Children.Add(kb);
keyBars.Add(kb);
if (vel)
@@ -100,7 +100,7 @@ internal sealed partial class RackCardView
var vbg = RcEditGesture();
vb.Changed += (lo, hi) => { vbg.Begin(); a.ChainZone(cc, out int k0, out int k1, out _, out _); a.SetChainZone(cc, k0, k1, lo, hi); RcProbeUpdate(); };
vb.Committed += () => { vbg.End(); Sel = cc; DeferRebuild(); };
- ToolTip.SetTip(vb, Loc.T("Drag the edges to set the velocity zone"));
+ ToolTip.SetTip(vb, Loc.T("device.rack.zones.drag_the_edges_to_set_3"));
Grid.SetColumn(vb, 2); grid.Children.Add(vb);
}
if (select)
@@ -111,7 +111,7 @@ internal sealed partial class RackCardView
var sbg = RcEditGesture();
sb.Changed += (lo, hi) => { sbg.Begin(); a.SetSelectRange(cc, lo, hi); RcProbeUpdate(); };
sb.Committed += () => { sbg.End(); Sel = cc; DeferRebuild(); };
- ToolTip.SetTip(sb, Loc.T("Select range: in Select mode this chain plays while the selector is inside it"));
+ ToolTip.SetTip(sb, Loc.T("device.rack.zones.select_range_in_select_mode"));
kb.VerticalAlignment = VerticalAlignment.Top;
kb.Height = 12;
grid.Children.Remove(kb); // it moves into the stack with the select bar
@@ -127,7 +127,7 @@ internal sealed partial class RackCardView
var sbg = RcEditGesture();
sb.Changed += (lo, hi) => { sbg.Begin(); a.SetSelectRange(cc, lo, hi); RcProbeUpdate(); };
sb.Committed += () => { sbg.End(); Sel = cc; DeferRebuild(); };
- ToolTip.SetTip(sb, Loc.T("Drag the edges to set the select range"));
+ ToolTip.SetTip(sb, Loc.T("device.rack.zones.drag_the_edges_to_set_2"));
Grid.SetColumn(sb, 1); grid.Children.Add(sb);
}
var rowBorder = new Border { CornerRadius = NotaRadius.Badge, Padding = new Thickness(4, 0, 0, 0), Child = grid };
@@ -135,8 +135,8 @@ internal sealed partial class RackCardView
rowHosts.Add((rowBorder, name, c));
}
- string hint = keys ? Loc.T("Drag zone edges · hover to test a note")
- : selectOn ? Loc.T("Drag the selector or map it to a macro") : Loc.T("Ranges apply when Chains run is set to Select");
+ string hint = keys ? Loc.T("device.rack.zones.drag_zone_edges_hover_to")
+ : selectOn ? Loc.T("device.rack.zones.drag_the_selector_or_map") : Loc.T("device.rack.zones.ranges_apply_when_chains_run");
var foot = new DockPanel
{
LastChildFill = false, Height = 16,
@@ -160,9 +160,9 @@ internal sealed partial class RackCardView
}
string names = string.Join(keys ? " + " : ", ", hits.Select(RcChainName));
if (keys)
- result.Text = probe < 0 ? Loc.T("Hover the zones") : Loc.F("{0} · vel {1} → {2}", NoteName(probe), RcProbeVelocity, names.Length > 0 ? names : Loc.T("nothing"));
+ result.Text = probe < 0 ? Loc.T("device.rack.zones.hover_the_zones") : Loc.F("device.rack.zones.vel", NoteName(probe), RcProbeVelocity, names.Length > 0 ? names : Loc.T("device.rack.zones.nothing"));
else
- result.Text = Loc.F("selector {0} → {1}{2}", (int)Math.Round(a.LiveSelector() * 127), names.Length > 0 ? names : Loc.T("silence"), selectOn ? "" : Loc.T(" · inactive"));
+ result.Text = Loc.F("device.rack.zones.selector", (int)Math.Round(a.LiveSelector() * 127), names.Length > 0 ? names : Loc.T("device.rack.zones.silence"), selectOn ? "" : Loc.T("device.rack.zones.inactive"));
result.Foreground = hits.Count > 0 ? NotaPalette.TealBright : NotaPalette.TextTertiary;
};
RcProbeUpdate();
@@ -173,12 +173,12 @@ internal sealed partial class RackCardView
private void RcSelectorMenu(Control anchor)
{
var f = new MenuFlyout();
- f.Items.Add(MenuKit.Header("Selector", null, Loc.T("Map to a macro")));
+ f.Items.Add(MenuKit.Header("Selector", null, Loc.T("device.rack.map_to_a_macro")));
f.Items.Add(new Separator());
for (int m = 0; m < 8; m++)
{
int mm = m;
- var mi = new MenuItem { Header = Loc.F("Macro {0} · {1}", m + 1, _ra.MacroName(m)) };
+ var mi = new MenuItem { Header = Loc.F("common.macro", m + 1, _ra.MacroName(m)) };
mi.Click += (_, _) => RcMapSelector(mm);
f.Items.Add(mi);
}
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCard.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCard.cs
index 542fd5e7..457ab782 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCard.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCard.cs
@@ -151,11 +151,11 @@ internal sealed partial class RackCardView
private string RcCentreSummary()
{
int n = _ra.ChainCount();
- string chains = Loc.Plural(n, "{0} chain", "{0} chains");
+ string chains = Loc.Plural("device.rack.chains", n);
return _rs.Centre switch
{
- RackCentreTab.Zones => _rp.KeyZones ? Loc.T("Keys C−1–G9 · vel 0–127") : "Select 0–127",
- RackCentreTab.Macros => Loc.F("{0} of 8 mapped", RcMappedMacros()),
+ RackCentreTab.Zones => _rp.KeyZones ? Loc.T("device.rack.keys_c_1_g9_vel") : "Select 0–127",
+ RackCentreTab.Macros => Loc.F("device.rack.of_8_mapped", RcMappedMacros()),
_ => _rp.Modes.Length > 0 ? $"{chains} · {RcModeWord()}" : chains,
};
}
@@ -222,7 +222,7 @@ internal sealed partial class RackCardView
if (_rp.TakesInstrument) { n = _ra.ChainInstrumentName(c); if (n.Length > 0) return n; }
if (_rp.Kind == RackKind.MidiEffect && _ra.ChainMidiCount(c) > 0) return _ra.ChainMidiName(c, 0);
if (_rp.Kind == RackKind.AudioEffect && _ra.ChainDeviceCount(c) > 0) return _ra.ChainDeviceName(c, 0);
- return Loc.F("Chain {0}", c + 1);
+ return Loc.F("device.rack.chain", c + 1);
}
/// <summary>Whether a chain sounds: not muted, and soloed when any chain is.</summary>
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCardView.Drum.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCardView.Drum.cs
index c4477a8b..8d320c78 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCardView.Drum.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCardView.Drum.cs
@@ -78,11 +78,11 @@ internal sealed partial class RackCardView
_ => DrumGrid(a),
};
if (_drumView == 3)
- readout.Text = Loc.F("{0} slots · {1} assigned", MacroPanel.Count, MacroPanel.Assigned(macros));
+ readout.Text = Loc.F("device.rack.drum.slots_assigned", MacroPanel.Count, MacroPanel.Assigned(macros));
else if (_drumView != 1)
{
int inBank = pads.Count(c => InBank(a.ChainTriggerNote(c)));
- readout.Text = Loc.F("{0} · {1}/16 loaded", BankNames[_drumBank], inBank);
+ readout.Text = Loc.F("device.rack.drum.16_loaded", BankNames[_drumBank], inBank);
}
var left = new Grid { RowDefinitions = new RowDefinitions("Auto,Auto,*") };
@@ -156,18 +156,18 @@ internal sealed partial class RackCardView
if (first >= 0) Sel = first;
DeferRebuild();
}, out _, padX: 5);
- ToolTip.SetTip(bank, Loc.T("Pad bank: sixteen notes from C1, C2, C3 or C4"));
+ ToolTip.SetTip(bank, Loc.T("device.rack.drum.pad_bank_sixteen_notes_from"));
var swing = SliderRow("SWING", () => E.RackSwing(T), v => E.RackSetSwing(T, (float)v),
() => NotaNum.Pct(E.RackSwing(T)), out var swingSync, reset: () => E.RackSetSwing(T, 0f), valueWidth: 28);
- ToolTip.SetTip(swing, Loc.T("Push the off-beat sixteenths late"));
+ ToolTip.SetTip(swing, Loc.T("device.rack.drum.push_the_off_beat_sixteenths"));
var humanize = SliderRow("HUMANIZE", () => E.RackHumanize(T), v => E.RackSetHumanize(T, (float)v),
() => NotaNum.Pct(E.RackHumanize(T)), out var humSync, reset: () => E.RackSetHumanize(T, 0f), valueWidth: 28);
- ToolTip.SetTip(humanize, Loc.T("Nudge every hit's timing at random"));
+ ToolTip.SetTip(humanize, Loc.T("device.rack.drum.nudge_every_hits_timing_at"));
_irTick.Add(swingSync); _irTick.Add(humSync);
var fold = DrumButton("Fold", _drumFold, () => { _drumFold = !_drumFold; DeferRebuild(); });
- ToolTip.SetTip(fold, _drumFold ? Loc.T("Show every pad of the bank") : Loc.T("Hide the empty pads"));
+ ToolTip.SetTip(fold, _drumFold ? Loc.T("device.rack.drum.show_every_pad_of_the") : Loc.T("device.rack.drum.hide_the_empty_pads"));
if (_drumView != 0) fold.AttachedToVisualTree += (_, _) => Inactive.Set(fold, true); // Fold is a Pads view setting
var g = new Grid
@@ -210,7 +210,7 @@ internal sealed partial class RackCardView
}
if (notes.Count == 0)
{
- var empty = DrumHint(Loc.F("No pads in bank {0}.", BankNames[_drumBank]));
+ var empty = DrumHint(Loc.F("device.rack.drum.no_pads_in_bank", BankNames[_drumBank]));
Grid.SetRowSpan(empty, 4); Grid.SetColumnSpan(empty, 4);
grid.Children.Add(empty);
}
@@ -251,8 +251,8 @@ internal sealed partial class RackCardView
CornerRadius = NotaRadius.Badge, Cursor = new Cursor(StandardCursorType.Hand), ClipToBounds = true, Child = cell,
};
ToolTip.SetTip(pad, filled
- ? Loc.F("{0} · {1} — click to play, right-click for more", name, NoteName(note))
- : Loc.F("{0} — click to add an instrument, or drop a sample here", NoteName(note)));
+ ? Loc.F("device.rack.drum.click_to_play_right_click", name, NoteName(note))
+ : Loc.F("device.rack.drum.click_to_add_an_instrument", NoteName(note)));
if (filled)
{
@@ -312,28 +312,28 @@ internal sealed partial class RackCardView
{
Sel = chain;
var f = new MenuFlyout();
- f.Items.Add(MenuKit.Header(PadName(a, chain), null, Loc.T("Pad")));
+ f.Items.Add(MenuKit.Header(PadName(a, chain), null, Loc.T("device.rack.drum.pad")));
f.Items.Add(new Separator());
- var rename = MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit);
+ var rename = MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit);
rename.Click += (_, _) => Avalonia.Threading.Dispatcher.UIThread.Post(() => PromptRenamePad(a, anchor, chain));
f.Items.Add(rename);
- var chokeMenu = new MenuItem { Header = Loc.T("Choke group") };
+ var chokeMenu = new MenuItem { Header = Loc.T("device.rack.drum.choke_group") };
int cur = E.RackChainChoke(T, chain);
for (int g = 0; g < ChokeNames.Length; g++)
{
int gv = g;
- var mi = new MenuItem { Header = g == 0 ? Loc.T("None", "choke group") : Loc.F("Group {0}", g), ToggleType = MenuItemToggleType.Radio, IsChecked = g == cur };
+ var mi = new MenuItem { Header = g == 0 ? Loc.T("device.rack.drum.none_choke_group") : Loc.F("device.rack.drum.group", g), ToggleType = MenuItemToggleType.Radio, IsChecked = g == cur };
mi.Click += (_, _) => E.RackSetChainChoke(T, chain, gv);
chokeMenu.Items.Add(mi);
}
f.Items.Add(chokeMenu);
- var open = new MenuItem { Header = Loc.T("Open chain") };
+ var open = new MenuItem { Header = Loc.T("device.rack.drum.open_chain") };
open.Click += (_, _) => _drumView = 2;
f.Items.Add(open);
f.Items.Add(new Separator());
- f.Items.Add(MenuKit.Danger(Loc.T("Remove pad"), GlyphKind.Trash, () => { a.RemoveChain(chain); _ctx.NotifyChanged(); }));
+ f.Items.Add(MenuKit.Danger(Loc.T("device.rack.drum.remove_pad"), GlyphKind.Trash, () => { a.RemoveChain(chain); _ctx.NotifyChanged(); }));
bool renaming = false;
rename.Click += (_, _) => renaming = true;
@@ -383,8 +383,8 @@ internal sealed partial class RackCardView
Control list;
if (pads.Count == 0)
{
- list = DrumHint(Loc.F("No pads in bank {0} — drop samples on the Pads view.", BankNames[_drumBank]));
- readout.Text = Loc.F("{0} · empty", BankNames[_drumBank]);
+ list = DrumHint(Loc.F("device.rack.drum.no_pads_in_bank_drop", BankNames[_drumBank]));
+ readout.Text = Loc.F("device.rack.drum.empty", BankNames[_drumBank]);
}
else
{
@@ -397,11 +397,11 @@ internal sealed partial class RackCardView
int shown = Math.Max(1, (int)Math.Floor((scroll.Viewport.Height - 2) / rowH));
int last = Math.Min(pads.Count, first + shown);
readout.Text = last - first >= pads.Count
- ? Loc.F("{0} · {1}", BankNames[_drumBank], Loc.Plural(pads.Count, "{0} pad", "{0} pads"))
+ ? Loc.F("common.pattern_n", BankNames[_drumBank], Loc.Plural("device.rack.drum.pads", pads.Count))
: $"{BankNames[_drumBank]} · {first + 1}–{last} of {pads.Count}";
}
scroll.ScrollChanged += (_, _) => Visible();
- readout.Text = Loc.F("{0} · {1}", BankNames[_drumBank], Loc.Plural(pads.Count, "{0} pad", "{0} pads"));
+ readout.Text = Loc.F("common.pattern_n", BankNames[_drumBank], Loc.Plural("device.rack.drum.pads", pads.Count));
list = scroll;
}
DockPanel.SetDock(headBar, Dock.Top);
@@ -427,7 +427,7 @@ internal sealed partial class RackCardView
if (!e.GetCurrentPoint(nameCell).Properties.IsLeftButtonPressed) return;
e.Handled = true; SelectPad(c);
};
- ToolTip.SetTip(nameCell, Loc.T("Select the pad"));
+ ToolTip.SetTip(nameCell, Loc.T("device.rack.drum.select_the_pad"));
g.Children.Add(nameCell);
var noteTb = DrumMono(NoteName(note), sel ? AccentBright : TextTertiary, 7);
@@ -436,7 +436,7 @@ internal sealed partial class RackCardView
var vol = new SliderTrack { Norm = VolNorm(a.ChainGain(c)), Reset = () => a.SetChainGain(c, 1f) };
vol.Changed += v => a.SetChainGain(c, NormVol(v));
_irTick.Add(() => { if (!vol.Dragging) vol.Norm = VolNorm(a.ChainGain(c)); });
- ToolTip.SetTip(vol, Loc.T("Pad volume · drag up or down, ⌥-click to type, double-click for 0\u2009dB"));
+ ToolTip.SetTip(vol, Loc.T("device.rack.drum.pad_volume_drag_up_or"));
ValueEntry.Attach(vol, new ValueField("Pad volume", () => VolNorm(a.ChainGain(c)), n => VolText(NormVol(n)),
n => { vol.Norm = n; a.SetChainGain(c, NormVol(n)); }, Default: VolNorm(1f)));
if (!Nested) MidiLearn.Bind(vol, MidiTarget.RackChainGain(T, a.AutomationDeviceIndex, c), "Pad Volume");
@@ -450,7 +450,7 @@ internal sealed partial class RackCardView
var solo = MixBtn("S", () => a.ChainSolo(c), NotaPalette.Solo, () => a.SetChainSolo(c, !a.ChainSolo(c)));
var chk = MixBtn(choke > 0 ? choke.ToString() : "·", () => E.RackChainChoke(T, c) > 0, NotaPalette.Teal,
() => { E.RackSetChainChoke(T, c, (E.RackChainChoke(T, c) + 1) % ChokeNames.Length); DeferRebuild(); }, choke: true);
- ToolTip.SetTip(mute, Loc.T("Mute the pad")); ToolTip.SetTip(solo, Loc.T("Solo the pad")); ToolTip.SetTip(chk, Loc.T("Choke group: click for the next"));
+ ToolTip.SetTip(mute, Loc.T("device.rack.drum.mute_the_pad")); ToolTip.SetTip(solo, Loc.T("device.rack.drum.solo_the_pad")); ToolTip.SetTip(chk, Loc.T("device.rack.drum.choke_group_click_for_the"));
if (!Nested) MidiLearn.Bind(mute, MidiTarget.RackChainMute(T, a.AutomationDeviceIndex, c), "Pad Mute");
if (!Nested) MidiLearn.Bind(solo, MidiTarget.RackChainSolo(T, a.AutomationDeviceIndex, c), "Pad Solo");
var msc = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 2, HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Center, Children = { mute, solo, chk } };
@@ -464,7 +464,7 @@ internal sealed partial class RackCardView
var tb = DrumMono(PanText(a.ChainPan(c)), TextSecondary, 7);
tb.HorizontalAlignment = HorizontalAlignment.Center;
var host = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.SizeNorthSouth), Child = tb };
- ToolTip.SetTip(host, MenuKit.Keys(Loc.T("Pad pan · drag up or down, ⌥-click to type, double-click to centre")));
+ ToolTip.SetTip(host, MenuKit.Keys(Loc.T("device.rack.drum.pad_pan_drag_up_or")));
ValueEntry.Attach(host, new ValueField("Pan", () => (a.ChainPan(c) + 1) / 2, n => PanText((float)(n * 2 - 1)),
n => a.SetChainPan(c, (float)Math.Clamp(n * 2 - 1, -1, 1)), Default: 0.5) { After = () => tb.Text = PanText(a.ChainPan(c)) }, tb); // specs/035
bool drag = false; double lastY = 0;
@@ -526,7 +526,7 @@ internal sealed partial class RackCardView
private Control DrumChain(IRackAccess a)
{
- if (!IsPad(a, Sel)) return DrumHint(Loc.T("Select a pad to see its device chain."));
+ if (!IsPad(a, Sel)) return DrumHint(Loc.T("device.rack.drum.select_a_pad_to_see"));
int sc = Sel, note = a.ChainTriggerNote(sc);
var head = new StackPanel
{
@@ -536,7 +536,7 @@ internal sealed partial class RackCardView
new Border { Width = 6, Height = 6, CornerRadius = NotaRadius.Clip, Background = PadHue(sc), VerticalAlignment = VerticalAlignment.Center },
new TextBlock { Text = PadName(a, sc), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center },
DrumMono(NoteName(note), TextTertiary, 7),
- new TextBlock { Text = Loc.T("instrument, then its effects · signal left → right"), FontSize = 8, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center },
+ new TextBlock { Text = Loc.T("device.rack.drum.instrument_then_its_effects_signal"), FontSize = 8, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center },
},
};
var slots = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5 };
@@ -560,7 +560,7 @@ internal sealed partial class RackCardView
Height = DrumTabH, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1), Padding = new Thickness(8, 0),
Child = new TextBlock { Text = "No pad", FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center },
});
- var hint = DrumHint(Loc.T("Drop a sample on a pad, or pick a kit above."));
+ var hint = DrumHint(Loc.T("device.rack.drum.drop_a_sample_on_a"));
Grid.SetRow(hint, 1); g0.Children.Add(hint);
return g0;
}
@@ -568,9 +568,9 @@ internal sealed partial class RackCardView
var hue = PadHue(c);
// header (20): dot · name · note · Open chain
- var link = new TextBlock { Text = _drumView == 2 ? Loc.T("Back to pads") : Loc.T("Open chain"), FontSize = 7, Foreground = NotaPalette.TextMuted, VerticalAlignment = VerticalAlignment.Center };
+ var link = new TextBlock { Text = _drumView == 2 ? Loc.T("device.rack.drum.back_to_pads") : Loc.T("device.rack.drum.open_chain"), FontSize = 7, Foreground = NotaPalette.TextMuted, VerticalAlignment = VerticalAlignment.Center };
var linkHost = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = link };
- ToolTip.SetTip(linkHost, _drumView == 2 ? Loc.T("Show the pads") : Loc.T("Show the pad's instrument and effects"));
+ ToolTip.SetTip(linkHost, _drumView == 2 ? Loc.T("device.rack.drum.show_the_pads") : Loc.T("device.rack.drum.show_the_pads_instrument_and"));
linkHost.PointerEntered += (_, _) => link.Foreground = TextPrimary;
linkHost.PointerExited += (_, _) => link.Foreground = NotaPalette.TextMuted;
linkHost.PointerPressed += (_, e) =>
@@ -606,7 +606,7 @@ internal sealed partial class RackCardView
durTb.Text = a.ChainInstrumentKind(c) == 1 ? "empty" : "synth";
var none = new TextBlock
{
- Text = a.ChainInstrumentKind(c) == 1 ? Loc.T("No sample — drop one on the pad") : Loc.T("A synth voice, no sample"),
+ Text = a.ChainInstrumentKind(c) == 1 ? Loc.T("device.rack.drum.no_sample_drop_one_on") : Loc.T("device.rack.drum.a_synth_voice_no_sample"),
FontSize = 7, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 12, 0, 0),
};
waveBox.Children.Add(none);
@@ -625,22 +625,22 @@ internal sealed partial class RackCardView
var tuneRow = Row("TUNE", () => (E.RackChainTune(T, c) + 48) / 96.0, v => E.RackSetChainTune(T, c, (int)Math.Round(v * 96 - 48)),
() => NotaNum.Unit(E.RackChainTune(T, c), "+0;−0;0", "st"), () => E.RackSetChainTune(T, c, 0), bipolar: true);
var decayRow = Row("DECAY", () => E.RackChainDecay(T, c), v => E.RackSetChainDecay(T, c, (float)v), () => DecayText(E.RackChainDecay(T, c)), () => E.RackSetChainDecay(T, c, 1f));
- ToolTip.SetTip(tuneRow, Loc.T("Transpose the note the pad plays, in semitones"));
- ToolTip.SetTip(decayRow, Loc.T("Shorten the pad's tail; hold lets it ring"));
+ ToolTip.SetTip(tuneRow, Loc.T("device.rack.drum.transpose_the_note_the_pad"));
+ ToolTip.SetTip(decayRow, Loc.T("device.rack.drum.shorten_the_pads_tail_hold"));
var sliders = new StackPanel { Spacing = 6, Children = { volRow, panRow, tuneRow, decayRow } };
// choke · instrument
var chokeSeg = Segments(ChokeNames, () => { int g = E.RackChainChoke(T, c); return g < ChokeNames.Length ? g : -1; },
i => { E.RackSetChainChoke(T, c, i); DeferRebuild(); }, out var chokeSync, padX: 5);
_irTick.Add(chokeSync);
- ToolTip.SetTip(chokeSeg, Loc.T("Pads in the same group cut each other off"));
+ ToolTip.SetTip(chokeSeg, Loc.T("device.rack.drum.pads_in_the_same_group"));
var chokeRow = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 6 };
chokeRow.Children.Add(DrumCap("Choke"));
Grid.SetColumn(chokeSeg, 1); chokeRow.Children.Add(chokeSeg);
Border inst = null!;
inst = DrumWideButton(InstrumentWord(a, c), () => OpenChainInstrumentGui(a, c, inst));
- ToolTip.SetTip(inst, Loc.T("Open the pad's instrument"));
+ ToolTip.SetTip(inst, Loc.T("device.rack.drum.open_the_pads_instrument"));
var foot = new StackPanel { Spacing = 5, Children = { chokeRow, inst } };
var footer = new Border { BorderBrush = NotaPalette.GraphBorder, BorderThickness = new Thickness(0, 1, 0, 0), Padding = new Thickness(0, 5, 0, 0), VerticalAlignment = VerticalAlignment.Bottom, Child = foot };
@@ -668,35 +668,35 @@ internal sealed partial class RackCardView
var status = new TextBlock { FontSize = 8, Foreground = TextSecondary, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis };
var meta = DrumMono("", TextSecondary, 8);
int groups = pads.Select(c => E.RackChainChoke(T, c)).Where(g => g > 0).Distinct().Count();
- meta.Text = Loc.F("{0} · {1}", Loc.Plural(pads.Count, "{0} pad", "{0} pads"), Loc.Plural(groups, "{0} choke group", "{0} choke groups"))
+ meta.Text = Loc.F("common.pattern_n", Loc.Plural("device.rack.drum.pads", pads.Count), Loc.Plural("device.rack.drum.choke_groups", groups))
+ (E.SampleRate > 0 ? " · " + NotaNum.Unit(E.SampleRate / 1000.0, "0.#", "kHz") : "");
// A Drum Rack in a chain has no kit timing (specs/041).
- string Timing() => Nested ? "" : Loc.F(" · swing {0} · humanize {1}", NotaNum.Pct(E.RackSwing(T)), NotaNum.Pct(E.RackHumanize(T)));
+ string Timing() => Nested ? "" : Loc.F("device.rack.drum.swing_humanize", NotaNum.Pct(E.RackSwing(T)), NotaNum.Pct(E.RackHumanize(T)));
string PadWords(int c)
{
string src = E.RackChainSamplerInfo(T, c, out var si) && si.SampleId != 0 && E.TryGetSampleInfo(si.SampleId, out var inf) && inf.SampleRate > 0
- ? Loc.F("sampler {0}", NotaNum.Time(inf.Frames / inf.SampleRate))
+ ? Loc.F("device.rack.drum.sampler", NotaNum.Time(inf.Frames / inf.SampleRate))
: InstrumentWord(a, c).ToLowerInvariant();
int g = E.RackChainChoke(T, c);
- return Loc.F("{0} {1} selected · {2} · choke {3}", PadName(a, c), NoteName(a.ChainTriggerNote(c)), src, g > 0 ? g.ToString() : Loc.T("off"));
+ return Loc.F("device.rack.drum.selected_choke", PadName(a, c), NoteName(a.ChainTriggerNote(c)), src, g > 0 ? g.ToString() : Loc.T("device.rack.drum.off"));
}
string Summary()
{
- string bank = Loc.F("Bank {0}", BankNames[_drumBank]);
+ string bank = Loc.F("device.rack.drum.bank", BankNames[_drumBank]);
if (_drumView == 3) return MacroPanel.Status(E, macros, _drumMacro);
if (_drumView == 1)
{
var inBank = pads.Where(c => InBank(a.ChainTriggerNote(c))).ToList();
var chokes = inBank.GroupBy(c => E.RackChainChoke(T, c)).Where(gr => gr.Key > 0).OrderBy(gr => gr.Key)
- .Select(gr => Loc.F("choke group {0}: {1}", gr.Key, string.Join(", ", gr.Select(c => PadName(a, c))))).ToList();
- return Loc.F("{0} · {1}", bank, Loc.Plural(inBank.Count, "{0} pad", "{0} pads")) + (chokes.Count > 0 ? " · " + string.Join(" · ", chokes) : Loc.T(" · no choke groups"));
+ .Select(gr => Loc.F("device.rack.drum.choke_group_n", gr.Key, string.Join(", ", gr.Select(c => PadName(a, c))))).ToList();
+ return Loc.F("common.pattern_n", bank, Loc.Plural("device.rack.drum.pads", inBank.Count)) + (chokes.Count > 0 ? " · " + string.Join(" · ", chokes) : Loc.T("device.rack.drum.no_choke_groups"));
}
- if (!IsPad(a, Sel)) return Loc.F("{0} · no pad selected{1}", bank, Timing());
+ if (!IsPad(a, Sel)) return Loc.F("device.rack.drum.no_pad_selected", bank, Timing());
if (_drumView == 2)
{
int d = a.ChainDeviceCount(Sel);
- return Loc.F("{0} {1} · {2} → {3} → pad volume, pan", PadName(a, Sel), NoteName(a.ChainTriggerNote(Sel)), a.ChainInstrumentName(Sel), Loc.Plural(d, "{0} effect", "{0} effects"));
+ return Loc.F("device.rack.drum.pad_volume_pan", PadName(a, Sel), NoteName(a.ChainTriggerNote(Sel)), a.ChainInstrumentName(Sel), Loc.Plural("device.rack.drum.effects", d));
}
return $"{bank} · {PadWords(Sel)}{Timing()}";
}
@@ -795,7 +795,7 @@ internal sealed partial class RackCardView
break;
case Nota.Presentation.BrowserItemKind.BuiltinInstrument:
// Racks nest one level, and only in an Instrument Rack chain (specs/041).
- if (item.BuiltinKind is 3 or 4) { _ctx.Status(Loc.T("A rack can't go on a Drum Rack pad.")); return; }
+ if (item.BuiltinKind is 3 or 4) { _ctx.Status(Loc.T("device.rack.drum.a_rack_cant_go_on")); return; }
if (existing >= 0) a.RemoveChain(existing);
added = a.AddChain(item.BuiltinKind);
if (added >= 0) a.SetChainTriggerNote(added, note);
@@ -968,7 +968,7 @@ internal sealed partial class RackCardView
public int MacroParamIndex(int m) => m;
public string MacroName(int m) => a.MacroName(m);
public void SetMacroName(int m, string n) => a.SetMacroName(m, n);
- public string SlotCount(int n) => Loc.Plural(n, "{0} pad", "{0} pads");
+ public string SlotCount(int n) => Loc.Plural("device.rack.drum.pads", n);
public IReadOnlyList<int> Slots() => LoadedPads(a);
public string SlotName(int c) => v.PadName(a, c);
public IBrush SlotHue(int c) => PadHue(c);
@@ -1036,10 +1036,10 @@ internal sealed partial class RackCardView
public void FillMapMenu(MenuFlyout menu, int macro, Action changed)
{
var pads = LoadedPads(a);
- if (pads.Count == 0) { menu.Items.Add(new MenuItem { Header = Loc.T("No pads to map"), IsEnabled = false }); return; }
+ if (pads.Count == 0) { menu.Items.Add(new MenuItem { Header = Loc.T("device.rack.drum.no_pads_to_map"), IsEnabled = false }); return; }
// Every pad at once: its own controls, or the same effect on each pad that has it.
- var all = new MenuItem { Header = Loc.Plural(pads.Count, "All {0} pad", "All {0} pads") };
+ var all = new MenuItem { Header = Loc.Plural("device.rack.drum.all_pads", pads.Count) };
for (int p = 0; p < 4; p++)
{
int pp = p;
@@ -1060,7 +1060,7 @@ internal sealed partial class RackCardView
{
// The pads holding this effect; each maps its first one.
var holders = pads.Select(c => (c, d: FirstOfKind(c, kind))).Where(x => x.d >= 0).ToList();
- var fx = new MenuItem { Header = Loc.F("Every {0} ({1})", dname, Loc.Plural(holders.Count, "{0} pad", "{0} pads")) };
+ var fx = new MenuItem { Header = Loc.F("device.rack.drum.every", dname, Loc.Plural("device.rack.drum.pads", holders.Count)) };
for (int p = 0; p < a.ChainDeviceParamCount(c0, d0); p++)
{
int pp = p;
@@ -1082,7 +1082,7 @@ internal sealed partial class RackCardView
foreach (int c in pads)
{
var pad = new MenuItem { Header = $"{v.PadName(a, c)} · {NoteName(a.ChainTriggerNote(c))}" };
- var ctl = new MenuItem { Header = Loc.T("Pad") };
+ var ctl = new MenuItem { Header = Loc.T("device.rack.drum.pad") };
for (int p = 0; p < 4; p++)
{
var (lo, hi) = PadDefault(p);
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs b/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs
index 045935e0..6fe7335c 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackCardView.cs
@@ -115,7 +115,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
}
// The Remove control in a device slot header (#110): the same one as the track chain's cards.
- private static Border SlotDelBtn(Action onDelete) => DeviceCardKit.RemoveButton(Loc.T("Remove device"), onDelete);
+ private static Border SlotDelBtn(Action onDelete) => DeviceCardKit.RemoveButton(Loc.T("device.rack.remove_device"), onDelete);
private int MacrosOnTarget(IRackAccess a, int sc, int dev)
{
@@ -127,7 +127,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
private Control IrInstrumentSlot(IRackAccess a, int sc)
{
int mc = MacrosOnTarget(a, sc, -1);
- var footer = mc > 0 ? new TextBlock { Text = Loc.Plural(mc, "{0} macro", "{0} macros"), FontSize = 7, FontWeight = FontWeight.Medium, Foreground = IrTeal, VerticalAlignment = VerticalAlignment.Center }
+ var footer = mc > 0 ? new TextBlock { Text = Loc.Plural("device.rack.macros", mc), FontSize = 7, FontWeight = FontWeight.Medium, Foreground = IrTeal, VerticalAlignment = VerticalAlignment.Center }
: (Control)new TextBlock { Text = "Instr", FontSize = 7, FontWeight = FontWeight.Medium, Foreground = IrMuted, VerticalAlignment = VerticalAlignment.Center };
Border slot = null!;
slot = IrSlot(ChainHue(sc), string.IsNullOrEmpty(a.ChainInstrumentName(sc)) ? "Instrument" : a.ChainInstrumentName(sc),
@@ -139,7 +139,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
{
bool byp = a.ChainDeviceBypassed(sc, d);
int mc = MacrosOnTarget(a, sc, d);
- var footer = mc > 0 ? (Control)new TextBlock { Text = Loc.Plural(mc, "{0} macro", "{0} macros"), FontSize = 7, FontWeight = FontWeight.Medium, Foreground = IrTeal, VerticalAlignment = VerticalAlignment.Center }
+ var footer = mc > 0 ? (Control)new TextBlock { Text = Loc.Plural("device.rack.macros", mc), FontSize = 7, FontWeight = FontWeight.Medium, Foreground = IrTeal, VerticalAlignment = VerticalAlignment.Center }
: IrMsBtn("Byp", byp, NotaPalette.TextTertiary, () => { a.SetChainDeviceBypassed(sc, d, !byp); _ctx.RequestRebuild(); });
Border slot = null!;
slot = IrSlot(byp ? IrMuted : Success, a.ChainDeviceName(sc, d), a.ChainDeviceBuiltinKind(sc, d) < 0 ? "Plug" : "FX", byp, () => OpenChainDeviceGui(a, sc, d, slot), () => OpenChainDeviceParams(a, sc, d, slot), footer,
@@ -162,7 +162,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
void Hover() { dash.Stroke = NotaPalette.TextTertiary; plus.Foreground = IrTxt; lbl.Foreground = NotaPalette.TextSecondary; }
void Drop() { dash.IsVisible = true; dash.Stroke = IrTeal; dash.Fill = NotaPalette.Wash(NotaPalette.Teal, 0x22); plus.Foreground = IrTeal; lbl.Foreground = IrTeal; }
- ToolTip.SetTip(box, Loc.T("Add device — click for the list, or drop an effect here"));
+ ToolTip.SetTip(box, Loc.T("device.rack.add_device_click_for_the"));
box.PointerEntered += (_, _) => Hover();
box.PointerExited += (_, _) => Idle();
box.PointerPressed += (_, _) => ShowAddDeviceMenu(a, sc, box);
@@ -261,7 +261,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
// rather than drive another rack.
int at = Resolve();
if (id == 0 || at < 0 || a.ChainInstrumentKind(at) != 4)
- return new DeviceWindowPage(new TextBlock { Text = Loc.T("This Drum Rack is no longer in the rack."), Foreground = TextTertiary, Margin = new Thickness(12) }, 700, CardBodyH);
+ return new DeviceWindowPage(new TextBlock { Text = Loc.T("device.rack.this_drum_rack_is_no"), Foreground = TextTertiary, Margin = new Thickness(12) }, 700, CardBodyH);
tickReg(() => { if (Resolve() != at) win.Refill(); });
var refreshers = new List<Action>();
var ctx = new DeviceCardContext(proxy, T, tickReg, _ctx.NotifyChanged, (_, _, _, _) => { }, _ => { }, _ => { }, () => sel, v => sel = v,
@@ -284,7 +284,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
});
}
return new DeviceWindowPage(new Border { Width = 700, Height = CardBodyH, ClipToBounds = true, Child = body }, 700, CardBodyH, presets);
- }, status: () => pp.Chain < 0 ? "Removed" : Loc.F("{0} · {1} pads", ChainLocation(a, pp.Chain), E.RackDevChainCount(T, RackMacroMapping.NestedRackBase - pp.Chain))) { ContextTrackId = T };
+ }, status: () => pp.Chain < 0 ? "Removed" : Loc.F("device.rack.pads", ChainLocation(a, pp.Chain), E.RackDevChainCount(T, RackMacroMapping.NestedRackBase - pp.Chain))) { ContextTrackId = T };
win.ShowFrom(anchor);
}
@@ -299,14 +299,14 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
case InstrumentRackAccess:
string n = E.RackChainName(T, sc);
if (E.TrackInstrumentKind(T) == 4)
- return Loc.F("Drum Rack · pad {0}{1}", NoteName(a.ChainTriggerNote(sc)), n.Length > 0 ? " " + n : "");
- return Loc.F("Instrument Rack · chain {0}{1}", sc + 1, n.Length > 0 ? " " + n : "");
+ return Loc.F("device.rack.drum_rack_pad", NoteName(a.ChainTriggerNote(sc)), n.Length > 0 ? " " + n : "");
+ return Loc.F("device.rack.instrument_rack_chain", sc + 1, n.Length > 0 ? " " + n : "");
case EffectRackAccess:
- return Loc.F("Audio Effect Rack · chain {0}", sc + 1);
+ return Loc.F("device.rack.audio_effect_rack_chain", sc + 1);
case RhythmVoiceAccess:
- return Loc.F("Nota Rhythm · voice {0}", sc + 1);
+ return Loc.F("device.rack.nota_rhythm_voice", sc + 1);
default:
- return Loc.F("chain {0}", sc + 1);
+ return Loc.F("device.rack.chain_n", sc + 1);
}
}
@@ -316,13 +316,13 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
int v = proxy.InstrumentVoiceCount(T);
if (v < 0) return where;
string voices = strategy.VoiceLabel(proxy, T, v) ?? $"{Math.Max(0, v)}/16";
- return Loc.F("{0} · voices {1}", where, voices);
+ return Loc.F("device.rack.voices", where, voices);
}
private string DeviceStatus(IRackAccess a, int sc, int d)
{
int n = a.ChainDeviceCount(sc);
- return d < n ? Loc.F("{0} · effect {1} of {2}", ChainLocation(a, sc), d + 1, n) : ChainLocation(a, sc);
+ return d < n ? Loc.F("device.rack.effect_of", ChainLocation(a, sc), d + 1, n) : ChainLocation(a, sc);
}
// A chain effect's bypass for its window; a flip there rebuilds the rack card so the
@@ -519,7 +519,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
{
var win = new DeviceWindow(name, E.GetTrackName(T), "Params",
_ => new DeviceWindowPage(ParamGridContent(count, row), 476, double.NaN), bypass,
- () => Loc.F("{0} · {1}", status(), Loc.Plural(count, "{0} parameter", "{0} parameters"))) { ContextTrackId = T };
+ () => Loc.F("common.pattern_n", status(), Loc.Plural("device.rack.parameters", count))) { ContextTrackId = T };
win.ShowFrom(anchor);
}
@@ -587,7 +587,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
{
if (e.GetCurrentPoint(host).Properties.IsRightButtonPressed) { e.Handled = true; ShowMacroMenu(a, host, m); }
};
- ToolTip.SetTip(host, Loc.T("Drag to set · right-click to map"));
+ ToolTip.SetTip(host, Loc.T("device.rack.drag_to_set_right_click"));
return host;
}
@@ -608,7 +608,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
: a.ChainDeviceParamName(lastChain, lastDev, lastParam);
text = $"→ C{lastChain + 1} {pn}";
}
- else if (count > 1) text = Loc.Plural(count, "→ {0} param", "→ {0} params");
+ else if (count > 1) text = Loc.Plural("device.rack.params", count);
return new TextBlock { Text = text, FontSize = 8, Foreground = NotaPalette.TealBright, TextTrimming = TextTrimming.CharacterEllipsis };
}
@@ -617,11 +617,11 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
var f = new MenuFlyout();
f.Items.Add(MenuKit.Header(a.MacroName(m), null, $"Macro · {m + 1}"));
f.Items.Add(new Separator());
- var map = new MenuItem { Header = Loc.T("Map to parameter") };
+ var map = new MenuItem { Header = Loc.T("device.rack.map_to_parameter") };
int chains = a.ChainCount();
for (int c = 0; c < chains; c++)
{
- var chainItem = new MenuItem { Header = Loc.F("Chain {0}", c + 1) };
+ var chainItem = new MenuItem { Header = Loc.F("device.rack.chain", c + 1) };
if (a.HasInstrumentChains)
{
var instItem = new MenuItem { Header = a.ChainInstrumentName(c) };
@@ -655,7 +655,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
f.Items.Add(map);
if (a.Kind != RackKind.Instrument)
{
- var sel = new MenuItem { Header = Loc.T("Map to the selector") };
+ var sel = new MenuItem { Header = Loc.T("device.rack.map_to_the_selector") };
sel.Click += (_, _) => { RcAddMapping(m, 0, RackMacroMapping.RackControl, 0, 0f, 1f); _ctx.RequestRebuild(); };
f.Items.Add(sel);
}
@@ -665,7 +665,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
if (mapped > 0)
{
f.Items.Add(new Separator());
- f.Items.Add(MenuKit.Danger(Loc.Plural(mapped, "Clear {0} mapping", "Clear {0} mappings"), GlyphKind.Trash,
+ f.Items.Add(MenuKit.Danger(Loc.Plural("device.rack.clear_mappings", mapped), GlyphKind.Trash,
() => { ClearMacroMappings(a, m); _ctx.RequestRebuild(); }));
}
f.ShowAt(anchor, showAtPointer: true);
@@ -760,7 +760,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
CornerRadius = NotaRadius.Badge, Padding = new Thickness(4, 0), Cursor = new Cursor(StandardCursorType.Hand),
VerticalAlignment = VerticalAlignment.Center, Child = tb,
};
- ToolTip.SetTip(chip, mapped >= 0 ? Loc.F("Mapped to Macro {0} — click to change", mapped + 1) : Loc.T("Map to a macro"));
+ ToolTip.SetTip(chip, mapped >= 0 ? Loc.F("device.rack.mapped_to_macro_click_to", mapped + 1) : Loc.T("device.rack.map_to_a_macro"));
chip.PointerPressed += (_, e) =>
{
e.Handled = true;
@@ -774,7 +774,7 @@ internal sealed partial class RackCardView(DeviceCardContext ctx)
}
if (mapped >= 0)
{
- var un = new MenuItem { Header = Loc.T("Unmap") };
+ var un = new MenuItem { Header = Loc.T("device.rack.unmap") };
un.Click += (_, _) => { RemoveParamMapping(a, chain, dev, param); _ctx.RequestRebuild(); };
f.Items.Add(un);
}
diff --git a/src/managed/Nota.App/DeviceCards/Rack/RackKindProfile.cs b/src/managed/Nota.App/DeviceCards/Rack/RackKindProfile.cs
index e8f732d6..7f57119e 100644
--- a/src/managed/Nota.App/DeviceCards/Rack/RackKindProfile.cs
+++ b/src/managed/Nota.App/DeviceCards/Rack/RackKindProfile.cs
@@ -33,30 +33,30 @@ internal sealed record RackKindProfile(
RackKind.Instrument, "Zones", KeyZones: true, VelocityZones: true, SelectRanges: false,
Modes: [], OutputTab: "Rack out", ChainPan: true, ChainTranspose: false, VolumeIsVelocity: false,
LevelMeter: true, TakesInstrument: true, TakesAudioEffects: true, TakesMidiEffects: true,
- ChainsHint: Loc.T("Drop an instrument to add a layer."));
+ ChainsHint: Loc.T("device.rack.drop_an_instrument_to_add"));
public static readonly RackKindProfile AudioEffect = new(
RackKind.AudioEffect, "Select", KeyZones: false, VelocityZones: false, SelectRanges: true,
Modes:
[
- (Parallel, "Parallel", Loc.T("All chains get the input. Outputs are summed.")),
- (Serial, "Serial", Loc.T("Chain 1 feeds chain 2, top to bottom.")),
- (Select, "Select", Loc.T("Only chains whose range holds the selector play.")),
+ (Parallel, "Parallel", Loc.T("device.rack.all_chains_get_the_input")),
+ (Serial, "Serial", Loc.T("device.rack.chain_1_feeds_chain_2")),
+ (Select, "Select", Loc.T("device.rack.only_chains_whose_range_holds_2")),
],
OutputTab: "Rack out", ChainPan: true, ChainTranspose: false, VolumeIsVelocity: false,
LevelMeter: true, TakesInstrument: false, TakesAudioEffects: true, TakesMidiEffects: false,
- ChainsHint: Loc.T("Drop an effect to add a chain."));
+ ChainsHint: Loc.T("device.rack.drop_an_effect_to_add"));
public static readonly RackKindProfile MidiEffect = new(
RackKind.MidiEffect, "Zones", KeyZones: true, VelocityZones: true, SelectRanges: true,
Modes:
[
- (Parallel, "Parallel", Loc.T("Each note goes to every chain whose zone it hits. Outputs merge before the instrument.")),
- (Select, "Select", Loc.T("Only chains whose range holds the selector get notes.")),
+ (Parallel, "Parallel", Loc.T("device.rack.each_note_goes_to_every")),
+ (Select, "Select", Loc.T("device.rack.only_chains_whose_range_holds")),
],
OutputTab: "Output", ChainPan: false, ChainTranspose: true, VolumeIsVelocity: true,
LevelMeter: false, TakesInstrument: false, TakesAudioEffects: false, TakesMidiEffects: true,
- ChainsHint: Loc.T("Drop MIDI effects here. Output goes to the track instrument."));
+ ChainsHint: Loc.T("device.rack.drop_midi_effects_here_output"));
public static RackKindProfile For(RackKind kind) => kind switch
{
diff --git a/src/managed/Nota.App/DeviceCards/Sampler/SamplerViews.cs b/src/managed/Nota.App/DeviceCards/Sampler/SamplerViews.cs
index a9112be4..9e4084a1 100644
--- a/src/managed/Nota.App/DeviceCards/Sampler/SamplerViews.cs
+++ b/src/managed/Nota.App/DeviceCards/Sampler/SamplerViews.cs
@@ -270,7 +270,7 @@ internal sealed class SamplerKeysView : Control
ctx.DrawText(t, new Point(rect.X + (rect.Width - t.Width) / 2, rect.Bottom - t.Height - 2));
}
}
- string range = Loc.F("range {0} — {1} · root {2} · keytrack {3}", SamplerModel.NoteName(_lo), SamplerModel.NoteName(_lo + 48), SamplerModel.NoteName(_root), NotaNum.Pct(_track));
+ string range = Loc.F("device.sampler.range_root_keytrack", SamplerModel.NoteName(_lo), SamplerModel.NoteName(_lo + 48), SamplerModel.NoteName(_root), NotaNum.Pct(_track));
SamplerInk.Corner(ctx, r, NotaGraph.Corner.TopLeft, range, NotaPalette.TextTertiary);
SamplerInk.Corner(ctx, r, NotaGraph.Corner.TopRight, _hint, NotaPalette.TextAxis);
}
diff --git a/src/managed/Nota.App/DeviceCards/SidechainSourcePicker.cs b/src/managed/Nota.App/DeviceCards/SidechainSourcePicker.cs
index a8aefd20..95175778 100644
--- a/src/managed/Nota.App/DeviceCards/SidechainSourcePicker.cs
+++ b/src/managed/Nota.App/DeviceCards/SidechainSourcePicker.cs
@@ -74,7 +74,7 @@ internal sealed class SidechainSourcePicker
if (k == _get()) return;
if (_set(k.Source, k.Part) == -2)
{
- ToolTip.SetTip(Combo, Loc.T("No free routes — every sidechain route is in use"));
+ ToolTip.SetTip(Combo, Loc.T("device.sidechain.no_free_routes_every_sidechain"));
Sync();
return;
}
@@ -91,7 +91,7 @@ internal sealed class SidechainSourcePicker
if (k.Source < 0) return none;
string track = TrackNames.Of(engine, k.Source);
if (k.Part == SidechainKey.WholeTrack) return track;
- if (k.Part == SidechainKey.Missing) return Loc.F("{0} · missing", track);
+ if (k.Part == SidechainKey.Missing) return Loc.F("device.sidechain.missing", track);
string part = engine.TrackPartName(k.Source, k.Part);
return $"{track} · {(part.Length > 0 ? part : $"Part {k.Part + 1}")}";
}
@@ -155,7 +155,7 @@ internal sealed class SidechainSourcePicker
// A source is takeable when it already has a route, when it is the one this key holds
// (moving off it frees that route), or while any route is free.
bool Takeable(int src, int part) => !full || engine.SidechainRouteInUse(src, part) || cur == new SidechainKey(src, part);
- string NoRoute = Loc.T("No free routes — every sidechain route is in use");
+ string NoRoute = Loc.T("device.sidechain.no_free_routes_every_sidechain");
for (int i = 0; i < engine.TrackCount; i++)
{
if (!engine.TryGetTrackInfo(i, out var ti) || ti.Id == ownTrack) continue;
@@ -167,11 +167,11 @@ internal sealed class SidechainSourcePicker
{
string name = engine.TrackPartName(ti.Id, p);
bool ok = !frozen && Takeable(ti.Id, p);
- list.Add(new Entry(new SidechainKey(ti.Id, p), name.Length > 0 ? name : Loc.F("Part {0}", p + 1), true, ok,
- frozen ? Loc.T("Frozen — its parts don't play until the track is unfrozen") : ok ? null : NoRoute));
+ list.Add(new Entry(new SidechainKey(ti.Id, p), name.Length > 0 ? name : Loc.F("device.sidechain.part", p + 1), true, ok,
+ frozen ? Loc.T("device.sidechain.frozen_its_parts_dont_play") : ok ? null : NoRoute));
}
if (parts && cur.Source == ti.Id && cur.Part == SidechainKey.Missing)
- list.Add(new Entry(cur, "missing part", true, false, Loc.T("The keyed part was deleted — undo brings it back")));
+ list.Add(new Entry(cur, "missing part", true, false, Loc.T("device.sidechain.the_keyed_part_was_deleted")));
}
return list;
}
diff --git a/src/managed/Nota.App/DeviceChainView.Clipboard.cs b/src/managed/Nota.App/DeviceChainView.Clipboard.cs
index 2fa8147f..cfe1112e 100644
--- a/src/managed/Nota.App/DeviceChainView.Clipboard.cs
+++ b/src/managed/Nota.App/DeviceChainView.Clipboard.cs
@@ -167,7 +167,7 @@ public sealed partial class DeviceChainView
}
finally { _engine.EndUndoGroup(); }
ClearDeviceSelection();
- StatusMessage?.Invoke(Loc.F("Deleted {0} devices", n));
+ StatusMessage?.Invoke(Loc.F("device_chain.clipboard.deleted_devices", n));
Rebuild(); Changed?.Invoke();
}
@@ -197,7 +197,7 @@ public sealed partial class DeviceChainView
// Nothing removed unless the copy landed: a cut device must stay pasteable.
if (!TryCopySelectedDevice())
{
- if (HasDeviceSelection) StatusMessage?.Invoke(_sel.Count > 1 ? Loc.T("These devices can't be copied, so they weren't cut.") : Loc.T("This device can't be copied, so it wasn't cut."));
+ if (HasDeviceSelection) StatusMessage?.Invoke(_sel.Count > 1 ? Loc.T("device_chain.clipboard.these_devices_cant_be_copied") : Loc.T("device_chain.clipboard.this_device_cant_be_copied"));
return;
}
if (_sel.HasInstrument) TrackDeleteRequested?.Invoke(_trackId, true, _sel.Count);
@@ -246,7 +246,7 @@ public sealed partial class DeviceChainView
}
}
finally { _engine.EndUndoGroup(); }
- if (failed) StatusMessage?.Invoke(Loc.T("Some devices can't be duplicated"));
+ if (failed) StatusMessage?.Invoke(Loc.T("device_chain.clipboard.some_devices_cant_be_duplicated"));
if (copies.Count > 0) SelectDevices(copies);
Rebuild(); Changed?.Invoke();
}
@@ -299,8 +299,8 @@ public sealed partial class DeviceChainView
int mEnd = MidiCount, fEnd = FxCount;
int midiAt = PasteAt(DeviceSection.Midi), fxAt = PasteAt(DeviceSection.Audio);
int n = _engine.PasteDevices(_trackId, midiAt, fxAt, out int skipped);
- if (n < 0) { StatusMessage?.Invoke(n == -3 ? Loc.T("Couldn't paste: a device failed to load.") : Loc.T("Nothing to paste.")); return; }
- if (n == 0) { StatusMessage?.Invoke(Loc.T("This track can't take the copied devices.")); return; }
+ if (n < 0) { StatusMessage?.Invoke(n == -3 ? Loc.T("device_chain.clipboard.couldnt_paste_a_device_failed") : Loc.T("device_chain.clipboard.nothing_to_paste")); return; }
+ if (n == 0) { StatusMessage?.Invoke(Loc.T("device_chain.clipboard.this_track_cant_take_the")); return; }
int km = MidiCount - mEnd, kf = FxCount - fEnd;
int ma = midiAt < 0 ? mEnd : midiAt, fa = fxAt < 0 ? fEnd : fxAt;
if (km > 0) RemapExtras(ChainKind.Midi, i => i >= ma ? i + km : i);
@@ -312,7 +312,7 @@ public sealed partial class DeviceChainView
if (instrument) pasted.Add((ChainKind.Instrument, -1));
for (int i = 0; i < kf; i++) pasted.Add((ChainKind.Effect, fa + i));
SelectDevices(pasted);
- StatusMessage?.Invoke(skipped > 0 ? Loc.F("Pasted {0} devices, skipped {1} this track can't take", n, skipped) : Loc.F("Pasted {0} devices", n));
+ StatusMessage?.Invoke(skipped > 0 ? Loc.F("device_chain.clipboard.pasted_devices_skipped_this_track", n, skipped) : Loc.F("device_chain.clipboard.pasted_devices", n));
Rebuild(); Changed?.Invoke();
}
@@ -320,14 +320,14 @@ public sealed partial class DeviceChainView
// instrument card or nothing selected; with only effects selected it would read as "paste here".
private void PasteInstrument(DeviceClip c)
{
- if (HasDeviceSelection && !_sel.HasInstrument) { StatusMessage?.Invoke(Loc.T("Paste an instrument on an instrument card.")); return; }
+ if (HasDeviceSelection && !_sel.HasInstrument) { StatusMessage?.Invoke(Loc.T("device_chain.clipboard.paste_an_instrument_on_an")); return; }
int r = _engine.PasteInstrument(_trackId);
- if (r == -2) { StatusMessage?.Invoke(Loc.T("Only an instrument track takes an instrument.")); return; }
- if (r < 0) { StatusMessage?.Invoke(Loc.T("Couldn't paste the instrument.")); return; }
+ if (r == -2) { StatusMessage?.Invoke(Loc.T("device_chain.clipboard.only_an_instrument_track_takes_2")); return; }
+ if (r < 0) { StatusMessage?.Invoke(Loc.T("device_chain.clipboard.couldnt_paste_the_instrument")); return; }
ForgetInstrumentState(_trackId);
var ex = Extra(ChainKind.Instrument, -1); ex.Preset = c.Preset; ex.PresetId = c.PresetId;
SelectDevices(new[] { (ChainKind.Instrument, -1) });
- StatusMessage?.Invoke(Loc.F("Pasted {0}", _engine.DeviceName(_trackId, -1)));
+ StatusMessage?.Invoke(Loc.F("device_chain.clipboard.pasted", _engine.DeviceName(_trackId, -1)));
Rebuild(); Changed?.Invoke();
}
@@ -348,19 +348,19 @@ public sealed partial class DeviceChainView
private static string GroupRefusalText(int r) => (GroupRefusal)r switch
{
- GroupRefusal.NotContiguous => Loc.T("Select devices next to each other to group them"),
- GroupRefusal.RackInRun => Loc.T("A rack can't go inside another rack"),
- GroupRefusal.CantHost => Loc.T("A plug-in can't go in a MIDI Effect Rack"),
- GroupRefusal.InstrumentCantNest => Loc.T("An Instrument Rack can't go inside another Instrument Rack"),
- GroupRefusal.NotInstrumentTrack => Loc.T("Only an instrument track takes MIDI effects and an instrument"),
- _ => Loc.T("These devices can't be grouped"),
+ GroupRefusal.NotContiguous => Loc.T("device_chain.clipboard.select_devices_next_to_each"),
+ GroupRefusal.RackInRun => Loc.T("device_chain.clipboard.a_rack_cant_go_inside"),
+ GroupRefusal.CantHost => Loc.T("device_chain.clipboard.a_plug_in_cant_go"),
+ GroupRefusal.InstrumentCantNest => Loc.T("device_chain.clipboard.an_instrument_rack_cant_go"),
+ GroupRefusal.NotInstrumentTrack => Loc.T("device_chain.clipboard.only_an_instrument_track_takes"),
+ _ => Loc.T("device_chain.clipboard.these_devices_cant_be_grouped"),
};
private void GroupSelectedDevice()
{
- if (!HasDeviceSelection) { StatusMessage?.Invoke(Loc.T("Select devices to put them in a rack")); return; }
+ if (!HasDeviceSelection) { StatusMessage?.Invoke(Loc.T("device_chain.clipboard.select_devices_to_put_them")); return; }
var shape = SelectionShape;
- if (!shape.CanGroup) { StatusMessage?.Invoke(shape.Reason ?? Loc.T("These devices can't be grouped")); return; }
+ if (!shape.CanGroup) { StatusMessage?.Invoke(shape.Reason ?? Loc.T("device_chain.clipboard.these_devices_cant_be_grouped")); return; }
// The grouped devices' card state (A/B, preset label) rides on the rack's card until
// ungroup brings it back.
var wrapped = new List<CardExtra>();
@@ -402,7 +402,7 @@ public sealed partial class DeviceChainView
if (wrapped.Count == 1) rex.Wrapped = wrapped[0]; // ⌘Z / ⌘⇧Z swap the two (ExtraFor)
else if (wrapped.Count > 1) rex.WrappedMany = wrapped;
SelectDevices(new[] { (rackKind, rackIdx) });
- StatusMessage?.Invoke(n == 1 && first.Length > 0 ? Loc.F("Put {0} in {1}", first, rackName) : Loc.F("Put {0} devices in {1}", n, rackName));
+ StatusMessage?.Invoke(n == 1 && first.Length > 0 ? Loc.F("device_chain.clipboard.put_in", first, rackName) : Loc.F("device_chain.clipboard.put_devices_in", n, rackName));
Rebuild(); Changed?.Invoke();
}
@@ -411,8 +411,8 @@ public sealed partial class DeviceChainView
private void UngroupSelectedDevice()
{
- if (SingleSelection is not { } s || RackChains(s) == 0) { StatusMessage?.Invoke(Loc.T("Select a rack to take its devices out")); return; }
- if (RackChains(s) != 1) { StatusMessage?.Invoke(Loc.T("Only a rack with one chain can be ungrouped")); return; }
+ if (SingleSelection is not { } s || RackChains(s) == 0) { StatusMessage?.Invoke(Loc.T("device_chain.clipboard.select_a_rack_to_take")); return; }
+ if (RackChains(s) != 1) { StatusMessage?.Invoke(Loc.T("device_chain.clipboard.only_a_rack_with_one")); return; }
var k = KindOf(s.Section);
TrackExtras().TryGetValue(ExtraKey(k, s.Index), out var rex);
int mBefore = MidiCount, fBefore = FxCount;
@@ -421,10 +421,10 @@ public sealed partial class DeviceChainView
{
StatusMessage?.Invoke((UngroupRefusal)n switch
{
- UngroupRefusal.SeveralChains => Loc.T("Only a rack with one chain can be ungrouped"),
- UngroupRefusal.DrumRack => Loc.T("A Drum Rack can't be ungrouped"),
- UngroupRefusal.NoInstrument => Loc.T("The rack's chain has no instrument to put back"),
- _ => Loc.T("This rack can't be ungrouped"),
+ UngroupRefusal.SeveralChains => Loc.T("device_chain.clipboard.only_a_rack_with_one"),
+ UngroupRefusal.DrumRack => Loc.T("device_chain.clipboard.a_drum_rack_cant_be"),
+ UngroupRefusal.NoInstrument => Loc.T("device_chain.clipboard.the_racks_chain_has_no"),
+ _ => Loc.T("device_chain.clipboard.this_rack_cant_be_ungrouped"),
});
return;
}
@@ -457,8 +457,8 @@ public sealed partial class DeviceChainView
TrackExtras()[ExtraKey(rk, ri)] = hit;
}
SelectDevices(restored);
- string msg = n == 1 ? Loc.T("Took the device out of the rack") : Loc.F("Took {0} devices out of the rack", n);
- if (dropped != UngroupDropped.None) msg += Loc.T(" — its macros and chain settings were dropped");
+ string msg = n == 1 ? Loc.T("device_chain.clipboard.took_the_device_out_of") : Loc.F("device_chain.clipboard.took_devices_out_of_the", n);
+ if (dropped != UngroupDropped.None) msg += Loc.T("device_chain.clipboard.its_macros_and_chain_settings");
StatusMessage?.Invoke(msg);
Rebuild(); Changed?.Invoke();
}
@@ -504,11 +504,11 @@ public sealed partial class DeviceChainView
};
string badge = kind switch
{
- ChainKind.Instrument => Loc.T("Instrument"),
- ChainKind.Midi => Loc.F("MIDI effect · {0}", di + 1),
- _ => Loc.F("Audio effect · {0}", di + 1),
+ ChainKind.Instrument => Loc.T("common.instrument"),
+ ChainKind.Midi => Loc.F("device_chain.clipboard.midi_effect", di + 1),
+ _ => Loc.F("device_chain.clipboard.audio_effect", di + 1),
};
- flyout.Items.Add(MenuKit.Header(name.Length > 0 ? name : Loc.T("Device"), null, badge));
+ flyout.Items.Add(MenuKit.Header(name.Length > 0 ? name : Loc.T("device_chain.clipboard.device"), null, badge));
flyout.Items.Add(new Separator());
header?.Invoke(flyout); // ends with its own separator
if (kind == ChainKind.Instrument)
@@ -517,32 +517,32 @@ public sealed partial class DeviceChainView
// its track away — an instrument track never stands without one.
MenuKit.AddGroups(flyout.Items,
new Control[] { ReplaceInstrumentMenu() },
- new Control[] { MenuKit.Item(Loc.T("Save preset"), GlyphKind.Save, () => PresetSaveRequested?.Invoke(-1)) },
+ new Control[] { MenuKit.Item(Loc.T("common.save_preset"), GlyphKind.Save, () => PresetSaveRequested?.Invoke(-1)) },
new Control[]
{
- MenuKit.Item(Loc.T("Copy"), GlyphKind.Copy, CopySelectedDevice, MenuKit.CopyKey),
- MenuKit.Item(Loc.T("Cut"), GlyphKind.Cut, CutSelectedDevice, MenuKit.CutKey),
- MenuKit.Item(Loc.T("Paste"), GlyphKind.Paste, PasteDevice, MenuKit.PasteKey, _engine.DeviceClipboardKind() == 3),
+ MenuKit.Item(Loc.T("common.copy"), GlyphKind.Copy, CopySelectedDevice, MenuKit.CopyKey),
+ MenuKit.Item(Loc.T("common.cut"), GlyphKind.Cut, CutSelectedDevice, MenuKit.CutKey),
+ MenuKit.Item(Loc.T("common.paste"), GlyphKind.Paste, PasteDevice, MenuKit.PasteKey, _engine.DeviceClipboardKind() == 3),
},
MoveToTrackGroup(kind, di),
new Control[] { GroupItem() },
- new Control[] { MenuKit.Danger(Loc.T("Delete track"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey) });
+ new Control[] { MenuKit.Danger(Loc.T("device_chain.clipboard.delete_track"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey) });
flyout.ShowAt(anchor, showAtPointer: true);
return;
}
bool selectable = SelectableKind(kind);
MenuKit.AddGroups(flyout.Items,
- new Control[] { MenuKit.Item(Loc.T("Save preset"), GlyphKind.Save, () => PresetSaveRequested?.Invoke(kind == ChainKind.Midi ? PresetService.MidiEffectBase - di : di)) },
+ new Control[] { MenuKit.Item(Loc.T("common.save_preset"), GlyphKind.Save, () => PresetSaveRequested?.Invoke(kind == ChainKind.Midi ? PresetService.MidiEffectBase - di : di)) },
new Control[]
{
- MenuKit.Item(Loc.T("Copy"), GlyphKind.Copy, CopySelectedDevice, MenuKit.CopyKey, selectable),
- MenuKit.Item(Loc.T("Cut"), GlyphKind.Cut, CutSelectedDevice, MenuKit.CutKey, selectable),
- MenuKit.Item(Loc.T("Paste"), GlyphKind.Paste, PasteDevice, MenuKit.PasteKey, CanPaste),
- MenuKit.Item(Loc.T("Duplicate"), GlyphKind.Duplicate, DuplicateSelectedDevice, MenuKit.DuplicateKey, selectable),
+ MenuKit.Item(Loc.T("common.copy"), GlyphKind.Copy, CopySelectedDevice, MenuKit.CopyKey, selectable),
+ MenuKit.Item(Loc.T("common.cut"), GlyphKind.Cut, CutSelectedDevice, MenuKit.CutKey, selectable),
+ MenuKit.Item(Loc.T("common.paste"), GlyphKind.Paste, PasteDevice, MenuKit.PasteKey, CanPaste),
+ MenuKit.Item(Loc.T("common.duplicate"), GlyphKind.Duplicate, DuplicateSelectedDevice, MenuKit.DuplicateKey, selectable),
},
MoveToTrackGroup(kind, di),
new Control[] { GroupItem() },
- new Control[] { MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey, selectable) });
+ new Control[] { MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey, selectable) });
flyout.ShowAt(anchor, showAtPointer: true);
}
@@ -550,8 +550,8 @@ public sealed partial class DeviceChainView
private Control GroupItem()
{
if (SingleSelection is { } s && RackChains(s) > 0)
- return MenuKit.Item(Loc.T("Ungroup rack"), GlyphKind.Ungroup, UngroupSelectedDevice, MenuKit.UngroupKey, RackChains(s) == 1);
- return MenuKit.Item(Loc.T("Group into rack"), GlyphKind.Folder, GroupSelectedDevice, MenuKit.GroupKey, SelectionShape.CanGroup);
+ return MenuKit.Item(Loc.T("device_chain.clipboard.ungroup_rack"), GlyphKind.Ungroup, UngroupSelectedDevice, MenuKit.UngroupKey, RackChains(s) == 1);
+ return MenuKit.Item(Loc.T("device_chain.clipboard.group_into_rack"), GlyphKind.Folder, GroupSelectedDevice, MenuKit.GroupKey, SelectionShape.CanGroup);
}
// The menu of several selected devices (specs/044): what it does, it does to all of them.
@@ -559,23 +559,23 @@ public sealed partial class DeviceChainView
{
var flyout = new MenuFlyout();
int n = _sel.Count;
- flyout.Items.Add(MenuKit.Header(Loc.Plural(n, "{0} device", "{0} devices"), null, _sel.HasInstrument ? Loc.T("With the instrument") : Loc.T("Selected")));
+ flyout.Items.Add(MenuKit.Header(Loc.Plural("device_chain.clipboard.devices", n), null, _sel.HasInstrument ? Loc.T("device_chain.clipboard.with_the_instrument") : Loc.T("device_chain.clipboard.selected")));
flyout.Items.Add(new Separator());
MenuKit.AddGroups(flyout.Items,
new Control[]
{
- MenuKit.Item(Loc.T("Copy"), GlyphKind.Copy, CopySelectedDevice, MenuKit.CopyKey),
- MenuKit.Item(Loc.T("Cut"), GlyphKind.Cut, CutSelectedDevice, MenuKit.CutKey),
- MenuKit.Item(Loc.T("Paste"), GlyphKind.Paste, PasteDevice, MenuKit.PasteKey, CanPaste),
- MenuKit.Item(Loc.T("Duplicate"), GlyphKind.Duplicate, DuplicateSelectedDevice, MenuKit.DuplicateKey, HasEffectSelection),
+ MenuKit.Item(Loc.T("common.copy"), GlyphKind.Copy, CopySelectedDevice, MenuKit.CopyKey),
+ MenuKit.Item(Loc.T("common.cut"), GlyphKind.Cut, CutSelectedDevice, MenuKit.CutKey),
+ MenuKit.Item(Loc.T("common.paste"), GlyphKind.Paste, PasteDevice, MenuKit.PasteKey, CanPaste),
+ MenuKit.Item(Loc.T("common.duplicate"), GlyphKind.Duplicate, DuplicateSelectedDevice, MenuKit.DuplicateKey, HasEffectSelection),
},
MoveSelectionToTrackGroup(),
new Control[] { GroupItem() },
new Control[]
{
_sel.HasInstrument
- ? MenuKit.Danger(Loc.T("Delete track"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey)
- : MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey),
+ ? MenuKit.Danger(Loc.T("device_chain.clipboard.delete_track"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey)
+ : MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, DeleteSelectedDevice, MenuKit.DeleteKey),
});
flyout.ShowAt(anchor, showAtPointer: true);
}
diff --git a/src/managed/Nota.App/DeviceChainView.Fold.cs b/src/managed/Nota.App/DeviceChainView.Fold.cs
index 11760b7e..53908bda 100644
--- a/src/managed/Nota.App/DeviceChainView.Fold.cs
+++ b/src/managed/Nota.App/DeviceChainView.Fold.cs
@@ -47,7 +47,7 @@ public sealed partial class DeviceChainView
if (bypassable)
{
var bypass = new SwitchTrack { IsOn = !bypassed, Cursor = new Cursor(StandardCursorType.Hand) };
- ToolTip.SetTip(bypass, bypassed ? Loc.T("Bypassed — click to enable") : Loc.T("Active — click to bypass"));
+ ToolTip.SetTip(bypass, bypassed ? Loc.T("device_chain.bypassed_click_to_enable") : Loc.T("device_chain.active_click_to_bypass"));
bypass.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(bypass).Properties.IsLeftButtonPressed) return;
@@ -72,7 +72,7 @@ public sealed partial class DeviceChainView
};
DockPanel.SetDock(power, Dock.Top);
// The Remove control (#110) at the strip's foot; on the instrument it takes the track.
- var remove = RemoveButton(k == ChainKind.Instrument ? Loc.T("Remove track") : Loc.T("Remove device"), () => RemoveDeviceAt(k, di));
+ var remove = RemoveButton(k == ChainKind.Instrument ? Loc.T("device_chain.remove_track") : Loc.T("device_chain.remove_device"), () => RemoveDeviceAt(k, di));
DockPanel.SetDock(remove, Dock.Bottom);
var strip = new Border
{
@@ -83,7 +83,7 @@ public sealed partial class DeviceChainView
Cursor = movable ? new Cursor(StandardCursorType.SizeAll) : null,
};
strip.BindResource(Border.BoxShadowProperty, "Shadow.Raised");
- ToolTip.SetTip(strip, Loc.F("{0} — double-click to unfold", name));
+ ToolTip.SetTip(strip, Loc.F("device_chain.fold.double_click_to_unfold", name));
const double RingGap = 3; // the same focus ring as the full card (BuildCardShell)
var selRing = new Border
@@ -97,7 +97,7 @@ public sealed partial class DeviceChainView
void Menu(MenuFlyout flyout)
{
- flyout.Items.Add(MenuKit.Item(Loc.T("Unfold"), null, () => SetFolded(k, di, false)));
+ flyout.Items.Add(MenuKit.Item(Loc.T("device_chain.fold.unfold"), null, () => SetFolded(k, di, false)));
flyout.Items.Add(new Separator());
}
strip.PointerPressed += (_, e) =>
diff --git a/src/managed/Nota.App/DeviceChainView.Instruments.cs b/src/managed/Nota.App/DeviceChainView.Instruments.cs
index d4612916..854ad654 100644
--- a/src/managed/Nota.App/DeviceChainView.Instruments.cs
+++ b/src/managed/Nota.App/DeviceChainView.Instruments.cs
@@ -87,7 +87,7 @@ public sealed partial class DeviceChainView
{
if (id == "program:") return "";
if (id.StartsWith("factory:", StringComparison.Ordinal)) return factory.ApplyInPlace(engine, id["factory:".Length..], t, -1);
- return packs?.ApplyInPlace(engine, id, t) ?? Loc.T("Presets are unavailable.");
+ return packs?.ApplyInPlace(engine, id, t) ?? Loc.T("device_chain.instruments.presets_are_unavailable");
}, Init: () => factory.ResetInPlace(engine, t, -1, false)); // every param to default, no program (#165)
}
@@ -97,7 +97,7 @@ public sealed partial class DeviceChainView
var view = _instrumentRackView = new RackCardView(NewCardContext());
var body = view.BuildInstrumentRackBody(out int chains);
var spec = new ShellSpec(
- Name: _engine.DeviceName(_trackId, -1), Subtitle: Loc.Plural(chains, "Rack · {0} chain", "Rack · {0} chains"), DeviceIndex: -1, Count: 1,
+ Name: _engine.DeviceName(_trackId, -1), Subtitle: Loc.Plural("device_chain.rack_chains", chains), DeviceIndex: -1, Count: 1,
Bypassed: _engine.DeviceBypassed(_trackId, -1), Bypassable: true, CanMove: false, CanDelete: true,
PresetKind: 3, IsInstrument: true, Width: 700, Kind: ChainKind.Instrument);
return BuildCardShell(spec, body);
@@ -110,7 +110,7 @@ public sealed partial class DeviceChainView
var body = new RackCardView(NewCardContext()).BuildDrumRackBody(out int pads);
var kits = KitPresets();
var spec = new ShellSpec(
- Name: _engine.DeviceName(_trackId, -1), Subtitle: Loc.Plural(pads, "Drums · {0} pad", "Drums · {0} pads"), DeviceIndex: -1, Count: 1,
+ Name: _engine.DeviceName(_trackId, -1), Subtitle: Loc.Plural("device_chain.instruments.drums_pads", pads), DeviceIndex: -1, Count: 1,
Bypassed: _engine.DeviceBypassed(_trackId, -1), Bypassable: true, CanMove: false, CanDelete: true,
PresetKind: 4, IsInstrument: true, Width: 700, Kind: ChainKind.Instrument, Presets: kits);
return BuildCardShell(spec, body);
diff --git a/src/managed/Nota.App/DeviceChainView.Midi.cs b/src/managed/Nota.App/DeviceChainView.Midi.cs
index 4ba302fe..e4ab4eb2 100644
--- a/src/managed/Nota.App/DeviceChainView.Midi.cs
+++ b/src/managed/Nota.App/DeviceChainView.Midi.cs
@@ -26,7 +26,7 @@ public sealed partial class DeviceChainView
{
int chains = _engine.MidiRackChainCount(_trackId, index);
var rackSpec = new ShellSpec(
- Name: name, Subtitle: Loc.Plural(chains, "Rack · {0} chain", "Rack · {0} chains"), DeviceIndex: index, Count: count, Bypassed: bypassed, Bypassable: true,
+ Name: name, Subtitle: Loc.Plural("device_chain.rack_chains", chains), DeviceIndex: index, Count: count, Bypassed: bypassed, Bypassable: true,
CanMove: true, CanDelete: true, PresetKind: kind, IsInstrument: false, Width: 700, Kind: ChainKind.Midi);
return BuildCardShell(rackSpec, new RackCardView(NewCardContext()).BuildMidiRackBody(index));
}
diff --git a/src/managed/Nota.App/DeviceChainView.Move.cs b/src/managed/Nota.App/DeviceChainView.Move.cs
index 75201ea1..99ca0160 100644
--- a/src/managed/Nota.App/DeviceChainView.Move.cs
+++ b/src/managed/Nota.App/DeviceChainView.Move.cs
@@ -20,7 +20,7 @@ public sealed partial class DeviceChainView
// plug-in instruments. Picking one hands it to the host, which swaps it in place.
private MenuItem ReplaceInstrumentMenu()
{
- var menu = MenuKit.Item(Loc.T("Replace…"), GlyphKind.Device);
+ var menu = MenuKit.Item(Loc.T("device_chain.move.replace"), GlyphKind.Device);
void Add(ItemsControl into, BrowserItem item, GlyphKind glyph)
=> into.Items.Add(MenuKit.Item(item.Name, glyph, () => InstrumentReplaceRequested?.Invoke(item)));
@@ -35,7 +35,7 @@ public sealed partial class DeviceChainView
if (plugins.Count > 0)
{
menu.Items.Add(new Separator());
- var sub = MenuKit.Item(Loc.T("Plug-ins"), GlyphKind.Plug);
+ var sub = MenuKit.Item(Loc.T("device_chain.move.plug_ins"), GlyphKind.Plug);
foreach (var p in plugins) Add(sub, p, GlyphKind.Plug);
menu.Items.Add(sub);
}
@@ -110,7 +110,7 @@ public sealed partial class DeviceChainView
// instrument tracks. The host does the move (one undo step) and asks before a track goes.
private IEnumerable<Control> MoveToTrackGroup(ChainKind kind, int di)
{
- var menu = MenuKit.Item(Loc.T("Move to track"), GlyphKind.Track);
+ var menu = MenuKit.Item(Loc.T("device_chain.move.move_to_track"), GlyphKind.Track);
foreach (var (id, name) in TracksThatTake(_engine, kind, _trackId))
menu.Items.Add(MenuKit.Item(name, null, () => MoveRequested?.Invoke(new DeviceMoveRequest(_trackId, FamilyOf(kind), di, id, false))));
menu.IsEnabled = menu.Items.Count > 0;
@@ -121,7 +121,7 @@ public sealed partial class DeviceChainView
// The host moves them in one undo step, the instrument last (it takes the source track).
private IEnumerable<Control> MoveSelectionToTrackGroup()
{
- var menu = MenuKit.Item(Loc.T("Move to track"), GlyphKind.Track);
+ var menu = MenuKit.Item(Loc.T("device_chain.move.move_to_track"), GlyphKind.Track);
var kind = _sel.HasInstrument || _sel.Indices(DeviceSection.Midi).Any() ? ChainKind.Midi : ChainKind.Effect;
foreach (var (id, name) in TracksThatTake(_engine, kind, _trackId))
menu.Items.Add(MenuKit.Item(name, null, () =>
@@ -148,7 +148,7 @@ public sealed partial class DeviceChainView
if (kind != ChainKind.Effect && !(ti.IsInstrument)) continue;
list.Add((ti.Id, TrackNames.Of(engine, ti))); // as the Arrangement names it
}
- if (kind == ChainKind.Effect && engine.MasterTrackId != exceptTrackId) list.Add((engine.MasterTrackId, Loc.T("Master")));
+ if (kind == ChainKind.Effect && engine.MasterTrackId != exceptTrackId) list.Add((engine.MasterTrackId, Loc.T("common.master")));
return list;
}
diff --git a/src/managed/Nota.App/DeviceChainView.Shell.cs b/src/managed/Nota.App/DeviceChainView.Shell.cs
index e43e9b4f..af2bbe7b 100644
--- a/src/managed/Nota.App/DeviceChainView.Shell.cs
+++ b/src/managed/Nota.App/DeviceChainView.Shell.cs
@@ -212,7 +212,7 @@ public sealed partial class DeviceChainView
{
int v = _engine.InstrumentVoiceCount(_trackId);
string voices = s.VoiceLabel?.Invoke(_engine, _trackId, v)
- ?? (_engine.PluginParamGet(_trackId, -1, IndexOfId("mono")) > 0.5f ? Loc.T("Mono") : $"{Math.Max(0, v)}/16");
+ ?? (_engine.PluginParamGet(_trackId, -1, IndexOfId("mono")) > 0.5f ? Loc.T("device_chain.shell.mono") : $"{Math.Max(0, v)}/16");
badge.Text = type.Length > 0 ? $"{type} · {voices}" : voices;
});
}
@@ -226,8 +226,8 @@ public sealed partial class DeviceChainView
{
var bypass = new SwitchTrack { IsOn = !s.Bypassed, Cursor = new Cursor(StandardCursorType.Hand) };
ToolTip.SetTip(bypass, s.IsInstrument
- ? (s.Bypassed ? Loc.T("Off — click to turn the instrument on") : Loc.T("On — click to turn the instrument off"))
- : (s.Bypassed ? Loc.T("Bypassed — click to enable") : Loc.T("Active — click to bypass")));
+ ? (s.Bypassed ? Loc.T("device_chain.shell.off_click_to_turn_the") : Loc.T("device_chain.shell.on_click_to_turn_the"))
+ : (s.Bypassed ? Loc.T("device_chain.bypassed_click_to_enable") : Loc.T("device_chain.active_click_to_bypass")));
bypass.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(bypass).Properties.IsLeftButtonPressed) return;
@@ -250,7 +250,7 @@ public sealed partial class DeviceChainView
if (!s.Utility && s.CanDelete)
{
right.ColumnDefinitions.Add(new ColumnDefinition(GridLength.Auto));
- var remove = RemoveButton(s.IsInstrument ? Loc.T("Remove track") : Loc.T("Remove device"), () => RemoveDeviceAt(s.Kind, di));
+ var remove = RemoveButton(s.IsInstrument ? Loc.T("device_chain.remove_track") : Loc.T("device_chain.remove_device"), () => RemoveDeviceAt(s.Kind, di));
remove.Margin = new Thickness(-4, 0, -6, 0); // tucked against the card's right inset
Grid.SetColumn(remove, 2); right.Children.Add(remove);
}
@@ -270,8 +270,8 @@ public sealed partial class DeviceChainView
Cursor = s.CanMove && SelectableKind(s.Kind) ? new Cursor(StandardCursorType.SizeAll) : null,
};
headerBar.BindResource(Border.BoxShadowProperty, "Shadow.Raised"); // the raised strip's top bevel
- if (!s.Utility) ToolTip.SetTip(headerBar, s.CanMove ? Loc.T("Drag to reorder · double-click to fold · right-click for A/B, move and delete")
- : s.IsInstrument ? Loc.T("Click to select · double-click to fold · right-click to replace, copy or move") : Loc.T("Double-click to fold · right-click for more"));
+ if (!s.Utility) ToolTip.SetTip(headerBar, s.CanMove ? Loc.T("device_chain.shell.drag_to_reorder_double_click")
+ : s.IsInstrument ? Loc.T("device_chain.shell.click_to_select_double_click") : Loc.T("device_chain.shell.double_click_to_fold_right"));
// Factory presets for this device (or the card's own list), and applying one in place.
List<(string Id, string Name)> presets;
@@ -398,13 +398,13 @@ public sealed partial class DeviceChainView
{
if (presets.Count > 0)
{
- var menu = new MenuItem { Header = Loc.F("Preset: {0}", string.IsNullOrEmpty(extra.Preset) ? Loc.T("Init") : extra.Preset), Icon = MenuKit.Icon(GlyphKind.List) };
- var prev = new MenuItem { Header = Loc.T("Previous preset"), Icon = MenuKit.Icon(GlyphKind.ChevronLeft) }; prev.Click += (_, _) => StepPreset(-1);
- var next = new MenuItem { Header = Loc.T("Next preset"), Icon = MenuKit.Icon(GlyphKind.ChevronRight) }; next.Click += (_, _) => StepPreset(+1);
+ var menu = new MenuItem { Header = Loc.F("device_chain.shell.preset", string.IsNullOrEmpty(extra.Preset) ? Loc.T("device_chain.shell.init") : extra.Preset), Icon = MenuKit.Icon(GlyphKind.List) };
+ var prev = new MenuItem { Header = Loc.T("device_chain.shell.previous_preset"), Icon = MenuKit.Icon(GlyphKind.ChevronLeft) }; prev.Click += (_, _) => StepPreset(-1);
+ var next = new MenuItem { Header = Loc.T("device_chain.shell.next_preset"), Icon = MenuKit.Icon(GlyphKind.ChevronRight) }; next.Click += (_, _) => StepPreset(+1);
menu.Items.Add(prev); menu.Items.Add(next); menu.Items.Add(new Separator());
if (resetToInit != null)
{
- var init = new MenuItem { Header = Loc.T("Init"), ToggleType = MenuItemToggleType.Radio, IsChecked = atInit };
+ var init = new MenuItem { Header = Loc.T("device_chain.shell.init"), ToggleType = MenuItemToggleType.Radio, IsChecked = atInit };
init.Click += (_, _) => ApplyInit();
menu.Items.Add(init); menu.Items.Add(new Separator());
}
@@ -420,7 +420,7 @@ public sealed partial class DeviceChainView
// A / B compare of two full-parameter snapshots.
float[] Capture() => CaptureParams(s.Kind, di);
if (extra.A == null) { extra.A = Capture(); extra.B = (float[])extra.A.Clone(); extra.Active = 0; }
- var ab = new MenuItem { Header = Loc.F("Compare: {0}", extra.Active == 0 ? "A" : "B"), Icon = MenuKit.Icon(GlyphKind.Compare) };
+ var ab = new MenuItem { Header = Loc.F("device_chain.shell.compare", extra.Active == 0 ? "A" : "B"), Icon = MenuKit.Icon(GlyphKind.Compare) };
void Switch(int slot)
{
if (slot == extra.Active) return;
@@ -431,18 +431,18 @@ public sealed partial class DeviceChainView
}
var toA = new MenuItem { Header = "A", ToggleType = MenuItemToggleType.Radio, IsChecked = extra.Active == 0 }; toA.Click += (_, _) => Switch(0);
var toB = new MenuItem { Header = "B", ToggleType = MenuItemToggleType.Radio, IsChecked = extra.Active == 1 }; toB.Click += (_, _) => Switch(1);
- var copy = new MenuItem { Header = extra.Active == 0 ? Loc.T("Copy A to B") : Loc.T("Copy B to A"), Icon = MenuKit.Icon(GlyphKind.Copy) };
+ var copy = new MenuItem { Header = extra.Active == 0 ? Loc.T("device_chain.shell.copy_a_to_b") : Loc.T("device_chain.shell.copy_b_to_a"), Icon = MenuKit.Icon(GlyphKind.Copy) };
copy.Click += (_, _) => { var c = Capture(); if (extra.Active == 0) extra.B = (float[])c.Clone(); else extra.A = (float[])c.Clone(); };
ab.Items.Add(toA); ab.Items.Add(toB); ab.Items.Add(new Separator()); ab.Items.Add(copy);
flyout.Items.Add(ab);
if (s.CanMove)
{
- var left = new MenuItem { Header = Loc.T("Move left"), IsEnabled = di > 0, Icon = MenuKit.Icon(GlyphKind.StepLeft) }; left.Click += (_, _) => Move(di - 1);
- var rightMi = new MenuItem { Header = Loc.T("Move right"), IsEnabled = di < s.Count - 1, Icon = MenuKit.Icon(GlyphKind.StepRight) }; rightMi.Click += (_, _) => Move(di + 1);
+ var left = new MenuItem { Header = Loc.T("device_chain.shell.move_left"), IsEnabled = di > 0, Icon = MenuKit.Icon(GlyphKind.StepLeft) }; left.Click += (_, _) => Move(di - 1);
+ var rightMi = new MenuItem { Header = Loc.T("device_chain.shell.move_right"), IsEnabled = di < s.Count - 1, Icon = MenuKit.Icon(GlyphKind.StepRight) }; rightMi.Click += (_, _) => Move(di + 1);
flyout.Items.Add(left); flyout.Items.Add(rightMi);
}
// This device's page in the user manual (a plug-in gets the plug-ins page).
- var docs = new MenuItem { Header = Loc.T("Documentation") };
+ var docs = new MenuItem { Header = Loc.T("common.documentation") };
docs.Click += (_, _) =>
{
int kind = s.Kind switch
@@ -454,7 +454,7 @@ public sealed partial class DeviceChainView
NotaDocs.Open(headerBar, NotaDocs.DevicePage(s.Kind, kind));
};
flyout.Items.Add(docs);
- var fold = new MenuItem { Header = Loc.T("Fold") }; // the header's double-click, findable
+ var fold = new MenuItem { Header = Loc.T("device_chain.shell.fold") }; // the header's double-click, findable
fold.Click += (_, _) => SetFolded(s.Kind, di, true);
flyout.Items.Add(fold);
flyout.Items.Add(new Separator());
diff --git a/src/managed/Nota.App/DeviceChainView.cs b/src/managed/Nota.App/DeviceChainView.cs
index 72e64508..c1cca5f4 100644
--- a/src/managed/Nota.App/DeviceChainView.cs
+++ b/src/managed/Nota.App/DeviceChainView.cs
@@ -207,7 +207,7 @@ public sealed partial class DeviceChainView : UserControl
_instLiveViz = null; _instFaders.Clear(); // rebuilt only when a built-in instrument card is shown
_deviceLiveRefreshers.Clear(); // compressor GR meter/curve
_rackParamRefreshers.Clear(); // rack chain param faders (macro live-follow)
- if (_trackId <= 0) { _row.Children.Add(Hint(Loc.T("Select a track"))); return; }
+ if (_trackId <= 0) { _row.Children.Add(Hint(Loc.T("device_chain.select_a_track"))); return; }
// MIDI effects sit before the instrument (they shape the note stream).
int midiCount = _engine.TrackMidiEffectCount(_trackId);
@@ -243,7 +243,7 @@ public sealed partial class DeviceChainView : UserControl
{ // that would overflow its fixed width and skew hit-testing).
body = new RackCardView(NewCardContext()).BuildEffectRackBody(index); width = 700; fullBleed = true;
int chains = _engine.RackDevChainCount(_trackId, index);
- tag = Loc.Plural(chains, "Rack · {0} chain", "Rack · {0} chains");
+ tag = Loc.Plural("device_chain.rack_chains", chains);
}
else
{
@@ -305,12 +305,12 @@ public sealed partial class DeviceChainView : UserControl
float v = _engine.GetTrackSend(_trackId, b);
if (Math.Abs(v - knob.Value) > 1e-3) { knob.Value = v; value.Text = Pct(v); }
});
- knobs.Children.Add(KnobCell(Loc.F("Send {0}", letter), knob, value));
+ knobs.Children.Add(KnobCell(Loc.F("common.send", letter), knob, value));
shown++;
}
- Control body = shown > 0 ? knobs : new TextBlock { Text = Loc.T("No return tracks"), FontSize = 9, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
+ Control body = shown > 0 ? knobs : new TextBlock { Text = Loc.T("device_chain.no_return_tracks"), FontSize = 9, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
var spec = new ShellSpec(
- Name: Loc.T("Sends"), Subtitle: "", DeviceIndex: -2, Count: 0, Bypassed: false, Bypassable: false,
+ Name: Loc.T("common.sends"), Subtitle: "", DeviceIndex: -2, Count: 0, Bypassed: false, Bypassable: false,
CanMove: false, CanDelete: false, PresetKind: -1, IsInstrument: false, Width: shown > 2 ? 200 : 140,
Kind: ChainKind.Effect, Compact: true, Utility: true);
return BuildCardShell(spec, new Border { Padding = new Thickness(10), Child = body });
@@ -344,7 +344,7 @@ public sealed partial class DeviceChainView : UserControl
AddDeviceRequested?.Invoke();
e.Handled = true;
};
- ToolTip.SetTip(card, Loc.T("Add an audio effect: search the browser, or drop a device here"));
+ ToolTip.SetTip(card, Loc.T("device_chain.add_an_audio_effect_search"));
return card;
}
diff --git a/src/managed/Nota.App/DeviceWindow.cs b/src/managed/Nota.App/DeviceWindow.cs
index c3f1a1ed..e39ad2c1 100644
--- a/src/managed/Nota.App/DeviceWindow.cs
+++ b/src/managed/Nota.App/DeviceWindow.cs
@@ -226,7 +226,7 @@ internal sealed class DeviceWindow : NotaWindow
var seg = DeviceCardKit.Segments(new[] { "S", "L" }, () => size.Mini ? 0 : 1,
i => { if ((i == 0) != size.Mini) { size.SetMini(i == 0); Dispatcher.UIThread.Post(Refill); } },
out _, padX: 0, minSegWidth: 16, fontSize: 9);
- ToolTip.SetTip(seg, Loc.T("Size: S (260 × 260) / L (700 × 260)"));
+ ToolTip.SetTip(seg, Loc.T("device.size_s_260_260_l"));
yield return seg;
}
if (_bypass is { } byp)
@@ -257,7 +257,7 @@ internal sealed class DeviceWindow : NotaWindow
Background = NotaPalette.SurfaceRaised, BorderBrush = NotaPalette.Rule,
HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, Margin = new Thickness(8),
IsHitTestVisible = false, IsVisible = false,
- Child = Caps(MonoText(9, NotaPalette.TextSecondary), Loc.T("Bypassed")),
+ Child = Caps(MonoText(9, NotaPalette.TextSecondary), Loc.T("device.bypassed")),
};
_bypassTag = tag;
return new Border
@@ -295,7 +295,7 @@ internal sealed class DeviceWindow : NotaWindow
if (_switch is { } sw)
{
sw.IsOn = !on;
- if (sw.Parent is Control host) ToolTip.SetTip(host, on ? Loc.T("Bypassed — click to enable") : Loc.T("Active — click to bypass"));
+ if (sw.Parent is Control host) ToolTip.SetTip(host, on ? Loc.T("device.bypassed_click_to_enable") : Loc.T("device.active_click_to_bypass"));
}
if (_bypassTag is { } tag) tag.IsVisible = on;
if (_bodyHost is not { } body || (fresh && !on)) return;
diff --git a/src/managed/Nota.App/DownloadJobs.cs b/src/managed/Nota.App/DownloadJobs.cs
index c93a66ad..d95a305a 100644
--- a/src/managed/Nota.App/DownloadJobs.cs
+++ b/src/managed/Nota.App/DownloadJobs.cs
@@ -81,13 +81,13 @@ internal sealed class DownloadJobs
catch (OperationCanceledException)
{
// Quitting: nothing to show. Otherwise the user pressed Cancel.
- if (!_app.IsCancellationRequested) result = Loc.F("Installing {0} was cancelled.", name);
+ if (!_app.IsCancellationRequested) result = Loc.F("download_jobs.installing_was_cancelled", name);
}
catch (StoreException e) { result = e.Message; sticky = true; }
catch (Exception e)
{
App.Services.GetRequiredService<ILogSink>().Error($"Installing {key} failed", e);
- result = Loc.F("Installing {0} failed: {1}", name, e.Message);
+ result = Loc.F("download_jobs.installing_failed", name, e.Message);
sticky = true;
}
finally
@@ -129,7 +129,7 @@ internal sealed class DownloadJobs
{
if (_job is not { IsCancellationRequested: false } job) return;
job.Cancel();
- Progress = Progress with { Message = Loc.T("Cancelling…") };
+ Progress = Progress with { Message = Loc.T("download_jobs.cancelling") };
ProgressChanged?.Invoke();
Changed?.Invoke();
}
diff --git a/src/managed/Nota.App/DrumPatternView.cs b/src/managed/Nota.App/DrumPatternView.cs
index 19d2ac2b..788d3cdb 100644
--- a/src/managed/Nota.App/DrumPatternView.cs
+++ b/src/managed/Nota.App/DrumPatternView.cs
@@ -268,8 +268,8 @@ public sealed class DrumPatternView : UserControl
VerticalAlignment = VerticalAlignment.Center,
Children =
{
- new TextBlock { Text = Loc.T("No pads loaded"), FontSize = 12, Foreground = TextSecondary, HorizontalAlignment = HorizontalAlignment.Center },
- new TextBlock { Text = Loc.T("Drop samples on the Drum Rack pads in Devices, then step them here."), FontSize = 10, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center },
+ new TextBlock { Text = Loc.T("drum_pattern.no_pads_loaded"), FontSize = 12, Foreground = TextSecondary, HorizontalAlignment = HorizontalAlignment.Center },
+ new TextBlock { Text = Loc.T("drum_pattern.drop_samples_on_the_drum"), FontSize = 10, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center },
},
},
};
@@ -303,15 +303,15 @@ public sealed class DrumPatternView : UserControl
Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center,
Children =
{
- Cap(Loc.T("Pattern")),
+ Cap(Loc.T("common.pattern")),
new TextBlock { Text = _title, FontSize = 11, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center },
- Mono(Loc.F("{0} · {1}", Loc.Plural(_pads.Count, "{0} pad", "{0} pads"), Loc.Plural(_steps, "{0} step", "{0} steps")), TextTertiary),
- Mono(Loc.T("click to place · shift-click accents · drag to paint"), NotaPalette.TextDisabled),
+ Mono(Loc.F("common.pattern_n", Loc.Plural("drum_pattern.pads", _pads.Count), Loc.Plural("drum_pattern.steps", _steps)), TextTertiary),
+ Mono(Loc.T("drum_pattern.click_to_place_shift_click"), NotaPalette.TextDisabled),
},
};
var right = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center, [DockPanel.DockProperty] = Dock.Right };
- right.Children.Add(Cap(Loc.T("Grid")));
+ right.Children.Add(Cap(Loc.T("common.grid")));
right.Children.Add(Seg(ResNames, Array.IndexOf(Resolutions, _res), i =>
{
_res = _resPersist = Resolutions[i];
@@ -329,10 +329,10 @@ public sealed class DrumPatternView : UserControl
int lastBar = (int)Math.Ceiling(Math.Min(_steps, (p + 1) * MaxCells) / barSteps);
names[p] = firstBar == lastBar ? $"{firstBar}" : $"{firstBar}–{lastBar}";
}
- right.Children.Add(Cap(Loc.T("Bars")));
+ right.Children.Add(Cap(Loc.T("drum_pattern.bars")));
right.Children.Add(Seg(names, _winStart / MaxCells, p => { _winStart = p * MaxCells; Rebuild(); }));
}
- right.Children.Add(Chip(Loc.T("Clear"), ClearPattern));
+ right.Children.Add(Chip(Loc.T("common.clear"), ClearPattern));
var dp = new DockPanel { LastChildFill = false, Margin = new Thickness(12, 0), Children = { left, right } };
return new Border { Height = 30, Background = NotaPalette.SurfaceCard, BorderBrush = NotaPalette.BorderDefault, BorderThickness = new Thickness(0, 0, 0, 1), Child = dp };
@@ -392,7 +392,7 @@ public sealed class DrumPatternView : UserControl
inner.Children.Add(note);
var cell = new Border { CornerRadius = NotaRadius.Control, BorderThickness = new Thickness(1), Cursor = new Cursor(StandardCursorType.Hand), Child = inner };
- ToolTip.SetTip(cell, Loc.F("Play {0} · {1} and show its velocity lane", pad.Name, NoteName(pad.Note)));
+ ToolTip.SetTip(cell, Loc.F("drum_pattern.play_and_show_its_velocity", pad.Name, NoteName(pad.Note)));
cell.PointerPressed += (_, e) =>
{
e.Handled = true;
@@ -437,7 +437,7 @@ public sealed class DrumPatternView : UserControl
var label = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 6, VerticalAlignment = VerticalAlignment.Center,
- Children = { Cap(Loc.T("Velocity")), _velLabel },
+ Children = { Cap(Loc.T("common.velocity")), _velLabel },
};
var lane = BeatGrid(VelocityCell);
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions($"{NameW},*"), ColumnSpacing = 8, Height = VelH, Margin = new Thickness(10, 0, 10, 0) };
diff --git a/src/managed/Nota.App/ExportWindow.cs b/src/managed/Nota.App/ExportWindow.cs
index b7c6aad3..d36f16c8 100644
--- a/src/managed/Nota.App/ExportWindow.cs
+++ b/src/managed/Nota.App/ExportWindow.cs
@@ -90,7 +90,7 @@ public sealed class ExportWindow : NotaWindow
};
}
SetRange(0);
- Title = Loc.T("Export audio");
+ Title = Loc.T("export.export_audio");
Width = 560;
SizeToContent = SizeToContent.Height;
CanResize = false;
@@ -103,7 +103,7 @@ public sealed class ExportWindow : NotaWindow
// Range. Custom shows a start and an end (bar.beat), checked as you type (#102).
_rangeReadout = Mono("", TextSecondary);
- var range = Segmented(new[] { (Loc.T("Loop"), true), (Loc.T("Full song"), true), (Loc.T("Custom"), true) }, 0, i =>
+ var range = Segmented(new[] { (Loc.T("common.loop"), true), (Loc.T("export.full_song"), true), (Loc.T("export.custom"), true) }, 0, i =>
{
SetRange(i);
RefreshRange();
@@ -119,8 +119,8 @@ public sealed class ExportWindow : NotaWindow
var a = ParsePosition(startBox.Text);
var b = ParsePosition(endBox.Text);
_customValid = a is not null && b is not null && b > a;
- _customError.Text = a is null || b is null ? Loc.T("Not a position: type bar.beat, like 5.1")
- : b <= a ? Loc.T("The end must be after the start") : "";
+ _customError.Text = a is null || b is null ? Loc.T("export.not_a_position_type_bar")
+ : b <= a ? Loc.T("export.the_end_must_be_after") : "";
if (_customValid) { _customStart = a!.Value; _customEnd = b!.Value; }
SetRange(2);
RefreshRange();
@@ -131,7 +131,7 @@ public sealed class ExportWindow : NotaWindow
// counter shows them, and that the end is where the export stops (#102).
var unitsHint = new TextBlock
{
- Text = Loc.T("Positions are bar.beat.sixteenth, counted from 1 as in the transport: 5 or 5.1 is the start of bar 5, 5.3 its third beat. The export stops at the end position, so 1 to 5 is four bars."),
+ Text = Loc.T("export.positions_are_bar_beat_sixteenth"),
FontSize = 10, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap, MaxWidth = 520,
HorizontalAlignment = HorizontalAlignment.Left,
};
@@ -143,12 +143,12 @@ public sealed class ExportWindow : NotaWindow
new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center,
- Children = { Caption(Loc.T("Start")), startBox, Caption(Loc.T("End")), endBox, _customError },
+ Children = { Caption(Loc.T("common.start")), startBox, Caption(Loc.T("export.end")), endBox, _customError },
},
unitsHint,
},
};
- body.Children.Add(Section(Loc.T("Range"), new StackPanel { Spacing = 8, Children = { rangeRow, _customRow } }));
+ body.Children.Add(Section(Loc.T("common.range"), new StackPanel { Spacing = 8, Children = { rangeRow, _customRow } }));
// Format / SR / bit-depth-or-quality. The third column swaps its control
// (and title) with the format: depth for WAV/FLAC, bitrate for MP3.
@@ -173,19 +173,19 @@ public sealed class ExportWindow : NotaWindow
depthOrQuality.Children.Add(_depth);
depthOrQuality.Children.Add(_quality);
var fmtGrid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,*,*"), ColumnSpacing = 12 };
- var f0 = Section(Loc.T("Format"), _format); fmtGrid.Children.Add(f0);
- var f1 = Section(Loc.T("Sample rate"), _rate); Grid.SetColumn(f1, 1); fmtGrid.Children.Add(f1);
- var f2 = Section(Loc.T("Bit depth"), depthOrQuality); Grid.SetColumn(f2, 2); fmtGrid.Children.Add(f2);
+ var f0 = Section(Loc.T("export.format"), _format); fmtGrid.Children.Add(f0);
+ var f1 = Section(Loc.T("export.sample_rate"), _rate); Grid.SetColumn(f1, 1); fmtGrid.Children.Add(f1);
+ var f2 = Section(Loc.T("export.bit_depth"), depthOrQuality); Grid.SetColumn(f2, 2); fmtGrid.Children.Add(f2);
_depthTitle = (TextBlock)((StackPanel)f2).Children[0];
body.Children.Add(fmtGrid);
_depth.SelectionChanged += (_, _) => { RefreshEstimate(); _refreshDitherEnabled?.Invoke(); };
ApplyFormat(); // populates depth items + visibility for the default format
// Options: normalize + dither (working toggles) and a release tail (checkbox).
- var normalize = WorkingToggle(Loc.T("Normalize −1 dBTP"), () => _normalize, v => { _normalize = v; RefreshEstimate(); });
- var dither = WorkingToggle(Loc.T("Dither"), () => _dither, v => { _dither = v; },
+ var normalize = WorkingToggle(Loc.T("export.normalize_1_dbtp"), () => _normalize, v => { _normalize = v; RefreshEstimate(); });
+ var dither = WorkingToggle(Loc.T("export.dither"), () => _dither, v => { _dither = v; },
enabled: () => SelectedFormat != ExportFormat.Mp3 && _depth.SelectedIndex == 0,
- hint: Loc.T("16-bit only"));
+ hint: Loc.T("export.16_bit_only"));
body.Children.Add(new StackPanel { Orientation = Orientation.Horizontal, Spacing = 22, Children = { normalize, dither } });
body.Children.Add(TailCheck());
@@ -201,7 +201,7 @@ public sealed class ExportWindow : NotaWindow
Background = NotaPalette.SurfaceHover, BorderBrush = NotaPalette.Seam, BorderThickness = new Thickness(1),
CornerRadius = NotaRadius.Control, Padding = new Thickness(18, 0), Height = 28,
Cursor = new Cursor(StandardCursorType.Hand), VerticalAlignment = VerticalAlignment.Center,
- Child = (_exportLabel = new TextBlock { Text = Loc.T("Export WAV"), FontSize = 12, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextHeading, VerticalAlignment = VerticalAlignment.Center }),
+ Child = (_exportLabel = new TextBlock { Text = Loc.T("export.export_wav"), FontSize = 12, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextHeading, VerticalAlignment = VerticalAlignment.Center }),
};
export.BindResource(Border.BoxShadowProperty, "Shadow.Raised");
export.PointerPressed += (_, _) =>
@@ -217,7 +217,7 @@ public sealed class ExportWindow : NotaWindow
int kbps = Bitrates[_quality.SelectedIndex < 0 ? 0 : _quality.SelectedIndex];
Close(new ExportOptions(sr, d, tailBeats, _rangeBeats, _stems, _normalize, dither, fmt, kbps, _startBeats));
};
- var cancel = new TextBlock { Text = Loc.T("Cancel"), FontSize = 11, Foreground = TextSecondary, VerticalAlignment = VerticalAlignment.Center, Cursor = new Cursor(StandardCursorType.Hand) };
+ var cancel = new TextBlock { Text = Loc.T("common.cancel"), FontSize = 11, Foreground = TextSecondary, VerticalAlignment = VerticalAlignment.Center, Cursor = new Cursor(StandardCursorType.Hand) };
cancel.PointerPressed += (_, _) => Close(null);
var footer = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto"), Margin = new Thickness(0, 2, 0, 0) };
footer.Children.Add(export);
@@ -255,7 +255,7 @@ public sealed class ExportWindow : NotaWindow
bool mp3 = fmt == ExportFormat.Mp3;
_depth.IsVisible = !mp3;
_quality.IsVisible = mp3;
- _depthTitle.Text = mp3 ? Loc.T("Quality") : Loc.T("Bit depth");
+ _depthTitle.Text = mp3 ? Loc.T("export.quality") : Loc.T("export.bit_depth");
// MP3 tops out at 48 kHz (MPEG-1): grey 96 kHz out, and move an existing
// 96 kHz selection down to 48 kHz so no invalid pair is reachable.
@@ -270,7 +270,7 @@ public sealed class ExportWindow : NotaWindow
private void PaintExportLabel()
{
if (_exportLabel is null) return; // during construction, before the footer exists
- _exportLabel.Text = _stems ? Loc.T("Export stems") : Loc.F("Export {0}", SelectedFormat.ToString().ToUpperInvariant());
+ _exportLabel.Text = _stems ? Loc.T("export.export_stems") : Loc.F("export.export", SelectedFormat.ToString().ToUpperInvariant());
}
private bool RangeValid => _rangeMode != 2 || _customValid;
@@ -312,7 +312,7 @@ public sealed class ExportWindow : NotaWindow
private TextBox PositionBox(double beats)
{
var box = new TextBox { Text = BarBeatText(beats), Width = 72, FontSize = 11, PlaceholderText = "bar.beat" };
- ToolTip.SetTip(box, Loc.T("Bar.beat.sixteenth, counted from 1 — e.g. 5.1 or 5.3.2"));
+ ToolTip.SetTip(box, Loc.T("export.bar_beat_sixteenth_counted_from"));
box.BindResource(TextBox.FontFamilyProperty, "Font.Mono");
return box;
}
@@ -336,8 +336,8 @@ public sealed class ExportWindow : NotaWindow
_ => sec * sr * 2 * bytesPerSample / 1_000_000.0,
};
_estimate.Text = _stems
- ? string.Format(NotaNum.Culture, Loc.T("one file per track · {0:0.0} MB each · offline render"), mb)
- : string.Format(NotaNum.Culture, Loc.T("≈ 1 file · {0:0.0} MB · offline render"), mb);
+ ? string.Format(NotaNum.Culture, Loc.T("export.one_file_per_track_mb"), mb)
+ : string.Format(NotaNum.Culture, Loc.T("export.1_file_mb_offline_render"), mb);
}
// ---- helpers ----------------------------------------------------------
@@ -402,7 +402,7 @@ public sealed class ExportWindow : NotaWindow
// The release-tail option: the shell switch (a themed CheckBox), word to the right.
private Control TailCheck()
{
- var sw = new CheckBox { Content = Loc.T("Add 1-bar release tail"), IsChecked = _tailOn, VerticalAlignment = VerticalAlignment.Center };
+ var sw = new CheckBox { Content = Loc.T("export.add_1_bar_release_tail"), IsChecked = _tailOn, VerticalAlignment = VerticalAlignment.Center };
sw.IsCheckedChanged += (_, _) => { _tailOn = sw.IsChecked == true; RefreshEstimate(); };
return sw;
}
@@ -429,8 +429,8 @@ public sealed class ExportWindow : NotaWindow
Children =
{
knob,
- new TextBlock { Text = Loc.T("Export stems"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center },
- new TextBlock { Text = Loc.T("· one file per track, post-fader"), FontSize = 9, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center },
+ new TextBlock { Text = Loc.T("export.export_stems"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center },
+ new TextBlock { Text = Loc.T("export.one_file_per_track_post"), FontSize = 9, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center },
},
};
var headerBar = new Border { Height = 28, Background = NotaPalette.SurfaceInset, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1), Padding = new Thickness(10, 0), Cursor = new Cursor(StandardCursorType.Hand), Child = header };
diff --git a/src/managed/Nota.App/HistoryView.cs b/src/managed/Nota.App/HistoryView.cs
index ded72173..a3d475de 100644
--- a/src/managed/Nota.App/HistoryView.cs
+++ b/src/managed/Nota.App/HistoryView.cs
@@ -75,7 +75,7 @@ internal sealed class HistoryView : UserControl
_history = history;
_host = host;
- var caption = new TextBlock { Text = Loc.T("Versions"), Classes = { "GroupLabel" }, VerticalAlignment = VerticalAlignment.Center };
+ var caption = new TextBlock { Text = Loc.T("history.versions"), Classes = { "GroupLabel" }, VerticalAlignment = VerticalAlignment.Center };
_summary.BindResource(TextBlock.ForegroundProperty, "Brush.TextTertiary");
var header = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto,Auto,Auto"), Height = RowH, Margin = new Thickness(10, 8, 6, 4) };
header.Children.Add(caption);
@@ -89,7 +89,7 @@ internal sealed class HistoryView : UserControl
PaintStarredOnly();
_options.Click += (_, _) => BuildOptionsMenu().ShowAt(_options);
((Glyph)_options.Content!).BindResource(Glyph.ForegroundProperty, "Brush.TextTertiary");
- ToolTip.SetTip(_options, Loc.T("Clean up the history"));
+ ToolTip.SetTip(_options, Loc.T("history.clean_up_the_history"));
_empty.BindResource(TextBlock.ForegroundProperty, "Brush.TextTertiary");
_details.BindResource(Border.BackgroundProperty, "Brush.Panel");
@@ -159,12 +159,12 @@ internal sealed class HistoryView : UserControl
ShowSelection();
_empty.Text = problem
- ?? (_dir is null ? Loc.T("Save the project to start its history.")
- : !_host.KeepVersionHistory && rows.Count == 0 ? Loc.T("Version history is turned off in Settings.")
- : all.Count == 0 ? Loc.T("Each save adds a version here.")
- : rows.Count == 0 ? Loc.T("No starred versions yet. Right-click a version and choose Star.") : "");
+ ?? (_dir is null ? Loc.T("history.save_the_project_to_start")
+ : !_host.KeepVersionHistory && rows.Count == 0 ? Loc.T("history.version_history_is_turned_off")
+ : all.Count == 0 ? Loc.T("history.each_save_adds_a_version")
+ : rows.Count == 0 ? Loc.T("history.no_starred_versions_yet_right") : "");
_empty.IsVisible = _empty.Text.Length > 0;
- ToolTip.SetTip(_empty, problem is null ? null : Loc.T("Its versions can't be listed until the file .history/versions.json is repaired."));
+ ToolTip.SetTip(_empty, problem is null ? null : Loc.T("history.its_versions_cant_be_listed"));
_options.IsVisible = all.Count > 1;
_starredOnly.IsVisible = all.Count > 0;
@@ -175,7 +175,7 @@ internal sealed class HistoryView : UserControl
long size = 0;
try { size = _history.Size(_dir).HistoryOnly; } catch (Exception ex) when (ex is System.IO.IOException or UnauthorizedAccessException) { }
_summary.Text = $"{all.Count} · {NotaNum.Bytes(size)}";
- ToolTip.SetTip(_summary, Loc.F("{0} · older versions take {1} on disk", Loc.Plural(all.Count, "{0} version", "{0} versions"), NotaNum.Bytes(size)));
+ ToolTip.SetTip(_summary, Loc.F("history.older_versions_take_on_disk", Loc.Plural("history.versions_n", all.Count), NotaNum.Bytes(size)));
}
}
@@ -185,7 +185,7 @@ internal sealed class HistoryView : UserControl
var g = (Glyph)_starredOnly.Content!;
g.Kind = _onlyStarred ? GlyphKind.StarFilled : GlyphKind.Star;
g.BindResource(Glyph.ForegroundProperty, _onlyStarred ? "Brush.Accent" : "Brush.TextTertiary");
- ToolTip.SetTip(_starredOnly, _onlyStarred ? Loc.T("Show all versions") : Loc.T("Show starred versions only"));
+ ToolTip.SetTip(_starredOnly, _onlyStarred ? Loc.T("history.show_all_versions") : Loc.T("history.show_starred_versions_only"));
}
// --- rows ----------------------------------------------------------------
@@ -284,7 +284,7 @@ internal sealed class HistoryView : UserControl
var name = new TextBlock { Text = Title(v), Classes = { "Name" }, TextTrimming = TextTrimming.CharacterEllipsis };
name.BindResource(TextBlock.ForegroundProperty, "Brush.TextPrimary");
var meta = new List<string> { LongTime(v.CreatedAt) };
- if (v.AppVersion.Length > 0) meta.Add(Loc.F("Nota {0}", v.AppVersion));
+ if (v.AppVersion.Length > 0) meta.Add(Loc.F("history.nota", v.AppVersion));
if (v.AddedBytes > 0) meta.Add("+" + NotaNum.Bytes(v.AddedBytes));
var metaText = new TextBlock { Text = string.Join(" · ", meta), Classes = { "Value" }, TextWrapping = TextWrapping.Wrap };
metaText.BindResource(TextBlock.ForegroundProperty, "Brush.TextSecondary");
@@ -299,25 +299,25 @@ internal sealed class HistoryView : UserControl
if (v.Note is { Length: > 0 } note && note != Title(v)) // the title already shows a one-line note
stack.Children.Add(new TextBlock { Text = note, Classes = { "Caption" }, TextWrapping = TextWrapping.Wrap, MaxHeight = 64 });
if (!v.CanOpen)
- stack.Children.Add(new TextBlock { Text = Loc.T("Saved by a newer Nota — update to open it."), Classes = { "Caption" }, TextWrapping = TextWrapping.Wrap });
+ stack.Children.Add(new TextBlock { Text = Loc.T("history.saved_by_a_newer_nota"), Classes = { "Caption" }, TextWrapping = TextWrapping.Wrap });
var switchBtn = new Button
{
- Content = ButtonText(row.IsHead ? Loc.T("Current") : Loc.T("Switch")),
+ Content = ButtonText(row.IsHead ? Loc.T("history.current") : Loc.T("history.switch")),
Classes = { "primary" },
IsEnabled = !row.IsHead && v.CanOpen,
HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center,
};
if (row.IsHead) switchBtn.Classes.Remove("primary");
- ToolTip.SetTip(switchBtn, row.IsHead ? Loc.T("The project is at this version") : Loc.T("Switch the project to this version"));
+ ToolTip.SetTip(switchBtn, row.IsHead ? Loc.T("history.the_project_is_at_this") : Loc.T("history.switch_the_project_to_this"));
switchBtn.Click += (_, _) => _ = Switch(v);
var copyBtn = new Button
{
- Content = ButtonText(Loc.T("Open copy")),
+ Content = ButtonText(Loc.T("history.open_copy")),
IsEnabled = v.CanOpen,
HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center,
};
- ToolTip.SetTip(copyBtn, Loc.T("Open this version as a new project, keeping this one as it is"));
+ ToolTip.SetTip(copyBtn, Loc.T("history.open_this_version_as_a"));
copyBtn.Click += (_, _) => _ = _host.OpenVersionAsCopyAsync(v.Id);
var buttons = new Grid { ColumnDefinitions = new ColumnDefinitions("*,6,*"), Margin = new Thickness(0, 4, 0, 0) };
buttons.Children.Add(switchBtn);
@@ -334,14 +334,14 @@ internal sealed class HistoryView : UserControl
_details.IsVisible = true;
var deletable = Deletable(rows);
- var name = new TextBlock { Text = Loc.Plural(rows.Count, "{0} version", "{0} versions"), Classes = { "Name" }, TextTrimming = TextTrimming.CharacterEllipsis };
+ var name = new TextBlock { Text = Loc.Plural("history.versions_n", rows.Count), Classes = { "Name" }, TextTrimming = TextTrimming.CharacterEllipsis };
name.BindResource(TextBlock.ForegroundProperty, "Brush.TextPrimary");
string first = LongTime(rows.Min(r => r.Version.CreatedAt)), last = LongTime(rows.Max(r => r.Version.CreatedAt));
var metaText = new TextBlock { Text = first == last ? first : $"{first} – {last}", Classes = { "Value" }, TextWrapping = TextWrapping.Wrap };
metaText.BindResource(TextBlock.ForegroundProperty, "Brush.TextSecondary");
var stack = new StackPanel { Spacing = 4, Children = { name, metaText } };
if (deletable.Count < rows.Count)
- stack.Children.Add(new TextBlock { Text = Loc.T("The current version stays."), Classes = { "Caption" }, TextWrapping = TextWrapping.Wrap });
+ stack.Children.Add(new TextBlock { Text = Loc.T("history.the_current_version_stays_2"), Classes = { "Caption" }, TextWrapping = TextWrapping.Wrap });
var deleteBtn = new Button
{
@@ -350,7 +350,7 @@ internal sealed class HistoryView : UserControl
HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center,
Margin = new Thickness(0, 4, 0, 0),
};
- ToolTip.SetTip(deleteBtn, Loc.T("Delete the selected versions and the audio only they use"));
+ ToolTip.SetTip(deleteBtn, Loc.T("history.delete_the_selected_versions_and"));
deleteBtn.Click += (_, _) => _ = DeleteSelected(deletable);
stack.Children.Add(deleteBtn);
_details.Child = stack;
@@ -380,20 +380,20 @@ internal sealed class HistoryView : UserControl
return mi;
}
- menu.Items.Add(MenuKit.Header(v.Label ?? LongTime(v.CreatedAt), null, row.IsHead ? Loc.T("Current version") : Loc.T("Version")));
+ menu.Items.Add(MenuKit.Header(v.Label ?? LongTime(v.CreatedAt), null, row.IsHead ? Loc.T("history.current_version") : Loc.T("history.version")));
menu.Items.Add(new Separator());
- Item(Loc.T("Switch to this version"), () => _ = Switch(v), !row.IsHead && v.CanOpen, GlyphKind.Arrow);
- Item(Loc.T("Open as copy…"), () => _ = _host.OpenVersionAsCopyAsync(v.Id), v.CanOpen, GlyphKind.Duplicate);
+ Item(Loc.T("history.switch_to_this_version"), () => _ = Switch(v), !row.IsHead && v.CanOpen, GlyphKind.Arrow);
+ Item(Loc.T("history.open_as_copy"), () => _ = _host.OpenVersionAsCopyAsync(v.Id), v.CanOpen, GlyphKind.Duplicate);
menu.Items.Add(new Separator());
- Item(v.Label is null ? Loc.T("Name…") : Loc.T("Rename…"), () => _ = Prompt(Loc.T("Name version"), Loc.T("Version name"), v.Label, t => _history.SetLabel(_dir!, v.Id, t)), icon: GlyphKind.Edit);
- if (v.Label is not null) Item(Loc.T("Remove name"), () => Apply(() => _history.SetLabel(_dir!, v.Id, null)));
- Item(v.Note is null ? Loc.T("Add note…") : Loc.T("Edit note…"), () => _ = Prompt(Loc.T("Version note"), Loc.T("What changed in this version?"), v.Note, t => _history.SetNote(_dir!, v.Id, t)), icon: GlyphKind.Note);
- if (v.Note is not null) Item(Loc.T("Remove note"), () => Apply(() => _history.SetNote(_dir!, v.Id, null)));
- Item(v.Starred ? Loc.T("Remove star") : Loc.T("Star"), () => Apply(() => _history.SetStarred(_dir!, v.Id, !v.Starred)));
+ Item(v.Label is null ? Loc.T("history.name") : Loc.T("common.rename"), () => _ = Prompt(Loc.T("history.name_version"), Loc.T("history.version_name"), v.Label, t => _history.SetLabel(_dir!, v.Id, t)), icon: GlyphKind.Edit);
+ if (v.Label is not null) Item(Loc.T("history.remove_name"), () => Apply(() => _history.SetLabel(_dir!, v.Id, null)));
+ Item(v.Note is null ? Loc.T("history.add_note") : Loc.T("history.edit_note"), () => _ = Prompt(Loc.T("history.version_note"), Loc.T("history.what_changed_in_this_version"), v.Note, t => _history.SetNote(_dir!, v.Id, t)), icon: GlyphKind.Note);
+ if (v.Note is not null) Item(Loc.T("history.remove_note"), () => Apply(() => _history.SetNote(_dir!, v.Id, null)));
+ Item(v.Starred ? Loc.T("history.remove_star") : Loc.T("history.star"), () => Apply(() => _history.SetStarred(_dir!, v.Id, !v.Starred)));
menu.Items.Add(new Separator());
- var del = Item(Loc.T("Delete version…"), () => _ = Delete(v), !row.IsHead, GlyphKind.Trash);
+ var del = Item(Loc.T("history.delete_version_2"), () => _ = Delete(v), !row.IsHead, GlyphKind.Trash);
del.Classes.Add("danger");
- if (row.IsHead) ToolTip.SetTip(del, Loc.T("Switch to another version to delete this one"));
+ if (row.IsHead) ToolTip.SetTip(del, Loc.T("history.switch_to_another_version_to"));
return menu;
}
@@ -402,11 +402,11 @@ internal sealed class HistoryView : UserControl
{
var deletable = Deletable(rows);
var menu = new MenuFlyout();
- menu.Items.Add(MenuKit.Header(Loc.Plural(rows.Count, "{0} version", "{0} versions"), null, ""));
+ menu.Items.Add(MenuKit.Header(Loc.Plural("history.versions_n", rows.Count), null, ""));
menu.Items.Add(new Separator());
var del = new MenuItem { Header = DeleteManyLabel(deletable.Count), Icon = MenuKit.Icon(GlyphKind.Trash), IsEnabled = deletable.Count > 0 };
del.Classes.Add("danger");
- if (deletable.Count < rows.Count) ToolTip.SetTip(del, Loc.T("The current version stays"));
+ if (deletable.Count < rows.Count) ToolTip.SetTip(del, Loc.T("history.the_current_version_stays"));
del.Click += (_, _) => _ = DeleteSelected(deletable);
menu.Items.Add(del);
return menu;
@@ -416,7 +416,7 @@ internal sealed class HistoryView : UserControl
private static List<ProjectVersion> Deletable(IEnumerable<HistoryRow> rows)
=> rows.Where(r => !r.IsHead).Select(r => r.Version).ToList();
- private static string DeleteManyLabel(int count) => count == 1 ? Loc.T("Delete version…") : Loc.Plural(count, "Delete {0} version…", "Delete {0} versions…");
+ private static string DeleteManyLabel(int count) => count == 1 ? Loc.T("history.delete_version_2") : Loc.Plural("history.delete_versions_n", count);
private MenuFlyout BuildOptionsMenu()
{
@@ -424,7 +424,7 @@ internal sealed class HistoryView : UserControl
var unnamed = UnnamedVersions();
var clean = new MenuItem
{
- Header = unnamed.Count == 0 ? Loc.T("Delete unnamed versions…") : Loc.Plural(unnamed.Count, "Delete {0} unnamed version…", "Delete {0} unnamed versions…"),
+ Header = unnamed.Count == 0 ? Loc.T("history.delete_unnamed_versions_2") : Loc.Plural("history.delete_unnamed_versions_n", unnamed.Count),
Icon = MenuKit.Icon(GlyphKind.Trash),
IsEnabled = unnamed.Count > 0,
};
@@ -447,26 +447,26 @@ internal sealed class HistoryView : UserControl
private async Task DeleteUnnamed(IReadOnlyList<ProjectVersion> versions)
{
if (TopLevel.GetTopLevel(this) is not Window owner || _dir is null || versions.Count == 0) return;
- bool ok = await new ConfirmWindow(Loc.T("Delete unnamed versions"),
- Loc.Plural(versions.Count, "Delete {0} version and the audio only it uses? The current version, the latest version of each branch, and every named, starred or noted version stay. This can't be undone.", "Delete {0} versions and the audio only they use? The current version, the latest version of each branch, and every named, starred or noted version stay. This can't be undone."),
- Loc.T("Delete"), Loc.T("Cancel")).ShowDialog<bool>(owner);
+ bool ok = await new ConfirmWindow(Loc.T("history.delete_unnamed_versions"),
+ Loc.Plural("history.delete_versions_and_the_audio", versions.Count),
+ Loc.T("common.delete"), Loc.T("common.cancel")).ShowDialog<bool>(owner);
if (!ok) return;
long freed = 0;
Apply(() => freed = _history.DeleteMany(_dir, versions.Select(v => v.Id).ToList()));
- _host.ReportStatus(Loc.F("{0} · {1} freed", Loc.Plural(versions.Count, "Deleted {0} version", "Deleted {0} versions"), NotaNum.Bytes(freed)));
+ _host.ReportStatus(Loc.F("history.freed", Loc.Plural("history.deleted_versions", versions.Count), NotaNum.Bytes(freed)));
}
private async Task DeleteSelected(IReadOnlyList<ProjectVersion> versions)
{
if (versions.Count == 1) { await Delete(versions[0]); return; }
if (TopLevel.GetTopLevel(this) is not Window owner || _dir is null || versions.Count == 0) return;
- bool ok = await new ConfirmWindow(Loc.T("Delete versions"),
- Loc.Plural(versions.Count, "Delete {0} version? Audio that only it uses is deleted from the project folder too. This can't be undone.", "Delete {0} versions? Audio that only they use is deleted from the project folder too. This can't be undone."),
- Loc.T("Delete"), Loc.T("Cancel")).ShowDialog<bool>(owner);
+ bool ok = await new ConfirmWindow(Loc.T("history.delete_versions"),
+ Loc.Plural("history.delete_versions_audio_that_only", versions.Count),
+ Loc.T("common.delete"), Loc.T("common.cancel")).ShowDialog<bool>(owner);
if (!ok) return;
long freed = 0;
Apply(() => freed = _history.DeleteMany(_dir, versions.Select(v => v.Id).ToList()));
- _host.ReportStatus(Loc.F("{0} · {1} freed", Loc.Plural(versions.Count, "Deleted {0} version", "Deleted {0} versions"), NotaNum.Bytes(freed)));
+ _host.ReportStatus(Loc.F("history.freed", Loc.Plural("history.deleted_versions", versions.Count), NotaNum.Bytes(freed)));
}
private async Task Prompt(string title, string prompt, string? initial, Action<string> apply)
@@ -479,9 +479,9 @@ internal sealed class HistoryView : UserControl
private async Task Delete(ProjectVersion v)
{
if (TopLevel.GetTopLevel(this) is not Window owner || _dir is null) return;
- bool ok = await new ConfirmWindow(Loc.T("Delete version"),
- Loc.F("Delete {0}? Audio that only this version uses is deleted from the project folder too. This can't be undone.", Title(v)),
- Loc.T("Delete"), Loc.T("Cancel")).ShowDialog<bool>(owner);
+ bool ok = await new ConfirmWindow(Loc.T("history.delete_version"),
+ Loc.F("history.delete_audio_that_only_this", Title(v)),
+ Loc.T("common.delete"), Loc.T("common.cancel")).ShowDialog<bool>(owner);
if (ok) Apply(() => _history.Delete(_dir, v.Id));
}
@@ -492,7 +492,7 @@ internal sealed class HistoryView : UserControl
try { edit(); }
catch (Exception ex) when (ex is ProjectHistoryException or System.IO.IOException or UnauthorizedAccessException)
{
- _host.ReportStatus(Loc.F("Couldn't change the version: {0}", ex.Message));
+ _host.ReportStatus(Loc.F("history.couldnt_change_the_version", ex.Message));
}
Refresh();
}
@@ -503,7 +503,7 @@ internal sealed class HistoryView : UserControl
// number in save order.
private string Title(ProjectVersion v)
=> v.Label ?? v.Note?.Split('\n')[0] ?? VersionSummary.Headline(v.Changes, NotaNum.Bpm)
- ?? (_numbers.TryGetValue(v.Id, out int n) ? Loc.F("Version {0}", n) : Loc.T("Version"));
+ ?? (_numbers.TryGetValue(v.Id, out int n) ? Loc.F("common.version", n) : Loc.T("history.version"));
// Everything the version changed, as one line ("" when unknown or nothing nameable).
private static string Changes(ProjectVersion v)
diff --git a/src/managed/Nota.App/Languages/NotaLanguages.cs b/src/managed/Nota.App/Languages/NotaLanguages.cs
index 2343ad58..4efae80c 100644
--- a/src/managed/Nota.App/Languages/NotaLanguages.cs
+++ b/src/managed/Nota.App/Languages/NotaLanguages.cs
@@ -1,8 +1,9 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
-// The interface languages (spec 068). Languages/<code>.json is the only place a translation
-// lives; each file is embedded as Nota.Languages.<code>.json and read here at startup. The
+// The interface languages (spec 068, keyed since spec 077). English is the reference built into
+// Loc; Languages/<code>.json is where a translation lives, embedded as Nota.Languages.<code>.json
+// and read here at startup, checked against the English reference. The
// picker lists whatever loads, so adding a language is adding a file. Like the colour-theme
// loader, this validates rather than trusts: a file that fails is left out and noted in
// LoadErrors, never thrown at the UI, and Nota still starts in English.
@@ -60,11 +61,14 @@ public static class NotaLanguages
var table = TranslationTable.Parse(json, out var error);
if (table is null) { _loadErrors.Add($"{fileCode}: {error}"); continue; }
if (table.Code != fileCode) { _loadErrors.Add($"{fileCode}: file declares code '{table.Code}'"); continue; }
+ if (table.Code == UiLanguage.Default) continue; // English is the built-in reference
+ var (problems, _) = table.ValidateAgainst(Loc.English);
+ foreach (var p in problems) _loadErrors.Add($"{fileCode}: {p.Key} — {p.Problem} (English is shown)");
tables[table.Code] = table;
}
- // English is the fallback of every text; it is offered even if its file were lost.
- if (!tables.ContainsKey(UiLanguage.Default))
- tables[UiLanguage.Default] = TranslationTable.Parse("{\"formatVersion\":1,\"code\":\"en\",\"name\":\"English\"}", out _)!;
+ // English is the reference of every text, built into Loc (spec 077); it is always offered.
+ if (Loc.EnglishError is { } englishError) _loadErrors.Add($"en: {englishError}");
+ tables[UiLanguage.Default] = Loc.English;
return tables;
}
}
diff --git a/src/managed/Nota.App/Languages/en.json b/src/managed/Nota.App/Languages/en.json
deleted file mode 100644
index b51af69f..00000000
--- a/src/managed/Nota.App/Languages/en.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
- "formatVersion": 1,
- "code": "en",
- "name": "English",
- "notes": "The reference language. The English text at each call site is the key, so this file has no strings."
-}
diff --git a/src/managed/Nota.App/Languages/fr.json b/src/managed/Nota.App/Languages/fr.json
index 3d417e64..b94b4756 100644
--- a/src/managed/Nota.App/Languages/fr.json
+++ b/src/managed/Nota.App/Languages/fr.json
@@ -1,3705 +1,3759 @@
{
- "formatVersion": 1,
+ "formatVersion": 2,
"code": "fr",
"name": "Français",
- "notes": "Glossary and register: specs/068-ui-language/glossary.md. Actions use the infinitive; sentence case; device and parameter names stay English. A key is the English text, or \"text|context\" when one English word needs two translations; counted texts take {\"one\", \"other\"} and French counts 0 and 1 as one.",
+ "plural": "one_is_0_1",
+ "notes": "Glossary and register: specs/068-ui-language/glossary.md. Actions use the infinitive; sentence case; device and parameter names stay English. Keys are the English reference's keys (Nota.Application/Localization/en.json); counted texts take {\"one\", \"other\"} and French counts 0 and 1 as one.",
"strings": {
- "About Nota": "À propos de Nota",
- "Check for updates…": "Rechercher des mises à jour…",
- "Settings…": "Réglages…",
- "Nothing to undo": "Rien à annuler",
- "Select a clip or a range first": "Sélectionner d’abord un clip ou une plage",
- "Select clips or a range first": "Sélectionner d’abord des clips ou une plage",
- "Select a time range first": "Sélectionner d’abord une plage de temps",
- "Toggled clip(s)": "État des clips inversé",
- "Select a clip first": "Sélectionner d’abord un clip",
- "Open a clip in the clip editor first": "Ouvrir d’abord un clip dans l’éditeur de clips",
- "Select a track first": "Sélectionner d’abord une piste",
- "Grouped tracks": "Pistes groupées",
- "Select tracks first": "Sélectionner d’abord des pistes",
- "Ungrouped": "Dégroupé",
- "This track can't be frozen": "Cette piste ne peut pas être gelée",
- "Open the Session view first": "Ouvrir d’abord la vue Session",
- "Scenes live in the Session view": "Les scènes se trouvent dans la vue Session",
- "Open a MIDI clip first": "Ouvrir d’abord un clip MIDI",
- "Quantized notes": "Notes quantifiées",
- "Select two or more MIDI clips": "Sélectionner au moins deux clips MIDI",
- "No notes outside the scale": "Aucune note hors de la gamme",
- "Envelopes locked — clip moves keep automation in place": "Enveloppes verrouillées : les déplacements de clips laissent l’automation en place",
- "Envelopes follow clips": "Les enveloppes suivent les clips",
- "Selecting a track leaves the arms alone": "Sélectionner une piste ne modifie pas l’armement",
- "Selecting an instrument track arms it": "Sélectionner une piste d’instrument l’arme",
- "Track headers on the left": "En-têtes de piste à gauche",
- "Track headers on the right": "En-têtes de piste à droite",
- "Snap off": "Magnétisme désactivé",
- "Arrangement grid: {0}": "Grille de l’arrangement : {0}",
- "Clip editor grid: {0}": "Grille de l’éditeur de clips : {0}",
- "Not implemented yet.": "Pas encore disponible.",
- "Undo": "Annuler",
- "Nothing to undo.": "Rien à annuler.",
- "Redo": "Rétablir",
- "Nothing to redo.": "Rien à rétablir.",
- "Scenes live in the Session view.": "Les scènes se trouvent dans la vue Session.",
- "Duplicated notes": "Notes dupliquées",
- "Duplicated track(s)": "Piste(s) dupliquée(s)",
- "Duplicated automation": "Automation dupliquée",
- "Duplicated range": "Plage dupliquée",
- "Duplicated clip(s)": "Clip(s) dupliqué(s)",
- "Select a clip first.": "Sélectionner d’abord un clip.",
- "Select a time range first.": "Sélectionner d’abord une plage de temps.",
- "Duplicated time": "Temps dupliqué",
- "Nothing to duplicate in the selected range.": "Rien à dupliquer dans la plage sélectionnée.",
- "Inserted silence": "Silence inséré",
- "Nothing after the selection to move.": "Rien à déplacer après la sélection.",
- "Split at selection": "Découpé à la sélection",
- "Split clip(s) at playhead": "Clip(s) découpé(s) à la tête de lecture",
- "Select a range, or a clip the playhead crosses.": "Sélectionner une plage, ou un clip que la tête de lecture traverse.",
- "Consolidated": "Consolidé",
- "Select a range or clips to consolidate.": "Sélectionner une plage ou des clips à consolider.",
- "Copied track(s)": "Piste(s) copiée(s)",
- "Copied notes": "Notes copiées",
- "Copied range": "Plage copiée",
- "Copied clip": "Clip copié",
- "Cut track(s)": "Piste(s) coupée(s)",
- "Cut notes": "Notes coupées",
- "Cut range": "Plage coupée",
- "Cut clip": "Clip coupé",
- "Pasted track(s)": "Piste(s) collée(s)",
- "Pasted notes": "Notes collées",
- "Pasted clip": "Clip collé",
- "Select a clip or a scene to copy to the arrangement.": "Sélectionner un clip ou une scène à copier dans l’arrangement.",
- "Select clips to copy to the session.": "Sélectionner des clips à copier dans la session.",
- "Deleted track(s)": "Piste(s) supprimée(s)",
- "Deleted notes": "Notes supprimées",
- "Deleted clip(s)": "Clip(s) supprimé(s)",
- "Overview strip hidden": "Bandeau d’aperçu masqué",
- "Overview strip shown": "Bandeau d’aperçu affiché",
- "Sections lane hidden": "Couloir des sections masqué",
- "Sections lane shown": "Couloir des sections affiché",
- "Clip names: every clip": "Noms des clips : tous les clips",
- "Clip names: first of a run": "Noms des clips : premier d’une série",
- "Clip names: none": "Noms des clips : aucun",
- "Loop set to selection": "Boucle réglée sur la sélection",
- "Show parameter-automation lanes (⌘⇧A)": "Afficher les couloirs d’automation des paramètres (⌘⇧A)",
- "{0} is no longer installed.": "{0} n’est plus installé.",
- "Couldn't load {0}.": "Impossible de charger {0}.",
- "Added {0} (track {1})": "{0} ajouté (piste {1})",
- "New": "Nouveau",
- "Open…": "Ouvrir…",
- "Save as…": "Enregistrer sous…",
- "Save version with note…": "Enregistrer une version avec note…",
- "Import audio…": "Importer de l’audio…",
- "Export audio…": "Exporter de l’audio…",
- "Exit": "Quitter",
- "Edit": "Édition",
- "Duplicate clip": "Dupliquer le clip",
- "Insert scene": "Insérer une scène",
- "Split at playhead": "Découper à la tête de lecture",
- "Consolidate": "Consolider",
- "Duplicate time": "Dupliquer le temps",
- "Insert silence": "Insérer du silence",
- "Lock envelopes": "Verrouiller les enveloppes",
- "Paste bounced audio": "Coller l’audio rendu",
- "Copy clips to Session / Arrangement": "Copier les clips vers Session / Arrangement",
- "Delete": "Supprimer",
- "Grid": "Grille",
- "Narrow grid": "Réduire la grille",
- "Widen grid": "Élargir la grille",
- "Triplet grid": "Grille en triolets",
- "Snap to grid": "Magnétisme sur la grille",
- "Adaptive grid": "Grille adaptative",
- "View": "Affichage",
- "Command palette…": "Palette de commandes…",
- "Mixer": "Mixeur",
- "Mixer in its own window": "Mixeur dans sa propre fenêtre",
- "Connect phone…": "Connecter un téléphone…",
- "Toggle browser": "Afficher/masquer le navigateur",
- "Toggle detail panel": "Afficher/masquer le panneau de détail",
- "Clip editor fills the window": "L’éditeur de clips remplit la fenêtre",
- "Toggle overview": "Afficher/masquer l’aperçu",
- "Toggle sections": "Afficher/masquer les sections",
- "Toggle full screen": "Activer/quitter le plein écran",
- "Follow playhead": "Suivre la tête de lecture",
- "Show playhead": "Afficher la tête de lecture",
- "Clip names": "Noms des clips",
- "Play / stop": "Lecture / arrêt",
- "Play / pause": "Lecture / pause",
- "Auto-arm selected track": "Armement automatique de la piste sélectionnée",
- "Loop": "Boucle",
- "Loop record: overdub / replace": "Enregistrement en boucle : superposition / remplacement",
- "Help": "Aide",
- "Documentation": "Documentation",
- "What's new": "Nouveautés",
- "Auto": "Auto",
- "Recent": "Récents",
- "Reveal in Finder": "Afficher dans le Finder",
- "Show in Explorer": "Afficher dans l’Explorateur",
- "Show in file manager": "Afficher dans le gestionnaire de fichiers",
- "Copy": "Copier",
- "Cut": "Couper",
- "Paste": "Coller",
- "Duplicate": "Dupliquer",
- "AI models": "Modèles d’IA",
- "Sample packs": "Packs d’échantillons",
- "Applies after restart": "S’applique au redémarrage",
- "Language": "Langue",
- "OK": "OK",
- "Later": "Plus tard",
- "Restart now": "Redémarrer maintenant",
- "Restart": "Redémarrer",
- "Applies the next time Nota starts": "S’applique au prochain démarrage de Nota",
- "AI models that run on this computer: the audio you give them never leaves it. Each downloads once from where its authors publish it and is checked against the checksum Nota pins for it.": "Modèles d’IA exécutés sur cet ordinateur : l’audio qui leur est confié ne le quitte jamais. Chacun est téléchargé une seule fois depuis le site de ses auteurs, puis vérifié avec la somme de contrôle que Nota lui associe.",
- "ONNX Runtime has no build for this computer, so the models can't run here.": "ONNX Runtime n’existe pas pour cet ordinateur : les modèles ne peuvent pas s’y exécuter.",
- "Installing…": "Installation…",
- "Removing…": "Suppression…",
- "Installed": "Installé",
- "Remove": "Supprimer",
- "Install": "Installer",
- "Comes with a model": "Fourni avec un modèle",
- "On disk": "Sur le disque",
- "{0} model + {1} AI runtime, downloaded once": "Modèle de {0} + environnement d’exécution IA de {1}, téléchargés une seule fois",
- "Download": "Télécharger",
- "Source": "Source",
- "Open the model's project page": "Ouvrir la page du projet du modèle",
- "Downloading {0}…": "Téléchargement de {0}…",
- "{0} is installed — right-click an audio clip and choose Separate Stems.": "{0} est installé : clic droit sur un clip audio, puis « Séparer les stems ».",
- "{0} is installed — Convert Melody and Convert Harmony now use it.": "{0} est installé : « Convertir la mélodie » et « Convertir l’harmonie » l’utilisent désormais.",
- "Remove AI model": "Supprimer le modèle d’IA",
- "Remove {0}? {1} will offer to download it again.": "Supprimer {0} ? {1} proposera de le télécharger à nouveau.",
- "Cancel": "Annuler",
- "Removing {0}…": "Suppression de {0}…",
- "{0} was removed.": "{0} a été supprimé.",
- "Pads and keys. Mixer, transport and mappings are read-only.": "Pads et touches. Le mixeur, le transport et les assignations sont en lecture seule.",
- "Play notes only": "Jouer des notes uniquement",
- "Also mixer, transport, macros, XY and Session.": "Aussi le mixeur, le transport, les macros, le XY et la vue Session.",
- "Play and control the project": "Jouer et piloter le projet",
- "No phone has paired yet. Turn Remote on and scan the code in Connect phone.": "Aucun téléphone n’est encore associé. Activer la télécommande et scanner le code dans « Connecter un téléphone ».",
- "now": "maintenant",
- "Forget": "Oublier",
- "Disconnect it and make it scan a new code to come back": "Le déconnecter et lui faire scanner un nouveau code pour revenir",
- "On · no network": "Activée · pas de réseau",
- "USB ": "USB ",
- "Off": "Désactivé",
- "Allow control from a phone": "Autoriser le contrôle depuis un téléphone",
- "Port": "Port",
- "Status": "État",
- "Phones may": "Les téléphones peuvent",
- "When you turn this on, macOS asks whether Nota may find devices on the local network. Allow it, or phones can't reach Nota.": "À l’activation, macOS demande si Nota peut trouver des appareils sur le réseau local. Il faut l’autoriser, sinon les téléphones ne peuvent pas joindre Nota.",
- "When you turn this on, Windows asks whether Nota may use the network. Allow private networks, or phones can't reach Nota.": "À l’activation, Windows demande si Nota peut utiliser le réseau. Il faut autoriser les réseaux privés, sinon les téléphones ne peuvent pas joindre Nota.",
- "Phones reach Nota on the port above: if a firewall is on, allow it.": "Les téléphones joignent Nota sur le port ci-dessus : si un pare-feu est actif, l’autoriser.",
- "Nota Remote": "Nota Remote",
- "Trusted devices": "Appareils de confiance",
- "just now": "à l’instant",
- "{0} min ago": "il y a {0} min",
- "{0} h ago": "il y a {0} h",
- "{0} days ago": "il y a {0} jours",
- "All": "Tous",
- "Instruments": "Instruments",
- "Free sample packs from the Nota sample registry, licensed for any music, commercial releases included. Each pack downloads from where its author publishes it, is checked against the registry's checksum and unpacked into your Samples folder.": "Packs d’échantillons gratuits issus du registre d’échantillons de Nota, utilisables pour toute musique, sorties commerciales comprises. Chaque pack est téléchargé depuis le site de son auteur, vérifié avec la somme de contrôle du registre, puis décompressé dans le dossier d’échantillons.",
- "Search": "Rechercher",
- "Refresh": "Actualiser",
- "Reload the registry": "Recharger le registre",
- "Installed to {0}": "Installé dans {0}",
- "Refreshing…": "Actualisation…",
- "No sample packs installed from the registry yet.": "Aucun pack d’échantillons installé depuis le registre pour l’instant.",
- "Nothing matches.": "Aucun résultat.",
- "Loading the sample registry…": "Chargement du registre d’échantillons…",
- "Loops": "Boucles",
- "Instrument": "Instrument",
- "Mixed": "Mixte",
- "Credit: {0}": "Crédit : {0}",
- "Working…": "En cours…",
- "Update to {0}": "Mettre à jour vers {0}",
- "Show": "Afficher",
- "Show the pack's folder": "Afficher le dossier du pack",
- "{0} samples": {
- "one": "{0} échantillon",
- "other": "{0} échantillons"
- },
- "{0} · {1} samples": "{0} · {1} échantillons",
- "{0} download · {1} samples · {2} on disk · {3}": "{0} à télécharger · {1} échantillons · {2} sur le disque · {3}",
- "Open the pack's page": "Ouvrir la page du pack",
- "{0} is installed — find it under Downloaded in the browser's Files tab, where it is being analysed for tempo and key; its instruments appear under Nota Mosaic → Packs.": "{0} est installé : il se trouve sous « Téléchargés » dans l’onglet Fichiers du navigateur, où son tempo et sa tonalité sont en cours d’analyse ; ses instruments apparaissent sous Nota Mosaic → Packs.",
- "Remove sample pack": "Supprimer le pack d’échantillons",
- "Remove {0}? Its folder ({1}) is deleted.": "Supprimer {0} ? Son dossier ({1}) sera supprimé.",
- "Effects": "Effets",
- "Open-source VST3 plugins from the Nota plugin registry. Each one downloads from the project's own GitHub release, is checked against the registry's checksum and unpacked — installers never run.": "Plug-ins VST3 open source issus du registre de plug-ins de Nota. Chacun est téléchargé depuis la publication GitHub du projet, vérifié avec la somme de contrôle du registre, puis décompressé : aucun installeur n’est jamais exécuté.",
- "Loading the plugin registry…": "Chargement du registre de plug-ins…",
- "Linux": "Linux",
- "Windows": "Windows",
- "Nothing installed from the registry yet.": "Rien d’installé depuis le registre pour l’instant.",
- "Not available for this computer": "Indisponibles pour cet ordinateur",
- "Stop the download — nothing is changed": "Arrêter le téléchargement : rien n’est modifié",
- "Open the source repository": "Ouvrir le dépôt source",
- "No {0} version": "Pas de version {0}",
- "No {0} version for {1}": "Pas de version {0} pour {1}",
- "Apple silicon + Intel": "Apple silicon + Intel",
- "Apple silicon": "Apple silicon",
- "Effect": "Effet",
- "Collection": "Collection",
- "Scanning {0}…": "Analyse de {0}…",
- "{0} {1} is installed — find it in the browser.": "{0} {1} est installé : il se trouve dans le navigateur.",
- "{0} is installed. Rescan plugins to use it.": "{0} est installé. Relancer l’analyse des plug-ins pour l’utiliser.",
- "Remove plugin": "Supprimer le plug-in",
- "Remove {0}? Projects that use it will load without it until it's installed again.": "Supprimer {0} ? Les projets qui l’utilisent se chargeront sans lui tant qu’il ne sera pas réinstallé.",
- "Check for updates automatically": "Rechercher les mises à jour automatiquement",
- "Check now": "Rechercher maintenant",
- "Update": "Mettre à jour",
- "Checking…": "Recherche…",
- "Nota {0} is available — you have {1}.": "Nota {0} est disponible : la version installée est la {1}.",
- "Download opens the release page.": "« Télécharger » ouvre la page de la version.",
- "Update downloads it here; it installs when you restart or quit Nota.": "« Mettre à jour » la télécharge ici ; elle s’installe au redémarrage ou à la fermeture de Nota.",
- "Downloading Nota {0}…": "Téléchargement de Nota {0}…",
- "It installs the next time you quit Nota, or click Restart to update in the status bar.": "Elle s’installe à la prochaine fermeture de Nota, ou en cliquant sur « Redémarrer pour mettre à jour » dans la barre d’état.",
- "Nota {0} is ready to install.": "Nota {0} est prêt à être installé.",
- "The update didn't download.": "La mise à jour n’a pas pu être téléchargée.",
- "Couldn't reach GitHub to check for a newer version. Check your internet connection and try again.": "Impossible de joindre GitHub pour rechercher une nouvelle version. Vérifier la connexion Internet, puis réessayer.",
- "You have Nota {0}.": "La version installée de Nota est la {0}.",
- "Last checked {0}.": "Dernière recherche : {0}.",
- "Nota {0} is the latest version.": "Nota {0} est la dernière version.",
- "Not checked yet.": "Pas encore recherchée.",
- "Try again": "Réessayer",
- "This copy of Nota can't replace itself (a development build, or one run straight from the disk image), so a new version opens its release page to download.": "Cet exemplaire de Nota ne peut pas se remplacer lui-même (version de développement, ou lancée directement depuis l’image disque) : une nouvelle version ouvre donc sa page de publication pour être téléchargée.",
- "Automatic updates": "Mises à jour automatiques",
- "On launch and once a day, Nota asks GitHub whether a newer version is out and tells you in the status bar. Nothing is downloaded until you click Update.": "Au lancement, puis une fois par jour, Nota demande à GitHub si une version plus récente est disponible et l’indique dans la barre d’état. Rien n’est téléchargé avant un clic sur « Mettre à jour ».",
- "This version": "Cette version",
- "Devices": "Appareils",
- "Audio": "Audio",
- "Device, sample rate and buffer": "Périphérique, fréquence d’échantillonnage et mémoire tampon",
- "Controllers Nota listens to": "Contrôleurs écoutés par Nota",
- "Gamepads": "Manettes",
- "Play notes or drive mapped controls": "Jouer des notes ou piloter les commandes assignées",
- "Phones and tablets on this network": "Téléphones et tablettes sur ce réseau",
- "Remote": "Télécommande",
- "Where Nota looks for VST3": "Où Nota cherche les VST3",
- "Downloads": "Téléchargements",
- "Plug-ins, sample packs and AI models": "Plug-ins, packs d’échantillons et modèles d’IA",
- "General": "Général",
- "Content folders and version history": "Dossiers de contenu et historique des versions",
- "Library": "Bibliothèque",
- "Appearance": "Apparence",
- "Theme, scale, waveforms and AI control": "Thème, échelle, formes d’onde et contrôle par IA",
- "Keyboard reference": "Référence du clavier",
- "Shortcuts": "Raccourcis",
- "New versions of Nota": "Nouvelles versions de Nota",
- "Updates": "Mises à jour",
- "Settings": "Réglages",
- "Audio settings are unavailable in this window.": "Les réglages audio ne sont pas disponibles dans cette fenêtre.",
- "Device default": "Par défaut du périphérique",
- "Latency": "Latence",
- "Audio device": "Périphérique audio",
- "Test": "Test",
- "Input": "Entrée",
- "Output": "Sortie",
- "Buffer size": "Taille de la mémoire tampon",
- "Sample rate": "Fréquence d’échantillonnage",
- "Exclusive mode": "Mode exclusif",
- "WASAPI exclusive — lowest latency, mutes other apps": "WASAPI exclusif : latence minimale, coupe le son des autres applications",
- "The device's native sample rate and buffer size are used instead of the ones above. If it is busy or doesn't allow exclusive access, Nota falls back to shared mode.": "La fréquence d’échantillonnage et la taille de tampon natives du périphérique remplacent celles ci-dessus. Si le périphérique est occupé ou n’autorise pas l’accès exclusif, Nota revient au mode partagé.",
- "ASIO": "ASIO",
- "Audio system": "Système audio",
- "No ASIO driver found. Few interfaces ship an ARM64 ASIO driver yet — install one from your interface's maker, or a generic one such as FlexASIO.": "Aucun pilote ASIO trouvé. Peu d’interfaces proposent déjà un pilote ASIO ARM64 : en installer un auprès du fabricant de l’interface, ou un pilote générique comme FlexASIO.",
- "No ASIO driver found. Install your interface's driver, or a generic one such as FlexASIO.": "Aucun pilote ASIO trouvé. Installer le pilote de l’interface, ou un pilote générique comme FlexASIO.",
- "Saved driver not found": "Pilote enregistré introuvable",
- "Driver settings…": "Réglages du pilote…",
- "Driver": "Pilote",
- "No inputs on this driver": "Aucune entrée sur ce pilote",
- "The driver doesn't support {0}": "Le pilote ne prend pas en charge {0}",
- "{0} frames (set in the driver's settings)": "{0} échantillons (défini dans les réglages du pilote)",
- "Set in the driver's settings": "Défini dans les réglages du pilote",
- "Play test tone": "Jouer une tonalité de test",
- "{0:0} Hz sine at −14 dBFS, through the master.": "Sinus de {0:0} Hz à −14 dBFS, via le master.",
- "Stop tone": "Arrêter la tonalité",
- "Output check": "Contrôle de la sortie",
- "CPU check": "Test du CPU",
- "Measures audio-thread load for 5 s — play your project for a real-world figure.": "Mesure la charge du thread audio pendant 5 s : lancer la lecture du projet pour obtenir une valeur réaliste.",
- "Audio device not running.": "Le périphérique audio n’est pas démarré.",
- "Measuring…": "Mesure…",
- "Measuring… {0} s left · now {1:0} %": "Mesure… encore {0} s · actuellement {1:0} %",
- "overloaded — raise the buffer size": "surchargé : augmenter la taille du tampon",
- "close to the limit — consider a larger buffer": "proche de la limite : envisager un tampon plus grand",
- "plenty of headroom": "large marge",
- "Last check: {0:0} % average, {1:0} % peak · {2} — {3}.": "Dernier contrôle : {0:0} % en moyenne, {1:0} % au pic · {2} — {3}.",
- "{0} dropouts": {
- "one": "{0} décrochage",
- "other": "{0} décrochages"
- },
- "Measuring… 5 s left — play your project for a real-world figure.": "Mesure… encore 5 s : lancer la lecture du projet pour obtenir une valeur réaliste.",
- "Performance": "Performances",
- "ASIO unavailable ({0}) → WASAPI": "ASIO indisponible ({0}) → WASAPI",
- "the driver didn't start": "le pilote ne s’est pas lancé",
- " · round trip {0}": " · aller-retour {0}",
- "ASIO · {0} frames @ {1}{2}": "ASIO · {0} échantillons @ {1}{2}",
- "{0} frames @ {1}{2}": "{0} échantillons @ {1}{2}",
- "MIDI settings are unavailable in this window.": "Les réglages MIDI ne sont pas disponibles dans cette fenêtre.",
- "No MIDI inputs detected. Connect a controller and reopen Settings.": "Aucune entrée MIDI détectée. Connecter un contrôleur, puis rouvrir les réglages.",
- "Switch a controller off to stop Nota listening to it. New devices are on by default.": "Désactiver un contrôleur pour que Nota cesse de l’écouter. Les nouveaux périphériques sont activés par défaut.",
- "MIDI inputs": "Entrées MIDI",
- "±{0} semitones": "±{0} demi-tons",
- "Per-note expression from MPE controllers": "Expression par note des contrôleurs MPE",
- "Expression": "Expression",
- "Bend range": "Amplitude du pitch bend",
- "Gamepad settings are unavailable in this window.": "Les réglages des manettes ne sont pas disponibles dans cette fenêtre.",
- "Gamepad input is macOS-only in this build.": "Les manettes ne sont prises en charge que sous macOS dans cette version.",
- "Use a connected gamepad for notes and mapped controls": "Utiliser une manette connectée pour les notes et les commandes assignées",
- "No gamepad detected. Connect one and it appears here.": "Aucune manette détectée. Une manette connectée apparaît ici.",
- "Last": "Dernier",
- "Face buttons": "Boutons de face",
- "Shoulder buttons": "Boutons d’épaule",
- "Octave −1 / +1": "Octave −1 / +1",
- "Velocity − / +": "Vélocité − / +",
- "Gamepad input": "Entrée manette",
- "Layout": "Disposition",
- "Notes go to the armed (record-enabled) instrument track — enable Record to capture them, or use the audition track to just play.": "Les notes vont à la piste d’instrument armée (prête à enregistrer) : activer l’enregistrement pour les capturer, ou utiliser la piste d’écoute pour simplement jouer.",
- "Any button can be mapped to a control instead: click MIDI in the top-right, click the control, then press the button. A mapped button drives that control and stops playing its note; the rest of the pad keeps the layout above. The sticks and the trigger travel map the same way and are continuous, so they suit a knob or a fader — they play no notes, and do nothing until mapped. Mappings are listed in the browser's MIDI Map tab and travel with the project.": "Un bouton quelconque peut être assigné à une commande à la place : cliquer sur MIDI en haut à droite, cliquer sur la commande, puis appuyer sur le bouton. Un bouton assigné pilote cette commande et ne joue plus sa note ; le reste de la manette garde la disposition ci-dessus. Les sticks et la course des gâchettes s’assignent de la même façon et sont continus, ce qui convient à un bouton rotatif ou à un fader : ils ne jouent aucune note et ne font rien tant qu’ils ne sont pas assignés. Les assignations sont listées dans l’onglet Carte MIDI du navigateur et suivent le projet.",
- "Add folder…": "Ajouter un dossier…",
- "default": "par défaut",
- "Add plugin scan folder": "Ajouter un dossier d’analyse de plug-ins",
- "Rescan plugins": "Relancer l’analyse des plug-ins",
- "Plugin scanning is unavailable in this window.": "L’analyse des plug-ins n’est pas disponible dans cette fenêtre.",
- "Scanning…": "Analyse…",
- "Searching {0} folders": {
- "one": "Recherche dans {0} dossier",
- "other": "Recherche dans {0} dossiers"
- },
- "Scanner worker not found.": "Processus d’analyse introuvable.",
- "Found {0:N0} plugins.": {
- "one": "{0:N0} plug-in trouvé.",
- "other": "{0:N0} plug-ins trouvés."
- },
- " {0:N0} couldn't be loaded — see plugin-scan.log in Nota's logs folder.": " Impossible d’en charger {0:N0} : voir plugin-scan.log dans le dossier de journaux de Nota.",
- "Open plug-in window on insert": "Ouvrir la fenêtre du plug-in à l’insertion",
- "Plug-in window": "Fenêtre du plug-in",
- "Adding a plug-in from the browser, by drag and drop or from the palette opens its editor. Loading a project, undo and paste never do.": "L’ajout d’un plug-in depuis le navigateur, par glisser-déposer ou depuis la palette, ouvre son éditeur. Le chargement d’un projet, l’annulation et le collage ne l’ouvrent jamais.",
- "Plugin scan folders": "Dossiers d’analyse des plug-ins",
- "Extra folders are searched for VST3 plugins on the next rescan (AU uses the system registry).": "Des dossiers supplémentaires sont explorés à la recherche de plug-ins VST3 à la prochaine analyse (les AU utilisent le registre du système).",
- "Scan": "Analyse",
- "Content folders are unavailable in this window.": "Les dossiers de contenu ne sont pas disponibles dans cette fenêtre.",
- "Content folders": "Dossiers de contenu",
- "Samples": "Échantillons",
- "Projects": "Projets",
- "Keep a version history of each project": "Conserver un historique des versions de chaque projet",
- "Turn off version history": "Désactiver l’historique des versions",
- "This erases the version history of the open project now, and of any other project the next time you save it. Older versions can't be brought back.": "Cela efface dès maintenant l’historique des versions du projet ouvert, et celui de tout autre projet au prochain enregistrement. Les anciennes versions ne pourront pas être restaurées.",
- "Turn off and erase": "Désactiver et effacer",
- "Version history": "Historique des versions",
- "Every save records a version, listed in the browser's History tab. Versions share their audio, so each one costs only what it adds.": "Chaque enregistrement crée une version, listée dans l’onglet Historique du navigateur. Les versions partagent leur audio : chacune ne coûte que ce qu’elle ajoute.",
- "custom": "personnalisé",
- "Choose…": "Choisir…",
- "Choose {0} folder": "Choisir le dossier {0}",
- "Dark": "Sombre",
- "Follow system": "Suivre le système",
- "Light": "Clair",
- "In dark mode": "En mode sombre",
- "In light mode": "En mode clair",
- "Bars": "Barres",
- "Smooth": "Lisse",
- "Solid": "Plein",
- "Left": "Gauche",
- "Right": "Droite",
- "Copy config": "Copier la config",
- "Add this config (or the URL) as an MCP server in Claude Desktop / Claude Code. Loopback only; off by default.": "Ajouter cette config (ou l’URL) comme serveur MCP dans Claude Desktop / Claude Code. Boucle locale uniquement ; désactivé par défaut.",
- "Listening on http://127.0.0.1:{0}/ (loopback)": "Écoute sur http://127.0.0.1:{0}/ (boucle locale)",
- "Enable MCP server (let an AI drive Nota)": "Activer le serveur MCP (laisser une IA piloter Nota)",
- "Copied": "Copié",
- "Label every note in the piano roll": "Nommer chaque note dans le piano roll",
- "Open the detail panel when you select a track or clip": "Ouvrir le panneau de détail à la sélection d’une piste ou d’un clip",
- "Detail panel": "Panneau de détail",
- "Off: a click only selects, and an open panel follows it. Double-click a track for its devices or a clip to edit it.": "Désactivé : un clic ne fait que sélectionner, et un panneau ouvert suit la sélection. Double-cliquer sur une piste pour ses appareils ou sur un clip pour le modifier.",
- "Colour theme": "Thème de couleurs",
- "Themes change colours only. Follow system switches between your dark-mode and light-mode theme with the OS appearance.": "Les thèmes ne changent que les couleurs. « Suivre le système » alterne entre le thème du mode sombre et celui du mode clair, selon l’apparence de l’OS.",
- "Waveform": "Forme d’onde",
- "How audio clips draw on the arrangement: Smooth outlines the peaks around the RMS level; Solid draws every pixel; Bars spaces the peaks out so the rhythm reads. Solid and Bars also set the browser's preview.": "Dessin des clips audio dans l’arrangement : « Lisse » trace le contour des pics autour du niveau RMS ; « Plein » dessine chaque pixel ; « Barres » espace les pics pour que le rythme se lise. « Plein » et « Barres » règlent aussi l’aperçu du navigateur.",
- "Track headers": "En-têtes de piste",
- "Which side of the arrangement the track list sits on. Right starts the timeline at the left edge, next to the browser. Also in the View menu.": "Côté de l’arrangement où se trouve la liste des pistes. « Droite » fait commencer la timeline au bord gauche, contre le navigateur. Aussi dans le menu Affichage.",
- "Interface scale": "Échelle de l’interface",
- "Makes the whole interface larger or smaller. Timeline, piano roll and audio editor zoom work on top of it.": "Agrandit ou réduit toute l’interface. Le zoom de la timeline, du piano roll et de l’éditeur audio s’applique par-dessus.",
- "The language of menus, panels and messages. It changes when Nota restarts. Project files and the names you type are never translated.": "La langue des menus, des panneaux et des messages. Elle change au redémarrage de Nota. Les fichiers de projet et les noms saisis ne sont jamais traduits.",
- "Piano roll": "Piano roll",
- "Shows every note name (C, D, E…) on the piano roll's keys instead of only C. Helpful when learning notes.": "Affiche le nom de chaque note (C, D, E…) sur les touches du piano roll, et non seulement celui des C. Utile pour apprendre les notes.",
- "AI control (MCP)": "Contrôle par IA (MCP)",
- "File": "Fichier",
- "New project / open a project": "Nouveau projet / ouvrir un projet",
- "Save (records a version) / save as": "Enregistrer (crée une version) / enregistrer sous",
- "Save a version with a note": "Enregistrer une version avec une note",
- "Export audio": "Exporter l’audio",
- "Quit Nota · asks about unsaved changes first": "Quitter Nota · demande d’abord quoi faire des modifications non enregistrées",
- "Window": "Fenêtre",
- "Enter / leave full screen — the title bar hides in full screen": "Entrer dans le plein écran / en sortir : la barre de titre se masque en plein écran",
- "The clip editor fills the window / back to the split it had": "L’éditeur de clips remplit la fenêtre / retour à la répartition précédente",
- "Double-click a panel edge": "Double-clic sur le bord d’un panneau",
- "Reset the detail panel, the Mixer or the browser to its default size": "Rétablir la taille par défaut du panneau de détail, du mixeur ou du navigateur",
- "Command palette": "Palette de commandes",
- "Open / close the command palette — from any window, even while typing": "Ouvrir / fermer la palette de commandes : depuis n’importe quelle fenêtre, même pendant la saisie",
- "Move through the results": "Parcourir les résultats",
- "Apply where the palette was opened (the target shows in the field)": "Appliquer là où la palette a été ouverte (la cible s’affiche dans le champ)",
- "An instrument or instrument preset on a new track · a track: open it in Devices": "Un instrument ou un préréglage d’instrument sur une nouvelle piste · une piste : l’ouvrir dans Appareils",
- "Replace the selected device instead of inserting after it": "Remplacer l’appareil sélectionné au lieu d’insérer après lui",
- "Apply and keep the palette open for the next device": "Appliquer et garder la palette ouverte pour l’appareil suivant",
- "Filter: all · actions · tracks · devices · presets": "Filtre : tout · actions · pistes · appareils · préréglages",
- "Type first to filter: actions, tracks, devices, presets, Modular nodes": "Saisir d’abord pour filtrer : actions, pistes, appareils, préréglages, nœuds Modular",
- "Close and go back where you were": "Fermer et revenir où l’on était",
- "Transport": "Transport",
- "Play / Stop · Stop goes back to where playback started": "Lecture / Arrêt · l’arrêt revient là où la lecture a commencé",
- "Play / pause · the playhead stays put and Play carries on from there": "Lecture / pause · la tête de lecture reste en place et la lecture reprend à partir de là",
- "Stop (again → back to the start) · in the Session grid it launches the selection": "Arrêt (de nouveau → retour au début) · dans la grille Session, lance la sélection",
- "Record": "Enregistrement",
- "Metronome": "Métronome",
- "Loop on / off · loop the selected clips or time range": "Boucle activée / désactivée · mettre en boucle les clips ou la plage de temps sélectionnés",
- "Double-click loop brace": "Double-clic sur l’accolade de boucle",
- "Drag loop edge · drag loop brace": "Glisser le bord de la boucle · glisser l’accolade de boucle",
- "Resize that end of the loop region · move the whole region · ⌥ off the grid": "Redimensionner cette extrémité de la région de boucle · déplacer toute la région · ⌥ hors de la grille",
- "Right-click ruler": "Clic droit sur la règle",
- "Show playhead · scroll the Arrangement to it without moving it · picks up a paused Follow": "Afficher la tête de lecture · faire défiler l’arrangement jusqu’à elle sans la déplacer · reprend un suivi en pause",
- "Loop recording: Overdub (every pass adds) / Replace (keep the latest pass)": "Enregistrement en boucle : Superposer (chaque passage s’ajoute) / Remplacer (garder le dernier passage)",
- "Click the position read-out": "Clic sur l’affichage de la position",
- "Switch it between bars and time · every ruler follows": "Basculer entre mesures et temps · toutes les règles suivent",
- "Arrangement & editing": "Arrangement et édition",
- "Undo / redo": "Annuler / rétablir",
- "Select all clips": "Sélectionner tous les clips",
- "Toggle automation mode": "Activer / désactiver le mode automation",
- "Toggle the Mixer view": "Afficher / masquer la vue Mixeur",
- "Cycle Devices / Pattern / Clip in the detail panel": "Passer d’Appareils à Pattern puis à Clip dans le panneau de détail",
- "Cancel the current gesture / clear the selection · close the patch-bay overlay": "Annuler le geste en cours / effacer la sélection · fermer la baie de brassage",
- "Group / ungroup selected tracks · on selected devices: group them into a rack / take a rack apart": "Grouper / dégrouper les pistes sélectionnées · sur des appareils sélectionnés : les grouper dans un rack / défaire un rack",
- "Copy / cut / paste clips, a time range or an automation range · pastes onto the track clicked last": "Copier / couper / coller des clips, une plage de temps ou une plage d’automation · colle sur la dernière piste cliquée",
- "Copy the selected clips to Session · the first scene row where they fit": "Copier les clips sélectionnés vers Session · dans la première rangée de scènes où ils tiennent",
- "Paste the last range as audio rendered through its devices": "Coller la dernière plage sous forme d’audio rendu à travers ses appareils",
- "Duplicate the selected clip(s) / range": "Dupliquer le ou les clips / la plage sélectionnés",
- "Duplicate time · insert a copy of the time range after it, pushing everything later right": "Dupliquer le temps · insérer une copie de la plage de temps après elle, en repoussant tout ce qui suit",
- "Insert silence · push everything from the range start right by its length": "Insérer du silence · repousser tout ce qui suit le début de la plage de sa longueur",
- "Split at the playhead · at the range edges": "Découper à la tête de lecture · aux bords de la plage",
- "Consolidate the selection into one clip per track": "Consolider la sélection en un clip par piste",
- "Deactivate / activate the selected clip(s)": "Désactiver / activer le ou les clips sélectionnés",
- "Nudge the selected clips by the grid step · stops at the song start": "Décaler les clips sélectionnés du pas de la grille · s’arrête au début du morceau",
- "Nudge the selected clips by a 64th note": "Décaler les clips sélectionnés d’une quadruple croche",
- "Move the selected clips to the next track that takes them, at the same beats": "Déplacer les clips sélectionnés vers la piste suivante qui les accepte, sur les mêmes temps",
- "Drag below the last track": "Glisser sous la dernière piste",
- "Move the clips to a new track like their own · one per source track": "Déplacer les clips vers une nouvelle piste du même type que la leur · une par piste d’origine",
- "Delete the selected clip / range": "Supprimer le clip / la plage sélectionnés",
- "Grid (Arrangement or clip editor — whichever you used last)": "Grille (arrangement ou éditeur de clips : le dernier utilisé)",
- "Narrow / widen the grid · in Auto, change the density": "Réduire / élargir la grille · en Auto, changer la densité",
- "Triplet grid on / off": "Grille en triolets activée / désactivée",
- "Snap to grid on / off": "Magnétisme sur la grille activé / désactivé",
- "Switch between the adaptive (Auto) and a fixed grid": "Basculer entre la grille adaptative (Auto) et une grille fixe",
- "Move freely, ignoring the grid": "Déplacer librement, sans tenir compte de la grille",
- "Audio clip editor on ADSR or an unwarped clip": "Éditeur de clips audio sur ADSR ou sur un clip non warpé",
- "Tracks (after a click in the track headers)": "Pistes (après un clic dans les en-têtes de piste)",
- "Select all tracks": "Sélectionner toutes les pistes",
- "Select a range of tracks / add or remove one track": "Sélectionner une série de pistes / ajouter ou retirer une piste",
- "Copy / cut / paste the selected tracks · paste lands after the last one": "Copier / couper / coller les pistes sélectionnées · le collage se place après la dernière",
- "Duplicate the selected tracks": "Dupliquer les pistes sélectionnées",
- "Delete the selected tracks · a group goes with its tracks": "Supprimer les pistes sélectionnées · un groupe part avec ses pistes",
- "Devices (after a click on a device)": "Appareils (après un clic sur un appareil)",
- "Select a range of devices (MIDI effects, instrument, audio effects) / add or remove one": "Sélectionner une série d’appareils (effets MIDI, instrument, effets audio) / en ajouter ou en retirer un",
- "Clear the device selection · so does a click on the chain's empty space": "Effacer la sélection d’appareils · un clic dans l’espace vide de la chaîne fait de même",
- "Copy / cut / paste the selected devices with all their settings · each lands in its section after the selected device · a copied instrument replaces the instrument it is pasted on": "Copier / couper / coller les appareils sélectionnés avec tous leurs réglages · chacun se place dans sa section après l’appareil sélectionné · un instrument copié remplace l’instrument sur lequel il est collé",
- "Duplicate the selected devices · each run right after itself": "Dupliquer les appareils sélectionnés · chaque série juste après elle-même",
- "Group the selected devices into a rack · audio effects: Audio Effect Rack · MIDI effects: MIDI Effect Rack · with the instrument: Instrument Rack": "Grouper les appareils sélectionnés dans un rack · effets audio : Audio Effect Rack · effets MIDI : MIDI Effect Rack · avec l’instrument : Instrument Rack",
- "Take the devices out of a selected one-chain rack": "Sortir les appareils d’un rack à une seule chaîne sélectionné",
- "Delete the selected devices · with the instrument, its track": "Supprimer les appareils sélectionnés · avec l’instrument, sa piste",
- "Drag a selected device's header": "Glisser l’en-tête d’un appareil sélectionné",
- "Move the selected devices of that section together": "Déplacer ensemble les appareils sélectionnés de cette section",
- "Drag a device onto a track": "Glisser un appareil sur une piste",
- "Move it there (out of the panel, onto a track row or Session column) · the instrument replaces that track's and its own track goes": "L’y déplacer (hors du panneau, sur une rangée de piste ou une colonne Session) · l’instrument remplace celui de cette piste et sa propre piste disparaît",
- "Copy it there": "L’y copier",
- "Racks": "Racks",
- "End macro mapping (Map on the rack card)": "Terminer l’assignation de macro (Assigner sur la carte du rack)",
- "Drag a zone edge": "Glisser le bord d’une zone",
- "Set a chain's key, velocity or select range · edges never cross": "Régler la plage de notes, de vélocité ou de sélection d’une chaîne · les bords ne se croisent jamais",
- "Hover the zones": "Survoler les zones",
- "See which chains a note would play": "Voir quelles chaînes jouerait une note",
- "Double-click a chain or macro name": "Double-clic sur le nom d’une chaîne ou d’une macro",
- "Rename it": "La renommer",
- "Map it to a parameter or the selector · clear its mappings": "L’assigner à un paramètre ou au sélecteur · effacer ses assignations",
- "Right-click a macro": "Clic droit sur une macro",
- "Drag a device's header": "Glisser l’en-tête d’un appareil",
- "Move it within its chain · onto another chain's row to move it there": "Le déplacer dans sa chaîne · sur la rangée d’une autre chaîne pour l’y déplacer",
- "Click a device": "Clic sur un appareil",
- "Select it for ⌘C ⌘X ⌘V ⌘D and Delete": "Le sélectionner pour ⌘C ⌘X ⌘V ⌘D et Delete",
- "Modular (after a click on the canvas)": "Modular (après un clic sur le canevas)",
- "Fit every node on screen": "Ajuster tous les nœuds à l’écran",
- "Bypass the selected device": "Contourner l’appareil sélectionné",
- "Duplicate the selected device with all its settings": "Dupliquer l’appareil sélectionné avec tous ses réglages",
- "Delete the selected device, modulator or cable · the track's input, instrument and output are fixed": "Supprimer l’appareil, le modulateur ou le câble sélectionné · l’entrée, l’instrument et la sortie de la piste sont fixes",
- "Show fewer parameters on every opened node": "Afficher moins de paramètres sur chaque nœud ouvert",
- "Session (after a click in the grid)": "Session (après un clic dans la grille)",
- "Move the selection between slots and scenes": "Déplacer la sélection entre les emplacements et les scènes",
- "Launch the selected clip or scene": "Lancer le clip ou la scène sélectionnés",
- "Copy / cut / paste a clip · a cut clip moves when pasted · clips copied in the Arrangement paste here": "Copier / couper / coller un clip · un clip coupé se déplace au collage · les clips copiés dans l’arrangement se collent ici",
- "Copy the selected clip, group slot or scene to the Arrangement at the playhead": "Copier le clip, l’emplacement de groupe ou la scène sélectionnés vers l’arrangement, à la tête de lecture",
- "Duplicate a clip into the slot below · a scene below itself": "Dupliquer un clip dans l’emplacement du dessous · une scène sous elle-même",
- "Insert a scene below the selection": "Insérer une scène sous la sélection",
- "Rename the selected clip or scene": "Renommer le clip ou la scène sélectionnés",
- "Delete the selected clip or scene": "Supprimer le clip ou la scène sélectionnés",
- "Drag clip": "Glisser un clip",
- "Move it to another slot · ⌥ copies": "Le déplacer vers un autre emplacement · ⌥ copie",
- "Drag scene": "Glisser une scène",
- "Reorder scenes": "Réordonner les scènes",
- "Double-click slot": "Double-clic sur un emplacement",
- "Edit the clip · an empty MIDI slot gets a new clip": "Éditer le clip · un emplacement MIDI vide reçoit un nouveau clip",
- "Double-click header": "Double-clic sur un en-tête",
- "Rename the track": "Renommer la piste",
- "Add an instrument, audio or return track · rename or delete one": "Ajouter une piste d’instrument, audio ou de retour · en renommer ou en supprimer une",
- "Right-click header or grid": "Clic droit sur un en-tête ou la grille",
- "Move notes by the grid": "Déplacer les notes selon la grille",
- "Transpose by a semitone": "Transposer d’un demi-ton",
- "Transpose by an octave": "Transposer d’une octave",
- "Shorten / lengthen the notes by the grid": "Raccourcir / allonger les notes selon la grille",
- "Velocity +10 / −10 · ⌥⇧ by 1": "Vélocité +10 / −10 · ⌥⇧ par 1",
- "Change its velocity · the whole selection's when the note is selected · elsewhere scroll sideways": "Changer sa vélocité · celle de toute la sélection si la note est sélectionnée · ailleurs, défiler latéralement",
- "Select all notes": "Sélectionner toutes les notes",
- "Duplicate the selection · replaces the notes it lands on": "Dupliquer la sélection · remplace les notes sur lesquelles elle tombe",
- "Copy / cut / paste notes · paste lands on the originals": "Copier / couper / coller des notes · le collage se place sur les originaux",
- "Deselect · moved or pasted notes replace the notes under them": "Désélectionner · les notes déplacées ou collées remplacent celles qui sont dessous",
- "Delete the selected notes": "Supprimer les notes sélectionnées",
- "Add a note with the length and velocity of the last note touched · on a note, delete it": "Ajouter une note avec la longueur et la vélocité de la dernière note touchée · sur une note, la supprimer",
- "Double-click empty grid": "Double-clic sur la grille vide",
- "Double-click and hold, drag": "Double-clic maintenu, puis glisser",
- "Change the note's start or end": "Changer le début ou la fin de la note",
- "Drag note edge": "Glisser le bord d’une note",
- "Click · drag the ruler": "Clic · glisser sur la règle",
- "Move the playhead there · drag to scrub, snapped to the grid · ⌥ off the grid": "Y déplacer la tête de lecture · glisser pour balayer, calé sur la grille · ⌥ hors de la grille",
- "Drag the playhead line": "Glisser la ligne de la tête de lecture",
- "Scrub the playhead · on the ruler or over empty grid": "Balayer avec la tête de lecture · sur la règle ou sur la grille vide",
- "Drag velocity stem": "Glisser une tige de vélocité",
- "Double-click velocity stem": "Double-clic sur une tige de vélocité",
- "Put the note back to the default velocity (0.8) · the whole selection's when the note is selected · undo is one step": "Remettre la note à la vélocité par défaut (0,8) · toute la sélection si la note est sélectionnée · l’annulation se fait en une seule étape",
- "Right-click velocity stem": "Clic droit sur une tige de vélocité",
- "Reset velocity from a menu · same as the double-click": "Réinitialiser la vélocité depuis un menu · comme le double-clic",
- "Reset velocity": "Réinitialiser la vélocité",
- "Set velocity · selected notes move together · ⇧ adds a note": "Régler la vélocité · les notes sélectionnées bougent ensemble · ⇧ ajoute une note",
- "Drag in the Bend / Pres / Slide lane": "Glisser dans le couloir Bend / Pres / Slide",
- "Draw the selected note's MPE curve · ⌥ draws a straight line · drag a point to move it": "Dessiner la courbe MPE de la note sélectionnée · ⌥ trace une ligne droite · glisser un point pour le déplacer",
- "Add a point · on a point, delete it · right-click to clear the curve": "Ajouter un point · sur un point, le supprimer · clic droit pour effacer la courbe",
- "Double-click in an MPE lane": "Double-clic dans un couloir MPE",
- "Click the Bend lane's range": "Clic sur l’amplitude du couloir Bend",
- "Pick how far the Bend lane reaches: ±2, 12, 24, 48 or 96 semitones · a bend already on the notes can widen it further": "Choisir l’amplitude du couloir Bend : ±2, 12, 24, 48 ou 96 demi-tons · un bend déjà présent sur les notes peut l’élargir davantage",
- "Click the controller tab": "Clic sur l’onglet de contrôleur",
- "Show a MIDI controller under the notes · click it again to pick another CC, the pitch wheel or channel pressure": "Afficher un contrôleur MIDI sous les notes · cliquer à nouveau pour choisir un autre CC, la molette de hauteur ou la pression de canal",
- "Drag in the Sustain lane": "Glisser dans le couloir Sustain",
- "Draw a pedal block on the grid · ⌘ off the grid · drag an edge to resize, the body to move · double-click or Delete removes it": "Dessiner un bloc de pédale sur la grille · ⌘ hors de la grille · glisser un bord pour redimensionner, le corps pour déplacer · double-clic ou Delete le supprime",
- "Drag in a controller lane": "Glisser dans un couloir de contrôleur",
- "Draw the controller's curve · ⌥ draws a straight line · drag a point to move it · double-click adds or deletes a point": "Dessiner la courbe du contrôleur · ⌥ trace une ligne droite · glisser un point pour le déplacer · double-clic ajoute ou supprime un point",
- "Click a clip in the clip strip": "Clic sur un clip du bandeau de clips",
- "Make it the active clip (several clips open) · its lock keeps it as a read-only reference": "En faire le clip actif (plusieurs clips ouverts) · son verrou le garde comme référence en lecture seule",
- "Zoom rows (vertical zoom)": "Zoom des rangées (zoom vertical)",
- "Click a key": "Clic sur une touche",
- "Play it on the track's instrument · ⇧-drag glides through the keys · ⌘-click selects every note of that pitch": "La jouer sur l’instrument de la piste · ⇧-glisser parcourt les touches · ⌘-clic sélectionne toutes les notes de cette hauteur",
- "Drag on the keys": "Glisser sur les touches",
- "Zoom rows · down taller, up shorter": "Zoom des rangées · vers le bas plus hautes, vers le haut plus basses",
- "Zoom rows (trackpad)": "Zoom des rangées (trackpad)",
- "Fit to notes": "Ajuster aux notes",
- "Fold: only the scale's notes, or a Drum Rack's pads": "Replier : seulement les notes de la gamme, ou les pads d’un Drum Rack",
- "Audio clip editor": "Éditeur de clips audio",
- "Move the playhead there · drag to scrub · snapped to the grid on a warped clip, ⌥ off it": "Y déplacer la tête de lecture · glisser pour balayer · calé sur la grille sur un clip warpé, ⌥ hors de la grille",
- "Scrub the playhead": "Balayer avec la tête de lecture",
- "Add a warp marker · on a marker, delete it": "Ajouter un marqueur de warp · sur un marqueur, le supprimer",
- "Double-click the wave": "Double-clic sur la forme d’onde",
- "Align the audio to the grid · the wave stretches as you drag": "Aligner l’audio sur la grille · la forme d’onde s’étire pendant le glissement",
- "Drag a warp marker": "Glisser un marqueur de warp",
- "While dragging a warp marker or a segment tempo: put it back": "Pendant le glissement d’un marqueur de warp ou d’un tempo de segment : le remettre en place",
- "Drag · double-click Tempo": "Glisser · double-clic sur Tempo",
- "Play notes (computer keyboard)": "Jouer des notes (clavier de l’ordinateur)",
- "White keys, from C4": "Touches blanches, à partir de C4",
- "Black keys (sharps)": "Touches noires (dièses)",
- "Shift octave down / up": "Octave vers le bas / vers le haut",
- "Lower / raise velocity": "Baisser / augmenter la vélocité",
- "Browser · preview": "Navigateur · aperçu",
- "Move through samples, presets and devices · with Auto on, each one plays as it is selected": "Parcourir les échantillons, les préréglages et les appareils · avec Auto activé, chacun est joué dès qu’il est sélectionné",
- "Click play button": "Clic sur le bouton de lecture",
- "Click waveform": "Clic sur la forme d’onde",
- "Play from that point": "Lire à partir de ce point",
- "Click WAVE / SPEC": "Clic sur WAVE / SPEC",
- "Switch the well between the waveform and a live spectrum": "Basculer la zone entre la forme d’onde et un spectre en direct",
- "Scroll on the track button": "Défiler sur le bouton de piste",
- "Step through the demo tracks an effect preset is heard through": "Parcourir les pistes de démonstration à travers lesquelles un préréglage d’effet s’écoute",
- "Type the preview volume · double-click resets it to 0 dB": "Saisir le volume d’aperçu · double-clic le remet à 0 dB",
- "Gamepad (macOS)": "Manette (macOS)",
- "Play C4 D4 E4 F4": "Jouer C4 D4 E4 F4",
- "Play G4 A4 B4 C5": "Jouer G4 A4 B4 C5",
- "Shift the gamepad octave": "Changer l’octave de la manette",
- "Any button": "N’importe quel bouton",
- "Mappable through MIDI Learn — a mapped button drives the control instead": "Assignable par MIDI Learn : un bouton assigné pilote la commande à la place",
- "Mappable as continuous controls (a knob, a fader); they play no notes": "Assignables comme commandes continues (un bouton rotatif, un fader) ; ils ne jouent aucune note",
- "Sticks · triggers": "Sticks · gâchettes",
- "Mouse": "Souris",
- "Double-click clip": "Double-clic sur un clip",
- "Open in the clip editor, opening the detail panel · on one of several selected MIDI clips, open them all together": "Ouvrir dans l’éditeur de clips, en ouvrant le panneau de détail · sur l’un de plusieurs clips MIDI sélectionnés, les ouvrir tous ensemble",
- "Double-click a track header": "Double-clic sur un en-tête de piste",
- "Open its devices in the detail panel · a plug-in's own window is Open editor on its card": "Ouvrir ses appareils dans le panneau de détail · la fenêtre d’un plug-in s’ouvre avec Open editor sur sa carte",
- "Double-click a browser instrument": "Double-clic sur un instrument du navigateur",
- "Swap it onto the selected instrument track · clips and effects stay · no track selected starts one": "L’échanger sur la piste d’instrument sélectionnée · les clips et les effets restent · sans piste sélectionnée, en crée une",
- "Always start a new track with it": "Toujours créer une nouvelle piste avec lui",
- "Right-click the metronome": "Clic droit sur le métronome",
- "Drag an audio clip's ADSR handle": "Glisser la poignée ADSR d’un clip audio",
- "Shape attack · decay + sustain · release (top corners and the dot on hover) · ⌥-click types the stage · double-click resets it": "Façonner l’attaque · le déclin + le maintien · le relâchement (coins du haut et point au survol) · ⌥-clic permet de saisir l’étape · double-clic la réinitialise",
- "Add the track to the selection · again to remove it": "Ajouter la piste à la sélection · de nouveau pour la retirer",
- "Right-click track headers": "Clic droit sur les en-têtes de piste",
- "Drag a track's bottom edge": "Glisser le bord inférieur d’une piste",
- "Drag a track's bottom edge + ⌥": "Glisser le bord inférieur d’une piste + ⌥",
- "Resize every track at once": "Redimensionner toutes les pistes à la fois",
- "Back to the standard height": "Retour à la hauteur standard",
- "Double-click a track's bottom edge": "Double-clic sur le bord inférieur d’une piste",
- "Drag a return's or the master's bottom edge": "Glisser le bord inférieur d’un retour ou du master",
- "Resize that row (header or lane) · same snaps · double-click goes back to compact": "Redimensionner cette rangée (en-tête ou couloir) · mêmes crans · double-clic revient à compact",
- "Select several returns · they resize together": "Sélectionner plusieurs retours · ils se redimensionnent ensemble",
- "Set every track to Compact · Standard · Large": "Mettre toutes les pistes en Compact · Standard · Grand",
- "Drag the track-list edge": "Glisser le bord de la liste des pistes",
- "Widen or narrow the track headers · double-click resets": "Élargir ou rétrécir les en-têtes de piste · double-clic réinitialise",
- "Drag sections lane": "Glisser dans le couloir des sections",
- "Mark a new section over the dragged bars": "Marquer une nouvelle section sur les mesures parcourues",
- "Click section": "Clic sur une section",
- "Jump the playhead to its start": "Placer la tête de lecture à son début",
- "Double-click section": "Double-clic sur une section",
- "Rename it · right-click → Reset to default name for its automatic Section N": "La renommer · clic droit → « Rétablir le nom par défaut » pour sa « Section N » automatique",
- "Return · Esc (renaming a section)": "Return · Esc (renommage d’une section)",
- "Drag section": "Glisser une section",
- "Rearrange the song · it and everything in it move to the marked boundary, the sections between close up · Esc cancels": "Réorganiser le morceau · la section et tout ce qu’elle contient vont à la limite marquée, les sections entre elles se resserrent · Esc annule",
- "⌥-drag section": "⌥-glisser une section",
- "Move only the section marker, snapped to bars": "Déplacer seulement le repère de la section, calé sur les mesures",
- "Drag section edge": "Glisser le bord d’une section",
- "Right-click section": "Clic droit sur une section",
- "Move earlier / later · duplicate or delete with content": "Déplacer plus tôt / plus tard · dupliquer ou supprimer avec le contenu",
- "Drag overview strip": "Glisser le bandeau d’aperçu",
- "Drag overview edge": "Glisser le bord de l’aperçu",
- "Zoom by resizing the viewport window": "Zoomer en redimensionnant la fenêtre de visualisation",
- "Double-click overview": "Double-clic sur l’aperçu",
- "Fit the whole project on screen": "Ajuster tout le projet à l’écran",
- "Drag a device header": "Glisser l’en-tête d’un appareil",
- "Right-click a device header": "Clic droit sur l’en-tête d’un appareil",
- "Delete (device selected)": "Delete (appareil sélectionné)",
- "Remove the selected device — the header no longer carries a close button": "Supprimer l’appareil sélectionné : l’en-tête n’a plus de bouton de fermeture",
- "Drag an audio clip onto an instrument track": "Glisser un clip audio sur une piste d’instrument",
- "Load its audio into the Sampler, Grain, Drum Rack (next free pad) or Instrument Rack · rest there to open its devices": "Charger son audio dans le Sampler, le Grain, le Drum Rack (prochain pad libre) ou l’Instrument Rack · s’y arrêter pour ouvrir ses appareils",
- "Drag an audio clip out of the Arrangement": "Glisser un clip audio hors de l’arrangement",
- "Take it as a sample: drop on a pad, a Grain, a Rhythm voice, a Session slot — the clip stays put": "Le prendre comme échantillon : le déposer sur un pad, un Grain, une voix Rhythm, un emplacement Session ; le clip reste en place",
- "Drag clip + ⌥": "Glisser un clip + ⌥",
- "Position freely, ignoring the grid for this drag (the magnet in the transport latches the same thing)": "Positionner librement, sans tenir compte de la grille pour ce glissement (l’aimant du transport verrouille la même chose)",
- "Scroll it sideways · over an EQ band's handle the wheel sets its Q, over a value box it steps the value": "Le faire défiler latéralement · sur la poignée d’une bande d’EQ, la molette règle son Q ; sur une case de valeur, elle change la valeur par pas",
- "Wheel over the device chain": "Molette sur la chaîne d’appareils",
- "Change a device value · hold ⌘ or ⇧ for fine steps": "Changer une valeur d’appareil · maintenir ⌘ ou ⇧ pour des pas fins",
- "Drag knob": "Glisser un bouton rotatif",
- "Drag slider": "Glisser un curseur",
- "Type a value (units like k, ms, dB, L / R work) · double-click its value does the same": "Saisir une valeur (les unités comme k, ms, dB, L / R fonctionnent) · un double-clic sur sa valeur fait de même",
- "Return · Esc · Tab / ⇧Tab (typing a value)": "Return · Esc · Tab / ⇧Tab (saisie d’une valeur)",
- "Set it · cancel · set it and type the next / previous value on the card": "La valider · annuler · la valider et saisir la valeur suivante / précédente de la carte",
- "Type its values — a node with several (frequency · gain · Q, decay · sustain) takes Tab between them": "Saisir ses valeurs : un nœud qui en a plusieurs (fréquence · gain · Q, déclin · maintien) utilise Tab pour passer de l’une à l’autre",
- "Double-click a knob, fader or slider": "Double-clic sur un bouton rotatif, un fader ou un curseur",
- "Reset the value to its default": "Remettre la valeur par défaut",
- "Clear the route (Volt, Aurora) · pull the cable (Consort)": "Effacer la route (Volt, Aurora) · retirer le câble (Consort)",
- "Double-click a mod-matrix cell": "Double-clic sur une cellule de la matrice de modulation",
- "Right-click a knob, fader or slider": "Clic droit sur un bouton rotatif, un fader ou un curseur",
- "Type value… · Reset to default": "Saisir une valeur… · Rétablir la valeur par défaut",
- "Drag jack → jack": "Glisser jack → jack",
- "Patch a cable in Nota Consort · ⌥-click a jack to pull its cables": "Brancher un câble dans Nota Consort · ⌥-clic sur un jack pour retirer ses câbles",
- "Click · ⇧ · ⌥ a Rhythm step": "Clic · ⇧ · ⌥ sur un pas Rhythm",
- "Click a Rhythm voice": "Clic sur une voix Rhythm",
- "Select and play it · drop a file on it to load a sample": "La sélectionner et la jouer · y déposer un fichier pour charger un échantillon",
- "Filter shortcuts": "Filtrer les raccourcis",
- "Wheel up lowers the velocity": "Molette vers le haut : baisse la vélocité",
- "Velocity wheel": "Molette de vélocité",
- "Direction": "Sens",
- "Step": "Pas",
- "System default": "Par défaut du système",
- "Cancelling…": "Annulation…",
- "Don't save": "Ne pas enregistrer",
- "Save": "Enregistrer",
- "Saving…": "Enregistrement…",
- " Nota never shows files or paths to the phone, and serves nothing from your disk.": " Nota n’affiche jamais de fichiers ni de chemins sur le téléphone, et ne sert rien depuis le disque.",
- "A trusted phone reconnects from its Home Screen icon without a code. Forget it and it has to scan again. Turning Remote off disconnects everyone.": "Un téléphone de confiance se reconnecte depuis l’icône de son écran d’accueil, sans code. L’oublier l’oblige à scanner de nouveau. Désactiver la télécommande déconnecte tout le monde.",
- "Channels 2–16 each carry one note with its own pitch bend, pressure and slide (CC74). A controller that announces its range overrides this one. Channel 1 plays as an ordinary keyboard, its pitch wheel and aftertouch moving the whole instrument. ": "Les canaux 2 à 16 portent chacun une note avec son propre pitch bend, sa pression et son glissement (CC74). Un contrôleur qui annonce son amplitude remplace celle-ci. Le canal 1 se joue comme un clavier ordinaire, sa molette de hauteur et son aftertouch agissant sur tout l’instrument. ",
- "Nota Synth, Volt, Aurora, Operator, Pentad and Physical play per-note expression.": "Nota Synth, Volt, Aurora, Operator, Pentad et Physical jouent l’expression par note.",
- "⌥-drag a device onto a track": "⌥-glisser un appareil sur une piste",
- "⇧ + wheel over a note": "⇧ + molette sur une note",
- "⇧-click track header": "⇧-clic sur un en-tête de piste",
- "⌥-click a height key in the track menu": "⌥-clic sur une touche de hauteur dans le menu de piste",
- "⌥-click a knob, fader or slider": "⌥-clic sur un bouton rotatif, un fader ou un curseur",
- "⌥-click a graph handle, envelope node or mod-matrix cell": "⌥-clic sur une poignée de graphique, un nœud d’enveloppe ou une cellule de la matrice de modulation",
- "⇧ + wheel over a note in the piano roll changes its velocity, or the whole selection's when that note is selected: one MIDI step per notch at 1×. Anywhere else ⇧ + wheel scrolls, and Off leaves it scrolling everywhere.": "⇧ + molette sur une note du piano roll change sa vélocité, ou celle de toute la sélection si cette note est sélectionnée : un pas MIDI par cran à 1×. Partout ailleurs, ⇧ + molette fait défiler, et « Désactivé » la laisse défiler partout.",
- "Nota": "Nota",
- "Version {0}": "Version {0}",
- "Engine {0}": "Moteur {0}",
- "Desktop DAW · AGPLv3": "DAW de bureau · AGPLv3",
- "© 2026 Egor Khindikaynen (Ambertape)": "© 2026 Egor Khindikaynen (Ambertape)",
- "Free software under the GNU AGPLv3.": "Logiciel libre sous licence GNU AGPLv3.",
- "Includes third-party software (JUCE, Avalonia, miniaudio, RtMidi, dr_libs, Signalsmith, HIIR). See LICENSES/THIRD-PARTY-NOTICES.md for copyright and attribution notices.": "Inclut des logiciels tiers (JUCE, Avalonia, miniaudio, RtMidi, dr_libs, Signalsmith, HIIR). Voir LICENSES/THIRD-PARTY-NOTICES.md pour les mentions de droits d’auteur et d’attribution.",
- "Search actions, tracks, devices, presets…": "Rechercher des actions, pistes, appareils, préréglages…",
- "1 result": "1 résultat",
- "{0} results": "{0} résultats",
- "Showing results for ": "Résultats pour ",
- " · typed in the other keyboard layout": " · saisi dans l’autre disposition de clavier",
- "Nothing matches. Try a role (reverb, comp), a character (warm, dark) or a source (vocals, drums).": "Aucun résultat. Essayer un rôle (reverb, comp), un caractère (warm, dark) ou une source (vocals, drums).",
- "run": "exécuter",
- "open in Devices": "ouvrir dans Appareils",
- "select": "sélectionner",
- "add & stay": "ajouter et rester",
- "add to canvas": "ajouter au canevas",
- "load": "charger",
- "new track": "nouvelle piste",
- "insert": "insérer",
- "replace": "remplacer",
- "filter": "filtrer",
- "Missing plugins": "Plug-ins manquants",
- "This project uses {0}, which isn't installed. It's open source and available from the Nota plugin registry. Install and reopen the project?": "Ce projet utilise {0}, qui n’est pas installé. Il est open source et disponible dans le registre de plug-ins de Nota. L’installer et rouvrir le projet ?",
- "This project uses {0}, which aren't installed. They're open source and available from the Nota plugin registry. Install and reopen the project?": "Ce projet utilise {0}, qui ne sont pas installés. Ils sont open source et disponibles dans le registre de plug-ins de Nota. Les installer et rouvrir le projet ?",
- "Not now": "Pas maintenant",
- "Installing plugins…": "Installation des plug-ins…",
- "Scanning plugins…": "Analyse des plug-ins…",
- "Installed {0} — reopen the project to use it.": "{0} installé — rouvrir le projet pour l’utiliser.",
- "Installed {0} — reopen the project to use them.": "{0} installés — rouvrir le projet pour les utiliser.",
- "Not available": "Indisponible",
- "Master": "Master",
- "Opened {0} in Devices": "{0} ouvert dans Appareils",
- "Selected {0}": "{0} sélectionné",
- "Couldn't add {0}.": "Impossible d’ajouter {0}.",
- "{0} added to the {1} canvas — connect it to a parameter": "{0} ajouté au canevas {1} — le relier à un paramètre",
- "Unsaved changes": "Modifications non enregistrées",
- "Do you really want to quit without saving your changes?": "Quitter sans enregistrer les modifications ?",
- "unsaved changes · {0}": "modifications non enregistrées · {0}",
- "Nota didn't shut down cleanly. Recover unsaved work from {0}?": "Nota ne s’est pas fermé correctement. Récupérer le travail non enregistré de {0} ?",
- "Recovered unsaved work.": "Travail non enregistré récupéré.",
- "Recover project": "Récupérer le projet",
- "Discard": "Ignorer",
- "Recover": "Récupérer",
- "Arrangement": "Arrangement",
- "Stop (Return)": "Arrêter (Return)",
- "Play (Space)": "Lire (Space)",
- "Record (⌘R)": "Lancer l’enregistrement (⌘R)",
- "Switch between bars and time": "Basculer entre mesures et temps",
- "Loop the range set on the ruler": "Mettre en boucle la plage définie sur la règle",
- "Loop recording: Overdub adds every pass · Replace keeps the latest pass (⌘⇧R)": "Enregistrement en boucle : Superposer ajoute chaque passage · Remplacer garde le dernier passage (⌘⇧R)",
- "Overdub": "Superposer",
- "Replace": "Remplacer",
- "Set the tempo — drag, or double-click to type": "Régler le tempo : glisser, ou double-clic pour le saisir",
- "Tap the beat to set the tempo": "Taper le rythme pour régler le tempo",
- "Tap": "Tap",
- "Set the time signature — drag each field": "Régler la signature rythmique : glisser chaque champ",
- "Set the project key — samples can be transposed to it": "Régler la tonalité du projet : les échantillons peuvent y être transposés",
- "Key": "Tonalité",
- "Turn the metronome on or off (⌘M) · right-click for count-in": "Activer ou désactiver le métronome (⌘M) · clic droit pour le décompte",
- "Snap clips to the grid (hold Alt to drag freely)": "Caler les clips sur la grille (maintenir Alt pour déplacer librement)",
- "Re-enable": "Réactiver",
- "Hand overridden controls back to their automation": "Rendre les commandes modifiées à leur automation",
- "Map a controller — click a control, then move a knob on the controller": "Assigner un contrôleur : cliquer sur une commande, puis bouger un bouton du contrôleur",
- "Play and control Nota from a phone": "Jouer et piloter Nota depuis un téléphone",
- "Sample rate and buffer size. Click to change the buffer size": "Fréquence d’échantillonnage et taille du tampon. Cliquer pour changer la taille du tampon",
- "View release notes": "Voir les notes de version",
- "Strips": "Tranches",
- "Stereo map": "Carte stéréo",
- "Open the mixer in a window": "Ouvrir le mixeur dans une fenêtre",
- "Hide the mixer": "Masquer le mixeur",
- "Pattern": "Motif",
- "Step the selected MIDI clip on a Drum Rack track": "Programmer pas à pas le clip MIDI sélectionné d’une piste Drum Rack",
- "Clip": "Clip",
- "Select a clip to edit it": "Sélectionner un clip pour l’éditer",
- "Freeze the track to audio to free CPU (right-click to flatten)": "Geler la piste en audio pour libérer du CPU (clic droit pour aplatir)",
- "Freeze": "Geler",
- "Bounce to a linked audio track below and put the source to sleep": "Rendre vers une piste audio liée en dessous et mettre la source en veille",
- "Live freeze": "Gel en direct",
- "Wake the frozen source to edit it (right-click to unfreeze or flatten)": "Réveiller la source gelée pour l’éditer (clic droit pour dégeler ou aplatir)",
- "Re-freeze the source and put it back to sleep": "Regeler la source et la remettre en veille",
- "Done": "Terminé",
- "Leave edit mode without re-freezing": "Quitter le mode édition sans regeler",
- "Fill the window with the clip editor (⌘⇧F)": "Remplir la fenêtre avec l’éditeur de clips (⌘⇧F)",
- "Open devices and clip in a separate window": "Ouvrir les appareils et le clip dans une fenêtre séparée",
- "Close": "Fermer",
- "Play": "Lecture",
- "Stop": "Arrêt",
- "Convert to MIDI": "Convertir en MIDI",
- "Convert Melody and Convert Harmony now use the AI model.": "« Convertir la mélodie » et « Convertir l’harmonie » utilisent désormais le modèle d’IA.",
- "Master volume": "Volume master",
- "Master Volume": "Volume master",
- "DSP {0}%": "DSP {0}%",
- "Bass": "Basse",
- "Drums": "Batterie",
- "Pad": "Pad",
- "Instrument track {0} (synth)": "Piste d’instrument {0} (synthé)",
- "Audio track {0} — arm it and hit Rec to record input": "Piste audio {0} — l’armer puis appuyer sur Rec pour enregistrer l’entrée",
- "All return buses are in use.": "Tous les bus de retour sont utilisés.",
- "Return {0} added — add an effect, then dial up track sends": "Retour {0} ajouté — ajouter un effet, puis augmenter les envois des pistes",
- "No key": "Aucune tonalité",
- "No project key": "Aucune tonalité de projet",
- "Project key: {0}": "Tonalité du projet : {0}",
- "measuring…": "mesure…",
- "DSP load: {0} of the audio buffer time — dropouts start near 100 %": "Charge DSP : {0} du temps de tampon audio — les décrochages commencent près de 100 %",
- "Nota process CPU: {0} (audio, interface, plugins)": "CPU du processus Nota : {0} (audio, interface, plug-ins)",
- "Tempo: {0} BPM (tapped)": "Tempo : {0} BPM (tapé)",
- "Follow playhead off": "Suivi de la tête de lecture désactivé",
- "Following the playhead": "Suivi de la tête de lecture",
- "Note audition off": "Écoute des notes désactivée",
- "Note audition on": "Écoute des notes activée",
- "Follow is paused while you look elsewhere · P or a click here picks it up again": "Le suivi est en pause pendant la consultation d’un autre endroit · P ou un clic ici le reprend",
- "Scroll the arrangement to keep the playhead in view": "Faire défiler l’arrangement pour garder la tête de lecture visible",
- "Follow paused · press P to go back to the playhead": "Suivi en pause · appuyer sur P pour revenir à la tête de lecture",
- "Snap off — clips position freely": "Magnétisme désactivé — les clips se placent librement",
- "Snap on": "Magnétisme activé",
- "Listening on {0}": "Écoute sur {0}",
- "Auto · {0}": "Auto · {0}",
- "Auto grid": "Grille auto",
- "Snap off — items move freely (⌘4)": "Magnétisme désactivé — les éléments se déplacent librement (⌘4)",
- "{0} — finer than the visible grid · zoom in to see it": "{0} — plus fin que la grille visible · zoomer pour la voir",
- "Snap grid · Auto follows the zoom ({0})": "Grille magnétique · Auto suit le zoom ({0})",
- "Snap grid · fixed {0}": "Grille magnétique · fixe {0}",
- "{0}\n{1} · hold ⌥ to drag freely": "{0}\n{1} · maintenir ⌥ pour déplacer librement",
- "Triplets": "Triolets",
- "Welcome to Nota": "Bienvenue dans Nota",
- "Version {0} · Engine {1} · Desktop DAW": "Version {0} · Moteur {1} · DAW de bureau",
- "New project": "Nouveau projet",
- "Open project…": "Ouvrir un projet…",
- "Recent projects": "Projets récents",
- "No recent projects": "Aucun projet récent",
- "Show on startup": "Afficher au démarrage",
- "What's New": "Nouveautés",
- "Nota {0} is ready to install": "Nota {0} est prêt à être installé",
- "Restart Nota to finish updating — or it installs the next time you quit.": "Redémarrer Nota pour terminer la mise à jour — ou elle s’installe à la prochaine fermeture.",
- "The update didn't download": "La mise à jour n’a pas pu être téléchargée",
- "Dismiss": "Ignorer",
- "A new version of Nota is available": "Une nouvelle version de Nota est disponible",
- "Nota {0} is out — you have {1}.": "Nota {0} est disponible — la version installée est la {1}.",
- "Release notes": "Notes de version",
- "Unsaved work available": "Travail non enregistré disponible",
- "Opening…": "Ouverture…",
- "What's new in Nota": "Nouveautés de Nota",
- "No release notes available.": "Aucune note de version disponible.",
- "Nota {0}": "Nota {0}",
- "Got it": "Compris",
- "All changes": "Toutes les modifications",
- "Save project": "Enregistrer le projet",
- "Save project as…": "Enregistrer le projet sous…",
- "Exit Nota": "Quitter Nota",
- "Activate / deactivate clip": "Activer / désactiver le clip",
- "Show Arrangement": "Afficher l’arrangement",
- "Show Session": "Afficher la vue Session",
- "Show Modular": "Afficher la vue Modular",
- "Show Mixer": "Afficher le mixeur",
- "Show devices": "Afficher les appareils",
- "Open devices in a window": "Ouvrir les appareils dans une fenêtre",
- "Reset section name": "Rétablir le nom de la section",
- "Cycle clip names": "Faire défiler les noms de clips",
- "Show version history": "Afficher l’historique des versions",
- "MIDI learn": "Apprentissage MIDI",
- "Toggle loop": "Activer / désactiver la boucle",
- "Tap tempo": "Tap tempo",
- "New MIDI track": "Nouvelle piste MIDI",
- "Track": "Piste",
- "New audio track": "Nouvelle piste audio",
- "New return track": "Nouvelle piste de retour",
- "Group tracks": "Grouper les pistes",
- "Ungroup tracks": "Dégrouper les pistes",
- "Freeze track": "Geler la piste",
- "Launch scene": "Lancer la scène",
- "Session": "Session",
- "Stop all clips": "Arrêter tous les clips",
- "Quantize notes": "Quantifier les notes",
- "Transpose notes up an octave": "Transposer les notes d’une octave vers le haut",
- "Transpose notes down an octave": "Transposer les notes d’une octave vers le bas",
- "Remove out-of-scale notes": "Supprimer les notes hors gamme",
- "Fold the piano roll": "Replier le piano roll",
- "Edit selected clips together": "Éditer ensemble les clips sélectionnés",
- "Toggle clip editor track mode": "Activer / désactiver le mode piste de l’éditeur de clips",
- "Toggle triplet grid": "Activer / désactiver la grille en triolets",
- "Toggle snap to grid": "Activer / désactiver le magnétisme sur la grille",
- "Toggle adaptive grid": "Activer / désactiver la grille adaptative",
- "Actions": "Actions",
- "Tracks": "Pistes",
- "Modular": "Modular",
- "Presets": "Préréglages",
- "Suggested · {0}": "Suggestions · {0}",
- "Device window": "Fenêtre d’appareil",
- "Changed instrument to {0} (track {1})": "Instrument remplacé par {0} (piste {1})",
- "A Drum Rack takes kits and instruments; load an instrument preset on a pad from its card.": "Un Drum Rack accepte des kits et des instruments ; charger un préréglage d’instrument sur un pad depuis sa carte.",
- "Select a track first.": "Sélectionner d’abord une piste.",
- "Changed instrument to {0}": "Instrument remplacé par {0}",
- "MIDI effects need an instrument track.": "Les effets MIDI nécessitent une piste d’instrument.",
- "Added {0} to track {1}": "{0} ajouté à la piste {1}",
- "Replaced with {0}": "Remplacé par {0}",
- "Added {0} chain": "Chaîne {0} ajoutée",
- "All 16 pads are used.": "Les 16 pads sont utilisés.",
- "Added {0} pad": "Pad {0} ajouté",
- "Loaded {0}": "{0} chargé",
- "Loaded {0} · root {1}": "{0} chargé · fondamentale {1}",
- "Drop samples onto the arrangement.": "Déposer des échantillons sur l’arrangement.",
- "Drop MIDI files onto the arrangement or a session slot.": "Déposer des fichiers MIDI sur l’arrangement ou un emplacement de session.",
- "Drop onto a track.": "Déposer sur une piste.",
- "Failed to load effect.": "Échec du chargement de l’effet.",
- "{0} can't go on a track.": "{0} ne peut pas aller sur une piste.",
- "MIDI effects need an instrument track: add an instrument first.": "Les effets MIDI nécessitent une piste d’instrument : ajouter d’abord un instrument.",
- "Couldn't add a track for {0}.": "Impossible d’ajouter une piste pour {0}.",
- "Added {0} on a new audio track (track {1})": "{0} ajouté sur une nouvelle piste audio (piste {1})",
- "Applied preset {0}": "Préréglage {0} appliqué",
- "Presets are unavailable.": "Les préréglages ne sont pas disponibles.",
- "Kits are unavailable.": "Les kits ne sont pas disponibles.",
- "Loaded {0} kit": "Kit {0} chargé",
- "Drop failed: {0}": "Échec du dépôt : {0}",
- "Select devices next to each other to group them": "Sélectionner des appareils côte à côte pour les grouper",
- "MIDI and audio effects go in one rack only with the instrument between them": "Les effets MIDI et audio ne vont dans un même rack qu’avec l’instrument entre eux",
- "Track {0}": "Piste {0}",
- "Group": "Groupe",
- "MIDI · {0}": "MIDI · {0}",
- "MIDI FX": "Effets MIDI",
- "Audio FX": "Effets audio",
- "Kits": "Kits",
- "Preset": "Préréglage",
- "Modular · {0}": "Modular · {0}",
- "Audio: driver settings changed · {0} frames": "Audio : réglages du pilote modifiés · {0} échantillons",
- "⚠ Audio dropout ({0})": "⚠ Décrochage audio ({0})",
- "Audio dropouts since the device started: buffers Nota couldn't fill in time, heard as clicks or gaps. If they keep coming, raise the buffer size or freeze heavy tracks. Click to reset": "Décrochages audio depuis le démarrage du périphérique : des tampons que Nota n’a pas pu remplir à temps, audibles sous forme de claquements ou de trous. S’ils persistent, augmenter la taille du tampon ou geler les pistes lourdes. Cliquer pour réinitialiser",
- "{0} · drag or turn to change, double-click to type": "{0} · glisser ou tourner pour modifier, double-clic pour saisir",
- "Close the driver's settings window to apply the change": "Fermer la fenêtre de réglages du pilote pour appliquer le changement",
- "Audio device error: {0}": "Erreur du périphérique audio : {0}",
- "Audio: ASIO · {0} · {1:0} Hz · {2} frames": "Audio : ASIO · {0} · {1:0} Hz · {2} échantillons",
- "WASAPI exclusive unavailable — using shared mode": "WASAPI exclusif indisponible — mode partagé utilisé",
- "Audio: {0:0} Hz · {1} frames": "Audio : {0:0} Hz · {1} échantillons",
- "Audio: {0:0} Hz": "Audio : {0:0} Hz",
- "ASIO driver ‘{0}’ couldn't start — using WASAPI. {1}": "Le pilote ASIO ‘{0}’ n’a pas pu démarrer — WASAPI utilisé. {1}",
- "No audio output could be opened — Nota runs without sound. Choose a device in Settings → Audio": "Aucune sortie audio n’a pu être ouverte — Nota fonctionne sans son. Choisir un périphérique dans Réglages → Audio",
- "No audio output device opened — Nota runs silently. Choose a device in Settings → Audio": "Aucun périphérique de sortie audio ouvert — Nota fonctionne en silence. Choisir un périphérique dans Réglages → Audio",
- "MIDI inputs updated.": "Entrées MIDI mises à jour.",
- "MIDI error: {0}": "Erreur MIDI : {0}",
- "Can't record: arm a track first (click Arm on a track header).": "Enregistrement impossible : armer d’abord une piste (cliquer sur Armer dans l’en-tête d’une piste).",
- "Can't record: no audio input — grant microphone access (needs a bundled app).": "Enregistrement impossible : aucune entrée audio — autoriser l’accès au microphone (nécessite une app empaquetée).",
- "Recording didn't start.": "L’enregistrement n’a pas démarré.",
- "Paused · Play carries on from here": "En pause · la lecture reprend à partir d’ici",
- "First save": "Premier enregistrement",
- "First save · {0} tracks": {
- "one": "Premier enregistrement · {0} piste",
- "other": "Premier enregistrement · {0} pistes"
- },
- "Added {0}": "{0} ajouté",
- "Removed {0}": "{0} supprimé",
- "Tempo {0} → {1}": "Tempo {0} → {1}",
- "New audio": "Nouvel audio",
- "{0} new audio files": "{0} nouveaux fichiers audio",
- "Edited {0}": "{0} modifié",
- "Devices on {0}": "Appareils sur {0}",
- "Mix of {0}": "Mixage de {0}",
- "Mix of {0} tracks": {
- "one": "Mixage de {0} piste",
- "other": "Mixage de {0} pistes"
- },
- "Settings: Audio": "Réglages : Audio",
- "Settings: MIDI": "Réglages : MIDI",
- "Settings: Gamepads": "Réglages : Manettes",
- "Settings: Remote": "Réglages : Télécommande",
- "Settings: Plug-ins": "Réglages : Plug-ins",
- "Settings: Downloads": "Réglages : Téléchargements",
- "Settings: Library": "Réglages : Bibliothèque",
- "Settings: Appearance": "Réglages : Apparence",
- "Settings: Shortcuts": "Réglages : Raccourcis",
- "Settings: Updates": "Réglages : Mises à jour",
- "Devices|settings": "Périphériques",
- "indexing {0}… {1} %": "indexation de {0}… {1} %",
- "1 item": "1 élément",
- "{0} items": "{0} éléments",
- "MIDI effects need an instrument track": "Les effets MIDI nécessitent une piste d’instrument",
- " · keep open": " · garder ouvert",
- "track {0}": "piste {0}",
- "↵ run": "↵ exécuter",
- "→ open {0} in Devices": "→ ouvrir {0} dans Appareils",
- "→ select {0} in {1}": "→ sélectionner {0} dans {1}",
- "canvas, unconnected": "canevas, non connecté",
- "→ {0} · {1}{2}": "→ {0} · {1}{2}",
- "loads the kit": "charge le kit",
- "→ new track{0}": "→ nouvelle piste{0}",
- "→ new MIDI track{0}": "→ nouvelle piste MIDI{0}",
- "instrument": "instrument",
- "replaces {0}": "remplace {0}",
- "new pad in Drum Rack": "nouveau pad dans Drum Rack",
- "new chain in Instrument Rack": "nouvelle chaîne dans Instrument Rack",
- "replaces the instrument": "remplace l’instrument",
- "after {0}": "après {0}",
- "end of Audio FX": "fin des effets audio",
- "end of MIDI FX": "fin des effets MIDI",
- "MIDI FX, end": "effets MIDI, fin",
- "end of chain": "fin de la chaîne",
- "Copy automation": "Copier l’automation",
- "Cut automation": "Couper l’automation",
- "Paste automation": "Coller l’automation",
- "Delete automation": "Supprimer l’automation",
- "Vol": "Vol",
- "Pan": "Pan",
- "Param": "Param",
- "Volume": "Volume",
- "Band {0}": "Bande {0}",
- "Stage {0}": "Étape {0}",
- "Choose parameter…": "Choisir un paramètre…",
- "Learn (touch a control in the plugin)": "Apprendre (toucher une commande dans le plug-in)",
- "Filter parameters…": "Filtrer les paramètres…",
- "Turn loop off": "Désactiver la boucle",
- "Turn loop on": "Activer la boucle",
- "Loop selection": "Boucler la sélection",
- "Clear loop region": "Effacer la région de boucle",
- "click to add master volume points": "cliquer pour ajouter des points de volume master",
- "Unfold the group to move these clips across tracks": "Déplier le groupe pour déplacer ces clips entre les pistes",
- "No track above takes these clips": "Aucune piste au-dessus n’accepte ces clips",
- "No track below takes these clips": "Aucune piste en dessous n’accepte ces clips",
- "Moved across tracks — device automation stayed on the source": "Déplacé entre les pistes — l’automation des appareils est restée sur la source",
- "Release to load the clip into {0}": "Relâcher pour charger le clip dans {0}",
- "Couldn't take the clip's audio: {0}": "Impossible de récupérer l’audio du clip : {0}",
- "Insert MIDI clip": "Insérer un clip MIDI",
- "Consolidate selection": "Consolider la sélection",
- "{0} clips": {
- "one": "{0} clip",
- "other": "{0} clips"
- },
- "Audio clip": "Clip audio",
- "MIDI clip": "Clip MIDI",
- "Rename…": "Renommer…",
- "Split here": "Découper ici",
- "Reverse": "Inverser",
- "Activate": "Activer",
- "Deactivate": "Désactiver",
- "Separate stems…": "Séparer les stems…",
- "Convert": "Convertir",
- "Melody to new MIDI track": "Mélodie vers une nouvelle piste MIDI",
- "Harmony to new MIDI track": "Harmonie vers une nouvelle piste MIDI",
- "Drums to new MIDI track": "Batterie vers une nouvelle piste MIDI",
- "Slice to new MIDI track": "Tranches vers une nouvelle piste MIDI",
- "Get the AI model for melody and harmony…": "Obtenir le modèle d’IA pour la mélodie et l’harmonie…",
- "Copy to Session": "Copier vers Session",
- "Copy to scene": "Copier vers la scène",
- "Scene {0}": "Scène {0}",
- "Rec": "Rec",
- "Add an instrument from the browser": "Ajouter un instrument depuis le navigateur",
- "New track": "Nouvelle piste",
- "Couldn't move the clips to new tracks": "Impossible de déplacer les clips vers de nouvelles pistes",
- "Moved to new tracks — device automation stayed on the source": "Déplacé vers de nouvelles pistes — l’automation des appareils est restée sur la source",
- "Overview": "Aperçu",
- "bar {0}–{1} / {2}": "mesure {0}–{1} / {2}",
- "the project appears here": "le projet apparaît ici",
- "Sections": "Sections",
- "Automatic name": "Nom automatique",
- "Custom name": "Nom personnalisé",
- "Reset to default": "Rétablir par défaut",
- "Back to the automatic name ({0}), which follows the section's position": "Retour au nom automatique ({0}), qui suit la position de la section",
- "No section at the playhead": "Aucune section à la tête de lecture",
- "{0} already has its automatic name": "{0} a déjà son nom automatique",
- "Move section earlier": "Déplacer la section plus tôt",
- "Move section later": "Déplacer la section plus tard",
- "Duplicate section with content": "Dupliquer la section avec son contenu",
- "Delete section with content": "Supprimer la section avec son contenu",
- "Move earlier": "Déplacer plus tôt",
- "Move later": "Déplacer plus tard",
- "Duplicate with content": "Dupliquer avec le contenu",
- "Delete with content": "Supprimer avec le contenu",
- "{0} overlaps another section — separate them to move its content with it": "{0} chevauche une autre section — les séparer pour déplacer son contenu avec elle",
- "{0} is already the last section": "{0} est déjà la dernière section",
- "{0} is already the first section": "{0} est déjà la première section",
- "Couldn't move {0} there": "Impossible de déplacer {0} à cet endroit",
- "Moved {0} later": "{0} déplacée plus tard",
- "Moved {0} earlier": "{0} déplacée plus tôt",
- "Duplicated {0} with its content": "{0} dupliquée avec son contenu",
- "Couldn't duplicate {0}": "Impossible de dupliquer {0}",
- "Deleted {0} with its content": "{0} supprimée avec son contenu",
- "Couldn't delete {0}": "Impossible de supprimer {0}",
- "“{0}” is {1} again": "“{0}” redevient {1}",
- "Reset to default name": "Rétablir le nom par défaut",
- "Loop section": "Boucler la section",
- "Select section": "Sélectionner la section",
- "Add section here": "Ajouter une section ici",
- "Delete all sections": "Supprimer toutes les sections",
- "drag here to mark a section": "glisser ici pour marquer une section",
- "Take {0}": "Prise {0}",
- "Use whole take": "Utiliser la prise entière",
- "Flatten takes": "Aplatir les prises",
- "Delete take": "Supprimer la prise",
- "Hide takes": "Masquer les prises",
- "Show {0} takes": "Afficher {0} prises",
- "{0} tracks": "{0} pistes",
- "Return {0}": "Retour {0}",
- "Compact": "Compact",
- "Large": "Grand",
- "Standard": "Standard",
- "Height": "Hauteur",
- "Zoom": "Zoom",
- "{0} bars": {
- "one": "{0} mesure",
- "other": "{0} mesures"
- },
- "{0:0.##} beats": "{0:0.##} temps",
- "Processing…": "Traitement…",
- "Paste a MIDI clip onto a MIDI track, audio onto audio.": "Coller un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
- "Copied clip to session scene {0}": "Clip copié vers la scène {0} de la session",
- "Copied {0} clips to the session from scene {1}": "{0} clips copiés vers la session à partir de la scène {1}",
- "Add instrument track": "Ajouter une piste d’instrument",
- "Add audio track": "Ajouter une piste audio",
- "Add return track": "Ajouter une piste de retour",
- "Paste track": "Coller la piste",
- "Ext": "Ext",
- "Record input": "Entrée d’enregistrement",
- "None": "Aucune",
- "MIDI from": "MIDI depuis",
- "Add track": "Ajouter une piste",
- "Ungroup": "Dégrouper",
- "In": "Entrée",
- "Monitor input: hear it live through this track": "Écoute de l’entrée : l’entendre en direct à travers cette piste",
- "Monitoring input — click to stop": "Écoute de l’entrée — cliquer pour arrêter",
- "Master can't be monitored (it would feed back)": "Le master ne peut pas être écouté (il y aurait un larsen)",
- "Played from a phone: {0}": "Joué depuis un téléphone : {0}",
- "Beats": "Beats",
- "Complex": "Complex",
- "Complex Pro": "Complex Pro",
- "Texture": "Texture",
- "Tones": "Tones",
- "Length": "Longueur",
- "Start": "Début",
- "Gain": "Gain",
- "Pitch": "Hauteur",
- "Playback": "Lecture",
- "Warp": "Warp",
- "Detect tempo": "Détecter le tempo",
- "Detect the file's tempo and conform it to the project": "Détecter le tempo du fichier et l’adapter au projet",
- "To transients": "Aux transitoires",
- "Pin a marker on every hit so drums lock to the grid": "Placer un marqueur sur chaque attaque pour caler la batterie sur la grille",
- "Detected": "Détecté",
- "Attack": "Attaque",
- "Decay": "Déclin",
- "Sustain": "Maintien",
- "Release": "Relâchement",
- "Reset": "Réinitialiser",
- "Play the whole sample at full level": "Jouer tout l’échantillon à plein niveau",
- "Envelope": "Enveloppe",
- "Sample": "Échantillon",
- "Audio {0}": "Audio {0}",
- "Mono": "Mono",
- "Stereo": "Stéréo",
- "off": "désactivé",
- "The tempo the audio was recorded at. Nota stretches it to the project tempo. ×2 / ÷2 fix a half- or double-time detection.": "Le tempo auquel l’audio a été enregistré. Nota l’étire jusqu’au tempo du projet. ×2 / ÷2 corrigent une détection en demi-temps ou en double temps.",
- "Tempo": "Tempo",
- "Half the tempo — the clip spans half as many beats": "Moitié du tempo — le clip couvre deux fois moins de temps",
- "Double the tempo — the clip spans twice as many beats": "Double du tempo — le clip couvre deux fois plus de temps",
- "Click — point · drag — move · right-click — delete": "Clic — point · glisser — déplacer · clic droit — supprimer",
- "Drag a handle · double-click — reset": "Glisser une poignée · double-clic — réinitialiser",
- "Snap needs Warp — turn on Warp to see the grid and snap to it": "Le magnétisme nécessite Warp — activer Warp pour voir la grille et s’y caler",
- "Double-click the wave — marker · drag — align": "Double-clic sur la forme d’onde — marqueur · glisser — aligner",
- "A Session slot plays on its own loop clock — launch it to play from the start": "Un emplacement de Session joue sur sa propre horloge de boucle — le lancer pour jouer depuis le début",
- "Audio effects": "Effets audio",
- "MIDI effects": "Effets MIDI",
- "Files": "Fichiers",
- "MIDI map": "Carte MIDI",
- "History": "Historique",
- "Track inspector": "Inspecteur de piste",
- "Collapse browser": "Replier le navigateur",
- "Expand browser": "Déplier le navigateur",
- "No matches yet": "Aucun résultat pour l’instant",
- "Nota is still analysing your samples — more matches appear as it goes.": "Nota analyse encore les échantillons — d’autres résultats apparaissent au fur et à mesure.",
- "No matches": "Aucun résultat",
- "Try a different search or clear the filters.": "Essayer une autre recherche ou effacer les filtres.",
- "No instruments yet": "Aucun instrument pour l’instant",
- "No audio effects yet": "Aucun effet audio pour l’instant",
- "Arpeggiator, chord, scale and more — they process notes before an instrument; drop one to the left of an instrument in a track.": "Arpégiateur, accord, gamme et plus — ils traitent les notes avant un instrument : en déposer un à gauche d’un instrument dans une piste.",
- "No MIDI effects yet": "Aucun effet MIDI pour l’instant",
- "Add audio files to your Samples folder (Settings → Library) or install free packs from Settings → Downloads → Sample packs, then browse them here as a folder tree. You can also drag files in from Finder.": "Ajouter des fichiers audio au dossier d’échantillons (Réglages → Bibliothèque) ou installer des packs gratuits depuis Réglages → Téléchargements → Packs d’échantillons, puis les parcourir ici sous forme d’arborescence. Des fichiers peuvent aussi être glissés depuis le Finder.",
- "No samples yet": "Aucun échantillon pour l’instant",
- "No presets yet": "Aucun préréglage pour l’instant",
- "Right-click a device header and choose Save preset; it appears here grouped by category and device.": "Clic droit sur l’en-tête d’un appareil puis « Enregistrer le préréglage » : il apparaît ici, groupé par catégorie et par appareil.",
- "No projects yet": "Aucun projet pour l’instant",
- "Save a project (⌘S) into your Projects folder (Settings → Library) and it shows up here.": "Enregistrer un projet (⌘S) dans le dossier Projets (Réglages → Bibliothèque) : il apparaît ici.",
- " · analysing {0} %": " · analyse {0} %",
- "Collapse": "Replier",
- "Expand": "Déplier",
- "Sort and view": "Tri et affichage",
- "Show type tags": "Afficher les étiquettes de type",
- "Category chips": "Pastilles de catégorie",
- "Group by source": "Grouper par source",
- "Favorites first": "Favoris en premier",
- "Warp loops to project tempo": "Warper les boucles au tempo du projet",
- "Transpose to project key": "Transposer à la tonalité du projet",
- "Edit tags…": "Modifier les étiquettes…",
- "Favorites": "Favoris",
- "Like {0}": "Comme {0}",
- "Sounds like {0}, closest first — click to go back to all samples": "Sons proches de {0}, les plus proches d’abord — cliquer pour revenir à tous les échantillons",
- "Filter by tempo": "Filtrer par tempo",
- "Filter by key — a key also shows its relative (A minor ↔ C major)": "Filtrer par tonalité — une tonalité montre aussi sa relative (A mineur ↔ C majeur)",
- "BPM": "BPM",
- "Project tempo ±5 %": "Tempo du projet ±5 %",
- "Loops within 5 % of {0} BPM warp to it cleanly": "Les boucles à moins de 5 % de {0} BPM s’y calent proprement",
- "Any tempo": "Tous les tempos",
- "Project key · {0}": "Tonalité du projet · {0}",
- "Any key": "Toutes les tonalités",
- "Finding sounds like {0}…": "Recherche de sons proches de {0}…",
- "Couldn't analyse that sample": "Impossible d’analyser cet échantillon",
- "Audio effect": "Effet audio",
- "MIDI effect": "Effet MIDI",
- "MIDI file": "Fichier MIDI",
- "Project": "Projet",
- "Folder": "Dossier",
- "Add to favorites": "Ajouter aux favoris",
- "Remove from favorites": "Retirer des favoris",
- "Tags": "Étiquettes",
- "New tag…": "Nouvelle étiquette…",
- "Show similar sounds": "Afficher les sons similaires",
- "Delete…": "Supprimer…",
- "Create multisample…": "Créer un multi-échantillon…",
- "Map the folder's samples by their names into Nota Mosaic presets": "Assigner les échantillons du dossier selon leurs noms dans des préréglages Nota Mosaic",
- "Open": "Ouvrir",
- "Attack {0}": "Attaque {0}",
- "Decay {0} · Sustain {1}": "Déclin {0} · Maintien {1}",
- "Release {0}": "Relâchement {0}",
- "Tools": "Outils",
- "Envelopes": "Enveloppes",
- "Notes": "Notes",
- "Clip: the selected clip · Track: every clip on the track": "Clip : le clip sélectionné · Piste : tous les clips de la piste",
- "Track {0} clip": "Clip de la piste {0}",
- "Hear notes as you place, click or drag them": "Entendre les notes quand on les place, les clique ou les fait glisser",
- "Fit": "Ajuster",
- "Fit to notes (⇧F)": "Ajuster aux notes (⇧F)",
- "Scale": "Gamme",
- "Remove out of scale": "Supprimer hors gamme",
- "Delete every note outside the scale": "Supprimer toutes les notes hors de la gamme",
- "Fold": "Replier",
- "only the notes in use": "seulement les notes utilisées",
- "only the pads": "seulement les pads",
- "only the scale's notes": "seulement les notes de la gamme",
- "Fold: show {0} (⌥⇧F)": "Replier : afficher {0} (⌥⇧F)",
- "Velocity": "Vélocité",
- "Env": "Env",
- "Click to add a point · drag to move · right-click to delete": "Clic pour ajouter un point · glisser pour déplacer · clic droit pour supprimer",
- "Click to add a point": "Clic pour ajouter un point",
- "Clips always loop": "Les clips bouclent toujours",
- "Quantize": "Quantifier",
- "Strength": "Intensité",
- "Transpose": "Transposer",
- "No notes selected": "Aucune note sélectionnée",
- "Selection": "Sélection",
- "Double-click — add or delete · edge — length · Shift — add to selection": "Double-clic — ajouter ou supprimer · bord — longueur · Shift — ajouter à la sélection",
- "beat": "temps",
- "beats": "temps",
- "Range": "Plage",
- "No pads loaded": "Aucun pad chargé",
- "Drop samples on the Drum Rack pads in Devices, then step them here.": "Déposer des échantillons sur les pads du Drum Rack dans Appareils, puis les programmer ici pas à pas.",
- "click to place · shift-click accents · drag to paint": "clic pour placer · ⇧-clic pour les accents · glisser pour peindre",
- "Clear": "Effacer",
- "Play {0} · {1} and show its velocity lane": "Jouer {0} · {1} et afficher son couloir de vélocité",
- "Versions": "Versions",
- "Clean up the history": "Nettoyer l’historique",
- "Save the project to start its history.": "Enregistrer le projet pour commencer son historique.",
- "Version history is turned off in Settings.": "L’historique des versions est désactivé dans les Réglages.",
- "Each save adds a version here.": "Chaque enregistrement ajoute une version ici.",
- "No starred versions yet. Right-click a version and choose Star.": "Aucune version étoilée pour l’instant. Clic droit sur une version puis « Étoiler ».",
- "Show all versions": "Afficher toutes les versions",
- "Show starred versions only": "Afficher seulement les versions étoilées",
- "Saved by a newer Nota — update to open it.": "Enregistré par une version plus récente de Nota — mettre à jour pour l’ouvrir.",
- "Current": "Actuelle",
- "Switch": "Basculer",
- "Switch the project to this version": "Basculer le projet vers cette version",
- "The project is at this version": "Le projet est à cette version",
- "Open copy": "Ouvrir une copie",
- "Open this version as a new project, keeping this one as it is": "Ouvrir cette version comme nouveau projet, en laissant celui-ci tel quel",
- "Current version": "Version actuelle",
- "Version": "Version",
- "Switch to this version": "Basculer vers cette version",
- "Open as copy…": "Ouvrir comme copie…",
- "Name version": "Nommer la version",
- "Name…": "Nommer…",
- "Version name": "Nom de la version",
- "Remove name": "Retirer le nom",
- "Add note…": "Ajouter une note…",
- "Edit note…": "Modifier la note…",
- "Version note": "Note de version",
- "What changed in this version?": "Qu’est-ce qui a changé dans cette version ?",
- "Remove note": "Retirer la note",
- "Remove star": "Retirer l’étoile",
- "Star": "Étoiler",
- "Delete version…": "Supprimer la version…",
- "Switch to another version to delete this one": "Basculer vers une autre version pour supprimer celle-ci",
- "Delete unnamed versions…": "Supprimer les versions sans nom…",
- "Delete unnamed versions": "Supprimer les versions sans nom",
- "Delete version": "Supprimer la version",
- "Delete {0}? Audio that only this version uses is deleted from the project folder too. This can't be undone.": "Supprimer {0} ? L’audio utilisé uniquement par cette version est aussi supprimé du dossier du projet. Cette action est irréversible.",
- "Couldn't change the version: {0}": "Impossible de changer de version : {0}",
- "Nota Lens · {0}": "Nota Lens · {0}",
- "Load failed: {0}": "Échec du chargement : {0}",
- "Reveal failed: {0}": "Échec de l’affichage : {0}",
- "Delete project": "Supprimer le projet",
- "Move “{0}” to the Trash?": "Mettre « {0} » à la corbeille ?",
- "Moved {0} to Trash": "{0} mis à la corbeille",
- "Delete preset": "Supprimer le préréglage",
- "Preset name": "Nom du préréglage",
- "Save preset": "Enregistrer le préréglage",
- "Nothing to save (built-in synth has no state).": "Rien à enregistrer (le synthé intégré n’a pas d’état).",
- "Saved preset {0}": "Préréglage {0} enregistré",
- "Save preset failed: {0}": "Échec de l’enregistrement du préréglage : {0}",
- "Only plug-in chain instruments can be saved as presets.": "Seuls les instruments à chaîne de plug-ins peuvent être enregistrés comme préréglages.",
- " · version not recorded: {0}": " · version non enregistrée : {0}",
- "Version history turned off · {0} freed": "Historique des versions désactivé · {0} libérés",
- "Save version": "Enregistrer la version",
- "Switch version": "Changer de version",
- "Save your changes as a new version before switching?": "Enregistrer les modifications comme nouvelle version avant de changer ?",
- "Couldn't switch version: {0}": "Impossible de changer de version : {0}",
- "Switched to {0}": "Passage à {0}",
- "Open version as copy": "Ouvrir la version comme copie",
- "Save your changes before opening the copy?": "Enregistrer les modifications avant d’ouvrir la copie ?",
- "Open version as a new project": "Ouvrir la version comme nouveau projet",
- "Choose a new name for the copy — it can't replace an existing project.": "Choisir un nouveau nom pour la copie — elle ne peut pas remplacer un projet existant.",
- "Couldn't open the version: {0}": "Impossible d’ouvrir la version : {0}",
- "Opened {0} as {1}": "{0} ouvert comme {1}",
- "the version of {0}": "la version du {0}",
- "the version “{0}” ({1})": "la version “{0}” ({1})",
- "Created the preset {0}": "Préréglage {0} créé",
- "Created {0} presets · loaded {1}": "{0} préréglages créés · {1} chargé",
- "Left stick ←→": "Stick gauche ←→",
- "Left stick ↑↓": "Stick gauche ↑↓",
- "Right stick ←→": "Stick droit ←→",
- "Right stick ↑↓": "Stick droit ↑↓",
- "Left trigger": "Gâchette gauche",
- "Right trigger": "Gâchette droite",
- "Button {0}": "Bouton {0}",
- "Pad · {0}": "Pad · {0}",
- "Phone · {0}": "Téléphone · {0}",
- "Note {0} · ch{1}": "Note {0} · canal {1}",
- "MIDI mappings": "Assignations MIDI",
- "No mappings yet.\n\nClick MIDI (top-right), then click any highlighted\ncontrol and move a knob or fader on your controller —\nor press a button or move a stick on a gamepad.": "Aucune assignation pour l’instant.\n\nCliquer sur MIDI (en haut à droite), puis sur une commande\nen surbrillance, et bouger un bouton ou un fader du contrôleur —\nou appuyer sur un bouton ou bouger un stick d’une manette.",
- "Invert": "Inverser",
- "Min": "Min",
- "Max": "Max",
- "Generate": "Générer",
- "Transform": "Transformer",
- "Seed": "Graine",
- "Reroll": "Retirer au sort",
- "Add": "Ajouter",
- "Apply": "Appliquer",
- "Defaults": "Valeurs par défaut",
- "Revert": "Rétablir",
- "{0} selected": "{0} sélectionné(s)",
- "clip · {0}": "clip · {0}",
- "{0} notes · applied": "{0} notes · appliqué",
- "Pick a tool": "Choisir un outil",
- "{0:+0;−0;±0} notes": "{0:+0;−0;±0} notes",
- "{0} notes, was {1}": "{0} notes, au lieu de {1}",
- "Parameters": "Paramètres",
- "Pick a tool to see its parameters": "Choisir un outil pour voir ses paramètres",
- "Group in": "Entrée du groupe",
- "MIDI in": "Entrée MIDI",
- "→ Master": "→ Master",
- "Monitor auto": "Écoute auto",
- "Monitor in": "Écoute entrée",
- "Sum bus": "Bus de somme",
- "→ Output": "→ Sortie",
- "Sends": "Envois",
- "Hidden: not enough height · click to show anyway": "Masqué : hauteur insuffisante · cliquer pour afficher quand même",
- "Pan law": "Loi de panoramique",
- "Balance": "Balance",
- "Panning attenuates the opposite channel (legacy behaviour)": "Le panoramique atténue le canal opposé (comportement historique)",
- "Panning moves the whole stereo image; nothing is dropped": "Le panoramique déplace toute l’image stéréo ; rien n’est supprimé",
- "Older project": "Ancien projet",
- "Projects saved before stereo pan law open with Balance so existing mixes do not change": "Les projets enregistrés avant la loi de panoramique stéréo s’ouvrent avec Balance, pour que les mixages existants ne changent pas",
- "Pan moves the whole image of stereo tracks and returns": "Le pan déplace toute l’image des pistes stéréo et des retours",
- "Pan attenuates the opposite channel, as in earlier versions": "Le pan atténue le canal opposé, comme dans les versions précédentes",
- "Send {0}": "Envoi {0}",
- "A hidden track is soloed": "Une piste masquée est en solo",
- "A hidden track is armed": "Une piste masquée est armée",
- "A hidden track clipped · click to clear": "Une piste masquée a saturé · cliquer pour effacer",
- "Fold group {0}": "Replier le groupe {0}",
- "Unfold group {0}": "Déplier le groupe {0}",
- "Show compact strips: more tracks on screen": "Afficher des tranches compactes : plus de pistes à l’écran",
- "Drag to set the volume · click to clear the peak hold": "Glisser pour régler le volume · cliquer pour effacer le maintien de crête",
- "Track Pan": "Pan de la piste",
- "Groups keep a unity-centre balance so grouping stays level-transparent": "Les groupes gardent une balance centrée à gain unitaire, pour que le groupage reste transparent en niveau",
- "Set the gain — drag, or double-click to type": "Régler le gain : glisser, ou double-clic pour le saisir",
- "Track Volume": "Volume de la piste",
- "Mute": "Muet",
- "Solo": "Solo",
- "Dock the mixer in the main window": "Ancrer le mixeur dans la fenêtre principale",
- "Watches CV. Drag a modulator's CV out onto this node. For audio, put Lens on the chain.": "Surveille le CV. Glisser la sortie CV d’un modulateur sur ce nœud. Pour l’audio, mettre Lens sur la chaîne.",
- "Drag to resize the trace": "Glisser pour redimensionner la trace",
- "Sync": "Sync",
- "The window is in beats at the tempo. Click for milliseconds": "La fenêtre est en temps, au tempo. Cliquer pour passer en millisecondes",
- "The window is in milliseconds. Click to sync it to the beat": "La fenêtre est en millisecondes. Cliquer pour la synchroniser au tempo",
- "Free": "Libre",
- "Free running: the newest value is at the right": "Défilement libre : la valeur la plus récente est à droite",
- "Rise": "Montée",
- "Trigger: start the trace where the input rises through 0, so a repeating shape holds still": "Déclencheur : démarrer la trace là où l’entrée franchit 0 en montant, pour qu’une forme répétée reste immobile",
- "Back to the live trace": "Retour à la trace en direct",
- "Hold the trace while the input keeps running": "Figer la trace pendant que l’entrée continue",
- "Scope {0} · {1}": "Scope {0} · {1}",
- "Global": "Global",
- "Pick a track to see its signal graph": "Choisir une piste pour voir son graphe de signal",
- "Drag from a CV out onto a node to modulate it · Space + drag — pan · ⌘ + wheel — zoom · F — fit · Esc — show fewer": "Glisser d’une sortie CV sur un nœud pour le moduler · Space + glisser — déplacer la vue · ⌘ + molette — zoom · F — ajuster · Esc — afficher moins",
- "No tracks yet": "Aucune piste pour l’instant",
- "Inst {0}": "Inst {0}",
- "Instrument {0}": "Instrument {0}",
- "Audio in": "Entrée audio",
- "Track output": "Sortie de piste",
- "{0:0.0} kHz · {1} · {2:0.0} ms": "{0:0.0} kHz · {1} · {2:0.0} ms",
- "{0} NODES": "{0} NŒUDS",
- "Out": "Sortie",
- "LFO {0}": "LFO {0}",
- "Macro": "Macro",
- "Math": "Math",
- "Scope": "Scope",
- "Depth": "Depth",
- "Phase": "Phase",
- "Multiply": "Multiply",
- "Subtract": "Subtract",
- "Offset": "Offset",
- "CV out": "CV out",
- "Gate": "Gate",
- "Note": "Note",
- "Vel": "Vel",
- "Rnd": "Rnd",
- "Saw": "Saw",
- "Sine": "Sine",
- "Sqr": "Sqr",
- "Tri": "Tri",
- "Rate": "Rate",
- "Parameter": "Paramètre",
- "Remove modulation": "Retirer la modulation",
- "From {0} · {1}": "Depuis {0} · {1}",
- "Modulate from a parameter": "Moduler depuis un paramètre",
- "Modulate from another track": "Moduler depuis une autre piste",
- "Add an LFO / expose a param first": "Ajouter d’abord un LFO / exposer un paramètre",
- "Expose as CV output": "Exposer comme sortie CV",
- "Unexpose CV output": "Ne plus exposer la sortie CV",
- "Remove connection": "Retirer la connexion",
- "CV LINK · LFO {0}": "LIEN CV · LFO {0}",
- "Override": "Forcer",
- "Mode": "Mode",
- "Bypass (B)": "Contourner (B)",
- "Delete (⌫)": "Supprimer (⌫)",
- "LFO": "LFO",
- "Open in a window": "Ouvrir dans une fenêtre",
- "Show fewer": "Afficher moins",
- "Hide the parameters that aren't modulated (Esc)": "Masquer les paramètres non modulés (Esc)",
- "Audio out": "Sortie audio",
- "MIDI out": "Sortie MIDI",
- "No parameters": "Aucun paramètre",
- "No modulatable parameters on that track": "Aucun paramètre modulable sur cette piste",
- "Fixed — the track's clips and input enter the chain here, so it can't be deleted.": "Fixe — les clips et l’entrée de la piste entrent dans la chaîne ici, donc il ne peut pas être supprimé.",
- "Fixed — the chain leaves the track for the mixer here, so it can't be deleted.": "Fixe — la chaîne quitte la piste vers le mixeur ici, donc il ne peut pas être supprimé.",
- "Fixed — the track's instrument takes its MIDI in. It can't be deleted; drop another instrument on the track to swap it.": "Fixe — l’instrument de la piste reçoit son MIDI ici. Il ne peut pas être supprimé ; déposer un autre instrument sur la piste pour le remplacer.",
- "Show all parameters": "Afficher tous les paramètres",
- "Show fewer parameters (Esc)": "Afficher moins de paramètres (Esc)",
- "+ Add": "+ Ajouter",
- "Multisamples": "Multi-échantillons",
- "Create multisample": "Créer un multi-échantillon",
- "by name stem": "par radical du nom",
- "Octave": "Octave",
- "Mapping": "Assignation",
- "next to gap": "à côté du trou",
- "Reading the files…": "Lecture des fichiers…",
- "Create presets": "Créer des préréglages",
- "Presets will appear in Nota Mosaic → Packs → {0}": "Les préréglages apparaîtront dans Nota Mosaic → Packs → {0}",
- "{0} files · {1}": "{0} fichiers · {1}",
- "{0} layer": "{0} couche",
- "No audio files with a note in their name or a clear pitch.": "Aucun fichier audio avec une note dans son nom ou une hauteur claire.",
- "The names are taken as written (C4 = 60).": "Les noms sont pris tels quels (C4 = 60).",
- "No repeat": "Sans répétition",
- "Seq": "Séq",
- "Edge zone stretch": "Étirement des zones de bord",
- "Velocity layers by dynamics": "Couches de vélocité par dynamique",
- "Release samples → Release group": "Échantillons de relâchement → groupe de relâchement",
- "nothing to map": "rien à assigner",
- "{0}–{1} · {2} zones": "{0}–{1} · {2} zones",
- "Gap at {0} — neighbours stretched": "Trou à {0} — voisines étirées",
- "{0} without a note — left out": "{0} sans note — ignoré",
- "{0} · analysis": "{0} · analyse",
- "{0} · MIDI": "{0} · MIDI",
- "Create 1 preset": "Créer 1 préréglage",
- "Create {0} presets": "Créer {0} préréglages",
- "Mapping…": "Assignation…",
- "Click a clip to edit it · the lock keeps a clip for reference": "Clic sur un clip pour l’éditer · le verrou garde un clip comme référence",
- "Other CC": "Autre CC",
- "Drag to draw": "Glisser pour dessiner",
- "Drag to draw a block": "Glisser pour dessiner un bloc",
- "Clear {0}": "Effacer {0}",
- "Bend": "Bend",
- "Pres": "Pres",
- "Slide": "Slide",
- "Pressure": "Pression",
- "Clear All Expression": "Effacer toute l’expression",
- "No selection": "Aucune sélection",
- "1 note · {0} · vel {1}": "1 note · {0} · vél {1}",
- "{0} notes": "{0} notes",
- "Scenes": "Scènes",
- "+ Scene": "+ Scène",
- "Add a scene at the end": "Ajouter une scène à la fin",
- "Stop every session clip": "Arrêter tous les clips de la session",
- "Stop every track in this group": "Arrêter toutes les pistes de ce groupe",
- "Stop this track": "Arrêter cette piste",
- "Fold the group into one column": "Replier le groupe en une colonne",
- "Show the group's tracks": "Afficher les pistes du groupe",
- "Arr": "Arr",
- "Back to Arrangement for this track": "Retour à l’arrangement pour cette piste",
- "Moved clip": "Clip déplacé",
- "Drop a MIDI clip on a MIDI track, audio on audio.": "Déposer un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
- "Rec in…": "Rec dans…",
- "Recording": "Enregistrement",
- "Moved scene": "Scène déplacée",
- "{0} · scene {1}": "{0} · scène {1}",
- "Launch": "Lancer",
- "Copy to Arrangement": "Copier vers l’arrangement",
- "Record here": "Enregistrer ici",
- "Add stop button": "Ajouter un bouton d’arrêt",
- "Remove stop button": "Retirer le bouton d’arrêt",
- "Delete group and its tracks": "Supprimer le groupe et ses pistes",
- "Scene · {0}": "Scène · {0}",
- "Stop scene": "Arrêter la scène",
- "Insert scene below": "Insérer une scène dessous",
- "Capture playing clips below": "Capturer les clips en lecture dessous",
- "Copy scene to Arrangement": "Copier la scène vers l’arrangement",
- "Delete scene": "Supprimer la scène",
- "Repeat": "Répéter",
- "Toggle": "Bascule",
- "Trigger": "Déclencheur",
- "Again": "Encore",
- "Next": "Suivant",
- "First": "Premier",
- "Previous": "Précédent",
- "Any": "Quelconque",
- "Other": "Autre",
- "Jump": "Saut",
- "One pass": "Un passage",
- "Click selects · the triangle launches · Enter launches the selection\n←↑↓→ move · ⌘C ⌘V ⌘D · ⌫ delete · ⌘I insert scene\n⌘⇧C copy to arrangement · ⌘V pastes clips copied there": "Clic sélectionne · le triangle lance · Entrée lance la sélection\n←↑↓→ déplacer · ⌘C ⌘V ⌘D · ⌫ supprimer · ⌘I insérer une scène\n⌘⇧C copier vers l’arrangement · ⌘V colle les clips copiés là",
- "Click again to use the default colour": "Cliquer de nouveau pour utiliser la couleur par défaut",
- "Color": "Couleur",
- "Off · one-shot": "Désactivé · one-shot",
- "Loop end": "Fin de boucle",
- "Trigger starts · Gate plays while held · Toggle starts and stops · Repeat retriggers while held": "Déclencheur démarre · Gate joue tant que tenu · Bascule démarre et arrête · Répéter redéclenche tant que tenu",
- "Legato": "Legato",
- "Velocity amount: how far the launch velocity scales the clip · drag": "Quantité de vélocité : dans quelle mesure la vélocité de lancement met le clip à l’échelle · glisser",
- "Velocity %": "Vélocité %",
- "Follow action": "Action de suivi",
- "Off globally": "Désactivé globalement",
- "Chance of A in percent · B gets the rest · drag": "Probabilité de A en pourcentage · B reçoit le reste · glisser",
- "Jump to": "Sauter à",
- "After": "Après",
- "Rename": "Renommer",
- "To Arrangement": "Vers l’arrangement",
- "Launch without a tempo change": "Lancer sans changement de tempo",
- "Tempo set when the scene launches · drag to change": "Tempo réglé au lancement de la scène · glisser pour le changer",
- "Signature": "Signature",
- "Next · {0}": "Suivant · {0}",
- "Next after {0}": "Suivant après {0}",
- "Select next scene on launch": "Sélectionner la scène suivante au lancement",
- "Insert below": "Insérer dessous",
- "Empty slot": "Emplacement vide",
- "Removed": "Retiré",
- "Stop button": "Bouton d’arrêt",
- "Launching this scene keeps {0} playing.": "Le lancement de cette scène laisse {0} en lecture.",
- "Launching this scene stops {0}.": "Le lancement de cette scène arrête {0}.",
- "Stop recording": "Arrêter l’enregistrement",
- "Every track ends up here. Its devices are in the Devices panel.": "Toutes les pistes aboutissent ici. Ses appareils sont dans le panneau Appareils.",
- "Tracks reach it through their sends. It has no clip slots; its devices are in the Devices panel.": "Les pistes l’atteignent par leurs envois. Il n’a pas d’emplacements de clips ; ses appareils sont dans le panneau Appareils.",
- "GROUP SLOT · {0} TRACKS": "EMPLACEMENT DE GROUPE · {0} PISTES",
- "Launches every track's slot in this scene. The stop button stops them all.": "Lance l’emplacement de chaque piste dans cette scène. Le bouton d’arrêt les arrête tous.",
- "Launch group slot": "Lancer l’emplacement du groupe",
- "Stop group": "Arrêter le groupe",
- "Monitor": "Écoute",
- "Send {0} · {1}": "Envoi {0} · {1}",
- "Send": "Envoi",
- "Show sends in track headers": "Afficher les envois dans les en-têtes de piste",
- "All ins": "Toutes les entrées",
- "MIDI input: every input, or another instrument track": "Entrée MIDI : toutes les entrées, ou une autre piste d’instrument",
- "In: hear the input live through this track · Auto: only while recording": "Entrée : entendre l’entrée en direct à travers cette piste · Auto : seulement pendant l’enregistrement",
- "Output — group a track to route it through the group": "Sortie — grouper une piste pour la router à travers le groupe",
- "Session rec": "Rec session",
- "Record into the armed track at the selected scene · click again to keep the take": "Enregistrer dans la piste armée à la scène sélectionnée · cliquer de nouveau pour garder la prise",
- "Fixed": "Fixe",
- "Fixed record length in bars — the take stops by itself": "Durée d’enregistrement fixe en mesures — la prise s’arrête d’elle-même",
- "Quant": "Quant",
- "Launch quantize: when clips and scenes start": "Quantification du lancement : quand les clips et les scènes démarrent",
- "Follow": "Suivi",
- "Follow actions on or off for every clip and scene": "Actions de suivi activées ou désactivées pour chaque clip et chaque scène",
- "Capture scene": "Capturer la scène",
- "Copy the clips playing now into a new scene": "Copier les clips en lecture dans une nouvelle scène",
- "Back to Arrangement": "Retour à l’arrangement",
- "Stop session clips and hand every track back to the Arrangement": "Arrêter les clips de la session et rendre chaque piste à l’arrangement",
- "Stop all": "Tout arrêter",
- "Inspector — show or hide it": "Inspecteur — l’afficher ou le masquer",
- "Inspector": "Inspecteur",
- "More session controls": "Plus de commandes de session",
- "Hide": "Masquer",
- "Turn follow off": "Désactiver le suivi",
- "Turn follow on": "Activer le suivi",
- "Arm a track with an empty slot in this scene to record.": "Armer une piste avec un emplacement vide dans cette scène pour enregistrer.",
- "Group · {0}{1}": "Groupe · {0}{1}",
- "Cut clip — paste to move it": "Clip coupé — coller pour le déplacer",
- "Pasted clip from the arrangement": "Clip de l’arrangement collé",
- "Pasted {0} clips from the arrangement": "{0} clips de l’arrangement collés",
- "Duplicated scene": "Scène dupliquée",
- "The slot below is taken.": "L’emplacement du dessous est occupé.",
- "Duplicated clip": "Clip dupliqué",
- "Deleted scene": "Scène supprimée",
- "Deleted clip": "Clip supprimé",
- "Inserted scene": "Scène insérée",
- "Captured": "Capturé",
- "Captured the playing clips into a new scene": "Clips en lecture capturés dans une nouvelle scène",
- "Copied clip to the arrangement at the playhead": "Clip copié dans l’arrangement à la tête de lecture",
- "Copied {0} clips to the arrangement at the playhead": "{0} clips copiés dans l’arrangement à la tête de lecture",
- "Correlation": "Corrélation",
- "Drag: pan + volume · Shift locks axis · double-click centres pan · ⌥-click types": "Glisser : pan + volume · Shift verrouille l’axe · double-clic centre le pan · ⌥-clic pour saisir",
- "Width": "Largeur",
- "Level": "Niveau",
- "Image is off the pan": "L’image est décalée du pan",
- "The pan is at {0}, but the signal measures {1}. The source itself is unbalanced.": "Le pan est à {0}, mais le signal mesure {1}. La source elle-même est déséquilibrée.",
- "Muted": "En sourdine",
- "No cloud while the track is muted.": "Pas de nuage tant que la piste est en sourdine.",
- "Below −60 dBFS, so the cloud is hidden.": "Sous −60 dBFS : le nuage est masqué.",
- "Silent": "Silence",
- "Arm for recording · ⌘-click to arm several tracks · ⌥-click to arm one track of a linked group": "Armer pour l’enregistrement · ⌘-clic pour armer plusieurs pistes · ⌥-clic pour armer une seule piste d’un groupe lié",
- "Link tracks — arming and clip edits act on every track of the group · ⌥-click a clip or an arm to act on one track": "Lier les pistes — l’armement et l’édition des clips agissent sur toutes les pistes du groupe · ⌥-clic sur un clip ou un bouton d’armement pour n’agir que sur une piste",
- "Link tracks": "Lier les pistes",
- "Linked with {0}": "Liée à {0}",
- "The group's tracks are linked": "Les pistes du groupe sont liées",
- "Click a group's Link key": "Clic sur la touche Link d’un groupe",
- "Link the group's tracks: arming one arms them all, and clip edits act on the clips at the same place on each": "Lier les pistes du groupe : en armer une les arme toutes, et l’édition d’un clip agit sur les clips au même endroit sur chacune",
- "⌥-click a clip or Arm": "⌥-clic sur un clip ou sur Armer",
- "In a linked group: select that clip alone, or arm that track alone": "Dans un groupe lié : sélectionner ce clip seul, ou armer cette piste seule",
- "No track selected": "Aucune piste sélectionnée",
- "Audio track": "Piste audio",
- "MIDI track": "Piste MIDI",
- "Name": "Nom",
- "Mute the track": "Mettre la piste en sourdine",
- "Solo the track": "Mettre la piste en solo",
- "Arm": "Armer",
- "Hear the input live through this track": "Entendre l’entrée en direct à travers cette piste",
- "Monitor input": "Écoute de l’entrée",
- "Play another instrument track's MIDI through this track's instrument": "Jouer le MIDI d’une autre piste d’instrument avec l’instrument de cette piste",
- "The colour the track's position gives it": "La couleur que lui donne la position de la piste",
- "Packs": "Packs",
- "Nota Kits": "Nota Kits",
- "sample packs installed from Settings → Downloads": "packs d’échantillons installés depuis Réglages → Téléchargements",
- "MIDI Effects": "Effets MIDI",
- "Audio Effects": "Effets audio",
- "Return in": "Entrée de retour",
- "Plug-ins": "Plug-ins",
- "Loop on / off in the ruler · the region stays, greyed out while off": "Boucle activée / désactivée dans la règle · la région reste, grisée tant qu’elle est désactivée",
- "Loop on / off · loop the selection · clear the loop region": "Boucle activée / désactivée · mettre la sélection en boucle · effacer la région de boucle",
- "Shape the new note: move it · ⇧ set its length · ⌘ drag up / down for velocity": "Façonner la nouvelle note : la déplacer · ⇧ pour régler sa longueur · ⌘ glisser vers le haut / le bas pour la vélocité",
- "Set the tempo the clip was recorded at · ÷2 / ×2 halve or double it": "Régler le tempo auquel le clip a été enregistré · ÷2 / ×2 le divisent ou le doublent",
- "Play / stop the selected sample, preset or device": "Lire / arrêter l’échantillon, le préréglage ou l’appareil sélectionné",
- "Count-in before Play / Record: off · 1 · 2 · 4 bars": "Décompte avant Lecture / Enregistrement : désactivé · 1 · 2 · 4 mesures",
- "A multi-selection gets its own menu: colour, height, freeze, group, copy, duplicate, delete": "Une sélection multiple a son propre menu : couleur, hauteur, gel, groupe, copie, duplication, suppression",
- "Resize the track (header or lane) · snaps to compact / standard / large · a multi-selection resizes together": "Redimensionner la piste (en-tête ou couloir) · se cale sur compact / standard / grand · une sélection multiple se redimensionne ensemble",
- "Resize it, snapped to bars": "La redimensionner, calée sur les mesures",
- "Drag sideways to scroll · up / down to zoom out / in": "Glisser latéralement pour défiler · vers le haut / le bas pour dézoomer / zoomer",
- "Reorder devices (or right-click the header → Move left / right)": "Réordonner les appareils (ou clic droit sur l’en-tête → Déplacer à gauche / à droite)",
- "A / B compare, move, copy, delete, presets, save preset": "Comparaison A / B, déplacer, copier, supprimer, préréglages, enregistrer le préréglage",
- "Left / right (or up / down) changes the value · hold ⌘ or ⇧ for fine steps": "Gauche / droite (ou haut / bas) change la valeur · maintenir ⌘ ou ⇧ pour des pas fins",
- "Step on / off · accent · quiet step — drag across to paint, up / down (or scroll) for its velocity": "Pas activé / désactivé · accent · pas doux — glisser pour peindre, haut / bas (ou défilement) pour sa vélocité",
- "1 Bar": "1 mesure",
- "2 Bars": "2 mesures",
- "4 Bars": "4 mesures",
- "8 Bars": "8 mesures",
- "In 1": "Entrée 1",
- "{0} edges": {
- "one": "{0} lien",
- "other": "{0} liens"
- },
- "{0} nodes": "{0} nœuds",
- "{0} · {1} · {2}": "{0} · {1} · {2}",
- "{0}.{1} bars": "{0}.{1} mesures",
- " (auto for this effect)": " (auto pour cet effet)",
- " Download it from the release page.": " Le télécharger depuis la page de la version.",
- " Nota downloads it here and installs it when you restart or quit.": " Nota le télécharge ici et l’installe au redémarrage ou à la fermeture.",
- " The AI runtime goes too.": " Le moteur d’IA est supprimé aussi.",
- " levels after the fold": " niveaux après le pli",
- " · deleted {0}": " · {0} supprimé",
- " · drag to change, double-click to reset": " · glisser pour modifier, double-clic pour réinitialiser",
- " · inactive": " · inactif",
- " · modulation links left on {0}": " · liaisons de modulation restantes sur {0}",
- " · no choke groups": " · aucun groupe d’exclusion",
- " · swing {0} · humanize {1}": " · swing {0} · humanize {1}",
- " · ⌥-click to type": " · ⌥-clic pour saisir",
- " — its macros and chain settings were dropped": " — ses macros et réglages de chaîne ont été abandonnés",
- " → Map (Pattern Out)": " → Map (Pattern Out)",
- " → Volume · gated": " → Volume · gaté",
- "\"{0}\" names {1} — make it the root": "« {0} » désigne {1} — en faire la fondamentale",
- "1 bar at {0:0} BPM · {1} notes": "1 mesure à {0:0} BPM · {1} notes",
- "1→2: resonator 1 rings into resonator 2 · 1+2: both struck, mixed": "1→2 : le résonateur 1 excite le résonateur 2 · 1+2 : les deux sont frappés, mélangés",
- "2 lines · BBD": "2 lignes · BBD",
- "3-band EQ": "EQ 3 bandes",
- "8 slots · {0} assigned": "8 emplacements · {0} assignés",
- "8-band EQ": "EQ 8 bandes",
- "A Drum Rack can't be ungrouped": "Un Drum Rack ne peut pas être dégroupé",
- "A MIDI Effect Rack holds up to {0} chains": "Un MIDI Effect Rack contient jusqu’à {0} chaînes",
- "A MIDI Effect Rack holds up to {0} chains.": "Un MIDI Effect Rack contient jusqu’à {0} chaînes.",
- "A MIDI Effect Rack takes MIDI effects only.": "Un MIDI Effect Rack n’accepte que des effets MIDI.",
- "A cable breaks the normal at Gate / Filt in / VCA in / Ext in · loops run with a one-sample delay": "Un câble coupe la connexion normalisée sur Gate / Filt in / VCA in / Ext in · les boucles tournent avec un échantillon de retard",
- "A low-frequency oscillator, free or synced to the tempo.": "Un oscillateur basse fréquence, libre ou synchronisé au tempo.",
- "A new, empty layer — move zones into it from the rail": "Une nouvelle couche vide — y déplacer des zones depuis le rail",
- "A plug-in can't go in a MIDI Effect Rack": "Un plug-in ne peut pas aller dans un MIDI Effect Rack",
- "A rack can't go inside a rack.": "Un rack ne peut pas aller dans un rack.",
- "A rack can't go inside another rack": "Un rack ne peut pas aller dans un autre rack",
- "A rack can't go on a Drum Rack pad.": "Un rack ne peut pas aller sur un pad de Drum Rack.",
- "A rack keeps at least one chain": "Un rack garde au moins une chaîne",
- "A single gain stage with a big readout.": "Un seul étage de gain avec un grand affichage.",
- "A step sequencer in scale degrees — pick a contour and a span, get a line.": "Un séquenceur pas à pas en degrés de gamme — choisir un contour et une étendue, obtenir une ligne.",
- "A synth voice, no sample": "Une voix de synthé, sans échantillon",
- "A synth with a built-in pattern engine for arpeggios and sequences.": "Un synthé avec un moteur de motifs intégré pour arpèges et séquences.",
- "ABOVE — COMPRESS": "Au-dessus — compresser",
- "ABOVE — COMPRESSION": "Au-dessus — compression",
- "Above 8 Hz the movement reads as a flutter, not as panning": "Au-delà de 8 Hz, le mouvement s’entend comme un flottement et non comme un panoramique",
- "Accent": "Accent",
- "Accent Vel": "Vélocité d’accent",
- "Accents": "Accents",
- "Active — click to bypass": "Actif — cliquer pour contourner",
- "Add 1-bar release tail": "Ajouter une queue de relâchement d’1 mesure",
- "Add a MIDI effect — or drop one from the Browser": "Ajouter un effet MIDI — ou en déposer un depuis le Navigateur",
- "Add a chain to start.": "Ajouter une chaîne pour commencer.",
- "Add a chain — or drop a device from the Browser on the list": "Ajouter une chaîne — ou déposer un appareil du Navigateur sur la liste",
- "Add a receiver to {0}: a voice param, a kit setting or a voice's effect": "Ajouter un récepteur à {0} : un paramètre de voix, un réglage du kit ou l’effet d’une voix",
- "Add a receiver: a pad control, the pad's instrument or one of its effects": "Ajouter un récepteur : une commande de pad, l’instrument du pad ou l’un de ses effets",
- "Add an audio effect: search the browser, or drop a device here": "Ajouter un effet audio : chercher dans le navigateur, ou déposer un appareil ici",
- "Add an effect — or drop one from the Browser": "Ajouter un effet — ou en déposer un depuis le Navigateur",
- "Add device — click for the list, or drop an effect here": "Ajouter un appareil — cliquer pour la liste, ou déposer un effet ici",
- "Add tag": "Ajouter une étiquette",
- "Added {0} to slot": "{0} ajouté à l’emplacement",
- "Address": "Adresse",
- "Adds, multiplies or mixes two control signals.": "Additionne, multiplie ou mélange deux signaux de contrôle.",
- "Algorithm share of the blend (drags Blend)": "Part de l’algorithme dans le mélange (entraîne Blend)",
- "Algorithm — Hall (large, spaced reflections) · Room (small, close walls) · Plate (dense, no room at all) · Chamber (between)": "Algorithme — Hall (grandes réflexions espacées) · Room (petite pièce, murs proches) · Plate (dense, sans pièce) · Chamber (entre les deux)",
- "Algorithmic reverb from small rooms to large halls.": "Réverbération algorithmique, des petites pièces aux grandes salles.",
- "All chains get the input. Outputs are summed.": "Toutes les chaînes reçoivent l’entrée. Les sorties sont additionnées.",
- "All chains share one voice, the last key wins": "Toutes les chaînes partagent une voix, la dernière touche l’emporte",
- "All-pass stages: every two cut one notch — 2 is a gentle swirl, 12 a deep, dense sweep": "Étages passe-tout : tous les deux creusent une encoche — 2 donne un léger tourbillon, 12 un balayage profond et dense",
- "Allow": "Autoriser",
- "Alternate": "Alterner",
- "Amount": "Quantité",
- "Amount at zero: the voices stand still, a static ": "Quantité à zéro : les voix restent immobiles, un ",
- "Amount or Mix at zero: nothing moves": "Amount ou Mix à zéro : rien ne bouge",
- "Amount — 0 … +30 dB into the stages. Drag the curve up / down for the same": "Amount — 0 … +30 dB dans les étages. Glisser la courbe vers le haut / bas pour la même chose",
- "Amount — how far the LFO swings each voice's delay: more is wider detune": "Amount — l’amplitude du LFO sur le retard de chaque voix : plus c’est grand, plus le désaccord est large",
- "Amount — how far the voice is pulled to the note": "Amount — l’attraction de la voix vers la note",
- "Amount — how far the voice is pulled to the target note": "Amount — l’attraction de la voix vers la note cible",
- "Amount — the depth: each channel dips to 1 − Amount at the LFO's low point": "Amount — la profondeur : chaque canal descend à 1 − Amount au creux du LFO",
- "Amp decay — shortens the hit": "Amp decay — raccourcit le coup",
- "An Audio Effect Rack takes audio effects only.": "Un Audio Effect Rack n’accepte que des effets audio.",
- "An Instrument Rack can't go inside a rack — add its instruments as chains.": "Un Instrument Rack ne peut pas aller dans un rack — ajouter ses instruments comme chaînes.",
- "An Instrument Rack can't go inside another Instrument Rack": "Un Instrument Rack ne peut pas aller dans un autre Instrument Rack",
- "An attack-decay-sustain-release envelope triggered by notes.": "Une enveloppe attaque-déclin-maintien-relâchement déclenchée par les notes.",
- "Analog delay · BBD": "Delay analogique · BBD",
- "Analog stage — a console-style soft clip after the saturation (click again for none)": "Étage analogique — un écrêtage doux façon console après la saturation (cliquer à nouveau pour aucun)",
- "Analog — a gentle saturation after the filter, like an analog circuit": "Analog — une légère saturation après le filtre, comme un circuit analogique",
- "Analysing…": "Analyse…",
- "Analyzer range — the graph's bottom edge, in dB below 0 dBFS": "Plage de l’analyseur — le bord inférieur du graphique, en dB sous 0 dBFS",
- "Analyzer — Pre: the input spectrum · Post: the output over a dimmer input · Off": "Analyseur — Pre : le spectre d’entrée · Post : la sortie au-dessus d’une entrée plus discrète · Off",
- "Anti-alias — a 4th-order low-pass at the reduced rate's Nyquist before the hold, so less folds back as images": "Anti-alias — un passe-bas d’ordre 4 à la fréquence de Nyquist du taux réduit avant le maintien, pour réduire le repliement en images",
- "Arch": "Arche",
- "Arm the next Single capture": "Armer la prochaine capture Single",
- "Arpeggiate": "Arpéger",
- "Attack click / snap": "Clic / claquement d’attaque",
- "Attack — how fast a band opens, 0.5 … 100 ms": "Attack — la vitesse d’ouverture d’une bande, 0,5 … 100 ms",
- "Attack — how fast the band moves toward its range": "Attack — la vitesse à laquelle la bande rejoint sa plage",
- "Attenuators scale whatever is patched into Atten 1/2 in; Sum adds its inputs": "Les atténuateurs mettent à l’échelle ce qui est branché sur Atten 1/2 in ; Sum additionne ses entrées",
- "Audio ": "Audio ",
- "Audio Effect Rack · chain {0}": "Audio Effect Rack · chaîne {0}",
- "Audio effect · {0}": "Effet audio · {0}",
- "Audio input 1 (mono)": "Entrée audio 1 (mono)",
- "Audio input 2 (mono)": "Entrée audio 2 (mono)",
- "Audio settings…": "Réglages audio…",
- "Auto ({0})": "Auto ({0})",
- "Auto gain — adds the opposite of the shelves' and bells' average level, so edits are judged at the same loudness": "Auto gain — ajoute l’opposé du niveau moyen des shelves et des bells, pour juger les modifications à volume égal",
- "Auto gain — make-up that follows the threshold and ratio": "Auto gain — un gain de compensation qui suit le seuil et le ratio",
- "Auto gain — rides the output back to the input's loudness (300 ms RMS, ±24 dB), so turning Bits or Drive doesn't jump in level": "Auto gain — ramène la sortie au volume de l’entrée (RMS 300 ms, ±24 dB), pour que Bits ou Drive ne fassent pas sauter le niveau",
- "Auto makeup — each band gets back about half of its compression at 0 dBFS": "Auto makeup — chaque bande récupère environ la moitié de sa compression à 0 dBFS",
- "Auto release — short peaks recover fast, sustained compression recovers slowly": "Auto release — les pics brefs se relâchent vite, une compression soutenue se relâche lentement",
- "Auto release — the release slows as the reduction deepens (up to 5× at 7 dB), so dense passages don't pump": "Auto release — le relâchement ralentit quand la réduction s’accentue (jusqu’à 5× à 7 dB), pour que les passages denses ne pompent pas",
- "Auto rides the gain to the target over Window; Manual holds the fader where you put it (Match sets it to the distance to the target)": "Auto amène le gain vers la cible sur Window ; Manual garde le fader là où il est placé (Match le règle sur l’écart à la cible)",
- "Auto-audition: play a preset or device on select": "Pré-écoute auto : jouer un préréglage ou un appareil à la sélection",
- "Auto-audition: play a sample on select": "Pré-écoute auto : jouer un échantillon à la sélection",
- "Auto-audition: play on select": "Pré-écoute auto : jouer à la sélection",
- "Auto-comp — the output level follows the input's, however hard the drive": "Auto-comp — le niveau de sortie suit celui de l’entrée, quelle que soit la saturation",
- "Auto-pan and tremolo synced to the tempo.": "Auto-pan et trémolo synchronisés au tempo.",
- "Auto-release — a slower second release once the reduction runs deep, so sustained material does not pump": "Auto-release — un second relâchement plus lent quand la réduction est profonde, pour que le matériel soutenu ne pompe pas",
- "BELOW — EXPAND": "Au-dessous — expanser",
- "BELOW — EXPANSION": "Au-dessous — expansion",
- "Back to the split (⌘⇧F)": "Retour à la vue partagée (⌘⇧F)",
- "Band gain ±24 dB — drag up / down, double-click resets": "Gain de bande ±24 dB — glisser vers le haut / bas, double-clic pour réinitialiser",
- "Band on — off leaves the band out of the signal (double-click its node does the same)": "Bande active — désactivée, elle sort du signal (double-clic sur son nœud pour le même effet)",
- "Bands — 3: Low / Mid / High · 2: Low + Mid (Mid runs to 20 kHz) · 1: Mid, full band": "Bandes — 3 : Low / Mid / High · 2 : Low + Mid (Mid va jusqu’à 20 kHz) · 1 : Mid, pleine bande",
- "Bands — how many bands, 8 … 32: fewer is more robotic, more is clearer": "Bands — le nombre de bandes, 8 … 32 : moins, c’est plus robotique ; plus, c’est plus clair",
- "Bank {0} — play and edit this pattern · right-click to copy or clear it": "Banque {0} — jouer et modifier ce motif · clic droit pour le copier ou l’effacer",
- "Bar.beat.sixteenth, counted from 1 — e.g. 5.1 or 5.3.2": "Mesure.temps.double-croche, comptés à partir de 1 — p. ex. 5.1 ou 5.3.2",
- "Bass mono — below this frequency the tail is mono, so a wide reverb does not smear the low end (off at the far left)": "Bass mono — sous cette fréquence la queue est mono, pour qu’une réverbération large n’empâte pas les graves (désactivé tout à gauche)",
- "Below — expansion": "Au-dessous — expansion",
- "Below — upward compression": "Au-dessous — compression ascendante",
- "Bend — the widest move between notes that bends over Glide; wider leaps jump": "Bend — le plus grand écart entre notes qui glisse via Glide ; les sauts plus larges sont directs",
- "Bends the time axis so a phrase accelerates, drags or breathes.": "Déforme l’axe du temps pour qu’une phrase accélère, traîne ou respire.",
- "Bias — the stage's asymmetry, −100 … +100 %: pushes the curve off-centre, adding even harmonics": "Bias — l’asymétrie de l’étage, −100 … +100 % : décale la courbe du centre et ajoute des harmoniques paires",
- "Bit depth": "Profondeur de bits",
- "Bit-depth and sample-rate reduction.": "Réduction de la profondeur de bits et de la fréquence d’échantillonnage.",
- "Bits — the bit depth, 1 … 24: fewer bits, fewer levels, more grit": "Bits — la profondeur de bits, 1 … 24 : moins de bits, moins de niveaux, plus de grain",
- "Blend": "Blend",
- "Blend the sample itself (dry) with the grain cloud (wet)": "Mélange l’échantillon lui-même (sec) avec le nuage de grains (traité)",
- "Blend — convolution (slate, top) ⇄ algorithm (neutral, bottom). Double-click: 50 / 50": "Blend — convolution (ardoise, haut) ⇄ algorithme (neutre, bas). Double-clic : 50 / 50",
- "Blends the loop's end into its start (forward loops)": "Fond la fin de la boucle dans son début (boucles avant)",
- "Both channels' gain over two LFO cycles — L neutral, R teal, Phase later — with the floor the depth reaches. Drag up / down for Amount, left / right for Phase; ⌥-click types, double-click resets both.": "Gain des deux canaux sur deux cycles du LFO — L neutre, R turquoise, Phase plus tard — avec le plancher atteint par la profondeur. Glisser vers le haut / bas pour Amount, à gauche / droite pour Phase ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
- "Breaks chords into a running sequence.": "Découpe les accords en une séquence continue.",
- "Brickwall limiter for the master.": "Limiteur brickwall pour le master.",
- "Bright — a treble lift before the preamp, strongest at low gain (the bright cap on a volume pot)": "Bright — une montée des aigus avant le préampli, plus forte à faible gain (le condensateur bright d’un potentiomètre de volume)",
- "Building pads…": "Création des pads…",
- "Bypassed": "Contourné",
- "Bypassed — click to enable": "Contourné — cliquer pour activer",
- "CV utility": "Utilitaire CV",
- "Cabinet — Match follows the model; 1×12 open, 2×12 combo, 4×12 closed, 1×15 bass": "Cabinet — Match suit le modèle ; 1×12 ouvert, 2×12 combo, 4×12 fermé, 1×15 basse",
- "Cabinet — Match follows the model; the others bring their own low resonance and presence peak. Scroll to step.": "Cabinet — Match suit le modèle ; les autres apportent leur propre résonance grave et leur pic de présence. Défiler pour changer.",
- "Cancel the download": "Annuler le téléchargement",
- "Captured sound · repeating": "Son capturé · répétition",
- "Captures and repeats slices for stutters and glitches.": "Capture et répète des tranches pour des bégaiements et des glitchs.",
- "Card size: S (mini) / L (full)": "Taille de la carte : S (mini) / L (complète)",
- "Carrier track — the track the voice shapes when Carrier is Track; this track and its groups are not offered": "Piste porteuse — la piste que la voix module quand Carrier est Track ; cette piste et ses groupes ne sont pas proposés",
- "Carrier — what the voice shapes: an internal saw (at Pitch), noise, or another track picked below": "Carrier — ce que la voix module : une dent de scie interne (à Pitch), du bruit, ou une autre piste choisie ci-dessous",
- "Ceiling — the output never goes above it (in dBTP with True peak on)": "Ceiling — la sortie ne le dépasse jamais (en dBTP avec True peak activé)",
- "Ceiling, −6 … 0 dBTP — drag up / down (Shift for fine steps), ⌥-click to type, double-click resets to −1.0": "Ceiling, −6 … 0 dBTP — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour revenir à −1,0",
- "Center — the middle of the sweep, 50 Hz … 5 kHz: higher moves the notches up": "Center — le milieu du balayage, 50 Hz … 5 kHz : plus haut, les encoches montent",
- "Centre": "Centre",
- "Centre Out": "Du centre vers l’extérieur",
- "Chain 1 feeds chain 2, top to bottom.": "La chaîne 1 alimente la chaîne 2, de haut en bas.",
- "Chance": "Probabilité",
- "Chance that a varied note is dropped": "Probabilité qu’une note variée soit supprimée",
- "Chance — how likely each interval fires a repeat": "Chance — la probabilité que chaque intervalle déclenche une répétition",
- "Chance — how many notes get varied at all": "Chance — combien de notes sont variées",
- "Changed since you loaded {0} · choose a preset": "Modifié depuis le chargement de {0} · choisir un préréglage",
- "Channel — St: both channels · Mid: the centre · Side: the edges · L / R: one channel alone": "Channel — St : les deux canaux · Mid : le centre · Side : les bords · L / R : un seul canal",
- "Channel — Stereo; Left or Right on both sides; Swap the sides": "Channel — Stereo ; Left ou Right des deux côtés ; Swap échange les côtés",
- "Character — Clean: transparent, the fastest attack; Punch: a slower attack lets the transient through to the clip; Glue: a slow release and a soft knee under the ceiling": "Character — Clean : transparent, l’attaque la plus rapide ; Punch : une attaque plus lente laisse passer le transitoire jusqu’à l’écrêtage ; Glue : un relâchement lent et un genou doux sous le plafond",
- "Character — the era the signal passes through: its saturation, tone, band-limit and how much hiss, crackle, wow and flutter it brings. Scroll to step.": "Character — l’époque que traverse le signal : sa saturation, sa tonalité, sa bande passante et la quantité de souffle, de craquements, de wow et de flutter. Défiler pour changer.",
- "Character — the voicing: Clean as set, Glue slower and softer, Punch faster, Opto slow and program-soft, FET very fast": "Character — le voicing : Clean tel que réglé, Glue plus lent et plus doux, Punch plus rapide, Opto lent et doux selon le programme, FET très rapide",
- "Check for updates": "Rechercher des mises à jour",
- "Checking for updates…": "Recherche de mises à jour…",
- "Choke group: click for the next": "Groupe d’exclusion : cliquer pour le suivant",
- "Choose the track Flux listens to — or one pad, chain or voice of it": "Choisir la piste écoutée par Flux — ou l’un de ses pads, chaînes ou voix",
- "Chord": "Accord",
- "Chorus and ensemble for width and shimmer.": "Chorus et ensemble pour la largeur et le scintillement.",
- "Chorus bypassed: the signal passes unchanged": "Chorus contourné : le signal passe inchangé",
- "Chromatic": "Chromatique",
- "Chunk": "Segment",
- "Classic jet flanger.": "Flanger jet classique.",
- "Classic — two voices, left and right; Ensemble — three voices 120° apart, a string-machine shimmer; Vibrato — the pitch wobble alone, no dry signal": "Classic — deux voix, gauche et droite ; Ensemble — trois voix à 120°, un scintillement de string machine ; Vibrato — l’oscillation de hauteur seule, sans signal sec",
- "Clear its steps in bank {0}": "Effacer ses pas dans la banque {0}",
- "Clear the peak hold": "Effacer le maintien de crête",
- "Clear the scale down to the root (Custom)": "Réduire la gamme à la fondamentale (Custom)",
- "Click a key to make it the root — the key that plays the sample as recorded": "Cliquer une touche pour en faire la fondamentale — celle qui joue l’échantillon tel qu’enregistré",
- "Click a key to make it the selected zone's root": "Cliquer une touche pour en faire la fondamentale de la zone sélectionnée",
- "Click a note to add it to or take it out of the scale (the scale turns Custom)": "Cliquer une note pour l’ajouter à la gamme ou l’en retirer (la gamme passe en Custom)",
- "Click an audio track to paste the bounced audio onto.": "Cliquer une piste audio pour y coller l’audio rendu.",
- "Click for the next macros, right-click for the previous": "Cliquer pour les macros suivantes, clic droit pour les précédentes",
- "Click for the next target, right-click for the previous": "Cliquer pour la cible suivante, clic droit pour la précédente",
- "Click to add or remove": "Cliquer pour ajouter ou retirer",
- "Click to change the Motion sync rate": "Cliquer pour changer la valeur de synchro de Motion",
- "Click to select · double-click to fold · right-click to replace, copy or move": "Cliquer pour sélectionner · double-clic pour replier · clic droit pour remplacer, copier ou déplacer",
- "Click: step on / off · Shift-click: accent · Alt-click: quiet step\nDrag across to paint · drag up / down or scroll to set the velocity · right-click for more": "Clic : pas actif / inactif · Maj-clic : accent · Alt-clic : pas faible\nGlisser pour peindre · glisser vers le haut / bas ou défiler pour régler la vélocité · clic droit pour plus d’options",
- "Clip editor: every clip on the track": "Éditeur de clips : tous les clips de la piste",
- "Clip editor: one clip": "Éditeur de clips : un seul clip",
- "Clock out (patch bay)": "Clock out (patch bay)",
- "Clock — Sync locks the pattern to the song's bars, Free runs it in Hz": "Clock — Sync cale le motif sur les mesures du morceau, Free le fait tourner en Hz",
- "Close editor": "Fermer l’éditeur",
- "Close the plug-in's own window": "Fermer la fenêtre propre au plug-in",
- "Cluster": "Cluster",
- "Code": "Code",
- "Compand — the same around the middle: above 1 stretches to the edges, below 1 squeezes to the middle": "Compand — la même chose autour du milieu : au-dessus de 1, étire vers les bords ; en dessous de 1, resserre vers le milieu",
- "Complexity — how busy and varied Rnd makes the pattern": "Complexity — le degré de densité et de variété que Rnd donne au motif",
- "Compression threshold · ratio (set the ratio in Band detail)": "Seuil de compression · ratio (régler le ratio dans Band detail)",
- "Compressor with sidechain and five characters — glue, punch and pumping.": "Compresseur avec sidechain et cinq caractères — glue, punch et pumping.",
- "Concert Hall · Wide": "Concert Hall · Wide",
- "Connect": "Relier",
- "Connect phone": "Connecter un téléphone",
- "Contour": "Contour",
- "Control": "Contrôle",
- "Controlled by {0} · click to open the macro": "Contrôlé par {0} · cliquer pour ouvrir la macro",
- "Controllers · Osc Bank": "Controllers · Osc Bank",
- "Converge": "Converger",
- "Convert failed: {0}": "Échec de la conversion : {0}",
- "Converted harmony: {0} notes → new track {1}": "Harmonie convertie : {0} notes → nouvelle piste {1}",
- "Converted melody: {0} notes → new track {1}": "Mélodie convertie : {0} notes → nouvelle piste {1}",
- "Converted {0} hits": "{0} frappes converties",
- "Converted {0}: {1} notes → new track {2}": "{0} converti : {1} notes → nouvelle piste {2}",
- "Converter": "Convertisseur",
- "Convolution share of the blend (drags Blend)": "Part de la convolution dans le mélange (entraîne Blend)",
- "Copied automation": "Automation copiée",
- "Copied clip(s)": "Clip(s) copié(s)",
- "Copy A to B": "Copier A vers B",
- "Copy B to A": "Copier B vers A",
- "Copy this chain after itself": "Copier cette chaîne après elle-même",
- "Couldn't add {0} to the rack.": "Impossible d’ajouter {0} au rack.",
- "Couldn't copy {0}.": "Impossible de copier {0}.",
- "Couldn't download the update: {0}": "Impossible de télécharger la mise à jour : {0}",
- "Couldn't freeze this track.": "Impossible de geler cette piste.",
- "Couldn't move {0}.": "Impossible de déplacer {0}.",
- "Couldn't open the {0} window.": "Impossible d’ouvrir la fenêtre {0}.",
- "Couldn't open the {0} window: {1}": "Impossible d’ouvrir la fenêtre {0} : {1}",
- "Couldn't paste the bounced audio.": "Impossible de coller l’audio rendu.",
- "Couldn't paste the instrument.": "Impossible de coller l’instrument.",
- "Couldn't paste: a device failed to load.": "Impossible de coller : un appareil n’a pas pu se charger.",
- "Couldn't reach GitHub to check for a newer version of Nota. Check your internet connection and try again.": "Impossible de joindre GitHub pour rechercher une version plus récente de Nota. Vérifier la connexion Internet, puis réessayer.",
- "Couldn't read {0}: {1}": "Impossible de lire {0} : {1}",
- "Couldn't render this track.": "Impossible de rendre cette piste.",
- "Count the length from the note-on or the note-off — click to switch": "Compter la durée depuis le note-on ou le note-off — cliquer pour basculer",
- "Count the length from the note-on, or from the note-off (the note fires when the key is released)": "Compter la durée depuis le note-on, ou depuis le note-off (la note part au relâchement de la touche)",
- "Crossover slope — Linkwitz-Riley 24 or 48 dB/oct: steeper touches the neighbours less": "Crossover slope — Linkwitz-Riley 24 ou 48 dB/oct : plus raide, moins d’effet sur les bandes voisines",
- "Curve": "Courbe",
- "Curve — bend the response: Drive above 1 lifts soft notes, below 1 pushes them down": "Curve — infléchit la réponse : Drive au-dessus de 1 remonte les notes douces, en dessous de 1 les abaisse",
- "Custom": "Personnalisé",
- "Custom — edit on the Scale tab": "Custom — à modifier dans l’onglet Scale",
- "Custom: your own notes — click the note map to edit": "Custom : vos propres notes — cliquer la carte des notes pour modifier",
- "Custom: your own shifts": "Custom : vos propres décalages",
- "Cut clip(s)": "Clip(s) coupé(s)",
- "Cut {0} — deleted {1}": "{0} coupé — {1} supprimé",
- "Cutoff — the base the modulation moves from; the dashed mark is where it is now. Double-click resets, ⌥-click types a value.": "Cutoff — la base d’où part la modulation ; le repère en pointillés indique la valeur actuelle. Double-clic pour réinitialiser, ⌥-clic pour saisir une valeur.",
- "Cycles": "Cycles",
- "DC filter — a 10 Hz high-pass on the crushed signal: takes out the offset a coarse, folded or noisy crush can leave": "DC filter — un passe-haut à 10 Hz sur le signal écrasé : retire le décalage continu que peut laisser un crush grossier, replié ou bruité",
- "Dashed — in · filled — out (brightness = velocity) · × — skipped": "Pointillés — entrée · plein — sortie (luminosité = vélocité) · × — ignoré",
- "Decay — RT60, the time the tail takes to fall 60 dB (0.2 … 12 s); Freeze holds it forever. Double-click resets.": "Decay — RT60, le temps que met la queue à baisser de 60 dB (0,2 … 12 s) ; Freeze la maintient indéfiniment. Double-clic pour réinitialiser.",
- "Decorates notes with grace notes, trills and rolls.": "Orne les notes de notes d’agrément, de trilles et de roulements.",
- "Deep — a low resonance boost after the tone stack, for a fuller, tighter bottom": "Deep — un renfort de résonance grave après le correcteur de tonalité, pour des graves plus pleins et plus serrés",
- "Delay — the centre of the sweep, 0.1 … 8 ms: shorter puts the notches higher": "Delay — le centre du balayage, 0,1 … 8 ms : plus court, les encoches montent",
- "Delete track": "Supprimer la piste",
- "Delete track “{0}”? The track and its {1} selected devices will be removed.": "Supprimer la piste « {0} » ? La piste et ses {1} appareils sélectionnés seront supprimés.",
- "Deleted automation": "Automation supprimée",
- "Deleted range": "Plage supprimée",
- "Deleted {0}": "{0} supprimé",
- "Delta · hear what it removes": "Delta · entendre ce qui est retiré",
- "Delta — play the difference between the input and the output: what the limiter takes away": "Delta — jouer la différence entre l’entrée et la sortie : ce que retire le limiteur",
- "Density": "Densité",
- "Depth at zero: the comb stands still, a static effect": "Depth à zéro : le peigne reste immobile, un effet statique",
- "Depth at zero: the notches stand still": "Depth à zéro : les encoches restent immobiles",
- "Depth — drag up / down (⌥-click to type, double-click: +50)": "Depth — glisser vers le haut / bas (⌥-clic pour saisir, double-clic : +50)",
- "Depth — how far an empty step turns the signal down": "Depth — de combien un pas vide baisse le signal",
- "Depth — how far the LFO swings the delay around its centre": "Depth — l’amplitude du LFO sur le retard autour de son centre",
- "Depth — how far the LFO swings the stages around Center, up to ±3 octaves": "Depth — l’amplitude du LFO sur les étages autour de Center, jusqu’à ±3 octaves",
- "Detect from file name": "Détecter d’après le nom du fichier",
- "Detecting harmony…": "Détection de l’harmonie…",
- "Detecting hits…": "Détection des frappes…",
- "Detecting pitch…": "Détection de la hauteur…",
- "Detecting transients…": "Détection des transitoires…",
- "Detector filter — the key goes through the band-pass (Sidechain tab) before the detector": "Detector filter — la clé passe par le passe-bande (onglet Sidechain) avant le détecteur",
- "Detector filter — the key goes through the band-pass before the detector": "Detector filter — la clé passe par le passe-bande avant le détecteur",
- "Detector · full band": "Détecteur · pleine bande",
- "Detector — Peak follows every transient; RMS (10 ms) follows loudness, smoother": "Detector — Peak suit chaque transitoire ; RMS (10 ms) suit le volume, plus lisse",
- "Detector — Peak reacts to every transient, RMS to the body, Auto follows the body and still catches the spikes": "Detector — Peak réagit à chaque transitoire, RMS au corps du son, Auto suit le corps tout en captant les pointes",
- "Detune of the chorus partner inside each voice": "Désaccord du partenaire de chorus dans chaque voix",
- "Detune up to ±": "Désaccord jusqu’à ±",
- "Devices / Clip": "Appareils / Clip",
- "Digital / Fold without oversampling alias: switch on 2× or more": "Digital / Fold sans suréchantillonnage produisent de l’aliasing : activer 2× ou plus",
- "Discard edits": "Abandonner les modifications",
- "Disconnect this phone (it stays trusted — forget it in Settings → Remote)": "Déconnecter ce téléphone (il reste de confiance — l’oublier dans Réglages → Télécommande)",
- "Distance": "Distance",
- "Distortion": "Distorsion",
- "Distribution: Gauss / Even / Walk — click for the next, Shift-click for the previous": "Distribution : Gauss / Even / Walk — cliquer pour la suivante, Maj-clic pour la précédente",
- "Distribution: Gauss — mostly small moves · Even — any amount equally · Walk — drifts from note to note": "Distribution : Gauss — surtout de petits écarts · Even — toute amplitude de façon égale · Walk — dérive de note en note",
- "Dither": "Dithering",
- "Dither — up to ±½ LSB of triangular noise before the levels: softens the steps into hiss": "Dither — jusqu’à ±½ LSB de bruit triangulaire avant les niveaux : adoucit les marches en souffle",
- "Diverge": "Diverger",
- "Done — re-freeze": "Terminé — geler à nouveau",
- "Double-click to fold · right-click for more": "Double-clic pour replier · clic droit pour plus d’options",
- "Down": "Bas",
- "Down-Up": "Bas-haut",
- "Download Nota {0}…": "Télécharger Nota {0}…",
- "Download cancelled.": "Téléchargement annulé.",
- "Downloading…": "Téléchargement…",
- "Drag Start / End (and the loop markers when looping) · ⌥-click a marker to type it · double-click to reset it": "Glisser Start / End (et les repères de boucle en mode boucle) · ⌥-clic sur un repère pour le saisir · double-clic pour le réinitialiser",
- "Drag a node — frequency and gain · wheel over a node — Q · double-click a node — band on / off · ": "Glisser un nœud — fréquence et gain · molette sur un nœud — Q · double-clic sur un nœud — bande active / inactive · ",
- "Drag a sample from the Files tab or the browser": "Glisser un échantillon depuis l’onglet Fichiers ou le navigateur",
- "Drag jack to jack · Alt-click to pull · right-click for a list": "Glisser de prise à prise · Alt-clic pour retirer · clic droit pour une liste",
- "Drag sideways for the cutoff, up and down for the resonance. The teal band is how far the envelope and LFO can move the cutoff; the dashed curve is where they have it now.": "Glisser latéralement pour la fréquence de coupure, vers le haut et le bas pour la résonance. La bande turquoise montre jusqu’où l’enveloppe et le LFO peuvent déplacer la coupure ; la courbe en pointillés indique où elle se trouve maintenant.",
- "Drag sideways for the threshold, up / down for the ratio. Double-click resets both. The dot is the key level right now.": "Glisser latéralement pour le seuil, vers le haut / bas pour le ratio. Double-clic pour réinitialiser les deux. Le point indique le niveau de la clé en ce moment.",
- "Drag the Start and End lines to set them · ⌥-click one to type it · double-click to load another file": "Glisser les lignes Start et End pour les régler · ⌥-clic sur l’une pour la saisir · double-clic pour charger un autre fichier",
- "Drag the edges to set the key zone · hover to test a note": "Glisser les bords pour définir la zone de touches · survoler pour tester une note",
- "Drag the edges to set the select range": "Glisser les bords pour définir la plage de sélection",
- "Drag the edges to set the velocity zone": "Glisser les bords pour définir la zone de vélocité",
- "Drag the ends · min above max inverts": "Glisser les extrémités · min au-dessus de max inverse",
- "Drag the nodes: attack, decay and sustain (up / down), release · Shift for fine steps · ⌥-click to type · double-click resets": "Glisser les nœuds : attaque, déclin et maintien (haut / bas), relâchement · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "Drag the selector or map it to a macro": "Glisser le sélecteur ou l’assigner à une macro",
- "Drag the trim lines to trim the IR (Start · Decay); ⌥-click to type, double-click resets. Drop an audio file here to load it.": "Glisser les lignes de découpe pour recadrer la réponse impulsionnelle (Start · Decay) ; ⌥-clic pour saisir, double-clic pour réinitialiser. Déposer un fichier audio ici pour le charger.",
- "Drag to blend the four timbres · ⌥-click to type · double-click to reset": "Glisser pour mélanger les quatre timbres · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "Drag to choose which chains play · right-click to map it to a macro": "Glisser pour choisir les chaînes jouées · clic droit pour l’assigner à une macro",
- "Drag to move the read position · ⌥-click to type it · double-click to reset": "Glisser pour déplacer la position de lecture · ⌥-clic pour la saisir · double-clic pour la réinitialiser",
- "Drag to reorder · double-click to fold · right-click for A/B, move and delete": "Glisser pour réordonner · double-clic pour replier · clic droit pour A/B, déplacer et supprimer",
- "Drag to set · right-click to map": "Glisser pour régler · clic droit pour assigner",
- "Drag up / down for the band's gain (Shift for fine steps); ⌥-click types it; double-click resets to 0 dB and lifts the kill": "Glisser vers le haut / bas pour le gain de la bande (Maj pour les pas fins) ; ⌥-clic pour le saisir ; double-clic pour revenir à 0 dB et lever le kill",
- "Drag up / down, Shift for fine, double-click resets": "Glisser vers le haut / bas, Maj pour les pas fins, double-clic pour réinitialiser",
- "Drag zone edges · hover to test a note": "Glisser les bords de la zone · survoler pour tester une note",
- "Drag: left / right for the cutoff, up / down for the resonance · Shift for fine steps · ⌥-click to type · double-click resets": "Glisser : gauche / droite pour la coupure, haut / bas pour la résonance · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "Draws a curve through the velocities instead of editing them one by one.": "Trace une courbe à travers les vélocités au lieu de les modifier une par une.",
- "Drive — how hard the signal hits the saturation. ⌥-click types, double-click resets.": "Drive — la force avec laquelle le signal attaque la saturation. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Drive — −12 … +24 dB into the crusher: pushes the signal up the levels, into the Analog clip or into more folds": "Drive — −12 … +24 dB dans le crusher : pousse le signal vers les niveaux supérieurs, dans l’écrêtage Analog ou vers davantage de repliements",
- "Drop 2": "Drop 2",
- "Drop MIDI effects here. Output goes to the track instrument.": "Déposer des effets MIDI ici. La sortie va à l’instrument de la piste.",
- "Drop MIDI files onto instrument slots.": "Déposer des fichiers MIDI sur les emplacements d’instruments.",
- "Drop a device here.": "Déposer un appareil ici.",
- "Drop a sample here": "Déposer un échantillon ici",
- "Drop a sample on a pad, or pick a kit above.": "Déposer un échantillon sur un pad, ou choisir un kit ci-dessus.",
- "Drop added notes outside the scale a semitone into it": "Ramener d’un demi-ton dans la gamme les notes ajoutées hors de celle-ci",
- "Drop added notes outside {0} a semitone into it": "Ramener d’un demi-ton dans {0} les notes ajoutées hors de celle-ci",
- "Drop an effect to add a chain.": "Déposer un effet pour ajouter une chaîne.",
- "Drop an impulse response here (WAV / FLAC / MP3) or click Load…": "Déposer une réponse impulsionnelle ici (WAV / FLAC / MP3) ou cliquer sur Load…",
- "Drop an instrument to add a layer.": "Déposer un instrument pour ajouter une couche.",
- "Drop effects onto a column.": "Déposer des effets sur une colonne.",
- "Drop samples and MIDI files onto a slot.": "Déposer des échantillons et des fichiers MIDI sur un emplacement.",
- "Drop samples onto audio slots.": "Déposer des échantillons sur les emplacements audio.",
- "Drop samples or a folder here · or pick a preset": "Déposer des échantillons ou un dossier ici · ou choisir un préréglage",
- "Drum Rack · pad {0}{1}": "Drum Rack · pad {0}{1}",
- "Drums · {0} pads": {
- "one": "Drums · {0} pad",
- "other": "Drums · {0} pads"
- },
- "Dry/Wet — double-click resets": "Dry/Wet — double-clic pour réinitialiser",
- "Duck — acts above the threshold": "Duck — agit au-dessus du seuil",
- "Ducking — the wet dips (up to 24 dB) while the input plays": "Ducking — le signal traité baisse (jusqu’à 24 dB) tant que l’entrée joue",
- "Dynamic — off parks every band on its static gain: hear what the dynamics do": "Dynamic — désactivé, chaque bande reste sur son gain statique : pour entendre ce que font les dynamiques",
- "Dynamics": "Dynamique",
- "EQ & filter": "EQ et filtre",
- "EQ bands that react to the level — de-essing and resonance control.": "Bandes d’EQ qui réagissent au niveau — dé-essage et contrôle des résonances.",
- "EXT: normalled to the VCA output (Moog feedback) — patch Ext in to replace it": "EXT : normalisé sur la sortie du VCA (réinjection façon Moog) — brancher Ext in pour le remplacer",
- "Each band in its colour, the sum in brass, the output spectrum behind. Drag a crossover handle left / right; drag anywhere else to ride that band's gain. Double-click resets, ⌥-click types.": "Chaque bande dans sa couleur, la somme en laiton, le spectre de sortie derrière. Glisser une poignée de crossover à gauche / droite ; glisser ailleurs pour régler le gain de cette bande. Double-clic pour réinitialiser, ⌥-clic pour saisir.",
- "Each note goes to every chain whose zone it hits. Outputs merge before the instrument.": "Chaque note va à toutes les chaînes dont elle touche la zone. Les sorties fusionnent avant l’instrument.",
- "Each note lasts until the next one starts (at most to the bar line)": "Chaque note dure jusqu’au début de la suivante (au plus jusqu’à la barre de mesure)",
- "Each voice over two LFO cycles — its delay (τ) or its detune (ct) — and where it is now. Drag up / down for Amount; ⌥-click types, double-click resets it.": "Chaque voix sur deux cycles du LFO — son retard (τ) ou son désaccord (ct) — et sa position actuelle. Glisser vers le haut / bas pour Amount ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Early reflections — the first discrete echoes off the walls, spaced by the algorithm and the size": "Early reflections — les premiers échos discrets sur les murs, espacés selon l’algorithme et la taille",
- "Eco: IR up to 3 s · Mid: 6 s · High: 10 s + cubic-interpolated algorithm modulation": "Eco : réponse jusqu’à 3 s · Mid : 6 s · High : 10 s + modulation de l’algorithme interpolée en cubique",
- "Edit modulation · {0}…": "Modifier la modulation · {0}…",
- "Edit on the {0} tab": "Modifier dans l’onglet {0}",
- "Edit source": "Modifier la source",
- "Edit tags": "Modifier les étiquettes",
- "Edit this zone's start, end and loop": "Modifier le début, la fin et la boucle de cette zone",
- "Editing the frozen source — press Done to re-freeze, or Discard.": "Modification de la source gelée — appuyer sur Terminé pour geler à nouveau, ou sur Abandonner.",
- "Eight-band parametric EQ with a live spectrum.": "EQ paramétrique à huit bandes avec spectre en direct.",
- "Eight-voice drum machine with a step sequencer.": "Boîte à rythmes à huit voix avec séquenceur pas à pas.",
- "Empty the delay buffer — silences what is still circulating": "Vider le tampon de delay — coupe ce qui circule encore",
- "Empty · drop samples or a folder, or pick a preset": "Vide · déposer des échantillons ou un dossier, ou choisir un préréglage",
- "End": "Fin",
- "Enter or Esc to close": "Entrée ou Échap pour fermer",
- "Env {0} — {1}": "Env {0} — {1}",
- "Env → Tone — loud parts push the tone brighter": "Env → Tone — les passages forts rendent le timbre plus brillant",
- "Envelope follower on / off": "Suiveur d’enveloppe activé / désactivé",
- "Euclidean": "Euclidien",
- "Even only — the preamp adds even harmonics only: warmth without the fizz of the odd ones": "Even only — le préampli n’ajoute que des harmoniques paires : de la chaleur sans le grésillement des impaires",
- "Every {0} ({1})": "Chaque {0} ({1})",
- "Exclusive is for hi-hats and valves: a new note chokes the off_by group.": "Exclusive sert aux charleys et aux valves : une nouvelle note coupe le groupe off_by.",
- "Exclusive mode uses the device's buffer": "Le mode exclusif utilise le tampon de l’appareil",
- "Exclusive · group / off by": "Exclusive · groupe / coupé par",
- "Expansion / upward-compression threshold · ratio — click the readout to switch it on or off": "Seuil d’expansion / compression ascendante · ratio — cliquer sur l’affichage pour l’activer ou le désactiver",
- "Exponential": "Exponentielle",
- "Export": "Exporter",
- "Export WAV": "Exporter en WAV",
- "Export failed: {0}": "Échec de l’export : {0}",
- "Export master to {0}": "Exporter le master en {0}",
- "Export stems": "Exporter les stems",
- "Export stems to folder": "Exporter les stems dans un dossier",
- "Export the Lens capture to WAV": "Exporter la capture de Lens en WAV",
- "Export {0}": "Exporter {0}",
- "Exported {0}": "{0} exporté",
- "Exported {0} stems": {
- "one": "{0} stem exporté",
- "other": "{0} stems exportés"
- },
- "Exporting stems…": "Export des stems…",
- "Exporting {0}… {1:0} %": "Export de {0}… {1:0} %",
- "Exporting…": "Export…",
- "Ext 1": "Ext 1",
- "Ext 2": "Ext 2",
- "External key — key off the source picked on the Sidechain tab; off, the track keys itself": "External key — déclenche depuis la source choisie dans l’onglet Sidechain ; désactivé, la piste se déclenche elle-même",
- "External sidechain — the detector listens to the key source instead of this track": "Sidechain externe — le détecteur écoute la source de clé au lieu de cette piste",
- "FM synth": "synthé FM",
- "FM synthesis — bells, electric pianos and hard basses.": "Synthèse FM — cloches, pianos électriques et basses dures.",
- "Fade on change — crossfade to a new delay time instead of gliding to it (which bends the pitch, tape style)": "Fade on change — fondu enchaîné vers le nouveau temps de delay au lieu d’y glisser (ce qui modifie la hauteur, façon bande)",
- "Failed to load {0}": "Échec du chargement de {0}",
- "Failed to load {0}: {1}": "Échec du chargement de {0} : {1}",
- "Fan the notes across the stereo field by where the ball is": "Répartir les notes dans le champ stéréo selon la position de la balle",
- "Feedback +70 %: the classic jet": "Feedback +70 % : le jet classique",
- "Feedback 0: a plain comb": "Feedback 0 : un simple peigne",
- "Feedback — how much of each repeat goes round again; Freeze pins it at 100 %. ⌥-click types, double-click resets.": "Feedback — la part de chaque répétition qui repart pour un tour ; Freeze la bloque à 100 %. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Feedback — the chain's output fed back in, ±95 %: positive sharpens the peaks, negative moves and widens the notches": "Feedback — la sortie de la chaîne réinjectée, ±95 % : positif, il affine les pics ; négatif, il déplace et élargit les encoches",
- "Feedback — the delayed signal fed back in, ±95 %: positive for the classic jet, negative for a hollow tone": "Feedback — le signal retardé réinjecté, ±95 % : positif pour le jet classique, négatif pour un timbre creux",
- "Feedback — the voices fed back into the line, ±90 %: a little thickens, past 60 % it rings metallic like a flanger": "Feedback — les voix réinjectées dans la ligne, ±90 % : un peu épaissit, au-delà de 60 % le son devient métallique comme un flanger",
- "Feedback −70 %: hollow": "Feedback −70 % : creux",
- "Fill": "Remplissage",
- "Fills the gaps between notes with runs that walk to the next pitch.": "Comble les vides entre les notes par des traits qui montent ou descendent vers la hauteur suivante.",
- "Filt 1 cutoff input": "Entrée de coupure Filt 1",
- "Filt 2 cutoff input": "Entrée de coupure Filt 2",
- "Filter off — the oscillator goes straight to the amplifier": "Filtre désactivé — l’oscillateur va directement à l’amplificateur",
- "Filter off — the sample passes untouched": "Filtre désactivé — l’échantillon passe intact",
- "Filter off — the samples pass untouched": "Filtre désactivé — les échantillons passent intacts",
- "Filter — Off, or a low-pass, band-pass or high-pass on the repeats": "Filter — Off, ou un passe-bas, passe-bande ou passe-haut sur les répétitions",
- "Fine tune of the whole instrument, ±50 cents": "Accord fin de tout l’instrument, ±50 cents",
- "Fine tune, ±50 cents": "Accord fin, ±50 cents",
- "Five-voice vintage polysynth — lush pads, brass and keys.": "Polysynthé vintage à cinq voix — nappes riches, cuivres et claviers.",
- "Fixed target — no reference": "Cible fixe — pas de référence",
- "Fixed — every note comes out at one velocity": "Fixed — toutes les notes sortent à une seule vélocité",
- "Flam": "Flam",
- "Flanger bypassed: the signal passes unchanged": "Flanger contourné : le signal passe inchangé",
- "Flatten": "Aplatir",
- "Flatten (remove source)": "Aplatir (supprimer la source)",
- "Flatten failed: {0}": "Échec de l’aplatissement : {0}",
- "Flatten keeps the frozen audio track and permanently removes its source (instrument, MIDI and devices). Continue?": "Aplatir conserve la piste audio gelée et supprime définitivement sa source (instrument, MIDI et appareils). Continuer ?",
- "Flatten replaces this track's instrument, MIDI and devices with a single audio clip of the frozen sound. ": "Aplatir remplace l’instrument, le MIDI et les appareils de cette piste par un seul clip audio du son gelé. ",
- "Flatten to audio track": "Aplatir en piste audio",
- "Flatten track": "Aplatir la piste",
- "Flattened — the frozen audio is now a plain track.": "Aplati — l’audio gelé est maintenant une piste ordinaire.",
- "Flip — cut ↔ boost (a Duck that boosts is upward expansion, a Lift that cuts is downward expansion)": "Flip — atténuation ↔ renfort (un Duck qui renforce est une expansion ascendante, un Lift qui atténue est une expansion descendante)",
- "Fold key — click for the next, Shift-click for the previous": "Fold key — cliquer pour la suivante, Maj-clic pour la précédente",
- "Fold scale — major / natural minor": "Fold scale — majeure / mineure naturelle",
- "Fold — where an out-of-scale note goes: the nearest scale note (a tie goes up), the one below or the one above": "Fold — où va une note hors gamme : la note de gamme la plus proche (à égalité, vers le haut), celle du dessous ou celle du dessus",
- "Follow key · from input": "Follow key · depuis l’entrée",
- "Follow key — the root moves to the key that best fits what you play (keeping the scale type)": "Follow key — la fondamentale se déplace vers la tonalité qui correspond le mieux à ce qui est joué (en gardant le type de gamme)",
- "Follow — copy the key and scale of a Nota Scale MIDI effect": "Follow — copie la tonalité et la gamme d’un effet MIDI Nota Scale",
- "Follow — copy the key and scale of a Nota Scale MIDI effect (this track, the MIDI source, or the first one found)": "Follow — copie la tonalité et la gamme d’un effet MIDI Nota Scale (celui de cette piste, de la source MIDI, ou le premier trouvé)",
- "Forces note lengths — staccato, legato or fixed.": "Impose les durées de notes — staccato, legato ou fixes.",
- "Formant — moves the carrier's bands against the modulator's, ±12 st: up sounds smaller, down larger": "Formant — décale les bandes de la porteuse par rapport à celles du modulateur, ±12 st : vers le haut, le son paraît plus petit ; vers le bas, plus grand",
- "Format": "Format",
- "Free: seconds per swing at +100 %": "Free : secondes par oscillation à +100 %",
- "Freeze failed: {0}": "Échec du gel : {0}",
- "Freeze the track first, then Flatten.": "Geler d’abord la piste, puis l’aplatir.",
- "Freeze {0} tracks": "Geler {0} pistes",
- "Freeze — hold the algorithm tail forever; the input is muted": "Freeze — maintient la queue de l’algorithme indéfiniment ; l’entrée est coupée",
- "Freeze — hold the loop forever; the input is muted and the repeats stop decaying": "Freeze — maintient la boucle indéfiniment ; l’entrée est coupée et les répétitions cessent de décroître",
- "Freeze — hold the tail forever; the input is muted and nothing decays": "Freeze — maintient la queue indéfiniment ; l’entrée est coupée et rien ne décroît",
- "Freeze — stop capturing and hold what is on screen": "Freeze — arrête la capture et conserve ce qui est à l’écran",
- "Freezing track {0} of {1}… {2:0} %": "Gel de la piste {0} sur {1}… {2:0} %",
- "Freezing tracks…": "Gel des pistes…",
- "Freezing track…": "Gel de la piste…",
- "Freezing track… {0:0} %": "Gel de la piste… {0:0} %",
- "Freq — the filter's frequency": "Freq — la fréquence du filtre",
- "Frequency — or drag the node left / right": "Fréquence — ou glisser le nœud à gauche / droite",
- "From — the instrument track whose notes set the target (its MIDI clips and effects, even when muted)": "From — la piste d’instrument dont les notes définissent la cible (ses clips et effets MIDI, même muette)",
- "Froze {0} of {1} tracks.": "{0} pistes sur {1} gelées.",
- "Frozen": "Gelée",
- "Frozen — its parts don't play until the track is unfrozen": "Gelée — ses parties ne jouent pas tant que la piste n’est pas dégelée",
- "Full song": "Morceau entier",
- "GAIN · 2 CYCLES": "Gain · 2 cycles",
- "Gain match — moves Gain once so the output meets the reference (the input's level, or Target) over the last 3 s, in the meter's unit": "Gain match — règle Gain une fois pour que la sortie atteigne la référence (le niveau d’entrée, ou Target) sur les 3 dernières secondes, dans l’unité du vumètre",
- "Gain reduction over the last four seconds; the dashed line is the peak. Click to clear it.": "Réduction de gain sur les quatre dernières secondes ; la ligne en pointillés est la crête. Cliquer pour l’effacer.",
- "Gain reduction — how far the gate has turned the signal down now": "Gain reduction — de combien le gate baisse le signal en ce moment",
- "Gain reduction, 0 … 24 dB": "Réduction de gain, 0 … 24 dB",
- "Gain — how hard the signal hits the preamp. Double-click resets.": "Gain — la force avec laquelle le signal attaque le préampli. Double-clic pour réinitialiser.",
- "Gain — how hard the signal is driven into the ceiling": "Gain — la force avec laquelle le signal est poussé vers le plafond",
- "Gain — or drag the node up / down (Scale multiplies it)": "Gain — ou glisser le nœud vers le haut / bas (Scale le multiplie)",
- "Gain — the output level, ±12 dB": "Gain — le niveau de sortie, ±12 dB",
- "Gain — the static gain; or drag the node up / down": "Gain — le gain statique ; ou glisser le nœud vers le haut / bas",
- "Gain, width, mono and phase — the housekeeping tool.": "Gain, largeur, mono et phase — l’outil de base.",
- "Gamepad octave: C{0}": "Octave manette : C{0}",
- "Gate envelope · trigger": "Gate envelope · trigger",
- "Gate — how long the burst lasts, in 16ths of the interval": "Gate — la durée de la rafale, en seizièmes de l’intervalle",
- "Gated glide: only between overlapping (legato) notes": "Glide conditionnel : seulement entre notes qui se chevauchent (legato)",
- "Gated — the pattern plays only while the threshold gate is open (gate × pattern)": "Gated — le motif ne joue que tant que le gate de seuil est ouvert (gate × motif)",
- "Glide — how long the target bends from one note to the next (Pitch bend from MIDI)": "Glide — la durée du glissement de la cible d’une note à la suivante (Pitch bend from MIDI)",
- "Glides between notes in mono mode": "Glisse entre les notes en mode mono",
- "Global · {0}": "Global · {0}",
- "Grace": "Appogiature",
- "Granular synth that turns a sample into clouds, textures and drones.": "Synthé granulaire qui transforme un échantillon en nuages, textures et drones.",
- "Grid — the length of the slice that repeats": "Grid — la durée de la tranche qui se répète",
- "Group {0}": "Groupe {0}",
- "Grows every note into a chord, voiced the way you would play it.": "Transforme chaque note en accord, voicé comme on le jouerait.",
- "Guitar amp and cabinet models from clean to high gain.": "Modèles d’amplis et de baffles de guitare, du son clair au fort gain.",
- "HF Damp — how much faster the highs die than the lows. Double-click resets.": "HF Damp — de combien les aigus s’éteignent plus vite que les graves. Double-clic pour réinitialiser.",
- "HPF — a high-pass on the wet input (20 Hz … 2 kHz), so the lows stay dry and centred; far left is off": "HPF — un passe-haut sur l’entrée traitée (20 Hz … 2 kHz), pour que les graves restent secs et centrés ; tout à gauche, il est désactivé",
- "Harmonics 2 … 9 of a −6 dB sine through the curve: odd partials in full ink (hard, buzzy), even ones dimmer (warm, round), and the total harmonic distortion": "Harmoniques 2 … 9 d’une sinusoïde à −6 dB passée dans la courbe : impaires en plein (dures, bourdonnantes), paires plus discrètes (chaudes, rondes), et la distorsion harmonique totale",
- "Heard through {0} — click to pick a track, scroll to step through them": "Entendu via {0} — cliquer pour choisir une piste, défiler pour les parcourir",
- "Hide the empty pads": "Masquer les pads vides",
- "Hide — it still installs when you quit": "Masquer — l’installation se fera quand même à la fermeture",
- "High — the highest band's edge, 2 … 20 kHz": "High — le bord de la bande la plus haute, 2 … 20 kHz",
- "Hold in — keep feeding the input into the frozen tail (layering)": "Hold in — continue d’envoyer l’entrée dans la queue gelée (superposition)",
- "Hold the roll showing now — it repeats every bar": "Maintenir le roulement affiché — il se répète à chaque mesure",
- "Hold — freezes every band where it is; the carrier keeps sounding through it": "Hold — fige chaque bande là où elle est ; la porteuse continue de sonner à travers",
- "Hold — keep the envelope at its peak for the HOLD time before it releases (∞ freezes it)": "Hold — garde l’enveloppe à son pic pendant le temps HOLD avant le relâchement (∞ la fige)",
- "Hold: keep arpeggiating after the keys are released": "Hold : continuer l’arpège après le relâchement des touches",
- "How deep the notches cut, dB (0 … −36 on the bar)": "Profondeur des encoches, dB (0 … −36 sur la barre)",
- "How far the balls' rates drift apart — each ball a little faster than the one before": "L’écart croissant entre les vitesses des balles — chaque balle un peu plus rapide que la précédente",
- "How far the envelope moves the cutoff, ±6 octaves": "L’amplitude du déplacement de la coupure par l’enveloppe, ±6 octaves",
- "How far the key moves the pitch — 100 % chromatic, 0 % every key plays the root": "L’influence de la touche sur la hauteur — 100 % chromatique, 0 % toutes les touches jouent la fondamentale",
- "How fast a stolen or superseded voice fades": "La vitesse d’extinction d’une voix volée ou remplacée",
- "How hard a released key damps the body — at 0 it rings on, fully up it stops at once": "La force avec laquelle une touche relâchée étouffe le corps — à 0 il continue de sonner, au maximum il s’arrête aussitôt",
- "How long each note was sung (the last ~16 bars) over the scale's notes — neutral in the scale, teal outside it. Click a column to add or remove its note": "La durée de chaque note chantée (les ~16 dernières mesures) sur les notes de la gamme — neutre dans la gamme, turquoise en dehors. Cliquer une colonne pour ajouter ou retirer sa note",
- "How long one swing (low → high → low) takes at +100 %": "La durée d’une oscillation (bas → haut → bas) à +100 %",
- "How many strikes of one key may ring together": "Le nombre de frappes d’une même touche qui peuvent sonner ensemble",
- "How many voices sing, or that the feedback makes it ring (past 60 %), or that Vibrato plays wet only": "Le nombre de voix qui chantent, ou le fait que le feedback le fait sonner (au-delà de 60 %), ou que Vibrato joue uniquement le signal traité",
- "How much louder an accented step plays": "De combien un pas accentué joue plus fort",
- "How much of the file plays, from Start": "La part du fichier jouée, à partir de Start",
- "How much quieter a release sample gets the longer the key was held — drag up / down, ⌥-click to type": "De combien l’échantillon de relâchement baisse quand la touche est tenue longtemps — glisser vers le haut / bas, ⌥-clic pour saisir",
- "How much velocity sets the level": "Dans quelle mesure la vélocité règle le niveau",
- "Humanize": "Humaniser",
- "Humanize on / off — the amount is the HUMAN slider": "Humanize activé / désactivé — la quantité est réglée par le curseur HUMAN",
- "Humanize: a random nudge to every hit's velocity": "Humanize : un léger décalage aléatoire de la vélocité de chaque frappe",
- "Hybrid reverb with early reflections and a long, dense tail.": "Réverbération hybride avec premières réflexions et longue queue dense.",
- "Hz runs the LFO free; Sync takes its rate from the tempo and locks it to the bar while the transport plays": "Hz fait tourner le LFO librement ; Sync prend sa vitesse du tempo et le cale sur la mesure pendant la lecture",
- "Import audio": "Importer de l’audio",
- "Import of {0} cancelled": "Import de {0} annulé",
- "Imported {0}": "{0} importé",
- "Imported {0} ({1} parts)": "{0} importé ({1} parties)",
- "Importing {0}…": "Import de {0}…",
- "Impulse response — built-in rooms, or your own file (drop it on the waveform)": "Impulse response — pièces intégrées, ou votre propre fichier (le déposer sur la forme d’onde)",
- "In ": "Entrée ",
- "In Scale": "Dans la gamme",
- "In Select mode the selector follows the input level instead of its handle": "En mode Select, le sélecteur suit le niveau d’entrée au lieu de sa poignée",
- "In scale": "Dans la gamme",
- "In {0} · {1} · {2} voices": "En {0} · {1} · {2} voix",
- "In {0} · {1} · {2} voices · strum {3} ms · spread {4}": "En {0} · {1} · {2} voix · strum {3} ms · spread {4}",
- "Input (teal) and output (neutral ink) over the last 8 s in the meter's unit; dashed: the target. Drag up or down for the target.": "Entrée (turquoise) et sortie (neutre) sur les 8 dernières secondes dans l’unité du vumètre ; en pointillés : la cible. Glisser vers le haut ou le bas pour la cible.",
- "Input across, output up · dashed — the Out range · band — Random · dots — the last notes": "Entrée en abscisse, sortie en ordonnée · pointillés — la plage Out · bande — Random · points — les dernières notes",
- "Input loudness on the chosen scale (LUFS); the teal mark is the target": "Volume d’entrée sur l’échelle choisie (LUFS) ; le repère turquoise est la cible",
- "Input peak, −60 … 0 dBFS": "Crête d’entrée, −60 … 0 dBFS",
- "Input silent: the measurement and the gain hold": "Entrée silencieuse : la mesure et le gain sont maintenus",
- "Input spectrum (fill) and output (line). Drag a crossover line to move it; ⌥-click to type, double-click resets. Click a band to select it.": "Spectre d’entrée (aplat) et de sortie (ligne). Glisser une ligne de crossover pour la déplacer ; ⌥-clic pour saisir, double-clic pour réinitialiser. Cliquer une bande pour la sélectionner.",
- "Input velocity across, output up. Dashed — the Out range; the band — where Random can put a note; dots — the last notes played": "Vélocité d’entrée en abscisse, de sortie en ordonnée. Pointillés — la plage Out ; la bande — où Random peut placer une note ; points — les dernières notes jouées",
- "Input → output through Drive, the mode and the levels; the dot is where the signal peaks. Drag up / down for Drive; ⌥-click types, double-click resets.": "Entrée → sortie à travers Drive, le mode et les niveaux ; le point marque la crête du signal. Glisser vers le haut / bas pour Drive ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Input → output through the device (in M/S and Multi through the selected stage): each stage alone faint, the LFO-modulated curve dashed teal, the node where the input sits now. Drag up / down for Amount; ⌥-click to type, double-click resets.": "Entrée → sortie à travers l’appareil (en M/S et Multi, à travers l’étage sélectionné) : chaque étage seul en pâle, la courbe modulée par le LFO en turquoise pointillé, le nœud là où se situe l’entrée. Glisser vers le haut / bas pour Amount ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Inst ": "Inst ",
- "Installing {0} failed: {1}": "Échec de l’installation de {0} : {1}",
- "Installing {0} was cancelled.": "L’installation de {0} a été annulée.",
- "Instrument Rack · chain {0}{1}": "Instrument Rack · chaîne {0}{1}",
- "Integrated loudness since the last Reset, gated (BS.1770), against the Target": "Volume intégré depuis le dernier Reset, avec gate (BS.1770), par rapport à Target",
- "Internal — this track": "Interne — cette piste",
- "Interval": "Intervalle",
- "Interval — how often it rolls Chance": "Interval — la fréquence à laquelle Chance est tiré",
- "Interval — how often it rolls Chance: 1/8, 1/4, 1/2 note, or every 1, 2, 4 bars": "Interval — la fréquence à laquelle Chance est tiré : 1/8, 1/4, 1/2 note, ou toutes les 1, 2, 4 mesures",
- "Invert the left channel's phase": "Inverser la phase du canal gauche",
- "Invert the right channel's phase": "Inverser la phase du canal droit",
- "Jack strip · {0} points · ": "Bandeau de prises · {0} points · ",
- "Jitter — the hold length wanders up to ±50 %: an unsteady, broken clock": "Jitter — la durée du maintien varie jusqu’à ±50 % : une horloge instable, irrégulière",
- "Jump up or down by up to two octaves": "Saute vers le haut ou le bas jusqu’à deux octaves",
- "Keep Ends": "Garder les extrémités",
- "Keeps notes in a key and scale.": "Garde les notes dans une tonalité et une gamme.",
- "Key Source is not MIDI": "Key Source n’est pas MIDI",
- "Key gain — drives the detector harder or softer. ⌥-click types, double-click resets.": "Key gain — pousse le détecteur plus ou moins fort. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Key gain — scales only the key's trace, for the eye (the sound is untouched)": "Key gain — ne met à l’échelle que la trace de la clé, pour l’œil (le son n’est pas modifié)",
- "Key source — Auto follows the key you sing, Manual uses the key and scale you set, MIDI takes the target from another track's notes (MIDI tab)": "Key source — Auto suit la tonalité chantée, Manual utilise la tonalité et la gamme réglées, MIDI prend la cible dans les notes d’une autre piste (onglet MIDI)",
- "Key source — Internal keys off this track; pick another track, or one pad or chain of it, to duck or pump against it": "Key source — Internal se déclenche sur cette piste ; choisir une autre piste, ou l’un de ses pads ou chaînes, pour ducker ou pomper contre elle",
- "Key source — Internal keys off this track; pick another track, or one pad or chain of it, to gate or duck against it": "Key source — Internal se déclenche sur cette piste ; choisir une autre piste, ou l’un de ses pads ou chaînes, pour gater ou ducker contre elle",
- "Key source — Internal limits on this track's own peaks; pick another track to duck this one when that one peaks": "Key source — Internal limite selon les crêtes de cette piste ; choisir une autre piste pour ducker celle-ci quand l’autre atteint son pic",
- "Key — Self: the band listens to this track · Ext: to the key track (click Ext again to pick the track)": "Key — Self : la bande écoute cette piste · Ext : la piste de clé (cliquer à nouveau sur Ext pour choisir la piste)",
- "Key — draw another track's audio over this one, in teal": "Key — superposer en turquoise l’audio d’une autre piste à celui-ci",
- "Key — the tonic; the scale's notes are counted from it": "Key — la tonique ; les notes de la gamme sont comptées à partir d’elle",
- "Keyboard octave: C{0}": "Octave clavier : C{0}",
- "Keyboard velocity: {0}": "Vélocité clavier : {0}",
- "Keys & physical": "Claviers et modélisation",
- "Keys C−1–G9 · vel 0–127": "Touches C−1–G9 · vél. 0–127",
- "Kill tail — empty the reverb at once; whatever is still ringing (or frozen) stops": "Kill tail — vide la réverbération d’un coup ; tout ce qui sonne encore (ou est gelé) s’arrête",
- "Kill the {0} band — removes it outright, with a 5 ms glide": "Kill de la bande {0} — la supprime d’un coup, avec un glissement de 5 ms",
- "LAST IN → OUT": "Dernière entrée → sortie",
- "LFO on / off": "LFO activé / désactivé",
- "LFO out (patch bay)": "LFO out (patch bay)",
- "LFO pitch → all oscillators, or only 2 and 4": "LFO pitch → tous les oscillateurs, ou seulement 2 et 4",
- "LFO rate input (patch bay)": "Entrée de vitesse LFO (patch bay)",
- "LFO rate — free 0.05 … 20 Hz, or with Sync a division from 2 bars to 1/64": "LFO rate — libre 0,05 … 20 Hz, ou avec Sync une division de 2 mesures à 1/64",
- "LFO → Drive — the LFO sweeps every stage's drive, up to ±30 %": "LFO → Drive — le LFO balaie le drive de chaque étage, jusqu’à ±30 %",
- "LOOP HELD · no decay": "Boucle maintenue · sans déclin",
- "Label — a short name shown next to the band's node (up to 24 characters)": "Label — un nom court affiché près du nœud de la bande (jusqu’à 24 caractères)",
- "Labels — show the bands' labels and note marks in the graph (the chips and the band panel keep them)": "Labels — affiche les étiquettes et repères de note des bandes dans le graphique (les pastilles et le panneau de bande les conservent)",
- "Latch the chord — it keeps swinging after you let go; the next chord replaces it": "Latch de l’accord — il continue d’osciller après le relâchement ; l’accord suivant le remplace",
- "Latch — the Repeat button stays on after a click instead of only while held": "Latch — le bouton Repeat reste actif après un clic au lieu de l’être seulement tant qu’il est tenu",
- "Latency comp.": "Comp. de latence",
- "Layered looper with overdubs.": "Looper à couches avec superpositions.",
- "Layers several instruments in parallel chains.": "Superpose plusieurs instruments dans des chaînes parallèles.",
- "Lays down a pattern that leans on the strong beats, as densely as you ask.": "Pose un motif qui s’appuie sur les temps forts, aussi dense qu’on le demande.",
- "Learn — listen to what is sung, then click again to set the key and scale that fit it best": "Learn — écoute ce qui est chanté, puis cliquer à nouveau pour régler la tonalité et la gamme qui conviennent le mieux",
- "Learn — play the notes of your scale; they pass through untouched and become the Custom scale. Click again to finish.": "Learn — jouer les notes de la gamme ; elles passent intactes et deviennent la gamme Custom. Cliquer à nouveau pour terminer.",
- "Learns the clip's intervals and rhythm, then writes a new take in the same voice.": "Apprend les intervalles et le rythme du clip, puis écrit une nouvelle prise dans le même style.",
- "Left edit mode (the frozen audio was not changed).": "Mode d’édition quitté (l’audio gelé n’a pas été modifié).",
- "Left handle: low cut (X) + low shelf (Y) · right handle: high cut (X) + high shelf (Y) · ⌥-click to type": "Poignée gauche : coupe-bas (X) + shelf grave (Y) · poignée droite : coupe-haut (X) + shelf aigu (Y) · ⌥-clic pour saisir",
- "Legato · retrigger held": "Legato · redéclenchement des notes tenues",
- "Length mode: Sync / ms / Gate % — click for the next, Shift-click for the previous": "Mode de durée : Sync / ms / Gate % — cliquer pour le suivant, Maj-clic pour le précédent",
- "Length — drag up / down, double-click resets": "Length — glisser vers le haut / bas, double-clic pour réinitialiser",
- "Let the amp envelope open (or close) the filter": "Laisser l’enveloppe d’ampli ouvrir (ou fermer) le filtre",
- "Let the amp envelope open (or close) the filter — the depth is ENV": "Laisser l’enveloppe d’ampli ouvrir (ou fermer) le filtre — la profondeur est ENV",
- "Level and pitch jitter per note": "Variation aléatoire du niveau et de la hauteur par note",
- "Leveler bypassed: the output equals the input": "Leveler contourné : la sortie est égale à l’entrée",
- "Levels — 4, 8 or 16 heights a step snaps to": "Levels — 4, 8 ou 16 hauteurs sur lesquelles un pas se cale",
- "Lift — acts as it falls below it (a boost by default)": "Lift — agit quand le signal passe en dessous (un renfort par défaut)",
- "Lift — acts below the threshold": "Lift — agit sous le seuil",
- "Line up chains with different latency": "Aligner des chaînes de latences différentes",
- "Link L/R — the right channel follows the left's time": "Link L/R — le canal droit suit le temps du gauche",
- "Listen — hear the detector's key signal (the sidechain, or the input), per solo band": "Listen — écouter le signal de clé du détecteur (le sidechain, ou l’entrée), par bande en solo",
- "Listen — hear the filtered key instead of the output, to set HP / LP by ear": "Listen — écouter la clé filtrée au lieu de la sortie, pour régler HP / LP à l’oreille",
- "Listen — hear the key as the detector hears it (after its filter), to tune the band": "Listen — écouter la clé comme l’entend le détecteur (après son filtre), pour régler la bande",
- "Listening for notes…": "À l’écoute des notes…",
- "Listening to the detector key": "À l’écoute de la clé du détecteur",
- "Live freeze failed: {0}": "Échec du gel en direct : {0}",
- "Live — the graph follows the audio; click to freeze the picture": "Live — le graphique suit l’audio ; cliquer pour figer l’image",
- "Live-freeze link removed — its track was deleted.": "Lien de gel en direct supprimé — sa piste a été supprimée.",
- "Load a one-shot into this voice (or drop a file on the voice)": "Charger un one-shot dans cette voix (ou déposer un fichier sur la voix)",
- "Load a sample into {0}": "Charger un échantillon dans {0}",
- "Load an impulse response (WAV / FLAC / MP3 — mono, stereo or 4-ch true stereo)": "Charger une réponse impulsionnelle (WAV / FLAC / MP3 — mono, stéréo ou vrai stéréo 4 canaux)",
- "Load impulse response…": "Charger une réponse impulsionnelle…",
- "Loading · {0} / {1} · notes muted": "Chargement · {0} / {1} · notes coupées",
- "Lock — hold the roll showing now": "Lock — maintenir le roulement affiché",
- "Logarithmic": "Logarithmique",
- "Lookahead — 0, 1 or 5 ms": "Lookahead — 0, 1 ou 5 ms",
- "Lookahead — the gate opens this much before the transient arrives (the track is delayed by it)": "Lookahead — le gate s’ouvre aussi tôt avant l’arrivée du transitoire (la piste est retardée d’autant)",
- "Looking for plugins…": "Recherche de plug-ins…",
- "Low / mid crossover": "Crossover grave / médium",
- "Low — the lowest band's edge, 20 Hz … 1 kHz": "Low — le bord de la bande la plus basse, 20 Hz … 1 kHz",
- "MIDI effect · {0}": "Effet MIDI · {0}",
- "MIDI effects run in the first 16 chains.": "Les effets MIDI s’exécutent dans les 16 premières chaînes.",
- "MIDI from ": "MIDI depuis ",
- "MIDI out · ch 1": "Sortie MIDI · can. 1",
- "MIDI · latency 0 smp": "MIDI · latence 0 éch.",
- "MIDI · waiting for notes": "MIDI · en attente de notes",
- "MPE pressure (aftertouch) → level": "Pression MPE (aftertouch) → niveau",
- "MPE slide (CC74) → cutoff": "Glissement MPE (CC74) → coupure",
- "Macro {0} is free — right-click (or Map) to give it a target": "La macro {0} est libre — clic droit (ou Map) pour lui donner une cible",
- "Macro {0} · {1}": "Macro {0} · {1}",
- "Make the note in the zone's file name its root": "Prendre la note du nom de fichier de la zone comme fondamentale",
- "Make-up gain. ⌥-click types, double-click resets.": "Gain de compensation. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Map a hardware control: arm, touch a control on the card, move a knob or key": "Assigner une commande matérielle : armer, toucher une commande sur la carte, bouger un potentiomètre ou une touche",
- "Map the chosen macro: click parameters in the chain": "Assigner la macro choisie : cliquer des paramètres dans la chaîne",
- "Map this macro: click parameters on the Chains tab": "Assigner cette macro : cliquer des paramètres dans l’onglet Chains",
- "Map to a macro": "Assigner à une macro",
- "Map to the selector": "Assigner au sélecteur",
- "Map → Pattern Out": "Map → Pattern Out",
- "Mapped to Macro {0} — click to change": "Assigné à la macro {0} — cliquer pour changer",
- "Match — set the manual gain to the distance between the measured input and the target": "Match — règle le gain manuel sur l’écart entre l’entrée mesurée et la cible",
- "Matrix view · drag a cell for depth, ⌥-click to type it, double-click to remove · ": "Vue matrice · glisser une cellule pour la profondeur, ⌥-clic pour la saisir, double-clic pour supprimer · ",
- "Max Steps": "Pas max.",
- "Max gain — the most the correction may boost or cut, 0 … 24 dB": "Max gain — le renfort ou l’atténuation maximum de la correction, 0 … 24 dB",
- "Melodic Steps": "Pas mélodiques",
- "Meter — LUFS-S: short-term loudness (3 s, K-weighted); Peak: sample peak; RMS: 300 ms": "Meter — LUFS-S : volume à court terme (3 s, pondération K) ; Peak : crête d’échantillon ; RMS : 300 ms",
- "Mic position — at the cone's cap (bright) or its edge (darker)": "Mic position — au centre du cône (brillant) ou sur son bord (plus sombre)",
- "Mic — Dynamic: the classic close mic; Condenser: brighter, less proximity bass; Ribbon: dark, the most proximity bass": "Mic — Dynamic : le micro proche classique ; Condenser : plus brillant, moins d’effet de proximité ; Ribbon : sombre, le plus d’effet de proximité",
- "Mid / high crossover": "Crossover médium / aigu",
- "Mirror Pitch": "Hauteur en miroir",
- "Mix at zero: only the dry signal is heard": "Mix à zéro : seul le signal sec s’entend",
- "Mix — 0 % dry, 50 % dry and wet equal, 100 % the voices alone. Vibrato is always wet": "Mix — 0 % sec, 50 % sec et traité à égalité, 100 % les voix seules. Vibrato est toujours traité",
- "Mix — 50 % gives the deepest notches; 100 % is the delayed signal alone, a vibrato": "Mix — 50 % donne les encoches les plus profondes ; 100 % est le signal retardé seul, un vibrato",
- "Mix — 50 % gives the deepest notches; 100 % is the phase-shifted signal alone": "Mix — 50 % donne les encoches les plus profondes ; 100 % est le signal déphasé seul",
- "Mix — the carrier as it came in against the vocoded sound": "Mix — la porteuse telle qu’elle arrive face au son vocodé",
- "Mix — the moving signal against the dry one": "Mix — le signal en mouvement face au signal sec",
- "Mod gain — trims the voice before the bands hear it, ±24 dB": "Mod gain — ajuste la voix avant que les bandes ne l’entendent, ±24 dB",
- "Mod on tail — the modulation wobbles the tail itself (a chorused, evolving decay); off, it moves only the early part and the tail stays still": "Mod on tail — la modulation fait osciller la queue elle-même (un déclin chorusé et évolutif) ; désactivé, elle ne bouge que le début et la queue reste immobile",
- "Mod wheel — opens the LFO onto the cutoff": "Mod wheel — ouvre le LFO sur la coupure",
- "Mode — Digital: hard truncation to the levels; Analog: a soft tanh clip before them (+4 dB, rounder); Fold: a wavefolder — more Drive folds the peaks back more times": "Mode — Digital : troncature dure aux niveaux ; Analog : un écrêtage tanh doux avant eux (+4 dB, plus rond) ; Fold : un wavefolder — plus de Drive replie les crêtes plus souvent",
- "Mode — Gate lets the signal through above the threshold; Duck turns it down while the key is above it": "Mode — Gate laisse passer le signal au-dessus du seuil ; Duck le baisse tant que la clé est au-dessus",
- "Mode — Mix: the repeats play over the dry; Insert: they replace it while they play; Gate: only the burst sounds": "Mode — Mix : les répétitions jouent par-dessus le signal sec ; Insert : elles le remplacent pendant qu’elles jouent ; Gate : seule la rafale sonne",
- "Model — the amp's voicing: how hard the preamp drives, how many stages clip, how tight the low end is and which cabinet it matches. Scroll to step.": "Model — le voicing de l’ampli : la force d’attaque du préampli, le nombre d’étages qui écrêtent, la fermeté des graves et le baffle associé. Défiler pour changer.",
- "Modelled electric piano — tine, suitcase, reed and clav with tremolo, phaser and cabinet.": "Piano électrique modélisé — tine, suitcase, reed et clav avec trémolo, phaser et baffle.",
- "Modulate with {0} {1}": "Moduler avec {0} {1}",
- "Modulation": "Modulation",
- "Modulator": "Modulateur",
- "Momentary (teal), short-term (neutral ink) and integrated (rose) loudness over the last 60 s around the target, ±1 LU shaded. Drag the target line; ⌥-click to type, double-click resets.": "Volume momentané (turquoise), à court terme (neutre) et intégré (rose) sur les 60 dernières secondes autour de la cible, ±1 LU ombré. Glisser la ligne de cible ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Mono below — removes the side below the cutoff, so the low end is mono": "Mono below — retire le signal latéral sous la coupure, pour que les graves soient mono",
- "Monophonic analog-style synth for fat basses and leads.": "Synthé monophonique de style analogique pour basses épaisses et leads.",
- "Mordent": "Mordant",
- "Mouse tool for the grid": "Outil souris pour la grille",
- "Move": "Déplacer",
- "Move Start and End to where the sound begins and fades out (−48 dB)": "Placer Start et End là où le son commence et s’éteint (−48 dB)",
- "Move Start, End and the loop to the nearest zero crossing": "Placer Start, End et la boucle au passage par zéro le plus proche",
- "Move Start, End and the loop to the nearest zero crossing — no clicks": "Placer Start, End et la boucle au passage par zéro le plus proche — sans clics",
- "Move {0} devices to “{1}” and delete “{2}”?": "Déplacer {0} appareils vers « {1} » et supprimer « {2} » ?",
- "Move {0} to “{1}” and delete “{2}” with its clips?": "Déplacer {0} vers « {1} » et supprimer « {2} » avec ses clips ?",
- "Moved {0} devices to {1}": "{0} appareils déplacés vers {1}",
- "Moved {0} devices to {1} · {2} couldn't move": "{0} appareils déplacés vers {1} · {2} n’ont pas pu être déplacés",
- "Multi-stage phaser.": "Phaser multi-étages.",
- "Multisample instrument — zones by key and velocity, round-robin and release samples; SFZ import and packs.": "Instrument multi-échantillons — zones par touche et vélocité, round-robin et échantillons de relâchement ; import SFZ et packs.",
- "Narrow with repeats — each repeat narrows the band and moves it with the pitch": "Narrow with repeats — chaque répétition rétrécit la bande et la déplace avec la hauteur",
- "New project.": "Nouveau projet.",
- "New tag": "Nouvelle étiquette",
- "Next seed — a new roll": "Graine suivante — un nouveau tirage",
- "No chain yet.": "Aucune chaîne pour l’instant.",
- "No drum hits found.": "Aucune frappe de batterie trouvée.",
- "No free routes — every sidechain route is in use": "Aucune route libre — toutes les routes de sidechain sont utilisées",
- "No harmony found.": "Aucune harmonie trouvée.",
- "No melody found.": "Aucune mélodie trouvée.",
- "No note crosses the bar line it started in": "Aucune note ne franchit la barre de mesure où elle a commencé",
- "No pads in bank {0} — drop samples on the Pads view.": "Aucun pad dans la banque {0} — déposer des échantillons dans la vue Pads.",
- "No pads in bank {0}.": "Aucun pad dans la banque {0}.",
- "No pads to map": "Aucun pad à assigner",
- "No sample · drop one from the Files tab or the browser": "Aucun échantillon · en déposer un depuis l’onglet Fichiers ou le navigateur",
- "No sample — drop one on the pad": "Aucun échantillon — en déposer un sur le pad",
- "No tags yet — add one below.": "Aucune étiquette pour l’instant — en ajouter une ci-dessous.",
- "No targets yet. Press Map, then click parameters on the Chains tab.": "Aucune cible pour l’instant. Appuyer sur Map, puis cliquer des paramètres dans l’onglet Chains.",
- "No {0} found.": "Aucun {0} trouvé.",
- "Noise gate and rhythmic trance gate.": "Noise gate et trance gate rythmique.",
- "Noise — a white noise floor under the crush, up to −50 dBFS": "Noise — un plancher de bruit blanc sous le crush, jusqu’à −50 dBFS",
- "None of its {0} samples were found. Zone settings are kept — point Mosaic at the folder that holds them.": "Aucun de ses {0} échantillons n’a été trouvé. Les réglages de zones sont conservés — indiquer à Mosaic le dossier qui les contient.",
- "None — own input": "Aucun — entrée propre",
- "None — this track's input": "Aucun — entrée de cette piste",
- "Normalize −1 dBTP": "Normaliser à −1 dBTP",
- "Not a position: type bar.beat, like 5.1": "Position invalide : saisir mesure.temps, comme 5.1",
- "Not mapped · pick it and press Map": "Non assigné · le choisir puis appuyer sur Map",
- "Nota Rhythm · voice {0}": "Nota Rhythm · voix {0}",
- "Nota project": "Projet Nota",
- "Nota {0} is available": "Nota {0} est disponible",
- "Nota {0} is downloaded. Click to restart now — or it installs the next time you quit.": "Nota {0} est téléchargé. Cliquer pour redémarrer maintenant — ou il s’installera à la prochaine fermeture.",
- "Nota {0} is ready to install. Restart Nota to finish updating — or it installs the next time you quit.": "Nota {0} est prêt à être installé. Redémarrer Nota pour terminer la mise à jour — ou il s’installera à la prochaine fermeture.",
- "Nota — {0}": "Nota — {0}",
- "Note — a longer note on what this band is for": "Note — une note plus longue sur le rôle de cette bande",
- "Note — the voice goes to the last held note; Scale — the held notes form the scale": "Note — la voix va à la dernière note tenue ; Scale — les notes tenues forment la gamme",
- "Notes are silent until loading finishes": "Les notes restent muettes jusqu’à la fin du chargement",
- "Notes no chain takes reach the instrument unchanged": "Les notes qu’aucune chaîne ne prend atteignent l’instrument inchangées",
- "Nothing mapped yet. Map gives this knob a pad control, an instrument param or any of the kit's effects.": "Rien d’assigné pour l’instant. Map donne à ce potentiomètre une commande de pad, un paramètre d’instrument ou l’un des effets du kit.",
- "Nothing to export — the arrangement is empty.": "Rien à exporter — l’arrangement est vide.",
- "Nothing to freeze — the arrangement is empty.": "Rien à geler — l’arrangement est vide.",
- "Nothing to paste here.": "Rien à coller ici.",
- "Nothing to paste.": "Rien à coller.",
- "Nothing to slice.": "Rien à découper.",
- "Nudge every hit's timing at random": "Décaler au hasard le timing de chaque frappe",
- "Octave +": "Octave +",
- "Octave −": "Octave −",
- "Octaves": "Octaves",
- "Off plays once · Fwd loops · Ping bounces · Rev loops backwards": "Off joue une fois · Fwd boucle · Ping fait des allers-retours · Rev boucle à l’envers",
- "Off plays once · Fwd loops · Ping bounces — this zone only": "Off joue une fois · Fwd boucle · Ping fait des allers-retours — cette zone uniquement",
- "Off · SEQ (steps transposed by the key) · ARP (the held chord over 1–3 octaves)": "Off · SEQ (pas transposés par la touche) · ARP (l’accord tenu sur 1 à 3 octaves)",
- "Off · low-pass · high-pass · band-pass (12 dB/oct)": "Off · passe-bas · passe-haut · passe-bande (12 dB/oct)",
- "Off — click to turn the instrument on": "Désactivé — cliquer pour activer l’instrument",
- "Offset — the right voice's LFO behind the left: 0° moves both together, 180° opposite. Ensemble spreads its three voices 120° apart on its own": "Offset — le LFO de la voix droite en retard sur la gauche : 0° les fait bouger ensemble, 180° en opposition. Ensemble espace ses trois voix de 120° de lui-même",
- "Offset — where in the interval it fires, in 16ths": "Offset — à quel endroit de l’intervalle il se déclenche, en seizièmes",
- "On — click to turn the instrument off": "Activé — cliquer pour désactiver l’instrument",
- "On: exact convolution timing at 0 ms predelay (FIR head, more CPU). Off: lighter — the first block arrives late and is absorbed into the predelay.": "On : timing de convolution exact à 0 ms de predelay (tête FIR, plus de CPU). Off : plus léger — le premier bloc arrive en retard et est absorbé dans le predelay.",
- "One ball fewer (2 at least)": "Une balle de moins (2 au minimum)",
- "One ball more (6 at most)": "Une balle de plus (6 au maximum)",
- "One bar of eight notes: dashed — the note in, filled — the note out (brightness = velocity, shifted right when delayed), × — skipped": "Une mesure de huit notes : pointillés — la note en entrée, plein — la note en sortie (luminosité = vélocité, décalée à droite si retardée), × — ignorée",
- "One knob driving several destinations.": "Un potentiomètre qui pilote plusieurs destinations.",
- "One lane per ball: x is pitch, low to high. Crossing a chord degree plays that note; teal shows the wall ahead": "Une voie par balle : x est la hauteur, du grave à l’aigu. Franchir un degré d’accord joue cette note ; le turquoise montre le mur devant",
- "One opening: attack, hold, release in the chosen shape, down to the floor (inverted for Duck). Drag a node sideways for its time, the teal floor up or down; double-click resets, ⌥-click types.": "Une ouverture : attaque, maintien, relâchement dans la forme choisie, jusqu’au plancher (inversé pour Duck). Glisser un nœud latéralement pour son temps, le plancher turquoise vers le haut ou le bas ; double-clic pour réinitialiser, ⌥-clic pour saisir.",
- "One-shots": "One-shots",
- "Only a rack with one chain can be ungrouped": "Seul un rack à une seule chaîne peut être dégroupé",
- "Only an instrument track takes MIDI effects and an instrument": "Seule une piste d’instrument accepte des effets MIDI et un instrument",
- "Only an instrument track takes an instrument.": "Seule une piste d’instrument accepte un instrument.",
- "Only chains whose range holds the selector get notes.": "Seules les chaînes dont la plage contient le sélecteur reçoivent des notes.",
- "Only chains whose range holds the selector play.": "Seules les chaînes dont la plage contient le sélecteur jouent.",
- "Only while gate open": "Uniquement gate ouvert",
- "Open Lens in its own window": "Ouvrir Lens dans sa propre fenêtre",
- "Open Nota project (.nota folder)": "Ouvrir un projet Nota (dossier .nota)",
- "Open Settings → Downloads": "Ouvrir Réglages → Téléchargements",
- "Open failed: {0}": "Échec de l’ouverture : {0}",
- "Open project": "Ouvrir un projet",
- "Open the full editor": "Ouvrir l’éditeur complet",
- "Open the full patch bay (all 42 points) · on the Patch tab: back to the last panel": "Ouvrir le patch bay complet (les 42 points) · dans l’onglet Patch : retour au dernier panneau",
- "Open the pad's instrument": "Ouvrir l’instrument du pad",
- "Open the plug-in's own window": "Ouvrir la fenêtre propre au plug-in",
- "Opened {0}": "{0} ouvert",
- "Opened {0} — {1} item(s) downgraded: {2}": "{0} ouvert — {1} élément(s) dégradé(s) : {2}",
- "Opens the mapping preview. A single file replaces the sample, as before.": "Ouvre l’aperçu de l’assignation. Un fichier seul remplace l’échantillon, comme avant.",
- "Ornament": "Ornement",
- "Osc {0} pitch input (patch bay)": "Entrée de hauteur Osc {0} (patch bay)",
- "Oscillator {0}'s note (paraphonic) · the latest voices in true poly": "Note de l’oscillateur {0} (paraphonique) · les dernières voix en vrai poly",
- "Out range — drag a handle, ⌥-click to type it, double-click resets to 1–127": "Out range — glisser une poignée, ⌥-clic pour la saisir, double-clic pour revenir à 1–127",
- "Outline — in · fill — out · band — Random's range": "Contour — entrée · aplat — sortie · bande — plage de Random",
- "Outline — the note played in · fill — the note out · band — the range Random spreads it over. The shaded part is past the bar line.": "Contour — la note jouée en entrée · aplat — la note en sortie · bande — la plage sur laquelle Random la répartit. La partie ombrée dépasse la barre de mesure.",
- "Output (plus the auto gain in effect) — drag up / down (Shift for fine), ⌥-click to type, double-click for 0 dB": "Output (plus l’auto gain en vigueur) — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour 0 dB",
- "Output correlation — +1 mono, 0 unrelated, below 0 out of phase (it cancels in mono)": "Corrélation de sortie — +1 mono, 0 sans rapport, sous 0 en opposition de phase (s’annule en mono)",
- "Output gain ±24 dB — double-click: 0 dB": "Gain de sortie ±24 dB — double-clic : 0 dB",
- "Output gain, ±12 dB": "Gain de sortie, ±12 dB",
- "Output gain, ±24 dB — drag up / down (Shift for fine), ⌥-click types, double-click resets": "Gain de sortie, ±24 dB — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour réinitialiser",
- "Output loudness on the chosen scale (LUFS); the teal mark is the target": "Volume de sortie sur l’échelle choisie (LUFS) ; le repère turquoise est la cible",
- "Output peak, −60 … 0 dBFS": "Crête de sortie, −60 … 0 dBFS",
- "Output true peak (dBTP); the teal mark is the ceiling while True-peak safe is on": "True peak de sortie (dBTP) ; le repère turquoise est le plafond tant que True-peak safe est activé",
- "Output {0} LU from the target · Match sets {1} dB": "Sortie à {0} LU de la cible · Match règle {1} dB",
- "Output — drag up / down (Shift for fine), ⌥-click to type, double-click for 0 dB": "Output — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour 0 dB",
- "Output — the level after the EQ, ±12 dB": "Output — le niveau après l’EQ, ±12 dB",
- "Output — the master level after the cabinet, ±12 dB. Double-click resets.": "Output — le niveau général après le baffle, ±12 dB. Double-clic pour réinitialiser.",
- "Output, −24 … +24 dB": "Sortie, −24 … +24 dB",
- "Oversampling — runs the stages at 2 / 4 / 8 × the rate so the harmonics above Nyquist don't fold back (minimum phase, no latency)": "Oversampling — fait tourner les étages à 2 / 4 / 8 × la fréquence pour que les harmoniques au-delà de Nyquist ne se replient pas (phase minimale, sans latence)",
- "PDC {0:0.0} ms": "PDC {0:0.0} ms",
- "POLY MOD — SOURCE → DESTINATION": "Poly mod — source → destination",
- "Pack “{0}” is not installed": "Le pack « {0} » n’est pas installé",
- "Pad bank: sixteen notes from C1, C2, C3 or C4": "Banque de pads : seize notes à partir de C1, C2, C3 ou C4",
- "Pad pan · drag up or down, ⌥-click to type, double-click to centre": "Panoramique du pad · glisser vers le haut ou le bas, ⌥-clic pour saisir, double-clic pour centrer",
- "Pad volume · drag up or down, ⌥-click to type, double-click for 0 dB": "Volume du pad · glisser vers le haut ou le bas, ⌥-clic pour saisir, double-clic pour 0 dB",
- "Pads in the same group cut each other off": "Les pads d’un même groupe se coupent mutuellement",
- "Paint {0} steps (Alt-click a step: rest)": "Peindre {0} pas (Alt-clic sur un pas : silence)",
- "Panner bypassed: the signal passes unchanged": "Panner contourné : le signal passe inchangé",
- "Parallel: both engines hear the input · Serial: the convolution feeds the algorithm": "Parallel : les deux moteurs entendent l’entrée · Serial : la convolution alimente l’algorithme",
- "Paraphonic ensemble synth — string machines and choirs.": "Synthé d’ensemble paraphonique — string machines et chœurs.",
- "Partials as the engine tunes them — drag ↔ to spread the series (Ratio), ↕ to tilt the highs (Bright)": "Partiels tels que le moteur les accorde — glisser ↔ pour étaler la série (Ratio), ↕ pour incliner les aigus (Bright)",
- "Pass through outside zones": "Laisser passer hors des zones",
- "Paste an instrument on an instrument card.": "Coller un instrument sur une carte d’instrument.",
- "Paste bounced audio failed: {0}": "Échec du collage de l’audio rendu : {0}",
- "Paste bounced audio takes a range on a single track.": "Coller l’audio rendu demande une plage sur une seule piste.",
- "Paste copied steps (fitted to the grid)": "Coller les pas copiés (ajustés à la grille)",
- "Pasted automation": "Automation collée",
- "Pasted bounced audio": "Audio rendu collé",
- "Pasted clip(s)": "Clip(s) collé(s)",
- "Pasted {0} devices, skipped {1} this chain can't take": "{0} appareils collés, {1} ignorés car cette chaîne ne peut pas les accepter",
- "Pasted {0} devices, skipped {1} this track can't take": "{0} appareils collés, {1} ignorés car cette piste ne peut pas les accepter",
- "Pattern shapes — the arrows step through them (fitted to the grid)": "Formes de motifs — les flèches les parcourent (ajustées à la grille)",
- "Peak hold — a thin line at each frequency's highest level of the last moments": "Peak hold — une ligne fine au niveau le plus haut de chaque fréquence ces derniers instants",
- "Peak hold — the detector holds each peak longer, so low notes and slow waves don't chatter the gate": "Peak hold — le détecteur maintient chaque crête plus longtemps, pour que les notes graves et les ondes lentes ne fassent pas trembler le gate",
- "Peaks in and out, and the output's crest factor (peak over RMS) — the crush flattens it": "Crêtes en entrée et en sortie, et facteur de crête de la sortie (crête sur RMS) — le crush l’aplatit",
- "Per Pitch": "Par hauteur",
- "Per note — every note rolls its own values · Per bar — one set of values for the whole bar": "Per note — chaque note tire ses propres valeurs · Per bar — un seul jeu de valeurs pour toute la mesure",
- "Period": "Période",
- "Phase 0°: L and R move together, the level dips to ": "Phase 0° : L et R bougent ensemble, le niveau descend à ",
- "Phase — the right LFO against the left: 0° tremolo, 90° a circling pan, 180° auto-pan": "Phase — le LFO droit par rapport au gauche : 0° trémolo, 90° panoramique circulaire, 180° auto-pan",
- "Phaser bypassed: the signal passes unchanged": "Phaser contourné : le signal passe inchangé",
- "Physical modelling of struck, plucked and blown bodies.": "Modélisation physique de corps frappés, pincés et soufflés.",
- "Pick a carrier track · until then the sound passes through": "Choisir une piste porteuse · d’ici là le son passe tel quel",
- "Pick an instrument — or drop one from the Browser": "Choisir un instrument — ou en déposer un depuis le Navigateur",
- "Pick the folder that holds the samples — Mosaic finds each file in it by its path or its name": "Choisir le dossier qui contient les échantillons — Mosaic y retrouve chaque fichier par son chemin ou son nom",
- "Picked for this effect: drums for dynamics, keys for time and modulation, a full mix for tone": "Choisi pour cet effet : batterie pour la dynamique, claviers pour le temps et la modulation, mix complet pour le timbre",
- "Ping-pong — each repeat crosses to the other channel": "Ping-pong — chaque répétition passe sur l’autre canal",
- "Pitch & time": "Hauteur et temps",
- "Pitch (Kick, Snare, Tom, Hats, Perc) or noise colour (Clap, Rim)": "Hauteur (Kick, Snare, Tom, Hats, Perc) ou couleur du bruit (Clap, Rim)",
- "Pitch Var": "Variation de hauteur",
- "Pitch bend from MIDI": "Pitch bend depuis le MIDI",
- "Pitch decay — each repeat drops lower, up to 6 semitones a repeat": "Pitch decay — chaque répétition descend plus bas, jusqu’à 6 demi-tons par répétition",
- "Pitch · arp (step types shape the rhythm)": "Hauteur · arp (les types de pas façonnent le rythme)",
- "Pitch · step offsets from the key": "Hauteur · décalages des pas par rapport à la touche",
- "Pitch — the internal saw's note, C0 … C7": "Pitch — la note de la dent de scie interne, C0 … C7",
- "Pitch — the repeats transposed, ±12 semitones": "Pitch — les répétitions transposées, ±12 demi-tons",
- "Play late by up to this long (a live effect can't play early)": "Jouer en retard jusqu’à cette durée (un effet en direct ne peut pas jouer en avance)",
- "Play the loaded sample": "Jouer l’échantillon chargé",
- "Play the note you pressed as well as the added notes": "Jouer la note appuyée en plus des notes ajoutées",
- "Play the region back to front": "Jouer la région à l’envers",
- "Play the synth engine": "Jouer le moteur de synthèse",
- "Plays a sample across the keyboard.": "Joue un échantillon sur tout le clavier.",
- "Plug-in presets can't go in a rack chain yet.": "Les préréglages de plug-in ne peuvent pas encore aller dans une chaîne de rack.",
- "Point the phone camera at the code. Over the cable the link is instant and needs no Wi-Fi; the code changes every 2 minutes and after each connection.": "Pointer la caméra du téléphone vers le code. Par câble, la liaison est instantanée et sans Wi-Fi ; le code change toutes les 2 minutes et après chaque connexion.",
- "Point the phone camera at the code. Same Wi-Fi only — or plug in a USB cable (USB tethering on the phone; Internet Sharing on the Mac) for an instant link. The code changes every 2 minutes and after each connection.": "Pointer la caméra du téléphone vers le code. Même Wi-Fi uniquement — ou brancher un câble USB (partage de connexion USB sur le téléphone ; Partage Internet sur le Mac) pour une liaison instantanée. Le code change toutes les 2 minutes et après chaque connexion.",
- "Poly: 16 voices · Mono: one at a time (legato with Glide) · Choke: a new note cuts the ringing ones": "Poly : 16 voix · Mono : une à la fois (legato avec Glide) · Choke : une nouvelle note coupe celles qui sonnent",
- "Poly: 8 voices ring over each other · Mono: a new strike chokes the sounding note": "Poly : 8 voix qui se chevauchent · Mono : une nouvelle frappe coupe la note qui sonne",
- "Poly: chords (click again for the voice settings) · Mono: one at a time, legato with Glide · Choke: a new note cuts the ringing ones": "Poly : accords (cliquer à nouveau pour les réglages de voix) · Mono : une à la fois, legato avec Glide · Choke : une nouvelle note coupe celles qui sonnent",
- "Port {0} is in use by another app. Pick another port.": "Le port {0} est utilisé par une autre application. Choisir un autre port.",
- "Post filter — a low-pass after the crush, 200 Hz … 20 kHz: under the Nyquist it smooths the steps": "Post filter — un passe-bas après le crush, 200 Hz … 20 kHz : sous Nyquist, il lisse les marches",
- "Power": "Alimentation",
- "Preparing audio…": "Préparation de l’audio…",
- "Preparing warped clips…": "Préparation des clips warpés…",
- "Preparing warped clips… {0:0} %": "Préparation des clips warpés… {0:0} %",
- "Press Record to lay down the first loop": "Appuyer sur Enregistrer pour poser la première boucle",
- "Preview failed: {0}": "Échec de la pré-écoute : {0}",
- "Preview volume": "Volume de pré-écoute",
- "Preview volume {0} · ⌥-click to type · double-click for 0{1}dB": "Volume de pré-écoute {0} · ⌥-clic pour saisir · double-clic pour 0{1}dB",
- "Previewing {0}": "Pré-écoute de {0}",
- "Pulls notes onto the grid, with swing and a strength short of rigid.": "Cale les notes sur la grille, avec du swing et une force qui reste souple.",
- "Pulls pitch and rhythm apart and puts them back together differently.": "Sépare hauteur et rythme puis les recompose autrement.",
- "Pulse width of the pulse wave (square stays 50 %)": "Largeur d’impulsion de l’onde pulse (le carré reste à 50 %)",
- "Pulses": "Impulsions",
- "Push the off-beat sixteenths late": "Retarder les doubles-croches en contretemps",
- "Push the velocity up or down by up to this much": "Pousser la vélocité vers le haut ou le bas jusqu’à cette valeur",
- "Put {0} devices in {1}": "Placer {0} appareils dans {1}",
- "Put {0} in {1}": "Placer {0} dans {1}",
- "Q — how narrow each band is, 1 … 10": "Q — l’étroitesse de chaque bande, 1 … 10",
- "Q — the width (the resonance on the cuts); or the wheel over the node": "Q — la largeur (la résonance sur les coupes) ; ou la molette sur le nœud",
- "Quality": "Qualité",
- "Quantize Ends": "Quantifier les fins",
- "Quantize: a crossing waits for the next 1/16 or 1/8 before it plays": "Quantize : un franchissement attend la prochaine double-croche ou croche avant de jouer",
- "Rack · {0} chains": {
- "one": "Rack · {0} chaîne",
- "other": "Rack · {0} chaînes"
- },
- "Ramp Down": "Rampe descendante",
- "Ramp Up": "Rampe ascendante",
- "Random": "Aléatoire",
- "Random Walk": "Marche aléatoire",
- "Random amount, ±0–64 velocity — drag up / down, double-click resets": "Quantité aléatoire, ±0–64 de vélocité — glisser vers le haut / bas, double-clic pour réinitialiser",
- "Random both ways, only up, or only down": "Aléatoire dans les deux sens, seulement vers le haut, ou seulement vers le bas",
- "Random transposition, timing and dropouts.": "Transposition, timing et silences aléatoires.",
- "Random — spread each note's velocity (the amount is kept while it is off)": "Random — disperse la vélocité de chaque note (la quantité est conservée tant qu’il est désactivé)",
- "Random: both ways → up → down → off — click to step, Shift-click back": "Random : deux sens → haut → bas → désactivé — cliquer pour avancer, Maj-clic pour reculer",
- "Range — how far the gain can move at full engagement (6 dB past the threshold); click the arrow to flip cut / boost": "Range — l’amplitude du gain à plein engagement (6 dB au-delà du seuil) ; cliquer la flèche pour inverser atténuation / renfort",
- "Range — the largest correction; a note further off than this is only pulled this far": "Range — la plus grande correction ; une note plus éloignée n’est ramenée que de cette valeur",
- "Ranges apply when Chains run is set to Select": "Les plages s’appliquent quand Chains run est réglé sur Select",
- "Ratchet repeats per step": "Répétitions de ratchet par pas",
- "Rate — how long the whole pattern takes: 1/4 … 4 bars in Sync, 4 … 0.25 Hz in Free": "Rate — la durée du motif entier : 1/4 … 4 mesures en Sync, 4 … 0,25 Hz en Free",
- "Rate — the free LFO rate, 0.01 … 40 Hz": "Rate — la vitesse libre du LFO, 0,01 … 40 Hz",
- "Rate — the free LFO rate, 0.02 … 8 Hz": "Rate — la vitesse libre du LFO, 0,02 … 8 Hz",
- "Rate — the note value of one LFO cycle, 2/1 … 1/16 with dotted (D) and triplet (T) values": "Rate — la valeur de note d’un cycle de LFO, 2/1 … 1/16 avec valeurs pointées (D) et en triolets (T)",
- "Rate — the note value of one LFO cycle, 4/1 … 1/16 with dotted (D) and triplet (T) values": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/16 avec valeurs pointées (D) et en triolets (T)",
- "Rate — the note value of one LFO cycle, 4/1 … 1/16 with triplet (T) values": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/16 avec valeurs en triolets (T)",
- "Rate — the note value of one LFO cycle, 4/1 … 1/32 with dotted (D) and triplet (T) values": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/32 avec valeurs pointées (D) et en triolets (T)",
- "Rate — the reduced sample rate, 500 Hz … full: lower holds each value longer and adds images above its Nyquist": "Rate — la fréquence d’échantillonnage réduite, 500 Hz … pleine : plus bas, chaque valeur est tenue plus longtemps et des images apparaissent au-dessus de sa fréquence de Nyquist",
- "Ratio above 1 : 1 expands (quiet parts get quieter); below 1 : 1 (↑) compresses upward (quiet parts are lifted). Floor limits either to ± that many dB.": "Un ratio au-dessus de 1 : 1 expanse (les passages faibles deviennent plus faibles) ; en dessous de 1 : 1 (↑) il comprime vers le haut (les passages faibles sont relevés). Floor limite les deux à ± ce nombre de dB.",
- "Re-freeze failed — the source is still live.": "Échec du nouveau gel — la source est toujours active.",
- "Re-freeze failed: {0}": "Échec du nouveau gel : {0}",
- "Re-roll the vintage seed (new per-voice spread)": "Retirer la graine vintage (nouvelle dispersion par voix)",
- "Real-time pitch correction to a key and scale.": "Correction de hauteur en temps réel vers une tonalité et une gamme.",
- "Receivers and ranges…": "Récepteurs et plages…",
- "Recombine": "Recombiner",
- "Release to build a multisample": "Relâcher pour créer un multi-échantillon",
- "Release to load the sample": "Relâcher pour charger l’échantillon",
- "Release — how fast a band closes, 5 … 1000 ms": "Release — la vitesse de fermeture d’une bande, 5 … 1000 ms",
- "Release — how fast it returns to its static gain": "Release — la vitesse de retour à son gain statique",
- "Release — how fast the gain comes back (the character scales it; Auto rel lets the signal decide)": "Release — la vitesse de retour du gain (le caractère la module ; Auto rel laisse le signal décider)",
- "Remote is off. Turn it on to show a QR code a phone on the same Wi-Fi can scan.": "La télécommande est désactivée. L’activer pour afficher un code QR qu’un téléphone sur le même Wi-Fi peut scanner.",
- "Remote is off. Turn it on to show a QR code. The first time, Windows asks whether Nota may use the network; allow private networks.": "La télécommande est désactivée. L’activer pour afficher un code QR. La première fois, Windows demande si Nota peut utiliser le réseau ; autoriser les réseaux privés.",
- "Remote is off. Turn it on to show a QR code. The first time, macOS asks to allow Nota on the local network; click Allow.": "La télécommande est désactivée. L’activer pour afficher un code QR. La première fois, macOS demande d’autoriser Nota sur le réseau local ; cliquer sur Autoriser.",
- "Remote is on · scan the code with a phone": "Télécommande activée · scanner le code avec un téléphone",
- "Remove every receiver of this macro": "Retirer tous les récepteurs de cette macro",
- "Rendering…": "Rendu…",
- "Rendering… {0:0} %": "Rendu… {0:0} %",
- "Repeat filter · off": "Repeat filter · off",
- "Repeat filter — the repeats go through the filter (Filter tab)": "Repeat filter — les répétitions passent par le filtre (onglet Filter)",
- "Repeat — repeat the current slice now, for as long as it is held (with Latch: click on, click off)": "Repeat — répète la tranche actuelle maintenant, tant qu’il est tenu (avec Latch : un clic pour activer, un clic pour arrêter)",
- "Reroll — the next seed": "Reroll — la graine suivante",
- "Res 1 against Res 2 — both at full level in the middle; in 1→2, res 1's own sound against the body it rings": "Res 1 face à Res 2 — les deux à plein niveau au milieu ; en 1→2, le son propre de res 1 face au corps qu’il fait résonner",
- "Reset peaks — clear the peak holds, the max reduction and the clip count": "Reset peaks — efface les maintiens de crête, la réduction maximale et le compte d’écrêtages",
- "Reset spread, humanize and scale to their defaults": "Réinitialiser spread, humanize et scale à leurs valeurs par défaut",
- "Reset — Gain back to 0 dB, and the meters, holds and the level history start over": "Reset — Gain revient à 0 dB, et les vumètres, maintiens et l’historique des niveaux repartent de zéro",
- "Reset — clear the peak reduction, the opening count and the history": "Reset — efface la réduction maximale, le compte d’ouvertures et l’historique",
- "Reset — restart the measurement from the loudness now, so the ride catches up at once": "Reset — relance la mesure à partir du volume actuel, pour que l’ajustement rattrape aussitôt",
- "Reset — start the integrated loudness, the range and the peaks again": "Reset — relance le volume intégré, la plage et les crêtes",
- "Reset — stop the repeat and clear the timeline and the meters": "Reset — arrête la répétition et efface la ligne de temps et les vumètres",
- "Reshapes, compresses or randomises note velocities.": "Remodèle, comprime ou randomise les vélocités des notes.",
- "Resonance — the peak at the cutoff; the dashed mark is where it is now. Double-click resets, ⌥-click types a value.": "Resonance — le pic à la coupure ; le repère en pointillés indique la valeur actuelle. Double-clic pour réinitialiser, ⌥-clic pour saisir une valeur.",
- "Resonant filter swept by an envelope follower or an LFO.": "Filtre résonant balayé par un suiveur d’enveloppe ou un LFO.",
- "Resonator 2 on / off — resonator 1 always rings": "Résonateur 2 activé / désactivé — le résonateur 1 sonne toujours",
- "Response — Slow glides over the whole Window with a 20 ms look-ahead; Fast over a quarter of it with 5 ms": "Response — Slow glisse sur toute la fenêtre Window avec 20 ms d’anticipation ; Fast sur un quart de celle-ci avec 5 ms",
- "Restart every ball from its start when a new chord begins": "Relancer chaque balle depuis son départ quand un nouvel accord commence",
- "Restart every ball's swing now": "Relancer maintenant l’oscillation de chaque balle",
- "Restart the pattern from step 1": "Relancer le motif depuis le pas 1",
- "Restart to update to Nota {0}": "Redémarrer pour passer à Nota {0}",
- "Restore lows at high Q": "Restaurer les graves à Q élevé",
- "Retrig on MIDI note": "Redéclencher sur note MIDI",
- "Retrig — every MIDI note on this track (or the key track) restarts the pattern": "Retrig — chaque note MIDI de cette piste (ou de la piste de clé) relance le motif",
- "Retrig — restart the LFO on each input onset (−24 dBFS) and when play starts": "Retrig — relance le LFO à chaque attaque d’entrée (−24 dBFS) et au démarrage de la lecture",
- "Retrigger — trigger mode: each hit fires one attack → hold → release, however long the signal stays above the threshold": "Retrigger — mode déclenché : chaque frappe lance une attaque → maintien → relâchement, quelle que soit la durée pendant laquelle le signal reste au-dessus du seuil",
- "Return — how far under the threshold the key must fall before the gate closes (stops chatter)": "Return — de combien la clé doit passer sous le seuil avant que le gate ne se ferme (évite les battements)",
- "Reverb & delay": "Réverbération et delay",
- "Reverse Pitch": "Hauteur inversée",
- "Reverse Time": "Temps inversé",
- "Rewrites note lengths — from staccato through legato to overlapping.": "Réécrit les durées de notes — du staccato au legato jusqu’au chevauchement.",
- "Rhythm": "Rythme",
- "Rhythm Var": "Variation de rythme",
- "Roll": "Roulement",
- "Roll a new pattern — Complexity sets how busy and how varied it is": "Tirer un nouveau motif — Complexity règle sa densité et sa variété",
- "Rolls the notes of a chord out in time instead of hitting them together.": "Étale dans le temps les notes d’un accord au lieu de les frapper ensemble.",
- "Root": "Fondamentale",
- "Root a semitone down": "Fondamentale un demi-ton plus bas",
- "Root a semitone up": "Fondamentale un demi-ton plus haut",
- "Root {0} plays the sample as recorded · coarse 0 · fine 0": "La fondamentale {0} joue l’échantillon tel qu’enregistré · coarse 0 · fine 0",
- "Root — click the arrows or scroll": "Root — cliquer les flèches ou défiler",
- "Rotate": "Rotation",
- "Rotate Pitch": "Rotation de hauteur",
- "Round-robin": "Round-robin",
- "Round-robin steps: the group's zones take turns 1 … N (each zone's step is set by its file)": "Étapes de round-robin : les zones du groupe jouent à tour de rôle de 1 à N (l’étape de chaque zone est définie par son fichier)",
- "Routing — Serial: 1 → 2 → 3. Parallel: all three from the same input, averaged. M/S: stage 1 drives the Mid, stage 2 the Side, stage 3 the recombined stereo. Multi: stage 1 the lows (< 180 Hz), 2 the mids, 3 the highs (> 2.4 kHz)": "Routing — Serial : 1 → 2 → 3. Parallel : les trois depuis la même entrée, moyennés. M/S : l’étage 1 traite le Mid, l’étage 2 le Side, l’étage 3 le stéréo recombiné. Multi : l’étage 1 les graves (< 180 Hz), le 2 les médiums, le 3 les aigus (> 2,4 kHz)",
- "Runs several effect chains in parallel.": "Exécute plusieurs chaînes d’effets en parallèle.",
- "S-Curve": "Courbe en S",
- "SHAPE · LFO 1": "Shape · LFO 1",
- "SHAPE · PULSE WIDTH": "Shape · pulse width",
- "SHIMMER · PITCH SHIFT": "Shimmer · pitch shift",
- "SIDECHAIN KEY — ENVELOPE SOURCE": "Clé sidechain — source de l’enveloppe",
- "Sample — pick one in Files": "Échantillon — en choisir un dans Fichiers",
- "Sample — {0}": "Échantillon — {0}",
- "Samplers": "Samplers",
- "Samples are not copied into the project; the program keeps where they are.": "Les échantillons ne sont pas copiés dans le projet ; le programme retient où ils se trouvent.",
- "Samples unavailable · notes muted": "Échantillons indisponibles · notes coupées",
- "Save Nota project": "Enregistrer le projet Nota",
- "Save failed: {0}": "Échec de l’enregistrement : {0}",
- "Save the plug-in's state as a preset": "Enregistrer l’état du plug-in comme préréglage",
- "Save your changes before opening another project?": "Enregistrer les modifications avant d’ouvrir un autre projet ?",
- "Save your changes before starting a new project?": "Enregistrer les modifications avant de commencer un nouveau projet ?",
- "Saved {0}": "{0} enregistré",
- "Saved {0} — {1} unsupported item(s) skipped: {2}": "{0} enregistré — {1} élément(s) non pris en charge ignoré(s) : {2}",
- "Scale Length": "Longueur de la gamme",
- "Scale — Chromatic, Major, Minor, Pentatonic (major or minor — click again to swap) or Custom (the notes below)": "Scale — Chromatic, Major, Minor, Pentatonic (majeure ou mineure — cliquer à nouveau pour alterner) ou Custom (les notes ci-dessous)",
- "Scale — multiplies every shelf and bell gain: 100 % as set, 0 % flat, 200 % twice as much": "Scale — multiplie le gain de chaque shelf et bell : 100 % tel que réglé, 0 % à plat, 200 % le double",
- "Scale — the notes the voice is pulled to": "Scale — les notes vers lesquelles la voix est attirée",
- "Scale — what the correction reads: Momentary (400 ms, fast and nervous), Short-term (3 s) or Integrated (12 s with BS.1770 gating, the steadiest)": "Scale — ce que lit la correction : Momentary (400 ms, rapide et nerveux), Short-term (3 s) ou Integrated (12 s avec gating BS.1770, le plus stable)",
- "Scan moves through the file · Freeze holds Position · Key moves it with the note": "Scan parcourt le fichier · Freeze maintient Position · Key la déplace avec la note",
- "Scanning plugins · {0:N0} of {1:N0}": "Analyse des plug-ins · {0:N0} sur {1:N0}",
- "Select a MIDI clip on a Drum Rack track to step it.": "Sélectionner un clip MIDI sur une piste Drum Rack pour le programmer pas à pas.",
- "Select a clip in the arrangement to edit it here": "Sélectionner un clip dans l’arrangement pour le modifier ici",
- "Select a clip to edit it.": "Sélectionner un clip pour le modifier.",
- "Select a pad to see its device chain.": "Sélectionner un pad pour voir sa chaîne d’appareils.",
- "Select a rack to take its devices out": "Sélectionner un rack pour en sortir les appareils",
- "Select a time range first (Shift+drag), then paste it bounced onto an audio track.": "Sélectionner d’abord une plage de temps (Maj+glisser), puis la coller rendue sur une piste audio.",
- "Select devices to put them in a rack": "Sélectionner des appareils pour les placer dans un rack",
- "Select range: in Select mode this chain plays while the selector is inside it": "Plage de sélection : en mode Select, cette chaîne joue tant que le sélecteur est dedans",
- "Separate Stems": "Séparer les stems",
- "Separate Stems cancelled.": "Séparation des stems annulée.",
- "Separate Stems failed: {0}": "Échec de la séparation des stems : {0}",
- "Separated \"{0}\" into drums, bass, other and vocals.": "« {0} » séparé en batterie, basse, autres et voix.",
- "Seq gate out (patch bay)": "Seq gate out (patch bay)",
- "Sequence length — drag up / down": "Longueur de la séquence — glisser vers le haut / bas",
- "Sequencer off · pick SEQ or ARP, then hold a key": "Séquenceur désactivé · choisir SEQ ou ARP, puis tenir une touche",
- "Set in the ASIO driver's settings": "À régler dans les réglages du pilote ASIO",
- "Set tempo from loop": "Régler le tempo d’après la boucle",
- "Settings → Downloads → Sample packs": "Réglages → Téléchargements → Packs d’échantillons",
- "Shape": "Forme",
- "Shape · LFO {0}": "Shape · LFO {0}",
- "Shape — Linear: straight ramps over the times; Log: the classic one-pole curve; Snap: stays open, then shuts hard": "Shape — Linear : rampes droites sur les durées ; Log : la courbe classique à un pôle ; Snap : reste ouvert, puis se ferme net",
- "Shape — sharpens Sine, Tri and Saw toward a square; on S&H it is Glide, the slide from one step to the next": "Shape — durcit Sine, Tri et Saw vers un carré ; sur S&H c’est Glide, le glissement d’un pas au suivant",
- "Shapes this track's sound with another track's voice.": "Façonne le son de cette piste avec la voix d’une autre piste.",
- "Shift every note, ±24 semitones": "Décaler toutes les notes, ±24 demi-tons",
- "Shift {0} on / off": "Décalage {0} activé / désactivé",
- "Shift {0} velocity offset — drag sideways, ⌥-click to type, double-click resets": "Décalage de vélocité {0} — glisser latéralement, ⌥-clic pour saisir, double-clic pour réinitialiser",
- "Shift {0}: drag up / down (±12 semitones) · ⌥-click to type · double-click resets": "Décalage {0} : glisser vers le haut / bas (±12 demi-tons) · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "Shimmer · pitch shift": "Shimmer · pitch shift",
- "Shimmer · shimmer mode only": "Shimmer · mode shimmer uniquement",
- "Shorten the pad's tail; hold lets it ring": "Raccourcir la queue du pad ; hold la laisse sonner",
- "Show every pad of the bank": "Afficher tous les pads de la banque",
- "Show the key's trace": "Afficher la trace de la clé",
- "Show the pad's instrument and effects": "Afficher l’instrument et les effets du pad",
- "Shows a control signal over time.": "Affiche un signal de contrôle au fil du temps.",
- "Shuffle Both": "Mélanger les deux",
- "Shuffle Pitch": "Mélanger la hauteur",
- "Shuffle Rhythm": "Mélanger le rythme",
- "Sidechain key — the envelope follows another track instead of this one. Switch on to pick the source and the key gain; right-click to change it.": "Clé sidechain — l’enveloppe suit une autre piste au lieu de celle-ci. L’activer pour choisir la source et le gain de clé ; clic droit pour la modifier.",
- "Sidechain — key every band's detector from another track (split into the same bands)": "Sidechain — pilote le détecteur de chaque bande depuis une autre piste (découpée dans les mêmes bandes)",
- "Signal tab: click to change the window — ": "Onglet Signal : cliquer pour changer la fenêtre — ",
- "Sixteen pads, each with its own sample or instrument chain.": "Seize pads, chacun avec son propre échantillon ou sa chaîne d’instruments.",
- "Size: S (260 × 260) / L (700 × 260)": "Taille : S (260 × 260) / L (700 × 260)",
- "Skip sibilants — s, sh, t and breath pass unshifted, so they don't turn metallic": "Skip sibilants — s, ch, t et le souffle passent sans transposition, pour ne pas devenir métalliques",
- "Sliced into {0} pads": "Découpé en {0} pads",
- "Slicing pads… {0}": "Découpe des pads… {0}",
- "Slide from the last note — in Mono, legato": "Glisser depuis la dernière note — en Mono, legato",
- "Slide from the last note — in Mono, legato: no retrigger": "Glisser depuis la dernière note — en Mono, legato : sans redéclenchement",
- "Slide into a note played over a held one without a new attack": "Glisser vers une note jouée par-dessus une note tenue, sans nouvelle attaque",
- "Slope of the mono cutoff — 6, 12 or 24 dB/oct; click to step": "Pente de la coupure mono — 6, 12 ou 24 dB/oct ; cliquer pour changer",
- "Slope — how steep the high-pass / low-pass falls: 12, 24 or 48 dB per octave": "Slope — la raideur du passe-haut / passe-bas : 12, 24 ou 48 dB par octave",
- "Smooth — ramps into each step instead of jumping (up to half a step)": "Smooth — monte en rampe vers chaque pas au lieu de sauter (jusqu’à un demi-pas)",
- "Snap every varied note into C major": "Ramener chaque note variée dans Do majeur",
- "Snap the generated notes to a scale": "Caler les notes générées sur une gamme",
- "Snap to Grid": "Magnétisme sur la grille",
- "Snare body ↔ noise · Hats metal ↔ noise · Perc ring ratio": "Snare corps ↔ bruit · Hats métal ↔ bruit · Perc rapport d’anneau",
- "Soft clip — a smooth ceiling at −0.3 dBFS after the output gain": "Soft clip — un plafond doux à −0,3 dBFS après le gain de sortie",
- "Solo a band — hear only that band (click again to clear)": "Solo d’une bande — n’entendre que cette bande (cliquer à nouveau pour annuler)",
- "Solo — hear this band alone": "Solo — entendre cette bande seule",
- "Some devices can't be duplicated": "Certains appareils ne peuvent pas être dupliqués",
- "Sound: the voice's source and shape · FX: its own effects, before the kit bus": "Sound : la source et la forme de la voix · FX : ses propres effets, avant le bus du kit",
- "Source — sets the detection range for a voice type or an instrument": "Source — définit la plage de détection pour un type de voix ou un instrument",
- "Span": "Étendue",
- "Span — how much of the song the scope shows, from a quarter beat to four bars": "Span — la portion du morceau affichée par l’oscilloscope, d’un quart de temps à quatre mesures",
- "Spec": "Spec",
- "Spectrum analyser, oscilloscope and level meter.": "Analyseur de spectre, oscilloscope et vumètre.",
- "Speed — how fast the voice follows the target": "Speed — la vitesse à laquelle la voix suit la cible",
- "Splits notes across chains of MIDI effects by key, velocity or a selector.": "Répartit les notes entre des chaînes d’effets MIDI selon la touche, la vélocité ou un sélecteur.",
- "Spread": "Spread",
- "Spread — pushes the right channel later, up to 50 ms. ⌥-click types, double-click resets.": "Spread — retarde le canal droit, jusqu’à 50 ms. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Spreads a number of hits as evenly as a number of steps allows.": "Répartit un nombre de frappes aussi régulièrement que le permet un nombre de pas.",
- "Square": "Carré",
- "Stacks": "Piles",
- "Stage {0} drive — how hard the stage is pushed (gain 1 … ×21, the level made up)": "Drive de l’étage {0} — la force avec laquelle l’étage est poussé (gain 1 … ×21, niveau compensé)",
- "Stage {0} feedback — its output back into its input (0 … 85 %): thicker, and on the edge of ringing with Fold / Fuzz": "Feedback de l’étage {0} — sa sortie réinjectée dans son entrée (0 … 85 %) : plus épais, et à la limite de l’accrochage avec Fold / Fuzz",
- "Stage {0} on / off": "Étage {0} activé / désactivé",
- "Stage {0} output, −12 … +12 dB — drag up / down, ⌥-click to type, double-click resets": "Sortie de l’étage {0}, −12 … +12 dB — glisser vers le haut / bas, ⌥-clic pour saisir, double-clic pour réinitialiser",
- "Static — a plain EQ band · Duck — acts as the band's level rises above the threshold (a cut by default) · ": "Static — une bande d’EQ simple · Duck — agit quand le niveau de la bande dépasse le seuil (une atténuation par défaut) · ",
- "Stay in scale · C maj": "Rester dans la gamme · Do maj",
- "Step arpeggiator with groove lanes.": "Arpégiateur pas à pas avec voies de groove.",
- "Step rate (synced to the host tempo)": "Vitesse des pas (synchronisée au tempo de l’hôte)",
- "Steps": "Pas",
- "Steps — 8, 16 or 32 (the pattern is stretched to fit)": "Steps — 8, 16 ou 32 (le motif est étiré pour s’y adapter)",
- "Stereo and ping-pong delay synced to the tempo.": "Delay stéréo et ping-pong synchronisé au tempo.",
- "Stereo link — one reduction for both channels; off, left and right compress on their own": "Stereo link — une seule réduction pour les deux canaux ; désactivé, gauche et droite compressent séparément",
- "Stereo phase — the right channel's LFO runs ahead of the left (90° when switched on; right-click steps 45° … 180°)": "Stereo phase — le LFO du canal droit avance sur celui du gauche (90° une fois activé ; clic droit par pas de 45° … 180°)",
- "Stereo — the right LFO against the left: 0° sweeps both together, 90° spreads them, 180° moves them opposite": "Stereo — le LFO droit par rapport au gauche : 0° balaie les deux ensemble, 90° les écarte, 180° les fait évoluer en opposition",
- "Stiffness sets the contact time: soft = long and dark, hard = short and bright": "Stiffness règle le temps de contact : doux = long et sombre, dur = court et brillant",
- "Stop loading — the instrument empties (undo brings it back)": "Arrêter le chargement — l’instrument se vide (annuler le rétablit)",
- "Stop recording to change it": "Arrêter l’enregistrement pour le modifier",
- "String · 2 pickups": "Corde · 2 micros",
- "Strum": "Strum",
- "Style": "Style",
- "Sustain pedal — click to hold it down; a keyboard's CC64 works too": "Pédale de sustain — cliquer pour la maintenir enfoncée ; le CC64 d’un clavier fonctionne aussi",
- "Swing": "Swing",
- "Swing speed — centre stops the balls, left of centre runs them in reverse": "Vitesse d’oscillation — le centre arrête les balles, à gauche du centre elles repartent en sens inverse",
- "Swing — every second step comes late": "Swing — un pas sur deux arrive en retard",
- "Swing: delays every second 16th — at 100 % by half a step": "Swing : retarde une double-croche sur deux — à 100 %, d’un demi-pas",
- "Sync — line the scope up with the song's beats and bars": "Sync — aligne l’oscilloscope sur les temps et les mesures du morceau",
- "Sync — the LFO rate as a note division locked to the song, or free in Hz": "Sync — la vitesse du LFO en valeur de note calée sur le morceau, ou libre en Hz",
- "Sync — the wow follows the tempo: one sway every 4 bars … 1/8 (RATE picks it)": "Sync — le wow suit le tempo : une oscillation toutes les 4 mesures … 1/8 (RATE la choisit)",
- "Sync: a swing takes a note division of the tempo · Free: it takes a time in seconds": "Sync : une oscillation dure une valeur de note du tempo · Free : elle dure un temps en secondes",
- "Sync: a tempo division · ms: a fixed time · Gate %: a share of how long each note was held": "Sync : une division du tempo · ms : un temps fixe · Gate % : une part de la durée de tenue de chaque note",
- "Synth: the voice's own engine · Sample: a loaded one-shot (loads one if the voice has none)": "Synth : le moteur propre de la voix · Sample : un one-shot chargé (en charge un si la voix n’en a pas)",
- "Synths": "Synthés",
- "Tags — title & colour": "Étiquettes — titre et couleur",
- "Tail held · no decay": "Queue maintenue · sans déclin",
- "Tap four times to set the delay time by ear (switches to free ms)": "Taper quatre fois pour régler le temps de delay à l’oreille (passe en ms libres)",
- "Tape and tube saturation — warmth, wow and flutter.": "Saturation à bande et à lampes — chaleur, wow et flutter.",
- "Target loudness, −36 … 0 LUFS. Click the value for the standards or to match another track's loudness (a reference); drag the dashed line in the graph for the same": "Volume cible, −36 … 0 LUFS. Cliquer sur la valeur pour les standards ou pour s’aligner sur le volume d’une autre piste (une référence) ; glisser la ligne en pointillés du graphique pour la même chose",
- "Target — Off; Volume: the pattern gates the audio; Map: the audio is left alone and the pattern drives Pattern Out, a CV source in the Modular view": "Target — Off ; Volume : le motif gate l’audio ; Map : l’audio n’est pas touché et le motif pilote Pattern Out, une source CV de la vue Modulaire",
- "Target — the loudness the meters compare against: −14 for streaming, −16 podcasts, −23 broadcast. It does not change the sound; drag the dashed line for any value": "Target — le volume auquel les vumètres se comparent : −14 pour le streaming, −16 pour les podcasts, −23 pour la diffusion. Cela ne change pas le son ; glisser la ligne en pointillés pour toute valeur",
- "Target — what the reaction drives": "Target — ce que pilote la réaction",
- "Tension": "Tension",
- "That converter isn't available yet.": "Ce convertisseur n’est pas encore disponible.",
- "The LFO rate: in Hz, or the note value it takes from the tempo": "La vitesse du LFO : en Hz, ou la valeur de note prise sur le tempo",
- "The LFO shape that sweeps the delay: Sine glides, Tri sweeps evenly, Saw rises and drops back": "La forme du LFO qui balaie le delay : Sine glisse, Tri balaie régulièrement, Saw monte puis retombe",
- "The LFO shape that sweeps the stages: Sine glides, Tri sweeps evenly, Saw rises and drops back": "La forme du LFO qui balaie les étages : Sine glisse, Tri balaie régulièrement, Saw monte puis retombe",
- "The LFO shape. S&H draws a random step every cycle; the right channel plays the same steps Phase later": "La forme du LFO. S&H tire un pas aléatoire à chaque cycle ; le canal droit joue les mêmes pas avec un décalage Phase",
- "The LFO's movement over the window — raw shape dashed, what the filter follows (after Smooth) in neutral ink, the right channel in rose when stereo is on. Drag up or down for the amount, sideways for the start phase.": "Le mouvement du LFO sur la fenêtre — forme brute en pointillés, ce que suit le filtre (après Smooth) en neutre, le canal droit en rose quand la stéréo est activée. Glisser vers le haut ou le bas pour la quantité, latéralement pour la phase de départ.",
- "The articulation — the SFZ's controller value its zones were chosen by": "L’articulation — la valeur de contrôleur du SFZ selon laquelle ses zones ont été choisies",
- "The band the repeats live in — drag the left handle for the low cut, the right one for the high cut. ⌥-click a handle to type it, double-click to open it.": "La bande dans laquelle vivent les répétitions — glisser la poignée gauche pour le coupe-bas, la droite pour le coupe-haut. ⌥-clic sur une poignée pour la saisir, double-clic pour l’ouvrir.",
- "The bar: generated notes land on the 1/16 grid — this bar in neutral ink with the note just played in accent, the last bar dimmer ahead of the playhead": "La mesure : les notes générées tombent sur la grille de doubles-croches — cette mesure en neutre avec la note qui vient de jouer en accent, la mesure précédente plus pâle devant la tête de lecture",
- "The cabinet as the mic hears it, with the low / high cuts — dashed is the same cab and mic on axis at the cap, 5 cm away. Drag sideways to move the mic off axis, up to bring it closer.": "Le baffle tel que l’entend le micro, avec les coupures grave / aigu — en pointillés le même baffle et micro dans l’axe, au centre du cône, à 5 cm. Glisser latéralement pour désaxer le micro, vers le haut pour le rapprocher.",
- "The channel's output peak, −60 … 0 dBFS, and the gain the LFO gives it now, dB": "La crête de sortie du canal, −60 … 0 dBFS, et le gain que le LFO lui donne en ce moment, dB",
- "The clip editor is in its own window": "L’éditeur de clips est dans sa propre fenêtre",
- "The comb the delay carves into the spectrum, L neutral and R teal, with the first notch dashed. Drag left / right to move the notch (Delay), up / down for Feedback; ⌥-click types, double-click resets both.": "Le peigne que le delay creuse dans le spectre, L neutre et R turquoise, avec la première encoche en pointillés. Glisser à gauche / droite pour déplacer l’encoche (Delay), vers le haut / bas pour Feedback ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
- "The corner frequency of both channels over two LFO cycles (20 Hz … 20 kHz), and where each is now": "La fréquence de coin des deux canaux sur deux cycles du LFO (20 Hz … 20 kHz), et la position actuelle de chacune",
- "The correction applied, ±Max Gain around 0 dB (trim not included)": "La correction appliquée, ±Max Gain autour de 0 dB (trim non inclus)",
- "The correction around 0 dB, ±Max Gain. In Manual drag it (Shift for fine steps); ⌥-click types, double-click resets to 0 dB. In Auto it shows the ride": "La correction autour de 0 dB, ±Max Gain. En Manual, la glisser (Maj pour les pas fins) ; ⌥-clic pour saisir, double-clic pour revenir à 0 dB. En Auto, elle montre l’ajustement",
- "The correction now — up or down from the centre, full height = 2 semitones": "La correction actuelle — vers le haut ou le bas depuis le centre, pleine hauteur = 2 demi-tons",
- "The cutoff follows the key": "La coupure suit la touche",
- "The cutoff follows the key, 0 … 100 %": "La coupure suit la touche, 0 … 100 %",
- "The decay tail — the impulse at the pre-delay (teal), the early reflections (drawn magnified), then the RT60 curve over 4 s. Drag the teal marker for the pre-delay, drag the tail for the decay; ⌥-click to type, double-click to reset.": "La queue de déclin — l’impulsion au pre-delay (turquoise), les premières réflexions (dessinées agrandies), puis la courbe RT60 sur 4 s. Glisser le repère turquoise pour le pre-delay, la queue pour le déclin ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "The delay τ of both channels over two LFO cycles, and where each is now": "Le retard τ des deux canaux sur deux cycles du LFO, et la position actuelle de chacun",
- "The detected pitch (teal dots) and the corrected output (neutral ink) over the last two seconds, on the scale's note lanes; the target lane is lit": "La hauteur détectée (points turquoise) et la sortie corrigée (neutre) sur les deux dernières secondes, sur les voies de notes de la gamme ; la voie cible est allumée",
- "The detected pitch, low to high across the detection range (Detect tab)": "La hauteur détectée, du grave à l’aigu sur la plage de détection (onglet Detect)",
- "The detector's band-pass (teal) — only this part of the key opens the gate — over the reduction in the window (neutral ink). Drag the nodes sideways; double-click resets, ⌥-click types.": "Le passe-bande du détecteur (turquoise) — seule cette partie de la clé ouvre le gate — au-dessus de la réduction dans la fenêtre (neutre). Glisser les nœuds latéralement ; double-clic pour réinitialiser, ⌥-clic pour saisir.",
- "The device can't go there.": "L’appareil ne peut pas aller là.",
- "The diffuser lengthens the loop by a fixed group delay; on, the read pointer is pulled back by exactly that so each repeat lands on the set time.": "Le diffuseur allonge la boucle d’un retard de groupe fixe ; activé, le pointeur de lecture est reculé d’autant pour que chaque répétition tombe sur le temps réglé.",
- "The end must be after the start": "La fin doit être après le début",
- "The first notch now, over the range the sweep moves it (20 Hz … 20 kHz)": "La première encoche actuelle, sur la plage où le balayage la déplace (20 Hz … 20 kHz)",
- "The gain reduction over the last 4 s: teal where a transient got through to the clip, the dashed line is the mean": "La réduction de gain sur les 4 dernières secondes : turquoise là où un transitoire est passé jusqu’à l’écrêtage, la ligne en pointillés est la moyenne",
- "The harmonics the preamp adds at the input's level (the fundamental at the top). Drag up or down for the gain.": "Les harmoniques ajoutées par le préampli au niveau de l’entrée (la fondamentale en haut). Glisser vers le haut ou le bas pour le gain.",
- "The harmonics the saturation adds at the input's level (the fundamental at the top), against the hiss floor in teal. Drag up or down for the drive, ⌥-click to type it.": "Les harmoniques ajoutées par la saturation au niveau de l’entrée (la fondamentale en haut), face au plancher de souffle en turquoise. Glisser vers le haut ou le bas pour le drive, ⌥-clic pour le saisir.",
- "The input (teal) and what passes (neutral ink) over the window, with the threshold (dashed) and where the gate closes again (dashed). Drag a line up or down; double-click resets it, ⌥-click types it.": "L’entrée (turquoise) et ce qui passe (neutre) sur la fenêtre, avec le seuil (pointillés) et le point où le gate se referme (pointillés). Glisser une ligne vers le haut ou le bas ; double-clic pour la réinitialiser, ⌥-clic pour la saisir.",
- "The input after Gain, with the ceiling marked": "L’entrée après Gain, avec le plafond marqué",
- "The input diffuser delays the tail by a fixed group delay; on, the pre-delay is shortened by exactly that so the tail starts on the set pre-delay (it cannot go below zero).": "Le diffuseur d’entrée retarde la queue d’un retard de groupe fixe ; activé, le pre-delay est raccourci d’autant pour que la queue démarre au pre-delay réglé (il ne peut pas descendre sous zéro).",
- "The input peak, −60 … 0 dBFS": "La crête d’entrée, −60 … 0 dBFS",
- "The input's envelope (teal) and the cutoff it drives (neutral ink), the base cutoff dashed. Drag up or down for the amount.": "L’enveloppe de l’entrée (turquoise) et la coupure qu’elle pilote (neutre), la coupure de base en pointillés. Glisser vers le haut ou le bas pour la quantité.",
- "The input's level in the meter's unit (LUFS-S, 1 s peak or 300 ms RMS)": "Le niveau de l’entrée dans l’unité du vumètre (LUFS-S, crête 1 s ou RMS 300 ms)",
- "The key in effect: root and scale": "La tonalité en vigueur : fondamentale et gamme",
- "The key that fits what was sung (Krumhansl profiles over the last ~16 bars), and the runner-up. Learn sets it; Auto follows it": "La tonalité qui correspond à ce qui a été chanté (profils de Krumhansl sur les ~16 dernières mesures), et la seconde. Learn la règle ; Auto la suit",
- "The key's spectrum under its filters — drag a handle sideways to move HP / LP, up / down for Q. ⌥-click a handle to type it, double-click to open it.": "Le spectre de la clé sous ses filtres — glisser une poignée latéralement pour déplacer HP / LP, vers le haut / bas pour Q. ⌥-clic sur une poignée pour la saisir, double-clic pour l’ouvrir.",
- "The keyed part was deleted — undo brings it back": "La partie pilotée a été supprimée — annuler la rétablit",
- "The kit's eight macros — knobs over every voice and its effects": "Les huit macros du kit — des potentiomètres sur chaque voix et ses effets",
- "The kit's output level": "Le niveau de sortie du kit",
- "The largest detune the sweep reaches, ± cents (0 … 60 on the bar)": "Le plus grand désaccord atteint par le balayage, ± cents (0 … 60 sur la barre)",
- "The last 12 notes: outline — velocity in, fill — velocity out": "Les 12 dernières notes : contour — vélocité en entrée, aplat — vélocité en sortie",
- "The last 4 s: the input (teal), the part over the ceiling (red) and the output (neutral ink), with the reduction under it. Drag the ceiling line; ⌥-click to type, double-click resets.": "Les 4 dernières secondes : l’entrée (turquoise), la partie au-dessus du plafond (rouge) et la sortie (neutre), avec la réduction en dessous. Glisser la ligne du plafond ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "The last 8 s: input, output and the target with its ±1 LU band (momentary loudness). Drag up / down to move the target; ⌥-click types, double-click resets it": "Les 8 dernières secondes : entrée, sortie et cible avec sa bande de ±1 LU (volume momentané). Glisser vers le haut / bas pour déplacer la cible ; ⌥-clic pour saisir, double-clic pour la réinitialiser",
- "The last interval's sound (teal) on the grid: the gate from the offset is shaded and the captured slice is brass. Drag the offset line or the gate's end sideways; ⌥-click to type, double-click resets.": "Le son du dernier intervalle (turquoise) sur la grille : le gate à partir de l’offset est ombré et la tranche capturée est en laiton. Glisser latéralement la ligne d’offset ou la fin du gate ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "The last note played and what it came out as": "La dernière note jouée et ce qu’elle est devenue",
- "The level after everything": "Le niveau après tout le reste",
- "The level the detector compares — this track's input, or the key when an external sidechain drives it; the dashed tick is the threshold": "Le niveau que compare le détecteur — l’entrée de cette piste, ou la clé quand un sidechain externe le pilote ; le repère en pointillés est le seuil",
- "The modulator is the sound of the track the vocoder sits on — the voice": "Le modulateur est le son de la piste sur laquelle se trouve le vocoder — la voix",
- "The modulator's level in each band (bars) and the carrier's (teal). Drag an edge to move Low or High; ⌥-click an edge to type it, double-click resets it.": "Le niveau du modulateur dans chaque bande (barres) et celui de la porteuse (turquoise). Glisser un bord pour déplacer Low ou High ; ⌥-clic sur un bord pour le saisir, double-clic pour le réinitialiser.",
- "The notches the stages cut into the spectrum, L neutral and R teal, with the corner dashed and each notch ticked on top. Drag left / right to move Center, up / down for Feedback; ⌥-click types, double-click resets both.": "Les encoches que les étages creusent dans le spectre, L neutre et R turquoise, avec le coin en pointillés et chaque encoche repérée en haut. Glisser à gauche / droite pour déplacer Center, vers le haut / bas pour Feedback ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
- "The oscillator whose table and warp mode this strip edits": "L’oscillateur dont cette tranche modifie la table et le mode de warp",
- "The output peak, −60 … 0 dBFS": "La crête de sortie, −60 … 0 dBFS",
- "The output spectrum: neutral ink is the signal, teal what the crush added — bright above the reduced Nyquist (the images). Drag the Nyquist line for Rate, the filter line for the post filter; ⌥-click types, double-click resets.": "Le spectre de sortie : le neutre est le signal, le turquoise ce qu’a ajouté le crush — vif au-dessus du Nyquist réduit (les images). Glisser la ligne de Nyquist pour Rate, la ligne du filtre pour le post filter ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "The output's level in the meter's unit": "Le niveau de la sortie dans l’unité du vumètre",
- "The output's stereo field by frequency over the last second — lows at the bottom, highs at the top. Solid: where each band sits between L and R; teal: how far it spreads; dashed: how far the width setting spreads an uncorrelated band. Drag sideways for the balance, up or down for the width.": "Le champ stéréo de la sortie par fréquence sur la dernière seconde — graves en bas, aigus en haut. Plein : la position de chaque bande entre L et R ; turquoise : son étalement ; pointillés : l’étalement que le réglage de largeur donne à une bande non corrélée. Glisser latéralement pour la balance, vers le haut ou le bas pour la largeur.",
- "The pitch drift over the last four seconds — wow in neutral ink, flutter in teal. Drag up or down for the depth of what is picked above, sideways for its rate; ⌥-click to type them.": "La dérive de hauteur sur les quatre dernières secondes — wow en neutre, flutter en turquoise. Glisser vers le haut ou le bas pour la profondeur de ce qui est choisi au-dessus, latéralement pour sa vitesse ; ⌥-clic pour les saisir.",
- "The pitch wheel's range (MPE bends are per note)": "La plage de la molette de hauteur (les bends MPE sont par note)",
- "The rack's chain has no instrument to put back": "La chaîne du rack n’a aucun instrument à remettre",
- "The range each voice's delay sweeps, ms (0 … 24 on the bar)": "La plage balayée par le retard de chaque voix, ms (0 … 24 sur la barre)",
- "The range the corner sweeps (20 Hz … 20 kHz on the bar), and the first notch now": "La plage balayée par le coin (20 Hz … 20 kHz sur la barre), et la première encoche actuelle",
- "The range the macro sweeps: drag either end · the tick is where it is now": "La plage balayée par la macro : glisser l’une ou l’autre extrémité · le repère indique la position actuelle",
- "The reduction (neutral ink, hanging from 0 dB) against the input level (teal) — attack is the fall, release the climb back. The dashed line is the threshold.": "La réduction (neutre, suspendue à 0 dB) face au niveau d’entrée (turquoise) — l’attaque est la descente, le relâchement la remontée. La ligne en pointillés est le seuil.",
- "The release samples' level": "Le niveau des échantillons de relâchement",
- "The repeat filter — only the repeats go through it. Solid: the first repeat; teal dashed: a later one when the band narrows and follows the pitch. Drag the node for the frequency, a band edge for the width; ⌥-click to type, double-click resets.": "Le filtre des répétitions — seules les répétitions le traversent. Plein : la première répétition ; turquoise en pointillés : une suivante quand la bande se resserre et suit la hauteur. Glisser le nœud pour la fréquence, un bord de bande pour la largeur ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "The repeat train — L above the axis, R below. Height is the level left after each pass; the repeat sounding now is lit.": "Le train de répétitions — L au-dessus de l’axe, R en dessous. La hauteur est le niveau restant après chaque passage ; la répétition qui sonne en ce moment est allumée.",
- "The repeats' level — after pitch, filter, decay and volume": "Le niveau des répétitions — après hauteur, filtre, déclin et volume",
- "The root note — scroll to step it": "La note fondamentale — défiler pour la changer",
- "The root — the key that plays the sample as recorded. Scroll to step it · double-click takes it from the file name (C4 if none)": "La fondamentale — la touche qui joue l’échantillon tel qu’enregistré. Défiler pour la changer · double-clic la prend dans le nom du fichier (C4 à défaut)",
- "The sample's file name isn't known": "Le nom de fichier de l’échantillon est inconnu",
- "The sample's level before the envelope": "Le niveau de l’échantillon avant l’enveloppe",
- "The samples aren't where the program says": "Les échantillons ne sont pas là où le programme l’indique",
- "The selected band's dynamic gain right now": "Le gain dynamique de la bande sélectionnée en ce moment",
- "The selected band's input peaks (grey) and what its compressor's detector makes of them (the last ~1.5 s), against the threshold.": "Les crêtes d’entrée de la bande sélectionnée (gris) et ce qu’en fait le détecteur de son compresseur (les ~1,5 dernières secondes), face au seuil.",
- "The selected range has no audio or instrument track to bounce.": "La plage sélectionnée ne contient aucune piste audio ou d’instrument à rendre.",
- "The selected stage's type — Tube: soft, asymmetric, warm; Tape: soft and even; Diode: hard on one side; Fuzz: squared-off, dense; Fold: folds the peaks back, bright and metallic; Digital: a hard clip": "Le type de l’étage sélectionné — Tube : doux, asymétrique, chaud ; Tape : doux et régulier ; Diode : dur d’un côté ; Fuzz : carré, dense ; Fold : replie les crêtes, brillant et métallique ; Digital : un écrêtage dur",
- "The selected voice's sound and effects": "Le son et les effets de la voix sélectionnée",
- "The selector follows the input level · turn Follow input off on the Rack out tab to set it by hand": "Le sélecteur suit le niveau d’entrée · désactiver Follow input dans l’onglet Rack out pour le régler à la main",
- "The shape of the roll — 1500 draws from the same generator": "La forme du roulement — 1500 tirages du même générateur",
- "The source track's notes (neutral blocks, accent while sounding) and the voice (teal) over the last two seconds — with Key Source MIDI the voice is pulled to the notes": "Les notes de la piste source (blocs neutres, accent pendant qu’elles sonnent) et la voix (turquoise) sur les deux dernières secondes — avec Key Source MIDI, la voix est attirée vers les notes",
- "The step pattern — each column is one step's level, the line is the gain it makes (smooth and swing bend it). Draw sets steps, Line draws a ramp, Erase clears, Flip toggles on / off.": "Le motif de pas — chaque colonne est le niveau d’un pas, la ligne est le gain qui en résulte (smooth et swing l’infléchissent). Draw règle les pas, Line trace une rampe, Erase efface, Flip bascule actif / inactif.",
- "The sustain pedal: a keyboard's CC64 holds released keys — click to stop listening to it": "La pédale de sustain : le CC64 d’un clavier maintient les touches relâchées — cliquer pour ne plus l’écouter",
- "The swing curve — Pendulum slows at the walls, Linear keeps one speed, Bounce settles with a ripple": "La courbe d’oscillation — Pendulum ralentit aux murs, Linear garde une vitesse constante, Bounce se stabilise avec une ondulation",
- "The tone stack before the cabinet — the pre-distortion tightness of the model, Bright, Bass / Middle / Treble / Presence and Deep; dashed is the stack flat. Drag sideways for the middle's frequency, up or down for the middle.": "Le correcteur de tonalité avant le baffle — la fermeté avant distorsion du modèle, Bright, Bass / Middle / Treble / Presence et Deep ; en pointillés, le correcteur à plat. Glisser latéralement pour la fréquence du médium, vers le haut ou le bas pour le médium.",
- "The transfer curve the saturation runs — input level across, output up; dashed is the dry line, teal what you hear with Mix and Output, the dot where the input peak sits. Drag up or down for the drive, ⌥-click to type it.": "La courbe de transfert de la saturation — niveau d’entrée en abscisse, sortie en ordonnée ; en pointillés la ligne sèche, en turquoise ce qu’on entend avec Mix et Output, le point où se situe la crête d’entrée. Glisser vers le haut ou le bas pour le drive, ⌥-clic pour le saisir.",
- "The usual cutoffs — 60, 120 or 240 Hz (turns Mono below on)": "Les coupures usuelles — 60, 120 ou 240 Hz (active Mono below)",
- "The vocoder's output level": "Le niveau de sortie du vocoder",
- "The voice's level after Mod gain": "Le niveau de la voix après Mod gain",
- "The voice's level in the kit": "Le niveau de la voix dans le kit",
- "The voice: soft Keys, bright Glass, Saw, hollow Square or inharmonic Bell": "La voix : Keys doux, Glass brillant, Saw, Square creux ou Bell inharmonique",
- "The width over frequency — solid: what the settings do (0 % = mono, 100 % = unchanged), the mono region shaded; teal dashed: the output's measured width (side against mid). Drag sideways for the mono cutoff, up or down for the width.": "La largeur selon la fréquence — plein : ce que font les réglages (0 % = mono, 100 % = inchangé), la zone mono ombrée ; turquoise en pointillés : la largeur mesurée de la sortie (side contre mid). Glisser latéralement pour la coupure mono, vers le haut ou le bas pour la largeur.",
- "The zone's fine tune — drag, wheel, double-click resets": "L’accord fin de la zone — glisser, molette, double-clic pour réinitialiser",
- "The zone's fine tune, ±100 cents": "L’accord fin de la zone, ±100 cents",
- "The zone's root — drag or scroll": "La fondamentale de la zone — glisser ou défiler",
- "These devices can't be copied, so they weren't cut.": "Ces appareils ne peuvent pas être copiés, ils n’ont donc pas été coupés.",
- "These devices can't be grouped": "Ces appareils ne peuvent pas être groupés",
- "This Drum Rack is no longer in the rack.": "Ce Drum Rack n’est plus dans le rack.",
- "This can't be undone. Continue?": "Cette action est irréversible. Continuer ?",
- "This chain can't take the copied devices.": "Cette chaîne ne peut pas accepter les appareils copiés.",
- "This clip has no audio to convert.": "Ce clip n’a pas d’audio à convertir.",
- "This computer isn't on a network. Join the same Wi-Fi as the phone, share the phone's hotspot with it, or plug in a USB cable (USB tethering on the phone; Internet Sharing on the Mac).": "Cet ordinateur n’est pas sur un réseau. Rejoindre le même Wi-Fi que le téléphone, partager le point d’accès du téléphone avec lui, ou brancher un câble USB (partage de connexion USB sur le téléphone ; Partage Internet sur le Mac).",
- "This device can't be copied, so it wasn't cut.": "Cet appareil ne peut pas être copié, il n’a donc pas été coupé.",
- "This device can't be duplicated": "Cet appareil ne peut pas être dupliqué",
- "This group's exclusive number": "Le numéro exclusif de ce groupe",
- "This plug-in exposes no parameters": "Ce plug-in n’expose aucun paramètre",
- "This preset can't go in a rack.": "Ce préréglage ne peut pas aller dans un rack.",
- "This preset uses {0} samples from the pack. Zone settings are kept, no sound until installed.": "Ce préréglage utilise {0} échantillons du pack. Les réglages de zones sont conservés, mais aucun son tant que le pack n’est pas installé.",
- "This rack can't be ungrouped": "Ce rack ne peut pas être dégroupé",
- "This rack can't host plug-ins.": "Ce rack ne peut pas accueillir de plug-ins.",
- "This rack's chains take no MIDI effects.": "Les chaînes de ce rack n’acceptent pas d’effets MIDI.",
- "This rack's chains take no audio effects.": "Les chaînes de ce rack n’acceptent pas d’effets audio.",
- "This track can't take the copied devices.": "Cette piste ne peut pas accepter les appareils copiés.",
- "Three-band DJ-style EQ with kills.": "EQ trois bandes façon DJ avec kills.",
- "Three-band upward and downward compression — OTT-style density.": "Compression ascendante et descendante en trois bandes — densité façon OTT.",
- "Threshold — the tick is the key's level right now. ⌥-click types, double-click resets.": "Threshold — le repère indique le niveau de la clé en ce moment. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Threshold — where the band starts to act; the teal mark is the band's level now": "Threshold — le point où la bande commence à agir ; le repère turquoise est le niveau actuel de la bande",
- "Tilt — brightens (or darkens) the saw or the carrier track around 1 kHz before the bands, ±12 dB": "Tilt — éclaircit (ou assombrit) la dent de scie ou la piste porteuse autour de 1 kHz avant les bandes, ±12 dB",
- "Time Warp": "Déformation temporelle",
- "To Next Note": "Jusqu’à la note suivante",
- "Tone model — Warm: the era's own tilt and head bump; Flat: the TONE knob alone; Dark: a lower, darker tilt": "Tone model — Warm : l’inclinaison propre à l’époque et la bosse de tête ; Flat : le potentiomètre TONE seul ; Dark : une inclinaison plus basse et plus sombre",
- "Tone — a tilt after the stage, −12 … +12 dB around 800 Hz: darker or brighter distortion": "Tone — une inclinaison après l’étage, −12 … +12 dB autour de 800 Hz : distorsion plus sombre ou plus brillante",
- "Took the device out of the rack": "Appareil sorti du rack",
- "Took {0} devices out of the rack": "{0} appareils sortis du rack",
- "Traces a curve across the clip and drops a note wherever it passes a step.": "Trace une courbe sur le clip et dépose une note chaque fois qu’elle croise un pas.",
- "Track flattened to audio.": "Piste aplatie en audio.",
- "Track frozen — its devices are idle until you unfreeze.": "Piste gelée — ses appareils sont inactifs jusqu’au dégel.",
- "Track live-frozen — press Edit to change it, then Done.": "Piste gelée en direct — appuyer sur Modifier pour la changer, puis sur Terminé.",
- "Track unfrozen.": "Piste dégelée.",
- "Track {0} · Scene {1}": "Piste {0} · Scène {1}",
- "Transpose the note the pad plays, in semitones": "Transposer la note jouée par le pad, en demi-tons",
- "Transpose up or down by up to this many semitones": "Transposer vers le haut ou le bas jusqu’à ce nombre de demi-tons",
- "Triangle": "Triangle",
- "Trill": "Trille",
- "Trim — a fixed offset after the correction, −12 … +12 dB (the output then sits that far off the target)": "Trim — un décalage fixe après la correction, −12 … +12 dB (la sortie s’écarte alors d’autant de la cible)",
- "Triplet — the grid in triplets (a third shorter)": "Triplet — la grille en triolets (un tiers plus court)",
- "True peak — the detector reads the inter-sample peak (4×), so the ceiling holds in dBTP after conversion": "True peak — le détecteur lit la crête inter-échantillons (4×), pour que le plafond tienne en dBTP après conversion",
- "True-peak safe — a look-ahead limiter keeps the output under the ceiling (adds 5 / 20 ms of latency, compensated)": "True-peak safe — un limiteur à anticipation maintient la sortie sous le plafond (ajoute 5 / 20 ms de latence, compensée)",
- "Tube stage — a warm, asymmetric valve stage after the saturation (click again for none)": "Étage à lampe — un étage à lampe chaud et asymétrique après la saturation (cliquer à nouveau pour aucun)",
- "Turn": "Gruppetto",
- "Turns notes, velocity and controllers into control signals.": "Transforme notes, vélocité et contrôleurs en signaux de contrôle.",
- "Turns single notes into chords.": "Transforme des notes seules en accords.",
- "Turns the track's loudness into a control signal: a peak controller, for ducking one track under another.": "Transforme le volume de la piste en signal de contrôle : un contrôleur de crête, pour faire ducker une piste sous une autre.",
- "Two chains sending the same pitch play one note": "Deux chaînes qui envoient la même hauteur ne jouent qu’une note",
- "Two cycles of a sine at the driven level (dashed) and what comes out": "Deux cycles d’une sinusoïde au niveau d’attaque (pointillés) et ce qui en sort",
- "Two intervals on the grid: each step is the input's level — dim when dry, full where the slice is captured, dimmer with every repeat as it decays. Ticks at the top mark where the interval fires.": "Deux intervalles sur la grille : chaque pas est le niveau de l’entrée — pâle quand il est sec, plein là où la tranche est capturée, plus pâle à chaque répétition au fil du déclin. Les repères en haut marquent où l’intervalle se déclenche.",
- "Two-oscillator analog-style synth with drive and a unison stack — pads, basses, acid lines and leads.": "Synthé de style analogique à deux oscillateurs avec drive et pile d’unissons — nappes, basses, lignes acid et leads.",
- "Type": "Type",
- "Type — high-pass, low shelf, bell, notch, high shelf, low-pass; only shelves and bells take gain": "Type — passe-haut, low shelf, bell, notch, high shelf, passe-bas ; seuls les shelves et les bells acceptent un gain",
- "Type — high-pass, low shelf, bell, notch, high shelf, low-pass; only shelves and bells take gain and dynamics": "Type — passe-haut, low shelf, bell, notch, high shelf, passe-bas ; seuls les shelves et les bells acceptent gain et dynamique",
- "USB": "USB",
- "Undo (from a phone)": "Annuler (depuis un téléphone)",
- "Unfreeze track": "Dégeler la piste",
- "Unfreeze {0} tracks": "Dégeler {0} pistes",
- "Unfrozen — the source is live again.": "Dégelée — la source est de nouveau active.",
- "Unsupported file location.": "Emplacement de fichier non pris en charge.",
- "Unsupported project location.": "Emplacement de projet non pris en charge.",
- "Untitled": "Sans titre",
- "Unvoiced — adds noise where the modulator hisses, so consonants stay clear": "Unvoiced — ajoute du bruit là où le modulateur siffle, pour que les consonnes restent claires",
- "Up": "Haut",
- "Up-Down": "Haut-bas",
- "Up: the low wall plays the chord's lowest note · Down: its highest": "Haut : le mur bas joue la note la plus basse de l’accord · Bas : la plus haute",
- "Update available": "Mise à jour disponible",
- "Update to Nota {0}": "Mettre à jour vers Nota {0}",
- "User IR (none loaded)": "Réponse perso (aucune chargée)",
- "User IR — none loaded": "Réponse perso — aucune chargée",
- "Using Nota's built-in file dialog: {0}. Check xdg-desktop-portal and its FileChooser backend.": "Utilisation de la boîte de dialogue de fichiers intégrée de Nota : {0}. Vérifier xdg-desktop-portal et son moteur FileChooser.",
- "Utility": "Utilitaires",
- "Valley": "Vallée",
- "Variation": "Variation",
- "Variation — the grid floats up to this many steps (double / half) on each trigger": "Variation — la grille varie jusqu’à ce nombre de pas (double / moitié) à chaque déclenchement",
- "Vector synth morphing between sources — moving pads and textures.": "Synthé vectoriel qui fond entre des sources — nappes et textures mouvantes.",
- "Vel Decay": "Déclin de vél.",
- "Vel Falloff": "Atténuation de vél.",
- "Vel Follows": "Vél. suit",
- "Vel Slope": "Pente de vél.",
- "Vel Var": "Var. de vél.",
- "Vel → FM off": "Vél. → FM off",
- "Vel → Vol off": "Vél. → Vol off",
- "Velocity +": "Vélocité +",
- "Velocity Shaper": "Façonneur de vélocité",
- "Velocity mode: Curve / Compand / Fixed — click for the next, Shift-click for the previous": "Mode de vélocité : Curve / Compand / Fixed — cliquer pour le suivant, Maj-clic pour le précédent",
- "Velocity sets the level — the amount is the rail's VEL → VOL": "La vélocité règle le niveau — la quantité est le VEL → VOL du rail",
- "Velocity → level curve": "Courbe vélocité → niveau",
- "Velocity → level: drag up for soft (quiet notes louder), down for hard; ⌥-click to type": "Vélocité → niveau : glisser vers le haut pour doux (notes faibles plus fortes), vers le bas pour dur ; ⌥-clic pour saisir",
- "Velocity −": "Vélocité −",
- "Vibrato: no dry signal, the pitch swings ±": "Vibrato : pas de signal sec, la hauteur oscille de ±",
- "Vintage — an early-digital colour: a band-limited input, 12-bit wet and a deeper wobble": "Vintage — une couleur des débuts du numérique : entrée limitée en bande, traitement en 12 bits et oscillation plus profonde",
- "Voice setup: polyphony, allocation, glide mode, oversampling, vintage seed": "Configuration des voix : polyphonie, allocation, mode de glide, suréchantillonnage, graine vintage",
- "Voice stealing · order": "Vol de voix · ordre",
- "Voices": "Voix",
- "Voices of this group stop when a note of that exclusive group starts": "Les voix de ce groupe s’arrêtent quand une note de ce groupe exclusif démarre",
- "Voicing": "Voicing",
- "Vpp {0:0.000} · RMS {1:0.000}": "Vpp {0:0.000} · RMS {1:0.000}",
- "WHEEL MOD — DESTINATIONS": "Wheel mod — destinations",
- "Waiting for signal — the gain holds until the input has been measured": "En attente de signal — le gain est maintenu jusqu’à la mesure de l’entrée",
- "Warmth — a bucket-brigade flavour on the delay line: darker (low-pass down to 2.5 kHz) and gently saturated": "Warmth — une saveur à capacités commutées sur la ligne à retard : plus sombre (passe-bas jusqu’à 2,5 kHz) et légèrement saturé",
- "Warp Lengths": "Longueurs de warp",
- "Warping {0}… {1:0} %": "Warp de {0}… {1:0} %",
- "Waterfall · {0} bins · {1} · overlap {2:0.#} % · window {3:0} s · floor {4:0} dB": "Waterfall · {0} bins · {1} · overlap {2:0.#} % · fenêtre {3:0} s · plancher {4:0} dB",
- "Wave": "Onde",
- "Waveshaping saturator from soft warmth to hard clipping.": "Saturateur à mise en forme d’onde, de la chaleur douce à l’écrêtage dur.",
- "Wavetable synth with warping oscillators — evolving pads and modern leads.": "Synthé à tables d’ondes avec oscillateurs déformants — nappes évolutives et leads modernes.",
- "Wear — the age of the medium: a narrower band, more hiss and crackle, a wandering flutter. ⌥-click types, double-click resets.": "Wear — l’âge du support : une bande plus étroite, plus de souffle et de craquements, un flutter erratique. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "Wet only — 100 % wet, no dry: for a return / send track": "Wet only — 100 % traité, sans signal sec : pour une piste de retour / d’envoi",
- "Wet only — repeats with no dry, for a return / send track": "Wet only — répétitions sans signal sec, pour une piste de retour / d’envoi",
- "Wet only — the tail with no dry, for a return / send track": "Wet only — la queue sans signal sec, pour une piste de retour / d’envoi",
- "Wet — the crushed signal against the dry one": "Wet — le signal écrasé face au signal sec",
- "Wet — the forged signal against the dry one": "Wet — le signal forgé face au signal sec",
- "What Gain match and Level match aim for — the input's level, or Target": "Ce que visent Gain match et Level match — le niveau de l’entrée, ou Target",
- "What comes out: the bit depth and the rate, and whether the post filter cuts the images above the reduced Nyquist or lets them through": "Ce qui sort : la profondeur de bits et la fréquence, et si le post filter coupe les images au-dessus du Nyquist réduit ou les laisse passer",
- "What the detector hears now and the correction applied — or, with Key Source MIDI, the note the voice is pulled to": "Ce que le détecteur entend en ce moment et la correction appliquée — ou, avec Key Source MIDI, la note vers laquelle la voix est attirée",
- "What the device is doing; the master Tone / Bias / Width offsets of older projects show here when set": "Ce que fait l’appareil ; les décalages généraux Tone / Bias / Width des anciens projets s’affichent ici lorsqu’ils sont réglés",
- "What the feedback makes: positive sharpens the peaks, negative hollows the tone, past 85 % the comb rings": "Effet du feedback : positif, il affine les pics ; négatif, il creuse le timbre ; au-delà de 85 %, le peigne accroche",
- "What the feedback makes: positive sharpens the peaks, negative moves and widens the notches, past 85 % the phaser whistles": "Effet du feedback : positif, il affine les pics ; négatif, il déplace et élargit les encoches ; au-delà de 85 %, le phaser siffle",
- "What the gate is doing now — closed, attack, open, hold or release — and its gain": "Ce que fait le gate en ce moment — fermé, attaque, ouvert, maintien ou relâchement — et son gain",
- "What the leveler is doing now": "Ce que fait le leveler en ce moment",
- "What the limiter listens to — or, with Delta on, that you are hearing only what it takes away": "Ce qu’écoute le limiteur — ou, avec Delta activé, que l’on n’entend que ce qu’il retire",
- "What the phase makes: tremolo near 0°, auto-pan near 180°, an offset pan between": "Effet de la phase : trémolo près de 0°, auto-pan près de 180°, un panoramique décalé entre les deux",
- "What the repeater is doing now — waiting for the interval, capturing the slice, or repeating it — and where the transport is": "Ce que fait le répéteur en ce moment — attendre l’intervalle, capturer la tranche, ou la répéter — et où en est le transport",
- "What the window shows and a drag in it edits": "Ce que montre la fenêtre et ce qu’un glissement y modifie",
- "What this band is for": "À quoi sert cette bande",
- "Where in the file the hit starts": "L’endroit du fichier où commence la frappe",
- "Where the carrier track is tapped: before its effects and fader, or after. Pre keeps feeding while the track is muted": "Où la piste porteuse est prélevée : avant ses effets et son fader, ou après. Pre continue d’alimenter même piste coupée",
- "Where the sound sits now between left and right, over the swing the LFO covers": "Où se trouve le son entre gauche et droite en ce moment, sur l’excursion couverte par le LFO",
- "Where the source is tapped: before its effects and fader, or after — for a pad or chain, before its own effects, or after them and its level": "Où la source est prélevée : avant ses effets et son fader, ou après — pour un pad ou une chaîne, avant ses propres effets, ou après eux et son niveau",
- "Where the voices sit in the stereo field (Width) and how far each is detuned right now": "Où se placent les voix dans le champ stéréo (Width) et de combien chacune est désaccordée en ce moment",
- "Which resonator the controls below edit": "Le résonateur que modifient les commandes ci-dessous",
- "Width 0 %: the voices fold to mono, no space": "Width 0 % : les voix se replient en mono, sans espace",
- "Width — the band in octaves (low- and high-pass: less is more resonant)": "Width — la largeur de la bande en octaves (passe-bas et passe-haut : moins, c’est plus résonant)",
- "Width — the stage's stereo image, 0 … 200 % (in M/S, stage 2's width scales the side)": "Width — l’image stéréo de l’étage, 0 … 200 % (en M/S, la largeur de l’étage 2 met à l’échelle le side)",
- "Width — the voices' stereo spread: 0 % mono, 100 % as they are, 200 % lifts the side by +6 dB": "Width — l’étalement stéréo des voix : 0 % mono, 100 % tel quel, 200 % relève le side de +6 dB",
- "Window — how long the ride takes to reach the target, 0.4 … 10 s (Fast: a quarter of it)": "Window — le temps que met l’ajustement à atteindre la cible, 0,4 … 10 s (Fast : un quart de ce temps)",
- "Write the captured scope window to a WAV file": "Écrire la fenêtre d’oscilloscope capturée dans un fichier WAV",
- "You can remove it later in Settings → Downloads → AI Models.": "Il pourra être supprimé plus tard dans Réglages → Téléchargements → Modèles d’IA.",
- "You have {0}. Click to update or read the release notes.": "La version installée est {0}. Cliquer pour mettre à jour ou lire les notes de version.",
- "You're up to date: Nota {0} is the latest version.": "Nota est à jour : la version {0} est la plus récente.",
- "Zero every route in the matrix": "Remettre à zéro toutes les routes de la matrice",
- "Zigzag": "Zigzag",
- "Zones can already be selected and edited": "Les zones peuvent déjà être sélectionnées et modifiées",
- "a folder of samples": "un dossier d’échantillons",
- "a long tail after release": "une longue queue après le relâchement",
- "almost a gate — the sample is heard whole": "presque un gate — l’échantillon s’entend en entier",
- "amplifier": "amplificateur",
- "analog synth": "synthé analogique",
- "analyzer / scope": "analyseur / oscilloscope",
- "arp synth": "synthé arpégiateur",
- "at the input, before both engines": "à l’entrée, avant les deux moteurs",
- "at the output, dry + wet": "à la sortie, sec + traité",
- "auto-pan": "auto-pan",
- "bar {0} · {1} changed · {2} skipped": "mesure {0} · {1} modifiées · {2} ignorées",
- "bar · quantize {0}": "mesure · quantification {0}",
- "bit crusher": "bit crusher",
- "built-in": "intégrés",
- "cab by model · ": "baffle selon le modèle · ",
- "chains of MIDI effects": "chaînes d’effets MIDI",
- "choke group {0}: {1}": "groupe d’exclusion {0} : {1}",
- "chorus": "chorus",
- "connected": "connecté",
- "connecting": "connexion",
- "crest {0:0.0} dB · LUFS {1:0.0}": "crête {0:0.0} dB · LUFS {1:0.0}",
- "crossovers {0} / {1}": "crossovers {0} / {1}",
- "cutoff +{0} of range": "coupure +{0} de la plage",
- "dashed — where the reaction pulls": "pointillés — où tire la réaction",
- "drag a cell — up adds, down subtracts · ⌥-click types · double-click clears": "glisser une cellule — vers le haut ajoute, vers le bas retranche · ⌥-clic pour saisir · double-clic pour effacer",
- "drag an operator onto another to re-route": "glisser un opérateur sur un autre pour le reconnecter",
- "drum machine": "boîte à rythmes",
- "dynamic EQ": "EQ dynamique",
- "each repeat lower and narrower": "chaque répétition plus basse et plus étroite",
- "each repeat lower, same band": "chaque répétition plus basse, même bande",
- "electric piano": "piano électrique",
- "empty · notes pass": "vide · les notes passent",
- "env → freq off": "env → freq off",
- "env → tone {0}": "env → tone {0}",
- "envelope / LFO": "enveloppe / LFO",
- "every key plays the same pitch": "toutes les touches jouent la même hauteur",
- "every note at this velocity": "toutes les notes à cette vélocité",
- "flanger": "flanger",
- "force note length": "durée de note imposée",
- "gain": "gain",
- "gate": "gate",
- "glitch & repeats": "glitch et répétitions",
- "granular synth": "synthé granulaire",
- "hearing what it removes": "écoute de ce qui est retiré",
- "held at the sustain level": "maintenu au niveau de sustain",
- "hybrid reverb": "réverbération hybride",
- "input muted · tail held": "entrée coupée · queue maintenue",
- "instrument, then its effects · signal left → right": "instrument, puis ses effets · signal de gauche → droite",
- "key audible · output muted": "clé audible · sortie coupée",
- "last note {0} · {1}": "dernière note {0} · {1}",
- "last {0} → {1}": "dernière {0} → {1}",
- "latch holds the target between notes": "latch maintient la cible entre les notes",
- "lets the attack through": "laisse passer l’attaque",
- "level step shown enlarged": "pas de niveau affiché agrandi",
- "level {0:0.00} · holdoff {1:0} ms": "niveau {0:0.00} · holdoff {1:0} ms",
- "limited by max cut": "limité par la coupe max.",
- "limited by max gain": "limité par le gain max.",
- "limiter": "limiteur",
- "loop warped {0} → {1} BPM": "boucle warpée {0} → {1} BPM",
- "looper": "looper",
- "loud notes longer at +": "notes fortes plus longues à +",
- "low notes longer at +": "notes graves plus longues à +",
- "lows at the bottom · highs at the top": "graves en bas · aigus en haut",
- "mono synth": "synthé mono",
- "move over the graph": "survoler le graphique",
- "multiband dynamics": "dynamique multibande",
- "multisample": "multi-échantillons",
- "n/a in a rack": "indisponible dans un rack",
- "no correction between notes": "aucune correction entre les notes",
- "no reduction to measure": "aucune réduction à mesurer",
- "no sound to preview": "aucun son à pré-écouter",
- "nothing": "rien",
- "of all CPUs": "de tous les CPU",
- "of one core": "d’un cœur",
- "on the tail, before Dry/Wet": "sur la queue, avant Dry/Wet",
- "one file per track · {0:0.0} MB each · offline render": "un fichier par piste · {0:0.0} Mo chacun · rendu hors ligne",
- "one-shot, not warped": "one-shot, non warpé",
- "out of phase — mono risk": "en opposition de phase — risque en mono",
- "pan by frequency · 1 s window": "panoramique par fréquence · fenêtre de 1 s",
- "paraphonic synth": "synthé paraphonique",
- "peak {0} · {1:0.0} dB": "crête {0} · {1:0.0} dB",
- "per voice · {0} active routes": {
- "one": "par voix · {0} route active",
- "other": "par voix · {0} routes actives"
- },
- "period {0:0.000} ms · {1:0.0} Hz": "période {0:0.000} ms · {1:0.0} Hz",
- "phaser": "phaser",
- "physical synth": "synthé à modélisation physique",
- "pick a track in FROM": "choisir une piste dans FROM",
- "pitch correction": "correction de hauteur",
- "pitch quantize": "quantification de hauteur",
- "play to see the spectrum": "lancer la lecture pour voir le spectre",
- "poly synth": "synthé polyphonique",
- "random transpose": "transposition aléatoire",
- "range {0} — {1} · root {2} · keytrack {3}": "plage {0} — {1} · fondamentale {2} · keytrack {3}",
- "row {0:0} ms · {1} bins": "ligne {0:0} ms · {1} bins",
- "saturator": "saturateur",
- "selector {0} → {1}{2}": "sélecteur {0} → {1}{2}",
- "silence": "silence",
- "sing a few bars": "chanter quelques mesures",
- "squeezed to the middle": "resserré vers le milieu",
- "stacked intervals": "intervalles superposés",
- "stage {0} · {1}": "étage {0} · {1}",
- "step arpeggiator": "arpégiateur pas à pas",
- "step {0} · {1}": "pas {0} · {1}",
- "stretched to the edges": "étiré vers les bords",
- "the difference in − out": "la différence entrée − sortie",
- "the filter cuts the images": "le filtre coupe les images",
- "the grid holds still": "la grille reste immobile",
- "the key sets the playback speed": "la touche règle la vitesse de lecture",
- "the repeats pass unfiltered": "les répétitions passent sans filtre",
- "the same on every repeat": "identique à chaque répétition",
- "the sample plays at its own pitch on the root": "l’échantillon joue à sa propre hauteur sur la fondamentale",
- "the synth listens to a track": "le synthé écoute une piste",
- "the system file dialog answered without showing": "la boîte de dialogue système a répondu sans s’afficher",
- "the system file dialog didn't open within {0:0} s": "la boîte de dialogue système ne s’est pas ouverte en {0:0} s",
- "the system file dialog failed: {0}": "échec de la boîte de dialogue système : {0}",
- "the {0} model": "le modèle {0}",
- "the {0} model and the AI runtime it runs on": "le modèle {0} et le moteur d’IA sur lequel il tourne",
- "transposed {0} st to {1}": "transposé de {0} st vers {1}",
- "true peak · 4×": "true peak · 4×",
- "vector-morph synth": "synthé à morphing vectoriel",
- "velocity shaping": "façonnage de la vélocité",
- "vibrato always rides the pitch": "le vibrato suit toujours la hauteur",
- "vintage saturator": "saturateur vintage",
- "vocoder": "vocoder",
- "warped to tempo ({0:0.0} BPM)": "warpé au tempo ({0:0.0} BPM)",
- "wavetable synth": "synthé à tables d’ondes",
- "window {0:0} ms · slope {1:0.0} dB/oct": "fenêtre {0:0} ms · pente {1:0.0} dB/oct",
- "{0:0.#} kHz · {1}{2} · CPU {3:0} %": "{0:0.#} kHz · {1}{2} · CPU {3:0} %",
- "{0:0.#} kHz · ×{1} OS · CPU {2:0} %": "{0:0.#} kHz · ×{1} OS · CPU {2:0} %",
- "{0:0.0} dB · bin {1:0}": "{0:0.0} dB · bin {1:0}",
- "{0} / 8 in use": "{0} / 8 utilisés",
- "{0} / {1} voices": "{0} / {1} voix",
- "{0} / {1} · {2} / {3} files": "{0} / {1} · {2} / {3} fichiers",
- "{0} audio": "Audio {0}",
- "{0} built-in · {1}": "{0} intégrés · {1}",
- "{0} busy · {1} on pedal · {2} release": "{0} occupées · {1} sur pédale · {2} en relâchement",
- "{0} cables · {1} points": "{0} câbles · {1} points",
- "{0} can't go in a rack chain.": "{0} ne peut pas aller dans une chaîne de rack.",
- "{0} changed · {1} skip": "{0} modifiées · {1} ignorées",
- "{0} choke groups": {
- "one": "{0} groupe d’exclusion",
- "other": "{0} groupes d’exclusion"
- },
- "{0} cross-track CV links": {
- "one": "{0} lien CV entre pistes",
- "other": "{0} liens CV entre pistes"
- },
- "{0} devices": {
- "one": "{0} appareil",
- "other": "{0} appareils"
- },
- "{0} devices →": {
- "one": "{0} appareil →",
- "other": "{0} appareils →"
- },
- "{0} duplicates": {
- "one": "{0} doublon",
- "other": "{0} doublons"
- },
- "{0} effects": {
- "one": "{0} effet",
- "other": "{0} effets"
- },
- "{0} failed: {1}": "Échec de {0} : {1}",
- "{0} files": {
- "one": "{0} fichier",
- "other": "{0} fichiers"
- },
- "{0} groups · {1} · {2}": "{0} groupes · {1} · {2}",
- "{0} has no notes.": "{0} ne contient aucune note.",
- "{0} held by the pedal": "{0} tenues par la pédale",
- "{0} instruments": {
- "one": "{0} instrument",
- "other": "{0} instruments"
- },
- "{0} is waiting for its model — it's downloading (see the status bar).": "{0} attend son modèle — il se télécharge (voir la barre d’état).",
- "{0} islands": {
- "one": "{0} îlot",
- "other": "{0} îlots"
- },
- "{0} isn't available on this computer.": "{0} n’est pas disponible sur cet ordinateur.",
- "{0} layers": {
- "one": "{0} couche",
- "other": "{0} couches"
- },
- "{0} notes from sample analysis": {
- "one": "{0} note issue de l’analyse de l’échantillon",
- "other": "{0} notes issues de l’analyse de l’échantillon"
- },
- "{0} notes · {1} oct · cycle {2} steps": "{0} notes · {1} oct · cycle de {2} pas",
- "{0} of 12 remapped": "{0} sur 12 réassignées",
- "{0} of 3 stages": "{0} étages sur 3",
- "{0} of 8 mapped": "{0} sur 8 assignées",
- "{0} of {1} · 1/16 · bank {2}": "{0} sur {1} · 1/16 · banque {2}",
- "{0} of {1} · one cycle shown": "{0} sur {1} · un cycle affiché",
- "{0} pads": {
- "one": "{0} pad",
- "other": "{0} pads"
- },
- "{0} parameters": {
- "one": "{0} paramètre",
- "other": "{0} paramètres"
- },
- "{0} phones connected": {
- "one": "{0} téléphone connecté",
- "other": "{0} téléphones connectés"
- },
- "{0} plays the sample at its own pitch": "{0} joue l’échantillon à sa propre hauteur",
- "{0} plug-ins": {
- "one": "{0} plug-in",
- "other": "{0} plug-ins"
- },
- "{0} presets": {
- "one": "{0} préréglage",
- "other": "{0} préréglages"
- },
- "{0} projects": {
- "one": "{0} projet",
- "other": "{0} projets"
- },
- "{0} slots · {1} assigned": "{0} emplacements · {1} assignés",
- "{0} targets": {
- "one": "{0} cible",
- "other": "{0} cibles"
- },
- "{0} tracks frozen — their devices are idle until you unfreeze.": "{0} pistes gelées — leurs appareils sont inactifs jusqu’au dégel.",
- "{0} tracks unfrozen.": "{0} pistes dégelées.",
- "{0} transients per bar": {
- "one": "{0} transitoire par mesure",
- "other": "{0} transitoires par mesure"
- },
- "{0} uses an AI model that runs on this computer. Download {1} ({2}) once? ": "{0} utilise un modèle d’IA qui s’exécute sur cet ordinateur. Télécharger {1} ({2}) une fois ? ",
- "{0} voices": {
- "one": "{0} voix",
- "other": "{0} voix"
- },
- "{0} zones": {
- "one": "{0} zone",
- "other": "{0} zones"
- },
- "{0} {1} selected · {2} · choke {3}": "{0} {1} sélectionné · {2} · exclusion {3}",
- "{0} {1} · from {2} · avg out {3}": "{0} {1} · depuis {2} · sortie moy. {3}",
- "{0} {1} · {2} notes": "{0} {1} · {2} notes",
- "{0} {1} · {2} notes · fold {3} · ": "{0} {1} · {2} notes · fold {3} · ",
- "{0} {1} · {2} → {3} → pad volume, pan": "{0} {1} · {2} → {3} → volume, panoramique du pad",
- "{0} {1}{2} · {3} VOICES · {4} GRAINS": "{0} {1}{2} · {3} voix · {4} grains",
- "{0} · MIDI effect {1}": "{0} · effet MIDI {1}",
- "{0} · MIDI {1}\nClick: select and play · drop a file to load it · right-click for more": "{0} · MIDI {1}\nClic : sélectionner et jouer · déposer un fichier pour le charger · clic droit pour plus d’options",
- "{0} · Processing…": "{0} · Traitement…",
- "{0} · Processing… {1:0} %": "{0} · Traitement… {1:0} %",
- "{0} · depth {1:+0;−0;0}": "{0} · depth {1:+0;−0;0}",
- "{0} · effect {1} of {2}": "{0} · effet {1} sur {2}",
- "{0} · no crossfade": "{0} · sans fondu enchaîné",
- "{0} · no pad selected{1}": "{0} · aucun pad sélectionné{1}",
- "{0} · position · pitch · pan": "{0} · position · hauteur · panoramique",
- "{0} · sync to host {1:0} BPM · CPU {2:0} %": "{0} · synchro à l’hôte {1:0} BPM · CPU {2:0} %",
- "{0} · vel {1} → {2}": "{0} · vél. {1} → {2}",
- "{0} · voices {1}": "{0} · voix {1}",
- "{0} · {1} cycles · unison {2}": "{0} · {1} cycles · unisson {2}",
- "{0} · {1} found by name: {2}": "{0} · {1} trouvés par le nom : {2}",
- "{0} · {1} left → right": "{0} · {1} de gauche à droite",
- "{0} · {1} oct": "{0} · {1} oct",
- "{0} · {1} pads": "{0} · {1} pads",
- "{0} · {1} voices": "{0} · {1} voix",
- "{0} · {1} zones": "{0} · {1} zones",
- "{0} · {1} · dry/wet {2} · {3}": "{0} · {1} · dry/wet {2} · {3}",
- "{0} · {1} — click to play, right-click for more": "{0} · {1} — cliquer pour jouer, clic droit pour plus d’options",
- "{0} · {1} → merged MIDI · {2}": "{0} · {1} → MIDI fusionné · {2}",
- "{0} · {1}/16 loaded": "{0} · {1}/16 chargés",
- "{0} · ×{1} OS · 0 smp · CPU {2:0} %": "{0} · ×{1} OS · 0 éch. · CPU {2:0} %",
- "{0} — click to add an instrument, or drop a sample here": "{0} — cliquer pour ajouter un instrument, ou déposer un échantillon ici",
- "{0} — click to load another file": "{0} — cliquer pour charger un autre fichier",
- "{0} — double-click to unfold": "{0} — double-clic pour déplier",
- "{0} — drag up / down, double-click resets": "{0} — glisser vers le haut / bas, double-clic pour réinitialiser",
- "{0} — {1}\nDrag to turn · click to show its receivers · right-click to map, rename or clear": "{0} — {1}\nGlisser pour tourner · cliquer pour voir ses récepteurs · clic droit pour assigner, renommer ou effacer",
- "{0} — {1} notes": "{0} — {1} notes",
- "{0} — ± an octave, drag or scroll the note for semitones, ⌥-click the note to type it, double-click resets. Notes outside the range pass through.": "{0} — ± une octave, glisser ou défiler la note pour les demi-tons, ⌥-clic sur la note pour la saisir, double-clic pour réinitialiser. Les notes hors de la plage passent telles quelles.",
- "{0} → new Drum Rack track {1}": "{0} → nouvelle piste Drum Rack {1}",
- "{0} → {1} · drag to turn · double-click resets": "{0} → {1} · glisser pour tourner · double-clic pour réinitialiser",
- "{0}-bit float": "{0} bits flottants",
- "{0}: set the shifts to {1}": "{0} : régler les décalages sur {1}",
- "{0} ms · weak network": "{0} ms · réseau faible",
- "· one file per track, post-fader": "· un fichier par piste, post-fader",
- "τ draws each voice's delay; ct its detune — how far the moving delay bends the pitch": "τ trace le retard de chaque voix ; ct son désaccord — de combien le retard mobile infléchit la hauteur",
- "“{0}” can't take {1}.": "« {0} » ne peut pas accepter {1}.",
- "“{0}” has clips. Delete the track with its clips?": "« {0} » contient des clips. Supprimer la piste avec ses clips ?",
- "→ assign a source to turn the reaction on": "→ assigner une source pour activer la réaction",
- "→ cut/pitch · wheel": "→ coupure/hauteur · molette",
- "→ the sidechain bends the pitch up": "→ le sidechain fait monter la hauteur",
- "→ the sidechain drags the vector in rhythm": "→ le sidechain entraîne le vecteur en rythme",
- "→ the sidechain opens the filter": "→ le sidechain ouvre le filtre",
- "→ the sidechain swells the space": "→ le sidechain gonfle l’espace",
- " · {0}": " · {0}",
- "{0} · {1}": "{0} · {1}",
- "USB · {0} ms · {1}": "USB · {0} ms · {1}",
- "{0} ms · {1}": "{0} ms · {1}",
- "Back to pads": "Retour aux pads",
- "Capture and repeat": "Capturer et répéter",
- "Choose a preset": "Choisir un préréglage",
- "Clear every step": "Effacer tous les pas",
- "Clip length limit": "Limite de durée du clip",
- "Compare: {0}": "Comparer : {0}",
- "Copy the steps": "Copier les pas",
- "Cutoff over time": "Coupure au fil du temps",
- "Delete this chain": "Supprimer cette chaîne",
- "Deleted {0} devices": "{0} appareils supprimés",
- "Device": "Appareil",
- "Double-click to rename": "Double-clic pour renommer",
- "Even harmonics only": "Harmoniques paires uniquement",
- "Feed shimmer back": "Réinjecter le shimmer",
- "Fill every 16th": "Remplir toutes les doubles-croches",
- "Fill every 8th": "Remplir toutes les croches",
- "Fill every beat": "Remplir tous les temps",
- "Follow Scale device": "Suivre l’appareil Scale",
- "Follow input level": "Suivre le niveau d’entrée",
- "Group into rack": "Grouper dans un rack",
- "Init": "Init",
- "Input and output": "Entrée et sortie",
- "LFO not assigned": "LFO non assigné",
- "Level and reduction": "Niveau et réduction",
- "Locate the samples": "Localiser les échantillons",
- "Map to parameter": "Assigner à un paramètre",
- "Merge duplicate notes": "Fusionner les notes en double",
- "Mid / Side": "Mid / Side",
- "Mono (last note)": "Mono (dernière note)",
- "Mono below freq": "Mono below freq",
- "Move left": "Déplacer vers la gauche",
- "Move right": "Déplacer vers la droite",
- "Move to track": "Déplacer vers la piste",
- "Mute the output": "Couper la sortie",
- "Mute the pad": "Couper le pad",
- "Name this band": "Nommer cette bande",
- "Narrow with repeats": "Narrow with repeats",
- "Next Groove lane": "Voie de groove suivante",
- "Next preset": "Préréglage suivant",
- "No parameter matches": "Aucun paramètre correspondant",
- "No return tracks": "Aucune piste de retour",
- "Not available yet": "Pas encore disponible",
- "Nothing to paste": "Rien à coller",
- "Old voice fade": "Old voice fade",
- "Open GUI ↗": "Ouvrir l’interface ↗",
- "Open in Sample": "Ouvrir dans Sample",
- "Pasted {0}": "{0} collé",
- "Pasted {0} devices": "{0} appareils collés",
- "Preset: {0}": "Préréglage : {0}",
- "Previous preset": "Préréglage précédent",
- "Remove device": "Retirer l’appareil",
- "Remove this receiver": "Retirer ce récepteur",
- "Remove track": "Retirer la piste",
- "Replace…": "Remplacer…",
- "Sample not loaded": "Échantillon non chargé",
- "Select a track": "Sélectionner une piste",
- "Select a zone": "Sélectionner une zone",
- "Select the pad": "Sélectionner le pad",
- "Selected": "Sélection",
- "Show the pads": "Afficher les pads",
- "Signal and duck": "Signal et duck",
- "Signal and gate": "Signal et gate",
- "Snap to peaks": "Caler sur les crêtes",
- "Snap to zero": "Caler sur le zéro",
- "Solo the pad": "Mettre le pad en solo",
- "Stop mapping (Esc)": "Arrêter l’assignation (Échap)",
- "The input level": "Le niveau d’entrée",
- "The voices' level": "Le niveau des voix",
- "The zone's level": "Le niveau de la zone",
- "The zone's pan": "Le panoramique de la zone",
- "This zone's level": "Le niveau de cette zone",
- "Total in RAM": "Total en RAM",
- "Transpose, ±12 semitones": "Transposition, ±12 demi-tons",
- "True poly (16)": "Vrai poly (16)",
- "Type value…": "Saisir une valeur…",
- "Unfold": "Déplier",
- "Ungroup rack": "Dégrouper le rack",
- "Value": "Valeur",
- "Wear follows input": "Wear suit l’entrée",
- "Wet only (send)": "Wet only (envoi)",
- "Width by frequency": "Largeur par fréquence",
- "With the instrument": "Avec l’instrument",
- "a slow swell": "une montée lente",
- "all normals intact": "toutes les connexions normalisées intactes",
- "at bar end": "en fin de mesure",
- "bass mono off": "bass mono désactivé",
- "both phases inverted": "les deux phases inversées",
- "closes to silence": "se ferme jusqu’au silence",
- "ducks to silence": "descend jusqu’au silence",
- "envelope not assigned": "enveloppe non assignée",
- "every macro assigned": "toutes les macros assignées",
- "hold a chord": "tenir un accord",
- "limited by true-peak": "limité par le true-peak",
- "match to input": "aligner sur l’entrée",
- "no key signal": "aucun signal de clé",
- "no modulation assigned": "aucune modulation assignée",
- "no note held": "aucune note tenue",
- "no notes yet": "aucune note pour l’instant",
- "no source assigned": "aucune source assignée",
- "one knob each": "un potentiomètre chacun",
- "out of scale": "hors gamme",
- "shift+step = accent": "Maj+pas = accent",
- "slow and dense": "lent et dense",
- "soft notes louder": "notes douces plus fortes",
- "soft notes quieter": "notes douces plus faibles",
- "spread per note": "dispersion par note",
- "waiting for signal": "en attente de signal",
- " · sidechain cleared": " · sidechain supprimé",
- "AI runtime": "Moteur d’IA",
- "Copied {0} to {1}": "{0} copié vers {1}",
- "Couldn't create a Drum Rack track.": "Impossible de créer une piste Drum Rack.",
- "Couldn't create a Nota Rhythm track.": "Impossible de créer une piste Nota Rhythm.",
- "Couldn't load the preset: {0}": "Impossible de charger le préréglage : {0}",
- "Couldn't load the sample \"{0}\".": "Impossible de charger l’échantillon « {0} ».",
- "Couldn't prepare the multisample \"{0}\".": "Impossible de préparer le multi-échantillon « {0} ».",
- "Couldn't prepare the sample \"{0}\".": "Impossible de préparer l’échantillon « {0} ».",
- "External drop named no files Nota can read. Formats: {0}": "Le dépôt externe ne contenait aucun fichier lisible par Nota. Formats : {0}",
- "Failed to add MIDI effect.": "Échec de l’ajout de l’effet MIDI.",
- "Failed to add device.": "Échec de l’ajout de l’appareil.",
- "Failed to add instrument.": "Échec de l’ajout de l’instrument.",
- "Failed to load instrument.": "Échec du chargement de l’instrument.",
- "Failed to load plugin.": "Échec du chargement du plug-in.",
- "Hears every note in a recording, chords included, for Convert Melody and Convert Harmony.": "Entend chaque note d’un enregistrement, accords compris, pour Convertir la mélodie et Convertir l’harmonie.",
- "Installing {0}…": "Installation de {0}…",
- "Its versions can't be listed until the file .history/versions.json is repaired.": "Ses versions ne peuvent pas être listées tant que le fichier .history/versions.json n’est pas réparé.",
- "Kit not found.": "Kit introuvable.",
- "Loading the model…": "Chargement du modèle…",
- "Moved {0} to {1}": "{0} déplacé vers {1}",
- "Not a MIDI effect.": "Ce n’est pas un effet MIDI.",
- "Not an effect.": "Ce n’est pas un effet.",
- "Nota's built-in effects plus your VST/AU plug-ins. Scan your plug-ins in Settings → Plug-ins to add more.": "Les effets intégrés de Nota et vos plug-ins VST/AU. Analyser vos plug-ins dans Réglages → Plug-ins pour en ajouter.",
- "Nota's built-in synths plus your VST/AU plug-ins. Scan your plug-ins in Settings → Plug-ins to add more.": "Les synthés intégrés de Nota et vos plug-ins VST/AU. Analyser vos plug-ins dans Réglages → Plug-ins pour en ajouter.",
- "On": "On",
- "Plug-in presets can't be previewed — load the plug-in to hear them.": "Les préréglages de plug-in ne peuvent pas être pré-écoutés — charger le plug-in pour les entendre.",
- "Plugin not installed: {0}": "Plug-in non installé : {0}",
- "Preparing the update…": "Préparation de la mise à jour…",
- "Preset can't be applied in place.": "Le préréglage ne peut pas être appliqué sur place.",
- "Preset not found.": "Préréglage introuvable.",
- "Racks play what their chains hold — nothing to preview on its own.": "Les racks jouent ce que contiennent leurs chaînes — rien à pré-écouter seul.",
- "Separating stems…": "Séparation des stems…",
- "Splits a mix into drums, bass, vocals and everything else, each on its own track.": "Sépare un mix en batterie, basse, voix et tout le reste, chacun sur sa propre piste.",
- "The Effect Rack plays what its chains hold — nothing to preview on its own.": "L’Effect Rack joue ce que contiennent ses chaînes — rien à pré-écouter seul.",
- "The library Nota's AI models run on. Installed with the first model.": "La bibliothèque sur laquelle tournent les modèles d’IA de Nota. Installée avec le premier modèle.",
- "This version was saved by Nota {0}, which is newer than this one. Update Nota to open it.": "Cette version a été enregistrée par Nota {0}, plus récent que celui-ci. Mettre Nota à jour pour l’ouvrir.",
- "Unknown drum kit.": "Kit de batterie inconnu.",
- "Unknown preset type.": "Type de préréglage inconnu.",
- "Unpacking {0}…": "Décompression de {0}…",
- "Width law — L/R: the side is scaled, so wider is louder; M/S: mid and side are traded, so the level holds (200 % = side only)": "Width law — L/R : le side est mis à l’échelle, donc plus large est plus fort ; M/S : mid et side sont échangés, donc le niveau reste constant (200 % = side seul)",
- "Writing stems…": "Écriture des stems…",
- "BUILT-IN": "Intégrés",
- "PLUG-INS": "Plug-ins",
- "D-pad up / down": "Croix ↑ / ↓",
- "D-pad left / right": "Croix ← / →",
- "1 bar": "1 mesure",
- "1 beat": "1 temps",
- "16 bars": "16 mesures",
- "16-bit only": "16 bits uniquement",
- "2 bars": "2 mesures",
- "2 beats": "2 temps",
- "4 bars": "4 mesures",
- "8 bars": "8 mesures",
- "≈ 1 file · {0:0.0} MB · offline render": "≈ 1 fichier · {0:0.0} Mo · rendu hors ligne",
- "bars": "mesures",
- "time": "durée",
- "count-in": "décompte",
- "A .{0} archive can only be unpacked on macOS.": "Une archive .{0} ne peut être décompressée que sous macOS.",
- "AI models aren't available for this computer: ONNX Runtime has no build for it.": "Les modèles d’IA ne sont pas disponibles pour cet ordinateur : ONNX Runtime n’en propose pas de version.",
- "Couldn't download {0}: {1}": "Impossible de télécharger {0} : {1}",
- "Couldn't prepare the update ({0}: {1}).": "Impossible de préparer la mise à jour ({0} : {1}).",
- "Couldn't reach the {0}. Check your internet connection.": "Impossible de joindre le {0}. Vérifier la connexion Internet.",
- "Couldn't remove the pack's files — close anything using them and try again.": "Impossible de supprimer les fichiers du pack — fermer ce qui les utilise puis réessayer.",
- "Couldn't remove {0} — it may be in use. Restart Nota and try again.": "Impossible de supprimer {0} — il est peut-être utilisé. Redémarrer Nota puis réessayer.",
- "Couldn't start {0}.": "Impossible de lancer {0}.",
- "Installing this model needs {0} of free disk space, and there is {1}.": "L’installation de ce modèle demande {0} d’espace disque libre, et il y en a {1}.",
- "Invalid model id \"{0}\".": "Identifiant de modèle « {0} » invalide.",
- "Invalid pack id \"{0}\".": "Identifiant de pack « {0} » invalide.",
- "Nota couldn't load the AI runtime. Remove it in Settings → Downloads → AI Models and install it again.": "Nota n’a pas pu charger le moteur d’IA. Le supprimer dans Réglages → Téléchargements → Modèles d’IA puis le réinstaller.",
- "Nota {0} has no download for this computer.": "Nota {0} n’a pas de téléchargement pour cet ordinateur.",
- "The .deb archive has no data.": "L’archive .deb ne contient aucune donnée.",
- "The .deb archive is damaged.": "L’archive .deb est endommagée.",
- "The .deb archive is truncated.": "L’archive .deb est tronquée.",
- "The AI model file is damaged. Remove it in Settings → Downloads → AI Models and install it again.": "Le fichier du modèle d’IA est endommagé. Le supprimer dans Réglages → Téléchargements → Modèles d’IA puis le réinstaller.",
- "The archive contains an unsafe path: {0}": "L’archive contient un chemin dangereux : {0}",
- "The download of {0} contains no samples Nota can use.": "Le téléchargement de {0} ne contient aucun échantillon utilisable par Nota.",
- "The download of {0} doesn't contain {1}.": "Le téléchargement de {0} ne contient pas {1}.",
- "The download of {0} doesn't match the registry's checksum — not installing it.": "Le téléchargement de {0} ne correspond pas à la somme de contrôle du registre — il n’est pas installé.",
- "The download of {0} is larger than the registry says — not installing it.": "Le téléchargement de {0} est plus volumineux que ce qu’indique le registre — il n’est pas installé.",
- "The downloaded Nota.app isn't the expected version — not installing it.": "Le Nota.app téléchargé n’est pas la version attendue — il n’est pas installé.",
- "The sample registry index is damaged.": "L’index du registre d’échantillons est endommagé.",
- "The sample registry needs a newer version of Nota.": "Le registre d’échantillons demande une version plus récente de Nota.",
- "The update disk image doesn't contain Nota.app.": "L’image disque de la mise à jour ne contient pas Nota.app.",
- "The update download is damaged (checksum mismatch) — not installing it.": "Le téléchargement de la mise à jour est endommagé (somme de contrôle différente) — il n’est pas installé.",
- "The update download is larger than expected — not installing it.": "Le téléchargement de la mise à jour est plus volumineux que prévu — il n’est pas installé.",
- "This copy of Nota can't update itself — download the new version from the release page.": "Cet exemplaire de Nota ne peut pas se mettre à jour lui-même — télécharger la nouvelle version depuis la page de publication.",
- "Unknown AI model \"{0}\".": "Modèle d’IA « {0} » inconnu.",
- "Unpacking needs \"{0}\", which wasn't found.": "La décompression demande « {0} », introuvable.",
- "Unpacking {0} needs {1} of free space on the system drive, which has {2}.": "La décompression de {0} demande {1} d’espace libre sur le disque système, qui en a {2}.",
- "Unsafe path in the registry entry: {0}": "Chemin dangereux dans l’entrée du registre : {0}",
- "Unsupported archive type \"{0}\".": "Type d’archive « {0} » non pris en charge.",
- "{0} failed ({1}): {2}": "Échec de {0} ({1}) : {2}",
- "{0} needs {1} of free space in your Samples folder, which has {2}.": "{0} demande {1} d’espace libre dans le dossier Échantillons, qui en a {2}.",
- "{0} timed out.": "{0} : délai dépassé.",
- "0° — tremolo: both channels together": "0° — trémolo : les deux canaux ensemble",
- "90° — a quarter cycle apart: the sound circles": "90° — un quart de cycle d’écart : le son tourne en cercle",
- "180° — auto-pan: one side up while the other is down": "180° — auto-pan : un côté monte quand l’autre descend",
- "11 topologies · feedback on A": "11 topologies · feedback sur A",
- "Audio inputs 1/2 (stereo)": "Entrées audio 1/2 (stéréo)",
- "{0} cables": {
- "one": "{0} câble",
- "other": "{0} câbles"
- },
- "{0} chains": {
- "one": "{0} chaîne",
- "other": "{0} chaînes"
- },
- "{0} macros mapped": {
- "one": "{0} macro assignée",
- "other": "{0} macros assignées"
- },
- "Off|remote": "Off",
- "Hide {0}": "Masquer {0}",
- "Hide Others": "Masquer les autres",
- "Show All": "Tout afficher",
- "Quit {0}": "Quitter {0}",
- "Amount — scales every band's compression and expansion (0 % = none). Double-click: 100 %": "Amount — met à l’échelle la compression et l’expansion de chaque bande (0 % = aucune). Double-clic : 100 %",
- "Drag a dot: ← → threshold, ↑ ↓ ratio (down = more). The bright dot is compression above, the grey one expansion below. Double-click a dot resets it. · ⌥-click to type": "Glisser un point : ← → seuil, ↑ ↓ ratio (vers le bas = plus). Le point brillant est la compression au-dessus, le gris l’expansion en dessous. Double-clic sur un point pour le réinitialiser. · ⌥-clic pour saisir",
- "Drag a marker to set that band's RT60 (mid = Decay; low / high follow it as ratios). The Damping knob sets the high crossover. · ⌥-click to type": "Glisser un repère pour régler le RT60 de cette bande (mid = Decay ; low / high le suivent en rapports). Le potentiomètre Damping règle le crossover haut. · ⌥-clic pour saisir",
- "Floor — the level when closed (−∞ = silence); in Duck, how far the signal goes down": "Floor — le niveau une fois fermé (−∞ = silence) ; en Duck, de combien le signal descend",
- "Glue: a bus compressor on the whole kit — holds the hits together (0 = off)": "Glue : un compresseur de bus sur tout le kit — soude les frappes entre elles (0 = désactivé)",
- "Human — keeps vibrato and slow drift around the corrected note (0 = flat)": "Human — garde le vibrato et la dérive lente autour de la note corrigée (0 = plat)",
- "Keep the name (empty = automatic) · cancel": "Garder le nom (vide = automatique) · annuler",
- "Latch — keep the last target between notes (off = no correction while no note is held)": "Latch — garde la dernière cible entre les notes (off = aucune correction tant qu’aucune note n’est tenue)",
- "Oct lock — the note's own octave (off = whichever octave of it is nearest the voice)": "Oct lock — l’octave propre de la note (off = l’octave de la note la plus proche de la voix)",
- "Pitch bend from MIDI — moves between notes bend over Glide when they are within Bend; off = the target steps": "Pitch bend from MIDI — les passages d’une note à l’autre glissent via Glide s’ils restent dans Bend ; off = la cible saute",
- "Preserve formants — the vowel colour stays put while the pitch moves (off = it moves with the pitch, like a tape speed-up)": "Preserve formants — la couleur des voyelles reste en place quand la hauteur bouge (off = elle suit la hauteur, comme une bande accélérée)",
- "Range — how far the gate closes or the duck goes down (−∞ = all the way)": "Range — de combien le gate se ferme ou le duck descend (−∞ = jusqu’au bout)",
- "SC EQ — the detector hears the key through its band-pass; off = the full band": "SC EQ — le détecteur entend la clé à travers son passe-bande ; off = pleine bande",
- "Speed — how fast the retune glides (2 ms = hard tune)": "Speed — la vitesse du glissement de la correction (2 ms = hard tune)",
- "The hit: amp contour over the pitch drop · drag across for Decay, up / down for Tune (Shift = fine) · ⌥-click to type them": "La frappe : contour d’amplitude sur la chute de hauteur · glisser latéralement pour Decay, vers le haut / bas pour Tune (Maj = fin) · ⌥-clic pour les saisir",
- "⌘1 ⌘2 narrow / widen · ⌘3 triplets · ⌘4 snap · ⌘5 auto": "⌘1 ⌘2 réduire / élargir · ⌘3 triolets · ⌘4 magnétisme · ⌘5 auto",
- "Positions are bar.beat.sixteenth, counted from 1 as in the transport: 5 or 5.1 is the start of bar 5, 5.3 its third beat. The export stops at the end position, so 1 to 5 is four bars.": "Les positions s’écrivent mesure.temps.double-croche, comptées à partir de 1 comme dans le transport : 5 ou 5.1 est le début de la mesure 5, 5.3 son troisième temps. L’export s’arrête à la position de fin, donc 1 à 5 fait quatre mesures.",
- "Return": "Retour",
- "Band on": "Bande active",
- "Choke group": "Groupe d’exclusion",
- "Clear all": "Tout effacer",
- "Clear loop": "Effacer la boucle",
- "Delete chain": "Supprimer la chaîne",
- "Install pack": "Installer le pack",
- "Load sample…": "Charger un échantillon…",
- "Load…": "Charger…",
- "Locate folder…": "Localiser le dossier…",
- "Map": "Assigner",
- "Map to": "Assigner à",
- "Off-beats": "Contretemps",
- "Open chain": "Ouvrir la chaîne",
- "Open editor": "Ouvrir l’éditeur",
- "Open recent": "Ouvrir un projet récent",
- "Remove pad": "Retirer le pad",
- "Replace instrument": "Remplacer l’instrument",
- "Shift left": "Décaler à gauche",
- "Shift right": "Décaler à droite",
- "Trim silence": "Rogner le silence",
- "Turn off": "Désactiver",
- "Turn on": "Activer",
- "Unmap": "Désassigner",
- "None|choke group": "Aucun",
- " · follows input": " · suit l’entrée",
- " · sidechain dropped": " · sidechain supprimé",
- " · {0} missing": " · {0} manquant(s)",
- "All {0} pads": {
- "one": "Tous les {0} pad",
- "other": "Tous les {0} pads"
- },
- "All {0} voices": {
- "one": "Toutes les {0} voix",
- "other": "Toutes les {0} voix"
- },
- "Bank {0}": "Banque {0}",
- "Chain {0}": "Chaîne {0}",
- "Chain · {0}": "Chaîne · {0}",
- "Clear bank {0}": "Effacer la banque {0}",
- "Clear {0} mappings": {
- "one": "Effacer {0} assignation",
- "other": "Effacer {0} assignations"
- },
- "Copied {0}": "{0} copié",
- "Copy {0} to": "Copier {0} vers",
- "Empty": "Vide",
- "Group · {0}": "Groupe · {0}",
- "Loading {0}": "Chargement {0}",
- "Loading {0} %": "Chargement {0} %",
- "Map to {0}": "Assigner à {0}",
- "Part {0}": "Partie {0}",
- "Remove {0} {1:+0;−0;0}": "Retirer {0} {1:+0;−0;0}",
- "Select {0}": "Sélecteur {0}",
- "Step {0} accent": "Pas {0} accentué",
- "Step {0} quiet": "Pas {0} faible",
- "Unmap from {0}": "Désassigner de {0}",
- "all": "tous",
- "all {0}": "tous les {0}",
- "chain {0}": "chaîne {0}",
- "not assigned": "non assigné",
- "of {0} bars": {
- "one": "sur {0} mesure",
- "other": "sur {0} mesures"
- },
- "onto layer {0}": "sur la couche {0}",
- "sampler {0}": "sampler {0}",
- "sel {0}–{1}": "sél. {0}–{1}",
- "{0} free": "{0} libre(s)",
- "{0} macros": {
- "one": "{0} macro",
- "other": "{0} macros"
- },
- "{0} params": {
- "one": "{0} param.",
- "other": "{0} param."
- },
- "{0} ringing out": "{0} en fin de résonance",
- "{0} · empty": "{0} · vide",
- "{0} · missing": "{0} · manquant",
- "→ {0} params": {
- "one": "→ {0} param.",
- "other": "→ {0} param."
- },
- "Delete {0} versions and the audio only they use? The current version, the latest version of each branch, and every named, starred or noted version stay. This can't be undone.": {
- "one": "Supprimer {0} version et l’audio qu’elle seule utilise ? La version actuelle, la dernière version de chaque branche et toute version nommée, étoilée ou annotée restent. Cette action est irréversible.",
- "other": "Supprimer {0} versions et l’audio que seules elles utilisent ? La version actuelle, la dernière version de chaque branche et toute version nommée, étoilée ou annotée restent. Cette action est irréversible."
- },
- "Deleted {0} versions": {
- "one": "{0} version supprimée",
- "other": "{0} versions supprimées"
- },
- "SCENE {0:00} · {1}": "SCÈNE {0:00} · {1}",
- "Section · {0} bars": {
- "one": "Section · {0} mesure",
- "other": "Section · {0} mesures"
- },
- "{0} steps": {
- "one": "{0} pas",
- "other": "{0} pas"
- },
- "{0} versions": {
- "one": "{0} version",
- "other": "{0} versions"
- },
- "{0} · older versions take {1} on disk": "{0} · les anciennes versions occupent {1} sur le disque",
- "{0} · {1} freed": "{0} · {1} libérés",
- "{0} markers": {
- "one": "{0} repère",
- "other": "{0} repères"
- },
- "Delete {0} unnamed versions…": {
- "one": "Supprimer {0} version sans nom…",
- "other": "Supprimer {0} versions sans nom…"
- },
- "The current version stays.": "La version actuelle reste.",
- "Delete the selected versions and the audio only they use": "Supprimer les versions sélectionnées et l’audio que seules elles utilisent",
- "The current version stays": "La version actuelle reste",
- "Delete {0} versions…": {
- "one": "Supprimer {0} version…",
- "other": "Supprimer {0} versions…"
- },
- "Delete versions": "Supprimer les versions",
- "Delete {0} versions? Audio that only they use is deleted from the project folder too. This can't be undone.": {
- "one": "Supprimer {0} version ? L’audio qu’elle seule utilise est aussi supprimé du dossier du projet. Cette action est irréversible.",
- "other": "Supprimer {0} versions ? L’audio que seules elles utilisent est aussi supprimé du dossier du projet. Cette action est irréversible."
- }
+ "about.2026_egor_khindikaynen_ambertape": "© 2026 Egor Khindikaynen (Ambertape)",
+ "about.desktop_daw_agplv3": "DAW de bureau · AGPLv3",
+ "about.engine": "Moteur {0}",
+ "about.free_software_under_the_gnu": "Logiciel libre sous licence GNU AGPLv3.",
+ "about.includes_third_party_software_juce": "Inclut des logiciels tiers (JUCE, Avalonia, miniaudio, RtMidi, dr_libs, Signalsmith, HIIR). Voir LICENSES/THIRD-PARTY-NOTICES.md pour les mentions de droits d’auteur et d’attribution.",
+ "ai.clip_ai.loading_the_model": "Chargement du modèle…",
+ "ai.clip_ai.preparing_audio": "Préparation de l’audio…",
+ "ai.clip_ai.separating_stems": "Séparation des stems…",
+ "ai.clip_ai.writing_stems": "Écriture des stems…",
+ "ai.onnx_runtime_loader.nota_couldnt_load_the_ai": "Nota n’a pas pu charger le moteur d’IA. Le supprimer dans Réglages → Téléchargements → Modèles d’IA puis le réinstaller.",
+ "ai.onnx_runtime_loader.the_ai_model_file_is": "Le fichier du modèle d’IA est endommagé. Le supprimer dans Réglages → Téléchargements → Modèles d’IA puis le réinstaller.",
+ "app.settings": "Réglages…",
+ "app_updates.couldnt_download_the_update": "Impossible de télécharger la mise à jour : {0}",
+ "arrangement.add_audio_track": "Ajouter une piste audio",
+ "arrangement.add_instrument_track": "Ajouter une piste d’instrument",
+ "arrangement.add_return_track": "Ajouter une piste de retour",
+ "arrangement.add_track": "Ajouter une piste",
+ "arrangement.auto_editor.copy_automation": "Copier l’automation",
+ "arrangement.auto_editor.cut_automation": "Couper l’automation",
+ "arrangement.auto_editor.delete_automation": "Supprimer l’automation",
+ "arrangement.auto_editor.paste_automation": "Coller l’automation",
+ "arrangement.automation.band": "Bande {0}",
+ "arrangement.automation.choose_parameter": "Choisir un paramètre…",
+ "arrangement.automation.filter_parameters": "Filtrer les paramètres…",
+ "arrangement.automation.learn_touch_a_control_in": "Apprendre (toucher une commande dans le plug-in)",
+ "arrangement.automation.param": "Param",
+ "arrangement.automation.stage": "Étape {0}",
+ "arrangement.bars": { "one": "{0} mesure", "other": "{0} mesures" },
+ "arrangement.beats": "{0:0.##} temps",
+ "arrangement.controls.clear_loop_region": "Effacer la région de boucle",
+ "arrangement.controls.click_to_add_master_volume": "cliquer pour ajouter des points de volume master",
+ "arrangement.controls.turn_loop_off": "Désactiver la boucle",
+ "arrangement.controls.turn_loop_on": "Activer la boucle",
+ "arrangement.copied_clip_to_session_scene": "Clip copié vers la scène {0} de la session",
+ "arrangement.copied_clips_to_the_session": "{0} clips copiés vers la session à partir de la scène {1}",
+ "arrangement.ext": "Ext",
+ "arrangement.group_tracks": "Grouper les pistes",
+ "arrangement.in": "Entrée",
+ "arrangement.key_moves.no_track_above_takes_these": "Aucune piste au-dessus n’accepte ces clips",
+ "arrangement.key_moves.no_track_below_takes_these": "Aucune piste en dessous n’accepte ces clips",
+ "arrangement.key_moves.unfold_the_group_to_move": "Déplier le groupe pour déplacer ces clips entre les pistes",
+ "arrangement.lane_control.activate": "Activer",
+ "arrangement.lane_control.add_an_instrument_from_the": "Ajouter un instrument depuis le navigateur",
+ "arrangement.lane_control.audio_clip": "Clip audio",
+ "arrangement.lane_control.clips": { "one": "{0} clip", "other": "{0} clips" },
+ "arrangement.lane_control.consolidate_selection": "Consolider la sélection",
+ "arrangement.lane_control.convert": "Convertir",
+ "arrangement.lane_control.copy_to_scene": "Copier vers la scène",
+ "arrangement.lane_control.copy_to_session": "Copier vers Session",
+ "arrangement.lane_control.couldnt_take_the_clips_audio": "Impossible de récupérer l’audio du clip : {0}",
+ "arrangement.lane_control.deactivate": "Désactiver",
+ "arrangement.lane_control.drums_to_new_midi_track": "Batterie vers une nouvelle piste MIDI",
+ "arrangement.lane_control.edit_selected_clips_together": "Éditer ensemble les clips sélectionnés",
+ "arrangement.lane_control.get_the_ai_model_for": "Obtenir le modèle d’IA pour la mélodie et l’harmonie…",
+ "arrangement.lane_control.harmony_to_new_midi_track": "Harmonie vers une nouvelle piste MIDI",
+ "arrangement.lane_control.insert_midi_clip": "Insérer un clip MIDI",
+ "arrangement.lane_control.melody_to_new_midi_track": "Mélodie vers une nouvelle piste MIDI",
+ "arrangement.lane_control.midi_clip": "Clip MIDI",
+ "arrangement.lane_control.new_track": "Nouvelle piste",
+ "arrangement.lane_control.rec": "Rec",
+ "arrangement.lane_control.release_to_load_the_clip": "Relâcher pour charger le clip dans {0}",
+ "arrangement.lane_control.scene": "Scène {0}",
+ "arrangement.lane_control.separate_stems": "Séparer les stems…",
+ "arrangement.lane_control.slice_to_new_midi_track": "Tranches vers une nouvelle piste MIDI",
+ "arrangement.lane_control.split_here": "Découper ici",
+ "arrangement.link.link_tracks_arming_and_clip": "Lier les pistes — l’armement et l’édition des clips agissent sur toutes les pistes du groupe · ⌥-clic sur un clip ou un bouton d’armement pour n’agir que sur une piste",
+ "arrangement.link.linked_with": "Liée à {0}",
+ "arrangement.link.the_groups_tracks_are_linked": "Les pistes du groupe sont liées",
+ "arrangement.link_tracks": "Lier les pistes",
+ "arrangement.loop_selection": "Boucler la sélection",
+ "arrangement.master_cant_be_monitored_it": "Le master ne peut pas être écouté (il y aurait un larsen)",
+ "arrangement.midi_from": "MIDI depuis",
+ "arrangement.monitor_input_hear_it_live": "Écoute de l’entrée : l’entendre en direct à travers cette piste",
+ "arrangement.monitoring_input_click_to_stop": "Écoute de l’entrée — cliquer pour arrêter",
+ "arrangement.moved_across_tracks_device_automation": "Déplacé entre les pistes — l’automation des appareils est restée sur la source",
+ "arrangement.new_track_drop.couldnt_move_the_clips_to": "Impossible de déplacer les clips vers de nouvelles pistes",
+ "arrangement.new_track_drop.moved_to_new_tracks_device": "Déplacé vers de nouvelles pistes — l’automation des appareils est restée sur la source",
+ "arrangement.overview.bar": "mesure {0}–{1} / {2}",
+ "arrangement.overview.overview": "Aperçu",
+ "arrangement.overview.the_project_appears_here": "le projet apparaît ici",
+ "arrangement.paste_a_midi_clip_onto": "Coller un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
+ "arrangement.paste_track": "Coller la piste",
+ "arrangement.played_from_a_phone": "Joué depuis un téléphone : {0}",
+ "arrangement.processing": "Traitement…",
+ "arrangement.sections.add_section_here": "Ajouter une section ici",
+ "arrangement.sections.already_has_its_automatic_name": "{0} a déjà son nom automatique",
+ "arrangement.sections.automatic_name": "Nom automatique",
+ "arrangement.sections.back_to_the_automatic_name": "Retour au nom automatique ({0}), qui suit la position de la section",
+ "arrangement.sections.couldnt_delete": "Impossible de supprimer {0}",
+ "arrangement.sections.couldnt_duplicate": "Impossible de dupliquer {0}",
+ "arrangement.sections.couldnt_move_there": "Impossible de déplacer {0} à cet endroit",
+ "arrangement.sections.custom_name": "Nom personnalisé",
+ "arrangement.sections.delete_all_sections": "Supprimer toutes les sections",
+ "arrangement.sections.delete_with_content": "Supprimer avec le contenu",
+ "arrangement.sections.deleted_with_its_content": "{0} supprimée avec son contenu",
+ "arrangement.sections.drag_here_to_mark_a": "glisser ici pour marquer une section",
+ "arrangement.sections.duplicate_with_content": "Dupliquer avec le contenu",
+ "arrangement.sections.duplicated_with_its_content": "{0} dupliquée avec son contenu",
+ "arrangement.sections.is_again": "“{0}” redevient {1}",
+ "arrangement.sections.is_already_the_first_section": "{0} est déjà la première section",
+ "arrangement.sections.is_already_the_last_section": "{0} est déjà la dernière section",
+ "arrangement.sections.loop_section": "Boucler la section",
+ "arrangement.sections.move_earlier": "Déplacer plus tôt",
+ "arrangement.sections.move_later": "Déplacer plus tard",
+ "arrangement.sections.moved_earlier": "{0} déplacée plus tôt",
+ "arrangement.sections.moved_later": "{0} déplacée plus tard",
+ "arrangement.sections.no_section_at_the_playhead": "Aucune section à la tête de lecture",
+ "arrangement.sections.overlaps_another_section_separate_them": "{0} chevauche une autre section — les séparer pour déplacer son contenu avec elle",
+ "arrangement.sections.reset_to_default": "Rétablir par défaut",
+ "arrangement.sections.reset_to_default_name": "Rétablir le nom par défaut",
+ "arrangement.sections.section_bars": { "one": "Section · {0} mesure", "other": "Section · {0} mesures" },
+ "arrangement.sections.sections": "Sections",
+ "arrangement.sections.select_section": "Sélectionner la section",
+ "arrangement.send": "Envoi {0} · {1}",
+ "arrangement.sends.show_sends_in_track_headers": "Afficher les envois dans les en-têtes de piste",
+ "arrangement.takes.delete_take": "Supprimer la prise",
+ "arrangement.takes.flatten_takes": "Aplatir les prises",
+ "arrangement.takes.hide_takes": "Masquer les prises",
+ "arrangement.takes.show_takes": "Afficher {0} prises",
+ "arrangement.takes.take": "Prise {0}",
+ "arrangement.takes.use_whole_take": "Utiliser la prise entière",
+ "arrangement.tracks.height": "Hauteur",
+ "arrangement.tracks.large": "Grand",
+ "arrangement.tracks.standard": "Standard",
+ "arrangement.tracks.tracks": "{0} pistes",
+ "arrangement.ungroup": "Dégrouper",
+ "arrangement.vol": "Vol",
+ "arrangement.zoom": "Zoom",
+ "audio_clip_editor.a_session_slot_plays_on": "Un emplacement de Session joue sur sa propre horloge de boucle — le lancer pour jouer depuis le début",
+ "audio_clip_editor.beats": "Beats",
+ "audio_clip_editor.click_point_drag_move_right": "Clic — point · glisser — déplacer · clic droit — supprimer",
+ "audio_clip_editor.complex": "Complex",
+ "audio_clip_editor.complex_pro": "Complex Pro",
+ "audio_clip_editor.detect_tempo": "Détecter le tempo",
+ "audio_clip_editor.detect_the_files_tempo_and": "Détecter le tempo du fichier et l’adapter au projet",
+ "audio_clip_editor.detected": "Détecté",
+ "audio_clip_editor.double_click_the_wave_marker": "Double-clic sur la forme d’onde — marqueur · glisser — aligner",
+ "audio_clip_editor.double_the_tempo_the_clip": "Double du tempo — le clip couvre deux fois plus de temps",
+ "audio_clip_editor.drag_a_handle_double_click": "Glisser une poignée · double-clic — réinitialiser",
+ "audio_clip_editor.envelope": "Enveloppe",
+ "audio_clip_editor.gain": "Gain",
+ "audio_clip_editor.half_the_tempo_the_clip": "Moitié du tempo — le clip couvre deux fois moins de temps",
+ "audio_clip_editor.markers": { "one": "{0} repère", "other": "{0} repères" },
+ "audio_clip_editor.mono": "Mono",
+ "audio_clip_editor.off": "désactivé",
+ "audio_clip_editor.pin_a_marker_on_every": "Placer un marqueur sur chaque attaque pour caler la batterie sur la grille",
+ "audio_clip_editor.play_the_whole_sample_at": "Jouer tout l’échantillon à plein niveau",
+ "audio_clip_editor.playback": "Lecture",
+ "audio_clip_editor.reset": "Réinitialiser",
+ "audio_clip_editor.snap_needs_warp_turn_on": "Le magnétisme nécessite Warp — activer Warp pour voir la grille et s’y caler",
+ "audio_clip_editor.stereo": "Stéréo",
+ "audio_clip_editor.tempo": "Tempo",
+ "audio_clip_editor.texture": "Texture",
+ "audio_clip_editor.the_tempo_the_audio_was": "Le tempo auquel l’audio a été enregistré. Nota l’étire jusqu’au tempo du projet. ×2 / ÷2 corrigent une détection en demi-temps ou en double temps.",
+ "audio_clip_editor.to_transients": "Aux transitoires",
+ "audio_clip_editor.tones": "Tones",
+ "audio_clip_editor.warp": "Warp",
+ "audition.preset_audition.kits.kit_not_found": "Kit introuvable.",
+ "audition.preset_audition.plug_in_presets_cant_be": "Les préréglages de plug-in ne peuvent pas être pré-écoutés — charger le plug-in pour les entendre.",
+ "audition.preset_audition.preset_not_found": "Préréglage introuvable.",
+ "audition.preset_audition.racks_play_what_their_chains": "Les racks jouent ce que contiennent leurs chaînes — rien à pré-écouter seul.",
+ "audition.preset_audition.the_effect_rack_plays_what": "L’Effect Rack joue ce que contiennent ses chaînes — rien à pré-écouter seul.",
+ "browser.add_audio_files_to_your": "Ajouter des fichiers audio au dossier d’échantillons (Réglages → Bibliothèque) ou installer des packs gratuits depuis Réglages → Téléchargements → Packs d’échantillons, puis les parcourir ici sous forme d’arborescence. Des fichiers peuvent aussi être glissés depuis le Finder.",
+ "browser.add_to_favorites": "Ajouter aux favoris",
+ "browser.analysing": " · analyse {0} %",
+ "browser.any_key": "Toutes les tonalités",
+ "browser.any_tempo": "Tous les tempos",
+ "browser.arpeggiator_chord_scale_and_more": "Arpégiateur, accord, gamme et plus — ils traitent les notes avant un instrument : en déposer un à gauche d’un instrument dans une piste.",
+ "browser.audio_effect": "Effet audio",
+ "browser.audio_effects": "Effets audio",
+ "browser.audio_effects_2": "Effets audio",
+ "browser.bpm_caps": "BPM",
+ "browser.built_in": "{0} intégrés · {1}",
+ "browser.built_in_caps": "Intégrés",
+ "browser.category_chips": "Pastilles de catégorie",
+ "browser.collapse": "Replier",
+ "browser.collapse_browser": "Replier le navigateur",
+ "browser.couldnt_analyse_that_sample": "Impossible d’analyser cet échantillon",
+ "browser.create_multisample": "Créer un multi-échantillon…",
+ "browser.delete": "Supprimer…",
+ "browser.edit_tags": "Modifier les étiquettes…",
+ "browser.expand": "Déplier",
+ "browser.expand_browser": "Déplier le navigateur",
+ "browser.external_drop_named_no_files": "Le dépôt externe ne contenait aucun fichier lisible par Nota. Formats : {0}",
+ "browser.favorites": "Favoris",
+ "browser.favorites_first": "Favoris en premier",
+ "browser.files": "Fichiers",
+ "browser.filter_by_key_a_key": "Filtrer par tonalité — une tonalité montre aussi sa relative (A mineur ↔ C majeur)",
+ "browser.filter_by_tempo": "Filtrer par tempo",
+ "browser.finding_sounds_like": "Recherche de sons proches de {0}…",
+ "browser.folder": "Dossier",
+ "browser.group_by_source": "Grouper par source",
+ "browser.history": "Historique",
+ "browser.key": "Tonalité",
+ "browser.like": "Comme {0}",
+ "browser.loops": "Boucles",
+ "browser.loops_within_5_of_bpm": "Les boucles à moins de 5 % de {0} BPM s’y calent proprement",
+ "browser.map_the_folders_samples_by": "Assigner les échantillons du dossier selon leurs noms dans des préréglages Nota Mosaic",
+ "browser.midi_effect": "Effet MIDI",
+ "browser.midi_effects": "Effets MIDI",
+ "browser.midi_effects_2": "Effets MIDI",
+ "browser.midi_file": "Fichier MIDI",
+ "browser.midi_map": "Carte MIDI",
+ "browser.new_tag": "Nouvelle étiquette…",
+ "browser.no_audio_effects_yet": "Aucun effet audio pour l’instant",
+ "browser.no_instruments_yet": "Aucun instrument pour l’instant",
+ "browser.no_matches": "Aucun résultat",
+ "browser.no_matches_yet": "Aucun résultat pour l’instant",
+ "browser.no_midi_effects_yet": "Aucun effet MIDI pour l’instant",
+ "browser.no_presets_yet": "Aucun préréglage pour l’instant",
+ "browser.no_projects_yet": "Aucun projet pour l’instant",
+ "browser.no_samples_yet": "Aucun échantillon pour l’instant",
+ "browser.nota_is_still_analysing_your": "Nota analyse encore les échantillons — d’autres résultats apparaissent au fur et à mesure.",
+ "browser.nota_kits": "Nota Kits",
+ "browser.notas_built_in_effects_plus": "Les effets intégrés de Nota et vos plug-ins VST/AU. Analyser vos plug-ins dans Réglages → Plug-ins pour en ajouter.",
+ "browser.notas_built_in_synths_plus": "Les synthés intégrés de Nota et vos plug-ins VST/AU. Analyser vos plug-ins dans Réglages → Plug-ins pour en ajouter.",
+ "browser.one_shots": "One-shots",
+ "browser.packs": "Packs",
+ "browser.plug_ins": { "one": "{0} plug-in", "other": "{0} plug-ins" },
+ "browser.plug_ins_caps": "Plug-ins",
+ "browser.preset": "Préréglage",
+ "browser.presets": "Préréglages",
+ "browser.presets_n": { "one": "{0} préréglage", "other": "{0} préréglages" },
+ "browser.project": "Projet",
+ "browser.project_key": "Tonalité du projet · {0}",
+ "browser.project_tempo_5": "Tempo du projet ±5 %",
+ "browser.projects": "Projets",
+ "browser.projects_n": { "one": "{0} projet", "other": "{0} projets" },
+ "browser.remove_from_favorites": "Retirer des favoris",
+ "browser.right_click_a_device_header": "Clic droit sur l’en-tête d’un appareil puis « Enregistrer le préréglage » : il apparaît ici, groupé par catégorie et par appareil.",
+ "browser.sample_packs_installed_from_settings": "packs d’échantillons installés depuis Réglages → Téléchargements",
+ "browser.samples": { "one": "{0} échantillon", "other": "{0} échantillons" },
+ "browser.save_a_project_s_into": "Enregistrer un projet (⌘S) dans le dossier Projets (Réglages → Bibliothèque) : il apparaît ici.",
+ "browser.search": "Rechercher",
+ "browser.show_similar_sounds": "Afficher les sons similaires",
+ "browser.show_type_tags": "Afficher les étiquettes de type",
+ "browser.sort_and_view": "Tri et affichage",
+ "browser.sounds_like_closest_first_click": "Sons proches de {0}, les plus proches d’abord — cliquer pour revenir à tous les échantillons",
+ "browser.tags": "Étiquettes",
+ "browser.track_inspector": "Inspecteur de piste",
+ "browser.transpose_to_project_key": "Transposer à la tonalité du projet",
+ "browser.try_a_different_search_or": "Essayer une autre recherche ou effacer les filtres.",
+ "browser.warp_loops_to_project_tempo": "Warper les boucles au tempo du projet",
+ "clip_adsr.attack": "Attaque {0}",
+ "clip_adsr.decay_sustain": "Déclin {0} · Maintien {1}",
+ "clip_adsr.release": "Relâchement {0}",
+ "clip_editor.click_to_add_a_point": "Clic pour ajouter un point",
+ "clip_editor.click_to_add_a_point_2": "Clic pour ajouter un point · glisser pour déplacer · clic droit pour supprimer",
+ "clip_editor.clip_the_selected_clip_track": "Clip : le clip sélectionné · Piste : tous les clips de la piste",
+ "clip_editor.delete_every_note_outside_the": "Supprimer toutes les notes hors de la gamme",
+ "clip_editor.env": "Env",
+ "clip_editor.envelopes": "Enveloppes",
+ "clip_editor.fit": "Ajuster",
+ "clip_editor.fit_to_notes_f": "Ajuster aux notes (⇧F)",
+ "clip_editor.fold": "Replier",
+ "clip_editor.fold_show_f": "Replier : afficher {0} (⌥⇧F)",
+ "clip_editor.hear_notes_as_you_place": "Entendre les notes quand on les place, les clique ou les fait glisser",
+ "clip_editor.notes": "Notes",
+ "clip_editor.only_the_notes_in_use": "seulement les notes utilisées",
+ "clip_editor.only_the_pads": "seulement les pads",
+ "clip_editor.only_the_scales_notes": "seulement les notes de la gamme",
+ "clip_editor.remove_out_of_scale": "Supprimer hors gamme",
+ "clip_editor.scale": "Gamme",
+ "clip_editor.tools": "Outils",
+ "clip_editor.track_clip": "Clip de la piste {0}",
+ "clip_props.beat": "temps",
+ "clip_props.beats": "temps",
+ "clip_props.clips_always_loop": "Les clips bouclent toujours",
+ "clip_props.double_click_add_or_delete": "Double-clic — ajouter ou supprimer · bord — longueur · Shift — ajouter à la sélection",
+ "clip_props.no_notes_selected": "Aucune note sélectionnée",
+ "clip_props.notes": "Notes",
+ "clip_props.selection": "Sélection",
+ "clip_props.strength": "Intensité",
+ "clip_props.transpose": "Transposer",
+ "command_palette.1_result": "1 résultat",
+ "command_palette.add_stay": "ajouter et rester",
+ "command_palette.add_to_canvas": "ajouter au canevas",
+ "command_palette.all": "Tous",
+ "command_palette.filter": "filtrer",
+ "command_palette.insert": "insérer",
+ "command_palette.load": "charger",
+ "command_palette.new_track": "nouvelle piste",
+ "command_palette.nothing_matches_try_a_role": "Aucun résultat. Essayer un rôle (reverb, comp), un caractère (warm, dark) ou une source (vocals, drums).",
+ "command_palette.open_in_devices": "ouvrir dans Appareils",
+ "command_palette.replace": "remplacer",
+ "command_palette.results": "{0} résultats",
+ "command_palette.run": "exécuter",
+ "command_palette.search_actions_tracks_devices_presets": "Rechercher des actions, pistes, appareils, préréglages…",
+ "command_palette.select": "sélectionner",
+ "command_palette.showing_results_for": "Résultats pour ",
+ "command_palette.typed_in_the_other_keyboard": " · saisi dans l’autre disposition de clavier",
+ "commands.activate_deactivate_clip": "Activer / désactiver le clip",
+ "commands.auto_arm_selected_track": "Armement automatique de la piste sélectionnée",
+ "commands.clip_editor_fills_the_window": "L’éditeur de clips remplit la fenêtre",
+ "commands.command_palette": "Palette de commandes",
+ "commands.connect_phone": "Connecter un téléphone…",
+ "commands.copy_clips_to_session_arrangement": "Copier les clips vers Session / Arrangement",
+ "commands.cycle_clip_names": "Faire défiler les noms de clips",
+ "commands.delete_section_with_content": "Supprimer la section avec son contenu",
+ "commands.duplicate_section_with_content": "Dupliquer la section avec son contenu",
+ "commands.edit_selected_clips_together": "Éditer ensemble les clips sélectionnés",
+ "commands.exit_nota": "Quitter Nota",
+ "commands.export_audio": "Exporter de l’audio…",
+ "commands.fit_to_notes": "Ajuster aux notes",
+ "commands.fold_the_piano_roll": "Replier le piano roll",
+ "commands.follow_playhead": "Suivre la tête de lecture",
+ "commands.freeze_track": "Geler la piste",
+ "commands.group_tracks": "Grouper les pistes",
+ "commands.help": "Aide",
+ "commands.import_audio": "Importer de l’audio…",
+ "commands.insert_scene": "Insérer une scène",
+ "commands.launch_scene": "Lancer la scène",
+ "commands.lock_envelopes": "Verrouiller les enveloppes",
+ "commands.loop_record_overdub_replace": "Enregistrement en boucle : superposition / remplacement",
+ "commands.midi_learn": "Apprentissage MIDI",
+ "commands.mixer_in_its_own_window": "Mixeur dans sa propre fenêtre",
+ "commands.move_section_earlier": "Déplacer la section plus tôt",
+ "commands.move_section_later": "Déplacer la section plus tard",
+ "commands.narrow_grid": "Réduire la grille",
+ "commands.new_audio_track": "Nouvelle piste audio",
+ "commands.new_midi_track": "Nouvelle piste MIDI",
+ "commands.new_return_track": "Nouvelle piste de retour",
+ "commands.open_devices_in_a_window": "Ouvrir les appareils dans une fenêtre",
+ "commands.open_project": "Ouvrir un projet…",
+ "commands.play_pause": "Lecture / pause",
+ "commands.quantize_notes": "Quantifier les notes",
+ "commands.redo": "Rétablir",
+ "commands.remove_out_of_scale_notes": "Supprimer les notes hors gamme",
+ "commands.reset_section_name": "Rétablir le nom de la section",
+ "commands.save_project": "Enregistrer le projet",
+ "commands.save_project_as": "Enregistrer le projet sous…",
+ "commands.save_version_with_note": "Enregistrer une version avec note…",
+ "commands.select_all_clips": "Sélectionner tous les clips",
+ "commands.session": "Session",
+ "commands.settings_appearance": "Réglages : Apparence",
+ "commands.settings_audio": "Réglages : Audio",
+ "commands.settings_downloads": "Réglages : Téléchargements",
+ "commands.settings_gamepads": "Réglages : Manettes",
+ "commands.settings_library": "Réglages : Bibliothèque",
+ "commands.settings_midi": "Réglages : MIDI",
+ "commands.settings_plug_ins": "Réglages : Plug-ins",
+ "commands.settings_remote": "Réglages : Télécommande",
+ "commands.settings_shortcuts": "Réglages : Raccourcis",
+ "commands.settings_updates": "Réglages : Mises à jour",
+ "commands.show_arrangement": "Afficher l’arrangement",
+ "commands.show_devices": "Afficher les appareils",
+ "commands.show_mixer": "Afficher le mixeur",
+ "commands.show_modular": "Afficher la vue Modular",
+ "commands.show_playhead": "Afficher la tête de lecture",
+ "commands.show_session": "Afficher la vue Session",
+ "commands.show_version_history": "Afficher l’historique des versions",
+ "commands.split_at_playhead": "Découper à la tête de lecture",
+ "commands.stop_all_clips": "Arrêter tous les clips",
+ "commands.tap_tempo": "Tap tempo",
+ "commands.toggle_adaptive_grid": "Activer / désactiver la grille adaptative",
+ "commands.toggle_automation_mode": "Activer / désactiver le mode automation",
+ "commands.toggle_browser": "Afficher/masquer le navigateur",
+ "commands.toggle_clip_editor_track_mode": "Activer / désactiver le mode piste de l’éditeur de clips",
+ "commands.toggle_detail_panel": "Afficher/masquer le panneau de détail",
+ "commands.toggle_full_screen": "Activer/quitter le plein écran",
+ "commands.toggle_loop": "Activer / désactiver la boucle",
+ "commands.toggle_overview": "Afficher/masquer l’aperçu",
+ "commands.toggle_sections": "Afficher/masquer les sections",
+ "commands.toggle_snap_to_grid": "Activer / désactiver le magnétisme sur la grille",
+ "commands.toggle_triplet_grid": "Activer / désactiver la grille en triolets",
+ "commands.track_headers_on_the_right": "En-têtes de piste à droite",
+ "commands.transpose_notes_down_an_octave": "Transposer les notes d’une octave vers le bas",
+ "commands.transpose_notes_up_an_octave": "Transposer les notes d’une octave vers le haut",
+ "commands.ungroup_tracks": "Dégrouper les pistes",
+ "commands.view": "Affichage",
+ "commands.widen_grid": "Élargir la grille",
+ "common.1_bar": "1 mesure",
+ "common.about_nota": "À propos de Nota",
+ "common.attack": "Attaque",
+ "common.audio": "Audio",
+ "common.audio_n": "Audio {0}",
+ "common.auto": "Auto",
+ "common.cancel": "Annuler",
+ "common.check_for_updates": "Rechercher des mises à jour…",
+ "common.clear": "Effacer",
+ "common.clear_all": "Tout effacer",
+ "common.clip": "Clip",
+ "common.close": "Fermer",
+ "common.compact": "Compact",
+ "common.consolidate": "Consolider",
+ "common.copy": "Copier",
+ "common.couldnt_load": "Impossible de charger {0}.",
+ "common.cut": "Couper",
+ "common.decay": "Déclin",
+ "common.delete": "Supprimer",
+ "common.documentation": "Documentation",
+ "common.download": "Télécharger",
+ "common.downloading_nota": "Téléchargement de Nota {0}…",
+ "common.duplicate": "Dupliquer",
+ "common.duplicate_time": "Dupliquer le temps",
+ "common.edit": "Édition",
+ "common.file": "Fichier",
+ "common.freeze": "Geler",
+ "common.gate": "Gate",
+ "common.grid": "Grille",
+ "common.group": "Groupe",
+ "common.hz_runs_the_lfo_free": "Hz fait tourner le LFO librement ; Sync prend sa vitesse du tempo et le cale sur la mesure pendant la lecture",
+ "common.input": "Entrée",
+ "common.insert_silence": "Insérer du silence",
+ "common.instrument": "Instrument",
+ "common.instruments": "Instruments",
+ "common.length": "Longueur",
+ "common.loop": "Boucle",
+ "common.macro": "Macro {0} · {1}",
+ "common.master": "Master",
+ "common.metronome": "Métronome",
+ "common.midi_latency_0_smp": "MIDI · latence 0 éch.",
+ "common.min": "Min",
+ "common.mix_at_zero_only_the": "Mix à zéro : seul le signal sec s’entend",
+ "common.mixer": "Mixeur",
+ "common.modular": "Modular",
+ "common.mute": "Muet",
+ "common.new_project": "Nouveau projet",
+ "common.none": "Aucune",
+ "common.nota": "Nota",
+ "common.off": "Désactivé",
+ "common.open": "Ouvrir",
+ "common.other": "Autre",
+ "common.output": "Sortie",
+ "common.pan": "Pan",
+ "common.paste": "Coller",
+ "common.paste_bounced_audio": "Coller l’audio rendu",
+ "common.pattern": "Motif",
+ "common.pattern_n": "{0} · {1}",
+ "common.piano_roll": "Piano roll",
+ "common.pitch": "Hauteur",
+ "common.play_stop": "Lecture / arrêt",
+ "common.quantize": "Quantifier",
+ "common.range": "Plage",
+ "common.rate_the_free_lfo_rate": "Rate — la vitesse libre du LFO, 0,02 … 8 Hz",
+ "common.recent": "Récents",
+ "common.record": "Enregistrement",
+ "common.record_input": "Entrée d’enregistrement",
+ "common.release": "Relâchement",
+ "common.rename": "Renommer…",
+ "common.return": "Retour",
+ "common.return_n": "Retour {0}",
+ "common.reverse": "Inverser",
+ "common.sample": "Échantillon",
+ "common.save_preset": "Enregistrer le préréglage",
+ "common.select_a_track_first": "Sélectionner d’abord une piste.",
+ "common.send": "Envoi {0}",
+ "common.sends": "Envois",
+ "common.settings": "Réglages",
+ "common.show": "Afficher",
+ "common.solo": "Solo",
+ "common.start": "Début",
+ "common.stereo_map": "Carte stéréo",
+ "common.stop": "Arrêt",
+ "common.sustain": "Maintien",
+ "common.the_lfo_rate_in_hz": "La vitesse du LFO : en Hz, ou la valeur de note prise sur le tempo",
+ "common.track": "Piste",
+ "common.track_n": "Piste {0}",
+ "common.transport": "Transport",
+ "common.try_again": "Réessayer",
+ "common.type_value": "Saisir une valeur…",
+ "common.undo": "Annuler",
+ "common.unpacking": "Décompression de {0}…",
+ "common.update": "Mettre à jour",
+ "common.velocity": "Vélocité",
+ "common.version": "Version {0}",
+ "common.volume": "Volume",
+ "common.wet_only_send": "Wet only (envoi)",
+ "common.whats_new": "Nouveautés",
+ "control.clear_the_peak_hold": "Effacer le maintien de crête",
+ "control.meter_fader.drag_to_set_the_volume": "Glisser pour régler le volume · cliquer pour effacer le maintien de crête",
+ "control.na_badge.not_available_yet": "Pas encore disponible",
+ "control.value_entry.parameter": "Paramètre",
+ "control.value_entry.reset_to_default": "Rétablir par défaut",
+ "control.value_entry.value": "Valeur",
+ "detail.devices_clip": "Appareils / Clip",
+ "device.active_click_to_bypass": "Actif — cliquer pour contourner",
+ "device.arp.hold_keep_arpeggiating_after_the": "Hold : continuer l’arpège après le relâchement des touches",
+ "device.arp.midi_out_ch_1": "Sortie MIDI · can. 1",
+ "device.arp.midi_waiting_for_notes": "MIDI · en attente de notes",
+ "device.arp.next_groove_lane": "Voie de groove suivante",
+ "device.arp.no_notes_yet": "aucune note pour l’instant",
+ "device.arp.notes_oct_cycle_steps": "{0} notes · {1} oct · cycle de {2} pas",
+ "device.arp.oct": "{0} · {1} oct",
+ "device.arp.restart_the_pattern_from_step": "Relancer le motif depuis le pas 1",
+ "device.arp.step": "pas {0} · {1}",
+ "device.aurora.8_in_use": "{0} / 8 utilisés",
+ "device.aurora.click_for_the_next_macros": "Cliquer pour les macros suivantes, clic droit pour les précédentes",
+ "device.aurora.click_for_the_next_target": "Cliquer pour la cible suivante, clic droit pour la précédente",
+ "device.aurora.drag_a_cell_up_adds": "glisser une cellule — vers le haut ajoute, vers le bas retranche · ⌥-clic pour saisir · double-clic pour effacer",
+ "device.aurora.drag_or_turn_to_change": "{0} · glisser ou tourner pour modifier, double-clic pour saisir",
+ "device.aurora.drag_to_change_double_click": " · glisser pour modifier, double-clic pour réinitialiser",
+ "device.aurora.shape_lfo": "Shape · LFO {0}",
+ "device.aurora.shape_lfo_1_caps": "Shape · LFO 1",
+ "device.aurora.the_oscillator_whose_table_and": "L’oscillateur dont cette tranche modifie la table et le mode de warp",
+ "device.aurora.zero_every_route_in_the": "Remettre à zéro toutes les routes de la matrice",
+ "device.auto_filter.analog_a_gentle_saturation_after": "Analog — une légère saturation après le filtre, comme un circuit analogique",
+ "device.auto_filter.cutoff_over_time": "Coupure au fil du temps",
+ "device.auto_filter.cutoff_the_base_the_modulation": "Cutoff — la base d’où part la modulation ; le repère en pointillés indique la valeur actuelle. Double-clic pour réinitialiser, ⌥-clic pour saisir une valeur.",
+ "device.auto_filter.drag_sideways_for_the_cutoff": "Glisser latéralement pour la fréquence de coupure, vers le haut et le bas pour la résonance. La bande turquoise montre jusqu’où l’enveloppe et le LFO peuvent déplacer la coupure ; la courbe en pointillés indique où elle se trouve maintenant.",
+ "device.auto_filter.envelope_follower_on_off": "Suiveur d’enveloppe activé / désactivé",
+ "device.auto_filter.envelope_not_assigned": "enveloppe non assignée",
+ "device.auto_filter.hold_keep_the_envelope_at": "Hold — garde l’enveloppe à son pic pendant le temps HOLD avant le relâchement (∞ la fige)",
+ "device.auto_filter.lfo_not_assigned": "LFO non assigné",
+ "device.auto_filter.lfo_on_off": "LFO activé / désactivé",
+ "device.auto_filter.no_modulation_assigned": "aucune modulation assignée",
+ "device.auto_filter.none_this_tracks_input": "Aucun — entrée de cette piste",
+ "device.auto_filter.resonance_the_peak_at_the": "Resonance — le pic à la coupure ; le repère en pointillés indique la valeur actuelle. Double-clic pour réinitialiser, ⌥-clic pour saisir une valeur.",
+ "device.auto_filter.retrig_restart_the_lfo_on": "Retrig — relance le LFO à chaque attaque d’entrée (−24 dBFS) et au démarrage de la lecture",
+ "device.auto_filter.sidechain_key_envelope_source_caps": "Clé sidechain — source de l’enveloppe",
+ "device.auto_filter.sidechain_key_the_envelope_follows": "Clé sidechain — l’enveloppe suit une autre piste au lieu de celle-ci. L’activer pour choisir la source et le gain de clé ; clic droit pour la modifier.",
+ "device.auto_filter.stereo_phase_the_right_channels": "Stereo phase — le LFO du canal droit avance sur celui du gauche (90° une fois activé ; clic droit par pas de 45° … 180°)",
+ "device.auto_filter.the_inputs_envelope_teal_and": "L’enveloppe de l’entrée (turquoise) et la coupure qu’elle pilote (neutre), la coupure de base en pointillés. Glisser vers le haut ou le bas pour la quantité.",
+ "device.auto_filter.the_lfos_movement_over_the": "Le mouvement du LFO sur la fenêtre — forme brute en pointillés, ce que suit le filtre (après Smooth) en neutre, le canal droit en rose quand la stéréo est activée. Glisser vers le haut ou le bas pour la quantité, latéralement pour la phase de départ.",
+ "device.auto_gain.auto_rides_the_gain_to": "Auto amène le gain vers la cible sur Window ; Manual garde le fader là où il est placé (Match le règle sur l’écart à la cible)",
+ "device.auto_gain.ceiling_6_0_dbtp_drag": "Ceiling, −6 … 0 dBTP — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour revenir à −1,0",
+ "device.auto_gain.fixed_target_no_reference": "Cible fixe — pas de référence",
+ "device.auto_gain.input_loudness_on_the_chosen": "Volume d’entrée sur l’échelle choisie (LUFS) ; le repère turquoise est la cible",
+ "device.auto_gain.input_silent_the_measurement_and": "Entrée silencieuse : la mesure et le gain sont maintenus",
+ "device.auto_gain.leveler_bypassed_the_output_equals": "Leveler contourné : la sortie est égale à l’entrée",
+ "device.auto_gain.limited_by_max_cut": "limité par la coupe max.",
+ "device.auto_gain.limited_by_max_gain": "limité par le gain max.",
+ "device.auto_gain.limited_by_true_peak": "limité par le true-peak",
+ "device.auto_gain.match_set_the_manual_gain": "Match — règle le gain manuel sur l’écart entre l’entrée mesurée et la cible",
+ "device.auto_gain.max_gain_the_most_the": "Max gain — le renfort ou l’atténuation maximum de la correction, 0 … 24 dB",
+ "device.auto_gain.output_loudness_on_the_chosen": "Volume de sortie sur l’échelle choisie (LUFS) ; le repère turquoise est la cible",
+ "device.auto_gain.output_lu_from_the_target": "Sortie à {0} LU de la cible · Match règle {1} dB",
+ "device.auto_gain.output_true_peak_dbtp_the": "True peak de sortie (dBTP) ; le repère turquoise est le plafond tant que True-peak safe est activé",
+ "device.auto_gain.reset_restart_the_measurement_from": "Reset — relance la mesure à partir du volume actuel, pour que l’ajustement rattrape aussitôt",
+ "device.auto_gain.response_slow_glides_over_the": "Response — Slow glisse sur toute la fenêtre Window avec 20 ms d’anticipation ; Fast sur un quart de celle-ci avec 5 ms",
+ "device.auto_gain.scale_what_the_correction_reads": "Scale — ce que lit la correction : Momentary (400 ms, rapide et nerveux), Short-term (3 s) ou Integrated (12 s avec gating BS.1770, le plus stable)",
+ "device.auto_gain.target_loudness_36_0_lufs": "Volume cible, −36 … 0 LUFS. Cliquer sur la valeur pour les standards ou pour s’aligner sur le volume d’une autre piste (une référence) ; glisser la ligne en pointillés du graphique pour la même chose",
+ "device.auto_gain.the_correction_applied_max_gain": "La correction appliquée, ±Max Gain autour de 0 dB (trim non inclus)",
+ "device.auto_gain.the_correction_around_0_db": "La correction autour de 0 dB, ±Max Gain. En Manual, la glisser (Maj pour les pas fins) ; ⌥-clic pour saisir, double-clic pour revenir à 0 dB. En Auto, elle montre l’ajustement",
+ "device.auto_gain.the_last_8_s_input": "Les 8 dernières secondes : entrée, sortie et cible avec sa bande de ±1 LU (volume momentané). Glisser vers le haut / bas pour déplacer la cible ; ⌥-clic pour saisir, double-clic pour la réinitialiser",
+ "device.auto_gain.trim_a_fixed_offset_after": "Trim — un décalage fixe après la correction, −12 … +12 dB (la sortie s’écarte alors d’autant de la cible)",
+ "device.auto_gain.true_peak_safe_a_look": "True-peak safe — un limiteur à anticipation maintient la sortie sous le plafond (ajoute 5 / 20 ms de latence, compensée)",
+ "device.auto_gain.waiting_for_signal": "en attente de signal",
+ "device.auto_gain.waiting_for_signal_the_gain": "En attente de signal — le gain est maintenu jusqu’à la mesure de l’entrée",
+ "device.auto_gain.what_the_leveler_is_doing": "Ce que fait le leveler en ce moment",
+ "device.auto_gain.window_how_long_the_ride": "Window — le temps que met l’ajustement à atteindre la cible, 0,4 … 10 s (Fast : un quart de ce temps)",
+ "device.auto_pan.0_tremolo_both_channels_together": "0° — trémolo : les deux canaux ensemble",
+ "device.auto_pan.180_auto_pan_one_side": "180° — auto-pan : un côté monte quand l’autre descend",
+ "device.auto_pan.90_a_quarter_cycle_apart": "90° — un quart de cycle d’écart : le son tourne en cercle",
+ "device.auto_pan.above_8_hz_the_movement": "Au-delà de 8 Hz, le mouvement s’entend comme un flottement et non comme un panoramique",
+ "device.auto_pan.amount_or_mix_at_zero": "Amount ou Mix à zéro : rien ne bouge",
+ "device.auto_pan.amount_the_depth_each_channel": "Amount — la profondeur : chaque canal descend à 1 − Amount au creux du LFO",
+ "device.auto_pan.both_channels_gain_over_two": "Gain des deux canaux sur deux cycles du LFO — L neutre, R turquoise, Phase plus tard — avec le plancher atteint par la profondeur. Glisser vers le haut / bas pour Amount, à gauche / droite pour Phase ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
+ "device.auto_pan.gain_2_cycles_caps": "Gain · 2 cycles",
+ "device.auto_pan.mix_the_moving_signal_against": "Mix — le signal en mouvement face au signal sec",
+ "device.auto_pan.panner_bypassed_the_signal_passes": "Panner contourné : le signal passe inchangé",
+ "device.auto_pan.phase_0_l_and_r": "Phase 0° : L et R bougent ensemble, le niveau descend à ",
+ "device.auto_pan.phase_the_right_lfo_against": "Phase — le LFO droit par rapport au gauche : 0° trémolo, 90° panoramique circulaire, 180° auto-pan",
+ "device.auto_pan.rate_the_free_lfo_rate": "Rate — la vitesse libre du LFO, 0,01 … 40 Hz",
+ "device.auto_pan.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/32 avec valeurs pointées (D) et en triolets (T)",
+ "device.auto_pan.shape_sharpens_sine_tri_and": "Shape — durcit Sine, Tri et Saw vers un carré ; sur S&H c’est Glide, le glissement d’un pas au suivant",
+ "device.auto_pan.the_channels_output_peak_60": "La crête de sortie du canal, −60 … 0 dBFS, et le gain que le LFO lui donne en ce moment, dB",
+ "device.auto_pan.the_lfo_shape_s_h": "La forme du LFO. S&H tire un pas aléatoire à chaque cycle ; le canal droit joue les mêmes pas avec un décalage Phase",
+ "device.auto_pan.what_the_phase_makes_tremolo": "Effet de la phase : trémolo près de 0°, auto-pan près de 180°, un panoramique décalé entre les deux",
+ "device.auto_pan.where_the_sound_sits_now": "Où se trouve le son entre gauche et droite en ce moment, sur l’excursion couverte par le LFO",
+ "device.auto_shift.amount_how_far_the_voice": "Amount — l’attraction de la voix vers la note",
+ "device.auto_shift.amount_how_far_the_voice_2": "Amount — l’attraction de la voix vers la note cible",
+ "device.auto_shift.bend_the_widest_move_between": "Bend — le plus grand écart entre notes qui glisse via Glide ; les sauts plus larges sont directs",
+ "device.auto_shift.custom_edit_on_the_scale": "Custom — à modifier dans l’onglet Scale",
+ "device.auto_shift.follow_copy_the_key_and": "Follow — copie la tonalité et la gamme d’un effet MIDI Nota Scale",
+ "device.auto_shift.follow_copy_the_key_and_2": "Follow — copie la tonalité et la gamme d’un effet MIDI Nota Scale (celui de cette piste, de la source MIDI, ou le premier trouvé)",
+ "device.auto_shift.follow_scale_device": "Suivre l’appareil Scale",
+ "device.auto_shift.from_the_instrument_track_whose": "From — la piste d’instrument dont les notes définissent la cible (ses clips et effets MIDI, même muette)",
+ "device.auto_shift.glide_how_long_the_target": "Glide — la durée du glissement de la cible d’une note à la suivante (Pitch bend from MIDI)",
+ "device.auto_shift.how_long_each_note_was": "La durée de chaque note chantée (les ~16 dernières mesures) sur les notes de la gamme — neutre dans la gamme, turquoise en dehors. Cliquer une colonne pour ajouter ou retirer sa note",
+ "device.auto_shift.human_keeps_vibrato_and_slow": "Human — garde le vibrato et la dérive lente autour de la note corrigée (0 = plat)",
+ "device.auto_shift.key_source_auto_follows_the": "Key source — Auto suit la tonalité chantée, Manual utilise la tonalité et la gamme réglées, MIDI prend la cible dans les notes d’une autre piste (onglet MIDI)",
+ "device.auto_shift.key_source_is_not_midi": "Key Source n’est pas MIDI",
+ "device.auto_shift.key_the_tonic_the_scales": "Key — la tonique ; les notes de la gamme sont comptées à partir d’elle",
+ "device.auto_shift.latch_holds_the_target_between": "latch maintient la cible entre les notes",
+ "device.auto_shift.latch_keep_the_last_target": "Latch — garde la dernière cible entre les notes (off = aucune correction tant qu’aucune note n’est tenue)",
+ "device.auto_shift.learn_listen_to_what_is": "Learn — écoute ce qui est chanté, puis cliquer à nouveau pour régler la tonalité et la gamme qui conviennent le mieux",
+ "device.auto_shift.no_correction_between_notes": "aucune correction entre les notes",
+ "device.auto_shift.no_note_held": "aucune note tenue",
+ "device.auto_shift.note_the_voice_goes_to": "Note — la voix va à la dernière note tenue ; Scale — les notes tenues forment la gamme",
+ "device.auto_shift.oct_lock_the_notes_own": "Oct lock — l’octave propre de la note (off = l’octave de la note la plus proche de la voix)",
+ "device.auto_shift.out_of_scale": "hors gamme",
+ "device.auto_shift.pick_a_track_in_from": "choisir une piste dans FROM",
+ "device.auto_shift.pitch_bend_from_midi": "Pitch bend depuis le MIDI",
+ "device.auto_shift.pitch_bend_from_midi_moves": "Pitch bend from MIDI — les passages d’une note à l’autre glissent via Glide s’ils restent dans Bend ; off = la cible saute",
+ "device.auto_shift.preserve_formants_the_vowel_colour": "Preserve formants — la couleur des voyelles reste en place quand la hauteur bouge (off = elle suit la hauteur, comme une bande accélérée)",
+ "device.auto_shift.range_the_largest_correction_a": "Range — la plus grande correction ; une note plus éloignée n’est ramenée que de cette valeur",
+ "device.auto_shift.scale_chromatic_major_minor_pentatonic": "Scale — Chromatic, Major, Minor, Pentatonic (majeure ou mineure — cliquer à nouveau pour alterner) ou Custom (les notes ci-dessous)",
+ "device.auto_shift.scale_the_notes_the_voice": "Scale — les notes vers lesquelles la voix est attirée",
+ "device.auto_shift.sing_a_few_bars": "chanter quelques mesures",
+ "device.auto_shift.skip_sibilants_s_sh_t": "Skip sibilants — s, ch, t et le souffle passent sans transposition, pour ne pas devenir métalliques",
+ "device.auto_shift.source_sets_the_detection_range": "Source — définit la plage de détection pour un type de voix ou un instrument",
+ "device.auto_shift.speed_how_fast_the_retune": "Speed — la vitesse du glissement de la correction (2 ms = hard tune)",
+ "device.auto_shift.speed_how_fast_the_voice": "Speed — la vitesse à laquelle la voix suit la cible",
+ "device.auto_shift.the_correction_now_up_or": "La correction actuelle — vers le haut ou le bas depuis le centre, pleine hauteur = 2 demi-tons",
+ "device.auto_shift.the_detected_pitch_low_to": "La hauteur détectée, du grave à l’aigu sur la plage de détection (onglet Detect)",
+ "device.auto_shift.the_detected_pitch_teal_dots": "La hauteur détectée (points turquoise) et la sortie corrigée (neutre) sur les deux dernières secondes, sur les voies de notes de la gamme ; la voie cible est allumée",
+ "device.auto_shift.the_key_that_fits_what": "La tonalité qui correspond à ce qui a été chanté (profils de Krumhansl sur les ~16 dernières mesures), et la seconde. Learn la règle ; Auto la suit",
+ "device.auto_shift.the_source_tracks_notes_neutral": "Les notes de la piste source (blocs neutres, accent pendant qu’elles sonnent) et la voix (turquoise) sur les deux dernières secondes — avec Key Source MIDI, la voix est attirée vers les notes",
+ "device.auto_shift.what_the_detector_hears_now": "Ce que le détecteur entend en ce moment et la correction appliquée — ou, avec Key Source MIDI, la note vers laquelle la voix est attirée",
+ "device.bass.cut_pitch_wheel": "→ coupure/hauteur · molette",
+ "device.bass.mod_wheel_opens_the_lfo": "Mod wheel — ouvre le LFO sur la coupure",
+ "device.bass.slide_into_a_note_played": "Glisser vers une note jouée par-dessus une note tenue, sans nouvelle attaque",
+ "device.beat_repeat.capture_and_repeat": "Capturer et répéter",
+ "device.beat_repeat.captured_sound_repeating": "Son capturé · répétition",
+ "device.beat_repeat.chance_how_likely_each_interval": "Chance — la probabilité que chaque intervalle déclenche une répétition",
+ "device.beat_repeat.each_repeat_lower_and_narrower": "chaque répétition plus basse et plus étroite",
+ "device.beat_repeat.each_repeat_lower_same_band": "chaque répétition plus basse, même bande",
+ "device.beat_repeat.filter_off_or_a_low": "Filter — Off, ou un passe-bas, passe-bande ou passe-haut sur les répétitions",
+ "device.beat_repeat.freq_the_filters_frequency": "Freq — la fréquence du filtre",
+ "device.beat_repeat.gate_how_long_the_burst": "Gate — la durée de la rafale, en seizièmes de l’intervalle",
+ "device.beat_repeat.grid_the_length_of_the": "Grid — la durée de la tranche qui se répète",
+ "device.beat_repeat.interval_how_often_it_rolls": "Interval — la fréquence à laquelle Chance est tiré",
+ "device.beat_repeat.interval_how_often_it_rolls_2": "Interval — la fréquence à laquelle Chance est tiré : 1/8, 1/4, 1/2 note, ou toutes les 1, 2, 4 mesures",
+ "device.beat_repeat.latch_the_repeat_button_stays": "Latch — le bouton Repeat reste actif après un clic au lieu de l’être seulement tant qu’il est tenu",
+ "device.beat_repeat.mode_mix_the_repeats_play": "Mode — Mix : les répétitions jouent par-dessus le signal sec ; Insert : elles le remplacent pendant qu’elles jouent ; Gate : seule la rafale sonne",
+ "device.beat_repeat.narrow_with_repeats": "Narrow with repeats",
+ "device.beat_repeat.narrow_with_repeats_each_repeat": "Narrow with repeats — chaque répétition rétrécit la bande et la déplace avec la hauteur",
+ "device.beat_repeat.offset_where_in_the_interval": "Offset — à quel endroit de l’intervalle il se déclenche, en seizièmes",
+ "device.beat_repeat.pitch_decay_each_repeat_drops": "Pitch decay — chaque répétition descend plus bas, jusqu’à 6 demi-tons par répétition",
+ "device.beat_repeat.pitch_the_repeats_transposed_12": "Pitch — les répétitions transposées, ±12 demi-tons",
+ "device.beat_repeat.repeat_filter_off": "Repeat filter · off",
+ "device.beat_repeat.repeat_filter_the_repeats_go": "Repeat filter — les répétitions passent par le filtre (onglet Filter)",
+ "device.beat_repeat.repeat_repeat_the_current_slice": "Repeat — répète la tranche actuelle maintenant, tant qu’il est tenu (avec Latch : un clic pour activer, un clic pour arrêter)",
+ "device.beat_repeat.reset_stop_the_repeat_and": "Reset — arrête la répétition et efface la ligne de temps et les vumètres",
+ "device.beat_repeat.the_grid_holds_still": "la grille reste immobile",
+ "device.beat_repeat.the_input_level": "Le niveau d’entrée",
+ "device.beat_repeat.the_last_intervals_sound_teal": "Le son du dernier intervalle (turquoise) sur la grille : le gate à partir de l’offset est ombré et la tranche capturée est en laiton. Glisser latéralement la ligne d’offset ou la fin du gate ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.beat_repeat.the_repeat_filter_only_the": "Le filtre des répétitions — seules les répétitions le traversent. Plein : la première répétition ; turquoise en pointillés : une suivante quand la bande se resserre et suit la hauteur. Glisser le nœud pour la fréquence, un bord de bande pour la largeur ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.beat_repeat.the_repeats_level_after_pitch": "Le niveau des répétitions — après hauteur, filtre, déclin et volume",
+ "device.beat_repeat.the_repeats_pass_unfiltered": "les répétitions passent sans filtre",
+ "device.beat_repeat.the_same_on_every_repeat": "identique à chaque répétition",
+ "device.beat_repeat.triplet_the_grid_in_triplets": "Triplet — la grille en triolets (un tiers plus court)",
+ "device.beat_repeat.two_intervals_on_the_grid": "Deux intervalles sur la grille : chaque pas est le niveau de l’entrée — pâle quand il est sec, plein là où la tranche est capturée, plus pâle à chaque répétition au fil du déclin. Les repères en haut marquent où l’intervalle se déclenche.",
+ "device.beat_repeat.variation_the_grid_floats_up": "Variation — la grille varie jusqu’à ce nombre de pas (double / moitié) à chaque déclenchement",
+ "device.beat_repeat.what_the_repeater_is_doing": "Ce que fait le répéteur en ce moment — attendre l’intervalle, capturer la tranche, ou la répéter — et où en est le transport",
+ "device.beat_repeat.width_the_band_in_octaves": "Width — la largeur de la bande en octaves (passe-bas et passe-haut : moins, c’est plus résonant)",
+ "device.bypassed": "Contourné",
+ "device.bypassed_click_to_enable": "Contourné — cliquer pour activer",
+ "device.card.bypassed": "Contourné",
+ "device.card.changed_since_you_loaded_choose": "Modifié depuis le chargement de {0} · choisir un préréglage",
+ "device.card.choose_a_preset": "Choisir un préréglage",
+ "device.card.init": "Init",
+ "device.card.next_preset": "Préréglage suivant",
+ "device.card.previous_preset": "Préréglage précédent",
+ "device.card.value": "Valeur",
+ "device.ceiling.auto_release_the_release_slows": "Auto release — le relâchement ralentit quand la réduction s’accentue (jusqu’à 5× à 7 dB), pour que les passages denses ne pompent pas",
+ "device.ceiling.ceiling_the_output_never_goes": "Ceiling — la sortie ne le dépasse jamais (en dBTP avec True peak activé)",
+ "device.ceiling.character_clean_transparent_the_fastest": "Character — Clean : transparent, l’attaque la plus rapide ; Punch : une attaque plus lente laisse passer le transitoire jusqu’à l’écrêtage ; Glue : un relâchement lent et un genou doux sous le plafond",
+ "device.ceiling.delta_hear_what_it_removes": "Delta · entendre ce qui est retiré",
+ "device.ceiling.delta_play_the_difference_between": "Delta — jouer la différence entre l’entrée et la sortie : ce que retire le limiteur",
+ "device.ceiling.gain_how_hard_the_signal": "Gain — la force avec laquelle le signal est poussé vers le plafond",
+ "device.ceiling.gain_reduction_0_24_db": "Réduction de gain, 0 … 24 dB",
+ "device.ceiling.hearing_what_it_removes": "écoute de ce qui est retiré",
+ "device.ceiling.integrated_loudness_since_the_last": "Volume intégré depuis le dernier Reset, avec gate (BS.1770), par rapport à Target",
+ "device.ceiling.internal_this_track": "Interne — cette piste",
+ "device.ceiling.key_source_internal_limits_on": "Key source — Internal limite selon les crêtes de cette piste ; choisir une autre piste pour ducker celle-ci quand l’autre atteint son pic",
+ "device.ceiling.lets_the_attack_through": "laisse passer l’attaque",
+ "device.ceiling.level_and_reduction": "Niveau et réduction",
+ "device.ceiling.momentary_teal_short_term_neutral": "Volume momentané (turquoise), à court terme (neutre) et intégré (rose) sur les 60 dernières secondes autour de la cible, ±1 LU ombré. Glisser la ligne de cible ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.ceiling.release_how_fast_the_gain": "Release — la vitesse de retour du gain (le caractère la module ; Auto rel laisse le signal décider)",
+ "device.ceiling.reset_peaks_clear_the_peak": "Reset peaks — efface les maintiens de crête, la réduction maximale et le compte d’écrêtages",
+ "device.ceiling.reset_start_the_integrated_loudness": "Reset — relance le volume intégré, la plage et les crêtes",
+ "device.ceiling.slow_and_dense": "lent et dense",
+ "device.ceiling.target_the_loudness_the_meters": "Target — le volume auquel les vumètres se comparent : −14 pour le streaming, −16 pour les podcasts, −23 pour la diffusion. Cela ne change pas le son ; glisser la ligne en pointillés pour toute valeur",
+ "device.ceiling.the_difference_in_out": "la différence entrée − sortie",
+ "device.ceiling.the_gain_reduction_over_the": "La réduction de gain sur les 4 dernières secondes : turquoise là où un transitoire est passé jusqu’à l’écrêtage, la ligne en pointillés est la moyenne",
+ "device.ceiling.the_input_after_gain_with": "L’entrée après Gain, avec le plafond marqué",
+ "device.ceiling.the_last_4_s_the": "Les 4 dernières secondes : l’entrée (turquoise), la partie au-dessus du plafond (rouge) et la sortie (neutre), avec la réduction en dessous. Glisser la ligne du plafond ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.ceiling.true_peak_4": "true peak · 4×",
+ "device.ceiling.true_peak_the_detector_reads": "True peak — le détecteur lit la crête inter-échantillons (4×), pour que le plafond tienne en dBTP après conversion",
+ "device.ceiling.what_the_limiter_listens_to": "Ce qu’écoute le limiteur — ou, avec Delta activé, que l’on n’entend que ce qu’il retire",
+ "device.chamber.algorithm_share_of_the_blend": "Part de l’algorithme dans le mélange (entraîne Blend)",
+ "device.chamber.at_the_input_before_both": "à l’entrée, avant les deux moteurs",
+ "device.chamber.at_the_output_dry_wet": "à la sortie, sec + traité",
+ "device.chamber.blend_convolution_slate_top_algorithm": "Blend — convolution (ardoise, haut) ⇄ algorithme (neutre, bas). Double-clic : 50 / 50",
+ "device.chamber.concert_hall_wide": "Concert Hall · Wide",
+ "device.chamber.convolution_share_of_the_blend": "Part de la convolution dans le mélange (entraîne Blend)",
+ "device.chamber.drag_a_marker_to_set": "Glisser un repère pour régler le RT60 de cette bande (mid = Decay ; low / high le suivent en rapports). Le potentiomètre Damping règle le crossover haut. · ⌥-clic pour saisir",
+ "device.chamber.drag_the_trim_lines_to": "Glisser les lignes de découpe pour recadrer la réponse impulsionnelle (Start · Decay) ; ⌥-clic pour saisir, double-clic pour réinitialiser. Déposer un fichier audio ici pour le charger.",
+ "device.chamber.drop_an_impulse_response_here": "Déposer une réponse impulsionnelle ici (WAV / FLAC / MP3) ou cliquer sur Load…",
+ "device.chamber.dry_wet_double_click_resets": "Dry/Wet — double-clic pour réinitialiser",
+ "device.chamber.ducking_the_wet_dips_up": "Ducking — le signal traité baisse (jusqu’à 24 dB) tant que l’entrée joue",
+ "device.chamber.eco_ir_up_to_3": "Eco : réponse jusqu’à 3 s · Mid : 6 s · High : 10 s + modulation de l’algorithme interpolée en cubique",
+ "device.chamber.feed_shimmer_back": "Réinjecter le shimmer",
+ "device.chamber.freeze_hold_the_algorithm_tail": "Freeze — maintient la queue de l’algorithme indéfiniment ; l’entrée est coupée",
+ "device.chamber.hold_in_keep_feeding_the": "Hold in — continue d’envoyer l’entrée dans la queue gelée (superposition)",
+ "device.chamber.impulse_response_built_in_rooms": "Impulse response — pièces intégrées, ou votre propre fichier (le déposer sur la forme d’onde)",
+ "device.chamber.left_handle_low_cut_x": "Poignée gauche : coupe-bas (X) + shelf grave (Y) · poignée droite : coupe-haut (X) + shelf aigu (Y) · ⌥-clic pour saisir",
+ "device.chamber.load": "Charger…",
+ "device.chamber.load_an_impulse_response_wav": "Charger une réponse impulsionnelle (WAV / FLAC / MP3 — mono, stéréo ou vrai stéréo 4 canaux)",
+ "device.chamber.load_impulse_response": "Charger une réponse impulsionnelle…",
+ "device.chamber.on_exact_convolution_timing_at": "On : timing de convolution exact à 0 ms de predelay (tête FIR, plus de CPU). Off : plus léger — le premier bloc arrive en retard et est absorbé dans le predelay.",
+ "device.chamber.on_the_tail_before_dry": "sur la queue, avant Dry/Wet",
+ "device.chamber.parallel_both_engines_hear_the": "Parallel : les deux moteurs entendent l’entrée · Serial : la convolution alimente l’algorithme",
+ "device.chamber.shimmer_pitch_shift": "Shimmer · pitch shift",
+ "device.chamber.shimmer_pitch_shift_caps": "Shimmer · pitch shift",
+ "device.chamber.shimmer_shimmer_mode_only": "Shimmer · mode shimmer uniquement",
+ "device.chamber.user_ir_none_loaded": "Réponse perso (aucune chargée)",
+ "device.chamber.user_ir_none_loaded_2": "Réponse perso — aucune chargée",
+ "device.chamber.wet_only_100_wet_no": "Wet only — 100 % traité, sans signal sec : pour une piste de retour / d’envoi",
+ "device.chord.custom_your_own_shifts": "Custom : vos propres décalages",
+ "device.chord.drop_added_notes_outside_a": "Ramener d’un demi-ton dans {0} les notes ajoutées hors de celle-ci",
+ "device.chord.drop_added_notes_outside_the": "Ramener d’un demi-ton dans la gamme les notes ajoutées hors de celle-ci",
+ "device.chord.fold_key_click_for_the": "Fold key — cliquer pour la suivante, Maj-clic pour la précédente",
+ "device.chord.fold_scale_major_natural_minor": "Fold scale — majeure / mineure naturelle",
+ "device.chord.in_voices": "En {0} · {1} · {2} voix",
+ "device.chord.in_voices_strum_ms_spread": "En {0} · {1} · {2} voix · strum {3} ms · spread {4}",
+ "device.chord.play_the_note_you_pressed": "Jouer la note appuyée en plus des notes ajoutées",
+ "device.chord.set_the_shifts_to": "{0} : régler les décalages sur {1}",
+ "device.chord.shift_drag_up_down_12": "Décalage {0} : glisser vers le haut / bas (±12 demi-tons) · ⌥-clic pour saisir · double-clic pour réinitialiser",
+ "device.chord.shift_on_off": "Décalage {0} activé / désactivé",
+ "device.chord.shift_velocity_offset_drag_sideways": "Décalage de vélocité {0} — glisser latéralement, ⌥-clic pour saisir, double-clic pour réinitialiser",
+ "device.chorus.amount_at_zero_the_voices": "Quantité à zéro : les voix restent immobiles, un ",
+ "device.chorus.amount_how_far_the_lfo": "Amount — l’amplitude du LFO sur le retard de chaque voix : plus c’est grand, plus le désaccord est large",
+ "device.chorus.chorus_bypassed_the_signal_passes": "Chorus contourné : le signal passe inchangé",
+ "device.chorus.classic_two_voices_left_and": "Classic — deux voix, gauche et droite ; Ensemble — trois voix à 120°, un scintillement de string machine ; Vibrato — l’oscillation de hauteur seule, sans signal sec",
+ "device.chorus.detune_up_to": "Désaccord jusqu’à ±",
+ "device.chorus.draws_each_voices_delay_ct": "τ trace le retard de chaque voix ; ct son désaccord — de combien le retard mobile infléchit la hauteur",
+ "device.chorus.each_voice_over_two_lfo": "Chaque voix sur deux cycles du LFO — son retard (τ) ou son désaccord (ct) — et sa position actuelle. Glisser vers le haut / bas pour Amount ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.chorus.feedback_the_voices_fed_back": "Feedback — les voix réinjectées dans la ligne, ±90 % : un peu épaissit, au-delà de 60 % le son devient métallique comme un flanger",
+ "device.chorus.how_many_voices_sing_or": "Le nombre de voix qui chantent, ou le fait que le feedback le fait sonner (au-delà de 60 %), ou que Vibrato joue uniquement le signal traité",
+ "device.chorus.hpf_a_high_pass_on": "HPF — un passe-haut sur l’entrée traitée (20 Hz … 2 kHz), pour que les graves restent secs et centrés ; tout à gauche, il est désactivé",
+ "device.chorus.mix_0_dry_50_dry": "Mix — 0 % sec, 50 % sec et traité à égalité, 100 % les voix seules. Vibrato est toujours traité",
+ "device.chorus.offset_the_right_voices_lfo": "Offset — le LFO de la voix droite en retard sur la gauche : 0° les fait bouger ensemble, 180° en opposition. Ensemble espace ses trois voix de 120° de lui-même",
+ "device.chorus.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/16 avec valeurs en triolets (T)",
+ "device.chorus.the_largest_detune_the_sweep": "Le plus grand désaccord atteint par le balayage, ± cents (0 … 60 sur la barre)",
+ "device.chorus.the_range_each_voices_delay": "La plage balayée par le retard de chaque voix, ms (0 … 24 sur la barre)",
+ "device.chorus.vibrato_no_dry_signal_the": "Vibrato : pas de signal sec, la hauteur oscille de ±",
+ "device.chorus.warmth_a_bucket_brigade_flavour": "Warmth — une saveur à capacités commutées sur la ligne à retard : plus sombre (passe-bas jusqu’à 2,5 kHz) et légèrement saturé",
+ "device.chorus.where_the_voices_sit_in": "Où se placent les voix dans le champ stéréo (Width) et de combien chacune est désaccordée en ce moment",
+ "device.chorus.width_0_the_voices_fold": "Width 0 % : les voix se replient en mono, sans espace",
+ "device.chorus.width_the_voices_stereo_spread": "Width — l’étalement stéréo des voix : 0 % mono, 100 % tel quel, 200 % relève le side de +6 dB",
+ "device.comp.no_key_signal": "aucun signal de clé",
+ "device.compressor.auto_gain_make_up_that": "Auto gain — un gain de compensation qui suit le seuil et le ratio",
+ "device.compressor.auto_release_a_slower_second": "Auto-release — un second relâchement plus lent quand la réduction est profonde, pour que le matériel soutenu ne pompe pas",
+ "device.compressor.character_the_voicing_clean_as": "Character — le voicing : Clean tel que réglé, Glue plus lent et plus doux, Punch plus rapide, Opto lent et doux selon le programme, FET très rapide",
+ "device.compressor.detector_peak_reacts_to_every": "Detector — Peak réagit à chaque transitoire, RMS au corps du son, Auto suit le corps tout en captant les pointes",
+ "device.compressor.drag_sideways_for_the_threshold": "Glisser latéralement pour le seuil, vers le haut / bas pour le ratio. Double-clic pour réinitialiser les deux. Le point indique le niveau de la clé en ce moment.",
+ "device.compressor.external_key_key_off_the": "External key — déclenche depuis la source choisie dans l’onglet Sidechain ; désactivé, la piste se déclenche elle-même",
+ "device.compressor.gain_reduction_over_the_last": "Réduction de gain sur les quatre dernières secondes ; la ligne en pointillés est la crête. Cliquer pour l’effacer.",
+ "device.compressor.key_audible_output_muted": "clé audible · sortie coupée",
+ "device.compressor.key_gain_drives_the_detector": "Key gain — pousse le détecteur plus ou moins fort. ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.compressor.key_source_internal_keys_off": "Key source — Internal se déclenche sur cette piste ; choisir une autre piste, ou l’un de ses pads ou chaînes, pour ducker ou pomper contre elle",
+ "device.compressor.listen_hear_the_filtered_key": "Listen — écouter la clé filtrée au lieu de la sortie, pour régler HP / LP à l’oreille",
+ "device.compressor.make_up_gain_click_types": "Gain de compensation. ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.compressor.no_reduction_to_measure": "aucune réduction à mesurer",
+ "device.compressor.stereo_link_one_reduction_for": "Stereo link — une seule réduction pour les deux canaux ; désactivé, gauche et droite compressent séparément",
+ "device.compressor.the_keys_spectrum_under_its": "Le spectre de la clé sous ses filtres — glisser une poignée latéralement pour déplacer HP / LP, vers le haut / bas pour Q. ⌥-clic sur une poignée pour la saisir, double-clic pour l’ouvrir.",
+ "device.compressor.the_reduction_neutral_ink_hanging": "La réduction (neutre, suspendue à 0 dB) face au niveau d’entrée (turquoise) — l’attaque est la descente, le relâchement la remontée. La ligne en pointillés est le seuil.",
+ "device.compressor.threshold_the_tick_is_the": "Threshold — le repère indique le niveau de la clé en ce moment. ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.compressor.where_the_source_is_tapped": "Où la source est prélevée : avant ses effets et son fader, ou après — pour un pad ou une chaîne, avant ses propres effets, ou après eux et son niveau",
+ "device.consort.a_cable_breaks_the_normal": "Un câble coupe la connexion normalisée sur Gate / Filt in / VCA in / Ext in · les boucles tournent avec un échantillon de retard",
+ "device.consort.all_normals_intact": "toutes les connexions normalisées intactes",
+ "device.consort.analog_delay_bbd": "Delay analogique · BBD",
+ "device.consort.attenuators_scale_whatever_is_patched": "Les atténuateurs mettent à l’échelle ce qui est branché sur Atten 1/2 in ; Sum additionne ses entrées",
+ "device.consort.cables": { "one": "{0} câble", "other": "{0} câbles" },
+ "device.consort.cables_points": "{0} câbles · {1} points",
+ "device.consort.clock_out_patch_bay": "Clock out (patch bay)",
+ "device.consort.depth": "{0} · depth {1:+0;−0;0}",
+ "device.consort.depth_drag_up_down_click": "Depth — glisser vers le haut / bas (⌥-clic pour saisir, double-clic : +50)",
+ "device.consort.drag_jack_to_jack_alt": "Glisser de prise à prise · Alt-clic pour retirer · clic droit pour une liste",
+ "device.consort.ext_normalled_to_the_vca": "EXT : normalisé sur la sortie du VCA (réinjection façon Moog) — brancher Ext in pour le remplacer",
+ "device.consort.filt_1_cutoff_input": "Entrée de coupure Filt 1",
+ "device.consort.filt_2_cutoff_input": "Entrée de coupure Filt 2",
+ "device.consort.gated_glide_only_between_overlapping": "Glide conditionnel : seulement entre notes qui se chevauchent (legato)",
+ "device.consort.jack_strip_points": "Bandeau de prises · {0} points · ",
+ "device.consort.lfo_out_patch_bay": "LFO out (patch bay)",
+ "device.consort.lfo_pitch_all_oscillators_or": "LFO pitch → tous les oscillateurs, ou seulement 2 et 4",
+ "device.consort.lfo_rate_input_patch_bay": "Entrée de vitesse LFO (patch bay)",
+ "device.consort.matrix_view_drag_a_cell": "Vue matrice · glisser une cellule pour la profondeur, ⌥-clic pour la saisir, double-clic pour supprimer · ",
+ "device.consort.off_seq_steps_transposed_by": "Off · SEQ (pas transposés par la touche) · ARP (l’accord tenu sur 1 à 3 octaves)",
+ "device.consort.open_the_full_patch_bay": "Ouvrir le patch bay complet (les 42 points) · dans l’onglet Patch : retour au dernier panneau",
+ "device.consort.os_0_smp_cpu": "{0} · ×{1} OS · 0 éch. · CPU {2:0} %",
+ "device.consort.osc_pitch_input_patch_bay": "Entrée de hauteur Osc {0} (patch bay)",
+ "device.consort.oscillator_s_note_paraphonic_the": "Note de l’oscillateur {0} (paraphonique) · les dernières voix en vrai poly",
+ "device.consort.paint_steps_alt_click_a": "Peindre {0} pas (Alt-clic sur un pas : silence)",
+ "device.consort.pitch_arp_step_types_shape": "Hauteur · arp (les types de pas façonnent le rythme)",
+ "device.consort.pitch_step_offsets_from_the": "Hauteur · décalages des pas par rapport à la touche",
+ "device.consort.pulse_width_of_the_pulse": "Largeur d’impulsion de l’onde pulse (le carré reste à 50 %)",
+ "device.consort.ratchet_repeats_per_step": "Répétitions de ratchet par pas",
+ "device.consort.remove": "Retirer {0} {1:+0;−0;0}",
+ "device.consort.seq_gate_out_patch_bay": "Seq gate out (patch bay)",
+ "device.consort.sequence_length_drag_up_down": "Longueur de la séquence — glisser vers le haut / bas",
+ "device.consort.sequencer_off_pick_seq_or": "Séquenceur désactivé · choisir SEQ ou ARP, puis tenir une touche",
+ "device.consort.step_rate_synced_to_the": "Vitesse des pas (synchronisée au tempo de l’hôte)",
+ "device.consort.sync_to_host_bpm_cpu": "{0} · synchro à l’hôte {1:0} BPM · CPU {2:0} %",
+ "device.consort.true_poly_16": "Vrai poly (16)",
+ "device.crush.anti_alias_a_4th_order": "Anti-alias — un passe-bas d’ordre 4 à la fréquence de Nyquist du taux réduit avant le maintien, pour réduire le repliement en images",
+ "device.crush.auto_gain_rides_the_output": "Auto gain — ramène la sortie au volume de l’entrée (RMS 300 ms, ±24 dB), pour que Bits ou Drive ne fassent pas sauter le niveau",
+ "device.crush.bits_the_bit_depth_1": "Bits — la profondeur de bits, 1 … 24 : moins de bits, moins de niveaux, plus de grain",
+ "device.crush.dc_filter_a_10_hz": "DC filter — un passe-haut à 10 Hz sur le signal écrasé : retire le décalage continu que peut laisser un crush grossier, replié ou bruité",
+ "device.crush.dither_up_to_lsb_of": "Dither — jusqu’à ±½ LSB de bruit triangulaire avant les niveaux : adoucit les marches en souffle",
+ "device.crush.drive_12_24_db_into": "Drive — −12 … +24 dB dans le crusher : pousse le signal vers les niveaux supérieurs, dans l’écrêtage Analog ou vers davantage de repliements",
+ "device.crush.input_output_through_drive_the": "Entrée → sortie à travers Drive, le mode et les niveaux ; le point marque la crête du signal. Glisser vers le haut / bas pour Drive ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.crush.jitter_the_hold_length_wanders": "Jitter — la durée du maintien varie jusqu’à ±50 % : une horloge instable, irrégulière",
+ "device.crush.level_step_shown_enlarged": "pas de niveau affiché agrandi",
+ "device.crush.levels_after_the_fold": " niveaux après le pli",
+ "device.crush.mode_digital_hard_truncation_to": "Mode — Digital : troncature dure aux niveaux ; Analog : un écrêtage tanh doux avant eux (+4 dB, plus rond) ; Fold : un wavefolder — plus de Drive replie les crêtes plus souvent",
+ "device.crush.noise_a_white_noise_floor": "Noise — un plancher de bruit blanc sous le crush, jusqu’à −50 dBFS",
+ "device.crush.output_gain_12_db": "Gain de sortie, ±12 dB",
+ "device.crush.peaks_in_and_out_and": "Crêtes en entrée et en sortie, et facteur de crête de la sortie (crête sur RMS) — le crush l’aplatit",
+ "device.crush.post_filter_a_low_pass": "Post filter — un passe-bas après le crush, 200 Hz … 20 kHz : sous Nyquist, il lisse les marches",
+ "device.crush.rate_the_reduced_sample_rate": "Rate — la fréquence d’échantillonnage réduite, 500 Hz … pleine : plus bas, chaque valeur est tenue plus longtemps et des images apparaissent au-dessus de sa fréquence de Nyquist",
+ "device.crush.the_filter_cuts_the_images": "le filtre coupe les images",
+ "device.crush.the_input_peak_60_0": "La crête d’entrée, −60 … 0 dBFS",
+ "device.crush.the_output_peak_60_0": "La crête de sortie, −60 … 0 dBFS",
+ "device.crush.the_output_spectrum_neutral_ink": "Le spectre de sortie : le neutre est le signal, le turquoise ce qu’a ajouté le crush — vif au-dessus du Nyquist réduit (les images). Glisser la ligne de Nyquist pour Rate, la ligne du filtre pour le post filter ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.crush.two_cycles_of_a_sine": "Deux cycles d’une sinusoïde au niveau d’attaque (pointillés) et ce qui en sort",
+ "device.crush.wet_the_crushed_signal_against": "Wet — le signal écrasé face au signal sec",
+ "device.crush.what_comes_out_the_bit": "Ce qui sort : la profondeur de bits et la fréquence, et si le post filter coupe les images au-dessus du Nyquist réduit ou les laisse passer",
+ "device.delay.clear_loop": "Effacer la boucle",
+ "device.delay.empty_the_delay_buffer_silences": "Vider le tampon de delay — coupe ce qui circule encore",
+ "device.delay.fade_on_change_crossfade_to": "Fade on change — fondu enchaîné vers le nouveau temps de delay au lieu d’y glisser (ce qui modifie la hauteur, façon bande)",
+ "device.delay.feedback_how_much_of_each": "Feedback — la part de chaque répétition qui repart pour un tour ; Freeze la bloque à 100 %. ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.delay.freeze_hold_the_loop_forever": "Freeze — maintient la boucle indéfiniment ; l’entrée est coupée et les répétitions cessent de décroître",
+ "device.delay.latency_comp": "Comp. de latence",
+ "device.delay.link_l_r_the_right": "Link L/R — le canal droit suit le temps du gauche",
+ "device.delay.loop_held_no_decay": "Boucle maintenue · sans déclin",
+ "device.delay.ping_pong_each_repeat_crosses": "Ping-pong — chaque répétition passe sur l’autre canal",
+ "device.delay.spread_pushes_the_right_channel": "Spread — retarde le canal droit, jusqu’à 50 ms. ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.delay.tap_four_times_to_set": "Taper quatre fois pour régler le temps de delay à l’oreille (passe en ms libres)",
+ "device.delay.tap_tempo": "Tap tempo",
+ "device.delay.the_band_the_repeats_live": "La bande dans laquelle vivent les répétitions — glisser la poignée gauche pour le coupe-bas, la droite pour le coupe-haut. ⌥-clic sur une poignée pour la saisir, double-clic pour l’ouvrir.",
+ "device.delay.the_diffuser_lengthens_the_loop": "Le diffuseur allonge la boucle d’un retard de groupe fixe ; activé, le pointeur de lecture est reculé d’autant pour que chaque répétition tombe sur le temps réglé.",
+ "device.delay.the_repeat_train_l_above": "Le train de répétitions — L au-dessus de l’axe, R en dessous. La hauteur est le niveau restant après chaque passage ; la répétition qui sonne en ce moment est allumée.",
+ "device.delay.wet_only_repeats_with_no": "Wet only — répétitions sans signal sec, pour une piste de retour / d’envoi",
+ "device.dynamic_eq.attack_how_fast_the_band": "Attack — la vitesse à laquelle la bande rejoint sa plage",
+ "device.dynamic_eq.band_on": "Bande active",
+ "device.dynamic_eq.band_on_off_leaves_the": "Bande active — désactivée, elle sort du signal (double-clic sur son nœud pour le même effet)",
+ "device.dynamic_eq.drag_a_node_frequency_and": "Glisser un nœud — fréquence et gain · molette sur un nœud — Q · double-clic sur un nœud — bande active / inactive · ",
+ "device.dynamic_eq.duck_acts_above_the_threshold": "Duck — agit au-dessus du seuil",
+ "device.dynamic_eq.dynamic_off_parks_every_band": "Dynamic — désactivé, chaque bande reste sur son gain statique : pour entendre ce que font les dynamiques",
+ "device.dynamic_eq.flip_cut_boost_a_duck": "Flip — atténuation ↔ renfort (un Duck qui renforce est une expansion ascendante, un Lift qui atténue est une expansion descendante)",
+ "device.dynamic_eq.frequency_or_drag_the_node": "Fréquence — ou glisser le nœud à gauche / droite",
+ "device.dynamic_eq.gain_the_static_gain_or": "Gain — le gain statique ; ou glisser le nœud vers le haut / bas",
+ "device.dynamic_eq.key_self_the_band_listens": "Key — Self : la bande écoute cette piste · Ext : la piste de clé (cliquer à nouveau sur Ext pour choisir la piste)",
+ "device.dynamic_eq.lift_acts_as_it_falls": "Lift — agit quand le signal passe en dessous (un renfort par défaut)",
+ "device.dynamic_eq.lift_acts_below_the_threshold": "Lift — agit sous le seuil",
+ "device.dynamic_eq.output_drag_up_down_shift": "Output — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour 0 dB",
+ "device.dynamic_eq.q_the_width_the_resonance": "Q — la largeur (la résonance sur les coupes) ; ou la molette sur le nœud",
+ "device.dynamic_eq.range_how_far_the_gain": "Range — l’amplitude du gain à plein engagement (6 dB au-delà du seuil) ; cliquer la flèche pour inverser atténuation / renfort",
+ "device.dynamic_eq.release_how_fast_it_returns": "Release — la vitesse de retour à son gain statique",
+ "device.dynamic_eq.solo_hear_this_band_alone": "Solo — entendre cette bande seule",
+ "device.dynamic_eq.static_a_plain_eq_band": "Static — une bande d’EQ simple · Duck — agit quand le niveau de la bande dépasse le seuil (une atténuation par défaut) · ",
+ "device.dynamic_eq.the_selected_bands_dynamic_gain": "Le gain dynamique de la bande sélectionnée en ce moment",
+ "device.dynamic_eq.threshold_where_the_band_starts": "Threshold — le point où la bande commence à agir ; le repère turquoise est le niveau actuel de la bande",
+ "device.dynamic_eq.type_high_pass_low_shelf": "Type — passe-haut, low shelf, bell, notch, high shelf, passe-bas ; seuls les shelves et les bells acceptent gain et dynamique",
+ "device.eq.analyzer_pre_the_input_spectrum": "Analyseur — Pre : le spectre d’entrée · Post : la sortie au-dessus d’une entrée plus discrète · Off",
+ "device.eq.analyzer_range_the_graphs_bottom": "Plage de l’analyseur — le bord inférieur du graphique, en dB sous 0 dBFS",
+ "device.eq.auto_gain_adds_the_opposite": "Auto gain — ajoute l’opposé du niveau moyen des shelves et des bells, pour juger les modifications à volume égal",
+ "device.eq.band_on_off_leaves_the": "Bande active — désactivée, elle sort du signal (double-clic sur son nœud pour le même effet)",
+ "device.eq.channel_st_both_channels_mid": "Channel — St : les deux canaux · Mid : le centre · Side : les bords · L / R : un seul canal",
+ "device.eq.drag_a_node_frequency_and": "Glisser un nœud — fréquence et gain · molette sur un nœud — Q · double-clic sur un nœud — bande active / inactive · ",
+ "device.eq.enter_or_esc_to_close": "Entrée ou Échap pour fermer",
+ "device.eq.frequency_or_drag_the_node": "Fréquence — ou glisser le nœud à gauche / droite",
+ "device.eq.gain_or_drag_the_node": "Gain — ou glisser le nœud vers le haut / bas (Scale le multiplie)",
+ "device.eq.label_a_short_name_shown": "Label — un nom court affiché près du nœud de la bande (jusqu’à 24 caractères)",
+ "device.eq.labels_show_the_bands_labels": "Labels — affiche les étiquettes et repères de note des bandes dans le graphique (les pastilles et le panneau de bande les conservent)",
+ "device.eq.name_this_band": "Nommer cette bande",
+ "device.eq.note_a_longer_note_on": "Note — une note plus longue sur le rôle de cette bande",
+ "device.eq.output_plus_the_auto_gain": "Output (plus l’auto gain en vigueur) — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour 0 dB",
+ "device.eq.output_the_level_after_the": "Output — le niveau après l’EQ, ±12 dB",
+ "device.eq.peak_hold_a_thin_line": "Peak hold — une ligne fine au niveau le plus haut de chaque fréquence ces derniers instants",
+ "device.eq.q_the_width_the_resonance": "Q — la largeur (la résonance sur les coupes) ; ou la molette sur le nœud",
+ "device.eq.scale_multiplies_every_shelf_and": "Scale — multiplie le gain de chaque shelf et bell : 100 % tel que réglé, 0 % à plat, 200 % le double",
+ "device.eq.slope_how_steep_the_high": "Slope — la raideur du passe-haut / passe-bas : 12, 24 ou 48 dB par octave",
+ "device.eq.type_high_pass_low_shelf": "Type — passe-haut, low shelf, bell, notch, high shelf, passe-bas ; seuls les shelves et les bells acceptent un gain",
+ "device.eq.what_this_band_is_for": "À quoi sert cette bande",
+ "device.eq3.crossover_slope_linkwitz_riley_24": "Crossover slope — Linkwitz-Riley 24 ou 48 dB/oct : plus raide, moins d’effet sur les bandes voisines",
+ "device.eq3.drag_up_down_for_the": "Glisser vers le haut / bas pour le gain de la bande (Maj pour les pas fins) ; ⌥-clic pour le saisir ; double-clic pour revenir à 0 dB et lever le kill",
+ "device.eq3.each_band_in_its_colour": "Chaque bande dans sa couleur, la somme en laiton, le spectre de sortie derrière. Glisser une poignée de crossover à gauche / droite ; glisser ailleurs pour régler le gain de cette bande. Double-clic pour réinitialiser, ⌥-clic pour saisir.",
+ "device.eq3.kill_the_band_removes_it": "Kill de la bande {0} — la supprime d’un coup, avec un glissement de 5 ms",
+ "device.eq3.low_mid_crossover": "Crossover grave / médium",
+ "device.eq3.mid_high_crossover": "Crossover médium / aigu",
+ "device.eq3.output_gain_24_db_drag": "Gain de sortie, ±24 dB — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour réinitialiser",
+ "device.eq8.band_on": "Bande active",
+ "device.flanger.delay_the_centre_of_the": "Delay — le centre du balayage, 0,1 … 8 ms : plus court, les encoches montent",
+ "device.flanger.depth_at_zero_the_comb": "Depth à zéro : le peigne reste immobile, un effet statique",
+ "device.flanger.depth_how_far_the_lfo": "Depth — l’amplitude du LFO sur le retard autour de son centre",
+ "device.flanger.feedback_0_a_plain_comb": "Feedback 0 : un simple peigne",
+ "device.flanger.feedback_70_hollow": "Feedback −70 % : creux",
+ "device.flanger.feedback_70_the_classic_jet": "Feedback +70 % : le jet classique",
+ "device.flanger.feedback_the_delayed_signal_fed": "Feedback — le signal retardé réinjecté, ±95 % : positif pour le jet classique, négatif pour un timbre creux",
+ "device.flanger.flanger_bypassed_the_signal_passes": "Flanger contourné : le signal passe inchangé",
+ "device.flanger.how_deep_the_notches_cut": "Profondeur des encoches, dB (0 … −36 sur la barre)",
+ "device.flanger.mix_50_gives_the_deepest": "Mix — 50 % donne les encoches les plus profondes ; 100 % est le signal retardé seul, un vibrato",
+ "device.flanger.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 2/1 … 1/16 avec valeurs pointées (D) et en triolets (T)",
+ "device.flanger.stereo_the_right_lfo_against": "Stereo — le LFO droit par rapport au gauche : 0° balaie les deux ensemble, 90° les écarte, 180° les fait évoluer en opposition",
+ "device.flanger.the_comb_the_delay_carves": "Le peigne que le delay creuse dans le spectre, L neutre et R turquoise, avec la première encoche en pointillés. Glisser à gauche / droite pour déplacer l’encoche (Delay), vers le haut / bas pour Feedback ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
+ "device.flanger.the_delay_of_both_channels": "Le retard τ des deux canaux sur deux cycles du LFO, et la position actuelle de chacun",
+ "device.flanger.the_first_notch_now_over": "La première encoche actuelle, sur la plage où le balayage la déplace (20 Hz … 20 kHz)",
+ "device.flanger.the_lfo_shape_that_sweeps": "La forme du LFO qui balaie le delay : Sine glisse, Tri balaie régulièrement, Saw monte puis retombe",
+ "device.flanger.what_the_feedback_makes_positive": "Effet du feedback : positif, il affine les pics ; négatif, il creuse le timbre ; au-delà de 85 %, le peigne accroche",
+ "device.flux.assign_a_source_to_turn": "→ assigner une source pour activer la réaction",
+ "device.flux.choose_the_track_flux_listens": "Choisir la piste écoutée par Flux — ou l’un de ses pads, chaînes ou voix",
+ "device.flux.click_to_change_the_motion": "Cliquer pour changer la valeur de synchro de Motion",
+ "device.flux.cutoff_of_range": "coupure +{0} de la plage",
+ "device.flux.dashed_where_the_reaction_pulls": "pointillés — où tire la réaction",
+ "device.flux.drag_to_blend_the_four": "Glisser pour mélanger les quatre timbres · ⌥-clic pour saisir · double-clic pour réinitialiser",
+ "device.flux.one_knob_each": "un potentiomètre chacun",
+ "device.flux.target_what_the_reaction_drives": "Target — ce que pilote la réaction",
+ "device.flux.the_sidechain_bends_the_pitch": "→ le sidechain fait monter la hauteur",
+ "device.flux.the_sidechain_drags_the_vector": "→ le sidechain entraîne le vecteur en rythme",
+ "device.flux.the_sidechain_opens_the_filter": "→ le sidechain ouvre le filtre",
+ "device.flux.the_sidechain_swells_the_space": "→ le sidechain gonfle l’espace",
+ "device.flux.the_synth_listens_to_a": "le synthé écoute une piste",
+ "device.flux.transients_per_bar": { "one": "{0} transitoire par mesure", "other": "{0} transitoires par mesure" },
+ "device.flux_react.no_source_assigned": "aucune source assignée",
+ "device.forge.amount_0_30_db_into": "Amount — 0 … +30 dB dans les étages. Glisser la courbe vers le haut / bas pour la même chose",
+ "device.forge.bias_the_stages_asymmetry_100": "Bias — l’asymétrie de l’étage, −100 … +100 % : décale la courbe du centre et ajoute des harmoniques paires",
+ "device.forge.digital_fold_without_oversampling_alias": "Digital / Fold sans suréchantillonnage produisent de l’aliasing : activer 2× ou plus",
+ "device.forge.env_tone": "env → tone {0}",
+ "device.forge.env_tone_loud_parts_push": "Env → Tone — les passages forts rendent le timbre plus brillant",
+ "device.forge.harmonics_2_9_of_a": "Harmoniques 2 … 9 d’une sinusoïde à −6 dB passée dans la courbe : impaires en plein (dures, bourdonnantes), paires plus discrètes (chaudes, rondes), et la distorsion harmonique totale",
+ "device.forge.input_output_through_the_device": "Entrée → sortie à travers l’appareil (en M/S et Multi, à travers l’étage sélectionné) : chaque étage seul en pâle, la courbe modulée par le LFO en turquoise pointillé, le nœud là où se situe l’entrée. Glisser vers le haut / bas pour Amount ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.forge.lfo_drive_the_lfo_sweeps": "LFO → Drive — le LFO balaie le drive de chaque étage, jusqu’à ±30 %",
+ "device.forge.lfo_rate_free_0_05": "LFO rate — libre 0,05 … 20 Hz, ou avec Sync une division de 2 mesures à 1/64",
+ "device.forge.of_3_stages": "{0} étages sur 3",
+ "device.forge.output_24_24_db": "Sortie, −24 … +24 dB",
+ "device.forge.oversampling_runs_the_stages_at": "Oversampling — fait tourner les étages à 2 / 4 / 8 × la fréquence pour que les harmoniques au-delà de Nyquist ne se replient pas (phase minimale, sans latence)",
+ "device.forge.routing_serial_1_2_3": "Routing — Serial : 1 → 2 → 3. Parallel : les trois depuis la même entrée, moyennés. M/S : l’étage 1 traite le Mid, l’étage 2 le Side, l’étage 3 le stéréo recombiné. Multi : l’étage 1 les graves (< 180 Hz), le 2 les médiums, le 3 les aigus (> 2,4 kHz)",
+ "device.forge.stage": "étage {0} · {1}",
+ "device.forge.stage_drive_how_hard_the": "Drive de l’étage {0} — la force avec laquelle l’étage est poussé (gain 1 … ×21, niveau compensé)",
+ "device.forge.stage_feedback_its_output_back": "Feedback de l’étage {0} — sa sortie réinjectée dans son entrée (0 … 85 %) : plus épais, et à la limite de l’accrochage avec Fold / Fuzz",
+ "device.forge.stage_on_off": "Étage {0} activé / désactivé",
+ "device.forge.stage_output_12_12_db": "Sortie de l’étage {0}, −12 … +12 dB — glisser vers le haut / bas, ⌥-clic pour saisir, double-clic pour réinitialiser",
+ "device.forge.sync_the_lfo_rate_as": "Sync — la vitesse du LFO en valeur de note calée sur le morceau, ou libre en Hz",
+ "device.forge.the_selected_stages_type_tube": "Le type de l’étage sélectionné — Tube : doux, asymétrique, chaud ; Tape : doux et régulier ; Diode : dur d’un côté ; Fuzz : carré, dense ; Fold : replie les crêtes, brillant et métallique ; Digital : un écrêtage dur",
+ "device.forge.tone_a_tilt_after_the": "Tone — une inclinaison après l’étage, −12 … +12 dB autour de 800 Hz : distorsion plus sombre ou plus brillante",
+ "device.forge.wet_the_forged_signal_against": "Wet — le signal forgé face au signal sec",
+ "device.forge.what_the_device_is_doing": "Ce que fait l’appareil ; les décalages généraux Tone / Bias / Width des anciens projets s’affichent ici lorsqu’ils sont réglés",
+ "device.forge.width_the_stages_stereo_image": "Width — l’image stéréo de l’étage, 0 … 200 % (en M/S, la largeur de l’étage 2 met à l’échelle le side)",
+ "device.generic.open_gui": "Ouvrir l’interface ↗",
+ "device.grain.blend_the_sample_itself_dry": "Mélange l’échantillon lui-même (sec) avec le nuage de grains (traité)",
+ "device.grain.drag_to_move_the_read": "Glisser pour déplacer la position de lecture · ⌥-clic pour la saisir · double-clic pour la réinitialiser",
+ "device.grain.position_pitch_pan": "{0} · position · hauteur · panoramique",
+ "device.grain.root_a_semitone_down": "Fondamentale un demi-ton plus bas",
+ "device.grain.root_a_semitone_up": "Fondamentale un demi-ton plus haut",
+ "device.grain.root_plays_the_sample_as": "La fondamentale {0} joue l’échantillon tel qu’enregistré · coarse 0 · fine 0",
+ "device.grain.scan_moves_through_the_file": "Scan parcourt le fichier · Freeze maintient Position · Key la déplace avec la note",
+ "device.grain.the_root_the_key_that": "La fondamentale — la touche qui joue l’échantillon tel qu’enregistré. Défiler pour la changer · double-clic la prend dans le nom du fichier (C4 à défaut)",
+ "device.grain.voices_grains_caps": "{0} {1}{2} · {3} voix · {4} grains",
+ "device.keys.2_lines_bbd": "2 lignes · BBD",
+ "device.keys.held_by_the_pedal": "{0} tenues par la pédale",
+ "device.keys.ringing_out": "{0} en fin de résonance",
+ "device.keys.string_2_pickups": "Corde · 2 micros",
+ "device.keys.sustain_pedal_click_to_hold": "Pédale de sustain — cliquer pour la maintenir enfoncée ; le CC64 d’un clavier fonctionne aussi",
+ "device.keys.voices": "{0} / {1} voix",
+ "device.keys.voices_n": "{0} · {1} voix",
+ "device.length.1_bar_at_bpm_notes": "1 mesure à {0:0} BPM · {1} notes",
+ "device.length.clip_length_limit": "Limite de durée du clip",
+ "device.length.count_the_length_from_the": "Compter la durée depuis le note-on ou le note-off — cliquer pour basculer",
+ "device.length.count_the_length_from_the_2": "Compter la durée depuis le note-on, ou depuis le note-off (la note part au relâchement de la touche)",
+ "device.length.drag_up_down_double_click": "{0} — glisser vers le haut / bas, double-clic pour réinitialiser",
+ "device.length.each_note_lasts_until_the": "Chaque note dure jusqu’au début de la suivante (au plus jusqu’à la barre de mesure)",
+ "device.length.from_avg_out": "{0} {1} · depuis {2} · sortie moy. {3}",
+ "device.length.legato_retrigger_held": "Legato · redéclenchement des notes tenues",
+ "device.length.length_drag_up_down_double": "Length — glisser vers le haut / bas, double-clic pour réinitialiser",
+ "device.length.length_mode_sync_ms_gate": "Mode de durée : Sync / ms / Gate % — cliquer pour le suivant, Maj-clic pour le précédent",
+ "device.length.loud_notes_longer_at": "notes fortes plus longues à +",
+ "device.length.low_notes_longer_at": "notes graves plus longues à +",
+ "device.length.no_note_crosses_the_bar": "Aucune note ne franchit la barre de mesure où elle a commencé",
+ "device.length.outline_in_fill_out_band": "Contour — entrée · aplat — sortie · bande — plage de Random",
+ "device.length.outline_the_note_played_in": "Contour — la note jouée en entrée · aplat — la note en sortie · bande — la plage sur laquelle Random la répartit. La partie ombrée dépasse la barre de mesure.",
+ "device.length.spread_per_note": "dispersion par note",
+ "device.length.sync_a_tempo_division_ms": "Sync : une division du tempo · ms : un temps fixe · Gate % : une part de la durée de tenue de chaque note",
+ "device.lens.arm_the_next_single_capture": "Armer la prochaine capture Single",
+ "device.lens.crest_db_lufs": "crête {0:0.0} dB · LUFS {1:0.0}",
+ "device.lens.db_bin": "{0:0.0} dB · bin {1:0}",
+ "device.lens.export_the_lens_capture_to": "Exporter la capture de Lens en WAV",
+ "device.lens.export_wav": "Exporter en WAV",
+ "device.lens.freeze_stop_capturing_and_hold": "Freeze — arrête la capture et conserve ce qui est à l’écran",
+ "device.lens.key_draw_another_tracks_audio": "Key — superposer en turquoise l’audio d’une autre piste à celui-ci",
+ "device.lens.key_gain_scales_only_the": "Key gain — ne met à l’échelle que la trace de la clé, pour l’œil (le son n’est pas modifié)",
+ "device.lens.level_holdoff_ms": "niveau {0:0.00} · holdoff {1:0} ms",
+ "device.lens.mid_side": "Mid / Side",
+ "device.lens.move_over_the_graph": "survoler le graphique",
+ "device.lens.n_a_in_a_rack": "indisponible dans un rack",
+ "device.lens.open_lens_in_its_own": "Ouvrir Lens dans sa propre fenêtre",
+ "device.lens.peak_db": "crête {0} · {1:0.0} dB",
+ "device.lens.period_ms_hz": "période {0:0.000} ms · {1:0.0} Hz",
+ "device.lens.row_ms_bins": "ligne {0:0} ms · {1} bins",
+ "device.lens.show_the_keys_trace": "Afficher la trace de la clé",
+ "device.lens.snap_to_peaks": "Caler sur les crêtes",
+ "device.lens.span_how_much_of_the": "Span — la portion du morceau affichée par l’oscilloscope, d’un quart de temps à quatre mesures",
+ "device.lens.sync_line_the_scope_up": "Sync — aligne l’oscilloscope sur les temps et les mesures du morceau",
+ "device.lens.vpp_rms": "Vpp {0:0.000} · RMS {1:0.000}",
+ "device.lens.waterfall_bins_overlap_window_s": "Waterfall · {0} bins · {1} · overlap {2:0.#} % · fenêtre {3:0} s · plancher {4:0} dB",
+ "device.lens.window_ms_slope_db_oct": "fenêtre {0:0} ms · pente {1:0.0} dB/oct",
+ "device.lens.write_the_captured_scope_window": "Écrire la fenêtre d’oscilloscope capturée dans un fichier WAV",
+ "device.midi.card_size_s_mini_l": "Taille de la carte : S (mini) / L (complète)",
+ "device.midi.map_a_hardware_control_arm": "Assigner une commande matérielle : armer, toucher une commande sur la carte, bouger un potentiomètre ou une touche",
+ "device.monolith.controllers_osc_bank": "Controllers · Osc Bank",
+ "device.mosaic.a_folder_of_samples": "un dossier d’échantillons",
+ "device.mosaic.a_new_empty_layer_move": "Une nouvelle couche vide — y déplacer des zones depuis le rail",
+ "device.mosaic.blends_the_loops_end_into": "Fond la fin de la boucle dans son début (boucles avant)",
+ "device.mosaic.busy_on_pedal_release": "{0} occupées · {1} sur pédale · {2} en relâchement",
+ "device.mosaic.click_a_key_to_make": "Cliquer une touche pour en faire la fondamentale de la zone sélectionnée",
+ "device.mosaic.detect_from_file_name": "Détecter d’après le nom du fichier",
+ "device.mosaic.drag_left_right_for_the": "Glisser : gauche / droite pour la coupure, haut / bas pour la résonance · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
+ "device.mosaic.drag_the_nodes_attack_decay": "Glisser les nœuds : attaque, déclin et maintien (haut / bas), relâchement · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
+ "device.mosaic.drop_samples_or_a_folder": "Déposer des échantillons ou un dossier ici · ou choisir un préréglage",
+ "device.mosaic.edit_this_zones_start_end": "Modifier le début, la fin et la boucle de cette zone",
+ "device.mosaic.empty": "Vide",
+ "device.mosaic.empty_drop_samples_or_a": "Vide · déposer des échantillons ou un dossier, ou choisir un préréglage",
+ "device.mosaic.exclusive_group_off_by": "Exclusive · groupe / coupé par",
+ "device.mosaic.exclusive_is_for_hi_hats": "Exclusive sert aux charleys et aux valves : une nouvelle note coupe le groupe off_by.",
+ "device.mosaic.files": "{0} / {1} · {2} / {3} fichiers",
+ "device.mosaic.files_n": { "one": "{0} fichier", "other": "{0} fichiers" },
+ "device.mosaic.filter_off_the_samples_pass": "Filtre désactivé — les échantillons passent intacts",
+ "device.mosaic.fine_tune_of_the_whole": "Accord fin de tout l’instrument, ±50 cents",
+ "device.mosaic.found_by_name": "{0} · {1} trouvés par le nom : {2}",
+ "device.mosaic.group": "Groupe · {0}",
+ "device.mosaic.groups": "{0} groupes · {1} · {2}",
+ "device.mosaic.how_far_the_key_moves": "L’influence de la touche sur la hauteur — 100 % chromatique, 0 % toutes les touches jouent la fondamentale",
+ "device.mosaic.how_fast_a_stolen_or": "La vitesse d’extinction d’une voix volée ou remplacée",
+ "device.mosaic.how_many_strikes_of_one": "Le nombre de frappes d’une même touche qui peuvent sonner ensemble",
+ "device.mosaic.how_much_quieter_a_release": "De combien l’échantillon de relâchement baisse quand la touche est tenue longtemps — glisser vers le haut / bas, ⌥-clic pour saisir",
+ "device.mosaic.how_much_velocity_sets_the": "Dans quelle mesure la vélocité règle le niveau",
+ "device.mosaic.install_pack": "Installer le pack",
+ "device.mosaic.instruments": { "one": "{0} instrument", "other": "{0} instruments" },
+ "device.mosaic.layers": { "one": "{0} couche", "other": "{0} couches" },
+ "device.mosaic.let_the_amp_envelope_open": "Laisser l’enveloppe d’ampli ouvrir (ou fermer) le filtre",
+ "device.mosaic.loading": "Chargement {0}",
+ "device.mosaic.loading_n": "Chargement {0} %",
+ "device.mosaic.loading_notes_muted": "Chargement · {0} / {1} · notes coupées",
+ "device.mosaic.locate_folder": "Localiser le dossier…",
+ "device.mosaic.locate_the_samples": "Localiser les échantillons",
+ "device.mosaic.make_the_note_in_the": "Prendre la note du nom de fichier de la zone comme fondamentale",
+ "device.mosaic.missing": " · {0} manquant(s)",
+ "device.mosaic.move_start_and_end_to": "Placer Start et End là où le son commence et s’éteint (−48 dB)",
+ "device.mosaic.move_start_end_and_the": "Placer Start, End et la boucle au passage par zéro le plus proche",
+ "device.mosaic.mpe_pressure_aftertouch_level": "Pression MPE (aftertouch) → niveau",
+ "device.mosaic.mpe_slide_cc74_cutoff": "Glissement MPE (CC74) → coupure",
+ "device.mosaic.none_of_its_samples_were": "Aucun de ses {0} échantillons n’a été trouvé. Les réglages de zones sont conservés — indiquer à Mosaic le dossier qui les contient.",
+ "device.mosaic.notes_are_silent_until_loading": "Les notes restent muettes jusqu’à la fin du chargement",
+ "device.mosaic.off_plays_once_fwd_loops": "Off joue une fois · Fwd boucle · Ping fait des allers-retours — cette zone uniquement",
+ "device.mosaic.old_voice_fade": "Old voice fade",
+ "device.mosaic.open_in_sample": "Ouvrir dans Sample",
+ "device.mosaic.opens_the_mapping_preview_a": "Ouvre l’aperçu de l’assignation. Un fichier seul remplace l’échantillon, comme avant.",
+ "device.mosaic.pack_is_not_installed": "Le pack « {0} » n’est pas installé",
+ "device.mosaic.pick_the_folder_that_holds": "Choisir le dossier qui contient les échantillons — Mosaic y retrouve chaque fichier par son chemin ou son nom",
+ "device.mosaic.poly_chords_click_again_for": "Poly : accords (cliquer à nouveau pour les réglages de voix) · Mono : une à la fois, legato avec Glide · Choke : une nouvelle note coupe celles qui sonnent",
+ "device.mosaic.release_to_build_a_multisample": "Relâcher pour créer un multi-échantillon",
+ "device.mosaic.release_to_load_the_sample": "Relâcher pour charger l’échantillon",
+ "device.mosaic.round_robin_steps_the_groups": "Étapes de round-robin : les zones du groupe jouent à tour de rôle de 1 à N (l’étape de chaque zone est définie par son fichier)",
+ "device.mosaic.sample_not_loaded": "Échantillon non chargé",
+ "device.mosaic.samples_are_not_copied_into": "Les échantillons ne sont pas copiés dans le projet ; le programme retient où ils se trouvent.",
+ "device.mosaic.samples_unavailable_notes_muted": "Échantillons indisponibles · notes coupées",
+ "device.mosaic.select_a_zone": "Sélectionner une zone",
+ "device.mosaic.settings_downloads_sample_packs": "Réglages → Téléchargements → Packs d’échantillons",
+ "device.mosaic.shift_every_note_24_semitones": "Décaler toutes les notes, ±24 demi-tons",
+ "device.mosaic.slide_from_the_last_note": "Glisser depuis la dernière note — en Mono, legato",
+ "device.mosaic.snap_to_zero": "Caler sur le zéro",
+ "device.mosaic.stop_loading_the_instrument_empties": "Arrêter le chargement — l’instrument se vide (annuler le rétablit)",
+ "device.mosaic.the_articulation_the_sfzs_controller": "L’articulation — la valeur de contrôleur du SFZ selon laquelle ses zones ont été choisies",
+ "device.mosaic.the_cutoff_follows_the_key": "La coupure suit la touche",
+ "device.mosaic.the_level_after_everything": "Le niveau après tout le reste",
+ "device.mosaic.the_pitch_wheels_range_mpe": "La plage de la molette de hauteur (les bends MPE sont par note)",
+ "device.mosaic.the_release_samples_level": "Le niveau des échantillons de relâchement",
+ "device.mosaic.the_samples_arent_where_the": "Les échantillons ne sont pas là où le programme l’indique",
+ "device.mosaic.the_sustain_pedal_a_keyboards": "La pédale de sustain : le CC64 d’un clavier maintient les touches relâchées — cliquer pour ne plus l’écouter",
+ "device.mosaic.the_zones_fine_tune_100": "L’accord fin de la zone, ±100 cents",
+ "device.mosaic.the_zones_fine_tune_drag": "L’accord fin de la zone — glisser, molette, double-clic pour réinitialiser",
+ "device.mosaic.the_zones_level": "Le niveau de la zone",
+ "device.mosaic.the_zones_pan": "Le panoramique de la zone",
+ "device.mosaic.the_zones_root_drag_or": "La fondamentale de la zone — glisser ou défiler",
+ "device.mosaic.this_groups_exclusive_number": "Le numéro exclusif de ce groupe",
+ "device.mosaic.this_preset_uses_samples_from": "Ce préréglage utilise {0} échantillons du pack. Les réglages de zones sont conservés, mais aucun son tant que le pack n’est pas installé.",
+ "device.mosaic.this_zones_level": "Le niveau de cette zone",
+ "device.mosaic.total_in_ram": "Total en RAM",
+ "device.mosaic.trim_silence": "Rogner le silence",
+ "device.mosaic.velocity_level_curve": "Courbe vélocité → niveau",
+ "device.mosaic.velocity_level_drag_up_for": "Vélocité → niveau : glisser vers le haut pour doux (notes faibles plus fortes), vers le bas pour dur ; ⌥-clic pour saisir",
+ "device.mosaic.voice_stealing_order": "Vol de voix · ordre",
+ "device.mosaic.voices_of_this_group_stop": "Les voix de ce groupe s’arrêtent quand une note de ce groupe exclusif démarre",
+ "device.mosaic.zones": { "one": "{0} zone", "other": "{0} zones" },
+ "device.mosaic.zones_can_already_be_selected": "Les zones peuvent déjà être sélectionnées et modifiées",
+ "device.mosaic.zones_n": "{0} · {1} zones",
+ "device.operator.11_topologies_feedback_on_a": "11 topologies · feedback sur A",
+ "device.operator.vel_fm_off": "Vél. → FM off",
+ "device.operator_algo.drag_an_operator_onto_another": "glisser un opérateur sur un autre pour le reconnecter",
+ "device.pendulum.bar_quantize": "mesure · quantification {0}",
+ "device.pendulum.detune_of_the_chorus_partner": "Désaccord du partenaire de chorus dans chaque voix",
+ "device.pendulum.fan_the_notes_across_the": "Répartir les notes dans le champ stéréo selon la position de la balle",
+ "device.pendulum.free_seconds_per_swing_at": "Free : secondes par oscillation à +100 %",
+ "device.pendulum.hold_a_chord": "tenir un accord",
+ "device.pendulum.how_far_the_balls_rates": "L’écart croissant entre les vitesses des balles — chaque balle un peu plus rapide que la précédente",
+ "device.pendulum.how_long_one_swing_low": "La durée d’une oscillation (bas → haut → bas) à +100 %",
+ "device.pendulum.humanize_on_off_the_amount": "Humanize activé / désactivé — la quantité est réglée par le curseur HUMAN",
+ "device.pendulum.last_note": "dernière note {0} · {1}",
+ "device.pendulum.latch_the_chord_it_keeps": "Latch de l’accord — il continue d’osciller après le relâchement ; l’accord suivant le remplace",
+ "device.pendulum.level_and_pitch_jitter_per": "Variation aléatoire du niveau et de la hauteur par note",
+ "device.pendulum.one_ball_fewer_2_at": "Une balle de moins (2 au minimum)",
+ "device.pendulum.one_ball_more_6_at": "Une balle de plus (6 au maximum)",
+ "device.pendulum.one_lane_per_ball_x": "Une voie par balle : x est la hauteur, du grave à l’aigu. Franchir un degré d’accord joue cette note ; le turquoise montre le mur devant",
+ "device.pendulum.quantize_a_crossing_waits_for": "Quantize : un franchissement attend la prochaine double-croche ou croche avant de jouer",
+ "device.pendulum.reset_spread_humanize_and_scale": "Réinitialiser spread, humanize et scale à leurs valeurs par défaut",
+ "device.pendulum.restart_every_ball_from_its": "Relancer chaque balle depuis son départ quand un nouvel accord commence",
+ "device.pendulum.restart_every_balls_swing_now": "Relancer maintenant l’oscillation de chaque balle",
+ "device.pendulum.snap_the_generated_notes_to": "Caler les notes générées sur une gamme",
+ "device.pendulum.swing_speed_centre_stops_the": "Vitesse d’oscillation — le centre arrête les balles, à gauche du centre elles repartent en sens inverse",
+ "device.pendulum.sync_a_swing_takes_a": "Sync : une oscillation dure une valeur de note du tempo · Free : elle dure un temps en secondes",
+ "device.pendulum.the_bar_generated_notes_land": "La mesure : les notes générées tombent sur la grille de doubles-croches — cette mesure en neutre avec la note qui vient de jouer en accent, la mesure précédente plus pâle devant la tête de lecture",
+ "device.pendulum.the_swing_curve_pendulum_slows": "La courbe d’oscillation — Pendulum ralentit aux murs, Linear garde une vitesse constante, Bounce se stabilise avec une ondulation",
+ "device.pendulum.the_voice_soft_keys_bright": "La voix : Keys doux, Glass brillant, Saw, Square creux ou Bell inharmonique",
+ "device.pendulum.up_the_low_wall_plays": "Haut : le mur bas joue la note la plus basse de l’accord · Bas : la plus haute",
+ "device.pendulum.voices": { "one": "{0} voix", "other": "{0} voix" },
+ "device.pentad.khz_os_cpu": "{0:0.#} kHz · ×{1} OS · CPU {2:0} %",
+ "device.pentad.per_voice_active_routes": { "one": "par voix · {0} route active", "other": "par voix · {0} routes actives" },
+ "device.pentad.poly_mod_source_destination_caps": "Poly mod — source → destination",
+ "device.pentad.re_roll_the_vintage_seed": "Retirer la graine vintage (nouvelle dispersion par voix)",
+ "device.pentad.restore_lows_at_high_q": "Restaurer les graves à Q élevé",
+ "device.pentad.shape_pulse_width_caps": "Shape · pulse width",
+ "device.pentad.voice_setup_polyphony_allocation_glide": "Configuration des voix : polyphonie, allocation, mode de glide, suréchantillonnage, graine vintage",
+ "device.pentad.wheel_mod_destinations_caps": "Wheel mod — destinations",
+ "device.phaser.all_pass_stages_every_two": "Étages passe-tout : tous les deux creusent une encoche — 2 donne un léger tourbillon, 12 un balayage profond et dense",
+ "device.phaser.center_the_middle_of_the": "Center — le milieu du balayage, 50 Hz … 5 kHz : plus haut, les encoches montent",
+ "device.phaser.depth_at_zero_the_notches": "Depth à zéro : les encoches restent immobiles",
+ "device.phaser.depth_how_far_the_lfo": "Depth — l’amplitude du LFO sur les étages autour de Center, jusqu’à ±3 octaves",
+ "device.phaser.feedback_the_chains_output_fed": "Feedback — la sortie de la chaîne réinjectée, ±95 % : positif, il affine les pics ; négatif, il déplace et élargit les encoches",
+ "device.phaser.how_deep_the_notches_cut": "Profondeur des encoches, dB (0 … −36 sur la barre)",
+ "device.phaser.mix_50_gives_the_deepest": "Mix — 50 % donne les encoches les plus profondes ; 100 % est le signal déphasé seul",
+ "device.phaser.phaser_bypassed_the_signal_passes": "Phaser contourné : le signal passe inchangé",
+ "device.phaser.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/16 avec valeurs pointées (D) et en triolets (T)",
+ "device.phaser.stereo_the_right_lfo_against": "Stereo — le LFO droit par rapport au gauche : 0° balaie les deux ensemble, 90° les écarte, 180° les fait évoluer en opposition",
+ "device.phaser.the_corner_frequency_of_both": "La fréquence de coin des deux canaux sur deux cycles du LFO (20 Hz … 20 kHz), et la position actuelle de chacune",
+ "device.phaser.the_lfo_shape_that_sweeps": "La forme du LFO qui balaie les étages : Sine glisse, Tri balaie régulièrement, Saw monte puis retombe",
+ "device.phaser.the_notches_the_stages_cut": "Les encoches que les étages creusent dans le spectre, L neutre et R turquoise, avec le coin en pointillés et chaque encoche repérée en haut. Glisser à gauche / droite pour déplacer Center, vers le haut / bas pour Feedback ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
+ "device.phaser.the_range_the_corner_sweeps": "La plage balayée par le coin (20 Hz … 20 kHz sur la barre), et la première encoche actuelle",
+ "device.phaser.what_the_feedback_makes_positive": "Effet du feedback : positif, il affine les pics ; négatif, il déplace et élargit les encoches ; au-delà de 85 %, le phaser siffle",
+ "device.physical.1_2_resonator_1_rings": "1→2 : le résonateur 1 excite le résonateur 2 · 1+2 : les deux sont frappés, mélangés",
+ "device.physical.env_freq_off": "env → freq off",
+ "device.physical.how_hard_a_released_key": "La force avec laquelle une touche relâchée étouffe le corps — à 0 il continue de sonner, au maximum il s’arrête aussitôt",
+ "device.physical.partials_as_the_engine_tunes": "Partiels tels que le moteur les accorde — glisser ↔ pour étaler la série (Ratio), ↕ pour incliner les aigus (Bright)",
+ "device.physical.poly_8_voices_ring_over": "Poly : 8 voix qui se chevauchent · Mono : une nouvelle frappe coupe la note qui sonne",
+ "device.physical.res_1_against_res_2": "Res 1 face à Res 2 — les deux à plein niveau au milieu ; en 1→2, le son propre de res 1 face au corps qu’il fait résonner",
+ "device.physical.resonator_2_on_off_resonator": "Résonateur 2 activé / désactivé — le résonateur 1 sonne toujours",
+ "device.physical.stiffness_sets_the_contact_time": "Stiffness règle le temps de contact : doux = long et sombre, dur = court et brillant",
+ "device.physical.which_resonator_the_controls_below": "Le résonateur que modifient les commandes ci-dessous",
+ "device.plugin.close_editor": "Fermer l’éditeur",
+ "device.plugin.close_the_plug_ins_own": "Fermer la fenêtre propre au plug-in",
+ "device.plugin.couldnt_open_the_window": "Impossible d’ouvrir la fenêtre {0}.",
+ "device.plugin.couldnt_open_the_window_n": "Impossible d’ouvrir la fenêtre {0} : {1}",
+ "device.plugin.no_parameter_matches": "Aucun paramètre correspondant",
+ "device.plugin.open_editor": "Ouvrir l’éditeur",
+ "device.plugin.open_the_plug_ins_own": "Ouvrir la fenêtre propre au plug-in",
+ "device.plugin.save_the_plug_ins_state": "Enregistrer l’état du plug-in comme préréglage",
+ "device.plugin.this_plug_in_exposes_no": "Ce plug-in n’expose aucun paramètre",
+ "device.prism.above_compress_caps": "Au-dessus — compresser",
+ "device.prism.above_compression_caps": "Au-dessus — compression",
+ "device.prism.amount_scales_every_bands_compression": "Amount — met à l’échelle la compression et l’expansion de chaque bande (0 % = aucune). Double-clic : 100 %",
+ "device.prism.auto_makeup_each_band_gets": "Auto makeup — chaque bande récupère environ la moitié de sa compression à 0 dBFS",
+ "device.prism.auto_release_short_peaks_recover": "Auto release — les pics brefs se relâchent vite, une compression soutenue se relâche lentement",
+ "device.prism.band_gain_24_db_drag": "Gain de bande ±24 dB — glisser vers le haut / bas, double-clic pour réinitialiser",
+ "device.prism.bands_3_low_mid_high": "Bandes — 3 : Low / Mid / High · 2 : Low + Mid (Mid va jusqu’à 20 kHz) · 1 : Mid, pleine bande",
+ "device.prism.below_expand_caps": "Au-dessous — expanser",
+ "device.prism.below_expansion": "Au-dessous — expansion",
+ "device.prism.below_expansion_caps": "Au-dessous — expansion",
+ "device.prism.below_upward_compression": "Au-dessous — compression ascendante",
+ "device.prism.compression_threshold_ratio_set_the": "Seuil de compression · ratio (régler le ratio dans Band detail)",
+ "device.prism.crossovers": "crossovers {0} / {1}",
+ "device.prism.detector_peak_follows_every_transient": "Detector — Peak suit chaque transitoire ; RMS (10 ms) suit le volume, plus lisse",
+ "device.prism.drag_a_dot_threshold_ratio": "Glisser un point : ← → seuil, ↑ ↓ ratio (vers le bas = plus). Le point brillant est la compression au-dessus, le gris l’expansion en dessous. Double-clic sur un point pour le réinitialiser. · ⌥-clic pour saisir",
+ "device.prism.expansion_upward_compression_threshold_ratio": "Seuil d’expansion / compression ascendante · ratio — cliquer sur l’affichage pour l’activer ou le désactiver",
+ "device.prism.input_spectrum_fill_and_output": "Spectre d’entrée (aplat) et de sortie (ligne). Glisser une ligne de crossover pour la déplacer ; ⌥-clic pour saisir, double-clic pour réinitialiser. Cliquer une bande pour la sélectionner.",
+ "device.prism.khz_cpu": "{0:0.#} kHz · {1}{2} · CPU {3:0} %",
+ "device.prism.listen_hear_the_detectors_key": "Listen — écouter le signal de clé du détecteur (le sidechain, ou l’entrée), par bande en solo",
+ "device.prism.listening_to_the_detector_key": "À l’écoute de la clé du détecteur",
+ "device.prism.low_mid_crossover": "Crossover grave / médium",
+ "device.prism.mid_high_crossover": "Crossover médium / aigu",
+ "device.prism.n_a_in_a_rack": "indisponible dans un rack",
+ "device.prism.none_own_input": "Aucun — entrée propre",
+ "device.prism.output_gain_24_db_double": "Gain de sortie ±24 dB — double-clic : 0 dB",
+ "device.prism.ratio_above_1_1_expands": "Un ratio au-dessus de 1 : 1 expanse (les passages faibles deviennent plus faibles) ; en dessous de 1 : 1 (↑) il comprime vers le haut (les passages faibles sont relevés). Floor limite les deux à ± ce nombre de dB.",
+ "device.prism.sidechain_key_every_bands_detector": "Sidechain — pilote le détecteur de chaque bande depuis une autre piste (découpée dans les mêmes bandes)",
+ "device.prism.soft_clip_a_smooth_ceiling": "Soft clip — un plafond doux à −0,3 dBFS après le gain de sortie",
+ "device.prism.solo_a_band_hear_only": "Solo d’une bande — n’entendre que cette bande (cliquer à nouveau pour annuler)",
+ "device.prism.the_selected_bands_input_peaks": "Les crêtes d’entrée de la bande sélectionnée (gris) et ce qu’en fait le détecteur de son compresseur (les ~1,5 dernières secondes), face au seuil.",
+ "device.rack.a_midi_effect_rack_holds": "Un MIDI Effect Rack contient jusqu’à {0} chaînes",
+ "device.rack.a_midi_effect_rack_takes": "Un MIDI Effect Rack n’accepte que des effets MIDI.",
+ "device.rack.a_rack_cant_go_inside": "Un rack ne peut pas aller dans un rack.",
+ "device.rack.add_device_click_for_the": "Ajouter un appareil — cliquer pour la liste, ou déposer un effet ici",
+ "device.rack.all_chains_get_the_input": "Toutes les chaînes reçoivent l’entrée. Les sorties sont additionnées.",
+ "device.rack.an_audio_effect_rack_takes": "Un Audio Effect Rack n’accepte que des effets audio.",
+ "device.rack.audio_effect_rack_chain": "Audio Effect Rack · chaîne {0}",
+ "device.rack.chain": "Chaîne {0}",
+ "device.rack.chain_1_feeds_chain_2": "La chaîne 1 alimente la chaîne 2, de haut en bas.",
+ "device.rack.chain_n": "chaîne {0}",
+ "device.rack.chains": { "one": "{0} chaîne", "other": "{0} chaînes" },
+ "device.rack.chains.a_midi_effect_rack_holds": "Un MIDI Effect Rack contient jusqu’à {0} chaînes.",
+ "device.rack.chains.add_a_chain_or_drop": "Ajouter une chaîne — ou déposer un appareil du Navigateur sur la liste",
+ "device.rack.chains.add_a_chain_to_start": "Ajouter une chaîne pour commencer.",
+ "device.rack.chains.add_a_midi_effect_or": "Ajouter un effet MIDI — ou en déposer un depuis le Navigateur",
+ "device.rack.chains.add_an_effect_or_drop": "Ajouter un effet — ou en déposer un depuis le Navigateur",
+ "device.rack.chains.an_instrument_rack_cant_go": "Un Instrument Rack ne peut pas aller dans un rack — ajouter ses instruments comme chaînes.",
+ "device.rack.chains.cant_go_in_a_rack": "{0} ne peut pas aller dans une chaîne de rack.",
+ "device.rack.chains.chain": "Chaîne · {0}",
+ "device.rack.chains.click_to_add_or_remove": "Cliquer pour ajouter ou retirer",
+ "device.rack.chains.controlled_by_click_to_open": "Contrôlé par {0} · cliquer pour ouvrir la macro",
+ "device.rack.chains.delete_chain": "Supprimer la chaîne",
+ "device.rack.chains.devices": { "one": "{0} appareil", "other": "{0} appareils" },
+ "device.rack.chains.drop_a_device_here": "Déposer un appareil ici.",
+ "device.rack.chains.left_right": "{0} · {1} de gauche à droite",
+ "device.rack.chains.map_to": "Assigner à {0}",
+ "device.rack.chains.midi_effect": "{0} · effet MIDI {1}",
+ "device.rack.chains.open_the_full_editor": "Ouvrir l’éditeur complet",
+ "device.rack.chains.pick_an_instrument_or_drop": "Choisir un instrument — ou en déposer un depuis le Navigateur",
+ "device.rack.chains.plug_in_presets_cant_go": "Les préréglages de plug-in ne peuvent pas encore aller dans une chaîne de rack.",
+ "device.rack.chains.replace_instrument": "Remplacer l’instrument",
+ "device.rack.chains.sel": "sél. {0}–{1}",
+ "device.rack.chains.this_preset_cant_go_in": "Ce préréglage ne peut pas aller dans un rack.",
+ "device.rack.chains.this_rack_cant_host_plug": "Ce rack ne peut pas accueillir de plug-ins.",
+ "device.rack.chains.turn_off": "Désactiver",
+ "device.rack.chains.turn_on": "Activer",
+ "device.rack.chains.unmap_from": "Désassigner de {0}",
+ "device.rack.clear_mappings": { "one": "Effacer {0} assignation", "other": "Effacer {0} assignations" },
+ "device.rack.clipboard.copied": "{0} copié",
+ "device.rack.clipboard.couldnt_paste_a_device_failed": "Impossible de coller : un appareil n’a pas pu se charger.",
+ "device.rack.clipboard.midi_effects_run_in_the": "Les effets MIDI s’exécutent dans les 16 premières chaînes.",
+ "device.rack.clipboard.move_left": "Déplacer vers la gauche",
+ "device.rack.clipboard.move_right": "Déplacer vers la droite",
+ "device.rack.clipboard.nothing_to_paste": "Rien à coller",
+ "device.rack.clipboard.nothing_to_paste_here": "Rien à coller ici.",
+ "device.rack.clipboard.pasted": "{0} collé",
+ "device.rack.clipboard.pasted_devices": "{0} appareils collés",
+ "device.rack.clipboard.pasted_devices_skipped_this_chain": "{0} appareils collés, {1} ignorés car cette chaîne ne peut pas les accepter",
+ "device.rack.clipboard.sidechain_dropped": " · sidechain supprimé",
+ "device.rack.clipboard.the_device_cant_go_there": "L’appareil ne peut pas aller là.",
+ "device.rack.clipboard.this_chain_cant_take_the": "Cette chaîne ne peut pas accepter les appareils copiés.",
+ "device.rack.clipboard.this_device_cant_be_duplicated": "Cet appareil ne peut pas être dupliqué",
+ "device.rack.clipboard.this_racks_chains_take_no": "Les chaînes de ce rack n’acceptent pas d’effets MIDI.",
+ "device.rack.clipboard.this_racks_chains_take_no_2": "Les chaînes de ce rack n’acceptent pas d’effets audio.",
+ "device.rack.double_click_to_rename": "Double-clic pour renommer",
+ "device.rack.drag_to_set_right_click": "Glisser pour régler · clic droit pour assigner",
+ "device.rack.drop_an_effect_to_add": "Déposer un effet pour ajouter une chaîne.",
+ "device.rack.drop_an_instrument_to_add": "Déposer un instrument pour ajouter une couche.",
+ "device.rack.drop_midi_effects_here_output": "Déposer des effets MIDI ici. La sortie va à l’instrument de la piste.",
+ "device.rack.drum.16_loaded": "{0} · {1}/16 chargés",
+ "device.rack.drum.a_rack_cant_go_on": "Un rack ne peut pas aller sur un pad de Drum Rack.",
+ "device.rack.drum.a_synth_voice_no_sample": "Une voix de synthé, sans échantillon",
+ "device.rack.drum.all_pads": { "one": "Tous les {0} pad", "other": "Tous les {0} pads" },
+ "device.rack.drum.back_to_pads": "Retour aux pads",
+ "device.rack.drum.bank": "Banque {0}",
+ "device.rack.drum.choke_group": "Groupe d’exclusion",
+ "device.rack.drum.choke_group_click_for_the": "Groupe d’exclusion : cliquer pour le suivant",
+ "device.rack.drum.choke_group_n": "groupe d’exclusion {0} : {1}",
+ "device.rack.drum.choke_groups": { "one": "{0} groupe d’exclusion", "other": "{0} groupes d’exclusion" },
+ "device.rack.drum.click_to_add_an_instrument": "{0} — cliquer pour ajouter un instrument, ou déposer un échantillon ici",
+ "device.rack.drum.click_to_play_right_click": "{0} · {1} — cliquer pour jouer, clic droit pour plus d’options",
+ "device.rack.drum.drop_a_sample_on_a": "Déposer un échantillon sur un pad, ou choisir un kit ci-dessus.",
+ "device.rack.drum.effects": { "one": "{0} effet", "other": "{0} effets" },
+ "device.rack.drum.empty": "{0} · vide",
+ "device.rack.drum.every": "Chaque {0} ({1})",
+ "device.rack.drum.group": "Groupe {0}",
+ "device.rack.drum.hide_the_empty_pads": "Masquer les pads vides",
+ "device.rack.drum.instrument_then_its_effects_signal": "instrument, puis ses effets · signal de gauche → droite",
+ "device.rack.drum.mute_the_pad": "Couper le pad",
+ "device.rack.drum.no_choke_groups": " · aucun groupe d’exclusion",
+ "device.rack.drum.no_pad_selected": "{0} · aucun pad sélectionné{1}",
+ "device.rack.drum.no_pads_in_bank": "Aucun pad dans la banque {0}.",
+ "device.rack.drum.no_pads_in_bank_drop": "Aucun pad dans la banque {0} — déposer des échantillons dans la vue Pads.",
+ "device.rack.drum.no_pads_to_map": "Aucun pad à assigner",
+ "device.rack.drum.no_sample_drop_one_on": "Aucun échantillon — en déposer un sur le pad",
+ "device.rack.drum.none_choke_group": "Aucun",
+ "device.rack.drum.nudge_every_hits_timing_at": "Décaler au hasard le timing de chaque frappe",
+ "device.rack.drum.off": "désactivé",
+ "device.rack.drum.open_chain": "Ouvrir la chaîne",
+ "device.rack.drum.open_the_pads_instrument": "Ouvrir l’instrument du pad",
+ "device.rack.drum.pad": "Pad",
+ "device.rack.drum.pad_bank_sixteen_notes_from": "Banque de pads : seize notes à partir de C1, C2, C3 ou C4",
+ "device.rack.drum.pad_pan_drag_up_or": "Panoramique du pad · glisser vers le haut ou le bas, ⌥-clic pour saisir, double-clic pour centrer",
+ "device.rack.drum.pad_volume_drag_up_or": "Volume du pad · glisser vers le haut ou le bas, ⌥-clic pour saisir, double-clic pour 0 dB",
+ "device.rack.drum.pad_volume_pan": "{0} {1} · {2} → {3} → volume, panoramique du pad",
+ "device.rack.drum.pads": { "one": "{0} pad", "other": "{0} pads" },
+ "device.rack.drum.pads_in_the_same_group": "Les pads d’un même groupe se coupent mutuellement",
+ "device.rack.drum.push_the_off_beat_sixteenths": "Retarder les doubles-croches en contretemps",
+ "device.rack.drum.remove_pad": "Retirer le pad",
+ "device.rack.drum.sampler": "sampler {0}",
+ "device.rack.drum.select_a_pad_to_see": "Sélectionner un pad pour voir sa chaîne d’appareils.",
+ "device.rack.drum.select_the_pad": "Sélectionner le pad",
+ "device.rack.drum.selected_choke": "{0} {1} sélectionné · {2} · exclusion {3}",
+ "device.rack.drum.shorten_the_pads_tail_hold": "Raccourcir la queue du pad ; hold la laisse sonner",
+ "device.rack.drum.show_every_pad_of_the": "Afficher tous les pads de la banque",
+ "device.rack.drum.show_the_pads": "Afficher les pads",
+ "device.rack.drum.show_the_pads_instrument_and": "Afficher l’instrument et les effets du pad",
+ "device.rack.drum.slots_assigned": "{0} emplacements · {1} assignés",
+ "device.rack.drum.solo_the_pad": "Mettre le pad en solo",
+ "device.rack.drum.swing_humanize": " · swing {0} · humanize {1}",
+ "device.rack.drum.transpose_the_note_the_pad": "Transposer la note jouée par le pad, en demi-tons",
+ "device.rack.drum_rack_pad": "Drum Rack · pad {0}{1}",
+ "device.rack.each_note_goes_to_every": "Chaque note va à toutes les chaînes dont elle touche la zone. Les sorties fusionnent avant l’instrument.",
+ "device.rack.effect_of": "{0} · effet {1} sur {2}",
+ "device.rack.instrument_rack_chain": "Instrument Rack · chaîne {0}{1}",
+ "device.rack.keys_c_1_g9_vel": "Touches C−1–G9 · vél. 0–127",
+ "device.rack.macro_tab.drag_the_ends_min_above": "Glisser les extrémités · min au-dessus de max inverse",
+ "device.rack.macro_tab.map_this_macro_click_parameters": "Assigner cette macro : cliquer des paramètres dans l’onglet Chains",
+ "device.rack.macro_tab.no_targets_yet_press_map": "Aucune cible pour l’instant. Appuyer sur Map, puis cliquer des paramètres dans l’onglet Chains.",
+ "device.rack.macros": { "one": "{0} macro", "other": "{0} macros" },
+ "device.rack.macros.add_a_receiver_a_pad": "Ajouter un récepteur : une commande de pad, l’instrument du pad ou l’un de ses effets",
+ "device.rack.macros.all": "tous",
+ "device.rack.macros.all_n": "tous les {0}",
+ "device.rack.macros.drag_to_turn_click_to": "{0} — {1}\nGlisser pour tourner · cliquer pour voir ses récepteurs · clic droit pour assigner, renommer ou effacer",
+ "device.rack.macros.drag_to_turn_double_click": "{0} → {1} · glisser pour tourner · double-clic pour réinitialiser",
+ "device.rack.macros.every_macro_assigned": "toutes les macros assignées",
+ "device.rack.macros.free": "{0} libre(s)",
+ "device.rack.macros.macro_is_free_right_click": "La macro {0} est libre — clic droit (ou Map) pour lui donner une cible",
+ "device.rack.macros.map": "Assigner",
+ "device.rack.macros.map_the_chosen_macro_click": "Assigner la macro choisie : cliquer des paramètres dans la chaîne",
+ "device.rack.macros.map_to": "Assigner à",
+ "device.rack.macros.not_assigned": "non assigné",
+ "device.rack.macros.not_mapped_pick_it_and": "Non assigné · le choisir puis appuyer sur Map",
+ "device.rack.macros.nothing_mapped_yet_map_gives": "Rien d’assigné pour l’instant. Map donne à ce potentiomètre une commande de pad, un paramètre d’instrument ou l’un des effets du kit.",
+ "device.rack.macros.params": { "one": "{0} param.", "other": "{0} param." },
+ "device.rack.macros.receivers_and_ranges": "Récepteurs et plages…",
+ "device.rack.macros.remove_every_receiver_of_this": "Retirer tous les récepteurs de cette macro",
+ "device.rack.macros.remove_this_receiver": "Retirer ce récepteur",
+ "device.rack.macros.rename": "Renommer",
+ "device.rack.macros.stop_mapping_esc": "Arrêter l’assignation (Échap)",
+ "device.rack.macros.targets": { "one": "{0} cible", "other": "{0} cibles" },
+ "device.rack.macros.the_range_the_macro_sweeps": "La plage balayée par la macro : glisser l’une ou l’autre extrémité · le repère indique la position actuelle",
+ "device.rack.map_to_a_macro": "Assigner à une macro",
+ "device.rack.map_to_parameter": "Assigner à un paramètre",
+ "device.rack.map_to_the_selector": "Assigner au sélecteur",
+ "device.rack.mapped_to_macro_click_to": "Assigné à la macro {0} — cliquer pour changer",
+ "device.rack.nota_rhythm_voice": "Nota Rhythm · voix {0}",
+ "device.rack.of_8_mapped": "{0} sur 8 assignées",
+ "device.rack.only_chains_whose_range_holds": "Seules les chaînes dont la plage contient le sélecteur reçoivent des notes.",
+ "device.rack.only_chains_whose_range_holds_2": "Seules les chaînes dont la plage contient le sélecteur jouent.",
+ "device.rack.pads": "{0} · {1} pads",
+ "device.rack.parameters": { "one": "{0} paramètre", "other": "{0} paramètres" },
+ "device.rack.params": { "one": "→ {0} param.", "other": "→ {0} param." },
+ "device.rack.remove_device": "Retirer l’appareil",
+ "device.rack.right_panel.a_rack_keeps_at_least": "Un rack garde au moins une chaîne",
+ "device.rack.right_panel.all_chains_share_one_voice": "Toutes les chaînes partagent une voix, la dernière touche l’emporte",
+ "device.rack.right_panel.copy_this_chain_after_itself": "Copier cette chaîne après elle-même",
+ "device.rack.right_panel.delete_this_chain": "Supprimer cette chaîne",
+ "device.rack.right_panel.dry_wet": "{0} · {1} · dry/wet {2} · {3}",
+ "device.rack.right_panel.edit_on_the_tab": "Modifier dans l’onglet {0}",
+ "device.rack.right_panel.follow_input_level": "Suivre le niveau d’entrée",
+ "device.rack.right_panel.follows_input": " · suit l’entrée",
+ "device.rack.right_panel.glides_between_notes_in_mono": "Glisse entre les notes en mode mono",
+ "device.rack.right_panel.in_select_mode_the_selector": "En mode Select, le sélecteur suit le niveau d’entrée au lieu de sa poignée",
+ "device.rack.right_panel.line_up_chains_with_different": "Aligner des chaînes de latences différentes",
+ "device.rack.right_panel.macros_mapped": { "one": "{0} macro assignée", "other": "{0} macros assignées" },
+ "device.rack.right_panel.merge_duplicate_notes": "Fusionner les notes en double",
+ "device.rack.right_panel.merged_midi": "{0} · {1} → MIDI fusionné · {2}",
+ "device.rack.right_panel.mono_last_note": "Mono (dernière note)",
+ "device.rack.right_panel.no_chain_yet": "Aucune chaîne pour l’instant.",
+ "device.rack.right_panel.notes_no_chain_takes_reach": "Les notes qu’aucune chaîne ne prend atteignent l’instrument inchangées",
+ "device.rack.right_panel.pass_through_outside_zones": "Laisser passer hors des zones",
+ "device.rack.right_panel.select": "Sélecteur {0}",
+ "device.rack.right_panel.two_chains_sending_the_same": "Deux chaînes qui envoient la même hauteur ne jouent qu’une note",
+ "device.rack.this_drum_rack_is_no": "Ce Drum Rack n’est plus dans le rack.",
+ "device.rack.unmap": "Désassigner",
+ "device.rack.voices": "{0} · voix {1}",
+ "device.rack.zones.drag_the_edges_to_set": "Glisser les bords pour définir la zone de touches · survoler pour tester une note",
+ "device.rack.zones.drag_the_edges_to_set_2": "Glisser les bords pour définir la plage de sélection",
+ "device.rack.zones.drag_the_edges_to_set_3": "Glisser les bords pour définir la zone de vélocité",
+ "device.rack.zones.drag_the_selector_or_map": "Glisser le sélecteur ou l’assigner à une macro",
+ "device.rack.zones.drag_to_choose_which_chains": "Glisser pour choisir les chaînes jouées · clic droit pour l’assigner à une macro",
+ "device.rack.zones.drag_zone_edges_hover_to": "Glisser les bords de la zone · survoler pour tester une note",
+ "device.rack.zones.hover_the_zones": "Survoler les zones",
+ "device.rack.zones.inactive": " · inactif",
+ "device.rack.zones.nothing": "rien",
+ "device.rack.zones.ranges_apply_when_chains_run": "Les plages s’appliquent quand Chains run est réglé sur Select",
+ "device.rack.zones.select_range_in_select_mode": "Plage de sélection : en mode Select, cette chaîne joue tant que le sélecteur est dedans",
+ "device.rack.zones.selector": "sélecteur {0} → {1}{2}",
+ "device.rack.zones.silence": "silence",
+ "device.rack.zones.the_selector_follows_the_input": "Le sélecteur suit le niveau d’entrée · désactiver Follow input dans l’onglet Rack out pour le régler à la main",
+ "device.rack.zones.vel": "{0} · vél. {1} → {2}",
+ "device.random.bar_changed_skipped": "mesure {0} · {1} modifiées · {2} ignorées",
+ "device.random.chance_how_many_notes_get": "Chance — combien de notes sont variées",
+ "device.random.chance_that_a_varied_note": "Probabilité qu’une note variée soit supprimée",
+ "device.random.changed_skip": "{0} modifiées · {1} ignorées",
+ "device.random.dashed_in_filled_out_brightness": "Pointillés — entrée · plein — sortie (luminosité = vélocité) · × — ignoré",
+ "device.random.distribution_gauss_even_walk_click": "Distribution : Gauss / Even / Walk — cliquer pour la suivante, Maj-clic pour la précédente",
+ "device.random.distribution_gauss_mostly_small_moves": "Distribution : Gauss — surtout de petits écarts · Even — toute amplitude de façon égale · Walk — dérive de note en note",
+ "device.random.drag_up_down_double_click": "{0} — glisser vers le haut / bas, double-clic pour réinitialiser",
+ "device.random.hold_the_roll_showing_now": "Maintenir le roulement affiché — il se répète à chaque mesure",
+ "device.random.jump_up_or_down_by": "Saute vers le haut ou le bas jusqu’à deux octaves",
+ "device.random.lock_hold_the_roll_showing": "Lock — maintenir le roulement affiché",
+ "device.random.next_seed_a_new_roll": "Graine suivante — un nouveau tirage",
+ "device.random.one_bar_of_eight_notes": "Une mesure de huit notes : pointillés — la note en entrée, plein — la note en sortie (luminosité = vélocité, décalée à droite si retardée), × — ignorée",
+ "device.random.per_note_every_note_rolls": "Per note — chaque note tire ses propres valeurs · Per bar — un seul jeu de valeurs pour toute la mesure",
+ "device.random.play_late_by_up_to": "Jouer en retard jusqu’à cette durée (un effet en direct ne peut pas jouer en avance)",
+ "device.random.push_the_velocity_up_or": "Pousser la vélocité vers le haut ou le bas jusqu’à cette valeur",
+ "device.random.reroll_the_next_seed": "Reroll — la graine suivante",
+ "device.random.snap_every_varied_note_into": "Ramener chaque note variée dans Do majeur",
+ "device.random.stay_in_scale_c_maj": "Rester dans la gamme · Do maj",
+ "device.random.the_shape_of_the_roll": "La forme du roulement — 1500 tirages du même générateur",
+ "device.random.transpose_up_or_down_by": "Transposer vers le haut ou le bas jusqu’à ce nombre de demi-tons",
+ "device.reverb.algorithm_hall_large_spaced_reflections": "Algorithme — Hall (grandes réflexions espacées) · Room (petite pièce, murs proches) · Plate (dense, sans pièce) · Chamber (entre les deux)",
+ "device.reverb.bass_mono_below_this_frequency": "Bass mono — sous cette fréquence la queue est mono, pour qu’une réverbération large n’empâte pas les graves (désactivé tout à gauche)",
+ "device.reverb.decay_rt60_the_time_the": "Decay — RT60, le temps que met la queue à baisser de 60 dB (0,2 … 12 s) ; Freeze la maintient indéfiniment. Double-clic pour réinitialiser.",
+ "device.reverb.early_reflections_the_first_discrete": "Early reflections — les premiers échos discrets sur les murs, espacés selon l’algorithme et la taille",
+ "device.reverb.freeze_hold_the_tail_forever": "Freeze — maintient la queue indéfiniment ; l’entrée est coupée et rien ne décroît",
+ "device.reverb.hf_damp_how_much_faster": "HF Damp — de combien les aigus s’éteignent plus vite que les graves. Double-clic pour réinitialiser.",
+ "device.reverb.input_muted_tail_held": "entrée coupée · queue maintenue",
+ "device.reverb.kill_tail_empty_the_reverb": "Kill tail — vide la réverbération d’un coup ; tout ce qui sonne encore (ou est gelé) s’arrête",
+ "device.reverb.latency_comp": "Comp. de latence",
+ "device.reverb.mod_on_tail_the_modulation": "Mod on tail — la modulation fait osciller la queue elle-même (un déclin chorusé et évolutif) ; désactivé, elle ne bouge que le début et la queue reste immobile",
+ "device.reverb.tail_held_no_decay": "Queue maintenue · sans déclin",
+ "device.reverb.the_decay_tail_the_impulse": "La queue de déclin — l’impulsion au pre-delay (turquoise), les premières réflexions (dessinées agrandies), puis la courbe RT60 sur 4 s. Glisser le repère turquoise pour le pre-delay, la queue pour le déclin ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.reverb.the_input_diffuser_delays_the": "Le diffuseur d’entrée retarde la queue d’un retard de groupe fixe ; activé, le pre-delay est raccourci d’autant pour que la queue démarre au pre-delay réglé (il ne peut pas descendre sous zéro).",
+ "device.reverb.vintage_an_early_digital_colour": "Vintage — une couleur des débuts du numérique : entrée limitée en bande, traitement en 12 bits et oscillation plus profonde",
+ "device.reverb.wet_only_the_tail_with": "Wet only — la queue sans signal sec, pour une piste de retour / d’envoi",
+ "device.rhythm.add_a_receiver_to_a": "Ajouter un récepteur à {0} : un paramètre de voix, un réglage du kit ou l’effet d’une voix",
+ "device.rhythm.all_voices": { "one": "Toutes les {0} voix", "other": "Toutes les {0} voix" },
+ "device.rhythm.amp_decay_shortens_the_hit": "Amp decay — raccourcit le coup",
+ "device.rhythm.attack_click_snap": "Clic / claquement d’attaque",
+ "device.rhythm.bank": "Banque {0}",
+ "device.rhythm.bank_play_and_edit_this": "Banque {0} — jouer et modifier ce motif · clic droit pour le copier ou l’effacer",
+ "device.rhythm.clear": "Effacer {0}",
+ "device.rhythm.clear_bank": "Effacer la banque {0}",
+ "device.rhythm.clear_its_steps_in_bank": "Effacer ses pas dans la banque {0}",
+ "device.rhythm.click_step_on_off_shift": "Clic : pas actif / inactif · Maj-clic : accent · Alt-clic : pas faible\nGlisser pour peindre · glisser vers le haut / bas ou défiler pour régler la vélocité · clic droit pour plus d’options",
+ "device.rhythm.click_to_load_another_file": "{0} — cliquer pour charger un autre fichier",
+ "device.rhythm.copy_to": "Copier {0} vers",
+ "device.rhythm.drag_the_start_and_end": "Glisser les lignes Start et End pour les régler · ⌥-clic sur l’une pour la saisir · double-clic pour charger un autre fichier",
+ "device.rhythm.every": "Chaque {0} ({1})",
+ "device.rhythm.fill_every_16th": "Remplir toutes les doubles-croches",
+ "device.rhythm.fill_every_8th": "Remplir toutes les croches",
+ "device.rhythm.fill_every_beat": "Remplir tous les temps",
+ "device.rhythm.glue_a_bus_compressor_on": "Glue : un compresseur de bus sur tout le kit — soude les frappes entre elles (0 = désactivé)",
+ "device.rhythm.how_much_louder_an_accented": "De combien un pas accentué joue plus fort",
+ "device.rhythm.how_much_of_the_file": "La part du fichier jouée, à partir de Start",
+ "device.rhythm.humanize_a_random_nudge_to": "Humanize : un léger décalage aléatoire de la vélocité de chaque frappe",
+ "device.rhythm.load_a_one_shot_into": "Charger un one-shot dans cette voix (ou déposer un fichier sur la voix)",
+ "device.rhythm.load_a_sample_into": "Charger un échantillon dans {0}",
+ "device.rhythm.load_sample": "Charger un échantillon…",
+ "device.rhythm.midi_click_select_and_play": "{0} · MIDI {1}\nClic : sélectionner et jouer · déposer un fichier pour le charger · clic droit pour plus d’options",
+ "device.rhythm.of_1_16_bank": "{0} sur {1} · 1/16 · banque {2}",
+ "device.rhythm.off_beats": "Contretemps",
+ "device.rhythm.pitch_kick_snare_tom_hats": "Hauteur (Kick, Snare, Tom, Hats, Perc) ou couleur du bruit (Clap, Rim)",
+ "device.rhythm.play_the_loaded_sample": "Jouer l’échantillon chargé",
+ "device.rhythm.play_the_region_back_to": "Jouer la région à l’envers",
+ "device.rhythm.play_the_synth_engine": "Jouer le moteur de synthèse",
+ "device.rhythm.shift_left": "Décaler à gauche",
+ "device.rhythm.shift_right": "Décaler à droite",
+ "device.rhythm.shift_step_accent": "Maj+pas = accent",
+ "device.rhythm.slots_assigned": "{0} emplacements · {1} assignés",
+ "device.rhythm.snare_body_noise_hats_metal": "Snare corps ↔ bruit · Hats métal ↔ bruit · Perc rapport d’anneau",
+ "device.rhythm.sound_the_voices_source_and": "Sound : la source et la forme de la voix · FX : ses propres effets, avant le bus du kit",
+ "device.rhythm.step_accent": "Pas {0} accentué",
+ "device.rhythm.step_quiet": "Pas {0} faible",
+ "device.rhythm.swing_delays_every_second_16th": "Swing : retarde une double-croche sur deux — à 100 %, d’un demi-pas",
+ "device.rhythm.synth_the_voices_own_engine": "Synth : le moteur propre de la voix · Sample : un one-shot chargé (en charge un si la voix n’en a pas)",
+ "device.rhythm.the_hit_amp_contour_over": "La frappe : contour d’amplitude sur la chute de hauteur · glisser latéralement pour Decay, vers le haut / bas pour Tune (Maj = fin) · ⌥-clic pour les saisir",
+ "device.rhythm.the_kits_eight_macros_knobs": "Les huit macros du kit — des potentiomètres sur chaque voix et ses effets",
+ "device.rhythm.the_kits_output_level": "Le niveau de sortie du kit",
+ "device.rhythm.the_selected_voices_sound_and": "Le son et les effets de la voix sélectionnée",
+ "device.rhythm.the_voices_level_in_the": "Le niveau de la voix dans le kit",
+ "device.rhythm.transpose_12_semitones": "Transposition, ±12 demi-tons",
+ "device.rhythm.voices": { "one": "{0} voix", "other": "{0} voix" },
+ "device.rhythm.where_in_the_file_the": "L’endroit du fichier où commence la frappe",
+ "device.sampler.a_long_tail_after_release": "une longue queue après le relâchement",
+ "device.sampler.a_slow_swell": "une montée lente",
+ "device.sampler.almost_a_gate_the_sample": "presque un gate — l’échantillon s’entend en entier",
+ "device.sampler.blends_the_loops_end_into": "Fond la fin de la boucle dans son début (boucles avant)",
+ "device.sampler.click_a_key_to_make": "Cliquer une touche pour en faire la fondamentale — celle qui joue l’échantillon tel qu’enregistré",
+ "device.sampler.detect_from_file_name": "Détecter d’après le nom du fichier",
+ "device.sampler.drag_a_sample_from_the": "Glisser un échantillon depuis l’onglet Fichiers ou le navigateur",
+ "device.sampler.drag_left_right_for_the": "Glisser : gauche / droite pour la coupure, haut / bas pour la résonance · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
+ "device.sampler.drag_start_end_and_the": "Glisser Start / End (et les repères de boucle en mode boucle) · ⌥-clic sur un repère pour le saisir · double-clic pour le réinitialiser",
+ "device.sampler.drag_the_nodes_attack_decay": "Glisser les nœuds : attaque, déclin et maintien (haut / bas), relâchement · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
+ "device.sampler.drop_a_sample_here": "Déposer un échantillon ici",
+ "device.sampler.env": "Env {0} — {1}",
+ "device.sampler.every_key_plays_the_same": "toutes les touches jouent la même hauteur",
+ "device.sampler.filter_off_the_sample_passes": "Filtre désactivé — l’échantillon passe intact",
+ "device.sampler.fine_tune_50_cents": "Accord fin, ±50 cents",
+ "device.sampler.held_at_the_sustain_level": "maintenu au niveau de sustain",
+ "device.sampler.how_far_the_envelope_moves": "L’amplitude du déplacement de la coupure par l’enveloppe, ±6 octaves",
+ "device.sampler.how_far_the_key_moves": "L’influence de la touche sur la hauteur — 100 % chromatique, 0 % toutes les touches jouent la fondamentale",
+ "device.sampler.how_much_velocity_sets_the": "Dans quelle mesure la vélocité règle le niveau",
+ "device.sampler.let_the_amp_envelope_open": "Laisser l’enveloppe d’ampli ouvrir (ou fermer) le filtre — la profondeur est ENV",
+ "device.sampler.move_start_and_end_to": "Placer Start et End là où le son commence et s’éteint (−48 dB)",
+ "device.sampler.move_start_end_and_the": "Placer Start, End et la boucle au passage par zéro le plus proche — sans clics",
+ "device.sampler.names_make_it_the_root": "« {0} » désigne {1} — en faire la fondamentale",
+ "device.sampler.no_crossfade": "{0} · sans fondu enchaîné",
+ "device.sampler.no_sample_drop_one_from": "Aucun échantillon · en déposer un depuis l’onglet Fichiers ou le navigateur",
+ "device.sampler.off_low_pass_high_pass": "Off · passe-bas · passe-haut · passe-bande (12 dB/oct)",
+ "device.sampler.off_plays_once_fwd_loops": "Off joue une fois · Fwd boucle · Ping fait des allers-retours · Rev boucle à l’envers",
+ "device.sampler.plays_the_sample_at_its": "{0} joue l’échantillon à sa propre hauteur",
+ "device.sampler.poly_16_voices_mono_one": "Poly : 16 voix · Mono : une à la fois (legato avec Glide) · Choke : une nouvelle note coupe celles qui sonnent",
+ "device.sampler.range_root_keytrack": "plage {0} — {1} · fondamentale {2} · keytrack {3}",
+ "device.sampler.root_a_semitone_down": "Fondamentale un demi-ton plus bas",
+ "device.sampler.root_a_semitone_up": "Fondamentale un demi-ton plus haut",
+ "device.sampler.shift_every_note_24_semitones": "Décaler toutes les notes, ±24 demi-tons",
+ "device.sampler.slide_from_the_last_note": "Glisser depuis la dernière note — en Mono, legato : sans redéclenchement",
+ "device.sampler.snap_to_zero": "Caler sur le zéro",
+ "device.sampler.the_cutoff_follows_the_key": "La coupure suit la touche, 0 … 100 %",
+ "device.sampler.the_key_sets_the_playback": "la touche règle la vitesse de lecture",
+ "device.sampler.the_level_after_everything": "Le niveau après tout le reste",
+ "device.sampler.the_root_note_scroll_to": "La note fondamentale — défiler pour la changer",
+ "device.sampler.the_sample_plays_at_its": "l’échantillon joue à sa propre hauteur sur la fondamentale",
+ "device.sampler.the_samples_file_name_isnt": "Le nom de fichier de l’échantillon est inconnu",
+ "device.sampler.the_samples_level_before_the": "Le niveau de l’échantillon avant l’enveloppe",
+ "device.sampler.the_voices_level": "Le niveau des voix",
+ "device.sampler.trim_silence": "Rogner le silence",
+ "device.sampler.velocity_sets_the_level_the": "La vélocité règle le niveau — la quantité est le VEL → VOL du rail",
+ "device.scale.an_octave_drag_or_scroll": "{0} — ± une octave, glisser ou défiler la note pour les demi-tons, ⌥-clic sur la note pour la saisir, double-clic pour réinitialiser. Les notes hors de la plage passent telles quelles.",
+ "device.scale.clear_the_scale_down_to": "Réduire la gamme à la fondamentale (Custom)",
+ "device.scale.click_a_note_to_add": "Cliquer une note pour l’ajouter à la gamme ou l’en retirer (la gamme passe en Custom)",
+ "device.scale.custom_your_own_notes_click": "Custom : vos propres notes — cliquer la carte des notes pour modifier",
+ "device.scale.empty_notes_pass": "vide · les notes passent",
+ "device.scale.fold_where_an_out_of": "Fold — où va une note hors gamme : la note de gamme la plus proche (à égalité, vers le haut), celle du dessous ou celle du dessus",
+ "device.scale.follow_key_from_input": "Follow key · depuis l’entrée",
+ "device.scale.follow_key_the_root_moves": "Follow key — la fondamentale se déplace vers la tonalité qui correspond le mieux à ce qui est joué (en gardant le type de gamme)",
+ "device.scale.last_in_out_caps": "Dernière entrée → sortie",
+ "device.scale.learn_play_the_notes_of": "Learn — jouer les notes de la gamme ; elles passent intactes et deviennent la gamme Custom. Cliquer à nouveau pour terminer.",
+ "device.scale.notes": "{0} {1} · {2} notes",
+ "device.scale.notes_fold": "{0} {1} · {2} notes · fold {3} · ",
+ "device.scale.notes_n": "{0} — {1} notes",
+ "device.scale.of_12_remapped": "{0} sur 12 réassignées",
+ "device.scale.root_click_the_arrows_or": "Root — cliquer les flèches ou défiler",
+ "device.scale.the_key_in_effect_root": "La tonalité en vigueur : fondamentale et gamme",
+ "device.scale.the_last_note_played_and": "La dernière note jouée et ce qu’elle est devenue",
+ "device.shutter.clear_every_step": "Effacer tous les pas",
+ "device.shutter.click_to_type": " · ⌥-clic pour saisir",
+ "device.shutter.clock_sync_locks_the_pattern": "Clock — Sync cale le motif sur les mesures du morceau, Free le fait tourner en Hz",
+ "device.shutter.closes_to_silence": "se ferme jusqu’au silence",
+ "device.shutter.complexity_how_busy_and_varied": "Complexity — le degré de densité et de variété que Rnd donne au motif",
+ "device.shutter.copy_the_steps": "Copier les pas",
+ "device.shutter.depth_how_far_an_empty": "Depth — de combien un pas vide baisse le signal",
+ "device.shutter.detector_filter_the_key_goes": "Detector filter — la clé passe par le passe-bande (onglet Sidechain) avant le détecteur",
+ "device.shutter.detector_filter_the_key_goes_2": "Detector filter — la clé passe par le passe-bande avant le détecteur",
+ "device.shutter.detector_full_band": "Détecteur · pleine bande",
+ "device.shutter.ducks_to_silence": "descend jusqu’au silence",
+ "device.shutter.external_sidechain_the_detector_listens": "Sidechain externe — le détecteur écoute la source de clé au lieu de cette piste",
+ "device.shutter.floor_the_level_when_closed": "Floor — le niveau une fois fermé (−∞ = silence) ; en Duck, de combien le signal descend",
+ "device.shutter.gain_reduction_how_far_the": "Gain reduction — de combien le gate baisse le signal en ce moment",
+ "device.shutter.gate_envelope_trigger": "Gate envelope · trigger",
+ "device.shutter.gated_the_pattern_plays_only": "Gated — le motif ne joue que tant que le gate de seuil est ouvert (gate × motif)",
+ "device.shutter.internal_this_track": "Interne — cette piste",
+ "device.shutter.key_source_internal_keys_off": "Key source — Internal se déclenche sur cette piste ; choisir une autre piste, ou l’un de ses pads ou chaînes, pour gater ou ducker contre elle",
+ "device.shutter.levels_4_8_or_16": "Levels — 4, 8 ou 16 hauteurs sur lesquelles un pas se cale",
+ "device.shutter.listen_hear_the_key_as": "Listen — écouter la clé comme l’entend le détecteur (après son filtre), pour régler la bande",
+ "device.shutter.live_the_graph_follows_the": "Live — le graphique suit l’audio ; cliquer pour figer l’image",
+ "device.shutter.lookahead_0_1_or_5": "Lookahead — 0, 1 ou 5 ms",
+ "device.shutter.lookahead_the_gate_opens_this": "Lookahead — le gate s’ouvre aussi tôt avant l’arrivée du transitoire (la piste est retardée d’autant)",
+ "device.shutter.map_pattern_out": " → Map (Pattern Out)",
+ "device.shutter.map_pattern_out_2": "Map → Pattern Out",
+ "device.shutter.mode_gate_lets_the_signal": "Mode — Gate laisse passer le signal au-dessus du seuil ; Duck le baisse tant que la clé est au-dessus",
+ "device.shutter.mouse_tool_for_the_grid": "Outil souris pour la grille",
+ "device.shutter.one_opening_attack_hold_release": "Une ouverture : attaque, maintien, relâchement dans la forme choisie, jusqu’au plancher (inversé pour Duck). Glisser un nœud latéralement pour son temps, le plancher turquoise vers le haut ou le bas ; double-clic pour réinitialiser, ⌥-clic pour saisir.",
+ "device.shutter.only_while_gate_open": "Uniquement gate ouvert",
+ "device.shutter.paste_copied_steps_fitted_to": "Coller les pas copiés (ajustés à la grille)",
+ "device.shutter.pattern_shapes_the_arrows_step": "Formes de motifs — les flèches les parcourent (ajustées à la grille)",
+ "device.shutter.peak_hold_the_detector_holds": "Peak hold — le détecteur maintient chaque crête plus longtemps, pour que les notes graves et les ondes lentes ne fassent pas trembler le gate",
+ "device.shutter.range_how_far_the_gate": "Range — de combien le gate se ferme ou le duck descend (−∞ = jusqu’au bout)",
+ "device.shutter.rate_how_long_the_whole": "Rate — la durée du motif entier : 1/4 … 4 mesures en Sync, 4 … 0,25 Hz en Free",
+ "device.shutter.reset_clear_the_peak_reduction": "Reset — efface la réduction maximale, le compte d’ouvertures et l’historique",
+ "device.shutter.retrig_every_midi_note_on": "Retrig — chaque note MIDI de cette piste (ou de la piste de clé) relance le motif",
+ "device.shutter.retrig_on_midi_note": "Redéclencher sur note MIDI",
+ "device.shutter.retrigger_trigger_mode_each_hit": "Retrigger — mode déclenché : chaque frappe lance une attaque → maintien → relâchement, quelle que soit la durée pendant laquelle le signal reste au-dessus du seuil",
+ "device.shutter.return_how_far_under_the": "Return — de combien la clé doit passer sous le seuil avant que le gate ne se ferme (évite les battements)",
+ "device.shutter.roll_a_new_pattern_complexity": "Tirer un nouveau motif — Complexity règle sa densité et sa variété",
+ "device.shutter.sc_eq_the_detector_hears": "SC EQ — le détecteur entend la clé à travers son passe-bande ; off = pleine bande",
+ "device.shutter.shape_linear_straight_ramps_over": "Shape — Linear : rampes droites sur les durées ; Log : la courbe classique à un pôle ; Snap : reste ouvert, puis se ferme net",
+ "device.shutter.signal_and_duck": "Signal et duck",
+ "device.shutter.signal_and_gate": "Signal et gate",
+ "device.shutter.signal_tab_click_to_change": "Onglet Signal : cliquer pour changer la fenêtre — ",
+ "device.shutter.smooth_ramps_into_each_step": "Smooth — monte en rampe vers chaque pas au lieu de sauter (jusqu’à un demi-pas)",
+ "device.shutter.steps_8_16_or_32": "Steps — 8, 16 ou 32 (le motif est étiré pour s’y adapter)",
+ "device.shutter.swing_every_second_step_comes": "Swing — un pas sur deux arrive en retard",
+ "device.shutter.target_off_volume_the_pattern": "Target — Off ; Volume : le motif gate l’audio ; Map : l’audio n’est pas touché et le motif pilote Pattern Out, une source CV de la vue Modulaire",
+ "device.shutter.the_detectors_band_pass_teal": "Le passe-bande du détecteur (turquoise) — seule cette partie de la clé ouvre le gate — au-dessus de la réduction dans la fenêtre (neutre). Glisser les nœuds latéralement ; double-clic pour réinitialiser, ⌥-clic pour saisir.",
+ "device.shutter.the_input_teal_and_what": "L’entrée (turquoise) et ce qui passe (neutre) sur la fenêtre, avec le seuil (pointillés) et le point où le gate se referme (pointillés). Glisser une ligne vers le haut ou le bas ; double-clic pour la réinitialiser, ⌥-clic pour la saisir.",
+ "device.shutter.the_level_the_detector_compares": "Le niveau que compare le détecteur — l’entrée de cette piste, ou la clé quand un sidechain externe le pilote ; le repère en pointillés est le seuil",
+ "device.shutter.the_step_pattern_each_column": "Le motif de pas — chaque colonne est le niveau d’un pas, la ligne est le gain qui en résulte (smooth et swing l’infléchissent). Draw règle les pas, Line trace une rampe, Erase efface, Flip bascule actif / inactif.",
+ "device.shutter.volume_gated": " → Volume · gaté",
+ "device.shutter.what_the_gate_is_doing": "Ce que fait le gate en ce moment — fermé, attaque, ouvert, maintien ou relâchement — et son gain",
+ "device.sidechain.frozen_its_parts_dont_play": "Gelée — ses parties ne jouent pas tant que la piste n’est pas dégelée",
+ "device.sidechain.missing": "{0} · manquant",
+ "device.sidechain.no_free_routes_every_sidechain": "Aucune route libre — toutes les routes de sidechain sont utilisées",
+ "device.sidechain.part": "Partie {0}",
+ "device.sidechain.the_keyed_part_was_deleted": "La partie pilotée a été supprimée — annuler la rétablit",
+ "device.size_s_260_260_l": "Taille : S (260 × 260) / L (700 × 260)",
+ "device.strata.at_bar_end": "en fin de mesure",
+ "device.strata.of_bars": { "one": "sur {0} mesure", "other": "sur {0} mesures" },
+ "device.strata.of_one_cycle_shown": "{0} sur {1} · un cycle affiché",
+ "device.strata.onto_layer": "sur la couche {0}",
+ "device.strata.press_record_to_lay_down": "Appuyer sur Enregistrer pour poser la première boucle",
+ "device.strata.set_tempo_from_loop": "Régler le tempo d’après la boucle",
+ "device.synth.cycles_unison": "{0} · {1} cycles · unisson {2}",
+ "device.synth.filter_off_the_oscillator_goes": "Filtre désactivé — l’oscillateur va directement à l’amplificateur",
+ "device.synth.vel_vol_off": "Vél. → Vol off",
+ "device.utility.bass_mono_off": "bass mono désactivé",
+ "device.utility.both_phases_inverted": "les deux phases inversées",
+ "device.utility.channel_stereo_left_or_right": "Channel — Stereo ; Left ou Right des deux côtés ; Swap échange les côtés",
+ "device.utility.gain_match_moves_gain_once": "Gain match — règle Gain une fois pour que la sortie atteigne la référence (le niveau d’entrée, ou Target) sur les 3 dernières secondes, dans l’unité du vumètre",
+ "device.utility.input_and_output": "Entrée et sortie",
+ "device.utility.input_peak_60_0_dbfs": "Crête d’entrée, −60 … 0 dBFS",
+ "device.utility.input_teal_and_output_neutral": "Entrée (turquoise) et sortie (neutre) sur les 8 dernières secondes dans l’unité du vumètre ; en pointillés : la cible. Glisser vers le haut ou le bas pour la cible.",
+ "device.utility.invert_the_left_channels_phase": "Inverser la phase du canal gauche",
+ "device.utility.invert_the_right_channels_phase": "Inverser la phase du canal droit",
+ "device.utility.lows_at_the_bottom_highs": "graves en bas · aigus en haut",
+ "device.utility.match_to_input": "aligner sur l’entrée",
+ "device.utility.meter_lufs_s_short_term": "Meter — LUFS-S : volume à court terme (3 s, pondération K) ; Peak : crête d’échantillon ; RMS : 300 ms",
+ "device.utility.mono_below_freq": "Mono below freq",
+ "device.utility.mono_below_removes_the_side": "Mono below — retire le signal latéral sous la coupure, pour que les graves soient mono",
+ "device.utility.mute_the_output": "Couper la sortie",
+ "device.utility.out_of_phase_mono_risk": "en opposition de phase — risque en mono",
+ "device.utility.output_correlation_1_mono_0": "Corrélation de sortie — +1 mono, 0 sans rapport, sous 0 en opposition de phase (s’annule en mono)",
+ "device.utility.output_peak_60_0_dbfs": "Crête de sortie, −60 … 0 dBFS",
+ "device.utility.pan_by_frequency_1_s": "panoramique par fréquence · fenêtre de 1 s",
+ "device.utility.reset_gain_back_to_0": "Reset — Gain revient à 0 dB, et les vumètres, maintiens et l’historique des niveaux repartent de zéro",
+ "device.utility.slope_of_the_mono_cutoff": "Pente de la coupure mono — 6, 12 ou 24 dB/oct ; cliquer pour changer",
+ "device.utility.the_inputs_level_in_the": "Le niveau de l’entrée dans l’unité du vumètre (LUFS-S, crête 1 s ou RMS 300 ms)",
+ "device.utility.the_outputs_level_in_the": "Le niveau de la sortie dans l’unité du vumètre",
+ "device.utility.the_outputs_stereo_field_by": "Le champ stéréo de la sortie par fréquence sur la dernière seconde — graves en bas, aigus en haut. Plein : la position de chaque bande entre L et R ; turquoise : son étalement ; pointillés : l’étalement que le réglage de largeur donne à une bande non corrélée. Glisser latéralement pour la balance, vers le haut ou le bas pour la largeur.",
+ "device.utility.the_usual_cutoffs_60_120": "Les coupures usuelles — 60, 120 ou 240 Hz (active Mono below)",
+ "device.utility.the_width_over_frequency_solid": "La largeur selon la fréquence — plein : ce que font les réglages (0 % = mono, 100 % = inchangé), la zone mono ombrée ; turquoise en pointillés : la largeur mesurée de la sortie (side contre mid). Glisser latéralement pour la coupure mono, vers le haut ou le bas pour la largeur.",
+ "device.utility.what_gain_match_and_level": "Ce que visent Gain match et Level match — le niveau de l’entrée, ou Target",
+ "device.utility.width_by_frequency": "Largeur par fréquence",
+ "device.utility.width_law_l_r_the": "Width law — L/R : le side est mis à l’échelle, donc plus large est plus fort ; M/S : mid et side sont échangés, donc le niveau reste constant (200 % = side seul)",
+ "device.valve.bright_a_treble_lift_before": "Bright — une montée des aigus avant le préampli, plus forte à faible gain (le condensateur bright d’un potentiomètre de volume)",
+ "device.valve.cab_by_model": "baffle selon le modèle · ",
+ "device.valve.cabinet_match_follows_the_model": "Cabinet — Match suit le modèle ; 1×12 ouvert, 2×12 combo, 4×12 fermé, 1×15 basse",
+ "device.valve.cabinet_match_follows_the_model_2": "Cabinet — Match suit le modèle ; les autres apportent leur propre résonance grave et leur pic de présence. Défiler pour changer.",
+ "device.valve.deep_a_low_resonance_boost": "Deep — un renfort de résonance grave après le correcteur de tonalité, pour des graves plus pleins et plus serrés",
+ "device.valve.even_harmonics_only": "Harmoniques paires uniquement",
+ "device.valve.even_only_the_preamp_adds": "Even only — le préampli n’ajoute que des harmoniques paires : de la chaleur sans le grésillement des impaires",
+ "device.valve.gain_how_hard_the_signal": "Gain — la force avec laquelle le signal attaque le préampli. Double-clic pour réinitialiser.",
+ "device.valve.mic_dynamic_the_classic_close": "Mic — Dynamic : le micro proche classique ; Condenser : plus brillant, moins d’effet de proximité ; Ribbon : sombre, le plus d’effet de proximité",
+ "device.valve.mic_position_at_the_cones": "Mic position — au centre du cône (brillant) ou sur son bord (plus sombre)",
+ "device.valve.model_the_amps_voicing_how": "Model — le voicing de l’ampli : la force d’attaque du préampli, le nombre d’étages qui écrêtent, la fermeté des graves et le baffle associé. Défiler pour changer.",
+ "device.valve.output_the_master_level_after": "Output — le niveau général après le baffle, ±12 dB. Double-clic pour réinitialiser.",
+ "device.valve.the_cabinet_as_the_mic": "Le baffle tel que l’entend le micro, avec les coupures grave / aigu — en pointillés le même baffle et micro dans l’axe, au centre du cône, à 5 cm. Glisser latéralement pour désaxer le micro, vers le haut pour le rapprocher.",
+ "device.valve.the_harmonics_the_preamp_adds": "Les harmoniques ajoutées par le préampli au niveau de l’entrée (la fondamentale en haut). Glisser vers le haut ou le bas pour le gain.",
+ "device.valve.the_tone_stack_before_the": "Le correcteur de tonalité avant le baffle — la fermeté avant distorsion du modèle, Bright, Bass / Middle / Treble / Presence et Deep ; en pointillés, le correcteur à plat. Glisser latéralement pour la fréquence du médium, vers le haut ou le bas pour le médium.",
+ "device.velocity.compand_the_same_around_the": "Compand — la même chose autour du milieu : au-dessus de 1, étire vers les bords ; en dessous de 1, resserre vers le milieu",
+ "device.velocity.curve_bend_the_response_drive": "Curve — infléchit la réponse : Drive au-dessus de 1 remonte les notes douces, en dessous de 1 les abaisse",
+ "device.velocity.drag_up_down_shift_for": "Glisser vers le haut / bas, Maj pour les pas fins, double-clic pour réinitialiser",
+ "device.velocity.every_note_at_this_velocity": "toutes les notes à cette vélocité",
+ "device.velocity.fixed_every_note_comes_out": "Fixed — toutes les notes sortent à une seule vélocité",
+ "device.velocity.input_across_output_up_dashed": "Entrée en abscisse, sortie en ordonnée · pointillés — la plage Out · bande — Random · points — les dernières notes",
+ "device.velocity.input_velocity_across_output_up": "Vélocité d’entrée en abscisse, de sortie en ordonnée. Pointillés — la plage Out ; la bande — où Random peut placer une note ; points — les dernières notes jouées",
+ "device.velocity.last": "dernière {0} → {1}",
+ "device.velocity.out_range_drag_a_handle": "Out range — glisser une poignée, ⌥-clic pour la saisir, double-clic pour revenir à 1–127",
+ "device.velocity.random_amount_0_64_velocity": "Quantité aléatoire, ±0–64 de vélocité — glisser vers le haut / bas, double-clic pour réinitialiser",
+ "device.velocity.random_both_ways_only_up": "Aléatoire dans les deux sens, seulement vers le haut, ou seulement vers le bas",
+ "device.velocity.random_both_ways_up_down": "Random : deux sens → haut → bas → désactivé — cliquer pour avancer, Maj-clic pour reculer",
+ "device.velocity.random_spread_each_notes_velocity": "Random — disperse la vélocité de chaque note (la quantité est conservée tant qu’il est désactivé)",
+ "device.velocity.soft_notes_louder": "notes douces plus fortes",
+ "device.velocity.soft_notes_quieter": "notes douces plus faibles",
+ "device.velocity.squeezed_to_the_middle": "resserré vers le milieu",
+ "device.velocity.stretched_to_the_edges": "étiré vers les bords",
+ "device.velocity.the_last_12_notes_outline": "Les 12 dernières notes : contour — vélocité en entrée, aplat — vélocité en sortie",
+ "device.velocity.velocity_mode_curve_compand_fixed": "Mode de vélocité : Curve / Compand / Fixed — cliquer pour le suivant, Maj-clic pour le précédent",
+ "device.vintage.analog_stage_a_console_style": "Étage analogique — un écrêtage doux façon console après la saturation (cliquer à nouveau pour aucun)",
+ "device.vintage.auto_comp_the_output_level": "Auto-comp — le niveau de sortie suit celui de l’entrée, quelle que soit la saturation",
+ "device.vintage.character_the_era_the_signal": "Character — l’époque que traverse le signal : sa saturation, sa tonalité, sa bande passante et la quantité de souffle, de craquements, de wow et de flutter. Défiler pour changer.",
+ "device.vintage.drive_how_hard_the_signal": "Drive — la force avec laquelle le signal attaque la saturation. ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.vintage.even_harmonics_only": "Harmoniques paires uniquement",
+ "device.vintage.sync_the_wow_follows_the": "Sync — le wow suit le tempo : une oscillation toutes les 4 mesures … 1/8 (RATE la choisit)",
+ "device.vintage.the_harmonics_the_saturation_adds": "Les harmoniques ajoutées par la saturation au niveau de l’entrée (la fondamentale en haut), face au plancher de souffle en turquoise. Glisser vers le haut ou le bas pour le drive, ⌥-clic pour le saisir.",
+ "device.vintage.the_pitch_drift_over_the": "La dérive de hauteur sur les quatre dernières secondes — wow en neutre, flutter en turquoise. Glisser vers le haut ou le bas pour la profondeur de ce qui est choisi au-dessus, latéralement pour sa vitesse ; ⌥-clic pour les saisir.",
+ "device.vintage.the_transfer_curve_the_saturation": "La courbe de transfert de la saturation — niveau d’entrée en abscisse, sortie en ordonnée ; en pointillés la ligne sèche, en turquoise ce qu’on entend avec Mix et Output, le point où se situe la crête d’entrée. Glisser vers le haut ou le bas pour le drive, ⌥-clic pour le saisir.",
+ "device.vintage.tone_model_warm_the_eras": "Tone model — Warm : l’inclinaison propre à l’époque et la bosse de tête ; Flat : le potentiomètre TONE seul ; Dark : une inclinaison plus basse et plus sombre",
+ "device.vintage.tube_stage_a_warm_asymmetric": "Étage à lampe — un étage à lampe chaud et asymétrique après la saturation (cliquer à nouveau pour aucun)",
+ "device.vintage.wear_follows_input": "Wear suit l’entrée",
+ "device.vintage.wear_the_age_of_the": "Wear — l’âge du support : une bande plus étroite, plus de souffle et de craquements, un flutter erratique. ⌥-clic pour saisir, double-clic pour réinitialiser.",
+ "device.vintage.what_the_window_shows_and": "Ce que montre la fenêtre et ce qu’un glissement y modifie",
+ "device.vocoder.attack_how_fast_a_band": "Attack — la vitesse d’ouverture d’une bande, 0,5 … 100 ms",
+ "device.vocoder.bands_how_many_bands_8": "Bands — le nombre de bandes, 8 … 32 : moins, c’est plus robotique ; plus, c’est plus clair",
+ "device.vocoder.carrier_track_the_track_the": "Piste porteuse — la piste que la voix module quand Carrier est Track ; cette piste et ses groupes ne sont pas proposés",
+ "device.vocoder.carrier_what_the_voice_shapes": "Carrier — ce que la voix module : une dent de scie interne (à Pitch), du bruit, ou une autre piste choisie ci-dessous",
+ "device.vocoder.formant_moves_the_carriers_bands": "Formant — décale les bandes de la porteuse par rapport à celles du modulateur, ±12 st : vers le haut, le son paraît plus petit ; vers le bas, plus grand",
+ "device.vocoder.gain_the_output_level_12": "Gain — le niveau de sortie, ±12 dB",
+ "device.vocoder.high_the_highest_bands_edge": "High — le bord de la bande la plus haute, 2 … 20 kHz",
+ "device.vocoder.hold_freezes_every_band_where": "Hold — fige chaque bande là où elle est ; la porteuse continue de sonner à travers",
+ "device.vocoder.low_the_lowest_bands_edge": "Low — le bord de la bande la plus basse, 20 Hz … 1 kHz",
+ "device.vocoder.mix_the_carrier_as_it": "Mix — la porteuse telle qu’elle arrive face au son vocodé",
+ "device.vocoder.mod_gain_trims_the_voice": "Mod gain — ajuste la voix avant que les bandes ne l’entendent, ±24 dB",
+ "device.vocoder.pick_a_carrier_track_until": "Choisir une piste porteuse · d’ici là le son passe tel quel",
+ "device.vocoder.pitch_the_internal_saws_note": "Pitch — la note de la dent de scie interne, C0 … C7",
+ "device.vocoder.q_how_narrow_each_band": "Q — l’étroitesse de chaque bande, 1 … 10",
+ "device.vocoder.release_how_fast_a_band": "Release — la vitesse de fermeture d’une bande, 5 … 1000 ms",
+ "device.vocoder.the_modulator_is_the_sound": "Le modulateur est le son de la piste sur laquelle se trouve le vocoder — la voix",
+ "device.vocoder.the_modulators_level_in_each": "Le niveau du modulateur dans chaque bande (barres) et celui de la porteuse (turquoise). Glisser un bord pour déplacer Low ou High ; ⌥-clic sur un bord pour le saisir, double-clic pour le réinitialiser.",
+ "device.vocoder.the_vocoders_output_level": "Le niveau de sortie du vocoder",
+ "device.vocoder.the_voices_level_after_mod": "Le niveau de la voix après Mod gain",
+ "device.vocoder.tilt_brightens_or_darkens_the": "Tilt — éclaircit (ou assombrit) la dent de scie ou la piste porteuse autour de 1 kHz avant les bandes, ±12 dB",
+ "device.vocoder.unvoiced_adds_noise_where_the": "Unvoiced — ajoute du bruit là où le modulateur siffle, pour que les consonnes restent claires",
+ "device.vocoder.where_the_carrier_track_is": "Où la piste porteuse est prélevée : avant ses effets et son fader, ou après. Pre continue d’alimenter même piste coupée",
+ "device.volt.8_slots_assigned": "8 emplacements · {0} assignés",
+ "device.volt.click_for_the_next_target": "Cliquer pour la cible suivante, clic droit pour la précédente",
+ "device.volt.drag_a_cell_up_adds": "glisser une cellule — vers le haut ajoute, vers le bas retranche · ⌥-clic pour saisir · double-clic pour effacer",
+ "device.volt.vibrato_always_rides_the_pitch": "le vibrato suit toujours la hauteur",
+ "device.volt.zero_every_route_in_the": "Remettre à zéro toutes les routes de la matrice",
+ "device_chain.active_click_to_bypass": "Actif — cliquer pour contourner",
+ "device_chain.add_an_audio_effect_search": "Ajouter un effet audio : chercher dans le navigateur, ou déposer un appareil ici",
+ "device_chain.bypassed_click_to_enable": "Contourné — cliquer pour activer",
+ "device_chain.clipboard.a_drum_rack_cant_be": "Un Drum Rack ne peut pas être dégroupé",
+ "device_chain.clipboard.a_plug_in_cant_go": "Un plug-in ne peut pas aller dans un MIDI Effect Rack",
+ "device_chain.clipboard.a_rack_cant_go_inside": "Un rack ne peut pas aller dans un autre rack",
+ "device_chain.clipboard.an_instrument_rack_cant_go": "Un Instrument Rack ne peut pas aller dans un autre Instrument Rack",
+ "device_chain.clipboard.audio_effect": "Effet audio · {0}",
+ "device_chain.clipboard.couldnt_paste_a_device_failed": "Impossible de coller : un appareil n’a pas pu se charger.",
+ "device_chain.clipboard.couldnt_paste_the_instrument": "Impossible de coller l’instrument.",
+ "device_chain.clipboard.delete_track": "Supprimer la piste",
+ "device_chain.clipboard.deleted_devices": "{0} appareils supprimés",
+ "device_chain.clipboard.device": "Appareil",
+ "device_chain.clipboard.devices": { "one": "{0} appareil", "other": "{0} appareils" },
+ "device_chain.clipboard.group_into_rack": "Grouper dans un rack",
+ "device_chain.clipboard.its_macros_and_chain_settings": " — ses macros et réglages de chaîne ont été abandonnés",
+ "device_chain.clipboard.midi_effect": "Effet MIDI · {0}",
+ "device_chain.clipboard.nothing_to_paste": "Rien à coller.",
+ "device_chain.clipboard.only_a_rack_with_one": "Seul un rack à une seule chaîne peut être dégroupé",
+ "device_chain.clipboard.only_an_instrument_track_takes": "Seule une piste d’instrument accepte des effets MIDI et un instrument",
+ "device_chain.clipboard.only_an_instrument_track_takes_2": "Seule une piste d’instrument accepte un instrument.",
+ "device_chain.clipboard.paste_an_instrument_on_an": "Coller un instrument sur une carte d’instrument.",
+ "device_chain.clipboard.pasted": "{0} collé",
+ "device_chain.clipboard.pasted_devices": "{0} appareils collés",
+ "device_chain.clipboard.pasted_devices_skipped_this_track": "{0} appareils collés, {1} ignorés car cette piste ne peut pas les accepter",
+ "device_chain.clipboard.put_devices_in": "Placer {0} appareils dans {1}",
+ "device_chain.clipboard.put_in": "Placer {0} dans {1}",
+ "device_chain.clipboard.select_a_rack_to_take": "Sélectionner un rack pour en sortir les appareils",
+ "device_chain.clipboard.select_devices_next_to_each": "Sélectionner des appareils côte à côte pour les grouper",
+ "device_chain.clipboard.select_devices_to_put_them": "Sélectionner des appareils pour les placer dans un rack",
+ "device_chain.clipboard.selected": "Sélection",
+ "device_chain.clipboard.some_devices_cant_be_duplicated": "Certains appareils ne peuvent pas être dupliqués",
+ "device_chain.clipboard.the_racks_chain_has_no": "La chaîne du rack n’a aucun instrument à remettre",
+ "device_chain.clipboard.these_devices_cant_be_copied": "Ces appareils ne peuvent pas être copiés, ils n’ont donc pas été coupés.",
+ "device_chain.clipboard.these_devices_cant_be_grouped": "Ces appareils ne peuvent pas être groupés",
+ "device_chain.clipboard.this_device_cant_be_copied": "Cet appareil ne peut pas être copié, il n’a donc pas été coupé.",
+ "device_chain.clipboard.this_rack_cant_be_ungrouped": "Ce rack ne peut pas être dégroupé",
+ "device_chain.clipboard.this_track_cant_take_the": "Cette piste ne peut pas accepter les appareils copiés.",
+ "device_chain.clipboard.took_devices_out_of_the": "{0} appareils sortis du rack",
+ "device_chain.clipboard.took_the_device_out_of": "Appareil sorti du rack",
+ "device_chain.clipboard.ungroup_rack": "Dégrouper le rack",
+ "device_chain.clipboard.with_the_instrument": "Avec l’instrument",
+ "device_chain.fold.double_click_to_unfold": "{0} — double-clic pour déplier",
+ "device_chain.fold.unfold": "Déplier",
+ "device_chain.instruments.drums_pads": { "one": "Drums · {0} pad", "other": "Drums · {0} pads" },
+ "device_chain.instruments.presets_are_unavailable": "Les préréglages ne sont pas disponibles.",
+ "device_chain.move.move_to_track": "Déplacer vers la piste",
+ "device_chain.move.plug_ins": "Plug-ins",
+ "device_chain.move.replace": "Remplacer…",
+ "device_chain.no_return_tracks": "Aucune piste de retour",
+ "device_chain.rack_chains": { "one": "Rack · {0} chaîne", "other": "Rack · {0} chaînes" },
+ "device_chain.remove_device": "Retirer l’appareil",
+ "device_chain.remove_track": "Retirer la piste",
+ "device_chain.select_a_track": "Sélectionner une piste",
+ "device_chain.shell.click_to_select_double_click": "Cliquer pour sélectionner · double-clic pour replier · clic droit pour remplacer, copier ou déplacer",
+ "device_chain.shell.compare": "Comparer : {0}",
+ "device_chain.shell.copy_a_to_b": "Copier A vers B",
+ "device_chain.shell.copy_b_to_a": "Copier B vers A",
+ "device_chain.shell.double_click_to_fold_right": "Double-clic pour replier · clic droit pour plus d’options",
+ "device_chain.shell.drag_to_reorder_double_click": "Glisser pour réordonner · double-clic pour replier · clic droit pour A/B, déplacer et supprimer",
+ "device_chain.shell.fold": "Replier",
+ "device_chain.shell.init": "Init",
+ "device_chain.shell.mono": "Mono",
+ "device_chain.shell.move_left": "Déplacer vers la gauche",
+ "device_chain.shell.move_right": "Déplacer vers la droite",
+ "device_chain.shell.next_preset": "Préréglage suivant",
+ "device_chain.shell.off_click_to_turn_the": "Désactivé — cliquer pour activer l’instrument",
+ "device_chain.shell.on_click_to_turn_the": "Activé — cliquer pour désactiver l’instrument",
+ "device_chain.shell.preset": "Préréglage : {0}",
+ "device_chain.shell.previous_preset": "Préréglage précédent",
+ "device_insert.a_drum_rack_takes_kits": "Un Drum Rack accepte des kits et des instruments ; charger un préréglage d’instrument sur un pad depuis sa carte.",
+ "device_insert.added_chain": "Chaîne {0} ajoutée",
+ "device_insert.added_on_a_new_audio": "{0} ajouté sur une nouvelle piste audio (piste {1})",
+ "device_insert.added_pad": "Pad {0} ajouté",
+ "device_insert.added_to_track": "{0} ajouté à la piste {1}",
+ "device_insert.added_track": "{0} ajouté (piste {1})",
+ "device_insert.all_16_pads_are_used": "Les 16 pads sont utilisés.",
+ "device_insert.applied_preset": "Préréglage {0} appliqué",
+ "device_insert.cant_go_on_a_track": "{0} ne peut pas aller sur une piste.",
+ "device_insert.changed_instrument_to": "Instrument remplacé par {0}",
+ "device_insert.changed_instrument_to_track": "Instrument remplacé par {0} (piste {1})",
+ "device_insert.couldnt_add_a_track_for": "Impossible d’ajouter une piste pour {0}.",
+ "device_insert.drop_failed": "Échec du dépôt : {0}",
+ "device_insert.drop_midi_files_onto_the": "Déposer des fichiers MIDI sur l’arrangement ou un emplacement de session.",
+ "device_insert.drop_onto_a_track": "Déposer sur une piste.",
+ "device_insert.drop_samples_onto_the_arrangement": "Déposer des échantillons sur l’arrangement.",
+ "device_insert.failed_to_load_effect": "Échec du chargement de l’effet.",
+ "device_insert.kits_are_unavailable": "Les kits ne sont pas disponibles.",
+ "device_insert.loaded": "{0} chargé",
+ "device_insert.loaded_kit": "Kit {0} chargé",
+ "device_insert.loaded_root": "{0} chargé · fondamentale {1}",
+ "device_insert.midi_effects_need_an_instrument": "Les effets MIDI nécessitent une piste d’instrument.",
+ "device_insert.midi_effects_need_an_instrument_2": "Les effets MIDI nécessitent une piste d’instrument : ajouter d’abord un instrument.",
+ "device_insert.presets_are_unavailable": "Les préréglages ne sont pas disponibles.",
+ "device_insert.replaced_with": "Remplacé par {0}",
+ "device_selection.midi_and_audio_effects_go": "Les effets MIDI et audio ne vont dans un même rack qu’avec l’instrument entre eux",
+ "device_selection.select_devices_next_to_each": "Sélectionner des appareils côte à côte pour les grouper",
+ "download_jobs.cancelling": "Annulation…",
+ "download_jobs.installing_failed": "Échec de l’installation de {0} : {1}",
+ "download_jobs.installing_was_cancelled": "L’installation de {0} a été annulée.",
+ "dropout_counter.dropouts": { "one": "{0} décrochage", "other": "{0} décrochages" },
+ "drum_pattern.bars": "Barres",
+ "drum_pattern.click_to_place_shift_click": "clic pour placer · ⇧-clic pour les accents · glisser pour peindre",
+ "drum_pattern.drop_samples_on_the_drum": "Déposer des échantillons sur les pads du Drum Rack dans Appareils, puis les programmer ici pas à pas.",
+ "drum_pattern.no_pads_loaded": "Aucun pad chargé",
+ "drum_pattern.pads": { "one": "{0} pad", "other": "{0} pads" },
+ "drum_pattern.play_and_show_its_velocity": "Jouer {0} · {1} et afficher son couloir de vélocité",
+ "drum_pattern.steps": { "one": "{0} pas", "other": "{0} pas" },
+ "editing.snap_grid.2_bars": "2 mesures",
+ "editing.snap_grid.4_bars": "4 mesures",
+ "editing.snap_grid.auto": "Auto · {0}",
+ "export.16_bit_only": "16 bits uniquement",
+ "export.1_file_mb_offline_render": "≈ 1 fichier · {0:0.0} Mo · rendu hors ligne",
+ "export.add_1_bar_release_tail": "Ajouter une queue de relâchement d’1 mesure",
+ "export.bar_beat_sixteenth_counted_from": "Mesure.temps.double-croche, comptés à partir de 1 — p. ex. 5.1 ou 5.3.2",
+ "export.bit_depth": "Profondeur de bits",
+ "export.custom": "Personnalisé",
+ "export.dither": "Dithering",
+ "export.end": "Fin",
+ "export.export": "Exporter {0}",
+ "export.export_audio": "Exporter l’audio",
+ "export.export_stems": "Exporter les stems",
+ "export.export_wav": "Exporter en WAV",
+ "export.format": "Format",
+ "export.full_song": "Morceau entier",
+ "export.normalize_1_dbtp": "Normaliser à −1 dBTP",
+ "export.not_a_position_type_bar": "Position invalide : saisir mesure.temps, comme 5.1",
+ "export.one_file_per_track_mb": "un fichier par piste · {0:0.0} Mo chacun · rendu hors ligne",
+ "export.one_file_per_track_post": "· un fichier par piste, post-fader",
+ "export.positions_are_bar_beat_sixteenth": "Les positions s’écrivent mesure.temps.double-croche, comptées à partir de 1 comme dans le transport : 5 ou 5.1 est le début de la mesure 5, 5.3 son troisième temps. L’export s’arrête à la position de fin, donc 1 à 5 fait quatre mesures.",
+ "export.quality": "Qualité",
+ "export.sample_rate": "Fréquence d’échantillonnage",
+ "export.the_end_must_be_after": "La fin doit être après le début",
+ "history.add_note": "Ajouter une note…",
+ "history.clean_up_the_history": "Nettoyer l’historique",
+ "history.couldnt_change_the_version": "Impossible de changer de version : {0}",
+ "history.current": "Actuelle",
+ "history.current_version": "Version actuelle",
+ "history.delete_audio_that_only_this": "Supprimer {0} ? L’audio utilisé uniquement par cette version est aussi supprimé du dossier du projet. Cette action est irréversible.",
+ "history.delete_the_selected_versions_and": "Supprimer les versions sélectionnées et l’audio que seules elles utilisent",
+ "history.delete_unnamed_versions": "Supprimer les versions sans nom",
+ "history.delete_unnamed_versions_2": "Supprimer les versions sans nom…",
+ "history.delete_unnamed_versions_n": { "one": "Supprimer {0} version sans nom…", "other": "Supprimer {0} versions sans nom…" },
+ "history.delete_version": "Supprimer la version",
+ "history.delete_version_2": "Supprimer la version…",
+ "history.delete_versions": "Supprimer les versions",
+ "history.delete_versions_and_the_audio": { "one": "Supprimer {0} version et l’audio qu’elle seule utilise ? La version actuelle, la dernière version de chaque branche et toute version nommée, étoilée ou annotée restent. Cette action est irréversible.", "other": "Supprimer {0} versions et l’audio que seules elles utilisent ? La version actuelle, la dernière version de chaque branche et toute version nommée, étoilée ou annotée restent. Cette action est irréversible." },
+ "history.delete_versions_audio_that_only": { "one": "Supprimer {0} version ? L’audio qu’elle seule utilise est aussi supprimé du dossier du projet. Cette action est irréversible.", "other": "Supprimer {0} versions ? L’audio que seules elles utilisent est aussi supprimé du dossier du projet. Cette action est irréversible." },
+ "history.delete_versions_n": { "one": "Supprimer {0} version…", "other": "Supprimer {0} versions…" },
+ "history.deleted_versions": { "one": "{0} version supprimée", "other": "{0} versions supprimées" },
+ "history.each_save_adds_a_version": "Chaque enregistrement ajoute une version ici.",
+ "history.edit_note": "Modifier la note…",
+ "history.freed": "{0} · {1} libérés",
+ "history.its_versions_cant_be_listed": "Ses versions ne peuvent pas être listées tant que le fichier .history/versions.json n’est pas réparé.",
+ "history.name": "Nommer…",
+ "history.name_version": "Nommer la version",
+ "history.no_starred_versions_yet_right": "Aucune version étoilée pour l’instant. Clic droit sur une version puis « Étoiler ».",
+ "history.nota": "Nota {0}",
+ "history.older_versions_take_on_disk": "{0} · les anciennes versions occupent {1} sur le disque",
+ "history.open_as_copy": "Ouvrir comme copie…",
+ "history.open_copy": "Ouvrir une copie",
+ "history.open_this_version_as_a": "Ouvrir cette version comme nouveau projet, en laissant celui-ci tel quel",
+ "history.remove_name": "Retirer le nom",
+ "history.remove_note": "Retirer la note",
+ "history.remove_star": "Retirer l’étoile",
+ "history.save_the_project_to_start": "Enregistrer le projet pour commencer son historique.",
+ "history.saved_by_a_newer_nota": "Enregistré par une version plus récente de Nota — mettre à jour pour l’ouvrir.",
+ "history.show_all_versions": "Afficher toutes les versions",
+ "history.show_starred_versions_only": "Afficher seulement les versions étoilées",
+ "history.star": "Étoiler",
+ "history.switch": "Basculer",
+ "history.switch_the_project_to_this": "Basculer le projet vers cette version",
+ "history.switch_to_another_version_to": "Basculer vers une autre version pour supprimer celle-ci",
+ "history.switch_to_this_version": "Basculer vers cette version",
+ "history.the_current_version_stays": "La version actuelle reste",
+ "history.the_current_version_stays_2": "La version actuelle reste.",
+ "history.the_project_is_at_this": "Le projet est à cette version",
+ "history.version": "Version",
+ "history.version_history_is_turned_off": "L’historique des versions est désactivé dans les Réglages.",
+ "history.version_name": "Nom de la version",
+ "history.version_note": "Note de version",
+ "history.versions": "Versions",
+ "history.versions_n": { "one": "{0} version", "other": "{0} versions" },
+ "history.what_changed_in_this_version": "Qu’est-ce qui a changé dans cette version ?",
+ "kits.drum_kit.couldnt_create_a_drum_rack": "Impossible de créer une piste Drum Rack.",
+ "kits.drum_kit.couldnt_create_a_nota_rhythm": "Impossible de créer une piste Nota Rhythm.",
+ "kits.drum_kit.unknown_drum_kit": "Kit de batterie inconnu.",
+ "lens.nota_lens": "Nota Lens · {0}",
+ "linux_file_dialogs.the_system_file_dialog_answered": "la boîte de dialogue système a répondu sans s’afficher",
+ "linux_file_dialogs.the_system_file_dialog_didnt": "la boîte de dialogue système ne s’est pas ouverte en {0:0} s",
+ "linux_file_dialogs.the_system_file_dialog_failed": "échec de la boîte de dialogue système : {0}",
+ "linux_file_dialogs.using_notas_built_in_file": "Utilisation de la boîte de dialogue de fichiers intégrée de Nota : {0}. Vérifier xdg-desktop-portal et son moteur FileChooser.",
+ "main.adaptive_grid": "Grille adaptative",
+ "main.added_to_slot": "{0} ajouté à l’emplacement",
+ "main.all_return_buses_are_in": "Tous les bus de retour sont utilisés.",
+ "main.arrangement": "Arrangement",
+ "main.asio_driver_couldnt_start_using": "Le pilote ASIO ‘{0}’ n’a pas pu démarrer — WASAPI utilisé. {1}",
+ "main.audio_asio_hz_frames": "Audio : ASIO · {0} · {1:0} Hz · {2} échantillons",
+ "main.audio_device_error": "Erreur du périphérique audio : {0}",
+ "main.audio_driver_settings_changed_frames": "Audio : réglages du pilote modifiés · {0} échantillons",
+ "main.audio_dropout": "⚠ Décrochage audio ({0})",
+ "main.audio_dropouts_since_the_device": "Décrochages audio depuis le démarrage du périphérique : des tampons que Nota n’a pas pu remplir à temps, audibles sous forme de claquements ou de trous. S’ils persistent, augmenter la taille du tampon ou geler les pistes lourdes. Cliquer pour réinitialiser",
+ "main.audio_format.audio_settings": "Réglages audio…",
+ "main.audio_format.buffer_size": "Taille de la mémoire tampon",
+ "main.audio_format.device_default": "Par défaut du périphérique",
+ "main.audio_format.driver_settings": "Réglages du pilote…",
+ "main.audio_format.exclusive_mode_uses_the_devices": "Le mode exclusif utilise le tampon de l’appareil",
+ "main.audio_format.set_in_the_asio_drivers": "À régler dans les réglages du pilote ASIO",
+ "main.audio_format.stop_recording_to_change_it": "Arrêter l’enregistrement pour le modifier",
+ "main.audio_hz": "Audio : {0:0} Hz",
+ "main.audio_hz_frames": "Audio : {0:0} Hz · {1} échantillons",
+ "main.audio_import.failed_to_load": "Échec du chargement de {0}",
+ "main.audio_import.failed_to_load_n": "Échec du chargement de {0} : {1}",
+ "main.audio_import.import_of_cancelled": "Import de {0} annulé",
+ "main.audio_import.importing": "Import de {0}…",
+ "main.audio_import.loop_warped_bpm": "boucle warpée {0} → {1} BPM",
+ "main.audio_import.one_shot_not_warped": "one-shot, non warpé",
+ "main.audio_import.processing": "{0} · Traitement…",
+ "main.audio_import.processing_n": "{0} · Traitement… {1:0} %",
+ "main.audio_import.transposed_st_to": "transposé de {0} st vers {1}",
+ "main.audio_import.warped_to_tempo_bpm": "warpé au tempo ({0:0.0} BPM)",
+ "main.audio_import.warping": "Warp de {0}… {1:0} %",
+ "main.audio_track_arm_it_and": "Piste audio {0} — l’armer puis appuyer sur Rec pour enregistrer l’entrée",
+ "main.auto_arm_selected_track": "Armement automatique de la piste sélectionnée",
+ "main.bass": "Basse",
+ "main.bounce_to_a_linked_audio": "Rendre vers une piste audio liée en dessous et mettre la source en veille",
+ "main.browser.couldnt_delete": "Impossible de supprimer {0}",
+ "main.browser.delete_preset": "Supprimer le préréglage",
+ "main.browser.delete_project": "Supprimer le projet",
+ "main.browser.load_failed": "Échec du chargement : {0}",
+ "main.browser.move_to_the_trash": "Mettre « {0} » à la corbeille ?",
+ "main.browser.moved_to_trash": "{0} mis à la corbeille",
+ "main.browser.nothing_to_save_built_in": "Rien à enregistrer (le synthé intégré n’a pas d’état).",
+ "main.browser.only_plug_in_chain_instruments": "Seuls les instruments à chaîne de plug-ins peuvent être enregistrés comme préréglages.",
+ "main.browser.preset_name": "Nom du préréglage",
+ "main.browser.reveal_failed": "Échec de l’affichage : {0}",
+ "main.browser.save_preset_failed": "Échec de l’enregistrement du préréglage : {0}",
+ "main.browser.saved_preset": "Préréglage {0} enregistré",
+ "main.cancel_the_download": "Annuler le téléchargement",
+ "main.clip_editor_fills_the_window": "L’éditeur de clips remplit la fenêtre",
+ "main.clip_names": "Noms des clips",
+ "main.close_the_drivers_settings_window": "Fermer la fenêtre de réglages du pilote pour appliquer le changement",
+ "main.command_palette": "Palette de commandes…",
+ "main.commands.arrangement_grid": "Grille de l’arrangement : {0}",
+ "main.commands.clip_editor_grid": "Grille de l’éditeur de clips : {0}",
+ "main.commands.envelopes_follow_clips": "Les enveloppes suivent les clips",
+ "main.commands.envelopes_locked_clip_moves_keep": "Enveloppes verrouillées : les déplacements de clips laissent l’automation en place",
+ "main.commands.grouped_tracks": "Pistes groupées",
+ "main.commands.no_notes_outside_the_scale": "Aucune note hors de la gamme",
+ "main.commands.nothing_to_undo": "Rien à annuler",
+ "main.commands.open_a_midi_clip_first": "Ouvrir d’abord un clip MIDI",
+ "main.commands.open_the_session_view_first": "Ouvrir d’abord la vue Session",
+ "main.commands.quantized_notes": "Notes quantifiées",
+ "main.commands.scenes_live_in_the_session": "Les scènes se trouvent dans la vue Session",
+ "main.commands.select_a_clip_first": "Sélectionner d’abord un clip",
+ "main.commands.select_a_clip_or_a": "Sélectionner d’abord un clip ou une plage",
+ "main.commands.select_a_time_range_first": "Sélectionner d’abord une plage de temps",
+ "main.commands.select_a_track_first": "Sélectionner d’abord une piste",
+ "main.commands.select_clips_or_a_range": "Sélectionner d’abord des clips ou une plage",
+ "main.commands.select_tracks_first": "Sélectionner d’abord des pistes",
+ "main.commands.select_two_or_more_midi": "Sélectionner au moins deux clips MIDI",
+ "main.commands.selecting_a_track_leaves_the": "Sélectionner une piste ne modifie pas l’armement",
+ "main.commands.selecting_an_instrument_track_arms": "Sélectionner une piste d’instrument l’arme",
+ "main.commands.snap_off": "Magnétisme désactivé",
+ "main.commands.this_track_cant_be_frozen": "Cette piste ne peut pas être gelée",
+ "main.commands.track_headers_on_the_left": "En-têtes de piste à gauche",
+ "main.commands.ungrouped": "Dégroupé",
+ "main.connect_phone": "Connecter un téléphone…",
+ "main.convert.analysing": "Analyse…",
+ "main.convert.building_pads": "Création des pads…",
+ "main.convert.convert_failed": "Échec de la conversion : {0}",
+ "main.convert.converted_harmony_notes_new_track": "Harmonie convertie : {0} notes → nouvelle piste {1}",
+ "main.convert.converted_hits": "{0} frappes converties",
+ "main.convert.converted_melody_notes_new_track": "Mélodie convertie : {0} notes → nouvelle piste {1}",
+ "main.convert.converted_notes_new_track": "{0} converti : {1} notes → nouvelle piste {2}",
+ "main.convert.detecting_harmony": "Détection de l’harmonie…",
+ "main.convert.detecting_hits": "Détection des frappes…",
+ "main.convert.detecting_pitch": "Détection de la hauteur…",
+ "main.convert.detecting_transients": "Détection des transitoires…",
+ "main.convert.listening_for_notes": "À l’écoute des notes…",
+ "main.convert.new_drum_rack_track": "{0} → nouvelle piste Drum Rack {1}",
+ "main.convert.no_drum_hits_found": "Aucune frappe de batterie trouvée.",
+ "main.convert.no_found": "Aucun {0} trouvé.",
+ "main.convert.no_harmony_found": "Aucune harmonie trouvée.",
+ "main.convert.no_melody_found": "Aucune mélodie trouvée.",
+ "main.convert.nothing_to_slice": "Rien à découper.",
+ "main.convert.sliced_into_pads": "Découpé en {0} pads",
+ "main.convert.slicing_pads": "Découpe des pads… {0}",
+ "main.convert.that_converter_isnt_available_yet": "Ce convertisseur n’est pas encore disponible.",
+ "main.convert.this_clip_has_no_audio": "Ce clip n’a pas d’audio à convertir.",
+ "main.convert_melody_and_convert_harmony": "« Convertir la mélodie » et « Convertir l’harmonie » utilisent désormais le modèle d’IA.",
+ "main.convert_to_midi": "Convertir en MIDI",
+ "main.copied_range": "Plage copiée",
+ "main.copied_track_s": "Piste(s) copiée(s)",
+ "main.copy_clips_to_session_arrangement": "Copier les clips vers Session / Arrangement",
+ "main.couldnt_freeze_this_track": "Impossible de geler cette piste.",
+ "main.cut_range": "Plage coupée",
+ "main.cut_track_s": "Piste(s) coupée(s)",
+ "main.deleted_clip_s": "Clip(s) supprimé(s)",
+ "main.deleted_track_s": "Piste(s) supprimée(s)",
+ "main.detail.audio": "Audio ",
+ "main.detail.back_to_the_split_f": "Retour à la vue partagée (⌘⇧F)",
+ "main.detail.clip_editor_every_clip_on": "Éditeur de clips : tous les clips de la piste",
+ "main.detail.clip_editor_one_clip": "Éditeur de clips : un seul clip",
+ "main.detail.group": "Groupe {0}",
+ "main.detail.in": "Entrée ",
+ "main.detail.inst": "Inst ",
+ "main.detail.midi_from": "MIDI depuis ",
+ "main.detail.monitor_in": "Écoute entrée",
+ "main.detail.pdc_ms": "PDC {0:0.0} ms",
+ "main.detail.select_a_clip_to_edit": "Sélectionner un clip pour le modifier.",
+ "main.detail.select_a_midi_clip_on": "Sélectionner un clip MIDI sur une piste Drum Rack pour le programmer pas à pas.",
+ "main.detail.the_clip_editor_is_in": "L’éditeur de clips est dans sa propre fenêtre",
+ "main.detail.track_clip": "Clip de la piste {0}",
+ "main.detail.track_scene": "Piste {0} · Scène {1}",
+ "main.detail_window.select_a_clip_in_the": "Sélectionner un clip dans l’arrangement pour le modifier ici",
+ "main.device_moves.cant_take": "« {0} » ne peut pas accepter {1}.",
+ "main.device_moves.copied_to": "{0} copié vers {1}",
+ "main.device_moves.couldnt_copy": "Impossible de copier {0}.",
+ "main.device_moves.couldnt_move": "Impossible de déplacer {0}.",
+ "main.device_moves.cut_deleted": "{0} coupé — {1} supprimé",
+ "main.device_moves.delete_track": "Supprimer la piste",
+ "main.device_moves.delete_track_the_track_and": "Supprimer la piste « {0} » ? La piste et ses {1} appareils sélectionnés seront supprimés.",
+ "main.device_moves.deleted": " · {0} supprimé",
+ "main.device_moves.deleted_n": "{0} supprimé",
+ "main.device_moves.has_clips_delete_the_track": "« {0} » contient des clips. Supprimer la piste avec ses clips ?",
+ "main.device_moves.modulation_links_left_on": " · liaisons de modulation restantes sur {0}",
+ "main.device_moves.move": "Déplacer",
+ "main.device_moves.move_devices_to_and_delete": "Déplacer {0} appareils vers « {1} » et supprimer « {2} » ?",
+ "main.device_moves.move_to_and_delete_with": "Déplacer {0} vers « {1} » et supprimer « {2} » avec ses clips ?",
+ "main.device_moves.moved_devices_to": "{0} appareils déplacés vers {1}",
+ "main.device_moves.moved_devices_to_couldnt_move": "{0} appareils déplacés vers {1} · {2} n’ont pas pu être déplacés",
+ "main.device_moves.moved_to": "{0} déplacé vers {1}",
+ "main.device_moves.sidechain_cleared": " · sidechain supprimé",
+ "main.devices": "Appareils",
+ "main.dnd.couldnt_add_to_the_rack": "Impossible d’ajouter {0} au rack.",
+ "main.dnd.drop_effects_onto_a_column": "Déposer des effets sur une colonne.",
+ "main.dnd.drop_failed": "Échec du dépôt : {0}",
+ "main.dnd.drop_samples_and_midi_files": "Déposer des échantillons et des fichiers MIDI sur un emplacement.",
+ "main.dnd.drop_samples_onto_audio_slots": "Déposer des échantillons sur les emplacements audio.",
+ "main.done": "Terminé",
+ "main.downloads.dismiss": "Ignorer",
+ "main.downloads.open_settings_downloads": "Ouvrir Réglages → Téléchargements",
+ "main.drums": "Batterie",
+ "main.dsp_caps": "DSP {0}%",
+ "main.dsp_load_of_the_audio": "Charge DSP : {0} du temps de tampon audio — les décrochages commencent près de 100 %",
+ "main.duplicate_clip": "Dupliquer le clip",
+ "main.duplicated_track_s": "Piste(s) dupliquée(s)",
+ "main.exit": "Quitter",
+ "main.export_audio": "Exporter de l’audio…",
+ "main.files.audio": "Audio {0}",
+ "main.files.export": "Exporter",
+ "main.files.export_failed": "Échec de l’export : {0}",
+ "main.files.export_master_to": "Exporter le master en {0}",
+ "main.files.export_stems_to_folder": "Exporter les stems dans un dossier",
+ "main.files.exported": "{0} exporté",
+ "main.files.exported_stems": { "one": "{0} stem exporté", "other": "{0} stems exportés" },
+ "main.files.exporting": "Export…",
+ "main.files.exporting_n": "Export de {0}… {1:0} %",
+ "main.files.exporting_stems": "Export des stems…",
+ "main.files.import_audio": "Importer de l’audio",
+ "main.files.new_project": "Nouveau projet.",
+ "main.files.nota": "Nota — {0}",
+ "main.files.nota_project": "Projet Nota",
+ "main.files.nothing_to_export_the_arrangement": "Rien à exporter — l’arrangement est vide.",
+ "main.files.open_failed": "Échec de l’ouverture : {0}",
+ "main.files.open_nota_project_nota_folder": "Ouvrir un projet Nota (dossier .nota)",
+ "main.files.open_project": "Ouvrir un projet",
+ "main.files.opened": "{0} ouvert",
+ "main.files.opened_item_s_downgraded": "{0} ouvert — {1} élément(s) dégradé(s) : {2}",
+ "main.files.preparing_warped_clips": "Préparation des clips warpés…",
+ "main.files.preparing_warped_clips_n": "Préparation des clips warpés… {0:0} %",
+ "main.files.save_failed": "Échec de l’enregistrement : {0}",
+ "main.files.save_nota_project": "Enregistrer le projet Nota",
+ "main.files.save_your_changes_before_opening": "Enregistrer les modifications avant d’ouvrir un autre projet ?",
+ "main.files.save_your_changes_before_starting": "Enregistrer les modifications avant de commencer un nouveau projet ?",
+ "main.files.saved": "{0} enregistré",
+ "main.files.saved_unsupported_item_s_skipped": "{0} enregistré — {1} élément(s) non pris en charge ignoré(s) : {2}",
+ "main.files.unsupported_file_location": "Emplacement de fichier non pris en charge.",
+ "main.files.unsupported_project_location": "Emplacement de projet non pris en charge.",
+ "main.files.untitled": "Sans titre",
+ "main.fill_the_window_with_the": "Remplir la fenêtre avec l’éditeur de clips (⌘⇧F)",
+ "main.flatten": "Aplatir",
+ "main.flatten_remove_source": "Aplatir (supprimer la source)",
+ "main.flatten_track": "Aplatir la piste",
+ "main.follow_is_paused_while_you": "Le suivi est en pause pendant la consultation d’un autre endroit · P ou un clic ici le reprend",
+ "main.follow_paused_press_p_to": "Suivi en pause · appuyer sur P pour revenir à la tête de lecture",
+ "main.follow_playhead": "Suivre la tête de lecture",
+ "main.follow_playhead_off": "Suivi de la tête de lecture désactivé",
+ "main.following_the_playhead": "Suivi de la tête de lecture",
+ "main.freeze.discard_edits": "Abandonner les modifications",
+ "main.freeze.done_re_freeze": "Terminé — geler à nouveau",
+ "main.freeze.edit_source": "Modifier la source",
+ "main.freeze.flatten_failed": "Échec de l’aplatissement : {0}",
+ "main.freeze.flatten_replaces_this_tracks_instrument": "Aplatir remplace l’instrument, le MIDI et les appareils de cette piste par un seul clip audio du son gelé. ",
+ "main.freeze.flatten_to_audio_track": "Aplatir en piste audio",
+ "main.freeze.freeze_failed": "Échec du gel : {0}",
+ "main.freeze.freeze_the_track_first_then": "Geler d’abord la piste, puis l’aplatir.",
+ "main.freeze.freeze_track": "Geler la piste",
+ "main.freeze.freeze_tracks": "Geler {0} pistes",
+ "main.freeze.freezing_track": "Gel de la piste…",
+ "main.freeze.freezing_track_n": "Gel de la piste… {0:0} %",
+ "main.freeze.freezing_track_of": "Gel de la piste {0} sur {1}… {2:0} %",
+ "main.freeze.freezing_tracks": "Gel des pistes…",
+ "main.freeze.froze_of_tracks": "{0} pistes sur {1} gelées.",
+ "main.freeze.frozen": "Gelée",
+ "main.freeze.this_cant_be_undone_continue": "Cette action est irréversible. Continuer ?",
+ "main.freeze.track_flattened_to_audio": "Piste aplatie en audio.",
+ "main.freeze.track_frozen_its_devices_are": "Piste gelée — ses appareils sont inactifs jusqu’au dégel.",
+ "main.freeze.track_unfrozen": "Piste dégelée.",
+ "main.freeze.tracks_frozen_their_devices_are": "{0} pistes gelées — leurs appareils sont inactifs jusqu’au dégel.",
+ "main.freeze.tracks_unfrozen": "{0} pistes dégelées.",
+ "main.freeze.unfreeze_track": "Dégeler la piste",
+ "main.freeze.unfreeze_tracks": "Dégeler {0} pistes",
+ "main.freeze_the_track_to_audio": "Geler la piste en audio pour libérer du CPU (clic droit pour aplatir)",
+ "main.gamepad.gamepad_octave_c": "Octave manette : C{0}",
+ "main.gamepad.octave": "Octave +",
+ "main.gamepad.octave_2": "Octave −",
+ "main.gamepad.velocity": "Vélocité +",
+ "main.gamepad.velocity_2": "Vélocité −",
+ "main.hand_overridden_controls_back_to": "Rendre les commandes modifiées à leur automation",
+ "main.help": "Aide",
+ "main.hide_the_mixer": "Masquer le mixeur",
+ "main.history.choose_a_new_name_for": "Choisir un nouveau nom pour la copie — elle ne peut pas remplacer un projet existant.",
+ "main.history.couldnt_open_the_version": "Impossible d’ouvrir la version : {0}",
+ "main.history.couldnt_switch_version": "Impossible de changer de version : {0}",
+ "main.history.open_version_as_a_new": "Ouvrir la version comme nouveau projet",
+ "main.history.open_version_as_copy": "Ouvrir la version comme copie",
+ "main.history.opened_as": "{0} ouvert comme {1}",
+ "main.history.save_version": "Enregistrer la version",
+ "main.history.save_your_changes_as_a": "Enregistrer les modifications comme nouvelle version avant de changer ?",
+ "main.history.save_your_changes_before_opening": "Enregistrer les modifications avant d’ouvrir la copie ?",
+ "main.history.switch_version": "Changer de version",
+ "main.history.switched_to": "Passage à {0}",
+ "main.history.the_version": "la version “{0}” ({1})",
+ "main.history.the_version_of": "la version du {0}",
+ "main.history.version_history_is_turned_off": "L’historique des versions est désactivé dans les Réglages.",
+ "main.history.version_history_turned_off_freed": "Historique des versions désactivé · {0} libérés",
+ "main.history.version_not_recorded": " · version non enregistrée : {0}",
+ "main.history.what_changed_in_this_version": "Qu’est-ce qui a changé dans cette version ?",
+ "main.import_audio": "Importer de l’audio…",
+ "main.imported": "{0} importé",
+ "main.input.copied_automation": "Automation copiée",
+ "main.input.copied_clip_s": "Clip(s) copié(s)",
+ "main.input.cut_automation": "Couper l’automation",
+ "main.input.cut_clip_s": "Clip(s) coupé(s)",
+ "main.input.deleted_automation": "Automation supprimée",
+ "main.input.deleted_range": "Plage supprimée",
+ "main.input.keyboard_octave_c": "Octave clavier : C{0}",
+ "main.input.keyboard_velocity": "Vélocité clavier : {0}",
+ "main.input.pasted_automation": "Automation collée",
+ "main.input.pasted_clip_s": "Clip(s) collé(s)",
+ "main.insert_scene": "Insérer une scène",
+ "main.instrument_track_synth": "Piste d’instrument {0} (synthé)",
+ "main.key": "Tonalité",
+ "main.leave_edit_mode_without_re": "Quitter le mode édition sans regeler",
+ "main.live_freeze": "Gel en direct",
+ "main.live_freeze.editing_the_frozen_source_press": "Modification de la source gelée — appuyer sur Terminé pour geler à nouveau, ou sur Abandonner.",
+ "main.live_freeze.failed": "Échec de {0} : {1}",
+ "main.live_freeze.flatten_keeps_the_frozen_audio": "Aplatir conserve la piste audio gelée et supprime définitivement sa source (instrument, MIDI et appareils). Continuer ?",
+ "main.live_freeze.flattened_the_frozen_audio_is": "Aplati — l’audio gelé est maintenant une piste ordinaire.",
+ "main.live_freeze.left_edit_mode_the_frozen": "Mode d’édition quitté (l’audio gelé n’a pas été modifié).",
+ "main.live_freeze.live_freeze_failed": "Échec du gel en direct : {0}",
+ "main.live_freeze.live_freeze_link_removed_its": "Lien de gel en direct supprimé — sa piste a été supprimée.",
+ "main.live_freeze.re_freeze_failed": "Échec du nouveau gel : {0}",
+ "main.live_freeze.re_freeze_failed_the_source": "Échec du nouveau gel — la source est toujours active.",
+ "main.live_freeze.track_live_frozen_press_edit": "Piste gelée en direct — appuyer sur Modifier pour la changer, puis sur Terminé.",
+ "main.live_freeze.unfrozen_the_source_is_live": "Dégelée — la source est de nouveau active.",
+ "main.lock_envelopes": "Verrouiller les enveloppes",
+ "main.loop_record_overdub_replace": "Enregistrement en boucle : superposition / remplacement",
+ "main.loop_recording_overdub_adds_every": "Enregistrement en boucle : Superposer ajoute chaque passage · Remplacer garde le dernier passage (⌘⇧R)",
+ "main.loop_the_range_set_on": "Mettre en boucle la plage définie sur la règle",
+ "main.map_a_controller_click_a": "Assigner un contrôleur : cliquer sur une commande, puis bouger un bouton du contrôleur",
+ "main.master_volume": "Volume master",
+ "main.measuring": "mesure…",
+ "main.menu.clip_names_every_clip": "Noms des clips : tous les clips",
+ "main.menu.clip_names_first_of_a": "Noms des clips : premier d’une série",
+ "main.menu.clip_names_none": "Noms des clips : aucun",
+ "main.menu.consolidated": "Consolidé",
+ "main.menu.copied_clip": "Clip copié",
+ "main.menu.copied_notes": "Notes copiées",
+ "main.menu.cut_clip": "Clip coupé",
+ "main.menu.cut_notes": "Notes coupées",
+ "main.menu.deleted_notes": "Notes supprimées",
+ "main.menu.duplicated_automation": "Automation dupliquée",
+ "main.menu.duplicated_clip_s": "Clip(s) dupliqué(s)",
+ "main.menu.duplicated_notes": "Notes dupliquées",
+ "main.menu.duplicated_range": "Plage dupliquée",
+ "main.menu.duplicated_time": "Temps dupliqué",
+ "main.menu.inserted_silence": "Silence inséré",
+ "main.menu.loop_set_to_selection": "Boucle réglée sur la sélection",
+ "main.menu.not_implemented_yet": "Pas encore disponible.",
+ "main.menu.nothing_after_the_selection_to": "Rien à déplacer après la sélection.",
+ "main.menu.nothing_to_duplicate_in_the": "Rien à dupliquer dans la plage sélectionnée.",
+ "main.menu.nothing_to_redo": "Rien à rétablir.",
+ "main.menu.nothing_to_undo": "Rien à annuler.",
+ "main.menu.overview_strip_hidden": "Bandeau d’aperçu masqué",
+ "main.menu.overview_strip_shown": "Bandeau d’aperçu affiché",
+ "main.menu.pasted_clip": "Clip collé",
+ "main.menu.pasted_notes": "Notes collées",
+ "main.menu.scenes_live_in_the_session": "Les scènes se trouvent dans la vue Session.",
+ "main.menu.sections_lane_hidden": "Couloir des sections masqué",
+ "main.menu.sections_lane_shown": "Couloir des sections affiché",
+ "main.menu.select_a_clip_first": "Sélectionner d’abord un clip.",
+ "main.menu.select_a_clip_or_a": "Sélectionner un clip ou une scène à copier dans l’arrangement.",
+ "main.menu.select_a_range_or_a": "Sélectionner une plage, ou un clip que la tête de lecture traverse.",
+ "main.menu.select_a_range_or_clips": "Sélectionner une plage ou des clips à consolider.",
+ "main.menu.select_a_time_range_first": "Sélectionner d’abord une plage de temps.",
+ "main.menu.select_clips_to_copy_to": "Sélectionner des clips à copier dans la session.",
+ "main.menu.split_at_selection": "Découpé à la sélection",
+ "main.menu.split_clip_s_at_playhead": "Clip(s) découpé(s) à la tête de lecture",
+ "main.menu_keys.show_parameter_automation_lanes_a": "Afficher les couloirs d’automation des paramètres (⌘⇧A)",
+ "main.midi_error": "Erreur MIDI : {0}",
+ "main.midi_import.couldnt_read": "Impossible de lire {0} : {1}",
+ "main.midi_import.drop_midi_files_onto_instrument": "Déposer des fichiers MIDI sur les emplacements d’instruments.",
+ "main.midi_import.has_no_notes": "{0} ne contient aucune note.",
+ "main.midi_import.imported_parts": "{0} importé ({1} parties)",
+ "main.midi_inputs_updated": "Entrées MIDI mises à jour.",
+ "main.missing_plugins.install": "Installer",
+ "main.missing_plugins.installed_reopen_the_project_to": "{0} installé — rouvrir le projet pour l’utiliser.",
+ "main.missing_plugins.installed_reopen_the_project_to_n": "{0} installés — rouvrir le projet pour les utiliser.",
+ "main.missing_plugins.installing_plugins": "Installation des plug-ins…",
+ "main.missing_plugins.missing_plugins": "Plug-ins manquants",
+ "main.missing_plugins.scanning_plugins": "Analyse des plug-ins…",
+ "main.missing_plugins.this_project_uses_which_arent": "Ce projet utilise {0}, qui ne sont pas installés. Ils sont open source et disponibles dans le registre de plug-ins de Nota. Les installer et rouvrir le projet ?",
+ "main.missing_plugins.this_project_uses_which_isnt": "Ce projet utilise {0}, qui n’est pas installé. Il est open source et disponible dans le registre de plug-ins de Nota. L’installer et rouvrir le projet ?",
+ "main.mixer_in_its_own_window": "Mixeur dans sa propre fenêtre",
+ "main.mosaic.created_presets_loaded": "{0} préréglages créés · {1} chargé",
+ "main.mosaic.created_the_preset": "Préréglage {0} créé",
+ "main.narrow_grid": "Réduire la grille",
+ "main.new": "Nouveau",
+ "main.no_audio_output_could_be": "Aucune sortie audio n’a pu être ouverte — Nota fonctionne sans son. Choisir un périphérique dans Réglages → Audio",
+ "main.no_audio_output_device_opened": "Aucun périphérique de sortie audio ouvert — Nota fonctionne en silence. Choisir un périphérique dans Réglages → Audio",
+ "main.no_key": "Aucune tonalité",
+ "main.no_project_key": "Aucune tonalité de projet",
+ "main.not_now": "Pas maintenant",
+ "main.nota_process_cpu_audio_interface": "CPU du processus Nota : {0} (audio, interface, plug-ins)",
+ "main.note_audition_off": "Écoute des notes désactivée",
+ "main.note_audition_on": "Écoute des notes activée",
+ "main.nothing_to_freeze_the_arrangement": "Rien à geler — l’arrangement est vide.",
+ "main.off_remote": "Off",
+ "main.open": "Ouvrir…",
+ "main.open_a_clip_in_the": "Ouvrir d’abord un clip dans l’éditeur de clips",
+ "main.open_devices_and_clip_in": "Ouvrir les appareils et le clip dans une fenêtre séparée",
+ "main.open_the_mixer_in_a": "Ouvrir le mixeur dans une fenêtre",
+ "main.overdub": "Superposer",
+ "main.pad": "Pad",
+ "main.palette.added_to_the_canvas_connect": "{0} ajouté au canevas {1} — le relier à un paramètre",
+ "main.palette.couldnt_add": "Impossible d’ajouter {0}.",
+ "main.palette.not_available": "Indisponible",
+ "main.palette.opened_in_devices": "{0} ouvert dans Appareils",
+ "main.palette.selected": "{0} sélectionné",
+ "main.paste_bounced.click_an_audio_track_to": "Cliquer une piste audio pour y coller l’audio rendu.",
+ "main.paste_bounced.couldnt_paste_the_bounced_audio": "Impossible de coller l’audio rendu.",
+ "main.paste_bounced.couldnt_render_this_track": "Impossible de rendre cette piste.",
+ "main.paste_bounced.paste_bounced_audio_failed": "Échec du collage de l’audio rendu : {0}",
+ "main.paste_bounced.paste_bounced_audio_takes_a": "Coller l’audio rendu demande une plage sur une seule piste.",
+ "main.paste_bounced.pasted_bounced_audio": "Audio rendu collé",
+ "main.paste_bounced.select_a_time_range_first": "Sélectionner d’abord une plage de temps (Maj+glisser), puis la coller rendue sur une piste audio.",
+ "main.paste_bounced.the_selected_range_has_no": "La plage sélectionnée ne contient aucune piste audio ou d’instrument à rendre.",
+ "main.pasted_track_s": "Piste(s) collée(s)",
+ "main.play_and_control_nota_from": "Jouer et piloter Nota depuis un téléphone",
+ "main.play_pause": "Lecture / pause",
+ "main.play_space": "Lire (Space)",
+ "main.project_key": "Tonalité du projet : {0}",
+ "main.re_enable": "Réactiver",
+ "main.re_freeze_the_source_and": "Regeler la source et la remettre en veille",
+ "main.recent.added_track": "{0} ajouté (piste {1})",
+ "main.recent.is_no_longer_installed": "{0} n’est plus installé.",
+ "main.recent_menu.no_recent_projects": "Aucun projet récent",
+ "main.recent_menu.open_recent": "Ouvrir un projet récent",
+ "main.record_r": "Lancer l’enregistrement (⌘R)",
+ "main.recovery.discard": "Ignorer",
+ "main.recovery.do_you_really_want_to": "Quitter sans enregistrer les modifications ?",
+ "main.recovery.just_now": "à l’instant",
+ "main.recovery.nota_didnt_shut_down_cleanly": "Nota ne s’est pas fermé correctement. Récupérer le travail non enregistré de {0} ?",
+ "main.recovery.recover": "Récupérer",
+ "main.recovery.recover_project": "Récupérer le projet",
+ "main.recovery.recovered_unsaved_work": "Travail non enregistré récupéré.",
+ "main.recovery.unsaved_changes": "Modifications non enregistrées",
+ "main.recovery.unsaved_changes_n": "modifications non enregistrées · {0}",
+ "main.redo": "Rétablir",
+ "main.remote": "Télécommande",
+ "main.remote.phones_connected": { "one": "{0} téléphone connecté", "other": "{0} téléphones connectés" },
+ "main.remote.remote_is_on_scan_the": "Télécommande activée · scanner le code avec un téléphone",
+ "main.remote.undo_from_a_phone": "Annuler (depuis un téléphone)",
+ "main.rendering": "Rendu…",
+ "main.rendering_n": "Rendu… {0:0} %",
+ "main.replace": "Remplacer",
+ "main.return_added_add_an_effect": "Retour {0} ajouté — ajouter un effet, puis augmenter les envois des pistes",
+ "main.sample_rate_and_buffer_size": "Fréquence d’échantillonnage et taille du tampon. Cliquer pour changer la taille du tampon",
+ "main.save": "Enregistrer",
+ "main.save_as": "Enregistrer sous…",
+ "main.save_version_with_note": "Enregistrer une version avec note…",
+ "main.scroll_the_arrangement_to_keep": "Faire défiler l’arrangement pour garder la tête de lecture visible",
+ "main.select_a_clip_to_edit": "Sélectionner un clip pour l’éditer",
+ "main.session": "Session",
+ "main.set_the_project_key_samples": "Régler la tonalité du projet : les échantillons peuvent y être transposés",
+ "main.set_the_tempo_drag_or": "Régler le tempo : glisser, ou double-clic pour le saisir",
+ "main.set_the_time_signature_drag": "Régler la signature rythmique : glisser chaque champ",
+ "main.settings": "Réglages…",
+ "main.show_playhead": "Afficher la tête de lecture",
+ "main.snap_clips_to_the_grid": "Caler les clips sur la grille (maintenir Alt pour déplacer librement)",
+ "main.snap_off_clips_position_freely": "Magnétisme désactivé — les clips se placent librement",
+ "main.snap_on": "Magnétisme activé",
+ "main.snap_to_grid": "Magnétisme sur la grille",
+ "main.split_at_playhead": "Découper à la tête de lecture",
+ "main.stems.download_cancelled": "Téléchargement annulé.",
+ "main.stems.downloading": "Téléchargement…",
+ "main.stems.is_waiting_for_its_model": "{0} attend son modèle — il se télécharge (voir la barre d’état).",
+ "main.stems.isnt_available_on_this_computer": "{0} n’est pas disponible sur cet ordinateur.",
+ "main.stems.preparing_audio": "Préparation de l’audio…",
+ "main.stems.separate_stems": "Séparer les stems",
+ "main.stems.separate_stems_cancelled": "Séparation des stems annulée.",
+ "main.stems.separate_stems_failed": "Échec de la séparation des stems : {0}",
+ "main.stems.separated_into_drums_bass_other": "« {0} » séparé en batterie, basse, autres et voix.",
+ "main.stems.the_model": "le modèle {0}",
+ "main.stems.the_model_and_the_ai": "le modèle {0} et le moteur d’IA sur lequel il tourne",
+ "main.stems.uses_an_ai_model_that": "{0} utilise un modèle d’IA qui s’exécute sur cet ordinateur. Télécharger {1} ({2}) une fois ? ",
+ "main.stems.you_can_remove_it_later": "Il pourra être supprimé plus tard dans Réglages → Téléchargements → Modèles d’IA.",
+ "main.step_the_selected_midi_clip": "Programmer pas à pas le clip MIDI sélectionné d’une piste Drum Rack",
+ "main.stop_return": "Arrêter (Return)",
+ "main.strips": "Tranches",
+ "main.switch_between_bars_and_time": "Basculer entre mesures et temps",
+ "main.tap": "Tap",
+ "main.tap_the_beat_to_set": "Taper le rythme pour régler le tempo",
+ "main.tempo_bpm_tapped": "Tempo : {0} BPM (tapé)",
+ "main.toggle_browser": "Afficher/masquer le navigateur",
+ "main.toggle_detail_panel": "Afficher/masquer le panneau de détail",
+ "main.toggle_full_screen": "Activer/quitter le plein écran",
+ "main.toggle_overview": "Afficher/masquer l’aperçu",
+ "main.toggle_sections": "Afficher/masquer les sections",
+ "main.toggled_clip_s": "État des clips inversé",
+ "main.track_headers_on_the_right": "En-têtes de piste à droite",
+ "main.triplet_grid": "Grille en triolets",
+ "main.turn_the_metronome_on_or": "Activer ou désactiver le métronome (⌘M) · clic droit pour le décompte",
+ "main.updates.check_for_updates": "Rechercher des mises à jour",
+ "main.updates.checking_for_updates": "Recherche de mises à jour…",
+ "main.updates.couldnt_reach_github_to_check": "Impossible de joindre GitHub pour rechercher une version plus récente de Nota. Vérifier la connexion Internet, puis réessayer.",
+ "main.updates.download_it_from_the_release": " Le télécharger depuis la page de la version.",
+ "main.updates.download_nota": "Télécharger Nota {0}…",
+ "main.updates.hide_it_still_installs_when": "Masquer — l’installation se fera quand même à la fermeture",
+ "main.updates.later": "Plus tard",
+ "main.updates.nota_downloads_it_here_and": " Nota le télécharge ici et l’installe au redémarrage ou à la fermeture.",
+ "main.updates.nota_is_available": "Nota {0} est disponible",
+ "main.updates.nota_is_downloaded_click_to": "Nota {0} est téléchargé. Cliquer pour redémarrer maintenant — ou il s’installera à la prochaine fermeture.",
+ "main.updates.nota_is_out_you_have": "Nota {0} est disponible — la version installée est la {1}.",
+ "main.updates.nota_is_ready_to_install": "Nota {0} est prêt à être installé. Redémarrer Nota pour terminer la mise à jour — ou il s’installera à la prochaine fermeture.",
+ "main.updates.release_notes": "Notes de version",
+ "main.updates.restart_now": "Redémarrer maintenant",
+ "main.updates.restart_to_update_to_nota": "Redémarrer pour passer à Nota {0}",
+ "main.updates.the_update_didnt_download": "La mise à jour n’a pas pu être téléchargée",
+ "main.updates.update_available": "Mise à jour disponible",
+ "main.updates.update_to_nota": "Mettre à jour vers Nota {0}",
+ "main.updates.you_have_click_to_update": "La version installée est {0}. Cliquer pour mettre à jour ou lire les notes de version.",
+ "main.updates.youre_up_to_date_nota": "Nota est à jour : la version {0} est la plus récente.",
+ "main.view": "Affichage",
+ "main.view_release_notes": "Voir les notes de version",
+ "main.wake_the_frozen_source_to": "Réveiller la source gelée pour l’éditer (clic droit pour dégeler ou aplatir)",
+ "main.wasapi_exclusive_unavailable_using_shared": "WASAPI exclusif indisponible — mode partagé utilisé",
+ "main.widen_grid": "Élargir la grille",
+ "menu.mac.hide": "Masquer {0}",
+ "menu.mac.hide_others": "Masquer les autres",
+ "menu.mac.quit": "Quitter {0}",
+ "menu.mac.show_all": "Tout afficher",
+ "menu.reveal_in_finder": "Afficher dans le Finder",
+ "menu.show_in_explorer": "Afficher dans l’Explorateur",
+ "menu.show_in_file_manager": "Afficher dans le gestionnaire de fichiers",
+ "midi.accent": "Accent",
+ "midi.cycles": "Cycles",
+ "midi.down": "Bas",
+ "midi.generators.a_step_sequencer_in_scale": "Un séquenceur pas à pas en degrés de gamme — choisir un contour et une étendue, obtenir une ligne.",
+ "midi.generators.accent_vel": "Vélocité d’accent",
+ "midi.generators.accents": "Accents",
+ "midi.generators.arch": "Arche",
+ "midi.generators.cluster": "Cluster",
+ "midi.generators.contour": "Contour",
+ "midi.generators.density": "Densité",
+ "midi.generators.drop_2": "Drop 2",
+ "midi.generators.euclidean": "Euclidien",
+ "midi.generators.exponential": "Exponentielle",
+ "midi.generators.grows_every_note_into_a": "Transforme chaque note en accord, voicé comme on le jouerait.",
+ "midi.generators.lays_down_a_pattern_that": "Pose un motif qui s’appuie sur les temps forts, aussi dense qu’on le demande.",
+ "midi.generators.learns_the_clips_intervals_and": "Apprend les intervalles et le rythme du clip, puis écrit une nouvelle prise dans le même style.",
+ "midi.generators.logarithmic": "Logarithmique",
+ "midi.generators.melodic_steps": "Pas mélodiques",
+ "midi.generators.pitch_var": "Variation de hauteur",
+ "midi.generators.power": "Alimentation",
+ "midi.generators.pulses": "Impulsions",
+ "midi.generators.random_walk": "Marche aléatoire",
+ "midi.generators.rhythm": "Rythme",
+ "midi.generators.rhythm_var": "Variation de rythme",
+ "midi.generators.root": "Fondamentale",
+ "midi.generators.seed": "Graine",
+ "midi.generators.spread": "Spread",
+ "midi.generators.spreads_a_number_of_hits": "Répartit un nombre de frappes aussi régulièrement que le permet un nombre de pas.",
+ "midi.generators.square": "Carré",
+ "midi.generators.stacks": "Piles",
+ "midi.generators.traces_a_curve_across_the": "Trace une courbe sur le clip et dépose une note chaque fois qu’elle croise un pas.",
+ "midi.generators.valley": "Vallée",
+ "midi.generators.variation": "Variation",
+ "midi.generators.vel_falloff": "Atténuation de vél.",
+ "midi.generators.vel_follows": "Vél. suit",
+ "midi.generators.vel_var": "Var. de vél.",
+ "midi.generators.voices": "Voix",
+ "midi.generators.voicing": "Voicing",
+ "midi.generators.zigzag": "Zigzag",
+ "midi.in_scale": "Dans la gamme",
+ "midi.interval": "Intervalle",
+ "midi.octaves": "Octaves",
+ "midi.phase": "Phase",
+ "midi.ramp_down": "Rampe descendante",
+ "midi.ramp_up": "Rampe ascendante",
+ "midi.random": "Aléatoire",
+ "midi.rate": "Rate",
+ "midi.rotate": "Rotation",
+ "midi.s_curve": "Courbe en S",
+ "midi.shape": "Forme",
+ "midi.sine": "Sine",
+ "midi.steps": "Pas",
+ "midi.tool.on": "On",
+ "midi.transforms.alternate": "Alterner",
+ "midi.transforms.amount": "Quantité",
+ "midi.transforms.arpeggiate": "Arpéger",
+ "midi.transforms.bends_the_time_axis_so": "Déforme l’axe du temps pour qu’une phrase accélère, traîne ou respire.",
+ "midi.transforms.blend": "Blend",
+ "midi.transforms.breaks_chords_into_a_running": "Découpe les accords en une séquence continue.",
+ "midi.transforms.centre": "Centre",
+ "midi.transforms.centre_out": "Du centre vers l’extérieur",
+ "midi.transforms.chance": "Probabilité",
+ "midi.transforms.chord": "Accord",
+ "midi.transforms.chromatic": "Chromatique",
+ "midi.transforms.chunk": "Segment",
+ "midi.transforms.connect": "Relier",
+ "midi.transforms.converge": "Converger",
+ "midi.transforms.curve": "Courbe",
+ "midi.transforms.decorates_notes_with_grace_notes": "Orne les notes de notes d’agrément, de trilles et de roulements.",
+ "midi.transforms.depth": "Depth",
+ "midi.transforms.direction": "Sens",
+ "midi.transforms.distance": "Distance",
+ "midi.transforms.diverge": "Diverger",
+ "midi.transforms.down_up": "Bas-haut",
+ "midi.transforms.draws_a_curve_through_the": "Trace une courbe à travers les vélocités au lieu de les modifier une par une.",
+ "midi.transforms.fill": "Remplissage",
+ "midi.transforms.fills_the_gaps_between_notes": "Comble les vides entre les notes par des traits qui montent ou descendent vers la hauteur suivante.",
+ "midi.transforms.fixed": "Fixe",
+ "midi.transforms.flam": "Flam",
+ "midi.transforms.flatten": "Aplatir",
+ "midi.transforms.grace": "Appogiature",
+ "midi.transforms.humanize": "Humaniser",
+ "midi.transforms.in_scale": "Dans la gamme",
+ "midi.transforms.keep_ends": "Garder les extrémités",
+ "midi.transforms.max_steps": "Pas max.",
+ "midi.transforms.mirror_pitch": "Hauteur en miroir",
+ "midi.transforms.mode": "Mode",
+ "midi.transforms.mordent": "Mordant",
+ "midi.transforms.ornament": "Ornement",
+ "midi.transforms.per_pitch": "Par hauteur",
+ "midi.transforms.period": "Période",
+ "midi.transforms.pulls_notes_onto_the_grid": "Cale les notes sur la grille, avec du swing et une force qui reste souple.",
+ "midi.transforms.pulls_pitch_and_rhythm_apart": "Sépare hauteur et rythme puis les recompose autrement.",
+ "midi.transforms.quantize_ends": "Quantifier les fins",
+ "midi.transforms.recombine": "Recombiner",
+ "midi.transforms.reverse_pitch": "Hauteur inversée",
+ "midi.transforms.reverse_time": "Temps inversé",
+ "midi.transforms.rewrites_note_lengths_from_staccato": "Réécrit les durées de notes — du staccato au legato jusqu’au chevauchement.",
+ "midi.transforms.roll": "Roulement",
+ "midi.transforms.rolls_the_notes_of_a": "Étale dans le temps les notes d’un accord au lieu de les frapper ensemble.",
+ "midi.transforms.rotate_pitch": "Rotation de hauteur",
+ "midi.transforms.scale_length": "Longueur de la gamme",
+ "midi.transforms.shuffle_both": "Mélanger les deux",
+ "midi.transforms.shuffle_pitch": "Mélanger la hauteur",
+ "midi.transforms.shuffle_rhythm": "Mélanger le rythme",
+ "midi.transforms.snap_to_grid": "Magnétisme sur la grille",
+ "midi.transforms.span": "Étendue",
+ "midi.transforms.strum": "Strum",
+ "midi.transforms.style": "Style",
+ "midi.transforms.swing": "Swing",
+ "midi.transforms.tension": "Tension",
+ "midi.transforms.time_warp": "Déformation temporelle",
+ "midi.transforms.to_next_note": "Jusqu’à la note suivante",
+ "midi.transforms.trill": "Trille",
+ "midi.transforms.turn": "Gruppetto",
+ "midi.transforms.type": "Type",
+ "midi.transforms.up_down": "Haut-bas",
+ "midi.transforms.vel_decay": "Déclin de vél.",
+ "midi.transforms.vel_slope": "Pente de vél.",
+ "midi.transforms.velocity_shaper": "Façonneur de vélocité",
+ "midi.transforms.warp_lengths": "Longueurs de warp",
+ "midi.triangle": "Triangle",
+ "midi.up": "Haut",
+ "midi_learn.button": "Bouton {0}",
+ "midi_learn.left_stick": "Stick gauche ←→",
+ "midi_learn.left_stick_2": "Stick gauche ↑↓",
+ "midi_learn.left_trigger": "Gâchette gauche",
+ "midi_learn.note_ch": "Note {0} · canal {1}",
+ "midi_learn.pad": "Pad · {0}",
+ "midi_learn.phone": "Téléphone · {0}",
+ "midi_learn.right_stick": "Stick droit ←→",
+ "midi_learn.right_stick_2": "Stick droit ↑↓",
+ "midi_learn.right_trigger": "Gâchette droite",
+ "midi_map.invert": "Inverser",
+ "midi_map.master_volume": "Volume master",
+ "midi_map.max": "Max",
+ "midi_map.midi_mappings": "Assignations MIDI",
+ "midi_map.no_mappings_yet_click_midi": "Aucune assignation pour l’instant.\n\nCliquer sur MIDI (en haut à droite), puis sur une commande\nen surbrillance, et bouger un bouton ou un fader du contrôleur —\nou appuyer sur un bouton ou bouger un stick d’une manette.",
+ "midi_map.play": "Lecture",
+ "midi_map.track_pan": "Pan de la piste",
+ "midi_map.track_volume": "Volume de la piste",
+ "midi_tools.add": "Ajouter",
+ "midi_tools.apply": "Appliquer",
+ "midi_tools.clip": "clip · {0}",
+ "midi_tools.defaults": "Valeurs par défaut",
+ "midi_tools.generate": "Générer",
+ "midi_tools.notes": "{0:+0;−0;±0} notes",
+ "midi_tools.notes_applied": "{0} notes · appliqué",
+ "midi_tools.notes_was": "{0} notes, au lieu de {1}",
+ "midi_tools.parameters": "Paramètres",
+ "midi_tools.pick_a_tool": "Choisir un outil",
+ "midi_tools.pick_a_tool_to_see": "Choisir un outil pour voir ses paramètres",
+ "midi_tools.replace": "Remplacer",
+ "midi_tools.reroll": "Retirer au sort",
+ "midi_tools.revert": "Rétablir",
+ "midi_tools.seed": "Graine",
+ "midi_tools.selected": "{0} sélectionné(s)",
+ "midi_tools.transform": "Transformer",
+ "mixer.a_hidden_track_clipped_click": "Une piste masquée a saturé · cliquer pour effacer",
+ "mixer.a_hidden_track_is_armed": "Une piste masquée est armée",
+ "mixer.a_hidden_track_is_soloed": "Une piste masquée est en solo",
+ "mixer.balance": "Balance",
+ "mixer.dock_the_mixer_in_the": "Ancrer le mixeur dans la fenêtre principale",
+ "mixer.fold_group": "Replier le groupe {0}",
+ "mixer.group_in": "Entrée du groupe",
+ "mixer.groups_keep_a_unity_centre": "Les groupes gardent une balance centrée à gain unitaire, pour que le groupage reste transparent en niveau",
+ "mixer.hidden_not_enough_height_click": "Masqué : hauteur insuffisante · cliquer pour afficher quand même",
+ "mixer.in_1": "Entrée 1",
+ "mixer.master": "→ Master",
+ "mixer.midi_in": "Entrée MIDI",
+ "mixer.monitor_auto": "Écoute auto",
+ "mixer.monitor_in": "Écoute entrée",
+ "mixer.older_project": "Ancien projet",
+ "mixer.output": "→ Sortie",
+ "mixer.pan_attenuates_the_opposite_channel": "Le pan atténue le canal opposé, comme dans les versions précédentes",
+ "mixer.pan_law": "Loi de panoramique",
+ "mixer.pan_moves_the_whole_image": "Le pan déplace toute l’image des pistes stéréo et des retours",
+ "mixer.panning_attenuates_the_opposite_channel": "Le panoramique atténue le canal opposé (comportement historique)",
+ "mixer.panning_moves_the_whole_stereo": "Le panoramique déplace toute l’image stéréo ; rien n’est supprimé",
+ "mixer.projects_saved_before_stereo_pan": "Les projets enregistrés avant la loi de panoramique stéréo s’ouvrent avec Balance, pour que les mixages existants ne changent pas",
+ "mixer.return_in": "Entrée de retour",
+ "mixer.set_the_gain_drag_or": "Régler le gain : glisser, ou double-clic pour le saisir",
+ "mixer.show_compact_strips_more_tracks": "Afficher des tranches compactes : plus de pistes à l’écran",
+ "mixer.stereo": "Stéréo",
+ "mixer.strips": "Tranches",
+ "mixer.sum_bus": "Bus de somme",
+ "mixer.unfold_group": "Déplier le groupe {0}",
+ "model_store.ai_models_arent_available_for": "Les modèles d’IA ne sont pas disponibles pour cet ordinateur : ONNX Runtime n’en propose pas de version.",
+ "model_store.couldnt_remove_it_may_be": "Impossible de supprimer {0} — il est peut-être utilisé. Redémarrer Nota puis réessayer.",
+ "model_store.installing_this_model_needs_of": "L’installation de ce modèle demande {0} d’espace disque libre, et il y en a {1}.",
+ "model_store.invalid_model_id": "Identifiant de modèle « {0} » invalide.",
+ "model_store.model_catalog.ai_runtime": "Moteur d’IA",
+ "model_store.model_catalog.convert_to_midi": "Convertir en MIDI",
+ "model_store.model_catalog.hears_every_note_in_a": "Entend chaque note d’un enregistrement, accords compris, pour Convertir la mélodie et Convertir l’harmonie.",
+ "model_store.model_catalog.separate_stems": "Séparer les stems",
+ "model_store.model_catalog.splits_a_mix_into_drums": "Sépare un mix en batterie, basse, voix et tout le reste, chacun sur sa propre piste.",
+ "model_store.model_catalog.the_library_notas_ai_models": "La bibliothèque sur laquelle tournent les modèles d’IA de Nota. Installée avec le premier modèle.",
+ "model_store.the_download_of_doesnt_contain": "Le téléchargement de {0} ne contient pas {1}.",
+ "model_store.unknown_ai_model": "Modèle d’IA « {0} » inconnu.",
+ "modular.add": "+ Ajouter",
+ "modular.add_2": "Ajouter",
+ "modular.add_an_lfo_expose_a": "Ajouter d’abord un LFO / exposer un paramètre",
+ "modular.audio_in": "Entrée audio",
+ "modular.audio_out": "Sortie audio",
+ "modular.bypass_b": "Contourner (B)",
+ "modular.cross_track_cv_links": { "one": "{0} lien CV entre pistes", "other": "{0} liens CV entre pistes" },
+ "modular.cv_link_lfo_caps": "LIEN CV · LFO {0}",
+ "modular.cv_out": "CV out",
+ "modular.delete": "Supprimer (⌫)",
+ "modular.depth": "Depth",
+ "modular.devices": { "one": "{0} appareil →", "other": "{0} appareils →" },
+ "modular.drag_from_a_cv_out": "Glisser d’une sortie CV sur un nœud pour le moduler · Space + glisser — déplacer la vue · ⌘ + molette — zoom · F — ajuster · Esc — afficher moins",
+ "modular.edges": { "one": "{0} lien", "other": "{0} liens" },
+ "modular.edit_modulation": "Modifier la modulation · {0}…",
+ "modular.env": "Env",
+ "modular.expose_as_cv_output": "Exposer comme sortie CV",
+ "modular.fit": "Ajuster",
+ "modular.fixed_the_chain_leaves_the": "Fixe — la chaîne quitte la piste vers le mixeur ici, donc il ne peut pas être supprimé.",
+ "modular.fixed_the_tracks_clips_and": "Fixe — les clips et l’entrée de la piste entrent dans la chaîne ici, donc il ne peut pas être supprimé.",
+ "modular.fixed_the_tracks_instrument_takes": "Fixe — l’instrument de la piste reçoit son MIDI ici. Il ne peut pas être supprimé ; déposer un autre instrument sur la piste pour le remplacer.",
+ "modular.free": "Libre",
+ "modular.from": "Depuis {0} · {1}",
+ "modular.gain": "Gain",
+ "modular.global": "Global",
+ "modular.global_n": "Global · {0}",
+ "modular.hide_the_parameters_that_arent": "Masquer les paramètres non modulés (Esc)",
+ "modular.inst": "Inst {0}",
+ "modular.instrument": "Instrument {0}",
+ "modular.invert": "Inverser",
+ "modular.islands": { "one": "{0} îlot", "other": "{0} îlots" },
+ "modular.khz_ms": "{0:0.0} kHz · {1} · {2:0.0} ms",
+ "modular.lfo_caps": "LFO",
+ "modular.lfo_caps_n": "LFO {0}",
+ "modular.macro": "Macro",
+ "modular.math": "Math",
+ "modular.max": "Max",
+ "modular.midi_in": "Entrée MIDI",
+ "modular.midi_out": "Sortie MIDI",
+ "modular.mode": "Mode",
+ "modular.modulate_from_a_parameter": "Moduler depuis un paramètre",
+ "modular.modulate_from_another_track": "Moduler depuis une autre piste",
+ "modular.modulate_with": "Moduler avec {0} {1}",
+ "modular.multiply": "Multiply",
+ "modular.no_modulatable_parameters_on_that": "Aucun paramètre modulable sur cette piste",
+ "modular.no_parameters": "Aucun paramètre",
+ "modular.no_tracks_yet": "Aucune piste pour l’instant",
+ "modular.nodes": "{0} nœuds",
+ "modular.nodes_caps": "{0} NŒUDS",
+ "modular.note": "Note",
+ "modular.offset": "Offset",
+ "modular.open_in_a_window": "Ouvrir dans une fenêtre",
+ "modular.out": "Sortie",
+ "modular.override": "Forcer",
+ "modular.parameter": "Paramètre",
+ "modular.pattern": " · {0}",
+ "modular.pattern_n": "{0} · {1} · {2}",
+ "modular.phase": "Phase",
+ "modular.pick_a_track_to_see": "Choisir une piste pour voir son graphe de signal",
+ "modular.rate": "Rate",
+ "modular.remove_connection": "Retirer la connexion",
+ "modular.remove_modulation": "Retirer la modulation",
+ "modular.rnd": "Rnd",
+ "modular.saw": "Saw",
+ "modular.scale": "Gamme",
+ "modular.scope": "Scope",
+ "modular.scope.back_to_the_live_trace": "Retour à la trace en direct",
+ "modular.scope.drag_to_resize_the_trace": "Glisser pour redimensionner la trace",
+ "modular.scope.free_running_the_newest_value": "Défilement libre : la valeur la plus récente est à droite",
+ "modular.scope.hold_the_trace_while_the": "Figer la trace pendant que l’entrée continue",
+ "modular.scope.rise": "Montée",
+ "modular.scope.scope": "Scope {0} · {1}",
+ "modular.scope.the_window_is_in_beats": "La fenêtre est en temps, au tempo. Cliquer pour passer en millisecondes",
+ "modular.scope.the_window_is_in_milliseconds": "La fenêtre est en millisecondes. Cliquer pour la synchroniser au tempo",
+ "modular.scope.trigger_start_the_trace_where": "Déclencheur : démarrer la trace là où l’entrée franchit 0 en montant, pour qu’une forme répétée reste immobile",
+ "modular.scope.watches_cv_drag_a_modulators": "Surveille le CV. Glisser la sortie CV d’un modulateur sur ce nœud. Pour l’audio, mettre Lens sur la chaîne.",
+ "modular.scope.window": "Fenêtre",
+ "modular.scope.zoom": "Zoom",
+ "modular.show_all_parameters": "Afficher tous les paramètres",
+ "modular.show_fewer": "Afficher moins",
+ "modular.show_fewer_parameters_esc": "Afficher moins de paramètres (Esc)",
+ "modular.sine": "Sine",
+ "modular.smooth": "Lisse",
+ "modular.sqr": "Sqr",
+ "modular.subtract": "Subtract",
+ "modular.sync": "Sync",
+ "modular.track_output": "Sortie de piste",
+ "modular.tracks": "Pistes",
+ "modular.tri": "Tri",
+ "modular.unexpose_cv_output": "Ne plus exposer la sortie CV",
+ "modular.vel": "Vel",
+ "mosaic.library.couldnt_load_the_preset": "Impossible de charger le préréglage : {0}",
+ "mosaic_create.analysis": "{0} · analyse",
+ "mosaic_create.by_name_stem": "par radical du nom",
+ "mosaic_create.create_1_preset": "Créer 1 préréglage",
+ "mosaic_create.create_multisample": "Créer un multi-échantillon",
+ "mosaic_create.create_presets": "Créer des préréglages",
+ "mosaic_create.create_presets_n": "Créer {0} préréglages",
+ "mosaic_create.duplicates": { "one": "{0} doublon", "other": "{0} doublons" },
+ "mosaic_create.edge_zone_stretch": "Étirement des zones de bord",
+ "mosaic_create.files": "{0} fichiers · {1}",
+ "mosaic_create.gap_at_neighbours_stretched": "Trou à {0} — voisines étirées",
+ "mosaic_create.layer": "{0} couche",
+ "mosaic_create.mapping": "Assignation",
+ "mosaic_create.mapping_2": "Assignation…",
+ "mosaic_create.midi_caps": "{0} · MIDI",
+ "mosaic_create.multisamples": "Multi-échantillons",
+ "mosaic_create.next_to_gap": "à côté du trou",
+ "mosaic_create.no_audio_files_with_a": "Aucun fichier audio avec une note dans son nom ou une hauteur claire.",
+ "mosaic_create.no_repeat": "Sans répétition",
+ "mosaic_create.notes_from_sample_analysis": { "one": "{0} note issue de l’analyse de l’échantillon", "other": "{0} notes issues de l’analyse de l’échantillon" },
+ "mosaic_create.nothing_to_map": "rien à assigner",
+ "mosaic_create.octave": "Octave",
+ "mosaic_create.presets_will_appear_in_nota": "Les préréglages apparaîtront dans Nota Mosaic → Packs → {0}",
+ "mosaic_create.reading_the_files": "Lecture des fichiers…",
+ "mosaic_create.release_samples_release_group": "Échantillons de relâchement → groupe de relâchement",
+ "mosaic_create.rnd": "Rnd",
+ "mosaic_create.round_robin": "Round-robin",
+ "mosaic_create.seq": "Séq",
+ "mosaic_create.the_names_are_taken_as": "Les noms sont pris tels quels (C4 = 60).",
+ "mosaic_create.velocity_layers_by_dynamics": "Couches de vélocité par dynamique",
+ "mosaic_create.without_a_note_left_out": "{0} sans note — ignoré",
+ "mosaic_create.zones": "{0}–{1} · {2} zones",
+ "palette.categories.distortion": "Distorsion",
+ "palette.categories.drums": "Batterie",
+ "palette.categories.dynamics": "Dynamique",
+ "palette.categories.eq_filter": "EQ et filtre",
+ "palette.categories.generate": "Générer",
+ "palette.categories.keys_physical": "Claviers et modélisation",
+ "palette.categories.modulation": "Modulation",
+ "palette.categories.pitch_time": "Hauteur et temps",
+ "palette.categories.racks": "Racks",
+ "palette.categories.reverb_delay": "Réverbération et delay",
+ "palette.categories.samplers": "Samplers",
+ "palette.categories.shape": "Forme",
+ "palette.categories.synths": "Synthés",
+ "palette.categories.utility": "Utilitaires",
+ "palette.devices.3_band_eq": "EQ 3 bandes",
+ "palette.devices.8_band_eq": "EQ 8 bandes",
+ "palette.devices.a_single_gain_stage_with": "Un seul étage de gain avec un grand affichage.",
+ "palette.devices.a_synth_with_a_built": "Un synthé avec un moteur de motifs intégré pour arpèges et séquences.",
+ "palette.devices.algorithmic_reverb_from_small_rooms": "Réverbération algorithmique, des petites pièces aux grandes salles.",
+ "palette.devices.amplifier": "amplificateur",
+ "palette.devices.analog_synth": "synthé analogique",
+ "palette.devices.analyzer_scope": "analyseur / oscilloscope",
+ "palette.devices.arp_synth": "synthé arpégiateur",
+ "palette.devices.auto_pan": "auto-pan",
+ "palette.devices.auto_pan_and_tremolo_synced": "Auto-pan et trémolo synchronisés au tempo.",
+ "palette.devices.bit_crusher": "bit crusher",
+ "palette.devices.bit_depth_and_sample_rate": "Réduction de la profondeur de bits et de la fréquence d’échantillonnage.",
+ "palette.devices.brickwall_limiter_for_the_master": "Limiteur brickwall pour le master.",
+ "palette.devices.built_in": "intégrés",
+ "palette.devices.captures_and_repeats_slices_for": "Capture et répète des tranches pour des bégaiements et des glitchs.",
+ "palette.devices.chains_of_midi_effects": "chaînes d’effets MIDI",
+ "palette.devices.chorus": "chorus",
+ "palette.devices.chorus_and_ensemble_for_width": "Chorus et ensemble pour la largeur et le scintillement.",
+ "palette.devices.classic_jet_flanger": "Flanger jet classique.",
+ "palette.devices.compressor_with_sidechain_and_five": "Compresseur avec sidechain et cinq caractères — glue, punch et pumping.",
+ "palette.devices.drum_machine": "boîte à rythmes",
+ "palette.devices.dynamic_eq": "EQ dynamique",
+ "palette.devices.eight_band_parametric_eq_with": "EQ paramétrique à huit bandes avec spectre en direct.",
+ "palette.devices.eight_voice_drum_machine_with": "Boîte à rythmes à huit voix avec séquenceur pas à pas.",
+ "palette.devices.electric_piano": "piano électrique",
+ "palette.devices.envelope_lfo": "enveloppe / LFO",
+ "palette.devices.eq_bands_that_react_to": "Bandes d’EQ qui réagissent au niveau — dé-essage et contrôle des résonances.",
+ "palette.devices.five_voice_vintage_polysynth_lush": "Polysynthé vintage à cinq voix — nappes riches, cuivres et claviers.",
+ "palette.devices.flanger": "flanger",
+ "palette.devices.fm_synth": "synthé FM",
+ "palette.devices.fm_synthesis_bells_electric_pianos": "Synthèse FM — cloches, pianos électriques et basses dures.",
+ "palette.devices.force_note_length": "durée de note imposée",
+ "palette.devices.forces_note_lengths_staccato_legato": "Impose les durées de notes — staccato, legato ou fixes.",
+ "palette.devices.gain": "gain",
+ "palette.devices.gain_width_mono_and_phase": "Gain, largeur, mono et phase — l’outil de base.",
+ "palette.devices.gate": "gate",
+ "palette.devices.glitch_repeats": "glitch et répétitions",
+ "palette.devices.granular_synth": "synthé granulaire",
+ "palette.devices.granular_synth_that_turns_a": "Synthé granulaire qui transforme un échantillon en nuages, textures et drones.",
+ "palette.devices.guitar_amp_and_cabinet_models": "Modèles d’amplis et de baffles de guitare, du son clair au fort gain.",
+ "palette.devices.hybrid_reverb": "réverbération hybride",
+ "palette.devices.hybrid_reverb_with_early_reflections": "Réverbération hybride avec premières réflexions et longue queue dense.",
+ "palette.devices.keeps_notes_in_a_key": "Garde les notes dans une tonalité et une gamme.",
+ "palette.devices.layered_looper_with_overdubs": "Looper à couches avec superpositions.",
+ "palette.devices.layers_several_instruments_in_parallel": "Superpose plusieurs instruments dans des chaînes parallèles.",
+ "palette.devices.limiter": "limiteur",
+ "palette.devices.looper": "looper",
+ "palette.devices.modelled_electric_piano_tine_suitcase": "Piano électrique modélisé — tine, suitcase, reed et clav avec trémolo, phaser et baffle.",
+ "palette.devices.mono_synth": "synthé mono",
+ "palette.devices.monophonic_analog_style_synth_for": "Synthé monophonique de style analogique pour basses épaisses et leads.",
+ "palette.devices.multi_stage_phaser": "Phaser multi-étages.",
+ "palette.devices.multiband_dynamics": "dynamique multibande",
+ "palette.devices.multisample": "multi-échantillons",
+ "palette.devices.multisample_instrument_zones_by_key": "Instrument multi-échantillons — zones par touche et vélocité, round-robin et échantillons de relâchement ; import SFZ et packs.",
+ "palette.devices.noise_gate_and_rhythmic_trance": "Noise gate et trance gate rythmique.",
+ "palette.devices.paraphonic_ensemble_synth_string_machines": "Synthé d’ensemble paraphonique — string machines et chœurs.",
+ "palette.devices.paraphonic_synth": "synthé paraphonique",
+ "palette.devices.phaser": "phaser",
+ "palette.devices.physical_modelling_of_struck_plucked": "Modélisation physique de corps frappés, pincés et soufflés.",
+ "palette.devices.physical_synth": "synthé à modélisation physique",
+ "palette.devices.pitch_correction": "correction de hauteur",
+ "palette.devices.pitch_quantize": "quantification de hauteur",
+ "palette.devices.plays_a_sample_across_the": "Joue un échantillon sur tout le clavier.",
+ "palette.devices.poly_synth": "synthé polyphonique",
+ "palette.devices.random_transpose": "transposition aléatoire",
+ "palette.devices.random_transposition_timing_and_dropouts": "Transposition, timing et silences aléatoires.",
+ "palette.devices.real_time_pitch_correction_to": "Correction de hauteur en temps réel vers une tonalité et une gamme.",
+ "palette.devices.reshapes_compresses_or_randomises_note": "Remodèle, comprime ou randomise les vélocités des notes.",
+ "palette.devices.resonant_filter_swept_by_an": "Filtre résonant balayé par un suiveur d’enveloppe ou un LFO.",
+ "palette.devices.runs_several_effect_chains_in": "Exécute plusieurs chaînes d’effets en parallèle.",
+ "palette.devices.saturator": "saturateur",
+ "palette.devices.shapes_this_tracks_sound_with": "Façonne le son de cette piste avec la voix d’une autre piste.",
+ "palette.devices.sixteen_pads_each_with_its": "Seize pads, chacun avec son propre échantillon ou sa chaîne d’instruments.",
+ "palette.devices.spectrum_analyser_oscilloscope_and_level": "Analyseur de spectre, oscilloscope et vumètre.",
+ "palette.devices.splits_notes_across_chains_of": "Répartit les notes entre des chaînes d’effets MIDI selon la touche, la vélocité ou un sélecteur.",
+ "palette.devices.stacked_intervals": "intervalles superposés",
+ "palette.devices.step_arpeggiator": "arpégiateur pas à pas",
+ "palette.devices.step_arpeggiator_with_groove_lanes": "Arpégiateur pas à pas avec voies de groove.",
+ "palette.devices.stereo_and_ping_pong_delay": "Delay stéréo et ping-pong synchronisé au tempo.",
+ "palette.devices.tape_and_tube_saturation_warmth": "Saturation à bande et à lampes — chaleur, wow et flutter.",
+ "palette.devices.three_band_dj_style_eq": "EQ trois bandes façon DJ avec kills.",
+ "palette.devices.three_band_upward_and_downward": "Compression ascendante et descendante en trois bandes — densité façon OTT.",
+ "palette.devices.turns_single_notes_into_chords": "Transforme des notes seules en accords.",
+ "palette.devices.two_oscillator_analog_style_synth": "Synthé de style analogique à deux oscillateurs avec drive et pile d’unissons — nappes, basses, lignes acid et leads.",
+ "palette.devices.vector_morph_synth": "synthé à morphing vectoriel",
+ "palette.devices.vector_synth_morphing_between_sources": "Synthé vectoriel qui fond entre des sources — nappes et textures mouvantes.",
+ "palette.devices.velocity_shaping": "façonnage de la vélocité",
+ "palette.devices.vintage_saturator": "saturateur vintage",
+ "palette.devices.vocoder": "vocoder",
+ "palette.devices.waveshaping_saturator_from_soft_warmth": "Saturateur à mise en forme d’onde, de la chaleur douce à l’écrêtage dur.",
+ "palette.devices.wavetable_synth": "synthé à tables d’ondes",
+ "palette.devices.wavetable_synth_with_warping_oscillators": "Synthé à tables d’ondes avec oscillateurs déformants — nappes évolutives et leads modernes.",
+ "palette.index.1_item": "1 élément",
+ "palette.index.indexing": "indexation de {0}… {1} %",
+ "palette.index.items": "{0} éléments",
+ "palette.modular.a_low_frequency_oscillator_free": "Un oscillateur basse fréquence, libre ou synchronisé au tempo.",
+ "palette.modular.adds_multiplies_or_mixes_two": "Additionne, multiplie ou mélange deux signaux de contrôle.",
+ "palette.modular.an_attack_decay_sustain_release": "Une enveloppe attaque-déclin-maintien-relâchement déclenchée par les notes.",
+ "palette.modular.control": "Contrôle",
+ "palette.modular.converter": "Convertisseur",
+ "palette.modular.cv_utility": "Utilitaire CV",
+ "palette.modular.modulator": "Modulateur",
+ "palette.modular.monitor": "Écoute",
+ "palette.modular.one_knob_driving_several_destinations": "Un potentiomètre qui pilote plusieurs destinations.",
+ "palette.modular.shows_a_control_signal_over": "Affiche un signal de contrôle au fil du temps.",
+ "palette.modular.turns_notes_velocity_and_controllers": "Transforme notes, vélocité et contrôleurs en signaux de contrôle.",
+ "palette.modular.turns_the_tracks_loudness_into": "Transforme le volume de la piste en signal de contrôle : un contrôleur de crête, pour faire ducker une piste sous une autre.",
+ "palette.search.actions": "Actions",
+ "palette.search.device_window": "Fenêtre d’appareil",
+ "palette.search.devices": "Appareils",
+ "palette.search.presets": "Préréglages",
+ "palette.search.suggested": "Suggestions · {0}",
+ "palette.search.tracks": "Pistes",
+ "palette.targets.after": "après {0}",
+ "palette.targets.canvas_unconnected": "canevas, non connecté",
+ "palette.targets.end_of_audio_fx": "fin des effets audio",
+ "palette.targets.end_of_chain": "fin de la chaîne",
+ "palette.targets.end_of_midi_fx": "fin des effets MIDI",
+ "palette.targets.instrument": "instrument",
+ "palette.targets.keep_open": " · garder ouvert",
+ "palette.targets.loads_the_kit": "charge le kit",
+ "palette.targets.midi_effects_need_an_instrument": "Les effets MIDI nécessitent une piste d’instrument",
+ "palette.targets.midi_fx_end": "effets MIDI, fin",
+ "palette.targets.new_chain_in_instrument_rack": "nouvelle chaîne dans Instrument Rack",
+ "palette.targets.new_midi_track": "→ nouvelle piste MIDI{0}",
+ "palette.targets.new_pad_in_drum_rack": "nouveau pad dans Drum Rack",
+ "palette.targets.new_track": "→ nouvelle piste{0}",
+ "palette.targets.open_in_devices": "→ ouvrir {0} dans Appareils",
+ "palette.targets.pattern": "→ {0} · {1}{2}",
+ "palette.targets.replaces": "remplace {0}",
+ "palette.targets.replaces_the_instrument": "remplace l’instrument",
+ "palette.targets.run": "↵ exécuter",
+ "palette.targets.select_a_track_first": "Sélectionner d’abord une piste",
+ "palette.targets.select_in": "→ sélectionner {0} dans {1}",
+ "palette.targets.track": "piste {0}",
+ "palette_providers.audio_fx": "Effets audio",
+ "palette_providers.kits": "Kits",
+ "palette_providers.midi_caps": "MIDI · {0}",
+ "palette_providers.midi_fx_caps": "Effets MIDI",
+ "palette_providers.modular": "Modular · {0}",
+ "palette_providers.preset": "Préréglage",
+ "persistence.preset.couldnt_load_the_sample": "Impossible de charger l’échantillon « {0} ».",
+ "persistence.preset.couldnt_prepare_the_multisample": "Impossible de préparer le multi-échantillon « {0} ».",
+ "persistence.preset.couldnt_prepare_the_sample": "Impossible de préparer l’échantillon « {0} ».",
+ "persistence.preset.failed_to_add_device": "Échec de l’ajout de l’appareil.",
+ "persistence.preset.failed_to_add_instrument": "Échec de l’ajout de l’instrument.",
+ "persistence.preset.failed_to_add_midi_effect": "Échec de l’ajout de l’effet MIDI.",
+ "persistence.preset.failed_to_load_instrument": "Échec du chargement de l’instrument.",
+ "persistence.preset.failed_to_load_plugin": "Échec du chargement du plug-in.",
+ "persistence.preset.not_a_midi_effect": "Ce n’est pas un effet MIDI.",
+ "persistence.preset.not_an_effect": "Ce n’est pas un effet.",
+ "persistence.preset.plugin_not_installed": "Plug-in non installé : {0}",
+ "persistence.preset.preset_cant_be_applied_in": "Le préréglage ne peut pas être appliqué sur place.",
+ "persistence.preset.unknown_preset_type": "Type de préréglage inconnu.",
+ "persistence.project_history.this_version_was_saved_by": "Cette version a été enregistrée par Nota {0}, plus récent que celui-ci. Mettre Nota à jour pour l’ouvrir.",
+ "piano_roll.1_note_vel": "1 note · {0} · vél {1}",
+ "piano_roll.a_session_slot_plays_on": "Un emplacement de Session joue sur sa propre horloge de boucle — le lancer pour jouer depuis le début",
+ "piano_roll.clear": "Effacer {0}",
+ "piano_roll.clip_strip.click_a_clip_to_edit": "Clic sur un clip pour l’éditer · le verrou garde un clip comme référence",
+ "piano_roll.controllers.drag_to_draw": "Glisser pour dessiner",
+ "piano_roll.controllers.drag_to_draw_a_block": "Glisser pour dessiner un bloc",
+ "piano_roll.controllers.other_cc": "Autre CC",
+ "piano_roll.expression.bend": "Bend",
+ "piano_roll.expression.clear_all_expression": "Effacer toute l’expression",
+ "piano_roll.expression.pres": "Pres",
+ "piano_roll.expression.pressure": "Pression",
+ "piano_roll.expression.slide": "Slide",
+ "piano_roll.expression.vel": "Vel",
+ "piano_roll.no_selection": "Aucune sélection",
+ "piano_roll.notes": "{0} notes",
+ "piano_roll.reset_velocity": "Réinitialiser la vélocité",
+ "plugin_scan.looking_for_plugins": "Recherche de plug-ins…",
+ "plugin_scan.scanning_plugins_of": "Analyse des plug-ins · {0:N0} sur {1:N0}",
+ "plugin_store.archive_unpacker.a_archive_can_only_be": "Une archive .{0} ne peut être décompressée que sous macOS.",
+ "plugin_store.archive_unpacker.couldnt_start": "Impossible de lancer {0}.",
+ "plugin_store.archive_unpacker.failed": "Échec de {0} ({1}) : {2}",
+ "plugin_store.archive_unpacker.the_archive_contains_an_unsafe": "L’archive contient un chemin dangereux : {0}",
+ "plugin_store.archive_unpacker.the_deb_archive_has_no": "L’archive .deb ne contient aucune donnée.",
+ "plugin_store.archive_unpacker.the_deb_archive_is_damaged": "L’archive .deb est endommagée.",
+ "plugin_store.archive_unpacker.the_deb_archive_is_truncated": "L’archive .deb est tronquée.",
+ "plugin_store.archive_unpacker.unpacking_needs_which_wasnt_found": "La décompression demande « {0} », introuvable.",
+ "plugin_store.archive_unpacker.unsupported_archive_type": "Type d’archive « {0} » non pris en charge.",
+ "plugin_store.installing": "Installation de {0}…",
+ "ports.i_process_cpu.of_all_cpus": "de tous les CPU",
+ "ports.i_process_cpu.of_one_core": "d’un cœur",
+ "preferences.a_b_compare_move_copy": "Comparaison A / B, déplacer, copier, supprimer, préréglages, enregistrer le préréglage",
+ "preferences.a_multi_selection_gets_its": "Une sélection multiple a son propre menu : couleur, hauteur, gel, groupe, copie, duplication, suppression",
+ "preferences.add_a_note_with_the": "Ajouter une note avec la longueur et la vélocité de la dernière note touchée · sur une note, la supprimer",
+ "preferences.add_a_point_on_a": "Ajouter un point · sur un point, le supprimer · clic droit pour effacer la courbe",
+ "preferences.add_a_warp_marker_on": "Ajouter un marqueur de warp · sur un marqueur, le supprimer",
+ "preferences.add_an_instrument_audio_or": "Ajouter une piste d’instrument, audio ou de retour · en renommer ou en supprimer une",
+ "preferences.add_folder": "Ajouter un dossier…",
+ "preferences.add_plugin_scan_folder": "Ajouter un dossier d’analyse de plug-ins",
+ "preferences.add_the_track_to_the": "Ajouter la piste à la sélection · de nouveau pour la retirer",
+ "preferences.add_this_config_or_the": "Ajouter cette config (ou l’URL) comme serveur MCP dans Claude Desktop / Claude Code. Boucle locale uniquement ; désactivé par défaut.",
+ "preferences.adding_a_plug_in_from": "L’ajout d’un plug-in depuis le navigateur, par glisser-déposer ou depuis la palette, ouvre son éditeur. Le chargement d’un projet, l’annulation et le collage ne l’ouvrent jamais.",
+ "preferences.ai_control_mcp": "Contrôle par IA (MCP)",
+ "preferences.align_the_audio_to_the": "Aligner l’audio sur la grille · la forme d’onde s’étire pendant le glissement",
+ "preferences.all": "Tous",
+ "preferences.always_start_a_new_track": "Toujours créer une nouvelle piste avec lui",
+ "preferences.an_instrument_or_instrument_preset": "Un instrument ou un préréglage d’instrument sur une nouvelle piste · une piste : l’ouvrir dans Appareils",
+ "preferences.any_button": "N’importe quel bouton",
+ "preferences.any_button_can_be_mapped": "Un bouton quelconque peut être assigné à une commande à la place : cliquer sur MIDI en haut à droite, cliquer sur la commande, puis appuyer sur le bouton. Un bouton assigné pilote cette commande et ne joue plus sa note ; le reste de la manette garde la disposition ci-dessus. Les sticks et la course des gâchettes s’assignent de la même façon et sont continus, ce qui convient à un bouton rotatif ou à un fader : ils ne jouent aucune note et ne font rien tant qu’ils ne sont pas assignés. Les assignations sont listées dans l’onglet Carte MIDI du navigateur et suivent le projet.",
+ "preferences.appearance": "Apparence",
+ "preferences.apply_and_keep_the_palette": "Appliquer et garder la palette ouverte pour l’appareil suivant",
+ "preferences.apply_where_the_palette_was": "Appliquer là où la palette a été ouverte (la cible s’affiche dans le champ)",
+ "preferences.arrangement_editing": "Arrangement et édition",
+ "preferences.asio_caps": "ASIO",
+ "preferences.asio_frames": "ASIO · {0} échantillons @ {1}{2}",
+ "preferences.asio_unavailable_wasapi": "ASIO indisponible ({0}) → WASAPI",
+ "preferences.audio_clip_editor": "Éditeur de clips audio",
+ "preferences.audio_clip_editor_on_adsr": "Éditeur de clips audio sur ADSR ou sur un clip non warpé",
+ "preferences.audio_device": "Périphérique audio",
+ "preferences.audio_device_not_running": "Le périphérique audio n’est pas démarré.",
+ "preferences.audio_settings_are_unavailable_in": "Les réglages audio ne sont pas disponibles dans cette fenêtre.",
+ "preferences.audio_system": "Système audio",
+ "preferences.back_to_the_standard_height": "Retour à la hauteur standard",
+ "preferences.bars": "Barres",
+ "preferences.bend_range": "Amplitude du pitch bend",
+ "preferences.black_keys_sharps": "Touches noires (dièses)",
+ "preferences.browser_preview": "Navigateur · aperçu",
+ "preferences.buffer_size": "Taille de la mémoire tampon",
+ "preferences.bypass_the_selected_device": "Contourner l’appareil sélectionné",
+ "preferences.cancel_the_current_gesture_clear": "Annuler le geste en cours / effacer la sélection · fermer la baie de brassage",
+ "preferences.change_a_device_value_hold": "Changer une valeur d’appareil · maintenir ⌘ ou ⇧ pour des pas fins",
+ "preferences.change_its_velocity_the_whole": "Changer sa vélocité · celle de toute la sélection si la note est sélectionnée · ailleurs, défiler latéralement",
+ "preferences.change_the_notes_start_or": "Changer le début ou la fin de la note",
+ "preferences.channels_2_16_each_carry": "Les canaux 2 à 16 portent chacun une note avec son propre pitch bend, sa pression et son glissement (CC74). Un contrôleur qui annonce son amplitude remplace celle-ci. Le canal 1 se joue comme un clavier ordinaire, sa molette de hauteur et son aftertouch agissant sur tout l’instrument. ",
+ "preferences.choose": "Choisir…",
+ "preferences.choose_folder": "Choisir le dossier {0}",
+ "preferences.clear_the_device_selection_so": "Effacer la sélection d’appareils · un clic dans l’espace vide de la chaîne fait de même",
+ "preferences.clear_the_route_volt_aurora": "Effacer la route (Volt, Aurora) · retirer le câble (Consort)",
+ "preferences.click_a_clip_in_the": "Clic sur un clip du bandeau de clips",
+ "preferences.click_a_clip_or_arm": "⌥-clic sur un clip ou sur Armer",
+ "preferences.click_a_device": "Clic sur un appareil",
+ "preferences.click_a_graph_handle_envelope": "⌥-clic sur une poignée de graphique, un nœud d’enveloppe ou une cellule de la matrice de modulation",
+ "preferences.click_a_groups_link_key": "Clic sur la touche Link d’un groupe",
+ "preferences.click_a_height_key_in": "⌥-clic sur une touche de hauteur dans le menu de piste",
+ "preferences.click_a_key": "Clic sur une touche",
+ "preferences.click_a_knob_fader_or": "⌥-clic sur un bouton rotatif, un fader ou un curseur",
+ "preferences.click_a_rhythm_step": "Clic · ⇧ · ⌥ sur un pas Rhythm",
+ "preferences.click_a_rhythm_voice": "Clic sur une voix Rhythm",
+ "preferences.click_drag_the_ruler": "Clic · glisser sur la règle",
+ "preferences.click_play_button": "Clic sur le bouton de lecture",
+ "preferences.click_section": "Clic sur une section",
+ "preferences.click_the_bend_lanes_range": "Clic sur l’amplitude du couloir Bend",
+ "preferences.click_the_controller_tab": "Clic sur l’onglet de contrôleur",
+ "preferences.click_the_position_read_out": "Clic sur l’affichage de la position",
+ "preferences.click_track_header": "⇧-clic sur un en-tête de piste",
+ "preferences.click_wave_spec": "Clic sur WAVE / SPEC",
+ "preferences.click_waveform": "Clic sur la forme d’onde",
+ "preferences.close_and_go_back_where": "Fermer et revenir où l’on était",
+ "preferences.close_to_the_limit_consider": "proche de la limite : envisager un tampon plus grand",
+ "preferences.colour_theme": "Thème de couleurs",
+ "preferences.command_palette": "Palette de commandes",
+ "preferences.consolidate_the_selection_into_one": "Consolider la sélection en un clip par piste",
+ "preferences.content_folders": "Dossiers de contenu",
+ "preferences.content_folders_and_version_history": "Dossiers de contenu et historique des versions",
+ "preferences.content_folders_are_unavailable_in": "Les dossiers de contenu ne sont pas disponibles dans cette fenêtre.",
+ "preferences.controllers_nota_listens_to": "Contrôleurs écoutés par Nota",
+ "preferences.copied": "Copié",
+ "preferences.copy_config": "Copier la config",
+ "preferences.copy_cut_paste_a_clip": "Copier / couper / coller un clip · un clip coupé se déplace au collage · les clips copiés dans l’arrangement se collent ici",
+ "preferences.copy_cut_paste_clips_a": "Copier / couper / coller des clips, une plage de temps ou une plage d’automation · colle sur la dernière piste cliquée",
+ "preferences.copy_cut_paste_notes_paste": "Copier / couper / coller des notes · le collage se place sur les originaux",
+ "preferences.copy_cut_paste_the_selected": "Copier / couper / coller les appareils sélectionnés avec tous leurs réglages · chacun se place dans sa section après l’appareil sélectionné · un instrument copié remplace l’instrument sur lequel il est collé",
+ "preferences.copy_cut_paste_the_selected_2": "Copier / couper / coller les pistes sélectionnées · le collage se place après la dernière",
+ "preferences.copy_it_there": "L’y copier",
+ "preferences.copy_the_selected_clip_group": "Copier le clip, l’emplacement de groupe ou la scène sélectionnés vers l’arrangement, à la tête de lecture",
+ "preferences.copy_the_selected_clips_to": "Copier les clips sélectionnés vers Session · dans la première rangée de scènes où ils tiennent",
+ "preferences.couldnt_be_loaded_see_plugin": " Impossible d’en charger {0:N0} : voir plugin-scan.log dans le dossier de journaux de Nota.",
+ "preferences.count_in_before_play_record": "Décompte avant Lecture / Enregistrement : désactivé · 1 · 2 · 4 mesures",
+ "preferences.cpu_check": "Test du CPU",
+ "preferences.custom": "personnalisé",
+ "preferences.cycle_devices_pattern_clip_in": "Passer d’Appareils à Pattern puis à Clip dans le panneau de détail",
+ "preferences.d_pad_left_right": "Croix ← / →",
+ "preferences.d_pad_up_down": "Croix ↑ / ↓",
+ "preferences.dark": "Sombre",
+ "preferences.deactivate_activate_the_selected_clip": "Désactiver / activer le ou les clips sélectionnés",
+ "preferences.default": "par défaut",
+ "preferences.delete_device_selected": "Delete (appareil sélectionné)",
+ "preferences.delete_the_selected_clip_or": "Supprimer le clip ou la scène sélectionnés",
+ "preferences.delete_the_selected_clip_range": "Supprimer le clip / la plage sélectionnés",
+ "preferences.delete_the_selected_device_modulator": "Supprimer l’appareil, le modulateur ou le câble sélectionné · l’entrée, l’instrument et la sortie de la piste sont fixes",
+ "preferences.delete_the_selected_devices_with": "Supprimer les appareils sélectionnés · avec l’instrument, sa piste",
+ "preferences.delete_the_selected_notes": "Supprimer les notes sélectionnées",
+ "preferences.delete_the_selected_tracks_a": "Supprimer les pistes sélectionnées · un groupe part avec ses pistes",
+ "preferences.deselect_moved_or_pasted_notes": "Désélectionner · les notes déplacées ou collées remplacent celles qui sont dessous",
+ "preferences.detail_panel": "Panneau de détail",
+ "preferences.device_default": "Par défaut du périphérique",
+ "preferences.device_sample_rate_and_buffer": "Périphérique, fréquence d’échantillonnage et mémoire tampon",
+ "preferences.devices_after_a_click_on": "Appareils (après un clic sur un appareil)",
+ "preferences.devices_settings": "Périphériques",
+ "preferences.direction": "Sens",
+ "preferences.double_click_a_browser_instrument": "Double-clic sur un instrument du navigateur",
+ "preferences.double_click_a_chain_or": "Double-clic sur le nom d’une chaîne ou d’une macro",
+ "preferences.double_click_a_knob_fader": "Double-clic sur un bouton rotatif, un fader ou un curseur",
+ "preferences.double_click_a_mod_matrix": "Double-clic sur une cellule de la matrice de modulation",
+ "preferences.double_click_a_panel_edge": "Double-clic sur le bord d’un panneau",
+ "preferences.double_click_a_track_header": "Double-clic sur un en-tête de piste",
+ "preferences.double_click_a_tracks_bottom": "Double-clic sur le bord inférieur d’une piste",
+ "preferences.double_click_and_hold_drag": "Double-clic maintenu, puis glisser",
+ "preferences.double_click_clip": "Double-clic sur un clip",
+ "preferences.double_click_empty_grid": "Double-clic sur la grille vide",
+ "preferences.double_click_header": "Double-clic sur un en-tête",
+ "preferences.double_click_in_an_mpe": "Double-clic dans un couloir MPE",
+ "preferences.double_click_loop_brace": "Double-clic sur l’accolade de boucle",
+ "preferences.double_click_overview": "Double-clic sur l’aperçu",
+ "preferences.double_click_section": "Double-clic sur une section",
+ "preferences.double_click_slot": "Double-clic sur un emplacement",
+ "preferences.double_click_the_wave": "Double-clic sur la forme d’onde",
+ "preferences.double_click_velocity_stem": "Double-clic sur une tige de vélocité",
+ "preferences.downloading": "Téléchargement de {0}…",
+ "preferences.downloads": "Téléchargements",
+ "preferences.downloads.ai_models": "Modèles d’IA",
+ "preferences.downloads.sample_packs": "Packs d’échantillons",
+ "preferences.drag_a_device_header": "Glisser l’en-tête d’un appareil",
+ "preferences.drag_a_device_onto_a": "Glisser un appareil sur une piste",
+ "preferences.drag_a_device_onto_a_2": "⌥-glisser un appareil sur une piste",
+ "preferences.drag_a_devices_header": "Glisser l’en-tête d’un appareil",
+ "preferences.drag_a_returns_or_the": "Glisser le bord inférieur d’un retour ou du master",
+ "preferences.drag_a_selected_devices_header": "Glisser l’en-tête d’un appareil sélectionné",
+ "preferences.drag_a_tracks_bottom_edge": "Glisser le bord inférieur d’une piste",
+ "preferences.drag_a_tracks_bottom_edge_2": "Glisser le bord inférieur d’une piste + ⌥",
+ "preferences.drag_a_warp_marker": "Glisser un marqueur de warp",
+ "preferences.drag_a_zone_edge": "Glisser le bord d’une zone",
+ "preferences.drag_an_audio_clip_onto": "Glisser un clip audio sur une piste d’instrument",
+ "preferences.drag_an_audio_clip_out": "Glisser un clip audio hors de l’arrangement",
+ "preferences.drag_an_audio_clips_adsr": "Glisser la poignée ADSR d’un clip audio",
+ "preferences.drag_below_the_last_track": "Glisser sous la dernière piste",
+ "preferences.drag_clip": "Glisser un clip",
+ "preferences.drag_clip_2": "Glisser un clip + ⌥",
+ "preferences.drag_double_click_tempo": "Glisser · double-clic sur Tempo",
+ "preferences.drag_in_a_controller_lane": "Glisser dans un couloir de contrôleur",
+ "preferences.drag_in_the_bend_pres": "Glisser dans le couloir Bend / Pres / Slide",
+ "preferences.drag_in_the_sustain_lane": "Glisser dans le couloir Sustain",
+ "preferences.drag_jack_jack": "Glisser jack → jack",
+ "preferences.drag_knob": "Glisser un bouton rotatif",
+ "preferences.drag_loop_edge_drag_loop": "Glisser le bord de la boucle · glisser l’accolade de boucle",
+ "preferences.drag_note_edge": "Glisser le bord d’une note",
+ "preferences.drag_on_the_keys": "Glisser sur les touches",
+ "preferences.drag_overview_edge": "Glisser le bord de l’aperçu",
+ "preferences.drag_overview_strip": "Glisser le bandeau d’aperçu",
+ "preferences.drag_scene": "Glisser une scène",
+ "preferences.drag_section": "Glisser une section",
+ "preferences.drag_section_2": "⌥-glisser une section",
+ "preferences.drag_section_edge": "Glisser le bord d’une section",
+ "preferences.drag_sections_lane": "Glisser dans le couloir des sections",
+ "preferences.drag_sideways_to_scroll_up": "Glisser latéralement pour défiler · vers le haut / le bas pour dézoomer / zoomer",
+ "preferences.drag_slider": "Glisser un curseur",
+ "preferences.drag_the_playhead_line": "Glisser la ligne de la tête de lecture",
+ "preferences.drag_the_track_list_edge": "Glisser le bord de la liste des pistes",
+ "preferences.drag_velocity_stem": "Glisser une tige de vélocité",
+ "preferences.draw_a_pedal_block_on": "Dessiner un bloc de pédale sur la grille · ⌘ hors de la grille · glisser un bord pour redimensionner, le corps pour déplacer · double-clic ou Delete le supprime",
+ "preferences.draw_the_controllers_curve_draws": "Dessiner la courbe du contrôleur · ⌥ trace une ligne droite · glisser un point pour le déplacer · double-clic ajoute ou supprime un point",
+ "preferences.draw_the_selected_notes_mpe": "Dessiner la courbe MPE de la note sélectionnée · ⌥ trace une ligne droite · glisser un point pour le déplacer",
+ "preferences.driver": "Pilote",
+ "preferences.driver_settings": "Réglages du pilote…",
+ "preferences.dropouts": { "one": "{0} décrochage", "other": "{0} décrochages" },
+ "preferences.duplicate_a_clip_into_the": "Dupliquer un clip dans l’emplacement du dessous · une scène sous elle-même",
+ "preferences.duplicate_the_selected_clip_s": "Dupliquer le ou les clips / la plage sélectionnés",
+ "preferences.duplicate_the_selected_device_with": "Dupliquer l’appareil sélectionné avec tous ses réglages",
+ "preferences.duplicate_the_selected_devices_each": "Dupliquer les appareils sélectionnés · chaque série juste après elle-même",
+ "preferences.duplicate_the_selected_tracks": "Dupliquer les pistes sélectionnées",
+ "preferences.duplicate_the_selection_replaces_the": "Dupliquer la sélection · remplace les notes sur lesquelles elle tombe",
+ "preferences.duplicate_time_insert_a_copy": "Dupliquer le temps · insérer une copie de la plage de temps après elle, en repoussant tout ce qui suit",
+ "preferences.edit_the_clip_an_empty": "Éditer le clip · un emplacement MIDI vide reçoit un nouveau clip",
+ "preferences.enable_mcp_server_let_an": "Activer le serveur MCP (laisser une IA piloter Nota)",
+ "preferences.end_macro_mapping_map_on": "Terminer l’assignation de macro (Assigner sur la carte du rack)",
+ "preferences.enter_leave_full_screen_the": "Entrer dans le plein écran / en sortir : la barre de titre se masque en plein écran",
+ "preferences.every_save_records_a_version": "Chaque enregistrement crée une version, listée dans l’onglet Historique du navigateur. Les versions partagent leur audio : chacune ne coûte que ce qu’elle ajoute.",
+ "preferences.exclusive_mode": "Mode exclusif",
+ "preferences.export_audio": "Exporter l’audio",
+ "preferences.expression": "Expression",
+ "preferences.extra_folders_are_searched_for": "Des dossiers supplémentaires sont explorés à la recherche de plug-ins VST3 à la prochaine analyse (les AU utilisent le registre du système).",
+ "preferences.face_buttons": "Boutons de face",
+ "preferences.filter_all_actions_tracks_devices": "Filtre : tout · actions · pistes · appareils · préréglages",
+ "preferences.filter_shortcuts": "Filtrer les raccourcis",
+ "preferences.fit_every_node_on_screen": "Ajuster tous les nœuds à l’écran",
+ "preferences.fit_the_whole_project_on": "Ajuster tout le projet à l’écran",
+ "preferences.fit_to_notes": "Ajuster aux notes",
+ "preferences.fold_only_the_scales_notes": "Replier : seulement les notes de la gamme, ou les pads d’un Drum Rack",
+ "preferences.follow_system": "Suivre le système",
+ "preferences.found_plugins": { "one": "{0:N0} plug-in trouvé.", "other": "{0:N0} plug-ins trouvés." },
+ "preferences.frames": "{0} échantillons @ {1}{2}",
+ "preferences.frames_set_in_the_drivers": "{0} échantillons (défini dans les réglages du pilote)",
+ "preferences.gamepad_input": "Entrée manette",
+ "preferences.gamepad_input_is_macos_only": "Les manettes ne sont prises en charge que sous macOS dans cette version.",
+ "preferences.gamepad_macos": "Manette (macOS)",
+ "preferences.gamepad_settings_are_unavailable_in": "Les réglages des manettes ne sont pas disponibles dans cette fenêtre.",
+ "preferences.gamepads": "Manettes",
+ "preferences.general": "Général",
+ "preferences.grid_arrangement_or_clip_editor": "Grille (arrangement ou éditeur de clips : le dernier utilisé)",
+ "preferences.group_the_selected_devices_into": "Grouper les appareils sélectionnés dans un rack · effets audio : Audio Effect Rack · effets MIDI : MIDI Effect Rack · avec l’instrument : Instrument Rack",
+ "preferences.group_ungroup_selected_tracks_on": "Grouper / dégrouper les pistes sélectionnées · sur des appareils sélectionnés : les grouper dans un rack / défaire un rack",
+ "preferences.hover_the_zones": "Survoler les zones",
+ "preferences.how_audio_clips_draw_on": "Dessin des clips audio dans l’arrangement : « Lisse » trace le contour des pics autour du niveau RMS ; « Plein » dessine chaque pixel ; « Barres » espace les pics pour que le rythme se lise. « Plein » et « Barres » règlent aussi l’aperçu du navigateur.",
+ "preferences.hz_sine_at_14_dbfs": "Sinus de {0:0} Hz à −14 dBFS, via le master.",
+ "preferences.in_a_linked_group_select": "Dans un groupe lié : sélectionner ce clip seul, ou armer cette piste seule",
+ "preferences.in_dark_mode": "En mode sombre",
+ "preferences.in_light_mode": "En mode clair",
+ "preferences.insert_a_scene_below_the": "Insérer une scène sous la sélection",
+ "preferences.insert_silence_push_everything_from": "Insérer du silence · repousser tout ce qui suit le début de la plage de sa longueur",
+ "preferences.install": "Installer",
+ "preferences.installed": "Installé",
+ "preferences.installed_to": "Installé dans {0}",
+ "preferences.installing": "Installation…",
+ "preferences.interface_scale": "Échelle de l’interface",
+ "preferences.jump_the_playhead_to_its": "Placer la tête de lecture à son début",
+ "preferences.keep_a_version_history_of": "Conserver un historique des versions de chaque projet",
+ "preferences.keep_the_name_empty_automatic": "Garder le nom (vide = automatique) · annuler",
+ "preferences.keyboard_reference": "Référence du clavier",
+ "preferences.label_every_note_in_the": "Nommer chaque note dans le piano roll",
+ "preferences.language": "Langue",
+ "preferences.language.applies_after_restart": "S’applique au redémarrage",
+ "preferences.language.applies_the_next_time_nota": "S’applique au prochain démarrage de Nota",
+ "preferences.language.restart": "Redémarrer",
+ "preferences.last": "Dernier",
+ "preferences.last_check_average_peak": "Dernier contrôle : {0:0} % en moyenne, {1:0} % au pic · {2} — {3}.",
+ "preferences.latency": "Latence",
+ "preferences.launch_the_selected_clip_or": "Lancer le clip ou la scène sélectionnés",
+ "preferences.layout": "Disposition",
+ "preferences.left": "Gauche",
+ "preferences.left_right_or_up_down": "Gauche / droite (ou haut / bas) change la valeur · maintenir ⌘ ou ⇧ pour des pas fins",
+ "preferences.library": "Bibliothèque",
+ "preferences.light": "Clair",
+ "preferences.link_the_groups_tracks_arming": "Lier les pistes du groupe : en armer une les arme toutes, et l’édition d’un clip agit sur les clips au même endroit sur chacune",
+ "preferences.listening_on_http_127_0": "Écoute sur http://127.0.0.1:{0}/ (boucle locale)",
+ "preferences.load_its_audio_into_the": "Charger son audio dans le Sampler, le Grain, le Drum Rack (prochain pad libre) ou l’Instrument Rack · s’y arrêter pour ouvrir ses appareils",
+ "preferences.loop_on_off_in_the": "Boucle activée / désactivée dans la règle · la région reste, grisée tant qu’elle est désactivée",
+ "preferences.loop_on_off_loop_the": "Boucle activée / désactivée · mettre en boucle les clips ou la plage de temps sélectionnés",
+ "preferences.loop_on_off_loop_the_2": "Boucle activée / désactivée · mettre la sélection en boucle · effacer la région de boucle",
+ "preferences.loop_recording_overdub_every_pass": "Enregistrement en boucle : Superposer (chaque passage s’ajoute) / Remplacer (garder le dernier passage)",
+ "preferences.lower_raise_velocity": "Baisser / augmenter la vélocité",
+ "preferences.make_it_the_active_clip": "En faire le clip actif (plusieurs clips ouverts) · son verrou le garde comme référence en lecture seule",
+ "preferences.makes_the_whole_interface_larger": "Agrandit ou réduit toute l’interface. Le zoom de la timeline, du piano roll et de l’éditeur audio s’applique par-dessus.",
+ "preferences.map_it_to_a_parameter": "L’assigner à un paramètre ou au sélecteur · effacer ses assignations",
+ "preferences.mappable_as_continuous_controls_a": "Assignables comme commandes continues (un bouton rotatif, un fader) ; ils ne jouent aucune note",
+ "preferences.mappable_through_midi_learn_a": "Assignable par MIDI Learn : un bouton assigné pilote la commande à la place",
+ "preferences.mark_a_new_section_over": "Marquer une nouvelle section sur les mesures parcourues",
+ "preferences.measures_audio_thread_load_for": "Mesure la charge du thread audio pendant 5 s : lancer la lecture du projet pour obtenir une valeur réaliste.",
+ "preferences.measuring": "Mesure…",
+ "preferences.measuring_5_s_left_play": "Mesure… encore 5 s : lancer la lecture du projet pour obtenir une valeur réaliste.",
+ "preferences.measuring_s_left_now": "Mesure… encore {0} s · actuellement {1:0} %",
+ "preferences.midi_inputs": "Entrées MIDI",
+ "preferences.midi_settings_are_unavailable_in": "Les réglages MIDI ne sont pas disponibles dans cette fenêtre.",
+ "preferences.models.ai_models_that_run_on": "Modèles d’IA exécutés sur cet ordinateur : l’audio qui leur est confié ne le quitte jamais. Chacun est téléchargé une seule fois depuis le site de ses auteurs, puis vérifié avec la somme de contrôle que Nota lui associe.",
+ "preferences.models.comes_with_a_model": "Fourni avec un modèle",
+ "preferences.models.is_installed_convert_melody_and": "{0} est installé : « Convertir la mélodie » et « Convertir l’harmonie » l’utilisent désormais.",
+ "preferences.models.is_installed_right_click_an": "{0} est installé : clic droit sur un clip audio, puis « Séparer les stems ».",
+ "preferences.models.model_ai_runtime_downloaded_once": "Modèle de {0} + environnement d’exécution IA de {1}, téléchargés une seule fois",
+ "preferences.models.on_disk": "Sur le disque",
+ "preferences.models.onnx_runtime_has_no_build": "ONNX Runtime n’existe pas pour cet ordinateur : les modèles ne peuvent pas s’y exécuter.",
+ "preferences.models.open_the_models_project_page": "Ouvrir la page du projet du modèle",
+ "preferences.models.remove_ai_model": "Supprimer le modèle d’IA",
+ "preferences.models.remove_will_offer_to_download": "Supprimer {0} ? {1} proposera de le télécharger à nouveau.",
+ "preferences.models.removing": "Suppression…",
+ "preferences.models.the_ai_runtime_goes_too": " Le moteur d’IA est supprimé aussi.",
+ "preferences.modular_after_a_click_on": "Modular (après un clic sur le canevas)",
+ "preferences.mouse": "Souris",
+ "preferences.move_earlier_later_duplicate_or": "Déplacer plus tôt / plus tard · dupliquer ou supprimer avec le contenu",
+ "preferences.move_freely_ignoring_the_grid": "Déplacer librement, sans tenir compte de la grille",
+ "preferences.move_it_there_out_of": "L’y déplacer (hors du panneau, sur une rangée de piste ou une colonne Session) · l’instrument remplace celui de cette piste et sa propre piste disparaît",
+ "preferences.move_it_to_another_slot": "Le déplacer vers un autre emplacement · ⌥ copie",
+ "preferences.move_it_within_its_chain": "Le déplacer dans sa chaîne · sur la rangée d’une autre chaîne pour l’y déplacer",
+ "preferences.move_notes_by_the_grid": "Déplacer les notes selon la grille",
+ "preferences.move_only_the_section_marker": "Déplacer seulement le repère de la section, calé sur les mesures",
+ "preferences.move_the_clips_to_a": "Déplacer les clips vers une nouvelle piste du même type que la leur · une par piste d’origine",
+ "preferences.move_the_playhead_there_drag": "Y déplacer la tête de lecture · glisser pour balayer · calé sur la grille sur un clip warpé, ⌥ hors de la grille",
+ "preferences.move_the_playhead_there_drag_2": "Y déplacer la tête de lecture · glisser pour balayer, calé sur la grille · ⌥ hors de la grille",
+ "preferences.move_the_selected_clips_to": "Déplacer les clips sélectionnés vers la piste suivante qui les accepte, sur les mêmes temps",
+ "preferences.move_the_selected_devices_of": "Déplacer ensemble les appareils sélectionnés de cette section",
+ "preferences.move_the_selection_between_slots": "Déplacer la sélection entre les emplacements et les scènes",
+ "preferences.move_through_samples_presets_and": "Parcourir les échantillons, les préréglages et les appareils · avec Auto activé, chacun est joué dès qu’il est sélectionné",
+ "preferences.move_through_the_results": "Parcourir les résultats",
+ "preferences.narrow_widen_the_grid_in": "Réduire / élargir la grille · en Auto, changer la densité",
+ "preferences.new_project_open_a_project": "Nouveau projet / ouvrir un projet",
+ "preferences.new_versions_of_nota": "Nouvelles versions de Nota",
+ "preferences.no_asio_driver_found_few": "Aucun pilote ASIO trouvé. Peu d’interfaces proposent déjà un pilote ASIO ARM64 : en installer un auprès du fabricant de l’interface, ou un pilote générique comme FlexASIO.",
+ "preferences.no_asio_driver_found_install": "Aucun pilote ASIO trouvé. Installer le pilote de l’interface, ou un pilote générique comme FlexASIO.",
+ "preferences.no_gamepad_detected_connect_one": "Aucune manette détectée. Une manette connectée apparaît ici.",
+ "preferences.no_inputs_on_this_driver": "Aucune entrée sur ce pilote",
+ "preferences.no_midi_inputs_detected_connect": "Aucune entrée MIDI détectée. Connecter un contrôleur, puis rouvrir les réglages.",
+ "preferences.nota_synth_volt_aurora_operator": "Nota Synth, Volt, Aurora, Operator, Pentad et Physical jouent l’expression par note.",
+ "preferences.notes_go_to_the_armed": "Les notes vont à la piste d’instrument armée (prête à enregistrer) : activer l’enregistrement pour les capturer, ou utiliser la piste d’écoute pour simplement jouer.",
+ "preferences.nothing_matches": "Aucun résultat.",
+ "preferences.nudge_the_selected_clips_by": "Décaler les clips sélectionnés d’une quadruple croche",
+ "preferences.nudge_the_selected_clips_by_2": "Décaler les clips sélectionnés du pas de la grille · s’arrête au début du morceau",
+ "preferences.octave_1_1": "Octave −1 / +1",
+ "preferences.off_a_click_only_selects": "Désactivé : un clic ne fait que sélectionner, et un panneau ouvert suit la sélection. Double-cliquer sur une piste pour ses appareils ou sur un clip pour le modifier.",
+ "preferences.open_close_the_command_palette": "Ouvrir / fermer la palette de commandes : depuis n’importe quelle fenêtre, même pendant la saisie",
+ "preferences.open_in_the_clip_editor": "Ouvrir dans l’éditeur de clips, en ouvrant le panneau de détail · sur l’un de plusieurs clips MIDI sélectionnés, les ouvrir tous ensemble",
+ "preferences.open_its_devices_in_the": "Ouvrir ses appareils dans le panneau de détail · la fenêtre d’un plug-in s’ouvre avec Open editor sur sa carte",
+ "preferences.open_plug_in_window_on": "Ouvrir la fenêtre du plug-in à l’insertion",
+ "preferences.open_the_detail_panel_when": "Ouvrir le panneau de détail à la sélection d’une piste ou d’un clip",
+ "preferences.output_check": "Contrôle de la sortie",
+ "preferences.overloaded_raise_the_buffer_size": "surchargé : augmenter la taille du tampon",
+ "preferences.paste_the_last_range_as": "Coller la dernière plage sous forme d’audio rendu à travers ses appareils",
+ "preferences.patch_a_cable_in_nota": "Brancher un câble dans Nota Consort · ⌥-clic sur un jack pour retirer ses câbles",
+ "preferences.per_note_expression_from_mpe": "Expression par note des contrôleurs MPE",
+ "preferences.performance": "Performances",
+ "preferences.phones_and_tablets_on_this": "Téléphones et tablettes sur ce réseau",
+ "preferences.pick_how_far_the_bend": "Choisir l’amplitude du couloir Bend : ±2, 12, 24, 48 ou 96 demi-tons · un bend déjà présent sur les notes peut l’élargir davantage",
+ "preferences.play_c4_d4_e4_f4": "Jouer C4 D4 E4 F4",
+ "preferences.play_from_that_point": "Lire à partir de ce point",
+ "preferences.play_g4_a4_b4_c5": "Jouer G4 A4 B4 C5",
+ "preferences.play_it_on_the_tracks": "La jouer sur l’instrument de la piste · ⇧-glisser parcourt les touches · ⌘-clic sélectionne toutes les notes de cette hauteur",
+ "preferences.play_notes_computer_keyboard": "Jouer des notes (clavier de l’ordinateur)",
+ "preferences.play_notes_or_drive_mapped": "Jouer des notes ou piloter les commandes assignées",
+ "preferences.play_pause_the_playhead_stays": "Lecture / pause · la tête de lecture reste en place et la lecture reprend à partir de là",
+ "preferences.play_stop_stop_goes_back": "Lecture / Arrêt · l’arrêt revient là où la lecture a commencé",
+ "preferences.play_stop_the_selected_sample": "Lire / arrêter l’échantillon, le préréglage ou l’appareil sélectionné",
+ "preferences.play_test_tone": "Jouer une tonalité de test",
+ "preferences.plenty_of_headroom": "large marge",
+ "preferences.plug_in_window": "Fenêtre du plug-in",
+ "preferences.plug_ins": "Plug-ins",
+ "preferences.plug_ins_sample_packs_and": "Plug-ins, packs d’échantillons et modèles d’IA",
+ "preferences.plugin_scan_folders": "Dossiers d’analyse des plug-ins",
+ "preferences.plugin_scanning_is_unavailable_in": "L’analyse des plug-ins n’est pas disponible dans cette fenêtre.",
+ "preferences.port": "Port",
+ "preferences.position_freely_ignoring_the_grid": "Positionner librement, sans tenir compte de la grille pour ce glissement (l’aimant du transport verrouille la même chose)",
+ "preferences.projects": "Projets",
+ "preferences.put_the_note_back_to": "Remettre la note à la vélocité par défaut (0,8) · toute la sélection si la note est sélectionnée · l’annulation se fait en une seule étape",
+ "preferences.quit_nota_asks_about_unsaved": "Quitter Nota · demande d’abord quoi faire des modifications non enregistrées",
+ "preferences.racks": "Racks",
+ "preferences.rearrange_the_song_it_and": "Réorganiser le morceau · la section et tout ce qu’elle contient vont à la limite marquée, les sections entre elles se resserrent · Esc annule",
+ "preferences.refresh": "Actualiser",
+ "preferences.refreshing": "Actualisation…",
+ "preferences.reload_the_registry": "Recharger le registre",
+ "preferences.remote": "Télécommande",
+ "preferences.remote.a_trusted_phone_reconnects_from": "Un téléphone de confiance se reconnecte depuis l’icône de son écran d’accueil, sans code. L’oublier l’oblige à scanner de nouveau. Désactiver la télécommande déconnecte tout le monde.",
+ "preferences.remote.allow_control_from_a_phone": "Autoriser le contrôle depuis un téléphone",
+ "preferences.remote.also_mixer_transport_macros_xy": "Aussi le mixeur, le transport, les macros, le XY et la vue Session.",
+ "preferences.remote.days_ago": "il y a {0} jours",
+ "preferences.remote.disconnect_it_and_make_it": "Le déconnecter et lui faire scanner un nouveau code pour revenir",
+ "preferences.remote.forget": "Oublier",
+ "preferences.remote.h_ago": "il y a {0} h",
+ "preferences.remote.just_now": "à l’instant",
+ "preferences.remote.listening_on": "Écoute sur {0}",
+ "preferences.remote.min_ago": "il y a {0} min",
+ "preferences.remote.no_phone_has_paired_yet": "Aucun téléphone n’est encore associé. Activer la télécommande et scanner le code dans « Connecter un téléphone ».",
+ "preferences.remote.nota_never_shows_files_or": " Nota n’affiche jamais de fichiers ni de chemins sur le téléphone, et ne sert rien depuis le disque.",
+ "preferences.remote.nota_remote": "Nota Remote",
+ "preferences.remote.now": "maintenant",
+ "preferences.remote.on_no_network": "Activée · pas de réseau",
+ "preferences.remote.pads_and_keys_mixer_transport": "Pads et touches. Le mixeur, le transport et les assignations sont en lecture seule.",
+ "preferences.remote.phones_may": "Les téléphones peuvent",
+ "preferences.remote.phones_reach_nota_on_the": "Les téléphones joignent Nota sur le port ci-dessus : si un pare-feu est actif, l’autoriser.",
+ "preferences.remote.play_and_control_the_project": "Jouer et piloter le projet",
+ "preferences.remote.play_notes_only": "Jouer des notes uniquement",
+ "preferences.remote.trusted_devices": "Appareils de confiance",
+ "preferences.remote.usb_caps": "USB ",
+ "preferences.remote.when_you_turn_this_on": "À l’activation, Windows demande si Nota peut utiliser le réseau. Il faut autoriser les réseaux privés, sinon les téléphones ne peuvent pas joindre Nota.",
+ "preferences.remote.when_you_turn_this_on_2": "À l’activation, macOS demande si Nota peut trouver des appareils sur le réseau local. Il faut l’autoriser, sinon les téléphones ne peuvent pas joindre Nota.",
+ "preferences.remove": "Supprimer",
+ "preferences.remove_the_selected_device_the": "Supprimer l’appareil sélectionné : l’en-tête n’a plus de bouton de fermeture",
+ "preferences.removing": "Suppression de {0}…",
+ "preferences.rename_it": "La renommer",
+ "preferences.rename_it_right_click_reset": "La renommer · clic droit → « Rétablir le nom par défaut » pour sa « Section N » automatique",
+ "preferences.rename_the_selected_clip_or": "Renommer le clip ou la scène sélectionnés",
+ "preferences.rename_the_track": "Renommer la piste",
+ "preferences.reorder_devices_or_right_click": "Réordonner les appareils (ou clic droit sur l’en-tête → Déplacer à gauche / à droite)",
+ "preferences.reorder_scenes": "Réordonner les scènes",
+ "preferences.replace_the_selected_device_instead": "Remplacer l’appareil sélectionné au lieu d’insérer après lui",
+ "preferences.rescan_plugins": "Relancer l’analyse des plug-ins",
+ "preferences.reset_the_detail_panel_the": "Rétablir la taille par défaut du panneau de détail, du mixeur ou du navigateur",
+ "preferences.reset_the_value_to_its": "Remettre la valeur par défaut",
+ "preferences.reset_velocity_from_a_menu": "Réinitialiser la vélocité depuis un menu · comme le double-clic",
+ "preferences.resize_every_track_at_once": "Redimensionner toutes les pistes à la fois",
+ "preferences.resize_it_snapped_to_bars": "La redimensionner, calée sur les mesures",
+ "preferences.resize_that_end_of_the": "Redimensionner cette extrémité de la région de boucle · déplacer toute la région · ⌥ hors de la grille",
+ "preferences.resize_that_row_header_or": "Redimensionner cette rangée (en-tête ou couloir) · mêmes crans · double-clic revient à compact",
+ "preferences.resize_the_track_header_or": "Redimensionner la piste (en-tête ou couloir) · se cale sur compact / standard / grand · une sélection multiple se redimensionne ensemble",
+ "preferences.return_esc_renaming_a_section": "Return · Esc (renommage d’une section)",
+ "preferences.return_esc_tab_tab_typing": "Return · Esc · Tab / ⇧Tab (saisie d’une valeur)",
+ "preferences.right": "Droite",
+ "preferences.right_click_a_device_header": "Clic droit sur l’en-tête d’un appareil",
+ "preferences.right_click_a_knob_fader": "Clic droit sur un bouton rotatif, un fader ou un curseur",
+ "preferences.right_click_a_macro": "Clic droit sur une macro",
+ "preferences.right_click_header_or_grid": "Clic droit sur un en-tête ou la grille",
+ "preferences.right_click_ruler": "Clic droit sur la règle",
+ "preferences.right_click_section": "Clic droit sur une section",
+ "preferences.right_click_the_metronome": "Clic droit sur le métronome",
+ "preferences.right_click_track_headers": "Clic droit sur les en-têtes de piste",
+ "preferences.right_click_velocity_stem": "Clic droit sur une tige de vélocité",
+ "preferences.round_trip": " · aller-retour {0}",
+ "preferences.sample_rate": "Fréquence d’échantillonnage",
+ "preferences.samples": "Échantillons",
+ "preferences.samples.credit": "Crédit : {0}",
+ "preferences.samples.download_samples_on_disk": "{0} à télécharger · {1} échantillons · {2} sur le disque · {3}",
+ "preferences.samples.free_sample_packs_from_the": "Packs d’échantillons gratuits issus du registre d’échantillons de Nota, utilisables pour toute musique, sorties commerciales comprises. Chaque pack est téléchargé depuis le site de son auteur, vérifié avec la somme de contrôle du registre, puis décompressé dans le dossier d’échantillons.",
+ "preferences.samples.is_installed_find_it_under": "{0} est installé : il se trouve sous « Téléchargés » dans l’onglet Fichiers du navigateur, où son tempo et sa tonalité sont en cours d’analyse ; ses instruments apparaissent sous Nota Mosaic → Packs.",
+ "preferences.samples.loading_the_sample_registry": "Chargement du registre d’échantillons…",
+ "preferences.samples.loops": "Boucles",
+ "preferences.samples.mixed": "Mixte",
+ "preferences.samples.no_sample_packs_installed_from": "Aucun pack d’échantillons installé depuis le registre pour l’instant.",
+ "preferences.samples.one_shots": "One-shots",
+ "preferences.samples.open_the_packs_page": "Ouvrir la page du pack",
+ "preferences.samples.remove_its_folder_is_deleted": "Supprimer {0} ? Son dossier ({1}) sera supprimé.",
+ "preferences.samples.remove_sample_pack": "Supprimer le pack d’échantillons",
+ "preferences.samples.samples": { "one": "{0} échantillon", "other": "{0} échantillons" },
+ "preferences.samples.samples_n": "{0} · {1} échantillons",
+ "preferences.samples.show_the_packs_folder": "Afficher le dossier du pack",
+ "preferences.save_a_version_with_a": "Enregistrer une version avec une note",
+ "preferences.save_records_a_version_save": "Enregistrer (crée une version) / enregistrer sous",
+ "preferences.saved_driver_not_found": "Pilote enregistré introuvable",
+ "preferences.scan": "Analyse",
+ "preferences.scanner_worker_not_found": "Processus d’analyse introuvable.",
+ "preferences.scanning": "Analyse…",
+ "preferences.scroll_it_sideways_over_an": "Le faire défiler latéralement · sur la poignée d’une bande d’EQ, la molette règle son Q ; sur une case de valeur, elle change la valeur par pas",
+ "preferences.scroll_on_the_track_button": "Défiler sur le bouton de piste",
+ "preferences.scrub_the_playhead": "Balayer avec la tête de lecture",
+ "preferences.scrub_the_playhead_on_the": "Balayer avec la tête de lecture · sur la règle ou sur la grille vide",
+ "preferences.search": "Rechercher",
+ "preferences.searching_folders": { "one": "Recherche dans {0} dossier", "other": "Recherche dans {0} dossiers" },
+ "preferences.see_which_chains_a_note": "Voir quelles chaînes jouerait une note",
+ "preferences.select_a_range_of_devices": "Sélectionner une série d’appareils (effets MIDI, instrument, effets audio) / en ajouter ou en retirer un",
+ "preferences.select_a_range_of_tracks": "Sélectionner une série de pistes / ajouter ou retirer une piste",
+ "preferences.select_all_clips": "Sélectionner tous les clips",
+ "preferences.select_all_notes": "Sélectionner toutes les notes",
+ "preferences.select_all_tracks": "Sélectionner toutes les pistes",
+ "preferences.select_and_play_it_drop": "La sélectionner et la jouer · y déposer un fichier pour charger un échantillon",
+ "preferences.select_it_for_c_x": "Le sélectionner pour ⌘C ⌘X ⌘V ⌘D et Delete",
+ "preferences.select_several_returns_they_resize": "Sélectionner plusieurs retours · ils se redimensionnent ensemble",
+ "preferences.semitones": "±{0} demi-tons",
+ "preferences.session_after_a_click_in": "Session (après un clic dans la grille)",
+ "preferences.set_a_chains_key_velocity": "Régler la plage de notes, de vélocité ou de sélection d’une chaîne · les bords ne se croisent jamais",
+ "preferences.set_every_track_to_compact": "Mettre toutes les pistes en Compact · Standard · Grand",
+ "preferences.set_in_the_drivers_settings": "Défini dans les réglages du pilote",
+ "preferences.set_it_cancel_set_it": "La valider · annuler · la valider et saisir la valeur suivante / précédente de la carte",
+ "preferences.set_the_tempo_the_clip": "Régler le tempo auquel le clip a été enregistré · ÷2 / ×2 le divisent ou le doublent",
+ "preferences.set_velocity_selected_notes_move": "Régler la vélocité · les notes sélectionnées bougent ensemble · ⇧ ajoute une note",
+ "preferences.shape_attack_decay_sustain_release": "Façonner l’attaque · le déclin + le maintien · le relâchement (coins du haut et point au survol) · ⌥-clic permet de saisir l’étape · double-clic la réinitialise",
+ "preferences.shape_the_new_note_move": "Façonner la nouvelle note : la déplacer · ⇧ pour régler sa longueur · ⌘ glisser vers le haut / le bas pour la vélocité",
+ "preferences.shift_octave_down_up": "Octave vers le bas / vers le haut",
+ "preferences.shift_the_gamepad_octave": "Changer l’octave de la manette",
+ "preferences.shortcuts": "Raccourcis",
+ "preferences.shorten_lengthen_the_notes_by": "Raccourcir / allonger les notes selon la grille",
+ "preferences.shoulder_buttons": "Boutons d’épaule",
+ "preferences.show_a_midi_controller_under": "Afficher un contrôleur MIDI sous les notes · cliquer à nouveau pour choisir un autre CC, la molette de hauteur ou la pression de canal",
+ "preferences.show_fewer_parameters_on_every": "Afficher moins de paramètres sur chaque nœud ouvert",
+ "preferences.show_playhead_scroll_the_arrangement": "Afficher la tête de lecture · faire défiler l’arrangement jusqu’à elle sans la déplacer · reprend un suivi en pause",
+ "preferences.shows_every_note_name_c": "Affiche le nom de chaque note (C, D, E…) sur les touches du piano roll, et non seulement celui des C. Utile pour apprendre les notes.",
+ "preferences.smooth": "Lisse",
+ "preferences.snap_to_grid_on_off": "Magnétisme sur la grille activé / désactivé",
+ "preferences.solid": "Plein",
+ "preferences.source": "Source",
+ "preferences.split_at_the_playhead_at": "Découper à la tête de lecture · aux bords de la plage",
+ "preferences.status": "État",
+ "preferences.step": "Pas",
+ "preferences.step_on_off_accent_quiet": "Pas activé / désactivé · accent · pas doux — glisser pour peindre, haut / bas (ou défilement) pour sa vélocité",
+ "preferences.step_through_the_demo_tracks": "Parcourir les pistes de démonstration à travers lesquelles un préréglage d’effet s’écoute",
+ "preferences.sticks_triggers": "Sticks · gâchettes",
+ "preferences.stop_again_back_to_the": "Arrêt (de nouveau → retour au début) · dans la grille Session, lance la sélection",
+ "preferences.stop_tone": "Arrêter la tonalité",
+ "preferences.store.apple_silicon": "Apple silicon",
+ "preferences.store.apple_silicon_intel": "Apple silicon + Intel",
+ "preferences.store.collection": "Collection",
+ "preferences.store.effect": "Effet",
+ "preferences.store.effects": "Effets",
+ "preferences.store.is_installed_find_it_in": "{0} {1} est installé : il se trouve dans le navigateur.",
+ "preferences.store.is_installed_rescan_plugins_to": "{0} est installé. Relancer l’analyse des plug-ins pour l’utiliser.",
+ "preferences.store.linux": "Linux",
+ "preferences.store.loading_the_plugin_registry": "Chargement du registre de plug-ins…",
+ "preferences.store.no_version": "Pas de version {0}",
+ "preferences.store.no_version_for": "Pas de version {0} pour {1}",
+ "preferences.store.not_available_for_this_computer": "Indisponibles pour cet ordinateur",
+ "preferences.store.nothing_installed_from_the_registry": "Rien d’installé depuis le registre pour l’instant.",
+ "preferences.store.open_source_vst3_plugins_from": "Plug-ins VST3 open source issus du registre de plug-ins de Nota. Chacun est téléchargé depuis la publication GitHub du projet, vérifié avec la somme de contrôle du registre, puis décompressé : aucun installeur n’est jamais exécuté.",
+ "preferences.store.open_the_source_repository": "Ouvrir le dépôt source",
+ "preferences.store.remove_plugin": "Supprimer le plug-in",
+ "preferences.store.remove_projects_that_use_it": "Supprimer {0} ? Les projets qui l’utilisent se chargeront sans lui tant qu’il ne sera pas réinstallé.",
+ "preferences.store.scanning": "Analyse de {0}…",
+ "preferences.store.stop_the_download_nothing_is": "Arrêter le téléchargement : rien n’est modifié",
+ "preferences.store.windows": "Windows",
+ "preferences.swap_it_onto_the_selected": "L’échanger sur la piste d’instrument sélectionnée · les clips et les effets restent · sans piste sélectionnée, en crée une",
+ "preferences.switch_a_controller_off_to": "Désactiver un contrôleur pour que Nota cesse de l’écouter. Les nouveaux périphériques sont activés par défaut.",
+ "preferences.switch_between_the_adaptive_auto": "Basculer entre la grille adaptative (Auto) et une grille fixe",
+ "preferences.switch_it_between_bars_and": "Basculer entre mesures et temps · toutes les règles suivent",
+ "preferences.switch_the_well_between_the": "Basculer la zone entre la forme d’onde et un spectre en direct",
+ "preferences.system_default": "Par défaut du système",
+ "preferences.take_it_as_a_sample": "Le prendre comme échantillon : le déposer sur un pad, un Grain, une voix Rhythm, un emplacement Session ; le clip reste en place",
+ "preferences.take_the_devices_out_of": "Sortir les appareils d’un rack à une seule chaîne sélectionné",
+ "preferences.test": "Test",
+ "preferences.the_clip_editor_fills_the": "L’éditeur de clips remplit la fenêtre / retour à la répartition précédente",
+ "preferences.the_devices_native_sample_rate": "La fréquence d’échantillonnage et la taille de tampon natives du périphérique remplacent celles ci-dessus. Si le périphérique est occupé ou n’autorise pas l’accès exclusif, Nota revient au mode partagé.",
+ "preferences.the_driver_didnt_start": "le pilote ne s’est pas lancé",
+ "preferences.the_driver_doesnt_support": "Le pilote ne prend pas en charge {0}",
+ "preferences.the_language_of_menus_panels": "La langue des menus, des panneaux et des messages. Elle change au redémarrage de Nota. Les fichiers de projet et les noms saisis ne sont jamais traduits.",
+ "preferences.theme_scale_waveforms_and_ai": "Thème, échelle, formes d’onde et contrôle par IA",
+ "preferences.themes_change_colours_only_follow": "Les thèmes ne changent que les couleurs. « Suivre le système » alterne entre le thème du mode sombre et celui du mode clair, selon l’apparence de l’OS.",
+ "preferences.this_erases_the_version_history": "Cela efface dès maintenant l’historique des versions du projet ouvert, et celui de tout autre projet au prochain enregistrement. Les anciennes versions ne pourront pas être restaurées.",
+ "preferences.toggle_automation_mode": "Activer / désactiver le mode automation",
+ "preferences.toggle_the_mixer_view": "Afficher / masquer la vue Mixeur",
+ "preferences.track_headers": "En-têtes de piste",
+ "preferences.tracks_after_a_click_in": "Pistes (après un clic dans les en-têtes de piste)",
+ "preferences.transpose_by_a_semitone": "Transposer d’un demi-ton",
+ "preferences.transpose_by_an_octave": "Transposer d’une octave",
+ "preferences.triplet_grid_on_off": "Grille en triolets activée / désactivée",
+ "preferences.turn_off_and_erase": "Désactiver et effacer",
+ "preferences.turn_off_version_history": "Désactiver l’historique des versions",
+ "preferences.type_a_value_units_like": "Saisir une valeur (les unités comme k, ms, dB, L / R fonctionnent) · un double-clic sur sa valeur fait de même",
+ "preferences.type_first_to_filter_actions": "Saisir d’abord pour filtrer : actions, pistes, appareils, préréglages, nœuds Modular",
+ "preferences.type_its_values_a_node": "Saisir ses valeurs : un nœud qui en a plusieurs (fréquence · gain · Q, déclin · maintien) utilise Tab pour passer de l’une à l’autre",
+ "preferences.type_the_preview_volume_double": "Saisir le volume d’aperçu · double-clic le remet à 0 dB",
+ "preferences.type_value_reset_to_default": "Saisir une valeur… · Rétablir la valeur par défaut",
+ "preferences.undo_redo": "Annuler / rétablir",
+ "preferences.update_to": "Mettre à jour vers {0}",
+ "preferences.updates": "Mises à jour",
+ "preferences.updates.automatic_updates": "Mises à jour automatiques",
+ "preferences.updates.check_for_updates_automatically": "Rechercher les mises à jour automatiquement",
+ "preferences.updates.check_now": "Rechercher maintenant",
+ "preferences.updates.checking": "Recherche…",
+ "preferences.updates.couldnt_reach_github_to_check": "Impossible de joindre GitHub pour rechercher une nouvelle version. Vérifier la connexion Internet, puis réessayer.",
+ "preferences.updates.download_opens_the_release_page": "« Télécharger » ouvre la page de la version.",
+ "preferences.updates.it_installs_the_next_time": "Elle s’installe à la prochaine fermeture de Nota, ou en cliquant sur « Redémarrer pour mettre à jour » dans la barre d’état.",
+ "preferences.updates.last_checked": "Dernière recherche : {0}.",
+ "preferences.updates.not_checked_yet": "Pas encore recherchée.",
+ "preferences.updates.nota_is_available_you_have": "Nota {0} est disponible : la version installée est la {1}.",
+ "preferences.updates.nota_is_ready_to_install": "Nota {0} est prêt à être installé.",
+ "preferences.updates.nota_is_the_latest_version": "Nota {0} est la dernière version.",
+ "preferences.updates.on_launch_and_once_a": "Au lancement, puis une fois par jour, Nota demande à GitHub si une version plus récente est disponible et l’indique dans la barre d’état. Rien n’est téléchargé avant un clic sur « Mettre à jour ».",
+ "preferences.updates.the_update_didnt_download": "La mise à jour n’a pas pu être téléchargée.",
+ "preferences.updates.this_copy_of_nota_cant": "Cet exemplaire de Nota ne peut pas se remplacer lui-même (version de développement, ou lancée directement depuis l’image disque) : une nouvelle version ouvre donc sa page de publication pour être téléchargée.",
+ "preferences.updates.this_version": "Cette version",
+ "preferences.updates.update_downloads_it_here_it": "« Mettre à jour » la télécharge ici ; elle s’installe au redémarrage ou à la fermeture de Nota.",
+ "preferences.updates.you_have_nota": "La version installée de Nota est la {0}.",
+ "preferences.use_a_connected_gamepad_for": "Utiliser une manette connectée pour les notes et les commandes assignées",
+ "preferences.velocity": "Vélocité − / +",
+ "preferences.velocity_10_10_by_1": "Vélocité +10 / −10 · ⌥⇧ par 1",
+ "preferences.velocity_wheel": "Molette de vélocité",
+ "preferences.version_history": "Historique des versions",
+ "preferences.was_removed": "{0} a été supprimé.",
+ "preferences.wasapi_exclusive_lowest_latency_mutes": "WASAPI exclusif : latence minimale, coupe le son des autres applications",
+ "preferences.waveform": "Forme d’onde",
+ "preferences.wheel_over_a_note": "⇧ + molette sur une note",
+ "preferences.wheel_over_a_note_in": "⇧ + molette sur une note du piano roll change sa vélocité, ou celle de toute la sélection si cette note est sélectionnée : un pas MIDI par cran à 1×. Partout ailleurs, ⇧ + molette fait défiler, et « Désactivé » la laisse défiler partout.",
+ "preferences.wheel_over_the_device_chain": "Molette sur la chaîne d’appareils",
+ "preferences.wheel_up_lowers_the_velocity": "Molette vers le haut : baisse la vélocité",
+ "preferences.where_nota_looks_for_vst3": "Où Nota cherche les VST3",
+ "preferences.which_side_of_the_arrangement": "Côté de l’arrangement où se trouve la liste des pistes. « Droite » fait commencer la timeline au bord gauche, contre le navigateur. Aussi dans le menu Affichage.",
+ "preferences.while_dragging_a_warp_marker": "Pendant le glissement d’un marqueur de warp ou d’un tempo de segment : le remettre en place",
+ "preferences.white_keys_from_c4": "Touches blanches, à partir de C4",
+ "preferences.widen_or_narrow_the_track": "Élargir ou rétrécir les en-têtes de piste · double-clic réinitialise",
+ "preferences.window": "Fenêtre",
+ "preferences.working": "En cours…",
+ "preferences.zoom_by_resizing_the_viewport": "Zoomer en redimensionnant la fenêtre de visualisation",
+ "preferences.zoom_rows_down_taller_up": "Zoom des rangées · vers le bas plus hautes, vers le haut plus basses",
+ "preferences.zoom_rows_trackpad": "Zoom des rangées (trackpad)",
+ "preferences.zoom_rows_vertical_zoom": "Zoom des rangées (zoom vertical)",
+ "preview_player.auto": "Auto ({0})",
+ "preview_player.auto_audition_play_a_preset": "Pré-écoute auto : jouer un préréglage ou un appareil à la sélection",
+ "preview_player.auto_audition_play_a_sample": "Pré-écoute auto : jouer un échantillon à la sélection",
+ "preview_player.auto_audition_play_on_select": "Pré-écoute auto : jouer à la sélection",
+ "preview_player.auto_for_this_effect": " (auto pour cet effet)",
+ "preview_player.bit_float": "{0} bits flottants",
+ "preview_player.heard_through_click_to_pick": "Entendu via {0} — cliquer pour choisir une piste, défiler pour les parcourir",
+ "preview_player.no_sound_to_preview": "aucun son à pré-écouter",
+ "preview_player.picked_for_this_effect_drums": "Choisi pour cet effet : batterie pour la dynamique, claviers pour le temps et la modulation, mix complet pour le timbre",
+ "preview_player.play_to_see_the_spectrum": "lancer la lecture pour voir le spectre",
+ "preview_player.preview_failed": "Échec de la pré-écoute : {0}",
+ "preview_player.preview_volume": "Volume de pré-écoute",
+ "preview_player.preview_volume_click_to_type": "Volume de pré-écoute {0} · ⌥-clic pour saisir · double-clic pour 0{1}dB",
+ "preview_player.previewing": "Pré-écoute de {0}",
+ "preview_player.sample": "Échantillon — {0}",
+ "preview_player.sample_pick_one_in_files": "Échantillon — en choisir un dans Fichiers",
+ "preview_player.spec": "Spec",
+ "preview_player.wave": "Onde",
+ "progress.cancelling": "Annulation…",
+ "record_input_pick.audio_input_1_mono": "Entrée audio 1 (mono)",
+ "record_input_pick.audio_input_2_mono": "Entrée audio 2 (mono)",
+ "record_input_pick.audio_inputs_1_2_stereo": "Entrées audio 1/2 (stéréo)",
+ "record_input_pick.ext": "Ext",
+ "record_input_pick.ext_1": "Ext 1",
+ "record_input_pick.ext_2": "Ext 2",
+ "registry.client.couldnt_download": "Impossible de télécharger {0} : {1}",
+ "registry.client.couldnt_reach_the_check_your": "Impossible de joindre le {0}. Vérifier la connexion Internet.",
+ "registry.client.the_download_of_doesnt_match": "Le téléchargement de {0} ne correspond pas à la somme de contrôle du registre — il n’est pas installé.",
+ "registry.client.the_download_of_is_larger": "Le téléchargement de {0} est plus volumineux que ce qu’indique le registre — il n’est pas installé.",
+ "registry.client.unsafe_path_in_the_registry": "Chemin dangereux dans l’entrée du registre : {0}",
+ "remote.connect.address": "Adresse",
+ "remote.connect.allow": "Autoriser",
+ "remote.connect.code": "Code",
+ "remote.connect.connect_phone": "Connecter un téléphone",
+ "remote.connect.connected": "connecté",
+ "remote.connect.connecting": "connexion",
+ "remote.connect.disconnect_this_phone_it_stays": "Déconnecter ce téléphone (il reste de confiance — l’oublier dans Réglages → Télécommande)",
+ "remote.connect.ms": "{0} ms · {1}",
+ "remote.connect.ms_weak_network": "{0} ms · réseau faible",
+ "remote.connect.point_the_phone_camera_at": "Pointer la caméra du téléphone vers le code. Par câble, la liaison est instantanée et sans Wi-Fi ; le code change toutes les 2 minutes et après chaque connexion.",
+ "remote.connect.point_the_phone_camera_at_2": "Pointer la caméra du téléphone vers le code. Même Wi-Fi uniquement — ou brancher un câble USB (partage de connexion USB sur le téléphone ; Partage Internet sur le Mac) pour une liaison instantanée. Le code change toutes les 2 minutes et après chaque connexion.",
+ "remote.connect.remote_is_off_turn_it": "La télécommande est désactivée. L’activer pour afficher un code QR qu’un téléphone sur le même Wi-Fi peut scanner.",
+ "remote.connect.remote_is_off_turn_it_2": "La télécommande est désactivée. L’activer pour afficher un code QR. La première fois, Windows demande si Nota peut utiliser le réseau ; autoriser les réseaux privés.",
+ "remote.connect.remote_is_off_turn_it_3": "La télécommande est désactivée. L’activer pour afficher un code QR. La première fois, macOS demande d’autoriser Nota sur le réseau local ; cliquer sur Autoriser.",
+ "remote.connect.this_computer_isnt_on_a": "Cet ordinateur n’est pas sur un réseau. Rejoindre le même Wi-Fi que le téléphone, partager le point d’accès du téléphone avec lui, ou brancher un câble USB (partage de connexion USB sur le téléphone ; Partage Internet sur le Mac).",
+ "remote.connect.usb_caps": "USB",
+ "remote.connect.usb_ms": "USB · {0} ms · {1}",
+ "remote.port_is_in_use_by": "Le port {0} est utilisé par une autre application. Choisir un autre port.",
+ "sample_store.couldnt_remove_the_packs_files": "Impossible de supprimer les fichiers du pack — fermer ce qui les utilise puis réessayer.",
+ "sample_store.installing": "Installation de {0}…",
+ "sample_store.invalid_pack_id": "Identifiant de pack « {0} » invalide.",
+ "sample_store.needs_of_free_space_in": "{0} demande {1} d’espace libre dans le dossier Échantillons, qui en a {2}.",
+ "sample_store.sample_index.the_sample_registry_needs_a": "Le registre d’échantillons demande une version plus récente de Nota.",
+ "sample_store.the_download_of_contains_no": "Le téléchargement de {0} ne contient aucun échantillon utilisable par Nota.",
+ "sample_store.the_download_of_doesnt_contain": "Le téléchargement de {0} ne contient pas {1}.",
+ "sample_store.the_sample_registry_index_is": "L’index du registre d’échantillons est endommagé.",
+ "sample_store.unpacking_needs_of_free_space": "La décompression de {0} demande {1} d’espace libre sur le disque système, qui en a {2}.",
+ "save_changes.dont_save": "Ne pas enregistrer",
+ "save_changes.save": "Enregistrer",
+ "save_changes.saving": "Enregistrement…",
+ "session.bars": { "one": "{0} mesure", "other": "{0} mesures" },
+ "session.bars_n": "{0}.{1} mesures",
+ "session.captured": "Capturé",
+ "session.captured_the_playing_clips_into": "Clips en lecture capturés dans une nouvelle scène",
+ "session.copied_clip": "Clip copié",
+ "session.copied_clip_to_the_arrangement": "Clip copié dans l’arrangement à la tête de lecture",
+ "session.copied_clips_to_the_arrangement": "{0} clips copiés dans l’arrangement à la tête de lecture",
+ "session.cut_clip_paste_to_move": "Clip coupé — coller pour le déplacer",
+ "session.deleted_clip": "Clip supprimé",
+ "session.deleted_scene": "Scène supprimée",
+ "session.duplicated_clip": "Clip dupliqué",
+ "session.duplicated_scene": "Scène dupliquée",
+ "session.grid.add_a_scene_at_the": "Ajouter une scène à la fin",
+ "session.grid.add_audio_track": "Ajouter une piste audio",
+ "session.grid.add_instrument_track": "Ajouter une piste d’instrument",
+ "session.grid.add_return_track": "Ajouter une piste de retour",
+ "session.grid.add_stop_button": "Ajouter un bouton d’arrêt",
+ "session.grid.add_track": "Ajouter une piste",
+ "session.grid.arr": "Arr",
+ "session.grid.back_to_arrangement_for_this": "Retour à l’arrangement pour cette piste",
+ "session.grid.capture_playing_clips_below": "Capturer les clips en lecture dessous",
+ "session.grid.copy_scene_to_arrangement": "Copier la scène vers l’arrangement",
+ "session.grid.copy_to_arrangement": "Copier vers l’arrangement",
+ "session.grid.delete_group_and_its_tracks": "Supprimer le groupe et ses pistes",
+ "session.grid.delete_scene": "Supprimer la scène",
+ "session.grid.drop_a_midi_clip_on": "Déposer un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
+ "session.grid.fold_the_group_into_one": "Replier le groupe en une colonne",
+ "session.grid.insert_scene_below": "Insérer une scène dessous",
+ "session.grid.launch_scene": "Lancer la scène",
+ "session.grid.moved_scene": "Scène déplacée",
+ "session.grid.rec_in": "Rec dans…",
+ "session.grid.remove_stop_button": "Retirer le bouton d’arrêt",
+ "session.grid.scene": "+ Scène",
+ "session.grid.scene_2": "{0} · scène {1}",
+ "session.grid.scene_n": "Scène · {0}",
+ "session.grid.scenes": "Scènes",
+ "session.grid.show_the_groups_tracks": "Afficher les pistes du groupe",
+ "session.grid.stop_all_clips": "Arrêter tous les clips",
+ "session.grid.stop_every_track_in_this": "Arrêter toutes les pistes de ce groupe",
+ "session.grid.stop_scene": "Arrêter la scène",
+ "session.grid.stop_this_track": "Arrêter cette piste",
+ "session.group": "Groupe · {0}{1}",
+ "session.insert_midi_clip": "Insérer un clip MIDI",
+ "session.inserted_scene": "Scène insérée",
+ "session.inspector.16_bars": "16 mesures",
+ "session.inspector.1_beat": "1 temps",
+ "session.inspector.2_bars": "2 mesures",
+ "session.inspector.2_beats": "2 temps",
+ "session.inspector.4_bars": "4 mesures",
+ "session.inspector.8_bars": "8 mesures",
+ "session.inspector.after": "Après",
+ "session.inspector.again": "Encore",
+ "session.inspector.any": "Quelconque",
+ "session.inspector.chance_of_a_in_percent": "Probabilité de A en pourcentage · B reçoit le reste · glisser",
+ "session.inspector.click_again_to_use_the": "Cliquer de nouveau pour utiliser la couleur par défaut",
+ "session.inspector.click_selects_the_triangle_launches": "Clic sélectionne · le triangle lance · Entrée lance la sélection\n←↑↓→ déplacer · ⌘C ⌘V ⌘D · ⌫ supprimer · ⌘I insérer une scène\n⌘⇧C copier vers l’arrangement · ⌘V colle les clips copiés là",
+ "session.inspector.clips": { "one": "{0} clip", "other": "{0} clips" },
+ "session.inspector.color": "Couleur",
+ "session.inspector.empty_slot": "Emplacement vide",
+ "session.inspector.every_track_ends_up_here": "Toutes les pistes aboutissent ici. Ses appareils sont dans le panneau Appareils.",
+ "session.inspector.first": "Premier",
+ "session.inspector.follow_action": "Action de suivi",
+ "session.inspector.global": "Global",
+ "session.inspector.group_slot_tracks_caps": "EMPLACEMENT DE GROUPE · {0} PISTES",
+ "session.inspector.insert_below": "Insérer dessous",
+ "session.inspector.jump": "Saut",
+ "session.inspector.jump_to": "Sauter à",
+ "session.inspector.last": "Dernier",
+ "session.inspector.launch_group_slot": "Lancer l’emplacement du groupe",
+ "session.inspector.launch_without_a_tempo_change": "Lancer sans changement de tempo",
+ "session.inspector.launches_every_tracks_slot_in": "Lance l’emplacement de chaque piste dans cette scène. Le bouton d’arrêt les arrête tous.",
+ "session.inspector.launching_this_scene_keeps_playing": "Le lancement de cette scène laisse {0} en lecture.",
+ "session.inspector.launching_this_scene_stops": "Le lancement de cette scène arrête {0}.",
+ "session.inspector.legato": "Legato",
+ "session.inspector.loop_end": "Fin de boucle",
+ "session.inspector.next": "Suivant",
+ "session.inspector.next_after": "Suivant après {0}",
+ "session.inspector.next_n": "Suivant · {0}",
+ "session.inspector.off_globally": "Désactivé globalement",
+ "session.inspector.off_one_shot": "Désactivé · one-shot",
+ "session.inspector.one_pass": "Un passage",
+ "session.inspector.previous": "Précédent",
+ "session.inspector.removed": "Retiré",
+ "session.inspector.rename": "Renommer",
+ "session.inspector.repeat": "Répéter",
+ "session.inspector.scene_caps": "SCÈNE {0:00} · {1}",
+ "session.inspector.select_next_scene_on_launch": "Sélectionner la scène suivante au lancement",
+ "session.inspector.signature": "Signature",
+ "session.inspector.stop_button": "Bouton d’arrêt",
+ "session.inspector.stop_group": "Arrêter le groupe",
+ "session.inspector.stop_recording": "Arrêter l’enregistrement",
+ "session.inspector.tempo": "Tempo",
+ "session.inspector.tempo_set_when_the_scene": "Tempo réglé au lancement de la scène · glisser pour le changer",
+ "session.inspector.to_arrangement": "Vers l’arrangement",
+ "session.inspector.toggle": "Bascule",
+ "session.inspector.tracks_reach_it_through_their": "Les pistes l’atteignent par leurs envois. Il n’a pas d’emplacements de clips ; ses appareils sont dans le panneau Appareils.",
+ "session.inspector.trigger": "Déclencheur",
+ "session.inspector.trigger_starts_gate_plays_while": "Déclencheur démarre · Gate joue tant que tenu · Bascule démarre et arrête · Répéter redéclenche tant que tenu",
+ "session.inspector.velocity": "Vélocité %",
+ "session.inspector.velocity_amount_how_far_the": "Quantité de vélocité : dans quelle mesure la vélocité de lancement met le clip à l’échelle · glisser",
+ "session.launch": "Lancer",
+ "session.mixer.all_ins": "Toutes les entrées",
+ "session.mixer.in_hear_the_input_live": "Entrée : entendre l’entrée en direct à travers cette piste · Auto : seulement pendant l’enregistrement",
+ "session.mixer.midi_input_every_input_or": "Entrée MIDI : toutes les entrées, ou une autre piste d’instrument",
+ "session.mixer.monitor": "Écoute",
+ "session.mixer.output_group_a_track_to": "Sortie — grouper une piste pour la router à travers le groupe",
+ "session.mixer.send": "Envoi",
+ "session.mixer.send_n": "Envoi {0} · {1}",
+ "session.moved_clip": "Clip déplacé",
+ "session.paste_a_midi_clip_onto": "Coller un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
+ "session.pasted_clip": "Clip collé",
+ "session.pasted_clip_from_the_arrangement": "Clip de l’arrangement collé",
+ "session.pasted_clips_from_the_arrangement": "{0} clips de l’arrangement collés",
+ "session.record_here": "Enregistrer ici",
+ "session.recording": "Enregistrement",
+ "session.scene": "Scène {0}",
+ "session.stop_every_session_clip": "Arrêter tous les clips de la session",
+ "session.the_slot_below_is_taken": "L’emplacement du dessous est occupé.",
+ "session.toolbar.1_bar": "1 mesure",
+ "session.toolbar.2_bars": "2 mesures",
+ "session.toolbar.4_bars": "4 mesures",
+ "session.toolbar.8_bars": "8 mesures",
+ "session.toolbar.arm_a_track_with_an": "Armer une piste avec un emplacement vide dans cette scène pour enregistrer.",
+ "session.toolbar.back_to_arrangement": "Retour à l’arrangement",
+ "session.toolbar.capture_scene": "Capturer la scène",
+ "session.toolbar.copy_the_clips_playing_now": "Copier les clips en lecture dans une nouvelle scène",
+ "session.toolbar.fixed": "Fixe",
+ "session.toolbar.fixed_record_length_in_bars": "Durée d’enregistrement fixe en mesures — la prise s’arrête d’elle-même",
+ "session.toolbar.follow": "Suivi",
+ "session.toolbar.follow_actions_on_or_off": "Actions de suivi activées ou désactivées pour chaque clip et chaque scène",
+ "session.toolbar.hide": "Masquer",
+ "session.toolbar.inspector": "Inspecteur",
+ "session.toolbar.inspector_show_or_hide_it": "Inspecteur — l’afficher ou le masquer",
+ "session.toolbar.launch_quantize_when_clips_and": "Quantification du lancement : quand les clips et les scènes démarrent",
+ "session.toolbar.more_session_controls": "Plus de commandes de session",
+ "session.toolbar.quant": "Quant",
+ "session.toolbar.record_into_the_armed_track": "Enregistrer dans la piste armée à la scène sélectionnée · cliquer de nouveau pour garder la prise",
+ "session.toolbar.session_rec": "Rec session",
+ "session.toolbar.stop_all": "Tout arrêter",
+ "session.toolbar.stop_session_clips_and_hand": "Arrêter les clips de la session et rendre chaque piste à l’arrangement",
+ "session.toolbar.turn_follow_off": "Désactiver le suivi",
+ "session.toolbar.turn_follow_on": "Activer le suivi",
+ "snap_chip.1_2_narrow_widen_3": "⌘1 ⌘2 réduire / élargir · ⌘3 triolets · ⌘4 magnétisme · ⌘5 auto",
+ "snap_chip.auto": "Auto · {0}",
+ "snap_chip.auto_grid": "Grille auto",
+ "snap_chip.finer_than_the_visible_grid": "{0} — plus fin que la grille visible · zoomer pour la voir",
+ "snap_chip.hold_to_drag_freely": "{0}\n{1} · maintenir ⌥ pour déplacer librement",
+ "snap_chip.snap_grid_auto_follows_the": "Grille magnétique · Auto suit le zoom ({0})",
+ "snap_chip.snap_grid_fixed": "Grille magnétique · fixe {0}",
+ "snap_chip.snap_off_items_move_freely": "Magnétisme désactivé — les éléments se déplacent librement (⌘4)",
+ "snap_chip.snap_to_grid": "Magnétisme sur la grille",
+ "snap_chip.triplets": "Triolets",
+ "stereo_map.balance": "Balance",
+ "stereo_map.below_60_dbfs_so_the": "Sous −60 dBFS : le nuage est masqué.",
+ "stereo_map.correlation": "Corrélation",
+ "stereo_map.drag_pan_volume_shift_locks": "Glisser : pan + volume · Shift verrouille l’axe · double-clic centre le pan · ⌥-clic pour saisir",
+ "stereo_map.image_is_off_the_pan": "L’image est décalée du pan",
+ "stereo_map.level": "Niveau",
+ "stereo_map.muted": "En sourdine",
+ "stereo_map.no_cloud_while_the_track": "Pas de nuage tant que la piste est en sourdine.",
+ "stereo_map.silent": "Silence",
+ "stereo_map.the_pan_is_at_but": "Le pan est à {0}, mais le signal mesure {1}. La source elle-même est déséquilibrée.",
+ "stereo_map.width": "Largeur",
+ "tag_editor.add_tag": "Ajouter une étiquette",
+ "tag_editor.edit_tags": "Modifier les étiquettes",
+ "tag_editor.new_tag": "Nouvelle étiquette",
+ "tag_editor.no_tags_yet_add_one": "Aucune étiquette pour l’instant — en ajouter une ci-dessous.",
+ "tag_editor.tags_title_colour": "Étiquettes — titre et couleur",
+ "text_prompt.ok_caps": "OK",
+ "track_arming.arm_for_recording_click_to": "Armer pour l’enregistrement · ⌘-clic pour armer plusieurs pistes · ⌥-clic pour armer une seule piste d’un groupe lié",
+ "track_inspector.arm": "Armer",
+ "track_inspector.audio_track": "Piste audio",
+ "track_inspector.color": "Couleur",
+ "track_inspector.every_track_ends_up_here": "Toutes les pistes aboutissent ici. Ses appareils sont dans le panneau Appareils.",
+ "track_inspector.hear_the_input_live_through": "Entendre l’entrée en direct à travers cette piste",
+ "track_inspector.height": "Hauteur",
+ "track_inspector.large": "Grand",
+ "track_inspector.master_cant_be_monitored_it": "Le master ne peut pas être écouté (il y aurait un larsen)",
+ "track_inspector.midi_from": "MIDI depuis",
+ "track_inspector.midi_track": "Piste MIDI",
+ "track_inspector.monitor_input": "Écoute de l’entrée",
+ "track_inspector.mute_the_track": "Mettre la piste en sourdine",
+ "track_inspector.name": "Nom",
+ "track_inspector.no_track_selected": "Aucune piste sélectionnée",
+ "track_inspector.play_another_instrument_tracks_midi": "Jouer le MIDI d’une autre piste d’instrument avec l’instrument de cette piste",
+ "track_inspector.solo_the_track": "Mettre la piste en solo",
+ "track_inspector.standard": "Standard",
+ "track_inspector.the_colour_the_tracks_position": "La couleur que lui donne la position de la piste",
+ "track_names.inst": "Inst {0}",
+ "transport.bars": "mesures",
+ "transport.cant_record_arm_a_track": "Enregistrement impossible : armer d’abord une piste (cliquer sur Armer dans l’en-tête d’une piste).",
+ "transport.cant_record_no_audio_input": "Enregistrement impossible : aucune entrée audio — autoriser l’accès au microphone (nécessite une app empaquetée).",
+ "transport.count_in": "décompte",
+ "transport.paused_play_carries_on_from": "En pause · la lecture reprend à partir d’ici",
+ "transport.recording_didnt_start": "L’enregistrement n’a pas démarré.",
+ "transport.time": "durée",
+ "update.app_updater.couldnt_download_the_update": "Impossible de télécharger la mise à jour : {0}",
+ "update.app_updater.couldnt_prepare_the_update": "Impossible de préparer la mise à jour ({0} : {1}).",
+ "update.app_updater.couldnt_start": "Impossible de lancer {0}.",
+ "update.app_updater.nota_has_no_download_for": "Nota {0} n’a pas de téléchargement pour cet ordinateur.",
+ "update.app_updater.preparing_the_update": "Préparation de la mise à jour…",
+ "update.app_updater.the_downloaded_nota_app_isnt": "Le Nota.app téléchargé n’est pas la version attendue — il n’est pas installé.",
+ "update.app_updater.the_update_disk_image_doesnt": "L’image disque de la mise à jour ne contient pas Nota.app.",
+ "update.app_updater.the_update_download_is_damaged": "Le téléchargement de la mise à jour est endommagé (somme de contrôle différente) — il n’est pas installé.",
+ "update.app_updater.the_update_download_is_larger": "Le téléchargement de la mise à jour est plus volumineux que prévu — il n’est pas installé.",
+ "update.app_updater.this_copy_of_nota_cant": "Cet exemplaire de Nota ne peut pas se mettre à jour lui-même — télécharger la nouvelle version depuis la page de publication.",
+ "update.app_updater.timed_out": "{0} : délai dépassé.",
+ "version_summary.added": "{0} ajouté",
+ "version_summary.devices_on": "Appareils sur {0}",
+ "version_summary.edited": "{0} modifié",
+ "version_summary.first_save": "Premier enregistrement",
+ "version_summary.first_save_tracks": { "one": "Premier enregistrement · {0} piste", "other": "Premier enregistrement · {0} pistes" },
+ "version_summary.mix_of": "Mixage de {0}",
+ "version_summary.mix_of_tracks": { "one": "Mixage de {0} piste", "other": "Mixage de {0} pistes" },
+ "version_summary.new_audio": "Nouvel audio",
+ "version_summary.new_audio_files": "{0} nouveaux fichiers audio",
+ "version_summary.removed": "{0} supprimé",
+ "version_summary.tempo": "Tempo {0} → {1}",
+ "welcome.a_new_version_of_nota": "Une nouvelle version de Nota est disponible",
+ "welcome.dismiss": "Ignorer",
+ "welcome.later": "Plus tard",
+ "welcome.no_recent_projects": "Aucun projet récent",
+ "welcome.nota_is_out_you_have": "Nota {0} est disponible — la version installée est la {1}.",
+ "welcome.nota_is_ready_to_install": "Nota {0} est prêt à être installé",
+ "welcome.open_project": "Ouvrir un projet…",
+ "welcome.opening": "Ouverture…",
+ "welcome.recent_projects": "Projets récents",
+ "welcome.recover": "Récupérer",
+ "welcome.release_notes": "Notes de version",
+ "welcome.restart_nota_to_finish_updating": "Redémarrer Nota pour terminer la mise à jour — ou elle s’installe à la prochaine fermeture.",
+ "welcome.restart_now": "Redémarrer maintenant",
+ "welcome.show_on_startup": "Afficher au démarrage",
+ "welcome.the_update_didnt_download": "La mise à jour n’a pas pu être téléchargée",
+ "welcome.unsaved_work_available": "Travail non enregistré disponible",
+ "welcome.version_engine_desktop_daw": "Version {0} · Moteur {1} · DAW de bureau",
+ "welcome.welcome_to_nota": "Bienvenue dans Nota",
+ "welcome.whats_new": "Nouveautés",
+ "whats_new.all_changes": "Toutes les modifications",
+ "whats_new.got_it": "Compris",
+ "whats_new.no_release_notes_available": "Aucune note de version disponible.",
+ "whats_new.nota": "Nota {0}",
+ "whats_new.whats_new_in_nota": "Nouveautés de Nota"
}
}
diff --git a/src/managed/Nota.App/LensWindow.cs b/src/managed/Nota.App/LensWindow.cs
index 46f79c75..63e2ce0b 100644
--- a/src/managed/Nota.App/LensWindow.cs
+++ b/src/managed/Nota.App/LensWindow.cs
@@ -32,7 +32,7 @@ internal sealed class LensWindow : NotaWindow
{
_engine = card.Engine; _trackId = card.TrackId; _device = device;
_instance = Instance();
- Title = Loc.F("Nota Lens · {0}", TrackNames.Of(_engine, _trackId));
+ Title = Loc.F("lens.nota_lens", TrackNames.Of(_engine, _trackId));
Width = 1100; Height = 520; MinWidth = 640; MinHeight = 260;
CanResize = true;
ShowInTaskbar = false;
diff --git a/src/managed/Nota.App/LinuxFileDialogs.cs b/src/managed/Nota.App/LinuxFileDialogs.cs
index c8a61081..c098e80c 100644
--- a/src/managed/Nota.App/LinuxFileDialogs.cs
+++ b/src/managed/Nota.App/LinuxFileDialogs.cs
@@ -77,13 +77,13 @@ internal static class LinuxFileDialogs
{
FileDialogFallback.Verdict.Keep => result,
FileDialogFallback.Verdict.Wait => await WaitForDialog(task),
- _ => await Broken(finished ? Loc.T("the system file dialog answered without showing")
- : Loc.F("the system file dialog didn't open within {0:0} s", ShowTimeout.TotalSeconds)),
+ _ => await Broken(finished ? Loc.T("linux_file_dialogs.the_system_file_dialog_answered")
+ : Loc.F("linux_file_dialogs.the_system_file_dialog_didnt", ShowTimeout.TotalSeconds)),
};
}
catch (Exception ex) when (ex is not OperationCanceledException)
{
- return await Broken(Loc.F("the system file dialog failed: {0}", ex.Message));
+ return await Broken(Loc.F("linux_file_dialogs.the_system_file_dialog_failed", ex.Message));
}
finally
{
@@ -104,7 +104,7 @@ internal static class LinuxFileDialogs
else if (activeSince == DateTime.MinValue) activeSince = DateTime.UtcNow;
var activeFor = active ? DateTime.UtcNow - activeSince : TimeSpan.Zero;
if (FileDialogFallback.WhileWaiting(false, activeFor, ShowTimeout) == FileDialogFallback.Verdict.Fallback)
- return await Broken(Loc.F("the system file dialog didn't open within {0:0} s", ShowTimeout.TotalSeconds));
+ return await Broken(Loc.F("linux_file_dialogs.the_system_file_dialog_didnt", ShowTimeout.TotalSeconds));
}
}
@@ -112,7 +112,7 @@ internal static class LinuxFileDialogs
{
SystemBroken = true;
App.Services?.GetService<ILogSink>()?.Warn(
- Loc.F("Using Nota's built-in file dialog: {0}. Check xdg-desktop-portal and its FileChooser backend.", why));
+ Loc.F("linux_file_dialogs.using_notas_built_in_file", why));
return open(builtin);
}
}
diff --git a/src/managed/Nota.App/MacAppMenu.cs b/src/managed/Nota.App/MacAppMenu.cs
index 71b2cb43..ad88a0d9 100644
--- a/src/managed/Nota.App/MacAppMenu.cs
+++ b/src/managed/Nota.App/MacAppMenu.cs
@@ -43,10 +43,10 @@ internal static class MacAppMenu
string current = TitleOf(item);
string? title = current switch
{
- "Hide Others" => Loc.T("Hide Others"),
- "Show All" => Loc.T("Show All"),
- var t when t.StartsWith("Hide ", StringComparison.Ordinal) => Loc.F("Hide {0}", AppName),
- var t when t.StartsWith("Quit", StringComparison.Ordinal) => Loc.F("Quit {0}", AppName),
+ "Hide Others" => Loc.T("menu.mac.hide_others"),
+ "Show All" => Loc.T("menu.mac.show_all"),
+ var t when t.StartsWith("Hide ", StringComparison.Ordinal) => Loc.F("menu.mac.hide", AppName),
+ var t when t.StartsWith("Quit", StringComparison.Ordinal) => Loc.F("menu.mac.quit", AppName),
_ => null,
};
if (title is null || TitleOf(item) == title) continue;
diff --git a/src/managed/Nota.App/MainWindow.AudioFormat.cs b/src/managed/Nota.App/MainWindow.AudioFormat.cs
index b72b7fd3..d7aabfba 100644
--- a/src/managed/Nota.App/MainWindow.AudioFormat.cs
+++ b/src/managed/Nota.App/MainWindow.AudioFormat.cs
@@ -29,15 +29,15 @@ public partial class MainWindow
private Control[] AudioFormatMenu(MainWindowViewModel vm)
{
var engine = vm.Engine;
- var items = new List<Control> { MenuKit.Caption(Loc.T("Buffer size")) };
+ var items = new List<Control> { MenuKit.Caption(Loc.T("main.audio_format.buffer_size")) };
switch (vm.BufferOwner)
{
case BufferOwner.Driver:
- items.Add(MenuKit.Item(Loc.T("Driver settings…"), click: () => engine.OpenAsioControlPanel()));
- items.Add(MenuKit.Caption(Loc.T("Set in the ASIO driver's settings")));
+ items.Add(MenuKit.Item(Loc.T("main.audio_format.driver_settings"), click: () => engine.OpenAsioControlPanel()));
+ items.Add(MenuKit.Caption(Loc.T("main.audio_format.set_in_the_asio_drivers")));
break;
case BufferOwner.Device:
- items.Add(MenuKit.Caption(Loc.T("Exclusive mode uses the device's buffer")));
+ items.Add(MenuKit.Caption(Loc.T("main.audio_format.exclusive_mode_uses_the_devices")));
break;
default:
double rate = engine.NegotiatedSampleRate > 0 ? engine.NegotiatedSampleRate : engine.SampleRate;
@@ -46,7 +46,7 @@ public partial class MainWindow
foreach (int frames in AudioFormatStatus.BufferSizes)
{
int size = frames;
- var mi = MenuKit.Item(size == 0 ? Loc.T("Device default") : size.ToString(),
+ var mi = MenuKit.Item(size == 0 ? Loc.T("main.audio_format.device_default") : size.ToString(),
click: () => { if (size != engine.GetAudioConfig().BufferFrames) vm.SetAudioBufferFrames(size); },
enabled: !recording);
mi.ToggleType = MenuItemToggleType.Radio;
@@ -54,11 +54,11 @@ public partial class MainWindow
MenuKit.SetTrailing(mi, AudioFormatStatus.Latency(rate, size));
items.Add(mi);
}
- if (recording) items.Add(MenuKit.Caption(Loc.T("Stop recording to change it")));
+ if (recording) items.Add(MenuKit.Caption(Loc.T("main.audio_format.stop_recording_to_change_it")));
break;
}
items.Add(new Separator());
- items.Add(MenuKit.Item(Loc.T("Audio settings…"), GlyphKind.Levels, () => ShowPreferencesPage("Audio")));
+ items.Add(MenuKit.Item(Loc.T("main.audio_format.audio_settings"), GlyphKind.Levels, () => ShowPreferencesPage("Audio")));
return items.ToArray();
}
}
diff --git a/src/managed/Nota.App/MainWindow.AudioImport.cs b/src/managed/Nota.App/MainWindow.AudioImport.cs
index a66f36f5..c1bb91f9 100644
--- a/src/managed/Nota.App/MainWindow.AudioImport.cs
+++ b/src/managed/Nota.App/MainWindow.AudioImport.cs
@@ -52,12 +52,12 @@ public partial class MainWindow
var pending = new ArrangementView.PendingImport
{
TrackId = t, OwnsTrack = ownsTrack, StartBeat = beat,
- LengthBeats = 4, Label = Loc.F("{0} · Processing…", name), // real length arrives with the header
+ LengthBeats = 4, Label = Loc.F("main.audio_import.processing", name), // real length arrives with the header
};
Timeline.AddPendingImport(pending);
Timeline.Select(t, -1); // the track it lands on (a new one included) is selected right away
_session?.Refresh();
- _vm.StatusText = Loc.F("Importing {0}…", name);
+ _vm.StatusText = Loc.F("main.audio_import.importing", name);
// Not disposed: Progress<T> posts ticks asynchronously, so one can still arrive after
// this method returned — `finished` makes it a no-op instead of touching a dead import.
@@ -72,7 +72,7 @@ public partial class MainWindow
pending.LengthBeats = tick.TotalFrames / tick.SampleRate * (double)_vm.Transport.Bpm / 60.0;
pending.Peaks = tick.Peaks;
pending.PeakCount = tick.Count;
- pending.Label = Loc.F("{0} · Processing… {1:0} %", name, tick.Fraction * 100);
+ pending.Label = Loc.F("main.audio_import.processing_n", name, tick.Fraction * 100);
Timeline.UpdatePendingImport();
});
@@ -82,12 +82,12 @@ public partial class MainWindow
{
string? project = _projectPath;
(job, double bpm, SampleInfo? info) = await Task.Run(() => DecodeImport(path, project, progress, cts.Token));
- if (job is null) { _vm.StatusText = Loc.F("Failed to load {0}", name); return; }
- if (!Alive()) { _vm.StatusText = Loc.F("Import of {0} cancelled", name); return; }
+ if (job is null) { _vm.StatusText = Loc.F("main.audio_import.failed_to_load", name); return; }
+ if (!Alive()) { _vm.StatusText = Loc.F("main.audio_import.import_of_cancelled", name); return; }
int clip = Engine.AddImportedAudioClip(t, job, beat);
job.Dispose(); job = null; // the engine holds its own reference to the buffer
- if (clip < 0) { _vm.StatusText = Loc.F("Failed to load {0}", name); return; }
+ if (clip < 0) { _vm.StatusText = Loc.F("main.audio_import.failed_to_load", name); return; }
placed = true;
pending.ClipPlaced = true;
@@ -121,11 +121,11 @@ public partial class MainWindow
}
catch (OperationCanceledException)
{
- _vm.StatusText = Loc.F("Import of {0} cancelled", name);
+ _vm.StatusText = Loc.F("main.audio_import.import_of_cancelled", name);
}
catch (Exception ex)
{
- _vm.StatusText = Loc.F("Failed to load {0}: {1}", name, ex.Message);
+ _vm.StatusText = Loc.F("main.audio_import.failed_to_load_n", name, ex.Message);
}
finally
{
@@ -152,15 +152,15 @@ public partial class MainWindow
private string ImportedText(string name, SampleInfo? info, double warpedBpm, int semis)
{
- var parts = new System.Collections.Generic.List<string> { Loc.F("Imported {0}", name) };
+ var parts = new System.Collections.Generic.List<string> { Loc.F("main.imported", name) };
double project = (double)_vm!.Transport.Bpm;
if (warpedBpm > 0)
parts.Add(info is { Kind: SampleKind.Loop, Bpm: > 0 } && Math.Abs(info.Bpm - project) > 0.01
- ? Loc.F("loop warped {0} \u2192 {1}\u2009BPM", SampleInfo.FormatBpm(info.Bpm), SampleInfo.FormatBpm(project))
- : string.Format(NotaNum.Culture, Loc.T("warped to tempo ({0:0.0}\u2009BPM)"), warpedBpm));
- else if (info?.Kind == SampleKind.OneShot) parts.Add(Loc.T("one-shot, not warped"));
+ ? Loc.F("main.audio_import.loop_warped_bpm", SampleInfo.FormatBpm(info.Bpm), SampleInfo.FormatBpm(project))
+ : string.Format(NotaNum.Culture, Loc.T("main.audio_import.warped_to_tempo_bpm"), warpedBpm));
+ else if (info?.Kind == SampleKind.OneShot) parts.Add(Loc.T("main.audio_import.one_shot_not_warped"));
if (semis != 0 && _vm.Transport.Key is { } k)
- parts.Add(Loc.F("transposed {0}\u2009st to {1}", (semis > 0 ? "+" : "\u2212") + Math.Abs(semis), k.Long));
+ parts.Add(Loc.F("main.audio_import.transposed_st_to", (semis > 0 ? "+" : "\u2212") + Math.Abs(semis), k.Long));
return string.Join(" · ", parts);
}
@@ -224,7 +224,7 @@ public partial class MainWindow
await PollWarpBuildAsync(alive, remaining =>
{
double frac = total > 0 ? Math.Clamp(1.0 - (double)remaining / total, 0.0, 1.0) : 1.0;
- if (_vm is not null) _vm.StatusText = Loc.F("Warping {0}… {1:0}\u2009%", name, frac * 100);
+ if (_vm is not null) _vm.StatusText = Loc.F("main.audio_import.warping", name, frac * 100);
});
}
diff --git a/src/managed/Nota.App/MainWindow.Browser.cs b/src/managed/Nota.App/MainWindow.Browser.cs
index 7d02adf9..a3843faf 100644
--- a/src/managed/Nota.App/MainWindow.Browser.cs
+++ b/src/managed/Nota.App/MainWindow.Browser.cs
@@ -123,7 +123,7 @@ public partial class MainWindow
}
catch (Exception ex)
{
- _vm.StatusText = Loc.F("Load failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.browser.load_failed", ex.Message);
}
}
@@ -132,7 +132,7 @@ public partial class MainWindow
{
if (_vm is null || string.IsNullOrEmpty(item.Path)) return;
try { RevealInFileManager(item.Path); }
- catch (Exception ex) { _vm.StatusText = Loc.F("Reveal failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.browser.reveal_failed", ex.Message); }
}
internal static void RevealInFileManager(string path)
@@ -147,26 +147,26 @@ public partial class MainWindow
private async void OnBrowserDeleteProject(BrowserItem item)
{
if (_vm is null) return;
- bool ok = await new ConfirmWindow(Loc.T("Delete project"),
- Loc.F("Move “{0}” to the Trash?", item.Name), Loc.T("Delete"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ bool ok = await new ConfirmWindow(Loc.T("main.browser.delete_project"),
+ Loc.F("main.browser.move_to_the_trash", item.Name), Loc.T("common.delete"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
bool done = await Task.Run(() => MoveToTrash(item.Path));
_vm.Browser.RebuildProjects();
- _vm.StatusText = done ? Loc.F("Moved {0} to Trash", item.Name) : Loc.F("Couldn't delete {0}", item.Name);
+ _vm.StatusText = done ? Loc.F("main.browser.moved_to_trash", item.Name) : Loc.F("main.browser.couldnt_delete", item.Name);
}
// Delete a saved preset (#234): confirm, then to the Trash, like a project.
private async void OnBrowserDeletePreset(BrowserItem item)
{
if (_vm is null) return;
- bool ok = await new ConfirmWindow(Loc.T("Delete preset"),
- Loc.F("Move “{0}” to the Trash?", item.Name), Loc.T("Delete"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ bool ok = await new ConfirmWindow(Loc.T("main.browser.delete_preset"),
+ Loc.F("main.browser.move_to_the_trash", item.Name), Loc.T("common.delete"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
bool done = await Task.Run(() => MoveToTrash(item.Path));
_vm.Browser.RebuildPresets();
- _vm.StatusText = done ? Loc.F("Moved {0} to Trash", item.Name) : Loc.F("Couldn't delete {0}", item.Name);
+ _vm.StatusText = done ? Loc.F("main.browser.moved_to_trash", item.Name) : Loc.F("main.browser.couldnt_delete", item.Name);
}
// Open the user presets folder itself (not its parent with it selected).
@@ -181,7 +181,7 @@ public partial class MainWindow
else if (OperatingSystem.IsWindows()) Process.Start("explorer.exe", $"\"{dir}\"");
else Process.Start("xdg-open", new[] { dir });
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Reveal failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.browser.reveal_failed", ex.Message); }
}
private static bool MoveToTrash(string path)
@@ -218,32 +218,32 @@ public partial class MainWindow
{
if (_vm is null || _deviceChain is null) return;
int trackId = _deviceChain.TrackId;
- if (trackId <= 0) { _vm.StatusText = Loc.T("Select a track first."); return; }
+ if (trackId <= 0) { _vm.StatusText = Loc.T("common.select_a_track_first"); return; }
string label = deviceIndex <= PresetService.MidiEffectBase
? Engine.MidiEffectName(trackId, PresetService.MidiEffectBase - deviceIndex)
: Engine.DeviceName(trackId, deviceIndex);
- if (string.IsNullOrEmpty(label)) label = Loc.T("Instrument");
+ if (string.IsNullOrEmpty(label)) label = Loc.T("common.instrument");
// The preset it was loaded from is the likelier name to start from (specs/048).
var (surface, index) = deviceIndex <= PresetService.MidiEffectBase ? (PresetSurface.MidiEffect, PresetService.MidiEffectBase - deviceIndex)
: deviceIndex < 0 ? (PresetSurface.Instrument, -1) : (PresetSurface.Effect, deviceIndex);
if (Nota.Application.Editing.PresetEdit.Name(Engine, trackId, surface, index) is { Length: > 0 } loaded) label = loaded;
- var name = await new TextPromptWindow(Loc.T("Save preset"), Loc.T("Preset name"), label).ShowDialog<string?>(this);
+ var name = await new TextPromptWindow(Loc.T("common.save_preset"), Loc.T("main.browser.preset_name"), label).ShowDialog<string?>(this);
if (string.IsNullOrEmpty(name)) return;
try
{
if (!_presets.Save(Engine, trackId, deviceIndex, name, _vm.Settings.PresetsFolder()))
- { _vm.StatusText = Loc.T("Nothing to save (built-in synth has no state)."); return; }
+ { _vm.StatusText = Loc.T("main.browser.nothing_to_save_built_in"); return; }
// The device now holds that preset: its name, no " *".
Engine.SetDevicePresetTag(trackId, surface, index, "user:" + name, name);
_deviceChain.Refresh();
_vm.Browser.RebuildPresets();
- _vm.StatusText = Loc.F("Saved preset {0}", name);
+ _vm.StatusText = Loc.F("main.browser.saved_preset", name);
}
catch (Exception ex)
{
- _vm.StatusText = Loc.F("Save preset failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.browser.save_preset_failed", ex.Message);
}
}
@@ -255,20 +255,20 @@ public partial class MainWindow
if (trackId <= 0) return;
string label = Engine.RackChainInstrumentName(trackId, chain);
- if (string.IsNullOrEmpty(label)) label = Loc.T("Instrument");
- var name = await new TextPromptWindow(Loc.T("Save preset"), Loc.T("Preset name"), label).ShowDialog<string?>(this);
+ if (string.IsNullOrEmpty(label)) label = Loc.T("common.instrument");
+ var name = await new TextPromptWindow(Loc.T("common.save_preset"), Loc.T("main.browser.preset_name"), label).ShowDialog<string?>(this);
if (string.IsNullOrEmpty(name)) return;
try
{
if (!_presets.SaveRackChainInstrument(Engine, trackId, chain, name, _vm.Settings.PresetsFolder()))
- { _vm.StatusText = Loc.T("Only plug-in chain instruments can be saved as presets."); return; }
+ { _vm.StatusText = Loc.T("main.browser.only_plug_in_chain_instruments"); return; }
_vm.Browser.RebuildPresets();
- _vm.StatusText = Loc.F("Saved preset {0}", name);
+ _vm.StatusText = Loc.F("main.browser.saved_preset", name);
}
catch (Exception ex)
{
- _vm.StatusText = Loc.F("Save preset failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.browser.save_preset_failed", ex.Message);
}
}
}
diff --git a/src/managed/Nota.App/MainWindow.Commands.cs b/src/managed/Nota.App/MainWindow.Commands.cs
index 039c2ad2..a326722d 100644
--- a/src/managed/Nota.App/MainWindow.Commands.cs
+++ b/src/managed/Nota.App/MainWindow.Commands.cs
@@ -50,13 +50,13 @@ public partial class MainWindow
B("file.exit", Close); // the close button's path: unsaved changes still ask first (#316)
// ---- Edit
- B("edit.undo", () => OnMenuUndo(this, e), _ => Need(_vm?.Engine.CanUndo == true, Loc.T("Nothing to undo")));
+ B("edit.undo", () => OnMenuUndo(this, e), _ => Need(_vm?.Engine.CanUndo == true, Loc.T("main.commands.nothing_to_undo")));
B("edit.redo", () => OnMenuRedo(this, e));
B("edit.duplicate", () => OnMenuDuplicate(this, e));
- B("edit.split", () => OnMenuSplit(this, e), c => Need(c.SelectedClips > 0 || c.HasTimeSelection, Loc.T("Select a clip or a range first")));
- B("edit.consolidate", () => OnMenuConsolidate(this, e), c => Need(c.SelectedClips > 0 || c.HasTimeSelection, Loc.T("Select clips or a range first")));
- B("edit.duplicateTime", () => OnMenuDuplicateTime(this, e), c => Need(c.HasTimeSelection, Loc.T("Select a time range first")));
- B("edit.insertSilence", () => OnMenuInsertSilence(this, e), c => Need(c.HasTimeSelection, Loc.T("Select a time range first")));
+ B("edit.split", () => OnMenuSplit(this, e), c => Need(c.SelectedClips > 0 || c.HasTimeSelection, Loc.T("main.commands.select_a_clip_or_a")));
+ B("edit.consolidate", () => OnMenuConsolidate(this, e), c => Need(c.SelectedClips > 0 || c.HasTimeSelection, Loc.T("main.commands.select_clips_or_a_range")));
+ B("edit.duplicateTime", () => OnMenuDuplicateTime(this, e), c => Need(c.HasTimeSelection, Loc.T("main.commands.select_a_time_range_first")));
+ B("edit.insertSilence", () => OnMenuInsertSilence(this, e), c => Need(c.HasTimeSelection, Loc.T("main.commands.select_a_time_range_first")));
B("edit.lockEnvelopes", ToggleLockEnvelopes);
B("edit.cut", () => OnMenuCut(this, e));
B("edit.copy", () => OnMenuCopy(this, e));
@@ -65,8 +65,8 @@ public partial class MainWindow
B("edit.copyToOtherView", () => OnMenuCopyToOtherView(this, e));
B("edit.delete", () => OnMenuDeleteSel(this, e));
B("edit.selectAll", () => Timeline.SelectAllClips());
- B("edit.toggleClipActive", () => { if (Timeline.ToggleSelectedClipsActive()) { _session?.Refresh(); if (_vm is not null) _vm.StatusText = Loc.T("Toggled clip(s)"); } },
- c => Need(c.SelectedClips > 0, Loc.T("Select a clip first")));
+ B("edit.toggleClipActive", () => { if (Timeline.ToggleSelectedClipsActive()) { _session?.Refresh(); if (_vm is not null) _vm.StatusText = Loc.T("main.toggled_clip_s"); } },
+ c => Need(c.SelectedClips > 0, Loc.T("main.commands.select_a_clip_first")));
// ---- View
B("view.arrangement", () => SetView(MainView.Arrangement));
@@ -78,9 +78,9 @@ public partial class MainWindow
B("view.toggleBrowser", () => OnMenuToggleBrowser(this, e));
B("view.toggleDetail", () => OnMenuToggleClip(this, e));
B("view.maximizeDetail", ToggleDetailMaximized,
- _ => Need(_detailMaximized || CanMaximizeDetail, Loc.T("Open a clip in the clip editor first")));
+ _ => Need(_detailMaximized || CanMaximizeDetail, Loc.T("main.open_a_clip_in_the")));
B("view.showDevices", () => { int t = Timeline.SelectedTrackId > 0 ? Timeline.SelectedTrackId : LastInstrumentTrack(); if (t > 0) ShowDevices(t); },
- c => Need(c.HasTrack, Loc.T("Select a track first")));
+ c => Need(c.HasTrack, Loc.T("main.commands.select_a_track_first")));
B("view.popOutDetail", () => OnToggleDetailWindow(this, e));
B("view.toggleOverview", () => OnMenuToggleOverview(this, e));
B("view.toggleSections", () => OnMenuToggleSections(this, e));
@@ -118,19 +118,19 @@ public partial class MainWindow
B("track.newInstrument", () => AddTrack(NewTrackKind.Instrument));
B("track.newAudio", () => AddTrack(NewTrackKind.Audio));
B("track.newReturn", () => OnAddReturnClicked(this, e));
- B("track.group", () => { if (Timeline.GroupSelection() && _vm is not null) _vm.StatusText = Loc.T("Grouped tracks"); },
- c => Need(c.SelectedTrackCount > 0, Loc.T("Select tracks first")));
- B("track.ungroup", () => { if (Timeline.UngroupSelection() && _vm is not null) _vm.StatusText = Loc.T("Ungrouped"); });
+ B("track.group", () => { if (Timeline.GroupSelection() && _vm is not null) _vm.StatusText = Loc.T("main.commands.grouped_tracks"); },
+ c => Need(c.SelectedTrackCount > 0, Loc.T("main.commands.select_tracks_first")));
+ B("track.ungroup", () => { if (Timeline.UngroupSelection() && _vm is not null) _vm.StatusText = Loc.T("main.commands.ungrouped"); });
r.Bind("track.freeze", (c, m) => { if (c.TrackId > 0) _ = ToggleFreezeAsync(c.TrackId); },
- c => Need(c.HasTrack && IsFreezable(c.TrackId), c.HasTrack ? Loc.T("This track can't be frozen") : Loc.T("Select a track first")));
+ c => Need(c.HasTrack && IsFreezable(c.TrackId), c.HasTrack ? Loc.T("main.commands.this_track_cant_be_frozen") : Loc.T("main.commands.select_a_track_first")));
// ---- Session
- B("session.launchScene", () => _session?.LaunchSelectedScene(), c => Need(c.View == "Session", Loc.T("Open the Session view first")));
+ B("session.launchScene", () => _session?.LaunchSelectedScene(), c => Need(c.View == "Session", Loc.T("main.commands.open_the_session_view_first")));
B("session.stopAll", () => _session?.StopAll());
- B("session.insertScene", () => OnMenuInsertScene(this, e), c => Need(c.View == "Session", Loc.T("Scenes live in the Session view")));
+ B("session.insertScene", () => OnMenuInsertScene(this, e), c => Need(c.View == "Session", Loc.T("main.commands.scenes_live_in_the_session")));
// ---- Piano roll: the clip open in the editor
- Availability Roll(PaletteContext c) => Need(c.HasOpenMidiClip, Loc.T("Open a MIDI clip first"));
+ Availability Roll(PaletteContext c) => Need(c.HasOpenMidiClip, Loc.T("main.commands.open_a_midi_clip_first"));
// ---- Grid: the editor used last (piano roll or arrangement), status line names it
void G(string id, Func<GridSetting, GridSetting> step) => B(id, () => StepGrid(step));
G("grid.narrower", SnapGrid.Narrower);
@@ -139,16 +139,16 @@ public partial class MainWindow
G("grid.snap", SnapGrid.ToggleSnap);
G("grid.adaptive", SnapGrid.ToggleAdaptive);
- B("roll.quantize", () => { if (_editorRoll is { } roll) { roll.Quantize(1.0); if (_vm is not null) _vm.StatusText = Loc.T("Quantized notes"); } }, Roll);
+ B("roll.quantize", () => { if (_editorRoll is { } roll) { roll.Quantize(1.0); if (_vm is not null) _vm.StatusText = Loc.T("main.commands.quantized_notes"); } }, Roll);
B("roll.octaveUp", () => _editorRoll?.TransposeBy(12), Roll);
B("roll.octaveDown", () => _editorRoll?.TransposeBy(-12), Roll);
B("roll.fitNotes", () => _editorRoll?.FitToNotes(), Roll);
B("roll.fold", () => { if (_editorRoll is { } r) r.SetFold(!r.Folded, user: true); }, Roll);
B("roll.editSelected", () => EditSelectedClips(),
- _ => Need(Timeline.SelectedMidiClips().Count >= 2, Loc.T("Select two or more MIDI clips")));
+ _ => Need(Timeline.SelectedMidiClips().Count >= 2, Loc.T("main.commands.select_two_or_more_midi")));
B("roll.trackMode", () => SetClipTrackMode(!ClipTrackMode));
B("roll.removeOutOfScale", () => _editorRoll?.RemoveOutOfScaleNotes(),
- c => Need(c.HasOpenMidiClip && _editorRoll?.HasOutOfScaleNotes == true, Loc.T("No notes outside the scale")));
+ c => Need(c.HasOpenMidiClip && _editorRoll?.HasOutOfScaleNotes == true, Loc.T("main.commands.no_notes_outside_the_scale")));
// ---- Settings
B("prefs.open", ShowPreferences);
@@ -207,8 +207,8 @@ public partial class MainWindow
bool locked = !_vm.Engine.AutomationLock;
_vm.Engine.SetAutomationLock(locked);
if (MenuItemFor("edit.lockEnvelopes") is { } mi) mi.IsChecked = locked;
- _vm.StatusText = locked ? Loc.T("Envelopes locked — clip moves keep automation in place")
- : Loc.T("Envelopes follow clips");
+ _vm.StatusText = locked ? Loc.T("main.commands.envelopes_locked_clip_moves_keep")
+ : Loc.T("main.commands.envelopes_follow_clips");
}
// Transport ▸ Auto-arm selected track (#332): arm-on-select, a saved preference, off by default.
@@ -219,7 +219,7 @@ public partial class MainWindow
SetArmOnSelect(on);
_vm.Settings.Current.ArmOnSelect = on;
_vm.Settings.Save();
- _vm.StatusText = on ? Loc.T("Selecting an instrument track arms it") : Loc.T("Selecting a track leaves the arms alone");
+ _vm.StatusText = on ? Loc.T("main.commands.selecting_an_instrument_track_arms") : Loc.T("main.commands.selecting_a_track_leaves_the");
}
private void SetArmOnSelect(bool on)
@@ -236,7 +236,7 @@ public partial class MainWindow
bool on = !Timeline.HeadersOnRight;
_vm.Settings.Current.ArrangementHeadersRight = on;
_vm.Settings.Save();
- _vm.StatusText = on ? Loc.T("Track headers on the right") : Loc.T("Track headers on the left");
+ _vm.StatusText = on ? Loc.T("main.track_headers_on_the_right") : Loc.T("main.commands.track_headers_on_the_left");
}
private void ApplyHeadersRight(bool on)
@@ -272,7 +272,7 @@ public partial class MainWindow
var r = kind == EditorKind.Arrangement ? Timeline.SnapGridState
: _audioEditor is { IsEffectivelyVisible: true, GridInert: false } audio ? audio.SnapGridState
: _editorRoll?.SnapGridState ?? Timeline.SnapGridState;
- string label = r.SnapOn ? SnapGrid.Label(grids.Get(kind), r) : Loc.T("Snap off");
- if (_vm is not null) _vm.StatusText = kind == EditorKind.PianoRoll ? Loc.F("Clip editor grid: {0}", label) : Loc.F("Arrangement grid: {0}", label);
+ string label = r.SnapOn ? SnapGrid.Label(grids.Get(kind), r) : Loc.T("main.commands.snap_off");
+ if (_vm is not null) _vm.StatusText = kind == EditorKind.PianoRoll ? Loc.F("main.commands.clip_editor_grid", label) : Loc.F("main.commands.arrangement_grid", label);
}
}
diff --git a/src/managed/Nota.App/MainWindow.Convert.cs b/src/managed/Nota.App/MainWindow.Convert.cs
index a5dcf93e..b45bd3c0 100644
--- a/src/managed/Nota.App/MainWindow.Convert.cs
+++ b/src/managed/Nota.App/MainWindow.Convert.cs
@@ -31,7 +31,7 @@ public partial class MainWindow
try
{
int n = Engine.GetClipAudioMono(trackId, clipIndex, null, out sr);
- if (n <= 0 || sr <= 0) { _vm.StatusText = Loc.T("This clip has no audio to convert."); return; }
+ if (n <= 0 || sr <= 0) { _vm.StatusText = Loc.T("main.convert.this_clip_has_no_audio"); return; }
mono = new float[n];
Engine.GetClipAudioMono(trackId, clipIndex, mono, out sr);
@@ -41,11 +41,11 @@ public partial class MainWindow
if (Engine.TryGetClipInfo(trackId, clipIndex, out var ci)) { startBeat = ci.StartBeat; clipBeats = ci.LengthBeats; }
if (clipBeats <= 0) clipBeats = n / sr * (double)_vm.Transport.Bpm / 60.0;
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Convert failed: {0}", ex.Message); return; }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.convert.convert_failed", ex.Message); return; }
try
{
- await RunBlockingAsync(Loc.T("Convert to MIDI"), Loc.T("Analysing…"), async prog =>
+ await RunBlockingAsync(Loc.T("main.convert_to_midi"), Loc.T("main.convert.analysing"), async prog =>
{
switch (mode)
{
@@ -56,18 +56,18 @@ public partial class MainWindow
await ConvertWithModelAsync(mono, sr, startBeat, clipBeats, mode == ClipConvertMode.Melody, prog); break;
case ClipConvertMode.Melody: await ConvertMelodyAsync(mono, sr, startBeat, clipBeats, prog); break;
case ClipConvertMode.Harmony: await ConvertHarmonyAsync(mono, sr, startBeat, clipBeats, prog); break;
- default: _vm.StatusText = Loc.T("That converter isn't available yet."); break;
+ default: _vm.StatusText = Loc.T("main.convert.that_converter_isnt_available_yet"); break;
}
});
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Convert failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.convert.convert_failed", ex.Message); }
}
// Slice: chop the audio at onsets (or an even 16-slice grid), one pad per slice on ascending
// notes from C1, and a MIDI clip that replays them in order.
private async Task SliceToMidiAsync(float[] mono, double sr, double startBeat, double clipBeats, IProgress<ProgressReport> prog)
{
- prog.Report(ProgressReport.Indeterminate(Loc.T("Detecting transients…")));
+ prog.Report(ProgressReport.Indeterminate(Loc.T("main.convert.detecting_transients")));
var cuts = await Task.Run(() =>
{
var c = AudioOnsets.Detect(mono, sr);
@@ -95,16 +95,16 @@ public partial class MainWindow
if (LoadPad(dr, mono, sr, a, b, note) < 0) continue;
notes.Add(new NotaNote(note, a * toBeat, Math.Max(0.05, (b - a) * toBeat), 0.9f));
pads++;
- prog.Report(ProgressReport.At((double)(i + 1) / cuts.Count, Loc.F("Slicing pads… {0}", pads)));
+ prog.Report(ProgressReport.At((double)(i + 1) / cuts.Count, Loc.F("main.convert.slicing_pads", pads)));
}
- FinishConvert(dr, startBeat, clipBeats, notes, pads == 0 ? Loc.T("Nothing to slice.") : Loc.F("Sliced into {0} pads", pads));
+ FinishConvert(dr, startBeat, clipBeats, notes, pads == 0 ? Loc.T("main.convert.nothing_to_slice") : Loc.F("main.convert.sliced_into_pads", pads));
}
// Convert Drums: classify onsets into kick/snare/hat, voice each class with its strongest hit as
// a pad, and place a MIDI note per onset at the class's pad note.
private async Task ConvertDrumsAsync(float[] mono, double sr, double startBeat, double clipBeats, IProgress<ProgressReport> prog)
{
- prog.Report(ProgressReport.Indeterminate(Loc.T("Detecting hits…")));
+ prog.Report(ProgressReport.Indeterminate(Loc.T("main.convert.detecting_hits")));
var (onsets, cls, vel) = await Task.Run(() =>
{
var on = AudioOnsets.Detect(mono, sr);
@@ -126,7 +126,7 @@ public partial class MainWindow
for (int i = 0; i < onsets.Count; i++)
if (!best.TryGetValue(cls[i], out var cur) || vel[i] > cur.str) best[cls[i]] = (onsets[i], vel[i]);
- prog.Report(ProgressReport.Indeterminate(Loc.T("Building pads…")));
+ prog.Report(ProgressReport.Indeterminate(Loc.T("main.convert.building_pads")));
int dr = Engine.AddDrumRackTrack();
// Build one pad per class that occurred, voiced by its strongest hit.
var loaded = new HashSet<DrumClass>();
@@ -141,7 +141,7 @@ public partial class MainWindow
if (!loaded.Contains(cls[i])) continue;
notes.Add(new NotaNote(padNote[cls[i]], onsets[i] * toBeat, noteLen, Math.Clamp(0.3f + vel[i] * 0.7f, 0.2f, 1f)));
}
- FinishConvert(dr, startBeat, clipBeats, notes, notes.Count == 0 ? Loc.T("No drum hits found.") : Loc.F("Converted {0} hits", notes.Count));
+ FinishConvert(dr, startBeat, clipBeats, notes, notes.Count == 0 ? Loc.T("main.convert.no_drum_hits_found") : Loc.F("main.convert.converted_hits", notes.Count));
}
// Convert Melody: YIN pitch per frame → median-smoothed MIDI pitch → note segmentation, onto a
@@ -153,9 +153,9 @@ public partial class MainWindow
int win = (int)(sr / minHz); // one lowest-note period of comparison window
int need = win + (int)(sr / minHz);
int frames = mono.Length > need ? (mono.Length - need) / hop + 1 : 0;
- if (frames < 2) { Status(Loc.T("No melody found.")); return; }
+ if (frames < 2) { Status(Loc.T("main.convert.no_melody_found")); return; }
- prog.Report(ProgressReport.At(0, Loc.T("Detecting pitch…")));
+ prog.Report(ProgressReport.At(0, Loc.T("main.convert.detecting_pitch")));
var (pitch, rms) = await Task.Run(() =>
{
var midi = new int[frames];
@@ -174,7 +174,7 @@ public partial class MainWindow
midi[i] = f0 > 0 ? (int)Math.Round(69 + 12 * Math.Log2(f0 / 440.0)) : -1;
}
int pct = (int)(100.0 * (i + 1) / frames);
- if (pct != lastPct) { lastPct = pct; prog.Report(ProgressReport.At((double)(i + 1) / frames, Loc.T("Detecting pitch…"))); }
+ if (pct != lastPct) { lastPct = pct; prog.Report(ProgressReport.At((double)(i + 1) / frames, Loc.T("main.convert.detecting_pitch"))); }
}
return (MedianFilter(midi, 2), r); // ±2-frame median kills octave/jitter blips
});
@@ -199,12 +199,12 @@ public partial class MainWindow
}
Flush(frames);
- if (notes.Count == 0) { Status(Loc.T("No melody found.")); return; }
+ if (notes.Count == 0) { Status(Loc.T("main.convert.no_melody_found")); return; }
int t = Engine.AddVoltSynthTrack(); // Nota Volt
int mc = Engine.AddMidiClip(t, startBeat, Math.Max(0.25, clipBeats));
Engine.SetClipNotes(t, mc, notes.ToArray());
Timeline.Refresh(); Timeline.Select(t, mc); ShowDevices(t); _session?.Refresh();
- Status(Loc.F("Converted melody: {0} notes → new track {1}", notes.Count, t));
+ Status(Loc.F("main.convert.converted_melody_notes_new_track", notes.Count, t));
}
private static IClipAi Ai => App.Services.GetRequiredService<IClipAi>();
@@ -215,28 +215,28 @@ public partial class MainWindow
private async Task ConvertWithModelAsync(float[] mono, double sr, double startBeat, double clipBeats, bool melody, IProgress<ProgressReport> prog)
{
string what = melody ? "melody" : "harmony";
- prog.Report(ProgressReport.At(0, Loc.T("Listening for notes…")));
- var p = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.T("Listening for notes…"))));
+ prog.Report(ProgressReport.At(0, Loc.T("main.convert.listening_for_notes")));
+ var p = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.T("main.convert.listening_for_notes"))));
var heard = await Task.Run(() => Ai.Transcribe(mono, sr, p));
if (melody) heard = Transcription.Monophonic(heard);
var notes = Transcription.ToClipNotes(heard, mono.Length / sr, clipBeats);
- if (notes.Length == 0) { Status(Loc.F("No {0} found.", what)); return; }
+ if (notes.Length == 0) { Status(Loc.F("main.convert.no_found", what)); return; }
int t = Engine.AddVoltSynthTrack(); // Nota Volt
int mc = Engine.AddMidiClip(t, startBeat, Math.Max(0.25, clipBeats));
Engine.SetClipNotes(t, mc, notes);
Timeline.Refresh(); Timeline.Select(t, mc); ShowDevices(t); _session?.Refresh();
- Status(Loc.F("Converted {0}: {1} notes → new track {2}", what, notes.Length, t));
+ Status(Loc.F("main.convert.converted_notes_new_track", what, notes.Length, t));
}
// Convert Harmony: harmonic-sum pitch estimation (AudioHarmony) → polyphonic note spans on a new
// Nota Volt track. Approximate — best on sustained chords / pads.
private async Task ConvertHarmonyAsync(float[] mono, double sr, double startBeat, double clipBeats, IProgress<ProgressReport> prog)
{
- prog.Report(ProgressReport.Indeterminate(Loc.T("Detecting harmony…")));
+ prog.Report(ProgressReport.Indeterminate(Loc.T("main.convert.detecting_harmony")));
// Shortest kept note: an eighth (half a beat) at the clip's own beats-per-second.
double secPerBeat = clipBeats > 0 ? mono.Length / sr / clipBeats : 0.5;
var spans = await Task.Run(() => AudioHarmony.Detect(mono, sr, minNoteSec: 0.5 * secPerBeat));
- if (spans.Count == 0) { Status(Loc.T("No harmony found.")); return; }
+ if (spans.Count == 0) { Status(Loc.T("main.convert.no_harmony_found")); return; }
double toBeat = mono.Length > 0 ? clipBeats / mono.Length : 0;
var notes = new List<NotaNote>(spans.Count);
foreach (var s in spans)
@@ -245,7 +245,7 @@ public partial class MainWindow
int mc = Engine.AddMidiClip(t, startBeat, Math.Max(0.25, clipBeats));
Engine.SetClipNotes(t, mc, notes.ToArray());
Timeline.Refresh(); Timeline.Select(t, mc); ShowDevices(t); _session?.Refresh();
- Status(Loc.F("Converted harmony: {0} notes → new track {1}", notes.Count, t));
+ Status(Loc.F("main.convert.converted_harmony_notes_new_track", notes.Count, t));
}
private void Status(string s) { if (_vm is not null) _vm.StatusText = s; }
@@ -293,6 +293,6 @@ public partial class MainWindow
Timeline.Select(dr, mc);
ShowDevices(dr);
_session?.Refresh();
- if (_vm is not null) _vm.StatusText = Loc.F("{0} → new Drum Rack track {1}", status, dr);
+ if (_vm is not null) _vm.StatusText = Loc.F("main.convert.new_drum_rack_track", status, dr);
}
}
diff --git a/src/managed/Nota.App/MainWindow.Detail.cs b/src/managed/Nota.App/MainWindow.Detail.cs
index cfa2b296..d4883242 100644
--- a/src/managed/Nota.App/MainWindow.Detail.cs
+++ b/src/managed/Nota.App/MainWindow.Detail.cs
@@ -84,13 +84,13 @@ public partial class MainWindow
private string ChipTrackName(int trackId)
{
- if (trackId == Engine.MasterTrackId) return Engine.GetTrackName(trackId) is { Length: > 0 } m ? m : Loc.T("Master");
+ if (trackId == Engine.MasterTrackId) return Engine.GetTrackName(trackId) is { Length: > 0 } m ? m : Loc.T("common.master");
string stored = Engine.GetTrackName(trackId);
if (stored.Length > 0) return stored;
ChipTrackInfo(trackId, out var ti);
- return ti.IsReturn ? Loc.F("Return {0}", Engine.TrackReturnIndex(trackId) + 1)
- : ti.IsGroup ? Loc.F("Group {0}", trackId)
- : (ti.IsInstrument ? Loc.T("Inst ") : Loc.T("Audio ")) + trackId;
+ return ti.IsReturn ? Loc.F("common.return_n", Engine.TrackReturnIndex(trackId) + 1)
+ : ti.IsGroup ? Loc.F("main.detail.group", trackId)
+ : (ti.IsInstrument ? Loc.T("main.detail.inst") : Loc.T("main.detail.audio")) + trackId;
}
// "· instrument · MIDI from Inst 1 · PDC 2.7 ms" / "· audio · In Ext · Monitor In · PDC 0.0 ms".
@@ -106,19 +106,19 @@ public partial class MainWindow
{
parts.Add("instrument");
int src = Engine.GetTrackMidiSource(trackId);
- if (src > 0) parts.Add(Loc.T("MIDI from ") + ChipTrackName(src));
+ if (src > 0) parts.Add(Loc.T("main.detail.midi_from") + ChipTrackName(src));
}
else
{
parts.Add("audio");
int src = Engine.GetTrackRecordInput(trackId);
- parts.Add(Loc.T("In ") + (src == 0 ? RecordInputPick.HardwareShort(Engine.GetTrackInputChannels(trackId)) : src == -1 ? Loc.T("Master") : ChipTrackName(src)));
+ parts.Add(Loc.T("main.detail.in") + (src == 0 ? RecordInputPick.HardwareShort(Engine.GetTrackInputChannels(trackId)) : src == -1 ? Loc.T("common.master") : ChipTrackName(src)));
// A Master source stays silent while monitored (it would feed back).
- if (src != -1 && Engine.GetTrackMonitor(trackId)) parts.Add(Loc.T("Monitor in"));
+ if (src != -1 && Engine.GetTrackMonitor(trackId)) parts.Add(Loc.T("main.detail.monitor_in"));
}
}
double ms = Engine.SampleRate > 0 ? Engine.TrackLatencySamples(trackId) / Engine.SampleRate * 1000.0 : 0;
- parts.Add(string.Format(NotaNum.Culture, Loc.T("PDC {0:0.0}\u2009ms"), ms));
+ parts.Add(string.Format(NotaNum.Culture, Loc.T("main.detail.pdc_ms"), ms));
return "· " + string.Join(" · ", parts);
}
@@ -343,14 +343,14 @@ public partial class MainWindow
string title;
if (scene >= 0)
{
- title = Loc.F("Track {0} · Scene {1}", trackId, scene + 1);
+ title = Loc.F("main.detail.track_scene", trackId, scene + 1);
get = () => Engine.GetSessionNotes(trackId, scene);
set = notes => { Engine.SetSessionNotes(trackId, scene, notes); _session?.Refresh(); };
length = () => { double l = Engine.SessionSlotLength(trackId, scene); return l > 0 ? l : 4; };
}
else
{
- title = Loc.F("Track {0} clip", trackId);
+ title = Loc.F("main.detail.track_clip", trackId);
get = () => Engine.GetClipNotes(trackId, clipIndex);
// Same staleness guard as the piano roll: the clip can be deleted, undone or
// reloaded under an editor that is still on screen.
@@ -397,7 +397,7 @@ public partial class MainWindow
if (!PatternTarget(out int tid, out int ci, out int scene))
{
DetailPatternBtn.IsChecked = false;
- if (_vm is not null) _vm.StatusText = Loc.T("Select a MIDI clip on a Drum Rack track to step it.");
+ if (_vm is not null) _vm.StatusText = Loc.T("main.detail.select_a_midi_clip_on");
return;
}
if (_patternView is null || _patternTrackId != tid || _patternClipIndex != ci || _patternScene != scene)
@@ -433,7 +433,7 @@ public partial class MainWindow
if (trackId <= 0)
{
_deviceChain.Show(-1);
- SetDetailChip(-1, Loc.T("Devices"));
+ SetDetailChip(-1, Loc.T("main.devices"));
ApplyFrozenChainDim(-1);
return;
}
@@ -490,7 +490,7 @@ public partial class MainWindow
if (_vm is null || ClipTrackMode == on) return;
_vm.Settings.Current.ClipEditorTrackMode = on;
_vm.Settings.Save();
- _vm.StatusText = on ? Loc.T("Clip editor: every clip on the track") : Loc.T("Clip editor: one clip");
+ _vm.StatusText = on ? Loc.T("main.detail.clip_editor_every_clip_on") : Loc.T("main.detail.clip_editor_one_clip");
if (!reopen || _editorRoll is not { } roll || _clipEditor is null || _editorTrackId <= 0) return;
bool shown = ClipEditorShown(_clipEditor);
var a = roll.ActiveClip;
@@ -723,7 +723,7 @@ public partial class MainWindow
// A note sounds on its own clip's track; the keys column on the active clip's.
AuditionOn = (pitch, vel) => AuditionNoteOn(roll.AuditionTrackId > 0 ? roll.AuditionTrackId : _editorTrackId, pitch, vel),
AuditionOff = pitch => Engine.TrackNoteOff(roll.AuditionTrackId > 0 ? roll.AuditionTrackId : _editorTrackId, pitch),
- ClipNameOf = (t, c) => Engine.GetClipName(t, c) is { Length: > 0 } n ? n : Loc.F("Track {0} clip", t),
+ ClipNameOf = (t, c) => Engine.GetClipName(t, c) is { Length: > 0 } n ? n : Loc.F("main.detail.track_clip", t),
Bpm = () => Engine.Bpm, // the ruler's time display (#275)
// The ruler moves the transport (#50): editor beat → arrangement beat.
Seek = local =>
@@ -741,7 +741,7 @@ public partial class MainWindow
_editorTrackId = set.ActiveClip.TrackId;
_editorClipIndex = set.ActiveClip.ClipIndex;
_editorRoll = roll;
- _clipEditor = new ClipEditorView(roll, Loc.F("Track {0} clip", _editorTrackId), set.ActiveClip.StartBeat, Engine,
+ _clipEditor = new ClipEditorView(roll, Loc.F("main.detail.track_clip", _editorTrackId), set.ActiveClip.StartBeat, Engine,
_editorTrackId, _editorClipIndex, set.ActiveClip.LengthBeats,
on => SetClipTrackMode(on));
// The active clip drives the detail chip, the playhead's live check and the envelopes.
@@ -1051,7 +1051,7 @@ public partial class MainWindow
{
int t = Timeline.SelectedTrackId > 0 ? Timeline.SelectedTrackId : LastInstrumentTrack();
if (t > 0) ShowDevices(t);
- else { DetailDevicesBtn.IsChecked = false; if (_vm is not null) _vm.StatusText = Loc.T("Select a track first."); }
+ else { DetailDevicesBtn.IsChecked = false; if (_vm is not null) _vm.StatusText = Loc.T("common.select_a_track_first"); }
}
private void OnDetailClip(object? sender, RoutedEventArgs e)
@@ -1063,12 +1063,12 @@ public partial class MainWindow
if (SelectedSessionClip(out int st, out int ss)) ShowSessionSlot(st, ss);
else if (_clipEditor is not null) ShowClipPanel();
else if (SessionAudioEditorOpen) ShowAudioClipPanel();
- else RejectClipTab(Loc.T("Select a clip to edit it."));
+ else RejectClipTab(Loc.T("main.detail.select_a_clip_to_edit"));
return;
}
if (!SelectedClip(out int tid, out int ci, out bool isMidi))
{
- RejectClipTab(Loc.T("Select a clip to edit it."));
+ RejectClipTab(Loc.T("main.detail.select_a_clip_to_edit"));
return;
}
if (isMidi)
@@ -1177,7 +1177,7 @@ public partial class MainWindow
{
if (!_detailMaximized && !CanMaximizeDetail)
{
- if (_vm is not null) _vm.StatusText = DetailFloating ? Loc.T("The clip editor is in its own window") : Loc.T("Open a clip in the clip editor first");
+ if (_vm is not null) _vm.StatusText = DetailFloating ? Loc.T("main.detail.the_clip_editor_is_in") : Loc.T("main.open_a_clip_in_the");
return;
}
SetDetailMaximized(!_detailMaximized);
@@ -1193,7 +1193,7 @@ public partial class MainWindow
_detailRow.Height = on ? new GridLength(1, GridUnitType.Star) : new GridLength(_detailWanted > 120 ? _detailWanted : _detailDefault);
DetailSplitter.IsVisible = !on;
DetailMaximizeGlyph.Kind = on ? GlyphKind.Shrink : GlyphKind.Expand;
- ToolTip.SetTip(DetailMaximizeBtn, MenuKit.Keys(on ? Loc.T("Back to the split (⌘⇧F)") : Loc.T("Fill the window with the clip editor (⌘⇧F)")));
+ ToolTip.SetTip(DetailMaximizeBtn, MenuKit.Keys(on ? Loc.T("main.detail.back_to_the_split_f") : Loc.T("main.fill_the_window_with_the")));
if (MenuItemFor("view.maximizeDetail") is { } mi) mi.IsChecked = on;
LayoutBottomPanels();
}
@@ -1386,7 +1386,7 @@ public partial class MainWindow
_editorRoll = roll;
_editorTrackId = -1; // session slot: recording-tick reload N/A
_editorClipIndex = -1;
- _clipEditor = new ClipEditorView(roll, Loc.F("Track {0} · Scene {1}", trackId, scene + 1), 0);
+ _clipEditor = new ClipEditorView(roll, Loc.F("main.detail.track_scene", trackId, scene + 1), 0);
_lastClipEditor = _clipEditor;
SetHost(ClipDetailHost, _clipEditor);
SetDetailChip(trackId);
diff --git a/src/managed/Nota.App/MainWindow.DetailWindow.cs b/src/managed/Nota.App/MainWindow.DetailWindow.cs
index 4d1d4623..8bac5d33 100644
--- a/src/managed/Nota.App/MainWindow.DetailWindow.cs
+++ b/src/managed/Nota.App/MainWindow.DetailWindow.cs
@@ -96,7 +96,7 @@ public partial class MainWindow
{
Child = new TextBlock
{
- Text = Loc.T("Select a clip in the arrangement to edit it here"),
+ Text = Loc.T("main.detail_window.select_a_clip_in_the"),
FontSize = 12,
Foreground = NotaPalette.TextTertiary,
HorizontalAlignment = HorizontalAlignment.Center,
diff --git a/src/managed/Nota.App/MainWindow.DeviceMoves.cs b/src/managed/Nota.App/MainWindow.DeviceMoves.cs
index 73d095ae..d0622632 100644
--- a/src/managed/Nota.App/MainWindow.DeviceMoves.cs
+++ b/src/managed/Nota.App/MainWindow.DeviceMoves.cs
@@ -49,14 +49,14 @@ public partial class MainWindow
// The track's name as the Arrangement shows it (an unnamed instrument track reads as its instrument).
private string TrackLabel(int trackId)
- => trackId == Engine.MasterTrackId ? Loc.T("Master") : TrackNames.Of(Engine, trackId);
+ => trackId == Engine.MasterTrackId ? Loc.T("common.master") : TrackNames.Of(Engine, trackId);
// Asks before a device-panel action takes a track that has clips; a track without clips goes
// without asking (one undo brings it back either way).
private async Task<bool> ConfirmTrackGoesAsync(int trackId, string message, string affirmative)
{
if (!TrackHasClips(trackId)) return true;
- return await new ConfirmWindow(Loc.T("Delete track"), message, affirmative, Loc.T("Cancel")).ShowDialog<bool>(this);
+ return await new ConfirmWindow(Loc.T("main.device_moves.delete_track"), message, affirmative, Loc.T("common.cancel")).ShowDialog<bool>(this);
}
// selected: how many devices the panel had selected. With the instrument and more (specs/044)
@@ -68,14 +68,14 @@ public partial class MainWindow
string name = TrackLabel(trackId), inst = Engine.DeviceName(trackId, -1);
if (selected > 1)
{
- if (!await new ConfirmWindow(Loc.T("Delete track"), Loc.F("Delete track “{0}”? The track and its {1} selected devices will be removed.", name, selected),
- Loc.T("Delete"), Loc.T("Cancel")).ShowDialog<bool>(this)) return;
+ if (!await new ConfirmWindow(Loc.T("main.device_moves.delete_track"), Loc.F("main.device_moves.delete_track_the_track_and", name, selected),
+ Loc.T("common.delete"), Loc.T("common.cancel")).ShowDialog<bool>(this)) return;
}
- else if (!await ConfirmTrackGoesAsync(trackId, Loc.F("“{0}” has clips. Delete the track with its clips?", name), Loc.T("Delete"))) return;
+ else if (!await ConfirmTrackGoesAsync(trackId, Loc.F("main.device_moves.has_clips_delete_the_track", name), Loc.T("common.delete"))) return;
if (!Timeline.DeleteTrack(trackId)) return;
if (_deviceChain?.TrackId == trackId) ShowDevices(-1, takeOverPanel: false); // its cards would edit a removed track
_session?.Refresh();
- _vm.StatusText = cut ? Loc.F("Cut {0} — deleted {1}", inst, name) : Loc.F("Deleted {0}", name);
+ _vm.StatusText = cut ? Loc.F("main.device_moves.cut_deleted", inst, name) : Loc.F("main.device_moves.deleted_n", name);
}
// Move to track ▸ for several selected devices (specs/044): one undo step, in chain order so
@@ -88,8 +88,8 @@ public partial class MainWindow
int srcId = moves[0].SrcTrackId, dstId = moves[0].DstTrackId;
string src = TrackLabel(srcId), dst = TrackLabel(dstId);
bool withInstrument = moves.Any(m => m.Family == DeviceFamily.Instrument);
- if (withInstrument && !await new ConfirmWindow(Loc.T("Delete track"),
- Loc.F("Move {0} devices to “{1}” and delete “{2}”?", moves.Count, dst, src), Loc.T("Move"), Loc.T("Cancel")).ShowDialog<bool>(this))
+ if (withInstrument && !await new ConfirmWindow(Loc.T("main.device_moves.delete_track"),
+ Loc.F("main.device_moves.move_devices_to_and_delete", moves.Count, dst, src), Loc.T("main.device_moves.move"), Loc.T("common.cancel")).ShowDialog<bool>(this))
return;
int moved = 0, failed = 0;
var shift = new Dictionary<DeviceFamily, int>(); // earlier moves of a section close its gaps
@@ -112,7 +112,7 @@ public partial class MainWindow
_session?.Refresh();
if (dstId != Engine.MasterTrackId) Timeline.Select(dstId, -1);
ShowDevices(dstId);
- _vm.StatusText = failed == 0 ? Loc.F("Moved {0} devices to {1}", moved, dst) : Loc.F("Moved {0} devices to {1} · {2} couldn't move", moved, dst, failed);
+ _vm.StatusText = failed == 0 ? Loc.F("main.device_moves.moved_devices_to", moved, dst) : Loc.F("main.device_moves.moved_devices_to_couldnt_move", moved, dst, failed);
}
// Move to track ▸, or a device card dropped on a track header (⌥ = copy). One undo step; an
@@ -128,12 +128,12 @@ public partial class MainWindow
_ => Engine.DeviceName(r.SrcTrackId, r.Index),
};
if (r.Family == DeviceFamily.Instrument && !r.Copy
- && !await ConfirmTrackGoesAsync(r.SrcTrackId, Loc.F("Move {0} to “{1}” and delete “{2}” with its clips?", device, dst, src), Loc.T("Move")))
+ && !await ConfirmTrackGoesAsync(r.SrcTrackId, Loc.F("main.device_moves.move_to_and_delete_with", device, dst, src), Loc.T("main.device_moves.move")))
return;
int at = Engine.TransferDevice(r.SrcTrackId, r.Family, r.Index, r.DstTrackId, -1, r.Copy, out var flags);
if (at < 0)
{
- _vm.StatusText = at == -2 ? Loc.F("“{0}” can't take {1}.", dst, device) : at == -3 ? Loc.F("Couldn't copy {0}.", device) : Loc.F("Couldn't move {0}.", device);
+ _vm.StatusText = at == -2 ? Loc.F("main.device_moves.cant_take", dst, device) : at == -3 ? Loc.F("main.device_moves.couldnt_copy", device) : Loc.F("main.device_moves.couldnt_move", device);
return;
}
_deviceChain?.DeviceTransferred(r, at); // card state (preset label, A/B) follows the device
@@ -142,10 +142,10 @@ public partial class MainWindow
// The device panel follows the device to its new track.
if (r.DstTrackId != Engine.MasterTrackId) Timeline.Select(r.DstTrackId, -1);
ShowDevices(r.DstTrackId);
- string msg = r.Copy ? Loc.F("Copied {0} to {1}", device, dst) : Loc.F("Moved {0} to {1}", device, dst);
- if (flags.HasFlag(TransferFlags.SidechainCleared)) msg += Loc.T(" · sidechain cleared");
- if (flags.HasFlag(TransferFlags.LinksDropped)) msg += Loc.F(" · modulation links left on {0}", src);
- if (flags.HasFlag(TransferFlags.SourceTrackRemoved)) msg += Loc.F(" · deleted {0}", src);
+ string msg = r.Copy ? Loc.F("main.device_moves.copied_to", device, dst) : Loc.F("main.device_moves.moved_to", device, dst);
+ if (flags.HasFlag(TransferFlags.SidechainCleared)) msg += Loc.T("main.device_moves.sidechain_cleared");
+ if (flags.HasFlag(TransferFlags.LinksDropped)) msg += Loc.F("main.device_moves.modulation_links_left_on", src);
+ if (flags.HasFlag(TransferFlags.SourceTrackRemoved)) msg += Loc.F("main.device_moves.deleted", src);
_vm.StatusText = msg;
}
}
diff --git a/src/managed/Nota.App/MainWindow.Dnd.cs b/src/managed/Nota.App/MainWindow.Dnd.cs
index a7dd05b7..f8d59487 100644
--- a/src/managed/Nota.App/MainWindow.Dnd.cs
+++ b/src/managed/Nota.App/MainWindow.Dnd.cs
@@ -53,7 +53,7 @@ public partial class MainWindow
_session?.Refresh();
if (landed > 0) Timeline.Select(landed, -1);
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Drop failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.dnd.drop_failed", ex.Message); }
}
private void OnSessionDrop(BrowserItem item, int trackId, int scene, bool instrumentTrack)
@@ -65,16 +65,16 @@ public partial class MainWindow
// A column header or the empty grid has no slot for a clip.
if (scene < 0 && item.Kind is BrowserItemKind.Sample or BrowserItemKind.MidiFile)
{
- _vm.StatusText = Loc.T("Drop samples and MIDI files onto a slot.");
+ _vm.StatusText = Loc.T("main.dnd.drop_samples_and_midi_files");
return;
}
switch (item.Kind)
{
case BrowserItemKind.Sample:
- if (instrumentTrack) { _vm.StatusText = Loc.T("Drop samples onto audio slots."); break; }
+ if (instrumentTrack) { _vm.StatusText = Loc.T("main.dnd.drop_samples_onto_audio_slots"); break; }
if (Engine.AddSessionAudioFile(trackId, scene, item.Path))
{
- _vm.StatusText = Loc.F("Added {0} to slot", item.Name);
+ _vm.StatusText = Loc.F("main.added_to_slot", item.Name);
landed = true;
}
break;
@@ -85,7 +85,7 @@ public partial class MainWindow
case BrowserItemKind.BuiltinEffect:
case BrowserItemKind.PluginEffect:
case BrowserItemKind.BuiltinMidiEffect:
- if (trackId <= 0) { _vm.StatusText = Loc.T("Drop effects onto a column."); break; }
+ if (trackId <= 0) { _vm.StatusText = Loc.T("main.dnd.drop_effects_onto_a_column"); break; }
var r = Insertion.RouteToTrack(item, trackId); // a session column is a track
ApplyInsertResult(r);
landed = r.Ok;
@@ -104,7 +104,7 @@ public partial class MainWindow
if (ir.ToRackCard) // an instrument preset on an Instrument Rack: a new chain, from its card
{
ShowDevices(ir.TrackId);
- if (_deviceChain?.DropOnInstrumentRack(item) != true) _vm.StatusText = Loc.F("Couldn't add {0} to the rack.", item.Name);
+ if (_deviceChain?.DropOnInstrumentRack(item) != true) _vm.StatusText = Loc.F("main.dnd.couldnt_add_to_the_rack", item.Name);
}
else ApplyInsertResult(ir, revealDevices: !ir.CreatedTrack);
if (ir.Ok && ir.TrackId > 0) { trackId = ir.TrackId; landed = true; }
@@ -121,7 +121,7 @@ public partial class MainWindow
if (Timeline.SelectedTrackId != trackId) Timeline.Select(trackId, -1);
}
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Drop failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.dnd.drop_failed", ex.Message); }
}
// A browser item dropped on the Devices panel of the shown track. An effect lands in
@@ -148,7 +148,7 @@ public partial class MainWindow
private void DropBrowserItem(BrowserItem item, int t)
{
if (_vm is null) return;
- if (t <= 0) { _vm.StatusText = Loc.T("Select a track first."); return; }
+ if (t <= 0) { _vm.StatusText = Loc.T("common.select_a_track_first"); return; }
ApplyInsertResult(Insertion.Insert(item, new InsertTarget(t)));
}
diff --git a/src/managed/Nota.App/MainWindow.Downloads.cs b/src/managed/Nota.App/MainWindow.Downloads.cs
index cf8ff0b2..a17b7a3c 100644
--- a/src/managed/Nota.App/MainWindow.Downloads.cs
+++ b/src/managed/Nota.App/MainWindow.Downloads.cs
@@ -29,7 +29,7 @@ public partial class MainWindow
{
_dlText = new TextBlock { Classes = { "Caption" }, VerticalAlignment = VerticalAlignment.Center, MaxWidth = 360, TextTrimming = TextTrimming.CharacterEllipsis };
var open = new Border { Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand), Child = _dlText };
- ToolTip.SetTip(open, Loc.T("Open Settings → Downloads"));
+ ToolTip.SetTip(open, Loc.T("main.downloads.open_settings_downloads"));
open.PointerEntered += (_, _) => _dlText.TextDecorations = TextDecorations.Underline;
open.PointerExited += (_, _) => _dlText.TextDecorations = null;
open.PointerPressed += (_, e) =>
@@ -88,7 +88,7 @@ public partial class MainWindow
// Past the download stage (unpacking, scanning, removing) there's nothing to cancel.
_dlCancel.IsVisible = !busy || jobs.Cancellable;
_dlCancel.IsEnabled = !jobs.Cancelling;
- ToolTip.SetTip(_dlCancel, busy ? Loc.T("Cancel the download") : Loc.T("Dismiss"));
+ ToolTip.SetTip(_dlCancel, busy ? Loc.T("main.cancel_the_download") : Loc.T("main.downloads.dismiss"));
}
/// <summary>Settings → Downloads, on the given source; reuses an open Settings window.</summary>
diff --git a/src/managed/Nota.App/MainWindow.Files.cs b/src/managed/Nota.App/MainWindow.Files.cs
index 458ff25d..77566a8f 100644
--- a/src/managed/Nota.App/MainWindow.Files.cs
+++ b/src/managed/Nota.App/MainWindow.Files.cs
@@ -32,18 +32,18 @@ public partial class MainWindow
Activate();
var files = await this.PickFilesAsync(new FilePickerOpenOptions
{
- Title = Loc.T("Import audio"),
+ Title = Loc.T("main.files.import_audio"),
AllowMultiple = false,
SuggestedStartLocation = await FolderAsync(_importFolder ?? _vm.Settings.ResolvedSamplesFolder()),
FileTypeFilter = new[]
{
- new FilePickerFileType(Loc.T("Audio")) { Patterns = new[] { "*.wav", "*.flac", "*.mp3" } }
+ new FilePickerFileType(Loc.T("common.audio")) { Patterns = new[] { "*.wav", "*.flac", "*.mp3" } }
}
});
if (files.Count == 0) return;
var path = files[0].TryGetLocalPath();
- if (path is null) { _vm.StatusText = Loc.T("Unsupported file location."); return; }
+ if (path is null) { _vm.StatusText = Loc.T("main.files.unsupported_file_location"); return; }
_importFolder = System.IO.Path.GetDirectoryName(path);
await ImportAudioInBackgroundAsync(path, -1, 0.0);
@@ -59,7 +59,7 @@ public partial class MainWindow
double endBeats = ProjectEndBeats();
if (endBeats <= 0.0)
{
- _vm.StatusText = Loc.T("Nothing to export — the arrangement is empty.");
+ _vm.StatusText = Loc.T("main.files.nothing_to_export_the_arrangement");
return;
}
@@ -79,7 +79,7 @@ public partial class MainWindow
{
var folders = await this.PickFoldersAsync(new FolderPickerOpenOptions
{
- Title = Loc.T("Export stems to folder"), AllowMultiple = false,
+ Title = Loc.T("main.files.export_stems_to_folder"), AllowMultiple = false,
});
path = folders.Count > 0 ? folders[0].TryGetLocalPath() : null;
}
@@ -87,12 +87,12 @@ public partial class MainWindow
{
var file = await this.PickSaveFileAsync(new FilePickerSaveOptions
{
- Title = Loc.F("Export master to {0}", ext.ToUpperInvariant()),
+ Title = Loc.F("main.files.export_master_to", ext.ToUpperInvariant()),
DefaultExtension = ext,
SuggestedFileName = $"Nota Export.{ext}",
FileTypeChoices = new[]
{
- new FilePickerFileType(Loc.F("{0} audio", ext.ToUpperInvariant())) { Patterns = new[] { $"*.{ext}" } }
+ new FilePickerFileType(Loc.F("main.files.audio", ext.ToUpperInvariant())) { Patterns = new[] { $"*.{ext}" } }
},
});
path = file?.TryGetLocalPath();
@@ -111,25 +111,25 @@ public partial class MainWindow
RestoreLoop: _vm.Transport.LoopOn, RestoreMetronome: _vm.Transport.MetronomeOn,
Normalize: opts.Normalize, Dither: opts.Dither,
Format: opts.Format, Mp3BitrateKbps: opts.BitrateKbps, StartBeats: opts.StartBeats);
- await RunBlockingAsync(Loc.T("Export"), opts.Stems ? Loc.T("Exporting stems…") : Loc.T("Exporting…"), async prog =>
+ await RunBlockingAsync(Loc.T("main.files.export"), opts.Stems ? Loc.T("main.files.exporting_stems") : Loc.T("main.files.exporting"), async prog =>
{
var frac = new Progress<double>(f =>
- prog.Report(ProgressReport.At(f, Loc.F("Exporting {0}… {1:0}\u2009%", noun, f * 100))));
+ prog.Report(ProgressReport.At(f, Loc.F("main.files.exporting_n", noun, f * 100))));
if (opts.Stems)
{
int count = await Task.Run(() => _exporter.ExportStems(Engine, request, frac));
- _vm.StatusText = Loc.F("{0} · {1}", Loc.Plural(count, "Exported {0} stem", "Exported {0} stems"), System.IO.Path.GetFileName(path));
+ _vm.StatusText = Loc.F("common.pattern_n", Loc.Plural("main.files.exported_stems", count), System.IO.Path.GetFileName(path));
}
else
{
await Task.Run(() => _exporter.ExportMaster(Engine, request, frac));
- _vm.StatusText = Loc.F("Exported {0}", System.IO.Path.GetFileName(path));
+ _vm.StatusText = Loc.F("main.files.exported", System.IO.Path.GetFileName(path));
}
});
}
catch (Exception ex)
{
- _vm.StatusText = Loc.F("Export failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.files.export_failed", ex.Message);
}
finally
{
@@ -161,7 +161,7 @@ public partial class MainWindow
/// ("Nota — Untitled" until the bundle is named).</summary>
private void UpdateWindowTitle()
{
- string title = Loc.F("Nota — {0}", ProjectDisplayName());
+ string title = Loc.F("main.files.nota", ProjectDisplayName());
Title = title;
// The project's name leads the transport, so the frameless title-bar caption is just
// the app; the OS window title keeps both for the Dock and window switcher.
@@ -178,8 +178,8 @@ public partial class MainWindow
private async Task DoNewAsync()
{
if (_vm is null) return;
- if (!await ConfirmLeaveChangesAsync(Loc.T("New project"),
- Loc.T("Save your changes before starting a new project?"))) return;
+ if (!await ConfirmLeaveChangesAsync(Loc.T("common.new_project"),
+ Loc.T("main.files.save_your_changes_before_starting"))) return;
_links.Clear(); // no live-freeze links (cleared first: stale ids must not hit the new graph)
Engine.Reset();
// Reset transport to defaults (these setters drive the engine + UI).
@@ -201,7 +201,7 @@ public partial class MainWindow
UpdateWindowTitle();
MarkProjectClean();
HistoryChanged?.Invoke(); // a new project has no history yet
- _vm.StatusText = Loc.T("New project.");
+ _vm.StatusText = Loc.T("main.files.new_project");
}
// The file panels start where their files live (#309): projects in the Projects folder from
@@ -226,23 +226,23 @@ public partial class MainWindow
Activate(); // keep the native panel focused (see DoImportAsync)
var folders = await this.PickFoldersAsync(new FolderPickerOpenOptions
{
- Title = Loc.T("Open Nota project (.nota folder)"),
+ Title = Loc.T("main.files.open_nota_project_nota_folder"),
AllowMultiple = false,
SuggestedStartLocation = await FolderAsync(_vm.Settings.ResolvedProjectsFolder()), // #309
});
if (folders.Count == 0) return;
var dir = folders[0].TryGetLocalPath();
- if (dir is null) { _vm.StatusText = Loc.T("Unsupported project location."); return; }
- if (!await ConfirmLeaveChangesAsync(Loc.T("Open project"),
- Loc.T("Save your changes before opening another project?"))) return;
+ if (dir is null) { _vm.StatusText = Loc.T("main.files.unsupported_project_location"); return; }
+ if (!await ConfirmLeaveChangesAsync(Loc.T("main.files.open_project"),
+ Loc.T("main.files.save_your_changes_before_opening"))) return;
OpenProject(dir);
}
// Open another project from the browser, after the unsaved-changes prompt.
private async Task OpenProjectConfirmedAsync(string dir)
{
- if (!await ConfirmLeaveChangesAsync(Loc.T("Open project"),
- Loc.T("Save your changes before opening another project?"))) return;
+ if (!await ConfirmLeaveChangesAsync(Loc.T("main.files.open_project"),
+ Loc.T("main.files.save_your_changes_before_opening"))) return;
OpenProject(dir);
}
@@ -294,15 +294,15 @@ public partial class MainWindow
App.Services.GetRequiredService<ILogSink>()
.Info($"Opened project '{System.IO.Path.GetFileName(dir)}' · {warnings.Count} warning(s)");
_vm.StatusText = warnings.Count == 0
- ? Loc.F("Opened {0}", System.IO.Path.GetFileName(dir))
- : Loc.F("Opened {0} — {1} item(s) downgraded: {2}", System.IO.Path.GetFileName(dir), warnings.Count, warnings[0]);
+ ? Loc.F("main.files.opened", System.IO.Path.GetFileName(dir))
+ : Loc.F("main.files.opened_item_s_downgraded", System.IO.Path.GetFileName(dir), warnings.Count, warnings[0]);
_ = BuildWarpCachesAsync(); // fill the deferred warp caches in the background
_ = OfferMissingPluginsAsync(dir, result.MissingPlugins);
}
catch (Exception ex)
{
App.Services.GetRequiredService<ILogSink>().Error("Open project failed", ex);
- _vm.StatusText = Loc.F("Open failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.files.open_failed", ex.Message);
}
}
@@ -315,13 +315,13 @@ public partial class MainWindow
int gen = _warpBuildGen;
long total = Engine.WarpBuildRemaining;
if (total <= 0) return;
- await RunBackgroundAsync(Loc.T("Preparing warped clips…"), async prog =>
+ await RunBackgroundAsync(Loc.T("main.files.preparing_warped_clips"), async prog =>
{
// The stretch runs on the engine's worker thread; the UI only polls + installs.
await PollWarpBuildAsync(() => gen == _warpBuildGen, remaining => // bail if another project opened
{
double frac = Math.Clamp(1.0 - (double)remaining / total, 0.0, 1.0);
- prog.Report(ProgressReport.At(frac, Loc.F("Preparing warped clips… {0:0}\u2009%", frac * 100)));
+ prog.Report(ProgressReport.At(frac, Loc.F("main.files.preparing_warped_clips_n", frac * 100)));
});
});
}
@@ -339,7 +339,7 @@ public partial class MainWindow
string? dir = _projectPath;
if (saveAs || dir is null)
{
- dir = await PickProjectPathAsync(Loc.T("Save Nota project"), "Untitled.nota");
+ dir = await PickProjectPathAsync(Loc.T("main.files.save_nota_project"), "Untitled.nota");
if (dir is null) return false;
}
@@ -364,15 +364,15 @@ public partial class MainWindow
App.Services.GetRequiredService<ILogSink>()
.Info($"Saved project '{System.IO.Path.GetFileName(dir)}' · {warnings.Count} warning(s)");
_vm.StatusText = (warnings.Count == 0
- ? Loc.F("Saved {0}", System.IO.Path.GetFileName(dir))
- : Loc.F("Saved {0} — {1} unsupported item(s) skipped: {2}", System.IO.Path.GetFileName(dir), warnings.Count, warnings[0]))
+ ? Loc.F("main.files.saved", System.IO.Path.GetFileName(dir))
+ : Loc.F("main.files.saved_unsupported_item_s_skipped", System.IO.Path.GetFileName(dir), warnings.Count, warnings[0]))
+ historyNote;
return true;
}
catch (Exception ex)
{
App.Services.GetRequiredService<ILogSink>().Error("Save project failed", ex);
- _vm.StatusText = Loc.F("Save failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.files.save_failed", ex.Message);
return false;
}
}
@@ -389,7 +389,7 @@ public partial class MainWindow
SuggestedFileName = suggestedName,
FileTypeChoices = new[]
{
- new FilePickerFileType(Loc.T("Nota project")) { Patterns = new[] { "*.nota" } }
+ new FilePickerFileType(Loc.T("main.files.nota_project")) { Patterns = new[] { "*.nota" } }
},
});
var chosen = file?.TryGetLocalPath();
@@ -434,7 +434,7 @@ public partial class MainWindow
private string ProjectDisplayName()
=> _projectPath is { Length: > 0 } p
? System.IO.Path.GetFileNameWithoutExtension(p.TrimEnd('/', '\\'))
- : Loc.T("Untitled");
+ : Loc.T("main.files.untitled");
/// <summary>True if the project changed since it was last created, opened or saved.</summary>
private bool HasUnsavedChanges()
diff --git a/src/managed/Nota.App/MainWindow.Freeze.cs b/src/managed/Nota.App/MainWindow.Freeze.cs
index 54b6445e..811f2438 100644
--- a/src/managed/Nota.App/MainWindow.Freeze.cs
+++ b/src/managed/Nota.App/MainWindow.Freeze.cs
@@ -54,7 +54,7 @@ public partial class MainWindow
if (!freezable) return;
bool frozen = Engine.IsTrackFrozen(trackId);
- FreezeLabel.Text = frozen ? Loc.T("Frozen") : Loc.T("Freeze");
+ FreezeLabel.Text = frozen ? Loc.T("main.freeze.frozen") : Loc.T("common.freeze");
IBrush idle = NotaPalette.TextSecondary;
FreezeIcon.Foreground = frozen ? IceBrush : idle;
FreezeLabel.Foreground = frozen ? IceBrush : idle;
@@ -77,7 +77,7 @@ public partial class MainWindow
{
if (_freezeMenuBuilt) return;
_freezeMenuBuilt = true;
- _flattenItem = MenuKit.Danger(Loc.T("Flatten to audio track"), GlyphKind.Flatten,
+ _flattenItem = MenuKit.Danger(Loc.T("main.freeze.flatten_to_audio_track"), GlyphKind.Flatten,
() => { if (_freezeTrackId > 0) _ = FlattenTrackAsync(_freezeTrackId); });
var menu = new ContextMenu();
menu.Items.Add(_flattenItem);
@@ -103,7 +103,7 @@ public partial class MainWindow
{
if (_vm is null) return;
double endBeats = ProjectEndBeats();
- if (endBeats <= 0.0) { _vm.StatusText = Loc.T("Nothing to freeze — the arrangement is empty."); return; }
+ if (endBeats <= 0.0) { _vm.StatusText = Loc.T("main.nothing_to_freeze_the_arrangement"); return; }
// Freeze takes over the engine (backend stopped) exactly like an export bounce, so
// suspend the UI clock and show the modal progress dialog while it renders.
@@ -111,15 +111,15 @@ public partial class MainWindow
try
{
bool ok = false;
- await RunBlockingAsync(Loc.T("Freeze"), Loc.T("Freezing track…"), async prog =>
+ await RunBlockingAsync(Loc.T("common.freeze"), Loc.T("main.freeze.freezing_track"), async prog =>
{
- var frac = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.F("Freezing track… {0:0}\u2009%", f * 100))));
+ var frac = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.F("main.freeze.freezing_track_n", f * 100))));
ok = await Task.Run(() => _freezer.Freeze(Engine, trackId, endBeats,
_vm.Transport.LoopOn, _vm.Transport.MetronomeOn, frac));
});
- _vm.StatusText = ok ? Loc.T("Track frozen — its devices are idle until you unfreeze.") : Loc.T("Couldn't freeze this track.");
+ _vm.StatusText = ok ? Loc.T("main.freeze.track_frozen_its_devices_are") : Loc.T("main.couldnt_freeze_this_track");
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Freeze failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.freeze.freeze_failed", ex.Message); }
finally { _vm.SuspendEnginePolling = false; }
AfterFreezeChange();
@@ -128,7 +128,7 @@ public partial class MainWindow
private void UnfreezeTrack(int trackId)
{
Engine.UnfreezeTrack(trackId);
- if (_vm is not null) _vm.StatusText = Loc.T("Track unfrozen.");
+ if (_vm is not null) _vm.StatusText = Loc.T("main.freeze.track_unfrozen");
AfterFreezeChange();
}
@@ -156,35 +156,35 @@ public partial class MainWindow
if ((LinkForSource(trackId) ?? LinkForFrozen(trackId)) is { } link)
{
int src = link.SourceId;
- items.Add(new(Loc.T("Live freeze"), GlyphKind.ChainLink, () => UnfreezeLink(src), Switch: true));
+ items.Add(new(Loc.T("main.live_freeze"), GlyphKind.ChainLink, () => UnfreezeLink(src), Switch: true));
if (link.State == LinkState.Editing)
{
- items.Add(new(Loc.T("Done — re-freeze"), GlyphKind.Check,
+ items.Add(new(Loc.T("main.freeze.done_re_freeze"), GlyphKind.Check,
() => { Timeline.Select(trackId, -1); _ = CommitEditSessionAsync(src); }));
- items.Add(new(Loc.T("Discard edits"), GlyphKind.Cross,
+ items.Add(new(Loc.T("main.freeze.discard_edits"), GlyphKind.Cross,
() => { Timeline.Select(trackId, -1); DiscardEditSession(src); }, Danger: true));
}
else
// Editing changes the source's notes/devices, so land on the source track.
- items.Add(new(Loc.T("Edit source"), GlyphKind.Edit,
+ items.Add(new(Loc.T("main.freeze.edit_source"), GlyphKind.Edit,
() => { Timeline.Select(src, -1); BeginEditSession(src); }));
- items.Add(new(Loc.T("Flatten (remove source)"), GlyphKind.Flatten, () => FlattenLinkAsync(src), Danger: true));
+ items.Add(new(Loc.T("main.flatten_remove_source"), GlyphKind.Flatten, () => FlattenLinkAsync(src), Danger: true));
return items;
}
if (!IsFreezable(trackId)) return items;
if (Engine.IsTrackFrozen(trackId))
{
- items.Add(new(Loc.T("Unfreeze track"), GlyphKind.Freeze,
+ items.Add(new(Loc.T("main.freeze.unfreeze_track"), GlyphKind.Freeze,
() => { Timeline.Select(trackId, -1); UnfreezeTrack(trackId); }));
- items.Add(new(Loc.T("Flatten to audio track"), GlyphKind.Flatten,
+ items.Add(new(Loc.T("main.freeze.flatten_to_audio_track"), GlyphKind.Flatten,
() => { Timeline.Select(trackId, -1); _ = FlattenTrackAsync(trackId); }, Danger: true));
}
else
{
- items.Add(new(Loc.T("Freeze track"), GlyphKind.Freeze,
+ items.Add(new(Loc.T("main.freeze.freeze_track"), GlyphKind.Freeze,
() => { Timeline.Select(trackId, -1); _ = FreezeTrackAsync(trackId); }));
- items.Add(new(Loc.T("Live freeze"), GlyphKind.ChainLink,
+ items.Add(new(Loc.T("main.live_freeze"), GlyphKind.ChainLink,
() => { Timeline.Select(trackId, -1); _ = LiveFreezeAsync(trackId); }, Switch: false));
}
return items;
@@ -205,10 +205,10 @@ public partial class MainWindow
var live = plain.Where(id => !Engine.IsTrackFrozen(id)).ToList();
var frozen = plain.Where(id => Engine.IsTrackFrozen(id)).ToList();
if (live.Count > 0)
- items.Add(MenuKit.Item(live.Count == 1 ? Loc.T("Freeze track") : Loc.F("Freeze {0} tracks", live.Count), GlyphKind.Freeze,
+ items.Add(MenuKit.Item(live.Count == 1 ? Loc.T("main.freeze.freeze_track") : Loc.F("main.freeze.freeze_tracks", live.Count), GlyphKind.Freeze,
() => _ = FreezeTracksAsync(live)));
if (frozen.Count > 0)
- items.Add(MenuKit.Item(frozen.Count == 1 ? Loc.T("Unfreeze track") : Loc.F("Unfreeze {0} tracks", frozen.Count), GlyphKind.Freeze,
+ items.Add(MenuKit.Item(frozen.Count == 1 ? Loc.T("main.freeze.unfreeze_track") : Loc.F("main.freeze.unfreeze_tracks", frozen.Count), GlyphKind.Freeze,
() => UnfreezeTracks(frozen)));
return items;
}
@@ -218,13 +218,13 @@ public partial class MainWindow
{
if (_vm is null || trackIds.Count == 0) return;
double endBeats = ProjectEndBeats();
- if (endBeats <= 0.0) { _vm.StatusText = Loc.T("Nothing to freeze — the arrangement is empty."); return; }
+ if (endBeats <= 0.0) { _vm.StatusText = Loc.T("main.nothing_to_freeze_the_arrangement"); return; }
_vm.SuspendEnginePolling = true;
int done = 0;
try
{
- await RunBlockingAsync(Loc.T("Freeze"), Loc.T("Freezing tracks…"), async prog =>
+ await RunBlockingAsync(Loc.T("common.freeze"), Loc.T("main.freeze.freezing_tracks"), async prog =>
{
for (int i = 0; i < trackIds.Count; i++)
{
@@ -232,7 +232,7 @@ public partial class MainWindow
var frac = new Progress<double>(f =>
{
double all = (k + f) / trackIds.Count;
- prog.Report(ProgressReport.At(all, Loc.F("Freezing track {0} of {1}… {2:0}\u2009%", k + 1, trackIds.Count, all * 100)));
+ prog.Report(ProgressReport.At(all, Loc.F("main.freeze.freezing_track_of", k + 1, trackIds.Count, all * 100)));
});
if (await Task.Run(() => _freezer.Freeze(Engine, trackIds[k], endBeats,
_vm.Transport.LoopOn, _vm.Transport.MetronomeOn, frac)))
@@ -240,10 +240,10 @@ public partial class MainWindow
}
});
_vm.StatusText = done == trackIds.Count
- ? Loc.F("{0} tracks frozen — their devices are idle until you unfreeze.", done)
- : Loc.F("Froze {0} of {1} tracks.", done, trackIds.Count);
+ ? Loc.F("main.freeze.tracks_frozen_their_devices_are", done)
+ : Loc.F("main.freeze.froze_of_tracks", done, trackIds.Count);
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Freeze failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.freeze.freeze_failed", ex.Message); }
finally { _vm.SuspendEnginePolling = false; }
AfterFreezeChange();
@@ -252,7 +252,7 @@ public partial class MainWindow
private void UnfreezeTracks(IReadOnlyList<int> trackIds)
{
foreach (var id in trackIds) Engine.UnfreezeTrack(id);
- if (_vm is not null) _vm.StatusText = trackIds.Count == 1 ? Loc.T("Track unfrozen.") : Loc.F("{0} tracks unfrozen.", trackIds.Count);
+ if (_vm is not null) _vm.StatusText = trackIds.Count == 1 ? Loc.T("main.freeze.track_unfrozen") : Loc.F("main.freeze.tracks_unfrozen", trackIds.Count);
AfterFreezeChange();
}
@@ -265,11 +265,11 @@ public partial class MainWindow
private async Task FlattenTrackAsync(int trackId)
{
if (_vm is null || !IsFreezable(trackId)) return;
- if (!Engine.IsTrackFrozen(trackId)) { _vm.StatusText = Loc.T("Freeze the track first, then Flatten."); return; }
+ if (!Engine.IsTrackFrozen(trackId)) { _vm.StatusText = Loc.T("main.freeze.freeze_the_track_first_then"); return; }
- bool ok = await new ConfirmWindow(Loc.T("Flatten track"),
- Loc.T("Flatten replaces this track's instrument, MIDI and devices with a single audio clip of the frozen sound. ") +
- Loc.T("This can't be undone. Continue?"), Loc.T("Flatten"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ bool ok = await new ConfirmWindow(Loc.T("main.flatten_track"),
+ Loc.T("main.freeze.flatten_replaces_this_tracks_instrument") +
+ Loc.T("main.freeze.this_cant_be_undone_continue"), Loc.T("main.flatten"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
try
@@ -277,9 +277,9 @@ public partial class MainWindow
int newId = FlattenFrozenTrack(trackId);
Timeline.Refresh();
if (newId > 0) Timeline.Select(newId, -1); // selecting rebuilds the device panel
- _vm.StatusText = Loc.T("Track flattened to audio.");
+ _vm.StatusText = Loc.T("main.freeze.track_flattened_to_audio");
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Flatten failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.freeze.flatten_failed", ex.Message); }
}
// Bounce the frozen buffer to a WAV, drop it onto a fresh audio track that inherits the
diff --git a/src/managed/Nota.App/MainWindow.Gamepad.cs b/src/managed/Nota.App/MainWindow.Gamepad.cs
index 0b8f0ff0..4e4c8595 100644
--- a/src/managed/Nota.App/MainWindow.Gamepad.cs
+++ b/src/managed/Nota.App/MainWindow.Gamepad.cs
@@ -144,10 +144,10 @@ public partial class MainWindow
string label;
switch ((GamepadButton)ev.ButtonId)
{
- case GamepadButton.DpadUp: ShiftGamepadOctave(+1); label = Loc.T("Octave +"); break;
- case GamepadButton.DpadDown: ShiftGamepadOctave(-1); label = Loc.T("Octave −"); break;
- case GamepadButton.DpadLeft: ShiftGamepadVelocity(-10); label = Loc.T("Velocity −"); break;
- case GamepadButton.DpadRight: ShiftGamepadVelocity(+10); label = Loc.T("Velocity +"); break;
+ case GamepadButton.DpadUp: ShiftGamepadOctave(+1); label = Loc.T("main.gamepad.octave"); break;
+ case GamepadButton.DpadDown: ShiftGamepadOctave(-1); label = Loc.T("main.gamepad.octave_2"); break;
+ case GamepadButton.DpadLeft: ShiftGamepadVelocity(-10); label = Loc.T("main.gamepad.velocity_2"); break;
+ case GamepadButton.DpadRight: ShiftGamepadVelocity(+10); label = Loc.T("main.gamepad.velocity"); break;
default:
{
// Generic button: index 1..N → a scale tone if within the 8-note
@@ -178,7 +178,7 @@ public partial class MainWindow
{
_vm.Settings.Current.GamepadOctave = _gamepadOctave;
_vm.Settings.Save();
- _vm.StatusText = Loc.F("Gamepad octave: C{0}", 4 + _gamepadOctave);
+ _vm.StatusText = Loc.F("main.gamepad.gamepad_octave_c", 4 + _gamepadOctave);
}
}
diff --git a/src/managed/Nota.App/MainWindow.History.cs b/src/managed/Nota.App/MainWindow.History.cs
index 342f035c..dd6bc538 100644
--- a/src/managed/Nota.App/MainWindow.History.cs
+++ b/src/managed/Nota.App/MainWindow.History.cs
@@ -77,7 +77,7 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
catch (Exception ex) when (ex is ProjectHistoryException or IOException or UnauthorizedAccessException)
{
App.Services.GetRequiredService<ILogSink>().Error("Recording a project version failed", ex);
- return Loc.F(" · version not recorded: {0}", ex.Message);
+ return Loc.F("main.history.version_not_recorded", ex.Message);
}
}
@@ -86,7 +86,7 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
{
if (_projectPath is not { } dir || !_history.Exists(dir)) { HistoryChanged?.Invoke(); return; }
long freed = EraseHistory(dir);
- if (_vm is not null) _vm.StatusText = Loc.F("Version history turned off · {0} freed", NotaNum.Bytes(freed));
+ if (_vm is not null) _vm.StatusText = Loc.F("main.history.version_history_turned_off_freed", NotaNum.Bytes(freed));
}
private long EraseHistory(string dir)
@@ -118,10 +118,10 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
if (_vm is null) return;
if (!KeepVersionHistory)
{
- _vm.StatusText = Loc.T("Version history is turned off in Settings.");
+ _vm.StatusText = Loc.T("main.history.version_history_is_turned_off");
return;
}
- var note = await new TextPromptWindow(Loc.T("Save version"), Loc.T("What changed in this version?"))
+ var note = await new TextPromptWindow(Loc.T("main.history.save_version"), Loc.T("main.history.what_changed_in_this_version"))
.ShowDialog<string?>(this);
if (note is null) return;
await DoSaveAsync(saveAs: false, note);
@@ -132,8 +132,8 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
internal async Task<bool> SwitchToVersionAsync(string versionId, bool askAboutChanges = true)
{
if (_vm is null || _projectPath is not { } dir) return false;
- if (askAboutChanges && !await ConfirmLeaveChangesAsync(Loc.T("Switch version"),
- Loc.T("Save your changes as a new version before switching?"))) return false;
+ if (askAboutChanges && !await ConfirmLeaveChangesAsync(Loc.T("main.history.switch_version"),
+ Loc.T("main.history.save_your_changes_as_a"))) return false;
try
{
_history.Checkout(dir, versionId);
@@ -141,11 +141,11 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
catch (Exception ex) when (ex is ProjectHistoryException or IOException or UnauthorizedAccessException)
{
App.Services.GetRequiredService<ILogSink>().Error("Switching project version failed", ex);
- _vm.StatusText = Loc.F("Couldn't switch version: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.history.couldnt_switch_version", ex.Message);
return false;
}
OpenProject(dir);
- if (_history.Read(dir).HeadVersion is { } v) _vm.StatusText = Loc.F("Switched to {0}", DescribeVersion(v));
+ if (_history.Read(dir).HeadVersion is { } v) _vm.StatusText = Loc.F("main.history.switched_to", DescribeVersion(v));
return true;
}
@@ -154,17 +154,17 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
internal async Task<bool> OpenVersionAsCopyAsync(string versionId)
{
if (_vm is null || _projectPath is not { } src) return false;
- if (!await ConfirmLeaveChangesAsync(Loc.T("Open version as copy"),
- Loc.T("Save your changes before opening the copy?"))) return false;
+ if (!await ConfirmLeaveChangesAsync(Loc.T("main.history.open_version_as_copy"),
+ Loc.T("main.history.save_your_changes_before_opening"))) return false;
var version = _history.Read(src).Versions.FirstOrDefault(v => v.Id == versionId);
if (version is null) return false;
string suggested = $"{Path.GetFileNameWithoutExtension(src)} ({version.CreatedAt.LocalDateTime:yyyy-MM-dd HH.mm}).nota";
- var dst = await PickProjectPathAsync(Loc.T("Open version as a new project"), suggested);
+ var dst = await PickProjectPathAsync(Loc.T("main.history.open_version_as_a_new"), suggested);
if (dst is null) return false;
if (SamePath(src, dst) || (Directory.Exists(dst) && Directory.EnumerateFileSystemEntries(dst).Any()))
{
- _vm.StatusText = Loc.T("Choose a new name for the copy — it can't replace an existing project.");
+ _vm.StatusText = Loc.T("main.history.choose_a_new_name_for");
return false;
}
try
@@ -175,11 +175,11 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
catch (Exception ex) when (ex is ProjectHistoryException or IOException or UnauthorizedAccessException)
{
App.Services.GetRequiredService<ILogSink>().Error("Opening a project version as a copy failed", ex);
- _vm.StatusText = Loc.F("Couldn't open the version: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.history.couldnt_open_the_version", ex.Message);
return false;
}
OpenProject(dst);
- _vm.StatusText = Loc.F("Opened {0} as {1}", DescribeVersion(version), Path.GetFileName(dst));
+ _vm.StatusText = Loc.F("main.history.opened_as", DescribeVersion(version), Path.GetFileName(dst));
return true;
}
@@ -201,7 +201,7 @@ public partial class MainWindow : IHistoryHost, Nota.Mcp.IProjectVersionsAccess
private static string DescribeVersion(ProjectVersion v)
{
string when = v.CreatedAt.LocalDateTime.ToString("d MMM, HH:mm", NotaNum.Culture);
- return v.Label is { Length: > 0 } label ? Loc.F("the version “{0}” ({1})", label, when) : Loc.F("the version of {0}", when);
+ return v.Label is { Length: > 0 } label ? Loc.F("main.history.the_version", label, when) : Loc.F("main.history.the_version_of", when);
}
private static bool SamePath(string a, string b)
diff --git a/src/managed/Nota.App/MainWindow.Input.cs b/src/managed/Nota.App/MainWindow.Input.cs
index 174de24c..a8540e04 100644
--- a/src/managed/Nota.App/MainWindow.Input.cs
+++ b/src/managed/Nota.App/MainWindow.Input.cs
@@ -285,17 +285,17 @@ public partial class MainWindow
// so the shortcut falls through to the clip clipboard below.
if (Timeline.AutomationMode)
{
- if (e.Key == Key.C && Timeline.CopyAutoSelection()) { _vm.StatusText = Loc.T("Copied automation"); e.Handled = true; return; }
- if (e.Key == Key.X && Timeline.CutAutoSelection()) { _vm.StatusText = Loc.T("Cut automation"); e.Handled = true; return; }
- if (e.Key == Key.V && Timeline.PasteAuto()) { _vm.StatusText = Loc.T("Pasted automation"); e.Handled = true; return; }
+ if (e.Key == Key.C && Timeline.CopyAutoSelection()) { _vm.StatusText = Loc.T("main.input.copied_automation"); e.Handled = true; return; }
+ if (e.Key == Key.X && Timeline.CutAutoSelection()) { _vm.StatusText = Loc.T("main.input.cut_automation"); e.Handled = true; return; }
+ if (e.Key == Key.V && Timeline.PasteAuto()) { _vm.StatusText = Loc.T("main.input.pasted_automation"); e.Handled = true; return; }
}
// A time range (Shift+drag) copies / cuts the covered slice; it and a clip selection
// are exclusive, so these return false whenever clips are selected instead.
- if (e.Key == Key.C && Timeline.CopyTimeSelection()) { _vm.StatusText = Loc.T("Copied range"); e.Handled = true; return; }
- if (e.Key == Key.X && Timeline.CutTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("Cut range"); e.Handled = true; return; }
- if (e.Key == Key.C && Timeline.CopySelectedClip()) { _vm.StatusText = Loc.T("Copied clip(s)"); e.Handled = true; return; }
- if (e.Key == Key.X && Timeline.CutSelectedClip()) { _session?.Refresh(); _vm.StatusText = Loc.T("Cut clip(s)"); e.Handled = true; return; }
- if (e.Key == Key.V && Timeline.PasteClipboard()) { _session?.Refresh(); _vm.StatusText = Loc.T("Pasted clip(s)"); e.Handled = true; return; }
+ if (e.Key == Key.C && Timeline.CopyTimeSelection()) { _vm.StatusText = Loc.T("main.copied_range"); e.Handled = true; return; }
+ if (e.Key == Key.X && Timeline.CutTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.cut_range"); e.Handled = true; return; }
+ if (e.Key == Key.C && Timeline.CopySelectedClip()) { _vm.StatusText = Loc.T("main.input.copied_clip_s"); e.Handled = true; return; }
+ if (e.Key == Key.X && Timeline.CutSelectedClip()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.input.cut_clip_s"); e.Handled = true; return; }
+ if (e.Key == Key.V && Timeline.PasteClipboard()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.input.pasted_clip_s"); e.Handled = true; return; }
}
// ←/→ nudge the selected arrangement clips by the grid step (⌥: a 64th); ⌥↑/⌥↓ move them
@@ -319,21 +319,21 @@ public partial class MainWindow
// note-deletion.
if (!mod && (e.Key == Key.Delete || e.Key == Key.Back) && Timeline.AutomationMode && Timeline.DeleteAutoSelection())
{
- _vm.StatusText = Loc.T("Deleted automation");
+ _vm.StatusText = Loc.T("main.input.deleted_automation");
e.Handled = true;
return;
}
if (!mod && (e.Key == Key.Delete || e.Key == Key.Back) && Timeline.DeleteTimeSelection())
{
_session?.Refresh();
- _vm.StatusText = Loc.T("Deleted range");
+ _vm.StatusText = Loc.T("main.input.deleted_range");
e.Handled = true;
return;
}
if (!mod && (e.Key == Key.Delete || e.Key == Key.Back) && Timeline.DeleteSelectedClips())
{
_session?.Refresh();
- _vm.StatusText = Loc.T("Deleted clip(s)");
+ _vm.StatusText = Loc.T("main.deleted_clip_s");
e.Handled = true;
return;
}
@@ -343,7 +343,7 @@ public partial class MainWindow
if (!mod && (e.Key == Key.D0 || e.Key == Key.NumPad0)
&& _editorRoll is not { GridFocused: true } && _heldKeys.Add(e.Key))
{
- if (Timeline.ToggleSelectedClipsActive()) { _session?.Refresh(); _vm.StatusText = Loc.T("Toggled clip(s)"); }
+ if (Timeline.ToggleSelectedClipsActive()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.toggled_clip_s"); }
e.Handled = true;
return;
}
@@ -397,16 +397,16 @@ public partial class MainWindow
switch (e.Key)
{
case Key.A: return Timeline.SelectAllTracks();
- case Key.C: return Report(Timeline.CopySelectedTracks(), Loc.T("Copied track(s)"));
- case Key.X: return Report(Timeline.CutSelectedTracks(), Loc.T("Cut track(s)"));
- case Key.V: return Report(Timeline.PasteTracks(), Loc.T("Pasted track(s)"));
+ case Key.C: return Report(Timeline.CopySelectedTracks(), Loc.T("main.copied_track_s"));
+ case Key.X: return Report(Timeline.CutSelectedTracks(), Loc.T("main.cut_track_s"));
+ case Key.V: return Report(Timeline.PasteTracks(), Loc.T("main.pasted_track_s"));
// macOS: the Edit menu's ⌘D accelerator gets there first (OnMenuDuplicate).
- case Key.D when !OperatingSystem.IsMacOS(): return Report(Timeline.DuplicateSelectedTracks(), Loc.T("Duplicated track(s)"));
+ case Key.D when !OperatingSystem.IsMacOS(): return Report(Timeline.DuplicateSelectedTracks(), Loc.T("main.duplicated_track_s"));
}
return false;
}
if (e.KeyModifiers == KeyModifiers.None && (e.Key == Key.Delete || e.Key == Key.Back))
- return Report(Timeline.DeleteSelectedTracks(), Loc.T("Deleted track(s)"));
+ return Report(Timeline.DeleteSelectedTracks(), Loc.T("main.deleted_track_s"));
return false;
bool Report(bool done, string status)
@@ -438,7 +438,7 @@ public partial class MainWindow
int prev = _typingOctave;
_typingOctave = Math.Clamp(_typingOctave + delta, -4, 4);
if (_vm is not null && _typingOctave != prev)
- _vm.StatusText = Loc.F("Keyboard octave: C{0}", 4 + _typingOctave);
+ _vm.StatusText = Loc.F("main.input.keyboard_octave_c", 4 + _typingOctave);
}
// C/V: nudge the velocity typed notes play at (1..127, typing keyboard).
@@ -447,6 +447,6 @@ public partial class MainWindow
int prev = _typingVelocity;
_typingVelocity = Math.Clamp(_typingVelocity + delta, 1, 127);
if (_vm is not null && _typingVelocity != prev)
- _vm.StatusText = Loc.F("Keyboard velocity: {0}", _typingVelocity);
+ _vm.StatusText = Loc.F("main.input.keyboard_velocity", _typingVelocity);
}
}
diff --git a/src/managed/Nota.App/MainWindow.LiveFreeze.cs b/src/managed/Nota.App/MainWindow.LiveFreeze.cs
index 3de306cd..c85c9144 100644
--- a/src/managed/Nota.App/MainWindow.LiveFreeze.cs
+++ b/src/managed/Nota.App/MainWindow.LiveFreeze.cs
@@ -66,7 +66,7 @@ public partial class MainWindow
}
if (dead is null) return;
foreach (int s in dead) _links.Remove(s);
- if (_vm is not null) _vm.StatusText = Loc.T("Live-freeze link removed — its track was deleted.");
+ if (_vm is not null) _vm.StatusText = Loc.T("main.live_freeze.live_freeze_link_removed_its");
UpdateFreezeButton(_freezeTrackId);
ApplyFrozenChainDim(_freezeTrackId);
}
@@ -113,10 +113,10 @@ public partial class MainWindow
{
if (_vm is null || !IsFreezable(sourceId) || LinkForSource(sourceId) is not null) return;
double endBeats = ProjectEndBeats();
- if (endBeats <= 0.0) { _vm.StatusText = Loc.T("Nothing to freeze — the arrangement is empty."); return; }
+ if (endBeats <= 0.0) { _vm.StatusText = Loc.T("main.nothing_to_freeze_the_arrangement"); return; }
- string? wav = await RenderSourceToWavAsync(sourceId, Loc.T("Live freeze"));
- if (wav is null) { _vm.StatusText = Loc.T("Couldn't freeze this track."); return; }
+ string? wav = await RenderSourceToWavAsync(sourceId, Loc.T("main.live_freeze"));
+ if (wav is null) { _vm.StatusText = Loc.T("main.couldnt_freeze_this_track"); return; }
try
{
@@ -142,9 +142,9 @@ public partial class MainWindow
Engine.SetTrackMute(sourceId, true); // implicit mute: engine skips its instrument/devices
_links[sourceId] = new FreezeLink { SourceId = sourceId, FrozenId = frozenId };
- _vm.StatusText = Loc.T("Track live-frozen — press Edit to change it, then Done.");
+ _vm.StatusText = Loc.T("main.live_freeze.track_live_frozen_press_edit");
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Live freeze failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.live_freeze_failed", ex.Message); }
finally { try { File.Delete(wav); } catch { } }
Timeline.Refresh();
@@ -158,7 +158,7 @@ public partial class MainWindow
Engine.SetTrackMute(sourceId, false); // wake the source — it plays live now
Engine.SetTrackMute(link.FrozenId, true); // silence the stale bounce
link.State = LinkState.Editing;
- _vm.StatusText = Loc.T("Editing the frozen source — press Done to re-freeze, or Discard.");
+ _vm.StatusText = Loc.T("main.live_freeze.editing_the_frozen_source_press");
Timeline.Refresh();
UpdateLiveFreezeButtons(_freezeTrackId);
ApplyFrozenChainDim(_freezeTrackId);
@@ -170,7 +170,7 @@ public partial class MainWindow
if (link is null || _vm is null) return;
string? wav = await RenderSourceToWavAsync(sourceId, "Re-freeze");
- if (wav is null) { _vm.StatusText = Loc.T("Re-freeze failed — the source is still live."); return; }
+ if (wav is null) { _vm.StatusText = Loc.T("main.live_freeze.re_freeze_failed_the_source"); return; }
try
{
@@ -186,7 +186,7 @@ public partial class MainWindow
link.Revision++;
_vm.StatusText = "Re-frozen.";
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Re-freeze failed: {0}", ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.re_freeze_failed", ex.Message); }
finally { try { File.Delete(wav); } catch { } }
Timeline.Refresh();
@@ -201,7 +201,7 @@ public partial class MainWindow
Engine.SetTrackMute(sourceId, true);
Engine.SetTrackMute(link.FrozenId, false);
link.State = LinkState.Frozen;
- _vm.StatusText = Loc.T("Left edit mode (the frozen audio was not changed).");
+ _vm.StatusText = Loc.T("main.live_freeze.left_edit_mode_the_frozen");
Timeline.Refresh();
UpdateLiveFreezeButtons(_freezeTrackId);
ApplyFrozenChainDim(_freezeTrackId);
@@ -215,7 +215,7 @@ public partial class MainWindow
Engine.RemoveTrack(link.FrozenId);
Engine.SetTrackMute(sourceId, false);
_links.Remove(sourceId);
- if (_vm is not null) _vm.StatusText = Loc.T("Unfrozen — the source is live again.");
+ if (_vm is not null) _vm.StatusText = Loc.T("main.live_freeze.unfrozen_the_source_is_live");
Timeline.Refresh();
Timeline.Select(sourceId, -1); // the frozen track may have been selected — it's gone now
}
@@ -225,9 +225,9 @@ public partial class MainWindow
{
var link = LinkForSource(sourceId);
if (link is null || _vm is null) return;
- bool ok = await new ConfirmWindow(Loc.T("Flatten track"),
- Loc.T("Flatten keeps the frozen audio track and permanently removes its source (instrument, MIDI and devices). Continue?"),
- Loc.T("Flatten"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ bool ok = await new ConfirmWindow(Loc.T("main.flatten_track"),
+ Loc.T("main.live_freeze.flatten_keeps_the_frozen_audio"),
+ Loc.T("main.flatten"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
int frozenId = link.FrozenId;
_links.Remove(sourceId);
@@ -236,7 +236,7 @@ public partial class MainWindow
string name = Engine.GetTrackName(frozenId);
if (name.EndsWith(FrozenSuffix, StringComparison.Ordinal))
Engine.SetTrackName(frozenId, name[..^FrozenSuffix.Length]); // no longer a "frozen" copy
- _vm.StatusText = Loc.T("Flattened — the frozen audio is now a plain track.");
+ _vm.StatusText = Loc.T("main.live_freeze.flattened_the_frozen_audio_is");
Timeline.Refresh();
if (Engine.TryGetTrackInfo(TrackIndexOf(frozenId), out _)) Timeline.Select(frozenId, -1);
}
@@ -253,21 +253,21 @@ public partial class MainWindow
_vm.SuspendEnginePolling = true;
try
{
- await RunBlockingAsync(title, Loc.T("Rendering…"), async prog =>
+ await RunBlockingAsync(title, Loc.T("main.rendering"), async prog =>
{
- var frac = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.F("Rendering… {0:0}\u2009%", f * 100))));
+ var frac = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.F("main.rendering_n", f * 100))));
ok = await Task.Run(() => _freezer.Freeze(Engine, sourceId, endBeats,
_vm.Transport.LoopOn, _vm.Transport.MetronomeOn, frac));
});
}
- catch (Exception ex) { _vm.StatusText = Loc.F("{0} failed: {1}", title, ex.Message); }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.failed", title, ex.Message); }
finally { _vm.SuspendEnginePolling = false; }
if (!ok) { Engine.UnfreezeTrack(sourceId); return null; }
byte[] blob = Engine.GetFreezeState(sourceId);
Engine.UnfreezeTrack(sourceId); // we only wanted the PCM; the link owns the audio
try { return WriteFreezeBlobToWav(blob); }
- catch (Exception ex) { _vm.StatusText = Loc.F("{0} failed: {1}", title, ex.Message); return null; }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.failed", title, ex.Message); return null; }
}
// --- context menu (Live freeze switch / Flatten), shared by source + frozen tracks ---
@@ -278,9 +278,9 @@ public partial class MainWindow
if (_liveFreezeMenuBuilt) return;
_liveFreezeMenuBuilt = true;
// The same switch the track menu shows: on while linked; switching it off unfreezes.
- var unfreeze = MenuKit.SwitchItem(Loc.T("Live freeze"), GlyphKind.ChainLink, true,
+ var unfreeze = MenuKit.SwitchItem(Loc.T("main.live_freeze"), GlyphKind.ChainLink, true,
() => { int s = LinkSourceFor(_freezeTrackId); if (s > 0) UnfreezeLink(s); });
- var flatten = MenuKit.Danger(Loc.T("Flatten (remove source)"), GlyphKind.Flatten,
+ var flatten = MenuKit.Danger(Loc.T("main.flatten_remove_source"), GlyphKind.Flatten,
() => { int s = LinkSourceFor(_freezeTrackId); if (s > 0) FlattenLinkAsync(s); });
var menu = new ContextMenu();
menu.Items.Add(unfreeze);
diff --git a/src/managed/Nota.App/MainWindow.Menu.cs b/src/managed/Nota.App/MainWindow.Menu.cs
index 614e99cb..839b3438 100644
--- a/src/managed/Nota.App/MainWindow.Menu.cs
+++ b/src/managed/Nota.App/MainWindow.Menu.cs
@@ -40,7 +40,7 @@ public partial class MainWindow
private void OnStub(object? sender, EventArgs e)
{
- if (_vm is not null) _vm.StatusText = Loc.T("Not implemented yet.");
+ if (_vm is not null) _vm.StatusText = Loc.T("main.menu.not_implemented_yet");
}
// --- undo / redo (M6-6) ------------------------------------------------
@@ -49,16 +49,16 @@ public partial class MainWindow
{
if (_vm is null) return;
_editorRoll?.EndVelocityWheel(); // the burst is the step about to be undone
- if (Engine.Undo()) { RefreshAfterUndoRedo(); _vm.StatusText = Loc.T("Undo"); }
- else _vm.StatusText = Loc.T("Nothing to undo.");
+ if (Engine.Undo()) { RefreshAfterUndoRedo(); _vm.StatusText = Loc.T("common.undo"); }
+ else _vm.StatusText = Loc.T("main.menu.nothing_to_undo");
}
private void OnMenuRedo(object? sender, EventArgs e)
{
if (_vm is null) return;
_editorRoll?.EndVelocityWheel();
- if (Engine.Redo()) { RefreshAfterUndoRedo(); _vm.StatusText = Loc.T("Redo"); }
- else _vm.StatusText = Loc.T("Nothing to redo.");
+ if (Engine.Redo()) { RefreshAfterUndoRedo(); _vm.StatusText = Loc.T("main.redo"); }
+ else _vm.StatusText = Loc.T("main.menu.nothing_to_redo");
}
// Undo/redo swaps the whole graph snapshot, so refresh every view that reads it.
@@ -91,7 +91,7 @@ public partial class MainWindow
private void OnMenuInsertScene(object? sender, EventArgs e)
{
if (_vm is null || _session is null) return;
- if (!_session.IsVisible) { _vm.StatusText = Loc.T("Scenes live in the Session view."); return; }
+ if (!_session.IsVisible) { _vm.StatusText = Loc.T("main.menu.scenes_live_in_the_session"); return; }
_session.InsertSceneAtSelection();
}
private void OnMenuExport(object? sender, EventArgs e) => _ = DoExportAsync();
@@ -104,34 +104,34 @@ public partial class MainWindow
// it duplicates the selected arrangement clip.
if (_editorRoll is { GridFocused: true } roll && roll.DuplicateSelection())
{
- _vm.StatusText = Loc.T("Duplicated notes");
+ _vm.StatusText = Loc.T("main.menu.duplicated_notes");
return;
}
// Track headers focused: duplicate the selected tracks.
- if (_trackHeadersFocused && Timeline.DuplicateSelectedTracks()) { _vm.StatusText = Loc.T("Duplicated track(s)"); return; }
+ if (_trackHeadersFocused && Timeline.DuplicateSelectedTracks()) { _vm.StatusText = Loc.T("main.duplicated_track_s"); return; }
// In automation mode a selected range duplicates the envelope slice (chains on repeat).
- if (Timeline.AutomationMode && Timeline.DuplicateAutoSelection()) { _vm.StatusText = Loc.T("Duplicated automation"); return; }
+ if (Timeline.AutomationMode && Timeline.DuplicateAutoSelection()) { _vm.StatusText = Loc.T("main.menu.duplicated_automation"); return; }
// A time-range selection duplicates the covered slice (chains on repeat) before clips.
- if (Timeline.DuplicateTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("Duplicated range"); return; }
- if (Timeline.DuplicateSelectedClip()) { _session?.Refresh(); _vm.StatusText = Loc.T("Duplicated clip(s)"); }
- else _vm.StatusText = Loc.T("Select a clip first.");
+ if (Timeline.DuplicateTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.duplicated_range"); return; }
+ if (Timeline.DuplicateSelectedClip()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.duplicated_clip_s"); }
+ else _vm.StatusText = Loc.T("main.menu.select_a_clip_first");
}
// ⌘⇧D Duplicate Time / ⌘⇧I Insert Silence: whole-arrangement time ops on the time selection.
private void OnMenuDuplicateTime(object? sender, EventArgs e)
{
if (_vm is null) return;
- if (!Timeline.HasTimeSelection) { _vm.StatusText = Loc.T("Select a time range first."); return; }
- if (Timeline.DuplicateTimeInsert()) { _session?.Refresh(); _vm.StatusText = Loc.T("Duplicated time"); }
- else _vm.StatusText = Loc.T("Nothing to duplicate in the selected range.");
+ if (!Timeline.HasTimeSelection) { _vm.StatusText = Loc.T("main.menu.select_a_time_range_first"); return; }
+ if (Timeline.DuplicateTimeInsert()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.duplicated_time"); }
+ else _vm.StatusText = Loc.T("main.menu.nothing_to_duplicate_in_the");
}
private void OnMenuInsertSilence(object? sender, EventArgs e)
{
if (_vm is null) return;
- if (!Timeline.HasTimeSelection) { _vm.StatusText = Loc.T("Select a time range first."); return; }
- if (Timeline.InsertSilenceAtTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("Inserted silence"); }
- else _vm.StatusText = Loc.T("Nothing after the selection to move.");
+ if (!Timeline.HasTimeSelection) { _vm.StatusText = Loc.T("main.menu.select_a_time_range_first"); return; }
+ if (Timeline.InsertSilenceAtTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.inserted_silence"); }
+ else _vm.StatusText = Loc.T("main.menu.nothing_after_the_selection_to");
}
private void OnMenuSplit(object? sender, EventArgs e)
@@ -140,17 +140,17 @@ public partial class MainWindow
_editorRoll?.SettlePlacement(); // lands in the clips as they are numbered now, before the split re-indexes them
// In the piano roll Cmd+E has no note meaning; only split arrangement clips.
// A time-range selection wins: split every covered track at the range edges.
- if (Timeline.SplitTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("Split at selection"); return; }
- if (Timeline.SplitSelectedAtPlayhead()) { _session?.Refresh(); _vm.StatusText = Loc.T("Split clip(s) at playhead"); }
- else _vm.StatusText = Loc.T("Select a range, or a clip the playhead crosses.");
+ if (Timeline.SplitTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.split_at_selection"); return; }
+ if (Timeline.SplitSelectedAtPlayhead()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.split_clip_s_at_playhead"); }
+ else _vm.StatusText = Loc.T("main.menu.select_a_range_or_a");
}
private void OnMenuConsolidate(object? sender, EventArgs e)
{
if (_vm is null) return;
// A time-range selection wins; otherwise the span of the selected clips.
- if (Timeline.ConsolidateSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("Consolidated"); }
- else _vm.StatusText = Loc.T("Select a range or clips to consolidate.");
+ if (Timeline.ConsolidateSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.consolidated"); }
+ else _vm.StatusText = Loc.T("main.menu.select_a_range_or_clips");
}
// The piano roll currently on screen, or null. Edit-menu clipboard commands target it
@@ -162,27 +162,27 @@ public partial class MainWindow
{
if (_vm is null) return;
if (SessionFocused && _session!.CopySelection()) return;
- if (_trackHeadersFocused && Timeline.CopySelectedTracks()) { _vm.StatusText = Loc.T("Copied track(s)"); return; }
- if (ActiveRoll() is { } roll && roll.CopySelection()) { _vm.StatusText = Loc.T("Copied notes"); return; }
- if (Timeline.CopyTimeSelection()) { _vm.StatusText = Loc.T("Copied range"); return; }
- if (Timeline.CopySelectedClip()) _vm.StatusText = Loc.T("Copied clip");
+ if (_trackHeadersFocused && Timeline.CopySelectedTracks()) { _vm.StatusText = Loc.T("main.copied_track_s"); return; }
+ if (ActiveRoll() is { } roll && roll.CopySelection()) { _vm.StatusText = Loc.T("main.menu.copied_notes"); return; }
+ if (Timeline.CopyTimeSelection()) { _vm.StatusText = Loc.T("main.copied_range"); return; }
+ if (Timeline.CopySelectedClip()) _vm.StatusText = Loc.T("main.menu.copied_clip");
}
private void OnMenuCut(object? sender, EventArgs e)
{
if (_vm is null) return;
if (SessionFocused && _session!.CutSelection()) return;
- if (_trackHeadersFocused && Timeline.CutSelectedTracks()) { _vm.StatusText = Loc.T("Cut track(s)"); return; }
- if (ActiveRoll() is { } roll && roll.CutSelection()) { _vm.StatusText = Loc.T("Cut notes"); return; }
- if (Timeline.CutTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("Cut range"); return; }
- if (Timeline.CutSelectedClip()) { _session?.Refresh(); _vm.StatusText = Loc.T("Cut clip"); }
+ if (_trackHeadersFocused && Timeline.CutSelectedTracks()) { _vm.StatusText = Loc.T("main.cut_track_s"); return; }
+ if (ActiveRoll() is { } roll && roll.CutSelection()) { _vm.StatusText = Loc.T("main.menu.cut_notes"); return; }
+ if (Timeline.CutTimeSelection()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.cut_range"); return; }
+ if (Timeline.CutSelectedClip()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.cut_clip"); }
}
private void OnMenuPaste(object? sender, EventArgs e)
{
if (_vm is null) return;
if (SessionFocused && _session!.PasteSelection()) return;
- if (_trackHeadersFocused && Timeline.PasteTracks()) { _vm.StatusText = Loc.T("Pasted track(s)"); return; }
- if (ActiveRoll() is { } roll && roll.PasteClipboard()) { _vm.StatusText = Loc.T("Pasted notes"); return; }
- if (Timeline.PasteClipboard()) { _session?.Refresh(); _vm.StatusText = Loc.T("Pasted clip"); }
+ if (_trackHeadersFocused && Timeline.PasteTracks()) { _vm.StatusText = Loc.T("main.pasted_track_s"); return; }
+ if (ActiveRoll() is { } roll && roll.PasteClipboard()) { _vm.StatusText = Loc.T("main.menu.pasted_notes"); return; }
+ if (Timeline.PasteClipboard()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.menu.pasted_clip"); }
}
// ⌘⇧C: the Arrangement's selected clips go to session slots, the Session view's selected
// slot / scene goes onto the timeline at the playhead — whichever view is on screen.
@@ -191,18 +191,18 @@ public partial class MainWindow
if (_vm is null) return;
if (_session?.IsVisible == true)
{
- if (!_session.CopySelectionToArrangement()) _vm.StatusText = Loc.T("Select a clip or a scene to copy to the arrangement.");
+ if (!_session.CopySelectionToArrangement()) _vm.StatusText = Loc.T("main.menu.select_a_clip_or_a");
}
else if (Timeline.IsVisible && Timeline.CopySelectionToSession() < 0)
- _vm.StatusText = Loc.T("Select clips to copy to the session.");
+ _vm.StatusText = Loc.T("main.menu.select_clips_to_copy_to");
}
private void OnMenuDeleteSel(object? sender, EventArgs e)
{
if (_vm is null) return;
if (SessionFocused && _session!.DeleteSelection()) return;
- if (_trackHeadersFocused && Timeline.DeleteSelectedTracks()) { _vm.StatusText = Loc.T("Deleted track(s)"); return; }
- if (ActiveRoll() is { } roll && roll.DeleteSelection()) { _vm.StatusText = Loc.T("Deleted notes"); return; }
- if (Timeline.DeleteSelectedClips()) { _session?.Refresh(); _vm.StatusText = Loc.T("Deleted clip(s)"); }
+ if (_trackHeadersFocused && Timeline.DeleteSelectedTracks()) { _vm.StatusText = Loc.T("main.deleted_track_s"); return; }
+ if (ActiveRoll() is { } roll && roll.DeleteSelection()) { _vm.StatusText = Loc.T("main.menu.deleted_notes"); return; }
+ if (Timeline.DeleteSelectedClips()) { _session?.Refresh(); _vm.StatusText = Loc.T("main.deleted_clip_s"); }
}
private void OnMenuToggleBrowser(object? sender, EventArgs e)
{
@@ -225,7 +225,7 @@ public partial class MainWindow
private void OnMenuToggleOverview(object? sender, EventArgs e)
{
Timeline.ShowOverview = !Timeline.ShowOverview;
- if (_vm is not null) _vm.StatusText = Timeline.ShowOverview ? Loc.T("Overview strip shown") : Loc.T("Overview strip hidden");
+ if (_vm is not null) _vm.StatusText = Timeline.ShowOverview ? Loc.T("main.menu.overview_strip_shown") : Loc.T("main.menu.overview_strip_hidden");
}
private void OnMenuToggleSections(object? sender, EventArgs e)
{
@@ -233,7 +233,7 @@ public partial class MainWindow
if (_vm is null) return;
_vm.Settings.Current.ArrangementShowSections = Timeline.ShowSections;
_vm.Settings.Save();
- _vm.StatusText = Timeline.ShowSections ? Loc.T("Sections lane shown") : Loc.T("Sections lane hidden");
+ _vm.StatusText = Timeline.ShowSections ? Loc.T("main.menu.sections_lane_shown") : Loc.T("main.menu.sections_lane_hidden");
}
// Follow: mirrors the transport bar's Follow button — one state, two surfaces.
private void OnMenuToggleFollow(object? sender, EventArgs e)
@@ -257,9 +257,9 @@ public partial class MainWindow
if (_vm is not null)
_vm.StatusText = Timeline.ClipLabels switch
{
- ClipLabelMode.Every => Loc.T("Clip names: every clip"),
- ClipLabelMode.RunStart => Loc.T("Clip names: first of a run"),
- _ => Loc.T("Clip names: none"),
+ ClipLabelMode.Every => Loc.T("main.menu.clip_names_every_clip"),
+ ClipLabelMode.RunStart => Loc.T("main.menu.clip_names_first_of_a"),
+ _ => Loc.T("main.menu.clip_names_none"),
};
}
private void OnMenuPlayStop(object? sender, EventArgs e) => _vm?.Transport.PlayStopCommand.Execute(null);
@@ -274,7 +274,7 @@ public partial class MainWindow
&& !(t.LoopOn && Engine.LoopStart == r.Start && Engine.LoopEnd == r.End))
{
Timeline.SetLoopRegion(r.Start, r.End);
- _vm.StatusText = Loc.T("Loop set to selection");
+ _vm.StatusText = Loc.T("main.menu.loop_set_to_selection");
return;
}
t.LoopOn = !t.LoopOn;
diff --git a/src/managed/Nota.App/MainWindow.MenuKeys.cs b/src/managed/Nota.App/MainWindow.MenuKeys.cs
index d4a90771..1615bde8 100644
--- a/src/managed/Nota.App/MainWindow.MenuKeys.cs
+++ b/src/managed/Nota.App/MainWindow.MenuKeys.cs
@@ -26,7 +26,7 @@ public partial class MainWindow
private void InitMenuShortcuts()
{
BindCommands();
- ToolTip.SetTip(AutomationToggle, MenuKit.Keys(Loc.T("Show parameter-automation lanes (⌘⇧A)")));
+ ToolTip.SetTip(AutomationToggle, MenuKit.Keys(Loc.T("main.menu_keys.show_parameter_automation_lanes_a")));
// The XAML tips name the macOS keys; spell them Ctrl+… on Windows / Linux (#10).
foreach (var c in new Control[] { RecordBtn, LoopRecordCell, MetronomeBtn, DetailMaximizeBtn })
if (ToolTip.GetTip(c) is string tip) ToolTip.SetTip(c, MenuKit.Keys(tip));
diff --git a/src/managed/Nota.App/MainWindow.MidiImport.cs b/src/managed/Nota.App/MainWindow.MidiImport.cs
index 1e657167..ba027364 100644
--- a/src/managed/Nota.App/MainWindow.MidiImport.cs
+++ b/src/managed/Nota.App/MainWindow.MidiImport.cs
@@ -41,14 +41,14 @@ public partial class MainWindow
}
finally { Engine.EndUndoGroup(); }
if (firstTrack > 0) _lastInstrumentTrackId = firstTrack;
- _vm.StatusText = multi ? Loc.F("Imported {0} ({1} parts)", item.Name, file.Parts.Count) : Loc.F("Imported {0}", item.Name);
+ _vm.StatusText = multi ? Loc.F("main.midi_import.imported_parts", item.Name, file.Parts.Count) : Loc.F("main.imported", item.Name);
return firstTrack;
}
private void ImportMidiFileToSlot(BrowserItem item, int trackId, int scene, bool instrumentTrack)
{
if (_vm is null) return;
- if (!instrumentTrack) { _vm.StatusText = Loc.T("Drop MIDI files onto instrument slots."); return; }
+ if (!instrumentTrack) { _vm.StatusText = Loc.T("main.midi_import.drop_midi_files_onto_instrument"); return; }
if (ReadMidiFile(item) is not { } file) return;
Engine.BeginUndoGroup();
try
@@ -57,7 +57,7 @@ public partial class MainWindow
Engine.SetSessionNotes(trackId, scene, file.AllNotes().ToArray());
}
finally { Engine.EndUndoGroup(); }
- _vm.StatusText = Loc.F("Added {0} to slot", item.Name);
+ _vm.StatusText = Loc.F("main.added_to_slot", item.Name);
}
// Parses the file, reporting a bad / empty one in the status bar instead of throwing.
@@ -67,9 +67,9 @@ public partial class MainWindow
{
var file = MidiFileReader.Read(item.Path);
if (file.Parts.Count > 0) return file;
- _vm!.StatusText = Loc.F("{0} has no notes.", item.Name);
+ _vm!.StatusText = Loc.F("main.midi_import.has_no_notes", item.Name);
}
- catch (Exception ex) { _vm!.StatusText = Loc.F("Couldn't read {0}: {1}", item.Name, ex.Message); }
+ catch (Exception ex) { _vm!.StatusText = Loc.F("main.midi_import.couldnt_read", item.Name, ex.Message); }
return null;
}
diff --git a/src/managed/Nota.App/MainWindow.MissingPlugins.cs b/src/managed/Nota.App/MainWindow.MissingPlugins.cs
index 494257d2..7570596f 100644
--- a/src/managed/Nota.App/MainWindow.MissingPlugins.cs
+++ b/src/managed/Nota.App/MainWindow.MissingPlugins.cs
@@ -34,14 +34,14 @@ public partial class MainWindow
bool one = offers.Count == 1;
var names = string.Join(", ", offers.Select(p => p.Name));
- var ok = await new ConfirmWindow(Loc.T("Missing plugins"),
- one ? Loc.F("This project uses {0}, which isn't installed. It's open source and available from the Nota plugin registry. Install and reopen the project?", names)
- : Loc.F("This project uses {0}, which aren't installed. They're open source and available from the Nota plugin registry. Install and reopen the project?", names),
- Loc.T("Install"), Loc.T("Not now")).ShowDialog<bool>(this);
+ var ok = await new ConfirmWindow(Loc.T("main.missing_plugins.missing_plugins"),
+ one ? Loc.F("main.missing_plugins.this_project_uses_which_isnt", names)
+ : Loc.F("main.missing_plugins.this_project_uses_which_arent", names),
+ Loc.T("main.missing_plugins.install"), Loc.T("main.not_now")).ShowDialog<bool>(this);
if (!ok || _vm is null) return;
string? error = null;
- await RunBackgroundAsync(Loc.T("Installing plugins…"), async prog =>
+ await RunBackgroundAsync(Loc.T("main.missing_plugins.installing_plugins"), async prog =>
{
foreach (var p in offers)
{
@@ -52,7 +52,7 @@ public partial class MainWindow
}
catch (StoreException e) { error ??= e.Message; }
}
- prog.Report(ProgressReport.Indeterminate(Loc.T("Scanning plugins…")));
+ prog.Report(ProgressReport.Indeterminate(Loc.T("main.missing_plugins.scanning_plugins")));
await PluginScan.RescanAsync(_vm, new Progress<PluginScanProgress>(s =>
prog.Report(new ProgressReport(PluginScan.Fraction(s), PluginScan.Describe(s)))), onlyDir: store.PluginsDir);
});
@@ -60,6 +60,6 @@ public partial class MainWindow
if (error is not null) { _vm.StatusText = error; return; }
// Reopen only when that's lossless: same project, nothing edited since it opened.
if (_projectPath == dir && !HasUnsavedChanges()) OpenProject(dir);
- else _vm.StatusText = one ? Loc.F("Installed {0} — reopen the project to use it.", names) : Loc.F("Installed {0} — reopen the project to use them.", names);
+ else _vm.StatusText = one ? Loc.F("main.missing_plugins.installed_reopen_the_project_to", names) : Loc.F("main.missing_plugins.installed_reopen_the_project_to_n", names);
}
}
diff --git a/src/managed/Nota.App/MainWindow.Mosaic.cs b/src/managed/Nota.App/MainWindow.Mosaic.cs
index 0371968f..11fcbde2 100644
--- a/src/managed/Nota.App/MainWindow.Mosaic.cs
+++ b/src/managed/Nota.App/MainWindow.Mosaic.cs
@@ -43,6 +43,6 @@ public partial class MainWindow
engine.MosaicSetProgram(t, prog.Serialize());
Timeline.Refresh();
ShowDevices(t);
- _vm.StatusText = win.Created.Count == 1 ? Loc.F("Created the preset {0}", prog.Name) : Loc.F("Created {0} presets · loaded {1}", win.Created.Count, prog.Name);
+ _vm.StatusText = win.Created.Count == 1 ? Loc.F("main.mosaic.created_the_preset", prog.Name) : Loc.F("main.mosaic.created_presets_loaded", win.Created.Count, prog.Name);
}
}
diff --git a/src/managed/Nota.App/MainWindow.Palette.cs b/src/managed/Nota.App/MainWindow.Palette.cs
index eccc67dc..8860848e 100644
--- a/src/managed/Nota.App/MainWindow.Palette.cs
+++ b/src/managed/Nota.App/MainWindow.Palette.cs
@@ -118,7 +118,7 @@ public partial class MainWindow
}
private Availability ActionAvailability(string id, PaletteContext ctx)
- => _commands.Get(id) is { } c ? c.CanExecute(ctx) : Availability.No(Loc.T("Not available"));
+ => _commands.Get(id) is { } c ? c.CanExecute(ctx) : Availability.No(Loc.T("main.palette.not_available"));
// ---- context (CP-2, CP-3) ---------------------------------------------------------------
@@ -165,7 +165,7 @@ public partial class MainWindow
}
else track = -1;
- string trackName = track <= 0 ? "" : type == PaletteTrackType.Master ? Loc.T("Master") : Engine.GetTrackName(track);
+ string trackName = track <= 0 ? "" : type == PaletteTrackType.Master ? Loc.T("common.master") : Engine.GetTrackName(track);
var insert = origin == PaletteOrigin.Devices && _deviceChain is { } dc && dc.TrackId == track ? dc.CurrentInsertPoint() : InsertPoint.None;
return new PaletteContext
{
@@ -201,12 +201,12 @@ public partial class MainWindow
return null;
case PaletteKind.Track when item.Payload is int t:
- if ((mode & ApplyMode.NewTrack) != 0 || Insertion.IsMaster(t)) { ShowDevices(t); _vm.StatusText = Loc.F("Opened {0} in Devices", item.Name); }
+ if ((mode & ApplyMode.NewTrack) != 0 || Insertion.IsMaster(t)) { ShowDevices(t); _vm.StatusText = Loc.F("main.palette.opened_in_devices", item.Name); }
else
{
Timeline.Select(t, -1);
if (_modular?.IsVisible == true) _modular.Show(t);
- _vm.StatusText = Loc.F("Selected {0}", item.Name);
+ _vm.StatusText = Loc.F("main.palette.selected", item.Name);
}
return null;
@@ -215,9 +215,9 @@ public partial class MainWindow
if (_modular is null || ctx.TrackId <= 0) return null;
if (_modular.TrackId != ctx.TrackId) _modular.Show(ctx.TrackId);
int modId = _modular.AddModulatorAt(kind);
- if (modId < 0) { _vm.StatusText = Loc.F("Couldn't add {0}.", item.Name); return null; }
+ if (modId < 0) { _vm.StatusText = Loc.F("main.palette.couldnt_add", item.Name); return null; }
Timeline.Refresh();
- string msg = Loc.F("{0} added to the {1} canvas — connect it to a parameter", item.Name, ctx.TrackName);
+ string msg = Loc.F("main.palette.added_to_the_canvas_connect", item.Name, ctx.TrackName);
_vm.StatusText = msg;
_paletteToast.Show(msg, () => _commands.Run("edit.undo"));
return ctx;
diff --git a/src/managed/Nota.App/MainWindow.PasteBounced.cs b/src/managed/Nota.App/MainWindow.PasteBounced.cs
index 0cef9965..60c1361c 100644
--- a/src/managed/Nota.App/MainWindow.PasteBounced.cs
+++ b/src/managed/Nota.App/MainWindow.PasteBounced.cs
@@ -28,16 +28,16 @@ public partial class MainWindow
{
if (_vm is null || _bounceBusy) return;
if (Timeline.BounceSource is not { } src)
- { _vm.StatusText = Loc.T("Select a time range first (Shift+drag), then paste it bounced onto an audio track."); return; }
+ { _vm.StatusText = Loc.T("main.paste_bounced.select_a_time_range_first"); return; }
// Only clip tracks render content (groups/returns have no chain of their own to bounce).
var sources = src.TrackIds.Where(id => TrackTypeOf(id) is 0 or 1).ToArray();
- if (sources.Length == 0) { _vm.StatusText = Loc.T("The selected range has no audio or instrument track to bounce."); return; }
- if (sources.Length > 1) { _vm.StatusText = Loc.T("Paste bounced audio takes a range on a single track."); return; }
+ if (sources.Length == 0) { _vm.StatusText = Loc.T("main.paste_bounced.the_selected_range_has_no"); return; }
+ if (sources.Length > 1) { _vm.StatusText = Loc.T("main.paste_bounced.paste_bounced_audio_takes_a"); return; }
int sourceId = sources[0];
if (targetId <= 0) targetId = Timeline.FocusTrackId;
- if (TrackTypeOf(targetId) != 0) { _vm.StatusText = Loc.T("Click an audio track to paste the bounced audio onto."); return; }
+ if (TrackTypeOf(targetId) != 0) { _vm.StatusText = Loc.T("main.paste_bounced.click_an_audio_track_to"); return; }
double at = Math.Max(0.0, atBeat ?? Engine.PositionBeats); // read now: the render moves the playhead
string name = Engine.GetTrackName(sourceId);
@@ -47,23 +47,23 @@ public partial class MainWindow
float[]? pcm = null;
try
{
- await RunBlockingAsync(Loc.T("Paste bounced audio"), Loc.T("Rendering…"), async prog =>
+ await RunBlockingAsync(Loc.T("common.paste_bounced_audio"), Loc.T("main.rendering"), async prog =>
{
- var frac = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.F("Rendering… {0:0} %", f * 100))));
+ var frac = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.F("main.rendering_n", f * 100))));
pcm = await Task.Run(() => _freezer.BounceRange(Engine, sourceId, src.Start, src.End,
_vm.Transport.LoopOn, _vm.Transport.MetronomeOn, frac));
});
}
- catch (Exception ex) { _vm.StatusText = Loc.F("Paste bounced audio failed: {0}", ex.Message); return; }
+ catch (Exception ex) { _vm.StatusText = Loc.F("main.paste_bounced.paste_bounced_audio_failed", ex.Message); return; }
finally { _vm.SuspendEnginePolling = false; _bounceBusy = false; }
- if (pcm is null) { _vm.StatusText = Loc.T("Couldn't render this track."); return; }
+ if (pcm is null) { _vm.StatusText = Loc.T("main.paste_bounced.couldnt_render_this_track"); return; }
if (Engine.PasteAudioFrames(targetId, pcm, pcm.Length / 2, at, name) < 0)
- { _vm.StatusText = Loc.T("Couldn't paste the bounced audio."); return; }
+ { _vm.StatusText = Loc.T("main.paste_bounced.couldnt_paste_the_bounced_audio"); return; }
Timeline.RefreshAndSelectPlaced();
_session?.Refresh();
- _vm.StatusText = Loc.T("Pasted bounced audio");
+ _vm.StatusText = Loc.T("main.paste_bounced.pasted_bounced_audio");
}
// Engine track type (0 audio, 1 instrument, 2 return, 3 group), or -1 when the id is gone.
diff --git a/src/managed/Nota.App/MainWindow.Recent.cs b/src/managed/Nota.App/MainWindow.Recent.cs
index 84e7e0cb..ee98d6b6 100644
--- a/src/managed/Nota.App/MainWindow.Recent.cs
+++ b/src/managed/Nota.App/MainWindow.Recent.cs
@@ -67,7 +67,7 @@ public partial class MainWindow
if (e.IsPlugin)
{
int index = RecentCatalog?.IndexOfId(e.Id) ?? -1;
- if (index < 0) { _vm.StatusText = Loc.F("{0} is no longer installed.", e.Name); return; }
+ if (index < 0) { _vm.StatusText = Loc.F("main.recent.is_no_longer_installed", e.Name); return; }
item = new BrowserItem { Name = e.Name, Kind = BrowserItemKind.PluginInstrument, CatalogIndex = index };
}
else item = new BrowserItem { Name = e.Name, Kind = BrowserItemKind.BuiltinInstrument, BuiltinKind = e.BuiltinKindId };
@@ -80,12 +80,12 @@ public partial class MainWindow
if (trackId > 0) Timeline.PlaceNewTrack(trackId, anchorTrackId);
}
finally { Engine.EndUndoGroup(); }
- if (trackId <= 0) { _vm.StatusText = Loc.F("Couldn't load {0}.", e.Name); return; }
+ if (trackId <= 0) { _vm.StatusText = Loc.F("common.couldnt_load", e.Name); return; }
Timeline.Refresh();
Timeline.RevealTrack(trackId);
if (anchorTrackId > 0) Timeline.Select(trackId, -1);
_session?.Refresh();
if (_modular?.IsVisible == true) _modular.Refresh();
- _vm.StatusText = Loc.F("Added {0} (track {1})", e.Name, trackId);
+ _vm.StatusText = Loc.F("main.recent.added_track", e.Name, trackId);
}
}
diff --git a/src/managed/Nota.App/MainWindow.RecentMenu.cs b/src/managed/Nota.App/MainWindow.RecentMenu.cs
index 6277992e..4d06616c 100644
--- a/src/managed/Nota.App/MainWindow.RecentMenu.cs
+++ b/src/managed/Nota.App/MainWindow.RecentMenu.cs
@@ -28,7 +28,7 @@ public partial class MainWindow
{
if (file.Items[i] is not NativeMenuItem item || Commands.GetId(item) != "file.open") continue;
_recentMenu = new NativeMenu();
- file.Items.Insert(i + 1, new NativeMenuItem(Loc.T("Open recent")) { Menu = _recentMenu });
+ file.Items.Insert(i + 1, new NativeMenuItem(Loc.T("main.recent_menu.open_recent")) { Menu = _recentMenu });
RefreshRecentMenu();
return;
}
@@ -50,6 +50,6 @@ public partial class MainWindow
_recentMenu.Items.Add(item);
}
if (recent.Count == 0)
- _recentMenu.Items.Add(new NativeMenuItem(Loc.T("No recent projects")) { IsEnabled = false });
+ _recentMenu.Items.Add(new NativeMenuItem(Loc.T("main.recent_menu.no_recent_projects")) { IsEnabled = false });
}
}
diff --git a/src/managed/Nota.App/MainWindow.Recovery.cs b/src/managed/Nota.App/MainWindow.Recovery.cs
index 04b83083..103b4d0c 100644
--- a/src/managed/Nota.App/MainWindow.Recovery.cs
+++ b/src/managed/Nota.App/MainWindow.Recovery.cs
@@ -66,8 +66,8 @@ public partial class MainWindow
_closePromptOpen = true;
try
{
- if (!await ConfirmLeaveChangesAsync(Loc.T("Unsaved changes"),
- Loc.T("Do you really want to quit without saving your changes?")))
+ if (!await ConfirmLeaveChangesAsync(Loc.T("main.recovery.unsaved_changes"),
+ Loc.T("main.recovery.do_you_really_want_to")))
{
AppRestart.Cancel(); // a language restart waits on this prompt (spec 068)
return;
@@ -82,10 +82,10 @@ public partial class MainWindow
private string UnsavedAgeText()
{
var age = _dirtySince is { } since ? DateTime.Now - since : TimeSpan.Zero;
- string when = age.TotalMinutes < 1 ? Loc.T("just now")
+ string when = age.TotalMinutes < 1 ? Loc.T("main.recovery.just_now")
: age.TotalHours < 1 ? NotaNum.F($"{(int)age.TotalMinutes}{NotaNum.Thin}min")
: NotaNum.F($"{(int)age.TotalHours}{NotaNum.Thin}h {age.Minutes}{NotaNum.Thin}min");
- return Loc.F("unsaved changes · {0}", when);
+ return Loc.F("main.recovery.unsaved_changes_n", when);
}
private async void OnOpenedRecoveryCheck(object? sender, EventArgs e)
@@ -119,7 +119,7 @@ public partial class MainWindow
{
string when = info.SavedAt;
if (DateTime.TryParse(info.SavedAt, out var dt)) when = dt.ToString("g");
- return Loc.F("Nota didn't shut down cleanly. Recover unsaved work from {0}?", when);
+ return Loc.F("main.recovery.nota_didnt_shut_down_cleanly", when);
}
/// <summary>Load the crash snapshot into the engine and point the next Save at the real
@@ -130,15 +130,15 @@ public partial class MainWindow
_projectPath = info.OriginalPath; // next Save targets the real bundle (null → prompt)
UpdateWindowTitle();
_cleanFingerprint = null; // recovered work is unsaved until the user saves it
- if (_vm is not null) _vm.StatusText = Loc.T("Recovered unsaved work.");
+ if (_vm is not null) _vm.StatusText = Loc.T("main.recovery.recovered_unsaved_work");
try { _recovery.ClearRecovery(); } catch { }
}
// Fallback path when the welcome launcher is disabled: a modal Recover / Discard dialog.
private async Task OfferRecoveryDialogAsync(RecoveryInfo info)
{
- bool restore = await new ConfirmWindow(Loc.T("Recover project"),
- RecoveryPromptText(info), Loc.T("Recover"), Loc.T("Discard")).ShowDialog<bool>(this);
+ bool restore = await new ConfirmWindow(Loc.T("main.recovery.recover_project"),
+ RecoveryPromptText(info), Loc.T("main.recovery.recover"), Loc.T("main.recovery.discard")).ShowDialog<bool>(this);
if (restore) ApplyPendingRecovery(info);
else try { _recovery.ClearRecovery(); } catch { }
}
diff --git a/src/managed/Nota.App/MainWindow.Remote.cs b/src/managed/Nota.App/MainWindow.Remote.cs
index 1ea95714..9448b389 100644
--- a/src/managed/Nota.App/MainWindow.Remote.cs
+++ b/src/managed/Nota.App/MainWindow.Remote.cs
@@ -64,10 +64,10 @@ public partial class MainWindow : IRemoteHost
if (_remote is null || _vm is null) return;
bool on = _vm.Settings.Current.RemoteEnabled && _remote.Running;
int n = _remote.Hub.Devices.Count;
- RemoteCount.Text = on ? n.ToString() : Loc.T("Off", "remote"); // short: the bar sheds this button when it is too wide
+ RemoteCount.Text = on ? n.ToString() : Loc.T("main.off_remote"); // short: the bar sheds this button when it is too wide
RemoteBtn.Classes.Set("lit", on);
- ToolTip.SetTip(RemoteBtn, !_vm.Settings.Current.RemoteEnabled ? Loc.T("Play and control Nota from a phone")
- : _remote.Error ?? (n == 0 ? Loc.T("Remote is on · scan the code with a phone") : Loc.Plural(n, "{0} phone connected", "{0} phones connected")));
+ ToolTip.SetTip(RemoteBtn, !_vm.Settings.Current.RemoteEnabled ? Loc.T("main.play_and_control_nota_from")
+ : _remote.Error ?? (n == 0 ? Loc.T("main.remote.remote_is_on_scan_the") : Loc.Plural("main.remote.phones_connected", n)));
Timeline.Refresh();
}
@@ -172,7 +172,7 @@ public partial class MainWindow : IRemoteHost
_editorRoll?.EndVelocityWheel();
if (!Engine.Undo()) return false;
RefreshAfterUndoRedo();
- if (_vm is not null) _vm.StatusText = Loc.T("Undo (from a phone)");
+ if (_vm is not null) _vm.StatusText = Loc.T("main.remote.undo_from_a_phone");
return true;
}
diff --git a/src/managed/Nota.App/MainWindow.Stems.cs b/src/managed/Nota.App/MainWindow.Stems.cs
index 91d49b1b..6b5b93ca 100644
--- a/src/managed/Nota.App/MainWindow.Stems.cs
+++ b/src/managed/Nota.App/MainWindow.Stems.cs
@@ -20,7 +20,7 @@ public partial class MainWindow
{
if (_vm is null) return;
var ai = App.Services.GetRequiredService<IClipAi>();
- if (!await EnsureModelAsync(AiModels.Stems, Loc.T("Separate Stems"))) return;
+ if (!await EnsureModelAsync(AiModels.Stems, Loc.T("main.stems.separate_stems"))) return;
StemJob job;
try { job = ai.ReadStemSource(trackId, clipIndex); }
@@ -29,27 +29,27 @@ public partial class MainWindow
StemResult? stems = null;
try
{
- bool done = await RunBlockingAsync(Loc.T("Separate Stems"), Loc.T("Preparing audio…"), async (prog, ct) =>
+ bool done = await RunBlockingAsync(Loc.T("main.stems.separate_stems"), Loc.T("main.stems.preparing_audio"), async (prog, ct) =>
{
var p = new Progress<(double Fraction, string Label)>(r => prog.Report(ProgressReport.At(r.Fraction, r.Label)));
stems = await Task.Run(() => ai.Separate(job, p, ct), ct);
});
- if (!done || stems is null) { _vm.StatusText = Loc.T("Separate Stems cancelled."); return; }
+ if (!done || stems is null) { _vm.StatusText = Loc.T("main.stems.separate_stems_cancelled"); return; }
int group = ai.ApplyStems(job, stems);
Timeline.Refresh();
if (group > 0) Timeline.Select(group, -1);
_session?.Refresh();
- _vm.StatusText = Loc.F("Separated \"{0}\" into drums, bass, other and vocals.", job.Name);
+ _vm.StatusText = Loc.F("main.stems.separated_into_drums_bass_other", job.Name);
}
catch (Exception ex) when (ex is InvalidOperationException or StoreException)
{
- _vm.StatusText = Loc.F("Separate Stems failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.stems.separate_stems_failed", ex.Message);
}
catch (Exception ex)
{
App.Services.GetRequiredService<ILogSink>().Error("Separate Stems failed", ex);
- _vm.StatusText = Loc.F("Separate Stems failed: {0}", ex.Message);
+ _vm.StatusText = Loc.F("main.stems.separate_stems_failed", ex.Message);
}
finally
{
@@ -66,33 +66,33 @@ public partial class MainWindow
if (_vm is null) return false;
if (store.Runtime is null)
{
- _vm.StatusText = Loc.F("{0} isn't available on this computer.", feature);
+ _vm.StatusText = Loc.F("main.stems.isnt_available_on_this_computer", feature);
return false;
}
if (DownloadJobs.Shared.BusyId == "model:" + id)
{
- _vm.StatusText = Loc.F("{0} is waiting for its model — it's downloading (see the status bar).", feature);
+ _vm.StatusText = Loc.F("main.stems.is_waiting_for_its_model", feature);
return false;
}
var model = store.Models.First(m => m.Id == id);
bool withRuntime = store.RuntimePath is null;
- string what = withRuntime ? Loc.F("the {0} model and the AI runtime it runs on", model.Name) : Loc.F("the {0} model", model.Name);
+ string what = withRuntime ? Loc.F("main.stems.the_model_and_the_ai", model.Name) : Loc.F("main.stems.the_model", model.Name);
bool ok = await new ConfirmWindow(feature,
- Loc.F("{0} uses an AI model that runs on this computer. Download {1} ({2}) once? ", feature, what, Size(store.DownloadSize(id))) +
- Loc.T("You can remove it later in Settings → Downloads → AI Models."),
- Loc.T("Download"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ Loc.F("main.stems.uses_an_ai_model_that", feature, what, Size(store.DownloadSize(id))) +
+ Loc.T("main.stems.you_can_remove_it_later"),
+ Loc.T("common.download"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return false;
try
{
- bool done = await RunBlockingAsync(feature, Loc.T("Downloading…"), async (prog, ct) =>
+ bool done = await RunBlockingAsync(feature, Loc.T("main.stems.downloading"), async (prog, ct) =>
{
var p = new Progress<StoreProgress>(r => prog.Report(r.Fraction < 0 ? ProgressReport.Indeterminate(r.Message) : ProgressReport.At(r.Fraction, r.Message)));
await store.InstallAsync(id, p, ct);
});
- if (!done) _vm.StatusText = Loc.T("Download cancelled.");
+ if (!done) _vm.StatusText = Loc.T("main.stems.download_cancelled");
return done && store.IsInstalled(id);
}
catch (StoreException ex)
diff --git a/src/managed/Nota.App/MainWindow.TransportFit.cs b/src/managed/Nota.App/MainWindow.TransportFit.cs
index c78fc7fc..e1dad6d1 100644
--- a/src/managed/Nota.App/MainWindow.TransportFit.cs
+++ b/src/managed/Nota.App/MainWindow.TransportFit.cs
@@ -59,7 +59,7 @@ public partial class MainWindow
{
string shown = CpuText.Text ?? "";
CpuText.MinWidth = 0;
- CpuText.Text = Loc.F("DSP {0}%", 100);
+ CpuText.Text = Loc.F("main.dsp_caps", 100);
CpuText.Measure(Avalonia.Size.Infinity);
double widest = CpuText.DesiredSize.Width;
CpuText.Text = shown;
@@ -94,7 +94,7 @@ public partial class MainWindow
}
// The name leaves the bar for the caption, so the open project stays on screen.
- DocTitleText.Text = ProjectNameText.IsVisible ? Loc.T("Nota") : ProjectDisplayName();
+ DocTitleText.Text = ProjectNameText.IsVisible ? Loc.T("common.nota") : ProjectDisplayName();
TransportGrid.InvalidateMeasure();
}
diff --git a/src/managed/Nota.App/MainWindow.Updates.cs b/src/managed/Nota.App/MainWindow.Updates.cs
index 0d9c1cbe..a3fba25a 100644
--- a/src/managed/Nota.App/MainWindow.Updates.cs
+++ b/src/managed/Nota.App/MainWindow.Updates.cs
@@ -94,17 +94,17 @@ public partial class MainWindow
var p = u.Progress;
_upText.Text = u.State switch
{
- AppUpdates.Stage.Downloading => Loc.F("Downloading Nota {0}…", version),
- AppUpdates.Stage.Ready => Loc.F("Restart to update to Nota {0}", version),
- AppUpdates.Stage.Failed => Loc.T("The update didn't download"),
- _ => Loc.F("Nota {0} is available", version),
+ AppUpdates.Stage.Downloading => Loc.F("common.downloading_nota", version),
+ AppUpdates.Stage.Ready => Loc.F("main.updates.restart_to_update_to_nota", version),
+ AppUpdates.Stage.Failed => Loc.T("main.updates.the_update_didnt_download"),
+ _ => Loc.F("main.updates.nota_is_available", version),
};
ToolTip.SetTip(_upOpen, u.State switch
{
AppUpdates.Stage.Downloading => null,
- AppUpdates.Stage.Ready => Loc.F("Nota {0} is downloaded. Click to restart now — or it installs the next time you quit.", version),
+ AppUpdates.Stage.Ready => Loc.F("main.updates.nota_is_downloaded_click_to", version),
AppUpdates.Stage.Failed => u.Error,
- _ => Loc.F("You have {0}. Click to update or read the release notes.", AppInfo.Version),
+ _ => Loc.F("main.updates.you_have_click_to_update", AppInfo.Version),
});
_upDot.IsVisible = !busy;
_upBar.IsVisible = busy;
@@ -112,8 +112,8 @@ public partial class MainWindow
if (busy && p.Fraction >= 0) _upBar.Value = p.Fraction;
_upDetail.Text = busy && p.Fraction >= 0 ? NotaNum.Unit(p.Fraction * 100, "0", "%") : "";
_upDetail.IsVisible = _upDetail.Text.Length > 0;
- ToolTip.SetTip(_upClose, busy ? Loc.T("Cancel the download")
- : u.State == AppUpdates.Stage.Ready ? Loc.T("Hide — it still installs when you quit") : Loc.T("Not now"));
+ ToolTip.SetTip(_upClose, busy ? Loc.T("main.cancel_the_download")
+ : u.State == AppUpdates.Stage.Ready ? Loc.T("main.updates.hide_it_still_installs_when") : Loc.T("main.not_now"));
}
// Available / failed: what to do about it.
@@ -123,12 +123,12 @@ public partial class MainWindow
var version = u.Release?.Version ?? "";
var menu = new ContextMenu();
menu.Items.Add(MenuKit.Item(
- u.State == AppUpdates.Stage.Failed ? Loc.T("Try again")
- : u.CanInstall ? Loc.F("Update to Nota {0}", version) : Loc.F("Download Nota {0}…", version),
+ u.State == AppUpdates.Stage.Failed ? Loc.T("common.try_again")
+ : u.CanInstall ? Loc.F("main.updates.update_to_nota", version) : Loc.F("main.updates.download_nota", version),
GlyphKind.Update, () => u.Download(this)));
- menu.Items.Add(MenuKit.Item(Loc.T("Release notes"), GlyphKind.Doc, () => u.OpenReleasePage(this)));
+ menu.Items.Add(MenuKit.Item(Loc.T("main.updates.release_notes"), GlyphKind.Doc, () => u.OpenReleasePage(this)));
menu.Items.Add(new Separator());
- menu.Items.Add(MenuKit.Item(Loc.T("Not now"), click: u.Dismiss));
+ menu.Items.Add(MenuKit.Item(Loc.T("main.not_now"), click: u.Dismiss));
return menu;
}
@@ -137,21 +137,21 @@ public partial class MainWindow
public async Task CheckForUpdatesAsync()
{
var u = AppUpdates.Shared;
- var checking = Loc.T("Checking for updates…");
+ var checking = Loc.T("main.updates.checking_for_updates");
if (_vm is not null) _vm.StatusText = checking;
bool? found = await u.CheckAsync();
if (_vm is not null && _vm.StatusText == checking) _vm.StatusText = "";
- var title = Loc.T("Check for updates");
+ var title = Loc.T("main.updates.check_for_updates");
if (found is null)
{
- await new ConfirmWindow(title, Loc.T("Couldn't reach GitHub to check for a newer version of Nota. Check your internet connection and try again."),
+ await new ConfirmWindow(title, Loc.T("main.updates.couldnt_reach_github_to_check"),
"OK", null).ShowDialog<bool>(this);
return;
}
if (found == false || u.Release is not { } release)
{
- await new ConfirmWindow(title, Loc.F("You're up to date: Nota {0} is the latest version.", AppInfo.Version), "OK", null).ShowDialog<bool>(this);
+ await new ConfirmWindow(title, Loc.F("main.updates.youre_up_to_date_nota", AppInfo.Version), "OK", null).ShowDialog<bool>(this);
return;
}
@@ -161,14 +161,14 @@ public partial class MainWindow
case AppUpdates.Stage.Downloading:
return; // its progress is in the status bar already
case AppUpdates.Stage.Ready:
- if (await new ConfirmWindow(title, Loc.F("Nota {0} is ready to install. Restart Nota to finish updating — or it installs the next time you quit.", release.Version),
- Loc.T("Restart now"), Loc.T("Later")).ShowDialog<bool>(this))
+ if (await new ConfirmWindow(title, Loc.F("main.updates.nota_is_ready_to_install", release.Version),
+ Loc.T("main.updates.restart_now"), Loc.T("main.updates.later")).ShowDialog<bool>(this))
u.Restart(Close);
return;
default:
- var message = Loc.F("Nota {0} is out — you have {1}.", release.Version, AppInfo.Version)
- + (u.CanInstall ? Loc.T(" Nota downloads it here and installs it when you restart or quit.") : Loc.T(" Download it from the release page."));
- if (await new ConfirmWindow(Loc.T("Update available"), message, u.CanInstall ? Loc.T("Update") : Loc.T("Download"), Loc.T("Later")).ShowDialog<bool>(this))
+ var message = Loc.F("main.updates.nota_is_out_you_have", release.Version, AppInfo.Version)
+ + (u.CanInstall ? Loc.T("main.updates.nota_downloads_it_here_and") : Loc.T("main.updates.download_it_from_the_release"));
+ if (await new ConfirmWindow(Loc.T("main.updates.update_available"), message, u.CanInstall ? Loc.T("common.update") : Loc.T("common.download"), Loc.T("main.updates.later")).ShowDialog<bool>(this))
u.Download(this);
return;
}
diff --git a/src/managed/Nota.App/MainWindow.axaml b/src/managed/Nota.App/MainWindow.axaml
index 05fe3f25..762d0256 100644
--- a/src/managed/Nota.App/MainWindow.axaml
+++ b/src/managed/Nota.App/MainWindow.axaml
@@ -18,107 +18,107 @@
</Window.Resources>
<NativeMenu.Menu>
<NativeMenu>
- <NativeMenuItem Header="{app:T 'File'}">
+ <NativeMenuItem Header="{app:T 'common.file'}">
<NativeMenuItem.Menu>
<NativeMenu>
- <NativeMenuItem Header="{app:T 'New'}" app:Commands.Id="file.new"/>
- <NativeMenuItem Header="{app:T 'Open…'}" app:Commands.Id="file.open"/>
- <NativeMenuItem Header="{app:T 'Save'}" app:Commands.Id="file.save"/>
- <NativeMenuItem Header="{app:T 'Save as…'}" app:Commands.Id="file.saveAs"/>
- <NativeMenuItem Header="{app:T 'Save version with note…'}" app:Commands.Id="file.saveVersion"/>
+ <NativeMenuItem Header="{app:T 'main.new'}" app:Commands.Id="file.new"/>
+ <NativeMenuItem Header="{app:T 'main.open'}" app:Commands.Id="file.open"/>
+ <NativeMenuItem Header="{app:T 'main.save'}" app:Commands.Id="file.save"/>
+ <NativeMenuItem Header="{app:T 'main.save_as'}" app:Commands.Id="file.saveAs"/>
+ <NativeMenuItem Header="{app:T 'main.save_version_with_note'}" app:Commands.Id="file.saveVersion"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Import audio…'}" app:Commands.Id="file.import"/>
- <NativeMenuItem Header="{app:T 'Export audio…'}" app:Commands.Id="file.export"/>
+ <NativeMenuItem Header="{app:T 'main.import_audio'}" app:Commands.Id="file.import"/>
+ <NativeMenuItem Header="{app:T 'main.export_audio'}" app:Commands.Id="file.export"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Settings…'}" app:Commands.Id="prefs.open"/>
+ <NativeMenuItem Header="{app:T 'main.settings'}" app:Commands.Id="prefs.open"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Exit'}" app:Commands.Id="file.exit"/>
+ <NativeMenuItem Header="{app:T 'main.exit'}" app:Commands.Id="file.exit"/>
</NativeMenu>
</NativeMenuItem.Menu>
</NativeMenuItem>
- <NativeMenuItem Header="{app:T 'Edit'}">
+ <NativeMenuItem Header="{app:T 'common.edit'}">
<NativeMenuItem.Menu>
<NativeMenu>
- <NativeMenuItem Header="{app:T 'Undo'}" app:Commands.Id="edit.undo"/>
- <NativeMenuItem Header="{app:T 'Redo'}" app:Commands.Id="edit.redo"/>
+ <NativeMenuItem Header="{app:T 'common.undo'}" app:Commands.Id="edit.undo"/>
+ <NativeMenuItem Header="{app:T 'main.redo'}" app:Commands.Id="edit.redo"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Duplicate clip'}" app:Commands.Id="edit.duplicate"/>
- <NativeMenuItem Header="{app:T 'Insert scene'}" app:Commands.Id="session.insertScene"/>
- <NativeMenuItem Header="{app:T 'Split at playhead'}" app:Commands.Id="edit.split"/>
- <NativeMenuItem Header="{app:T 'Consolidate'}" app:Commands.Id="edit.consolidate"/>
- <NativeMenuItem Header="{app:T 'Duplicate time'}" app:Commands.Id="edit.duplicateTime"/>
- <NativeMenuItem Header="{app:T 'Insert silence'}" app:Commands.Id="edit.insertSilence"/>
+ <NativeMenuItem Header="{app:T 'main.duplicate_clip'}" app:Commands.Id="edit.duplicate"/>
+ <NativeMenuItem Header="{app:T 'main.insert_scene'}" app:Commands.Id="session.insertScene"/>
+ <NativeMenuItem Header="{app:T 'main.split_at_playhead'}" app:Commands.Id="edit.split"/>
+ <NativeMenuItem Header="{app:T 'common.consolidate'}" app:Commands.Id="edit.consolidate"/>
+ <NativeMenuItem Header="{app:T 'common.duplicate_time'}" app:Commands.Id="edit.duplicateTime"/>
+ <NativeMenuItem Header="{app:T 'common.insert_silence'}" app:Commands.Id="edit.insertSilence"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Lock envelopes'}" app:Commands.Id="edit.lockEnvelopes" ToggleType="CheckBox"/>
+ <NativeMenuItem Header="{app:T 'main.lock_envelopes'}" app:Commands.Id="edit.lockEnvelopes" ToggleType="CheckBox"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Cut'}" app:Commands.Id="edit.cut"/>
- <NativeMenuItem Header="{app:T 'Copy'}" app:Commands.Id="edit.copy"/>
- <NativeMenuItem Header="{app:T 'Paste'}" app:Commands.Id="edit.paste"/>
- <NativeMenuItem Header="{app:T 'Paste bounced audio'}" app:Commands.Id="edit.pasteBounced"/>
- <NativeMenuItem Header="{app:T 'Copy clips to Session / Arrangement'}" app:Commands.Id="edit.copyToOtherView"/>
- <NativeMenuItem Header="{app:T 'Delete'}" app:Commands.Id="edit.delete"/>
+ <NativeMenuItem Header="{app:T 'common.cut'}" app:Commands.Id="edit.cut"/>
+ <NativeMenuItem Header="{app:T 'common.copy'}" app:Commands.Id="edit.copy"/>
+ <NativeMenuItem Header="{app:T 'common.paste'}" app:Commands.Id="edit.paste"/>
+ <NativeMenuItem Header="{app:T 'common.paste_bounced_audio'}" app:Commands.Id="edit.pasteBounced"/>
+ <NativeMenuItem Header="{app:T 'main.copy_clips_to_session_arrangement'}" app:Commands.Id="edit.copyToOtherView"/>
+ <NativeMenuItem Header="{app:T 'common.delete'}" app:Commands.Id="edit.delete"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Grid'}">
+ <NativeMenuItem Header="{app:T 'common.grid'}">
<NativeMenuItem.Menu>
<NativeMenu>
- <NativeMenuItem Header="{app:T 'Narrow grid'}" app:Commands.Id="grid.narrower"/>
- <NativeMenuItem Header="{app:T 'Widen grid'}" app:Commands.Id="grid.wider"/>
- <NativeMenuItem Header="{app:T 'Triplet grid'}" app:Commands.Id="grid.triplets"/>
- <NativeMenuItem Header="{app:T 'Snap to grid'}" app:Commands.Id="grid.snap"/>
- <NativeMenuItem Header="{app:T 'Adaptive grid'}" app:Commands.Id="grid.adaptive"/>
+ <NativeMenuItem Header="{app:T 'main.narrow_grid'}" app:Commands.Id="grid.narrower"/>
+ <NativeMenuItem Header="{app:T 'main.widen_grid'}" app:Commands.Id="grid.wider"/>
+ <NativeMenuItem Header="{app:T 'main.triplet_grid'}" app:Commands.Id="grid.triplets"/>
+ <NativeMenuItem Header="{app:T 'main.snap_to_grid'}" app:Commands.Id="grid.snap"/>
+ <NativeMenuItem Header="{app:T 'main.adaptive_grid'}" app:Commands.Id="grid.adaptive"/>
</NativeMenu>
</NativeMenuItem.Menu>
</NativeMenuItem>
</NativeMenu>
</NativeMenuItem.Menu>
</NativeMenuItem>
- <NativeMenuItem Header="{app:T 'View'}">
+ <NativeMenuItem Header="{app:T 'main.view'}">
<NativeMenuItem.Menu>
<NativeMenu>
- <NativeMenuItem Header="{app:T 'Command palette…'}" app:Commands.Id="view.palette"/>
+ <NativeMenuItem Header="{app:T 'main.command_palette'}" app:Commands.Id="view.palette"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Mixer'}" app:Commands.Id="view.mixer"/>
- <NativeMenuItem Header="{app:T 'Mixer in its own window'}" app:Commands.Id="view.mixerFloat" ToggleType="CheckBox"/>
- <NativeMenuItem Header="{app:T 'Connect phone…'}" app:Commands.Id="view.connectPhone"/>
+ <NativeMenuItem Header="{app:T 'common.mixer'}" app:Commands.Id="view.mixer"/>
+ <NativeMenuItem Header="{app:T 'main.mixer_in_its_own_window'}" app:Commands.Id="view.mixerFloat" ToggleType="CheckBox"/>
+ <NativeMenuItem Header="{app:T 'main.connect_phone'}" app:Commands.Id="view.connectPhone"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Toggle browser'}" app:Commands.Id="view.toggleBrowser"/>
- <NativeMenuItem Header="{app:T 'Toggle detail panel'}" app:Commands.Id="view.toggleDetail"/>
- <NativeMenuItem Header="{app:T 'Clip editor fills the window'}" app:Commands.Id="view.maximizeDetail" ToggleType="CheckBox"/>
- <NativeMenuItem Header="{app:T 'Toggle overview'}" app:Commands.Id="view.toggleOverview"/>
- <NativeMenuItem Header="{app:T 'Toggle sections'}" app:Commands.Id="view.toggleSections"/>
- <NativeMenuItem Header="{app:T 'Toggle full screen'}" app:Commands.Id="view.fullscreen"/>
+ <NativeMenuItem Header="{app:T 'main.toggle_browser'}" app:Commands.Id="view.toggleBrowser"/>
+ <NativeMenuItem Header="{app:T 'main.toggle_detail_panel'}" app:Commands.Id="view.toggleDetail"/>
+ <NativeMenuItem Header="{app:T 'main.clip_editor_fills_the_window'}" app:Commands.Id="view.maximizeDetail" ToggleType="CheckBox"/>
+ <NativeMenuItem Header="{app:T 'main.toggle_overview'}" app:Commands.Id="view.toggleOverview"/>
+ <NativeMenuItem Header="{app:T 'main.toggle_sections'}" app:Commands.Id="view.toggleSections"/>
+ <NativeMenuItem Header="{app:T 'main.toggle_full_screen'}" app:Commands.Id="view.fullscreen"/>
<NativeMenuItemSeparator/>
<!-- Header text is matched from code to keep this checkmark in step with the
transport bar's Follow button — see MainWindow.SetFollowPlayhead. -->
- <NativeMenuItem Header="{app:T 'Follow playhead'}" app:Commands.Id="view.follow" ToggleType="CheckBox"/>
- <NativeMenuItem Header="{app:T 'Show playhead'}" app:Commands.Id="view.showPlayhead"/>
+ <NativeMenuItem Header="{app:T 'main.follow_playhead'}" app:Commands.Id="view.follow" ToggleType="CheckBox"/>
+ <NativeMenuItem Header="{app:T 'main.show_playhead'}" app:Commands.Id="view.showPlayhead"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'Clip names'}" app:Commands.Id="view.clipNames"/>
- <NativeMenuItem Header="{app:T 'Track headers on the right'}" app:Commands.Id="view.headersRight" ToggleType="CheckBox"/>
+ <NativeMenuItem Header="{app:T 'main.clip_names'}" app:Commands.Id="view.clipNames"/>
+ <NativeMenuItem Header="{app:T 'main.track_headers_on_the_right'}" app:Commands.Id="view.headersRight" ToggleType="CheckBox"/>
</NativeMenu>
</NativeMenuItem.Menu>
</NativeMenuItem>
- <NativeMenuItem Header="{app:T 'Transport'}">
+ <NativeMenuItem Header="{app:T 'common.transport'}">
<NativeMenuItem.Menu>
<NativeMenu>
- <NativeMenuItem Header="{app:T 'Play / stop'}" app:Commands.Id="transport.playStop"/>
- <NativeMenuItem Header="{app:T 'Play / pause'}" app:Commands.Id="transport.playPause"/>
- <NativeMenuItem Header="{app:T 'Record'}" app:Commands.Id="transport.record"/>
- <NativeMenuItem Header="{app:T 'Auto-arm selected track'}" app:Commands.Id="transport.armOnSelect" ToggleType="CheckBox"/>
- <NativeMenuItem Header="{app:T 'Loop'}" app:Commands.Id="transport.loop"/>
- <NativeMenuItem Header="{app:T 'Loop record: overdub / replace'}" app:Commands.Id="transport.loopRecordMode"/>
- <NativeMenuItem Header="{app:T 'Metronome'}" app:Commands.Id="transport.metronome"/>
+ <NativeMenuItem Header="{app:T 'common.play_stop'}" app:Commands.Id="transport.playStop"/>
+ <NativeMenuItem Header="{app:T 'main.play_pause'}" app:Commands.Id="transport.playPause"/>
+ <NativeMenuItem Header="{app:T 'common.record'}" app:Commands.Id="transport.record"/>
+ <NativeMenuItem Header="{app:T 'main.auto_arm_selected_track'}" app:Commands.Id="transport.armOnSelect" ToggleType="CheckBox"/>
+ <NativeMenuItem Header="{app:T 'common.loop'}" app:Commands.Id="transport.loop"/>
+ <NativeMenuItem Header="{app:T 'main.loop_record_overdub_replace'}" app:Commands.Id="transport.loopRecordMode"/>
+ <NativeMenuItem Header="{app:T 'common.metronome'}" app:Commands.Id="transport.metronome"/>
</NativeMenu>
</NativeMenuItem.Menu>
</NativeMenuItem>
- <NativeMenuItem Header="{app:T 'Help'}">
+ <NativeMenuItem Header="{app:T 'main.help'}">
<NativeMenuItem.Menu>
<NativeMenu>
- <NativeMenuItem Header="{app:T 'Documentation'}" app:Commands.Id="help.docs"/>
- <NativeMenuItem Header="{app:T 'What\'s new'}" app:Commands.Id="help.whatsNew"/>
- <NativeMenuItem Header="{app:T 'Check for updates…'}" app:Commands.Id="help.checkUpdates"/>
+ <NativeMenuItem Header="{app:T 'common.documentation'}" app:Commands.Id="help.docs"/>
+ <NativeMenuItem Header="{app:T 'common.whats_new'}" app:Commands.Id="help.whatsNew"/>
+ <NativeMenuItem Header="{app:T 'common.check_for_updates'}" app:Commands.Id="help.checkUpdates"/>
<NativeMenuItemSeparator/>
- <NativeMenuItem Header="{app:T 'About Nota'}" app:Commands.Id="help.about"/>
+ <NativeMenuItem Header="{app:T 'common.about_nota'}" app:Commands.Id="help.about"/>
</NativeMenu>
</NativeMenuItem.Menu>
</NativeMenuItem>
@@ -169,15 +169,15 @@
<!-- The views as icon keys (spec 012): the tooltip and the accessible name carry
the view name. View → Arrangement / Session / Modular do the same. -->
<ToggleButton x:Name="ArrangeBtn" Classes="seg view" IsChecked="True" Click="OnShowArrangement"
- ToolTip.Tip="{app:T 'Arrangement'}" AutomationProperties.Name="{app:T 'Arrangement'}">
+ ToolTip.Tip="{app:T 'main.arrangement'}" AutomationProperties.Name="{app:T 'main.arrangement'}">
<app:Glyph Kind="Arrangement" Size="16"/>
</ToggleButton>
<ToggleButton x:Name="SessionBtn" Classes="seg view" Click="OnShowSession"
- ToolTip.Tip="{app:T 'Session'}" AutomationProperties.Name="{app:T 'Session'}">
+ ToolTip.Tip="{app:T 'main.session'}" AutomationProperties.Name="{app:T 'main.session'}">
<app:Glyph Kind="Session" Size="16"/>
</ToggleButton>
<ToggleButton x:Name="ModularBtn" Classes="seg view" Click="OnShowModular"
- ToolTip.Tip="{app:T 'Modular'}" AutomationProperties.Name="{app:T 'Modular'}">
+ ToolTip.Tip="{app:T 'common.modular'}" AutomationProperties.Name="{app:T 'common.modular'}">
<app:Glyph Kind="Modular" Size="16"/>
</ToggleButton>
</StackPanel>
@@ -190,15 +190,15 @@
<StackPanel Orientation="Horizontal" Spacing="1" VerticalAlignment="Center">
<!-- Shapes built from geometry: stop a square, play a filled triangle, record a
filled disc. No glyph font. Keys butt against each other on 1px seams. -->
- <Button x:Name="StopBtn" Classes="tp-icon" ToolTip.Tip="{app:T 'Stop (Return)'}"
+ <Button x:Name="StopBtn" Classes="tp-icon" ToolTip.Tip="{app:T 'main.stop_return'}"
Foreground="{DynamicResource Brush.TextStrong}" Command="{Binding Transport.StopCommand}">
<app:Glyph x:Name="StopGlyph" Kind="Stop" Width="9" Height="9"/>
</Button>
- <Button x:Name="PlayBtn" Classes="tp-play" ToolTip.Tip="{app:T 'Play (Space)'}"
+ <Button x:Name="PlayBtn" Classes="tp-play" ToolTip.Tip="{app:T 'main.play_space'}"
Classes.playing="{Binding Transport.IsPlaying}" Command="{Binding Transport.PlayCommand}">
<app:Glyph x:Name="PlayGlyph" Kind="Play" Width="10" Height="12" Margin="2,0,0,0"/>
</Button>
- <ToggleButton x:Name="RecordBtn" Classes="tp-icon rec" ToolTip.Tip="{app:T 'Record (⌘R)'}"
+ <ToggleButton x:Name="RecordBtn" Classes="tp-icon rec" ToolTip.Tip="{app:T 'main.record_r'}"
IsChecked="{Binding Transport.RecordOn}">
<app:Glyph x:Name="RecordGlyph" Kind="Record" Width="10" Height="10"/>
</ToggleButton>
@@ -209,7 +209,7 @@
<!-- Position — click to flip bars.beats ↔ minutes:seconds; the unit beside says which -->
<StackPanel Orientation="Horizontal" Spacing="6" VerticalAlignment="Center" Cursor="Hand" Background="Transparent"
PointerPressed="OnTogglePositionDisplay"
- ToolTip.Tip="{app:T 'Switch between bars and time'}">
+ ToolTip.Tip="{app:T 'main.switch_between_bars_and_time'}">
<TextBlock Classes="Readout" Text="{Binding Transport.PositionText}" FontSize="14"
MinWidth="72" VerticalAlignment="Center" Foreground="{DynamicResource Brush.TextPrimary}"/>
<TextBlock Classes="CellLabel" Text="{Binding Transport.PositionUnitText}" VerticalAlignment="Center"/>
@@ -218,9 +218,9 @@
<Border x:Name="LoopSep" Width="1" Height="18" Background="{DynamicResource Brush.Rule}"/>
<!-- Loop: the range is the key -->
- <ToggleButton x:Name="LoopCell" Classes="cell" Height="22" IsChecked="{Binding Transport.LoopOn}" ToolTip.Tip="{app:T 'Loop the range set on the ruler'}">
+ <ToggleButton x:Name="LoopCell" Classes="cell" Height="22" IsChecked="{Binding Transport.LoopOn}" ToolTip.Tip="{app:T 'main.loop_the_range_set_on'}">
<StackPanel Orientation="Horizontal" Spacing="6">
- <TextBlock Classes="CellLabel" Text="{app:T 'Loop'}" VerticalAlignment="Center" Foreground="{Binding $parent[ToggleButton].Foreground}"/>
+ <TextBlock Classes="CellLabel" Text="{app:T 'common.loop'}" VerticalAlignment="Center" Foreground="{Binding $parent[ToggleButton].Foreground}"/>
<TextBlock Classes="Mono" FontSize="11" MinWidth="58" VerticalAlignment="Center"
Text="{Binding Transport.LoopRangeText}"
Foreground="{Binding $parent[ToggleButton].Foreground}"/>
@@ -228,13 +228,13 @@
</ToggleButton>
<!-- Loop record mode: Overdub (rests neutral) or Replace (lit, the non-default choice) -->
<ToggleButton x:Name="LoopRecordCell" Classes="cell" Height="22" IsChecked="{Binding Transport.LoopRecordReplace}"
- ToolTip.Tip="{app:T 'Loop recording: Overdub adds every pass · Replace keeps the latest pass (⌘⇧R)'}">
+ ToolTip.Tip="{app:T 'main.loop_recording_overdub_adds_every'}">
<Panel>
<!-- Sizer: the cell keeps the longer label's width in both states, so the bar doesn't shift -->
- <TextBlock Classes="CellLabel" Text="{app:T 'Overdub'}" Opacity="0" VerticalAlignment="Center"/>
- <TextBlock Classes="CellLabel" Text="{app:T 'Overdub'}" VerticalAlignment="Center" HorizontalAlignment="Center"
+ <TextBlock Classes="CellLabel" Text="{app:T 'main.overdub'}" Opacity="0" VerticalAlignment="Center"/>
+ <TextBlock Classes="CellLabel" Text="{app:T 'main.overdub'}" VerticalAlignment="Center" HorizontalAlignment="Center"
IsVisible="{Binding !Transport.LoopRecordReplace}" Foreground="{Binding $parent[ToggleButton].Foreground}"/>
- <TextBlock Classes="CellLabel" Text="{app:T 'Replace'}" VerticalAlignment="Center" HorizontalAlignment="Center"
+ <TextBlock Classes="CellLabel" Text="{app:T 'main.replace'}" VerticalAlignment="Center" HorizontalAlignment="Center"
IsVisible="{Binding Transport.LoopRecordReplace}" Foreground="{Binding $parent[ToggleButton].Foreground}"/>
</Panel>
</ToggleButton>
@@ -244,7 +244,7 @@
<!-- Readouts: one 26px well each, a mono value and its muted unit on one line -->
<StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="6" VerticalAlignment="Center" Margin="10,0,0,0">
<!-- Tempo (drag ↕ or double-click to type) -->
- <Border Classes="well" ToolTip.Tip="{app:T 'Set the tempo — drag, or double-click to type'}">
+ <Border Classes="well" ToolTip.Tip="{app:T 'main.set_the_tempo_drag_or'}">
<StackPanel Orientation="Horizontal" Spacing="4" VerticalAlignment="Center">
<Panel x:Name="BpmHost" Width="52" Height="18" VerticalAlignment="Center"/>
<TextBlock Classes="CellLabel" Text="BPM" VerticalAlignment="Center"/>
@@ -253,7 +253,7 @@
<!-- Tap tempo: fires on press (a release lags the beat). The dots count the beats
of the current series, brass as each one lands; they clear when it times out. -->
<Button x:Name="TapChip" Classes="cell" ClickMode="Press" Click="OnTapTempo"
- ToolTip.Tip="{app:T 'Tap the beat to set the tempo'}">
+ ToolTip.Tip="{app:T 'main.tap_the_beat_to_set'}">
<StackPanel Orientation="Horizontal" Spacing="6">
<StackPanel x:Name="TapDots" Orientation="Horizontal" Spacing="3"
HorizontalAlignment="Center" VerticalAlignment="Center">
@@ -262,11 +262,11 @@
<Ellipse Width="4" Height="4" Fill="{DynamicResource Brush.BorderStrong}"/>
<Ellipse Width="4" Height="4" Fill="{DynamicResource Brush.BorderStrong}"/>
</StackPanel>
- <TextBlock Classes="CellLabel" Text="{app:T 'Tap'}" VerticalAlignment="Center"/>
+ <TextBlock Classes="CellLabel" Text="{app:T 'main.tap'}" VerticalAlignment="Center"/>
</StackPanel>
</Button>
<!-- Time signature (drag ↕ each field) -->
- <Border x:Name="TimeSigCell" Classes="well" ToolTip.Tip="{app:T 'Set the time signature — drag each field'}">
+ <Border x:Name="TimeSigCell" Classes="well" ToolTip.Tip="{app:T 'main.set_the_time_signature_drag'}">
<StackPanel Orientation="Horizontal" Spacing="1" Height="18" VerticalAlignment="Center">
<Panel x:Name="TimeSigNumHost" Width="16"/>
<TextBlock Classes="Mono" Text="/" FontSize="13" VerticalAlignment="Center"
@@ -275,11 +275,11 @@
</StackPanel>
</Border>
<!-- Project key: loops dropped in can be transposed to it -->
- <Button x:Name="KeyChip" Classes="cell" Click="OnPickProjectKey" ToolTip.Tip="{app:T 'Set the project key — samples can be transposed to it'}">
+ <Button x:Name="KeyChip" Classes="cell" Click="OnPickProjectKey" ToolTip.Tip="{app:T 'main.set_the_project_key_samples'}">
<StackPanel Orientation="Horizontal" Spacing="6">
<TextBlock x:Name="KeyLabel" Classes="Mono" Text="—" FontSize="13"
MinWidth="30" TextAlignment="Center" VerticalAlignment="Center" Foreground="{DynamicResource Brush.TextMuted}"/>
- <TextBlock Classes="CellLabel" Text="{app:T 'Key'}" VerticalAlignment="Center"/>
+ <TextBlock Classes="CellLabel" Text="{app:T 'main.key'}" VerticalAlignment="Center"/>
</StackPanel>
</Button>
<!-- Clip snap grid (SnapChip.cs): the step in effect, live with the zoom in Auto;
@@ -288,7 +288,7 @@
<StackPanel Orientation="Horizontal" Spacing="6">
<TextBlock x:Name="SnapLabel" Classes="Mono" Text="1/4" FontSize="13"
MinWidth="36" TextAlignment="Center" VerticalAlignment="Center" Foreground="{DynamicResource Brush.TextPrimary}"/>
- <TextBlock x:Name="SnapCaption" Classes="CellLabel" Text="{app:T 'Grid'}" VerticalAlignment="Center"/>
+ <TextBlock x:Name="SnapCaption" Classes="CellLabel" Text="{app:T 'common.grid'}" VerticalAlignment="Center"/>
</StackPanel>
</Button>
</StackPanel>
@@ -301,7 +301,7 @@
<!-- Metronome: body, pendulum rod, weight -->
<ToggleButton x:Name="MetronomeBtn" Classes="tp-icon" IsChecked="{Binding Transport.MetronomeOn}"
ContextRequested="OnMetronomeContext"
- ToolTip.Tip="{app:T 'Turn the metronome on or off (⌘M) · right-click for count-in'}">
+ ToolTip.Tip="{app:T 'main.turn_the_metronome_on_or'}">
<app:Glyph Kind="Metronome" Size="15"/>
</ToggleButton>
<!-- Follow playhead: keep the arrangement scrolling with the cursor. The
@@ -310,14 +310,14 @@
brackets around it were tried too and collapse into noise at this size. Mirrored by View ▸ Follow playhead,
which shares one code path. -->
<ToggleButton x:Name="FollowBtn" Classes="tp-icon" Click="OnToggleFollow"
- ToolTip.Tip="{app:T 'Scroll the arrangement to keep the playhead in view'}">
+ ToolTip.Tip="{app:T 'main.scroll_the_arrangement_to_keep'}">
<app:Glyph Kind="Follow" Size="15"/>
</ToggleButton>
<!-- Snapping on/off, independent of which grid the GRID cell shows. Off is the
same as holding Alt, but latched. A horseshoe magnet: the poles are banded
off the body by a transparent gap, so the shape reads on any button state. -->
<ToggleButton x:Name="SnapToggle" Classes="tp-icon" IsChecked="True" Click="OnToggleSnapEnabled"
- ToolTip.Tip="{app:T 'Snap clips to the grid (hold Alt to drag freely)'}">
+ ToolTip.Tip="{app:T 'main.snap_clips_to_the_grid'}">
<app:Glyph Kind="Snap" Size="15"/>
</ToggleButton>
<!-- Automation: a breakpoint envelope — the ramp and handles the lanes draw -->
@@ -326,9 +326,9 @@
</ToggleButton>
<!-- Shown only while a hand-moved control has taken a lane over from
playback (M9-C); one click hands every overridden lane back. -->
- <Button x:Name="ReenableAutoBtn" Classes="chip" Content="{app:T 'Re-enable'}"
+ <Button x:Name="ReenableAutoBtn" Classes="chip" Content="{app:T 'main.re_enable'}"
IsVisible="False" Click="OnReenableAutomation"
- ToolTip.Tip="{app:T 'Hand overridden controls back to their automation'}"/>
+ ToolTip.Tip="{app:T 'main.hand_overridden_controls_back_to'}"/>
</StackPanel>
<!-- Add track: one menu instead of three chips -->
@@ -352,7 +352,7 @@
<StackPanel x:Name="RemotePanel" Grid.Column="6" Orientation="Horizontal" Spacing="6" Margin="8,0,0,0">
<ToggleButton x:Name="MidiLearnBtn" Classes="chip"
Click="OnToggleMidiLearn"
- ToolTip.Tip="{app:T 'Map a controller — click a control, then move a knob on the controller'}">
+ ToolTip.Tip="{app:T 'main.map_a_controller_click_a'}">
<StackPanel Orientation="Horizontal" Spacing="6" VerticalAlignment="Center">
<TextBlock Text="MIDI" VerticalAlignment="Center"
Foreground="{Binding $parent[ToggleButton].Foreground}"/>
@@ -361,13 +361,13 @@
</StackPanel>
</ToggleButton>
<Button x:Name="RemoteBtn" Classes="chip" Click="OnRemoteClick"
- ToolTip.Tip="{app:T 'Play and control Nota from a phone'}">
+ ToolTip.Tip="{app:T 'main.play_and_control_nota_from'}">
<StackPanel Orientation="Horizontal" Spacing="7" VerticalAlignment="Center">
<Border x:Name="RemoteGlyph" Width="8" Height="12" CornerRadius="{StaticResource Radius.Clip}" BorderThickness="1.5"
BorderBrush="{Binding $parent[Button].Foreground}" VerticalAlignment="Center"/>
- <TextBlock x:Name="RemoteLabel" Text="{app:T 'Remote'}" VerticalAlignment="Center"
+ <TextBlock x:Name="RemoteLabel" Text="{app:T 'main.remote'}" VerticalAlignment="Center"
Foreground="{Binding $parent[Button].Foreground}"/>
- <TextBlock x:Name="RemoteCount" Classes="Mono" Text="{app:T 'Off', Context=remote}" FontSize="10" VerticalAlignment="Center"
+ <TextBlock x:Name="RemoteCount" Classes="Mono" Text="{app:T 'main.off_remote'}" FontSize="10" VerticalAlignment="Center"
Foreground="{Binding $parent[Button].Foreground}"/>
<Ellipse x:Name="RemoteDot" Width="5" Height="5" VerticalAlignment="Center"
Fill="{DynamicResource Brush.BorderStrong}"/>
@@ -391,7 +391,7 @@
<!-- Master: fader over its meter, with the gain in dB -->
<Border x:Name="MasterWell" Grid.Column="9" Classes="tp-well" Margin="10,0,0,0">
<StackPanel Orientation="Horizontal" Spacing="8" VerticalAlignment="Center">
- <TextBlock Classes="CellLabel" Text="{app:T 'Master'}" VerticalAlignment="Center"/>
+ <TextBlock Classes="CellLabel" Text="{app:T 'common.master'}" VerticalAlignment="Center"/>
<StackPanel Spacing="3" VerticalAlignment="Center">
<Panel x:Name="MasterVolHost" Width="88" Height="10"/>
<Panel x:Name="MasterMeterHost" Width="88" Height="4"/>
@@ -429,19 +429,19 @@
<!-- Audio dropouts since the device started, in red and hidden at 0; a click resets it (#271). -->
<Button x:Name="DropoutButton" Grid.Column="4" Classes="ghost" IsVisible="{Binding HasDropouts}"
VerticalAlignment="Center" Margin="0" Padding="6,1" MinHeight="0" Cursor="Hand"
- ToolTip.Tip="{app:T 'Audio dropouts since the device started: buffers Nota couldn\'t fill in time, heard as clicks or gaps. If they keep coming, raise the buffer size or freeze heavy tracks. Click to reset'}">
+ ToolTip.Tip="{app:T 'main.audio_dropouts_since_the_device'}">
<TextBlock Classes="Caption Mono alert" Text="{Binding DropoutText}"/>
</Button>
<!-- Sample rate · buffer size: opens the buffer menu (MainWindow.AudioFormat.cs, #373). -->
<Button x:Name="AudioFormatButton" Grid.Column="5" Classes="ghost"
VerticalAlignment="Center" Margin="0" Padding="6,1" MinHeight="0" Cursor="Hand"
- ToolTip.Tip="{app:T 'Sample rate and buffer size. Click to change the buffer size'}">
+ ToolTip.Tip="{app:T 'main.sample_rate_and_buffer_size'}">
<TextBlock Classes="Caption Mono" Text="{Binding EngineInfo}"/>
</Button>
<!-- The installed version: opens its release notes (What's New), never an update (#127). -->
<Button x:Name="VersionButton" Grid.Column="6" Classes="ghost"
VerticalAlignment="Center" Margin="0,0,-6,0" Padding="6,1" MinHeight="0"
- Cursor="Hand" ToolTip.Tip="{app:T 'View release notes'}">
+ Cursor="Hand" ToolTip.Tip="{app:T 'main.view_release_notes'}">
<TextBlock x:Name="VersionText" Classes="Caption Mono"/>
</Button>
</Grid>
@@ -493,22 +493,22 @@
<Border DockPanel.Dock="Top" Height="32" Background="{DynamicResource Brush.Panel}"
BorderBrush="{DynamicResource Brush.Seam}" BorderThickness="0,0,0,1">
<Grid Margin="12,0,6,0" ColumnDefinitions="Auto,Auto,*,Auto,Auto,Auto">
- <TextBlock Text="{app:T 'Mixer'}" Classes="Title" VerticalAlignment="Center"/>
+ <TextBlock Text="{app:T 'common.mixer'}" Classes="Title" VerticalAlignment="Center"/>
<Border Grid.Column="1" Classes="segmented" Margin="14,0,0,0" VerticalAlignment="Center">
<StackPanel Orientation="Horizontal" Spacing="1">
- <ToggleButton x:Name="MixerStripsBtn" Classes="seg" Content="{app:T 'Strips'}" Click="OnMixerStrips"/>
- <ToggleButton x:Name="MixerMapBtn" Classes="seg" Content="{app:T 'Stereo map'}" Click="OnMixerMap"/>
+ <ToggleButton x:Name="MixerStripsBtn" Classes="seg" Content="{app:T 'main.strips'}" Click="OnMixerStrips"/>
+ <ToggleButton x:Name="MixerMapBtn" Classes="seg" Content="{app:T 'common.stereo_map'}" Click="OnMixerMap"/>
</StackPanel>
</Border>
<Border Grid.Column="3" Width="1" Height="16" Margin="10,0,6,0" VerticalAlignment="Center"
Background="{DynamicResource Brush.Rule}"/>
<Button x:Name="MixerPopOut" Grid.Column="4" Classes="ghost" Height="22" Padding="6,0"
Foreground="{DynamicResource Brush.TextTertiary}" Click="OnMixerPopOut"
- ToolTip.Tip="{app:T 'Open the mixer in a window'}">
+ ToolTip.Tip="{app:T 'main.open_the_mixer_in_a'}">
<app:Glyph Kind="PopOut"/>
</Button>
<Button Grid.Column="5" Classes="ghost" Height="22" Margin="2,0,0,0" Padding="6,0"
- Foreground="{DynamicResource Brush.TextTertiary}" Click="OnCloseMixer" ToolTip.Tip="{app:T 'Hide the mixer'}">
+ Foreground="{DynamicResource Brush.TextTertiary}" Click="OnCloseMixer" ToolTip.Tip="{app:T 'main.hide_the_mixer'}">
<app:Glyph Kind="Close"/>
</Button>
</Grid>
@@ -543,53 +543,53 @@
<Grid Margin="8,0,6,0" ColumnDefinitions="Auto,*,Auto,Auto,Auto,Auto,Auto">
<Border Classes="segmented" VerticalAlignment="Center">
<StackPanel Orientation="Horizontal" Spacing="1">
- <ToggleButton x:Name="DetailDevicesBtn" Classes="seg" Content="{app:T 'Devices'}" Click="OnDetailDevices"/>
- <ToggleButton x:Name="DetailPatternBtn" Classes="seg" Content="{app:T 'Pattern'}" IsEnabled="False" IsVisible="False"
- ToolTip.Tip="{app:T 'Step the selected MIDI clip on a Drum Rack track'}"
+ <ToggleButton x:Name="DetailDevicesBtn" Classes="seg" Content="{app:T 'main.devices'}" Click="OnDetailDevices"/>
+ <ToggleButton x:Name="DetailPatternBtn" Classes="seg" Content="{app:T 'common.pattern'}" IsEnabled="False" IsVisible="False"
+ ToolTip.Tip="{app:T 'main.step_the_selected_midi_clip'}"
Click="OnDetailPattern"/>
- <ToggleButton x:Name="DetailClipBtn" Classes="seg" Content="{app:T 'Clip'}" IsEnabled="False"
- ToolTip.Tip="{app:T 'Select a clip to edit it'}" Click="OnDetailClip"/>
+ <ToggleButton x:Name="DetailClipBtn" Classes="seg" Content="{app:T 'common.clip'}" IsEnabled="False"
+ ToolTip.Tip="{app:T 'main.select_a_clip_to_edit'}" Click="OnDetailClip"/>
</StackPanel>
</Border>
<ContentControl x:Name="DetailChipHost" Grid.Column="1" Margin="14,0,0,0" VerticalAlignment="Center"/>
<StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="4" VerticalAlignment="Center">
<Button x:Name="FreezeBtn" Height="22" Padding="9,0" VerticalAlignment="Center"
Click="OnFreezeClick"
- ToolTip.Tip="{app:T 'Freeze the track to audio to free CPU (right-click to flatten)'}">
+ ToolTip.Tip="{app:T 'main.freeze_the_track_to_audio'}">
<StackPanel Orientation="Horizontal" Spacing="6" VerticalAlignment="Center">
<app:Glyph x:Name="FreezeIcon" Kind="Freeze" Foreground="{DynamicResource Brush.TextSecondary}"/>
- <TextBlock x:Name="FreezeLabel" Text="{app:T 'Freeze'}" FontSize="12" VerticalAlignment="Center"
+ <TextBlock x:Name="FreezeLabel" Text="{app:T 'common.freeze'}" FontSize="12" VerticalAlignment="Center"
Foreground="{DynamicResource Brush.TextSecondary}"/>
</StackPanel>
</Button>
<Button x:Name="LiveFreezeBtn" Height="22" Padding="9,0" VerticalAlignment="Center"
IsVisible="False" Click="OnLiveFreezeClick"
- ToolTip.Tip="{app:T 'Bounce to a linked audio track below and put the source to sleep'}">
+ ToolTip.Tip="{app:T 'main.bounce_to_a_linked_audio'}">
<StackPanel Orientation="Horizontal" Spacing="6" VerticalAlignment="Center">
<app:Glyph Kind="ChainLink" Size="14" Foreground="{DynamicResource Brush.TextSecondary}"/>
- <TextBlock Text="{app:T 'Live freeze'}" FontSize="12" VerticalAlignment="Center"
+ <TextBlock Text="{app:T 'main.live_freeze'}" FontSize="12" VerticalAlignment="Center"
Foreground="{DynamicResource Brush.TextSecondary}"/>
</StackPanel>
</Button>
<Button x:Name="EditBtn" Height="22" Padding="9,0" VerticalAlignment="Center"
IsVisible="False" Click="OnEditClick"
- ToolTip.Tip="{app:T 'Wake the frozen source to edit it (right-click to unfreeze or flatten)'}">
+ ToolTip.Tip="{app:T 'main.wake_the_frozen_source_to'}">
<StackPanel Orientation="Horizontal" Spacing="5" VerticalAlignment="Center">
<app:Glyph x:Name="EditGlyph" Kind="Edit" Foreground="{DynamicResource Brush.AccentBright}"/>
- <TextBlock Text="{app:T 'Edit'}" FontSize="12" VerticalAlignment="Center" Foreground="{DynamicResource Brush.AccentBright}"/>
+ <TextBlock Text="{app:T 'common.edit'}" FontSize="12" VerticalAlignment="Center" Foreground="{DynamicResource Brush.AccentBright}"/>
</StackPanel>
</Button>
<Button x:Name="DoneBtn" Height="22" Padding="9,0" VerticalAlignment="Center"
IsVisible="False" Click="OnDoneClick"
- ToolTip.Tip="{app:T 'Re-freeze the source and put it back to sleep'}">
+ ToolTip.Tip="{app:T 'main.re_freeze_the_source_and'}">
<StackPanel Orientation="Horizontal" Spacing="5" VerticalAlignment="Center">
<app:Glyph x:Name="DoneGlyph" Kind="Check" Foreground="{DynamicResource Brush.AccentBright}"/>
- <TextBlock Text="{app:T 'Done'}" FontSize="12" VerticalAlignment="Center" Foreground="{DynamicResource Brush.AccentBright}"/>
+ <TextBlock Text="{app:T 'main.done'}" FontSize="12" VerticalAlignment="Center" Foreground="{DynamicResource Brush.AccentBright}"/>
</StackPanel>
</Button>
<Button x:Name="DiscardBtn" Classes="ghost" Height="22" Padding="6,0" VerticalAlignment="Center"
IsVisible="False" Click="OnDiscardClick"
- ToolTip.Tip="{app:T 'Leave edit mode without re-freezing'}">
+ ToolTip.Tip="{app:T 'main.leave_edit_mode_without_re'}">
<app:Glyph x:Name="DiscardGlyph" Kind="Cross" Foreground="{DynamicResource Brush.TextTertiary}"/>
</Button>
</StackPanel>
@@ -597,16 +597,16 @@
Background="{DynamicResource Brush.Rule}"/>
<Button x:Name="DetailMaximizeBtn" Grid.Column="4" Classes="ghost" Height="22" Margin="0,0,2,0" Padding="6,0"
Foreground="{DynamicResource Brush.TextTertiary}" Click="OnDetailMaximize" IsVisible="False"
- ToolTip.Tip="{app:T 'Fill the window with the clip editor (⌘⇧F)'}">
+ ToolTip.Tip="{app:T 'main.fill_the_window_with_the'}">
<app:Glyph x:Name="DetailMaximizeGlyph" Kind="Expand"/>
</Button>
<Button x:Name="DetailPopOut" Grid.Column="5" Classes="ghost" Height="22" Padding="6,0"
Foreground="{DynamicResource Brush.TextTertiary}" Click="OnToggleDetailWindow"
- ToolTip.Tip="{app:T 'Open devices and clip in a separate window'}">
+ ToolTip.Tip="{app:T 'main.open_devices_and_clip_in'}">
<app:Glyph x:Name="PopOutGlyph" Kind="PopOut"/>
</Button>
<Button Grid.Column="6" Classes="ghost" Height="22" Margin="2,0,0,0" Padding="6,0"
- Foreground="{DynamicResource Brush.TextTertiary}" Click="OnCloseDetail" ToolTip.Tip="{app:T 'Close'}">
+ Foreground="{DynamicResource Brush.TextTertiary}" Click="OnCloseDetail" ToolTip.Tip="{app:T 'common.close'}">
<app:Glyph x:Name="CloseDetailGlyph" Kind="Close"/>
</Button>
</Grid>
diff --git a/src/managed/Nota.App/MainWindow.axaml.cs b/src/managed/Nota.App/MainWindow.axaml.cs
index 0ca543e2..936ac5f9 100644
--- a/src/managed/Nota.App/MainWindow.axaml.cs
+++ b/src/managed/Nota.App/MainWindow.axaml.cs
@@ -222,8 +222,8 @@ public partial class MainWindow : Window
Timeline.CanTranscribe = () => Ai.CanTranscribe;
Timeline.TranscriptionModelRequested += async () =>
{
- if (await EnsureModelAsync(AiModels.Transcription, Loc.T("Convert to MIDI")) && _vm is not null)
- _vm.StatusText = Loc.T("Convert Melody and Convert Harmony now use the AI model.");
+ if (await EnsureModelAsync(AiModels.Transcription, Loc.T("main.convert_to_midi")) && _vm is not null)
+ _vm.StatusText = Loc.T("main.convert_melody_and_convert_harmony");
};
// Arrangement context menus add tracks through the toolbar's own path, so the two
// routes seed, refresh and report identically; the menu's row places the new track.
@@ -245,7 +245,7 @@ public partial class MainWindow : Window
Action<double> setMaster = v => vm.Transport.MasterVolume = v;
masterVol.ValueChanged += v => masterUndo.Change(v, setMaster);
// Double-click the fader or its dB number to type the master gain, ⌥-click for 0 dB.
- ValueEntry.Attach(masterVol, masterVol.EntryField(Loc.T("Master volume"), v => NotaNum.GainDb(v)), MasterDb);
+ ValueEntry.Attach(masterVol, masterVol.EntryField(Loc.T("main.master_volume"), v => NotaNum.GainDb(v)), MasterDb);
MasterVolHost.Children.Add(masterVol);
MidiLearn.Bind(masterVol, MidiTarget.MasterVolume, "Master Volume");
@@ -348,7 +348,7 @@ public partial class MainWindow : Window
cpuShown = pct;
CpuFill.Width = pct * 0.52;
CpuFill.Background = pct > 90 ? cpuRed : pct > 70 ? cpuAmber : cpuGreen;
- CpuText.Text = Loc.F("DSP {0}%", pct);
+ CpuText.Text = Loc.F("main.dsp_caps", pct);
}
_cpuTipTick?.Invoke();
SyncMidiDot();
@@ -620,7 +620,7 @@ public partial class MainWindow : Window
Engine.AddMidiEffect(t, 0); // Arpeggiator (MIDI FX)
Engine.AddBuiltinDevice(t, 16); // Nota EQ-3
Engine.AddBuiltinDevice(t, 3); // Nota Delay
- Engine.SetTrackName(t, Loc.T("Bass"));
+ Engine.SetTrackName(t, Loc.T("main.bass"));
int mod = Engine.ModulatorAdd(t, 0); // LFO
Engine.ModulatorSet(t, mod, 1, 1f); // tempo sync
Engine.CvLinkAdd(t, mod, 0, 0); // LFO → EQ-3 param 0
@@ -637,8 +637,8 @@ public partial class MainWindow : Window
int scope = Engine.ModulatorAdd(t, 6); // Scope (monitors the LFO)
Engine.ModulatorSet(t, scope, 10, mod); // input = LFO
// A couple more tracks so the Global view has several islands.
- int dr = Engine.AddInstrumentTrack(); Engine.SetTrackBuiltinInstrument(dr, 1); Engine.AddBuiltinDevice(dr, 0); Engine.SetTrackName(dr, Loc.T("Drums"));
- int pad = Engine.AddInstrumentTrack(); Engine.SetTrackBuiltinInstrument(pad, 5); Engine.AddBuiltinDevice(pad, 2); Engine.AddBuiltinDevice(pad, 7); Engine.SetTrackName(pad, Loc.T("Pad"));
+ int dr = Engine.AddInstrumentTrack(); Engine.SetTrackBuiltinInstrument(dr, 1); Engine.AddBuiltinDevice(dr, 0); Engine.SetTrackName(dr, Loc.T("main.drums"));
+ int pad = Engine.AddInstrumentTrack(); Engine.SetTrackBuiltinInstrument(pad, 5); Engine.AddBuiltinDevice(pad, 2); Engine.AddBuiltinDevice(pad, 7); Engine.SetTrackName(pad, Loc.T("main.pad"));
Engine.CvLinkAddTo(t, mod, pad, 1, 0); // Bass LFO → Pad's Auto Filter (cross-track CV)
Timeline.Refresh();
SetView(MainView.Modular);
@@ -685,21 +685,21 @@ public partial class MainWindow : Window
_session?.Refresh();
if (_modular?.IsVisible == true) _modular.Refresh(); // new track shows in the graph/sidebar
_vm.StatusText = kind == NewTrackKind.Instrument
- ? Loc.F("Instrument track {0} (synth)", trackId)
- : Loc.F("Audio track {0} — arm it and hit Rec to record input", trackId);
+ ? Loc.F("main.instrument_track_synth", trackId)
+ : Loc.F("main.audio_track_arm_it_and", trackId);
}
private void OnAddReturnClicked(object? sender, RoutedEventArgs e)
{
if (_vm is null) return;
int trackId = Engine.AddReturnTrack();
- if (trackId <= 0) { _vm.StatusText = Loc.T("All return buses are in use."); return; }
+ if (trackId <= 0) { _vm.StatusText = Loc.T("main.all_return_buses_are_in"); return; }
Timeline.Refresh();
if (DetailBody.Content == _deviceChain) _deviceChain?.Refresh(); // new bus -> Sends section
_session?.Refresh(); // mini-mixer send controls follow the return count
if (_modular?.IsVisible == true) _modular.Refresh();
int bus = Engine.TrackReturnIndex(trackId);
- _vm.StatusText = Loc.F("Return {0} added — add an effect, then dial up track sends", bus + 1);
+ _vm.StatusText = Loc.F("main.return_added_add_an_effect", bus + 1);
}
// --- Session view (M5) --------------------------------------------------
@@ -735,10 +735,10 @@ public partial class MainWindow : Window
private void OnPickProjectKey(object? sender, RoutedEventArgs e)
{
if (_vm is null) return;
- KeyPicker.Show(KeyChip, _vm.Transport.Key, Loc.T("No key"), k =>
+ KeyPicker.Show(KeyChip, _vm.Transport.Key, Loc.T("main.no_key"), k =>
{
_vm.Transport.KeyCode = k?.Code ?? -1;
- _vm.StatusText = k is { } key ? Loc.F("Project key: {0}", key.Long) : Loc.T("No project key");
+ _vm.StatusText = k is { } key ? Loc.F("main.project_key", key.Long) : Loc.T("main.no_project_key");
});
}
@@ -794,9 +794,9 @@ public partial class MainWindow : Window
string proc = cpu.CorePercent() is { } core
? NotaNum.Unit(ProcessCpuScale.ToDisplay(core, cpu.LogicalCpus, wholeMachine), "0", "%")
+ " " + ProcessCpuScale.Unit(wholeMachine)
- : Loc.T("measuring…");
- string tip = Loc.F("DSP load: {0} of the audio buffer time — dropouts start near 100\u2009%", NotaNum.Unit(dsp, "0", "%")) + "\n"
- + Loc.F("Nota process CPU: {0} (audio, interface, plugins)", proc);
+ : Loc.T("main.measuring");
+ string tip = Loc.F("main.dsp_load_of_the_audio", NotaNum.Unit(dsp, "0", "%")) + "\n"
+ + Loc.F("main.nota_process_cpu_audio_interface", proc);
if (tip != shown) ToolTip.SetTip(CpuMeter, shown = tip); // re-set only when it changed (#66)
};
_cpuTipTick();
@@ -817,7 +817,7 @@ public partial class MainWindow : Window
if (bpm is { } b)
{
_vm.Transport.Bpm = (decimal)b;
- _vm.StatusText = Loc.F("Tempo: {0} BPM (tapped)", NotaNum.Bpm(b));
+ _vm.StatusText = Loc.F("main.tempo_bpm_tapped", NotaNum.Bpm(b));
}
ShowTapDots(_tap.Count);
_tapIdle ??= new DispatcherTimer { Interval = TimeSpan.FromSeconds(3) };
@@ -884,7 +884,7 @@ public partial class MainWindow : Window
_followMenuItem ??= MenuItemFor("view.follow");
if (_followMenuItem is not null) _followMenuItem.IsChecked = on;
if (on) Timeline.RecenterOnPlayhead(); // jump to the cursor now
- if (_vm is not null) _vm.StatusText = on ? Loc.T("Following the playhead") : Loc.T("Follow playhead off");
+ if (_vm is not null) _vm.StatusText = on ? Loc.T("main.following_the_playhead") : Loc.T("main.follow_playhead_off");
}
private NativeMenuItem? _followMenuItem;
@@ -894,7 +894,7 @@ public partial class MainWindow : Window
if (_vm is null) return;
_vm.Settings.Current.PianoRollAudition = PianoRollView.AuditionEnabled;
_vm.Settings.Save();
- _vm.StatusText = PianoRollView.AuditionEnabled ? Loc.T("Note audition on") : Loc.T("Note audition off");
+ _vm.StatusText = PianoRollView.AuditionEnabled ? Loc.T("main.note_audition_on") : Loc.T("main.note_audition_off");
}
// Show playhead (#105, P / View menu / the ruler's off-screen arrow): a one-shot scroll
@@ -903,7 +903,7 @@ public partial class MainWindow : Window
{
bool resumed = Timeline.FollowPlayhead && Timeline.FollowSuspended;
Timeline.RevealPlayhead();
- if (_vm is not null && resumed) _vm.StatusText = Loc.T("Following the playhead");
+ if (_vm is not null && resumed) _vm.StatusText = Loc.T("main.following_the_playhead");
}
// Follow pauses when the lanes are scrolled away during playback (#105); the Follow
@@ -922,9 +922,9 @@ public partial class MainWindow : Window
bool paused = Timeline.FollowSuspended;
FollowBtn.Classes.Set("paused", paused);
ToolTip.SetTip(FollowBtn, paused
- ? Loc.T("Follow is paused while you look elsewhere · P or a click here picks it up again")
- : Loc.T("Scroll the arrangement to keep the playhead in view"));
- if (paused && _vm is not null) _vm.StatusText = Loc.T("Follow paused · press P to go back to the playhead");
+ ? Loc.T("main.follow_is_paused_while_you")
+ : Loc.T("main.scroll_the_arrangement_to_keep"));
+ if (paused && _vm is not null) _vm.StatusText = Loc.T("main.follow_paused_press_p_to");
}
private static NativeMenuItem? FindMenuItem(NativeMenu? menu, string header)
@@ -946,7 +946,7 @@ public partial class MainWindow : Window
bool on = SnapToggle.IsChecked == true;
var grids = EditorGrids.Shared;
grids.Set(EditorKind.Arrangement, grids.Get(EditorKind.Arrangement) with { SnapOn = on });
- if (_vm is not null) _vm.StatusText = on ? Loc.T("Snap on") : Loc.T("Snap off — clips position freely");
+ if (_vm is not null) _vm.StatusText = on ? Loc.T("main.snap_on") : Loc.T("main.snap_off_clips_position_freely");
}
// The toolbar GRID cell and the magnet follow the arrangement's grid wherever it changes
diff --git a/src/managed/Nota.App/MenuKit.Rows.cs b/src/managed/Nota.App/MenuKit.Rows.cs
index 93582601..1afecddf 100644
--- a/src/managed/Nota.App/MenuKit.Rows.cs
+++ b/src/managed/Nota.App/MenuKit.Rows.cs
@@ -91,7 +91,7 @@ internal static partial class MenuKit
{
Height = 52, MinWidth = 40, Margin = new Thickness(6, 0, 0, 0), CornerRadius = NotaRadius.Control,
BorderThickness = new Thickness(1), Padding = new Thickness(6, 0), VerticalAlignment = VerticalAlignment.Top,
- Child = new TextBlock { Text = Loc.T("Auto"), FontSize = NotaType.Caption, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center },
+ Child = new TextBlock { Text = Loc.T("common.auto"), FontSize = NotaType.Caption, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center },
};
Grid.SetColumn(auto, bases); Grid.SetRowSpan(auto, shades);
grid.Children.Add(auto);
@@ -148,7 +148,7 @@ internal static partial class MenuKit
{
if (recent is null || recent.Count == 0) return;
submenu.Items.Add(new Separator());
- submenu.Items.Add(Caption(Loc.T("Recent")));
+ submenu.Items.Add(Caption(Loc.T("common.recent")));
foreach (var mi in recent) submenu.Items.Add(mi);
}
diff --git a/src/managed/Nota.App/MenuKit.cs b/src/managed/Nota.App/MenuKit.cs
index a0a665a0..c70165ff 100644
--- a/src/managed/Nota.App/MenuKit.cs
+++ b/src/managed/Nota.App/MenuKit.cs
@@ -28,9 +28,9 @@ internal static partial class MenuKit
/// wording (pairs with <c>MainWindow.RevealInFileManager</c>). Menus use this instead of
/// hard-coding "Finder".</summary>
public static string RevealLabel =>
- OperatingSystem.IsMacOS() ? Loc.T("Reveal in Finder")
- : OperatingSystem.IsWindows() ? Loc.T("Show in Explorer")
- : Loc.T("Show in file manager");
+ OperatingSystem.IsMacOS() ? Loc.T("menu.reveal_in_finder")
+ : OperatingSystem.IsWindows() ? Loc.T("menu.show_in_explorer")
+ : Loc.T("menu.show_in_file_manager");
private static KeyModifiers Primary => OperatingSystem.IsMacOS() ? KeyModifiers.Meta : KeyModifiers.Control;
@@ -113,10 +113,10 @@ internal static partial class MenuKit
public static IEnumerable<MenuItem> ClipboardGroup(Action? copy, Action? cut, Action? paste,
Action? duplicate, bool canPaste = true)
{
- if (copy is not null) yield return Item(Loc.T("Copy"), GlyphKind.Copy, copy, CopyKey);
- if (cut is not null) yield return Item(Loc.T("Cut"), GlyphKind.Cut, cut, CutKey);
- if (paste is not null) yield return Item(Loc.T("Paste"), GlyphKind.Paste, paste, PasteKey, canPaste);
- if (duplicate is not null) yield return Item(Loc.T("Duplicate"), GlyphKind.Duplicate, duplicate, DuplicateKey);
+ if (copy is not null) yield return Item(Loc.T("common.copy"), GlyphKind.Copy, copy, CopyKey);
+ if (cut is not null) yield return Item(Loc.T("common.cut"), GlyphKind.Cut, cut, CutKey);
+ if (paste is not null) yield return Item(Loc.T("common.paste"), GlyphKind.Paste, paste, PasteKey, canPaste);
+ if (duplicate is not null) yield return Item(Loc.T("common.duplicate"), GlyphKind.Duplicate, duplicate, DuplicateKey);
}
/// <summary>Adds groups to a menu with a rule between non-empty ones, so callers can pass
diff --git a/src/managed/Nota.App/MidiLearn.cs b/src/managed/Nota.App/MidiLearn.cs
index 6470d2d6..0a7bed46 100644
--- a/src/managed/Nota.App/MidiLearn.cs
+++ b/src/managed/Nota.App/MidiLearn.cs
@@ -52,12 +52,12 @@ public static class GamepadControls
if (IsAxis(controlId))
return Axis(controlId) switch
{
- GamepadAxis.LeftX => Loc.T("Left stick ←→"),
- GamepadAxis.LeftY => Loc.T("Left stick ↑↓"),
- GamepadAxis.RightX => Loc.T("Right stick ←→"),
- GamepadAxis.RightY => Loc.T("Right stick ↑↓"),
- GamepadAxis.LeftTrigger => Loc.T("Left trigger"),
- _ => Loc.T("Right trigger"),
+ GamepadAxis.LeftX => Loc.T("midi_learn.left_stick"),
+ GamepadAxis.LeftY => Loc.T("midi_learn.left_stick_2"),
+ GamepadAxis.RightX => Loc.T("midi_learn.right_stick"),
+ GamepadAxis.RightY => Loc.T("midi_learn.right_stick_2"),
+ GamepadAxis.LeftTrigger => Loc.T("midi_learn.left_trigger"),
+ _ => Loc.T("midi_learn.right_trigger"),
};
return (GamepadButton)controlId switch
{
@@ -65,7 +65,7 @@ public static class GamepadControls
GamepadButton.DpadDown => "D-pad ↓",
GamepadButton.DpadLeft => "D-pad ←",
GamepadButton.DpadRight => "D-pad →",
- _ => Loc.F("Button {0}", controlId),
+ _ => Loc.F("midi_learn.button", controlId),
};
}
}
@@ -173,8 +173,8 @@ public sealed class MidiMapping
public string SourceLabel => SourceKind switch
{
MidiSourceKind.Cc => $"CC {Number} · ch{Channel + 1}",
- MidiSourceKind.Gamepad => Loc.F("Pad · {0}", GamepadControls.Name(Number)),
- MidiSourceKind.Phone => Loc.F("Phone · {0}", Nota.Remote.PhoneControls.Name(Number)),
- _ => Loc.F("Note {0} · ch{1}", Number, Channel + 1),
+ MidiSourceKind.Gamepad => Loc.F("midi_learn.pad", GamepadControls.Name(Number)),
+ MidiSourceKind.Phone => Loc.F("midi_learn.phone", Nota.Remote.PhoneControls.Name(Number)),
+ _ => Loc.F("midi_learn.note_ch", Number, Channel + 1),
};
}
diff --git a/src/managed/Nota.App/MidiMapView.cs b/src/managed/Nota.App/MidiMapView.cs
index 4f90e7ab..afa8bd28 100644
--- a/src/managed/Nota.App/MidiMapView.cs
+++ b/src/managed/Nota.App/MidiMapView.cs
@@ -25,7 +25,7 @@ public sealed partial class MidiMapView : UserControl
var header = new TextBlock
{
- Text = Loc.T("MIDI mappings"), FontSize = 10, Margin = new Avalonia.Thickness(12, 12, 12, 2),
+ Text = Loc.T("midi_map.midi_mappings"), FontSize = 10, Margin = new Avalonia.Thickness(12, 12, 12, 2),
Foreground = NotaPalette.TextTertiary,
};
var body = new StackPanel { Margin = new Avalonia.Thickness(8, 4), Children = { _rows } };
@@ -40,7 +40,7 @@ public sealed partial class MidiMapView : UserControl
{
_rows.Children.Add(new TextBlock
{
- Text = Loc.T("No mappings yet.\n\nClick MIDI (top-right), then click any highlighted\ncontrol and move a knob or fader on your controller —\nor press a button or move a stick on a gamepad."),
+ Text = Loc.T("midi_map.no_mappings_yet_click_midi"),
FontSize = 11, TextWrapping = TextWrapping.Wrap, LineHeight = 16,
Margin = new Avalonia.Thickness(6, 10), Foreground = NotaPalette.TextTertiary,
});
@@ -57,16 +57,16 @@ public sealed partial class MidiMapView : UserControl
var name = m.DisplayName;
switch (m.Target.Kind)
{
- case MidiTargetKind.TransportPlay: return name == "Play" ? Loc.T("Play") : name;
- case MidiTargetKind.TransportStop: return name == "Stop" ? Loc.T("Stop") : name;
- case MidiTargetKind.TransportRecord: return name == "Record" ? Loc.T("Record") : name;
- case MidiTargetKind.MasterVolume: return name == "Master Volume" ? Loc.T("Master Volume") : name;
- case MidiTargetKind.TrackVolume: return name == "Track Volume" ? Loc.T("Track Volume") : name;
- case MidiTargetKind.TrackPan: return name == "Track Pan" ? Loc.T("Track Pan") : name;
- case MidiTargetKind.TrackMute: return name == "Mute" ? Loc.T("Mute") : name;
- case MidiTargetKind.TrackSolo: return name == "Solo" ? Loc.T("Solo") : name;
+ case MidiTargetKind.TransportPlay: return name == "Play" ? Loc.T("midi_map.play") : name;
+ case MidiTargetKind.TransportStop: return name == "Stop" ? Loc.T("common.stop") : name;
+ case MidiTargetKind.TransportRecord: return name == "Record" ? Loc.T("common.record") : name;
+ case MidiTargetKind.MasterVolume: return name == "Master Volume" ? Loc.T("midi_map.master_volume") : name;
+ case MidiTargetKind.TrackVolume: return name == "Track Volume" ? Loc.T("midi_map.track_volume") : name;
+ case MidiTargetKind.TrackPan: return name == "Track Pan" ? Loc.T("midi_map.track_pan") : name;
+ case MidiTargetKind.TrackMute: return name == "Mute" ? Loc.T("common.mute") : name;
+ case MidiTargetKind.TrackSolo: return name == "Solo" ? Loc.T("common.solo") : name;
case MidiTargetKind.PluginParam when MacroLabel().Match(name) is { Success: true } g:
- return Loc.F("Macro {0} · {1}", g.Groups[1].Value, g.Groups[2].Value); // a rack macro
+ return Loc.F("common.macro", g.Groups[1].Value, g.Groups[2].Value); // a rack macro
default: return name;
}
}
@@ -119,7 +119,7 @@ public sealed partial class MidiMapView : UserControl
// Range + invert only make sense for continuous (non-button) targets.
if (!m.Target.IsButton)
{
- var inv = new CheckBox { Content = Loc.T("Invert"), FontSize = 10, IsChecked = m.Invert, VerticalAlignment = VerticalAlignment.Center, Foreground = NotaPalette.TextSecondary };
+ var inv = new CheckBox { Content = Loc.T("midi_map.invert"), FontSize = 10, IsChecked = m.Invert, VerticalAlignment = VerticalAlignment.Center, Foreground = NotaPalette.TextSecondary };
inv.IsCheckedChanged += (_, _) => m.Invert = inv.IsChecked == true;
Grid.SetColumn(inv, 1);
srcRow.Children.Add(inv);
@@ -129,8 +129,8 @@ public sealed partial class MidiMapView : UserControl
Orientation = Orientation.Horizontal, Spacing = 16,
VerticalAlignment = VerticalAlignment.Center,
};
- range.Children.Add(RangeField(Loc.T("Min"), m.RangeMin, v => m.RangeMin = v));
- range.Children.Add(RangeField(Loc.T("Max"), m.RangeMax, v => m.RangeMax = v));
+ range.Children.Add(RangeField(Loc.T("common.min"), m.RangeMin, v => m.RangeMin = v));
+ range.Children.Add(RangeField(Loc.T("midi_map.max"), m.RangeMax, v => m.RangeMax = v));
body.Children.Add(range);
}
diff --git a/src/managed/Nota.App/MidiToolsView.cs b/src/managed/Nota.App/MidiToolsView.cs
index d7a4228b..784d5024 100644
--- a/src/managed/Nota.App/MidiToolsView.cs
+++ b/src/managed/Nota.App/MidiToolsView.cs
@@ -63,7 +63,7 @@ public sealed class MidiToolsView : UserControl
BorderBrush = NotaPalette.BorderDefault;
BorderThickness = new Thickness(1, 0, 0, 0);
- var kinds = Segments(new[] { Loc.T("Generate"), Loc.T("Transform") }, 0, i =>
+ var kinds = Segments(new[] { Loc.T("midi_tools.generate"), Loc.T("midi_tools.transform") }, 0, i =>
{
var kind = i == 0 ? MidiToolKind.Generate : MidiToolKind.Transform;
if (_kind == kind) return;
@@ -76,9 +76,9 @@ public sealed class MidiToolsView : UserControl
var seedBox = Field(new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 8,
- Children = { CapsLabel(Loc.T("Seed")), _seedText },
+ Children = { CapsLabel(Loc.T("midi_tools.seed")), _seedText },
});
- var reroll = ClipEditorKit.Button(Loc.T("Reroll"), () =>
+ var reroll = ClipEditorKit.Button(Loc.T("midi_tools.reroll"), () =>
{
_seed = Random.Shared.Next(1, 9999);
_seedText.Text = _seed.ToString(NotaNum.Culture);
@@ -90,14 +90,14 @@ public sealed class MidiToolsView : UserControl
Grid.SetColumn(reroll, 1); seedRow.Children.Add(reroll);
var parameters = Section(title, 9, _paramList, seedRow);
- var output = Section(SectionTitle(Loc.T("Output"), _scopeText), 8,
- Segments(new[] { Loc.T("Replace"), Loc.T("Add") }, 0, i =>
+ var output = Section(SectionTitle(Loc.T("common.output"), _scopeText), 8,
+ Segments(new[] { Loc.T("midi_tools.replace"), Loc.T("midi_tools.add") }, 0, i =>
{
_blend = i == 0 ? MidiToolBlend.Replace : MidiToolBlend.Add;
Preview();
}, out _, fill: true));
- _applyButton = new Button { Content = Loc.T("Apply"), Height = 30, FontSize = NotaType.Name, FontWeight = FontWeight.SemiBold, HorizontalAlignment = HorizontalAlignment.Stretch, Classes = { "primary" } };
+ _applyButton = new Button { Content = Loc.T("midi_tools.apply"), Height = 30, FontSize = NotaType.Name, FontWeight = FontWeight.SemiBold, HorizontalAlignment = HorizontalAlignment.Stretch, Classes = { "primary" } };
_applyButton.Click += (_, _) => Apply();
_resultText.HorizontalAlignment = HorizontalAlignment.Center;
var foot = new StackPanel
@@ -106,7 +106,7 @@ public sealed class MidiToolsView : UserControl
Children =
{
_resultText, _applyButton,
- Pair(ClipEditorKit.Button(Loc.T("Revert"), Revert), ClipEditorKit.Button(Loc.T("Defaults"), ResetTool)),
+ Pair(ClipEditorKit.Button(Loc.T("midi_tools.revert"), Revert), ClipEditorKit.Button(Loc.T("midi_tools.defaults"), ResetTool)),
},
};
foot.Margin = new Thickness(14, 10, 14, 12);
@@ -162,8 +162,8 @@ public sealed class MidiToolsView : UserControl
_work.Add((clips[set.Active], new HashSet<int>(), set.ActiveClip.LengthBeats));
int scoped = _work.Sum(w => w.Scope.Count);
_scopeText.Text = scoped > 0
- ? Loc.F("{0} selected", scoped)
- : Loc.F("clip · {0}", SourceCount);
+ ? Loc.F("midi_tools.selected", scoped)
+ : Loc.F("midi_tools.clip", SourceCount);
}
private MidiToolContext Context(double lengthBeats) => new()
@@ -206,7 +206,7 @@ public sealed class MidiToolsView : UserControl
// Deliberately no re-preview: the applied result is the new source, so running the
// tool again here would show it applied twice before the user asked for anything.
// The next knob move (or Reroll) arms a fresh preview from the new source.
- _resultText.Text = Loc.F("{0} notes · applied", SourceCount);
+ _resultText.Text = Loc.F("midi_tools.notes_applied", SourceCount);
_resultText.Foreground = NotaPalette.TextMuted;
PaintApply();
}
@@ -232,13 +232,13 @@ public sealed class MidiToolsView : UserControl
private void PaintResult(int? resultCount)
{
if (resultCount is not int count)
- _resultText.Text = _tool is null ? Loc.T("Pick a tool") : "—";
+ _resultText.Text = _tool is null ? Loc.T("midi_tools.pick_a_tool") : "—";
else
{
int delta = count - SourceCount;
_resultText.Text = _blend == MidiToolBlend.Add
- ? Loc.F("{0:+0;−0;\u00b10} notes", delta)
- : Loc.F("{0} notes, was {1}", count, SourceCount);
+ ? Loc.F("midi_tools.notes", delta)
+ : Loc.F("midi_tools.notes_was", count, SourceCount);
}
_resultText.Foreground = NotaPalette.TextMuted;
PaintApply();
@@ -311,10 +311,10 @@ public sealed class MidiToolsView : UserControl
private void RebuildParams()
{
_paramList.Children.Clear();
- _paramTitle.Text = _tool is null ? Loc.T("Parameters") : _tool.Name;
+ _paramTitle.Text = _tool is null ? Loc.T("midi_tools.parameters") : _tool.Name;
if (_tool is null)
{
- _paramList.Children.Add(new TextBlock { Text = Loc.T("Pick a tool to see its parameters"), FontSize = NotaType.Body, Foreground = NotaPalette.TextTertiary });
+ _paramList.Children.Add(new TextBlock { Text = Loc.T("midi_tools.pick_a_tool_to_see"), FontSize = NotaType.Body, Foreground = NotaPalette.TextTertiary });
return;
}
var settings = SettingsFor(_tool);
diff --git a/src/managed/Nota.App/MixerView.Compact.cs b/src/managed/Nota.App/MixerView.Compact.cs
index b92d0ab3..7336d419 100644
--- a/src/managed/Nota.App/MixerView.Compact.cs
+++ b/src/managed/Nota.App/MixerView.Compact.cs
@@ -34,10 +34,10 @@ public sealed partial class MixerView
if (ti.IsInstrument) io = MidiIoRow(id, compact: true);
else
{
- string from = isReturn ? Loc.T("Return in") : ti.IsGroup ? Loc.T("Group in") : Loc.T("In 1");
- string to = isReturn ? Loc.T("→ Master")
- : ti.IsGroup ? "→ " + (ti.GroupId >= 0 ? TrackNames.Of(_engine, ti.GroupId) : Loc.T("Master"))
- : Loc.T("Monitor in");
+ string from = isReturn ? Loc.T("mixer.return_in") : ti.IsGroup ? Loc.T("mixer.group_in") : Loc.T("mixer.in_1");
+ string to = isReturn ? Loc.T("mixer.master")
+ : ti.IsGroup ? "→ " + (ti.GroupId >= 0 ? TrackNames.Of(_engine, ti.GroupId) : Loc.T("common.master"))
+ : Loc.T("mixer.monitor_in");
io = CompactIoRow(from + " " + to);
}
io.IsVisible = IoShown;
@@ -64,8 +64,8 @@ public sealed partial class MixerView
private Border CompactMasterStrip()
{
var col = new StackPanel();
- col.Children.Add(Header(Loc.T("Master"), NotaPalette.Master, MasterBg));
- var io = CompactIoRow(Loc.T("Sum bus") + " " + Loc.T("→ Output"));
+ col.Children.Add(Header(Loc.T("common.master"), NotaPalette.Master, MasterBg));
+ var io = CompactIoRow(Loc.T("mixer.sum_bus") + " " + Loc.T("mixer.output"));
io.IsVisible = IoShown;
_ioSections.Add(io);
col.Children.Add(io);
@@ -113,7 +113,7 @@ public sealed partial class MixerView
var f = new MiniFader(_engine.GetTrackSend(id, bus), 1.0) { VerticalAlignment = VerticalAlignment.Center };
int b = bus;
SendControl.Attach(f, _engine, id, b); // undoable, writes automation (specs/072)
- ValueEntry.Attach(f, f.EntryField(Loc.F("Send {0}", (char)('A' + b)), NotaNum.Pct));
+ ValueEntry.Attach(f, f.EntryField(Loc.F("common.send", (char)('A' + b)), NotaNum.Pct));
_sendFaders.Add((id, b, f));
bar = f;
}
@@ -141,12 +141,12 @@ public sealed partial class MixerView
MidiLearn.Bind(bar, MidiTarget.TrackPan(id), "Track Pan");
}
bar.GestureEnd += undo.End;
- ValueEntry.Attach(bar, bar.EntryField(Loc.T("Pan")));
+ ValueEntry.Attach(bar, bar.EntryField(Loc.T("common.pan")));
var row = new DockPanel { VerticalAlignment = VerticalAlignment.Center, LastChildFill = true };
if (isGroup)
{
- var bal = Tag("BAL", 7, 0.84, 11, Loc.T("Groups keep a unity-centre balance so grouping stays level-transparent"));
+ var bal = Tag("BAL", 7, 0.84, 11, Loc.T("mixer.groups_keep_a_unity_centre"));
bal.IsVisible = _engine.PanLaw == PanLaw.Stereo;
bal.Margin = new Thickness(3, 0, 0, 0);
_balBadges.Add(bal);
@@ -162,7 +162,7 @@ public sealed partial class MixerView
{
var fader = new MeterFader(vol) { HorizontalAlignment = HorizontalAlignment.Center };
var dbNum = DbField(vol);
- ToolTip.SetTip(dbNum, Loc.T("Set the gain — drag, or double-click to type"));
+ ToolTip.SetTip(dbNum, Loc.T("mixer.set_the_gain_drag_or"));
void SetVolume(double v) { if (id < 0) SetMasterVolume?.Invoke((float)v); else _engine.SetTrackVolume(id, (float)v); }
if (id < 0) { _masterMeterFader = fader; _masterDb = dbNum; }
else { var sync = SyncOf(id); sync.MeterFader = fader; sync.Db = dbNum; }
@@ -180,7 +180,7 @@ public sealed partial class MixerView
fader.GestureEnd += undo.End;
dbNum.GestureEnd += undo.End;
MidiLearn.Bind(fader, id > 0 ? MidiTarget.TrackVolume(id) : MidiTarget.MasterVolume, id > 0 ? "Track Volume" : "Master Volume");
- ValueEntry.Attach(fader, fader.EntryField(Loc.T("Volume"), v => NotaNum.GainDb(v, signed: true), 1.0));
+ ValueEntry.Attach(fader, fader.EntryField(Loc.T("common.volume"), v => NotaNum.GainDb(v, signed: true), 1.0));
_meters.Add((id, fader, fader.Push));
db = dbNum;
diff --git a/src/managed/Nota.App/MixerView.cs b/src/managed/Nota.App/MixerView.cs
index f6d6b505..395d597f 100644
--- a/src/managed/Nota.App/MixerView.cs
+++ b/src/managed/Nota.App/MixerView.cs
@@ -563,10 +563,10 @@ public sealed partial class MixerView : UserControl
col.Children.Add(Header(TrackNames.Of(_engine, ti), color, Card, ti.IsGroup ? entry : null));
- string io1 = isReturn ? Loc.T("Return in") : ti.IsGroup ? Loc.T("Group in") : ti.IsInstrument ? Loc.T("MIDI in") : Loc.T("In 1");
- string io2 = isReturn ? Loc.T("→ Master")
- : ti.IsGroup ? "→ " + (ti.GroupId >= 0 ? TrackNames.Of(_engine, ti.GroupId) : Loc.T("Master"))
- : ti.IsInstrument ? Loc.T("Monitor auto") : Loc.T("Monitor in");
+ string io1 = isReturn ? Loc.T("mixer.return_in") : ti.IsGroup ? Loc.T("mixer.group_in") : ti.IsInstrument ? Loc.T("mixer.midi_in") : Loc.T("mixer.in_1");
+ string io2 = isReturn ? Loc.T("mixer.master")
+ : ti.IsGroup ? "→ " + (ti.GroupId >= 0 ? TrackNames.Of(_engine, ti.GroupId) : Loc.T("common.master"))
+ : ti.IsInstrument ? Loc.T("mixer.monitor_auto") : Loc.T("mixer.monitor_in");
// Instrument tracks get a live "MIDI To" selector in place of the static I/O text.
var ioRow = ti.IsInstrument ? MidiIoRow(id) : IoRow(io1, io2);
ioRow.IsVisible = IoShown;
@@ -597,8 +597,8 @@ public sealed partial class MixerView : UserControl
private Border MasterStrip()
{
var col = new StackPanel();
- col.Children.Add(Header(Loc.T("Master"), NotaPalette.Master, MasterBg));
- var ioRow = IoRow(Loc.T("Sum bus"), Loc.T("→ Output"));
+ col.Children.Add(Header(Loc.T("common.master"), NotaPalette.Master, MasterBg));
+ var ioRow = IoRow(Loc.T("mixer.sum_bus"), Loc.T("mixer.output"));
ioRow.IsVisible = IoShown;
_ioSections.Add(ioRow);
col.Children.Add(ioRow);
@@ -623,14 +623,14 @@ public sealed partial class MixerView : UserControl
private Control Footer()
{
- var sendsToggle = SectionToggle(Loc.T("Sends"), () => _sendsVisible, () => _sendsAuto, () => _sendsPinned,
+ var sendsToggle = SectionToggle(Loc.T("common.sends"), () => _sendsVisible, () => _sendsAuto, () => _sendsPinned,
(on, pinned) => { _sendsVisible = on; _sendsPinned = pinned; FitHeight(); }, out _paintSendsToggle);
var ioToggle = SectionToggle("I/O", () => _ioVisible, () => _ioAuto, () => _ioPinned,
(on, pinned) => { _ioVisible = on; _ioPinned = pinned; FitHeight(); }, out _paintIoToggle);
var left = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 6, VerticalAlignment = VerticalAlignment.Center,
- Children = { new TextBlock { Text = Loc.T("Show"), FontSize = 9, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center }, sendsToggle, ioToggle, CompactToggle() },
+ Children = { new TextBlock { Text = Loc.T("common.show"), FontSize = 9, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center }, sendsToggle, ioToggle, CompactToggle() },
};
var divider = new Border { Width = 1, Height = 20, Background = BorderDef, VerticalAlignment = VerticalAlignment.Center };
@@ -665,7 +665,7 @@ public sealed partial class MixerView : UserControl
b.Background = lit ? Brass : NotaPalette.SurfaceRaised;
b.BorderBrush = lit || hiddenByHeight ? Brass : NotaPalette.Seam;
t.Foreground = lit ? OnAccent : hiddenByHeight ? TextTertiary : TextSecondary;
- ToolTip.SetTip(b, hiddenByHeight ? Loc.T("Hidden: not enough height · click to show anyway") : null);
+ ToolTip.SetTip(b, hiddenByHeight ? Loc.T("mixer.hidden_not_enough_height_click") : null);
}
b.PointerPressed += (_, e) =>
{
@@ -683,9 +683,9 @@ public sealed partial class MixerView : UserControl
// Compact strips (specs/070): a two-state key painted like the section toggles.
private Border CompactToggle()
{
- var t = new TextBlock { Text = Loc.T("Compact"), FontSize = 10, FontWeight = FontWeight.SemiBold, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
+ var t = new TextBlock { Text = Loc.T("common.compact"), FontSize = 10, FontWeight = FontWeight.SemiBold, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };
var b = new Border { Height = 22, Padding = new Thickness(8, 0), CornerRadius = NotaRadius.Control, BorderThickness = new Thickness(1), VerticalAlignment = VerticalAlignment.Center, Cursor = new Cursor(StandardCursorType.Hand), Child = t };
- ToolTip.SetTip(b, Loc.T("Show compact strips: more tracks on screen"));
+ ToolTip.SetTip(b, Loc.T("mixer.show_compact_strips_more_tracks"));
void Paint()
{
b.Background = _compact ? Brass : NotaPalette.SurfaceRaised;
@@ -753,8 +753,8 @@ public sealed partial class MixerView : UserControl
// badge for projects made before the law existed (they keep Balance until switched).
private Control PanLawGroup()
{
- var label = new TextBlock { Text = Loc.T("Pan law"), FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
- var seg = ClipEditorKit.Segments(new[] { Loc.T("Stereo"), Loc.T("Balance") }, _engine.PanLaw == PanLaw.Stereo ? 0 : 1, i =>
+ var label = new TextBlock { Text = Loc.T("mixer.pan_law"), FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
+ var seg = ClipEditorKit.Segments(new[] { Loc.T("mixer.stereo"), Loc.T("mixer.balance") }, _engine.PanLaw == PanLaw.Stereo ? 0 : 1, i =>
{
var law = i == 0 ? PanLaw.Stereo : PanLaw.Balance;
if (_engine.PanLaw != law) _engine.SetPanLaw(law); // one undo step
@@ -764,11 +764,11 @@ public sealed partial class MixerView : UserControl
_setLawSegment = set;
if (seg.Child is Panel buttons)
{
- string[] tips = { Loc.T("Panning moves the whole stereo image; nothing is dropped"), Loc.T("Panning attenuates the opposite channel (legacy behaviour)") };
+ string[] tips = { Loc.T("mixer.panning_moves_the_whole_stereo"), Loc.T("mixer.panning_attenuates_the_opposite_channel") };
for (int i = 0; i < buttons.Children.Count && i < tips.Length; i++) ToolTip.SetTip(buttons.Children[i], tips[i]);
}
_lawHint = new TextBlock { FontSize = 11, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
- _olderBadge = Tag(Loc.T("Older project"), 9, 0, 18, Loc.T("Projects saved before stereo pan law open with Balance so existing mixes do not change"));
+ _olderBadge = Tag(Loc.T("mixer.older_project"), 9, 0, 18, Loc.T("mixer.projects_saved_before_stereo_pan"));
return new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 10, VerticalAlignment = VerticalAlignment.Center,
@@ -788,8 +788,8 @@ public sealed partial class MixerView : UserControl
bool stereo = law == PanLaw.Stereo;
_setLawSegment?.Invoke(stereo ? 0 : 1);
if (_lawHint is not null)
- _lawHint.Text = stereo ? Loc.T("Pan moves the whole image of stereo tracks and returns")
- : Loc.T("Pan attenuates the opposite channel, as in earlier versions");
+ _lawHint.Text = stereo ? Loc.T("mixer.pan_moves_the_whole_image")
+ : Loc.T("mixer.pan_attenuates_the_opposite_channel");
if (_olderBadge is not null) _olderBadge.IsVisible = older && !stereo;
foreach (var b in _balBadges) b.IsVisible = stereo;
}
@@ -847,9 +847,9 @@ public sealed partial class MixerView : UserControl
DockPanel.SetDock(fold, Dock.Left);
line.Children.Add(fold);
var dots = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 3, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(3, 0, 0, 0) };
- group.SoloDot = Dot(NotaPalette.Solo, Loc.T("A hidden track is soloed"));
- group.ArmDot = Dot(NotaPalette.Record, Loc.T("A hidden track is armed"));
- group.ClipDot = Dot(NotaPalette.Danger, Loc.T("A hidden track clipped · click to clear"));
+ group.SoloDot = Dot(NotaPalette.Solo, Loc.T("mixer.a_hidden_track_is_soloed"));
+ group.ArmDot = Dot(NotaPalette.Record, Loc.T("mixer.a_hidden_track_is_armed"));
+ group.ClipDot = Dot(NotaPalette.Danger, Loc.T("mixer.a_hidden_track_clipped_click"));
group.ClipDot.PointerPressed += (_, e) => { e.Handled = true; _clipLatched.Remove(group.Id); group.ClipDot.IsVisible = false; };
dots.Children.Add(group.SoloDot); dots.Children.Add(group.ArmDot); dots.Children.Add(group.ClipDot);
DockPanel.SetDock(dots, Dock.Right);
@@ -877,7 +877,7 @@ public sealed partial class MixerView : UserControl
group.PaintFold = folded =>
{
glyph.Kind = folded ? GlyphKind.ChevronRight : GlyphKind.ChevronDown;
- string tip = folded ? Loc.F("Unfold group {0}", name) : Loc.F("Fold group {0}", name);
+ string tip = folded ? Loc.F("mixer.unfold_group", name) : Loc.F("mixer.fold_group", name);
ToolTip.SetTip(key, tip);
Avalonia.Automation.AutomationProperties.SetName(key, tip);
};
@@ -922,7 +922,7 @@ public sealed partial class MixerView : UserControl
cb.Items.Add(new ComboBoxItem { Content = new TextBlock { Text = label, FontSize = 8, TextTrimming = TextTrimming.CharacterEllipsis }, Padding = new Thickness(5, 1), MinHeight = 0 });
sources.Add(src);
}
- Add(Loc.T("None"), -1);
+ Add(Loc.T("common.none"), -1);
int n = _engine.TrackCount;
for (int i = 0; i < n; i++)
if (_engine.TryGetTrackInfo(i, out var ti) && ti.IsInstrument && ti.Id != id)
@@ -938,7 +938,7 @@ public sealed partial class MixerView : UserControl
if (compact) // one line: the selector alone, its label in the tooltip (specs/070)
{
cb.Height = 14;
- ToolTip.SetTip(cb, Loc.T("MIDI in"));
+ ToolTip.SetTip(cb, Loc.T("mixer.midi_in"));
return new Border { Height = IoH, BorderBrush = BorderInner, BorderThickness = new Thickness(0, 0, 0, 1), Padding = new Thickness(4, 2), Child = cb };
}
return new Border
@@ -949,7 +949,7 @@ public sealed partial class MixerView : UserControl
Spacing = 2,
Children =
{
- new TextBlock { Text = Loc.T("MIDI in"), FontSize = 8, Foreground = TextTertiary },
+ new TextBlock { Text = Loc.T("mixer.midi_in"), FontSize = 8, Foreground = TextTertiary },
cb,
},
},
@@ -969,7 +969,7 @@ public sealed partial class MixerView : UserControl
var f = new MiniFader(_engine.GetTrackSend(id, bus), 1.0) { VerticalAlignment = VerticalAlignment.Center };
int b = bus;
SendControl.Attach(f, _engine, id, b); // undoable, writes automation (specs/072)
- ValueEntry.Attach(f, f.EntryField(Loc.F("Send {0}", (char)('A' + b)), NotaNum.Pct));
+ ValueEntry.Attach(f, f.EntryField(Loc.F("common.send", (char)('A' + b)), NotaNum.Pct));
_sendFaders.Add((id, b, f));
Grid.SetColumn(f, 1); grid.Children.Add(f);
}
@@ -993,7 +993,7 @@ public sealed partial class MixerView : UserControl
knob.GestureBegin += undo.Begin;
Action<double> setPan = p => _engine.SetTrackPan(id, (float)p);
knob.PanChanged += p => undo.Change(p, setPan);
- ValueEntry.Attach(knob, knob.EntryField(Loc.T("Pan"), NotaNum.Pan));
+ ValueEntry.Attach(knob, knob.EntryField(Loc.T("common.pan"), NotaNum.Pan));
if (id > 0) // M9-C: record pan moves (master pan isn't an automation target)
{
knob.GestureBegin += () => _engine.BeginAutomationWrite(id, AutomationTarget.Pan, -1, -1, "");
@@ -1001,10 +1001,10 @@ public sealed partial class MixerView : UserControl
MidiLearn.Bind(knob, MidiTarget.TrackPan(id), "Track Pan");
}
knob.GestureEnd += undo.End;
- Control label = Mono(Loc.T("Pan"), TextTertiary);
+ Control label = Mono(Loc.T("common.pan"), TextTertiary);
if (isGroup) // groups keep their unity-centre balance whatever the project law (specs/006)
{
- var bal = Tag("BAL", 7, 0.84, 11, Loc.T("Groups keep a unity-centre balance so grouping stays level-transparent"));
+ var bal = Tag("BAL", 7, 0.84, 11, Loc.T("mixer.groups_keep_a_unity_centre"));
bal.IsVisible = _engine.PanLaw == PanLaw.Stereo;
_balBadges.Add(bal);
label = new StackPanel { Spacing = 2, VerticalAlignment = VerticalAlignment.Center, Children = { label, bal } };
@@ -1032,7 +1032,7 @@ public sealed partial class MixerView : UserControl
{
var fader = new VFader(vol, color);
var dbNum = DbField(vol);
- ToolTip.SetTip(dbNum, Loc.T("Set the gain — drag, or double-click to type"));
+ ToolTip.SetTip(dbNum, Loc.T("mixer.set_the_gain_drag_or"));
void SetVolume(double v) { if (id < 0) SetMasterVolume?.Invoke((float)v); else _engine.SetTrackVolume(id, (float)v); }
if (id < 0) { _masterFader = fader; _masterDb = dbNum; }
else { var sync = SyncOf(id); sync.Fader = fader; sync.Db = dbNum; }
@@ -1052,7 +1052,7 @@ public sealed partial class MixerView : UserControl
fader.GestureEnd += undo.End;
dbNum.GestureEnd += undo.End;
MidiLearn.Bind(fader, id > 0 ? MidiTarget.TrackVolume(id) : MidiTarget.MasterVolume, id > 0 ? "Track Volume" : "Master Volume");
- ValueEntry.Attach(fader, fader.EntryField(Loc.T("Volume"), v => NotaNum.GainDb(v, signed: true), 1.0));
+ ValueEntry.Attach(fader, fader.EntryField(Loc.T("common.volume"), v => NotaNum.GainDb(v, signed: true), 1.0));
db = dbNum;
meter = new MeterBar(); // the almanac stereo meter: 11 + 5 + 11
diff --git a/src/managed/Nota.App/MixerWindow.cs b/src/managed/Nota.App/MixerWindow.cs
index 1392637e..9706e03a 100644
--- a/src/managed/Nota.App/MixerWindow.cs
+++ b/src/managed/Nota.App/MixerWindow.cs
@@ -48,7 +48,7 @@ internal sealed class MixerWindow : NotaWindow
Close();
};
- Title = Loc.T("Mixer");
+ Title = Loc.T("common.mixer");
Width = 1040;
Height = 460;
MinWidth = 560;
@@ -61,10 +61,10 @@ internal sealed class MixerWindow : NotaWindow
// Title bar: caption left, the view switch centred; empty bar area drags the window.
var caption = new TextBlock
{
- Text = Loc.T("Mixer"), FontSize = NotaType.Name, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextPrimary,
+ Text = Loc.T("common.mixer"), FontSize = NotaType.Name, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextPrimary,
VerticalAlignment = VerticalAlignment.Center,
};
- var seg = ClipEditorKit.Segments(new[] { Loc.T("Strips"), Loc.T("Stereo map") }, view == MixerViewMode.StereoMap ? 1 : 0,
+ var seg = ClipEditorKit.Segments(new[] { Loc.T("mixer.strips"), Loc.T("common.stereo_map") }, view == MixerViewMode.StereoMap ? 1 : 0,
i => ViewPicked?.Invoke(i == 1 ? MixerViewMode.StereoMap : MixerViewMode.Strips), out _setViewSegment);
seg.HorizontalAlignment = HorizontalAlignment.Center;
seg.VerticalAlignment = VerticalAlignment.Center;
@@ -74,7 +74,7 @@ internal sealed class MixerWindow : NotaWindow
HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Center,
Content = new Glyph(GlyphKind.DockIn),
};
- ToolTip.SetTip(dockBtn, Loc.T("Dock the mixer in the main window"));
+ ToolTip.SetTip(dockBtn, Loc.T("mixer.dock_the_mixer_in_the"));
dockBtn.Click += (_, _) => DockRequested?.Invoke();
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto,*") };
grid.Children.Add(caption);
diff --git a/src/managed/Nota.App/ModularView.Scope.cs b/src/managed/Nota.App/ModularView.Scope.cs
index d8157423..f203810b 100644
--- a/src/managed/Nota.App/ModularView.Scope.cs
+++ b/src/managed/Nota.App/ModularView.Scope.cs
@@ -78,7 +78,7 @@ public sealed partial class ModularView
{
body = new TextBlock
{
- Text = Loc.T("Watches CV. Drag a modulator's CV out onto this node. For audio, put Lens on the chain."),
+ Text = Loc.T("modular.scope.watches_cv_drag_a_modulators"),
FontSize = 9, Foreground = Text3, TextWrapping = TextWrapping.Wrap, TextAlignment = TextAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(8, 0),
};
@@ -100,7 +100,7 @@ public sealed partial class ModularView
HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center,
};
var grip = new Border { Height = 9, Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.SizeNorthSouth), Child = line };
- ToolTip.SetTip(grip, Loc.T("Drag to resize the trace"));
+ ToolTip.SetTip(grip, Loc.T("modular.scope.drag_to_resize_the_trace"));
bool drag = false; double y0 = 0, h0 = 0;
grip.PointerEntered += (_, _) => line.Background = Text3;
grip.PointerExited += (_, _) => { if (!drag) line.Background = NotaPalette.Seam; };
@@ -153,9 +153,9 @@ public sealed partial class ModularView
};
wKnob.Format = f => Fmt(FromFrac(f));
wKnob.ValueChanged += f => { float v = FromFrac(f); e.ModulatorSet(t, modId, wField, v); wValue.Text = Fmt(v); };
- ValueEntry.Attach(wKnob, Loc.T("Window"), wValue);
- var syncChip = ToggleLabel(sync ? Loc.T("Sync") : "ms", sync ? Loc.T("The window is in beats at the tempo. Click for milliseconds")
- : Loc.T("The window is in milliseconds. Click to sync it to the beat"),
+ ValueEntry.Attach(wKnob, Loc.T("modular.scope.window"), wValue);
+ var syncChip = ToggleLabel(sync ? Loc.T("modular.sync") : "ms", sync ? Loc.T("modular.scope.the_window_is_in_beats")
+ : Loc.T("modular.scope.the_window_is_in_milliseconds"),
() => { e.ModulatorSet(t, modId, ScopeTrace.FieldSync, sync ? 0f : 1f); Changed?.Invoke(); refresh(); });
var windowCell = new StackPanel
{
@@ -171,8 +171,8 @@ public sealed partial class ModularView
var zKnob = new Knob(ScopeTrace.ZoomIndex(z0) / (double)last, 0) { Accent = true };
zKnob.Format = f => ScopeTrace.ZoomLabel(ZoomAt(f));
zKnob.ValueChanged += f => { int z = ZoomAt(f); e.ModulatorSet(t, modId, ScopeTrace.FieldZoom, z); zValue.Text = ScopeTrace.ZoomLabel(z); };
- ValueEntry.Attach(zKnob, Loc.T("Zoom"), zValue);
- var zoomCell = KnobCell(Loc.T("Zoom"), zKnob, zValue);
+ ValueEntry.Attach(zKnob, Loc.T("modular.scope.zoom"), zValue);
+ var zoomCell = KnobCell(Loc.T("modular.scope.zoom"), zKnob, zValue);
addTick(() =>
{
@@ -194,12 +194,12 @@ public sealed partial class ModularView
var chips = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 3, Margin = new Thickness(9, 0), VerticalAlignment = VerticalAlignment.Center };
void SetTrig(bool on) { e.ModulatorSet(t, modId, ScopeTrace.FieldTrigger, on ? 1f : 0f); Changed?.Invoke(); refresh(); }
- var free = SegChip(Loc.T("Free"), !trig, () => SetTrig(false));
- ToolTip.SetTip(free, Loc.T("Free running: the newest value is at the right"));
- var rise = SegChip(Loc.T("Rise"), trig, () => SetTrig(true));
- ToolTip.SetTip(rise, Loc.T("Trigger: start the trace where the input rises through 0, so a repeating shape holds still"));
- var freeze = SegChip(Loc.T("Freeze"), frozen, () => { SetScopeFrozen(t, modId, !frozen); refresh(); });
- ToolTip.SetTip(freeze, frozen ? Loc.T("Back to the live trace") : Loc.T("Hold the trace while the input keeps running"));
+ var free = SegChip(Loc.T("modular.free"), !trig, () => SetTrig(false));
+ ToolTip.SetTip(free, Loc.T("modular.scope.free_running_the_newest_value"));
+ var rise = SegChip(Loc.T("modular.scope.rise"), trig, () => SetTrig(true));
+ ToolTip.SetTip(rise, Loc.T("modular.scope.trigger_start_the_trace_where"));
+ var freeze = SegChip(Loc.T("common.freeze"), frozen, () => { SetScopeFrozen(t, modId, !frozen); refresh(); });
+ ToolTip.SetTip(freeze, frozen ? Loc.T("modular.scope.back_to_the_live_trace") : Loc.T("modular.scope.hold_the_trace_while_the"));
freeze.Margin = new Thickness(8, 0, 0, 0);
chips.Children.Add(free); chips.Children.Add(rise); chips.Children.Add(freeze);
@@ -218,7 +218,7 @@ public sealed partial class ModularView
private void OpenScopeWindow(int t, int modId, Control anchor)
{
if (_scopeWindows.TryGetValue((t, modId), out var open)) { open.Activate(); return; }
- var w = new ScopeWindow(this, _engine, t, modId, Loc.F("Scope {0} · {1}", modId, TrackName(t)));
+ var w = new ScopeWindow(this, _engine, t, modId, Loc.F("modular.scope.scope", modId, TrackName(t)));
_scopeWindows[(t, modId)] = w;
w.Closed += (_, _) => _scopeWindows.Remove((t, modId));
// After the click has finished (the button opens on release), owned by the window that
diff --git a/src/managed/Nota.App/ModularView.cs b/src/managed/Nota.App/ModularView.cs
index 2f28a424..f8abb581 100644
--- a/src/managed/Nota.App/ModularView.cs
+++ b/src/managed/Nota.App/ModularView.cs
@@ -60,8 +60,8 @@ public sealed partial class ModularView : UserControl
private readonly IAudioEngine _engine;
// toolbar / status widgets
- private readonly ToggleButton _trackBtn = Seg(Loc.T("Track"), true);
- private readonly ToggleButton _globalBtn = Seg(Loc.T("Global"), false);
+ private readonly ToggleButton _trackBtn = Seg(Loc.T("common.track"), true);
+ private readonly ToggleButton _globalBtn = Seg(Loc.T("modular.global"), false);
private readonly TextBlock _zoomLabel = new() { Text = "100\u2009%", FontSize = 10, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center };
private readonly TextBlock _status = new() { Text = "", FontSize = 10, Foreground = Text2, VerticalAlignment = VerticalAlignment.Center };
private readonly TextBlock _statusRight = new() { Text = "", FontSize = 10, Foreground = Text2, VerticalAlignment = VerticalAlignment.Center };
@@ -89,7 +89,7 @@ public sealed partial class ModularView : UserControl
// Shown on the canvas in Track view while no track is picked (an empty project).
private readonly TextBlock _emptyHint = new()
{
- Text = Loc.T("Pick a track to see its signal graph"), Classes = { "Caption" }, IsVisible = false,
+ Text = Loc.T("modular.pick_a_track_to_see"), Classes = { "Caption" }, IsVisible = false,
HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center,
};
@@ -127,7 +127,7 @@ public sealed partial class ModularView : UserControl
// hint + minimap overlays (screen-space, not transformed)
var hint = new TextBlock
{
- Text = MenuKit.Keys(Loc.T("Drag from a CV out onto a node to modulate it · Space + drag — pan · ⌘ + wheel — zoom · F — fit · Esc — show fewer")),
+ Text = MenuKit.Keys(Loc.T("modular.drag_from_a_cv_out")),
FontSize = 9, Foreground = Text4,
HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Bottom,
Margin = new Thickness(14, 0, 0, 14),
@@ -159,7 +159,7 @@ public sealed partial class ModularView : UserControl
// Middle row: track-list sidebar (Track view) + the canvas.
var header = new Border
{
- Height = 26, Child = new TextBlock { Text = Loc.T("Tracks"), FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(10, 0) },
+ Height = 26, Child = new TextBlock { Text = Loc.T("modular.tracks"), FontSize = 10, FontWeight = FontWeight.SemiBold, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(10, 0) },
BorderBrush = BorderDef, BorderThickness = new Thickness(0, 0, 0, 1),
};
var listCol = new DockPanel { LastChildFill = true };
@@ -268,14 +268,14 @@ public sealed partial class ModularView : UserControl
if (_engine.TryGetTrackInfo(i, out var ti) && !ti.IsGroup)
_sidebar.Children.Add(TrackRow(ti.Id, ti));
if (_sidebar.Children.Count == 0)
- _sidebar.Children.Add(new TextBlock { Text = Loc.T("No tracks yet"), Classes = { "Caption" }, Margin = new Thickness(10, 8) });
+ _sidebar.Children.Add(new TextBlock { Text = Loc.T("modular.no_tracks_yet"), Classes = { "Caption" }, Margin = new Thickness(10, 8) });
}
private Control TrackRow(int trackId, NotaTrackInfo ti)
{
bool active = trackId == _trackId;
string name = _engine.GetTrackName(trackId);
- if (string.IsNullOrEmpty(name)) name = ti.IsReturn ? Loc.F("Return {0}", trackId) : ti.IsInstrument ? Loc.F("Inst {0}", trackId) : Loc.F("Audio {0}", trackId);
+ if (string.IsNullOrEmpty(name)) name = ti.IsReturn ? Loc.F("common.return_n", trackId) : ti.IsInstrument ? Loc.F("modular.inst", trackId) : Loc.F("common.audio_n", trackId);
var color = ArrangementView.TrackBrush(ArrangementView.EffectiveColorIndex(_engine, trackId));
var row = new Border
{
@@ -381,7 +381,7 @@ public sealed partial class ModularView : UserControl
bool isInstrument = _engine.TryGetTrackInfo(TrackIndex(_trackId), out var ti) && ti.IsInstrument;
string trackName = _engine.GetTrackName(_trackId);
- if (string.IsNullOrEmpty(trackName)) trackName = isInstrument ? Loc.F("Instrument {0}", _trackId) : Loc.F("Audio {0}", _trackId);
+ if (string.IsNullOrEmpty(trackName)) trackName = isInstrument ? Loc.F("modular.instrument", _trackId) : Loc.F("common.audio_n", _trackId);
// Pre-scan incoming CV links (this track) so each modulated param gets its own input
// port on its node — built before the nodes so their port blocks know the count.
@@ -427,7 +427,7 @@ public sealed partial class ModularView : UserControl
}
else
{
- var src = SimpleNode("input", Loc.T("Audio in"), Sage, new Point(x, y),
+ var src = SimpleNode("input", Loc.T("modular.audio_in"), Sage, new Point(x, y),
audioIn: false, audioOut: true, midiIn: false, midiOut: false,
badge: "CLIPS", slot: Slot.Input);
AddNode(src);
@@ -447,7 +447,7 @@ public sealed partial class ModularView : UserControl
}
// 4) Track output.
- var outNode = SimpleNode("output", Loc.T("Track output"), Text1, new Point(x, y + 28),
+ var outNode = SimpleNode("output", Loc.T("modular.track_output"), Text1, new Point(x, y + 28),
audioIn: true, audioOut: false, midiIn: false, midiOut: false, badge: "MASTER", slot: Slot.Output);
AddNode(outNode);
if (prevAudio != null) _edgeList.Add(new GEdge(prevAudio, PortKind.Audio, outNode, PortKind.Audio));
@@ -517,10 +517,10 @@ public sealed partial class ModularView : UserControl
}
int edges = _edgeList.Count;
- _status.Text = Loc.F("{0} · {1} · {2}", trackName, Loc.F("{0} nodes", _nodes.Count), Loc.Plural(edges, "{0} edge", "{0} edges"));
+ _status.Text = Loc.F("modular.pattern_n", trackName, Loc.F("modular.nodes", _nodes.Count), Loc.Plural("modular.edges", edges));
var cfg = _engine.GetAudioConfig();
double ms = cfg.BufferFrames > 0 && cfg.SampleRate > 0 ? cfg.BufferFrames / cfg.SampleRate * 1000.0 : 0;
- _statusRight.Text = Loc.F("{0:0.0}\u2009kHz · {1} · {2:0.0}\u2009ms", _engine.SampleRate / 1000.0, cfg.BufferFrames, ms);
+ _statusRight.Text = Loc.F("modular.khz_ms", _engine.SampleRate / 1000.0, cfg.BufferFrames, ms);
// Re-apply selection to the surviving node (structural edits rebuild the nodes).
if (_selId != null)
@@ -578,11 +578,11 @@ public sealed partial class ModularView : UserControl
}
}
- _status.Text = Loc.F("Global · {0}", Loc.Plural(islands, "{0} island", "{0} islands"))
- + (xlinks > 0 ? Loc.F(" · {0}", Loc.Plural(xlinks, "{0} cross-track CV link", "{0} cross-track CV links")) : "");
+ _status.Text = Loc.F("modular.global_n", Loc.Plural("modular.islands", islands))
+ + (xlinks > 0 ? Loc.F("modular.pattern", Loc.Plural("modular.cross_track_cv_links", xlinks)) : "");
var cfg = _engine.GetAudioConfig();
double ms = cfg.BufferFrames > 0 && cfg.SampleRate > 0 ? cfg.BufferFrames / cfg.SampleRate * 1000.0 : 0;
- _statusRight.Text = Loc.F("{0:0.0}\u2009kHz · {1} · {2:0.0}\u2009ms", _engine.SampleRate / 1000.0, cfg.BufferFrames, ms);
+ _statusRight.Text = Loc.F("modular.khz_ms", _engine.SampleRate / 1000.0, cfg.BufferFrames, ms);
if (_selId != null) { var s = _nodes.FirstOrDefault(x => x.Id == _selId); if (s != null) SelectNode(s); }
_grid.InvalidateVisual();
_edges.InvalidateVisual();
@@ -594,7 +594,7 @@ public sealed partial class ModularView : UserControl
private GNode IslandNode(int trackId, int trackIndex, NotaTrackInfo ti)
{
string name = _engine.GetTrackName(trackId);
- if (string.IsNullOrEmpty(name)) name = Loc.F("Track {0}", trackId);
+ if (string.IsNullOrEmpty(name)) name = Loc.F("common.track_n", trackId);
var color = ArrangementView.TrackBrush(ArrangementView.EffectiveColorIndex(_engine, trackId));
int mfx = ti.IsInstrument ? _engine.TrackMidiEffectCount(trackId) : 0;
int dev = _engine.TrackDeviceCount(trackId);
@@ -622,7 +622,7 @@ public sealed partial class ModularView : UserControl
var meta = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center };
DockPanel.SetDock(meta, Dock.Left);
meta.Children.Add(new TextBlock { Text = n.Title, FontSize = 11, FontWeight = FontWeight.SemiBold, Foreground = Text1, VerticalAlignment = VerticalAlignment.Center });
- meta.Children.Add(new TextBlock { Text = Loc.F("{0} NODES", nodeCount), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center });
+ meta.Children.Add(new TextBlock { Text = Loc.F("modular.nodes_caps", nodeCount), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center });
head.Children.Add(meta);
if (cv > 0)
{
@@ -635,26 +635,26 @@ public sealed partial class ModularView : UserControl
col.Children.Add(Row(headBorder, 1));
// collapsed pipe: [source] —bar— [N devices ▸] —bar— [Out]
- string srcName = ti.IsInstrument ? (_engine.TrackInstrumentKind(trackId) >= 0 ? _engine.DeviceName(trackId, -1) : Loc.T("Instrument")) : Loc.T("Audio in");
+ string srcName = ti.IsInstrument ? (_engine.TrackInstrumentKind(trackId) >= 0 ? _engine.DeviceName(trackId, -1) : Loc.T("common.instrument")) : Loc.T("modular.audio_in");
var pipe = new Grid { Margin = new Thickness(10, 0), VerticalAlignment = VerticalAlignment.Center };
if (dev > 0)
{
pipe.ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto,*,Auto");
- var pill = IslandPill(Loc.Plural(dev, "{0} device →", "{0} devices →"));
+ var pill = IslandPill(Loc.Plural("modular.devices", dev));
pill.PointerPressed += (_, e) => { OpenTrack(trackId); e.Handled = true; };
Grid.SetColumn(pill, 2);
pipe.Children.Add(IslandChip(srcName, n.Stripe, 0));
pipe.Children.Add(Pipe(1));
pipe.Children.Add(pill);
pipe.Children.Add(Pipe(3));
- pipe.Children.Add(IslandChip(Loc.T("Out"), Text1, 4));
+ pipe.Children.Add(IslandChip(Loc.T("modular.out"), Text1, 4));
}
else
{
pipe.ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto");
pipe.Children.Add(IslandChip(srcName, n.Stripe, 0));
pipe.Children.Add(Pipe(1));
- pipe.Children.Add(IslandChip(Loc.T("Out"), Text1, 2));
+ pipe.Children.Add(IslandChip(Loc.T("modular.out"), Text1, 2));
}
col.Children.Add(Row(pipe, 2));
@@ -666,7 +666,7 @@ public sealed partial class ModularView : UserControl
for (int i = 0; i < show; i++)
{
int id = _engine.ModulatorIdAt(trackId, i);
- mrow.Children.Add(IslandChip(Loc.F("LFO {0}", id), Brass, -1));
+ mrow.Children.Add(IslandChip(Loc.F("modular.lfo_caps_n", id), Brass, -1));
}
if (mods > show) mrow.Children.Add(new TextBlock { Text = $"+{mods - show}", FontSize = 9, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center });
col.Children.Add(Row(mrow, 3));
@@ -726,7 +726,7 @@ public sealed partial class ModularView : UserControl
private GNode InstrumentNode(Point at, string trackName)
{
int kind = _engine.TrackInstrumentKind(_trackId);
- string name = kind >= 0 ? _engine.DeviceName(_trackId, -1) : Loc.T("Instrument");
+ string name = kind >= 0 ? _engine.DeviceName(_trackId, -1) : Loc.T("common.instrument");
var n = new GNode($"inst", name, Slate, at)
{
AudioOut = true, MidiIn = true, CvIn = true, Slot = Slot.Instrument, // params are CV targets
@@ -922,12 +922,12 @@ public sealed partial class ModularView : UserControl
private static (string title, string badge) ModKindLabel(int kind) => kind switch
{
- 1 => (Loc.T("Env"), "ENV"),
+ 1 => (Loc.T("modular.env"), "ENV"),
2 => ("MIDI", "MIDI"),
3 => ("ADSR", "ADSR"),
- 4 => (Loc.T("Macro"), "MACRO"),
- 5 => (Loc.T("Math"), "MATH"),
- 6 => (Loc.T("Scope"), "SCOPE"),
+ 4 => (Loc.T("modular.macro"), "MACRO"),
+ 5 => (Loc.T("modular.math"), "MATH"),
+ 6 => (Loc.T("modular.scope"), "SCOPE"),
_ => ("LFO", "LFO"),
};
@@ -957,45 +957,45 @@ public sealed partial class ModularView : UserControl
Grid grid;
if (kind == 4) // Macro: one manual knob (its value is the CV output)
{
- grid = KnobGrid(ModFieldCell(Loc.T("Macro"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
+ grid = KnobGrid(ModFieldCell(Loc.T("modular.macro"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
}
else if (kind == 3) // ADSR: Attack / Decay / Sustain / Release (+ Depth)
{
grid = KnobGrid(
- ModFieldCell(Loc.T("Attack"), modId, 6, 0.1f, 2000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
- ModFieldCell(Loc.T("Decay"), modId, 8, 1f, 2000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
- ModFieldCell(Loc.T("Sustain"), modId, 9, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"),
- ModFieldCell(Loc.T("Release"), modId, 7, 1f, 4000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
- ModFieldCell(Loc.T("Depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
+ ModFieldCell(Loc.T("common.attack"), modId, 6, 0.1f, 2000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
+ ModFieldCell(Loc.T("common.decay"), modId, 8, 1f, 2000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
+ ModFieldCell(Loc.T("common.sustain"), modId, 9, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"),
+ ModFieldCell(Loc.T("common.release"), modId, 7, 1f, 4000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
+ ModFieldCell(Loc.T("modular.depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
}
else if (kind == 1) // envelope follower: Attack / Release / Depth
{
grid = KnobGrid(
- ModFieldCell(Loc.T("Attack"), modId, 6, 0.1f, 500f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
- ModFieldCell(Loc.T("Release"), modId, 7, 1f, 2000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
- ModFieldCell(Loc.T("Depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
+ ModFieldCell(Loc.T("common.attack"), modId, 6, 0.1f, 500f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
+ ModFieldCell(Loc.T("common.release"), modId, 7, 1f, 2000f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
+ ModFieldCell(Loc.T("modular.depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
}
else if (kind == 2) // MIDI→CV: source select + Smooth / Depth
{
col.Children.Add(Row(MidiSourceRow(modId), 2));
grid = KnobGrid(
- ModFieldCell(Loc.T("Smooth"), modId, 6, 0.1f, 500f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
- ModFieldCell(Loc.T("Depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
+ ModFieldCell(Loc.T("modular.smooth"), modId, 6, 0.1f, 500f, v => v.ToString("0", NotaNum.Culture) + "\u2009ms"),
+ ModFieldCell(Loc.T("modular.depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"));
}
else // LFO: waveform + sync, then Rate / Depth / Phase
{
col.Children.Add(Row(WaveSyncRow(modId), 2));
grid = KnobGrid(
ModRateCell(modId),
- ModFieldCell(Loc.T("Depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"),
- ModFieldCell(Loc.T("Phase"), modId, 5, 0f, 1f, v => (v * 360).ToString("0", NotaNum.Culture) + "°"));
+ ModFieldCell(Loc.T("modular.depth"), modId, 4, 0f, 1f, v => (v * 100).ToString("0", NotaNum.Culture) + "\u2009%"),
+ ModFieldCell(Loc.T("modular.phase"), modId, 5, 0f, 1f, v => (v * 360).ToString("0", NotaNum.Culture) + "°"));
}
col.Children.Add(Row(grid, gridRow));
col.Children.Add(Row(PortsBlock(n), gridRow + 1));
WrapFrame(n, col, headBorder);
}
- private static readonly string[] MathOpNames = { Loc.T("Add"), Loc.T("Subtract"), Loc.T("Multiply"), Loc.T("Invert"), Loc.T("Scale"), Loc.T("Min"), Loc.T("Max") };
+ private static readonly string[] MathOpNames = { Loc.T("modular.add_2"), Loc.T("modular.subtract"), Loc.T("modular.multiply"), Loc.T("modular.invert"), Loc.T("modular.scale"), Loc.T("common.min"), Loc.T("modular.max") };
private void BuildMathView(GNode n, int modId)
{
@@ -1007,8 +1007,8 @@ public sealed partial class ModularView : UserControl
var body = new StackPanel { Spacing = 4, Margin = new Thickness(9, 6) };
body.Children.Add(MathLabeledRow("Op", MathOpCombo(modId)));
body.Children.Add(KnobGrid(
- ModFieldCell(Loc.T("Gain"), modId, 4, 0f, 2f, v => v.ToString("0.00", NotaNum.Culture)),
- ModFieldCell(Loc.T("Offset"), modId, 12, -1f, 1f, v => v.ToString("0.00", NotaNum.Culture))));
+ ModFieldCell(Loc.T("modular.gain"), modId, 4, 0f, 2f, v => v.ToString("0.00", NotaNum.Culture)),
+ ModFieldCell(Loc.T("modular.offset"), modId, 12, -1f, 1f, v => v.ToString("0.00", NotaNum.Culture))));
col.Children.Add(Row(body, 2));
col.Children.Add(Row(MathPortsBlock(n), 3)); // A/B CV inputs (drag a cable in) + CV out
WrapFrame(n, col, headBorder);
@@ -1018,7 +1018,7 @@ public sealed partial class ModularView : UserControl
private Control MathPortsBlock(GNode n)
{
var stack = new StackPanel { Margin = new Thickness(0, 6, 0, 6) };
- stack.Children.Add(PortRowUI(left: ("A", Brass, true), right: (Loc.T("CV out"), Brass, true), rightPress: e => BeginConnect(n, e)));
+ stack.Children.Add(PortRowUI(left: ("A", Brass, true), right: (Loc.T("modular.cv_out"), Brass, true), rightPress: e => BeginConnect(n, e)));
stack.Children.Add(PortRowUI(left: ("B", Brass, true), right: null));
return new Border { Child = stack, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 1, 0, 0) };
}
@@ -1043,7 +1043,7 @@ public sealed partial class ModularView : UserControl
return combo;
}
- private static readonly string[] MidiSourceNames = { Loc.T("Vel"), Loc.T("Gate"), Loc.T("Note") };
+ private static readonly string[] MidiSourceNames = { Loc.T("modular.vel"), Loc.T("common.gate"), Loc.T("modular.note") };
private Control MidiSourceRow(int modId)
{
@@ -1077,7 +1077,7 @@ public sealed partial class ModularView : UserControl
return grid;
}
- private static readonly string[] WaveNames = { Loc.T("Sine"), Loc.T("Tri"), Loc.T("Saw"), Loc.T("Sqr"), Loc.T("Rnd") };
+ private static readonly string[] WaveNames = { Loc.T("modular.sine"), Loc.T("modular.tri"), Loc.T("modular.saw"), Loc.T("modular.sqr"), Loc.T("modular.rnd") };
// LFO waveform selector. The Sync/Free toggle used to live here too, but with five
// waveform chips it overflowed the node width — it now sits above the Rate knob (ModRateCell).
@@ -1096,7 +1096,7 @@ public sealed partial class ModularView : UserControl
// A compact Sync/Free toggle used as the Rate cell's label (14px so it fits the knob row).
private Border SyncToggle(int modId, bool synced) =>
- ToggleLabel(synced ? Loc.T("Sync") : Loc.T("Free"), null, () => { _engine.ModulatorSet(_trackId, modId, 1, synced ? 0f : 1f); Rebuild(); });
+ ToggleLabel(synced ? Loc.T("modular.sync") : Loc.T("modular.free"), null, () => { _engine.ModulatorSet(_trackId, modId, 1, synced ? 0f : 1f); Rebuild(); });
// A small clickable label chip over a knob (Sync/Free, the Scope's ms/Sync).
private static Border ToggleLabel(string text, string? tip, Action onClick)
@@ -1167,7 +1167,7 @@ public sealed partial class ModularView : UserControl
float cur = e.ModulatorGet(t, modId, field); double frac = (cur - min) / span;
if (Math.Abs(frac - knob.Value) > 1e-3) { knob.Value = frac; value.Text = fmt(cur); }
});
- ValueEntry.Attach(knob, Loc.T("Rate"), value);
+ ValueEntry.Attach(knob, Loc.T("modular.rate"), value);
return new StackPanel
{
Spacing = 0, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center,
@@ -1177,7 +1177,7 @@ public sealed partial class ModularView : UserControl
private static string DivisionLabel(double beats)
{
- if (beats >= 3.5) return Loc.T("1 bar");
+ if (beats >= 3.5) return Loc.T("common.1_bar");
int denom = (int)Math.Round(4.0 / Math.Max(0.0625, beats));
return "1/" + Math.Clamp(denom, 1, 64);
}
@@ -1188,7 +1188,7 @@ public sealed partial class ModularView : UserControl
{
int t = _trackId; var e = _engine;
var flyout = new MenuFlyout();
- flyout.Items.Add(MenuKit.Header(paramName, null, Loc.T("Parameter")));
+ flyout.Items.Add(MenuKit.Header(paramName, null, Loc.T("modular.parameter")));
flyout.Items.Add(new Separator());
// Type value… / Reset to default first, as on every parameter (specs/035).
foreach (var c in ValueEntry.MenuItems(anchor)) flyout.Items.Add(c);
@@ -1203,11 +1203,11 @@ public sealed partial class ModularView : UserControl
bool cross = e.CvLinkTargetTrack(owner, li) >= 0;
string srcLabel = e.CvLinkSourceKind(owner, li) == 1
? e.DeviceParamName(owner, e.CvLinkSourceDevice(owner, li), e.CvLinkSourceParam(owner, li))
- : Loc.F("LFO {0}", e.CvLinkSource(owner, li));
- var edit = new MenuItem { Header = Loc.F("Edit modulation · {0}…", srcLabel + (cross ? " (" + TrackName(owner) + ")" : "")) };
+ : Loc.F("modular.lfo_caps_n", e.CvLinkSource(owner, li));
+ var edit = new MenuItem { Header = Loc.F("modular.edit_modulation", srcLabel + (cross ? " (" + TrackName(owner) + ")" : "")) };
edit.Click += (_, _) => ShowLinkEditor(anchor, owner, li);
flyout.Items.Add(edit);
- remove = MenuKit.Danger(Loc.T("Remove modulation"), null,
+ remove = MenuKit.Danger(Loc.T("modular.remove_modulation"), null,
() => { e.CvLinkRemove(owner, li); Rebuild(); Changed?.Invoke(); });
}
else
@@ -1218,7 +1218,7 @@ public sealed partial class ModularView : UserControl
for (int i = 0; i < mc; i++)
{
int modId = e.ModulatorIdAt(t, i);
- var mi = new MenuItem { Header = Loc.F("Modulate with {0} {1}", e.ModulatorKind(t, modId) == 1 ? "Env" : "LFO", modId) };
+ var mi = new MenuItem { Header = Loc.F("modular.modulate_with", e.ModulatorKind(t, modId) == 1 ? "Env" : "LFO", modId) };
mi.Click += (_, _) => { e.CvLinkAddToTarget(t, modId, targetKind, -1, device, param); Rebuild(); Changed?.Invoke(); };
flyout.Items.Add(mi); sources++;
}
@@ -1228,13 +1228,13 @@ public sealed partial class ModularView : UserControl
{
if (xt != t || (xd == device && xp == param)) continue;
int sd = xd, sp = xp;
- var mi = new MenuItem { Header = Loc.F("From {0} · {1}", e.DeviceName(t, sd), e.DeviceParamName(t, sd, sp)) };
+ var mi = new MenuItem { Header = Loc.F("modular.from", e.DeviceName(t, sd), e.DeviceParamName(t, sd, sp)) };
mi.Click += (_, _) => { e.CvLinkAddFromParamToTarget(t, sd, sp, targetKind, -1, device, param); Rebuild(); Changed?.Invoke(); };
paramSrc.Add(mi);
}
if (paramSrc.Count > 0)
{
- var sub = new MenuItem { Header = Loc.T("Modulate from a parameter") };
+ var sub = new MenuItem { Header = Loc.T("modular.modulate_from_a_parameter") };
foreach (var it in paramSrc) sub.Items.Add(it);
flyout.Items.Add(sub); sources++;
}
@@ -1255,12 +1255,12 @@ public sealed partial class ModularView : UserControl
}
if (cross_.Count > 0)
{
- var sub = new MenuItem { Header = Loc.T("Modulate from another track") };
+ var sub = new MenuItem { Header = Loc.T("modular.modulate_from_another_track") };
foreach (var it in cross_) sub.Items.Add(it);
flyout.Items.Add(sub); sources++;
}
if (sources == 0)
- flyout.Items.Add(new MenuItem { Header = Loc.T("Add an LFO / expose a param first"), IsEnabled = false });
+ flyout.Items.Add(new MenuItem { Header = Loc.T("modular.add_an_lfo_expose_a"), IsEnabled = false });
}
// Expose toggle — only device params can be CV sources (param source is device-only).
@@ -1268,7 +1268,7 @@ public sealed partial class ModularView : UserControl
{
flyout.Items.Add(new Separator());
bool exposed = _exposedParams.Contains((t, device, param));
- var ex = new MenuItem { Header = exposed ? Loc.T("Unexpose CV output") : Loc.T("Expose as CV output") };
+ var ex = new MenuItem { Header = exposed ? Loc.T("modular.unexpose_cv_output") : Loc.T("modular.expose_as_cv_output") };
ex.Click += (_, _) => { if (!_exposedParams.Remove((t, device, param))) _exposedParams.Add((t, device, param)); Rebuild(); };
flyout.Items.Add(ex);
}
@@ -1306,7 +1306,7 @@ public sealed partial class ModularView : UserControl
private string TrackName(int trackId)
{
string nm = _engine.GetTrackName(trackId);
- return string.IsNullOrEmpty(nm) ? Loc.F("Track {0}", trackId) : nm;
+ return string.IsNullOrEmpty(nm) ? Loc.F("common.track_n", trackId) : nm;
}
// CV-link depth + mode popover (mockup 1d). The link is owned by ownerTrack.
@@ -1324,7 +1324,7 @@ public sealed partial class ModularView : UserControl
{
var title = new TextBlock { Text = e.Tip, FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = Text3, TextWrapping = TextWrapping.Wrap };
var flyout = new Flyout { Placement = Avalonia.Controls.PlacementMode.Pointer };
- var remove = new Button { Content = Loc.T("Remove connection"), FontSize = 10, HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center };
+ var remove = new Button { Content = Loc.T("modular.remove_connection"), FontSize = 10, HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center };
remove.Click += (_, _) => { flyout.Hide(); RemoveModInputEdge(e); };
flyout.Content = new StackPanel { Spacing = 8, Width = 200, Children = { title, remove } };
flyout.ShowAt(_edges);
@@ -1340,18 +1340,18 @@ public sealed partial class ModularView : UserControl
{
int t = ownerTrack; var e = _engine;
int modId = e.CvLinkSource(t, linkIndex);
- var title = new TextBlock { Text = Loc.F("CV LINK · LFO {0}", modId), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = Text3 };
+ var title = new TextBlock { Text = Loc.F("modular.cv_link_lfo_caps", modId), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = Text3 };
var depth = new Slider { Minimum = -1, Maximum = 1, Value = e.CvLinkDepth(t, linkIndex), Width = 180, SmallChange = 0.05, LargeChange = 0.2 };
var depthVal = MonoValue(((int)Math.Round(e.CvLinkDepth(t, linkIndex) * 100)) + "\u2009%");
depth.PropertyChanged += (_, ev) => { if (ev.Property == Slider.ValueProperty) { e.SetCvLinkDepth(t, linkIndex, (float)depth.Value); depthVal.Text = ((int)Math.Round(depth.Value * 100)) + "\u2009%"; } };
var depthRow = new DockPanel { LastChildFill = true };
- var dl = new TextBlock { Text = Loc.T("Depth"), FontSize = 8, FontWeight = FontWeight.SemiBold, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 8, 0) };
+ var dl = new TextBlock { Text = Loc.T("modular.depth"), FontSize = 8, FontWeight = FontWeight.SemiBold, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 8, 0) };
DockPanel.SetDock(dl, Dock.Left); DockPanel.SetDock(depthVal, Dock.Right);
depthRow.Children.Add(dl); depthRow.Children.Add(depthVal); depthRow.Children.Add(depth);
var modeRow = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 3 };
- var modeNames = new[] { Loc.T("Add"), Loc.T("Multiply"), Loc.T("Override") };
+ var modeNames = new[] { Loc.T("modular.add_2"), Loc.T("modular.multiply"), Loc.T("modular.override") };
int curMode = e.CvLinkMode(t, linkIndex);
var chips = new Border[3];
void SyncModes(int sel) { for (int i = 0; i < 3; i++) { bool on = i == sel; chips[i].Background = on ? NotaPalette.Accent : Brushes.Transparent; chips[i].BorderBrush = on ? NotaPalette.Accent : BorderStrong; ((TextBlock)chips[i].Child!).Foreground = on ? BrassBright : Text2; } }
@@ -1363,10 +1363,10 @@ public sealed partial class ModularView : UserControl
}
var flyout = new Flyout { Placement = atPointer ? Avalonia.Controls.PlacementMode.Pointer : Avalonia.Controls.PlacementMode.Bottom };
- var remove = new Button { Content = Loc.T("Remove modulation"), FontSize = 10, HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center };
+ var remove = new Button { Content = Loc.T("modular.remove_modulation"), FontSize = 10, HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center };
remove.Click += (_, _) => { flyout.Hide(); e.CvLinkRemove(t, linkIndex); Rebuild(); Changed?.Invoke(); };
- var panel = new StackPanel { Spacing = 8, Width = 220, Children = { title, depthRow, new TextBlock { Text = Loc.T("Mode"), FontSize = 8, FontWeight = FontWeight.SemiBold, Foreground = Text3 }, modeRow, remove } };
+ var panel = new StackPanel { Spacing = 8, Width = 220, Children = { title, depthRow, new TextBlock { Text = Loc.T("modular.mode"), FontSize = 8, FontWeight = FontWeight.SemiBold, Foreground = Text3 }, modeRow, remove } };
flyout.Content = panel;
flyout.ShowAt(anchor);
}
@@ -1406,12 +1406,12 @@ public sealed partial class ModularView : UserControl
if (n.IsChainDevice)
{
var actions = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4, VerticalAlignment = VerticalAlignment.Center };
- actions.Children.Add(HeaderGlyph(GlyphKind.Bypass, n.Bypassed ? BrassBright : Text3, Loc.T("Bypass (B)"), () => ToggleBypass(n)));
+ actions.Children.Add(HeaderGlyph(GlyphKind.Bypass, n.Bypassed ? BrassBright : Text3, Loc.T("modular.bypass_b"), () => ToggleBypass(n)));
// Only offer expand when there are more params than the headline row shows,
// otherwise the button reveals nothing (e.g. a plugin exposing few params).
if (CanExpand(n) || _expanded.Contains(n.Id)) actions.Children.Add(ExpandGlyph(n));
// A bin, not ×: an × reads as "close", and closing the opened knobs deleted the device (#261).
- actions.Children.Add(HeaderGlyph(GlyphKind.Trash, Text3, Loc.T("Delete (⌫)"), () => DeleteNode(n)));
+ actions.Children.Add(HeaderGlyph(GlyphKind.Trash, Text3, Loc.T("modular.delete"), () => DeleteNode(n)));
DockPanel.SetDock(actions, Dock.Right);
head.Children.Add(actions);
}
@@ -1427,17 +1427,17 @@ public sealed partial class ModularView : UserControl
else if (n.Slot == Slot.Modulator)
{
var actions = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, VerticalAlignment = VerticalAlignment.Center };
- actions.Children.Add(new TextBlock { Text = string.IsNullOrEmpty(n.Badge) ? Loc.T("LFO") : NotaText.Label(n.Badge), FontSize = 9, FontWeight = FontWeight.Medium, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center });
+ actions.Children.Add(new TextBlock { Text = string.IsNullOrEmpty(n.Badge) ? Loc.T("modular.lfo_caps") : NotaText.Label(n.Badge), FontSize = 9, FontWeight = FontWeight.Medium, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center });
if (n.IsScopeNode)
{
int scopeTrack = _trackId, scopeMod = n.ModId;
Control? pop = null;
// Opens on release: opened on the press, the release raises the main window over it (macOS).
- pop = HeaderGlyph(GlyphKind.PopOut, Text3, Loc.T("Open in a window"), () => { });
+ pop = HeaderGlyph(GlyphKind.PopOut, Text3, Loc.T("modular.open_in_a_window"), () => { });
pop.PointerReleased += (_, e) => { OpenScopeWindow(scopeTrack, scopeMod, pop!); e.Handled = true; };
actions.Children.Add(pop);
}
- actions.Children.Add(HeaderGlyph(GlyphKind.Trash, Text3, Loc.T("Delete (⌫)"), () => RemoveModulatorNode(n)));
+ actions.Children.Add(HeaderGlyph(GlyphKind.Trash, Text3, Loc.T("modular.delete"), () => RemoveModulatorNode(n)));
DockPanel.SetDock(actions, Dock.Right);
head.Children.Add(actions);
}
@@ -1520,7 +1520,7 @@ public sealed partial class ModularView : UserControl
private Control CollapseStrip(GNode n)
{
- var text = new TextBlock { Text = Loc.T("Show fewer"), FontSize = 9, FontWeight = FontWeight.Medium, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center };
+ var text = new TextBlock { Text = Loc.T("modular.show_fewer"), FontSize = 9, FontWeight = FontWeight.Medium, Foreground = Text3, VerticalAlignment = VerticalAlignment.Center };
var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 5, HorizontalAlignment = HorizontalAlignment.Center,
Children = { new Glyph(GlyphKind.ChevronUp, 8) { Foreground = Text3, VerticalAlignment = VerticalAlignment.Center }, text } };
var strip = new Border
@@ -1528,7 +1528,7 @@ public sealed partial class ModularView : UserControl
Height = 22, Background = Brushes.Transparent, BorderBrush = BorderInner, BorderThickness = new Thickness(0, 1, 0, 0),
Cursor = new Cursor(StandardCursorType.Hand), Child = row,
};
- ToolTip.SetTip(strip, Loc.T("Hide the parameters that aren't modulated (Esc)"));
+ ToolTip.SetTip(strip, Loc.T("modular.hide_the_parameters_that_arent"));
strip.PointerEntered += (_, _) => text.Foreground = Text1;
strip.PointerExited += (_, _) => text.Foreground = Text3;
strip.PointerPressed += (_, e) => { if (!e.GetCurrentPoint(strip).Properties.IsLeftButtonPressed) return; ToggleExpand(n); e.Handled = true; };
@@ -1541,13 +1541,13 @@ public sealed partial class ModularView : UserControl
// audio row (skipped for CV-only nodes like modulators)
if (n.AudioIn || n.AudioOut)
stack.Children.Add(PortRowUI(
- left: n.AudioIn ? (Loc.T("Audio in"), Sage, true) : null,
- right: n.AudioOut ? (Loc.T("Audio out"), Sage, true) : null));
+ left: n.AudioIn ? (Loc.T("modular.audio_in"), Sage, true) : null,
+ right: n.AudioOut ? (Loc.T("modular.audio_out"), Sage, true) : null));
// midi row
if (n.MidiIn || n.MidiOut)
stack.Children.Add(PortRowUI(
- left: n.MidiIn ? (Loc.T("MIDI in"), Slate, false) : null,
- right: n.MidiOut ? (Loc.T("MIDI out"), Slate, false) : null));
+ left: n.MidiIn ? (Loc.T("modular.midi_in"), Slate, false) : null,
+ right: n.MidiOut ? (Loc.T("modular.midi_out"), Slate, false) : null));
// cv row (Phase 3): only drawn for ports that actually function — a real CV
// target (CvIn) and/or a real CV source (CvOut). Nodes with no CV role (LFO
// input, audio-only nodes) show nothing, so the graph never lies. A
@@ -1566,7 +1566,7 @@ public sealed partial class ModularView : UserControl
if (n.CvOut)
{
Action<PointerPressedEventArgs>? cvOutPress = n.Slot == Slot.Modulator ? e => BeginConnect(n, e) : null;
- stack.Children.Add(PortRowUI(left: null, right: (Loc.T("CV out"), Brass, true), rightPress: cvOutPress));
+ stack.Children.Add(PortRowUI(left: null, right: (Loc.T("modular.cv_out"), Brass, true), rightPress: cvOutPress));
}
return new Border { Child = stack, BorderBrush = BorderDef, BorderThickness = new Thickness(0, 1, 0, 0) };
}
@@ -1799,7 +1799,7 @@ public sealed partial class ModularView : UserControl
mi.Click += (_, _) => { _engine.CvLinkAddToTarget(t, modId, kind, -1, di, prm); Rebuild(); Changed?.Invoke(); };
flyout.Items.Add(mi);
}
- if (pc == 0) flyout.Items.Add(new MenuItem { Header = Loc.T("No parameters"), IsEnabled = false });
+ if (pc == 0) flyout.Items.Add(new MenuItem { Header = Loc.T("modular.no_parameters"), IsEnabled = false });
flyout.ShowAt(node.View, showAtPointer: true);
}
@@ -1839,7 +1839,7 @@ public sealed partial class ModularView : UserControl
int dc = e.TrackDeviceCount(targetTrackId);
for (int d = 0; d < dc; d++) AddDeviceSub(e.DeviceName(targetTrackId, d), 0, d, e.DeviceParamCount(targetTrackId, d));
- if (flyout.Items.Count == 0) flyout.Items.Add(new MenuItem { Header = Loc.T("No modulatable parameters on that track"), IsEnabled = false });
+ if (flyout.Items.Count == 0) flyout.Items.Add(new MenuItem { Header = Loc.T("modular.no_modulatable_parameters_on_that"), IsEnabled = false });
flyout.ShowAt(anchor, showAtPointer: true);
}
@@ -1915,9 +1915,9 @@ public sealed partial class ModularView : UserControl
// lock in the header says why (#261). Null for a node that can be deleted.
private static string? FixedReason(GNode n) => n.Slot switch
{
- Slot.Input => Loc.T("Fixed — the track's clips and input enter the chain here, so it can't be deleted."),
- Slot.Output => Loc.T("Fixed — the chain leaves the track for the mixer here, so it can't be deleted."),
- Slot.Instrument => Loc.T("Fixed — the track's instrument takes its MIDI in. It can't be deleted; drop another instrument on the track to swap it."),
+ Slot.Input => Loc.T("modular.fixed_the_tracks_clips_and"),
+ Slot.Output => Loc.T("modular.fixed_the_chain_leaves_the"),
+ Slot.Instrument => Loc.T("modular.fixed_the_tracks_instrument_takes"),
_ => null,
};
@@ -1933,7 +1933,7 @@ public sealed partial class ModularView : UserControl
{
bool open = _expanded.Contains(n.Id);
return HeaderGlyph(open ? GlyphKind.ChevronUp : GlyphKind.ChevronDown, open ? BrassBright : Text3,
- open ? Loc.T("Show fewer parameters (Esc)") : Loc.T("Show all parameters"), () => ToggleExpand(n));
+ open ? Loc.T("modular.show_fewer_parameters_esc") : Loc.T("modular.show_all_parameters"), () => ToggleExpand(n));
}
private GNode? Selected() { foreach (var n in _nodes) if (n.Selected) return n; return null; }
@@ -2140,7 +2140,7 @@ public sealed partial class ModularView : UserControl
addMenu.Items.Add(mi);
}
foreach (var node in Nota.Application.Palette.ModularCatalog.All) AddItem(node.Name, node.Kind); // the palette lists the same nodes
- var addBtn = Chip(Loc.T("+ Add")); addBtn.Content = Glyph.Labeled(Loc.T("+ Add"), GlyphKind.ChevronDown);
+ var addBtn = Chip(Loc.T("modular.add")); addBtn.Content = Glyph.Labeled(Loc.T("modular.add"), GlyphKind.ChevronDown);
addBtn.Flyout = addMenu;
left.Children.Add(seg);
left.Children.Add(addBtn);
@@ -2153,7 +2153,7 @@ public sealed partial class ModularView : UserControl
Background = Sunken, CornerRadius = NotaRadius.Tile, Padding = new Thickness(2),
Child = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 2, Children = { zoomOut, zoomIn } },
};
- var fit = Chip(Loc.T("Fit")); fit.Click += (_, _) => FitNow();
+ var fit = Chip(Loc.T("modular.fit")); fit.Click += (_, _) => FitNow();
right.Children.Add(zoomSeg);
right.Children.Add(fit);
right.Children.Add(_zoomLabel);
diff --git a/src/managed/Nota.App/MosaicCreateWindow.cs b/src/managed/Nota.App/MosaicCreateWindow.cs
index 17d1218a..d0cd4d64 100644
--- a/src/managed/Nota.App/MosaicCreateWindow.cs
+++ b/src/managed/Nota.App/MosaicCreateWindow.cs
@@ -57,15 +57,15 @@ public sealed class MosaicCreateWindow : NotaWindow
_packs = packs;
_inputs = inputs;
_folderName = inputs.Count == 1 && Directory.Exists(inputs[0]) ? Path.GetFileName(inputs[0].TrimEnd('/', '\\'))
- : Path.GetFileName(Path.GetDirectoryName(inputs.FirstOrDefault() ?? "") ?? Loc.T("Multisamples"));
- if (string.IsNullOrWhiteSpace(_folderName)) _folderName = Loc.T("Multisamples");
- Title = Loc.T("Create multisample");
+ : Path.GetFileName(Path.GetDirectoryName(inputs.FirstOrDefault() ?? "") ?? Loc.T("mosaic_create.multisamples"));
+ if (string.IsNullOrWhiteSpace(_folderName)) _folderName = Loc.T("mosaic_create.multisamples");
+ Title = Loc.T("mosaic_create.create_multisample");
Width = 860; Height = 520; MinWidth = 760; MinHeight = 440;
WindowStartupLocation = WindowStartupLocation.CenterOwner;
Background = NotaPalette.BgApp;
var head = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto"), ColumnSpacing = 12, Margin = new Thickness(12, 8) };
- head.Children.Add(new TextBlock { Text = Loc.T("Create multisample"), FontSize = 11, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center });
+ head.Children.Add(new TextBlock { Text = Loc.T("mosaic_create.create_multisample"), FontSize = 11, FontWeight = FontWeight.SemiBold, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center });
var crumb = Mono(breadcrumb ?? _folderName, TextTertiary, 8.5);
Grid.SetColumn(crumb, 1); head.Children.Add(crumb);
Grid.SetColumn(_headerInfo, 2); head.Children.Add(_headerInfo);
@@ -76,9 +76,9 @@ public sealed class MosaicCreateWindow : NotaWindow
Spacing = 6, Width = 210,
Children =
{
- Panel(Loc.T("Instruments"), new ScrollViewer { Content = _instList, MaxHeight = 190, HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Disabled }, Loc.T("by name stem")),
- Panel(Loc.T("Octave"), _octave),
- Panel(Loc.T("Mapping"), _mapping),
+ Panel(Loc.T("common.instruments"), new ScrollViewer { Content = _instList, MaxHeight = 190, HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Disabled }, Loc.T("mosaic_create.by_name_stem")),
+ Panel(Loc.T("mosaic_create.octave"), _octave),
+ Panel(Loc.T("mosaic_create.mapping"), _mapping),
},
};
@@ -86,14 +86,14 @@ public sealed class MosaicCreateWindow : NotaWindow
var legend = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 10, VerticalAlignment = VerticalAlignment.Center,
- Children = { LegendItem("stretched", NotaPalette.TextTertiary), LegendItem(Loc.T("next to gap"), NotaPalette.Danger), LegendItem("low confidence", NotaPalette.Warning) },
+ Children = { LegendItem("stretched", NotaPalette.TextTertiary), LegendItem(Loc.T("mosaic_create.next_to_gap"), NotaPalette.Danger), LegendItem("low confidence", NotaPalette.Warning) },
};
var instHead = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,Auto,*,Auto"), ColumnSpacing = 8, Margin = new Thickness(0, 0, 0, 4) };
instHead.Children.Add(_instTitle);
Grid.SetColumn(_instSub, 1); instHead.Children.Add(_instSub);
Grid.SetColumn(legend, 3); instHead.Children.Add(legend);
_map.Height = 150;
- var tableHead = TableRow(Loc.T("File"), "NOTE", "LAYER", "RR", "RELEASE", "CONF", "", TextTertiary, caps: true);
+ var tableHead = TableRow(Loc.T("common.file"), "NOTE", "LAYER", "RR", "RELEASE", "CONF", "", TextTertiary, caps: true);
var table = new Grid { RowDefinitions = new RowDefinitions("Auto,*") };
table.Children.Add(tableHead);
var scroll = new ScrollViewer { Content = _rows };
@@ -109,7 +109,7 @@ public sealed class MosaicCreateWindow : NotaWindow
mid.Children.Add(new ScrollViewer { Content = left, HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Disabled });
Grid.SetColumn(rightBox, 1); mid.Children.Add(rightBox);
- var cancel = new Button { Content = Loc.T("Cancel"), Classes = { "ghost" } };
+ var cancel = new Button { Content = Loc.T("common.cancel"), Classes = { "ghost" } };
cancel.Click += (_, _) => Close();
_create.Click += (_, _) => Create();
var foot = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto,Auto"), ColumnSpacing = 8, Margin = new Thickness(12, 0, 12, 10) };
@@ -123,10 +123,10 @@ public sealed class MosaicCreateWindow : NotaWindow
Grid.SetRow(foot, 2); root.Children.Add(foot);
SetBody(root);
- _instTitle.Text = Loc.T("Reading the files…");
+ _instTitle.Text = Loc.T("mosaic_create.reading_the_files");
_create.IsEnabled = false;
- _create.Content = Loc.T("Create presets");
- _where.Text = Loc.F("Presets will appear in Nota Mosaic → Packs → {0}", _folderName);
+ _create.Content = Loc.T("mosaic_create.create_presets");
+ _where.Text = Loc.F("mosaic_create.presets_will_appear_in_nota", _folderName);
Opened += async (_, _) => await MapAsync();
}
@@ -159,7 +159,7 @@ public sealed class MosaicCreateWindow : NotaWindow
{
if (_prop is not { } prop) return;
int files = prop.Instruments.Sum(i => i.Files.Count);
- _headerInfo.Text = Loc.F("{0} files · {1}", files, NotaNum.Bytes(prop.Bytes));
+ _headerInfo.Text = Loc.F("mosaic_create.files", files, NotaNum.Bytes(prop.Bytes));
// Instruments.
_instList.Children.Clear();
@@ -170,7 +170,7 @@ public sealed class MosaicCreateWindow : NotaWindow
bool sel = i == _sel;
var check = new CheckBox { IsChecked = inst.Selected, VerticalAlignment = VerticalAlignment.Center, MinWidth = 0 };
check.IsCheckedChanged += (_, _) => { inst.Selected = check.IsChecked == true; PaintFoot(); };
- string layers = inst.Layers.Count > 1 ? string.Join("/", inst.Layers) : Loc.F("{0} layer", inst.Layers.Count);
+ string layers = inst.Layers.Count > 1 ? string.Join("/", inst.Layers) : Loc.F("mosaic_create.layer", inst.Layers.Count);
var name = new TextBlock { Text = inst.Stem, FontSize = 9, FontWeight = sel ? FontWeight.SemiBold : FontWeight.Normal, Foreground = sel ? AccentBright : TextPrimary };
var sub = Mono($"{inst.Files.Count} files · {inst.Roots} roots · {layers}{(inst.MaxRr > 1 ? $" · rr {inst.MaxRr}" : "")}", TextTertiary, 7.5);
var conf = Mono(NotaNum.Unit(inst.Confidence, "0", "%"), inst.Confidence >= 85 ? TextPrimary : NotaPalette.Warning, 8.5);
@@ -187,7 +187,7 @@ public sealed class MosaicCreateWindow : NotaWindow
b.PointerPressed += (_, e) => { if (e.Source is CheckBox) return; _sel = iv; Paint(); };
_instList.Children.Add(b);
}
- if (prop.Instruments.Count == 0) _instList.Children.Add(new TextBlock { Text = Loc.T("No audio files with a note in their name or a clear pitch."), FontSize = 8.5, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap });
+ if (prop.Instruments.Count == 0) _instList.Children.Add(new TextBlock { Text = Loc.T("mosaic_create.no_audio_files_with_a"), FontSize = 8.5, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap });
// Octave.
var oct = Segments(new[] { "C4 = 60", "C3 = 60" }, () => (_opt.OctaveShift ?? 0) == 12 ? 1 : 0, iv => { _opt.OctaveShift = iv == 1 ? 12 : 0; Remap(); }, out _, fill: true, fontSize: 8.5);
@@ -197,7 +197,7 @@ public sealed class MosaicCreateWindow : NotaWindow
Children =
{
oct,
- new TextBlock { Text = prop.OctaveWhy.Length > 0 ? prop.OctaveWhy : Loc.T("The names are taken as written (C4 = 60)."), FontSize = 8, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap },
+ new TextBlock { Text = prop.OctaveWhy.Length > 0 ? prop.OctaveWhy : Loc.T("mosaic_create.the_names_are_taken_as"), FontSize = 8, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap },
},
};
@@ -211,17 +211,17 @@ public sealed class MosaicCreateWindow : NotaWindow
var layerText = inst0 is null || inst0.Layers.Count <= 1 ? "one layer"
: string.Join(" · ", inst0.Layers.Select(l => { var f = inst0.Used.First(x => !x.Release && x.Layer == l); return $"{l} {f.VelLo}–{f.VelHi}"; }));
int rel = inst0?.Used.Count(f => f.Release) ?? 0;
- var rrSeg = Segments(new[] { Loc.T("Seq"), Loc.T("Rnd"), Loc.T("No repeat") }, () => _opt.RrMode, iv => { _opt.RrMode = iv; }, out _, fill: true, fontSize: 8);
+ var rrSeg = Segments(new[] { Loc.T("mosaic_create.seq"), Loc.T("mosaic_create.rnd"), Loc.T("mosaic_create.no_repeat") }, () => _opt.RrMode, iv => { _opt.RrMode = iv; }, out _, fill: true, fontSize: 8);
_mapping.Content = new StackPanel
{
Spacing = 5,
Children =
{
- KV(Loc.T("Edge zone stretch"), stretch),
- new TextBlock { Text = Loc.T("Velocity layers by dynamics"), FontSize = 8.5, Foreground = TextSecondary },
+ KV(Loc.T("mosaic_create.edge_zone_stretch"), stretch),
+ new TextBlock { Text = Loc.T("mosaic_create.velocity_layers_by_dynamics"), FontSize = 8.5, Foreground = TextSecondary },
Mono(layerText, TextPrimary, 8.5),
- KV(Loc.T("Release samples → Release group"), Mono(rel.ToString(NotaNum.Culture), TextPrimary, 9)),
- KV(Loc.T("Round-robin"), Mono(inst0?.MaxRr > 1 ? $"rr {inst0.MaxRr}" : "none", TextPrimary, 9)),
+ KV(Loc.T("mosaic_create.release_samples_release_group"), Mono(rel.ToString(NotaNum.Culture), TextPrimary, 9)),
+ KV(Loc.T("mosaic_create.round_robin"), Mono(inst0?.MaxRr > 1 ? $"rr {inst0.MaxRr}" : "none", TextPrimary, 9)),
rrSeg,
},
};
@@ -235,28 +235,28 @@ public sealed class MosaicCreateWindow : NotaWindow
_rows.Children.Clear();
_issues.Children.Clear();
_map.Flagged.Clear();
- if (inst is null) { _instTitle.Text = "—"; _instSub.Text = ""; _map.Set(Array.Empty<MosaicZone>(), false, -1, Loc.T("nothing to map")); return; }
+ if (inst is null) { _instTitle.Text = "—"; _instSub.Text = ""; _map.Set(Array.Empty<MosaicZone>(), false, -1, Loc.T("mosaic_create.nothing_to_map")); return; }
var prog = MultisampleMapper.Build(inst, _opt);
var (lo, hi) = inst.Span;
_instTitle.Text = inst.Stem;
- _instSub.Text = Loc.F("{0}–{1} · {2} zones", MosaicNames.NoteName(lo), MosaicNames.NoteName(hi), prog.Zones.Count);
+ _instSub.Text = Loc.F("mosaic_create.zones", MosaicNames.NoteName(lo), MosaicNames.NoteName(hi), prog.Zones.Count);
foreach (var g in inst.Gaps) _map.Flagged.Add(g);
_map.Set(prog.Zones, false, -1);
foreach (var g in inst.Gaps)
- _issues.Children.Add(Chip(Loc.F("Gap at {0} — neighbours stretched", MosaicNames.NoteName(g)), NotaPalette.Danger));
+ _issues.Children.Add(Chip(Loc.F("mosaic_create.gap_at_neighbours_stretched", MosaicNames.NoteName(g)), NotaPalette.Danger));
int dups = inst.Files.Count(f => f.Duplicate);
- if (dups > 0) _issues.Children.Add(Chip(Loc.Plural(dups, "{0} duplicate", "{0} duplicates"), NotaPalette.Danger));
+ if (dups > 0) _issues.Children.Add(Chip(Loc.Plural("mosaic_create.duplicates", dups), NotaPalette.Danger));
int an = inst.Files.Count(f => f.NoteFrom == "analysis");
- if (an > 0) _issues.Children.Add(Chip(Loc.Plural(an, "{0} note from sample analysis", "{0} notes from sample analysis"), NotaPalette.Warning));
+ if (an > 0) _issues.Children.Add(Chip(Loc.Plural("mosaic_create.notes_from_sample_analysis", an), NotaPalette.Warning));
int none = inst.Files.Count(f => f.Note < 0);
- if (none > 0) _issues.Children.Add(Chip(Loc.F("{0} without a note — left out", none), NotaPalette.TextTertiary));
+ if (none > 0) _issues.Children.Add(Chip(Loc.F("mosaic_create.without_a_note_left_out", none), NotaPalette.TextTertiary));
foreach (var f in inst.Files.OrderBy(f => f.Duplicate).ThenBy(f => f.Note).ThenBy(f => f.Name, StringComparer.Ordinal))
{
- string note = f.Note < 0 ? "—" : f.NoteFrom == "analysis" ? Loc.F("{0} · analysis", f.NoteText)
+ string note = f.Note < 0 ? "—" : f.NoteFrom == "analysis" ? Loc.F("mosaic_create.analysis", f.NoteText)
: f.NamedNote != f.Note ? $"{MosaicNames.NoteName(f.NamedNote)} → {f.NoteText}"
- : f.NoteFrom == "midi" ? Loc.F("{0} · MIDI", f.NoteText) : f.NoteText;
+ : f.NoteFrom == "midi" ? Loc.F("mosaic_create.midi_caps", f.NoteText) : f.NoteText;
string action = f.Duplicate ? "duplicate" : f.Note < 0 ? "skipped" : f.LayerGuessed ? "layer?" : "";
IBrush ink = f.Duplicate || f.Note < 0 ? TextTertiary : TextPrimary;
var row = TableRow(f.Name, note, f.Release ? "—" : f.Layer.Length > 0 ? f.Layer : "—", f.Rr > 0 ? f.Rr.ToString(NotaNum.Culture) : "—",
@@ -270,13 +270,13 @@ public sealed class MosaicCreateWindow : NotaWindow
private void PaintFoot()
{
int n = _prop?.Instruments.Count(i => i.Selected && i.Used.Any()) ?? 0;
- _create.Content = n == 1 ? Loc.T("Create 1 preset") : Loc.F("Create {0} presets", n);
+ _create.Content = n == 1 ? Loc.T("mosaic_create.create_1_preset") : Loc.F("mosaic_create.create_presets_n", n);
_create.IsEnabled = n > 0;
}
private async void Remap()
{
- _instTitle.Text = Loc.T("Mapping…");
+ _instTitle.Text = Loc.T("mosaic_create.mapping_2");
var keep = _prop?.Instruments.Where(i => !i.Selected).Select(i => i.Stem).ToHashSet() ?? new HashSet<string>();
await MapAsync();
if (_prop is not null) foreach (var i in _prop.Instruments) i.Selected = !keep.Contains(i.Stem);
diff --git a/src/managed/Nota.App/Nota.App.csproj b/src/managed/Nota.App/Nota.App.csproj
index ff807070..3c6ca7a6 100644
--- a/src/managed/Nota.App/Nota.App.csproj
+++ b/src/managed/Nota.App/Nota.App.csproj
@@ -52,9 +52,10 @@
<EmbeddedResource Include="Theme\Themes\*.json" LogicalName="Nota.Themes.%(Filename)%(Extension)" />
</ItemGroup>
- <!-- The interface languages (spec 068): one JSON file per language, English text → translation.
- Read by NotaLanguages at startup; the picker lists whatever is embedded here, so a new
- language is one new file. The smoke test reads the same files from disk. -->
+ <!-- The interface translations (spec 068, keyed since spec 077): one JSON file per language,
+ key → translation. English is not here: it is the reference, embedded in Nota.Application
+ beside Loc. Read by NotaLanguages at startup; the picker lists whatever is embedded here.
+ The smoke test reads the same files from disk. -->
<ItemGroup>
<EmbeddedResource Include="Languages\*.json" LogicalName="Nota.Languages.%(Filename)%(Extension)" />
</ItemGroup>
diff --git a/src/managed/Nota.App/PianoRollView.ClipStrip.cs b/src/managed/Nota.App/PianoRollView.ClipStrip.cs
index 47043700..c1ab8fcf 100644
--- a/src/managed/Nota.App/PianoRollView.ClipStrip.cs
+++ b/src/managed/Nota.App/PianoRollView.ClipStrip.cs
@@ -33,7 +33,7 @@ public sealed partial class PianoRollView
{
_o = o;
Cursor = new Cursor(StandardCursorType.Hand);
- ToolTip.SetTip(this, Loc.T("Click a clip to edit it · the lock keeps a clip for reference"));
+ ToolTip.SetTip(this, Loc.T("piano_roll.clip_strip.click_a_clip_to_edit"));
}
/// <summary>Re-stacks the bars (clips added, removed, moved) and sizes the strip.</summary>
@@ -91,7 +91,7 @@ public sealed partial class PianoRollView
}
IBrush ink = active ? NotaPalette.InkOn(track) : locked ? NotaPalette.TextTertiary : NotaPalette.TextSecondary;
var clip = set.Clips[k];
- string name = _o.ClipNameOf?.Invoke(clip.TrackId, clip.ClipIndex) ?? Loc.F("Track {0}", clip.TrackId);
+ string name = _o.ClipNameOf?.Invoke(clip.TrackId, clip.ClipIndex) ?? Loc.F("common.track_n", clip.TrackId);
var ft = new FormattedText(name, NotaNum.Culture, FlowDirection.LeftToRight, NotaFonts.SansMedium, 9, ink);
double textX = r.X + (active ? 6 : Stripe + 5);
double room = r.Width - (textX - r.X) - (active ? 6 : LockW + 2);
diff --git a/src/managed/Nota.App/PianoRollView.Controllers.cs b/src/managed/Nota.App/PianoRollView.Controllers.cs
index 0f752547..6fde9b1a 100644
--- a/src/managed/Nota.App/PianoRollView.Controllers.cs
+++ b/src/managed/Nota.App/PianoRollView.Controllers.cs
@@ -110,7 +110,7 @@ public sealed partial class PianoRollView
foreach (int c in CommonControllers)
if (Array.IndexOf(data, c) < 0) f.Items.Add(Item(c, MidiController.Name(c)));
f.Items.Add(new Separator());
- var other = new MenuItem { Header = Loc.T("Other CC") };
+ var other = new MenuItem { Header = Loc.T("piano_roll.controllers.other_cc") };
for (int g = 0; g < 128; g += 16)
{
var ctls = Enumerable.Range(g, 16).Where(c => !MidiController.IsReserved(c)).ToList();
@@ -380,7 +380,7 @@ public sealed partial class PianoRollView
ctx.DrawText(name, new Point(4, 3));
if (c.Count == 0 && Editable && _drag == Drag.None)
{
- var hint = new FormattedText(IsSwitch ? Loc.T("Drag to draw a block") : Loc.T("Drag to draw"), NotaNum.Culture, FlowDirection.LeftToRight, NotaFonts.Sans, 9, LabelText);
+ var hint = new FormattedText(IsSwitch ? Loc.T("piano_roll.controllers.drag_to_draw_a_block") : Loc.T("piano_roll.controllers.drag_to_draw"), NotaNum.Culture, FlowDirection.LeftToRight, NotaFonts.Sans, 9, LabelText);
ctx.DrawText(hint, new Point((w - hint.Width) / 2, (h - hint.Height) / 2));
}
if (!double.IsNaN(_hoverBeat) || _drag != Drag.None)
@@ -667,7 +667,7 @@ public sealed partial class PianoRollView
private void ShowClearMenu()
{
int ctl = Ctl;
- ClipEditorKit.ShowMenu(this, new[] { Loc.F("Clear {0}", MidiController.Name(ctl)) }, -1, _ =>
+ ClipEditorKit.ShowMenu(this, new[] { Loc.F("piano_roll.clear", MidiController.Name(ctl)) }, -1, _ =>
{
_selBlock = -1;
_o.StoreController(ctl, new List<AutomationPoint>());
diff --git a/src/managed/Nota.App/PianoRollView.Expression.cs b/src/managed/Nota.App/PianoRollView.Expression.cs
index b3d408ad..10ad2b91 100644
--- a/src/managed/Nota.App/PianoRollView.Expression.cs
+++ b/src/managed/Nota.App/PianoRollView.Expression.cs
@@ -165,7 +165,7 @@ public sealed partial class PianoRollView
private sealed class LaneTabs : Control
{
private static readonly (LaneMode Mode, string Label)[] Tabs =
- { (LaneMode.Velocity, Loc.T("Vel")), (LaneMode.Bend, Loc.T("Bend")), (LaneMode.Pressure, Loc.T("Pres")), (LaneMode.Slide, Loc.T("Slide")), (LaneMode.Controller, "") };
+ { (LaneMode.Velocity, Loc.T("piano_roll.expression.vel")), (LaneMode.Bend, Loc.T("piano_roll.expression.bend")), (LaneMode.Pressure, Loc.T("piano_roll.expression.pres")), (LaneMode.Slide, Loc.T("piano_roll.expression.slide")), (LaneMode.Controller, "") };
// Five rows fit the velocity lane's 72 px.
private const double Top = 4, RowStep = 13;
private const double ChevronW = 7;
@@ -613,8 +613,8 @@ public sealed partial class PianoRollView
private void ShowClearMenu()
{
- string lane = Dim switch { NoteExpressionDim.Bend => Loc.T("Bend"), NoteExpressionDim.Pressure => Loc.T("Pressure"), _ => Loc.T("Slide") };
- var items = new[] { Loc.F("Clear {0}", lane), Loc.T("Clear All Expression") };
+ string lane = Dim switch { NoteExpressionDim.Bend => Loc.T("piano_roll.expression.bend"), NoteExpressionDim.Pressure => Loc.T("piano_roll.expression.pressure"), _ => Loc.T("piano_roll.expression.slide") };
+ var items = new[] { Loc.F("piano_roll.clear", lane), Loc.T("piano_roll.expression.clear_all_expression") };
ClipEditorKit.ShowMenu(this, items, -1, k =>
{
bool changed = false;
diff --git a/src/managed/Nota.App/PianoRollView.cs b/src/managed/Nota.App/PianoRollView.cs
index 707ef97d..311fe37b 100644
--- a/src/managed/Nota.App/PianoRollView.cs
+++ b/src/managed/Nota.App/PianoRollView.cs
@@ -893,17 +893,17 @@ public sealed partial class PianoRollView : UserControl
{
get
{
- if (_selection.Count == 0) return Loc.T("No selection");
+ if (_selection.Count == 0) return Loc.T("piano_roll.no_selection");
if (_selection.Count == 1)
{
int i = _selection.First();
if (i >= 0 && i < _notes.Count)
{
var n = _notes[i];
- return Loc.F("1 note · {0} · vel {1}", NoteName(n.Pitch), (int)Math.Round(n.Velocity * 127));
+ return Loc.F("piano_roll.1_note_vel", NoteName(n.Pitch), (int)Math.Round(n.Velocity * 127));
}
}
- return Loc.F("{0} notes", _selection.Count);
+ return Loc.F("piano_roll.notes", _selection.Count);
}
}
@@ -1724,7 +1724,7 @@ public sealed partial class PianoRollView : UserControl
SetPlayhead(b, true); // immediate feedback; the transport tick keeps it in sync
}
- private static readonly string SlotSeekTip = Loc.T("A Session slot plays on its own loop clock — launch it to play from the start");
+ private static readonly string SlotSeekTip = Loc.T("piano_roll.a_session_slot_plays_on");
private static readonly Cursor HandCursorShared = new(StandardCursorType.Hand);
private static readonly Cursor LineCursor = new(StandardCursorType.SizeWestEast);
private static readonly Cursor NoCursor = new(StandardCursorType.No);
@@ -2947,7 +2947,7 @@ public sealed partial class PianoRollView : UserControl
private void ShowResetMenu(int hit)
{
var flyout = new MenuFlyout();
- flyout.Items.Add(MenuKit.Item(Loc.T("Reset velocity"), click: () =>
+ flyout.Items.Add(MenuKit.Item(Loc.T("piano_roll.reset_velocity"), click: () =>
{
_o.EndVelocityWheel(); // its own step, apart from anything just before it
Snapshot();
diff --git a/src/managed/Nota.App/PluginScan.cs b/src/managed/Nota.App/PluginScan.cs
index 00b5442e..6e429732 100644
--- a/src/managed/Nota.App/PluginScan.cs
+++ b/src/managed/Nota.App/PluginScan.cs
@@ -64,8 +64,8 @@ internal static class PluginScan
/// <summary>Status line for a running scan, e.g. "Scanning plugins · 312 of 1,000 · Analytiks".</summary>
public static string Describe(PluginScanProgress p)
{
- if (p.Total == 0) return Loc.T("Looking for plugins…");
- var line = Loc.F("Scanning plugins · {0:N0} of {1:N0}", p.Done, p.Total);
+ if (p.Total == 0) return Loc.T("plugin_scan.looking_for_plugins");
+ var line = Loc.F("plugin_scan.scanning_plugins_of", p.Done, p.Total);
return p.Current.Length > 0 ? $"{line} · {p.Current}" : line;
}
diff --git a/src/managed/Nota.App/PreferencesWindow.Downloads.cs b/src/managed/Nota.App/PreferencesWindow.Downloads.cs
index 8f37c6d1..9af1eda8 100644
--- a/src/managed/Nota.App/PreferencesWindow.Downloads.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Downloads.cs
@@ -21,7 +21,7 @@ namespace Nota.App;
public sealed partial class PreferencesWindow
{
private const int DownloadsIndex = 5;
- private static readonly string[] DownloadSources = { Loc.T("Plug-ins"), Loc.T("Sample packs"), Loc.T("AI models") };
+ private static readonly string[] DownloadSources = { Loc.T("preferences.plug_ins"), Loc.T("preferences.downloads.sample_packs"), Loc.T("preferences.downloads.ai_models") };
private int _downloadSource; // 0 = plug-ins, 1 = sample packs, 2 = AI models; kept for the window's life
private Control DownloadsPane(Control header)
diff --git a/src/managed/Nota.App/PreferencesWindow.Language.cs b/src/managed/Nota.App/PreferencesWindow.Language.cs
index cb1c7a6c..2efe3777 100644
--- a/src/managed/Nota.App/PreferencesWindow.Language.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Language.cs
@@ -39,11 +39,11 @@ public sealed partial class PreferencesWindow
var canRelaunch = AppRestart.CanRelaunch;
var pending = new TextBlock
{
- Text = canRelaunch ? Loc.T("Applies after restart") : Loc.T("Applies the next time Nota starts"),
+ Text = canRelaunch ? Loc.T("preferences.language.applies_after_restart") : Loc.T("preferences.language.applies_the_next_time_nota"),
FontSize = 11, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center,
TextWrapping = Avalonia.Media.TextWrapping.Wrap,
};
- var restart = Btn(Loc.T("Restart"));
+ var restart = Btn(Loc.T("preferences.language.restart"));
restart.Height = 24;
restart.Padding = new Avalonia.Thickness(10, 0);
restart.Click += (_, _) =>
diff --git a/src/managed/Nota.App/PreferencesWindow.Models.cs b/src/managed/Nota.App/PreferencesWindow.Models.cs
index 98f7ae61..2111a164 100644
--- a/src/managed/Nota.App/PreferencesWindow.Models.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Models.cs
@@ -27,7 +27,7 @@ public sealed partial class PreferencesWindow
private static string ModelKey(string id) => "model:" + id;
- private static readonly string ModelsIntro = Loc.T("AI models that run on this computer: the audio you give them never leaves it. Each downloads once from where its authors publish it and is checked against the checksum Nota pins for it.");
+ private static readonly string ModelsIntro = Loc.T("preferences.models.ai_models_that_run_on");
// The AI Models third of Downloads (PreferencesWindow.Downloads.cs). No toolbar: the list is short.
private (Control? Toolbar, Control Body) ModelParts()
@@ -47,7 +47,7 @@ public sealed partial class PreferencesWindow
if (_models.Runtime is { } rt) rows.Add(ModelRow(rt, runtime: true));
else rows.Add(new TextBlock
{
- Text = Loc.T("ONNX Runtime has no build for this computer, so the models can't run here."),
+ Text = Loc.T("preferences.models.onnx_runtime_has_no_build"),
FontSize = 12, Foreground = TextTertiary, Margin = new Thickness(16, 14),
});
_modelList.Content = Table(rows);
@@ -77,20 +77,20 @@ public sealed partial class PreferencesWindow
var actions = new StackPanel { Spacing = 8, MinWidth = 96, HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Top };
bool busy = Jobs.BusyId is not null;
if (Jobs.BusyId == ModelKey(m.Id))
- actions.Children.Add(StoreButton(installed ? Loc.T("Removing…") : Loc.T("Installing…"), enabled: false, () => { }));
+ actions.Children.Add(StoreButton(installed ? Loc.T("preferences.models.removing") : Loc.T("preferences.installing"), enabled: false, () => { }));
else if (installed)
{
actions.Children.Add(new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 6, Height = 26, HorizontalAlignment = HorizontalAlignment.Right,
- Children = { Dot(Brass), new TextBlock { Text = Loc.T("Installed"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center } },
+ Children = { Dot(Brass), new TextBlock { Text = Loc.T("preferences.installed"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center } },
});
- if (!runtime) actions.Children.Add(StoreLink(Loc.T("Remove"), null, busy ? null : () => RemoveModel(m)));
+ if (!runtime) actions.Children.Add(StoreLink(Loc.T("preferences.remove"), null, busy ? null : () => RemoveModel(m)));
}
else if (!runtime)
- actions.Children.Add(StoreButton(Loc.T("Install"), enabled: !busy && _models.Runtime is not null, () => InstallModel(m)));
+ actions.Children.Add(StoreButton(Loc.T("preferences.install"), enabled: !busy && _models.Runtime is not null, () => InstallModel(m)));
else
- actions.Children.Add(new TextBlock { Text = Loc.T("Comes with a model"), FontSize = 11, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Right, Height = 26 });
+ actions.Children.Add(new TextBlock { Text = Loc.T("preferences.models.comes_with_a_model"), FontSize = 11, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Right, Height = 26 });
long download = runtime || installed || _models.Runtime is null ? m.Size : _models.DownloadSize(m.Id);
var size = new TextBlock
@@ -98,12 +98,12 @@ public sealed partial class PreferencesWindow
Text = installed ? Megabytes(m.UnpackedSize) : Megabytes(download),
FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Right,
};
- ToolTip.SetTip(size, installed ? Loc.T("On disk")
- : download > m.Size ? Loc.F("{0} model + {1} AI runtime, downloaded once", Megabytes(m.Size), Megabytes(download - m.Size))
- : Loc.T("Download"));
+ ToolTip.SetTip(size, installed ? Loc.T("preferences.models.on_disk")
+ : download > m.Size ? Loc.F("preferences.models.model_ai_runtime_downloaded_once", Megabytes(m.Size), Megabytes(download - m.Size))
+ : Loc.T("common.download"));
actions.Children.Add(size);
- var source = StoreLink(Loc.T("Source"), GlyphKind.PopOut, () => _ = Launcher.LaunchUriAsync(new Uri(m.Source)));
- ToolTip.SetTip(source, Loc.T("Open the model's project page"));
+ var source = StoreLink(Loc.T("preferences.source"), GlyphKind.PopOut, () => _ = Launcher.LaunchUriAsync(new Uri(m.Source)));
+ ToolTip.SetTip(source, Loc.T("preferences.models.open_the_models_project_page"));
actions.Children.Add(source);
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 16, Margin = new Thickness(16, 14, 14, 14) };
@@ -117,25 +117,25 @@ public sealed partial class PreferencesWindow
{
// Size 0: the model and the runtime download one after the other, each reporting its own
// fraction, so a byte count would mix two files.
- Jobs.Install(ModelKey(m.Id), source: 2, m.Name, 0, new StoreProgress(0, Loc.F("Downloading {0}…", m.Name)),
+ Jobs.Install(ModelKey(m.Id), source: 2, m.Name, 0, new StoreProgress(0, Loc.F("preferences.downloading", m.Name)),
(progress, ct) => _models.InstallAsync(m.Id, progress, ct),
() => Task.FromResult(m.Id == AiModels.Stems
- ? Loc.F("{0} is installed — right-click an audio clip and choose Separate Stems.", m.Name)
- : Loc.F("{0} is installed — Convert Melody and Convert Harmony now use it.", m.Name)));
+ ? Loc.F("preferences.models.is_installed_right_click_an", m.Name)
+ : Loc.F("preferences.models.is_installed_convert_melody_and", m.Name)));
}
private async void RemoveModel(StoreModel m)
{
if (Jobs.Busy) return;
bool last = _models.Models.Count(x => _models.IsInstalled(x.Id)) == 1;
- var ok = await new ConfirmWindow(Loc.T("Remove AI model"),
- Loc.F("Remove {0}? {1} will offer to download it again.", m.Name, m.Feature) + (last ? Loc.T(" The AI runtime goes too.") : ""),
- Loc.T("Remove"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ var ok = await new ConfirmWindow(Loc.T("preferences.models.remove_ai_model"),
+ Loc.F("preferences.models.remove_will_offer_to_download", m.Name, m.Feature) + (last ? Loc.T("preferences.models.the_ai_runtime_goes_too") : ""),
+ Loc.T("preferences.remove"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
- Jobs.Remove(ModelKey(m.Id), source: 2, Loc.F("Removing {0}…", m.Name), async () =>
+ Jobs.Remove(ModelKey(m.Id), source: 2, Loc.F("preferences.removing", m.Name), async () =>
{
await Task.Run(() => _models.Uninstall(m.Id));
- return Loc.F("{0} was removed.", m.Name);
+ return Loc.F("preferences.was_removed", m.Name);
});
}
}
diff --git a/src/managed/Nota.App/PreferencesWindow.Remote.cs b/src/managed/Nota.App/PreferencesWindow.Remote.cs
index 5d024c8c..5ed01080 100644
--- a/src/managed/Nota.App/PreferencesWindow.Remote.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Remote.cs
@@ -57,8 +57,8 @@ public sealed partial class PreferencesWindow
}
foreach (var (i, name, sub) in new[]
{
- (0, Loc.T("Play notes only"), Loc.T("Pads and keys. Mixer, transport and mappings are read-only.")),
- (1, Loc.T("Play and control the project"), Loc.T("Also mixer, transport, macros, XY and Session.")),
+ (0, Loc.T("preferences.remote.play_notes_only"), Loc.T("preferences.remote.pads_and_keys_mixer_transport")),
+ (1, Loc.T("preferences.remote.play_and_control_the_project"), Loc.T("preferences.remote.also_mixer_transport_macros_xy")),
})
{
var ring = new Ellipse { Width = 12, Height = 12, StrokeThickness = 1.5 };
@@ -90,16 +90,16 @@ public sealed partial class PreferencesWindow
{
var connected = remote.Hub.Devices.Select(d => d.DeviceId).ToHashSet();
var list = remote.Pairing.Trusted.OrderByDescending(d => d.LastSeen).ToList();
- if (list.Count == 0) { trustedHost.Content = EmptyBox(Loc.T("No phone has paired yet. Turn Remote on and scan the code in Connect phone.")); return; }
+ if (list.Count == 0) { trustedHost.Content = EmptyBox(Loc.T("preferences.remote.no_phone_has_paired_yet")); return; }
var rows = new List<Control>();
foreach (var d in list)
{
bool live = connected.Contains(d.Id) && remote.Running;
var name = new TextBlock { Text = d.Name, FontSize = 12, Foreground = TextPrimary, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis };
- var seen = new TextBlock { Text = live ? Loc.T("now") : Ago(d.LastSeen), FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
- var forget = Btn(Loc.T("Forget"));
+ var seen = new TextBlock { Text = live ? Loc.T("preferences.remote.now") : Ago(d.LastSeen), FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
+ var forget = Btn(Loc.T("preferences.remote.forget"));
forget.Height = 24; forget.FontSize = 11; forget.Padding = new Thickness(10, 0);
- ToolTip.SetTip(forget, Loc.T("Disconnect it and make it scan a new code to come back"));
+ ToolTip.SetTip(forget, Loc.T("preferences.remote.disconnect_it_and_make_it"));
string id = d.Id;
forget.Click += (_, _) => { remote.Hub.Forget(id); RenderTrusted(); };
rows.Add(ListRow(38, "Auto,*,Auto,Auto", Dot(live ? NotaPalette.SuccessDim : BorderStrong), name, seen, forget));
@@ -112,9 +112,9 @@ public sealed partial class PreferencesWindow
void Refresh()
{
bool on = Enabled();
- string listen = remote.Links.Count == 0 ? Loc.T("On · no network")
- : Loc.F("Listening on {0}", string.Join(" · ", remote.Links.Select(l => (l.Usb ? Loc.T("USB ") : "") + l.Address + ":" + settings.Current.RemotePort)));
- status.Text = !on ? Loc.T("Off") : remote.Error ?? listen;
+ string listen = remote.Links.Count == 0 ? Loc.T("preferences.remote.on_no_network")
+ : Loc.F("preferences.remote.listening_on", string.Join(" · ", remote.Links.Select(l => (l.Usb ? Loc.T("preferences.remote.usb_caps") : "") + l.Address + ":" + settings.Current.RemotePort)));
+ status.Text = !on ? Loc.T("common.off") : remote.Error ?? listen;
statusDot.Fill = !on ? BorderStrong : remote.Error is null ? NotaPalette.SuccessDim : NotaPalette.Danger;
Inactive.Set(details, !on);
RenderTrusted();
@@ -128,17 +128,17 @@ public sealed partial class PreferencesWindow
_ = remote.ApplyAsync();
Refresh();
}
- var enable = SwitchRow(Loc.T("Allow control from a phone"), Enabled(), Apply);
+ var enable = SwitchRow(Loc.T("preferences.remote.allow_control_from_a_phone"), Enabled(), Apply);
portBox.LostFocus += (_, _) => Apply(Enabled());
void OnChanged() => Dispatcher.UIThread.Post(Refresh);
remote.Changed += OnChanged;
Closed += (_, _) => remote.Changed -= OnChanged;
DetachedFromVisualTree += (_, _) => remote.Changed -= OnChanged;
- details.Children.Add(Row(Loc.T("Port"), portBox));
- details.Children.Add(Row(Loc.T("Status"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { statusDot, status } }));
+ details.Children.Add(Row(Loc.T("preferences.port"), portBox));
+ details.Children.Add(Row(Loc.T("preferences.status"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { statusDot, status } }));
var accessRow = new Grid { ColumnDefinitions = new ColumnDefinitions($"{LabelCol},*") };
- var accessLabel = RowLabel(Loc.T("Phones may"));
+ var accessLabel = RowLabel(Loc.T("preferences.remote.phones_may"));
accessLabel.VerticalAlignment = VerticalAlignment.Top;
accessLabel.Margin = new Thickness(0, 6, 0, 0);
accessRow.Children.Add(accessLabel);
@@ -148,10 +148,10 @@ public sealed partial class PreferencesWindow
Refresh();
string sysNote = OperatingSystem.IsMacOS()
- ? Loc.T("When you turn this on, macOS asks whether Nota may find devices on the local network. Allow it, or phones can't reach Nota.")
+ ? Loc.T("preferences.remote.when_you_turn_this_on_2")
: OperatingSystem.IsWindows()
- ? Loc.T("When you turn this on, Windows asks whether Nota may use the network. Allow private networks, or phones can't reach Nota.")
- : Loc.T("Phones reach Nota on the port above: if a firewall is on, allow it.");
+ ? Loc.T("preferences.remote.when_you_turn_this_on")
+ : Loc.T("preferences.remote.phones_reach_nota_on_the");
var warn = new Border
{
Padding = new Thickness(14, 12), CornerRadius = NotaRadius.Panel, Background = RowBg, BorderBrush = Divider, BorderThickness = new Thickness(1),
@@ -161,25 +161,25 @@ public sealed partial class PreferencesWindow
Children =
{
new Ellipse { Width = 6, Height = 6, Fill = NotaPalette.Warning, VerticalAlignment = VerticalAlignment.Top, Margin = new Thickness(0, 5, 0, 0) },
- new TextBlock { Text = sysNote + Loc.T(" Nota never shows files or paths to the phone, and serves nothing from your disk."), FontSize = 11, LineHeight = 17, Foreground = TextSecondary, TextWrapping = TextWrapping.Wrap, MaxWidth = 560 },
+ new TextBlock { Text = sysNote + Loc.T("preferences.remote.nota_never_shows_files_or"), FontSize = 11, LineHeight = 17, Foreground = TextSecondary, TextWrapping = TextWrapping.Wrap, MaxWidth = 560 },
},
},
};
return Sections(
- Section(Loc.T("Nota Remote"), 10, enable, details),
- Section(Loc.T("Trusted devices"), 8, trustedHost,
- Caption(Loc.T("A trusted phone reconnects from its Home Screen icon without a code. Forget it and it has to scan again. Turning Remote off disconnects everyone."), muted: true)),
+ Section(Loc.T("preferences.remote.nota_remote"), 10, enable, details),
+ Section(Loc.T("preferences.remote.trusted_devices"), 8, trustedHost,
+ Caption(Loc.T("preferences.remote.a_trusted_phone_reconnects_from"), muted: true)),
warn);
}
private static string Ago(DateTime utc)
{
var d = DateTime.UtcNow - utc;
- if (d.TotalMinutes < 2) return Loc.T("just now");
- if (d.TotalHours < 1) return Loc.F("{0} min ago", (int)d.TotalMinutes);
- if (d.TotalDays < 1) return Loc.F("{0} h ago", (int)d.TotalHours);
+ if (d.TotalMinutes < 2) return Loc.T("preferences.remote.just_now");
+ if (d.TotalHours < 1) return Loc.F("preferences.remote.min_ago", (int)d.TotalMinutes);
+ if (d.TotalDays < 1) return Loc.F("preferences.remote.h_ago", (int)d.TotalHours);
if (d.TotalDays < 2) return "yesterday";
- return Loc.F("{0} days ago", (int)d.TotalDays);
+ return Loc.F("preferences.remote.days_ago", (int)d.TotalDays);
}
}
diff --git a/src/managed/Nota.App/PreferencesWindow.Samples.cs b/src/managed/Nota.App/PreferencesWindow.Samples.cs
index 297d8946..0e5a54e4 100644
--- a/src/managed/Nota.App/PreferencesWindow.Samples.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Samples.cs
@@ -25,7 +25,7 @@ namespace Nota.App;
public sealed partial class PreferencesWindow
{
- private static readonly string[] PackFilters = { Loc.T("All"), Loc.T("One-shots"), Loc.T("Instruments"), Loc.T("Installed") };
+ private static readonly string[] PackFilters = { Loc.T("preferences.all"), Loc.T("preferences.samples.one_shots"), Loc.T("common.instruments"), Loc.T("preferences.installed") };
private readonly ISampleStore _samples = App.Services.GetRequiredService<ISampleStore>();
private IReadOnlyList<StorePack>? _packs;
@@ -45,7 +45,7 @@ public sealed partial class PreferencesWindow
private static string PackKey(string id) => "pack:" + id;
- private static readonly string PacksIntro = Loc.T("Free sample packs from the Nota sample registry, licensed for any music, commercial releases included. Each pack downloads from where its author publishes it, is checked against the registry's checksum and unpacked into your Samples folder.");
+ private static readonly string PacksIntro = Loc.T("preferences.samples.free_sample_packs_from_the");
// The Sample Packs half of Downloads (PreferencesWindow.Downloads.cs).
private (Control Toolbar, Control Body) PackParts()
@@ -76,10 +76,10 @@ public sealed partial class PreferencesWindow
segs.Add(b);
strip.Children.Add(b);
}
- var search = new TextBox { PlaceholderText = Loc.T("Search"), Text = _packSearch, Classes = { "search" }, FontSize = 12 };
+ var search = new TextBox { PlaceholderText = Loc.T("preferences.search"), Text = _packSearch, Classes = { "search" }, FontSize = 12 };
search.TextChanged += (_, _) => { _packSearch = search.Text ?? ""; RenderPackList(); };
- var refresh = new Button { Content = Loc.T("Refresh"), Classes = { "ghost" }, Height = 30, FontSize = 12, Padding = new Thickness(12, 0), Foreground = TextSecondary };
- ToolTip.SetTip(refresh, Loc.T("Reload the registry"));
+ var refresh = new Button { Content = Loc.T("preferences.refresh"), Classes = { "ghost" }, Height = 30, FontSize = 12, Padding = new Thickness(12, 0), Foreground = TextSecondary };
+ ToolTip.SetTip(refresh, Loc.T("preferences.reload_the_registry"));
refresh.Click += (_, _) => { if (!_packLoading) _packLoad = LoadPacksAsync(refresh: true); };
_packRefresh = refresh;
@@ -102,7 +102,7 @@ public sealed partial class PreferencesWindow
{
_packStatus,
new StackPanel { Spacing = 6, Children = { _packLoadBar, _packList } },
- Caption(Loc.F("Installed to {0}", _samples.InstallDir)),
+ Caption(Loc.F("preferences.installed_to", _samples.InstallDir)),
},
};
body.DetachedFromVisualTree += (_, _) =>
@@ -157,7 +157,7 @@ public sealed partial class PreferencesWindow
if (_packRefresh is not null)
{
_packRefresh.IsEnabled = !_packLoading;
- _packRefresh.Content = _packLoading && _packs is not null ? Loc.T("Refreshing…") : Loc.T("Refresh");
+ _packRefresh.Content = _packLoading && _packs is not null ? Loc.T("preferences.refreshing") : Loc.T("preferences.refresh");
}
if (_packLoadBar is not null) _packLoadBar.IsVisible = _packLoading && _packs is not null;
if (_packs is null)
@@ -182,7 +182,7 @@ public sealed partial class PreferencesWindow
{
var empty = new TextBlock
{
- Text = _packFilter == 3 && q.Length == 0 ? Loc.T("No sample packs installed from the registry yet.") : Loc.T("Nothing matches."),
+ Text = _packFilter == 3 && q.Length == 0 ? Loc.T("preferences.samples.no_sample_packs_installed_from") : Loc.T("preferences.nothing_matches"),
FontSize = 12, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(28),
};
_packList.Content = Table(new List<Control> { empty });
@@ -206,7 +206,7 @@ public sealed partial class PreferencesWindow
Children =
{
new ProgressBar { IsIndeterminate = true, Width = 180, Height = 4, MinWidth = 0 },
- new TextBlock { Text = Loc.T("Loading the sample registry…"), FontSize = 12, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center },
+ new TextBlock { Text = Loc.T("preferences.samples.loading_the_sample_registry"), FontSize = 12, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center },
},
},
});
@@ -231,10 +231,10 @@ public sealed partial class PreferencesWindow
private static string PackKindLabel(string kind) => kind switch
{
- "one-shots" => Loc.T("One-shots"),
- "loops" => Loc.T("Loops"),
- "multisample" => Loc.T("Instrument"),
- "mixed" => Loc.T("Mixed"),
+ "one-shots" => Loc.T("preferences.samples.one_shots"),
+ "loops" => Loc.T("preferences.samples.loops"),
+ "multisample" => Loc.T("common.instrument"),
+ "mixed" => Loc.T("preferences.samples.mixed"),
_ => NotaText.Label(kind.ToUpperInvariant()),
};
@@ -261,7 +261,7 @@ public sealed partial class PreferencesWindow
},
};
if (p.Attribution is { Length: > 0 } credit)
- text.Children.Add(new TextBlock { Text = Loc.F("Credit: {0}", credit), FontSize = 11, LineHeight = 16, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap });
+ text.Children.Add(new TextBlock { Text = Loc.F("preferences.samples.credit", credit), FontSize = 11, LineHeight = 16, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap });
if (p.Notes is { Length: > 0 } notes)
text.Children.Add(new TextBlock { Text = notes, FontSize = 11, LineHeight = 16, Foreground = TextTertiary, TextWrapping = TextWrapping.Wrap });
@@ -269,36 +269,36 @@ public sealed partial class PreferencesWindow
bool busy = Jobs.BusyId is not null;
if (Jobs.BusyId == PackKey(p.Id))
{
- actions.Children.Add(StoreButton(inst is null ? Loc.T("Installing…") : Loc.T("Working…"), enabled: false, () => { }));
+ actions.Children.Add(StoreButton(inst is null ? Loc.T("preferences.installing") : Loc.T("preferences.working"), enabled: false, () => { }));
}
else if (inst is null)
{
- actions.Children.Add(StoreButton(Loc.T("Install"), enabled: !busy, () => InstallPack(p)));
+ actions.Children.Add(StoreButton(Loc.T("preferences.install"), enabled: !busy, () => InstallPack(p)));
}
else
{
if (inst.Version != p.Version)
- actions.Children.Add(StoreButton(Loc.F("Update to {0}", p.Version), enabled: !busy, () => InstallPack(p)));
+ actions.Children.Add(StoreButton(Loc.F("preferences.update_to", p.Version), enabled: !busy, () => InstallPack(p)));
else
actions.Children.Add(new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 6, Height = 26, HorizontalAlignment = HorizontalAlignment.Right,
- Children = { Dot(Brass), new TextBlock { Text = Loc.T("Installed"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center } },
+ Children = { Dot(Brass), new TextBlock { Text = Loc.T("preferences.installed"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center } },
});
- var show = StoreLink(Loc.T("Show"), null, () => { try { MainWindow.RevealInFileManager(inst.Path); } catch { /* no file manager */ } });
- ToolTip.SetTip(show, Loc.T("Show the pack's folder"));
+ var show = StoreLink(Loc.T("common.show"), null, () => { try { MainWindow.RevealInFileManager(inst.Path); } catch { /* no file manager */ } });
+ ToolTip.SetTip(show, Loc.T("preferences.samples.show_the_packs_folder"));
actions.Children.Add(show);
- actions.Children.Add(StoreLink(Loc.T("Remove"), null, busy ? null : () => RemovePack(p, inst)));
+ actions.Children.Add(StoreLink(Loc.T("preferences.remove"), null, busy ? null : () => RemovePack(p, inst)));
}
actions.Children.Add(new TextBlock
{
- Text = inst is null ? Loc.F("{0} · {1} samples", Megabytes(p.Asset.Size), p.Asset.Files) : Loc.Plural(inst.Files, "{0} sample", "{0} samples"),
+ Text = inst is null ? Loc.F("preferences.samples.samples_n", Megabytes(p.Asset.Size), p.Asset.Files) : Loc.Plural("preferences.samples.samples", inst.Files),
FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Right,
});
if (inst is null)
- ToolTip.SetTip(actions.Children[^1], Loc.F("{0} download · {1} samples · {2} on disk · {3}", Megabytes(p.Asset.Size), p.Asset.Files, Megabytes(p.Asset.UnpackedSize), string.Join(", ", p.Asset.Formats)));
- var source = StoreLink(Loc.T("Source"), GlyphKind.PopOut, () => _ = Launcher.LaunchUriAsync(new Uri(p.Source)));
- ToolTip.SetTip(source, Loc.T("Open the pack's page"));
+ ToolTip.SetTip(actions.Children[^1], Loc.F("preferences.samples.download_samples_on_disk", Megabytes(p.Asset.Size), p.Asset.Files, Megabytes(p.Asset.UnpackedSize), string.Join(", ", p.Asset.Formats)));
+ var source = StoreLink(Loc.T("preferences.source"), GlyphKind.PopOut, () => _ = Launcher.LaunchUriAsync(new Uri(p.Source)));
+ ToolTip.SetTip(source, Loc.T("preferences.samples.open_the_packs_page"));
actions.Children.Add(source);
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 16, Margin = new Thickness(16, 14, 14, 14) };
@@ -311,7 +311,7 @@ public sealed partial class PreferencesWindow
private void InstallPack(StorePack p)
{
var main = _main;
- Jobs.Install(PackKey(p.Id), source: 1, p.Name, p.Asset.Size, new StoreProgress(0, Loc.F("Downloading {0}…", p.Name)),
+ Jobs.Install(PackKey(p.Id), source: 1, p.Name, p.Asset.Size, new StoreProgress(0, Loc.F("preferences.downloading", p.Name)),
(progress, ct) => _samples.InstallAsync(p, progress, ct),
() =>
{
@@ -321,23 +321,23 @@ public sealed partial class PreferencesWindow
main?.Browser.RebuildSamples();
// Its instruments become Nota Mosaic presets (Packs → the pack) in the background.
_ = App.Services.GetService<IMosaicPacks>()?.ScanAsync();
- return Task.FromResult(Loc.F("{0} is installed — find it under Downloaded in the browser's Files tab, where it is being analysed for tempo and key; its instruments appear under Nota Mosaic → Packs.", p.Name));
+ return Task.FromResult(Loc.F("preferences.samples.is_installed_find_it_under", p.Name));
});
}
private async void RemovePack(StorePack p, InstalledStorePack inst)
{
if (Jobs.Busy) return;
- var ok = await new ConfirmWindow(Loc.T("Remove sample pack"),
- Loc.F("Remove {0}? Its folder ({1}) is deleted.", p.Name, inst.Path),
- Loc.T("Remove"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ var ok = await new ConfirmWindow(Loc.T("preferences.samples.remove_sample_pack"),
+ Loc.F("preferences.samples.remove_its_folder_is_deleted", p.Name, inst.Path),
+ Loc.T("preferences.remove"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
var main = _main;
- Jobs.Remove(PackKey(p.Id), source: 1, Loc.F("Removing {0}…", p.Name), async () =>
+ Jobs.Remove(PackKey(p.Id), source: 1, Loc.F("preferences.removing", p.Name), async () =>
{
await Task.Run(() => _samples.Uninstall(p.Id));
main?.Browser.RebuildSamples();
- return Loc.F("{0} was removed.", p.Name);
+ return Loc.F("preferences.was_removed", p.Name);
});
}
diff --git a/src/managed/Nota.App/PreferencesWindow.Store.cs b/src/managed/Nota.App/PreferencesWindow.Store.cs
index 8e92a4a0..74c5fc4d 100644
--- a/src/managed/Nota.App/PreferencesWindow.Store.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Store.cs
@@ -34,7 +34,7 @@ namespace Nota.App;
public sealed partial class PreferencesWindow
{
- private static readonly string[] StoreFilters = { Loc.T("All"), Loc.T("Instruments"), Loc.T("Effects"), Loc.T("Installed") };
+ private static readonly string[] StoreFilters = { Loc.T("preferences.all"), Loc.T("common.instruments"), Loc.T("preferences.store.effects"), Loc.T("preferences.installed") };
private readonly IPluginStore _store = App.Services.GetRequiredService<IPluginStore>();
private IReadOnlyList<StorePlugin>? _storePlugins;
@@ -62,7 +62,7 @@ public sealed partial class PreferencesWindow
private Button _dockCancel = null!;
private Control _dockClose = null!;
- private static readonly string StoreIntro = Loc.T("Open-source VST3 plugins from the Nota plugin registry. Each one downloads from the project's own GitHub release, is checked against the registry's checksum and unpacked — installers never run.");
+ private static readonly string StoreIntro = Loc.T("preferences.store.open_source_vst3_plugins_from");
// The Plug-ins half of Downloads (PreferencesWindow.Downloads.cs): its toolbar pins to the
// top while the body scrolls.
@@ -95,10 +95,10 @@ public sealed partial class PreferencesWindow
segs.Add(b);
strip.Children.Add(b);
}
- var search = new TextBox { PlaceholderText = Loc.T("Search"), Text = _storeSearch, Classes = { "search" }, FontSize = 12 };
+ var search = new TextBox { PlaceholderText = Loc.T("preferences.search"), Text = _storeSearch, Classes = { "search" }, FontSize = 12 };
search.TextChanged += (_, _) => { _storeSearch = search.Text ?? ""; RenderStoreList(); };
- var refresh = new Button { Content = Loc.T("Refresh"), Classes = { "ghost" }, Height = 30, FontSize = 12, Padding = new Thickness(12, 0), Foreground = TextSecondary };
- ToolTip.SetTip(refresh, Loc.T("Reload the registry"));
+ var refresh = new Button { Content = Loc.T("preferences.refresh"), Classes = { "ghost" }, Height = 30, FontSize = 12, Padding = new Thickness(12, 0), Foreground = TextSecondary };
+ ToolTip.SetTip(refresh, Loc.T("preferences.reload_the_registry"));
refresh.Click += (_, _) => { if (!_storeLoading) _storeLoad = LoadStoreAsync(refresh: true); };
_storeRefresh = refresh;
@@ -121,7 +121,7 @@ public sealed partial class PreferencesWindow
{
_storeStatus,
new StackPanel { Spacing = 6, Children = { _storeLoadBar, _storeList } },
- Caption(Loc.F("Installed to {0}", _store.PluginsDir)),
+ Caption(Loc.F("preferences.installed_to", _store.PluginsDir)),
},
};
// Only forget the controls if they are still these: switching to Sample Packs and back
@@ -199,13 +199,13 @@ public sealed partial class PreferencesWindow
Children =
{
new ProgressBar { IsIndeterminate = true, Width = 180, Height = 4, MinWidth = 0 },
- new TextBlock { Text = Loc.T("Loading the plugin registry…"), FontSize = 12, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center },
+ new TextBlock { Text = Loc.T("preferences.store.loading_the_plugin_registry"), FontSize = 12, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center },
},
},
});
private static string CurrentOsName =>
- OperatingSystem.IsMacOS() ? "macOS" : OperatingSystem.IsWindows() ? Loc.T("Windows") : OperatingSystem.IsLinux() ? Loc.T("Linux") : "this computer";
+ OperatingSystem.IsMacOS() ? "macOS" : OperatingSystem.IsWindows() ? Loc.T("preferences.store.windows") : OperatingSystem.IsLinux() ? Loc.T("preferences.store.linux") : "this computer";
private void RenderStoreList()
{
@@ -215,7 +215,7 @@ public sealed partial class PreferencesWindow
if (_storeRefresh is not null)
{
_storeRefresh.IsEnabled = !_storeLoading;
- _storeRefresh.Content = _storeLoading && _storePlugins is not null ? Loc.T("Refreshing…") : Loc.T("Refresh");
+ _storeRefresh.Content = _storeLoading && _storePlugins is not null ? Loc.T("preferences.refreshing") : Loc.T("preferences.refresh");
}
if (_storeLoadBar is not null) _storeLoadBar.IsVisible = _storeLoading && _storePlugins is not null;
if (_storePlugins is null)
@@ -240,7 +240,7 @@ public sealed partial class PreferencesWindow
{
var empty = new TextBlock
{
- Text = _storeFilter == 3 && q.Length == 0 ? Loc.T("Nothing installed from the registry yet.") : Loc.T("Nothing matches."),
+ Text = _storeFilter == 3 && q.Length == 0 ? Loc.T("preferences.store.nothing_installed_from_the_registry") : Loc.T("preferences.nothing_matches"),
FontSize = 12, Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(28),
};
_storeList.Content = Table(new List<Control> { empty });
@@ -255,7 +255,7 @@ public sealed partial class PreferencesWindow
if (unavailable.Count > 0)
{
// The heading sits at the very top when nothing else matched — no rule above it then.
- if (available.Count > 0) items.Add(new StoreSection(Loc.T("Not available for this computer"), unavailable.Count));
+ if (available.Count > 0) items.Add(new StoreSection(Loc.T("preferences.store.not_available_for_this_computer"), unavailable.Count));
items.AddRange(unavailable.Select(p => new StoreEntry(p, installed.GetValueOrDefault(p.Id), First: false)));
}
if (available.Count == 0 && items[0] is StoreEntry first) items[0] = first with { First = true };
@@ -311,9 +311,9 @@ public sealed partial class PreferencesWindow
_dockTitle = new TextBlock { FontSize = 12, FontWeight = FontWeight.Medium, Foreground = TextPrimary, TextWrapping = TextWrapping.Wrap, VerticalAlignment = VerticalAlignment.Center };
_dockDetail = new TextBlock { FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
_dockBar = new ProgressBar { Minimum = 0, Maximum = 1, Height = 4, MinWidth = 0 };
- _dockCancel = StoreButton(Loc.T("Cancel"), enabled: true, Jobs.Cancel);
+ _dockCancel = StoreButton(Loc.T("common.cancel"), enabled: true, Jobs.Cancel);
_dockCancel.VerticalAlignment = VerticalAlignment.Center;
- ToolTip.SetTip(_dockCancel, Loc.T("Stop the download — nothing is changed"));
+ ToolTip.SetTip(_dockCancel, Loc.T("preferences.store.stop_the_download_nothing_is"));
_dockClose = new Button
{
Content = new Glyph(GlyphKind.Close, 10), Classes = { "ghost" }, Width = 26, Height = 26, Padding = new Thickness(0),
@@ -395,7 +395,7 @@ public sealed partial class PreferencesWindow
bool busy = Jobs.BusyId is not null;
if (Jobs.BusyId == p.Id)
{
- actions.Children.Add(StoreButton(inst is null ? Loc.T("Installing…") : Loc.T("Working…"), enabled: false, () => { }));
+ actions.Children.Add(StoreButton(inst is null ? Loc.T("preferences.installing") : Loc.T("preferences.working"), enabled: false, () => { }));
}
else if (p.Asset is null)
{
@@ -403,19 +403,19 @@ public sealed partial class PreferencesWindow
}
else if (inst is null)
{
- actions.Children.Add(StoreButton(Loc.T("Install"), enabled: !busy, () => InstallFromStore(p)));
+ actions.Children.Add(StoreButton(Loc.T("preferences.install"), enabled: !busy, () => InstallFromStore(p)));
}
else
{
if (inst.Version != p.Version)
- actions.Children.Add(StoreButton(Loc.F("Update to {0}", p.Version), enabled: !busy, () => InstallFromStore(p)));
+ actions.Children.Add(StoreButton(Loc.F("preferences.update_to", p.Version), enabled: !busy, () => InstallFromStore(p)));
else
actions.Children.Add(new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 6, Height = 26, HorizontalAlignment = HorizontalAlignment.Right,
- Children = { Dot(Brass), new TextBlock { Text = Loc.T("Installed"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center } },
+ Children = { Dot(Brass), new TextBlock { Text = Loc.T("preferences.installed"), FontSize = 11, FontWeight = FontWeight.Medium, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center } },
});
- actions.Children.Add(StoreLink(Loc.T("Remove"), null, busy ? null : () => RemoveFromStore(p)));
+ actions.Children.Add(StoreLink(Loc.T("preferences.remove"), null, busy ? null : () => RemoveFromStore(p)));
}
if (inst is null && p.Asset is { Size: > 0 } asset)
actions.Children.Add(new TextBlock
@@ -423,8 +423,8 @@ public sealed partial class PreferencesWindow
Text = NotaNum.Unit(asset.Size / 1048576.0, "0.0", "MB"), FontSize = 10, FontFamily = NotaFonts.MonoFamily,
Foreground = TextTertiary, HorizontalAlignment = HorizontalAlignment.Right,
});
- var source = StoreLink(Loc.T("Source"), GlyphKind.PopOut, () => _ = Launcher.LaunchUriAsync(new Uri(p.Repo)));
- ToolTip.SetTip(source, Loc.T("Open the source repository"));
+ var source = StoreLink(Loc.T("preferences.source"), GlyphKind.PopOut, () => _ = Launcher.LaunchUriAsync(new Uri(p.Repo)));
+ ToolTip.SetTip(source, Loc.T("preferences.store.open_the_source_repository"));
actions.Children.Add(source);
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto"), ColumnSpacing = 16, Margin = new Thickness(16, 14, 14, 14) };
@@ -473,8 +473,8 @@ public sealed partial class PreferencesWindow
foreach (var (prefix, name, icon, current) in new[]
{
("macos-", "macOS", GlyphKind.Apple, OperatingSystem.IsMacOS()),
- ("windows-", Loc.T("Windows"), GlyphKind.Windows, OperatingSystem.IsWindows()),
- ("linux-", Loc.T("Linux"), GlyphKind.Linux, OperatingSystem.IsLinux()),
+ ("windows-", Loc.T("preferences.store.windows"), GlyphKind.Windows, OperatingSystem.IsWindows()),
+ ("linux-", Loc.T("preferences.store.linux"), GlyphKind.Linux, OperatingSystem.IsLinux()),
})
{
var archs = keys.Where(k => k.StartsWith(prefix, StringComparison.Ordinal)).Select(k => ArchLabel(k[prefix.Length..])).Distinct().ToList();
@@ -492,25 +492,25 @@ public sealed partial class PreferencesWindow
{
var os = CurrentOsName;
var prefix = os is "macOS" ? "macos-" : os.ToLowerInvariant() + "-";
- if (!keys.Any(k => k.StartsWith(prefix, StringComparison.Ordinal))) return Loc.F("No {0} version", os);
+ if (!keys.Any(k => k.StartsWith(prefix, StringComparison.Ordinal))) return Loc.F("preferences.store.no_version", os);
var cpu = System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture == System.Runtime.InteropServices.Architecture.Arm64 ? "arm64" : "x64";
- return Loc.F("No {0} version for {1}", os, ArchLabel(cpu));
+ return Loc.F("preferences.store.no_version_for", os, ArchLabel(cpu));
}
private static string ArchLabel(string arch) => arch switch
{
- "universal" => Loc.T("Apple silicon + Intel"),
- "arm64" => OperatingSystem.IsMacOS() ? Loc.T("Apple silicon") : "ARM64",
+ "universal" => Loc.T("preferences.store.apple_silicon_intel"),
+ "arm64" => OperatingSystem.IsMacOS() ? Loc.T("preferences.store.apple_silicon") : "ARM64",
"x64" => "x64",
_ => arch,
};
private static string KindLabel(string kind) => kind switch
{
- "instrument" => Loc.T("Instrument"),
- "effect" => Loc.T("Effect"),
+ "instrument" => Loc.T("common.instrument"),
+ "effect" => Loc.T("preferences.store.effect"),
"midi" => "MIDI",
- "bundle" => Loc.T("Collection"),
+ "bundle" => Loc.T("preferences.store.collection"),
_ => NotaText.Label(kind.ToUpperInvariant()),
};
@@ -518,31 +518,31 @@ public sealed partial class PreferencesWindow
{
var main = _main;
var dir = _store.PluginsDir;
- Jobs.Install(p.Id, source: 0, p.Name, p.Asset?.Size ?? 0, new StoreProgress(0, Loc.F("Downloading {0}…", p.Name)),
+ Jobs.Install(p.Id, source: 0, p.Name, p.Asset?.Size ?? 0, new StoreProgress(0, Loc.F("preferences.downloading", p.Name)),
(progress, ct) => _store.InstallAsync(p, progress, ct),
async () =>
{
- Jobs.Report(new StoreProgress(-1, Loc.F("Scanning {0}…", p.Name)));
- return await RescanAfterStoreChange(main, dir, Loc.F("Scanning {0}…", p.Name))
- ? Loc.F("{0} {1} is installed — find it in the browser.", p.Name, p.Version)
- : Loc.F("{0} is installed. Rescan plugins to use it.", p.Name);
+ Jobs.Report(new StoreProgress(-1, Loc.F("preferences.store.scanning", p.Name)));
+ return await RescanAfterStoreChange(main, dir, Loc.F("preferences.store.scanning", p.Name))
+ ? Loc.F("preferences.store.is_installed_find_it_in", p.Name, p.Version)
+ : Loc.F("preferences.store.is_installed_rescan_plugins_to", p.Name);
});
}
private async void RemoveFromStore(StorePlugin p)
{
if (Jobs.Busy) return;
- var ok = await new ConfirmWindow(Loc.T("Remove plugin"),
- Loc.F("Remove {0}? Projects that use it will load without it until it's installed again.", p.Name),
- Loc.T("Remove"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ var ok = await new ConfirmWindow(Loc.T("preferences.store.remove_plugin"),
+ Loc.F("preferences.store.remove_projects_that_use_it", p.Name),
+ Loc.T("preferences.remove"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
var main = _main;
var dir = _store.PluginsDir;
- Jobs.Remove(p.Id, source: 0, Loc.F("Removing {0}…", p.Name), async () =>
+ Jobs.Remove(p.Id, source: 0, Loc.F("preferences.removing", p.Name), async () =>
{
_store.Uninstall(p.Id);
- await RescanAfterStoreChange(main, dir, Loc.F("Removing {0}…", p.Name));
- return Loc.F("{0} was removed.", p.Name);
+ await RescanAfterStoreChange(main, dir, Loc.F("preferences.removing", p.Name));
+ return Loc.F("preferences.was_removed", p.Name);
});
}
diff --git a/src/managed/Nota.App/PreferencesWindow.Updates.cs b/src/managed/Nota.App/PreferencesWindow.Updates.cs
index 4bf6605a..0981e2d7 100644
--- a/src/managed/Nota.App/PreferencesWindow.Updates.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Updates.cs
@@ -24,7 +24,7 @@ public sealed partial class PreferencesWindow
var settings = App.Services.GetRequiredService<ISettingsService>();
var updates = AppUpdates.Shared;
- var auto = SwitchRow(Loc.T("Check for updates automatically"), settings.Current.CheckForUpdates, on =>
+ var auto = SwitchRow(Loc.T("preferences.updates.check_for_updates_automatically"), settings.Current.CheckForUpdates, on =>
{
settings.Current.CheckForUpdates = on;
settings.Save();
@@ -33,8 +33,8 @@ public sealed partial class PreferencesWindow
var status = new TextBlock { FontSize = 12, Foreground = TextPrimary, TextWrapping = TextWrapping.Wrap, VerticalAlignment = VerticalAlignment.Center };
var detail = Caption("");
- var check = Btn(Loc.T("Check now"));
- var act = Btn(Loc.T("Update"));
+ var check = Btn(Loc.T("preferences.updates.check_now"));
+ var act = Btn(Loc.T("common.update"));
act.Classes.Add("primary");
check.Click += async (_, _) => await updates.CheckAsync();
act.Click += (_, _) =>
@@ -47,24 +47,24 @@ public sealed partial class PreferencesWindow
{
var r = updates.Release;
check.IsEnabled = !updates.Checking && updates.State is not (AppUpdates.Stage.Downloading or AppUpdates.Stage.Ready);
- check.Content = updates.Checking ? Loc.T("Checking…") : Loc.T("Check now");
+ check.Content = updates.Checking ? Loc.T("preferences.updates.checking") : Loc.T("preferences.updates.check_now");
act.IsVisible = r is not null && updates.State != AppUpdates.Stage.Ready;
(status.Text, detail.Text) = updates.State switch
{
- AppUpdates.Stage.Available => (Loc.F("Nota {0} is available — you have {1}.", r!.Version, AppInfo.Version),
- updates.CanInstall ? Loc.T("Update downloads it here; it installs when you restart or quit Nota.") : Loc.T("Download opens the release page.")),
- AppUpdates.Stage.Downloading => (Loc.F("Downloading Nota {0}…", r!.Version), Percent()),
- AppUpdates.Stage.Ready => (Loc.F("Nota {0} is ready to install.", r!.Version), Loc.T("It installs the next time you quit Nota, or click Restart to update in the status bar.")),
- AppUpdates.Stage.Failed => (Loc.T("The update didn't download."), updates.Error ?? ""),
- _ when updates.LastCheckFailed => (Loc.F("You have Nota {0}.", AppInfo.Version), Loc.T("Couldn't reach GitHub to check for a newer version. Check your internet connection and try again.")),
- _ when updates.LastChecked is { } at => (Loc.F("Nota {0} is the latest version.", AppInfo.Version), Loc.F("Last checked {0}.", When(at))),
- _ => (Loc.F("You have Nota {0}.", AppInfo.Version), Loc.T("Not checked yet.")),
+ AppUpdates.Stage.Available => (Loc.F("preferences.updates.nota_is_available_you_have", r!.Version, AppInfo.Version),
+ updates.CanInstall ? Loc.T("preferences.updates.update_downloads_it_here_it") : Loc.T("preferences.updates.download_opens_the_release_page")),
+ AppUpdates.Stage.Downloading => (Loc.F("common.downloading_nota", r!.Version), Percent()),
+ AppUpdates.Stage.Ready => (Loc.F("preferences.updates.nota_is_ready_to_install", r!.Version), Loc.T("preferences.updates.it_installs_the_next_time")),
+ AppUpdates.Stage.Failed => (Loc.T("preferences.updates.the_update_didnt_download"), updates.Error ?? ""),
+ _ when updates.LastCheckFailed => (Loc.F("preferences.updates.you_have_nota", AppInfo.Version), Loc.T("preferences.updates.couldnt_reach_github_to_check")),
+ _ when updates.LastChecked is { } at => (Loc.F("preferences.updates.nota_is_the_latest_version", AppInfo.Version), Loc.F("preferences.updates.last_checked", When(at))),
+ _ => (Loc.F("preferences.updates.you_have_nota", AppInfo.Version), Loc.T("preferences.updates.not_checked_yet")),
};
act.Content = updates.State switch
{
- AppUpdates.Stage.Downloading => Loc.T("Cancel"),
- AppUpdates.Stage.Failed => Loc.T("Try again"),
- _ => updates.CanInstall ? Loc.T("Update") : Loc.T("Download"),
+ AppUpdates.Stage.Downloading => Loc.T("common.cancel"),
+ AppUpdates.Stage.Failed => Loc.T("common.try_again"),
+ _ => updates.CanInstall ? Loc.T("common.update") : Loc.T("common.download"),
};
act.Classes.Set("primary", updates.State != AppUpdates.Stage.Downloading);
detail.IsVisible = detail.Text!.Length > 0;
@@ -83,12 +83,12 @@ public sealed partial class PreferencesWindow
new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { check, act } },
};
if (!updates.CanInstallInPlace)
- rows.Add(Caption(Loc.T("This copy of Nota can't replace itself (a development build, or one run straight from the disk image), so a new version opens its release page to download."), muted: true));
+ rows.Add(Caption(Loc.T("preferences.updates.this_copy_of_nota_cant"), muted: true));
return Sections(
- Section(Loc.T("Automatic updates"), 10, auto,
- Caption(Loc.T("On launch and once a day, Nota asks GitHub whether a newer version is out and tells you in the status bar. Nothing is downloaded until you click Update."))),
- Section(Loc.T("This version"), 10, rows.ToArray()));
+ Section(Loc.T("preferences.updates.automatic_updates"), 10, auto,
+ Caption(Loc.T("preferences.updates.on_launch_and_once_a"))),
+ Section(Loc.T("preferences.updates.this_version"), 10, rows.ToArray()));
}
// "today at 14:02", "yesterday at 09:15", or the date.
diff --git a/src/managed/Nota.App/PreferencesWindow.cs b/src/managed/Nota.App/PreferencesWindow.cs
index 6b72880c..fb811436 100644
--- a/src/managed/Nota.App/PreferencesWindow.cs
+++ b/src/managed/Nota.App/PreferencesWindow.cs
@@ -63,24 +63,24 @@ public sealed partial class PreferencesWindow : NotaWindow
private static readonly (string Group, Page[] Pages)[] Nav =
{
- (Loc.T("Devices", "settings"), new[]
+ (Loc.T("preferences.devices_settings"), new[]
{
- new Page("Audio", Loc.T("Audio"), Loc.T("Device, sample rate and buffer"), GlyphKind.Levels),
- new Page("MIDI", "MIDI", Loc.T("Controllers Nota listens to"), GlyphKind.MidiPort),
- new Page("Gamepads", Loc.T("Gamepads"), Loc.T("Play notes or drive mapped controls"), GlyphKind.Gamepad),
- new Page("Remote", Loc.T("Remote"), Loc.T("Phones and tablets on this network"), GlyphKind.Phone),
+ new Page("Audio", Loc.T("common.audio"), Loc.T("preferences.device_sample_rate_and_buffer"), GlyphKind.Levels),
+ new Page("MIDI", "MIDI", Loc.T("preferences.controllers_nota_listens_to"), GlyphKind.MidiPort),
+ new Page("Gamepads", Loc.T("preferences.gamepads"), Loc.T("preferences.play_notes_or_drive_mapped"), GlyphKind.Gamepad),
+ new Page("Remote", Loc.T("preferences.remote"), Loc.T("preferences.phones_and_tablets_on_this"), GlyphKind.Phone),
}),
- (Loc.T("Plug-ins"), new[]
+ (Loc.T("preferences.plug_ins"), new[]
{
- new Page("Plug-ins", Loc.T("Plug-ins"), Loc.T("Where Nota looks for VST3"), GlyphKind.Plug),
- new Page("Downloads", Loc.T("Downloads"), Loc.T("Plug-ins, sample packs and AI models"), GlyphKind.Downloads),
+ new Page("Plug-ins", Loc.T("preferences.plug_ins"), Loc.T("preferences.where_nota_looks_for_vst3"), GlyphKind.Plug),
+ new Page("Downloads", Loc.T("preferences.downloads"), Loc.T("preferences.plug_ins_sample_packs_and"), GlyphKind.Downloads),
}),
- (Loc.T("General"), new[]
+ (Loc.T("preferences.general"), new[]
{
- new Page("Library", Loc.T("Library"), Loc.T("Content folders and version history"), GlyphKind.Library),
- new Page("Appearance", Loc.T("Appearance"), Loc.T("Theme, scale, waveforms and AI control"), GlyphKind.Appearance),
- new Page("Shortcuts", Loc.T("Shortcuts"), Loc.T("Keyboard reference"), GlyphKind.Shortcuts),
- new Page("Updates", Loc.T("Updates"), Loc.T("New versions of Nota"), GlyphKind.Update),
+ new Page("Library", Loc.T("preferences.library"), Loc.T("preferences.content_folders_and_version_history"), GlyphKind.Library),
+ new Page("Appearance", Loc.T("preferences.appearance"), Loc.T("preferences.theme_scale_waveforms_and_ai"), GlyphKind.Appearance),
+ new Page("Shortcuts", Loc.T("preferences.shortcuts"), Loc.T("preferences.keyboard_reference"), GlyphKind.Shortcuts),
+ new Page("Updates", Loc.T("preferences.updates"), Loc.T("preferences.new_versions_of_nota"), GlyphKind.Update),
}),
};
@@ -125,7 +125,7 @@ public sealed partial class PreferencesWindow : NotaWindow
{
_ = vm; // toolbar-side pref retired with the fixed 1b layout
_main = main;
- Title = Loc.T("Settings");
+ Title = Loc.T("common.settings");
Width = 880;
Height = 640;
// The widest page (Appearance: two theme cards beside the labels) still fits; the
@@ -293,7 +293,7 @@ public sealed partial class PreferencesWindow : NotaWindow
private Control AudioPane()
{
- if (_main is null) return Caption(Loc.T("Audio settings are unavailable in this window."));
+ if (_main is null) return Caption(Loc.T("preferences.audio_settings_are_unavailable_in"));
_loading = true;
var engine = _main.Engine;
@@ -308,12 +308,12 @@ public sealed partial class PreferencesWindow : NotaWindow
inputCombo.SelectionChanged += (_, _) => { int i = inputCombo.SelectedIndex; if (i >= 0 && i < _inputUids.Count) { engine.SetAudioInputDevice(_inputUids[i]); Apply(); } };
var srCombo = Combo(150);
- foreach (var sr in SampleRates) srCombo.Items.Add(sr == 0 ? Loc.T("Device default") : NotaNum.Unit(sr, "0", "Hz"));
+ foreach (var sr in SampleRates) srCombo.Items.Add(sr == 0 ? Loc.T("preferences.device_default") : NotaNum.Unit(sr, "0", "Hz"));
srCombo.SelectedIndex = IndexOf(SampleRates, cfg.SampleRate);
srCombo.SelectionChanged += (_, _) => { int i = srCombo.SelectedIndex; if (i >= 0) { engine.SetAudioSampleRate(SampleRates[i]); Apply(); } };
var bufCombo = Combo(150);
- foreach (var b in BufferSizes) bufCombo.Items.Add(b == 0 ? Loc.T("Device default") : b.ToString());
+ foreach (var b in BufferSizes) bufCombo.Items.Add(b == 0 ? Loc.T("preferences.device_default") : b.ToString());
bufCombo.SelectedIndex = IndexOf(BufferSizes, cfg.BufferFrames);
bufCombo.SelectionChanged += (_, _) => { int i = bufCombo.SelectedIndex; if (i >= 0) { engine.SetAudioBufferFrames(BufferSizes[i]); Apply(); } };
@@ -330,17 +330,17 @@ public sealed partial class PreferencesWindow : NotaWindow
if (asio)
{
AsioRows(device, engine, srCombo);
- device.Add(Row(Loc.T("Latency"), latency));
+ device.Add(Row(Loc.T("preferences.latency"), latency));
var asioBody = Sections(
- Section(Loc.T("Audio device"), 6, device.ToArray()),
- Section(Loc.T("Test"), 8, TestToneRow(), CpuCheckRow(engine)));
+ Section(Loc.T("preferences.audio_device"), 6, device.ToArray()),
+ Section(Loc.T("preferences.test"), 8, TestToneRow(), CpuCheckRow(engine)));
_loading = false;
return asioBody;
}
device.AddRange(new[]
{
- Row(Loc.T("Output"), outputCombo), Row(Loc.T("Input"), inputCombo),
- Row(Loc.T("Sample rate"), srCombo), Row(Loc.T("Buffer size"), bufCombo),
+ Row(Loc.T("common.output"), outputCombo), Row(Loc.T("common.input"), inputCombo),
+ Row(Loc.T("preferences.sample_rate"), srCombo), Row(Loc.T("preferences.buffer_size"), bufCombo),
});
// WASAPI exclusive (Windows only): lets Nota own the output device for the lowest
// latency, at the cost of muting other apps. The device then dictates the sample rate /
@@ -348,19 +348,19 @@ public sealed partial class PreferencesWindow : NotaWindow
// not allowed), the backend falls back to shared mode and the latency line says so.
if (OperatingSystem.IsWindows())
{
- device.Add(Row(Loc.T("Exclusive mode"), SwitchRow(Loc.T("WASAPI exclusive — lowest latency, mutes other apps"), cfg.WasapiExclusive, on =>
+ device.Add(Row(Loc.T("preferences.exclusive_mode"), SwitchRow(Loc.T("preferences.wasapi_exclusive_lowest_latency_mutes"), cfg.WasapiExclusive, on =>
{
if (_loading) return;
engine.SetAudioWasapiExclusive(on);
Apply();
})));
- device.Add(Row("", Caption(Loc.T("The device's native sample rate and buffer size are used instead of the ones above. If it is busy or doesn't allow exclusive access, Nota falls back to shared mode."))));
+ device.Add(Row("", Caption(Loc.T("preferences.the_devices_native_sample_rate"))));
}
- device.Add(Row(Loc.T("Latency"), latency));
+ device.Add(Row(Loc.T("preferences.latency"), latency));
var body = Sections(
- Section(Loc.T("Audio device"), 6, device.ToArray()),
- Section(Loc.T("Test"), 8, TestToneRow(), CpuCheckRow(engine)));
+ Section(Loc.T("preferences.audio_device"), 6, device.ToArray()),
+ Section(Loc.T("preferences.test"), 8, TestToneRow(), CpuCheckRow(engine)));
_loading = false;
return body;
}
@@ -372,7 +372,7 @@ public sealed partial class PreferencesWindow : NotaWindow
var drivers = engine.AsioDrivers();
var combo = Combo(150);
combo.Items.Add("WASAPI");
- combo.Items.Add(new ComboBoxItem { Content = Loc.T("ASIO"), IsEnabled = drivers.Count > 0 || asio });
+ combo.Items.Add(new ComboBoxItem { Content = Loc.T("preferences.asio_caps"), IsEnabled = drivers.Count > 0 || asio });
combo.SelectedIndex = asio ? 1 : 0;
combo.SelectionChanged += (_, _) =>
{
@@ -383,11 +383,11 @@ public sealed partial class PreferencesWindow : NotaWindow
Apply();
RebuildAudioPane();
};
- device.Add(Row(Loc.T("Audio system"), combo));
+ device.Add(Row(Loc.T("preferences.audio_system"), combo));
if (drivers.Count == 0 && !asio)
device.Add(Row("", Caption(RuntimeInformation.ProcessArchitecture == Architecture.Arm64
- ? Loc.T("No ASIO driver found. Few interfaces ship an ARM64 ASIO driver yet — install one from your interface's maker, or a generic one such as FlexASIO.")
- : Loc.T("No ASIO driver found. Install your interface's driver, or a generic one such as FlexASIO."))));
+ ? Loc.T("preferences.no_asio_driver_found_few")
+ : Loc.T("preferences.no_asio_driver_found_install"))));
}
// Driver · Output pair · Input pair · Sample rate · Buffer size (read-only) under ASIO.
@@ -406,7 +406,7 @@ public sealed partial class PreferencesWindow : NotaWindow
// any installed one (even the only one) is a real change that stages and applies it.
bool missing = saved.Length > 0 && selected < 0;
int offset = missing ? 1 : 0;
- if (missing) driverCombo.Items.Add(Loc.T("Saved driver not found"));
+ if (missing) driverCombo.Items.Add(Loc.T("preferences.saved_driver_not_found"));
foreach (var d in drivers) driverCombo.Items.Add(d.Name);
driverCombo.SelectedIndex = missing ? 0 : selected >= 0 ? selected : (drivers.Count > 0 ? 0 : -1);
driverCombo.SelectionChanged += (_, _) =>
@@ -421,7 +421,7 @@ public sealed partial class PreferencesWindow : NotaWindow
};
// Running: the driver's own panel (a change there comes back as a reset event). In the
// WASAPI fallback: try the driver again — it may be free or plugged in now (US4-3).
- var panel = Btn(running ? Loc.T("Driver settings…") : Loc.T("Try again"));
+ var panel = Btn(running ? Loc.T("preferences.driver_settings") : Loc.T("common.try_again"));
panel.IsEnabled = running || drivers.Count > 0;
panel.Click += (_, _) =>
{
@@ -431,13 +431,13 @@ public sealed partial class PreferencesWindow : NotaWindow
Apply();
RebuildAudioPane();
};
- device.Add(Row(Loc.T("Driver"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { driverCombo, panel } }));
+ device.Add(Row(Loc.T("preferences.driver"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { driverCombo, panel } }));
if (running)
{
- device.Add(Row(Loc.T("Output"), PairCombo(engine, input: false, engine.AsioChannels(false))));
+ device.Add(Row(Loc.T("common.output"), PairCombo(engine, input: false, engine.AsioChannels(false))));
var ins = engine.AsioChannels(true);
- device.Add(Row(Loc.T("Input"), ins.Count > 0 ? PairCombo(engine, input: true, ins) : Caption(Loc.T("No inputs on this driver"))));
+ device.Add(Row(Loc.T("common.input"), ins.Count > 0 ? PairCombo(engine, input: true, ins) : Caption(Loc.T("preferences.no_inputs_on_this_driver"))));
}
// Sample rate is a request: a rate the driver refuses is reverted and explained (FR-007).
@@ -448,7 +448,7 @@ public sealed partial class PreferencesWindow : NotaWindow
void ShowRefusal()
{
double r = _main?.RefusedSampleRate ?? 0;
- refused.Text = r > 0 ? Loc.F("The driver doesn't support {0}", NotaNum.Unit(r / 1000, "0.#", "kHz")) : "";
+ refused.Text = r > 0 ? Loc.F("preferences.the_driver_doesnt_support", NotaNum.Unit(r / 1000, "0.#", "kHz")) : "";
refused.IsVisible = r > 0;
}
ShowRefusal();
@@ -464,12 +464,12 @@ public sealed partial class PreferencesWindow : NotaWindow
srCombo.SelectedIndex = 0;
_loading = false;
};
- device.Add(Row(Loc.T("Sample rate"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 10, Children = { srCombo, refused } }));
+ device.Add(Row(Loc.T("preferences.sample_rate"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 10, Children = { srCombo, refused } }));
int buf = engine.NegotiatedBufferFrames;
- device.Add(Row(Loc.T("Buffer size"), Caption(running && buf > 0
- ? Loc.F("{0} frames (set in the driver's settings)", buf)
- : Loc.T("Set in the driver's settings"))));
+ device.Add(Row(Loc.T("preferences.buffer_size"), Caption(running && buf > 0
+ ? Loc.F("preferences.frames_set_in_the_drivers", buf)
+ : Loc.T("preferences.set_in_the_drivers_settings"))));
}
// Channel pairs of the open driver, labelled from its own names ("Out 1 + 2", "Analog 3 + 4");
@@ -515,18 +515,18 @@ public sealed partial class PreferencesWindow : NotaWindow
private Control TestToneRow()
{
- var button = Btn(Loc.T("Play test tone"));
+ var button = Btn(Loc.T("preferences.play_test_tone"));
button.Width = 132;
- var note = Caption(Loc.F("{0:0}\u2009Hz sine at −14\u2009dBFS, through the master.", TestToneHz));
+ var note = Caption(Loc.F("preferences.hz_sine_at_14_dbfs", TestToneHz));
button.Click += (_, _) =>
{
SetTone(!_toneOn);
button.Content = _toneOn
- ? new StackPanel { Orientation = Orientation.Horizontal, Spacing = 7, Children = { new Glyph(GlyphKind.Stop, 8), new TextBlock { Text = Loc.T("Stop tone") } } }
- : Loc.T("Play test tone");
+ ? new StackPanel { Orientation = Orientation.Horizontal, Spacing = 7, Children = { new Glyph(GlyphKind.Stop, 8), new TextBlock { Text = Loc.T("preferences.stop_tone") } } }
+ : Loc.T("preferences.play_test_tone");
button.Classes.Set("primary", _toneOn);
};
- return TestRow(Loc.T("Output check"), button, note);
+ return TestRow(Loc.T("preferences.output_check"), button, note);
}
private void SetTone(bool on)
@@ -541,19 +541,19 @@ public sealed partial class PreferencesWindow : NotaWindow
// counts dropouts over the same window, then gives a verdict for the current buffer size.
private Control CpuCheckRow(IAudioEngine engine)
{
- var button = Btn(Loc.T("CPU check"));
+ var button = Btn(Loc.T("preferences.cpu_check"));
button.Width = 132;
- var result = Caption(Loc.T("Measures audio-thread load for 5\u2009s — play your project for a real-world figure."));
+ var result = Caption(Loc.T("preferences.measures_audio_thread_load_for"));
button.Click += (_, _) =>
{
if (_cpuTimer is not null) return;
if (engine.NegotiatedSampleRate <= 0)
{
- result.Text = Loc.T("Audio device not running.");
+ result.Text = Loc.T("preferences.audio_device_not_running");
result.Foreground = NotaPalette.Danger;
return;
}
- button.Content = Loc.T("Measuring…");
+ button.Content = Loc.T("preferences.measuring");
result.Foreground = TextTertiary;
int ticks = 0, xrunsStart = engine.XrunCount;
double sum = 0, peak = 0;
@@ -564,24 +564,24 @@ public sealed partial class PreferencesWindow : NotaWindow
sum += load; peak = Math.Max(peak, load); ticks++;
if (ticks < CpuCheckTicks)
{
- result.Text = Loc.F("Measuring… {0}\u2009s left · now {1:0}\u2009%", (CpuCheckTicks - ticks + 9) / 10, load * 100);
+ result.Text = Loc.F("preferences.measuring_s_left_now", (CpuCheckTicks - ticks + 9) / 10, load * 100);
return;
}
StopCpuCheck();
- button.Content = Loc.T("CPU check");
+ button.Content = Loc.T("preferences.cpu_check");
int xruns = Math.Max(0, engine.XrunCount - xrunsStart);
var (verdict, brush) = peak > 0.9 || xruns > 0
- ? (Loc.T("overloaded — raise the buffer size"), NotaPalette.Danger)
+ ? (Loc.T("preferences.overloaded_raise_the_buffer_size"), NotaPalette.Danger)
: peak > 0.7
- ? (Loc.T("close to the limit — consider a larger buffer"), NotaPalette.Warning)
- : (Loc.T("plenty of headroom"), TextSecondary);
- result.Text = Loc.F("Last check: {0:0}\u2009% average, {1:0}\u2009% peak · {2} — {3}.", sum / ticks * 100, peak * 100, Loc.Plural(xruns, "{0} dropout", "{0} dropouts"), verdict);
+ ? (Loc.T("preferences.close_to_the_limit_consider"), NotaPalette.Warning)
+ : (Loc.T("preferences.plenty_of_headroom"), TextSecondary);
+ result.Text = Loc.F("preferences.last_check_average_peak", sum / ticks * 100, peak * 100, Loc.Plural("preferences.dropouts", xruns), verdict);
result.Foreground = brush;
};
- result.Text = Loc.T("Measuring… 5\u2009s left — play your project for a real-world figure.");
+ result.Text = Loc.T("preferences.measuring_5_s_left_play");
_cpuTimer.Start();
};
- return TestRow(Loc.T("Performance"), button, result);
+ return TestRow(Loc.T("preferences.performance"), button, result);
}
private void StopCpuCheck()
@@ -618,15 +618,15 @@ public sealed partial class PreferencesWindow : NotaWindow
{
string why = eng.AudioFallbackReason;
_latencyValue.Text = buf > 0 ? NotaNum.Unit(buf / sr * 1000, "0.0", "ms") : "";
- _latencyDetail.Text = Loc.F("ASIO unavailable ({0}) → WASAPI", why.Length > 0 ? why : Loc.T("the driver didn't start"));
+ _latencyDetail.Text = Loc.F("preferences.asio_unavailable_wasapi", why.Length > 0 ? why : Loc.T("preferences.the_driver_didnt_start"));
}
else
{
int outLat = eng.OutputLatencyFrames > 0 ? eng.OutputLatencyFrames : buf;
int inLat = eng.InputLatencyFrames;
- string roundTrip = inLat > 0 ? Loc.F(" · round trip {0}", NotaNum.Unit((inLat + outLat) / sr * 1000, "0.0", "ms")) : "";
+ string roundTrip = inLat > 0 ? Loc.F("preferences.round_trip", NotaNum.Unit((inLat + outLat) / sr * 1000, "0.0", "ms")) : "";
_latencyValue.Text = NotaNum.Unit(outLat / sr * 1000, "0.0", "ms");
- _latencyDetail.Text = Loc.F("ASIO · {0} frames @ {1}{2}", buf, khz, roundTrip);
+ _latencyDetail.Text = Loc.F("preferences.asio_frames", buf, khz, roundTrip);
}
_latencyValue.IsVisible = _latencyValue.Text.Length > 0;
return;
@@ -636,9 +636,9 @@ public sealed partial class PreferencesWindow : NotaWindow
: OperatingSystem.IsWindows() && _main.Engine.GetAudioConfig().WasapiExclusive ? " · exclusive" : "";
string rate = NotaNum.Unit(sr / 1000, "0.#", "kHz");
(_latencyValue.Text, _latencyDetail.Text) = sr <= 0
- ? ("", Loc.T("Audio device not running."))
+ ? ("", Loc.T("preferences.audio_device_not_running"))
: buf > 0
- ? (NotaNum.Unit(buf / sr * 1000, "0.0", "ms"), Loc.F("{0} frames @ {1}{2}", buf, rate, mode))
+ ? (NotaNum.Unit(buf / sr * 1000, "0.0", "ms"), Loc.F("preferences.frames", buf, rate, mode))
: (rate, mode.TrimStart(' ', '·'));
_latencyValue.IsVisible = _latencyValue.Text.Length > 0;
}
@@ -647,13 +647,13 @@ public sealed partial class PreferencesWindow : NotaWindow
private Control MidiPane()
{
- if (_main is null) return Caption(Loc.T("MIDI settings are unavailable in this window."));
+ if (_main is null) return Caption(Loc.T("preferences.midi_settings_are_unavailable_in"));
var engine = _main.Engine;
var devices = _midiDevices.InputDevices();
var items = new List<Control> { };
if (devices.Count == 0)
- items.Add(EmptyBox(Loc.T("No MIDI inputs detected. Connect a controller and reopen Settings.")));
+ items.Add(EmptyBox(Loc.T("preferences.no_midi_inputs_detected_connect")));
else
{
var rows = new List<Control>();
@@ -682,8 +682,8 @@ public sealed partial class PreferencesWindow : NotaWindow
}
items.Add(Table(rows));
}
- items.Add(Caption(Loc.T("Switch a controller off to stop Nota listening to it. New devices are on by default.")));
- return Sections(Section(Loc.T("MIDI inputs"), 8, items.ToArray()), MpeSection(engine));
+ items.Add(Caption(Loc.T("preferences.switch_a_controller_off_to")));
+ return Sections(Section(Loc.T("preferences.midi_inputs"), 8, items.ToArray()), MpeSection(engine));
}
private static readonly int[] MpeBendRanges = [12, 24, 48, 96];
@@ -694,7 +694,7 @@ public sealed partial class PreferencesWindow : NotaWindow
{
var (on, range) = engine.GetMpe();
var rangeCombo = Combo(150);
- foreach (var r in MpeBendRanges) rangeCombo.Items.Add(Loc.F("±{0} semitones", r));
+ foreach (var r in MpeBendRanges) rangeCombo.Items.Add(Loc.F("preferences.semitones", r));
int idx = Array.IndexOf(MpeBendRanges, range);
rangeCombo.SelectedIndex = idx >= 0 ? idx : Array.IndexOf(MpeBendRanges, 48);
rangeCombo.IsEnabled = on;
@@ -705,30 +705,30 @@ public sealed partial class PreferencesWindow : NotaWindow
engine.SetMpe(engine.GetMpe().Enabled, MpeBendRanges[k]);
_main!.ApplyMidiSettings();
};
- var sw = SwitchRow(Loc.T("Per-note expression from MPE controllers"), on, v =>
+ var sw = SwitchRow(Loc.T("preferences.per_note_expression_from_mpe"), on, v =>
{
rangeCombo.IsEnabled = v;
engine.SetMpe(v, engine.GetMpe().BendRange);
_main!.ApplyMidiSettings();
});
return Section("MPE", 8,
- Row(Loc.T("Expression"), sw),
- Row(Loc.T("Bend range"), rangeCombo),
- Row("", Caption(Loc.T("Channels 2–16 each carry one note with its own pitch bend, pressure and slide (CC74). A controller that announces its range overrides this one. Channel 1 plays as an ordinary keyboard, its pitch wheel and aftertouch moving the whole instrument. ") +
- Loc.T("Nota Synth, Volt, Aurora, Operator, Pentad and Physical play per-note expression."))));
+ Row(Loc.T("preferences.expression"), sw),
+ Row(Loc.T("preferences.bend_range"), rangeCombo),
+ Row("", Caption(Loc.T("preferences.channels_2_16_each_carry") +
+ Loc.T("preferences.nota_synth_volt_aurora_operator"))));
}
// ---- Gamepads -----------------------------------------------------------
private Control GamepadsPane()
{
- if (_main is null) return Caption(Loc.T("Gamepad settings are unavailable in this window."));
- if (!OperatingSystem.IsMacOS()) return Caption(Loc.T("Gamepad input is macOS-only in this build."));
+ if (_main is null) return Caption(Loc.T("preferences.gamepad_settings_are_unavailable_in"));
+ if (!OperatingSystem.IsMacOS()) return Caption(Loc.T("preferences.gamepad_input_is_macos_only"));
// The master switch lives in Settings (not the native engine): the pad thread
// always runs once started so new pads are still detected, but button edges only
// reach the engine while this is on.
- var enable = SwitchRow(Loc.T("Use a connected gamepad for notes and mapped controls"), _main.Settings.Current.GamepadEnabled, on =>
+ var enable = SwitchRow(Loc.T("preferences.use_a_connected_gamepad_for"), _main.Settings.Current.GamepadEnabled, on =>
{
_main.Settings.Current.GamepadEnabled = on;
_main.Settings.Save();
@@ -748,7 +748,7 @@ public sealed partial class PreferencesWindow : NotaWindow
var pads = _gamepads.Pads();
if (pads.Count == 0)
{
- padHost.Content = EmptyBox(Loc.T("No gamepad detected. Connect one and it appears here."));
+ padHost.Content = EmptyBox(Loc.T("preferences.no_gamepad_detected_connect_one"));
return;
}
var rows = new List<Control>();
@@ -765,7 +765,7 @@ public sealed partial class PreferencesWindow : NotaWindow
Text = pads[i].Name, FontSize = 12, Foreground = TextPrimary,
VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis,
};
- var cap = new TextBlock { Text = Loc.T("Last"), FontSize = 11, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
+ var cap = new TextBlock { Text = Loc.T("preferences.last"), FontSize = 11, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
rows.Add(ListRow(40, "Auto,*,Auto,Auto", Dot(Success), name, cap, last));
}
padHost.Content = Table(rows);
@@ -807,8 +807,8 @@ public sealed partial class PreferencesWindow : NotaWindow
var map = new List<Control>();
foreach (var (input, action) in new[]
{
- (Loc.T("Face buttons"), "C4 D4 E4 F4"), (Loc.T("Shoulder buttons"), "G4 A4 B4 C5"),
- (Loc.T("D-pad up / down"), Loc.T("Octave −1 / +1")), (Loc.T("D-pad left / right"), Loc.T("Velocity − / +")),
+ (Loc.T("preferences.face_buttons"), "C4 D4 E4 F4"), (Loc.T("preferences.shoulder_buttons"), "G4 A4 B4 C5"),
+ (Loc.T("preferences.d_pad_up_down"), Loc.T("preferences.octave_1_1")), (Loc.T("preferences.d_pad_left_right"), Loc.T("preferences.velocity")),
})
{
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions($"{LabelCol},*") };
@@ -820,11 +820,11 @@ public sealed partial class PreferencesWindow : NotaWindow
}
return Sections(
- Section(Loc.T("Gamepad input"), 10, enable, padHost),
- Section(Loc.T("Layout"), 10,
+ Section(Loc.T("preferences.gamepad_input"), 10, enable, padHost),
+ Section(Loc.T("preferences.layout"), 10,
Table(map),
- Caption(Loc.T("Notes go to the armed (record-enabled) instrument track — enable Record to capture them, or use the audition track to just play."), muted: true),
- Caption(Loc.T("Any button can be mapped to a control instead: click MIDI in the top-right, click the control, then press the button. A mapped button drives that control and stops playing its note; the rest of the pad keeps the layout above. The sticks and the trigger travel map the same way and are continuous, so they suit a knob or a fader — they play no notes, and do nothing until mapped. Mappings are listed in the browser's MIDI Map tab and travel with the project."))));
+ Caption(Loc.T("preferences.notes_go_to_the_armed"), muted: true),
+ Caption(Loc.T("preferences.any_button_can_be_mapped"))));
}
// ---- Plug-ins ---------------------------------------------------------
@@ -837,8 +837,8 @@ public sealed partial class PreferencesWindow : NotaWindow
Background = Sunken, BorderBrush = Divider, BorderThickness = new Thickness(1),
CornerRadius = NotaRadius.Panel, Padding = new Thickness(4), MinHeight = 132, Child = list,
};
- var addBtn = Btn(Loc.T("Add folder…"));
- var removeBtn = Btn(Loc.T("Remove"));
+ var addBtn = Btn(Loc.T("preferences.add_folder"));
+ var removeBtn = Btn(Loc.T("preferences.remove"));
// Nota's own install folder (Downloads) is always searched — it is re-added at startup,
// so it is tagged and can't be removed.
@@ -860,7 +860,7 @@ public sealed partial class PreferencesWindow : NotaWindow
Text = path, FontSize = 11, FontFamily = NotaFonts.MonoFamily, Foreground = sel ? TextPrimary : TextSecondary,
VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis,
});
- var tag = new TextBlock { Text = IsDefault(path) ? Loc.T("default") : "", FontSize = 10, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
+ var tag = new TextBlock { Text = IsDefault(path) ? Loc.T("preferences.default") : "", FontSize = 10, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center };
Grid.SetColumn(tag, 1);
grid.Children.Add(tag);
var row = new Border
@@ -878,7 +878,7 @@ public sealed partial class PreferencesWindow : NotaWindow
addBtn.Click += async (_, _) =>
{
Activate();
- var folders = await this.PickFoldersAsync(new FolderPickerOpenOptions { Title = Loc.T("Add plugin scan folder"), AllowMultiple = false });
+ var folders = await this.PickFoldersAsync(new FolderPickerOpenOptions { Title = Loc.T("preferences.add_plugin_scan_folder"), AllowMultiple = false });
if (folders.Count == 0) return;
var path = folders[0].TryGetLocalPath();
if (path is null) return;
@@ -895,42 +895,42 @@ public sealed partial class PreferencesWindow : NotaWindow
};
var rescanStatus = new TextBlock { FontSize = 11, Foreground = TextTertiary, VerticalAlignment = VerticalAlignment.Center, TextWrapping = TextWrapping.Wrap };
- var rescan = Btn(Loc.T("Rescan plugins"));
+ var rescan = Btn(Loc.T("preferences.rescan_plugins"));
rescan.Click += async (_, _) =>
{
- if (_main is null) { rescanStatus.Text = Loc.T("Plugin scanning is unavailable in this window."); return; }
+ if (_main is null) { rescanStatus.Text = Loc.T("preferences.plugin_scanning_is_unavailable_in"); return; }
rescan.IsEnabled = false;
- rescan.Content = Loc.T("Scanning…");
+ rescan.Content = Loc.T("preferences.scanning");
int folders = _catalog.ScanPathCount;
- rescanStatus.Text = Loc.Plural(folders, "Searching {0} folder", "Searching {0} folders");
+ rescanStatus.Text = Loc.Plural("preferences.searching_folders", folders);
try
{
// An explicit Rescan also retries plugins that failed before.
var progress = new Progress<PluginScanProgress>(p => rescanStatus.Text = PluginScan.Describe(p));
int? n = await PluginScan.RescanAsync(_main, progress, retryFailed: true);
int failed = _catalog.FailedCount;
- rescanStatus.Text = n is not { } c ? Loc.T("Scanner worker not found.")
- : Loc.Plural(c, "Found {0:N0} plugin.", "Found {0:N0} plugins.") +
- (failed > 0 ? Loc.F(" {0:N0} couldn't be loaded — see plugin-scan.log in Nota's logs folder.", failed) : "");
+ rescanStatus.Text = n is not { } c ? Loc.T("preferences.scanner_worker_not_found")
+ : Loc.Plural("preferences.found_plugins", c) +
+ (failed > 0 ? Loc.F("preferences.couldnt_be_loaded_see_plugin", failed) : "");
}
- finally { rescan.IsEnabled = true; rescan.Content = Loc.T("Rescan plugins"); }
+ finally { rescan.IsEnabled = true; rescan.Content = Loc.T("preferences.rescan_plugins"); }
};
var settings = App.Services.GetRequiredService<ISettingsService>();
- var openOnInsert = SwitchRow(Loc.T("Open plug-in window on insert"), settings.Current.OpenPluginWindowOnInsert, on =>
+ var openOnInsert = SwitchRow(Loc.T("preferences.open_plug_in_window_on"), settings.Current.OpenPluginWindowOnInsert, on =>
{
settings.Current.OpenPluginWindowOnInsert = on;
settings.Save();
});
return Sections(
- Section(Loc.T("Plug-in window"), 10, openOnInsert,
- Caption(Loc.T("Adding a plug-in from the browser, by drag and drop or from the palette opens its editor. Loading a project, undo and paste never do."))),
- Section(Loc.T("Plugin scan folders"), 10,
+ Section(Loc.T("preferences.plug_in_window"), 10, openOnInsert,
+ Caption(Loc.T("preferences.adding_a_plug_in_from"))),
+ Section(Loc.T("preferences.plugin_scan_folders"), 10,
well,
new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { addBtn, removeBtn } },
- Caption(Loc.T("Extra folders are searched for VST3 plugins on the next rescan (AU uses the system registry)."))),
- Section(Loc.T("Scan"), 10,
+ Caption(Loc.T("preferences.extra_folders_are_searched_for"))),
+ Section(Loc.T("preferences.scan"), 10,
new StackPanel { Orientation = Orientation.Horizontal, Spacing = 14, Children = { rescan, rescanStatus } }));
}
@@ -938,14 +938,14 @@ public sealed partial class PreferencesWindow : NotaWindow
private Control LibraryPane()
{
- if (_main is null) return Caption(Loc.T("Content folders are unavailable in this window."));
+ if (_main is null) return Caption(Loc.T("preferences.content_folders_are_unavailable_in"));
var settings = _main.Settings;
- return Sections(Section(Loc.T("Content folders"), 10, Table(new List<Control>
+ return Sections(Section(Loc.T("preferences.content_folders"), 10, Table(new List<Control>
{
- FolderRow(Loc.T("Samples"),
+ FolderRow(Loc.T("preferences.samples"),
() => settings.Current.SamplesFolder, () => settings.ResolvedSamplesFolder(),
path => { settings.Current.SamplesFolder = path; settings.Save(); _main.Browser.RebuildSamples(); }),
- FolderRow(Loc.T("Projects"),
+ FolderRow(Loc.T("preferences.projects"),
() => settings.Current.ProjectsFolder, () => settings.ResolvedProjectsFolder(),
path => { settings.Current.ProjectsFolder = path; settings.Save(); _main.Browser.RebuildProjects(); }),
})), VersionHistorySection(_main));
@@ -954,19 +954,19 @@ public sealed partial class PreferencesWindow : NotaWindow
// On by default. Turning it off erases history, so it asks first — and stays on if not confirmed.
private Control VersionHistorySection(MainWindowViewModel main)
{
- var row = (StackPanel)SwitchRow(Loc.T("Keep a version history of each project"), main.Settings.Current.KeepVersionHistory, _ => { });
+ var row = (StackPanel)SwitchRow(Loc.T("preferences.keep_a_version_history_of"), main.Settings.Current.KeepVersionHistory, _ => { });
var sw = (ToggleSwitch)row.Children[0];
sw.Changed += async on =>
{
if (on) { main.SetKeepVersionHistory(true); return; }
- bool ok = await new ConfirmWindow(Loc.T("Turn off version history"),
- Loc.T("This erases the version history of the open project now, and of any other project the next time you save it. Older versions can't be brought back."),
- Loc.T("Turn off and erase"), Loc.T("Cancel")).ShowDialog<bool>(this);
+ bool ok = await new ConfirmWindow(Loc.T("preferences.turn_off_version_history"),
+ Loc.T("preferences.this_erases_the_version_history"),
+ Loc.T("preferences.turn_off_and_erase"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (ok) main.SetKeepVersionHistory(false);
else sw.IsOn = true;
};
- return Section(Loc.T("Version history"), 10, row,
- Caption(Loc.T("Every save records a version, listed in the browser's History tab. Versions share their audio, so each one costs only what it adds.")));
+ return Section(Loc.T("preferences.version_history"), 10, row,
+ Caption(Loc.T("preferences.every_save_records_a_version")));
}
private Control FolderRow(string label, Func<string> get, Func<string> resolved, Action<string> set)
@@ -977,18 +977,18 @@ public sealed partial class PreferencesWindow : NotaWindow
Text = custom ? get() : resolved(), FontSize = 11, FontFamily = NotaFonts.MonoFamily, Foreground = TextPrimary,
TextTrimming = TextTrimming.CharacterEllipsis,
};
- var tag = new TextBlock { Text = custom ? Loc.T("custom") : Loc.T("default"), FontSize = 10, Foreground = TextTertiary };
- var choose = Btn(Loc.T("Choose…"));
+ var tag = new TextBlock { Text = custom ? Loc.T("preferences.custom") : Loc.T("preferences.default"), FontSize = 10, Foreground = TextTertiary };
+ var choose = Btn(Loc.T("preferences.choose"));
choose.Click += async (_, _) =>
{
Activate();
- var folders = await this.PickFoldersAsync(new FolderPickerOpenOptions { Title = Loc.F("Choose {0} folder", label), AllowMultiple = false });
+ var folders = await this.PickFoldersAsync(new FolderPickerOpenOptions { Title = Loc.F("preferences.choose_folder", label), AllowMultiple = false });
if (folders.Count == 0) return;
var p = folders[0].TryGetLocalPath();
if (p is null) return;
set(p);
path.Text = p;
- tag.Text = Loc.T("custom");
+ tag.Text = Loc.T("preferences.custom");
};
var grid = new Grid { ColumnDefinitions = new ColumnDefinitions("110,*,Auto"), ColumnSpacing = 12, Margin = new Thickness(14, 12) };
grid.Children.Add(new TextBlock { Text = label, FontSize = 12, Foreground = TextSecondary, VerticalAlignment = VerticalAlignment.Center });
@@ -1017,7 +1017,7 @@ public sealed partial class PreferencesWindow : NotaWindow
var modes = new List<ToggleButton>();
var strip = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 2 };
- foreach (var label in new[] { Loc.T("Dark"), Loc.T("Light"), Loc.T("Follow system") })
+ foreach (var label in new[] { Loc.T("preferences.dark"), Loc.T("preferences.light"), Loc.T("preferences.follow_system") })
{
var btn = new ToggleButton { Classes = { "seg" }, FontSize = 12, Content = label };
modes.Add(btn);
@@ -1034,8 +1034,8 @@ public sealed partial class PreferencesWindow : NotaWindow
for (int i = 0; i < modes.Count; i++) modes[i].IsChecked = i == (int)mode;
bool follow = mode == AppearanceMode.FollowSystem;
// The labels change text and ink, never size: the row in use reads one step up.
- darkLabel.Text = follow ? Loc.T("In dark mode") : Loc.T("Dark");
- lightLabel.Text = follow ? Loc.T("In light mode") : Loc.T("Light");
+ darkLabel.Text = follow ? Loc.T("preferences.in_dark_mode") : Loc.T("preferences.dark");
+ lightLabel.Text = follow ? Loc.T("preferences.in_light_mode") : Loc.T("preferences.light");
darkLabel.Foreground = mode != AppearanceMode.Light ? TextSecondary : TextMuted;
lightLabel.Foreground = mode != AppearanceMode.Dark ? TextSecondary : TextMuted;
darkCards.SelectedItem = follow ? NotaThemes.Find(c.Dark) : mode == AppearanceMode.Dark ? NotaThemes.Find(c.Single) : null;
@@ -1170,7 +1170,7 @@ public sealed partial class PreferencesWindow : NotaWindow
var settings = App.Services.GetRequiredService<ISettingsService>();
var strip = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 2 };
var buttons = new List<(int Style, ToggleButton Btn)>();
- foreach (var (style, label) in new[] { (0, Loc.T("Smooth")), (1, Loc.T("Solid")), (2, Loc.T("Bars")) })
+ foreach (var (style, label) in new[] { (0, Loc.T("preferences.smooth")), (1, Loc.T("preferences.solid")), (2, Loc.T("preferences.bars")) })
{
var st = style;
var btn = new ToggleButton { Classes = { "seg" }, FontSize = 12, Content = label, IsChecked = settings.Current.ArrangementWaveform == st };
@@ -1201,7 +1201,7 @@ public sealed partial class PreferencesWindow : NotaWindow
bool right = settings.Current.ArrangementHeadersRight;
foreach (var (br, bb) in buttons) bb.IsChecked = br == right;
}
- foreach (var (right, label) in new[] { (false, Loc.T("Left")), (true, Loc.T("Right")) })
+ foreach (var (right, label) in new[] { (false, Loc.T("preferences.left")), (true, Loc.T("preferences.right")) })
{
var r = right;
var btn = new ToggleButton { Classes = { "seg" }, FontSize = 12, Content = label };
@@ -1277,22 +1277,22 @@ public sealed partial class PreferencesWindow : NotaWindow
FontSize = 11, FontFamily = NotaFonts.MonoFamily, Foreground = TextSecondary,
VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis,
};
- var copyBtn = Btn(Loc.T("Copy config"));
+ var copyBtn = Btn(Loc.T("preferences.copy_config"));
copyBtn.HorizontalAlignment = HorizontalAlignment.Left;
var details = new StackPanel
{
Spacing = 10,
Children =
{
- Row(Loc.T("Port"), portBox),
- Row(Loc.T("Status"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { statusDot, status } }),
+ Row(Loc.T("preferences.port"), portBox),
+ Row(Loc.T("preferences.status"), new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { statusDot, status } }),
Row("", new StackPanel
{
Spacing = 10,
Children =
{
copyBtn,
- Caption(Loc.T("Add this config (or the URL) as an MCP server in Claude Desktop / Claude Code. Loopback only; off by default.")),
+ Caption(Loc.T("preferences.add_this_config_or_the")),
},
}),
},
@@ -1302,7 +1302,7 @@ public sealed partial class PreferencesWindow : NotaWindow
void Refresh()
{
bool on = Enabled();
- status.Text = on ? Loc.F("Listening on http://127.0.0.1:{0}/ (loopback)", settings!.Current.McpPort) : Loc.T("Off");
+ status.Text = on ? Loc.F("preferences.listening_on_http_127_0", settings!.Current.McpPort) : Loc.T("common.off");
statusDot.Fill = on ? NotaPalette.SuccessDim : BorderStrong;
portBox.IsEnabled = on;
portBox.Foreground = on ? TextPrimary : TextDisabled;
@@ -1318,7 +1318,7 @@ public sealed partial class PreferencesWindow : NotaWindow
_ = mcp?.ApplyAsync();
Refresh();
}
- var enable = SwitchRow(Loc.T("Enable MCP server (let an AI drive Nota)"), Enabled(), ApplyMcp);
+ var enable = SwitchRow(Loc.T("preferences.enable_mcp_server_let_an"), Enabled(), ApplyMcp);
portBox.LostFocus += (_, _) => ApplyMcp(Enabled());
// Copy a ready client-config JSON (Claude Desktop / Claude Code) with the current port.
@@ -1333,17 +1333,17 @@ public sealed partial class PreferencesWindow : NotaWindow
var cb = TopLevel.GetTopLevel(this)?.Clipboard;
if (cb is null) return;
await cb.SetTextAsync(McpConfigJson());
- copyBtn.Content = Loc.T("Copied");
+ copyBtn.Content = Loc.T("preferences.copied");
copied?.Stop();
copied = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(1500) };
- copied.Tick += (_, _) => { copied!.Stop(); copyBtn.Content = Loc.T("Copy config"); };
+ copied.Tick += (_, _) => { copied!.Stop(); copyBtn.Content = Loc.T("preferences.copy_config"); };
copied.Start();
};
// Inactive.Set walks the visual tree, so the dimming waits until the pane is shown.
details.AttachedToVisualTree += (_, _) => Refresh();
// Piano-roll key labels: every note for beginners, C-only by default.
- var labelAll = SwitchRow(Loc.T("Label every note in the piano roll"), settings?.Current.PianoRollLabelAllNotes ?? false, on =>
+ var labelAll = SwitchRow(Loc.T("preferences.label_every_note_in_the"), settings?.Current.PianoRollLabelAllNotes ?? false, on =>
{
if (settings is null) return;
settings.Current.PianoRollLabelAllNotes = on;
@@ -1351,7 +1351,7 @@ public sealed partial class PreferencesWindow : NotaWindow
});
// Detail panel (#308): a selection opens a closed panel only when this is on.
- var openOnSelect = SwitchRow(Loc.T("Open the detail panel when you select a track or clip"), settings?.Current.OpenDetailOnSelect ?? false, on =>
+ var openOnSelect = SwitchRow(Loc.T("preferences.open_the_detail_panel_when"), settings?.Current.OpenDetailOnSelect ?? false, on =>
{
if (settings is null) return;
settings.Current.OpenDetailOnSelect = on;
@@ -1360,21 +1360,21 @@ public sealed partial class PreferencesWindow : NotaWindow
return Sections(
Section("UI", 10,
- TopRow(Loc.T("Colour theme"), ThemePicker()),
- Row("", Caption(Loc.T("Themes change colours only. Follow system switches between your dark-mode and light-mode theme with the OS appearance."))),
- Row(Loc.T("Waveform"), WaveformPicker()),
- Row("", Caption(Loc.T("How audio clips draw on the arrangement: Smooth outlines the peaks around the RMS level; Solid draws every pixel; Bars spaces the peaks out so the rhythm reads. Solid and Bars also set the browser's preview."))),
- Row(Loc.T("Track headers"), HeaderSidePicker()),
- Row("", Caption(Loc.T("Which side of the arrangement the track list sits on. Right starts the timeline at the left edge, next to the browser. Also in the View menu."))),
- Row(Loc.T("Interface scale"), ScalePicker()),
- Row("", Caption(Loc.T("Makes the whole interface larger or smaller. Timeline, piano roll and audio editor zoom work on top of it."))),
- Row(Loc.T("Language"), LanguagePicker()),
- Row("", Caption(Loc.T("The language of menus, panels and messages. It changes when Nota restarts. Project files and the names you type are never translated.")))),
- Section(Loc.T("Piano roll"), 10, labelAll,
- Caption(Loc.T("Shows every note name (C, D, E…) on the piano roll's keys instead of only C. Helpful when learning notes."))),
- Section(Loc.T("Detail panel"), 10, openOnSelect,
- Caption(Loc.T("Off: a click only selects, and an open panel follows it. Double-click a track for its devices or a clip to edit it."))),
- Section(Loc.T("AI control (MCP)"), 12, enable, details));
+ TopRow(Loc.T("preferences.colour_theme"), ThemePicker()),
+ Row("", Caption(Loc.T("preferences.themes_change_colours_only_follow"))),
+ Row(Loc.T("preferences.waveform"), WaveformPicker()),
+ Row("", Caption(Loc.T("preferences.how_audio_clips_draw_on"))),
+ Row(Loc.T("preferences.track_headers"), HeaderSidePicker()),
+ Row("", Caption(Loc.T("preferences.which_side_of_the_arrangement"))),
+ Row(Loc.T("preferences.interface_scale"), ScalePicker()),
+ Row("", Caption(Loc.T("preferences.makes_the_whole_interface_larger"))),
+ Row(Loc.T("preferences.language"), LanguagePicker()),
+ Row("", Caption(Loc.T("preferences.the_language_of_menus_panels")))),
+ Section(Loc.T("common.piano_roll"), 10, labelAll,
+ Caption(Loc.T("preferences.shows_every_note_name_c"))),
+ Section(Loc.T("preferences.detail_panel"), 10, openOnSelect,
+ Caption(Loc.T("preferences.off_a_click_only_selects"))),
+ Section(Loc.T("preferences.ai_control_mcp"), 12, enable, details));
}
// ---- Shortcuts --------------------------------------------------------
@@ -1387,260 +1387,260 @@ public sealed partial class PreferencesWindow : NotaWindow
// keys (see IsKeyToken) is drawn as one key-cap per token; a gesture is plain text.
private static readonly (string Title, (string Key, string Action)[] Rows)[] ShortcutGroups =
{
- (Loc.T("File"), new[]
- {
- ("⌘N ⌘O", Loc.T("New project / open a project")),
- ("⌘S ⌘⇧S", Loc.T("Save (records a version) / save as")),
- ("⌥⌘S", Loc.T("Save a version with a note")),
- ("⌘⇧E", Loc.T("Export audio")),
- ("⌘,", Loc.T("Settings")),
- ("⌘Q", Loc.T("Quit Nota · asks about unsaved changes first")),
+ (Loc.T("common.file"), new[]
+ {
+ ("⌘N ⌘O", Loc.T("preferences.new_project_open_a_project")),
+ ("⌘S ⌘⇧S", Loc.T("preferences.save_records_a_version_save")),
+ ("⌥⌘S", Loc.T("preferences.save_a_version_with_a")),
+ ("⌘⇧E", Loc.T("preferences.export_audio")),
+ ("⌘,", Loc.T("common.settings")),
+ ("⌘Q", Loc.T("preferences.quit_nota_asks_about_unsaved")),
}),
- (Loc.T("Window"), new[]
+ (Loc.T("preferences.window"), new[]
{
- ("F11", Loc.T("Enter / leave full screen — the title bar hides in full screen")),
- ("⌘⇧F", Loc.T("The clip editor fills the window / back to the split it had")),
- (Loc.T("Double-click a panel edge"), Loc.T("Reset the detail panel, the Mixer or the browser to its default size")),
+ ("F11", Loc.T("preferences.enter_leave_full_screen_the")),
+ ("⌘⇧F", Loc.T("preferences.the_clip_editor_fills_the")),
+ (Loc.T("preferences.double_click_a_panel_edge"), Loc.T("preferences.reset_the_detail_panel_the")),
}),
- (Loc.T("Command palette"), new[]
- {
- ("⌘⇧P", Loc.T("Open / close the command palette — from any window, even while typing")),
- ("↑ ↓ PgUp PgDn", Loc.T("Move through the results")),
- ("Return", Loc.T("Apply where the palette was opened (the target shows in the field)")),
- ("⌘Return", Loc.T("An instrument or instrument preset on a new track · a track: open it in Devices")),
- ("⌥Return", Loc.T("Replace the selected device instead of inserting after it")),
- ("⇧Return", Loc.T("Apply and keep the palette open for the next device")),
- ("Tab ⇧Tab", Loc.T("Filter: all · actions · tracks · devices · presets")),
- ("> @ + # ~", Loc.T("Type first to filter: actions, tracks, devices, presets, Modular nodes")),
- ("Esc", Loc.T("Close and go back where you were")),
+ (Loc.T("preferences.command_palette"), new[]
+ {
+ ("⌘⇧P", Loc.T("preferences.open_close_the_command_palette")),
+ ("↑ ↓ PgUp PgDn", Loc.T("preferences.move_through_the_results")),
+ ("Return", Loc.T("preferences.apply_where_the_palette_was")),
+ ("⌘Return", Loc.T("preferences.an_instrument_or_instrument_preset")),
+ ("⌥Return", Loc.T("preferences.replace_the_selected_device_instead")),
+ ("⇧Return", Loc.T("preferences.apply_and_keep_the_palette")),
+ ("Tab ⇧Tab", Loc.T("preferences.filter_all_actions_tracks_devices")),
+ ("> @ + # ~", Loc.T("preferences.type_first_to_filter_actions")),
+ ("Esc", Loc.T("preferences.close_and_go_back_where")),
}),
- (Loc.T("Transport"), new[]
- {
- ("Space", Loc.T("Play / Stop · Stop goes back to where playback started")),
- ("⇧Space", Loc.T("Play / pause · the playhead stays put and Play carries on from there")),
- ("Return", Loc.T("Stop (again → back to the start) · in the Session grid it launches the selection")),
- ("⌘R", Loc.T("Record")),
- ("⌘M", Loc.T("Metronome")),
- ("⌘L", Loc.T("Loop on / off · loop the selected clips or time range")),
- (Loc.T("Double-click loop brace"), Loc.T("Loop on / off in the ruler · the region stays, greyed out while off")),
- (Loc.T("Drag loop edge · drag loop brace"), Loc.T("Resize that end of the loop region · move the whole region · ⌥ off the grid")),
- (Loc.T("Right-click ruler"), Loc.T("Loop on / off · loop the selection · clear the loop region")),
- ("P", Loc.T("Show playhead · scroll the Arrangement to it without moving it · picks up a paused Follow")),
- ("⌘⇧R", Loc.T("Loop recording: Overdub (every pass adds) / Replace (keep the latest pass)")),
- (Loc.T("Click the position read-out"), Loc.T("Switch it between bars and time · every ruler follows")),
+ (Loc.T("common.transport"), new[]
+ {
+ ("Space", Loc.T("preferences.play_stop_stop_goes_back")),
+ ("⇧Space", Loc.T("preferences.play_pause_the_playhead_stays")),
+ ("Return", Loc.T("preferences.stop_again_back_to_the")),
+ ("⌘R", Loc.T("common.record")),
+ ("⌘M", Loc.T("common.metronome")),
+ ("⌘L", Loc.T("preferences.loop_on_off_loop_the")),
+ (Loc.T("preferences.double_click_loop_brace"), Loc.T("preferences.loop_on_off_in_the")),
+ (Loc.T("preferences.drag_loop_edge_drag_loop"), Loc.T("preferences.resize_that_end_of_the")),
+ (Loc.T("preferences.right_click_ruler"), Loc.T("preferences.loop_on_off_loop_the_2")),
+ ("P", Loc.T("preferences.show_playhead_scroll_the_arrangement")),
+ ("⌘⇧R", Loc.T("preferences.loop_recording_overdub_every_pass")),
+ (Loc.T("preferences.click_the_position_read_out"), Loc.T("preferences.switch_it_between_bars_and")),
}),
- (Loc.T("Arrangement & editing"), new[]
- {
- ("⌘Z ⌘⇧Z", Loc.T("Undo / redo")),
- ("⌘A", Loc.T("Select all clips")),
- ("⌘⇧A", Loc.T("Toggle automation mode")),
- ("⌘⇧M", Loc.T("Toggle the Mixer view")),
- ("Tab", Loc.T("Cycle Devices / Pattern / Clip in the detail panel")),
- ("Esc", Loc.T("Cancel the current gesture / clear the selection · close the patch-bay overlay")),
- ("⌘G ⌘⇧G", Loc.T("Group / ungroup selected tracks · on selected devices: group them into a rack / take a rack apart")),
- ("⌘C ⌘X ⌘V", Loc.T("Copy / cut / paste clips, a time range or an automation range · pastes onto the track clicked last")),
- ("⌘⇧C", Loc.T("Copy the selected clips to Session · the first scene row where they fit")),
- ("⌘⇧V", Loc.T("Paste the last range as audio rendered through its devices")),
- ("⌘D", Loc.T("Duplicate the selected clip(s) / range")),
- ("⌘⇧D", Loc.T("Duplicate time · insert a copy of the time range after it, pushing everything later right")),
- ("⌘⇧I", Loc.T("Insert silence · push everything from the range start right by its length")),
- ("⌘E", Loc.T("Split at the playhead · at the range edges")),
- ("⌘J", Loc.T("Consolidate the selection into one clip per track")),
- ("0", Loc.T("Deactivate / activate the selected clip(s)")),
- ("← →", Loc.T("Nudge the selected clips by the grid step · stops at the song start")),
- ("⌥← ⌥→", Loc.T("Nudge the selected clips by a 64th note")),
- ("⌥↑ ⌥↓", Loc.T("Move the selected clips to the next track that takes them, at the same beats")),
- (Loc.T("Drag below the last track"), Loc.T("Move the clips to a new track like their own · one per source track")),
- ("Delete", Loc.T("Delete the selected clip / range")),
+ (Loc.T("preferences.arrangement_editing"), new[]
+ {
+ ("⌘Z ⌘⇧Z", Loc.T("preferences.undo_redo")),
+ ("⌘A", Loc.T("preferences.select_all_clips")),
+ ("⌘⇧A", Loc.T("preferences.toggle_automation_mode")),
+ ("⌘⇧M", Loc.T("preferences.toggle_the_mixer_view")),
+ ("Tab", Loc.T("preferences.cycle_devices_pattern_clip_in")),
+ ("Esc", Loc.T("preferences.cancel_the_current_gesture_clear")),
+ ("⌘G ⌘⇧G", Loc.T("preferences.group_ungroup_selected_tracks_on")),
+ ("⌘C ⌘X ⌘V", Loc.T("preferences.copy_cut_paste_clips_a")),
+ ("⌘⇧C", Loc.T("preferences.copy_the_selected_clips_to")),
+ ("⌘⇧V", Loc.T("preferences.paste_the_last_range_as")),
+ ("⌘D", Loc.T("preferences.duplicate_the_selected_clip_s")),
+ ("⌘⇧D", Loc.T("preferences.duplicate_time_insert_a_copy")),
+ ("⌘⇧I", Loc.T("preferences.insert_silence_push_everything_from")),
+ ("⌘E", Loc.T("preferences.split_at_the_playhead_at")),
+ ("⌘J", Loc.T("preferences.consolidate_the_selection_into_one")),
+ ("0", Loc.T("preferences.deactivate_activate_the_selected_clip")),
+ ("← →", Loc.T("preferences.nudge_the_selected_clips_by_2")),
+ ("⌥← ⌥→", Loc.T("preferences.nudge_the_selected_clips_by")),
+ ("⌥↑ ⌥↓", Loc.T("preferences.move_the_selected_clips_to")),
+ (Loc.T("preferences.drag_below_the_last_track"), Loc.T("preferences.move_the_clips_to_a")),
+ ("Delete", Loc.T("preferences.delete_the_selected_clip_range")),
}),
- (Loc.T("Grid (Arrangement or clip editor — whichever you used last)"), new[]
- {
- ("⌘1 ⌘2", Loc.T("Narrow / widen the grid · in Auto, change the density")),
- ("⌘3", Loc.T("Triplet grid on / off")),
- ("⌘4", Loc.T("Snap to grid on / off")),
- ("⌘5", Loc.T("Switch between the adaptive (Auto) and a fixed grid")),
- ("⌥ while dragging", Loc.T("Move freely, ignoring the grid")),
- (Loc.T("Audio clip editor on ADSR or an unwarped clip"), "⌘1–⌘5 act on the Arrangement · that view follows no grid"),
+ (Loc.T("preferences.grid_arrangement_or_clip_editor"), new[]
+ {
+ ("⌘1 ⌘2", Loc.T("preferences.narrow_widen_the_grid_in")),
+ ("⌘3", Loc.T("preferences.triplet_grid_on_off")),
+ ("⌘4", Loc.T("preferences.snap_to_grid_on_off")),
+ ("⌘5", Loc.T("preferences.switch_between_the_adaptive_auto")),
+ ("⌥ while dragging", Loc.T("preferences.move_freely_ignoring_the_grid")),
+ (Loc.T("preferences.audio_clip_editor_on_adsr"), "⌘1–⌘5 act on the Arrangement · that view follows no grid"),
}),
- (Loc.T("Tracks (after a click in the track headers)"), new[]
+ (Loc.T("preferences.tracks_after_a_click_in"), new[]
{
- ("⌘A", Loc.T("Select all tracks")),
- ("⇧-click ⌘-click", Loc.T("Select a range of tracks / add or remove one track")),
- ("⌘C ⌘X ⌘V", Loc.T("Copy / cut / paste the selected tracks · paste lands after the last one")),
- ("⌘D", Loc.T("Duplicate the selected tracks")),
- ("Delete", Loc.T("Delete the selected tracks · a group goes with its tracks")),
+ ("⌘A", Loc.T("preferences.select_all_tracks")),
+ ("⇧-click ⌘-click", Loc.T("preferences.select_a_range_of_tracks")),
+ ("⌘C ⌘X ⌘V", Loc.T("preferences.copy_cut_paste_the_selected_2")),
+ ("⌘D", Loc.T("preferences.duplicate_the_selected_tracks")),
+ ("Delete", Loc.T("preferences.delete_the_selected_tracks_a")),
}),
- (Loc.T("Devices (after a click on a device)"), new[]
- {
- ("⇧-click ⌘-click", Loc.T("Select a range of devices (MIDI effects, instrument, audio effects) / add or remove one")),
- ("Esc", Loc.T("Clear the device selection · so does a click on the chain's empty space")),
- ("⌘C ⌘X ⌘V", Loc.T("Copy / cut / paste the selected devices with all their settings · each lands in its section after the selected device · a copied instrument replaces the instrument it is pasted on")),
- ("⌘D", Loc.T("Duplicate the selected devices · each run right after itself")),
- ("⌘G", Loc.T("Group the selected devices into a rack · audio effects: Audio Effect Rack · MIDI effects: MIDI Effect Rack · with the instrument: Instrument Rack")),
- ("⌘⇧G", Loc.T("Take the devices out of a selected one-chain rack")),
- ("Delete", Loc.T("Delete the selected devices · with the instrument, its track")),
- (Loc.T("Drag a selected device's header"), Loc.T("Move the selected devices of that section together")),
- (Loc.T("Drag a device onto a track"), Loc.T("Move it there (out of the panel, onto a track row or Session column) · the instrument replaces that track's and its own track goes")),
- (Loc.T("⌥-drag a device onto a track"), Loc.T("Copy it there")),
+ (Loc.T("preferences.devices_after_a_click_on"), new[]
+ {
+ ("⇧-click ⌘-click", Loc.T("preferences.select_a_range_of_devices")),
+ ("Esc", Loc.T("preferences.clear_the_device_selection_so")),
+ ("⌘C ⌘X ⌘V", Loc.T("preferences.copy_cut_paste_the_selected")),
+ ("⌘D", Loc.T("preferences.duplicate_the_selected_devices_each")),
+ ("⌘G", Loc.T("preferences.group_the_selected_devices_into")),
+ ("⌘⇧G", Loc.T("preferences.take_the_devices_out_of")),
+ ("Delete", Loc.T("preferences.delete_the_selected_devices_with")),
+ (Loc.T("preferences.drag_a_selected_devices_header"), Loc.T("preferences.move_the_selected_devices_of")),
+ (Loc.T("preferences.drag_a_device_onto_a"), Loc.T("preferences.move_it_there_out_of")),
+ (Loc.T("preferences.drag_a_device_onto_a_2"), Loc.T("preferences.copy_it_there")),
}),
- (Loc.T("Racks"), new[]
- {
- ("Esc", Loc.T("End macro mapping (Map on the rack card)")),
- (Loc.T("Drag a zone edge"), Loc.T("Set a chain's key, velocity or select range · edges never cross")),
- (Loc.T("Hover the zones"), Loc.T("See which chains a note would play")),
- (Loc.T("Double-click a chain or macro name"), Loc.T("Rename it")),
- (Loc.T("Right-click a macro"), Loc.T("Map it to a parameter or the selector · clear its mappings")),
- (Loc.T("Drag a device's header"), Loc.T("Move it within its chain · onto another chain's row to move it there")),
- (Loc.T("Click a device"), Loc.T("Select it for ⌘C ⌘X ⌘V ⌘D and Delete")),
+ (Loc.T("preferences.racks"), new[]
+ {
+ ("Esc", Loc.T("preferences.end_macro_mapping_map_on")),
+ (Loc.T("preferences.drag_a_zone_edge"), Loc.T("preferences.set_a_chains_key_velocity")),
+ (Loc.T("preferences.hover_the_zones"), Loc.T("preferences.see_which_chains_a_note")),
+ (Loc.T("preferences.double_click_a_chain_or"), Loc.T("preferences.rename_it")),
+ (Loc.T("preferences.right_click_a_macro"), Loc.T("preferences.map_it_to_a_parameter")),
+ (Loc.T("preferences.drag_a_devices_header"), Loc.T("preferences.move_it_within_its_chain")),
+ (Loc.T("preferences.click_a_device"), Loc.T("preferences.select_it_for_c_x")),
}),
- (Loc.T("Modular (after a click on the canvas)"), new[]
+ (Loc.T("preferences.modular_after_a_click_on"), new[]
{
- ("F", Loc.T("Fit every node on screen")),
- ("B", Loc.T("Bypass the selected device")),
- ("⌘D", Loc.T("Duplicate the selected device with all its settings")),
- ("Delete", Loc.T("Delete the selected device, modulator or cable · the track's input, instrument and output are fixed")),
- ("Esc", Loc.T("Show fewer parameters on every opened node")),
+ ("F", Loc.T("preferences.fit_every_node_on_screen")),
+ ("B", Loc.T("preferences.bypass_the_selected_device")),
+ ("⌘D", Loc.T("preferences.duplicate_the_selected_device_with")),
+ ("Delete", Loc.T("preferences.delete_the_selected_device_modulator")),
+ ("Esc", Loc.T("preferences.show_fewer_parameters_on_every")),
}),
- (Loc.T("Session (after a click in the grid)"), new[]
- {
- ("← → ↑ ↓", Loc.T("Move the selection between slots and scenes")),
- ("Return", Loc.T("Launch the selected clip or scene")),
- ("⌘C ⌘X ⌘V", Loc.T("Copy / cut / paste a clip · a cut clip moves when pasted · clips copied in the Arrangement paste here")),
- ("⌘⇧C", Loc.T("Copy the selected clip, group slot or scene to the Arrangement at the playhead")),
- ("⌘D", Loc.T("Duplicate a clip into the slot below · a scene below itself")),
- ("⌘I", Loc.T("Insert a scene below the selection")),
- ("F2", Loc.T("Rename the selected clip or scene")),
- ("Delete", Loc.T("Delete the selected clip or scene")),
- (Loc.T("Drag clip"), Loc.T("Move it to another slot · ⌥ copies")),
- (Loc.T("Drag scene"), Loc.T("Reorder scenes")),
- (Loc.T("Double-click slot"), Loc.T("Edit the clip · an empty MIDI slot gets a new clip")),
- (Loc.T("Double-click header"), Loc.T("Rename the track")),
- (Loc.T("Right-click header or grid"), Loc.T("Add an instrument, audio or return track · rename or delete one")),
+ (Loc.T("preferences.session_after_a_click_in"), new[]
+ {
+ ("← → ↑ ↓", Loc.T("preferences.move_the_selection_between_slots")),
+ ("Return", Loc.T("preferences.launch_the_selected_clip_or")),
+ ("⌘C ⌘X ⌘V", Loc.T("preferences.copy_cut_paste_a_clip")),
+ ("⌘⇧C", Loc.T("preferences.copy_the_selected_clip_group")),
+ ("⌘D", Loc.T("preferences.duplicate_a_clip_into_the")),
+ ("⌘I", Loc.T("preferences.insert_a_scene_below_the")),
+ ("F2", Loc.T("preferences.rename_the_selected_clip_or")),
+ ("Delete", Loc.T("preferences.delete_the_selected_clip_or")),
+ (Loc.T("preferences.drag_clip"), Loc.T("preferences.move_it_to_another_slot")),
+ (Loc.T("preferences.drag_scene"), Loc.T("preferences.reorder_scenes")),
+ (Loc.T("preferences.double_click_slot"), Loc.T("preferences.edit_the_clip_an_empty")),
+ (Loc.T("preferences.double_click_header"), Loc.T("preferences.rename_the_track")),
+ (Loc.T("preferences.right_click_header_or_grid"), Loc.T("preferences.add_an_instrument_audio_or")),
}),
- (Loc.T("Piano roll"), new[]
- {
- ("← →", Loc.T("Move notes by the grid")),
- ("↑ ↓", Loc.T("Transpose by a semitone")),
- ("⇧↑ ⇧↓", Loc.T("Transpose by an octave")),
- ("⇧← ⇧→", Loc.T("Shorten / lengthen the notes by the grid")),
- ("⌥↑ ⌥↓", Loc.T("Velocity +10 / −10 · ⌥⇧ by 1")),
- (Loc.T("⇧ + wheel over a note"), Loc.T("Change its velocity · the whole selection's when the note is selected · elsewhere scroll sideways")),
- ("⌘A", Loc.T("Select all notes")),
- ("⌘D", Loc.T("Duplicate the selection · replaces the notes it lands on")),
- ("⌘C ⌘X ⌘V", Loc.T("Copy / cut / paste notes · paste lands on the originals")),
- ("Esc", Loc.T("Deselect · moved or pasted notes replace the notes under them")),
- ("Delete", Loc.T("Delete the selected notes")),
- (Loc.T("Double-click empty grid"), Loc.T("Add a note with the length and velocity of the last note touched · on a note, delete it")),
- (Loc.T("Double-click and hold, drag"), Loc.T("Shape the new note: move it · ⇧ set its length · ⌘ drag up / down for velocity")),
- (Loc.T("Drag note edge"), Loc.T("Change the note's start or end")),
- (Loc.T("Click · drag the ruler"), Loc.T("Move the playhead there · drag to scrub, snapped to the grid · ⌥ off the grid")),
- (Loc.T("Drag the playhead line"), Loc.T("Scrub the playhead · on the ruler or over empty grid")),
- (Loc.T("Drag velocity stem"), Loc.T("Set velocity · selected notes move together · ⇧ adds a note")),
- (Loc.T("Double-click velocity stem"), Loc.T("Put the note back to the default velocity (0.8) · the whole selection's when the note is selected · undo is one step")),
- (Loc.T("Right-click velocity stem"), Loc.T("Reset velocity from a menu · same as the double-click")),
- (Loc.T("Drag in the Bend / Pres / Slide lane"), Loc.T("Draw the selected note's MPE curve · ⌥ draws a straight line · drag a point to move it")),
- (Loc.T("Double-click in an MPE lane"), Loc.T("Add a point · on a point, delete it · right-click to clear the curve")),
- (Loc.T("Click the Bend lane's range"), Loc.T("Pick how far the Bend lane reaches: ±2, 12, 24, 48 or 96 semitones · a bend already on the notes can widen it further")),
- (Loc.T("Click the controller tab"), Loc.T("Show a MIDI controller under the notes · click it again to pick another CC, the pitch wheel or channel pressure")),
- (Loc.T("Drag in the Sustain lane"), Loc.T("Draw a pedal block on the grid · ⌘ off the grid · drag an edge to resize, the body to move · double-click or Delete removes it")),
- (Loc.T("Drag in a controller lane"), Loc.T("Draw the controller's curve · ⌥ draws a straight line · drag a point to move it · double-click adds or deletes a point")),
- (Loc.T("Click a clip in the clip strip"), Loc.T("Make it the active clip (several clips open) · its lock keeps it as a read-only reference")),
- ("⌘⌥ + wheel", Loc.T("Zoom rows (vertical zoom)")),
- (Loc.T("Click a key"), Loc.T("Play it on the track's instrument · ⇧-drag glides through the keys · ⌘-click selects every note of that pitch")),
- (Loc.T("Drag on the keys"), Loc.T("Zoom rows · down taller, up shorter")),
- ("⌥ + pinch", Loc.T("Zoom rows (trackpad)")),
- ("⇧F", Loc.T("Fit to notes")),
- ("⌥⇧F", Loc.T("Fold: only the scale's notes, or a Drum Rack's pads")),
+ (Loc.T("common.piano_roll"), new[]
+ {
+ ("← →", Loc.T("preferences.move_notes_by_the_grid")),
+ ("↑ ↓", Loc.T("preferences.transpose_by_a_semitone")),
+ ("⇧↑ ⇧↓", Loc.T("preferences.transpose_by_an_octave")),
+ ("⇧← ⇧→", Loc.T("preferences.shorten_lengthen_the_notes_by")),
+ ("⌥↑ ⌥↓", Loc.T("preferences.velocity_10_10_by_1")),
+ (Loc.T("preferences.wheel_over_a_note"), Loc.T("preferences.change_its_velocity_the_whole")),
+ ("⌘A", Loc.T("preferences.select_all_notes")),
+ ("⌘D", Loc.T("preferences.duplicate_the_selection_replaces_the")),
+ ("⌘C ⌘X ⌘V", Loc.T("preferences.copy_cut_paste_notes_paste")),
+ ("Esc", Loc.T("preferences.deselect_moved_or_pasted_notes")),
+ ("Delete", Loc.T("preferences.delete_the_selected_notes")),
+ (Loc.T("preferences.double_click_empty_grid"), Loc.T("preferences.add_a_note_with_the")),
+ (Loc.T("preferences.double_click_and_hold_drag"), Loc.T("preferences.shape_the_new_note_move")),
+ (Loc.T("preferences.drag_note_edge"), Loc.T("preferences.change_the_notes_start_or")),
+ (Loc.T("preferences.click_drag_the_ruler"), Loc.T("preferences.move_the_playhead_there_drag_2")),
+ (Loc.T("preferences.drag_the_playhead_line"), Loc.T("preferences.scrub_the_playhead_on_the")),
+ (Loc.T("preferences.drag_velocity_stem"), Loc.T("preferences.set_velocity_selected_notes_move")),
+ (Loc.T("preferences.double_click_velocity_stem"), Loc.T("preferences.put_the_note_back_to")),
+ (Loc.T("preferences.right_click_velocity_stem"), Loc.T("preferences.reset_velocity_from_a_menu")),
+ (Loc.T("preferences.drag_in_the_bend_pres"), Loc.T("preferences.draw_the_selected_notes_mpe")),
+ (Loc.T("preferences.double_click_in_an_mpe"), Loc.T("preferences.add_a_point_on_a")),
+ (Loc.T("preferences.click_the_bend_lanes_range"), Loc.T("preferences.pick_how_far_the_bend")),
+ (Loc.T("preferences.click_the_controller_tab"), Loc.T("preferences.show_a_midi_controller_under")),
+ (Loc.T("preferences.drag_in_the_sustain_lane"), Loc.T("preferences.draw_a_pedal_block_on")),
+ (Loc.T("preferences.drag_in_a_controller_lane"), Loc.T("preferences.draw_the_controllers_curve_draws")),
+ (Loc.T("preferences.click_a_clip_in_the"), Loc.T("preferences.make_it_the_active_clip")),
+ ("⌘⌥ + wheel", Loc.T("preferences.zoom_rows_vertical_zoom")),
+ (Loc.T("preferences.click_a_key"), Loc.T("preferences.play_it_on_the_tracks")),
+ (Loc.T("preferences.drag_on_the_keys"), Loc.T("preferences.zoom_rows_down_taller_up")),
+ ("⌥ + pinch", Loc.T("preferences.zoom_rows_trackpad")),
+ ("⇧F", Loc.T("preferences.fit_to_notes")),
+ ("⌥⇧F", Loc.T("preferences.fold_only_the_scales_notes")),
}),
- (Loc.T("Audio clip editor"), new[]
- {
- (Loc.T("Click · drag the ruler"), Loc.T("Move the playhead there · drag to scrub · snapped to the grid on a warped clip, ⌥ off it")),
- (Loc.T("Drag the playhead line"), Loc.T("Scrub the playhead")),
- (Loc.T("Double-click the wave"), Loc.T("Add a warp marker · on a marker, delete it")),
- (Loc.T("Drag a warp marker"), Loc.T("Align the audio to the grid · the wave stretches as you drag")),
- ("Esc", Loc.T("While dragging a warp marker or a segment tempo: put it back")),
- (Loc.T("Drag · double-click Tempo"), Loc.T("Set the tempo the clip was recorded at · ÷2 / ×2 halve or double it")),
+ (Loc.T("preferences.audio_clip_editor"), new[]
+ {
+ (Loc.T("preferences.click_drag_the_ruler"), Loc.T("preferences.move_the_playhead_there_drag")),
+ (Loc.T("preferences.drag_the_playhead_line"), Loc.T("preferences.scrub_the_playhead")),
+ (Loc.T("preferences.double_click_the_wave"), Loc.T("preferences.add_a_warp_marker_on")),
+ (Loc.T("preferences.drag_a_warp_marker"), Loc.T("preferences.align_the_audio_to_the")),
+ ("Esc", Loc.T("preferences.while_dragging_a_warp_marker")),
+ (Loc.T("preferences.drag_double_click_tempo"), Loc.T("preferences.set_the_tempo_the_clip")),
}),
- (Loc.T("Play notes (computer keyboard)"), new[]
+ (Loc.T("preferences.play_notes_computer_keyboard"), new[]
{
- ("A S D F G H J K", Loc.T("White keys, from C4")),
- ("W E · T Y U", Loc.T("Black keys (sharps)")),
- ("Z / X", Loc.T("Shift octave down / up")),
- ("C / V", Loc.T("Lower / raise velocity")),
+ ("A S D F G H J K", Loc.T("preferences.white_keys_from_c4")),
+ ("W E · T Y U", Loc.T("preferences.black_keys_sharps")),
+ ("Z / X", Loc.T("preferences.shift_octave_down_up")),
+ ("C / V", Loc.T("preferences.lower_raise_velocity")),
}),
- (Loc.T("Browser · preview"), new[]
- {
- ("↑ ↓", Loc.T("Move through samples, presets and devices · with Auto on, each one plays as it is selected")),
- (Loc.T("Click play button"), Loc.T("Play / stop the selected sample, preset or device")),
- (Loc.T("Click waveform"), Loc.T("Play from that point")),
- (Loc.T("Click WAVE / SPEC"), Loc.T("Switch the well between the waveform and a live spectrum")),
- (Loc.T("Scroll on the track button"), Loc.T("Step through the demo tracks an effect preset is heard through")),
- ("⌥-click volume", Loc.T("Type the preview volume · double-click resets it to 0\u2009dB")),
+ (Loc.T("preferences.browser_preview"), new[]
+ {
+ ("↑ ↓", Loc.T("preferences.move_through_samples_presets_and")),
+ (Loc.T("preferences.click_play_button"), Loc.T("preferences.play_stop_the_selected_sample")),
+ (Loc.T("preferences.click_waveform"), Loc.T("preferences.play_from_that_point")),
+ (Loc.T("preferences.click_wave_spec"), Loc.T("preferences.switch_the_well_between_the")),
+ (Loc.T("preferences.scroll_on_the_track_button"), Loc.T("preferences.step_through_the_demo_tracks")),
+ ("⌥-click volume", Loc.T("preferences.type_the_preview_volume_double")),
}),
- (Loc.T("Gamepad (macOS)"), new[]
- {
- (Loc.T("Face buttons"), Loc.T("Play C4 D4 E4 F4")),
- (Loc.T("Shoulder buttons"), Loc.T("Play G4 A4 B4 C5")),
- ("D-pad ↑ / ↓", Loc.T("Shift the gamepad octave")),
- ("D-pad ← / →", Loc.T("Lower / raise velocity")),
- (Loc.T("Any button"), Loc.T("Mappable through MIDI Learn — a mapped button drives the control instead")),
- (Loc.T("Sticks · triggers"), Loc.T("Mappable as continuous controls (a knob, a fader); they play no notes")),
+ (Loc.T("preferences.gamepad_macos"), new[]
+ {
+ (Loc.T("preferences.face_buttons"), Loc.T("preferences.play_c4_d4_e4_f4")),
+ (Loc.T("preferences.shoulder_buttons"), Loc.T("preferences.play_g4_a4_b4_c5")),
+ ("D-pad ↑ / ↓", Loc.T("preferences.shift_the_gamepad_octave")),
+ ("D-pad ← / →", Loc.T("preferences.lower_raise_velocity")),
+ (Loc.T("preferences.any_button"), Loc.T("preferences.mappable_through_midi_learn_a")),
+ (Loc.T("preferences.sticks_triggers"), Loc.T("preferences.mappable_as_continuous_controls_a")),
}),
- (Loc.T("Mouse"), new[]
- {
- (Loc.T("Double-click clip"), Loc.T("Open in the clip editor, opening the detail panel · on one of several selected MIDI clips, open them all together")),
- (Loc.T("Double-click a track header"), Loc.T("Open its devices in the detail panel · a plug-in's own window is Open editor on its card")),
- (Loc.T("Double-click a browser instrument"), Loc.T("Swap it onto the selected instrument track · clips and effects stay · no track selected starts one")),
- ("⌥ + double-click a browser instrument", Loc.T("Always start a new track with it")),
- (Loc.T("Right-click the metronome"), Loc.T("Count-in before Play / Record: off · 1 · 2 · 4 bars")),
- (Loc.T("Drag an audio clip's ADSR handle"), Loc.T("Shape attack · decay + sustain · release (top corners and the dot on hover) · ⌥-click types the stage · double-click resets it")),
- (Loc.T("⇧-click track header"), Loc.T("Add the track to the selection · again to remove it")),
- (Loc.T("Click a group's Link key"), Loc.T("Link the group's tracks: arming one arms them all, and clip edits act on the clips at the same place on each")),
- (Loc.T("⌥-click a clip or Arm"), Loc.T("In a linked group: select that clip alone, or arm that track alone")),
- (Loc.T("Right-click track headers"), Loc.T("A multi-selection gets its own menu: colour, height, freeze, group, copy, duplicate, delete")),
- (Loc.T("Drag a track's bottom edge"), Loc.T("Resize the track (header or lane) · snaps to compact / standard / large · a multi-selection resizes together")),
- (Loc.T("Drag a track's bottom edge + ⌥"), Loc.T("Resize every track at once")),
- (Loc.T("Double-click a track's bottom edge"), Loc.T("Back to the standard height")),
- (Loc.T("Drag a return's or the master's bottom edge"), Loc.T("Resize that row (header or lane) · same snaps · double-click goes back to compact")),
- ("⌘-click / ⇧-click return headers", Loc.T("Select several returns · they resize together")),
- (Loc.T("⌥-click a height key in the track menu"), Loc.T("Set every track to Compact · Standard · Large")),
- (Loc.T("Drag the track-list edge"), Loc.T("Widen or narrow the track headers · double-click resets")),
- (Loc.T("Drag sections lane"), Loc.T("Mark a new section over the dragged bars")),
- (Loc.T("Click section"), Loc.T("Jump the playhead to its start")),
- (Loc.T("Double-click section"), Loc.T("Rename it · right-click → Reset to default name for its automatic Section N")),
- (Loc.T("Return · Esc (renaming a section)"), Loc.T("Keep the name (empty = automatic) · cancel")),
- (Loc.T("Drag section"), Loc.T("Rearrange the song · it and everything in it move to the marked boundary, the sections between close up · Esc cancels")),
- (Loc.T("⌥-drag section"), Loc.T("Move only the section marker, snapped to bars")),
- (Loc.T("Drag section edge"), Loc.T("Resize it, snapped to bars")),
- (Loc.T("Right-click section"), Loc.T("Move earlier / later · duplicate or delete with content")),
- (Loc.T("Drag overview strip"), Loc.T("Drag sideways to scroll · up / down to zoom out / in")),
- (Loc.T("Drag overview edge"), Loc.T("Zoom by resizing the viewport window")),
- (Loc.T("Double-click overview"), Loc.T("Fit the whole project on screen")),
- (Loc.T("Drag a device header"), Loc.T("Reorder devices (or right-click the header → Move left / right)")),
- (Loc.T("Right-click a device header"), Loc.T("A / B compare, move, copy, delete, presets, save preset")),
- (Loc.T("Delete (device selected)"), Loc.T("Remove the selected device — the header no longer carries a close button")),
- (Loc.T("Drag an audio clip onto an instrument track"), Loc.T("Load its audio into the Sampler, Grain, Drum Rack (next free pad) or Instrument Rack · rest there to open its devices")),
- (Loc.T("Drag an audio clip out of the Arrangement"), Loc.T("Take it as a sample: drop on a pad, a Grain, a Rhythm voice, a Session slot — the clip stays put")),
- (Loc.T("Drag clip + ⌥"), Loc.T("Position freely, ignoring the grid for this drag (the magnet in the transport latches the same thing)")),
- (Loc.T("Wheel over the device chain"), Loc.T("Scroll it sideways · over an EQ band's handle the wheel sets its Q, over a value box it steps the value")),
- (Loc.T("Drag knob"), Loc.T("Change a device value · hold ⌘ or ⇧ for fine steps")),
- (Loc.T("Drag slider"), Loc.T("Left / right (or up / down) changes the value · hold ⌘ or ⇧ for fine steps")),
- (Loc.T("⌥-click a knob, fader or slider"), Loc.T("Type a value (units like k, ms, dB, L / R work) · double-click its value does the same")),
- (Loc.T("Return · Esc · Tab / ⇧Tab (typing a value)"), Loc.T("Set it · cancel · set it and type the next / previous value on the card")),
- (Loc.T("⌥-click a graph handle, envelope node or mod-matrix cell"), Loc.T("Type its values — a node with several (frequency · gain · Q, decay · sustain) takes Tab between them")),
- (Loc.T("Double-click a knob, fader or slider"), Loc.T("Reset the value to its default")),
- (Loc.T("Double-click a mod-matrix cell"), Loc.T("Clear the route (Volt, Aurora) · pull the cable (Consort)")),
- (Loc.T("Right-click a knob, fader or slider"), Loc.T("Type value… · Reset to default")),
- (Loc.T("Drag jack → jack"), Loc.T("Patch a cable in Nota Consort · ⌥-click a jack to pull its cables")),
- (Loc.T("Click · ⇧ · ⌥ a Rhythm step"), Loc.T("Step on / off · accent · quiet step — drag across to paint, up / down (or scroll) for its velocity")),
- (Loc.T("Click a Rhythm voice"), Loc.T("Select and play it · drop a file on it to load a sample")),
+ (Loc.T("preferences.mouse"), new[]
+ {
+ (Loc.T("preferences.double_click_clip"), Loc.T("preferences.open_in_the_clip_editor")),
+ (Loc.T("preferences.double_click_a_track_header"), Loc.T("preferences.open_its_devices_in_the")),
+ (Loc.T("preferences.double_click_a_browser_instrument"), Loc.T("preferences.swap_it_onto_the_selected")),
+ ("⌥ + double-click a browser instrument", Loc.T("preferences.always_start_a_new_track")),
+ (Loc.T("preferences.right_click_the_metronome"), Loc.T("preferences.count_in_before_play_record")),
+ (Loc.T("preferences.drag_an_audio_clips_adsr"), Loc.T("preferences.shape_attack_decay_sustain_release")),
+ (Loc.T("preferences.click_track_header"), Loc.T("preferences.add_the_track_to_the")),
+ (Loc.T("preferences.click_a_groups_link_key"), Loc.T("preferences.link_the_groups_tracks_arming")),
+ (Loc.T("preferences.click_a_clip_or_arm"), Loc.T("preferences.in_a_linked_group_select")),
+ (Loc.T("preferences.right_click_track_headers"), Loc.T("preferences.a_multi_selection_gets_its")),
+ (Loc.T("preferences.drag_a_tracks_bottom_edge"), Loc.T("preferences.resize_the_track_header_or")),
+ (Loc.T("preferences.drag_a_tracks_bottom_edge_2"), Loc.T("preferences.resize_every_track_at_once")),
+ (Loc.T("preferences.double_click_a_tracks_bottom"), Loc.T("preferences.back_to_the_standard_height")),
+ (Loc.T("preferences.drag_a_returns_or_the"), Loc.T("preferences.resize_that_row_header_or")),
+ ("⌘-click / ⇧-click return headers", Loc.T("preferences.select_several_returns_they_resize")),
+ (Loc.T("preferences.click_a_height_key_in"), Loc.T("preferences.set_every_track_to_compact")),
+ (Loc.T("preferences.drag_the_track_list_edge"), Loc.T("preferences.widen_or_narrow_the_track")),
+ (Loc.T("preferences.drag_sections_lane"), Loc.T("preferences.mark_a_new_section_over")),
+ (Loc.T("preferences.click_section"), Loc.T("preferences.jump_the_playhead_to_its")),
+ (Loc.T("preferences.double_click_section"), Loc.T("preferences.rename_it_right_click_reset")),
+ (Loc.T("preferences.return_esc_renaming_a_section"), Loc.T("preferences.keep_the_name_empty_automatic")),
+ (Loc.T("preferences.drag_section"), Loc.T("preferences.rearrange_the_song_it_and")),
+ (Loc.T("preferences.drag_section_2"), Loc.T("preferences.move_only_the_section_marker")),
+ (Loc.T("preferences.drag_section_edge"), Loc.T("preferences.resize_it_snapped_to_bars")),
+ (Loc.T("preferences.right_click_section"), Loc.T("preferences.move_earlier_later_duplicate_or")),
+ (Loc.T("preferences.drag_overview_strip"), Loc.T("preferences.drag_sideways_to_scroll_up")),
+ (Loc.T("preferences.drag_overview_edge"), Loc.T("preferences.zoom_by_resizing_the_viewport")),
+ (Loc.T("preferences.double_click_overview"), Loc.T("preferences.fit_the_whole_project_on")),
+ (Loc.T("preferences.drag_a_device_header"), Loc.T("preferences.reorder_devices_or_right_click")),
+ (Loc.T("preferences.right_click_a_device_header"), Loc.T("preferences.a_b_compare_move_copy")),
+ (Loc.T("preferences.delete_device_selected"), Loc.T("preferences.remove_the_selected_device_the")),
+ (Loc.T("preferences.drag_an_audio_clip_onto"), Loc.T("preferences.load_its_audio_into_the")),
+ (Loc.T("preferences.drag_an_audio_clip_out"), Loc.T("preferences.take_it_as_a_sample")),
+ (Loc.T("preferences.drag_clip_2"), Loc.T("preferences.position_freely_ignoring_the_grid")),
+ (Loc.T("preferences.wheel_over_the_device_chain"), Loc.T("preferences.scroll_it_sideways_over_an")),
+ (Loc.T("preferences.drag_knob"), Loc.T("preferences.change_a_device_value_hold")),
+ (Loc.T("preferences.drag_slider"), Loc.T("preferences.left_right_or_up_down")),
+ (Loc.T("preferences.click_a_knob_fader_or"), Loc.T("preferences.type_a_value_units_like")),
+ (Loc.T("preferences.return_esc_tab_tab_typing"), Loc.T("preferences.set_it_cancel_set_it")),
+ (Loc.T("preferences.click_a_graph_handle_envelope"), Loc.T("preferences.type_its_values_a_node")),
+ (Loc.T("preferences.double_click_a_knob_fader"), Loc.T("preferences.reset_the_value_to_its")),
+ (Loc.T("preferences.double_click_a_mod_matrix"), Loc.T("preferences.clear_the_route_volt_aurora")),
+ (Loc.T("preferences.right_click_a_knob_fader"), Loc.T("preferences.type_value_reset_to_default")),
+ (Loc.T("preferences.drag_jack_jack"), Loc.T("preferences.patch_a_cable_in_nota")),
+ (Loc.T("preferences.click_a_rhythm_step"), Loc.T("preferences.step_on_off_accent_quiet")),
+ (Loc.T("preferences.click_a_rhythm_voice"), Loc.T("preferences.select_and_play_it_drop")),
}),
};
private Control ShortcutsPane()
{
var groups = new StackPanel { Spacing = 18 };
- var filter = new TextBox { PlaceholderText = Loc.T("Filter shortcuts"), Text = _shortcutFilter, Classes = { "search" }, FontSize = 12 };
+ var filter = new TextBox { PlaceholderText = Loc.T("preferences.filter_shortcuts"), Text = _shortcutFilter, Classes = { "search" }, FontSize = 12 };
void Render()
{
@@ -1665,7 +1665,7 @@ public sealed partial class PreferencesWindow : NotaWindow
};
groups.Children.Add(new StackPanel { Spacing = 6, Children = { head, Table(shown.Select(r => ShortcutRow(r.Key, r.Action)).ToList()) } });
}
- if (groups.Children.Count == 0) groups.Children.Add(Caption(Loc.T("Nothing matches.")));
+ if (groups.Children.Count == 0) groups.Children.Add(Caption(Loc.T("preferences.nothing_matches")));
}
filter.TextChanged += (_, _) => { _shortcutFilter = filter.Text ?? ""; Render(); };
Render();
@@ -1680,7 +1680,7 @@ public sealed partial class PreferencesWindow : NotaWindow
{
var settings = App.Services.GetService<ISettingsService>();
var step = Combo(150);
- foreach (var m in VelocityWheelSteps) step.Items.Add(m == 0 ? Loc.T("Off") : $"{m.ToString("0.##", NotaNum.Culture)}×");
+ foreach (var m in VelocityWheelSteps) step.Items.Add(m == 0 ? Loc.T("common.off") : $"{m.ToString("0.##", NotaNum.Culture)}×");
int idx = Array.FindIndex(VelocityWheelSteps, m => Math.Abs(m - PianoRollView.VelocityWheelMultiplier) < 1e-6);
step.SelectedIndex = idx >= 0 ? idx : Array.IndexOf(VelocityWheelSteps, 1.0);
step.SelectionChanged += (_, _) =>
@@ -1692,17 +1692,17 @@ public sealed partial class PreferencesWindow : NotaWindow
settings.Current.PianoRollVelocityWheelMultiplier = VelocityWheelSteps[k];
settings.Save();
};
- var reverse = SwitchRow(Loc.T("Wheel up lowers the velocity"), PianoRollView.VelocityWheelReversed, on =>
+ var reverse = SwitchRow(Loc.T("preferences.wheel_up_lowers_the_velocity"), PianoRollView.VelocityWheelReversed, on =>
{
PianoRollView.VelocityWheelReversed = on;
if (settings is null) return;
settings.Current.PianoRollVelocityWheelReversed = on;
settings.Save();
});
- return Section(Loc.T("Velocity wheel"), 8,
- Row(Loc.T("Direction"), reverse),
- Row(Loc.T("Step"), step),
- Row("", Caption(Loc.T("⇧ + wheel over a note in the piano roll changes its velocity, or the whole selection's when that note is selected: one MIDI step per notch at 1×. Anywhere else ⇧ + wheel scrolls, and Off leaves it scrolling everywhere."))));
+ return Section(Loc.T("preferences.velocity_wheel"), 8,
+ Row(Loc.T("preferences.direction"), reverse),
+ Row(Loc.T("preferences.step"), step),
+ Row("", Caption(Loc.T("preferences.wheel_over_a_note_in"))));
}
private static readonly HashSet<string> NamedKeys = new(StringComparer.Ordinal) { "Space", "Return", "Delete", "Tab", "Esc", "PgUp", "PgDn", "⌘Return", "⌥Return", "⇧Return", "⇧Tab", "⇧Space" };
@@ -1924,7 +1924,7 @@ public sealed partial class PreferencesWindow : NotaWindow
private static void FillDeviceCombo(ComboBox combo, List<string> uids, IReadOnlyList<AudioDevice> devices, string savedUid)
{
uids.Clear();
- combo.Items.Add(Loc.T("System default"));
+ combo.Items.Add(Loc.T("preferences.system_default"));
uids.Add("");
int selected = 0;
for (int i = 0; i < devices.Count; i++)
diff --git a/src/managed/Nota.App/PreviewPlayer.cs b/src/managed/Nota.App/PreviewPlayer.cs
index 0c0d938a..cf13ae74 100644
--- a/src/managed/Nota.App/PreviewPlayer.cs
+++ b/src/managed/Nota.App/PreviewPlayer.cs
@@ -127,7 +127,7 @@ public sealed class PreviewPlayer : UserControl
_playGlyph = new Glyph(GlyphKind.Play, 11);
_stopGlyph = new Glyph(GlyphKind.Stop, 8) { Foreground = NotaPalette.TextOnAccent, IsVisible = false };
_playBtn = Chip(new Panel { Children = { _playGlyph, _stopGlyph } }, 28, 28, 5);
- ToolTip.SetTip(_playBtn, Loc.T("Play / stop"));
+ ToolTip.SetTip(_playBtn, Loc.T("common.play_stop"));
_playBtn.PointerPressed += (_, e) => { if (IsLeft(e)) { Toggle(); e.Handled = true; } };
_timeNow = new TextBlock { FontSize = 10, FontFamily = NotaFonts.MonoFamily, VerticalAlignment = VerticalAlignment.Center };
@@ -160,18 +160,18 @@ public sealed class PreviewPlayer : UserControl
_loopIcon = new Glyph(GlyphKind.Loop, 12);
_loopBtn = Chip(_loopIcon, 22, 22, 4);
- ToolTip.SetTip(_loopBtn, Loc.T("Loop"));
+ ToolTip.SetTip(_loopBtn, Loc.T("common.loop"));
_loopBtn.PointerPressed += (_, e) => { if (IsLeft(e)) { SetLoop(!_loop, persist: true); e.Handled = true; } };
_autoDot = new Ellipse { Width = 6, Height = 6, VerticalAlignment = VerticalAlignment.Center };
- _autoText = new TextBlock { Text = Loc.T("Auto"), FontSize = 10, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center };
+ _autoText = new TextBlock { Text = Loc.T("common.auto"), FontSize = 10, FontWeight = FontWeight.SemiBold, VerticalAlignment = VerticalAlignment.Center };
_autoBtn = Chip(new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 5, VerticalAlignment = VerticalAlignment.Center,
Children = { _autoDot, _autoText },
}, double.NaN, 22, 4);
_autoBtn.Padding = new Thickness(7, 0);
- ToolTip.SetTip(_autoBtn, Loc.T("Auto-audition: play on select"));
+ ToolTip.SetTip(_autoBtn, Loc.T("preview_player.auto_audition_play_on_select"));
_autoBtn.PointerPressed += (_, e) => { if (IsLeft(e)) { SetAuto(!_auto, persist: true); e.Handled = true; } };
var speaker = new Glyph(GlyphKind.Speaker, 12) { Foreground = NotaPalette.TextMuted };
@@ -394,12 +394,12 @@ public sealed class PreviewPlayer : UserControl
_playing = true;
_pos = from;
_poll.Start();
- StatusChanged?.Invoke(Loc.F("Previewing {0}", _item.Name));
+ StatusChanged?.Invoke(Loc.F("preview_player.previewing", _item.Name));
}
catch (Exception ex)
{
_playing = false;
- StatusChanged?.Invoke(Loc.F("Preview failed: {0}", ex.Message));
+ StatusChanged?.Invoke(Loc.F("preview_player.preview_failed", ex.Message));
}
Refresh();
}
@@ -450,7 +450,7 @@ public sealed class PreviewPlayer : UserControl
_autoBtn.BorderBrush = on ? NotaPalette.Accent : NotaPalette.Seam;
_autoDot.Fill = on ? NotaPalette.TextOnAccent : NotaPalette.BorderStrong;
_autoText.Foreground = on ? NotaPalette.TextOnAccent : NotaPalette.TextMuted;
- ToolTip.SetTip(_autoBtn, _filesContext ? Loc.T("Auto-audition: play a sample on select") : Loc.T("Auto-audition: play a preset or device on select"));
+ ToolTip.SetTip(_autoBtn, _filesContext ? Loc.T("preview_player.auto_audition_play_a_sample") : Loc.T("preview_player.auto_audition_play_a_preset"));
if (persist && _settings is not null)
{
if (_filesContext) _settings.Current.BrowserPreviewAuto = on;
@@ -484,8 +484,8 @@ public sealed class PreviewPlayer : UserControl
try { _engine?.SetPreviewGain((float)(v * v)); } catch { }
_volWaves.Kind = v <= 0.001 ? GlyphKind.SpeakerMute : v < 0.5 ? GlyphKind.SpeakerLow : GlyphKind.SpeakerHigh;
var db = NotaNum.Db(v <= 0.001 ? double.NegativeInfinity : 40 * Math.Log10(v));
- ToolTip.SetTip(_volumeBox, Loc.F("Preview volume {0} · ⌥-click to type · double-click for 0{1}dB", db, NotaNum.Thin));
- ToolTip.SetTip(_volumePop, Loc.F("Preview volume {0} · ⌥-click to type · double-click for 0{1}dB", db, NotaNum.Thin));
+ ToolTip.SetTip(_volumeBox, Loc.F("preview_player.preview_volume_click_to_type", db, NotaNum.Thin));
+ ToolTip.SetTip(_volumePop, Loc.F("preview_player.preview_volume_click_to_type", db, NotaNum.Thin));
if (persist && _settings is not null) { _settings.Current.BrowserPreviewVolume = v; _settings.Save(); }
}
@@ -516,7 +516,7 @@ public sealed class PreviewPlayer : UserControl
mi.Click += (_, _) => SetTrack(id);
flyout.Items.Add(mi);
}
- Add(autoName.Length > 0 ? Loc.F("Auto ({0})", autoName) : Loc.T("Auto"), AuditionTrackIds.Auto, Loc.T("Picked for this effect: drums for dynamics, keys for time and modulation, a full mix for tone"));
+ Add(autoName.Length > 0 ? Loc.F("preview_player.auto", autoName) : Loc.T("common.auto"), AuditionTrackIds.Auto, Loc.T("preview_player.picked_for_this_effect_drums"));
string group = "";
foreach (var t in _audition.Tracks)
{
@@ -529,7 +529,7 @@ public sealed class PreviewPlayer : UserControl
Add(t.Name, t.Id, t.Blurb);
}
flyout.Items.Add(new Separator());
- Add(_samplePath is null ? Loc.T("Sample — pick one in Files") : Loc.F("Sample — {0}", System.IO.Path.GetFileNameWithoutExtension(_samplePath)),
+ Add(_samplePath is null ? Loc.T("preview_player.sample_pick_one_in_files") : Loc.F("preview_player.sample", System.IO.Path.GetFileNameWithoutExtension(_samplePath)),
AuditionTrackIds.Sample, enabled: _samplePath is not null);
flyout.ShowAt(_sourceBtn);
}
@@ -576,8 +576,8 @@ public sealed class PreviewPlayer : UserControl
_sourceBtn.IsVisible = _plan is { IsEffect: true };
if (_plan is { IsEffect: true } plan)
{
- _sourceText.Text = plan.TrackId == AuditionTrackIds.Sample ? Loc.T("Sample") : plan.TrackName;
- ToolTip.SetTip(_sourceBtn, Loc.F("Heard through {0} — click to pick a track, scroll to step through them", plan.TrackName + (_fxTrack == AuditionTrackIds.Auto ? Loc.T(" (auto for this effect)") : "")));
+ _sourceText.Text = plan.TrackId == AuditionTrackIds.Sample ? Loc.T("common.sample") : plan.TrackName;
+ ToolTip.SetTip(_sourceBtn, Loc.F("preview_player.heard_through_click_to_pick", plan.TrackName + (_fxTrack == AuditionTrackIds.Auto ? Loc.T("preview_player.auto_for_this_effect") : "")));
}
Adapt();
}
@@ -611,7 +611,7 @@ public sealed class PreviewPlayer : UserControl
const double gap = 6, minMiddle = 8;
double now = TextW(_timeNow.Text ?? "", NotaFonts.Mono, 10);
double total = 3 + TextW(_timeTotal.Text ?? "", NotaFonts.Mono, 10);
- double autoFull = 2 + 7 + 6 + 5 + TextW(Loc.T("Auto"), NotaFonts.SansSemiBold, 10) + 7, autoDot = 22;
+ double autoFull = 2 + 7 + 6 + 5 + TextW(Loc.T("common.auto"), NotaFonts.SansSemiBold, 10) + 7, autoDot = 22;
double volFull = 12 + 5 + 46, volIcon = 22, loop = 22 + gap;
double source = _sourceBtn.IsVisible ? 2 + 14 + 5 + 6 + TextW(_sourceText.Text ?? "", NotaFonts.SansSemiBold, 10) + gap : 0;
@@ -705,9 +705,9 @@ public sealed class PreviewPlayer : UserControl
{
if (!job.Cancelled && current)
{
- _wave.Hint = Loc.T("no sound to preview");
+ _wave.Hint = Loc.T("preview_player.no_sound_to_preview");
_playWhenReady = null;
- StatusChanged?.Invoke(Loc.F("Preview failed: {0}", _item?.Name));
+ StatusChanged?.Invoke(Loc.F("preview_player.preview_failed", _item?.Name));
Refresh();
}
if (!current || job.Cancelled) Prefetch();
@@ -862,7 +862,7 @@ public sealed class PreviewPlayer : UserControl
br.ReadBytes(8);
format = br.ReadUInt16();
}
- return format == 3 ? Loc.F("{0}-bit float", bits) : $"{bits}-bit";
+ return format == 3 ? Loc.F("preview_player.bit_float", bits) : $"{bits}-bit";
}
fs.Position += size + (size & 1);
}
@@ -1039,7 +1039,7 @@ public sealed class PreviewWaveform : Control
}
ctx.DrawGeometry(null, NotaGraph.PrimaryPen, geo);
}
- else hint ??= _peaks is null ? null : Loc.T("play to see the spectrum");
+ else hint ??= _peaks is null ? null : Loc.T("preview_player.play_to_see_the_spectrum");
if (started && _duration > 0)
ctx.FillRectangle(NotaPalette.Accent, new Rect(InsetX, h - 3, innerW * p, 1.5));
}
@@ -1098,8 +1098,8 @@ public sealed class PreviewWaveform : Control
}
// WAVE · SPEC, the active one in brass, top-right.
- var wave = NotaGraph.AxisText(Loc.T("Wave"), _spectrum ? NotaPalette.TextTertiary : NotaPalette.Accent, 7);
- var spec = NotaGraph.AxisText(Loc.T("Spec"), _spectrum ? NotaPalette.Accent : NotaPalette.TextTertiary, 7);
+ var wave = NotaGraph.AxisText(Loc.T("preview_player.wave"), _spectrum ? NotaPalette.TextTertiary : NotaPalette.Accent, 7);
+ var spec = NotaGraph.AxisText(Loc.T("preview_player.spec"), _spectrum ? NotaPalette.Accent : NotaPalette.TextTertiary, 7);
double lw = wave.Width + 5 + spec.Width, lx = w - lw - 5, ly = 3;
_toggleRect = new Rect(lx - 4, 0, lw + 9, ly + wave.Height + 3);
ctx.FillRectangle(NotaPalette.BgSunken, new Rect(lx - 2, ly - 1, lw + 4, wave.Height + 2), 2);
@@ -1134,7 +1134,7 @@ public sealed class PreviewVolume : Control
public PreviewVolume()
{
Cursor = new Cursor(StandardCursorType.SizeWestEast);
- ValueEntry.Attach(this, new ValueField(Loc.T("Preview volume"), () => _value, n => NotaNum.GainDb(n),
+ ValueEntry.Attach(this, new ValueField(Loc.T("preview_player.preview_volume"), () => _value, n => NotaNum.GainDb(n),
n => { Value = n; ValueChanged?.Invoke(_value, true); }, Default: 1));
}
diff --git a/src/managed/Nota.App/ProgressWindow.cs b/src/managed/Nota.App/ProgressWindow.cs
index ecab0bfd..00bab3d1 100644
--- a/src/managed/Nota.App/ProgressWindow.cs
+++ b/src/managed/Nota.App/ProgressWindow.cs
@@ -69,11 +69,11 @@ public sealed class ProgressWindow : NotaWindow
body.Children.Add(_bar);
if (cancel is not null)
{
- var stop = new Button { Content = Loc.T("Cancel"), Classes = { "ghost" }, HorizontalAlignment = HorizontalAlignment.Right };
+ var stop = new Button { Content = Loc.T("common.cancel"), Classes = { "ghost" }, HorizontalAlignment = HorizontalAlignment.Right };
stop.Click += (_, _) =>
{
stop.IsEnabled = false;
- _label.Text = Loc.T("Cancelling…");
+ _label.Text = Loc.T("progress.cancelling");
cancel.Cancel();
};
body.Children.Add(stop);
diff --git a/src/managed/Nota.App/RecordInputPick.cs b/src/managed/Nota.App/RecordInputPick.cs
index 9bfb906d..ad30e544 100644
--- a/src/managed/Nota.App/RecordInputPick.cs
+++ b/src/managed/Nota.App/RecordInputPick.cs
@@ -17,9 +17,9 @@ internal readonly record struct RecordInputPick(int Source, InputChannels Channe
/// <summary>The hardware-input entries, in picker order, with their menu and short labels.</summary>
public static readonly (RecordInputPick Pick, string Label, string Short)[] Hardware =
{
- (new(0, InputChannels.Mono1), Loc.T("Audio input 1 (mono)"), Loc.T("Ext 1")),
- (new(0, InputChannels.Mono2), Loc.T("Audio input 2 (mono)"), Loc.T("Ext 2")),
- (new(0, InputChannels.Stereo), Loc.T("Audio inputs 1/2 (stereo)"), "Ext 1/2"),
+ (new(0, InputChannels.Mono1), Loc.T("record_input_pick.audio_input_1_mono"), Loc.T("record_input_pick.ext_1")),
+ (new(0, InputChannels.Mono2), Loc.T("record_input_pick.audio_input_2_mono"), Loc.T("record_input_pick.ext_2")),
+ (new(0, InputChannels.Stereo), Loc.T("record_input_pick.audio_inputs_1_2_stereo"), "Ext 1/2"),
};
/// <summary>A track's current pick. Channels only matter for the hardware input.</summary>
@@ -31,7 +31,7 @@ internal readonly record struct RecordInputPick(int Source, InputChannels Channe
/// <summary>The short label of a hardware pick ("Ext 1", "Ext 2", "Ext 1/2").</summary>
public static string HardwareShort(InputChannels channels)
- => Array.Find(Hardware, h => h.Pick.Channels == channels).Short ?? Loc.T("Ext");
+ => Array.Find(Hardware, h => h.Pick.Channels == channels).Short ?? Loc.T("record_input_pick.ext");
/// <summary>A track or return as a source (any channel setting: only hardware has one).</summary>
public static RecordInputPick Track(int source) => new(source, InputChannels.Stereo);
diff --git a/src/managed/Nota.App/Remote/ConnectPhoneView.cs b/src/managed/Nota.App/Remote/ConnectPhoneView.cs
index 746c8d61..806ef776 100644
--- a/src/managed/Nota.App/Remote/ConnectPhoneView.cs
+++ b/src/managed/Nota.App/Remote/ConnectPhoneView.cs
@@ -68,10 +68,10 @@ internal sealed class ConnectPhoneView : Border
_qr = null; _code = _left = null; _ring = null;
bool on = _settings.Current.RemoteEnabled;
- var title = new TextBlock { Text = Loc.T("Connect phone"), FontSize = 13, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextPrimary, VerticalAlignment = VerticalAlignment.Center };
+ var title = new TextBlock { Text = Loc.T("remote.connect.connect_phone"), FontSize = 13, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextPrimary, VerticalAlignment = VerticalAlignment.Center };
var sw = new ToggleSwitch(on) { VerticalAlignment = VerticalAlignment.Center };
sw.Changed += v => { _settings.Current.RemoteEnabled = v; _settings.Save(); _ = _remote.ApplyAsync(); };
- var allow = new TextBlock { Text = Loc.T("Allow"), FontSize = 11, Foreground = NotaPalette.TextSecondary, VerticalAlignment = VerticalAlignment.Center };
+ var allow = new TextBlock { Text = Loc.T("remote.connect.allow"), FontSize = 11, Foreground = NotaPalette.TextSecondary, VerticalAlignment = VerticalAlignment.Center };
var head = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto,Auto"), ColumnSpacing = 7, Margin = new Thickness(18, 16, 18, 12) };
head.Children.Add(title);
Grid.SetColumn(sw, 1); head.Children.Add(sw);
@@ -81,10 +81,10 @@ internal sealed class ConnectPhoneView : Border
if (!on)
{
_body.Children.Add(Note(OperatingSystem.IsMacOS()
- ? Loc.T("Remote is off. Turn it on to show a QR code. The first time, macOS asks to allow Nota on the local network; click Allow.")
+ ? Loc.T("remote.connect.remote_is_off_turn_it_3")
: OperatingSystem.IsWindows()
- ? Loc.T("Remote is off. Turn it on to show a QR code. The first time, Windows asks whether Nota may use the network; allow private networks.")
- : Loc.T("Remote is off. Turn it on to show a QR code a phone on the same Wi-Fi can scan."), new Thickness(18, 0, 18, 18)));
+ ? Loc.T("remote.connect.remote_is_off_turn_it_2")
+ : Loc.T("remote.connect.remote_is_off_turn_it"), new Thickness(18, 0, 18, 18)));
_lastDevices = "";
return;
}
@@ -95,23 +95,23 @@ internal sealed class ConnectPhoneView : Border
}
if (_remote.Url is null)
{
- _body.Children.Add(Note(Loc.T("This computer isn't on a network. Join the same Wi-Fi as the phone, share the phone's hotspot with it, or plug in a USB cable (USB tethering on the phone; Internet Sharing on the Mac)."), new Thickness(18, 0, 18, 18)));
+ _body.Children.Add(Note(Loc.T("remote.connect.this_computer_isnt_on_a"), new Thickness(18, 0, 18, 18)));
return;
}
_qr = new QrView { Width = 150, Height = 150, Text = _remote.QrText };
var info = new StackPanel { Spacing = 10 };
- info.Children.Add(Field(Loc.T("Address"), AddressRows()));
+ info.Children.Add(Field(Loc.T("remote.connect.address"), AddressRows()));
_code = new TextBlock { FontSize = 24, FontWeight = FontWeight.Medium, LetterSpacing = 4.8, FontFamily = NotaFonts.MonoFamily, Foreground = NotaPalette.TextHeading, VerticalAlignment = VerticalAlignment.Center };
_ring = new Arc { Width = 20, Height = 20, StrokeThickness = 2.5, Stroke = NotaPalette.VizInk, StartAngle = -90, VerticalAlignment = VerticalAlignment.Center };
var ringBack = new Ellipse { Width = 20, Height = 20, StrokeThickness = 2.5, Stroke = NotaPalette.TrackOff };
_left = new TextBlock { FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = NotaPalette.TextTertiary, VerticalAlignment = VerticalAlignment.Center };
var codeRow = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 10, Children = { _code, new Panel { Children = { ringBack, _ring } }, _left } };
- info.Children.Add(Field(Loc.T("Code"), codeRow));
+ info.Children.Add(Field(Loc.T("remote.connect.code"), codeRow));
bool usb = _remote.Links is { Count: > 0 } links && links[0].Usb;
info.Children.Add(Note(usb
- ? Loc.T("Point the phone camera at the code. Over the cable the link is instant and needs no Wi-Fi; the code changes every 2 minutes and after each connection.")
- : Loc.T("Point the phone camera at the code. Same Wi-Fi only — or plug in a USB cable (USB tethering on the phone; Internet Sharing on the Mac) for an instant link. The code changes every 2 minutes and after each connection."),
+ ? Loc.T("remote.connect.point_the_phone_camera_at")
+ : Loc.T("remote.connect.point_the_phone_camera_at_2"),
new Thickness(0)));
var top = new Grid { ColumnDefinitions = new ColumnDefinitions("Auto,*"), ColumnSpacing = 16, Margin = new Thickness(18, 0, 18, 16) };
top.Children.Add(_qr);
@@ -139,10 +139,10 @@ internal sealed class ConnectPhoneView : Border
for (int b = 0; b < 3; b++)
sig.Children.Add(new Border { Width = 3, Height = 4 + b * 4, CornerRadius = NotaRadius.Bar, VerticalAlignment = VerticalAlignment.Bottom, Background = b < bars ? c : NotaPalette.BorderStrong });
- string screen = d.Screen.Length > 0 ? d.Screen : Loc.T("connected");
- string sub = d.RttMs < 0 ? Loc.T("connecting") : weak ? Loc.F("{0} ms · weak network", d.RttMs)
- : d.Usb ? Loc.F("USB · {0}\u2009ms · {1}", d.RttMs, screen)
- : Loc.F("{0}\u2009ms · {1}", d.RttMs, screen);
+ string screen = d.Screen.Length > 0 ? d.Screen : Loc.T("remote.connect.connected");
+ string sub = d.RttMs < 0 ? Loc.T("remote.connect.connecting") : weak ? Loc.F("remote.connect.ms_weak_network", d.RttMs)
+ : d.Usb ? Loc.F("remote.connect.usb_ms", d.RttMs, screen)
+ : Loc.F("remote.connect.ms", d.RttMs, screen);
var names = new StackPanel { Spacing = 1, VerticalAlignment = VerticalAlignment.Center };
names.Children.Add(new TextBlock { Text = d.Name, FontSize = 12, FontWeight = FontWeight.Medium, Foreground = NotaPalette.TextPrimary, TextTrimming = TextTrimming.CharacterEllipsis });
names.Children.Add(new TextBlock { Text = sub, FontSize = 10, FontFamily = NotaFonts.MonoFamily, Foreground = weak ? NotaPalette.Warning : NotaPalette.TextTertiary });
@@ -155,7 +155,7 @@ internal sealed class ConnectPhoneView : Border
Width = 26, Height = 26, CornerRadius = NotaRadius.Tile, Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand),
Child = new Glyph(GlyphKind.Close, 9) { Foreground = NotaPalette.TextMuted, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center },
};
- ToolTip.SetTip(x, Loc.T("Disconnect this phone (it stays trusted — forget it in Settings → Remote)"));
+ ToolTip.SetTip(x, Loc.T("remote.connect.disconnect_this_phone_it_stays"));
x.PointerEntered += (_, _) => x.Background = NotaPalette.SurfaceHover;
x.PointerExited += (_, _) => x.Background = Brushes.Transparent;
int conn = d.ConnectionId;
@@ -195,7 +195,7 @@ internal sealed class ConnectPhoneView : Border
{
Height = 16, Padding = new Thickness(5, 0), CornerRadius = NotaRadius.Bar, VerticalAlignment = VerticalAlignment.Center,
Background = NotaPalette.SurfaceRaised, BorderBrush = NotaPalette.Seam, BorderThickness = new Thickness(1),
- Child = new TextBlock { Text = Loc.T("USB"), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextPrimary, VerticalAlignment = VerticalAlignment.Center },
+ Child = new TextBlock { Text = Loc.T("remote.connect.usb_caps"), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextPrimary, VerticalAlignment = VerticalAlignment.Center },
});
var rows = new StackPanel { Spacing = links.Count > 1 ? 3 : 0, Children = { first } };
for (int i = 1; i < links.Count; i++)
diff --git a/src/managed/Nota.App/Remote/RemoteService.cs b/src/managed/Nota.App/Remote/RemoteService.cs
index 7a79ab32..6bc7c903 100644
--- a/src/managed/Nota.App/Remote/RemoteService.cs
+++ b/src/managed/Nota.App/Remote/RemoteService.cs
@@ -116,7 +116,7 @@ public sealed class RemoteService
catch (Exception e)
{
Error = e is IOException || e.InnerException is System.Net.Sockets.SocketException
- ? Loc.F("Port {0} is in use by another app. Pick another port.", s.RemotePort)
+ ? Loc.F("remote.port_is_in_use_by", s.RemotePort)
: e.Message;
_log.Error($"Nota Remote: {e.Message}");
}
diff --git a/src/managed/Nota.App/SaveChangesWindow.cs b/src/managed/Nota.App/SaveChangesWindow.cs
index fb051c66..45f7a301 100644
--- a/src/managed/Nota.App/SaveChangesWindow.cs
+++ b/src/managed/Nota.App/SaveChangesWindow.cs
@@ -65,16 +65,16 @@ public sealed class SaveChangesWindow : NotaWindow
_dontSave = new Button
{
- Content = Loc.T("Don't save"),
+ Content = Loc.T("save_changes.dont_save"),
Classes = { "ghost" },
Padding = new Thickness(12, 0),
Margin = new Thickness(-12, 0, 0, 0), // the label, not the hover wash, lines up with the text
Foreground = NotaPalette.TextSecondary,
};
_dontSave.Click += (_, _) => Choose(SaveChoice.DontSave);
- _cancel = new Button { Content = Loc.T("Cancel") };
+ _cancel = new Button { Content = Loc.T("common.cancel") };
_cancel.Click += (_, _) => Choose(SaveChoice.Cancel);
- _save = new Button { Content = Loc.T("Save"), Classes = { "primary" }, FontWeight = FontWeight.SemiBold, MinWidth = 64 };
+ _save = new Button { Content = Loc.T("save_changes.save"), Classes = { "primary" }, FontWeight = FontWeight.SemiBold, MinWidth = 64 };
_save.Click += (_, _) => _ = SaveAsync();
var buttons = new DockPanel { LastChildFill = false };
@@ -147,7 +147,7 @@ public sealed class SaveChangesWindow : NotaWindow
if (_saveInPlace is null) { Close(SaveChoice.Save); return; }
_busy = true;
- _save.Content = Loc.T("Saving…"); // the other buttons stay as drawn; Choose ignores them meanwhile
+ _save.Content = Loc.T("save_changes.saving"); // the other buttons stay as drawn; Choose ignores them meanwhile
bool ok;
try { ok = await _saveInPlace(); }
catch { ok = false; }
diff --git a/src/managed/Nota.App/SessionView.Grid.cs b/src/managed/Nota.App/SessionView.Grid.cs
index 971d515d..1026f627 100644
--- a/src/managed/Nota.App/SessionView.Grid.cs
+++ b/src/managed/Nota.App/SessionView.Grid.cs
@@ -52,7 +52,7 @@ public sealed partial class SessionView
Orientation = Orientation.Horizontal, Spacing = 8, VerticalAlignment = VerticalAlignment.Center,
Children =
{
- Text(Loc.T("Scenes"), 10, NotaPalette.TextMuted, FontWeight.SemiBold),
+ Text(Loc.T("session.grid.scenes"), 10, NotaPalette.TextMuted, FontWeight.SemiBold),
Mono(_sceneCount.ToString(CultureInfo.CurrentCulture), 9, NotaPalette.TextDisabled),
},
},
@@ -67,8 +67,8 @@ public sealed partial class SessionView
}
_cellsRow.Children.Add(mid);
- var addScene = new Button { Content = Loc.T("+ Scene"), Classes = { "ghost" }, Height = SpacerH, FontSize = 10, HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center, Padding = new Thickness(0) };
- ToolTip.SetTip(addScene, Loc.T("Add a scene at the end"));
+ var addScene = new Button { Content = Loc.T("session.grid.scene"), Classes = { "ghost" }, Height = SpacerH, FontSize = 10, HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center, Padding = new Thickness(0) };
+ ToolTip.SetTip(addScene, Loc.T("session.grid.add_a_scene_at_the"));
addScene.Click += (_, _) => { int s = _engine.InsertScene(_engine.SceneCount); Refresh(); if (s >= 0) Select(new Selection(SelKind.Scene, 0, s)); };
var stopAll = new Button
@@ -77,10 +77,10 @@ public sealed partial class SessionView
Content = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 7,
- Children = { new Glyph(GlyphKind.Stop, 7), new TextBlock { Text = Loc.T("Stop all clips"), FontSize = 10, FontWeight = FontWeight.SemiBold } },
+ Children = { new Glyph(GlyphKind.Stop, 7), new TextBlock { Text = Loc.T("session.grid.stop_all_clips"), FontSize = 10, FontWeight = FontWeight.SemiBold } },
},
};
- ToolTip.SetTip(stopAll, Loc.T("Stop every session clip"));
+ ToolTip.SetTip(stopAll, Loc.T("session.stop_every_session_clip"));
stopAll.Click += (_, _) => { _engine.StopAllSession(); UpdateStates(); };
var foot = new StackPanel { Width = SceneRailW, Spacing = Gap, Children = { addScene, stopAll } };
@@ -114,7 +114,7 @@ public sealed partial class SessionView
if (c.Kind is ColKind.Track or ColKind.Group)
{
var stop = new Button { Height = StopRowH, HorizontalAlignment = HorizontalAlignment.Stretch, HorizontalContentAlignment = HorizontalAlignment.Center, Padding = new Thickness(0), Content = new Glyph(GlyphKind.Stop, 7) };
- ToolTip.SetTip(stop, c.Kind == ColKind.Group ? Loc.T("Stop every track in this group") : Loc.T("Stop this track"));
+ ToolTip.SetTip(stop, c.Kind == ColKind.Group ? Loc.T("session.grid.stop_every_track_in_this") : Loc.T("session.grid.stop_this_track"));
stop.Click += (_, _) => { StopColumn(c); UpdateStates(); };
foot.Children.Add(stop);
}
@@ -242,7 +242,7 @@ public sealed partial class SessionView
Child = new Glyph(folded ? GlyphKind.ChevronRight : GlyphKind.ChevronDown, 8) { Foreground = NotaPalette.TextSecondary },
Margin = new Thickness(0, 0, 4, 0),
};
- ToolTip.SetTip(chevron, folded ? Loc.T("Show the group's tracks") : Loc.T("Fold the group into one column"));
+ ToolTip.SetTip(chevron, folded ? Loc.T("session.grid.show_the_groups_tracks") : Loc.T("session.grid.fold_the_group_into_one"));
chevron.PointerPressed += (_, e) =>
{
e.Handled = true;
@@ -254,7 +254,7 @@ public sealed partial class SessionView
}
if (c.Kind == ColKind.Track)
{
- var arrText = new TextBlock { Text = Loc.T("Arr"), FontSize = 8, FontWeight = FontWeight.Medium, Foreground = NotaPalette.Accent };
+ var arrText = new TextBlock { Text = Loc.T("session.grid.arr"), FontSize = 8, FontWeight = FontWeight.Medium, Foreground = NotaPalette.Accent };
arrText.BindResource(TextBlock.FontFamilyProperty, "Font.Mono");
_arr = new Border
{
@@ -262,7 +262,7 @@ public sealed partial class SessionView
Padding = new Thickness(3, 0), Margin = new Thickness(4, 0, 0, 0), VerticalAlignment = VerticalAlignment.Center,
Cursor = new Cursor(StandardCursorType.Hand), Child = arrText, IsVisible = false,
};
- ToolTip.SetTip(_arr, Loc.T("Back to Arrangement for this track"));
+ ToolTip.SetTip(_arr, Loc.T("session.grid.back_to_arrangement_for_this"));
_arr.PointerPressed += (_, e) => { e.Handled = true; o._engine.TrackBackToArrangement(c.TrackId); o.UpdateStates(); };
DockPanel.SetDock(_arr, Dock.Right);
top.Children.Add(_arr);
@@ -480,9 +480,9 @@ public sealed partial class SessionView
if (_o.MoveOrCopySlot(_c.TrackId, _scene, t.TrackId, t.Scene, move: !copy))
{
_o.Select(new Selection(SelKind.Slot, t.TrackId, t.Scene));
- _o.Say(copy ? Loc.T("Copied clip") : Loc.T("Moved clip"));
+ _o.Say(copy ? Loc.T("session.copied_clip") : Loc.T("session.moved_clip"));
}
- else _o.Say(Loc.T("Drop a MIDI clip on a MIDI track, audio on audio."));
+ else _o.Say(Loc.T("session.grid.drop_a_midi_clip_on"));
return;
}
if (_o._dragTarget is not null) { _o._dragTarget = null; _o.UpdateStates(); }
@@ -587,7 +587,7 @@ public sealed partial class SessionView
var lenFt = Ft(FormatDuration(_o._recElapsed), NotaFonts.Mono, 9, NotaPalette.DangerBright);
double lenX = r.Width - 6 - lenFt.Width;
ctx.DrawText(lenFt, new Point(lenX, (TopRowH - lenFt.Height) / 2));
- var nameFt = Ft(waiting ? Loc.T("Rec in…") : Loc.T("Recording"), NotaFonts.SansMedium, 11, NotaPalette.TextHeading, lenX - 31);
+ var nameFt = Ft(waiting ? Loc.T("session.grid.rec_in") : Loc.T("session.recording"), NotaFonts.SansMedium, 11, NotaPalette.TextHeading, lenX - 31);
ctx.DrawText(nameFt, new Point(27, (TopRowH - nameFt.Height) / 2));
if (!_c.IsInstrument)
{
@@ -755,7 +755,7 @@ public sealed partial class SessionView
Width = SceneRailW; Height = CellH;
string n = o._engine.GetSceneName(scene);
_named = n.Length > 0;
- _name = _named ? n : Loc.F("Scene {0}", scene + 1);
+ _name = _named ? n : Loc.F("session.scene", scene + 1);
o._engine.TryGetSceneProps(scene, out var p);
_color = p.Color >= 0 ? ArrangementView.TrackBrush(p.Color) : NotaPalette.BorderStrong;
var parts = new List<string>();
@@ -809,7 +809,7 @@ public sealed partial class SessionView
if (_o._sceneDragTarget is { } to && wasDragging)
{
_o._sceneDragTarget = null;
- if (_o._engine.MoveScene(_scene, to)) { _o.Refresh(); _o.Select(new Selection(SelKind.Scene, 0, to)); _o.Say(Loc.T("Moved scene")); }
+ if (_o._engine.MoveScene(_scene, to)) { _o.Refresh(); _o.Select(new Selection(SelKind.Scene, 0, to)); _o.Say(Loc.T("session.grid.moved_scene")); }
return;
}
if (_o._sceneDragTarget is not null) { _o._sceneDragTarget = null; _o.InvalidateAll(); }
@@ -888,27 +888,27 @@ public sealed partial class SessionView
{
string name = _engine.GetSessionClipName(c.TrackId, scene);
MenuKit.AddGroups(f.Items,
- new Control[] { MenuKit.Header(name.Length > 0 ? name : Loc.T("Clip"), c.Brush, Loc.F("{0} · scene {1}", c.Name, scene + 1)) },
+ new Control[] { MenuKit.Header(name.Length > 0 ? name : Loc.T("common.clip"), c.Brush, Loc.F("session.grid.scene_2", c.Name, scene + 1)) },
new Control[]
{
- MenuKit.Item(Loc.T("Launch"), GlyphKind.Play, () => _engine.LaunchSlot(c.TrackId, scene)),
- MenuKit.Item(Loc.T("Edit"), GlyphKind.Edit, () => SlotEditRequested?.Invoke(c.TrackId, scene)),
- MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit, () => RenameSelection(), new KeyGesture(Key.F2)),
+ MenuKit.Item(Loc.T("session.launch"), GlyphKind.Play, () => _engine.LaunchSlot(c.TrackId, scene)),
+ MenuKit.Item(Loc.T("common.edit"), GlyphKind.Edit, () => SlotEditRequested?.Invoke(c.TrackId, scene)),
+ MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit, () => RenameSelection(), new KeyGesture(Key.F2)),
},
- new Control[] { MenuKit.Item(Loc.T("Copy to Arrangement"), GlyphKind.Arrow, () => CopySelectionToArrangement(), MenuKit.CopyToOtherViewKey) },
+ new Control[] { MenuKit.Item(Loc.T("session.grid.copy_to_arrangement"), GlyphKind.Arrow, () => CopySelectionToArrangement(), MenuKit.CopyToOtherViewKey) },
new Control[] { AddTrackSubmenu(c.TrackId) },
MenuKit.ClipboardGroup(() => CopySelection(), () => CutSelection(), () => PasteSelection(), () => DuplicateSelection(), CanPaste),
- new Control[] { MenuKit.Danger(Loc.T("Delete"), GlyphKind.Trash, () => DeleteSelection(), MenuKit.DeleteKey) });
+ new Control[] { MenuKit.Danger(Loc.T("common.delete"), GlyphKind.Trash, () => DeleteSelection(), MenuKit.DeleteKey) });
}
else
{
var create = new List<Control>();
- if (c.IsInstrument) create.Add(MenuKit.Item(Loc.T("Insert MIDI clip"), GlyphKind.Plus, () => InsertMidiClip(c.TrackId, scene)));
- create.Add(MenuKit.Item(Loc.T("Record here"), GlyphKind.Record, () => { _engine.RecordSessionSlot(c.TrackId, scene); Refresh(); }));
+ if (c.IsInstrument) create.Add(MenuKit.Item(Loc.T("session.insert_midi_clip"), GlyphKind.Plus, () => InsertMidiClip(c.TrackId, scene)));
+ create.Add(MenuKit.Item(Loc.T("session.record_here"), GlyphKind.Record, () => { _engine.RecordSessionSlot(c.TrackId, scene); Refresh(); }));
bool stop = _engine.GetSessionSlotStopButton(c.TrackId, scene);
- create.Add(MenuKit.Item(stop ? Loc.T("Remove stop button") : Loc.T("Add stop button"), GlyphKind.Stop, () => { _engine.SetSessionSlotStopButton(c.TrackId, scene, !stop); RefreshSlot(c.TrackId, scene); }));
+ create.Add(MenuKit.Item(stop ? Loc.T("session.grid.remove_stop_button") : Loc.T("session.grid.add_stop_button"), GlyphKind.Stop, () => { _engine.SetSessionSlotStopButton(c.TrackId, scene, !stop); RefreshSlot(c.TrackId, scene); }));
MenuKit.AddGroups(f.Items, create,
- new Control[] { MenuKit.Item(Loc.T("Paste"), GlyphKind.Paste, () => PasteSelection(), MenuKit.PasteKey, CanPaste) },
+ new Control[] { MenuKit.Item(Loc.T("common.paste"), GlyphKind.Paste, () => PasteSelection(), MenuKit.PasteKey, CanPaste) },
new Control[] { AddTrackSubmenu(c.TrackId) });
}
f.ShowAt(anchor, showAtPointer: true);
@@ -917,9 +917,9 @@ public sealed partial class SessionView
// "Add …" entries: the new track lands after `anchorTrackId` (inside it for a group), or at the end.
private IEnumerable<MenuItem> AddTrackItems(int anchorTrackId)
{
- yield return MenuKit.Item(Loc.T("Add instrument track"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Instrument, anchorTrackId));
- yield return MenuKit.Item(Loc.T("Add audio track"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Audio, anchorTrackId));
- yield return MenuKit.Item(Loc.T("Add return track"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Return, anchorTrackId));
+ yield return MenuKit.Item(Loc.T("session.grid.add_instrument_track"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Instrument, anchorTrackId));
+ yield return MenuKit.Item(Loc.T("session.grid.add_audio_track"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Audio, anchorTrackId));
+ yield return MenuKit.Item(Loc.T("session.grid.add_return_track"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Return, anchorTrackId));
}
// "Add track ▸ Instrument / Audio / Return · Recent" — the same submenu the arrangement
@@ -928,10 +928,10 @@ public sealed partial class SessionView
private MenuItem AddTrackSubmenu(int anchorTrackId)
{
- var add = MenuKit.Item(Loc.T("Add track"), GlyphKind.Plus);
- add.Items.Add(MenuKit.Item(Loc.T("Instrument"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Instrument, anchorTrackId)));
- add.Items.Add(MenuKit.Item(Loc.T("Audio"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Audio, anchorTrackId)));
- add.Items.Add(MenuKit.Item(Loc.T("Return"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Return, anchorTrackId)));
+ var add = MenuKit.Item(Loc.T("session.grid.add_track"), GlyphKind.Plus);
+ add.Items.Add(MenuKit.Item(Loc.T("common.instrument"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Instrument, anchorTrackId)));
+ add.Items.Add(MenuKit.Item(Loc.T("common.audio"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Audio, anchorTrackId)));
+ add.Items.Add(MenuKit.Item(Loc.T("common.return"), GlyphKind.Plus, () => AddTrackRequested?.Invoke(NewTrackKind.Return, anchorTrackId)));
MenuKit.AddRecent(add, RecentInstrumentItems?.Invoke(anchorTrackId));
return add;
}
@@ -943,7 +943,7 @@ public sealed partial class SessionView
if (RecentInstrumentItems?.Invoke(anchorTrackId) is { Count: > 0 } recent)
{
f.Items.Add(new Separator());
- f.Items.Add(MenuKit.Caption(Loc.T("Recent")));
+ f.Items.Add(MenuKit.Caption(Loc.T("common.recent")));
foreach (var mi in recent) f.Items.Add(mi);
}
f.ShowAt(anchor, showAtPointer: true);
@@ -957,7 +957,7 @@ public sealed partial class SessionView
if (c.Kind == ColKind.Master)
{
MenuKit.AddGroups(f.Items,
- new Control[] { MenuKit.Header(Loc.T("Master"), NotaPalette.Master, Loc.T("Master")) },
+ new Control[] { MenuKit.Header(Loc.T("common.master"), NotaPalette.Master, Loc.T("common.master")) },
new Control[] { AddTrackSubmenu(-1) });
f.ShowAt(anchor, showAtPointer: true);
return;
@@ -974,11 +974,11 @@ public sealed partial class SessionView
MenuKit.AddGroups(f.Items,
new Control[] { MenuKit.Header(c.Name, c.Brush, pos >= 0 ? $"{c.KindLabel} · {pos + 1}" : c.KindLabel) },
new Control[] { colour },
- new Control[] { MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit, () => PromptRenameTrack(anchor, c.TrackId)) },
+ new Control[] { MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit, () => PromptRenameTrack(anchor, c.TrackId)) },
new Control[] { AddTrackSubmenu(c.TrackId) },
new Control[]
{
- MenuKit.Danger(c.Kind == ColKind.Group ? Loc.T("Delete group and its tracks") : Loc.T("Delete"), GlyphKind.Trash, () =>
+ MenuKit.Danger(c.Kind == ColKind.Group ? Loc.T("session.grid.delete_group_and_its_tracks") : Loc.T("common.delete"), GlyphKind.Trash, () =>
{
_engine.RemoveTracks(new[] { c.TrackId }); // a group takes its tracks along, one undo step
Refresh();
@@ -1001,21 +1001,21 @@ public sealed partial class SessionView
var f = new MenuFlyout();
string name = _engine.GetSceneName(scene);
MenuKit.AddGroups(f.Items,
- new Control[] { MenuKit.Header(name.Length > 0 ? name : Loc.F("Scene {0}", scene + 1), null, Loc.F("Scene · {0}", scene + 1)) },
+ new Control[] { MenuKit.Header(name.Length > 0 ? name : Loc.F("session.scene", scene + 1), null, Loc.F("session.grid.scene_n", scene + 1)) },
new Control[]
{
- MenuKit.Item(Loc.T("Launch scene"), GlyphKind.Play, () => LaunchSceneRow(scene)),
- MenuKit.Item(Loc.T("Stop scene"), GlyphKind.Stop, () => _engine.StopScene(scene)),
- MenuKit.Item(Loc.T("Rename…"), GlyphKind.Edit, () => RenameSelection(), new KeyGesture(Key.F2)),
+ MenuKit.Item(Loc.T("session.grid.launch_scene"), GlyphKind.Play, () => LaunchSceneRow(scene)),
+ MenuKit.Item(Loc.T("session.grid.stop_scene"), GlyphKind.Stop, () => _engine.StopScene(scene)),
+ MenuKit.Item(Loc.T("common.rename"), GlyphKind.Edit, () => RenameSelection(), new KeyGesture(Key.F2)),
},
new Control[]
{
- MenuKit.Item(Loc.T("Insert scene below"), GlyphKind.Plus, () => InsertSceneAtSelection(), MenuKit.Cmd(Key.I)),
- MenuKit.Item(Loc.T("Capture playing clips below"), GlyphKind.Copy, CaptureScene),
- MenuKit.Item(Loc.T("Copy scene to Arrangement"), GlyphKind.Arrow, () => CopySelectionToArrangement(), MenuKit.CopyToOtherViewKey, SelectedSlots().Length > 0),
+ MenuKit.Item(Loc.T("session.grid.insert_scene_below"), GlyphKind.Plus, () => InsertSceneAtSelection(), MenuKit.Cmd(Key.I)),
+ MenuKit.Item(Loc.T("session.grid.capture_playing_clips_below"), GlyphKind.Copy, CaptureScene),
+ MenuKit.Item(Loc.T("session.grid.copy_scene_to_arrangement"), GlyphKind.Arrow, () => CopySelectionToArrangement(), MenuKit.CopyToOtherViewKey, SelectedSlots().Length > 0),
},
MenuKit.ClipboardGroup(null, null, () => PasteSelection(), () => DuplicateSelection(), ClipTransfer.FromArrangement(_engine)),
- new Control[] { MenuKit.Danger(Loc.T("Delete scene"), GlyphKind.Trash, () => DeleteSelection(), MenuKit.DeleteKey, _sceneCount > 1) });
+ new Control[] { MenuKit.Danger(Loc.T("session.grid.delete_scene"), GlyphKind.Trash, () => DeleteSelection(), MenuKit.DeleteKey, _sceneCount > 1) });
f.ShowAt(anchor, showAtPointer: true);
}
}
diff --git a/src/managed/Nota.App/SessionView.Inspector.cs b/src/managed/Nota.App/SessionView.Inspector.cs
index 17d417da..066ceaae 100644
--- a/src/managed/Nota.App/SessionView.Inspector.cs
+++ b/src/managed/Nota.App/SessionView.Inspector.cs
@@ -22,21 +22,21 @@ namespace Nota.App;
public sealed partial class SessionView
{
- private static readonly string[] ModeLabels = { Loc.T("Trigger"), Loc.T("Gate"), Loc.T("Toggle"), Loc.T("Repeat") };
+ private static readonly string[] ModeLabels = { Loc.T("session.inspector.trigger"), Loc.T("common.gate"), Loc.T("session.inspector.toggle"), Loc.T("session.inspector.repeat") };
private static readonly (SessionFollowAction Action, string Label)[] FollowActions =
{
- (SessionFollowAction.None, Loc.T("None")), (SessionFollowAction.Next, Loc.T("Next")), (SessionFollowAction.Again, Loc.T("Again")),
- (SessionFollowAction.Previous, Loc.T("Previous")), (SessionFollowAction.First, Loc.T("First")), (SessionFollowAction.Last, Loc.T("Last")),
- (SessionFollowAction.Any, Loc.T("Any")), (SessionFollowAction.Other, Loc.T("Other")), (SessionFollowAction.Stop, Loc.T("Stop")),
- (SessionFollowAction.Jump, Loc.T("Jump")),
+ (SessionFollowAction.None, Loc.T("common.none")), (SessionFollowAction.Next, Loc.T("session.inspector.next")), (SessionFollowAction.Again, Loc.T("session.inspector.again")),
+ (SessionFollowAction.Previous, Loc.T("session.inspector.previous")), (SessionFollowAction.First, Loc.T("session.inspector.first")), (SessionFollowAction.Last, Loc.T("session.inspector.last")),
+ (SessionFollowAction.Any, Loc.T("session.inspector.any")), (SessionFollowAction.Other, Loc.T("common.other")), (SessionFollowAction.Stop, Loc.T("common.stop")),
+ (SessionFollowAction.Jump, Loc.T("session.inspector.jump")),
};
private static readonly (double Beats, string Label)[] LengthSteps =
{
- (1, Loc.T("1 beat")), (2, Loc.T("2 beats")), (4, Loc.T("1 bar")), (8, Loc.T("2 bars")), (16, Loc.T("4 bars")), (32, Loc.T("8 bars")), (64, Loc.T("16 bars")),
+ (1, Loc.T("session.inspector.1_beat")), (2, Loc.T("session.inspector.2_beats")), (4, Loc.T("common.1_bar")), (8, Loc.T("session.inspector.2_bars")), (16, Loc.T("session.inspector.4_bars")), (32, Loc.T("session.inspector.8_bars")), (64, Loc.T("session.inspector.16_bars")),
};
private static readonly (double Beats, string Label)[] FollowTimes =
{
- (0, Loc.T("One pass")), (1, Loc.T("1 beat")), (2, Loc.T("2 beats")), (4, Loc.T("1 bar")), (8, Loc.T("2 bars")), (16, Loc.T("4 bars")), (32, Loc.T("8 bars")), (64, Loc.T("16 bars")),
+ (0, Loc.T("session.inspector.one_pass")), (1, Loc.T("session.inspector.1_beat")), (2, Loc.T("session.inspector.2_beats")), (4, Loc.T("common.1_bar")), (8, Loc.T("session.inspector.2_bars")), (16, Loc.T("session.inspector.4_bars")), (32, Loc.T("session.inspector.8_bars")), (64, Loc.T("session.inspector.16_bars")),
};
private static readonly (int Num, int Den)[] Signatures = { (0, 0), (2, 4), (3, 4), (4, 4), (5, 4), (6, 8), (7, 8), (12, 8) };
@@ -57,7 +57,7 @@ public sealed partial class SessionView
var hint = new TextBlock
{
- Text = MenuKit.Keys(Loc.T("Click selects · the triangle launches · Enter launches the selection\n←↑↓→ move · ⌘C ⌘V ⌘D · ⌫ delete · ⌘I insert scene\n⌘⇧C copy to arrangement · ⌘V pastes clips copied there")),
+ Text = MenuKit.Keys(Loc.T("session.inspector.click_selects_the_triangle_launches")),
FontSize = 9, LineHeight = 15, Foreground = NotaPalette.TextDisabled, TextWrapping = TextWrapping.Wrap, Margin = new Thickness(16),
};
hint.BindResource(TextBlock.FontFamilyProperty, "Font.Mono");
@@ -199,7 +199,7 @@ public sealed partial class SessionView
BorderBrush = on ? NotaPalette.TextPrimary : Brushes.Transparent, BorderThickness = new Thickness(on ? 1.5 : 0),
Cursor = new Cursor(StandardCursorType.Hand),
};
- ToolTip.SetTip(sw, on ? Loc.T("Click again to use the default colour") : null);
+ ToolTip.SetTip(sw, on ? Loc.T("session.inspector.click_again_to_use_the") : null);
sw.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(sw).Properties.IsLeftButtonPressed) return;
@@ -208,7 +208,7 @@ public sealed partial class SessionView
};
grid.Children.Add(sw);
}
- return new StackPanel { Spacing = 7, Children = { SectionHead(Loc.T("Color")), grid } };
+ return new StackPanel { Spacing = 7, Children = { SectionHead(Loc.T("session.inspector.color")), grid } };
}
// ---- clip ---------------------------------------------------------------------------
@@ -225,7 +225,7 @@ public sealed partial class SessionView
}
var brush = ClipBrush(c, scene);
double len = _engine.SessionSlotLength(id, scene);
- string kind = c.IsInstrument ? "MIDI" : Loc.T("Audio");
+ string kind = c.IsInstrument ? "MIDI" : Loc.T("common.audio");
s.Children.Add(Title(brush, ClipName(c, scene), $"{c.Name} · {SceneName(scene)} · {NotaText.Label(kind)}"));
_inspPreview = new InspectorPreview(this, c, scene, brush);
@@ -237,38 +237,38 @@ public sealed partial class SessionView
bool loop = p.Loop != 0;
s.Children.Add(TwoUp(
- Field(Loc.T("Length"), FormatLength(len), NotaPalette.TextPrimary, a => Pick(a, LengthSteps, b => Math.Abs(b - len) < 1e-6,
+ Field(Loc.T("common.length"), FormatLength(len), NotaPalette.TextPrimary, a => Pick(a, LengthSteps, b => Math.Abs(b - len) < 1e-6,
b => { _engine.SetSessionSlotLength(id, scene, b); RefreshSlot(id, scene); })),
- Field(Loc.T("Loop"), loop ? "On" : Loc.T("Off · one-shot"), loop ? NotaPalette.TextPrimary : NotaPalette.Warning, _ => Set(x => { x.Loop = loop ? 0 : 1; return x; })),
- Field(Loc.T("Start"), "1.1.1", NotaPalette.TextSecondary, null),
- Field(Loc.T("Loop end"), FormatPosition(len), NotaPalette.TextSecondary, null)));
+ Field(Loc.T("common.loop"), loop ? "On" : Loc.T("session.inspector.off_one_shot"), loop ? NotaPalette.TextPrimary : NotaPalette.Warning, _ => Set(x => { x.Loop = loop ? 0 : 1; return x; })),
+ Field(Loc.T("common.start"), "1.1.1", NotaPalette.TextSecondary, null),
+ Field(Loc.T("session.inspector.loop_end"), FormatPosition(len), NotaPalette.TextSecondary, null)));
var launch = new StackPanel { Spacing = 10 };
- launch.Children.Add(SectionHead(Loc.T("Launch")));
+ launch.Children.Add(SectionHead(Loc.T("session.launch")));
var modes = Segmented(ModeLabels, Math.Clamp(p.LaunchMode, 0, 3), i => Set(x => { x.LaunchMode = i; return x; }));
- ToolTip.SetTip(modes, Loc.T("Trigger starts · Gate plays while held · Toggle starts and stops · Repeat retriggers while held"));
+ ToolTip.SetTip(modes, Loc.T("session.inspector.trigger_starts_gate_plays_while"));
launch.Children.Add(modes);
- string quant = p.QuantBeats < 0 ? Loc.T("Global") : QuantLabel(p.QuantBeats);
- var quantItems = new List<(double, string)> { (-1.0, Loc.T("Global")) };
+ string quant = p.QuantBeats < 0 ? Loc.T("session.inspector.global") : QuantLabel(p.QuantBeats);
+ var quantItems = new List<(double, string)> { (-1.0, Loc.T("session.inspector.global")) };
foreach (var q in QuantSteps) quantItems.Add(q);
- launch.Children.Add(Row(Loc.T("Quantize"), Chip(quant, false, a => Pick(a, quantItems, q => Math.Abs(q - p.QuantBeats) < 1e-6,
+ launch.Children.Add(Row(Loc.T("common.quantize"), Chip(quant, false, a => Pick(a, quantItems, q => Math.Abs(q - p.QuantBeats) < 1e-6,
q => Set(x => { x.QuantBeats = q; return x; })))));
- launch.Children.Add(Row(Loc.T("Legato"), Chip(p.Legato != 0 ? "On" : Loc.T("Off"), p.Legato != 0, _ => Set(x => { x.Legato = x.Legato != 0 ? 0 : 1; return x; }))));
+ launch.Children.Add(Row(Loc.T("session.inspector.legato"), Chip(p.Legato != 0 ? "On" : Loc.T("common.off"), p.Legato != 0, _ => Set(x => { x.Legato = x.Legato != 0 ? 0 : 1; return x; }))));
var vel = new DragNumber(p.VelocityAmount * 100, 0, 100, 0.5, "0", 10) { Width = 44, Height = 22 };
OneUndoStep(vel);
vel.ValueChanged += v => { if (_engine.TryGetSessionClipProps(id, scene, out var cur)) { cur.VelocityAmount = (float)(v / 100); _engine.SetSessionClipProps(id, scene, cur); } };
- ToolTip.SetTip(vel, Loc.T("Velocity amount: how far the launch velocity scales the clip · drag"));
- launch.Children.Add(Row(Loc.T("Velocity %"), new Border { CornerRadius = NotaRadius.Badge, BorderBrush = NotaPalette.BorderDefault, BorderThickness = new Thickness(1), Child = vel }));
+ ToolTip.SetTip(vel, Loc.T("session.inspector.velocity_amount_how_far_the"));
+ launch.Children.Add(Row(Loc.T("session.inspector.velocity"), new Border { CornerRadius = NotaRadius.Badge, BorderBrush = NotaPalette.BorderDefault, BorderThickness = new Thickness(1), Child = vel }));
s.Children.Add(launch);
// Follow actions.
bool follow = _engine.SessionFollow;
var fa = new StackPanel { Spacing = 10 };
var faHead = new Grid { ColumnDefinitions = new ColumnDefinitions("*,Auto") };
- faHead.Children.Add(SectionHead(Loc.T("Follow action")));
- if (!follow) { var off = Mono(Loc.T("Off globally"), 9, NotaPalette.TextTertiary); Grid.SetColumn(off, 1); faHead.Children.Add(off); }
+ faHead.Children.Add(SectionHead(Loc.T("session.inspector.follow_action")));
+ if (!follow) { var off = Mono(Loc.T("session.inspector.off_globally"), 9, NotaPalette.TextTertiary); Grid.SetColumn(off, 1); faHead.Children.Add(off); }
fa.Children.Add(faHead);
- string ActionLabel(int a) => Array.Find(FollowActions, x => (int)x.Action == a).Label ?? Loc.T("None");
+ string ActionLabel(int a) => Array.Find(FollowActions, x => (int)x.Action == a).Label ?? Loc.T("common.none");
Control ActionRow(string slot, int action, Action<int> setAction, Control chance)
{
var label = Mono(slot, 10, NotaPalette.TextTertiary);
@@ -302,29 +302,29 @@ public sealed partial class SessionView
chanceB.Text = $"{100 - a}";
if (_engine.TryGetSessionClipProps(id, scene, out var cur)) { cur.ChanceA = a; cur.ChanceB = 100 - a; _engine.SetSessionClipProps(id, scene, cur); }
};
- ToolTip.SetTip(chanceA, Loc.T("Chance of A in percent · B gets the rest · drag"));
+ ToolTip.SetTip(chanceA, Loc.T("session.inspector.chance_of_a_in_percent"));
fa.Children.Add(ActionRow("A", p.FollowA, a => Set(x => { x.FollowA = a; return x; }), chanceA));
fa.Children.Add(ActionRow("B", p.FollowB, a => Set(x => { x.FollowB = a; return x; }), chanceB));
if (p.FollowA == (int)SessionFollowAction.Jump || p.FollowB == (int)SessionFollowAction.Jump)
{
var scenes = new List<(int, string)>();
for (int i = 0; i < _sceneCount; i++) scenes.Add((i, SceneName(i)));
- fa.Children.Add(Row(Loc.T("Jump to"), Chip(SceneName(Math.Clamp(p.JumpScene, 0, Math.Max(0, _sceneCount - 1))), false,
+ fa.Children.Add(Row(Loc.T("session.inspector.jump_to"), Chip(SceneName(Math.Clamp(p.JumpScene, 0, Math.Max(0, _sceneCount - 1))), false,
a => Pick(a, scenes, i => i == p.JumpScene, i => Set(x => { x.JumpScene = i; return x; })))));
}
double after = p.FollowBeats > 0 ? p.FollowBeats : len;
- fa.Children.Add(Row(Loc.T("After"), Chip(FormatDuration(after), false, a => Pick(a, FollowTimes, b => Math.Abs(b - p.FollowBeats) < 1e-6,
+ fa.Children.Add(Row(Loc.T("session.inspector.after"), Chip(FormatDuration(after), false, a => Pick(a, FollowTimes, b => Math.Abs(b - p.FollowBeats) < 1e-6,
b => Set(x => { x.FollowBeats = b; return x; })))));
s.Children.Add(fa);
if (!follow) Inactive.Set(fa, true, interactive: true);
s.Children.Add(Swatches(p.Color, idx => Set(x => { x.Color = idx; return x; })));
s.Children.Add(Actions(
- (Loc.T("Duplicate"), Shortcut.Cmd('D'), () => DuplicateSelection()),
- (Loc.T("Rename"), "F2", () => RenameSelection()),
- (Loc.T("To Arrangement"), Shortcut.CmdShift('C'), () => CopySelectionToArrangement()),
- (Loc.T("Edit"), "", () => SlotEditRequested?.Invoke(id, scene)),
- (Loc.T("Delete"), Shortcut.None(KeyGlyphs.Backspace), () => DeleteSelection())));
+ (Loc.T("common.duplicate"), Shortcut.Cmd('D'), () => DuplicateSelection()),
+ (Loc.T("session.inspector.rename"), "F2", () => RenameSelection()),
+ (Loc.T("session.inspector.to_arrangement"), Shortcut.CmdShift('C'), () => CopySelectionToArrangement()),
+ (Loc.T("common.edit"), "", () => SlotEditRequested?.Invoke(id, scene)),
+ (Loc.T("common.delete"), Shortcut.None(KeyGlyphs.Backspace), () => DeleteSelection())));
}
// A drag on a number is one undo step, however many values it passes through.
@@ -354,7 +354,7 @@ public sealed partial class SessionView
int clips = 0;
foreach (var c in LaunchCols) if (SlotFilled(c.TrackId, scene)) clips++;
var color = p.Color >= 0 ? ArrangementView.TrackBrush(p.Color) : NotaPalette.BorderStrong;
- s.Children.Add(Title(color, SceneName(scene), Loc.F("SCENE {0:00} · {1}", scene + 1, Loc.Plural(clips, "{0} clip", "{0} clips"))));
+ s.Children.Add(Title(color, SceneName(scene), Loc.F("session.inspector.scene_caps", scene + 1, Loc.Plural("session.inspector.clips", clips))));
Control tempo;
if (p.Tempo > 0)
@@ -363,7 +363,7 @@ public sealed partial class SessionView
OneUndoStep(dn);
dn.ValueChanged += v => { if (_engine.TryGetSceneProps(scene, out var cur)) { cur.Tempo = v; _engine.SetSceneProps(scene, cur); } };
var clear = new Button { Classes = { "ghost" }, Width = 22, Height = 22, Padding = new Thickness(0), Content = new Glyph(GlyphKind.Close, 8), HorizontalContentAlignment = HorizontalAlignment.Center };
- ToolTip.SetTip(clear, Loc.T("Launch without a tempo change"));
+ ToolTip.SetTip(clear, Loc.T("session.inspector.launch_without_a_tempo_change"));
clear.Click += (_, _) => Set(x => { x.Tempo = 0; return x; });
var row = new DockPanel { Children = { clear, dn } };
DockPanel.SetDock(clear, Dock.Right);
@@ -372,39 +372,39 @@ public sealed partial class SessionView
Spacing = 4,
Children =
{
- new TextBlock { Text = Loc.T("Tempo"), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextTertiary },
+ new TextBlock { Text = Loc.T("session.inspector.tempo"), FontSize = 9, FontWeight = FontWeight.SemiBold, Foreground = NotaPalette.TextTertiary },
new Border { Height = NotaSize.Shell, CornerRadius = NotaRadius.Badge, Background = NotaPalette.BgSunken, BorderBrush = NotaPalette.BorderDefault, BorderThickness = new Thickness(1), Child = row },
},
};
- ToolTip.SetTip(tempo, Loc.T("Tempo set when the scene launches · drag to change"));
+ ToolTip.SetTip(tempo, Loc.T("session.inspector.tempo_set_when_the_scene"));
}
else
- tempo = Field(Loc.T("Tempo"), "—", NotaPalette.TextDisabled, _ =>
+ tempo = Field(Loc.T("session.inspector.tempo"), "—", NotaPalette.TextDisabled, _ =>
Set(x => { x.Tempo = GetTempo?.Invoke().Bpm ?? 120; return x; }));
string sig = p.SigNum > 0 && p.SigDen > 0 ? $"{p.SigNum}/{p.SigDen}" : "—";
- var sigField = Field(Loc.T("Signature"), sig, p.SigNum > 0 ? NotaPalette.TextPrimary : NotaPalette.TextDisabled, a =>
- Pick(a, Array.ConvertAll(Signatures, x => ((x.Num, x.Den), x.Num == 0 ? Loc.T("None") : $"{x.Num}/{x.Den}")),
+ var sigField = Field(Loc.T("session.inspector.signature"), sig, p.SigNum > 0 ? NotaPalette.TextPrimary : NotaPalette.TextDisabled, a =>
+ Pick(a, Array.ConvertAll(Signatures, x => ((x.Num, x.Den), x.Num == 0 ? Loc.T("common.none") : $"{x.Num}/{x.Den}")),
v => v.Num == p.SigNum && v.Den == p.SigDen, v => Set(x => { x.SigNum = v.Num; x.SigDen = v.Den; return x; })));
s.Children.Add(TwoUp(tempo, sigField));
var rows = new StackPanel { Spacing = 8 };
- string follow = p.Follow != 0 ? Loc.F("Next · {0}", FormatLength(p.FollowBeats)) : Loc.T("Off");
- var followItems = new List<(double, string)> { (0, Loc.T("Off")) };
- foreach (double bars in new[] { 1.0, 2, 4, 8, 16, 32 }) followItems.Add((bars * 4, Loc.F("Next after {0}", FormatLength(bars * 4))));
- rows.Children.Add(Row(Loc.T("Follow action"), Chip(follow, p.Follow != 0, a => Pick(a, followItems,
+ string follow = p.Follow != 0 ? Loc.F("session.inspector.next_n", FormatLength(p.FollowBeats)) : Loc.T("common.off");
+ var followItems = new List<(double, string)> { (0, Loc.T("common.off")) };
+ foreach (double bars in new[] { 1.0, 2, 4, 8, 16, 32 }) followItems.Add((bars * 4, Loc.F("session.inspector.next_after", FormatLength(bars * 4))));
+ rows.Children.Add(Row(Loc.T("session.inspector.follow_action"), Chip(follow, p.Follow != 0, a => Pick(a, followItems,
b => p.Follow == 0 ? b == 0 : Math.Abs(b - p.FollowBeats) < 1e-6,
b => Set(x => { x.Follow = b > 0 ? 1 : 0; if (b > 0) x.FollowBeats = b; return x; })))));
- rows.Children.Add(Row(Loc.T("Select next scene on launch"), Chip(_selectNextOnLaunch ? "On" : Loc.T("Off"), _selectNextOnLaunch, _ => { _selectNextOnLaunch = !_selectNextOnLaunch; RebuildInspector(); })));
+ rows.Children.Add(Row(Loc.T("session.inspector.select_next_scene_on_launch"), Chip(_selectNextOnLaunch ? "On" : Loc.T("common.off"), _selectNextOnLaunch, _ => { _selectNextOnLaunch = !_selectNextOnLaunch; RebuildInspector(); })));
s.Children.Add(rows);
s.Children.Add(Swatches(p.Color, idx => Set(x => { x.Color = idx; return x; })));
s.Children.Add(Actions(
- (Loc.T("Launch"), "", () => LaunchSceneRow(scene)),
- (Loc.T("Insert below"), Shortcut.Cmd('I'), () => InsertSceneAtSelection()),
- (Loc.T("Duplicate"), Shortcut.Cmd('D'), () => DuplicateSelection()),
- (Loc.T("Rename"), "F2", () => RenameSelection()),
- (Loc.T("To Arrangement"), Shortcut.CmdShift('C'), () => CopySelectionToArrangement()),
- (Loc.T("Delete"), Shortcut.None(KeyGlyphs.Backspace), () => DeleteSelection())));
+ (Loc.T("session.launch"), "", () => LaunchSceneRow(scene)),
+ (Loc.T("session.inspector.insert_below"), Shortcut.Cmd('I'), () => InsertSceneAtSelection()),
+ (Loc.T("common.duplicate"), Shortcut.Cmd('D'), () => DuplicateSelection()),
+ (Loc.T("session.inspector.rename"), "F2", () => RenameSelection()),
+ (Loc.T("session.inspector.to_arrangement"), Shortcut.CmdShift('C'), () => CopySelectionToArrangement()),
+ (Loc.T("common.delete"), Shortcut.None(KeyGlyphs.Backspace), () => DeleteSelection())));
}
// ---- empty slot + group slot ------------------------------------------------------------
@@ -412,21 +412,21 @@ public sealed partial class SessionView
private void BuildEmptyInspector(StackPanel s, Column c, int scene)
{
bool rec = _recTrack == c.TrackId && _recScene == scene;
- s.Children.Add(Title(NotaPalette.BorderStrong, rec ? Loc.T("Recording") : Loc.T("Empty slot"), $"{c.Name} · {SceneName(scene)}"));
+ s.Children.Add(Title(NotaPalette.BorderStrong, rec ? Loc.T("session.recording") : Loc.T("session.inspector.empty_slot"), $"{c.Name} · {SceneName(scene)}"));
bool stop = _engine.GetSessionSlotStopButton(c.TrackId, scene);
var rows = new StackPanel { Spacing = 8 };
- rows.Children.Add(Row(Loc.T("Stop button"), Chip(stop ? "On" : Loc.T("Removed"), false, _ => { _engine.SetSessionSlotStopButton(c.TrackId, scene, !stop); RefreshSlot(c.TrackId, scene); })));
+ rows.Children.Add(Row(Loc.T("session.inspector.stop_button"), Chip(stop ? "On" : Loc.T("session.inspector.removed"), false, _ => { _engine.SetSessionSlotStopButton(c.TrackId, scene, !stop); RefreshSlot(c.TrackId, scene); })));
rows.Children.Add(new TextBlock
{
- Text = stop ? Loc.F("Launching this scene stops {0}.", c.Name) : Loc.F("Launching this scene keeps {0} playing.", c.Name),
+ Text = stop ? Loc.F("session.inspector.launching_this_scene_stops", c.Name) : Loc.F("session.inspector.launching_this_scene_keeps_playing", c.Name),
FontSize = 11, LineHeight = 16, Foreground = NotaPalette.TextTertiary, TextWrapping = TextWrapping.Wrap,
});
s.Children.Add(rows);
var actions = new List<(string, string, Action)>();
- if (c.IsInstrument) actions.Add((Loc.T("Insert MIDI clip"), "", () => InsertMidiClip(c.TrackId, scene)));
- actions.Add(rec ? (Loc.T("Stop recording"), "", () => { _engine.StopSessionRecord(); Refresh(); })
- : (Loc.T("Record here"), "", () => { _engine.RecordSessionSlot(c.TrackId, scene); Refresh(); }));
- if (CanPaste) actions.Add((Loc.T("Paste"), Shortcut.Cmd('V'), () => PasteSelection()));
+ if (c.IsInstrument) actions.Add((Loc.T("session.insert_midi_clip"), "", () => InsertMidiClip(c.TrackId, scene)));
+ actions.Add(rec ? (Loc.T("session.inspector.stop_recording"), "", () => { _engine.StopSessionRecord(); Refresh(); })
+ : (Loc.T("session.record_here"), "", () => { _engine.RecordSessionSlot(c.TrackId, scene); Refresh(); }));
+ if (CanPaste) actions.Add((Loc.T("common.paste"), Shortcut.Cmd('V'), () => PasteSelection()));
s.Children.Add(Actions(actions.ToArray()));
}
@@ -437,22 +437,22 @@ public sealed partial class SessionView
s.Children.Add(new TextBlock
{
Text = c.Kind == ColKind.Master
- ? Loc.T("Every track ends up here. Its devices are in the Devices panel.")
- : Loc.T("Tracks reach it through their sends. It has no clip slots; its devices are in the Devices panel."),
+ ? Loc.T("session.inspector.every_track_ends_up_here")
+ : Loc.T("session.inspector.tracks_reach_it_through_their"),
FontSize = 11, LineHeight = 16, Foreground = NotaPalette.TextTertiary, TextWrapping = TextWrapping.Wrap,
});
}
private void BuildGroupInspector(StackPanel s, Column g, int scene)
{
- s.Children.Add(Title(g.Brush, $"{g.Name} · {SceneName(scene)}", Loc.F("GROUP SLOT · {0} TRACKS", g.Children.Count)));
+ s.Children.Add(Title(g.Brush, $"{g.Name} · {SceneName(scene)}", Loc.F("session.inspector.group_slot_tracks_caps", g.Children.Count)));
s.Children.Add(new TextBlock
{
- Text = Loc.T("Launches every track's slot in this scene. The stop button stops them all."),
+ Text = Loc.T("session.inspector.launches_every_tracks_slot_in"),
FontSize = 11, LineHeight = 16, Foreground = NotaPalette.TextTertiary, TextWrapping = TextWrapping.Wrap,
});
- s.Children.Add(Actions((Loc.T("Launch group slot"), Shortcut.None(KeyGlyphs.Return), () => LaunchGroup(g, scene)), (Loc.T("Stop group"), "", () => StopColumn(g)),
- (Loc.T("To Arrangement"), Shortcut.CmdShift('C'), () => CopySelectionToArrangement())));
+ s.Children.Add(Actions((Loc.T("session.inspector.launch_group_slot"), Shortcut.None(KeyGlyphs.Return), () => LaunchGroup(g, scene)), (Loc.T("session.inspector.stop_group"), "", () => StopColumn(g)),
+ (Loc.T("session.inspector.to_arrangement"), Shortcut.CmdShift('C'), () => CopySelectionToArrangement())));
}
/// <summary>The selected clip's notes / waveform with a live playhead.</summary>
diff --git a/src/managed/Nota.App/SessionView.Mixer.cs b/src/managed/Nota.App/SessionView.Mixer.cs
index 0871af36..8e0e9e90 100644
--- a/src/managed/Nota.App/SessionView.Mixer.cs
+++ b/src/managed/Nota.App/SessionView.Mixer.cs
@@ -59,14 +59,14 @@ public sealed partial class SessionView
};
Border Row(double h, string text) => new() { Height = h, Child = Label(text) };
if (_showIO)
- stack.Children.Add(Section(Row(IoRowH, Loc.T("Input")), Row(IoRowH, Loc.T("Monitor")), Row(IoRowH, Loc.T("Output"))));
+ stack.Children.Add(Section(Row(IoRowH, Loc.T("common.input")), Row(IoRowH, Loc.T("session.mixer.monitor")), Row(IoRowH, Loc.T("common.output"))));
if (_showSends && ReturnRows > 0)
{
- var rows = Returns().Take(ReturnRows).Select((r, i) => (Control)Row(FaderRowH, Loc.F("Send {0} · {1}", (char)('A' + i), r.Name))).ToArray();
+ var rows = Returns().Take(ReturnRows).Select((r, i) => (Control)Row(FaderRowH, Loc.F("session.mixer.send_n", (char)('A' + i), r.Name))).ToArray();
stack.Children.Add(Section(rows));
}
if (_showMixer)
- stack.Children.Add(Section(Row(FaderRowH, Loc.T("Pan")), Row(FaderRowH, Loc.T("Volume")), new Border { Height = MeterRowH }, new Border { Height = ButtonRowH }));
+ stack.Children.Add(Section(Row(FaderRowH, Loc.T("common.pan")), Row(FaderRowH, Loc.T("common.volume")), new Border { Height = MeterRowH }, new Border { Height = ButtonRowH }));
return stack;
}
@@ -124,7 +124,7 @@ public sealed partial class SessionView
var read = ReadoutText();
void Show() => read.Text = f.Value <= 0.005 ? "–" : NotaNum.Str(f.Value * 100, "0");
SendControl.Attach(f, _engine, id, bus, _ => Show()); // undoable, writes automation (specs/072)
- ValueEntry.Attach(f, f.EntryField(Loc.T("Send"), v => v <= 0.005 ? "–" : NotaNum.Str(v * 100, "0")), read);
+ ValueEntry.Attach(f, f.EntryField(Loc.T("session.mixer.send"), v => v <= 0.005 ? "–" : NotaNum.Str(v * 100, "0")), read);
Show();
sendSyncs.Add(() =>
{
@@ -153,7 +153,7 @@ public sealed partial class SessionView
pan.GestureEnd += panUndo.End;
Action<double> setPan = p => _engine.SetTrackPan(id, (float)p);
pan.PanChanged += p => panUndo.Change(p, setPan);
- ValueEntry.Attach(pan, pan.EntryField(Loc.T("Pan")));
+ ValueEntry.Attach(pan, pan.EntryField(Loc.T("common.pan")));
follow.Add(t => { if (!pan.Dragging && Math.Abs(pan.Pan - t.Pan) > 1e-3) pan.Pan = t.Pan; });
panRow = FaderRow(pan, ReadoutText());
}
@@ -172,7 +172,7 @@ public sealed partial class SessionView
else SetMasterVolume?.Invoke((float)v);
};
vol.ValueChanged += v => { volUndo.Change(v, setVol); ShowDb(); };
- ValueEntry.Attach(vol, vol.EntryField(Loc.T("Volume"), v => v <= 1e-4 ? "−∞" : NotaNum.Db(AudioMath.LinToDb(v), signed: true)), db);
+ ValueEntry.Attach(vol, vol.EntryField(Loc.T("common.volume"), v => v <= 1e-4 ? "−∞" : NotaNum.Db(AudioMath.LinToDb(v), signed: true)), db);
ShowDb();
if (hasTrack) follow.Add(t => { if (!vol.Dragging && Math.Abs(vol.Value - t.Volume) > 1e-3) { vol.Value = t.Volume; ShowDb(); } });
@@ -287,7 +287,7 @@ public sealed partial class SessionView
b.BorderBrush = on ? fill : NotaPalette.Seam;
text.Foreground = on ? NotaPalette.InkOn(fill) : NotaPalette.TextSecondary;
}
- ToolTip.SetTip(b, arm ? TrackArming.Tip : label == "M" ? Loc.T("Mute") : Loc.T("Solo"));
+ ToolTip.SetTip(b, arm ? TrackArming.Tip : label == "M" ? Loc.T("common.mute") : Loc.T("common.solo"));
b.PointerPressed += (_, e) =>
{
if (!e.GetCurrentPoint(b).Properties.IsLeftButtonPressed) return;
@@ -314,14 +314,14 @@ public sealed partial class SessionView
RecordInputPick cur;
if (c.IsInstrument)
{
- items.Add((RecordInputPick.Track(-1), Loc.T("All ins")));
+ items.Add((RecordInputPick.Track(-1), Loc.T("session.mixer.all_ins")));
foreach (var n in names.Where(n => n.Instrument)) items.Add((RecordInputPick.Track(n.Id), n.Name));
cur = RecordInputPick.Track(_engine.GetTrackMidiSource(c.TrackId));
}
else
{
foreach (var (pick, _, shortName) in RecordInputPick.Hardware) items.Add((pick, shortName));
- items.Add((RecordInputPick.Track(-1), Loc.T("Master")));
+ items.Add((RecordInputPick.Track(-1), Loc.T("common.master")));
foreach (var n in names) items.Add((RecordInputPick.Track(n.Id), n.Name));
cur = RecordInputPick.Of(_engine, c.TrackId);
}
@@ -337,7 +337,7 @@ public sealed partial class SessionView
var v = items[cb.SelectedIndex].Value;
if (inst) _engine.SetTrackMidiSource(id, v.Source); else v.ApplyTo(_engine, id);
};
- ToolTip.SetTip(cb, inst ? Loc.T("MIDI input: every input, or another instrument track") : Loc.T("Record input"));
+ ToolTip.SetTip(cb, inst ? Loc.T("session.mixer.midi_input_every_input_or") : Loc.T("common.record_input"));
return cb;
}
@@ -346,15 +346,15 @@ public sealed partial class SessionView
if (c.Kind != ColKind.Track || !c.IsAudio) return new Border { Height = IoRowH };
int id = c.TrackId;
bool on = _engine.GetTrackMonitor(id);
- var seg = Segmented(new[] { "In", Loc.T("Auto") }, on ? 0 : 1, i => _engine.SetTrackMonitor(id, i == 0), compact: true);
+ var seg = Segmented(new[] { "In", Loc.T("common.auto") }, on ? 0 : 1, i => _engine.SetTrackMonitor(id, i == 0), compact: true);
seg.Margin = new Thickness(4, 0);
- ToolTip.SetTip(seg, Loc.T("In: hear the input live through this track · Auto: only while recording"));
+ ToolTip.SetTip(seg, Loc.T("session.mixer.in_hear_the_input_live"));
return seg;
}
private Control OutputRow(Column c)
{
- string text = c.Kind == ColKind.Master ? "Ext Out 1/2" : Loc.T("Master");
+ string text = c.Kind == ColKind.Master ? "Ext Out 1/2" : Loc.T("common.master");
if (c.GroupId > 0 && ColumnFor(c.GroupId) is { } g) text = g.Name;
else if (c.GroupId > 0)
for (int i = 0; i < _engine.TrackCount; i++)
@@ -365,7 +365,7 @@ public sealed partial class SessionView
Background = NotaPalette.SurfaceCard, BorderBrush = NotaPalette.BorderDefault, BorderThickness = new Thickness(1),
Child = new TextBlock { Text = text, FontSize = 10, Foreground = NotaPalette.TextSecondary, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis },
};
- ToolTip.SetTip(b, Loc.T("Output — group a track to route it through the group"));
+ ToolTip.SetTip(b, Loc.T("session.mixer.output_group_a_track_to"));
return b;
}
diff --git a/src/managed/Nota.App/SessionView.Toolbar.cs b/src/managed/Nota.App/SessionView.Toolbar.cs
index cb34327e..7417fc0f 100644
--- a/src/managed/Nota.App/SessionView.Toolbar.cs
+++ b/src/managed/Nota.App/SessionView.Toolbar.cs
@@ -21,8 +21,8 @@ public sealed partial class SessionView
// Launch quantum steps (beats, label). 0 = launch at once.
internal static readonly (double Beats, string Label)[] QuantSteps =
{
- (0.0, Loc.T("None")), (0.25, "1/16"), (0.5, "1/8"), (1.0, "1/4"), (2.0, "1/2"),
- (4.0, Loc.T("1 Bar")), (8.0, Loc.T("2 Bars")), (16.0, Loc.T("4 Bars")), (32.0, Loc.T("8 Bars")),
+ (0.0, Loc.T("common.none")), (0.25, "1/16"), (0.5, "1/8"), (1.0, "1/4"), (2.0, "1/2"),
+ (4.0, Loc.T("session.toolbar.1_bar")), (8.0, Loc.T("session.toolbar.2_bars")), (16.0, Loc.T("session.toolbar.4_bars")), (32.0, Loc.T("session.toolbar.8_bars")),
};
private static readonly int[] FixedBars = { 0, 1, 2, 4, 8 };
@@ -44,19 +44,19 @@ public sealed partial class SessionView
private Control BuildToolbar()
{
_recDot = new Glyph(GlyphKind.Record, 8);
- _recText = new TextBlock { Text = Loc.T("Session rec"), FontSize = 11, FontWeight = FontWeight.SemiBold };
+ _recText = new TextBlock { Text = Loc.T("session.toolbar.session_rec"), FontSize = 11, FontWeight = FontWeight.SemiBold };
_recBtn = new Button
{
Height = NotaSize.Shell, Padding = new Thickness(10, 0),
Content = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 7, Children = { _recDot, _recText } },
};
- ToolTip.SetTip(_recBtn, Loc.T("Record into the armed track at the selected scene · click again to keep the take"));
+ ToolTip.SetTip(_recBtn, Loc.T("session.toolbar.record_into_the_armed_track"));
_recBtn.Click += (_, _) => SessionRec();
- var fixedLabel = Caps(Loc.T("Fixed"));
+ var fixedLabel = Caps(Loc.T("session.toolbar.fixed"));
_fixedSeg = new Border();
var fixedRow = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, VerticalAlignment = VerticalAlignment.Center, Children = { fixedLabel, _fixedSeg } };
- ToolTip.SetTip(fixedRow, Loc.T("Fixed record length in bars — the take stops by itself"));
+ ToolTip.SetTip(fixedRow, Loc.T("session.toolbar.fixed_record_length_in_bars"));
_quantLabel = new TextBlock { FontSize = 10, Foreground = NotaPalette.TextPrimary, VerticalAlignment = VerticalAlignment.Center };
_quantLabel.BindResource(TextBlock.FontFamilyProperty, "Font.Mono");
@@ -66,10 +66,10 @@ public sealed partial class SessionView
Content = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 8,
- Children = { Caps(Loc.T("Quant")), _quantLabel, new Glyph(GlyphKind.ChevronDown, 7) { Foreground = NotaPalette.TextDisabled } },
+ Children = { Caps(Loc.T("session.toolbar.quant")), _quantLabel, new Glyph(GlyphKind.ChevronDown, 7) { Foreground = NotaPalette.TextDisabled } },
},
};
- ToolTip.SetTip(quant, Loc.T("Launch quantize: when clips and scenes start"));
+ ToolTip.SetTip(quant, Loc.T("session.toolbar.launch_quantize_when_clips_and"));
quant.Click += (_, _) =>
{
var f = new MenuFlyout();
@@ -84,17 +84,17 @@ public sealed partial class SessionView
};
_followSwitch = new SwitchTrack { VerticalAlignment = VerticalAlignment.Center };
- _followText = new TextBlock { Text = Loc.T("Follow"), FontSize = 11, FontWeight = FontWeight.Medium, VerticalAlignment = VerticalAlignment.Center };
+ _followText = new TextBlock { Text = Loc.T("session.toolbar.follow"), FontSize = 11, FontWeight = FontWeight.Medium, VerticalAlignment = VerticalAlignment.Center };
var follow = new Button
{
Height = NotaSize.Shell, Padding = new Thickness(9, 0),
Content = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 7, Children = { _followSwitch, _followText } },
};
- ToolTip.SetTip(follow, Loc.T("Follow actions on or off for every clip and scene"));
+ ToolTip.SetTip(follow, Loc.T("session.toolbar.follow_actions_on_or_off"));
follow.Click += (_, _) => { _engine.SessionFollow = !_engine.SessionFollow; SyncToolbar(); RebuildInspector(); };
- var capture = new Button { Content = Loc.T("Capture scene"), Height = NotaSize.Shell, Padding = new Thickness(10, 0), FontSize = 11 };
- ToolTip.SetTip(capture, Loc.T("Copy the clips playing now into a new scene"));
+ var capture = new Button { Content = Loc.T("session.toolbar.capture_scene"), Height = NotaSize.Shell, Padding = new Thickness(10, 0), FontSize = 11 };
+ ToolTip.SetTip(capture, Loc.T("session.toolbar.copy_the_clips_playing_now"));
capture.Click += (_, _) => CaptureScene();
// Section toggles: each shows or hides one mixer section under the grid.
@@ -107,8 +107,8 @@ public sealed partial class SessionView
sections.Children.Add(tb);
}
Section("I/O", () => _showIO, v => _showIO = v);
- Section(Loc.T("Sends"), () => _showSends, v => _showSends = v);
- Section(Loc.T("Mixer"), () => _showMixer, v => _showMixer = v);
+ Section(Loc.T("common.sends"), () => _showSends, v => _showSends = v);
+ Section(Loc.T("common.mixer"), () => _showMixer, v => _showMixer = v);
var sectionsWell = new Border { Classes = { "segmented" }, Padding = new Thickness(2), Child = sections };
_posText = new TextBlock { FontSize = 12, Foreground = NotaPalette.TextPrimary, MinWidth = 56, VerticalAlignment = VerticalAlignment.Center };
@@ -117,8 +117,8 @@ public sealed partial class SessionView
_tempoText.BindResource(TextBlock.FontFamilyProperty, "Font.Mono");
var readout = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Margin = new Thickness(8, 0), Children = { _posText, _tempoText } };
- _backBtn = new Button { Content = Loc.T("Back to Arrangement"), Height = NotaSize.Shell, Padding = new Thickness(10, 0), FontSize = 11 };
- ToolTip.SetTip(_backBtn, Loc.T("Stop session clips and hand every track back to the Arrangement"));
+ _backBtn = new Button { Content = Loc.T("session.toolbar.back_to_arrangement"), Height = NotaSize.Shell, Padding = new Thickness(10, 0), FontSize = 11 };
+ ToolTip.SetTip(_backBtn, Loc.T("session.toolbar.stop_session_clips_and_hand"));
_backBtn.Click += (_, _) => { _engine.BackToArrangement(); UpdateStates(); };
var stopAll = new Button
@@ -127,10 +127,10 @@ public sealed partial class SessionView
Content = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 7,
- Children = { new Glyph(GlyphKind.Stop, 7), new TextBlock { Text = Loc.T("Stop all"), FontSize = 11, FontWeight = FontWeight.SemiBold } },
+ Children = { new Glyph(GlyphKind.Stop, 7), new TextBlock { Text = Loc.T("session.toolbar.stop_all"), FontSize = 11, FontWeight = FontWeight.SemiBold } },
},
};
- ToolTip.SetTip(stopAll, Loc.T("Stop every session clip"));
+ ToolTip.SetTip(stopAll, Loc.T("session.stop_every_session_clip"));
stopAll.Click += (_, _) => { _engine.StopAllSession(); UpdateStates(); };
// The inspector column can be folded away to give the grid its width back (critique F2).
@@ -139,8 +139,8 @@ public sealed partial class SessionView
Content = new Glyph(GlyphKind.Sidebar, 16), Width = NotaSize.Shell + 6, Height = NotaSize.Shell, Padding = new Thickness(0),
HorizontalContentAlignment = HorizontalAlignment.Center, VerticalContentAlignment = VerticalAlignment.Center, IsChecked = InspectorOpen,
};
- ToolTip.SetTip(_inspectorToggle, Loc.T("Inspector — show or hide it"));
- Avalonia.Automation.AutomationProperties.SetName(_inspectorToggle, Loc.T("Inspector"));
+ ToolTip.SetTip(_inspectorToggle, Loc.T("session.toolbar.inspector_show_or_hide_it"));
+ Avalonia.Automation.AutomationProperties.SetName(_inspectorToggle, Loc.T("session.toolbar.inspector"));
_inspectorToggle.Click += (_, _) => SetInspectorOpen(_inspectorToggle.IsChecked == true);
// Overflow: when the bar is too narrow, the least-used controls fold into "⋯" one by one
@@ -148,20 +148,20 @@ public sealed partial class SessionView
// Every control stays reachable — the menu offers whatever is hidden.
const double MoreW = 32;
var more = new Button { Content = "⋯", Width = MoreW, Height = NotaSize.Shell, Padding = new Thickness(0), FontSize = 12, HorizontalContentAlignment = HorizontalAlignment.Center, IsVisible = false };
- ToolTip.SetTip(more, Loc.T("More session controls"));
+ ToolTip.SetTip(more, Loc.T("session.toolbar.more_session_controls"));
more.Click += (_, _) =>
{
var f = new MenuFlyout();
void Add(string header, Action act) { var mi = new MenuItem { Header = header }; mi.Click += (_, _) => act(); f.Items.Add(mi); }
- if (!_backBtn!.IsVisible) Add(Loc.T("Back to Arrangement"), () => { _engine.BackToArrangement(); UpdateStates(); });
- if (!capture.IsVisible) Add(Loc.T("Capture scene"), CaptureScene);
+ if (!_backBtn!.IsVisible) Add(Loc.T("session.toolbar.back_to_arrangement"), () => { _engine.BackToArrangement(); UpdateStates(); });
+ if (!capture.IsVisible) Add(Loc.T("session.toolbar.capture_scene"), CaptureScene);
if (!sectionsWell.IsVisible)
{
- Add((_showIO ? Loc.T("Hide") : Loc.T("Show")) + " I/O", () => { _showIO = !_showIO; Refresh(); });
- Add((_showSends ? Loc.T("Hide") : Loc.T("Show")) + " sends", () => { _showSends = !_showSends; Refresh(); });
- Add((_showMixer ? Loc.T("Hide") : Loc.T("Show")) + " mixer", () => { _showMixer = !_showMixer; Refresh(); });
+ Add((_showIO ? Loc.T("session.toolbar.hide") : Loc.T("common.show")) + " I/O", () => { _showIO = !_showIO; Refresh(); });
+ Add((_showSends ? Loc.T("session.toolbar.hide") : Loc.T("common.show")) + " sends", () => { _showSends = !_showSends; Refresh(); });
+ Add((_showMixer ? Loc.T("session.toolbar.hide") : Loc.T("common.show")) + " mixer", () => { _showMixer = !_showMixer; Refresh(); });
}
- if (!follow.IsVisible) Add(_engine.SessionFollow ? Loc.T("Turn follow off") : Loc.T("Turn follow on"), () => { _engine.SessionFollow = !_engine.SessionFollow; SyncToolbar(); RebuildInspector(); });
+ if (!follow.IsVisible) Add(_engine.SessionFollow ? Loc.T("session.toolbar.turn_follow_off") : Loc.T("session.toolbar.turn_follow_on"), () => { _engine.SessionFollow = !_engine.SessionFollow; SyncToolbar(); RebuildInspector(); });
f.ShowAt(more);
};
@@ -210,7 +210,7 @@ public sealed partial class SessionView
if (_engine.TryGetSessionRecordTarget(out _, out _, out _)) { _engine.StopSessionRecord(); Refresh(); return; }
int scene = _sel.Scene;
int id = _engine.RecordSessionScene(scene);
- if (id == 0) { Say(Loc.T("Arm a track with an empty slot in this scene to record.")); return; }
+ if (id == 0) { Say(Loc.T("session.toolbar.arm_a_track_with_an")); return; }
Refresh();
}
@@ -218,7 +218,7 @@ public sealed partial class SessionView
public void SyncToolbar()
{
double q = _engine.LaunchQuant;
- string ql = q > 0 ? NotaNum.Str(q, "0.##") + " beats" : Loc.T("None");
+ string ql = q > 0 ? NotaNum.Str(q, "0.##") + " beats" : Loc.T("common.none");
foreach (var (beats, label) in QuantSteps) if (Math.Abs(beats - q) < 1e-6) ql = label;
if (_quantLabel is not null) _quantLabel.Text = ql;
@@ -230,7 +230,7 @@ public sealed partial class SessionView
{
double len = _engine.SessionRecordLength;
int sel = Array.FindIndex(FixedBars, b => Math.Abs(b * 4 - len) < 1e-6);
- var seg = Segmented(Array.ConvertAll(FixedBars, b => b == 0 ? Loc.T("Off") : b.ToString(NotaNum.Culture)), sel < 0 ? 0 : sel,
+ var seg = Segmented(Array.ConvertAll(FixedBars, b => b == 0 ? Loc.T("common.off") : b.ToString(NotaNum.Culture)), sel < 0 ? 0 : sel,
i => _engine.SessionRecordLength = FixedBars[i] * 4.0, mono: true);
_fixedSeg.Child = seg;
}
diff --git a/src/managed/Nota.App/SessionView.cs b/src/managed/Nota.App/SessionView.cs
index 978f5aee..fe712163 100644
--- a/src/managed/Nota.App/SessionView.cs
+++ b/src/managed/Nota.App/SessionView.cs
@@ -295,14 +295,14 @@ public sealed partial class SessionView : UserControl
{
col.Kind = ColKind.Group;
col.Children = infos.Where(c => !c.IsGroup && !c.IsReturn && Under(c, ti.Id)).Select(c => c.Id).ToList();
- col.KindLabel = Loc.F("Group · {0}{1}", col.Children.Count, Parent(ti));
+ col.KindLabel = Loc.F("session.group", col.Children.Count, Parent(ti));
}
else
{
col.Kind = ColKind.Track;
col.IsInstrument = ti.IsInstrument;
col.IsAudio = ti.Type == 0;
- col.KindLabel = (ti.IsInstrument ? "MIDI" : Loc.T("Audio")) + Parent(ti);
+ col.KindLabel = (ti.IsInstrument ? "MIDI" : Loc.T("common.audio")) + Parent(ti);
}
_cols.Add(col);
}
@@ -311,11 +311,11 @@ public sealed partial class SessionView : UserControl
{
_cols.Add(new Column
{
- Kind = ColKind.Return, TrackId = ti.Id, Name = TrackNames.Of(_engine, ti), KindLabel = Loc.T("Return"),
+ Kind = ColKind.Return, TrackId = ti.Id, Name = TrackNames.Of(_engine, ti), KindLabel = Loc.T("common.return"),
ColorIndex = ArrangementView.ReturnColorIndex(r++), Width = ReturnColW,
});
}
- _cols.Add(new Column { Kind = ColKind.Master, TrackId = 0, Name = Loc.T("Master"), KindLabel = "Out 1/2", ColorIndex = -1, Width = MasterColW });
+ _cols.Add(new Column { Kind = ColKind.Master, TrackId = 0, Name = Loc.T("common.master"), KindLabel = "Out 1/2", ColorIndex = -1, Width = MasterColW });
}
// ---- live state ---------------------------------------------------------------
@@ -463,7 +463,7 @@ public sealed partial class SessionView : UserControl
if (_sel.Kind == SelKind.Bus) return true; // a Return / Master has no clip to act on; keep it from reaching the Arrangement
if (_sel.Kind != SelKind.Slot || !SlotFilled(_sel.TrackId, _sel.Scene)) return false;
ClipTransfer.TookSlot(_sel.TrackId, _sel.Scene, cut: false);
- Say(Loc.T("Copied clip"));
+ Say(Loc.T("session.copied_clip"));
return true;
}
@@ -473,7 +473,7 @@ public sealed partial class SessionView : UserControl
if (_sel.Kind == SelKind.Bus) return true; // a Return / Master has no clip to act on; keep it from reaching the Arrangement
if (_sel.Kind != SelKind.Slot || !SlotFilled(_sel.TrackId, _sel.Scene)) return false;
ClipTransfer.TookSlot(_sel.TrackId, _sel.Scene, cut: true);
- Say(Loc.T("Cut clip — paste to move it"));
+ Say(Loc.T("session.cut_clip_paste_to_move"));
return true;
}
@@ -490,11 +490,11 @@ public sealed partial class SessionView : UserControl
bool move = src.Cut && (src.TrackId, src.Scene) != (_sel.TrackId, _sel.Scene);
if (!MoveOrCopySlot(src.TrackId, src.Scene, _sel.TrackId, _sel.Scene, move))
{
- Say(Loc.T("Paste a MIDI clip onto a MIDI track, audio onto audio."));
+ Say(Loc.T("session.paste_a_midi_clip_onto"));
return true;
}
if (move) ClipTransfer.SlotMoved((_sel.TrackId, _sel.Scene));
- Say(move ? Loc.T("Moved clip") : Loc.T("Pasted clip"));
+ Say(move ? Loc.T("session.moved_clip") : Loc.T("session.pasted_clip"));
return true;
}
@@ -508,12 +508,12 @@ public sealed partial class SessionView : UserControl
int first = _engine.PasteClipBlockToSession(dest, _sel.Scene);
if (first < 0)
{
- Say(Loc.T("Paste a MIDI clip onto a MIDI track, audio onto audio."));
+ Say(Loc.T("session.paste_a_midi_clip_onto"));
return true;
}
Refresh(); // the paste may have added scene rows
if (dest > 0) Select(new Selection(SelKind.Slot, dest, first));
- Say(n == 1 ? Loc.T("Pasted clip from the arrangement") : Loc.F("Pasted {0} clips from the arrangement", n));
+ Say(n == 1 ? Loc.T("session.pasted_clip_from_the_arrangement") : Loc.F("session.pasted_clips_from_the_arrangement", n));
return true;
}
// Copy a slot onto another (same track kind), and for a move clear the source — one undo
@@ -559,15 +559,15 @@ public sealed partial class SessionView : UserControl
if (s < 0) return false;
Refresh();
Select(new Selection(SelKind.Scene, 0, s));
- Say(Loc.T("Duplicated scene"));
+ Say(Loc.T("session.duplicated_scene"));
return true;
}
int below = _sel.Scene + 1;
if (_sel.Kind != SelKind.Slot || !SlotFilled(_sel.TrackId, _sel.Scene)) return false;
- if (below >= _sceneCount || SlotFilled(_sel.TrackId, below)) { Say(Loc.T("The slot below is taken.")); return true; }
+ if (below >= _sceneCount || SlotFilled(_sel.TrackId, below)) { Say(Loc.T("session.the_slot_below_is_taken")); return true; }
MoveOrCopySlot(_sel.TrackId, _sel.Scene, _sel.TrackId, below, move: false);
Select(_sel with { Scene = below });
- Say(Loc.T("Duplicated clip"));
+ Say(Loc.T("session.duplicated_clip"));
return true;
}
@@ -579,12 +579,12 @@ public sealed partial class SessionView : UserControl
{
if (!_engine.RemoveScene(_sel.Scene)) return false;
Refresh();
- Say(Loc.T("Deleted scene"));
+ Say(Loc.T("session.deleted_scene"));
return true;
}
if (_sel.Kind != SelKind.Slot || !_engine.ClearSessionSlot(_sel.TrackId, _sel.Scene)) return false;
RefreshSlot(_sel.TrackId, _sel.Scene);
- Say(Loc.T("Deleted clip"));
+ Say(Loc.T("session.deleted_clip"));
return true;
}
@@ -595,7 +595,7 @@ public sealed partial class SessionView : UserControl
if (s < 0) return false;
Refresh();
Select(new Selection(SelKind.Scene, 0, s));
- Say(Loc.T("Inserted scene"));
+ Say(Loc.T("session.inserted_scene"));
return true;
}
@@ -603,10 +603,10 @@ public sealed partial class SessionView : UserControl
{
int s = _engine.CaptureScene(Math.Min(_sel.Scene + 1, _sceneCount));
if (s < 0) return;
- if (string.IsNullOrEmpty(_engine.GetSceneName(s))) _engine.SetSceneName(s, Loc.T("Captured"));
+ if (string.IsNullOrEmpty(_engine.GetSceneName(s))) _engine.SetSceneName(s, Loc.T("session.captured"));
Refresh();
Select(new Selection(SelKind.Scene, 0, s));
- Say(Loc.T("Captured the playing clips into a new scene"));
+ Say(Loc.T("session.captured_the_playing_clips_into"));
}
// The filled slots a selection covers: a track's slot, a group's slots in that scene, or a
@@ -628,8 +628,8 @@ public sealed partial class SessionView : UserControl
int placed = _engine.SessionSlotsToArrangement(slots, _engine.PositionBeats);
if (placed <= 0) return false;
ArrangementChanged?.Invoke();
- Say(placed == 1 ? Loc.T("Copied clip to the arrangement at the playhead")
- : Loc.F("Copied {0} clips to the arrangement at the playhead", placed));
+ Say(placed == 1 ? Loc.T("session.copied_clip_to_the_arrangement")
+ : Loc.F("session.copied_clips_to_the_arrangement", placed));
return true;
}
@@ -721,16 +721,16 @@ public sealed partial class SessionView : UserControl
private string SceneName(int scene)
{
string n = _engine.GetSceneName(scene);
- return n.Length > 0 ? n : Loc.F("Scene {0}", scene + 1);
+ return n.Length > 0 ? n : Loc.F("session.scene", scene + 1);
}
/// <summary>"2 bars", "3 beats", "2.2 bars" — a clip length as the grid shows it.</summary>
internal static string FormatLength(double beats)
{
if (beats <= 0) return "";
- if (Math.Abs(beats % 4) < 1e-6) { int n = (int)Math.Round(beats / 4); return Loc.Plural(n, "{0} bar", "{0} bars"); }
+ if (Math.Abs(beats % 4) < 1e-6) { int n = (int)Math.Round(beats / 4); return Loc.Plural("session.bars", n); }
if (beats < 4) return NotaNum.Str(beats, "0.##") + (Math.Abs(beats - 1) < 1e-6 ? " beat" : " beats");
- return Loc.F("{0}.{1} bars", (int)(beats / 4), NotaNum.Str(beats % 4, "0.##"));
+ return Loc.F("session.bars_n", (int)(beats / 4), NotaNum.Str(beats % 4, "0.##"));
}
/// <summary>bars.beats.sixteenths, 1-based, the way positions read in the transport.</summary>
diff --git a/src/managed/Nota.App/SnapChip.cs b/src/managed/Nota.App/SnapChip.cs
index 8e016607..19f93a4c 100644
--- a/src/managed/Nota.App/SnapChip.cs
+++ b/src/managed/Nota.App/SnapChip.cs
@@ -21,7 +21,7 @@ namespace Nota.App;
internal sealed class SnapChip
{
- private static string Shortcuts => Loc.T("⌘1 ⌘2 narrow / widen · ⌘3 triplets · ⌘4 snap · ⌘5 auto");
+ private static string Shortcuts => Loc.T("snap_chip.1_2_narrow_widen_3");
private readonly Button _button;
private readonly TextBlock _value;
@@ -81,7 +81,7 @@ internal sealed class SnapChip
foreach (bool t in new[] { false, true })
{
string label = GridStep.Of(i, t).Label;
- if (_caption is null) label = Loc.F("Auto · {0}", label);
+ if (_caption is null) label = Loc.F("snap_chip.auto", label);
var ft = new FormattedText(label, NotaNum.Culture,
FlowDirection.LeftToRight, face, _value.FontSize, null);
widest = Math.Max(widest, ft.WidthIncludingTrailingWhitespace);
@@ -100,16 +100,16 @@ internal sealed class SnapChip
_shown = key;
_value.Text = text;
- if (_caption is not null) _caption.Text = s.Adaptive ? Loc.T("Auto grid") : Loc.T("Grid");
+ if (_caption is not null) _caption.Text = s.Adaptive ? Loc.T("snap_chip.auto_grid") : Loc.T("common.grid");
_value.TextDecorations = r.SnapOn ? null : TextDecorations.Strikethrough;
_value.Foreground = !r.SnapOn ? NotaPalette.TextDisabled
: r.FinerThanVisible ? NotaPalette.TextSecondary
: NotaPalette.TextPrimary;
- string tip = !r.SnapOn ? Loc.T("Snap off — items move freely (⌘4)")
- : r.FinerThanVisible ? Loc.F("{0} — finer than the visible grid · zoom in to see it", r.Snap.Label)
- : s.Adaptive ? Loc.F("Snap grid · Auto follows the zoom ({0})", s.Density)
- : Loc.F("Snap grid · fixed {0}", r.Snap.Label);
- ToolTip.SetTip(_button, MenuKit.Keys(Loc.F("{0}\n{1} · hold ⌥ to drag freely", tip, Shortcuts)));
+ string tip = !r.SnapOn ? Loc.T("snap_chip.snap_off_items_move_freely")
+ : r.FinerThanVisible ? Loc.F("snap_chip.finer_than_the_visible_grid", r.Snap.Label)
+ : s.Adaptive ? Loc.F("snap_chip.snap_grid_auto_follows_the", s.Density)
+ : Loc.F("snap_chip.snap_grid_fixed", r.Snap.Label);
+ ToolTip.SetTip(_button, MenuKit.Keys(Loc.F("snap_chip.hold_to_drag_freely", tip, Shortcuts)));
}
private void OpenMenu()
@@ -125,7 +125,7 @@ internal sealed class SnapChip
}
foreach (var d in new[] { GridDensity.Narrow, GridDensity.Medium, GridDensity.Wide })
- Item(Loc.F("Auto · {0}", d), s.Adaptive && s.Density == d, g => SnapGrid.PickAdaptive(g, d));
+ Item(Loc.F("snap_chip.auto", d), s.Adaptive && s.Density == d, g => SnapGrid.PickAdaptive(g, d));
f.Items.Add(new Separator());
for (int i = 0; i < GridStep.Count; i++)
{
@@ -133,8 +133,8 @@ internal sealed class SnapChip
Item(GridStep.Of(i, s.Triplets).Label, !s.Adaptive && s.FixedIndex == i, g => SnapGrid.PickFixed(g, idx));
}
f.Items.Add(new Separator());
- Item(Loc.T("Triplets"), s.Triplets, SnapGrid.ToggleTriplets, MenuKit.Cmd(Key.D3));
- Item(Loc.T("Snap to grid"), s.SnapOn, SnapGrid.ToggleSnap, MenuKit.Cmd(Key.D4));
+ Item(Loc.T("snap_chip.triplets"), s.Triplets, SnapGrid.ToggleTriplets, MenuKit.Cmd(Key.D3));
+ Item(Loc.T("snap_chip.snap_to_grid"), s.SnapOn, SnapGrid.ToggleSnap, MenuKit.Cmd(Key.D4));
f.ShowAt(_button);
}
}
diff --git a/src/managed/Nota.App/SplashWindow.cs b/src/managed/Nota.App/SplashWindow.cs
index dfaed890..050bccd5 100644
--- a/src/managed/Nota.App/SplashWindow.cs
+++ b/src/managed/Nota.App/SplashWindow.cs
@@ -51,14 +51,14 @@ public sealed class SplashWindow : Window
var words = new StackPanel { Spacing = 4, VerticalAlignment = VerticalAlignment.Center };
words.Children.Add(new TextBlock
{
- Text = Loc.T("Nota"),
+ Text = Loc.T("common.nota"),
FontSize = 24,
FontWeight = FontWeight.SemiBold,
Foreground = NotaPalette.TextPrimary,
});
words.Children.Add(new TextBlock
{
- Text = Loc.F("Version {0}", AppInfo.Version),
+ Text = Loc.F("common.version", AppInfo.Version),
FontSize = 12,
Foreground = NotaPalette.TextTertiary,
});
@@ -113,7 +113,7 @@ public sealed class SplashWindow : Window
stack.Children.Add(logo);
stack.Children.Add(new TextBlock
{
- Text = Loc.T("Nota"),
+ Text = Loc.T("common.nota"),
FontSize = 30,
FontWeight = FontWeight.SemiBold,
Foreground = NotaPalette.TextPrimary,
@@ -121,7 +121,7 @@ public sealed class SplashWindow : Window
});
stack.Children.Add(new TextBlock
{
- Text = Loc.F("Version {0}", AppInfo.Version),
+ Text = Loc.F("common.version", AppInfo.Version),
FontSize = 12,
Foreground = NotaPalette.TextTertiary,
HorizontalAlignment = HorizontalAlignment.Center,
diff --git a/src/managed/Nota.App/StereoMapView.cs b/src/managed/Nota.App/StereoMapView.cs
index 72d01464..ad5f347c 100644
--- a/src/managed/Nota.App/StereoMapView.cs
+++ b/src/managed/Nota.App/StereoMapView.cs
@@ -107,10 +107,10 @@ public sealed class StereoMapView : Control, IValueEntryHost
() => { g = new MixGesture(_engine, target); g.Begin(); _engine.BeginAutomationWrite(id, auto, -1, -1, ""); },
() => { _engine.EndAutomationWrite(id, auto, -1, -1, ""); g?.End(); g = null; }) { After = InvalidateVisual };
}
- var pan = One(Loc.T("Pan"), MixTarget.Pan(id), AutomationTarget.Pan, () => ((Of()?.Pan ?? 0f) + 1) / 2, n => NotaNum.Pan(n * 2 - 1),
+ var pan = One(Loc.T("common.pan"), MixTarget.Pan(id), AutomationTarget.Pan, () => ((Of()?.Pan ?? 0f) + 1) / 2, n => NotaNum.Pan(n * 2 - 1),
n => _engine.SetTrackPan(id, (float)Math.Clamp(n * 2 - 1, -1, 1)))
with { Reset = () => _engine.SetTrackPan(id, 0f) }; // double-click centres the pan, as before
- var vol = One(Loc.T("Volume"), MixTarget.Volume(id), AutomationTarget.Volume, () => FaderScale.Frac(Of()?.Volume ?? 1f),
+ var vol = One(Loc.T("common.volume"), MixTarget.Volume(id), AutomationTarget.Volume, () => FaderScale.Frac(Of()?.Volume ?? 1f),
n => NotaNum.GainDb(FaderScale.Gain(n), signed: true), n => _engine.SetTrackVolume(id, (float)FaderScale.Gain(n)))
with { Default = FaderScale.Frac(1.0), ResetOnDoubleClick = false }; // 0 dB from the menu; a double-click centres the pan
_entry = (id, [pan, vol]);
@@ -184,7 +184,7 @@ public sealed class StereoMapView : Control, IValueEntryHost
int masterId = _engine.MasterTrackId;
var master = new Item
{
- Id = masterId, Name = _engine.GetTrackName(masterId) is { Length: > 0 } mn ? mn : Loc.T("Master"),
+ Id = masterId, Name = _engine.GetTrackName(masterId) is { Length: > 0 } mn ? mn : Loc.T("common.master"),
Color = NotaPalette.Accent, Pan = 0, Volume = _engine.MasterVolume, Master = true,
};
if (_measureAt.TryGetValue(masterId, out int mm)) { master.M = _measures[mm]; master.Has = true; }
@@ -229,7 +229,7 @@ public sealed class StereoMapView : Control, IValueEntryHost
// Panel, header, well.
ctx.DrawRectangle(NotaPalette.SurfaceCard, new Pen(NotaPalette.BorderDefault, 1), new Rect(0.5, 0.5, b.Width - 1, b.Height - 1), Radius, Radius);
ctx.DrawLine(new Pen(NotaPalette.BorderDefault, 1), new Point(0, HeaderH), new Point(b.Width, HeaderH));
- DrawText(ctx, Loc.T("Stereo map"), NotaFonts.SansBold, 10, NotaPalette.TextPrimary, new Point(12, HeaderH / 2), vCenter: true);
+ DrawText(ctx, Loc.T("common.stereo_map"), NotaFonts.SansBold, 10, NotaPalette.TextPrimary, new Point(12, HeaderH / 2), vCenter: true);
var well = new Rect(Inset, HeaderH + Inset, b.Width - 2 * Inset, b.Height - HeaderH - BottomH - 2 * Inset);
ctx.DrawRectangle(NotaPalette.BgSunken, new Pen(NotaPalette.BorderDefault, 1), well, 4, 4);
DrawGrid(ctx, plot);
@@ -322,7 +322,7 @@ public sealed class StereoMapView : Control, IValueEntryHost
double y0 = b.Height - BottomH, cy = y0 + BottomH / 2;
ctx.DrawLine(new Pen(NotaPalette.BorderDefault, 1), new Point(0, y0), new Point(b.Width, y0));
double x = 10;
- x += DrawText(ctx, Loc.T("Correlation"), NotaFonts.SansBold, 8, NotaPalette.TextTertiary, new Point(x, cy), vCenter: true) + 10;
+ x += DrawText(ctx, Loc.T("stereo_map.correlation"), NotaFonts.SansBold, 8, NotaPalette.TextTertiary, new Point(x, cy), vCenter: true) + 10;
x += DrawText(ctx, "−1", NotaFonts.Mono, 8, NotaPalette.TextTertiary, new Point(x, cy), vCenter: true) + 6;
var bar = new Rect(x, cy - 3, 180, 6);
ctx.DrawRectangle(NotaPalette.BgSunken, new Pen(NotaPalette.BorderDefault, 1), bar, 2, 2);
@@ -336,7 +336,7 @@ public sealed class StereoMapView : Control, IValueEntryHost
x = bar.Right + 6;
x += DrawText(ctx, "+1", NotaFonts.Mono, 8, NotaPalette.TextTertiary, new Point(x, cy), vCenter: true) + 10;
DrawText(ctx, Signed(corr, 2), NotaFonts.Mono, 10, corr < PhaseAlarm ? NotaPalette.Danger : NotaPalette.TextSecondary, new Point(x, cy), vCenter: true);
- DrawText(ctx, MenuKit.Keys(Loc.T("Drag: pan + volume · Shift locks axis · double-click centres pan · ⌥-click types")),
+ DrawText(ctx, MenuKit.Keys(Loc.T("stereo_map.drag_pan_volume_shift_locks")),
NotaFonts.Sans, 10, NotaPalette.TextTertiary, new Point(b.Width - 10, cy), vCenter: true, rightAlign: true);
}
@@ -348,21 +348,21 @@ public sealed class StereoMapView : Control, IValueEntryHost
var it = _items[idx];
var rows = new List<(string k, string v, IBrush ink)>
{
- (Loc.T("Pan"), it.Master ? "—" : PanText(it.Pan), NotaPalette.TextPrimary),
- (Loc.T("Volume"), DbText(it.Volume), NotaPalette.TextPrimary),
+ (Loc.T("common.pan"), it.Master ? "—" : PanText(it.Pan), NotaPalette.TextPrimary),
+ (Loc.T("common.volume"), DbText(it.Volume), NotaPalette.TextPrimary),
};
if (it.Has)
{
- rows.Add((Loc.T("Balance"), Signed(it.M.Balance, 2), NotaPalette.TextSecondary));
- rows.Add((Loc.T("Width"), it.M.Width.ToString("0.00", NotaNum.Culture), NotaPalette.TextSecondary));
- rows.Add((Loc.T("Correlation"), Signed(it.M.Correlation, 2), it.M.Correlation < PhaseAlarm ? NotaPalette.Danger : NotaPalette.TextSecondary));
- rows.Add((Loc.T("Level"), it.M.Silent ? "below −60 dBFS" : Signed(it.M.LevelDb, 1) + NotaNum.Thin + "dBFS", NotaPalette.TextSecondary));
+ rows.Add((Loc.T("stereo_map.balance"), Signed(it.M.Balance, 2), NotaPalette.TextSecondary));
+ rows.Add((Loc.T("stereo_map.width"), it.M.Width.ToString("0.00", NotaNum.Culture), NotaPalette.TextSecondary));
+ rows.Add((Loc.T("stereo_map.correlation"), Signed(it.M.Correlation, 2), it.M.Correlation < PhaseAlarm ? NotaPalette.Danger : NotaPalette.TextSecondary));
+ rows.Add((Loc.T("stereo_map.level"), it.M.Silent ? "below −60 dBFS" : Signed(it.M.LevelDb, 1) + NotaNum.Thin + "dBFS", NotaPalette.TextSecondary));
}
var notes = new List<(string title, string body, IBrush ink)>();
if (it.Has && !it.M.Silent && !it.Muted && !it.Master && Math.Abs(it.M.Balance - it.Pan) > OffPanNote)
- notes.Add((Loc.T("Image is off the pan"), Loc.F("The pan is at {0}, but the signal measures {1}. The source itself is unbalanced.", PanText(it.Pan), PanText(it.M.Balance)), NotaPalette.Accent));
- if (it.Muted) notes.Add((Loc.T("Muted"), Loc.T("No cloud while the track is muted."), NotaPalette.TextSecondary));
- else if (!it.Has || it.M.Silent) notes.Add((Loc.T("Silent"), Loc.T("Below −60 dBFS, so the cloud is hidden."), NotaPalette.TextSecondary));
+ notes.Add((Loc.T("stereo_map.image_is_off_the_pan"), Loc.F("stereo_map.the_pan_is_at_but", PanText(it.Pan), PanText(it.M.Balance)), NotaPalette.Accent));
+ if (it.Muted) notes.Add((Loc.T("stereo_map.muted"), Loc.T("stereo_map.no_cloud_while_the_track"), NotaPalette.TextSecondary));
+ else if (!it.Has || it.M.Silent) notes.Add((Loc.T("stereo_map.silent"), Loc.T("stereo_map.below_60_dbfs_so_the"), NotaPalette.TextSecondary));
_tooltipRows.Clear();
foreach (var (k, v, _) in rows) _tooltipRows.Add((k, v));
diff --git a/src/managed/Nota.App/TExtension.cs b/src/managed/Nota.App/TExtension.cs
index 9200587c..7797a200 100644
--- a/src/managed/Nota.App/TExtension.cs
+++ b/src/managed/Nota.App/TExtension.cs
@@ -1,10 +1,11 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
-// Loc.T for XAML (spec 068): Header="{app:T 'Save as…'}". The English text is the key, as in
-// code; a text the language lacks stays English. Windows load their XAML after the language is
-// installed, so this is right for everything under a Window. App.axaml loads earlier, in
-// Initialize(), so its few texts are set from code in App.InstallLanguage instead.
+// Loc.T for XAML (spec 068, keyed since spec 077): Header="{app:T 'main.save_as'}". The argument
+// is a key of the English reference, as in code; a text the language lacks stays English.
+// Windows load their XAML after the language is installed, so this is right for everything under
+// a Window. App.axaml loads earlier, in Initialize(), so its few texts are set from code in
+// App.TranslateAppMenu instead.
using System;
using Avalonia.Markup.Xaml;
@@ -14,13 +15,10 @@ namespace Nota.App;
public sealed class TExtension : MarkupExtension
{
- public TExtension(string text) => Text = text;
+ public TExtension(string key) => Key = key;
- /// <summary>The English text, which is also the lookup key.</summary>
- public string Text { get; }
+ /// <summary>The key of the text in the English reference (en.json).</summary>
+ public string Key { get; }
- /// <summary>Separates two meanings of the same English word (see Loc.T).</summary>
- public string? Context { get; set; }
-
- public override object ProvideValue(IServiceProvider serviceProvider) => Loc.T(Text, Context);
+ public override object ProvideValue(IServiceProvider serviceProvider) => Loc.T(Key);
}
diff --git a/src/managed/Nota.App/TagEditorWindow.cs b/src/managed/Nota.App/TagEditorWindow.cs
index 2feadc3b..487be827 100644
--- a/src/managed/Nota.App/TagEditorWindow.cs
+++ b/src/managed/Nota.App/TagEditorWindow.cs
@@ -38,7 +38,7 @@ public sealed class TagEditorWindow : NotaWindow
_lib = library;
_assignKey = assignToKey;
- Title = Loc.T("Edit tags");
+ Title = Loc.T("tag_editor.edit_tags");
Width = 440;
SizeToContent = SizeToContent.Height;
CanResize = false;
@@ -47,10 +47,10 @@ public sealed class TagEditorWindow : NotaWindow
_rows = new StackPanel { Spacing = 8 };
- var add = new Button { Content = Loc.T("Add tag"), Classes = { "ghost" } };
+ var add = new Button { Content = Loc.T("tag_editor.add_tag"), Classes = { "ghost" } };
add.Click += (_, _) => { CreateTag(); RebuildRows(); };
- var close = new Button { Content = Loc.T("Close"), Classes = { "primary" } };
+ var close = new Button { Content = Loc.T("common.close"), Classes = { "primary" } };
close.Click += (_, _) => Close();
SetBody(new StackPanel
@@ -59,7 +59,7 @@ public sealed class TagEditorWindow : NotaWindow
Spacing = 14,
Children =
{
- new TextBlock { Text = Loc.T("Tags — title & colour"), Classes = { "Caption" } },
+ new TextBlock { Text = Loc.T("tag_editor.tags_title_colour"), Classes = { "Caption" } },
new ScrollViewer { MaxHeight = 360, Content = _rows },
new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Children = { add } },
new StackPanel
@@ -77,7 +77,7 @@ public sealed class TagEditorWindow : NotaWindow
private void CreateTag()
{
- var tag = _lib.CreateTag(Loc.T("New tag"), Palette[0]);
+ var tag = _lib.CreateTag(Loc.T("tag_editor.new_tag"), Palette[0]);
if (_assignKey is not null) _lib.AssignTag(_assignKey, tag.Id, true);
}
@@ -86,7 +86,7 @@ public sealed class TagEditorWindow : NotaWindow
_rows.Children.Clear();
foreach (var tag in _lib.Tags) _rows.Children.Add(BuildRow(tag));
if (_lib.Tags.Count == 0)
- _rows.Children.Add(new TextBlock { Text = Loc.T("No tags yet — add one below."), Foreground = NotaPalette.TextTertiary, FontSize = 11 });
+ _rows.Children.Add(new TextBlock { Text = Loc.T("tag_editor.no_tags_yet_add_one"), Foreground = NotaPalette.TextTertiary, FontSize = 11 });
}
private Control BuildRow(BrowserTag tag)
diff --git a/src/managed/Nota.App/TextBoxMenu.cs b/src/managed/Nota.App/TextBoxMenu.cs
index 62973677..24081db1 100644
--- a/src/managed/Nota.App/TextBoxMenu.cs
+++ b/src/managed/Nota.App/TextBoxMenu.cs
@@ -29,9 +29,9 @@ internal static class TextBoxMenu
// No Nota text box has a flyout of its own (checked by grep), so the theme's is always replaced;
// a box that comes to have one later is left alone through the marker below.
if (box.ContextFlyout is MenuFlyout { } mine && Mine.TryGetValue(mine, out _)) return;
- var cut = MenuKit.Item(Loc.T("Cut"), GlyphKind.Cut, box.Cut, MenuKit.CutKey);
- var copy = MenuKit.Item(Loc.T("Copy"), GlyphKind.Copy, box.Copy, MenuKit.CopyKey);
- var paste = MenuKit.Item(Loc.T("Paste"), GlyphKind.Paste, box.Paste, MenuKit.PasteKey);
+ var cut = MenuKit.Item(Loc.T("common.cut"), GlyphKind.Cut, box.Cut, MenuKit.CutKey);
+ var copy = MenuKit.Item(Loc.T("common.copy"), GlyphKind.Copy, box.Copy, MenuKit.CopyKey);
+ var paste = MenuKit.Item(Loc.T("common.paste"), GlyphKind.Paste, box.Paste, MenuKit.PasteKey);
// The items exist before the menu is shown (a menu built in Opening came up empty); what
// changes is only whether each is available.
var flyout = new MenuFlyout { Items = { cut, copy, paste } };
diff --git a/src/managed/Nota.App/TextPromptWindow.cs b/src/managed/Nota.App/TextPromptWindow.cs
index ed123551..cbea537c 100644
--- a/src/managed/Nota.App/TextPromptWindow.cs
+++ b/src/managed/Nota.App/TextPromptWindow.cs
@@ -29,9 +29,9 @@ public sealed class TextPromptWindow : NotaWindow
_input = new TextBox { Text = initial, PlaceholderText = prompt };
_input.KeyDown += (_, e) => { if (e.Key == Key.Enter) Accept(); else if (e.Key == Key.Escape) Close(null); };
- var ok = new Button { Content = Loc.T("OK"), Classes = { "primary" } };
+ var ok = new Button { Content = Loc.T("text_prompt.ok_caps"), Classes = { "primary" } };
ok.Click += (_, _) => Accept();
- var cancel = new Button { Content = Loc.T("Cancel"), Classes = { "ghost" } };
+ var cancel = new Button { Content = Loc.T("common.cancel"), Classes = { "ghost" } };
cancel.Click += (_, _) => Close(null);
SetBody(new StackPanel
diff --git a/src/managed/Nota.App/TrackArming.cs b/src/managed/Nota.App/TrackArming.cs
index 1e2988d0..f7c0a5f2 100644
--- a/src/managed/Nota.App/TrackArming.cs
+++ b/src/managed/Nota.App/TrackArming.cs
@@ -49,7 +49,7 @@ internal static class TrackArming
public static void ForgetSelection() => _followed = -1;
/// <summary>The arm buttons' tooltip, with the platform's modifier spelled out.</summary>
- public static string Tip => MenuKit.Keys(Loc.T("Arm for recording · ⌘-click to arm several tracks · ⌥-click to arm one track of a linked group"));
+ public static string Tip => MenuKit.Keys(Loc.T("track_arming.arm_for_recording_click_to"));
/// <summary>⌘ on macOS, Ctrl elsewhere: the "add to the armed set" modifier.</summary>
public static bool IsAdditive(Avalonia.Input.KeyModifiers m)
diff --git a/src/managed/Nota.App/TrackInspectorView.cs b/src/managed/Nota.App/TrackInspectorView.cs
index 0e63c2f7..c10338eb 100644
--- a/src/managed/Nota.App/TrackInspectorView.cs
+++ b/src/managed/Nota.App/TrackInspectorView.cs
@@ -30,7 +30,7 @@ internal sealed class TrackInspectorView : UserControl
{
private static readonly (string Label, double Height)[] Heights =
{
- (Loc.T("Compact"), ArrangementView.CompactRowHeight), (Loc.T("Standard"), ArrangementView.StandardRowHeight), (Loc.T("Large"), ArrangementView.LargeRowHeight),
+ (Loc.T("common.compact"), ArrangementView.CompactRowHeight), (Loc.T("track_inspector.standard"), ArrangementView.StandardRowHeight), (Loc.T("track_inspector.large"), ArrangementView.LargeRowHeight),
};
private readonly IAudioEngine _engine;
@@ -142,7 +142,7 @@ internal sealed class TrackInspectorView : UserControl
{
Content = new TextBlock
{
- Text = Loc.T("No track selected"), FontSize = 11, Foreground = NotaPalette.TextTertiary,
+ Text = Loc.T("track_inspector.no_track_selected"), FontSize = 11, Foreground = NotaPalette.TextTertiary,
HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center,
};
return;
@@ -154,9 +154,9 @@ internal sealed class TrackInspectorView : UserControl
private void BuildMaster(StackPanel s)
{
- string name = _engine.GetTrackName(_trackId) is { Length: > 0 } m ? m : Loc.T("Master");
+ string name = _engine.GetTrackName(_trackId) is { Length: > 0 } m ? m : Loc.T("common.master");
s.Children.Add(Title(NotaPalette.Master, name, "MASTER"));
- s.Children.Add(Note(Loc.T("Every track ends up here. Its devices are in the Devices panel.")));
+ s.Children.Add(Note(Loc.T("track_inspector.every_track_ends_up_here")));
}
private void BuildTrack(StackPanel s, NotaTrackInfo ti)
@@ -164,38 +164,38 @@ internal sealed class TrackInspectorView : UserControl
int id = ti.Id;
bool audio = IsAudio(ti);
bool frozen = (audio || ti.IsInstrument) && _engine.IsTrackFrozen(id);
- string kind = ti.IsReturn ? Loc.T("Return") : ti.IsGroup ? Loc.T("Group") : ti.IsInstrument ? Loc.T("MIDI track") : Loc.T("Audio track");
+ string kind = ti.IsReturn ? Loc.T("common.return") : ti.IsGroup ? Loc.T("common.group") : ti.IsInstrument ? Loc.T("track_inspector.midi_track") : Loc.T("track_inspector.audio_track");
s.Children.Add(Title(ArrangementView.TrackBrush(ArrangementView.EffectiveColorIndex(_engine, id)), TrackNames.Of(_engine, ti),
NotaText.Label(frozen ? kind + " · frozen" : kind)));
- s.Children.Add(Section(Loc.T("Name"), NameBox(ti)));
+ s.Children.Add(Section(Loc.T("track_inspector.name"), NameBox(ti)));
var state = new UniformGrid { Rows = 1, Columns = 3, ColumnSpacing = 6 };
- state.Children.Add(Toggle(Loc.T("Mute"), ti.Muted != 0, NotaPalette.Mute, Loc.T("Mute the track"),
+ state.Children.Add(Toggle(Loc.T("common.mute"), ti.Muted != 0, NotaPalette.Mute, Loc.T("track_inspector.mute_the_track"),
(on, _) => { _engine.SetTrackMute(id, on); Edited(); }));
if (!ti.IsReturn)
- state.Children.Add(Toggle(Loc.T("Solo"), ti.Soloed != 0, NotaPalette.Solo, Loc.T("Solo the track"),
+ state.Children.Add(Toggle(Loc.T("common.solo"), ti.Soloed != 0, NotaPalette.Solo, Loc.T("track_inspector.solo_the_track"),
(on, _) => { _engine.SetTrackSolo(id, on); Edited(); }));
if (audio || ti.IsInstrument)
- state.Children.Add(Toggle(Loc.T("Arm"), ti.Armed != 0, NotaPalette.Record, TrackArming.Tip,
+ state.Children.Add(Toggle(Loc.T("track_inspector.arm"), ti.Armed != 0, NotaPalette.Record, TrackArming.Tip,
(on, mods) => { TrackArming.Set(_engine, id, on, mods); Edited(); }));
s.Children.Add(state);
- if (audio) s.Children.Add(Section(Loc.T("Input"), InputRows(id)));
- if (ti.IsInstrument) s.Children.Add(Section(Loc.T("Input"), MidiFromRow(id)));
+ if (audio) s.Children.Add(Section(Loc.T("common.input"), InputRows(id)));
+ if (ti.IsInstrument) s.Children.Add(Section(Loc.T("common.input"), MidiFromRow(id)));
- s.Children.Add(Section(Loc.T("Color"), Swatches(id)));
+ s.Children.Add(Section(Loc.T("track_inspector.color"), Swatches(id)));
if (!ti.IsReturn)
{
double h = _timeline.TrackRowHeight(id);
int chosen = Array.FindIndex(Heights, p => Math.Abs(p.Height - h) < 0.5);
- s.Children.Add(Section(Loc.T("Height"), SessionView.Segmented(Heights.Select(p => p.Label).ToList(), chosen,
+ s.Children.Add(Section(Loc.T("track_inspector.height"), SessionView.Segmented(Heights.Select(p => p.Label).ToList(), chosen,
i => { _timeline.SetTrackHeights(new[] { id }, Heights[i].Height); Rebuild(); })));
}
var freeze = _freezeEntries(id);
- if (freeze.Count > 0) s.Children.Add(Section(Loc.T("Freeze"), FreezeButtons(freeze)));
+ if (freeze.Count > 0) s.Children.Add(Section(Loc.T("common.freeze"), FreezeButtons(freeze)));
}
// Enter or leaving the box renames; Esc puts the name back. An empty name returns the
@@ -237,30 +237,30 @@ internal sealed class TrackInspectorView : UserControl
int sel = choices.FindIndex(c => c.Pick.Matches(cur));
string label = sel >= 0 ? choices[sel].Label : RecordInputPick.Hardware[0].Label;
var rows = new StackPanel { Spacing = 8 };
- rows.Children.Add(SessionView.Row(Loc.T("Record input"), SessionView.Chip(label, false, a =>
+ rows.Children.Add(SessionView.Row(Loc.T("common.record_input"), SessionView.Chip(label, false, a =>
SessionView.Pick(a, choices.Select(c => (c.Pick, c.Label)), p => p.Matches(cur),
p => { p.ApplyTo(_engine, id); Edited(); }))));
// Master can't be monitored (it would feed back), as on the header's monitor chip.
bool canMonitor = cur.Source != -1;
bool monitor = _engine.GetTrackMonitor(id);
- var chip = SessionView.Chip(monitor ? "On" : Loc.T("Off"), monitor, _ => { _engine.SetTrackMonitor(id, !monitor); Edited(); });
+ var chip = SessionView.Chip(monitor ? "On" : Loc.T("common.off"), monitor, _ => { _engine.SetTrackMonitor(id, !monitor); Edited(); });
chip.IsEnabled = canMonitor;
- ToolTip.SetTip(chip, canMonitor ? Loc.T("Hear the input live through this track") : Loc.T("Master can't be monitored (it would feed back)"));
- rows.Children.Add(SessionView.Row(Loc.T("Monitor input"), chip));
+ ToolTip.SetTip(chip, canMonitor ? Loc.T("track_inspector.hear_the_input_live_through") : Loc.T("track_inspector.master_cant_be_monitored_it"));
+ rows.Children.Add(SessionView.Row(Loc.T("track_inspector.monitor_input"), chip));
return rows;
}
private Control MidiFromRow(int id)
{
int cur = _engine.GetTrackMidiSource(id);
- var choices = new List<(int Id, string Name)> { (-1, Loc.T("None")) };
+ var choices = new List<(int Id, string Name)> { (-1, Loc.T("common.none")) };
choices.AddRange(_timeline.MidiSourceChoices(id));
- string label = choices.FirstOrDefault(c => c.Id == cur).Name ?? Loc.T("None");
+ string label = choices.FirstOrDefault(c => c.Id == cur).Name ?? Loc.T("common.none");
var chip = SessionView.Chip(label, false, a =>
SessionView.Pick(a, choices.Select(c => (c.Id, c.Name)), v => v == cur, v => { _engine.SetTrackMidiSource(id, v); Edited(); }));
- ToolTip.SetTip(chip, Loc.T("Play another instrument track's MIDI through this track's instrument"));
- return SessionView.Row(Loc.T("MIDI from"), chip);
+ ToolTip.SetTip(chip, Loc.T("track_inspector.play_another_instrument_tracks_midi"));
+ return SessionView.Row(Loc.T("track_inspector.midi_from"), chip);
}
// The track palette — each base in its normal, light and dark shade — and Auto, the
@@ -276,8 +276,8 @@ internal sealed class TrackInspectorView : UserControl
int idx = b * shades + shade;
grid.Children.Add(Swatch(ArrangementView.TrackBrush(idx), idx == current, () => _timeline.SetTrackColours(new[] { id }, idx)));
}
- var auto = SessionView.Chip(Loc.T("Auto"), current == -1, _ => _timeline.SetTrackColours(new[] { id }, -1));
- ToolTip.SetTip(auto, Loc.T("The colour the track's position gives it"));
+ var auto = SessionView.Chip(Loc.T("common.auto"), current == -1, _ => _timeline.SetTrackColours(new[] { id }, -1));
+ ToolTip.SetTip(auto, Loc.T("track_inspector.the_colour_the_tracks_position"));
auto.HorizontalAlignment = HorizontalAlignment.Left;
return new StackPanel { Spacing = 6, Children = { grid, auto } };
}
diff --git a/src/managed/Nota.App/TrackNames.cs b/src/managed/Nota.App/TrackNames.cs
index 82fcc00c..588f9912 100644
--- a/src/managed/Nota.App/TrackNames.cs
+++ b/src/managed/Nota.App/TrackNames.cs
@@ -13,14 +13,14 @@ internal static class TrackNames
{
string stored = eng.GetTrackName(ti.Id);
if (stored.Length > 0) return stored;
- if (ti.IsGroup) return Loc.T("Group");
- if (ti.IsReturn) return Loc.F("Return {0}", eng.TrackReturnIndex(ti.Id) + 1);
+ if (ti.IsGroup) return Loc.T("common.group");
+ if (ti.IsReturn) return Loc.F("common.return_n", eng.TrackReturnIndex(ti.Id) + 1);
if (ti.IsInstrument)
{
string inst = eng.DeviceName(ti.Id, -1); // Synth / Sampler / plugin name
- return string.IsNullOrWhiteSpace(inst) ? Loc.F("Inst {0}", ti.Id) : inst;
+ return string.IsNullOrWhiteSpace(inst) ? Loc.F("track_names.inst", ti.Id) : inst;
}
- return Loc.F("Audio {0}", ti.Id);
+ return Loc.F("common.audio_n", ti.Id);
}
/// <summary>By track id; "—" when no such track exists.</summary>
diff --git a/src/managed/Nota.App/WelcomeWindow.cs b/src/managed/Nota.App/WelcomeWindow.cs
index 0c6104af..0fcb98fd 100644
--- a/src/managed/Nota.App/WelcomeWindow.cs
+++ b/src/managed/Nota.App/WelcomeWindow.cs
@@ -47,7 +47,7 @@ public sealed class WelcomeWindow : NotaWindow
Action? onRecover = null,
Action? onDismissRecovery = null)
{
- Title = Loc.T("Welcome to Nota");
+ Title = Loc.T("welcome.welcome_to_nota");
Width = 640;
Height = 560; // including the title-bar band
CanResize = false;
@@ -70,7 +70,7 @@ public sealed class WelcomeWindow : NotaWindow
var brand = new StackPanel { Spacing = 6, VerticalAlignment = VerticalAlignment.Center };
brand.Children.Add(new TextBlock
{
- Text = Loc.T("Nota"),
+ Text = Loc.T("common.nota"),
FontSize = NotaType.Title,
FontWeight = FontWeight.SemiBold,
LetterSpacing = -0.4,
@@ -79,7 +79,7 @@ public sealed class WelcomeWindow : NotaWindow
});
brand.Children.Add(new TextBlock
{
- Text = Loc.F("Version {0} · Engine {1} · Desktop DAW", AppInfo.Version, App.Services.GetRequiredService<EngineBuildInfo>().Version),
+ Text = Loc.F("welcome.version_engine_desktop_daw", AppInfo.Version, App.Services.GetRequiredService<EngineBuildInfo>().Version),
FontFamily = NotaFonts.MonoFamily,
FontSize = NotaType.Value,
Foreground = NotaPalette.TextMuted,
@@ -95,9 +95,9 @@ public sealed class WelcomeWindow : NotaWindow
Spacing = 8,
Margin = new Thickness(0, 20, 0, 20),
};
- var newBtn = new Button { Content = Loc.T("New project"), Classes = { "primary" }, FontWeight = FontWeight.SemiBold };
+ var newBtn = new Button { Content = Loc.T("common.new_project"), Classes = { "primary" }, FontWeight = FontWeight.SemiBold };
newBtn.Click += (_, _) => { Close(); onNew(); };
- var openBtn = new Button { Content = Loc.T("Open project…") };
+ var openBtn = new Button { Content = Loc.T("welcome.open_project") };
openBtn.Click += (_, _) => { Close(); onOpen(); };
actions.Children.Add(newBtn);
actions.Children.Add(openBtn);
@@ -106,7 +106,7 @@ public sealed class WelcomeWindow : NotaWindow
// --- Recent projects ----------------------------------------------
var recentHead = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, Margin = new Thickness(0, 0, 0, 8) };
- recentHead.Children.Add(new TextBlock { Classes = { "SectionLabel" }, Text = Loc.T("Recent projects"), VerticalAlignment = VerticalAlignment.Bottom });
+ recentHead.Children.Add(new TextBlock { Classes = { "SectionLabel" }, Text = Loc.T("welcome.recent_projects"), VerticalAlignment = VerticalAlignment.Bottom });
recentHead.Children.Add(new TextBlock
{
Text = recent.Count.ToString(NotaNum.Culture),
@@ -122,7 +122,7 @@ public sealed class WelcomeWindow : NotaWindow
{
wellBody = new TextBlock
{
- Text = Loc.T("No recent projects"),
+ Text = Loc.T("welcome.no_recent_projects"),
FontSize = NotaType.Body,
Foreground = NotaPalette.TextTertiary,
HorizontalAlignment = HorizontalAlignment.Center,
@@ -195,7 +195,7 @@ public sealed class WelcomeWindow : NotaWindow
startupTrack,
new TextBlock
{
- Text = Loc.T("Show on startup"),
+ Text = Loc.T("welcome.show_on_startup"),
FontSize = NotaType.Body,
Foreground = NotaPalette.TextStrong,
VerticalAlignment = VerticalAlignment.Center,
@@ -214,18 +214,18 @@ public sealed class WelcomeWindow : NotaWindow
footer.Children.Add(startup);
// The user manual, for a first launch that wants a guided start.
- var docsBtn = FooterLink(Loc.T("Documentation"));
+ var docsBtn = FooterLink(Loc.T("common.documentation"));
docsBtn.Click += (_, _) => NotaDocs.Open(this, "start-here/first-track");
Grid.SetColumn(docsBtn, 2);
footer.Children.Add(docsBtn);
- var settingsBtn = FooterLink(Loc.T("Settings"));
+ var settingsBtn = FooterLink(Loc.T("common.settings"));
settingsBtn.Margin = new Thickness(8, 0, 0, 0);
settingsBtn.Click += (_, _) => onSettings();
Grid.SetColumn(settingsBtn, 3);
footer.Children.Add(settingsBtn);
- var whatsNewBtn = FooterLink(Loc.T("What's New"));
+ var whatsNewBtn = FooterLink(Loc.T("welcome.whats_new"));
whatsNewBtn.Margin = new Thickness(8, 0, 0, 0);
whatsNewBtn.Click += (_, _) => onWhatsNew();
Grid.SetColumn(whatsNewBtn, 4);
@@ -376,26 +376,26 @@ public sealed class WelcomeWindow : NotaWindow
_card.Child = u.State switch
{
AppUpdates.Stage.Downloading => Downloading(release),
- AppUpdates.Stage.Ready => BannerContent(Loc.F("Nota {0} is ready to install", release.Version),
- Loc.T("Restart Nota to finish updating — or it installs the next time you quit."),
+ AppUpdates.Stage.Ready => BannerContent(Loc.F("welcome.nota_is_ready_to_install", release.Version),
+ Loc.T("welcome.restart_nota_to_finish_updating"),
progress: null,
- (Loc.T("Restart now"), true, () => u.Restart(_restart)),
- (Loc.T("Later"), false, u.Dismiss)),
- AppUpdates.Stage.Failed => BannerContent(Loc.T("The update didn't download"), u.Error ?? "",
+ (Loc.T("welcome.restart_now"), true, () => u.Restart(_restart)),
+ (Loc.T("welcome.later"), false, u.Dismiss)),
+ AppUpdates.Stage.Failed => BannerContent(Loc.T("welcome.the_update_didnt_download"), u.Error ?? "",
progress: null,
- (Loc.T("Try again"), true, () => u.Download(top)),
- (Loc.T("Dismiss"), false, u.Dismiss)),
- _ when u.CanInstall => BannerContent(Loc.T("A new version of Nota is available"),
- Loc.F("Nota {0} is out — you have {1}.", release.Version, AppInfo.Version),
+ (Loc.T("common.try_again"), true, () => u.Download(top)),
+ (Loc.T("welcome.dismiss"), false, u.Dismiss)),
+ _ when u.CanInstall => BannerContent(Loc.T("welcome.a_new_version_of_nota"),
+ Loc.F("welcome.nota_is_out_you_have", release.Version, AppInfo.Version),
progress: null,
- (Loc.T("Update"), true, () => u.Download(top)),
- (Loc.T("Release notes"), false, () => u.OpenReleasePage(top)),
- (Loc.T("Dismiss"), false, u.Dismiss)),
- _ => BannerContent(Loc.T("A new version of Nota is available"),
- Loc.F("Nota {0} is out — you have {1}.", release.Version, AppInfo.Version),
+ (Loc.T("common.update"), true, () => u.Download(top)),
+ (Loc.T("welcome.release_notes"), false, () => u.OpenReleasePage(top)),
+ (Loc.T("welcome.dismiss"), false, u.Dismiss)),
+ _ => BannerContent(Loc.T("welcome.a_new_version_of_nota"),
+ Loc.F("welcome.nota_is_out_you_have", release.Version, AppInfo.Version),
progress: null,
- (Loc.T("Download"), true, () => u.Download(top)),
- (Loc.T("Dismiss"), false, u.Dismiss)),
+ (Loc.T("common.download"), true, () => u.Download(top)),
+ (Loc.T("welcome.dismiss"), false, u.Dismiss)),
};
}
@@ -406,8 +406,8 @@ public sealed class WelcomeWindow : NotaWindow
Minimum = 0, Maximum = 1, Height = 4, Margin = new Thickness(0, 6, 0, 0),
Foreground = NotaPalette.Accent, Background = NotaPalette.BorderDefault,
};
- var content = BannerContent(Loc.F("Downloading Nota {0}…", release.Version), "", _bar,
- (Loc.T("Cancel"), false, _updates.CancelDownload));
+ var content = BannerContent(Loc.F("common.downloading_nota", release.Version), "", _bar,
+ (Loc.T("common.cancel"), false, _updates.CancelDownload));
_message = (TextBlock)((StackPanel)content.Children[0]).Children[1]; // BannerContent's message line
ShowProgress();
return content;
@@ -432,7 +432,7 @@ public sealed class WelcomeWindow : NotaWindow
// Offer to restore a crashed session.
private static Border RecoveryBanner(string message, Action onRecover, Action onDismiss)
- => Banner(Loc.T("Unsaved work available"), message, Loc.T("Recover"), onRecover, onDismiss);
+ => Banner(Loc.T("welcome.unsaved_work_available"), message, Loc.T("welcome.recover"), onRecover, onDismiss);
// A dismissible alert card with one action. Accent-tinted so it reads as an action
// prompt, not an error.
@@ -441,7 +441,7 @@ public sealed class WelcomeWindow : NotaWindow
{
var card = BannerCard();
card.Child = BannerContent(title, message, progress: null,
- (actionLabel, true, onAction), (Loc.T("Dismiss"), false, onDismiss));
+ (actionLabel, true, onAction), (Loc.T("welcome.dismiss"), false, onDismiss));
return card;
}
@@ -558,7 +558,7 @@ public sealed class WelcomeWindow : NotaWindow
public void ShowOpening()
{
- _meta.Text = Loc.T("Opening…");
+ _meta.Text = Loc.T("welcome.opening");
_meta.Foreground = NotaPalette.AccentHover;
}
diff --git a/src/managed/Nota.App/WhatsNewWindow.cs b/src/managed/Nota.App/WhatsNewWindow.cs
index fe6ab1f7..91c84459 100644
--- a/src/managed/Nota.App/WhatsNewWindow.cs
+++ b/src/managed/Nota.App/WhatsNewWindow.cs
@@ -26,7 +26,7 @@ public sealed class WhatsNewWindow : NotaWindow
{
public WhatsNewWindow(IReadOnlyList<ChangelogEntry> entries)
{
- Title = Loc.T("What's new in Nota");
+ Title = Loc.T("whats_new.whats_new_in_nota");
Width = 460;
Height = 556; // + title-bar band
CanResize = false;
@@ -44,7 +44,7 @@ public sealed class WhatsNewWindow : NotaWindow
stack.Children.Add(new TextBlock
{
Classes = { "Caption" },
- Text = Loc.T("No release notes available."),
+ Text = Loc.T("whats_new.no_release_notes_available"),
});
var scroll = new ScrollViewer
@@ -57,7 +57,7 @@ public sealed class WhatsNewWindow : NotaWindow
var header = new StackPanel { Margin = new Thickness(28, 24, 28, 4), Spacing = 2 };
header.Children.Add(new TextBlock
{
- Text = Loc.T("What's new"),
+ Text = Loc.T("common.whats_new"),
FontSize = 24,
FontWeight = FontWeight.SemiBold,
Foreground = Brush("Brush.TextPrimary"),
@@ -65,12 +65,12 @@ public sealed class WhatsNewWindow : NotaWindow
header.Children.Add(new TextBlock
{
Classes = { "Caption" },
- Text = Loc.F("Nota {0}", AppInfo.Version),
+ Text = Loc.F("whats_new.nota", AppInfo.Version),
});
var ok = new Button
{
- Content = Loc.T("Got it"),
+ Content = Loc.T("whats_new.got_it"),
HorizontalAlignment = HorizontalAlignment.Right,
Margin = new Thickness(28, 8, 28, 24),
Classes = { "primary" },
@@ -95,7 +95,7 @@ public sealed class WhatsNewWindow : NotaWindow
var title = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 10 };
title.Children.Add(new TextBlock
{
- Text = Loc.F("Version {0}", entry.Version),
+ Text = Loc.F("common.version", entry.Version),
FontSize = 15,
FontWeight = FontWeight.SemiBold,
Foreground = Brush("Brush.TextHeading"),
@@ -129,7 +129,7 @@ public sealed class WhatsNewWindow : NotaWindow
Background = Brush("Brush.BorderDefault"),
Margin = new Thickness(0, 10, 0, 2),
});
- panel.Children.Add(FeatureTitle(Loc.T("All changes")));
+ panel.Children.Add(FeatureTitle(Loc.T("whats_new.all_changes")));
}
panel.Children.Add(feature
? FeatureTitle(section.Title)
diff --git a/src/managed/Nota.Application/Editing/SnapGrid.cs b/src/managed/Nota.Application/Editing/SnapGrid.cs
index 6e475f54..d254b287 100644
--- a/src/managed/Nota.Application/Editing/SnapGrid.cs
+++ b/src/managed/Nota.Application/Editing/SnapGrid.cs
@@ -29,7 +29,7 @@ public readonly record struct GridStep(int Index, bool Triplet)
// The rung as the toolbar shows it: note values are numbers, the bar steps are words.
private static string NameOf(int index) => index switch
{
- 5 => Loc.T("1 bar"), 6 => Loc.T("2 bars"), 7 => Loc.T("4 bars"),
+ 5 => Loc.T("common.1_bar"), 6 => Loc.T("editing.snap_grid.2_bars"), 7 => Loc.T("editing.snap_grid.4_bars"),
_ => Names[index],
};
@@ -177,7 +177,7 @@ public static class SnapGrid
=> Math.Max(0, (int)Math.Ceiling((bar - Eps) / stepBeats) - 1);
/// <summary>The snap control's text: "Auto · 1/8" in Adaptive mode, "1/8" when Fixed.</summary>
- public static string Label(GridSetting s, ResolvedGrid r) => s.Adaptive ? Loc.F("Auto · {0}", r.Snap.Label) : r.Snap.Label;
+ public static string Label(GridSetting s, ResolvedGrid r) => s.Adaptive ? Loc.F("editing.snap_grid.auto", r.Snap.Label) : r.Snap.Label;
// ---- transitions (⌘1–⌘5 and the menu) ------------------------------------------------
diff --git a/src/managed/Nota.Application/Localization/Loc.cs b/src/managed/Nota.Application/Localization/Loc.cs
index 9552b239..017fb663 100644
--- a/src/managed/Nota.Application/Localization/Loc.cs
+++ b/src/managed/Nota.Application/Localization/Loc.cs
@@ -1,33 +1,58 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
-// The one call every user-visible text goes through (spec 068, contracts/loc-api.md). The
-// English source text is the key, so English needs no table and wrapping a literal can never
-// change what an English user sees; any text the running language lacks falls back to its
-// English original, never blank and never an identifier. The language is fixed for the whole
-// run (a change applies after a restart), so static text tables built after Install stay
-// right and no view ever has to rebuild.
+// The one call every user-visible text goes through (spec 077, contracts/loc-api.md). A text is
+// asked for by a stable key ("preferences.language.restart"), never by its English wording, so
+// rewording English never detaches a translation. English lives in en.json, embedded in this
+// assembly beside Loc: it is there before Install, in tests that never install a language and in
+// projects that do not reference the app. Any text the running language lacks, or has in a form
+// that cannot be used, falls back to English — never blank. The language is fixed for the whole
+// run (a change applies after a restart), so static text tables built after Install stay right
+// and no view ever has to rebuild.
//
// Numbers format with the thread's current culture, exactly as the interpolated strings they
// replace did, and the language never changes that culture: choosing French alters no number.
// In the app that culture is the display culture NotaNum installs at start-up (a point, a real
// minus sign), so a tempo, dB or frequency reads as it did before.
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
using System.Globalization;
+using System.IO;
namespace Nota.Application.Localization;
public static class Loc
{
- private sealed record State(string Code, TranslationTable? Table);
+ /// <summary>The manifest name of the English reference in this assembly.</summary>
+ public const string EnglishResource = "Nota.Localization.en.json";
- private static volatile State _state = new(UiLanguage.Default, null);
+ // Usable: the running language's entries that can stand for their English entry, checked
+ // once at Install, so a lookup — labels are drawn every frame — is a dictionary read.
+ private sealed record State(string Code, TranslationTable? Table, IReadOnlyDictionary<string, Translation>? Usable);
+
+ private static readonly Lazy<TranslationTable> _english = new(LoadEnglish);
+ private static volatile TranslationTable? _englishForTests;
+ private static volatile State _state = new(UiLanguage.Default, null, null);
private static volatile bool _installed;
private static volatile bool _usedBeforeInstall;
+ private static readonly ConcurrentDictionary<string, byte> _missing = new(StringComparer.Ordinal);
/// <summary>The running language code. English until <see cref="Install"/>.</summary>
public static string Language => _state.Code;
+ /// <summary>The English reference: every key with its English text.</summary>
+ public static TranslationTable English => _englishForTests ?? _english.Value;
+
+ /// <summary>Why the English reference could not be read, if it could not (then every text
+ /// shows its key). Null in a healthy build; the smoke test checks it.</summary>
+ public static string? EnglishError { get; private set; }
+
+ /// <summary>Raised once per key that is in no table, not even English (the key is shown).
+ /// The smoke test makes this unreachable; the app logs it.</summary>
+ public static event Action<string>? MissingKey;
+
/// <summary>True if a text was asked for before <see cref="Install"/>. Such a text was
/// built in English and will not follow the language, so the app logs it and the smoke
/// test watches for it (static tables must be built after the install).</summary>
@@ -37,60 +62,67 @@ public static class Loc
/// built. English passes a null table.</summary>
public static void Install(TranslationTable? table, string languageCode)
{
- _state = new State(languageCode, languageCode == UiLanguage.Default ? null : table);
+ var running = languageCode == UiLanguage.Default ? null : table;
+ _state = new State(languageCode, running, running?.UsableAgainst(English));
_installed = true;
}
- /// <summary>Back to the uninstalled English state. For tests only.</summary>
- public static void ResetForTests()
+ /// <summary>Back to the uninstalled English state. For tests only: <paramref name="english"/>
+ /// stands in for the embedded reference until the next reset (null = the real one).</summary>
+ public static void ResetForTests(TranslationTable? english = null)
{
- _state = new State(UiLanguage.Default, null);
+ _englishForTests = english;
+ _state = new State(UiLanguage.Default, null, null);
_installed = false;
_usedBeforeInstall = false;
}
- /// <summary>The text in the running language, else <paramref name="text"/> itself. A
- /// <paramref name="context"/> separates two meanings of the same English word.</summary>
- public static string T(string text, string? context = null)
- {
- var table = Enter();
- return table is not null && Find(table, text, context) is { } t ? t.Other : text;
- }
+ /// <summary>The text of <paramref name="key"/> in the running language, else in English.</summary>
+ public static string T(string key) => Lookup(key, Enter()) is { } t ? t.Other : Missing(key);
/// <summary>A text with values: one whole pattern ("Delete {0} clips?") so the translator
/// controls word order and agreement. Placeholders are {0}, {1}…; {{ }} are literal braces.</summary>
- public static string F(string text, params object?[] args) => Format(Pattern(text, null), text, args);
-
- /// <summary><see cref="F"/> with a context, for the few patterns that need one.</summary>
- public static string FC(string context, string text, params object?[] args) => Format(Pattern(text, context), text, args);
+ public static string F(string key, params object?[] args)
+ {
+ var usable = Enter();
+ var english = English.TryGet(key, out var e) ? e.Other : Missing(key);
+ var pattern = Lookup(key, usable) is { } t ? t.Other : english;
+ return Format(pattern, english, args);
+ }
- /// <summary>A counted text. <paramref name="other"/> is the key; <paramref name="n"/> is
- /// {0} and picks the form by the running language's rule (French counts 0 and 1 as one).</summary>
- public static string Plural(long n, string one, string other, string? context = null)
+ /// <summary>A counted text: <paramref name="n"/> is {0} and picks the form by the running
+ /// language's rule (French counts 0 and 1 as one).</summary>
+ public static string Plural(string key, long n)
{
- var table = Enter();
- string english = UiLanguage.Plural(UiLanguage.Default, n) == PluralForm.One ? one : other;
- string pattern = table is not null && Find(table, other, context) is { } t
- ? UiLanguage.Plural(_state.Code, n) == PluralForm.One ? t.One ?? t.Other : t.Other
- : english;
+ _ = Enter();
+ var state = _state; // one read: the table and its usable entries belong together
+ if (!English.TryGet(key, out var e)) return Missing(key);
+ string english = UiLanguage.Plural(UiLanguage.RuleOneIs1, n) == PluralForm.One ? e.One ?? e.Other : e.Other;
+ string pattern = english;
+ if (state.Table is not null && state.Usable is not null && state.Usable.TryGetValue(key, out var t))
+ pattern = UiLanguage.Plural(state.Table.PluralRule, n) == PluralForm.One ? t.One ?? t.Other : t.Other;
return Format(pattern, english, new object?[] { n });
}
- private static TranslationTable? Enter()
+ private static IReadOnlyDictionary<string, Translation>? Enter()
{
if (!_installed) _usedBeforeInstall = true;
- return _state.Table;
+ return _state.Usable;
}
- private static string Pattern(string text, string? context)
+ // The running language's entry when it can stand for the English one (a broken entry in a
+ // language file shows English — it never crashes or garbles the UI), else the English entry.
+ private static Translation? Lookup(string key, IReadOnlyDictionary<string, Translation>? usable)
{
- var table = Enter();
- return table is not null && Find(table, text, context) is { } t ? t.Other : text;
+ if (usable is not null && usable.TryGetValue(key, out var t)) return t;
+ return English.TryGet(key, out var e) ? e : null;
}
- // An empty translation counts as missing: a text is never shown blank.
- private static Translation? Find(TranslationTable table, string text, string? context)
- => table.TryGet(TranslationTable.KeyOf(text, context), out var t) && t.Other.Length > 0 ? t : null;
+ private static string Missing(string key)
+ {
+ if (_missing.TryAdd(key, 0)) MissingKey?.Invoke(key);
+ return key;
+ }
// A bad pattern in a language file must not crash the UI: fall back to the English one.
private static string Format(string pattern, string english, object?[] args)
@@ -102,4 +134,21 @@ public static class Loc
catch (FormatException) { return english; }
}
}
+
+ private static TranslationTable LoadEnglish()
+ {
+ const string empty = "{\"formatVersion\":2,\"code\":\"en\",\"name\":\"English\"}";
+ string? error;
+ using (var s = typeof(Loc).Assembly.GetManifestResourceStream(EnglishResource))
+ {
+ if (s is null) error = $"{EnglishResource} is not embedded";
+ else
+ {
+ using var r = new StreamReader(s);
+ if (TranslationTable.Parse(r.ReadToEnd(), out error) is { } table) return table;
+ }
+ }
+ EnglishError = error;
+ return TranslationTable.Parse(empty, out _)!;
+ }
}
diff --git a/src/managed/Nota.Application/Localization/TranslationTable.cs b/src/managed/Nota.Application/Localization/TranslationTable.cs
index bd82cac7..8d7e2ab6 100644
--- a/src/managed/Nota.Application/Localization/TranslationTable.cs
+++ b/src/managed/Nota.Application/Localization/TranslationTable.cs
@@ -1,35 +1,53 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
-// One language's texts (spec 068, contracts/translation-file.md): a map from the English
-// source text to its translation, read from a JSON language file. The loader validates
-// rather than trusts, like the colour-theme loader: a file that fails yields no table and
-// a reason, never an exception thrown at the UI. Immutable once built, so lookups are
-// lock-free from any thread.
+// One language's texts by key (spec 077, contracts/language-file.md, format version 2): the
+// English reference (en.json, embedded beside Loc) and every translation share this shape. The
+// loader validates rather than trusts, like the colour-theme loader: a file that cannot be read
+// as a language yields no table and a reason, never an exception thrown at the UI; an entry that
+// is merely wrong is left out and listed in Problems, so the rest of the language still shows.
+// Immutable once built, so lookups are lock-free from any thread.
using System;
using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
namespace Nota.Application.Localization;
-/// <summary>A translated text: a plain string (<see cref="One"/> is null), or the singular
-/// and other forms of a counted one.</summary>
-public readonly record struct Translation(string? One, string Other);
+/// <summary>A translated text: a plain string (<see cref="One"/> is null and
+/// <see cref="IsPlural"/> false), or the singular and other forms of a counted one.</summary>
+public readonly record struct Translation(string? One, string Other, bool IsPlural = false);
+
+/// <summary>Something wrong with one entry of a language file; the entry is not used.</summary>
+public readonly record struct TranslationProblem(string Key, string Problem);
public sealed class TranslationTable
{
+ /// <summary>The language-file format this build reads (contract § Rules).</summary>
+ public const int FormatVersion = 2;
+
+ /// <summary>A key: lower-case dot-separated segments, at least two (research R2).</summary>
+ public static readonly Regex KeyPattern = new(@"^[a-z0-9_]+(\.[a-z0-9_]+)+$", RegexOptions.Compiled);
+ public const int MaxKeyLength = 80;
+
private static readonly Regex CodePattern = new("^[a-z]{2,3}(-[a-z0-9]+)*$", RegexOptions.Compiled);
+ private static readonly Regex PlaceholderPattern = new(@"\{(\d+)(?:[,:][^{}]*)?\}", RegexOptions.Compiled);
private readonly Dictionary<string, Translation> _strings;
- private TranslationTable(string code, string name, string notes, Dictionary<string, Translation> strings)
+ private TranslationTable(string code, string name, string pluralRule, string notes,
+ Dictionary<string, Translation> strings, List<TranslationProblem> problems)
{
Code = code;
Name = name;
+ PluralRule = pluralRule;
Notes = notes;
_strings = strings;
+ Problems = problems;
}
/// <summary>Lower-case language code, equal to the file name ("fr").</summary>
@@ -38,23 +56,25 @@ public sealed class TranslationTable
/// <summary>The language's own name, shown in the picker ("Français").</summary>
public string Name { get; }
+ /// <summary>Which count takes the singular form (<see cref="UiLanguage.Plural"/>).</summary>
+ public string PluralRule { get; }
+
/// <summary>Free text for translators; not used at run time.</summary>
public string Notes { get; }
+ /// <summary>Entries left out while reading, with why. Empty for a clean file.</summary>
+ public IReadOnlyList<TranslationProblem> Problems { get; }
+
public int Count => _strings.Count;
public IEnumerable<string> Keys => _strings.Keys;
- /// <summary>The lookup key of a text: the English text itself, or "text|context" when the
- /// same English needs two translations.</summary>
- public static string KeyOf(string text, string? context)
- => string.IsNullOrEmpty(context) ? text : text + "|" + context;
-
public bool TryGet(string key, out Translation translation) => _strings.TryGetValue(key, out translation);
- /// <summary>Parse and validate one language file. Returns null with a reason on the first
- /// problem; a file with a newer formatVersion, a duplicate key or a malformed entry is
- /// left out (the language is not offered) and Nota carries on in English.</summary>
+ /// <summary>Parse one language file. Returns null with a reason when the file as a whole
+ /// cannot be used (not JSON, another format version, a bad code or plural rule, a duplicate
+ /// key) — the language is then not offered and Nota carries on in English. A bad key or a
+ /// malformed or empty value only drops that entry (listed in <see cref="Problems"/>).</summary>
public static TranslationTable? Parse(string json, out string? error)
{
error = null;
@@ -64,27 +84,36 @@ public sealed class TranslationTable
var root = doc.RootElement;
if (root.ValueKind != JsonValueKind.Object) return Fail("the file must hold one JSON object", out error);
if (!root.TryGetProperty("formatVersion", out var fv) || fv.ValueKind != JsonValueKind.Number
- || !fv.TryGetInt32(out var version) || version != 1)
- return Fail("formatVersion must be 1", out error);
+ || !fv.TryGetInt32(out var version))
+ return Fail("formatVersion is missing", out error);
+ if (version != FormatVersion)
+ return Fail($"language file format {version} is not supported (this Nota reads format {FormatVersion})", out error);
var code = Str(root, "code");
if (!CodePattern.IsMatch(code)) return Fail($"invalid code '{code}'", out error);
var name = Str(root, "name");
if (name.Length is < 1 or > 40) return Fail("name must be 1–40 characters", out error);
+ var rule = Str(root, "plural");
+ if (rule.Length == 0 && code == UiLanguage.Default) rule = UiLanguage.RuleOneIs1;
+ if (!UiLanguage.IsKnownRule(rule)) return Fail(rule.Length == 0 ? "plural rule is missing" : $"unknown plural rule '{rule}'", out error);
var notes = Str(root, "notes");
var strings = new Dictionary<string, Translation>(StringComparer.Ordinal);
+ var problems = new List<TranslationProblem>();
if (root.TryGetProperty("strings", out var table))
{
if (table.ValueKind != JsonValueKind.Object) return Fail("strings must be an object", out error);
+ var seen = new HashSet<string>(StringComparer.Ordinal);
foreach (var p in table.EnumerateObject())
{
- if (strings.ContainsKey(p.Name)) return Fail($"duplicate key \"{p.Name}\"", out error);
- if (!TryEntry(p.Value, out var entry)) return Fail($"\"{p.Name}\": a text, or an object with an \"other\" text", out error);
+ if (!seen.Add(p.Name)) return Fail($"duplicate key \"{p.Name}\"", out error);
+ if (!IsKey(p.Name)) { problems.Add(new(p.Name, "not a valid key (lower-case dot-separated segments, up to 80 characters)")); continue; }
+ if (!TryEntry(p.Value, out var entry)) { problems.Add(new(p.Name, "must be a text, or an object with an \"other\" text")); continue; }
+ if (entry.Other.Length == 0) { problems.Add(new(p.Name, "empty text (English is shown)")); continue; }
strings[p.Name] = entry;
}
}
- return new TranslationTable(code, name, notes, strings);
+ return new TranslationTable(code, name, rule, notes, strings, problems);
}
catch (JsonException e)
{
@@ -92,6 +121,86 @@ public sealed class TranslationTable
}
}
+ public static bool IsKey(string key) => key.Length <= MaxKeyLength && KeyPattern.IsMatch(key);
+
+ /// <summary>The placeholder indices a text uses ({0}, {1:0.0} …); {{ }} are literal braces. An
+ /// index too large for an int reads as -1, so it never matches the English set.</summary>
+ public static HashSet<int> Placeholders(string text)
+ => PlaceholderPattern.Matches(text.Replace("{{", "").Replace("}}", ""))
+ .Select(m => int.TryParse(m.Groups[1].Value, out var i) ? i : -1).ToHashSet();
+
+ /// <summary>Why a pattern cannot be formatted (a stray brace, "{0,abc}", an index past
+ /// <see cref="MaxPlaceholder"/>), or null if it can. Formatting is tried with numbers, as
+ /// Loc.F and Loc.Plural pass them.</summary>
+ public static string? PatternProblem(string pattern)
+ {
+ var used = Placeholders(pattern);
+ if (used.Any(i => i is < 0 or > MaxPlaceholder)) return $"a placeholder index outside 0–{MaxPlaceholder}";
+ var args = Enumerable.Repeat<object?>(0, used.Count == 0 ? 0 : used.Max() + 1).ToArray();
+ try { _ = string.Format(System.Globalization.CultureInfo.InvariantCulture, pattern, args); return null; }
+ catch (FormatException) { return "the text cannot be formatted (check its braces and placeholders)"; }
+ }
+
+ /// <summary>The highest placeholder index a text may use.</summary>
+ public const int MaxPlaceholder = 9;
+
+ /// <summary>The entries of this table that can stand for their English reference entry
+ /// (<see cref="EntryProblem"/> is null), worked out once: Loc keeps this for the run so a
+ /// lookup is a dictionary read, never a re-check.</summary>
+ public IReadOnlyDictionary<string, Translation> UsableAgainst(TranslationTable reference)
+ {
+ var usable = new Dictionary<string, Translation>(StringComparer.Ordinal);
+ foreach (var (key, t) in _strings)
+ if (reference.TryGet(key, out var r) && EntryProblem(t, r) is null) usable[key] = t;
+ return usable;
+ }
+
+ /// <summary>This language checked against the English reference: the entries that cannot be
+ /// used (unknown key, text where the reference counts or the other way round, placeholders
+ /// that differ) and the share of reference keys it translates validly, in whole percent
+ /// rounded down (contract § Coverage). The table itself is not changed.</summary>
+ public (IReadOnlyList<TranslationProblem> Problems, int Coverage) ValidateAgainst(TranslationTable reference)
+ {
+ var problems = new List<TranslationProblem>(Problems);
+ int valid = 0;
+ foreach (var (key, t) in _strings.OrderBy(kv => kv.Key, StringComparer.Ordinal))
+ {
+ if (!reference.TryGet(key, out var r)) { problems.Add(new(key, "not in the English reference")); continue; }
+ if (EntryProblem(t, r) is { } p) { problems.Add(new(key, p)); continue; }
+ valid++;
+ }
+ int coverage = reference.Count == 0 ? 100 : (int)(100L * valid / reference.Count);
+ return (problems, coverage);
+ }
+
+ /// <summary>Why a translation cannot stand for its reference entry, or null if it can.</summary>
+ public static string? EntryProblem(Translation t, Translation reference)
+ {
+ if (t.IsPlural != reference.IsPlural)
+ return reference.IsPlural ? "the English text is counted: give \"one\" and \"other\"" : "the English text is not counted: give a plain text";
+ if (PatternProblem(t.Other) is { } other) return other;
+ if (t.One is not null && PatternProblem(t.One) is { } one) return "singular form: " + one;
+ var want = Placeholders(reference.Other);
+ if (!Placeholders(t.Other).SetEquals(want))
+ return $"placeholders {{{string.Join(",", Placeholders(t.Other).Order())}}} differ from the English {{{string.Join(",", want.Order())}}}";
+ if (t.One is not null && !Placeholders(t.One).IsSubsetOf(want))
+ return "the singular form has a placeholder the English lacks";
+ return null;
+ }
+
+ /// <summary>The identity of this table's key set (contract § Key-set hash): SHA-256 over
+ /// the sorted lines "key \t text|plural \t placeholders", first 16 hex characters. Rewording
+ /// a text keeps it; adding or removing a key, or changing a text's shape or placeholders,
+ /// changes it.</summary>
+ public string KeySetHash()
+ {
+ var lines = _strings
+ .Select(kv => $"{kv.Key}\t{(kv.Value.IsPlural ? "plural" : "text")}\t{string.Join(",", Placeholders(kv.Value.Other).Order())}")
+ .OrderBy(l => l, StringComparer.Ordinal);
+ var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(string.Join("\n", lines)));
+ return Convert.ToHexString(bytes).ToLowerInvariant()[..16];
+ }
+
private static bool TryEntry(JsonElement v, out Translation entry)
{
entry = default;
@@ -99,7 +208,8 @@ public sealed class TranslationTable
if (v.ValueKind != JsonValueKind.Object) return false;
if (!v.TryGetProperty("other", out var other) || other.ValueKind != JsonValueKind.String) return false;
string? one = v.TryGetProperty("one", out var o) && o.ValueKind == JsonValueKind.String ? o.GetString() : null;
- entry = new Translation(one, other.GetString() ?? "");
+ if (one is { Length: 0 }) one = null;
+ entry = new Translation(one, other.GetString() ?? "", IsPlural: true);
return true; // other plural categories are ignored (contract)
}
diff --git a/src/managed/Nota.Application/Localization/UiLanguage.cs b/src/managed/Nota.Application/Localization/UiLanguage.cs
index b7d9ce4d..c3d28766 100644
--- a/src/managed/Nota.Application/Localization/UiLanguage.cs
+++ b/src/managed/Nota.Application/Localization/UiLanguage.cs
@@ -3,6 +3,8 @@
//
// The interface language (spec 068): which codes exist, what a stored value means, when a
// change is still waiting for a restart, and how a language counts ("1 track", "2 tracks").
+// The counting rule is named by the language file itself (spec 077 research R6), so a language
+// downloaded later brings its rule instead of needing one written here per code.
// Pure — no UI, no I/O — so the smoke test can walk it, like InterfaceScale. A hand-edited or
// future value never throws: it reads as English.
@@ -34,11 +36,20 @@ public static class UiLanguage
public static bool IsPending(string? stored, string running, IReadOnlyCollection<string> available)
=> !string.Equals(Normalize(stored, available), running, StringComparison.Ordinal);
- /// <summary>Which plural form a whole-number count takes in a language. English: one when
- /// n is 1. French: one when n is 0 or 1. A language with no rule here counts like English.</summary>
- public static PluralForm Plural(string code, long n) => code switch
+ /// <summary>English, German …: one when n is 1.</summary>
+ public const string RuleOneIs1 = "one_is_1";
+
+ /// <summary>French …: one when n is 0 or 1.</summary>
+ public const string RuleOneIs0Or1 = "one_is_0_1";
+
+ /// <summary>Whether this build implements a plural rule a language file names.</summary>
+ public static bool IsKnownRule(string? rule) => rule is RuleOneIs1 or RuleOneIs0Or1;
+
+ /// <summary>Which plural form a whole-number count takes under a language file's rule. An
+ /// unknown rule counts like English (a file naming one is rejected when it is read).</summary>
+ public static PluralForm Plural(string rule, long n) => rule switch
{
- "fr" => n is 0 or 1 ? PluralForm.One : PluralForm.Other,
+ RuleOneIs0Or1 => n is 0 or 1 ? PluralForm.One : PluralForm.Other,
_ => n == 1 ? PluralForm.One : PluralForm.Other,
};
}
diff --git a/src/managed/Nota.Application/Localization/en.json b/src/managed/Nota.Application/Localization/en.json
new file mode 100644
index 00000000..a2db9a59
--- /dev/null
+++ b/src/managed/Nota.Application/Localization/en.json
@@ -0,0 +1,3759 @@
+{
+ "formatVersion": 2,
+ "code": "en",
+ "name": "English",
+ "plural": "one_is_1",
+ "notes": "The English reference: every interface text of Nota by key (spec 077). Change a text here; a new meaning or new placeholders get a new key.",
+ "strings": {
+ "about.2026_egor_khindikaynen_ambertape": "© 2026 Egor Khindikaynen (Ambertape)",
+ "about.desktop_daw_agplv3": "Desktop DAW · AGPLv3",
+ "about.engine": "Engine {0}",
+ "about.free_software_under_the_gnu": "Free software under the GNU AGPLv3.",
+ "about.includes_third_party_software_juce": "Includes third-party software (JUCE, Avalonia, miniaudio, RtMidi, dr_libs, Signalsmith, HIIR). See LICENSES/THIRD-PARTY-NOTICES.md for copyright and attribution notices.",
+ "ai.clip_ai.loading_the_model": "Loading the model…",
+ "ai.clip_ai.preparing_audio": "Preparing audio…",
+ "ai.clip_ai.separating_stems": "Separating stems…",
+ "ai.clip_ai.writing_stems": "Writing stems…",
+ "ai.onnx_runtime_loader.nota_couldnt_load_the_ai": "Nota couldn't load the AI runtime. Remove it in Settings → Downloads → AI Models and install it again.",
+ "ai.onnx_runtime_loader.the_ai_model_file_is": "The AI model file is damaged. Remove it in Settings → Downloads → AI Models and install it again.",
+ "app.settings": "Settings…",
+ "app_updates.couldnt_download_the_update": "Couldn't download the update: {0}",
+ "arrangement.add_audio_track": "Add audio track",
+ "arrangement.add_instrument_track": "Add instrument track",
+ "arrangement.add_return_track": "Add return track",
+ "arrangement.add_track": "Add track",
+ "arrangement.auto_editor.copy_automation": "Copy automation",
+ "arrangement.auto_editor.cut_automation": "Cut automation",
+ "arrangement.auto_editor.delete_automation": "Delete automation",
+ "arrangement.auto_editor.paste_automation": "Paste automation",
+ "arrangement.automation.band": "Band {0}",
+ "arrangement.automation.choose_parameter": "Choose parameter…",
+ "arrangement.automation.filter_parameters": "Filter parameters…",
+ "arrangement.automation.learn_touch_a_control_in": "Learn (touch a control in the plugin)",
+ "arrangement.automation.param": "Param",
+ "arrangement.automation.stage": "Stage {0}",
+ "arrangement.bars": { "one": "{0} bar", "other": "{0} bars" },
+ "arrangement.beats": "{0:0.##} beats",
+ "arrangement.controls.clear_loop_region": "Clear loop region",
+ "arrangement.controls.click_to_add_master_volume": "click to add master volume points",
+ "arrangement.controls.turn_loop_off": "Turn loop off",
+ "arrangement.controls.turn_loop_on": "Turn loop on",
+ "arrangement.copied_clip_to_session_scene": "Copied clip to session scene {0}",
+ "arrangement.copied_clips_to_the_session": "Copied {0} clips to the session from scene {1}",
+ "arrangement.ext": "Ext",
+ "arrangement.group_tracks": "Group tracks",
+ "arrangement.in": "In",
+ "arrangement.key_moves.no_track_above_takes_these": "No track above takes these clips",
+ "arrangement.key_moves.no_track_below_takes_these": "No track below takes these clips",
+ "arrangement.key_moves.unfold_the_group_to_move": "Unfold the group to move these clips across tracks",
+ "arrangement.lane_control.activate": "Activate",
+ "arrangement.lane_control.add_an_instrument_from_the": "Add an instrument from the browser",
+ "arrangement.lane_control.audio_clip": "Audio clip",
+ "arrangement.lane_control.clips": { "one": "{0} clip", "other": "{0} clips" },
+ "arrangement.lane_control.consolidate_selection": "Consolidate selection",
+ "arrangement.lane_control.convert": "Convert",
+ "arrangement.lane_control.copy_to_scene": "Copy to scene",
+ "arrangement.lane_control.copy_to_session": "Copy to Session",
+ "arrangement.lane_control.couldnt_take_the_clips_audio": "Couldn't take the clip's audio: {0}",
+ "arrangement.lane_control.deactivate": "Deactivate",
+ "arrangement.lane_control.drums_to_new_midi_track": "Drums to new MIDI track",
+ "arrangement.lane_control.edit_selected_clips_together": "Edit selected clips together",
+ "arrangement.lane_control.get_the_ai_model_for": "Get the AI model for melody and harmony…",
+ "arrangement.lane_control.harmony_to_new_midi_track": "Harmony to new MIDI track",
+ "arrangement.lane_control.insert_midi_clip": "Insert MIDI clip",
+ "arrangement.lane_control.melody_to_new_midi_track": "Melody to new MIDI track",
+ "arrangement.lane_control.midi_clip": "MIDI clip",
+ "arrangement.lane_control.new_track": "New track",
+ "arrangement.lane_control.rec": "Rec",
+ "arrangement.lane_control.release_to_load_the_clip": "Release to load the clip into {0}",
+ "arrangement.lane_control.scene": "Scene {0}",
+ "arrangement.lane_control.separate_stems": "Separate stems…",
+ "arrangement.lane_control.slice_to_new_midi_track": "Slice to new MIDI track",
+ "arrangement.lane_control.split_here": "Split here",
+ "arrangement.link.link_tracks_arming_and_clip": "Link tracks — arming and clip edits act on every track of the group · ⌥-click a clip or an arm to act on one track",
+ "arrangement.link.linked_with": "Linked with {0}",
+ "arrangement.link.the_groups_tracks_are_linked": "The group's tracks are linked",
+ "arrangement.link_tracks": "Link tracks",
+ "arrangement.loop_selection": "Loop selection",
+ "arrangement.master_cant_be_monitored_it": "Master can't be monitored (it would feed back)",
+ "arrangement.midi_from": "MIDI from",
+ "arrangement.monitor_input_hear_it_live": "Monitor input: hear it live through this track",
+ "arrangement.monitoring_input_click_to_stop": "Monitoring input — click to stop",
+ "arrangement.moved_across_tracks_device_automation": "Moved across tracks — device automation stayed on the source",
+ "arrangement.new_track_drop.couldnt_move_the_clips_to": "Couldn't move the clips to new tracks",
+ "arrangement.new_track_drop.moved_to_new_tracks_device": "Moved to new tracks — device automation stayed on the source",
+ "arrangement.overview.bar": "bar {0}–{1} / {2}",
+ "arrangement.overview.overview": "Overview",
+ "arrangement.overview.the_project_appears_here": "the project appears here",
+ "arrangement.paste_a_midi_clip_onto": "Paste a MIDI clip onto a MIDI track, audio onto audio.",
+ "arrangement.paste_track": "Paste track",
+ "arrangement.played_from_a_phone": "Played from a phone: {0}",
+ "arrangement.processing": "Processing…",
+ "arrangement.sections.add_section_here": "Add section here",
+ "arrangement.sections.already_has_its_automatic_name": "{0} already has its automatic name",
+ "arrangement.sections.automatic_name": "Automatic name",
+ "arrangement.sections.back_to_the_automatic_name": "Back to the automatic name ({0}), which follows the section's position",
+ "arrangement.sections.couldnt_delete": "Couldn't delete {0}",
+ "arrangement.sections.couldnt_duplicate": "Couldn't duplicate {0}",
+ "arrangement.sections.couldnt_move_there": "Couldn't move {0} there",
+ "arrangement.sections.custom_name": "Custom name",
+ "arrangement.sections.delete_all_sections": "Delete all sections",
+ "arrangement.sections.delete_with_content": "Delete with content",
+ "arrangement.sections.deleted_with_its_content": "Deleted {0} with its content",
+ "arrangement.sections.drag_here_to_mark_a": "drag here to mark a section",
+ "arrangement.sections.duplicate_with_content": "Duplicate with content",
+ "arrangement.sections.duplicated_with_its_content": "Duplicated {0} with its content",
+ "arrangement.sections.is_again": "“{0}” is {1} again",
+ "arrangement.sections.is_already_the_first_section": "{0} is already the first section",
+ "arrangement.sections.is_already_the_last_section": "{0} is already the last section",
+ "arrangement.sections.loop_section": "Loop section",
+ "arrangement.sections.move_earlier": "Move earlier",
+ "arrangement.sections.move_later": "Move later",
+ "arrangement.sections.moved_earlier": "Moved {0} earlier",
+ "arrangement.sections.moved_later": "Moved {0} later",
+ "arrangement.sections.no_section_at_the_playhead": "No section at the playhead",
+ "arrangement.sections.overlaps_another_section_separate_them": "{0} overlaps another section — separate them to move its content with it",
+ "arrangement.sections.reset_to_default": "Reset to default",
+ "arrangement.sections.reset_to_default_name": "Reset to default name",
+ "arrangement.sections.section_bars": { "one": "Section · {0} bar", "other": "Section · {0} bars" },
+ "arrangement.sections.sections": "Sections",
+ "arrangement.sections.select_section": "Select section",
+ "arrangement.send": "Send {0} · {1}",
+ "arrangement.sends.show_sends_in_track_headers": "Show sends in track headers",
+ "arrangement.takes.delete_take": "Delete take",
+ "arrangement.takes.flatten_takes": "Flatten takes",
+ "arrangement.takes.hide_takes": "Hide takes",
+ "arrangement.takes.show_takes": "Show {0} takes",
+ "arrangement.takes.take": "Take {0}",
+ "arrangement.takes.use_whole_take": "Use whole take",
+ "arrangement.tracks.height": "Height",
+ "arrangement.tracks.large": "Large",
+ "arrangement.tracks.standard": "Standard",
+ "arrangement.tracks.tracks": "{0} tracks",
+ "arrangement.ungroup": "Ungroup",
+ "arrangement.vol": "Vol",
+ "arrangement.zoom": "Zoom",
+ "audio_clip_editor.a_session_slot_plays_on": "A Session slot plays on its own loop clock — launch it to play from the start",
+ "audio_clip_editor.beats": "Beats",
+ "audio_clip_editor.click_point_drag_move_right": "Click — point · drag — move · right-click — delete",
+ "audio_clip_editor.complex": "Complex",
+ "audio_clip_editor.complex_pro": "Complex Pro",
+ "audio_clip_editor.detect_tempo": "Detect tempo",
+ "audio_clip_editor.detect_the_files_tempo_and": "Detect the file's tempo and conform it to the project",
+ "audio_clip_editor.detected": "Detected",
+ "audio_clip_editor.double_click_the_wave_marker": "Double-click the wave — marker · drag — align",
+ "audio_clip_editor.double_the_tempo_the_clip": "Double the tempo — the clip spans twice as many beats",
+ "audio_clip_editor.drag_a_handle_double_click": "Drag a handle · double-click — reset",
+ "audio_clip_editor.envelope": "Envelope",
+ "audio_clip_editor.gain": "Gain",
+ "audio_clip_editor.half_the_tempo_the_clip": "Half the tempo — the clip spans half as many beats",
+ "audio_clip_editor.markers": { "one": "{0} marker", "other": "{0} markers" },
+ "audio_clip_editor.mono": "Mono",
+ "audio_clip_editor.off": "off",
+ "audio_clip_editor.pin_a_marker_on_every": "Pin a marker on every hit so drums lock to the grid",
+ "audio_clip_editor.play_the_whole_sample_at": "Play the whole sample at full level",
+ "audio_clip_editor.playback": "Playback",
+ "audio_clip_editor.reset": "Reset",
+ "audio_clip_editor.snap_needs_warp_turn_on": "Snap needs Warp — turn on Warp to see the grid and snap to it",
+ "audio_clip_editor.stereo": "Stereo",
+ "audio_clip_editor.tempo": "Tempo",
+ "audio_clip_editor.texture": "Texture",
+ "audio_clip_editor.the_tempo_the_audio_was": "The tempo the audio was recorded at. Nota stretches it to the project tempo. ×2 / ÷2 fix a half- or double-time detection.",
+ "audio_clip_editor.to_transients": "To transients",
+ "audio_clip_editor.tones": "Tones",
+ "audio_clip_editor.warp": "Warp",
+ "audition.preset_audition.kits.kit_not_found": "Kit not found.",
+ "audition.preset_audition.plug_in_presets_cant_be": "Plug-in presets can't be previewed — load the plug-in to hear them.",
+ "audition.preset_audition.preset_not_found": "Preset not found.",
+ "audition.preset_audition.racks_play_what_their_chains": "Racks play what their chains hold — nothing to preview on its own.",
+ "audition.preset_audition.the_effect_rack_plays_what": "The Effect Rack plays what its chains hold — nothing to preview on its own.",
+ "browser.add_audio_files_to_your": "Add audio files to your Samples folder (Settings → Library) or install free packs from Settings → Downloads → Sample packs, then browse them here as a folder tree. You can also drag files in from Finder.",
+ "browser.add_to_favorites": "Add to favorites",
+ "browser.analysing": " · analysing {0} %",
+ "browser.any_key": "Any key",
+ "browser.any_tempo": "Any tempo",
+ "browser.arpeggiator_chord_scale_and_more": "Arpeggiator, chord, scale and more — they process notes before an instrument; drop one to the left of an instrument in a track.",
+ "browser.audio_effect": "Audio effect",
+ "browser.audio_effects": "Audio Effects",
+ "browser.audio_effects_2": "Audio effects",
+ "browser.bpm_caps": "BPM",
+ "browser.built_in": "{0} built-in · {1}",
+ "browser.built_in_caps": "BUILT-IN",
+ "browser.category_chips": "Category chips",
+ "browser.collapse": "Collapse",
+ "browser.collapse_browser": "Collapse browser",
+ "browser.couldnt_analyse_that_sample": "Couldn't analyse that sample",
+ "browser.create_multisample": "Create multisample…",
+ "browser.delete": "Delete…",
+ "browser.edit_tags": "Edit tags…",
+ "browser.expand": "Expand",
+ "browser.expand_browser": "Expand browser",
+ "browser.external_drop_named_no_files": "External drop named no files Nota can read. Formats: {0}",
+ "browser.favorites": "Favorites",
+ "browser.favorites_first": "Favorites first",
+ "browser.files": "Files",
+ "browser.filter_by_key_a_key": "Filter by key — a key also shows its relative (A minor ↔ C major)",
+ "browser.filter_by_tempo": "Filter by tempo",
+ "browser.finding_sounds_like": "Finding sounds like {0}…",
+ "browser.folder": "Folder",
+ "browser.group_by_source": "Group by source",
+ "browser.history": "History",
+ "browser.key": "Key",
+ "browser.like": "Like {0}",
+ "browser.loops": "Loops",
+ "browser.loops_within_5_of_bpm": "Loops within 5 % of {0} BPM warp to it cleanly",
+ "browser.map_the_folders_samples_by": "Map the folder's samples by their names into Nota Mosaic presets",
+ "browser.midi_effect": "MIDI effect",
+ "browser.midi_effects": "MIDI Effects",
+ "browser.midi_effects_2": "MIDI effects",
+ "browser.midi_file": "MIDI file",
+ "browser.midi_map": "MIDI map",
+ "browser.new_tag": "New tag…",
+ "browser.no_audio_effects_yet": "No audio effects yet",
+ "browser.no_instruments_yet": "No instruments yet",
+ "browser.no_matches": "No matches",
+ "browser.no_matches_yet": "No matches yet",
+ "browser.no_midi_effects_yet": "No MIDI effects yet",
+ "browser.no_presets_yet": "No presets yet",
+ "browser.no_projects_yet": "No projects yet",
+ "browser.no_samples_yet": "No samples yet",
+ "browser.nota_is_still_analysing_your": "Nota is still analysing your samples — more matches appear as it goes.",
+ "browser.nota_kits": "Nota Kits",
+ "browser.notas_built_in_effects_plus": "Nota's built-in effects plus your VST/AU plug-ins. Scan your plug-ins in Settings → Plug-ins to add more.",
+ "browser.notas_built_in_synths_plus": "Nota's built-in synths plus your VST/AU plug-ins. Scan your plug-ins in Settings → Plug-ins to add more.",
+ "browser.one_shots": "One-shots",
+ "browser.packs": "Packs",
+ "browser.plug_ins": { "one": "{0} plug-in", "other": "{0} plug-ins" },
+ "browser.plug_ins_caps": "PLUG-INS",
+ "browser.preset": "Preset",
+ "browser.presets": "Presets",
+ "browser.presets_n": { "one": "{0} preset", "other": "{0} presets" },
+ "browser.project": "Project",
+ "browser.project_key": "Project key · {0}",
+ "browser.project_tempo_5": "Project tempo ±5 %",
+ "browser.projects": "Projects",
+ "browser.projects_n": { "one": "{0} project", "other": "{0} projects" },
+ "browser.remove_from_favorites": "Remove from favorites",
+ "browser.right_click_a_device_header": "Right-click a device header and choose Save preset; it appears here grouped by category and device.",
+ "browser.sample_packs_installed_from_settings": "sample packs installed from Settings → Downloads",
+ "browser.samples": { "one": "{0} sample", "other": "{0} samples" },
+ "browser.save_a_project_s_into": "Save a project (⌘S) into your Projects folder (Settings → Library) and it shows up here.",
+ "browser.search": "Search",
+ "browser.show_similar_sounds": "Show similar sounds",
+ "browser.show_type_tags": "Show type tags",
+ "browser.sort_and_view": "Sort and view",
+ "browser.sounds_like_closest_first_click": "Sounds like {0}, closest first — click to go back to all samples",
+ "browser.tags": "Tags",
+ "browser.track_inspector": "Track inspector",
+ "browser.transpose_to_project_key": "Transpose to project key",
+ "browser.try_a_different_search_or": "Try a different search or clear the filters.",
+ "browser.warp_loops_to_project_tempo": "Warp loops to project tempo",
+ "clip_adsr.attack": "Attack {0}",
+ "clip_adsr.decay_sustain": "Decay {0} · Sustain {1}",
+ "clip_adsr.release": "Release {0}",
+ "clip_editor.click_to_add_a_point": "Click to add a point",
+ "clip_editor.click_to_add_a_point_2": "Click to add a point · drag to move · right-click to delete",
+ "clip_editor.clip_the_selected_clip_track": "Clip: the selected clip · Track: every clip on the track",
+ "clip_editor.delete_every_note_outside_the": "Delete every note outside the scale",
+ "clip_editor.env": "Env",
+ "clip_editor.envelopes": "Envelopes",
+ "clip_editor.fit": "Fit",
+ "clip_editor.fit_to_notes_f": "Fit to notes (⇧F)",
+ "clip_editor.fold": "Fold",
+ "clip_editor.fold_show_f": "Fold: show {0} (⌥⇧F)",
+ "clip_editor.hear_notes_as_you_place": "Hear notes as you place, click or drag them",
+ "clip_editor.notes": "Notes",
+ "clip_editor.only_the_notes_in_use": "only the notes in use",
+ "clip_editor.only_the_pads": "only the pads",
+ "clip_editor.only_the_scales_notes": "only the scale's notes",
+ "clip_editor.remove_out_of_scale": "Remove out of scale",
+ "clip_editor.scale": "Scale",
+ "clip_editor.tools": "Tools",
+ "clip_editor.track_clip": "Track {0} clip",
+ "clip_props.beat": "beat",
+ "clip_props.beats": "beats",
+ "clip_props.clips_always_loop": "Clips always loop",
+ "clip_props.double_click_add_or_delete": "Double-click — add or delete · edge — length · Shift — add to selection",
+ "clip_props.no_notes_selected": "No notes selected",
+ "clip_props.notes": "Notes",
+ "clip_props.selection": "Selection",
+ "clip_props.strength": "Strength",
+ "clip_props.transpose": "Transpose",
+ "command_palette.1_result": "1 result",
+ "command_palette.add_stay": "add & stay",
+ "command_palette.add_to_canvas": "add to canvas",
+ "command_palette.all": "All",
+ "command_palette.filter": "filter",
+ "command_palette.insert": "insert",
+ "command_palette.load": "load",
+ "command_palette.new_track": "new track",
+ "command_palette.nothing_matches_try_a_role": "Nothing matches. Try a role (reverb, comp), a character (warm, dark) or a source (vocals, drums).",
+ "command_palette.open_in_devices": "open in Devices",
+ "command_palette.replace": "replace",
+ "command_palette.results": "{0} results",
+ "command_palette.run": "run",
+ "command_palette.search_actions_tracks_devices_presets": "Search actions, tracks, devices, presets…",
+ "command_palette.select": "select",
+ "command_palette.showing_results_for": "Showing results for ",
+ "command_palette.typed_in_the_other_keyboard": " · typed in the other keyboard layout",
+ "commands.activate_deactivate_clip": "Activate / deactivate clip",
+ "commands.auto_arm_selected_track": "Auto-arm selected track",
+ "commands.clip_editor_fills_the_window": "Clip editor fills the window",
+ "commands.command_palette": "Command palette",
+ "commands.connect_phone": "Connect phone…",
+ "commands.copy_clips_to_session_arrangement": "Copy clips to Session / Arrangement",
+ "commands.cycle_clip_names": "Cycle clip names",
+ "commands.delete_section_with_content": "Delete section with content",
+ "commands.duplicate_section_with_content": "Duplicate section with content",
+ "commands.edit_selected_clips_together": "Edit selected clips together",
+ "commands.exit_nota": "Exit Nota",
+ "commands.export_audio": "Export audio…",
+ "commands.fit_to_notes": "Fit to notes",
+ "commands.fold_the_piano_roll": "Fold the piano roll",
+ "commands.follow_playhead": "Follow playhead",
+ "commands.freeze_track": "Freeze track",
+ "commands.group_tracks": "Group tracks",
+ "commands.help": "Help",
+ "commands.import_audio": "Import audio…",
+ "commands.insert_scene": "Insert scene",
+ "commands.launch_scene": "Launch scene",
+ "commands.lock_envelopes": "Lock envelopes",
+ "commands.loop_record_overdub_replace": "Loop record: overdub / replace",
+ "commands.midi_learn": "MIDI learn",
+ "commands.mixer_in_its_own_window": "Mixer in its own window",
+ "commands.move_section_earlier": "Move section earlier",
+ "commands.move_section_later": "Move section later",
+ "commands.narrow_grid": "Narrow grid",
+ "commands.new_audio_track": "New audio track",
+ "commands.new_midi_track": "New MIDI track",
+ "commands.new_return_track": "New return track",
+ "commands.open_devices_in_a_window": "Open devices in a window",
+ "commands.open_project": "Open project…",
+ "commands.play_pause": "Play / pause",
+ "commands.quantize_notes": "Quantize notes",
+ "commands.redo": "Redo",
+ "commands.remove_out_of_scale_notes": "Remove out-of-scale notes",
+ "commands.reset_section_name": "Reset section name",
+ "commands.save_project": "Save project",
+ "commands.save_project_as": "Save project as…",
+ "commands.save_version_with_note": "Save version with note…",
+ "commands.select_all_clips": "Select all clips",
+ "commands.session": "Session",
+ "commands.settings_appearance": "Settings: Appearance",
+ "commands.settings_audio": "Settings: Audio",
+ "commands.settings_downloads": "Settings: Downloads",
+ "commands.settings_gamepads": "Settings: Gamepads",
+ "commands.settings_library": "Settings: Library",
+ "commands.settings_midi": "Settings: MIDI",
+ "commands.settings_plug_ins": "Settings: Plug-ins",
+ "commands.settings_remote": "Settings: Remote",
+ "commands.settings_shortcuts": "Settings: Shortcuts",
+ "commands.settings_updates": "Settings: Updates",
+ "commands.show_arrangement": "Show Arrangement",
+ "commands.show_devices": "Show devices",
+ "commands.show_mixer": "Show Mixer",
+ "commands.show_modular": "Show Modular",
+ "commands.show_playhead": "Show playhead",
+ "commands.show_session": "Show Session",
+ "commands.show_version_history": "Show version history",
+ "commands.split_at_playhead": "Split at playhead",
+ "commands.stop_all_clips": "Stop all clips",
+ "commands.tap_tempo": "Tap tempo",
+ "commands.toggle_adaptive_grid": "Toggle adaptive grid",
+ "commands.toggle_automation_mode": "Toggle automation mode",
+ "commands.toggle_browser": "Toggle browser",
+ "commands.toggle_clip_editor_track_mode": "Toggle clip editor track mode",
+ "commands.toggle_detail_panel": "Toggle detail panel",
+ "commands.toggle_full_screen": "Toggle full screen",
+ "commands.toggle_loop": "Toggle loop",
+ "commands.toggle_overview": "Toggle overview",
+ "commands.toggle_sections": "Toggle sections",
+ "commands.toggle_snap_to_grid": "Toggle snap to grid",
+ "commands.toggle_triplet_grid": "Toggle triplet grid",
+ "commands.track_headers_on_the_right": "Track headers on the right",
+ "commands.transpose_notes_down_an_octave": "Transpose notes down an octave",
+ "commands.transpose_notes_up_an_octave": "Transpose notes up an octave",
+ "commands.ungroup_tracks": "Ungroup tracks",
+ "commands.view": "View",
+ "commands.widen_grid": "Widen grid",
+ "common.1_bar": "1 bar",
+ "common.about_nota": "About Nota",
+ "common.attack": "Attack",
+ "common.audio": "Audio",
+ "common.audio_n": "Audio {0}",
+ "common.auto": "Auto",
+ "common.cancel": "Cancel",
+ "common.check_for_updates": "Check for updates…",
+ "common.clear": "Clear",
+ "common.clear_all": "Clear all",
+ "common.clip": "Clip",
+ "common.close": "Close",
+ "common.compact": "Compact",
+ "common.consolidate": "Consolidate",
+ "common.copy": "Copy",
+ "common.couldnt_load": "Couldn't load {0}.",
+ "common.cut": "Cut",
+ "common.decay": "Decay",
+ "common.delete": "Delete",
+ "common.documentation": "Documentation",
+ "common.download": "Download",
+ "common.downloading_nota": "Downloading Nota {0}…",
+ "common.duplicate": "Duplicate",
+ "common.duplicate_time": "Duplicate time",
+ "common.edit": "Edit",
+ "common.file": "File",
+ "common.freeze": "Freeze",
+ "common.gate": "Gate",
+ "common.grid": "Grid",
+ "common.group": "Group",
+ "common.hz_runs_the_lfo_free": "Hz runs the LFO free; Sync takes its rate from the tempo and locks it to the bar while the transport plays",
+ "common.input": "Input",
+ "common.insert_silence": "Insert silence",
+ "common.instrument": "Instrument",
+ "common.instruments": "Instruments",
+ "common.length": "Length",
+ "common.loop": "Loop",
+ "common.macro": "Macro {0} · {1}",
+ "common.master": "Master",
+ "common.metronome": "Metronome",
+ "common.midi_latency_0_smp": "MIDI · latency 0 smp",
+ "common.min": "Min",
+ "common.mix_at_zero_only_the": "Mix at zero: only the dry signal is heard",
+ "common.mixer": "Mixer",
+ "common.modular": "Modular",
+ "common.mute": "Mute",
+ "common.new_project": "New project",
+ "common.none": "None",
+ "common.nota": "Nota",
+ "common.off": "Off",
+ "common.open": "Open",
+ "common.other": "Other",
+ "common.output": "Output",
+ "common.pan": "Pan",
+ "common.paste": "Paste",
+ "common.paste_bounced_audio": "Paste bounced audio",
+ "common.pattern": "Pattern",
+ "common.pattern_n": "{0} · {1}",
+ "common.piano_roll": "Piano roll",
+ "common.pitch": "Pitch",
+ "common.play_stop": "Play / stop",
+ "common.quantize": "Quantize",
+ "common.range": "Range",
+ "common.rate_the_free_lfo_rate": "Rate — the free LFO rate, 0.02 … 8 Hz",
+ "common.recent": "Recent",
+ "common.record": "Record",
+ "common.record_input": "Record input",
+ "common.release": "Release",
+ "common.rename": "Rename…",
+ "common.return": "Return",
+ "common.return_n": "Return {0}",
+ "common.reverse": "Reverse",
+ "common.sample": "Sample",
+ "common.save_preset": "Save preset",
+ "common.select_a_track_first": "Select a track first.",
+ "common.send": "Send {0}",
+ "common.sends": "Sends",
+ "common.settings": "Settings",
+ "common.show": "Show",
+ "common.solo": "Solo",
+ "common.start": "Start",
+ "common.stereo_map": "Stereo map",
+ "common.stop": "Stop",
+ "common.sustain": "Sustain",
+ "common.the_lfo_rate_in_hz": "The LFO rate: in Hz, or the note value it takes from the tempo",
+ "common.track": "Track",
+ "common.track_n": "Track {0}",
+ "common.transport": "Transport",
+ "common.try_again": "Try again",
+ "common.type_value": "Type value…",
+ "common.undo": "Undo",
+ "common.unpacking": "Unpacking {0}…",
+ "common.update": "Update",
+ "common.velocity": "Velocity",
+ "common.version": "Version {0}",
+ "common.volume": "Volume",
+ "common.wet_only_send": "Wet only (send)",
+ "common.whats_new": "What's new",
+ "control.clear_the_peak_hold": "Clear the peak hold",
+ "control.meter_fader.drag_to_set_the_volume": "Drag to set the volume · click to clear the peak hold",
+ "control.na_badge.not_available_yet": "Not available yet",
+ "control.value_entry.parameter": "Parameter",
+ "control.value_entry.reset_to_default": "Reset to default",
+ "control.value_entry.value": "Value",
+ "detail.devices_clip": "Devices / Clip",
+ "device.active_click_to_bypass": "Active — click to bypass",
+ "device.arp.hold_keep_arpeggiating_after_the": "Hold: keep arpeggiating after the keys are released",
+ "device.arp.midi_out_ch_1": "MIDI out · ch 1",
+ "device.arp.midi_waiting_for_notes": "MIDI · waiting for notes",
+ "device.arp.next_groove_lane": "Next Groove lane",
+ "device.arp.no_notes_yet": "no notes yet",
+ "device.arp.notes_oct_cycle_steps": "{0} notes · {1} oct · cycle {2} steps",
+ "device.arp.oct": "{0} · {1} oct",
+ "device.arp.restart_the_pattern_from_step": "Restart the pattern from step 1",
+ "device.arp.step": "step {0} · {1}",
+ "device.aurora.8_in_use": "{0} / 8 in use",
+ "device.aurora.click_for_the_next_macros": "Click for the next macros, right-click for the previous",
+ "device.aurora.click_for_the_next_target": "Click for the next target, right-click for the previous",
+ "device.aurora.drag_a_cell_up_adds": "drag a cell — up adds, down subtracts · ⌥-click types · double-click clears",
+ "device.aurora.drag_or_turn_to_change": "{0} · drag or turn to change, double-click to type",
+ "device.aurora.drag_to_change_double_click": " · drag to change, double-click to reset",
+ "device.aurora.shape_lfo": "Shape · LFO {0}",
+ "device.aurora.shape_lfo_1_caps": "SHAPE · LFO 1",
+ "device.aurora.the_oscillator_whose_table_and": "The oscillator whose table and warp mode this strip edits",
+ "device.aurora.zero_every_route_in_the": "Zero every route in the matrix",
+ "device.auto_filter.analog_a_gentle_saturation_after": "Analog — a gentle saturation after the filter, like an analog circuit",
+ "device.auto_filter.cutoff_over_time": "Cutoff over time",
+ "device.auto_filter.cutoff_the_base_the_modulation": "Cutoff — the base the modulation moves from; the dashed mark is where it is now. Double-click resets, ⌥-click types a value.",
+ "device.auto_filter.drag_sideways_for_the_cutoff": "Drag sideways for the cutoff, up and down for the resonance. The teal band is how far the envelope and LFO can move the cutoff; the dashed curve is where they have it now.",
+ "device.auto_filter.envelope_follower_on_off": "Envelope follower on / off",
+ "device.auto_filter.envelope_not_assigned": "envelope not assigned",
+ "device.auto_filter.hold_keep_the_envelope_at": "Hold — keep the envelope at its peak for the HOLD time before it releases (∞ freezes it)",
+ "device.auto_filter.lfo_not_assigned": "LFO not assigned",
+ "device.auto_filter.lfo_on_off": "LFO on / off",
+ "device.auto_filter.no_modulation_assigned": "no modulation assigned",
+ "device.auto_filter.none_this_tracks_input": "None — this track's input",
+ "device.auto_filter.resonance_the_peak_at_the": "Resonance — the peak at the cutoff; the dashed mark is where it is now. Double-click resets, ⌥-click types a value.",
+ "device.auto_filter.retrig_restart_the_lfo_on": "Retrig — restart the LFO on each input onset (−24 dBFS) and when play starts",
+ "device.auto_filter.sidechain_key_envelope_source_caps": "SIDECHAIN KEY — ENVELOPE SOURCE",
+ "device.auto_filter.sidechain_key_the_envelope_follows": "Sidechain key — the envelope follows another track instead of this one. Switch on to pick the source and the key gain; right-click to change it.",
+ "device.auto_filter.stereo_phase_the_right_channels": "Stereo phase — the right channel's LFO runs ahead of the left (90° when switched on; right-click steps 45° … 180°)",
+ "device.auto_filter.the_inputs_envelope_teal_and": "The input's envelope (teal) and the cutoff it drives (neutral ink), the base cutoff dashed. Drag up or down for the amount.",
+ "device.auto_filter.the_lfos_movement_over_the": "The LFO's movement over the window — raw shape dashed, what the filter follows (after Smooth) in neutral ink, the right channel in rose when stereo is on. Drag up or down for the amount, sideways for the start phase.",
+ "device.auto_gain.auto_rides_the_gain_to": "Auto rides the gain to the target over Window; Manual holds the fader where you put it (Match sets it to the distance to the target)",
+ "device.auto_gain.ceiling_6_0_dbtp_drag": "Ceiling, −6 … 0 dBTP — drag up / down (Shift for fine steps), ⌥-click to type, double-click resets to −1.0",
+ "device.auto_gain.fixed_target_no_reference": "Fixed target — no reference",
+ "device.auto_gain.input_loudness_on_the_chosen": "Input loudness on the chosen scale (LUFS); the teal mark is the target",
+ "device.auto_gain.input_silent_the_measurement_and": "Input silent: the measurement and the gain hold",
+ "device.auto_gain.leveler_bypassed_the_output_equals": "Leveler bypassed: the output equals the input",
+ "device.auto_gain.limited_by_max_cut": "limited by max cut",
+ "device.auto_gain.limited_by_max_gain": "limited by max gain",
+ "device.auto_gain.limited_by_true_peak": "limited by true-peak",
+ "device.auto_gain.match_set_the_manual_gain": "Match — set the manual gain to the distance between the measured input and the target",
+ "device.auto_gain.max_gain_the_most_the": "Max gain — the most the correction may boost or cut, 0 … 24 dB",
+ "device.auto_gain.output_loudness_on_the_chosen": "Output loudness on the chosen scale (LUFS); the teal mark is the target",
+ "device.auto_gain.output_lu_from_the_target": "Output {0} LU from the target · Match sets {1} dB",
+ "device.auto_gain.output_true_peak_dbtp_the": "Output true peak (dBTP); the teal mark is the ceiling while True-peak safe is on",
+ "device.auto_gain.reset_restart_the_measurement_from": "Reset — restart the measurement from the loudness now, so the ride catches up at once",
+ "device.auto_gain.response_slow_glides_over_the": "Response — Slow glides over the whole Window with a 20 ms look-ahead; Fast over a quarter of it with 5 ms",
+ "device.auto_gain.scale_what_the_correction_reads": "Scale — what the correction reads: Momentary (400 ms, fast and nervous), Short-term (3 s) or Integrated (12 s with BS.1770 gating, the steadiest)",
+ "device.auto_gain.target_loudness_36_0_lufs": "Target loudness, −36 … 0 LUFS. Click the value for the standards or to match another track's loudness (a reference); drag the dashed line in the graph for the same",
+ "device.auto_gain.the_correction_applied_max_gain": "The correction applied, ±Max Gain around 0 dB (trim not included)",
+ "device.auto_gain.the_correction_around_0_db": "The correction around 0 dB, ±Max Gain. In Manual drag it (Shift for fine steps); ⌥-click types, double-click resets to 0 dB. In Auto it shows the ride",
+ "device.auto_gain.the_last_8_s_input": "The last 8 s: input, output and the target with its ±1 LU band (momentary loudness). Drag up / down to move the target; ⌥-click types, double-click resets it",
+ "device.auto_gain.trim_a_fixed_offset_after": "Trim — a fixed offset after the correction, −12 … +12 dB (the output then sits that far off the target)",
+ "device.auto_gain.true_peak_safe_a_look": "True-peak safe — a look-ahead limiter keeps the output under the ceiling (adds 5 / 20 ms of latency, compensated)",
+ "device.auto_gain.waiting_for_signal": "waiting for signal",
+ "device.auto_gain.waiting_for_signal_the_gain": "Waiting for signal — the gain holds until the input has been measured",
+ "device.auto_gain.what_the_leveler_is_doing": "What the leveler is doing now",
+ "device.auto_gain.window_how_long_the_ride": "Window — how long the ride takes to reach the target, 0.4 … 10 s (Fast: a quarter of it)",
+ "device.auto_pan.0_tremolo_both_channels_together": "0° — tremolo: both channels together",
+ "device.auto_pan.180_auto_pan_one_side": "180° — auto-pan: one side up while the other is down",
+ "device.auto_pan.90_a_quarter_cycle_apart": "90° — a quarter cycle apart: the sound circles",
+ "device.auto_pan.above_8_hz_the_movement": "Above 8 Hz the movement reads as a flutter, not as panning",
+ "device.auto_pan.amount_or_mix_at_zero": "Amount or Mix at zero: nothing moves",
+ "device.auto_pan.amount_the_depth_each_channel": "Amount — the depth: each channel dips to 1 − Amount at the LFO's low point",
+ "device.auto_pan.both_channels_gain_over_two": "Both channels' gain over two LFO cycles — L neutral, R teal, Phase later — with the floor the depth reaches. Drag up / down for Amount, left / right for Phase; ⌥-click types, double-click resets both.",
+ "device.auto_pan.gain_2_cycles_caps": "GAIN · 2 CYCLES",
+ "device.auto_pan.mix_the_moving_signal_against": "Mix — the moving signal against the dry one",
+ "device.auto_pan.panner_bypassed_the_signal_passes": "Panner bypassed: the signal passes unchanged",
+ "device.auto_pan.phase_0_l_and_r": "Phase 0°: L and R move together, the level dips to ",
+ "device.auto_pan.phase_the_right_lfo_against": "Phase — the right LFO against the left: 0° tremolo, 90° a circling pan, 180° auto-pan",
+ "device.auto_pan.rate_the_free_lfo_rate": "Rate — the free LFO rate, 0.01 … 40 Hz",
+ "device.auto_pan.rate_the_note_value_of": "Rate — the note value of one LFO cycle, 4/1 … 1/32 with dotted (D) and triplet (T) values",
+ "device.auto_pan.shape_sharpens_sine_tri_and": "Shape — sharpens Sine, Tri and Saw toward a square; on S&H it is Glide, the slide from one step to the next",
+ "device.auto_pan.the_channels_output_peak_60": "The channel's output peak, −60 … 0 dBFS, and the gain the LFO gives it now, dB",
+ "device.auto_pan.the_lfo_shape_s_h": "The LFO shape. S&H draws a random step every cycle; the right channel plays the same steps Phase later",
+ "device.auto_pan.what_the_phase_makes_tremolo": "What the phase makes: tremolo near 0°, auto-pan near 180°, an offset pan between",
+ "device.auto_pan.where_the_sound_sits_now": "Where the sound sits now between left and right, over the swing the LFO covers",
+ "device.auto_shift.amount_how_far_the_voice": "Amount — how far the voice is pulled to the note",
+ "device.auto_shift.amount_how_far_the_voice_2": "Amount — how far the voice is pulled to the target note",
+ "device.auto_shift.bend_the_widest_move_between": "Bend — the widest move between notes that bends over Glide; wider leaps jump",
+ "device.auto_shift.custom_edit_on_the_scale": "Custom — edit on the Scale tab",
+ "device.auto_shift.follow_copy_the_key_and": "Follow — copy the key and scale of a Nota Scale MIDI effect",
+ "device.auto_shift.follow_copy_the_key_and_2": "Follow — copy the key and scale of a Nota Scale MIDI effect (this track, the MIDI source, or the first one found)",
+ "device.auto_shift.follow_scale_device": "Follow Scale device",
+ "device.auto_shift.from_the_instrument_track_whose": "From — the instrument track whose notes set the target (its MIDI clips and effects, even when muted)",
+ "device.auto_shift.glide_how_long_the_target": "Glide — how long the target bends from one note to the next (Pitch bend from MIDI)",
+ "device.auto_shift.how_long_each_note_was": "How long each note was sung (the last ~16 bars) over the scale's notes — neutral in the scale, teal outside it. Click a column to add or remove its note",
+ "device.auto_shift.human_keeps_vibrato_and_slow": "Human — keeps vibrato and slow drift around the corrected note (0 = flat)",
+ "device.auto_shift.key_source_auto_follows_the": "Key source — Auto follows the key you sing, Manual uses the key and scale you set, MIDI takes the target from another track's notes (MIDI tab)",
+ "device.auto_shift.key_source_is_not_midi": "Key Source is not MIDI",
+ "device.auto_shift.key_the_tonic_the_scales": "Key — the tonic; the scale's notes are counted from it",
+ "device.auto_shift.latch_holds_the_target_between": "latch holds the target between notes",
+ "device.auto_shift.latch_keep_the_last_target": "Latch — keep the last target between notes (off = no correction while no note is held)",
+ "device.auto_shift.learn_listen_to_what_is": "Learn — listen to what is sung, then click again to set the key and scale that fit it best",
+ "device.auto_shift.no_correction_between_notes": "no correction between notes",
+ "device.auto_shift.no_note_held": "no note held",
+ "device.auto_shift.note_the_voice_goes_to": "Note — the voice goes to the last held note; Scale — the held notes form the scale",
+ "device.auto_shift.oct_lock_the_notes_own": "Oct lock — the note's own octave (off = whichever octave of it is nearest the voice)",
+ "device.auto_shift.out_of_scale": "out of scale",
+ "device.auto_shift.pick_a_track_in_from": "pick a track in FROM",
+ "device.auto_shift.pitch_bend_from_midi": "Pitch bend from MIDI",
+ "device.auto_shift.pitch_bend_from_midi_moves": "Pitch bend from MIDI — moves between notes bend over Glide when they are within Bend; off = the target steps",
+ "device.auto_shift.preserve_formants_the_vowel_colour": "Preserve formants — the vowel colour stays put while the pitch moves (off = it moves with the pitch, like a tape speed-up)",
+ "device.auto_shift.range_the_largest_correction_a": "Range — the largest correction; a note further off than this is only pulled this far",
+ "device.auto_shift.scale_chromatic_major_minor_pentatonic": "Scale — Chromatic, Major, Minor, Pentatonic (major or minor — click again to swap) or Custom (the notes below)",
+ "device.auto_shift.scale_the_notes_the_voice": "Scale — the notes the voice is pulled to",
+ "device.auto_shift.sing_a_few_bars": "sing a few bars",
+ "device.auto_shift.skip_sibilants_s_sh_t": "Skip sibilants — s, sh, t and breath pass unshifted, so they don't turn metallic",
+ "device.auto_shift.source_sets_the_detection_range": "Source — sets the detection range for a voice type or an instrument",
+ "device.auto_shift.speed_how_fast_the_retune": "Speed — how fast the retune glides (2 ms = hard tune)",
+ "device.auto_shift.speed_how_fast_the_voice": "Speed — how fast the voice follows the target",
+ "device.auto_shift.the_correction_now_up_or": "The correction now — up or down from the centre, full height = 2 semitones",
+ "device.auto_shift.the_detected_pitch_low_to": "The detected pitch, low to high across the detection range (Detect tab)",
+ "device.auto_shift.the_detected_pitch_teal_dots": "The detected pitch (teal dots) and the corrected output (neutral ink) over the last two seconds, on the scale's note lanes; the target lane is lit",
+ "device.auto_shift.the_key_that_fits_what": "The key that fits what was sung (Krumhansl profiles over the last ~16 bars), and the runner-up. Learn sets it; Auto follows it",
+ "device.auto_shift.the_source_tracks_notes_neutral": "The source track's notes (neutral blocks, accent while sounding) and the voice (teal) over the last two seconds — with Key Source MIDI the voice is pulled to the notes",
+ "device.auto_shift.what_the_detector_hears_now": "What the detector hears now and the correction applied — or, with Key Source MIDI, the note the voice is pulled to",
+ "device.bass.cut_pitch_wheel": "→ cut/pitch · wheel",
+ "device.bass.mod_wheel_opens_the_lfo": "Mod wheel — opens the LFO onto the cutoff",
+ "device.bass.slide_into_a_note_played": "Slide into a note played over a held one without a new attack",
+ "device.beat_repeat.capture_and_repeat": "Capture and repeat",
+ "device.beat_repeat.captured_sound_repeating": "Captured sound · repeating",
+ "device.beat_repeat.chance_how_likely_each_interval": "Chance — how likely each interval fires a repeat",
+ "device.beat_repeat.each_repeat_lower_and_narrower": "each repeat lower and narrower",
+ "device.beat_repeat.each_repeat_lower_same_band": "each repeat lower, same band",
+ "device.beat_repeat.filter_off_or_a_low": "Filter — Off, or a low-pass, band-pass or high-pass on the repeats",
+ "device.beat_repeat.freq_the_filters_frequency": "Freq — the filter's frequency",
+ "device.beat_repeat.gate_how_long_the_burst": "Gate — how long the burst lasts, in 16ths of the interval",
+ "device.beat_repeat.grid_the_length_of_the": "Grid — the length of the slice that repeats",
+ "device.beat_repeat.interval_how_often_it_rolls": "Interval — how often it rolls Chance",
+ "device.beat_repeat.interval_how_often_it_rolls_2": "Interval — how often it rolls Chance: 1/8, 1/4, 1/2 note, or every 1, 2, 4 bars",
+ "device.beat_repeat.latch_the_repeat_button_stays": "Latch — the Repeat button stays on after a click instead of only while held",
+ "device.beat_repeat.mode_mix_the_repeats_play": "Mode — Mix: the repeats play over the dry; Insert: they replace it while they play; Gate: only the burst sounds",
+ "device.beat_repeat.narrow_with_repeats": "Narrow with repeats",
+ "device.beat_repeat.narrow_with_repeats_each_repeat": "Narrow with repeats — each repeat narrows the band and moves it with the pitch",
+ "device.beat_repeat.offset_where_in_the_interval": "Offset — where in the interval it fires, in 16ths",
+ "device.beat_repeat.pitch_decay_each_repeat_drops": "Pitch decay — each repeat drops lower, up to 6 semitones a repeat",
+ "device.beat_repeat.pitch_the_repeats_transposed_12": "Pitch — the repeats transposed, ±12 semitones",
+ "device.beat_repeat.repeat_filter_off": "Repeat filter · off",
+ "device.beat_repeat.repeat_filter_the_repeats_go": "Repeat filter — the repeats go through the filter (Filter tab)",
+ "device.beat_repeat.repeat_repeat_the_current_slice": "Repeat — repeat the current slice now, for as long as it is held (with Latch: click on, click off)",
+ "device.beat_repeat.reset_stop_the_repeat_and": "Reset — stop the repeat and clear the timeline and the meters",
+ "device.beat_repeat.the_grid_holds_still": "the grid holds still",
+ "device.beat_repeat.the_input_level": "The input level",
+ "device.beat_repeat.the_last_intervals_sound_teal": "The last interval's sound (teal) on the grid: the gate from the offset is shaded and the captured slice is brass. Drag the offset line or the gate's end sideways; ⌥-click to type, double-click resets.",
+ "device.beat_repeat.the_repeat_filter_only_the": "The repeat filter — only the repeats go through it. Solid: the first repeat; teal dashed: a later one when the band narrows and follows the pitch. Drag the node for the frequency, a band edge for the width; ⌥-click to type, double-click resets.",
+ "device.beat_repeat.the_repeats_level_after_pitch": "The repeats' level — after pitch, filter, decay and volume",
+ "device.beat_repeat.the_repeats_pass_unfiltered": "the repeats pass unfiltered",
+ "device.beat_repeat.the_same_on_every_repeat": "the same on every repeat",
+ "device.beat_repeat.triplet_the_grid_in_triplets": "Triplet — the grid in triplets (a third shorter)",
+ "device.beat_repeat.two_intervals_on_the_grid": "Two intervals on the grid: each step is the input's level — dim when dry, full where the slice is captured, dimmer with every repeat as it decays. Ticks at the top mark where the interval fires.",
+ "device.beat_repeat.variation_the_grid_floats_up": "Variation — the grid floats up to this many steps (double / half) on each trigger",
+ "device.beat_repeat.what_the_repeater_is_doing": "What the repeater is doing now — waiting for the interval, capturing the slice, or repeating it — and where the transport is",
+ "device.beat_repeat.width_the_band_in_octaves": "Width — the band in octaves (low- and high-pass: less is more resonant)",
+ "device.bypassed": "Bypassed",
+ "device.bypassed_click_to_enable": "Bypassed — click to enable",
+ "device.card.bypassed": "Bypassed",
+ "device.card.changed_since_you_loaded_choose": "Changed since you loaded {0} · choose a preset",
+ "device.card.choose_a_preset": "Choose a preset",
+ "device.card.init": "Init",
+ "device.card.next_preset": "Next preset",
+ "device.card.previous_preset": "Previous preset",
+ "device.card.value": "Value",
+ "device.ceiling.auto_release_the_release_slows": "Auto release — the release slows as the reduction deepens (up to 5× at 7 dB), so dense passages don't pump",
+ "device.ceiling.ceiling_the_output_never_goes": "Ceiling — the output never goes above it (in dBTP with True peak on)",
+ "device.ceiling.character_clean_transparent_the_fastest": "Character — Clean: transparent, the fastest attack; Punch: a slower attack lets the transient through to the clip; Glue: a slow release and a soft knee under the ceiling",
+ "device.ceiling.delta_hear_what_it_removes": "Delta · hear what it removes",
+ "device.ceiling.delta_play_the_difference_between": "Delta — play the difference between the input and the output: what the limiter takes away",
+ "device.ceiling.gain_how_hard_the_signal": "Gain — how hard the signal is driven into the ceiling",
+ "device.ceiling.gain_reduction_0_24_db": "Gain reduction, 0 … 24 dB",
+ "device.ceiling.hearing_what_it_removes": "hearing what it removes",
+ "device.ceiling.integrated_loudness_since_the_last": "Integrated loudness since the last Reset, gated (BS.1770), against the Target",
+ "device.ceiling.internal_this_track": "Internal — this track",
+ "device.ceiling.key_source_internal_limits_on": "Key source — Internal limits on this track's own peaks; pick another track to duck this one when that one peaks",
+ "device.ceiling.lets_the_attack_through": "lets the attack through",
+ "device.ceiling.level_and_reduction": "Level and reduction",
+ "device.ceiling.momentary_teal_short_term_neutral": "Momentary (teal), short-term (neutral ink) and integrated (rose) loudness over the last 60 s around the target, ±1 LU shaded. Drag the target line; ⌥-click to type, double-click resets.",
+ "device.ceiling.release_how_fast_the_gain": "Release — how fast the gain comes back (the character scales it; Auto rel lets the signal decide)",
+ "device.ceiling.reset_peaks_clear_the_peak": "Reset peaks — clear the peak holds, the max reduction and the clip count",
+ "device.ceiling.reset_start_the_integrated_loudness": "Reset — start the integrated loudness, the range and the peaks again",
+ "device.ceiling.slow_and_dense": "slow and dense",
+ "device.ceiling.target_the_loudness_the_meters": "Target — the loudness the meters compare against: −14 for streaming, −16 podcasts, −23 broadcast. It does not change the sound; drag the dashed line for any value",
+ "device.ceiling.the_difference_in_out": "the difference in − out",
+ "device.ceiling.the_gain_reduction_over_the": "The gain reduction over the last 4 s: teal where a transient got through to the clip, the dashed line is the mean",
+ "device.ceiling.the_input_after_gain_with": "The input after Gain, with the ceiling marked",
+ "device.ceiling.the_last_4_s_the": "The last 4 s: the input (teal), the part over the ceiling (red) and the output (neutral ink), with the reduction under it. Drag the ceiling line; ⌥-click to type, double-click resets.",
+ "device.ceiling.true_peak_4": "true peak · 4×",
+ "device.ceiling.true_peak_the_detector_reads": "True peak — the detector reads the inter-sample peak (4×), so the ceiling holds in dBTP after conversion",
+ "device.ceiling.what_the_limiter_listens_to": "What the limiter listens to — or, with Delta on, that you are hearing only what it takes away",
+ "device.chamber.algorithm_share_of_the_blend": "Algorithm share of the blend (drags Blend)",
+ "device.chamber.at_the_input_before_both": "at the input, before both engines",
+ "device.chamber.at_the_output_dry_wet": "at the output, dry + wet",
+ "device.chamber.blend_convolution_slate_top_algorithm": "Blend — convolution (slate, top) ⇄ algorithm (neutral, bottom). Double-click: 50 / 50",
+ "device.chamber.concert_hall_wide": "Concert Hall · Wide",
+ "device.chamber.convolution_share_of_the_blend": "Convolution share of the blend (drags Blend)",
+ "device.chamber.drag_a_marker_to_set": "Drag a marker to set that band's RT60 (mid = Decay; low / high follow it as ratios). The Damping knob sets the high crossover. · ⌥-click to type",
+ "device.chamber.drag_the_trim_lines_to": "Drag the trim lines to trim the IR (Start · Decay); ⌥-click to type, double-click resets. Drop an audio file here to load it.",
+ "device.chamber.drop_an_impulse_response_here": "Drop an impulse response here (WAV / FLAC / MP3) or click Load…",
+ "device.chamber.dry_wet_double_click_resets": "Dry/Wet — double-click resets",
+ "device.chamber.ducking_the_wet_dips_up": "Ducking — the wet dips (up to 24 dB) while the input plays",
+ "device.chamber.eco_ir_up_to_3": "Eco: IR up to 3 s · Mid: 6 s · High: 10 s + cubic-interpolated algorithm modulation",
+ "device.chamber.feed_shimmer_back": "Feed shimmer back",
+ "device.chamber.freeze_hold_the_algorithm_tail": "Freeze — hold the algorithm tail forever; the input is muted",
+ "device.chamber.hold_in_keep_feeding_the": "Hold in — keep feeding the input into the frozen tail (layering)",
+ "device.chamber.impulse_response_built_in_rooms": "Impulse response — built-in rooms, or your own file (drop it on the waveform)",
+ "device.chamber.left_handle_low_cut_x": "Left handle: low cut (X) + low shelf (Y) · right handle: high cut (X) + high shelf (Y) · ⌥-click to type",
+ "device.chamber.load": "Load…",
+ "device.chamber.load_an_impulse_response_wav": "Load an impulse response (WAV / FLAC / MP3 — mono, stereo or 4-ch true stereo)",
+ "device.chamber.load_impulse_response": "Load impulse response…",
+ "device.chamber.on_exact_convolution_timing_at": "On: exact convolution timing at 0 ms predelay (FIR head, more CPU). Off: lighter — the first block arrives late and is absorbed into the predelay.",
+ "device.chamber.on_the_tail_before_dry": "on the tail, before Dry/Wet",
+ "device.chamber.parallel_both_engines_hear_the": "Parallel: both engines hear the input · Serial: the convolution feeds the algorithm",
+ "device.chamber.shimmer_pitch_shift": "Shimmer · pitch shift",
+ "device.chamber.shimmer_pitch_shift_caps": "SHIMMER · PITCH SHIFT",
+ "device.chamber.shimmer_shimmer_mode_only": "Shimmer · shimmer mode only",
+ "device.chamber.user_ir_none_loaded": "User IR (none loaded)",
+ "device.chamber.user_ir_none_loaded_2": "User IR — none loaded",
+ "device.chamber.wet_only_100_wet_no": "Wet only — 100 % wet, no dry: for a return / send track",
+ "device.chord.custom_your_own_shifts": "Custom: your own shifts",
+ "device.chord.drop_added_notes_outside_a": "Drop added notes outside {0} a semitone into it",
+ "device.chord.drop_added_notes_outside_the": "Drop added notes outside the scale a semitone into it",
+ "device.chord.fold_key_click_for_the": "Fold key — click for the next, Shift-click for the previous",
+ "device.chord.fold_scale_major_natural_minor": "Fold scale — major / natural minor",
+ "device.chord.in_voices": "In {0} · {1} · {2} voices",
+ "device.chord.in_voices_strum_ms_spread": "In {0} · {1} · {2} voices · strum {3} ms · spread {4}",
+ "device.chord.play_the_note_you_pressed": "Play the note you pressed as well as the added notes",
+ "device.chord.set_the_shifts_to": "{0}: set the shifts to {1}",
+ "device.chord.shift_drag_up_down_12": "Shift {0}: drag up / down (±12 semitones) · ⌥-click to type · double-click resets",
+ "device.chord.shift_on_off": "Shift {0} on / off",
+ "device.chord.shift_velocity_offset_drag_sideways": "Shift {0} velocity offset — drag sideways, ⌥-click to type, double-click resets",
+ "device.chorus.amount_at_zero_the_voices": "Amount at zero: the voices stand still, a static ",
+ "device.chorus.amount_how_far_the_lfo": "Amount — how far the LFO swings each voice's delay: more is wider detune",
+ "device.chorus.chorus_bypassed_the_signal_passes": "Chorus bypassed: the signal passes unchanged",
+ "device.chorus.classic_two_voices_left_and": "Classic — two voices, left and right; Ensemble — three voices 120° apart, a string-machine shimmer; Vibrato — the pitch wobble alone, no dry signal",
+ "device.chorus.detune_up_to": "Detune up to ±",
+ "device.chorus.draws_each_voices_delay_ct": "τ draws each voice's delay; ct its detune — how far the moving delay bends the pitch",
+ "device.chorus.each_voice_over_two_lfo": "Each voice over two LFO cycles — its delay (τ) or its detune (ct) — and where it is now. Drag up / down for Amount; ⌥-click types, double-click resets it.",
+ "device.chorus.feedback_the_voices_fed_back": "Feedback — the voices fed back into the line, ±90 %: a little thickens, past 60 % it rings metallic like a flanger",
+ "device.chorus.how_many_voices_sing_or": "How many voices sing, or that the feedback makes it ring (past 60 %), or that Vibrato plays wet only",
+ "device.chorus.hpf_a_high_pass_on": "HPF — a high-pass on the wet input (20 Hz … 2 kHz), so the lows stay dry and centred; far left is off",
+ "device.chorus.mix_0_dry_50_dry": "Mix — 0 % dry, 50 % dry and wet equal, 100 % the voices alone. Vibrato is always wet",
+ "device.chorus.offset_the_right_voices_lfo": "Offset — the right voice's LFO behind the left: 0° moves both together, 180° opposite. Ensemble spreads its three voices 120° apart on its own",
+ "device.chorus.rate_the_note_value_of": "Rate — the note value of one LFO cycle, 4/1 … 1/16 with triplet (T) values",
+ "device.chorus.the_largest_detune_the_sweep": "The largest detune the sweep reaches, ± cents (0 … 60 on the bar)",
+ "device.chorus.the_range_each_voices_delay": "The range each voice's delay sweeps, ms (0 … 24 on the bar)",
+ "device.chorus.vibrato_no_dry_signal_the": "Vibrato: no dry signal, the pitch swings ±",
+ "device.chorus.warmth_a_bucket_brigade_flavour": "Warmth — a bucket-brigade flavour on the delay line: darker (low-pass down to 2.5 kHz) and gently saturated",
+ "device.chorus.where_the_voices_sit_in": "Where the voices sit in the stereo field (Width) and how far each is detuned right now",
+ "device.chorus.width_0_the_voices_fold": "Width 0 %: the voices fold to mono, no space",
+ "device.chorus.width_the_voices_stereo_spread": "Width — the voices' stereo spread: 0 % mono, 100 % as they are, 200 % lifts the side by +6 dB",
+ "device.comp.no_key_signal": "no key signal",
+ "device.compressor.auto_gain_make_up_that": "Auto gain — make-up that follows the threshold and ratio",
+ "device.compressor.auto_release_a_slower_second": "Auto-release — a slower second release once the reduction runs deep, so sustained material does not pump",
+ "device.compressor.character_the_voicing_clean_as": "Character — the voicing: Clean as set, Glue slower and softer, Punch faster, Opto slow and program-soft, FET very fast",
+ "device.compressor.detector_peak_reacts_to_every": "Detector — Peak reacts to every transient, RMS to the body, Auto follows the body and still catches the spikes",
+ "device.compressor.drag_sideways_for_the_threshold": "Drag sideways for the threshold, up / down for the ratio. Double-click resets both. The dot is the key level right now.",
+ "device.compressor.external_key_key_off_the": "External key — key off the source picked on the Sidechain tab; off, the track keys itself",
+ "device.compressor.gain_reduction_over_the_last": "Gain reduction over the last four seconds; the dashed line is the peak. Click to clear it.",
+ "device.compressor.key_audible_output_muted": "key audible · output muted",
+ "device.compressor.key_gain_drives_the_detector": "Key gain — drives the detector harder or softer. ⌥-click types, double-click resets.",
+ "device.compressor.key_source_internal_keys_off": "Key source — Internal keys off this track; pick another track, or one pad or chain of it, to duck or pump against it",
+ "device.compressor.listen_hear_the_filtered_key": "Listen — hear the filtered key instead of the output, to set HP / LP by ear",
+ "device.compressor.make_up_gain_click_types": "Make-up gain. ⌥-click types, double-click resets.",
+ "device.compressor.no_reduction_to_measure": "no reduction to measure",
+ "device.compressor.stereo_link_one_reduction_for": "Stereo link — one reduction for both channels; off, left and right compress on their own",
+ "device.compressor.the_keys_spectrum_under_its": "The key's spectrum under its filters — drag a handle sideways to move HP / LP, up / down for Q. ⌥-click a handle to type it, double-click to open it.",
+ "device.compressor.the_reduction_neutral_ink_hanging": "The reduction (neutral ink, hanging from 0 dB) against the input level (teal) — attack is the fall, release the climb back. The dashed line is the threshold.",
+ "device.compressor.threshold_the_tick_is_the": "Threshold — the tick is the key's level right now. ⌥-click types, double-click resets.",
+ "device.compressor.where_the_source_is_tapped": "Where the source is tapped: before its effects and fader, or after — for a pad or chain, before its own effects, or after them and its level",
+ "device.consort.a_cable_breaks_the_normal": "A cable breaks the normal at Gate / Filt in / VCA in / Ext in · loops run with a one-sample delay",
+ "device.consort.all_normals_intact": "all normals intact",
+ "device.consort.analog_delay_bbd": "Analog delay · BBD",
+ "device.consort.attenuators_scale_whatever_is_patched": "Attenuators scale whatever is patched into Atten 1/2 in; Sum adds its inputs",
+ "device.consort.cables": { "one": "{0} cable", "other": "{0} cables" },
+ "device.consort.cables_points": "{0} cables · {1} points",
+ "device.consort.clock_out_patch_bay": "Clock out (patch bay)",
+ "device.consort.depth": "{0} · depth {1:+0;−0;0}",
+ "device.consort.depth_drag_up_down_click": "Depth — drag up / down (⌥-click to type, double-click: +50)",
+ "device.consort.drag_jack_to_jack_alt": "Drag jack to jack · Alt-click to pull · right-click for a list",
+ "device.consort.ext_normalled_to_the_vca": "EXT: normalled to the VCA output (Moog feedback) — patch Ext in to replace it",
+ "device.consort.filt_1_cutoff_input": "Filt 1 cutoff input",
+ "device.consort.filt_2_cutoff_input": "Filt 2 cutoff input",
+ "device.consort.gated_glide_only_between_overlapping": "Gated glide: only between overlapping (legato) notes",
+ "device.consort.jack_strip_points": "Jack strip · {0} points · ",
+ "device.consort.lfo_out_patch_bay": "LFO out (patch bay)",
+ "device.consort.lfo_pitch_all_oscillators_or": "LFO pitch → all oscillators, or only 2 and 4",
+ "device.consort.lfo_rate_input_patch_bay": "LFO rate input (patch bay)",
+ "device.consort.matrix_view_drag_a_cell": "Matrix view · drag a cell for depth, ⌥-click to type it, double-click to remove · ",
+ "device.consort.off_seq_steps_transposed_by": "Off · SEQ (steps transposed by the key) · ARP (the held chord over 1–3 octaves)",
+ "device.consort.open_the_full_patch_bay": "Open the full patch bay (all 42 points) · on the Patch tab: back to the last panel",
+ "device.consort.os_0_smp_cpu": "{0} · ×{1} OS · 0 smp · CPU {2:0} %",
+ "device.consort.osc_pitch_input_patch_bay": "Osc {0} pitch input (patch bay)",
+ "device.consort.oscillator_s_note_paraphonic_the": "Oscillator {0}'s note (paraphonic) · the latest voices in true poly",
+ "device.consort.paint_steps_alt_click_a": "Paint {0} steps (Alt-click a step: rest)",
+ "device.consort.pitch_arp_step_types_shape": "Pitch · arp (step types shape the rhythm)",
+ "device.consort.pitch_step_offsets_from_the": "Pitch · step offsets from the key",
+ "device.consort.pulse_width_of_the_pulse": "Pulse width of the pulse wave (square stays 50 %)",
+ "device.consort.ratchet_repeats_per_step": "Ratchet repeats per step",
+ "device.consort.remove": "Remove {0} {1:+0;−0;0}",
+ "device.consort.seq_gate_out_patch_bay": "Seq gate out (patch bay)",
+ "device.consort.sequence_length_drag_up_down": "Sequence length — drag up / down",
+ "device.consort.sequencer_off_pick_seq_or": "Sequencer off · pick SEQ or ARP, then hold a key",
+ "device.consort.step_rate_synced_to_the": "Step rate (synced to the host tempo)",
+ "device.consort.sync_to_host_bpm_cpu": "{0} · sync to host {1:0} BPM · CPU {2:0} %",
+ "device.consort.true_poly_16": "True poly (16)",
+ "device.crush.anti_alias_a_4th_order": "Anti-alias — a 4th-order low-pass at the reduced rate's Nyquist before the hold, so less folds back as images",
+ "device.crush.auto_gain_rides_the_output": "Auto gain — rides the output back to the input's loudness (300 ms RMS, ±24 dB), so turning Bits or Drive doesn't jump in level",
+ "device.crush.bits_the_bit_depth_1": "Bits — the bit depth, 1 … 24: fewer bits, fewer levels, more grit",
+ "device.crush.dc_filter_a_10_hz": "DC filter — a 10 Hz high-pass on the crushed signal: takes out the offset a coarse, folded or noisy crush can leave",
+ "device.crush.dither_up_to_lsb_of": "Dither — up to ±½ LSB of triangular noise before the levels: softens the steps into hiss",
+ "device.crush.drive_12_24_db_into": "Drive — −12 … +24 dB into the crusher: pushes the signal up the levels, into the Analog clip or into more folds",
+ "device.crush.input_output_through_drive_the": "Input → output through Drive, the mode and the levels; the dot is where the signal peaks. Drag up / down for Drive; ⌥-click types, double-click resets.",
+ "device.crush.jitter_the_hold_length_wanders": "Jitter — the hold length wanders up to ±50 %: an unsteady, broken clock",
+ "device.crush.level_step_shown_enlarged": "level step shown enlarged",
+ "device.crush.levels_after_the_fold": " levels after the fold",
+ "device.crush.mode_digital_hard_truncation_to": "Mode — Digital: hard truncation to the levels; Analog: a soft tanh clip before them (+4 dB, rounder); Fold: a wavefolder — more Drive folds the peaks back more times",
+ "device.crush.noise_a_white_noise_floor": "Noise — a white noise floor under the crush, up to −50 dBFS",
+ "device.crush.output_gain_12_db": "Output gain, ±12 dB",
+ "device.crush.peaks_in_and_out_and": "Peaks in and out, and the output's crest factor (peak over RMS) — the crush flattens it",
+ "device.crush.post_filter_a_low_pass": "Post filter — a low-pass after the crush, 200 Hz … 20 kHz: under the Nyquist it smooths the steps",
+ "device.crush.rate_the_reduced_sample_rate": "Rate — the reduced sample rate, 500 Hz … full: lower holds each value longer and adds images above its Nyquist",
+ "device.crush.the_filter_cuts_the_images": "the filter cuts the images",
+ "device.crush.the_input_peak_60_0": "The input peak, −60 … 0 dBFS",
+ "device.crush.the_output_peak_60_0": "The output peak, −60 … 0 dBFS",
+ "device.crush.the_output_spectrum_neutral_ink": "The output spectrum: neutral ink is the signal, teal what the crush added — bright above the reduced Nyquist (the images). Drag the Nyquist line for Rate, the filter line for the post filter; ⌥-click types, double-click resets.",
+ "device.crush.two_cycles_of_a_sine": "Two cycles of a sine at the driven level (dashed) and what comes out",
+ "device.crush.wet_the_crushed_signal_against": "Wet — the crushed signal against the dry one",
+ "device.crush.what_comes_out_the_bit": "What comes out: the bit depth and the rate, and whether the post filter cuts the images above the reduced Nyquist or lets them through",
+ "device.delay.clear_loop": "Clear loop",
+ "device.delay.empty_the_delay_buffer_silences": "Empty the delay buffer — silences what is still circulating",
+ "device.delay.fade_on_change_crossfade_to": "Fade on change — crossfade to a new delay time instead of gliding to it (which bends the pitch, tape style)",
+ "device.delay.feedback_how_much_of_each": "Feedback — how much of each repeat goes round again; Freeze pins it at 100 %. ⌥-click types, double-click resets.",
+ "device.delay.freeze_hold_the_loop_forever": "Freeze — hold the loop forever; the input is muted and the repeats stop decaying",
+ "device.delay.latency_comp": "Latency comp.",
+ "device.delay.link_l_r_the_right": "Link L/R — the right channel follows the left's time",
+ "device.delay.loop_held_no_decay": "LOOP HELD · no decay",
+ "device.delay.ping_pong_each_repeat_crosses": "Ping-pong — each repeat crosses to the other channel",
+ "device.delay.spread_pushes_the_right_channel": "Spread — pushes the right channel later, up to 50 ms. ⌥-click types, double-click resets.",
+ "device.delay.tap_four_times_to_set": "Tap four times to set the delay time by ear (switches to free ms)",
+ "device.delay.tap_tempo": "Tap tempo",
+ "device.delay.the_band_the_repeats_live": "The band the repeats live in — drag the left handle for the low cut, the right one for the high cut. ⌥-click a handle to type it, double-click to open it.",
+ "device.delay.the_diffuser_lengthens_the_loop": "The diffuser lengthens the loop by a fixed group delay; on, the read pointer is pulled back by exactly that so each repeat lands on the set time.",
+ "device.delay.the_repeat_train_l_above": "The repeat train — L above the axis, R below. Height is the level left after each pass; the repeat sounding now is lit.",
+ "device.delay.wet_only_repeats_with_no": "Wet only — repeats with no dry, for a return / send track",
+ "device.dynamic_eq.attack_how_fast_the_band": "Attack — how fast the band moves toward its range",
+ "device.dynamic_eq.band_on": "Band on",
+ "device.dynamic_eq.band_on_off_leaves_the": "Band on — off leaves the band out of the signal (double-click its node does the same)",
+ "device.dynamic_eq.drag_a_node_frequency_and": "Drag a node — frequency and gain · wheel over a node — Q · double-click a node — band on / off · ",
+ "device.dynamic_eq.duck_acts_above_the_threshold": "Duck — acts above the threshold",
+ "device.dynamic_eq.dynamic_off_parks_every_band": "Dynamic — off parks every band on its static gain: hear what the dynamics do",
+ "device.dynamic_eq.flip_cut_boost_a_duck": "Flip — cut ↔ boost (a Duck that boosts is upward expansion, a Lift that cuts is downward expansion)",
+ "device.dynamic_eq.frequency_or_drag_the_node": "Frequency — or drag the node left / right",
+ "device.dynamic_eq.gain_the_static_gain_or": "Gain — the static gain; or drag the node up / down",
+ "device.dynamic_eq.key_self_the_band_listens": "Key — Self: the band listens to this track · Ext: to the key track (click Ext again to pick the track)",
+ "device.dynamic_eq.lift_acts_as_it_falls": "Lift — acts as it falls below it (a boost by default)",
+ "device.dynamic_eq.lift_acts_below_the_threshold": "Lift — acts below the threshold",
+ "device.dynamic_eq.output_drag_up_down_shift": "Output — drag up / down (Shift for fine), ⌥-click to type, double-click for 0 dB",
+ "device.dynamic_eq.q_the_width_the_resonance": "Q — the width (the resonance on the cuts); or the wheel over the node",
+ "device.dynamic_eq.range_how_far_the_gain": "Range — how far the gain can move at full engagement (6 dB past the threshold); click the arrow to flip cut / boost",
+ "device.dynamic_eq.release_how_fast_it_returns": "Release — how fast it returns to its static gain",
+ "device.dynamic_eq.solo_hear_this_band_alone": "Solo — hear this band alone",
+ "device.dynamic_eq.static_a_plain_eq_band": "Static — a plain EQ band · Duck — acts as the band's level rises above the threshold (a cut by default) · ",
+ "device.dynamic_eq.the_selected_bands_dynamic_gain": "The selected band's dynamic gain right now",
+ "device.dynamic_eq.threshold_where_the_band_starts": "Threshold — where the band starts to act; the teal mark is the band's level now",
+ "device.dynamic_eq.type_high_pass_low_shelf": "Type — high-pass, low shelf, bell, notch, high shelf, low-pass; only shelves and bells take gain and dynamics",
+ "device.eq.analyzer_pre_the_input_spectrum": "Analyzer — Pre: the input spectrum · Post: the output over a dimmer input · Off",
+ "device.eq.analyzer_range_the_graphs_bottom": "Analyzer range — the graph's bottom edge, in dB below 0 dBFS",
+ "device.eq.auto_gain_adds_the_opposite": "Auto gain — adds the opposite of the shelves' and bells' average level, so edits are judged at the same loudness",
+ "device.eq.band_on_off_leaves_the": "Band on — off leaves the band out of the signal (double-click its node does the same)",
+ "device.eq.channel_st_both_channels_mid": "Channel — St: both channels · Mid: the centre · Side: the edges · L / R: one channel alone",
+ "device.eq.drag_a_node_frequency_and": "Drag a node — frequency and gain · wheel over a node — Q · double-click a node — band on / off · ",
+ "device.eq.enter_or_esc_to_close": "Enter or Esc to close",
+ "device.eq.frequency_or_drag_the_node": "Frequency — or drag the node left / right",
+ "device.eq.gain_or_drag_the_node": "Gain — or drag the node up / down (Scale multiplies it)",
+ "device.eq.label_a_short_name_shown": "Label — a short name shown next to the band's node (up to 24 characters)",
+ "device.eq.labels_show_the_bands_labels": "Labels — show the bands' labels and note marks in the graph (the chips and the band panel keep them)",
+ "device.eq.name_this_band": "Name this band",
+ "device.eq.note_a_longer_note_on": "Note — a longer note on what this band is for",
+ "device.eq.output_plus_the_auto_gain": "Output (plus the auto gain in effect) — drag up / down (Shift for fine), ⌥-click to type, double-click for 0 dB",
+ "device.eq.output_the_level_after_the": "Output — the level after the EQ, ±12 dB",
+ "device.eq.peak_hold_a_thin_line": "Peak hold — a thin line at each frequency's highest level of the last moments",
+ "device.eq.q_the_width_the_resonance": "Q — the width (the resonance on the cuts); or the wheel over the node",
+ "device.eq.scale_multiplies_every_shelf_and": "Scale — multiplies every shelf and bell gain: 100 % as set, 0 % flat, 200 % twice as much",
+ "device.eq.slope_how_steep_the_high": "Slope — how steep the high-pass / low-pass falls: 12, 24 or 48 dB per octave",
+ "device.eq.type_high_pass_low_shelf": "Type — high-pass, low shelf, bell, notch, high shelf, low-pass; only shelves and bells take gain",
+ "device.eq.what_this_band_is_for": "What this band is for",
+ "device.eq3.crossover_slope_linkwitz_riley_24": "Crossover slope — Linkwitz-Riley 24 or 48 dB/oct: steeper touches the neighbours less",
+ "device.eq3.drag_up_down_for_the": "Drag up / down for the band's gain (Shift for fine steps); ⌥-click types it; double-click resets to 0 dB and lifts the kill",
+ "device.eq3.each_band_in_its_colour": "Each band in its colour, the sum in brass, the output spectrum behind. Drag a crossover handle left / right; drag anywhere else to ride that band's gain. Double-click resets, ⌥-click types.",
+ "device.eq3.kill_the_band_removes_it": "Kill the {0} band — removes it outright, with a 5 ms glide",
+ "device.eq3.low_mid_crossover": "Low / mid crossover",
+ "device.eq3.mid_high_crossover": "Mid / high crossover",
+ "device.eq3.output_gain_24_db_drag": "Output gain, ±24 dB — drag up / down (Shift for fine), ⌥-click types, double-click resets",
+ "device.eq8.band_on": "Band on",
+ "device.flanger.delay_the_centre_of_the": "Delay — the centre of the sweep, 0.1 … 8 ms: shorter puts the notches higher",
+ "device.flanger.depth_at_zero_the_comb": "Depth at zero: the comb stands still, a static effect",
+ "device.flanger.depth_how_far_the_lfo": "Depth — how far the LFO swings the delay around its centre",
+ "device.flanger.feedback_0_a_plain_comb": "Feedback 0: a plain comb",
+ "device.flanger.feedback_70_hollow": "Feedback −70 %: hollow",
+ "device.flanger.feedback_70_the_classic_jet": "Feedback +70 %: the classic jet",
+ "device.flanger.feedback_the_delayed_signal_fed": "Feedback — the delayed signal fed back in, ±95 %: positive for the classic jet, negative for a hollow tone",
+ "device.flanger.flanger_bypassed_the_signal_passes": "Flanger bypassed: the signal passes unchanged",
+ "device.flanger.how_deep_the_notches_cut": "How deep the notches cut, dB (0 … −36 on the bar)",
+ "device.flanger.mix_50_gives_the_deepest": "Mix — 50 % gives the deepest notches; 100 % is the delayed signal alone, a vibrato",
+ "device.flanger.rate_the_note_value_of": "Rate — the note value of one LFO cycle, 2/1 … 1/16 with dotted (D) and triplet (T) values",
+ "device.flanger.stereo_the_right_lfo_against": "Stereo — the right LFO against the left: 0° sweeps both together, 90° spreads them, 180° moves them opposite",
+ "device.flanger.the_comb_the_delay_carves": "The comb the delay carves into the spectrum, L neutral and R teal, with the first notch dashed. Drag left / right to move the notch (Delay), up / down for Feedback; ⌥-click types, double-click resets both.",
+ "device.flanger.the_delay_of_both_channels": "The delay τ of both channels over two LFO cycles, and where each is now",
+ "device.flanger.the_first_notch_now_over": "The first notch now, over the range the sweep moves it (20 Hz … 20 kHz)",
+ "device.flanger.the_lfo_shape_that_sweeps": "The LFO shape that sweeps the delay: Sine glides, Tri sweeps evenly, Saw rises and drops back",
+ "device.flanger.what_the_feedback_makes_positive": "What the feedback makes: positive sharpens the peaks, negative hollows the tone, past 85 % the comb rings",
+ "device.flux.assign_a_source_to_turn": "→ assign a source to turn the reaction on",
+ "device.flux.choose_the_track_flux_listens": "Choose the track Flux listens to — or one pad, chain or voice of it",
+ "device.flux.click_to_change_the_motion": "Click to change the Motion sync rate",
+ "device.flux.cutoff_of_range": "cutoff +{0} of range",
+ "device.flux.dashed_where_the_reaction_pulls": "dashed — where the reaction pulls",
+ "device.flux.drag_to_blend_the_four": "Drag to blend the four timbres · ⌥-click to type · double-click to reset",
+ "device.flux.one_knob_each": "one knob each",
+ "device.flux.target_what_the_reaction_drives": "Target — what the reaction drives",
+ "device.flux.the_sidechain_bends_the_pitch": "→ the sidechain bends the pitch up",
+ "device.flux.the_sidechain_drags_the_vector": "→ the sidechain drags the vector in rhythm",
+ "device.flux.the_sidechain_opens_the_filter": "→ the sidechain opens the filter",
+ "device.flux.the_sidechain_swells_the_space": "→ the sidechain swells the space",
+ "device.flux.the_synth_listens_to_a": "the synth listens to a track",
+ "device.flux.transients_per_bar": { "one": "{0} transient per bar", "other": "{0} transients per bar" },
+ "device.flux_react.no_source_assigned": "no source assigned",
+ "device.forge.amount_0_30_db_into": "Amount — 0 … +30 dB into the stages. Drag the curve up / down for the same",
+ "device.forge.bias_the_stages_asymmetry_100": "Bias — the stage's asymmetry, −100 … +100 %: pushes the curve off-centre, adding even harmonics",
+ "device.forge.digital_fold_without_oversampling_alias": "Digital / Fold without oversampling alias: switch on 2× or more",
+ "device.forge.env_tone": "env → tone {0}",
+ "device.forge.env_tone_loud_parts_push": "Env → Tone — loud parts push the tone brighter",
+ "device.forge.harmonics_2_9_of_a": "Harmonics 2 … 9 of a −6 dB sine through the curve: odd partials in full ink (hard, buzzy), even ones dimmer (warm, round), and the total harmonic distortion",
+ "device.forge.input_output_through_the_device": "Input → output through the device (in M/S and Multi through the selected stage): each stage alone faint, the LFO-modulated curve dashed teal, the node where the input sits now. Drag up / down for Amount; ⌥-click to type, double-click resets.",
+ "device.forge.lfo_drive_the_lfo_sweeps": "LFO → Drive — the LFO sweeps every stage's drive, up to ±30 %",
+ "device.forge.lfo_rate_free_0_05": "LFO rate — free 0.05 … 20 Hz, or with Sync a division from 2 bars to 1/64",
+ "device.forge.of_3_stages": "{0} of 3 stages",
+ "device.forge.output_24_24_db": "Output, −24 … +24 dB",
+ "device.forge.oversampling_runs_the_stages_at": "Oversampling — runs the stages at 2 / 4 / 8 × the rate so the harmonics above Nyquist don't fold back (minimum phase, no latency)",
+ "device.forge.routing_serial_1_2_3": "Routing — Serial: 1 → 2 → 3. Parallel: all three from the same input, averaged. M/S: stage 1 drives the Mid, stage 2 the Side, stage 3 the recombined stereo. Multi: stage 1 the lows (< 180 Hz), 2 the mids, 3 the highs (> 2.4 kHz)",
+ "device.forge.stage": "stage {0} · {1}",
+ "device.forge.stage_drive_how_hard_the": "Stage {0} drive — how hard the stage is pushed (gain 1 … ×21, the level made up)",
+ "device.forge.stage_feedback_its_output_back": "Stage {0} feedback — its output back into its input (0 … 85 %): thicker, and on the edge of ringing with Fold / Fuzz",
+ "device.forge.stage_on_off": "Stage {0} on / off",
+ "device.forge.stage_output_12_12_db": "Stage {0} output, −12 … +12 dB — drag up / down, ⌥-click to type, double-click resets",
+ "device.forge.sync_the_lfo_rate_as": "Sync — the LFO rate as a note division locked to the song, or free in Hz",
+ "device.forge.the_selected_stages_type_tube": "The selected stage's type — Tube: soft, asymmetric, warm; Tape: soft and even; Diode: hard on one side; Fuzz: squared-off, dense; Fold: folds the peaks back, bright and metallic; Digital: a hard clip",
+ "device.forge.tone_a_tilt_after_the": "Tone — a tilt after the stage, −12 … +12 dB around 800 Hz: darker or brighter distortion",
+ "device.forge.wet_the_forged_signal_against": "Wet — the forged signal against the dry one",
+ "device.forge.what_the_device_is_doing": "What the device is doing; the master Tone / Bias / Width offsets of older projects show here when set",
+ "device.forge.width_the_stages_stereo_image": "Width — the stage's stereo image, 0 … 200 % (in M/S, stage 2's width scales the side)",
+ "device.generic.open_gui": "Open GUI ↗",
+ "device.grain.blend_the_sample_itself_dry": "Blend the sample itself (dry) with the grain cloud (wet)",
+ "device.grain.drag_to_move_the_read": "Drag to move the read position · ⌥-click to type it · double-click to reset",
+ "device.grain.position_pitch_pan": "{0} · position · pitch · pan",
+ "device.grain.root_a_semitone_down": "Root a semitone down",
+ "device.grain.root_a_semitone_up": "Root a semitone up",
+ "device.grain.root_plays_the_sample_as": "Root {0} plays the sample as recorded · coarse 0 · fine 0",
+ "device.grain.scan_moves_through_the_file": "Scan moves through the file · Freeze holds Position · Key moves it with the note",
+ "device.grain.the_root_the_key_that": "The root — the key that plays the sample as recorded. Scroll to step it · double-click takes it from the file name (C4 if none)",
+ "device.grain.voices_grains_caps": "{0} {1}{2} · {3} VOICES · {4} GRAINS",
+ "device.keys.2_lines_bbd": "2 lines · BBD",
+ "device.keys.held_by_the_pedal": "{0} held by the pedal",
+ "device.keys.ringing_out": "{0} ringing out",
+ "device.keys.string_2_pickups": "String · 2 pickups",
+ "device.keys.sustain_pedal_click_to_hold": "Sustain pedal — click to hold it down; a keyboard's CC64 works too",
+ "device.keys.voices": "{0} / {1} voices",
+ "device.keys.voices_n": "{0} · {1} voices",
+ "device.length.1_bar_at_bpm_notes": "1 bar at {0:0} BPM · {1} notes",
+ "device.length.clip_length_limit": "Clip length limit",
+ "device.length.count_the_length_from_the": "Count the length from the note-on or the note-off — click to switch",
+ "device.length.count_the_length_from_the_2": "Count the length from the note-on, or from the note-off (the note fires when the key is released)",
+ "device.length.drag_up_down_double_click": "{0} — drag up / down, double-click resets",
+ "device.length.each_note_lasts_until_the": "Each note lasts until the next one starts (at most to the bar line)",
+ "device.length.from_avg_out": "{0} {1} · from {2} · avg out {3}",
+ "device.length.legato_retrigger_held": "Legato · retrigger held",
+ "device.length.length_drag_up_down_double": "Length — drag up / down, double-click resets",
+ "device.length.length_mode_sync_ms_gate": "Length mode: Sync / ms / Gate % — click for the next, Shift-click for the previous",
+ "device.length.loud_notes_longer_at": "loud notes longer at +",
+ "device.length.low_notes_longer_at": "low notes longer at +",
+ "device.length.no_note_crosses_the_bar": "No note crosses the bar line it started in",
+ "device.length.outline_in_fill_out_band": "Outline — in · fill — out · band — Random's range",
+ "device.length.outline_the_note_played_in": "Outline — the note played in · fill — the note out · band — the range Random spreads it over. The shaded part is past the bar line.",
+ "device.length.spread_per_note": "spread per note",
+ "device.length.sync_a_tempo_division_ms": "Sync: a tempo division · ms: a fixed time · Gate %: a share of how long each note was held",
+ "device.lens.arm_the_next_single_capture": "Arm the next Single capture",
+ "device.lens.crest_db_lufs": "crest {0:0.0} dB · LUFS {1:0.0}",
+ "device.lens.db_bin": "{0:0.0} dB · bin {1:0}",
+ "device.lens.export_the_lens_capture_to": "Export the Lens capture to WAV",
+ "device.lens.export_wav": "Export WAV",
+ "device.lens.freeze_stop_capturing_and_hold": "Freeze — stop capturing and hold what is on screen",
+ "device.lens.key_draw_another_tracks_audio": "Key — draw another track's audio over this one, in teal",
+ "device.lens.key_gain_scales_only_the": "Key gain — scales only the key's trace, for the eye (the sound is untouched)",
+ "device.lens.level_holdoff_ms": "level {0:0.00} · holdoff {1:0} ms",
+ "device.lens.mid_side": "Mid / Side",
+ "device.lens.move_over_the_graph": "move over the graph",
+ "device.lens.n_a_in_a_rack": "n/a in a rack",
+ "device.lens.open_lens_in_its_own": "Open Lens in its own window",
+ "device.lens.peak_db": "peak {0} · {1:0.0} dB",
+ "device.lens.period_ms_hz": "period {0:0.000} ms · {1:0.0} Hz",
+ "device.lens.row_ms_bins": "row {0:0} ms · {1} bins",
+ "device.lens.show_the_keys_trace": "Show the key's trace",
+ "device.lens.snap_to_peaks": "Snap to peaks",
+ "device.lens.span_how_much_of_the": "Span — how much of the song the scope shows, from a quarter beat to four bars",
+ "device.lens.sync_line_the_scope_up": "Sync — line the scope up with the song's beats and bars",
+ "device.lens.vpp_rms": "Vpp {0:0.000} · RMS {1:0.000}",
+ "device.lens.waterfall_bins_overlap_window_s": "Waterfall · {0} bins · {1} · overlap {2:0.#} % · window {3:0} s · floor {4:0} dB",
+ "device.lens.window_ms_slope_db_oct": "window {0:0} ms · slope {1:0.0} dB/oct",
+ "device.lens.write_the_captured_scope_window": "Write the captured scope window to a WAV file",
+ "device.midi.card_size_s_mini_l": "Card size: S (mini) / L (full)",
+ "device.midi.map_a_hardware_control_arm": "Map a hardware control: arm, touch a control on the card, move a knob or key",
+ "device.monolith.controllers_osc_bank": "Controllers · Osc Bank",
+ "device.mosaic.a_folder_of_samples": "a folder of samples",
+ "device.mosaic.a_new_empty_layer_move": "A new, empty layer — move zones into it from the rail",
+ "device.mosaic.blends_the_loops_end_into": "Blends the loop's end into its start (forward loops)",
+ "device.mosaic.busy_on_pedal_release": "{0} busy · {1} on pedal · {2} release",
+ "device.mosaic.click_a_key_to_make": "Click a key to make it the selected zone's root",
+ "device.mosaic.detect_from_file_name": "Detect from file name",
+ "device.mosaic.drag_left_right_for_the": "Drag: left / right for the cutoff, up / down for the resonance · Shift for fine steps · ⌥-click to type · double-click resets",
+ "device.mosaic.drag_the_nodes_attack_decay": "Drag the nodes: attack, decay and sustain (up / down), release · Shift for fine steps · ⌥-click to type · double-click resets",
+ "device.mosaic.drop_samples_or_a_folder": "Drop samples or a folder here · or pick a preset",
+ "device.mosaic.edit_this_zones_start_end": "Edit this zone's start, end and loop",
+ "device.mosaic.empty": "Empty",
+ "device.mosaic.empty_drop_samples_or_a": "Empty · drop samples or a folder, or pick a preset",
+ "device.mosaic.exclusive_group_off_by": "Exclusive · group / off by",
+ "device.mosaic.exclusive_is_for_hi_hats": "Exclusive is for hi-hats and valves: a new note chokes the off_by group.",
+ "device.mosaic.files": "{0} / {1} · {2} / {3} files",
+ "device.mosaic.files_n": { "one": "{0} file", "other": "{0} files" },
+ "device.mosaic.filter_off_the_samples_pass": "Filter off — the samples pass untouched",
+ "device.mosaic.fine_tune_of_the_whole": "Fine tune of the whole instrument, ±50 cents",
+ "device.mosaic.found_by_name": "{0} · {1} found by name: {2}",
+ "device.mosaic.group": "Group · {0}",
+ "device.mosaic.groups": "{0} groups · {1} · {2}",
+ "device.mosaic.how_far_the_key_moves": "How far the key moves the pitch — 100 % chromatic, 0 % every key plays the root",
+ "device.mosaic.how_fast_a_stolen_or": "How fast a stolen or superseded voice fades",
+ "device.mosaic.how_many_strikes_of_one": "How many strikes of one key may ring together",
+ "device.mosaic.how_much_quieter_a_release": "How much quieter a release sample gets the longer the key was held — drag up / down, ⌥-click to type",
+ "device.mosaic.how_much_velocity_sets_the": "How much velocity sets the level",
+ "device.mosaic.install_pack": "Install pack",
+ "device.mosaic.instruments": { "one": "{0} instrument", "other": "{0} instruments" },
+ "device.mosaic.layers": { "one": "{0} layer", "other": "{0} layers" },
+ "device.mosaic.let_the_amp_envelope_open": "Let the amp envelope open (or close) the filter",
+ "device.mosaic.loading": "Loading {0}",
+ "device.mosaic.loading_n": "Loading {0} %",
+ "device.mosaic.loading_notes_muted": "Loading · {0} / {1} · notes muted",
+ "device.mosaic.locate_folder": "Locate folder…",
+ "device.mosaic.locate_the_samples": "Locate the samples",
+ "device.mosaic.make_the_note_in_the": "Make the note in the zone's file name its root",
+ "device.mosaic.missing": " · {0} missing",
+ "device.mosaic.move_start_and_end_to": "Move Start and End to where the sound begins and fades out (−48 dB)",
+ "device.mosaic.move_start_end_and_the": "Move Start, End and the loop to the nearest zero crossing",
+ "device.mosaic.mpe_pressure_aftertouch_level": "MPE pressure (aftertouch) → level",
+ "device.mosaic.mpe_slide_cc74_cutoff": "MPE slide (CC74) → cutoff",
+ "device.mosaic.none_of_its_samples_were": "None of its {0} samples were found. Zone settings are kept — point Mosaic at the folder that holds them.",
+ "device.mosaic.notes_are_silent_until_loading": "Notes are silent until loading finishes",
+ "device.mosaic.off_plays_once_fwd_loops": "Off plays once · Fwd loops · Ping bounces — this zone only",
+ "device.mosaic.old_voice_fade": "Old voice fade",
+ "device.mosaic.open_in_sample": "Open in Sample",
+ "device.mosaic.opens_the_mapping_preview_a": "Opens the mapping preview. A single file replaces the sample, as before.",
+ "device.mosaic.pack_is_not_installed": "Pack “{0}” is not installed",
+ "device.mosaic.pick_the_folder_that_holds": "Pick the folder that holds the samples — Mosaic finds each file in it by its path or its name",
+ "device.mosaic.poly_chords_click_again_for": "Poly: chords (click again for the voice settings) · Mono: one at a time, legato with Glide · Choke: a new note cuts the ringing ones",
+ "device.mosaic.release_to_build_a_multisample": "Release to build a multisample",
+ "device.mosaic.release_to_load_the_sample": "Release to load the sample",
+ "device.mosaic.round_robin_steps_the_groups": "Round-robin steps: the group's zones take turns 1 … N (each zone's step is set by its file)",
+ "device.mosaic.sample_not_loaded": "Sample not loaded",
+ "device.mosaic.samples_are_not_copied_into": "Samples are not copied into the project; the program keeps where they are.",
+ "device.mosaic.samples_unavailable_notes_muted": "Samples unavailable · notes muted",
+ "device.mosaic.select_a_zone": "Select a zone",
+ "device.mosaic.settings_downloads_sample_packs": "Settings → Downloads → Sample packs",
+ "device.mosaic.shift_every_note_24_semitones": "Shift every note, ±24 semitones",
+ "device.mosaic.slide_from_the_last_note": "Slide from the last note — in Mono, legato",
+ "device.mosaic.snap_to_zero": "Snap to zero",
+ "device.mosaic.stop_loading_the_instrument_empties": "Stop loading — the instrument empties (undo brings it back)",
+ "device.mosaic.the_articulation_the_sfzs_controller": "The articulation — the SFZ's controller value its zones were chosen by",
+ "device.mosaic.the_cutoff_follows_the_key": "The cutoff follows the key",
+ "device.mosaic.the_level_after_everything": "The level after everything",
+ "device.mosaic.the_pitch_wheels_range_mpe": "The pitch wheel's range (MPE bends are per note)",
+ "device.mosaic.the_release_samples_level": "The release samples' level",
+ "device.mosaic.the_samples_arent_where_the": "The samples aren't where the program says",
+ "device.mosaic.the_sustain_pedal_a_keyboards": "The sustain pedal: a keyboard's CC64 holds released keys — click to stop listening to it",
+ "device.mosaic.the_zones_fine_tune_100": "The zone's fine tune, ±100 cents",
+ "device.mosaic.the_zones_fine_tune_drag": "The zone's fine tune — drag, wheel, double-click resets",
+ "device.mosaic.the_zones_level": "The zone's level",
+ "device.mosaic.the_zones_pan": "The zone's pan",
+ "device.mosaic.the_zones_root_drag_or": "The zone's root — drag or scroll",
+ "device.mosaic.this_groups_exclusive_number": "This group's exclusive number",
+ "device.mosaic.this_preset_uses_samples_from": "This preset uses {0} samples from the pack. Zone settings are kept, no sound until installed.",
+ "device.mosaic.this_zones_level": "This zone's level",
+ "device.mosaic.total_in_ram": "Total in RAM",
+ "device.mosaic.trim_silence": "Trim silence",
+ "device.mosaic.velocity_level_curve": "Velocity → level curve",
+ "device.mosaic.velocity_level_drag_up_for": "Velocity → level: drag up for soft (quiet notes louder), down for hard; ⌥-click to type",
+ "device.mosaic.voice_stealing_order": "Voice stealing · order",
+ "device.mosaic.voices_of_this_group_stop": "Voices of this group stop when a note of that exclusive group starts",
+ "device.mosaic.zones": { "one": "{0} zone", "other": "{0} zones" },
+ "device.mosaic.zones_can_already_be_selected": "Zones can already be selected and edited",
+ "device.mosaic.zones_n": "{0} · {1} zones",
+ "device.operator.11_topologies_feedback_on_a": "11 topologies · feedback on A",
+ "device.operator.vel_fm_off": "Vel → FM off",
+ "device.operator_algo.drag_an_operator_onto_another": "drag an operator onto another to re-route",
+ "device.pendulum.bar_quantize": "bar · quantize {0}",
+ "device.pendulum.detune_of_the_chorus_partner": "Detune of the chorus partner inside each voice",
+ "device.pendulum.fan_the_notes_across_the": "Fan the notes across the stereo field by where the ball is",
+ "device.pendulum.free_seconds_per_swing_at": "Free: seconds per swing at +100 %",
+ "device.pendulum.hold_a_chord": "hold a chord",
+ "device.pendulum.how_far_the_balls_rates": "How far the balls' rates drift apart — each ball a little faster than the one before",
+ "device.pendulum.how_long_one_swing_low": "How long one swing (low → high → low) takes at +100 %",
+ "device.pendulum.humanize_on_off_the_amount": "Humanize on / off — the amount is the HUMAN slider",
+ "device.pendulum.last_note": "last note {0} · {1}",
+ "device.pendulum.latch_the_chord_it_keeps": "Latch the chord — it keeps swinging after you let go; the next chord replaces it",
+ "device.pendulum.level_and_pitch_jitter_per": "Level and pitch jitter per note",
+ "device.pendulum.one_ball_fewer_2_at": "One ball fewer (2 at least)",
+ "device.pendulum.one_ball_more_6_at": "One ball more (6 at most)",
+ "device.pendulum.one_lane_per_ball_x": "One lane per ball: x is pitch, low to high. Crossing a chord degree plays that note; teal shows the wall ahead",
+ "device.pendulum.quantize_a_crossing_waits_for": "Quantize: a crossing waits for the next 1/16 or 1/8 before it plays",
+ "device.pendulum.reset_spread_humanize_and_scale": "Reset spread, humanize and scale to their defaults",
+ "device.pendulum.restart_every_ball_from_its": "Restart every ball from its start when a new chord begins",
+ "device.pendulum.restart_every_balls_swing_now": "Restart every ball's swing now",
+ "device.pendulum.snap_the_generated_notes_to": "Snap the generated notes to a scale",
+ "device.pendulum.swing_speed_centre_stops_the": "Swing speed — centre stops the balls, left of centre runs them in reverse",
+ "device.pendulum.sync_a_swing_takes_a": "Sync: a swing takes a note division of the tempo · Free: it takes a time in seconds",
+ "device.pendulum.the_bar_generated_notes_land": "The bar: generated notes land on the 1/16 grid — this bar in neutral ink with the note just played in accent, the last bar dimmer ahead of the playhead",
+ "device.pendulum.the_swing_curve_pendulum_slows": "The swing curve — Pendulum slows at the walls, Linear keeps one speed, Bounce settles with a ripple",
+ "device.pendulum.the_voice_soft_keys_bright": "The voice: soft Keys, bright Glass, Saw, hollow Square or inharmonic Bell",
+ "device.pendulum.up_the_low_wall_plays": "Up: the low wall plays the chord's lowest note · Down: its highest",
+ "device.pendulum.voices": { "one": "{0} voice", "other": "{0} voices" },
+ "device.pentad.khz_os_cpu": "{0:0.#} kHz · ×{1} OS · CPU {2:0} %",
+ "device.pentad.per_voice_active_routes": { "one": "per voice · {0} active route", "other": "per voice · {0} active routes" },
+ "device.pentad.poly_mod_source_destination_caps": "POLY MOD — SOURCE → DESTINATION",
+ "device.pentad.re_roll_the_vintage_seed": "Re-roll the vintage seed (new per-voice spread)",
+ "device.pentad.restore_lows_at_high_q": "Restore lows at high Q",
+ "device.pentad.shape_pulse_width_caps": "SHAPE · PULSE WIDTH",
+ "device.pentad.voice_setup_polyphony_allocation_glide": "Voice setup: polyphony, allocation, glide mode, oversampling, vintage seed",
+ "device.pentad.wheel_mod_destinations_caps": "WHEEL MOD — DESTINATIONS",
+ "device.phaser.all_pass_stages_every_two": "All-pass stages: every two cut one notch — 2 is a gentle swirl, 12 a deep, dense sweep",
+ "device.phaser.center_the_middle_of_the": "Center — the middle of the sweep, 50 Hz … 5 kHz: higher moves the notches up",
+ "device.phaser.depth_at_zero_the_notches": "Depth at zero: the notches stand still",
+ "device.phaser.depth_how_far_the_lfo": "Depth — how far the LFO swings the stages around Center, up to ±3 octaves",
+ "device.phaser.feedback_the_chains_output_fed": "Feedback — the chain's output fed back in, ±95 %: positive sharpens the peaks, negative moves and widens the notches",
+ "device.phaser.how_deep_the_notches_cut": "How deep the notches cut, dB (0 … −36 on the bar)",
+ "device.phaser.mix_50_gives_the_deepest": "Mix — 50 % gives the deepest notches; 100 % is the phase-shifted signal alone",
+ "device.phaser.phaser_bypassed_the_signal_passes": "Phaser bypassed: the signal passes unchanged",
+ "device.phaser.rate_the_note_value_of": "Rate — the note value of one LFO cycle, 4/1 … 1/16 with dotted (D) and triplet (T) values",
+ "device.phaser.stereo_the_right_lfo_against": "Stereo — the right LFO against the left: 0° sweeps both together, 90° spreads them, 180° moves them opposite",
+ "device.phaser.the_corner_frequency_of_both": "The corner frequency of both channels over two LFO cycles (20 Hz … 20 kHz), and where each is now",
+ "device.phaser.the_lfo_shape_that_sweeps": "The LFO shape that sweeps the stages: Sine glides, Tri sweeps evenly, Saw rises and drops back",
+ "device.phaser.the_notches_the_stages_cut": "The notches the stages cut into the spectrum, L neutral and R teal, with the corner dashed and each notch ticked on top. Drag left / right to move Center, up / down for Feedback; ⌥-click types, double-click resets both.",
+ "device.phaser.the_range_the_corner_sweeps": "The range the corner sweeps (20 Hz … 20 kHz on the bar), and the first notch now",
+ "device.phaser.what_the_feedback_makes_positive": "What the feedback makes: positive sharpens the peaks, negative moves and widens the notches, past 85 % the phaser whistles",
+ "device.physical.1_2_resonator_1_rings": "1→2: resonator 1 rings into resonator 2 · 1+2: both struck, mixed",
+ "device.physical.env_freq_off": "env → freq off",
+ "device.physical.how_hard_a_released_key": "How hard a released key damps the body — at 0 it rings on, fully up it stops at once",
+ "device.physical.partials_as_the_engine_tunes": "Partials as the engine tunes them — drag ↔ to spread the series (Ratio), ↕ to tilt the highs (Bright)",
+ "device.physical.poly_8_voices_ring_over": "Poly: 8 voices ring over each other · Mono: a new strike chokes the sounding note",
+ "device.physical.res_1_against_res_2": "Res 1 against Res 2 — both at full level in the middle; in 1→2, res 1's own sound against the body it rings",
+ "device.physical.resonator_2_on_off_resonator": "Resonator 2 on / off — resonator 1 always rings",
+ "device.physical.stiffness_sets_the_contact_time": "Stiffness sets the contact time: soft = long and dark, hard = short and bright",
+ "device.physical.which_resonator_the_controls_below": "Which resonator the controls below edit",
+ "device.plugin.close_editor": "Close editor",
+ "device.plugin.close_the_plug_ins_own": "Close the plug-in's own window",
+ "device.plugin.couldnt_open_the_window": "Couldn't open the {0} window.",
+ "device.plugin.couldnt_open_the_window_n": "Couldn't open the {0} window: {1}",
+ "device.plugin.no_parameter_matches": "No parameter matches",
+ "device.plugin.open_editor": "Open editor",
+ "device.plugin.open_the_plug_ins_own": "Open the plug-in's own window",
+ "device.plugin.save_the_plug_ins_state": "Save the plug-in's state as a preset",
+ "device.plugin.this_plug_in_exposes_no": "This plug-in exposes no parameters",
+ "device.prism.above_compress_caps": "ABOVE — COMPRESS",
+ "device.prism.above_compression_caps": "ABOVE — COMPRESSION",
+ "device.prism.amount_scales_every_bands_compression": "Amount — scales every band's compression and expansion (0 % = none). Double-click: 100 %",
+ "device.prism.auto_makeup_each_band_gets": "Auto makeup — each band gets back about half of its compression at 0 dBFS",
+ "device.prism.auto_release_short_peaks_recover": "Auto release — short peaks recover fast, sustained compression recovers slowly",
+ "device.prism.band_gain_24_db_drag": "Band gain ±24 dB — drag up / down, double-click resets",
+ "device.prism.bands_3_low_mid_high": "Bands — 3: Low / Mid / High · 2: Low + Mid (Mid runs to 20 kHz) · 1: Mid, full band",
+ "device.prism.below_expand_caps": "BELOW — EXPAND",
+ "device.prism.below_expansion": "Below — expansion",
+ "device.prism.below_expansion_caps": "BELOW — EXPANSION",
+ "device.prism.below_upward_compression": "Below — upward compression",
+ "device.prism.compression_threshold_ratio_set_the": "Compression threshold · ratio (set the ratio in Band detail)",
+ "device.prism.crossovers": "crossovers {0} / {1}",
+ "device.prism.detector_peak_follows_every_transient": "Detector — Peak follows every transient; RMS (10 ms) follows loudness, smoother",
+ "device.prism.drag_a_dot_threshold_ratio": "Drag a dot: ← → threshold, ↑ ↓ ratio (down = more). The bright dot is compression above, the grey one expansion below. Double-click a dot resets it. · ⌥-click to type",
+ "device.prism.expansion_upward_compression_threshold_ratio": "Expansion / upward-compression threshold · ratio — click the readout to switch it on or off",
+ "device.prism.input_spectrum_fill_and_output": "Input spectrum (fill) and output (line). Drag a crossover line to move it; ⌥-click to type, double-click resets. Click a band to select it.",
+ "device.prism.khz_cpu": "{0:0.#} kHz · {1}{2} · CPU {3:0} %",
+ "device.prism.listen_hear_the_detectors_key": "Listen — hear the detector's key signal (the sidechain, or the input), per solo band",
+ "device.prism.listening_to_the_detector_key": "Listening to the detector key",
+ "device.prism.low_mid_crossover": "Low / mid crossover",
+ "device.prism.mid_high_crossover": "Mid / high crossover",
+ "device.prism.n_a_in_a_rack": "n/a in a rack",
+ "device.prism.none_own_input": "None — own input",
+ "device.prism.output_gain_24_db_double": "Output gain ±24 dB — double-click: 0 dB",
+ "device.prism.ratio_above_1_1_expands": "Ratio above 1 : 1 expands (quiet parts get quieter); below 1 : 1 (↑) compresses upward (quiet parts are lifted). Floor limits either to ± that many dB.",
+ "device.prism.sidechain_key_every_bands_detector": "Sidechain — key every band's detector from another track (split into the same bands)",
+ "device.prism.soft_clip_a_smooth_ceiling": "Soft clip — a smooth ceiling at −0.3 dBFS after the output gain",
+ "device.prism.solo_a_band_hear_only": "Solo a band — hear only that band (click again to clear)",
+ "device.prism.the_selected_bands_input_peaks": "The selected band's input peaks (grey) and what its compressor's detector makes of them (the last ~1.5 s), against the threshold.",
+ "device.rack.a_midi_effect_rack_holds": "A MIDI Effect Rack holds up to {0} chains",
+ "device.rack.a_midi_effect_rack_takes": "A MIDI Effect Rack takes MIDI effects only.",
+ "device.rack.a_rack_cant_go_inside": "A rack can't go inside a rack.",
+ "device.rack.add_device_click_for_the": "Add device — click for the list, or drop an effect here",
+ "device.rack.all_chains_get_the_input": "All chains get the input. Outputs are summed.",
+ "device.rack.an_audio_effect_rack_takes": "An Audio Effect Rack takes audio effects only.",
+ "device.rack.audio_effect_rack_chain": "Audio Effect Rack · chain {0}",
+ "device.rack.chain": "Chain {0}",
+ "device.rack.chain_1_feeds_chain_2": "Chain 1 feeds chain 2, top to bottom.",
+ "device.rack.chain_n": "chain {0}",
+ "device.rack.chains": { "one": "{0} chain", "other": "{0} chains" },
+ "device.rack.chains.a_midi_effect_rack_holds": "A MIDI Effect Rack holds up to {0} chains.",
+ "device.rack.chains.add_a_chain_or_drop": "Add a chain — or drop a device from the Browser on the list",
+ "device.rack.chains.add_a_chain_to_start": "Add a chain to start.",
+ "device.rack.chains.add_a_midi_effect_or": "Add a MIDI effect — or drop one from the Browser",
+ "device.rack.chains.add_an_effect_or_drop": "Add an effect — or drop one from the Browser",
+ "device.rack.chains.an_instrument_rack_cant_go": "An Instrument Rack can't go inside a rack — add its instruments as chains.",
+ "device.rack.chains.cant_go_in_a_rack": "{0} can't go in a rack chain.",
+ "device.rack.chains.chain": "Chain · {0}",
+ "device.rack.chains.click_to_add_or_remove": "Click to add or remove",
+ "device.rack.chains.controlled_by_click_to_open": "Controlled by {0} · click to open the macro",
+ "device.rack.chains.delete_chain": "Delete chain",
+ "device.rack.chains.devices": { "one": "{0} device", "other": "{0} devices" },
+ "device.rack.chains.drop_a_device_here": "Drop a device here.",
+ "device.rack.chains.left_right": "{0} · {1} left → right",
+ "device.rack.chains.map_to": "Map to {0}",
+ "device.rack.chains.midi_effect": "{0} · MIDI effect {1}",
+ "device.rack.chains.open_the_full_editor": "Open the full editor",
+ "device.rack.chains.pick_an_instrument_or_drop": "Pick an instrument — or drop one from the Browser",
+ "device.rack.chains.plug_in_presets_cant_go": "Plug-in presets can't go in a rack chain yet.",
+ "device.rack.chains.replace_instrument": "Replace instrument",
+ "device.rack.chains.sel": "sel {0}–{1}",
+ "device.rack.chains.this_preset_cant_go_in": "This preset can't go in a rack.",
+ "device.rack.chains.this_rack_cant_host_plug": "This rack can't host plug-ins.",
+ "device.rack.chains.turn_off": "Turn off",
+ "device.rack.chains.turn_on": "Turn on",
+ "device.rack.chains.unmap_from": "Unmap from {0}",
+ "device.rack.clear_mappings": { "one": "Clear {0} mapping", "other": "Clear {0} mappings" },
+ "device.rack.clipboard.copied": "Copied {0}",
+ "device.rack.clipboard.couldnt_paste_a_device_failed": "Couldn't paste: a device failed to load.",
+ "device.rack.clipboard.midi_effects_run_in_the": "MIDI effects run in the first 16 chains.",
+ "device.rack.clipboard.move_left": "Move left",
+ "device.rack.clipboard.move_right": "Move right",
+ "device.rack.clipboard.nothing_to_paste": "Nothing to paste",
+ "device.rack.clipboard.nothing_to_paste_here": "Nothing to paste here.",
+ "device.rack.clipboard.pasted": "Pasted {0}",
+ "device.rack.clipboard.pasted_devices": "Pasted {0} devices",
+ "device.rack.clipboard.pasted_devices_skipped_this_chain": "Pasted {0} devices, skipped {1} this chain can't take",
+ "device.rack.clipboard.sidechain_dropped": " · sidechain dropped",
+ "device.rack.clipboard.the_device_cant_go_there": "The device can't go there.",
+ "device.rack.clipboard.this_chain_cant_take_the": "This chain can't take the copied devices.",
+ "device.rack.clipboard.this_device_cant_be_duplicated": "This device can't be duplicated",
+ "device.rack.clipboard.this_racks_chains_take_no": "This rack's chains take no MIDI effects.",
+ "device.rack.clipboard.this_racks_chains_take_no_2": "This rack's chains take no audio effects.",
+ "device.rack.double_click_to_rename": "Double-click to rename",
+ "device.rack.drag_to_set_right_click": "Drag to set · right-click to map",
+ "device.rack.drop_an_effect_to_add": "Drop an effect to add a chain.",
+ "device.rack.drop_an_instrument_to_add": "Drop an instrument to add a layer.",
+ "device.rack.drop_midi_effects_here_output": "Drop MIDI effects here. Output goes to the track instrument.",
+ "device.rack.drum.16_loaded": "{0} · {1}/16 loaded",
+ "device.rack.drum.a_rack_cant_go_on": "A rack can't go on a Drum Rack pad.",
+ "device.rack.drum.a_synth_voice_no_sample": "A synth voice, no sample",
+ "device.rack.drum.all_pads": { "one": "All {0} pad", "other": "All {0} pads" },
+ "device.rack.drum.back_to_pads": "Back to pads",
+ "device.rack.drum.bank": "Bank {0}",
+ "device.rack.drum.choke_group": "Choke group",
+ "device.rack.drum.choke_group_click_for_the": "Choke group: click for the next",
+ "device.rack.drum.choke_group_n": "choke group {0}: {1}",
+ "device.rack.drum.choke_groups": { "one": "{0} choke group", "other": "{0} choke groups" },
+ "device.rack.drum.click_to_add_an_instrument": "{0} — click to add an instrument, or drop a sample here",
+ "device.rack.drum.click_to_play_right_click": "{0} · {1} — click to play, right-click for more",
+ "device.rack.drum.drop_a_sample_on_a": "Drop a sample on a pad, or pick a kit above.",
+ "device.rack.drum.effects": { "one": "{0} effect", "other": "{0} effects" },
+ "device.rack.drum.empty": "{0} · empty",
+ "device.rack.drum.every": "Every {0} ({1})",
+ "device.rack.drum.group": "Group {0}",
+ "device.rack.drum.hide_the_empty_pads": "Hide the empty pads",
+ "device.rack.drum.instrument_then_its_effects_signal": "instrument, then its effects · signal left → right",
+ "device.rack.drum.mute_the_pad": "Mute the pad",
+ "device.rack.drum.no_choke_groups": " · no choke groups",
+ "device.rack.drum.no_pad_selected": "{0} · no pad selected{1}",
+ "device.rack.drum.no_pads_in_bank": "No pads in bank {0}.",
+ "device.rack.drum.no_pads_in_bank_drop": "No pads in bank {0} — drop samples on the Pads view.",
+ "device.rack.drum.no_pads_to_map": "No pads to map",
+ "device.rack.drum.no_sample_drop_one_on": "No sample — drop one on the pad",
+ "device.rack.drum.none_choke_group": "None",
+ "device.rack.drum.nudge_every_hits_timing_at": "Nudge every hit's timing at random",
+ "device.rack.drum.off": "off",
+ "device.rack.drum.open_chain": "Open chain",
+ "device.rack.drum.open_the_pads_instrument": "Open the pad's instrument",
+ "device.rack.drum.pad": "Pad",
+ "device.rack.drum.pad_bank_sixteen_notes_from": "Pad bank: sixteen notes from C1, C2, C3 or C4",
+ "device.rack.drum.pad_pan_drag_up_or": "Pad pan · drag up or down, ⌥-click to type, double-click to centre",
+ "device.rack.drum.pad_volume_drag_up_or": "Pad volume · drag up or down, ⌥-click to type, double-click for 0 dB",
+ "device.rack.drum.pad_volume_pan": "{0} {1} · {2} → {3} → pad volume, pan",
+ "device.rack.drum.pads": { "one": "{0} pad", "other": "{0} pads" },
+ "device.rack.drum.pads_in_the_same_group": "Pads in the same group cut each other off",
+ "device.rack.drum.push_the_off_beat_sixteenths": "Push the off-beat sixteenths late",
+ "device.rack.drum.remove_pad": "Remove pad",
+ "device.rack.drum.sampler": "sampler {0}",
+ "device.rack.drum.select_a_pad_to_see": "Select a pad to see its device chain.",
+ "device.rack.drum.select_the_pad": "Select the pad",
+ "device.rack.drum.selected_choke": "{0} {1} selected · {2} · choke {3}",
+ "device.rack.drum.shorten_the_pads_tail_hold": "Shorten the pad's tail; hold lets it ring",
+ "device.rack.drum.show_every_pad_of_the": "Show every pad of the bank",
+ "device.rack.drum.show_the_pads": "Show the pads",
+ "device.rack.drum.show_the_pads_instrument_and": "Show the pad's instrument and effects",
+ "device.rack.drum.slots_assigned": "{0} slots · {1} assigned",
+ "device.rack.drum.solo_the_pad": "Solo the pad",
+ "device.rack.drum.swing_humanize": " · swing {0} · humanize {1}",
+ "device.rack.drum.transpose_the_note_the_pad": "Transpose the note the pad plays, in semitones",
+ "device.rack.drum_rack_pad": "Drum Rack · pad {0}{1}",
+ "device.rack.each_note_goes_to_every": "Each note goes to every chain whose zone it hits. Outputs merge before the instrument.",
+ "device.rack.effect_of": "{0} · effect {1} of {2}",
+ "device.rack.instrument_rack_chain": "Instrument Rack · chain {0}{1}",
+ "device.rack.keys_c_1_g9_vel": "Keys C−1–G9 · vel 0–127",
+ "device.rack.macro_tab.drag_the_ends_min_above": "Drag the ends · min above max inverts",
+ "device.rack.macro_tab.map_this_macro_click_parameters": "Map this macro: click parameters on the Chains tab",
+ "device.rack.macro_tab.no_targets_yet_press_map": "No targets yet. Press Map, then click parameters on the Chains tab.",
+ "device.rack.macros": { "one": "{0} macro", "other": "{0} macros" },
+ "device.rack.macros.add_a_receiver_a_pad": "Add a receiver: a pad control, the pad's instrument or one of its effects",
+ "device.rack.macros.all": "all",
+ "device.rack.macros.all_n": "all {0}",
+ "device.rack.macros.drag_to_turn_click_to": "{0} — {1}\nDrag to turn · click to show its receivers · right-click to map, rename or clear",
+ "device.rack.macros.drag_to_turn_double_click": "{0} → {1} · drag to turn · double-click resets",
+ "device.rack.macros.every_macro_assigned": "every macro assigned",
+ "device.rack.macros.free": "{0} free",
+ "device.rack.macros.macro_is_free_right_click": "Macro {0} is free — right-click (or Map) to give it a target",
+ "device.rack.macros.map": "Map",
+ "device.rack.macros.map_the_chosen_macro_click": "Map the chosen macro: click parameters in the chain",
+ "device.rack.macros.map_to": "Map to",
+ "device.rack.macros.not_assigned": "not assigned",
+ "device.rack.macros.not_mapped_pick_it_and": "Not mapped · pick it and press Map",
+ "device.rack.macros.nothing_mapped_yet_map_gives": "Nothing mapped yet. Map gives this knob a pad control, an instrument param or any of the kit's effects.",
+ "device.rack.macros.params": { "one": "{0} param", "other": "{0} params" },
+ "device.rack.macros.receivers_and_ranges": "Receivers and ranges…",
+ "device.rack.macros.remove_every_receiver_of_this": "Remove every receiver of this macro",
+ "device.rack.macros.remove_this_receiver": "Remove this receiver",
+ "device.rack.macros.rename": "Rename",
+ "device.rack.macros.stop_mapping_esc": "Stop mapping (Esc)",
+ "device.rack.macros.targets": { "one": "{0} target", "other": "{0} targets" },
+ "device.rack.macros.the_range_the_macro_sweeps": "The range the macro sweeps: drag either end · the tick is where it is now",
+ "device.rack.map_to_a_macro": "Map to a macro",
+ "device.rack.map_to_parameter": "Map to parameter",
+ "device.rack.map_to_the_selector": "Map to the selector",
+ "device.rack.mapped_to_macro_click_to": "Mapped to Macro {0} — click to change",
+ "device.rack.nota_rhythm_voice": "Nota Rhythm · voice {0}",
+ "device.rack.of_8_mapped": "{0} of 8 mapped",
+ "device.rack.only_chains_whose_range_holds": "Only chains whose range holds the selector get notes.",
+ "device.rack.only_chains_whose_range_holds_2": "Only chains whose range holds the selector play.",
+ "device.rack.pads": "{0} · {1} pads",
+ "device.rack.parameters": { "one": "{0} parameter", "other": "{0} parameters" },
+ "device.rack.params": { "one": "→ {0} param", "other": "→ {0} params" },
+ "device.rack.remove_device": "Remove device",
+ "device.rack.right_panel.a_rack_keeps_at_least": "A rack keeps at least one chain",
+ "device.rack.right_panel.all_chains_share_one_voice": "All chains share one voice, the last key wins",
+ "device.rack.right_panel.copy_this_chain_after_itself": "Copy this chain after itself",
+ "device.rack.right_panel.delete_this_chain": "Delete this chain",
+ "device.rack.right_panel.dry_wet": "{0} · {1} · dry/wet {2} · {3}",
+ "device.rack.right_panel.edit_on_the_tab": "Edit on the {0} tab",
+ "device.rack.right_panel.follow_input_level": "Follow input level",
+ "device.rack.right_panel.follows_input": " · follows input",
+ "device.rack.right_panel.glides_between_notes_in_mono": "Glides between notes in mono mode",
+ "device.rack.right_panel.in_select_mode_the_selector": "In Select mode the selector follows the input level instead of its handle",
+ "device.rack.right_panel.line_up_chains_with_different": "Line up chains with different latency",
+ "device.rack.right_panel.macros_mapped": { "one": "{0} macro mapped", "other": "{0} macros mapped" },
+ "device.rack.right_panel.merge_duplicate_notes": "Merge duplicate notes",
+ "device.rack.right_panel.merged_midi": "{0} · {1} → merged MIDI · {2}",
+ "device.rack.right_panel.mono_last_note": "Mono (last note)",
+ "device.rack.right_panel.no_chain_yet": "No chain yet.",
+ "device.rack.right_panel.notes_no_chain_takes_reach": "Notes no chain takes reach the instrument unchanged",
+ "device.rack.right_panel.pass_through_outside_zones": "Pass through outside zones",
+ "device.rack.right_panel.select": "Select {0}",
+ "device.rack.right_panel.two_chains_sending_the_same": "Two chains sending the same pitch play one note",
+ "device.rack.this_drum_rack_is_no": "This Drum Rack is no longer in the rack.",
+ "device.rack.unmap": "Unmap",
+ "device.rack.voices": "{0} · voices {1}",
+ "device.rack.zones.drag_the_edges_to_set": "Drag the edges to set the key zone · hover to test a note",
+ "device.rack.zones.drag_the_edges_to_set_2": "Drag the edges to set the select range",
+ "device.rack.zones.drag_the_edges_to_set_3": "Drag the edges to set the velocity zone",
+ "device.rack.zones.drag_the_selector_or_map": "Drag the selector or map it to a macro",
+ "device.rack.zones.drag_to_choose_which_chains": "Drag to choose which chains play · right-click to map it to a macro",
+ "device.rack.zones.drag_zone_edges_hover_to": "Drag zone edges · hover to test a note",
+ "device.rack.zones.hover_the_zones": "Hover the zones",
+ "device.rack.zones.inactive": " · inactive",
+ "device.rack.zones.nothing": "nothing",
+ "device.rack.zones.ranges_apply_when_chains_run": "Ranges apply when Chains run is set to Select",
+ "device.rack.zones.select_range_in_select_mode": "Select range: in Select mode this chain plays while the selector is inside it",
+ "device.rack.zones.selector": "selector {0} → {1}{2}",
+ "device.rack.zones.silence": "silence",
+ "device.rack.zones.the_selector_follows_the_input": "The selector follows the input level · turn Follow input off on the Rack out tab to set it by hand",
+ "device.rack.zones.vel": "{0} · vel {1} → {2}",
+ "device.random.bar_changed_skipped": "bar {0} · {1} changed · {2} skipped",
+ "device.random.chance_how_many_notes_get": "Chance — how many notes get varied at all",
+ "device.random.chance_that_a_varied_note": "Chance that a varied note is dropped",
+ "device.random.changed_skip": "{0} changed · {1} skip",
+ "device.random.dashed_in_filled_out_brightness": "Dashed — in · filled — out (brightness = velocity) · × — skipped",
+ "device.random.distribution_gauss_even_walk_click": "Distribution: Gauss / Even / Walk — click for the next, Shift-click for the previous",
+ "device.random.distribution_gauss_mostly_small_moves": "Distribution: Gauss — mostly small moves · Even — any amount equally · Walk — drifts from note to note",
+ "device.random.drag_up_down_double_click": "{0} — drag up / down, double-click resets",
+ "device.random.hold_the_roll_showing_now": "Hold the roll showing now — it repeats every bar",
+ "device.random.jump_up_or_down_by": "Jump up or down by up to two octaves",
+ "device.random.lock_hold_the_roll_showing": "Lock — hold the roll showing now",
+ "device.random.next_seed_a_new_roll": "Next seed — a new roll",
+ "device.random.one_bar_of_eight_notes": "One bar of eight notes: dashed — the note in, filled — the note out (brightness = velocity, shifted right when delayed), × — skipped",
+ "device.random.per_note_every_note_rolls": "Per note — every note rolls its own values · Per bar — one set of values for the whole bar",
+ "device.random.play_late_by_up_to": "Play late by up to this long (a live effect can't play early)",
+ "device.random.push_the_velocity_up_or": "Push the velocity up or down by up to this much",
+ "device.random.reroll_the_next_seed": "Reroll — the next seed",
+ "device.random.snap_every_varied_note_into": "Snap every varied note into C major",
+ "device.random.stay_in_scale_c_maj": "Stay in scale · C maj",
+ "device.random.the_shape_of_the_roll": "The shape of the roll — 1500 draws from the same generator",
+ "device.random.transpose_up_or_down_by": "Transpose up or down by up to this many semitones",
+ "device.reverb.algorithm_hall_large_spaced_reflections": "Algorithm — Hall (large, spaced reflections) · Room (small, close walls) · Plate (dense, no room at all) · Chamber (between)",
+ "device.reverb.bass_mono_below_this_frequency": "Bass mono — below this frequency the tail is mono, so a wide reverb does not smear the low end (off at the far left)",
+ "device.reverb.decay_rt60_the_time_the": "Decay — RT60, the time the tail takes to fall 60 dB (0.2 … 12 s); Freeze holds it forever. Double-click resets.",
+ "device.reverb.early_reflections_the_first_discrete": "Early reflections — the first discrete echoes off the walls, spaced by the algorithm and the size",
+ "device.reverb.freeze_hold_the_tail_forever": "Freeze — hold the tail forever; the input is muted and nothing decays",
+ "device.reverb.hf_damp_how_much_faster": "HF Damp — how much faster the highs die than the lows. Double-click resets.",
+ "device.reverb.input_muted_tail_held": "input muted · tail held",
+ "device.reverb.kill_tail_empty_the_reverb": "Kill tail — empty the reverb at once; whatever is still ringing (or frozen) stops",
+ "device.reverb.latency_comp": "Latency comp.",
+ "device.reverb.mod_on_tail_the_modulation": "Mod on tail — the modulation wobbles the tail itself (a chorused, evolving decay); off, it moves only the early part and the tail stays still",
+ "device.reverb.tail_held_no_decay": "Tail held · no decay",
+ "device.reverb.the_decay_tail_the_impulse": "The decay tail — the impulse at the pre-delay (teal), the early reflections (drawn magnified), then the RT60 curve over 4 s. Drag the teal marker for the pre-delay, drag the tail for the decay; ⌥-click to type, double-click to reset.",
+ "device.reverb.the_input_diffuser_delays_the": "The input diffuser delays the tail by a fixed group delay; on, the pre-delay is shortened by exactly that so the tail starts on the set pre-delay (it cannot go below zero).",
+ "device.reverb.vintage_an_early_digital_colour": "Vintage — an early-digital colour: a band-limited input, 12-bit wet and a deeper wobble",
+ "device.reverb.wet_only_the_tail_with": "Wet only — the tail with no dry, for a return / send track",
+ "device.rhythm.add_a_receiver_to_a": "Add a receiver to {0}: a voice param, a kit setting or a voice's effect",
+ "device.rhythm.all_voices": { "one": "All {0} voice", "other": "All {0} voices" },
+ "device.rhythm.amp_decay_shortens_the_hit": "Amp decay — shortens the hit",
+ "device.rhythm.attack_click_snap": "Attack click / snap",
+ "device.rhythm.bank": "Bank {0}",
+ "device.rhythm.bank_play_and_edit_this": "Bank {0} — play and edit this pattern · right-click to copy or clear it",
+ "device.rhythm.clear": "Clear {0}",
+ "device.rhythm.clear_bank": "Clear bank {0}",
+ "device.rhythm.clear_its_steps_in_bank": "Clear its steps in bank {0}",
+ "device.rhythm.click_step_on_off_shift": "Click: step on / off · Shift-click: accent · Alt-click: quiet step\nDrag across to paint · drag up / down or scroll to set the velocity · right-click for more",
+ "device.rhythm.click_to_load_another_file": "{0} — click to load another file",
+ "device.rhythm.copy_to": "Copy {0} to",
+ "device.rhythm.drag_the_start_and_end": "Drag the Start and End lines to set them · ⌥-click one to type it · double-click to load another file",
+ "device.rhythm.every": "Every {0} ({1})",
+ "device.rhythm.fill_every_16th": "Fill every 16th",
+ "device.rhythm.fill_every_8th": "Fill every 8th",
+ "device.rhythm.fill_every_beat": "Fill every beat",
+ "device.rhythm.glue_a_bus_compressor_on": "Glue: a bus compressor on the whole kit — holds the hits together (0 = off)",
+ "device.rhythm.how_much_louder_an_accented": "How much louder an accented step plays",
+ "device.rhythm.how_much_of_the_file": "How much of the file plays, from Start",
+ "device.rhythm.humanize_a_random_nudge_to": "Humanize: a random nudge to every hit's velocity",
+ "device.rhythm.load_a_one_shot_into": "Load a one-shot into this voice (or drop a file on the voice)",
+ "device.rhythm.load_a_sample_into": "Load a sample into {0}",
+ "device.rhythm.load_sample": "Load sample…",
+ "device.rhythm.midi_click_select_and_play": "{0} · MIDI {1}\nClick: select and play · drop a file to load it · right-click for more",
+ "device.rhythm.of_1_16_bank": "{0} of {1} · 1/16 · bank {2}",
+ "device.rhythm.off_beats": "Off-beats",
+ "device.rhythm.pitch_kick_snare_tom_hats": "Pitch (Kick, Snare, Tom, Hats, Perc) or noise colour (Clap, Rim)",
+ "device.rhythm.play_the_loaded_sample": "Play the loaded sample",
+ "device.rhythm.play_the_region_back_to": "Play the region back to front",
+ "device.rhythm.play_the_synth_engine": "Play the synth engine",
+ "device.rhythm.shift_left": "Shift left",
+ "device.rhythm.shift_right": "Shift right",
+ "device.rhythm.shift_step_accent": "shift+step = accent",
+ "device.rhythm.slots_assigned": "{0} slots · {1} assigned",
+ "device.rhythm.snare_body_noise_hats_metal": "Snare body ↔ noise · Hats metal ↔ noise · Perc ring ratio",
+ "device.rhythm.sound_the_voices_source_and": "Sound: the voice's source and shape · FX: its own effects, before the kit bus",
+ "device.rhythm.step_accent": "Step {0} accent",
+ "device.rhythm.step_quiet": "Step {0} quiet",
+ "device.rhythm.swing_delays_every_second_16th": "Swing: delays every second 16th — at 100 % by half a step",
+ "device.rhythm.synth_the_voices_own_engine": "Synth: the voice's own engine · Sample: a loaded one-shot (loads one if the voice has none)",
+ "device.rhythm.the_hit_amp_contour_over": "The hit: amp contour over the pitch drop · drag across for Decay, up / down for Tune (Shift = fine) · ⌥-click to type them",
+ "device.rhythm.the_kits_eight_macros_knobs": "The kit's eight macros — knobs over every voice and its effects",
+ "device.rhythm.the_kits_output_level": "The kit's output level",
+ "device.rhythm.the_selected_voices_sound_and": "The selected voice's sound and effects",
+ "device.rhythm.the_voices_level_in_the": "The voice's level in the kit",
+ "device.rhythm.transpose_12_semitones": "Transpose, ±12 semitones",
+ "device.rhythm.voices": { "one": "{0} voice", "other": "{0} voices" },
+ "device.rhythm.where_in_the_file_the": "Where in the file the hit starts",
+ "device.sampler.a_long_tail_after_release": "a long tail after release",
+ "device.sampler.a_slow_swell": "a slow swell",
+ "device.sampler.almost_a_gate_the_sample": "almost a gate — the sample is heard whole",
+ "device.sampler.blends_the_loops_end_into": "Blends the loop's end into its start (forward loops)",
+ "device.sampler.click_a_key_to_make": "Click a key to make it the root — the key that plays the sample as recorded",
+ "device.sampler.detect_from_file_name": "Detect from file name",
+ "device.sampler.drag_a_sample_from_the": "Drag a sample from the Files tab or the browser",
+ "device.sampler.drag_left_right_for_the": "Drag: left / right for the cutoff, up / down for the resonance · Shift for fine steps · ⌥-click to type · double-click resets",
+ "device.sampler.drag_start_end_and_the": "Drag Start / End (and the loop markers when looping) · ⌥-click a marker to type it · double-click to reset it",
+ "device.sampler.drag_the_nodes_attack_decay": "Drag the nodes: attack, decay and sustain (up / down), release · Shift for fine steps · ⌥-click to type · double-click resets",
+ "device.sampler.drop_a_sample_here": "Drop a sample here",
+ "device.sampler.env": "Env {0} — {1}",
+ "device.sampler.every_key_plays_the_same": "every key plays the same pitch",
+ "device.sampler.filter_off_the_sample_passes": "Filter off — the sample passes untouched",
+ "device.sampler.fine_tune_50_cents": "Fine tune, ±50 cents",
+ "device.sampler.held_at_the_sustain_level": "held at the sustain level",
+ "device.sampler.how_far_the_envelope_moves": "How far the envelope moves the cutoff, ±6 octaves",
+ "device.sampler.how_far_the_key_moves": "How far the key moves the pitch — 100 % chromatic, 0 % every key plays the root",
+ "device.sampler.how_much_velocity_sets_the": "How much velocity sets the level",
+ "device.sampler.let_the_amp_envelope_open": "Let the amp envelope open (or close) the filter — the depth is ENV",
+ "device.sampler.move_start_and_end_to": "Move Start and End to where the sound begins and fades out (−48 dB)",
+ "device.sampler.move_start_end_and_the": "Move Start, End and the loop to the nearest zero crossing — no clicks",
+ "device.sampler.names_make_it_the_root": "\"{0}\" names {1} — make it the root",
+ "device.sampler.no_crossfade": "{0} · no crossfade",
+ "device.sampler.no_sample_drop_one_from": "No sample · drop one from the Files tab or the browser",
+ "device.sampler.off_low_pass_high_pass": "Off · low-pass · high-pass · band-pass (12 dB/oct)",
+ "device.sampler.off_plays_once_fwd_loops": "Off plays once · Fwd loops · Ping bounces · Rev loops backwards",
+ "device.sampler.plays_the_sample_at_its": "{0} plays the sample at its own pitch",
+ "device.sampler.poly_16_voices_mono_one": "Poly: 16 voices · Mono: one at a time (legato with Glide) · Choke: a new note cuts the ringing ones",
+ "device.sampler.range_root_keytrack": "range {0} — {1} · root {2} · keytrack {3}",
+ "device.sampler.root_a_semitone_down": "Root a semitone down",
+ "device.sampler.root_a_semitone_up": "Root a semitone up",
+ "device.sampler.shift_every_note_24_semitones": "Shift every note, ±24 semitones",
+ "device.sampler.slide_from_the_last_note": "Slide from the last note — in Mono, legato: no retrigger",
+ "device.sampler.snap_to_zero": "Snap to zero",
+ "device.sampler.the_cutoff_follows_the_key": "The cutoff follows the key, 0 … 100 %",
+ "device.sampler.the_key_sets_the_playback": "the key sets the playback speed",
+ "device.sampler.the_level_after_everything": "The level after everything",
+ "device.sampler.the_root_note_scroll_to": "The root note — scroll to step it",
+ "device.sampler.the_sample_plays_at_its": "the sample plays at its own pitch on the root",
+ "device.sampler.the_samples_file_name_isnt": "The sample's file name isn't known",
+ "device.sampler.the_samples_level_before_the": "The sample's level before the envelope",
+ "device.sampler.the_voices_level": "The voices' level",
+ "device.sampler.trim_silence": "Trim silence",
+ "device.sampler.velocity_sets_the_level_the": "Velocity sets the level — the amount is the rail's VEL → VOL",
+ "device.scale.an_octave_drag_or_scroll": "{0} — ± an octave, drag or scroll the note for semitones, ⌥-click the note to type it, double-click resets. Notes outside the range pass through.",
+ "device.scale.clear_the_scale_down_to": "Clear the scale down to the root (Custom)",
+ "device.scale.click_a_note_to_add": "Click a note to add it to or take it out of the scale (the scale turns Custom)",
+ "device.scale.custom_your_own_notes_click": "Custom: your own notes — click the note map to edit",
+ "device.scale.empty_notes_pass": "empty · notes pass",
+ "device.scale.fold_where_an_out_of": "Fold — where an out-of-scale note goes: the nearest scale note (a tie goes up), the one below or the one above",
+ "device.scale.follow_key_from_input": "Follow key · from input",
+ "device.scale.follow_key_the_root_moves": "Follow key — the root moves to the key that best fits what you play (keeping the scale type)",
+ "device.scale.last_in_out_caps": "LAST IN → OUT",
+ "device.scale.learn_play_the_notes_of": "Learn — play the notes of your scale; they pass through untouched and become the Custom scale. Click again to finish.",
+ "device.scale.notes": "{0} {1} · {2} notes",
+ "device.scale.notes_fold": "{0} {1} · {2} notes · fold {3} · ",
+ "device.scale.notes_n": "{0} — {1} notes",
+ "device.scale.of_12_remapped": "{0} of 12 remapped",
+ "device.scale.root_click_the_arrows_or": "Root — click the arrows or scroll",
+ "device.scale.the_key_in_effect_root": "The key in effect: root and scale",
+ "device.scale.the_last_note_played_and": "The last note played and what it came out as",
+ "device.shutter.clear_every_step": "Clear every step",
+ "device.shutter.click_to_type": " · ⌥-click to type",
+ "device.shutter.clock_sync_locks_the_pattern": "Clock — Sync locks the pattern to the song's bars, Free runs it in Hz",
+ "device.shutter.closes_to_silence": "closes to silence",
+ "device.shutter.complexity_how_busy_and_varied": "Complexity — how busy and varied Rnd makes the pattern",
+ "device.shutter.copy_the_steps": "Copy the steps",
+ "device.shutter.depth_how_far_an_empty": "Depth — how far an empty step turns the signal down",
+ "device.shutter.detector_filter_the_key_goes": "Detector filter — the key goes through the band-pass (Sidechain tab) before the detector",
+ "device.shutter.detector_filter_the_key_goes_2": "Detector filter — the key goes through the band-pass before the detector",
+ "device.shutter.detector_full_band": "Detector · full band",
+ "device.shutter.ducks_to_silence": "ducks to silence",
+ "device.shutter.external_sidechain_the_detector_listens": "External sidechain — the detector listens to the key source instead of this track",
+ "device.shutter.floor_the_level_when_closed": "Floor — the level when closed (−∞ = silence); in Duck, how far the signal goes down",
+ "device.shutter.gain_reduction_how_far_the": "Gain reduction — how far the gate has turned the signal down now",
+ "device.shutter.gate_envelope_trigger": "Gate envelope · trigger",
+ "device.shutter.gated_the_pattern_plays_only": "Gated — the pattern plays only while the threshold gate is open (gate × pattern)",
+ "device.shutter.internal_this_track": "Internal — this track",
+ "device.shutter.key_source_internal_keys_off": "Key source — Internal keys off this track; pick another track, or one pad or chain of it, to gate or duck against it",
+ "device.shutter.levels_4_8_or_16": "Levels — 4, 8 or 16 heights a step snaps to",
+ "device.shutter.listen_hear_the_key_as": "Listen — hear the key as the detector hears it (after its filter), to tune the band",
+ "device.shutter.live_the_graph_follows_the": "Live — the graph follows the audio; click to freeze the picture",
+ "device.shutter.lookahead_0_1_or_5": "Lookahead — 0, 1 or 5 ms",
+ "device.shutter.lookahead_the_gate_opens_this": "Lookahead — the gate opens this much before the transient arrives (the track is delayed by it)",
+ "device.shutter.map_pattern_out": " → Map (Pattern Out)",
+ "device.shutter.map_pattern_out_2": "Map → Pattern Out",
+ "device.shutter.mode_gate_lets_the_signal": "Mode — Gate lets the signal through above the threshold; Duck turns it down while the key is above it",
+ "device.shutter.mouse_tool_for_the_grid": "Mouse tool for the grid",
+ "device.shutter.one_opening_attack_hold_release": "One opening: attack, hold, release in the chosen shape, down to the floor (inverted for Duck). Drag a node sideways for its time, the teal floor up or down; double-click resets, ⌥-click types.",
+ "device.shutter.only_while_gate_open": "Only while gate open",
+ "device.shutter.paste_copied_steps_fitted_to": "Paste copied steps (fitted to the grid)",
+ "device.shutter.pattern_shapes_the_arrows_step": "Pattern shapes — the arrows step through them (fitted to the grid)",
+ "device.shutter.peak_hold_the_detector_holds": "Peak hold — the detector holds each peak longer, so low notes and slow waves don't chatter the gate",
+ "device.shutter.range_how_far_the_gate": "Range — how far the gate closes or the duck goes down (−∞ = all the way)",
+ "device.shutter.rate_how_long_the_whole": "Rate — how long the whole pattern takes: 1/4 … 4 bars in Sync, 4 … 0.25 Hz in Free",
+ "device.shutter.reset_clear_the_peak_reduction": "Reset — clear the peak reduction, the opening count and the history",
+ "device.shutter.retrig_every_midi_note_on": "Retrig — every MIDI note on this track (or the key track) restarts the pattern",
+ "device.shutter.retrig_on_midi_note": "Retrig on MIDI note",
+ "device.shutter.retrigger_trigger_mode_each_hit": "Retrigger — trigger mode: each hit fires one attack → hold → release, however long the signal stays above the threshold",
+ "device.shutter.return_how_far_under_the": "Return — how far under the threshold the key must fall before the gate closes (stops chatter)",
+ "device.shutter.roll_a_new_pattern_complexity": "Roll a new pattern — Complexity sets how busy and how varied it is",
+ "device.shutter.sc_eq_the_detector_hears": "SC EQ — the detector hears the key through its band-pass; off = the full band",
+ "device.shutter.shape_linear_straight_ramps_over": "Shape — Linear: straight ramps over the times; Log: the classic one-pole curve; Snap: stays open, then shuts hard",
+ "device.shutter.signal_and_duck": "Signal and duck",
+ "device.shutter.signal_and_gate": "Signal and gate",
+ "device.shutter.signal_tab_click_to_change": "Signal tab: click to change the window — ",
+ "device.shutter.smooth_ramps_into_each_step": "Smooth — ramps into each step instead of jumping (up to half a step)",
+ "device.shutter.steps_8_16_or_32": "Steps — 8, 16 or 32 (the pattern is stretched to fit)",
+ "device.shutter.swing_every_second_step_comes": "Swing — every second step comes late",
+ "device.shutter.target_off_volume_the_pattern": "Target — Off; Volume: the pattern gates the audio; Map: the audio is left alone and the pattern drives Pattern Out, a CV source in the Modular view",
+ "device.shutter.the_detectors_band_pass_teal": "The detector's band-pass (teal) — only this part of the key opens the gate — over the reduction in the window (neutral ink). Drag the nodes sideways; double-click resets, ⌥-click types.",
+ "device.shutter.the_input_teal_and_what": "The input (teal) and what passes (neutral ink) over the window, with the threshold (dashed) and where the gate closes again (dashed). Drag a line up or down; double-click resets it, ⌥-click types it.",
+ "device.shutter.the_level_the_detector_compares": "The level the detector compares — this track's input, or the key when an external sidechain drives it; the dashed tick is the threshold",
+ "device.shutter.the_step_pattern_each_column": "The step pattern — each column is one step's level, the line is the gain it makes (smooth and swing bend it). Draw sets steps, Line draws a ramp, Erase clears, Flip toggles on / off.",
+ "device.shutter.volume_gated": " → Volume · gated",
+ "device.shutter.what_the_gate_is_doing": "What the gate is doing now — closed, attack, open, hold or release — and its gain",
+ "device.sidechain.frozen_its_parts_dont_play": "Frozen — its parts don't play until the track is unfrozen",
+ "device.sidechain.missing": "{0} · missing",
+ "device.sidechain.no_free_routes_every_sidechain": "No free routes — every sidechain route is in use",
+ "device.sidechain.part": "Part {0}",
+ "device.sidechain.the_keyed_part_was_deleted": "The keyed part was deleted — undo brings it back",
+ "device.size_s_260_260_l": "Size: S (260 × 260) / L (700 × 260)",
+ "device.strata.at_bar_end": "at bar end",
+ "device.strata.of_bars": { "one": "of {0} bar", "other": "of {0} bars" },
+ "device.strata.of_one_cycle_shown": "{0} of {1} · one cycle shown",
+ "device.strata.onto_layer": "onto layer {0}",
+ "device.strata.press_record_to_lay_down": "Press Record to lay down the first loop",
+ "device.strata.set_tempo_from_loop": "Set tempo from loop",
+ "device.synth.cycles_unison": "{0} · {1} cycles · unison {2}",
+ "device.synth.filter_off_the_oscillator_goes": "Filter off — the oscillator goes straight to the amplifier",
+ "device.synth.vel_vol_off": "Vel → Vol off",
+ "device.utility.bass_mono_off": "bass mono off",
+ "device.utility.both_phases_inverted": "both phases inverted",
+ "device.utility.channel_stereo_left_or_right": "Channel — Stereo; Left or Right on both sides; Swap the sides",
+ "device.utility.gain_match_moves_gain_once": "Gain match — moves Gain once so the output meets the reference (the input's level, or Target) over the last 3 s, in the meter's unit",
+ "device.utility.input_and_output": "Input and output",
+ "device.utility.input_peak_60_0_dbfs": "Input peak, −60 … 0 dBFS",
+ "device.utility.input_teal_and_output_neutral": "Input (teal) and output (neutral ink) over the last 8 s in the meter's unit; dashed: the target. Drag up or down for the target.",
+ "device.utility.invert_the_left_channels_phase": "Invert the left channel's phase",
+ "device.utility.invert_the_right_channels_phase": "Invert the right channel's phase",
+ "device.utility.lows_at_the_bottom_highs": "lows at the bottom · highs at the top",
+ "device.utility.match_to_input": "match to input",
+ "device.utility.meter_lufs_s_short_term": "Meter — LUFS-S: short-term loudness (3 s, K-weighted); Peak: sample peak; RMS: 300 ms",
+ "device.utility.mono_below_freq": "Mono below freq",
+ "device.utility.mono_below_removes_the_side": "Mono below — removes the side below the cutoff, so the low end is mono",
+ "device.utility.mute_the_output": "Mute the output",
+ "device.utility.out_of_phase_mono_risk": "out of phase — mono risk",
+ "device.utility.output_correlation_1_mono_0": "Output correlation — +1 mono, 0 unrelated, below 0 out of phase (it cancels in mono)",
+ "device.utility.output_peak_60_0_dbfs": "Output peak, −60 … 0 dBFS",
+ "device.utility.pan_by_frequency_1_s": "pan by frequency · 1 s window",
+ "device.utility.reset_gain_back_to_0": "Reset — Gain back to 0 dB, and the meters, holds and the level history start over",
+ "device.utility.slope_of_the_mono_cutoff": "Slope of the mono cutoff — 6, 12 or 24 dB/oct; click to step",
+ "device.utility.the_inputs_level_in_the": "The input's level in the meter's unit (LUFS-S, 1 s peak or 300 ms RMS)",
+ "device.utility.the_outputs_level_in_the": "The output's level in the meter's unit",
+ "device.utility.the_outputs_stereo_field_by": "The output's stereo field by frequency over the last second — lows at the bottom, highs at the top. Solid: where each band sits between L and R; teal: how far it spreads; dashed: how far the width setting spreads an uncorrelated band. Drag sideways for the balance, up or down for the width.",
+ "device.utility.the_usual_cutoffs_60_120": "The usual cutoffs — 60, 120 or 240 Hz (turns Mono below on)",
+ "device.utility.the_width_over_frequency_solid": "The width over frequency — solid: what the settings do (0 % = mono, 100 % = unchanged), the mono region shaded; teal dashed: the output's measured width (side against mid). Drag sideways for the mono cutoff, up or down for the width.",
+ "device.utility.what_gain_match_and_level": "What Gain match and Level match aim for — the input's level, or Target",
+ "device.utility.width_by_frequency": "Width by frequency",
+ "device.utility.width_law_l_r_the": "Width law — L/R: the side is scaled, so wider is louder; M/S: mid and side are traded, so the level holds (200 % = side only)",
+ "device.valve.bright_a_treble_lift_before": "Bright — a treble lift before the preamp, strongest at low gain (the bright cap on a volume pot)",
+ "device.valve.cab_by_model": "cab by model · ",
+ "device.valve.cabinet_match_follows_the_model": "Cabinet — Match follows the model; 1×12 open, 2×12 combo, 4×12 closed, 1×15 bass",
+ "device.valve.cabinet_match_follows_the_model_2": "Cabinet — Match follows the model; the others bring their own low resonance and presence peak. Scroll to step.",
+ "device.valve.deep_a_low_resonance_boost": "Deep — a low resonance boost after the tone stack, for a fuller, tighter bottom",
+ "device.valve.even_harmonics_only": "Even harmonics only",
+ "device.valve.even_only_the_preamp_adds": "Even only — the preamp adds even harmonics only: warmth without the fizz of the odd ones",
+ "device.valve.gain_how_hard_the_signal": "Gain — how hard the signal hits the preamp. Double-click resets.",
+ "device.valve.mic_dynamic_the_classic_close": "Mic — Dynamic: the classic close mic; Condenser: brighter, less proximity bass; Ribbon: dark, the most proximity bass",
+ "device.valve.mic_position_at_the_cones": "Mic position — at the cone's cap (bright) or its edge (darker)",
+ "device.valve.model_the_amps_voicing_how": "Model — the amp's voicing: how hard the preamp drives, how many stages clip, how tight the low end is and which cabinet it matches. Scroll to step.",
+ "device.valve.output_the_master_level_after": "Output — the master level after the cabinet, ±12 dB. Double-click resets.",
+ "device.valve.the_cabinet_as_the_mic": "The cabinet as the mic hears it, with the low / high cuts — dashed is the same cab and mic on axis at the cap, 5 cm away. Drag sideways to move the mic off axis, up to bring it closer.",
+ "device.valve.the_harmonics_the_preamp_adds": "The harmonics the preamp adds at the input's level (the fundamental at the top). Drag up or down for the gain.",
+ "device.valve.the_tone_stack_before_the": "The tone stack before the cabinet — the pre-distortion tightness of the model, Bright, Bass / Middle / Treble / Presence and Deep; dashed is the stack flat. Drag sideways for the middle's frequency, up or down for the middle.",
+ "device.velocity.compand_the_same_around_the": "Compand — the same around the middle: above 1 stretches to the edges, below 1 squeezes to the middle",
+ "device.velocity.curve_bend_the_response_drive": "Curve — bend the response: Drive above 1 lifts soft notes, below 1 pushes them down",
+ "device.velocity.drag_up_down_shift_for": "Drag up / down, Shift for fine, double-click resets",
+ "device.velocity.every_note_at_this_velocity": "every note at this velocity",
+ "device.velocity.fixed_every_note_comes_out": "Fixed — every note comes out at one velocity",
+ "device.velocity.input_across_output_up_dashed": "Input across, output up · dashed — the Out range · band — Random · dots — the last notes",
+ "device.velocity.input_velocity_across_output_up": "Input velocity across, output up. Dashed — the Out range; the band — where Random can put a note; dots — the last notes played",
+ "device.velocity.last": "last {0} → {1}",
+ "device.velocity.out_range_drag_a_handle": "Out range — drag a handle, ⌥-click to type it, double-click resets to 1–127",
+ "device.velocity.random_amount_0_64_velocity": "Random amount, ±0–64 velocity — drag up / down, double-click resets",
+ "device.velocity.random_both_ways_only_up": "Random both ways, only up, or only down",
+ "device.velocity.random_both_ways_up_down": "Random: both ways → up → down → off — click to step, Shift-click back",
+ "device.velocity.random_spread_each_notes_velocity": "Random — spread each note's velocity (the amount is kept while it is off)",
+ "device.velocity.soft_notes_louder": "soft notes louder",
+ "device.velocity.soft_notes_quieter": "soft notes quieter",
+ "device.velocity.squeezed_to_the_middle": "squeezed to the middle",
+ "device.velocity.stretched_to_the_edges": "stretched to the edges",
+ "device.velocity.the_last_12_notes_outline": "The last 12 notes: outline — velocity in, fill — velocity out",
+ "device.velocity.velocity_mode_curve_compand_fixed": "Velocity mode: Curve / Compand / Fixed — click for the next, Shift-click for the previous",
+ "device.vintage.analog_stage_a_console_style": "Analog stage — a console-style soft clip after the saturation (click again for none)",
+ "device.vintage.auto_comp_the_output_level": "Auto-comp — the output level follows the input's, however hard the drive",
+ "device.vintage.character_the_era_the_signal": "Character — the era the signal passes through: its saturation, tone, band-limit and how much hiss, crackle, wow and flutter it brings. Scroll to step.",
+ "device.vintage.drive_how_hard_the_signal": "Drive — how hard the signal hits the saturation. ⌥-click types, double-click resets.",
+ "device.vintage.even_harmonics_only": "Even harmonics only",
+ "device.vintage.sync_the_wow_follows_the": "Sync — the wow follows the tempo: one sway every 4 bars … 1/8 (RATE picks it)",
+ "device.vintage.the_harmonics_the_saturation_adds": "The harmonics the saturation adds at the input's level (the fundamental at the top), against the hiss floor in teal. Drag up or down for the drive, ⌥-click to type it.",
+ "device.vintage.the_pitch_drift_over_the": "The pitch drift over the last four seconds — wow in neutral ink, flutter in teal. Drag up or down for the depth of what is picked above, sideways for its rate; ⌥-click to type them.",
+ "device.vintage.the_transfer_curve_the_saturation": "The transfer curve the saturation runs — input level across, output up; dashed is the dry line, teal what you hear with Mix and Output, the dot where the input peak sits. Drag up or down for the drive, ⌥-click to type it.",
+ "device.vintage.tone_model_warm_the_eras": "Tone model — Warm: the era's own tilt and head bump; Flat: the TONE knob alone; Dark: a lower, darker tilt",
+ "device.vintage.tube_stage_a_warm_asymmetric": "Tube stage — a warm, asymmetric valve stage after the saturation (click again for none)",
+ "device.vintage.wear_follows_input": "Wear follows input",
+ "device.vintage.wear_the_age_of_the": "Wear — the age of the medium: a narrower band, more hiss and crackle, a wandering flutter. ⌥-click types, double-click resets.",
+ "device.vintage.what_the_window_shows_and": "What the window shows and a drag in it edits",
+ "device.vocoder.attack_how_fast_a_band": "Attack — how fast a band opens, 0.5 … 100 ms",
+ "device.vocoder.bands_how_many_bands_8": "Bands — how many bands, 8 … 32: fewer is more robotic, more is clearer",
+ "device.vocoder.carrier_track_the_track_the": "Carrier track — the track the voice shapes when Carrier is Track; this track and its groups are not offered",
+ "device.vocoder.carrier_what_the_voice_shapes": "Carrier — what the voice shapes: an internal saw (at Pitch), noise, or another track picked below",
+ "device.vocoder.formant_moves_the_carriers_bands": "Formant — moves the carrier's bands against the modulator's, ±12 st: up sounds smaller, down larger",
+ "device.vocoder.gain_the_output_level_12": "Gain — the output level, ±12 dB",
+ "device.vocoder.high_the_highest_bands_edge": "High — the highest band's edge, 2 … 20 kHz",
+ "device.vocoder.hold_freezes_every_band_where": "Hold — freezes every band where it is; the carrier keeps sounding through it",
+ "device.vocoder.low_the_lowest_bands_edge": "Low — the lowest band's edge, 20 Hz … 1 kHz",
+ "device.vocoder.mix_the_carrier_as_it": "Mix — the carrier as it came in against the vocoded sound",
+ "device.vocoder.mod_gain_trims_the_voice": "Mod gain — trims the voice before the bands hear it, ±24 dB",
+ "device.vocoder.pick_a_carrier_track_until": "Pick a carrier track · until then the sound passes through",
+ "device.vocoder.pitch_the_internal_saws_note": "Pitch — the internal saw's note, C0 … C7",
+ "device.vocoder.q_how_narrow_each_band": "Q — how narrow each band is, 1 … 10",
+ "device.vocoder.release_how_fast_a_band": "Release — how fast a band closes, 5 … 1000 ms",
+ "device.vocoder.the_modulator_is_the_sound": "The modulator is the sound of the track the vocoder sits on — the voice",
+ "device.vocoder.the_modulators_level_in_each": "The modulator's level in each band (bars) and the carrier's (teal). Drag an edge to move Low or High; ⌥-click an edge to type it, double-click resets it.",
+ "device.vocoder.the_vocoders_output_level": "The vocoder's output level",
+ "device.vocoder.the_voices_level_after_mod": "The voice's level after Mod gain",
+ "device.vocoder.tilt_brightens_or_darkens_the": "Tilt — brightens (or darkens) the saw or the carrier track around 1 kHz before the bands, ±12 dB",
+ "device.vocoder.unvoiced_adds_noise_where_the": "Unvoiced — adds noise where the modulator hisses, so consonants stay clear",
+ "device.vocoder.where_the_carrier_track_is": "Where the carrier track is tapped: before its effects and fader, or after. Pre keeps feeding while the track is muted",
+ "device.volt.8_slots_assigned": "8 slots · {0} assigned",
+ "device.volt.click_for_the_next_target": "Click for the next target, right-click for the previous",
+ "device.volt.drag_a_cell_up_adds": "drag a cell — up adds, down subtracts · ⌥-click types · double-click clears",
+ "device.volt.vibrato_always_rides_the_pitch": "vibrato always rides the pitch",
+ "device.volt.zero_every_route_in_the": "Zero every route in the matrix",
+ "device_chain.active_click_to_bypass": "Active — click to bypass",
+ "device_chain.add_an_audio_effect_search": "Add an audio effect: search the browser, or drop a device here",
+ "device_chain.bypassed_click_to_enable": "Bypassed — click to enable",
+ "device_chain.clipboard.a_drum_rack_cant_be": "A Drum Rack can't be ungrouped",
+ "device_chain.clipboard.a_plug_in_cant_go": "A plug-in can't go in a MIDI Effect Rack",
+ "device_chain.clipboard.a_rack_cant_go_inside": "A rack can't go inside another rack",
+ "device_chain.clipboard.an_instrument_rack_cant_go": "An Instrument Rack can't go inside another Instrument Rack",
+ "device_chain.clipboard.audio_effect": "Audio effect · {0}",
+ "device_chain.clipboard.couldnt_paste_a_device_failed": "Couldn't paste: a device failed to load.",
+ "device_chain.clipboard.couldnt_paste_the_instrument": "Couldn't paste the instrument.",
+ "device_chain.clipboard.delete_track": "Delete track",
+ "device_chain.clipboard.deleted_devices": "Deleted {0} devices",
+ "device_chain.clipboard.device": "Device",
+ "device_chain.clipboard.devices": { "one": "{0} device", "other": "{0} devices" },
+ "device_chain.clipboard.group_into_rack": "Group into rack",
+ "device_chain.clipboard.its_macros_and_chain_settings": " — its macros and chain settings were dropped",
+ "device_chain.clipboard.midi_effect": "MIDI effect · {0}",
+ "device_chain.clipboard.nothing_to_paste": "Nothing to paste.",
+ "device_chain.clipboard.only_a_rack_with_one": "Only a rack with one chain can be ungrouped",
+ "device_chain.clipboard.only_an_instrument_track_takes": "Only an instrument track takes MIDI effects and an instrument",
+ "device_chain.clipboard.only_an_instrument_track_takes_2": "Only an instrument track takes an instrument.",
+ "device_chain.clipboard.paste_an_instrument_on_an": "Paste an instrument on an instrument card.",
+ "device_chain.clipboard.pasted": "Pasted {0}",
+ "device_chain.clipboard.pasted_devices": "Pasted {0} devices",
+ "device_chain.clipboard.pasted_devices_skipped_this_track": "Pasted {0} devices, skipped {1} this track can't take",
+ "device_chain.clipboard.put_devices_in": "Put {0} devices in {1}",
+ "device_chain.clipboard.put_in": "Put {0} in {1}",
+ "device_chain.clipboard.select_a_rack_to_take": "Select a rack to take its devices out",
+ "device_chain.clipboard.select_devices_next_to_each": "Select devices next to each other to group them",
+ "device_chain.clipboard.select_devices_to_put_them": "Select devices to put them in a rack",
+ "device_chain.clipboard.selected": "Selected",
+ "device_chain.clipboard.some_devices_cant_be_duplicated": "Some devices can't be duplicated",
+ "device_chain.clipboard.the_racks_chain_has_no": "The rack's chain has no instrument to put back",
+ "device_chain.clipboard.these_devices_cant_be_copied": "These devices can't be copied, so they weren't cut.",
+ "device_chain.clipboard.these_devices_cant_be_grouped": "These devices can't be grouped",
+ "device_chain.clipboard.this_device_cant_be_copied": "This device can't be copied, so it wasn't cut.",
+ "device_chain.clipboard.this_rack_cant_be_ungrouped": "This rack can't be ungrouped",
+ "device_chain.clipboard.this_track_cant_take_the": "This track can't take the copied devices.",
+ "device_chain.clipboard.took_devices_out_of_the": "Took {0} devices out of the rack",
+ "device_chain.clipboard.took_the_device_out_of": "Took the device out of the rack",
+ "device_chain.clipboard.ungroup_rack": "Ungroup rack",
+ "device_chain.clipboard.with_the_instrument": "With the instrument",
+ "device_chain.fold.double_click_to_unfold": "{0} — double-click to unfold",
+ "device_chain.fold.unfold": "Unfold",
+ "device_chain.instruments.drums_pads": { "one": "Drums · {0} pad", "other": "Drums · {0} pads" },
+ "device_chain.instruments.presets_are_unavailable": "Presets are unavailable.",
+ "device_chain.move.move_to_track": "Move to track",
+ "device_chain.move.plug_ins": "Plug-ins",
+ "device_chain.move.replace": "Replace…",
+ "device_chain.no_return_tracks": "No return tracks",
+ "device_chain.rack_chains": { "one": "Rack · {0} chain", "other": "Rack · {0} chains" },
+ "device_chain.remove_device": "Remove device",
+ "device_chain.remove_track": "Remove track",
+ "device_chain.select_a_track": "Select a track",
+ "device_chain.shell.click_to_select_double_click": "Click to select · double-click to fold · right-click to replace, copy or move",
+ "device_chain.shell.compare": "Compare: {0}",
+ "device_chain.shell.copy_a_to_b": "Copy A to B",
+ "device_chain.shell.copy_b_to_a": "Copy B to A",
+ "device_chain.shell.double_click_to_fold_right": "Double-click to fold · right-click for more",
+ "device_chain.shell.drag_to_reorder_double_click": "Drag to reorder · double-click to fold · right-click for A/B, move and delete",
+ "device_chain.shell.fold": "Fold",
+ "device_chain.shell.init": "Init",
+ "device_chain.shell.mono": "Mono",
+ "device_chain.shell.move_left": "Move left",
+ "device_chain.shell.move_right": "Move right",
+ "device_chain.shell.next_preset": "Next preset",
+ "device_chain.shell.off_click_to_turn_the": "Off — click to turn the instrument on",
+ "device_chain.shell.on_click_to_turn_the": "On — click to turn the instrument off",
+ "device_chain.shell.preset": "Preset: {0}",
+ "device_chain.shell.previous_preset": "Previous preset",
+ "device_insert.a_drum_rack_takes_kits": "A Drum Rack takes kits and instruments; load an instrument preset on a pad from its card.",
+ "device_insert.added_chain": "Added {0} chain",
+ "device_insert.added_on_a_new_audio": "Added {0} on a new audio track (track {1})",
+ "device_insert.added_pad": "Added {0} pad",
+ "device_insert.added_to_track": "Added {0} to track {1}",
+ "device_insert.added_track": "Added {0} (track {1})",
+ "device_insert.all_16_pads_are_used": "All 16 pads are used.",
+ "device_insert.applied_preset": "Applied preset {0}",
+ "device_insert.cant_go_on_a_track": "{0} can't go on a track.",
+ "device_insert.changed_instrument_to": "Changed instrument to {0}",
+ "device_insert.changed_instrument_to_track": "Changed instrument to {0} (track {1})",
+ "device_insert.couldnt_add_a_track_for": "Couldn't add a track for {0}.",
+ "device_insert.drop_failed": "Drop failed: {0}",
+ "device_insert.drop_midi_files_onto_the": "Drop MIDI files onto the arrangement or a session slot.",
+ "device_insert.drop_onto_a_track": "Drop onto a track.",
+ "device_insert.drop_samples_onto_the_arrangement": "Drop samples onto the arrangement.",
+ "device_insert.failed_to_load_effect": "Failed to load effect.",
+ "device_insert.kits_are_unavailable": "Kits are unavailable.",
+ "device_insert.loaded": "Loaded {0}",
+ "device_insert.loaded_kit": "Loaded {0} kit",
+ "device_insert.loaded_root": "Loaded {0} · root {1}",
+ "device_insert.midi_effects_need_an_instrument": "MIDI effects need an instrument track.",
+ "device_insert.midi_effects_need_an_instrument_2": "MIDI effects need an instrument track: add an instrument first.",
+ "device_insert.presets_are_unavailable": "Presets are unavailable.",
+ "device_insert.replaced_with": "Replaced with {0}",
+ "device_selection.midi_and_audio_effects_go": "MIDI and audio effects go in one rack only with the instrument between them",
+ "device_selection.select_devices_next_to_each": "Select devices next to each other to group them",
+ "download_jobs.cancelling": "Cancelling…",
+ "download_jobs.installing_failed": "Installing {0} failed: {1}",
+ "download_jobs.installing_was_cancelled": "Installing {0} was cancelled.",
+ "dropout_counter.dropouts": { "one": "{0} dropout", "other": "{0} dropouts" },
+ "drum_pattern.bars": "Bars",
+ "drum_pattern.click_to_place_shift_click": "click to place · shift-click accents · drag to paint",
+ "drum_pattern.drop_samples_on_the_drum": "Drop samples on the Drum Rack pads in Devices, then step them here.",
+ "drum_pattern.no_pads_loaded": "No pads loaded",
+ "drum_pattern.pads": { "one": "{0} pad", "other": "{0} pads" },
+ "drum_pattern.play_and_show_its_velocity": "Play {0} · {1} and show its velocity lane",
+ "drum_pattern.steps": { "one": "{0} step", "other": "{0} steps" },
+ "editing.snap_grid.2_bars": "2 bars",
+ "editing.snap_grid.4_bars": "4 bars",
+ "editing.snap_grid.auto": "Auto · {0}",
+ "export.16_bit_only": "16-bit only",
+ "export.1_file_mb_offline_render": "≈ 1 file · {0:0.0} MB · offline render",
+ "export.add_1_bar_release_tail": "Add 1-bar release tail",
+ "export.bar_beat_sixteenth_counted_from": "Bar.beat.sixteenth, counted from 1 — e.g. 5.1 or 5.3.2",
+ "export.bit_depth": "Bit depth",
+ "export.custom": "Custom",
+ "export.dither": "Dither",
+ "export.end": "End",
+ "export.export": "Export {0}",
+ "export.export_audio": "Export audio",
+ "export.export_stems": "Export stems",
+ "export.export_wav": "Export WAV",
+ "export.format": "Format",
+ "export.full_song": "Full song",
+ "export.normalize_1_dbtp": "Normalize −1 dBTP",
+ "export.not_a_position_type_bar": "Not a position: type bar.beat, like 5.1",
+ "export.one_file_per_track_mb": "one file per track · {0:0.0} MB each · offline render",
+ "export.one_file_per_track_post": "· one file per track, post-fader",
+ "export.positions_are_bar_beat_sixteenth": "Positions are bar.beat.sixteenth, counted from 1 as in the transport: 5 or 5.1 is the start of bar 5, 5.3 its third beat. The export stops at the end position, so 1 to 5 is four bars.",
+ "export.quality": "Quality",
+ "export.sample_rate": "Sample rate",
+ "export.the_end_must_be_after": "The end must be after the start",
+ "history.add_note": "Add note…",
+ "history.clean_up_the_history": "Clean up the history",
+ "history.couldnt_change_the_version": "Couldn't change the version: {0}",
+ "history.current": "Current",
+ "history.current_version": "Current version",
+ "history.delete_audio_that_only_this": "Delete {0}? Audio that only this version uses is deleted from the project folder too. This can't be undone.",
+ "history.delete_the_selected_versions_and": "Delete the selected versions and the audio only they use",
+ "history.delete_unnamed_versions": "Delete unnamed versions",
+ "history.delete_unnamed_versions_2": "Delete unnamed versions…",
+ "history.delete_unnamed_versions_n": { "one": "Delete {0} unnamed version…", "other": "Delete {0} unnamed versions…" },
+ "history.delete_version": "Delete version",
+ "history.delete_version_2": "Delete version…",
+ "history.delete_versions": "Delete versions",
+ "history.delete_versions_and_the_audio": { "one": "Delete {0} version and the audio only it uses? The current version, the latest version of each branch, and every named, starred or noted version stay. This can't be undone.", "other": "Delete {0} versions and the audio only they use? The current version, the latest version of each branch, and every named, starred or noted version stay. This can't be undone." },
+ "history.delete_versions_audio_that_only": { "one": "Delete {0} version? Audio that only it uses is deleted from the project folder too. This can't be undone.", "other": "Delete {0} versions? Audio that only they use is deleted from the project folder too. This can't be undone." },
+ "history.delete_versions_n": { "one": "Delete {0} version…", "other": "Delete {0} versions…" },
+ "history.deleted_versions": { "one": "Deleted {0} version", "other": "Deleted {0} versions" },
+ "history.each_save_adds_a_version": "Each save adds a version here.",
+ "history.edit_note": "Edit note…",
+ "history.freed": "{0} · {1} freed",
+ "history.its_versions_cant_be_listed": "Its versions can't be listed until the file .history/versions.json is repaired.",
+ "history.name": "Name…",
+ "history.name_version": "Name version",
+ "history.no_starred_versions_yet_right": "No starred versions yet. Right-click a version and choose Star.",
+ "history.nota": "Nota {0}",
+ "history.older_versions_take_on_disk": "{0} · older versions take {1} on disk",
+ "history.open_as_copy": "Open as copy…",
+ "history.open_copy": "Open copy",
+ "history.open_this_version_as_a": "Open this version as a new project, keeping this one as it is",
+ "history.remove_name": "Remove name",
+ "history.remove_note": "Remove note",
+ "history.remove_star": "Remove star",
+ "history.save_the_project_to_start": "Save the project to start its history.",
+ "history.saved_by_a_newer_nota": "Saved by a newer Nota — update to open it.",
+ "history.show_all_versions": "Show all versions",
+ "history.show_starred_versions_only": "Show starred versions only",
+ "history.star": "Star",
+ "history.switch": "Switch",
+ "history.switch_the_project_to_this": "Switch the project to this version",
+ "history.switch_to_another_version_to": "Switch to another version to delete this one",
+ "history.switch_to_this_version": "Switch to this version",
+ "history.the_current_version_stays": "The current version stays",
+ "history.the_current_version_stays_2": "The current version stays.",
+ "history.the_project_is_at_this": "The project is at this version",
+ "history.version": "Version",
+ "history.version_history_is_turned_off": "Version history is turned off in Settings.",
+ "history.version_name": "Version name",
+ "history.version_note": "Version note",
+ "history.versions": "Versions",
+ "history.versions_n": { "one": "{0} version", "other": "{0} versions" },
+ "history.what_changed_in_this_version": "What changed in this version?",
+ "kits.drum_kit.couldnt_create_a_drum_rack": "Couldn't create a Drum Rack track.",
+ "kits.drum_kit.couldnt_create_a_nota_rhythm": "Couldn't create a Nota Rhythm track.",
+ "kits.drum_kit.unknown_drum_kit": "Unknown drum kit.",
+ "lens.nota_lens": "Nota Lens · {0}",
+ "linux_file_dialogs.the_system_file_dialog_answered": "the system file dialog answered without showing",
+ "linux_file_dialogs.the_system_file_dialog_didnt": "the system file dialog didn't open within {0:0} s",
+ "linux_file_dialogs.the_system_file_dialog_failed": "the system file dialog failed: {0}",
+ "linux_file_dialogs.using_notas_built_in_file": "Using Nota's built-in file dialog: {0}. Check xdg-desktop-portal and its FileChooser backend.",
+ "main.adaptive_grid": "Adaptive grid",
+ "main.added_to_slot": "Added {0} to slot",
+ "main.all_return_buses_are_in": "All return buses are in use.",
+ "main.arrangement": "Arrangement",
+ "main.asio_driver_couldnt_start_using": "ASIO driver ‘{0}’ couldn't start — using WASAPI. {1}",
+ "main.audio_asio_hz_frames": "Audio: ASIO · {0} · {1:0} Hz · {2} frames",
+ "main.audio_device_error": "Audio device error: {0}",
+ "main.audio_driver_settings_changed_frames": "Audio: driver settings changed · {0} frames",
+ "main.audio_dropout": "⚠ Audio dropout ({0})",
+ "main.audio_dropouts_since_the_device": "Audio dropouts since the device started: buffers Nota couldn't fill in time, heard as clicks or gaps. If they keep coming, raise the buffer size or freeze heavy tracks. Click to reset",
+ "main.audio_format.audio_settings": "Audio settings…",
+ "main.audio_format.buffer_size": "Buffer size",
+ "main.audio_format.device_default": "Device default",
+ "main.audio_format.driver_settings": "Driver settings…",
+ "main.audio_format.exclusive_mode_uses_the_devices": "Exclusive mode uses the device's buffer",
+ "main.audio_format.set_in_the_asio_drivers": "Set in the ASIO driver's settings",
+ "main.audio_format.stop_recording_to_change_it": "Stop recording to change it",
+ "main.audio_hz": "Audio: {0:0} Hz",
+ "main.audio_hz_frames": "Audio: {0:0} Hz · {1} frames",
+ "main.audio_import.failed_to_load": "Failed to load {0}",
+ "main.audio_import.failed_to_load_n": "Failed to load {0}: {1}",
+ "main.audio_import.import_of_cancelled": "Import of {0} cancelled",
+ "main.audio_import.importing": "Importing {0}…",
+ "main.audio_import.loop_warped_bpm": "loop warped {0} → {1} BPM",
+ "main.audio_import.one_shot_not_warped": "one-shot, not warped",
+ "main.audio_import.processing": "{0} · Processing…",
+ "main.audio_import.processing_n": "{0} · Processing… {1:0} %",
+ "main.audio_import.transposed_st_to": "transposed {0} st to {1}",
+ "main.audio_import.warped_to_tempo_bpm": "warped to tempo ({0:0.0} BPM)",
+ "main.audio_import.warping": "Warping {0}… {1:0} %",
+ "main.audio_track_arm_it_and": "Audio track {0} — arm it and hit Rec to record input",
+ "main.auto_arm_selected_track": "Auto-arm selected track",
+ "main.bass": "Bass",
+ "main.bounce_to_a_linked_audio": "Bounce to a linked audio track below and put the source to sleep",
+ "main.browser.couldnt_delete": "Couldn't delete {0}",
+ "main.browser.delete_preset": "Delete preset",
+ "main.browser.delete_project": "Delete project",
+ "main.browser.load_failed": "Load failed: {0}",
+ "main.browser.move_to_the_trash": "Move “{0}” to the Trash?",
+ "main.browser.moved_to_trash": "Moved {0} to Trash",
+ "main.browser.nothing_to_save_built_in": "Nothing to save (built-in synth has no state).",
+ "main.browser.only_plug_in_chain_instruments": "Only plug-in chain instruments can be saved as presets.",
+ "main.browser.preset_name": "Preset name",
+ "main.browser.reveal_failed": "Reveal failed: {0}",
+ "main.browser.save_preset_failed": "Save preset failed: {0}",
+ "main.browser.saved_preset": "Saved preset {0}",
+ "main.cancel_the_download": "Cancel the download",
+ "main.clip_editor_fills_the_window": "Clip editor fills the window",
+ "main.clip_names": "Clip names",
+ "main.close_the_drivers_settings_window": "Close the driver's settings window to apply the change",
+ "main.command_palette": "Command palette…",
+ "main.commands.arrangement_grid": "Arrangement grid: {0}",
+ "main.commands.clip_editor_grid": "Clip editor grid: {0}",
+ "main.commands.envelopes_follow_clips": "Envelopes follow clips",
+ "main.commands.envelopes_locked_clip_moves_keep": "Envelopes locked — clip moves keep automation in place",
+ "main.commands.grouped_tracks": "Grouped tracks",
+ "main.commands.no_notes_outside_the_scale": "No notes outside the scale",
+ "main.commands.nothing_to_undo": "Nothing to undo",
+ "main.commands.open_a_midi_clip_first": "Open a MIDI clip first",
+ "main.commands.open_the_session_view_first": "Open the Session view first",
+ "main.commands.quantized_notes": "Quantized notes",
+ "main.commands.scenes_live_in_the_session": "Scenes live in the Session view",
+ "main.commands.select_a_clip_first": "Select a clip first",
+ "main.commands.select_a_clip_or_a": "Select a clip or a range first",
+ "main.commands.select_a_time_range_first": "Select a time range first",
+ "main.commands.select_a_track_first": "Select a track first",
+ "main.commands.select_clips_or_a_range": "Select clips or a range first",
+ "main.commands.select_tracks_first": "Select tracks first",
+ "main.commands.select_two_or_more_midi": "Select two or more MIDI clips",
+ "main.commands.selecting_a_track_leaves_the": "Selecting a track leaves the arms alone",
+ "main.commands.selecting_an_instrument_track_arms": "Selecting an instrument track arms it",
+ "main.commands.snap_off": "Snap off",
+ "main.commands.this_track_cant_be_frozen": "This track can't be frozen",
+ "main.commands.track_headers_on_the_left": "Track headers on the left",
+ "main.commands.ungrouped": "Ungrouped",
+ "main.connect_phone": "Connect phone…",
+ "main.convert.analysing": "Analysing…",
+ "main.convert.building_pads": "Building pads…",
+ "main.convert.convert_failed": "Convert failed: {0}",
+ "main.convert.converted_harmony_notes_new_track": "Converted harmony: {0} notes → new track {1}",
+ "main.convert.converted_hits": "Converted {0} hits",
+ "main.convert.converted_melody_notes_new_track": "Converted melody: {0} notes → new track {1}",
+ "main.convert.converted_notes_new_track": "Converted {0}: {1} notes → new track {2}",
+ "main.convert.detecting_harmony": "Detecting harmony…",
+ "main.convert.detecting_hits": "Detecting hits…",
+ "main.convert.detecting_pitch": "Detecting pitch…",
+ "main.convert.detecting_transients": "Detecting transients…",
+ "main.convert.listening_for_notes": "Listening for notes…",
+ "main.convert.new_drum_rack_track": "{0} → new Drum Rack track {1}",
+ "main.convert.no_drum_hits_found": "No drum hits found.",
+ "main.convert.no_found": "No {0} found.",
+ "main.convert.no_harmony_found": "No harmony found.",
+ "main.convert.no_melody_found": "No melody found.",
+ "main.convert.nothing_to_slice": "Nothing to slice.",
+ "main.convert.sliced_into_pads": "Sliced into {0} pads",
+ "main.convert.slicing_pads": "Slicing pads… {0}",
+ "main.convert.that_converter_isnt_available_yet": "That converter isn't available yet.",
+ "main.convert.this_clip_has_no_audio": "This clip has no audio to convert.",
+ "main.convert_melody_and_convert_harmony": "Convert Melody and Convert Harmony now use the AI model.",
+ "main.convert_to_midi": "Convert to MIDI",
+ "main.copied_range": "Copied range",
+ "main.copied_track_s": "Copied track(s)",
+ "main.copy_clips_to_session_arrangement": "Copy clips to Session / Arrangement",
+ "main.couldnt_freeze_this_track": "Couldn't freeze this track.",
+ "main.cut_range": "Cut range",
+ "main.cut_track_s": "Cut track(s)",
+ "main.deleted_clip_s": "Deleted clip(s)",
+ "main.deleted_track_s": "Deleted track(s)",
+ "main.detail.audio": "Audio ",
+ "main.detail.back_to_the_split_f": "Back to the split (⌘⇧F)",
+ "main.detail.clip_editor_every_clip_on": "Clip editor: every clip on the track",
+ "main.detail.clip_editor_one_clip": "Clip editor: one clip",
+ "main.detail.group": "Group {0}",
+ "main.detail.in": "In ",
+ "main.detail.inst": "Inst ",
+ "main.detail.midi_from": "MIDI from ",
+ "main.detail.monitor_in": "Monitor in",
+ "main.detail.pdc_ms": "PDC {0:0.0} ms",
+ "main.detail.select_a_clip_to_edit": "Select a clip to edit it.",
+ "main.detail.select_a_midi_clip_on": "Select a MIDI clip on a Drum Rack track to step it.",
+ "main.detail.the_clip_editor_is_in": "The clip editor is in its own window",
+ "main.detail.track_clip": "Track {0} clip",
+ "main.detail.track_scene": "Track {0} · Scene {1}",
+ "main.detail_window.select_a_clip_in_the": "Select a clip in the arrangement to edit it here",
+ "main.device_moves.cant_take": "“{0}” can't take {1}.",
+ "main.device_moves.copied_to": "Copied {0} to {1}",
+ "main.device_moves.couldnt_copy": "Couldn't copy {0}.",
+ "main.device_moves.couldnt_move": "Couldn't move {0}.",
+ "main.device_moves.cut_deleted": "Cut {0} — deleted {1}",
+ "main.device_moves.delete_track": "Delete track",
+ "main.device_moves.delete_track_the_track_and": "Delete track “{0}”? The track and its {1} selected devices will be removed.",
+ "main.device_moves.deleted": " · deleted {0}",
+ "main.device_moves.deleted_n": "Deleted {0}",
+ "main.device_moves.has_clips_delete_the_track": "“{0}” has clips. Delete the track with its clips?",
+ "main.device_moves.modulation_links_left_on": " · modulation links left on {0}",
+ "main.device_moves.move": "Move",
+ "main.device_moves.move_devices_to_and_delete": "Move {0} devices to “{1}” and delete “{2}”?",
+ "main.device_moves.move_to_and_delete_with": "Move {0} to “{1}” and delete “{2}” with its clips?",
+ "main.device_moves.moved_devices_to": "Moved {0} devices to {1}",
+ "main.device_moves.moved_devices_to_couldnt_move": "Moved {0} devices to {1} · {2} couldn't move",
+ "main.device_moves.moved_to": "Moved {0} to {1}",
+ "main.device_moves.sidechain_cleared": " · sidechain cleared",
+ "main.devices": "Devices",
+ "main.dnd.couldnt_add_to_the_rack": "Couldn't add {0} to the rack.",
+ "main.dnd.drop_effects_onto_a_column": "Drop effects onto a column.",
+ "main.dnd.drop_failed": "Drop failed: {0}",
+ "main.dnd.drop_samples_and_midi_files": "Drop samples and MIDI files onto a slot.",
+ "main.dnd.drop_samples_onto_audio_slots": "Drop samples onto audio slots.",
+ "main.done": "Done",
+ "main.downloads.dismiss": "Dismiss",
+ "main.downloads.open_settings_downloads": "Open Settings → Downloads",
+ "main.drums": "Drums",
+ "main.dsp_caps": "DSP {0}%",
+ "main.dsp_load_of_the_audio": "DSP load: {0} of the audio buffer time — dropouts start near 100 %",
+ "main.duplicate_clip": "Duplicate clip",
+ "main.duplicated_track_s": "Duplicated track(s)",
+ "main.exit": "Exit",
+ "main.export_audio": "Export audio…",
+ "main.files.audio": "{0} audio",
+ "main.files.export": "Export",
+ "main.files.export_failed": "Export failed: {0}",
+ "main.files.export_master_to": "Export master to {0}",
+ "main.files.export_stems_to_folder": "Export stems to folder",
+ "main.files.exported": "Exported {0}",
+ "main.files.exported_stems": { "one": "Exported {0} stem", "other": "Exported {0} stems" },
+ "main.files.exporting": "Exporting…",
+ "main.files.exporting_n": "Exporting {0}… {1:0} %",
+ "main.files.exporting_stems": "Exporting stems…",
+ "main.files.import_audio": "Import audio",
+ "main.files.new_project": "New project.",
+ "main.files.nota": "Nota — {0}",
+ "main.files.nota_project": "Nota project",
+ "main.files.nothing_to_export_the_arrangement": "Nothing to export — the arrangement is empty.",
+ "main.files.open_failed": "Open failed: {0}",
+ "main.files.open_nota_project_nota_folder": "Open Nota project (.nota folder)",
+ "main.files.open_project": "Open project",
+ "main.files.opened": "Opened {0}",
+ "main.files.opened_item_s_downgraded": "Opened {0} — {1} item(s) downgraded: {2}",
+ "main.files.preparing_warped_clips": "Preparing warped clips…",
+ "main.files.preparing_warped_clips_n": "Preparing warped clips… {0:0} %",
+ "main.files.save_failed": "Save failed: {0}",
+ "main.files.save_nota_project": "Save Nota project",
+ "main.files.save_your_changes_before_opening": "Save your changes before opening another project?",
+ "main.files.save_your_changes_before_starting": "Save your changes before starting a new project?",
+ "main.files.saved": "Saved {0}",
+ "main.files.saved_unsupported_item_s_skipped": "Saved {0} — {1} unsupported item(s) skipped: {2}",
+ "main.files.unsupported_file_location": "Unsupported file location.",
+ "main.files.unsupported_project_location": "Unsupported project location.",
+ "main.files.untitled": "Untitled",
+ "main.fill_the_window_with_the": "Fill the window with the clip editor (⌘⇧F)",
+ "main.flatten": "Flatten",
+ "main.flatten_remove_source": "Flatten (remove source)",
+ "main.flatten_track": "Flatten track",
+ "main.follow_is_paused_while_you": "Follow is paused while you look elsewhere · P or a click here picks it up again",
+ "main.follow_paused_press_p_to": "Follow paused · press P to go back to the playhead",
+ "main.follow_playhead": "Follow playhead",
+ "main.follow_playhead_off": "Follow playhead off",
+ "main.following_the_playhead": "Following the playhead",
+ "main.freeze.discard_edits": "Discard edits",
+ "main.freeze.done_re_freeze": "Done — re-freeze",
+ "main.freeze.edit_source": "Edit source",
+ "main.freeze.flatten_failed": "Flatten failed: {0}",
+ "main.freeze.flatten_replaces_this_tracks_instrument": "Flatten replaces this track's instrument, MIDI and devices with a single audio clip of the frozen sound. ",
+ "main.freeze.flatten_to_audio_track": "Flatten to audio track",
+ "main.freeze.freeze_failed": "Freeze failed: {0}",
+ "main.freeze.freeze_the_track_first_then": "Freeze the track first, then Flatten.",
+ "main.freeze.freeze_track": "Freeze track",
+ "main.freeze.freeze_tracks": "Freeze {0} tracks",
+ "main.freeze.freezing_track": "Freezing track…",
+ "main.freeze.freezing_track_n": "Freezing track… {0:0} %",
+ "main.freeze.freezing_track_of": "Freezing track {0} of {1}… {2:0} %",
+ "main.freeze.freezing_tracks": "Freezing tracks…",
+ "main.freeze.froze_of_tracks": "Froze {0} of {1} tracks.",
+ "main.freeze.frozen": "Frozen",
+ "main.freeze.this_cant_be_undone_continue": "This can't be undone. Continue?",
+ "main.freeze.track_flattened_to_audio": "Track flattened to audio.",
+ "main.freeze.track_frozen_its_devices_are": "Track frozen — its devices are idle until you unfreeze.",
+ "main.freeze.track_unfrozen": "Track unfrozen.",
+ "main.freeze.tracks_frozen_their_devices_are": "{0} tracks frozen — their devices are idle until you unfreeze.",
+ "main.freeze.tracks_unfrozen": "{0} tracks unfrozen.",
+ "main.freeze.unfreeze_track": "Unfreeze track",
+ "main.freeze.unfreeze_tracks": "Unfreeze {0} tracks",
+ "main.freeze_the_track_to_audio": "Freeze the track to audio to free CPU (right-click to flatten)",
+ "main.gamepad.gamepad_octave_c": "Gamepad octave: C{0}",
+ "main.gamepad.octave": "Octave +",
+ "main.gamepad.octave_2": "Octave −",
+ "main.gamepad.velocity": "Velocity +",
+ "main.gamepad.velocity_2": "Velocity −",
+ "main.hand_overridden_controls_back_to": "Hand overridden controls back to their automation",
+ "main.help": "Help",
+ "main.hide_the_mixer": "Hide the mixer",
+ "main.history.choose_a_new_name_for": "Choose a new name for the copy — it can't replace an existing project.",
+ "main.history.couldnt_open_the_version": "Couldn't open the version: {0}",
+ "main.history.couldnt_switch_version": "Couldn't switch version: {0}",
+ "main.history.open_version_as_a_new": "Open version as a new project",
+ "main.history.open_version_as_copy": "Open version as copy",
+ "main.history.opened_as": "Opened {0} as {1}",
+ "main.history.save_version": "Save version",
+ "main.history.save_your_changes_as_a": "Save your changes as a new version before switching?",
+ "main.history.save_your_changes_before_opening": "Save your changes before opening the copy?",
+ "main.history.switch_version": "Switch version",
+ "main.history.switched_to": "Switched to {0}",
+ "main.history.the_version": "the version “{0}” ({1})",
+ "main.history.the_version_of": "the version of {0}",
+ "main.history.version_history_is_turned_off": "Version history is turned off in Settings.",
+ "main.history.version_history_turned_off_freed": "Version history turned off · {0} freed",
+ "main.history.version_not_recorded": " · version not recorded: {0}",
+ "main.history.what_changed_in_this_version": "What changed in this version?",
+ "main.import_audio": "Import audio…",
+ "main.imported": "Imported {0}",
+ "main.input.copied_automation": "Copied automation",
+ "main.input.copied_clip_s": "Copied clip(s)",
+ "main.input.cut_automation": "Cut automation",
+ "main.input.cut_clip_s": "Cut clip(s)",
+ "main.input.deleted_automation": "Deleted automation",
+ "main.input.deleted_range": "Deleted range",
+ "main.input.keyboard_octave_c": "Keyboard octave: C{0}",
+ "main.input.keyboard_velocity": "Keyboard velocity: {0}",
+ "main.input.pasted_automation": "Pasted automation",
+ "main.input.pasted_clip_s": "Pasted clip(s)",
+ "main.insert_scene": "Insert scene",
+ "main.instrument_track_synth": "Instrument track {0} (synth)",
+ "main.key": "Key",
+ "main.leave_edit_mode_without_re": "Leave edit mode without re-freezing",
+ "main.live_freeze": "Live freeze",
+ "main.live_freeze.editing_the_frozen_source_press": "Editing the frozen source — press Done to re-freeze, or Discard.",
+ "main.live_freeze.failed": "{0} failed: {1}",
+ "main.live_freeze.flatten_keeps_the_frozen_audio": "Flatten keeps the frozen audio track and permanently removes its source (instrument, MIDI and devices). Continue?",
+ "main.live_freeze.flattened_the_frozen_audio_is": "Flattened — the frozen audio is now a plain track.",
+ "main.live_freeze.left_edit_mode_the_frozen": "Left edit mode (the frozen audio was not changed).",
+ "main.live_freeze.live_freeze_failed": "Live freeze failed: {0}",
+ "main.live_freeze.live_freeze_link_removed_its": "Live-freeze link removed — its track was deleted.",
+ "main.live_freeze.re_freeze_failed": "Re-freeze failed: {0}",
+ "main.live_freeze.re_freeze_failed_the_source": "Re-freeze failed — the source is still live.",
+ "main.live_freeze.track_live_frozen_press_edit": "Track live-frozen — press Edit to change it, then Done.",
+ "main.live_freeze.unfrozen_the_source_is_live": "Unfrozen — the source is live again.",
+ "main.lock_envelopes": "Lock envelopes",
+ "main.loop_record_overdub_replace": "Loop record: overdub / replace",
+ "main.loop_recording_overdub_adds_every": "Loop recording: Overdub adds every pass · Replace keeps the latest pass (⌘⇧R)",
+ "main.loop_the_range_set_on": "Loop the range set on the ruler",
+ "main.map_a_controller_click_a": "Map a controller — click a control, then move a knob on the controller",
+ "main.master_volume": "Master volume",
+ "main.measuring": "measuring…",
+ "main.menu.clip_names_every_clip": "Clip names: every clip",
+ "main.menu.clip_names_first_of_a": "Clip names: first of a run",
+ "main.menu.clip_names_none": "Clip names: none",
+ "main.menu.consolidated": "Consolidated",
+ "main.menu.copied_clip": "Copied clip",
+ "main.menu.copied_notes": "Copied notes",
+ "main.menu.cut_clip": "Cut clip",
+ "main.menu.cut_notes": "Cut notes",
+ "main.menu.deleted_notes": "Deleted notes",
+ "main.menu.duplicated_automation": "Duplicated automation",
+ "main.menu.duplicated_clip_s": "Duplicated clip(s)",
+ "main.menu.duplicated_notes": "Duplicated notes",
+ "main.menu.duplicated_range": "Duplicated range",
+ "main.menu.duplicated_time": "Duplicated time",
+ "main.menu.inserted_silence": "Inserted silence",
+ "main.menu.loop_set_to_selection": "Loop set to selection",
+ "main.menu.not_implemented_yet": "Not implemented yet.",
+ "main.menu.nothing_after_the_selection_to": "Nothing after the selection to move.",
+ "main.menu.nothing_to_duplicate_in_the": "Nothing to duplicate in the selected range.",
+ "main.menu.nothing_to_redo": "Nothing to redo.",
+ "main.menu.nothing_to_undo": "Nothing to undo.",
+ "main.menu.overview_strip_hidden": "Overview strip hidden",
+ "main.menu.overview_strip_shown": "Overview strip shown",
+ "main.menu.pasted_clip": "Pasted clip",
+ "main.menu.pasted_notes": "Pasted notes",
+ "main.menu.scenes_live_in_the_session": "Scenes live in the Session view.",
+ "main.menu.sections_lane_hidden": "Sections lane hidden",
+ "main.menu.sections_lane_shown": "Sections lane shown",
+ "main.menu.select_a_clip_first": "Select a clip first.",
+ "main.menu.select_a_clip_or_a": "Select a clip or a scene to copy to the arrangement.",
+ "main.menu.select_a_range_or_a": "Select a range, or a clip the playhead crosses.",
+ "main.menu.select_a_range_or_clips": "Select a range or clips to consolidate.",
+ "main.menu.select_a_time_range_first": "Select a time range first.",
+ "main.menu.select_clips_to_copy_to": "Select clips to copy to the session.",
+ "main.menu.split_at_selection": "Split at selection",
+ "main.menu.split_clip_s_at_playhead": "Split clip(s) at playhead",
+ "main.menu_keys.show_parameter_automation_lanes_a": "Show parameter-automation lanes (⌘⇧A)",
+ "main.midi_error": "MIDI error: {0}",
+ "main.midi_import.couldnt_read": "Couldn't read {0}: {1}",
+ "main.midi_import.drop_midi_files_onto_instrument": "Drop MIDI files onto instrument slots.",
+ "main.midi_import.has_no_notes": "{0} has no notes.",
+ "main.midi_import.imported_parts": "Imported {0} ({1} parts)",
+ "main.midi_inputs_updated": "MIDI inputs updated.",
+ "main.missing_plugins.install": "Install",
+ "main.missing_plugins.installed_reopen_the_project_to": "Installed {0} — reopen the project to use it.",
+ "main.missing_plugins.installed_reopen_the_project_to_n": "Installed {0} — reopen the project to use them.",
+ "main.missing_plugins.installing_plugins": "Installing plugins…",
+ "main.missing_plugins.missing_plugins": "Missing plugins",
+ "main.missing_plugins.scanning_plugins": "Scanning plugins…",
+ "main.missing_plugins.this_project_uses_which_arent": "This project uses {0}, which aren't installed. They're open source and available from the Nota plugin registry. Install and reopen the project?",
+ "main.missing_plugins.this_project_uses_which_isnt": "This project uses {0}, which isn't installed. It's open source and available from the Nota plugin registry. Install and reopen the project?",
+ "main.mixer_in_its_own_window": "Mixer in its own window",
+ "main.mosaic.created_presets_loaded": "Created {0} presets · loaded {1}",
+ "main.mosaic.created_the_preset": "Created the preset {0}",
+ "main.narrow_grid": "Narrow grid",
+ "main.new": "New",
+ "main.no_audio_output_could_be": "No audio output could be opened — Nota runs without sound. Choose a device in Settings → Audio",
+ "main.no_audio_output_device_opened": "No audio output device opened — Nota runs silently. Choose a device in Settings → Audio",
+ "main.no_key": "No key",
+ "main.no_project_key": "No project key",
+ "main.not_now": "Not now",
+ "main.nota_process_cpu_audio_interface": "Nota process CPU: {0} (audio, interface, plugins)",
+ "main.note_audition_off": "Note audition off",
+ "main.note_audition_on": "Note audition on",
+ "main.nothing_to_freeze_the_arrangement": "Nothing to freeze — the arrangement is empty.",
+ "main.off_remote": "Off",
+ "main.open": "Open…",
+ "main.open_a_clip_in_the": "Open a clip in the clip editor first",
+ "main.open_devices_and_clip_in": "Open devices and clip in a separate window",
+ "main.open_the_mixer_in_a": "Open the mixer in a window",
+ "main.overdub": "Overdub",
+ "main.pad": "Pad",
+ "main.palette.added_to_the_canvas_connect": "{0} added to the {1} canvas — connect it to a parameter",
+ "main.palette.couldnt_add": "Couldn't add {0}.",
+ "main.palette.not_available": "Not available",
+ "main.palette.opened_in_devices": "Opened {0} in Devices",
+ "main.palette.selected": "Selected {0}",
+ "main.paste_bounced.click_an_audio_track_to": "Click an audio track to paste the bounced audio onto.",
+ "main.paste_bounced.couldnt_paste_the_bounced_audio": "Couldn't paste the bounced audio.",
+ "main.paste_bounced.couldnt_render_this_track": "Couldn't render this track.",
+ "main.paste_bounced.paste_bounced_audio_failed": "Paste bounced audio failed: {0}",
+ "main.paste_bounced.paste_bounced_audio_takes_a": "Paste bounced audio takes a range on a single track.",
+ "main.paste_bounced.pasted_bounced_audio": "Pasted bounced audio",
+ "main.paste_bounced.select_a_time_range_first": "Select a time range first (Shift+drag), then paste it bounced onto an audio track.",
+ "main.paste_bounced.the_selected_range_has_no": "The selected range has no audio or instrument track to bounce.",
+ "main.pasted_track_s": "Pasted track(s)",
+ "main.play_and_control_nota_from": "Play and control Nota from a phone",
+ "main.play_pause": "Play / pause",
+ "main.play_space": "Play (Space)",
+ "main.project_key": "Project key: {0}",
+ "main.re_enable": "Re-enable",
+ "main.re_freeze_the_source_and": "Re-freeze the source and put it back to sleep",
+ "main.recent.added_track": "Added {0} (track {1})",
+ "main.recent.is_no_longer_installed": "{0} is no longer installed.",
+ "main.recent_menu.no_recent_projects": "No recent projects",
+ "main.recent_menu.open_recent": "Open recent",
+ "main.record_r": "Record (⌘R)",
+ "main.recovery.discard": "Discard",
+ "main.recovery.do_you_really_want_to": "Do you really want to quit without saving your changes?",
+ "main.recovery.just_now": "just now",
+ "main.recovery.nota_didnt_shut_down_cleanly": "Nota didn't shut down cleanly. Recover unsaved work from {0}?",
+ "main.recovery.recover": "Recover",
+ "main.recovery.recover_project": "Recover project",
+ "main.recovery.recovered_unsaved_work": "Recovered unsaved work.",
+ "main.recovery.unsaved_changes": "Unsaved changes",
+ "main.recovery.unsaved_changes_n": "unsaved changes · {0}",
+ "main.redo": "Redo",
+ "main.remote": "Remote",
+ "main.remote.phones_connected": { "one": "{0} phone connected", "other": "{0} phones connected" },
+ "main.remote.remote_is_on_scan_the": "Remote is on · scan the code with a phone",
+ "main.remote.undo_from_a_phone": "Undo (from a phone)",
+ "main.rendering": "Rendering…",
+ "main.rendering_n": "Rendering… {0:0} %",
+ "main.replace": "Replace",
+ "main.return_added_add_an_effect": "Return {0} added — add an effect, then dial up track sends",
+ "main.sample_rate_and_buffer_size": "Sample rate and buffer size. Click to change the buffer size",
+ "main.save": "Save",
+ "main.save_as": "Save as…",
+ "main.save_version_with_note": "Save version with note…",
+ "main.scroll_the_arrangement_to_keep": "Scroll the arrangement to keep the playhead in view",
+ "main.select_a_clip_to_edit": "Select a clip to edit it",
+ "main.session": "Session",
+ "main.set_the_project_key_samples": "Set the project key — samples can be transposed to it",
+ "main.set_the_tempo_drag_or": "Set the tempo — drag, or double-click to type",
+ "main.set_the_time_signature_drag": "Set the time signature — drag each field",
+ "main.settings": "Settings…",
+ "main.show_playhead": "Show playhead",
+ "main.snap_clips_to_the_grid": "Snap clips to the grid (hold Alt to drag freely)",
+ "main.snap_off_clips_position_freely": "Snap off — clips position freely",
+ "main.snap_on": "Snap on",
+ "main.snap_to_grid": "Snap to grid",
+ "main.split_at_playhead": "Split at playhead",
+ "main.stems.download_cancelled": "Download cancelled.",
+ "main.stems.downloading": "Downloading…",
+ "main.stems.is_waiting_for_its_model": "{0} is waiting for its model — it's downloading (see the status bar).",
+ "main.stems.isnt_available_on_this_computer": "{0} isn't available on this computer.",
+ "main.stems.preparing_audio": "Preparing audio…",
+ "main.stems.separate_stems": "Separate Stems",
+ "main.stems.separate_stems_cancelled": "Separate Stems cancelled.",
+ "main.stems.separate_stems_failed": "Separate Stems failed: {0}",
+ "main.stems.separated_into_drums_bass_other": "Separated \"{0}\" into drums, bass, other and vocals.",
+ "main.stems.the_model": "the {0} model",
+ "main.stems.the_model_and_the_ai": "the {0} model and the AI runtime it runs on",
+ "main.stems.uses_an_ai_model_that": "{0} uses an AI model that runs on this computer. Download {1} ({2}) once? ",
+ "main.stems.you_can_remove_it_later": "You can remove it later in Settings → Downloads → AI Models.",
+ "main.step_the_selected_midi_clip": "Step the selected MIDI clip on a Drum Rack track",
+ "main.stop_return": "Stop (Return)",
+ "main.strips": "Strips",
+ "main.switch_between_bars_and_time": "Switch between bars and time",
+ "main.tap": "Tap",
+ "main.tap_the_beat_to_set": "Tap the beat to set the tempo",
+ "main.tempo_bpm_tapped": "Tempo: {0} BPM (tapped)",
+ "main.toggle_browser": "Toggle browser",
+ "main.toggle_detail_panel": "Toggle detail panel",
+ "main.toggle_full_screen": "Toggle full screen",
+ "main.toggle_overview": "Toggle overview",
+ "main.toggle_sections": "Toggle sections",
+ "main.toggled_clip_s": "Toggled clip(s)",
+ "main.track_headers_on_the_right": "Track headers on the right",
+ "main.triplet_grid": "Triplet grid",
+ "main.turn_the_metronome_on_or": "Turn the metronome on or off (⌘M) · right-click for count-in",
+ "main.updates.check_for_updates": "Check for updates",
+ "main.updates.checking_for_updates": "Checking for updates…",
+ "main.updates.couldnt_reach_github_to_check": "Couldn't reach GitHub to check for a newer version of Nota. Check your internet connection and try again.",
+ "main.updates.download_it_from_the_release": " Download it from the release page.",
+ "main.updates.download_nota": "Download Nota {0}…",
+ "main.updates.hide_it_still_installs_when": "Hide — it still installs when you quit",
+ "main.updates.later": "Later",
+ "main.updates.nota_downloads_it_here_and": " Nota downloads it here and installs it when you restart or quit.",
+ "main.updates.nota_is_available": "Nota {0} is available",
+ "main.updates.nota_is_downloaded_click_to": "Nota {0} is downloaded. Click to restart now — or it installs the next time you quit.",
+ "main.updates.nota_is_out_you_have": "Nota {0} is out — you have {1}.",
+ "main.updates.nota_is_ready_to_install": "Nota {0} is ready to install. Restart Nota to finish updating — or it installs the next time you quit.",
+ "main.updates.release_notes": "Release notes",
+ "main.updates.restart_now": "Restart now",
+ "main.updates.restart_to_update_to_nota": "Restart to update to Nota {0}",
+ "main.updates.the_update_didnt_download": "The update didn't download",
+ "main.updates.update_available": "Update available",
+ "main.updates.update_to_nota": "Update to Nota {0}",
+ "main.updates.you_have_click_to_update": "You have {0}. Click to update or read the release notes.",
+ "main.updates.youre_up_to_date_nota": "You're up to date: Nota {0} is the latest version.",
+ "main.view": "View",
+ "main.view_release_notes": "View release notes",
+ "main.wake_the_frozen_source_to": "Wake the frozen source to edit it (right-click to unfreeze or flatten)",
+ "main.wasapi_exclusive_unavailable_using_shared": "WASAPI exclusive unavailable — using shared mode",
+ "main.widen_grid": "Widen grid",
+ "menu.mac.hide": "Hide {0}",
+ "menu.mac.hide_others": "Hide Others",
+ "menu.mac.quit": "Quit {0}",
+ "menu.mac.show_all": "Show All",
+ "menu.reveal_in_finder": "Reveal in Finder",
+ "menu.show_in_explorer": "Show in Explorer",
+ "menu.show_in_file_manager": "Show in file manager",
+ "midi.accent": "Accent",
+ "midi.cycles": "Cycles",
+ "midi.down": "Down",
+ "midi.generators.a_step_sequencer_in_scale": "A step sequencer in scale degrees — pick a contour and a span, get a line.",
+ "midi.generators.accent_vel": "Accent Vel",
+ "midi.generators.accents": "Accents",
+ "midi.generators.arch": "Arch",
+ "midi.generators.cluster": "Cluster",
+ "midi.generators.contour": "Contour",
+ "midi.generators.density": "Density",
+ "midi.generators.drop_2": "Drop 2",
+ "midi.generators.euclidean": "Euclidean",
+ "midi.generators.exponential": "Exponential",
+ "midi.generators.grows_every_note_into_a": "Grows every note into a chord, voiced the way you would play it.",
+ "midi.generators.lays_down_a_pattern_that": "Lays down a pattern that leans on the strong beats, as densely as you ask.",
+ "midi.generators.learns_the_clips_intervals_and": "Learns the clip's intervals and rhythm, then writes a new take in the same voice.",
+ "midi.generators.logarithmic": "Logarithmic",
+ "midi.generators.melodic_steps": "Melodic Steps",
+ "midi.generators.pitch_var": "Pitch Var",
+ "midi.generators.power": "Power",
+ "midi.generators.pulses": "Pulses",
+ "midi.generators.random_walk": "Random Walk",
+ "midi.generators.rhythm": "Rhythm",
+ "midi.generators.rhythm_var": "Rhythm Var",
+ "midi.generators.root": "Root",
+ "midi.generators.seed": "Seed",
+ "midi.generators.spread": "Spread",
+ "midi.generators.spreads_a_number_of_hits": "Spreads a number of hits as evenly as a number of steps allows.",
+ "midi.generators.square": "Square",
+ "midi.generators.stacks": "Stacks",
+ "midi.generators.traces_a_curve_across_the": "Traces a curve across the clip and drops a note wherever it passes a step.",
+ "midi.generators.valley": "Valley",
+ "midi.generators.variation": "Variation",
+ "midi.generators.vel_falloff": "Vel Falloff",
+ "midi.generators.vel_follows": "Vel Follows",
+ "midi.generators.vel_var": "Vel Var",
+ "midi.generators.voices": "Voices",
+ "midi.generators.voicing": "Voicing",
+ "midi.generators.zigzag": "Zigzag",
+ "midi.in_scale": "In Scale",
+ "midi.interval": "Interval",
+ "midi.octaves": "Octaves",
+ "midi.phase": "Phase",
+ "midi.ramp_down": "Ramp Down",
+ "midi.ramp_up": "Ramp Up",
+ "midi.random": "Random",
+ "midi.rate": "Rate",
+ "midi.rotate": "Rotate",
+ "midi.s_curve": "S-Curve",
+ "midi.shape": "Shape",
+ "midi.sine": "Sine",
+ "midi.steps": "Steps",
+ "midi.tool.on": "On",
+ "midi.transforms.alternate": "Alternate",
+ "midi.transforms.amount": "Amount",
+ "midi.transforms.arpeggiate": "Arpeggiate",
+ "midi.transforms.bends_the_time_axis_so": "Bends the time axis so a phrase accelerates, drags or breathes.",
+ "midi.transforms.blend": "Blend",
+ "midi.transforms.breaks_chords_into_a_running": "Breaks chords into a running sequence.",
+ "midi.transforms.centre": "Centre",
+ "midi.transforms.centre_out": "Centre Out",
+ "midi.transforms.chance": "Chance",
+ "midi.transforms.chord": "Chord",
+ "midi.transforms.chromatic": "Chromatic",
+ "midi.transforms.chunk": "Chunk",
+ "midi.transforms.connect": "Connect",
+ "midi.transforms.converge": "Converge",
+ "midi.transforms.curve": "Curve",
+ "midi.transforms.decorates_notes_with_grace_notes": "Decorates notes with grace notes, trills and rolls.",
+ "midi.transforms.depth": "Depth",
+ "midi.transforms.direction": "Direction",
+ "midi.transforms.distance": "Distance",
+ "midi.transforms.diverge": "Diverge",
+ "midi.transforms.down_up": "Down-Up",
+ "midi.transforms.draws_a_curve_through_the": "Draws a curve through the velocities instead of editing them one by one.",
+ "midi.transforms.fill": "Fill",
+ "midi.transforms.fills_the_gaps_between_notes": "Fills the gaps between notes with runs that walk to the next pitch.",
+ "midi.transforms.fixed": "Fixed",
+ "midi.transforms.flam": "Flam",
+ "midi.transforms.flatten": "Flatten",
+ "midi.transforms.grace": "Grace",
+ "midi.transforms.humanize": "Humanize",
+ "midi.transforms.in_scale": "In scale",
+ "midi.transforms.keep_ends": "Keep Ends",
+ "midi.transforms.max_steps": "Max Steps",
+ "midi.transforms.mirror_pitch": "Mirror Pitch",
+ "midi.transforms.mode": "Mode",
+ "midi.transforms.mordent": "Mordent",
+ "midi.transforms.ornament": "Ornament",
+ "midi.transforms.per_pitch": "Per Pitch",
+ "midi.transforms.period": "Period",
+ "midi.transforms.pulls_notes_onto_the_grid": "Pulls notes onto the grid, with swing and a strength short of rigid.",
+ "midi.transforms.pulls_pitch_and_rhythm_apart": "Pulls pitch and rhythm apart and puts them back together differently.",
+ "midi.transforms.quantize_ends": "Quantize Ends",
+ "midi.transforms.recombine": "Recombine",
+ "midi.transforms.reverse_pitch": "Reverse Pitch",
+ "midi.transforms.reverse_time": "Reverse Time",
+ "midi.transforms.rewrites_note_lengths_from_staccato": "Rewrites note lengths — from staccato through legato to overlapping.",
+ "midi.transforms.roll": "Roll",
+ "midi.transforms.rolls_the_notes_of_a": "Rolls the notes of a chord out in time instead of hitting them together.",
+ "midi.transforms.rotate_pitch": "Rotate Pitch",
+ "midi.transforms.scale_length": "Scale Length",
+ "midi.transforms.shuffle_both": "Shuffle Both",
+ "midi.transforms.shuffle_pitch": "Shuffle Pitch",
+ "midi.transforms.shuffle_rhythm": "Shuffle Rhythm",
+ "midi.transforms.snap_to_grid": "Snap to Grid",
+ "midi.transforms.span": "Span",
+ "midi.transforms.strum": "Strum",
+ "midi.transforms.style": "Style",
+ "midi.transforms.swing": "Swing",
+ "midi.transforms.tension": "Tension",
+ "midi.transforms.time_warp": "Time Warp",
+ "midi.transforms.to_next_note": "To Next Note",
+ "midi.transforms.trill": "Trill",
+ "midi.transforms.turn": "Turn",
+ "midi.transforms.type": "Type",
+ "midi.transforms.up_down": "Up-Down",
+ "midi.transforms.vel_decay": "Vel Decay",
+ "midi.transforms.vel_slope": "Vel Slope",
+ "midi.transforms.velocity_shaper": "Velocity Shaper",
+ "midi.transforms.warp_lengths": "Warp Lengths",
+ "midi.triangle": "Triangle",
+ "midi.up": "Up",
+ "midi_learn.button": "Button {0}",
+ "midi_learn.left_stick": "Left stick ←→",
+ "midi_learn.left_stick_2": "Left stick ↑↓",
+ "midi_learn.left_trigger": "Left trigger",
+ "midi_learn.note_ch": "Note {0} · ch{1}",
+ "midi_learn.pad": "Pad · {0}",
+ "midi_learn.phone": "Phone · {0}",
+ "midi_learn.right_stick": "Right stick ←→",
+ "midi_learn.right_stick_2": "Right stick ↑↓",
+ "midi_learn.right_trigger": "Right trigger",
+ "midi_map.invert": "Invert",
+ "midi_map.master_volume": "Master Volume",
+ "midi_map.max": "Max",
+ "midi_map.midi_mappings": "MIDI mappings",
+ "midi_map.no_mappings_yet_click_midi": "No mappings yet.\n\nClick MIDI (top-right), then click any highlighted\ncontrol and move a knob or fader on your controller —\nor press a button or move a stick on a gamepad.",
+ "midi_map.play": "Play",
+ "midi_map.track_pan": "Track Pan",
+ "midi_map.track_volume": "Track Volume",
+ "midi_tools.add": "Add",
+ "midi_tools.apply": "Apply",
+ "midi_tools.clip": "clip · {0}",
+ "midi_tools.defaults": "Defaults",
+ "midi_tools.generate": "Generate",
+ "midi_tools.notes": "{0:+0;−0;±0} notes",
+ "midi_tools.notes_applied": "{0} notes · applied",
+ "midi_tools.notes_was": "{0} notes, was {1}",
+ "midi_tools.parameters": "Parameters",
+ "midi_tools.pick_a_tool": "Pick a tool",
+ "midi_tools.pick_a_tool_to_see": "Pick a tool to see its parameters",
+ "midi_tools.replace": "Replace",
+ "midi_tools.reroll": "Reroll",
+ "midi_tools.revert": "Revert",
+ "midi_tools.seed": "Seed",
+ "midi_tools.selected": "{0} selected",
+ "midi_tools.transform": "Transform",
+ "mixer.a_hidden_track_clipped_click": "A hidden track clipped · click to clear",
+ "mixer.a_hidden_track_is_armed": "A hidden track is armed",
+ "mixer.a_hidden_track_is_soloed": "A hidden track is soloed",
+ "mixer.balance": "Balance",
+ "mixer.dock_the_mixer_in_the": "Dock the mixer in the main window",
+ "mixer.fold_group": "Fold group {0}",
+ "mixer.group_in": "Group in",
+ "mixer.groups_keep_a_unity_centre": "Groups keep a unity-centre balance so grouping stays level-transparent",
+ "mixer.hidden_not_enough_height_click": "Hidden: not enough height · click to show anyway",
+ "mixer.in_1": "In 1",
+ "mixer.master": "→ Master",
+ "mixer.midi_in": "MIDI in",
+ "mixer.monitor_auto": "Monitor auto",
+ "mixer.monitor_in": "Monitor in",
+ "mixer.older_project": "Older project",
+ "mixer.output": "→ Output",
+ "mixer.pan_attenuates_the_opposite_channel": "Pan attenuates the opposite channel, as in earlier versions",
+ "mixer.pan_law": "Pan law",
+ "mixer.pan_moves_the_whole_image": "Pan moves the whole image of stereo tracks and returns",
+ "mixer.panning_attenuates_the_opposite_channel": "Panning attenuates the opposite channel (legacy behaviour)",
+ "mixer.panning_moves_the_whole_stereo": "Panning moves the whole stereo image; nothing is dropped",
+ "mixer.projects_saved_before_stereo_pan": "Projects saved before stereo pan law open with Balance so existing mixes do not change",
+ "mixer.return_in": "Return in",
+ "mixer.set_the_gain_drag_or": "Set the gain — drag, or double-click to type",
+ "mixer.show_compact_strips_more_tracks": "Show compact strips: more tracks on screen",
+ "mixer.stereo": "Stereo",
+ "mixer.strips": "Strips",
+ "mixer.sum_bus": "Sum bus",
+ "mixer.unfold_group": "Unfold group {0}",
+ "model_store.ai_models_arent_available_for": "AI models aren't available for this computer: ONNX Runtime has no build for it.",
+ "model_store.couldnt_remove_it_may_be": "Couldn't remove {0} — it may be in use. Restart Nota and try again.",
+ "model_store.installing_this_model_needs_of": "Installing this model needs {0} of free disk space, and there is {1}.",
+ "model_store.invalid_model_id": "Invalid model id \"{0}\".",
+ "model_store.model_catalog.ai_runtime": "AI runtime",
+ "model_store.model_catalog.convert_to_midi": "Convert to MIDI",
+ "model_store.model_catalog.hears_every_note_in_a": "Hears every note in a recording, chords included, for Convert Melody and Convert Harmony.",
+ "model_store.model_catalog.separate_stems": "Separate Stems",
+ "model_store.model_catalog.splits_a_mix_into_drums": "Splits a mix into drums, bass, vocals and everything else, each on its own track.",
+ "model_store.model_catalog.the_library_notas_ai_models": "The library Nota's AI models run on. Installed with the first model.",
+ "model_store.the_download_of_doesnt_contain": "The download of {0} doesn't contain {1}.",
+ "model_store.unknown_ai_model": "Unknown AI model \"{0}\".",
+ "modular.add": "+ Add",
+ "modular.add_2": "Add",
+ "modular.add_an_lfo_expose_a": "Add an LFO / expose a param first",
+ "modular.audio_in": "Audio in",
+ "modular.audio_out": "Audio out",
+ "modular.bypass_b": "Bypass (B)",
+ "modular.cross_track_cv_links": { "one": "{0} cross-track CV link", "other": "{0} cross-track CV links" },
+ "modular.cv_link_lfo_caps": "CV LINK · LFO {0}",
+ "modular.cv_out": "CV out",
+ "modular.delete": "Delete (⌫)",
+ "modular.depth": "Depth",
+ "modular.devices": { "one": "{0} device →", "other": "{0} devices →" },
+ "modular.drag_from_a_cv_out": "Drag from a CV out onto a node to modulate it · Space + drag — pan · ⌘ + wheel — zoom · F — fit · Esc — show fewer",
+ "modular.edges": { "one": "{0} edge", "other": "{0} edges" },
+ "modular.edit_modulation": "Edit modulation · {0}…",
+ "modular.env": "Env",
+ "modular.expose_as_cv_output": "Expose as CV output",
+ "modular.fit": "Fit",
+ "modular.fixed_the_chain_leaves_the": "Fixed — the chain leaves the track for the mixer here, so it can't be deleted.",
+ "modular.fixed_the_tracks_clips_and": "Fixed — the track's clips and input enter the chain here, so it can't be deleted.",
+ "modular.fixed_the_tracks_instrument_takes": "Fixed — the track's instrument takes its MIDI in. It can't be deleted; drop another instrument on the track to swap it.",
+ "modular.free": "Free",
+ "modular.from": "From {0} · {1}",
+ "modular.gain": "Gain",
+ "modular.global": "Global",
+ "modular.global_n": "Global · {0}",
+ "modular.hide_the_parameters_that_arent": "Hide the parameters that aren't modulated (Esc)",
+ "modular.inst": "Inst {0}",
+ "modular.instrument": "Instrument {0}",
+ "modular.invert": "Invert",
+ "modular.islands": { "one": "{0} island", "other": "{0} islands" },
+ "modular.khz_ms": "{0:0.0} kHz · {1} · {2:0.0} ms",
+ "modular.lfo_caps": "LFO",
+ "modular.lfo_caps_n": "LFO {0}",
+ "modular.macro": "Macro",
+ "modular.math": "Math",
+ "modular.max": "Max",
+ "modular.midi_in": "MIDI in",
+ "modular.midi_out": "MIDI out",
+ "modular.mode": "Mode",
+ "modular.modulate_from_a_parameter": "Modulate from a parameter",
+ "modular.modulate_from_another_track": "Modulate from another track",
+ "modular.modulate_with": "Modulate with {0} {1}",
+ "modular.multiply": "Multiply",
+ "modular.no_modulatable_parameters_on_that": "No modulatable parameters on that track",
+ "modular.no_parameters": "No parameters",
+ "modular.no_tracks_yet": "No tracks yet",
+ "modular.nodes": "{0} nodes",
+ "modular.nodes_caps": "{0} NODES",
+ "modular.note": "Note",
+ "modular.offset": "Offset",
+ "modular.open_in_a_window": "Open in a window",
+ "modular.out": "Out",
+ "modular.override": "Override",
+ "modular.parameter": "Parameter",
+ "modular.pattern": " · {0}",
+ "modular.pattern_n": "{0} · {1} · {2}",
+ "modular.phase": "Phase",
+ "modular.pick_a_track_to_see": "Pick a track to see its signal graph",
+ "modular.rate": "Rate",
+ "modular.remove_connection": "Remove connection",
+ "modular.remove_modulation": "Remove modulation",
+ "modular.rnd": "Rnd",
+ "modular.saw": "Saw",
+ "modular.scale": "Scale",
+ "modular.scope": "Scope",
+ "modular.scope.back_to_the_live_trace": "Back to the live trace",
+ "modular.scope.drag_to_resize_the_trace": "Drag to resize the trace",
+ "modular.scope.free_running_the_newest_value": "Free running: the newest value is at the right",
+ "modular.scope.hold_the_trace_while_the": "Hold the trace while the input keeps running",
+ "modular.scope.rise": "Rise",
+ "modular.scope.scope": "Scope {0} · {1}",
+ "modular.scope.the_window_is_in_beats": "The window is in beats at the tempo. Click for milliseconds",
+ "modular.scope.the_window_is_in_milliseconds": "The window is in milliseconds. Click to sync it to the beat",
+ "modular.scope.trigger_start_the_trace_where": "Trigger: start the trace where the input rises through 0, so a repeating shape holds still",
+ "modular.scope.watches_cv_drag_a_modulators": "Watches CV. Drag a modulator's CV out onto this node. For audio, put Lens on the chain.",
+ "modular.scope.window": "Window",
+ "modular.scope.zoom": "Zoom",
+ "modular.show_all_parameters": "Show all parameters",
+ "modular.show_fewer": "Show fewer",
+ "modular.show_fewer_parameters_esc": "Show fewer parameters (Esc)",
+ "modular.sine": "Sine",
+ "modular.smooth": "Smooth",
+ "modular.sqr": "Sqr",
+ "modular.subtract": "Subtract",
+ "modular.sync": "Sync",
+ "modular.track_output": "Track output",
+ "modular.tracks": "Tracks",
+ "modular.tri": "Tri",
+ "modular.unexpose_cv_output": "Unexpose CV output",
+ "modular.vel": "Vel",
+ "mosaic.library.couldnt_load_the_preset": "Couldn't load the preset: {0}",
+ "mosaic_create.analysis": "{0} · analysis",
+ "mosaic_create.by_name_stem": "by name stem",
+ "mosaic_create.create_1_preset": "Create 1 preset",
+ "mosaic_create.create_multisample": "Create multisample",
+ "mosaic_create.create_presets": "Create presets",
+ "mosaic_create.create_presets_n": "Create {0} presets",
+ "mosaic_create.duplicates": { "one": "{0} duplicate", "other": "{0} duplicates" },
+ "mosaic_create.edge_zone_stretch": "Edge zone stretch",
+ "mosaic_create.files": "{0} files · {1}",
+ "mosaic_create.gap_at_neighbours_stretched": "Gap at {0} — neighbours stretched",
+ "mosaic_create.layer": "{0} layer",
+ "mosaic_create.mapping": "Mapping",
+ "mosaic_create.mapping_2": "Mapping…",
+ "mosaic_create.midi_caps": "{0} · MIDI",
+ "mosaic_create.multisamples": "Multisamples",
+ "mosaic_create.next_to_gap": "next to gap",
+ "mosaic_create.no_audio_files_with_a": "No audio files with a note in their name or a clear pitch.",
+ "mosaic_create.no_repeat": "No repeat",
+ "mosaic_create.notes_from_sample_analysis": { "one": "{0} note from sample analysis", "other": "{0} notes from sample analysis" },
+ "mosaic_create.nothing_to_map": "nothing to map",
+ "mosaic_create.octave": "Octave",
+ "mosaic_create.presets_will_appear_in_nota": "Presets will appear in Nota Mosaic → Packs → {0}",
+ "mosaic_create.reading_the_files": "Reading the files…",
+ "mosaic_create.release_samples_release_group": "Release samples → Release group",
+ "mosaic_create.rnd": "Rnd",
+ "mosaic_create.round_robin": "Round-robin",
+ "mosaic_create.seq": "Seq",
+ "mosaic_create.the_names_are_taken_as": "The names are taken as written (C4 = 60).",
+ "mosaic_create.velocity_layers_by_dynamics": "Velocity layers by dynamics",
+ "mosaic_create.without_a_note_left_out": "{0} without a note — left out",
+ "mosaic_create.zones": "{0}–{1} · {2} zones",
+ "palette.categories.distortion": "Distortion",
+ "palette.categories.drums": "Drums",
+ "palette.categories.dynamics": "Dynamics",
+ "palette.categories.eq_filter": "EQ & filter",
+ "palette.categories.generate": "Generate",
+ "palette.categories.keys_physical": "Keys & physical",
+ "palette.categories.modulation": "Modulation",
+ "palette.categories.pitch_time": "Pitch & time",
+ "palette.categories.racks": "Racks",
+ "palette.categories.reverb_delay": "Reverb & delay",
+ "palette.categories.samplers": "Samplers",
+ "palette.categories.shape": "Shape",
+ "palette.categories.synths": "Synths",
+ "palette.categories.utility": "Utility",
+ "palette.devices.3_band_eq": "3-band EQ",
+ "palette.devices.8_band_eq": "8-band EQ",
+ "palette.devices.a_single_gain_stage_with": "A single gain stage with a big readout.",
+ "palette.devices.a_synth_with_a_built": "A synth with a built-in pattern engine for arpeggios and sequences.",
+ "palette.devices.algorithmic_reverb_from_small_rooms": "Algorithmic reverb from small rooms to large halls.",
+ "palette.devices.amplifier": "amplifier",
+ "palette.devices.analog_synth": "analog synth",
+ "palette.devices.analyzer_scope": "analyzer / scope",
+ "palette.devices.arp_synth": "arp synth",
+ "palette.devices.auto_pan": "auto-pan",
+ "palette.devices.auto_pan_and_tremolo_synced": "Auto-pan and tremolo synced to the tempo.",
+ "palette.devices.bit_crusher": "bit crusher",
+ "palette.devices.bit_depth_and_sample_rate": "Bit-depth and sample-rate reduction.",
+ "palette.devices.brickwall_limiter_for_the_master": "Brickwall limiter for the master.",
+ "palette.devices.built_in": "built-in",
+ "palette.devices.captures_and_repeats_slices_for": "Captures and repeats slices for stutters and glitches.",
+ "palette.devices.chains_of_midi_effects": "chains of MIDI effects",
+ "palette.devices.chorus": "chorus",
+ "palette.devices.chorus_and_ensemble_for_width": "Chorus and ensemble for width and shimmer.",
+ "palette.devices.classic_jet_flanger": "Classic jet flanger.",
+ "palette.devices.compressor_with_sidechain_and_five": "Compressor with sidechain and five characters — glue, punch and pumping.",
+ "palette.devices.drum_machine": "drum machine",
+ "palette.devices.dynamic_eq": "dynamic EQ",
+ "palette.devices.eight_band_parametric_eq_with": "Eight-band parametric EQ with a live spectrum.",
+ "palette.devices.eight_voice_drum_machine_with": "Eight-voice drum machine with a step sequencer.",
+ "palette.devices.electric_piano": "electric piano",
+ "palette.devices.envelope_lfo": "envelope / LFO",
+ "palette.devices.eq_bands_that_react_to": "EQ bands that react to the level — de-essing and resonance control.",
+ "palette.devices.five_voice_vintage_polysynth_lush": "Five-voice vintage polysynth — lush pads, brass and keys.",
+ "palette.devices.flanger": "flanger",
+ "palette.devices.fm_synth": "FM synth",
+ "palette.devices.fm_synthesis_bells_electric_pianos": "FM synthesis — bells, electric pianos and hard basses.",
+ "palette.devices.force_note_length": "force note length",
+ "palette.devices.forces_note_lengths_staccato_legato": "Forces note lengths — staccato, legato or fixed.",
+ "palette.devices.gain": "gain",
+ "palette.devices.gain_width_mono_and_phase": "Gain, width, mono and phase — the housekeeping tool.",
+ "palette.devices.gate": "gate",
+ "palette.devices.glitch_repeats": "glitch & repeats",
+ "palette.devices.granular_synth": "granular synth",
+ "palette.devices.granular_synth_that_turns_a": "Granular synth that turns a sample into clouds, textures and drones.",
+ "palette.devices.guitar_amp_and_cabinet_models": "Guitar amp and cabinet models from clean to high gain.",
+ "palette.devices.hybrid_reverb": "hybrid reverb",
+ "palette.devices.hybrid_reverb_with_early_reflections": "Hybrid reverb with early reflections and a long, dense tail.",
+ "palette.devices.keeps_notes_in_a_key": "Keeps notes in a key and scale.",
+ "palette.devices.layered_looper_with_overdubs": "Layered looper with overdubs.",
+ "palette.devices.layers_several_instruments_in_parallel": "Layers several instruments in parallel chains.",
+ "palette.devices.limiter": "limiter",
+ "palette.devices.looper": "looper",
+ "palette.devices.modelled_electric_piano_tine_suitcase": "Modelled electric piano — tine, suitcase, reed and clav with tremolo, phaser and cabinet.",
+ "palette.devices.mono_synth": "mono synth",
+ "palette.devices.monophonic_analog_style_synth_for": "Monophonic analog-style synth for fat basses and leads.",
+ "palette.devices.multi_stage_phaser": "Multi-stage phaser.",
+ "palette.devices.multiband_dynamics": "multiband dynamics",
+ "palette.devices.multisample": "multisample",
+ "palette.devices.multisample_instrument_zones_by_key": "Multisample instrument — zones by key and velocity, round-robin and release samples; SFZ import and packs.",
+ "palette.devices.noise_gate_and_rhythmic_trance": "Noise gate and rhythmic trance gate.",
+ "palette.devices.paraphonic_ensemble_synth_string_machines": "Paraphonic ensemble synth — string machines and choirs.",
+ "palette.devices.paraphonic_synth": "paraphonic synth",
+ "palette.devices.phaser": "phaser",
+ "palette.devices.physical_modelling_of_struck_plucked": "Physical modelling of struck, plucked and blown bodies.",
+ "palette.devices.physical_synth": "physical synth",
+ "palette.devices.pitch_correction": "pitch correction",
+ "palette.devices.pitch_quantize": "pitch quantize",
+ "palette.devices.plays_a_sample_across_the": "Plays a sample across the keyboard.",
+ "palette.devices.poly_synth": "poly synth",
+ "palette.devices.random_transpose": "random transpose",
+ "palette.devices.random_transposition_timing_and_dropouts": "Random transposition, timing and dropouts.",
+ "palette.devices.real_time_pitch_correction_to": "Real-time pitch correction to a key and scale.",
+ "palette.devices.reshapes_compresses_or_randomises_note": "Reshapes, compresses or randomises note velocities.",
+ "palette.devices.resonant_filter_swept_by_an": "Resonant filter swept by an envelope follower or an LFO.",
+ "palette.devices.runs_several_effect_chains_in": "Runs several effect chains in parallel.",
+ "palette.devices.saturator": "saturator",
+ "palette.devices.shapes_this_tracks_sound_with": "Shapes this track's sound with another track's voice.",
+ "palette.devices.sixteen_pads_each_with_its": "Sixteen pads, each with its own sample or instrument chain.",
+ "palette.devices.spectrum_analyser_oscilloscope_and_level": "Spectrum analyser, oscilloscope and level meter.",
+ "palette.devices.splits_notes_across_chains_of": "Splits notes across chains of MIDI effects by key, velocity or a selector.",
+ "palette.devices.stacked_intervals": "stacked intervals",
+ "palette.devices.step_arpeggiator": "step arpeggiator",
+ "palette.devices.step_arpeggiator_with_groove_lanes": "Step arpeggiator with groove lanes.",
+ "palette.devices.stereo_and_ping_pong_delay": "Stereo and ping-pong delay synced to the tempo.",
+ "palette.devices.tape_and_tube_saturation_warmth": "Tape and tube saturation — warmth, wow and flutter.",
+ "palette.devices.three_band_dj_style_eq": "Three-band DJ-style EQ with kills.",
+ "palette.devices.three_band_upward_and_downward": "Three-band upward and downward compression — OTT-style density.",
+ "palette.devices.turns_single_notes_into_chords": "Turns single notes into chords.",
+ "palette.devices.two_oscillator_analog_style_synth": "Two-oscillator analog-style synth with drive and a unison stack — pads, basses, acid lines and leads.",
+ "palette.devices.vector_morph_synth": "vector-morph synth",
+ "palette.devices.vector_synth_morphing_between_sources": "Vector synth morphing between sources — moving pads and textures.",
+ "palette.devices.velocity_shaping": "velocity shaping",
+ "palette.devices.vintage_saturator": "vintage saturator",
+ "palette.devices.vocoder": "vocoder",
+ "palette.devices.waveshaping_saturator_from_soft_warmth": "Waveshaping saturator from soft warmth to hard clipping.",
+ "palette.devices.wavetable_synth": "wavetable synth",
+ "palette.devices.wavetable_synth_with_warping_oscillators": "Wavetable synth with warping oscillators — evolving pads and modern leads.",
+ "palette.index.1_item": "1 item",
+ "palette.index.indexing": "indexing {0}… {1} %",
+ "palette.index.items": "{0} items",
+ "palette.modular.a_low_frequency_oscillator_free": "A low-frequency oscillator, free or synced to the tempo.",
+ "palette.modular.adds_multiplies_or_mixes_two": "Adds, multiplies or mixes two control signals.",
+ "palette.modular.an_attack_decay_sustain_release": "An attack-decay-sustain-release envelope triggered by notes.",
+ "palette.modular.control": "Control",
+ "palette.modular.converter": "Converter",
+ "palette.modular.cv_utility": "CV utility",
+ "palette.modular.modulator": "Modulator",
+ "palette.modular.monitor": "Monitor",
+ "palette.modular.one_knob_driving_several_destinations": "One knob driving several destinations.",
+ "palette.modular.shows_a_control_signal_over": "Shows a control signal over time.",
+ "palette.modular.turns_notes_velocity_and_controllers": "Turns notes, velocity and controllers into control signals.",
+ "palette.modular.turns_the_tracks_loudness_into": "Turns the track's loudness into a control signal: a peak controller, for ducking one track under another.",
+ "palette.search.actions": "Actions",
+ "palette.search.device_window": "Device window",
+ "palette.search.devices": "Devices",
+ "palette.search.presets": "Presets",
+ "palette.search.suggested": "Suggested · {0}",
+ "palette.search.tracks": "Tracks",
+ "palette.targets.after": "after {0}",
+ "palette.targets.canvas_unconnected": "canvas, unconnected",
+ "palette.targets.end_of_audio_fx": "end of Audio FX",
+ "palette.targets.end_of_chain": "end of chain",
+ "palette.targets.end_of_midi_fx": "end of MIDI FX",
+ "palette.targets.instrument": "instrument",
+ "palette.targets.keep_open": " · keep open",
+ "palette.targets.loads_the_kit": "loads the kit",
+ "palette.targets.midi_effects_need_an_instrument": "MIDI effects need an instrument track",
+ "palette.targets.midi_fx_end": "MIDI FX, end",
+ "palette.targets.new_chain_in_instrument_rack": "new chain in Instrument Rack",
+ "palette.targets.new_midi_track": "→ new MIDI track{0}",
+ "palette.targets.new_pad_in_drum_rack": "new pad in Drum Rack",
+ "palette.targets.new_track": "→ new track{0}",
+ "palette.targets.open_in_devices": "→ open {0} in Devices",
+ "palette.targets.pattern": "→ {0} · {1}{2}",
+ "palette.targets.replaces": "replaces {0}",
+ "palette.targets.replaces_the_instrument": "replaces the instrument",
+ "palette.targets.run": "↵ run",
+ "palette.targets.select_a_track_first": "Select a track first",
+ "palette.targets.select_in": "→ select {0} in {1}",
+ "palette.targets.track": "track {0}",
+ "palette_providers.audio_fx": "Audio FX",
+ "palette_providers.kits": "Kits",
+ "palette_providers.midi_caps": "MIDI · {0}",
+ "palette_providers.midi_fx_caps": "MIDI FX",
+ "palette_providers.modular": "Modular · {0}",
+ "palette_providers.preset": "Preset",
+ "persistence.preset.couldnt_load_the_sample": "Couldn't load the sample \"{0}\".",
+ "persistence.preset.couldnt_prepare_the_multisample": "Couldn't prepare the multisample \"{0}\".",
+ "persistence.preset.couldnt_prepare_the_sample": "Couldn't prepare the sample \"{0}\".",
+ "persistence.preset.failed_to_add_device": "Failed to add device.",
+ "persistence.preset.failed_to_add_instrument": "Failed to add instrument.",
+ "persistence.preset.failed_to_add_midi_effect": "Failed to add MIDI effect.",
+ "persistence.preset.failed_to_load_instrument": "Failed to load instrument.",
+ "persistence.preset.failed_to_load_plugin": "Failed to load plugin.",
+ "persistence.preset.not_a_midi_effect": "Not a MIDI effect.",
+ "persistence.preset.not_an_effect": "Not an effect.",
+ "persistence.preset.plugin_not_installed": "Plugin not installed: {0}",
+ "persistence.preset.preset_cant_be_applied_in": "Preset can't be applied in place.",
+ "persistence.preset.unknown_preset_type": "Unknown preset type.",
+ "persistence.project_history.this_version_was_saved_by": "This version was saved by Nota {0}, which is newer than this one. Update Nota to open it.",
+ "piano_roll.1_note_vel": "1 note · {0} · vel {1}",
+ "piano_roll.a_session_slot_plays_on": "A Session slot plays on its own loop clock — launch it to play from the start",
+ "piano_roll.clear": "Clear {0}",
+ "piano_roll.clip_strip.click_a_clip_to_edit": "Click a clip to edit it · the lock keeps a clip for reference",
+ "piano_roll.controllers.drag_to_draw": "Drag to draw",
+ "piano_roll.controllers.drag_to_draw_a_block": "Drag to draw a block",
+ "piano_roll.controllers.other_cc": "Other CC",
+ "piano_roll.expression.bend": "Bend",
+ "piano_roll.expression.clear_all_expression": "Clear All Expression",
+ "piano_roll.expression.pres": "Pres",
+ "piano_roll.expression.pressure": "Pressure",
+ "piano_roll.expression.slide": "Slide",
+ "piano_roll.expression.vel": "Vel",
+ "piano_roll.no_selection": "No selection",
+ "piano_roll.notes": "{0} notes",
+ "piano_roll.reset_velocity": "Reset velocity",
+ "plugin_scan.looking_for_plugins": "Looking for plugins…",
+ "plugin_scan.scanning_plugins_of": "Scanning plugins · {0:N0} of {1:N0}",
+ "plugin_store.archive_unpacker.a_archive_can_only_be": "A .{0} archive can only be unpacked on macOS.",
+ "plugin_store.archive_unpacker.couldnt_start": "Couldn't start {0}.",
+ "plugin_store.archive_unpacker.failed": "{0} failed ({1}): {2}",
+ "plugin_store.archive_unpacker.the_archive_contains_an_unsafe": "The archive contains an unsafe path: {0}",
+ "plugin_store.archive_unpacker.the_deb_archive_has_no": "The .deb archive has no data.",
+ "plugin_store.archive_unpacker.the_deb_archive_is_damaged": "The .deb archive is damaged.",
+ "plugin_store.archive_unpacker.the_deb_archive_is_truncated": "The .deb archive is truncated.",
+ "plugin_store.archive_unpacker.unpacking_needs_which_wasnt_found": "Unpacking needs \"{0}\", which wasn't found.",
+ "plugin_store.archive_unpacker.unsupported_archive_type": "Unsupported archive type \"{0}\".",
+ "plugin_store.installing": "Installing {0}…",
+ "ports.i_process_cpu.of_all_cpus": "of all CPUs",
+ "ports.i_process_cpu.of_one_core": "of one core",
+ "preferences.a_b_compare_move_copy": "A / B compare, move, copy, delete, presets, save preset",
+ "preferences.a_multi_selection_gets_its": "A multi-selection gets its own menu: colour, height, freeze, group, copy, duplicate, delete",
+ "preferences.add_a_note_with_the": "Add a note with the length and velocity of the last note touched · on a note, delete it",
+ "preferences.add_a_point_on_a": "Add a point · on a point, delete it · right-click to clear the curve",
+ "preferences.add_a_warp_marker_on": "Add a warp marker · on a marker, delete it",
+ "preferences.add_an_instrument_audio_or": "Add an instrument, audio or return track · rename or delete one",
+ "preferences.add_folder": "Add folder…",
+ "preferences.add_plugin_scan_folder": "Add plugin scan folder",
+ "preferences.add_the_track_to_the": "Add the track to the selection · again to remove it",
+ "preferences.add_this_config_or_the": "Add this config (or the URL) as an MCP server in Claude Desktop / Claude Code. Loopback only; off by default.",
+ "preferences.adding_a_plug_in_from": "Adding a plug-in from the browser, by drag and drop or from the palette opens its editor. Loading a project, undo and paste never do.",
+ "preferences.ai_control_mcp": "AI control (MCP)",
+ "preferences.align_the_audio_to_the": "Align the audio to the grid · the wave stretches as you drag",
+ "preferences.all": "All",
+ "preferences.always_start_a_new_track": "Always start a new track with it",
+ "preferences.an_instrument_or_instrument_preset": "An instrument or instrument preset on a new track · a track: open it in Devices",
+ "preferences.any_button": "Any button",
+ "preferences.any_button_can_be_mapped": "Any button can be mapped to a control instead: click MIDI in the top-right, click the control, then press the button. A mapped button drives that control and stops playing its note; the rest of the pad keeps the layout above. The sticks and the trigger travel map the same way and are continuous, so they suit a knob or a fader — they play no notes, and do nothing until mapped. Mappings are listed in the browser's MIDI Map tab and travel with the project.",
+ "preferences.appearance": "Appearance",
+ "preferences.apply_and_keep_the_palette": "Apply and keep the palette open for the next device",
+ "preferences.apply_where_the_palette_was": "Apply where the palette was opened (the target shows in the field)",
+ "preferences.arrangement_editing": "Arrangement & editing",
+ "preferences.asio_caps": "ASIO",
+ "preferences.asio_frames": "ASIO · {0} frames @ {1}{2}",
+ "preferences.asio_unavailable_wasapi": "ASIO unavailable ({0}) → WASAPI",
+ "preferences.audio_clip_editor": "Audio clip editor",
+ "preferences.audio_clip_editor_on_adsr": "Audio clip editor on ADSR or an unwarped clip",
+ "preferences.audio_device": "Audio device",
+ "preferences.audio_device_not_running": "Audio device not running.",
+ "preferences.audio_settings_are_unavailable_in": "Audio settings are unavailable in this window.",
+ "preferences.audio_system": "Audio system",
+ "preferences.back_to_the_standard_height": "Back to the standard height",
+ "preferences.bars": "Bars",
+ "preferences.bend_range": "Bend range",
+ "preferences.black_keys_sharps": "Black keys (sharps)",
+ "preferences.browser_preview": "Browser · preview",
+ "preferences.buffer_size": "Buffer size",
+ "preferences.bypass_the_selected_device": "Bypass the selected device",
+ "preferences.cancel_the_current_gesture_clear": "Cancel the current gesture / clear the selection · close the patch-bay overlay",
+ "preferences.change_a_device_value_hold": "Change a device value · hold ⌘ or ⇧ for fine steps",
+ "preferences.change_its_velocity_the_whole": "Change its velocity · the whole selection's when the note is selected · elsewhere scroll sideways",
+ "preferences.change_the_notes_start_or": "Change the note's start or end",
+ "preferences.channels_2_16_each_carry": "Channels 2–16 each carry one note with its own pitch bend, pressure and slide (CC74). A controller that announces its range overrides this one. Channel 1 plays as an ordinary keyboard, its pitch wheel and aftertouch moving the whole instrument. ",
+ "preferences.choose": "Choose…",
+ "preferences.choose_folder": "Choose {0} folder",
+ "preferences.clear_the_device_selection_so": "Clear the device selection · so does a click on the chain's empty space",
+ "preferences.clear_the_route_volt_aurora": "Clear the route (Volt, Aurora) · pull the cable (Consort)",
+ "preferences.click_a_clip_in_the": "Click a clip in the clip strip",
+ "preferences.click_a_clip_or_arm": "⌥-click a clip or Arm",
+ "preferences.click_a_device": "Click a device",
+ "preferences.click_a_graph_handle_envelope": "⌥-click a graph handle, envelope node or mod-matrix cell",
+ "preferences.click_a_groups_link_key": "Click a group's Link key",
+ "preferences.click_a_height_key_in": "⌥-click a height key in the track menu",
+ "preferences.click_a_key": "Click a key",
+ "preferences.click_a_knob_fader_or": "⌥-click a knob, fader or slider",
+ "preferences.click_a_rhythm_step": "Click · ⇧ · ⌥ a Rhythm step",
+ "preferences.click_a_rhythm_voice": "Click a Rhythm voice",
+ "preferences.click_drag_the_ruler": "Click · drag the ruler",
+ "preferences.click_play_button": "Click play button",
+ "preferences.click_section": "Click section",
+ "preferences.click_the_bend_lanes_range": "Click the Bend lane's range",
+ "preferences.click_the_controller_tab": "Click the controller tab",
+ "preferences.click_the_position_read_out": "Click the position read-out",
+ "preferences.click_track_header": "⇧-click track header",
+ "preferences.click_wave_spec": "Click WAVE / SPEC",
+ "preferences.click_waveform": "Click waveform",
+ "preferences.close_and_go_back_where": "Close and go back where you were",
+ "preferences.close_to_the_limit_consider": "close to the limit — consider a larger buffer",
+ "preferences.colour_theme": "Colour theme",
+ "preferences.command_palette": "Command palette",
+ "preferences.consolidate_the_selection_into_one": "Consolidate the selection into one clip per track",
+ "preferences.content_folders": "Content folders",
+ "preferences.content_folders_and_version_history": "Content folders and version history",
+ "preferences.content_folders_are_unavailable_in": "Content folders are unavailable in this window.",
+ "preferences.controllers_nota_listens_to": "Controllers Nota listens to",
+ "preferences.copied": "Copied",
+ "preferences.copy_config": "Copy config",
+ "preferences.copy_cut_paste_a_clip": "Copy / cut / paste a clip · a cut clip moves when pasted · clips copied in the Arrangement paste here",
+ "preferences.copy_cut_paste_clips_a": "Copy / cut / paste clips, a time range or an automation range · pastes onto the track clicked last",
+ "preferences.copy_cut_paste_notes_paste": "Copy / cut / paste notes · paste lands on the originals",
+ "preferences.copy_cut_paste_the_selected": "Copy / cut / paste the selected devices with all their settings · each lands in its section after the selected device · a copied instrument replaces the instrument it is pasted on",
+ "preferences.copy_cut_paste_the_selected_2": "Copy / cut / paste the selected tracks · paste lands after the last one",
+ "preferences.copy_it_there": "Copy it there",
+ "preferences.copy_the_selected_clip_group": "Copy the selected clip, group slot or scene to the Arrangement at the playhead",
+ "preferences.copy_the_selected_clips_to": "Copy the selected clips to Session · the first scene row where they fit",
+ "preferences.couldnt_be_loaded_see_plugin": " {0:N0} couldn't be loaded — see plugin-scan.log in Nota's logs folder.",
+ "preferences.count_in_before_play_record": "Count-in before Play / Record: off · 1 · 2 · 4 bars",
+ "preferences.cpu_check": "CPU check",
+ "preferences.custom": "custom",
+ "preferences.cycle_devices_pattern_clip_in": "Cycle Devices / Pattern / Clip in the detail panel",
+ "preferences.d_pad_left_right": "D-pad left / right",
+ "preferences.d_pad_up_down": "D-pad up / down",
+ "preferences.dark": "Dark",
+ "preferences.deactivate_activate_the_selected_clip": "Deactivate / activate the selected clip(s)",
+ "preferences.default": "default",
+ "preferences.delete_device_selected": "Delete (device selected)",
+ "preferences.delete_the_selected_clip_or": "Delete the selected clip or scene",
+ "preferences.delete_the_selected_clip_range": "Delete the selected clip / range",
+ "preferences.delete_the_selected_device_modulator": "Delete the selected device, modulator or cable · the track's input, instrument and output are fixed",
+ "preferences.delete_the_selected_devices_with": "Delete the selected devices · with the instrument, its track",
+ "preferences.delete_the_selected_notes": "Delete the selected notes",
+ "preferences.delete_the_selected_tracks_a": "Delete the selected tracks · a group goes with its tracks",
+ "preferences.deselect_moved_or_pasted_notes": "Deselect · moved or pasted notes replace the notes under them",
+ "preferences.detail_panel": "Detail panel",
+ "preferences.device_default": "Device default",
+ "preferences.device_sample_rate_and_buffer": "Device, sample rate and buffer",
+ "preferences.devices_after_a_click_on": "Devices (after a click on a device)",
+ "preferences.devices_settings": "Devices",
+ "preferences.direction": "Direction",
+ "preferences.double_click_a_browser_instrument": "Double-click a browser instrument",
+ "preferences.double_click_a_chain_or": "Double-click a chain or macro name",
+ "preferences.double_click_a_knob_fader": "Double-click a knob, fader or slider",
+ "preferences.double_click_a_mod_matrix": "Double-click a mod-matrix cell",
+ "preferences.double_click_a_panel_edge": "Double-click a panel edge",
+ "preferences.double_click_a_track_header": "Double-click a track header",
+ "preferences.double_click_a_tracks_bottom": "Double-click a track's bottom edge",
+ "preferences.double_click_and_hold_drag": "Double-click and hold, drag",
+ "preferences.double_click_clip": "Double-click clip",
+ "preferences.double_click_empty_grid": "Double-click empty grid",
+ "preferences.double_click_header": "Double-click header",
+ "preferences.double_click_in_an_mpe": "Double-click in an MPE lane",
+ "preferences.double_click_loop_brace": "Double-click loop brace",
+ "preferences.double_click_overview": "Double-click overview",
+ "preferences.double_click_section": "Double-click section",
+ "preferences.double_click_slot": "Double-click slot",
+ "preferences.double_click_the_wave": "Double-click the wave",
+ "preferences.double_click_velocity_stem": "Double-click velocity stem",
+ "preferences.downloading": "Downloading {0}…",
+ "preferences.downloads": "Downloads",
+ "preferences.downloads.ai_models": "AI models",
+ "preferences.downloads.sample_packs": "Sample packs",
+ "preferences.drag_a_device_header": "Drag a device header",
+ "preferences.drag_a_device_onto_a": "Drag a device onto a track",
+ "preferences.drag_a_device_onto_a_2": "⌥-drag a device onto a track",
+ "preferences.drag_a_devices_header": "Drag a device's header",
+ "preferences.drag_a_returns_or_the": "Drag a return's or the master's bottom edge",
+ "preferences.drag_a_selected_devices_header": "Drag a selected device's header",
+ "preferences.drag_a_tracks_bottom_edge": "Drag a track's bottom edge",
+ "preferences.drag_a_tracks_bottom_edge_2": "Drag a track's bottom edge + ⌥",
+ "preferences.drag_a_warp_marker": "Drag a warp marker",
+ "preferences.drag_a_zone_edge": "Drag a zone edge",
+ "preferences.drag_an_audio_clip_onto": "Drag an audio clip onto an instrument track",
+ "preferences.drag_an_audio_clip_out": "Drag an audio clip out of the Arrangement",
+ "preferences.drag_an_audio_clips_adsr": "Drag an audio clip's ADSR handle",
+ "preferences.drag_below_the_last_track": "Drag below the last track",
+ "preferences.drag_clip": "Drag clip",
+ "preferences.drag_clip_2": "Drag clip + ⌥",
+ "preferences.drag_double_click_tempo": "Drag · double-click Tempo",
+ "preferences.drag_in_a_controller_lane": "Drag in a controller lane",
+ "preferences.drag_in_the_bend_pres": "Drag in the Bend / Pres / Slide lane",
+ "preferences.drag_in_the_sustain_lane": "Drag in the Sustain lane",
+ "preferences.drag_jack_jack": "Drag jack → jack",
+ "preferences.drag_knob": "Drag knob",
+ "preferences.drag_loop_edge_drag_loop": "Drag loop edge · drag loop brace",
+ "preferences.drag_note_edge": "Drag note edge",
+ "preferences.drag_on_the_keys": "Drag on the keys",
+ "preferences.drag_overview_edge": "Drag overview edge",
+ "preferences.drag_overview_strip": "Drag overview strip",
+ "preferences.drag_scene": "Drag scene",
+ "preferences.drag_section": "Drag section",
+ "preferences.drag_section_2": "⌥-drag section",
+ "preferences.drag_section_edge": "Drag section edge",
+ "preferences.drag_sections_lane": "Drag sections lane",
+ "preferences.drag_sideways_to_scroll_up": "Drag sideways to scroll · up / down to zoom out / in",
+ "preferences.drag_slider": "Drag slider",
+ "preferences.drag_the_playhead_line": "Drag the playhead line",
+ "preferences.drag_the_track_list_edge": "Drag the track-list edge",
+ "preferences.drag_velocity_stem": "Drag velocity stem",
+ "preferences.draw_a_pedal_block_on": "Draw a pedal block on the grid · ⌘ off the grid · drag an edge to resize, the body to move · double-click or Delete removes it",
+ "preferences.draw_the_controllers_curve_draws": "Draw the controller's curve · ⌥ draws a straight line · drag a point to move it · double-click adds or deletes a point",
+ "preferences.draw_the_selected_notes_mpe": "Draw the selected note's MPE curve · ⌥ draws a straight line · drag a point to move it",
+ "preferences.driver": "Driver",
+ "preferences.driver_settings": "Driver settings…",
+ "preferences.dropouts": { "one": "{0} dropout", "other": "{0} dropouts" },
+ "preferences.duplicate_a_clip_into_the": "Duplicate a clip into the slot below · a scene below itself",
+ "preferences.duplicate_the_selected_clip_s": "Duplicate the selected clip(s) / range",
+ "preferences.duplicate_the_selected_device_with": "Duplicate the selected device with all its settings",
+ "preferences.duplicate_the_selected_devices_each": "Duplicate the selected devices · each run right after itself",
+ "preferences.duplicate_the_selected_tracks": "Duplicate the selected tracks",
+ "preferences.duplicate_the_selection_replaces_the": "Duplicate the selection · replaces the notes it lands on",
+ "preferences.duplicate_time_insert_a_copy": "Duplicate time · insert a copy of the time range after it, pushing everything later right",
+ "preferences.edit_the_clip_an_empty": "Edit the clip · an empty MIDI slot gets a new clip",
+ "preferences.enable_mcp_server_let_an": "Enable MCP server (let an AI drive Nota)",
+ "preferences.end_macro_mapping_map_on": "End macro mapping (Map on the rack card)",
+ "preferences.enter_leave_full_screen_the": "Enter / leave full screen — the title bar hides in full screen",
+ "preferences.every_save_records_a_version": "Every save records a version, listed in the browser's History tab. Versions share their audio, so each one costs only what it adds.",
+ "preferences.exclusive_mode": "Exclusive mode",
+ "preferences.export_audio": "Export audio",
+ "preferences.expression": "Expression",
+ "preferences.extra_folders_are_searched_for": "Extra folders are searched for VST3 plugins on the next rescan (AU uses the system registry).",
+ "preferences.face_buttons": "Face buttons",
+ "preferences.filter_all_actions_tracks_devices": "Filter: all · actions · tracks · devices · presets",
+ "preferences.filter_shortcuts": "Filter shortcuts",
+ "preferences.fit_every_node_on_screen": "Fit every node on screen",
+ "preferences.fit_the_whole_project_on": "Fit the whole project on screen",
+ "preferences.fit_to_notes": "Fit to notes",
+ "preferences.fold_only_the_scales_notes": "Fold: only the scale's notes, or a Drum Rack's pads",
+ "preferences.follow_system": "Follow system",
+ "preferences.found_plugins": { "one": "Found {0:N0} plugin.", "other": "Found {0:N0} plugins." },
+ "preferences.frames": "{0} frames @ {1}{2}",
+ "preferences.frames_set_in_the_drivers": "{0} frames (set in the driver's settings)",
+ "preferences.gamepad_input": "Gamepad input",
+ "preferences.gamepad_input_is_macos_only": "Gamepad input is macOS-only in this build.",
+ "preferences.gamepad_macos": "Gamepad (macOS)",
+ "preferences.gamepad_settings_are_unavailable_in": "Gamepad settings are unavailable in this window.",
+ "preferences.gamepads": "Gamepads",
+ "preferences.general": "General",
+ "preferences.grid_arrangement_or_clip_editor": "Grid (Arrangement or clip editor — whichever you used last)",
+ "preferences.group_the_selected_devices_into": "Group the selected devices into a rack · audio effects: Audio Effect Rack · MIDI effects: MIDI Effect Rack · with the instrument: Instrument Rack",
+ "preferences.group_ungroup_selected_tracks_on": "Group / ungroup selected tracks · on selected devices: group them into a rack / take a rack apart",
+ "preferences.hover_the_zones": "Hover the zones",
+ "preferences.how_audio_clips_draw_on": "How audio clips draw on the arrangement: Smooth outlines the peaks around the RMS level; Solid draws every pixel; Bars spaces the peaks out so the rhythm reads. Solid and Bars also set the browser's preview.",
+ "preferences.hz_sine_at_14_dbfs": "{0:0} Hz sine at −14 dBFS, through the master.",
+ "preferences.in_a_linked_group_select": "In a linked group: select that clip alone, or arm that track alone",
+ "preferences.in_dark_mode": "In dark mode",
+ "preferences.in_light_mode": "In light mode",
+ "preferences.insert_a_scene_below_the": "Insert a scene below the selection",
+ "preferences.insert_silence_push_everything_from": "Insert silence · push everything from the range start right by its length",
+ "preferences.install": "Install",
+ "preferences.installed": "Installed",
+ "preferences.installed_to": "Installed to {0}",
+ "preferences.installing": "Installing…",
+ "preferences.interface_scale": "Interface scale",
+ "preferences.jump_the_playhead_to_its": "Jump the playhead to its start",
+ "preferences.keep_a_version_history_of": "Keep a version history of each project",
+ "preferences.keep_the_name_empty_automatic": "Keep the name (empty = automatic) · cancel",
+ "preferences.keyboard_reference": "Keyboard reference",
+ "preferences.label_every_note_in_the": "Label every note in the piano roll",
+ "preferences.language": "Language",
+ "preferences.language.applies_after_restart": "Applies after restart",
+ "preferences.language.applies_the_next_time_nota": "Applies the next time Nota starts",
+ "preferences.language.restart": "Restart",
+ "preferences.last": "Last",
+ "preferences.last_check_average_peak": "Last check: {0:0} % average, {1:0} % peak · {2} — {3}.",
+ "preferences.latency": "Latency",
+ "preferences.launch_the_selected_clip_or": "Launch the selected clip or scene",
+ "preferences.layout": "Layout",
+ "preferences.left": "Left",
+ "preferences.left_right_or_up_down": "Left / right (or up / down) changes the value · hold ⌘ or ⇧ for fine steps",
+ "preferences.library": "Library",
+ "preferences.light": "Light",
+ "preferences.link_the_groups_tracks_arming": "Link the group's tracks: arming one arms them all, and clip edits act on the clips at the same place on each",
+ "preferences.listening_on_http_127_0": "Listening on http://127.0.0.1:{0}/ (loopback)",
+ "preferences.load_its_audio_into_the": "Load its audio into the Sampler, Grain, Drum Rack (next free pad) or Instrument Rack · rest there to open its devices",
+ "preferences.loop_on_off_in_the": "Loop on / off in the ruler · the region stays, greyed out while off",
+ "preferences.loop_on_off_loop_the": "Loop on / off · loop the selected clips or time range",
+ "preferences.loop_on_off_loop_the_2": "Loop on / off · loop the selection · clear the loop region",
+ "preferences.loop_recording_overdub_every_pass": "Loop recording: Overdub (every pass adds) / Replace (keep the latest pass)",
+ "preferences.lower_raise_velocity": "Lower / raise velocity",
+ "preferences.make_it_the_active_clip": "Make it the active clip (several clips open) · its lock keeps it as a read-only reference",
+ "preferences.makes_the_whole_interface_larger": "Makes the whole interface larger or smaller. Timeline, piano roll and audio editor zoom work on top of it.",
+ "preferences.map_it_to_a_parameter": "Map it to a parameter or the selector · clear its mappings",
+ "preferences.mappable_as_continuous_controls_a": "Mappable as continuous controls (a knob, a fader); they play no notes",
+ "preferences.mappable_through_midi_learn_a": "Mappable through MIDI Learn — a mapped button drives the control instead",
+ "preferences.mark_a_new_section_over": "Mark a new section over the dragged bars",
+ "preferences.measures_audio_thread_load_for": "Measures audio-thread load for 5 s — play your project for a real-world figure.",
+ "preferences.measuring": "Measuring…",
+ "preferences.measuring_5_s_left_play": "Measuring… 5 s left — play your project for a real-world figure.",
+ "preferences.measuring_s_left_now": "Measuring… {0} s left · now {1:0} %",
+ "preferences.midi_inputs": "MIDI inputs",
+ "preferences.midi_settings_are_unavailable_in": "MIDI settings are unavailable in this window.",
+ "preferences.models.ai_models_that_run_on": "AI models that run on this computer: the audio you give them never leaves it. Each downloads once from where its authors publish it and is checked against the checksum Nota pins for it.",
+ "preferences.models.comes_with_a_model": "Comes with a model",
+ "preferences.models.is_installed_convert_melody_and": "{0} is installed — Convert Melody and Convert Harmony now use it.",
+ "preferences.models.is_installed_right_click_an": "{0} is installed — right-click an audio clip and choose Separate Stems.",
+ "preferences.models.model_ai_runtime_downloaded_once": "{0} model + {1} AI runtime, downloaded once",
+ "preferences.models.on_disk": "On disk",
+ "preferences.models.onnx_runtime_has_no_build": "ONNX Runtime has no build for this computer, so the models can't run here.",
+ "preferences.models.open_the_models_project_page": "Open the model's project page",
+ "preferences.models.remove_ai_model": "Remove AI model",
+ "preferences.models.remove_will_offer_to_download": "Remove {0}? {1} will offer to download it again.",
+ "preferences.models.removing": "Removing…",
+ "preferences.models.the_ai_runtime_goes_too": " The AI runtime goes too.",
+ "preferences.modular_after_a_click_on": "Modular (after a click on the canvas)",
+ "preferences.mouse": "Mouse",
+ "preferences.move_earlier_later_duplicate_or": "Move earlier / later · duplicate or delete with content",
+ "preferences.move_freely_ignoring_the_grid": "Move freely, ignoring the grid",
+ "preferences.move_it_there_out_of": "Move it there (out of the panel, onto a track row or Session column) · the instrument replaces that track's and its own track goes",
+ "preferences.move_it_to_another_slot": "Move it to another slot · ⌥ copies",
+ "preferences.move_it_within_its_chain": "Move it within its chain · onto another chain's row to move it there",
+ "preferences.move_notes_by_the_grid": "Move notes by the grid",
+ "preferences.move_only_the_section_marker": "Move only the section marker, snapped to bars",
+ "preferences.move_the_clips_to_a": "Move the clips to a new track like their own · one per source track",
+ "preferences.move_the_playhead_there_drag": "Move the playhead there · drag to scrub · snapped to the grid on a warped clip, ⌥ off it",
+ "preferences.move_the_playhead_there_drag_2": "Move the playhead there · drag to scrub, snapped to the grid · ⌥ off the grid",
+ "preferences.move_the_selected_clips_to": "Move the selected clips to the next track that takes them, at the same beats",
+ "preferences.move_the_selected_devices_of": "Move the selected devices of that section together",
+ "preferences.move_the_selection_between_slots": "Move the selection between slots and scenes",
+ "preferences.move_through_samples_presets_and": "Move through samples, presets and devices · with Auto on, each one plays as it is selected",
+ "preferences.move_through_the_results": "Move through the results",
+ "preferences.narrow_widen_the_grid_in": "Narrow / widen the grid · in Auto, change the density",
+ "preferences.new_project_open_a_project": "New project / open a project",
+ "preferences.new_versions_of_nota": "New versions of Nota",
+ "preferences.no_asio_driver_found_few": "No ASIO driver found. Few interfaces ship an ARM64 ASIO driver yet — install one from your interface's maker, or a generic one such as FlexASIO.",
+ "preferences.no_asio_driver_found_install": "No ASIO driver found. Install your interface's driver, or a generic one such as FlexASIO.",
+ "preferences.no_gamepad_detected_connect_one": "No gamepad detected. Connect one and it appears here.",
+ "preferences.no_inputs_on_this_driver": "No inputs on this driver",
+ "preferences.no_midi_inputs_detected_connect": "No MIDI inputs detected. Connect a controller and reopen Settings.",
+ "preferences.nota_synth_volt_aurora_operator": "Nota Synth, Volt, Aurora, Operator, Pentad and Physical play per-note expression.",
+ "preferences.notes_go_to_the_armed": "Notes go to the armed (record-enabled) instrument track — enable Record to capture them, or use the audition track to just play.",
+ "preferences.nothing_matches": "Nothing matches.",
+ "preferences.nudge_the_selected_clips_by": "Nudge the selected clips by a 64th note",
+ "preferences.nudge_the_selected_clips_by_2": "Nudge the selected clips by the grid step · stops at the song start",
+ "preferences.octave_1_1": "Octave −1 / +1",
+ "preferences.off_a_click_only_selects": "Off: a click only selects, and an open panel follows it. Double-click a track for its devices or a clip to edit it.",
+ "preferences.open_close_the_command_palette": "Open / close the command palette — from any window, even while typing",
+ "preferences.open_in_the_clip_editor": "Open in the clip editor, opening the detail panel · on one of several selected MIDI clips, open them all together",
+ "preferences.open_its_devices_in_the": "Open its devices in the detail panel · a plug-in's own window is Open editor on its card",
+ "preferences.open_plug_in_window_on": "Open plug-in window on insert",
+ "preferences.open_the_detail_panel_when": "Open the detail panel when you select a track or clip",
+ "preferences.output_check": "Output check",
+ "preferences.overloaded_raise_the_buffer_size": "overloaded — raise the buffer size",
+ "preferences.paste_the_last_range_as": "Paste the last range as audio rendered through its devices",
+ "preferences.patch_a_cable_in_nota": "Patch a cable in Nota Consort · ⌥-click a jack to pull its cables",
+ "preferences.per_note_expression_from_mpe": "Per-note expression from MPE controllers",
+ "preferences.performance": "Performance",
+ "preferences.phones_and_tablets_on_this": "Phones and tablets on this network",
+ "preferences.pick_how_far_the_bend": "Pick how far the Bend lane reaches: ±2, 12, 24, 48 or 96 semitones · a bend already on the notes can widen it further",
+ "preferences.play_c4_d4_e4_f4": "Play C4 D4 E4 F4",
+ "preferences.play_from_that_point": "Play from that point",
+ "preferences.play_g4_a4_b4_c5": "Play G4 A4 B4 C5",
+ "preferences.play_it_on_the_tracks": "Play it on the track's instrument · ⇧-drag glides through the keys · ⌘-click selects every note of that pitch",
+ "preferences.play_notes_computer_keyboard": "Play notes (computer keyboard)",
+ "preferences.play_notes_or_drive_mapped": "Play notes or drive mapped controls",
+ "preferences.play_pause_the_playhead_stays": "Play / pause · the playhead stays put and Play carries on from there",
+ "preferences.play_stop_stop_goes_back": "Play / Stop · Stop goes back to where playback started",
+ "preferences.play_stop_the_selected_sample": "Play / stop the selected sample, preset or device",
+ "preferences.play_test_tone": "Play test tone",
+ "preferences.plenty_of_headroom": "plenty of headroom",
+ "preferences.plug_in_window": "Plug-in window",
+ "preferences.plug_ins": "Plug-ins",
+ "preferences.plug_ins_sample_packs_and": "Plug-ins, sample packs and AI models",
+ "preferences.plugin_scan_folders": "Plugin scan folders",
+ "preferences.plugin_scanning_is_unavailable_in": "Plugin scanning is unavailable in this window.",
+ "preferences.port": "Port",
+ "preferences.position_freely_ignoring_the_grid": "Position freely, ignoring the grid for this drag (the magnet in the transport latches the same thing)",
+ "preferences.projects": "Projects",
+ "preferences.put_the_note_back_to": "Put the note back to the default velocity (0.8) · the whole selection's when the note is selected · undo is one step",
+ "preferences.quit_nota_asks_about_unsaved": "Quit Nota · asks about unsaved changes first",
+ "preferences.racks": "Racks",
+ "preferences.rearrange_the_song_it_and": "Rearrange the song · it and everything in it move to the marked boundary, the sections between close up · Esc cancels",
+ "preferences.refresh": "Refresh",
+ "preferences.refreshing": "Refreshing…",
+ "preferences.reload_the_registry": "Reload the registry",
+ "preferences.remote": "Remote",
+ "preferences.remote.a_trusted_phone_reconnects_from": "A trusted phone reconnects from its Home Screen icon without a code. Forget it and it has to scan again. Turning Remote off disconnects everyone.",
+ "preferences.remote.allow_control_from_a_phone": "Allow control from a phone",
+ "preferences.remote.also_mixer_transport_macros_xy": "Also mixer, transport, macros, XY and Session.",
+ "preferences.remote.days_ago": "{0} days ago",
+ "preferences.remote.disconnect_it_and_make_it": "Disconnect it and make it scan a new code to come back",
+ "preferences.remote.forget": "Forget",
+ "preferences.remote.h_ago": "{0} h ago",
+ "preferences.remote.just_now": "just now",
+ "preferences.remote.listening_on": "Listening on {0}",
+ "preferences.remote.min_ago": "{0} min ago",
+ "preferences.remote.no_phone_has_paired_yet": "No phone has paired yet. Turn Remote on and scan the code in Connect phone.",
+ "preferences.remote.nota_never_shows_files_or": " Nota never shows files or paths to the phone, and serves nothing from your disk.",
+ "preferences.remote.nota_remote": "Nota Remote",
+ "preferences.remote.now": "now",
+ "preferences.remote.on_no_network": "On · no network",
+ "preferences.remote.pads_and_keys_mixer_transport": "Pads and keys. Mixer, transport and mappings are read-only.",
+ "preferences.remote.phones_may": "Phones may",
+ "preferences.remote.phones_reach_nota_on_the": "Phones reach Nota on the port above: if a firewall is on, allow it.",
+ "preferences.remote.play_and_control_the_project": "Play and control the project",
+ "preferences.remote.play_notes_only": "Play notes only",
+ "preferences.remote.trusted_devices": "Trusted devices",
+ "preferences.remote.usb_caps": "USB ",
+ "preferences.remote.when_you_turn_this_on": "When you turn this on, Windows asks whether Nota may use the network. Allow private networks, or phones can't reach Nota.",
+ "preferences.remote.when_you_turn_this_on_2": "When you turn this on, macOS asks whether Nota may find devices on the local network. Allow it, or phones can't reach Nota.",
+ "preferences.remove": "Remove",
+ "preferences.remove_the_selected_device_the": "Remove the selected device — the header no longer carries a close button",
+ "preferences.removing": "Removing {0}…",
+ "preferences.rename_it": "Rename it",
+ "preferences.rename_it_right_click_reset": "Rename it · right-click → Reset to default name for its automatic Section N",
+ "preferences.rename_the_selected_clip_or": "Rename the selected clip or scene",
+ "preferences.rename_the_track": "Rename the track",
+ "preferences.reorder_devices_or_right_click": "Reorder devices (or right-click the header → Move left / right)",
+ "preferences.reorder_scenes": "Reorder scenes",
+ "preferences.replace_the_selected_device_instead": "Replace the selected device instead of inserting after it",
+ "preferences.rescan_plugins": "Rescan plugins",
+ "preferences.reset_the_detail_panel_the": "Reset the detail panel, the Mixer or the browser to its default size",
+ "preferences.reset_the_value_to_its": "Reset the value to its default",
+ "preferences.reset_velocity_from_a_menu": "Reset velocity from a menu · same as the double-click",
+ "preferences.resize_every_track_at_once": "Resize every track at once",
+ "preferences.resize_it_snapped_to_bars": "Resize it, snapped to bars",
+ "preferences.resize_that_end_of_the": "Resize that end of the loop region · move the whole region · ⌥ off the grid",
+ "preferences.resize_that_row_header_or": "Resize that row (header or lane) · same snaps · double-click goes back to compact",
+ "preferences.resize_the_track_header_or": "Resize the track (header or lane) · snaps to compact / standard / large · a multi-selection resizes together",
+ "preferences.return_esc_renaming_a_section": "Return · Esc (renaming a section)",
+ "preferences.return_esc_tab_tab_typing": "Return · Esc · Tab / ⇧Tab (typing a value)",
+ "preferences.right": "Right",
+ "preferences.right_click_a_device_header": "Right-click a device header",
+ "preferences.right_click_a_knob_fader": "Right-click a knob, fader or slider",
+ "preferences.right_click_a_macro": "Right-click a macro",
+ "preferences.right_click_header_or_grid": "Right-click header or grid",
+ "preferences.right_click_ruler": "Right-click ruler",
+ "preferences.right_click_section": "Right-click section",
+ "preferences.right_click_the_metronome": "Right-click the metronome",
+ "preferences.right_click_track_headers": "Right-click track headers",
+ "preferences.right_click_velocity_stem": "Right-click velocity stem",
+ "preferences.round_trip": " · round trip {0}",
+ "preferences.sample_rate": "Sample rate",
+ "preferences.samples": "Samples",
+ "preferences.samples.credit": "Credit: {0}",
+ "preferences.samples.download_samples_on_disk": "{0} download · {1} samples · {2} on disk · {3}",
+ "preferences.samples.free_sample_packs_from_the": "Free sample packs from the Nota sample registry, licensed for any music, commercial releases included. Each pack downloads from where its author publishes it, is checked against the registry's checksum and unpacked into your Samples folder.",
+ "preferences.samples.is_installed_find_it_under": "{0} is installed — find it under Downloaded in the browser's Files tab, where it is being analysed for tempo and key; its instruments appear under Nota Mosaic → Packs.",
+ "preferences.samples.loading_the_sample_registry": "Loading the sample registry…",
+ "preferences.samples.loops": "Loops",
+ "preferences.samples.mixed": "Mixed",
+ "preferences.samples.no_sample_packs_installed_from": "No sample packs installed from the registry yet.",
+ "preferences.samples.one_shots": "One-shots",
+ "preferences.samples.open_the_packs_page": "Open the pack's page",
+ "preferences.samples.remove_its_folder_is_deleted": "Remove {0}? Its folder ({1}) is deleted.",
+ "preferences.samples.remove_sample_pack": "Remove sample pack",
+ "preferences.samples.samples": { "one": "{0} sample", "other": "{0} samples" },
+ "preferences.samples.samples_n": "{0} · {1} samples",
+ "preferences.samples.show_the_packs_folder": "Show the pack's folder",
+ "preferences.save_a_version_with_a": "Save a version with a note",
+ "preferences.save_records_a_version_save": "Save (records a version) / save as",
+ "preferences.saved_driver_not_found": "Saved driver not found",
+ "preferences.scan": "Scan",
+ "preferences.scanner_worker_not_found": "Scanner worker not found.",
+ "preferences.scanning": "Scanning…",
+ "preferences.scroll_it_sideways_over_an": "Scroll it sideways · over an EQ band's handle the wheel sets its Q, over a value box it steps the value",
+ "preferences.scroll_on_the_track_button": "Scroll on the track button",
+ "preferences.scrub_the_playhead": "Scrub the playhead",
+ "preferences.scrub_the_playhead_on_the": "Scrub the playhead · on the ruler or over empty grid",
+ "preferences.search": "Search",
+ "preferences.searching_folders": { "one": "Searching {0} folder", "other": "Searching {0} folders" },
+ "preferences.see_which_chains_a_note": "See which chains a note would play",
+ "preferences.select_a_range_of_devices": "Select a range of devices (MIDI effects, instrument, audio effects) / add or remove one",
+ "preferences.select_a_range_of_tracks": "Select a range of tracks / add or remove one track",
+ "preferences.select_all_clips": "Select all clips",
+ "preferences.select_all_notes": "Select all notes",
+ "preferences.select_all_tracks": "Select all tracks",
+ "preferences.select_and_play_it_drop": "Select and play it · drop a file on it to load a sample",
+ "preferences.select_it_for_c_x": "Select it for ⌘C ⌘X ⌘V ⌘D and Delete",
+ "preferences.select_several_returns_they_resize": "Select several returns · they resize together",
+ "preferences.semitones": "±{0} semitones",
+ "preferences.session_after_a_click_in": "Session (after a click in the grid)",
+ "preferences.set_a_chains_key_velocity": "Set a chain's key, velocity or select range · edges never cross",
+ "preferences.set_every_track_to_compact": "Set every track to Compact · Standard · Large",
+ "preferences.set_in_the_drivers_settings": "Set in the driver's settings",
+ "preferences.set_it_cancel_set_it": "Set it · cancel · set it and type the next / previous value on the card",
+ "preferences.set_the_tempo_the_clip": "Set the tempo the clip was recorded at · ÷2 / ×2 halve or double it",
+ "preferences.set_velocity_selected_notes_move": "Set velocity · selected notes move together · ⇧ adds a note",
+ "preferences.shape_attack_decay_sustain_release": "Shape attack · decay + sustain · release (top corners and the dot on hover) · ⌥-click types the stage · double-click resets it",
+ "preferences.shape_the_new_note_move": "Shape the new note: move it · ⇧ set its length · ⌘ drag up / down for velocity",
+ "preferences.shift_octave_down_up": "Shift octave down / up",
+ "preferences.shift_the_gamepad_octave": "Shift the gamepad octave",
+ "preferences.shortcuts": "Shortcuts",
+ "preferences.shorten_lengthen_the_notes_by": "Shorten / lengthen the notes by the grid",
+ "preferences.shoulder_buttons": "Shoulder buttons",
+ "preferences.show_a_midi_controller_under": "Show a MIDI controller under the notes · click it again to pick another CC, the pitch wheel or channel pressure",
+ "preferences.show_fewer_parameters_on_every": "Show fewer parameters on every opened node",
+ "preferences.show_playhead_scroll_the_arrangement": "Show playhead · scroll the Arrangement to it without moving it · picks up a paused Follow",
+ "preferences.shows_every_note_name_c": "Shows every note name (C, D, E…) on the piano roll's keys instead of only C. Helpful when learning notes.",
+ "preferences.smooth": "Smooth",
+ "preferences.snap_to_grid_on_off": "Snap to grid on / off",
+ "preferences.solid": "Solid",
+ "preferences.source": "Source",
+ "preferences.split_at_the_playhead_at": "Split at the playhead · at the range edges",
+ "preferences.status": "Status",
+ "preferences.step": "Step",
+ "preferences.step_on_off_accent_quiet": "Step on / off · accent · quiet step — drag across to paint, up / down (or scroll) for its velocity",
+ "preferences.step_through_the_demo_tracks": "Step through the demo tracks an effect preset is heard through",
+ "preferences.sticks_triggers": "Sticks · triggers",
+ "preferences.stop_again_back_to_the": "Stop (again → back to the start) · in the Session grid it launches the selection",
+ "preferences.stop_tone": "Stop tone",
+ "preferences.store.apple_silicon": "Apple silicon",
+ "preferences.store.apple_silicon_intel": "Apple silicon + Intel",
+ "preferences.store.collection": "Collection",
+ "preferences.store.effect": "Effect",
+ "preferences.store.effects": "Effects",
+ "preferences.store.is_installed_find_it_in": "{0} {1} is installed — find it in the browser.",
+ "preferences.store.is_installed_rescan_plugins_to": "{0} is installed. Rescan plugins to use it.",
+ "preferences.store.linux": "Linux",
+ "preferences.store.loading_the_plugin_registry": "Loading the plugin registry…",
+ "preferences.store.no_version": "No {0} version",
+ "preferences.store.no_version_for": "No {0} version for {1}",
+ "preferences.store.not_available_for_this_computer": "Not available for this computer",
+ "preferences.store.nothing_installed_from_the_registry": "Nothing installed from the registry yet.",
+ "preferences.store.open_source_vst3_plugins_from": "Open-source VST3 plugins from the Nota plugin registry. Each one downloads from the project's own GitHub release, is checked against the registry's checksum and unpacked — installers never run.",
+ "preferences.store.open_the_source_repository": "Open the source repository",
+ "preferences.store.remove_plugin": "Remove plugin",
+ "preferences.store.remove_projects_that_use_it": "Remove {0}? Projects that use it will load without it until it's installed again.",
+ "preferences.store.scanning": "Scanning {0}…",
+ "preferences.store.stop_the_download_nothing_is": "Stop the download — nothing is changed",
+ "preferences.store.windows": "Windows",
+ "preferences.swap_it_onto_the_selected": "Swap it onto the selected instrument track · clips and effects stay · no track selected starts one",
+ "preferences.switch_a_controller_off_to": "Switch a controller off to stop Nota listening to it. New devices are on by default.",
+ "preferences.switch_between_the_adaptive_auto": "Switch between the adaptive (Auto) and a fixed grid",
+ "preferences.switch_it_between_bars_and": "Switch it between bars and time · every ruler follows",
+ "preferences.switch_the_well_between_the": "Switch the well between the waveform and a live spectrum",
+ "preferences.system_default": "System default",
+ "preferences.take_it_as_a_sample": "Take it as a sample: drop on a pad, a Grain, a Rhythm voice, a Session slot — the clip stays put",
+ "preferences.take_the_devices_out_of": "Take the devices out of a selected one-chain rack",
+ "preferences.test": "Test",
+ "preferences.the_clip_editor_fills_the": "The clip editor fills the window / back to the split it had",
+ "preferences.the_devices_native_sample_rate": "The device's native sample rate and buffer size are used instead of the ones above. If it is busy or doesn't allow exclusive access, Nota falls back to shared mode.",
+ "preferences.the_driver_didnt_start": "the driver didn't start",
+ "preferences.the_driver_doesnt_support": "The driver doesn't support {0}",
+ "preferences.the_language_of_menus_panels": "The language of menus, panels and messages. It changes when Nota restarts. Project files and the names you type are never translated.",
+ "preferences.theme_scale_waveforms_and_ai": "Theme, scale, waveforms and AI control",
+ "preferences.themes_change_colours_only_follow": "Themes change colours only. Follow system switches between your dark-mode and light-mode theme with the OS appearance.",
+ "preferences.this_erases_the_version_history": "This erases the version history of the open project now, and of any other project the next time you save it. Older versions can't be brought back.",
+ "preferences.toggle_automation_mode": "Toggle automation mode",
+ "preferences.toggle_the_mixer_view": "Toggle the Mixer view",
+ "preferences.track_headers": "Track headers",
+ "preferences.tracks_after_a_click_in": "Tracks (after a click in the track headers)",
+ "preferences.transpose_by_a_semitone": "Transpose by a semitone",
+ "preferences.transpose_by_an_octave": "Transpose by an octave",
+ "preferences.triplet_grid_on_off": "Triplet grid on / off",
+ "preferences.turn_off_and_erase": "Turn off and erase",
+ "preferences.turn_off_version_history": "Turn off version history",
+ "preferences.type_a_value_units_like": "Type a value (units like k, ms, dB, L / R work) · double-click its value does the same",
+ "preferences.type_first_to_filter_actions": "Type first to filter: actions, tracks, devices, presets, Modular nodes",
+ "preferences.type_its_values_a_node": "Type its values — a node with several (frequency · gain · Q, decay · sustain) takes Tab between them",
+ "preferences.type_the_preview_volume_double": "Type the preview volume · double-click resets it to 0 dB",
+ "preferences.type_value_reset_to_default": "Type value… · Reset to default",
+ "preferences.undo_redo": "Undo / redo",
+ "preferences.update_to": "Update to {0}",
+ "preferences.updates": "Updates",
+ "preferences.updates.automatic_updates": "Automatic updates",
+ "preferences.updates.check_for_updates_automatically": "Check for updates automatically",
+ "preferences.updates.check_now": "Check now",
+ "preferences.updates.checking": "Checking…",
+ "preferences.updates.couldnt_reach_github_to_check": "Couldn't reach GitHub to check for a newer version. Check your internet connection and try again.",
+ "preferences.updates.download_opens_the_release_page": "Download opens the release page.",
+ "preferences.updates.it_installs_the_next_time": "It installs the next time you quit Nota, or click Restart to update in the status bar.",
+ "preferences.updates.last_checked": "Last checked {0}.",
+ "preferences.updates.not_checked_yet": "Not checked yet.",
+ "preferences.updates.nota_is_available_you_have": "Nota {0} is available — you have {1}.",
+ "preferences.updates.nota_is_ready_to_install": "Nota {0} is ready to install.",
+ "preferences.updates.nota_is_the_latest_version": "Nota {0} is the latest version.",
+ "preferences.updates.on_launch_and_once_a": "On launch and once a day, Nota asks GitHub whether a newer version is out and tells you in the status bar. Nothing is downloaded until you click Update.",
+ "preferences.updates.the_update_didnt_download": "The update didn't download.",
+ "preferences.updates.this_copy_of_nota_cant": "This copy of Nota can't replace itself (a development build, or one run straight from the disk image), so a new version opens its release page to download.",
+ "preferences.updates.this_version": "This version",
+ "preferences.updates.update_downloads_it_here_it": "Update downloads it here; it installs when you restart or quit Nota.",
+ "preferences.updates.you_have_nota": "You have Nota {0}.",
+ "preferences.use_a_connected_gamepad_for": "Use a connected gamepad for notes and mapped controls",
+ "preferences.velocity": "Velocity − / +",
+ "preferences.velocity_10_10_by_1": "Velocity +10 / −10 · ⌥⇧ by 1",
+ "preferences.velocity_wheel": "Velocity wheel",
+ "preferences.version_history": "Version history",
+ "preferences.was_removed": "{0} was removed.",
+ "preferences.wasapi_exclusive_lowest_latency_mutes": "WASAPI exclusive — lowest latency, mutes other apps",
+ "preferences.waveform": "Waveform",
+ "preferences.wheel_over_a_note": "⇧ + wheel over a note",
+ "preferences.wheel_over_a_note_in": "⇧ + wheel over a note in the piano roll changes its velocity, or the whole selection's when that note is selected: one MIDI step per notch at 1×. Anywhere else ⇧ + wheel scrolls, and Off leaves it scrolling everywhere.",
+ "preferences.wheel_over_the_device_chain": "Wheel over the device chain",
+ "preferences.wheel_up_lowers_the_velocity": "Wheel up lowers the velocity",
+ "preferences.where_nota_looks_for_vst3": "Where Nota looks for VST3",
+ "preferences.which_side_of_the_arrangement": "Which side of the arrangement the track list sits on. Right starts the timeline at the left edge, next to the browser. Also in the View menu.",
+ "preferences.while_dragging_a_warp_marker": "While dragging a warp marker or a segment tempo: put it back",
+ "preferences.white_keys_from_c4": "White keys, from C4",
+ "preferences.widen_or_narrow_the_track": "Widen or narrow the track headers · double-click resets",
+ "preferences.window": "Window",
+ "preferences.working": "Working…",
+ "preferences.zoom_by_resizing_the_viewport": "Zoom by resizing the viewport window",
+ "preferences.zoom_rows_down_taller_up": "Zoom rows · down taller, up shorter",
+ "preferences.zoom_rows_trackpad": "Zoom rows (trackpad)",
+ "preferences.zoom_rows_vertical_zoom": "Zoom rows (vertical zoom)",
+ "preview_player.auto": "Auto ({0})",
+ "preview_player.auto_audition_play_a_preset": "Auto-audition: play a preset or device on select",
+ "preview_player.auto_audition_play_a_sample": "Auto-audition: play a sample on select",
+ "preview_player.auto_audition_play_on_select": "Auto-audition: play on select",
+ "preview_player.auto_for_this_effect": " (auto for this effect)",
+ "preview_player.bit_float": "{0}-bit float",
+ "preview_player.heard_through_click_to_pick": "Heard through {0} — click to pick a track, scroll to step through them",
+ "preview_player.no_sound_to_preview": "no sound to preview",
+ "preview_player.picked_for_this_effect_drums": "Picked for this effect: drums for dynamics, keys for time and modulation, a full mix for tone",
+ "preview_player.play_to_see_the_spectrum": "play to see the spectrum",
+ "preview_player.preview_failed": "Preview failed: {0}",
+ "preview_player.preview_volume": "Preview volume",
+ "preview_player.preview_volume_click_to_type": "Preview volume {0} · ⌥-click to type · double-click for 0{1}dB",
+ "preview_player.previewing": "Previewing {0}",
+ "preview_player.sample": "Sample — {0}",
+ "preview_player.sample_pick_one_in_files": "Sample — pick one in Files",
+ "preview_player.spec": "Spec",
+ "preview_player.wave": "Wave",
+ "progress.cancelling": "Cancelling…",
+ "record_input_pick.audio_input_1_mono": "Audio input 1 (mono)",
+ "record_input_pick.audio_input_2_mono": "Audio input 2 (mono)",
+ "record_input_pick.audio_inputs_1_2_stereo": "Audio inputs 1/2 (stereo)",
+ "record_input_pick.ext": "Ext",
+ "record_input_pick.ext_1": "Ext 1",
+ "record_input_pick.ext_2": "Ext 2",
+ "registry.client.couldnt_download": "Couldn't download {0}: {1}",
+ "registry.client.couldnt_reach_the_check_your": "Couldn't reach the {0}. Check your internet connection.",
+ "registry.client.the_download_of_doesnt_match": "The download of {0} doesn't match the registry's checksum — not installing it.",
+ "registry.client.the_download_of_is_larger": "The download of {0} is larger than the registry says — not installing it.",
+ "registry.client.unsafe_path_in_the_registry": "Unsafe path in the registry entry: {0}",
+ "remote.connect.address": "Address",
+ "remote.connect.allow": "Allow",
+ "remote.connect.code": "Code",
+ "remote.connect.connect_phone": "Connect phone",
+ "remote.connect.connected": "connected",
+ "remote.connect.connecting": "connecting",
+ "remote.connect.disconnect_this_phone_it_stays": "Disconnect this phone (it stays trusted — forget it in Settings → Remote)",
+ "remote.connect.ms": "{0} ms · {1}",
+ "remote.connect.ms_weak_network": "{0} ms · weak network",
+ "remote.connect.point_the_phone_camera_at": "Point the phone camera at the code. Over the cable the link is instant and needs no Wi-Fi; the code changes every 2 minutes and after each connection.",
+ "remote.connect.point_the_phone_camera_at_2": "Point the phone camera at the code. Same Wi-Fi only — or plug in a USB cable (USB tethering on the phone; Internet Sharing on the Mac) for an instant link. The code changes every 2 minutes and after each connection.",
+ "remote.connect.remote_is_off_turn_it": "Remote is off. Turn it on to show a QR code a phone on the same Wi-Fi can scan.",
+ "remote.connect.remote_is_off_turn_it_2": "Remote is off. Turn it on to show a QR code. The first time, Windows asks whether Nota may use the network; allow private networks.",
+ "remote.connect.remote_is_off_turn_it_3": "Remote is off. Turn it on to show a QR code. The first time, macOS asks to allow Nota on the local network; click Allow.",
+ "remote.connect.this_computer_isnt_on_a": "This computer isn't on a network. Join the same Wi-Fi as the phone, share the phone's hotspot with it, or plug in a USB cable (USB tethering on the phone; Internet Sharing on the Mac).",
+ "remote.connect.usb_caps": "USB",
+ "remote.connect.usb_ms": "USB · {0} ms · {1}",
+ "remote.port_is_in_use_by": "Port {0} is in use by another app. Pick another port.",
+ "sample_store.couldnt_remove_the_packs_files": "Couldn't remove the pack's files — close anything using them and try again.",
+ "sample_store.installing": "Installing {0}…",
+ "sample_store.invalid_pack_id": "Invalid pack id \"{0}\".",
+ "sample_store.needs_of_free_space_in": "{0} needs {1} of free space in your Samples folder, which has {2}.",
+ "sample_store.sample_index.the_sample_registry_needs_a": "The sample registry needs a newer version of Nota.",
+ "sample_store.the_download_of_contains_no": "The download of {0} contains no samples Nota can use.",
+ "sample_store.the_download_of_doesnt_contain": "The download of {0} doesn't contain {1}.",
+ "sample_store.the_sample_registry_index_is": "The sample registry index is damaged.",
+ "sample_store.unpacking_needs_of_free_space": "Unpacking {0} needs {1} of free space on the system drive, which has {2}.",
+ "save_changes.dont_save": "Don't save",
+ "save_changes.save": "Save",
+ "save_changes.saving": "Saving…",
+ "session.bars": { "one": "{0} bar", "other": "{0} bars" },
+ "session.bars_n": "{0}.{1} bars",
+ "session.captured": "Captured",
+ "session.captured_the_playing_clips_into": "Captured the playing clips into a new scene",
+ "session.copied_clip": "Copied clip",
+ "session.copied_clip_to_the_arrangement": "Copied clip to the arrangement at the playhead",
+ "session.copied_clips_to_the_arrangement": "Copied {0} clips to the arrangement at the playhead",
+ "session.cut_clip_paste_to_move": "Cut clip — paste to move it",
+ "session.deleted_clip": "Deleted clip",
+ "session.deleted_scene": "Deleted scene",
+ "session.duplicated_clip": "Duplicated clip",
+ "session.duplicated_scene": "Duplicated scene",
+ "session.grid.add_a_scene_at_the": "Add a scene at the end",
+ "session.grid.add_audio_track": "Add audio track",
+ "session.grid.add_instrument_track": "Add instrument track",
+ "session.grid.add_return_track": "Add return track",
+ "session.grid.add_stop_button": "Add stop button",
+ "session.grid.add_track": "Add track",
+ "session.grid.arr": "Arr",
+ "session.grid.back_to_arrangement_for_this": "Back to Arrangement for this track",
+ "session.grid.capture_playing_clips_below": "Capture playing clips below",
+ "session.grid.copy_scene_to_arrangement": "Copy scene to Arrangement",
+ "session.grid.copy_to_arrangement": "Copy to Arrangement",
+ "session.grid.delete_group_and_its_tracks": "Delete group and its tracks",
+ "session.grid.delete_scene": "Delete scene",
+ "session.grid.drop_a_midi_clip_on": "Drop a MIDI clip on a MIDI track, audio on audio.",
+ "session.grid.fold_the_group_into_one": "Fold the group into one column",
+ "session.grid.insert_scene_below": "Insert scene below",
+ "session.grid.launch_scene": "Launch scene",
+ "session.grid.moved_scene": "Moved scene",
+ "session.grid.rec_in": "Rec in…",
+ "session.grid.remove_stop_button": "Remove stop button",
+ "session.grid.scene": "+ Scene",
+ "session.grid.scene_2": "{0} · scene {1}",
+ "session.grid.scene_n": "Scene · {0}",
+ "session.grid.scenes": "Scenes",
+ "session.grid.show_the_groups_tracks": "Show the group's tracks",
+ "session.grid.stop_all_clips": "Stop all clips",
+ "session.grid.stop_every_track_in_this": "Stop every track in this group",
+ "session.grid.stop_scene": "Stop scene",
+ "session.grid.stop_this_track": "Stop this track",
+ "session.group": "Group · {0}{1}",
+ "session.insert_midi_clip": "Insert MIDI clip",
+ "session.inserted_scene": "Inserted scene",
+ "session.inspector.16_bars": "16 bars",
+ "session.inspector.1_beat": "1 beat",
+ "session.inspector.2_bars": "2 bars",
+ "session.inspector.2_beats": "2 beats",
+ "session.inspector.4_bars": "4 bars",
+ "session.inspector.8_bars": "8 bars",
+ "session.inspector.after": "After",
+ "session.inspector.again": "Again",
+ "session.inspector.any": "Any",
+ "session.inspector.chance_of_a_in_percent": "Chance of A in percent · B gets the rest · drag",
+ "session.inspector.click_again_to_use_the": "Click again to use the default colour",
+ "session.inspector.click_selects_the_triangle_launches": "Click selects · the triangle launches · Enter launches the selection\n←↑↓→ move · ⌘C ⌘V ⌘D · ⌫ delete · ⌘I insert scene\n⌘⇧C copy to arrangement · ⌘V pastes clips copied there",
+ "session.inspector.clips": { "one": "{0} clip", "other": "{0} clips" },
+ "session.inspector.color": "Color",
+ "session.inspector.empty_slot": "Empty slot",
+ "session.inspector.every_track_ends_up_here": "Every track ends up here. Its devices are in the Devices panel.",
+ "session.inspector.first": "First",
+ "session.inspector.follow_action": "Follow action",
+ "session.inspector.global": "Global",
+ "session.inspector.group_slot_tracks_caps": "GROUP SLOT · {0} TRACKS",
+ "session.inspector.insert_below": "Insert below",
+ "session.inspector.jump": "Jump",
+ "session.inspector.jump_to": "Jump to",
+ "session.inspector.last": "Last",
+ "session.inspector.launch_group_slot": "Launch group slot",
+ "session.inspector.launch_without_a_tempo_change": "Launch without a tempo change",
+ "session.inspector.launches_every_tracks_slot_in": "Launches every track's slot in this scene. The stop button stops them all.",
+ "session.inspector.launching_this_scene_keeps_playing": "Launching this scene keeps {0} playing.",
+ "session.inspector.launching_this_scene_stops": "Launching this scene stops {0}.",
+ "session.inspector.legato": "Legato",
+ "session.inspector.loop_end": "Loop end",
+ "session.inspector.next": "Next",
+ "session.inspector.next_after": "Next after {0}",
+ "session.inspector.next_n": "Next · {0}",
+ "session.inspector.off_globally": "Off globally",
+ "session.inspector.off_one_shot": "Off · one-shot",
+ "session.inspector.one_pass": "One pass",
+ "session.inspector.previous": "Previous",
+ "session.inspector.removed": "Removed",
+ "session.inspector.rename": "Rename",
+ "session.inspector.repeat": "Repeat",
+ "session.inspector.scene_caps": "SCENE {0:00} · {1}",
+ "session.inspector.select_next_scene_on_launch": "Select next scene on launch",
+ "session.inspector.signature": "Signature",
+ "session.inspector.stop_button": "Stop button",
+ "session.inspector.stop_group": "Stop group",
+ "session.inspector.stop_recording": "Stop recording",
+ "session.inspector.tempo": "Tempo",
+ "session.inspector.tempo_set_when_the_scene": "Tempo set when the scene launches · drag to change",
+ "session.inspector.to_arrangement": "To Arrangement",
+ "session.inspector.toggle": "Toggle",
+ "session.inspector.tracks_reach_it_through_their": "Tracks reach it through their sends. It has no clip slots; its devices are in the Devices panel.",
+ "session.inspector.trigger": "Trigger",
+ "session.inspector.trigger_starts_gate_plays_while": "Trigger starts · Gate plays while held · Toggle starts and stops · Repeat retriggers while held",
+ "session.inspector.velocity": "Velocity %",
+ "session.inspector.velocity_amount_how_far_the": "Velocity amount: how far the launch velocity scales the clip · drag",
+ "session.launch": "Launch",
+ "session.mixer.all_ins": "All ins",
+ "session.mixer.in_hear_the_input_live": "In: hear the input live through this track · Auto: only while recording",
+ "session.mixer.midi_input_every_input_or": "MIDI input: every input, or another instrument track",
+ "session.mixer.monitor": "Monitor",
+ "session.mixer.output_group_a_track_to": "Output — group a track to route it through the group",
+ "session.mixer.send": "Send",
+ "session.mixer.send_n": "Send {0} · {1}",
+ "session.moved_clip": "Moved clip",
+ "session.paste_a_midi_clip_onto": "Paste a MIDI clip onto a MIDI track, audio onto audio.",
+ "session.pasted_clip": "Pasted clip",
+ "session.pasted_clip_from_the_arrangement": "Pasted clip from the arrangement",
+ "session.pasted_clips_from_the_arrangement": "Pasted {0} clips from the arrangement",
+ "session.record_here": "Record here",
+ "session.recording": "Recording",
+ "session.scene": "Scene {0}",
+ "session.stop_every_session_clip": "Stop every session clip",
+ "session.the_slot_below_is_taken": "The slot below is taken.",
+ "session.toolbar.1_bar": "1 Bar",
+ "session.toolbar.2_bars": "2 Bars",
+ "session.toolbar.4_bars": "4 Bars",
+ "session.toolbar.8_bars": "8 Bars",
+ "session.toolbar.arm_a_track_with_an": "Arm a track with an empty slot in this scene to record.",
+ "session.toolbar.back_to_arrangement": "Back to Arrangement",
+ "session.toolbar.capture_scene": "Capture scene",
+ "session.toolbar.copy_the_clips_playing_now": "Copy the clips playing now into a new scene",
+ "session.toolbar.fixed": "Fixed",
+ "session.toolbar.fixed_record_length_in_bars": "Fixed record length in bars — the take stops by itself",
+ "session.toolbar.follow": "Follow",
+ "session.toolbar.follow_actions_on_or_off": "Follow actions on or off for every clip and scene",
+ "session.toolbar.hide": "Hide",
+ "session.toolbar.inspector": "Inspector",
+ "session.toolbar.inspector_show_or_hide_it": "Inspector — show or hide it",
+ "session.toolbar.launch_quantize_when_clips_and": "Launch quantize: when clips and scenes start",
+ "session.toolbar.more_session_controls": "More session controls",
+ "session.toolbar.quant": "Quant",
+ "session.toolbar.record_into_the_armed_track": "Record into the armed track at the selected scene · click again to keep the take",
+ "session.toolbar.session_rec": "Session rec",
+ "session.toolbar.stop_all": "Stop all",
+ "session.toolbar.stop_session_clips_and_hand": "Stop session clips and hand every track back to the Arrangement",
+ "session.toolbar.turn_follow_off": "Turn follow off",
+ "session.toolbar.turn_follow_on": "Turn follow on",
+ "snap_chip.1_2_narrow_widen_3": "⌘1 ⌘2 narrow / widen · ⌘3 triplets · ⌘4 snap · ⌘5 auto",
+ "snap_chip.auto": "Auto · {0}",
+ "snap_chip.auto_grid": "Auto grid",
+ "snap_chip.finer_than_the_visible_grid": "{0} — finer than the visible grid · zoom in to see it",
+ "snap_chip.hold_to_drag_freely": "{0}\n{1} · hold ⌥ to drag freely",
+ "snap_chip.snap_grid_auto_follows_the": "Snap grid · Auto follows the zoom ({0})",
+ "snap_chip.snap_grid_fixed": "Snap grid · fixed {0}",
+ "snap_chip.snap_off_items_move_freely": "Snap off — items move freely (⌘4)",
+ "snap_chip.snap_to_grid": "Snap to grid",
+ "snap_chip.triplets": "Triplets",
+ "stereo_map.balance": "Balance",
+ "stereo_map.below_60_dbfs_so_the": "Below −60 dBFS, so the cloud is hidden.",
+ "stereo_map.correlation": "Correlation",
+ "stereo_map.drag_pan_volume_shift_locks": "Drag: pan + volume · Shift locks axis · double-click centres pan · ⌥-click types",
+ "stereo_map.image_is_off_the_pan": "Image is off the pan",
+ "stereo_map.level": "Level",
+ "stereo_map.muted": "Muted",
+ "stereo_map.no_cloud_while_the_track": "No cloud while the track is muted.",
+ "stereo_map.silent": "Silent",
+ "stereo_map.the_pan_is_at_but": "The pan is at {0}, but the signal measures {1}. The source itself is unbalanced.",
+ "stereo_map.width": "Width",
+ "tag_editor.add_tag": "Add tag",
+ "tag_editor.edit_tags": "Edit tags",
+ "tag_editor.new_tag": "New tag",
+ "tag_editor.no_tags_yet_add_one": "No tags yet — add one below.",
+ "tag_editor.tags_title_colour": "Tags — title & colour",
+ "text_prompt.ok_caps": "OK",
+ "track_arming.arm_for_recording_click_to": "Arm for recording · ⌘-click to arm several tracks · ⌥-click to arm one track of a linked group",
+ "track_inspector.arm": "Arm",
+ "track_inspector.audio_track": "Audio track",
+ "track_inspector.color": "Color",
+ "track_inspector.every_track_ends_up_here": "Every track ends up here. Its devices are in the Devices panel.",
+ "track_inspector.hear_the_input_live_through": "Hear the input live through this track",
+ "track_inspector.height": "Height",
+ "track_inspector.large": "Large",
+ "track_inspector.master_cant_be_monitored_it": "Master can't be monitored (it would feed back)",
+ "track_inspector.midi_from": "MIDI from",
+ "track_inspector.midi_track": "MIDI track",
+ "track_inspector.monitor_input": "Monitor input",
+ "track_inspector.mute_the_track": "Mute the track",
+ "track_inspector.name": "Name",
+ "track_inspector.no_track_selected": "No track selected",
+ "track_inspector.play_another_instrument_tracks_midi": "Play another instrument track's MIDI through this track's instrument",
+ "track_inspector.solo_the_track": "Solo the track",
+ "track_inspector.standard": "Standard",
+ "track_inspector.the_colour_the_tracks_position": "The colour the track's position gives it",
+ "track_names.inst": "Inst {0}",
+ "transport.bars": "bars",
+ "transport.cant_record_arm_a_track": "Can't record: arm a track first (click Arm on a track header).",
+ "transport.cant_record_no_audio_input": "Can't record: no audio input — grant microphone access (needs a bundled app).",
+ "transport.count_in": "count-in",
+ "transport.paused_play_carries_on_from": "Paused · Play carries on from here",
+ "transport.recording_didnt_start": "Recording didn't start.",
+ "transport.time": "time",
+ "update.app_updater.couldnt_download_the_update": "Couldn't download the update: {0}",
+ "update.app_updater.couldnt_prepare_the_update": "Couldn't prepare the update ({0}: {1}).",
+ "update.app_updater.couldnt_start": "Couldn't start {0}.",
+ "update.app_updater.nota_has_no_download_for": "Nota {0} has no download for this computer.",
+ "update.app_updater.preparing_the_update": "Preparing the update…",
+ "update.app_updater.the_downloaded_nota_app_isnt": "The downloaded Nota.app isn't the expected version — not installing it.",
+ "update.app_updater.the_update_disk_image_doesnt": "The update disk image doesn't contain Nota.app.",
+ "update.app_updater.the_update_download_is_damaged": "The update download is damaged (checksum mismatch) — not installing it.",
+ "update.app_updater.the_update_download_is_larger": "The update download is larger than expected — not installing it.",
+ "update.app_updater.this_copy_of_nota_cant": "This copy of Nota can't update itself — download the new version from the release page.",
+ "update.app_updater.timed_out": "{0} timed out.",
+ "version_summary.added": "Added {0}",
+ "version_summary.devices_on": "Devices on {0}",
+ "version_summary.edited": "Edited {0}",
+ "version_summary.first_save": "First save",
+ "version_summary.first_save_tracks": { "one": "First save · {0} track", "other": "First save · {0} tracks" },
+ "version_summary.mix_of": "Mix of {0}",
+ "version_summary.mix_of_tracks": { "one": "Mix of {0} track", "other": "Mix of {0} tracks" },
+ "version_summary.new_audio": "New audio",
+ "version_summary.new_audio_files": "{0} new audio files",
+ "version_summary.removed": "Removed {0}",
+ "version_summary.tempo": "Tempo {0} → {1}",
+ "welcome.a_new_version_of_nota": "A new version of Nota is available",
+ "welcome.dismiss": "Dismiss",
+ "welcome.later": "Later",
+ "welcome.no_recent_projects": "No recent projects",
+ "welcome.nota_is_out_you_have": "Nota {0} is out — you have {1}.",
+ "welcome.nota_is_ready_to_install": "Nota {0} is ready to install",
+ "welcome.open_project": "Open project…",
+ "welcome.opening": "Opening…",
+ "welcome.recent_projects": "Recent projects",
+ "welcome.recover": "Recover",
+ "welcome.release_notes": "Release notes",
+ "welcome.restart_nota_to_finish_updating": "Restart Nota to finish updating — or it installs the next time you quit.",
+ "welcome.restart_now": "Restart now",
+ "welcome.show_on_startup": "Show on startup",
+ "welcome.the_update_didnt_download": "The update didn't download",
+ "welcome.unsaved_work_available": "Unsaved work available",
+ "welcome.version_engine_desktop_daw": "Version {0} · Engine {1} · Desktop DAW",
+ "welcome.welcome_to_nota": "Welcome to Nota",
+ "welcome.whats_new": "What's New",
+ "whats_new.all_changes": "All changes",
+ "whats_new.got_it": "Got it",
+ "whats_new.no_release_notes_available": "No release notes available.",
+ "whats_new.nota": "Nota {0}",
+ "whats_new.whats_new_in_nota": "What's new in Nota"
+ }
+}
diff --git a/src/managed/Nota.Application/Midi/MidiGenerators.cs b/src/managed/Nota.Application/Midi/MidiGenerators.cs
index 680b14fc..c4778bb0 100644
--- a/src/managed/Nota.Application/Midi/MidiGenerators.cs
+++ b/src/managed/Nota.Application/Midi/MidiGenerators.cs
@@ -16,18 +16,18 @@ public static class MidiGenerators
// -------------------------------------------------------------------- Rhythm
public static MidiTool Rhythm { get; } = new(
- "rhythm", Loc.T("Rhythm"), MidiToolKind.Generate,
- Loc.T("Lays down a pattern that leans on the strong beats, as densely as you ask."),
+ "rhythm", Loc.T("midi.generators.rhythm"), MidiToolKind.Generate,
+ Loc.T("midi.generators.lays_down_a_pattern_that"),
new[]
{
- MidiToolParam.Rate("rate", Loc.T("Rate")),
- MidiToolParam.Int("steps", Loc.T("Pattern"), 1, 32, 16, " st"),
- MidiToolParam.Percent("density", Loc.T("Density"), 0.5),
- MidiToolParam.Percent("variation", Loc.T("Variation"), 0.15),
- MidiToolParam.Note("pitch", Loc.T("Pitch"), 36),
- MidiToolParam.Float("gate", Loc.T("Gate"), 0.05, 2.0, 0.5, "×"),
- MidiToolParam.Percent("accent", Loc.T("Accent"), 0.45),
- MidiToolParam.Percent("velocity", Loc.T("Velocity"), 0.85),
+ MidiToolParam.Rate("rate", Loc.T("midi.rate")),
+ MidiToolParam.Int("steps", Loc.T("common.pattern"), 1, 32, 16, " st"),
+ MidiToolParam.Percent("density", Loc.T("midi.generators.density"), 0.5),
+ MidiToolParam.Percent("variation", Loc.T("midi.generators.variation"), 0.15),
+ MidiToolParam.Note("pitch", Loc.T("common.pitch"), 36),
+ MidiToolParam.Float("gate", Loc.T("common.gate"), 0.05, 2.0, 0.5, "×"),
+ MidiToolParam.Percent("accent", Loc.T("midi.accent"), 0.45),
+ MidiToolParam.Percent("velocity", Loc.T("common.velocity"), 0.85),
},
RunRhythm);
@@ -88,16 +88,16 @@ public static class MidiGenerators
// ---------------------------------------------------------------------- Seed
public static MidiTool Seed { get; } = new(
- "seed", Loc.T("Seed"), MidiToolKind.Generate,
- Loc.T("Learns the clip's intervals and rhythm, then writes a new take in the same voice."),
+ "seed", Loc.T("midi.generators.seed"), MidiToolKind.Generate,
+ Loc.T("midi.generators.learns_the_clips_intervals_and"),
new[]
{
- MidiToolParam.Percent("pitchvar", Loc.T("Pitch Var"), 0.5),
- MidiToolParam.Percent("rhythmvar", Loc.T("Rhythm Var"), 0.4),
- MidiToolParam.Float("density", Loc.T("Density"), 0.25, 2.5, 1.0, "×"),
- MidiToolParam.Int("range", Loc.T("Range"), 0, 24, 12, " st"),
- MidiToolParam.Toggle("scale", Loc.T("In Scale"), true),
- MidiToolParam.Percent("velocity", Loc.T("Vel Var"), 0.2),
+ MidiToolParam.Percent("pitchvar", Loc.T("midi.generators.pitch_var"), 0.5),
+ MidiToolParam.Percent("rhythmvar", Loc.T("midi.generators.rhythm_var"), 0.4),
+ MidiToolParam.Float("density", Loc.T("midi.generators.density"), 0.25, 2.5, 1.0, "×"),
+ MidiToolParam.Int("range", Loc.T("common.range"), 0, 24, 12, " st"),
+ MidiToolParam.Toggle("scale", Loc.T("midi.in_scale"), true),
+ MidiToolParam.Percent("velocity", Loc.T("midi.generators.vel_var"), 0.2),
},
RunSeed);
@@ -169,20 +169,20 @@ public static class MidiGenerators
// -------------------------------------------------------------------- Stacks
- private static readonly string[] StackIntervals = { "3rds", "4ths", "5ths", Loc.T("Octaves"), Loc.T("Cluster") };
- private static readonly string[] StackVoicings = { Loc.T("Close"), Loc.T("Open"), Loc.T("Drop 2"), Loc.T("Spread"), Loc.T("Power") };
+ private static readonly string[] StackIntervals = { "3rds", "4ths", "5ths", Loc.T("midi.octaves"), Loc.T("midi.generators.cluster") };
+ private static readonly string[] StackVoicings = { Loc.T("common.close"), Loc.T("common.open"), Loc.T("midi.generators.drop_2"), Loc.T("midi.generators.spread"), Loc.T("midi.generators.power") };
public static MidiTool Stacks { get; } = new(
- "stacks", Loc.T("Stacks"), MidiToolKind.Generate,
- Loc.T("Grows every note into a chord, voiced the way you would play it."),
+ "stacks", Loc.T("midi.generators.stacks"), MidiToolKind.Generate,
+ Loc.T("midi.generators.grows_every_note_into_a"),
new[]
{
- MidiToolParam.Int("voices", Loc.T("Voices"), 1, 5, 2),
- MidiToolParam.Choice("interval", Loc.T("Interval"), StackIntervals, 0),
- MidiToolParam.Choice("voicing", Loc.T("Voicing"), StackVoicings, 0),
- MidiToolParam.Int("spread", Loc.T("Spread"), 0, 3, 0, " oct"),
- MidiToolParam.Float("falloff", Loc.T("Vel Falloff"), 0, 1, 0.15, "×"),
- MidiToolParam.Toggle("scale", Loc.T("In Scale"), true),
+ MidiToolParam.Int("voices", Loc.T("midi.generators.voices"), 1, 5, 2),
+ MidiToolParam.Choice("interval", Loc.T("midi.interval"), StackIntervals, 0),
+ MidiToolParam.Choice("voicing", Loc.T("midi.generators.voicing"), StackVoicings, 0),
+ MidiToolParam.Int("spread", Loc.T("midi.generators.spread"), 0, 3, 0, " oct"),
+ MidiToolParam.Float("falloff", Loc.T("midi.generators.vel_falloff"), 0, 1, 0.15, "×"),
+ MidiToolParam.Toggle("scale", Loc.T("midi.in_scale"), true),
},
RunStacks);
@@ -246,19 +246,19 @@ public static class MidiGenerators
// ----------------------------------------------------------------- Euclidean
public static MidiTool Euclidean { get; } = new(
- "euclidean", Loc.T("Euclidean"), MidiToolKind.Generate,
- Loc.T("Spreads a number of hits as evenly as a number of steps allows."),
+ "euclidean", Loc.T("midi.generators.euclidean"), MidiToolKind.Generate,
+ Loc.T("midi.generators.spreads_a_number_of_hits"),
new[]
{
- MidiToolParam.Int("steps", Loc.T("Steps"), 1, 32, 16),
- MidiToolParam.Int("pulses", Loc.T("Pulses"), 0, 32, 5),
- MidiToolParam.Int("rotation", Loc.T("Rotate"), -31, 31, 0),
- MidiToolParam.Rate("rate", Loc.T("Rate")),
- MidiToolParam.Note("pitch", Loc.T("Pitch"), 36),
- MidiToolParam.Float("gate", Loc.T("Gate"), 0.05, 2.0, 0.5, "×"),
- MidiToolParam.Percent("velocity", Loc.T("Velocity"), 0.85),
- MidiToolParam.Int("accents", Loc.T("Accents"), 0, 32, 0),
- MidiToolParam.Percent("accentvel", Loc.T("Accent Vel"), 1.0),
+ MidiToolParam.Int("steps", Loc.T("midi.steps"), 1, 32, 16),
+ MidiToolParam.Int("pulses", Loc.T("midi.generators.pulses"), 0, 32, 5),
+ MidiToolParam.Int("rotation", Loc.T("midi.rotate"), -31, 31, 0),
+ MidiToolParam.Rate("rate", Loc.T("midi.rate")),
+ MidiToolParam.Note("pitch", Loc.T("common.pitch"), 36),
+ MidiToolParam.Float("gate", Loc.T("common.gate"), 0.05, 2.0, 0.5, "×"),
+ MidiToolParam.Percent("velocity", Loc.T("common.velocity"), 0.85),
+ MidiToolParam.Int("accents", Loc.T("midi.generators.accents"), 0, 32, 0),
+ MidiToolParam.Percent("accentvel", Loc.T("midi.generators.accent_vel"), 1.0),
},
RunEuclidean);
@@ -292,22 +292,22 @@ public static class MidiGenerators
// ------------------------------------------------------------- Melodic Steps
private static readonly string[] Contours =
- { Loc.T("Up"), Loc.T("Down"), Loc.T("Arch"), Loc.T("Valley"), Loc.T("Zigzag"), Loc.T("Random Walk"), Loc.T("Random") };
+ { Loc.T("midi.up"), Loc.T("midi.down"), Loc.T("midi.generators.arch"), Loc.T("midi.generators.valley"), Loc.T("midi.generators.zigzag"), Loc.T("midi.generators.random_walk"), Loc.T("midi.random") };
public static MidiTool MelodicSteps { get; } = new(
- "melodicsteps", Loc.T("Melodic Steps"), MidiToolKind.Generate,
- Loc.T("A step sequencer in scale degrees — pick a contour and a span, get a line."),
+ "melodicsteps", Loc.T("midi.generators.melodic_steps"), MidiToolKind.Generate,
+ Loc.T("midi.generators.a_step_sequencer_in_scale"),
new[]
{
- MidiToolParam.Int("steps", Loc.T("Steps"), 1, 32, 8),
- MidiToolParam.Rate("rate", Loc.T("Rate"), 3),
- MidiToolParam.Choice("contour", Loc.T("Contour"), Contours, 2),
- MidiToolParam.Int("range", Loc.T("Range"), 1, 21, 7, " deg"),
- MidiToolParam.Note("root", Loc.T("Root"), 60),
- MidiToolParam.Percent("density", Loc.T("Density"), 0.85),
- MidiToolParam.Float("gate", Loc.T("Gate"), 0.05, 2.0, 0.9, "×"),
- MidiToolParam.Percent("velocity", Loc.T("Velocity"), 0.8),
- MidiToolParam.Percent("velvar", Loc.T("Vel Var"), 0.15),
+ MidiToolParam.Int("steps", Loc.T("midi.steps"), 1, 32, 8),
+ MidiToolParam.Rate("rate", Loc.T("midi.rate"), 3),
+ MidiToolParam.Choice("contour", Loc.T("midi.generators.contour"), Contours, 2),
+ MidiToolParam.Int("range", Loc.T("common.range"), 1, 21, 7, " deg"),
+ MidiToolParam.Note("root", Loc.T("midi.generators.root"), 60),
+ MidiToolParam.Percent("density", Loc.T("midi.generators.density"), 0.85),
+ MidiToolParam.Float("gate", Loc.T("common.gate"), 0.05, 2.0, 0.9, "×"),
+ MidiToolParam.Percent("velocity", Loc.T("common.velocity"), 0.8),
+ MidiToolParam.Percent("velvar", Loc.T("midi.generators.vel_var"), 0.15),
},
RunMelodicSteps);
@@ -357,23 +357,23 @@ public static class MidiGenerators
// --------------------------------------------------------------------- Shape
private static readonly string[] Shapes =
- { Loc.T("Ramp Up"), Loc.T("Ramp Down"), Loc.T("Sine"), Loc.T("Triangle"), Loc.T("Exponential"), Loc.T("Logarithmic"), Loc.T("S-Curve"), Loc.T("Square"), Loc.T("Random Walk") };
+ { Loc.T("midi.ramp_up"), Loc.T("midi.ramp_down"), Loc.T("midi.sine"), Loc.T("midi.triangle"), Loc.T("midi.generators.exponential"), Loc.T("midi.generators.logarithmic"), Loc.T("midi.s_curve"), Loc.T("midi.generators.square"), Loc.T("midi.generators.random_walk") };
public static MidiTool Shape { get; } = new(
- "shape", Loc.T("Shape"), MidiToolKind.Generate,
- Loc.T("Traces a curve across the clip and drops a note wherever it passes a step."),
+ "shape", Loc.T("midi.shape"), MidiToolKind.Generate,
+ Loc.T("midi.generators.traces_a_curve_across_the"),
new[]
{
- MidiToolParam.Choice("shape", Loc.T("Shape"), Shapes, 2),
- MidiToolParam.Rate("rate", Loc.T("Rate"), 4),
- MidiToolParam.Int("range", Loc.T("Range"), 1, 36, 12, " st"),
- MidiToolParam.Note("root", Loc.T("Root"), 60),
- MidiToolParam.Float("cycles", Loc.T("Cycles"), 0.25, 8, 1, "×"),
- MidiToolParam.Float("phase", Loc.T("Phase"), 0, 1, 0, ""),
- MidiToolParam.Float("gate", Loc.T("Gate"), 0.05, 2.0, 0.9, "×"),
- MidiToolParam.Percent("velocity", Loc.T("Velocity"), 0.8),
- MidiToolParam.Toggle("velfollow", Loc.T("Vel Follows"), false),
- MidiToolParam.Toggle("scale", Loc.T("In Scale"), true),
+ MidiToolParam.Choice("shape", Loc.T("midi.shape"), Shapes, 2),
+ MidiToolParam.Rate("rate", Loc.T("midi.rate"), 4),
+ MidiToolParam.Int("range", Loc.T("common.range"), 1, 36, 12, " st"),
+ MidiToolParam.Note("root", Loc.T("midi.generators.root"), 60),
+ MidiToolParam.Float("cycles", Loc.T("midi.cycles"), 0.25, 8, 1, "×"),
+ MidiToolParam.Float("phase", Loc.T("midi.phase"), 0, 1, 0, ""),
+ MidiToolParam.Float("gate", Loc.T("common.gate"), 0.05, 2.0, 0.9, "×"),
+ MidiToolParam.Percent("velocity", Loc.T("common.velocity"), 0.8),
+ MidiToolParam.Toggle("velfollow", Loc.T("midi.generators.vel_follows"), false),
+ MidiToolParam.Toggle("scale", Loc.T("midi.in_scale"), true),
},
RunShape);
diff --git a/src/managed/Nota.Application/Midi/MidiTool.cs b/src/managed/Nota.Application/Midi/MidiTool.cs
index 84c2490d..ef781f40 100644
--- a/src/managed/Nota.Application/Midi/MidiTool.cs
+++ b/src/managed/Nota.Application/Midi/MidiTool.cs
@@ -59,7 +59,7 @@ public sealed record MidiToolParam(
public string Display(double v) => Kind switch
{
- MidiParamKind.Toggle => v >= 0.5 ? Loc.T("On") : Loc.T("Off"),
+ MidiParamKind.Toggle => v >= 0.5 ? Loc.T("midi.tool.on") : Loc.T("common.off"),
MidiParamKind.Choice => Choices is { Length: > 0 }
? Choices[Math.Clamp((int)Math.Round(v), 0, Choices.Length - 1)]
: "",
diff --git a/src/managed/Nota.Application/Midi/MidiTransforms.cs b/src/managed/Nota.Application/Midi/MidiTransforms.cs
index cc89f444..75c76054 100644
--- a/src/managed/Nota.Application/Midi/MidiTransforms.cs
+++ b/src/managed/Nota.Application/Midi/MidiTransforms.cs
@@ -15,19 +15,19 @@ public static class MidiTransforms
// ---------------------------------------------------------------- Arpeggiate
private static readonly string[] ArpStyles =
- { Loc.T("Up"), Loc.T("Down"), Loc.T("Up-Down"), Loc.T("Down-Up"), Loc.T("Converge"), Loc.T("Diverge"), Loc.T("Random"), Loc.T("Chord") };
+ { Loc.T("midi.up"), Loc.T("midi.down"), Loc.T("midi.transforms.up_down"), Loc.T("midi.transforms.down_up"), Loc.T("midi.transforms.converge"), Loc.T("midi.transforms.diverge"), Loc.T("midi.random"), Loc.T("midi.transforms.chord") };
public static MidiTool Arpeggiate { get; } = new(
- "arpeggiate", Loc.T("Arpeggiate"), MidiToolKind.Transform,
- Loc.T("Breaks chords into a running sequence."),
+ "arpeggiate", Loc.T("midi.transforms.arpeggiate"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.breaks_chords_into_a_running"),
new[]
{
- MidiToolParam.Rate("rate", Loc.T("Rate")),
- MidiToolParam.Choice("style", Loc.T("Style"), ArpStyles, 0),
- MidiToolParam.Int("octaves", Loc.T("Octaves"), 1, 4, 1),
- MidiToolParam.Float("gate", Loc.T("Gate"), 0.05, 2.0, 0.9, "×"),
- MidiToolParam.Int("distance", Loc.T("Distance"), -12, 12, 12, " st"),
- MidiToolParam.Float("decay", Loc.T("Vel Decay"), -1, 1, 0, "×"),
+ MidiToolParam.Rate("rate", Loc.T("midi.rate")),
+ MidiToolParam.Choice("style", Loc.T("midi.transforms.style"), ArpStyles, 0),
+ MidiToolParam.Int("octaves", Loc.T("midi.octaves"), 1, 4, 1),
+ MidiToolParam.Float("gate", Loc.T("common.gate"), 0.05, 2.0, 0.9, "×"),
+ MidiToolParam.Int("distance", Loc.T("midi.transforms.distance"), -12, 12, 12, " st"),
+ MidiToolParam.Float("decay", Loc.T("midi.transforms.vel_decay"), -1, 1, 0, "×"),
},
RunArpeggiate);
@@ -124,19 +124,19 @@ public static class MidiTransforms
// ------------------------------------------------------------------- Connect
- private static readonly string[] ConnectModes = { Loc.T("Chromatic"), Loc.T("In scale") };
+ private static readonly string[] ConnectModes = { Loc.T("midi.transforms.chromatic"), Loc.T("midi.transforms.in_scale") };
public static MidiTool Connect { get; } = new(
- "connect", Loc.T("Connect"), MidiToolKind.Transform,
- Loc.T("Fills the gaps between notes with runs that walk to the next pitch."),
+ "connect", Loc.T("midi.transforms.connect"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.fills_the_gaps_between_notes"),
new[]
{
- MidiToolParam.Rate("rate", Loc.T("Rate"), 5),
- MidiToolParam.Choice("mode", Loc.T("Steps"), ConnectModes, 1),
- MidiToolParam.Percent("fill", Loc.T("Fill"), 0.5),
- MidiToolParam.Float("gate", Loc.T("Gate"), 0.1, 1.5, 0.9, "×"),
- MidiToolParam.Float("velocity", Loc.T("Velocity"), 0.1, 1.5, 0.7, "×"),
- MidiToolParam.Int("maxsteps", Loc.T("Max Steps"), 1, 16, 4),
+ MidiToolParam.Rate("rate", Loc.T("midi.rate"), 5),
+ MidiToolParam.Choice("mode", Loc.T("midi.steps"), ConnectModes, 1),
+ MidiToolParam.Percent("fill", Loc.T("midi.transforms.fill"), 0.5),
+ MidiToolParam.Float("gate", Loc.T("common.gate"), 0.1, 1.5, 0.9, "×"),
+ MidiToolParam.Float("velocity", Loc.T("common.velocity"), 0.1, 1.5, 0.7, "×"),
+ MidiToolParam.Int("maxsteps", Loc.T("midi.transforms.max_steps"), 1, 16, 4),
},
RunConnect);
@@ -200,19 +200,19 @@ public static class MidiTransforms
// ------------------------------------------------------------------ Ornament
private static readonly string[] OrnamentTypes =
- { Loc.T("Grace"), Loc.T("Trill"), Loc.T("Mordent"), Loc.T("Turn"), Loc.T("Flam"), Loc.T("Roll") };
+ { Loc.T("midi.transforms.grace"), Loc.T("midi.transforms.trill"), Loc.T("midi.transforms.mordent"), Loc.T("midi.transforms.turn"), Loc.T("midi.transforms.flam"), Loc.T("midi.transforms.roll") };
public static MidiTool Ornament { get; } = new(
- "ornament", Loc.T("Ornament"), MidiToolKind.Transform,
- Loc.T("Decorates notes with grace notes, trills and rolls."),
+ "ornament", Loc.T("midi.transforms.ornament"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.decorates_notes_with_grace_notes"),
new[]
{
- MidiToolParam.Choice("type", Loc.T("Type"), OrnamentTypes, 0),
- MidiToolParam.Rate("rate", Loc.T("Rate"), 5),
- MidiToolParam.Percent("chance", Loc.T("Chance"), 1.0),
- MidiToolParam.Int("interval", Loc.T("Interval"), -4, 4, 1, " deg"),
- MidiToolParam.Float("velocity", Loc.T("Velocity"), 0.1, 1.5, 0.75, "×"),
- MidiToolParam.Toggle("scale", Loc.T("In Scale"), true),
+ MidiToolParam.Choice("type", Loc.T("midi.transforms.type"), OrnamentTypes, 0),
+ MidiToolParam.Rate("rate", Loc.T("midi.rate"), 5),
+ MidiToolParam.Percent("chance", Loc.T("midi.transforms.chance"), 1.0),
+ MidiToolParam.Int("interval", Loc.T("midi.interval"), -4, 4, 1, " deg"),
+ MidiToolParam.Float("velocity", Loc.T("common.velocity"), 0.1, 1.5, 0.75, "×"),
+ MidiToolParam.Toggle("scale", Loc.T("midi.in_scale"), true),
},
RunOrnament);
@@ -295,15 +295,15 @@ public static class MidiTransforms
// ------------------------------------------------------------------ Quantize
public static MidiTool Quantize { get; } = new(
- "quantize", Loc.T("Quantize"), MidiToolKind.Transform,
- Loc.T("Pulls notes onto the grid, with swing and a strength short of rigid."),
+ "quantize", Loc.T("common.quantize"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.pulls_notes_onto_the_grid"),
new[]
{
- MidiToolParam.Rate("rate", Loc.T("Grid")),
- MidiToolParam.Percent("amount", Loc.T("Amount"), 1.0),
- MidiToolParam.Float("swing", Loc.T("Swing"), -0.75, 0.75, 0, "×"),
- MidiToolParam.Toggle("ends", Loc.T("Quantize Ends"), false),
- MidiToolParam.Float("humanize", Loc.T("Humanize"), 0, 0.25, 0, " b"),
+ MidiToolParam.Rate("rate", Loc.T("common.grid")),
+ MidiToolParam.Percent("amount", Loc.T("midi.transforms.amount"), 1.0),
+ MidiToolParam.Float("swing", Loc.T("midi.transforms.swing"), -0.75, 0.75, 0, "×"),
+ MidiToolParam.Toggle("ends", Loc.T("midi.transforms.quantize_ends"), false),
+ MidiToolParam.Float("humanize", Loc.T("midi.transforms.humanize"), 0, 0.25, 0, " b"),
},
RunQuantize);
@@ -344,17 +344,17 @@ public static class MidiTransforms
// ----------------------------------------------------------------- Recombine
private static readonly string[] RecombineModes =
- { Loc.T("Shuffle Pitch"), Loc.T("Shuffle Rhythm"), Loc.T("Shuffle Both"), Loc.T("Rotate Pitch"), Loc.T("Reverse Pitch"), Loc.T("Mirror Pitch"), Loc.T("Reverse Time") };
+ { Loc.T("midi.transforms.shuffle_pitch"), Loc.T("midi.transforms.shuffle_rhythm"), Loc.T("midi.transforms.shuffle_both"), Loc.T("midi.transforms.rotate_pitch"), Loc.T("midi.transforms.reverse_pitch"), Loc.T("midi.transforms.mirror_pitch"), Loc.T("midi.transforms.reverse_time") };
public static MidiTool Recombine { get; } = new(
- "recombine", Loc.T("Recombine"), MidiToolKind.Transform,
- Loc.T("Pulls pitch and rhythm apart and puts them back together differently."),
+ "recombine", Loc.T("midi.transforms.recombine"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.pulls_pitch_and_rhythm_apart"),
new[]
{
- MidiToolParam.Choice("mode", Loc.T("Mode"), RecombineModes, 0),
- MidiToolParam.Percent("amount", Loc.T("Amount"), 0.6),
- MidiToolParam.Int("rotate", Loc.T("Rotate"), -16, 16, 1),
- MidiToolParam.Int("chunk", Loc.T("Chunk"), 1, 8, 1),
+ MidiToolParam.Choice("mode", Loc.T("midi.transforms.mode"), RecombineModes, 0),
+ MidiToolParam.Percent("amount", Loc.T("midi.transforms.amount"), 0.6),
+ MidiToolParam.Int("rotate", Loc.T("midi.rotate"), -16, 16, 1),
+ MidiToolParam.Int("chunk", Loc.T("midi.transforms.chunk"), 1, 8, 1),
},
RunRecombine);
@@ -454,18 +454,18 @@ public static class MidiTransforms
// ---------------------------------------------------------------------- Span
- private static readonly string[] SpanModes = { Loc.T("To Next Note"), Loc.T("Scale Length"), Loc.T("Fixed") };
+ private static readonly string[] SpanModes = { Loc.T("midi.transforms.to_next_note"), Loc.T("midi.transforms.scale_length"), Loc.T("midi.transforms.fixed") };
public static MidiTool Span { get; } = new(
- "span", Loc.T("Span"), MidiToolKind.Transform,
- Loc.T("Rewrites note lengths — from staccato through legato to overlapping."),
+ "span", Loc.T("midi.transforms.span"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.rewrites_note_lengths_from_staccato"),
new[]
{
- MidiToolParam.Choice("mode", Loc.T("Mode"), SpanModes, 0),
- MidiToolParam.Float("amount", Loc.T("Amount"), 0.05, 2.0, 1.0, "×"),
- MidiToolParam.Float("fixed", Loc.T("Length"), 0.03125, 8.0, 0.25, " b"),
- MidiToolParam.Float("min", Loc.T("Min"), 0.015625, 2.0, 0.0625, " b"),
- MidiToolParam.Toggle("perpitch", Loc.T("Per Pitch"), false),
+ MidiToolParam.Choice("mode", Loc.T("midi.transforms.mode"), SpanModes, 0),
+ MidiToolParam.Float("amount", Loc.T("midi.transforms.amount"), 0.05, 2.0, 1.0, "×"),
+ MidiToolParam.Float("fixed", Loc.T("common.length"), 0.03125, 8.0, 0.25, " b"),
+ MidiToolParam.Float("min", Loc.T("common.min"), 0.015625, 2.0, 0.0625, " b"),
+ MidiToolParam.Toggle("perpitch", Loc.T("midi.transforms.per_pitch"), false),
},
RunSpan);
@@ -506,18 +506,18 @@ public static class MidiTransforms
// --------------------------------------------------------------------- Strum
- private static readonly string[] StrumDirections = { Loc.T("Up"), Loc.T("Down"), Loc.T("Alternate"), Loc.T("Centre Out"), Loc.T("Random") };
+ private static readonly string[] StrumDirections = { Loc.T("midi.up"), Loc.T("midi.down"), Loc.T("midi.transforms.alternate"), Loc.T("midi.transforms.centre_out"), Loc.T("midi.random") };
public static MidiTool Strum { get; } = new(
- "strum", Loc.T("Strum"), MidiToolKind.Transform,
- Loc.T("Rolls the notes of a chord out in time instead of hitting them together."),
+ "strum", Loc.T("midi.transforms.strum"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.rolls_the_notes_of_a"),
new[]
{
- MidiToolParam.Float("amount", Loc.T("Amount"), 0, 1.0, 0.125, " b"),
- MidiToolParam.Choice("direction", Loc.T("Direction"), StrumDirections, 0),
- MidiToolParam.Float("tension", Loc.T("Tension"), -1, 1, 0, ""),
- MidiToolParam.Float("velslope", Loc.T("Vel Slope"), -1, 1, 0, ""),
- MidiToolParam.Toggle("keepend", Loc.T("Keep Ends"), true),
+ MidiToolParam.Float("amount", Loc.T("midi.transforms.amount"), 0, 1.0, 0.125, " b"),
+ MidiToolParam.Choice("direction", Loc.T("midi.transforms.direction"), StrumDirections, 0),
+ MidiToolParam.Float("tension", Loc.T("midi.transforms.tension"), -1, 1, 0, ""),
+ MidiToolParam.Float("velslope", Loc.T("midi.transforms.vel_slope"), -1, 1, 0, ""),
+ MidiToolParam.Toggle("keepend", Loc.T("midi.transforms.keep_ends"), true),
},
RunStrum);
@@ -561,18 +561,18 @@ public static class MidiTransforms
// ----------------------------------------------------------------- Time Warp
- private static readonly string[] WarpShapes = { Loc.T("Curve"), Loc.T("S-Curve"), Loc.T("Sine"), Loc.T("Swing"), Loc.T("Snap to Grid") };
+ private static readonly string[] WarpShapes = { Loc.T("midi.transforms.curve"), Loc.T("midi.s_curve"), Loc.T("midi.sine"), Loc.T("midi.transforms.swing"), Loc.T("midi.transforms.snap_to_grid") };
public static MidiTool TimeWarp { get; } = new(
- "timewarp", Loc.T("Time Warp"), MidiToolKind.Transform,
- Loc.T("Bends the time axis so a phrase accelerates, drags or breathes."),
+ "timewarp", Loc.T("midi.transforms.time_warp"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.bends_the_time_axis_so"),
new[]
{
- MidiToolParam.Choice("shape", Loc.T("Shape"), WarpShapes, 0),
- MidiToolParam.Float("curve", Loc.T("Curve"), -1, 1, 0.4, ""),
- MidiToolParam.Percent("amount", Loc.T("Amount"), 1.0),
- MidiToolParam.Int("cycles", Loc.T("Cycles"), 1, 8, 1),
- MidiToolParam.Toggle("lengths", Loc.T("Warp Lengths"), true),
+ MidiToolParam.Choice("shape", Loc.T("midi.shape"), WarpShapes, 0),
+ MidiToolParam.Float("curve", Loc.T("midi.transforms.curve"), -1, 1, 0.4, ""),
+ MidiToolParam.Percent("amount", Loc.T("midi.transforms.amount"), 1.0),
+ MidiToolParam.Int("cycles", Loc.T("midi.cycles"), 1, 8, 1),
+ MidiToolParam.Toggle("lengths", Loc.T("midi.transforms.warp_lengths"), true),
},
RunTimeWarp);
@@ -637,20 +637,20 @@ public static class MidiTransforms
// ----------------------------------------------------------- Velocity Shaper
private static readonly string[] VelShapes =
- { Loc.T("Ramp Up"), Loc.T("Ramp Down"), Loc.T("Sine"), Loc.T("Triangle"), Loc.T("Random"), Loc.T("Accent"), Loc.T("Flatten") };
+ { Loc.T("midi.ramp_up"), Loc.T("midi.ramp_down"), Loc.T("midi.sine"), Loc.T("midi.triangle"), Loc.T("midi.random"), Loc.T("midi.accent"), Loc.T("midi.transforms.flatten") };
public static MidiTool VelocityShaper { get; } = new(
- "velshaper", Loc.T("Velocity Shaper"), MidiToolKind.Transform,
- Loc.T("Draws a curve through the velocities instead of editing them one by one."),
+ "velshaper", Loc.T("midi.transforms.velocity_shaper"), MidiToolKind.Transform,
+ Loc.T("midi.transforms.draws_a_curve_through_the"),
new[]
{
- MidiToolParam.Choice("shape", Loc.T("Shape"), VelShapes, 2),
- MidiToolParam.Rate("period", Loc.T("Period"), 0),
- MidiToolParam.Percent("depth", Loc.T("Depth"), 0.35),
- MidiToolParam.Percent("centre", Loc.T("Centre"), 0.7),
- MidiToolParam.Float("phase", Loc.T("Phase"), 0, 1, 0, ""),
- MidiToolParam.Percent("random", Loc.T("Random"), 0),
- MidiToolParam.Percent("blend", Loc.T("Blend"), 1.0),
+ MidiToolParam.Choice("shape", Loc.T("midi.shape"), VelShapes, 2),
+ MidiToolParam.Rate("period", Loc.T("midi.transforms.period"), 0),
+ MidiToolParam.Percent("depth", Loc.T("midi.transforms.depth"), 0.35),
+ MidiToolParam.Percent("centre", Loc.T("midi.transforms.centre"), 0.7),
+ MidiToolParam.Float("phase", Loc.T("midi.phase"), 0, 1, 0, ""),
+ MidiToolParam.Percent("random", Loc.T("midi.random"), 0),
+ MidiToolParam.Percent("blend", Loc.T("midi.transforms.blend"), 1.0),
},
RunVelocityShaper);
diff --git a/src/managed/Nota.Application/Nota.Application.csproj b/src/managed/Nota.Application/Nota.Application.csproj
index 43ad3a78..7aaf1ab3 100644
--- a/src/managed/Nota.Application/Nota.Application.csproj
+++ b/src/managed/Nota.Application/Nota.Application.csproj
@@ -13,4 +13,10 @@
<ProjectReference Include="..\Nota.Domain\Nota.Domain.csproj" />
</ItemGroup>
+ <ItemGroup>
+ <!-- The English reference (spec 077): every interface text by key. Embedded beside Loc so
+ English is there before a language is installed and in every project using Loc. -->
+ <EmbeddedResource Include="Localization\en.json" LogicalName="Nota.Localization.en.json" />
+ </ItemGroup>
+
</Project>
diff --git a/src/managed/Nota.Application/Palette/BuiltinDeviceCatalog.cs b/src/managed/Nota.Application/Palette/BuiltinDeviceCatalog.cs
index 78311411..0680a1d0 100644
--- a/src/managed/Nota.Application/Palette/BuiltinDeviceCatalog.cs
+++ b/src/managed/Nota.Application/Palette/BuiltinDeviceCatalog.cs
@@ -44,162 +44,162 @@ public static class BuiltinDeviceCatalog
public static IReadOnlyList<BuiltinDevice> All { get; } = new BuiltinDevice[]
{
// ---- instruments ----------------------------------------------------------------------
- new("Nota Physical", I, 2, Loc.T("physical synth"), D("synth.physical", "modal karplus string mallet",
+ new("Nota Physical", I, 2, Loc.T("palette.devices.physical_synth"), D("synth.physical", "modal karplus string mallet",
"metallic glassy", "pluck bell keys strings perc", "", "", "cinematic",
- Loc.T("Physical modelling of struck, plucked and blown bodies."))),
- new("Nota Aurora", I, 5, Loc.T("wavetable synth"), D("synth.wavetable", "wt serum",
+ Loc.T("palette.devices.physical_modelling_of_struck_plucked"))),
+ new("Nota Aurora", I, 5, Loc.T("palette.devices.wavetable_synth"), D("synth.wavetable", "wt serum",
"bright airy evolving lush", "pad lead texture", "", "", "edm cinematic",
- Loc.T("Wavetable synth with warping oscillators — evolving pads and modern leads."))),
+ Loc.T("palette.devices.wavetable_synth_with_warping_oscillators"))),
// Nota Synth (kind 0) and Nota Bass (kind 7) folded into Volt (specs/026): their engines
// still load saved tracks, but new ones are Volts, so they are not offered here.
- new("Nota Volt", I, 6, Loc.T("analog synth"), D("synth.subtractive", "moog analog poly va init basic supersaw 303 acid tb",
+ new("Nota Volt", I, 6, Loc.T("palette.devices.analog_synth"), D("synth.subtractive", "moog analog poly va init basic supersaw 303 acid tb",
"warm vintage clean bright gritty", "pad bass lead keys pluck", "", "", "synthwave techno acid house",
- Loc.T("Two-oscillator analog-style synth with drive and a unison stack — pads, basses, acid lines and leads."))),
- new("Nota Pendulum", I, 8, Loc.T("arp synth"), D("synth", "arpsynth sequencer",
+ Loc.T("palette.devices.two_oscillator_analog_style_synth"))),
+ new("Nota Pendulum", I, 8, Loc.T("palette.devices.arp_synth"), D("synth", "arpsynth sequencer",
"evolving bright", "seq pluck", "", "", "synthwave techno",
- Loc.T("A synth with a built-in pattern engine for arpeggios and sequences."))),
- new("Nota Operator", I, 9, Loc.T("FM synth"), D("synth.fm", "dx7 operator fm",
+ Loc.T("palette.devices.a_synth_with_a_built"))),
+ new("Nota Operator", I, 9, Loc.T("palette.devices.fm_synth"), D("synth.fm", "dx7 operator fm",
"bright metallic glassy", "bell keys bass pluck", "", "", "",
- Loc.T("FM synthesis — bells, electric pianos and hard basses."))),
- new("Nota Grain", I, 10, Loc.T("granular synth"), D("synth.granular", "granulator cloud",
+ Loc.T("palette.devices.fm_synthesis_bells_electric_pianos"))),
+ new("Nota Grain", I, 10, Loc.T("palette.devices.granular_synth"), D("synth.granular", "granulator cloud",
"airy evolving", "texture drone pad", "", "", "ambient cinematic",
- Loc.T("Granular synth that turns a sample into clouds, textures and drones."))),
- new("Nota Flux", I, 11, Loc.T("vector-morph synth"), D("synth.vector", "wavestation morph",
+ Loc.T("palette.devices.granular_synth_that_turns_a"))),
+ new("Nota Flux", I, 11, Loc.T("palette.devices.vector_morph_synth"), D("synth.vector", "wavestation morph",
"evolving lush", "pad texture", "", "", "ambient",
- Loc.T("Vector synth morphing between sources — moving pads and textures."))),
- new("Nota Rhythm", I, 12, Loc.T("drum machine"), D("drum", "808 909 drummachine groovebox",
+ Loc.T("palette.devices.vector_synth_morphing_between_sources"))),
+ new("Nota Rhythm", I, 12, Loc.T("palette.devices.drum_machine"), D("drum", "808 909 drummachine groovebox",
"punchy", "perc", "drums", "", "trap house techno hiphop",
- Loc.T("Eight-voice drum machine with a step sequencer."))),
- new("Nota Monolith", I, 13, Loc.T("mono synth"), D("synth.subtractive", "minimoog monosynth",
+ Loc.T("palette.devices.eight_voice_drum_machine_with"))),
+ new("Nota Monolith", I, 13, Loc.T("palette.devices.mono_synth"), D("synth.subtractive", "minimoog monosynth",
"warm aggressive deep", "bass lead", "", "", "",
- Loc.T("Monophonic analog-style synth for fat basses and leads."))),
- new("Nota Pentad", I, 14, Loc.T("poly synth"), D("synth.subtractive", "prophet poly",
+ Loc.T("palette.devices.monophonic_analog_style_synth_for"))),
+ new("Nota Pentad", I, 14, Loc.T("palette.devices.poly_synth"), D("synth.subtractive", "prophet poly",
"warm lush vintage", "pad keys lead brass", "", "", "synthwave",
- Loc.T("Five-voice vintage polysynth — lush pads, brass and keys."))),
- new("Nota Consort", I, 15, Loc.T("paraphonic synth"), D("synth.subtractive", "paraphonic string-machine",
+ Loc.T("palette.devices.five_voice_vintage_polysynth_lush"))),
+ new("Nota Consort", I, 15, Loc.T("palette.devices.paraphonic_synth"), D("synth.subtractive", "paraphonic string-machine",
"lush vintage warm", "strings pad choir", "", "", "synthwave",
- Loc.T("Paraphonic ensemble synth — string machines and choirs."))),
- new("Nota Keys", I, 16, Loc.T("electric piano"), D("synth.physical", "epiano e-piano rhodes wurlitzer wurli clavinet clav tine reed suitcase",
+ Loc.T("palette.devices.paraphonic_ensemble_synth_string_machines"))),
+ new("Nota Keys", I, 16, Loc.T("palette.devices.electric_piano"), D("synth.physical", "epiano e-piano rhodes wurlitzer wurli clavinet clav tine reed suitcase",
"warm vintage", "keys", "", "", "jazz funk",
- Loc.T("Modelled electric piano — tine, suitcase, reed and clav with tremolo, phaser and cabinet."))),
- new("Nota Mosaic", I, 17, Loc.T("multisample"), D("sampler", "multisample multisampler sfz soundfont piano grand acoustic orchestral orchestra zones velocity round-robin мультисэмпл пианино рояль",
+ Loc.T("palette.devices.modelled_electric_piano_tine_suitcase"))),
+ new("Nota Mosaic", I, 17, Loc.T("palette.devices.multisample"), D("sampler", "multisample multisampler sfz soundfont piano grand acoustic orchestral orchestra zones velocity round-robin мультисэмпл пианино рояль",
"", "keys strings brass choir", "", "", "cinematic",
- Loc.T("Multisample instrument — zones by key and velocity, round-robin and release samples; SFZ import and packs."))),
- new("Nota Sampler", I, 1, Loc.T("built-in"), D("sampler", "simpler oneshot",
+ Loc.T("palette.devices.multisample_instrument_zones_by_key"))),
+ new("Nota Sampler", I, 1, Loc.T("palette.devices.built_in"), D("sampler", "simpler oneshot",
"", "keys perc", "", "", "",
- Loc.T("Plays a sample across the keyboard."))),
- new("Nota Instrument Rack", I, 3, Loc.T("built-in"), D("rack", "layer split instrumentrack",
+ Loc.T("palette.devices.plays_a_sample_across_the"))),
+ new("Nota Instrument Rack", I, 3, Loc.T("palette.devices.built_in"), D("rack", "layer split instrumentrack",
"", "", "", "", "",
- Loc.T("Layers several instruments in parallel chains."))),
- new("Nota Drum Rack", I, 4, Loc.T("built-in"), D("drum", "drumrack pads kit",
+ Loc.T("palette.devices.layers_several_instruments_in_parallel"))),
+ new("Nota Drum Rack", I, 4, Loc.T("palette.devices.built_in"), D("drum", "drumrack pads kit",
"punchy", "perc", "drums", "", "trap hiphop house",
- Loc.T("Sixteen pads, each with its own sample or instrument chain."))),
+ Loc.T("palette.devices.sixteen_pads_each_with_its"))),
// ---- audio effects ------------------------------------------------------------------
- new("Nota EQ-3", A, 16, Loc.T("3-band EQ"), D("eq", "dj eq3 threeband",
+ new("Nota EQ-3", A, 16, Loc.T("palette.devices.3_band_eq"), D("eq", "dj eq3 threeband",
"", "", "master bus", "", "house techno",
- Loc.T("Three-band DJ-style EQ with kills."))),
- new("Nota EQ-8", A, 0, Loc.T("8-band EQ"), D("eq", "parametric eq8 proq",
+ Loc.T("palette.devices.three_band_dj_style_eq"))),
+ new("Nota EQ-8", A, 0, Loc.T("palette.devices.8_band_eq"), D("eq", "parametric eq8 proq",
"clean", "", "vocals master bus drums", "repair", "",
- Loc.T("Eight-band parametric EQ with a live spectrum."))),
- new("Nota Compressor", A, 1, Loc.T("built-in"), D("compressor", "comp vca opto",
+ Loc.T("palette.devices.eight_band_parametric_eq_with"))),
+ new("Nota Compressor", A, 1, Loc.T("palette.devices.built_in"), D("compressor", "comp vca opto",
"punchy", "", "drums vocals bus bass", "glue sidechain parallel", "",
- Loc.T("Compressor with sidechain and five characters — glue, punch and pumping."))),
- new("Nota Prism", A, 21, Loc.T("multiband dynamics"), D("multiband", "ott upward multibandcompressor",
+ Loc.T("palette.devices.compressor_with_sidechain_and_five"))),
+ new("Nota Prism", A, 21, Loc.T("palette.devices.multiband_dynamics"), D("multiband", "ott upward multibandcompressor",
"bright aggressive", "", "master bus", "loudness", "edm dubstep",
- Loc.T("Three-band upward and downward compression — OTT-style density."))),
- new("Nota Lens", A, 22, Loc.T("analyzer / scope"), D("analyzer", "oscilloscope spectrum meter",
+ Loc.T("palette.devices.three_band_upward_and_downward"))),
+ new("Nota Lens", A, 22, Loc.T("palette.devices.analyzer_scope"), D("analyzer", "oscilloscope spectrum meter",
"", "", "master", "", "",
- Loc.T("Spectrum analyser, oscilloscope and level meter."))),
- new("Nota Reverb", A, 2, Loc.T("built-in"), D("reverb", "verb hall room plate",
+ Loc.T("palette.devices.spectrum_analyser_oscilloscope_and_level"))),
+ new("Nota Reverb", A, 2, Loc.T("palette.devices.built_in"), D("reverb", "verb hall room plate",
"airy wide", "", "vocals bus drums", "", "ambient",
- Loc.T("Algorithmic reverb from small rooms to large halls."))),
- new("Nota Chamber", A, 20, Loc.T("hybrid reverb"), D("reverb", "verb convolution chamber",
+ Loc.T("palette.devices.algorithmic_reverb_from_small_rooms"))),
+ new("Nota Chamber", A, 20, Loc.T("palette.devices.hybrid_reverb"), D("reverb", "verb convolution chamber",
"dark lush wide", "", "vocals bus", "", "ambient cinematic",
- Loc.T("Hybrid reverb with early reflections and a long, dense tail."))),
- new("Nota Delay", A, 3, Loc.T("built-in"), D("delay", "echo pingpong",
+ Loc.T("palette.devices.hybrid_reverb_with_early_reflections"))),
+ new("Nota Delay", A, 3, Loc.T("palette.devices.built_in"), D("delay", "echo pingpong",
"wide", "", "vocals synth guitar", "", "",
- Loc.T("Stereo and ping-pong delay synced to the tempo."))),
- new("Nota Utility", A, 4, Loc.T("built-in"), D("utility", "gain width mono phase",
+ Loc.T("palette.devices.stereo_and_ping_pong_delay"))),
+ new("Nota Utility", A, 4, Loc.T("palette.devices.built_in"), D("utility", "gain width mono phase",
"", "", "master bus", "widen", "",
- Loc.T("Gain, width, mono and phase — the housekeeping tool."))),
- new("Nota Level", A, 18, Loc.T("gain"), D("utility", "gain trim volume",
+ Loc.T("palette.devices.gain_width_mono_and_phase"))),
+ new("Nota Level", A, 18, Loc.T("palette.devices.gain"), D("utility", "gain trim volume",
"clean", "", "bus master", "loudness", "",
- Loc.T("A single gain stage with a big readout."))),
- new("Nota Shutter", A, 19, Loc.T("gate"), D("gate", "noisegate trancegate",
+ Loc.T("palette.devices.a_single_gain_stage_with"))),
+ new("Nota Shutter", A, 19, Loc.T("palette.devices.gate"), D("gate", "noisegate trancegate",
"punchy", "", "drums vocals", "repair transient", "trance",
- Loc.T("Noise gate and rhythmic trance gate."))),
- new("Nota Valve", A, 6, Loc.T("amplifier"), D("amp", "guitaramp tube cabinet",
+ Loc.T("palette.devices.noise_gate_and_rhythmic_trance"))),
+ new("Nota Valve", A, 6, Loc.T("palette.devices.amplifier"), D("amp", "guitaramp tube cabinet",
"warm gritty aggressive", "", "guitar bass", "", "rock",
- Loc.T("Guitar amp and cabinet models from clean to high gain."))),
- new("Nota Auto Filter", A, 7, Loc.T("envelope / LFO"), D("filter", "autofilter wah sweep",
+ Loc.T("palette.devices.guitar_amp_and_cabinet_models"))),
+ new("Nota Auto Filter", A, 7, Loc.T("palette.devices.envelope_lfo"), D("filter", "autofilter wah sweep",
"evolving", "", "synth drums bass", "modulation", "house techno",
- Loc.T("Resonant filter swept by an envelope follower or an LFO."))),
- new("Nota Vintage", A, 8, Loc.T("vintage saturator"), D("saturation", "tape tube saturator",
+ Loc.T("palette.devices.resonant_filter_swept_by_an"))),
+ new("Nota Vintage", A, 8, Loc.T("palette.devices.vintage_saturator"), D("saturation", "tape tube saturator",
"warm vintage lofi", "", "master bus drums", "", "lofi",
- Loc.T("Tape and tube saturation — warmth, wow and flutter."))),
- new("Nota Forge", A, 17, Loc.T("saturator"), D("saturation", "distortion waveshaper",
+ Loc.T("palette.devices.tape_and_tube_saturation_warmth"))),
+ new("Nota Forge", A, 17, Loc.T("palette.devices.saturator"), D("saturation", "distortion waveshaper",
"gritty aggressive warm", "", "drums bass synth", "", "",
- Loc.T("Waveshaping saturator from soft warmth to hard clipping."))),
- new("Nota Orbit", A, 9, Loc.T("auto-pan"), D("autopan", "panner tremolo",
+ Loc.T("palette.devices.waveshaping_saturator_from_soft_warmth"))),
+ new("Nota Orbit", A, 9, Loc.T("palette.devices.auto_pan"), D("autopan", "panner tremolo",
"wide evolving", "", "synth keys", "modulation", "",
- Loc.T("Auto-pan and tremolo synced to the tempo."))),
- new("Nota Flanger", A, 23, Loc.T("flanger"), D("flanger", "jet",
+ Loc.T("palette.devices.auto_pan_and_tremolo_synced"))),
+ new("Nota Flanger", A, 23, Loc.T("palette.devices.flanger"), D("flanger", "jet",
"metallic evolving", "", "drums guitar synth", "modulation", "",
- Loc.T("Classic jet flanger."))),
- new("Nota Phaser", A, 24, Loc.T("phaser"), D("phaser", "phase",
+ Loc.T("palette.devices.classic_jet_flanger"))),
+ new("Nota Phaser", A, 24, Loc.T("palette.devices.phaser"), D("phaser", "phase",
"evolving vintage", "", "keys guitar synth", "modulation", "funk",
- Loc.T("Multi-stage phaser."))),
- new("Nota Chorus", A, 25, Loc.T("chorus"), D("chorus", "ensemble dimension",
+ Loc.T("palette.devices.multi_stage_phaser"))),
+ new("Nota Chorus", A, 25, Loc.T("palette.devices.chorus"), D("chorus", "ensemble dimension",
"wide lush", "", "synth keys guitar vocals", "widen modulation", "",
- Loc.T("Chorus and ensemble for width and shimmer."))),
- new("Nota Vocoder", A, 26, Loc.T("vocoder"), D("vocoder", "talkbox robot choir channel",
+ Loc.T("palette.devices.chorus_and_ensemble_for_width"))),
+ new("Nota Vocoder", A, 26, Loc.T("palette.devices.vocoder"), D("vocoder", "talkbox robot choir channel",
"metallic vintage", "", "vocals synth", "modulation", "synthwave",
- Loc.T("Shapes this track's sound with another track's voice."))),
- new("Nota Auto Shift", A, 10, Loc.T("pitch correction"), D("pitch", "autotune melodyne tune",
+ Loc.T("palette.devices.shapes_this_tracks_sound_with"))),
+ new("Nota Auto Shift", A, 10, Loc.T("palette.devices.pitch_correction"), D("pitch", "autotune melodyne tune",
"", "", "vocals", "tuning", "trap pop",
- Loc.T("Real-time pitch correction to a key and scale."))),
- new("Nota Beat Repeat", A, 11, Loc.T("glitch & repeats"), D("glitch", "stutter repeat buffer",
+ Loc.T("palette.devices.real_time_pitch_correction_to"))),
+ new("Nota Beat Repeat", A, 11, Loc.T("palette.devices.glitch_repeats"), D("glitch", "stutter repeat buffer",
"aggressive", "", "drums vocals", "tapestop", "edm dubstep",
- Loc.T("Captures and repeats slices for stutters and glitches."))),
- new("Nota Crush", A, 12, Loc.T("bit crusher"), D("bitcrusher", "decimator redux",
+ Loc.T("palette.devices.captures_and_repeats_slices_for"))),
+ new("Nota Crush", A, 12, Loc.T("palette.devices.bit_crusher"), D("bitcrusher", "decimator redux",
"lofi gritty", "", "drums synth", "", "lofi hiphop",
- Loc.T("Bit-depth and sample-rate reduction."))),
- new("Nota Dynamic EQ-8", A, 13, Loc.T("dynamic EQ"), D("eq", "dynamiceq soothe deesser",
+ Loc.T("palette.devices.bit_depth_and_sample_rate"))),
+ new("Nota Dynamic EQ-8", A, 13, Loc.T("palette.devices.dynamic_eq"), D("eq", "dynamiceq soothe deesser",
"clean", "", "vocals master bus", "deess repair", "",
- Loc.T("EQ bands that react to the level — de-essing and resonance control."))),
- new("Nota Ceiling", A, 14, Loc.T("limiter"), D("limiter", "maximizer brickwall l2",
+ Loc.T("palette.devices.eq_bands_that_react_to"))),
+ new("Nota Ceiling", A, 14, Loc.T("palette.devices.limiter"), D("limiter", "maximizer brickwall l2",
"clean", "", "master bus", "loudness", "",
- Loc.T("Brickwall limiter for the master."))),
- new("Nota Strata", A, 15, Loc.T("looper"), D("looper", "loop overdub",
+ Loc.T("palette.devices.brickwall_limiter_for_the_master"))),
+ new("Nota Strata", A, 15, Loc.T("palette.devices.looper"), D("looper", "loop overdub",
"evolving", "", "guitar vocals synth", "", "ambient",
- Loc.T("Layered looper with overdubs."))),
- new("Nota Audio Effect Rack", A, 5, Loc.T("built-in"), D("rack", "effectrack chain parallel",
+ Loc.T("palette.devices.layered_looper_with_overdubs"))),
+ new("Nota Audio Effect Rack", A, 5, Loc.T("palette.devices.built_in"), D("rack", "effectrack chain parallel",
"", "", "bus", "parallel", "",
- Loc.T("Runs several effect chains in parallel."))),
+ Loc.T("palette.devices.runs_several_effect_chains_in"))),
// ---- MIDI effects -----------------------------------------------------------------
- new("Nota Arp", M, 0, Loc.T("step arpeggiator"), D("arp", "arpeggiator steps",
+ new("Nota Arp", M, 0, Loc.T("palette.devices.step_arpeggiator"), D("arp", "arpeggiator steps",
"evolving", "seq", "", "", "synthwave trance",
- Loc.T("Step arpeggiator with groove lanes."))),
- new("Nota Chord", M, 1, Loc.T("stacked intervals"), D("chord", "harmonizer stack",
+ Loc.T("palette.devices.step_arpeggiator_with_groove_lanes"))),
+ new("Nota Chord", M, 1, Loc.T("palette.devices.stacked_intervals"), D("chord", "harmonizer stack",
"lush", "", "keys synth", "", "house",
- Loc.T("Turns single notes into chords."))),
- new("Nota Scale", M, 2, Loc.T("pitch quantize"), D("scale", "keylock quantizepitch",
+ Loc.T("palette.devices.turns_single_notes_into_chords"))),
+ new("Nota Scale", M, 2, Loc.T("palette.devices.pitch_quantize"), D("scale", "keylock quantizepitch",
"", "", "synth keys", "tuning", "",
- Loc.T("Keeps notes in a key and scale."))),
- new("Nota Length", M, 3, Loc.T("force note length"), D("notelength", "gatelength legato",
+ Loc.T("palette.devices.keeps_notes_in_a_key"))),
+ new("Nota Length", M, 3, Loc.T("palette.devices.force_note_length"), D("notelength", "gatelength legato",
"", "", "synth", "", "",
- Loc.T("Forces note lengths — staccato, legato or fixed."))),
- new("Nota Velocity", M, 4, Loc.T("velocity shaping"), D("velocity", "velocitycurve touch",
+ Loc.T("palette.devices.forces_note_lengths_staccato_legato"))),
+ new("Nota Velocity", M, 4, Loc.T("palette.devices.velocity_shaping"), D("velocity", "velocitycurve touch",
"", "", "drums keys", "", "",
- Loc.T("Reshapes, compresses or randomises note velocities."))),
- new("Nota Random", M, 5, Loc.T("random transpose"), D("random", "humanize chance",
+ Loc.T("palette.devices.reshapes_compresses_or_randomises_note"))),
+ new("Nota Random", M, 5, Loc.T("palette.devices.random_transpose"), D("random", "humanize chance",
"evolving", "", "synth", "", "",
- Loc.T("Random transposition, timing and dropouts."))),
- new("Nota MIDI Effect Rack", M, 6, Loc.T("chains of MIDI effects"), D("rack", "midirack split layer zones",
+ Loc.T("palette.devices.random_transposition_timing_and_dropouts"))),
+ new("Nota MIDI Effect Rack", M, 6, Loc.T("palette.devices.chains_of_midi_effects"), D("rack", "midirack split layer zones",
"", "", "keys synth", "", "",
- Loc.T("Splits notes across chains of MIDI effects by key, velocity or a selector."))),
+ Loc.T("palette.devices.splits_notes_across_chains_of"))),
};
public static IEnumerable<BuiltinDevice> OfType(BuiltinDeviceType t) => All.Where(d => d.Type == t);
diff --git a/src/managed/Nota.Application/Palette/CommandCatalog.cs b/src/managed/Nota.Application/Palette/CommandCatalog.cs
index bf6cac72..2cf55504 100644
--- a/src/managed/Nota.Application/Palette/CommandCatalog.cs
+++ b/src/managed/Nota.Application/Palette/CommandCatalog.cs
@@ -22,121 +22,121 @@ public static class CommandCatalog
public static List<PaletteCommand> Create() => new()
{
// ---- File -------------------------------------------------------------------------
- C("file.new", Loc.T("New project"), Loc.T("File"), Shortcut.Cmd('N'), "create blank empty"),
- C("file.open", Loc.T("Open project…"), Loc.T("File"), Shortcut.Cmd('O'), "load"),
- C("file.save", Loc.T("Save project"), Loc.T("File"), Shortcut.Cmd('S'), "store write"),
- C("file.saveAs", Loc.T("Save project as…"), Loc.T("File"), Shortcut.CmdShift('S'), "copy rename"),
- C("file.saveVersion", Loc.T("Save version with note…"), Loc.T("File"), Shortcut.CmdAlt('S'), "snapshot history commit"),
- C("file.import", Loc.T("Import audio…"), Loc.T("File"), "", "add file wav"),
- C("file.export", Loc.T("Export audio…"), Loc.T("File"), Shortcut.CmdShift('E'), "render bounce mixdown stems"),
- C("file.exit", Loc.T("Exit Nota"), Loc.T("File"), Shortcut.Cmd('Q'), "quit close leave"),
+ C("file.new", Loc.T("common.new_project"), Loc.T("common.file"), Shortcut.Cmd('N'), "create blank empty"),
+ C("file.open", Loc.T("commands.open_project"), Loc.T("common.file"), Shortcut.Cmd('O'), "load"),
+ C("file.save", Loc.T("commands.save_project"), Loc.T("common.file"), Shortcut.Cmd('S'), "store write"),
+ C("file.saveAs", Loc.T("commands.save_project_as"), Loc.T("common.file"), Shortcut.CmdShift('S'), "copy rename"),
+ C("file.saveVersion", Loc.T("commands.save_version_with_note"), Loc.T("common.file"), Shortcut.CmdAlt('S'), "snapshot history commit"),
+ C("file.import", Loc.T("commands.import_audio"), Loc.T("common.file"), "", "add file wav"),
+ C("file.export", Loc.T("commands.export_audio"), Loc.T("common.file"), Shortcut.CmdShift('E'), "render bounce mixdown stems"),
+ C("file.exit", Loc.T("commands.exit_nota"), Loc.T("common.file"), Shortcut.Cmd('Q'), "quit close leave"),
// ---- Edit -------------------------------------------------------------------------
- C("edit.undo", Loc.T("Undo"), Loc.T("Edit"), Shortcut.Cmd('Z'), "back revert"),
- C("edit.redo", Loc.T("Redo"), Loc.T("Edit"), Shortcut.CmdShift('Z'), "forward"),
- C("edit.duplicate", Loc.T("Duplicate"), Loc.T("Edit"), Shortcut.Cmd('D'), "copy clone"),
- C("edit.split", Loc.T("Split at playhead"), Loc.T("Edit"), Shortcut.Cmd('E'), "cut slice", view: "Arrangement"),
- C("edit.consolidate", Loc.T("Consolidate"), Loc.T("Edit"), Shortcut.Cmd('J'), "join merge glue", view: "Arrangement"),
- C("edit.duplicateTime", Loc.T("Duplicate time"), Loc.T("Edit"), Shortcut.CmdShift('D'), "repeat range", view: "Arrangement"),
- C("edit.insertSilence", Loc.T("Insert silence"), Loc.T("Edit"), Shortcut.CmdShift('I'), "gap space", view: "Arrangement"),
- C("edit.lockEnvelopes", Loc.T("Lock envelopes"), Loc.T("Edit"), "", "automation pin"),
- C("edit.cut", Loc.T("Cut"), Loc.T("Edit"), "", ""),
- C("edit.copy", Loc.T("Copy"), Loc.T("Edit"), "", ""),
- C("edit.paste", Loc.T("Paste"), Loc.T("Edit"), "", ""),
- C("edit.pasteBounced", Loc.T("Paste bounced audio"), Loc.T("Edit"), Shortcut.CmdShift('V'), "render resample", view: "Arrangement"),
- C("edit.copyToOtherView", Loc.T("Copy clips to Session / Arrangement"), Loc.T("Edit"), Shortcut.CmdShift('C'), "transfer"),
- C("edit.delete", Loc.T("Delete"), Loc.T("Edit"), "", "remove erase"),
- C("edit.selectAll", Loc.T("Select all clips"), Loc.T("Edit"), Shortcut.Cmd('A'), "everything", view: "Arrangement"),
- C("edit.toggleClipActive", Loc.T("Activate / deactivate clip"), Loc.T("Edit"), Shortcut.None('0'), "mute disable", view: "Arrangement"),
+ C("edit.undo", Loc.T("common.undo"), Loc.T("common.edit"), Shortcut.Cmd('Z'), "back revert"),
+ C("edit.redo", Loc.T("commands.redo"), Loc.T("common.edit"), Shortcut.CmdShift('Z'), "forward"),
+ C("edit.duplicate", Loc.T("common.duplicate"), Loc.T("common.edit"), Shortcut.Cmd('D'), "copy clone"),
+ C("edit.split", Loc.T("commands.split_at_playhead"), Loc.T("common.edit"), Shortcut.Cmd('E'), "cut slice", view: "Arrangement"),
+ C("edit.consolidate", Loc.T("common.consolidate"), Loc.T("common.edit"), Shortcut.Cmd('J'), "join merge glue", view: "Arrangement"),
+ C("edit.duplicateTime", Loc.T("common.duplicate_time"), Loc.T("common.edit"), Shortcut.CmdShift('D'), "repeat range", view: "Arrangement"),
+ C("edit.insertSilence", Loc.T("common.insert_silence"), Loc.T("common.edit"), Shortcut.CmdShift('I'), "gap space", view: "Arrangement"),
+ C("edit.lockEnvelopes", Loc.T("commands.lock_envelopes"), Loc.T("common.edit"), "", "automation pin"),
+ C("edit.cut", Loc.T("common.cut"), Loc.T("common.edit"), "", ""),
+ C("edit.copy", Loc.T("common.copy"), Loc.T("common.edit"), "", ""),
+ C("edit.paste", Loc.T("common.paste"), Loc.T("common.edit"), "", ""),
+ C("edit.pasteBounced", Loc.T("common.paste_bounced_audio"), Loc.T("common.edit"), Shortcut.CmdShift('V'), "render resample", view: "Arrangement"),
+ C("edit.copyToOtherView", Loc.T("commands.copy_clips_to_session_arrangement"), Loc.T("common.edit"), Shortcut.CmdShift('C'), "transfer"),
+ C("edit.delete", Loc.T("common.delete"), Loc.T("common.edit"), "", "remove erase"),
+ C("edit.selectAll", Loc.T("commands.select_all_clips"), Loc.T("common.edit"), Shortcut.Cmd('A'), "everything", view: "Arrangement"),
+ C("edit.toggleClipActive", Loc.T("commands.activate_deactivate_clip"), Loc.T("common.edit"), Shortcut.None('0'), "mute disable", view: "Arrangement"),
// ---- View -------------------------------------------------------------------------
- C("view.arrangement", Loc.T("Show Arrangement"), Loc.T("View"), "", "timeline linear"),
- C("view.session", Loc.T("Show Session"), Loc.T("View"), "", "clips grid launch"),
- C("view.modular", Loc.T("Show Modular"), Loc.T("View"), "", "graph patch cv"),
- C("view.mixer", Loc.T("Show Mixer"), Loc.T("View"), Shortcut.CmdShift('M'), "faders channels"),
- C("view.mixerFloat", Loc.T("Mixer in its own window"), Loc.T("View"), "", "dock undock float pop out mixer window"),
- C("view.connectPhone", Loc.T("Connect phone…"), Loc.T("View"), "", "remote mobile qr"),
- C("view.toggleBrowser", Loc.T("Toggle browser"), Loc.T("View"), "", "library sidebar"),
- C("view.toggleDetail", Loc.T("Toggle detail panel"), Loc.T("View"), "", "devices clip"),
- C("view.maximizeDetail", Loc.T("Clip editor fills the window"), Loc.T("View"), Shortcut.CmdShift('F'), "maximize maximise full detail panel piano roll restore split"),
- C("view.showDevices", Loc.T("Show devices"), Loc.T("View"), "", "chain detail"),
- C("view.popOutDetail", Loc.T("Open devices in a window"), Loc.T("View"), "", "detach float pop out"),
- C("view.toggleOverview", Loc.T("Toggle overview"), Loc.T("View"), "", "minimap", view: "Arrangement"),
- C("view.toggleSections", Loc.T("Toggle sections"), Loc.T("View"), "", "markers locators", view: "Arrangement"),
- C("edit.resetSectionName", Loc.T("Reset section name"), Loc.T("Edit"), "", "default automatic rename section at playhead", view: "Arrangement"),
- C("edit.moveSectionEarlier", Loc.T("Move section earlier"), Loc.T("Edit"), "", "rearrange reorder section content left before previous at playhead", view: "Arrangement"),
- C("edit.moveSectionLater", Loc.T("Move section later"), Loc.T("Edit"), "", "rearrange reorder section content right after next at playhead", view: "Arrangement"),
- C("edit.duplicateSectionWithContent", Loc.T("Duplicate section with content"), Loc.T("Edit"), "", "copy repeat section clips automation ripple at playhead", view: "Arrangement"),
- C("edit.deleteSectionWithContent", Loc.T("Delete section with content"), Loc.T("Edit"), "", "remove cut section clips automation ripple close gap at playhead", view: "Arrangement"),
- C("view.follow", Loc.T("Follow playhead"), Loc.T("View"), "", "scroll"),
- C("view.showPlayhead", Loc.T("Show playhead"), Loc.T("View"), Shortcut.None('P'), "find locate scroll reveal cursor position", view: "Arrangement"),
- C("view.clipNames", Loc.T("Cycle clip names"), Loc.T("View"), "", "labels", view: "Arrangement"),
- C("view.headersRight", Loc.T("Track headers on the right"), Loc.T("View"), "", "track list side left right swap mirror ableton", view: "Arrangement"),
- C("view.automation", Loc.T("Toggle automation mode"), Loc.T("View"), Shortcut.CmdShift('A'), "envelopes lanes", view: "Arrangement"),
- C("view.history", Loc.T("Show version history"), Loc.T("View"), "", "undo history versions snapshots"),
- C("view.midiLearn", Loc.T("MIDI learn"), Loc.T("View"), "", "map controller"),
- C("view.fullscreen", Loc.T("Toggle full screen"), Loc.T("View"), Shortcut.None("F11"), "maximize immersive hide chrome"),
- C(Palette, Loc.T("Command palette"), Loc.T("View"), Shortcut.CmdShift('P'), "search", hide: true),
+ C("view.arrangement", Loc.T("commands.show_arrangement"), Loc.T("commands.view"), "", "timeline linear"),
+ C("view.session", Loc.T("commands.show_session"), Loc.T("commands.view"), "", "clips grid launch"),
+ C("view.modular", Loc.T("commands.show_modular"), Loc.T("commands.view"), "", "graph patch cv"),
+ C("view.mixer", Loc.T("commands.show_mixer"), Loc.T("commands.view"), Shortcut.CmdShift('M'), "faders channels"),
+ C("view.mixerFloat", Loc.T("commands.mixer_in_its_own_window"), Loc.T("commands.view"), "", "dock undock float pop out mixer window"),
+ C("view.connectPhone", Loc.T("commands.connect_phone"), Loc.T("commands.view"), "", "remote mobile qr"),
+ C("view.toggleBrowser", Loc.T("commands.toggle_browser"), Loc.T("commands.view"), "", "library sidebar"),
+ C("view.toggleDetail", Loc.T("commands.toggle_detail_panel"), Loc.T("commands.view"), "", "devices clip"),
+ C("view.maximizeDetail", Loc.T("commands.clip_editor_fills_the_window"), Loc.T("commands.view"), Shortcut.CmdShift('F'), "maximize maximise full detail panel piano roll restore split"),
+ C("view.showDevices", Loc.T("commands.show_devices"), Loc.T("commands.view"), "", "chain detail"),
+ C("view.popOutDetail", Loc.T("commands.open_devices_in_a_window"), Loc.T("commands.view"), "", "detach float pop out"),
+ C("view.toggleOverview", Loc.T("commands.toggle_overview"), Loc.T("commands.view"), "", "minimap", view: "Arrangement"),
+ C("view.toggleSections", Loc.T("commands.toggle_sections"), Loc.T("commands.view"), "", "markers locators", view: "Arrangement"),
+ C("edit.resetSectionName", Loc.T("commands.reset_section_name"), Loc.T("common.edit"), "", "default automatic rename section at playhead", view: "Arrangement"),
+ C("edit.moveSectionEarlier", Loc.T("commands.move_section_earlier"), Loc.T("common.edit"), "", "rearrange reorder section content left before previous at playhead", view: "Arrangement"),
+ C("edit.moveSectionLater", Loc.T("commands.move_section_later"), Loc.T("common.edit"), "", "rearrange reorder section content right after next at playhead", view: "Arrangement"),
+ C("edit.duplicateSectionWithContent", Loc.T("commands.duplicate_section_with_content"), Loc.T("common.edit"), "", "copy repeat section clips automation ripple at playhead", view: "Arrangement"),
+ C("edit.deleteSectionWithContent", Loc.T("commands.delete_section_with_content"), Loc.T("common.edit"), "", "remove cut section clips automation ripple close gap at playhead", view: "Arrangement"),
+ C("view.follow", Loc.T("commands.follow_playhead"), Loc.T("commands.view"), "", "scroll"),
+ C("view.showPlayhead", Loc.T("commands.show_playhead"), Loc.T("commands.view"), Shortcut.None('P'), "find locate scroll reveal cursor position", view: "Arrangement"),
+ C("view.clipNames", Loc.T("commands.cycle_clip_names"), Loc.T("commands.view"), "", "labels", view: "Arrangement"),
+ C("view.headersRight", Loc.T("commands.track_headers_on_the_right"), Loc.T("commands.view"), "", "track list side left right swap mirror ableton", view: "Arrangement"),
+ C("view.automation", Loc.T("commands.toggle_automation_mode"), Loc.T("commands.view"), Shortcut.CmdShift('A'), "envelopes lanes", view: "Arrangement"),
+ C("view.history", Loc.T("commands.show_version_history"), Loc.T("commands.view"), "", "undo history versions snapshots"),
+ C("view.midiLearn", Loc.T("commands.midi_learn"), Loc.T("commands.view"), "", "map controller"),
+ C("view.fullscreen", Loc.T("commands.toggle_full_screen"), Loc.T("commands.view"), Shortcut.None("F11"), "maximize immersive hide chrome"),
+ C(Palette, Loc.T("commands.command_palette"), Loc.T("commands.view"), Shortcut.CmdShift('P'), "search", hide: true),
// ---- Transport --------------------------------------------------------------------
- C("transport.playStop", Loc.T("Play / stop"), Loc.T("Transport"), Shortcut.None("Space"), "start pause"),
- C("transport.playPause", Loc.T("Play / pause"), Loc.T("Transport"), Shortcut.Shift("Space"), "resume continue hold"),
- C("transport.stop", Loc.T("Stop"), Loc.T("Transport"), Shortcut.None("Return"), "halt"),
- C("transport.record", Loc.T("Record"), Loc.T("Transport"), Shortcut.Cmd('R'), "arm capture"),
- C("transport.armOnSelect", Loc.T("Auto-arm selected track"), Loc.T("Transport"), "", "arm on select follow selection record keyboard"),
- C("transport.loop", Loc.T("Toggle loop"), Loc.T("Transport"), Shortcut.Cmd('L'), "cycle repeat"),
- C("transport.metronome", Loc.T("Metronome"), Loc.T("Transport"), Shortcut.Cmd('M'), "click"),
- C("transport.loopRecordMode", Loc.T("Loop record: overdub / replace"), Loc.T("Transport"), Shortcut.CmdShift('R'), "overdub replace take pass loop record"),
- C("transport.tapTempo", Loc.T("Tap tempo"), Loc.T("Transport"), "", "bpm beat tap"),
+ C("transport.playStop", Loc.T("common.play_stop"), Loc.T("common.transport"), Shortcut.None("Space"), "start pause"),
+ C("transport.playPause", Loc.T("commands.play_pause"), Loc.T("common.transport"), Shortcut.Shift("Space"), "resume continue hold"),
+ C("transport.stop", Loc.T("common.stop"), Loc.T("common.transport"), Shortcut.None("Return"), "halt"),
+ C("transport.record", Loc.T("common.record"), Loc.T("common.transport"), Shortcut.Cmd('R'), "arm capture"),
+ C("transport.armOnSelect", Loc.T("commands.auto_arm_selected_track"), Loc.T("common.transport"), "", "arm on select follow selection record keyboard"),
+ C("transport.loop", Loc.T("commands.toggle_loop"), Loc.T("common.transport"), Shortcut.Cmd('L'), "cycle repeat"),
+ C("transport.metronome", Loc.T("common.metronome"), Loc.T("common.transport"), Shortcut.Cmd('M'), "click"),
+ C("transport.loopRecordMode", Loc.T("commands.loop_record_overdub_replace"), Loc.T("common.transport"), Shortcut.CmdShift('R'), "overdub replace take pass loop record"),
+ C("transport.tapTempo", Loc.T("commands.tap_tempo"), Loc.T("common.transport"), "", "bpm beat tap"),
// ---- Track ------------------------------------------------------------------------
- C("track.newInstrument", Loc.T("New MIDI track"), Loc.T("Track"), "", "add instrument track"),
- C("track.newAudio", Loc.T("New audio track"), Loc.T("Track"), "", "add"),
- C("track.newReturn", Loc.T("New return track"), Loc.T("Track"), "", "add send bus aux"),
- C("track.group", Loc.T("Group tracks"), Loc.T("Track"), Shortcut.Cmd('G'), "folder bus", view: "Arrangement"),
- C("track.ungroup", Loc.T("Ungroup tracks"), Loc.T("Track"), Shortcut.CmdShift('G'), "", view: "Arrangement"),
- C("track.freeze", Loc.T("Freeze track"), Loc.T("Track"), "", "render bounce cpu"),
+ C("track.newInstrument", Loc.T("commands.new_midi_track"), Loc.T("common.track"), "", "add instrument track"),
+ C("track.newAudio", Loc.T("commands.new_audio_track"), Loc.T("common.track"), "", "add"),
+ C("track.newReturn", Loc.T("commands.new_return_track"), Loc.T("common.track"), "", "add send bus aux"),
+ C("track.group", Loc.T("commands.group_tracks"), Loc.T("common.track"), Shortcut.Cmd('G'), "folder bus", view: "Arrangement"),
+ C("track.ungroup", Loc.T("commands.ungroup_tracks"), Loc.T("common.track"), Shortcut.CmdShift('G'), "", view: "Arrangement"),
+ C("track.freeze", Loc.T("commands.freeze_track"), Loc.T("common.track"), "", "render bounce cpu"),
// ---- Session ----------------------------------------------------------------------
- C("session.launchScene", Loc.T("Launch scene"), Loc.T("Session"), "", "play row", view: "Session"),
- C("session.stopAll", Loc.T("Stop all clips"), Loc.T("Session"), "", "halt", view: "Session"),
- C("session.insertScene", Loc.T("Insert scene"), Loc.T("Session"), Shortcut.Cmd('I'), "add scene row", view: "Session"),
+ C("session.launchScene", Loc.T("commands.launch_scene"), Loc.T("commands.session"), "", "play row", view: "Session"),
+ C("session.stopAll", Loc.T("commands.stop_all_clips"), Loc.T("commands.session"), "", "halt", view: "Session"),
+ C("session.insertScene", Loc.T("commands.insert_scene"), Loc.T("commands.session"), Shortcut.Cmd('I'), "add scene row", view: "Session"),
// ---- Piano roll -------------------------------------------------------------------
- C("roll.quantize", Loc.T("Quantize notes"), Loc.T("Piano roll"), "", "quantise grid snap align"),
- C("roll.octaveUp", Loc.T("Transpose notes up an octave"), Loc.T("Piano roll"), "", "pitch shift"),
- C("roll.octaveDown", Loc.T("Transpose notes down an octave"), Loc.T("Piano roll"), "", "pitch shift"),
- C("roll.removeOutOfScale", Loc.T("Remove out-of-scale notes"), Loc.T("Piano roll"), "", "key fix"),
- C("roll.fitNotes", Loc.T("Fit to notes"), Loc.T("Piano roll"), Shortcut.Shift('F'), "zoom vertical rows height"),
- C("roll.fold", Loc.T("Fold the piano roll"), Loc.T("Piano roll"), Shortcut.Alt('F').WithShift(), "fold scale rows drum pads names hide keys"),
- C("roll.editSelected", Loc.T("Edit selected clips together"), Loc.T("Piano roll"), "", "multi clip several open piano roll", view: "Arrangement"),
- C("roll.trackMode", Loc.T("Toggle clip editor track mode"), Loc.T("Piano roll"), "", "track mode whole track all clips every clip piano roll", view: "Arrangement"),
+ C("roll.quantize", Loc.T("commands.quantize_notes"), Loc.T("common.piano_roll"), "", "quantise grid snap align"),
+ C("roll.octaveUp", Loc.T("commands.transpose_notes_up_an_octave"), Loc.T("common.piano_roll"), "", "pitch shift"),
+ C("roll.octaveDown", Loc.T("commands.transpose_notes_down_an_octave"), Loc.T("common.piano_roll"), "", "pitch shift"),
+ C("roll.removeOutOfScale", Loc.T("commands.remove_out_of_scale_notes"), Loc.T("common.piano_roll"), "", "key fix"),
+ C("roll.fitNotes", Loc.T("commands.fit_to_notes"), Loc.T("common.piano_roll"), Shortcut.Shift('F'), "zoom vertical rows height"),
+ C("roll.fold", Loc.T("commands.fold_the_piano_roll"), Loc.T("common.piano_roll"), Shortcut.Alt('F').WithShift(), "fold scale rows drum pads names hide keys"),
+ C("roll.editSelected", Loc.T("commands.edit_selected_clips_together"), Loc.T("common.piano_roll"), "", "multi clip several open piano roll", view: "Arrangement"),
+ C("roll.trackMode", Loc.T("commands.toggle_clip_editor_track_mode"), Loc.T("common.piano_roll"), "", "track mode whole track all clips every clip piano roll", view: "Arrangement"),
// ---- Grid (the arrangement or the piano roll — whichever was used last) -----------
- C("grid.narrower", Loc.T("Narrow grid"), Loc.T("Grid"), Shortcut.Cmd('1'), "finer smaller snap"),
- C("grid.wider", Loc.T("Widen grid"), Loc.T("Grid"), Shortcut.Cmd('2'), "coarser larger snap"),
- C("grid.triplets", Loc.T("Toggle triplet grid"), Loc.T("Grid"), Shortcut.Cmd('3'), "triplet 1/8T swing"),
- C("grid.snap", Loc.T("Toggle snap to grid"), Loc.T("Grid"), Shortcut.Cmd('4'), "magnet free"),
- C("grid.adaptive", Loc.T("Toggle adaptive grid"), Loc.T("Grid"), Shortcut.Cmd('5'), "auto zoom fixed"),
+ C("grid.narrower", Loc.T("commands.narrow_grid"), Loc.T("common.grid"), Shortcut.Cmd('1'), "finer smaller snap"),
+ C("grid.wider", Loc.T("commands.widen_grid"), Loc.T("common.grid"), Shortcut.Cmd('2'), "coarser larger snap"),
+ C("grid.triplets", Loc.T("commands.toggle_triplet_grid"), Loc.T("common.grid"), Shortcut.Cmd('3'), "triplet 1/8T swing"),
+ C("grid.snap", Loc.T("commands.toggle_snap_to_grid"), Loc.T("common.grid"), Shortcut.Cmd('4'), "magnet free"),
+ C("grid.adaptive", Loc.T("commands.toggle_adaptive_grid"), Loc.T("common.grid"), Shortcut.Cmd('5'), "auto zoom fixed"),
// ---- Settings ---------------------------------------------------------------------
- C("prefs.open", Loc.T("Settings"), Loc.T("Settings"), Shortcut.Cmd(','), "preferences options"),
- C("prefs.audio", Loc.T("Settings: Audio"), Loc.T("Settings"), "", "preferences device driver sample rate buffer"),
- C("prefs.midi", Loc.T("Settings: MIDI"), Loc.T("Settings"), "", "preferences controller keyboard"),
- C("prefs.gamepads", Loc.T("Settings: Gamepads"), Loc.T("Settings"), "", "preferences joystick controller"),
- C("prefs.remote", Loc.T("Settings: Remote"), Loc.T("Settings"), "", "preferences phone"),
- C("prefs.plugins", Loc.T("Settings: Plug-ins"), Loc.T("Settings"), "", "preferences vst3 au scan folders"),
- C("prefs.downloads", Loc.T("Settings: Downloads"), Loc.T("Settings"), "", "preferences store models sample packs"),
- C("prefs.library", Loc.T("Settings: Library"), Loc.T("Settings"), "", "preferences folders"),
- C("prefs.appearance", Loc.T("Settings: Appearance"), Loc.T("Settings"), "", "preferences theme dark light language langue francais english"),
- C("prefs.shortcuts", Loc.T("Settings: Shortcuts"), Loc.T("Settings"), "", "preferences hotkeys keys keyboard"),
- C("prefs.updates", Loc.T("Settings: Updates"), Loc.T("Settings"), "", "preferences update automatic check version"),
+ C("prefs.open", Loc.T("common.settings"), Loc.T("common.settings"), Shortcut.Cmd(','), "preferences options"),
+ C("prefs.audio", Loc.T("commands.settings_audio"), Loc.T("common.settings"), "", "preferences device driver sample rate buffer"),
+ C("prefs.midi", Loc.T("commands.settings_midi"), Loc.T("common.settings"), "", "preferences controller keyboard"),
+ C("prefs.gamepads", Loc.T("commands.settings_gamepads"), Loc.T("common.settings"), "", "preferences joystick controller"),
+ C("prefs.remote", Loc.T("commands.settings_remote"), Loc.T("common.settings"), "", "preferences phone"),
+ C("prefs.plugins", Loc.T("commands.settings_plug_ins"), Loc.T("common.settings"), "", "preferences vst3 au scan folders"),
+ C("prefs.downloads", Loc.T("commands.settings_downloads"), Loc.T("common.settings"), "", "preferences store models sample packs"),
+ C("prefs.library", Loc.T("commands.settings_library"), Loc.T("common.settings"), "", "preferences folders"),
+ C("prefs.appearance", Loc.T("commands.settings_appearance"), Loc.T("common.settings"), "", "preferences theme dark light language langue francais english"),
+ C("prefs.shortcuts", Loc.T("commands.settings_shortcuts"), Loc.T("common.settings"), "", "preferences hotkeys keys keyboard"),
+ C("prefs.updates", Loc.T("commands.settings_updates"), Loc.T("common.settings"), "", "preferences update automatic check version"),
// ---- Help -------------------------------------------------------------------------
- C("help.docs", Loc.T("Documentation"), Loc.T("Help"), "", "manual guide"),
- C("help.whatsNew", Loc.T("What's new"), Loc.T("Help"), "", "changelog release notes"),
- C("help.checkUpdates", Loc.T("Check for updates…"), Loc.T("Help"), "", "update upgrade new version download install"),
- C("help.about", Loc.T("About Nota"), Loc.T("Help"), "", "version"),
+ C("help.docs", Loc.T("common.documentation"), Loc.T("commands.help"), "", "manual guide"),
+ C("help.whatsNew", Loc.T("common.whats_new"), Loc.T("commands.help"), "", "changelog release notes"),
+ C("help.checkUpdates", Loc.T("common.check_for_updates"), Loc.T("commands.help"), "", "update upgrade new version download install"),
+ C("help.about", Loc.T("common.about_nota"), Loc.T("commands.help"), "", "version"),
};
private static PaletteCommand C(string id, string title, string category, string gesture, string aliases,
diff --git a/src/managed/Nota.Application/Palette/DeviceCategories.cs b/src/managed/Nota.Application/Palette/DeviceCategories.cs
index 7555f26b..83b71013 100644
--- a/src/managed/Nota.Application/Palette/DeviceCategories.cs
+++ b/src/managed/Nota.Application/Palette/DeviceCategories.cs
@@ -59,21 +59,21 @@ public static class DeviceCategories
/// plug-in mapping); only what is drawn is translated.</summary>
public static string Display(string name) => name switch
{
- "Synths" => Loc.T("Synths"),
- "Keys & physical" => Loc.T("Keys & physical"),
- "Drums" => Loc.T("Drums"),
- "Samplers" => Loc.T("Samplers"),
- "Racks" => Loc.T("Racks"),
- "EQ & filter" => Loc.T("EQ & filter"),
- "Dynamics" => Loc.T("Dynamics"),
- "Reverb & delay" => Loc.T("Reverb & delay"),
- "Modulation" => Loc.T("Modulation"),
- "Distortion" => Loc.T("Distortion"),
- "Pitch & time" => Loc.T("Pitch & time"),
- "Utility" => Loc.T("Utility"),
- "Generate" => Loc.T("Generate"),
- "Shape" => Loc.T("Shape"),
- "Other" => Loc.T("Other"),
+ "Synths" => Loc.T("palette.categories.synths"),
+ "Keys & physical" => Loc.T("palette.categories.keys_physical"),
+ "Drums" => Loc.T("palette.categories.drums"),
+ "Samplers" => Loc.T("palette.categories.samplers"),
+ "Racks" => Loc.T("palette.categories.racks"),
+ "EQ & filter" => Loc.T("palette.categories.eq_filter"),
+ "Dynamics" => Loc.T("palette.categories.dynamics"),
+ "Reverb & delay" => Loc.T("palette.categories.reverb_delay"),
+ "Modulation" => Loc.T("palette.categories.modulation"),
+ "Distortion" => Loc.T("palette.categories.distortion"),
+ "Pitch & time" => Loc.T("palette.categories.pitch_time"),
+ "Utility" => Loc.T("palette.categories.utility"),
+ "Generate" => Loc.T("palette.categories.generate"),
+ "Shape" => Loc.T("palette.categories.shape"),
+ "Other" => Loc.T("common.other"),
_ => name,
};
diff --git a/src/managed/Nota.Application/Palette/ModularCatalog.cs b/src/managed/Nota.Application/Palette/ModularCatalog.cs
index 23a0aaa8..15f0fdac 100644
--- a/src/managed/Nota.Application/Palette/ModularCatalog.cs
+++ b/src/managed/Nota.Application/Palette/ModularCatalog.cs
@@ -22,12 +22,12 @@ public static class ModularCatalog
public static IReadOnlyList<ModularNode> All { get; } = new ModularNode[]
{
- new("LFO", 0, Loc.T("Modulator"), D("lfo oscillator wobble", Loc.T("A low-frequency oscillator, free or synced to the tempo."))),
- new("Envelope Follower", 1, Loc.T("Modulator"), D("envelope follower env sidechain peak controller ducking duck pump loudness level volume", Loc.T("Turns the track's loudness into a control signal: a peak controller, for ducking one track under another."))),
- new("MIDI → CV", 2, Loc.T("Converter"), D("midi cv velocity note pitch", Loc.T("Turns notes, velocity and controllers into control signals."))),
- new("ADSR", 3, Loc.T("Modulator"), D("adsr envelope", Loc.T("An attack-decay-sustain-release envelope triggered by notes."))),
- new("Macro", 4, Loc.T("Control"), D("macro knob", Loc.T("One knob driving several destinations."))),
- new("Math", 5, Loc.T("CV utility"), D("math add multiply mixer attenuverter", Loc.T("Adds, multiplies or mixes two control signals."))),
- new("Scope", 6, Loc.T("Monitor"), D("scope oscilloscope monitor", Loc.T("Shows a control signal over time."))),
+ new("LFO", 0, Loc.T("palette.modular.modulator"), D("lfo oscillator wobble", Loc.T("palette.modular.a_low_frequency_oscillator_free"))),
+ new("Envelope Follower", 1, Loc.T("palette.modular.modulator"), D("envelope follower env sidechain peak controller ducking duck pump loudness level volume", Loc.T("palette.modular.turns_the_tracks_loudness_into"))),
+ new("MIDI → CV", 2, Loc.T("palette.modular.converter"), D("midi cv velocity note pitch", Loc.T("palette.modular.turns_notes_velocity_and_controllers"))),
+ new("ADSR", 3, Loc.T("palette.modular.modulator"), D("adsr envelope", Loc.T("palette.modular.an_attack_decay_sustain_release"))),
+ new("Macro", 4, Loc.T("palette.modular.control"), D("macro knob", Loc.T("palette.modular.one_knob_driving_several_destinations"))),
+ new("Math", 5, Loc.T("palette.modular.cv_utility"), D("math add multiply mixer attenuverter", Loc.T("palette.modular.adds_multiplies_or_mixes_two"))),
+ new("Scope", 6, Loc.T("palette.modular.monitor"), D("scope oscilloscope monitor", Loc.T("palette.modular.shows_a_control_signal_over"))),
};
}
diff --git a/src/managed/Nota.Application/Palette/PaletteIndex.cs b/src/managed/Nota.Application/Palette/PaletteIndex.cs
index c5bdf22b..41e7da3f 100644
--- a/src/managed/Nota.Application/Palette/PaletteIndex.cs
+++ b/src/managed/Nota.Application/Palette/PaletteIndex.cs
@@ -81,7 +81,7 @@ public sealed class PaletteIndex
/// <summary>The footer status: the progress while indexing, else the item count.</summary>
public string Status => IsIndexing
- ? Loc.F("indexing {0}… {1} %", _progressLabel, (int)Math.Round(_progress * 100))
- : Count == 1 ? Loc.T("1 item")
- : Loc.F("{0} items", Count.ToString("#,0", System.Globalization.CultureInfo.InvariantCulture).Replace(",", "\u2009"));
+ ? Loc.F("palette.index.indexing", _progressLabel, (int)Math.Round(_progress * 100))
+ : Count == 1 ? Loc.T("palette.index.1_item")
+ : Loc.F("palette.index.items", Count.ToString("#,0", System.Globalization.CultureInfo.InvariantCulture).Replace(",", "\u2009"));
}
diff --git a/src/managed/Nota.Application/Palette/PaletteSearch.cs b/src/managed/Nota.Application/Palette/PaletteSearch.cs
index 814951c3..9a291965 100644
--- a/src/managed/Nota.Application/Palette/PaletteSearch.cs
+++ b/src/managed/Nota.Application/Palette/PaletteSearch.cs
@@ -46,8 +46,8 @@ public sealed class ParsedQuery
public static readonly (char Prefix, PaletteKind Kind, string Label)[] Prefixes =
{
- ('>', PaletteKind.Action, Loc.T("Actions")), ('@', PaletteKind.Track, Loc.T("Tracks")), ('+', PaletteKind.Device, Loc.T("Devices")),
- ('#', PaletteKind.Preset, Loc.T("Presets")), ('~', PaletteKind.Modular, Loc.T("Modular")),
+ ('>', PaletteKind.Action, Loc.T("palette.search.actions")), ('@', PaletteKind.Track, Loc.T("palette.search.tracks")), ('+', PaletteKind.Device, Loc.T("palette.search.devices")),
+ ('#', PaletteKind.Preset, Loc.T("palette.search.presets")), ('~', PaletteKind.Modular, Loc.T("common.modular")),
};
public static ParsedQuery Parse(string raw)
@@ -282,8 +282,8 @@ public sealed class PaletteSearch
public static string GroupLabel(PaletteKind k) => k switch
{
- PaletteKind.Action => Loc.T("Actions"), PaletteKind.Track => Loc.T("Tracks"), PaletteKind.Device => Loc.T("Devices"),
- PaletteKind.Preset => Loc.T("Presets"), _ => Loc.T("Modular"),
+ PaletteKind.Action => Loc.T("palette.search.actions"), PaletteKind.Track => Loc.T("palette.search.tracks"), PaletteKind.Device => Loc.T("palette.search.devices"),
+ PaletteKind.Preset => Loc.T("palette.search.presets"), _ => Loc.T("common.modular"),
};
// CP-8: an unavailable action is shown only when the query names it.
@@ -368,14 +368,14 @@ public sealed class PaletteSearch
var recent = (_usage?.Recent ?? []).Select(_index.Find).Where(Ok).Select(it => it!).ToList();
if (recent.Count > 0)
{
- res.Rows.Add(new PaletteRow(Loc.T("Recent"), default));
+ res.Rows.Add(new PaletteRow(Loc.T("common.recent"), default));
foreach (var it in recent) { AddItem(res, Make(it)); seen.Add(it.Id); }
}
var sug = (suggested ?? []).Select(_index.Find).Where(it => Ok(it) && !seen.Contains(it!.Id)).Select(it => it!)
.Where(it => it.Kind != PaletteKind.Action || availability is null || availability(it).Ok).ToList();
if (sug.Count > 0)
{
- res.Rows.Add(new PaletteRow(Loc.F("Suggested · {0}", OriginLabel(ctx.Origin)), default));
+ res.Rows.Add(new PaletteRow(Loc.F("palette.search.suggested", OriginLabel(ctx.Origin)), default));
foreach (var it in sug) AddItem(res, Make(it));
}
return;
@@ -391,8 +391,8 @@ public sealed class PaletteSearch
public static string OriginLabel(PaletteOrigin o) => o switch
{
- PaletteOrigin.PianoRoll => Loc.T("Piano roll"),
- PaletteOrigin.DeviceWindow => Loc.T("Device window"),
+ PaletteOrigin.PianoRoll => Loc.T("common.piano_roll"),
+ PaletteOrigin.DeviceWindow => Loc.T("palette.search.device_window"),
_ => o.ToString(),
};
}
diff --git a/src/managed/Nota.Application/Palette/PaletteTargets.cs b/src/managed/Nota.Application/Palette/PaletteTargets.cs
index c2af79df..68edce61 100644
--- a/src/managed/Nota.Application/Palette/PaletteTargets.cs
+++ b/src/managed/Nota.Application/Palette/PaletteTargets.cs
@@ -21,13 +21,13 @@ public static class PaletteTargets
case PaletteKind.Action:
return actionCheck?.Invoke(it.Payload as string ?? "") ?? Availability.Yes;
case PaletteKind.Modular:
- return ctx.HasTrack ? Availability.Yes : Availability.No(Loc.T("Select a track first"));
+ return ctx.HasTrack ? Availability.Yes : Availability.No(Loc.T("palette.targets.select_a_track_first"));
case PaletteKind.Device:
case PaletteKind.Preset:
if (it.Role == PaletteDeviceRole.Instrument) return Availability.Yes; // no track → a new one (CP-4)
- if (!ctx.HasTrack) return Availability.No(Loc.T("Select a track first"));
+ if (!ctx.HasTrack) return Availability.No(Loc.T("palette.targets.select_a_track_first"));
if (it.Role == PaletteDeviceRole.MidiEffect && ctx.TrackType != PaletteTrackType.Instrument)
- return Availability.No(Loc.T("MIDI effects need an instrument track"));
+ return Availability.No(Loc.T("palette.targets.midi_effects_need_an_instrument"));
return Availability.Yes;
}
return Availability.Yes;
@@ -40,14 +40,14 @@ public static class PaletteTargets
if (it is null) return ("", false);
var a = Check(it, ctx, actionCheck);
if (!a.Ok) return (a.Reason, true);
- string keep = (mode & ApplyMode.KeepOpen) != 0 && it.Kind is PaletteKind.Device or PaletteKind.Preset or PaletteKind.Modular ? Loc.T(" · keep open") : "";
- string track = ctx.TrackName.Length > 0 ? ctx.TrackName : Loc.F("track {0}", ctx.TrackId);
+ string keep = (mode & ApplyMode.KeepOpen) != 0 && it.Kind is PaletteKind.Device or PaletteKind.Preset or PaletteKind.Modular ? Loc.T("palette.targets.keep_open") : "";
+ string track = ctx.TrackName.Length > 0 ? ctx.TrackName : Loc.F("palette.targets.track", ctx.TrackId);
switch (it.Kind)
{
- case PaletteKind.Action: return (Loc.T("↵ run"), false);
+ case PaletteKind.Action: return (Loc.T("palette.targets.run"), false);
case PaletteKind.Track:
- return ((mode & ApplyMode.NewTrack) != 0 ? Loc.F("→ open {0} in Devices", it.Name) : Loc.F("→ select {0} in {1}", it.Name, ctx.View), false);
- case PaletteKind.Modular: return (Loc.F("→ {0} · {1}{2}", track, Loc.T("canvas, unconnected"), keep), false);
+ return ((mode & ApplyMode.NewTrack) != 0 ? Loc.F("palette.targets.open_in_devices", it.Name) : Loc.F("palette.targets.select_in", it.Name, ctx.View), false);
+ case PaletteKind.Modular: return (Loc.F("palette.targets.pattern", track, Loc.T("palette.targets.canvas_unconnected"), keep), false);
}
bool newTrack = (mode & ApplyMode.NewTrack) != 0;
@@ -58,15 +58,15 @@ public static class PaletteTargets
{
if (it.PresetOrigin == PresetOrigin.Kit)
return !newTrack && instTrack && ctx.InstrumentKind is 4 or 12
- ? (Loc.F("→ {0} · {1}{2}", track, Loc.T("loads the kit"), keep), false) : (Loc.F("→ new track{0}", keep), false);
+ ? (Loc.F("palette.targets.pattern", track, Loc.T("palette.targets.loads_the_kit"), keep), false) : (Loc.F("palette.targets.new_track", keep), false);
if (it.PresetOrigin != PresetOrigin.Factory || newTrack || !instTrack || ctx.IsRack)
- return (Loc.F("→ new MIDI track{0}", keep), false);
- return (Loc.F("→ {0} · {1}{2}", track, ctx.InstrumentName.Length > 0 ? Loc.F("replaces {0}", ctx.InstrumentName) : Loc.T("instrument"), keep), false);
+ return (Loc.F("palette.targets.new_midi_track", keep), false);
+ return (Loc.F("palette.targets.pattern", track, ctx.InstrumentName.Length > 0 ? Loc.F("palette.targets.replaces", ctx.InstrumentName) : Loc.T("palette.targets.instrument"), keep), false);
}
- if (newTrack || !instTrack) return (Loc.F("→ new MIDI track{0}", keep), false);
- if (ctx.InstrumentKind == 4) return (Loc.F("→ {0} · {1}{2}", track, Loc.T("new pad in Drum Rack"), keep), false);
- if (ctx.InstrumentKind == 3) return (Loc.F("→ {0} · {1}{2}", track, Loc.T("new chain in Instrument Rack"), keep), false);
- return (Loc.F("→ {0} · {1}{2}", track, ctx.InstrumentName.Length > 0 ? Loc.F("replaces {0}", ctx.InstrumentName) : Loc.T("replaces the instrument"), keep), false);
+ if (newTrack || !instTrack) return (Loc.F("palette.targets.new_midi_track", keep), false);
+ if (ctx.InstrumentKind == 4) return (Loc.F("palette.targets.pattern", track, Loc.T("palette.targets.new_pad_in_drum_rack"), keep), false);
+ if (ctx.InstrumentKind == 3) return (Loc.F("palette.targets.pattern", track, Loc.T("palette.targets.new_chain_in_instrument_rack"), keep), false);
+ return (Loc.F("palette.targets.pattern", track, ctx.InstrumentName.Length > 0 ? Loc.F("palette.targets.replaces", ctx.InstrumentName) : Loc.T("palette.targets.replaces_the_instrument"), keep), false);
}
bool midi = it.Role == PaletteDeviceRole.MidiEffect;
@@ -75,13 +75,13 @@ public static class PaletteTargets
{
var ins = ctx.Insert;
bool alt = (mode & ApplyMode.Replace) != 0;
- if (!midi && ins.Section == ChainSection.Audio && ins.Index >= 0) where = alt ? Loc.F("replaces {0}", ins.DeviceName) : Loc.F("after {0}", ins.DeviceName);
- else if (midi && ins.Section == ChainSection.Midi && ins.Index >= 0) where = alt ? Loc.F("replaces {0}", ins.DeviceName) : Loc.F("after {0}", ins.DeviceName);
- else if (!midi && ins.Section == ChainSection.Instrument && ctx.InstrumentName.Length > 0) where = Loc.F("after {0}", ctx.InstrumentName);
- else where = midi ? Loc.T("end of MIDI FX") : Loc.T("end of Audio FX");
+ if (!midi && ins.Section == ChainSection.Audio && ins.Index >= 0) where = alt ? Loc.F("palette.targets.replaces", ins.DeviceName) : Loc.F("palette.targets.after", ins.DeviceName);
+ else if (midi && ins.Section == ChainSection.Midi && ins.Index >= 0) where = alt ? Loc.F("palette.targets.replaces", ins.DeviceName) : Loc.F("palette.targets.after", ins.DeviceName);
+ else if (!midi && ins.Section == ChainSection.Instrument && ctx.InstrumentName.Length > 0) where = Loc.F("palette.targets.after", ctx.InstrumentName);
+ else where = midi ? Loc.T("palette.targets.end_of_midi_fx") : Loc.T("palette.targets.end_of_audio_fx");
}
- else where = midi ? Loc.T("MIDI FX, end") : Loc.T("end of chain");
- return (Loc.F("→ {0} · {1}{2}", track, where, keep), false);
+ else where = midi ? Loc.T("palette.targets.midi_fx_end") : Loc.T("palette.targets.end_of_chain");
+ return (Loc.F("palette.targets.pattern", track, where, keep), false);
}
/// <summary>Ids suggested for an empty query in each context (CP-19).</summary>
diff --git a/src/managed/Nota.Application/Ports/IProcessCpu.cs b/src/managed/Nota.Application/Ports/IProcessCpu.cs
index 0817be0f..ddc416ad 100644
--- a/src/managed/Nota.Application/Ports/IProcessCpu.cs
+++ b/src/managed/Nota.Application/Ports/IProcessCpu.cs
@@ -32,5 +32,5 @@ public static class ProcessCpuScale
wholeMachine ? corePercent / Math.Max(1, logicalCpus) : corePercent;
/// <summary>What a displayed figure is a percentage of, for tooltips.</summary>
- public static string Unit(bool wholeMachine) => wholeMachine ? Loc.T("of all CPUs") : Loc.T("of one core");
+ public static string Unit(bool wholeMachine) => wholeMachine ? Loc.T("ports.i_process_cpu.of_all_cpus") : Loc.T("ports.i_process_cpu.of_one_core");
}
diff --git a/src/managed/Nota.Infrastructure/Ai/ClipAi.cs b/src/managed/Nota.Infrastructure/Ai/ClipAi.cs
index ab5e0dff..796a0995 100644
--- a/src/managed/Nota.Infrastructure/Ai/ClipAi.cs
+++ b/src/managed/Nota.Infrastructure/Ai/ClipAi.cs
@@ -104,17 +104,17 @@ public sealed class ClipAi(IAudioEngine engine, IModelStore models) : IClipAi
{
var src = (StemSource)job;
var (runtime, model) = Require(AiModels.Stems);
- progress?.Report((0, Loc.T("Preparing audio…")));
+ progress?.Report((0, Loc.T("ai.clip_ai.preparing_audio")));
double sr = src.SampleRate;
var l = Resampler.Convert(src.Left, sr, StemSeparator.SampleRate, ct);
var r = Resampler.Convert(src.Right, sr, StemSeparator.SampleRate, ct);
float[][][] stems;
- progress?.Report((0, Loc.T("Loading the model…")));
+ progress?.Report((0, Loc.T("ai.clip_ai.loading_the_model")));
using (var sep = new StemSeparator(runtime, model))
- stems = sep.Separate(l, r, new Progress(p => progress?.Report((p, Loc.T("Separating stems…")))), ct);
+ stems = sep.Separate(l, r, new Progress(p => progress?.Report((p, Loc.T("ai.clip_ai.separating_stems")))), ct);
- progress?.Report((1, Loc.T("Writing stems…")));
+ progress?.Report((1, Loc.T("ai.clip_ai.writing_stems")));
var files = new StemFiles { Paths = new string[StemSeparator.Stems.Length] };
try
{
diff --git a/src/managed/Nota.Infrastructure/Ai/OnnxRuntimeLoader.cs b/src/managed/Nota.Infrastructure/Ai/OnnxRuntimeLoader.cs
index d64f1074..5d01f86a 100644
--- a/src/managed/Nota.Infrastructure/Ai/OnnxRuntimeLoader.cs
+++ b/src/managed/Nota.Infrastructure/Ai/OnnxRuntimeLoader.cs
@@ -28,7 +28,7 @@ internal static class OnnxRuntimeLoader
{
if (_handle != IntPtr.Zero) return; // already loaded; a process can't swap it
if (!NativeLibrary.TryLoad(libraryPath, out var h))
- throw new StoreException(Loc.T("Nota couldn't load the AI runtime. Remove it in Settings → Downloads → AI Models and install it again."));
+ throw new StoreException(Loc.T("ai.onnx_runtime_loader.nota_couldnt_load_the_ai"));
_handle = h;
if (_path is null)
NativeLibrary.SetDllImportResolver(typeof(InferenceSession).Assembly, Resolve);
@@ -51,7 +51,7 @@ internal static class OnnxRuntimeLoader
try { return new InferenceSession(modelPath, opts); }
catch (OnnxRuntimeException e)
{
- throw new StoreException(Loc.T("The AI model file is damaged. Remove it in Settings → Downloads → AI Models and install it again."), e);
+ throw new StoreException(Loc.T("ai.onnx_runtime_loader.the_ai_model_file_is"), e);
}
}
}
diff --git a/src/managed/Nota.Infrastructure/Audition/PresetAudition.Kits.cs b/src/managed/Nota.Infrastructure/Audition/PresetAudition.Kits.cs
index e99eab70..1827c2f5 100644
--- a/src/managed/Nota.Infrastructure/Audition/PresetAudition.Kits.cs
+++ b/src/managed/Nota.Infrastructure/Audition/PresetAudition.Kits.cs
@@ -93,7 +93,7 @@ public sealed partial class PresetAudition
{
reason = "";
var kit = KitCatalog.ById(kitId);
- if (kit is null) { reason = Loc.T("Kit not found."); return null; }
+ if (kit is null) { reason = Loc.T("audition.preset_audition.kits.kit_not_found"); return null; }
return new AuditionPlan(keyBase, rhythm ? "Nota Rhythm" : "Nota Drum Rack", $"groove · {kit.Name}", false, "", "",
rig => SetupKit(rig, kit, rhythm), KitGroove(kit.Swing), KitBpm(kit), 8, 2.5, false);
}
diff --git a/src/managed/Nota.Infrastructure/Audition/PresetAudition.cs b/src/managed/Nota.Infrastructure/Audition/PresetAudition.cs
index 0e9422d8..8b347d0b 100644
--- a/src/managed/Nota.Infrastructure/Audition/PresetAudition.cs
+++ b/src/managed/Nota.Infrastructure/Audition/PresetAudition.cs
@@ -62,7 +62,7 @@ public sealed partial class PresetAudition : IPresetAudition
case AuditionSubjectKind.Preset when s.Path.StartsWith("rhythmkit:", StringComparison.Ordinal):
return KitPlan(s.Path, s.Path[10..], rhythm: true, out reason);
case AuditionSubjectKind.Preset:
- reason = Loc.T("Preset not found.");
+ reason = Loc.T("audition.preset_audition.preset_not_found");
return null;
// A fresh Drum Rack / Nota Rhythm is heard with the kit a new Rhythm starts with.
case AuditionSubjectKind.Instrument when s.BuiltinKind is 4 or 12:
@@ -82,7 +82,7 @@ public sealed partial class PresetAudition : IPresetAudition
default:
return null;
}
- if (doc is null) { reason = Loc.T("Preset not found."); return null; }
+ if (doc is null) { reason = Loc.T("audition.preset_audition.preset_not_found"); return null; }
var named = doc.NamedParams ?? new Dictionary<string, float>();
switch (doc.Type)
@@ -90,7 +90,7 @@ public sealed partial class PresetAudition : IPresetAudition
case "builtin-instrument":
{
int kind = doc.BuiltinKind;
- if (kind is 3 or 4) { reason = Loc.T("Racks play what their chains hold — nothing to preview on its own."); return null; }
+ if (kind is 3 or 4) { reason = Loc.T("audition.preset_audition.racks_play_what_their_chains"); return null; }
var phrase = PhraseFor(kind, category, s.Name);
return new AuditionPlan(keyBase, DeviceName(doc, kind, instrument: true), phrase.Label, false, "", "",
rig =>
@@ -136,7 +136,7 @@ public sealed partial class PresetAudition : IPresetAudition
case "builtin-effect":
{
int kind = doc.BuiltinKind;
- if (kind == 5) { reason = Loc.T("The Effect Rack plays what its chains hold — nothing to preview on its own."); return null; }
+ if (kind == 5) { reason = Loc.T("audition.preset_audition.the_effect_rack_plays_what"); return null; }
string id = trackId == AuditionTrackIds.Auto ? AutoTrack(kind) : trackId;
if (id == AuditionTrackIds.Sample && string.IsNullOrEmpty(samplePath)) id = AutoTrack(kind);
var track = id == AuditionTrackIds.Sample ? null : TrackById(id) ?? TrackById(AutoTrack(kind))!;
@@ -157,7 +157,7 @@ public sealed partial class PresetAudition : IPresetAudition
Array.Empty<AuditionNote>(), track?.Bpm ?? Bpm, 0, 4.0, true);
}
default:
- reason = Loc.T("Plug-in presets can't be previewed — load the plug-in to hear them.");
+ reason = Loc.T("audition.preset_audition.plug_in_presets_cant_be");
return null;
}
}
diff --git a/src/managed/Nota.Infrastructure/Kits/DrumKitService.cs b/src/managed/Nota.Infrastructure/Kits/DrumKitService.cs
index 57b7c690..f21d999e 100644
--- a/src/managed/Nota.Infrastructure/Kits/DrumKitService.cs
+++ b/src/managed/Nota.Infrastructure/Kits/DrumKitService.cs
@@ -57,13 +57,13 @@ public sealed class DrumKitService : IDrumKits
public int CreateTrack(IAudioEngine engine, string id, out string warning)
{
var kit = KitCatalog.ById(id);
- if (kit is null) { warning = Loc.T("Unknown drum kit."); return -1; }
+ if (kit is null) { warning = Loc.T("kits.drum_kit.unknown_drum_kit"); return -1; }
// One undo step: the new track with its whole kit.
engine.BeginUndoGroup();
try
{
int track = engine.AddDrumRackTrack();
- if (track <= 0) { warning = Loc.T("Couldn't create a Drum Rack track."); return -1; }
+ if (track <= 0) { warning = Loc.T("kits.drum_kit.couldnt_create_a_drum_rack"); return -1; }
Fill(engine, track, kit, out warning);
return track;
}
@@ -73,9 +73,9 @@ public sealed class DrumKitService : IDrumKits
public int CreateRhythmTrack(IAudioEngine engine, string id, out string warning)
{
var kit = KitCatalog.ById(id);
- if (kit is null) { warning = Loc.T("Unknown drum kit."); return -1; }
+ if (kit is null) { warning = Loc.T("kits.drum_kit.unknown_drum_kit"); return -1; }
int track = engine.AddRhythmTrack();
- if (track <= 0) { warning = Loc.T("Couldn't create a Nota Rhythm track."); return -1; }
+ if (track <= 0) { warning = Loc.T("kits.drum_kit.couldnt_create_a_nota_rhythm"); return -1; }
FillRhythm(engine, track, kit, out warning);
return track;
}
@@ -83,7 +83,7 @@ public sealed class DrumKitService : IDrumKits
public bool LoadInto(IAudioEngine engine, int trackId, string id, out string warning)
{
var kit = KitCatalog.ById(id);
- if (kit is null) { warning = Loc.T("Unknown drum kit."); return false; }
+ if (kit is null) { warning = Loc.T("kits.drum_kit.unknown_drum_kit"); return false; }
if (engine.TrackInstrumentKind(trackId) == RhythmModel.Kind) { FillRhythm(engine, trackId, kit, out warning); return true; }
// Clear the existing pads first — a kit replaces the rack's contents rather than
// layering onto whatever was there. One undo step brings the old pads back.
diff --git a/src/managed/Nota.Infrastructure/ModelStore/ModelCatalog.cs b/src/managed/Nota.Infrastructure/ModelStore/ModelCatalog.cs
index 3fc0940b..43b93509 100644
--- a/src/managed/Nota.Infrastructure/ModelStore/ModelCatalog.cs
+++ b/src/managed/Nota.Infrastructure/ModelStore/ModelCatalog.cs
@@ -35,14 +35,14 @@ public static class ModelCatalog
public static readonly IReadOnlyList<CatalogModel> Models =
[
- new(new StoreModel(AiModels.Stems, "htdemucs", Loc.T("Separate Stems"),
- Loc.T("Splits a mix into drums, bass, vocals and everything else, each on its own track."),
+ new(new StoreModel(AiModels.Stems, "htdemucs", Loc.T("model_store.model_catalog.separate_stems"),
+ Loc.T("model_store.model_catalog.splits_a_mix_into_drums"),
"Meta AI (Demucs v4)", "MIT", "https://github.com/facebookresearch/demucs",
174264717, 174264717),
new ModelAsset("https://github.com/nota-daw/nota-models/releases/download/htdemucs-v1/htdemucs.onnx",
"04c2b1a149788d048f710a6140446a72f7b4bab3171bc42189176a64ed609c78", 174264717, "file", [], "htdemucs.onnx")),
- new(new StoreModel(AiModels.Transcription, "basic-pitch", Loc.T("Convert to MIDI"),
- Loc.T("Hears every note in a recording, chords included, for Convert Melody and Convert Harmony."),
+ new(new StoreModel(AiModels.Transcription, "basic-pitch", Loc.T("model_store.model_catalog.convert_to_midi"),
+ Loc.T("model_store.model_catalog.hears_every_note_in_a"),
"Spotify", "Apache-2.0", "https://github.com/spotify/basic-pitch",
230444, 230444),
new ModelAsset("https://raw.githubusercontent.com/spotify/basic-pitch/v0.4.0/basic_pitch/saved_models/icassp_2022/nmp.onnx",
@@ -78,8 +78,8 @@ public static class ModelCatalog
bool win = rid.StartsWith("win", StringComparison.Ordinal);
string dir = $"onnxruntime-{rid}-{OrtVersion}/";
string file = $"onnxruntime-{rid}-{OrtVersion}" + (win ? ".zip" : ".tgz");
- return new(new StoreModel(AiModels.Runtime, "ONNX Runtime", Loc.T("AI runtime"),
- Loc.T("The library Nota's AI models run on. Installed with the first model."),
+ return new(new StoreModel(AiModels.Runtime, "ONNX Runtime", Loc.T("model_store.model_catalog.ai_runtime"),
+ Loc.T("model_store.model_catalog.the_library_notas_ai_models"),
"Microsoft", "MIT", "https://github.com/microsoft/onnxruntime",
r.Size, r.LibSize + 340_000),
new ModelAsset(OrtRelease + file, r.Sha, r.Size, win ? "zip" : "tar",
diff --git a/src/managed/Nota.Infrastructure/ModelStore/ModelStore.cs b/src/managed/Nota.Infrastructure/ModelStore/ModelStore.cs
index a7dc3cfe..982b890f 100644
--- a/src/managed/Nota.Infrastructure/ModelStore/ModelStore.cs
+++ b/src/managed/Nota.Infrastructure/ModelStore/ModelStore.cs
@@ -53,7 +53,7 @@ public sealed class ModelStore : IModelStore
public long DownloadSize(string id)
{
- var m = Find(id) ?? throw new StoreException(Loc.F("Unknown AI model \"{0}\".", id));
+ var m = Find(id) ?? throw new StoreException(Loc.F("model_store.unknown_ai_model", id));
long size = Installed(m) ? 0 : m.Asset.Size;
if (id != AiModels.Runtime && _runtime is not null && !Installed(_runtime)) size += _runtime.Asset.Size;
return size;
@@ -65,9 +65,9 @@ public sealed class ModelStore : IModelStore
public async Task InstallAsync(string id, IProgress<StoreProgress>? progress = null, CancellationToken ct = default)
{
- var model = Find(id) ?? throw new StoreException(Loc.F("Unknown AI model \"{0}\".", id));
+ var model = Find(id) ?? throw new StoreException(Loc.F("model_store.unknown_ai_model", id));
if (id != AiModels.Runtime && _runtime is null)
- throw new StoreException(Loc.T("AI models aren't available for this computer: ONNX Runtime has no build for it."));
+ throw new StoreException(Loc.T("model_store.ai_models_arent_available_for"));
await _installGate.WaitAsync(ct).ConfigureAwait(false);
try
{
@@ -99,7 +99,7 @@ public sealed class ModelStore : IModelStore
private async Task InstallOneAsync(CatalogModel m, IProgress<StoreProgress>? progress, CancellationToken ct)
{
- if (!RegistryClient.IsValidId(m.Info.Id)) throw new StoreException(Loc.F("Invalid model id \"{0}\".", m.Info.Id));
+ if (!RegistryClient.IsValidId(m.Info.Id)) throw new StoreException(Loc.F("model_store.invalid_model_id", m.Info.Id));
var work = Directory.CreateTempSubdirectory("nota-model-").FullName;
var staging = Path.Combine(_root, ".staging-" + m.Info.Id);
try
@@ -116,17 +116,17 @@ public sealed class ModelStore : IModelStore
}
else
{
- progress?.Report(new StoreProgress(-1, Loc.F("Unpacking {0}…", m.Info.Name)));
+ progress?.Report(new StoreProgress(-1, Loc.F("common.unpacking", m.Info.Name)));
var unpacked = Path.Combine(work, "x");
await Task.Run(() => ArchiveUnpacker.Unpack(file, a.Archive, unpacked, ct), ct).ConfigureAwait(false);
foreach (var keep in a.Keep)
{
var src = RegistryClient.Resolve(unpacked, keep);
- if (!File.Exists(src)) throw new StoreException(Loc.F("The download of {0} doesn't contain {1}.", m.Info.Name, keep));
+ if (!File.Exists(src)) throw new StoreException(Loc.F("model_store.the_download_of_doesnt_contain", m.Info.Name, keep));
File.Copy(src, Path.Combine(staging, Path.GetFileName(src)));
}
}
- if (!File.Exists(Path.Combine(staging, a.Entry))) throw new StoreException(Loc.F("The download of {0} doesn't contain {1}.", m.Info.Name, a.Entry));
+ if (!File.Exists(Path.Combine(staging, a.Entry))) throw new StoreException(Loc.F("model_store.the_download_of_doesnt_contain", m.Info.Name, a.Entry));
File.WriteAllText(Path.Combine(staging, MarkerFile), a.Sha256);
var final = FolderOf(m);
@@ -153,7 +153,7 @@ public sealed class ModelStore : IModelStore
if (m is not null && !Installed(m)) need += m.Asset.Size + m.Info.UnpackedSize;
need += need / 20;
if (FreeBytes(_root) is { } free && free < need)
- throw new StoreException(Loc.F("Installing this model needs {0} of free disk space, and there is {1}.", Mb(need), Mb(free)));
+ throw new StoreException(Loc.F("model_store.installing_this_model_needs_of", Mb(need), Mb(free)));
}
private static long? FreeBytes(string path)
@@ -193,7 +193,7 @@ public sealed class ModelStore : IModelStore
try { Directory.Delete(dir, recursive: true); }
catch (Exception e) when (e is IOException or UnauthorizedAccessException)
{
- throw new StoreException(Loc.F("Couldn't remove {0} — it may be in use. Restart Nota and try again.", m.Info.Name), e);
+ throw new StoreException(Loc.F("model_store.couldnt_remove_it_may_be", m.Info.Name), e);
}
}
}
diff --git a/src/managed/Nota.Infrastructure/Mosaic/MosaicLibrary.cs b/src/managed/Nota.Infrastructure/Mosaic/MosaicLibrary.cs
index effd7838..4270e175 100644
--- a/src/managed/Nota.Infrastructure/Mosaic/MosaicLibrary.cs
+++ b/src/managed/Nota.Infrastructure/Mosaic/MosaicLibrary.cs
@@ -196,7 +196,7 @@ public sealed class MosaicPackLibrary : IMosaicPacks
public string ApplyInPlace(IAudioEngine engine, string path, int trackId)
{
try { return PresetService.ApplyInPlace(PresetService.Load(path), engine, trackId, -1); }
- catch (Exception e) { return Loc.F("Couldn't load the preset: {0}", e.Message); }
+ catch (Exception e) { return Loc.F("mosaic.library.couldnt_load_the_preset", e.Message); }
}
public MosaicProgram? Read(string path)
diff --git a/src/managed/Nota.Infrastructure/Persistence/PresetService.cs b/src/managed/Nota.Infrastructure/Persistence/PresetService.cs
index 2eda3162..60f1ebc4 100644
--- a/src/managed/Nota.Infrastructure/Persistence/PresetService.cs
+++ b/src/managed/Nota.Infrastructure/Persistence/PresetService.cs
@@ -207,9 +207,9 @@ public static class PresetService
{
case "builtin-effect":
{
- if (targetTrackId <= 0) return Loc.T("Select a track first.");
+ if (targetTrackId <= 0) return Loc.T("common.select_a_track_first");
int di = engine.AddBuiltinDevice(targetTrackId, doc.BuiltinKind);
- if (di < 0) return Loc.T("Failed to add device.");
+ if (di < 0) return Loc.T("persistence.preset.failed_to_add_device");
if (doc.NamedParams is { Count: > 0 })
{
int pc = engine.DeviceParamCount(targetTrackId, di);
@@ -226,9 +226,9 @@ public static class PresetService
}
case "builtin-midi-effect":
{
- if (targetTrackId <= 0) return Loc.T("Select a track first.");
+ if (targetTrackId <= 0) return Loc.T("common.select_a_track_first");
int mi = engine.AddMidiEffect(targetTrackId, doc.BuiltinKind);
- if (mi < 0) return Loc.T("Failed to add MIDI effect.");
+ if (mi < 0) return Loc.T("persistence.preset.failed_to_add_midi_effect");
if (doc.NamedParams is { Count: > 0 })
{
int pc = engine.MidiEffectParamCount(targetTrackId, mi);
@@ -263,7 +263,7 @@ public static class PresetService
17 => engine.AddMosaicTrack(),
_ => engine.AddInstrumentTrack(),
};
- if (t <= 0) return Loc.T("Failed to add instrument.");
+ if (t <= 0) return Loc.T("persistence.preset.failed_to_add_instrument");
if (doc.NamedParams is { Count: > 0 })
{
int pc = engine.PluginParamCount(t, -1);
@@ -277,25 +277,25 @@ public static class PresetService
}
case "plugin-effect":
{
- if (targetTrackId <= 0) return Loc.T("Select a track first.");
+ if (targetTrackId <= 0) return Loc.T("common.select_a_track_first");
int idx = NotaEngine.PluginIndexOfId(doc.PluginId);
- if (idx < 0) return Loc.F("Plugin not installed: {0}", doc.PluginId);
+ if (idx < 0) return Loc.F("persistence.preset.plugin_not_installed", doc.PluginId);
int di = engine.AddTrackEffectPlugin(targetTrackId, idx);
- if (di < 0) return Loc.T("Failed to load plugin.");
+ if (di < 0) return Loc.T("persistence.preset.failed_to_load_plugin");
ApplyState(engine, targetTrackId, di, doc.StateBase64);
return "";
}
case "plugin-instrument":
{
int idx = NotaEngine.PluginIndexOfId(doc.PluginId);
- if (idx < 0) return Loc.F("Plugin not installed: {0}", doc.PluginId);
+ if (idx < 0) return Loc.F("persistence.preset.plugin_not_installed", doc.PluginId);
int t = engine.AddPluginInstrumentTrack(idx);
- if (t <= 0) return Loc.T("Failed to load instrument.");
+ if (t <= 0) return Loc.T("persistence.preset.failed_to_load_instrument");
ApplyState(engine, t, -1, doc.StateBase64);
return "";
}
default:
- return Loc.T("Unknown preset type.");
+ return Loc.T("persistence.preset.unknown_preset_type");
}
}
@@ -305,8 +305,8 @@ public static class PresetService
if (doc.BuiltinKind != 10 || string.IsNullOrEmpty(doc.GrainSource)) return "";
var src = Grain.GrainSources.ById(doc.GrainSource);
var path = Grain.GrainSourceLibrary.Ensure(doc.GrainSource);
- if (src is null || path is null) return Loc.F("Couldn't prepare the sample \"{0}\".", doc.GrainSource);
- return engine.SetTrackGrainSample(trackId, path, src.Root) ? "" : Loc.F("Couldn't load the sample \"{0}\".", src.Name);
+ if (src is null || path is null) return Loc.F("persistence.preset.couldnt_prepare_the_sample", doc.GrainSource);
+ return engine.SetTrackGrainSample(trackId, path, src.Root) ? "" : Loc.F("persistence.preset.couldnt_load_the_sample", src.Name);
}
// A Nota Mosaic preset loads its program: a factory multisample (rendered on first use) or
@@ -317,7 +317,7 @@ public static class PresetService
if (!string.IsNullOrEmpty(doc.MosaicSource))
{
var prog = global::Nota.Infrastructure.Mosaic.MosaicSourceLibrary.Program(doc.MosaicSource);
- if (prog is null) return Loc.F("Couldn't prepare the multisample \"{0}\".", doc.MosaicSource);
+ if (prog is null) return Loc.F("persistence.preset.couldnt_prepare_the_multisample", doc.MosaicSource);
prog.Name = doc.DisplayName.Length > 0 ? doc.DisplayName : prog.Name;
engine.MosaicSetProgram(trackId, prog.Serialize());
return "";
@@ -331,7 +331,7 @@ public static class PresetService
/// card size, a loaded sample (and the Sampler's / Rhythm's sample regions) like any preset.</summary>
public static string ResetInPlace(IAudioEngine engine, int trackId, int deviceIndex, bool midiEffect)
{
- if (trackId <= 0) return Loc.T("Select a track first.");
+ if (trackId <= 0) return Loc.T("common.select_a_track_first");
if (deviceIndex < 0)
{
string warn = ApplyInPlace(new PresetDocument { Type = "builtin-instrument", NamedParams = new() }, engine, trackId, -1);
@@ -386,7 +386,7 @@ public static class PresetService
/// params to default first so the patch is clean; effects set the preset's named params.</summary>
public static string ApplyInPlace(PresetDocument doc, IAudioEngine engine, int trackId, int deviceIndex)
{
- if (trackId <= 0) return Loc.T("Select a track first.");
+ if (trackId <= 0) return Loc.T("common.select_a_track_first");
switch (doc.Type)
{
case "builtin-instrument":
@@ -412,7 +412,7 @@ public static class PresetService
}
case "builtin-effect":
{
- if (deviceIndex < 0) return Loc.T("Not an effect.");
+ if (deviceIndex < 0) return Loc.T("persistence.preset.not_an_effect");
int pc = engine.DeviceParamCount(trackId, deviceIndex);
if (doc.NamedParams is { Count: > 0 })
{
@@ -435,7 +435,7 @@ public static class PresetService
}
case "builtin-midi-effect":
{
- if (deviceIndex < 0) return Loc.T("Not a MIDI effect.");
+ if (deviceIndex < 0) return Loc.T("persistence.preset.not_a_midi_effect");
if (doc.NamedParams is { Count: > 0 })
{
// Params the preset leaves out go back to their defaults, so switching presets
@@ -462,14 +462,14 @@ public static class PresetService
return "";
}
case "plugin-effect":
- if (deviceIndex < 0) return Loc.T("Not an effect.");
+ if (deviceIndex < 0) return Loc.T("persistence.preset.not_an_effect");
ApplyState(engine, trackId, deviceIndex, doc.StateBase64);
return "";
case "plugin-instrument":
ApplyState(engine, trackId, -1, doc.StateBase64);
return "";
default:
- return Loc.T("Preset can't be applied in place.");
+ return Loc.T("persistence.preset.preset_cant_be_applied_in");
}
}
diff --git a/src/managed/Nota.Infrastructure/Persistence/ProjectHistory.cs b/src/managed/Nota.Infrastructure/Persistence/ProjectHistory.cs
index 96846d72..5446a7a2 100644
--- a/src/managed/Nota.Infrastructure/Persistence/ProjectHistory.cs
+++ b/src/managed/Nota.Infrastructure/Persistence/ProjectHistory.cs
@@ -139,7 +139,7 @@ public sealed partial class ProjectHistory : IProjectHistory
var node = Find(doc, versionId) ?? throw new ProjectHistoryException("That version no longer exists.");
if (node.ProjectFormat > ProjectService.CurrentFormatVersion)
throw new ProjectHistoryException(
- Loc.F("This version was saved by Nota {0}, which is newer than this one. Update Nota to open it.", node.AppVersion));
+ Loc.F("persistence.project_history.this_version_was_saved_by", node.AppVersion));
// Read and check everything before touching the working copy.
var contents = new Dictionary<string, byte[]>(StringComparer.Ordinal);
diff --git a/src/managed/Nota.Infrastructure/PluginStore/ArchiveUnpacker.cs b/src/managed/Nota.Infrastructure/PluginStore/ArchiveUnpacker.cs
index 27b4fd0b..9381bad6 100644
--- a/src/managed/Nota.Infrastructure/PluginStore/ArchiveUnpacker.cs
+++ b/src/managed/Nota.Infrastructure/PluginStore/ArchiveUnpacker.cs
@@ -59,13 +59,13 @@ public static class ArchiveUnpacker
UnpackDeb(archive, dest, ct);
break;
default:
- throw new StoreException(Loc.F("Unsupported archive type \"{0}\".", kind));
+ throw new StoreException(Loc.F("plugin_store.archive_unpacker.unsupported_archive_type", kind));
}
}
private static void RequireMac(string kind)
{
- if (!OperatingSystem.IsMacOS()) throw new StoreException(Loc.F("A .{0} archive can only be unpacked on macOS.", kind));
+ if (!OperatingSystem.IsMacOS()) throw new StoreException(Loc.F("plugin_store.archive_unpacker.a_archive_can_only_be", kind));
}
// Refuses entries that would land outside the destination (absolute, drive-rooted or
@@ -79,7 +79,7 @@ public static class ArchiveUnpacker
{
var rel = e.FullName.Replace('\\', '/');
if (rel.StartsWith('/') || rel.Contains(':') || rel.Split('/').Contains(".."))
- throw new StoreException(Loc.F("The archive contains an unsafe path: {0}", e.FullName));
+ throw new StoreException(Loc.F("plugin_store.archive_unpacker.the_archive_contains_an_unsafe", e.FullName));
backslashes |= e.FullName.Contains('\\');
}
return backslashes;
@@ -95,7 +95,7 @@ public static class ArchiveUnpacker
var rel = e.FullName.Replace('\\', '/');
var target = Path.GetFullPath(Path.Combine(dest, rel));
if (!target.StartsWith(root, StringComparison.Ordinal) && target + Path.DirectorySeparatorChar != root)
- throw new StoreException(Loc.F("The archive contains an unsafe path: {0}", e.FullName));
+ throw new StoreException(Loc.F("plugin_store.archive_unpacker.the_archive_contains_an_unsafe", e.FullName));
if (rel.EndsWith('/')) { Directory.CreateDirectory(target); continue; }
Directory.CreateDirectory(Path.GetDirectoryName(target)!);
e.ExtractToFile(target, overwrite: true);
@@ -127,7 +127,7 @@ public static class ArchiveUnpacker
using var f = File.OpenRead(archive);
var magic = new byte[8];
if (f.Read(magic) != 8 || System.Text.Encoding.ASCII.GetString(magic) != "!<arch>\n")
- throw new StoreException(Loc.T("The .deb archive is damaged."));
+ throw new StoreException(Loc.T("plugin_store.archive_unpacker.the_deb_archive_is_damaged"));
var header = new byte[60];
while (f.Read(header) == 60)
{
@@ -147,7 +147,7 @@ public static class ArchiveUnpacker
}
f.Seek(size + (size & 1), SeekOrigin.Current);
}
- throw new StoreException(Loc.T("The .deb archive has no data."));
+ throw new StoreException(Loc.T("plugin_store.archive_unpacker.the_deb_archive_has_no"));
}
private static void CopyExactly(Stream from, Stream to, long count)
@@ -156,7 +156,7 @@ public static class ArchiveUnpacker
while (count > 0)
{
int n = from.Read(buf, 0, (int)Math.Min(buf.Length, count));
- if (n <= 0) throw new StoreException(Loc.T("The .deb archive is truncated."));
+ if (n <= 0) throw new StoreException(Loc.T("plugin_store.archive_unpacker.the_deb_archive_is_truncated"));
to.Write(buf, 0, n);
count -= n;
}
@@ -200,8 +200,8 @@ public static class ArchiveUnpacker
foreach (var a in args) psi.ArgumentList.Add(a);
Process p;
- try { p = Process.Start(psi) ?? throw new StoreException(Loc.F("Couldn't start {0}.", exe)); }
- catch (System.ComponentModel.Win32Exception e) { throw new StoreException(Loc.F("Unpacking needs \"{0}\", which wasn't found.", exe), e); }
+ try { p = Process.Start(psi) ?? throw new StoreException(Loc.F("plugin_store.archive_unpacker.couldnt_start", exe)); }
+ catch (System.ComponentModel.Win32Exception e) { throw new StoreException(Loc.F("plugin_store.archive_unpacker.unpacking_needs_which_wasnt_found", exe), e); }
using (p)
{
if (stdin is not null) { p.StandardInput.Write(stdin); p.StandardInput.Close(); }
@@ -210,7 +210,7 @@ public static class ArchiveUnpacker
try { p.WaitForExitAsync(ct).GetAwaiter().GetResult(); }
catch (OperationCanceledException) { try { p.Kill(entireProcessTree: true); } catch { } throw; }
if (p.ExitCode != 0)
- throw new StoreException(Loc.F("{0} failed ({1}): {2}", exe, p.ExitCode, stderr.GetAwaiter().GetResult().Trim()));
+ throw new StoreException(Loc.F("plugin_store.archive_unpacker.failed", exe, p.ExitCode, stderr.GetAwaiter().GetResult().Trim()));
}
}
}
diff --git a/src/managed/Nota.Infrastructure/PluginStore/PluginStore.cs b/src/managed/Nota.Infrastructure/PluginStore/PluginStore.cs
index 0579f5d6..b2f5209e 100644
--- a/src/managed/Nota.Infrastructure/PluginStore/PluginStore.cs
+++ b/src/managed/Nota.Infrastructure/PluginStore/PluginStore.cs
@@ -88,10 +88,10 @@ public sealed class PluginStore : IPluginStore
var file = Path.Combine(work, "asset" + RegistryClient.ExtensionOf(asset.Url, asset.Archive));
await _registry.DownloadAsync(asset.Url, asset.Size, asset.Sha256, file, plugin.Name, progress, ct).ConfigureAwait(false);
- progress?.Report(new StoreProgress(-1, Loc.F("Unpacking {0}…", plugin.Name)));
+ progress?.Report(new StoreProgress(-1, Loc.F("common.unpacking", plugin.Name)));
var bundleRoot = await Task.Run(() => Expand(asset, file, work, ct), ct).ConfigureAwait(false);
- progress?.Report(new StoreProgress(-1, Loc.F("Installing {0}…", plugin.Name)));
+ progress?.Report(new StoreProgress(-1, Loc.F("plugin_store.installing", plugin.Name)));
var bundles = await Task.Run(() => Place(plugin.Id, asset, bundleRoot, ct), ct).ConfigureAwait(false);
lock (_gate)
diff --git a/src/managed/Nota.Infrastructure/Registry/RegistryClient.cs b/src/managed/Nota.Infrastructure/Registry/RegistryClient.cs
index 5720253e..22da379f 100644
--- a/src/managed/Nota.Infrastructure/Registry/RegistryClient.cs
+++ b/src/managed/Nota.Infrastructure/Registry/RegistryClient.cs
@@ -54,7 +54,7 @@ internal sealed class RegistryClient
|| e is JsonException)
{
if (!File.Exists(_cachePath))
- throw new StoreException(Loc.F("Couldn't reach the {0}. Check your internet connection.", _what), e);
+ throw new StoreException(Loc.F("registry.client.couldnt_reach_the_check_your", _what), e);
return await File.ReadAllTextAsync(_cachePath, ct).ConfigureAwait(false);
}
}
@@ -89,7 +89,7 @@ internal sealed class RegistryClient
{
total += n;
if (total > size)
- throw new StoreException(Loc.F("The download of {0} is larger than the registry says — not installing it.", name));
+ throw new StoreException(Loc.F("registry.client.the_download_of_is_larger", name));
sha.AppendData(buf, 0, n);
await dst.WriteAsync(buf.AsMemory(0, n), ct).ConfigureAwait(false);
progress?.Report(new StoreProgress((double)total / size, label));
@@ -98,12 +98,12 @@ internal sealed class RegistryClient
}
catch (HttpRequestException e)
{
- throw new StoreException(Loc.F("Couldn't download {0}: {1}", name, e.Message), e);
+ throw new StoreException(Loc.F("registry.client.couldnt_download", name, e.Message), e);
}
var digest = Convert.ToHexStringLower(sha.GetHashAndReset());
if (total != size || digest != sha256)
- throw new StoreException(Loc.F("The download of {0} doesn't match the registry's checksum — not installing it.", name));
+ throw new StoreException(Loc.F("registry.client.the_download_of_doesnt_match", name));
}
/// <summary>A manifest-relative path ("a/b.vst3") under root; refuses paths that escape it.</summary>
@@ -112,7 +112,7 @@ internal sealed class RegistryClient
var full = Path.GetFullPath(Path.Combine(root, rel.Replace('/', Path.DirectorySeparatorChar)));
var prefix = Path.GetFullPath(root) + Path.DirectorySeparatorChar;
if (!full.StartsWith(prefix, StringComparison.Ordinal))
- throw new StoreException(Loc.F("Unsafe path in the registry entry: {0}", rel));
+ throw new StoreException(Loc.F("registry.client.unsafe_path_in_the_registry", rel));
return full;
}
diff --git a/src/managed/Nota.Infrastructure/SampleStore/SampleIndex.cs b/src/managed/Nota.Infrastructure/SampleStore/SampleIndex.cs
index 9f9d1082..89e55bf6 100644
--- a/src/managed/Nota.Infrastructure/SampleStore/SampleIndex.cs
+++ b/src/managed/Nota.Infrastructure/SampleStore/SampleIndex.cs
@@ -53,7 +53,7 @@ public static class SampleIndex
var root = doc.RootElement;
int schema = root.TryGetProperty("schema", out var s) && s.TryGetInt32(out var n) ? n : 0;
if (schema is < 1 or > SupportedSchema)
- throw new StoreException(Loc.T("The sample registry needs a newer version of Nota."));
+ throw new StoreException(Loc.T("sample_store.sample_index.the_sample_registry_needs_a"));
var list = new List<StorePack>();
foreach (var p in root.GetProperty("packs").EnumerateArray())
diff --git a/src/managed/Nota.Infrastructure/SampleStore/SampleStore.cs b/src/managed/Nota.Infrastructure/SampleStore/SampleStore.cs
index d93eea2f..010a1569 100644
--- a/src/managed/Nota.Infrastructure/SampleStore/SampleStore.cs
+++ b/src/managed/Nota.Infrastructure/SampleStore/SampleStore.cs
@@ -72,14 +72,14 @@ public sealed class SampleStore : ISampleStore
{
var json = await _registry.FetchIndexAsync(refresh, j => SampleIndex.Parse(j), ct).ConfigureAwait(false);
try { return SampleIndex.Parse(json); }
- catch (JsonException e) { throw new StoreException(Loc.T("The sample registry index is damaged."), e); }
+ catch (JsonException e) { throw new StoreException(Loc.T("sample_store.the_sample_registry_index_is"), e); }
}
// ---- install / uninstall ----------------------------------------------------------
public async Task InstallAsync(StorePack pack, IProgress<StoreProgress>? progress = null, CancellationToken ct = default)
{
- if (!RegistryClient.IsValidId(pack.Id)) throw new StoreException(Loc.F("Invalid pack id \"{0}\".", pack.Id));
+ if (!RegistryClient.IsValidId(pack.Id)) throw new StoreException(Loc.F("sample_store.invalid_pack_id", pack.Id));
var asset = pack.Asset;
var installDir = InstallDir;
Directory.CreateDirectory(installDir);
@@ -91,12 +91,12 @@ public sealed class SampleStore : ISampleStore
var file = Path.Combine(work, "pack" + RegistryClient.ExtensionOf(asset.Url, asset.Archive));
await _registry.DownloadAsync(asset.Url, asset.Size, asset.Sha256, file, pack.Name, progress, ct).ConfigureAwait(false);
- progress?.Report(new StoreProgress(-1, Loc.F("Unpacking {0}…", pack.Name)));
+ progress?.Report(new StoreProgress(-1, Loc.F("common.unpacking", pack.Name)));
var unpacked = Path.Combine(work, "x");
await Task.Run(() => ArchiveUnpacker.Unpack(file, asset.Archive, unpacked, ct), ct).ConfigureAwait(false);
try { File.Delete(file); } catch { /* temp; frees space for big packs */ }
var packRoot = asset.Root is { } r ? RegistryClient.Resolve(unpacked, r) : unpacked;
- if (!Directory.Exists(packRoot)) throw new StoreException(Loc.F("The download of {0} doesn't contain {1}.", pack.Name, asset.Root));
+ if (!Directory.Exists(packRoot)) throw new StoreException(Loc.F("sample_store.the_download_of_doesnt_contain", pack.Name, asset.Root));
var path = await Task.Run(() => Place(pack, packRoot, installDir, progress, ct), ct).ConfigureAwait(false);
lock (_gate)
@@ -114,7 +114,7 @@ public sealed class SampleStore : ISampleStore
public void Uninstall(string id)
{
- if (!RegistryClient.IsValidId(id)) throw new StoreException(Loc.F("Invalid pack id \"{0}\".", id));
+ if (!RegistryClient.IsValidId(id)) throw new StoreException(Loc.F("sample_store.invalid_pack_id", id));
InstalledStorePack? inst;
lock (_gate) inst = _installed.FirstOrDefault(i => i.Id == id);
if (inst is null) return;
@@ -124,7 +124,7 @@ public sealed class SampleStore : ISampleStore
}
catch (Exception e) when (e is IOException or UnauthorizedAccessException)
{
- throw new StoreException(Loc.T("Couldn't remove the pack's files — close anything using them and try again."), e);
+ throw new StoreException(Loc.T("sample_store.couldnt_remove_the_packs_files"), e);
}
lock (_gate)
{
@@ -139,9 +139,9 @@ public sealed class SampleStore : ISampleStore
long need = pack.Asset.UnpackedSize + pack.Asset.UnpackedSize / 20;
long needTemp = pack.Asset.Size + need;
if (FreeBytes(installDir) is { } free && free < need)
- throw new StoreException(Loc.F("{0} needs {1} of free space in your Samples folder, which has {2}.", pack.Name, Mb(need), Mb(free)));
+ throw new StoreException(Loc.F("sample_store.needs_of_free_space_in", pack.Name, Mb(need), Mb(free)));
if (FreeBytes(work) is { } freeTemp && freeTemp < needTemp)
- throw new StoreException(Loc.F("Unpacking {0} needs {1} of free space on the system drive, which has {2}.", pack.Name, Mb(needTemp), Mb(freeTemp)));
+ throw new StoreException(Loc.F("sample_store.unpacking_needs_of_free_space", pack.Name, Mb(needTemp), Mb(freeTemp)));
}
// Free space on the volume holding path: the drive whose root is the longest prefix of it
@@ -173,12 +173,12 @@ public sealed class SampleStore : ISampleStore
Directory.CreateDirectory(staging);
try
{
- string label = Loc.F("Installing {0}…", pack.Name);
+ string label = Loc.F("sample_store.installing", pack.Name);
long copied = 0, total = Math.Max(1, pack.Asset.UnpackedSize);
int files = 0;
progress?.Report(new StoreProgress(0, label));
CopyPack(new DirectoryInfo(packRoot), staging, ref files, ref copied, () => progress?.Report(new StoreProgress(Math.Min(1, (double)copied / total), label)), ct);
- if (files == 0) throw new StoreException(Loc.F("The download of {0} contains no samples Nota can use.", pack.Name));
+ if (files == 0) throw new StoreException(Loc.F("sample_store.the_download_of_contains_no", pack.Name));
File.WriteAllText(Path.Combine(staging, MarkerFile), pack.Id);
InstalledStorePack? previous;
diff --git a/src/managed/Nota.Infrastructure/Update/AppUpdater.cs b/src/managed/Nota.Infrastructure/Update/AppUpdater.cs
index f183e27d..3a3f8411 100644
--- a/src/managed/Nota.Infrastructure/Update/AppUpdater.cs
+++ b/src/managed/Nota.Infrastructure/Update/AppUpdater.cs
@@ -199,19 +199,19 @@ public sealed partial class AppUpdater : IAppUpdater
public async Task DownloadAsync(AppRelease release, IProgress<StoreProgress>? progress = null, CancellationToken ct = default)
{
- var asset = release.Asset ?? throw new StoreException(Loc.F("Nota {0} has no download for this computer.", release.Version));
- if (!CanInstallInPlace) throw new StoreException(Loc.T("This copy of Nota can't update itself — download the new version from the release page."));
+ var asset = release.Asset ?? throw new StoreException(Loc.F("update.app_updater.nota_has_no_download_for", release.Version));
+ if (!CanInstallInPlace) throw new StoreException(Loc.T("update.app_updater.this_copy_of_nota_cant"));
_pending = null;
CleanUpdatesDir();
Directory.CreateDirectory(_updatesDir);
var file = Path.Combine(_updatesDir, Path.GetFileName(asset.Name));
- await DownloadVerifiedAsync(asset, file, Loc.F("Downloading Nota {0}…", release.Version), progress, ct).ConfigureAwait(false);
+ await DownloadVerifiedAsync(asset, file, Loc.F("common.downloading_nota", release.Version), progress, ct).ConfigureAwait(false);
switch (_os == OSPlatform.OSX ? InstallKind.MacBundle : _os == OSPlatform.Windows ? InstallKind.WindowsInstaller : InstallKind.AppImage)
{
case InstallKind.MacBundle:
- progress?.Report(new StoreProgress(-1, Loc.T("Preparing the update…")));
+ progress?.Report(new StoreProgress(-1, Loc.T("update.app_updater.preparing_the_update")));
var staged = Path.Combine(_updatesDir, $"Nota-{release.Version}.app");
await Task.Run(() => StageMacBundle(file, staged, release.Version), ct).ConfigureAwait(false);
TryDelete(file);
@@ -252,7 +252,7 @@ public sealed partial class AppUpdater : IAppUpdater
while ((n = await src.ReadAsync(buf, ct).ConfigureAwait(false)) > 0)
{
total += n;
- if (total > asset.Size) throw new StoreException(Loc.T("The update download is larger than expected — not installing it."));
+ if (total > asset.Size) throw new StoreException(Loc.T("update.app_updater.the_update_download_is_larger"));
sha.AppendData(buf, 0, n);
await dst.WriteAsync(buf.AsMemory(0, n), ct).ConfigureAwait(false);
progress?.Report(new StoreProgress((double)total / asset.Size, label));
@@ -262,7 +262,7 @@ public sealed partial class AppUpdater : IAppUpdater
catch (HttpRequestException e)
{
TryDelete(file);
- throw new StoreException(Loc.F("Couldn't download the update: {0}", e.Message), e);
+ throw new StoreException(Loc.F("update.app_updater.couldnt_download_the_update", e.Message), e);
}
catch
{
@@ -274,7 +274,7 @@ public sealed partial class AppUpdater : IAppUpdater
if (total != asset.Size || asset.Sha256 is not null && digest != asset.Sha256)
{
TryDelete(file);
- throw new StoreException(Loc.T("The update download is damaged (checksum mismatch) — not installing it."));
+ throw new StoreException(Loc.T("update.app_updater.the_update_download_is_damaged"));
}
}
@@ -287,7 +287,7 @@ public sealed partial class AppUpdater : IAppUpdater
try
{
var app = Directory.EnumerateDirectories(mount, "*.app").FirstOrDefault()
- ?? throw new StoreException(Loc.T("The update disk image doesn't contain Nota.app."));
+ ?? throw new StoreException(Loc.T("update.app_updater.the_update_disk_image_doesnt"));
RunTool("ditto", app, staged);
}
finally
@@ -297,7 +297,7 @@ public sealed partial class AppUpdater : IAppUpdater
var plist = Path.Combine(staged, "Contents", "Info.plist");
var m = File.Exists(plist) ? BundleVersion().Match(File.ReadAllText(plist)) : Match.Empty;
if (!m.Success || m.Groups[1].Value.Trim() != version)
- throw new StoreException(Loc.T("The downloaded Nota.app isn't the expected version — not installing it."));
+ throw new StoreException(Loc.T("update.app_updater.the_downloaded_nota_app_isnt"));
}
[GeneratedRegex(@"<key>CFBundleShortVersionString</key>\s*<string>([^<]*)</string>")]
@@ -307,11 +307,11 @@ public sealed partial class AppUpdater : IAppUpdater
{
var psi = new ProcessStartInfo(exe) { UseShellExecute = false, RedirectStandardError = true, RedirectStandardOutput = true };
foreach (var a in args) psi.ArgumentList.Add(a);
- using var p = Process.Start(psi) ?? throw new StoreException(Loc.F("Couldn't start {0}.", exe));
+ using var p = Process.Start(psi) ?? throw new StoreException(Loc.F("update.app_updater.couldnt_start", exe));
var err = p.StandardError.ReadToEndAsync();
_ = p.StandardOutput.ReadToEndAsync();
- if (!p.WaitForExit(TimeSpan.FromMinutes(2))) { try { p.Kill(); } catch { } throw new StoreException(Loc.F("{0} timed out.", exe)); }
- if (p.ExitCode != 0) throw new StoreException(Loc.F("Couldn't prepare the update ({0}: {1}).", exe, err.Result.Trim()));
+ if (!p.WaitForExit(TimeSpan.FromMinutes(2))) { try { p.Kill(); } catch { } throw new StoreException(Loc.F("update.app_updater.timed_out", exe)); }
+ if (p.ExitCode != 0) throw new StoreException(Loc.F("update.app_updater.couldnt_prepare_the_update", exe, err.Result.Trim()));
}
// ---- install on exit --------------------------------------------------------------------
diff --git a/src/managed/Nota.Presentation/DeviceInsertService.cs b/src/managed/Nota.Presentation/DeviceInsertService.cs
index 9c6528c1..46b32350 100644
--- a/src/managed/Nota.Presentation/DeviceInsertService.cs
+++ b/src/managed/Nota.Presentation/DeviceInsertService.cs
@@ -216,10 +216,10 @@ public sealed class DeviceInsertService
return TagPlugin(item, Group(() =>
{
if (TryReplaceInstrument(item, trackId))
- return new InsertResult { Ok = true, TrackId = trackId, InstrumentReplaced = true, Status = Loc.F("Changed instrument to {0} (track {1})", item.Name, trackId) };
+ return new InsertResult { Ok = true, TrackId = trackId, InstrumentReplaced = true, Status = Loc.F("device_insert.changed_instrument_to_track", item.Name, trackId) };
int t = CreateInstrumentTrack(item, beat);
- return t > 0 ? new InsertResult { Ok = true, TrackId = t, CreatedTrack = true, Status = Loc.F("Added {0} (track {1})", item.Name, t) }
- : InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ return t > 0 ? new InsertResult { Ok = true, TrackId = t, CreatedTrack = true, Status = Loc.F("device_insert.added_track", item.Name, t) }
+ : InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
}));
// A preset on a plain instrument track loads into its instrument, like a bare instrument.
if (item.Kind == BrowserItemKind.Preset) return ApplyPreset(item, new InsertTarget(trackId, Beat: beat, InPlace: true));
@@ -241,12 +241,12 @@ public sealed class DeviceInsertService
{
if (_engine.TrackInstrumentKind(trackId) is 3 or 4) return AddToTrack(item, trackId);
return TryReplaceInstrument(item, trackId)
- ? new InsertResult { Ok = true, TrackId = trackId, InstrumentReplaced = true, Status = Loc.F("Changed instrument to {0} (track {1})", item.Name, trackId) }
- : InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ ? new InsertResult { Ok = true, TrackId = trackId, InstrumentReplaced = true, Status = Loc.F("device_insert.changed_instrument_to_track", item.Name, trackId) }
+ : InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
}
int t = CreateInstrumentTrack(item, 0);
- return t > 0 ? new InsertResult { Ok = true, TrackId = t, CreatedTrack = true, Status = Loc.F("Added {0} (track {1})", item.Name, t) }
- : InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ return t > 0 ? new InsertResult { Ok = true, TrackId = t, CreatedTrack = true, Status = Loc.F("device_insert.added_track", item.Name, t) }
+ : InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
}));
// A preset: in place on an instrument track; on another column an instrument preset
// spawns its own track and an effect preset lands on the column.
@@ -256,7 +256,7 @@ public sealed class DeviceInsertService
&& _engine.TrackInstrumentKind(trackId) is int rk and (3 or 4))
{
if (rk == 3) return new InsertResult { Ok = true, TrackId = trackId, ToRackCard = true, ShowDevices = true };
- if (!IsKit(item)) return InsertResult.Fail(Loc.T("A Drum Rack takes kits and instruments; load an instrument preset on a pad from its card."));
+ if (!IsKit(item)) return InsertResult.Fail(Loc.T("device_insert.a_drum_rack_takes_kits"));
}
if (item.Kind == BrowserItemKind.Preset)
return hostsInstrument ? ApplyPreset(item, new InsertTarget(trackId, InPlace: true))
@@ -280,15 +280,15 @@ public sealed class DeviceInsertService
if (isInstrument && (target.NewTrack || t <= 0 || !TryTrackInfo(t, out var ti0) || !ti0.IsInstrument || ti0.IsGroup || ti0.IsReturn))
{
int nt = CreateInstrumentTrack(item, target.Beat);
- return nt > 0 ? new InsertResult { Ok = true, TrackId = nt, CreatedTrack = true, ShowDevices = item.BuiltinKind is 1 or 3 or 4, Status = Loc.F("Added {0} (track {1})", item.Name, nt) }
- : InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ return nt > 0 ? new InsertResult { Ok = true, TrackId = nt, CreatedTrack = true, ShowDevices = item.BuiltinKind is 1 or 3 or 4, Status = Loc.F("device_insert.added_track", item.Name, nt) }
+ : InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
}
if (item.Kind == BrowserItemKind.Preset) return ApplyPreset(item, target);
- if (t <= 0) return InsertResult.Fail(Loc.T("Select a track first."));
+ if (t <= 0) return InsertResult.Fail(Loc.T("common.select_a_track_first"));
if (isInstrument && target.Placement == InsertPlacement.ReplaceInstrument)
return TryReplaceInstrument(item, t, evenRack: true)
- ? new InsertResult { Ok = true, TrackId = t, InstrumentReplaced = true, ShowDevices = true, Status = Loc.F("Changed instrument to {0}", item.Name) }
- : InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ ? new InsertResult { Ok = true, TrackId = t, InstrumentReplaced = true, ShowDevices = true, Status = Loc.F("device_insert.changed_instrument_to", item.Name) }
+ : InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
if (target.Placement != InsertPlacement.Default)
switch (item.Kind)
@@ -296,21 +296,21 @@ public sealed class DeviceInsertService
case BrowserItemKind.BuiltinInstrument:
case BrowserItemKind.PluginInstrument:
if (TryReplaceInstrument(item, t))
- return new InsertResult { Ok = true, TrackId = t, InstrumentReplaced = true, Status = Loc.F("Changed instrument to {0} (track {1})", item.Name, t) };
+ return new InsertResult { Ok = true, TrackId = t, InstrumentReplaced = true, Status = Loc.F("device_insert.changed_instrument_to_track", item.Name, t) };
break; // a rack: the default routing adds a chain / pad
case BrowserItemKind.BuiltinEffect:
case BrowserItemKind.PluginEffect:
case BrowserItemKind.BuiltinMidiEffect:
{
bool midi = item.Kind == BrowserItemKind.BuiltinMidiEffect;
- if (midi && !(TryTrackInfo(t, out var mt) && mt.IsInstrument)) return InsertResult.Fail(Loc.T("MIDI effects need an instrument track."));
+ if (midi && !(TryTrackInfo(t, out var mt) && mt.IsInstrument)) return InsertResult.Fail(Loc.T("device_insert.midi_effects_need_an_instrument"));
int idx = AddEffect(item, t);
- if (idx < 0) return InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ if (idx < 0) return InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
var placed = Place(t, midi, idx, target);
return new InsertResult
{
Ok = true, TrackId = t, ShowDevices = true, Placed = placed,
- Status = placed.Replaced ? Loc.F("Replaced with {0}", item.Name) : Loc.F("Added {0} to track {1}", item.Name, t),
+ Status = placed.Replaced ? Loc.F("device_insert.replaced_with", item.Name) : Loc.F("device_insert.added_to_track", item.Name, t),
};
}
}
@@ -320,65 +320,65 @@ public sealed class DeviceInsertService
// The Devices-panel / Modular default routing (was MainWindow.DropBrowserItem).
private InsertResult AddToTrack(BrowserItem item, int t)
{
- if (t <= 0) return InsertResult.Fail(Loc.T("Select a track first."));
+ if (t <= 0) return InsertResult.Fail(Loc.T("common.select_a_track_first"));
int kind = _engine.TrackInstrumentKind(t);
switch (item.Kind)
{
case BrowserItemKind.BuiltinInstrument when kind == 3: // Instrument Rack → new chain
_engine.RackAddChain(t, item.BuiltinKind);
- return Done(t, Loc.F("Added {0} chain", item.Name));
+ return Done(t, Loc.F("device_insert.added_chain", item.Name));
case BrowserItemKind.BuiltinInstrument when kind == 4: // Drum Rack → next free pad
{
int note = NextFreeDrumPad(t);
- if (note < 0) return InsertResult.Fail(Loc.T("All 16 pads are used."));
+ if (note < 0) return InsertResult.Fail(Loc.T("device_insert.all_16_pads_are_used"));
int c = _engine.RackAddChain(t, item.BuiltinKind);
if (c >= 0) _engine.RackSetChainTriggerNote(t, c, note);
- return Done(t, Loc.F("Added {0} pad", item.Name));
+ return Done(t, Loc.F("device_insert.added_pad", item.Name));
}
case BrowserItemKind.PluginInstrument when kind == 3: // Instrument Rack → plugin chain
return _engine.RackAddPluginInstrumentChain(t, item.CatalogIndex) < 0
- ? InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name)) : Done(t, Loc.F("Added {0} chain", item.Name));
+ ? InsertResult.Fail(Loc.F("common.couldnt_load", item.Name)) : Done(t, Loc.F("device_insert.added_chain", item.Name));
case BrowserItemKind.PluginInstrument when kind == 4: // Drum Rack → plugin pad
{
int note = NextFreeDrumPad(t);
- if (note < 0) return InsertResult.Fail(Loc.T("All 16 pads are used."));
+ if (note < 0) return InsertResult.Fail(Loc.T("device_insert.all_16_pads_are_used"));
int c = _engine.RackAddPluginInstrumentChain(t, item.CatalogIndex);
- if (c < 0) return InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ if (c < 0) return InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
_engine.RackSetChainTriggerNote(t, c, note);
- return Done(t, Loc.F("Added {0} pad", item.Name));
+ return Done(t, Loc.F("device_insert.added_pad", item.Name));
}
case BrowserItemKind.BuiltinInstrument:
case BrowserItemKind.PluginInstrument:
if (TryReplaceInstrument(item, t))
- return new InsertResult { Ok = true, TrackId = t, InstrumentReplaced = true, Status = Loc.F("Changed instrument to {0} (track {1})", item.Name, t) };
- return InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ return new InsertResult { Ok = true, TrackId = t, InstrumentReplaced = true, Status = Loc.F("device_insert.changed_instrument_to_track", item.Name, t) };
+ return InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
case BrowserItemKind.Sample when kind == 4: // sample → drum pad (Sampler)
{
int note = NextFreeDrumPad(t);
- if (note < 0) return InsertResult.Fail(Loc.T("All 16 pads are used."));
+ if (note < 0) return InsertResult.Fail(Loc.T("device_insert.all_16_pads_are_used"));
int c = _engine.RackAddSamplerChain(t, item.Path, note, false); // root = pad note → natural pitch
- if (c < 0) return InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ if (c < 0) return InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
_engine.RackSetChainTriggerNote(t, c, note);
- return Done(t, Loc.F("Added {0} pad", item.Name));
+ return Done(t, Loc.F("device_insert.added_pad", item.Name));
}
case BrowserItemKind.Sample when kind == 3: // sample → instrument-rack Sampler chain
return _engine.RackAddSamplerChain(t, item.Path, 60, false) < 0
- ? InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name)) : Done(t, Loc.F("Added {0} chain", item.Name));
+ ? InsertResult.Fail(Loc.F("common.couldnt_load", item.Name)) : Done(t, Loc.F("device_insert.added_chain", item.Name));
case BrowserItemKind.Sample when kind == 1: // sample → load into the Sampler
return !_engine.SetTrackSamplerSample(t, item.Path, 60)
- ? InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name)) : Done(t, Loc.F("Loaded {0}", item.Name)) with { ShowDevices = true };
+ ? InsertResult.Fail(Loc.F("common.couldnt_load", item.Name)) : Done(t, Loc.F("device_insert.loaded", item.Name)) with { ShowDevices = true };
case BrowserItemKind.Sample when kind == 10: // sample → load into Nota Grain
{
// The root from a note in the file name ("Pad_F#3.wav"), else C4.
int root = SamplerModel.DetectRoot(item.Path) is var d and >= 0 ? d : 60;
return !_engine.SetTrackGrainSample(t, item.Path, root)
- ? InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name))
- : Done(t, Loc.F("Loaded {0} · root {1}", item.Name, SamplerModel.NoteName(root))) with { ShowDevices = true };
+ ? InsertResult.Fail(Loc.F("common.couldnt_load", item.Name))
+ : Done(t, Loc.F("device_insert.loaded_root", item.Name, SamplerModel.NoteName(root))) with { ShowDevices = true };
}
case BrowserItemKind.Sample:
- return InsertResult.Fail(Loc.T("Drop samples onto the arrangement."));
+ return InsertResult.Fail(Loc.T("device_insert.drop_samples_onto_the_arrangement"));
case BrowserItemKind.MidiFile:
- return InsertResult.Fail(Loc.T("Drop MIDI files onto the arrangement or a session slot."));
+ return InsertResult.Fail(Loc.T("device_insert.drop_midi_files_onto_the"));
default: // effects + presets
return RouteToTrack(item, t);
}
@@ -392,18 +392,18 @@ public sealed class DeviceInsertService
// Presets first: an instrument preset spawns its own track, so it doesn't need a
// target; an effect preset reports "Select a track first." itself.
if (item.Kind == BrowserItemKind.Preset) return ApplyPreset(item, new InsertTarget(trackId));
- if (trackId <= 0) return InsertResult.Fail(Loc.T("Drop onto a track."));
+ if (trackId <= 0) return InsertResult.Fail(Loc.T("device_insert.drop_onto_a_track"));
switch (item.Kind)
{
case BrowserItemKind.BuiltinEffect:
case BrowserItemKind.BuiltinMidiEffect:
case BrowserItemKind.PluginEffect:
if (item.Kind == BrowserItemKind.BuiltinMidiEffect && !(TryTrackInfo(trackId, out var ti) && ti.IsInstrument))
- return InsertResult.Fail(Loc.T("MIDI effects need an instrument track."));
- if (AddEffect(item, trackId) < 0) return InsertResult.Fail(item.Kind == BrowserItemKind.PluginEffect ? Loc.T("Failed to load effect.") : Loc.F("Couldn't load {0}.", item.Name));
- return Done(trackId, Loc.F("Added {0} to track {1}", item.Name, trackId)) with { ShowDevices = true };
+ return InsertResult.Fail(Loc.T("device_insert.midi_effects_need_an_instrument"));
+ if (AddEffect(item, trackId) < 0) return InsertResult.Fail(item.Kind == BrowserItemKind.PluginEffect ? Loc.T("device_insert.failed_to_load_effect") : Loc.F("common.couldnt_load", item.Name));
+ return Done(trackId, Loc.F("device_insert.added_to_track", item.Name, trackId)) with { ShowDevices = true };
}
- return InsertResult.Fail(Loc.F("{0} can't go on a track.", item.Name));
+ return InsertResult.Fail(Loc.F("device_insert.cant_go_on_a_track", item.Name));
}
/// <summary>An effect activated with nothing to land on (no selected track, no instrument
@@ -412,12 +412,12 @@ public sealed class DeviceInsertService
public InsertResult EffectOnNewTrack(BrowserItem item) => Group(() =>
{
if (item.Kind == BrowserItemKind.BuiltinMidiEffect)
- return InsertResult.Fail(Loc.T("MIDI effects need an instrument track: add an instrument first."));
+ return InsertResult.Fail(Loc.T("device_insert.midi_effects_need_an_instrument_2"));
int t = _engine.AddAudioTrack();
- if (t <= 0) return InsertResult.Fail(Loc.F("Couldn't add a track for {0}.", item.Name));
+ if (t <= 0) return InsertResult.Fail(Loc.F("device_insert.couldnt_add_a_track_for", item.Name));
var r = RouteToTrack(item, t);
if (!r.Ok) { _engine.RemoveTrack(t); return r; }
- return r with { CreatedTrack = true, Status = Loc.F("Added {0} on a new audio track (track {1})", item.Name, t) };
+ return r with { CreatedTrack = true, Status = Loc.F("device_insert.added_on_a_new_audio", item.Name, t) };
});
// Names the plug-in a successful insertion added (#250). Rack chains / pads are left out:
@@ -499,7 +499,7 @@ public sealed class DeviceInsertService
bool swapped = false;
if (_engine.TrackInstrumentKind(t) != f.BuiltinKind)
{
- if (!_engine.SetTrackBuiltinInstrument(t, f.BuiltinKind)) return InsertResult.Fail(Loc.F("Couldn't load {0}.", item.Name));
+ if (!_engine.SetTrackBuiltinInstrument(t, f.BuiltinKind)) return InsertResult.Fail(Loc.F("common.couldnt_load", item.Name));
swapped = true;
}
// On the same instrument the sound and the name change as one undo step, so undo
@@ -510,7 +510,7 @@ public sealed class DeviceInsertService
return new InsertResult
{
Ok = w.Length == 0, TrackId = t, InstrumentReplaced = swapped, ShowDevices = true,
- Status = w.Length > 0 ? w : Loc.F("Applied preset {0}", item.Name),
+ Status = w.Length > 0 ? w : Loc.F("device_insert.applied_preset", item.Name),
PresetLanded = (t, PresetChain.Instrument, -1, item.Name, factoryId), PresetTagged = !swapped,
};
}
@@ -522,12 +522,12 @@ public sealed class DeviceInsertService
{
bool fileSwapped = false;
string sw = InstrumentInPlace(t, "file:" + item.Path, item.Name,
- () => _presets!.ApplyInstrumentInPlace(_engine, item.Path, t, out fileSwapped) ?? Loc.T("Presets are unavailable."));
+ () => _presets!.ApplyInstrumentInPlace(_engine, item.Path, t, out fileSwapped) ?? Loc.T("device_insert.presets_are_unavailable"));
if (sw.Length == 0) InstrumentPresetApplied?.Invoke(t);
return new InsertResult
{
Ok = sw.Length == 0, TrackId = t, InstrumentReplaced = fileSwapped, ShowDevices = true,
- Status = sw.Length > 0 ? sw : Loc.F("Applied preset {0}", item.Name),
+ Status = sw.Length > 0 ? sw : Loc.F("device_insert.applied_preset", item.Name),
PresetLanded = (t, PresetChain.Instrument, -1, item.Name, ""), PresetTagged = !fileSwapped,
};
}
@@ -538,7 +538,7 @@ public sealed class DeviceInsertService
return new InsertResult
{
Ok = fw.Length == 0, TrackId = t, InstrumentReplaced = fileSwapped2, ShowDevices = true,
- Status = fw.Length > 0 ? fw : Loc.F("Applied preset {0}", item.Name),
+ Status = fw.Length > 0 ? fw : Loc.F("device_insert.applied_preset", item.Name),
PresetLanded = (t, PresetChain.Instrument, -1, item.Name, ""),
};
}
@@ -549,7 +549,7 @@ public sealed class DeviceInsertService
int fxBefore = t > 0 ? _engine.TrackDeviceCount(t) : 0;
int midiBefore = t > 0 ? _engine.TrackMidiEffectCount(t) : 0;
string warn = fp is not null ? _factory.Apply(_engine, factoryId, t)
- : _presets?.ApplyFromFile(_engine, item.Path, t) ?? Loc.T("Presets are unavailable.");
+ : _presets?.ApplyFromFile(_engine, item.Path, t) ?? Loc.T("device_insert.presets_are_unavailable");
if (warn.Length > 0) return InsertResult.Fail(warn);
int newTrack = TrackIds().FirstOrDefault(id => !before.Contains(id));
@@ -557,7 +557,7 @@ public sealed class DeviceInsertService
if (newTrack > 0)
return new InsertResult
{
- Ok = true, TrackId = newTrack, CreatedTrack = true, ShowDevices = true, Status = Loc.F("Applied preset {0}", item.Name),
+ Ok = true, TrackId = newTrack, CreatedTrack = true, ShowDevices = true, Status = Loc.F("device_insert.applied_preset", item.Name),
PresetLanded = (newTrack, PresetChain.Instrument, -1, item.Name, factoryId),
};
if (t > 0 && _engine.TrackDeviceCount(t) is var fx && fx > fxBefore)
@@ -565,7 +565,7 @@ public sealed class DeviceInsertService
var placed = Place(t, false, fx - 1, target);
return new InsertResult
{
- Ok = true, TrackId = t, ShowDevices = true, Placed = placed, Status = Loc.F("Applied preset {0}", item.Name),
+ Ok = true, TrackId = t, ShowDevices = true, Placed = placed, Status = Loc.F("device_insert.applied_preset", item.Name),
PresetLanded = (t, PresetChain.Effect, placed.Final, item.Name, factoryId),
};
}
@@ -574,30 +574,30 @@ public sealed class DeviceInsertService
var placed = Place(t, true, midi - 1, target);
return new InsertResult
{
- Ok = true, TrackId = t, ShowDevices = true, Placed = placed, Status = Loc.F("Applied preset {0}", item.Name),
+ Ok = true, TrackId = t, ShowDevices = true, Placed = placed, Status = Loc.F("device_insert.applied_preset", item.Name),
PresetLanded = (t, PresetChain.Midi, placed.Final, item.Name, factoryId),
};
}
- return new InsertResult { Ok = true, TrackId = t, ShowDevices = t > 0, Status = Loc.F("Applied preset {0}", item.Name) };
+ return new InsertResult { Ok = true, TrackId = t, ShowDevices = t > 0, Status = Loc.F("device_insert.applied_preset", item.Name) };
}
// A factory kit. On a Drum Rack or Nota Rhythm it replaces the pads / voices; anywhere else
// it spawns its own track — a Drum Rack, or a Rhythm for a row under Rhythm.
private InsertResult ApplyKit(BrowserItem item, InsertTarget target)
{
- if (_kits is null) return InsertResult.Fail(Loc.T("Kits are unavailable."));
+ if (_kits is null) return InsertResult.Fail(Loc.T("device_insert.kits_are_unavailable"));
bool rhythm = item.Path.StartsWith(RhythmKitPrefix, StringComparison.Ordinal);
string id = item.Path[(rhythm ? RhythmKitPrefix.Length : KitPrefix.Length)..];
int t = target.TrackId;
if (!target.NewTrack && t > 0 && _engine.TrackInstrumentKind(t) is 4 or RhythmModel.Kind)
{
_kits.LoadInto(_engine, t, id, out string replaceWarn);
- return new InsertResult { Ok = true, TrackId = t, ShowDevices = true, Status = replaceWarn.Length > 0 ? replaceWarn : Loc.F("Loaded {0} kit", item.Name) };
+ return new InsertResult { Ok = true, TrackId = t, ShowDevices = true, Status = replaceWarn.Length > 0 ? replaceWarn : Loc.F("device_insert.loaded_kit", item.Name) };
}
int track = rhythm ? _kits.CreateRhythmTrack(_engine, id, out string warn) : _kits.CreateTrack(_engine, id, out warn);
- if (track <= 0) return InsertResult.Fail(warn.Length > 0 ? warn : Loc.F("Couldn't load {0}.", item.Name));
+ if (track <= 0) return InsertResult.Fail(warn.Length > 0 ? warn : Loc.F("common.couldnt_load", item.Name));
_engine.AddMidiClip(track, 0.0, 4.0);
- return new InsertResult { Ok = true, TrackId = track, CreatedTrack = true, ShowDevices = true, Status = warn.Length > 0 ? warn : Loc.F("Loaded {0} kit", item.Name) };
+ return new InsertResult { Ok = true, TrackId = track, CreatedTrack = true, ShowDevices = true, Status = warn.Length > 0 ? warn : Loc.F("device_insert.loaded_kit", item.Name) };
}
// ---- helpers ----------------------------------------------------------------------------
@@ -620,7 +620,7 @@ public sealed class DeviceInsertService
{
_engine.BeginUndoGroup();
try { return body(); }
- catch (Exception ex) { return InsertResult.Fail(Loc.F("Drop failed: {0}", ex.Message)); }
+ catch (Exception ex) { return InsertResult.Fail(Loc.F("device_insert.drop_failed", ex.Message)); }
finally { _engine.EndUndoGroup(); }
}
}
diff --git a/src/managed/Nota.Presentation/DeviceSelection.cs b/src/managed/Nota.Presentation/DeviceSelection.cs
index 9c861c4b..1f3c3a1c 100644
--- a/src/managed/Nota.Presentation/DeviceSelection.cs
+++ b/src/managed/Nota.Presentation/DeviceSelection.cs
@@ -103,16 +103,16 @@ public sealed class DeviceSelection
bool inst = HasInstrument;
static bool Consecutive(List<int> l) => l.Count == 0 || l[^1] - l[0] == l.Count - 1;
GroupShape Refuse(string why) => new(GroupShapeKind.Refused, -1, 0, false, -1, 0, why);
- if (!Consecutive(midi) || !Consecutive(fx)) return Refuse(Loc.T("Select devices next to each other to group them"));
+ if (!Consecutive(midi) || !Consecutive(fx)) return Refuse(Loc.T("device_selection.select_devices_next_to_each"));
int mf = midi.Count > 0 ? midi[0] : -1, ff = fx.Count > 0 ? fx[0] : -1;
if (inst)
{
- if (midi.Count > 0 && midi[^1] != midiCount - 1) return Refuse(Loc.T("Select devices next to each other to group them"));
- if (fx.Count > 0 && ff != 0) return Refuse(Loc.T("Select devices next to each other to group them"));
+ if (midi.Count > 0 && midi[^1] != midiCount - 1) return Refuse(Loc.T("device_selection.select_devices_next_to_each"));
+ if (fx.Count > 0 && ff != 0) return Refuse(Loc.T("device_selection.select_devices_next_to_each"));
return new(GroupShapeKind.InstrumentRack, mf, midi.Count, true, ff, fx.Count, null);
}
if (midi.Count > 0 && fx.Count > 0)
- return Refuse(Loc.T("MIDI and audio effects go in one rack only with the instrument between them"));
+ return Refuse(Loc.T("device_selection.midi_and_audio_effects_go"));
return midi.Count > 0
? new(GroupShapeKind.MidiRack, mf, midi.Count, false, -1, 0, null)
: new(GroupShapeKind.AudioRack, -1, 0, false, ff, fx.Count, null);
diff --git a/src/managed/Nota.Presentation/PaletteProviders.cs b/src/managed/Nota.Presentation/PaletteProviders.cs
index 5a8914cb..0708726b 100644
--- a/src/managed/Nota.Presentation/PaletteProviders.cs
+++ b/src/managed/Nota.Presentation/PaletteProviders.cs
@@ -37,27 +37,27 @@ public sealed class TrackPaletteProvider(IAudioEngine engine) : IPaletteProvider
{
if (!engine.TryGetTrackInfo(i, out var ti)) continue;
string name = engine.GetTrackName(ti.Id);
- if (string.IsNullOrWhiteSpace(name)) name = Loc.F("Track {0}", ti.Id);
+ if (string.IsNullOrWhiteSpace(name)) name = Loc.F("common.track_n", ti.Id);
string type, alias;
- if (ti.IsGroup) { type = Loc.T("Group"); alias = "group folder"; }
- else if (ti.IsReturn) { type = Loc.T("Return"); alias = "return send bus aux"; }
+ if (ti.IsGroup) { type = Loc.T("common.group"); alias = "group folder"; }
+ else if (ti.IsReturn) { type = Loc.T("common.return"); alias = "return send bus aux"; }
else if (ti.IsInstrument)
{
string inst = engine.DeviceName(ti.Id, -1);
- type = inst.Length > 0 ? Loc.F("MIDI · {0}", inst) : "MIDI";
+ type = inst.Length > 0 ? Loc.F("palette_providers.midi_caps", inst) : "MIDI";
alias = "midi instrument";
}
- else { type = Loc.T("Audio"); alias = "audio"; }
+ else { type = Loc.T("common.audio"); alias = "audio"; }
list.Add(new PaletteItem
{
- Kind = PaletteKind.Track, Id = "t:" + ti.Id, Name = name, Sub = type, Tag = Loc.T("Track"),
+ Kind = PaletteKind.Track, Id = "t:" + ti.Id, Name = name, Sub = type, Tag = Loc.T("common.track"),
Aliases = alias.Split(' '), Payload = ti.Id,
});
}
if (engine.MasterTrackId > 0)
list.Add(new PaletteItem
{
- Kind = PaletteKind.Track, Id = "t:" + engine.MasterTrackId, Name = Loc.T("Master"), Sub = Loc.T("Master"), Tag = Loc.T("Track"),
+ Kind = PaletteKind.Track, Id = "t:" + engine.MasterTrackId, Name = Loc.T("common.master"), Sub = Loc.T("common.master"), Tag = Loc.T("common.track"),
Aliases = ["master", "main", "output"], Payload = engine.MasterTrackId,
});
return list;
@@ -114,9 +114,9 @@ public sealed class DevicePaletteProvider(BrowserViewModel browser) : IPalettePr
internal static string TypeLabel(PaletteDeviceRole r) => r switch
{
- PaletteDeviceRole.Instrument => Loc.T("Instrument"),
- PaletteDeviceRole.MidiEffect => Loc.T("MIDI FX"),
- _ => Loc.T("Audio FX"),
+ PaletteDeviceRole.Instrument => Loc.T("common.instrument"),
+ PaletteDeviceRole.MidiEffect => Loc.T("palette_providers.midi_fx_caps"),
+ _ => Loc.T("palette_providers.audio_fx"),
};
}
@@ -137,7 +137,7 @@ public sealed class PresetPaletteProvider(BrowserViewModel browser) : IPalettePr
foreach (var c in dev.Children)
{
if (c.Kind == BrowserItemKind.Folder) foreach (var p in c.Children) list.Add(Item(p, dev.Name, c.Name, role, desc));
- else if (c.Kind == BrowserItemKind.Preset) list.Add(Item(c, dev.Name, DeviceInsertService.IsKit(c) ? Loc.T("Kits") : "", role, desc));
+ else if (c.Kind == BrowserItemKind.Preset) list.Add(Item(c, dev.Name, DeviceInsertService.IsKit(c) ? Loc.T("palette_providers.kits") : "", role, desc));
}
}
// User presets: category folder → device folder → preset.
@@ -168,7 +168,7 @@ public sealed class PresetPaletteProvider(BrowserViewModel browser) : IPalettePr
if (user) sub += " · user";
return new PaletteItem
{
- Kind = PaletteKind.Preset, Id = "p:" + p.Path, Name = p.Name, Sub = sub, Tag = Loc.T("Preset"), Role = role,
+ Kind = PaletteKind.Preset, Id = "p:" + p.Path, Name = p.Name, Sub = sub, Tag = Loc.T("palette_providers.preset"), Role = role,
PresetOrigin = origin, Descriptor = PresetDescriptors.For(deviceDesc, folder, p.Name),
OwnDescriptor = PresetDescriptors.Own(folder, p.Name),
Device = device, Folder = folder, Payload = p, CanPreview = !kit && !user,
@@ -183,7 +183,7 @@ public sealed class ModularPaletteProvider : IPaletteProvider
public IReadOnlyList<PaletteItem> Build() => ModularCatalog.All.Select(n => new PaletteItem
{
- Kind = PaletteKind.Modular, Id = "m:" + n.Kind, Name = n.Name, Sub = Loc.F("Modular · {0}", n.Sub), Tag = Loc.T("Modular"),
+ Kind = PaletteKind.Modular, Id = "m:" + n.Kind, Name = n.Name, Sub = Loc.F("palette_providers.modular", n.Sub), Tag = Loc.T("common.modular"),
Role = PaletteDeviceRole.Modular, Descriptor = n.Descriptor, Payload = n.Kind,
}).ToList();
}
diff --git a/src/managed/Nota.Presentation/ViewModels/BrowserViewModel.cs b/src/managed/Nota.Presentation/ViewModels/BrowserViewModel.cs
index 9a2339da..17af0921 100644
--- a/src/managed/Nota.Presentation/ViewModels/BrowserViewModel.cs
+++ b/src/managed/Nota.Presentation/ViewModels/BrowserViewModel.cs
@@ -357,7 +357,7 @@ public sealed partial class BrowserViewModel : ObservableObject
var list = _mosaic.Presets();
if (list.Count > 0)
{
- var packs = new BrowserItem { Name = Loc.T("Packs"), Kind = BrowserItemKind.Folder, Path = $"category:{mosaicDev.LibraryKey}/Packs", Depth = 1 };
+ var packs = new BrowserItem { Name = Loc.T("browser.packs"), Kind = BrowserItemKind.Folder, Path = $"category:{mosaicDev.LibraryKey}/Packs", Depth = 1 };
foreach (var g in list.GroupBy(p => p.Folder))
{
var folder = new BrowserItem { Name = g.Key, Kind = BrowserItemKind.Folder, Path = $"category:{mosaicDev.LibraryKey}/Packs/{g.Key}", Depth = 2 };
@@ -552,7 +552,7 @@ public sealed partial class BrowserViewModel : ObservableObject
collapsed = _collapsedSections.Contains(key);
dst.Add(new BrowserItem
{
- Name = node.IsPlugin ? Loc.T("PLUG-INS") : Loc.T("BUILT-IN"),
+ Name = node.IsPlugin ? Loc.T("browser.plug_ins_caps") : Loc.T("browser.built_in_caps"),
Kind = BrowserItemKind.Group,
Path = key,
IsExpanded = !collapsed,
@@ -752,7 +752,7 @@ public sealed partial class BrowserViewModel : ObservableObject
var rootNode = new BrowserItem
{
- Name = Loc.T("Nota Kits"),
+ Name = Loc.T("browser.nota_kits"),
Kind = BrowserItemKind.Folder,
Sub = "factory",
Path = root,
@@ -809,7 +809,7 @@ public sealed partial class BrowserViewModel : ObservableObject
Name = segments[i],
Kind = BrowserItemKind.Folder,
Sub = "",
- Tip = downloads ? Loc.T("sample packs installed from Settings → Downloads") : "",
+ Tip = downloads ? Loc.T("browser.sample_packs_installed_from_settings") : "",
Path = abs,
Depth = i,
IsExpanded = _expandedTreeKeys.Contains(abs),
@@ -937,11 +937,11 @@ public sealed partial class BrowserViewModel : ObservableObject
{
string cat = CategoryOf(p.Type);
bool noDevice = string.IsNullOrWhiteSpace(p.DeviceName);
- string dev = noDevice ? Loc.T("Other") : p.DeviceName;
+ string dev = noDevice ? Loc.T("common.other") : p.DeviceName;
// The ids (the keys and Paths) stay English so a remembered open folder survives a language change;
// only the shown name is translated.
var catNode = GetOrAddPresetFolder(cats, cat, CategoryName(cat), $"presetcat:{cat}", depth: 0, parent: _presetTree);
- var devNode = GetOrAddPresetFolder(devs, $"{cat}/{dev}", noDevice ? Loc.T("Other") : dev, $"presetdev:{cat}/{dev}", depth: 1, parent: catNode.Children);
+ var devNode = GetOrAddPresetFolder(devs, $"{cat}/{dev}", noDevice ? Loc.T("common.other") : dev, $"presetdev:{cat}/{dev}", depth: 1, parent: catNode.Children);
devNode.Children.Add(new BrowserItem
{
Name = p.DisplayName,
@@ -964,9 +964,9 @@ public sealed partial class BrowserViewModel : ObservableObject
// The shown name of a category id from CategoryOf.
private static string CategoryName(string category) => category switch
{
- "MIDI Effects" => Loc.T("MIDI Effects"),
- "Instruments" => Loc.T("Instruments"),
- _ => Loc.T("Audio Effects"),
+ "MIDI Effects" => Loc.T("browser.midi_effects"),
+ "Instruments" => Loc.T("common.instruments"),
+ _ => Loc.T("browser.audio_effects"),
};
// Fetches or creates a preset-tree folder node (category or device), keyed for expansion
diff --git a/src/managed/Nota.Presentation/ViewModels/DropoutCounter.cs b/src/managed/Nota.Presentation/ViewModels/DropoutCounter.cs
index 4b5637c0..2eaf5dc8 100644
--- a/src/managed/Nota.Presentation/ViewModels/DropoutCounter.cs
+++ b/src/managed/Nota.Presentation/ViewModels/DropoutCounter.cs
@@ -34,5 +34,5 @@ public sealed class DropoutCounter
}
/// <summary>"0 dropouts", "1 dropout", "3 dropouts".</summary>
- public static string Text(int count) => Loc.Plural(count, "{0} dropout", "{0} dropouts");
+ public static string Text(int count) => Loc.Plural("dropout_counter.dropouts", count);
}
diff --git a/src/managed/Nota.Presentation/ViewModels/MainWindowViewModel.cs b/src/managed/Nota.Presentation/ViewModels/MainWindowViewModel.cs
index a71a18ae..49805190 100644
--- a/src/managed/Nota.Presentation/ViewModels/MainWindowViewModel.cs
+++ b/src/managed/Nota.Presentation/ViewModels/MainWindowViewModel.cs
@@ -142,7 +142,7 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
_log.Info(ev == AudioDeviceEvent.ResetRequested ? "Audio driver asked for a reset" : "Audio driver stopped responding");
ApplyAudioSettings();
if (ev == AudioDeviceEvent.ResetRequested && Engine.ActiveAudioSystem == AudioSystem.Asio)
- StatusText = Loc.F("Audio: driver settings changed · {0} frames", Engine.NegotiatedBufferFrames);
+ StatusText = Loc.F("main.audio_driver_settings_changed_frames", Engine.NegotiatedBufferFrames);
if (wasPlaying && Engine.IsRunning)
{
Engine.Seek(position);
@@ -168,7 +168,7 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
_log.Warn($"Audio dropout #{count}");
if (!_dropouts.Observe(count)) return; // all from before the last reset: logged only
ShowDropouts();
- StatusText = Loc.F("⚠ Audio dropout ({0})", _dropouts.Count);
+ StatusText = Loc.F("main.audio_dropout", _dropouts.Count);
}
/// <summary>Count dropouts from zero again (#271): a click on the status bar's counter,
@@ -199,7 +199,7 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
{
_applyAfterPanel = true;
RefusedSampleRate = 0; // the old refusal no longer answers this new request
- StatusText = Loc.T("Close the driver's settings window to apply the change");
+ StatusText = Loc.T("main.close_the_drivers_settings_window");
return StatusText;
}
@@ -215,7 +215,7 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
catch (NotaEngineException ex)
{
_log.Error("Audio device apply failed", ex);
- StatusText = Loc.F("Audio device error: {0}", ex.Message);
+ StatusText = Loc.F("main.audio_device_error", ex.Message);
return StatusText;
}
finally
@@ -245,19 +245,19 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
}
if (Engine.ActiveAudioSystem == AudioSystem.Asio)
{
- StatusText = Loc.F("Audio: ASIO · {0} · {1:0}\u2009Hz · {2} frames", AsioDriverName(), Engine.NegotiatedSampleRate, buf);
+ StatusText = Loc.F("main.audio_asio_hz_frames", AsioDriverName(), Engine.NegotiatedSampleRate, buf);
return StatusText;
}
bool fallback = Engine.AudioExclusiveFallback;
if (fallback)
{
_log.Warn("WASAPI exclusive mode refused — fell back to shared");
- StatusText = Loc.T("WASAPI exclusive unavailable — using shared mode");
+ StatusText = Loc.T("main.wasapi_exclusive_unavailable_using_shared");
return StatusText;
}
StatusText = buf > 0
- ? Loc.F("Audio: {0:0}\u2009Hz · {1} frames", Engine.NegotiatedSampleRate, buf)
- : Loc.F("Audio: {0:0}\u2009Hz", Engine.NegotiatedSampleRate);
+ ? Loc.F("main.audio_hz_frames", Engine.NegotiatedSampleRate, buf)
+ : Loc.F("main.audio_hz", Engine.NegotiatedSampleRate);
return StatusText;
}
@@ -306,7 +306,7 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
if (Engine.AudioSystem != AudioSystem.Asio || Engine.ActiveAudioSystem == AudioSystem.Asio) return null;
string reason = Engine.AudioFallbackReason;
if (reason.Length > 0) reason = char.ToUpperInvariant(reason[0]) + reason[1..] + ".";
- return Loc.F("ASIO driver ‘{0}’ couldn't start — using WASAPI. {1}", AsioDriverName(), reason).TrimEnd();
+ return Loc.F("main.asio_driver_couldnt_start_using", AsioDriverName(), reason).TrimEnd();
}
/// <summary>Display name of the staged ASIO driver (the first installed when none is staged).</summary>
@@ -322,8 +322,8 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
/// <summary>Why nothing is heard when no output device opened (the engine runs silently
/// or not at all), else null.</summary>
public string? NoAudioOutput
- => !Engine.IsRunning ? Loc.T("No audio output could be opened — Nota runs without sound. Choose a device in Settings → Audio")
- : Engine.AudioSilentFallback ? Loc.T("No audio output device opened — Nota runs silently. Choose a device in Settings → Audio")
+ => !Engine.IsRunning ? Loc.T("main.no_audio_output_could_be")
+ : Engine.AudioSilentFallback ? Loc.T("main.no_audio_output_device_opened")
: null;
/// <summary>
@@ -337,12 +337,12 @@ public sealed partial class MainWindowViewModel : ObservableObject, IDisposable
{
Engine.ApplyMidi();
_log.Info("MIDI inputs updated");
- StatusText = Loc.T("MIDI inputs updated.");
+ StatusText = Loc.T("main.midi_inputs_updated");
}
catch (NotaEngineException ex)
{
_log.Error("MIDI apply failed", ex);
- StatusText = Loc.F("MIDI error: {0}", ex.Message);
+ StatusText = Loc.F("main.midi_error", ex.Message);
}
}
diff --git a/src/managed/Nota.Presentation/ViewModels/TransportViewModel.cs b/src/managed/Nota.Presentation/ViewModels/TransportViewModel.cs
index 8b1f4d9a..2b096bca 100644
--- a/src/managed/Nota.Presentation/ViewModels/TransportViewModel.cs
+++ b/src/managed/Nota.Presentation/ViewModels/TransportViewModel.cs
@@ -46,7 +46,7 @@ public partial class TransportViewModel(IAudioEngine engine) : ObservableObject
[ObservableProperty] private bool _recordOn;
/// <summary>Which clock the position readout is showing, printed under it so the
/// number is never ambiguous (transport console, mockup 1b).</summary>
- [ObservableProperty] private string _positionUnitText = Loc.T("bars");
+ [ObservableProperty] private string _positionUnitText = Loc.T("transport.bars");
private bool _revertingRec;
@@ -152,9 +152,9 @@ public partial class TransportViewModel(IAudioEngine engine) : ObservableObject
_revertingRec = true; RecordOn = false; _revertingRec = false;
Message?.Invoke(_engine.RecordStartStatus switch
{
- 1 => Loc.T("Can't record: arm a track first (click Arm on a track header)."),
- 2 => Loc.T("Can't record: no audio input — grant microphone access (needs a bundled app)."),
- _ => Loc.T("Recording didn't start."),
+ 1 => Loc.T("transport.cant_record_arm_a_track"),
+ 2 => Loc.T("transport.cant_record_no_audio_input"),
+ _ => Loc.T("transport.recording_didnt_start"),
});
}
@@ -180,7 +180,7 @@ public partial class TransportViewModel(IAudioEngine engine) : ObservableObject
double here = _engine.PositionBeats;
StopAll();
if (!counting) _engine.Seek(here); // a count-in hasn't moved anything yet
- Message?.Invoke(Loc.T("Paused · Play carries on from here"));
+ Message?.Invoke(Loc.T("transport.paused_play_carries_on_from"));
}
else _engine.PlayWithCountIn();
}
@@ -214,7 +214,7 @@ public partial class TransportViewModel(IAudioEngine engine) : ObservableObject
{
ShowTimeDisplay = !ShowTimeDisplay;
if (IsCountingIn) return; // the readout is showing the count-in; Tick restores it
- PositionUnitText = ShowTimeDisplay ? Loc.T("time") : Loc.T("bars");
+ PositionUnitText = ShowTimeDisplay ? Loc.T("transport.time") : Loc.T("transport.bars");
UpdatePositionText(_lastBeats); // reflect immediately, don't wait for the next tick
}
@@ -228,7 +228,7 @@ public partial class TransportViewModel(IAudioEngine engine) : ObservableObject
IsCountingIn = countIn > 0;
if (IsCountingIn) PositionText = CountInText(countIn);
else UpdatePositionText(beats);
- if (IsCountingIn != wasCounting) PositionUnitText = IsCountingIn ? Loc.T("count-in") : ShowTimeDisplay ? Loc.T("time") : Loc.T("bars");
+ if (IsCountingIn != wasCounting) PositionUnitText = IsCountingIn ? Loc.T("transport.count_in") : ShowTimeDisplay ? Loc.T("transport.time") : Loc.T("transport.bars");
IsPlaying = _engine.IsPlaying || IsCountingIn; // the Play button lights from the first click
PlayLabel = IsPlaying ? "■ Stop" : "▶ Play";
// The loop record mode can also be set from outside the UI (MCP): follow the engine.
diff --git a/src/managed/Nota.Presentation/ViewModels/VersionSummary.cs b/src/managed/Nota.Presentation/ViewModels/VersionSummary.cs
index d3589be8..43e24e47 100644
--- a/src/managed/Nota.Presentation/ViewModels/VersionSummary.cs
+++ b/src/managed/Nota.Presentation/ViewModels/VersionSummary.cs
@@ -19,18 +19,18 @@ public static class VersionSummary
var parts = new List<string>();
if (c.First)
{
- parts.Add(c.TrackCount == 0 ? Loc.T("First save") : Loc.Plural(c.TrackCount, "First save · {0} track", "First save · {0} tracks"));
+ parts.Add(c.TrackCount == 0 ? Loc.T("version_summary.first_save") : Loc.Plural("version_summary.first_save_tracks", c.TrackCount));
return parts;
}
- if (c.TracksAdded.Count > 0) parts.Add(Loc.F("Added {0}", Names(c.TracksAdded)));
- if (c.TracksRemoved.Count > 0) parts.Add(Loc.F("Removed {0}", Names(c.TracksRemoved)));
+ if (c.TracksAdded.Count > 0) parts.Add(Loc.F("version_summary.added", Names(c.TracksAdded)));
+ if (c.TracksRemoved.Count > 0) parts.Add(Loc.F("version_summary.removed", Names(c.TracksRemoved)));
foreach (var r in c.TracksRenamed.Take(2)) parts.Add($"{r.From} → {r.To}");
- if (c.TempoFrom is { } tf && c.TempoTo is { } tt) parts.Add(Loc.F("Tempo {0} → {1}", tempo(tf), tempo(tt)));
+ if (c.TempoFrom is { } tf && c.TempoTo is { } tt) parts.Add(Loc.F("version_summary.tempo", tempo(tf), tempo(tt)));
if (c.MeterFrom is { } mf && c.MeterTo is { } mt) parts.Add($"{mf} → {mt}");
- if (c.NewAudio > 0) parts.Add(c.NewAudio == 1 ? Loc.T("New audio") : Loc.F("{0} new audio files", c.NewAudio));
- if (c.Edited.Count > 0) parts.Add(Loc.F("Edited {0}", Names(c.Edited)));
- if (c.Sound.Count > 0) parts.Add(Loc.F("Devices on {0}", Names(c.Sound)));
- if (c.Mix.Count > 0) parts.Add(c.Mix.Count > 2 ? Loc.Plural(c.Mix.Count, "Mix of {0} track", "Mix of {0} tracks") : Loc.F("Mix of {0}", Names(c.Mix)));
+ if (c.NewAudio > 0) parts.Add(c.NewAudio == 1 ? Loc.T("version_summary.new_audio") : Loc.F("version_summary.new_audio_files", c.NewAudio));
+ if (c.Edited.Count > 0) parts.Add(Loc.F("version_summary.edited", Names(c.Edited)));
+ if (c.Sound.Count > 0) parts.Add(Loc.F("version_summary.devices_on", Names(c.Sound)));
+ if (c.Mix.Count > 0) parts.Add(c.Mix.Count > 2 ? Loc.Plural("version_summary.mix_of_tracks", c.Mix.Count) : Loc.F("version_summary.mix_of", Names(c.Mix)));
foreach (var o in c.Other) parts.Add(char.ToUpperInvariant(o[0]) + o[1..]);
return parts;
}
diff --git a/tests/Nota.SmokeTest/DesignTokenCheck.Labels.cs b/tests/Nota.SmokeTest/DesignTokenCheck.Labels.cs
index 796d2581..f6558d9e 100644
--- a/tests/Nota.SmokeTest/DesignTokenCheck.Labels.cs
+++ b/tests/Nota.SmokeTest/DesignTokenCheck.Labels.cs
@@ -138,10 +138,17 @@ internal static partial class DesignTokenCheck
foreach (Capture c in m.Groups["lit"].Captures)
{
if (!seen.Add(c.Index)) continue;
- // Loc.T("…") / Loc.F("…") (spec 068): still a label for the style rules, but
- // not a raw literal for the localization ratchet, which passes false.
- if (!includeWrapped && Regex.IsMatch(code[..c.Index], @"Loc\.(?:T|F)\(\s*$")) continue;
+ // Loc.T("key") / Loc.F("key") (specs 068, 077): still a label for the style
+ // rules — checked as the English text of its key — but not a raw literal
+ // for the localization ratchet, which passes false.
+ bool wrapped = Regex.IsMatch(code[..c.Index], @"Loc\.(?:T|F)\(\s*$");
+ if (!includeWrapped && wrapped) continue;
var body = c.Value[1..^1];
+ if (wrapped && Nota.Application.Localization.Loc.English.TryGet(body, out var english))
+ {
+ yield return (n, english.Other, english.Other, viaBuilder || InsideLabelCall(code, c.Index));
+ continue;
+ }
yield return (n, body, Unescape(body), viaBuilder || InsideLabelCall(code, c.Index));
}
}
diff --git a/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs b/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs
index cea88c61..29c5bc11 100644
--- a/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs
+++ b/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs
@@ -1,14 +1,16 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
-// The interface language (spec 068), checked in two parts.
+// The interface language (spec 068, keyed since spec 077), checked in two parts.
//
-// RunLanguage the pure layer as data: the language-file contract, lookup and fallback,
-// plurals, invariant number format, the settings default and the real
-// Languages/*.json files.
-// RunLocalization the source against the translation: every Loc.T / F / FC / Plural key in
-// src/managed has a French entry (a missing one fails the build), none is
-// orphaned, placeholders match; and a shrink-only ratchet on interface text still written as a raw literal
+// RunLanguage the pure layer as data: the language-file contract on the shared fixtures
+// (Fixtures/Languages/verdicts.json), the key-set hash, lookup and fallback,
+// plural rules, invariant number format, the settings default and the real
+// en.json and Languages/*.json files.
+// RunLocalization the source against the English reference (spec 077): every Loc.T / F /
+// Plural and {app:T} key in src/managed is a well-formed key of en.json, every
+// en.json key is used, each is used the way it is shaped; French covers every
+// key validly; and a shrink-only ratchet on interface text still written as a raw literal
// (LocalizationAllowList.txt), the same technique as the label ratchet of
// spec 012. Wrapping a literal in Loc.T takes it off the list; a new raw
// literal fails until it is wrapped or listed as data.
@@ -34,15 +36,15 @@ internal static partial class DesignTokenCheck
{
var available = new[] { "en", "fr" };
- // Plural rules (data-model § Available languages).
- yield return (UiLanguage.Plural("en", 1) == PluralForm.One && UiLanguage.Plural("en", 0) == PluralForm.Other
- && UiLanguage.Plural("en", 2) == PluralForm.Other,
- "English: 1 is one; 0 and 2 are other");
- yield return (UiLanguage.Plural("fr", 0) == PluralForm.One && UiLanguage.Plural("fr", 1) == PluralForm.One
- && UiLanguage.Plural("fr", 2) == PluralForm.Other,
- "French: 0 and 1 are one; 2 is other");
- yield return (UiLanguage.Plural("xx", 1) == PluralForm.One && UiLanguage.Plural("xx", 0) == PluralForm.Other,
- "a language with no rule counts like English");
+ // Plural rules, named by the language file (spec 077 research R6).
+ yield return (UiLanguage.Plural(UiLanguage.RuleOneIs1, 1) == PluralForm.One && UiLanguage.Plural(UiLanguage.RuleOneIs1, 0) == PluralForm.Other
+ && UiLanguage.Plural(UiLanguage.RuleOneIs1, 2) == PluralForm.Other,
+ "one_is_1 (English): 1 is one; 0 and 2 are other");
+ yield return (UiLanguage.Plural(UiLanguage.RuleOneIs0Or1, 0) == PluralForm.One && UiLanguage.Plural(UiLanguage.RuleOneIs0Or1, 1) == PluralForm.One
+ && UiLanguage.Plural(UiLanguage.RuleOneIs0Or1, 2) == PluralForm.Other,
+ "one_is_0_1 (French): 0 and 1 are one; 2 is other");
+ yield return (UiLanguage.IsKnownRule("one_is_1") && UiLanguage.IsKnownRule("one_is_0_1") && !UiLanguage.IsKnownRule("one_is_42") && !UiLanguage.IsKnownRule(null),
+ "only the plural rules this build implements are known");
// Stored value → running language.
yield return (UiLanguage.Normalize(null, available) == "en" && UiLanguage.Normalize("", available) == "en"
@@ -73,61 +75,89 @@ internal static partial class DesignTokenCheck
yield return (UiLanguage.Normalize(edited.Language, available) == "en" && edited.Language == "zz" && edited.InterfaceScale == 125,
"an unknown stored language runs as English and is not rewritten by reading it");
- // The language-file contract (contracts/translation-file.md).
- const string frJson = """
- { "formatVersion": 1, "code": "fr", "name": "Français", "strings": {
- "Save": "Enregistrer",
- "Open|menu": "Ouvrir",
- "Open|clip": "Ouvrir le clip",
- "Blank": "",
- "Bad {0}": "Mauvais {",
- "{0} tracks": { "one": "{0} piste", "other": "{0} pistes" },
- "{0} clips": { "other": "{0} clips FR" },
- "Brace {0}": "Accolade {{x}} {0}"
- } }
- """;
- var fr = TranslationTable.Parse(frJson, out var frError);
- yield return (fr is not null && fr.Code == "fr" && fr.Name == "Français" && fr.Count == 8,
- fr is null ? "a language file parses: " + frError : "a language file parses (8 texts)");
- if (fr is null) yield break;
+ // The language-file contract (spec 077 contracts/language-file.md), on the shared fixtures.
+ var root = RepoRoot();
+ if (root is null) { yield return (false, "repo root located"); yield break; }
+ var fixtures = Path.Combine(root, "tests/Nota.SmokeTest/Fixtures/Languages");
+ TranslationTable? Fixture(string name, out string? error) => TranslationTable.Parse(File.ReadAllText(Path.Combine(fixtures, name)), out error);
+ var english = Fixture("en-ref.json", out var enError);
+ yield return (english is not null && english.Count == 12 && english.PluralRule == UiLanguage.RuleOneIs1,
+ english is null ? "the fixture reference parses: " + enError : "the fixture reference parses (12 keys, English counting)");
+ if (english is null) yield break;
+
+ using (var verdicts = JsonDocument.Parse(File.ReadAllText(Path.Combine(fixtures, "verdicts.json"))))
+ foreach (var v in verdicts.RootElement.GetProperty("files").EnumerateObject())
+ {
+ var table = Fixture(v.Name, out var error);
+ bool loads = v.Value.GetProperty("loads").GetBoolean();
+ if (!loads) { yield return (table is null && error is not null, $"{v.Name}: rejected with a reason ({error ?? "accepted!"})"); continue; }
+ if (table is null) { yield return (false, $"{v.Name}: should load: {error}"); continue; }
+ var (problems, coverage) = table.ValidateAgainst(english);
+ var got = problems.Select(p => p.Key).Distinct().Order(StringComparer.Ordinal).ToList();
+ var want = v.Value.GetProperty("problems").EnumerateArray().Select(e => e.GetString()!).Order(StringComparer.Ordinal).ToList();
+ int wantCoverage = v.Value.GetProperty("coverage").GetInt32();
+ yield return (got.SequenceEqual(want) && coverage == wantCoverage,
+ $"{v.Name}: problems [{string.Join(", ", got)}], coverage {coverage} % (verdicts.json: [{string.Join(", ", want)}], {wantCoverage} %)");
+ }
string? e1, e2, e3, e4, e5, e6;
- yield return (TranslationTable.Parse("{\"formatVersion\":2,\"code\":\"xx\",\"name\":\"X\"}", out e1) is null && e1 is not null,
- "a newer formatVersion is left out with a reason, not thrown");
- yield return (TranslationTable.Parse("{ not json", out e2) is null && e2 is not null, "malformed JSON is left out with a reason, not thrown");
- yield return (TranslationTable.Parse("{\"formatVersion\":1,\"code\":\"xx\",\"name\":\"X\",\"strings\":{\"A\":\"1\",\"A\":\"2\"}}", out e3) is null && e3 is not null,
+ yield return (TranslationTable.Parse("{ not json", out e1) is null && e1 is not null, "malformed JSON is left out with a reason, not thrown");
+ yield return (TranslationTable.Parse("{\"formatVersion\":2,\"code\":\"xx\",\"name\":\"X\",\"plural\":\"one_is_1\",\"strings\":{\"a.b\":\"1\",\"a.b\":\"2\"}}", out e2) is null && e2 is not null,
"a duplicate key is an error");
- yield return (TranslationTable.Parse("{\"formatVersion\":1,\"code\":\"xx\",\"name\":\"X\",\"strings\":{\"A\":5}}", out e4) is null && e4 is not null,
- "a text that is neither a string nor a plural object is an error");
- yield return (TranslationTable.Parse("{\"formatVersion\":1,\"code\":\"FR\",\"name\":\"X\"}", out e5) is null
- && TranslationTable.Parse("{\"formatVersion\":1,\"code\":\"xx\"}", out e6) is null,
+ yield return (TranslationTable.Parse("{\"formatVersion\":2,\"code\":\"FR\",\"name\":\"X\",\"plural\":\"one_is_1\"}", out e3) is null
+ && TranslationTable.Parse("{\"formatVersion\":2,\"code\":\"xx\",\"plural\":\"one_is_1\"}", out e4) is null,
"an upper-case code or a missing name is an error");
-
- // Lookup and fallback, with French running.
- Loc.ResetForTests();
+ yield return (TranslationTable.Parse("{\"formatVersion\":2,\"code\":\"xx\",\"name\":\"X\"}", out e5) is null && e5 is not null
+ && TranslationTable.Parse("{\"formatVersion\":2,\"code\":\"en\",\"name\":\"English\"}", out e6) is not null,
+ "a translation must name its plural rule; English counts as one_is_1 without one");
+ yield return (TranslationTable.IsKey("main.save_as") && TranslationTable.IsKey("device.eq8.band_2") && !TranslationTable.IsKey("Save")
+ && !TranslationTable.IsKey("main") && !TranslationTable.IsKey("main.Save") && !TranslationTable.IsKey("main..save")
+ && !TranslationTable.IsKey("a." + new string('b', 80)),
+ "keys are lower-case dot-separated segments, at least two, up to 80 characters");
+
+ // The key-set hash: the identity of a Nota version's keys (contract § Key-set hash).
+ string Reference(string strings) => $"{{\"formatVersion\":2,\"code\":\"en\",\"name\":\"English\",\"strings\":{{{strings}}}}}";
+ string Hash(string strings) => TranslationTable.Parse(Reference(strings), out _)!.KeySetHash();
+ var h = Hash("\"a.b\":\"Save {0}\",\"a.c\":{\"one\":\"{0} x\",\"other\":\"{0} xs\"}");
+ yield return (h.Length == 16 && h == Hash("\"a.c\":{\"one\":\"{0} y\",\"other\":\"{0} ys\"},\"a.b\":\"Keep {0} safe\""),
+ "the key-set hash ignores wording and order");
+ yield return (h != Hash("\"a.b\":\"Save {0}\"") && h != Hash("\"a.b\":\"Save {0} {1}\",\"a.c\":{\"one\":\"{0} x\",\"other\":\"{0} xs\"}")
+ && h != Hash("\"a.b\":\"Save {0}\",\"a.c\":\"{0} xs\""),
+ "the key-set hash changes with a removed key, new placeholders or a text that stops being counted");
+
+ // Lookup and fallback, on the fixture reference.
+ var xx = Fixture("xx.json", out _)!;
+ var broken = Fixture("xx-broken.json", out _)!;
+ Loc.ResetForTests(english);
yield return (!Loc.UsedBeforeInstall, "nothing has been asked for yet");
- _ = Loc.T("anything");
- yield return (Loc.UsedBeforeInstall, "a text asked for before Install is flagged");
- Loc.ResetForTests();
+ yield return (Loc.T("test.save") == "Save" && Loc.UsedBeforeInstall, "before Install a text is English, and flagged");
+ Loc.ResetForTests(english);
Loc.Install(null, "en");
- _ = Loc.T("anything");
- yield return (!Loc.UsedBeforeInstall && Loc.Language == "en", "after Install nothing is flagged");
-
- Loc.Install(fr, "fr");
- yield return (Loc.Language == "fr", "French is running");
- yield return (Loc.T("Save") == "Enregistrer", "a translated text is returned");
- yield return (Loc.T("Never translated") == "Never translated", "a missing text is its English original");
- yield return (Loc.T("Open", "menu") == "Ouvrir" && Loc.T("Open", "clip") == "Ouvrir le clip", "a context picks the meaning");
- yield return (Loc.T("Open") == "Open" && Loc.T("Close", "menu") == "Close", "no context leaks into the shown text");
- yield return (Loc.T("Blank") == "Blank", "an empty translation is never shown blank");
- yield return (Loc.Plural(0, "{0} track", "{0} tracks") == "0 piste" && Loc.Plural(1, "{0} track", "{0} tracks") == "1 piste"
- && Loc.Plural(2, "{0} track", "{0} tracks") == "2 pistes",
- "French counts 0 and 1 as one");
- yield return (Loc.Plural(1, "{0} clip", "{0} clips") == "1 clips FR", "a counted text with no singular form uses its other form");
- yield return (Loc.Plural(1, "{0} take", "{0} takes") == "1 take" && Loc.Plural(0, "{0} take", "{0} takes") == "0 takes",
- "a counted text with no entry falls back to English and its rule");
- yield return (Loc.F("Bad {0}", 1) == "Bad 1", "a broken pattern in a language file falls back to English, not an exception");
- yield return (Loc.F("Brace {0}", 7) == "Accolade {x} 7", "{{ }} are literal braces");
+ yield return (Loc.T("test.save") == "Save" && !Loc.UsedBeforeInstall && Loc.Language == "en", "after Install nothing is flagged");
+ yield return (Loc.Plural("test.tracks", 1) == "1 track" && Loc.Plural("test.tracks", 0) == "0 tracks" && Loc.F("test.delete_clips", 3) == "Delete 3 clips?",
+ "English running: counted and formatted texts read as the reference has them");
+ string? missing = null;
+ void OnMissing(string k) => missing = k;
+ Loc.MissingKey += OnMissing;
+ var shown = Loc.T("test.not_in_any_table");
+ Loc.MissingKey -= OnMissing;
+ yield return (shown == "test.not_in_any_table" && missing == "test.not_in_any_table", "a key in no table shows itself and is reported");
+
+ Loc.Install(xx, "xx");
+ yield return (Loc.Language == "xx" && Loc.T("test.save") == "Xsave", "a translated text is returned");
+ yield return (Loc.T("test.open_menu") == "Xopen" && Loc.T("test.open_clip") == "Xopen clip", "two meanings of one English word are two keys");
+ yield return (Loc.T("test.blank") == "Blank" && Loc.F("test.delete_clips", 3) == "Delete 3 clips?", "a text the language lacks is English");
+ yield return (Loc.Plural("test.tracks", 1) == "1 xtrack" && Loc.Plural("test.tracks", 0) == "0 xtracks", "a one_is_1 language counts like English");
+ yield return (Loc.Plural("test.takes", 1) == "1 take" && Loc.Plural("test.takes", 0) == "0 takes", "a counted text the language lacks falls back to English and its rule");
+
+ Loc.Install(broken, "xx");
+ yield return (Loc.Plural("test.tracks", 0) == "0 piste" && Loc.Plural("test.tracks", 1) == "1 piste" && Loc.Plural("test.tracks", 2) == "2 pistes",
+ "a one_is_0_1 language counts 0 and 1 as one");
+ yield return (Loc.Plural("test.clips", 1) == "1 clips FR", "a counted text with no singular form uses its other form");
+ yield return (Loc.F("test.bad", 1) == "Bad 1" && Loc.F("test.delete_clips", 2) == "Delete 2 clips?",
+ "an entry with the wrong placeholders shows English, not an exception");
+ yield return (Loc.T("test.save") == "Save" && Loc.T("test.blank") == "Blank", "an entry of the wrong shape, or empty, shows English");
+ yield return (Loc.F("test.brace", 7) == "Accolade {x} 7", "{{ }} are literal braces");
// Numbers follow the thread culture, as the interpolated strings they replace did; the
// language never changes that culture.
@@ -136,54 +166,37 @@ internal static partial class DesignTokenCheck
try
{
CultureInfo.CurrentCulture = new CultureInfo("fr-FR");
- notation = Loc.F("{0}", 1.5) + "|" + Loc.Plural(2, "{0} bar", "{0} bars");
+ notation = Loc.F("test.number", 1.5) + "|" + Loc.Plural("test.bars", 2);
}
catch (CultureNotFoundException) { notation = "1,5|2 bars"; }
finally { CultureInfo.CurrentCulture = before; }
yield return (notation == "1,5|2 bars", "numbers format with the thread culture, which the language leaves alone");
- Loc.Install(fr, "fr");
+ Loc.Install(xx, "xx");
yield return (before.Name == CultureInfo.CurrentCulture.Name, "installing a language leaves the thread culture alone");
- // English running: every call is its own text.
- Loc.Install(fr, "en");
- yield return (Loc.T("Save") == "Save" && Loc.T("Open", "menu") == "Open" && Loc.Plural(1, "{0} track", "{0} tracks") == "1 track",
- "English running: wrapping a text never changes it");
- yield return (Loc.Plural(2, "{0} track", "{0} tracks") == "2 tracks" && Loc.F("Delete {0} clips?", 3) == "Delete 3 clips?",
- "English running: counted and formatted texts read as written");
+ // English running ignores any table passed in.
+ Loc.Install(xx, "en");
+ yield return (Loc.T("test.save") == "Save" && Loc.Plural("test.tracks", 1) == "1 track", "English running: a table passed in is not used");
- // A language the app does not ship, from a fixture: any file in the format works (spec 068 US5).
- var fixtureRoot = RepoRoot();
- if (fixtureRoot is not null)
- {
- var xx = TranslationTable.Parse(File.ReadAllText(Path.Combine(fixtureRoot, "tests/Nota.SmokeTest/Fixtures/Languages/xx.json")), out var xxError);
- yield return (xx is not null && xx.Code == "xx" && xx.Name == "Xxxx", xx is null ? "the fixture language parses: " + xxError : "the fixture language parses");
- if (xx is not null)
- {
- Loc.Install(xx, "xx");
- yield return (Loc.T("Save") == "Xsave" && Loc.T("Open", "menu") == "Xopen" && Loc.T("Open", "clip") == "Xopen clip",
- "a new language translates its texts, contexts included");
- yield return (Loc.T("Never written") == "Never written" && Loc.F("Delete {0} clips?", 3) == "Delete 3 clips?",
- "a text the new language does not cover shows in English");
- yield return (Loc.Plural(1, "{0} track", "{0} tracks") == "1 xtrack" && Loc.Plural(0, "{0} track", "{0} tracks") == "0 xtracks",
- "a language with no plural rule counts like English");
- }
- }
- Loc.Install(fr, "en");
-
- // The real language files, from disk.
- var root = RepoRoot();
- if (root is null) { yield return (false, "repo root located"); yield break; }
+ // The real English reference and language files, from disk.
+ Loc.ResetForTests();
+ var real = Loc.English;
+ yield return (Loc.EnglishError is null && real.Count > 1000 && real.Code == "en" && real.Problems.Count == 0,
+ Loc.EnglishError is null ? $"the embedded English reference is valid ({real.Count} keys, key set {real.KeySetHash()})" : "the embedded English reference: " + Loc.EnglishError);
+ var onDisk = TranslationTable.Parse(File.ReadAllText(Path.Combine(root, "src/managed/Nota.Application/Localization/en.json")), out _);
+ yield return (onDisk is not null && onDisk.KeySetHash() == real.KeySetHash(), "the embedded English is the en.json in the source");
var dir = Path.Combine(root, "src/managed/Nota.App/Languages");
var files = Directory.EnumerateFiles(dir, "*.json").OrderBy(f => f, StringComparer.Ordinal).ToArray();
foreach (var file in files)
{
var id = Path.GetFileNameWithoutExtension(file)!;
var table = TranslationTable.Parse(File.ReadAllText(file), out var error);
- yield return (table is not null && table.Code == id, table is null ? $"{id}.json: {error}" : $"{id}.json: valid ({table.Name}, {table.Count} texts)");
+ yield return (table is not null && table.Code == id && id != "en",
+ table is null ? $"{id}.json: {error}" : $"{id}.json: valid ({table.Name}, {table.Count} texts, rule {table.PluralRule})");
}
var names = files.Select(f => TranslationTable.Parse(File.ReadAllText(f), out _)).Where(t => t is not null)
.ToDictionary(t => t!.Code, t => t!.Name);
- yield return (names.GetValueOrDefault("en") == "English" && names.GetValueOrDefault("fr") == "Français",
+ yield return (real.Name == "English" && names.GetValueOrDefault("fr") == "Français",
"the picker offers English and Français, each by its own name");
Loc.ResetForTests();
@@ -193,23 +206,24 @@ internal static partial class DesignTokenCheck
// ---- The source against the translation ------------------------------------------------
private const string LocLit = @"""(?:[^""\\\n]|\\.)*""";
- private static readonly Regex LocT = new($@"\bLoc\.T\(\s*(?<t>{LocLit})(?:\s*,\s*(?:context:\s*)?(?<c>{LocLit}))?");
- private static readonly Regex LocF = new($@"\bLoc\.F\(\s*(?<t>{LocLit})");
- private static readonly Regex LocFC = new($@"\bLoc\.FC\(\s*(?<c>{LocLit})\s*,\s*(?<t>{LocLit})");
- private static readonly Regex LocPlural = new($@"\bLoc\.Plural\([^""]*?,\s*(?<one>{LocLit})\s*,\s*(?<t>{LocLit})(?:\s*,\s*(?:context:\s*)?(?<c>{LocLit}))?");
- private static readonly Regex LocInterpolated = new(@"\bLoc\.(?:T|F)\(\s*[$@]+""|\bLoc\.FC\(\s*""[^""]*""\s*,\s*[$@]+""");
- private static readonly Regex LocPlaceholder = new(@"\{(\d+)(?:[,:][^{}]*)?\}");
- // The XAML form: Header="{app:T 'Save as…'}" or {app:T File}, optionally with ", Context=menu".
- private static readonly Regex LocXaml = new(@"\{app:T\s+(?:'(?<t>(?:[^'\\]|\\.)*)'|(?<t>[^\s'},][^},]*?))\s*(?:,\s*Context=(?<c>[^}\s]+))?\s*\}");
-
- private static HashSet<int> Placeholders(string s)
- => LocPlaceholder.Matches(s.Replace("{{", "").Replace("}}", "")).Select(m => int.Parse(m.Groups[1].Value)).ToHashSet();
-
- private readonly record struct LocKey(string Key, bool Plural, string Path, int Line);
-
- /// <summary>Every Loc.T / F / FC / Plural call in src/managed with a literal text, plus the
- /// calls whose text is interpolated (which can never be translated).</summary>
- private static (List<LocKey> Keys, List<Hit> Interpolated) LocCalls(string root)
+ // The keyed calls (spec 077): Loc.T("key"), Loc.F("key", …), Loc.Plural("key", n).
+ // The key must be the whole argument: ")" after a T key, "," (or ")") after an F or Plural
+ // key — so Loc.T("common.cancel" + suffix) is a computed key, not "common.cancel".
+ private static readonly Regex LocKeyed = new($@"\bLoc\.(?<k>T|F|Plural)\(\s*(?<t>{LocLit})\s*(?<end>[,)])");
+ private static readonly Regex LocAnyCall = new(@"\bLoc\.(?:T|F|Plural)\(");
+ // The XAML form: Header="{app:T 'main.save_as'}" (quotes optional).
+ private static readonly Regex LocXaml = new(@"\{app:T\s+(?:'(?<t>[^']*)'|(?<t>[^\s'},]+))\s*\}");
+ private static readonly Regex LocXamlAny = new(@"\{app:T\b");
+
+ // FormatArg: the call is the pattern of a string.Format(culture, Loc.T(key), …) — a text with
+ // placeholders formatted in a culture of the caller's choosing (NotaNum.Culture), not Loc.F's.
+ private readonly record struct LocKey(string Key, char Kind, string Path, int Line, bool FormatArg = false);
+ private static readonly Regex FormatOpen = new(@"\bstring\.Format\([^;()]*,\s*$");
+
+ /// <summary>Every Loc.T / F / Plural call in src/managed and every {app:T …} in XAML, with its
+ /// key, plus the calls whose key is not a plain literal (interpolated or computed), which the
+ /// source cannot be checked against.</summary>
+ private static (List<LocKey> Keys, List<Hit> NotLiteral) LocCalls(string root)
{
var managed = Path.Combine(root, "src/managed");
var keys = new List<LocKey>();
@@ -217,82 +231,140 @@ internal static partial class DesignTokenCheck
foreach (var f in SourceFiles(managed, ".cs"))
{
var rel = RelManaged(root, f);
- if (rel.StartsWith("Nota.Application/Localization/")) continue; // its own examples
+ if (rel.StartsWith("Nota.Application/Localization/") || rel == "Nota.App/TExtension.cs") continue; // the API itself
var text = string.Join('\n', File.ReadLines(f).Select(CodeOf));
if (!text.Contains("Loc.")) continue;
- int LineOf(int index) { int n = 1; for (int i = 0; i < index; i++) if (text[i] == '\n') n++; return n; }
- string Key(Match m) => TranslationTable.KeyOf(Unescape(m.Groups["t"].Value[1..^1]),
- m.Groups["c"].Success ? Unescape(m.Groups["c"].Value[1..^1]) : null);
- foreach (Match m in LocT.Matches(text)) keys.Add(new LocKey(Key(m), false, rel, LineOf(m.Index)));
- foreach (Match m in LocF.Matches(text)) keys.Add(new LocKey(Key(m), false, rel, LineOf(m.Index)));
- foreach (Match m in LocFC.Matches(text)) keys.Add(new LocKey(Key(m), false, rel, LineOf(m.Index)));
- foreach (Match m in LocPlural.Matches(text)) keys.Add(new LocKey(Key(m), true, rel, LineOf(m.Index)));
- foreach (Match m in LocInterpolated.Matches(text)) bad.Add(new Hit(rel, LineOf(m.Index), m.Value));
+ ScanLocCalls(rel, text, keys, bad);
}
foreach (var f in SourceFiles(managed, ".axaml"))
{
var rel = RelManaged(root, f);
var text = BlankXmlComments(File.ReadAllText(f));
+ int LineOf(int index) { int n = 1; for (int i = 0; i < index; i++) if (text[i] == '\n') n++; return n; }
+ var literal = new HashSet<int>();
foreach (Match m in LocXaml.Matches(text))
{
- int line = 1; for (int i = 0; i < m.Index; i++) if (text[i] == '\n') line++;
- keys.Add(new LocKey(TranslationTable.KeyOf(WebUtility.HtmlDecode(m.Groups["t"].Value).Replace("\\'", "'"),
- m.Groups["c"].Success ? m.Groups["c"].Value : null), false, rel, line));
+ literal.Add(m.Index);
+ keys.Add(new LocKey(WebUtility.HtmlDecode(m.Groups["t"].Value), 'T', rel, LineOf(m.Index)));
}
+ foreach (Match m in LocXamlAny.Matches(text))
+ if (!literal.Contains(m.Index)) bad.Add(new Hit(rel, LineOf(m.Index), text.Substring(m.Index, Math.Min(60, text.Length - m.Index))));
}
return (keys, bad);
}
+ /// <summary>The Loc calls of one C# text (comments already removed): keys named by a plain
+ /// literal that is the whole key argument go to <paramref name="keys"/>, every other Loc call
+ /// to <paramref name="bad"/>.</summary>
+ private static void ScanLocCalls(string rel, string text, List<LocKey> keys, List<Hit> bad)
+ {
+ int LineOf(int index) { int n = 1; for (int i = 0; i < index; i++) if (text[i] == '\n') n++; return n; }
+ var literal = new HashSet<int>();
+ foreach (Match m in LocKeyed.Matches(text))
+ {
+ char kind = m.Groups["k"].Value[0];
+ bool whole = kind == 'T' ? m.Groups["end"].Value == ")" : kind == 'F' || m.Groups["end"].Value == ",";
+ if (!whole) continue;
+ literal.Add(m.Index);
+ keys.Add(new LocKey(Unescape(m.Groups["t"].Value[1..^1]), kind, rel, LineOf(m.Index),
+ FormatOpen.IsMatch(text[Math.Max(0, m.Index - 200)..m.Index])));
+ }
+ foreach (Match m in LocAnyCall.Matches(text))
+ if (!literal.Contains(m.Index)) bad.Add(new Hit(rel, LineOf(m.Index), text.Substring(m.Index, Math.Min(60, text.Length - m.Index))));
+ }
+
public static IEnumerable<(bool Ok, string Label)> RunLocalization()
{
var root = RepoRoot();
if (root is null) { yield return (false, "repo root located"); yield break; }
- // -- coverage: source keys ↔ the French file --
- var (calls, interpolated) = LocCalls(root);
- yield return (interpolated.Count == 0,
- interpolated.Count == 0 ? "no Loc call passes an interpolated string (build the pattern with {0} and Loc.F)"
- : "interpolated text in a Loc call can never be translated: " + string.Join(", ", interpolated.Take(8).Select(h => $"{h.Path}:{h.Line}")));
+ // -- the source against the English reference (spec 077 FR-006) --
+ var (calls, notLiteral) = LocCalls(root);
+ yield return (notLiteral.Count == 0,
+ notLiteral.Count == 0 ? "every Loc call and {app:T} names its key as a plain literal"
+ : "a Loc call whose key is computed or interpolated can never be checked: " + string.Join(", ", notLiteral.Take(8).Select(h => $"{h.Path}:{h.Line}")));
+
+ // The scanner itself (review of #479): a key is only a key when it is the whole argument.
+ {
+ var k = new List<LocKey>();
+ var b = new List<Hit>();
+ ScanLocCalls("sample.cs", string.Join('\n',
+ "a = Loc.T(\"common.cancel\");",
+ "b = Loc.F(\"main.pdc\", ms);",
+ "c = Loc.Plural(\"main.clips\", n);",
+ "d = Loc.T(\"common.cancel\" + suffix);",
+ "e = Loc.F(\"main.pdc\" + suffix, ms);",
+ "f = Loc.Plural(\"main.clips\");",
+ "g = Loc.T(key);",
+ "h = Loc.T( \"common.close\" );"), k, b);
+ var found = string.Join(",", k.Select(x => x.Kind + ":" + x.Key));
+ var flagged = string.Join(",", b.Select(x => x.Key[..Math.Min(x.Key.Length, 12)]));
+ yield return (found == "T:common.cancel,F:main.pdc,P:main.clips,T:common.close" && b.Count == 4,
+ $"the key scanner takes only whole literal keys and flags the rest (keys {found}; flagged {b.Count}: {flagged})");
+ }
+
+ var badKeys = calls.Where(c => !TranslationTable.IsKey(c.Key)).ToList();
+ yield return (badKeys.Count == 0,
+ badKeys.Count == 0 ? $"all {calls.Count} Loc calls use well-formed keys (area.segment…, lower-case)"
+ : "not a key (an English text, or a malformed key): " + string.Join(", ", badKeys.Take(8).Select(c => $"\"{c.Key}\" at {c.Path}:{c.Line}")));
+
+ var enPath = Path.Combine(root, "src/managed/Nota.Application/Localization/en.json");
+ var en = TranslationTable.Parse(File.ReadAllText(enPath), out var enError);
+ yield return (en is not null && en.Problems.Count == 0,
+ en is null ? "en.json: " + enError : en.Problems.Count == 0 ? $"en.json parsed ({en.Count} keys)"
+ : "en.json entries that cannot be used: " + string.Join("; ", en.Problems.Take(6).Select(p => $"{p.Key} — {p.Problem}")));
+ if (en is null) yield break;
+
+ var unformattable = en.Keys.Order(StringComparer.Ordinal)
+ .Select(k => (k, en.TryGet(k, out var t) ? TranslationTable.PatternProblem(t.Other) ?? (t.One is null ? null : TranslationTable.PatternProblem(t.One)) : null))
+ .Where(x => x.Item2 is not null).ToList();
+ yield return (unformattable.Count == 0,
+ unformattable.Count == 0 ? "every English text formats (braces and placeholders 0–9)"
+ : "English texts that cannot be formatted: " + string.Join("; ", unformattable.Take(6).Select(x => $"{x.k} — {x.Item2}")));
var used = new Dictionary<string, LocKey>(StringComparer.Ordinal);
foreach (var c in calls) if (!used.ContainsKey(c.Key)) used[c.Key] = c;
+ var missing = calls.Where(c => !en.TryGet(c.Key, out _)).ToList();
+ yield return (missing.Count == 0,
+ missing.Count == 0 ? $"every key used in the source is in en.json ({used.Count} keys)"
+ : $"{missing.Count} keys used in the source are not in en.json (add them): " + string.Join(", ", missing.Take(8).Select(c => $"\"{c.Key}\" at {c.Path}:{c.Line}")));
+ var unused = en.Keys.Where(k => !used.ContainsKey(k)).Order(StringComparer.Ordinal).ToList();
+ yield return (unused.Count == 0,
+ unused.Count == 0 ? "every key in en.json is used by the source"
+ : $"en.json keys nothing uses (delete them): {string.Join(", ", unused.Take(8))}" + (unused.Count > 8 ? $" (+{unused.Count - 8} more)" : ""));
+
+ // Every call, not one per key: a text counted in one place and plain in another is a bug.
+ var shape = new List<string>();
+ foreach (var c in calls)
+ {
+ if (!en.TryGet(c.Key, out var e)) continue;
+ if ((c.Kind == 'P') != e.IsPlural)
+ shape.Add($"\"{c.Key}\" at {c.Path}:{c.Line} ({(c.Kind == 'P' ? "Loc.Plural, but en.json has a plain text" : "a plain text call, but en.json counts it")})");
+ else if (c.Kind == 'T' && !c.FormatArg && TranslationTable.Placeholders(e.Other).Count > 0)
+ shape.Add($"\"{c.Key}\" at {c.Path}:{c.Line} (Loc.T of a text with placeholders — use Loc.F)");
+ else if (c.Kind == 'P' && !TranslationTable.Placeholders(e.Other).IsSubsetOf(new HashSet<int> { 0 }))
+ shape.Add($"\"{c.Key}\" at {c.Path}:{c.Line} (a counted text has only {{0}}, the count)");
+ }
+ yield return (shape.Count == 0,
+ shape.Count == 0 ? "each key is used the way en.json shapes it (counted, formatted or plain)"
+ : "key used against its shape: " + string.Join("; ", shape.Take(6)));
+ // -- French, still embedded until the languages move to nota-translations (spec 077 PR 3) --
var frPath = Path.Combine(root, "src/managed/Nota.App/Languages/fr.json");
var fr = TranslationTable.Parse(File.ReadAllText(frPath), out var frError);
yield return (fr is not null, fr is null ? "fr.json: " + frError : "fr.json parsed");
if (fr is null) yield break;
-
- var frKeys = fr.Keys.ToHashSet(StringComparer.Ordinal);
- var missing = used.Keys.Where(k => !frKeys.Contains(k)).OrderBy(k => k, StringComparer.Ordinal).ToList();
- // NOTA_LOC_DUMP_MISSING=<file> writes the texts French still lacks (key, counted?, file) as JSON.
+ var (frProblems, frCoverage) = fr.ValidateAgainst(en);
+ var frMissing = en.Keys.Where(k => !fr.TryGet(k, out _)).Order(StringComparer.Ordinal).ToList();
+ // NOTA_LOC_DUMP_MISSING=<file> writes the keys French still lacks (key, English, counted?, file) as JSON.
if (Environment.GetEnvironmentVariable("NOTA_LOC_DUMP_MISSING") is { Length: > 0 } dump)
- File.WriteAllText(dump, JsonSerializer.Serialize(missing.Select(k => new { key = k, plural = used[k].Plural, file = used[k].Path, line = used[k].Line })));
- yield return (missing.Count == 0,
- missing.Count == 0 ? $"French covers all {used.Count} interface texts in Loc calls"
- : $"{missing.Count} texts have no French: {string.Join(", ", missing.Take(8).Select(k => $"\"{k}\""))}");
-
- var orphans = frKeys.Where(k => !used.ContainsKey(k)).OrderBy(k => k, StringComparer.Ordinal).ToList();
- yield return (orphans.Count == 0,
- orphans.Count == 0 ? "every French text is used by a Loc call"
- : $"French texts no Loc call uses (renamed or removed in the source — fix or delete them): {string.Join(", ", orphans.Take(8).Select(k => $"\"{k}\""))}"
- + (orphans.Count > 8 ? $" (+{orphans.Count - 8} more)" : ""));
-
- var parity = new List<string>();
- foreach (var key in fr.Keys.OrderBy(k => k, StringComparer.Ordinal))
- {
- fr.TryGet(key, out var t);
- var want = Placeholders(key);
- if (!Placeholders(t.Other).SetEquals(want)) parity.Add($"\"{key}\" (other form has {{{string.Join(",", Placeholders(t.Other).Order())}}}, key has {{{string.Join(",", want.Order())}}})");
- // The singular form may drop the number ("Une piste") but may not invent a placeholder.
- else if (t.One is not null && !Placeholders(t.One).IsSubsetOf(want)) parity.Add($"\"{key}\" (singular form has a placeholder the key lacks)");
- }
- // Every call, not one per key: a text counted in one place and plain in another is a bug in the plain one.
- foreach (var c in calls)
- if (fr.TryGet(c.Key, out var ct) && c.Plural != (ct.One is not null))
- parity.Add($"\"{c.Key}\" at {c.Path}:{c.Line} ({(c.Plural ? "counted in the source but has no singular form" : "plain in the source but has a singular form")})");
- yield return (parity.Count == 0,
- parity.Count == 0 ? "French placeholders match their English and counted texts have both forms"
- : "French placeholder or plural mismatch: " + string.Join("; ", parity.Take(6)));
+ File.WriteAllText(dump, JsonSerializer.Serialize(frMissing.Select(k => new { key = k, english = en.TryGet(k, out var t) ? t.Other : "", plural = t.IsPlural, file = used.GetValueOrDefault(k).Path })));
+ yield return (frMissing.Count == 0,
+ frMissing.Count == 0 ? $"French covers all {en.Count} keys ({frCoverage} %)"
+ : $"{frMissing.Count} keys have no French: {string.Join(", ", frMissing.Take(8))}");
+ yield return (frProblems.Count == 0,
+ frProblems.Count == 0 ? "every French entry is a key of en.json with its shape and placeholders"
+ : "French entries that cannot be used: " + string.Join("; ", frProblems.Take(6).Select(p => $"{p.Key} — {p.Problem}")));
// -- the language is a view setting: it follows only the stored choice, and writes nothing --
var osLanguage = new List<string>();
diff --git a/tests/Nota.SmokeTest/Fixtures/Languages/en-ref.json b/tests/Nota.SmokeTest/Fixtures/Languages/en-ref.json
new file mode 100644
index 00000000..b915fe7b
--- /dev/null
+++ b/tests/Nota.SmokeTest/Fixtures/Languages/en-ref.json
@@ -0,0 +1,20 @@
+{
+ "formatVersion": 2,
+ "code": "en",
+ "name": "English",
+ "notes": "Test fixture for spec 077: a small English reference the language-layer checks run against.",
+ "strings": {
+ "test.save": "Save",
+ "test.open_menu": "Open",
+ "test.open_clip": "Open clip",
+ "test.blank": "Blank",
+ "test.bad": "Bad {0}",
+ "test.brace": "Brace {0}",
+ "test.delete_clips": "Delete {0} clips?",
+ "test.number": "{0}",
+ "test.tracks": { "one": "{0} track", "other": "{0} tracks" },
+ "test.clips": { "one": "{0} clip", "other": "{0} clips" },
+ "test.takes": { "one": "{0} take", "other": "{0} takes" },
+ "test.bars": { "one": "{0} bar", "other": "{0} bars" }
+ }
+}
diff --git a/tests/Nota.SmokeTest/Fixtures/Languages/verdicts.json b/tests/Nota.SmokeTest/Fixtures/Languages/verdicts.json
new file mode 100644
index 00000000..cfd85773
--- /dev/null
+++ b/tests/Nota.SmokeTest/Fixtures/Languages/verdicts.json
@@ -0,0 +1,10 @@
+{
+ "notes": "Expected results of reading each fixture and checking it against en-ref.json (spec 077 research R11). The app's smoke test and nota-translations/tools/validate.py must both agree with this file.",
+ "reference": "en-ref.json",
+ "files": {
+ "xx.json": { "loads": true, "problems": [], "coverage": 33 },
+ "xx-broken.json": { "loads": true, "problems": ["Not A Key", "test.bad", "test.bars", "test.blank", "test.delete_clips", "test.number", "test.save", "test.unknown"], "coverage": 25 },
+ "xx-v1.json": { "loads": false },
+ "xx-badrule.json": { "loads": false }
+ }
+}
diff --git a/tests/Nota.SmokeTest/Fixtures/Languages/xx-badrule.json b/tests/Nota.SmokeTest/Fixtures/Languages/xx-badrule.json
new file mode 100644
index 00000000..26bc3dee
--- /dev/null
+++ b/tests/Nota.SmokeTest/Fixtures/Languages/xx-badrule.json
@@ -0,0 +1,8 @@
+{
+ "formatVersion": 2,
+ "code": "xx",
+ "name": "Xxxx",
+ "plural": "one_is_42",
+ "notes": "Test fixture for spec 077: a plural rule this build does not know.",
+ "strings": { "test.save": "Xsave" }
+}
diff --git a/tests/Nota.SmokeTest/Fixtures/Languages/xx-broken.json b/tests/Nota.SmokeTest/Fixtures/Languages/xx-broken.json
new file mode 100644
index 00000000..e580fcf2
--- /dev/null
+++ b/tests/Nota.SmokeTest/Fixtures/Languages/xx-broken.json
@@ -0,0 +1,20 @@
+{
+ "formatVersion": 2,
+ "code": "xx",
+ "name": "Xxxx broken",
+ "plural": "one_is_0_1",
+ "notes": "Test fixture for spec 077: a language that loads, with entries that cannot be used (see verdicts.json).",
+ "strings": {
+ "Not A Key": "x",
+ "test.blank": "",
+ "test.bad": "Mauvais {1}",
+ "test.delete_clips": "Mauvais {",
+ "test.save": { "one": "Xsave one", "other": "Xsave" },
+ "test.unknown": "Xunknown",
+ "test.tracks": { "one": "{0} piste", "other": "{0} pistes" },
+ "test.clips": { "other": "{0} clips FR" },
+ "test.brace": "Accolade {{x}} {0}",
+ "test.number": "{0,abc}",
+ "test.bars": { "one": "{99999999999999999999} mesure", "other": "{0} mesures" }
+ }
+}
diff --git a/tests/Nota.SmokeTest/Fixtures/Languages/xx-v1.json b/tests/Nota.SmokeTest/Fixtures/Languages/xx-v1.json
new file mode 100644
index 00000000..c6ef9133
--- /dev/null
+++ b/tests/Nota.SmokeTest/Fixtures/Languages/xx-v1.json
@@ -0,0 +1,7 @@
+{
+ "formatVersion": 1,
+ "code": "xx",
+ "name": "Xxxx",
+ "notes": "Test fixture for spec 077: the text-keyed format of spec 068, no longer read.",
+ "strings": { "Save": "Xsave" }
+}
diff --git a/tests/Nota.SmokeTest/Fixtures/Languages/xx.json b/tests/Nota.SmokeTest/Fixtures/Languages/xx.json
index 1b02cda7..8f2cf112 100644
--- a/tests/Nota.SmokeTest/Fixtures/Languages/xx.json
+++ b/tests/Nota.SmokeTest/Fixtures/Languages/xx.json
@@ -1,12 +1,13 @@
{
- "formatVersion": 1,
+ "formatVersion": 2,
"code": "xx",
"name": "Xxxx",
- "notes": "Test fixture for spec 068: a language the app does not ship. Not embedded.",
+ "plural": "one_is_1",
+ "notes": "Test fixture for specs 068 and 077: a valid language the app does not ship. Not embedded.",
"strings": {
- "Save": "Xsave",
- "Open|menu": "Xopen",
- "Open|clip": "Xopen clip",
- "{0} tracks": { "one": "{0} xtrack", "other": "{0} xtracks" }
+ "test.save": "Xsave",
+ "test.open_menu": "Xopen",
+ "test.open_clip": "Xopen clip",
+ "test.tracks": { "one": "{0} xtrack", "other": "{0} xtracks" }
}
}