Migrate ACTION_LAYER_MOMENTARYs to MO() (#5176)

* Migrate ACTION_LAYER_MOMENTARYs to MO()

* Add changelog entry

* Update docs/ChangeLog/20190830/PR5176.md

Co-Authored-By: skullydazed <skullydazed@users.noreply.github.com>

docs/ChangeLog/20190830/PR5176.md

@@ -0,0 +1,4 @@
+* Migrating `ACTION_LAYER_MOMENTARY()` entries in `fn_actions` to `MO()` keycodes
+    * `fn_actions` is deprecated, and its functionality has been superseded by direct keycodes and `process_record_user()`
+    * The end result of removing this obsolete feature should result in a decent reduction in firmware size and code complexity
+    * All keymaps affected are recommended to switch away from `fn_actions` in favour of the [custom keycode](https://docs.qmk.fm/#/custom_quantum_functions) and [macro](https://docs.qmk.fm/#/feature_macros) features

keyboards/atomic/keymaps/abienz.c

@@ -6,22 +6,17 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_TAB,  CM_Q,    CM_W,    CM_F,    CM_P,    CM_G,    CM_J,    CM_L,    CM_U,    CM_Y,    CM_SCLN, KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL ,
     KC_BSPC, CM_A,    CM_R,    CM_S,    CM_T,    CM_D,    CM_H,    CM_N,    CM_E,    CM_I,    CM_O,    KC_QUOT, KC_ENT,  KC_NO,   KC_PGUP,
     KC_LSFT, CM_Z,    CM_X,    CM_C,    CM_V,    CM_B,    CM_K,    CM_M,    CM_COMM, CM_DOT,  CM_SLSH, KC_RSFT, KC_NO,   KC_UP,   KC_PGDN,
-    KC_LCTL, KC_LGUI, KC_NO,   KC_LALT, FUNC(1), KC_SPC,  KC_NO,   KC_RALT, FUNC(2), KC_RGUI, KC_NO,   KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT,
+    KC_LCTL, KC_LGUI, KC_NO,   KC_LALT, MO(1),   KC_SPC,  KC_NO,   KC_RALT, MO(1),   KC_RGUI, KC_NO,   KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT,
   ),
   [1] = LAYOUT_grid( /* function */
     KC_GRV,  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_BSPC, 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_SLEP, 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_CALC, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_VOLU, KC_MPLY,
-    KC_TRNS, KC_TRNS, KC_NO,   KC_TRNS, FUNC(1), KC_TRNS, KC_NO,   KC_TRNS, FUNC(2), KC_TRNS, KC_NO,   KC_TRNS, KC_MPRV, KC_VOLD, KC_MNXT,
+    KC_TRNS, KC_TRNS, KC_NO,   KC_TRNS, MO(1),   KC_TRNS, KC_NO,   KC_TRNS, MO(1),   KC_TRNS, KC_NO,   KC_TRNS, KC_MPRV, KC_VOLD, KC_MNXT,
   ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-  [1] = ACTION_LAYER_MOMENTARY(1),
-  [2] = ACTION_LAYER_MOMENTARY(1),
-};
-
 const macro_t * action_get_macro(keyrecord_t * record, uint8_t id, uint8_t opt) {
   // MACRODOWN only works in this function
   switch (id) {

keyboards/atomic/keymaps/twolayer.c

@@ -45,11 +45,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-  [1] = ACTION_LAYER_MOMENTARY(1),
-  [2] = ACTION_LAYER_MOMENTARY(1),
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
   // MACRODOWN only works in this function
   switch(id) {

keyboards/atreus/keymaps/erlandsona/keymap.c

@@ -16,7 +16,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_Q       , KC_W   , KC_E   , KC_R   ,  KC_T   ,                 KC_Y  ,  KC_U   , KC_I   , KC_O   , KC_P          ,
     KC_A       , KC_S   , KC_D   , KC_F   ,  KC_G   ,                 KC_H  ,  KC_J   , KC_K   , KC_L   , KC_SCLN       ,
     SFT_T(KC_Z), KC_X   , KC_C   , KC_V   ,  KC_B   ,                 KC_N  ,  KC_M   , KC_COMM, KC_DOT , SFT_T(KC_QUOT),
-    KC_LCTL    , KC_LALT, KC_LALT, KC_LGUI,  KC_BSPC, KC_ESC, KC_ENT, KC_SPC,  F(NUMS), KC_RALT, KC_SLSH, KC_BSLS
+    KC_LCTL    , KC_LALT, KC_LALT, KC_LGUI,  KC_BSPC, KC_ESC, KC_ENT, KC_SPC,  MO(NUMS),KC_RALT, KC_SLSH, KC_BSLS
   ),
 
   [NUMS] = LAYOUT( /* Numbers / Arrows / Symbols */
@@ -39,7 +39,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 // so that I can get out of mouse mode just by tapping/holding my base layer FN key.
 const uint16_t PROGMEM fn_actions[] = {
   [BASE] = ACTION_LAYER_OFF(2, 1),  // switch back to layer 0
-  [NUMS] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
   [MOUS] = ACTION_LAYER_ON(2, 1)  // switch to layer 2
 };
 

keyboards/atreus62/keymaps/atreus52/keymap.c

@@ -8,13 +8,16 @@
 #define BDO 4
 #define RESETL 5
 
+#define KC_RAIS MO(RAISE)
+#define KC_LOWR MO(LOWER)
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   [DVORAK] = LAYOUT_kc(
     NO, 1,    2,    3,    4,    5,                6,    7,    8,    9,    0,    NO, \
     NO, QUOT, COMM, DOT,  P,    Y,                F,    G,    C,    R,    L,    NO, \
     NO, A,    O,    E,    U,    I,                D,    H,    T,    N,    S,    NO, \
     NO, SCLN, Q,    J,    K,    X,                B,    M,    W,    V,    Z,    NO, \
-    NO, FN2,  LALT, LCTL, FN1,  LSFT, BSPC, ENT,  SPC,  FN0,  LGUI, LEFT, RGHT, NO
+    NO, FN2,  LALT, LCTL, LOWR, LSFT, BSPC, ENT,  SPC,  RAIS, LGUI, LEFT, RGHT, NO
   ),
 
   [QWERTY] = LAYOUT_kc(
@@ -22,7 +25,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     NO, Q,    W,    E,    R,    T,                Y,    U,    I,    O,    P,    NO, \
     NO, A,    S,    D,    F,    G,                H,    J,    K,    L,    SCLN, NO, \
     NO, Z,    X,    C,    V,    B,                N,    M,    COMM, DOT,  SLSH, NO, \
-    NO, FN2,  LALT, LCTL, FN1,  LSFT, BSPC, ENT,  SPC,  FN0,  LGUI, LEFT, RGHT, NO
+    NO, FN2,  LALT, LCTL, LOWR, LSFT, BSPC, ENT,  SPC,  RAIS, LGUI, LEFT, RGHT, NO
   ),
 
   [RAISE] = LAYOUT_kc(
@@ -59,8 +62,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_LAYER_MOMENTARY(RAISE), // Raise layer
-  [1] = ACTION_LAYER_MOMENTARY(LOWER), // Lower layer
   [2] = ACTION_LAYER_TOGGLE(BDO), // BDO layer
   [3] = ACTION_LAYER_TOGGLE(RESETL) // RESET layer
 };

keyboards/bpiphany/frosty_flake/keymaps/QFR_JM/keymap.c

@@ -23,12 +23,10 @@ enum custom_macros {
 
   const uint16_t PROGMEM fn_actions[] = {
       [0] = ACTION_LAYER_TAP_KEY(_LOWER, KC_SPC),    //Hold for momentary Lower layer, Tap for Space,
-      [1] = ACTION_LAYER_MOMENTARY(_MOUSE)           //Hold for momentary MOUSE
-
    };
 
 #define SPC_LW FUNC(0)
-#define MSE FUNC(1)
+#define MSE MO(_MOUSE)
 #define PIPE M(R_PIPE)
 #define POINT M(R_POINT)
 

keyboards/bpiphany/pegasushoof/keymaps/blowrak/keymap.c

@@ -48,7 +48,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 		KC_TAB,  SE_AO,  SE_AE,  SE_OE,  KC_P,   KC_Y,   KC_F,   KC_G,   KC_C,   KC_R,   KC_L,   KC_COMM,SE_CIRC,SE_QUOT,   KC_DEL, KC_END, KC_PGDN, \
 		KC_LCTRL,KC_A,   KC_O,   KC_E,   KC_U,   KC_I,   KC_H,   KC_D,   KC_T,   KC_N,   KC_S,   SE_MINS,        KC_ENT,                             \
 		KC_LSFT, SE_LTGT,KC_DOT, KC_Q,   KC_J,   KC_K,   KC_B,   KC_X,   KC_M,   KC_W,   KC_V,   KC_Z,           KC_RSFT,           KC_UP,           \
-		KC_FN0,  KC_LGUI,KC_LALT,                       KC_SPC,                          KC_RALT,KC_RGUI,KC_MENU,KC_FN1,    KC_LEFT,KC_DOWN,KC_RGHT),
+		MO(KM_MEDIA),KC_LGUI,KC_LALT,                   KC_SPC,                          KC_RALT,KC_RGUI,KC_MENU,KC_FN1,    KC_LEFT,KC_DOWN,KC_RGHT),
 	/* Layer 1: Standard ISO layer */
 	[KM_QWERTY] = LAYOUT( \
 		KC_ESC,          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_PSCR,KC_SLCK,KC_PAUS, \
@@ -56,7 +56,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,   SE_AO,  SE_CIRC,SE_QUOT,   KC_DEL, KC_END, KC_PGDN, \
 		KC_LCTRL,KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,   SE_OE,  SE_AE,          KC_ENT,                             \
 		KC_LSFT, SE_LTGT,KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM,KC_DOT, SE_MINS,        KC_RSFT,           KC_UP,           \
-		KC_FN0,  KC_LGUI,KC_LALT,                       KC_SPC,                          KC_RALT,KC_RGUI,KC_MENU,KC_FN1,    KC_LEFT,KC_DOWN,KC_RGHT),
+		MO(KM_MEDIA),KC_LGUI,KC_LALT,                   KC_SPC,                          KC_RALT,KC_RGUI,KC_MENU,KC_FN1,    KC_LEFT,KC_DOWN,KC_RGHT),
 	/* Layer 2: Media layer */
 	[KM_MEDIA] = LAYOUT( \
 		_______,        _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,   KC_WAKE,KC_PWR, KC_SLEP, \
@@ -76,7 +76,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-	[0] = ACTION_LAYER_MOMENTARY(KM_MEDIA),
 	[1] = ACTION_LAYER_TOGGLE(KM_QWERTY)
 };
 

keyboards/dz60/keymaps/LEdiodes/keymap.c

@@ -100,11 +100,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-// 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/gh60/revc/keymaps/maxr1998/keymap.c

@@ -38,7 +38,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Z,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_NO,  \
     KC_LOCK, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_HOME, KC_ENT, \
     KC_LSFT, KC_BSLS, KC_Y,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_UP,   KC_RSFT,\
-    KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                    KC_NO,   F(0),    KC_LEFT, KC_DOWN, KC_RGHT),
+    KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                    KC_NO,   MO(1),   KC_LEFT, KC_DOWN, KC_RGHT),
   /* 1: fn */
   LAYOUT(
     KC_ESC,  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_DEL, \
@@ -48,10 +48,6 @@ 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),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_LAYER_MOMENTARY(1)  // to Fn overlay
-};
-
 void matrix_scan_user(void) {
 
 }
@@ -80,4 +76,4 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     }
   }
   return true;
-}
+}

keyboards/gh60/revc/keymaps/robotmaxtron/keymap.c

@@ -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, \
         F(2),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_NO,KC_RSFT, \
