logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

process_caps_word.c (9834B)

    

  1. // Copyright 2021-2022 Google LLC
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //     https://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. #include "process_caps_word.h"
  16. #include "process_auto_shift.h"
  17. #include "process_space_cadet.h"
  18. #include "caps_word.h"
  19. #include "keycodes.h"
  20. #include "quantum_keycodes.h"
  21. #include "modifiers.h"
  22. #include "timer.h"
  23. #include "action_tapping.h"
  24. #include "action_util.h"
  26. #ifdef CAPS_WORD_INVERT_ON_SHIFT
  27. static uint8_t held_mods = 0;
  29. static bool handle_shift(uint16_t keycode, keyrecord_t* record) {
  30.     switch (keycode) {
  31.         case OSM(MOD_LSFT):
  32.             keycode = KC_LSFT;
  33.             break;
  34.         case OSM(MOD_RSFT):
  35.             keycode = KC_RSFT;
  36.             break;
  38. #    ifndef NO_ACTION_TAPPING
  39.         case QK_MOD_TAP ... QK_MOD_TAP_MAX:
  40.             if (record->tap.count == 0) { // Mod-tap key is held.
  41.                 switch (QK_MOD_TAP_GET_MODS(keycode)) {
  42.                     case MOD_LSFT:
  43.                         keycode = KC_LSFT;
  44.                         break;
  45.                     case MOD_RSFT:
  46.                         keycode = KC_RSFT;
  47.                         break;
  48.                 }
  49.             }
  50. #    endif // NO_ACTION_TAPPING
  51.     }
  53.     if (keycode == KC_LSFT || keycode == KC_RSFT) {
  54.         const uint8_t mod = MOD_BIT(keycode);
  56.         if (is_caps_word_on()) {
  57.             if (record->event.pressed) {
  58.                 held_mods |= mod;
  59.             } else {
  60.                 held_mods &= ~mod;
  61.             }
  62.             return false;
  63.         } else if ((held_mods & mod) != 0) {
  64.             held_mods &= ~mod;
  65.             del_mods(mod);
  66.             return record->event.pressed;
  67.         }
  68.     }
  70.     return true;
  71. }
  72. #endif // CAPS_WORD_INVERT_ON_SHIFT
  74. bool process_caps_word(uint16_t keycode, keyrecord_t* record) {
  75.     if (keycode == QK_CAPS_WORD_TOGGLE) {
  76.         if (record->event.pressed) {
  77.             caps_word_toggle();
  78.         }
  79.         return false;
  80.     }
  81. #ifdef CAPS_WORD_INVERT_ON_SHIFT
  82.     if (!handle_shift(keycode, record)) {
  83.         return false;
  84.     }
  85. #endif // CAPS_WORD_INVERT_ON_SHIFT
  87. #ifndef NO_ACTION_ONESHOT
  88.     const uint8_t mods = get_mods() | get_oneshot_mods();
  89. #else
  90.     const uint8_t mods = get_mods();
  91. #endif // NO_ACTION_ONESHOT
  93.     if (!is_caps_word_on()) {
  94.         // The following optionally turns on Caps Word by holding left and
  95.         // right shifts or by double tapping left shift. This way Caps Word
  96.         // may be used without needing a dedicated key and also without
  97.         // needing combos or tap dance.
  99. #ifdef BOTH_SHIFTS_TURNS_ON_CAPS_WORD
  100.         // Many keyboards enable the Command feature by default, which also
  101.         // uses left+right shift. It can be configured to use a different
  102.         // key combination by defining IS_COMMAND(). We make a non-fatal
  103.         // warning if Command is enabled but IS_COMMAND() is *not* defined.
  104. #    if defined(COMMAND_ENABLE) && !defined(IS_COMMAND)
  105. #        pragma message "BOTH_SHIFTS_TURNS_ON_CAPS_WORD and Command should not be enabled at the same time, since both use the Left Shift + Right Shift key combination. Please disable Command, or ensure that `IS_COMMAND` is not set to (get_mods() == MOD_MASK_SHIFT)."
  106. #    else
  107.         if (mods == MOD_MASK_SHIFT
  108. #        ifdef COMMAND_ENABLE
  109.             // Don't activate Caps Word at the same time as Command.
  110.             && !(IS_COMMAND())
  111. #        endif // COMMAND_ENABLE
  112.         ) {
  113.             caps_word_on();
  114. #        ifdef SPACE_CADET_ENABLE
  115.             reset_space_cadet();
  116. #        endif // SPACE_CADET_ENABLE
  117.         }
  118. #    endif     // defined(COMMAND_ENABLE) && !defined(IS_COMMAND)
  119. #endif         // BOTH_SHIFTS_TURNS_ON_CAPS_WORD
  121. #ifdef DOUBLE_TAP_SHIFT_TURNS_ON_CAPS_WORD
  122.         // Double tapping left shift turns on Caps Word.
  123.         //
  124.         // NOTE: This works with KC_LSFT and one-shot left shift. It
  125.         // wouldn't make sense with mod-tap or Space Cadet shift since
  126.         // double tapping would of course trigger the tapping action.
  127.         if (record->event.pressed) {
  128.             static bool     tapped = false;
  129.             static uint16_t timer  = 0;
  130.             if (keycode == KC_LSFT || keycode == OSM(MOD_LSFT)) {
  131.                 if (tapped && !timer_expired(record->event.time, timer)) {
  132.                     // Left shift was double tapped, activate Caps Word.
  133.                     caps_word_on();
  134.                 }
  135.                 tapped = true;
  136.                 timer  = record->event.time + GET_TAPPING_TERM(keycode, record);
  137.             } else {
  138.                 tapped = false; // Reset when any other key is pressed.
  139.             }
  140.         }
  141. #endif // DOUBLE_TAP_SHIFT_TURNS_ON_CAPS_WORD
  143.         return true;
  144.     }
  146. #if CAPS_WORD_IDLE_TIMEOUT > 0
  147.     caps_word_reset_idle_timer();
  148. #endif // CAPS_WORD_IDLE_TIMEOUT > 0
  150.     // From here on, we only take action on press events.
  151.     if (!record->event.pressed) {
  152.         return true;
  153.     }
  155.     if (!(mods & ~(MOD_MASK_SHIFT | MOD_BIT(KC_RALT)))) {
  156.         switch (keycode) {
  157.             // Ignore MO, TO, TG, TT, and OSL layer switch keys.
  158.             case QK_MOMENTARY ... QK_MOMENTARY_MAX:
  159.             case QK_TO ... QK_TO_MAX:
  160.             case QK_TOGGLE_LAYER ... QK_TOGGLE_LAYER_MAX:
  161.             case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX:
  162.             case QK_ONE_SHOT_LAYER ... QK_ONE_SHOT_LAYER_MAX:
  163. #ifdef TRI_LAYER_ENABLE // Ignore Tri Layer keys.
  164.             case QK_TRI_LAYER_LOWER ... QK_TRI_LAYER_UPPER:
  165. #endif                   // TRI_LAYER_ENABLE
  166. #ifdef LAYER_LOCK_ENABLE // Ignore Layer Lock key.
  167.             case QK_LAYER_LOCK:
  168. #endif // LAYER_LOCK_ENABLE
  169.        // Ignore AltGr.
  170.             case KC_RALT:
  171.             case OSM(MOD_RALT):
  172.                 return true;
  174. #ifndef NO_ACTION_TAPPING
  175.             // Corresponding to mod keys above, a held mod-tap is handled as:
  176.             // * For shift mods, pass KC_LSFT or KC_RSFT to
  177.             //   caps_word_press_user() to determine whether to continue.
  178.             // * For Shift + AltGr (MOD_RSFT | MOD_RALT), pass RSFT(KC_RALT).
  179.             // * AltGr (MOD_RALT) is ignored.
  180.             // * Otherwise stop Caps Word.
  181.             case QK_MOD_TAP ... QK_MOD_TAP_MAX:
  182.                 if (record->tap.count == 0) { // Mod-tap key is held.
  183.                     const uint8_t mods = QK_MOD_TAP_GET_MODS(keycode);
  184.                     switch (mods) {
  185. #    ifndef CAPS_WORD_INVERT_ON_SHIFT
  186.                         case MOD_LSFT:
  187.                             keycode = KC_LSFT;
  188.                             break;
  189.                         case MOD_RSFT:
  190.                             keycode = KC_RSFT;
  191.                             break;
  192. #    endif // CAPS_WORD_INVERT_ON_SHIFT
  193.                         case MOD_RSFT | MOD_RALT:
  194.                             keycode = RSFT(KC_RALT);
  195.                             break;
  196.                         case MOD_RALT:
  197.                             return true;
  198.                         default:
  199.                             caps_word_off();
  200. #    ifdef CAPS_WORD_INVERT_ON_SHIFT
  201.                             add_mods(held_mods);
  202. #    endif // CAPS_WORD_INVERT_ON_SHIFT
  203.                             return true;
  204.                     }
  205.                 } else {
  206.                     keycode = QK_MOD_TAP_GET_TAP_KEYCODE(keycode);
  207.                 }
  208.                 break;
  210. #    ifndef NO_ACTION_LAYER
  211.             case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
  212. #    endif // NO_ACTION_LAYER
  213.                 if (record->tap.count == 0) {
  214.                     return true;
  215.                 }
  216.                 keycode = QK_LAYER_TAP_GET_TAP_KEYCODE(keycode);
  217.                 break;
  218. #endif // NO_ACTION_TAPPING
  220. #ifdef SWAP_HANDS_ENABLE
  221.             case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX:
  222.                 // Note: IS_SWAP_HANDS_KEYCODE() actually tests for the special action keycodes like SH_TOGG, SH_TT, ...,
  223.                 // which currently overlap the SH_T(kc) range.
  224.                 if (IS_SWAP_HANDS_KEYCODE(keycode)
  225. #    ifndef NO_ACTION_TAPPING
  226.                     || record->tap.count == 0
  227. #    endif // NO_ACTION_TAPPING
  228.                 ) {
  229.                     return true;
  230.                 }
  231.                 keycode = QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode);
  232.                 break;
  233. #endif // SWAP_HANDS_ENABLE
  234.         }
  236. #ifdef AUTO_SHIFT_ENABLE
  237.         del_weak_mods(get_autoshift_state() ? ~MOD_BIT(KC_LSFT) : 0xff);
  238. #else
  239.         clear_weak_mods();
  240. #endif // AUTO_SHIFT_ENABLE
  241.         if (caps_word_press_user(keycode)) {
  242. #ifdef CAPS_WORD_INVERT_ON_SHIFT
  243.             if (held_mods) {
  244.                 set_weak_mods(get_weak_mods() ^ MOD_BIT(KC_LSFT));
  245.             }
  246. #endif // CAPS_WORD_INVERT_ON_SHIFT
  247.             send_keyboard_report();
  248.             return true;
  249.         }
  250.     }
  252.     caps_word_off();
  253. #ifdef CAPS_WORD_INVERT_ON_SHIFT
  254.     add_mods(held_mods);
  255. #endif // CAPS_WORD_INVERT_ON_SHIFT
  256.     return true;
  257. }
  259. __attribute__((weak)) bool caps_word_press_user(uint16_t keycode) {
  260.     switch (keycode) {
  261.         // Keycodes that continue Caps Word, with shift applied.
  262.         case KC_A ... KC_Z:
  263.         case KC_MINS:
  264.             add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to next key.
  265.             return true;
  267.         // Keycodes that continue Caps Word, without shifting.
  268.         case KC_1 ... KC_0:
  269.         case KC_BSPC:
  270.         case KC_DEL:
  271.         case KC_UNDS:
  272.             return true;
  274.         default:
  275.             return false; // Deactivate Caps Word.
  276.     }
  277. }