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

Convert static variables and functions to members

Browse Source 
Signed-off-by: Michael Richters <gedankenexperimenter@gmail.com>
pull/1194/head
Michael Richters 3 years ago
parent 403ea4a8ec
commit bce72c4ddc
No known key found for this signature in database
GPG Key ID: 1288FD13E4EEF0C0
44 changed files with 155 additions and 269 deletions
Show Stats Download Patch File Download Diff File

19
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.cpp
Unescape View File

@ -29,25 +29,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
// =============================================================================
// AutoShift static class variables
// Configuration settings that can be saved to persistent storage.
AutoShift::Settings AutoShift::settings_ = {
.enabled = true,
.timeout = 175,
.enabled_categories = AutoShift::Categories::printableKeys(),
};
// The event tracker ensures that the `onKeyswitchEvent()` handler will follow
// the rules in order to avoid interference with other plugins and prevent
// processing the same event more than once.
KeyEventTracker AutoShift::event_tracker_;
// If there's a delayed keypress from AutoShift, this stored event will contain
// a valid `KeyAddr`. The default constructor produces an event addr of
// `KeyAddr::none()`, so the plugin will start in an inactive state.
KeyEvent pending_event_;
// ============================================================================= // =============================================================================
// AutoShift functions // AutoShift functions

43
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.h
Unescape View File

