Migrate fn_actions for default keymaps (#4935)

* Migrate fn_actions for default keymaps

* Rename the Grave/Escape Shift masks

* No need for shift_esc_shift_mask

* Change breaks to return false

* Right align pointers

* Add default case

* Separate cases with empty lines

keyboards/acr60/keymaps/default/keymap.c

@@ -1,6 +1,10 @@
 #include QMK_KEYBOARD_H
 
-#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
@@ -13,7 +17,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * via the function actions code at the bottom.
  */
 	LAYOUT(
-		F(0), KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_NO, KC_BSPC,
+		SFT_ESC,KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_NO, KC_BSPC,
 		KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
 		KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
 		KC_LSFT, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_NO,
@@ -34,21 +38,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 };
 
-enum function_id {
-    SHIFT_ESC,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(SHIFT_ESC),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case SHIFT_ESC:
-      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -56,7 +50,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -64,6 +58,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/amj40/keymaps/default/keymap.c

@@ -45,7 +45,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_ESC,  KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,    KC_O,    KC_P,   KC_BSPC,\
         KC_TAB,  KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,    KC_L,    KC_ENT,\
         KC_LSFT, KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_SLSH,\
-        KC_LCTL, KC_LGUI, KC_LALT,          F(0),           F(1),        F(2), KC_RALT, KC_RCTL \
+        KC_LCTL, KC_LGUI, KC_LALT,          LT(_LOWER, KC_SPC),LT(_RAISE, KC_SPC),LT(_ADJUST, KC_LGUI), KC_RALT, KC_RCTL \
 		),
 
     /* Function Layer 1 HHKB style
@@ -106,24 +106,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-
-		
-
-enum function_id {
-    LAUNCH,
-    RGBLED_TOGGLE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-	[0]  = ACTION_LAYER_TAP_KEY(_LOWER, KC_SPC),
-	[1]  = ACTION_LAYER_TAP_KEY(_RAISE, KC_SPC),
-	[2]  = ACTION_LAYER_TAP_KEY(_ADJUST, KC_LGUI),
-
-};
-
-
-
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
     // MACRODOWN only works in this function

keyboards/amj60/keymaps/iso_split_rshift/keymap.c

@@ -111,21 +111,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     [_SFX] = LAYOUT_iso_splitrshift(
         RESET,   _______, _______, _______, _______, _______, _______, KC_7,    KC_8,    KC_9, _______, _______, _______, KC_BSPC, \
         _______, _______, _______, _______, _______, _______, _______, KC_4,    KC_5,    KC_6, _______, _______, _______, KC_BSLS, \
-        _______, F(2),    F(3),    _______, _______, _______, _______, KC_1,    KC_2,    KC_3, _______, _______, XXXXXXX, KC_ENT,  \
-        _______, F(4),    F(5),    F(6),    F(7),    F(8),    F(9),    _______, _______, KC_0, _______, KC_SLSH, KC_UP,   _______, \
+        _______, _______, _______, _______, _______, _______, _______, KC_1,    KC_2,    KC_3, _______, _______, XXXXXXX, KC_ENT,  \
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_0, _______, KC_SLSH, KC_UP,   _______, \
         _______, _______, _______,                            _______,                         _______, KC_LEFT, KC_DOWN, KC_RGHT),
 };
 
-enum function_id {
-    LAUNCH,
-    RGBLED_TOGGLE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-    [1]  = ACTION_FUNCTION(LAUNCH),
-    [10] = ACTION_MODS_TAP_KEY(MOD_LCTL, KC_ENT),
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
     // MACRODOWN only works in this function

keyboards/clueboard/card/keymaps/default/keymap.c

@@ -1,12 +1,18 @@
 #include QMK_KEYBOARD_H
 
+enum custom_keycodes {
+	SONG_SU = SAFE_RANGE,
+	SONG_SC,
+	SONG_GB
+};
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 	[0] = LAYOUT(
 		RGB_TOG,        RGB_SAI,        RGB_VAI, \
 		        RGB_HUD,        RGB_HUI,         \
 		RGB_MOD,        RGB_SAD,        RGB_VAD, \
 		BL_STEP,                                 \
-		F(0),   F(1),   F(2)                     \
+		SONG_SU,SONG_SC,SONG_GB                  \
 	)
 };
 
@@ -23,28 +29,6 @@ float music_scale[][2] = SONG(MUSIC_SCALE_SOUND);
 float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
 #endif
 
-const uint16_t PROGMEM fn_actions[] = {
-	[0] = ACTION_FUNCTION(0),
-	[1] = ACTION_FUNCTION(1),
-	[2] = ACTION_FUNCTION(2)
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-	if (record->event.pressed) {
-		switch (id) {
-			case 0:
-				PLAY_SONG(tone_startup);
-				break;
-			case 1:
-				PLAY_SONG(music_scale);
-				break;
-			case 2:
-				PLAY_SONG(tone_goodbye);
-				break;
-		}
-	}
-};
-
 void matrix_init_user(void) {
 }
 
@@ -53,7 +37,31 @@ void matrix_scan_user(void) {
 }
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  return true;
+  switch (keycode) {
+    case SONG_SU:
+      if (record->event.pressed) {
+        PLAY_SONG(tone_startup);
+      }
+
+      return false;
+
+    case SONG_SC:
+      if (record->event.pressed) {
+        PLAY_SONG(music_scale);
+      }
+
+      return false;
+
+    case SONG_GB:
+      if (record->event.pressed) {
+        PLAY_SONG(tone_goodbye);
+      }
+
+      return false;
+
+    default:
+      return true;
+  }
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/do60/keymaps/default/keymap.c

@@ -9,7 +9,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,    KC_P,    KC_LBRC,  KC_RBRC,           KC_BSLS,   \
       KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_RSFT,  KC_SLSH,   KC_UP,    KC_SLSH,    \
-      KC_LCTL, KC_LGUI, KC_LALT,                  KC_SPC, KC_NO,  KC_BSPC,                 KC_RGUI, F(0),     KC_LEFT, KC_DOWN,  KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                  KC_SPC, KC_NO,  KC_BSPC,                 KC_RGUI, MO(1),    KC_LEFT, KC_DOWN,  KC_RIGHT),
 
   // 1: Function Layer
   [1] = LAYOUT_all(
@@ -17,15 +17,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   RGB_HUI, RGB_SAI, RGB_VAI, RGB_MOD,  BL_TOGG,BL_ON,  BL_INC, KC_INS, KC_NO,   KC_PSCR, KC_SLCK,  KC_PAUS,          KC_DEL,    \
       KC_NO,   RGB_HUD, RGB_SAD, RGB_VAD, RGB_RMOD, BL_STEP,BL_OFF, BL_DEC, KC_NO,  KC_NO,   KC_HOME, KC_PGUP,  KC_NO,            KC_ENT,    \
       KC_LSFT, KC_NO,   KC_NO,   KC_APP,  BL_STEP,  KC_NO,  KC_NO,  KC_VOLD,KC_VOLU,KC_MUTE, KC_END,  KC_RSFT,  KC_NO  , KC_PGUP,  KC_INS,    \
-      KC_LCTL, KC_LGUI, KC_LALT,                    KC_BSPC,KC_SPC, KC_DEL,                  KC_RGUI, F(0),     KC_HOME, KC_PGDOWN,KC_END),
+      KC_LCTL, KC_LGUI, KC_LALT,                    KC_BSPC,KC_SPC, KC_DEL,                  KC_RGUI, MO(1),    KC_HOME, KC_PGDOWN,KC_END),
 
 };
 
-// Custom Actions
-const uint16_t PROGMEM fn_actions[] = {
-     [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
- };
-
 // Macros
 /*
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
@@ -44,4 +39,4 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 // Loop
 void matrix_scan_user(void) {
   // Empty
-};
+};

keyboards/do60/keymaps/test/keymap.c

@@ -9,7 +9,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,    KC_P,    KC_LBRC,  KC_RBRC,           KC_BSLS,   \
       KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_SLSH,  KC_RSFT, KC_UP,    KC_SLSH,    \
-      KC_LCTL, KC_LGUI, KC_LALT,                  KC_BSPC,KC_SPC, KC_DEL,                  KC_RGUI, F(0),    KC_LEFT, KC_DOWN,  KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                  KC_BSPC,KC_SPC, KC_DEL,                  KC_RGUI, MO(1),   KC_LEFT, KC_DOWN,  KC_RIGHT),
 
   // 1: Function Layer
   [1] = LAYOUT_all(
@@ -17,15 +17,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   RGB_HUI, RGB_SAI, RGB_VAI, RGB_MOD,  KC_HOME,KC_CALC,KC_NO,  KC_INS, KC_NO,   KC_PSCR, KC_SLCK,  KC_PAUS,          KC_DEL,    \
       KC_NO,   RGB_HUD, RGB_SAD, RGB_VAD, RGB_RMOD, KC_END, KC_PGDN,KC_NO,  KC_NO,  KC_NO,   KC_HOME, KC_PGUP,  KC_NO,            KC_ENT,    \
       KC_LSFT, KC_NO,   KC_NO,   KC_APP,  BL_STEP,  KC_NO,  KC_NO,  KC_VOLD,KC_VOLU,KC_MUTE, KC_END,  KC_RSFT,  KC_NO  , KC_PGUP,  KC_INS,    \
-      KC_LCTL, KC_LGUI, KC_LALT,                    KC_BSPC,KC_SPC, KC_DEL,                  KC_RGUI, F(0),     KC_HOME, KC_PGDOWN,KC_END),
+      KC_LCTL, KC_LGUI, KC_LALT,                    KC_BSPC,KC_SPC, KC_DEL,                  KC_RGUI, MO(1),    KC_HOME, KC_PGDOWN,KC_END),
 
 };
 
-// Custom Actions
- const uint16_t PROGMEM fn_actions[] = {
-     [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
- };
-
 // Macros
 /*
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {

keyboards/ergodone/keymaps/default/keymap.c

@@ -53,7 +53,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
              TG(SYMB),    KC_Y,   KC_U,  KC_I,   KC_O,   KC_P,             KC_BSLS,
                           KC_H,   KC_J,  KC_K,   KC_L,   LT(MDIA, KC_SCLN),GUI_T(KC_QUOT),
              MEH_T(KC_NO),KC_N,   KC_M,  KC_COMM,KC_DOT, CTL_T(KC_SLSH),   KC_RSFT,
-                                  KC_UP, KC_DOWN,KC_LBRC,KC_RBRC,          KC_FN1,
+                                  KC_UP, KC_DOWN,KC_LBRC,KC_RBRC,          TT(SYMB),
              KC_LALT,        CTL_T(KC_ESC),
              KC_PGUP,
              KC_PGDN,KC_TAB, KC_ENT
@@ -143,10 +143,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // FN1 - Momentary Layer 1 (Symbols)
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function

keyboards/ergodox_ez/keymaps/default/keymap.c

@@ -48,7 +48,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   TG(SYMB),     KC_Y,    KC_U,    KC_I,    KC_O,              KC_P,           KC_BSLS,
   KC_H,         KC_J,    KC_K,    KC_L,    LT(MDIA, KC_SCLN), GUI_T(KC_QUOT),
   MEH_T(KC_NO), KC_N,    KC_M,    KC_COMM, KC_DOT,            CTL_T(KC_SLSH), KC_RSFT,
-  KC_UP,        KC_DOWN, KC_LBRC, KC_RBRC, KC_FN1,
+  KC_UP,        KC_DOWN, KC_LBRC, KC_RBRC, TT(SYMB),
   KC_LALT, CTL_T(KC_ESC),
   KC_PGUP,
   KC_PGDN, KC_TAB, KC_ENT
@@ -137,10 +137,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // FN1 - Momentary Layer 1 (Symbols)
-};
-
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   if (record->event.pressed) {
     switch (keycode) {

keyboards/ergodox_ez/keymaps/default_osx/keymap.c

@@ -48,7 +48,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
              TG(SYMB),       KC_Y,   KC_U,   KC_I,   KC_O,   KC_P,             KC_BSLS,
                           KC_H,   KC_J,   KC_K,   KC_L,   LT(MDIA, KC_SCLN),KC_LGUI,
              MEH_T(KC_NO),KC_N,   KC_M,   KC_COMM,KC_DOT, CTL_T(KC_SLSH),   KC_RSFT,
-                                  KC_UP,  KC_DOWN,KC_LBRC,KC_RBRC,          KC_FN1,
+                                  KC_UP,  KC_DOWN,KC_LBRC,KC_RBRC,          TT(SYMB),
              KC_LALT,        CTL_T(KC_ESC),
              KC_PGUP,
              KC_PGDN,KC_TAB, KC_ENT
@@ -138,10 +138,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // FN1 - Momentary Layer 1 (Symbols)
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function

keyboards/ergodox_infinity/keymaps/default/keymap.c

@@ -53,7 +53,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
              TG(SYMB),    KC_Y,   KC_U,  KC_I,   KC_O,   KC_P,             KC_BSLS,
                           KC_H,   KC_J,  KC_K,   KC_L,   LT(MDIA, KC_SCLN),GUI_T(KC_QUOT),
              MEH_T(KC_NO),KC_N,   KC_M,  KC_COMM,KC_DOT, CTL_T(KC_SLSH),   KC_RSFT,
-                                  KC_UP, KC_DOWN,KC_LBRC,KC_RBRC,          KC_FN1,
+                                  KC_UP, KC_DOWN,KC_LBRC,KC_RBRC,          TT(SYMB),
              KC_LALT,        CTL_T(KC_ESC),
              KC_PGUP,
              KC_PGDN,KC_TAB, KC_ENT
@@ -143,10 +143,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // FN1 - Momentary Layer 1 (Symbols)
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function

keyboards/gh60/keymaps/default/keymap.c

@@ -10,7 +10,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_GRV,
     KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSPC,
     KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_NO,   KC_ENT,
-    KC_LSFT, F(1),    KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, F(0),    KC_RSFT,
+    KC_LSFT, TG(2),   KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, MO(1),   KC_RSFT,
     KC_LCTL, KC_LGUI, KC_LALT,                   KC_SPC,                             KC_BSLS, KC_RALT, KC_RGUI, KC_APP,  KC_RCTL
   ),
   /* 1: fn */
@@ -33,11 +33,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-    [1] = ACTION_LAYER_TOGGLE(2),     // toggle arrow overlay
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function

keyboards/handwired/dactyl/keymaps/default/keymap.c

@@ -47,7 +47,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                              KC_Y,   KC_U,     KC_I,     KC_O,               KC_P,         KC_BSLS,
                              KC_H,   KC_J,     KC_K,     KC_L,  LT(MDIA, KC_SCLN),  GUI_T(KC_QUOT),
                              KC_N,   KC_M,  KC_COMM,   KC_DOT,     CTL_T(KC_SLSH),         KC_RSFT,
-                                    KC_UP,  KC_DOWN,  KC_LBRC,            KC_RBRC,          KC_FN1,
+                                    KC_UP,  KC_DOWN,  KC_LBRC,            KC_RBRC,          TT(SYMB),
           KC_RALT,  CTL_T(KC_ESC),
           KC_PGUP,
           KC_PGDN, KC_TAB, KC_ENT
@@ -137,10 +137,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // FN1 - Momentary Layer 1 (Symbols)
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function

keyboards/handwired/dactyl/keymaps/dvorak/keymap.c

@@ -47,7 +47,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                              KC_F,   KC_G,     KC_C,     KC_R,            KC_L,         KC_BSLS,
                              KC_D,   KC_H,     KC_T,     KC_N,  LT(MDIA, KC_S),  GUI_T(KC_SLSH),
                              KC_B,   KC_M,     KC_W,     KC_V,     CTL_T(KC_Z),         KC_RSFT,
-                                    KC_UP,  KC_DOWN,  KC_LBRC,         KC_RBRC,          KC_FN1,
+                                    KC_UP,  KC_DOWN,  KC_LBRC,         KC_RBRC,          TT(SYMB),
           KC_RALT,  CTL_T(KC_ESC),
           KC_PGUP,
           KC_PGDN, KC_TAB, KC_ENT
@@ -137,10 +137,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // FN1 - Momentary Layer 1 (Symbols)
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function

keyboards/handwired/gamenum/keymaps/default/keymap.c

@@ -7,21 +7,21 @@
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [DEF] = LAYOUT(
-    KC_FN0,  KC_SLSH, KC_ASTR, KC_MINS, \
+    TO(HDN), KC_SLSH, KC_ASTR, KC_MINS, \
     KC_7,    KC_8,    KC_9,    KC_PLUS, \
     KC_4,    KC_5,    KC_6,             \
     KC_1,    KC_2,    KC_3,             \
     KC_0,             KC_DOT,  KC_ENT   \
   ),
   [HDN] = LAYOUT(
-    KC_FN1,  KC_1,    KC_2,    KC_3,    \
+    TO(OSY), KC_1,    KC_2,    KC_3,    \
     KC_Q,    KC_W,    KC_E,    KC_R,    \
     KC_A,    KC_S,    KC_D,             \
     KC_Z,    KC_X,    KC_C,             \
     KC_LSFT,          KC_LALT, KC_SPC   \
   ),
   [OSY] = LAYOUT(
-    KC_A,    KC_Q,    KC_1,    KC_FN2,  \
+    KC_A,    KC_Q,    KC_1,    TO(DEF), \
     KC_S,    KC_W,    KC_2,    KC_LALT, \
     KC_D,    KC_E,    KC_3,             \
     KC_F,    KC_R,    KC_4,             \
@@ -29,36 +29,36 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   )
 };
 
