2 files changed, 223 insertions, 200 deletions
diff --git a/keyboards/georgi/keymaps/default/keymap.c b/keyboards/georgi/keymaps/default/keymap.c
index c3d69eb8a..3a0edb892 100644
--- a/keyboards/georgi/keymaps/default/keymap.c
+++ b/keyboards/georgi/keymaps/default/keymap.c
@@ -1,4 +1,4 @@
-/* 
+/*
 * Good on you for modifying your layout, this is the most nonQMK layout you will come across
 * There are three modes, Steno (the default), QWERTY (Toggleable) and a Momentary symbol layer
 *
@@ -15,215 +15,224 @@
 #include "keymap_steno.h"
 #define IGNORE_MOD_TAP_INTERRUPT
-int getKeymapCount(void);
 // Proper Layers
 #define FUNCT   (LSD | LK | LP | LH)
 #define MEDIA   (LSD | LK | LW | LR)
 #define MOVE    (ST1 | ST2)
+// QMK Layers
+#define STENO_LAYER   0
+#define GAMING        1
+#define GAMING_2      2
 /* Keyboard Layout
 * ,---------------------------------.    ,------------------------------.
 * | FN  | LSU | LFT | LP | LH | ST1 |    | ST3 | RF | RP | RL | RT | RD |
 * |-----+-----+-----+----+----|-----|    |-----|----+----+----+----+----|
- * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | RG | RB | RS | RZ |
+ * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | BB | RG | RS | RZ |
 * `---------------------------------'    `------------------------------'
 *                   ,---------------,    .---------------.
- *                   | NUM | LA | LO |    | RE | RU | NUM |
+ *                   | LNO | LA | LO |    | RE | RU | RNO |
 *                   `---------------'    `---------------'
 */
-// YOU MUST ORDER THIS!
+// Note: You can only use basic keycodes here!
-// P   Will return from processing on the first match it finds. Therefore
+// P() is just a wrapper to make your life easier.
-// PJ  Will run the requested action, remove the matched chord and continue 
-//
-// First any chords that would conflict with PJs need to be checked, then PJs, lastly Ps.
-// For all chords should be ordered by length in their section!
 //
 // http://docs.gboards.ca