-        KC_LCTL,KC_LGUI,KC_LALT,        KC_SPC,      KC_NO,KC_RALT,F(0),KC_APP,KC_RCTL),
+        KC_LCTL,KC_LGUI,KC_LALT,        KC_SPC,      KC_NO,KC_RALT,MO(2),KC_APP,KC_RCTL),
 
    /*
    * Locking arrow keys to WASD for when you need dedicated arrow keys
@@ -106,7 +106,6 @@ enum function_id {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [0]  = ACTION_LAYER_MOMENTARY(2),  // Momentary Fn overlay
     [1]  = ACTION_LAYER_TOGGLE(1),     // Toggle Arrow Layer overlay
     [2]  = ACTION_LAYER_TAP_KEY(2, KC_CAPS), // Tap to toggle caps lock and hold to activate function layer
     [3]  = ACTION_LAYER_TOGGLE(3),     // Toggle Underglow Layer overlay

keyboards/gh60/revc/keymaps/sethbc/keymap.c

@@ -9,7 +9,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         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_BSLS,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_LCTL,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,F(1),\
+        KC_LSFT,KC_Z,KC_X,KC_C,KC_V,KC_B,KC_N,KC_M,KC_COMM,KC_DOT,KC_SLSH,KC_RSFT,MO(1),\
         KC_LCTL,KC_LALT,KC_LGUI,      KC_SPC,            KC_RGUI,KC_RALT,KC_APP,KC_RCTL),
     /* 1: fn */
   LAYOUT_60_ansi_split_bs_rshift(
@@ -26,7 +26,6 @@ enum function_id {
 
 const uint16_t PROGMEM fn_actions[] = {
     [0] = ACTION_FUNCTION(SHIFT_ESC),
-    [1] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
 };
 
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)

keyboards/hhkb/keymaps/shela/keymap.c

@@ -35,7 +35,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         LAYOUT(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_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_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
-               OSM(MOD_LSFT), KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_FN0,
+               OSM(MOD_LSFT), KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, MO(HHKB),
                KC_LALT, KC_LGUI, KC_FN2, KC_RGUI, KC_RALT),
 
     /* Layer 1: Pseudo US Layout Layer
@@ -55,7 +55,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         LAYOUT(KC_ESC, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_BSPC,
                KC_TAB, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1,
                KC_LCTL, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_ENT,
-               KC_LSFT, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_RSFT, KC_FN0,
+               KC_LSFT, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_FN1, KC_RSFT, MO(HHKB),
                KC_LGUI, KC_FN3, KC_FN2, KC_FN4, KC_RGUI),
 
     /* Layer 2: Dvorak Layer
@@ -75,7 +75,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         LAYOUT(KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_LBRC, KC_RBRC, KC_GRV, KC_BSPC,
                KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_SLSH, KC_EQL, KC_BSLS,
                KC_LCTL, KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, KC_MINS, KC_ENT,
-               KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_RSFT, KC_FN0,
+               KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_RSFT, MO(HHKB),
                KC_LALT, KC_LGUI, KC_FN2, KC_RGUI, KC_RALT),
 
     /* Layer 3: Mouse layer
@@ -95,7 +95,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         LAYOUT(KC_ESC, 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_NO, KC_TRNS,
                KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_WH_L, KC_WH_D, KC_WH_U, KC_WH_R, KC_NO, KC_NO, KC_NO, KC_NO,
                KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, KC_NO, KC_NO, KC_TRNS,
-               KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BTN1, KC_BTN2, KC_BTN3, KC_NO, KC_NO, KC_TRNS, KC_FN0,
+               KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_BTN1, KC_BTN2, KC_BTN3, KC_NO, KC_NO, KC_TRNS, MO(HHKB),
                KC_TRNS, KC_TRNS, KC_BTN1, KC_TRNS, KC_TRNS),
 
     /* Layer 4: Tenkey layer
@@ -115,7 +115,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         LAYOUT(KC_ESC, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_PSLS, KC_PAST, KC_PMNS, KC_NO, KC_BSPC,
                KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_KP_7, KC_KP_8, KC_KP_9, KC_PPLS, KC_NO,
                KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_KP_4, KC_KP_5, KC_KP_6, KC_PENT,
-               KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_KP_1, KC_KP_2, KC_KP_3, KC_PPLS, KC_FN0,
+               KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_KP_1, KC_KP_2, KC_KP_3, KC_PPLS, MO(HHKB),
                KC_TRNS, KC_TRNS, KC_FN2, KC_KP_0, KC_PDOT),
 
     /* Layer 5: HHKB mode (HHKB Fn)
@@ -182,7 +182,6 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
  * Fn action definition
  */
 const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(HHKB),
     [1] = ACTION_FUNCTION(PSEUDO_US_FUNCTION),
     [2] = ACTION_LAYER_TAP_KEY(SPACE_FN, KC_SPACE),
     [3] = ACTION_MODS_TAP_KEY(MOD_LALT, KC_MHEN),

keyboards/jd45/keymaps/justin/keymap.c

@@ -1,11 +1,15 @@
 #include QMK_KEYBOARD_H
 
+#define KC_MO1 MO(1)
+#define KC_MO2 MO(2)
+#define KC_MO3 MO(3)
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     [0] = LAYOUT_kc(
         ESC, Q, W, F, P, G, J, L, U, Y, SCLN, QUOT, BSPC,
         FN8, A, R, S, T, D, H, N, E, I, O, ENT,
         LSFT, Z, X, C, V, B, K, M, COMM, DOT, SLSH, FN6,
-        FN4, LGUI, FN7, FN2, FN1, SPC, FN5, RALT, FN3, FN0),
+        FN4, LGUI, FN7, MO2, MO1, SPC, FN5, RALT, MO3, FN0),
     [1] = LAYOUT_kc(
         TRNS, FN10, FN11, FN12, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, UP, DEL,
         TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, HOME, PGUP, LEFT, RGHT,
@@ -37,9 +41,6 @@ enum macro_id
 
 const uint16_t PROGMEM fn_actions[] = {
     [0] = ACTION_MODS_TAP_KEY(MOD_LCTL, KC_MINS),
-    [1] = ACTION_LAYER_MOMENTARY(1), // FN1
-    [2] = ACTION_LAYER_MOMENTARY(2), // FN2
-    [3] = ACTION_LAYER_MOMENTARY(3), // FN3
     [4] = ACTION_MODS_TAP_KEY(MOD_LSFT, KC_GRV),
     [5] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_RGUI),
     [6] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_CAPS),

keyboards/keebio/nyquist/keymaps/DivergeJM/keymap.c

@@ -47,13 +47,11 @@ enum {
   const uint16_t PROGMEM fn_actions[] = {
       [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 FNC MO(_FUNCTION)
+#define MSE MO(_MOUSE)
 #define PIPE M(R_PIPE)
 #define POINT M(R_POINT)
 

keyboards/org60/keymaps/boardy/keymap.c

@@ -54,7 +54,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    //--------------------------------------------------------------------------------------------------------------------------------------|
    //          |          |          |                                                        |          |░░░░░░|        |        |        |
    //          |          |          |                                                        |          |░░░░░░|        |        |        |
-     KC_LCTL,   KC_LGUI,   KC_LALT,   KC_SPC,                                                  F(0),      KC_NO, KC_LEFT, KC_DOWN, KC_RIGHT),
+     KC_LCTL,   KC_LGUI,   KC_LALT,   KC_SPC,                                               MO(_FUNCTION),KC_NO, KC_LEFT, KC_DOWN, KC_RIGHT),
    //--------------------------------------------------------------------------------------------------------------------------------------'
 
 
@@ -103,19 +103,12 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    //--------------------------------------------------------------------------------------------------------------------------------------|
    //          |          |          |                                                        |          |░░░░░░|        |        |        |
    //          |          |          |                                                        |          |░░░░░░|        |        |        |
-     KC_LCTL,   KC_LGUI,   KC_LALT,   KC_0,                                                    F(0),      KC_NO, KC_MUTE, KC_VOLD, KC_MPLY),
+     KC_LCTL,   KC_LGUI,   KC_LALT,   KC_0,                                                 MO(_FUNCTION),KC_NO, KC_MUTE, KC_VOLD, KC_MPLY),
    //--------------------------------------------------------------------------------------------------------------------------------------'
 
 };
 
-
-// Custom Actions
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(_FUNCTION),  // to Function overlay
-};
-
-
 // Loop
 void matrix_scan_user(void) {
   // Empty
-};
+};

keyboards/planck/keymaps/angerthosenear/keymap.c

@@ -5,34 +5,31 @@ 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_SCLN,  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_QUOT},
-  {KC_LCTL, KC_LGUI, KC_LALT, BL_STEP, FUNC(2), KC_SPC,  KC_SPC,  FUNC(1), KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_LCTL, KC_LGUI, KC_LALT, BL_STEP, MO(3),   KC_SPC,  KC_SPC,  MO(2),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommodate for both spacebar wiring positions
 },
 [1] = { /* WASD + NumPad */
   {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_P7,   KC_P8,   KC_P9,   KC_PSLS, KC_PMNS, KC_TRNS},
   {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_P4,   KC_P5,   KC_P6,   KC_PAST, KC_PPLS, KC_TRNS},
   {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_P1,   KC_P2,   KC_P3,   KC_PDOT, KC_PENT, KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2), KC_SPC,  KC_P0,   FUNC(1), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(3),   KC_SPC,  KC_P0,   MO(2),   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS}
 },
 [2] = { /* RAISE */
   {KC_GRV,	KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_TRNS},
   {KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS},
   {KC_TRNS, KC_F11,  KC_F12,  KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20, KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_MPRV,  FUNC(1),   KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_MPRV,  MO(2),     KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [3] = { /* LOWER */
   {S(KC_GRV),  S(KC_1),    S(KC_2),    S(KC_3),    S(KC_4),    S(KC_5),    S(KC_6),    S(KC_7),    S(KC_8),    S(KC_9),    S(KC_0), KC_DEL},
   {KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), KC_TRNS, KC_TRNS, KC_TRNS, S(KC_MINS), S(KC_EQL),  S(KC_LBRC), S(KC_RBRC), S(KC_BSLS)},
   {KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2),   KC_TRNS,   KC_TRNS,   KC_TRNS, KC_HOME, KC_PGDN, KC_PGUP, KC_END}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(3),     KC_TRNS,   KC_TRNS,   KC_TRNS, KC_HOME, KC_PGDN, KC_PGUP, KC_END}
 }
 };
 
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to LOWER
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

keyboards/planck/keymaps/austin/keymap.c