@ -134,17 +134,17 @@ class AutoShift : public Plugin {
// Configuration functions // Configuration functions
/// Returns `true` if AutoShift is active, `false` otherwise /// Returns `true` if AutoShift is active, `false` otherwise
static bool enabled() { bool enabled() {
return settings_.enabled; return settings_.enabled;
} }
/// Activates the AutoShift plugin (held keys will trigger auto-shift) /// Activates the AutoShift plugin (held keys will trigger auto-shift)
static void enable() { void enable() {
settings_.enabled = true; settings_.enabled = true;
} }
/// Deactivates the AutoShift plugin (held keys will not trigger auto-shift) /// Deactivates the AutoShift plugin (held keys will not trigger auto-shift)
static void disable(); void disable();
/// Turns AutoShift on if it's off, and vice versa /// Turns AutoShift on if it's off, and vice versa
static void toggle() { void toggle() {
if (settings_.enabled) { if (settings_.enabled) {
disable(); disable();
} else { } else {
@ -153,16 +153,16 @@ class AutoShift : public Plugin {
} }
/// Returns the hold time required to trigger auto-shift (in ms) /// Returns the hold time required to trigger auto-shift (in ms)
static uint16_t timeout() { uint16_t timeout() {
return settings_.timeout; return settings_.timeout;
} }
/// Sets the hold time required to trigger auto-shift (in ms) /// Sets the hold time required to trigger auto-shift (in ms)
static void setTimeout(uint16_t new_timeout) { void setTimeout(uint16_t new_timeout) {
settings_.timeout = new_timeout; settings_.timeout = new_timeout;
} }
/// Returns the set of categories currently eligible for auto-shift /// Returns the set of categories currently eligible for auto-shift
static Categories enabledCategories() { Categories enabledCategories() {
return settings_.enabled_categories; return settings_.enabled_categories;
} }
/// Adds `category` to the set eligible for auto-shift /// Adds `category` to the set eligible for auto-shift
@ -175,19 +175,19 @@ class AutoShift : public Plugin {
/// - `AutoShift::Categories::functionKeys()` /// - `AutoShift::Categories::functionKeys()`
/// - `AutoShift::Categories::printableKeys()` /// - `AutoShift::Categories::printableKeys()`
/// - `AutoShift::Categories::allKeys()` /// - `AutoShift::Categories::allKeys()`
static void enable(Categories category) { void enable(Categories category) {
settings_.enabled_categories.add(category); settings_.enabled_categories.add(category);
} }
/// Removes a `Key` category from the set eligible for auto-shift /// Removes a `Key` category from the set eligible for auto-shift
static void disable(Categories category) { void disable(Categories category) {
settings_.enabled_categories.remove(category); settings_.enabled_categories.remove(category);
} }
/// Replaces the list of `Key` categories eligible for auto-shift /// Replaces the list of `Key` categories eligible for auto-shift
static void setEnabled(Categories categories) { void setEnabled(Categories categories) {
settings_.enabled_categories = categories; settings_.enabled_categories = categories;
} }
/// Returns `true` if the given category is eligible for auto-shift /// Returns `true` if the given category is eligible for auto-shift
static bool isEnabled(Categories category) { bool isEnabled(Categories category) {
return settings_.enabled_categories.contains(category); return settings_.enabled_categories.contains(category);
} }
@ -225,7 +225,7 @@ class AutoShift : public Plugin {
/// ///
/// This function can be overridden by the user sketch to configure which keys /// This function can be overridden by the user sketch to configure which keys
/// can trigger auto-shift. /// can trigger auto-shift.
static bool isAutoShiftable(Key key); bool isAutoShiftable(Key key);
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Event handlers // Event handlers
@ -237,19 +237,19 @@ class AutoShift : public Plugin {
/// A container for AutoShift configuration settings /// A container for AutoShift configuration settings
struct Settings { struct Settings {
/// The overall state of the plugin (on/off) /// The overall state of the plugin (on/off)
bool enabled; bool enabled = true;
/// The length of time (ms) a key must be held to trigger auto-shift /// The length of time (ms) a key must be held to trigger auto-shift
uint16_t timeout; uint16_t timeout = 175;
/// The set of `Key` categories eligible to be auto-shifted /// The set of `Key` categories eligible to be auto-shifted
Categories enabled_categories; Categories enabled_categories = AutoShift::Categories::printableKeys();
}; };
static Settings settings_; Settings settings_;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Key event queue state variables // Key event queue state variables
// A device for processing only new events // A device for processing only new events
static KeyEventTracker event_tracker_; KeyEventTracker event_tracker_;
// The maximum number of events in the queue at a time. // The maximum number of events in the queue at a time.
static constexpr uint8_t queue_capacity_{4}; static constexpr uint8_t queue_capacity_{4};
@ -257,12 +257,17 @@ class AutoShift : public Plugin {
// The event queue stores a series of press and release events. // The event queue stores a series of press and release events.
KeyAddrEventQueue<queue_capacity_> queue_; KeyAddrEventQueue<queue_capacity_> queue_;
// If there's a delayed keypress from AutoShift, this stored event will
// contain a valid `KeyAddr`. The default constructor produces an event addr
// of `KeyAddr::none()`, so the plugin will start in an inactive state.
KeyEvent pending_event_;
void flushQueue(); void flushQueue();
void flushEvent(bool is_long_press = false); void flushEvent(bool is_long_press = false);
bool checkForRelease() const; bool checkForRelease() const;
/// The default function for `isAutoShiftable()` /// The default function for `isAutoShiftable()`
static bool enabledForKey(Key key); bool enabledForKey(Key key);
}; };
// ============================================================================= // =============================================================================
@ -274,7 +279,7 @@ class AutoShiftConfig : public Plugin {
private: private:
// The base address in persistent storage for configuration data // The base address in persistent storage for configuration data
static uint16_t settings_base_; uint16_t settings_base_;
}; };
} // namespace plugin } // namespace plugin

12
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShiftConfig.cpp
Unescape View File

@ -32,20 +32,18 @@ namespace plugin {
// ============================================================================= // =============================================================================
// AutoShift configurator // AutoShift configurator
uint16_t AutoShiftConfig::settings_base_;
EventHandlerResult AutoShiftConfig::onSetup() { EventHandlerResult AutoShiftConfig::onSetup() {
settings_base_ = ::EEPROMSettings.requestSlice(sizeof(AutoShift::settings_)); settings_base_ = ::EEPROMSettings.requestSlice(sizeof(AutoShift::Settings));
if (Runtime.storage().isSliceUninitialized( if (Runtime.storage().isSliceUninitialized(
settings_base_, settings_base_,
sizeof(AutoShift::settings_))) { sizeof(AutoShift::Settings))) {
// If our slice is uninitialized, set sensible defaults. // If our slice is uninitialized, set sensible defaults.
Runtime.storage().put(settings_base_, AutoShift::settings_); Runtime.storage().put(settings_base_, ::AutoShift.settings_);
Runtime.storage().commit(); Runtime.storage().commit();
} }
Runtime.storage().get(settings_base_, AutoShift::settings_); Runtime.storage().get(settings_base_, ::AutoShift.settings_);
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
@ -112,7 +110,7 @@ EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) {
break; break;
} }
Runtime.storage().put(settings_base_, AutoShift::settings_); Runtime.storage().put(settings_base_, ::AutoShift.settings_);
Runtime.storage().commit(); Runtime.storage().commit();
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }

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

@ -35,14 +35,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
// =============================================================================
// CharShift class variables
CharShift::KeyPair const *CharShift::progmem_keypairs_{nullptr};
uint8_t CharShift::num_keypairs_{0};
bool CharShift::reverse_shift_state_{false};
// ============================================================================= // =============================================================================
// Event handlers // Event handlers

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

@ -77,42 +77,42 @@ class CharShift : public Plugin {
/// Generally, it will be called via the `KEYPAIRS()` preprocessor macro, not /// Generally, it will be called via the `KEYPAIRS()` preprocessor macro, not
/// directly by user code. /// directly by user code.
template<uint8_t _num_keypairs> template<uint8_t _num_keypairs>
static void setProgmemKeyPairs(KeyPair const (&keypairs)[_num_keypairs]) { void setProgmemKeyPairs(KeyPair const (&keypairs)[_num_keypairs]) {
progmem_keypairs_ = keypairs; progmem_keypairs_ = keypairs;
num_keypairs_ = _num_keypairs; num_keypairs_ = _num_keypairs;
} }
private: private:
// A pointer to an array of `KeyPair` objects in PROGMEM // A pointer to an array of `KeyPair` objects in PROGMEM
static KeyPair const *progmem_keypairs_; KeyPair const *progmem_keypairs_ = nullptr;
// The size of the PROGMEM array of `KeyPair` objects // The size of the PROGMEM array of `KeyPair` objects
static uint8_t num_keypairs_; uint8_t num_keypairs_ = 0;
// 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_; bool reverse_shift_state_ = false;
/// Test for keys that should be handled by CharShift /// Test for keys that should be handled by CharShift
static bool isCharShiftKey(Key key); bool isCharShiftKey(Key key);
/// 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); KeyPair decodeCharShiftKey(Key key);
/// Get the total number of KeyPairs defined /// Get the total number of KeyPairs defined
/// ///
/// This function can be overridden in order to store the `KeyPair` array in /// This function can be overridden in order to store the `KeyPair` array in
/// EEPROM instead of PROGMEM. /// EEPROM instead of PROGMEM.
static uint8_t numKeyPairs(); uint8_t numKeyPairs();
/// Get the `KeyPair` at the specified index from the defined `KeyPair` array /// Get the `KeyPair` at the specified index from the defined `KeyPair` array
/// ///
/// This function can be overridden in order to store the `KeyPair` array in /// This function can be overridden in order to store the `KeyPair` array in
/// EEPROM instead of PROGMEM. /// EEPROM instead of PROGMEM.
static KeyPair readKeyPair(uint8_t n); KeyPair readKeyPair(uint8_t n);
// Default for `keypairsCount()`: size of the PROGMEM array // Default for `keypairsCount()`: size of the PROGMEM array
static uint8_t numProgmemKeyPairs(); uint8_t numProgmemKeyPairs();
// Default for `readKeypair(i)`: fetch the value from PROGMEM // Default for `readKeypair(i)`: fetch the value from PROGMEM
static KeyPair readKeyPairFromProgmem(uint8_t n); KeyPair readKeyPairFromProgmem(uint8_t n);
}; };
} // namespace plugin } // namespace plugin

5
plugins/Kaleidoscope-Cycle/src/kaleidoscope/plugin/Cycle.cpp
Unescape View File

@ -31,11 +31,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
// --- state ---
Key Cycle::last_non_cycle_key_;
KeyAddr Cycle::cycle_key_addr_{KeyAddr::invalid_state};
uint8_t Cycle::current_modifier_flags_;
uint8_t Cycle::cycle_count_;
// --- helpers --- // --- helpers ---

14
plugins/Kaleidoscope-Cycle/src/kaleidoscope/plugin/Cycle.h
Unescape View File

@ -38,18 +38,18 @@ namespace kaleidoscope {
namespace plugin { namespace plugin {
class Cycle : public kaleidoscope::Plugin { class Cycle : public kaleidoscope::Plugin {
public: public:
static void replace(Key key); void replace(Key key);
static void replace(uint8_t cycle_size, const Key cycle_steps[]); void replace(uint8_t cycle_size, const Key cycle_steps[]);
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
private: private:
static uint8_t toModFlag(uint8_t keyCode); uint8_t toModFlag(uint8_t keyCode);
static Key last_non_cycle_key_; Key last_non_cycle_key_;
static KeyAddr cycle_key_addr_; KeyAddr cycle_key_addr_{KeyAddr::invalid_state};
static uint8_t cycle_count_; uint8_t cycle_count_;
static uint8_t current_modifier_flags_; uint8_t current_modifier_flags_;
}; };
} // namespace plugin } // namespace plugin

6
plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.cpp
Unescape View File

@ -34,12 +34,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
uint16_t DynamicMacros::storage_base_;
uint16_t DynamicMacros::storage_size_;
uint16_t DynamicMacros::map_[];
uint8_t DynamicMacros::macro_count_;
Key DynamicMacros::active_macro_keys_[];
// ============================================================================= // =============================================================================
// It might be possible to use Macros instead of reproducing it // It might be possible to use Macros instead of reproducing it
void DynamicMacros::press(Key key) { void DynamicMacros::press(Key key) {

20
plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.h
Unescape View File

@ -42,20 +42,20 @@ class DynamicMacros : public kaleidoscope::Plugin {
EventHandlerResult beforeReportingState(const KeyEvent &event); EventHandlerResult beforeReportingState(const KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *command);
static void reserve_storage(uint16_t size); void reserve_storage(uint16_t size);
void play(uint8_t seq_id); void play(uint8_t seq_id);
private: private:
static uint16_t storage_base_; uint16_t storage_base_;
static uint16_t storage_size_; uint16_t storage_size_;
static uint16_t map_[32]; uint16_t map_[32];
static uint8_t macro_count_; uint8_t macro_count_;
static uint8_t updateDynamicMacroCache(); uint8_t updateDynamicMacroCache();
static Key active_macro_keys_[MAX_CONCURRENT_DYNAMIC_MACRO_KEYS]; Key active_macro_keys_[MAX_CONCURRENT_DYNAMIC_MACRO_KEYS];
static void press(Key key); void press(Key key);
static void release(Key key); void release(Key key);
static void tap(Key key); void tap(Key key);
}; };
} // namespace plugin } // namespace plugin

7
plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.cpp
Unescape View File

@ -34,13 +34,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
uint16_t DynamicTapDance::storage_base_;
uint16_t DynamicTapDance::storage_size_;
uint16_t DynamicTapDance::map_[];
uint8_t DynamicTapDance::offset_;
uint8_t DynamicTapDance::dance_count_;
constexpr uint8_t DynamicTapDance::reserved_tap_dance_key_count_;
void DynamicTapDance::updateDynamicTapDanceCache() { void DynamicTapDance::updateDynamicTapDanceCache() {
uint16_t pos = storage_base_; uint16_t pos = storage_base_;
uint8_t current_id = 0; uint8_t current_id = 0;

16
plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.h
Unescape View File

@ -33,18 +33,18 @@ class DynamicTapDance : public kaleidoscope::Plugin {
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *command);
static void setup(uint8_t dynamic_offset, uint16_t size); void setup(uint8_t dynamic_offset, uint16_t size);
static bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action); bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action);
private: private:
static uint16_t storage_base_; uint16_t storage_base_;
static uint16_t storage_size_; uint16_t storage_size_;
static constexpr uint8_t reserved_tap_dance_key_count_ = ranges::TD_LAST - ranges::TD_FIRST + 1; static constexpr uint8_t reserved_tap_dance_key_count_ = ranges::TD_LAST - ranges::TD_FIRST + 1;
static uint16_t map_[reserved_tap_dance_key_count_]; uint16_t map_[reserved_tap_dance_key_count_];
static uint8_t dance_count_; uint8_t dance_count_;
static uint8_t offset_; uint8_t offset_;
static void updateDynamicTapDanceCache(); void updateDynamicTapDanceCache();
}; };
} // namespace plugin } // namespace plugin

4
plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp
Unescape View File

@ -33,10 +33,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
uint16_t EEPROMKeymapProgrammer::update_position_;
EEPROMKeymapProgrammer::state_t EEPROMKeymapProgrammer::state_;
EEPROMKeymapProgrammer::mode_t EEPROMKeymapProgrammer::mode;
Key EEPROMKeymapProgrammer::new_key_;
void EEPROMKeymapProgrammer::nextState(void) { void EEPROMKeymapProgrammer::nextState(void) {
switch (state_) { switch (state_) {

14
plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h
Unescape View File

@ -32,13 +32,13 @@ class EEPROMKeymapProgrammer : public kaleidoscope::Plugin {
CODE, CODE,
COPY, COPY,
} mode_t; } mode_t;
static mode_t mode; mode_t mode;
static void activate(void) { void activate(void) {
nextState(); nextState();
} }
static void nextState(void); void nextState(void);
static void cancel(void); void cancel(void);
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *command);
@ -50,10 +50,10 @@ class EEPROMKeymapProgrammer : public kaleidoscope::Plugin {
WAIT_FOR_CODE, WAIT_FOR_CODE,
WAIT_FOR_SOURCE_KEY, WAIT_FOR_SOURCE_KEY,
} state_t; } state_t;
static state_t state_; state_t state_;
static uint16_t update_position_; // layer, row, col uint16_t update_position_; // layer, row, col
static Key new_key_; Key new_key_;
}; };
} // namespace plugin } // namespace plugin