-bool processQwerty(void) {
+uint32_t processQwerty(bool lookup) {
-        // Place P's that would be trashed by PJ's here
+    // Specials
-        P( RT  | RS  | RD  | RZ | NUM,          SEND_STRING(VERSION); SEND_STRING(__DATE__));
+    P( RT  | RS  | RD  | RZ | LNO,        SEND_STRING(VERSION); SEND_STRING(__DATE__));
-        P( NUM | LA  | LO  | RE | RU,           SEND(KC_MPLY));
+    P( LNO | RNO | LA  | LO | RE | RU,    SEND(KC_MPLY));
-        P( ST1 | ST2 | ST3 | ST4,                       SEND(KC_BSPC));
+    P( LFT | LK  | LP  | LW,              REPEAT());
+    P( ST1 | ST2 | LW  | ST4,             SEND(KC_BSPC));
-        // Thumb Chords
-        P(  LA  | LO  | RE  | RU,                       SEND(KC_CAPS));
+    // Mouse Keys
-        P(  LA  | RU,                                           SEND(KC_ESC));
+    P( LO  | LSD | LK,    CLICK_MOUSE(KC_MS_BTN2));
-        PJ( LO  | RE,                                           SEND(KC_LCTL));
+    P( LO  | LR  | LW,    CLICK_MOUSE(KC_MS_BTN1));
-        PJ( NUM | LA | RU,                                      SEND(KC_LCTL); SEND(KC_LSFT));
-        PJ( NUM | LA | RE,                                      SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
+    // Thumb Chords
-        
+    P( LA  | LO  | RE  | RU,    SEND(KC_CAPS));
-        // Mods 
+    P( LA  | RU,                SEND(KC_ESC));
-        PJ( RT | RD | RS | RZ,                          SEND(KC_LGUI));
+    P( LO  | RE,                SEND(KC_LCTL));
-        PJ( RT | RD,                                            SEND(KC_LCTL));
+    P( LNO | RNO | LA | RU,     SEND(KC_LCTL); SEND(KC_LSFT));
-        PJ( RS | RZ,                                            SEND(KC_LALT));
+    P( LNO | LA  | RE,          SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
-        PJ( LA | NUM,                                           SEND(KC_LCTL));
-        PJ( LA | LO,                                            SEND(KC_LALT));
+    // Mods
-        PJ( LO,                                                         SEND(KC_LSFT));
+    P( RT | RD   | RS | RZ,    SEND(KC_LGUI));
+    P( RT | RD,                SEND(KC_LCTL));
-        // Function Layer 
+    P( RS | RZ,                SEND(KC_LALT));
-        P( FUNCT | RF | RR,                                     SEND(KC_F5));
+    P( LA | LNO,               SEND(KC_LCTL));
-        P( FUNCT | RP | RB,                                     SEND(KC_F6));
+    P( LA | LO,                SEND(KC_LALT));
-        P( FUNCT | RL | RG,                                     SEND(KC_F7));
+    P( LO,                     SEND(KC_LSFT));
-        P( FUNCT | RT | RS,                                     SEND(KC_F8));
-        P( FUNCT | RF,                                          SEND(KC_F1));
+    // Function Layer
-        P( FUNCT | RP,                                          SEND(KC_F2));
+    P( FUNCT | RF | RR,    SEND(KC_F5));
-        P( FUNCT | RL,                                          SEND(KC_F3));
+    P( FUNCT | RP | RB,    SEND(KC_F6));
-        P( FUNCT | RT,                                          SEND(KC_F4));
+    P( FUNCT | RL | RG,    SEND(KC_F7));
-        P( FUNCT | RR,                                          SEND(KC_F9));
+    P( FUNCT | RT | RS,    SEND(KC_F8));
-        P( FUNCT | RG,                                          SEND(KC_F10));
+    P( FUNCT | RF,         SEND(KC_F1));
-        P( FUNCT | RB,                                          SEND(KC_F11));
+    P( FUNCT | RP,         SEND(KC_F2));
-        P( FUNCT | RS,                                          SEND(KC_F12));
+    P( FUNCT | RL,         SEND(KC_F3));
+    P( FUNCT | RT,         SEND(KC_F4));
-        // Movement Layer
+    P( FUNCT | RR,         SEND(KC_F9));
-        P( MOVE | RF,                                           SEND(KC_LEFT));
+    P( FUNCT | RG,         SEND(KC_F10));
-        P( MOVE | RP,                                           SEND(KC_DOWN));
+    P( FUNCT | RB,         SEND(KC_F11));
-        P( MOVE | RL,                                           SEND(KC_UP));
+    P( FUNCT | RS,         SEND(KC_F12));
-        P( MOVE | RT,                                           SEND(KC_RIGHT));
-        P( MOVE | ST3,                                          SEND(KC_PGUP));
+    // Movement Layer
-        P( MOVE | ST4,                                          SEND(KC_PGDN));
+    P( MOVE | RF,     SEND(KC_LEFT));
+    P( MOVE | RP,     SEND(KC_DOWN));
-        // Media Layer
+    P( MOVE | RL,     SEND(KC_UP));
-        P( MEDIA | RF,                                          SEND(KC_MPRV));
+    P( MOVE | RT,     SEND(KC_RIGHT));
-        P( MEDIA | RP,                                          SEND(KC_MPLY));
+    P( MOVE | ST3,    SEND(KC_PGUP));
-        P( MEDIA | RL,                                          SEND(KC_MPLY));
+    P( MOVE | ST4,    SEND(KC_PGDN));
-        P( MEDIA | RT,                                          SEND(KC_MNXT));
-        P( MEDIA | RD,                                          SEND(KC_VOLU));
+    // Media Layer
-        P( MEDIA | RZ,                                          SEND(KC_VOLD));
+    P( MEDIA | RF,    SEND(KC_MPRV));
-        P( MEDIA | RS,                                          SEND(KC_MUTE));
+    P( MEDIA | RP,    SEND(KC_MPLY));
+    P( MEDIA | RL,    SEND(KC_MPLY));
-        // Mouse Keys
+    P( MEDIA | RT,    SEND(KC_MNXT));
-        P( LP | LH,                                                     clickMouse(KC_MS_BTN1));
+    P( MEDIA | RD,    SEND(KC_VOLU));
-        P( LW | LR,                                                     clickMouse(KC_MS_BTN2));
+    P( MEDIA | RZ,    SEND(KC_VOLD));
-        
+    P( MEDIA | RS,    SEND(KC_MUTE));
-        // Number Row
-        P( NUM | LSU,                                           SEND(KC_1));
+    // Number Row, Left
-        P( NUM | LFT,                                           SEND(KC_2));
+    P( LNO | LSU,    SEND(KC_1));
-        P( NUM | LP,                                            SEND(KC_3));
+    P( LNO | LFT,    SEND(KC_2));
-        P( NUM | LH,                                            SEND(KC_4));
+    P( LNO | LP,     SEND(KC_3));
-        P( NUM | ST1,                                           SEND(KC_5));
+    P( LNO | LH,     SEND(KC_4));
-        P( NUM | ST3,                                           SEND(KC_6));
+    P( LNO | ST1,    SEND(KC_5));
-        P( NUM | RF,                                            SEND(KC_7));
+    P( LNO | ST3,    SEND(KC_6));
-        P( NUM | RP,                                            SEND(KC_8));
+    P( LNO | RF,     SEND(KC_7));
-        P( NUM | RL,                                            SEND(KC_9));
+    P( LNO | RP,     SEND(KC_8));
-        P( NUM | RT,                                            SEND(KC_0));
+    P( LNO | RL,     SEND(KC_9));
-        P( NUM | LA,                                            SEND(KC_5));
+    P( LNO | RT,     SEND(KC_0));
-        P( NUM | RT,                                            SEND(KC_0));
-        
+    // Number Row, Right
-        // Specials
+    P( RNO | LSU,    SEND(KC_1));
-        P( LA | NUM,                                            SEND(KC_ESC));
+    P( RNO | LFT,    SEND(KC_2));
-        P( RU | NUM,                                            SEND(KC_TAB));
+    P( RNO | LP,     SEND(KC_3));
-        P( RE | RU,                                                     SEND(KC_BSPC));
+    P( RNO | LH,     SEND(KC_4));
-        P( RD | RZ,                                                     SEND(KC_ENT));
+    P( RNO | ST1,    SEND(KC_5));
-        P( RE,                                                          SEND(KC_ENT));
+    P( RNO | ST3,    SEND(KC_6));
-        P( RD,                                                          SEND(KC_BSPC)); 
+    P( RNO | RF,     SEND(KC_7));
-        P( NUM,                                                         SEND(KC_BSPC));
+    P( RNO | RP,     SEND(KC_8));
-        P( LA,                                                          SEND(KC_SPC));
+    P( RNO | RL,     SEND(KC_9));
-        P( RU,                                                          SEND(KC_SPC));
+    P( RNO | RT,     SEND(KC_0));
-        P( RZ,                                                          SEND(KC_ESC));
+    P( RNO | LA,     SEND(KC_5));
-        // Letters
+    // Specials
-        P( LSU | LSD,                                           SEND(KC_A));
+    P( RU | RNO,    SEND(KC_TAB));
-        P( LFT | LK,                                            SEND(KC_S));
+    P( RE | RU,     SEND(KC_BSPC));
-        P( LP  | LW,                                            SEND(KC_D));
+    P( RD | RZ,     SEND(KC_ENT));
-        P( LH  | LR,                                            SEND(KC_F));
+    P( RE,          SEND(KC_ENT));
-        P( ST1 | ST2,                                           SEND(KC_G));
+    P( RD,          SEND(KC_BSPC));
-        P( ST3 | ST4,                                           SEND(KC_H));
+    P( LNO,         SEND(KC_BSPC));
-        P( RF  | RR,                                            SEND(KC_J));
+    P( RNO,         SEND(KC_BSPC));
-        P( RT  | RS,                                            SEND(KC_SCLN))
+    P( LA,          SEND(KC_SPC));
-        P( RG  | RL,                                            SEND(KC_L));
+    P( RU,          SEND(KC_SPC));
-        P( RP  | RB,                                            SEND(KC_K));
+    P( RZ,          SEND(KC_ESC));
-        P( LSU,                                                         SEND(KC_Q));
-        P( LSD,                                                         SEND(KC_Z));
+    // Symbols and Numbers
-        P( LFT,                                                         SEND(KC_W));
+    P( PWR | RE | RU,      SEND(KC_ENT));
-        P( LK,                                                          SEND(KC_X));
+    P( PWR | LA | LO,      SEND(KC_SPC));
-        P( LP,                                                          SEND(KC_E));
+    P( PWR | LP | LW,      SEND(KC_LSFT); SEND(KC_9));       // (
-        P( LW,                                                          SEND(KC_C));
+    P( PWR | LH | LR,      SEND(KC_LSFT); SEND(KC_0));       // )
-        P( LH,                                                          SEND(KC_R));
+    P( PWR | ST1 | ST2,    SEND(KC_GRV));                    // `
-        P( LR,                                                          SEND(KC_V));
+    P( PWR | RD | RZ,      SEND(KC_ESC));
-        P( ST1,                                                         SEND(KC_T));
+    P( PWR | LSU | LSD,    SEND(KC_LSFT); SEND(KC_3));       // #
-        P( ST2,                                                         SEND(KC_B));
+    P( PWR | LFT | LK,     SEND(KC_LSFT); SEND(KC_4));       // $
-        P( ST3,                                                         SEND(KC_Y));
+    P( PWR | LSU,          SEND(KC_LSFT); SEND(KC_1));       // !
-        P( ST4,                                                         SEND(KC_N));
+    P( PWR | LSD,          SEND(KC_LSFT); SEND(KC_5));       // %
-        P( RF,                                                          SEND(KC_U));
+    P( PWR | LFT,          SEND(KC_LSFT); SEND(KC_2));       // @
-        P( RR,                                                          SEND(KC_M));
+    P( PWR | LK,           SEND(KC_LSFT); SEND(KC_6));       // ^
-        P( RP,                                                          SEND(KC_I));
+    P( PWR | LP,           SEND(KC_LSFT); SEND(KC_LBRC));    // {
-        P( RB,                                                          SEND(KC_COMM));
+    P( PWR | LW,           SEND(KC_LBRC));
-        P( RL,                                                          SEND(KC_O));
+    P( PWR | LH,           SEND(KC_LSFT); SEND(KC_RBRC));    // }
-        P( RG,                                                          SEND(KC_DOT));
+    P( PWR | LR,           SEND(KC_RBRC));
-        P( RT,                                                          SEND(KC_P));
+    P( PWR | ST1,          SEND(KC_LSFT); SEND(KC_BSLS));    // |
-        P( RS,                                                          SEND(KC_SLSH));
+    P( PWR | ST2,          SEND(KC_LSFT); SEND(KC_GRV));     // ~
+    P( PWR | ST3,          SEND(KC_QUOT));
-        // Symbols and Numbers
+    P( PWR | ST4,          SEND(KC_LSFT); SEND(KC_QUOT));    // "
-        P( PWR | RE | RU,                                       SEND(KC_ENT));
+    P( PWR | RF,           SEND(KC_KP_PLUS));
-        P( PWR | LA | LO,                                       SEND(KC_SPC));
+    P( PWR | RR,           SEND(KC_LSFT); SEND(KC_7));       // &
-        P( PWR | LP | LW,                                       SEND(KC_LSFT); SEND(KC_9));                     // (
+    P( PWR | RP,           SEND(KC_MINS));
-        P( PWR | LH | LR,                                       SEND(KC_LSFT); SEND(KC_0));                     // )
+    P( PWR | RB,           SEND(KC_EQL));
-        P( PWR | ST1 | ST2,                                     SEND(KC_GRV));                                          // `
+    P( PWR | RL,           SEND(KC_SLSH));
-        P( PWR | RD | RZ,                                       SEND(KC_ESC));                                                  
+    P( PWR | RG,           SEND(KC_COMM));
-        P( PWR | LSU | LSD,                                     SEND(KC_LSFT); SEND(KC_3));                     // #
+    P( PWR | RT,           SEND(KC_PAST));
-        P( PWR | LFT | LK,                                      SEND(KC_LSFT); SEND(KC_4));                     // $
+    P( PWR | RS,           SEND(KC_DOT));
-        P( PWR | LSU,                                           SEND(KC_LSFT); SEND(KC_1));                     // !
+    P( PWR | RD,           SEND(KC_TAB));
-        P( PWR | LSD,                                           SEND(KC_LSFT); SEND(KC_5));                     // %
+    P( PWR | LA,           SEND(KC_LSFT));
-        P( PWR | LFT,                                           SEND(KC_LSFT); SEND(KC_2));                     // @
+    P( PWR | LO,           SEND(KC_SLSH));
-        P( PWR | LK,                                            SEND(KC_LSFT); SEND(KC_6));                     // ^
+    P( PWR | RE,           SEND(KC_SCLN));
-        P( PWR | LP,                                            SEND(KC_LSFT); SEND(KC_LBRC));          // {
+    P( PWR | RU,           SEND(KC_BSLS));
-        P( PWR | LW,                                            SEND(KC_LBRC));
+    P( PWR | LNO,          SEND(KC_BSLS));
-        P( PWR | LH,                                            SEND(KC_LSFT); SEND(KC_RBRC));          // }
-        P( PWR | LR,                                            SEND(KC_RBRC));
+    // Letters
-        P( PWR | ST1,                                           SEND(KC_LSFT); SEND(KC_BSLS));          // |
+    P( LSU | LSD,    SEND(KC_A));
-        P( PWR | ST2,                                           SEND(KC_LSFT); SEND(KC_GRV));           // ~
+    P( LFT | LK,     SEND(KC_S));
-        P( PWR | ST3,                                           SEND(KC_QUOT));
+    P( LP  | LW,     SEND(KC_D));
-        P( PWR | ST4,                                           SEND(KC_LSFT); SEND(KC_QUOT));          // "
+    P( LH  | LR,     SEND(KC_F));
-        P( PWR | RF,                                            SEND(KC_KP_PLUS));
+    P( ST1 | ST2,    SEND(KC_G));
-        P( PWR | RR,                                            SEND(KC_LSFT); SEND(KC_7));                     // &
+    P( ST3 | ST4,    SEND(KC_H));
-        P( PWR | RP,                                            SEND(KC_MINS));
+    P( RF  | RR,     SEND(KC_J));
-        P( PWR | RB,                                            SEND(KC_EQL));
+    P( RT  | RS,     SEND(KC_SCLN));
-        P( PWR | RL,                                            SEND(KC_SLSH));
+    P( RG  | RL,     SEND(KC_L));
-        P( PWR | RG,                                            SEND(KC_COMM));
+    P( RP  | RB,     SEND(KC_K));
-        P( PWR | RT,                                            SEND(KC_PAST));
+    P( LSU,          SEND(KC_Q));
-        P( PWR | RS,                                            SEND(KC_DOT));
+    P( LSD,          SEND(KC_Z));
-        P( PWR | RD,                                            SEND(KC_TAB));
+    P( LFT,          SEND(KC_W));
-        P( PWR | LA,                                            SEND(KC_SCLN));
+    P( LK,           SEND(KC_X));
-        P( PWR | LO,                                            SEND(KC_SLSH));
+    P( LP,           SEND(KC_E));
-        P( PWR | RE,                                            SEND(KC_SCLN));
+    P( LW,           SEND(KC_C));
-        P( PWR | RU,                                            SEND(KC_SLSH));
+    P( LH,           SEND(KC_R));
+    P( LR,           SEND(KC_V));
+    P( ST1,          SEND(KC_T));
-        // If we make here, send as a steno chord
+    P( ST2,          SEND(KC_B));
-        // If plover is running we can hook that host side
+    P( ST3,          SEND(KC_Y));
-        return false;
+    P( ST4,          SEND(KC_N));
+    P( RF,           SEND(KC_U));
+    P( RR,           SEND(KC_M));
+    P( RP,           SEND(KC_I));
+    P( RB,           SEND(KC_COMM));
+    P( RL,           SEND(KC_O));
+    P( RG,           SEND(KC_DOT));
+    P( RT,           SEND(KC_P));
+    P( RS,           SEND(KC_SLSH));
+    P( RNO,          SEND(KC_BSPC));
+    P( LNO,          SEND(KC_BSPC));
+    return 0;
 }
-#define STENO_LAYER     0
-#define GAMING                  1
-#define GAMING_2                2
 // "Layers"
 // Steno layer should be first in your map.
-// When PWR | FN | RR | RG | RB | RS is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
+// When PWR | FN | ST3 | ST4 is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
-// If you have only a single layer, you must set SINGLELAYER = yes in your rules.mk, otherwise you may experince undefined behaviour
+// If you need more space for chords, remove the two gaming layers.
+// Note: If using NO_ACTION_TAPPING, LT will not work!
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-// Main layer, everything goes through here
+    // Main layer, everything goes through here
-[STENO_LAYER] = LAYOUT_georgi(  
+    [STENO_LAYER] = LAYOUT_georgi(
-STN_FN,  STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1,       STN_ST3, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR,
+        STN_FN,  STN_S1,  STN_TL,  STN_PL,  STN_HL,  STN_ST1,       STN_ST3, STN_FR,  STN_PR,  STN_LR,  STN_TR,  STN_DR,
-STN_PWR, STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2,       STN_ST4, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR,
+        STN_PWR, STN_S2,  STN_KL,  STN_WL,  STN_RL,  STN_ST2,       STN_ST4, STN_RR,  STN_BR,  STN_GR,  STN_SR,  STN_ZR,
-                                                 STN_N1, STN_A,  STN_O,                 STN_E,   STN_U,  STN_N1)
+                                   STN_N1,  STN_A,   STN_O,         STN_E,   STN_U,   STN_N7
-,
+    ),
-// Gaming layer with Numpad, Very limited
+    // Gaming layer with Numpad, Very limited
-[GAMING] = LAYOUT_georgi(  
+    [GAMING] = LAYOUT_georgi(
-KC_LSFT, KC_Q, KC_W, KC_E, KC_R, KC_T,       KC_Y,   KC_U, KC_I, KC_O, KC_P,    KC_ENT,
+        KC_LSFT, KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                       KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_ENT,
-KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G,       KC_H,   KC_J, KC_K, KC_L, KC_SCLN, KC_DQUO,
+        KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,                       KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_DQUO,
-KC_LALT, KC_SPC, LT(GAMING_2, KC_ENT),       KC_DEL, KC_ASTR,  TO(STENO_LAYER)), 
+                                   KC_LALT, KC_SPC,  LT(GAMING_2, KC_ENT),       KC_DEL,  KC_ASTR, TO(STENO_LAYER)
+    ),
-[GAMING_2] = LAYOUT_georgi(  
-KC_LSFT, KC_1, KC_2, KC_3, KC_4, KC_5,       KC_6, KC_7, KC_8,  KC_9,  KC_0, KC_MINS,
+    [GAMING_2] = LAYOUT_georgi(
-KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B,       KC_N, KC_M, KC_LT, KC_GT, KC_QUES, KC_RSFT,
+        KC_LSFT, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,          KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS,
-                          KC_LALT, KC_SPC, KC_ENT,           KC_DEL, KC_ASTR,  TO(STENO_LAYER))
+        KC_LCTL, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,          KC_N,    KC_M,    KC_LT,   KC_GT,   KC_QUES, KC_RSFT,
-}; 
+                                   KC_LALT, KC_SPC,  KC_ENT,        KC_DEL,  KC_ASTR, TO(STENO_LAYER)
+    )
-int getKeymapCount(void) {
+};
-        return sizeof(keymaps)/sizeof(keymaps[0]);
-}
+// Don't fuck with this, thanks.
+size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);
diff --git a/keyboards/georgi/keymaps/default/rules.mk b/keyboards/georgi/keymaps/default/rules.mk
index 2973c4591..90d8057c3 100644
--- a/keyboards/georgi/keymaps/default/rules.mk
+++ b/keyboards/georgi/keymaps/default/rules.mk
@@ -1,18 +1,23 @@
 #----------------------------------------------------------------------------