-
-const uint16_t PROGMEM fn_actions[] = {
-		[0] = ACTION_LAYER_SET(HDN, ON_PRESS),
-		[1] = ACTION_LAYER_SET(OSY, ON_PRESS),
-		[2] = ACTION_LAYER_SET(DEF, ON_PRESS),
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
   return MACRO_NONE;
 };
 
 
-bool process_record_user (uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch(keycode) {
-  case KC_FN0:
-    if (record->event.pressed) {
-      PORTC |= (1 << 6); // PC6 goes high
-    }
-    break;
-  case KC_FN1:
-    if (record->event.pressed) {
-      PORTC &= ~(1 << 6); // PC6 goes high
-      PORTD |= (1<<4);
-    }
-    break;
-  case KC_FN2:
-    if (record->event.pressed) {
-      PORTD &= ~(1 << 4); // PC6 goes high
-    }
-    break;
+    case TO(HDN):
+      if (record->event.pressed) {
+        PORTC |= (1 << 6); // PC6 goes high
+      }
+
+      return true;
+
+    case TO(OSY):
+      if (record->event.pressed) {
+        PORTC &= ~(1 << 6); // PC6 goes high
+        PORTD |= (1<<4);
+      }
+
+      return true;
+
+    case TO(DEF):
+      if (record->event.pressed) {
+        PORTD &= ~(1 << 4); // PC6 goes high
+      }
+
+      return true;
+
+    default:
+      return true;
   }
-  return true;
 }

