keymap_common.c (8977B)
1 /* 2 Copyright 2012-2017 Jun Wako <wakojun@gmail.com> 3 4 This program is free software: you can redistribute it and/or modify 5 it under the terms of the GNU General Public License as published by 6 the Free Software Foundation, either version 2 of the License, or 7 (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 14 You should have received a copy of the GNU General Public License 15 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 */ 17 18 #include "keymap_common.h" 19 #include "keymap_introspection.h" 20 #include "report.h" 21 #include "keycode.h" 22 #include "action_layer.h" 23 #include "action.h" 24 #include "debug.h" 25 #include "keycode_config.h" 26 #include "quantum_keycodes.h" 27 28 #ifdef ENCODER_MAP_ENABLE 29 # include "encoder.h" 30 #endif 31 32 #ifdef DIP_SWITCH_MAP_ENABLE 33 # include "dip_switch.h" 34 #endif 35 36 #ifdef BACKLIGHT_ENABLE 37 # include "backlight.h" 38 #endif 39 40 #ifdef MIDI_ENABLE 41 # include "process_midi.h" 42 #endif 43 44 extern keymap_config_t keymap_config; 45 46 #include <inttypes.h> 47 48 /* converts key to action */ 49 action_t action_for_key(uint8_t layer, keypos_t key) { 50 // 16bit keycodes - important 51 uint16_t keycode = keymap_key_to_keycode(layer, key); 52 return action_for_keycode(keycode); 53 }; 54 55 action_t action_for_keycode(uint16_t keycode) { 56 // keycode remapping 57 keycode = keycode_config(keycode); 58 59 action_t action = {}; 60 uint8_t action_layer, mod; 61 62 (void)action_layer; 63 (void)mod; 64 65 switch (keycode) { 66 case BASIC_KEYCODE_RANGE: 67 case MODIFIER_KEYCODE_RANGE: 68 action.code = ACTION_KEY(keycode); 69 break; 70 #ifdef EXTRAKEY_ENABLE 71 case SYSTEM_KEYCODE_RANGE: 72 action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode)); 73 break; 74 case CONSUMER_KEYCODE_RANGE: 75 action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode)); 76 break; 77 #endif 78 case MOUSE_KEYCODE_RANGE: 79 action.code = ACTION_MOUSEKEY(keycode); 80 break; 81 case KC_TRANSPARENT: 82 action.code = ACTION_TRANSPARENT; 83 break; 84 case QK_MODS ... QK_MODS_MAX:; 85 // Has a modifier 86 // Split it up 87 #ifdef LEGACY_MAGIC_HANDLING 88 action.code = ACTION_MODS_KEY(QK_MODS_GET_MODS(keycode), QK_MODS_GET_BASIC_KEYCODE(keycode)); // adds modifier to key 89 #else // LEGACY_MAGIC_HANDLING 90 action.code = ACTION_MODS_KEY(mod_config(QK_MODS_GET_MODS(keycode)), keycode_config(QK_MODS_GET_BASIC_KEYCODE(keycode))); // adds modifier to key 91 #endif // LEGACY_MAGIC_HANDLING 92 break; 93 case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: 94 #if !defined(NO_ACTION_LAYER) && !defined(NO_ACTION_TAPPING) 95 # ifdef LEGACY_MAGIC_HANDLING 96 action.code = ACTION_LAYER_TAP_KEY(QK_LAYER_TAP_GET_LAYER(keycode), QK_LAYER_TAP_GET_TAP_KEYCODE(keycode)); 97 # else // LEGACY_MAGIC_HANDLING 98 action.code = ACTION_LAYER_TAP_KEY(QK_LAYER_TAP_GET_LAYER(keycode), keycode_config(QK_LAYER_TAP_GET_TAP_KEYCODE(keycode))); 99 # endif // LEGACY_MAGIC_HANDLING 100 #else 101 // pass through keycode_config again, since it previously missed it 102 // and then only send as ACTION_KEY to bypass most of action.c handling 103 action.code = ACTION_KEY(keycode_config(QK_LAYER_TAP_GET_TAP_KEYCODE(keycode))); 104 #endif 105 break; 106 #ifndef NO_ACTION_LAYER 107 case QK_TO ... QK_TO_MAX:; 108 // Layer set "GOTO" 109 action_layer = QK_TO_GET_LAYER(keycode); 110 action.code = ACTION_LAYER_GOTO(action_layer); 111 break; 112 case QK_MOMENTARY ... QK_MOMENTARY_MAX:; 113 // Momentary action_layer 114 action_layer = QK_MOMENTARY_GET_LAYER(keycode); 115 action.code = ACTION_LAYER_MOMENTARY(action_layer); 116 break; 117 case QK_DEF_LAYER ... QK_DEF_LAYER_MAX:; 118 // Set default action_layer 119 action_layer = QK_DEF_LAYER_GET_LAYER(keycode); 120 action.code = ACTION_DEFAULT_LAYER_SET(action_layer); 121 break; 122 case QK_TOGGLE_LAYER ... QK_TOGGLE_LAYER_MAX:; 123 // Set toggle 124 action_layer = QK_TOGGLE_LAYER_GET_LAYER(keycode); 125 action.code = ACTION_LAYER_TOGGLE(action_layer); 126 break; 127 #endif 128 #ifndef NO_ACTION_ONESHOT 129 case QK_ONE_SHOT_LAYER ... QK_ONE_SHOT_LAYER_MAX:; 130 // OSL(action_layer) - One-shot action_layer 131 action_layer = QK_ONE_SHOT_LAYER_GET_LAYER(keycode); 132 action.code = ACTION_LAYER_ONESHOT(action_layer); 133 break; 134 #endif // NO_ACTION_ONESHOT 135 case QK_ONE_SHOT_MOD ... QK_ONE_SHOT_MOD_MAX:; 136 // OSM(mod) - One-shot mod 137 mod = mod_config(QK_ONE_SHOT_MOD_GET_MODS(keycode)); 138 #if defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT) 139 action.code = ACTION_MODS(mod); 140 #else // defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT) 141 action.code = ACTION_MODS_ONESHOT(mod); 142 #endif // defined(NO_ACTION_TAPPING) || defined(NO_ACTION_ONESHOT) 143 break; 144 #ifndef NO_ACTION_LAYER 145 case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX: 146 # ifndef NO_ACTION_TAPPING 147 action.code = ACTION_LAYER_TAP_TOGGLE(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode)); 148 # else // NO_ACTION_TAPPING 149 # ifdef NO_ACTION_TAPPING_TAP_TOGGLE_MO 150 action.code = ACTION_LAYER_MOMENTARY(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode)); 151 # else // NO_ACTION_TAPPING_TAP_TOGGLE_MO 152 action.code = ACTION_LAYER_TOGGLE(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode)); 153 # endif // NO_ACTION_TAPPING_TAP_TOGGLE_MO 154 # endif // NO_ACTION_TAPPING 155 break; 156 case QK_LAYER_MOD ... QK_LAYER_MOD_MAX: 157 mod = mod_config(QK_LAYER_MOD_GET_MODS(keycode)); 158 action_layer = QK_LAYER_MOD_GET_LAYER(keycode); 159 action.code = ACTION_LAYER_MODS(action_layer, (mod & 0x10) ? (mod & 0xF) << 4 : mod); 160 break; 161 #endif // NO_ACTION_LAYER 162 case QK_MOD_TAP ... QK_MOD_TAP_MAX: 163 #ifndef NO_ACTION_TAPPING 164 mod = mod_config(QK_MOD_TAP_GET_MODS(keycode)); 165 # ifdef LEGACY_MAGIC_HANDLING 166 action.code = ACTION_MODS_TAP_KEY(mod, QK_MOD_TAP_GET_TAP_KEYCODE(keycode)); 167 # else // LEGACY_MAGIC_HANDLING 168 action.code = ACTION_MODS_TAP_KEY(mod, keycode_config(QK_MOD_TAP_GET_TAP_KEYCODE(keycode))); 169 # endif // LEGACY_MAGIC_HANDLING 170 #else // NO_ACTION_TAPPING 171 # ifdef NO_ACTION_TAPPING_MODTAP_MODS 172 // pass through mod_config again, since it previously missed it 173 // and then only send as ACTION_KEY to bypass most of action.c handling 174 action.code = ACTION_MODS(mod_config(QK_MOD_TAP_GET_MODS(keycode))); 175 # else // NO_ACTION_TAPPING_MODTAP_MODS 176 // pass through keycode_config again, since it previously missed it 177 // and then only send as ACTION_KEY to bypass most of action.c handling 178 action.code = ACTION_KEY(keycode_config(QK_MOD_TAP_GET_TAP_KEYCODE(keycode))); 179 # endif // NO_ACTION_TAPPING_MODTAP_MODS 180 #endif // NO_ACTION_TAPPING 181 break; 182 #ifdef SWAP_HANDS_ENABLE 183 case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX: 184 # ifdef LEGACY_MAGIC_HANDLING 185 action.code = ACTION(ACT_SWAP_HANDS, QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode)); 186 # else // LEGACY_MAGIC_HANDLING 187 action.code = ACTION(ACT_SWAP_HANDS, keycode_config(QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode))); 188 # endif // LEGACY_MAGIC_HANDLING 189 break; 190 #endif 191 192 default: 193 action.code = ACTION_NO; 194 break; 195 } 196 return action; 197 } 198 199 // translates key to keycode 200 __attribute__((weak)) uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key) { 201 if (key.row < MATRIX_ROWS && key.col < MATRIX_COLS) { 202 return keycode_at_keymap_location(layer, key.row, key.col); 203 } 204 #ifdef ENCODER_MAP_ENABLE 205 else if (key.row == KEYLOC_ENCODER_CW && key.col < NUM_ENCODERS) { 206 return keycode_at_encodermap_location(layer, key.col, true); 207 } else if (key.row == KEYLOC_ENCODER_CCW && key.col < NUM_ENCODERS) { 208 return keycode_at_encodermap_location(layer, key.col, false); 209 } 210 #endif // ENCODER_MAP_ENABLE 211 #ifdef DIP_SWITCH_MAP_ENABLE 212 else if (key.row == KEYLOC_DIP_SWITCH_ON && key.col < NUM_DIP_SWITCHES) { 213 return keycode_at_dip_switch_map_location(key.col, true); 214 } else if (key.row == KEYLOC_DIP_SWITCH_OFF && key.col < NUM_DIP_SWITCHES) { 215 return keycode_at_dip_switch_map_location(key.col, false); 216 } 217 #endif // DIP_SWITCH_MAP_ENABLE 218 219 return KC_NO; 220 }