@@ -5,35 +5,32 @@ 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_BSPC},
   {KC_ESC,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN,  KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {BL_STEP, KC_LGUI, KC_LALT, KC_LCTL, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {BL_STEP, KC_LGUI, KC_LALT, KC_LCTL, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 },
 [1] = { /* Colemak */
   {KC_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC},
   {KC_ESC,  KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,     KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {KC_FN3, KC_LGUI, KC_LALT, KC_LCTL,  FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_FN3, KC_LGUI, KC_LALT, KC_LCTL,  MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
 },
 [2] = { /* RAISE */
   {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS},
   {KC_TRNS, KC_F11,  KC_F12,  KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20, KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  FUNC(1),   KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  MO(2),     KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [3] = { /* LOWER */
   {S(KC_GRV),  S(KC_1),    S(KC_2),    S(KC_3),    S(KC_4),    S(KC_5),    S(KC_6),    S(KC_7),    S(KC_8),    S(KC_9),    S(KC_0), KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), KC_TRNS, KC_TRNS, KC_TRNS, S(KC_MINS), S(KC_EQL),  S(KC_LBRC), S(KC_RBRC), S(KC_BSLS)},
   {KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2),   KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(3),     KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 }
 };
 
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to LOWER
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 
-};
+};

keyboards/planck/keymaps/charlie/keymap.c

@@ -11,20 +11,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       {KC_DELETE,  KC_0,    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    FUNC(1)},
       {KC_O,       KC_G,    KC_S,    KC_U,    KC_T,    FUNC(27),  KC_F21,  KC_F10,  KC_F11,  KC_F7,   KC_F8,   KC_F9},
       {KC_TAB,     FUNC(4), FUNC(5),  FUNC(6),  KC_F1,   FUNC(7),  KC_F18,  KC_F19,  KC_F23,  KC_F20,  KC_F22,  FUNC(9)},
-      {KC_COMM,    KC_DOT,  KC_R, FUNC(11), FUNC(3),  KC_SPC,        FUNC(12), KC_F2,   FUNC(8),  KC_F3,   KC_F14}
+      {KC_COMM,    KC_DOT,  KC_R, FUNC(11), MO(2),    KC_SPC,        FUNC(12), KC_F2,   FUNC(8),  KC_F3,   KC_F14}
 	  },
     [2] = { /* 2: FUNC(3 PHOTOSHOP */
       {KC_ESC,    FUNC(25), FUNC(26),   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO},
       {KC_NO,      KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   FUNC(19), FUNC(20), FUNC(21)}, 
       {KC_C,       KC_NO,  FUNC(22),  FUNC(5),   KC_NO,   FUNC(23), KC_NO,   KC_NO,   KC_NO,   KC_NO,   FUNC(13), KC_NO},
-      {FUNC(14),    FUNC(15), FUNC(16), FUNC(17), FUNC(3),   KC_SPC,        FUNC(18), KC_NO,   KC_NO,   KC_F24,  KC_NO}
+      {FUNC(14),    FUNC(15), FUNC(16), FUNC(17), MO(2),     KC_SPC,        FUNC(18), KC_NO,   KC_NO,   KC_F24,  KC_NO}
 	  }
 };
 
 const uint16_t PROGMEM fn_actions[] = {
     [1] = ACTION_DEFAULT_LAYER_SET(0),                             // set Qwerty layout
     [2] = ACTION_DEFAULT_LAYER_SET(1),                             // set Photoshop presets
-    [3] = ACTION_LAYER_MOMENTARY(2),                                  // Photoshop function layer
  
     [4] = ACTION_MODS_KEY(MOD_LSFT | MOD_LCTL | MOD_LALT, KC_F9),   // photo folder AHK
     [5] = ACTION_MODS_KEY(MOD_LSFT | MOD_LCTL, KC_I),              // select inverse

keyboards/planck/keymaps/daniel/keymap.c

@@ -5,33 +5,26 @@ 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_SCLN,  KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT},
-  {FUNC(3), KC_LCTL, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {MO(3),   KC_LCTL, KC_LALT, KC_LGUI, MO(2),      KC_SPC,   KC_SPC,    MO(1),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 },
 [1] = { /* RAISE */
   {KC_GRV, S(KC_1),  S(KC_2),  S(KC_3),  S(KC_4),  S(KC_5),  S(KC_6),  S(KC_7),  S(KC_8),  S(KC_9),  S(KC_0), KC_EQL},
   {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_LBRC, KC_RBRC},
   {KC_TRNS, KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_TRNS,  KC_MINS,  S(KC_MINS),  KC_BSLS, KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  FUNC(1),   KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  MO(1),     KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [2] = { /* LOWER */
   {S(KC_GRV), KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,  S(KC_EQL)},
   {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_CAPS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_ENT},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2),   KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(2),     KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [3] = { /* Qwerty */
   {KC_ESC,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,   KC_DEL},
   {KC_TAB,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN,  KC_QUOT},
   {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_TRNS, KC_LCTL, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_TRNS, KC_LCTL, KC_LALT, KC_LGUI, MO(2),      KC_SPC,   KC_SPC,    MO(1),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 }
 };
-
-
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(1),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(2),   // to LOWER
-    [3] = ACTION_LAYER_MOMENTARY(3)   // to LOWER
-};

keyboards/planck/keymaps/david/keymap.c

@@ -5,33 +5,30 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   {KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_BSPC,  KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,   KC_BSPC},
   {KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_ENT,   KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN,  KC_QUOT},
   {KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_ESC,   KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {M(10), KC_LCTL, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {M(10), KC_LCTL, KC_LALT, KC_LGUI, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 },
 [1] = { /* Colemak */
   {KC_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC},
   {KC_ESC,  KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,     KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {KC_FN3, KC_LCTL, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_FN3, KC_LCTL, KC_LALT, KC_LGUI, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
 },
 [2] = { /* RAISE */
   {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), RESET, M(0), M(1), M(2), KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS},
   {KC_TRNS, KC_F11,  KC_F12,  M(0),   M(1),   M(2),   M(3),   M(4),   M(5),   M(6),   M(7), KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  FUNC(1),   KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  MO(2),     KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [3] = { /* LOWER */
   {S(KC_GRV),  S(KC_1),    S(KC_2),    S(KC_3),    S(KC_4),    S(KC_5),    S(KC_6),    S(KC_7),    S(KC_8),    S(KC_9),    S(KC_0), KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), RESET, M(0), M(1), M(2), S(KC_MINS), S(KC_EQL),  S(KC_LBRC), S(KC_RBRC), S(KC_BSLS)},
   {KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2),   KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(3),     KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 }
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to LOWER
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

keyboards/planck/keymaps/dzobert/keymap.c

@@ -5,33 +5,30 @@ 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_TAB},
   {KC_LCTL,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN,  KC_BSPC},
   {KC_LALT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {KC_FN4, KC_RSFT, KC_LGUI, KC_LSFT, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_FN4, KC_RSFT, KC_LGUI, KC_LSFT, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 },
 [1] = { /* Colemak */
   {KC_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_TAB},
   {KC_ESC,  KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,     KC_BSPC},
   {KC_LALT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {KC_FN3, KC_RSFT, KC_LGUI, KC_LSFT, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_FN3, KC_RSFT, KC_LGUI, KC_LSFT, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
 },
 [2] = { /* RAISE */
   {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_1,    KC_2,    KC_3,    KC_4,    KC_5,     KC_6,     KC_7,    KC_8,          KC_9,  KC_DEL},
   {KC_TRNS, KC_GRV,  KC_MINS,  KC_EQL,  KC_QUOT,  S(KC_QUOT),  S(KC_LBRC),  S(KC_RBRC),  KC_LBRC,  KC_RBRC,  KC_BSLS, KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  FUNC(1),   KC_HOME, KC_PGUP, KC_PGDN, KC_END}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  MO(2),     KC_HOME, KC_PGUP, KC_PGDN, KC_END}
 },
 [3] = { /* LOWER */
   {KC_POWER,KC_PSCR, KC_SLCK, KC_PAUSE, KC_NLCK, KC_EXECUTE, KC_MENU,   KC_APP,  KC_7,  KC_8, KC_9, KC_KP_SLASH},
   {KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_CAPS, KC_CANCEL, KC_UNDO, KC_AGAIN, KC_4,  KC_5, KC_6, KC_KP_ASTERISK},
   {KC_TRNS, KC_INSERT,KC_CUT,   KC_COPY,   KC_PASTE,   KC_BSLS,   KC_9,   KC_0,   KC_1,   KC_2,   KC_3,  KC_KP_MINUS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2),   KC_TRNS,   KC_TRNS,   KC_TRNS, KC_0, KC_KP_DOT, KC_KP_ENTER, KC_KP_PLUS}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(3),     KC_TRNS,   KC_TRNS,   KC_TRNS, KC_0, KC_KP_DOT, KC_KP_ENTER, KC_KP_PLUS}
 }
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to LOWER
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

keyboards/planck/keymaps/joe/keymap.c

@@ -6,50 +6,47 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     {F(3),    KC_Q,    KC_W,    KC_F,    KC_P, KC_G,   KC_J,   KC_L, KC_U,    KC_Y,    KC_SCLN, KC_MINS},
     {KC_BSPC, KC_A,    KC_R,    KC_S,    KC_T, KC_D,   KC_H,   KC_N, KC_E,    KC_I,    KC_O,    KC_ENT },
     {F(15),   KC_Z,    KC_X,    KC_C,    KC_V, KC_B,   KC_K,   KC_M, KC_COMM, KC_DOT,  KC_UP,   KC_QUOT},
-    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, F(1), KC_SPC, KC_SPC, F(2), KC_SLSH, KC_LEFT, KC_DOWN, KC_RGHT}
+    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, MO(4),KC_SPC, KC_SPC, MO(5),KC_SLSH, KC_LEFT, KC_DOWN, KC_RGHT}
   },
   [1] = { /* Joe soft Colemak */
     {F(3),    CM_Q,    CM_W,    CM_F,    CM_P, CM_G,   CM_J,   CM_L, CM_U,    CM_Y,    CM_SCLN, KC_MINS},
     {KC_BSPC, CM_A,    CM_R,    CM_S,    CM_T, CM_D,   CM_H,   CM_N, CM_E,    CM_I,    CM_O,    KC_ENT },
     {F(15),   CM_Z,    CM_X,    CM_C,    CM_V, CM_B,   CM_K,   CM_M, KC_COMM, KC_DOT,  KC_UP,   KC_QUOT},
-    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, F(1), KC_SPC, KC_SPC, F(2), KC_SLSH, KC_LEFT, KC_DOWN, KC_RGHT}
+    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, MO(4),KC_SPC, KC_SPC, MO(5),KC_SLSH, KC_LEFT, KC_DOWN, KC_RGHT}
   },
   [2] = { /* Joe NUMPAD */
     {F(3),    KC_NO,   KC_UP,   KC_NO,   KC_NO, KC_NO,   LSFT(KC_9), LSFT(KC_0), KC_PSLS, KC_P7, KC_P8,   KC_P9  },
     {KC_BSPC, KC_LEFT, KC_DOWN, KC_RGHT, KC_NO, KC_NO,   LSFT(KC_5), KC_PEQL,    KC_PAST, KC_P4, KC_P5,   KC_P6  },
     {F(15),   KC_NO,   KC_NO,   KC_NO,   KC_NO, KC_NO,   KC_NO,      KC_PCMM,    KC_PMNS, KC_P1, KC_P2,   KC_P3  },
-    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, F(1),  KC_TRNS, KC_TRNS,    F(2),       KC_PPLS, KC_P0, KC_PDOT, KC_PENT}
+    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, MO(4), KC_TRNS, KC_TRNS,    MO(5),      KC_PPLS, KC_P0, KC_PDOT, KC_PENT}
   },
   [3] = { /* Joe 1337 haxOr5*/
     {F(3),    KC_Q,    KC_W,    KC_F,    KC_P, KC_6,   KC_J,   KC_L, KC_U,    KC_Y,    KC_SCLN, KC_MINS},
     {KC_BSPC, KC_4,    KC_R,    KC_5,    KC_7, KC_D,   KC_H,   KC_N, KC_3,    KC_1,    KC_0,    KC_ENT },
     {F(15),   KC_Z,    KC_X,    KC_C,    KC_V, KC_B,   KC_K,   KC_M, KC_COMM, KC_DOT,  KC_UP,   KC_QUOT},
-    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, F(1), KC_SPC, KC_SPC, F(2), KC_SLSH, KC_LEFT, KC_DOWN, KC_RGHT}
+    {KC_LCTL, KC_LGUI, KC_LALT, KC_LSFT, MO(4),KC_SPC, KC_SPC, MO(5),KC_SLSH, KC_LEFT, KC_DOWN, KC_RGHT}
   },
   [4] = { /* Joe LOWER fn1 */
     {KC_GRV,  KC_NO,   KC_NO,   KC_NO,   KC_NO, KC_NO,   KC_NO,   KC_NO, M(3),    M(2),    M(1),    M(0)   },
     {KC_BSPC, KC_1,    KC_2,    KC_3,    KC_4,  KC_5,    KC_6,    KC_7,  KC_8,    KC_9,    KC_0,    KC_TRNS},
     {KC_BSLS, KC_NO,   KC_NO,   KC_NO,   KC_NO, KC_NO,   KC_NO,   KC_NO, KC_LBRC, KC_RBRC, KC_PGUP, KC_EQL },
-    {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, F(1),  KC_TRNS, KC_TRNS, F(2),  KC_NO,   KC_HOME, KC_PGDN, KC_END }
+    {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(4), KC_TRNS, KC_TRNS, MO(5), KC_NO,   KC_HOME, KC_PGDN, KC_END }
   },
   [5] = { /* Joe UPPER fn2 */
     {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_DEL,  KC_BTN1, KC_MS_U, KC_BTN2, KC_BTN3, KC_WH_U, KC_BTN4, KC_LEFT, KC_DOWN, KC_UP,               KC_RGHT,             KC_NO              },
     {KC_TRNS, KC_MS_L, KC_MS_D, KC_MS_R, KC_WH_L, KC_WH_D, KC_WH_R, KC_NO,   KC_NO,   LCTL(KC_PGUP),       LCTL(LALT(KC_UP)),   LCTL(KC_PGDN)      },
-    {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, F(1),    KC_NO,   KC_NO,   F(2),    KC_NO,   LCTL(LALT(KC_LEFT)), LCTL(LALT(KC_DOWN)), LCTL(LALT(KC_RGHT))}
+    {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(4),   KC_NO,   KC_NO,   MO(5),   KC_NO,   LCTL(LALT(KC_LEFT)), LCTL(LALT(KC_DOWN)), LCTL(LALT(KC_RGHT))}
   },
   [6] = { /* Joe SPECIAL fn3 */
     {KC_TRNS, KC_MUTE, KC_VOLD, KC_VOLU, KC_NO, KC_NO,   KC_NO,   KC_NO, KC_NO,    KC_NO,   KC_NO,   KC_NO           },
     {KC_NO,   KC_MPLY, KC_MPRV, KC_MNXT, KC_NO, KC_NO,   KC_NO,   KC_NO, KC_NO,    KC_NO,   KC_NO,   RESET           },
     {KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO, KC_NO,   KC_NO,   KC_NO, KC_NO,    KC_NO,   KC_NO,   KC_NO           },
-    {F(6),    F(7),    F(8),    F(9),   F(1),  KC_TRNS, KC_TRNS, F(2),  KC_POWER, KC_WAKE, KC_SLEP, LCTL(LALT(KC_L))}
+    {F(6),    F(7),    F(8),    F(9),   MO(4), KC_TRNS, KC_TRNS, MO(5), KC_POWER, KC_WAKE, KC_SLEP, LCTL(LALT(KC_L))}
   }
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(4),  // fn1
-    [2] = ACTION_LAYER_MOMENTARY(5),  // fn2
-
     /* ESC on tap, fn3 on hold */
     [3] = ACTION_LAYER_TAP_KEY(6, KC_ESC),
 

keyboards/planck/keymaps/kyle/keymap.c

@@ -5,33 +5,30 @@ 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_SCLN,  KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {KC_RCTL, KC_LCTL, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_RCTL, KC_LCTL, KC_LALT, KC_LGUI, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 },
 [1] = { /* Colemak */
   {KC_ESC,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC},
   {KC_TAB,  KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,     KC_QUOT},
   {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT},
-  {KC_FN3, KC_LCTL, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_FN3, KC_LCTL, KC_LALT, KC_LGUI, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
 },
 [2] = { /* RAISE */
   {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS},
   {KC_TRNS, KC_F11,  KC_F12,  KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20, KC_TRNS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  FUNC(1),   KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  MO(2),     KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [3] = { /* LOWER */
   {S(KC_GRV),  S(KC_1),    S(KC_2),    S(KC_3),    S(KC_4),    S(KC_5),    S(KC_6),    S(KC_7),    S(KC_8),    S(KC_9),    S(KC_0), KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), LSFT(RSFT(KC_PAUSE)), LSFT(RSFT(KC_D)), KC_TRNS, KC_TRNS, S(KC_MINS), S(KC_EQL),  S(KC_LBRC), S(KC_RBRC), S(KC_BSLS)},
   {KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_TRNS},
-  {BL_STEP, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2),   KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {BL_STEP, KC_TRNS, KC_TRNS, KC_TRNS, MO(3),     KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 }
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to LOWER
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

keyboards/planck/keymaps/leo/keymap.c

@@ -5,7 +5,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   {KC_ESC,  KC_LBRC, KC_QUOT, KC_SCLN, KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSPC},
   {KC_TAB,  KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_ENT},
   {KC_LSFT, KC_DOT,  KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_COMM},
-  {KC_LCTL, KC_LALT, KC_LGUI, FUNC(3), FUNC(2), KC_SPC,  KC_SPC,  FUNC(1), FUNC(3), KC_RGUI, KC_RALT, KC_RCTL}
+  {KC_LCTL, KC_LALT, KC_LGUI, MO(4),   MO(3),   KC_SPC,  KC_SPC,  MO(2),   MO(4),   KC_RGUI, KC_RALT, KC_RCTL}
 },
 [2] = { /* RAISE */
   {RALT(KC_RBRC),  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,  S(KC_RBRC)},
@@ -26,10 +26,3 @@ 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,  KC_TRNS}
 }
 };