-# make georgi:extrakey:dfu
+# make georgi:default:dfu
 # Make sure you have dfu-programmer installed!
 #----------------------------------------------------------------------------
-#Debug options
+NO_REPEAT                                = no
 VERBOSE                                  = yes
-CONSOLE_ENABLE                   = yes
-DEBUG_MATRIX_SCAN_RATE   = no
-DEBUG_MATRIX                     = no
 KEYBOARD_SHARED_EP       = yes
 CUSTOM_MATRIX                    = yes
-MOUSEKEY_ENABLE                  = yes
-SINGLE_LAYER                     = no
+#Firmware reduction options
+MOUSEKEY_ENABLE                  = yes          # 1500 bytes
+NO_TAPPING                               = no       # 2000 bytes
+NO_PRINT                                 = yes          
+#Debug options
+CONSOLE_ENABLE                   = no
+DEBUG_MATRIX_SCAN_RATE   = no
+DEBUG_MATRIX                     = no
+ONLY_QWERTY                              = no
 # A bunch of stuff that you shouldn't touch unless you
 # know what you're doing.
@@ -22,6 +27,15 @@ SRC += matrix.c i2c_master.c
 ifeq ($(strip $(DEBUG_MATRIX)), yes)
    OPT_DEFS += -DDEBUG_MATRIX
 endif
