keyboards/gherkin/keymaps/mjt/keymap.c

   1 #include "gherkin.h"
   2 #include "action_layer.h"
   3 #ifdef AUDIO_ENABLE
   4   #include "audio.h"
   5 #endif
   6 #include "eeconfig.h"
   7
   8 extern keymap_config_t keymap_config;
   9
  10 //Tap Dance Declarations
  11 enum {
  12   TD_Z_LCTL = 0,
  13   TD_X_LGUI = 1,
  14   TD_C_LALT = 2,
  15   TD_A_TAB = 3,
  16   TD_Q_ESC = 4,
  17 //   M(0)
  18 };
  19
  20 //Friendly Layer Names
  21 enum gherkin_layers {
  22   _QWERTY,
  23   _SONGS,
  24   _NUMBERS,
  25   _SYMBOLS,
  26   _PLOVER,
  27   _ADJUST
  28 };
  29
  30 // custom keycodes
  31 enum gherkin_keycodes {
  32   QWERTY = SAFE_RANGE,
  33   NUMBERS,
  34   SYMBOLS,
  35   SONGS,
  36   PLOVER,
  37   BACKLIT,
  38   MACSLEEP,
  39   EXT_PLV
  40 };
  41
  42 // Fillers to make layering more clear
  43 #define _______ KC_TRNS
  44 #define XXXXXXX KC_NO
  45
  46 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  47   [_QWERTY] = KEYMAP(
  48                 TD(TD_Q_ESC),   KC_W,              KC_E,           KC_R,  KC_T,               KC_Y,  KC_U,  KC_I,     KC_O,    KC_P,
  49                 TD(TD_A_TAB),   LT(_SYMBOLS,KC_S), KC_D,           KC_F,  KC_G,               KC_H,  KC_J,  KC_K,     KC_L,    LT(_ADJUST,KC_SPC),
  50                 TD(TD_Z_LCTL),  TD(TD_X_LGUI),    TD(TD_C_LALT),  KC_V,  KC_B,  LT(_NUMBERS, KC_N),  KC_M,  KC_COMM,  KC_DOT,  SFT_T(KC_ENT))
  51   ,
  52   [_NUMBERS] = KEYMAP(
  53     KC_1,   KC_2,   KC_3,   KC_4,   KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,
  54     KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,   KC_F6,   KC_HOME, KC_PGDN, KC_PGUP,  KC_END ,
  55     KC_F7,  KC_F8,  KC_F9,  KC_F10, LT(_ADJUST,KC_F11),  _______, KC_LEFT, KC_DOWN, KC_UP,   KC_RIGHT)
  56   ,
  57   [_SYMBOLS] = KEYMAP(
  58     KC_EXLM,   KC_AT,   KC_HASH,   KC_DLR,   KC_PERC,  KC_CIRC,  KC_AMPR,  KC_ASTR, KC_LPRN,       KC_RPRN,
  59     KC_GRV,  _______,  XXXXXXX,  KC_LBRC,   KC_RBRC,  KC_BSLS,  KC_MINS,  KC_EQL ,  KC_SCLN,      KC_QUOT,
  60     KC_TILD,  MO(_ADJUST),  XXXXXXX,  KC_LCBR,   KC_RCBR,  KC_PIPE,  KC_UNDS,  KC_PLUS,  S(KC_SCLN), S(KC_QUOT))
  61   ,
  62   [_PLOVER] = KEYMAP(
  63     KC_Q,    KC_W,    KC_E,    KC_R,    KC_1,       KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC,
  64     KC_A,    KC_S,    KC_D,    KC_F,    KC_G,       KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,
  65     EXT_PLV, XXXXXXX, KC_C,    KC_V,    XXXXXXX,    KC_N,    KC_M,    XXXXXXX, XXXXXXX, XXXXXXX)
  66   ,
  67   [_ADJUST] = KEYMAP(
  68     RESET,    _______,  _______,  _______,    _______,  QWERTY,  NUMBERS,  SYMBOLS,     PLOVER,  SONGS,
  69     MUV_DE,   MUV_IN,   MU_ON,    MU_OFF,     _______,  _______,  _______,  _______,     MACSLEEP,  _______,
  70     BACKLIT,  _______,  _______,  _______,    _______,  _______,  _______,  _______,     _______,  _______)
  71 };
  72
  73 #ifdef AUDIO_ENABLE
  74
  75 float tone_startup[][2]    = SONG(STARTUP_SOUND);
  76 float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
  77 float tone_dvorak[][2]     = SONG(DVORAK_SOUND);
  78 float tone_colemak[][2]    = SONG(COLEMAK_SOUND);
  79 float tone_plover[][2]     = SONG(PLOVER_SOUND);
  80 float tone_plover_gb[][2]  = SONG(PLOVER_GOODBYE_SOUND);
  81 float music_scale[][2]     = SONG(MUSIC_SCALE_SOUND);
  82
  83 float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
  84 #endif
  85
  86 void persistant_default_layer_set(uint16_t default_layer) {
  87   eeconfig_update_default_layer(default_layer);
  88   default_layer_set(default_layer);
  89 }
  90
  91 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  92   switch (keycode) {
  93     case QWERTY:
  94       if (record->event.pressed) {
  95         #ifdef AUDIO_ENABLE
  96           PLAY_SONG(tone_qwerty);
  97         #endif
  98         persistant_default_layer_set(1UL<<_QWERTY);
  99       }
 100       return false;
 101       break;
 102     case NUMBERS:
 103       if (record->event.pressed) {
 104         #ifdef AUDIO_ENABLE
 105           PLAY_SONG(tone_dvorak);
 106         #endif
 107         persistant_default_layer_set(1UL<<_NUMBERS);
 108       }
 109       return false;
 110       break;
 111     case SYMBOLS:
 112       if (record->event.pressed) {
 113         #ifdef AUDIO_ENABLE
 114           PLAY_SONG(tone_colemak);
 115         #endif
 116         persistant_default_layer_set(1UL<<_SYMBOLS);
 117       }
 118       return false;
 119       break;
 120     case PLOVER:
 121       if (record->event.pressed) {
 122         #ifdef AUDIO_ENABLE
 123           stop_all_notes();
 124           PLAY_SONG(tone_plover);
 125         #endif
 126         layer_off(_NUMBERS);
 127         layer_off(_SYMBOLS);
 128         layer_off(_ADJUST);
 129         layer_on(_PLOVER);
 130         if (!eeconfig_is_enabled()) {
 131             eeconfig_init();
 132         }
 133         keymap_config.raw = eeconfig_read_keymap();
 134         keymap_config.nkro = 1;
 135         eeconfig_update_keymap(keymap_config.raw);
 136       }
 137       return false;
 138       break;
 139     case EXT_PLV:
 140       if (record->event.pressed) {
 141         #ifdef AUDIO_ENABLE
 142           PLAY_SONG(tone_plover_gb);
 143         #endif
 144         layer_off(_PLOVER);
 145       }
 146       return false;
 147       break;
 148     case MACSLEEP:
 149       if (record->event.pressed) {
 150           // ACTION_MODS_KEY(MOD_LCTL | MOD_LSFT, KC_POWER);
 151           register_code(KC_RSFT);
 152           register_code(KC_RCTL);
 153           register_code(KC_POWER);
 154           unregister_code(KC_POWER);
 155           unregister_code(KC_RCTL);
 156           unregister_code(KC_RSFT);
 157       }
 158       return false;
 159       break;
 160     case BACKLIT:
 161       if (record->event.pressed) {
 162         register_code(KC_RSFT);
 163         #ifdef BACKLIGHT_ENABLE
 164           backlight_step();
 165         #endif
 166       } else {
 167         unregister_code(KC_RSFT);
 168       }
 169       return false;
 170       break;
 171     }
 172     return true;
 173 }
 174
 175
 176 /*
 177 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 178         keyevent_t event = record->event;
 179
 180         switch (id) {
 181         case 0: {
 182             if (record->event.pressed) {
 183                 key_timer = timer_read(); // if the key is being pressed, we start the timer.
 184             }
 185             else { // this means the key was just released, so we can figure out how long it was pressed for (tap or "held down").
 186                 if (timer_elapsed(key_timer) > 150) { // 150 being 150ms, the threshhold we pick for counting something as a tap.
 187                     return MACRO( D(LSFT), END  );
 188                 }
 189                 else {
 190                     return MACRO( T(N), END  );
 191                 }
 192             }
 193             break;
 194         }
 195       }
 196         return MACRO_NONE;
 197 }*/
 198
 199 void matrix_init_user(void) {
 200     #ifdef AUDIO_ENABLE
 201         startup_user();
 202     #endif
 203 }
 204
 205 #ifdef AUDIO_ENABLE
 206
 207 void startup_user()
 208 {
 209     _delay_ms(20); // gets rid of tick
 210     PLAY_SONG(tone_startup);
 211 }
 212
 213 void shutdown_user()
 214 {
 215     PLAY_SONG(tone_goodbye);
 216     _delay_ms(150);
 217     stop_all_notes();
 218 }
 219
 220 void music_on_user(void)
 221 {
 222     music_scale_user();
 223 }
 224
 225 void music_scale_user(void)
 226 {
 227     PLAY_SONG(music_scale);
 228 }
 229
 230 #endif
 231
 232 void matrix_scan_user(void) {
 233 }
 234
 235 //Tap Dance Definitions
 236 qk_tap_dance_action_t tap_dance_actions[] = {
 237   //Tap once for Esc, twice for Caps Lock
 238   [TD_Z_LCTL]  = ACTION_TAP_DANCE_DOUBLE(KC_Z, KC_LCTL),
 239   [TD_X_LGUI]  = ACTION_TAP_DANCE_DOUBLE(KC_X, KC_LGUI),
 240   [TD_C_LALT]  = ACTION_TAP_DANCE_DOUBLE(KC_C, KC_LALT),
 241   [TD_A_TAB]  = ACTION_TAP_DANCE_DOUBLE(KC_A, KC_TAB),
 242   [TD_Q_ESC]  = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC)
 243 };
 244
 245 // don't know what this is doing...
 246 /*
 247 void led_set_user(uint8_t usb_led) {
 248
 249         if (usb_led & (1 << USB_LED_NUM_LOCK)) {
 250                 DDRD |= (1 << 5); PORTD &= ~(1 << 5);
 251         } else {
 252                 DDRD &= ~(1 << 5); PORTD &= ~(1 << 5);
 253         }
 254
 255         if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
 256                 DDRB |= (1 << 0); PORTB &= ~(1 << 0);
 257         } else {
 258                 DDRB &= ~(1 << 0); PORTB &= ~(1 << 0);
 259         }
 260
 261         if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
 262
 263         } else {
 264
 265         }
 266
 267         if (usb_led & (1 << USB_LED_COMPOSE)) {
 268
 269         } else {
 270
 271         }
 272
 273         if (usb_led & (1 << USB_LED_KANA)) {
 274
 275         } else {
 276
 277         }
 278
 279 }
 280 */