keyboards/georgi/keymaps/norman/keymap.c

   1 /*
   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
   4  *
   5  * Don't modify the steno layer directly, instead add chords using the keycodes and macros
   6  * from sten.h to the layout you want to modify.
   7  *
   8  * Observe the comment above processQWERTY!
   9  *
  10  * http://docs.gboards.ca
  11  */
  12
  13 #include QMK_KEYBOARD_H
  14 #include "sten.h"
  15 #include "keymap_steno.h"
  16 #define IGNORE_MOD_TAP_INTERRUPT
  17
  18 // Proper Layers
  19 #define FUNCT   (LSD | LK | LP | LH)
  20 #define MEDIA   (LSD | LK | LW | LR)
  21 #define MOVE    (LH | ST2)
  22
  23 /* Keyboard Layout
  24  * ,---------------------------------.    ,------------------------------.
  25  * | FN  | LSU | LFT | LP | LH | ST1 |    | ST3 | RF | RP | RL | RT | RD |
  26  * |-----+-----+-----+----+----|-----|    |-----|----+----+----+----+----|
  27  * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | RB | RG | RS | RZ |
  28  * `---------------------------------'    `------------------------------'
  29  *                   ,---------------,    .---------------.
  30  *                   | LNO | LA | LO |    | RE | RU | RNO |
  31  *                   `---------------'    `---------------'
  32  */
  33
  34 // YOU MUST ORDER THIS!
  35 // Order your chords from longest to shortest!
  36 // You can only use basic keycodes here!
  37 //
  38 // P() is just a wrapper to make your life easier.
  39 //
  40 // http://docs.gboards.ca
  41 uint32_t processQwerty(bool lookup) {
  42         // Specials
  43         P( RT  | RS  | RD  | RZ | LNO,          SEND_STRING(VERSION); SEND_STRING(__DATE__));
  44         P( LNO | LA  | LO  | RE | RU,           SEND(KC_MPLY));
  45         P( ST1 | ST2 | ST3 | ST4,                       SEND(KC_BSPC));
  46
  47         // Thumb Chords
  48         P(  LA  | LO  | RE  | RU,                       SEND(KC_CAPS));
  49         P(  LA  | RU,                                           SEND(KC_ESC));
  50         P( LO  | RE,                                            SEND(KC_LCTL));
  51         P( LNO | LA | RU,                                       SEND(KC_LCTL); SEND(KC_LSFT));
  52         P( LNO | LA | RE,                                       SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
  53
  54         // Mods
  55         P( RT | RD | RS | RZ,                           SEND(KC_LGUI));
  56         P( RT | RD,                                             SEND(KC_LCTL));
  57         P( RS | RZ,                                             SEND(KC_LALT));
  58         P( LA | LNO,                                            SEND(KC_LCTL));
  59         P( LA | LO,                                             SEND(KC_LALT));
  60         P( LO,                                                          SEND(KC_LSFT));
  61
  62         // Function Layer
  63         P( FUNCT | RF | RR,                                     SEND(KC_F6));
  64         P( FUNCT | RP | RB,                                     SEND(KC_F7));
  65         P( FUNCT | RL | RG,                                     SEND(KC_F8));
  66         P( FUNCT | ST3 | ST4,                           SEND(KC_F5));
  67   P( FUNCT| ST3,              SEND(KC_F1));
  68   P( FUNCT| ST4,              SEND(KC_F9));
  69         P( FUNCT | RF,                                          SEND(KC_F2));
  70         P( FUNCT | RP,                                          SEND(KC_F3));
  71         P( FUNCT | RL,                                          SEND(KC_F4));
  72         P( FUNCT | RR,                                          SEND(KC_F10));
  73         P( FUNCT | RG,                                          SEND(KC_F12));
  74         P( FUNCT | RB,                                          SEND(KC_F11));
  75   P( FUNCT | RD,            SEND(KC_RALT); SEND(KC_T); SEND(KC_H); SEND(KC_U); SEND(KC_P));
  76   P( FUNCT | RZ,            SEND(KC_RALT); SEND(KC_T); SEND(KC_H); SEND(KC_D); SEND(KC_N));
  77   P( FUNCT | RT,            SEND(KC_RALT); SEND(KC_S); SEND(KC_F));
  78   P( FUNCT | RS,            SEND(KC_LALT); SEND(KC_SPC));
  79   P( FUNCT | RE,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_ESC));
  80   P( FUNCT | RU,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_0));
  81
  82         // Movement Layer
  83         P( MOVE | RF,                                            SEND(KC_LGUI); SEND(KC_LSFT); SEND(KC_LEFT));
  84         P( MOVE | RP,                                           SEND(KC_UP));
  85         P( MOVE | RL,                                           SEND(KC_LGUI); SEND(KC_LSFT); SEND(KC_RGHT));
  86         P( MOVE | RT,                                           SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_C));
  87         P( MOVE | ST3,                                          SEND(KC_PGUP));
  88         P( MOVE | ST4,                                          SEND(KC_PGDN));
  89   P( MOVE | RD,           SEND(KC_HOME));
  90   P( MOVE | RZ,           SEND(KC_END));
  91   P( MOVE | RG,            SEND(KC_RIGHT));
  92   P( MOVE | RB,            SEND(KC_DOWN));
  93   P( MOVE | RR,            SEND(KC_LEFT));
  94   P( MOVE | RS,            SEND(KC_LSFT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_T));
  95   P( MOVE | RE,            SEND(KC_LSFT); SEND(KC_LALT); SEND(KC_LGUI); SEND(KC_S));
  96   P( MOVE | RU,            SEND(KC_LSFT); SEND(KC_LCTL); SEND(KC_1));
  97
  98
  99         // Media Layer
 100         P( MEDIA | RF,                                          SEND(KC_MEDIA_PREV_TRACK));
 101         P( MEDIA | RP,                                          SEND(KC_MPLY));
 102         P( MEDIA | RL,                                          SEND(KC_MPLY));
 103         P( MEDIA | RT,                                          SEND(KC_MEDIA_NEXT_TRACK));
 104         P( MEDIA | RD,                                          SEND(KC_VOLU));
 105         P( MEDIA | RZ,                                          SEND(KC_VOLD));
 106         P( MEDIA | RS,                                          SEND(KC_MUTE));
 107   P( MEDIA | ST3,           SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_4));
 108   P( MEDIA | ST4,           SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_2));
 109   P( MEDIA | RR,            SEND(KC_LALT); SEND(KC_LCTL); SEND(KC_LGUI); SEND(KC_3));
 110   P( MEDIA | RB,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_GRV));
 111   P( MEDIA | RG,            SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_8));
 112   P( MEDIA | RE,            SEND(KC_RALT); SEND(KC_F); SEND(KC_I); SEND(KC_R); SEND(KC_E));
 113   P( MEDIA | RU,            SEND(KC_RALT); SEND(KC_T); SEND(KC_A); SEND(KC_D));
 114
 115         // Mouse Keys and Printscreen
 116         P( LFT | LH,                                                    CLICK_MOUSE(KC_MS_BTN1));
 117         P( LK | LR,                                                     CLICK_MOUSE(KC_MS_BTN2));
 118         P( RF | RT,                                                     SEND(KC_PSCR););
 119
 120         // Number Row Left
 121         P( LNO | LSU,                                           SEND(KC_1));
 122         P( LNO | LFT,                                           SEND(KC_2));
 123         P( LNO | LP,                                            SEND(KC_3));
 124         P( LNO | LH,                                            SEND(KC_4));
 125         P( LNO | ST1,                                           SEND(KC_5));
 126         P( LNO | ST3,                                           SEND(KC_6));
 127         P( LNO | RF,                                            SEND(KC_7));
 128         P( LNO | RP,                                            SEND(KC_8));
 129         P( LNO | RL,                                            SEND(KC_9));
 130         P( LNO | RT,                                            SEND(KC_0));
 131         P( LNO | LA,                                            SEND(KC_5));
 132         P( LNO | RT,                                            SEND(KC_0));
 133
 134   // Number Row Right
 135         P( RNO | LSU,                                           SEND(KC_1));
 136         P( RNO | LFT,                                           SEND(KC_2));
 137         P( RNO | LP,                                            SEND(KC_3));
 138         P( RNO | LH,                                            SEND(KC_4));
 139         P( RNO | ST1,                                           SEND(KC_5));
 140         P( RNO | ST3,                                           SEND(KC_6));
 141         P( RNO | RF,                                            SEND(KC_7));
 142         P( RNO | RP,                                            SEND(KC_8));
 143         P( RNO | RL,                                            SEND(KC_9));
 144         P( RNO | RT,                                            SEND(KC_0));
 145         P( RNO | LA,                                            SEND(KC_5));
 146         P( RNO | RT,                                            SEND(KC_0));
 147
 148         // Specials
 149         P( LA | LNO,                                            SEND(KC_ESC));
 150         P( RU | RNO,                                            SEND(KC_TAB));
 151         P( RE | RU,                                                     SEND(KC_LSFT); SEND(KC_SLSH));
 152         P( RD | RZ,                                                     SEND(KC_ENT));
 153         P( RE,                                                          SEND(KC_ENT));
 154         //P( RD,                                                                SEND(KC_BSPC));
 155         P( LNO,                                                         SEND(KC_BSPC));
 156   P( RD,                                                                SEND(KC_DEL));
 157         P( LA,                                                          SEND(KC_SPC));
 158         P( RU,                                                          SEND(KC_SPC));
 159         P( RZ,                                                          SEND(KC_ESC));
 160   //P( RNO,               REPEAT());
 161
 162         // Letters
 163         P( LSU | LSD,                                           SEND(KC_A));
 164         P( LFT | LK,                                            SEND(KC_S));
 165         P( LP  | LW,                                            SEND(KC_E));
 166         P( LH  | LR,                                            SEND(KC_T));
 167         P( ST1 | ST2,                                           SEND(KC_G));
 168         P( ST3 | ST4,                                           SEND(KC_Y));
 169         P( RF  | RR,                                            SEND(KC_N));
 170         P( RT  | RS,                                            SEND(KC_H))
 171         P( RG  | RL,                                            SEND(KC_O));
 172         P( RP  | RB,                                            SEND(KC_I));
 173         P( LSU,                                                         SEND(KC_Q));
 174         P( LSD,                                                         SEND(KC_Z));
 175         P( LFT,                                                         SEND(KC_W));
 176         P( LK,                                                          SEND(KC_X));
 177         P( LP,                                                          SEND(KC_D));
 178         P( LW,                                                          SEND(KC_C));
 179         P( LH,                                                          SEND(KC_F));
 180         P( LR,                                                          SEND(KC_V));
 181         P( ST1,                                                         SEND(KC_K));
 182         P( ST2,                                                         SEND(KC_B));
 183         P( ST3,                                                         SEND(KC_J));
 184         P( ST4,                                                         SEND(KC_P));
 185         P( RF,                                                          SEND(KC_U));
 186         P( RR,                                                          SEND(KC_M));
 187         P( RP,                                                          SEND(KC_R));
 188         P( RB,                                                          SEND(KC_COMM));
 189         P( RL,                                                          SEND(KC_L));
 190         P( RG,                                                          SEND(KC_DOT));
 191         P( RT,                                                          SEND(KC_SCLN));
 192         P( RS,                                                          SEND(KC_SLSH));
 193
 194         // Symbols and Numbers
 195         P( PWR | RE | RU,                                       SEND(KC_ENT));
 196         P( PWR | LA | LO,                                       SEND(KC_SPC));
 197         P( PWR | LP | LW,                                       SEND(KC_LSFT); SEND(KC_9));                     // (
 198         P( PWR | LH | LR,                                       SEND(KC_LSFT); SEND(KC_0));                     // )
 199         P( PWR | ST1 | ST2,                                     SEND(KC_GRV));                                          // `
 200         P( PWR | RD | RZ,                                       SEND(KC_ESC));
 201         P( PWR | LSU | LSD,                                     SEND(KC_LSFT); SEND(KC_3));                     // #
 202         P( PWR | LFT | LK,                                      SEND(KC_LSFT); SEND(KC_4));                     // $
 203         P( PWR | LSU,                                           SEND(KC_LSFT); SEND(KC_1));                     // !
 204         P( PWR | LSD,                                           SEND(KC_LSFT); SEND(KC_5));                     // %
 205         P( PWR | LFT,                                           SEND(KC_LSFT); SEND(KC_2));                     // @
 206         P( PWR | LK,                                            SEND(KC_LSFT); SEND(KC_6));                     // ^
 207         P( PWR | LP,                                            SEND(KC_LSFT); SEND(KC_LBRC));          // {
 208         P( PWR | LW,                                            SEND(KC_LBRC));
 209         P( PWR | LH,                                            SEND(KC_LSFT); SEND(KC_RBRC));          // }
 210         P( PWR | LR,                                            SEND(KC_RBRC));
 211         P( PWR | ST1,                                           SEND(KC_LSFT); SEND(KC_BSLS));          // |
 212         P( PWR | ST2,                                           SEND(KC_LSFT); SEND(KC_GRV));           // ~
 213         P( PWR | ST3,                                           SEND(KC_QUOT));
 214         P( PWR | ST4,                                           SEND(KC_LSFT); SEND(KC_QUOT));          // "
 215         P( PWR | RF,                                            SEND(KC_KP_PLUS));
 216         P( PWR | RR,                                            SEND(KC_LSFT); SEND(KC_7));                     // &
 217         P( PWR | RP,                                            SEND(KC_MINS));
 218         P( PWR | RB,                                            SEND(KC_EQL));
 219         P( PWR | RL,                                            SEND(KC_SLSH));
 220         P( PWR | RG,                                            SEND(KC_LSFT); SEND(KC_MINS));
 221         P( PWR | RT,                                            SEND(KC_PAST));
 222         P( PWR | RS,                                            SEND(KC_DOT));
 223         P( PWR | RD,                                            SEND(KC_TAB));
 224         P( PWR | LA,                                            SEND(KC_LSFT); SEND(KC_SCLN));
 225         P( PWR | LO,                                            SEND(KC_BSLS));
 226         P( PWR | RE,                                            SEND(KC_SCLN));
 227         P( PWR | RU,                                            SEND(KC_BSLS));
 228   P( PWR | RZ,                                          SEND(KC_LSFT));
 229
 230         return 0;
 231 }
 232
 233 #define STENO_LAYER             0
 234 #define GAMING                  1
 235 #define GAMING_2                2
 236 #define MOVEMENT    3
 237
 238 // "Layers"
 239 // Steno layer should be first in your map.
 240 // When PWR | FN | ST3 | ST4 is pressed, the layer is increased to the next map. You must return to STENO_LAYER at the end.
 241 // If you need more space for chords, remove the two gaming layers.
 242
 243 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 244 // Main layer, everything goes through here
 245 [STENO_LAYER] = LAYOUT_georgi(
 246 STN_FN,  STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1,       STN_ST3, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR,
 247 STN_PWR, STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2,       STN_ST4, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR,
 248                                                  STN_N1, STN_A,  STN_O,                 STN_E,   STN_U,  STN_N7)
 249 ,
 250 // Gaming layer with Numpad, Very limited
 251 [GAMING] = LAYOUT_georgi(
 252 KC_LSFT, KC_Q, KC_W, KC_E, KC_R, KC_T,       KC_Y,   KC_U, KC_I, KC_O, KC_P,    KC_ENT,
 253 KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G,       KC_H,   KC_J, KC_K, KC_L, KC_SCLN, KC_DQUO,
 254 KC_LALT, KC_SPC, LT(GAMING_2, KC_ENT),       KC_DEL, KC_ASTR,  TO(STENO_LAYER)),
 255
 256 [GAMING_2] = LAYOUT_georgi(
 257 KC_LSFT, KC_1, KC_2, KC_3, KC_4, KC_5,       KC_6, KC_7, KC_8,  KC_9,  KC_0, KC_MINS,
 258 KC_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B,       KC_N, KC_M, KC_LT, KC_GT, KC_QUES, KC_RSFT,
 259                           KC_LALT, KC_SPC, KC_NO,                    KC_DEL, KC_ASTR,  TO(STENO_LAYER)),
 260
 261 [MOVEMENT] = LAYOUT_georgi(
 262 KC_TRNS, KC_TRNS, KC_TRNS,  KC_TRNS, KC_TRNS,KC_TRNS,       KC_PGUP, KC_TRNS, KC_UP,   KC_TRNS,  KC_TRNS, KC_HOME,
 263 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,       KC_PGDN, KC_LEFT, KC_DOWN, KC_RIGHT, KC_TRNS, KC_END,
 264                           KC_TRNS, KC_TRNS, KC_TRNS,                            KC_TRNS, KC_TRNS, KC_TRNS)
 265 };
 266 // Don't fuck with this, thanks.
 267 size_t keymapsCount  = sizeof(keymaps)/sizeof(keymaps[0]);