void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
    if (record->event.pressed) dprint("P"); else dprint("R");
    if (record->tap.interrupted) dprint("i");

#   define MODS_SHIFT_MASK   (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
    static uint8_t shift_mod;

    switch (id) {
        // Shift + Esc -> ~
        case SHIFT_ESC:
            shift_mod = get_mods()&MODS_SHIFT_MASK;
            if (record->event.pressed) {
                if (shift_mod) {
                    add_key(KC_GRV);
                    send_keyboard_report(); // send grave with shift for tilde result
                } else {
                    del_mods(shift_mod); // remove shift
                    add_key(KC_ESC);
                    send_keyboard_report(); // send escape
                    add_mods(shift_mod); // return shift but not sent
                }
            } else {
                if (shift_mod) {
                    del_key(KC_GRV);
                    send_keyboard_report();
                } else {
                    del_key(KC_ESC);
                    send_keyboard_report();
                }
            }
            break;
        case SHIFT_BSPC:
            shift_mod = get_mods()&MODS_SHIFT_MASK;
            if (record->event.pressed) {
                if (shift_mod) {
                    add_key(KC_BSLS);
                    send_keyboard_report(); // send backslash with shift for pipe result
                } else {
                    del_mods(shift_mod); // remove shift
                    add_key(KC_BSPC);
                    send_keyboard_report(); // send backspace
                    add_mods(shift_mod); // return shift but not sent
                }
            } else {
                if (shift_mod) {
                    del_key(KC_BSLS);
                    send_keyboard_report();
                } else {
                    del_key(KC_BSPC);
                    send_keyboard_report();
                }
            }
            break;
    }
}
Example #2
0
/*
 * user defined action function
 */
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
    keyevent_t event = record->event;
    tap_t tap = record->tap;

    switch (id) {
        case LSHIFT_LPAREN:
            // LShft + tap '('
            // NOTE: cant use register_code to avoid conflicting with magic key bind
            if (event.pressed) {
                if (tap.count == 0 || tap.interrupted) {
                    add_mods(MOD_BIT(KC_LSHIFT));
                } else {
                    add_mods(MOD_BIT(KC_LSHIFT));
                    add_key(KC_9);
                    send_keyboard_report();
                    del_mods(MOD_BIT(KC_LSHIFT));
                    del_key(KC_9);
                    send_keyboard_report();
                }
            } else {
                if (tap.count == 0 || tap.interrupted) {
                    del_mods(MOD_BIT(KC_LSHIFT));
                    //layer_off(1);
                }
            }
            break;
        case RSHIFT_RPAREN:
            // RShift + tap ')'
            if (event.pressed) {
                if (tap.count == 0 || tap.interrupted) {
                    add_mods(MOD_BIT(KC_RSHIFT));
                } else {
                    add_mods(MOD_BIT(KC_RSHIFT));
                    add_key(KC_0);
                    send_keyboard_report();
                    del_mods(MOD_BIT(KC_RSHIFT));
                    del_key(KC_0);
                    send_keyboard_report();
                }
            } else {
                if (tap.count == 0 || tap.interrupted) {
                    del_mods(MOD_BIT(KC_RSHIFT));
                }
            }
            break;
    }
}
Example #3
0
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
#   define MODS_CTRL_MASK   (MOD_BIT(KC_LCTRL)|MOD_BIT(KC_RCTRL))
    static uint8_t ctrl_space_i_prev_ctrl;

    switch (id) {
    // Ctrl + Up(SpaceFN) -> PgUp
    case CTRL_SPACE_I:
        ctrl_space_i_prev_ctrl = get_mods()&MODS_CTRL_MASK;
        if (record->event.pressed) {
            if (ctrl_space_i_prev_ctrl) {
                del_mods(ctrl_space_i_prev_ctrl);   // remove Ctrl
                add_key(KC_PGUP);
                send_keyboard_report(); // send PgUp without Ctrl
                add_mods(ctrl_space_i_prev_ctrl);   // return Ctrl but not sent
            } else {
                add_key(KC_UP);
                send_keyboard_report();
            }
        } else {
            if (ctrl_space_i_prev_ctrl) {
                del_key(KC_PGUP);
                send_keyboard_report();
            } else {
                del_key(KC_UP);
                send_keyboard_report();
            }
        }
        break;
    }
}
static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t *action)
{
  _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_reset);
  del_mods(action->state.oneshot_mods);
  del_weak_mods(action->state.weak_mods);
  send_keyboard_report();
}
Example #5
0
void stroke(void)
{
    // Send characters for each key family
    const uint8_t original_mods = get_mods();
    del_mods(MOD_LSFT|MOD_RSFT);
    bool initial_case_1 = false;
    bool initial_case_2 = false;
    undo_command_t new_undo_command;
    memset(&new_undo_command, 0, sizeof(undo_command_t));

    // Get *, + and case controls info
    const uint8_t special_controls_bits = g_family_bits[FAMILY_SPECIAL_CONTROLS];
    const uint8_t thumbs_bits = g_family_bits[FAMILY_THUMBS];
    const bool has_star = special_controls_bits & (1 << (SC_STAR & 0xF));
    const bool has_plus = special_controls_bits & (1 << (SC_PLUS & 0xF));
    const bool has_meta_space = special_controls_bits & (1 << (SC_MSPC & 0xF));
    const uint8_t case_controls_bits = g_family_bits[FAMILY_CASE_CONTROLS];
    if (case_controls_bits)
    {
        initial_case_1 = case_controls_bits == 2;
        initial_case_2 = case_controls_bits == 3;
        add_mods(MOD_LSFT);
    }

    // Evaluate stroke
    bool undo_allowed = true;
    bool no_space_code_detected = false;
    for (int family_id = 0; family_id < NB_FAMILY; ++family_id)
    {
        uint8_t family_bits = g_family_bits[family_id];
        if (family_bits == 0)
        {
            continue;
        }

        // Get the lookup table
        undo_allowed = family_id == FAMILY_SPECIAL_CONTROLS;
        void* any_table = 0;
        uint8_t kind = g_family_to_kind_table[family_id];
        if (family_id == FAMILY_THUMBS && has_star)
        {
            any_table = g_thumbs_bigrams_table;
        }
        else if (family_id == FAMILY_LEFT_HAND && has_star && !thumbs_bits)
        {
            any_table = g_left_punctuations_table;
            kind = KIND_PUNCTUATIONS;
        }
        else if (family_id == FAMILY_RIGHT_HAND && has_star && !thumbs_bits)
        {
            any_table = g_right_punctuations_table;
            kind = KIND_PUNCTUATIONS;
        }
        else
        {
            any_table = g_all_tables[family_id];
        }

        if (any_table)
        {
            switch (kind)
            {
            case KIND_LETTERS:
                {
                    uint8_t register_count = 0;
                    uint8_t last_byte = 0;
                    letters_table_t* letters_table = (letters_table_t*)any_table;
                    for (int code_pos = 0; code_pos < MAX_LETTERS; ++code_pos)
                    {
                        const uint8_t byte = pgm_read_byte(&(letters_table[family_bits][code_pos]));
                        if (byte)
                        {
                            register_code(byte);
                            unregister_code(byte);
                            last_byte = byte;
                            register_count++;
                            new_undo_command.inserted_chars_count++;

                            if ((initial_case_1 && new_undo_command.inserted_chars_count == 1) || (initial_case_2 && new_undo_command.inserted_chars_count == 2))
                            {
                                del_mods(MOD_LSFT);
                            }
                        }
                        else
                        {
                            // Double the consonnant for the right hand only
                            if (    has_plus && (register_count == 1)
                                    && (family_id == FAMILY_RIGHT_HAND)
                                    && (last_byte != 0))
                            {
                                register_code(last_byte);
                                unregister_code(last_byte);
                                new_undo_command.inserted_chars_count++;
                            }
                            break;
                        }
                    }
                    break;
                }

            case KIND_SYMBOLS:
                {
                    symbols_table_t* symbols_table = (symbols_table_t*)any_table;
                    for (int code_pos = 0; code_pos < MAX_SYMBOLS; ++code_pos)
                    {
                        const uint16_t word = pgm_read_word(&(symbols_table[family_bits][code_pos]));
                        if (word)
                        {
                            const uint8_t code = (uint8_t)word;
                            if (is_letter(code))
                            {
                                // By doing this the shift mod can be applied on letter code
                                register_code(code);
                            }
                            else
                            {
                                send_mods_and_code(word >> 8, code);
                            }

                            unregister_code(code);

                            if (code == KC_LEFT)
                            {
                                new_undo_command.left_arrow_count++;
                            }
                            else
                            {
                                new_undo_command.inserted_chars_count++;
                            }

                            if ((initial_case_1 && new_undo_command.inserted_chars_count == 1) || (initial_case_2 && new_undo_command.inserted_chars_count == 2))
                            {
                                del_mods(MOD_LSFT);
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                    break;
                }
            case KIND_PUNCTUATIONS:
                {
                    punctuations_table_t* punctuations_table = (punctuations_table_t*)any_table;
                    for (int code_pos = 0; code_pos < MAX_PUNCTUATIONS; ++code_pos)
                    {
                        const uint16_t word = pgm_read_word(&(punctuations_table[family_bits][code_pos]));
                        if (word)
                        {
                            if (word == _NOSPC)
                            {
                                no_space_code_detected = true;
                            }
                            else
                            {
                                const uint8_t code = (uint8_t)word;
                                send_mods_and_code(word >> 8, code);
                                unregister_code(code);

                                if (code == KC_LEFT)
                                {
                                    new_undo_command.left_arrow_count++;
                                }
                                else
                                {
                                    new_undo_command.inserted_chars_count++;
                                }
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                    break;
                }
            }
        }
Example #6
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
}
Example #7
0
void process_action(keyrecord_t *record)
{
    bool do_release_oneshot = false;
    keyevent_t event = record->event;
#ifndef NO_ACTION_TAPPING
    uint8_t tap_count = record->tap.count;
#endif

    if (IS_NOEVENT(event)) { return; }

#if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
    if (has_oneshot_layer_timed_out()) {
        dprintf("Oneshot layer: timeout\n");
        clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
    }
#endif

    action_t action = layer_switch_get_action(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();


#ifndef NO_ACTION_ONESHOT
    if (is_oneshot_layer_active() && event.pressed) {
        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) {
                        add_weak_mods(mods);
                        send_keyboard_report();
                    }
                    register_code(action.key.code);
                } else {
                    unregister_code(action.key.code);
                    if (mods) {
                        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) {
                                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 {
                                    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;
            #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");
                            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;
    }

#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_action(record);
        layer_off(get_oneshot_layer());
    }
#endif
}
Example #8
0
void process_unregister_key(uint8_t code)
{
    dprintf("process_unregister_key: code=%X\n", code);
    if (code == KC_LAMBDA)
    {
        dprintf("    lambda\n");
        lambda_pressed = 1;
    }
    else if (code == KC_TILDE)
    {
        dprintf("    tilde\n");
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_TLDE_S);
        send_keyboard_report();
    }
    else if (code == KC_EXCLAM)
    {
        dprintf("    exclam\n");
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_EXCL_S);
        send_keyboard_report();
    }
    else if (code == KC_AT_SIGN)
    {
        dprintf("    at_sign\n");
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_ATSI_S);
        send_keyboard_report();
    }
    else if (code == KC_NUMBER_SIGN)
    {
        dprintf("    num_sign\n");
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_NUSI_S);
        send_keyboard_report();
    }
    else if (code == KC_DOLLAR_SIGN)
    {
        dprintf("    dollar_sign\n");
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_DOSI_S);
        send_keyboard_report();
    }
    else if (code == KC_PERCENT)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_PCNT_S);
        send_keyboard_report();
    }
    else if (code == KC_CARET)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_CART_S);
        send_keyboard_report();
    }
    else if (code == KC_AMPERSTAND)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_AMPT_S);
        send_keyboard_report();
    }
    else if (code == KC_ASTERISK)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_ASTK_S);
        send_keyboard_report();
    }
    else if (code == KC_LPARENT)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_LPAR_S);
        send_keyboard_report();
    }
    else if (code == KC_RPARENT)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_RPAR_S);
        send_keyboard_report();
    }
    else if (code == KC_UNDERSCORE)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_UNDS_S);
        send_keyboard_report();
    }
    else if (code == KC_PLUS)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_PLUS_S);
        send_keyboard_report();
    }
    else if (code == KC_LCBRACKET)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_LCBR_S);
        send_keyboard_report();
    }
    else if (code == KC_RCBRACKET)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_RCBR_S);
        send_keyboard_report();
    }
    else if (code == KC_PIPE)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_PIPE_S);
        send_keyboard_report();
    }
    else if (code == KC_DOUBLE_QUOTE)
    {
        del_mods(MOD_BIT(KC_LSFT));
        del_key(KC_DQUO_S);
        send_keyboard_report();
    }
    else
    {
        del_key(code);
        send_keyboard_report();
    }
}
Example #9
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;
    }
}
Example #10
0
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
    if (record->event.pressed) dprint("P"); else dprint("R");
    if (record->tap.interrupted) dprint("i");

