Merge pull request #56 from algernon/f/keyswitch-state-rework

Rework the keyswitch states
pull/59/head
Jesse Vincent 8 years ago committed by GitHub
commit 95b2b4ea4f

@ -4,8 +4,8 @@
#include "MouseWrapper.h" #include "MouseWrapper.h"
#include "KeyboardioFirmware.h" #include "KeyboardioFirmware.h"
static void handle_mouse_key_event(Key mappedKey, uint8_t currentState, uint8_t previousState) { static void handle_mouse_key_event(Key mappedKey, uint8_t keyState) {
if (!key_is_pressed(currentState,previousState)) if (!key_is_pressed(keyState))
return; return;
if (mappedKey.rawKey & KEY_MOUSE_UP) { if (mappedKey.rawKey & KEY_MOUSE_UP) {
@ -22,14 +22,14 @@ static void handle_mouse_key_event(Key mappedKey, uint8_t currentState, uint8_t
} }
} }
static bool handleMouseKeys(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState) { static bool handleMouseKeys(Key mappedKey, byte row, byte col, uint8_t keyState) {
if (! (mappedKey.flags & IS_INTERNAL) if (! (mappedKey.flags & IS_INTERNAL)
&& (mappedKey.rawKey == KEY_MOUSE_BTN_L && (mappedKey.rawKey == KEY_MOUSE_BTN_L
|| mappedKey.rawKey == KEY_MOUSE_BTN_M || mappedKey.rawKey == KEY_MOUSE_BTN_M
|| mappedKey.rawKey == KEY_MOUSE_BTN_R)) { || mappedKey.rawKey == KEY_MOUSE_BTN_R)) {
if (key_toggled_on(currentState, previousState)) { if (key_toggled_on(keyState)) {
MouseWrapper.press_button(mappedKey.rawKey); MouseWrapper.press_button(mappedKey.rawKey);
} else if (key_toggled_off(currentState, previousState)) { } else if (key_toggled_off(keyState)) {
MouseWrapper.release_button(mappedKey.rawKey); MouseWrapper.release_button(mappedKey.rawKey);
} }
return true; return true;
@ -39,8 +39,8 @@ static bool handleMouseKeys(Key mappedKey, byte row, byte col, uint8_t currentSt
return false; return false;
if (!(mappedKey.rawKey & KEY_MOUSE_WARP)) { if (!(mappedKey.rawKey & KEY_MOUSE_WARP)) {
handle_mouse_key_event(mappedKey, currentState, previousState); handle_mouse_key_event(mappedKey, keyState);
} else if (key_toggled_on(currentState,previousState)) { } else if (key_toggled_on(keyState)) {
if (mappedKey.rawKey & KEY_MOUSE_WARP && mappedKey.flags & IS_MOUSE_KEY) { if (mappedKey.rawKey & KEY_MOUSE_WARP && mappedKey.flags & IS_MOUSE_KEY) {
// we don't pass in the left and up values because those are the // we don't pass in the left and up values because those are the
// default, "no-op" conditionals // default, "no-op" conditionals

@ -130,15 +130,14 @@ void Model01::act_on_matrix_scan() {
uint8_t keynum = (row*8)+(col); uint8_t keynum = (row*8)+(col);
handle_key_event(Key_NoKey, row, 7-col, uint8_t keyState = (bitRead(previousLeftHandState.all, keynum) << 0) |
bitRead(leftHandState.all, keynum), (bitRead(leftHandState.all, keynum) << 1);
bitRead(previousLeftHandState.all, keynum) handle_key_event(Key_NoKey, row, 7-col, keyState);
);
keyState = (bitRead(previousRightHandState.all, keynum) << 0) |
handle_key_event(Key_NoKey, row, (15- col), (bitRead(rightHandState.all, keynum) << 1);
bitRead(rightHandState.all, keynum),
bitRead(previousRightHandState.all, keynum) handle_key_event(Key_NoKey, row, (15- col), keyState);
);
} }
} }
} }

@ -64,7 +64,7 @@ void TestMode_::TestMatrix () {
void TestMode_::setup() { void TestMode_::setup() {
eventHandlers[0] = handle_key_event_test; eventHandlers[0] = handle_key_event_test;
} }
bool handle_key_event_test(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState) { bool handle_key_event_test(Key mappedKey, byte row, byte col, uint8_t keyState) {
Serial.write(row); Serial.write(row);
return false; return false;
} }

@ -15,4 +15,4 @@ class TestMode_ {
extern TestMode_ TestMode; extern TestMode_ TestMode;
bool handle_key_event_test(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState); bool handle_key_event_test(Key mappedKey, byte row, byte col, uint8_t keyState);

@ -5,7 +5,7 @@
#define HOOK_MAX 64 #define HOOK_MAX 64
typedef bool (*custom_handler_t)(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState); typedef bool (*custom_handler_t)(Key mappedKey, byte row, byte col, uint8_t keyState);
extern custom_handler_t eventHandlers[HOOK_MAX]; extern custom_handler_t eventHandlers[HOOK_MAX];
void event_handler_hook_add (custom_handler_t hook); void event_handler_hook_add (custom_handler_t hook);

@ -1,7 +1,7 @@
#include "key_events.h" #include "key_events.h"
void handle_synthetic_key_event(Key mappedKey, uint8_t currentState, uint8_t previousState) { void handle_synthetic_key_event(Key mappedKey, uint8_t keyState) {
if (key_toggled_on(currentState,previousState)) { if (key_toggled_on(keyState)) {
if (mappedKey.flags & IS_CONSUMER) { if (mappedKey.flags & IS_CONSUMER) {
ConsumerControl.press(mappedKey.rawKey); ConsumerControl.press(mappedKey.rawKey);
} else if (mappedKey.flags & IS_INTERNAL) { } else if (mappedKey.flags & IS_INTERNAL) {
@ -29,32 +29,32 @@ Key lookup_key(byte keymap, byte row, byte col) {
return mappedKey; return mappedKey;
} }
void handle_key_event(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState) { void handle_key_event(Key mappedKey, byte row, byte col, uint8_t keyState) {
if (mappedKey.raw == Key_NoKey.raw) { if (!(keyState & INJECTED)) {
mappedKey = lookup_key(temporary_keymap, row, col); mappedKey = lookup_key(temporary_keymap, row, col);
} }
for (byte i = 0; eventHandlers[i] != NULL && i < HOOK_MAX; i++) { for (byte i = 0; eventHandlers[i] != NULL && i < HOOK_MAX; i++) {
custom_handler_t handler = eventHandlers[i]; custom_handler_t handler = eventHandlers[i];
if ((*handler)(mappedKey, row, col, currentState, previousState)) if ((*handler)(mappedKey, row, col, keyState))
return; return;
} }
} }
bool handle_key_event_default(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState) { bool handle_key_event_default(Key mappedKey, byte row, byte col, uint8_t keyState) {
//for every newly pressed button, figure out what logical key it is and send a key down event //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 // for every newly released button, figure out what logical key it is and send a key up event
Key baseKey = Key_NoKey; Key baseKey = Key_NoKey;
if (mappedKey.raw == Key_NoKey.raw) { if (!(keyState & INJECTED)) {
baseKey = lookup_key(primary_keymap, row, col); baseKey = lookup_key(primary_keymap, row, col);
} }
if ((baseKey.flags & SWITCH_TO_KEYMAP if ((baseKey.flags & SWITCH_TO_KEYMAP
|| baseKey.flags & SWITCH_TO_KEYMAP_MOMENTARY)) { || baseKey.flags & SWITCH_TO_KEYMAP_MOMENTARY)) {
handle_keymap_key_event(baseKey, currentState, previousState); handle_keymap_key_event(baseKey, keyState);
} else if (mappedKey.flags & SYNTHETIC) { } else if (mappedKey.flags & SYNTHETIC) {
handle_synthetic_key_event( mappedKey, currentState, previousState); handle_synthetic_key_event( mappedKey, keyState);
} else if (key_is_pressed(currentState, previousState)) { } else if (key_is_pressed(keyState)) {
press_key(mappedKey); press_key(mappedKey);
} }
return true; return true;
@ -80,9 +80,9 @@ void press_key(Key mappedKey) {
} }
void handle_keymap_key_event(Key keymapEntry, uint8_t currentState, uint8_t previousState) { void handle_keymap_key_event(Key keymapEntry, uint8_t keyState) {
if (keymapEntry.flags & SWITCH_TO_KEYMAP_MOMENTARY ) { if (keymapEntry.flags & SWITCH_TO_KEYMAP_MOMENTARY ) {
if (key_toggled_on(currentState, previousState)) { if (key_toggled_on(keyState)) {
if ( keymapEntry.rawKey == KEYMAP_NEXT) { if ( keymapEntry.rawKey == KEYMAP_NEXT) {
temporary_keymap++; temporary_keymap++;
} else if ( keymapEntry.rawKey == KEYMAP_PREVIOUS) { } else if ( keymapEntry.rawKey == KEYMAP_PREVIOUS) {
@ -91,12 +91,12 @@ void handle_keymap_key_event(Key keymapEntry, uint8_t currentState, uint8_t prev
temporary_keymap = keymapEntry.rawKey; temporary_keymap = keymapEntry.rawKey;
} }
} }
if (key_toggled_off(currentState, previousState)) { if (key_toggled_off(keyState)) {
temporary_keymap = primary_keymap; temporary_keymap = primary_keymap;
} }
// switch keymap and stay there // switch keymap and stay there
} else if (key_toggled_on(currentState, previousState)) { } else if (key_toggled_on(keyState)) {
temporary_keymap = primary_keymap = keymapEntry.rawKey; temporary_keymap = primary_keymap = keymapEntry.rawKey;
Storage.save_primary_keymap(primary_keymap); Storage.save_primary_keymap(primary_keymap);
} }

@ -39,14 +39,16 @@ extern const Key keymaps[][ROWS][COLS];
* For this reason, the handle_key_event receives four arguments: the mapped key * For this reason, the handle_key_event receives four arguments: the mapped key
* (or Key_NoKey if we do not want to override what is in the keymap), the row * (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 * and column 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. * 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 handle_key_event(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState); void handle_key_event(Key mappedKey, byte row, byte col, uint8_t keyState);
// Internal use // Internal use
void handle_synthetic_key_event( Key mappedKey, uint8_t currentState, uint8_t previousState); void handle_synthetic_key_event( Key mappedKey, uint8_t keyState);
void press_key(Key mappedKey); void press_key(Key mappedKey);
void handle_keymap_key_event(Key keymapEntry, uint8_t currentState, uint8_t previousState); void handle_keymap_key_event(Key keymapEntry, uint8_t keyState);
bool handle_key_event_default(Key mappedKey, byte row, byte col, uint8_t currentState, uint8_t previousState); bool handle_key_event_default(Key mappedKey, byte row, byte col, uint8_t keyState);
Key lookup_key(byte keymap, byte row, byte col); Key lookup_key(byte keymap, byte row, byte col);

@ -1,68 +0,0 @@
#include "keyswitch_state.h"
// switch debouncing and status
boolean key_was_pressed (byte keyState) {
if ( keyState & B00001000 || keyState & B00000100) {
return true;
} else {
return false;
}
}
boolean key_was_pressed (uint8_t currentState, uint8_t previousState) {
if (previousState) {
return true;
} else {
return false;
}
}
boolean key_is_pressed (byte keyState) {
if ( keyState & B00000001 && keyState & B00000010 ) {
return true;
} else {
return false;
}
}
boolean key_is_pressed (uint8_t currentState, uint8_t previousState) {
if (currentState) {
return true;
} else {
return false;
}
}
boolean key_toggled_on(byte keyState) {
if (key_is_pressed(keyState) && ! key_was_pressed(keyState)) {
return true;
} else {
return false;
}
}
boolean key_toggled_on (uint8_t currentState, uint8_t previousState) {
if (currentState && ! previousState ) {
return true;
} else {
return false;
}
}
boolean key_toggled_off(byte keyState) {
if (key_was_pressed(keyState) && ! key_is_pressed(keyState)) {
return true;
} else {
return false;
}
}
boolean key_toggled_off (uint8_t currentState, uint8_t previousState) {
if (previousState && ! currentState ) {
return true;
} else {
return false;
}
}

@ -3,13 +3,11 @@
#include <Arduino.h> #include <Arduino.h>
#define INJECTED B10000000
boolean key_was_pressed (byte keyState); #define IS_PRESSED B00000010
boolean key_is_pressed (byte keyState); #define WAS_PRESSED B00000001
boolean key_toggled_on(byte keyState);
boolean key_toggled_off(byte keyState); #define key_was_pressed(keyState) (keyState & WAS_PRESSED)
#define key_is_pressed(keyState) (keyState & IS_PRESSED)
boolean key_was_pressed (uint8_t currentState, uint8_t previousState); #define key_toggled_on(keyState) (key_is_pressed(keyState) && ! key_was_pressed(keyState))
boolean key_is_pressed (uint8_t currentState, uint8_t previousState); #define key_toggled_off(keyState) (key_was_pressed(keyState) && ! key_is_pressed(keyState))
boolean key_toggled_on(uint8_t currentState, uint8_t previousState);
boolean key_toggled_off(uint8_t currentState, uint8_t previousState);

Loading…
Cancel
Save