Merge pull request #57 from UltimateHackingKeyboard/keymap-switching

Implement keymap switching

right/src/config_parser/parse_config.c

@@ -1,6 +1,7 @@
 #include "parse_config.h"
 #include "parse_keymap.h"
 #include "parse_macro.h"
+#include "keymaps.h"
 
 static parser_error_t parseModuleConfiguration(config_buffer_t *buffer) {
     uint8_t id = readUInt8(buffer);
@@ -38,10 +39,13 @@ parser_error_t ParseConfig(config_buffer_t *buffer) {
     }
     keymapCount = readCompactLength(buffer);
     for (uint16_t keymapIdx = 0; keymapIdx < keymapCount; keymapIdx++) {
-        errorCode = ParseKeymap(buffer);
+        errorCode = ParseKeymap(buffer, keymapIdx, keymapCount);
         if (errorCode != ParserError_Success) {
             return errorCode;
         }
     }
+    if (!ParserRunDry) {
+        AllKeymapsCount = keymapCount;
+    }
     return ParserError_Success;
 }

right/src/config_parser/parse_config.h

@@ -16,6 +16,7 @@
         ParserError_InvalidModuleCount,
         ParserError_InvalidActionCount,
         ParserError_InvalidSerializedMacroActionType,
+        ParserError_InvalidSerializedSwitchKeymapAction,
     } parser_error_t;
 
 // Functions:

right/src/config_parser/parse_keymap.c

@@ -1,8 +1,10 @@
 #include "config_parser/parse_keymap.h"
 #include "key_action.h"
-#include "current_keymap.h"
+#include "keymaps.h"
 #include "led_display.h"
 
