diff --git a/UPGRADING.md b/UPGRADING.md index 1cef8430..984afbab 100644 --- a/UPGRADING.md +++ b/UPGRADING.md @@ -75,7 +75,7 @@ In practice, this boils down to implementing one or more of the following hook p - `onSetup()`: Called once during device bootup, at the end of the `setup()` method. It takes no arguments, and must return `kaleidoscope::EventHandlerResult::OK`. - `beforeEachCycle()`: Called once, at the beginning of each cycle of the main loop. This is similar to the old "loop hook" with its `post_clear` argument set to false. Takes no arguments, must return `kaleidoscope::EventHandlerResult::OK`. -- `onKeyswitchEvent`: Called for every non-idle key event. This replaces the old "event handler hook". It takes a key reference, coordinates, and a key state. The key reference can be updated to change the key being processed, so that any plugin that processes it further, will see the updated key. Can return `kaleidoscope::EventHandlerResult::OK` to let other plugins process the event further, or `kaleidoscope::EventHandlerResult::EVENT_CONSUMED` to stop processing. +- `onKeyswitchEvent`: Called for every non-idle key event. This replaces the old "event handler hook". It takes a key reference, a key address, and a key state. The key reference can be updated to change the key being processed, so that any plugin that processes it further, will see the updated key. Can return `kaleidoscope::EventHandlerResult::OK` to let other plugins process the event further, or `kaleidoscope::EventHandlerResult::EVENT_CONSUMED` to stop processing. - `onFocusEvent`: Used to implement [bi-directional communication](#bidirectional-communication-for-plugins). This is called whenever the firmware receives a command from the host. The only argument is the command name. Can return `kaleidoscope::EventHandlerResult::OK` to let other plugins process the event further, or `kaleidoscope::EventHandlerResult::EVENT_CONSUMED` to stop processing. - `beforeReportingState`: Called without arguments, just before sending the keyboard and mouse reports to the host. Must return `kaleidoscope::EventHandlerResult::OK`. - `afterEachCycle`: Called without arguments at the very end of each cycle. This is the replacement for the "loop hook" with its `post_clear` argument set. @@ -435,6 +435,13 @@ Older versions of the plugin required one to set up `Key_Redial` manually, and l ## Deprecated APIs and their replacements +### Transition to linear indexing + +Row/col based indexing was replaced by linear indexing throughout the whole firmware. A compatibility layer of functions was introduced that allows +the firmware to remain backwards compatible, however, these functions are deprecated and will be removed in future versions of the firmware. + +Also a new version of the onKeyswitchEvent-handler has been introduced. The old version is deprecated. + ### Finer OneShot stickability control The [OneShot plugin](doc/plugin/OneShot.md) has much improved stickability control. Instead of only being able to control if one-shot layers should be stickable too, or disabling the sticky feature in general, it is now possible to control stickiness on a per-key basis with the new `OneShot.enableStickability()` and `OneShot.disableStickablity()` methods. The old properties are still available, but will be removed by **2019-04-30**. @@ -572,7 +579,7 @@ class Plugin { public: EventHandlerResult onSetup(); EventHandlerResult beforeEachCycle(); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult beforeReportingState(); EventHandlerResult afterEachCycle(); }; diff --git a/doc/plugin/LED-AlphaSquare.md b/doc/plugin/LED-AlphaSquare.md index e24795d3..97ce3d87 100644 --- a/doc/plugin/LED-AlphaSquare.md +++ b/doc/plugin/LED-AlphaSquare.md @@ -34,11 +34,11 @@ methods or properties other than those provided by all LED modes. ### `.display(key)` ### `.display(key, col)` -### `.display(key, row, col)` -### `.display(key, row, col, color)` +### `.display(key, key_addr)` +### `.display(key, key_addr, color)` -> Display the symbol for `key` at the given row or column, with pixels set to -> the specified `color`. If `row` is omitted, the first row - `0` is assumed. If +> Display the symbol for `key` at the given led address, with pixels set to +> the specified `color`. If only `col` is provided, the first row - `0` is assumed. If > the column is omitted, then the third column - `2` - is used. > If the `color` is omitted, the plugin will use the global `.color` property. > @@ -50,8 +50,8 @@ methods or properties other than those provided by all LED modes. ### `.display(symbol)` ### `.display(symbol, col)` -### `.display(symbol, row, col)` -### `.display(symbol, row, col, color)` +### `.display(symbol, key_addr)` +### `.display(symbol, key_addr, color)` > As the previous function, but instead of a key, it expects a 4x4 bitmap in > the form of a 16-bit unsigned integer, where the low bit is the top-right @@ -61,7 +61,7 @@ methods or properties other than those provided by all LED modes. ### `.clear(key)`, `.clear(symbol)` ### `.clear(key, col)`, `.clear(symbol, col)` -### `.clear(key, col, row)`, `.clear(symbol, col, row)` +### `.clear(key, key_addr)`, `.clear(symbol, key_addr)` > Just like the `.display()` counterparts, except these clear the symbol, by > turning the LED pixels it is made up from off. diff --git a/doc/plugin/Qukeys.md b/doc/plugin/Qukeys.md index 0a5079e0..d1ef8794 100644 --- a/doc/plugin/Qukeys.md +++ b/doc/plugin/Qukeys.md @@ -18,8 +18,8 @@ one keycode (i.e. symbol) when tapped, and a different keycode -- most likely a KALEIDOSCOPE_INIT_PLUGINS(Qukeys); ``` -- Define some `Qukeys` of the format `Qukey(layer, row, col, alt_keycode)` - (layers, rows and columns are all zero-indexed, rows are top to bottom and +- Define some `Qukeys` of the format `Qukey(layer, key_addr, alt_keycode)` + (layers, and key addresses are all zero-indexed, in key addresses rows are top to bottom and columns are left to right): - For the Keyboardio Model 01, key coordinates refer to [this header diff --git a/doc/plugin/Syster.md b/doc/plugin/Syster.md index 6345b20a..e97afc64 100644 --- a/doc/plugin/Syster.md +++ b/doc/plugin/Syster.md @@ -28,9 +28,9 @@ void systerAction(kaleidoscope::plugin::Syster::action_t action, const char *sym Unicode.type (0x2328); break; case kaleidoscope::plugin::Syster::EndAction: - handleKeyswitchEvent (Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, IS_PRESSED | INJECTED); + handleKeyswitchEvent (Key_Backspace, UnknownKeyswitchLocation, IS_PRESSED | INJECTED); kaleidoscope::hid::sendKeyboardReport (); - handleKeyswitchEvent (Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, WAS_PRESSED | INJECTED); + handleKeyswitchEvent (Key_Backspace, UnknownKeyswitchLocation, WAS_PRESSED | INJECTED); kaleidoscope::hid::sendKeyboardReport (); break; case kaleidoscope::plugin::Syster::SymbolAction: diff --git a/doc/plugin/TapDance.md b/doc/plugin/TapDance.md index 1ee710c2..04d4c0f4 100644 --- a/doc/plugin/TapDance.md +++ b/doc/plugin/TapDance.md @@ -123,7 +123,7 @@ property only: > The `tap_count` and `tap_dance_actions` parameters should be the same as the > similarly named parameters of the `tapDanceAction` function. -### `tapDanceAction(tap_dance_index, row, col, tap_count, tap_dance_action)` +### `tapDanceAction(tap_dance_index, key_addr, tap_count, tap_dance_action)` > The heart of the tap-dance plugin is the handler method. This is called every > time any kind of tap-dance action is to be performed. See the diff --git a/examples/Features/AppSwitcher/Macros.cpp b/examples/Features/AppSwitcher/Macros.cpp index 14fa5920..93474785 100644 --- a/examples/Features/AppSwitcher/Macros.cpp +++ b/examples/Features/AppSwitcher/Macros.cpp @@ -58,6 +58,6 @@ void macroAppSwitchLoop() { // if appSwitchActive is true, we continue holding Alt. if (appSwitchActive) { - handleKeyswitchEvent(mod, UNKNOWN_KEYSWITCH_LOCATION, IS_PRESSED); + handleKeyswitchEvent(mod, UnknownKeyswitchLocation, IS_PRESSED); } } diff --git a/examples/Features/GhostInTheFirmware/GhostInTheFirmware.ino b/examples/Features/GhostInTheFirmware/GhostInTheFirmware.ino index e86e0b71..aa6b417a 100644 --- a/examples/Features/GhostInTheFirmware/GhostInTheFirmware.ino +++ b/examples/Features/GhostInTheFirmware/GhostInTheFirmware.ino @@ -45,7 +45,7 @@ class EventDropper_ : public kaleidoscope::Plugin { public: EventDropper_() {} - kaleidoscope::EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { + kaleidoscope::EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { return kaleidoscope::EventHandlerResult::EVENT_CONSUMED; } }; diff --git a/examples/Keystrokes/Qukeys/Qukeys.ino b/examples/Keystrokes/Qukeys/Qukeys.ino index c16558c8..660bb943 100644 --- a/examples/Keystrokes/Qukeys/Qukeys.ino +++ b/examples/Keystrokes/Qukeys/Qukeys.ino @@ -64,11 +64,11 @@ KALEIDOSCOPE_INIT_PLUGINS(Qukeys, Macros); void setup() { QUKEYS( - kaleidoscope::plugin::Qukey(0, 2, 1, Key_LeftGui), // A/cmd - kaleidoscope::plugin::Qukey(0, 2, 2, Key_LeftAlt), // S/alt - kaleidoscope::plugin::Qukey(0, 2, 3, Key_LeftControl), // D/ctrl - kaleidoscope::plugin::Qukey(0, 2, 4, Key_LeftShift), // F/shift - kaleidoscope::plugin::Qukey(0, 3, 6, ShiftToLayer(1)) // Q/layer-shift (on `fn`) + kaleidoscope::plugin::Qukey(0, KeyAddr(2, 1), Key_LeftGui), // A/cmd + kaleidoscope::plugin::Qukey(0, KeyAddr(2, 2), Key_LeftAlt), // S/alt + kaleidoscope::plugin::Qukey(0, KeyAddr(2, 3), Key_LeftControl), // D/ctrl + kaleidoscope::plugin::Qukey(0, KeyAddr(2, 4), Key_LeftShift), // F/shift + kaleidoscope::plugin::Qukey(0, KeyAddr(3, 6), ShiftToLayer(1)) // Q/layer-shift (on `fn`) ) Qukeys.setTimeout(200); Qukeys.setReleaseDelay(20); diff --git a/examples/Keystrokes/Syster/Syster.ino b/examples/Keystrokes/Syster/Syster.ino index ef8bd3ed..00d5db62 100644 --- a/examples/Keystrokes/Syster/Syster.ino +++ b/examples/Keystrokes/Syster/Syster.ino @@ -50,9 +50,9 @@ void systerAction(kaleidoscope::plugin::Syster::action_t action, const char *sym Unicode.type(0x2328); break; case kaleidoscope::plugin::Syster::EndAction: - handleKeyswitchEvent(Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, IS_PRESSED | INJECTED); + handleKeyswitchEvent(Key_Backspace, UnknownKeyswitchLocation, IS_PRESSED | INJECTED); kaleidoscope::hid::sendKeyboardReport(); - handleKeyswitchEvent(Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, WAS_PRESSED | INJECTED); + handleKeyswitchEvent(Key_Backspace, UnknownKeyswitchLocation, WAS_PRESSED | INJECTED); kaleidoscope::hid::sendKeyboardReport(); break; case kaleidoscope::plugin::Syster::SymbolAction: diff --git a/examples/Keystrokes/TapDance/TapDance.ino b/examples/Keystrokes/TapDance/TapDance.ino index 7cd5b0fb..1e14eb94 100644 --- a/examples/Keystrokes/TapDance/TapDance.ino +++ b/examples/Keystrokes/TapDance/TapDance.ino @@ -44,7 +44,7 @@ static void tapDanceEsc(uint8_t tap_dance_index, uint8_t tap_count, kaleidoscope tapDanceActionKeys(tap_count, tap_dance_action, Key_Escape, Key_Tab); } -void tapDanceAction(uint8_t tap_dance_index, byte row, byte col, uint8_t tap_count, kaleidoscope::plugin::TapDance::ActionType tap_dance_action) { +void tapDanceAction(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, kaleidoscope::plugin::TapDance::ActionType tap_dance_action) { switch (tap_dance_index) { case 0: return tapDanceActionKeys(tap_count, tap_dance_action, Key_Tab, Key_Escape); diff --git a/src/kaleidoscope/Hardware.h b/src/kaleidoscope/Hardware.h index 00d45cb0..7c197498 100644 --- a/src/kaleidoscope/Hardware.h +++ b/src/kaleidoscope/Hardware.h @@ -22,6 +22,7 @@ #pragma once #include "kaleidoscope/MatrixAddr.h" +#include "kaleidoscope_internal/deprecations.h" #ifndef CRGB #error cRGB and CRGB *must* be defined before including this header! @@ -57,6 +58,12 @@ namespace kaleidoscope { */ class Hardware { public: + + // To satisfy the interface of those methods that allow + // for matrix addressing we define default key and led address classes. + // Those typedefs are supposed to overridden by derived hardware classes. + typedef MatrixAddr<0, 0> KeyAddr; + /** * @defgroup kaleidoscope_hardware_leds Kaleidoscope::Hardware/LEDs * @{ @@ -66,6 +73,16 @@ class Hardware { * changes made before this call are reflected on the device. */ void syncLeds(void) {} + /** + * Set the color of a per-key LED at a given row and column. + * + * Setting the color does not need to take effect immediately, it can be + * delayed until @ref syncLeds is called. + * + * @param key_addr is the matrix address of the LED. + * @param color is the color to set the LED to. + */ + void setCrgbAt(KeyAddr key_addr, cRGB color) {} /** * Set the color of a per-key LED at a given row and column. * @@ -76,7 +93,7 @@ class Hardware { * @param col is the logical column position of the key. * @param color is the color to set the LED to. */ - void setCrgbAt(byte row, byte col, cRGB color) {} + DEPRECATED(ROW_COL_FUNC) void setCrgbAt(byte row, byte col, cRGB color) {} /** * Set the color of a per-key LED at a given LED index. * @@ -100,6 +117,17 @@ class Hardware { }; return c; } + /** + * Returns the index of the LED at a given row & column. + * + * @param key_addr is the matrix address of the LED. + * + * @returns The index of the LED at the given position, or -1 if there are no + * LEDs there. + */ + int8_t getLedIndex(KeyAddr key_addr) { + return -1; + } /** * Returns the index of the LED at a given row & column. * @@ -109,7 +137,7 @@ class Hardware { * @returns The index of the LED at the given position, or -1 if there are no * LEDs there. */ - int8_t getLedIndex(uint8_t row, byte col) { + DEPRECATED(ROW_COL_FUNC) int8_t getLedIndex(uint8_t row, byte col) { return -1; } /** @} */ @@ -149,6 +177,15 @@ class Hardware { * which is all but hidden from the rest of the plugins. * @{ */ + /** + * Mask out a key. + * + * Masking a key out means that any other event than a release will be + * ignored until said release. + * + * @param key_addr is the matrix address of the key. + */ + void maskKey(KeyAddr key_addr) {} /** * Mask out a key. * @@ -158,7 +195,16 @@ class Hardware { * @param row is the row the key is located at in the matrix. * @param col is the column the key is located at in the matrix. */ - void maskKey(byte row, byte col) {} + DEPRECATED(ROW_COL_FUNC) void maskKey(byte row, byte col) {} + /** + * Unmask a key. + * + * Remove the mask - if any - for a given key. To be used when the mask + * needs to be removed without the key being released. + * + * @param key_addr is the matrix address of the key. + */ + void unMaskKey(KeyAddr key_addr) {} /** * Unmask a key. * @@ -169,6 +215,16 @@ class Hardware { * @param col is the column the key is located at in the matrix. */ void unMaskKey(byte row, byte col) {} + /** + * Check whether a key is masked or not. + * + * @param key_addr is the matrix address of the key. + * + * @returns true if the key is masked, false otherwise. + */ + bool isKeyMasked(KeyAddr key_addr) { + return false; + } /** * Check whether a key is masked or not. * @@ -177,7 +233,7 @@ class Hardware { * * @returns true if the key is masked, false otherwise. */ - bool isKeyMasked(byte row, byte col) { + DEPRECATED(ROW_COL_FUNC) bool isKeyMasked(byte row, byte col) { return false; } /** @} */ @@ -223,6 +279,16 @@ class Hardware { * * @{ */ + /** + * Check if a key is pressed at a given position. + * + * @param key_addr is the matrix address of the key. + * + * @returns true if the key is pressed, false otherwise. + */ + bool isKeyswitchPressed(KeyAddr key_addr) { + return false; + } /** * Check if a key is pressed at a given position. * @@ -231,7 +297,7 @@ class Hardware { * * @returns true if the key is pressed, false otherwise. */ - bool isKeyswitchPressed(byte row, byte col) { + DEPRECATED(ROW_COL_FUNC) bool isKeyswitchPressed(byte row, byte col) { return false; } /** @@ -263,7 +329,17 @@ class Hardware { * * @returns true if the key was pressed, false otherwise. */ - bool wasKeyswitchPressed(byte row, byte col) { + DEPRECATED(ROW_COL_FUNC) bool wasKeyswitchPressed(byte row, byte col) { + return false; + } + /** + * Check if a key was pressed at a given position on the previous scan + * + * @param key_addr is the matrix address of the key. + * + * @returns true if the key was pressed, false otherwise. + */ + bool wasKeyswitchPressed(KeyAddr key_addr) { return false; } /** diff --git a/src/kaleidoscope/Kaleidoscope.cpp b/src/kaleidoscope/Kaleidoscope.cpp index 0a81682d..ed2929bc 100644 --- a/src/kaleidoscope/Kaleidoscope.cpp +++ b/src/kaleidoscope/Kaleidoscope.cpp @@ -46,10 +46,8 @@ Kaleidoscope_::setup(void) { // Update the keymap cache, so we start with a non-empty state. Layer.updateActiveLayers(); - for (byte row = 0; row < ROWS; row++) { - for (byte col = 0; col < COLS; col++) { - Layer.updateLiveCompositeKeymap(row, col); - } + for (auto key_addr : KeyAddr::all()) { + Layer.updateLiveCompositeKeymap(key_addr); } } diff --git a/src/kaleidoscope/addr.h b/src/kaleidoscope/addr.h deleted file mode 100644 index 6b44358f..00000000 --- a/src/kaleidoscope/addr.h +++ /dev/null @@ -1,44 +0,0 @@ -/* -*- mode: c++ -*- - * Kaleidoscope-Qukeys -- Assign two keycodes to a single key - * Copyright (C) 2017 Michael Richters - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#pragma once - -#include - -// Helper functions for converting between separate (row,col) -// coordinates and a single-byte key number (addr). This works as long -// as the keyboard has fewer than 256 keys. -namespace kaleidoscope { -namespace addr { -inline uint8_t row(uint8_t key_addr) { - return (key_addr / COLS); -} -inline uint8_t col(uint8_t key_addr) { - return (key_addr % COLS); -} -inline uint8_t addr(uint8_t row, uint8_t col) { - return ((row * COLS) + col); -} -inline void mask(uint8_t key_addr) { - KeyboardHardware.maskKey(row(key_addr), col(key_addr)); -} -inline void unmask(uint8_t key_addr) { - KeyboardHardware.unMaskKey(row(key_addr), col(key_addr)); -} -} // namespace addr { -} // namespace kaleidoscope { diff --git a/src/kaleidoscope/hardware/ATMegaKeyboard.cpp b/src/kaleidoscope/hardware/ATMegaKeyboard.cpp index b3801d2a..fe866c44 100644 --- a/src/kaleidoscope/hardware/ATMegaKeyboard.cpp +++ b/src/kaleidoscope/hardware/ATMegaKeyboard.cpp @@ -74,15 +74,13 @@ uint8_t ATMegaKeyboard::pressedKeyswitchCount() { return count; } -bool ATMegaKeyboard::isKeyswitchPressed(uint8_t row, byte col) { - return (bitRead(KeyboardHardware.keyState_[row], col) != 0); - +bool ATMegaKeyboard::isKeyswitchPressed(KeyAddr key_addr) { + return (bitRead(KeyboardHardware.keyState_[key_addr.row()], key_addr.col()) != 0); } bool ATMegaKeyboard::isKeyswitchPressed(uint8_t keyIndex) { keyIndex--; - return isKeyswitchPressed(keyIndex / KeyboardHardware.matrix_columns, - keyIndex % KeyboardHardware.matrix_columns); + return isKeyswitchPressed(KeyAddr(keyIndex)); } @@ -95,15 +93,14 @@ uint8_t ATMegaKeyboard::previousPressedKeyswitchCount() { return count; } -bool ATMegaKeyboard::wasKeyswitchPressed(uint8_t row, byte col) { - return (bitRead(KeyboardHardware.previousKeyState_[row], col) != 0); +bool ATMegaKeyboard::wasKeyswitchPressed(KeyAddr key_addr) { + return (bitRead(KeyboardHardware.previousKeyState_[key_addr.row()], key_addr.col()) != 0); } bool ATMegaKeyboard::wasKeyswitchPressed(uint8_t keyIndex) { keyIndex--; - return wasKeyswitchPressed(keyIndex / KeyboardHardware.matrix_columns, - keyIndex % KeyboardHardware.matrix_columns); + return wasKeyswitchPressed(KeyAddr(keyIndex)); } @@ -113,7 +110,7 @@ void __attribute__((optimize(3))) ATMegaKeyboard::actOnMatrixScan() { uint8_t keyState = (bitRead(KeyboardHardware.previousKeyState_[row], col) << 0) | (bitRead(KeyboardHardware.keyState_[row], col) << 1); if (keyState) { - handleKeyswitchEvent(Key_NoKey, row, col, keyState); + handleKeyswitchEvent(Key_NoKey, KeyAddr(row, col), keyState); } } KeyboardHardware.previousKeyState_[row] = KeyboardHardware.keyState_[row]; @@ -130,25 +127,25 @@ void ATMegaKeyboard::scanMatrix() { KeyboardHardware.actOnMatrixScan(); } -void ATMegaKeyboard::maskKey(byte row, byte col) { - if (row >= KeyboardHardware.matrix_rows || col >= KeyboardHardware.matrix_columns) +void ATMegaKeyboard::maskKey(KeyAddr key_addr) { + if (!key_addr.isValid()) return; - bitWrite(KeyboardHardware.masks_[row], col, 1); + bitWrite(KeyboardHardware.masks_[key_addr.row()], key_addr.col(), 1); } -void ATMegaKeyboard::unMaskKey(byte row, byte col) { - if (row >= KeyboardHardware.matrix_rows || col >= KeyboardHardware.matrix_columns) +void ATMegaKeyboard::unMaskKey(KeyAddr key_addr) { + if (!key_addr.isValid()) return; - bitWrite(KeyboardHardware.masks_[row], col, 0); + bitWrite(KeyboardHardware.masks_[key_addr.row()], key_addr.col(), 0); } -bool ATMegaKeyboard::isKeyMasked(byte row, byte col) { - if (row >= KeyboardHardware.matrix_rows || col >= KeyboardHardware.matrix_columns) +bool ATMegaKeyboard::isKeyMasked(KeyAddr key_addr) { + if (!key_addr.isValid()) return false; - return bitRead(KeyboardHardware.masks_[row], col); + return bitRead(KeyboardHardware.masks_[key_addr.row()], key_addr.col()); } /* diff --git a/src/kaleidoscope/hardware/ATMegaKeyboard.h b/src/kaleidoscope/hardware/ATMegaKeyboard.h index 079ba0c2..54cc51dd 100644 --- a/src/kaleidoscope/hardware/ATMegaKeyboard.h +++ b/src/kaleidoscope/hardware/ATMegaKeyboard.h @@ -22,9 +22,9 @@ #include #include #include "Kaleidoscope-HIDAdaptor-KeyboardioHID.h" +#include "kaleidoscope/MatrixAddr.h" #include "kaleidoscope/macro_helpers.h" -#include "kaleidoscope/key_events.h" #include "kaleidoscope/hardware/avr/pins_and_ports.h" #include @@ -84,16 +84,31 @@ class ATMegaKeyboard : public kaleidoscope::Hardware { void scanMatrix(); uint8_t pressedKeyswitchCount(); - bool isKeyswitchPressed(uint8_t row, byte col); + bool isKeyswitchPressed(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool isKeyswitchPressed(uint8_t row, byte col) { + return isKeyswitchPressed(KeyAddr(row, col)); + } bool isKeyswitchPressed(uint8_t keyIndex); uint8_t previousPressedKeyswitchCount(); - bool wasKeyswitchPressed(uint8_t row, byte col); + bool wasKeyswitchPressed(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool wasKeyswitchPressed(uint8_t row, byte col) { + return wasKeyswitchPressed(KeyAddr(row, col)); + } bool wasKeyswitchPressed(uint8_t keyIndex); - void maskKey(byte row, byte col); - void unMaskKey(byte row, byte col); - bool isKeyMasked(byte row, byte col); + void maskKey(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) void maskKey(byte row, byte col) { + maskKey(KeyAddr(row, col)); + } + void unMaskKey(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) void unMaskKey(byte row, byte col) { + unMaskKey(KeyAddr(row, col)); + } + bool isKeyMasked(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool isKeyMasked(byte row, byte col) { + return isKeyMasked(KeyAddr(row, col)); + } static bool do_scan_; diff --git a/src/kaleidoscope/hardware/ez/ErgoDox.cpp b/src/kaleidoscope/hardware/ez/ErgoDox.cpp index b7d87a0c..77852f36 100644 --- a/src/kaleidoscope/hardware/ez/ErgoDox.cpp +++ b/src/kaleidoscope/hardware/ez/ErgoDox.cpp @@ -113,7 +113,7 @@ void __attribute__((optimize(3))) ErgoDox::actOnMatrixScan() { uint8_t keyState = (bitRead(previousKeyState_[row], col) << 0) | (bitRead(keyState_[row], col) << 1); if (keyState) - handleKeyswitchEvent(Key_NoKey, row, col, keyState); + handleKeyswitchEvent(Key_NoKey, KeyAddr(row, col), keyState); } previousKeyState_[row] = keyState_[row]; } @@ -130,25 +130,25 @@ void ErgoDox::scanMatrix() { actOnMatrixScan(); } -void ErgoDox::maskKey(byte row, byte col) { - if (row >= ROWS || col >= COLS) +void ErgoDox::maskKey(KeyAddr key_addr) { + if (!key_addr.isValid()) return; - bitWrite(masks_[row], col, 1); + bitWrite(masks_[key_addr.row()], key_addr.col(), 1); } -void ErgoDox::unMaskKey(byte row, byte col) { - if (row >= ROWS || col >= COLS) +void ErgoDox::unMaskKey(KeyAddr key_addr) { + if (!key_addr.isValid()) return; - bitWrite(masks_[row], col, 0); + bitWrite(masks_[key_addr.row()], key_addr.col(), 0); } -bool ErgoDox::isKeyMasked(byte row, byte col) { - if (row >= ROWS || col >= COLS) +bool ErgoDox::isKeyMasked(KeyAddr key_addr) { + if (!key_addr.isValid()) return false; - return bitRead(masks_[row], col); + return bitRead(masks_[key_addr.row()], key_addr.col()); } // ErgoDox-specific stuff @@ -223,22 +223,22 @@ void ErgoDox::debounceRow(uint8_t change, uint8_t row) { } } -bool ErgoDox::isKeyswitchPressed(byte row, byte col) { - return (bitRead(keyState_[row], col) != 0); +bool ErgoDox::isKeyswitchPressed(KeyAddr key_addr) { + return (bitRead(keyState_[key_addr.row()], key_addr.col()) != 0); } bool ErgoDox::isKeyswitchPressed(uint8_t keyIndex) { keyIndex--; - return isKeyswitchPressed(keyIndex / COLS, keyIndex % COLS); + return isKeyswitchPressed(KeyAddr(keyIndex)); } -bool ErgoDox::wasKeyswitchPressed(byte row, byte col) { - return (bitRead(previousKeyState_[row], col) != 0); +bool ErgoDox::wasKeyswitchPressed(KeyAddr key_addr) { + return (bitRead(previousKeyState_[key_addr.row()], key_addr.col()) != 0); } bool ErgoDox::wasKeyswitchPressed(uint8_t keyIndex) { keyIndex--; - return wasKeyswitchPressed(keyIndex / COLS, keyIndex % COLS); + return wasKeyswitchPressed(KeyAddr(keyIndex)); } uint8_t ErgoDox::previousPressedKeyswitchCount() { diff --git a/src/kaleidoscope/hardware/ez/ErgoDox.h b/src/kaleidoscope/hardware/ez/ErgoDox.h index b534a8c2..5e315d18 100644 --- a/src/kaleidoscope/hardware/ez/ErgoDox.h +++ b/src/kaleidoscope/hardware/ez/ErgoDox.h @@ -43,6 +43,7 @@ struct cRGB { #define CRGB(r,g,b) (cRGB){b, g, r} #include "kaleidoscope/Hardware.h" +#include "kaleidoscope/MatrixAddr.h" namespace kaleidoscope { namespace hardware { @@ -66,15 +67,30 @@ class ErgoDox : public kaleidoscope::Hardware { void actOnMatrixScan(void); void setup(); - void maskKey(byte row, byte col); - void unMaskKey(byte row, byte col); - bool isKeyMasked(byte row, byte col); + void maskKey(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) void maskKey(byte row, byte col) { + maskKey(KeyAddr(row, col)); + } + void unMaskKey(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) void unMaskKey(byte row, byte col) { + unMaskKey(KeyAddr(row, col)); + } + bool isKeyMasked(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool isKeyMasked(byte row, byte col) { + return isKeyMasked(KeyAddr(row, col)); + } - bool isKeyswitchPressed(byte row, byte col); + bool isKeyswitchPressed(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool isKeyswitchPressed(byte row, byte col) { + return isKeyswitchPressed(KeyAddr(row, col)); + } bool isKeyswitchPressed(uint8_t keyIndex); uint8_t pressedKeyswitchCount(); - bool wasKeyswitchPressed(byte row, byte col); + bool wasKeyswitchPressed(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool wasKeyswitchPressed(byte row, byte col) { + return wasKeyswitchPressed(KeyAddr(row, col)); + } bool wasKeyswitchPressed(uint8_t keyIndex); uint8_t previousPressedKeyswitchCount(); diff --git a/src/kaleidoscope/hardware/keyboardio/Model01.cpp b/src/kaleidoscope/hardware/keyboardio/Model01.cpp index 55a697bc..5fed4f2e 100644 --- a/src/kaleidoscope/hardware/keyboardio/Model01.cpp +++ b/src/kaleidoscope/hardware/keyboardio/Model01.cpp @@ -31,11 +31,11 @@ bool Model01::isLEDChanged = true; keydata_t Model01::leftHandMask; keydata_t Model01::rightHandMask; -static constexpr int8_t key_led_map[4][16] PROGMEM = { - {3, 4, 11, 12, 19, 20, 26, 27, 36, 37, 43, 44, 51, 52, 59, 60}, - {2, 5, 10, 13, 18, 21, 25, 28, 35, 38, 42, 45, 50, 53, 58, 61}, - {1, 6, 9, 14, 17, 22, 24, 29, 34, 39, 41, 46, 49, 54, 57, 62}, - {0, 7, 8, 15, 16, 23, 31, 30, 33, 32, 40, 47, 48, 55, 56, 63}, +static constexpr int8_t key_led_map[Model01::led_count] PROGMEM = { + 3, 4, 11, 12, 19, 20, 26, 27, 36, 37, 43, 44, 51, 52, 59, 60, + 2, 5, 10, 13, 18, 21, 25, 28, 35, 38, 42, 45, 50, 53, 58, 61, + 1, 6, 9, 14, 17, 22, 24, 29, 34, 39, 41, 46, 49, 54, 57, 62, + 0, 7, 8, 15, 16, 23, 31, 30, 33, 32, 40, 47, 48, 55, 56, 63, }; Model01::Model01(void) { @@ -118,12 +118,12 @@ void Model01::setCrgbAt(int8_t i, cRGB crgb) { } } -void Model01::setCrgbAt(byte row, byte col, cRGB color) { - setCrgbAt(getLedIndex(row, col), color); +void Model01::setCrgbAt(KeyAddr key_addr, cRGB color) { + setCrgbAt(getLedIndex(key_addr), color); } -int8_t Model01::getLedIndex(byte row, byte col) { - return pgm_read_byte(&(key_led_map[row][col])); +int8_t Model01::getLedIndex(KeyAddr key_addr) { + return pgm_read_byte(&(key_led_map[key_addr.toInt()])); } cRGB Model01::getCrgbAt(int8_t i) { @@ -164,12 +164,12 @@ boolean Model01::ledPowerFault() { } } -void debugKeyswitchEvent(keydata_t state, keydata_t previousState, uint8_t keynum, uint8_t row, uint8_t col) { +void debugKeyswitchEvent(keydata_t state, keydata_t previousState, uint8_t keynum, KeyAddr key_addr) { if (bitRead(state.all, keynum) != bitRead(previousState.all, keynum)) { Serial.print("Looking at row "); - Serial.print(row); + Serial.print(key_addr.row()); Serial.print(", col "); - Serial.print(col); + Serial.print(key_addr.col()); Serial.print(" key # "); Serial.print(keynum); Serial.print(" "); @@ -202,7 +202,7 @@ void Model01::actOnHalfRow(byte row, byte colState, byte colPrevState, byte star uint8_t keyState = ((bitRead(colPrevState, 0) << 0) | (bitRead(colState, 0) << 1)); if (keyState) - handleKeyswitchEvent(Key_NoKey, row, startPos - col, keyState); + handleKeyswitchEvent(Key_NoKey, KeyAddr(row, startPos - col), keyState); // Throw away the data we've just used, so we can read the next column colState = colState >> 1; @@ -259,10 +259,12 @@ constexpr byte HAND_BIT = B00001000; constexpr byte ROW_BITS = B00110000; constexpr byte COL_BITS = B00000111; -void Model01::maskKey(byte row, byte col) { - if (row >= ROWS || col >= COLS) +void Model01::maskKey(KeyAddr key_addr) { + if (!key_addr.isValid()) return; + auto row = key_addr.row(); + auto col = key_addr.col(); if (col & HAND_BIT) { rightHandMask.rows[row] |= (HIGH_BIT >> (col & COL_BITS)); } else { @@ -270,10 +272,12 @@ void Model01::maskKey(byte row, byte col) { } } -void Model01::unMaskKey(byte row, byte col) { - if (row >= ROWS || col >= COLS) +void Model01::unMaskKey(KeyAddr key_addr) { + if (!key_addr.isValid()) return; + auto row = key_addr.row(); + auto col = key_addr.col(); if (col & HAND_BIT) { rightHandMask.rows[row] &= ~(HIGH_BIT >> (col & COL_BITS)); } else { @@ -281,10 +285,12 @@ void Model01::unMaskKey(byte row, byte col) { } } -bool Model01::isKeyMasked(byte row, byte col) { - if (row >= ROWS || col >= COLS) +bool Model01::isKeyMasked(KeyAddr key_addr) { + if (!key_addr.isValid()) return false; + auto row = key_addr.row(); + auto col = key_addr.col(); if (col & HAND_BIT) { return rightHandMask.rows[row] & (HIGH_BIT >> (col & COL_BITS)); } else { @@ -303,7 +309,9 @@ void Model01::setKeyscanInterval(uint8_t interval) { rightHand.setKeyscanInterval(interval); } -bool Model01::isKeyswitchPressed(byte row, byte col) { +bool Model01::isKeyswitchPressed(KeyAddr key_addr) { + auto row = key_addr.row(); + auto col = key_addr.col(); if (col <= 7) { return (bitRead(leftHandState.rows[row], 7 - col) != 0); } else { @@ -313,11 +321,13 @@ bool Model01::isKeyswitchPressed(byte row, byte col) { bool Model01::isKeyswitchPressed(uint8_t keyIndex) { keyIndex--; - return isKeyswitchPressed(keyIndex / COLS, keyIndex % COLS); + return isKeyswitchPressed(KeyAddr(keyIndex)); } -bool Model01::wasKeyswitchPressed(byte row, byte col) { +bool Model01::wasKeyswitchPressed(KeyAddr key_addr) { + auto row = key_addr.row(); + auto col = key_addr.col(); if (col <= 7) { return (bitRead(previousLeftHandState.rows[row], 7 - col) != 0); } else { @@ -327,7 +337,7 @@ bool Model01::wasKeyswitchPressed(byte row, byte col) { bool Model01::wasKeyswitchPressed(uint8_t keyIndex) { keyIndex--; - return wasKeyswitchPressed(keyIndex / COLS, keyIndex % COLS); + return wasKeyswitchPressed(KeyAddr(keyIndex)); } uint8_t Model01::pressedKeyswitchCount() { diff --git a/src/kaleidoscope/hardware/keyboardio/Model01.h b/src/kaleidoscope/hardware/keyboardio/Model01.h index cc089b65..6ffeb7a2 100644 --- a/src/kaleidoscope/hardware/keyboardio/Model01.h +++ b/src/kaleidoscope/hardware/keyboardio/Model01.h @@ -30,6 +30,7 @@ #define CRGB(r,g,b) (cRGB){b, g, r} #include "kaleidoscope/Hardware.h" +#include "kaleidoscope/MatrixAddr.h" namespace kaleidoscope { namespace hardware { @@ -49,10 +50,16 @@ class Model01 : public kaleidoscope::Hardware { } void syncLeds(void); - void setCrgbAt(byte row, byte col, cRGB color); + void setCrgbAt(KeyAddr key_addr, cRGB color); + DEPRECATED(ROW_COL_FUNC) void setCrgbAt(byte row, byte col, cRGB color) { + setCrgbAt(KeyAddr(row, col), color); + } void setCrgbAt(int8_t i, cRGB crgb); cRGB getCrgbAt(int8_t i); - int8_t getLedIndex(byte row, byte col); + int8_t getLedIndex(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) int8_t getLedIndex(byte row, byte col) { + return getLedIndex(KeyAddr(row, col)); + } void scanMatrix(void); void readMatrix(void); @@ -68,16 +75,31 @@ class Model01 : public kaleidoscope::Hardware { void setKeyscanInterval(uint8_t interval); boolean ledPowerFault(void); - void maskKey(byte row, byte col); - void unMaskKey(byte row, byte col); - bool isKeyMasked(byte row, byte col); + void maskKey(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) void maskKey(byte row, byte col) { + maskKey(KeyAddr(row, col)); + } + void unMaskKey(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) void unMaskKey(byte row, byte col) { + unMaskKey(KeyAddr(row, col)); + } + bool isKeyMasked(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool isKeyMasked(byte row, byte col) { + return isKeyMasked(KeyAddr(row, col)); + } void maskHeldKeys(void); - bool isKeyswitchPressed(byte row, byte col); + bool isKeyswitchPressed(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool isKeyswitchPressed(byte row, byte col) { + return isKeyswitchPressed(KeyAddr(row, col)); + } bool isKeyswitchPressed(uint8_t keyIndex); uint8_t pressedKeyswitchCount(); - bool wasKeyswitchPressed(byte row, byte col); + bool wasKeyswitchPressed(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) bool wasKeyswitchPressed(byte row, byte col) { + return wasKeyswitchPressed(KeyAddr(row, col)); + } bool wasKeyswitchPressed(uint8_t keyIndex); uint8_t previousPressedKeyswitchCount(); diff --git a/src/kaleidoscope/hooks.h b/src/kaleidoscope/hooks.h index 076a8fba..43646f12 100644 --- a/src/kaleidoscope/hooks.h +++ b/src/kaleidoscope/hooks.h @@ -29,7 +29,8 @@ union Key; // Forward declaration required to enable friend declarations // in class Hooks. class kaleidoscope_; -extern void handleKeyswitchEvent(kaleidoscope::Key mappedKey, byte row, byte col, uint8_t keyState); +extern void handleKeyswitchEvent(kaleidoscope::Key mappedKey, KeyAddr key_addr, uint8_t keyState); +DEPRECATED(ROW_COL_FUNC) extern void handleKeyswitchEvent(kaleidoscope::Key mappedKey, byte row, byte col, uint8_t keyState); namespace kaleidoscope { @@ -57,7 +58,7 @@ class Hooks { // ::handleKeyswitchEvent(...) calls Hooks::onKeyswitchEvent. friend void ::handleKeyswitchEvent(kaleidoscope::Key mappedKey, - byte row, byte col, uint8_t keyState); + KeyAddr key_addr, uint8_t keyState); private: diff --git a/src/kaleidoscope/key_events.cpp b/src/kaleidoscope/key_events.cpp index dd02be13..008be924 100644 --- a/src/kaleidoscope/key_events.cpp +++ b/src/kaleidoscope/key_events.cpp @@ -43,7 +43,7 @@ static bool handleSyntheticKeyswitchEvent(Key mappedKey, uint8_t keyState) { return true; } -static bool handleKeyswitchEventDefault(Key mappedKey, byte row, byte col, uint8_t keyState) { +static bool handleKeyswitchEventDefault(Key mappedKey, KeyAddr key_addr, uint8_t keyState) { //for every newly pressed button, figure out what logical key it is and send a key down event // for every newly released button, figure out what logical key it is and send a key up event @@ -59,33 +59,33 @@ static bool handleKeyswitchEventDefault(Key mappedKey, byte row, byte col, uint8 return true; } -void handleKeyswitchEvent(Key mappedKey, byte row, byte col, uint8_t keyState) { - /* These first steps are only done for keypresses that have a real (row,col). - * In particular, doing them for keypresses with out-of-bounds (row,col) +void handleKeyswitchEvent(Key mappedKey, KeyAddr key_addr, uint8_t keyState) { + /* These first steps are only done for keypresses that have a valid key_addr. + * In particular, doing them for keypresses with out-of-bounds key_addr * would cause out-of-bounds array accesses in Layer.lookup(), * Layer.updateLiveCompositeKeymap(), etc. - * Note that many INJECTED keypresses use the UNKNOWN_KEYSWITCH_LOCATION macro - * which gives us row==255, col==255 here. Therefore, it's legitimate that - * we may have keypresses with out-of-bounds (row, col). - * However, some INJECTED keypresses do have valid (row, col) if they are + * Note that many INJECTED keypresses use UnknownKeyswitchLocation + * which gives us an invalid key_addr here. Therefore, it's legitimate that + * we may have keypresses with out-of-bounds key_addr. + * However, some INJECTED keypresses do have valid key_addr if they are * injecting an event tied to a physical keyswitch - and we want them to go * through this lookup. - * So we can't just test for INJECTED here, we need to test the row and col + * So we can't just test for INJECTED here, we need to test the key_addr * directly. - * Note also that this (row, col) test avoids out-of-bounds accesses in *core*, + * Note also that this key_addr test avoids out-of-bounds accesses in *core*, * but doesn't guarantee anything about event handlers - event handlers may - * still receive out-of-bounds (row, col), and handling that properly is on + * still receive out-of-bounds key_addr, and handling that properly is on * them. */ - if (row < ROWS && col < COLS) { + if (key_addr.isValid()) { /* If a key had an on event, we update the live composite keymap. See * layers.h for an explanation about the different caches we have. */ if (keyToggledOn(keyState)) { if (mappedKey.raw == Key_NoKey.raw || keyState & EPHEMERAL) { - Layer.updateLiveCompositeKeymap(row, col); + Layer.updateLiveCompositeKeymap(key_addr); } else { - Layer.updateLiveCompositeKeymap(row, col, mappedKey); + Layer.updateLiveCompositeKeymap(key_addr, mappedKey); } } @@ -96,32 +96,44 @@ void handleKeyswitchEvent(Key mappedKey, byte row, byte col, uint8_t keyState) { * See layers.cpp for an example that masks keys, and the reason why it does * so. */ - if (KeyboardHardware.isKeyMasked(row, col)) { + if (KeyboardHardware.isKeyMasked(key_addr)) { if (keyToggledOff(keyState)) { - KeyboardHardware.unMaskKey(row, col); + KeyboardHardware.unMaskKey(key_addr); } else { return; } } - /* Convert (row, col) to the correct mappedKey - * The condition here means that if mappedKey and (row, col) are both valid, + /* Convert key_addr to the correct mappedKey + * The condition here means that if mappedKey and key_addr are both valid, * the mappedKey wins - we don't re-look-up the mappedKey */ if (mappedKey.raw == Key_NoKey.raw) { - mappedKey = Layer.lookup(row, col); + mappedKey = Layer.lookup(key_addr); } - } // row < ROWS && col < COLS + } // key_addr valid - // Keypresses with out-of-bounds (row,col) start here in the processing chain + // Keypresses with out-of-bounds key_addr start here in the processing chain - // New event handler interface - if (kaleidoscope::Hooks::onKeyswitchEvent(mappedKey, row, col, keyState) != kaleidoscope::EventHandlerResult::OK) + // We call both versions of onKeyswitchEvent. This assumes that a plugin + // implements either the old or the new version of the hook. + // The call to that version that is not implemented is optimized out + // by the caller. This is possible as the call would fall back to + // the version of the hook that is implemented in the base class of the + // plugin. This fallback version is an empty inline noop method that + // is simple for the compiler to optimize out. + + // New event handler interface version 2 (key address version) + if (kaleidoscope::Hooks::onKeyswitchEvent(mappedKey, key_addr, keyState) != kaleidoscope::EventHandlerResult::OK) + return; + + // New event handler interface (deprecated version) + if (kaleidoscope::Hooks::onKeyswitchEvent(mappedKey, key_addr.row(), key_addr.col(), keyState) != kaleidoscope::EventHandlerResult::OK) return; - mappedKey = Layer.eventHandler(mappedKey, row, col, keyState); + mappedKey = Layer.eventHandler(mappedKey, key_addr, keyState); if (mappedKey.raw == Key_NoKey.raw) return; - handleKeyswitchEventDefault(mappedKey, row, col, keyState); + handleKeyswitchEventDefault(mappedKey, key_addr, keyState); } diff --git a/src/kaleidoscope/key_events.h b/src/kaleidoscope/key_events.h index 0c124e05..41e2accf 100644 --- a/src/kaleidoscope/key_events.h +++ b/src/kaleidoscope/key_events.h @@ -24,6 +24,10 @@ // Code can use this macro on injected key events to signal that // the event isn't tied to a specific physical keyswitch +// +// TODO DEPRECATED(ROW_COL_FUNC): Once row/col based key/LED access +// is deprecated, deprecate UNKNOWN_KEYSWITCH_LOCATION as well. +// #define UNKNOWN_KEYSWITCH_LOCATION 255,255 // UnknownKeyswitchLocation represents an invalid (as default constructed) @@ -35,7 +39,7 @@ // Conversely, if an injected event *is* tied to a physical keyswitch and should // be resolved by the current keymap, code can use Key_NoKey on the injected event -// with a real (row, col) location +// with a real key address // sending events to the computer /* The event handling starts with the Scanner calling handleKeyswitchEvent() for @@ -62,10 +66,13 @@ * too. * * For this reason, the handleKeyswitchEvent receives four arguments: the mapped key - * (or Key_NoKey if we do not want to override what is in the keymap), the row - * and column of the key, so we can look up the code for it, and the current and + * (or Key_NoKey if we do not want to override what is in the keymap), the matrix + * address of the key, so we can look up the code for it, and the current and * previous state of the key, so we can determine what the event is. The * currentState may be flagged INJECTED, which signals that the event was * injected, and is not a direct result of a keypress, coming from the scanner. */ -void handleKeyswitchEvent(Key mappedKey, byte row, byte col, uint8_t keyState); +void handleKeyswitchEvent(Key mappedKey, KeyAddr key_addr, uint8_t keyState); +DEPRECATED(ROW_COL_FUNC) inline void handleKeyswitchEvent(Key mappedKey, byte row, byte col, uint8_t keyState) { + handleKeyswitchEvent(mappedKey, KeyAddr(row, col), keyState); +} diff --git a/src/kaleidoscope/keymaps.h b/src/kaleidoscope/keymaps.h index 9e49222c..d3cd0148 100644 --- a/src/kaleidoscope/keymaps.h +++ b/src/kaleidoscope/keymaps.h @@ -23,8 +23,8 @@ extern const Key keymaps_linear[][ROWS * COLS]; namespace kaleidoscope { inline -Key keyFromKeymap(uint8_t layer, uint8_t row, uint8_t col) { - return pgm_read_word(&keymaps_linear[layer][row * COLS + col]); +Key keyFromKeymap(uint8_t layer, KeyAddr key_addr) { + return pgm_read_word(&keymaps_linear[layer][key_addr.toInt()]); } namespace internal { diff --git a/src/kaleidoscope/layers.cpp b/src/kaleidoscope/layers.cpp index 5a8e755f..102ffdce 100644 --- a/src/kaleidoscope/layers.cpp +++ b/src/kaleidoscope/layers.cpp @@ -38,9 +38,9 @@ extern const Key keymaps_linear[][ROWS * COLS] = {}; namespace kaleidoscope { uint32_t Layer_::layer_state_; uint8_t Layer_::top_active_layer_; -Key Layer_::live_composite_keymap_[ROWS][COLS]; -uint8_t Layer_::active_layers_[ROWS][COLS]; -Key(*Layer_::getKey)(uint8_t layer, byte row, byte col) = Layer.getKeyFromPROGMEM; +Key Layer_::live_composite_keymap_[KeyboardHardware.numKeys()]; +uint8_t Layer_::active_layers_[KeyboardHardware.numKeys()]; +Key(*Layer_::getKey)(uint8_t layer, KeyAddr key_addr) = Layer.getKeyFromPROGMEM; void Layer_::handleKeymapKeyswitchEvent(Key keymapEntry, uint8_t keyState) { if (keymapEntry.keyCode >= LAYER_SHIFT_OFFSET) { @@ -93,7 +93,7 @@ void Layer_::handleKeymapKeyswitchEvent(Key keymapEntry, uint8_t keyState) { } } -Key Layer_::eventHandler(Key mappedKey, byte row, byte col, uint8_t keyState) { +Key Layer_::eventHandler(Key mappedKey, KeyAddr key_addr, uint8_t keyState) { if (mappedKey.flags != (SYNTHETIC | SWITCH_TO_KEYMAP)) return mappedKey; @@ -101,32 +101,30 @@ Key Layer_::eventHandler(Key mappedKey, byte row, byte col, uint8_t keyState) { return Key_NoKey; } -Key Layer_::getKeyFromPROGMEM(uint8_t layer, byte row, byte col) { - return keyFromKeymap(layer, row, col); +Key Layer_::getKeyFromPROGMEM(uint8_t layer, KeyAddr key_addr) { + return keyFromKeymap(layer, key_addr); } -void Layer_::updateLiveCompositeKeymap(byte row, byte col) { - int8_t layer = active_layers_[row][col]; - live_composite_keymap_[row][col] = (*getKey)(layer, row, col); +void Layer_::updateLiveCompositeKeymap(KeyAddr key_addr) { + int8_t layer = active_layers_[key_addr.toInt()]; + live_composite_keymap_[key_addr.toInt()] = (*getKey)(layer, key_addr); } void Layer_::updateActiveLayers(void) { memset(active_layers_, 0, KeyboardHardware.numKeys()); - for (byte row = 0; row < ROWS; row++) { - for (byte col = 0; col < COLS; col++) { - int8_t layer = top_active_layer_; - - while (layer > 0) { - if (Layer.isActive(layer)) { - Key mappedKey = (*getKey)(layer, row, col); - - if (mappedKey != Key_Transparent) { - active_layers_[row][col] = layer; - break; - } + for (auto key_addr : KeyAddr::all()) { + int8_t layer = top_active_layer_; + + while (layer > 0) { + if (Layer.isActive(layer)) { + Key mappedKey = (*getKey)(layer, key_addr); + + if (mappedKey != Key_Transparent) { + active_layers_[key_addr.toInt()] = layer; + break; } - layer--; } + layer--; } } } diff --git a/src/kaleidoscope/layers.h b/src/kaleidoscope/layers.h index 490b5a2b..14b25dfb 100644 --- a/src/kaleidoscope/layers.h +++ b/src/kaleidoscope/layers.h @@ -70,15 +70,26 @@ class Layer_ { * are curious what the active layer state describes the key as, use * `lookupOnActiveLayer`. */ - static Key lookup(byte row, byte col) { - return live_composite_keymap_[row][col]; + static Key lookup(KeyAddr key_addr) { + return live_composite_keymap_[key_addr.toInt()]; } - static Key lookupOnActiveLayer(byte row, byte col) { - uint8_t layer = active_layers_[row][col]; - return (*getKey)(layer, row, col); + DEPRECATED(ROW_COL_FUNC) static Key lookup(byte row, byte col) { + return live_composite_keymap_[KeyAddr(row, col).toInt()]; } - static uint8_t lookupActiveLayer(byte row, byte col) { - return active_layers_[row][col]; + static Key lookupOnActiveLayer(KeyAddr key_addr) { + uint8_t layer = active_layers_[key_addr.toInt()]; + return (*getKey)(layer, key_addr); + } + DEPRECATED(ROW_COL_FUNC) static Key lookupOnActiveLayer(byte row, byte col) { + KeyAddr key_addr(row, col); + uint8_t layer = active_layers_[key_addr.toInt()]; + return (*getKey)(layer, key_addr); + } + static uint8_t lookupActiveLayer(KeyAddr key_addr) { + return active_layers_[key_addr.toInt()]; + } + DEPRECATED(ROW_COL_FUNC) static uint8_t lookupActiveLayer(byte row, byte col) { + return active_layers_[KeyAddr(row, col).toInt()]; } static void activate(uint8_t layer); @@ -96,23 +107,35 @@ class Layer_ { return layer_state_; } - static Key eventHandler(Key mappedKey, byte row, byte col, uint8_t keyState); + static Key eventHandler(Key mappedKey, KeyAddr key_addr, uint8_t keyState); + DEPRECATED(ROW_COL_FUNC) static Key eventHandler(Key mappedKey, byte row, byte col, uint8_t keyState) { + return eventHandler(mappedKey, KeyAddr(row, col), keyState); + } - static Key(*getKey)(uint8_t layer, byte row, byte col); + static Key(*getKey)(uint8_t layer, KeyAddr key_addr); - static Key getKeyFromPROGMEM(uint8_t layer, byte row, byte col); + static Key getKeyFromPROGMEM(uint8_t layer, KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static Key getKeyFromPROGMEM(uint8_t layer, byte row, byte col) { + return getKeyFromPROGMEM(layer, KeyAddr(row, col)); + } - static void updateLiveCompositeKeymap(byte row, byte col); - static void updateLiveCompositeKeymap(byte row, byte col, Key mappedKey) { - live_composite_keymap_[row][col] = mappedKey; + static void updateLiveCompositeKeymap(KeyAddr key_addr, Key mappedKey) { + live_composite_keymap_[key_addr.toInt()] = mappedKey; + } + DEPRECATED(ROW_COL_FUNC) static void updateLiveCompositeKeymap(byte row, byte col, Key mappedKey) { + updateLiveCompositeKeymap(KeyAddr(row, col), mappedKey); + } + static void updateLiveCompositeKeymap(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static void updateLiveCompositeKeymap(byte row, byte col) { + updateLiveCompositeKeymap(KeyAddr(row, col)); } static void updateActiveLayers(void); private: static uint32_t layer_state_; static uint8_t top_active_layer_; - static Key live_composite_keymap_[ROWS][COLS]; - static uint8_t active_layers_[ROWS][COLS]; + static Key live_composite_keymap_[KeyboardHardware.numKeys()]; + static uint8_t active_layers_[KeyboardHardware.numKeys()]; static void handleKeymapKeyswitchEvent(Key keymapEntry, uint8_t keyState); static void updateTopActiveLayer(void); diff --git a/src/kaleidoscope/plugin/Colormap.cpp b/src/kaleidoscope/plugin/Colormap.cpp index c1db2e85..d24707d8 100644 --- a/src/kaleidoscope/plugin/Colormap.cpp +++ b/src/kaleidoscope/plugin/Colormap.cpp @@ -44,9 +44,9 @@ void ColormapEffect::TransientLEDMode::onActivate(void) { ::LEDPaletteTheme.updateHandler(parent_->map_base_, parent_->top_layer_); } -void ColormapEffect::TransientLEDMode::refreshAt(byte row, byte col) { +void ColormapEffect::TransientLEDMode::refreshAt(KeyAddr key_addr) { if (parent_->top_layer_ <= parent_->max_layers_) - ::LEDPaletteTheme.refreshAt(parent_->map_base_, parent_->top_layer_, row, col); + ::LEDPaletteTheme.refreshAt(parent_->map_base_, parent_->top_layer_, key_addr); } EventHandlerResult ColormapEffect::onLayerChange() { diff --git a/src/kaleidoscope/plugin/Colormap.h b/src/kaleidoscope/plugin/Colormap.h index eedc2db0..4259c31d 100644 --- a/src/kaleidoscope/plugin/Colormap.h +++ b/src/kaleidoscope/plugin/Colormap.h @@ -49,8 +49,10 @@ class ColormapEffect : public Plugin, friend class ColormapEffect; virtual void onActivate(void) final; - virtual void refreshAt(byte row, byte col) final; - + virtual void refreshAt(KeyAddr key_addr) final; + DEPRECATED(ROW_COL_FUNC) void refreshAt(byte row, byte col) final { + refreshAt(KeyAddr(row, col)); + } private: const ColormapEffect *parent_; diff --git a/src/kaleidoscope/plugin/Cycle.cpp b/src/kaleidoscope/plugin/Cycle.cpp index 00361a83..9b0f5d80 100644 --- a/src/kaleidoscope/plugin/Cycle.cpp +++ b/src/kaleidoscope/plugin/Cycle.cpp @@ -33,14 +33,14 @@ uint8_t Cycle::cycle_count_; // --- api --- void Cycle::replace(Key key) { - handleKeyswitchEvent(Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, IS_PRESSED | INJECTED); + handleKeyswitchEvent(Key_Backspace, UnknownKeyswitchLocation, IS_PRESSED | INJECTED); hid::sendKeyboardReport(); - handleKeyswitchEvent(Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, WAS_PRESSED | INJECTED); + handleKeyswitchEvent(Key_Backspace, UnknownKeyswitchLocation, WAS_PRESSED | INJECTED); hid::sendKeyboardReport(); - handleKeyswitchEvent(key, UNKNOWN_KEYSWITCH_LOCATION, IS_PRESSED | INJECTED); + handleKeyswitchEvent(key, UnknownKeyswitchLocation, IS_PRESSED | INJECTED); hid::sendKeyboardReport(); - handleKeyswitchEvent(key, UNKNOWN_KEYSWITCH_LOCATION, WAS_PRESSED | INJECTED); + handleKeyswitchEvent(key, UnknownKeyswitchLocation, WAS_PRESSED | INJECTED); hid::sendKeyboardReport(); } @@ -54,7 +54,7 @@ void Cycle::replace(uint8_t cycle_size, const Key cycle_steps[]) { // --- hooks --- -EventHandlerResult Cycle::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult Cycle::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (key_state & INJECTED) return EventHandlerResult::OK; diff --git a/src/kaleidoscope/plugin/Cycle.h b/src/kaleidoscope/plugin/Cycle.h index 0a7a1d83..e467d99c 100644 --- a/src/kaleidoscope/plugin/Cycle.h +++ b/src/kaleidoscope/plugin/Cycle.h @@ -36,7 +36,7 @@ class Cycle : public kaleidoscope::Plugin { static void replace(Key key); static void replace(uint8_t cycle_size, const Key cycle_steps[]); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); private: static uint8_t toModFlag(uint8_t keyCode); diff --git a/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp b/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp index 7540aa7f..0c4874b8 100644 --- a/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp +++ b/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp @@ -50,16 +50,16 @@ void EEPROMKeymapProgrammer::cancel(void) { state_ = INACTIVE; } -EventHandlerResult EEPROMKeymapProgrammer::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult EEPROMKeymapProgrammer::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (state_ == INACTIVE) return EventHandlerResult::OK; if (state_ == WAIT_FOR_KEY) { if (keyToggledOn(key_state)) { - update_position_ = Layer.top() * KeyboardHardware.numKeys() + row * COLS + col; + update_position_ = Layer.top() * KeyboardHardware.numKeys() + key_addr.toInt(); } if (keyToggledOff(key_state)) { - if ((uint16_t)(Layer.top() * KeyboardHardware.numKeys() + row * COLS + col) == update_position_) + if ((uint16_t)(Layer.top() * KeyboardHardware.numKeys() + key_addr.toInt()) == update_position_) nextState(); } return EventHandlerResult::EVENT_CONSUMED; @@ -67,10 +67,10 @@ EventHandlerResult EEPROMKeymapProgrammer::onKeyswitchEvent(Key &mapped_key, byt if (state_ == WAIT_FOR_SOURCE_KEY) { if (keyToggledOn(key_state)) { - new_key_ = Layer.getKeyFromPROGMEM(Layer.top(), row, col); + new_key_ = Layer.getKeyFromPROGMEM(Layer.top(), key_addr); } if (keyToggledOff(key_state)) { - if (new_key_ == Layer.getKeyFromPROGMEM(Layer.top(), row, col)) + if (new_key_ == Layer.getKeyFromPROGMEM(Layer.top(), key_addr)) nextState(); } return EventHandlerResult::EVENT_CONSUMED; diff --git a/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h b/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h index 14ba6c57..dd45b148 100644 --- a/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h +++ b/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h @@ -38,7 +38,7 @@ class EEPROMKeymapProgrammer : public kaleidoscope::Plugin { static void nextState(void); static void cancel(void); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult onFocusEvent(const char *command); private: diff --git a/src/kaleidoscope/plugin/EEPROM-Keymap.cpp b/src/kaleidoscope/plugin/EEPROM-Keymap.cpp index de3205ed..acc2d88d 100644 --- a/src/kaleidoscope/plugin/EEPROM-Keymap.cpp +++ b/src/kaleidoscope/plugin/EEPROM-Keymap.cpp @@ -47,13 +47,13 @@ void EEPROMKeymap::max_layers(uint8_t max) { keymap_base_ = ::EEPROMSettings.requestSlice(max_layers_ * KeyboardHardware.numKeys() * 2); } -Key EEPROMKeymap::getKey(uint8_t layer, byte row, byte col) { +Key EEPROMKeymap::getKey(uint8_t layer, KeyAddr key_addr) { Key key; if (layer >= max_layers_) return Key_NoKey; - uint16_t pos = ((layer * KeyboardHardware.numKeys()) + (row * COLS) + col) * 2; + uint16_t pos = ((layer * KeyboardHardware.numKeys()) + key_addr.toInt()) * 2; key.flags = EEPROM.read(keymap_base_ + pos); key.keyCode = EEPROM.read(keymap_base_ + pos + 1); @@ -61,16 +61,15 @@ Key EEPROMKeymap::getKey(uint8_t layer, byte row, byte col) { return key; } -Key EEPROMKeymap::getKeyExtended(uint8_t layer, byte row, byte col) { - Key key; +Key EEPROMKeymap::getKeyExtended(uint8_t layer, KeyAddr key_addr) { // If the layer is within PROGMEM bounds, look it up from there if (layer < progmem_layers_) { - return Layer.getKeyFromPROGMEM(layer, row, col); + return Layer.getKeyFromPROGMEM(layer, key_addr); } // If the layer is outside of PROGMEM, look up from EEPROM - return getKey(layer - progmem_layers_, row, col); + return getKey(layer - progmem_layers_, key_addr); } uint16_t EEPROMKeymap::keymap_base(void) { @@ -82,14 +81,22 @@ void EEPROMKeymap::updateKey(uint16_t base_pos, Key key) { EEPROM.update(keymap_base_ + base_pos * 2 + 1, key.keyCode); } +void EEPROMKeymap::dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, KeyAddr)) { + for (uint8_t layer = 0; layer < layers; layer++) { + for (auto key_addr : KeyAddr::all()) { + Key k = (*getkey)(layer, key_addr); + + ::Focus.send(k); + } + } +} + void EEPROMKeymap::dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, byte, byte)) { for (uint8_t layer = 0; layer < layers; layer++) { - for (uint8_t row = 0; row < ROWS; row++) { - for (uint8_t col = 0; col < COLS; col++) { - Key k = (*getkey)(layer, row, col); + for (auto key_addr : KeyAddr::all()) { + Key k = (*getkey)(layer, key_addr.row(), key_addr.col()); - ::Focus.send(k); - } + ::Focus.send(k); } } } @@ -122,7 +129,12 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) { } if (strcmp_P(command + 7, PSTR("default")) == 0) { - dumpKeymap(progmem_layers_, Layer.getKeyFromPROGMEM); + // By using a cast to the appropriate function type, + // tell the compiler which overload of getKeyFromPROGMEM + // we actully want. + // + dumpKeymap(progmem_layers_, + static_cast(Layer.getKeyFromPROGMEM)); return EventHandlerResult::EVENT_CONSUMED; } @@ -130,7 +142,11 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) { return EventHandlerResult::OK; if (::Focus.isEOL()) { - dumpKeymap(max_layers_, getKey); + // By using a cast to the appropriate function type, + // tell the compiler which overload of getKey + // we actually want. + // + dumpKeymap(max_layers_, static_cast(getKey)); } else { uint16_t i = 0; diff --git a/src/kaleidoscope/plugin/EEPROM-Keymap.h b/src/kaleidoscope/plugin/EEPROM-Keymap.h index 0aee9cbb..af7d4398 100644 --- a/src/kaleidoscope/plugin/EEPROM-Keymap.h +++ b/src/kaleidoscope/plugin/EEPROM-Keymap.h @@ -47,8 +47,14 @@ class EEPROMKeymap : public kaleidoscope::Plugin { static uint16_t keymap_base(void); - static Key getKey(uint8_t layer, byte row, byte col); - static Key getKeyExtended(uint8_t layer, byte row, byte col); + static Key getKey(uint8_t layer, KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static Key getKey(uint8_t layer, byte row, byte col) { + return getKey(layer, KeyAddr(row, col)); + } + static Key getKeyExtended(uint8_t layer, KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static Key getKeyExtended(uint8_t layer, byte row, byte col) { + return getKeyExtended(layer, KeyAddr(row, col)); + } static void updateKey(uint16_t base_pos, Key key); @@ -59,7 +65,8 @@ class EEPROMKeymap : public kaleidoscope::Plugin { static Key parseKey(void); static void printKey(Key key); - static void dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, byte, byte)); + static void dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, KeyAddr)); + DEPRECATED(ROW_COL_FUNC) static void dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, byte, byte)); }; } } diff --git a/src/kaleidoscope/plugin/Escape-OneShot.cpp b/src/kaleidoscope/plugin/Escape-OneShot.cpp index 3beb5adc..7f110307 100644 --- a/src/kaleidoscope/plugin/Escape-OneShot.cpp +++ b/src/kaleidoscope/plugin/Escape-OneShot.cpp @@ -22,7 +22,7 @@ namespace kaleidoscope { namespace plugin { -EventHandlerResult EscapeOneShot::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { +EventHandlerResult EscapeOneShot::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState) { if (mapped_key.raw != Key_Escape.raw || (keyState & INJECTED) || !keyToggledOn(keyState)) @@ -32,7 +32,7 @@ EventHandlerResult EscapeOneShot::onKeyswitchEvent(Key &mapped_key, byte row, by return EventHandlerResult::OK; } - KeyboardHardware.maskKey(row, col); + KeyboardHardware.maskKey(key_addr); ::OneShot.cancel(true); return EventHandlerResult::EVENT_CONSUMED; diff --git a/src/kaleidoscope/plugin/Escape-OneShot.h b/src/kaleidoscope/plugin/Escape-OneShot.h index 558d707f..47592228 100644 --- a/src/kaleidoscope/plugin/Escape-OneShot.h +++ b/src/kaleidoscope/plugin/Escape-OneShot.h @@ -25,7 +25,7 @@ class EscapeOneShot : public kaleidoscope::Plugin { public: EscapeOneShot(void) {} - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState); }; } } diff --git a/src/kaleidoscope/plugin/FingerPainter.cpp b/src/kaleidoscope/plugin/FingerPainter.cpp index bc83014e..5d9f29df 100644 --- a/src/kaleidoscope/plugin/FingerPainter.cpp +++ b/src/kaleidoscope/plugin/FingerPainter.cpp @@ -37,15 +37,15 @@ void FingerPainter::update(void) { ::LEDPaletteTheme.updateHandler(color_base_, 0); } -void FingerPainter::refreshAt(byte row, byte col) { - ::LEDPaletteTheme.refreshAt(color_base_, 0, row, col); +void FingerPainter::refreshAt(KeyAddr key_addr) { + ::LEDPaletteTheme.refreshAt(color_base_, 0, key_addr); } void FingerPainter::toggle(void) { edit_mode_ = !edit_mode_; } -EventHandlerResult FingerPainter::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult FingerPainter::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (!Kaleidoscope.has_leds || !edit_mode_) return EventHandlerResult::OK; @@ -53,10 +53,12 @@ EventHandlerResult FingerPainter::onKeyswitchEvent(Key &mapped_key, byte row, by return EventHandlerResult::EVENT_CONSUMED; } - if (row >= ROWS || col >= COLS) + if (!key_addr.isValid()) return EventHandlerResult::EVENT_CONSUMED; - uint8_t color_index = ::LEDPaletteTheme.lookupColorIndexAtPosition(color_base_, KeyboardHardware.getLedIndex(row, col)); + // TODO: The following works only for keyboards with LEDs for each key. + + uint8_t color_index = ::LEDPaletteTheme.lookupColorIndexAtPosition(color_base_, KeyboardHardware.getLedIndex(key_addr)); // Find the next color in the palette that is different. // But do not loop forever! @@ -73,7 +75,7 @@ EventHandlerResult FingerPainter::onKeyswitchEvent(Key &mapped_key, byte row, by new_color = ::LEDPaletteTheme.lookupPaletteColor(color_index); } - ::LEDPaletteTheme.updateColorIndexAtPosition(color_base_, KeyboardHardware.getLedIndex(row, col), color_index); + ::LEDPaletteTheme.updateColorIndexAtPosition(color_base_, KeyboardHardware.getLedIndex(key_addr), color_index); return EventHandlerResult::EVENT_CONSUMED; } diff --git a/src/kaleidoscope/plugin/FingerPainter.h b/src/kaleidoscope/plugin/FingerPainter.h index add9f175..1caf4d03 100644 --- a/src/kaleidoscope/plugin/FingerPainter.h +++ b/src/kaleidoscope/plugin/FingerPainter.h @@ -32,13 +32,16 @@ class FingerPainter : public LEDMode { static void toggle(void); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onSetup(); protected: void update(void) final; - void refreshAt(byte row, byte col) final; + void refreshAt(KeyAddr key_addr) final; + DEPRECATED(ROW_COL_FUNC) void refreshAt(byte row, byte col) final { + refreshAt(KeyAddr(row, col)); + } private: static uint16_t color_base_; diff --git a/src/kaleidoscope/plugin/GeminiPR.cpp b/src/kaleidoscope/plugin/GeminiPR.cpp index 39331f72..659684ca 100644 --- a/src/kaleidoscope/plugin/GeminiPR.cpp +++ b/src/kaleidoscope/plugin/GeminiPR.cpp @@ -24,7 +24,7 @@ namespace steno { uint8_t GeminiPR::keys_held_; uint8_t GeminiPR::state_[6]; -EventHandlerResult GeminiPR::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { +EventHandlerResult GeminiPR::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState) { if (mapped_key < geminipr::START || mapped_key > geminipr::END) return EventHandlerResult::OK; diff --git a/src/kaleidoscope/plugin/GeminiPR.h b/src/kaleidoscope/plugin/GeminiPR.h index e6696c55..193c08e1 100644 --- a/src/kaleidoscope/plugin/GeminiPR.h +++ b/src/kaleidoscope/plugin/GeminiPR.h @@ -29,8 +29,7 @@ class GeminiPR : public kaleidoscope::Plugin { public: GeminiPR(void) {} - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); - + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState); private: static uint8_t keys_held_; static uint8_t state_[6]; diff --git a/src/kaleidoscope/plugin/GhostInTheFirmware.cpp b/src/kaleidoscope/plugin/GhostInTheFirmware.cpp index 8e5edf7e..d582b86c 100644 --- a/src/kaleidoscope/plugin/GhostInTheFirmware.cpp +++ b/src/kaleidoscope/plugin/GhostInTheFirmware.cpp @@ -55,12 +55,12 @@ EventHandlerResult GhostInTheFirmware::beforeReportingState() { byte row = pgm_read_byte(&(ghost_keys[current_pos_].row)); byte col = pgm_read_byte(&(ghost_keys[current_pos_].col)); - handleKeyswitchEvent(Key_NoKey, row, col, WAS_PRESSED); + handleKeyswitchEvent(Key_NoKey, KeyAddr(row, col), WAS_PRESSED); } else if (is_pressed_) { byte row = pgm_read_byte(&(ghost_keys[current_pos_].row)); byte col = pgm_read_byte(&(ghost_keys[current_pos_].col)); - handleKeyswitchEvent(Key_NoKey, row, col, IS_PRESSED); + handleKeyswitchEvent(Key_NoKey, KeyAddr(row, col), IS_PRESSED); } else if (Kaleidoscope.hasTimeExpired(start_time_, delay_timeout_)) { current_pos_++; press_timeout_ = 0; diff --git a/src/kaleidoscope/plugin/HardwareTestMode.cpp b/src/kaleidoscope/plugin/HardwareTestMode.cpp index d36f0f9b..8b7e9f26 100644 --- a/src/kaleidoscope/plugin/HardwareTestMode.cpp +++ b/src/kaleidoscope/plugin/HardwareTestMode.cpp @@ -76,7 +76,7 @@ void HardwareTestMode::testLeds(void) { void HardwareTestMode::testMatrix() { // Reset bad keys from previous tests. - chatter_data state[KeyboardHardware.matrix_columns * KeyboardHardware.matrix_rows] = {0, 0, 0}; + chatter_data state[KeyboardHardware.numKeys()] = {0, 0, 0}; constexpr cRGB red = CRGB(201, 0, 0); constexpr cRGB blue = CRGB(0, 0, 201); @@ -85,36 +85,34 @@ void HardwareTestMode::testMatrix() { while (1) { KeyboardHardware.readMatrix(); - for (byte row = 0; row < KeyboardHardware.matrix_rows; row++) { - for (byte col = 0; col < KeyboardHardware.matrix_columns; col++) { - uint8_t keynum = (row * KeyboardHardware.matrix_columns) + (col); - - // If the key is toggled on - if (KeyboardHardware.isKeyswitchPressed(row, col) && ! KeyboardHardware.wasKeyswitchPressed(row, col)) { - // And it's too soon (in terms of cycles between changes) - state[keynum].tested = 1; - if (state[keynum].cyclesSinceStateChange < CHATTER_CYCLE_LIMIT) { - state[keynum].bad = 1; - } - state[keynum].cyclesSinceStateChange = 0; - } else if (state[keynum].cyclesSinceStateChange < CHATTER_CYCLE_LIMIT) { - state[keynum].cyclesSinceStateChange++; - } - // If the key is held down - if (KeyboardHardware.isKeyswitchPressed(row, col) && KeyboardHardware.wasKeyswitchPressed(row, col)) { - KeyboardHardware.setCrgbAt(row, col, green); + for (auto key_addr : KeyAddr::all()) { + uint8_t keynum = key_addr.toInt(); + + // If the key is toggled on + if (KeyboardHardware.isKeyswitchPressed(key_addr) && ! KeyboardHardware.wasKeyswitchPressed(key_addr)) { + // And it's too soon (in terms of cycles between changes) + state[keynum].tested = 1; + if (state[keynum].cyclesSinceStateChange < CHATTER_CYCLE_LIMIT) { + state[keynum].bad = 1; } + state[keynum].cyclesSinceStateChange = 0; + } else if (state[keynum].cyclesSinceStateChange < CHATTER_CYCLE_LIMIT) { + state[keynum].cyclesSinceStateChange++; + } + // If the key is held down + if (KeyboardHardware.isKeyswitchPressed(key_addr) && KeyboardHardware.wasKeyswitchPressed(key_addr)) { + KeyboardHardware.setCrgbAt(key_addr, green); + } - // If we triggered chatter detection ever on this key - else if (state[keynum].bad == 1) { - KeyboardHardware.setCrgbAt(row, col, red); - } else if (state[keynum].tested == 0) { - KeyboardHardware.setCrgbAt(row, col, yellow); - } - // If the key is not currently pressed and was not just released and is not marked bad - else if (! KeyboardHardware.isKeyswitchPressed(row, col)) { - KeyboardHardware.setCrgbAt(row, col, blue); - } + // If we triggered chatter detection ever on this key + else if (state[keynum].bad == 1) { + KeyboardHardware.setCrgbAt(key_addr, red); + } else if (state[keynum].tested == 0) { + KeyboardHardware.setCrgbAt(key_addr, yellow); + } + // If the key is not currently pressed and was not just released and is not marked bad + else if (! KeyboardHardware.isKeyswitchPressed(key_addr)) { + KeyboardHardware.setCrgbAt(key_addr, blue); } } ::LEDControl.syncLeds(); diff --git a/src/kaleidoscope/plugin/Heatmap.cpp b/src/kaleidoscope/plugin/Heatmap.cpp index fe8108a7..755c44bf 100644 --- a/src/kaleidoscope/plugin/Heatmap.cpp +++ b/src/kaleidoscope/plugin/Heatmap.cpp @@ -106,10 +106,8 @@ void Heatmap::TransientLEDMode::shiftStats(void) { // 2. highest_ reach heat_colors_length*512 (see Heatmap::loopHook) // we divide every heatmap element by 2 - for (uint8_t r = 0; r < ROWS; r++) { - for (uint8_t c = 0; c < COLS; c++) { - heatmap_[r][c] = heatmap_[r][c] >> 1; - } + for (auto key_addr : KeyAddr::all()) { + heatmap_[key_addr.toInt()] = heatmap_[key_addr.toInt()] >> 1; } // and also divide highest_ accordingly @@ -128,16 +126,14 @@ void Heatmap::TransientLEDMode::resetMap() { // this method can be used as a way to work around an existing bug with a single key // getting special attention or if the user just wants a button to reset the map - for (uint8_t r = 0; r < ROWS; r++) { - for (uint8_t c = 0; c < COLS; c++) { - heatmap_[r][c] = 0; - } + for (auto key_addr : KeyAddr::all()) { + heatmap_[key_addr.toInt()] = 0; } highest_ = 1; } -EventHandlerResult Heatmap::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult Heatmap::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (!Kaleidoscope.has_leds) return EventHandlerResult::OK; @@ -157,16 +153,16 @@ EventHandlerResult Heatmap::onKeyswitchEvent(Key &mapped_key, byte row, byte col return EventHandlerResult::OK; return ::LEDControl.get_mode() - ->onKeyswitchEvent(mapped_key, row, col, key_state); + ->onKeyswitchEvent(mapped_key, key_addr, key_state); } -EventHandlerResult Heatmap::TransientLEDMode::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult Heatmap::TransientLEDMode::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { // increment the heatmap_ value related to the key - heatmap_[row][col]++; + heatmap_[key_addr.toInt()]++; // check highest_ - if (highest_ < heatmap_[row][col]) { - highest_ = heatmap_[row][col]; + if (highest_ < heatmap_[key_addr.toInt()]) { + highest_ = heatmap_[key_addr.toInt()]; // if highest_ (and so heatmap_ value related to the key) // is close to overflow: call shiftStats @@ -221,19 +217,17 @@ void Heatmap::TransientLEDMode::update(void) { last_heatmap_comp_time_ = Kaleidoscope.millisAtCycleStart(); // for each key - for (uint8_t r = 0; r < ROWS; r++) { - for (uint8_t c = 0; c < COLS; c++) { - // how much the key was pressed compared to the others (between 0 and 1) - // (total_keys_ can't be equal to 0) - float v = static_cast(heatmap_[r][c]) / highest_; - // we could have used an interger instead of a float, but then we would - // have had to change some multiplication in division. - // / on uint is slower than * on float, so I stay with the float - // https://forum.arduino.cc/index.php?topic=92684.msg2733723#msg2733723 - - // set the LED color accordingly - ::LEDControl.setCrgbAt(r, c, computeColor(v)); - } + for (auto key_addr : KeyAddr::all()) { + // how much the key was pressed compared to the others (between 0 and 1) + // (total_keys_ can't be equal to 0) + float v = static_cast(heatmap_[key_addr.toInt()]) / highest_; + // we could have used an interger instead of a float, but then we would + // have had to change some multiplication in division. + // / on uint is slower than * on float, so I stay with the float + // https://forum.arduino.cc/index.php?topic=92684.msg2733723#msg2733723 + + // set the LED color accordingly + ::LEDControl.setCrgbAt(KeyAddr(key_addr), computeColor(v)); } } diff --git a/src/kaleidoscope/plugin/Heatmap.h b/src/kaleidoscope/plugin/Heatmap.h index 391485b0..efba28ac 100644 --- a/src/kaleidoscope/plugin/Heatmap.h +++ b/src/kaleidoscope/plugin/Heatmap.h @@ -33,7 +33,7 @@ class Heatmap : public Plugin, static uint8_t heat_colors_length; void resetMap(void); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult beforeEachCycle(); // This class' instance has dynamic lifetime @@ -48,7 +48,7 @@ class Heatmap : public Plugin, TransientLEDMode(const Heatmap *parent); void resetMap(); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult beforeEachCycle(); protected: @@ -59,7 +59,7 @@ class Heatmap : public Plugin, const Heatmap *parent_; - uint16_t heatmap_[ROWS][COLS]; + uint16_t heatmap_[KeyboardHardware.numKeys()]; uint16_t highest_; uint16_t last_heatmap_comp_time_; diff --git a/src/kaleidoscope/plugin/IdleLEDs.cpp b/src/kaleidoscope/plugin/IdleLEDs.cpp index 449db057..34f75dff 100644 --- a/src/kaleidoscope/plugin/IdleLEDs.cpp +++ b/src/kaleidoscope/plugin/IdleLEDs.cpp @@ -36,7 +36,7 @@ EventHandlerResult IdleLEDs::beforeEachCycle() { return EventHandlerResult::OK; } -EventHandlerResult IdleLEDs::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult IdleLEDs::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (::LEDControl.paused) { ::LEDControl.paused = false; diff --git a/src/kaleidoscope/plugin/IdleLEDs.h b/src/kaleidoscope/plugin/IdleLEDs.h index 19d27a51..801eafa9 100644 --- a/src/kaleidoscope/plugin/IdleLEDs.h +++ b/src/kaleidoscope/plugin/IdleLEDs.h @@ -29,7 +29,7 @@ class IdleLEDs: public kaleidoscope::Plugin { static uint16_t idle_time_limit; EventHandlerResult beforeEachCycle(); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); private: static uint32_t start_time_; diff --git a/src/kaleidoscope/plugin/LED-ActiveLayerColor.cpp b/src/kaleidoscope/plugin/LED-ActiveLayerColor.cpp index cc424987..12eb2bf8 100644 --- a/src/kaleidoscope/plugin/LED-ActiveLayerColor.cpp +++ b/src/kaleidoscope/plugin/LED-ActiveLayerColor.cpp @@ -52,8 +52,8 @@ void LEDActiveLayerColorEffect::TransientLEDMode::onActivate(void) { ::LEDControl.set_all_leds_to(active_color_); } -void LEDActiveLayerColorEffect::TransientLEDMode::refreshAt(byte row, byte col) { - ::LEDControl.setCrgbAt(row, col, active_color_); +void LEDActiveLayerColorEffect::TransientLEDMode::refreshAt(KeyAddr key_addr) { + ::LEDControl.setCrgbAt(key_addr, active_color_); } EventHandlerResult LEDActiveLayerColorEffect::onLayerChange() { diff --git a/src/kaleidoscope/plugin/LED-ActiveLayerColor.h b/src/kaleidoscope/plugin/LED-ActiveLayerColor.h index 2030e0ed..0ee80de9 100644 --- a/src/kaleidoscope/plugin/LED-ActiveLayerColor.h +++ b/src/kaleidoscope/plugin/LED-ActiveLayerColor.h @@ -44,7 +44,10 @@ class LEDActiveLayerColorEffect : public Plugin, protected: virtual void onActivate(void) final; - virtual void refreshAt(byte row, byte col) final; + virtual void refreshAt(KeyAddr key_addr) final; + DEPRECATED(ROW_COL_FUNC) void refreshAt(byte row, byte col) final { + refreshAt(KeyAddr(row, col)); + } private: diff --git a/src/kaleidoscope/plugin/LED-ActiveModColor.cpp b/src/kaleidoscope/plugin/LED-ActiveModColor.cpp index 88b21baa..6636b6fa 100644 --- a/src/kaleidoscope/plugin/LED-ActiveModColor.cpp +++ b/src/kaleidoscope/plugin/LED-ActiveModColor.cpp @@ -22,7 +22,7 @@ namespace kaleidoscope { namespace plugin { -uint8_t ActiveModColorEffect::mod_keys_[MAX_MODS_PER_LAYER]; +KeyAddr ActiveModColorEffect::mod_keys_[MAX_MODS_PER_LAYER]; uint8_t ActiveModColorEffect::mod_key_count_; bool ActiveModColorEffect::highlight_normal_modifiers_ = true; @@ -38,17 +38,14 @@ EventHandlerResult ActiveModColorEffect::onLayerChange() { mod_key_count_ = 0; - for (byte r = 0; r < ROWS; r++) { - for (byte c = 0; c < COLS; c++) { - Key k = Layer.lookupOnActiveLayer(r, c); - - if (::OneShot.isOneShotKey(k) || - (highlight_normal_modifiers_ && ( - (k.raw >= Key_LeftControl.raw && k.raw <= Key_RightGui.raw) || - (k.flags == (SYNTHETIC | SWITCH_TO_KEYMAP))))) { - uint8_t coords = r * COLS + c; - mod_keys_[mod_key_count_++] = coords; - } + for (auto key_addr : KeyAddr::all()) { + Key k = Layer.lookupOnActiveLayer(key_addr); + + if (::OneShot.isOneShotKey(k) || + (highlight_normal_modifiers_ && ( + (k.raw >= Key_LeftControl.raw && k.raw <= Key_RightGui.raw) || + (k.flags == (SYNTHETIC | SWITCH_TO_KEYMAP))))) { + mod_keys_[mod_key_count_++] = key_addr; } } @@ -61,33 +58,31 @@ EventHandlerResult ActiveModColorEffect::beforeReportingState() { } for (uint8_t i = 0; i < mod_key_count_; i++) { - uint8_t coords = mod_keys_[i]; - byte c = coords % COLS; - byte r = (coords - c) / COLS; + const KeyAddr &key_addr = mod_keys_[i]; - Key k = Layer.lookupOnActiveLayer(r, c); + Key k = Layer.lookupOnActiveLayer(key_addr); if (::OneShot.isOneShotKey(k)) { if (::OneShot.isSticky(k)) - ::LEDControl.setCrgbAt(r, c, sticky_color); + ::LEDControl.setCrgbAt(key_addr, sticky_color); else if (::OneShot.isActive(k)) - ::LEDControl.setCrgbAt(r, c, highlight_color); + ::LEDControl.setCrgbAt(key_addr, highlight_color); else - ::LEDControl.refreshAt(r, c); + ::LEDControl.refreshAt(key_addr); } else if (k.raw >= Key_LeftControl.raw && k.raw <= Key_RightGui.raw) { if (hid::isModifierKeyActive(k)) - ::LEDControl.setCrgbAt(r, c, highlight_color); + ::LEDControl.setCrgbAt(key_addr, highlight_color); else - ::LEDControl.refreshAt(r, c); + ::LEDControl.refreshAt(key_addr); } else if (k.flags == (SYNTHETIC | SWITCH_TO_KEYMAP)) { uint8_t layer = k.keyCode; if (layer >= LAYER_SHIFT_OFFSET) layer -= LAYER_SHIFT_OFFSET; if (Layer.isActive(layer)) - ::LEDControl.setCrgbAt(r, c, highlight_color); + ::LEDControl.setCrgbAt(key_addr, highlight_color); else - ::LEDControl.refreshAt(r, c); + ::LEDControl.refreshAt(key_addr); } } diff --git a/src/kaleidoscope/plugin/LED-ActiveModColor.h b/src/kaleidoscope/plugin/LED-ActiveModColor.h index 1ea1d729..a75e4a0f 100644 --- a/src/kaleidoscope/plugin/LED-ActiveModColor.h +++ b/src/kaleidoscope/plugin/LED-ActiveModColor.h @@ -40,7 +40,7 @@ class ActiveModColorEffect : public kaleidoscope::Plugin { private: static bool highlight_normal_modifiers_; - static uint8_t mod_keys_[MAX_MODS_PER_LAYER]; + static KeyAddr mod_keys_[MAX_MODS_PER_LAYER]; static uint8_t mod_key_count_; }; } diff --git a/src/kaleidoscope/plugin/LED-AlphaSquare.cpp b/src/kaleidoscope/plugin/LED-AlphaSquare.cpp index 30ee3249..459acd93 100644 --- a/src/kaleidoscope/plugin/LED-AlphaSquare.cpp +++ b/src/kaleidoscope/plugin/LED-AlphaSquare.cpp @@ -63,7 +63,7 @@ static const uint16_t alphabet[] PROGMEM = { cRGB AlphaSquare::color = {0x80, 0x80, 0x80}; -void AlphaSquare::display(Key key, uint8_t row, uint8_t col, cRGB key_color) { +void AlphaSquare::display(Key key, KeyAddr key_addr, cRGB key_color) { if (!Kaleidoscope.has_leds) return; @@ -73,14 +73,14 @@ void AlphaSquare::display(Key key, uint8_t row, uint8_t col, cRGB key_color) { uint8_t index = key.keyCode - Key_A.keyCode; uint16_t symbol = pgm_read_word(&alphabet[index]); - display(symbol, row, col, key_color); + display(symbol, key_addr, key_color); } -void AlphaSquare::display(Key key, uint8_t row, uint8_t col) { - display(key, row, col, color); +void AlphaSquare::display(Key key, KeyAddr key_addr) { + display(key, key_addr, color); } -void AlphaSquare::display(uint16_t symbol, uint8_t row, uint8_t col, cRGB key_color) { +void AlphaSquare::display(uint16_t symbol, KeyAddr key_addr, cRGB key_color) { if (!Kaleidoscope.has_leds) return; @@ -90,20 +90,22 @@ void AlphaSquare::display(uint16_t symbol, uint8_t row, uint8_t col, cRGB key_co if (!pixel) continue; - ::LEDControl.setCrgbAt(row + r, col + c, key_color); + KeyAddr shifted_addr = key_addr.shifted(r, c); + + ::LEDControl.setCrgbAt(shifted_addr, key_color); } } ::LEDControl.syncLeds(); } -void AlphaSquare::display(uint16_t symbol, uint8_t row, uint8_t col) { - display(symbol, row, col, color); +void AlphaSquare::display(uint16_t symbol, KeyAddr key_addr) { + display(symbol, key_addr, color); } bool AlphaSquare::isSymbolPart(Key key, - uint8_t display_row, uint8_t display_col, - uint8_t row, uint8_t col) { + KeyAddr displayLedAddr, + KeyAddr key_addr) { if (!Kaleidoscope.has_leds) return false; @@ -113,12 +115,12 @@ bool AlphaSquare::isSymbolPart(Key key, uint8_t index = key.keyCode - Key_A.keyCode; uint16_t symbol = pgm_read_word(&alphabet[index]); - return isSymbolPart(symbol, display_row, display_col, row, col); + return isSymbolPart(symbol, displayLedAddr, key_addr); } bool AlphaSquare::isSymbolPart(uint16_t symbol, - uint8_t display_row, uint8_t display_col, - uint8_t row, uint8_t col) { + KeyAddr displayLedAddr, + KeyAddr key_addr) { if (!Kaleidoscope.has_leds) return false; @@ -126,8 +128,8 @@ bool AlphaSquare::isSymbolPart(uint16_t symbol, for (uint8_t c = 0; c < 4; c++) { uint8_t pixel = bitRead(symbol, r * 4 + c); - if (display_row + r == row && - display_col + c == col) + KeyAddr addr_shifted = displayLedAddr.shifted(r, c); + if (addr_shifted == key_addr) return !!pixel; } } diff --git a/src/kaleidoscope/plugin/LED-AlphaSquare.h b/src/kaleidoscope/plugin/LED-AlphaSquare.h index 2c8525af..5dd38d80 100644 --- a/src/kaleidoscope/plugin/LED-AlphaSquare.h +++ b/src/kaleidoscope/plugin/LED-AlphaSquare.h @@ -35,52 +35,81 @@ namespace kaleidoscope { namespace plugin { class AlphaSquare : public kaleidoscope::Plugin { public: + AlphaSquare(void) {} - static void display(Key key, uint8_t row, uint8_t col, cRGB key_color); - static void display(Key key, uint8_t row, uint8_t col); + static void display(Key key, KeyAddr key_addr, cRGB key_color); + DEPRECATED(ROW_COL_FUNC) static void display(Key key, uint8_t row, uint8_t col, cRGB key_color) { + display(key, KeyAddr(row, col), key_color); + } + static void display(Key key, KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static void display(Key key, uint8_t row, uint8_t col) { + display(key, KeyAddr(row, col)); + } static void display(Key key) { - display(key, 0, 2); + display(key, KeyAddr(0, 2)); } static void display(Key key, uint8_t col) { - display(key, 0, col); + display(key, KeyAddr(0, col)); } - static void display(uint16_t symbol, uint8_t row, uint8_t col, cRGB key_color); - static void display(uint16_t symbol, uint8_t row, uint8_t col); + static void display(uint16_t symbol, KeyAddr key_addr, cRGB key_color); + DEPRECATED(ROW_COL_FUNC) static void display(uint16_t symbol, uint8_t row, uint8_t col, cRGB key_color) { + display(symbol, KeyAddr(row, col), key_color); + } + static void display(uint16_t symbol, KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static void display(uint16_t symbol, uint8_t row, uint8_t col) { + display(symbol, KeyAddr(row, col)); + } static void display(uint16_t symbol) { - display(symbol, 0, 2); + display(symbol, KeyAddr(0, 2)); } static void display(uint16_t symbol, uint8_t col) { - display(symbol, 0, col); + display(symbol, KeyAddr(0, col)); } - static void clear(Key key, uint8_t row, uint8_t col) { - display(key, row, col, {0, 0, 0}); + static void clear(Key key, KeyAddr key_addr) { + display(key, key_addr, {0, 0, 0}); + } + DEPRECATED(ROW_COL_FUNC) static void clear(Key key, uint8_t row, uint8_t col) { + clear(key, KeyAddr(row, col)); } static void clear(Key key, uint8_t col) { - clear(key, 0, col); + clear(key, KeyAddr(0, col)); } static void clear(Key key) { - clear(key, 0, 2); + clear(key, KeyAddr(0, 2)); } - static void clear(uint16_t symbol, uint8_t row, uint8_t col) { - display(symbol, row, col, {0, 0, 0}); + static void clear(uint16_t symbol, KeyAddr key_addr) { + display(symbol, key_addr, {0, 0, 0}); + } + DEPRECATED(ROW_COL_FUNC) static void clear(uint16_t symbol, uint8_t row, uint8_t col) { + clear(symbol, KeyAddr(row, col)); } static void clear(uint16_t symbol, uint8_t col) { - clear(symbol, 0, col); + clear(symbol, KeyAddr(0, col)); } static void clear(uint16_t symbol) { - clear(symbol, 0, 2); + clear(symbol, KeyAddr(0, 2)); } static bool isSymbolPart(Key key, - uint8_t display_row, uint8_t display_col, - uint8_t row, uint8_t col); + KeyAddr displayLedAddr, + KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static bool isSymbolPart(Key key, + uint8_t display_row, uint8_t display_col, + uint8_t row, uint8_t col) { + return isSymbolPart(key, KeyAddr(display_row, display_col), KeyAddr(row, col)); + } static bool isSymbolPart(uint16_t symbol, - uint8_t display_row, uint8_t display_col, - uint8_t row, uint8_t col); + KeyAddr displayLedAddr, + KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static bool isSymbolPart(uint16_t symbol, + uint8_t display_row, uint8_t display_col, + uint8_t row, uint8_t col) { + return isSymbolPart(symbol, KeyAddr(display_row, display_col), KeyAddr(row, col)); + } static cRGB color; }; diff --git a/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.cpp b/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.cpp index e37d03cb..e17a9f99 100644 --- a/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.cpp +++ b/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.cpp @@ -43,12 +43,12 @@ void AlphaSquareEffect::TransientLEDMode::update(void) { } } -void AlphaSquareEffect::TransientLEDMode::refreshAt(byte row, byte col) { +void AlphaSquareEffect::TransientLEDMode::refreshAt(KeyAddr key_addr) { bool timed_out; uint8_t display_col = 2; Key key = last_key_left_; - if (col < COLS / 2) { + if (key_addr.col() < COLS / 2) { timed_out = Kaleidoscope.hasTimeExpired(start_time_left_, length); } else { key = last_key_right_; @@ -56,11 +56,11 @@ void AlphaSquareEffect::TransientLEDMode::refreshAt(byte row, byte col) { timed_out = Kaleidoscope.hasTimeExpired(start_time_right_, length); } - if (!::AlphaSquare.isSymbolPart(key, 0, display_col, row, col) || timed_out) - ::LEDControl.setCrgbAt(row, col, CRGB(0, 0, 0)); + if (!::AlphaSquare.isSymbolPart(key, KeyAddr(0, display_col), key_addr) || timed_out) + ::LEDControl.setCrgbAt(key_addr, CRGB(0, 0, 0)); } -EventHandlerResult AlphaSquareEffect::onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState) { +EventHandlerResult AlphaSquareEffect::onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState) { if (!Kaleidoscope.has_leds) return EventHandlerResult::OK; @@ -81,7 +81,7 @@ EventHandlerResult AlphaSquareEffect::onKeyswitchEvent(Key &mappedKey, byte row, Key prev_key = this_led_mode->last_key_left_; - if (col < COLS / 2) { + if (key_addr.col() < COLS / 2) { this_led_mode->last_key_left_ = mappedKey; this_led_mode->start_time_left_ = Kaleidoscope.millisAtCycleStart(); } else { diff --git a/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.h b/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.h index 6bf228d0..a7a9788a 100644 --- a/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.h +++ b/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.h @@ -30,7 +30,7 @@ class AlphaSquareEffect : public Plugin, static uint16_t length; - EventHandlerResult onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState); // This class' instance has dynamic lifetime // @@ -40,7 +40,10 @@ class AlphaSquareEffect : public Plugin, protected: void update(void) final; - void refreshAt(byte row, byte col) final; + void refreshAt(KeyAddr key_addr) final; + DEPRECATED(ROW_COL_FUNC) void refreshAt(byte row, byte col) final { + refreshAt(KeyAddr(row, col)); + } private: uint16_t start_time_left_, start_time_right_; diff --git a/src/kaleidoscope/plugin/LED-Palette-Theme.cpp b/src/kaleidoscope/plugin/LED-Palette-Theme.cpp index 34c08d93..4611125f 100644 --- a/src/kaleidoscope/plugin/LED-Palette-Theme.cpp +++ b/src/kaleidoscope/plugin/LED-Palette-Theme.cpp @@ -37,21 +37,21 @@ void LEDPaletteTheme::updateHandler(uint16_t theme_base, uint8_t theme) { uint16_t map_base = theme_base + (theme * KeyboardHardware.numKeys() / 2); - for (uint16_t pos = 0; pos < KeyboardHardware.numKeys(); pos++) { + for (uint8_t pos = 0; pos < KeyboardHardware.numKeys(); pos++) { cRGB color = lookupColorAtPosition(map_base, pos); ::LEDControl.setCrgbAt(pos, color); } } -void LEDPaletteTheme::refreshAt(uint16_t theme_base, uint8_t theme, byte row, byte col) { +void LEDPaletteTheme::refreshAt(uint16_t theme_base, uint8_t theme, KeyAddr key_addr) { if (!Kaleidoscope.has_leds) return; uint16_t map_base = theme_base + (theme * KeyboardHardware.numKeys() / 2); - uint16_t pos = KeyboardHardware.getLedIndex(row, col); + uint8_t pos = KeyboardHardware.getLedIndex(key_addr); cRGB color = lookupColorAtPosition(map_base, pos); - ::LEDControl.setCrgbAt(pos, color); + ::LEDControl.setCrgbAt(KeyAddr(pos), color); } diff --git a/src/kaleidoscope/plugin/LED-Palette-Theme.h b/src/kaleidoscope/plugin/LED-Palette-Theme.h index fe8d382f..08c96d63 100644 --- a/src/kaleidoscope/plugin/LED-Palette-Theme.h +++ b/src/kaleidoscope/plugin/LED-Palette-Theme.h @@ -29,7 +29,10 @@ class LEDPaletteTheme : public kaleidoscope::Plugin { static uint16_t reserveThemes(uint8_t max_themes); static void updateHandler(uint16_t theme_base, uint8_t theme); - static void refreshAt(uint16_t theme_base, uint8_t theme, byte row, byte col); + static void refreshAt(uint16_t theme_base, uint8_t theme, KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static void refreshAt(uint16_t theme_base, uint8_t theme, byte row, byte col) { + refreshAt(theme_base, theme, KeyAddr(row, col)); + } static const uint8_t lookupColorIndexAtPosition(uint16_t theme_base, uint16_t position); static const cRGB lookupColorAtPosition(uint16_t theme_base, uint16_t position); diff --git a/src/kaleidoscope/plugin/LED-Stalker.cpp b/src/kaleidoscope/plugin/LED-Stalker.cpp index c225d423..e2301d5e 100644 --- a/src/kaleidoscope/plugin/LED-Stalker.cpp +++ b/src/kaleidoscope/plugin/LED-Stalker.cpp @@ -33,18 +33,18 @@ StalkerEffect::TransientLEDMode::TransientLEDMode(const StalkerEffect *parent) map_{} {} -EventHandlerResult StalkerEffect::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { +EventHandlerResult StalkerEffect::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState) { if (!Kaleidoscope.has_leds) return EventHandlerResult::OK; - if (row >= ROWS || col >= COLS) + if (!key_addr.isValid()) return EventHandlerResult::OK; if (::LEDControl.get_mode_index() != led_mode_id_) return EventHandlerResult::OK; if (keyIsPressed(keyState)) { - ::LEDControl.get_mode()->map_[row][col] = 0xff; + ::LEDControl.get_mode()->map_[key_addr.toInt()] = 0xff; } return EventHandlerResult::OK; @@ -60,18 +60,16 @@ void StalkerEffect::TransientLEDMode::update(void) { if (!Kaleidoscope.hasTimeExpired(step_start_time_, parent_->step_length)) return; - for (byte r = 0; r < ROWS; r++) { - for (byte c = 0; c < COLS; c++) { - uint8_t step = map_[r][c]; - if (step) { - ::LEDControl.setCrgbAt(r, c, parent_->variant->compute(&step)); - } + for (auto key_addr : KeyAddr::all()) { + uint8_t step = map_[key_addr.toInt()]; + if (step) { + ::LEDControl.setCrgbAt(key_addr, parent_->variant->compute(&step)); + } - map_[r][c] = step; + map_[key_addr.toInt()] = step; - if (!map_[r][c]) - ::LEDControl.setCrgbAt(r, c, parent_->inactive_color); - } + if (!map_[key_addr.toInt()]) + ::LEDControl.setCrgbAt(key_addr, parent_->inactive_color); } step_start_time_ = Kaleidoscope.millisAtCycleStart(); diff --git a/src/kaleidoscope/plugin/LED-Stalker.h b/src/kaleidoscope/plugin/LED-Stalker.h index dc7ca1a3..47ad0263 100644 --- a/src/kaleidoscope/plugin/LED-Stalker.h +++ b/src/kaleidoscope/plugin/LED-Stalker.h @@ -39,7 +39,7 @@ class StalkerEffect : public Plugin, static uint16_t step_length; static cRGB inactive_color; - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState); // This class' instance has dynamic lifetime // @@ -61,7 +61,7 @@ class StalkerEffect : public Plugin, const StalkerEffect *parent_; uint16_t step_start_time_; - uint8_t map_[ROWS][COLS]; + uint8_t map_[KeyboardHardware.numKeys()]; friend class StalkerEffect; }; diff --git a/src/kaleidoscope/plugin/LED-Wavepool.cpp b/src/kaleidoscope/plugin/LED-Wavepool.cpp index 099b175f..9112e513 100644 --- a/src/kaleidoscope/plugin/LED-Wavepool.cpp +++ b/src/kaleidoscope/plugin/LED-Wavepool.cpp @@ -45,21 +45,20 @@ WavepoolEffect::TransientLEDMode::TransientLEDMode(const WavepoolEffect *parent) page_(0) {} -EventHandlerResult WavepoolEffect::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { - if (row >= ROWS || col >= COLS) +EventHandlerResult WavepoolEffect::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { + if (!key_addr.isValid()) return EventHandlerResult::OK; if (::LEDControl.get_mode_index() != led_mode_id_) return EventHandlerResult::OK; return ::LEDControl.get_mode() - ->onKeyswitchEvent(mapped_key, row, col, key_state); + ->onKeyswitchEvent(mapped_key, key_addr, key_state); } -EventHandlerResult WavepoolEffect::TransientLEDMode::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult WavepoolEffect::TransientLEDMode::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (keyIsPressed(key_state)) { - uint8_t offset = (row * COLS) + col; - surface_[page_][pgm_read_byte(rc2pos + offset)] = 0x7f; + surface_[page_][pgm_read_byte(rc2pos + key_addr.toInt())] = 0x7f; frames_since_event_ = 0; } @@ -191,32 +190,29 @@ void WavepoolEffect::TransientLEDMode::update(void) { #endif // draw the water on the keys - for (byte r = 0; r < ROWS; r++) { - for (byte c = 0; c < COLS; c++) { - uint8_t offset = (r * COLS) + c; - int8_t height = oldpg[pgm_read_byte(rc2pos + offset)]; + for (auto key_addr : KeyAddr::all()) { + int8_t height = oldpg[pgm_read_byte(rc2pos + key_addr.toInt())]; #ifdef INTERPOLATE - if (now & 1) { // odd frames only - // average height with other frame - height = ((int16_t)height + newpg[pgm_read_byte(rc2pos + offset)]) >> 1; - } + if (now & 1) { // odd frames only + // average height with other frame + height = ((int16_t)height + newpg[pgm_read_byte(rc2pos + key_addr.toInt())]) >> 1; + } #endif - uint8_t intensity = abs(height) * 2; - uint8_t saturation = 0xff - intensity; - uint8_t value = (intensity >= 128) ? 255 : intensity << 1; - int16_t hue = ripple_hue; + uint8_t intensity = abs(height) * 2; + uint8_t saturation = 0xff - intensity; + uint8_t value = (intensity >= 128) ? 255 : intensity << 1; + int16_t hue = ripple_hue; - if (ripple_hue == WavepoolEffect::rainbow_hue) { - // color starts white but gets dimmer and more saturated as it fades, - // with hue wobbling according to height map - hue = (current_hue + height + (height >> 1)) & 0xff; - } + if (ripple_hue == WavepoolEffect::rainbow_hue) { + // color starts white but gets dimmer and more saturated as it fades, + // with hue wobbling according to height map + hue = (current_hue + height + (height >> 1)) & 0xff; + } - cRGB color = hsvToRgb(hue, saturation, value); + cRGB color = hsvToRgb(hue, saturation, value); - ::LEDControl.setCrgbAt(r, c, color); - } + ::LEDControl.setCrgbAt(key_addr, color); } #ifdef INTERPOLATE diff --git a/src/kaleidoscope/plugin/LED-Wavepool.h b/src/kaleidoscope/plugin/LED-Wavepool.h index e5877171..c715e048 100644 --- a/src/kaleidoscope/plugin/LED-Wavepool.h +++ b/src/kaleidoscope/plugin/LED-Wavepool.h @@ -34,7 +34,7 @@ class WavepoolEffect : public Plugin, public: WavepoolEffect(void) {} - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); // ms before idle animation starts after last keypress static uint16_t idle_timeout; @@ -53,7 +53,7 @@ class WavepoolEffect : public Plugin, // TransientLEDMode(const WavepoolEffect *parent); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); protected: diff --git a/src/kaleidoscope/plugin/LEDControl.cpp b/src/kaleidoscope/plugin/LEDControl.cpp index aac66d20..4cf49bf3 100644 --- a/src/kaleidoscope/plugin/LEDControl.cpp +++ b/src/kaleidoscope/plugin/LEDControl.cpp @@ -101,16 +101,19 @@ void LEDControl::set_all_leds_to(cRGB color) { } } -void LEDControl::setCrgbAt(int8_t i, cRGB crgb) { - KeyboardHardware.setCrgbAt(i, crgb); +void LEDControl::setCrgbAt(int8_t led_index, cRGB crgb) { + KeyboardHardware.setCrgbAt(led_index, crgb); } -void LEDControl::setCrgbAt(byte row, byte col, cRGB color) { - KeyboardHardware.setCrgbAt(row, col, color); +void LEDControl::setCrgbAt(KeyAddr key_addr, cRGB color) { + KeyboardHardware.setCrgbAt(key_addr, color); } -cRGB LEDControl::getCrgbAt(int8_t i) { - return KeyboardHardware.getCrgbAt(i); +cRGB LEDControl::getCrgbAt(int8_t led_index) { + return KeyboardHardware.getCrgbAt(led_index); +} +cRGB LEDControl::getCrgbAt(KeyAddr key_addr) { + return KeyboardHardware.getCrgbAt(KeyboardHardware.getLedIndex(key_addr)); } void LEDControl::syncLeds(void) { @@ -132,7 +135,7 @@ kaleidoscope::EventHandlerResult LEDControl::onSetup() { return EventHandlerResult::OK; } -kaleidoscope::EventHandlerResult LEDControl::onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState) { +kaleidoscope::EventHandlerResult LEDControl::onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState) { if (mappedKey.flags != (SYNTHETIC | IS_INTERNAL | LED_TOGGLE)) return kaleidoscope::EventHandlerResult::OK; @@ -236,22 +239,24 @@ EventHandlerResult FocusLEDCommand::onFocusEvent(const char *command) { } case THEME: { if (::Focus.isEOL()) { - for (int8_t idx = 0; idx < LED_COUNT; idx++) { - cRGB c = ::LEDControl.getCrgbAt(idx); + for (auto key_addr : KeyAddr::all()) { + cRGB c = ::LEDControl.getCrgbAt(key_addr); ::Focus.send(c); } break; } - int8_t idx = 0; - while (idx < LED_COUNT && !::Focus.isEOL()) { + for (auto key_addr : KeyAddr::all()) { + if (::Focus.isEOL()) { + break; + } + cRGB color; ::Focus.read(color); - ::LEDControl.setCrgbAt(idx, color); - idx++; + ::LEDControl.setCrgbAt(key_addr, color); } break; } diff --git a/src/kaleidoscope/plugin/LEDControl.h b/src/kaleidoscope/plugin/LEDControl.h index 4b4e2eb6..8001bacf 100644 --- a/src/kaleidoscope/plugin/LEDControl.h +++ b/src/kaleidoscope/plugin/LEDControl.h @@ -46,11 +46,11 @@ class LEDControl : public kaleidoscope::Plugin { cur_led_mode_->update(); } - static void refreshAt(byte row, byte col) { + static void refreshAt(KeyAddr key_addr) { if (!Kaleidoscope.has_leds) return; - cur_led_mode_->refreshAt(row, col); + cur_led_mode_->refreshAt(key_addr); } static void set_mode(uint8_t mode_id); static uint8_t get_mode_index() { @@ -62,6 +62,10 @@ class LEDControl : public kaleidoscope::Plugin { template static LEDMode__ *get_mode() { return static_cast(cur_led_mode_); + + } + DEPRECATED(ROW_COL_FUNC) static void refreshAt(byte row, byte col) { + refreshAt(KeyAddr(row, col)); } static void refreshAll() { @@ -81,9 +85,16 @@ class LEDControl : public kaleidoscope::Plugin { return 0; } - static void setCrgbAt(int8_t i, cRGB crgb); - static void setCrgbAt(byte row, byte col, cRGB color); - static cRGB getCrgbAt(int8_t i); + static void setCrgbAt(int8_t led_index, cRGB crgb); + static void setCrgbAt(KeyAddr key_addr, cRGB color); + DEPRECATED(ROW_COL_FUNC) static void setCrgbAt(byte row, byte col, cRGB color) { + setCrgbAt(KeyAddr(row, col), color); + } + static cRGB getCrgbAt(int8_t led_index); + static cRGB getCrgbAt(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) static cRGB getCrgbAt(byte row, byte col) { + return getCrgbAt(KeyAddr(row, col)); + } static void syncLeds(void); static void set_all_leds_to(uint8_t r, uint8_t g, uint8_t b); @@ -99,7 +110,7 @@ class LEDControl : public kaleidoscope::Plugin { static bool paused; kaleidoscope::EventHandlerResult onSetup(); - kaleidoscope::EventHandlerResult onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState); + kaleidoscope::EventHandlerResult onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState); kaleidoscope::EventHandlerResult beforeReportingState(); private: diff --git a/src/kaleidoscope/plugin/LEDControl/LED-Off.cpp b/src/kaleidoscope/plugin/LEDControl/LED-Off.cpp index 175ccab1..e6792160 100644 --- a/src/kaleidoscope/plugin/LEDControl/LED-Off.cpp +++ b/src/kaleidoscope/plugin/LEDControl/LED-Off.cpp @@ -22,8 +22,8 @@ void LEDOff::onActivate(void) { ::LEDControl.set_all_leds_to({0, 0, 0}); } -void LEDOff::refreshAt(byte row, byte col) { - ::LEDControl.setCrgbAt(row, col, {0, 0, 0}); +void LEDOff::refreshAt(KeyAddr key_addr) { + ::LEDControl.setCrgbAt(key_addr, {0, 0, 0}); } } } diff --git a/src/kaleidoscope/plugin/LEDControl/LED-Off.h b/src/kaleidoscope/plugin/LEDControl/LED-Off.h index a13bec5a..fae240bd 100644 --- a/src/kaleidoscope/plugin/LEDControl/LED-Off.h +++ b/src/kaleidoscope/plugin/LEDControl/LED-Off.h @@ -30,7 +30,10 @@ class LEDOff : public LEDMode { protected: void onActivate(void) final; - void refreshAt(byte row, byte col) final; + void refreshAt(KeyAddr key_addr) final; + DEPRECATED(ROW_COL_FUNC) void refreshAt(byte row, byte col) final { + refreshAt(KeyAddr(row, col)); + } }; } } diff --git a/src/kaleidoscope/plugin/LEDEffect-BootAnimation.cpp b/src/kaleidoscope/plugin/LEDEffect-BootAnimation.cpp index a44f4d9c..ac52d933 100644 --- a/src/kaleidoscope/plugin/LEDEffect-BootAnimation.cpp +++ b/src/kaleidoscope/plugin/LEDEffect-BootAnimation.cpp @@ -52,20 +52,17 @@ EventHandlerResult BootAnimationEffect::afterEachCycle() { return EventHandlerResult::OK; } - byte row = 255, col = 255; + KeyAddr key_addr_found; - for (uint8_t r = 0; r < ROWS; r++) { - for (uint8_t c = 0; c < COLS; c++) { - Key k = Layer.lookupOnActiveLayer(r, c); - Key g; - g.flags = 0; - g.keyCode = pgm_read_byte(&greeting_[current_index_]); + for (auto key_addr : KeyAddr::all()) { + Key k = Layer.lookupOnActiveLayer(key_addr); + Key g; + g.flags = 0; + g.keyCode = pgm_read_byte(&greeting_[current_index_]); - if (k.raw == g.raw) { - row = r; - col = c; - break; - } + if (k.raw == g.raw) { + key_addr_found = key_addr; + break; } } @@ -75,13 +72,13 @@ EventHandlerResult BootAnimationEffect::afterEachCycle() { done_ = true; start_time_ += timeout; - if (row != 255 && col != 255) - ::LEDControl.refreshAt(row, col); + if (key_addr_found.isValid()) + ::LEDControl.refreshAt(KeyAddr(key_addr_found)); return EventHandlerResult::OK; } - if (row != 255 && col != 255) { - ::LEDControl.setCrgbAt(row, col, color); + if (key_addr_found.isValid()) { + ::LEDControl.setCrgbAt(KeyAddr(key_addr_found), color); } return EventHandlerResult::OK; diff --git a/src/kaleidoscope/plugin/LEDEffect-BootGreeting.cpp b/src/kaleidoscope/plugin/LEDEffect-BootGreeting.cpp index a1e744c8..36f598d5 100644 --- a/src/kaleidoscope/plugin/LEDEffect-BootGreeting.cpp +++ b/src/kaleidoscope/plugin/LEDEffect-BootGreeting.cpp @@ -21,38 +21,31 @@ namespace kaleidoscope { namespace plugin { bool BootGreetingEffect::done_ = false; -byte BootGreetingEffect::row_; -byte BootGreetingEffect::col_; -byte BootGreetingEffect::key_row = 255; -byte BootGreetingEffect::key_col = 255; +KeyAddr BootGreetingEffect::key_addr_; +KeyAddr BootGreetingEffect::user_key_addr; Key BootGreetingEffect::search_key = Key_LEDEffectNext; uint8_t BootGreetingEffect::hue = 170; uint16_t BootGreetingEffect::start_time = 0; uint16_t BootGreetingEffect::timeout = 9200; -BootGreetingEffect::BootGreetingEffect(byte pos_row, byte pos_col) { - key_row = pos_row; - key_col = pos_col; +BootGreetingEffect::BootGreetingEffect(KeyAddr key_addr) { + user_key_addr = key_addr; } void BootGreetingEffect::findLed(void) { - if (key_col != 255 && key_row != 255) { - row_ = key_row; - col_ = key_col; + if (user_key_addr.isValid()) { + key_addr_ = user_key_addr; done_ = true; return; } // Find the LED key. - for (uint8_t r = 0; r < ROWS; r++) { - for (uint8_t c = 0; c < COLS; c++) { - Key k = Layer.lookupOnActiveLayer(r, c); - - if (k.raw == search_key.raw) { - row_ = r; - col_ = c; - return; - } + for (auto key_addr : KeyAddr::all()) { + Key k = Layer.lookupOnActiveLayer(key_addr); + + if (k.raw == search_key.raw) { + key_addr_ = key_addr; + return; } } @@ -77,12 +70,12 @@ EventHandlerResult BootGreetingEffect::afterEachCycle() { //Only run for 'timeout' milliseconds if (Kaleidoscope.hasTimeExpired(start_time, timeout)) { done_ = true; - ::LEDControl.refreshAt(row_, col_); + ::LEDControl.refreshAt(key_addr_); return EventHandlerResult::OK; } cRGB color = breath_compute(hue); - ::LEDControl.setCrgbAt(row_, col_, color); + ::LEDControl.setCrgbAt(key_addr_, color); return EventHandlerResult::OK; } diff --git a/src/kaleidoscope/plugin/LEDEffect-BootGreeting.h b/src/kaleidoscope/plugin/LEDEffect-BootGreeting.h index 7dcbbf86..562a941c 100644 --- a/src/kaleidoscope/plugin/LEDEffect-BootGreeting.h +++ b/src/kaleidoscope/plugin/LEDEffect-BootGreeting.h @@ -24,10 +24,11 @@ namespace plugin { class BootGreetingEffect : public kaleidoscope::Plugin { public: BootGreetingEffect(void) {} - BootGreetingEffect(byte, byte); + BootGreetingEffect(KeyAddr key_addr); + DEPRECATED(ROW_COL_FUNC) BootGreetingEffect(byte row, byte col) + : BootGreetingEffect(KeyAddr(row, col)) {} - static byte key_row; - static byte key_col; + static KeyAddr user_key_addr; static Key search_key; static uint8_t hue; static uint16_t timeout; @@ -38,8 +39,7 @@ class BootGreetingEffect : public kaleidoscope::Plugin { private: static void findLed(void); static bool done_; - static byte row_; - static byte col_; + static KeyAddr key_addr_; static uint16_t start_time; }; } diff --git a/src/kaleidoscope/plugin/LEDEffect-Chase.h b/src/kaleidoscope/plugin/LEDEffect-Chase.h index 2a027b2d..31a93764 100644 --- a/src/kaleidoscope/plugin/LEDEffect-Chase.h +++ b/src/kaleidoscope/plugin/LEDEffect-Chase.h @@ -58,7 +58,7 @@ class LEDChaseEffect : public Plugin, const LEDChaseEffect *parent_; - int8_t pos_ = 0; + int8_t pos_ = uint8_t(0); int8_t direction_ = 1; uint16_t last_update_; }; diff --git a/src/kaleidoscope/plugin/LEDEffect-Rainbow.cpp b/src/kaleidoscope/plugin/LEDEffect-Rainbow.cpp index cacf6caf..598bf8fb 100644 --- a/src/kaleidoscope/plugin/LEDEffect-Rainbow.cpp +++ b/src/kaleidoscope/plugin/LEDEffect-Rainbow.cpp @@ -61,13 +61,13 @@ void LEDRainbowWaveEffect::TransientLEDMode::update(void) { rainbow_last_update += parent_->rainbow_update_delay; } - for (int8_t i = 0; i < LED_COUNT; i++) { - uint16_t key_hue = rainbow_hue + 16 * (i / 4); + for (auto key_addr : KeyAddr::all()) { + uint16_t key_hue = rainbow_hue + 16 * (key_addr.toInt() / 4); if (key_hue >= 255) { key_hue -= 255; } cRGB rainbow = hsvToRgb(key_hue, rainbow_saturation, parent_->rainbow_value); - ::LEDControl.setCrgbAt(i, rainbow); + ::LEDControl.setCrgbAt(key_addr.toInt(), rainbow); } rainbow_hue += rainbow_wave_steps; if (rainbow_hue >= 255) { diff --git a/src/kaleidoscope/plugin/LEDEffect-SolidColor.cpp b/src/kaleidoscope/plugin/LEDEffect-SolidColor.cpp index ad929256..1a089792 100644 --- a/src/kaleidoscope/plugin/LEDEffect-SolidColor.cpp +++ b/src/kaleidoscope/plugin/LEDEffect-SolidColor.cpp @@ -25,8 +25,8 @@ void LEDSolidColor::TransientLEDMode::onActivate(void) { parent_->b_); } -void LEDSolidColor::TransientLEDMode::refreshAt(byte row, byte col) { - ::LEDControl.setCrgbAt(row, col, +void LEDSolidColor::TransientLEDMode::refreshAt(KeyAddr key_addr) { + ::LEDControl.setCrgbAt(key_addr, CRGB(parent_->r_, parent_->g_, parent_->b_)); diff --git a/src/kaleidoscope/plugin/LEDEffect-SolidColor.h b/src/kaleidoscope/plugin/LEDEffect-SolidColor.h index d66971f9..0cfaf374 100644 --- a/src/kaleidoscope/plugin/LEDEffect-SolidColor.h +++ b/src/kaleidoscope/plugin/LEDEffect-SolidColor.h @@ -42,7 +42,10 @@ class LEDSolidColor : public Plugin, protected: virtual void onActivate(void) final; - virtual void refreshAt(byte row, byte col) final; + virtual void refreshAt(KeyAddr key_addr) final; + DEPRECATED(ROW_COL_FUNC) virtual void refreshAt(byte row, byte col) final { + refreshAt(KeyAddr(row, col)); + } private: diff --git a/src/kaleidoscope/plugin/LEDMode.h b/src/kaleidoscope/plugin/LEDMode.h index 2f63e690..6a412fb4 100644 --- a/src/kaleidoscope/plugin/LEDMode.h +++ b/src/kaleidoscope/plugin/LEDMode.h @@ -81,6 +81,17 @@ class LEDMode : public kaleidoscope::Plugin, */ virtual void update(void) {} + /** Refresh the color of a given key. + * + * If we have another plugin that overrides colors set by the active LED mode + * (either at @onActivate time, or via @ref update), if that plugin wants to + * restore whatever color the mode would set the key color to, this is the + * method it will call. + * + * @param key_addr is the matrix coordinate of the key to refresh the color of. + */ + virtual void refreshAt(KeyAddr key_addr) {} + /** Refresh the color of a given key. * * If we have another plugin that overrides colors set by the active LED mode @@ -91,7 +102,9 @@ class LEDMode : public kaleidoscope::Plugin, * @param row is the row coordinate of the key to refresh the color of. * @param col is the column coordinate of the key to refresh the color of. */ - virtual void refreshAt(byte row, byte col) {} + DEPRECATED(ROW_COL_FUNC) virtual void refreshAt(byte row, byte col) { + refreshAt(KeyAddr(row, col)); + } public: diff --git a/src/kaleidoscope/plugin/Leader.cpp b/src/kaleidoscope/plugin/Leader.cpp index 8c1d9069..4aefd15f 100644 --- a/src/kaleidoscope/plugin/Leader.cpp +++ b/src/kaleidoscope/plugin/Leader.cpp @@ -77,11 +77,11 @@ void Leader::reset(void) { } void Leader::inject(Key key, uint8_t key_state) { - onKeyswitchEvent(key, UNKNOWN_KEYSWITCH_LOCATION, key_state); + onKeyswitchEvent(key, UnknownKeyswitchLocation, key_state); } // --- hooks --- -EventHandlerResult Leader::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { +EventHandlerResult Leader::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState) { if (keyState & INJECTED) return EventHandlerResult::OK; diff --git a/src/kaleidoscope/plugin/Leader.h b/src/kaleidoscope/plugin/Leader.h index d52db1bd..2fe289a6 100644 --- a/src/kaleidoscope/plugin/Leader.h +++ b/src/kaleidoscope/plugin/Leader.h @@ -46,7 +46,7 @@ class Leader : public kaleidoscope::Plugin { void inject(Key key, uint8_t key_state); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState); EventHandlerResult afterEachCycle(); private: diff --git a/src/kaleidoscope/plugin/Macros.cpp b/src/kaleidoscope/plugin/Macros.cpp index 52b398cc..70040b5d 100644 --- a/src/kaleidoscope/plugin/Macros.cpp +++ b/src/kaleidoscope/plugin/Macros.cpp @@ -27,10 +27,10 @@ namespace plugin { MacroKeyEvent Macros_::active_macros[]; byte Macros_::active_macro_count; -byte Macros_::row, Macros_::col; +KeyAddr Macros_::key_addr; void playMacroKeyswitchEvent(Key key, uint8_t keyswitch_state, bool explicit_report) { - handleKeyswitchEvent(key, UNKNOWN_KEYSWITCH_LOCATION, keyswitch_state | INJECTED); + handleKeyswitchEvent(key, UnknownKeyswitchLocation, keyswitch_state | INJECTED); if (explicit_report) return; @@ -219,12 +219,11 @@ const macro_t *Macros_::type(const char *string) { return MACRO_NONE; } -EventHandlerResult Macros_::onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState) { +EventHandlerResult Macros_::onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState) { if (mappedKey.flags != (SYNTHETIC | IS_MACRO)) return EventHandlerResult::OK; - byte key_id = (row * COLS) + col; - addActiveMacroKey(mappedKey.keyCode, key_id, keyState); + addActiveMacroKey(mappedKey.keyCode, key_addr.toInt(), keyState); return EventHandlerResult::EVENT_CONSUMED; } @@ -238,12 +237,9 @@ EventHandlerResult Macros_::afterEachCycle() { EventHandlerResult Macros_::beforeReportingState() { for (byte i = 0; i < active_macro_count; ++i) { if (active_macros[i].key_id == 0xFF) { - // i.e. UNKNOWN_KEYSWITCH_LOCATION - row = 0xFF; - col = 0xFF; + key_addr = UnknownKeyswitchLocation; } else { - row = active_macros[i].key_id / COLS; - col = active_macros[i].key_id % COLS; + key_addr = KeyAddr(active_macros[i].key_id); } const macro_t *m = macroAction(active_macros[i].key_code, active_macros[i].key_state); diff --git a/src/kaleidoscope/plugin/Macros.h b/src/kaleidoscope/plugin/Macros.h index e0dc9e13..2d398dd9 100644 --- a/src/kaleidoscope/plugin/Macros.h +++ b/src/kaleidoscope/plugin/Macros.h @@ -53,7 +53,7 @@ class Macros_ : public kaleidoscope::Plugin { ++active_macro_count; } - EventHandlerResult onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState); EventHandlerResult beforeReportingState(); EventHandlerResult afterEachCycle(); @@ -74,7 +74,7 @@ class Macros_ : public kaleidoscope::Plugin { return type(strings...); } - static byte row, col; + static KeyAddr key_addr; private: Key lookupAsciiCode(uint8_t ascii_code); diff --git a/src/kaleidoscope/plugin/Model01-TestMode.cpp b/src/kaleidoscope/plugin/Model01-TestMode.cpp index 5789a314..af858c9e 100644 --- a/src/kaleidoscope/plugin/Model01-TestMode.cpp +++ b/src/kaleidoscope/plugin/Model01-TestMode.cpp @@ -92,13 +92,13 @@ void TestMode::test_leds(void) { -void TestMode::handleKeyEvent(side_data_t *side, keydata_t *oldState, keydata_t *newState, uint8_t row, uint8_t col, uint8_t col_offset) { +void TestMode::handleKeyEvent(side_data_t *side, keydata_t *oldState, keydata_t *newState, KeyAddr key_addr, uint8_t col_offset) { constexpr cRGB red = CRGB(201, 0, 0); constexpr cRGB blue = CRGB(0, 0, 201); constexpr cRGB green = CRGB(0, 201, 0); - const uint8_t keynum = (row * 8) + (col); + auto keynum = key_addr.toInt(); const uint8_t keyState = ((bitRead(oldState->all, keynum) << 1) | (bitRead(newState->all, keynum) << 0)); @@ -111,17 +111,17 @@ void TestMode::handleKeyEvent(side_data_t *side, keydata_t *oldState, keydata_t side->cyclesSinceStateChange[keynum]++; } - + auto key_addr_col_shifted = KeyAddr(key_addr.row(), col_offset - key_addr.col()); // If the key is held down if (keyState == HELD) { - KeyboardHardware.setCrgbAt(row, col_offset - col, green); - } else if (bitRead(side->badKeys, keynum) == 1) { + KeyboardHardware.setCrgbAt(key_addr_col_shifted, green); + } else if (bitRead(side->badKeys, key_addr_col_shifted.toInt()) == 1) { // If we triggered chatter detection ever on this key - KeyboardHardware.setCrgbAt(row, col_offset - col, red); + KeyboardHardware.setCrgbAt(key_addr_col_shifted, red); } else if (keyState == TOGGLED_OFF) { // If the key was just released - KeyboardHardware.setCrgbAt(row, col_offset - col, blue); + KeyboardHardware.setCrgbAt(key_addr_col_shifted, blue); } } @@ -143,11 +143,9 @@ void TestMode::testMatrix() { KeyboardHardware.pressedKeyswitchCount() == 3) { break; } - for (byte row = 0; row < 4; row++) { - for (byte col = 0; col < 8; col++) { - handleKeyEvent(&left, &(KeyboardHardware.previousLeftHandState), &(KeyboardHardware.leftHandState), row, col, 7); - handleKeyEvent(&right, &(KeyboardHardware.previousRightHandState), &(KeyboardHardware.rightHandState), row, col, 15); - } + for (auto key_addr : KeyAddr::all()) { + handleKeyEvent(&left, &(KeyboardHardware.previousLeftHandState), &(KeyboardHardware.leftHandState), key_addr, 7); + handleKeyEvent(&right, &(KeyboardHardware.previousRightHandState), &(KeyboardHardware.rightHandState), key_addr, 15); } ::LEDControl.syncLeds(); } diff --git a/src/kaleidoscope/plugin/Model01-TestMode.h b/src/kaleidoscope/plugin/Model01-TestMode.h index 4fc7ba51..5bf59825 100644 --- a/src/kaleidoscope/plugin/Model01-TestMode.h +++ b/src/kaleidoscope/plugin/Model01-TestMode.h @@ -41,7 +41,7 @@ class TestMode : public kaleidoscope::Plugin { static void test_leds(); static void testMatrix(); static void toggle_programming_leds_on(); - static void handleKeyEvent(side_data_t *side, keydata_t *oldState, keydata_t *newState, uint8_t row, uint8_t col, uint8_t col_offset); + static void handleKeyEvent(side_data_t *side, keydata_t *oldState, keydata_t *newState, KeyAddr key_addr, uint8_t col_offset); static void waitForKeypress(); static void set_leds(cRGB color); }; diff --git a/src/kaleidoscope/plugin/MouseKeys.cpp b/src/kaleidoscope/plugin/MouseKeys.cpp index b6b4e13a..24e79879 100644 --- a/src/kaleidoscope/plugin/MouseKeys.cpp +++ b/src/kaleidoscope/plugin/MouseKeys.cpp @@ -104,7 +104,7 @@ EventHandlerResult MouseKeys_::beforeReportingState() { return EventHandlerResult::OK; } -EventHandlerResult MouseKeys_::onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState) { +EventHandlerResult MouseKeys_::onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState) { if (mappedKey.flags != (SYNTHETIC | IS_MOUSE_KEY)) return EventHandlerResult::OK; diff --git a/src/kaleidoscope/plugin/MouseKeys.h b/src/kaleidoscope/plugin/MouseKeys.h index 7a723db3..c6cbfc0b 100644 --- a/src/kaleidoscope/plugin/MouseKeys.h +++ b/src/kaleidoscope/plugin/MouseKeys.h @@ -40,7 +40,7 @@ class MouseKeys_ : public kaleidoscope::Plugin { EventHandlerResult onSetup(); EventHandlerResult beforeReportingState(); EventHandlerResult afterEachCycle(); - EventHandlerResult onKeyswitchEvent(Key &mappedKey, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mappedKey, KeyAddr key_addr, uint8_t keyState); private: static uint8_t mouseMoveIntent; diff --git a/src/kaleidoscope/plugin/NumPad.cpp b/src/kaleidoscope/plugin/NumPad.cpp index 61900bdb..105576ab 100644 --- a/src/kaleidoscope/plugin/NumPad.cpp +++ b/src/kaleidoscope/plugin/NumPad.cpp @@ -25,7 +25,7 @@ cRGB NumPad::color = CRGB(160, 0, 0); uint8_t NumPad::lock_hue = 170; // private: -byte NumPad::numpadLayerToggleKeyRow = 255, NumPad::numpadLayerToggleKeyCol = 255; +KeyAddr NumPad::numpadLayerToggleKeyAddr; bool NumPad::numpadActive = false; EventHandlerResult NumPad::onSetup(void) { @@ -35,27 +35,24 @@ EventHandlerResult NumPad::onSetup(void) { void NumPad::setKeyboardLEDColors(void) { ::LEDControl.set_mode(::LEDControl.get_mode_index()); - for (uint8_t r = 0; r < ROWS; r++) { - for (uint8_t c = 0; c < COLS; c++) { - Key k = Layer.lookupOnActiveLayer(r, c); - Key layer_key = Layer.getKey(numPadLayer, r, c); + for (auto key_addr : KeyAddr::all()) { + Key k = Layer.lookupOnActiveLayer(key_addr); + Key layer_key = Layer.getKey(numPadLayer, key_addr); - if (k == LockLayer(numPadLayer)) { - numpadLayerToggleKeyRow = r; - numpadLayerToggleKeyCol = c; - } + if (k == LockLayer(numPadLayer)) { + numpadLayerToggleKeyAddr = key_addr; + } - if ((k != layer_key) || (k == Key_NoKey) || (k.flags != KEY_FLAGS)) { - ::LEDControl.refreshAt(r, c); - } else { - ::LEDControl.setCrgbAt(r, c, color); - } + if ((k != layer_key) || (k == Key_NoKey) || (k.flags != KEY_FLAGS)) { + ::LEDControl.refreshAt(KeyAddr(key_addr)); + } else { + ::LEDControl.setCrgbAt(KeyAddr(key_addr), color); } } - if ((numpadLayerToggleKeyRow <= ROWS) && (numpadLayerToggleKeyCol <= COLS)) { + if (numpadLayerToggleKeyAddr.isValid()) { cRGB lock_color = breath_compute(lock_hue); - ::LEDControl.setCrgbAt(numpadLayerToggleKeyRow, numpadLayerToggleKeyCol, lock_color); + ::LEDControl.setCrgbAt(KeyAddr(numpadLayerToggleKeyAddr), lock_color); } } diff --git a/src/kaleidoscope/plugin/NumPad.h b/src/kaleidoscope/plugin/NumPad.h index 0a5b8643..2f276419 100644 --- a/src/kaleidoscope/plugin/NumPad.h +++ b/src/kaleidoscope/plugin/NumPad.h @@ -36,8 +36,7 @@ class NumPad : public kaleidoscope::Plugin { void setKeyboardLEDColors(void); - static uint8_t numpadLayerToggleKeyRow; - static uint8_t numpadLayerToggleKeyCol; + static KeyAddr numpadLayerToggleKeyAddr; static bool numpadActive; }; } diff --git a/src/kaleidoscope/plugin/OneShot.cpp b/src/kaleidoscope/plugin/OneShot.cpp index 7c4c05e4..6b05765c 100644 --- a/src/kaleidoscope/plugin/OneShot.cpp +++ b/src/kaleidoscope/plugin/OneShot.cpp @@ -54,7 +54,6 @@ bool OneShot::isStickable(Key key) { // ---- OneShot stuff ---- void OneShot::injectNormalKey(uint8_t idx, uint8_t key_state) { Key key; - byte row, col; if (idx < 8) { key.flags = Key_LeftControl.flags; @@ -64,7 +63,7 @@ void OneShot::injectNormalKey(uint8_t idx, uint8_t key_state) { key.keyCode = LAYER_SHIFT_OFFSET + idx - 8; } - handleKeyswitchEvent(key, UNKNOWN_KEYSWITCH_LOCATION, key_state | INJECTED); + handleKeyswitchEvent(key, UnknownKeyswitchLocation, key_state | INJECTED); } void OneShot::activateOneShot(uint8_t idx) { @@ -76,7 +75,7 @@ void OneShot::cancelOneShot(uint8_t idx) { injectNormalKey(idx, WAS_PRESSED); } -EventHandlerResult OneShot::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { +EventHandlerResult OneShot::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState) { uint8_t idx = mapped_key.raw - ranges::OS_FIRST; if (keyState & INJECTED) @@ -91,7 +90,7 @@ EventHandlerResult OneShot::onKeyswitchEvent(Key &mapped_key, byte row, byte col state_[idx].pressed = false; } else if (keyToggledOn(keyState)) { start_time_ = Kaleidoscope.millisAtCycleStart(); - state_[idx].position = row * COLS + col; + state_[idx].position = key_addr.toInt(); state_[idx].pressed = true; state_[idx].active = true; prev_key_ = mapped_key; @@ -131,7 +130,7 @@ EventHandlerResult OneShot::onKeyswitchEvent(Key &mapped_key, byte row, byte col } else { start_time_ = Kaleidoscope.millisAtCycleStart(); - state_[idx].position = row * COLS + col; + state_[idx].position = key_addr.toInt(); state_[idx].active = true; prev_key_ = mapped_key; @@ -204,7 +203,7 @@ EventHandlerResult OneShot::afterEachCycle() { } void OneShot::inject(Key mapped_key, uint8_t key_state) { - onKeyswitchEvent(mapped_key, UNKNOWN_KEYSWITCH_LOCATION, key_state); + onKeyswitchEvent(mapped_key, UnknownKeyswitchLocation, key_state); } // --- glue code --- diff --git a/src/kaleidoscope/plugin/OneShot.h b/src/kaleidoscope/plugin/OneShot.h index 1ffeb0c7..3142eb29 100644 --- a/src/kaleidoscope/plugin/OneShot.h +++ b/src/kaleidoscope/plugin/OneShot.h @@ -74,7 +74,7 @@ class OneShot : public kaleidoscope::Plugin { EventHandlerResult beforeReportingState(); EventHandlerResult afterEachCycle(); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState); void inject(Key mapped_key, uint8_t key_state); diff --git a/src/kaleidoscope/plugin/Qukeys.cpp b/src/kaleidoscope/plugin/Qukeys.cpp index 43469f7d..34694d1d 100644 --- a/src/kaleidoscope/plugin/Qukeys.cpp +++ b/src/kaleidoscope/plugin/Qukeys.cpp @@ -40,10 +40,9 @@ bool isDualUse(Key k) { } inline -bool isDualUse(byte key_addr) { - byte row = addr::row(key_addr); - byte col = addr::col(key_addr); - Key k = Layer.lookup(row, col); +bool isDualUse(byte key_addr_offset) { + KeyAddr key_addr(key_addr_offset); + Key k = Layer.lookup(key_addr); return isDualUse(k); } @@ -74,9 +73,9 @@ Key getDualUseAlternateKey(Key k) { } -Qukey::Qukey(int8_t layer, byte row, byte col, Key alt_keycode) { +Qukey::Qukey(int8_t layer, KeyAddr key_addr, Key alt_keycode) { this->layer = layer; - this->addr = addr::addr(row, col); + this->addr = key_addr.toInt(); this->alt_keycode = alt_keycode; } @@ -97,16 +96,15 @@ constexpr uint16_t QUKEYS_RELEASE_DELAY_OFFSET = 4096; // Empty constructor; nothing is stored at the instance level Qukeys::Qukeys(void) {} -int8_t Qukeys::lookupQukey(uint8_t key_addr) { - if (key_addr == QUKEY_UNKNOWN_ADDR) { +int8_t Qukeys::lookupQukey(uint8_t key_addr_offset) { + if (key_addr_offset == QUKEY_UNKNOWN_ADDR) { return QUKEY_NOT_FOUND; } for (int8_t i = 0; i < qukeys_count; i++) { - if (qukeys[i].addr == key_addr) { - byte row = addr::row(key_addr); - byte col = addr::col(key_addr); + if (qukeys[i].addr == key_addr_offset) { + KeyAddr key_addr(key_addr_offset); if ((qukeys[i].layer == QUKEY_ALL_LAYERS) || - (qukeys[i].layer == Layer.lookupActiveLayer(row, col))) { + (qukeys[i].layer == Layer.lookupActiveLayer(key_addr))) { return i; } } @@ -138,9 +136,8 @@ int8_t Qukeys::searchQueue(uint8_t key_addr) { bool Qukeys::flushKey(bool qukey_state, uint8_t keyswitch_state) { int8_t qukey_index = lookupQukey(key_queue_[0].addr); bool is_qukey = (qukey_index != QUKEY_NOT_FOUND); - byte row = addr::row(key_queue_[0].addr); - byte col = addr::col(key_queue_[0].addr); - Key keycode = Layer.lookupOnActiveLayer(row, col); + KeyAddr key_addr(key_queue_[0].addr); + Key keycode = Layer.lookupOnActiveLayer(key_addr); bool is_dual_use = isDualUse(keycode); if (is_qukey || is_dual_use) { if (qukey_state == QUKEY_STATE_PRIMARY) { @@ -184,7 +181,7 @@ bool Qukeys::flushKey(bool qukey_state, uint8_t keyswitch_state) { // we can ignore it and don't start an infinite loop. It would be // nice if we could use key_state to also indicate which plugin // injected the key. - handleKeyswitchEvent(keycode, row, col, IS_PRESSED); + handleKeyswitchEvent(keycode, key_addr, IS_PRESSED); // Now we send the report (if there were any changes) hid::sendKeyboardReport(); @@ -193,10 +190,10 @@ bool Qukeys::flushKey(bool qukey_state, uint8_t keyswitch_state) { // Last, if the key is still down, add its code back in if (keyswitch_state & IS_PRESSED) { - handleKeyswitchEvent(keycode, row, col, IS_PRESSED | WAS_PRESSED); + handleKeyswitchEvent(keycode, key_addr, IS_PRESSED | WAS_PRESSED); } else { // If this is the key that was released, send that release event now - handleKeyswitchEvent(Key_NoKey, row, col, WAS_PRESSED); + handleKeyswitchEvent(Key_NoKey, key_addr, WAS_PRESSED); // ...and if there's another key in the queue that's about to also be // flushed, we need to do something to clear this one's modifier flags (if // any) from the previous report @@ -256,10 +253,10 @@ bool Qukeys::isQukey(uint8_t addr) { return (isDualUse(addr) || lookupQukey(addr) != QUKEY_NOT_FOUND); } -EventHandlerResult Qukeys::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult Qukeys::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { // If key_addr is not a physical key, ignore it; some other plugin injected it - if (row >= ROWS || col >= COLS || (key_state & INJECTED) != 0) + if (!key_addr.isValid() || (key_state & INJECTED) != 0) return EventHandlerResult::OK; // If Qukeys is turned off, continue to next plugin @@ -269,8 +266,7 @@ EventHandlerResult Qukeys::onKeyswitchEvent(Key &mapped_key, byte row, byte col, } // get key addr & qukey (if any) - uint8_t key_addr = addr::addr(row, col); - int8_t qukey_index = lookupQukey(key_addr); + int8_t qukey_index = lookupQukey(key_addr.toInt()); // If the key was injected (from the queue being flushed) if (flushing_queue_) { @@ -287,13 +283,13 @@ EventHandlerResult Qukeys::onKeyswitchEvent(Key &mapped_key, byte row, byte col, } // Otherwise, queue the key and stop processing: - enqueue(key_addr); + enqueue(key_addr.toInt()); // flushQueue() has already handled this key release return EventHandlerResult::EVENT_CONSUMED; } // In all other cases, we need to know if the key is queued already - int8_t queue_index = searchQueue(key_addr); + int8_t queue_index = searchQueue(key_addr.toInt()); // If the key was just released: if (keyToggledOff(key_state)) { @@ -305,12 +301,10 @@ EventHandlerResult Qukeys::onKeyswitchEvent(Key &mapped_key, byte row, byte col, // order to send a toggle off of a `ShiftToLayer()` key; otherwise, that layer gets // stuck on if there's a release delay and a rollover. if (delayed_qukey_addr_ != QUKEY_UNKNOWN_ADDR) { - int8_t r = addr::row(delayed_qukey_addr_); - int8_t c = addr::col(delayed_qukey_addr_); flushQueue(queue_index); flushQueue(); flushing_queue_ = true; - handleKeyswitchEvent(Key_NoKey, r, c, WAS_PRESSED); + handleKeyswitchEvent(Key_NoKey, KeyAddr(delayed_qukey_addr_), WAS_PRESSED); flushing_queue_ = false; delayed_qukey_addr_ = QUKEY_UNKNOWN_ADDR; } else { diff --git a/src/kaleidoscope/plugin/Qukeys.h b/src/kaleidoscope/plugin/Qukeys.h index e60e6b52..1485551f 100644 --- a/src/kaleidoscope/plugin/Qukeys.h +++ b/src/kaleidoscope/plugin/Qukeys.h @@ -19,7 +19,6 @@ #pragma once #include -#include #include // Maximum length of the pending queue @@ -59,7 +58,9 @@ namespace plugin { struct Qukey { public: Qukey(void) {} - Qukey(int8_t layer, byte row, byte col, Key alt_keycode); + Qukey(int8_t layer, KeyAddr key_addr, Key alt_keycode); + DEPRECATED(ROW_COL_FUNC) Qukey(int8_t layer, byte row, byte col, Key alt_keycode) + : Qukey(layer, KeyAddr(row, col), alt_keycode) {} int8_t layer; uint8_t addr; @@ -102,7 +103,7 @@ class Qukeys : public kaleidoscope::Plugin { static uint8_t qukeys_count; EventHandlerResult onSetup(); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult beforeReportingState(); private: diff --git a/src/kaleidoscope/plugin/Redial.cpp b/src/kaleidoscope/plugin/Redial.cpp index eecd340d..20c951cb 100644 --- a/src/kaleidoscope/plugin/Redial.cpp +++ b/src/kaleidoscope/plugin/Redial.cpp @@ -24,7 +24,7 @@ Key Redial::key_to_redial_; Key Redial::last_key_; bool Redial::redial_held_ = false; -EventHandlerResult Redial::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult Redial::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (mapped_key == Key_Redial) { if (keyToggledOff(key_state)) key_to_redial_ = last_key_; diff --git a/src/kaleidoscope/plugin/Redial.h b/src/kaleidoscope/plugin/Redial.h index 57aff116..09c9d567 100644 --- a/src/kaleidoscope/plugin/Redial.h +++ b/src/kaleidoscope/plugin/Redial.h @@ -31,7 +31,7 @@ class Redial : public kaleidoscope::Plugin { static bool shouldRemember(Key mappedKey); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); private: static Key key_to_redial_; diff --git a/src/kaleidoscope/plugin/ShapeShifter.cpp b/src/kaleidoscope/plugin/ShapeShifter.cpp index f97cefbf..f81541ae 100644 --- a/src/kaleidoscope/plugin/ShapeShifter.cpp +++ b/src/kaleidoscope/plugin/ShapeShifter.cpp @@ -30,7 +30,7 @@ EventHandlerResult ShapeShifter::beforeReportingState() { return EventHandlerResult::OK; } -EventHandlerResult ShapeShifter::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult ShapeShifter::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (!dictionary) return EventHandlerResult::OK; diff --git a/src/kaleidoscope/plugin/ShapeShifter.h b/src/kaleidoscope/plugin/ShapeShifter.h index 116cd3fe..c1d8bcdd 100644 --- a/src/kaleidoscope/plugin/ShapeShifter.h +++ b/src/kaleidoscope/plugin/ShapeShifter.h @@ -32,7 +32,7 @@ class ShapeShifter : public kaleidoscope::Plugin { static const dictionary_t *dictionary; - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult beforeReportingState(); private: diff --git a/src/kaleidoscope/plugin/SpaceCadet.cpp b/src/kaleidoscope/plugin/SpaceCadet.cpp index 6b1b02e7..8e544649 100644 --- a/src/kaleidoscope/plugin/SpaceCadet.cpp +++ b/src/kaleidoscope/plugin/SpaceCadet.cpp @@ -70,7 +70,7 @@ bool SpaceCadet::active() { return !disabled; } -EventHandlerResult SpaceCadet::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult SpaceCadet::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { //Handle our synthetic keys for enabling and disabling functionality if (mapped_key.raw >= kaleidoscope::ranges::SC_FIRST && mapped_key.raw <= kaleidoscope::ranges::SC_LAST) { @@ -130,7 +130,7 @@ EventHandlerResult SpaceCadet::onKeyswitchEvent(Key &mapped_key, byte row, byte //hit another key after this -- if it's a modifier, we want the modifier //key to be added to the report, for things like ctrl, alt, shift, etc) if (map[i].flagged) { - handleKeyswitchEvent(map[i].input, UNKNOWN_KEYSWITCH_LOCATION, IS_PRESSED | INJECTED); + handleKeyswitchEvent(map[i].input, UnknownKeyswitchLocation, IS_PRESSED | INJECTED); } //The keypress wasn't a match, so we need to mark it as not flagged and @@ -225,7 +225,7 @@ EventHandlerResult SpaceCadet::onKeyswitchEvent(Key &mapped_key, byte row, byte //only need to send that key and not the original key. //inject our new key - handleKeyswitchEvent(alternate_key, row, col, IS_PRESSED | INJECTED); + handleKeyswitchEvent(alternate_key, key_addr, IS_PRESSED | INJECTED); //Unflag the key so we don't try this again. map[index].flagged = false; diff --git a/src/kaleidoscope/plugin/SpaceCadet.h b/src/kaleidoscope/plugin/SpaceCadet.h index 9938800a..22a4f078 100644 --- a/src/kaleidoscope/plugin/SpaceCadet.h +++ b/src/kaleidoscope/plugin/SpaceCadet.h @@ -66,7 +66,7 @@ class SpaceCadet : public kaleidoscope::Plugin { static uint16_t time_out; // The global timeout in milliseconds static SpaceCadet::KeyBinding * map; // The map of key bindings - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); private: static bool disabled; diff --git a/src/kaleidoscope/plugin/Syster.cpp b/src/kaleidoscope/plugin/Syster.cpp index e3cecc68..b2247176 100644 --- a/src/kaleidoscope/plugin/Syster.cpp +++ b/src/kaleidoscope/plugin/Syster.cpp @@ -43,7 +43,7 @@ bool Syster::is_active(void) { } // --- hooks --- -EventHandlerResult Syster::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { +EventHandlerResult Syster::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState) { if (!is_active_) { if (!isSyster(mapped_key)) return EventHandlerResult::OK; @@ -69,9 +69,9 @@ EventHandlerResult Syster::onKeyswitchEvent(Key &mapped_key, byte row, byte col, if (keyToggledOff(keyState)) { if (mapped_key == Key_Spacebar) { for (uint8_t i = 0; i <= symbol_pos_; i++) { - handleKeyswitchEvent(Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, IS_PRESSED | INJECTED); + handleKeyswitchEvent(Key_Backspace, UnknownKeyswitchLocation, IS_PRESSED | INJECTED); hid::sendKeyboardReport(); - handleKeyswitchEvent(Key_Backspace, UNKNOWN_KEYSWITCH_LOCATION, WAS_PRESSED | INJECTED); + handleKeyswitchEvent(Key_Backspace, UnknownKeyswitchLocation, WAS_PRESSED | INJECTED); hid::sendKeyboardReport(); } diff --git a/src/kaleidoscope/plugin/Syster.h b/src/kaleidoscope/plugin/Syster.h index 31d38083..1433b7eb 100644 --- a/src/kaleidoscope/plugin/Syster.h +++ b/src/kaleidoscope/plugin/Syster.h @@ -41,7 +41,7 @@ class Syster : public kaleidoscope::Plugin { bool is_active(void); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState); private: static char symbol_[SYSTER_MAX_SYMBOL_LENGTH + 1]; diff --git a/src/kaleidoscope/plugin/TapDance.cpp b/src/kaleidoscope/plugin/TapDance.cpp index 60f18990..30e7acbe 100644 --- a/src/kaleidoscope/plugin/TapDance.cpp +++ b/src/kaleidoscope/plugin/TapDance.cpp @@ -26,20 +26,19 @@ uint16_t TapDance::start_time_; uint16_t TapDance::time_out = 200; TapDance::TapDanceState TapDance::state_[TapDance::TAPDANCE_KEY_COUNT]; Key TapDance::last_tap_dance_key_ = Key_NoKey; -byte TapDance::last_tap_dance_row_; -byte TapDance::last_tap_dance_col_; +KeyAddr TapDance::last_tap_dance_addr_; // --- actions --- -void TapDance::interrupt(byte row, byte col) { +void TapDance::interrupt(KeyAddr key_addr) { uint8_t idx = last_tap_dance_key_.raw - ranges::TD_FIRST; - tapDanceAction(idx, last_tap_dance_row_, last_tap_dance_col_, state_[idx].count, Interrupt); + tapDanceAction(idx, last_tap_dance_addr_, state_[idx].count, Interrupt); state_[idx].triggered = true; last_tap_dance_key_ = Key_NoKey; - KeyboardHardware.maskKey(row, col); + KeyboardHardware.maskKey(key_addr); kaleidoscope::hid::sendKeyboardReport(); kaleidoscope::hid::releaseAllKeys(); @@ -52,7 +51,7 @@ void TapDance::interrupt(byte row, byte col) { void TapDance::timeout(void) { uint8_t idx = last_tap_dance_key_.raw - ranges::TD_FIRST; - tapDanceAction(idx, last_tap_dance_row_, last_tap_dance_col_, state_[idx].count, Timeout); + tapDanceAction(idx, last_tap_dance_addr_, state_[idx].count, Timeout); state_[idx].triggered = true; if (state_[idx].pressed) @@ -77,7 +76,7 @@ void TapDance::tap(void) { state_[idx].count++; start_time_ = Kaleidoscope.millisAtCycleStart(); - tapDanceAction(idx, last_tap_dance_row_, last_tap_dance_col_, state_[idx].count, Tap); + tapDanceAction(idx, last_tap_dance_addr_, state_[idx].count, Tap); } // --- api --- @@ -94,21 +93,21 @@ void TapDance::actionKeys(uint8_t tap_count, ActionType tap_dance_action, uint8_ break; case Interrupt: case Timeout: - handleKeyswitchEvent(key, last_tap_dance_row_, last_tap_dance_col_, IS_PRESSED | INJECTED); + handleKeyswitchEvent(key, last_tap_dance_addr_, IS_PRESSED | INJECTED); break; case Hold: - handleKeyswitchEvent(key, last_tap_dance_row_, last_tap_dance_col_, IS_PRESSED | WAS_PRESSED | INJECTED); + handleKeyswitchEvent(key, last_tap_dance_addr_, IS_PRESSED | WAS_PRESSED | INJECTED); break; case Release: hid::sendKeyboardReport(); - handleKeyswitchEvent(key, last_tap_dance_row_, last_tap_dance_col_, WAS_PRESSED | INJECTED); + handleKeyswitchEvent(key, last_tap_dance_addr_, WAS_PRESSED | INJECTED); break; } } // --- hooks --- -EventHandlerResult TapDance::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState) { +EventHandlerResult TapDance::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState) { if (keyState & INJECTED) return EventHandlerResult::OK; @@ -117,10 +116,10 @@ EventHandlerResult TapDance::onKeyswitchEvent(Key &mapped_key, byte row, byte co return EventHandlerResult::OK; if (keyToggledOn(keyState)) - interrupt(row, col); + interrupt(key_addr); - if (KeyboardHardware.isKeyMasked(row, col)) { - KeyboardHardware.unMaskKey(row, col); + if (KeyboardHardware.isKeyMasked(key_addr)) { + KeyboardHardware.unMaskKey(key_addr); return EventHandlerResult::EVENT_CONSUMED; } return EventHandlerResult::OK; @@ -142,8 +141,7 @@ EventHandlerResult TapDance::onKeyswitchEvent(Key &mapped_key, byte row, byte co } last_tap_dance_key_.raw = mapped_key.raw; - last_tap_dance_row_ = row; - last_tap_dance_col_ = col; + last_tap_dance_addr_ = key_addr; tap(); @@ -158,7 +156,7 @@ EventHandlerResult TapDance::onKeyswitchEvent(Key &mapped_key, byte row, byte co return EventHandlerResult::EVENT_CONSUMED; } - interrupt(row, col); + interrupt(key_addr); } } @@ -169,8 +167,7 @@ EventHandlerResult TapDance::onKeyswitchEvent(Key &mapped_key, byte row, byte co } last_tap_dance_key_.raw = mapped_key.raw; - last_tap_dance_row_ = row; - last_tap_dance_col_ = col; + last_tap_dance_addr_ = key_addr; state_[tap_dance_index].pressed = true; if (keyToggledOn(keyState)) { @@ -179,7 +176,7 @@ EventHandlerResult TapDance::onKeyswitchEvent(Key &mapped_key, byte row, byte co } if (state_[tap_dance_index].triggered) - tapDanceAction(tap_dance_index, row, col, state_[tap_dance_index].count, Hold); + tapDanceAction(tap_dance_index, key_addr, state_[tap_dance_index].count, Hold); return EventHandlerResult::EVENT_CONSUMED; } @@ -189,7 +186,7 @@ EventHandlerResult TapDance::afterEachCycle() { if (!state_[i].release_next) continue; - tapDanceAction(i, last_tap_dance_row_, last_tap_dance_col_, state_[i].count, Release); + tapDanceAction(i, last_tap_dance_addr_, state_[i].count, Release); state_[i].count = 0; state_[i].release_next = false; } @@ -210,4 +207,10 @@ __attribute__((weak)) void tapDanceAction(uint8_t tap_dance_index, byte row, byt kaleidoscope::plugin::TapDance::ActionType tap_dance_action) { } +// Let the future version be the wrapper to enable backward compatibility. +__attribute__((weak)) void tapDanceAction(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, + kaleidoscope::plugin::TapDance::ActionType tap_dance_action) { + tapDanceAction(tap_dance_index, key_addr.row(), key_addr.col(), tap_count, tap_dance_action); +} + kaleidoscope::plugin::TapDance TapDance; diff --git a/src/kaleidoscope/plugin/TapDance.h b/src/kaleidoscope/plugin/TapDance.h index ce6ced53..9e60bc34 100644 --- a/src/kaleidoscope/plugin/TapDance.h +++ b/src/kaleidoscope/plugin/TapDance.h @@ -46,7 +46,7 @@ class TapDance : public kaleidoscope::Plugin { void actionKeys(uint8_t tap_count, ActionType tap_dance_action, uint8_t max_keys, const Key tap_keys[]); - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t keyState); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t keyState); EventHandlerResult afterEachCycle(); private: @@ -61,11 +61,10 @@ class TapDance : public kaleidoscope::Plugin { static uint16_t start_time_; static Key last_tap_dance_key_; - static byte last_tap_dance_row_; - static byte last_tap_dance_col_; + static KeyAddr last_tap_dance_addr_; static void tap(void); - static void interrupt(byte row, byte col); + static void interrupt(KeyAddr key_addr); static void timeout(void); static void release(uint8_t tap_dance_index); }; @@ -73,6 +72,14 @@ class TapDance : public kaleidoscope::Plugin { } +void tapDanceAction(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, + kaleidoscope::plugin::TapDance::ActionType tap_dance_action); + +// The old version of te tapdance action is DEPRECATED(ROW_COL_FUNC) although this +// cannot be flagged to the user. The weak function is called by the tap dance +// plugin's implementation. That's why the deprecation warning would always +// fire. +// void tapDanceAction(uint8_t tap_dance_index, byte row, byte col, uint8_t tap_count, kaleidoscope::plugin::TapDance::ActionType tap_dance_action); diff --git a/src/kaleidoscope/plugin/TopsyTurvy.cpp b/src/kaleidoscope/plugin/TopsyTurvy.cpp index 07ee12fa..c0df461a 100644 --- a/src/kaleidoscope/plugin/TopsyTurvy.cpp +++ b/src/kaleidoscope/plugin/TopsyTurvy.cpp @@ -25,7 +25,7 @@ uint8_t TopsyTurvy::last_pressed_position_; bool TopsyTurvy::is_shifted_; bool TopsyTurvy::is_active_; -EventHandlerResult TopsyTurvy::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult TopsyTurvy::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { if (mapped_key == Key_LeftShift || mapped_key == Key_RightShift) { @@ -36,7 +36,7 @@ EventHandlerResult TopsyTurvy::onKeyswitchEvent(Key &mapped_key, byte row, byte if (mapped_key < ranges::TT_FIRST || mapped_key > ranges::TT_LAST) { if (keyToggledOn(key_state) && (mapped_key < Key_LeftControl || mapped_key > Key_RightGui)) { - last_pressed_position_ = row * COLS + col; + last_pressed_position_ = key_addr.toInt(); } return EventHandlerResult::OK; @@ -45,9 +45,9 @@ EventHandlerResult TopsyTurvy::onKeyswitchEvent(Key &mapped_key, byte row, byte is_active_ = keyIsPressed(key_state); if (keyToggledOn(key_state)) { - last_pressed_position_ = row * COLS + col; + last_pressed_position_ = key_addr.toInt(); } else { - if (last_pressed_position_ != row * COLS + col) { + if (last_pressed_position_ != key_addr.toInt()) { return EventHandlerResult::EVENT_CONSUMED; } } diff --git a/src/kaleidoscope/plugin/TopsyTurvy.h b/src/kaleidoscope/plugin/TopsyTurvy.h index 4dadf556..2462357b 100644 --- a/src/kaleidoscope/plugin/TopsyTurvy.h +++ b/src/kaleidoscope/plugin/TopsyTurvy.h @@ -29,7 +29,7 @@ class TopsyTurvy: public kaleidoscope::Plugin { public: TopsyTurvy(void) {} - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); private: static uint8_t last_pressed_position_; diff --git a/src/kaleidoscope/plugin/TriColor.cpp b/src/kaleidoscope/plugin/TriColor.cpp index cb457ec5..965e6adc 100644 --- a/src/kaleidoscope/plugin/TriColor.cpp +++ b/src/kaleidoscope/plugin/TriColor.cpp @@ -27,34 +27,32 @@ TriColor::TriColor(cRGB base_color, cRGB mod_color, cRGB esc_color) { } void TriColor::TransientLEDMode::update(void) { - for (uint8_t r = 0; r < ROWS; r++) { - for (uint8_t c = 0; c < COLS; c++) { - Key k = Layer.lookup(r, c); - - // Special keys are always mod_color - if (k.flags != 0) { - ::LEDControl.setCrgbAt(r, c, parent_->mod_color_); - continue; - } - - cRGB color = parent_->mod_color_; - - switch (k.keyCode) { - case Key_A.keyCode ... Key_0.keyCode: - case Key_Spacebar.keyCode: - case Key_KeypadDivide.keyCode ... Key_KeypadSubtract.keyCode: - case Key_Keypad1.keyCode ... Key_KeypadDot.keyCode: - case Key_F1.keyCode ... Key_F4.keyCode: - case Key_F9.keyCode ... Key_F12.keyCode: - color = parent_->base_color_; - break; - case Key_Escape.keyCode: - color = parent_->esc_color_; - break; - } - - ::LEDControl.setCrgbAt(r, c, color); + for (auto key_addr : KeyAddr::all()) { + Key k = Layer.lookup(key_addr); + + // Special keys are always mod_color + if (k.flags != 0) { + ::LEDControl.setCrgbAt(KeyAddr(key_addr), parent_->mod_color_); + continue; + } + + cRGB color = parent_->mod_color_; + + switch (k.keyCode) { + case Key_A.keyCode ... Key_0.keyCode: + case Key_Spacebar.keyCode: + case Key_KeypadDivide.keyCode ... Key_KeypadSubtract.keyCode: + case Key_Keypad1.keyCode ... Key_KeypadDot.keyCode: + case Key_F1.keyCode ... Key_F4.keyCode: + case Key_F9.keyCode ... Key_F12.keyCode: + color = parent_->base_color_; + break; + case Key_Escape.keyCode: + color = parent_->esc_color_; + break; } + + ::LEDControl.setCrgbAt(KeyAddr(key_addr), color); } } diff --git a/src/kaleidoscope/plugin/TypingBreaks.cpp b/src/kaleidoscope/plugin/TypingBreaks.cpp index 24e27536..38faeb58 100644 --- a/src/kaleidoscope/plugin/TypingBreaks.cpp +++ b/src/kaleidoscope/plugin/TypingBreaks.cpp @@ -38,7 +38,7 @@ uint16_t TypingBreaks::left_hand_keys_; uint16_t TypingBreaks::right_hand_keys_; uint16_t TypingBreaks::settings_base_; -EventHandlerResult TypingBreaks::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) { +EventHandlerResult TypingBreaks::onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state) { uint32_t lock_length = settings.lock_length * 1000; uint32_t idle_time_limit = settings.idle_time_limit * 1000; uint32_t lock_time_out = settings.lock_time_out * 1000; @@ -91,7 +91,7 @@ EventHandlerResult TypingBreaks::onKeyswitchEvent(Key &mapped_key, byte row, byt // counters if need be. if (keyToggledOn(key_state)) { - if (col <= COLS / 2) + if (key_addr.col() <= COLS / 2) left_hand_keys_++; else right_hand_keys_++; diff --git a/src/kaleidoscope/plugin/TypingBreaks.h b/src/kaleidoscope/plugin/TypingBreaks.h index 33166ecd..4bbc0379 100644 --- a/src/kaleidoscope/plugin/TypingBreaks.h +++ b/src/kaleidoscope/plugin/TypingBreaks.h @@ -36,7 +36,7 @@ class TypingBreaks : public kaleidoscope::Plugin { static settings_t settings; - EventHandlerResult onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &mapped_key, KeyAddr key_addr, uint8_t key_state); EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onSetup(); diff --git a/src/kaleidoscope/plugin/WinKeyToggle.cpp b/src/kaleidoscope/plugin/WinKeyToggle.cpp index 74c8861e..c4273269 100644 --- a/src/kaleidoscope/plugin/WinKeyToggle.cpp +++ b/src/kaleidoscope/plugin/WinKeyToggle.cpp @@ -23,7 +23,7 @@ namespace plugin { bool WinKeyToggle::enabled_; -EventHandlerResult WinKeyToggle::onKeyswitchEvent(Key &key, byte row, byte col, uint8_t key_state) { +EventHandlerResult WinKeyToggle::onKeyswitchEvent(Key &key, KeyAddr key_addr, uint8_t key_state) { if (!enabled_) return EventHandlerResult::OK; diff --git a/src/kaleidoscope/plugin/WinKeyToggle.h b/src/kaleidoscope/plugin/WinKeyToggle.h index 1ee0922e..08380713 100644 --- a/src/kaleidoscope/plugin/WinKeyToggle.h +++ b/src/kaleidoscope/plugin/WinKeyToggle.h @@ -25,7 +25,7 @@ class WinKeyToggle: public kaleidoscope::Plugin { public: WinKeyToggle() {} - EventHandlerResult onKeyswitchEvent(Key &key, byte row, byte col, uint8_t key_state); + EventHandlerResult onKeyswitchEvent(Key &key, KeyAddr key_addr, uint8_t key_state); void toggle() { enabled_ = !enabled_; } diff --git a/test/MatrixAddr/Makefile b/test/MatrixAddr/Makefile new file mode 100644 index 00000000..503de5e0 --- /dev/null +++ b/test/MatrixAddr/Makefile @@ -0,0 +1,2 @@ +test: test.cpp ../../src/kaleidoscope/MatrixAddr.h + g++ -std=c++11 -o test test.cpp diff --git a/test/MatrixAddr/test.cpp b/test/MatrixAddr/test.cpp new file mode 100644 index 00000000..1681c644 --- /dev/null +++ b/test/MatrixAddr/test.cpp @@ -0,0 +1,102 @@ +#define MATRIX_ADDR_TESTING + +#include "../../src/kaleidoscope/MatrixAddr.h" + +#include +#include +#include +#include + +template +void logType() { + std::cout << " rows:" << (int)MA__::rows << std::endl; + std::cout << " cols:" << (int)MA__::cols << std::endl; + std::cout << " rowSize:" << (int)MA__::rowSize << std::endl; +} + +template +void testIndexedAccess() { + MA__ ma2; + + ma2.setRow(1); + ma2.setCol(3); + assert(ma2 == MA__(1, 3)); + + ma2.setRow(7); + assert(ma2 == MA__(7, 3)); + + ma2.setCol(5); + assert(ma2 == MA__(7, 5)); + + MA__ ma3(3, 5); + + assert(ma3.row() == 3); + assert(ma3.col() == 5); +} + +template +std::string typenameString() { + std::string nameString; + char * name = 0; + int status; + name = abi::__cxa_demangle(typeid(MA__).name(), 0, 0, &status); + if (name != 0) { + nameString = name; + } + free(name); + return nameString; +} + +template +void testRelation() { + + std::cout << "***************************************" << std::endl; + std::cout << "MA1:" << typenameString() << std::endl; + logType(); + + std::cout << "MA2:" << typenameString() << std::endl; + logType(); + + MA1__ mAddr1(3, 5); + MA2__ mAddr2(2, 5); + MA1__ mAddr3; + + assert(mAddr1.isValid()); + assert(!mAddr3.isValid()); + + assert(mAddr1 != mAddr2); + + MA2__ mAddr1Copy = mAddr1; + assert(mAddr1Copy == mAddr1); + + MA2__ mAddr1Assigned; + mAddr1Assigned = mAddr1; + assert(mAddr1Assigned == mAddr1); + + assert(mAddr2 < mAddr1); + assert(mAddr1 > mAddr2); + + assert(mAddr2 <= mAddr1); + assert(mAddr1 >= mAddr2); + + assert(mAddr1 <= mAddr1); + assert(mAddr2 >= mAddr2); +} + +int main(int argc, char **argv) { + typedef kaleidoscope::MatrixAddr<7, 14> MA1; + typedef kaleidoscope::MatrixAddrCompressed<7, 14> MA2; + typedef kaleidoscope::MatrixAddrCompressed<7, 8> MA3; + + testIndexedAccess(); + testIndexedAccess(); + + testRelation(); + testRelation(); + testRelation(); + testRelation(); + + testRelation(); + testRelation(); + testRelation(); +}