Merge pull request #60 from dreamer-coding/add_input_api_key_binding

dreamer-coding · web-flow · commit 6ca5162a5d5e · 2025-09-05T21:34:52.000-07:00
diff --git a/code/logic/fossil/io/input.h b/code/logic/fossil/io/input.h
@@ -172,9 +172,85 @@ void fossil_io_show_progress(int progress);
  */
 int fossil_io_gets(char *buffer, size_t size);
 
+/**
+ * @brief Type for representing a key binding.
+ */
+typedef void (*fossil_io_action_callback_t)(void);
+
+typedef struct {
+    int key_code;                         /**< The integer key code (e.g., ASCII or special code). */
+    const char *action;                    /**< The action string associated with this key. */
+    fossil_io_action_callback_t callback;  /**< Optional function to call when key is pressed. */
+} fossil_io_keybinding_t;
+
+/**
+ * @brief Registers a new key binding.
+ *
+ * Adds a key-action mapping to the input library.
+ *
+ * @param key_code The integer key code to bind.
+ * @param action The action string associated with the key.
+ * @return 0 on success, non-zero on failure (e.g., duplicate key).
+ */
+int fossil_io_register_keybinding(int key_code, const char *action);
+
+/**
+ * @brief Removes an existing key binding.
+ *
+ * @param key_code The key code of the binding to remove.
+ * @return 0 on success, non-zero if the key was not found.
+ */
+int fossil_io_unregister_keybinding(int key_code);
+
+/**
+ * Registers a new key binding with optional callback.
+ */
+int fossil_io_register_keybinding_with_callback(int key_code, const char *action, fossil_io_action_callback_t cb);
+
+/**
+ * @brief Retrieves the action associated with a key code.
+ *
+ * @param key_code The key code to look up.
+ * @return The action string if found, NULL otherwise.
+ */
+const char* fossil_io_get_keybinding_action(int key_code);
+
+/**
+ * @brief Processes a key event.
+ *
+ * Checks if a key has a registered action and triggers it if found.
+ *
+ * @param key_code The key code that was pressed.
+ * @return 1 if an action was triggered, 0 if no binding exists.
+ */
+int fossil_io_process_keybinding(int key_code);
+
+/**
+ * @brief Lists all currently registered key bindings.
+ *
+ * @param bindings Array of fossil_io_keybinding_t to populate.
+ * @param max_bindings Maximum number of bindings to populate.
+ * @return Number of bindings populated in the array.
+ */
+size_t fossil_io_list_keybindings(fossil_io_keybinding_t *bindings, size_t max_bindings);
+
+/**
+ * @brief Clears all registered key bindings.
+ *
+ * Frees any internal memory and removes all key-action mappings.
+ */
+void fossil_io_clear_keybindings(void);
+
 #ifdef __cplusplus
 }
 
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <utility>
+#include <cstdarg>
+#include <istream>
+
 /**
  * Namespace for the Fossil Logic I/O library.
  */
@@ -397,6 +473,82 @@ namespace fossil {
                 return input_stream;
             }
 
+            /**
+             * Registers a key binding with an associated action string.
+             *
+             * @param key_code The integer key code.
+             * @param action The action string to associate with the key.
+             * @return 0 on success, non-zero on failure.
+             */
+            static int register_keybinding(int key_code, const std::string &action) {
+                return fossil_io_register_keybinding(key_code, action.c_str());
+            }
+
+            /**
+             * Registers a key binding with an optional callback function.
+             *
+             * @param key_code The integer key code.
+             * @param action The action string to associate with the key.
+             * @param callback Function pointer to execute when the key is pressed.
+             * @return 0 on success, non-zero on failure.
+             */
+            static int register_keybinding_callback(int key_code, const std::string &action, void (*callback)()) {
+                return fossil_io_register_keybinding_with_callback(key_code, action.c_str(), callback);
+            }
+
+            /**
+             * Unregisters a key binding.
+             *
+             * @param key_code The key code of the binding to remove.
+             * @return 0 on success, non-zero if the key was not found.
+             */
+            static int unregister_keybinding(int key_code) {
+                return fossil_io_unregister_keybinding(key_code);
+            }
+
+            /**
+             * Processes a key event.
+             *
+             * @param key_code The key code to process.
+             * @return 1 if an action was triggered, 0 if no binding exists.
+             */
+            static int process_keybinding(int key_code) {
+                return fossil_io_process_keybinding(key_code);
+            }
+
+            /**
+             * Retrieves the action associated with a key code.
+             *
+             * @param key_code The key code to look up.
+             * @return The action string if found, empty string otherwise.
+             */
+            static std::string get_keybinding_action(int key_code) {
+                const char *action = fossil_io_get_keybinding_action(key_code);
+                return action ? std::string(action) : std::string();
+            }
+
+            /**
+             * Lists all registered key bindings.
+             *
+             * @return A vector of key-action pairs representing all bindings.
+             */
+            static std::vector<std::pair<int, std::string>> list_keybindings() {
+                std::vector<std::pair<int, std::string>> bindings;
+                fossil_io_keybinding_t arr[256];
+                size_t count = fossil_io_list_keybindings(arr, 256);
+                for (size_t i = 0; i < count; i++) {
+                    bindings.emplace_back(arr[i].key_code, arr[i].action ? arr[i].action : "");
+                }
+                return bindings;
+            }
+
+            /**
+             * Clears all registered key bindings.
+             */
+            static void clear_keybindings() {
+                fossil_io_clear_keybindings();
+            }
+
         };
 
     }
