aboutsummaryrefslogtreecommitdiff
path: root/quantum
diff options
context:
space:
mode:
Diffstat (limited to 'quantum')
-rw-r--r--quantum/audio/song_list.h27
-rw-r--r--quantum/audio/voices.c1
-rw-r--r--quantum/keymap_common.c3
-rw-r--r--quantum/keymap_extras/keymap_french.h4
-rw-r--r--quantum/process_keycode/process_ucis.c133
-rw-r--r--quantum/process_keycode/process_ucis.h35
-rw-r--r--quantum/process_keycode/process_unicode.c285
-rw-r--r--quantum/process_keycode/process_unicode.h160
-rw-r--r--quantum/process_keycode/process_unicode_common.c85
-rw-r--r--quantum/process_keycode/process_unicode_common.h132
-rw-r--r--quantum/process_keycode/process_unicodemap.c56
-rw-r--r--quantum/process_keycode/process_unicodemap.h9
-rw-r--r--quantum/quantum.c80
-rw-r--r--quantum/quantum.h11
-rw-r--r--quantum/quantum_keycodes.h21
15 files changed, 567 insertions, 475 deletions
diff --git a/quantum/audio/song_list.h b/quantum/audio/song_list.h
index 8022ca672..400915db9 100644
--- a/quantum/audio/song_list.h
+++ b/quantum/audio/song_list.h
@@ -122,4 +122,31 @@
122 E__NOTE(_E5), \ 122 E__NOTE(_E5), \
123 E__NOTE(_D5), 123 E__NOTE(_D5),
124 124
125#define COIN_SOUND \
126 E__NOTE(_A5 ), \
127 HD_NOTE(_E6 ),
128
129#define ONE_UP_SOUND \
130 Q__NOTE(_E6 ), \
131 Q__NOTE(_G6 ), \
132 Q__NOTE(_E7 ), \
133 Q__NOTE(_C7 ), \
134 Q__NOTE(_D7 ), \
135 Q__NOTE(_G7 ),
136
137#define SONIC_RING \
138 E__NOTE(_E6), \
139 E__NOTE(_G6), \
140 HD_NOTE(_C7),
141
142#define ZELDA_PUZZLE \
143 Q__NOTE(_G5), \
144 Q__NOTE(_FS5), \
145 Q__NOTE(_DS5), \
146 Q__NOTE(_A4), \
147 Q__NOTE(_GS4), \
148 Q__NOTE(_E5), \
149 Q__NOTE(_GS5), \
150 HD_NOTE(_C6),
151
125#endif 152#endif
diff --git a/quantum/audio/voices.c b/quantum/audio/voices.c
index 8326e91ea..c2edb75f0 100644
--- a/quantum/audio/voices.c
+++ b/quantum/audio/voices.c
@@ -24,6 +24,7 @@ void voice_deiterate() {
24 24
25float voice_envelope(float frequency) { 25float voice_envelope(float frequency) {
26 // envelope_index ranges from 0 to 0xFFFF, which is preserved at 880.0 Hz 26 // envelope_index ranges from 0 to 0xFFFF, which is preserved at 880.0 Hz
27 __attribute__ ((unused))
27 uint16_t compensated_index = (uint16_t)((float)envelope_index * (880.0 / frequency)); 28 uint16_t compensated_index = (uint16_t)((float)envelope_index * (880.0 / frequency));
28 29
29 switch (voice) { 30 switch (voice) {
diff --git a/quantum/keymap_common.c b/quantum/keymap_common.c
index 54b872d49..002eabd85 100644
--- a/quantum/keymap_common.c
+++ b/quantum/keymap_common.c
@@ -119,6 +119,9 @@ action_t action_for_key(uint8_t layer, keypos_t key)
119 mod = keycode & 0xFF; 119 mod = keycode & 0xFF;
120 action.code = ACTION_MODS_ONESHOT(mod); 120 action.code = ACTION_MODS_ONESHOT(mod);
121 break; 121 break;
122 case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX:
123 action.code = ACTION_LAYER_TAP_TOGGLE(keycode & 0xFF);
124 break;
122 case QK_MOD_TAP ... QK_MOD_TAP_MAX: 125 case QK_MOD_TAP ... QK_MOD_TAP_MAX:
123 action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0x1F, keycode & 0xFF); 126 action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0x1F, keycode & 0xFF);
124 break; 127 break;
diff --git a/quantum/keymap_extras/keymap_french.h b/quantum/keymap_extras/keymap_french.h
index 834c69650..401bbdf64 100644
--- a/quantum/keymap_extras/keymap_french.h
+++ b/quantum/keymap_extras/keymap_french.h
@@ -4,7 +4,9 @@
4#include "keymap.h" 4#include "keymap.h"
5 5
6// Alt gr 6// Alt gr
7#ifndef ALGR
7#define ALGR(kc) RALT(kc) 8#define ALGR(kc) RALT(kc)
9#endif
8#define NO_ALGR KC_RALT 10#define NO_ALGR KC_RALT
9 11
10// Normal characters 12// Normal characters
@@ -72,7 +74,7 @@
72#define FR_PIPE ALGR(KC_6) 74#define FR_PIPE ALGR(KC_6)
73#define FR_GRV ALGR(KC_7) 75#define FR_GRV ALGR(KC_7)
74#define FR_BSLS ALGR(KC_8) 76#define FR_BSLS ALGR(KC_8)
75#define FR_CIRC ALGR(KC_9) 77#define FR_CCIRC ALGR(KC_9)
76#define FR_AT ALGR(KC_0) 78#define FR_AT ALGR(KC_0)
77#define FR_RBRC ALGR(FR_RPRN) 79#define FR_RBRC ALGR(FR_RPRN)
78#define FR_RCBR ALGR(FR_EQL) 80#define FR_RCBR ALGR(FR_EQL)
diff --git a/quantum/process_keycode/process_ucis.c b/quantum/process_keycode/process_ucis.c
new file mode 100644
index 000000000..4ad2533b0
--- /dev/null
+++ b/quantum/process_keycode/process_ucis.c
@@ -0,0 +1,133 @@
1#include "process_ucis.h"
2
3qk_ucis_state_t qk_ucis_state;
4
5void qk_ucis_start(void) {
6 qk_ucis_state.count = 0;
7 qk_ucis_state.in_progress = true;
8
9 qk_ucis_start_user();
10}
11
12__attribute__((weak))
13void qk_ucis_start_user(void) {
14 unicode_input_start();
15 register_hex(0x2328);
16 unicode_input_finish();
17}
18
19static bool is_uni_seq(char *seq) {
20 uint8_t i;
21
22 for (i = 0; seq[i]; i++) {
23 uint16_t code;
24 if (('1' <= seq[i]) && (seq[i] <= '0'))
25 code = seq[i] - '1' + KC_1;
26 else
27 code = seq[i] - 'a' + KC_A;
28
29 if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
30 return false;
31 }
32
33 return (qk_ucis_state.codes[i] == KC_ENT ||
34 qk_ucis_state.codes[i] == KC_SPC);
35}
36
37__attribute__((weak))
38void qk_ucis_symbol_fallback (void) {
39 for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
40 uint8_t code = qk_ucis_state.codes[i];
41 register_code(code);
42 unregister_code(code);
43 wait_ms(UNICODE_TYPE_DELAY);
44 }
45}
46
47void register_ucis(const char *hex) {
48 for(int i = 0; hex[i]; i++) {
49 uint8_t kc = 0;
50 char c = hex[i];
51
52 switch (c) {
53 case '0':
54 kc = KC_0;
55 break;
56 case '1' ... '9':
57 kc = c - '1' + KC_1;
58 break;
59 case 'a' ... 'f':
60 kc = c - 'a' + KC_A;
61 break;
62 case 'A' ... 'F':
63 kc = c - 'A' + KC_A;
64 break;
65 }
66
67 if (kc) {
68 register_code (kc);
69 unregister_code (kc);
70 wait_ms (UNICODE_TYPE_DELAY);
71 }
72 }
73}
74
75bool process_ucis (uint16_t keycode, keyrecord_t *record) {
76 uint8_t i;
77
78 if (!qk_ucis_state.in_progress)
79 return true;
80
81 if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
82 !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
83 return false;
84 }
85
86 if (!record->event.pressed)
87 return true;
88
89 qk_ucis_state.codes[qk_ucis_state.count] = keycode;
90 qk_ucis_state.count++;
91
92 if (keycode == KC_BSPC) {
93 if (qk_ucis_state.count >= 2) {
94 qk_ucis_state.count -= 2;
95 return true;
96 } else {
97 qk_ucis_state.count--;
98 return false;
99 }
100 }
101
102 if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
103 bool symbol_found = false;
104
105 for (i = qk_ucis_state.count; i > 0; i--) {
106 register_code (KC_BSPC);
107 unregister_code (KC_BSPC);
108 wait_ms(UNICODE_TYPE_DELAY);
109 }
110
111 if (keycode == KC_ESC) {
112 qk_ucis_state.in_progress = false;
113 return false;
114 }
115
116 unicode_input_start();
117 for (i = 0; ucis_symbol_table[i].symbol; i++) {
118 if (is_uni_seq (ucis_symbol_table[i].symbol)) {
119 symbol_found = true;
120 register_ucis(ucis_symbol_table[i].code + 2);
121 break;
122 }
123 }
124 if (!symbol_found) {
125 qk_ucis_symbol_fallback();
126 }
127 unicode_input_finish();
128
129 qk_ucis_state.in_progress = false;
130 return false;
131 }
132 return true;
133} \ No newline at end of file
diff --git a/quantum/process_keycode/process_ucis.h b/quantum/process_keycode/process_ucis.h
new file mode 100644
index 000000000..4332f57b3
--- /dev/null
+++ b/quantum/process_keycode/process_ucis.h
@@ -0,0 +1,35 @@
1#ifndef PROCESS_UCIS_H
2#define PROCESS_UCIS_H
3
4#include "quantum.h"
5#include "process_unicode_common.h"
6
7#ifndef UCIS_MAX_SYMBOL_LENGTH
8#define UCIS_MAX_SYMBOL_LENGTH 32
9#endif
10
11typedef struct {
12 char *symbol;
13 char *code;
14} qk_ucis_symbol_t;
15
16typedef struct {
17 uint8_t count;
18 uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
19 bool in_progress:1;
20} qk_ucis_state_t;
21
22extern qk_ucis_state_t qk_ucis_state;
23
24#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
25#define UCIS_SYM(name, code) {name, #code}
26
27extern const qk_ucis_symbol_t ucis_symbol_table[];
28
29void qk_ucis_start(void);
30void qk_ucis_start_user(void);
31void qk_ucis_symbol_fallback (void);
32void register_ucis(const char *hex);
33bool process_ucis (uint16_t keycode, keyrecord_t *record);
34
35#endif
diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index 9d01a592d..ccae6fdca 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -1,103 +1,6 @@
1#include "process_unicode.h" 1#include "process_unicode.h"
2#include "action_util.h" 2#include "action_util.h"
3 3
4static uint8_t input_mode;
5uint8_t mods;
6
7__attribute__((weak))
8uint16_t hex_to_keycode(uint8_t hex)
9{
10 if (hex == 0x0) {
11 return KC_0;
12 } else if (hex < 0xA) {
13 return KC_1 + (hex - 0x1);
14 } else {
15 return KC_A + (hex - 0xA);
16 }
17}
18
19void set_unicode_input_mode(uint8_t os_target)
20{
21 input_mode = os_target;
22}
23
24uint8_t get_unicode_input_mode(void) {
25 return input_mode;
26}
27
28__attribute__((weak))
29void unicode_input_start (void) {
30 // save current mods
31 mods = keyboard_report->mods;
32
33 // unregister all mods to start from clean state
34 if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
35 if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
36 if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
37 if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
38 if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
39 if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
40 if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
41 if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
42
43 switch(input_mode) {
44 case UC_OSX:
45 register_code(KC_LALT);
46 break;
47 case UC_LNX:
48 register_code(KC_LCTL);
49 register_code(KC_LSFT);
50 register_code(KC_U);
51 unregister_code(KC_U);
52 unregister_code(KC_LSFT);
53 unregister_code(KC_LCTL);
54 break;
55 case UC_WIN:
56 register_code(KC_LALT);
57 register_code(KC_PPLS);
58 unregister_code(KC_PPLS);
59 break;
60 case UC_WINC:
61 register_code(KC_RALT);
62 unregister_code(KC_RALT);
63 register_code(KC_U);
64 unregister_code(KC_U);
65 }
66 wait_ms(UNICODE_TYPE_DELAY);
67}
68
69__attribute__((weak))
70void unicode_input_finish (void) {
71 switch(input_mode) {
72 case UC_OSX:
73 case UC_WIN:
74 unregister_code(KC_LALT);
75 break;
76 case UC_LNX:
77 register_code(KC_SPC);
78 unregister_code(KC_SPC);
79 break;
80 }
81
82 // reregister previously set mods
83 if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
84 if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
85 if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
86 if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
87 if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
88 if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
89 if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
90 if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
91}
92
93void register_hex(uint16_t hex) {
94 for(int i = 3; i >= 0; i--) {
95 uint8_t digit = ((hex >> (i*4)) & 0xF);
96 register_code(hex_to_keycode(digit));
97 unregister_code(hex_to_keycode(digit));
98 }
99}
100
101bool process_unicode(uint16_t keycode, keyrecord_t *record) { 4bool process_unicode(uint16_t keycode, keyrecord_t *record) {
102 if (keycode > QK_UNICODE && record->event.pressed) { 5 if (keycode > QK_UNICODE && record->event.pressed) {
103 uint16_t unicode = keycode & 0x7FFF; 6 uint16_t unicode = keycode & 0x7FFF;
@@ -108,191 +11,3 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
108 return true; 11 return true;
109} 12}
110 13
111#ifdef UNICODEMAP_ENABLE
112__attribute__((weak))
113const uint32_t PROGMEM unicode_map[] = {
114};
115
116void register_hex32(uint32_t hex) {
117 uint8_t onzerostart = 1;
118 for(int i = 7; i >= 0; i--) {
119 if (i <= 3) {
120 onzerostart = 0;
121 }
122 uint8_t digit = ((hex >> (i*4)) & 0xF);
123 if (digit == 0) {
124 if (onzerostart == 0) {
125 register_code(hex_to_keycode(digit));
126 unregister_code(hex_to_keycode(digit));
127 }
128 } else {
129 register_code(hex_to_keycode(digit));
130 unregister_code(hex_to_keycode(digit));
131 onzerostart = 0;
132 }
133 }
134}
135
136__attribute__((weak))
137void unicode_map_input_error() {}
138
139bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
140 if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
141 const uint32_t* map = unicode_map;
142 uint16_t index = keycode - QK_UNICODE_MAP;
143 uint32_t code = pgm_read_dword_far(&map[index]);
144 if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
145 // Convert to UTF-16 surrogate pair
146 code -= 0x10000;
147 uint32_t lo = code & 0x3ff;
148 uint32_t hi = (code & 0xffc00) >> 10;
149 unicode_input_start();
150 register_hex32(hi + 0xd800);
151 register_hex32(lo + 0xdc00);
152 unicode_input_finish();
153 } else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
154 // when character is out of range supported by the OS
155 unicode_map_input_error();
156 } else {
157 unicode_input_start();
158 register_hex32(code);
159 unicode_input_finish();
160 }
161 }
162 return true;
163}
164#endif
165
166#ifdef UCIS_ENABLE
167qk_ucis_state_t qk_ucis_state;
168
169void qk_ucis_start(void) {
170 qk_ucis_state.count = 0;
171 qk_ucis_state.in_progress = true;
172
173 qk_ucis_start_user();
174}
175
176__attribute__((weak))
177void qk_ucis_start_user(void) {
178 unicode_input_start();
179 register_hex(0x2328);
180 unicode_input_finish();
181}
182
183static bool is_uni_seq(char *seq) {
184 uint8_t i;
185
186 for (i = 0; seq[i]; i++) {
187 uint16_t code;
188 if (('1' <= seq[i]) && (seq[i] <= '0'))
189 code = seq[i] - '1' + KC_1;
190 else
191 code = seq[i] - 'a' + KC_A;
192
193 if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
194 return false;
195 }
196
197 return (qk_ucis_state.codes[i] == KC_ENT ||
198 qk_ucis_state.codes[i] == KC_SPC);
199}
200
201__attribute__((weak))
202void qk_ucis_symbol_fallback (void) {
203 for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
204 uint8_t code = qk_ucis_state.codes[i];
205 register_code(code);
206 unregister_code(code);
207 wait_ms(UNICODE_TYPE_DELAY);
208 }
209}
210
211void register_ucis(const char *hex) {
212 for(int i = 0; hex[i]; i++) {
213 uint8_t kc = 0;
214 char c = hex[i];
215
216 switch (c) {
217 case '0':
218 kc = KC_0;
219 break;
220 case '1' ... '9':
221 kc = c - '1' + KC_1;
222 break;
223 case 'a' ... 'f':
224 kc = c - 'a' + KC_A;
225 break;
226 case 'A' ... 'F':
227 kc = c - 'A' + KC_A;
228 break;
229 }
230
231 if (kc) {
232 register_code (kc);
233 unregister_code (kc);
234 wait_ms (UNICODE_TYPE_DELAY);
235 }
236 }
237}
238
239bool process_ucis (uint16_t keycode, keyrecord_t *record) {
240 uint8_t i;
241
242 if (!qk_ucis_state.in_progress)
243 return true;
244
245 if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
246 !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
247 return false;
248 }
249
250 if (!record->event.pressed)
251 return true;
252
253 qk_ucis_state.codes[qk_ucis_state.count] = keycode;
254 qk_ucis_state.count++;
255
256 if (keycode == KC_BSPC) {
257 if (qk_ucis_state.count >= 2) {
258 qk_ucis_state.count -= 2;
259 return true;
260 } else {
261 qk_ucis_state.count--;
262 return false;
263 }
264 }
265
266 if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
267 bool symbol_found = false;
268
269 for (i = qk_ucis_state.count; i > 0; i--) {
270 register_code (KC_BSPC);
271 unregister_code (KC_BSPC);
272 wait_ms(UNICODE_TYPE_DELAY);
273 }
274
275 if (keycode == KC_ESC) {
276 qk_ucis_state.in_progress = false;
277 return false;
278 }
279
280 unicode_input_start();
281 for (i = 0; ucis_symbol_table[i].symbol; i++) {
282 if (is_uni_seq (ucis_symbol_table[i].symbol)) {
283 symbol_found = true;
284 register_ucis(ucis_symbol_table[i].code + 2);
285 break;
286 }
287 }
288 if (!symbol_found) {
289 qk_ucis_symbol_fallback();
290 }
291 unicode_input_finish();
292
293 qk_ucis_state.in_progress = false;
294 return false;
295 }
296 return true;
297}
298#endif
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index f17cfa6cf..4c21f11eb 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -2,166 +2,8 @@
2#define PROCESS_UNICODE_H 2#define PROCESS_UNICODE_H
3 3
4#include "quantum.h" 4#include "quantum.h"
5 5#include "process_unicode_common.h"
6#define UC_OSX 0 // Mac OS X
7#define UC_LNX 1 // Linux
8#define UC_WIN 2 // Windows 'HexNumpad'
9#define UC_BSD 3 // BSD (not implemented)
10#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
11
12#ifndef UNICODE_TYPE_DELAY
13#define UNICODE_TYPE_DELAY 10
14#endif
15
16void set_unicode_input_mode(uint8_t os_target);
17uint8_t get_unicode_input_mode(void);
18void unicode_input_start(void);
19void unicode_input_finish(void);
20void register_hex(uint16_t hex);
21 6
22bool process_unicode(uint16_t keycode, keyrecord_t *record); 7bool process_unicode(uint16_t keycode, keyrecord_t *record);
23 8
24#ifdef UNICODEMAP_ENABLE
25void unicode_map_input_error(void);
26bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
27#endif
28
29#ifdef UCIS_ENABLE
30#ifndef UCIS_MAX_SYMBOL_LENGTH
31#define UCIS_MAX_SYMBOL_LENGTH 32
32#endif
33
34typedef struct {
35 char *symbol;
36 char *code;
37} qk_ucis_symbol_t;
38
39typedef struct {
40 uint8_t count;
41 uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
42 bool in_progress:1;
43} qk_ucis_state_t;
44
45extern qk_ucis_state_t qk_ucis_state;
46
47#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
48#define UCIS_SYM(name, code) {name, #code}
49
50extern const qk_ucis_symbol_t ucis_symbol_table[];
51
52void qk_ucis_start(void);
53void qk_ucis_start_user(void);
54void qk_ucis_symbol_fallback (void);
55void register_ucis(const char *hex);
56bool process_ucis (uint16_t keycode, keyrecord_t *record);
57
58#endif
59
60#define UC_BSPC UC(0x0008)
61
62#define UC_SPC UC(0x0020)
63
64#define UC_EXLM UC(0x0021)
65#define UC_DQUT UC(0x0022)
66#define UC_HASH UC(0x0023)
67#define UC_DLR UC(0x0024)
68#define UC_PERC UC(0x0025)
69#define UC_AMPR UC(0x0026)
70#define UC_QUOT UC(0x0027)
71#define UC_LPRN UC(0x0028)
72#define UC_RPRN UC(0x0029)
73#define UC_ASTR UC(0x002A)
74#define UC_PLUS UC(0x002B)
75#define UC_COMM UC(0x002C)
76#define UC_DASH UC(0x002D)
77#define UC_DOT UC(0x002E)
78#define UC_SLSH UC(0x002F)
79
80#define UC_0 UC(0x0030)
81#define UC_1 UC(0x0031)
82#define UC_2 UC(0x0032)
83#define UC_3 UC(0x0033)
84#define UC_4 UC(0x0034)
85#define UC_5 UC(0x0035)
86#define UC_6 UC(0x0036)
87#define UC_7 UC(0x0037)
88#define UC_8 UC(0x0038)
89#define UC_9 UC(0x0039)
90
91#define UC_COLN UC(0x003A)
92#define UC_SCLN UC(0x003B)
93#define UC_LT UC(0x003C)
94#define UC_EQL UC(0x003D)
95#define UC_GT UC(0x003E)
96#define UC_QUES UC(0x003F)
97#define UC_AT UC(0x0040)
98
99#define UC_A UC(0x0041)
100#define UC_B UC(0x0042)
101#define UC_C UC(0x0043)
102#define UC_D UC(0x0044)
103#define UC_E UC(0x0045)
104#define UC_F UC(0x0046)
105#define UC_G UC(0x0047)
106#define UC_H UC(0x0048)
107#define UC_I UC(0x0049)
108#define UC_J UC(0x004A)
109#define UC_K UC(0x004B)
110#define UC_L UC(0x004C)
111#define UC_M UC(0x004D)
112#define UC_N UC(0x004E)
113#define UC_O UC(0x004F)
114#define UC_P UC(0x0050)
115#define UC_Q UC(0x0051)
116#define UC_R UC(0x0052)
117#define UC_S UC(0x0053)
118#define UC_T UC(0x0054)
119#define UC_U UC(0x0055)
120#define UC_V UC(0x0056)
121#define UC_W UC(0x0057)
122#define UC_X UC(0x0058)
123#define UC_Y UC(0x0059)
124#define UC_Z UC(0x005A)
125
126#define UC_LBRC UC(0x005B)
127#define UC_BSLS UC(0x005C)
128#define UC_RBRC UC(0x005D)
129#define UC_CIRM UC(0x005E)
130#define UC_UNDR UC(0x005F)
131
132#define UC_GRV UC(0x0060)
133
134#define UC_a UC(0x0061)
135#define UC_b UC(0x0062)
136#define UC_c UC(0x0063)
137#define UC_d UC(0x0064)
138#define UC_e UC(0x0065)
139#define UC_f UC(0x0066)
140#define UC_g UC(0x0067)
141#define UC_h UC(0x0068)
142#define UC_i UC(0x0069)
143#define UC_j UC(0x006A)
144#define UC_k UC(0x006B)
145#define UC_l UC(0x006C)
146#define UC_m UC(0x006D)
147#define UC_n UC(0x006E)
148#define UC_o UC(0x006F)
149#define UC_p UC(0x0070)
150#define UC_q UC(0x0071)
151#define UC_r UC(0x0072)
152#define UC_s UC(0x0073)
153#define UC_t UC(0x0074)
154#define UC_u UC(0x0075)
155#define UC_v UC(0x0076)
156#define UC_w UC(0x0077)
157#define UC_x UC(0x0078)
158#define UC_y UC(0x0079)
159#define UC_z UC(0x007A)
160
161#define UC_LCBR UC(0x007B)
162#define UC_PIPE UC(0x007C)
163#define UC_RCBR UC(0x007D)
164#define UC_TILD UC(0x007E)
165#define UC_DEL UC(0x007F)
166
167#endif 9#endif
diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
new file mode 100644
index 000000000..31bc3b7ab
--- /dev/null
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -0,0 +1,85 @@
1#include "process_unicode_common.h"
2
3uint8_t mods;
4
5void set_unicode_input_mode(uint8_t os_target)
6{
7 input_mode = os_target;
8}
9
10uint8_t get_unicode_input_mode(void) {
11 return input_mode;
12}
13
14__attribute__((weak))
15void unicode_input_start (void) {
16 // save current mods
17 mods = keyboard_report->mods;
18
19 // unregister all mods to start from clean state
20 if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
21 if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
22 if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
23 if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
24 if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
25 if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
26 if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
27 if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
28
29 switch(input_mode) {
30 case UC_OSX:
31 register_code(KC_LALT);
32 break;
33 case UC_LNX:
34 register_code(KC_LCTL);
35 register_code(KC_LSFT);
36 register_code(KC_U);
37 unregister_code(KC_U);
38 unregister_code(KC_LSFT);
39 unregister_code(KC_LCTL);
40 break;
41 case UC_WIN:
42 register_code(KC_LALT);
43 register_code(KC_PPLS);
44 unregister_code(KC_PPLS);
45 break;
46 case UC_WINC:
47 register_code(KC_RALT);
48 unregister_code(KC_RALT);
49 register_code(KC_U);
50 unregister_code(KC_U);
51 }
52 wait_ms(UNICODE_TYPE_DELAY);
53}
54
55__attribute__((weak))
56void unicode_input_finish (void) {
57 switch(input_mode) {
58 case UC_OSX:
59 case UC_WIN:
60 unregister_code(KC_LALT);
61 break;
62 case UC_LNX:
63 register_code(KC_SPC);
64 unregister_code(KC_SPC);
65 break;
66 }
67
68 // reregister previously set mods
69 if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
70 if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
71 if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
72 if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
73 if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
74 if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
75 if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
76 if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
77}
78
79void register_hex(uint16_t hex) {
80 for(int i = 3; i >= 0; i--) {
81 uint8_t digit = ((hex >> (i*4)) & 0xF);
82 register_code(hex_to_keycode(digit));
83 unregister_code(hex_to_keycode(digit));
84 }
85} \ No newline at end of file
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
new file mode 100644
index 000000000..864693cdd
--- /dev/null
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -0,0 +1,132 @@
1#ifndef PROCESS_UNICODE_COMMON_H
2#define PROCESS_UNICODE_COMMON_H
3
4#include "quantum.h"
5
6#ifndef UNICODE_TYPE_DELAY
7#define UNICODE_TYPE_DELAY 10
8#endif
9
10__attribute__ ((unused))
11static uint8_t input_mode;
12
13void set_unicode_input_mode(uint8_t os_target);
14uint8_t get_unicode_input_mode(void);
15void unicode_input_start(void);
16void unicode_input_finish(void);
17void register_hex(uint16_t hex);
18
19#define UC_OSX 0 // Mac OS X
20#define UC_LNX 1 // Linux
21#define UC_WIN 2 // Windows 'HexNumpad'
22#define UC_BSD 3 // BSD (not implemented)
23#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
24
25#define UC_BSPC UC(0x0008)
26
27#define UC_SPC UC(0x0020)
28
29#define UC_EXLM UC(0x0021)
30#define UC_DQUT UC(0x0022)
31#define UC_HASH UC(0x0023)
32#define UC_DLR UC(0x0024)
33#define UC_PERC UC(0x0025)
34#define UC_AMPR UC(0x0026)
35#define UC_QUOT UC(0x0027)
36#define UC_LPRN UC(0x0028)
37#define UC_RPRN UC(0x0029)
38#define UC_ASTR UC(0x002A)
39#define UC_PLUS UC(0x002B)
40#define UC_COMM UC(0x002C)
41#define UC_DASH UC(0x002D)
42#define UC_DOT UC(0x002E)
43#define UC_SLSH UC(0x002F)
44
45#define UC_0 UC(0x0030)
46#define UC_1 UC(0x0031)
47#define UC_2 UC(0x0032)
48#define UC_3 UC(0x0033)
49#define UC_4 UC(0x0034)
50#define UC_5 UC(0x0035)
51#define UC_6 UC(0x0036)
52#define UC_7 UC(0x0037)
53#define UC_8 UC(0x0038)
54#define UC_9 UC(0x0039)
55
56#define UC_COLN UC(0x003A)
57#define UC_SCLN UC(0x003B)
58#define UC_LT UC(0x003C)
59#define UC_EQL UC(0x003D)
60#define UC_GT UC(0x003E)
61#define UC_QUES UC(0x003F)
62#define UC_AT UC(0x0040)
63
64#define UC_A UC(0x0041)
65#define UC_B UC(0x0042)
66#define UC_C UC(0x0043)
67#define UC_D UC(0x0044)
68#define UC_E UC(0x0045)
69#define UC_F UC(0x0046)
70#define UC_G UC(0x0047)
71#define UC_H UC(0x0048)
72#define UC_I UC(0x0049)
73#define UC_J UC(0x004A)
74#define UC_K UC(0x004B)
75#define UC_L UC(0x004C)
76#define UC_M UC(0x004D)
77#define UC_N UC(0x004E)
78#define UC_O UC(0x004F)
79#define UC_P UC(0x0050)
80#define UC_Q UC(0x0051)
81#define UC_R UC(0x0052)
82#define UC_S UC(0x0053)
83#define UC_T UC(0x0054)
84#define UC_U UC(0x0055)
85#define UC_V UC(0x0056)
86#define UC_W UC(0x0057)
87#define UC_X UC(0x0058)
88#define UC_Y UC(0x0059)
89#define UC_Z UC(0x005A)
90
91#define UC_LBRC UC(0x005B)
92#define UC_BSLS UC(0x005C)
93#define UC_RBRC UC(0x005D)
94#define UC_CIRM UC(0x005E)
95#define UC_UNDR UC(0x005F)
96
97#define UC_GRV UC(0x0060)
98
99#define UC_a UC(0x0061)
100#define UC_b UC(0x0062)
101#define UC_c UC(0x0063)
102#define UC_d UC(0x0064)
103#define UC_e UC(0x0065)
104#define UC_f UC(0x0066)
105#define UC_g UC(0x0067)
106#define UC_h UC(0x0068)
107#define UC_i UC(0x0069)
108#define UC_j UC(0x006A)
109#define UC_k UC(0x006B)
110#define UC_l UC(0x006C)
111#define UC_m UC(0x006D)
112#define UC_n UC(0x006E)
113#define UC_o UC(0x006F)
114#define UC_p UC(0x0070)
115#define UC_q UC(0x0071)
116#define UC_r UC(0x0072)
117#define UC_s UC(0x0073)
118#define UC_t UC(0x0074)
119#define UC_u UC(0x0075)
120#define UC_v UC(0x0076)
121#define UC_w UC(0x0077)
122#define UC_x UC(0x0078)
123#define UC_y UC(0x0079)
124#define UC_z UC(0x007A)
125
126#define UC_LCBR UC(0x007B)
127#define UC_PIPE UC(0x007C)
128#define UC_RCBR UC(0x007D)
129#define UC_TILD UC(0x007E)
130#define UC_DEL UC(0x007F)
131
132#endif \ No newline at end of file
diff --git a/quantum/process_keycode/process_unicodemap.c b/quantum/process_keycode/process_unicodemap.c
new file mode 100644
index 000000000..68a593a18
--- /dev/null
+++ b/quantum/process_keycode/process_unicodemap.c
@@ -0,0 +1,56 @@
1#include "process_unicodemap.h"
2#include "process_unicode_common.h"
3
4__attribute__((weak))
5const uint32_t PROGMEM unicode_map[] = {
6};
7
8void register_hex32(uint32_t hex) {
9 bool onzerostart = true;
10 for(int i = 7; i >= 0; i--) {
11 if (i <= 3) {
12 onzerostart = false;
13 }
14 uint8_t digit = ((hex >> (i*4)) & 0xF);
15 if (digit == 0) {
16 if (!onzerostart) {
17 register_code(hex_to_keycode(digit));
18 unregister_code(hex_to_keycode(digit));
19 }
20 } else {
21 register_code(hex_to_keycode(digit));
22 unregister_code(hex_to_keycode(digit));
23 onzerostart = false;
24 }
25 }
26}
27
28__attribute__((weak))
29void unicode_map_input_error() {}
30
31bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
32 uint8_t input_mode = get_unicode_input_mode();
33 if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
34 const uint32_t* map = unicode_map;
35 uint16_t index = keycode - QK_UNICODE_MAP;
36 uint32_t code = pgm_read_dword_far(&map[index]);
37 if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
38 // Convert to UTF-16 surrogate pair
39 code -= 0x10000;
40 uint32_t lo = code & 0x3ff;
41 uint32_t hi = (code & 0xffc00) >> 10;
42 unicode_input_start();
43 register_hex32(hi + 0xd800);
44 register_hex32(lo + 0xdc00);
45 unicode_input_finish();
46 } else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
47 // when character is out of range supported by the OS
48 unicode_map_input_error();
49 } else {
50 unicode_input_start();
51 register_hex32(code);
52 unicode_input_finish();
53 }
54 }
55 return true;
56} \ No newline at end of file
diff --git a/quantum/process_keycode/process_unicodemap.h b/quantum/process_keycode/process_unicodemap.h
new file mode 100644
index 000000000..64a7a0109
--- /dev/null
+++ b/quantum/process_keycode/process_unicodemap.h
@@ -0,0 +1,9 @@
1#ifndef PROCESS_UNICODEMAP_H
2#define PROCESS_UNICODEMAP_H
3
4#include "quantum.h"
5#include "process_unicode_common.h"
6
7void unicode_map_input_error(void);
8bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
9#endif \ No newline at end of file
diff --git a/quantum/quantum.c b/quantum/quantum.c
index 2088c10c9..807a7084a 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -7,6 +7,9 @@
7#define TAPPING_TERM 200 7#define TAPPING_TERM 200
8#endif 8#endif
9 9
10#include "backlight.h"
11extern backlight_config_t backlight_config;
12
10#ifdef FAUXCLICKY_ENABLE 13#ifdef FAUXCLICKY_ENABLE
11#include "fauxclicky.h" 14#include "fauxclicky.h"
12#endif 15#endif
@@ -291,14 +294,6 @@ bool process_record_quantum(keyrecord_t *record) {
291 return false; 294 return false;
292 break; 295 break;
293 #endif 296 #endif
294 #ifdef ADAFRUIT_BLE_ENABLE
295 case OUT_BLE:
296 if (record->event.pressed) {
297 set_output(OUTPUT_ADAFRUIT_BLE);
298 }
299 return false;
300 break;
301 #endif
302 #endif 297 #endif
303 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO: 298 case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
304 if (record->event.pressed) { 299 if (record->event.pressed) {
@@ -601,6 +596,10 @@ void matrix_scan_quantum() {
601 matrix_scan_combo(); 596 matrix_scan_combo();
602 #endif 597 #endif
603 598
599 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
600 backlight_task();
601 #endif
602
604 matrix_scan_kb(); 603 matrix_scan_kb();
605} 604}
606 605
@@ -668,13 +667,13 @@ __attribute__ ((weak))
668void backlight_set(uint8_t level) 667void backlight_set(uint8_t level)
669{ 668{
670 // Prevent backlight blink on lowest level 669 // Prevent backlight blink on lowest level
671 #if BACKLIGHT_ON_STATE == 0 670 // #if BACKLIGHT_ON_STATE == 0
672 // PORTx &= ~n 671 // // PORTx &= ~n
673 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF); 672 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
674 #else 673 // #else
675 // PORTx |= n 674 // // PORTx |= n
676 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF); 675 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
677 #endif 676 // #endif
678 677
679 if ( level == 0 ) { 678 if ( level == 0 ) {
680 #ifndef NO_BACKLIGHT_CLOCK 679 #ifndef NO_BACKLIGHT_CLOCK
@@ -682,13 +681,13 @@ void backlight_set(uint8_t level)
682 TCCR1A &= ~(_BV(COM1x1)); 681 TCCR1A &= ~(_BV(COM1x1));
683 OCR1x = 0x0; 682 OCR1x = 0x0;
684 #else 683 #else
685 #if BACKLIGHT_ON_STATE == 0 684 // #if BACKLIGHT_ON_STATE == 0
686 // PORTx |= n 685 // // PORTx |= n
687 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF); 686 // _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
688 #else 687 // #else
689 // PORTx &= ~n 688 // // PORTx &= ~n
690 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF); 689 // _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
691 #endif 690 // #endif
692 #endif 691 #endif
693 } 692 }
694 #ifndef NO_BACKLIGHT_CLOCK 693 #ifndef NO_BACKLIGHT_CLOCK
@@ -711,6 +710,30 @@ void backlight_set(uint8_t level)
711 #endif 710 #endif
712} 711}
713 712
713uint8_t backlight_tick = 0;
714
715void backlight_task(void) {
716 #ifdef NO_BACKLIGHT_CLOCK
717 if ((0xFFFF >> ((BACKLIGHT_LEVELS - backlight_config.level) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
718 #if BACKLIGHT_ON_STATE == 0
719 // PORTx &= ~n
720 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
721 #else
722 // PORTx |= n
723 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
724 #endif
725 } else {
726 #if BACKLIGHT_ON_STATE == 0
727 // PORTx |= n
728 _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
729 #else
730 // PORTx &= ~n
731 _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
732 #endif
733 }
734 backlight_tick = (backlight_tick + 1) % 16;
735 #endif
736}
714 737
715#ifdef BACKLIGHT_BREATHING 738#ifdef BACKLIGHT_BREATHING
716 739
@@ -972,6 +995,19 @@ void send_nibble(uint8_t number) {
972 } 995 }
973} 996}
974 997
998
999__attribute__((weak))
1000uint16_t hex_to_keycode(uint8_t hex)
1001{
1002 if (hex == 0x0) {
1003 return KC_0;
1004 } else if (hex < 0xA) {
1005 return KC_1 + (hex - 0x1);
1006 } else {
1007 return KC_A + (hex - 0xA);
1008 }
1009}
1010
975void api_send_unicode(uint32_t unicode) { 1011void api_send_unicode(uint32_t unicode) {
976#ifdef API_ENABLE 1012#ifdef API_ENABLE
977 uint8_t chunk[4]; 1013 uint8_t chunk[4];
diff --git a/quantum/quantum.h b/quantum/quantum.h
index 18f072189..259bac369 100644
--- a/quantum/quantum.h
+++ b/quantum/quantum.h
@@ -56,6 +56,14 @@ extern uint32_t default_layer_state;
56 #include "process_unicode.h" 56 #include "process_unicode.h"
57#endif 57#endif
58 58
59#ifdef UCIS_ENABLE
60 #include "process_ucis.h"
61#endif
62
63#ifdef UNICODEMAP_ENABLE
64 #include "process_unicodemap.h"
65#endif
66
59#include "process_tap_dance.h" 67#include "process_tap_dance.h"
60 68
61#ifdef PRINTING_ENABLE 69#ifdef PRINTING_ENABLE
@@ -95,6 +103,7 @@ void unregister_code16 (uint16_t code);
95 103
96#ifdef BACKLIGHT_ENABLE 104#ifdef BACKLIGHT_ENABLE
97void backlight_init_ports(void); 105void backlight_init_ports(void);
106void backlight_task(void);
98 107
99#ifdef BACKLIGHT_BREATHING 108#ifdef BACKLIGHT_BREATHING
100void breathing_enable(void); 109void breathing_enable(void);
@@ -117,7 +126,7 @@ void send_dword(uint32_t number);
117void send_word(uint16_t number); 126void send_word(uint16_t number);
118void send_byte(uint8_t number); 127void send_byte(uint8_t number);
119void send_nibble(uint8_t number); 128void send_nibble(uint8_t number);
120 129uint16_t hex_to_keycode(uint8_t hex);
121 130
122void led_set_user(uint8_t usb_led); 131void led_set_user(uint8_t usb_led);
123void led_set_kb(uint8_t usb_led); 132void led_set_kb(uint8_t usb_led);
diff --git a/quantum/quantum_keycodes.h b/quantum/quantum_keycodes.h
index cc7a5013f..78b02a0de 100644
--- a/quantum/quantum_keycodes.h
+++ b/quantum/quantum_keycodes.h
@@ -41,16 +41,21 @@ enum quantum_keycodes {
41#endif 41#endif
42 QK_TAP_DANCE = 0x5700, 42 QK_TAP_DANCE = 0x5700,
43 QK_TAP_DANCE_MAX = 0x57FF, 43 QK_TAP_DANCE_MAX = 0x57FF,
44#ifdef UNICODEMAP_ENABLE 44 QK_LAYER_TAP_TOGGLE = 0x5800,
45 QK_UNICODE_MAP = 0x5800, 45 QK_LAYER_TAP_TOGGLE_MAX = 0x58FF,
46 QK_UNICODE_MAP_MAX = 0x5BFF,
47#endif
48 QK_MOD_TAP = 0x6000, 46 QK_MOD_TAP = 0x6000,
49 QK_MOD_TAP_MAX = 0x7FFF, 47 QK_MOD_TAP_MAX = 0x7FFF,
48#if defined(UNICODEMAP_ENABLE) && defined(UNICODE_ENABLE)
49 #error "Cannot enable both UNICODEMAP && UNICODE"
50#endif
50#ifdef UNICODE_ENABLE 51#ifdef UNICODE_ENABLE
51 QK_UNICODE = 0x8000, 52 QK_UNICODE = 0x8000,
52 QK_UNICODE_MAX = 0xFFFF, 53 QK_UNICODE_MAX = 0xFFFF,
53#endif 54#endif
55#ifdef UNICODEMAP_ENABLE
56 QK_UNICODE_MAP = 0x8000,
57 QK_UNICODE_MAP_MAX = 0x83FF,
58#endif
54 59
55 // Loose keycodes - to be used directly 60 // Loose keycodes - to be used directly
56 61
@@ -154,9 +159,6 @@ enum quantum_keycodes {
154#ifdef BLUETOOTH_ENABLE 159#ifdef BLUETOOTH_ENABLE
155 OUT_BT, 160 OUT_BT,
156#endif 161#endif
157#ifdef ADAFRUIT_BLE_ENABLE
158 OUT_BLE,
159#endif
160 162
161 // always leave at the end 163 // always leave at the end
162 SAFE_RANGE 164 SAFE_RANGE
@@ -178,6 +180,7 @@ enum quantum_keycodes {
178#define ALTG(kc) (kc | QK_RCTL | QK_RALT) 180#define ALTG(kc) (kc | QK_RCTL | QK_RALT)
179#define SCMD(kc) (kc | QK_LGUI | QK_LSFT) 181#define SCMD(kc) (kc | QK_LGUI | QK_LSFT)
180#define SWIN(kc) SCMD(kc) 182#define SWIN(kc) SCMD(kc)
183#define LCA(kc) (kc | QK_LCTL | QK_LALT)
181 184
182#define MOD_HYPR 0xf 185#define MOD_HYPR 0xf
183#define MOD_MEH 0x7 186#define MOD_MEH 0x7
@@ -304,6 +307,9 @@ enum quantum_keycodes {
304// One-shot mod 307// One-shot mod
305#define OSM(mod) (mod | QK_ONE_SHOT_MOD) 308#define OSM(mod) (mod | QK_ONE_SHOT_MOD)
306 309
310// Layer tap-toggle
311#define TT(layer) (layer | QK_LAYER_TAP_TOGGLE)
312
307// M-od, T-ap - 256 keycode max 313// M-od, T-ap - 256 keycode max
308#define MT(mod, kc) (kc | QK_MOD_TAP | ((mod & 0x1F) << 8)) 314#define MT(mod, kc) (kc | QK_MOD_TAP | ((mod & 0x1F) << 8))
309 315
@@ -331,6 +337,7 @@ enum quantum_keycodes {
331#define ALL_T(kc) MT((MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI), kc) // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/ 337#define ALL_T(kc) MT((MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI), kc) // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/
332#define SCMD_T(kc) MT((MOD_LGUI | MOD_LSFT), kc) 338#define SCMD_T(kc) MT((MOD_LGUI | MOD_LSFT), kc)
333#define SWIN_T(kc) SCMD_T(kc) 339#define SWIN_T(kc) SCMD_T(kc)
340#define LCA_T(kc) MT((MOD_LCTL | MOD_LALT), kc) // Left control and left alt
334 341
335// Dedicated keycode versions for Hyper and Meh, if you want to use them as standalone keys rather than mod-tap 342// Dedicated keycode versions for Hyper and Meh, if you want to use them as standalone keys rather than mod-tap
336#define KC_HYPR HYPR(KC_NO) 343#define KC_HYPR HYPR(KC_NO)
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-03 10:11:36 +0000