keyboards/roadkit/keymaps/mjt/keymap.c

   1 #include "roadkit.h"
   2 #include "action_layer.h"
   3 #include "eeconfig.h"
   4
   5 extern keymap_config_t keymap_config;
   6
   7 #ifdef BACKLIGHT_ENABLE
   8   #include "backlight.h"
   9 #endif
  10
  11 #ifdef AUDIO_ENABLE
  12   #include "audio.h"
  13 #endif
  14
  15 void backlight_toggle(void){
  16 };
  17
  18 enum roadkit_layers {
  19   _NUMPAD,
  20   _NAVIGATION,
  21   _EXCEL,
  22   _ADJUST,
  23   _DYN
  24 };
  25
  26 enum minivan_keycodes {
  27   NUMPAD = SAFE_RANGE,
  28   NAVIGATION,
  29   EXCEL,
  30   NUMPAD_LOCK,
  31   NAVIGATION_LOCK,
  32   EXCEL_LOCK,
  33   PARENS,
  34   BRACKETS,
  35   BRACES,
  36   BACKLIT,
  37   MACSLEEP,
  38   DYNAMIC_MACRO_RANGE,
  39 };
  40
  41 #include "dynamic_macro.h"
  42
  43 // Fillers to make keymaps cleaner looking
  44 #define _______ KC_TRNS
  45 #define XXXXXXX KC_NO
  46
  47
  48 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  49   [_NUMPAD] = /* Numpad */
  50     KEYMAP(KC_KP_7, KC_KP_8,   KC_KP_9, KC_KP_PLUS,  \
  51            KC_KP_4, KC_KP_5,   KC_KP_6,              \
  52            KC_KP_1, KC_KP_2,   KC_KP_3, NAVIGATION, \
  53            EXCEL,            KC_KP_DOT),
  54   [_EXCEL] = /* Excel related */
  55     KEYMAP(KC_KP_SLASH, KC_KP_ASTERISK,   KC_MINS, KC_TAB,  \
  56           KC_QUOT, KC_KP_EQUAL,  PARENS ,              \
  57           KC_DQT, BRACKETS,  BRACES, _______, \
  58           _______,            MO(_DYN)),
  59   [_NAVIGATION] = /* Navigation */
  60     KEYMAP(KC_HOME, _______,  KC_PGUP, KC_TAB,  \
  61           KC_END,  KC_UP,     KC_PGDN,              \
  62           KC_LEFT, KC_DOWN,   KC_RIGHT, _______, \
  63           _______,            MO(_DYN)),
  64  [_ADJUST] = /* Adjustments */
  65    KEYMAP(KC_NUMLOCK, MACSLEEP,   BACKLIT, _______,  \
  66          KC_BSPC, _______,   KC_DEL,              \
  67          EXCEL_LOCK, NUMPAD_LOCK,   NAVIGATION_LOCK, _______, \
  68          _______,          _______),
  69  [_DYN] = /* DYNAMIC MACRO */
  70     KEYMAP(DYN_REC_START1, DYN_REC_START2, _______, _______,  \
  71          _______, _______,  _______,              \
  72          DYN_MACRO_PLAY1, DYN_MACRO_PLAY2, _______, _______, \
  73          _______,            _______),
  74 };
  75
  76 const uint16_t PROGMEM fn_actions[] = {
  77
  78 };
  79
  80 #ifdef AUDIO_ENABLE
  81
  82 float tone_startup[][2]    = SONG(STARTUP_SOUND);
  83 float tone_numpad[][2]     = SONG(QWERTY_SOUND);
  84 float tone_excel[][2]     = SONG(DVORAK_SOUND);
  85 float tone_navigation[][2]    = SONG(COLEMAK_SOUND);
  86 float tone_plover[][2]     = SONG(PLOVER_SOUND);
  87 float tone_plover_gb[][2]  = SONG(PLOVER_GOODBYE_SOUND);
  88 float music_scale[][2]     = SONG(MUSIC_SCALE_SOUND);
  89
  90 float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
  91 #endif
  92
  93 void persistant_default_layer_set(uint16_t default_layer) {
  94   eeconfig_update_default_layer(default_layer);
  95   default_layer_set(default_layer);
  96 }
  97
  98 bool fn_tap_used = false; // sets to false when space is pressed,
  99                           // sets to true when any other key is pressed,
 100                           //when space is lifted, if another key was prssed, don't send space.
 101 uint16_t fn_keycode = 0; // stores which spacebar was used, either raise or lower...
 102
 103 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 104   if (!process_record_dynamic_macro(keycode, record)) {
 105     return false;
 106   }
 107
 108   switch (keycode) {
 109       case NAVIGATION: // This key is enter if tapped, navigation if held
 110         if (record->event.pressed) {
 111           fn_keycode = NAVIGATION; // these two lines figure out if the next action is
 112           fn_tap_used = false;
 113           layer_on(_NAVIGATION);
 114           update_tri_layer(_EXCEL, _NAVIGATION, _ADJUST);
 115         } else {
 116           layer_off(_NAVIGATION);
 117           update_tri_layer(_EXCEL, _NAVIGATION, _ADJUST);
 118           if(!fn_tap_used && fn_keycode == NAVIGATION ){
 119               register_code(KC_KP_ENTER);
 120               unregister_code(KC_KP_ENTER);
 121               fn_keycode = 0;
 122               fn_tap_used = false;
 123           }
 124         }
 125         return false;
 126         break;
 127       case EXCEL:
 128         if (record->event.pressed) {
 129           fn_keycode = EXCEL;
 130           fn_tap_used = false;
 131           layer_on(_EXCEL);
 132           update_tri_layer(_EXCEL, _NAVIGATION, _ADJUST);
 133         } else {
 134           layer_off(_EXCEL);
 135           update_tri_layer(_EXCEL, _NAVIGATION, _ADJUST);
 136           if(!fn_tap_used && fn_keycode == EXCEL ){
 137               register_code(KC_KP_0);
 138               unregister_code(KC_KP_0);
 139               fn_keycode = 0;
 140               fn_tap_used = false;
 141           }
 142         }
 143         return false;
 144         break;
 145     default:
 146         fn_tap_used = true;
 147         break; // don't return because this just handles the spacebars.
 148     }
 149     // this is the normal keycode processing switch from Planck default layout.
 150     switch (keycode) {
 151     case NUMPAD_LOCK:
 152       if (record->event.pressed) {
 153         #ifdef AUDIO_ENABLE
 154           PLAY_NOTE_ARRAY(tone_numpad, false, 0);
 155         #endif
 156         persistant_default_layer_set(1UL<<_NUMPAD);
 157       }
 158       return false;
 159       break;
 160     case NAVIGATION_LOCK:
 161       if (record->event.pressed) {
 162         #ifdef AUDIO_ENABLE
 163           PLAY_NOTE_ARRAY(tone_navigation, false, 0);
 164         #endif
 165         persistant_default_layer_set(1UL<<_NAVIGATION);
 166       }
 167       return false;
 168       break;
 169     case EXCEL_LOCK:
 170       if (record->event.pressed) {
 171         #ifdef AUDIO_ENABLE
 172           PLAY_NOTE_ARRAY(tone_excel, false, 0);
 173         #endif
 174         persistant_default_layer_set(1UL<<_EXCEL);
 175       }
 176       return false;
 177       break;
 178     case PARENS:
 179       if (record->event.pressed) {
 180           register_code(KC_RSFT);
 181           register_code(KC_9);
 182           unregister_code(KC_9);
 183           register_code(KC_0);
 184           unregister_code(KC_0);
 185           register_code(KC_RSFT);
 186           register_code(KC_LEFT);
 187           unregister_code(KC_LEFT);
 188       }
 189       return false;
 190       break;
 191     case BRACKETS:
 192       if (record->event.pressed) {
 193           register_code(KC_LBRC);
 194           unregister_code(KC_LBRC);
 195           register_code(KC_RBRC);
 196           unregister_code(KC_RBRC);
 197           register_code(KC_LEFT);
 198           unregister_code(KC_LEFT);
 199         }
 200         return false;
 201         break;
 202     case BRACES:
 203       if (record->event.pressed) {
 204           register_code(KC_RSFT);
 205           register_code(KC_LBRC);
 206           unregister_code(KC_LBRC);
 207           register_code(KC_RBRC);
 208           unregister_code(KC_RBRC);
 209           unregister_code(KC_RSFT);
 210           register_code(KC_LEFT);
 211           unregister_code(KC_LEFT);
 212       }
 213       return false;
 214       break;
 215     case BACKLIT:
 216       if (record->event.pressed) {
 217         #ifdef BACKLIGHT_ENABLE
 218           backlight_step();
 219         #endif
 220       }
 221       return false;
 222       break;
 223     case MACSLEEP:
 224       if (record->event.pressed) {
 225           register_code(KC_RSFT);
 226           register_code(KC_RCTL);
 227           register_code(KC_POWER);
 228           unregister_code(KC_POWER);
 229           unregister_code(KC_RCTL);
 230           unregister_code(KC_RSFT);
 231       }
 232       return false;
 233       break;
 234   }
 235   return true;
 236 }