keyboards/roadkit/keymaps/flipphone/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   _FPH,
  21   _FPHNOISY,
  22   _ADJUST,
  23   _DYN
  24 };
  25
  26 enum roadkit_keycodes {
  27   NUMPAD = SAFE_RANGE,
  28   FPH_1,
  29   FPH_2,
  30   FPH_3,
  31   FPH_4,
  32   FPH_5,
  33   FPH_6,
  34   FPH_7,
  35   FPH_8,
  36   FPH_9,
  37   FN_0,
  38   BACKLIT,
  39   MACSLEEP,
  40   DYNAMIC_MACRO_RANGE,
  41 };
  42
  43 #include "dynamic_macro.h"
  44
  45 // Fillers to make keymaps cleaner looking
  46 #define _______ KC_TRNS
  47 #define XXXXXXX KC_NO
  48
  49 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  50   [_NUMPAD] = /* Numpad */
  51     KEYMAP(KC_KP_7, KC_KP_8,   KC_KP_9, KC_KP_PLUS,  \
  52            KC_KP_4, KC_KP_5,   KC_KP_6,              \
  53            KC_KP_1, KC_KP_2,   KC_KP_3, KC_KP_ENTER, \
  54            LT(_ADJUST, KC_KP_0),  KC_KP_DOT),
  55   [_FPH] = /* Quiet T9 */
  56     KEYMAP(FPH_7, FPH_8,   FPH_9, KC_KP_PLUS,  \
  57            FPH_4, FPH_5,   FPH_6,              \
  58            FPH_1, FPH_2,   FPH_3, SFT_T(KC_KP_ENTER), \
  59            LT(_ADJUST, KC_SPACE),   KC_KP_DOT),
  60   [_FPHNOISY] = /* Noisy T9 */
  61     KEYMAP(FPH_7, FPH_8,   FPH_9, KC_KP_PLUS,  \
  62            FPH_4, FPH_5,   FPH_6,              \
  63            FPH_1, FPH_2,   FPH_3, SFT_T(KC_KP_ENTER), \
  64            LT(_ADJUST, KC_SPACE),   KC_KP_DOT),
  65  [_ADJUST] = /* Adjustments */
  66    KEYMAP(KC_NUMLOCK, TG(_FPHNOISY),  TG(_FPH), TG(_NUMPAD),  \
  67          KC_BSPC, BACKLIT,   KC_DEL,              \
  68          MACSLEEP, _______,   _______, _______, \
  69          _______,           MO(_DYN)),
  70  [_DYN] = /* DYNAMIC MACRO */
  71     KEYMAP(DYN_REC_START1, DYN_REC_START2, _______, DYN_REC_STOP,  \
  72          _______, _______,  _______,              \
  73          DYN_MACRO_PLAY1, DYN_MACRO_PLAY2, _______, _______, \
  74          _______,            _______),
  75 };
  76
  77 const uint16_t PROGMEM fn_actions[] = {
  78
  79 };
  80
  81 void persistant_default_layer_set(uint16_t default_layer) {
  82   eeconfig_update_default_layer(default_layer);
  83   default_layer_set(default_layer);
  84 }
  85
  86 uint16_t fph_tap_qty = false;
  87 uint16_t fph_keycode = 0; // stores which spacebar was used, either raise or lower...
  88
  89 uint16_t get_render_keycode(uint16_t keycode, uint16_t tap_qty){ // maybe replace shift with "mods"
  90   tap_qty--; // reduce by one to match array indexes.
  91   switch(keycode){
  92     case FPH_2:
  93       {uint16_t kc[] = {KC_A, KC_B, KC_C};
  94        if(tap_qty % 6 > 2)
  95         return LSFT(kc[tap_qty % 3]);
  96       return kc[tap_qty % 3];}
  97     break;
  98     case FPH_3:
  99       {uint16_t kc[] = {KC_D, KC_E, KC_F};
 100        if(tap_qty % 6 > 2)
 101         return LSFT(kc[tap_qty % 3]);
 102       return kc[tap_qty % 3];}
 103     break;
 104     case FPH_4:
 105       {uint16_t kc[] = {KC_G, KC_H, KC_I};
 106        if(tap_qty % 6 > 2)
 107         return LSFT(kc[tap_qty % 3]);
 108       return kc[tap_qty % 3];}
 109     break;
 110     case FPH_5:
 111       {uint16_t kc[] = {KC_J, KC_K, KC_L};
 112        if(tap_qty % 6 > 2)
 113         return LSFT(kc[tap_qty % 3]);
 114       return kc[tap_qty % 3];}
 115     break;
 116     case FPH_6:
 117       {uint16_t kc[] = {KC_M, KC_N, KC_O};
 118        if(tap_qty % 6 > 2)
 119         return LSFT(kc[tap_qty % 3]);
 120       return kc[tap_qty % 3];}
 121     break;
 122     case FPH_7:
 123       {uint16_t kc[] = {KC_P, KC_Q, KC_R, KC_S};
 124        if(tap_qty % 8 > 2)
 125         return LSFT(kc[tap_qty % 4]);
 126       return kc[tap_qty % 4];}
 127     break;
 128     case FPH_8:
 129       {uint16_t kc[] = {KC_T, KC_U, KC_V};
 130        if(tap_qty % 8 > 2)
 131         return LSFT(kc[tap_qty % 4]);
 132       return kc[tap_qty % 4];}
 133     break;
 134     case FPH_9:
 135       {uint16_t kc[] = {KC_W, KC_X, KC_Y, KC_Z};
 136        if(tap_qty % 8 > 2)
 137         return LSFT(kc[tap_qty % 4]);
 138       return kc[tap_qty % 4];}
 139     break;
 140     case FPH_1:
 141       {uint16_t kc[] = {KC_COMM, LSFT(KC_SLSH), KC_EXLM, KC_AT, KC_MINS, KC_UNDS, KC_PLUS, \
 142           KC_SCLN, LSFT(KC_SCLN), KC_QUOT, LSFT(KC_QUOT), KC_TILD, \
 143           KC_PIPE, KC_BSLS, KC_HASH, LSFT(KC_4), KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, \
 144           KC_LBRC, KC_RBRC, KC_LCBR, KC_RCBR, LSFT(KC_COMM), LSFT(KC_DOT)};
 145       return kc[tap_qty % 26];}
 146   }
 147   return KC_NO;
 148 }
 149
 150 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 151     if (!process_record_dynamic_macro(keycode, record)) {
 152       return false;
 153     }
 154     uint8_t layer;
 155     layer = biton32(layer_state);
 156
 157     switch (keycode) {
 158     case FPH_1 ... FPH_9:
 159       if(layer == _FPHNOISY){
 160         if (record->event.pressed) {
 161           if(fph_keycode != keycode) { // key change
 162             fph_tap_qty = 0;
 163             fph_keycode = keycode;
 164           } else { // same key tapped again so erase and increment.
 165             register_code(KC_BSPC);
 166             unregister_code(KC_BSPC);
 167             fph_tap_qty++;
 168           }
 169           uint16_t render_keycode = get_render_keycode(keycode, fph_tap_qty);
 170           // find mods? Apply mods..
 171           register_code(render_keycode);
 172           unregister_code(render_keycode);
 173         } else {
 174           // do we need to do anything on key-release?
 175         }
 176       } else { // not noisy, be demure .
 177         if (record->event.pressed) {
 178           if(fph_keycode != keycode) { // key change, kill everything.
 179             uint16_t render_keycode = get_render_keycode(fph_keycode, fph_tap_qty);
 180             // find mods? Apply mods..
 181             register_code(render_keycode);
 182             unregister_code(render_keycode);
 183             fph_keycode = keycode;
 184             fph_tap_qty = 0;
 185           } else { // same key tapped again so increment counter silently
 186             fph_tap_qty++;
 187           }
 188         } else {
 189             // do we need to do anything on key-release?
 190             // maybe start a timer on this one?
 191         }
 192       }
 193       return false;
 194       break;
 195     case BACKLIT:
 196       if (record->event.pressed) {
 197         #ifdef BACKLIGHT_ENABLE
 198           backlight_step();
 199         #endif
 200       }
 201       return false;
 202       break;
 203     case MACSLEEP:
 204       if (record->event.pressed) {
 205           register_code(KC_RSFT);
 206           register_code(KC_RCTL);
 207           register_code(KC_POWER);
 208           unregister_code(KC_POWER);
 209           unregister_code(KC_RCTL);
 210           unregister_code(KC_RSFT);
 211       }
 212       return false;
 213       break;
 214   }
 215   return true;
 216 }