aboutsummaryrefslogtreecommitdiff
path: root/users/dennytom/chording_engine/engine.part.2
diff options
context:
space:
mode:
Diffstat (limited to 'users/dennytom/chording_engine/engine.part.2')
-rw-r--r--users/dennytom/chording_engine/engine.part.2323
1 files changed, 323 insertions, 0 deletions
diff --git a/users/dennytom/chording_engine/engine.part.2 b/users/dennytom/chording_engine/engine.part.2
new file mode 100644
index 000000000..91dcbb750
--- /dev/null
+++ b/users/dennytom/chording_engine/engine.part.2
@@ -0,0 +1,323 @@
1void single_dance(const struct Chord* self) {
2 switch (*self->state) {
3 case ACTIVATED:
4 key_in(self->value1);
5 break;
6 case DEACTIVATED:
7 key_out(self->value1);
8 *self->state = IDLE;
9 break;
10 case RESTART:
11 key_out(self->value1);
12 break;
13 default:
14 break;
15 }
16}
17
18void key_layer_dance(const struct Chord* self) {
19 switch (*self->state) {
20 case ACTIVATED:
21 current_pseudolayer = self->value2;
22 a_key_went_through = false;
23 break;
24 case DEACTIVATED:
25 case RESTART:
26 if (!a_key_went_through) {
27 tap_key(self->value1);
28 }
29 current_pseudolayer = self->pseudolayer;
30 *self->state = IDLE; // does not have effect if the state was RESTART
31 break;
32 default:
33 break;
34 }
35}
36
37void key_mod_dance(const struct Chord* self) {
38 switch (*self->state) {
39 case ACTIVATED:
40 key_in(self->value2);
41 a_key_went_through = false;
42 break;
43 case DEACTIVATED:
44 case RESTART:
45 key_out(self->value2);
46 if (!a_key_went_through) {
47 tap_key(self->value1);
48 }
49 *self->state = IDLE; // does not have effect if the state was RESTART
50 break;
51 default:
52 break;
53 }
54}
55
56void key_key_dance(const struct Chord* self) {
57 switch (*self->state) {
58 case ACTIVATED:
59 break;
60 case DEACTIVATED:
61 tap_key(self->value1);
62 *self->state = IDLE;
63 break;
64 case FINISHED:
65 case PRESS_FROM_ACTIVE:
66 key_in(self->value2);
67 break;
68 case RESTART:
69 key_out(self->value2);
70 break;
71 default:
72 break;
73 }
74}
75
76void autoshift_dance_impl(const struct Chord* self) {
77 switch (*self->state) {
78 case ACTIVATED:
79 *self->counter = 0;
80 break;
81 case DEACTIVATED:
82 case RESTART:
83 tap_key(self->value1);
84 *self->state = IDLE;
85 break;
86 case FINISHED_FROM_ACTIVE:
87 if (*self->counter == (LONG_PRESS_MULTIPLIER - 2)) {
88 key_in(KC_LSFT);
89 tap_key(self->value1);
90 key_out(KC_LSFT);
91 *self->state = IDLE;
92 // the skip to IDLE is usually just a lag optimization,
93 // in this case it has a logic function, on a short
94 // press (still longer than a tap) the key does not get shifted
95 } else {
96 *self->counter += 1;
97 *self->state = PRESS_FROM_ACTIVE;
98 dance_timer = timer_read();
99 }
100 break;
101 default:
102 break;
103 }
104}
105
106void autoshift_dance(const struct Chord* self) {
107 if (autoshift_mode) {
108 autoshift_dance_impl(self);
109 } else {
110 single_dance(self);
111 }
112}
113
114void autoshift_toggle(const struct Chord* self){
115 if (*self->state == ACTIVATED) {
116 autoshift_mode = !autoshift_mode;
117 *self->state = IDLE;
118 }
119}
120
121void temp_pseudolayer(const struct Chord* self) {
122 switch (*self->state) {
123 case ACTIVATED:
124 current_pseudolayer = self->value1;
125 break;
126 case DEACTIVATED:
127 current_pseudolayer = self->pseudolayer;
128 *self->state = IDLE;
129 break;
130 case RESTART:
131 current_pseudolayer = self->pseudolayer;
132 break;
133 default:
134 break;
135 }
136}
137
138void temp_pseudolayer_alt(const struct Chord* self) {
139 switch (*self->state) {
140 case ACTIVATED:
141 current_pseudolayer = self->value1;
142 break;
143 case DEACTIVATED:
144 current_pseudolayer = self->value2;
145 *self->state = IDLE;
146 break;
147 case RESTART:
148 current_pseudolayer = self->value2;
149 break;
150 default:
151 break;
152 }
153}
154
155void perm_pseudolayer(const struct Chord* self) {
156 if (*self->state == ACTIVATED) {
157 current_pseudolayer = self->value1;
158 *self->state = IDLE;
159 }
160}
161
162void switch_layer(const struct Chord* self) {
163 if (*self->state == ACTIVATED) {
164 layer_move(self->value1);
165 *self->state = IDLE;
166 }
167}
168
169void lock(const struct Chord* self) {
170 if (*self->state == ACTIVATED) {
171 lock_next = true;
172 *self->state = IDLE;
173 }
174}
175
176void one_shot_key(const struct Chord* self) {
177 switch (*self->state) {
178 case ACTIVATED:
179 break;
180 case DEACTIVATED:
181 key_in(self->value1);
182 *self->state = IN_ONE_SHOT;
183 break;
184 case FINISHED:
185 case PRESS_FROM_ACTIVE:
186 key_in(self->value1);
187 a_key_went_through = false;
188 break;
189 case RESTART:
190 if (a_key_went_through) {
191 key_out(self->value1);
192 } else {
193 *self->state = IN_ONE_SHOT;
194 }
195 default:
196 break;
197 }
198}
199
200void one_shot_layer(const struct Chord* self) {
201 switch (*self->state) {
202 case ACTIVATED:
203 break;
204 case DEACTIVATED:
205 current_pseudolayer = self->value1;
206 *self->state = IN_ONE_SHOT;
207 break;
208 case FINISHED:
209 case PRESS_FROM_ACTIVE:
210 current_pseudolayer = self->value1;
211 a_key_went_through = false;
212 break;
213 case RESTART:
214 if (a_key_went_through) {
215 current_pseudolayer = self->pseudolayer;
216 } else {
217 *self->state = IN_ONE_SHOT;
218 }
219 default:
220 break;
221 }
222}
223
224void command(const struct Chord* self) {
225 if (*self->state == ACTIVATED) {
226 command_mode++;
227 *self->state = IDLE;
228 }
229}
230
231bool identical(uint16_t* buffer1, uint16_t* buffer2) {
232 bool same = true;
233 for (int i = 0; i < LEADER_MAX_LENGTH; i++) {
234 same = same && (buffer1[i] == buffer2[i]);
235 }
236 return same;
237}
238
239void leader(const struct Chord* self) {
240 if (*self->state == ACTIVATED) {
241 in_leader_mode = true;
242 *self->state = IDLE;
243 }
244}
245
246void dynamic_macro_record(const struct Chord* self) {
247 if (*self->state == ACTIVATED) {
248 for (int i = 0; i < DYNAMIC_MACRO_MAX_LENGTH; i++) {
249 dynamic_macro_buffer[i] = 0;
250 }
251 dynamic_macro_mode = true;
252 *self->state = IDLE;
253 }
254}
255
256void dynamic_macro_next(const struct Chord* self) {
257 if (*self->state == ACTIVATED) {
258 if (dynamic_macro_mode && dynamic_macro_ind < DYNAMIC_MACRO_MAX_LENGTH) {
259 dynamic_macro_buffer[dynamic_macro_ind] = 0;
260 dynamic_macro_ind++;
261 }
262 *self->state = IDLE;
263 }
264}
265
266void dynamic_macro_end(const struct Chord* self) {
267 if (*self->state == ACTIVATED) {
268 if (dynamic_macro_mode) {
269 dynamic_macro_mode = false;
270 }
271 *self->state = IDLE;
272 }
273}
274
275void dynamic_macro_play(const struct Chord* self) {
276 if (*self->state == ACTIVATED) {
277 int ind_start = 0;
278 while (ind_start < DYNAMIC_MACRO_MAX_LENGTH) {
279 for (int i = ind_start; i < DYNAMIC_MACRO_MAX_LENGTH; i++) {
280 if (dynamic_macro_buffer[i] == 0) {
281 break;
282 }
283 register_code(dynamic_macro_buffer[i]);
284 }
285 send_keyboard_report();
286 wait_ms(TAP_TIMEOUT);
287 for (int i = ind_start; i < DYNAMIC_MACRO_MAX_LENGTH; i++) {
288 if (dynamic_macro_buffer[i] == 0) {
289 ind_start = i + 1;
290 break;
291 }
292 unregister_code(dynamic_macro_buffer[i]);
293 }
294 send_keyboard_report();
295 }
296 *self->state = IDLE;
297 }
298}
299
300void string_in(const struct Chord* self) {
301 if (*self->state == ACTIVATED) {
302 char buffer[STRING_MAX_LENGTH];
303 strcpy_P(buffer, (char*)pgm_read_word(&(strings[self->value1])));
304 send_string(buffer);
305 }
306}
307
308void clear(const struct Chord* self);
309
310void reset_keyboard_kb(void){
311#ifdef WATCHDOG_ENABLE
312 MCUSR = 0;
313 wdt_disable();
314 wdt_reset();
315#endif
316 reset_keyboard();
317}
318
319void reset(const struct Chord* self) {
320 if (*self->state == ACTIVATED) {
321 reset_keyboard_kb();
322 }
323}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-15 18:17:54 +0000