-
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to LOWER
-    [3] = ACTION_LAYER_MOMENTARY(4),  // to META
-
-};

keyboards/planck/keymaps/lucas/keymap.c

@@ -29,7 +29,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   {KC_ESC,  KC_Q,    KC_W,   KC_F,    KC_P, KC_G, KC_J, KC_L, KC_U,    KC_Z,    DE_SCLN, DE_MINS},
   {KC_BSPC, KC_A,    KC_R,   KC_S,    KC_T, KC_D, KC_H, KC_N, KC_E,    KC_I,    KC_O,    DE_QUOT},
   {M(0),    KC_Y,    KC_X,   KC_C,    KC_V, KC_B, KC_K, KC_M, DE_COMM, DE_DOT,  DE_SLSH, KC_ENT},
-  {KC_LCTL, KC_LGUI, KC_TAB, KC_LALT, F(2), F(3), F(3), F(1), KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+  {KC_LCTL, KC_LGUI, KC_TAB, KC_LALT, MO(3),F(3), F(3), MO(2),KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
 },
 [1] = { /* Symbols
     * ,-----------------------------------------------------------------------.
@@ -93,7 +93,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   {KC_F13, KC_F14,  KC_F15, KC_F16, KC_F17,  KC_F18,  KC_F19,  KC_F20,  KC_F21,  KC_F22,  KC_F23,  KC_F24},
   {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_NO,  KC_NO,   KC_NO,  KC_NO,  KC_NO,   KC_PMNS, KC_PPLS, KC_NO,   KC_NO,   KC_NO,   RESET,   KC_NO},
-  {KC_NO,  BL_TOGG, BL_DEC, BL_INC, FUNC(2), KC_TRNS, KC_TRNS, KC_TRNS, KC_MUTE, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_NO,  BL_TOGG, BL_DEC, BL_INC, MO(3),   KC_TRNS, KC_TRNS, KC_TRNS, KC_MUTE, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [5] = { /* Gaming
     * ,-----------------------------------------------------------------------.
@@ -131,8 +131,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),              // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),              // to LOWER
     [3] = ACTION_LAYER_TAP_KEY(4,KC_SPC),         // to Function
     [4] = ACTION_LAYER_TOGGLE(5),                 // toggle Gaming
 	[5] = ACTION_MODS_TAP_KEY(KC_LSFT, KC_CAPS),  //Shift on press, Caps on tap

keyboards/planck/keymaps/max/keymap.c

@@ -5,34 +5,31 @@ 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_SCLN, 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_QUOT},
-  {KC_LCTL, BL_STEP, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_LCTL, BL_STEP, KC_LALT, KC_LGUI, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
                                                 // Space is repeated to accommadate for both spacebar wiring positions
 },
 [1] = { /* Colemak */
   {KC_ESC,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC},
   {KC_TAB,  KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    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_QUOT},
-  {KC_LCTL, BL_STEP, KC_LALT, KC_LGUI, FUNC(2),    KC_SPC,   KC_SPC,    FUNC(1),   KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
+  {KC_LCTL, BL_STEP, KC_LALT, KC_LGUI, MO(3),      KC_SPC,   KC_SPC,    MO(2),     KC_LEFT, KC_DOWN, KC_UP,  KC_RGHT}
 },
 [2] = { /* RAISE */
   {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), RESET, KC_TRNS, KC_TRNS, KC_TRNS, KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_TRNS},
   {KC_TRNS, KC_F11,  KC_F12,  KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20, KC_BSLS},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  FUNC(1),   KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,   KC_TRNS,  MO(2),     KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 },
 [3] = { /* LOWER */
   {S(KC_GRV),  S(KC_1),    S(KC_2),    S(KC_3),    S(KC_4),    S(KC_5),    S(KC_6),    S(KC_7),    S(KC_8),    S(KC_9),    S(KC_0), KC_BSPC},
   {KC_TRNS, FUNC(3), FUNC(4), RESET, KC_TRNS, KC_TRNS, KC_TRNS, S(KC_MINS), S(KC_EQL),  S(KC_LBRC), S(KC_RBRC), KC_TRNS},
   {KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  S(KC_BSLS)},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, FUNC(2),   KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(3),     KC_TRNS,   KC_TRNS,   KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
 }
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to LOWER
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 
-};
+};

keyboards/planck/old_keymap_files/common_keymaps/keymap_brett.c

@@ -1,26 +1,26 @@
 #include "keymap.h"
 
+#define KC_MO1 MO(1)
+#define KC_MO2 MO(2)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP( 
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   LCTL, A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, ENT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, RSFT,
-  TAB, LGUI,  RSFT, LALT, FN2,     SPC,     FN1,  LEFT, DOWN, UP,   RGHT),
+  TAB, LGUI,  RSFT, LALT, MO2,     SPC,     MO1,  LEFT, DOWN, UP,   RGHT),
 [1] = KEYMAP( /* RAISE */
   GRV,  1,    2,    3,    4,    5,    6,    7,    8,    9,    0,    DEL,
   TRNS, F1,   F2,   F3,   F4,   F5,   F6,   4,    5,    6,   QUOT, TRNS,
   TRNS, F7,   F8,   F9,   F10,  F11,  F12,  1,    2,    3,   TRNS, PGUP,
-  MPRV, MNXT, TRNS, MUTE, TRNS,    TRNS,    FN1,  0,  0,  TRNS, PGDN),
+  MPRV, MNXT, TRNS, MUTE, TRNS,    TRNS,    MO1,  0,  0,  TRNS, PGDN),
 [2] = KEYMAP( /* LOWER */
   TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, MINS,
   TRNS, TRNS, TRNS, PAUSE, TRNS, TRNS, TRNS, TRNS, LBRC, RBRC, BSLS, EQL,
   TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
-  MPLY, MSTP, VOLU, VOLD, FN2,     TRNS,    TRNS, TRNS, TRNS, TRNS, TRNS),
+  MPLY, MSTP, VOLU, VOLD, MO2,     TRNS,    TRNS, TRNS, TRNS, TRNS, TRNS),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-    [2] = ACTION_LAYER_MOMENTARY(2),  // to Fn overlay 
-
     [10] = ACTION_MODS_KEY(MOD_LSFT, KC_1),
     [11] = ACTION_MODS_KEY(MOD_LSFT, KC_2),
     [12] = ACTION_MODS_KEY(MOD_LSFT, KC_3),

keyboards/planck/old_keymap_files/common_keymaps/keymap_dotcom.c

@@ -1,20 +1,20 @@
 #include "keymap.h"
 
+#define KC_MO1 MO(1)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP( 
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
-  FN1,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, ENT,
+  MO1,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, ENT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, LBRC,
   LCTL, BSLS, QUOT, LALT, FN22,    SPC,     LEFT, UP, DOWN, RGHT,  RBRC),
 [1] = KEYMAP( 
   GRV,  1,    2,    3,    4,    5,    6,    7,    8,    9,    0,    DEL,
   TRNS, FN10, FN11, FN12, FN13, FN14, FN15, FN16, FN17,  TRNS, TRNS, TRNS,
   TRNS, FN18,  FN19,  FN22,  EQL,  MINS,  FN20,  TRNS,  TRNS,  TRNS,  TRNS, TRNS,
-  TRNS, TRNS, TRNS, TRNS, TRNS,    TRNS,   FN1,  TRNS, VOLD, VOLU, TRNS),
+  TRNS, TRNS, TRNS, TRNS, TRNS,    TRNS,   MO1,  TRNS, VOLD, VOLU, TRNS),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-
     [10] = ACTION_MODS_KEY(MOD_LSFT, KC_1),
     [11] = ACTION_MODS_KEY(MOD_LSFT, KC_2),
     [12] = ACTION_MODS_KEY(MOD_LSFT, KC_3),

keyboards/planck/old_keymap_files/common_keymaps/keymap_jack.c

@@ -1,31 +1,31 @@
 #include "keymap.h"
 
+#define KC_MO2 MO(2)
+#define KC_MO3 MO(3)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP( /* Jack */
   TAB,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   ESC,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, QUOT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, ENT,
-  RSFT, LCTL, LALT, LGUI, FN2,    SPC,     FN1, LEFT, DOWN, UP,  RGHT),
+  RSFT, LCTL, LALT, LGUI, MO3,    SPC,     MO2, LEFT, DOWN, UP,  RGHT),
 [1] = KEYMAP( /* Jack colemak */
   TAB,  Q,    W,    F,    P,    G,    J,    L,    U,    Y,    SCLN, BSPC,
   ESC,  A,    R,    S,    T,    D,    H,    N,    E,    I,    O,     QUOT,
   LSFT, Z,    X,    C,    V,    B,    K,    M,    COMM, DOT,  SLSH, ENT,
-  FN3, LCTL, LALT, LGUI, FN2,    SPC,     FN1, LEFT, DOWN, UP,  RGHT),
+  FN3, LCTL, LALT, LGUI, MO3,    SPC,     MO2, LEFT, DOWN, UP,  RGHT),
 [2] = KEYMAP( /* Jack RAISE */
   GRV,  1,    2,    3,    4,    5,    6,    7,    8,    9,    0,    BSPC,
   TRNS, FN3, FN4, PAUSE, TRNS, TRNS, TRNS, MINS, EQL,  LBRC, RBRC, BSLS,
   TRNS, F11,  F12,  F13,  F14,  F15,  F16,  F17,  F18,  F19,  F20, TRNS,
-  TRNS, TRNS, TRNS, TRNS, TRNS,    TRNS,   FN1,  MNXT, VOLD, VOLU, MPLY),
+  TRNS, TRNS, TRNS, TRNS, TRNS,    TRNS,   MO2,  MNXT, VOLD, VOLU, MPLY),
 [3] = KEYMAP( /* Jack LOWER */
   FN22, FN10, FN11, FN12, FN13, FN14, FN15, FN16, FN17, FN18, FN19, BSPC,
   TRNS, FN3, FN4, PAUSE, TRNS, TRNS, TRNS, FN20, FN21, FN23, FN24, FN28,
   TRNS, F1,   F2,   F3,   F4,   F5,   F6,   F7,   F8,   F9,   F10,  TRNS,
-  TRNS, TRNS, TRNS, TRNS, FN2,    TRNS,    TRNS, MNXT, VOLD, VOLU, MPLY),
+  TRNS, TRNS, TRNS, TRNS, MO3,    TRNS,    TRNS, MNXT, VOLD, VOLU, MPLY),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to Fn overlay
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to Fn overlay
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),  
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

keyboards/planck/old_keymap_files/common_keymaps/keymap_joe.c

@@ -1,26 +1,30 @@
 #include "keymap.h"
 
+#define KC_MO2 MO(2)
+#define KC_MO3 MO(3)
+#define KC_MO4 MO(4)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP( /* Joe qwerty */
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    MINS,
   BSPC, A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, ENTER,
   FN7,  Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, QUOT,
