alpha
/
Kaleidoscope
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

CharShift: Migrate to a pluggable storage sub-class

Browse Source 
Signed-off-by: Gergely Nagy <algernon@keyboard.io>
pull/1069/head
Gergely Nagy 3 years ago
parent 7d6ce8bf45
commit ee36ed6929
No known key found for this signature in database
GPG Key ID: AC1E90BAC433F68F
3 changed files with 94 additions and 95 deletions
Show Stats Download Patch File Download Diff File

27
plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShift.cpp
Unescape View File

@ -32,20 +32,21 @@ namespace plugin {
// ============================================================================= // =============================================================================
// CharShift class variables // CharShift class variables
CharShift::KeyPair const * CharShift::progmem_keypairs_{nullptr}; charshift::Storage * CharShift::storage_;
uint8_t CharShift::num_keypairs_{0};
CharShift::GetNumKeyPairsFunction CharShift::numKeyPairs_ =
CharShift::numProgmemKeyPairs;
CharShift::ReadKeyPairFunction CharShift::readKeyPair_ =
CharShift::readKeyPairFromProgmem;
bool CharShift::reverse_shift_state_{false}; bool CharShift::reverse_shift_state_{false};
static auto progmem_storage_ = charshift::ProgmemStorage();
// ============================================================================= // =============================================================================
// Event handlers // Event handlers
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
EventHandlerResult CharShift::onSetup() {
if (!storage_) {
storage_ = &progmem_storage_;
}
return EventHandlerResult::OK;
}
EventHandlerResult CharShift::onNameQuery() { EventHandlerResult CharShift::onNameQuery() {
return ::Focus.sendName(F("CharShift")); return ::Focus.sendName(F("CharShift"));
} }
@ -121,20 +122,12 @@ bool CharShift::isCharShiftKey(Key key) {
CharShift::KeyPair CharShift::decodeCharShiftKey(Key key) { CharShift::KeyPair CharShift::decodeCharShiftKey(Key key) {
uint8_t i = key.getRaw() - ranges::CS_FIRST; uint8_t i = key.getRaw() - ranges::CS_FIRST;
if (i < numKeyPairs_()) { if (i < storage_->numKeyPairs()) {
return readKeyPair_(i); return storage_->readKeyPair(i);
} }
return {Key_NoKey, Key_NoKey}; return {Key_NoKey, Key_NoKey};
} }
uint8_t CharShift::numProgmemKeyPairs() {
return num_keypairs_;
}
CharShift::KeyPair CharShift::readKeyPairFromProgmem(uint8_t n) {
return cloneFromProgmem(progmem_keypairs_[n]);
}
} // namespace plugin } // namespace plugin
} // namespace kaleidoscope } // namespace kaleidoscope

107
plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShift.h
Unescape View File

