|
|
@ -27,6 +27,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
#include "keymap_midi.h" |
|
|
|
#include "bootloader.h" |
|
|
|
|
|
|
|
extern keymap_config_t keymap_config; |
|
|
|
|
|
|
|
#include <stdio.h> |
|
|
|
#include <inttypes.h> |
|
|
|
#ifdef AUDIO_ENABLE |
|
|
@ -47,120 +49,9 @@ action_t action_for_key(uint8_t layer, keypos_t key) |
|
|
|
// 16bit keycodes - important |
|
|
|
uint16_t keycode = keymap_key_to_keycode(layer, key); |
|
|
|
|
|
|
|
if (keycode >= 0x0100 && keycode < 0x2000) { |
|
|
|
// Has a modifier |
|
|
|
action_t action; |
|
|
|
// Split it up |
|
|
|
action.code = ACTION_MODS_KEY(keycode >> 8, keycode & 0xFF); // adds modifier to key |
|
|
|
return action; |
|
|
|
} else if (keycode >= 0x2000 && keycode < 0x3000) { |
|
|
|
// Is a shortcut for function layer, pull last 12bits |
|
|
|
// This means we have 4,096 FN macros at our disposal |
|
|
|
return keymap_func_to_action(keycode & 0xFFF); |
|
|
|
} else if (keycode >= 0x3000 && keycode < 0x4000) { |
|
|
|
// When the code starts with 3, it's an action macro. |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_MACRO(keycode & 0xFF); |
|
|
|
return action; |
|
|
|
#ifdef BACKLIGHT_ENABLE |
|
|
|
} else if (keycode >= BL_0 && keycode <= BL_15) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_BACKLIGHT_LEVEL(keycode & 0x000F); |
|
|
|
return action; |
|
|
|
} else if (keycode == BL_DEC) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_BACKLIGHT_DECREASE(); |
|
|
|
return action; |
|
|
|
} else if (keycode == BL_INC) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_BACKLIGHT_INCREASE(); |
|
|
|
return action; |
|
|
|
} else if (keycode == BL_TOGG) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_BACKLIGHT_TOGGLE(); |
|
|
|
return action; |
|
|
|
} else if (keycode == BL_STEP) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_BACKLIGHT_STEP(); |
|
|
|
return action; |
|
|
|
#endif |
|
|
|
} else if (keycode == RESET) { // RESET is 0x5000, which is why this is here |
|
|
|
action_t action; |
|
|
|
clear_keyboard(); |
|
|
|
#ifdef AUDIO_ENABLE |
|
|
|
play_notes(&goodbye, 3, false); |
|
|
|
#endif |
|
|
|
_delay_ms(250); |
|
|
|
#ifdef ATREUS_ASTAR |
|
|
|
*(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific |
|
|
|
#endif |
|
|
|
bootloader_jump(); |
|
|
|
return action; |
|
|
|
} else if (keycode == DEBUG) { // DEBUG is 0x5001 |
|
|
|
// TODO: Does this actually work? |
|
|
|
action_t action; |
|
|
|
print("\nDEBUG: enabled.\n"); |
|
|
|
debug_enable = true; |
|
|
|
return action; |
|
|
|
} else if (keycode >= 0x5000 && keycode < 0x6000) { |
|
|
|
// Layer movement shortcuts |
|
|
|
// See .h to see constraints/usage |
|
|
|
int type = (keycode >> 0x8) & 0xF; |
|
|
|
if (type == 0x1) { |
|
|
|
// Layer set "GOTO" |
|
|
|
int when = (keycode >> 0x4) & 0x3; |
|
|
|
int layer = keycode & 0xF; |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_LAYER_SET(layer, when); |
|
|
|
return action; |
|
|
|
} else if (type == 0x2) { |
|
|
|
// Momentary layer |
|
|
|
int layer = keycode & 0xFF; |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_LAYER_MOMENTARY(layer); |
|
|
|
return action; |
|
|
|
} else if (type == 0x3) { |
|
|
|
// Set default layer |
|
|
|
int layer = keycode & 0xFF; |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_DEFAULT_LAYER_SET(layer); |
|
|
|
return action; |
|
|
|
} else if (type == 0x4) { |
|
|
|
// Set default layer |
|
|
|
int layer = keycode & 0xFF; |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_LAYER_TOGGLE(layer); |
|
|
|
return action; |
|
|
|
} |
|
|
|
#ifdef MIDI_ENABLE |
|
|
|
} else if (keycode >= 0x6000 && keycode < 0x7000) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_FUNCTION_OPT(keycode & 0xFF, (keycode & 0x0F00) >> 8); |
|
|
|
return action; |
|
|
|
#endif |
|
|
|
} else if (keycode >= 0x7000 && keycode < 0x8000) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF); |
|
|
|
return action; |
|
|
|
} else if (keycode >= 0x8000 && keycode < 0x9000) { |
|
|
|
action_t action; |
|
|
|
action.code = ACTION_LAYER_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF); |
|
|
|
return action; |
|
|
|
#ifdef UNICODE_ENABLE |
|
|
|
} else if (keycode >= 0x8000000) { |
|
|
|
action_t action; |
|
|
|
uint16_t unicode = keycode & ~(0x8000); |
|
|
|
action.code = ACTION_FUNCTION_OPT(unicode & 0xFF, (unicode & 0xFF00) >> 8); |
|
|
|
return action; |
|
|
|
#endif |
|
|
|
} else { |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
switch (keycode) { |
|
|
|
case KC_FN0 ... KC_FN31: |
|
|
|
return keymap_fn_to_action(keycode); |
|
|
|
#ifdef BOOTMAGIC_ENABLE |
|
|
|
case KC_CAPSLOCK: |
|
|
|
case KC_LOCKING_CAPS: |
|
|
|
if (keymap_config.swap_control_capslock || keymap_config.capslock_to_control) { |
|
|
@ -224,7 +115,6 @@ action_t action_for_key(uint8_t layer, keypos_t key) |
|
|
|
return keycode_to_action(KC_BSLASH); |
|
|
|
} |
|
|
|
return keycode_to_action(KC_BSPACE); |
|
|
|
#endif |
|
|
|
default: |
|
|
|
return keycode_to_action(keycode); |
|
|
|
} |
|
|
@ -265,6 +155,142 @@ static action_t keycode_to_action(uint16_t keycode) |
|
|
|
case KC_TRNS: |
|
|
|
action.code = ACTION_TRANSPARENT; |
|
|
|
break; |
|
|
|
case 0x0100 ... 0x1FFF: ; |
|
|
|
// Has a modifier |
|
|
|
// Split it up |
|
|
|
action.code = ACTION_MODS_KEY(keycode >> 8, keycode & 0xFF); // adds modifier to key |
|
|
|
break; |
|
|
|
case 0x2000 ... 0x2FFF: |
|
|
|
// Is a shortcut for function layer, pull last 12bits |
|
|
|
// This means we have 4,096 FN macros at our disposal |
|
|
|
return keymap_func_to_action(keycode & 0xFFF); |
|
|
|
break; |
|
|
|
case 0x3000 ... 0x3FFF: ; |
|
|
|
// When the code starts with 3, it's an action macro. |
|
|
|
action.code = ACTION_MACRO(keycode & 0xFF); |
|
|
|
break; |
|
|
|
#ifdef BACKLIGHT_ENABLE |
|
|
|
case BL_0 ... BL_15: |
|
|
|
action.code = ACTION_BACKLIGHT_LEVEL(keycode & 0x000F); |
|
|
|
break; |
|
|
|
case BL_DEC: |
|
|
|
action.code = ACTION_BACKLIGHT_DECREASE(); |
|
|
|
break; |
|
|
|
case BL_INC: |
|
|
|
action.code = ACTION_BACKLIGHT_INCREASE(); |
|
|
|
break; |
|
|
|
case BL_TOGG: |
|
|
|
action.code = ACTION_BACKLIGHT_TOGGLE(); |
|
|
|
break; |
|
|
|
case BL_STEP: |
|
|
|
action.code = ACTION_BACKLIGHT_STEP(); |
|
|
|
break; |
|
|
|
#endif |
|
|
|
case RESET: ; // RESET is 0x5000, which is why this is here |
|
|
|
clear_keyboard(); |
|
|
|
#ifdef AUDIO_ENABLE |
|
|
|
play_notes(&goodbye, 3, false); |
|
|
|
#endif |
|
|
|
_delay_ms(250); |
|
|
|
#ifdef ATREUS_ASTAR |
|
|
|
*(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific |
|
|
|
#endif |
|
|
|
bootloader_jump(); |
|
|
|
break; |
|
|
|
case DEBUG: ; // DEBUG is 0x5001 |
|
|
|
print("\nDEBUG: enabled.\n"); |
|
|
|
debug_enable = true; |
|
|
|
break; |
|
|
|
case 0x5002 ... 0x50FF: |
|
|
|
// MAGIC actions (BOOTMAGIC without the boot) |
|
|
|
if (!eeconfig_is_enabled()) { |
|
|
|
eeconfig_init(); |
|
|
|
} |
|
|
|
/* keymap config */ |
|
|
|
keymap_config.raw = eeconfig_read_keymap(); |
|
|
|
if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) { |
|
|
|
keymap_config.swap_control_capslock = 1; |
|
|
|
} else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) { |
|
|
|
keymap_config.capslock_to_control = 1; |
|
|
|
} else if (keycode == MAGIC_SWAP_LALT_LGUI) { |
|
|
|
keymap_config.swap_lalt_lgui = 1; |
|
|
|
} else if (keycode == MAGIC_SWAP_RALT_RGUI) { |
|
|
|
keymap_config.swap_ralt_rgui = 1; |
|
|
|
} else if (keycode == MAGIC_NO_GUI) { |
|
|
|
keymap_config.no_gui = 1; |
|
|
|
} else if (keycode == MAGIC_SWAP_GRAVE_ESC) { |
|
|
|
keymap_config.swap_grave_esc = 1; |
|
|
|
} else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) { |
|
|
|
keymap_config.swap_backslash_backspace = 1; |
|
|
|
} else if (keycode == MAGIC_HOST_NKRO) { |
|
|
|
keymap_config.nkro = 1; |
|
|
|
} else if (keycode == MAGIC_SWAP_ALT_GUI) { |
|
|
|
keymap_config.swap_lalt_lgui = 1; |
|
|
|
keymap_config.swap_ralt_rgui = 1; |
|
|
|
} |
|
|
|
/* UNs */ |
|
|
|
else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) { |
|
|
|
keymap_config.swap_control_capslock = 0; |
|
|
|
} else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) { |
|
|
|
keymap_config.capslock_to_control = 0; |
|
|
|
} else if (keycode == MAGIC_UNSWAP_LALT_LGUI) { |
|
|
|
keymap_config.swap_lalt_lgui = 0; |
|
|
|
} else if (keycode == MAGIC_UNSWAP_RALT_RGUI) { |
|
|
|
keymap_config.swap_ralt_rgui = 0; |
|
|
|
} else if (keycode == MAGIC_UNNO_GUI) { |
|
|
|
keymap_config.no_gui = 0; |
|
|
|
} else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) { |
|
|
|
keymap_config.swap_grave_esc = 0; |
|
|
|
} else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) { |
|
|
|
keymap_config.swap_backslash_backspace = 0; |
|
|
|
} else if (keycode == MAGIC_UNHOST_NKRO) { |
|
|
|
keymap_config.nkro = 0; |
|
|
|
} else if (keycode == MAGIC_UNSWAP_ALT_GUI) { |
|
|
|
keymap_config.swap_lalt_lgui = 0; |
|
|
|
keymap_config.swap_ralt_rgui = 0; |
|
|
|
} |
|
|
|
eeconfig_write_keymap(keymap_config.raw); |
|
|
|
break; |
|
|
|
case 0x5100 ... 0x5FFF: ; |
|
|
|
// Layer movement shortcuts |
|
|
|
// See .h to see constraints/usage |
|
|
|
int type = (keycode >> 0x8) & 0xF; |
|
|
|
if (type == 0x1) { |
|
|
|
// Layer set "GOTO" |
|
|
|
int when = (keycode >> 0x4) & 0x3; |
|
|
|
int layer = keycode & 0xF; |
|
|
|
action.code = ACTION_LAYER_SET(layer, when); |
|
|
|
} else if (type == 0x2) { |
|
|
|
// Momentary layer |
|
|
|
int layer = keycode & 0xFF; |
|
|
|
action.code = ACTION_LAYER_MOMENTARY(layer); |
|
|
|
} else if (type == 0x3) { |
|
|
|
// Set default layer |
|
|
|
int layer = keycode & 0xFF; |
|
|
|
action.code = ACTION_DEFAULT_LAYER_SET(layer); |
|
|
|
} else if (type == 0x4) { |
|
|
|
// Set default layer |
|
|
|
int layer = keycode & 0xFF; |
|
|
|
action.code = ACTION_LAYER_TOGGLE(layer); |
|
|
|
} |
|
|
|
break; |
|
|
|
#ifdef MIDI_ENABLE |
|
|
|
case 0x6000 ... 0x6FFF: |
|
|
|
action.code = ACTION_FUNCTION_OPT(keycode & 0xFF, (keycode & 0x0F00) >> 8); |
|
|
|
break; |
|
|
|
#endif |
|
|
|
case 0x7000 ... 0x7FFF: |
|
|
|
action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF); |
|
|
|
break; |
|
|
|
case 0x8000 ... 0x8FFF: |
|
|
|
action.code = ACTION_LAYER_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF); |
|
|
|
break; |
|
|
|
#ifdef UNICODE_ENABLE |
|
|
|
case 0x8000000 ... 0x8FFFFFF: |
|
|
|
uint16_t unicode = keycode & ~(0x8000); |
|
|
|
action.code = ACTION_FUNCTION_OPT(unicode & 0xFF, (unicode & 0xFF00) >> 8); |
|
|
|
break; |
|
|
|
#endif |
|
|
|
default: |
|
|
|
action.code = ACTION_NO; |
|
|
|
break; |
|
|
|