keyboards/handwired/kbod/keymaps/default/keymap.c

@@ -2,6 +2,11 @@
 
 #define MODS_PRESSED(btn)  (get_mods() & (MOD_BIT(KC_L##btn)|MOD_BIT(KC_R##btn)))
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE,
+  ALT_F4
+};
+
 #define SET_WHETHER(mask, btn1, btn2) \
 if (record->event.pressed) {          \
     if (mask) {                       \
@@ -24,7 +29,7 @@ if (record->event.pressed) {          \
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   LAYOUT( /* Base */
-    F(0),    KC_1,    KC_2,    KC_3,    F(1),    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    SFT_ESC, KC_1,    KC_2,    KC_3,    ALT_F4,  KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,          KC_ENT,  \
     KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT, \
@@ -38,7 +43,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     _______, _______, _______,                            _______,                            _______, KC_LEFT, KC_DOWN, KC_RGHT  \
   ),
   LAYOUT( /* Keypad layer */
-    TO(0),   KC_1,    KC_2,    KC_3,    F(1),    KC_5,    KC_6,    KC_P7,   KC_P8,   KC_P9,   KC_P0,   KC_PMNS, KC_PPLS, KC_BSPC, \
+    TO(0),   KC_1,    KC_2,    KC_3,    ALT_F4,  KC_5,    KC_6,    KC_P7,   KC_P8,   KC_P9,   KC_P0,   KC_PMNS, KC_PPLS, KC_BSPC, \
     _______, _______, _______, _______, _______, _______, _______, KC_P4,   KC_P5,   KC_P6,   _______, _______, _______, _______, \
     _______, _______, _______, _______, _______, _______, _______, KC_P1,   KC_P2,   KC_P3,   _______, _______,          _______, \
     _______,          _______, _______, _______, _______, _______, _______, KC_P0,   KC_PDOT, KC_BTN1, KC_MS_U,          KC_BTN2, \
@@ -53,24 +58,20 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(0),
-  [1]  = ACTION_FUNCTION(1),
-};
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
+      SET_WHETHER(MODS_PRESSED(SHIFT), KC_ESC, KC_GRAVE);
+
+      return false;
+
+    case ALT_F4:
+      SET_WHETHER(MODS_PRESSED(ALT), KC_4, KC_F4);
 
+      return false;
 
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_mask;
-  static uint8_t alt_mask;
-  switch (id) {
-    case 0:
-      shift_esc_mask = MODS_PRESSED(SHIFT);
-      SET_WHETHER(shift_esc_mask, KC_ESC, KC_GRAVE);
-      break;
-    case 1:
-      alt_mask = MODS_PRESSED(ALT);
-      SET_WHETHER(alt_mask, KC_4, KC_F4);
-      break;
+    default:
+      return true;
   }
 }
 

keyboards/handwired/space_oddity/keymaps/default/keymap.c

@@ -38,8 +38,6 @@ enum {
 
 #include "dynamic_macro.h"
 
-#define MOUSE_LAYER 2
-
 // Tap dance actions - double tap for Caps Lock.
 qk_tap_dance_action_t tap_dance_actions[] = {
 

keyboards/handwired/terminus_mini/keymaps/default/keymap.c

@@ -53,17 +53,10 @@ enum custom_macros {
   R_POINT
 };
 
-  // Enable these functions using FUNC(n) macro.
-  const uint16_t PROGMEM fn_actions[] = { //ACTION_LAYER_TAP_TOGGLE requires that number of taps be defined in *config.h* - default set to 5
-      [0] = ACTION_LAYER_TAP_KEY(_LOWER, KC_SPC),    //Hold for momentary Lower layer, Tap for Space, 
-      [1] = ACTION_LAYER_TAP_KEY(_RAISE, KC_ENT),    //Hold for momentary Mouse layer, Tap for Enter,
-      [2] = ACTION_LAYER_MOMENTARY(_FUNCTION),       //Hold for momentary Function
-      [3] = ACTION_LAYER_MOMENTARY(_MOUSE)           //Hold for momentary MOUSE
-   };
-#define SPC_LW FUNC(0)
-#define ENT_RS FUNC(1)
-#define FNC FUNC(2)
-#define MSE FUNC(3)
+#define SPC_LW LT(_LOWER, KC_SPC)
+#define ENT_RS LT(_RAISE, KC_ENT)
+#define FNC MO(_FUNCTION)
+#define MSE MO(_MOUSE)
 #define PIPE M(R_PIPE)
 #define POINT M(R_POINT)
 

keyboards/handwired/traveller/keymaps/default/keymap.c

@@ -38,9 +38,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * 
  */
 [_QW] = KEYMAP( 
-  F(_NAV),          KC_GRV, KC_W,    KC_E,    KC_R,    KC_T,             KC_Y,    KC_U,    KC_I,    KC_O,    KC_MINS,  KC_EQL,
-  KC_TAB,           KC_Q,    KC_S,    KC_D,    KC_F,    KC_G,            KC_H,    KC_J,    KC_K,    KC_L,    KC_P, 	KC_BSLS,
-  CTL_T(KC_ESC),    KC_A,    KC_X,    KC_C,    KC_V,    KC_B,    KC_RCTL,  KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SCLN, 	KC_QUOT,
+  TG(_NAV),         KC_GRV, KC_W,    KC_E,    KC_R,    KC_T,             KC_Y,    KC_U,    KC_I,    KC_O,    KC_MINS,  KC_EQL,
+  KC_TAB,           KC_Q,    KC_S,    KC_D,    KC_F,    KC_G,            KC_H,    KC_J,    KC_K,    KC_L,    KC_P,  KC_BSLS,
+  CTL_T(KC_ESC),    KC_A,    KC_X,    KC_C,    KC_V,    KC_B,    KC_RCTL,  KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SCLN,   KC_QUOT,
   KC_LSFT, KC_Z,    KC_DEL, KC_LGUI, MO(_LW), KC_BSPC, KC_ENTER, KC_SPC,  MO(_HI), KC_RGUI, KC_RALT,    KC_SLSH,   KC_RSFT
  ),
 
@@ -59,7 +59,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  */
 
 [_LW] = KEYMAP( 
-  F(_FKEYS),   KC_1,     KC_2,      KC_3,     KC_4,    KC_5,             KC_6,    KC_7,       KC_8,      KC_9,    KC_0,  LCTL(LALT(KC_DEL)) ,
+  TG(_FKEYS),  KC_1,     KC_2,      KC_3,     KC_4,    KC_5,             KC_6,    KC_7,       KC_8,      KC_9,    KC_0,  LCTL(LALT(KC_DEL)) ,
   KC_TRNS,  KC_1,     KC_RBRC,   KC_LPRN,  KC_RPRN, KC_NO,               KC_ASTR, KC_LPRN,    KC_RPRN,    KC_LBRC,    KC_NO, KC_NO,
   KC_CAPS,   KC_LBRC,  KC_NO,     KC_LCBR,  KC_RCBR, KC_TILD,   KC_TRNS,  KC_HASH, KC_LCBR,    KC_RCBR,   KC_NO,    KC_RBRC,   KC_NO,
   KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,  KC_TRNS, KC_TRNS,  KC_TRNS,  KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_TRNS
@@ -81,11 +81,11 @@ Right hand nav keys work pretty well chorded with the Right hand Hi Key
  */
 
 [_HI] = KEYMAP( 
- F(_FKEYS), KC_EXLM,  KC_AT,   KC_HASH,  KC_DLR,   KC_PERC,           KC_CIRC,  KC_AMPR,    KC_ASTR,   KC_LPRN,  KC_RPRN,  KC_PLUS,
+ TG(_FKEYS),KC_EXLM,  KC_AT,   KC_HASH,  KC_DLR,   KC_PERC,           KC_CIRC,  KC_AMPR,    KC_ASTR,   KC_LPRN,  KC_RPRN,  KC_PLUS,
  KC_TRNS, KC_EXLM,  KC_AMPR, KC_PIPE,  KC_DLR,   KC_PERC,             KC_VOLU, KC_MUTE,    KC_NO,     KC_NO,    KC_NO,    KC_NO, 
  KC_CAPS, KC_CIRC,  KC_COLN,  KC_DOT,  KC_ASTR,  KC_MINS,   KC_TRNS,  KC_VOLD, KC_PPLS,    KC_PGUP,   KC_HOME,  KC_UP,    KC_END,
- KC_TRNS, KC_SLSH,  KC_TRNS,  KC_TRNS, F(_LW),   KC_TRNS,   KC_TRNS,  KC_TRNS, KC_TRNS,    KC_PGDN,   KC_LEFT,  KC_DOWN,  KC_RIGHT 
-),	
+ KC_TRNS, KC_SLSH,  KC_TRNS,  KC_TRNS, TT(_LW),  KC_TRNS,   KC_TRNS,  KC_TRNS, KC_TRNS,    KC_PGDN,   KC_LEFT,  KC_DOWN,  KC_RIGHT 
+),  
 
 /* NAV - mouse &  navigation
 //gui left and right are line home/end, or fore & back in browser
@@ -103,7 +103,7 @@ Right hand nav keys work pretty well chorded with the Right hand Hi Key
 */
 
 [_NAV] = KEYMAP( 
-  F(_NAV),  KC_NO,         KC_NO,    KC_UP,       KC_NO,     RGUI(KC_RIGHT),            KC_WH_U,  M(MUL), KC_MS_U,   M(MUR), KC_NO, KC_ACL2,
+  TG(_NAV), KC_NO,         KC_NO,    KC_UP,       KC_NO,     RGUI(KC_RIGHT),            KC_WH_U,  M(MUL), KC_MS_U,   M(MUR), KC_NO, KC_ACL2,
   KC_TRNS, RGUI(KC_LEFT),  KC_LEFT,  KC_DOWN,     KC_RIGHT,  LCTL(KC_E),                KC_BTN3,  KC_MS_L,  KC_MS_U,   KC_MS_R,  KC_NO, KC_ACL1,
   KC_TRNS, LCTL(KC_A),     LGUI(KC_X),RGUI(KC_C), RGUI(KC_V),KC_NO,         KC_ENTER,   KC_WH_D,  M(MDL), KC_MS_D,  M(MDR),  KC_UP, KC_ACL0,
   KC_TRNS, RGUI(KC_Z),     KC_TRNS,  KC_TRNS,     KC_TRNS,   KC_TRNS,       KC_BTN2,   KC_BTN1,  KC_TRNS,  KC_TRNS,   KC_LEFT,   KC_DOWN,   KC_RIGHT
@@ -123,10 +123,10 @@ Right hand nav keys work pretty well chorded with the Right hand Hi Key
  */ 
  
 [_FKEYS] = KEYMAP( 
-  F(_FKEYS), KC_F1,    KC_F2,  	KC_F3,      KC_F4,     KC_F5,               KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,    KC_RCTL,
-  KC_TRNS,   KC_NO,    KC_NO,   KC_NO,      KC_NO,     KC_NO,               KC_F11,   KC_F12,   KC_F13,    KC_F14,  KC_F15,  	 KC_LALT ,
-  F(_QW),   KC_NO,     KC_NO,   KC_NO,      KC_NO,     KC_NO,    KC_TRNS,   KC_NO,    KC_NO,    KC_NO,      KC_NO,   KC_NO,    KC_DEL,
-  KC_TRNS, F(RGBLED_TOGGLE),    KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS
+  TG(_FKEYS),KC_F1,    KC_F2,   KC_F3,      KC_F4,     KC_F5,               KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,    KC_RCTL,
+  KC_TRNS,   KC_NO,    KC_NO,   KC_NO,      KC_NO,     KC_NO,               KC_F11,   KC_F12,   KC_F13,    KC_F14,  KC_F15,    KC_LALT ,
+  TO(_QW),  KC_NO,     KC_NO,   KC_NO,      KC_NO,     KC_NO,    KC_TRNS,   KC_NO,    KC_NO,    KC_NO,      KC_NO,   KC_NO,    KC_DEL,
+  KC_TRNS, RGB_TOG,             KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS
 ),
 
 
@@ -145,26 +145,14 @@ Right hand nav keys work pretty well chorded with the Right hand Hi Key
 
 [_TRNS] = {
   {KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_NO,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS},
-  {KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_NO,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS, 	KC_TRNS},
-  {KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS, 	KC_TRNS},
+  {KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_NO,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS},
+  {KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS},
   {KC_TRNS, KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,   KC_TRNS}
  }
 
 
 };
 
-
-const uint16_t PROGMEM fn_actions[] = {
-    [_QW] = ACTION_LAYER_ON(_QW,ON_RELEASE), // return to QWERTY  layer
-    [_LW] = ACTION_LAYER_TAP_TOGGLE(_LW), // Turn on LW when holding, or tap 3 times to switch
-    [_NAV] = ACTION_LAYER_TOGGLE(_NAV),                                   
-    [_FKEYS] = ACTION_LAYER_TOGGLE(_FKEYS),  
-    
-    // Functions
-  [RGBLED_TOGGLE]  = ACTION_FUNCTION(RGBLED_TOGGLE),
- 
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function
@@ -230,21 +218,6 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     return MACRO_NONE;
 };
 
-
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  switch (id) {
-    case RGBLED_TOGGLE:
-      //led operations
-      if (record->event.pressed) {
-        rgblight_toggle();
-      }
-        break;
-  }
-}
-
- 
-
 void LayerLEDSet(uint8_t layr) {
 
     switch (layr) {

keyboards/kona_classic/keymaps/ansi/keymap.c

@@ -15,9 +15,13 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 // Helpful defines
 #define _______ KC_TRNS
 #define XXXXXXX KC_NO
@@ -29,7 +33,7 @@
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_ansi(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,           \
     KC_F7,   KC_F8,   KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,          \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/ansi_arrows/keymap.c

@@ -15,9 +15,13 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 // Helpful defines
 #define _______ KC_TRNS
 #define XXXXXXX KC_NO
@@ -29,7 +33,7 @@
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_ansi_arrows(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,           \
     KC_F7,   KC_F8,   KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   MO(_FN), \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/ansi_arrows_lcap/keymap.c

@@ -15,9 +15,13 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 // Helpful defines
 #define _______ KC_TRNS
 #define XXXXXXX KC_NO
@@ -29,7 +33,7 @@
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_ansi_arrows(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_F5,   KC_F6,   KC_LCAP, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,           \
     KC_F7,   KC_F8,   KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   MO(_FN), \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/ansi_split/keymap.c

@@ -15,7 +15,7 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
 // Helpful defines
@@ -25,11 +25,15 @@
 #define _DEFAULT 0
 #define _FN 1
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 //RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_ansi_split(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,           \
     KC_F7,   KC_F8,   KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,          \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/ansi_split_arrows/keymap.c

@@ -15,7 +15,7 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
 // Helpful defines
@@ -25,11 +25,15 @@
 #define _DEFAULT 0
 #define _FN 1
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 //RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_ansi_split_arrows(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,           \
     KC_F7,   KC_F8,   KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   MO(_FN), \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/default/keymap.c

@@ -15,9 +15,13 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 // Helpful defines
 #define _______ KC_TRNS
 #define XXXXXXX KC_NO
@@ -29,7 +33,7 @@
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_all(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,     KC_3,   KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,     KC_3,   KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,     KC_E,   KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_F5,   KC_F6,   MO(_FN), KC_A,    KC_S,     KC_D,   KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,           \
     KC_F7,   KC_F8,   KC_LSFT, _______, KC_Z,     KC_X,   KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   MO(_FN), \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/iso/keymap.c

@@ -15,7 +15,7 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
 // Helpful defines
@@ -25,11 +25,15 @@
 #define _DEFAULT 0
 #define _FN 1
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 //RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_iso(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_ENT,  \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_NUHS,          \
     KC_F7,   KC_F8,   KC_LSFT, KC_NUBS, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,          \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/iso_arrows/keymap.c

@@ -15,7 +15,7 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
 // Helpful defines
@@ -25,11 +25,15 @@
 #define _DEFAULT 0
 #define _FN 1
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 //RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_iso_arrows(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_ENT,  \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_NUHS,          \
     KC_F7,   KC_F8,   KC_LSFT, KC_NUBS, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   MO(_FN), \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/iso_split/keymap.c

@@ -15,7 +15,7 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
 // Helpful defines
@@ -25,11 +25,15 @@
 #define _DEFAULT 0
 #define _FN 1
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 //RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_iso_split(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_ENT,  \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_NUHS,          \
     KC_F7,   KC_F8,   KC_LSFT, KC_NUBS, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,          \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/kona_classic/keymaps/iso_split_arrows/keymap.c

@@ -15,7 +15,7 @@
  */
 #include QMK_KEYBOARD_H
 
-#define MODS_SHFT_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
+#define MODS_SHIFT_GUI_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 #define MODS_GUI_MASK   (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
 
 // Helpful defines
@@ -25,11 +25,15 @@
 #define _DEFAULT 0
 #define _FN 1
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 //RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [_DEFAULT] = LAYOUT_iso_split_arrows(
-    KC_F1,   KC_F2,   F(0),    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    KC_F1,   KC_F2,   SFT_ESC, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_F3,   KC_F4,   KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_ENT,  \
     KC_F5,   KC_F6,   KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_NUHS,          \
     KC_F7,   KC_F8,   KC_LSFT, KC_NUBS, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   MO(_FN), \
@@ -55,29 +59,15 @@ void matrix_scan_user(void) {
 
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-    return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    ESCAPE,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(ESCAPE),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case ESCAPE:
-      shift_esc_shift_mask = get_mods()&MODS_SHFT_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -85,7 +75,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_GUI_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -93,6 +83,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/mechmini/v2/keymaps/default/keymap.c

@@ -4,11 +4,15 @@
 #define _FN1 1
 #define _FN2 2
 
-#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+enum custom_keycodes {
+	SFT_ESC
+};
+
+#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 	[_BL] = LAYOUT_split_space(
-		F(0), KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
+		SFT_ESC,KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
 		KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_ENT,
 		KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_RSFT, KC_DOT,
 		KC_LCTL, KC_LALT, KC_LGUI, KC_SPC, KC_SPC, KC_RCTL, MO(1), MO(2)),
@@ -42,10 +46,6 @@ void matrix_init_user(void) {
 void matrix_scan_user(void) {
 }
 
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-	return true;
-}
-
 void led_set_user(uint8_t usb_led) {
 
 	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
@@ -80,21 +80,11 @@ void led_set_user(uint8_t usb_led) {
 
 }
 
-enum function_id {
-    SHIFT_ESC,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(SHIFT_ESC),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case SHIFT_ESC:
-      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -102,7 +92,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -110,6 +100,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/org60/keymaps/default/keymap.c

@@ -9,7 +9,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,    KC_P,    KC_LBRC,  KC_RBRC,           KC_BSLS,   \
       KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_NO,  KC_RSFT  ,KC_UP,    KC_DEL,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, F(0),     KC_LEFT, KC_DOWN,  KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, MO(1),    KC_LEFT, KC_DOWN,  KC_RIGHT),
 
   // 1: Function Layer
   LAYOUT(
@@ -17,15 +17,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   KC_WH_U, KC_UP,   KC_WH_D, KC_BSPC,KC_HOME,KC_CALC,KC_NO,  KC_INS, KC_NO,   KC_PSCR, KC_SLCK,  KC_PAUS,           KC_DEL,    \
       KC_NO,   KC_LEFT, KC_DOWN, KC_RIGHT,KC_DEL, KC_END, KC_PGDN,KC_NO,  KC_NO,  KC_NO,   KC_HOME, KC_PGUP,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_NO,   KC_APP,  BL_STEP,KC_NO,  KC_NO,  KC_VOLD,KC_VOLU,KC_MUTE, KC_END,  KC_RSFT,  KC_NO  ,KC_PGUP,  KC_INS,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, F(0),     KC_HOME, KC_PGDOWN,KC_END),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, MO(1),    KC_HOME, KC_PGDOWN,KC_END),
 
 };
 
-// Custom Actions
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-};
-
 // Macros
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 
@@ -43,4 +38,4 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 // Loop
 void matrix_scan_user(void) {
   // Empty
-};
+};

keyboards/satan/keymaps/colemak/keymap.c

@@ -3,7 +3,7 @@
 
 
 // Used for SHIFT_ESC
-#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
 
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
@@ -14,6 +14,10 @@
 
 #define _______ KC_TRNS
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   /* Keymap _BL: (Base Layer) Default Layer
    * ,-----------------------------------------------------------.
@@ -29,7 +33,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    * `-----------------------------------------------------------'
    */
 [_BL] = LAYOUT_60_ansi(
-  F(0),    KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,   KC_0,   KC_MINS, KC_EQL, KC_BSPC, \
+  SFT_ESC, KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,   KC_0,   KC_MINS, KC_EQL, KC_BSPC, \
   KC_TAB,  KC_Q,   KC_W,   KC_F,   KC_P,   KC_G,   KC_J,   KC_L,   KC_U,   KC_Y,   KC_SCLN,   KC_LBRC, KC_RBRC,KC_BSLS, \
   KC_BSPC, KC_A,   KC_R,   KC_S,   KC_T,   KC_D,   KC_H,   KC_N,   KC_E,   KC_I,   KC_O,KC_QUOT,         KC_ENT,  \
   KC_LSFT,         KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_K,   KC_M,   KC_COMM,KC_DOT, KC_SLSH,         KC_RSFT, \
@@ -40,7 +44,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    * |   |   |   |   |   |   |   |   |   |   |   |   |   |  RESET|
    * |-----------------------------------------------------------|
    * |     |   |   |   |   |   |   |   |   |   |   |BL-|BL+|BL   |
-   * |--------------------------------------------ΩΩ---------------|
+   * |-----------------------------------------------------------|
    * |      |   |   |   |   |   |   |       |   |   |   |        |
    * |-----------------------------------------------------------|
    * |        | F1|F2 | F3|F4 | F5| F6| F7| F8|   |   |          |
@@ -64,21 +68,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   #endif
 };
 
-enum function_id {
-    SHIFT_ESC,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(SHIFT_ESC),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case SHIFT_ESC:
-      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -86,7 +80,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -94,6 +88,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/satan/keymaps/default/keymap.c

@@ -1,9 +1,11 @@
 #include QMK_KEYBOARD_H
 
-
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
 
 // Used for SHIFT_ESC
-#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
 
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
@@ -29,7 +31,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    * `-----------------------------------------------------------'
    */
 [_BL] = LAYOUT_60_ansi(
-  F(0),    KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,   KC_0,   KC_MINS, KC_EQL, KC_BSPC, \
+  SFT_ESC, KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,   KC_0,   KC_MINS, KC_EQL, KC_BSPC, \
   KC_TAB,  KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,   KC_P,   KC_LBRC, KC_RBRC,KC_BSLS, \
   KC_CAPS, KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,   KC_SCLN,KC_QUOT,         KC_ENT,  \
   KC_LSFT,         KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM,KC_DOT, KC_SLSH,         KC_RSFT, \
@@ -64,21 +66,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   #endif
 };
 
-enum function_id {
-    SHIFT_ESC,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(SHIFT_ESC),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case SHIFT_ESC:
-      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -86,7 +78,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -94,6 +86,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/satan/keymaps/iso_split_rshift/keymap.c

@@ -113,36 +113,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     [_SFX] = LAYOUT_60_iso_split_rshift(
         RESET,   _______, _______, _______, _______, _______, _______, KC_7,    KC_8,    KC_9, _______, _______, _______, KC_BSPC, \
         _______, _______, _______, _______, _______, _______, _______, KC_4,    KC_5,    KC_6, _______, _______, _______, \
-        _______, F(2),    F(3),    _______, _______, _______, _______, KC_1,    KC_2,    KC_3, _______, _______, XXXXXXX, KC_ENT,  \
-        _______, F(4),    F(5),    F(6),    F(7),    F(8),    F(9),    _______, _______, KC_0, _______, KC_SLSH, KC_UP,   _______, \
+        _______, RGB_TOG, RGB_MOD, _______, _______, _______, _______, KC_1,    KC_2,    KC_3, _______, _______, XXXXXXX, KC_ENT,  \
+        _______, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, _______, _______, KC_0, _______, KC_SLSH, KC_UP,   _______, \
         _______, _______, _______,                            _______,                         _______, KC_LEFT, KC_DOWN, KC_RGHT),
 };
 
-enum function_id {
-    LAUNCH,
-    RGBLED_TOGGLE,
-    RGBLED_STEP_MODE,
-    RGBLED_INCREASE_HUE,
-    RGBLED_DECREASE_HUE,
-    RGBLED_INCREASE_SAT,
-    RGBLED_DECREASE_SAT,
-    RGBLED_INCREASE_VAL,
-    RGBLED_DECREASE_VAL,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-    [1]  = ACTION_FUNCTION(LAUNCH),
-    [2]  = ACTION_FUNCTION(RGBLED_TOGGLE),
-    [3]  = ACTION_FUNCTION(RGBLED_STEP_MODE),
-    [4]  = ACTION_FUNCTION(RGBLED_INCREASE_HUE),
-    [5]  = ACTION_FUNCTION(RGBLED_DECREASE_HUE),
-    [6]  = ACTION_FUNCTION(RGBLED_INCREASE_SAT),
-    [7]  = ACTION_FUNCTION(RGBLED_DECREASE_SAT),
-    [8]  = ACTION_FUNCTION(RGBLED_INCREASE_VAL),
-    [9]  = ACTION_FUNCTION(RGBLED_DECREASE_VAL),
-    [10] = ACTION_MODS_TAP_KEY(MOD_LCTL, KC_ENT),
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
     // MACRODOWN only works in this function
@@ -160,49 +135,3 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     }
     return MACRO_NONE;
 };
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-    switch (id) {
-        case RGBLED_TOGGLE:
-            //led operations
-            if (record->event.pressed) {
-                rgblight_toggle();
-            }
-            break;
-        case RGBLED_INCREASE_HUE:
-            if (record->event.pressed) {
-                rgblight_increase_hue();
-            }
-            break;
-        case RGBLED_DECREASE_HUE:
-            if (record->event.pressed) {
-                rgblight_decrease_hue();
-            }
-            break;
-        case RGBLED_INCREASE_SAT:
-            if (record->event.pressed) {
-                rgblight_increase_sat();
-            }
-            break;
-        case RGBLED_DECREASE_SAT:
-            if (record->event.pressed) {
-                rgblight_decrease_sat();
-            }
-            break;
-        case RGBLED_INCREASE_VAL:
-            if (record->event.pressed) {
-                rgblight_increase_val();
-            }
-            break;
-        case RGBLED_DECREASE_VAL:
-            if (record->event.pressed) {
-                rgblight_decrease_val();
-            }
-            break;
-        case RGBLED_STEP_MODE:
-            if (record->event.pressed) {
-                rgblight_step();
-            }
-            break;
-    }
-}

keyboards/satan/keymaps/poker/keymap.c

@@ -2,7 +2,7 @@
 
 
 // Used for SHIFT_ESC
-#define MODS_CTRL_MASK  (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
+#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
 
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
@@ -16,6 +16,10 @@
 #define _______ KC_TRNS
 #define XXXXXXX KC_NO
 
+enum custom_keycodes {
+  SFT_ESC = SAFE_RANGE
+};
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   /* Keymap _BL: (Base Layer) Default Layer
    * ,-----------------------------------------------------------.
@@ -31,7 +35,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    * `-----------------------------------------------------------'
    */
   [_BL] = LAYOUT_60_ansi(
-    F(0),    KC_1,    KC_2,    KC_3,   KC_4,    KC_5,    KC_6,    KC_7,     KC_8,    KC_9,   KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
+    SFT_ESC, KC_1,    KC_2,    KC_3,   KC_4,    KC_5,    KC_6,    KC_7,     KC_8,    KC_9,   KC_0,    KC_MINS, KC_EQL,  KC_BSPC, \
     KC_TAB,  KC_Q,    KC_W,    KC_E,   KC_R,    KC_T,    KC_Y,    KC_U,     KC_I,    KC_O,   KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_CAPS, KC_A,    KC_S,    KC_D,   KC_F,    KC_G,    KC_H,    KC_J,     KC_K,    KC_L,   KC_SCLN, KC_QUOT,          KC_ENT,  \
     KC_LSFT, KC_Z,    KC_X,    KC_C,   KC_V,    KC_B,    KC_N,    KC_M,     KC_COMM, KC_DOT, KC_SLSH,                   KC_RSFT, \
@@ -89,21 +93,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ),
 };
 
-enum function_id {
-    SHIFT_ESC,
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0]  = ACTION_FUNCTION(SHIFT_ESC),
-};
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
-  static uint8_t shift_esc_shift_mask;
-  switch (id) {
-    case SHIFT_ESC:
-      shift_esc_shift_mask = get_mods()&MODS_CTRL_MASK;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case SFT_ESC:
       if (record->event.pressed) {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           add_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -111,7 +105,7 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       } else {
-        if (shift_esc_shift_mask) {
+        if (get_mods() & MODS_SHIFT_MASK) {
           del_key(KC_GRV);
           send_keyboard_report();
         } else {
@@ -119,6 +113,10 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
           send_keyboard_report();
         }
       }
-      break;
+
+      return false;
+
+    default:
+      return true;
   }
 }

keyboards/sentraq/s60_x/keymaps/default/keymap.c

@@ -16,7 +16,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    * ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
    * │LSHFT│▒▒▒▒▒│  Z  │  X  │  C  │  V  │  B  │  N  │  M  │  ,  │  .  │  /  │▒▒▒▒▒│RSHFT│▒▒▒▒▒│
    * ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
-   * │LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ FN0 │ APP │RCTRL│█████│
+   * │LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ MO1 │ APP │RCTRL│█████│
    * └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
    */
   /* 0: ANSI qwerty */
@@ -25,7 +25,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,          KC_ENT,  \
     KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT, \
-    KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                             KC_RALT, KC_FN0,  KC_APP,  KC_RCTL  \
+    KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                             KC_RALT, MO(1),   KC_APP,  KC_RCTL  \
   ),
 
   /* 1: Fn layer
@@ -49,7 +49,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     _______, _______, _______,                            _______,                            _______, _______, _______, _______  \
   ),
 };
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-};

keyboards/sentraq/s60_x/keymaps/default_rgb/keymap.c

@@ -16,7 +16,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    * ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
    * │LSHFT│▒▒▒▒▒│  Z  │  X  │  C  │  V  │  B  │  N  │  M  │  ,  │  .  │  /  │▒▒▒▒▒│RSHFT│▒▒▒▒▒│
    * ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
-   * │LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ FN0 │ APP │RCTRL│█████│
+   * │LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ MO1 │ APP │RCTRL│█████│
    * └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
    */
   /* 0: ANSI qwerty */
@@ -25,7 +25,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS, \
     KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,          KC_ENT,  \
     KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT, \
-    KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                             KC_RALT, KC_FN0,  KC_APP,  KC_RCTL  \
+    KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                             KC_RALT, MO(1),   KC_APP,  KC_RCTL  \
   ),
 
   /* 1: Fn layer
@@ -51,7 +51,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     _______, _______, _______,                            _______,                            _______, _______, _______, _______  \
   ),
 };
-
-const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-};

keyboards/sentraq/s60_x/keymaps/iso/keymap.c

@@ -10,7 +10,7 @@
 ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
 │LSHFT│  \  │  Z  │  X  │  C  │  V  │  B  │  N  │  M  │  ,  │  .  │  /  │▒▒▒▒▒│RSHFT│▒▒▒▒▒│
 ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
-│LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ FN0 │ APP │RCTRL│█████│
+│LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ MO1 │ APP │RCTRL│█████│
 └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
 */
 
@@ -20,7 +20,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
            TAB,    Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P, LBRC, RBRC,   NO,       \
           CAPS,    A,    S,    D,    F,    G,    H,    J,    K,    L, SCLN, QUOT, NUHS, ENT ,       \
           LSFT, BSLS,    Z,    X,    C,    V,    B,    N,    M, COMM,  DOT, SLSH,   NO, RSFT,   NO, \
-          LCTL, LGUI, LALT,                    SPC,                   RALT,  FN0,  APP, RCTL),
+          LCTL, LGUI, LALT,                    SPC,                   RALT,  MO(1),APP, RCTL),
 
 /* 1: Fn layer
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
@@ -42,7 +42,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, \
         TRNS, TRNS, TRNS,                   TRNS,                   TRNS, TRNS, TRNS, TRNS),
 };
-
-const uint16_t PROGMEM fn_actions[] = {
-	[0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-};

keyboards/sentraq/s60_x/keymaps/iso_rgb/keymap.c

@@ -10,7 +10,7 @@
 ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
 │LSHFT│  \  │  Z  │  X  │  C  │  V  │  B  │  N  │  M  │  ,  │  .  │  /  │▒▒▒▒▒│RSHFT│▒▒▒▒▒│
 ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
-│LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ FN0 │ APP │RCTRL│█████│
+│LCTRL│L_GUI│L_ALT│█████│█████│█████│ SPC │█████│█████│█████│R_ALT│ MO1 │ APP │RCTRL│█████│
 └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
 */
 