@ -24,6 +24,10 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
namespace charshift {
class Storage;
}
// ============================================================================= // =============================================================================
/// Kaleidoscope plugin for independently assigning shifted symbols /// Kaleidoscope plugin for independently assigning shifted symbols
/// ///
@ -36,9 +40,11 @@ namespace plugin {
class CharShift : public Plugin { class CharShift : public Plugin {
public: public:
EventHandlerResult onSetup();
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
EventHandlerResult beforeReportingState(const KeyEvent &event); EventHandlerResult beforeReportingState(const KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command);
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/// A structure that stores CharShift key pair values /// A structure that stores CharShift key pair values
@ -63,39 +69,15 @@ class CharShift : public Plugin {
KeyPair() = default; KeyPair() = default;
}; };
/// Configure the KeyPairs array in PROGMEM charshift::Storage &storage() {
/// return *storage_;
/// This function configures the PROGMEM array of `KeyPair` objects,
/// automatically setting the internal count variable from the size of the
/// `keypairs` array given, which must be a fixed-sized array, not a pointer.
/// Generally, it will be called via the `KEYPAIRS()` preprocessor macro, not
/// directly by user code.
template <uint8_t _num_keypairs>
static void setProgmemKeyPairs(KeyPair const(&keypairs)[_num_keypairs]) {
progmem_keypairs_ = keypairs;
num_keypairs_ = _num_keypairs;
} }
void setStorage(charshift::Storage *st) {
typedef uint8_t (*GetNumKeyPairsFunction)(); storage_ = st;
typedef KeyPair (*ReadKeyPairFunction)(uint8_t n);
static void setNumKeyPairsFunction(GetNumKeyPairsFunction f) {
numKeyPairs_ = f;
} }
static void setReadKeyPairFunction(ReadKeyPairFunction f) {
readKeyPair_ = f;
}
friend class CharShiftConfig;
private: private:
// A pointer to an array of `KeyPair` objects in PROGMEM static charshift::Storage *storage_;
static KeyPair const * progmem_keypairs_;
// The size of the PROGMEM array of `KeyPair` objects
static uint8_t num_keypairs_;
static GetNumKeyPairsFunction numKeyPairs_;
static ReadKeyPairFunction readKeyPair_;
// If a `shift` key needs to be suppressed in `beforeReportingState()` // If a `shift` key needs to be suppressed in `beforeReportingState()`
static bool reverse_shift_state_; static bool reverse_shift_state_;
@ -105,41 +87,68 @@ class CharShift : public Plugin {
/// Look up the `KeyPair` specified by the given keymap entry /// Look up the `KeyPair` specified by the given keymap entry
static KeyPair decodeCharShiftKey(Key key); static KeyPair decodeCharShiftKey(Key key);
// Default for `keypairsCount()`: size of the PROGMEM array
static uint8_t numProgmemKeyPairs();
// Default for `readKeypair(i)`: fetch the value from PROGMEM
static KeyPair readKeyPairFromProgmem(uint8_t n);
}; };
class CharShiftConfig: public Plugin { namespace charshift {
class Storage {
public: public:
CharShiftConfig() {} Storage() {}
EventHandlerResult onNameQuery(); static uint8_t numKeyPairs() {
EventHandlerResult onFocusEvent(const char *command); return num_keypairs_;
}
static CharShift::KeyPair readKeyPair(uint8_t n) {
return CharShift::KeyPair(Key_NoKey, Key_NoKey);
}
static void setup(uint8_t dynamic_offset, uint8_t max_pairs); EventHandlerResult onFocusEvent(const char *command) {
return EventHandlerResult::OK;
}
private: protected:
static uint8_t max_pairs_; static uint8_t num_keypairs_;
static uint16_t storage_base_; };
static uint8_t dynamic_offset_;
class ProgmemStorage: public Storage {
public:
static CharShift::KeyPair readKeyPair(uint8_t n);
static uint8_t numEEPROMPairs() { /// Configure the KeyPairs array in PROGMEM
return max_pairs_; ///
/// This function configures the PROGMEM array of `KeyPair` objects,
/// automatically setting the internal count variable from the size of the
/// `keypairs` array given, which must be a fixed-sized array, not a pointer.
/// Generally, it will be called via the `KEYPAIRS()` preprocessor macro, not
/// directly by user code.
template <uint8_t _num_keypairs>
static void setKeyPairs(CharShift::KeyPair const(&keypairs)[_num_keypairs]) {
keypairs_ = keypairs;
num_keypairs_ = _num_keypairs;
} }
static CharShift::KeyPair readKeyPairFromEEPROM(uint8_t n);
static uint8_t numPairs(); private:
// A pointer to an array of `KeyPair` objects in PROGMEM
static CharShift::KeyPair const *keypairs_;
};
class EEPROMStorage: public Storage {
public:
void setup(uint8_t num_pairs);
static CharShift::KeyPair readKeyPair(uint8_t n); static CharShift::KeyPair readKeyPair(uint8_t n);
EventHandlerResult onFocusEvent(const char *command);
private:
static uint16_t storage_base_;
}; };
}
} // namespace plugin } // namespace plugin
} // namespace kaleidoscope } // namespace kaleidoscope
extern kaleidoscope::plugin::CharShift CharShift; extern kaleidoscope::plugin::CharShift CharShift;
extern kaleidoscope::plugin::CharShiftConfig CharShiftConfig;
/// Define an array of `KeyPair` objects in PROGMEM /// Define an array of `KeyPair` objects in PROGMEM
/// ///
@ -151,7 +160,7 @@ extern kaleidoscope::plugin::CharShiftConfig CharShiftConfig;
static kaleidoscope::plugin::CharShift::KeyPair const kp_table[] PROGMEM = { \ static kaleidoscope::plugin::CharShift::KeyPair const kp_table[] PROGMEM = { \
keypairs \ keypairs \
}; \ }; \
CharShift.setProgmemKeyPairs(kp_table); \ CharShift.storage().setKeyPairs(kp_table); \
} }
/// Define an `KeyPair` entry in a keymap /// Define an `KeyPair` entry in a keymap

55
plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShiftConfig.cpp → plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShiftStorage.cpp
Unescape View File