diff --git a/code/logic/input.c b/code/logic/input.c
@@ -13,6 +13,7 @@
  */
 #include "fossil/io/input.h"
 #include "fossil/io/output.h"
+#include "fossil/io/cstring.h"
 
 #include <ctype.h>
 #include <stdio.h>
@@ -315,3 +316,100 @@ int fossil_io_gets(char *buffer, size_t size) {
     }
     return 0; // Success
 }
+
+#define MAX_KEYBINDINGS 256
+static fossil_io_keybinding_t _keybindings[MAX_KEYBINDINGS];
+static size_t _num_keybindings = 0;
+
+int fossil_io_register_keybinding(int key_code, const char *action) {
+    if (!action || _num_keybindings >= MAX_KEYBINDINGS) return 1;
+
+    // Check for duplicate
+    for (size_t i = 0; i < _num_keybindings; i++) {
+        if (_keybindings[i].key_code == key_code) return 2; // Duplicate key
+    }
+
+    _keybindings[_num_keybindings].key_code = key_code;
+    _keybindings[_num_keybindings].action = fossil_io_cstring_dup(action);
+    if (!_keybindings[_num_keybindings].action) return 3; // Allocation failure
+
+    _num_keybindings++;
+    return 0;
+}
+
+int fossil_io_unregister_keybinding(int key_code) {
+    for (size_t i = 0; i < _num_keybindings; i++) {
+        if (_keybindings[i].key_code == key_code) {
+            free((void*)_keybindings[i].action);
+            // Shift remaining bindings
+            for (size_t j = i; j < _num_keybindings - 1; j++) {
+                _keybindings[j] = _keybindings[j + 1];
+            }
+            _num_keybindings--;
+            return 0;
+        }
+    }
+    return 1; // Key not found
+}
+
+const char* fossil_io_get_keybinding_action(int key_code) {
+    for (size_t i = 0; i < _num_keybindings; i++) {
+        if (_keybindings[i].key_code == key_code) {
+            return _keybindings[i].action;
+        }
+    }
+    return NULL;
+}
+
+/**
+ * Registers a new key binding with optional callback.
+ */
+int fossil_io_register_keybinding_with_callback(int key_code, const char *action, fossil_io_action_callback_t cb) {
+    if (!action || _num_keybindings >= MAX_KEYBINDINGS) return 1;
+
+    // Check for duplicate key
+    for (size_t i = 0; i < _num_keybindings; i++) {
+        if (_keybindings[i].key_code == key_code) return 2; // Duplicate
+    }
+
+    _keybindings[_num_keybindings].key_code = key_code;
+    _keybindings[_num_keybindings].action = fossil_io_cstring_dup(action);
+    _keybindings[_num_keybindings].callback = cb;
+    if (!_keybindings[_num_keybindings].action) return 3; // Allocation failed
+
+    _num_keybindings++;
+    return 0;
+}
+
+/**
+ * Enhanced key processing that calls registered callback.
+ */
+int fossil_io_process_keybinding(int key_code) {
+    for (size_t i = 0; i < _num_keybindings; i++) {
+        if (_keybindings[i].key_code == key_code) {
+            if (_keybindings[i].callback) {
+                _keybindings[i].callback();  // Execute callback
+            } else {
+                printf("Action triggered: %s\n", _keybindings[i].action);
+            }
+            return 1; // Action processed
+        }
+    }
+    return 0; // No binding
+}
+
+size_t fossil_io_list_keybindings(fossil_io_keybinding_t *bindings, size_t max_bindings) {
+    size_t count = (max_bindings < _num_keybindings) ? max_bindings : _num_keybindings;
+    for (size_t i = 0; i < count; i++) {
+        bindings[i].key_code = _keybindings[i].key_code;
+        bindings[i].action = _keybindings[i].action;
+    }
+    return count;
+}
+
+void fossil_io_clear_keybindings(void) {
+    for (size_t i = 0; i < _num_keybindings; i++) {
+        free((void*)_keybindings[i].action);
+    }
+    _num_keybindings = 0;
+}
diff --git a/code/tests/cases/test_input.c b/code/tests/cases/test_input.c
@@ -219,6 +219,91 @@ FOSSIL_TEST(c_test_io_getc) {
     fclose(input_stream.file);
 }
 
