diff --git a/README.md b/README.md index 05f0f63a..0da50974 100644 --- a/README.md +++ b/README.md @@ -5,9 +5,9 @@ [travis:image]: https://travis-ci.org/keyboardio/Kaleidoscope-SpaceCadet.svg?branch=master [travis:status]: https://travis-ci.org/keyboardio/Kaleidoscope-SpaceCadet - [st:stable]: https://img.shields.io/badge/stable-✔-black.png?style=flat&colorA=44cc11&colorB=494e52 - [st:broken]: https://img.shields.io/badge/broken-X-black.png?style=flat&colorA=e05d44&colorB=494e52 - [st:experimental]: https://img.shields.io/badge/experimental----black.png?style=flat&colorA=dfb317&colorB=494e52 + [st:stable]: https://img.shields.io/badge/stable-✔-black.svg?style=flat&colorA=44cc11&colorB=494e52 + [st:broken]: https://img.shields.io/badge/broken-X-black.svg?style=flat&colorA=e05d44&colorB=494e52 + [st:experimental]: https://img.shields.io/badge/experimental----black.svg?style=flat&colorA=dfb317&colorB=494e52 [Space Cadet][space-cadet] Shift is a way to make it more convenient to input parens - those `(` and `)` things -, symbols that a lot of programming languages @@ -36,44 +36,39 @@ enabling the plugin: #include #include -void setup () { - Kaleidoscope.setup (); - USE_PLUGINS (&SpaceCadetShift); +void setup() { + USE_PLUGINS(&SpaceCadetShift); + + Kaleidoscope.setup(); } ``` This assumes a US QWERTY layout on the host computer, and will use the `9` and `0` keys for the left and right parens, respectively. To change these keys, use -the [`.configure()`](#configureleft-right) method outlined below. +the `.opening_paren` and `.closing_paren` properties outlined below. ## Plugin methods -The plugin has a number of methods available on the `SpaceCadetShift` object: +The plugin provides the `SpaceCadetShift` object, with the following methods and +properties: -### `.configure(left, right)` +### `.opening_paren` -> Used to change the configuration of the plugin, namely, the keys used for the -> left and right parens. These keys will be pressed with `Shift` held, and -> should result in the opening and closing parens. +> Set this property to the key that - when shifted - will result in an opening paren. > -> As an example, assuming a Hungarian QWERTZ layout where the parens are not on -> `9` and `0`, we can use the following little snippet in the `setup` method of -> our Sketch: +> Defaults to `Key_9`. -```c++ -void setup () { - SpaceCadetShift.configure(Key_8, Key_9); - Kaleidoscope.setup (); -} -``` +### `.closing_paren` -### `.timeOut` - -> The number of milliseconds to wait before considering a held key in isolation -> as its secondary role. That is, we'd have to hold a `Shift` key this long, by -> itself, to trigger the `Shift` role in itself. +> Set this property to the key that - when shifted - will result in a closing paren. > -> Not strictly a method, it is a variable one can assign a new value to. +> Defaults to `Key_0`. + +### `.time_out` + +> Set this property to the number of milliseconds to wait before considering a +> held key in isolation as its secondary role. That is, we'd have to hold a +> `Shift` key this long, by itself, to trigger the `Shift` role in itself. > > Defaults to 1000. diff --git a/examples/SpaceCadet/SpaceCadet.ino b/examples/SpaceCadet/SpaceCadet.ino index e887dafa..b945f0e6 100644 --- a/examples/SpaceCadet/SpaceCadet.ino +++ b/examples/SpaceCadet/SpaceCadet.ino @@ -40,8 +40,9 @@ const Key keymaps[][ROWS][COLS] PROGMEM = { }; void setup() { - Kaleidoscope.setup(); USE_PLUGINS(&SpaceCadetShift); + + Kaleidoscope.setup(); } void loop() { diff --git a/src/Kaleidoscope/SpaceCadet.cpp b/src/Kaleidoscope/SpaceCadet.cpp index 46ef64f2..21274d94 100644 --- a/src/Kaleidoscope/SpaceCadet.cpp +++ b/src/Kaleidoscope/SpaceCadet.cpp @@ -18,89 +18,79 @@ #include -namespace KaleidoscopePlugins { +namespace kaleidoscope { -uint8_t SpaceCadetShift::parenNeeded; -uint32_t SpaceCadetShift::startTime; -uint16_t SpaceCadetShift::timeOut = 1000; -Key SpaceCadetShift::leftParen, SpaceCadetShift::rightParen; +uint8_t SpaceCadetShift::paren_needed_; +uint32_t SpaceCadetShift::start_time_; +uint16_t SpaceCadetShift::time_out = 1000; +Key SpaceCadetShift::opening_paren = Key_9, SpaceCadetShift::closing_paren = Key_0; SpaceCadetShift::SpaceCadetShift() { - leftParen.raw = Key_9.raw; - rightParen.raw = Key_0.raw; } -void -SpaceCadetShift::begin() { - event_handler_hook_use(this->eventHandlerHook); +void SpaceCadetShift::begin() { + event_handler_hook_use(eventHandlerHook); } -void -SpaceCadetShift::configure(Key left, Key right) { - leftParen = left; - rightParen = right; -} - -Key -SpaceCadetShift::eventHandlerHook(Key mappedKey, byte row, byte col, uint8_t keyState) { +Key SpaceCadetShift::eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_state) { // If nothing happened, bail out fast. - if (!key_is_pressed(keyState) && !key_was_pressed(keyState)) { - return mappedKey; + if (!key_is_pressed(key_state) && !key_was_pressed(key_state)) { + return mapped_key; } // If a key has been just toggled on... - if (key_toggled_on(keyState)) { - if (mappedKey.raw == Key_LeftShift.raw) { // if it is LShift, remember it - bitWrite(parenNeeded, 0, 1); - startTime = millis(); - } else if (mappedKey.raw == Key_RightShift.raw) { // if it is RShift, remember it - bitWrite(parenNeeded, 1, 1); - startTime = millis(); + if (key_toggled_on(key_state)) { + if (mapped_key.raw == Key_LeftShift.raw) { // if it is LShift, remember it + bitWrite(paren_needed_, 0, 1); + start_time_ = millis(); + } else if (mapped_key.raw == Key_RightShift.raw) { // if it is RShift, remember it + bitWrite(paren_needed_, 1, 1); + start_time_ = millis(); } else { // if it is something else, we do not need a paren at the end. - parenNeeded = 0; - startTime = 0; + paren_needed_ = 0; + start_time_ = 0; } // this is all we need to do on keypress, let the next handler do its thing too. - return mappedKey; + return mapped_key; } // if the state is empty, that means that either the shifts weren't pressed, // or we used another key in the interim. in both cases, nothing special to do. - if (!parenNeeded) - return mappedKey; + if (!paren_needed_) + return mapped_key; // if we timed out, that means we need to keep pressing shift, but won't // need the parens in the end. - if ((millis() - startTime) >= timeOut) { - parenNeeded = 0; - return mappedKey; + if ((millis() - start_time_) >= time_out) { + paren_needed_ = 0; + return mapped_key; } // if we have a state, but the key in question is not either of the shifts, // return. This can happen when another key is released, and that should not // interrupt us. - if (mappedKey.raw != Key_LeftShift.raw && - mappedKey.raw != Key_RightShift.raw) - return mappedKey; + if (mapped_key.raw != Key_LeftShift.raw && + mapped_key.raw != Key_RightShift.raw) + return mapped_key; // if a key toggled off (and that must be one of the shifts at this point), // send the parens too (if we were interrupted, we bailed out earlier). - if (key_toggled_off(keyState)) { - Key paren = leftParen; - if (bitRead(parenNeeded, 1)) - paren = rightParen; + if (key_toggled_off(key_state)) { + Key paren = opening_paren; + if (bitRead(paren_needed_, 1)) + paren = closing_paren; - handle_keyswitch_event(mappedKey, row, col, IS_PRESSED | INJECTED); + handle_keyswitch_event(mapped_key, row, col, IS_PRESSED | INJECTED); handle_keyswitch_event(paren, row, col, IS_PRESSED | INJECTED); Keyboard.sendReport(); - parenNeeded = 0; + paren_needed_ = 0; } - return mappedKey; + return mapped_key; } -}; +} -KaleidoscopePlugins::SpaceCadetShift SpaceCadetShift; +kaleidoscope::SpaceCadetShift SpaceCadetShift; diff --git a/src/Kaleidoscope/SpaceCadet.h b/src/Kaleidoscope/SpaceCadet.h index b6c6ffaa..626ef573 100644 --- a/src/Kaleidoscope/SpaceCadet.h +++ b/src/Kaleidoscope/SpaceCadet.h @@ -20,23 +20,23 @@ #include -namespace KaleidoscopePlugins { +namespace kaleidoscope { + class SpaceCadetShift : public KaleidoscopePlugin { public: SpaceCadetShift(void); void begin(void) final; - static void configure(Key left, Key right); - static uint16_t timeOut; + static uint16_t time_out; + static Key opening_paren, closing_paren; private: - static uint8_t parenNeeded; - static uint32_t startTime; - static Key leftParen, rightParen; + static uint8_t paren_needed_; + static uint32_t start_time_; - static Key eventHandlerHook(Key mappedKey, byte row, byte col, uint8_t keyState); + static Key eventHandlerHook(Key mapped_key, byte row, byte col, uint8_t key_state); }; }; -extern KaleidoscopePlugins::SpaceCadetShift SpaceCadetShift; +extern kaleidoscope::SpaceCadetShift SpaceCadetShift;