#   define MODS_SHIFT_MASK   (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
    static uint8_t shift_mod;
    
#   define MODS_MASK_1   (MOD_BIT(KC_LALT))
#   define MODS_MASK_2   (MOD_BIT(KC_RALT))    
    static uint8_t lalt_ralt_mods;
    
    switch (id) {
        // Shift + Scroll Lock -> Num Pad Layer On
        case SHIFT_NUM:
            shift_mod = get_mods()&MODS_SHIFT_MASK;
            if (record->event.pressed) {
                if (shift_mod) {
		    layer_invert(1); // toggle number pad layer
		    DDR_NUMLAYER ^= (1<<BIT_NUMLAYER); // turn on layer LED
                } else {
                    del_mods(shift_mod); // remove shift
                    add_key(KC_SLCK);
                    send_keyboard_report(); // send Scroll Lock
                    add_mods(shift_mod); // return shift but not sent
                }
            } else {
                if (shift_mod) {                    
                } else {
                    del_key(KC_SLCK);
                    send_keyboard_report();
                }
            }
            break;
	    
	// Shift + Num Lock -> Num Pad Layer Off
        case SHIFT_NUM1:
            shift_mod = get_mods()&MODS_SHIFT_MASK;
            if (record->event.pressed) {
                if (shift_mod) {
		    layer_invert(1); // toggle number pad layer
		    DDR_NUMLAYER ^= (1<<BIT_NUMLAYER); // turn off layer LED
                } else {
                    del_mods(shift_mod); // remove shift
                    add_key(KC_NLCK);
                    send_keyboard_report(); // send Num Lock
                    add_mods(shift_mod); // return shift but not sent
                }
            } else {
                if (shift_mod) {
                } else {
                    del_key(KC_NLCK);
                    send_keyboard_report();
                }
            }
            break;

        // Left ALT + Right ALT + Pause = DFU
        case PAUS_BOOT:
            lalt_ralt_mods = get_mods()&MODS_MASK_1 && get_mods()&MODS_MASK_2;
            if (record->event.pressed) {
                if (lalt_ralt_mods) {
		    del_mods(lalt_ralt_mods);
		    send_keyboard_report();
		    clear_keyboard();
		    bootloader_jump(); 
                } else {
                    del_mods(lalt_ralt_mods); // remove shift
                    add_key(KC_PAUS);
                    send_keyboard_report(); // send Scroll Lock
                    add_mods(lalt_ralt_mods); // return shift but not sent
                }
            } else {
                if (lalt_ralt_mods) {                   
                } else {
                    del_key(KC_PAUS);
                    send_keyboard_report();
                }
            }
            break;
    }
  
};