fddb97c508dbd96865c73ef08bfd68cc1739b1ac
[tmk_keyboard.git] / common / action.c
1 /*
2 Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17 #include "host.h"
18 #include "keycode.h"
19 #include "keyboard.h"
20 #include "mousekey.h"
21 #include "command.h"
22 #include "led.h"
23 #include "backlight.h"
24 #include "action_layer.h"
25 #include "action_tapping.h"
26 #include "action_macro.h"
27 #include "action_util.h"
28 #include "action.h"
29
30 #ifdef DEBUG_ACTION
31 #include "debug.h"
32 #else
33 #include "nodebug.h"
34 #endif
35
36
37 void action_exec(keyevent_t event)
38 {
39 if (!IS_NOEVENT(event)) {
40 dprint("\n---- action_exec: start -----\n");
41 dprint("EVENT: "); debug_event(event); dprintln();
42 }
43
44 keyrecord_t record = { .event = event };
45
46 #ifndef NO_ACTION_TAPPING
47 action_tapping_process(record);
48 #else
49 process_action(&record);
50 if (!IS_NOEVENT(record.event)) {
51 dprint("processed: "); debug_record(record); dprintln();
52 }
53 #endif
54 }
55
56 void process_action(keyrecord_t *record)
57 {
58 keyevent_t event = record->event;
59 #ifndef NO_ACTION_TAPPING
60 uint8_t tap_count = record->tap.count;
61 #endif
62
63 if (IS_NOEVENT(event)) { return; }
64
65 action_t action = layer_switch_get_action(event.key);
66 dprint("ACTION: "); debug_action(action);
67 #ifndef NO_ACTION_LAYER
68 dprint(" layer_state: "); layer_debug();
69 dprint(" default_layer_state: "); default_layer_debug();
70 #endif
71 dprintln();
72
73 switch (action.kind.id) {
74 /* Key and Mods */
75 case ACT_LMODS:
76 case ACT_RMODS:
77 {
78 uint8_t mods = (action.kind.id == ACT_LMODS) ? action.key.mods :
79 action.key.mods<<4;
80 if (event.pressed) {
81 if (mods) {
82 add_weak_mods(mods);
83 send_keyboard_report();
84 }
85 register_code(action.key.code);
86 } else {
87 unregister_code(action.key.code);
88 if (mods) {
89 del_weak_mods(mods);
90 send_keyboard_report();
91 }
92 }
93 }
94 break;
95 #ifndef NO_ACTION_TAPPING
96 case ACT_LMODS_TAP:
97 case ACT_RMODS_TAP:
98 {
99 uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods :
100 action.key.mods<<4;
101 switch (action.layer_tap.code) {
102 #ifndef NO_ACTION_ONESHOT
103 case MODS_ONESHOT:
104 // Oneshot modifier
105 if (event.pressed) {
106 if (tap_count == 0) {
107 register_mods(mods);
108 }
109 else if (tap_count == 1) {
110 dprint("MODS_TAP: Oneshot: start\n");
111 set_oneshot_mods(mods);
112 }
113 else {
114 register_mods(mods);
115 }
116 } else {
117 if (tap_count == 0) {
118 clear_oneshot_mods();
119 unregister_mods(mods);
120 }
121 else if (tap_count == 1) {
122 // Retain Oneshot mods
123 }
124 else {
125 clear_oneshot_mods();
126 unregister_mods(mods);
127 }
128 }
129 break;
130 #endif
131 case MODS_TAP_TOGGLE:
132 if (event.pressed) {
133 if (tap_count <= TAPPING_TOGGLE) {
134 register_mods(mods);
135 }
136 } else {
137 if (tap_count < TAPPING_TOGGLE) {
138 unregister_mods(mods);
139 }
140 }
141 break;
142 default:
143 if (event.pressed) {
144 if (tap_count > 0) {
145 if (record->tap.interrupted) {
146 dprint("MODS_TAP: Tap: Cancel: add_mods\n");
147 // ad hoc: set 0 to cancel tap
148 record->tap.count = 0;
149 register_mods(mods);
150 } else {
151 dprint("MODS_TAP: Tap: register_code\n");
152 register_code(action.key.code);
153 }
154 } else {
155 dprint("MODS_TAP: No tap: add_mods\n");
156 register_mods(mods);
157 }
158 } else {
159 if (tap_count > 0) {
160 dprint("MODS_TAP: Tap: unregister_code\n");
161 unregister_code(action.key.code);
162 } else {
163 dprint("MODS_TAP: No tap: add_mods\n");
164 unregister_mods(mods);
165 }
166 }
167 break;
168 }
169 }
170 break;
171 #endif
172 #ifdef EXTRAKEY_ENABLE
173 /* other HID usage */
174 case ACT_USAGE:
175 switch (action.usage.page) {
176 case PAGE_SYSTEM:
177 if (event.pressed) {
178 host_system_send(action.usage.code);
179 } else {
180 host_system_send(0);
181 }
182 break;
183 case PAGE_CONSUMER:
184 if (event.pressed) {
185 host_consumer_send(action.usage.code);
186 } else {
187 host_consumer_send(0);
188 }
189 break;
190 }
191 break;
192 #endif
193 #ifdef MOUSEKEY_ENABLE
194 /* Mouse key */
195 case ACT_MOUSEKEY:
196 if (event.pressed) {
197 mousekey_on(action.key.code);
198 mousekey_send();
199 } else {
200 mousekey_off(action.key.code);
201 mousekey_send();
202 }
203 break;
204 #endif
205 #ifndef NO_ACTION_LAYER
206 case ACT_LAYER:
207 if (action.layer_bitop.on == 0) {
208 /* Default Layer Bitwise Operation */
209 if (!event.pressed) {
210 uint8_t shift = action.layer_bitop.part*4;
211 uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
212 uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
213 switch (action.layer_bitop.op) {
214 case OP_BIT_AND: default_layer_and(bits | mask); break;
215 case OP_BIT_OR: default_layer_or(bits | mask); break;
216 case OP_BIT_XOR: default_layer_xor(bits | mask); break;
217 case OP_BIT_SET: default_layer_and(mask); default_layer_or(bits); break;
218 }
219 }
220 } else {
221 /* Layer Bitwise Operation */
222 if (event.pressed ? (action.layer_bitop.on & ON_PRESS) :
223 (action.layer_bitop.on & ON_RELEASE)) {
224 uint8_t shift = action.layer_bitop.part*4;
225 uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
226 uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
227 switch (action.layer_bitop.op) {
228 case OP_BIT_AND: layer_and(bits | mask); break;
229 case OP_BIT_OR: layer_or(bits | mask); break;
230 case OP_BIT_XOR: layer_xor(bits | mask); break;
231 case OP_BIT_SET: layer_and(mask); layer_or(bits); break;
232 }
233 }
234 }
235 break;
236 #ifndef NO_ACTION_TAPPING
237 case ACT_LAYER_TAP:
238 case ACT_LAYER_TAP_EXT:
239 switch (action.layer_tap.code) {
240 case OP_TAP_TOGGLE:
241 /* tap toggle */
242 if (event.pressed) {
243 if (tap_count < TAPPING_TOGGLE) {
244 layer_invert(action.layer_tap.val);
245 }
246 } else {
247 if (tap_count <= TAPPING_TOGGLE) {
248 layer_invert(action.layer_tap.val);
249 }
250 }
251 break;
252 case OP_ON_OFF:
253 event.pressed ? layer_on(action.layer_tap.val) :
254 layer_off(action.layer_tap.val);
255 break;
256 case OP_OFF_ON:
257 event.pressed ? layer_off(action.layer_tap.val) :
258 layer_on(action.layer_tap.val);
259 break;
260 case OP_SET_CLEAR:
261 event.pressed ? layer_move(action.layer_tap.val) :
262 layer_clear();
263 break;
264 default:
265 /* tap key */
266 if (event.pressed) {
267 if (tap_count > 0) {
268 dprint("KEYMAP_TAP_KEY: Tap: register_code\n");
269 register_code(action.layer_tap.code);
270 } else {
271 dprint("KEYMAP_TAP_KEY: No tap: On on press\n");
272 layer_on(action.layer_tap.val);
273 }
274 } else {
275 if (tap_count > 0) {
276 dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n");
277 unregister_code(action.layer_tap.code);
278 } else {
279 dprint("KEYMAP_TAP_KEY: No tap: Off on release\n");
280 layer_off(action.layer_tap.val);
281 }
282 }
283 break;
284 }
285 break;
286 #endif
287 #endif
288 /* Extentions */
289 #ifndef NO_ACTION_MACRO
290 case ACT_MACRO:
291 action_macro_play(action_get_macro(record, action.func.id, action.func.opt));
292 break;
293 #endif
294 #ifdef BACKLIGHT_ENABLE
295 case ACT_BACKLIGHT:
296 if (!event.pressed) {
297 switch (action.backlight.opt) {
298 case BACKLIGHT_INCREASE:
299 backlight_increase();
300 break;
301 case BACKLIGHT_DECREASE:
302 backlight_decrease();
303 break;
304 case BACKLIGHT_TOGGLE:
305 backlight_toggle();
306 break;
307 case BACKLIGHT_STEP:
308 backlight_step();
309 break;
310 case BACKLIGHT_LEVEL:
311 backlight_level(action.backlight.level);
312 break;
313 }
314 }
315 break;
316 #endif
317 case ACT_COMMAND:
318 break;
319 #ifndef NO_ACTION_FUNCTION
320 case ACT_FUNCTION:
321 action_function(record, action.func.id, action.func.opt);
322 break;
323 #endif
324 default:
325 break;
326 }
327 }
328
329
330
331
332 /*
333 * Utilities for actions.
334 */
335 void register_code(uint8_t code)
336 {
337 if (code == KC_NO) {
338 return;
339 }
340
341 #ifdef LOCKING_SUPPORT_ENABLE
342 else if (KC_LOCKING_CAPS == code) {
343 #ifdef LOCKING_RESYNC_ENABLE
344 // Resync: ignore if caps lock already is on
345 if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) return;
346 #endif
347 add_key(KC_CAPSLOCK);
348 send_keyboard_report();
349 del_key(KC_CAPSLOCK);
350 send_keyboard_report();
351 }
352
353 else if (KC_LOCKING_NUM == code) {
354 #ifdef LOCKING_RESYNC_ENABLE
355 if (host_keyboard_leds() & (1<<USB_LED_NUM_LOCK)) return;
356 #endif
357 add_key(KC_NUMLOCK);
358 send_keyboard_report();
359 del_key(KC_NUMLOCK);
360 send_keyboard_report();
361 }
362
363 else if (KC_LOCKING_SCROLL == code) {
364 #ifdef LOCKING_RESYNC_ENABLE
365 if (host_keyboard_leds() & (1<<USB_LED_SCROLL_LOCK)) return;
366 #endif
367 add_key(KC_SCROLLLOCK);
368 send_keyboard_report();
369 del_key(KC_SCROLLLOCK);
370 send_keyboard_report();
371 }
372 #endif
373
374 else if IS_KEY(code) {
375 // TODO: should push command_proc out of this block?
376 if (command_proc(code)) return;
377
378 #ifndef NO_ACTION_ONESHOT
379 /* TODO: remove
380 if (oneshot_state.mods && !oneshot_state.disabled) {
381 uint8_t tmp_mods = get_mods();
382 add_mods(oneshot_state.mods);
383
384 add_key(code);
385 send_keyboard_report();
386
387 set_mods(tmp_mods);
388 send_keyboard_report();
389 oneshot_cancel();
390 } else
391 */
392 #endif
393 {
394 add_key(code);
395 send_keyboard_report();
396 }
397 }
398 else if IS_MOD(code) {
399 add_mods(MOD_BIT(code));
400 send_keyboard_report();
401 }
402 else if IS_SYSTEM(code) {
403 host_system_send(KEYCODE2SYSTEM(code));
404 }
405 else if IS_CONSUMER(code) {
406 host_consumer_send(KEYCODE2CONSUMER(code));
407 }
408 }
409
410 void unregister_code(uint8_t code)
411 {
412 if (code == KC_NO) {
413 return;
414 }
415
416 #ifdef LOCKING_SUPPORT_ENABLE
417 else if (KC_LOCKING_CAPS == code) {
418 #ifdef LOCKING_RESYNC_ENABLE
419 // Resync: ignore if caps lock already is off
420 if (!(host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK))) return;
421 #endif
422 add_key(KC_CAPSLOCK);
423 send_keyboard_report();
424 del_key(KC_CAPSLOCK);
425 send_keyboard_report();
426 }
427
428 else if (KC_LOCKING_NUM == code) {
429 #ifdef LOCKING_RESYNC_ENABLE
430 if (!(host_keyboard_leds() & (1<<USB_LED_NUM_LOCK))) return;
431 #endif
432 add_key(KC_NUMLOCK);
433 send_keyboard_report();
434 del_key(KC_NUMLOCK);
435 send_keyboard_report();
436 }
437
438 else if (KC_LOCKING_SCROLL == code) {
439 #ifdef LOCKING_RESYNC_ENABLE
440 if (!(host_keyboard_leds() & (1<<USB_LED_SCROLL_LOCK))) return;
441 #endif
442 add_key(KC_SCROLLLOCK);
443 send_keyboard_report();
444 del_key(KC_SCROLLLOCK);
445 send_keyboard_report();
446 }
447 #endif
448
449 else if IS_KEY(code) {
450 del_key(code);
451 send_keyboard_report();
452 }
453 else if IS_MOD(code) {
454 del_mods(MOD_BIT(code));
455 send_keyboard_report();
456 }
457 else if IS_SYSTEM(code) {
458 host_system_send(0);
459 }
460 else if IS_CONSUMER(code) {
461 host_consumer_send(0);
462 }
463 }
464
465 void register_mods(uint8_t mods)
466 {
467 if (mods) {
468 add_mods(mods);
469 send_keyboard_report();
470 }
471 }
472
473 void unregister_mods(uint8_t mods)
474 {
475 if (mods) {
476 del_mods(mods);
477 send_keyboard_report();
478 }
479 }
480
481 void clear_keyboard(void)
482 {
483 clear_mods();
484 clear_keyboard_but_mods();
485 }
486
487 void clear_keyboard_but_mods(void)
488 {
489 clear_weak_mods();
490 clear_keys();
491 send_keyboard_report();
492 #ifdef MOUSEKEY_ENABLE
493 mousekey_clear();
494 mousekey_send();
495 #endif
496 #ifdef EXTRAKEY_ENABLE
497 host_system_send(0);
498 host_consumer_send(0);
499 #endif
500 }
501
502 bool is_tap_key(key_t key)
503 {
504 action_t action = layer_switch_get_action(key);
505
506 switch (action.kind.id) {
507 case ACT_LMODS_TAP:
508 case ACT_RMODS_TAP:
509 case ACT_LAYER_TAP:
510 case ACT_LAYER_TAP_EXT:
511 return true;
512 case ACT_MACRO:
513 case ACT_FUNCTION:
514 if (action.func.opt & FUNC_TAP) { return true; }
515 return false;
516 }
517 return false;
518 }
519
520
521 /*
522 * debug print
523 */
524 void debug_event(keyevent_t event)
525 {
526 dprintf("%04X%c(%u)", (event.key.row<<8 | event.key.col), (event.pressed ? 'd' : 'u'), event.time);
527 }
528
529 void debug_record(keyrecord_t record)
530 {
531 debug_event(record.event);
532 #ifndef NO_ACTION_TAPPING
533 dprintf(":%u%c", record.tap.count, (record.tap.interrupted ? '-' : ' '));
534 #endif
535 }
536
537 void debug_action(action_t action)
538 {
539 switch (action.kind.id) {
540 case ACT_LMODS: dprint("ACT_LMODS"); break;
541 case ACT_RMODS: dprint("ACT_RMODS"); break;
542 case ACT_LMODS_TAP: dprint("ACT_LMODS_TAP"); break;
543 case ACT_RMODS_TAP: dprint("ACT_RMODS_TAP"); break;
544 case ACT_USAGE: dprint("ACT_USAGE"); break;
545 case ACT_MOUSEKEY: dprint("ACT_MOUSEKEY"); break;
546 case ACT_LAYER: dprint("ACT_LAYER"); break;
547 case ACT_LAYER_TAP: dprint("ACT_LAYER_TAP"); break;
548 case ACT_LAYER_TAP_EXT: dprint("ACT_LAYER_TAP_EXT"); break;
549 case ACT_MACRO: dprint("ACT_MACRO"); break;
550 case ACT_COMMAND: dprint("ACT_COMMAND"); break;
551 case ACT_FUNCTION: dprint("ACT_FUNCTION"); break;
552 default: dprint("UNKNOWN"); break;
553 }
554 dprintf("[%X:%02X]", action.kind.param>>8, action.kind.param&0xff);
555 }
Imprint / Impressum