-  LCTL, LGUI, LALT, LSFT, FN1,    SPC,      FN0,  LEFT, UP,   DOWN, RGHT),
+  LCTL, LGUI, LALT, LSFT, MO3,    SPC,      MO2,  LEFT, UP,   DOWN, RGHT),
 [1] = KEYMAP( /* Joe colemak */
   ESC,  Q,    W,    F,    P,    G,    J,    L,    U,    Y,    SCLN, MINS,
   BSPC, A,    R,    S,    T,    D,    H,    N,    E,    I,    O,    ENTER,
   FN7,  Z,    X,    C,    V,    B,    K,    M,    COMM, DOT,  SLSH, QUOT,
-  LCTL, LGUI, LALT, LSFT, FN1,    SPC,      FN0,  LEFT, UP,   DOWN, RGHT),
+  LCTL, LGUI, LALT, LSFT, MO3,    SPC,      MO2,  LEFT, UP,   DOWN, RGHT),
 [2] = KEYMAP( /* Joe UPPER */
   F1,   F2,   F3,   F4,   F5,   F6,   F7,   F8,   F9,   F10,  F11,  F12,
   DEL,  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
   TRNS, TRNS, TRNS, TRNS, TRNS, MENU, CAPS, INS,  PSCR, TRNS, FN5,  FN6,
-  TRNS, TRNS, TRNS, TRNS, FN2,     TRNS,    FN0,  FN26, FN27, FN28, FN29),
+  TRNS, TRNS, TRNS, TRNS, MO4,     TRNS,    MO2,  FN26, FN27, FN28, FN29),
 [3] = KEYMAP( /* Joe LOWER */
   GRV,  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, FN8,  FN9,  FN30,
   BSPC, 1,    2,    3,    4,    5,    6,    7,    8,    9,    0,    TRNS,
   BSLS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, LBRC, RBRC, TRNS, EQL,
-  TRNS, TRNS, TRNS, TRNS, FN1,     TRNS,    FN2,  HOME, PGUP, PGDN, END),
+  TRNS, TRNS, TRNS, TRNS, MO3,     TRNS,    MO4,  HOME, PGUP, PGDN, END),
 [4] = KEYMAP( /* Joe LOWER + UPPER */
   FN3,  FN4,  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, SLEP,
   TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
@@ -35,10 +39,6 @@ enum macro_id {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(2),  // to Fn overlay
-    [1] = ACTION_LAYER_MOMENTARY(3),  // to Fn overlay
-    [2] = ACTION_LAYER_MOMENTARY(4),  // to Fn overlay
-
     [3] = ACTION_DEFAULT_LAYER_SET(0), 
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

keyboards/planck/old_keymap_files/common_keymaps/keymap_matthew.c

@@ -22,12 +22,15 @@
 
 #include "keymap.h"
 
+#define KC_MO1 MO(1)
+#define KC_MO2 MO(2)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   /* 0: dvorak */
   [0] = KEYMAP_GRID( ESC, SCLN, COMM,  DOT,    P,    Y,    F,    G,    C,    R,    L, BSPC,   \
                      GRV,    A,    O,    E,    U,    I,    D,    H,    T,    N,    S, MINS,   \
                      TAB, QUOT,    Q,    J,    K,    X,    B,    M,    W,    V,    Z,  ENT,   \
-                    LCTL, LGUI, LALT, RALT,  FN1, LSFT,  SPC,  FN2, LEFT, DOWN,   UP, RGHT),
+                    LCTL, LGUI, LALT, RALT,  MO1, LSFT,  SPC,  MO2, LEFT, DOWN,   UP, RGHT),
 
   /* 1: lower (FN1) */
   [1] = KEYMAP_GRID( F1,   F2,   F3,   F4,   F5,   F6,   F7,   F8,   F9,  F10,  F11,  F12,   \
@@ -44,9 +47,6 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(1),               // lower Fn layer
-    [2] = ACTION_LAYER_MOMENTARY(2),               // raise Fn layer
-
     // lower row1
     [17] = ACTION_MODS_KEY(MOD_LSFT, KC_5),        // %
     [18] = ACTION_MODS_KEY(MOD_LSFT, KC_SLASH),    // ?

keyboards/planck/old_keymap_files/common_keymaps/keymap_nathan.c

@@ -3,6 +3,9 @@
 
 #include "keymap.h"
 
+#define KC_MO1 MO(1)
+#define KC_MO2 MO(2)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /* 0: main layer
     * ,-----------------------------------------------------------------------.
@@ -19,7 +22,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        TAB,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
        LCTL, A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, ENT,
        RSFT, Z,    X,    C,    V,    B,    N,    M,    LBRC, FN10, FN11, FN12,
-       LGUI, BSLS, SLSH, LALT, FN0,  SPC,  SPC,  FN1,  LEFT, DOWN, UP,   RGHT),
+       LGUI, BSLS, SLSH, LALT, MO1,  SPC,  SPC,  MO2,  LEFT, DOWN, UP,   RGHT),
 
    /* 1: fn left/lower layer
     * The top row are Visual Studio combos:
@@ -73,8 +76,6 @@ enum macro_id {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_LAYER_MOMENTARY(1), // left/lower layer
-  [1] = ACTION_LAYER_MOMENTARY(2), // right/raise layer
   // Program macros
   [2] = ACTION_MACRO(M_P0),
   [3] = ACTION_MACRO(M_P1),

keyboards/planck/old_keymap_files/common_keymaps/keymap_paul.c

@@ -1,32 +1,32 @@
 #include "keymap.h"
 
+#define KC_MO1 MO(1)
+#define KC_MO2 MO(2)
+#define KC_MO3 MO(3)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP( /* Paul */
   TAB,   Q,     W,     E,     R,     T,     Y,     U,     I,     O,     P,     BSPC,
-  FN1,   A,     S,     D,     F,     G,     H,     J,     K,     L,     SCLN,  QUOT,
+  MO1,   A,     S,     D,     F,     G,     H,     J,     K,     L,     SCLN,  QUOT,
   LSFT,  Z,     X,     C,     V,     B,     N,     M,     COMM,  DOT,   SLSH,  ENT,
-  ESC,   LCTL,  LALT,  LGUI,  FN2,       SPC,      FN3,   LEFT,  DOWN,  UP,    RGHT),
+  ESC,   LCTL,  LALT,  LGUI,  MO2,       SPC,      MO3,   LEFT,  DOWN,  UP,    RGHT),
 [1] = KEYMAP( /* Paul FN */
   TRNS,  TRNS,  TRNS,  FN8,   FN9,   TRNS,  TRNS,  TRNS,  TRNS,  MUTE,  VOLD,  VOLU,
-  FN1,   TRNS,  TRNS,  HOME,  END,   TRNS,  TRNS,  TRNS,  TRNS,  MPRV,  MPLY,  MNXT,
+  MO1,   TRNS,  TRNS,  HOME,  END,   TRNS,  TRNS,  TRNS,  TRNS,  MPRV,  MPLY,  MNXT,
   TRNS,  TRNS,  TRNS,  TRNS,  TRNS,  TRNS,  TRNS,  TRNS,  TRNS,  TRNS,  UP,    TRNS,
   TRNS,  TRNS,  TRNS,  TRNS,  TRNS,      TRNS,     TRNS,  TRNS,  LEFT,  DOWN,  RGHT),
 [2] = KEYMAP( /* Paul LOWER */
   FN22,  FN10,  FN11,  FN12,  FN13,  FN14,  FN15,  FN16,  FN17,  FN18,  FN19,  BSPC,
   TRNS,  TRNS,  TRNS,  TRNS, TRNS,   TRNS,  TRNS,  FN20,  FN21,  FN23,  FN24,  FN28,
   TRNS,  F1,    F2,    F3,    F4,    F5,    F6,    F7,    F8,    F9,    F10,   TRNS,
-  TRNS,  TRNS,  TRNS,  TRNS,  FN2,       TRNS,     TRNS,  TRNS,  TRNS,  TRNS,  TRNS),
+  TRNS,  TRNS,  TRNS,  TRNS,  MO2,       TRNS,     TRNS,  TRNS,  TRNS,  TRNS,  TRNS),
 [3] = KEYMAP( /* Paul RAISE */
   GRV,   1,     2,     3,     4,     5,     6,     7,     8,     9,     0,     BSPC,
   TRNS,  TRNS,  TRNS,  TRNS, TRNS,  TRNS,   TRNS,  MINS,  EQL,   LBRC,  RBRC,  BSLS,
   TRNS,  F11,   F12,   F13,   F14,   F15,   F16,   F17,   F18,   F19,   F20,   TRNS,
-  TRNS,  TRNS,  TRNS,  TRNS,  TRNS,      TRNS,     FN3,   TRNS,  TRNS,  TRNS,  TRNS),
+  TRNS,  TRNS,  TRNS,  TRNS,  TRNS,      TRNS,     MO3,   TRNS,  TRNS,  TRNS,  TRNS),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(1),  // to Fn1 overlay (FN)
-    [2] = ACTION_LAYER_MOMENTARY(2),  // to Fn2 overlay (LOWER)
-    [3] = ACTION_LAYER_MOMENTARY(3),  // to Fn3 overlay (RAISE)
-
     [8]  = ACTION_MODS_KEY(MOD_LSFT, KC_HOME),
     [9]  = ACTION_MODS_KEY(MOD_LSFT, KC_END),
     [10] = ACTION_MODS_KEY(MOD_LSFT, KC_1),

keyboards/planck/old_keymap_files/common_keymaps/keymap_reed.c

@@ -1,5 +1,8 @@
 #include "keymap.h"
 
+#define KC_MO2 MO(2)
+#define KC_MO3 MO(3)
+
 /*
  * BUILD:
  * Simply run the command below in the keyboards/planck directory
@@ -23,30 +26,27 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   TAB,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, QUOT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, FN5,
-  LCTL, CAPS, LALT, LGUI, FN2, FN7,  SPC,  FN1,   LEFT, DOWN, UP,  RGHT),
+  LCTL, CAPS, LALT, LGUI, MO3, FN7,  SPC,  MO2,   LEFT, DOWN, UP,  RGHT),
 
 [1] = KEYMAP_GRID( /* Reed EXTREME GAMING */
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   TAB,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, QUOT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, FN5,
-  LCTL, 1,    2,    3,    4,   SPC,  FN2,  FN1,   LEFT, DOWN, UP,  RGHT),
+  LCTL, 1,    2,    3,    4,   SPC,  MO3,  MO2,   LEFT, DOWN, UP,  RGHT),
 
 [2] = KEYMAP_GRID( /* Reed RAISE */
   GRV,  1,    2,    3,    4,    5,    6,    7,    8,    9,    0,    BSPC,
   TRNS, FN3, FN4, PAUSE, TRNS, TRNS, TRNS, MINS, EQL,  LBRC, RBRC,  BSLS,
   TRNS, F1,   F2,    F3,   F4,   F5,   F6,   F7,  F8,    F9,  F10,  TRNS,
-  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, FN1, MNXT, VOLD, VOLU, MPLY),
+  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, MO2, MNXT, VOLD, VOLU, MPLY),
 
 [3] = KEYMAP_GRID( /* Reed LOWER */
   TRNS,  FN10, FN11, FN12, FN13, FN14, FN15, FN16, FN17, FN18, FN19, DEL,
   TRNS,  TRNS, INS, HOME, PGUP, TRNS, TRNS, FN20, FN21, FN23, FN24, FN28,
   TRNS,  TRNS, DEL,  END, PGDN,  F11,  F12,  F13,  TRNS, VOLD, VOLU, TRNS,
-  TRNS,  TRNS, TRNS, TRNS, FN2,  TRNS, TRNS, TRNS, MPRV, MUTE, MPLY, MNXT),
+  TRNS,  TRNS, TRNS, TRNS, MO3,  TRNS, TRNS, TRNS, MPRV, MUTE, MPLY, MNXT),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to Fn overlay - RAISE
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to Fn overlay - LOWER
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 	// Actions for the tap/hold modifiers listed above

keyboards/planck/old_keymap_files/common_keymaps/keymap_sean.c

@@ -8,6 +8,10 @@ enum planck_layers {
   _ADJUST
 };
 
+#define KC_LOWR MO(_LOWER)
+#define KC_RAIS MO(_RAISE)
+#define KC_ADJS MO(_ADJUST)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 /* Dvorak
@@ -25,7 +29,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       QUOT, COMM,  DOT,    P,    Y, SLSH,  EQL,    F,    G,    C,    R,    L,
          A,    O,    E,    U,    I,  ESC, BSPC,    D,    H,    T,    N,    S,
       SCLN,    Q,    J,    K,    X,  TAB,  ENT,    B,    M,    W,    V,    Z,
-      LSFT, LCTL, LALT, LGUI,  FN1,  SPC,        FN2, LEFT, DOWN,   UP, RGHT),
+      LSFT, LCTL, LALT, LGUI,  LOWR, SPC,        RAIS,LEFT, DOWN,   UP, RGHT),
 
 /* Lower
  * ,-----------------------------------------------------------------------------------.
@@ -42,7 +46,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         F1,   F2,   F3,   F4,   F5, FN26, FN27,   F6,   F7,   F8,   F9,  F10,
          1,    2,    3,    4,    5, LBRC, RBRC,    6,    7,    8,    9,    0,
        FN23, FN25,  GRV,MINS, FN24, INS,   DEL, FN19, FN20, FN22,  EQL, BSLS,
-      TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,        FN4, HOME, PGDN, PGUP,  END),
+      TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,        ADJS,HOME, PGDN, PGUP,  END),
 
 /* Raise
  * ,-----------------------------------------------------------------------------------.
@@ -59,7 +63,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        F11,  F12,  F13,  F14,  F15,MINS,  FN24,  F16,  F17,  F18,  F19,  F20,
       FN11, FN12, FN13, FN14, FN15,  NO,    NO, FN16, FN17, FN18, FN19, FN20,
        PWR, EJCT,   NO,   NO,   NO,  NO,    NO,   NO,   NO,   NO,   NO,   NO,
-      CAPS, TRNS, TRNS, TRNS,  FN4, TRNS,        FN2,   NO,   NO,   NO,   NO),
+      CAPS, TRNS, TRNS, TRNS,  ADJS,TRNS,        RAIS,  NO,   NO,   NO,   NO),
 /* Adjust (Lower + Raise or SLower + SRaise)
  * ,-----------------------------------------------------------------------------------.
  * |      | Reset|      |      |      |      |      |      |      |      |      |      |
@@ -79,10 +83,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(_LOWER),  // to Fn overlay LOWER
-    [2] = ACTION_LAYER_MOMENTARY(_RAISE),  // to Fn overlay RAISE
     [3] = ACTION_DEFAULT_LAYER_SET(_DVRK), 
-    [4] = ACTION_LAYER_MOMENTARY(_ADJUST),  // RAISE + LOWER
     [11] = ACTION_MODS_KEY(MOD_LSFT, KC_1),     //!
     [12] = ACTION_MODS_KEY(MOD_LSFT, KC_2),     //@
     [13] = ACTION_MODS_KEY(MOD_LSFT, KC_3),     //#

keyboards/planck/old_keymap_files/common_keymaps/keymap_shane.c

@@ -3,6 +3,9 @@
 #include "action.h"
 #include "action_util.h"
 
+#define KC_MO6 MO(6)
+#define KC_MO8 MO(8)
+
 /*
   Shane's Planck Layout
   http://www.keyboard-layout-editor.com/#/layouts/015d9011102619d7695c86ffe57cf441
@@ -12,7 +15,7 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     TAB,  Q,  W,  E,  R,  T,  Y,  U,  I,  O,  P,  MINS,
     LCTL, A,  S,  D,  F,  G,  H,  J,  K,  L,  SCLN, BSPC,
     LSFT, Z,  X,  C,  V,  B,  N,  M,  COMM, DOT,  SLSH, FN5,
-    /*ALPHA*/FN3, /*HYPER*/ /*SUPER*/LGUI, /*META*/LALT, LCTL,  FN2,  FN6,  FN1,  LEFT, DOWN, UP, RGHT),
+    /*ALPHA*/FN3, /*HYPER*/ /*SUPER*/LGUI, /*META*/LALT, LCTL,  MO8,  FN6,  MO6,  LEFT, DOWN, UP, RGHT),
   [2] = KEYMAP_AND_SWAP( /* More modifiers */
     TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
     TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
@@ -72,8 +75,6 @@ void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
 
 
 const uint16_t PROGMEM fn_actions[] = {
-  [1] = ACTION_LAYER_MOMENTARY(6),  // to fist Fn overlay
-  [2] = ACTION_LAYER_MOMENTARY(8),  // to second Fn overlay
   [3] = ACTION_LAYER_TOGGLE(2), // toggle more modifiers
   [4] = ACTION_LAYER_TOGGLE(4), // toggle wasd
   [5] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_ENT),
@@ -95,4 +96,4 @@ const uint16_t PROGMEM fn_actions[] = {
   [24] = ACTION_MODS_KEY(MOD_LSFT, KC_LBRC),
   [25] = ACTION_MODS_KEY(MOD_LSFT, KC_RBRC),
   [26] = ACTION_MODS_KEY(MOD_LSFT, KC_BSLS),
-};
+};

