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 0x00:
 104                         // Oneshot modifier
 105                         if (event.pressed) {
 106                             if (tap_count == 0) {
 107                                 dprint("MODS_TAP: Oneshot: add_mods\n");
 108                                 register_mods(mods);
 109                             }
 110                             else if (tap_count == 1) {
 111                                 dprint("MODS_TAP: Oneshot: start\n");
 112                                 set_oneshot_mods(mods);
 113                             }
 114                             else if (tap_count == TAPPING_TOGGLE) {
 115                                 dprint("MODS_TAP: Oneshot: toggle\n");
 116                                 oneshot_toggle();
 117                             }
 118                             else {
 119                                 dprint("MODS_TAP: Oneshot: cancel&add_mods\n");
 120                                 // double tap cancels oneshot and works as normal modifier.
 121                                 clear_oneshot_mods();
 122                                 register_mods(mods);
 123                             }
 124                         } else {
 125                             if (tap_count == 0) {
 126                                 dprint("MODS_TAP: Oneshot: cancel/del_mods\n");
 127                                 // cancel oneshot on hold
 128                                 clear_oneshot_mods();
 129                                 unregister_mods(mods);
 130                             }
 131                             else if (tap_count == 1) {
 132                                 // Oneshot
 133                             }
 134                             else {
 135                                 dprint("MODS_TAP: Oneshot: del_mods\n");
 136                                 // cancel Mods
 137                                 unregister_mods(mods);
 138                             }
 139                         }
 140                         break;
 141     #endif
 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.id) {
 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                 }
 311             }
 312             break;
 313 #endif
 314         case ACT_COMMAND:
 315             break;
 316 #ifndef NO_ACTION_FUNCTION
 317         case ACT_FUNCTION:
 318             action_function(record, action.func.id, action.func.opt);
 319             break;
 320 #endif
 321         default:
 322             break;
 323     }
 324 }
 325
 326
 327
 328
 329 /*
 330  * Utilities for actions.
 331  */
 332 void register_code(uint8_t code)
 333 {
 334     if (code == KC_NO) {
 335         return;
 336     }
 337
 338 #ifdef LOCKING_SUPPORT_ENABLE
 339     else if (KC_LOCKING_CAPS == code) {
 340 #ifdef LOCKING_RESYNC_ENABLE
 341         // Resync: ignore if caps lock already is on
 342         if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) return;
 343 #endif
 344         add_key(KC_CAPSLOCK);
 345         send_keyboard_report();
 346         del_key(KC_CAPSLOCK);
 347         send_keyboard_report();
 348     }
 349
 350     else if (KC_LOCKING_NUM == code) {
 351 #ifdef LOCKING_RESYNC_ENABLE
 352         if (host_keyboard_leds() & (1<<USB_LED_NUM_LOCK)) return;
 353 #endif
 354         add_key(KC_NUMLOCK);
 355         send_keyboard_report();
 356         del_key(KC_NUMLOCK);
 357         send_keyboard_report();
 358     }
 359
 360     else if (KC_LOCKING_SCROLL == code) {
 361 #ifdef LOCKING_RESYNC_ENABLE
 362         if (host_keyboard_leds() & (1<<USB_LED_SCROLL_LOCK)) return;
 363 #endif
 364         add_key(KC_SCROLLLOCK);
 365         send_keyboard_report();
 366         del_key(KC_SCROLLLOCK);
 367         send_keyboard_report();
 368     }
 369 #endif
 370
 371     else if IS_KEY(code) {
 372         // TODO: should push command_proc out of this block?
 373         if (command_proc(code)) return;
 374
 375 #ifndef NO_ACTION_ONESHOT
 376 /* TODO: remove
 377         if (oneshot_state.mods && !oneshot_state.disabled) {
 378             uint8_t tmp_mods = get_mods();
 379             add_mods(oneshot_state.mods);
 380
 381             add_key(code);
 382             send_keyboard_report();
 383
 384             set_mods(tmp_mods);
 385             send_keyboard_report();
 386             oneshot_cancel();
 387         } else
 388 */
 389 #endif
 390         {
 391             add_key(code);
 392             send_keyboard_report();
 393         }
 394     }
 395     else if IS_MOD(code) {
 396         add_mods(MOD_BIT(code));
 397         send_keyboard_report();
 398     }
 399     else if IS_SYSTEM(code) {
 400         host_system_send(KEYCODE2SYSTEM(code));
 401     }
 402     else if IS_CONSUMER(code) {
 403         host_consumer_send(KEYCODE2CONSUMER(code));
 404     }
 405 }
 406
 407 void unregister_code(uint8_t code)
 408 {
 409     if (code == KC_NO) {
 410         return;
 411     }
 412
 413 #ifdef LOCKING_SUPPORT_ENABLE
 414     else if (KC_LOCKING_CAPS == code) {
 415 #ifdef LOCKING_RESYNC_ENABLE
 416         // Resync: ignore if caps lock already is off
 417         if (!(host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK))) return;
 418 #endif
 419         add_key(KC_CAPSLOCK);
 420         send_keyboard_report();
 421         del_key(KC_CAPSLOCK);
 422         send_keyboard_report();
 423     }
 424
 425     else if (KC_LOCKING_NUM == code) {
 426 #ifdef LOCKING_RESYNC_ENABLE
 427         if (!(host_keyboard_leds() & (1<<USB_LED_NUM_LOCK))) return;
 428 #endif
 429         add_key(KC_NUMLOCK);
 430         send_keyboard_report();
 431         del_key(KC_NUMLOCK);
 432         send_keyboard_report();
 433     }
 434
 435     else if (KC_LOCKING_SCROLL == code) {
 436 #ifdef LOCKING_RESYNC_ENABLE
 437         if (!(host_keyboard_leds() & (1<<USB_LED_SCROLL_LOCK))) return;
 438 #endif
 439         add_key(KC_SCROLLLOCK);
 440         send_keyboard_report();
 441         del_key(KC_SCROLLLOCK);
 442         send_keyboard_report();
 443     }
 444 #endif
 445
 446     else if IS_KEY(code) {
 447         del_key(code);
 448         send_keyboard_report();
 449     }
 450     else if IS_MOD(code) {
 451         del_mods(MOD_BIT(code));
 452         send_keyboard_report();
 453     }
 454     else if IS_SYSTEM(code) {
 455         host_system_send(0);
 456     }
 457     else if IS_CONSUMER(code) {
 458         host_consumer_send(0);
 459     }
 460 }
 461
 462 void register_mods(uint8_t mods)
 463 {
 464     if (mods) {
 465         add_mods(mods);
 466         send_keyboard_report();
 467     }
 468 }
 469
 470 void unregister_mods(uint8_t mods)
 471 {
 472     if (mods) {
 473         del_mods(mods);
 474         send_keyboard_report();
 475     }
 476 }
 477
 478 void clear_keyboard(void)
 479 {
 480     clear_mods();
 481     clear_keyboard_but_mods();
 482 }
 483
 484 void clear_keyboard_but_mods(void)
 485 {
 486     clear_weak_mods();
 487     clear_keys();
 488     send_keyboard_report();
 489 #ifdef MOUSEKEY_ENABLE
 490     mousekey_clear();
 491     mousekey_send();
 492 #endif
 493 #ifdef EXTRAKEY_ENABLE
 494     host_system_send(0);
 495     host_consumer_send(0);
 496 #endif
 497 }
 498
 499 bool sending_anykey(void)
 500 {
 501     return (has_anykey() || host_mouse_in_use() ||
 502             host_last_sysytem_report() || host_last_consumer_report());
 503 }
 504
 505 bool is_tap_key(key_t key)
 506 {
 507     action_t action = layer_switch_get_action(key);
 508
 509     switch (action.kind.id) {
 510         case ACT_LMODS_TAP:
 511         case ACT_RMODS_TAP:
 512         case ACT_LAYER_TAP:
 513         case ACT_LAYER_TAP_EXT:
 514             return true;
 515         case ACT_MACRO:
 516         case ACT_FUNCTION:
 517             if (action.func.opt & FUNC_TAP) { return true; }
 518             return false;
 519     }
 520     return false;
 521 }
 522
 523
 524 /*
 525  * debug print
 526  */
 527 void debug_event(keyevent_t event)
 528 {
 529     dprintf("%04X%c(%u)", (event.key.row<<8 | event.key.col), (event.pressed ? 'd' : 'u'), event.time);
 530 }
 531
 532 void debug_record(keyrecord_t record)
 533 {
 534     debug_event(record.event);
 535 #ifndef NO_ACTION_TAPPING
 536     dprintf(":%u%c", record.tap.count, (record.tap.interrupted ? '-' : ' '));
 537 #endif
 538 }
 539
 540 void debug_action(action_t action)
 541 {
 542     switch (action.kind.id) {
 543         case ACT_LMODS:             dprint("ACT_LMODS");             break;
 544         case ACT_RMODS:             dprint("ACT_RMODS");             break;
 545         case ACT_LMODS_TAP:         dprint("ACT_LMODS_TAP");         break;
 546         case ACT_RMODS_TAP:         dprint("ACT_RMODS_TAP");         break;
 547         case ACT_USAGE:             dprint("ACT_USAGE");             break;
 548         case ACT_MOUSEKEY:          dprint("ACT_MOUSEKEY");          break;
 549         case ACT_LAYER:             dprint("ACT_LAYER");             break;
 550         case ACT_LAYER_TAP:         dprint("ACT_LAYER_TAP");         break;
 551         case ACT_LAYER_TAP_EXT:     dprint("ACT_LAYER_TAP_EXT");     break;
 552         case ACT_MACRO:             dprint("ACT_MACRO");             break;
 553         case ACT_COMMAND:           dprint("ACT_COMMAND");           break;
 554         case ACT_FUNCTION:          dprint("ACT_FUNCTION");          break;
 555         default:                    dprint("UNKNOWN");               break;
 556     }
 557     dprintf("[%X:%02X]", action.kind.param>>8, action.kind.param&0xff);
 558 }