5
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.cpp
Unescape View File

@ -30,11 +30,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
struct EEPROMSettings::settings EEPROMSettings::settings_;
bool EEPROMSettings::is_valid_;
bool EEPROMSettings::sealed_;
uint16_t EEPROMSettings::next_start_ = sizeof(EEPROMSettings::settings);
EventHandlerResult EEPROMSettings::onSetup() { EventHandlerResult EEPROMSettings::onSetup() {
Runtime.storage().get(0, settings_); Runtime.storage().get(0, settings_);

36
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.h
Unescape View File

@ -44,34 +44,34 @@ class EEPROMSettings : public kaleidoscope::Plugin {
* fall back to not using it. */ * fall back to not using it. */
static constexpr uint8_t VERSION_CURRENT = 0x01; static constexpr uint8_t VERSION_CURRENT = 0x01;
static void update(void); void update(void);
static bool isValid(void); bool isValid(void);
static void invalidate(void); void invalidate(void);
static uint8_t version(void) { uint8_t version(void) {
return settings_.version; return settings_.version;
} }
static uint16_t requestSlice(uint16_t size); uint16_t requestSlice(uint16_t size);
static void seal(void); void seal(void);
static uint16_t crc(void); uint16_t crc(void);
static uint16_t used(void); uint16_t used(void);
static uint8_t default_layer(uint8_t layer); uint8_t default_layer(uint8_t layer);
static uint8_t default_layer() { uint8_t default_layer() {
return settings_.default_layer; return settings_.default_layer;
} }
static void ignoreHardcodedLayers(bool value); void ignoreHardcodedLayers(bool value);
static bool ignoreHardcodedLayers() { bool ignoreHardcodedLayers() {
return settings_.ignore_hardcoded_layers; return settings_.ignore_hardcoded_layers;
} }
private: private:
static constexpr uint8_t IGNORE_HARDCODED_LAYER = 0x7e; static constexpr uint8_t IGNORE_HARDCODED_LAYER = 0x7e;
static uint16_t next_start_; uint16_t next_start_ = sizeof(EEPROMSettings::settings);
static bool is_valid_; bool is_valid_;
static bool sealed_; bool sealed_;
static struct settings { struct settings {
uint8_t default_layer : 7; uint8_t default_layer : 7;
bool ignore_hardcoded_layers : 1; bool ignore_hardcoded_layers : 1;
uint8_t version; uint8_t version;
@ -81,15 +81,11 @@ class EEPROMSettings : public kaleidoscope::Plugin {
class FocusSettingsCommand : public kaleidoscope::Plugin { class FocusSettingsCommand : public kaleidoscope::Plugin {
public: public:
FocusSettingsCommand() {}
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *command);
}; };
class FocusEEPROMCommand : public kaleidoscope::Plugin { class FocusEEPROMCommand : public kaleidoscope::Plugin {
public: public:
FocusEEPROMCommand() {}
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *command);
}; };

10
plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot-Config.cpp
Unescape View File

@ -30,20 +30,18 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
uint16_t EscapeOneShotConfig::settings_base_;
EventHandlerResult EscapeOneShotConfig::onSetup() { EventHandlerResult EscapeOneShotConfig::onSetup() {
settings_base_ = ::EEPROMSettings.requestSlice(sizeof(EscapeOneShot::settings_)); settings_base_ = ::EEPROMSettings.requestSlice(sizeof(EscapeOneShot::settings_));
if (Runtime.storage().isSliceUninitialized( if (Runtime.storage().isSliceUninitialized(
settings_base_, settings_base_,
sizeof(EscapeOneShot::settings_))) { sizeof(EscapeOneShot::Settings))) {
// If our slice is uninitialized, set sensible defaults. // If our slice is uninitialized, set sensible defaults.
Runtime.storage().put(settings_base_, EscapeOneShot::settings_); Runtime.storage().put(settings_base_, ::EscapeOneShot.settings_);
Runtime.storage().commit(); Runtime.storage().commit();
} }
Runtime.storage().get(settings_base_, EscapeOneShot::settings_); Runtime.storage().get(settings_base_, ::EscapeOneShot.settings_);
return EventHandlerResult::OK; return EventHandlerResult::OK;
} }
@ -66,7 +64,7 @@ EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *command) {
::EscapeOneShot.setCancelKey(k); ::EscapeOneShot.setCancelKey(k);
} }
Runtime.storage().put(settings_base_, EscapeOneShot::settings_); Runtime.storage().put(settings_base_, ::EscapeOneShot.settings_);
Runtime.storage().commit(); Runtime.storage().commit();
return EventHandlerResult::EVENT_CONSUMED; return EventHandlerResult::EVENT_CONSUMED;
} }

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

