Basic keycode overhaul (#14726)
This commit is contained in:
parent
b06d9d822c
commit
f529580860
52 changed files with 1135 additions and 1081 deletions
|
@ -277,8 +277,8 @@ void process_action(keyrecord_t *record, action_t action) {
|
|||
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).
|
||||
// e.g. LSFT(KC_LEFT_GUI): we don't want the LSFT to be weak as it would make it useless.
|
||||
// This also makes LSFT(KC_LEFT_GUI) behave exactly the same as LGUI(KC_LEFT_SHIFT).
|
||||
// Same applies for some keys like KC_MEH which are declared as MEH(KC_NO).
|
||||
add_mods(mods);
|
||||
} else {
|
||||
|
@ -410,7 +410,7 @@ void process_action(keyrecord_t *record, action_t action) {
|
|||
} else {
|
||||
if (tap_count > 0) {
|
||||
dprint("MODS_TAP: Tap: unregister_code\n");
|
||||
if (action.layer_tap.code == KC_CAPS) {
|
||||
if (action.layer_tap.code == KC_CAPS_LOCK) {
|
||||
wait_ms(TAP_HOLD_CAPS_DELAY);
|
||||
} else {
|
||||
wait_ms(TAP_CODE_DELAY);
|
||||
|
@ -609,7 +609,7 @@ void process_action(keyrecord_t *record, action_t action) {
|
|||
} else {
|
||||
if (tap_count > 0) {
|
||||
dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n");
|
||||
if (action.layer_tap.code == KC_CAPS) {
|
||||
if (action.layer_tap.code == KC_CAPS_LOCK) {
|
||||
wait_ms(TAP_HOLD_CAPS_DELAY);
|
||||
} else {
|
||||
wait_ms(TAP_CODE_DELAY);
|
||||
|
@ -786,37 +786,37 @@ void register_code(uint8_t code) {
|
|||
return;
|
||||
}
|
||||
#ifdef LOCKING_SUPPORT_ENABLE
|
||||
else if (KC_LOCKING_CAPS == code) {
|
||||
else if (KC_LOCKING_CAPS_LOCK == code) {
|
||||
# ifdef LOCKING_RESYNC_ENABLE
|
||||
// Resync: ignore if caps lock already is on
|
||||
if (host_keyboard_leds() & (1 << USB_LED_CAPS_LOCK)) return;
|
||||
# endif
|
||||
add_key(KC_CAPSLOCK);
|
||||
add_key(KC_CAPS_LOCK);
|
||||
send_keyboard_report();
|
||||
wait_ms(100);
|
||||
del_key(KC_CAPSLOCK);
|
||||
del_key(KC_CAPS_LOCK);
|
||||
send_keyboard_report();
|
||||
}
|
||||
|
||||
else if (KC_LOCKING_NUM == code) {
|
||||
else if (KC_LOCKING_NUM_LOCK == code) {
|
||||
# ifdef LOCKING_RESYNC_ENABLE
|
||||
if (host_keyboard_leds() & (1 << USB_LED_NUM_LOCK)) return;
|
||||
# endif
|
||||
add_key(KC_NUMLOCK);
|
||||
add_key(KC_NUM_LOCK);
|
||||
send_keyboard_report();
|
||||
wait_ms(100);
|
||||
del_key(KC_NUMLOCK);
|
||||
del_key(KC_NUM_LOCK);
|
||||
send_keyboard_report();
|
||||
}
|
||||
|
||||
else if (KC_LOCKING_SCROLL == code) {
|
||||
else if (KC_LOCKING_SCROLL_LOCK == code) {
|
||||
# ifdef LOCKING_RESYNC_ENABLE
|
||||
if (host_keyboard_leds() & (1 << USB_LED_SCROLL_LOCK)) return;
|
||||
# endif
|
||||
add_key(KC_SCROLLLOCK);
|
||||
add_key(KC_SCROLL_LOCK);
|
||||
send_keyboard_report();
|
||||
wait_ms(100);
|
||||
del_key(KC_SCROLLLOCK);
|
||||
del_key(KC_SCROLL_LOCK);
|
||||
send_keyboard_report();
|
||||
}
|
||||
#endif
|
||||
|
@ -882,34 +882,34 @@ void unregister_code(uint8_t code) {
|
|||
return;
|
||||
}
|
||||
#ifdef LOCKING_SUPPORT_ENABLE
|
||||
else if (KC_LOCKING_CAPS == code) {
|
||||
else if (KC_LOCKING_CAPS_LOCK == code) {
|
||||
# ifdef LOCKING_RESYNC_ENABLE
|
||||
// Resync: ignore if caps lock already is off
|
||||
if (!(host_keyboard_leds() & (1 << USB_LED_CAPS_LOCK))) return;
|
||||
# endif
|
||||
add_key(KC_CAPSLOCK);
|
||||
add_key(KC_CAPS_LOCK);
|
||||
send_keyboard_report();
|
||||
del_key(KC_CAPSLOCK);
|
||||
del_key(KC_CAPS_LOCK);
|
||||
send_keyboard_report();
|
||||
}
|
||||
|
||||
else if (KC_LOCKING_NUM == code) {
|
||||
else if (KC_LOCKING_NUM_LOCK == code) {
|
||||
# ifdef LOCKING_RESYNC_ENABLE
|
||||
if (!(host_keyboard_leds() & (1 << USB_LED_NUM_LOCK))) return;
|
||||
# endif
|
||||
add_key(KC_NUMLOCK);
|
||||
add_key(KC_NUM_LOCK);
|
||||
send_keyboard_report();
|
||||
del_key(KC_NUMLOCK);
|
||||
del_key(KC_NUM_LOCK);
|
||||
send_keyboard_report();
|
||||
}
|
||||
|
||||
else if (KC_LOCKING_SCROLL == code) {
|
||||
else if (KC_LOCKING_SCROLL_LOCK == code) {
|
||||
# ifdef LOCKING_RESYNC_ENABLE
|
||||
if (!(host_keyboard_leds() & (1 << USB_LED_SCROLL_LOCK))) return;
|
||||
# endif
|
||||
add_key(KC_SCROLLLOCK);
|
||||
add_key(KC_SCROLL_LOCK);
|
||||
send_keyboard_report();
|
||||
del_key(KC_SCROLLLOCK);
|
||||
del_key(KC_SCROLL_LOCK);
|
||||
send_keyboard_report();
|
||||
}
|
||||
#endif
|
||||
|
@ -952,9 +952,9 @@ void tap_code_delay(uint8_t code, uint16_t delay) {
|
|||
|
||||
/** \brief Tap a keycode with the default delay.
|
||||
*
|
||||
* \param code The basic keycode to tap. If `code` is `KC_CAPS`, the delay will be `TAP_HOLD_CAPS_DELAY`, otherwise `TAP_CODE_DELAY`, if defined.
|
||||
* \param code The basic keycode to tap. If `code` is `KC_CAPS_LOCK`, the delay will be `TAP_HOLD_CAPS_DELAY`, otherwise `TAP_CODE_DELAY`, if defined.
|
||||
*/
|
||||
void tap_code(uint8_t code) { tap_code_delay(code, code == KC_CAPS ? TAP_HOLD_CAPS_DELAY : TAP_CODE_DELAY); }
|
||||
void tap_code(uint8_t code) { tap_code_delay(code, code == KC_CAPS_LOCK ? TAP_HOLD_CAPS_DELAY : TAP_CODE_DELAY); }
|
||||
|
||||
/** \brief Adds the given physically pressed modifiers and sends a keyboard report immediately.
|
||||
*
|
||||
|
@ -1078,7 +1078,7 @@ bool is_tap_action(action_t action) {
|
|||
case ACT_LAYER_TAP:
|
||||
case ACT_LAYER_TAP_EXT:
|
||||
switch (action.layer_tap.code) {
|
||||
case KC_NO ... KC_RGUI:
|
||||
case KC_NO ... KC_RIGHT_GUI:
|
||||
case OP_TAP_TOGGLE:
|
||||
case OP_ONESHOT:
|
||||
return true;
|
||||
|
@ -1086,7 +1086,7 @@ bool is_tap_action(action_t action) {
|
|||
return false;
|
||||
case ACT_SWAP_HANDS:
|
||||
switch (action.swap.code) {
|
||||
case KC_NO ... KC_RGUI:
|
||||
case KC_NO ... KC_RIGHT_GUI:
|
||||
case OP_SH_TAP_TOGGLE:
|
||||
return true;
|
||||
}
|
||||
|
|
|
@ -29,7 +29,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
#define IS_ERROR(code) (KC_ROLL_OVER <= (code) && (code) <= KC_UNDEFINED)
|
||||
#define IS_ANY(code) (KC_A <= (code) && (code) <= 0xFF)
|
||||
#define IS_KEY(code) (KC_A <= (code) && (code) <= KC_EXSEL)
|
||||
#define IS_MOD(code) (KC_LCTRL <= (code) && (code) <= KC_RGUI)
|
||||
#define IS_MOD(code) (KC_LEFT_CTRL <= (code) && (code) <= KC_RIGHT_GUI)
|
||||
|
||||
#define IS_SPECIAL(code) ((0xA5 <= (code) && (code) <= 0xDF) || (0xE8 <= (code) && (code) <= 0xFF))
|
||||
#define IS_SYSTEM(code) (KC_PWR <= (code) && (code) <= KC_WAKE)
|
||||
|
@ -46,10 +46,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
#define MOD_BIT(code) (1 << MOD_INDEX(code))
|
||||
#define MOD_INDEX(code) ((code)&0x07)
|
||||
|
||||
#define MOD_MASK_CTRL (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RCTRL))
|
||||
#define MOD_MASK_SHIFT (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))
|
||||
#define MOD_MASK_ALT (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))
|
||||
#define MOD_MASK_GUI (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))
|
||||
#define MOD_MASK_CTRL (MOD_BIT(KC_LEFT_CTRL) | MOD_BIT(KC_RIGHT_CTRL))
|
||||
#define MOD_MASK_SHIFT (MOD_BIT(KC_LEFT_SHIFT) | MOD_BIT(KC_RIGHT_SHIFT))
|
||||
#define MOD_MASK_ALT (MOD_BIT(KC_LEFT_ALT) | MOD_BIT(KC_RIGHT_ALT))
|
||||
#define MOD_MASK_GUI (MOD_BIT(KC_LEFT_GUI) | MOD_BIT(KC_RIGHT_GUI))
|
||||
#define MOD_MASK_CS (MOD_MASK_CTRL | MOD_MASK_SHIFT)
|
||||
#define MOD_MASK_CA (MOD_MASK_CTRL | MOD_MASK_ALT)
|
||||
#define MOD_MASK_CG (MOD_MASK_CTRL | MOD_MASK_GUI)
|
||||
|
@ -67,6 +67,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
#define FN_MIN KC_FN0
|
||||
#define FN_MAX KC_FN31
|
||||
|
||||
// clang-format off
|
||||
|
||||
/*
|
||||
* Short names for ease of definition of keymap
|
||||
*/
|
||||
|
@ -75,47 +77,55 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
#define KC_TRNS KC_TRANSPARENT
|
||||
|
||||
/* Punctuation */
|
||||
#define KC_ENT KC_ENTER
|
||||
#define KC_ESC KC_ESCAPE
|
||||
#define KC_BSPC KC_BSPACE
|
||||
#define KC_SPC KC_SPACE
|
||||
#define KC_ENT KC_ENTER
|
||||
#define KC_ESC KC_ESCAPE
|
||||
#define KC_BSPC KC_BACKSPACE
|
||||
#define KC_SPC KC_SPACE
|
||||
#define KC_MINS KC_MINUS
|
||||
#define KC_EQL KC_EQUAL
|
||||
#define KC_LBRC KC_LBRACKET
|
||||
#define KC_RBRC KC_RBRACKET
|
||||
#define KC_BSLS KC_BSLASH
|
||||
#define KC_EQL KC_EQUAL
|
||||
#define KC_LBRC KC_LEFT_BRACKET
|
||||
#define KC_RBRC KC_RIGHT_BRACKET
|
||||
#define KC_BSLS KC_BACKSLASH
|
||||
#define KC_NUHS KC_NONUS_HASH
|
||||
#define KC_SCLN KC_SCOLON
|
||||
#define KC_SCLN KC_SEMICOLON
|
||||
#define KC_QUOT KC_QUOTE
|
||||
#define KC_GRV KC_GRAVE
|
||||
#define KC_GRV KC_GRAVE
|
||||
#define KC_COMM KC_COMMA
|
||||
#define KC_SLSH KC_SLASH
|
||||
#define KC_NUBS KC_NONUS_BSLASH
|
||||
#define KC_NUBS KC_NONUS_BACKSLASH
|
||||
|
||||
/* Lock Keys */
|
||||
#define KC_CLCK KC_CAPSLOCK
|
||||
#define KC_CAPS KC_CAPSLOCK
|
||||
#define KC_SLCK KC_SCROLLLOCK
|
||||
#define KC_NLCK KC_NUMLOCK
|
||||
#define KC_LCAP KC_LOCKING_CAPS
|
||||
#define KC_LNUM KC_LOCKING_NUM
|
||||
#define KC_LSCR KC_LOCKING_SCROLL
|
||||
#define KC_CAPS KC_CAPS_LOCK
|
||||
#define KC_SCRL KC_SCROLL_LOCK
|
||||
#define KC_NUM KC_NUM_LOCK
|
||||
#define KC_LCAP KC_LOCKING_CAPS_LOCK
|
||||
#define KC_LNUM KC_LOCKING_NUM_LOCK
|
||||
#define KC_LSCR KC_LOCKING_SCROLL_LOCK
|
||||
|
||||
/* Commands */
|
||||
#define KC_PSCR KC_PSCREEN
|
||||
#define KC_PSCR KC_PRINT_SCREEN
|
||||
#define KC_PAUS KC_PAUSE
|
||||
#define KC_BRK KC_PAUSE
|
||||
#define KC_INS KC_INSERT
|
||||
#define KC_DEL KC_DELETE
|
||||
#define KC_PGDN KC_PGDOWN
|
||||
#define KC_BRK KC_PAUSE
|
||||
#define KC_INS KC_INSERT
|
||||
#define KC_PGUP KC_PAGE_UP
|
||||
#define KC_DEL KC_DELETE
|
||||
#define KC_PGDN KC_PAGE_DOWN
|
||||
#define KC_RGHT KC_RIGHT
|
||||
#define KC_APP KC_APPLICATION
|
||||
#define KC_APP KC_APPLICATION
|
||||
#define KC_EXEC KC_EXECUTE
|
||||
#define KC_SLCT KC_SELECT
|
||||
#define KC_AGIN KC_AGAIN
|
||||
#define KC_PSTE KC_PASTE
|
||||
#define KC_ERAS KC_ALT_ERASE
|
||||
#define KC_CLR KC_CLEAR
|
||||
#define KC_ERAS KC_ALTERNATE_ERASE
|
||||
#define KC_SYRQ KC_SYSTEM_REQUEST
|
||||
#define KC_CNCL KC_CANCEL
|
||||
#define KC_CLR KC_CLEAR
|
||||
#define KC_PRIR KC_PRIOR
|
||||
#define KC_RETN KC_RETURN
|
||||
#define KC_SEPR KC_SEPARATOR
|
||||
#define KC_CLAG KC_CLEAR_AGAIN
|
||||
#define KC_CRSL KC_CRSEL
|
||||
#define KC_EXSL KC_EXSEL
|
||||
|
||||
/* Keypad */
|
||||
#define KC_PSLS KC_KP_SLASH
|
||||
|
@ -123,47 +133,59 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
#define KC_PMNS KC_KP_MINUS
|
||||
#define KC_PPLS KC_KP_PLUS
|
||||
#define KC_PENT KC_KP_ENTER
|
||||
#define KC_P1 KC_KP_1
|
||||
#define KC_P2 KC_KP_2
|
||||
#define KC_P3 KC_KP_3
|
||||
#define KC_P4 KC_KP_4
|
||||
#define KC_P5 KC_KP_5
|
||||
#define KC_P6 KC_KP_6
|
||||
#define KC_P7 KC_KP_7
|
||||
#define KC_P8 KC_KP_8
|
||||
#define KC_P9 KC_KP_9
|
||||
#define KC_P0 KC_KP_0
|
||||
#define KC_P1 KC_KP_1
|
||||
#define KC_P2 KC_KP_2
|
||||
#define KC_P3 KC_KP_3
|
||||
#define KC_P4 KC_KP_4
|
||||
#define KC_P5 KC_KP_5
|
||||
#define KC_P6 KC_KP_6
|
||||
#define KC_P7 KC_KP_7
|
||||
#define KC_P8 KC_KP_8
|
||||
#define KC_P9 KC_KP_9
|
||||
#define KC_P0 KC_KP_0
|
||||
#define KC_PDOT KC_KP_DOT
|
||||
#define KC_PEQL KC_KP_EQUAL
|
||||
#define KC_PCMM KC_KP_COMMA
|
||||
|
||||
/* Japanese specific */
|
||||
#define KC_ZKHK KC_GRAVE
|
||||
#define KC_RO KC_INT1
|
||||
#define KC_KANA KC_INT2
|
||||
#define KC_JYEN KC_INT3
|
||||
#define KC_HENK KC_INT4
|
||||
#define KC_MHEN KC_INT5
|
||||
|
||||
/* Korean specific */
|
||||
#define KC_HAEN KC_LANG1
|
||||
#define KC_HANJ KC_LANG2
|
||||
/* Language Specific */
|
||||
#define KC_INT1 KC_INTERNATIONAL_1
|
||||
#define KC_INT2 KC_INTERNATIONAL_2
|
||||
#define KC_INT3 KC_INTERNATIONAL_3
|
||||
#define KC_INT4 KC_INTERNATIONAL_4
|
||||
#define KC_INT5 KC_INTERNATIONAL_5
|
||||
#define KC_INT6 KC_INTERNATIONAL_6
|
||||
#define KC_INT7 KC_INTERNATIONAL_7
|
||||
#define KC_INT8 KC_INTERNATIONAL_8
|
||||
#define KC_INT9 KC_INTERNATIONAL_9
|
||||
#define KC_LNG1 KC_LANGUAGE_1
|
||||
#define KC_LNG2 KC_LANGUAGE_2
|
||||
#define KC_LNG3 KC_LANGUAGE_3
|
||||
#define KC_LNG4 KC_LANGUAGE_4
|
||||
#define KC_LNG5 KC_LANGUAGE_5
|
||||
#define KC_LNG6 KC_LANGUAGE_6
|
||||
#define KC_LNG7 KC_LANGUAGE_7
|
||||
#define KC_LNG8 KC_LANGUAGE_8
|
||||
#define KC_LNG9 KC_LANGUAGE_9
|
||||
|
||||
/* Modifiers */
|
||||
#define KC_LCTL KC_LCTRL
|
||||
#define KC_LSFT KC_LSHIFT
|
||||
#define KC_LOPT KC_LALT
|
||||
#define KC_LCMD KC_LGUI
|
||||
#define KC_LWIN KC_LGUI
|
||||
#define KC_RCTL KC_RCTRL
|
||||
#define KC_RSFT KC_RSHIFT
|
||||
#define KC_ALGR KC_RALT
|
||||
#define KC_ROPT KC_RALT
|
||||
#define KC_RCMD KC_RGUI
|
||||
#define KC_RWIN KC_RGUI
|
||||
#define KC_LCTL KC_LEFT_CTRL
|
||||
#define KC_LSFT KC_LEFT_SHIFT
|
||||
#define KC_LALT KC_LEFT_ALT
|
||||
#define KC_LOPT KC_LEFT_ALT
|
||||
#define KC_LGUI KC_LEFT_GUI
|
||||
#define KC_LCMD KC_LEFT_GUI
|
||||
#define KC_LWIN KC_LEFT_GUI
|
||||
#define KC_RCTL KC_RIGHT_CTRL
|
||||
#define KC_RSFT KC_RIGHT_SHIFT
|
||||
#define KC_RALT KC_RIGHT_ALT
|
||||
#define KC_ALGR KC_RIGHT_ALT
|
||||
#define KC_ROPT KC_RIGHT_ALT
|
||||
#define KC_RGUI KC_RIGHT_GUI
|
||||
#define KC_RCMD KC_RIGHT_GUI
|
||||
#define KC_RWIN KC_RIGHT_GUI
|
||||
|
||||
/* Generic Desktop Page (0x01) */
|
||||
#define KC_PWR KC_SYSTEM_POWER
|
||||
#define KC_PWR KC_SYSTEM_POWER
|
||||
#define KC_SLEP KC_SYSTEM_SLEEP
|
||||
#define KC_WAKE KC_SYSTEM_WAKE
|
||||
|
||||
|
@ -193,7 +215,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
|
||||
/* System Specific */
|
||||
#define KC_BRMU KC_PAUSE
|
||||
#define KC_BRMD KC_SCROLLLOCK
|
||||
#define KC_BRMD KC_SCROLL_LOCK
|
||||
|
||||
/* Mouse Keys */
|
||||
#define KC_MS_U KC_MS_UP
|
||||
|
@ -216,6 +238,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
#define KC_ACL1 KC_MS_ACCEL1
|
||||
#define KC_ACL2 KC_MS_ACCEL2
|
||||
|
||||
// clang-format on
|
||||
|
||||
/* Keyboard/Keypad Page (0x07) */
|
||||
enum hid_keyboard_keypad_usage {
|
||||
KC_NO = 0x00,
|
||||
|
@ -260,22 +284,22 @@ enum hid_keyboard_keypad_usage {
|
|||
KC_0,
|
||||
KC_ENTER,
|
||||
KC_ESCAPE,
|
||||
KC_BSPACE,
|
||||
KC_BACKSPACE,
|
||||
KC_TAB,
|
||||
KC_SPACE,
|
||||
KC_MINUS,
|
||||
KC_EQUAL,
|
||||
KC_LBRACKET,
|
||||
KC_RBRACKET, // 0x30
|
||||
KC_BSLASH,
|
||||
KC_LEFT_BRACKET,
|
||||
KC_RIGHT_BRACKET, // 0x30
|
||||
KC_BACKSLASH,
|
||||
KC_NONUS_HASH,
|
||||
KC_SCOLON,
|
||||
KC_SEMICOLON,
|
||||
KC_QUOTE,
|
||||
KC_GRAVE,
|
||||
KC_COMMA,
|
||||
KC_DOT,
|
||||
KC_SLASH,
|
||||
KC_CAPSLOCK,
|
||||
KC_CAPS_LOCK,
|
||||
KC_F1,
|
||||
KC_F2,
|
||||
KC_F3,
|
||||
|
@ -288,20 +312,20 @@ enum hid_keyboard_keypad_usage {
|
|||
KC_F10,
|
||||
KC_F11,
|
||||
KC_F12,
|
||||
KC_PSCREEN,
|
||||
KC_SCROLLLOCK,
|
||||
KC_PRINT_SCREEN,
|
||||
KC_SCROLL_LOCK,
|
||||
KC_PAUSE,
|
||||
KC_INSERT,
|
||||
KC_HOME,
|
||||
KC_PGUP,
|
||||
KC_PAGE_UP,
|
||||
KC_DELETE,
|
||||
KC_END,
|
||||
KC_PGDOWN,
|
||||
KC_PAGE_DOWN,
|
||||
KC_RIGHT,
|
||||
KC_LEFT, // 0x50
|
||||
KC_DOWN,
|
||||
KC_UP,
|
||||
KC_NUMLOCK,
|
||||
KC_NUM_LOCK,
|
||||
KC_KP_SLASH,
|
||||
KC_KP_ASTERISK,
|
||||
KC_KP_MINUS,
|
||||
|
@ -318,9 +342,9 @@ enum hid_keyboard_keypad_usage {
|
|||
KC_KP_9,
|
||||
KC_KP_0,
|
||||
KC_KP_DOT,
|
||||
KC_NONUS_BSLASH,
|
||||
KC_NONUS_BACKSLASH,
|
||||
KC_APPLICATION,
|
||||
KC_POWER,
|
||||
KC_KB_POWER,
|
||||
KC_KP_EQUAL,
|
||||
KC_F13,
|
||||
KC_F14,
|
||||
|
@ -345,34 +369,34 @@ enum hid_keyboard_keypad_usage {
|
|||
KC_COPY,
|
||||
KC_PASTE,
|
||||
KC_FIND,
|
||||
KC__MUTE,
|
||||
KC__VOLUP, // 0x80
|
||||
KC__VOLDOWN,
|
||||
KC_LOCKING_CAPS,
|
||||
KC_LOCKING_NUM,
|
||||
KC_LOCKING_SCROLL,
|
||||
KC_KB_MUTE,
|
||||
KC_KB_VOLUME_UP, // 0x80
|
||||
KC_KB_VOLUME_DOWN,
|
||||
KC_LOCKING_CAPS_LOCK,
|
||||
KC_LOCKING_NUM_LOCK,
|
||||
KC_LOCKING_SCROLL_LOCK,
|
||||
KC_KP_COMMA,
|
||||
KC_KP_EQUAL_AS400,
|
||||
KC_INT1,
|
||||
KC_INT2,
|
||||
KC_INT3,
|
||||
KC_INT4,
|
||||
KC_INT5,
|
||||
KC_INT6,
|
||||
KC_INT7,
|
||||
KC_INT8,
|
||||
KC_INT9,
|
||||
KC_LANG1, // 0x90
|
||||
KC_LANG2,
|
||||
KC_LANG3,
|
||||
KC_LANG4,
|
||||
KC_LANG5,
|
||||
KC_LANG6,
|
||||
KC_LANG7,
|
||||
KC_LANG8,
|
||||
KC_LANG9,
|
||||
KC_ALT_ERASE,
|
||||
KC_SYSREQ,
|
||||
KC_INTERNATIONAL_1,
|
||||
KC_INTERNATIONAL_2,
|
||||
KC_INTERNATIONAL_3,
|
||||
KC_INTERNATIONAL_4,
|
||||
KC_INTERNATIONAL_5,
|
||||
KC_INTERNATIONAL_6,
|
||||
KC_INTERNATIONAL_7,
|
||||
KC_INTERNATIONAL_8,
|
||||
KC_INTERNATIONAL_9,
|
||||
KC_LANGUAGE_1, // 0x90
|
||||
KC_LANGUAGE_2,
|
||||
KC_LANGUAGE_3,
|
||||
KC_LANGUAGE_4,
|
||||
KC_LANGUAGE_5,
|
||||
KC_LANGUAGE_6,
|
||||
KC_LANGUAGE_7,
|
||||
KC_LANGUAGE_8,
|
||||
KC_LANGUAGE_9,
|
||||
KC_ALTERNATE_ERASE,
|
||||
KC_SYSTEM_REQUEST,
|
||||
KC_CANCEL,
|
||||
KC_CLEAR,
|
||||
KC_PRIOR,
|
||||
|
@ -397,12 +421,12 @@ enum hid_keyboard_keypad_usage {
|
|||
KC_DECIMAL_SEPARATOR,
|
||||
KC_CURRENCY_UNIT,
|
||||
KC_CURRENCY_SUB_UNIT,
|
||||
KC_KP_LPAREN,
|
||||
KC_KP_RPAREN,
|
||||
KC_KP_LCBRACKET,
|
||||
KC_KP_RCBRACKET,
|
||||
KC_KP_LEFT_PARENTHESIS,
|
||||
KC_KP_RIGHT_PARENTHESIS,
|
||||
KC_KP_LEFT_BRACE,
|
||||
KC_KP_RIGHT_BRACE,
|
||||
KC_KP_TAB,
|
||||
KC_KP_BSPACE,
|
||||
KC_KP_BACKSPACE,
|
||||
KC_KP_A,
|
||||
KC_KP_B,
|
||||
KC_KP_C,
|
||||
|
@ -411,17 +435,17 @@ enum hid_keyboard_keypad_usage {
|
|||
KC_KP_F,
|
||||
KC_KP_XOR,
|
||||
KC_KP_HAT,
|
||||
KC_KP_PERC,
|
||||
KC_KP_LT,
|
||||
KC_KP_GT,
|
||||
KC_KP_PERCENT,
|
||||
KC_KP_LESS_THAN,
|
||||
KC_KP_GREATER_THAN,
|
||||
KC_KP_AND,
|
||||
KC_KP_LAZYAND,
|
||||
KC_KP_LAZY_AND,
|
||||
KC_KP_OR,
|
||||
KC_KP_LAZYOR,
|
||||
KC_KP_LAZY_OR,
|
||||
KC_KP_COLON,
|
||||
KC_KP_HASH,
|
||||
KC_KP_SPACE,
|
||||
KC_KP_ATMARK,
|
||||
KC_KP_AT,
|
||||
KC_KP_EXCLAMATION,
|
||||
KC_KP_MEM_STORE, //0xD0
|
||||
KC_KP_MEM_RECALL,
|
||||
|
@ -440,14 +464,14 @@ enum hid_keyboard_keypad_usage {
|
|||
#endif
|
||||
|
||||
/* Modifiers */
|
||||
KC_LCTRL = 0xE0,
|
||||
KC_LSHIFT,
|
||||
KC_LALT,
|
||||
KC_LGUI,
|
||||
KC_RCTRL,
|
||||
KC_RSHIFT,
|
||||
KC_RALT,
|
||||
KC_RGUI
|
||||
KC_LEFT_CTRL = 0xE0,
|
||||
KC_LEFT_SHIFT,
|
||||
KC_LEFT_ALT,
|
||||
KC_LEFT_GUI,
|
||||
KC_RIGHT_CTRL,
|
||||
KC_RIGHT_SHIFT,
|
||||
KC_RIGHT_ALT,
|
||||
KC_RIGHT_GUI
|
||||
|
||||
// **********************************************
|
||||
// * 0xF0-0xFF are unallocated in the HID spec. *
|
||||
|
@ -558,3 +582,5 @@ enum mouse_keys {
|
|||
KC_MS_ACCEL1,
|
||||
KC_MS_ACCEL2 // 0xFF
|
||||
};
|
||||
|
||||
#include "keycode_legacy.h"
|
||||
|
|
|
@ -25,89 +25,89 @@ extern keymap_config_t keymap_config;
|
|||
*/
|
||||
uint16_t keycode_config(uint16_t keycode) {
|
||||
switch (keycode) {
|
||||
case KC_CAPSLOCK:
|
||||
case KC_LOCKING_CAPS:
|
||||
case KC_CAPS_LOCK:
|
||||
case KC_LOCKING_CAPS_LOCK:
|
||||
if (keymap_config.swap_control_capslock || keymap_config.capslock_to_control) {
|
||||
return KC_LCTL;
|
||||
return KC_LEFT_CTRL;
|
||||
}
|
||||
return keycode;
|
||||
case KC_LCTL:
|
||||
case KC_LEFT_CTRL:
|
||||
if (keymap_config.swap_control_capslock) {
|
||||
return KC_CAPSLOCK;
|
||||
return KC_CAPS_LOCK;
|
||||
}
|
||||
if (keymap_config.swap_lctl_lgui) {
|
||||
if (keymap_config.no_gui) {
|
||||
return KC_NO;
|
||||
}
|
||||
return KC_LGUI;
|
||||
return KC_LEFT_GUI;
|
||||
}
|
||||
return KC_LCTL;
|
||||
case KC_LALT:
|
||||
return KC_LEFT_CTRL;
|
||||
case KC_LEFT_ALT:
|
||||
if (keymap_config.swap_lalt_lgui) {
|
||||
if (keymap_config.no_gui) {
|
||||
return KC_NO;
|
||||
}
|
||||
return KC_LGUI;
|
||||
return KC_LEFT_GUI;
|
||||
}
|
||||
return KC_LALT;
|
||||
case KC_LGUI:
|
||||
return KC_LEFT_ALT;
|
||||
case KC_LEFT_GUI:
|
||||
if (keymap_config.swap_lalt_lgui) {
|
||||
return KC_LALT;
|
||||
return KC_LEFT_ALT;
|
||||
}
|
||||
if (keymap_config.swap_lctl_lgui) {
|
||||
return KC_LCTRL;
|
||||
return KC_LEFT_CTRL;
|
||||
}
|
||||
if (keymap_config.no_gui) {
|
||||
return KC_NO;
|
||||
}
|
||||
return KC_LGUI;
|
||||
case KC_RCTL:
|
||||
return KC_LEFT_GUI;
|
||||
case KC_RIGHT_CTRL:
|
||||
if (keymap_config.swap_rctl_rgui) {
|
||||
if (keymap_config.no_gui) {
|
||||
return KC_NO;
|
||||
}
|
||||
return KC_RGUI;
|
||||
return KC_RIGHT_GUI;
|
||||
}
|
||||
return KC_RCTL;
|
||||
case KC_RALT:
|
||||
return KC_RIGHT_CTRL;
|
||||
case KC_RIGHT_ALT:
|
||||
if (keymap_config.swap_ralt_rgui) {
|
||||
if (keymap_config.no_gui) {
|
||||
return KC_NO;
|
||||
}
|
||||
return KC_RGUI;
|
||||
return KC_RIGHT_GUI;
|
||||
}
|
||||
return KC_RALT;
|
||||
case KC_RGUI:
|
||||
return KC_RIGHT_ALT;
|
||||
case KC_RIGHT_GUI:
|
||||
if (keymap_config.swap_ralt_rgui) {
|
||||
return KC_RALT;
|
||||
return KC_RIGHT_ALT;
|
||||
}
|
||||
if (keymap_config.swap_rctl_rgui) {
|
||||
return KC_RCTL;
|
||||
return KC_RIGHT_CTRL;
|
||||
}
|
||||
if (keymap_config.no_gui) {
|
||||
return KC_NO;
|
||||
}
|
||||
return KC_RGUI;
|
||||
return KC_RIGHT_GUI;
|
||||
case KC_GRAVE:
|
||||
if (keymap_config.swap_grave_esc) {
|
||||
return KC_ESC;
|
||||
return KC_ESCAPE;
|
||||
}
|
||||
return KC_GRAVE;
|
||||
case KC_ESC:
|
||||
case KC_ESCAPE:
|
||||
if (keymap_config.swap_grave_esc) {
|
||||
return KC_GRAVE;
|
||||
}
|
||||
return KC_ESC;
|
||||
case KC_BSLASH:
|
||||
return KC_ESCAPE;
|
||||
case KC_BACKSLASH:
|
||||
if (keymap_config.swap_backslash_backspace) {
|
||||
return KC_BSPACE;
|
||||
return KC_BACKSPACE;
|
||||
}
|
||||
return KC_BSLASH;
|
||||
case KC_BSPACE:
|
||||
return KC_BACKSLASH;
|
||||
case KC_BACKSPACE:
|
||||
if (keymap_config.swap_backslash_backspace) {
|
||||
return KC_BSLASH;
|
||||
return KC_BACKSLASH;
|
||||
}
|
||||
return KC_BSPACE;
|
||||
return KC_BACKSPACE;
|
||||
default:
|
||||
return keycode;
|
||||
}
|
||||
|
|
53
quantum/keycode_legacy.h
Normal file
53
quantum/keycode_legacy.h
Normal file
|
@ -0,0 +1,53 @@
|
|||
#pragma once
|
||||
|
||||
// clang-format off
|
||||
|
||||
// These keycode names have been deprecated
|
||||
|
||||
#define KC_BSPACE KC_BACKSPACE
|
||||
#define KC_LBRACKET KC_LEFT_BRACKET
|
||||
#define KC_RBRACKET KC_RIGHT_BRACKET
|
||||
#define KC_BSLASH KC_BACKSLASH
|
||||
#define KC_SCOLON KC_SEMICOLON
|
||||
#define KC_CAPSLOCK KC_CAPS_LOCK
|
||||
#define KC_PSCREEN KC_PRINT_SCREEN
|
||||
#define KC_SCROLLLOCK KC_SCROLL_LOCK
|
||||
#define KC_PGDOWN KC_PAGE_DOWN
|
||||
#define KC_NUMLOCK KC_NUM_LOCK
|
||||
#define KC_NONUS_BSLASH KC_NONUS_BACKSLASH
|
||||
#define KC_POWER KC_KB_POWER
|
||||
#define KC__MUTE KC_KB_MUTE
|
||||
#define KC__VOLUP KC_KB_VOLUME_UP
|
||||
#define KC__VOLDOWN KC_KB_VOLUME_DOWN
|
||||
#define KC_LOCKING_CAPS KC_LOCKING_CAPS_LOCK
|
||||
#define KC_LOCKING_NUM KC_LOCKING_NUM_LOCK
|
||||
#define KC_LOCKING_SCROLL KC_LOCKING_SCROLL_LOCK
|
||||
#define KC_LANG1 KC_LANGUAGE_1
|
||||
#define KC_LANG2 KC_LANGUAGE_2
|
||||
#define KC_LANG3 KC_LANGUAGE_3
|
||||
#define KC_LANG4 KC_LANGUAGE_4
|
||||
#define KC_LANG5 KC_LANGUAGE_5
|
||||
#define KC_LANG6 KC_LANGUAGE_6
|
||||
#define KC_LANG7 KC_LANGUAGE_7
|
||||
#define KC_LANG8 KC_LANGUAGE_8
|
||||
#define KC_LANG9 KC_LANGUAGE_9
|
||||
#define KC_ALT_ERASE KC_ALTERNATE_ERASE
|
||||
#define KC_SYSREQ KC_SYSTEM_REQUEST
|
||||
|
||||
#define KC_LCTRL KC_LEFT_CTRL
|
||||
#define KC_LSHIFT KC_LEFT_SHIFT
|
||||
#define KC_RCTRL KC_RIGHT_CTRL
|
||||
#define KC_RSHIFT KC_RIGHT_SHIFT
|
||||
|
||||
#define KC_ZKHK KC_GRAVE
|
||||
#define KC_RO KC_INTERNATIONAL_1
|
||||
#define KC_KANA KC_INTERNATIONAL_2
|
||||
#define KC_JYEN KC_INTERNATIONAL_3
|
||||
#define KC_HENK KC_INTERNATIONAL_4
|
||||
#define KC_MHEN KC_INTERNATIONAL_5
|
||||
#define KC_HAEN KC_LANGUAGE_1
|
||||
#define KC_HANJ KC_LANGUAGE_2
|
||||
|
||||
#define KC_CLCK KC_CAPS_LOCK
|
||||
#define KC_SLCK KC_SCROLL_LOCK
|
||||
#define KC_NLCK KC_NUM_LOCK
|
|
@ -56,7 +56,7 @@ action_t action_for_keycode(uint16_t keycode) {
|
|||
|
||||
switch (keycode) {
|
||||
case KC_A ... KC_EXSEL:
|
||||
case KC_LCTRL ... KC_RGUI:
|
||||
case KC_LEFT_CTRL ... KC_RIGHT_GUI:
|
||||
action.code = ACTION_KEY(keycode);
|
||||
break;
|
||||
#ifdef EXTRAKEY_ENABLE
|
||||
|
@ -72,7 +72,7 @@ action_t action_for_keycode(uint16_t keycode) {
|
|||
action.code = ACTION_MOUSEKEY(keycode);
|
||||
break;
|
||||
#endif
|
||||
case KC_TRNS:
|
||||
case KC_TRANSPARENT:
|
||||
action.code = ACTION_TRANSPARENT;
|
||||
break;
|
||||
case QK_MODS ... QK_MODS_MAX:;
|
||||
|
|
|
@ -85,8 +85,8 @@
|
|||
#define KR_DOT KC_DOT // .
|
||||
#define KR_SLSH KC_SLSH // /
|
||||
// Row 5
|
||||
#define KR_HANJ KC_LANG2 // Hanja (한자)
|
||||
#define KR_HAEN KC_LANG1 // Han ↔ Yeong (한 ↔ 영)
|
||||
#define KR_HANJ KC_LNG2 // Hanja (한자)
|
||||
#define KR_HAEN KC_LNG1 // Han ↔ Yeong (한 ↔ 영)
|
||||
|
||||
/* Shifted symbols
|
||||
* ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐
|
||||
|
|
|
@ -67,7 +67,7 @@ static bool autoshift_press(uint16_t keycode, uint16_t now, keyrecord_t *record)
|
|||
register_code(autoshift_lastkey);
|
||||
} else {
|
||||
// Simulate pressing the shift key.
|
||||
add_weak_mods(MOD_BIT(KC_LSFT));
|
||||
add_weak_mods(MOD_BIT(KC_LEFT_SHIFT));
|
||||
register_code(autoshift_lastkey);
|
||||
}
|
||||
return false;
|
||||
|
@ -108,7 +108,7 @@ static void autoshift_end(uint16_t keycode, uint16_t now, bool matrix_trigger) {
|
|||
autoshift_flags.lastshifted = false;
|
||||
} else {
|
||||
// Simulate pressing the shift key.
|
||||
add_weak_mods(MOD_BIT(KC_LSFT));
|
||||
add_weak_mods(MOD_BIT(KC_LEFT_SHIFT));
|
||||
register_code(autoshift_lastkey);
|
||||
autoshift_flags.lastshifted = true;
|
||||
# if defined(AUTO_SHIFT_REPEAT) && !defined(AUTO_SHIFT_NO_AUTO_REPEAT)
|
||||
|
@ -123,7 +123,7 @@ static void autoshift_end(uint16_t keycode, uint16_t now, bool matrix_trigger) {
|
|||
wait_ms(TAP_CODE_DELAY);
|
||||
# endif
|
||||
unregister_code(autoshift_lastkey);
|
||||
del_weak_mods(MOD_BIT(KC_LSFT));
|
||||
del_weak_mods(MOD_BIT(KC_LEFT_SHIFT));
|
||||
} else {
|
||||
// Release after keyrepeat.
|
||||
unregister_code(keycode);
|
||||
|
@ -131,7 +131,7 @@ static void autoshift_end(uint16_t keycode, uint16_t now, bool matrix_trigger) {
|
|||
// This will only fire when the key was the last auto-shiftable
|
||||
// pressed. That prevents aaaaBBBB then releasing a from unshifting
|
||||
// later Bs (if B wasn't auto-shiftable).
|
||||
del_weak_mods(MOD_BIT(KC_LSFT));
|
||||
del_weak_mods(MOD_BIT(KC_LEFT_SHIFT));
|
||||
}
|
||||
}
|
||||
send_keyboard_report(); // del_weak_mods doesn't send one.
|
||||
|
@ -157,14 +157,14 @@ void autoshift_matrix_scan(void) {
|
|||
|
||||
void autoshift_toggle(void) {
|
||||
autoshift_flags.enabled = !autoshift_flags.enabled;
|
||||
del_weak_mods(MOD_BIT(KC_LSFT));
|
||||
del_weak_mods(MOD_BIT(KC_LEFT_SHIFT));
|
||||
}
|
||||
|
||||
void autoshift_enable(void) { autoshift_flags.enabled = true; }
|
||||
|
||||
void autoshift_disable(void) {
|
||||
autoshift_flags.enabled = false;
|
||||
del_weak_mods(MOD_BIT(KC_LSFT));
|
||||
del_weak_mods(MOD_BIT(KC_LEFT_SHIFT));
|
||||
}
|
||||
|
||||
# ifndef AUTO_SHIFT_NO_SETUP
|
||||
|
@ -195,7 +195,7 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
|
|||
autoshift_end(KC_NO, now, false);
|
||||
}
|
||||
// For pressing another key while keyrepeating shifted autoshift.
|
||||
del_weak_mods(MOD_BIT(KC_LSFT));
|
||||
del_weak_mods(MOD_BIT(KC_LEFT_SHIFT));
|
||||
|
||||
switch (keycode) {
|
||||
case KC_ASTG:
|
||||
|
@ -244,7 +244,7 @@ __attribute__((weak)) bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *r
|
|||
# ifndef NO_AUTO_SHIFT_SPECIAL
|
||||
case KC_TAB:
|
||||
case KC_MINUS ... KC_SLASH:
|
||||
case KC_NONUS_BSLASH:
|
||||
case KC_NONUS_BACKSLASH:
|
||||
# endif
|
||||
return true;
|
||||
}
|
||||
|
|
|
@ -31,7 +31,7 @@ __attribute__((weak)) bool get_haptic_enabled_key(uint16_t keycode, keyrecord_t
|
|||
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
|
||||
if (record->tap.count == 0) return false;
|
||||
break;
|
||||
case KC_LCTRL ... KC_RGUI:
|
||||
case KC_LEFT_CTRL ... KC_RIGHT_GUI:
|
||||
case QK_MOMENTARY ... QK_MOMENTARY_MAX:
|
||||
case QK_LAYER_MOD ... QK_LAYER_MOD_MAX:
|
||||
#endif
|
||||
|
@ -44,34 +44,34 @@ __attribute__((weak)) bool get_haptic_enabled_key(uint16_t keycode, keyrecord_t
|
|||
#ifdef NO_HAPTIC_PUNCTUATION
|
||||
case KC_ENTER:
|
||||
case KC_ESCAPE:
|
||||
case KC_BSPACE:
|
||||
case KC_BACKSPACE:
|
||||
case KC_SPACE:
|
||||
case KC_MINUS:
|
||||
case KC_EQUAL:
|
||||
case KC_LBRACKET:
|
||||
case KC_RBRACKET:
|
||||
case KC_BSLASH:
|
||||
case KC_LEFT_BRACKET:
|
||||
case KC_RIGHT_BRACKET:
|
||||
case KC_BACKSLASH:
|
||||
case KC_NONUS_HASH:
|
||||
case KC_SCOLON:
|
||||
case KC_SEMICOLON:
|
||||
case KC_QUOTE:
|
||||
case KC_GRAVE:
|
||||
case KC_COMMA:
|
||||
case KC_SLASH:
|
||||
case KC_DOT:
|
||||
case KC_NONUS_BSLASH:
|
||||
case KC_NONUS_BACKSLASH:
|
||||
#endif
|
||||
#ifdef NO_HAPTIC_LOCKKEYS
|
||||
case KC_CAPSLOCK:
|
||||
case KC_SCROLLLOCK:
|
||||
case KC_NUMLOCK:
|
||||
case KC_CAPS_LOCK:
|
||||
case KC_SCROLL_LOCK:
|
||||
case KC_NUM_LOCK:
|
||||
#endif
|
||||
#ifdef NO_HAPTIC_NAV
|
||||
case KC_PSCREEN:
|
||||
case KC_PRINT_SCREEN:
|
||||
case KC_PAUSE:
|
||||
case KC_INSERT:
|
||||
case KC_DELETE:
|
||||
case KC_PGDOWN:
|
||||
case KC_PGUP:
|
||||
case KC_PAGE_DOWN:
|
||||
case KC_PAGE_UP:
|
||||
case KC_LEFT:
|
||||
case KC_UP:
|
||||
case KC_RIGHT:
|
||||
|
|
|
@ -146,7 +146,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
|
|||
|
||||
if (music_activated || midi_activated) {
|
||||
if (record->event.pressed) {
|
||||
if (keycode == KC_LCTL) { // Start recording
|
||||
if (keycode == KC_LEFT_CTRL) { // Start recording
|
||||
music_all_notes_off();
|
||||
music_sequence_recording = true;
|
||||
music_sequence_recorded = false;
|
||||
|
@ -155,7 +155,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
|
|||
return false;
|
||||
}
|
||||
|
||||
if (keycode == KC_LALT) { // Stop recording/playing
|
||||
if (keycode == KC_LEFT_ALT) { // Stop recording/playing
|
||||
music_all_notes_off();
|
||||
if (music_sequence_recording) { // was recording
|
||||
music_sequence_recorded = true;
|
||||
|
@ -165,7 +165,7 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
|
|||
return false;
|
||||
}
|
||||
|
||||
if (keycode == KC_LGUI && music_sequence_recorded) { // Start playing
|
||||
if (keycode == KC_LEFT_GUI && music_sequence_recorded) { // Start playing
|
||||
music_all_notes_off();
|
||||
music_sequence_recording = false;
|
||||
music_sequence_playing = true;
|
||||
|
|
|
@ -31,7 +31,7 @@ uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0
|
|||
|
||||
// uint8_t keycode_to_ascii[0xFF][2];
|
||||
|
||||
// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
|
||||
// keycode_to_ascii[KC_MINUS] = {0x2D, 0x5F};
|
||||
|
||||
void print_char(char c) {
|
||||
USB_Disable();
|
||||
|
@ -90,8 +90,8 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
case KC_PIPE:
|
||||
case KC_TILD:
|
||||
keycode &= 0xFF;
|
||||
case KC_LSFT:
|
||||
case KC_RSFT:
|
||||
case KC_LEFT_SHIFT:
|
||||
case KC_RIGHT_SHIFT:
|
||||
if (record->event.pressed) {
|
||||
character_shift++;
|
||||
} else {
|
||||
|
@ -107,13 +107,13 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
print_box_string("This is a line of text!");
|
||||
}
|
||||
return false;
|
||||
case KC_ESC:
|
||||
case KC_ESCAPE:
|
||||
if (record->event.pressed) {
|
||||
print_char(0x1B);
|
||||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_SPC:
|
||||
case KC_SPACE:
|
||||
if (record->event.pressed) {
|
||||
print_char(0x20);
|
||||
}
|
||||
|
@ -139,7 +139,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_ENT:
|
||||
case KC_ENTER:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x0C);
|
||||
|
@ -149,7 +149,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_BSPC:
|
||||
case KC_BACKSPACE:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x18);
|
||||
|
@ -169,7 +169,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_COMM:
|
||||
case KC_COMMA:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x3C);
|
||||
|
@ -179,7 +179,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_SLSH:
|
||||
case KC_SLASH:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x3F);
|
||||
|
@ -189,7 +189,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_QUOT:
|
||||
case KC_QUOTE:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x22);
|
||||
|
@ -199,7 +199,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_GRV:
|
||||
case KC_GRAVE:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7E);
|
||||
|
@ -209,7 +209,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_MINS:
|
||||
case KC_MINUS:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x5F);
|
||||
|
@ -219,7 +219,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_EQL:
|
||||
case KC_EQUAL:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x2B);
|
||||
|
@ -229,7 +229,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_LBRC:
|
||||
case KC_LEFT_BRACKET:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7B);
|
||||
|
@ -239,7 +239,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_RBRC:
|
||||
case KC_RIGHT_BRACKET:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7D);
|
||||
|
@ -249,7 +249,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_BSLS:
|
||||
case KC_BACKSLASH:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7C);
|
||||
|
|
|
@ -45,7 +45,7 @@ uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0
|
|||
|
||||
// uint8_t keycode_to_ascii[0xFF][2];
|
||||
|
||||
// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
|
||||
// keycode_to_ascii[KC_MINUS] = {0x2D, 0x5F};
|
||||
|
||||
void print_char(char c) {
|
||||
uint8_t b = 8;
|
||||
|
@ -84,8 +84,8 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
case KC_PIPE:
|
||||
case KC_TILD:
|
||||
keycode &= 0xFF;
|
||||
case KC_LSFT:
|
||||
case KC_RSFT:
|
||||
case KC_LEFT_SHIFT:
|
||||
case KC_RIGHT_SHIFT:
|
||||
if (record->event.pressed) {
|
||||
character_shift++;
|
||||
} else {
|
||||
|
@ -101,13 +101,13 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
print_string("This is a line of text!\n\n\n");
|
||||
}
|
||||
return false;
|
||||
case KC_ESC:
|
||||
case KC_ESCAPE:
|
||||
if (record->event.pressed) {
|
||||
print_char(0x1B);
|
||||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_SPC:
|
||||
case KC_SPACE:
|
||||
if (record->event.pressed) {
|
||||
print_char(0x20);
|
||||
}
|
||||
|
@ -133,7 +133,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_ENT:
|
||||
case KC_ENTER:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x0C);
|
||||
|
@ -143,7 +143,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_BSPC:
|
||||
case KC_BACKSPACE:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x18);
|
||||
|
@ -163,7 +163,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_COMM:
|
||||
case KC_COMMA:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x3C);
|
||||
|
@ -173,7 +173,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_SLSH:
|
||||
case KC_SLASH:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x3F);
|
||||
|
@ -183,7 +183,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_QUOT:
|
||||
case KC_QUOTE:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x22);
|
||||
|
@ -193,7 +193,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_GRV:
|
||||
case KC_GRAVE:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7E);
|
||||
|
@ -203,7 +203,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_MINS:
|
||||
case KC_MINUS:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x5F);
|
||||
|
@ -213,7 +213,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_EQL:
|
||||
case KC_EQUAL:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x2B);
|
||||
|
@ -223,7 +223,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_LBRC:
|
||||
case KC_LEFT_BRACKET:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7B);
|
||||
|
@ -233,7 +233,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_RBRC:
|
||||
case KC_RIGHT_BRACKET:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7D);
|
||||
|
@ -243,7 +243,7 @@ bool process_printer(uint16_t keycode, keyrecord_t *record) {
|
|||
}
|
||||
return false;
|
||||
break;
|
||||
case KC_BSLS:
|
||||
case KC_BACKSLASH:
|
||||
if (record->event.pressed) {
|
||||
if (character_shift) {
|
||||
print_char(0x7C);
|
||||
|
|
|
@ -27,53 +27,53 @@
|
|||
|
||||
// Shift / Enter setup
|
||||
#ifndef SFTENT_KEY
|
||||
# define SFTENT_KEY KC_ENT
|
||||
# define SFTENT_KEY KC_ENTER
|
||||
#endif
|
||||
|
||||
#ifdef DISABLE_SPACE_CADET_MODIFIER
|
||||
# ifndef LSPO_MOD
|
||||
# define LSPO_MOD KC_TRNS
|
||||
# define LSPO_MOD KC_TRANSPARENT
|
||||
# endif
|
||||
# ifndef RSPC_MOD
|
||||
# define RSPC_MOD KC_TRNS
|
||||
# define RSPC_MOD KC_TRANSPARENT
|
||||
# endif
|
||||
#else
|
||||
# ifndef LSPO_MOD
|
||||
# define LSPO_MOD KC_LSFT
|
||||
# define LSPO_MOD KC_LEFT_SHIFT
|
||||
# endif
|
||||
# ifndef RSPC_MOD
|
||||
# define RSPC_MOD KC_RSFT
|
||||
# define RSPC_MOD KC_RIGHT_SHIFT
|
||||
# endif
|
||||
#endif
|
||||
// **********************************************************
|
||||
|
||||
// Shift / paren setup
|
||||
#ifndef LSPO_KEYS
|
||||
# define LSPO_KEYS KC_LSFT, LSPO_MOD, LSPO_KEY
|
||||
# define LSPO_KEYS KC_LEFT_SHIFT, LSPO_MOD, LSPO_KEY
|
||||
#endif
|
||||
#ifndef RSPC_KEYS
|
||||
# define RSPC_KEYS KC_RSFT, RSPC_MOD, RSPC_KEY
|
||||
# define RSPC_KEYS KC_RIGHT_SHIFT, RSPC_MOD, RSPC_KEY
|
||||
#endif
|
||||
|
||||
// Control / paren setup
|
||||
#ifndef LCPO_KEYS
|
||||
# define LCPO_KEYS KC_LCTL, KC_LSFT, KC_9
|
||||
# define LCPO_KEYS KC_LEFT_CTRL, KC_LEFT_SHIFT, KC_9
|
||||
#endif
|
||||
#ifndef RCPC_KEYS
|
||||
# define RCPC_KEYS KC_RCTL, KC_RSFT, KC_0
|
||||
# define RCPC_KEYS KC_RIGHT_CTRL, KC_RIGHT_SHIFT, KC_0
|
||||
#endif
|
||||
|
||||
// Alt / paren setup
|
||||
#ifndef LAPO_KEYS
|
||||
# define LAPO_KEYS KC_LALT, KC_LSFT, KC_9
|
||||
# define LAPO_KEYS KC_LEFT_ALT, KC_LEFT_SHIFT, KC_9
|
||||
#endif
|
||||
#ifndef RAPC_KEYS
|
||||
# define RAPC_KEYS KC_RALT, KC_RSFT, KC_0
|
||||
# define RAPC_KEYS KC_RIGHT_ALT, KC_RIGHT_SHIFT, KC_0
|
||||
#endif
|
||||
|
||||
// Shift / Enter setup
|
||||
#ifndef SFTENT_KEYS
|
||||
# define SFTENT_KEYS KC_RSFT, KC_TRNS, SFTENT_KEY
|
||||
# define SFTENT_KEYS KC_RIGHT_SHIFT, KC_TRANSPARENT, SFTENT_KEY
|
||||
#endif
|
||||
|
||||
static uint8_t sc_last = 0;
|
||||
|
|
|
@ -257,12 +257,12 @@ bool process_terminal(uint16_t keycode, keyrecord_t *record) {
|
|||
process_terminal_command();
|
||||
return false;
|
||||
break;
|
||||
case KC_ESC:
|
||||
case KC_ESCAPE:
|
||||
SEND_STRING("\n");
|
||||
enable_terminal();
|
||||
return false;
|
||||
break;
|
||||
case KC_BSPC:
|
||||
case KC_BACKSPACE:
|
||||
str_len = strlen(buffer);
|
||||
if (str_len > 0) {
|
||||
buffer[str_len - 1] = 0;
|
||||
|
@ -284,7 +284,7 @@ bool process_terminal(uint16_t keycode, keyrecord_t *record) {
|
|||
str_len = strlen(buffer);
|
||||
for (int i = 0; i < str_len; ++i) {
|
||||
send_string(SS_TAP(X_BSPACE)); // clear w/e is on the line already
|
||||
// process_terminal(KC_BSPC,record);
|
||||
// process_terminal(KC_BACKSPACE,record);
|
||||
}
|
||||
strncpy(buffer, cmd_buffer[current_cmd_buffer_pos], 80);
|
||||
|
||||
|
@ -299,7 +299,7 @@ bool process_terminal(uint16_t keycode, keyrecord_t *record) {
|
|||
str_len = strlen(buffer);
|
||||
for (int i = 0; i < str_len; ++i) {
|
||||
send_string(SS_TAP(X_BSPACE)); // clear w/e is on the line already
|
||||
// process_terminal(KC_BSPC,record);
|
||||
// process_terminal(KC_BACKSPACE,record);
|
||||
}
|
||||
strncpy(buffer, cmd_buffer[current_cmd_buffer_pos], 79);
|
||||
|
||||
|
@ -311,7 +311,7 @@ bool process_terminal(uint16_t keycode, keyrecord_t *record) {
|
|||
default:
|
||||
if (keycode <= 58) {
|
||||
char_to_add = 0;
|
||||
if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
|
||||
if (get_mods() & (MOD_BIT(KC_LEFT_SHIFT) | MOD_BIT(KC_RIGHT_SHIFT))) {
|
||||
char_to_add = shifted_keycode_to_ascii_lut[keycode];
|
||||
} else if (get_mods() == 0) {
|
||||
char_to_add = keycode_to_ascii_lut[keycode];
|
||||
|
|
|
@ -46,7 +46,7 @@ static bool is_uni_seq(char *seq) {
|
|||
return false;
|
||||
}
|
||||
}
|
||||
return qk_ucis_state.codes[i] == KC_ENT || qk_ucis_state.codes[i] == KC_SPC;
|
||||
return qk_ucis_state.codes[i] == KC_ENTER || qk_ucis_state.codes[i] == KC_SPACE;
|
||||
}
|
||||
|
||||
__attribute__((weak)) void qk_ucis_symbol_fallback(void) {
|
||||
|
@ -72,7 +72,7 @@ bool process_ucis(uint16_t keycode, keyrecord_t *record) {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool special = keycode == KC_SPC || keycode == KC_ENT || keycode == KC_ESC || keycode == KC_BSPC;
|
||||
bool special = keycode == KC_SPACE || keycode == KC_ENTER || keycode == KC_ESCAPE || keycode == KC_BACKSPACE;
|
||||
if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH && !special) {
|
||||
return false;
|
||||
}
|
||||
|
@ -81,7 +81,7 @@ bool process_ucis(uint16_t keycode, keyrecord_t *record) {
|
|||
qk_ucis_state.count++;
|
||||
|
||||
switch (keycode) {
|
||||
case KC_BSPC:
|
||||
case KC_BACKSPACE:
|
||||
if (qk_ucis_state.count >= 2) {
|
||||
qk_ucis_state.count -= 2;
|
||||
return true;
|
||||
|
@ -90,16 +90,16 @@ bool process_ucis(uint16_t keycode, keyrecord_t *record) {
|
|||
return false;
|
||||
}
|
||||
|
||||
case KC_SPC:
|
||||
case KC_ENT:
|
||||
case KC_ESC:
|
||||
case KC_SPACE:
|
||||
case KC_ENTER:
|
||||
case KC_ESCAPE:
|
||||
for (uint8_t i = 0; i < qk_ucis_state.count; i++) {
|
||||
register_code(KC_BSPC);
|
||||
unregister_code(KC_BSPC);
|
||||
register_code(KC_BACKSPACE);
|
||||
unregister_code(KC_BACKSPACE);
|
||||
wait_ms(UNICODE_TYPE_DELAY);
|
||||
}
|
||||
|
||||
if (keycode == KC_ESC) {
|
||||
if (keycode == KC_ESCAPE) {
|
||||
qk_ucis_state.in_progress = false;
|
||||
qk_ucis_cancel();
|
||||
return false;
|
||||
|
|
|
@ -87,7 +87,7 @@ __attribute__((weak)) void unicode_input_start(void) {
|
|||
// UNICODE_KEY_LNX (which is usually Ctrl-Shift-U) might not work
|
||||
// correctly in the shifted case.
|
||||
if (unicode_config.input_mode == UC_LNX && unicode_saved_caps_lock) {
|
||||
tap_code(KC_CAPSLOCK);
|
||||
tap_code(KC_CAPS_LOCK);
|
||||
}
|
||||
|
||||
unicode_saved_mods = get_mods(); // Save current mods
|
||||
|
@ -103,9 +103,9 @@ __attribute__((weak)) void unicode_input_start(void) {
|
|||
case UC_WIN:
|
||||
// For increased reliability, use numpad keys for inputting digits
|
||||
if (!unicode_saved_num_lock) {
|
||||
tap_code(KC_NUMLOCK);
|
||||
tap_code(KC_NUM_LOCK);
|
||||
}
|
||||
register_code(KC_LALT);
|
||||
register_code(KC_LEFT_ALT);
|
||||
tap_code(KC_KP_PLUS);
|
||||
break;
|
||||
case UC_WINC:
|
||||
|
@ -125,13 +125,13 @@ __attribute__((weak)) void unicode_input_finish(void) {
|
|||
case UC_LNX:
|
||||
tap_code(KC_SPACE);
|
||||
if (unicode_saved_caps_lock) {
|
||||
tap_code(KC_CAPSLOCK);
|
||||
tap_code(KC_CAPS_LOCK);
|
||||
}
|
||||
break;
|
||||
case UC_WIN:
|
||||
unregister_code(KC_LALT);
|
||||
unregister_code(KC_LEFT_ALT);
|
||||
if (!unicode_saved_num_lock) {
|
||||
tap_code(KC_NUMLOCK);
|
||||
tap_code(KC_NUM_LOCK);
|
||||
}
|
||||
break;
|
||||
case UC_WINC:
|
||||
|
@ -150,16 +150,16 @@ __attribute__((weak)) void unicode_input_cancel(void) {
|
|||
case UC_LNX:
|
||||
tap_code(KC_ESCAPE);
|
||||
if (unicode_saved_caps_lock) {
|
||||
tap_code(KC_CAPSLOCK);
|
||||
tap_code(KC_CAPS_LOCK);
|
||||
}
|
||||
break;
|
||||
case UC_WINC:
|
||||
tap_code(KC_ESCAPE);
|
||||
break;
|
||||
case UC_WIN:
|
||||
unregister_code(KC_LALT);
|
||||
unregister_code(KC_LEFT_ALT);
|
||||
if (!unicode_saved_num_lock) {
|
||||
tap_code(KC_NUMLOCK);
|
||||
tap_code(KC_NUM_LOCK);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -24,13 +24,13 @@
|
|||
|
||||
// Keycodes used for starting Unicode input on different platforms
|
||||
#ifndef UNICODE_KEY_MAC
|
||||
# define UNICODE_KEY_MAC KC_LALT
|
||||
# define UNICODE_KEY_MAC KC_LEFT_ALT
|
||||
#endif
|
||||
#ifndef UNICODE_KEY_LNX
|
||||
# define UNICODE_KEY_LNX LCTL(LSFT(KC_U))
|
||||
#endif
|
||||
#ifndef UNICODE_KEY_WINC
|
||||
# define UNICODE_KEY_WINC KC_RALT
|
||||
# define UNICODE_KEY_WINC KC_RIGHT_ALT
|
||||
#endif
|
||||
|
||||
// Comma-delimited, ordered list of input modes selected for use (e.g. in cycle)
|
||||
|
|
|
@ -62,15 +62,15 @@ uint8_t extract_mod_bits(uint16_t code) {
|
|||
uint8_t mods_to_send = 0;
|
||||
|
||||
if (code & QK_RMODS_MIN) { // Right mod flag is set
|
||||
if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_RCTL);
|
||||
if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_RSFT);
|
||||
if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_RALT);
|
||||
if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_RGUI);
|
||||
if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_RIGHT_CTRL);
|
||||
if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_RIGHT_SHIFT);
|
||||
if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_RIGHT_ALT);
|
||||
if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_RIGHT_GUI);
|
||||
} else {
|
||||
if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_LCTL);
|
||||
if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_LSFT);
|
||||
if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_LALT);
|
||||
if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_LGUI);
|
||||
if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_LEFT_CTRL);
|
||||
if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_LEFT_SHIFT);
|
||||
if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_LEFT_ALT);
|
||||
if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_LEFT_GUI);
|
||||
}
|
||||
|
||||
return mods_to_send;
|
||||
|
|
|
@ -19,7 +19,7 @@
|
|||
#include "sequencer.h"
|
||||
|
||||
// Fillers to make layering more clear
|
||||
#define _______ KC_TRNS
|
||||
#define _______ KC_TRANSPARENT
|
||||
#define XXXXXXX KC_NO
|
||||
|
||||
enum quantum_keycodes {
|
||||
|
@ -599,69 +599,67 @@ enum quantum_keycodes {
|
|||
#define MOD_MEH 0x7
|
||||
|
||||
// US ANSI shifted keycode aliases
|
||||
#define KC_TILD LSFT(KC_GRV) // ~
|
||||
#define KC_TILDE KC_TILD
|
||||
#define KC_TILDE LSFT(KC_GRAVE) // ~
|
||||
#define KC_TILD KC_TILDE
|
||||
|
||||
#define KC_EXLM LSFT(KC_1) // !
|
||||
#define KC_EXCLAIM KC_EXLM
|
||||
#define KC_EXCLAIM LSFT(KC_1) // !
|
||||
#define KC_EXLM KC_EXCLAIM
|
||||
|
||||
#define KC_AT LSFT(KC_2) // @
|
||||
|
||||
#define KC_HASH LSFT(KC_3) // #
|
||||
|
||||
#define KC_DLR LSFT(KC_4) // $
|
||||
#define KC_DOLLAR KC_DLR
|
||||
#define KC_DOLLAR LSFT(KC_4) // $
|
||||
#define KC_DLR KC_DOLLAR
|
||||
|
||||
#define KC_PERC LSFT(KC_5) // %
|
||||
#define KC_PERCENT KC_PERC
|
||||
#define KC_PERCENT LSFT(KC_5) // %
|
||||
#define KC_PERC KC_PERCENT
|
||||
|
||||
#define KC_CIRC LSFT(KC_6) // ^
|
||||
#define KC_CIRCUMFLEX KC_CIRC
|
||||
#define KC_CIRCUMFLEX LSFT(KC_6) // ^
|
||||
#define KC_CIRC KC_CIRCUMFLEX
|
||||
|
||||
#define KC_AMPR LSFT(KC_7) // &
|
||||
#define KC_AMPERSAND KC_AMPR
|
||||
#define KC_AMPERSAND LSFT(KC_7) // &
|
||||
#define KC_AMPR KC_AMPERSAND
|
||||
|
||||
#define KC_ASTR LSFT(KC_8) // *
|
||||
#define KC_ASTERISK KC_ASTR
|
||||
#define KC_ASTERISK LSFT(KC_8) // *
|
||||
#define KC_ASTR KC_ASTERISK
|
||||
|
||||
#define KC_LPRN LSFT(KC_9) // (
|
||||
#define KC_LEFT_PAREN KC_LPRN
|
||||
#define KC_LEFT_PAREN LSFT(KC_9) // (
|
||||
#define KC_LPRN KC_LEFT_PAREN
|
||||
|
||||
#define KC_RPRN LSFT(KC_0) // )
|
||||
#define KC_RIGHT_PAREN KC_RPRN
|
||||
#define KC_RIGHT_PAREN LSFT(KC_0) // )
|
||||
#define KC_RPRN KC_RIGHT_PAREN
|
||||
|
||||
#define KC_UNDS LSFT(KC_MINS) // _
|
||||
#define KC_UNDERSCORE KC_UNDS
|
||||
#define KC_UNDERSCORE LSFT(KC_MINUS) // _
|
||||
#define KC_UNDS KC_UNDERSCORE
|
||||
|
||||
#define KC_PLUS LSFT(KC_EQL) // +
|
||||
#define KC_PLUS LSFT(KC_EQUAL) // +
|
||||
|
||||
#define KC_LCBR LSFT(KC_LBRC) // {
|
||||
#define KC_LEFT_CURLY_BRACE KC_LCBR
|
||||
#define KC_LEFT_CURLY_BRACE LSFT(KC_LEFT_BRACKET) // {
|
||||
#define KC_LCBR KC_LEFT_CURLY_BRACE
|
||||
|
||||
#define KC_RCBR LSFT(KC_RBRC) // }
|
||||
#define KC_RIGHT_CURLY_BRACE KC_RCBR
|
||||
#define KC_RIGHT_CURLY_BRACE LSFT(KC_RIGHT_BRACKET) // }
|
||||
#define KC_RCBR KC_RIGHT_CURLY_BRACE
|
||||
|
||||
#define KC_LABK LSFT(KC_COMM) // <
|
||||
#define KC_LEFT_ANGLE_BRACKET KC_LABK
|
||||
#define KC_LEFT_ANGLE_BRACKET LSFT(KC_COMMA) // <
|
||||
#define KC_LABK KC_LEFT_ANGLE_BRACKET
|
||||
#define KC_LT KC_LEFT_ANGLE_BRACKET
|
||||
|
||||
#define KC_RABK LSFT(KC_DOT) // >
|
||||
#define KC_RIGHT_ANGLE_BRACKET KC_RABK
|
||||
#define KC_RIGHT_ANGLE_BRACKET LSFT(KC_DOT) // >
|
||||
#define KC_RABK KC_RIGHT_ANGLE_BRACKET
|
||||
#define KC_GT KC_RIGHT_ANGLE_BRACKET
|
||||
|
||||
#define KC_COLN LSFT(KC_SCLN) // :
|
||||
#define KC_COLON KC_COLN
|
||||
#define KC_COLON LSFT(KC_SEMICOLON) // :
|
||||
#define KC_COLN KC_COLON
|
||||
|
||||
#define KC_PIPE LSFT(KC_BSLS) // |
|
||||
#define KC_PIPE LSFT(KC_BACKSLASH) // |
|
||||
|
||||
#define KC_LT LSFT(KC_COMM) // <
|
||||
#define KC_QUESTION LSFT(KC_SLASH) // ?
|
||||
#define KC_QUES KC_QUESTION
|
||||
|
||||
#define KC_GT LSFT(KC_DOT) // >
|
||||
|
||||
#define KC_QUES LSFT(KC_SLSH) // ?
|
||||
#define KC_QUESTION KC_QUES
|
||||
|
||||
#define KC_DQT LSFT(KC_QUOT) // "
|
||||
#define KC_DOUBLE_QUOTE KC_DQT
|
||||
#define KC_DQUO KC_DQT
|
||||
#define KC_DOUBLE_QUOTE LSFT(KC_QUOTE) // "
|
||||
#define KC_DQUO KC_DOUBLE_QUOTE
|
||||
#define KC_DQT KC_DOUBLE_QUOTE
|
||||
|
||||
#define KC_DELT KC_DELETE // Del key (four letter code)
|
||||
|
||||
|
|
|
@ -5,362 +5,338 @@
|
|||
|
||||
#ifndef VIA_HAS_BROKEN_KEYCODES
|
||||
|
||||
_Static_assert(KC_NO == 0, "");
|
||||
_Static_assert(KC_TRNS == 1, "");
|
||||
// clang-format off
|
||||
|
||||
_Static_assert(KC_A == 0x04, "");
|
||||
_Static_assert(KC_B == 0x05, "");
|
||||
_Static_assert(KC_C == 0x06, "");
|
||||
_Static_assert(KC_D == 0x07, "");
|
||||
_Static_assert(KC_E == 0x08, "");
|
||||
_Static_assert(KC_F == 0x09, "");
|
||||
_Static_assert(KC_G == 0x0A, "");
|
||||
_Static_assert(KC_H == 0x0B, "");
|
||||
_Static_assert(KC_I == 0x0C, "");
|
||||
_Static_assert(KC_J == 0x0D, "");
|
||||
_Static_assert(KC_K == 0x0E, "");
|
||||
_Static_assert(KC_L == 0x0F, "");
|
||||
_Static_assert(KC_M == 0x10, "");
|
||||
_Static_assert(KC_N == 0x11, "");
|
||||
_Static_assert(KC_O == 0x12, "");
|
||||
_Static_assert(KC_P == 0x13, "");
|
||||
_Static_assert(KC_Q == 0x14, "");
|
||||
_Static_assert(KC_R == 0x15, "");
|
||||
_Static_assert(KC_S == 0x16, "");
|
||||
_Static_assert(KC_T == 0x17, "");
|
||||
_Static_assert(KC_U == 0x18, "");
|
||||
_Static_assert(KC_V == 0x19, "");
|
||||
_Static_assert(KC_W == 0x1A, "");
|
||||
_Static_assert(KC_X == 0x1B, "");
|
||||
_Static_assert(KC_Y == 0x1C, "");
|
||||
_Static_assert(KC_Z == 0x1D, "");
|
||||
_Static_assert(KC_1 == 0x1E, "");
|
||||
_Static_assert(KC_2 == 0x1F, "");
|
||||
_Static_assert(KC_3 == 0x20, "");
|
||||
_Static_assert(KC_4 == 0x21, "");
|
||||
_Static_assert(KC_5 == 0x22, "");
|
||||
_Static_assert(KC_6 == 0x23, "");
|
||||
_Static_assert(KC_7 == 0x24, "");
|
||||
_Static_assert(KC_8 == 0x25, "");
|
||||
_Static_assert(KC_9 == 0x26, "");
|
||||
_Static_assert(KC_0 == 0x27, "");
|
||||
_Static_assert(KC_ENTER == 0x28, "");
|
||||
_Static_assert(KC_ESCAPE == 0x29, "");
|
||||
_Static_assert(KC_BSPACE == 0x2A, "");
|
||||
_Static_assert(KC_TAB == 0x2B, "");
|
||||
_Static_assert(KC_SPACE == 0x2C, "");
|
||||
_Static_assert(KC_MINUS == 0x2D, "");
|
||||
_Static_assert(KC_EQUAL == 0x2E, "");
|
||||
_Static_assert(KC_LBRACKET == 0x2F, "");
|
||||
_Static_assert(KC_RBRACKET == 0x30, "");
|
||||
_Static_assert(KC_BSLASH == 0x31, "");
|
||||
_Static_assert(KC_SCOLON == 0x33, "");
|
||||
_Static_assert(KC_QUOTE == 0x34, "");
|
||||
_Static_assert(KC_GRAVE == 0x35, "");
|
||||
_Static_assert(KC_COMMA == 0x36, "");
|
||||
_Static_assert(KC_DOT == 0x37, "");
|
||||
_Static_assert(KC_SLASH == 0x38, "");
|
||||
_Static_assert(KC_CAPSLOCK == 0x39, "");
|
||||
_Static_assert(KC_F1 == 0x3A, "");
|
||||
_Static_assert(KC_F2 == 0x3B, "");
|
||||
_Static_assert(KC_F3 == 0x3C, "");
|
||||
_Static_assert(KC_F4 == 0x3D, "");
|
||||
_Static_assert(KC_F5 == 0x3E, "");
|
||||
_Static_assert(KC_F6 == 0x3F, "");
|
||||
_Static_assert(KC_F7 == 0x40, "");
|
||||
_Static_assert(KC_F8 == 0x41, "");
|
||||
_Static_assert(KC_F9 == 0x42, "");
|
||||
_Static_assert(KC_F10 == 0x43, "");
|
||||
_Static_assert(KC_F11 == 0x44, "");
|
||||
_Static_assert(KC_F12 == 0x45, "");
|
||||
_Static_assert(KC_PSCREEN == 0x46, "");
|
||||
_Static_assert(KC_SCROLLLOCK == 0x47, "");
|
||||
_Static_assert(KC_PAUSE == 0x48, "");
|
||||
_Static_assert(KC_INSERT == 0x49, "");
|
||||
_Static_assert(KC_HOME == 0x4A, "");
|
||||
_Static_assert(KC_PGUP == 0x4B, "");
|
||||
_Static_assert(KC_DELETE == 0x4C, "");
|
||||
_Static_assert(KC_END == 0x4D, "");
|
||||
_Static_assert(KC_PGDOWN == 0x4E, "");
|
||||
_Static_assert(KC_RIGHT == 0x4F, "");
|
||||
_Static_assert(KC_LEFT == 0x50, "");
|
||||
_Static_assert(KC_DOWN == 0x51, "");
|
||||
_Static_assert(KC_UP == 0x52, "");
|
||||
_Static_assert(KC_NUMLOCK == 0x53, "");
|
||||
_Static_assert(KC_KP_SLASH == 0x54, "");
|
||||
_Static_assert(KC_KP_ASTERISK == 0x55, "");
|
||||
_Static_assert(KC_KP_MINUS == 0x56, "");
|
||||
_Static_assert(KC_KP_PLUS == 0x57, "");
|
||||
_Static_assert(KC_KP_ENTER == 0x58, "");
|
||||
_Static_assert(KC_KP_1 == 0x59, "");
|
||||
_Static_assert(KC_KP_2 == 0x5A, "");
|
||||
_Static_assert(KC_KP_3 == 0x5B, "");
|
||||
_Static_assert(KC_KP_4 == 0x5C, "");
|
||||
_Static_assert(KC_KP_5 == 0x5D, "");
|
||||
_Static_assert(KC_KP_6 == 0x5E, "");
|
||||
_Static_assert(KC_KP_7 == 0x5F, "");
|
||||
_Static_assert(KC_KP_8 == 0x60, "");
|
||||
_Static_assert(KC_KP_9 == 0x61, "");
|
||||
_Static_assert(KC_KP_0 == 0x62, "");
|
||||
_Static_assert(KC_KP_DOT == 0x63, "");
|
||||
_Static_assert(KC_APPLICATION == 0x65, "");
|
||||
_Static_assert(KC_KP_EQUAL == 0x67, "");
|
||||
_Static_assert(KC_KP_COMMA == 0x85, "");
|
||||
_Static_assert(KC_LCTRL == 0xE0, "");
|
||||
_Static_assert(KC_LSHIFT == 0xE1, "");
|
||||
_Static_assert(KC_LALT == 0xE2, "");
|
||||
_Static_assert(KC_LGUI == 0xE3, "");
|
||||
_Static_assert(KC_RCTRL == 0xE4, "");
|
||||
_Static_assert(KC_RSHIFT == 0xE5, "");
|
||||
_Static_assert(KC_RALT == 0xE6, "");
|
||||
_Static_assert(KC_RGUI == 0xE7, "");
|
||||
_Static_assert(KC_NO == 0x0000, "");
|
||||
_Static_assert(KC_TRANSPARENT == 0x0001, "");
|
||||
|
||||
_Static_assert(KC_TILD == 0x235, "");
|
||||
_Static_assert(KC_EXLM == 0x21E, "");
|
||||
_Static_assert(KC_AT == 0x21F, "");
|
||||
_Static_assert(KC_HASH == 0x220, "");
|
||||
_Static_assert(KC_DLR == 0x221, "");
|
||||
_Static_assert(KC_PERC == 0x222, "");
|
||||
_Static_assert(KC_CIRC == 0x223, "");
|
||||
_Static_assert(KC_AMPR == 0x224, "");
|
||||
_Static_assert(KC_ASTR == 0x225, "");
|
||||
_Static_assert(KC_LPRN == 0x226, "");
|
||||
_Static_assert(KC_RPRN == 0x227, "");
|
||||
_Static_assert(KC_UNDS == 0x22D, "");
|
||||
_Static_assert(KC_PLUS == 0x22E, "");
|
||||
_Static_assert(KC_LCBR == 0x22F, "");
|
||||
_Static_assert(KC_RCBR == 0x230, "");
|
||||
_Static_assert(KC_LT == 0x236, "");
|
||||
_Static_assert(KC_GT == 0x237, "");
|
||||
_Static_assert(KC_COLN == 0x233, "");
|
||||
_Static_assert(KC_PIPE == 0x231, "");
|
||||
_Static_assert(KC_QUES == 0x238, "");
|
||||
_Static_assert(KC_DQUO == 0x234, "");
|
||||
_Static_assert(KC_A == 0x0004, "");
|
||||
_Static_assert(KC_B == 0x0005, "");
|
||||
_Static_assert(KC_C == 0x0006, "");
|
||||
_Static_assert(KC_D == 0x0007, "");
|
||||
_Static_assert(KC_E == 0x0008, "");
|
||||
_Static_assert(KC_F == 0x0009, "");
|
||||
_Static_assert(KC_G == 0x000A, "");
|
||||
_Static_assert(KC_H == 0x000B, "");
|
||||
_Static_assert(KC_I == 0x000C, "");
|
||||
_Static_assert(KC_J == 0x000D, "");
|
||||
_Static_assert(KC_K == 0x000E, "");
|
||||
_Static_assert(KC_L == 0x000F, "");
|
||||
_Static_assert(KC_M == 0x0010, "");
|
||||
_Static_assert(KC_N == 0x0011, "");
|
||||
_Static_assert(KC_O == 0x0012, "");
|
||||
_Static_assert(KC_P == 0x0013, "");
|
||||
_Static_assert(KC_Q == 0x0014, "");
|
||||
_Static_assert(KC_R == 0x0015, "");
|
||||
_Static_assert(KC_S == 0x0016, "");
|
||||
_Static_assert(KC_T == 0x0017, "");
|
||||
_Static_assert(KC_U == 0x0018, "");
|
||||
_Static_assert(KC_V == 0x0019, "");
|
||||
_Static_assert(KC_W == 0x001A, "");
|
||||
_Static_assert(KC_X == 0x001B, "");
|
||||
_Static_assert(KC_Y == 0x001C, "");
|
||||
_Static_assert(KC_Z == 0x001D, "");
|
||||
_Static_assert(KC_1 == 0x001E, "");
|
||||
_Static_assert(KC_2 == 0x001F, "");
|
||||
_Static_assert(KC_3 == 0x0020, "");
|
||||
_Static_assert(KC_4 == 0x0021, "");
|
||||
_Static_assert(KC_5 == 0x0022, "");
|
||||
_Static_assert(KC_6 == 0x0023, "");
|
||||
_Static_assert(KC_7 == 0x0024, "");
|
||||
_Static_assert(KC_8 == 0x0025, "");
|
||||
_Static_assert(KC_9 == 0x0026, "");
|
||||
_Static_assert(KC_0 == 0x0027, "");
|
||||
_Static_assert(KC_ENTER == 0x0028, "");
|
||||
_Static_assert(KC_ESCAPE == 0x0029, "");
|
||||
_Static_assert(KC_BACKSPACE == 0x002A, "");
|
||||
_Static_assert(KC_TAB == 0x002B, "");
|
||||
_Static_assert(KC_SPACE == 0x002C, "");
|
||||
_Static_assert(KC_MINUS == 0x002D, "");
|
||||
_Static_assert(KC_EQUAL == 0x002E, "");
|
||||
_Static_assert(KC_LEFT_BRACKET == 0x002F, "");
|
||||
_Static_assert(KC_RIGHT_BRACKET == 0x0030, "");
|
||||
_Static_assert(KC_BACKSLASH == 0x0031, "");
|
||||
_Static_assert(KC_NONUS_HASH == 0x0032, "");
|
||||
_Static_assert(KC_SEMICOLON == 0x0033, "");
|
||||
_Static_assert(KC_QUOTE == 0x0034, "");
|
||||
_Static_assert(KC_GRAVE == 0x0035, "");
|
||||
_Static_assert(KC_COMMA == 0x0036, "");
|
||||
_Static_assert(KC_DOT == 0x0037, "");
|
||||
_Static_assert(KC_SLASH == 0x0038, "");
|
||||
_Static_assert(KC_CAPS_LOCK == 0x0039, "");
|
||||
_Static_assert(KC_F1 == 0x003A, "");
|
||||
_Static_assert(KC_F2 == 0x003B, "");
|
||||
_Static_assert(KC_F3 == 0x003C, "");
|
||||
_Static_assert(KC_F4 == 0x003D, "");
|
||||
_Static_assert(KC_F5 == 0x003E, "");
|
||||
_Static_assert(KC_F6 == 0x003F, "");
|
||||
_Static_assert(KC_F7 == 0x0040, "");
|
||||
_Static_assert(KC_F8 == 0x0041, "");
|
||||
_Static_assert(KC_F9 == 0x0042, "");
|
||||
_Static_assert(KC_F10 == 0x0043, "");
|
||||
_Static_assert(KC_F11 == 0x0044, "");
|
||||
_Static_assert(KC_F12 == 0x0045, "");
|
||||
_Static_assert(KC_PRINT_SCREEN == 0x0046, "");
|
||||
_Static_assert(KC_SCROLL_LOCK == 0x0047, "");
|
||||
_Static_assert(KC_PAUSE == 0x0048, "");
|
||||
_Static_assert(KC_INSERT == 0x0049, "");
|
||||
_Static_assert(KC_HOME == 0x004A, "");
|
||||
_Static_assert(KC_PAGE_UP == 0x004B, "");
|
||||
_Static_assert(KC_DELETE == 0x004C, "");
|
||||
_Static_assert(KC_END == 0x004D, "");
|
||||
_Static_assert(KC_PAGE_DOWN == 0x004E, "");
|
||||
_Static_assert(KC_RIGHT == 0x004F, "");
|
||||
_Static_assert(KC_LEFT == 0x0050, "");
|
||||
_Static_assert(KC_DOWN == 0x0051, "");
|
||||
_Static_assert(KC_UP == 0x0052, "");
|
||||
_Static_assert(KC_NUM_LOCK == 0x0053, "");
|
||||
_Static_assert(KC_KP_SLASH == 0x0054, "");
|
||||
_Static_assert(KC_KP_ASTERISK == 0x0055, "");
|
||||
_Static_assert(KC_KP_MINUS == 0x0056, "");
|
||||
_Static_assert(KC_KP_PLUS == 0x0057, "");
|
||||
_Static_assert(KC_KP_ENTER == 0x0058, "");
|
||||
_Static_assert(KC_KP_1 == 0x0059, "");
|
||||
_Static_assert(KC_KP_2 == 0x005A, "");
|
||||
_Static_assert(KC_KP_3 == 0x005B, "");
|
||||
_Static_assert(KC_KP_4 == 0x005C, "");
|
||||
_Static_assert(KC_KP_5 == 0x005D, "");
|
||||
_Static_assert(KC_KP_6 == 0x005E, "");
|
||||
_Static_assert(KC_KP_7 == 0x005F, "");
|
||||
_Static_assert(KC_KP_8 == 0x0060, "");
|
||||
_Static_assert(KC_KP_9 == 0x0061, "");
|
||||
_Static_assert(KC_KP_0 == 0x0062, "");
|
||||
_Static_assert(KC_KP_DOT == 0x0063, "");
|
||||
_Static_assert(KC_NONUS_BACKSLASH == 0x0064, "");
|
||||
_Static_assert(KC_APPLICATION == 0x0065, "");
|
||||
_Static_assert(KC_KB_POWER == 0x0066, "");
|
||||
_Static_assert(KC_KP_EQUAL == 0x0067, "");
|
||||
_Static_assert(KC_F13 == 0x0068, "");
|
||||
_Static_assert(KC_F14 == 0x0069, "");
|
||||
_Static_assert(KC_F15 == 0x006A, "");
|
||||
_Static_assert(KC_F16 == 0x006B, "");
|
||||
_Static_assert(KC_F17 == 0x006C, "");
|
||||
_Static_assert(KC_F18 == 0x006D, "");
|
||||
_Static_assert(KC_F19 == 0x006E, "");
|
||||
_Static_assert(KC_F20 == 0x006F, "");
|
||||
_Static_assert(KC_F21 == 0x0070, "");
|
||||
_Static_assert(KC_F22 == 0x0071, "");
|
||||
_Static_assert(KC_F23 == 0x0072, "");
|
||||
_Static_assert(KC_F24 == 0x0073, "");
|
||||
_Static_assert(KC_EXECUTE == 0x0074, "");
|
||||
_Static_assert(KC_HELP == 0x0075, "");
|
||||
_Static_assert(KC_MENU == 0x0076, "");
|
||||
_Static_assert(KC_SELECT == 0x0077, "");
|
||||
_Static_assert(KC_STOP == 0x0078, "");
|
||||
_Static_assert(KC_AGAIN == 0x0079, "");
|
||||
_Static_assert(KC_UNDO == 0x007A, "");
|
||||
_Static_assert(KC_CUT == 0x007B, "");
|
||||
_Static_assert(KC_COPY == 0x007C, "");
|
||||
_Static_assert(KC_PASTE == 0x007D, "");
|
||||
_Static_assert(KC_FIND == 0x007E, "");
|
||||
|
||||
_Static_assert(KC_NONUS_HASH == 0x32, "");
|
||||
_Static_assert(KC_NONUS_BSLASH == 0x64, "");
|
||||
_Static_assert(KC_RO == 0x87, "");
|
||||
_Static_assert(KC_KANA == 0x88, "");
|
||||
_Static_assert(KC_JYEN == 0x89, "");
|
||||
_Static_assert(KC_HENK == 0x8A, "");
|
||||
_Static_assert(KC_MHEN == 0x8B, "");
|
||||
_Static_assert(KC_LANG1 == 0x90, "");
|
||||
_Static_assert(KC_LANG2 == 0x91, "");
|
||||
_Static_assert(KC_LOCKING_CAPS_LOCK == 0x0082, "");
|
||||
_Static_assert(KC_LOCKING_NUM_LOCK == 0x0083, "");
|
||||
_Static_assert(KC_LOCKING_SCROLL_LOCK == 0x0084, "");
|
||||
_Static_assert(KC_KP_COMMA == 0x0085, "");
|
||||
_Static_assert(KC_KP_EQUAL_AS400 == 0x0086, "");
|
||||
_Static_assert(KC_INTERNATIONAL_1 == 0x0087, "");
|
||||
_Static_assert(KC_INTERNATIONAL_2 == 0x0088, "");
|
||||
_Static_assert(KC_INTERNATIONAL_3 == 0x0089, "");
|
||||
_Static_assert(KC_INTERNATIONAL_4 == 0x008A, "");
|
||||
_Static_assert(KC_INTERNATIONAL_5 == 0x008B, "");
|
||||
_Static_assert(KC_INTERNATIONAL_6 == 0x008C, "");
|
||||
_Static_assert(KC_INTERNATIONAL_7 == 0x008D, "");
|
||||
_Static_assert(KC_INTERNATIONAL_8 == 0x008E, "");
|
||||
_Static_assert(KC_INTERNATIONAL_9 == 0x008F, "");
|
||||
_Static_assert(KC_LANGUAGE_1 == 0x0090, "");
|
||||
_Static_assert(KC_LANGUAGE_2 == 0x0091, "");
|
||||
_Static_assert(KC_LANGUAGE_3 == 0x0092, "");
|
||||
_Static_assert(KC_LANGUAGE_4 == 0x0093, "");
|
||||
_Static_assert(KC_LANGUAGE_5 == 0x0094, "");
|
||||
_Static_assert(KC_LANGUAGE_6 == 0x0095, "");
|
||||
_Static_assert(KC_LANGUAGE_7 == 0x0096, "");
|
||||
_Static_assert(KC_LANGUAGE_8 == 0x0097, "");
|
||||
_Static_assert(KC_LANGUAGE_9 == 0x0098, "");
|
||||
_Static_assert(KC_ALTERNATE_ERASE == 0x0099, "");
|
||||
_Static_assert(KC_SYSTEM_REQUEST == 0x009A, "");
|
||||
_Static_assert(KC_CANCEL == 0x009B, "");
|
||||
_Static_assert(KC_CLEAR == 0x009C, "");
|
||||
_Static_assert(KC_PRIOR == 0x009D, "");
|
||||
|
||||
_Static_assert(KC_GESC == 0x5C16, "");
|
||||
_Static_assert(KC_LSPO == 0x5CD7, "");
|
||||
_Static_assert(KC_RSPC == 0x5CD8, "");
|
||||
_Static_assert(KC_LCPO == 0x5CF3, "");
|
||||
_Static_assert(KC_RCPC == 0x5CF4, "");
|
||||
_Static_assert(KC_LAPO == 0x5CF5, "");
|
||||
_Static_assert(KC_RAPC == 0x5CF6, "");
|
||||
_Static_assert(KC_SFTENT == 0x5CD9, "");
|
||||
_Static_assert(KC_OUT == 0x00A0, "");
|
||||
_Static_assert(KC_OPER == 0x00A1, "");
|
||||
_Static_assert(KC_CLEAR_AGAIN == 0x00A2, "");
|
||||
_Static_assert(KC_CRSEL == 0x00A3, "");
|
||||
_Static_assert(KC_EXSEL == 0x00A4, "");
|
||||
|
||||
_Static_assert(BL_TOGG == 23743, "");
|
||||
_Static_assert(BL_STEP == 23744, "");
|
||||
_Static_assert(BL_BRTG == 23745, "");
|
||||
_Static_assert(BL_ON == 23739, "");
|
||||
_Static_assert(BL_OFF == 23740, "");
|
||||
_Static_assert(BL_INC == 23742, "");
|
||||
_Static_assert(BL_DEC == 23741, "");
|
||||
_Static_assert(RGB_TOG == 23746, "");
|
||||
_Static_assert(RGB_MOD == 23747, "");
|
||||
_Static_assert(RGB_RMOD == 23748, "");
|
||||
_Static_assert(RGB_HUI == 23749, "");
|
||||
_Static_assert(RGB_HUD == 23750, "");
|
||||
_Static_assert(RGB_SAI == 23751, "");
|
||||
_Static_assert(RGB_SAD == 23752, "");
|
||||
_Static_assert(RGB_VAI == 23753, "");
|
||||
_Static_assert(RGB_VAD == 23754, "");
|
||||
_Static_assert(RGB_SPI == 23755, "");
|
||||
_Static_assert(RGB_SPD == 23756, "");
|
||||
_Static_assert(RGB_M_P == 23757, "");
|
||||
_Static_assert(RGB_M_B == 23758, "");
|
||||
_Static_assert(RGB_M_R == 23759, "");
|
||||
_Static_assert(RGB_M_SW == 23760, "");
|
||||
_Static_assert(RGB_M_SN == 23761, "");
|
||||
_Static_assert(RGB_M_K == 23762, "");
|
||||
_Static_assert(RGB_M_X == 23763, "");
|
||||
_Static_assert(RGB_M_G == 23764, "");
|
||||
_Static_assert(RGB_M_T == 23765, "");
|
||||
_Static_assert(KC_PWR == 0x00A5, "");
|
||||
_Static_assert(KC_SLEP == 0x00A6, "");
|
||||
_Static_assert(KC_WAKE == 0x00A7, "");
|
||||
_Static_assert(KC_MUTE == 0x00A8, "");
|
||||
_Static_assert(KC_VOLU == 0x00A9, "");
|
||||
_Static_assert(KC_VOLD == 0x00AA, "");
|
||||
_Static_assert(KC_MNXT == 0x00AB, "");
|
||||
_Static_assert(KC_MPRV == 0x00AC, "");
|
||||
_Static_assert(KC_MSTP == 0x00AD, "");
|
||||
_Static_assert(KC_MPLY == 0x00AE, "");
|
||||
_Static_assert(KC_MSEL == 0x00AF, "");
|
||||
_Static_assert(KC_EJCT == 0x00B0, "");
|
||||
_Static_assert(KC_MAIL == 0x00B1, "");
|
||||
_Static_assert(KC_CALC == 0x00B2, "");
|
||||
_Static_assert(KC_MYCM == 0x00B3, "");
|
||||
_Static_assert(KC_WSCH == 0x00B4, "");
|
||||
_Static_assert(KC_WHOM == 0x00B5, "");
|
||||
_Static_assert(KC_WBAK == 0x00B6, "");
|
||||
_Static_assert(KC_WFWD == 0x00B7, "");
|
||||
_Static_assert(KC_WSTP == 0x00B8, "");
|
||||
_Static_assert(KC_WREF == 0x00B9, "");
|
||||
_Static_assert(KC_WFAV == 0x00BA, "");
|
||||
_Static_assert(KC_MFFD == 0x00BB, "");
|
||||
_Static_assert(KC_MRWD == 0x00BC, "");
|
||||
_Static_assert(KC_BRIU == 0x00BD, "");
|
||||
_Static_assert(KC_BRID == 0x00BE, "");
|
||||
|
||||
_Static_assert(KC_F13 == 104, "");
|
||||
_Static_assert(KC_F14 == 105, "");
|
||||
_Static_assert(KC_F15 == 106, "");
|
||||
_Static_assert(KC_F16 == 107, "");
|
||||
_Static_assert(KC_F17 == 108, "");
|
||||
_Static_assert(KC_F18 == 109, "");
|
||||
_Static_assert(KC_F19 == 110, "");
|
||||
_Static_assert(KC_F20 == 111, "");
|
||||
_Static_assert(KC_F21 == 112, "");
|
||||
_Static_assert(KC_F22 == 113, "");
|
||||
_Static_assert(KC_F23 == 114, "");
|
||||
_Static_assert(KC_F24 == 115, "");
|
||||
_Static_assert(KC_PWR == 165, "");
|
||||
_Static_assert(KC_SLEP == 166, "");
|
||||
_Static_assert(KC_WAKE == 167, "");
|
||||
_Static_assert(KC_EXEC == 116, "");
|
||||
_Static_assert(KC_HELP == 117, "");
|
||||
_Static_assert(KC_SLCT == 119, "");
|
||||
_Static_assert(KC_STOP == 120, "");
|
||||
_Static_assert(KC_AGIN == 121, "");
|
||||
_Static_assert(KC_UNDO == 122, "");
|
||||
_Static_assert(KC_CUT == 123, "");
|
||||
_Static_assert(KC_COPY == 124, "");
|
||||
_Static_assert(KC_PSTE == 125, "");
|
||||
_Static_assert(KC_FIND == 126, "");
|
||||
_Static_assert(KC_CALC == 178, "");
|
||||
_Static_assert(KC_MAIL == 177, "");
|
||||
_Static_assert(KC_MSEL == 175, "");
|
||||
_Static_assert(KC_MYCM == 179, "");
|
||||
_Static_assert(KC_WSCH == 180, "");
|
||||
_Static_assert(KC_WHOM == 181, "");
|
||||
_Static_assert(KC_WBAK == 182, "");
|
||||
_Static_assert(KC_WFWD == 183, "");
|
||||
_Static_assert(KC_WSTP == 184, "");
|
||||
_Static_assert(KC_WREF == 185, "");
|
||||
_Static_assert(KC_WFAV == 186, "");
|
||||
_Static_assert(KC_BRIU == 189, "");
|
||||
_Static_assert(KC_BRID == 190, "");
|
||||
_Static_assert(KC_MPRV == 172, "");
|
||||
_Static_assert(KC_MNXT == 171, "");
|
||||
_Static_assert(KC_MUTE == 168, "");
|
||||
_Static_assert(KC_VOLD == 170, "");
|
||||
_Static_assert(KC_VOLU == 169, "");
|
||||
_Static_assert(KC_MSTP == 173, "");
|
||||
_Static_assert(KC_MPLY == 174, "");
|
||||
_Static_assert(KC_MRWD == 188, "");
|
||||
_Static_assert(KC_MFFD == 187, "");
|
||||
_Static_assert(KC_EJCT == 176, "");
|
||||
_Static_assert(KC_MS_U == 240, "");
|
||||
_Static_assert(KC_MS_D == 241, "");
|
||||
_Static_assert(KC_MS_L == 242, "");
|
||||
_Static_assert(KC_MS_R == 243, "");
|
||||
_Static_assert(KC_BTN1 == 244, "");
|
||||
_Static_assert(KC_BTN2 == 245, "");
|
||||
_Static_assert(KC_BTN3 == 246, "");
|
||||
_Static_assert(KC_BTN4 == 247, "");
|
||||
_Static_assert(KC_BTN5 == 248, "");
|
||||
_Static_assert(KC_WH_U == 249, "");
|
||||
_Static_assert(KC_WH_D == 250, "");
|
||||
_Static_assert(KC_WH_L == 251, "");
|
||||
_Static_assert(KC_WH_R == 252, "");
|
||||
_Static_assert(KC_ACL0 == 253, "");
|
||||
_Static_assert(KC_ACL1 == 254, "");
|
||||
_Static_assert(KC_ACL2 == 255, "");
|
||||
_Static_assert(KC_LCAP == 130, "");
|
||||
_Static_assert(KC_LNUM == 131, "");
|
||||
_Static_assert(KC_LSCR == 132, "");
|
||||
_Static_assert(KC_LEFT_CTRL == 0x00E0, "");
|
||||
_Static_assert(KC_LEFT_SHIFT == 0x00E1, "");
|
||||
_Static_assert(KC_LEFT_ALT == 0x00E2, "");
|
||||
_Static_assert(KC_LEFT_GUI == 0x00E3, "");
|
||||
_Static_assert(KC_RIGHT_CTRL == 0x00E4, "");
|
||||
_Static_assert(KC_RIGHT_SHIFT == 0x00E5, "");
|
||||
_Static_assert(KC_RIGHT_ALT == 0x00E6, "");
|
||||
_Static_assert(KC_RIGHT_GUI == 0x00E7, "");
|
||||
|
||||
_Static_assert(FN_MO13 == 0x5F10, "");
|
||||
_Static_assert(FN_MO23 == 0x5F11, "");
|
||||
_Static_assert(KC_MS_U == 0x00F0, "");
|
||||
_Static_assert(KC_MS_D == 0x00F1, "");
|
||||
_Static_assert(KC_MS_L == 0x00F2, "");
|
||||
_Static_assert(KC_MS_R == 0x00F3, "");
|
||||
_Static_assert(KC_BTN1 == 0x00F4, "");
|
||||
_Static_assert(KC_BTN2 == 0x00F5, "");
|
||||
_Static_assert(KC_BTN3 == 0x00F6, "");
|
||||
_Static_assert(KC_BTN4 == 0x00F7, "");
|
||||
_Static_assert(KC_BTN5 == 0x00F8, "");
|
||||
_Static_assert(KC_WH_U == 0x00F9, "");
|
||||
_Static_assert(KC_WH_D == 0x00FA, "");
|
||||
_Static_assert(KC_WH_L == 0x00FB, "");
|
||||
_Static_assert(KC_WH_R == 0x00FC, "");
|
||||
_Static_assert(KC_ACL0 == 0x00FD, "");
|
||||
_Static_assert(KC_ACL1 == 0x00FE, "");
|
||||
_Static_assert(KC_ACL2 == 0x00FF, "");
|
||||
|
||||
_Static_assert(MACRO00 == 0x5F12, "");
|
||||
_Static_assert(MACRO01 == 0x5F13, "");
|
||||
_Static_assert(MACRO02 == 0x5F14, "");
|
||||
_Static_assert(MACRO03 == 0x5F15, "");
|
||||
_Static_assert(MACRO04 == 0x5F16, "");
|
||||
_Static_assert(MACRO05 == 0x5F17, "");
|
||||
_Static_assert(MACRO06 == 0x5F18, "");
|
||||
_Static_assert(MACRO07 == 0x5F19, "");
|
||||
_Static_assert(MACRO08 == 0x5F1A, "");
|
||||
_Static_assert(MACRO09 == 0x5F1B, "");
|
||||
_Static_assert(MACRO10 == 0x5F1C, "");
|
||||
_Static_assert(MACRO11 == 0x5F1D, "");
|
||||
_Static_assert(MACRO12 == 0x5F1E, "");
|
||||
_Static_assert(MACRO13 == 0x5F1F, "");
|
||||
_Static_assert(MACRO14 == 0x5F20, "");
|
||||
_Static_assert(MACRO15 == 0x5F21, "");
|
||||
_Static_assert(KC_EXLM == 0x021E, "");
|
||||
_Static_assert(KC_AT == 0x021F, "");
|
||||
_Static_assert(KC_HASH == 0x0220, "");
|
||||
_Static_assert(KC_DLR == 0x0221, "");
|
||||
_Static_assert(KC_PERC == 0x0222, "");
|
||||
_Static_assert(KC_CIRC == 0x0223, "");
|
||||
_Static_assert(KC_AMPR == 0x0224, "");
|
||||
_Static_assert(KC_ASTR == 0x0225, "");
|
||||
_Static_assert(KC_LPRN == 0x0226, "");
|
||||
_Static_assert(KC_RPRN == 0x0227, "");
|
||||
_Static_assert(KC_UNDS == 0x022D, "");
|
||||
_Static_assert(KC_PLUS == 0x022E, "");
|
||||
_Static_assert(KC_LCBR == 0x022F, "");
|
||||
_Static_assert(KC_RCBR == 0x0230, "");
|
||||
_Static_assert(KC_PIPE == 0x0231, "");
|
||||
_Static_assert(KC_COLN == 0x0233, "");
|
||||
_Static_assert(KC_DQUO == 0x0234, "");
|
||||
_Static_assert(KC_TILD == 0x0235, "");
|
||||
_Static_assert(KC_LT == 0x0236, "");
|
||||
_Static_assert(KC_GT == 0x0237, "");
|
||||
_Static_assert(KC_QUES == 0x0238, "");
|
||||
|
||||
_Static_assert(USER00 == 0x5F80, "");
|
||||
_Static_assert(USER01 == 0x5F81, "");
|
||||
_Static_assert(USER02 == 0x5F82, "");
|
||||
_Static_assert(USER03 == 0x5F83, "");
|
||||
_Static_assert(USER04 == 0x5F84, "");
|
||||
_Static_assert(USER05 == 0x5F85, "");
|
||||
_Static_assert(USER06 == 0x5F86, "");
|
||||
_Static_assert(USER07 == 0x5F87, "");
|
||||
_Static_assert(USER08 == 0x5F88, "");
|
||||
_Static_assert(USER09 == 0x5F89, "");
|
||||
_Static_assert(USER10 == 0x5F8A, "");
|
||||
_Static_assert(USER11 == 0x5F8B, "");
|
||||
_Static_assert(USER12 == 0x5F8C, "");
|
||||
_Static_assert(USER13 == 0x5F8D, "");
|
||||
_Static_assert(USER14 == 0x5F8E, "");
|
||||
_Static_assert(USER15 == 0x5F8F, "");
|
||||
_Static_assert(RESET == 0x5C00, "");
|
||||
_Static_assert(DEBUG == 0x5C01, "");
|
||||
|
||||
_Static_assert(KC_POWER == 102, "");
|
||||
_Static_assert(KC_MENU == 118, "");
|
||||
_Static_assert(KC_KP_EQUAL_AS400 == 134, "");
|
||||
_Static_assert(KC_INT6 == 140, "");
|
||||
_Static_assert(KC_INT7 == 141, "");
|
||||
_Static_assert(KC_INT8 == 142, "");
|
||||
_Static_assert(KC_INT9 == 143, "");
|
||||
_Static_assert(KC_LANG3 == 146, "");
|
||||
_Static_assert(KC_LANG4 == 147, "");
|
||||
_Static_assert(KC_LANG5 == 148, "");
|
||||
_Static_assert(KC_LANG6 == 149, "");
|
||||
_Static_assert(KC_LANG7 == 150, "");
|
||||
_Static_assert(KC_LANG8 == 151, "");
|
||||
_Static_assert(KC_LANG9 == 152, "");
|
||||
_Static_assert(KC_ERAS == 153, "");
|
||||
_Static_assert(KC_SYSREQ == 154, "");
|
||||
_Static_assert(KC_CANCEL == 155, "");
|
||||
_Static_assert(KC_CLEAR == 156, "");
|
||||
_Static_assert(KC_CLR == 156, "");
|
||||
_Static_assert(KC_PRIOR == 157, "");
|
||||
_Static_assert(KC_OUT == 160, "");
|
||||
_Static_assert(KC_OPER == 161, "");
|
||||
_Static_assert(KC_CLEAR_AGAIN == 162, "");
|
||||
_Static_assert(KC_CRSEL == 163, "");
|
||||
_Static_assert(KC_EXSEL == 164, "");
|
||||
_Static_assert(KC_FN0 == 192, "");
|
||||
_Static_assert(KC_FN1 == 193, "");
|
||||
_Static_assert(KC_FN2 == 194, "");
|
||||
_Static_assert(KC_FN3 == 195, "");
|
||||
_Static_assert(KC_FN4 == 196, "");
|
||||
_Static_assert(KC_FN5 == 197, "");
|
||||
_Static_assert(KC_FN6 == 198, "");
|
||||
_Static_assert(KC_FN7 == 199, "");
|
||||
_Static_assert(KC_FN8 == 200, "");
|
||||
_Static_assert(KC_FN9 == 201, "");
|
||||
_Static_assert(KC_FN10 == 202, "");
|
||||
_Static_assert(KC_FN11 == 203, "");
|
||||
_Static_assert(KC_FN12 == 204, "");
|
||||
_Static_assert(KC_FN13 == 205, "");
|
||||
_Static_assert(KC_FN14 == 206, "");
|
||||
_Static_assert(KC_FN15 == 207, "");
|
||||
_Static_assert(KC_FN16 == 208, "");
|
||||
_Static_assert(KC_FN17 == 209, "");
|
||||
_Static_assert(KC_FN18 == 210, "");
|
||||
_Static_assert(KC_FN19 == 211, "");
|
||||
_Static_assert(KC_FN20 == 212, "");
|
||||
_Static_assert(KC_FN21 == 213, "");
|
||||
_Static_assert(KC_FN22 == 214, "");
|
||||
_Static_assert(KC_FN23 == 215, "");
|
||||
_Static_assert(KC_FN24 == 216, "");
|
||||
_Static_assert(KC_FN25 == 217, "");
|
||||
_Static_assert(KC_FN26 == 218, "");
|
||||
_Static_assert(KC_FN27 == 219, "");
|
||||
_Static_assert(KC_FN28 == 220, "");
|
||||
_Static_assert(KC_FN29 == 221, "");
|
||||
_Static_assert(KC_FN30 == 222, "");
|
||||
_Static_assert(KC_FN31 == 223, "");
|
||||
_Static_assert(RESET == 23552, "");
|
||||
_Static_assert(DEBUG == 23553, "");
|
||||
_Static_assert(MAGIC_TOGGLE_NKRO == 23572, "");
|
||||
_Static_assert(AU_ON == 23581, "");
|
||||
_Static_assert(AU_OFF == 23582, "");
|
||||
_Static_assert(AU_TOG == 23583, "");
|
||||
_Static_assert(CLICKY_TOGGLE == 23584, "");
|
||||
_Static_assert(CLICKY_ENABLE == 23585, "");
|
||||
_Static_assert(CLICKY_DISABLE == 23586, "");
|
||||
_Static_assert(CLICKY_UP == 23587, "");
|
||||
_Static_assert(CLICKY_DOWN == 23588, "");
|
||||
_Static_assert(CLICKY_RESET == 23589, "");
|
||||
_Static_assert(MU_ON == 23590, "");
|
||||
_Static_assert(MU_OFF == 23591, "");
|
||||
_Static_assert(MU_TOG == 23592, "");
|
||||
_Static_assert(MU_MOD == 23593, "");
|
||||
_Static_assert(MAGIC_TOGGLE_NKRO == 0x5C14, "");
|
||||
|
||||
_Static_assert(KC_GESC == 0x5C16, "");
|
||||
|
||||
_Static_assert(AU_ON == 0x5C1D, "");
|
||||
_Static_assert(AU_OFF == 0x5C1E, "");
|
||||
_Static_assert(AU_TOG == 0x5C1F, "");
|
||||
|
||||
_Static_assert(CLICKY_TOGGLE == 0x5C20, "");
|
||||
_Static_assert(CLICKY_ENABLE == 0x5C21, "");
|
||||
_Static_assert(CLICKY_DISABLE == 0x5C22, "");
|
||||
_Static_assert(CLICKY_UP == 0x5C23, "");
|
||||
_Static_assert(CLICKY_DOWN == 0x5C24, "");
|
||||
_Static_assert(CLICKY_RESET == 0x5C25, "");
|
||||
_Static_assert(MU_ON == 0x5C26, "");
|
||||
_Static_assert(MU_OFF == 0x5C27, "");
|
||||
_Static_assert(MU_TOG == 0x5C28, "");
|
||||
_Static_assert(MU_MOD == 0x5C29, "");
|
||||
|
||||
_Static_assert(BL_ON == 0x5CBB, "");
|
||||
_Static_assert(BL_OFF == 0x5CBC, "");
|
||||
_Static_assert(BL_DEC == 0x5CBD, "");
|
||||
_Static_assert(BL_INC == 0x5CBE, "");
|
||||
_Static_assert(BL_TOGG == 0x5CBF, "");
|
||||
_Static_assert(BL_STEP == 0x5CC0, "");
|
||||
_Static_assert(BL_BRTG == 0x5CC1, "");
|
||||
_Static_assert(RGB_TOG == 0x5CC2, "");
|
||||
_Static_assert(RGB_MOD == 0x5CC3, "");
|
||||
_Static_assert(RGB_RMOD == 0x5CC4, "");
|
||||
_Static_assert(RGB_HUI == 0x5CC5, "");
|
||||
_Static_assert(RGB_HUD == 0x5CC6, "");
|
||||
_Static_assert(RGB_SAI == 0x5CC7, "");
|
||||
_Static_assert(RGB_SAD == 0x5CC8, "");
|
||||
_Static_assert(RGB_VAI == 0x5CC9, "");
|
||||
_Static_assert(RGB_VAD == 0x5CCA, "");
|
||||
_Static_assert(RGB_SPI == 0x5CCB, "");
|
||||
_Static_assert(RGB_SPD == 0x5CCC, "");
|
||||
_Static_assert(RGB_M_P == 0x5CCD, "");
|
||||
_Static_assert(RGB_M_B == 0x5CCE, "");
|
||||
_Static_assert(RGB_M_R == 0x5CCF, "");
|
||||
_Static_assert(RGB_M_SW == 0x5CD0, "");
|
||||
_Static_assert(RGB_M_SN == 0x5CD1, "");
|
||||
_Static_assert(RGB_M_K == 0x5CD2, "");
|
||||
_Static_assert(RGB_M_X == 0x5CD3, "");
|
||||
_Static_assert(RGB_M_G == 0x5CD4, "");
|
||||
_Static_assert(RGB_M_T == 0x5CD5, "");
|
||||
|
||||
_Static_assert(KC_LSPO == 0x5CD7, "");
|
||||
_Static_assert(KC_RSPC == 0x5CD8, "");
|
||||
_Static_assert(KC_SFTENT == 0x5CD9, "");
|
||||
|
||||
_Static_assert(KC_LCPO == 0x5CF3, "");
|
||||
_Static_assert(KC_RCPC == 0x5CF4, "");
|
||||
_Static_assert(KC_LAPO == 0x5CF5, "");
|
||||
_Static_assert(KC_RAPC == 0x5CF6, "");
|
||||
|
||||
_Static_assert(FN_MO13 == 0x5F10, "");
|
||||
_Static_assert(FN_MO23 == 0x5F11, "");
|
||||
_Static_assert(MACRO00 == 0x5F12, "");
|
||||
_Static_assert(MACRO01 == 0x5F13, "");
|
||||
_Static_assert(MACRO02 == 0x5F14, "");
|
||||
_Static_assert(MACRO03 == 0x5F15, "");
|
||||
_Static_assert(MACRO04 == 0x5F16, "");
|
||||
_Static_assert(MACRO05 == 0x5F17, "");
|
||||
_Static_assert(MACRO06 == 0x5F18, "");
|
||||
_Static_assert(MACRO07 == 0x5F19, "");
|
||||
_Static_assert(MACRO08 == 0x5F1A, "");
|
||||
_Static_assert(MACRO09 == 0x5F1B, "");
|
||||
_Static_assert(MACRO10 == 0x5F1C, "");
|
||||
_Static_assert(MACRO11 == 0x5F1D, "");
|
||||
_Static_assert(MACRO12 == 0x5F1E, "");
|
||||
_Static_assert(MACRO13 == 0x5F1F, "");
|
||||
_Static_assert(MACRO14 == 0x5F20, "");
|
||||
_Static_assert(MACRO15 == 0x5F21, "");
|
||||
|
||||
_Static_assert(USER00 == 0x5F80, "");
|
||||
_Static_assert(USER01 == 0x5F81, "");
|
||||
_Static_assert(USER02 == 0x5F82, "");
|
||||
_Static_assert(USER03 == 0x5F83, "");
|
||||
_Static_assert(USER04 == 0x5F84, "");
|
||||
_Static_assert(USER05 == 0x5F85, "");
|
||||
_Static_assert(USER06 == 0x5F86, "");
|
||||
_Static_assert(USER07 == 0x5F87, "");
|
||||
_Static_assert(USER08 == 0x5F88, "");
|
||||
_Static_assert(USER09 == 0x5F89, "");
|
||||
_Static_assert(USER10 == 0x5F8A, "");
|
||||
_Static_assert(USER11 == 0x5F8B, "");
|
||||
_Static_assert(USER12 == 0x5F8C, "");
|
||||
_Static_assert(USER13 == 0x5F8D, "");
|
||||
_Static_assert(USER14 == 0x5F8E, "");
|
||||
_Static_assert(USER15 == 0x5F8F, "");
|
||||
|
||||
#endif
|
||||
|
|
|
@ -56,7 +56,7 @@ __attribute__((weak)) uint8_t wpm_regress_count(uint16_t keycode) {
|
|||
} else if (keycode > 0xFF) {
|
||||
keycode = 0;
|
||||
}
|
||||
if (keycode == KC_DEL || keycode == KC_BSPC) {
|
||||
if (keycode == KC_DELETE || keycode == KC_BACKSPACE) {
|
||||
if (((get_mods() | get_oneshot_mods()) & MOD_MASK_CTRL) || weak_modded) {
|
||||
return WPM_ESTIMATED_WORD_SIZE;
|
||||
} else {
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue