keyboards/comet46/keymaps/satt/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   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 }