Ejemplo n.º 1
0
void action_macro_play(const macro_t *macro_p)
{
    macro_t macro = END;
    uint8_t interval = 0;

    if (!macro_p) return;
    while (true) {
        switch (MACRO_READ()) {
            case KEY_DOWN:
                MACRO_READ();
                dprintf("KEY_DOWN(%02X)\n", macro);
                if (IS_MOD(macro)) {
                    add_macro_mods(MOD_BIT(macro));
                    send_keyboard_report();
                } else {
                    register_code(macro);
                }
                break;
            case KEY_UP:
                MACRO_READ();
                dprintf("KEY_UP(%02X)\n", macro);
                if (IS_MOD(macro)) {
                    del_macro_mods(MOD_BIT(macro));
                    send_keyboard_report();
                } else {
                    unregister_code(macro);
                }
                break;
            case WAIT:
                MACRO_READ();
                dprintf("WAIT(%u)\n", macro);
                { uint8_t ms = macro; while (ms--) wait_ms(1); }
                break;
            case INTERVAL:
                interval = MACRO_READ();
                dprintf("INTERVAL(%u)\n", interval);
                break;
            case 0x04 ... 0x73:
                dprintf("DOWN(%02X)\n", macro);
                register_code(macro);
                break;
            case 0x84 ... 0xF3:
                dprintf("UP(%02X)\n", macro);
                unregister_code(macro&0x7F);
                break;
            case END:
            default:
                return;
        }
        // interval
        { uint8_t ms = interval; while (ms--) wait_ms(1); }
    }
}
Ejemplo n.º 2
0
void unregister_code16 (uint16_t code) {
  unregister_code (code);
  if (IS_MOD(code) || code == KC_NO) {
      do_code16 (code, qk_unregister_mods);
  } else {
      do_code16 (code, qk_unregister_weak_mods);
  }
}
Ejemplo n.º 3
0
void event_keyup(int col, int row)
{
    __IO uint8_t *rep = kbd_report_scanning;
    uint8_t key;
    int i, j;

    key = keymaps[kbd_layer][col][row];

    if (IS_MOD(key)){
	switch (key){
	    case KC_LCTRL:
		rep[0] &= ~0x01;
		break;
	    case KC_LSHIFT:
		rep[0] &= ~0x02;
		break;
	    case KC_LALT:
		rep[0] &= ~0x04;
		break;
	    case KC_LGUI:
		rep[0] &= ~0x08;
		break;
	    case KC_RCTRL:
		rep[0] &= ~0x10;
		break;
	    case KC_RSHIFT:
		rep[0] &= ~0x20;
		break;
	    case KC_RALT:
		rep[0] &= ~0x40;
		break;
	    case KC_RGUI:
		rep[0] &= ~0x80;
		break;
	}
	kbd_report_status |= REPORT_STATUS_PROC;
    } else
    if (IS_KEY(key)){
	for (i=2;i<KBD_SIZE;i++){
	    if (rep[i] == key){
		for (j=i+1;j<KBD_SIZE;j++){
		    rep[j-1] = rep[j];
		}
		rep[KBD_SIZE-1] = 0;
		kbd_report_status |= REPORT_STATUS_PROC;
		break;
	    }
	}
    } else
    if (key == KC_FN1){
	kbd_release_keys();
	kbd_layer = 0;
	kbd_report_status |= REPORT_STATUS_PROC;
    }
}
Ejemplo n.º 4
0
/* return true when key event is processed or consumed. */
bool process_tapping(keyrecord_t *keyp)
{
    keyevent_t event = keyp->event;

    // if tapping
    if (IS_TAPPING_PRESSED()) {
        if (WITHIN_TAPPING_TERM(event)) {
            if (tapping_key.tap.count == 0) {
                if (IS_TAPPING_KEY(event.key) && !event.pressed) {
                    // first tap!
                    debug("Tapping: First tap(0->1).\n");
                    tapping_key.tap.count = 1;
                    debug_tapping_key();
                    process_action(&tapping_key);

                    // copy tapping state
                    keyp->tap = tapping_key.tap;
                    // enqueue
                    return false;
                }
#if TAPPING_TERM >= 500
                /* Process a key typed within TAPPING_TERM
                 * This can register the key before settlement of tapping,
                 * useful for long TAPPING_TERM but may prevent fast typing.
                 */
                else if (IS_RELEASED(event) && waiting_buffer_typed(event)) {
                    debug("Tapping: End. No tap. Interfered by typing key\n");
                    process_action(&tapping_key);
                    tapping_key = (keyrecord_t){};
                    debug_tapping_key();
                    // enqueue
                    return false;
                }
#endif
                /* Process release event of a key pressed before tapping starts
                 * Without this unexpected repeating will occur with having fast repeating setting
                 * https://github.com/tmk/tmk_keyboard/issues/60
                 */
                else if (IS_RELEASED(event) && !waiting_buffer_typed(event)) {
                    // Modifier should be retained till end of this tapping.
                    action_t action = layer_switch_get_action(event.key);
                    switch (action.kind.id) {
                        case ACT_LMODS:
                        case ACT_RMODS:
                            if (action.key.mods && !action.key.code) return false;
                            if (IS_MOD(action.key.code)) return false;
                            break;
                        case ACT_LMODS_TAP:
                        case ACT_RMODS_TAP:
                            if (action.key.mods && keyp->tap.count == 0) return false;
                            if (IS_MOD(action.key.code)) return false;
                            break;
                    }
                    // Release of key should be process immediately.
                    debug("Tapping: release event of a key pressed before tapping\n");
                    process_action(keyp);
                    return true;
                }
                else {
                    // set interrupted flag when other key preesed during tapping
                    if (event.pressed) {
                        tapping_key.tap.interrupted = true;
                    }
                    // enqueue 
                    return false;
                }
            }
            // tap_count > 0
            else {
                if (IS_TAPPING_KEY(event.key) && !event.pressed) {
                    debug("Tapping: Tap release("); debug_dec(tapping_key.tap.count); debug(")\n");
                    keyp->tap = tapping_key.tap;
                    process_action(keyp);
                    tapping_key = *keyp;
                    debug_tapping_key();
                    return true;
                }
                else if (is_tap_key(event.key) && event.pressed) {
                    if (tapping_key.tap.count > 1) {
                        debug("Tapping: Start new tap with releasing last tap(>1).\n");
                        // unregister key
                        process_action(&(keyrecord_t){
                                .tap = tapping_key.tap,
                                .event.key = tapping_key.event.key,
                                .event.time = event.time,
                                .event.pressed = false
                        });
                    } else {
                        debug("Tapping: Start while last tap(1).\n");
                    }
                    tapping_key = *keyp;
                    waiting_buffer_scan_tap();
                    debug_tapping_key();
                    return true;
                }
                else {
                    if (!IS_NOEVENT(event)) {
Ejemplo n.º 5
0
/** \brief Take an action and processes it.
 *
 * FIXME: Needs documentation.
 */
void process_action(keyrecord_t *record, action_t action)
{
    keyevent_t event = record->event;
#ifndef NO_ACTION_TAPPING
    uint8_t tap_count = record->tap.count;
#endif

    if (event.pressed) {
        // clear the potential weak mods left by previously pressed keys
        clear_weak_mods();
    }

#ifndef NO_ACTION_ONESHOT
    bool do_release_oneshot = false;
    // notice we only clear the one shot layer if the pressed key is not a modifier.
    if (is_oneshot_layer_active() && event.pressed && !IS_MOD(action.key.code)) {
        clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
        do_release_oneshot = !is_oneshot_layer_active();
    }
#endif

    switch (action.kind.id) {
        /* Key and Mods */
        case ACT_LMODS:
        case ACT_RMODS:
            {
                uint8_t mods = (action.kind.id == ACT_LMODS) ?  action.key.mods :
                                                                action.key.mods<<4;
                if (event.pressed) {
                    if (mods) {
                        if (IS_MOD(action.key.code) || action.key.code == KC_NO) {
                            // e.g. LSFT(KC_LGUI): we don't want the LSFT to be weak as it would make it useless.
                            // This also makes LSFT(KC_LGUI) behave exactly the same as LGUI(KC_LSFT).
                            // Same applies for some keys like KC_MEH which are declared as MEH(KC_NO).
                            add_mods(mods);
                        } else {
                            add_weak_mods(mods);
                        }
                        send_keyboard_report();
                    }
                    register_code(action.key.code);
                } else {
                    unregister_code(action.key.code);
                    if (mods) {
                        if (IS_MOD(action.key.code) || action.key.code == KC_NO) {
                            del_mods(mods);
                        } else {
                            del_weak_mods(mods);
                        }
                        send_keyboard_report();
                    }
                }
            }
            break;
#ifndef NO_ACTION_TAPPING
        case ACT_LMODS_TAP:
        case ACT_RMODS_TAP:
            {
                uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ?  action.key.mods :
                                                                    action.key.mods<<4;
                switch (action.layer_tap.code) {
    #ifndef NO_ACTION_ONESHOT
                    case MODS_ONESHOT:
                        // Oneshot modifier
                        if (event.pressed) {
                            if (tap_count == 0) {
                                dprint("MODS_TAP: Oneshot: 0\n");
                                register_mods(mods);
                            } else if (tap_count == 1) {
                                dprint("MODS_TAP: Oneshot: start\n");
                                set_oneshot_mods(mods);
                    #if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
                            } else if (tap_count == ONESHOT_TAP_TOGGLE) {
                                dprint("MODS_TAP: Toggling oneshot");
                                clear_oneshot_mods();
                                set_oneshot_locked_mods(mods);
                                register_mods(mods);
                    #endif
                            } else {
                                register_mods(mods);
                            }
                        } else {
                            if (tap_count == 0) {
                                clear_oneshot_mods();
                                unregister_mods(mods);
                            } else if (tap_count == 1) {
                                // Retain Oneshot mods
                    #if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
                                if (mods & get_mods()) {
                                    clear_oneshot_locked_mods();
                                    clear_oneshot_mods();
                                    unregister_mods(mods);
                                }
                            } else if (tap_count == ONESHOT_TAP_TOGGLE) {
                                // Toggle Oneshot Layer
                    #endif
                            } else {
                                clear_oneshot_mods();
                                unregister_mods(mods);
                            }
                        }
                        break;
    #endif
                    case MODS_TAP_TOGGLE:
                        if (event.pressed) {
                            if (tap_count <= TAPPING_TOGGLE) {
                                register_mods(mods);
                            }
                        } else {
                            if (tap_count < TAPPING_TOGGLE) {
                                unregister_mods(mods);
                            }
                        }
                        break;
                    default:
                        if (event.pressed) {
                            if (tap_count > 0) {
#ifndef IGNORE_MOD_TAP_INTERRUPT
                                if (record->tap.interrupted) {
                                    dprint("mods_tap: tap: cancel: add_mods\n");
                                    // ad hoc: set 0 to cancel tap
                                    record->tap.count = 0;
                                    register_mods(mods);
                                } else
#endif
                                {
                                    dprint("MODS_TAP: Tap: register_code\n");
                                    register_code(action.key.code);
                                }
                            } else {
                                dprint("MODS_TAP: No tap: add_mods\n");
                                register_mods(mods);
                            }
                        } else {
                            if (tap_count > 0) {
                                dprint("MODS_TAP: Tap: unregister_code\n");
                                unregister_code(action.key.code);
                            } else {
                                dprint("MODS_TAP: No tap: add_mods\n");
                                unregister_mods(mods);
                            }
                        }
                        break;
                }
            }
            break;
#endif
#ifdef EXTRAKEY_ENABLE
        /* other HID usage */
        case ACT_USAGE:
            switch (action.usage.page) {
                case PAGE_SYSTEM:
                    if (event.pressed) {
                        host_system_send(action.usage.code);
                    } else {
                        host_system_send(0);
                    }
                    break;
                case PAGE_CONSUMER:
                    if (event.pressed) {
                        host_consumer_send(action.usage.code);
                    } else {
                        host_consumer_send(0);
                    }
                    break;
            }
            break;
#endif
#ifdef MOUSEKEY_ENABLE
        /* Mouse key */
        case ACT_MOUSEKEY:
            if (event.pressed) {
                switch (action.key.code) {
                    case KC_MS_BTN1:
                        tp_buttons |= (1<<0);
                        break;
                    case KC_MS_BTN2:
                        tp_buttons |= (1<<1);
                        break;
                    case KC_MS_BTN3:
                        tp_buttons |= (1<<2);
                        break;
                    default:
                        break;
                }
                mousekey_on(action.key.code);
                mousekey_send();
            } else {
                switch (action.key.code) {
                    case KC_MS_BTN1:
                        tp_buttons &= ~(1<<0);
                        break;
                    case KC_MS_BTN2:
                        tp_buttons &= ~(1<<1);
                        break;
                    case KC_MS_BTN3:
                        tp_buttons &= ~(1<<2);
                        break;
                    default:
                        break;
                }
                mousekey_off(action.key.code);
                mousekey_send();
            }
            break;
#endif
#ifndef NO_ACTION_LAYER
        case ACT_LAYER:
            if (action.layer_bitop.on == 0) {
                /* Default Layer Bitwise Operation */
                if (!event.pressed) {
                    uint8_t shift = action.layer_bitop.part*4;
                    uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
                    uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
                    switch (action.layer_bitop.op) {
                        case OP_BIT_AND: default_layer_and(bits | mask); break;
                        case OP_BIT_OR:  default_layer_or(bits | mask);  break;
                        case OP_BIT_XOR: default_layer_xor(bits | mask); break;
                        case OP_BIT_SET: default_layer_and(mask); default_layer_or(bits); break;
                    }
                }
            } else {
                /* Layer Bitwise Operation */
                if (event.pressed ? (action.layer_bitop.on & ON_PRESS) :
                                    (action.layer_bitop.on & ON_RELEASE)) {
                    uint8_t shift = action.layer_bitop.part*4;
                    uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
                    uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
                    switch (action.layer_bitop.op) {
                        case OP_BIT_AND: layer_and(bits | mask); break;
                        case OP_BIT_OR:  layer_or(bits | mask);  break;
                        case OP_BIT_XOR: layer_xor(bits | mask); break;
                        case OP_BIT_SET: layer_and(mask); layer_or(bits); break;
                    }
                }
            }
            break;
    #ifndef NO_ACTION_TAPPING
        case ACT_LAYER_TAP:
        case ACT_LAYER_TAP_EXT:
            switch (action.layer_tap.code) {
                case 0xe0 ... 0xef:
                    /* layer On/Off with modifiers(left only) */
                    if (event.pressed) {
                        layer_on(action.layer_tap.val);
                        register_mods(action.layer_tap.code & 0x0f);
                    } else {
                        layer_off(action.layer_tap.val);
                        unregister_mods(action.layer_tap.code & 0x0f);
                    }
                    break;
                case OP_TAP_TOGGLE:
                    /* tap toggle */
                    if (event.pressed) {
                        if (tap_count < TAPPING_TOGGLE) {
                            layer_invert(action.layer_tap.val);
                        }
                    } else {
                        if (tap_count <= TAPPING_TOGGLE) {
                            layer_invert(action.layer_tap.val);
                        }
                    }
                    break;
                case OP_ON_OFF:
                    event.pressed ? layer_on(action.layer_tap.val) :
                                    layer_off(action.layer_tap.val);
                    break;
                case OP_OFF_ON:
                    event.pressed ? layer_off(action.layer_tap.val) :
                                    layer_on(action.layer_tap.val);
                    break;
                case OP_SET_CLEAR:
                    event.pressed ? layer_move(action.layer_tap.val) :
                                    layer_clear();
                    break;
            #ifndef NO_ACTION_ONESHOT
                case OP_ONESHOT:
                    // Oneshot modifier
                #if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1
                    do_release_oneshot = false;
                    if (event.pressed) {
                        del_mods(get_oneshot_locked_mods());
                        if (get_oneshot_layer_state() == ONESHOT_TOGGLED) {
                            reset_oneshot_layer();
                            layer_off(action.layer_tap.val);
                            break;
                        } else if (tap_count < ONESHOT_TAP_TOGGLE) {
                            layer_on(action.layer_tap.val);
                            set_oneshot_layer(action.layer_tap.val, ONESHOT_START);
                        }
                    } else {
                        add_mods(get_oneshot_locked_mods());
                        if (tap_count >= ONESHOT_TAP_TOGGLE) {
                            reset_oneshot_layer();
                            clear_oneshot_locked_mods();
                            set_oneshot_layer(action.layer_tap.val, ONESHOT_TOGGLED);
                        } else {
                            clear_oneshot_layer_state(ONESHOT_PRESSED);
                        }
                    }
                #else
                    if (event.pressed) {
                        layer_on(action.layer_tap.val);
                        set_oneshot_layer(action.layer_tap.val, ONESHOT_START);
                    } else {
                        clear_oneshot_layer_state(ONESHOT_PRESSED);
                        if (tap_count > 1) {
                            clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
                        }
                    }
                #endif
                    break;
            #endif
                default:
                    /* tap key */
                    if (event.pressed) {
                        if (tap_count > 0) {
                            dprint("KEYMAP_TAP_KEY: Tap: register_code\n");
                            register_code(action.layer_tap.code);
                        } else {
                            dprint("KEYMAP_TAP_KEY: No tap: On on press\n");
                            layer_on(action.layer_tap.val);
                        }
                    } else {
                        if (tap_count > 0) {
                            dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n");
                            if (action.layer_tap.code == KC_CAPS) {
                                wait_ms(80);
                            }
                            unregister_code(action.layer_tap.code);
                        } else {
                            dprint("KEYMAP_TAP_KEY: No tap: Off on release\n");
                            layer_off(action.layer_tap.val);
                        }
                    }
                    break;
            }
            break;
    #endif
#endif
        /* Extentions */
#ifndef NO_ACTION_MACRO
        case ACT_MACRO:
            action_macro_play(action_get_macro(record, action.func.id, action.func.opt));
            break;
#endif
#ifdef BACKLIGHT_ENABLE
        case ACT_BACKLIGHT:
            if (!event.pressed) {
                switch (action.backlight.opt) {
                    case BACKLIGHT_INCREASE:
                        backlight_increase();
                        break;
                    case BACKLIGHT_DECREASE:
                        backlight_decrease();
                        break;
                    case BACKLIGHT_TOGGLE:
                        backlight_toggle();
                        break;
                    case BACKLIGHT_STEP:
                        backlight_step();
                        break;
                    case BACKLIGHT_ON:
                        backlight_level(BACKLIGHT_LEVELS);
                        break;
                    case BACKLIGHT_OFF:
                        backlight_level(0);
                        break;
                }
            }
            break;
#endif
        case ACT_COMMAND:
            break;
#ifdef SWAP_HANDS_ENABLE
        case ACT_SWAP_HANDS:
            switch (action.swap.code) {
                case OP_SH_TOGGLE:
                    if (event.pressed) {
                        swap_hands = !swap_hands;
                    }
                    break;
                case OP_SH_ON_OFF:
                    swap_hands = event.pressed;
                    break;
                case OP_SH_OFF_ON:
                    swap_hands = !event.pressed;
                    break;
                case OP_SH_ON:
                    if (!event.pressed) {
                        swap_hands = true;
                    }
                    break;
                case OP_SH_OFF:
                    if (!event.pressed) {
                        swap_hands = false;
                    }
                    break;
    #ifndef NO_ACTION_TAPPING
                case OP_SH_TAP_TOGGLE:
                    /* tap toggle */

                    if (event.pressed) {
                        if (swap_held) {
                            swap_held = false;
                        } else {
                            swap_hands = !swap_hands;
                        }
                    } else {
                        if (tap_count < TAPPING_TOGGLE) {
                            swap_hands = !swap_hands;
                        }
                    }
                    break;
                default:
                    /* tap key */
                    if (tap_count > 0) {
                        if (swap_held) {
                            swap_hands = !swap_hands; // undo hold set up in _tap_hint
                            swap_held = false;
                        }
                        if (event.pressed) {
                            register_code(action.swap.code);
                        } else {
                            unregister_code(action.swap.code);
                            *record = (keyrecord_t){}; // hack: reset tap mode
                        }
                    } else {
                        if (swap_held && !event.pressed) {
                            swap_hands = !swap_hands; // undo hold set up in _tap_hint
                            swap_held = false;
                        }
                    }
    #endif
            }
#endif
#ifndef NO_ACTION_FUNCTION
        case ACT_FUNCTION:
            action_function(record, action.func.id, action.func.opt);
            break;
#endif
        default:
            break;
    }

#ifndef NO_ACTION_LAYER
    // if this event is a layer action, update the leds
    switch (action.kind.id) {
        case ACT_LAYER:
        #ifndef NO_ACTION_TAPPING
        case ACT_LAYER_TAP:
        case ACT_LAYER_TAP_EXT:
        #endif
            led_set(host_keyboard_leds());
            break;
        default:
            break;
    }
#endif

#ifndef NO_ACTION_TAPPING
  #ifdef RETRO_TAPPING
  if (!is_tap_key(record->event.key)) {
    retro_tapping_counter = 0;
  } else {
    if (event.pressed) {
        if (tap_count > 0) {
          retro_tapping_counter = 0;
        } else {

        }
    } else {
      if (tap_count > 0) {
        retro_tapping_counter = 0;
      } else {
        if (retro_tapping_counter == 2) {
          register_code(action.layer_tap.code);
          unregister_code(action.layer_tap.code);
        }
        retro_tapping_counter = 0;
      }
    }
  }
  #endif
#endif

#ifndef NO_ACTION_ONESHOT
    /* Because we switch layers after a oneshot event, we need to release the
     * key before we leave the layer or no key up event will be generated.
     */
    if (do_release_oneshot && !(get_oneshot_layer_state() & ONESHOT_PRESSED )   ) {
        record->event.pressed = false;
        layer_on(get_oneshot_layer());
        process_record(record);
        layer_off(get_oneshot_layer());
    }
#endif
}
Ejemplo n.º 6
0
void process_action(keyrecord_t *record)
{
    keyevent_t event = record->event;
#ifndef NO_ACTION_TAPPING
    uint8_t tap_count = record->tap.count;
#endif

    if (IS_NOEVENT(event)) {
        return;
    }

    process_action_kb(record);

    action_t action = store_or_get_action(event.pressed, event.key);
    dprint("ACTION: ");
    debug_action(action);
#ifndef NO_ACTION_LAYER
    dprint(" layer_state: ");
    layer_debug();
    dprint(" default_layer_state: ");
    default_layer_debug();
#endif
    dprintln();

    if (event.pressed) {
        // clear the potential weak mods left by previously pressed keys
        clear_weak_mods();
    }
    switch (action.kind.id) {
    /* Key and Mods */
    case ACT_LMODS:
    case ACT_RMODS:
    {
        uint8_t mods = (action.kind.id == ACT_LMODS) ?  action.key.mods :
                       action.key.mods<<4;
        if (event.pressed) {
            if (mods) {
                if (IS_MOD(action.key.code)) {
                    // e.g. LSFT(KC_LGUI): we don't want the LSFT to be weak as it would make it useless.
                    // this also makes LSFT(KC_LGUI) behave exactly the same as LGUI(KC_LSFT)
                    add_mods(mods);
                } else {
                    add_weak_mods(mods);
                }
                send_keyboard_report();
            }
            register_code(action.key.code);
        } else {
            unregister_code(action.key.code);
            if (mods) {
                if (IS_MOD(action.key.code)) {
                    del_mods(mods);
                } else {
                    del_weak_mods(mods);
                }
                send_keyboard_report();
            }
        }
    }
    break;
#ifndef NO_ACTION_TAPPING
    case ACT_LMODS_TAP:
    case ACT_RMODS_TAP:
    {
        uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ?  action.key.mods :
                       action.key.mods<<4;
        switch (action.layer_tap.code) {
#ifndef NO_ACTION_ONESHOT
        case MODS_ONESHOT:
            // Oneshot modifier
            if (event.pressed) {
                if (tap_count == 0) {
                    register_mods(mods);
                }
                else if (tap_count == 1) {
                    dprint("MODS_TAP: Oneshot: start\n");
                    set_oneshot_mods(mods);
                }
                else {
                    register_mods(mods);
                }
            } else {
                if (tap_count == 0) {
                    clear_oneshot_mods();
                    unregister_mods(mods);
                }
                else if (tap_count == 1) {
                    // Retain Oneshot mods
                }
                else {
                    clear_oneshot_mods();
                    unregister_mods(mods);
                }
            }
            break;
#endif
        case MODS_TAP_TOGGLE:
            if (event.pressed) {
                if (tap_count <= TAPPING_TOGGLE) {
                    register_mods(mods);
                }
            } else {
                if (tap_count < TAPPING_TOGGLE) {
                    unregister_mods(mods);
                }
            }
            break;
        default:
            if (event.pressed) {
                if (tap_count > 0) {
#ifndef IGNORE_MOD_TAP_INTERRUPT
                    if (record->tap.interrupted) {
                        dprint("mods_tap: tap: cancel: add_mods\n");
                        // ad hoc: set 0 to cancel tap
                        record->tap.count = 0;
                        register_mods(mods);
                    } else
#endif
                    {
                        dprint("MODS_TAP: Tap: register_code\n");
                        register_code(action.key.code);
                    }
                } else {
                    dprint("MODS_TAP: No tap: add_mods\n");
                    register_mods(mods);
                }
            } else {
                if (tap_count > 0) {
                    dprint("MODS_TAP: Tap: unregister_code\n");
                    unregister_code(action.key.code);
                } else {
                    dprint("MODS_TAP: No tap: add_mods\n");
                    unregister_mods(mods);
                }
            }
            break;
        }
    }
    break;
#endif
#ifdef EXTRAKEY_ENABLE
    /* other HID usage */
    case ACT_USAGE:
        switch (action.usage.page) {
        case PAGE_SYSTEM:
            if (event.pressed) {
                host_system_send(action.usage.code);
            } else {
                host_system_send(0);
            }
            break;
        case PAGE_CONSUMER:
            if (event.pressed) {
                host_consumer_send(action.usage.code);
            } else {
                host_consumer_send(0);
            }
            break;
        }
        break;
#endif
#ifdef MOUSEKEY_ENABLE
    /* Mouse key */
    case ACT_MOUSEKEY:
        if (event.pressed) {
            mousekey_on(action.key.code);
            mousekey_send();
        } else {
            mousekey_off(action.key.code);
            mousekey_send();
        }
        break;
#endif
#ifndef NO_ACTION_LAYER
    case ACT_LAYER:
        if (action.layer_bitop.on == 0) {
            /* Default Layer Bitwise Operation */
            if (!event.pressed) {
                uint8_t shift = action.layer_bitop.part*4;
                uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
                uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
                switch (action.layer_bitop.op) {
                case OP_BIT_AND:
                    default_layer_and(bits | mask);
                    break;
                case OP_BIT_OR:
                    default_layer_or(bits | mask);
                    break;
                case OP_BIT_XOR:
                    default_layer_xor(bits | mask);
                    break;
                case OP_BIT_SET:
                    default_layer_and(mask);
                    default_layer_or(bits);
                    break;
                }
            }
        } else {
            /* Layer Bitwise Operation */
            if (event.pressed ? (action.layer_bitop.on & ON_PRESS) :
                    (action.layer_bitop.on & ON_RELEASE)) {
                uint8_t shift = action.layer_bitop.part*4;
                uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift;
                uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0;
                switch (action.layer_bitop.op) {
                case OP_BIT_AND:
                    layer_and(bits | mask);
                    break;
                case OP_BIT_OR:
                    layer_or(bits | mask);
                    break;
                case OP_BIT_XOR:
                    layer_xor(bits | mask);
                    break;
                case OP_BIT_SET:
                    layer_and(mask);
                    layer_or(bits);
                    break;
                }
            }
        }
        break;
#ifndef NO_ACTION_TAPPING
    case ACT_LAYER_TAP:
    case ACT_LAYER_TAP_EXT:
        switch (action.layer_tap.code) {
        case 0xe0 ... 0xef:
            /* layer On/Off with modifiers(left only) */
            if (event.pressed) {
                layer_on(action.layer_tap.val);
                register_mods(action.layer_tap.code & 0x0f);
            } else {
                layer_off(action.layer_tap.val);
                unregister_mods(action.layer_tap.code & 0x0f);
            }
            break;
        case OP_TAP_TOGGLE:
            /* tap toggle */
            if (event.pressed) {
                if (tap_count < TAPPING_TOGGLE) {
                    layer_invert(action.layer_tap.val);
                }
            } else {
                if (tap_count <= TAPPING_TOGGLE) {
                    layer_invert(action.layer_tap.val);
                }
            }
            break;
        case OP_ON_OFF:
            event.pressed ? layer_on(action.layer_tap.val) :
            layer_off(action.layer_tap.val);
            break;
        case OP_OFF_ON:
            event.pressed ? layer_off(action.layer_tap.val) :
            layer_on(action.layer_tap.val);
            break;
        case OP_SET_CLEAR:
            event.pressed ? layer_move(action.layer_tap.val) :
            layer_clear();
            break;
        default:
            /* tap key */
            if (event.pressed) {
                if (tap_count > 0) {
                    dprint("KEYMAP_TAP_KEY: Tap: register_code\n");
                    register_code(action.layer_tap.code);
                } else {
                    dprint("KEYMAP_TAP_KEY: No tap: On on press\n");
                    layer_on(action.layer_tap.val);
                }
            } else {
                if (tap_count > 0) {
                    dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n");
                    unregister_code(action.layer_tap.code);
                } else {
                    dprint("KEYMAP_TAP_KEY: No tap: Off on release\n");
                    layer_off(action.layer_tap.val);
                }
            }
            break;
        }
        break;
#endif
#endif
        /* Extentions */
#ifndef NO_ACTION_MACRO
    case ACT_MACRO:
        action_macro_play(action_get_macro(record, action.func.id, action.func.opt));
        break;
#endif
#ifdef BACKLIGHT_ENABLE
    case ACT_BACKLIGHT:
        if (!event.pressed) {
            switch (action.backlight.opt) {
            case BACKLIGHT_INCREASE:
                backlight_increase();
                break;
            case BACKLIGHT_DECREASE:
                backlight_decrease();
                break;
            case BACKLIGHT_TOGGLE:
                backlight_toggle();
                break;
            case BACKLIGHT_STEP:
                backlight_step();
                break;
            case BACKLIGHT_LEVEL:
                backlight_level(action.backlight.level);
                break;
            }
        }
        break;
#endif
    case ACT_COMMAND:
        break;
#ifndef NO_ACTION_FUNCTION
    case ACT_FUNCTION:
        action_function(record, action.func.id, action.func.opt);
        break;
#endif
    default:
        break;
    }
}