+uint8_t tempKeymapCount;
+
 static parser_error_t parseNoneAction(key_action_t *keyAction, config_buffer_t *buffer) {
     keyAction->type = KeyActionType_None;
     return ParserError_Success;
@@ -51,9 +53,11 @@ static parser_error_t parseSwitchLayerAction(key_action_t *KeyAction, config_buf
 static parser_error_t parseSwitchKeymapAction(key_action_t *keyAction, config_buffer_t *buffer) {
     uint8_t keymapIndex = readUInt8(buffer);
 
-    (void)keymapIndex;
+    if (keymapIndex >= tempKeymapCount) {
+        return ParserError_InvalidSerializedSwitchKeymapAction;
+    }
     keyAction->type = KeyActionType_SwitchKeymap;
-    // TODO: Implement this
+    keyAction->switchKeymap.keymapId = keymapIndex;
     return ParserError_Success;
 }
 
@@ -175,7 +179,8 @@ static parser_error_t parseLayer(config_buffer_t *buffer, uint8_t layer) {
     return ParserError_Success;
 }
 
-parser_error_t ParseKeymap(config_buffer_t *buffer) {;
+parser_error_t ParseKeymap(config_buffer_t *buffer, uint8_t keymapIdx, uint8_t keymapCount) {;
+    uint16_t offset = buffer->offset;
     parser_error_t errorCode;
     uint16_t abbreviationLen;
     uint16_t nameLen;
@@ -185,28 +190,27 @@ parser_error_t ParseKeymap(config_buffer_t *buffer) {;
     const char *name = readString(buffer, &nameLen);
     const char *description = readString(buffer, &descriptionLen);
     uint16_t layerCount = readCompactLength(buffer);
-    bool temp;
 
     (void)name;
     (void)description;
     if (layerCount != LAYER_COUNT) {
         return ParserError_InvalidLayerCount;
     }
-    temp = ParserRunDry;
-    if (!isDefault) {
-        ParserRunDry = true;
-    }
     if (!ParserRunDry) {
-        LedDisplay_SetText(abbreviationLen, abbreviation);
+        AllKeymaps[keymapIdx].abbreviation = abbreviation;
+        AllKeymaps[keymapIdx].abbreviationLen = abbreviationLen;
+        AllKeymaps[keymapIdx].offset = offset;
+        if (isDefault) {
+            DefaultKeymapIndex = keymapIdx;
+        }
     }
+    tempKeymapCount = keymapCount;
     for (uint16_t layerIdx = 0; layerIdx < layerCount; layerIdx++) {
         errorCode = parseLayer(buffer, layerIdx);
         if (errorCode != ParserError_Success) {
-            ParserRunDry = temp;
             return errorCode;
         }
     }
-    ParserRunDry = temp;
     return ParserError_Success;
 }
 

right/src/config_parser/parse_keymap.h

@@ -52,6 +52,6 @@
 
 // Functions:
 
-    parser_error_t ParseKeymap(config_buffer_t *buffer);
+    parser_error_t ParseKeymap(config_buffer_t *buffer, uint8_t keymapIdx, uint8_t keymapCount);
 
 #endif

right/src/current_keymap.h

@@ -1,12 +0,0 @@
-#ifndef __CURRENT_KEYMAP_H__
-#define __CURRENT_KEYMAP_H__
-
-// Includes:
-
-    #include <stdint.h>
-
-// Variables:
-
-    extern key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE];
-
-#endif

right/src/keymaps.c

@@ -1,9 +1,23 @@
-#include "key_action.h"
 #include "arduino_hid/ConsumerAPI.h"
 #include "arduino_hid/SystemAPI.h"
+#include "keymaps.h"
+#include "led_display.h"
+#include "config_parser/parse_keymap.h"
 
 // TODO: Restore Ctrl and Super keys and Mod+N.
 
+keymap_reference_t AllKeymaps[MAX_KEYMAP_NUM] = { { "QTY", 3 } };
+uint8_t AllKeymapsCount;
+uint8_t DefaultKeymapIndex;
+uint8_t CurrentKeymapIndex = 0;
+
+void Keymaps_Switch(uint8_t index) {
+    CurrentKeymapIndex = index;
+    UserConfigBuffer.offset = AllKeymaps[index].offset;
+    ParseKeymap(&UserConfigBuffer, index, AllKeymapsCount);
+    LedDisplay_SetText(AllKeymaps[index].abbreviationLen, AllKeymaps[index].abbreviation);
+}
+
 key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] = {
     // Base layer
     {

right/src/keymaps.h

@@ -0,0 +1,33 @@
+#ifndef __KEYMAPS_H__
+#define __KEYMAPS_H__
+
+// Includes:
+
+    #include <stdint.h>
+    #include "key_action.h"
+
+// Macros:
+
+    #define MAX_KEYMAP_NUM 255
+
+// Typedefs:
+
+    typedef struct {
+        const char *abbreviation;
+        uint16_t abbreviationLen;
+        uint16_t offset;
+    } keymap_reference_t;
+
+// Variables:
+
+    extern keymap_reference_t AllKeymaps[MAX_KEYMAP_NUM];
+    extern uint8_t AllKeymapsCount;
+    extern uint8_t DefaultKeymapIndex;
+    extern uint8_t CurrentKeymapIndex;
+    extern key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE];
+
+// Functions:
+
+    void Keymaps_Switch(uint8_t index);
+
+#endif

right/src/usb_protocol_handler.c

@@ -12,6 +12,7 @@
 #include "wormhole.h"
 #include "peripherals/adc.h"
 #include "eeprom.h"
+#include "keymaps.h"
 
 // Functions for setting error statuses
 
@@ -86,6 +87,8 @@ void readMergeSensor(void)
 void applyConfig(void)
 {
     uint8_t *temp;
+    char oldKeymapAbbreviation[3];
+    uint8_t oldKeymapAbbreviationLen;
 
     ParserRunDry = true;
     StagingUserConfigBuffer.offset = 0;
@@ -96,6 +99,8 @@ void applyConfig(void)
     if (GenericHidOutBuffer[0]) {
         return;
     }
+    memcpy(oldKeymapAbbreviation, AllKeymaps[CurrentKeymapIndex].abbreviation, 3);
+    oldKeymapAbbreviationLen = AllKeymaps[CurrentKeymapIndex].abbreviationLen;
     ParserRunDry = false;
     temp = UserConfigBuffer.buffer;
     UserConfigBuffer.buffer = StagingUserConfigBuffer.buffer;
@@ -105,6 +110,20 @@ void applyConfig(void)
     GenericHidOutBuffer[1] = UserConfigBuffer.offset;
     GenericHidOutBuffer[2] = UserConfigBuffer.offset >> 8;
     GenericHidOutBuffer[3] = 1;
+    if (GenericHidOutBuffer[0]) {
+        return;
+    }
+    for (uint8_t i = 0; i < AllKeymapsCount; i++) {
+        if (AllKeymaps[i].abbreviationLen != oldKeymapAbbreviationLen) {
+            continue;
+        }
+        if (memcmp(oldKeymapAbbreviation, AllKeymaps[i].abbreviation, oldKeymapAbbreviationLen)) {
+            continue;
+        }
+        Keymaps_Switch(i);
+        return;
+    }
+    Keymaps_Switch(DefaultKeymapIndex);
 }
 
 void setLedPwm(void)

right/src/usb_report_updater.c

@@ -3,7 +3,7 @@
 #include "led_display.h"
 #include "layer.h"
 #include "usb_interfaces/usb_interface_mouse.h"
-#include "current_keymap.h"
+#include "keymaps.h"
 #include "test_states.h"
 #include "peripherals/test_led.h"
 #include "slave_drivers/is31fl3731_driver.h"
@@ -174,6 +174,9 @@ void UpdateActiveUsbReports()
                 case KeyActionType_Test:
                     processTestAction(action);
                     break;
+                case KeyActionType_SwitchKeymap:
+                    Keymaps_Switch(action.switchKeymap.keymapId);
+                    break;
             }
         }
     }