keyboards/planck/old_keymap_files/common_keymaps/keymap_simon.c

@@ -1,11 +1,14 @@
 #include "keymap.h"
 
+#define KC_MO1 MO(1)
+#define KC_MO2 MO(2)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP( /* Jack */
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   TAB,  A,    S,    D,    F,    G,    H,    J,    K,    L,    DOT,  ENT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SCLN, DEL,
-  LCTL, ENT,  LALT, CAPS, FN2,    SPC,      FN1,  LEFT, DOWN, UP,   RGHT),
+  LCTL, ENT,  LALT, CAPS, MO2,    SPC,      MO1,  LEFT, DOWN, UP,   RGHT),
 [1] = KEYMAP( /* Jack RAISE */
   TRNS, F1,   F2,   F3,   F4,   NO,   FN11, FN9,  FN12, NO,   FN14, TRNS,
   TRNS, F5,   F6,   F7,   F8,   FN16, SLSH, MINS, EQL,  LBRC, FN8,  TRNS,
@@ -18,9 +21,6 @@ const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   TRNS, TRNS, TRNS, TRNS, TRNS,    TRNS,    TRNS, TRNS, TRNS, TRNS, TRNS),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(1),  // to Fn overlay
-    [2] = ACTION_LAYER_MOMENTARY(2),  // to Fn overlay
-
     [8]  = ACTION_MODS_KEY(MOD_LSFT, KC_SLSH),
     [9]  = ACTION_MODS_KEY(MOD_LSFT, KC_QUOT),
     [10] = ACTION_MODS_KEY(MOD_LSFT, KC_1),

keyboards/planck/old_keymap_files/common_keymaps/keymap_tim.c

@@ -1,26 +1,26 @@
 #include "keymap.h"
 
+#define KC_MO2 MO(2)
+#define KC_MO3 MO(3)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP(
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   TAB,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, ENT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, RSFT,
-  LCTL, LALT, DEL,  LGUI, FN2,    SPC,     FN1,   F2,   F5,   F9,   F12),
+  LCTL, LALT, DEL,  LGUI, MO3,    SPC,     MO2,   F2,   F5,   F9,   F12),
 [2] = KEYMAP( /* RAISE */
   TRNS,  1,    2,    3,    4,    5,    6,    7,    8,    9,    0,   BSPC,
   GRV,  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, MINS, EQL,  LBRC, RBRC, BSLS,
   TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, QUOT, FN29, TRNS, TRNS,
-  TRNS, TRNS, TRNS, TRNS, TRNS,    TRNS,    FN1,  TRNS, TRNS, TRNS, TRNS),
+  TRNS, TRNS, TRNS, TRNS, TRNS,    TRNS,    MO2,  TRNS, TRNS, TRNS, TRNS),
 [3] = KEYMAP( /* LOWER */
   TRNS, FN10, FN11, FN12, FN13, FN14, FN15, FN16, FN17, FN18, FN19, BSPC,
   FN22, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, FN20, FN21, FN23, FN24, FN28,
   TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, QUOT, FN29, TRNS, TRNS,
-  TRNS, TRNS, TRNS, TRNS, FN2,    TRNS,     TRNS, TRNS, TRNS, TRNS, TRNS),
+  TRNS, TRNS, TRNS, TRNS, MO3,    TRNS,     TRNS, TRNS, TRNS, TRNS, TRNS),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to Fn overlay
-    [2] = ACTION_LAYER_MOMENTARY(3),  // to Fn overlay
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),  
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

keyboards/planck/old_keymap_files/common_keymaps/keymap_wilba.c

@@ -1,31 +1,31 @@
 #include "keymap.h"
 
+#define KC_MO2 MO(2)
+#define KC_MO3 MO(3)
+
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [0] = KEYMAP( /* Wilba */
   FN27, FN28, FN29, E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   TAB,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, QUOT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, ENT,
-  LCTL, LGUI, LALT, RSFT, FN1,  SPC,        FN2,  LEFT, DOWN, UP,   RGHT),
+  LCTL, LGUI, LALT, RSFT, MO2,  SPC,        MO3,  LEFT, DOWN, UP,   RGHT),
 [1] = KEYMAP( /* Wilba Alternate */
   ESC,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    BSPC,
   TAB,  A,    S,    D,    F,    G,    H,    J,    K,    L,    SCLN, QUOT,
   LSFT, Z,    X,    C,    V,    B,    N,    M,    COMM, DOT,  SLSH, ENT,
-  LCTL, LGUI, LALT, RSFT, FN1,  SPC,        FN2,  LEFT, DOWN, UP,   RGHT),
+  LCTL, LGUI, LALT, RSFT, MO2,  SPC,        MO3,  LEFT, DOWN, UP,   RGHT),
 [2] = KEYMAP( /* Wilba LOWER */
   TRNS, 1,    2,    3,    4,    5,    6,    7,    8,    9,    0,    TRNS,
   TRNS, F11,  F12,  LBRC, RBRC, FN20, EQL,  FN23, FN24, MINS, FN21, TRNS,
   TRNS, BSLS, GRV,  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
-  TRNS, TRNS, TRNS, TRNS, FN1,  TRNS,       TRNS, MNXT, VOLD, VOLU, MPLY),
+  TRNS, TRNS, TRNS, TRNS, MO2,  TRNS,       TRNS, MNXT, VOLD, VOLU, MPLY),
 [3] = KEYMAP( /* Wilba RAISE */
   TRNS, FN10, FN11, FN12, FN13, FN14, FN15, FN16, FN17, FN18, FN19, TRNS,
   TRNS, F1,   F2,   F3,   F4,   F5,   F6,   F7,   F8,   F9,   F10,  TRNS,  
   TRNS, FN25, FN22, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,
-  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,       FN2,  TRNS, TRNS, TRNS, TRNS),
+  TRNS, TRNS, TRNS, TRNS, TRNS, TRNS,       MO3,  TRNS, TRNS, TRNS, TRNS),
 };
 const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(2),  // LOWER
-    [2] = ACTION_LAYER_MOMENTARY(3),  // RAISE
-
     [3] = ACTION_DEFAULT_LAYER_SET(0),  
     [4] = ACTION_DEFAULT_LAYER_SET(1),
 

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

@@ -31,14 +31,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define KC_SPACEFN KC_FN0
 #define KC_OSLS KC_FN3
 #define KC_GMLK KC_FN1
-#define KC_FUNC KC_FN2
+#define KC_FUNC MO(2)
 #define MICMUTE RCTL(KC_LCTL)
 
 enum function_codes {
     F_SPACEFN = 0,
     F_OSLS = 3,
     F_GMLK = 1,
-    F_FUNC = 2
 };
 
 enum layer_names {
@@ -154,7 +153,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 const uint16_t PROGMEM fn_actions[] = {
     [F_SPACEFN] = ACTION_LAYER_TAP_KEY(2, KC_SPACE),    // SpaceFn layout 1
     [F_GMLK] = ACTION_LAYER_TOGGLE(1),                  // Disable SpaceFn and Oneshot Shift
-    [F_FUNC] = ACTION_LAYER_MOMENTARY(2),               // SpaceFn layout 1
     [F_OSLS] = ACTION_MODS_ONESHOT(MOD_LSFT)            // Oneshot Leftshift
 };
 

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

@@ -1,5 +1,9 @@
 #include QMK_KEYBOARD_H
 
+#define KC_MO4 MO(4)
+#define KC_MO6 MO(6)
+#define KC_MO7 MO(7)
+
 /*
  * Hasu
  */
@@ -22,7 +26,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB,    Q,    W,   E,   R,   T,   Y,   U,   I,    O,    P, LBRC, RBRC, BSLS,       \
         CAPS,    A,    S,   D,   F,   G,   H,   J,   K,    L,  FN2, QUOT,   NO,  ENT,       \
         LSFT,   NO,    Z,   X,   C,   V,   B,   N,   M, COMM,  DOT,  FN1,   NO,  FN9,   NO, \
-        LCTL, LGUI, LALT,                SPC,                 RALT,  FN3,  FN3,  FN0),
+        LCTL, LGUI, LALT,                SPC,                 RALT,  MO6,  MO6,  MO4),
     /* Keymap 1: colemak
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │GRAVE│  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │  0  │  -  │  =  │▒▒▒▒▒│BKSPC│
@@ -41,7 +45,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB,    Q,    W,   F,   P,   G,   J,   L,   U,    Y, SCLN, LBRC, RBRC, BSLS,      \
         BSPC,    A,    R,   S,   T,   D,   H,   N,   E,    I,    O, QUOT,   NO,  ENT,      \
         LSFT,   NO,    Z,   X,   C,   V,   B,   K,   M, COMM,  DOT, SLSH,   NO, RSFT,  NO, \
-        LCTL, LGUI, LALT,                SPC,                 RALT, RGUI,  APP,  FN0),
+        LCTL, LGUI, LALT,                SPC,                 RALT, RGUI,  APP,  MO4),
     /* Keymap 2: dvorak
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │GRAVE│  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │  0  │  [  │  ]  │▒▒▒▒▒│BKSPC│
@@ -60,7 +64,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB, QUOT, COMM,  DOT,   P,   Y,   F,   G,   C,   R,   L, SLSH,  EQL, BSLS,       \
         CAPS,    A,    O,    E,   U,   I,   D,   H,   T,   N,   S, MINS,   NO,  ENT,       \
         LSFT,   NO, SCLN,    Q,   J,   K,   X,   B,   M,   W,   V,    Z,   NO, RSFT,   NO, \
-        LCTL, LGUI, LALT,                 SPC,               RALT, RGUI,  APP,  FN0),
+        LCTL, LGUI, LALT,                 SPC,               RALT, RGUI,  APP,  MO4),
     /* Keymap 3: workman
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │GRAVE│  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │  0  │  -  │  =  │▒▒▒▒▒│BKSPC│
@@ -79,7 +83,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB,    Q,    D,   R,   W,   B,   J,   F,   U,    P, SCLN, LBRC, RBRC, BSLS,       \
         BSPC,    A,    S,   H,   T,   G,   Y,   N,   E,    O,    I, QUOT,   NO,  ENT,       \
         LSFT,   NO,    Z,   X,   M,   C,   V,   K,   L, COMM,  DOT, SLSH,   NO, RSFT,   NO, \
-        LCTL, LGUI, LALT,                SPC,                 RALT, RGUI,  APP,  FN0),
+        LCTL, LGUI, LALT,                SPC,                 RALT, RGUI,  APP,  MO4),
     /* Overlay 4: HHKB mode
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │Grave│ F1  │ F2  │ F3  │ F4  │ F5  │ F6  │ F7  │ F8  │ F9  │ F10 │ F11 │ F12 │▒▒▒▒▒│ Del │
@@ -98,7 +102,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         CAPS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, PSCR, SLCK, PAUS,   UP, TRNS,  INS,       \
         LCTL, VOLD, VOLU, MUTE, TRNS, TRNS, PAST, PSLS, HOME, PGUP, LEFT, RGHT, TRNS,  ENT,       \
         LSFT, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, PPLS, PMNS,  END, PGDN, DOWN, TRNS, RSFT, TRNS, \
-        LCTL, LGUI, LALT,                    SPC,                   RALT, RGUI,  FN4, TRNS),
+        LCTL, LGUI, LALT,                    SPC,                   RALT, RGUI,  MO7, TRNS),
     /* Overlay 5: Vi mode (Slash)
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │Grave│ F1  │ F2  │ F3  │ F4  │ F5  │ F6  │ F7  │ F8  │ F9  │ F10 │ F11 │ F12 │▒▒▒▒▒│BkSpc│
@@ -169,11 +173,8 @@ Lw: set Workman layout
  * Fn action definition
  */
 const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(4),
     [1] = ACTION_LAYER_TAP_KEY(5, KC_SLASH),
     [2] = ACTION_LAYER_TAP_KEY(6, KC_SCLN),
-    [3] = ACTION_LAYER_MOMENTARY(6),
-    [4] = ACTION_LAYER_MOMENTARY(7),   // to Layout selector
     [5] = ACTION_DEFAULT_LAYER_SET(0),  // set qwerty layout
     [6] = ACTION_DEFAULT_LAYER_SET(1),  // set colemak layout
     [7] = ACTION_DEFAULT_LAYER_SET(2),  // set dvorak layout

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