@ -27,9 +27,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
EscapeOneShot::Settings EscapeOneShot::settings_ = {
.cancel_oneshot_key = Key_Escape};
EventHandlerResult EscapeOneShot::onKeyEvent(KeyEvent &event) { EventHandlerResult EscapeOneShot::onKeyEvent(KeyEvent &event) {
// We only act on an escape key (or `cancel_oneshot_key_`, if that has been // We only act on an escape key (or `cancel_oneshot_key_`, if that has been
// set) that has just been pressed, and not generated by some other // set) that has just been pressed, and not generated by some other

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

@ -37,10 +37,10 @@ class EscapeOneShot : public kaleidoscope::Plugin {
public: public:
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
static void setCancelKey(Key cancel_key) { void setCancelKey(Key cancel_key) {
settings_.cancel_oneshot_key = cancel_key; settings_.cancel_oneshot_key = cancel_key;
} }
static Key getCancelKey() { Key getCancelKey() {
return settings_.cancel_oneshot_key; return settings_.cancel_oneshot_key;
} }
@ -50,7 +50,9 @@ class EscapeOneShot : public kaleidoscope::Plugin {
struct Settings { struct Settings {
Key cancel_oneshot_key; Key cancel_oneshot_key;
}; };
static Settings settings_; Settings settings_ = {
.cancel_oneshot_key = Key_Escape
};
}; };
class EscapeOneShotConfig : public Plugin { class EscapeOneShotConfig : public Plugin {
@ -60,7 +62,7 @@ class EscapeOneShotConfig : public Plugin {
EventHandlerResult onNameQuery(); EventHandlerResult onNameQuery();
private: private:
static uint16_t settings_base_; uint16_t settings_base_;
}; };
} // namespace plugin } // namespace plugin

3
plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.cpp
Unescape View File

@ -33,9 +33,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
uint16_t FingerPainter::color_base_;
bool FingerPainter::edit_mode_;
EventHandlerResult FingerPainter::onNameQuery() { EventHandlerResult FingerPainter::onNameQuery() {
return ::Focus.sendName(F("FingerPainter")); return ::Focus.sendName(F("FingerPainter"));
} }

6
plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.h
Unescape View File

@ -33,7 +33,7 @@ namespace plugin {
// //
class FingerPainter : public LEDMode { class FingerPainter : public LEDMode {
public: public:
static void toggle(void); void toggle(void);
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *command);
@ -45,8 +45,8 @@ class FingerPainter : public LEDMode {
void refreshAt(KeyAddr key_addr) final; void refreshAt(KeyAddr key_addr) final;
private: private:
static uint16_t color_base_; uint16_t color_base_;
static bool edit_mode_; bool edit_mode_;
}; };
} // namespace plugin } // namespace plugin

3
plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.cpp
Unescape View File

@ -33,9 +33,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
char FocusSerial::command_[32];
uint8_t FocusSerial::buf_cursor_ = 0;
EventHandlerResult FocusSerial::afterEachCycle() { EventHandlerResult FocusSerial::afterEachCycle() {
// GD32 doesn't currently autoflush the very last packet. So manually flush here // GD32 doesn't currently autoflush the very last packet. So manually flush here
Runtime.serialPort().flush(); Runtime.serialPort().flush();

8
plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.h
Unescape View File

@ -113,15 +113,15 @@ class FocusSerial : public kaleidoscope::Plugin {
EventHandlerResult onFocusEvent(const char *command); EventHandlerResult onFocusEvent(const char *command);
private: private:
static char command_[32]; char command_[32];
static uint8_t buf_cursor_; uint8_t buf_cursor_ = 0;
static void printBool(bool b); void printBool(bool b);
// This is a hacky workaround for the host seemingly dropping characters // This is a hacky workaround for the host seemingly dropping characters
// when a client spams its serial port too quickly // when a client spams its serial port too quickly
// Verified on GD32 and macOS 12.3 2022-03-29 // Verified on GD32 and macOS 12.3 2022-03-29
static constexpr uint8_t focus_delay_us_after_character_ = 100; static constexpr uint8_t focus_delay_us_after_character_ = 100;
static void delayAfterPrint() { delayMicroseconds(focus_delay_us_after_character_); } void delayAfterPrint() { delayMicroseconds(focus_delay_us_after_character_); }
}; };
} // namespace plugin } // namespace plugin

4
plugins/Kaleidoscope-GhostInTheFirmware/src/kaleidoscope/plugin/GhostInTheFirmware.cpp
Unescape View File

@ -28,10 +28,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
const GhostInTheFirmware::GhostKey *GhostInTheFirmware::ghost_keys;
bool GhostInTheFirmware::is_active_ = false;
uint16_t GhostInTheFirmware::current_pos_ = 0;
uint16_t GhostInTheFirmware::start_time_;
void GhostInTheFirmware::activate(void) { void GhostInTheFirmware::activate(void) {
is_active_ = true; is_active_ = true;

10
plugins/Kaleidoscope-GhostInTheFirmware/src/kaleidoscope/plugin/GhostInTheFirmware.h
Unescape View File

@ -32,16 +32,16 @@ class GhostInTheFirmware : public kaleidoscope::Plugin {
uint16_t press_time; uint16_t press_time;
uint16_t delay; uint16_t delay;
}; };
static const GhostKey *ghost_keys; const GhostKey *ghost_keys;
static void activate(void); void activate(void);
EventHandlerResult afterEachCycle(); EventHandlerResult afterEachCycle();
private: private:
static bool is_active_; bool is_active_ = false;
static uint16_t current_pos_; uint16_t current_pos_ = 0;
static uint16_t start_time_; uint16_t start_time_;
}; };
} // namespace plugin } // namespace plugin

