From 1d7962ba8a20323dc13cc913381608e117afaeb4 Mon Sep 17 00:00:00 2001 From: tmk Date: Fri, 1 Feb 2013 14:48:11 +0900 Subject: [PATCH] Add user defined function to action. --- common/action.c | 46 ++++++------ common/action.h | 47 ++++++------ common/keyboard.h | 1 + common/keymap.c | 2 +- common/keymap.h | 8 +- keyboard/hhkb/keymap.c | 165 ++++++++++++++++++++++++++++------------- 6 files changed, 168 insertions(+), 101 deletions(-) diff --git a/common/action.c b/common/action.c index d1f493fe..cb44e272 100644 --- a/common/action.c +++ b/common/action.c @@ -110,7 +110,7 @@ static bool waiting_buffer_typed(keyevent_t event) } #endif -static bool waiting_buffer_has_anykey_pressed(void) +bool waiting_buffer_has_anykey_pressed(void) { for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) { if (waiting_buffer[i].event.pressed) return true; @@ -256,7 +256,7 @@ static void process_action(keyrecord_t *record) debug("MODS_TAP: Oneshot: start\n"); oneshot_start(mods, event.time); } - else if (tap_count == 5) { + else if (tap_count == TAPPING_TOGGLE) { debug("MODS_TAP: Oneshot: toggle\n"); oneshot_toggle(); } @@ -356,7 +356,7 @@ static void process_action(keyrecord_t *record) switch (action.layer.code) { case 0x00: if (event.pressed) { - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } //TODO: this is ok? else { @@ -367,19 +367,19 @@ static void process_action(keyrecord_t *record) // tap toggle if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } } else { if (tap_count >= TAPPING_TOGGLE) { debug("LAYER_PRESSED: tap toggle.\n"); - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } } break; case 0xFF: // change default layer if (event.pressed) { - default_layer = action.layer.opt; + default_layer = action.layer.val; layer_switch(default_layer); } break; @@ -391,7 +391,7 @@ static void process_action(keyrecord_t *record) register_code(action.layer.code); } else { debug("LAYER_PRESSED: No tap: layer_switch\n"); - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } } else { if (tap_count > 0) { @@ -411,7 +411,7 @@ static void process_action(keyrecord_t *record) switch (action.layer.code) { case 0x00: if (!event.pressed) { - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } break; case 0xF0: @@ -419,18 +419,18 @@ static void process_action(keyrecord_t *record) if (event.pressed) { if (tap_count >= TAPPING_TOGGLE) { debug("LAYER_RELEASED: tap toggle.\n"); - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } } else { if (tap_count < TAPPING_TOGGLE) { - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } } break; case 0xFF: // change default layer if (!event.pressed) { - default_layer = action.layer.opt; + default_layer = action.layer.val; layer_switch(default_layer); } break; @@ -449,7 +449,7 @@ static void process_action(keyrecord_t *record) unregister_code(action.layer.code); } else { debug("LAYER_RELEASED: No tap: layer_switch\n"); - layer_switch(action.layer.opt); + layer_switch(action.layer.val); } } break; @@ -459,9 +459,9 @@ static void process_action(keyrecord_t *record) switch (action.layer.code) { case 0x00: if (event.pressed) { - layer_switch(current_layer ^ action.layer.opt); + layer_switch(current_layer ^ action.layer.val); } else { - layer_switch(current_layer ^ action.layer.opt); + layer_switch(current_layer ^ action.layer.val); } break; case 0xF0: @@ -469,22 +469,22 @@ static void process_action(keyrecord_t *record) if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { debug("LAYER_BIT: tap toggle(press).\n"); - layer_switch(current_layer ^ action.layer.opt); + layer_switch(current_layer ^ action.layer.val); } } else { if (tap_count <= TAPPING_TOGGLE) { debug("LAYER_BIT: tap toggle(release).\n"); - layer_switch(current_layer ^ action.layer.opt); + layer_switch(current_layer ^ action.layer.val); } } break; case 0xFF: // change default layer if (event.pressed) { - default_layer = current_layer ^ action.layer.opt; + default_layer = current_layer ^ action.layer.val; layer_switch(default_layer); } else { - default_layer = current_layer ^ action.layer.opt; + default_layer = current_layer ^ action.layer.val; layer_switch(default_layer); } break; @@ -496,7 +496,7 @@ static void process_action(keyrecord_t *record) register_code(action.layer.code); } else { debug("LAYER_BIT: No tap: layer_switch(bit on)\n"); - layer_switch(current_layer ^ action.layer.opt); + layer_switch(current_layer ^ action.layer.val); } } else { if (IS_TAPPING_KEY(event.key) && tap_count > 0) { @@ -504,14 +504,14 @@ static void process_action(keyrecord_t *record) unregister_code(action.layer.code); } else { debug("LAYER_BIT: No tap: layer_switch(bit off)\n"); - layer_switch(current_layer ^ action.layer.opt); + layer_switch(current_layer ^ action.layer.val); } } break; } break; case ACT_LAYER_EXT: - switch (action.layer.opt) { + switch (action.layer.val) { case 0x00: // set default layer when pressed switch (action.layer.code) { @@ -620,7 +620,7 @@ static void process_action(keyrecord_t *record) break; case ACT_FUNCTION: // TODO - action_call_function(event, action.func.id); + keymap_call_function(record, action.func.id); break; default: break; @@ -944,7 +944,7 @@ bool is_tap_key(key_t key) } return false; case ACT_FUNCTION: - if (action.func.opt & 0x1) { + if (action.func.opt & O_TAP) { return true; } return false; diff --git a/common/action.h b/common/action.h index d6530df4..b657aa54 100644 --- a/common/action.h +++ b/common/action.h @@ -21,6 +21,16 @@ along with this program. If not, see . #include "keycode.h" +/* Execute action per keyevent */ +void action_exec(keyevent_t event); + + +/* Struct to record event and tap count */ +typedef struct { + keyevent_t event; + uint8_t tap_count; +} keyrecord_t; + /* Action struct. * * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15). @@ -48,7 +58,7 @@ typedef union { } key; struct action_layer { uint16_t code :8; - uint16_t opt :4; + uint16_t val :4; uint16_t kind :4; } layer; struct action_usage { @@ -58,7 +68,7 @@ typedef union { } usage; struct action_command { uint16_t id :8; - uint16_t option :4; + uint16_t opt :4; uint16_t kind :4; } command; struct action_function { @@ -68,18 +78,6 @@ typedef union { } func; } action_t; -/* Struct to record action and tap count */ -typedef struct { - keyevent_t event; - uint8_t tap_count; -} keyrecord_t; - - -/* execute action per keyevent */ -void action_exec(keyevent_t event); -typedef void (*action_func_t)(keyevent_t event, uint8_t opt); // TODO:no need? -void action_call_function(keyevent_t event, uint8_t id); // TODO: action function - /* * Utilities for actions. @@ -94,6 +92,7 @@ void clear_keyboard_but_mods(void); bool sending_anykey(void); void layer_switch(uint8_t new_layer); bool is_tap_key(key_t key); +bool waiting_buffer_has_anykey_pressed(void); @@ -203,9 +202,6 @@ ACT_FUNCTION(1111): 1111| address(12) Function? 1111|opt | id(8) Function? -TODO: modifier + function by tap? - for example: LShift + '('[Shift+9] and RShift + ')'[Shift+0] - http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478.html#p90052 */ enum action_kind_id { ACT_LMODS = 0b0000, @@ -226,8 +222,12 @@ enum action_kind_id { ACT_FUNCTION = 0b1111 }; -enum acion_param { - ONE_SHOT = 0x00, +enum params { + P_ONESHOT = 0x00, +}; + +enum options { + O_TAP = 0x8, }; @@ -251,14 +251,14 @@ enum acion_param { /* Mods + Tap key */ #define ACTION_LMODS_TAP_KEY(mods, key) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | (key)) -#define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | ONE_SHOT) +#define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | P_ONESHOT) #define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key)) -#define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | ONE_SHOT) +#define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | P_ONESHOT) /* Mod + Tap key */ #define ACTION_LMOD_TAP_KEY(mod, key) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) -#define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | ONE_SHOT) +#define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | P_ONESHOT) #define ACTION_RMOD_TAP_KEY(mod, key) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) -#define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | ONE_SHOT) +#define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | P_ONESHOT) // TODO: contemplate about layer action /* Switch current layer */ @@ -304,5 +304,6 @@ enum acion_param { /* Function */ #define ACTION_FUNCTION(id, opt) ACTION(ACT_FUNCTION, (opt)<<8 | id) +#define ACTION_FUNCTION_TAP(id) ACTION(ACT_FUNCTION, O_TAP<<8 | id) #endif /* ACTION_H */ diff --git a/common/keyboard.h b/common/keyboard.h index 32c1bf46..e1cab311 100644 --- a/common/keyboard.h +++ b/common/keyboard.h @@ -32,6 +32,7 @@ typedef struct { uint8_t row; } keypos_t; +// TODO: need raw? keypos_t -> key_t? typedef union { uint16_t raw; keypos_t pos; diff --git a/common/keymap.c b/common/keymap.c index 41512130..40d20f68 100644 --- a/common/keymap.c +++ b/common/keymap.c @@ -68,6 +68,6 @@ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) #endif __attribute__ ((weak)) -void action_call_function(keyevent_t event, uint8_t id) +void keymap_call_function(keyrecord_t *event, uint8_t id) { } diff --git a/common/keymap.h b/common/keymap.h index 74876155..e0fafeaf 100644 --- a/common/keymap.h +++ b/common/keymap.h @@ -29,11 +29,13 @@ extern uint8_t current_layer; extern uint8_t default_layer; -/* - * new keymap interface: action - */ +/* action for key */ +// TODO: should use struct key_t? action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col); +/* user defined special function */ +void keymap_call_function(keyrecord_t *record, uint8_t id); + #ifndef NO_LEGACY_KEYMAP_SUPPORT /* keycode of key */ diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c index c7e4cfc3..e11b4563 100644 --- a/keyboard/hhkb/keymap.c +++ b/keyboard/hhkb/keymap.c @@ -51,23 +51,6 @@ along with this program. If not, see . } -static const uint16_t PROGMEM fn_actions[] = { - ACTION_LAYER_TO_DEFAULT_ON_RELEASED, // Fn0 - ACTION_LAYER_SET_ON_PRESSED(1), // Fn1 - ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // Fn2 - ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // Fn3 - //ACTION_LAYER_SET_ON_PRESSED(3), // Fn4 - ACTION_FUNCTION(0x01, 0xA), // Fn4 - ACTION_LAYER_SET_TAP_KEY(5, KC_SPC), // Fn5 - ACTION_LMODS_TAP(MOD_BIT(KC_LCTL), KC_BSPC), // Fn6 - ACTION_RMODS_TAP(MOD_BIT(KC_RCTL), KC_ENT), // Fn7 - - ACTION_LMODS_TAP(MOD_BIT(KC_LSFT), ONE_SHOT), // Fn8 - ACTION_LAYER_SET_ON_RELEASED_TAP_TOGGLE(1), // Fn9 - ACTION_LAYER_BIT_TAP_TOGGLE(1), // Fn10 -}; - - static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { /* Layer 0: Default Layer * ,-----------------------------------------------------------. @@ -85,7 +68,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSLS,GRV, \ TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \ FN6, A, S, D, F, G, H, J, K, L, FN3, QUOT,FN7, \ - FN8, Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN10, \ + FN8, Z, X, C, V, B, N, M, COMM,DOT, FN2, FN12,FN10, \ LGUI,LALT, FN5, RALT,FN4), /* Layer 1: HHKB mode (HHKB Fn) @@ -173,25 +156,128 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { LGUI,LALT, FN0, RALT,RGUI), }; -#define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) -/* legacy interface */ -uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col) { return 0; } -uint8_t keymap_fn_layer(uint8_t fn_bits) { return 0; } -uint8_t keymap_fn_keycode(uint8_t fn_bits) { return 0; } +/* id for user defined functions */ +enum function_id { + LSHIFT_LPAREN, + RSHIFT_RPAREN, +}; +/* + * Fn action definition + */ +static const uint16_t PROGMEM fn_actions[] = { + ACTION_LAYER_RETURN_DEFAULT, // FN0 + ACTION_LAYER_SET(1), // FN1 + ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // FN2 + ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // FN3 + ACTION_LAYER_SET(3), // FN4 + ACTION_LAYER_SET_TAP_KEY(5, KC_SPC), // FN5 + ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // FN6 + ACTION_RMOD_TAP_KEY(KC_RCTL, KC_ENT), // FN7 + ACTION_LMOD_ONESHOT(KC_LSFT), // FN8 Oneshot Shift + ACTION_LAYER_SET_ON_RELEASED_TAP_TOGGLE(1), // FN9 + ACTION_LAYER_BIT_TAP_KEY(1, KC_GRV), // FN10 + //ACTION_LAYER_BIT(1), // FN10 + //ACTION_LAYER_BIT_TAP_TOGGLE(1), // FN10 + ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // FN11 + ACTION_FUNCTION_TAP(RSHIFT_RPAREN), // FN12 +}; +/* + * user defined action function + */ +void keymap_call_function(keyrecord_t *record, uint8_t id) +{ + keyevent_t event = record->event; + uint8_t tap_count = record->tap_count; + + debug("action_call_function: "); + if (event.pressed) debug("pressed"); else debug("released"); + debug(" id: "); debug_hex(id); + debug(" tap_count: "); debug_dec(tap_count); + debug("\n"); + + switch (id) { + case LSHIFT_LPAREN: + // LShft + tap '(' + if (event.pressed) { + if (tap_count == 0) { + add_mods(MOD_BIT(KC_LSHIFT)); + } else { + if (waiting_buffer_has_anykey_pressed()) { + // ad hoc: set 0 to cancel tap + record->tap_count = 0; + add_mods(MOD_BIT(KC_LSHIFT)); + } else { + // NOTE to avoid conflicting command key bind(LShift+RShift) + //register_code(KC_LSHIFT); + //register_code(KC_9); + host_add_mods(MOD_BIT(KC_LSHIFT)); + host_add_key(KC_9); + host_send_keyboard_report(); + } + } + } else { + if (tap_count == 0) { + del_mods(MOD_BIT(KC_LSHIFT)); + } else { + //unregister_code(KC_9); + //unregister_code(KC_LSHIFT); + host_del_mods(MOD_BIT(KC_LSHIFT)); + host_del_key(KC_9); + host_send_keyboard_report(); + } + } + break; + case RSHIFT_RPAREN: + // RShift + tap ')' + if (event.pressed) { + if (tap_count == 0) { + add_mods(MOD_BIT(KC_RSHIFT)); + } else { + if (waiting_buffer_has_anykey_pressed()) { + // ad hoc: set 0 to cancel tap + record->tap_count = 0; + add_mods(MOD_BIT(KC_RSHIFT)); + } else { + //register_code(KC_RSHIFT); + //register_code(KC_0); + host_add_mods(MOD_BIT(KC_RSHIFT)); + host_add_key(KC_0); + host_send_keyboard_report(); + } + } + } else { + if (tap_count == 0) { + del_mods(MOD_BIT(KC_RSHIFT)); + } else { + //unregister_code(KC_0); + //unregister_code(KC_RSHIFT); + host_del_mods(MOD_BIT(KC_RSHIFT)); + host_del_key(KC_0); + host_send_keyboard_report(); + } + } + break; + } +} + +/* convert keycode to action */ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) { - /* convert from legacy keycode to action */ - uint8_t key = KEYCODE(layer, row, col); + uint8_t key = (pgm_read_byte(&keymaps[(layer)][(row)][(col)])); action_t action; switch (key) { case KC_A ... KC_EXSEL: - case KC_LCTRL ... KC_LGUI: - case KC_RCTRL ... KC_RGUI: action.code = ACTION_KEY(key); break; + case KC_LCTRL ... KC_LGUI: + action.code = ACTION_LMOD(key); + break; + case KC_RCTRL ... KC_RGUI: + action.code = ACTION_RMOD(key); + break; case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE: action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(key)); break; @@ -201,15 +287,7 @@ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) { case KC_MS_UP ... KC_MS_ACCEL2: action.code = ACTION_MOUSEKEY(key); break; -/* TODO - case KC_LCTRL ... KC_LGUI: - action.code = ACTION_LMODS(MOD_BIT(key)); - break; - case KC_RCTRL ... KC_RGUI: - action.code = ACTION_RMODS(MOD_BIT(key)>>4); - break; -*/ - case KC_FN0 ... FN_MAX: + case KC_FN0 ... KC_FN31: if (FN_INDEX(key) < sizeof(fn_actions) / sizeof(fn_actions[0])) { action.code = pgm_read_word(&fn_actions[FN_INDEX(key)]); } else { @@ -223,18 +301,3 @@ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) { } return action; } - -// TODO: how to define action function -void action_call_function(keyevent_t event, uint8_t id) -{ - // '(' Shift+9 - if (event.pressed) { - register_code(KC_LSHIFT); - register_code(KC_9); - debug("action_call_function: pressed: id: "); debug_hex(id); debug("\n"); - } else { - unregister_code(KC_9); - unregister_code(KC_LSHIFT); - debug("action_call_function: released: id: "); debug_hex(id); debug("\n"); - } -}