@@ -20,7 +20,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
            KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_NO,       \
            KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_NUHS, KC_ENT ,       \
            KC_LSFT, KC_NUBS, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT, KC_NO, \
-           KC_LCTL, KC_LGUI, KC_LALT,                   KC_SPC,                    KC_RALT, KC_FN0,  KC_APP,  KC_RCTL),
+           KC_LCTL, KC_LGUI, KC_LALT,                   KC_SPC,                    KC_RALT, MO(1),   KC_APP,  KC_RCTL),
 
 /* 1: Fn layer
 UG = Underglow = RGB Backlighting
@@ -44,7 +44,3 @@ BL = Backlighting = In-Switch LED
         KC_TRNS, KC_TRNS, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, KC_TRNS, BL_DEC,  BL_TOGG, BL_INC,           KC_TRNS, KC_TRNS, \
         KC_TRNS, KC_TRNS, KC_TRNS,                   KC_TRNS,                   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
 };
-
-const uint16_t PROGMEM fn_actions[] = {
-	[0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-};

keyboards/vision_division/keymaps/default/keymap.c

@@ -121,7 +121,7 @@ enum keyboard_macros {
 
 #define M_CP_CT             M(MACRO_COPY_CUT)
 
-#define M_COPY              KC_FN1
+#define M_COPY              MACROTAP(MACRO_COPY_CUT)
 
 #define SC_UNDO             LCTL(KC_Z)
 #define SC_REDO             LCTL(KC_Y)
@@ -135,7 +135,7 @@ enum keyboard_macros {
 #define SC_CCLS             LCTL(KC_F4)
 
 #define TG_NKRO             MAGIC_TOGGLE_NKRO
-#define OS_SHFT             KC_FN0
+#define OS_SHFT             OSM(MOD_LSFT)
 
 #define _______             KC_TRNS
 #define XXXXXXX             KC_NO
@@ -305,11 +305,6 @@ void persistent_default_layer_set(uint16_t default_layer)
   default_layer_set(default_layer);
 }
 
-const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_MODS_ONESHOT(MOD_LSFT),
-  [1] = ACTION_MACRO_TAP(MACRO_COPY_CUT),
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
 
@@ -619,4 +614,4 @@ void music_scale_user(void)
   PLAY_SONG(music_scale);
 }
 
-#endif /* AUDIO_ENABLE */
+#endif /* AUDIO_ENABLE */

