keyboards/planck/keymaps/hieax/common/keycode_functions.h

   1
   2 // .......................................................... Keycode Primitives
   3
   4 // register simple key press
   5 void tap_key(uint16_t keycode)
   6 {
   7   register_code  (keycode);
   8   unregister_code(keycode);
   9 }
  10
  11 void shift_key(uint16_t keycode)
  12 {
  13   register_code  (KC_LSFT);
  14   tap_key        (keycode);
  15   unregister_code(KC_LSFT);
  16 }
  17
  18 #define SHIFT   1
  19 #define NOSHIFT 0
  20
  21 static uint16_t key_timer = 0;
  22
  23 // key press for thumb_layer() and lt_shift() macros
  24 bool key_press(uint8_t shift, uint16_t keycode)
  25 {
  26   if (keycode) {
  27     if (timer_elapsed(key_timer) < TAPPING_TERM) {
  28       if (shift) {
  29         shift_key(keycode);
  30       }
  31       else {
  32         tap_key(keycode);
  33       }
  34       return true;
  35     }
  36   }
  37   return false;
  38 }
  39
  40 // ALT_T, CTL_T, GUI_T, SFT_T for shifted keycodes
  41 void mt_shift(keyrecord_t *record, uint16_t modifier, uint16_t modifier2, uint16_t keycode)
  42 {
  43   if (record->event.pressed) {
  44     key_timer = timer_read();
  45     register_code(modifier);
  46     if (modifier2) {
  47       register_code(modifier2);
  48     }
  49   }
  50   else {
  51     unregister_code(modifier);
  52     if (modifier2) {
  53       unregister_code(modifier2);
  54     }
  55     if (timer_elapsed(key_timer) < TAPPING_TERM) {
  56       shift_key(keycode);
  57     }
  58     key_timer = 0;
  59   }
  60 }
  61
  62 // ................................................................... Mod Masks
  63
  64 // tap dance persistant mods, see process_record_user()
  65 // keyboard_report->mods (?) appears to be cleared by tap dance
  66 static uint8_t mods = 0;
  67
  68 void tap_mods(keyrecord_t *record, uint16_t keycode)
  69 {
  70   if (record->event.pressed) {
  71     mods |= MOD_BIT(keycode);
  72   }
  73   else {
  74     mods &= ~(MOD_BIT(keycode));
  75   }
  76 }
  77
  78 // (un)register modifiers
  79 void modifier(void (*f)(uint8_t))
  80 {
  81   if (mods & MOD_BIT(KC_LCTL)) {
  82     (*f)(KC_LCTL);
  83   }
  84   if (mods & MOD_BIT(KC_LGUI)) {
  85     (*f)(KC_LGUI);
  86   }
  87   if (mods & MOD_BIT(KC_LALT)) {
  88     (*f)(KC_LALT);
  89   }
  90   if (mods & MOD_BIT(KC_LSFT)) {
  91     (*f)(KC_LSFT);
  92   }
  93   if (mods & MOD_BIT(KC_RSFT)) {
  94     (*f)(KC_RSFT);
  95   }
  96 }
  97
  98 // .................................................... Triple Dance Shift/Layer
  99
 100 static uint8_t dt_shift = 0;
 101
 102 void double_shift(uint16_t keycode, uint8_t layer)
 103 {
 104   tap_key (keycode);
 105   if (DT_SHIFT) {
 106     // set_oneshot_mods(MOD_LSFT);
 107     // layer_on(layer);
 108     layer_on         (_SHIFT);
 109     set_oneshot_layer(_SHIFT, ONESHOT_START);
 110     dt_shift = 1;
 111   }
 112   else {
 113     layer_on(layer);
 114   }
 115 }
 116
 117 // tap dance LT (LAYER, KEY) emulation with <KEY><DOWN> -> <KEY><SHIFT> and auto-repeat extensions!
 118 void tap_shift(qk_tap_dance_state_t *state, uint16_t keycode, uint8_t layer)
 119 {
 120   // double tap plus down
 121   if (state->count > 2) {
 122     // double enter shift
 123     if (keycode == KC_ENT) {
 124       tap_key     (keycode);
 125       double_shift(keycode, layer);
 126     }
 127     // repeating keycode
 128     else {
 129       register_code(keycode);
 130     }
 131   }
 132   // tap plus down (or double tap): keycode (one shot) shift
 133   else if (state->count > 1) {
 134     double_shift(keycode, layer);
 135   }
 136   // down: shift
 137   else if (state->pressed) {
 138     layer_on(layer);
 139   }
 140   // tap: keycode
 141   else {
 142     modifier(register_code);
 143     tap_key (keycode);
 144     modifier(unregister_code);
 145   }
 146 }
 147
 148 void tap_reset(uint16_t keycode, uint8_t layer)
 149 {
 150   unregister_code(keycode);
 151   if (DT_SHIFT && dt_shift) {
 152     clear_oneshot_layer_state(ONESHOT_PRESSED);
 153     dt_shift = 0;
 154   }
 155   else {
 156     layer_off(layer);
 157   }
 158 }
 159
 160 // augment pseudo LT (_RSHIFT, KC_ENT) handling below for rapid <ENTER><SHIFT> sequences
 161 void enter(qk_tap_dance_state_t *state, void *user_data)
 162 {
 163   tap_shift(state, KC_ENT, _RSHIFT);
 164 }
 165
 166 void enter_reset(qk_tap_dance_state_t *state, void *user_data)
 167 {
 168   tap_reset(KC_ENT, _RSHIFT);
 169 }
 170
 171 // augment pseudo LT (_LSHIFT, KC_SPC) handling below for rapid <SPACE><SHIFT> sequences
 172 void space(qk_tap_dance_state_t *state, void *user_data)
 173 {
 174   tap_shift(state, KC_SPC, _LSHIFT);
 175 }
 176
 177 void space_reset(qk_tap_dance_state_t *state, void *user_data)
 178 {
 179   tap_reset(KC_SPC, _LSHIFT);
 180 }
 181
 182 // ......................................................... Triple Dance Insert
 183
 184 void double_max(uint8_t count, uint8_t shift, uint16_t keycode)
 185 {
 186   if (shift) {
 187     shift_key(keycode);
 188     if (count > 1) {
 189       shift_key(keycode);
 190     }
 191   }
 192   else {
 193     tap_key(keycode);
 194     if (count > 1) {
 195       tap_key(keycode);
 196     }
 197   }
 198 }
 199
 200 void colon(qk_tap_dance_state_t *state, void *user_data)
 201 {
 202   if (state->count > 2) {
 203     tap_key  (KC_SPC);
 204     shift_key(KC_SCLN);
 205     shift_key(KC_SCLN);
 206     tap_key  (KC_SPC);
 207   }
 208   else {
 209     double_max(state->count, SHIFT, KC_SCLN);
 210   }
 211   reset_tap_dance(state);
 212 }
 213
 214 void eql(qk_tap_dance_state_t *state, void *user_data)
 215 {
 216   if (state->count > 2) {
 217     tap_key(KC_SPC);
 218     tap_key(KC_SLSH);
 219     tap_key(KC_EQL);
 220     tap_key(KC_SPC);
 221   }
 222   else {
 223     double_max(state->count, NOSHIFT, KC_EQL);
 224   }
 225   reset_tap_dance(state);
 226 }
 227
 228 void greater(qk_tap_dance_state_t *state, void *user_data)
 229 {
 230   if (state->count > 2) {
 231     tap_key  (KC_SPC);
 232     tap_key  (KC_MINS);
 233     shift_key(KC_DOT);
 234     tap_key  (KC_SPC);
 235   }
 236   else {
 237     double_max(state->count, SHIFT, KC_DOT);
 238   }
 239   reset_tap_dance(state);
 240 }
 241
 242 void lesser(qk_tap_dance_state_t *state, void *user_data)
 243 {
 244   if (state->count > 2) {
 245     tap_key  (KC_SPC);
 246     shift_key(KC_COMM);
 247     tap_key  (KC_MINS);
 248     tap_key  (KC_SPC);
 249   }
 250   else {
 251     double_max(state->count, SHIFT, KC_COMM);
 252   }
 253   reset_tap_dance(state);
 254 }
 255
 256 void tilde(qk_tap_dance_state_t *state, void *user_data)
 257 {
 258   // double tap plus down: repeating keycode
 259   if (state->count > 2) {
 260     register_code(KC_LSFT);
 261     register_code(KC_GRV);
 262   }
 263   // tap: keycode
 264   else {
 265     shift_key(KC_GRV);
 266     // double tap: unix home directory
 267     if (state->count > 1) {
 268       tap_key(KC_SLSH);
 269     }
 270   }
 271 }
 272
 273 void tilde_reset(qk_tap_dance_state_t *state, void *user_data)
 274 {
 275   unregister_code(KC_GRV);
 276   unregister_code(KC_LSFT);
 277 }
 278
 279 // ............................................................. Tap Dance Pairs
 280
 281 // tap dance shift rules
 282 #define S_NEVER  0
 283 #define S_SINGLE 1
 284 #define S_DOUBLE 2
 285 #define S_ALWAYS S_SINGLE | S_DOUBLE
 286
 287 void symbol_pair(uint8_t shift, uint16_t left, uint16_t right)
 288 {
 289   if (shift & S_DOUBLE) {
 290     shift_key(left);
 291     shift_key(right);
 292   }
 293   else {
 294     tap_key(left);
 295     tap_key(right);
 296   }
 297 }
 298
 299 #define CLOSE 1
 300
 301 // tap dance symbol pairs
 302 void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close)
 303 {
 304   // triple tap: left right with cursor between symbol pair a la vim :-)
 305   if (state->count > 2) {
 306     symbol_pair(shift, left, right);
 307     tap_key    (KC_LEFT);
 308   }
 309   // double tap: left right
 310   else if (state->count > 1) {
 311     symbol_pair(shift, left, right);
 312   }
 313   // down: modifier
 314   else if (state->pressed) {
 315     if (modifier) {
 316       register_code(modifier);
 317     }
 318   }
 319   // tap: left (close: right)
 320   else {
 321     if (shift & S_SINGLE) {
 322       shift_key(close ? right : left);
 323     }
 324     else {
 325       tap_key(close ? right : left);
 326     }
 327   }
 328   if (!modifier) {
 329     reset_tap_dance(state);
 330   }
 331 }
 332
 333 void doublequote(qk_tap_dance_state_t *state, void *user_data)
 334 {
 335   tap_pair(state, S_ALWAYS, KC_QUOT, KC_QUOT, 0, 0);
 336 }
 337
 338 void grave(qk_tap_dance_state_t *state, void *user_data)
 339 {
 340   tap_pair(state, S_NEVER, KC_GRV, KC_GRV, 0, 0);
 341 }
 342
 343 void lbrace(qk_tap_dance_state_t *state, void *user_data)
 344 {
 345   tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, 0);
 346 }
 347
 348 void lcurly(qk_tap_dance_state_t *state, void *user_data)
 349 {
 350   tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, 0);
 351 }
 352
 353 void lparen(qk_tap_dance_state_t *state, void *user_data)
 354 {
 355   tap_pair(state, S_ALWAYS, KC_9, KC_0, KC_LCTL, 0);
 356 }
 357
 358 void lparen_reset(qk_tap_dance_state_t *state, void *user_data)
 359 {
 360   unregister_code(KC_LCTL);
 361 }
 362
 363 void quote(qk_tap_dance_state_t *state, void *user_data)
 364 {
 365   tap_pair(state, S_NEVER, KC_QUOT, KC_QUOT, 0, 0);
 366 }
 367
 368 void rangle(qk_tap_dance_state_t *state, void *user_data)
 369 {
 370   tap_pair(state, S_ALWAYS, KC_COMM, KC_DOT, 0, CLOSE);
 371 }
 372
 373 void rbrace(qk_tap_dance_state_t *state, void *user_data)
 374 {
 375   tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, CLOSE);
 376 }
 377
 378 void rcurly(qk_tap_dance_state_t *state, void *user_data)
 379 {
 380   tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, CLOSE);
 381 }
 382
 383 void rparen(qk_tap_dance_state_t *state, void *user_data)
 384 {
 385   tap_pair(state, S_ALWAYS, KC_9, KC_0, 0, CLOSE);
 386 }
 387
 388 void rparen_reset(qk_tap_dance_state_t *state, void *user_data)
 389 {
 390   unregister_code(KC_LCTL);
 391 }
 392
 393 // ............................................................ Tap Dance Insert
 394
 395 void comma(qk_tap_dance_state_t *state, void *user_data)
 396 {
 397   tap_key(KC_COMM);
 398   if (state->count > 1) {
 399     tap_key(KC_SPC);
 400   }
 401   reset_tap_dance(state);
 402 }
 403
 404 void dot(qk_tap_dance_state_t *state, void *user_data)
 405 {
 406   if (state->count > 1) {
 407     shift_key(KC_COLN);
 408   }
 409   else {
 410     tap_key(KC_DOT);
 411   }
 412   reset_tap_dance(state);
 413 }
 414
 415 // compile time macro string, see functions/hardware planck script
 416 void private(qk_tap_dance_state_t *state, void *user_data)
 417 {
 418   if (state->count > 1) {
 419 #ifdef PRIVATE_STRING
 420 #include "private_string.h"
 421 #endif
 422   }
 423   reset_tap_dance(state);
 424 }
 425
 426 // config.h defined string
 427 void send(qk_tap_dance_state_t *state, void *user_data)
 428 {
 429   if (state->count > 1) {
 430     SEND_STRING(PUBLIC_STRING);
 431   }
 432   reset_tap_dance(state);
 433 }
 434
 435 // .......................................................... Tap Dance One Shot
 436
 437 void caps(qk_tap_dance_state_t *state, void *user_data)
 438 {
 439   if (state->count > 1) {
 440     tap_key(KC_CAPS);
 441   }
 442   else {
 443     set_oneshot_mods(MOD_LSFT);
 444     register_code   (KC_LSFT);              // on hold down
 445   }
 446 }
 447
 448 void caps_reset(qk_tap_dance_state_t *state, void *user_data)
 449 {
 450   unregister_code(KC_LSFT);
 451 }
 452
 453 // ................................................................... Tap Dance
 454
 455 qk_tap_dance_action_t tap_dance_actions[] = {
 456   [_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, caps, caps_reset)
 457  ,[_COLN] = ACTION_TAP_DANCE_FN         (colon)
 458  ,[_COMM] = ACTION_TAP_DANCE_FN         (comma)
 459  ,[_DOT]  = ACTION_TAP_DANCE_FN         (dot)
 460  ,[_DQOT] = ACTION_TAP_DANCE_FN         (doublequote)
 461  ,[_ENT]  = ACTION_TAP_DANCE_FN_ADVANCED(NULL, enter, enter_reset)
 462  ,[_EQL]  = ACTION_TAP_DANCE_FN         (eql)
 463  ,[_GRV]  = ACTION_TAP_DANCE_FN         (grave)
 464  ,[_GT]   = ACTION_TAP_DANCE_FN         (greater)
 465  ,[_LBRC] = ACTION_TAP_DANCE_FN         (lbrace)
 466  ,[_LCBR] = ACTION_TAP_DANCE_FN         (lcurly)
 467  ,[_LPRN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lparen, lparen_reset)
 468  ,[_LT]   = ACTION_TAP_DANCE_FN         (lesser)
 469  ,[_PRIV] = ACTION_TAP_DANCE_FN         (private)
 470  ,[_QUOT] = ACTION_TAP_DANCE_FN         (quote)
 471  ,[_RBRC] = ACTION_TAP_DANCE_FN         (rbrace)
 472  ,[_RCBR] = ACTION_TAP_DANCE_FN         (rcurly)
 473  ,[_RNGL] = ACTION_TAP_DANCE_FN         (rangle)
 474  ,[_RPRN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, rparen, rparen_reset)
 475  ,[_SEND] = ACTION_TAP_DANCE_FN         (send)
 476  ,[_SPC]  = ACTION_TAP_DANCE_FN_ADVANCED(NULL, space, space_reset)
 477  ,[_TILD] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tilde, tilde_reset)
 478 };
 479
 480 // .............................................................. Dynamic Layers
 481
 482 #define        LEFT    1
 483 #define        RIGHT   2
 484 static uint8_t thumb = 0;
 485
 486 // LEFT (KC_SPC, S(KC_BSLS)), RIGHT (KC_LEFT, S(KC_LEFT)) opposite thumb combinations, see process_record_user()
 487 // up,   up   -> _BASE
 488 // up,   down -> _SYMBOL
 489 // down, up   -> _NUMBER
 490 // down, down -> _MOUSE                     // see layer keycodes that raise mouse layer
 491 #define THUMBS_DOWN _MOUSE                  // layer
 492
 493 static uint8_t overlayer = 0;
 494
 495 // left right thumb layer combinations
 496 void thumb_layer(keyrecord_t *record, uint8_t side, uint8_t shift, uint16_t keycode, uint8_t thumb_dn_layer, uint8_t thumb_up_layer)
 497 {
 498   if (record->event.pressed) {
 499     // layer_on via tap_layer(), see process_record_user()
 500     key_timer = timer_read();
 501     thumb     = thumb | side;
 502   }
 503   else {
 504     layer_off(thumb_dn_layer);
 505     // opposite thumb_layer() thumb may have switched effective layer!
 506     if (overlayer) {
 507       layer_off(overlayer);
 508       overlayer = 0;
 509     }
 510     if (!key_press(shift, keycode)) {
 511       layer_off(THUMBS_DOWN);               // both thumbs needed
 512       // opposite thumb down? see left right combination layer table above
 513       if (thumb & (side == LEFT ? RIGHT : LEFT)) {
 514         layer_on(thumb_up_layer);
 515         overlayer = thumb_up_layer;
 516       }
 517     }
 518     clear_mods();
 519     thumb     = thumb & ~side;
 520     key_timer = 0;
 521   }
 522 }
 523
 524 // #ifdef STENO_ENABLE
 525 // // LT for steno keycode
 526 // void stn_layer(keyrecord_t *record, uint16_t keycode, uint8_t layer)
 527 // {
 528 //   if (record->event.pressed) {
 529 //     key_timer = timer_read();
 530 //     if (keycode) {
 531 //       process_steno(keycode, record);
 532 //     }
 533 //     layer_on(layer);
 534 //   }
 535 //   else {
 536 //     layer_off(layer);
 537 //     if (keycode) {
 538 //       if (timer_elapsed(key_timer) < TAPPING_TERM) {
 539 //         process_steno(keycode, record);
 540 //       }
 541 //       else {
 542 //         // clear pressed state (request push of updated) process_steno.c and .h
 543 //         // steno_clear_state();
 544 //       }
 545 //     }
 546 //     key_timer = 0;
 547 //   }
 548 // }
 549 // #endif
 550
 551 // LT macro for nested LT layers
 552 void lt(keyrecord_t *record, uint8_t shift, uint16_t keycode, uint16_t modifier, uint8_t layer)
 553 {
 554   if (record->event.pressed) {
 555     key_timer = timer_read();
 556     if (modifier) {
 557       register_code(modifier);
 558     }
 559     layer_on(layer);
 560   }
 561   else {
 562     if (modifier) {
 563       unregister_code(modifier);
 564     }
 565     layer_off(layer);
 566     // for shifted keycodes, hence, LT_SHIFT
 567     key_press(shift, keycode);
 568     clear_mods();
 569     key_timer = 0;
 570   }
 571 }
 572
 573 // LT for S(keycode)
 574 void lt_shift(keyrecord_t *record, uint16_t keycode, uint8_t layer)
 575 {
 576   lt(record, SHIFT, keycode, 0, layer);
 577 }
 578
 579 // set layer asap to overcome macro latency errors, notably tap dance and LT usage
 580 // this routine inexplicably (?) sets layer_on() faster than can be done in thumb_layer()
 581 void tap_layer(keyrecord_t *record, uint8_t layer)
 582 {
 583   if (record->event.pressed) {
 584     layer_on(layer);
 585   }
 586   else {
 587     layer_off(layer);
 588   }
 589 }
 590
 591 // ..................................................................... Keymaps
 592
 593 // void persistant_default_layer_set(uint16_t default_layer)
 594 // {
 595 //   eeconfig_update_default_layer(default_layer);
 596 //   default_layer_set            (default_layer);
 597 // }
 598
 599 void clear_layers(void)
 600 {
 601   uint8_t layer;
 602   for (layer = 0; layer < _END_LAYERS; layer++) {
 603     layer_off(layer);
 604   }
 605 }
 606
 607 #ifdef HOME_MODS
 608 // home row layer/shift key state, see tap_mods() and keymap.c
 609 #define LSYMBOL MOD_BIT(KC_LSFT)
 610 #define RSYMBOL MOD_BIT(KC_RSFT)
 611
 612 void home_state(void) {
 613   // if only the shift key, raise the opposite hand symbol layer
 614   if (mods == LSYMBOL) {
 615     layer_on(_LSYMBOL);
 616   }
 617   else if (mods == RSYMBOL) {
 618     layer_on(_RSYMBOL);
 619   }
 620   // or combine modifiers
 621   else if (mods & LSYMBOL) {
 622     register_code(KC_LSFT);
 623   }
 624   else if (mods & RSYMBOL) {
 625     register_code(KC_RSFT);
 626   }
 627 }
 628
 629 // home row layer/shift
 630 void symbol_shift(keyrecord_t *record, uint16_t keycode)
 631 {
 632   if (keycode) {
 633     if (record->event.pressed) {
 634       key_timer = timer_read();
 635       home_state();
 636     }
 637     else {
 638       // clear layer/shift state
 639       if (keycode == KC_A) {
 640         layer_off(_LSYMBOL);
 641         unregister_code(KC_LSFT);
 642       }
 643       else if (keycode == KC_T) {
 644         layer_off(_RSYMBOL);
 645         unregister_code(KC_RSFT);
 646       }
 647       // no other modifier enabled, issue keycode
 648       if (~mods) {
 649         key_press(NOSHIFT, keycode);
 650       }
 651       key_timer = 0;
 652     }
 653   }
 654   else {
 655     // a non-shift modifier disables symbol layer
 656     layer_off(_LSYMBOL);
 657     layer_off(_RSYMBOL);
 658     // update home layer/shift state
 659     home_state();
 660   }
 661 }
 662 #endif
 663
 664 #ifdef CENTER_TT
 665 static uint16_t tt_keycode = 0;             // current TT keycode
 666
 667 void clear_tt(void)
 668 {
 669   if (tt_keycode == KC_CAPS) {
 670     tap_key(KC_CAPS);                       // clear capslock
 671   }
 672   tt_keycode = 0;
 673   clear_layers();
 674   set_single_persistent_default_layer(_BASE);
 675 }
 676 #endif
 677
 678 // txbolt plover run state
 679 static uint8_t plover = 0;
 680
 681 void toggle_plover(uint8_t state)
 682 {
 683   if (plover != state) {
 684 #ifdef PLOVER_KEYBIND
 685 #include "plover_keybind.h"
 686 #endif
 687     plover = state;
 688   }
 689 }
 690
 691 void base_layer(void)
 692 {
 693 #ifdef AUDIO_ENABLE
 694   if (plover) {
 695     PLAY_SONG(song_plover_gb);
 696   }
 697   else {
 698     PLAY_SONG(song_qwerty);
 699   }
 700 #endif
 701   clear_layers();
 702   set_single_persistent_default_layer(_BASE);
 703   toggle_plover(0);
 704 }
 705
 706 void steno(keyrecord_t *record)
 707 {
 708   if (record->event.pressed) {
 709 #ifdef AUDIO_ENABLE
 710     PLAY_SONG(song_plover);
 711 #endif
 712     clear_layers();
 713     layer_on(_PLOVER);
 714     if (!eeconfig_is_enabled()) {
 715       eeconfig_init();
 716     }
 717     keymap_config.raw  = eeconfig_read_keymap();
 718     keymap_config.nkro = 1;
 719     eeconfig_update_keymap(keymap_config.raw);
 720     if (!plover) {
 721       toggle_plover(1);
 722     }
 723   }
 724 }
 725
 726 void steno_exit(keyrecord_t *record)
 727 {
 728   if (record->event.pressed) {
 729     base_layer();
 730     toggle_plover(0);
 731   }
 732 }