-ifeq ($(strip $(SINGLE_LAYER)), yes)
+ifeq ($(strip $(NO_REPEAT)), yes)
-    OPT_DEFS += -DSINGLE_LAYER
+    OPT_DEFS += -DNO_REPEAT
+endif
+ifeq ($(strip $(NO_PRINT)), yes)
+    OPT_DEFS += -DNO_PRINT -DNO_DEBUG
+endif
+ifeq ($(strip $(ONLY_QWERTY)), yes)
+    OPT_DEFS += -DONLYQWERTY
+endif
+ifeq ($(strip $(NO_TAPPING)), yes)
+    OPT_DEFS += -DNO_ACTION_TAPPING
 endif

diff --git a/keyboards/georgi/keymaps/default/keymap.c b/keyboards/georgi/keymaps/default/keymap.c index c3d69eb8a..3a0edb892 100644 --- a/keyboards/georgi/keymaps/default/keymap.c +++ b/keyboards/georgi/keymaps/default/keymap.c
@@ -1,4 +1,4 @@
1	/*	1	/*
2	* Good on you for modifying your layout, this is the most nonQMK layout you will come across	2	* Good on you for modifying your layout, this is the most nonQMK layout you will come across
3	* There are three modes, Steno (the default), QWERTY (Toggleable) and a Momentary symbol layer	3	* There are three modes, Steno (the default), QWERTY (Toggleable) and a Momentary symbol layer
4	*	4	*
@@ -15,215 +15,224 @@
15	#include "keymap_steno.h"	15	#include "keymap_steno.h"
16	#define IGNORE_MOD_TAP_INTERRUPT	16	#define IGNORE_MOD_TAP_INTERRUPT
17		17
18	int getKeymapCount(void);
19
20	// Proper Layers	18	// Proper Layers
21	#define FUNCT (LSD \| LK \| LP \| LH)	19	#define FUNCT (LSD \| LK \| LP \| LH)
22	#define MEDIA (LSD \| LK \| LW \| LR)	20	#define MEDIA (LSD \| LK \| LW \| LR)
23	#define MOVE (ST1 \| ST2)	21	#define MOVE (ST1 \| ST2)
24		22
		23	// QMK Layers
		24	#define STENO_LAYER 0
		25	#define GAMING 1
		26	#define GAMING_2 2
		27
25	/* Keyboard Layout	28	/* Keyboard Layout
26	* ,---------------------------------. ,------------------------------.	29	* ,---------------------------------. ,------------------------------.
27	* \| FN \| LSU \| LFT \| LP \| LH \| ST1 \| \| ST3 \| RF \| RP \| RL \| RT \| RD \|	30	* \| FN \| LSU \| LFT \| LP \| LH \| ST1 \| \| ST3 \| RF \| RP \| RL \| RT \| RD \|
28	* \|-----+-----+-----+----+----\|-----\| \|-----\|----+----+----+----+----\|	31	* \|-----+-----+-----+----+----\|-----\| \|-----\|----+----+----+----+----\|
29	* \| PWR \| LSD \| LK \| LW \| LR \| ST2 \| \| ST4 \| RR \| RG \| RB \| RS \| RZ \|	32	* \| PWR \| LSD \| LK \| LW \| LR \| ST2 \| \| ST4 \| RR \| BB \| RG \| RS \| RZ \|
30	* `---------------------------------' `------------------------------'	33	* `---------------------------------' `------------------------------'
31	* ,---------------, .---------------.	34	* ,---------------, .---------------.
32	* \| NUM \| LA \| LO \| \| RE \| RU \| NUM \|	35	* \| LNO \| LA \| LO \| \| RE \| RU \| RNO \|
33	* `---------------' `---------------'	36	* `---------------' `---------------'
34	*/	37	*/
35		38
36	// YOU MUST ORDER THIS!	39	// Note: You can only use basic keycodes here!
37	// P Will return from processing on the first match it finds. Therefore	40	// P() is just a wrapper to make your life easier.
38	// PJ Will run the requested action, remove the matched chord and continue
39	//
40	// First any chords that would conflict with PJs need to be checked, then PJs, lastly Ps.
41	// For all chords should be ordered by length in their section!
42	//	41	//
43	// http://docs.gboards.ca	42	// http://docs.gboards.ca
44	bool processQwerty(void) {	43	uint32_t processQwerty(bool lookup) {
45	// Place P's that would be trashed by PJ's here	44	// Specials
46	P( RT \| RS \| RD \| RZ \| NUM, SEND_STRING(VERSION); SEND_STRING(__DATE__));	45	P( RT \| RS \| RD \| RZ \| LNO, SEND_STRING(VERSION); SEND_STRING(__DATE__));
47	P( NUM \| LA \| LO \| RE \| RU, SEND(KC_MPLY));	46	P( LNO \| RNO \| LA \| LO \| RE \| RU, SEND(KC_MPLY));
48	P( ST1 \| ST2 \| ST3 \| ST4, SEND(KC_BSPC));	47	P( LFT \| LK \| LP \| LW, REPEAT());
49		48	P( ST1 \| ST2 \| LW \| ST4, SEND(KC_BSPC));
50	// Thumb Chords	49
51	P( LA \| LO \| RE \| RU, SEND(KC_CAPS));	50	// Mouse Keys
52	P( LA \| RU, SEND(KC_ESC));	51	P( LO \| LSD \| LK, CLICK_MOUSE(KC_MS_BTN2));
53	PJ( LO \| RE, SEND(KC_LCTL));	52	P( LO \| LR \| LW, CLICK_MOUSE(KC_MS_BTN1));
54	PJ( NUM \| LA \| RU, SEND(KC_LCTL); SEND(KC_LSFT));	53
55	PJ( NUM \| LA \| RE, SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));	54	// Thumb Chords
56		55	P( LA \| LO \| RE \| RU, SEND(KC_CAPS));
57	// Mods	56	P( LA \| RU, SEND(KC_ESC));
58	PJ( RT \| RD \| RS \| RZ, SEND(KC_LGUI));	57	P( LO \| RE, SEND(KC_LCTL));
59	PJ( RT \| RD, SEND(KC_LCTL));	58	P( LNO \| RNO \| LA \| RU, SEND(KC_LCTL); SEND(KC_LSFT));
60	PJ( RS \| RZ, SEND(KC_LALT));	59	P( LNO \| LA \| RE, SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
61	PJ( LA \| NUM, SEND(KC_LCTL));	60
62	PJ( LA \| LO, SEND(KC_LALT));	61	// Mods
63	PJ( LO, SEND(KC_LSFT));	62	P( RT \| RD \| RS \| RZ, SEND(KC_LGUI));
64		63	P( RT \| RD, SEND(KC_LCTL));
65	// Function Layer	64	P( RS \| RZ, SEND(KC_LALT));
66	P( FUNCT \| RF \| RR, SEND(KC_F5));	65	P( LA \| LNO, SEND(KC_LCTL));
67	P( FUNCT \| RP \| RB, SEND(KC_F6));	66	P( LA \| LO, SEND(KC_LALT));
68	P( FUNCT \| RL \| RG, SEND(KC_F7));	67	P( LO, SEND(KC_LSFT));
69	P( FUNCT \| RT \| RS, SEND(KC_F8));	68
70	P( FUNCT \| RF, SEND(KC_F1));	69	// Function Layer
71	P( FUNCT \| RP, SEND(KC_F2));	70	P( FUNCT \| RF \| RR, SEND(KC_F5));
72	P( FUNCT \| RL, SEND(KC_F3));	71	P( FUNCT \| RP \| RB, SEND(KC_F6));
73	P( FUNCT \| RT, SEND(KC_F4));	72	P( FUNCT \| RL \| RG, SEND(KC_F7));
74	P( FUNCT \| RR, SEND(KC_F9));	73	P( FUNCT \| RT \| RS, SEND(KC_F8));
75	P( FUNCT \| RG, SEND(KC_F10));	74	P( FUNCT \| RF, SEND(KC_F1));
76	P( FUNCT \| RB, SEND(KC_F11));	75	P( FUNCT \| RP, SEND(KC_F2));
77	P( FUNCT \| RS, SEND(KC_F12));	76	P( FUNCT \| RL, SEND(KC_F3));
78		77	P( FUNCT \| RT, SEND(KC_F4));
79	// Movement Layer	78	P( FUNCT \| RR, SEND(KC_F9));
80	P( MOVE \| RF, SEND(KC_LEFT));	79	P( FUNCT \| RG, SEND(KC_F10));
81	P( MOVE \| RP, SEND(KC_DOWN));	80	P( FUNCT \| RB, SEND(KC_F11));
82	P( MOVE \| RL, SEND(KC_UP));	81	P( FUNCT \| RS, SEND(KC_F12));
83	P( MOVE \| RT, SEND(KC_RIGHT));	82
84	P( MOVE \| ST3, SEND(KC_PGUP));	83	// Movement Layer
85	P( MOVE \| ST4, SEND(KC_PGDN));	84	P( MOVE \| RF, SEND(KC_LEFT));
86		85	P( MOVE \| RP, SEND(KC_DOWN));
87	// Media Layer	86	P( MOVE \| RL, SEND(KC_UP));
88	P( MEDIA \| RF, SEND(KC_MPRV));	87	P( MOVE \| RT, SEND(KC_RIGHT));
89	P( MEDIA \| RP, SEND(KC_MPLY));	88	P( MOVE \| ST3, SEND(KC_PGUP));
90	P( MEDIA \| RL, SEND(KC_MPLY));	89	P( MOVE \| ST4, SEND(KC_PGDN));
91	P( MEDIA \| RT, SEND(KC_MNXT));	90
92	P( MEDIA \| RD, SEND(KC_VOLU));	91	// Media Layer
93	P( MEDIA \| RZ, SEND(KC_VOLD));	92	P( MEDIA \| RF, SEND(KC_MPRV));
94	P( MEDIA \| RS, SEND(KC_MUTE));	93	P( MEDIA \| RP, SEND(KC_MPLY));
95		94	P( MEDIA \| RL, SEND(KC_MPLY));
96	// Mouse Keys	95	P( MEDIA \| RT, SEND(KC_MNXT));
97	P( LP \| LH, clickMouse(KC_MS_BTN1));	96	P( MEDIA \| RD, SEND(KC_VOLU));
98	P( LW \| LR, clickMouse(KC_MS_BTN2));	97	P( MEDIA \| RZ, SEND(KC_VOLD));
99		98	P( MEDIA \| RS, SEND(KC_MUTE));
100	// Number Row	99
101	P( NUM \| LSU, SEND(KC_1));	100	// Number Row, Left
102	P( NUM \| LFT, SEND(KC_2));	101	P( LNO \| LSU, SEND(KC_1));
103	P( NUM \| LP, SEND(KC_3));	102	P( LNO \| LFT, SEND(KC_2));
104	P( NUM \| LH, SEND(KC_4));	103	P( LNO \| LP, SEND(KC_3));
105	P( NUM \| ST1, SEND(KC_5));	104	P( LNO \| LH, SEND(KC_4));
106	P( NUM \| ST3, SEND(KC_6));	105	P( LNO \| ST1, SEND(KC_5));
107	P( NUM \| RF, SEND(KC_7));	106	P( LNO \| ST3, SEND(KC_6));
108	P( NUM \| RP, SEND(KC_8));	107	P( LNO \| RF, SEND(KC_7));
109	P( NUM \| RL, SEND(KC_9));	108	P( LNO \| RP, SEND(KC_8));
110	P( NUM \| RT, SEND(KC_0));	109	P( LNO \| RL, SEND(KC_9));
111	P( NUM \| LA, SEND(KC_5));	110	P( LNO \| RT, SEND(KC_0));
112	P( NUM \| RT, SEND(KC_0));	111
113		112	// Number Row, Right
114	// Specials	113	P( RNO \| LSU, SEND(KC_1));
115	P( LA \| NUM, SEND(KC_ESC));	114	P( RNO \| LFT, SEND(KC_2));
116	P( RU \| NUM, SEND(KC_TAB));	115	P( RNO \| LP, SEND(KC_3));
117	P( RE \| RU, SEND(KC_BSPC));	116	P( RNO \| LH, SEND(KC_4));
118	P( RD \| RZ, SEND(KC_ENT));	117	P( RNO \| ST1, SEND(KC_5));
119	P( RE, SEND(KC_ENT));	118	P( RNO \| ST3, SEND(KC_6));
120	P( RD, SEND(KC_BSPC));	119	P( RNO \| RF, SEND(KC_7));
121	P( NUM, SEND(KC_BSPC));	120	P( RNO \| RP, SEND(KC_8));
122	P( LA, SEND(KC_SPC));	121	P( RNO \| RL, SEND(KC_9));
123	P( RU, SEND(KC_SPC));	122	P( RNO \| RT, SEND(KC_0));
124	P( RZ, SEND(KC_ESC));	123	P( RNO \| LA, SEND(KC_5));
125		124
126	// Letters	125	// Specials
127	P( LSU \| LSD, SEND(KC_A));	126	P( RU \| RNO, SEND(KC_TAB));
128	P( LFT \| LK, SEND(KC_S));	127	P( RE \| RU, SEND(KC_BSPC));
129	P( LP \| LW, SEND(KC_D));	128	P( RD \| RZ, SEND(KC_ENT));
130	P( LH \| LR, SEND(KC_F));	129	P( RE, SEND(KC_ENT));
131	P( ST1 \| ST2, SEND(KC_G));	130	P( RD, SEND(KC_BSPC));
132	P( ST3 \| ST4, SEND(KC_H));	131	P( LNO, SEND(KC_BSPC));
133	P( RF \| RR, SEND(KC_J));	132	P( RNO, SEND(KC_BSPC));
134	P( RT \| RS, SEND(KC_SCLN))	133	P( LA, SEND(KC_SPC));
135	P( RG \| RL, SEND(KC_L));	134	P( RU, SEND(KC_SPC));
136	P( RP \| RB, SEND(KC_K));	135	P( RZ, SEND(KC_ESC));
137	P( LSU, SEND(KC_Q));	136
138	P( LSD, SEND(KC_Z));	137	// Symbols and Numbers
139	P( LFT, SEND(KC_W));	138	P( PWR \| RE \| RU, SEND(KC_ENT));
140	P( LK, SEND(KC_X));	139	P( PWR \| LA \| LO, SEND(KC_SPC));
141	P( LP, SEND(KC_E));	140	P( PWR \| LP \| LW, SEND(KC_LSFT); SEND(KC_9)); // (
142	P( LW, SEND(KC_C));	141	P( PWR \| LH \| LR, SEND(KC_LSFT); SEND(KC_0)); // )
143	P( LH, SEND(KC_R));	142	P( PWR \| ST1 \| ST2, SEND(KC_GRV)); // `
144	P( LR, SEND(KC_V));	143	P( PWR \| RD \| RZ, SEND(KC_ESC));
145	P( ST1, SEND(KC_T));	144	P( PWR \| LSU \| LSD, SEND(KC_LSFT); SEND(KC_3)); // #
146	P( ST2, SEND(KC_B));	145	P( PWR \| LFT \| LK, SEND(KC_LSFT); SEND(KC_4)); // $
147	P( ST3, SEND(KC_Y));	146	P( PWR \| LSU, SEND(KC_LSFT); SEND(KC_1)); // !
148	P( ST4, SEND(KC_N));	147	P( PWR \| LSD, SEND(KC_LSFT); SEND(KC_5)); // %
149	P( RF, SEND(KC_U));	148	P( PWR \| LFT, SEND(KC_LSFT); SEND(KC_2)); // @
150	P( RR, SEND(KC_M));	149	P( PWR \| LK, SEND(KC_LSFT); SEND(KC_6)); // ^
151	P( RP, SEND(KC_I));	150	P( PWR \| LP, SEND(KC_LSFT); SEND(KC_LBRC)); // {
152	P( RB, SEND(KC_COMM));	151	P( PWR \| LW, SEND(KC_LBRC));
153	P( RL, SEND(KC_O));	152	P( PWR \| LH, SEND(KC_LSFT); SEND(KC_RBRC)); // }
154	P( RG, SEND(KC_DOT));	153	P( PWR \| LR, SEND(KC_RBRC));
155	P( RT, SEND(KC_P));	154	P( PWR \| ST1, SEND(KC_LSFT); SEND(KC_BSLS)); // \|
156	P( RS, SEND(KC_SLSH));	155	P( PWR \| ST2, SEND(KC_LSFT); SEND(KC_GRV)); // ~
157		156	P( PWR \| ST3, SEND(KC_QUOT));
158	// Symbols and Numbers	157	P( PWR \| ST4, SEND(KC_LSFT); SEND(KC_QUOT)); // "
159	P( PWR \| RE \| RU, SEND(KC_ENT));	158	P( PWR \| RF, SEND(KC_KP_PLUS));
160	P( PWR \| LA \| LO, SEND(KC_SPC));	159	P( PWR \| RR, SEND(KC_LSFT); SEND(KC_7)); // &
161	P( PWR \| LP \| LW, SEND(KC_LSFT); SEND(KC_9)); // (	160	P( PWR \| RP, SEND(KC_MINS));
162	P( PWR \| LH \| LR, SEND(KC_LSFT); SEND(KC_0)); // )	161	P( PWR \| RB, SEND(KC_EQL));
163	P( PWR \| ST1 \| ST2, SEND(KC_GRV)); // `	162	P( PWR \| RL, SEND(KC_SLSH));
164	P( PWR \| RD \| RZ, SEND(KC_ESC));	163	P( PWR \| RG, SEND(KC_COMM));
165	P( PWR \| LSU \| LSD, SEND(KC_LSFT); SEND(KC_3)); // #	164	P( PWR \| RT, SEND(KC_PAST));
166	P( PWR \| LFT \| LK, SEND(KC_LSFT); SEND(KC_4)); // $	165	P( PWR \| RS, SEND(KC_DOT));
167	P( PWR \| LSU, SEND(KC_LSFT); SEND(KC_1)); // !	166	P( PWR \| RD, SEND(KC_TAB));
168	P( PWR \| LSD, SEND(KC_LSFT); SEND(KC_5)); // %	167	P( PWR \| LA, SEND(KC_LSFT));
169	P( PWR \| LFT, SEND(KC_LSFT); SEND(KC_2)); // @	168	P( PWR \| LO, SEND(KC_SLSH));
170	P( PWR \| LK, SEND(KC_LSFT); SEND(KC_6)); // ^	169	P( PWR \| RE, SEND(KC_SCLN));
171	P( PWR \| LP, SEND(KC_LSFT); SEND(KC_LBRC)); // {	170	P( PWR \| RU, SEND(KC_BSLS));
172	P( PWR \| LW, SEND(KC_LBRC));	171	P( PWR \| LNO, SEND(KC_BSLS));
173	P( PWR \| LH, SEND(KC_LSFT); SEND(KC_RBRC)); // }	172
174	P( PWR \| LR, SEND(KC_RBRC));	173	// Letters
175	P( PWR \| ST1, SEND(KC_LSFT); SEND(KC_BSLS)); // \|	174	P( LSU \| LSD, SEND(KC_A));
176	P( PWR \| ST2, SEND(KC_LSFT); SEND(KC_GRV)); // ~	175	P( LFT \| LK, SEND(KC_S));
177	P( PWR \| ST3, SEND(KC_QUOT));	176	P( LP \| LW, SEND(KC_D));
178	P( PWR \| ST4, SEND(KC_LSFT); SEND(KC_QUOT)); // "	177	P( LH \| LR, SEND(KC_F));
179	P( PWR \| RF, SEND(KC_KP_PLUS));	178	P( ST1 \| ST2, SEND(KC_G));
180	P( PWR \| RR, SEND(KC_LSFT); SEND(KC_7)); // &	179	P( ST3 \| ST4, SEND(KC_H));
181	P( PWR \| RP, SEND(KC_MINS));	180	P( RF \| RR, SEND(KC_J));
182	P( PWR \| RB, SEND(KC_EQL));	181	P( RT \| RS, SEND(KC_SCLN));
183	P( PWR \| RL, SEND(KC_SLSH));	182	P( RG \| RL, SEND(KC_L));
184	P( PWR \| RG, SEND(KC_COMM));	183	P( RP \| RB, SEND(KC_K));
185	P( PWR \| RT, SEND(KC_PAST));	184	P( LSU, SEND(KC_Q));
186	P( PWR \| RS, SEND(KC_DOT));	185	P( LSD, SEND(KC_Z));
187	P( PWR \| RD, SEND(KC_TAB));	186	P( LFT, SEND(KC_W));
188	P( PWR \| LA, SEND(KC_SCLN));	187	P( LK, SEND(KC_X));
189	P( PWR \| LO, SEND(KC_SLSH));	188	P( LP, SEND(KC_E));
190	P( PWR \| RE, SEND(KC_SCLN));	189	P( LW, SEND(KC_C));
191	P( PWR \| RU, SEND(KC_SLSH));	190	P( LH, SEND(KC_R));
192		191	P( LR, SEND(KC_V));
193		192	P( ST1, SEND(KC_T));
194	// If we make here, send as a steno chord	193	P( ST2, SEND(KC_B));
195	// If plover is running we can hook that host side	194	P( ST3, SEND(KC_Y));
196	return false;	195	P( ST4, SEND(KC_N));
		196	P( RF, SEND(KC_U));
		197	P( RR, SEND(KC_M));
		198	P( RP, SEND(KC_I));
		199	P( RB, SEND(KC_COMM));
		200	P( RL, SEND(KC_O));
		201	P( RG, SEND(KC_DOT));
		202	P( RT, SEND(KC_P));
		203	P( RS, SEND(KC_SLSH));
		204	P( RNO, SEND(KC_BSPC));
		205	P( LNO, SEND(KC_BSPC));
		206
		207	return 0;
197	}	208	}
198		209
199	#define STENO_LAYER 0
200	#define GAMING 1
201	#define GAMING_2 2
202
203	// "Layers"	210	// "Layers"
204	// Steno layer should be first in your map.	211	// Steno layer should be first in your map.
205	// When PWR \| FN \| RR \| RG \| RB \| RS is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.	212	// When PWR \| FN \| ST3 \| ST4 is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
206	// If you have only a single layer, you must set SINGLELAYER = yes in your rules.mk, otherwise you may experince undefined behaviour	213	// If you need more space for chords, remove the two gaming layers.
		214	// Note: If using NO_ACTION_TAPPING, LT will not work!
