keyboards/hhkb/keymaps/shela/action_pseudo_lut.c

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