keyboards/whitefox/keymaps/default/keymap.c

@@ -35,7 +35,7 @@ const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_TAB, KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,   KC_P,   KC_LBRC,KC_RBRC,KC_BSPC,     KC_DEL, \
         KC_CAPS,KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,   KC_SCLN,KC_QUOT,KC_NUHS,KC_ENT,      KC_PGUP,\
         KC_LSFT,KC_NUBS,KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM,KC_DOT, KC_SLSH,KC_RSFT,     KC_UP,  KC_PGDN,\
-        KC_LCTL,KC_LGUI,KC_LALT,               KC_SPC,           KC_RALT,KC_FN0, KC_RCTL,     KC_LEFT,KC_DOWN,KC_RGHT \
+        KC_LCTL,KC_LGUI,KC_LALT,               KC_SPC,           KC_RALT,MO(1),  KC_RCTL,     KC_LEFT,KC_DOWN,KC_RGHT \
     ),
     [1] = LAYOUT( \
         KC_TRNS,KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10, KC_F11, KC_F12, KC_TRNS,KC_TRNS,KC_MUTE,\
@@ -45,7 +45,3 @@ const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_TRNS,KC_TRNS,KC_TRNS,               KC_TRNS,          KC_TRNS,KC_TRNS,KC_TRNS,     KC_HOME,KC_PGDN,KC_END  \
     ),
 };
