users/drashna/drashna.c

   1 #include "drashna.h"
   2 #include "quantum.h"
   3 #include "action.h"
   4 #include "version.h"
   5
   6 // Add reconfigurable functions here, for keymap customization
   7 // This allows for a global, userspace functions, and continued
   8 // customization of the keymap.  Use _keymap instead of _user
   9 // functions in the keymaps
  10 __attribute__ ((weak))
  11 void matrix_init_keymap(void) {}
  12
  13 __attribute__ ((weak))
  14 void matrix_scan_keymap(void) {}
  15
  16 __attribute__ ((weak))
  17 bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
  18   return true;
  19 }
  20 __attribute__ ((weak))
  21 uint32_t layer_state_set_keymap (uint32_t state) {
  22   return state;
  23 }
  24
  25 bool is_overwatch = false;
  26
  27 // Call user matrix init, set default RGB colors and then
  28 // call the keymap's init function
  29 void matrix_init_user(void) {
  30 #ifdef RGBLIGHT_ENABLE
  31   uint8_t default_layer = eeconfig_read_default_layer();
  32
  33   rgblight_enable();
  34
  35   if (true) {
  36     if (default_layer & (1UL << _COLEMAK)) {
  37       rgblight_set_magenta;
  38     }
  39     else if (default_layer & (1UL << _DVORAK)) {
  40       rgblight_set_green;
  41     }
  42     else if (default_layer & (1UL << _WORKMAN)) {
  43       rgblight_set_purple;
  44     }
  45     else {
  46       rgblight_set_teal;
  47     }
  48   }
  49   else
  50   {
  51     rgblight_set_red;
  52     rgblight_mode(5);
  53   }
  54 #endif
  55   matrix_init_keymap();
  56 }
  57
  58 // No global matrix scan code, so just run keymap's matix
  59 // scan function
  60 void matrix_scan_user(void) {
  61   matrix_scan_keymap();
  62 }
  63
  64 #ifdef AUDIO_ENABLE
  65 float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
  66 float tone_dvorak[][2]     = SONG(DVORAK_SOUND);
  67 float tone_colemak[][2]    = SONG(COLEMAK_SOUND);
  68 float tone_workman[][2]    = SONG(PLOVER_SOUND);
  69 #endif
  70
  71
  72 void persistent_default_layer_set(uint16_t default_layer) {
  73   eeconfig_update_default_layer(default_layer);
  74   default_layer_set(default_layer);
  75 }
  76
  77 // Defines actions tor my global custom keycodes. Defined in drashna.h file
  78 // Then runs the _keymap's recod handier if not processed here
  79 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  80
  81 #ifdef CONSOLE_ENABLE
  82   xprintf("KL: row: %u, column: %u, pressed: %u\n", record->event.key.col, record->event.key.row, record->event.pressed);
  83 #endif
  84
  85   switch (keycode) {
  86   case KC_QWERTY:
  87     if (record->event.pressed) {
  88 #ifdef AUDIO_ENABLE
  89       PLAY_SONG(tone_qwerty);
  90 #endif
  91       persistent_default_layer_set(1UL << _QWERTY);
  92     }
  93     return false;
  94     break;
  95   case KC_COLEMAK:
  96     if (record->event.pressed) {
  97 #ifdef AUDIO_ENABLE
  98       PLAY_SONG(tone_colemak);
  99 #endif
 100       persistent_default_layer_set(1UL << _COLEMAK);
 101     }
 102     return false;
 103     break;
 104   case KC_DVORAK:
 105     if (record->event.pressed) {
 106 #ifdef AUDIO_ENABLE
 107       PLAY_SONG(tone_dvorak);
 108 #endif
 109       persistent_default_layer_set(1UL << _DVORAK);
 110     }
 111     return false;
 112     break;
 113   case KC_WORKMAN:
 114     if (record->event.pressed) {
 115 #ifdef AUDIO_ENABLE
 116       PLAY_SONG(tone_workman);
 117 #endif
 118       persistent_default_layer_set(1UL << _WORKMAN);
 119     }
 120     return false;
 121     break;
 122   case LOWER:
 123     if (record->event.pressed) {
 124       layer_on(_LOWER);
 125       update_tri_layer(_LOWER, _RAISE, _ADJUST);
 126     }
 127     else {
 128       layer_off(_LOWER);
 129       update_tri_layer(_LOWER, _RAISE, _ADJUST);
 130     }
 131     return false;
 132     break;
 133   case RAISE:
 134     if (record->event.pressed) {
 135       layer_on(_RAISE);
 136       update_tri_layer(_LOWER, _RAISE, _ADJUST);
 137     }
 138     else {
 139       layer_off(_RAISE);
 140       update_tri_layer(_LOWER, _RAISE, _ADJUST);
 141     }
 142     return false;
 143     break;
 144   case ADJUST:
 145     if (record->event.pressed) {
 146       layer_on(_ADJUST);
 147     }
 148     else {
 149       layer_off(_ADJUST);
 150     }
 151     return false;
 152     break;
 153 #if !(defined(KEYBOARD_orthodox_rev1) || defined(KEYBOARD_ergodox_ez))
 154   case KC_OVERWATCH:
 155     if (record->event.pressed) {
 156       is_overwatch = !is_overwatch;
 157     }
 158 #ifdef RGBLIGHT_ENABLE
 159     is_overwatch ? rgblight_mode(17) : rgblight_mode(18);
 160 #endif
 161     return false;
 162     break;
 163   case KC_SALT:
 164     if (!record->event.pressed) {
 165       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 166       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 167       _delay_ms(50);
 168       SEND_STRING("Salt, salt, salt...");
 169       register_code(KC_ENTER);
 170       unregister_code(KC_ENTER);
 171     }
 172     return false;
 173     break;
 174   case KC_MORESALT:
 175     if (!record->event.pressed) {
 176       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 177       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 178       _delay_ms(50);
 179       SEND_STRING("Please sir, can I have some more salt?!");
 180       register_code(KC_ENTER);
 181       unregister_code(KC_ENTER);
 182     }
 183     return false;
 184     break;
 185   case KC_SALTHARD:
 186     if (!record->event.pressed) {
 187       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 188       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 189       _delay_ms(50);
 190       SEND_STRING("Your salt only makes me harder, and even more aggressive!");
 191       register_code(KC_ENTER);
 192       unregister_code(KC_ENTER);
 193     }
 194     return false;
 195     break;
 196   case KC_GOODGAME:
 197     if (!record->event.pressed) {
 198       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 199       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 200       _delay_ms(50);
 201       SEND_STRING("Good game, everyone!");
 202       register_code(KC_ENTER);
 203       unregister_code(KC_ENTER);
 204   }
 205     return false;
 206     break;
 207   case KC_GLHF:
 208     if (!record->event.pressed) {
 209       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 210       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 211       _delay_ms(50);
 212       SEND_STRING("Good luck, have fun!!!");
 213       register_code(KC_ENTER);
 214       unregister_code(KC_ENTER);
 215     }
 216     return false;
 217     break;
 218   case KC_SYMM:
 219     if (!record->event.pressed) {
 220       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 221       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 222       _delay_ms(50);
 223       SEND_STRING("Left click to win!");
 224       register_code(KC_ENTER);
 225       unregister_code(KC_ENTER);
 226     }
 227     return false;
 228     break;
 229   case KC_JUSTGAME:
 230     if (!record->event.pressed) {
 231       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 232       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 233       _delay_ms(50);
 234       SEND_STRING("It may be a game, but if you don't want to actually try, please go play AI, so that people that actually want to take the game seriously and \"get good\" have a place to do so without trolls like you throwing games.");
 235       register_code(KC_ENTER);
 236       unregister_code(KC_ENTER);
 237     }
 238     return false;
 239     break;
 240   case KC_TORB:
 241     if (!record->event.pressed) {
 242       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 243       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 244       _delay_ms(50);
 245       SEND_STRING("That was positively riveting!");
 246       register_code(KC_ENTER);
 247       unregister_code(KC_ENTER);
 248     }
 249     return false;
 250     break;
 251   case KC_AIM:
 252     if (!record->event.pressed) {
 253       register_code(is_overwatch ? KC_BSPC : KC_ENTER);
 254       unregister_code(is_overwatch ? KC_BSPC : KC_ENTER);
 255       _delay_ms(50);
 256       SEND_STRING("That aim is absolutely amazing. It's almost like you're a machine!" SS_TAP(X_ENTER));
 257       _delay_ms(50);
 258       SEND_STRING("Wait! That aim is TOO good!  You're clearly using an aim hack! CHEATER!" SS_TAP(X_ENTER));
 259     }
 260     return false;
 261     break;
 262 #endif
 263   case KC_MAKE:
 264     if (!record->event.pressed) {
 265       SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP);
 266 #ifndef CATERINA_BOOTLOADER
 267       SEND_STRING(":teensy ");
 268 #else
 269       SEND_STRING(" ");
 270 #endif
 271 #ifdef RGBLIGHT_ENABLE
 272       SEND_STRING("RGBLIGHT_ENABLE=yes ");
 273 #else
 274       SEND_STRING("RGBLIGHT_ENABLE=no ");
 275 #endif
 276 #ifdef AUDIO_ENABLE
 277       SEND_STRING("AUDIO_ENABLE=yes ");
 278 #else
 279       SEND_STRING("AUDIO_ENABLE=no ");
 280 #endif
 281 #ifdef FAUXCLICKY_ENABLE
 282       SEND_STRING("FAUXCLICKY_ENABLE=yes ");
 283 #else
 284       SEND_STRING("FAUXCLICKY_ENABLE=no ");
 285 #endif
 286       SEND_STRING(SS_TAP(X_ENTER));
 287     }
 288     return false;
 289     break;
 290   case KC_RESET:
 291     if (!record->event.pressed) {
 292 #ifdef RGBLIGHT_ENABLE
 293       rgblight_enable();
 294       rgblight_mode(1);
 295       rgblight_setrgb(0xff, 0x00, 0x00);
 296 #endif
 297       reset_keyboard();
 298     }
 299     return false;
 300     break;
 301   case EPRM:
 302     if (record->event.pressed) {
 303       eeconfig_init();
 304     }
 305     return false;
 306     break;
 307   case VRSN:
 308     if (record->event.pressed) {
 309       SEND_STRING(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
 310     }
 311     return false;
 312     break;
 313   }
 314   return process_record_keymap(keycode, record);
 315 }
 316
 317 // Runs state check and changes underglow color and animation
 318 // on layer change, no matter where the change was initiated
 319 // Then runs keymap's layer change check
 320 uint32_t layer_state_set_user (uint32_t state) {
 321 #ifdef RGBLIGHT_ENABLE
 322   uint8_t default_layer = eeconfig_read_default_layer();
 323
 324   switch (biton32(state)) {
 325   case _NAV:
 326     rgblight_set_blue;
 327     rgblight_mode(1);
 328     break;
 329   case _SYMB:
 330     rgblight_set_blue;
 331     rgblight_mode(2);
 332     break;
 333   case _MOUS:
 334     rgblight_set_yellow;
 335     rgblight_mode(1);
 336     break;
 337   case _MACROS:
 338     rgblight_set_orange;
 339     is_overwatch ? rgblight_mode(17) : rgblight_mode(18);
 340     break;
 341   case _MEDIA:
 342     rgblight_set_green;
 343     rgblight_mode(22);
 344     break;
 345   case _OVERWATCH:
 346     rgblight_set_orange;
 347     rgblight_mode(17);
 348     break;
 349   case _DIABLO:
 350     rgblight_set_red;
 351     rgblight_mode(5);
 352     break;
 353   case _RAISE:
 354     rgblight_set_yellow;
 355     rgblight_mode(5);
 356     break;
 357   case _LOWER:
 358     rgblight_set_orange;
 359     rgblight_mode(5);
 360     break;
 361   case _ADJUST:
 362     rgblight_set_red;
 363     rgblight_mode(23);
 364     break;
 365   case _COVECUBE:
 366     rgblight_set_green;
 367     rgblight_mode(2);
 368   default:
 369     if (default_layer & (1UL << _COLEMAK)) {
 370       rgblight_set_magenta;
 371     }
 372     else if (default_layer & (1UL << _DVORAK)) {
 373       rgblight_set_green;
 374     }
 375     else if (default_layer & (1UL << _WORKMAN)) {
 376       rgblight_set_purple;
 377     }
 378     else {
 379       rgblight_set_teal;
 380     }
 381     rgblight_mode(1);
 382     break;
 383   }
 384 #endif
 385   return layer_state_set_keymap (state);
 386 }