@@ -1,5 +1,7 @@
 #include QMK_KEYBOARD_H
 
+#define KC_MO1 MO(1)
+
 /*
  * HHKB Layout
  */
@@ -21,7 +23,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         ESC,    1,    2,   3,   4,   5,   6,   7,   8,    9,    0, MINS,  EQL, BSLS, GRV, \
         TAB,    Q,    W,   E,   R,   T,   Y,   U,   I,    O,    P, LBRC, RBRC, BSPC,      \
         LCTL,    A,    S,   D,   F,   G,   H,   J,   K,    L, SCLN, QUOT,   NO,  ENT,      \
-        LSFT,   NO,    Z,   X,   C,   V,   B,   N,   M, COMM,  DOT, SLSH,   NO, RSFT, FN0, \
+        LSFT,   NO,    Z,   X,   C,   V,   B,   N,   M, COMM,  DOT, SLSH,   NO, RSFT, MO1, \
         NO, LGUI, LALT,                SPC,                   NO, RALT, RGUI,   NO),
     /* 1: HHKB Fn layer
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
@@ -43,10 +45,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, PPLS, PMNS,  END, PGDN, DOWN,   NO, TRNS, TRNS, \
        TRNS, TRNS, TRNS,                   TRNS,                   TRNS, TRNS, TRNS, TRNS),
 };
-
-/*
- * Fn action definition
- */
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),
-};

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

@@ -16,6 +16,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include QMK_KEYBOARD_H
 
+#define KC_MO1 MO(1)
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 	/* Layout 0: Default Layer
 	* ,-----------------------------------------------------------.
@@ -35,7 +37,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 		TAB,  Q,    W,    E,    R,    T,    Y,    U,    I,    O,    P,    LBRC, RBRC, BSLS, \
 		LCTL, A,    S,    D,    F,    G,    H,    J,    K,    L, SCLN,    QUOT, NUHS, ENT,  \
 		LSFT, NUBS, Z,    X,    C,    V,    B,    N,    M, COMM,  DOT,    SLSH,   NO, RSFT, NO, \
-		FN1,  LGUI, LALT,             FN0,                          RALT, RGUI, APP,  RCTL),
+		MO1,  LGUI, LALT,             FN0,                          RALT, RGUI, APP,  RCTL),
 
 	/* Layout 1: Function Layer
 	* ,-----------------------------------------------------------.
@@ -63,7 +65,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 */
 const uint16_t PROGMEM fn_actions[] = {
 	[0] = ACTION_LAYER_TAP_KEY(1, KC_SPACE),    /* SpaceFn layout 1 */
-	[1] = ACTION_LAYER_MOMENTARY(1),            /* Momentary layout 1 */
 	[2] = ACTION_MODS_KEY(MOD_LSFT, KC_DEL),    /* Cut  */
 	[3] = ACTION_MODS_KEY(MOD_LCTL, KC_INS),    /* Copy  */
 	[4] = ACTION_MODS_KEY(MOD_LSFT, KC_INS),    /* Paste */

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

@@ -1,5 +1,8 @@
 #include QMK_KEYBOARD_H
 
+#define KC_MO6 MO(6)
+#define KC_MO7 MO(7)
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     /* 0: qwerty
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
@@ -19,7 +22,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB,    Q,    W,   E,   R,   T,   Y,   U,   I,    O,    P, LBRC, RBRC, BSLS,       \
         CAPS,    A,    S,   D,   F,   G,   H,   J,   K,    L, SCLN, QUOT,   NO,  ENT,       \
         LSFT,   NO,    Z,   X,   C,   V,   B,   N,   M, COMM,  DOT, SLSH,   NO, RSFT,   NO, \
-        LCTL, LGUI, LALT,                SPC,                  FN0, RGUI,  APP, RCTL),
+        LCTL, LGUI, LALT,                SPC,                  MO6, RGUI,  APP, RCTL),
     /* 1: colemak
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │GRAVE│  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │  0  │  -  │  =  │▒▒▒▒▒│BKSPC│
@@ -38,7 +41,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB,    Q,    W,   F,   P,   G,   J,   L,   U,    Y, SCLN, LBRC, RBRC, BSLS,      \
         BSPC,    A,    R,   S,   T,   D,   H,   N,   E,    I,    O, QUOT,   NO,  ENT,      \
         LSFT,   NO,    Z,   X,   C,   V,   B,   K,   M, COMM,  DOT, SLSH,   NO, RSFT,  NO, \
-        LCTL, LGUI, LALT,                SPC,                  FN0, RGUI,  APP, RCTL),
+        LCTL, LGUI, LALT,                SPC,                  MO6, RGUI,  APP, RCTL),
     /* 2: dvorak
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │GRAVE│  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │  0  │  [  │  ]  │▒▒▒▒▒│BKSPC│
@@ -57,7 +60,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB, QUOT, COMM,  DOT,   P,   Y,   F,   G,   C,   R,   L, SLSH,  EQL, BSLS,       \
         CAPS,    A,    O,    E,   U,   I,   D,   H,   T,   N,   S, MINS,   NO,  ENT,       \
         LSFT,   NO, SCLN,    Q,   J,   K,   X,   B,   M,   W,   V,    Z,   NO, RSFT,   NO, \
-        LCTL, LGUI, LALT,                 SPC,                FN0, RGUI,  APP, RCTL),
+        LCTL, LGUI, LALT,                 SPC,                MO6, RGUI,  APP, RCTL),
     /* 3: workman
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │GRAVE│  1  │  2  │  3  │  4  │  5  │  6  │  7  │  8  │  9  │  0  │  -  │  =  │▒▒▒▒▒│BKSPC│
@@ -76,7 +79,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
          TAB,    Q,    D,   R,   W,   B,   J,   F,   U,    P, SCLN, LBRC, RBRC, BSLS,       \
         BSPC,    A,    S,   H,   T,   G,   Y,   N,   E,    O,    I, QUOT,   NO,  ENT,       \
         LSFT,   NO,    Z,   X,   M,   C,   V,   K,   L, COMM,  DOT, SLSH,   NO, RSFT,   NO, \
-        LCTL, LGUI, LALT,                SPC,                  FN0, RGUI,  APP, RCTL),
+        LCTL, LGUI, LALT,                SPC,                  MO6, RGUI,  APP, RCTL),
     /* 4: Poker with Arrow
 ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
 │     │     │     │     │     │     │     │     │     │     │     │     │     │▒▒▒▒▒│     │
@@ -136,7 +139,7 @@ FnS: toggle Arrow overlay
     */
     LAYOUT_kc(
         ESC,   F1,   F2,   F3,   F4,   F5,   F6,   F7,   F8,   F9,  F10,  F11,  F12, TRNS, TRNS, \
-        TRNS,  FN2,   UP, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, CALC, TRNS, HOME,  INS,  FN4,       \
+        TRNS,  FN2,   UP, TRNS, TRNS, TRNS, TRNS, TRNS, TRNS, CALC, TRNS, HOME,  INS,  MO7,       \
         TRNS, LEFT, DOWN, RGHT, TRNS, TRNS, PSCR, SLCK, PAUS, TRNS,  FN3,  END, TRNS, TRNS,       \
         TRNS, TRNS,  DEL, TRNS, WHOM, MUTE, VOLU, VOLD, TRNS, PGUP, PGDN,  DEL, TRNS, TRNS, TRNS, \
         TRNS, TRNS, TRNS,                    FN1,                   TRNS, TRNS, TRNS, TRNS),
@@ -168,11 +171,9 @@ Lw: set Workman layout
 };
 const uint16_t PROGMEM fn_actions[] = {
     /* Poker Layout */
-    [0] = ACTION_LAYER_MOMENTARY(6),  // to Fn overlay
     [1] = ACTION_LAYER_TOGGLE(4),     // toggle arrow overlay
     [2] = ACTION_LAYER_TOGGLE(5),     // toggle Esc overlay
     [3] = ACTION_MODS_KEY(MOD_RCTL|MOD_RSFT, KC_ESC), // Task(RControl,RShift+Esc)
-    [4] = ACTION_LAYER_MOMENTARY(7),  // to Layout selector
     [5] = ACTION_DEFAULT_LAYER_SET(0),  // set qwerty layout
     [6] = ACTION_DEFAULT_LAYER_SET(1),  // set colemak layout
     [7] = ACTION_DEFAULT_LAYER_SET(2),  // set dvorak layout

keyboards/sentraq/s65_x/keymaps/kelorean/keymap.c

@@ -140,7 +140,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_LAYER_MOMENTARY(_FL),        // Momentary Fn overlay
   [1] = ACTION_LAYER_TOGGLE(_CM),           //Toggle Colemak Layer overlay
   [2] = ACTION_LAYER_TOGGLE(_DV),           // Toggle Dvorak Layer overlay
   [3] = ACTION_LAYER_TOGGLE(_AL),           // Toggle Arrow Layer overlay

keyboards/sentraq/s65_x/keymaps/nall/keymap.c

@@ -94,7 +94,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-  [0] = ACTION_LAYER_MOMENTARY(_FL),       // Momentary Fn overlay
   [1] = ACTION_LAYER_TOGGLE(_AL),          // Toggle Arrow Layer overlay
   [2] = ACTION_LAYER_TAP_KEY(_FL, KC_CAPS),// Tap to toggle caps lock and hold to activate function layer
   [3] = ACTION_LAYER_TOGGLE(_UL),          // Toggle Underglow Layer overlay

keyboards/whitefox/keymaps/kim-kim/keymap.c

@@ -41,7 +41,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_LCTRL, 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,XXXXXXX,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_LALT,KC_FN0,KC_LGUI,               KC_SPC,           KC_RGUI,KC_RALT, XXXXXXX,     KC_LEFT,KC_DOWN,KC_RGHT \
+        KC_LALT,MO(1), KC_LGUI,               KC_SPC,           KC_RGUI,KC_RALT, XXXXXXX,     KC_LEFT,KC_DOWN,KC_RGHT \
     ),
     [1] = LAYOUT( \
         _______,KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10, KC_F11, KC_F12, _______,_______,_______,\
@@ -57,8 +57,6 @@ const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 #define ACTION_LEDS_GAME 2
 
 const uint16_t fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),
-    [1] = ACTION_LAYER_MOMENTARY(2),
     [2] = ACTION_FUNCTION(ACTION_LEDS_ALL),
     [3] = ACTION_FUNCTION(ACTION_LEDS_GAME),
 

keyboards/whitefox/keymaps/matt3o/keymap.c

@@ -33,9 +33,9 @@ const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     [0] = LAYOUT( \
         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_BSLS,KC_GRV, KC_MUTE,\
         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_FN0, 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,\
+        MO(1),  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_FN1, KC_RCTL,     KC_LEFT,KC_DOWN,KC_RGHT \
+        KC_LCTL,KC_LGUI,KC_LALT,               KC_SPC,           KC_RALT,MO(2),  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_TRNS,\
@@ -58,8 +58,6 @@ const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 #define ACTION_LEDS_GAME 2
 
 const uint16_t fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),
-    [1] = ACTION_LAYER_MOMENTARY(2),
     [2] = ACTION_FUNCTION(ACTION_LEDS_ALL),
     [3] = ACTION_FUNCTION(ACTION_LEDS_GAME),
 

keyboards/winkeyless/bface/keymaps/kpeatt/keymap.c

@@ -73,7 +73,3 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         ______,______,______,                ______,                        ______,______,______,______
     ), // */
 };
-
-const uint16_t PROGMEM fn_actions[] = {
-	[0]  = ACTION_LAYER_MOMENTARY(1),
-};

keyboards/xd60/keymaps/Jos/keymap.c

@@ -38,7 +38,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_GRAVE, 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_DEL,    \
       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_ESC,   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_LGUI, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM,  KC_DOT,   KC_SLSH,   KC_RSFT,  KC_UP,     F(0),      \
+      KC_LSFT,  KC_LGUI, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM,  KC_DOT,   KC_SLSH,   KC_RSFT,  KC_UP,     MO(1),     \
       KC_LCTL,  TD(0),   KC_LALT,                            KC_SPC ,                             KC_RALT,  KC_RCTRL,  KC_LEFT,  KC_DOWN,   KC_RIGHT),
                                                                                                                                            
   // 1: Function 1 Layers                                                                                                                  
@@ -76,8 +76,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 // Custom Actions
 const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),  // to Fn1 layer
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to GUI/Fn2 layer
     [2] = ACTION_LAYER_TOGGLE(3),     // to Fn3/Num toggle layer
 };
 

keyboards/xd60/keymaps/birkir/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_SLSH, KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_NO,    KC_RSFT, KC_UP,    TG(2),     \
-    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
@@ -18,7 +18,7 @@ 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,  TG(2),     \
-    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
   ),
 
   // 2: Cool Layer
