aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--common/action.c46
-rw-r--r--common/action.h47
-rw-r--r--common/keyboard.h1
-rw-r--r--common/keymap.c2
-rw-r--r--common/keymap.h8
-rw-r--r--keyboard/hhkb/keymap.c163
6 files changed, 167 insertions, 100 deletions
diff --git a/common/action.c b/common/action.c
index d1f493fe0..cb44e272a 100644
--- a/common/action.c
+++ b/common/action.c
@@ -110,7 +110,7 @@ static bool waiting_buffer_typed(keyevent_t event)
110} 110}
111#endif 111#endif
112 112
113static bool waiting_buffer_has_anykey_pressed(void) 113bool waiting_buffer_has_anykey_pressed(void)
114{ 114{
115 for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) { 115 for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) {
116 if (waiting_buffer[i].event.pressed) return true; 116 if (waiting_buffer[i].event.pressed) return true;
@@ -256,7 +256,7 @@ static void process_action(keyrecord_t *record)
256 debug("MODS_TAP: Oneshot: start\n"); 256 debug("MODS_TAP: Oneshot: start\n");
257 oneshot_start(mods, event.time); 257 oneshot_start(mods, event.time);
258 } 258 }
259 else if (tap_count == 5) { 259 else if (tap_count == TAPPING_TOGGLE) {
260 debug("MODS_TAP: Oneshot: toggle\n"); 260 debug("MODS_TAP: Oneshot: toggle\n");
261 oneshot_toggle(); 261 oneshot_toggle();
262 } 262 }
@@ -356,7 +356,7 @@ static void process_action(keyrecord_t *record)
356 switch (action.layer.code) { 356 switch (action.layer.code) {
357 case 0x00: 357 case 0x00:
358 if (event.pressed) { 358 if (event.pressed) {
359 layer_switch(action.layer.opt); 359 layer_switch(action.layer.val);
360 } 360 }
361//TODO: this is ok? 361//TODO: this is ok?
362 else { 362 else {
@@ -367,19 +367,19 @@ static void process_action(keyrecord_t *record)
367 // tap toggle 367 // tap toggle
368 if (event.pressed) { 368 if (event.pressed) {
369 if (tap_count < TAPPING_TOGGLE) { 369 if (tap_count < TAPPING_TOGGLE) {
370 layer_switch(action.layer.opt); 370 layer_switch(action.layer.val);
371 } 371 }
372 } else { 372 } else {
373 if (tap_count >= TAPPING_TOGGLE) { 373 if (tap_count >= TAPPING_TOGGLE) {
374 debug("LAYER_PRESSED: tap toggle.\n"); 374 debug("LAYER_PRESSED: tap toggle.\n");
375 layer_switch(action.layer.opt); 375 layer_switch(action.layer.val);
376 } 376 }
377 } 377 }
378 break; 378 break;
379 case 0xFF: 379 case 0xFF:
380 // change default layer 380 // change default layer
381 if (event.pressed) { 381 if (event.pressed) {
382 default_layer = action.layer.opt; 382 default_layer = action.layer.val;
383 layer_switch(default_layer); 383 layer_switch(default_layer);
384 } 384 }
385 break; 385 break;
@@ -391,7 +391,7 @@ static void process_action(keyrecord_t *record)
391 register_code(action.layer.code); 391 register_code(action.layer.code);
392 } else { 392 } else {
393 debug("LAYER_PRESSED: No tap: layer_switch\n"); 393 debug("LAYER_PRESSED: No tap: layer_switch\n");
394 layer_switch(action.layer.opt); 394 layer_switch(action.layer.val);
395 } 395 }
396 } else { 396 } else {
397 if (tap_count > 0) { 397 if (tap_count > 0) {
@@ -411,7 +411,7 @@ static void process_action(keyrecord_t *record)
411 switch (action.layer.code) { 411 switch (action.layer.code) {
412 case 0x00: 412 case 0x00:
413 if (!event.pressed) { 413 if (!event.pressed) {
414 layer_switch(action.layer.opt); 414 layer_switch(action.layer.val);
415 } 415 }
416 break; 416 break;
417 case 0xF0: 417 case 0xF0:
@@ -419,18 +419,18 @@ static void process_action(keyrecord_t *record)
419 if (event.pressed) { 419 if (event.pressed) {
420 if (tap_count >= TAPPING_TOGGLE) { 420 if (tap_count >= TAPPING_TOGGLE) {
421 debug("LAYER_RELEASED: tap toggle.\n"); 421 debug("LAYER_RELEASED: tap toggle.\n");
422 layer_switch(action.layer.opt); 422 layer_switch(action.layer.val);
423 } 423 }
424 } else { 424 } else {
425 if (tap_count < TAPPING_TOGGLE) { 425 if (tap_count < TAPPING_TOGGLE) {
426 layer_switch(action.layer.opt); 426 layer_switch(action.layer.val);
427 } 427 }
428 } 428 }
429 break; 429 break;
430 case 0xFF: 430 case 0xFF:
431 // change default layer 431 // change default layer
432 if (!event.pressed) { 432 if (!event.pressed) {
433 default_layer = action.layer.opt; 433 default_layer = action.layer.val;
434 layer_switch(default_layer); 434 layer_switch(default_layer);
435 } 435 }
436 break; 436 break;
@@ -449,7 +449,7 @@ static void process_action(keyrecord_t *record)
449 unregister_code(action.layer.code); 449 unregister_code(action.layer.code);
450 } else { 450 } else {
451 debug("LAYER_RELEASED: No tap: layer_switch\n"); 451 debug("LAYER_RELEASED: No tap: layer_switch\n");
452 layer_switch(action.layer.opt); 452 layer_switch(action.layer.val);
453 } 453 }
454 } 454 }
455 break; 455 break;
@@ -459,9 +459,9 @@ static void process_action(keyrecord_t *record)
459 switch (action.layer.code) { 459 switch (action.layer.code) {
460 case 0x00: 460 case 0x00:
461 if (event.pressed) { 461 if (event.pressed) {
462 layer_switch(current_layer ^ action.layer.opt); 462 layer_switch(current_layer ^ action.layer.val);
463 } else { 463 } else {
464 layer_switch(current_layer ^ action.layer.opt); 464 layer_switch(current_layer ^ action.layer.val);
465 } 465 }
466 break; 466 break;
467 case 0xF0: 467 case 0xF0:
@@ -469,22 +469,22 @@ static void process_action(keyrecord_t *record)
469 if (event.pressed) { 469 if (event.pressed) {
470 if (tap_count < TAPPING_TOGGLE) { 470 if (tap_count < TAPPING_TOGGLE) {
471 debug("LAYER_BIT: tap toggle(press).\n"); 471 debug("LAYER_BIT: tap toggle(press).\n");
472 layer_switch(current_layer ^ action.layer.opt); 472 layer_switch(current_layer ^ action.layer.val);
473 } 473 }
474 } else { 474 } else {
475 if (tap_count <= TAPPING_TOGGLE) { 475 if (tap_count <= TAPPING_TOGGLE) {
476 debug("LAYER_BIT: tap toggle(release).\n"); 476 debug("LAYER_BIT: tap toggle(release).\n");
477 layer_switch(current_layer ^ action.layer.opt); 477 layer_switch(current_layer ^ action.layer.val);
478 } 478 }
479 } 479 }
480 break; 480 break;
481 case 0xFF: 481 case 0xFF:
482 // change default layer 482 // change default layer
483 if (event.pressed) { 483 if (event.pressed) {
484 default_layer = current_layer ^ action.layer.opt; 484 default_layer = current_layer ^ action.layer.val;
485 layer_switch(default_layer); 485 layer_switch(default_layer);
486 } else { 486 } else {
487 default_layer = current_layer ^ action.layer.opt; 487 default_layer = current_layer ^ action.layer.val;
488 layer_switch(default_layer); 488 layer_switch(default_layer);
489 } 489 }
490 break; 490 break;
@@ -496,7 +496,7 @@ static void process_action(keyrecord_t *record)
496 register_code(action.layer.code); 496 register_code(action.layer.code);
497 } else { 497 } else {
498 debug("LAYER_BIT: No tap: layer_switch(bit on)\n"); 498 debug("LAYER_BIT: No tap: layer_switch(bit on)\n");
499 layer_switch(current_layer ^ action.layer.opt); 499 layer_switch(current_layer ^ action.layer.val);
500 } 500 }
501 } else { 501 } else {
502 if (IS_TAPPING_KEY(event.key) && tap_count > 0) { 502 if (IS_TAPPING_KEY(event.key) && tap_count > 0) {
@@ -504,14 +504,14 @@ static void process_action(keyrecord_t *record)
504 unregister_code(action.layer.code); 504 unregister_code(action.layer.code);
505 } else { 505 } else {
506 debug("LAYER_BIT: No tap: layer_switch(bit off)\n"); 506 debug("LAYER_BIT: No tap: layer_switch(bit off)\n");
507 layer_switch(current_layer ^ action.layer.opt); 507 layer_switch(current_layer ^ action.layer.val);
508 } 508 }
509 } 509 }
510 break; 510 break;
511 } 511 }
512 break; 512 break;
513 case ACT_LAYER_EXT: 513 case ACT_LAYER_EXT:
514 switch (action.layer.opt) { 514 switch (action.layer.val) {
515 case 0x00: 515 case 0x00:
516 // set default layer when pressed 516 // set default layer when pressed
517 switch (action.layer.code) { 517 switch (action.layer.code) {
@@ -620,7 +620,7 @@ static void process_action(keyrecord_t *record)
620 break; 620 break;
621 case ACT_FUNCTION: 621 case ACT_FUNCTION:
622 // TODO 622 // TODO
623 action_call_function(event, action.func.id); 623 keymap_call_function(record, action.func.id);
624 break; 624 break;
625 default: 625 default:
626 break; 626 break;
@@ -944,7 +944,7 @@ bool is_tap_key(key_t key)
944 } 944 }
945 return false; 945 return false;
946 case ACT_FUNCTION: 946 case ACT_FUNCTION:
947 if (action.func.opt & 0x1) { 947 if (action.func.opt & O_TAP) {
948 return true; 948 return true;
949 } 949 }
950 return false; 950 return false;
diff --git a/common/action.h b/common/action.h
index d6530df42..b657aa540 100644
--- a/common/action.h
+++ b/common/action.h
@@ -21,6 +21,16 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
21#include "keycode.h" 21#include "keycode.h"
22 22
23 23
24/* Execute action per keyevent */
25void action_exec(keyevent_t event);
26
27
28/* Struct to record event and tap count */
29typedef struct {
30 keyevent_t event;
31 uint8_t tap_count;
32} keyrecord_t;
33
24/* Action struct. 34/* Action struct.
25 * 35 *
26 * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15). 36 * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15).
@@ -48,7 +58,7 @@ typedef union {
48 } key; 58 } key;
49 struct action_layer { 59 struct action_layer {
50 uint16_t code :8; 60 uint16_t code :8;
51 uint16_t opt :4; 61 uint16_t val :4;
52 uint16_t kind :4; 62 uint16_t kind :4;
53 } layer; 63 } layer;
54 struct action_usage { 64 struct action_usage {
@@ -58,7 +68,7 @@ typedef union {
58 } usage; 68 } usage;
59 struct action_command { 69 struct action_command {
60 uint16_t id :8; 70 uint16_t id :8;
61 uint16_t option :4; 71 uint16_t opt :4;
62 uint16_t kind :4; 72 uint16_t kind :4;
63 } command; 73 } command;
64 struct action_function { 74 struct action_function {
@@ -68,18 +78,6 @@ typedef union {
68 } func; 78 } func;
69} action_t; 79} action_t;
70 80
71/* Struct to record action and tap count */
72typedef struct {
73 keyevent_t event;
74 uint8_t tap_count;
75} keyrecord_t;
76
77
78/* execute action per keyevent */
79void action_exec(keyevent_t event);
80typedef void (*action_func_t)(keyevent_t event, uint8_t opt); // TODO:no need?
81void action_call_function(keyevent_t event, uint8_t id); // TODO: action function
82
83 81
84/* 82/*
85 * Utilities for actions. 83 * Utilities for actions.
@@ -94,6 +92,7 @@ void clear_keyboard_but_mods(void);
94bool sending_anykey(void); 92bool sending_anykey(void);
95void layer_switch(uint8_t new_layer); 93void layer_switch(uint8_t new_layer);
96bool is_tap_key(key_t key); 94bool is_tap_key(key_t key);
95bool waiting_buffer_has_anykey_pressed(void);
97 96
98 97
99 98
@@ -203,9 +202,6 @@ ACT_FUNCTION(1111):
2031111| address(12) Function? 2021111| address(12) Function?
2041111|opt | id(8) Function? 2031111|opt | id(8) Function?
205 204
206TODO: modifier + function by tap?
207 for example: LShift + '('[Shift+9] and RShift + ')'[Shift+0]
208 http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478.html#p90052
209 */ 205 */
210enum action_kind_id { 206enum action_kind_id {
211 ACT_LMODS = 0b0000, 207 ACT_LMODS = 0b0000,
@@ -226,8 +222,12 @@ enum action_kind_id {
226 ACT_FUNCTION = 0b1111 222 ACT_FUNCTION = 0b1111
227}; 223};
228 224
229enum acion_param { 225enum params {
230 ONE_SHOT = 0x00, 226 P_ONESHOT = 0x00,
227};
228
229enum options {
230 O_TAP = 0x8,
231}; 231};
232 232
233 233
@@ -251,14 +251,14 @@ enum acion_param {
251 251
252/* Mods + Tap key */ 252/* Mods + Tap key */
253#define ACTION_LMODS_TAP_KEY(mods, key) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | (key)) 253#define ACTION_LMODS_TAP_KEY(mods, key) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | (key))
254#define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | ONE_SHOT) 254#define ACTION_LMODS_ONESHOT(mods) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | P_ONESHOT)
255#define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key)) 255#define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key))
256#define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | ONE_SHOT) 256#define ACTION_RMODS_ONESHOT(mods) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | P_ONESHOT)
257/* Mod + Tap key */ 257/* Mod + Tap key */
258#define ACTION_LMOD_TAP_KEY(mod, key) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) 258#define ACTION_LMOD_TAP_KEY(mod, key) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key))
259#define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | ONE_SHOT) 259#define ACTION_LMOD_ONESHOT(mod) ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | P_ONESHOT)
260#define ACTION_RMOD_TAP_KEY(mod, key) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key)) 260#define ACTION_RMOD_TAP_KEY(mod, key) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key))
261#define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | ONE_SHOT) 261#define ACTION_RMOD_ONESHOT(mod) ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | P_ONESHOT)
262 262
263// TODO: contemplate about layer action 263// TODO: contemplate about layer action
264/* Switch current layer */ 264/* Switch current layer */
@@ -304,5 +304,6 @@ enum acion_param {
304 304
305/* Function */ 305/* Function */
306#define ACTION_FUNCTION(id, opt) ACTION(ACT_FUNCTION, (opt)<<8 | id) 306#define ACTION_FUNCTION(id, opt) ACTION(ACT_FUNCTION, (opt)<<8 | id)
307#define ACTION_FUNCTION_TAP(id) ACTION(ACT_FUNCTION, O_TAP<<8 | id)
307 308
308#endif /* ACTION_H */ 309#endif /* ACTION_H */
diff --git a/common/keyboard.h b/common/keyboard.h
index 32c1bf464..e1cab3119 100644
--- a/common/keyboard.h
+++ b/common/keyboard.h
@@ -32,6 +32,7 @@ typedef struct {
32 uint8_t row; 32 uint8_t row;
33} keypos_t; 33} keypos_t;
34 34
35// TODO: need raw? keypos_t -> key_t?
35typedef union { 36typedef union {
36 uint16_t raw; 37 uint16_t raw;
37 keypos_t pos; 38 keypos_t pos;
diff --git a/common/keymap.c b/common/keymap.c
index 415121308..40d20f684 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)
68#endif 68#endif
69 69
70__attribute__ ((weak)) 70__attribute__ ((weak))
71void action_call_function(keyevent_t event, uint8_t id) 71void keymap_call_function(keyrecord_t *event, uint8_t id)
72{ 72{
73} 73}
diff --git a/common/keymap.h b/common/keymap.h
index 748761551..e0fafeaf2 100644
--- a/common/keymap.h
+++ b/common/keymap.h
@@ -29,11 +29,13 @@ extern uint8_t current_layer;
29extern uint8_t default_layer; 29extern uint8_t default_layer;
30 30
31 31
32/* 32/* action for key */
33 * new keymap interface: action 33// TODO: should use struct key_t?
34 */
35action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col); 34action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col);
36 35
36/* user defined special function */
37void keymap_call_function(keyrecord_t *record, uint8_t id);
38
37 39
38#ifndef NO_LEGACY_KEYMAP_SUPPORT 40#ifndef NO_LEGACY_KEYMAP_SUPPORT
39/* keycode of key */ 41/* keycode of key */
diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c
index c7e4cfc38..e11b4563a 100644
--- a/keyboard/hhkb/keymap.c
+++ b/keyboard/hhkb/keymap.c
@@ -51,23 +51,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
51} 51}
52 52
53 53
54static const uint16_t PROGMEM fn_actions[] = {
55 ACTION_LAYER_TO_DEFAULT_ON_RELEASED, // Fn0
56 ACTION_LAYER_SET_ON_PRESSED(1), // Fn1
57 ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // Fn2
58 ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // Fn3
59 //ACTION_LAYER_SET_ON_PRESSED(3), // Fn4
60 ACTION_FUNCTION(0x01, 0xA), // Fn4
61 ACTION_LAYER_SET_TAP_KEY(5, KC_SPC), // Fn5
62 ACTION_LMODS_TAP(MOD_BIT(KC_LCTL), KC_BSPC), // Fn6
63 ACTION_RMODS_TAP(MOD_BIT(KC_RCTL), KC_ENT), // Fn7
64
65 ACTION_LMODS_TAP(MOD_BIT(KC_LSFT), ONE_SHOT), // Fn8
66 ACTION_LAYER_SET_ON_RELEASED_TAP_TOGGLE(1), // Fn9
67 ACTION_LAYER_BIT_TAP_TOGGLE(1), // Fn10
68};
69
70
71static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 54static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
72 /* Layer 0: Default Layer 55 /* Layer 0: Default Layer
73 * ,-----------------------------------------------------------. 56 * ,-----------------------------------------------------------.
@@ -85,7 +68,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
85 KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSLS,GRV, \ 68 KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSLS,GRV, \
86 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \ 69 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \
87 FN6, A, S, D, F, G, H, J, K, L, FN3, QUOT,FN7, \ 70 FN6, A, S, D, F, G, H, J, K, L, FN3, QUOT,FN7, \
88 FN8, Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN10, \ 71 FN8, Z, X, C, V, B, N, M, COMM,DOT, FN2, FN12,FN10, \
89 LGUI,LALT, FN5, RALT,FN4), 72 LGUI,LALT, FN5, RALT,FN4),
90 73
91 /* Layer 1: HHKB mode (HHKB Fn) 74 /* Layer 1: HHKB mode (HHKB Fn)
@@ -173,24 +156,127 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
173 LGUI,LALT, FN0, RALT,RGUI), 156 LGUI,LALT, FN0, RALT,RGUI),
174}; 157};
175 158
176#define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))
177 159
178 160
179/* legacy interface */ 161/* id for user defined functions */
180uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col) { return 0; } 162enum function_id {
181uint8_t keymap_fn_layer(uint8_t fn_bits) { return 0; } 163 LSHIFT_LPAREN,
182uint8_t keymap_fn_keycode(uint8_t fn_bits) { return 0; } 164 RSHIFT_RPAREN,
165};
166
167/*
168 * Fn action definition
169 */
170static const uint16_t PROGMEM fn_actions[] = {
171 ACTION_LAYER_RETURN_DEFAULT, // FN0
172 ACTION_LAYER_SET(1), // FN1
173 ACTION_LAYER_SET_TAP_KEY(2, KC_SLASH), // FN2
174 ACTION_LAYER_SET_TAP_KEY(3, KC_SCLN), // FN3
175 ACTION_LAYER_SET(3), // FN4
176 ACTION_LAYER_SET_TAP_KEY(5, KC_SPC), // FN5
177 ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // FN6
178 ACTION_RMOD_TAP_KEY(KC_RCTL, KC_ENT), // FN7
179 ACTION_LMOD_ONESHOT(KC_LSFT), // FN8 Oneshot Shift
180 ACTION_LAYER_SET_ON_RELEASED_TAP_TOGGLE(1), // FN9
181 ACTION_LAYER_BIT_TAP_KEY(1, KC_GRV), // FN10
182 //ACTION_LAYER_BIT(1), // FN10
183 //ACTION_LAYER_BIT_TAP_TOGGLE(1), // FN10
184 ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // FN11
185 ACTION_FUNCTION_TAP(RSHIFT_RPAREN), // FN12
186};
187
188/*
189 * user defined action function
190 */
191void keymap_call_function(keyrecord_t *record, uint8_t id)
192{
193 keyevent_t event = record->event;
194 uint8_t tap_count = record->tap_count;
195
196 debug("action_call_function: ");
197 if (event.pressed) debug("pressed"); else debug("released");
198 debug(" id: "); debug_hex(id);
199 debug(" tap_count: "); debug_dec(tap_count);
200 debug("\n");
183 201
202 switch (id) {
203 case LSHIFT_LPAREN:
204 // LShft + tap '('
205 if (event.pressed) {
206 if (tap_count == 0) {
207 add_mods(MOD_BIT(KC_LSHIFT));
208 } else {
209 if (waiting_buffer_has_anykey_pressed()) {
210 // ad hoc: set 0 to cancel tap
211 record->tap_count = 0;
212 add_mods(MOD_BIT(KC_LSHIFT));
213 } else {
214 // NOTE to avoid conflicting command key bind(LShift+RShift)
215 //register_code(KC_LSHIFT);
216 //register_code(KC_9);
217 host_add_mods(MOD_BIT(KC_LSHIFT));
218 host_add_key(KC_9);
219 host_send_keyboard_report();
220 }
221 }
222 } else {
223 if (tap_count == 0) {
224 del_mods(MOD_BIT(KC_LSHIFT));
225 } else {
226 //unregister_code(KC_9);
227 //unregister_code(KC_LSHIFT);
228 host_del_mods(MOD_BIT(KC_LSHIFT));
229 host_del_key(KC_9);
230 host_send_keyboard_report();
231 }
232 }
233 break;
234 case RSHIFT_RPAREN:
235 // RShift + tap ')'
236 if (event.pressed) {
237 if (tap_count == 0) {
238 add_mods(MOD_BIT(KC_RSHIFT));
239 } else {
240 if (waiting_buffer_has_anykey_pressed()) {
241 // ad hoc: set 0 to cancel tap
242 record->tap_count = 0;
243 add_mods(MOD_BIT(KC_RSHIFT));
244 } else {
245 //register_code(KC_RSHIFT);
246 //register_code(KC_0);
247 host_add_mods(MOD_BIT(KC_RSHIFT));
248 host_add_key(KC_0);
249 host_send_keyboard_report();
250 }
251 }
252 } else {
253 if (tap_count == 0) {
254 del_mods(MOD_BIT(KC_RSHIFT));
255 } else {
256 //unregister_code(KC_0);
257 //unregister_code(KC_RSHIFT);
258 host_del_mods(MOD_BIT(KC_RSHIFT));
259 host_del_key(KC_0);
260 host_send_keyboard_report();
261 }
262 }
263 break;
264 }
265}
184 266
267/* convert keycode to action */
185action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) { 268action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) {
186 /* convert from legacy keycode to action */ 269 uint8_t key = (pgm_read_byte(&keymaps[(layer)][(row)][(col)]));
187 uint8_t key = KEYCODE(layer, row, col);
188 action_t action; 270 action_t action;
189 switch (key) { 271 switch (key) {
190 case KC_A ... KC_EXSEL: 272 case KC_A ... KC_EXSEL:
273 action.code = ACTION_KEY(key);
274 break;
191 case KC_LCTRL ... KC_LGUI: 275 case KC_LCTRL ... KC_LGUI:
276 action.code = ACTION_LMOD(key);
277 break;
192 case KC_RCTRL ... KC_RGUI: 278 case KC_RCTRL ... KC_RGUI:
193 action.code = ACTION_KEY(key); 279 action.code = ACTION_RMOD(key);
194 break; 280 break;
195 case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE: 281 case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE:
196 action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(key)); 282 action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(key));
@@ -201,15 +287,7 @@ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) {
201 case KC_MS_UP ... KC_MS_ACCEL2: 287 case KC_MS_UP ... KC_MS_ACCEL2:
202 action.code = ACTION_MOUSEKEY(key); 288 action.code = ACTION_MOUSEKEY(key);
203 break; 289 break;
204/* TODO 290 case KC_FN0 ... KC_FN31:
205 case KC_LCTRL ... KC_LGUI:
206 action.code = ACTION_LMODS(MOD_BIT(key));
207 break;
208 case KC_RCTRL ... KC_RGUI:
209 action.code = ACTION_RMODS(MOD_BIT(key)>>4);
210 break;
211*/
212 case KC_FN0 ... FN_MAX:
213 if (FN_INDEX(key) < sizeof(fn_actions) / sizeof(fn_actions[0])) { 291 if (FN_INDEX(key) < sizeof(fn_actions) / sizeof(fn_actions[0])) {
214 action.code = pgm_read_word(&fn_actions[FN_INDEX(key)]); 292 action.code = pgm_read_word(&fn_actions[FN_INDEX(key)]);
215 } else { 293 } else {
@@ -223,18 +301,3 @@ action_t keymap_get_action(uint8_t layer, uint8_t row, uint8_t col) {
223 } 301 }
224 return action; 302 return action;
225} 303}
226
227// TODO: how to define action function
228void action_call_function(keyevent_t event, uint8_t id)
229{
230 // '(' Shift+9
231 if (event.pressed) {
232 register_code(KC_LSHIFT);
233 register_code(KC_9);
234 debug("action_call_function: pressed: id: "); debug_hex(id); debug("\n");
235 } else {
236 unregister_code(KC_9);
237 unregister_code(KC_LSHIFT);
238 debug("action_call_function: released: id: "); debug_hex(id); debug("\n");
239 }
240}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-19 07:53:23 +0000