6
plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.cpp
Unescape View File

@ -38,12 +38,6 @@ namespace kaleidoscope {
namespace device { namespace device {
namespace ez { namespace ez {
ErgoDoxScanner ErgoDox::scanner_;
uint8_t ErgoDox::previousKeyState_[matrix_rows];
uint8_t ErgoDox::keyState_[matrix_rows];
uint8_t ErgoDox::debounce_matrix_[matrix_rows][matrix_columns];
uint8_t ErgoDox::debounce = 5;
static bool do_scan_ = 1; static bool do_scan_ = 1;
void ErgoDox::setup(void) { void ErgoDox::setup(void) {

18
plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.h
Unescape View File

@ -78,17 +78,17 @@ class ErgoDox : public kaleidoscope::device::ATmega32U4Keyboard<ErgoDoxProps> {
void setStatusLED(uint8_t led, bool state = true); void setStatusLED(uint8_t led, bool state = true);
void setStatusLEDBrightness(uint8_t led, uint8_t brightness); void setStatusLEDBrightness(uint8_t led, uint8_t brightness);
static uint8_t debounce; uint8_t debounce = 5;
private: private:
static ErgoDoxScanner scanner_; ErgoDoxScanner scanner_;
static uint8_t previousKeyState_[matrix_rows]; uint8_t previousKeyState_[matrix_rows];
static uint8_t keyState_[matrix_rows]; uint8_t keyState_[matrix_rows];
static uint8_t debounce_matrix_[matrix_rows][matrix_columns]; uint8_t debounce_matrix_[matrix_rows][matrix_columns];
static uint8_t debounceMaskForRow(uint8_t row); uint8_t debounceMaskForRow(uint8_t row);
static void debounceRow(uint8_t change, uint8_t row); void debounceRow(uint8_t change, uint8_t row);
static void readMatrixRow(uint8_t row); void readMatrixRow(uint8_t row);
}; };
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD #else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class ErgoDox; class ErgoDox;

6
plugins/Kaleidoscope-Leader/src/kaleidoscope/plugin/Leader.cpp
Unescape View File

@ -34,15 +34,9 @@ namespace kaleidoscope {
namespace plugin { namespace plugin {
// --- state --- // --- state ---
Key Leader::sequence_[LEADER_MAX_SEQUENCE_LENGTH + 1];
KeyEventTracker Leader::event_tracker_;
uint8_t Leader::sequence_pos_;
uint16_t Leader::start_time_ = 0;
#ifndef NDEPRECATED #ifndef NDEPRECATED
uint16_t Leader::time_out = 1000; uint16_t Leader::time_out = 1000;
#endif #endif
uint16_t Leader::timeout_ = 1000;
const Leader::dictionary_t *Leader::dictionary;
// --- helpers --- // --- helpers ---

18
plugins/Kaleidoscope-Leader/src/kaleidoscope/plugin/Leader.h
Unescape View File

@ -67,9 +67,9 @@ class Leader : public kaleidoscope::Plugin {
action_t action; action_t action;
} dictionary_t; } dictionary_t;
static const dictionary_t *dictionary; const dictionary_t *dictionary;
static void reset(void); void reset(void);
#ifndef NDEPRECATED #ifndef NDEPRECATED
DEPRECATED(LEADER_TIME_OUT) DEPRECATED(LEADER_TIME_OUT)
@ -79,7 +79,7 @@ class Leader : public kaleidoscope::Plugin {
void inject(Key key, uint8_t key_state); void inject(Key key, uint8_t key_state);
#endif #endif
static void setTimeout(uint16_t timeout) { void setTimeout(uint16_t timeout) {
#ifndef NDEPRECATED #ifndef NDEPRECATED
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations" #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@ -94,13 +94,13 @@ class Leader : public kaleidoscope::Plugin {
EventHandlerResult afterEachCycle(); EventHandlerResult afterEachCycle();
private: private:
static Key sequence_[LEADER_MAX_SEQUENCE_LENGTH + 1]; Key sequence_[LEADER_MAX_SEQUENCE_LENGTH + 1];
static KeyEventTracker event_tracker_; KeyEventTracker event_tracker_;
static uint8_t sequence_pos_; uint8_t sequence_pos_;
static uint16_t start_time_; uint16_t start_time_ = 0;
static uint16_t timeout_; uint16_t timeout_ = 1000;
static int8_t lookup(void); int8_t lookup(void);
}; };
} // namespace plugin } // namespace plugin

1
plugins/Kaleidoscope-MagicCombo/src/kaleidoscope/plugin/MagicCombo.cpp
Unescape View File

@ -29,7 +29,6 @@ namespace kaleidoscope {
namespace plugin { namespace plugin {
uint16_t MagicCombo::min_interval = 500; uint16_t MagicCombo::min_interval = 500;
uint16_t MagicCombo::start_time_ = 0;
EventHandlerResult MagicCombo::onNameQuery() { EventHandlerResult MagicCombo::onNameQuery() {
return ::Focus.sendName(F("MagicCombo")); return ::Focus.sendName(F("MagicCombo"));

2
plugins/Kaleidoscope-MagicCombo/src/kaleidoscope/plugin/MagicCombo.h
Unescape View File

@ -54,7 +54,7 @@ class MagicCombo : public kaleidoscope::Plugin {
EventHandlerResult afterEachCycle(); EventHandlerResult afterEachCycle();
private: private:
static uint16_t start_time_; uint16_t start_time_ = 0;
}; };
namespace magiccombo { namespace magiccombo {

2
plugins/Kaleidoscope-Redial/src/kaleidoscope/plugin/Redial.cpp
Unescape View File

@ -28,8 +28,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
Key Redial::last_key_;
EventHandlerResult Redial::onNameQuery() { EventHandlerResult Redial::onNameQuery() {
return ::Focus.sendName(F("Redial")); return ::Focus.sendName(F("Redial"));
} }

2
plugins/Kaleidoscope-Redial/src/kaleidoscope/plugin/Redial.h
Unescape View File

@ -37,7 +37,7 @@ class Redial : public kaleidoscope::Plugin {
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
private: private:
static Key last_key_; Key last_key_;
}; };
} // namespace plugin } // namespace plugin

2
plugins/Kaleidoscope-ShapeShifter/src/kaleidoscope/plugin/ShapeShifter.cpp
Unescape View File

@ -28,8 +28,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
const ShapeShifter::dictionary_t *ShapeShifter::dictionary = nullptr;
EventHandlerResult ShapeShifter::onKeyEvent(KeyEvent &event) { EventHandlerResult ShapeShifter::onKeyEvent(KeyEvent &event) {
if (dictionary == nullptr) if (dictionary == nullptr)
return EventHandlerResult::OK; return EventHandlerResult::OK;

2
plugins/Kaleidoscope-ShapeShifter/src/kaleidoscope/plugin/ShapeShifter.h
Unescape View File

@ -31,7 +31,7 @@ class ShapeShifter : public kaleidoscope::Plugin {
Key original, replacement; Key original, replacement;
} dictionary_t; } dictionary_t;
static const dictionary_t *dictionary; const dictionary_t *dictionary = nullptr;
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
}; };

13
plugins/Kaleidoscope-SpaceCadet/src/kaleidoscope/plugin/SpaceCadet.cpp
Unescape View File

@ -51,19 +51,6 @@ SpaceCadet::KeyBinding::KeyBinding(Key input, Key output, uint16_t timeout)
SpaceCadet::KeyBinding *SpaceCadet::map; SpaceCadet::KeyBinding *SpaceCadet::map;
uint16_t SpaceCadet::time_out = 200; uint16_t SpaceCadet::time_out = 200;
// -----------------------------------------------------------------------------
// State variables
uint8_t SpaceCadet::mode_ = SpaceCadet::Mode::ON;
// These variables are used to keep track of any pending unresolved SpaceCadet
// key that has been pressed. If `pending_map_index_` is negative, it means
// there is no such pending keypress. Otherwise, it holds the value of the index
// of that key in the array.
int8_t SpaceCadet::pending_map_index_ = -1;
KeyEventTracker SpaceCadet::event_tracker_;
// ============================================================================= // =============================================================================
// SpaceCadet functions // SpaceCadet functions

16
plugins/Kaleidoscope-SpaceCadet/src/kaleidoscope/plugin/SpaceCadet.h
Unescape View File

@ -66,16 +66,16 @@ class SpaceCadet : public kaleidoscope::Plugin {
SpaceCadet(void); SpaceCadet(void);
// Methods // Methods
static void enable() { void enable() {
mode_ = Mode::ON; mode_ = Mode::ON;
} }
static void disable() { void disable() {
mode_ = Mode::OFF; mode_ = Mode::OFF;
} }
static void enableWithoutDelay() { void enableWithoutDelay() {
mode_ = Mode::NO_DELAY; mode_ = Mode::NO_DELAY;
} }
static bool active() { bool active() {
return (mode_ == Mode::ON || mode_ == Mode::NO_DELAY); return (mode_ == Mode::ON || mode_ == Mode::NO_DELAY);
} }
@ -93,7 +93,7 @@ class SpaceCadet : public kaleidoscope::Plugin {
OFF, OFF,
NO_DELAY, NO_DELAY,
}; };
static uint8_t mode_; uint8_t mode_;
static KeyEventTracker event_tracker_; static KeyEventTracker event_tracker_;
@ -103,7 +103,11 @@ class SpaceCadet : public kaleidoscope::Plugin {
// The event queue stores a series of press and release events. // The event queue stores a series of press and release events.
KeyAddrEventQueue<queue_capacity_> event_queue_; KeyAddrEventQueue<queue_capacity_> event_queue_;
static int8_t pending_map_index_; // This variable is used to keep track of any pending unresolved SpaceCadet
// key that has been pressed. If `pending_map_index_` is negative, it means
// there is no such pending keypress. Otherwise, it holds the value of the
// index of that key in the array.
int8_t pending_map_index_ = -1;
int8_t getSpaceCadetKeyIndex(Key key) const; int8_t getSpaceCadetKeyIndex(Key key) const;

5
plugins/Kaleidoscope-Syster/src/kaleidoscope/plugin/Syster.cpp
Unescape View File

@ -31,11 +31,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
// --- state ---
char Syster::symbol_[SYSTER_MAX_SYMBOL_LENGTH + 1];
uint8_t Syster::symbol_pos_;
bool Syster::is_active_;
// --- api --- // --- api ---
void Syster::reset(void) { void Syster::reset(void) {
symbol_pos_ = 0; symbol_pos_ = 0;

8
plugins/Kaleidoscope-Syster/src/kaleidoscope/plugin/Syster.h
Unescape View File

@ -41,7 +41,7 @@ class Syster : public kaleidoscope::Plugin {
SymbolAction SymbolAction
} action_t; } action_t;
static void reset(); void reset();
bool is_active(); bool is_active();
@ -49,9 +49,9 @@ class Syster : public kaleidoscope::Plugin {
EventHandlerResult onKeyEvent(KeyEvent &event); EventHandlerResult onKeyEvent(KeyEvent &event);
private: private:
static char symbol_[SYSTER_MAX_SYMBOL_LENGTH + 1]; char symbol_[SYSTER_MAX_SYMBOL_LENGTH + 1];
static uint8_t symbol_pos_; uint8_t symbol_pos_;
static bool is_active_; bool is_active_ = false;
}; };
} // namespace plugin } // namespace plugin

3
plugins/Kaleidoscope-TapDance/src/kaleidoscope/plugin/TapDance.cpp
Unescape View File

@ -38,9 +38,6 @@ namespace plugin {
// --- config --- // --- config ---
uint16_t TapDance::time_out = 200; uint16_t TapDance::time_out = 200;
uint8_t TapDance::tap_count_ = 0;
KeyEventTracker TapDance::event_tracker_;
// --- api --- // --- api ---
void TapDance::actionKeys(uint8_t tap_count, void TapDance::actionKeys(uint8_t tap_count,

4
plugins/Kaleidoscope-TapDance/src/kaleidoscope/plugin/TapDance.h
Unescape View File

@ -73,10 +73,10 @@ class TapDance : public kaleidoscope::Plugin {
// The event queue stores a series of press and release events. // The event queue stores a series of press and release events.
KeyAddrEventQueue<queue_capacity_> event_queue_; KeyAddrEventQueue<queue_capacity_> event_queue_;
static KeyEventTracker event_tracker_; KeyEventTracker event_tracker_;
// The number of taps in the current TapDance sequence. // The number of taps in the current TapDance sequence.
static uint8_t tap_count_; uint8_t tap_count_ = 0;
void flushQueue(KeyAddr ignored_addr = KeyAddr::none()); void flushQueue(KeyAddr ignored_addr = KeyAddr::none());
}; };

2
plugins/Kaleidoscope-TopsyTurvy/src/kaleidoscope/plugin/TopsyTurvy.cpp
Unescape View File

@ -32,8 +32,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
KeyAddr TopsyTurvy::tt_addr_ = KeyAddr::none();
EventHandlerResult TopsyTurvy::onKeyEvent(KeyEvent &event) { EventHandlerResult TopsyTurvy::onKeyEvent(KeyEvent &event) {
if (keyToggledOff(event.state)) { if (keyToggledOff(event.state)) {
if (event.addr == tt_addr_) if (event.addr == tt_addr_)

2
plugins/Kaleidoscope-TopsyTurvy/src/kaleidoscope/plugin/TopsyTurvy.h
Unescape View File

@ -45,7 +45,7 @@ class TopsyTurvy : public kaleidoscope::Plugin {
} }
private: private:
static KeyAddr tt_addr_; KeyAddr tt_addr_ = KeyAddr::none();
}; };
} // namespace plugin } // namespace plugin

10
plugins/Kaleidoscope-Turbo/src/kaleidoscope/plugin/Turbo.cpp
Unescape View File

@ -37,16 +37,6 @@
namespace kaleidoscope { namespace kaleidoscope {
namespace plugin { namespace plugin {
uint16_t Turbo::interval_ = 10;
uint16_t Turbo::flash_interval_ = 69;
bool Turbo::sticky_ = false;
bool Turbo::flash_ = true;
cRGB Turbo::active_color_ = CRGB(160, 0, 0);
bool Turbo::active_ = false;
uint32_t Turbo::start_time_ = 0;
uint32_t Turbo::flash_start_time_ = 0;
uint16_t Turbo::interval() { uint16_t Turbo::interval() {
return interval_; return interval_;
} }

16
plugins/Kaleidoscope-Turbo/src/kaleidoscope/plugin/Turbo.h
Unescape View File

@ -53,15 +53,15 @@ class Turbo : public kaleidoscope::Plugin {
EventHandlerResult beforeSyncingLeds(); EventHandlerResult beforeSyncingLeds();
private: private:
static uint16_t interval_; uint16_t interval_ = 10;
static uint16_t flash_interval_; uint16_t flash_interval_ = 69;
static bool sticky_; bool sticky_ = false;
static bool flash_; bool flash_ = true;
static cRGB active_color_; cRGB active_color_ = CRGB(160, 0, 0);
static bool active_; bool active_ = false;
static uint32_t start_time_; uint32_t start_time_ = 0;
static uint32_t flash_start_time_; uint32_t flash_start_time_ = 0;
}; };
} // namespace plugin } // namespace plugin

Write Preview
Loading…
Cancel
Save