@@ -27,15 +27,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,  TG(2),       \
-    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/edulpn/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_NO, KC_RSHIFT,  KC_NO,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RALT,    F(0),  KC_NO, KC_RGUI,    KC_RCTL),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          KC_RALT,    MO(1), KC_NO, KC_RGUI,    KC_RCTL),
 
   // 1: Function Layer
   LAYOUT_all(
@@ -17,15 +17,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,    KC_NO,    KC_UP,    KC_NO,    KC_INSERT,  KC_HOME,  KC_PGUP,  RGB_TOG,  RGB_MOD,  RGB_HUI,  RGB_HUD,  KC_NO,    KC_NO,              KC_NO,    \
       KC_NO,    KC_LEFT,  KC_DOWN,  KC_RIGHT, KC_DEL,     KC_END,   KC_PGDN,  RGB_SAI,  RGB_SAD,  RGB_VAI,  RGB_VAD,  KC_NO,    KC_NO,              KC_ENT,    \
       KC_LSFT,  KC_NO,    KC_MPRV,  KC_MPLY,  KC_MNXT,    KC_VOLD,  KC_VOLU,  KC_MUTE,  KC_NO,    KC_NO,    KC_NO,    KC_NO,    KC_RSFT,  KC_NO,    KC_NO,      \
-      KC_LCTL,  KC_LGUI,  KC_LALT,                           KC_SPC,                                      KC_RALT,  F(0),     KC_NO,    KC_RGUI,  KC_RCTL),
+      KC_LCTL,  KC_LGUI,  KC_LALT,                           KC_SPC,                                      KC_RALT,  MO(1),    KC_NO,    KC_RGUI,  KC_RCTL),
 
 };
 
-// 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/edulpn64/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,                          F(0)   , KC_RCTL,  KC_LEFT, KC_DOWN,  KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          MO(1),   KC_RCTL,  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_TAB,  KC_NO,   KC_NO,   KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_PSCR,KC_SLCK,KC_PAUS, RGB_RMOD,RGB_MOD,  RGB_VAD,           RGB_VAI,   \
       KC_CAPS, KC_NO,   KC_NO,   KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_INS, KC_HOME,KC_PGUP, RGB_HUD, RGB_HUI,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_NO,   KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_END,  KC_PGDN, KC_NO,    KC_RSFT, KC_UP,    KC_DEL,    \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          F(0),    KC_RCTRL, KC_LEFT, KC_DOWN,  KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          MO(1),   KC_RCTRL, KC_LEFT, KC_DOWN,  KC_RIGHT),
 
 };
 
-// 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/kmontag42/keymap.c

@@ -10,7 +10,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_ESC,  KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_DOT,           KC_ENT,    \
       KC_LSPO, KC_NO,   KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_SLSH,  KC_NO,   KC_RSPC, KC_RGUI,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          F(0),    KC_LEFT,  KC_DOWN, KC_UP,   KC_RIGHT),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          MO(1),   KC_LEFT,  KC_DOWN, KC_UP,   KC_RIGHT),
 
   // 1: Function Layer
   LAYOUT_all(
@@ -18,15 +18,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,   KC_NO, \
       KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,   KC_NO, \
       KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,   KC_NO,  KC_NO,      \
-      KC_NO,   KC_NO,   KC_NO,                            KC_NO,                           F(0),    KC_NO,    KC_NO,   KC_NO,  KC_NO),
+      KC_NO,   KC_NO,   KC_NO,                            KC_NO,                           MO(1),   KC_NO,    KC_NO,   KC_NO,  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) {
 

keyboards/xd60/keymaps/krusli/keymap.c

@@ -21,11 +21,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       _______, _______, _______,                          _______,                              _______, _______, _______, _______, _______),
 };
 
-// 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/split_bksp_arrows/keymap.c

@@ -19,7 +19,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   LAYOUT_all(
       KC_GESC, 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_BSLS,  KC_INS,    \
       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,   \
-      F(0),    KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_TRNS,           KC_ENT,    \
+      MO(1),   KC_A,    KC_S,    KC_D,    KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN, KC_QUOT,  KC_TRNS,           KC_ENT,    \
       KC_LSFT, KC_TRNS, KC_Z,    KC_X,    KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM, KC_DOT,  KC_SLSH,  KC_SLSH, KC_UP,    KC_DEL,    \
       KC_LCTL, KC_LALT, KC_LGUI,                          KC_SPC,                          KC_CAPS, KC_RSFT,  KC_LEFT, KC_DOWN,  KC_RIGHT),
 
@@ -33,9 +33,18 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 };
 
-// Custom Actions
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),  // to Function Layer
+// Macros
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+
+  // MACRODOWN only works in this function
+  switch(id) {
+    case 0:
+      if (record->event.pressed) { register_code(KC_RSFT); }
+      else { unregister_code(KC_RSFT); }
+      break;
+  }
+
+  return MACRO_NONE;
 };
 
 // Loop

keyboards/xd60/keymaps/stanleylai/keymap.c

@@ -7,15 +7,15 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   LAYOUT_all(
       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_BSLS,  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,   \
-      F(0),    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,  F(1),    KC_UP,    KC_DEL,    \
+      MO(1),   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,  MO(2),   KC_UP,    KC_DEL,    \
       KC_LCTL, KC_LALT, KC_LGUI,                          KC_SPC,                          KC_RGUI, KC_RALT,  KC_LEFT, KC_DOWN,  KC_RIGHT),
 
   // 1: Function Layer
   LAYOUT_all(
       RESET,   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_F13,   KC_F14,    \
       KC_CAPS, KC_MPRV, KC_UP,   KC_MNXT, KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,             KC_DEL,    \
-      F(0),    KC_LEFT, KC_DOWN, KC_RIGHT,KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,             KC_ENT,    \
+      MO(1),   KC_LEFT, KC_DOWN, KC_RIGHT,KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_VOLD, KC_MUTE, KC_VOLU,KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,   KC_PGUP,  KC_INS,    \
       KC_LCTL, KC_LALT, KC_LGUI,                          KC_MPLY,                         KC_RGUI, KC_RALT,  KC_HOME, KC_PGDOWN,KC_END),
 
@@ -24,17 +24,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   BL_TOGG, BL_STEP, KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,   KC_NO,    KC_NO,    \
       KC_NO,   RGB_TOG, RGB_MOD, KC_NO,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,             KC_NO,    \
       KC_NO,   RGB_HUI, RGB_SAI, RGB_VAI, KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    KC_NO,             KC_NO,    \
-      KC_NO,   KC_NO,   RGB_HUD, RGB_SAD, RGB_VAD,KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    F(1),    KC_NO,    KC_NO,    \
+      KC_NO,   KC_NO,   RGB_HUD, RGB_SAD, RGB_VAD,KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,   KC_NO,   KC_NO,    MO(2),   KC_NO,    KC_NO,    \
       KC_NO,   KC_NO,   KC_NO,                            KC_NO,                           KC_NO,   KC_NO,    KC_NO,   KC_NO,    KC_NO),
 
 };
 
-// Custom Actions
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_LAYER_MOMENTARY(1),  // to Function Layer
-    [1] = ACTION_LAYER_MOMENTARY(2),  // to RGB Layer
-};
-
 // Macros
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 

keyboards/xd60/keymaps/supercoffee/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_NO, KC_RSHIFT,  KC_NO,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          F(0),    KC_RALT,  KC_NO, KC_RGUI,    KC_RCTL),
+      KC_LCTL, KC_LGUI, KC_LALT,                          KC_SPC,                          MO(1),   KC_RALT,  KC_NO, KC_RGUI,    KC_RCTL),
 
   // 1: Function Layer
   LAYOUT_all(
@@ -17,15 +17,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       KC_NO,   KC_NO,   KC_UP,   KC_END,  KC_NO,  KC_NO,   KC_CALC, KC_PGUP, KC_NO, KC_NO,    KC_NO,  KC_NO,    KC_NO,             KC_DEL,    \
       KC_NO,   KC_LEFT, KC_DOWN, KC_RIGHT,KC_NO,  KC_NO,   KC_HOME, KC_PGDN, KC_NO,  KC_NO,   KC_NO,  KC_PGUP,  KC_NO,             KC_ENT,    \
       KC_LSFT, KC_NO,   KC_NO,   KC_DEL,  BL_STEP,KC_NO,   KC_NO,   KC_VOLD, KC_VOLU,KC_MUTE, KC_NO,  KC_PGDN,  KC_RSFT, KC_NO,    KC_NO,      \
-      KC_LCTL, KC_LGUI, KC_LALT,                           KC_SPC,                            F(0),   KC_RALT,  KC_NO, KC_RGUI,    KC_RCTL),
+      KC_LCTL, KC_LGUI, KC_LALT,                           KC_SPC,                            MO(1),  KC_RALT,  KC_NO, KC_RGUI,    KC_RCTL),
 
 };
 
-// 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) {
 

layouts/community/60_iso/unxmaal/keymap.c

@@ -108,7 +108,6 @@ enum function_id {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    [0]  = ACTION_LAYER_MOMENTARY(2),  // Momentary Fn overlay
     [1]  = ACTION_LAYER_TOGGLE(1),     // Toggle Arrow Layer overlay
     [2]  = ACTION_LAYER_TAP_KEY(2, KC_CAPS), // Tap to toggle caps lock and hold to activate function layer
     [3]  = ACTION_LAYER_TOGGLE(3),     // Toggle Underglow Layer overlay

layouts/community/ergodox/guni/keymap.c

@@ -138,7 +138,6 @@ const uint16_t PROGMEM fn_actions[] = {
 	//[29]  =  ACTION_LAYER_TOGGLE(4),
         [29]  = ACTION_MODS_TAP_KEY(MOD_RSFT,KC_ESC),
 	[30]  =  ACTION_LAYER_TAP_KEY(1, KC_QUOT),
-        [31]  =  ACTION_LAYER_MOMENTARY(2),
 	//[]  =  ACTION_LAYER_TAP_KEY(4, KC_S),
 };
 

layouts/community/ergodox/ishigoya-jp/keymap.c

@@ -144,7 +144,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_RCTL,       KC_LGUI,      KC_LALT,JP_UNDS,KC_LCTL,
                                               KC_BTN3,  KC_DEL,
                                                               KC_NO,
-                                               KC_SPC,KC_LSFT,F(1),
+                                               KC_SPC,KC_LSFT,MO(NUM),
         // right hand
              LCTL(KC_Z), KC_NO, LSFT(KC_4),      JP_AT,   KC_LEFT,       KC_UP,   KC_RIGHT,
              KC_PGUP,    KC_J,       KC_F,       KC_U,       KC_P,       KC_DOWN, LSFT(KC_3),
@@ -187,7 +187,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
                                            KC_TRNS, KC_TRNS,
                                                     KC_NO,
-                                  M(SHIFT), M(JPFN), F(1),
+                                  M(SHIFT), M(JPFN), MO(NUM),
     // right hand
        KC_TRNS,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
        KC_TRNS,  M(JPFU), M(JPSE), M(JPTSU), M(JPKU), KC_TRNS, KC_TRNS,
@@ -415,10 +415,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ),
 };
 
-const uint16_t PROGMEM fn_actions[] = {
-    [1] = ACTION_LAYER_MOMENTARY(NUM)                // FN1 - Momentary Layer 6 (Numbers)
-};
-
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
 	

layouts/community/ergodox/osx_whiskey_tango_foxtrot_capslock/keymap.c

@@ -47,7 +47,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_TAB,     M(KC_Q),  M(KC_W), M(KC_E), M(KC_R), M(KC_T), KC_LBRC,
         M(KC_CAPS), M(KC_A),  M(KC_S), M(KC_D), M(KC_F), M(KC_G),
-        KC_LSFT,    M(KC_Z),  M(KC_X), M(KC_C), M(KC_V), M(KC_B), KC_FN0,
+        KC_LSFT,    M(KC_Z),  M(KC_X), M(KC_C), M(KC_V), M(KC_B), MO(SYMB),
         KC_LCTL,    KC_LALT,  KC_LGUI, KC_LEFT, KC_RGHT,
                                                          KC_TRNS, KC_FN1,
                                                                   KC_HOME,
@@ -56,7 +56,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_GRV,     KC_7,     KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,
         KC_RBRC,    M(KC_Y),  M(KC_U), M(KC_I), M(KC_O), M(KC_P), KC_BSLS,
                     M(KC_H),  M(KC_J), M(KC_K), M(KC_L), KC_SCLN, KC_QUOT,
-        KC_FN0,     M(KC_N),  M(KC_M), KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
+        MO(SYMB),   M(KC_N),  M(KC_M), KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
                               KC_DOWN, KC_UP,   KC_RCTL, KC_RGUI, KC_RALT,
         KC_RALT,    KC_RCTL,
         KC_PGUP,
@@ -148,12 +148,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 const uint16_t PROGMEM fn_actions[] = {
-    ACTION_LAYER_MOMENTARY(SYMB),               // FN0 - Momentary Layer 1 (Symbols)
-    ACTION_LAYER_ON(SYMB,ON_RELEASE),           // FN1 - Enable Layer 1 (Symbols)
-    ACTION_LAYER_ON(MDIA,ON_RELEASE),           // FN2 - Enable Layer 2 (Media)
-    ACTION_LAYER_OFF(SYMB,ON_RELEASE),          // FN3 - Disable Layer 1 (Symbols)
-    ACTION_LAYER_OFF(MDIA,ON_RELEASE),          // FN4 - Disable Layer 2 (MMedia)
-    ACTION_LAYER_MOMENTARY(MDIA)                // FN5 - Momentary Layer 2 (Mdia)
+    [1] = ACTION_LAYER_ON(SYMB,ON_RELEASE),           // FN1 - Enable Layer 1 (Symbols)
+    [2] = ACTION_LAYER_ON(MDIA,ON_RELEASE),           // FN2 - Enable Layer 2 (Media)
+    [3] = ACTION_LAYER_OFF(SYMB,ON_RELEASE),          // FN3 - Disable Layer 1 (Symbols)
+    [4] = ACTION_LAYER_OFF(MDIA,ON_RELEASE),          // FN4 - Disable Layer 2 (MMedia)
 };