-
-const uint16_t fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),
-};

keyboards/xd60/keymaps/default/keymap.c

@@ -9,7 +9,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,    KC_P,    KC_LBRC,  KC_RBRC,           KC_BSLS,   \
       KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_SLSH,  KC_RSFT, KC_UP,    KC_DEL,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, F(0),     KC_LEFT, KC_DOWN,  KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, MO(1),    KC_LEFT, KC_DOWN,  KC_RIGHT),
 
   // 1: Function Layer
   LAYOUT_all(
@@ -17,15 +17,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   KC_WH_U, KC_UP,   KC_WH_D, KC_BSPC,KC_HOME,KC_CALC,KC_NO,  KC_INS, KC_NO,   KC_PSCR, KC_SLCK,  KC_PAUS,           KC_DEL,    \
       KC_NO,   KC_LEFT, KC_DOWN, KC_RIGHT,KC_DEL, KC_END, KC_PGDN,KC_NO,  KC_NO,  KC_NO,   KC_HOME, KC_PGUP,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_NO,   KC_APP,  BL_STEP,KC_NO,  KC_NO,  KC_VOLD,KC_VOLU,KC_MUTE, KC_END,  KC_PGDN,  KC_RSFT, KC_PGUP,  KC_INS,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, F(0),     KC_HOME, KC_PGDOWN,KC_END),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, MO(1),    KC_HOME, KC_PGDOWN,KC_END),
 
 };
 
