keyboards/ergodox_ez/keymaps/lukaus/keymap.c

   1 #include QMK_KEYBOARD_H
   2 #include "version.h"
   3
   4 #include "keymap_german.h"
   5
   6 #include "keymap_nordic.h"
   7
   8 enum custom_keycodes {
   9   PLACEHOLDER = SAFE_RANGE, // can always be here
  10
  11   // Programmer's Dvorak "macros" :
  12   //  To be paired with get_mods to enable both
  13   //  Shift functionality and Programmer's Dvorak
  14
  15   DVP_ESC, // Grave escape basically i think
  16   DVP_AMPR,
  17   DVP_LBRACKET,
  18   DVP_LCBR,
  19   DVP_RCBR,
  20   DVP_LPRN,
  21   DVP_AT,
  22
  23   DVP_EQUAL,
  24   DVP_ASTERISK,
  25   DVP_RPRN,
  26   DVP_PLUS,
  27   DVP_RBRACKET,
  28   DVP_EXLM,
  29   DVP_HASH,
  30
  31   RU_2,
  32   RU_3,
  33   RU_4,
  34   RU_6,
  35   RU_7,
  36   RU_DOT,
  37
  38   SHFT_COMMA,
  39   SHFT_DOT,
  40
  41   RGB_SLD,
  42   RGB_FF0000,
  43   RGB_008000,
  44   RGB_0000FF,
  45   RGB_FFFFFF,
  46   RGB_800080
  47 };
  48
  49 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  50   // Programmer's Dvorak layer
  51   [0] = LAYOUT_ergodox(
  52     DVP_ESC,      DVP_AMPR,         DVP_LBRACKET, DVP_LCBR,         DVP_RCBR,     DVP_LPRN,   DVP_AT,
  53     KC_TAB,       KC_SCOLON,        KC_COMMA,     KC_DOT,           KC_P,         KC_Y,       MO(4),
  54     MO(3),        KC_A,             KC_O,         KC_E,             KC_U,         KC_I,
  55     KC_LSHIFT,    KC_QUOTE,         KC_Q,         KC_J,             KC_K,         KC_X,       KC_HYPR,
  56     KC_LCTL,      KC_LALT,          KC_LGUI,      LCTL(KC_C),       LCTL(KC_V),
  57
  58       KC_MS_BTN3, TO(1),    KC_HOME,  KC_SPACE,   MO(4),  KC_END,
  59
  60     DVP_EQUAL,    DVP_ASTERISK,     DVP_RPRN,     DVP_PLUS,         DVP_RBRACKET, DVP_EXLM,   DVP_HASH,
  61     TT(4),        KC_F,             KC_G,         KC_C,             KC_R,         KC_L,       KC_SLASH,
  62                   KC_D,             KC_H,         KC_T,             KC_N,         KC_S,       KC_MINUS,
  63     KC_MEH,       KC_B,             KC_M,         KC_W,             KC_V,         KC_Z,       MO(3),
  64                                     KC_DELETE,    KC_BSLASH,        KC_RGUI,      KC_RCTL,    LCTL(KC_F),
  65
  66       KC_F17,     KC_F18,   KC_PGUP,  KC_PGDOWN,  KC_ENTER,   KC_BSPACE
  67   ),
  68   // Gaming QWERTY layer
  69   [1] = LAYOUT_ergodox(
  70     KC_ESCAPE,  KC_1,   KC_2,     KC_3,         KC_4,       KC_5,         KC_F14,
  71     KC_TAB,     KC_Q,   KC_W,     KC_E,         KC_R,       KC_T,         KC_F23,
  72     MO(3),      KC_A,   KC_S,     KC_D,         KC_F,       KC_G,
  73     KC_LSHIFT,  KC_Z,   KC_X,     KC_C,         KC_V,       KC_B,         KC_F24,
  74     KC_LCTL,    KC_F8,  KC_LALT,  KC_F14,      KC_F13,
  75
  76       KC_HOME,  TO(0),  KC_F15,  KC_SPACE, KC_LCTL,  KC_LALT,
  77
  78     KC_6,       KC_7,   KC_8,     KC_9,         KC_0,       KC_MINUS,   KC_EQUAL,
  79     KC_F24,     KC_Y,   KC_U,     KC_I,         KC_O,       KC_P,       KC_BSLASH,
  80                 KC_H,   KC_J,     KC_K,         KC_L,       KC_SCOLON,  KC_QUOTE,
  81     KC_F17,     KC_N,   KC_M,     KC_COMMA,     KC_DOT,     KC_SLASH,   KC_RSHIFT,
  82             KC_DELETE,  KC_F19,   KC_LGUI,       KC_F21,     KC_F22,
  83
  84       KC_F17,   KC_F18, KC_PGUP,  KC_PGDOWN,    KC_ENTER,   KC_BSPACE
  85   ),
  86   [2] = LAYOUT_ergodox(
  87     KC_ESCAPE,  KC_F1,     KC_F2,     KC_F3,     KC_F4,     KC_F5,     KC_C,
  88     KC_TAB,     KC_Q,      KC_W,      KC_E,      KC_R,      KC_T,      TO(0),
  89     MO(3),      KC_1,      KC_2,      KC_3,      KC_4,      KC_5,
  90     KC_LSHIFT,  KC_6,      KC_7,      KC_8,      KC_9,      KC_0,     KC_NO,
  91     KC_LCTL,    KC_F8,     KC_LALT,   KC_I,      KC_S,
  92
  93     KC_MS_BTN3, TO(1),  KC_HOME,  KC_SPACE, KC_LSHIFT,  KC_END,
  94
  95     KC_NO,     KC_NUMLOCK,     KC_KP_SLASH,    KC_KP_ASTERISK, KC_KP_MINUS,     KC_NO,   KC_NO,
  96     TO(0),     KC_KP_7,        KC_KP_8,        KC_KP_9,        KC_KP_PLUS,      KC_NO,   KC_NO,
  97                KC_KP_4,        KC_KP_5,        KC_KP_6,        KC_EQUAL,        KC_NO,  KC_NO,
  98     KC_NO,     KC_KP_1,        KC_KP_2,        KC_KP_3,        KC_KP_ENTER,     KC_NO,  KC_NO,
  99                KC_KP_0,        KC_KP_DOT,      KC_NO,          KC_NO,           KC_NO,
 100
 101       TO(0), KC_F18, KC_PGUP,  KC_PGDOWN,  KC_ENTER, KC_BSPACE
 102   ),
 103   // Function Layer
 104   [3] = LAYOUT_ergodox(
 105     KC_DLR,         KC_F1,            KC_F2,              KC_F3,              KC_F4,              KC_F5,          KC_TRANSPARENT,
 106     KC_TRANSPARENT, KC_TRANSPARENT,   KC_MEDIA_PREV_TRACK,KC_MEDIA_PLAY_PAUSE,KC_MEDIA_NEXT_TRACK,KC_NO,          TT(4),
 107     KC_TRANSPARENT, KC_TRANSPARENT,   KC_AUDIO_VOL_DOWN,  KC_AUDIO_VOL_UP,    KC_AUDIO_MUTE,      KC_TRANSPARENT,
 108     KC_LSHIFT,      LALT(KC_Z),       KC_TRANSPARENT,     KC_TRANSPARENT,     KC_F12,             KC_TRANSPARENT, ALL_T(KC_NO),
 109     KC_LCTL,        KC_LALT,          KC_LGUI,            KC_CAPSLOCK,        LSFT(KC_F12),
 110
 111      KC_PSCREEN, KC_PGUP,  KC_PGDOWN,  KC_SPACE, KC_LSHIFT,  KC_INSERT,
 112
 113     KC_F6,          KC_F7,            KC_F8,              KC_F9,              KC_F10,             KC_F11,         KC_F12,
 114     KC_NO,          KC_HOME,          KC_TRANSPARENT,     KC_PSCREEN,         KC_SLCK,            KC_TRANSPARENT, KC_TRANSPARENT,
 115                     KC_LEFT,          KC_DOWN,            KC_UP,              KC_RIGHT,           KC_TRANSPARENT, KC_TRANSPARENT,
 116     MEH_T(KC_NO),   KC_CALCULATOR,    KC_TRANSPARENT,     KC_TRANSPARENT,     KC_TRANSPARENT,     KC_TRANSPARENT, KC_RSHIFT,
 117                                       KC_DELETE,          KC_INSERT,          KC_TRANSPARENT,     KC_F19,         KC_RCTL,
 118
 119      TO(2),KC_TRANSPARENT,KC_TRANSPARENT,LALT(KC_F10),KC_ENTER,KC_BSPACE
 120   ),
 121   // Keypad, Lighting, and Mouse emulation layer
 122  ///*
 123     [4] = LAYOUT_ergodox(
 124     KC_ESCAPE,  KC_NO,      KC_NO,        KC_MS_BTN3, KC_NO,        KC_NO,          KC_NO,
 125     KC_TAB,     KC_NO,      KC_MS_BTN2,   KC_MS_UP,   KC_MS_BTN1,   KC_MS_WH_UP,    TO(0),
 126     KC_NO,      KC_NO,      KC_MS_LEFT,   KC_MS_DOWN, KC_MS_RIGHT,  KC_MS_WH_DOWN,
 127     KC_LSHIFT,  KC_NO,      KC_NO,        KC_UP,      KC_NO,        KC_NO,          TO(5),
 128     KC_LCTL,    KC_NO,      KC_LEFT,      KC_DOWN,    KC_RIGHT,
 129
 130     KC_MS_BTN3, TO(1),  KC_HOME,  KC_SPACE, KC_LSHIFT,  KC_END,
 131
 132     KC_NO,          KC_NUMLOCK,     KC_KP_SLASH,    KC_KP_ASTERISK, KC_CALCULATOR,    KC_NO,      RGB_VAI,
 133     TO(0),          KC_KP_7,        KC_KP_8,        KC_KP_9,        KC_KP_MINUS,      KC_NO,      RGB_VAD,
 134                     KC_KP_4,        KC_KP_5,        KC_KP_6,        KC_KP_PLUS,       KC_NO,    RGB_HUI,
 135     KC_NO,          KC_KP_1,        KC_KP_2,        KC_KP_3,        KC_EQUAL,         RGB_SLD,    RGB_HUD,
 136                                     KC_KP_0,        KC_KP_DOT,      KC_KP_ENTER,      RGB_MOD,   RGB_TOG,
 137
 138       KC_F17, KC_F18, KC_PGUP,  KC_PGDOWN,  KC_ENTER, KC_BSPACE
 139   )
 140   //*/
 141   /*
 142   // Keypad, Lighting, and Mouse emulation layer
 143   [4] = KEYMAP(
 144     KC_ESCAPE,  KC_NO,      KC_NO,        KC_MS_BTN3, KC_NO,        KC_NO,          KC_NO,
 145     KC_TAB,     KC_NO,      KC_MS_BTN2,   KC_MS_UP,   KC_MS_BTN1,   KC_MS_WH_UP,    TO(0),
 146     KC_NO,      KC_NO,      KC_MS_LEFT,   KC_MS_DOWN, KC_MS_RIGHT,  KC_MS_WH_DOWN,
 147     KC_LSHIFT,  KC_NO,      KC_NO,        KC_UP,      KC_NO,        KC_NO,          TO(5),
 148     KC_LCTL,    KC_NO,      KC_LEFT,      KC_DOWN,    KC_RIGHT,
 149
 150     KC_MS_BTN3, TO(1),  KC_HOME,  KC_SPACE, KC_LSHIFT,  KC_END,
 151
 152     KC_NO,    KC_I,       KC_NUMLOCK,     KC_KP_SLASH,    KC_KP_ASTERISK, KC_CALCULATOR,  RGB_VAI,
 153     TO(0),    KC_G,       KC_KP_7,        KC_KP_8,        KC_KP_9,        KC_KP_MINUS,    RGB_VAD,
 154               SHFT_COMMA,       KC_KP_4,        KC_KP_5,        KC_KP_6,        KC_KP_PLUS,     RGB_HUI,
 155     KC_NO,    SHFT_DOT,       KC_KP_1,        KC_KP_2,        KC_KP_3,        KC_EQUAL,       RGB_HUD,
 156               KC_NO,                       KC_KP_0,        KC_KP_DOT,      KC_KP_ENTER,    RGB_TOG,
 157
 158       KC_F17, KC_F18, KC_PGUP,  KC_PGDOWN,  KC_ENTER, KC_BSPACE
 159   )
 160   */
 161
 162 };
 163
 164 void led_set_keymap(uint8_t usb_led) {
 165
 166 }
 167
 168 void matrix_init_user (void) {
 169
 170 }
 171
 172
 173 bool left_shift_down = false;
 174 bool right_shift_down = false;
 175
 176 bool numlock = false;
 177
 178 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 179
 180   switch (keycode) {
 181     case KC_LSHIFT:
 182     if (record->event.pressed)
 183       {
 184         left_shift_down = true;
 185       return true;
 186       }
 187       else
 188       {
 189         left_shift_down = false;
 190         return true;
 191       }
 192     break;
 193     case KC_RSHIFT:
 194
 195       if (record->event.pressed)
 196       {
 197         right_shift_down = true;
 198       return true;
 199       }
 200       else
 201       {
 202         right_shift_down = false;
 203         return true;
 204       }
 205     break;
 206     case KC_NUMLOCK:
 207
 208       if (record->event.pressed)
 209       {
 210         numlock = !numlock;
 211     }
 212     break;
 213
 214     case DVP_ESC:
 215     if (left_shift_down || right_shift_down)
 216     {
 217       if(record->event.pressed)
 218         SEND_STRING("~");
 219       return false;
 220     }
 221     else
 222     {
 223       if(record->event.pressed)
 224         SEND_STRING(SS_DOWN(X_ESCAPE));
 225       else
 226         SEND_STRING(SS_UP(X_ESCAPE));
 227       return false;
 228     }
 229     break;
 230
 231     case DVP_AMPR:
 232     if (left_shift_down || right_shift_down)
 233     {
 234       if(record->event.pressed)
 235       {
 236         SEND_STRING("%");
 237
 238       }
 239     }
 240     else
 241     {
 242       if(record->event.pressed)
 243         SEND_STRING("&");
 244     }
 245     return false;
 246
 247     break;
 248
 249     case SHFT_DOT:
 250       if(record->event.pressed)
 251         SEND_STRING(">");
 252       break;
 253
 254     case SHFT_COMMA:
 255       if(record->event.pressed)
 256         SEND_STRING("<");
 257       break;
 258
 259     case DVP_LBRACKET:
 260     if (left_shift_down || right_shift_down)
 261     {
 262       if(record->event.pressed)
 263         {
 264           if(left_shift_down)
 265             unregister_code(KC_LSHIFT);
 266           if(right_shift_down)
 267             unregister_code(KC_RSHIFT);
 268
 269           register_code(KC_7);
 270           unregister_code(KC_7);
 271
 272           if(left_shift_down)
 273             register_code(KC_LSHIFT);
 274           if(right_shift_down)
 275             register_code(KC_RSHIFT);
 276         }
 277     }
 278     else
 279     {
 280       if(record->event.pressed)
 281         SEND_STRING("[");
 282     }
 283     return false;
 284
 285         return false;
 286         break;
 287
 288     case DVP_LCBR:
 289     if (left_shift_down || right_shift_down)
 290     {
 291       if(record->event.pressed)
 292        {
 293           if(left_shift_down)
 294             unregister_code(KC_LSHIFT);
 295           if(right_shift_down)
 296             unregister_code(KC_RSHIFT);
 297
 298           register_code(KC_5);
 299           unregister_code(KC_5);
 300
 301           if(left_shift_down)
 302             register_code(KC_LSHIFT);
 303           if(right_shift_down)
 304             register_code(KC_RSHIFT);
 305         }
 306     }
 307     else
 308     {
 309       if(record->event.pressed)
 310         SEND_STRING("{");
 311     }
 312     return false;
 313     break;
 314
 315     case DVP_RCBR:
 316     if (left_shift_down || right_shift_down)
 317     {
 318       if(record->event.pressed)
 319       {
 320         if(left_shift_down)
 321           unregister_code(KC_LSHIFT);
 322         if(right_shift_down)
 323           unregister_code(KC_RSHIFT);
 324
 325         register_code(KC_3);
 326         unregister_code(KC_3);
 327
 328         if(left_shift_down)
 329           register_code(KC_LSHIFT);
 330         if(right_shift_down)
 331           register_code(KC_RSHIFT);
 332       }
 333     }
 334     else
 335     {
 336       if(record->event.pressed)
 337         SEND_STRING("}");
 338     }
 339     return false;
 340     break;
 341
 342     case DVP_LPRN:
 343     if (left_shift_down || right_shift_down)
 344     {
 345       if(record->event.pressed)
 346       {
 347         if(left_shift_down)
 348           unregister_code(KC_LSHIFT);
 349         if(right_shift_down)
 350           unregister_code(KC_RSHIFT);
 351
 352         register_code(KC_1);
 353         unregister_code(KC_1);
 354
 355         if(left_shift_down)
 356           register_code(KC_LSHIFT);
 357         if(right_shift_down)
 358           register_code(KC_RSHIFT);
 359       }
 360     }
 361     else
 362     {
 363       if(record->event.pressed)
 364         SEND_STRING("(");
 365     }
 366     return false;
 367     break;
 368
 369     case DVP_AT:
 370     if (left_shift_down || right_shift_down)
 371     {
 372       if(record->event.pressed)
 373       {
 374         if(left_shift_down)
 375           unregister_code(KC_LSHIFT);
 376         if(right_shift_down)
 377           unregister_code(KC_RSHIFT);
 378
 379         register_code(KC_LSHIFT);
 380         register_code(KC_6);
 381         unregister_code(KC_6);
 382         unregister_code(KC_LSHIFT);
 383
 384         if(left_shift_down)
 385           register_code(KC_LSHIFT);
 386         if(right_shift_down)
 387           register_code(KC_RSHIFT);
 388       }
 389     }
 390     else
 391     {
 392       if(record->event.pressed)
 393         SEND_STRING("@");
 394     }
 395     return false;
 396     break;
 397
 398
 399     case DVP_EQUAL:
 400     if (left_shift_down || right_shift_down)
 401     {
 402       if(record->event.pressed)
 403       {
 404         if(left_shift_down)
 405           unregister_code(KC_LSHIFT);
 406         if(right_shift_down)
 407           unregister_code(KC_RSHIFT);
 408
 409         register_code(KC_9);
 410         unregister_code(KC_9);
 411
 412         if(left_shift_down)
 413           register_code(KC_LSHIFT);
 414         if(right_shift_down)
 415           register_code(KC_RSHIFT);
 416       }
 417     }
 418     else
 419     {
 420       if(record->event.pressed)
 421         SEND_STRING("=");
 422     }
 423     return false;
 424     break;
 425
 426     case DVP_ASTERISK:
 427     if (left_shift_down || right_shift_down)
 428     {
 429       if(record->event.pressed)
 430       {
 431         if(left_shift_down)
 432           unregister_code(KC_LSHIFT);
 433         if(right_shift_down)
 434           unregister_code(KC_RSHIFT);
 435
 436         register_code(KC_0);
 437         unregister_code(KC_0);
 438
 439         if(left_shift_down)
 440           register_code(KC_LSHIFT);
 441         if(right_shift_down)
 442           register_code(KC_RSHIFT);
 443       }
 444     }
 445     else
 446     {
 447       if(record->event.pressed)
 448         SEND_STRING("*");
 449     }
 450     return false;
 451     break;
 452
 453     case DVP_RPRN:
 454     if (left_shift_down || right_shift_down)
 455     {
 456       if(record->event.pressed)
 457       {
 458         if(left_shift_down)
 459           unregister_code(KC_LSHIFT);
 460         if(right_shift_down)
 461           unregister_code(KC_RSHIFT);
 462
 463         register_code(KC_2);
 464         unregister_code(KC_2);
 465
 466         if(left_shift_down)
 467           register_code(KC_LSHIFT);
 468         if(right_shift_down)
 469           register_code(KC_RSHIFT);
 470       }
 471     }
 472     else
 473     {
 474       if(record->event.pressed)
 475         SEND_STRING(")");
 476     }
 477     return false;
 478     break;
 479
 480     case DVP_PLUS:
 481     if (left_shift_down || right_shift_down)
 482     {
 483       if(record->event.pressed)
 484       {
 485         if(left_shift_down)
 486           unregister_code(KC_LSHIFT);
 487         if(right_shift_down)
 488           unregister_code(KC_RSHIFT);
 489
 490         register_code(KC_4);
 491         unregister_code(KC_4);
 492
 493         if(left_shift_down)
 494           register_code(KC_LSHIFT);
 495         if(right_shift_down)
 496           register_code(KC_RSHIFT);
 497       }
 498     }
 499     else
 500     {
 501       if(record->event.pressed)
 502         SEND_STRING("+");
 503     }
 504     return false;
 505     break;
 506
 507     case DVP_RBRACKET:
 508     if (left_shift_down || right_shift_down)
 509     {
 510       if(record->event.pressed)
 511       {
 512         if(left_shift_down)
 513           unregister_code(KC_LSHIFT);
 514         if(right_shift_down)
 515           unregister_code(KC_RSHIFT);
 516
 517         register_code(KC_6);
 518         unregister_code(KC_6);
 519
 520         if(left_shift_down)
 521           register_code(KC_LSHIFT);
 522         if(right_shift_down)
 523           register_code(KC_RSHIFT);
 524       }
 525     }
 526     else
 527     {
 528       if(record->event.pressed)
 529         SEND_STRING("]");
 530     }
 531     return false;
 532     break;
 533
 534     case DVP_EXLM:
 535     if (left_shift_down || right_shift_down)
 536     {
 537       if(record->event.pressed)
 538       {
 539         if(left_shift_down)
 540           unregister_code(KC_LSHIFT);
 541         if(right_shift_down)
 542           unregister_code(KC_RSHIFT);
 543
 544         register_code(KC_8);
 545         unregister_code(KC_8);
 546
 547         if(left_shift_down)
 548           register_code(KC_LSHIFT);
 549         if(right_shift_down)
 550           register_code(KC_RSHIFT);
 551       }
 552     }
 553     else
 554     {
 555       if(record->event.pressed)
 556         SEND_STRING("!");
 557     }
 558     return false;
 559     break;
 560
 561     case DVP_HASH:
 562     if (left_shift_down || right_shift_down)
 563     {
 564       if(record->event.pressed)
 565       {
 566         if(left_shift_down)
 567           unregister_code(KC_LSHIFT);
 568         if(right_shift_down)
 569           unregister_code(KC_RSHIFT);
 570
 571         register_code(KC_GRAVE);
 572         unregister_code(KC_GRAVE);
 573
 574         if(left_shift_down)
 575           register_code(KC_LSHIFT);
 576         if(right_shift_down)
 577           register_code(KC_RSHIFT);
 578       }
 579     }
 580     else
 581     {
 582       if(record->event.pressed)
 583         SEND_STRING("#");
 584     }
 585     return false;
 586     break;
 587
 588     // Russian
 589     case RU_2:
 590     if (left_shift_down || right_shift_down)
 591     {
 592       if(record->event.pressed)
 593       {
 594         if(left_shift_down)
 595           unregister_code(KC_LSHIFT);
 596         if(right_shift_down)
 597           unregister_code(KC_RSHIFT);
 598
 599         register_code(KC_GRAVE);
 600         unregister_code(KC_GRAVE);
 601
 602         if(left_shift_down)
 603           register_code(KC_LSHIFT);
 604         if(right_shift_down)
 605           register_code(KC_RSHIFT);
 606       }
 607     }
 608     else
 609     {
 610       if(record->event.pressed)
 611         SEND_STRING("#");
 612     }
 613     return false;
 614     break;
 615 case RU_3:
 616     if (left_shift_down || right_shift_down)
 617     {
 618       if(record->event.pressed)
 619       {
 620         if(left_shift_down)
 621           unregister_code(KC_LSHIFT);
 622         if(right_shift_down)
 623           unregister_code(KC_RSHIFT);
 624
 625         register_code(KC_GRAVE);
 626         unregister_code(KC_GRAVE);
 627
 628         if(left_shift_down)
 629           register_code(KC_LSHIFT);
 630         if(right_shift_down)
 631           register_code(KC_RSHIFT);
 632       }
 633     }
 634     else
 635     {
 636       if(record->event.pressed)
 637         SEND_STRING("#");
 638     }
 639     return false;
 640     break;
 641 case RU_4:
 642     if (left_shift_down || right_shift_down)
 643     {
 644       if(record->event.pressed)
 645       {
 646         if(left_shift_down)
 647           unregister_code(KC_LSHIFT);
 648         if(right_shift_down)
 649           unregister_code(KC_RSHIFT);
 650
 651         register_code(KC_GRAVE);
 652         unregister_code(KC_GRAVE);
 653
 654         if(left_shift_down)
 655           register_code(KC_LSHIFT);
 656         if(right_shift_down)
 657           register_code(KC_RSHIFT);
 658       }
 659     }
 660     else
 661     {
 662       if(record->event.pressed)
 663         SEND_STRING("#");
 664     }
 665     return false;
 666     break;
 667 case RU_6:
 668     if (left_shift_down || right_shift_down)
 669     {
 670       if(record->event.pressed)
 671       {
 672         if(left_shift_down)
 673           unregister_code(KC_LSHIFT);
 674         if(right_shift_down)
 675           unregister_code(KC_RSHIFT);
 676
 677         register_code(KC_GRAVE);
 678         unregister_code(KC_GRAVE);
 679
 680         if(left_shift_down)
 681           register_code(KC_LSHIFT);
 682         if(right_shift_down)
 683           register_code(KC_RSHIFT);
 684       }
 685     }
 686     else
 687     {
 688       if(record->event.pressed)
 689         SEND_STRING("#");
 690     }
 691     return false;
 692     break;
 693 case RU_7:
 694     if (left_shift_down || right_shift_down)
 695     {
 696       if(record->event.pressed)
 697       {
 698         if(left_shift_down)
 699           unregister_code(KC_LSHIFT);
 700         if(right_shift_down)
 701           unregister_code(KC_RSHIFT);
 702
 703         register_code(KC_GRAVE);
 704         unregister_code(KC_GRAVE);
 705
 706         if(left_shift_down)
 707           register_code(KC_LSHIFT);
 708         if(right_shift_down)
 709           register_code(KC_RSHIFT);
 710       }
 711     }
 712     else
 713     {
 714       if(record->event.pressed)
 715         SEND_STRING("#");
 716     }
 717     return false;
 718     break;
 719
 720   case RU_DOT:
 721     if (left_shift_down || right_shift_down)
 722     {
 723       if(record->event.pressed)
 724       {
 725         if(left_shift_down)
 726           unregister_code(KC_LSHIFT);
 727         if(right_shift_down)
 728           unregister_code(KC_RSHIFT);
 729
 730         register_code(KC_GRAVE);
 731         unregister_code(KC_GRAVE);
 732
 733         if(left_shift_down)
 734           register_code(KC_LSHIFT);
 735         if(right_shift_down)
 736           register_code(KC_RSHIFT);
 737       }
 738     }
 739     else
 740     {
 741       if(record->event.pressed)
 742         SEND_STRING("#");
 743     }
 744     return false;
 745     break;
 746
 747
 748     case RGB_SLD:
 749       if (record->event.pressed) {
 750         rgblight_mode(1);
 751       }
 752       return false;
 753       break;
 754
 755     case RGB_FF0000:
 756       if (record->event.pressed) {
 757         #ifdef RGBLIGHT_ENABLE
 758           rgblight_enable();
 759           rgblight_mode(1);
 760           rgblight_setrgb(0xff,0x00,0x00);
 761         #endif
 762       }
 763       return false;
 764       break;
 765
 766     case RGB_008000:
 767       if (record->event.pressed) {
 768         #ifdef RGBLIGHT_ENABLE
 769           rgblight_enable();
 770           rgblight_mode(1);
 771           rgblight_setrgb(0x00,0x80,0x00);
 772         #endif
 773       }
 774       return false;
 775       break;
 776
 777     case RGB_0000FF:
 778       if (record->event.pressed) {
 779         #ifdef RGBLIGHT_ENABLE
 780           rgblight_enable();
 781           rgblight_mode(1);
 782           rgblight_setrgb(0x00,0x00,0xff);
 783         #endif
 784       }
 785       return false;
 786       break;
 787
 788     case RGB_FFFFFF:
 789       if (record->event.pressed) {
 790         #ifdef RGBLIGHT_ENABLE
 791           rgblight_enable();
 792           rgblight_mode(1);
 793           rgblight_setrgb(0xff,0xff,0xff);
 794         #endif
 795       }
 796       return false;
 797       break;
 798
 799     case RGB_800080:
 800       if (record->event.pressed) {
 801         #ifdef RGBLIGHT_ENABLE
 802           rgblight_enable();
 803           rgblight_mode(1);
 804           rgblight_setrgb(0x80,0x00,0x80);
 805         #endif
 806       }
 807       return false;
 808       break;
 809
 810   }
 811   return true;
 812 }
 813
 814 uint32_t layer_state_set_user(uint32_t state) {
 815
 816     uint8_t layer = biton32(state);
 817
 818   //  ergodox_board_led_off();
 819     ergodox_right_led_1_off();
 820     ergodox_right_led_2_off();
 821     ergodox_right_led_3_off();
 822     switch (layer) {
 823       case 0:
 824         break;
 825       case 1:
 826         ergodox_right_led_1_on();
 827         break;
 828       case 2:
 829         ergodox_right_led_2_on();
 830         break;
 831       case 3:
 832         ergodox_right_led_3_on();
 833         break;
 834       case 4:
 835         ergodox_right_led_1_on();
 836         ergodox_right_led_3_on();
 837         break;
 838       default:
 839         break;
 840     }
 841     return state;
 842
 843 };