Key binding in UI

Author: tommitytom

runtime/lvgljs/input.ts

@@ -82,6 +82,42 @@ function resolveKeyName(name: string): number | null {
     return null;
 }
 
+// Inverse of resolveKeyName: DPF key code → preferred symbolic name. Used
+// by the in-app bindings editor so that the user pressing e.g. KEY_ENTER
+// in capture mode lands "Enter" in the JSON (canonical) rather than
+// "Return" (synonym). Returns null for keys we don't know how to name.
+//
+// Multiple entries in KEY_NAME_TO_DPF collide on the same code (Enter /
+// Return both = 0x0D); the preferred-name table below picks one.
+const DPF_TO_KEY_NAME: Record<number, string> = {
+    [KEY_BACKSPACE]: "Backspace",
+    [KEY_TAB]:       "Tab",
+    [KEY_ENTER]:     "Enter",
+    [KEY_ESCAPE]:    "Escape",
+    [KEY_LEFT]:      "Left",
+    [KEY_UP]:        "Up",
+    [KEY_RIGHT]:     "Right",
+    [KEY_DOWN]:      "Down",
+    [KEY_SHIFT_L]:   "ShiftL",
+    [KEY_SHIFT_R]:   "ShiftR",
+};
+
+export function dpfKeyToName(code: number): string | null {
+    if (code in DPF_TO_KEY_NAME) return DPF_TO_KEY_NAME[code];
+    // Printable ASCII: keep case (so "Z" and "z" remain distinguishable).
+    if (code >= 0x20 && code <= 0x7E) return String.fromCharCode(code);
+    return null;
+}
+
+// List of every symbolic key name the loader understands, plus a single
+// representative of the printable-ASCII range. Useful for the editor's
+// "unbind / clear" affordance when the underlying file is multi-bind.
+export const KNOWN_KEY_NAMES: readonly string[] = [
+    "Backspace", "Tab", "Enter", "Escape",
+    "Left", "Up", "Right", "Down",
+    "ShiftL", "ShiftR",
+];
+
 // Runtime maps populated either from the hardcoded defaults below (initial
 // state) or from a user JSON profile (after installBindings runs).
 let keyMap_: Map<number, GameboyButton> = new Map();

src/PluginRpcRegistration.hpp