-// Custom Actions
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-};
-
 // Macros
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 

keyboards/xd60/keymaps/iso/keymap.c

@@ -12,7 +12,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,    KC_P,    KC_LBRC,  KC_RBRC,           KC_NO,   \
       KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_NUHS,           KC_ENT,  \
       KC_LSFT,   KC_BSLS,   KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_SLSH,  KC_RSFT, KC_UP,KC_DEL,  \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, F(0),     KC_LEFT, KC_DOWN,  KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, MO(1),    KC_LEFT, KC_DOWN,  KC_RIGHT),
 
   // 1: Function Layer
   [_FL] = LAYOUT_all(
@@ -20,15 +20,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   KC_VOLD, KC_MUTE, KC_VOLU, KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   BL_TOGG, BL_DEC,   BL_INC,           KC_NO,  \
       KC_NO,   KC_MPLY, KC_MSTP, KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,              KC_ENT, \
       KC_LSFT, RGB_TOG, RGB_MOD, KC_CUT,  KC_COPY,KC_PASTE,RGB_HUI,RGB_HUD,RGB_SAI,RGB_SAD,RGB_VAI,RGB_VAD, KC_HOME, KC_PGUP,   KC_END, \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, F(0),   KC_NO,   KC_PGDOWN, KC_NO),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RGUI, MO(1),  KC_NO,   KC_PGDOWN, KC_NO),
 
 };
 
-// Custom Actions
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-};
-
 // Macros
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {