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