keyboards/hhkb/keymaps/shela/action_pseudo_lut.c

   1 #include "quantum.h"
   2 #include "action_pseudo_lut.h"
   3
   4 static uint8_t send_key_shift_bit[SHIFT_BIT_SIZE];
   5
   6 /*
   7  * Pseudo layout action.
   8  * This action converts a keycode in order to output the character according to the keymap you specified
   9  * still your keyboard layout recognized wrongly on your OS.
  10  * Memo: Using other layer keymap to get keycode
  11  */
  12 void action_pseudo_lut(keyrecord_t *record, uint8_t base_keymap_id, const uint16_t (*keymap)[2]) {
  13     static uint8_t prev_shift;
  14     uint16_t keycode;
  15     uint16_t pseudo_keycode;
  16
  17     /* get keycode from keymap you specified */
  18     keycode = keymap_key_to_keycode(base_keymap_id, record->event.key);
  19
  20     prev_shift = keyboard_report->mods & (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT));
  21
  22     if (record->event.pressed) {
  23         /* when magic commands entered, keycode does not converted */
  24         if (IS_COMMAND()) {
  25             if (prev_shift) {
  26                 add_shift_bit(keycode);
  27             }
  28             register_code(keycode);
  29             return;
  30         }
  31
  32         if (prev_shift) {
  33             pseudo_keycode = convert_keycode(keymap, keycode, true);
  34             dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
  35             add_shift_bit(keycode);
  36
  37             if (IS_LSFT(pseudo_keycode)) {
  38                 register_code(QK_LSFT ^ pseudo_keycode);
  39             } else {
  40                 /* delete shift mod temporarily */
  41                 del_mods(prev_shift);
  42                 send_keyboard_report();
  43                 register_code(pseudo_keycode);
  44                 add_mods(prev_shift);
  45                 send_keyboard_report();
  46             }
  47         } else {
  48             pseudo_keycode = convert_keycode(keymap, keycode, false);
  49             dprintf("pressed: %02X, converted: %04X\n", keycode, pseudo_keycode);
  50
  51             if (IS_LSFT(pseudo_keycode)) {
  52                 add_weak_mods(MOD_BIT(KC_LSFT));
  53                 send_keyboard_report();
  54                 register_code(QK_LSFT ^ pseudo_keycode);
  55                 /* on Windows, prevent key repeat to avoid unintended output */
  56                 unregister_code(QK_LSFT ^ pseudo_keycode);
  57                 del_weak_mods(MOD_BIT(KC_LSFT));
  58                 send_keyboard_report();
  59             } else {
  60                 register_code(pseudo_keycode);
  61             }
  62         }
  63     } else {
  64         if (get_shift_bit(keycode)) {
  65             del_shift_bit(keycode);
  66             pseudo_keycode = convert_keycode(keymap, keycode, true);
  67         } else {
  68             pseudo_keycode = convert_keycode(keymap, keycode, false);
  69         }
  70         dprintf("released: %02X, converted: %04X\n", keycode, pseudo_keycode);
  71
  72         if (IS_LSFT(pseudo_keycode)) {
  73             unregister_code(QK_LSFT ^ pseudo_keycode);
  74         } else {
  75             unregister_code(pseudo_keycode);
  76         }
  77     }
  78 }
  79
  80 uint16_t convert_keycode(const uint16_t (*keymap)[2], uint16_t keycode, bool shift_modded)
  81 {
  82     uint16_t pseudo_keycode;
  83
  84     switch (keycode) {
  85         case KC_A ... KC_CAPSLOCK:
  86 #if defined(__AVR__)
  87             if (shift_modded) {
  88                 pseudo_keycode = pgm_read_word(&keymap[keycode][1]);
  89             } else {
  90                 pseudo_keycode = pgm_read_word(&keymap[keycode][0]);
  91             }
  92 #else
  93             if (shift_modded) {
  94                 pseudo_keycode = keymap[keycode][1];
  95             } else {
  96                 pseudo_keycode = keymap[keycode][0];
  97             }
  98 #endif
  99             /* if undefined, use got keycode as it is */
 100             if (pseudo_keycode == 0x00) {
 101                 if (shift_modded) {
 102                     pseudo_keycode = S(keycode);
 103                 } else {
 104                     pseudo_keycode = keycode;
 105                 }
 106             }
 107             break;
 108         default:
 109             if (shift_modded) {
 110                 pseudo_keycode = S(keycode);
 111             } else {
 112                 pseudo_keycode = keycode;
 113             }
 114             break;
 115     }
 116     return pseudo_keycode;
 117 }
 118
 119 uint8_t get_shift_bit(uint16_t keycode) {
 120     if ((keycode >> 3) < SHIFT_BIT_SIZE) {
 121         return send_key_shift_bit[keycode >> 3] & (1 << (keycode & 7));
 122     } else {
 123         dprintf("get_shift_bit: Can't get shift bit. keycode: %02X\n", keycode);
 124         return 0;
 125     }
 126 }
 127
 128 void add_shift_bit(uint16_t keycode) {
 129     if ((keycode >> 3) < SHIFT_BIT_SIZE) {
 130         send_key_shift_bit[keycode >> 3] |= (1 << (keycode & 7));
 131     } else {
 132         dprintf("add_shift_bit: Can't add shift bit. keycode: %02X\n", keycode);
 133     }
 134 }
 135
 136 void del_shift_bit(uint16_t keycode) {
 137     if ((keycode >> 3) < SHIFT_BIT_SIZE) {
 138         send_key_shift_bit[keycode >> 3] &= ~(1 << (keycode & 7));
 139     } else {
 140         dprintf("del_shift_bit: Can't delete shift bit. keycode: %02X\n", keycode);
 141     }
 142 }