@ -17,29 +17,42 @@
#include "kaleidoscope/plugin/CharShift.h" #include "kaleidoscope/plugin/CharShift.h"
#include <Kaleidoscope-Ranges.h>
#include <Kaleidoscope-FocusSerial.h> #include <Kaleidoscope-FocusSerial.h>
#include <Kaleidoscope-EEPROM-Settings.h> #include <Kaleidoscope-EEPROM-Settings.h>
#include "kaleidoscope/KeyAddr.h"
#include "kaleidoscope/key_defs.h"
#include "kaleidoscope/KeyEvent.h"
#include "kaleidoscope/keyswitch_state.h"
#include "kaleidoscope/progmem_helpers.h"
#include "kaleidoscope/Runtime.h" #include "kaleidoscope/Runtime.h"
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
namespace charshift {
// ============================================================================= // =============================================================================
// CharShiftConfig class variables // Storage class variables
uint8_t Storage::num_keypairs_;
CharShift::KeyPair const * ProgmemStorage::keypairs_{nullptr};
uint16_t EEPROMStorage::storage_base_;
uint8_t CharShiftConfig::max_pairs_;
uint8_t CharShiftConfig::dynamic_offset_;
uint16_t CharShiftConfig::storage_base_;
// ============================================================================= // =============================================================================
// Event handlers // Progmem Storage
EventHandlerResult CharShiftConfig::onNameQuery() { CharShift::KeyPair ProgmemStorage::readKeyPair(uint8_t n) {
return ::Focus.sendName(F("CharShiftConfig")); return cloneFromProgmem(keypairs_[n]);
} }
EventHandlerResult CharShiftConfig::onFocusEvent(const char *command) {
// =============================================================================
// EEPROM Storage
EventHandlerResult EEPROMStorage::onFocusEvent(const char *command) {
if (::Focus.handleHelp(command, PSTR("charshift.map"))) if (::Focus.handleHelp(command, PSTR("charshift.map")))
return EventHandlerResult::OK; return EventHandlerResult::OK;
@ -49,7 +62,7 @@ EventHandlerResult CharShiftConfig::onFocusEvent(const char *command) {
if (::Focus.isEOL()) { if (::Focus.isEOL()) {
// We dump key by key, rather than pairs, because the end result is the // We dump key by key, rather than pairs, because the end result is the
// same, and dumping one by one is less code. // same, and dumping one by one is less code.
for (uint16_t i = 0; i < max_pairs_ * 2; i += 2) { for (uint16_t i = 0; i < num_keypairs_ * 2; i += 2) {
Key k; Key k;
Runtime.storage().get(storage_base_ + i, k); Runtime.storage().get(storage_base_ + i, k);
@ -73,19 +86,13 @@ EventHandlerResult CharShiftConfig::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }
// ============================================================================= void EEPROMStorage::setup(uint8_t num_keypairs) {
// Support functions num_keypairs_ = num_keypairs;
void CharShiftConfig::setup(uint8_t dynamic_offset, uint8_t max_pairs) {
dynamic_offset_ = dynamic_offset;
max_pairs_ = max_pairs;
storage_base_ = ::EEPROMSettings.requestSlice(max_pairs * 4); storage_base_ = ::EEPROMSettings.requestSlice(num_keypairs * 4);
::CharShift.setNumKeyPairsFunction(numPairs);
::CharShift.setReadKeyPairFunction(readKeyPair);
} }
CharShift::KeyPair CharShiftConfig::readKeyPairFromEEPROM(uint8_t n) { CharShift::KeyPair EEPROMStorage::readKeyPair(uint8_t n) {
uint16_t pos = storage_base_ + n * 4; // 4: Size of a keypair. uint16_t pos = storage_base_ + n * 4; // 4: Size of a keypair.
uint16_t raw_lower = Runtime.storage().read(pos); uint16_t raw_lower = Runtime.storage().read(pos);
uint16_t raw_upper = Runtime.storage().read(pos + 2); uint16_t raw_upper = Runtime.storage().read(pos + 2);
@ -93,18 +100,8 @@ CharShift::KeyPair CharShiftConfig::readKeyPairFromEEPROM(uint8_t n) {
return CharShift::KeyPair(Key(raw_lower), Key(raw_upper)); return CharShift::KeyPair(Key(raw_lower), Key(raw_upper));
} }
uint8_t CharShiftConfig::numPairs() {
return CharShift::numProgmemKeyPairs() + numEEPROMPairs();
} }
CharShift::KeyPair CharShiftConfig::readKeyPair(uint8_t n) {
if (n < dynamic_offset_) {
return CharShift::readKeyPairFromProgmem(n);
}
return readKeyPairFromEEPROM(n - dynamic_offset_);
}
} // namespace plugin } // namespace plugin
} // namespace kaleidoscope } // namespace kaleidoscope
kaleidoscope::plugin::CharShiftConfig CharShiftConfig;
Write Preview
Loading…
Cancel
Save