@@ -50,6 +50,10 @@ void registerPluginRpcMethods(Server& server) {
     server.template addMethod<&PluginRpcService::getUserConfig>();
     server.template addMethod<&PluginRpcService::setActiveKeyboardBindings>();
     server.template addMethod<&PluginRpcService::setActiveGamepadBindings>();
+    server.template addMethod<&PluginRpcService::getBindingProfile>();
+    server.template addMethod<&PluginRpcService::saveBindingProfile>();
+    server.template addMethod<&PluginRpcService::renameBindingProfile>();
+    server.template addMethod<&PluginRpcService::deleteBindingProfile>();
     server.template addMethod<&PluginRpcService::openSettingsFolder>();
     server.template addMethod<&PluginRpcService::saveSram>();
     server.template addMethod<&PluginRpcService::openSaveSramBrowser>();

src/PluginRpcService.cpp

@@ -887,6 +887,26 @@ bool PluginRpcService::setActiveGamepadBindings(std::string name) {
     return userConfig_->setActiveGamepadBindings(std::move(name));
 }
 
+std::optional<BindingMapJson> PluginRpcService::getBindingProfile(std::string name) {
+    if (!userConfig_) return std::nullopt;
+    return userConfig_->loadProfile(name);
+}
+
+bool PluginRpcService::saveBindingProfile(std::string name, BindingMapJson bindings) {
+    if (!userConfig_) return false;
+    return userConfig_->saveProfile(std::move(name), std::move(bindings));
+}
+
+bool PluginRpcService::renameBindingProfile(std::string oldName, std::string newName) {
+    if (!userConfig_) return false;
+    return userConfig_->renameProfile(std::move(oldName), std::move(newName));
+}
+
+bool PluginRpcService::deleteBindingProfile(std::string name) {
+    if (!userConfig_) return false;
+    return userConfig_->deleteProfile(std::move(name));
+}
+
 namespace {
 std::string defaultSavePath(const SystemBase& sys, const char* ext) {
     const std::string& romPath = sys.romPath();

src/PluginRpcService.hpp

@@ -250,6 +250,13 @@ class PluginRpcService {
     UserConfigDto getUserConfig();
     bool          setActiveKeyboardBindings(std::string name);
     bool          setActiveGamepadBindings(std::string name);
+    // In-app bindings editor surface. Validation rules live in
+    // UserConfig::isValidProfileName; all four return false / nullopt when
+    // userConfig_ is null (LV2-UI / rpc-schema-dump).
+    std::optional<BindingMapJson> getBindingProfile(std::string name);
+    bool          saveBindingProfile  (std::string name, BindingMapJson bindings);
+    bool          renameBindingProfile(std::string oldName, std::string newName);
+    bool          deleteBindingProfile(std::string name);
     // Launch the platform file manager on the user config directory. False if
     // we have no UserConfig wired or the shell-out call fails.
     bool          openSettingsFolder();

src/config/UserConfig.cpp

@@ -143,6 +143,118 @@ bool UserConfig::setActiveGamepadBindings(std::string name) {
     return true;
 }
 
+std::optional<BindingMapJson> UserConfig::loadProfile(std::string_view name) const {
+    if (!isValidProfileName(name)) return std::nullopt;
+    const fs::path p = bindingsDir_ / (std::string(name) + ".json");
+    auto text = slurp(p);
+    if (text.empty()) return std::nullopt;
+    return bindingMapFromJson(text);
+}
+
+bool UserConfig::isValidProfileName(std::string_view name) {
+    if (name.empty()) return false;
+    if (name == "config") return false;       // would collide with config.json
+    for (char c : name) {
+        const bool ok = (c >= 'a' && c <= 'z')
+                     || (c >= 'A' && c <= 'Z')
+                     || (c >= '0' && c <= '9')
+                     ||  c == '_' || c == '-';
+        if (!ok) return false;
+    }
+    return true;
+}
+
+bool UserConfig::saveProfile(std::string name, BindingMapJson bindings) {
+    if (!started_.load()) return false;
+    if (!isValidProfileName(name)) return false;
+    bindings.schemaVersion = 1;
+    bindings.name          = name;
+    const fs::path target  = bindingsDir_ / (name + ".json");
+    if (!atomicWrite(target, bindingMapToJson(bindings))) {
+        std::fprintf(stderr, "[user-config] failed to write %s\n",
+                     target.string().c_str());
+        return false;
+    }
+    reloadFromDisk();
+    if (onReload_) onReload_();
+    return true;
+}
+
+bool UserConfig::renameProfile(std::string oldName, std::string newName) {
+    if (!started_.load()) return false;
+    if (!isValidProfileName(oldName) || !isValidProfileName(newName)) return false;
+    if (oldName == newName) return true;
+    const fs::path src = bindingsDir_ / (oldName + ".json");
+    const fs::path dst = bindingsDir_ / (newName + ".json");
+    std::error_code ec;
+    if (!fs::exists(src, ec)) return false;
+    if (fs::exists(dst, ec)) return false;     // refuse to clobber
+
+    // If the source carries an embedded `name` field, rewrite it so the
+    // file's content matches its new filename (cosmetic — the loader uses
+    // the filename, not the field). Keeps hand-inspection sane.
+    if (auto text = slurp(src); !text.empty()) {
+        if (auto parsed = bindingMapFromJson(text)) {
+            parsed->name = newName;
+            const fs::path tmpRename = src.string() + ".renaming";
+            if (!atomicWrite(tmpRename, bindingMapToJson(*parsed))) return false;
+            fs::rename(tmpRename, src, ec);
+            if (ec) { fs::remove(tmpRename, ec); return false; }
+        }
+    }
+
+    fs::rename(src, dst, ec);
+    if (ec) return false;
+
+    // Repoint active profile references in config.json if needed.
+    bool rewrote = false;
+    UserConfigJson cfg;
+    cfg.schemaVersion = 1;
+    {
+        std::lock_guard<std::mutex> lock(mu_);
+        cfg.activeKeyboardBindings = current_.activeKeyboardBindings;
+        cfg.activeGamepadBindings  = current_.activeGamepadBindings;
+        cfg.defaultZoom            = current_.defaultZoom;
+        if (cfg.activeKeyboardBindings == oldName) {
+            cfg.activeKeyboardBindings = newName;
+            rewrote = true;
+        }
+        if (cfg.activeGamepadBindings == oldName) {
+            cfg.activeGamepadBindings = newName;
+            rewrote = true;
+        }
+    }
+    if (rewrote) {
+        if (!atomicWrite(configFile_, userConfigToJson(cfg))) {
+            std::fprintf(stderr, "[user-config] failed to update %s after rename\n",
+                         configFile_.string().c_str());
+            return false;
+        }
+    }
+
+    reloadFromDisk();
+    if (onReload_) onReload_();
+    return true;
+}
+
+bool UserConfig::deleteProfile(std::string name) {
+    if (!started_.load()) return false;
+    if (!isValidProfileName(name)) return false;
+    {
+        std::lock_guard<std::mutex> lock(mu_);
+        if (name == current_.activeKeyboardBindings) return false;
+        if (name == current_.activeGamepadBindings)  return false;
+    }
+    const fs::path target = bindingsDir_ / (name + ".json");
+    std::error_code ec;
+    if (!fs::exists(target, ec)) return false;
+    fs::remove(target, ec);
+    if (ec) return false;
+    reloadFromDisk();
+    if (onReload_) onReload_();
+    return true;
+}
+
 void UserConfig::reloadFromDisk() {
     UserConfigDto next;
     {

src/config/UserConfig.hpp

@@ -5,7 +5,9 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <string>
+#include <string_view>
 
 #include <efsw/efsw.hpp>
 
@@ -63,6 +65,32 @@ class UserConfig final : public efsw::FileWatchListener {
     bool setActiveKeyboardBindings(std::string name);
     bool setActiveGamepadBindings(std::string name);
 
+    // Read a single profile file from disk. Returns nullopt if the file
+    // doesn't exist or fails to parse. Used by the in-app bindings editor
+    // so it can edit one channel (keyboard or gamepad) of a profile
+    // without clobbering the other when saving.
+    std::optional<BindingMapJson> loadProfile(std::string_view name) const;
+
+    // Profile management used by the in-app bindings editor. All three
+    // validate `name` (and `newName`) as `[A-Za-z0-9_-]+`, refuse reserved
+    // stems ("config"), and refresh the in-memory snapshot synchronously
+    // before returning.
+    //
+    // saveProfile   — overwrites bindings/<name>.json (creates if missing).
+    // renameProfile — fs::rename; if `oldName` is the active keyboard or
+    //                 gamepad profile, config.json is rewritten to point
+    //                 at `newName` so the active reference stays valid.
+    // deleteProfile — refuses if `name` matches either active profile
+    //                 (caller must switch first); otherwise unlinks.
+    bool saveProfile  (std::string name, BindingMapJson bindings);
+    bool renameProfile(std::string oldName, std::string newName);
+    bool deleteProfile(std::string name);
+
+    // Validate a profile name: non-empty, contains only [A-Za-z0-9_-], and
+    // not equal to a reserved stem. Exposed for the RPC layer so the UI can
+    // surface the rejection without round-tripping a write.
+    static bool isValidProfileName(std::string_view name);
+
     // efsw callback — runs on a background thread. Only flips dirty_.
     void handleFileAction(efsw::WatchID,
                           const std::string& dir,

test/UserConfigTests.cpp

@@ -6,6 +6,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <algorithm>
 #include <chrono>
 #include <filesystem>
 #include <fstream>
@@ -167,6 +168,109 @@ TEST_CASE("UserConfig live-reloads when bindings file changes on disk", "[user-c
     fs::remove_all(dir);
 }
 
+TEST_CASE("UserConfig::saveProfile writes a new profile file", "[user-config]") {
+    auto dir = makeTempDir("save-profile");
+    UserConfig cfg(dir);
+    cfg.start();
+
+    BindingMapJson b;
+    b.keyboard["A"] = {"q"};
+    b.gamepad ["A"] = {"y"};
+    REQUIRE(cfg.saveProfile("custom", b));
+
+    REQUIRE(fs::exists(dir / "bindings" / "custom.json"));
+    auto loaded = cfg.loadProfile("custom");
+    REQUIRE(loaded.has_value());
+    REQUIRE(loaded->keyboard.at("A") == std::vector<std::string>{"q"});
+    REQUIRE(loaded->gamepad .at("A") == std::vector<std::string>{"y"});
+    REQUIRE(loaded->name == "custom");
+
+    auto snap = cfg.snapshot();
+    const auto& list = snap.availableProfiles;
+    REQUIRE(std::find(list.begin(), list.end(), std::string("custom")) != list.end());
+
+    fs::remove_all(dir);
+}
+
+TEST_CASE("UserConfig::saveProfile rejects invalid names", "[user-config]") {
+    auto dir = makeTempDir("save-invalid");
+    UserConfig cfg(dir);
+    cfg.start();
+
+    BindingMapJson b;
+    REQUIRE_FALSE(cfg.saveProfile("",        b));
+    REQUIRE_FALSE(cfg.saveProfile("config",  b));     // reserved
+    REQUIRE_FALSE(cfg.saveProfile("../etc",  b));     // path traversal
+    REQUIRE_FALSE(cfg.saveProfile("a b",     b));     // whitespace
+    REQUIRE_FALSE(cfg.saveProfile("a.b",     b));     // dot
+
+    fs::remove_all(dir);
+}
+
+TEST_CASE("UserConfig::renameProfile moves the file and updates active references", "[user-config]") {
+    auto dir = makeTempDir("rename-profile");
+    UserConfig cfg(dir);
+    cfg.start();
+
+    BindingMapJson b;
+    b.keyboard["A"] = {"j"};
+    REQUIRE(cfg.saveProfile("alpha", b));
+    REQUIRE(cfg.setActiveKeyboardBindings("alpha"));
+    REQUIRE(cfg.snapshot().activeKeyboardBindings == "alpha");
+
+    REQUIRE(cfg.renameProfile("alpha", "beta"));
+    REQUIRE_FALSE(fs::exists(dir / "bindings" / "alpha.json"));
+    REQUIRE(fs::exists(dir / "bindings" / "beta.json"));
+
+    auto snap = cfg.snapshot();
+    REQUIRE(snap.activeKeyboardBindings == "beta");
+    REQUIRE(snap.bindings.keyboard.at("A") == std::vector<std::string>{"j"});
+
+    // The renamed file's own `name` field was rewritten to match.
+    auto loaded = cfg.loadProfile("beta");
+    REQUIRE(loaded.has_value());
+    REQUIRE(loaded->name == "beta");
+
+    fs::remove_all(dir);
+}
+
+TEST_CASE("UserConfig::renameProfile refuses to clobber an existing file", "[user-config]") {
+    auto dir = makeTempDir("rename-conflict");
+    UserConfig cfg(dir);
+    cfg.start();
+
+    BindingMapJson b;
+    REQUIRE(cfg.saveProfile("alpha", b));
+    REQUIRE(cfg.saveProfile("beta",  b));
+
+    REQUIRE_FALSE(cfg.renameProfile("alpha", "beta"));
+    REQUIRE(fs::exists(dir / "bindings" / "alpha.json"));
+    REQUIRE(fs::exists(dir / "bindings" / "beta.json"));
+
+    fs::remove_all(dir);
+}
+
+TEST_CASE("UserConfig::deleteProfile refuses the active profile", "[user-config]") {
+    auto dir = makeTempDir("delete-active");
+    UserConfig cfg(dir);
+    cfg.start();
+
+    BindingMapJson b;
+    REQUIRE(cfg.saveProfile("alt", b));
+    REQUIRE(cfg.setActiveKeyboardBindings("alt"));
+
+    // Active keyboard profile — refused.
+    REQUIRE_FALSE(cfg.deleteProfile("alt"));
+    REQUIRE(fs::exists(dir / "bindings" / "alt.json"));
+
+    // Switch back, then delete succeeds.
+    REQUIRE(cfg.setActiveKeyboardBindings("default"));
+    REQUIRE(cfg.deleteProfile("alt"));
+    REQUIRE_FALSE(fs::exists(dir / "bindings" / "alt.json"));
+
+    fs::remove_all(dir);
+}
+
 TEST_CASE("UserConfig keeps previous snapshot AND leaves file alone on malformed JSON", "[user-config]") {
     auto dir = makeTempDir("malformed");