207		215
208	const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {	216	const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
209	// Main layer, everything goes through here	217	// Main layer, everything goes through here
210	[STENO_LAYER] = LAYOUT_georgi(	218	[STENO_LAYER] = LAYOUT_georgi(
211	STN_FN, STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1, STN_ST3, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR,	219	STN_FN, STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1, STN_ST3, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR,
212	STN_PWR, STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2, STN_ST4, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR,	220	STN_PWR, STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2, STN_ST4, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR,
213	STN_N1, STN_A, STN_O, STN_E, STN_U, STN_N1)	221	STN_N1, STN_A, STN_O, STN_E, STN_U, STN_N7
214	,	222	),
215	// Gaming layer with Numpad, Very limited	223	// Gaming layer with Numpad, Very limited
216	[GAMING] = LAYOUT_georgi(	224	[GAMING] = LAYOUT_georgi(
217	KC_LSFT, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_ENT,	225	KC_LSFT, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_ENT,
218	KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_DQUO,	226	KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_DQUO,
219	KC_LALT, KC_SPC, LT(GAMING_2, KC_ENT), KC_DEL, KC_ASTR, TO(STENO_LAYER)),	227	KC_LALT, KC_SPC, LT(GAMING_2, KC_ENT), KC_DEL, KC_ASTR, TO(STENO_LAYER)
220		228	),
221	[GAMING_2] = LAYOUT_georgi(	229
222	KC_LSFT, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,	230	[GAMING_2] = LAYOUT_georgi(
223	KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_LT, KC_GT, KC_QUES, KC_RSFT,	231	KC_LSFT, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,
224	KC_LALT, KC_SPC, KC_ENT, KC_DEL, KC_ASTR, TO(STENO_LAYER))	232	KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_LT, KC_GT, KC_QUES, KC_RSFT,
225	};	233	KC_LALT, KC_SPC, KC_ENT, KC_DEL, KC_ASTR, TO(STENO_LAYER)
226		234	)
227	int getKeymapCount(void) {	235	};
228	return sizeof(keymaps)/sizeof(keymaps[0]);	236
229	}	237	// Don't fuck with this, thanks.
		238	size_t keymapsCount = sizeof(keymaps)/sizeof(keymaps[0]);