+FOSSIL_TEST(c_test_io_register_keybinding_success) {
+    fossil_io_clear_keybindings();
+    int result = fossil_io_register_keybinding(42, "jump");
+    ASSUME_ITS_EQUAL_I32(0, result);
+    const char *action = fossil_io_get_keybinding_action(42);
+    ASSUME_ITS_EQUAL_CSTR("jump", action);
+    fossil_io_clear_keybindings();
+}
+
+FOSSIL_TEST(c_test_io_register_keybinding_duplicate) {
+    fossil_io_clear_keybindings();
+    fossil_io_register_keybinding(42, "jump");
+    int result = fossil_io_register_keybinding(42, "run");
+    ASSUME_ITS_EQUAL_I32(2, result); // Duplicate key
+    fossil_io_clear_keybindings();
+}
+
+FOSSIL_TEST(c_test_io_unregister_keybinding_success) {
+    fossil_io_clear_keybindings();
+    fossil_io_register_keybinding(42, "jump");
+    int result = fossil_io_unregister_keybinding(42);
+    ASSUME_ITS_EQUAL_I32(0, result);
+    const char *action = fossil_io_get_keybinding_action(42);
+    ASSUME_ITS_CNULL(action);
+    fossil_io_clear_keybindings();
+}
+
+FOSSIL_TEST(c_test_io_unregister_keybinding_not_found) {
+    fossil_io_clear_keybindings();
+    int result = fossil_io_unregister_keybinding(99);
+    ASSUME_ITS_EQUAL_I32(1, result); // Key not found
+    fossil_io_clear_keybindings();
+}
+
+// Callback for keybinding test
+static int cb_called = 0;
+static void cb(void) { cb_called = 1; }
+
+FOSSIL_TEST(c_test_io_register_keybinding_with_callback_success) {
+    fossil_io_clear_keybindings();
+    cb_called = 0;
+    int result = fossil_io_register_keybinding_with_callback(55, "shoot", cb);
+    ASSUME_ITS_EQUAL_I32(0, result);
+    fossil_io_process_keybinding(55);
+    ASSUME_ITS_EQUAL_I32(1, cb_called);
+    fossil_io_clear_keybindings();
+}
+
+FOSSIL_TEST(c_test_io_get_keybinding_action_not_found) {
+    fossil_io_clear_keybindings();
+    const char *action = fossil_io_get_keybinding_action(123);
+    ASSUME_ITS_CNULL(action);
+    fossil_io_clear_keybindings();
+}
+
+FOSSIL_TEST(c_test_io_process_keybinding_no_binding) {
+    fossil_io_clear_keybindings();
+    int result = fossil_io_process_keybinding(77);
+    ASSUME_ITS_EQUAL_I32(0, result);
+    fossil_io_clear_keybindings();
+}
+
+FOSSIL_TEST(c_test_io_list_keybindings_populates_array) {
+    fossil_io_clear_keybindings();
+    fossil_io_register_keybinding(1, "up");
+    fossil_io_register_keybinding(2, "down");
+    fossil_io_keybinding_t bindings[4];
+    size_t count = fossil_io_list_keybindings(bindings, 4);
+    ASSUME_ITS_EQUAL_I32(2, (int)count);
+    ASSUME_ITS_EQUAL_I32(1, bindings[0].key_code);
+    ASSUME_ITS_EQUAL_CSTR("up", bindings[0].action);
+    ASSUME_ITS_EQUAL_I32(2, bindings[1].key_code);
+    ASSUME_ITS_EQUAL_CSTR("down", bindings[1].action);
+    fossil_io_clear_keybindings();
+}
+
+FOSSIL_TEST(c_test_io_clear_keybindings_removes_all) {
+    fossil_io_register_keybinding(1, "up");
+    fossil_io_register_keybinding(2, "down");
+    fossil_io_clear_keybindings();
+    fossil_io_keybinding_t bindings[2];
+    size_t count = fossil_io_list_keybindings(bindings, 2);
+    ASSUME_ITS_EQUAL_I32(0, (int)count);
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * *
 // * Fossil Logic Test Pool
 // * * * * * * * * * * * * * * * * * * * * * * * *
@@ -242,6 +327,16 @@ FOSSIL_TEST_GROUP(c_input_tests) {
     FOSSIL_TEST_ADD(c_input_suite, c_test_io_validate_is_length_valid);
     FOSSIL_TEST_ADD(c_input_suite, c_test_io_validate_is_length_invalid);
     FOSSIL_TEST_ADD(c_input_suite, c_test_io_getc);
+
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_register_keybinding_success);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_register_keybinding_duplicate);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_unregister_keybinding_success);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_unregister_keybinding_not_found);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_register_keybinding_with_callback_success);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_get_keybinding_action_not_found);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_process_keybinding_no_binding);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_list_keybindings_populates_array);
+    FOSSIL_TEST_ADD(c_input_suite, c_test_io_clear_keybindings_removes_all);
     
     FOSSIL_TEST_REGISTER(c_input_suite);
 }
diff --git a/code/tests/cases/test_input.cpp b/code/tests/cases/test_input.cpp
