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

Convert OneShot variables and functions from `static`

Browse Source 
This is more like "standard" C++ code, resulting in more readable code, with
default configuration values stored in the header file, and `const`-correct
member functions clearly marking which ones alter internal state and which ones
don't (with the exception of the event handlers).

Things had been declared `static` because the compiler produced a significantly
smaller binary in PROGMEM, but that appears not to be the case now.

Signed-off-by: Michael Richters <gedankenexperimenter@gmail.com>
pull/1121/head
Michael Richters 3 years ago
parent fd17553f1a
commit a1c1fe6ba2
No known key found for this signature in database
GPG Key ID: 1288FD13E4EEF0C0
2 changed files with 69 additions and 91 deletions
Show Stats Download Patch File Download Diff File

48
plugins/Kaleidoscope-OneShot/src/kaleidoscope/plugin/OneShot.cpp
Unescape View File

@ -1,6 +1,6 @@
/* -*- mode: c++ -*- /* -*- mode: c++ -*-
* Kaleidoscope-OneShot -- One-shot modifiers and layers * Kaleidoscope-OneShot -- One-shot modifiers and layers
* Copyright (C) 2016-2021 Keyboard.io, Inc. * Copyright (C) 2016-2022 Keyboard.io, Inc.
* *
* This program is free software: you can redistribute it and/or modify it under * 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 * the terms of the GNU General Public License as published by the Free Software
@ -23,28 +23,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
// ----------------------------------------------------------------------------
// Configuration variables
uint16_t OneShot::timeout_ = 2500;
uint16_t OneShot::hold_timeout_ = 250;
int16_t OneShot::double_tap_timeout_ = -1;
// ----------------------------------------------------------------------------
// State variables
uint16_t OneShot::stickable_keys_ = -1;
bool OneShot::auto_modifiers_ = false;
bool OneShot::auto_layers_ = false;
KeyAddrBitfield OneShot::temp_addrs_;
KeyAddrBitfield OneShot::glue_addrs_;
uint16_t OneShot::start_time_ = 0;
KeyAddr OneShot::prev_key_addr_ = OneShot::invalid_key_addr;
// ============================================================================ // ============================================================================
// Public interface // Public interface
@ -80,7 +58,7 @@ void OneShot::disableStickabilityForLayers() {
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Global tests for any OneShot key // Global tests for any OneShot key
bool OneShot::isActive() { bool OneShot::isActive() const {
for (KeyAddr key_addr __attribute__((unused)) : temp_addrs_) { for (KeyAddr key_addr __attribute__((unused)) : temp_addrs_) {
return true; return true;
} }
@ -90,7 +68,7 @@ bool OneShot::isActive() {
return false; return false;
} }
bool OneShot::isSticky() { bool OneShot::isSticky() const {
for (KeyAddr key_addr : glue_addrs_) { for (KeyAddr key_addr : glue_addrs_) {
if (! temp_addrs_.read(key_addr)) { if (! temp_addrs_.read(key_addr)) {
return true; return true;
@ -107,11 +85,11 @@ bool OneShot::isSticky() {
// states (sticky | active && !sticky | pressed && !active). // states (sticky | active && !sticky | pressed && !active).
__attribute__((weak)) __attribute__((weak))
bool OneShot::isStickable(Key key) { bool OneShot::isStickable(Key key) const {
return isStickableDefault(key); return isStickableDefault(key);
} }
bool OneShot::isStickableDefault(Key key) { bool OneShot::isStickableDefault(Key key) const {
int8_t n; int8_t n;
// If the key is either a keyboard modifier or a layer shift, we check to see // If the key is either a keyboard modifier or a layer shift, we check to see
// if it has been set to be non-stickable. // if it has been set to be non-stickable.
@ -132,19 +110,19 @@ bool OneShot::isStickableDefault(Key key) {
return true; return true;
} }
bool OneShot::isTemporary(KeyAddr key_addr) { bool OneShot::isTemporary(KeyAddr key_addr) const {
return temp_addrs_.read(key_addr); return temp_addrs_.read(key_addr);
} }
bool OneShot::isPending(KeyAddr key_addr) { bool OneShot::isPending(KeyAddr key_addr) const {
return (glue_addrs_.read(key_addr) && temp_addrs_.read(key_addr)); return (glue_addrs_.read(key_addr) && temp_addrs_.read(key_addr));
} }
bool OneShot::isSticky(KeyAddr key_addr) { bool OneShot::isSticky(KeyAddr key_addr) const {
return (glue_addrs_.read(key_addr) && !temp_addrs_.read(key_addr)); return (glue_addrs_.read(key_addr) && !temp_addrs_.read(key_addr));
} }
bool OneShot::isActive(KeyAddr key_addr) { bool OneShot::isActive(KeyAddr key_addr) const {
return (isTemporary(key_addr) || glue_addrs_.read(key_addr)); return (isTemporary(key_addr) || glue_addrs_.read(key_addr));
} }
@ -334,7 +312,7 @@ EventHandlerResult OneShot::afterEachCycle() {
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Helper functions for acting on OneShot key events // Helper functions for acting on OneShot key events
uint8_t OneShot::getOneShotKeyIndex(Key oneshot_key) { uint8_t OneShot::getOneShotKeyIndex(Key oneshot_key) const {
// The calling function is responsible for verifying that // The calling function is responsible for verifying that
// `oneshot_key` is an actual OneShot key (i.e. call // `oneshot_key` is an actual OneShot key (i.e. call
// `isOneShotKey(oneshot_key)` first). // `isOneShotKey(oneshot_key)` first).
@ -342,7 +320,7 @@ uint8_t OneShot::getOneShotKeyIndex(Key oneshot_key) {
return index; return index;
} }
uint8_t OneShot::getKeyIndex(Key key) { uint8_t OneShot::getKeyIndex(Key key) const {
// Default to returning a value that's out of range. This should be // Default to returning a value that's out of range. This should be
// harmless because we only use the returned index to reference a // harmless because we only use the returned index to reference a
// bit in a bitfield, not as a memory address. // bit in a bitfield, not as a memory address.
@ -358,7 +336,7 @@ uint8_t OneShot::getKeyIndex(Key key) {
return n; return n;
} }
Key OneShot::decodeOneShotKey(Key oneshot_key) { Key OneShot::decodeOneShotKey(Key oneshot_key) const {
// The calling function is responsible for verifying that // The calling function is responsible for verifying that
// `oneshot_key` is an actual OneShot key (i.e. call // `oneshot_key` is an actual OneShot key (i.e. call
// `isOneShotKey(oneshot_key)` first). // `isOneShotKey(oneshot_key)` first).
@ -386,7 +364,7 @@ void OneShot::pressKey(KeyAddr key_addr, Key key) {
Runtime.handleKeyEvent(event); Runtime.handleKeyEvent(event);
} }
void OneShot::holdKey(KeyAddr key_addr) { void OneShot::holdKey(KeyAddr key_addr) const {
KeyEvent event{key_addr, WAS_PRESSED | IS_PRESSED | INJECTED}; KeyEvent event{key_addr, WAS_PRESSED | IS_PRESSED | INJECTED};
Runtime.handleKeyEvent(event); Runtime.handleKeyEvent(event);
} }

112
plugins/Kaleidoscope-OneShot/src/kaleidoscope/plugin/OneShot.h
Unescape View File

@ -1,6 +1,6 @@
/* -*- mode: c++ -*- /* -*- mode: c++ -*-
* Kaleidoscope-OneShot -- One-shot modifiers and layers * Kaleidoscope-OneShot -- One-shot modifiers and layers
* Copyright (C) 2016-2021 Keyboard.io, Inc. * Copyright (C) 2016-2022 Keyboard.io, Inc.
* *
* This program is free software: you can redistribute it and/or modify it under * 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 * the terms of the GNU General Public License as published by the Free Software
@ -33,60 +33,60 @@ namespace plugin {
class OneShot : public kaleidoscope::Plugin { class OneShot : public kaleidoscope::Plugin {
public: public:
// Constructor // Constructor
OneShot() {} // OneShot() {}
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Configuration functions // Configuration functions
static inline void enableStickablity() {} void enableStickablity() {}
static void enableStickability(Key key); void enableStickability(Key key);
template <typename... Keys> template <typename... Keys>
static void enableStickability(Key key, Keys&&... keys) { void enableStickability(Key key, Keys&&... keys) {
enableStickability(key); enableStickability(key);
enableStickability(keys...); enableStickability(keys...);
} }
static void enableStickabilityForModifiers(); void enableStickabilityForModifiers();
static void enableStickabilityForLayers(); void enableStickabilityForLayers();
static inline void disableStickability() {} void disableStickability() {}
static void disableStickability(Key key); void disableStickability(Key key);
template <typename... Keys> template <typename... Keys>
static void disableStickability(Key key, Keys&&... keys) { void disableStickability(Key key, Keys&&... keys) {
disableStickability(key); disableStickability(key);
disableStickability(keys...); disableStickability(keys...);
} }
static void disableStickabilityForModifiers(); void disableStickabilityForModifiers();
static void disableStickabilityForLayers(); void disableStickabilityForLayers();
static void enableAutoModifiers() { void enableAutoModifiers() {
auto_modifiers_ = true; auto_modifiers_ = true;
} }
static void enableAutoLayers() { void enableAutoLayers() {
auto_layers_ = true; auto_layers_ = true;
} }
static void enableAutoOneShot() { void enableAutoOneShot() {
enableAutoModifiers(); enableAutoModifiers();
enableAutoLayers(); enableAutoLayers();
} }
static void disableAutoModifiers() { void disableAutoModifiers() {
auto_modifiers_ = false; auto_modifiers_ = false;
} }
static void disableAutoLayers() { void disableAutoLayers() {
auto_layers_ = false; auto_layers_ = false;
} }
static void disableAutoOneShot() { void disableAutoOneShot() {
disableAutoModifiers(); disableAutoModifiers();
disableAutoLayers(); disableAutoLayers();
} }
static void toggleAutoModifiers() { void toggleAutoModifiers() {
auto_modifiers_ = ! auto_modifiers_; auto_modifiers_ = ! auto_modifiers_;
} }
static void toggleAutoLayers() { void toggleAutoLayers() {
auto_layers_ = ! auto_layers_; auto_layers_ = ! auto_layers_;
} }
static void toggleAutoOneShot() { void toggleAutoOneShot() {
if (auto_modifiers_ || auto_layers_) { if (auto_modifiers_ || auto_layers_) {
disableAutoOneShot(); disableAutoOneShot();
} else { } else {
@ -97,25 +97,25 @@ class OneShot : public kaleidoscope::Plugin {
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Global test functions // Global test functions
static bool isActive(); bool isActive() const;
static bool isSticky(); bool isSticky() const;
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Single-key test functions // Single-key test functions
static bool isOneShotKey(Key key) { bool isOneShotKey(Key key) const {
return (key.getRaw() >= kaleidoscope::ranges::OS_FIRST && return (key.getRaw() >= kaleidoscope::ranges::OS_FIRST &&
key.getRaw() <= kaleidoscope::ranges::OS_LAST); key.getRaw() <= kaleidoscope::ranges::OS_LAST);
} }
/// Determine if the given `key` is allowed to become sticky. /// Determine if the given `key` is allowed to become sticky.
static bool isStickable(Key key); bool isStickable(Key key) const;
static bool isStickableDefault(Key key); bool isStickableDefault(Key key) const;
static bool isTemporary(KeyAddr key_addr); // inline? bool isTemporary(KeyAddr key_addr) const; // inline?
static bool isPending(KeyAddr key_addr); bool isPending(KeyAddr key_addr) const;
static bool isSticky(KeyAddr key_addr); // inline? bool isSticky(KeyAddr key_addr) const; // inline?
static bool isActive(KeyAddr key_addr); // inline? bool isActive(KeyAddr key_addr) const; // inline?
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Public OneShot state control // Public OneShot state control
@ -126,7 +126,7 @@ class OneShot : public kaleidoscope::Plugin {
/// This is appropriate to use when a key toggles on and you want it to behave /// This is appropriate to use when a key toggles on and you want it to behave
/// like a OneShot key starting with the current event, and lasting until the /// like a OneShot key starting with the current event, and lasting until the
/// key becomes inactive (cancelled by a subsequent keypress). /// key becomes inactive (cancelled by a subsequent keypress).
static void setPending(KeyAddr key_addr); void setPending(KeyAddr key_addr);
/// Put a key directly in the "one-shot" state. /// Put a key directly in the "one-shot" state.
/// ///
@ -136,33 +136,33 @@ class OneShot : public kaleidoscope::Plugin {
/// use `setPending()` instead, rather than calling this function explicitly, /// use `setPending()` instead, rather than calling this function explicitly,
/// as OneShot will automatically cause any key in the "pending" state to /// as OneShot will automatically cause any key in the "pending" state to
/// progress to this state when it is (physically) released. /// progress to this state when it is (physically) released.
static void setOneShot(KeyAddr key_addr); void setOneShot(KeyAddr key_addr);
/// Put a key in the "sticky" OneShot state. /// Put a key in the "sticky" OneShot state.
/// ///
/// This function puts the key at `key_addr` in the "sticky" OneShot state. /// This function puts the key at `key_addr` in the "sticky" OneShot state.
/// It will remain active until it is pressed again. /// It will remain active until it is pressed again.
static void setSticky(KeyAddr key_addr); void setSticky(KeyAddr key_addr);
/// Clear any OneShot state for a key. /// Clear any OneShot state for a key.
/// ///
/// This function clears any OneShot state of the key at `key_addr`. It does /// This function clears any OneShot state of the key at `key_addr`. It does
/// not, however, release the key if it is held. /// not, however, release the key if it is held.
static void clear(KeyAddr key_addr); void clear(KeyAddr key_addr);
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Utility function for other plugins to cancel OneShot keys // Utility function for other plugins to cancel OneShot keys
static void cancel(bool with_stickies = false); void cancel(bool with_stickies = false);
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Timeout onfiguration functions // Timeout onfiguration functions
static void setTimeout(uint16_t ttl) { void setTimeout(uint16_t ttl) {
timeout_ = ttl; timeout_ = ttl;
} }
static void setHoldTimeout(uint16_t ttl) { void setHoldTimeout(uint16_t ttl) {
hold_timeout_ = ttl; hold_timeout_ = ttl;
} }
static void setDoubleTapTimeout(int16_t ttl) { void setDoubleTapTimeout(int16_t ttl) {
double_tap_timeout_ = ttl; double_tap_timeout_ = ttl;
} }
@ -187,39 +187,39 @@ class OneShot : public kaleidoscope::Plugin {
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Configuration variables // Configuration variables
static uint16_t timeout_; uint16_t timeout_{2500};
static uint16_t hold_timeout_; uint16_t hold_timeout_{250};
static int16_t double_tap_timeout_; int16_t double_tap_timeout_{-1};
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// State variables // State variables
static uint16_t stickable_keys_; uint16_t stickable_keys_{uint16_t(-1)};
static bool auto_modifiers_; bool auto_modifiers_{false};
static bool auto_layers_; bool auto_layers_{false};
static KeyAddrBitfield temp_addrs_; KeyAddrBitfield temp_addrs_;
static KeyAddrBitfield glue_addrs_; KeyAddrBitfield glue_addrs_;
static uint16_t start_time_; uint16_t start_time_{0};
static KeyAddr prev_key_addr_; KeyAddr prev_key_addr_{invalid_key_addr};
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Internal utility functions // Internal utility functions
static bool hasTimedOut(uint16_t ttl) { bool hasTimedOut(uint16_t ttl) const {
return Runtime.hasTimeExpired(start_time_, ttl); return Runtime.hasTimeExpired(start_time_, ttl);
} }
static bool hasDoubleTapTimedOut() { bool hasDoubleTapTimedOut() const {
// Derive the true double-tap timeout value if we're using the default. // Derive the true double-tap timeout value if we're using the default.
uint16_t dtto = (double_tap_timeout_ < 0) ? timeout_ : double_tap_timeout_; uint16_t dtto = (double_tap_timeout_ < 0) ? timeout_ : double_tap_timeout_;
return hasTimedOut(dtto); return hasTimedOut(dtto);
} }
static uint8_t getOneShotKeyIndex(Key oneshot_key); uint8_t getOneShotKeyIndex(Key oneshot_key) const;
static uint8_t getKeyIndex(Key key); uint8_t getKeyIndex(Key key) const;
static Key decodeOneShotKey(Key oneshot_key); Key decodeOneShotKey(Key oneshot_key) const;
static void pressKey(KeyAddr key_addr, Key oneshot_key); void pressKey(KeyAddr key_addr, Key oneshot_key);
static void holdKey(KeyAddr key_addr); void holdKey(KeyAddr key_addr) const;
static void releaseKey(KeyAddr key_addr); void releaseKey(KeyAddr key_addr);
}; };
} // namespace plugin } // namespace plugin

Write Preview
Loading…
Cancel
Save