diff --git a/keyboards/georgi/keymaps/default/rules.mk b/keyboards/georgi/keymaps/default/rules.mk index 2973c4591..90d8057c3 100644 --- a/keyboards/georgi/keymaps/default/rules.mk +++ b/keyboards/georgi/keymaps/default/rules.mk
@@ -1,18 +1,23 @@
1	#----------------------------------------------------------------------------	1	#----------------------------------------------------------------------------
2	# make georgi:extrakey:dfu	2	# make georgi:default:dfu
3	# Make sure you have dfu-programmer installed!	3	# Make sure you have dfu-programmer installed!
4	#----------------------------------------------------------------------------	4	#----------------------------------------------------------------------------
5		5
6	#Debug options	6	NO_REPEAT = no
7	VERBOSE = yes	7	VERBOSE = yes
8	CONSOLE_ENABLE = yes
9	DEBUG_MATRIX_SCAN_RATE = no
10	DEBUG_MATRIX = no
11	KEYBOARD_SHARED_EP = yes	8	KEYBOARD_SHARED_EP = yes
12	CUSTOM_MATRIX = yes	9	CUSTOM_MATRIX = yes
13	MOUSEKEY_ENABLE = yes
14	SINGLE_LAYER = no
15		10
		11	#Firmware reduction options
		12	MOUSEKEY_ENABLE = yes # 1500 bytes
		13	NO_TAPPING = no # 2000 bytes
		14	NO_PRINT = yes
		15
		16	#Debug options
		17	CONSOLE_ENABLE = no
		18	DEBUG_MATRIX_SCAN_RATE = no
		19	DEBUG_MATRIX = no
		20	ONLY_QWERTY = no
