keyboards/roadkit/keymaps/flipphone/keymap.c

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