keyboards/georgi/keymaps/default/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 int getKeymapCount(void);
  19
  20 // Proper Layers
  21 #define FUNCT   (LSD | LK | LP | LH)
  22 #define MEDIA   (LSD | LK | LW | LR)
  23 #define MOVE    (ST1 | ST2)
  24
  25 /* Keyboard Layout
  26  * ,---------------------------------.    ,------------------------------.
  27  * | FN  | LSU | LFT | LP | LH | ST1 |    | ST3 | RF | RP | RL | RT | RD |
  28  * |-----+-----+-----+----+----|-----|    |-----|----+----+----+----+----|
  29  * | PWR | LSD | LK  | LW | LR | ST2 |    | ST4 | RR | RG | RB | RS | RZ |
  30  * `---------------------------------'    `------------------------------'
  31  *                   ,---------------,    .---------------.
  32  *                   | NUM | LA | LO |    | RE | RU | NUM |
  33  *                   `---------------'    `---------------'
  34  */
  35
  36 // YOU MUST ORDER THIS!
  37 // P   Will return from processing on the first match it finds. Therefore
  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 //
  43 // http://docs.gboards.ca
  44 bool processQwerty(void) {
  45         // Place P's that would be trashed by PJ's here
  46         P( RT  | RS  | RD  | RZ | NUM,          SEND_STRING(VERSION); SEND_STRING(__DATE__));
  47         P( NUM | LA  | LO  | RE | RU,           SEND(KC_MPLY));
  48         P( ST1 | ST2 | ST3 | ST4,                       SEND(KC_BSPC));
  49
  50         // Thumb Chords
  51         P(  LA  | LO  | RE  | RU,                       SEND(KC_CAPS));
  52         P(  LA  | RU,                                           SEND(KC_ESC));
  53         PJ( LO  | RE,                                           SEND(KC_LCTL));
  54         PJ( NUM | LA | RU,                                      SEND(KC_LCTL); SEND(KC_LSFT));
  55         PJ( NUM | LA | RE,                                      SEND(KC_LCTL); SEND(KC_LSFT); SEND(KC_LALT));
  56
  57         // Mods
  58         PJ( RT | RD | RS | RZ,                          SEND(KC_LGUI));
  59         PJ( RT | RD,                                            SEND(KC_LCTL));
  60         PJ( RS | RZ,                                            SEND(KC_LALT));
  61         PJ( LA | NUM,                                           SEND(KC_LCTL));
  62         PJ( LA | LO,                                            SEND(KC_LALT));
  63         PJ( LO,                                                         SEND(KC_LSFT));
  64
  65         // Function Layer
  66         P( FUNCT | RF | RR,                                     SEND(KC_F5));
  67         P( FUNCT | RP | RB,                                     SEND(KC_F6));
  68         P( FUNCT | RL | RG,                                     SEND(KC_F7));
  69         P( FUNCT | RT | RS,                                     SEND(KC_F8));
  70         P( FUNCT | RF,                                          SEND(KC_F1));
  71         P( FUNCT | RP,                                          SEND(KC_F2));
  72         P( FUNCT | RL,                                          SEND(KC_F3));
  73         P( FUNCT | RT,                                          SEND(KC_F4));
  74         P( FUNCT | RR,                                          SEND(KC_F9));
  75         P( FUNCT | RG,                                          SEND(KC_F10));
  76         P( FUNCT | RB,                                          SEND(KC_F11));
  77         P( FUNCT | RS,                                          SEND(KC_F12));
  78
  79         // Movement Layer
  80         P( MOVE | RF,                                           SEND(KC_LEFT));
  81         P( MOVE | RP,                                           SEND(KC_DOWN));
  82         P( MOVE | RL,                                           SEND(KC_UP));
  83         P( MOVE | RT,                                           SEND(KC_RIGHT));
  84         P( MOVE | ST3,                                          SEND(KC_PGUP));
  85         P( MOVE | ST4,                                          SEND(KC_PGDN));
  86
  87         // Media Layer
  88         P( MEDIA | RF,                                          SEND(KC_MPRV));
  89         P( MEDIA | RP,                                          SEND(KC_MPLY));
  90         P( MEDIA | RL,                                          SEND(KC_MPLY));
  91         P( MEDIA | RT,                                          SEND(KC_MNXT));
  92         P( MEDIA | RD,                                          SEND(KC_VOLU));
  93         P( MEDIA | RZ,                                          SEND(KC_VOLD));
  94         P( MEDIA | RS,                                          SEND(KC_MUTE));
  95
  96         // Mouse Keys
  97         P( LP | LH,                                                     clickMouse(KC_MS_BTN1));
  98         P( LW | LR,                                                     clickMouse(KC_MS_BTN2));
  99
 100         // Number Row
 101         P( NUM | LSU,                                           SEND(KC_1));
 102         P( NUM | LFT,                                           SEND(KC_2));
 103         P( NUM | LP,                                            SEND(KC_3));
 104         P( NUM | LH,                                            SEND(KC_4));
 105         P( NUM | ST1,                                           SEND(KC_5));
 106         P( NUM | ST3,                                           SEND(KC_6));
 107         P( NUM | RF,                                            SEND(KC_7));
 108         P( NUM | RP,                                            SEND(KC_8));
 109         P( NUM | RL,                                            SEND(KC_9));
 110         P( NUM | RT,                                            SEND(KC_0));
 111         P( NUM | LA,                                            SEND(KC_5));
 112         P( NUM | RT,                                            SEND(KC_0));
 113
 114         // Specials
 115         P( LA | NUM,                                            SEND(KC_ESC));
 116         P( RU | NUM,                                            SEND(KC_TAB));
 117         P( RE | RU,                                                     SEND(KC_BSPC));
 118         P( RD | RZ,                                                     SEND(KC_ENT));
 119         P( RE,                                                          SEND(KC_ENT));
 120         P( RD,                                                          SEND(KC_BSPC));
 121         P( NUM,                                                         SEND(KC_BSPC));
 122         P( LA,                                                          SEND(KC_SPC));
 123         P( RU,                                                          SEND(KC_SPC));
 124         P( RZ,                                                          SEND(KC_ESC));
 125
 126         // Letters
 127         P( LSU | LSD,                                           SEND(KC_A));
 128         P( LFT | LK,                                            SEND(KC_S));
 129         P( LP  | LW,                                            SEND(KC_D));
 130         P( LH  | LR,                                            SEND(KC_F));
 131         P( ST1 | ST2,                                           SEND(KC_G));
 132         P( ST3 | ST4,                                           SEND(KC_H));
 133         P( RF  | RR,                                            SEND(KC_J));
 134         P( RT  | RS,                                            SEND(KC_SCLN))
 135         P( RG  | RL,                                            SEND(KC_L));
 136         P( RP  | RB,                                            SEND(KC_K));
 137         P( LSU,                                                         SEND(KC_Q));
 138         P( LSD,                                                         SEND(KC_Z));
 139         P( LFT,                                                         SEND(KC_W));
 140         P( LK,                                                          SEND(KC_X));
 141         P( LP,                                                          SEND(KC_E));
 142         P( LW,                                                          SEND(KC_C));
 143         P( LH,                                                          SEND(KC_R));
 144         P( LR,                                                          SEND(KC_V));
 145         P( ST1,                                                         SEND(KC_T));
 146         P( ST2,                                                         SEND(KC_B));
 147         P( ST3,                                                         SEND(KC_Y));
 148         P( ST4,                                                         SEND(KC_N));
 149         P( RF,                                                          SEND(KC_U));
 150         P( RR,                                                          SEND(KC_M));
 151         P( RP,                                                          SEND(KC_I));
 152         P( RB,                                                          SEND(KC_COMM));
 153         P( RL,                                                          SEND(KC_O));
 154         P( RG,                                                          SEND(KC_DOT));
 155         P( RT,                                                          SEND(KC_P));
 156         P( RS,                                                          SEND(KC_SLSH));
 157
 158         // Symbols and Numbers
 159         P( PWR | RE | RU,                                       SEND(KC_ENT));
 160         P( PWR | LA | LO,                                       SEND(KC_SPC));
 161         P( PWR | LP | LW,                                       SEND(KC_LSFT); SEND(KC_9));                     // (
 162         P( PWR | LH | LR,                                       SEND(KC_LSFT); SEND(KC_0));                     // )
 163         P( PWR | ST1 | ST2,                                     SEND(KC_GRV));                                          // `
 164         P( PWR | RD | RZ,                                       SEND(KC_ESC));
 165         P( PWR | LSU | LSD,                                     SEND(KC_LSFT); SEND(KC_3));                     // #
 166         P( PWR | LFT | LK,                                      SEND(KC_LSFT); SEND(KC_4));                     // $
 167         P( PWR | LSU,                                           SEND(KC_LSFT); SEND(KC_1));                     // !
 168         P( PWR | LSD,                                           SEND(KC_LSFT); SEND(KC_5));                     // %
 169         P( PWR | LFT,                                           SEND(KC_LSFT); SEND(KC_2));                     // @
 170         P( PWR | LK,                                            SEND(KC_LSFT); SEND(KC_6));                     // ^
 171         P( PWR | LP,                                            SEND(KC_LSFT); SEND(KC_LBRC));          // {
 172         P( PWR | LW,                                            SEND(KC_LBRC));
 173         P( PWR | LH,                                            SEND(KC_LSFT); SEND(KC_RBRC));          // }
 174         P( PWR | LR,                                            SEND(KC_RBRC));
 175         P( PWR | ST1,                                           SEND(KC_LSFT); SEND(KC_BSLS));          // |
 176         P( PWR | ST2,                                           SEND(KC_LSFT); SEND(KC_GRV));           // ~
 177         P( PWR | ST3,                                           SEND(KC_QUOT));
 178         P( PWR | ST4,                                           SEND(KC_LSFT); SEND(KC_QUOT));          // "
 179         P( PWR | RF,                                            SEND(KC_KP_PLUS));
 180         P( PWR | RR,                                            SEND(KC_LSFT); SEND(KC_7));                     // &
 181         P( PWR | RP,                                            SEND(KC_MINS));
 182         P( PWR | RB,                                            SEND(KC_EQL));
 183         P( PWR | RL,                                            SEND(KC_SLSH));
 184         P( PWR | RG,                                            SEND(KC_COMM));
 185         P( PWR | RT,                                            SEND(KC_PAST));
 186         P( PWR | RS,                                            SEND(KC_DOT));
 187         P( PWR | RD,                                            SEND(KC_TAB));
 188         P( PWR | LA,                                            SEND(KC_SCLN));
 189         P( PWR | LO,                                            SEND(KC_SLSH));
 190         P( PWR | RE,                                            SEND(KC_SCLN));
 191         P( PWR | RU,                                            SEND(KC_SLSH));
 192
 193
 194         // If we make here, send as a steno chord
 195         // If plover is running we can hook that host side
 196         return false;
 197 }
 198
 199 #define STENO_LAYER     0
 200 #define GAMING                  1
 201 #define GAMING_2                2
 202
 203 // "Layers"
 204 // 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.
 206 // If you have only a single layer, you must set SINGLELAYER = yes in your rules.mk, otherwise you may experince undefined behaviour
 207
 208 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 209 // Main layer, everything goes through here
 210 [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,
 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,
 213                                                  STN_N1, STN_A,  STN_O,                 STN_E,   STN_U,  STN_N1)
 214 ,
 215 // Gaming layer with Numpad, Very limited
 216 [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,
 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,
 219 KC_LALT, KC_SPC, LT(GAMING_2, KC_ENT),       KC_DEL, KC_ASTR,  TO(STENO_LAYER)),
 220
 221 [GAMING_2] = LAYOUT_georgi(
 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,
 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,
 224                           KC_LALT, KC_SPC, KC_ENT,           KC_DEL, KC_ASTR,  TO(STENO_LAYER))
 225 };
 226
 227 int getKeymapCount(void) {
 228         return sizeof(keymaps)/sizeof(keymaps[0]);
 229 }