16		21
17	# A bunch of stuff that you shouldn't touch unless you	22	# A bunch of stuff that you shouldn't touch unless you
18	# know what you're doing.	23	# know what you're doing.
@@ -22,6 +27,15 @@ SRC += matrix.c i2c_master.c
22	ifeq ($(strip $(DEBUG_MATRIX)), yes)	27	ifeq ($(strip $(DEBUG_MATRIX)), yes)
23	OPT_DEFS += -DDEBUG_MATRIX	28	OPT_DEFS += -DDEBUG_MATRIX
24	endif	29	endif
25	ifeq ($(strip $(SINGLE_LAYER)), yes)	30	ifeq ($(strip $(NO_REPEAT)), yes)
26	OPT_DEFS += -DSINGLE_LAYER	31	OPT_DEFS += -DNO_REPEAT
		32	endif
		33	ifeq ($(strip $(NO_PRINT)), yes)
		34	OPT_DEFS += -DNO_PRINT -DNO_DEBUG
		35	endif
		36	ifeq ($(strip $(ONLY_QWERTY)), yes)
		37	OPT_DEFS += -DONLYQWERTY
		38	endif
		39	ifeq ($(strip $(NO_TAPPING)), yes)
		40	OPT_DEFS += -DNO_ACTION_TAPPING
27	endif	41	endif