keyboards/gherkin/keymaps/wanleg/keymap.c

   1 /* Copyright 2017 Brian Fong
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16 #include "gherkin.h"
  17
  18 // Each layer gets a name for readability, which is then used in the keymap matrix below.
  19 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
  20 // Layer names don't all need to be of the same length, obviously, and you can also skip them
  21 // entirely and just use numbers.
  22 #define _QW 0
  23 #define DIR 1
  24 #define NUM 2
  25 #define ETC 3
  26
  27
  28 /////////////// TAP DANCE SECTION START ///////////////
  29 //Tap Dance Declarations (list of my tap dance configurations)
  30 enum {
  31   TD_SFT_CAPS = 0
  32   ,TD_Q_ESC
  33   ,ENT_TAP_DANCE
  34   ,DEL_TAP_DANCE
  35 };
  36
  37 ///// QUAD FUNCTION TAP DANCE GENERAL SETUP SECTION START /////
  38 ///// (no need to edit this section) /////
  39 //Enums used to clearly convey the state of the tap dance
  40 enum {
  41   SINGLE_TAP = 1,
  42   SINGLE_HOLD = 2,
  43   DOUBLE_TAP = 3,
  44   DOUBLE_HOLD = 4,
  45   DOUBLE_SINGLE_TAP = 5 //send SINGLE_TAP twice - NOT DOUBLE_TAP
  46   // Add more enums here if you want for triple, quadruple, etc.
  47 };
  48
  49 typedef struct {
  50   bool is_press_action;
  51   int state;
  52 } tap;
  53
  54 int cur_dance (qk_tap_dance_state_t *state) {
  55   if (state->count == 1) {
  56     //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
  57     if (state->interrupted || !state->pressed) return SINGLE_TAP;
  58     if (state->interrupted) return SINGLE_TAP;
  59     else return SINGLE_HOLD;
  60   }
  61   //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
  62   //with single tap.
  63   else if (state->count == 2) {
  64     if (state->interrupted) return DOUBLE_SINGLE_TAP;
  65     else if (state->pressed) return DOUBLE_HOLD;
  66     else return DOUBLE_TAP;
  67   }
  68   else return 6; //magic number. At some point this method will expand to work for more presses
  69 }
  70 ///// QUAD FUNCTION TAP DANCE GENERAL SETUP SECTION END /////
  71 ///// QUAD FUNCTION TAP DANCE PERSONALIZATION SECTION START /////
  72 //instantialize an instance of 'tap' for the 'ENT' tap dance.
  73 static tap ENTtap_state = {
  74   .is_press_action = true,
  75   .state = 0
  76 };
  77
  78 void ENT_finished (qk_tap_dance_state_t *state, void *user_data) {
  79   ENTtap_state.state = cur_dance(state);
  80   switch (ENTtap_state.state) {
  81     case SINGLE_TAP: register_code(KC_SPC); break;
  82     case SINGLE_HOLD: register_code(KC_LSFT); break;
  83     case DOUBLE_TAP: register_code(KC_ENT); break;
  84     case DOUBLE_HOLD: register_code(KC_NO); break; // setting double hold to do nothing (change this if you want)
  85     case DOUBLE_SINGLE_TAP: register_code(KC_SPC); unregister_code(KC_SPC); register_code(KC_SPC);
  86     //Last case is for fast typing. Assuming your key is `f`:
  87     //For example, when typing the word `buffer`, and you want to make sure that you send `ff` and not `Esc`.
  88     //In order to type `ff` when typing fast, the next character will have to be hit within the `TAPPING_TERM`, which by default is 200ms.
  89   }
  90 }
  91
  92 void ENT_reset (qk_tap_dance_state_t *state, void *user_data) {
  93   switch (ENTtap_state.state) {
  94     case SINGLE_TAP: unregister_code(KC_SPC); break;
  95     case SINGLE_HOLD: unregister_code(KC_LSFT); break;
  96     case DOUBLE_TAP: unregister_code(KC_ENT); break;
  97     case DOUBLE_HOLD: unregister_code(KC_NO);
  98     case DOUBLE_SINGLE_TAP: unregister_code(KC_SPC);
  99   }
 100   ENTtap_state.state = 0;
 101 }
 102
 103 //instanalize an instance of 'tap' for the 'DEL' tap dance.
 104 static tap DELtap_state = {
 105   .is_press_action = true,
 106   .state = 0
 107 };
 108
 109 void DEL_finished (qk_tap_dance_state_t *state, void *user_data) {
 110   DELtap_state.state = cur_dance(state);
 111   switch (DELtap_state.state) {
 112     case SINGLE_TAP: register_code(KC_BSPC); break;
 113     case SINGLE_HOLD: register_code(KC_LCTL); break;
 114     case DOUBLE_TAP: register_code(KC_DEL); break;
 115     case DOUBLE_HOLD: register_code(KC_NO); break;
 116     case DOUBLE_SINGLE_TAP: register_code(KC_BSPC); unregister_code(KC_BSPC); register_code(KC_BSPC);
 117   }
 118 }
 119
 120 void DEL_reset (qk_tap_dance_state_t *state, void *user_data) {
 121   switch (DELtap_state.state) {
 122     case SINGLE_TAP: unregister_code(KC_BSPC); break;
 123     case SINGLE_HOLD: unregister_code(KC_LCTL); break;
 124     case DOUBLE_TAP: unregister_code(KC_DEL); break;
 125     case DOUBLE_HOLD: unregister_code(KC_NO);
 126     case DOUBLE_SINGLE_TAP: unregister_code(KC_BSPC);
 127   }
 128   DELtap_state.state = 0;
 129 }
 130 ///// QUAD FUNCTION TAP DANCE PERSONALIZATION SECTION END /////
 131
 132 //Tap Dance Definitions
 133 //THIS SECTION HAS TO BE AT THE END OF THE TAP DANCE SECTION
 134 qk_tap_dance_action_t tap_dance_actions[] = {
 135   [TD_SFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS)
 136 // Other declarations would go here, separated by commas, if you have them
 137  ,[TD_Q_ESC]  = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC)
 138  ,[ENT_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ENT_finished, ENT_reset)
 139  ,[DEL_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, DEL_finished, DEL_reset)
 140 };
 141
 142 //In Layer declaration, add tap dance item in place of a key code
 143 //TD(TD_SFT_CAPS)
 144
 145 ///////////// TAP DANCE SECTION END ///////////////
 146
 147 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 148
 149  /* Qwerty
 150  * .-----------------------------------------------------------------------------------------.
 151  * | Q//ESC | W      | E      | R      | T      | Y      | U      | I      | O      | P      |
 152  * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 153  * | A      | S      | D      | F      | G      | H      | J      | K      | L      | ENTER  |
 154  * |        |        |        |        |        |        |        |        |        |SFThold |
 155  * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 156  * | Z      | X      | C      | V/NUM  | B/ETC  | N      | M/DIR  | ,/GUI  | ./ALT  | BKSC   |
 157  * | SFThold|        |        |        |        |        |        |        |        |CTRLhold|
 158  * '-----------------------------------------------------------------------------------------'
 159  */
 160
 161  [_QW] = KEYMAP( /* Qwerty*/
 162    TD(TD_Q_ESC), KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,
 163    KC_A,    KC_S,    KC_D,    KC_F,    KC_G, KC_H,    KC_J,    KC_K,    KC_L,   SFT_T(KC_SPC),
 164    SFT_T(KC_Z),    KC_X,    KC_C,    LT(NUM, KC_V), LT(ETC, KC_B), KC_N, LT(DIR, KC_M), GUI_T(KC_COMM), ALT_T(KC_DOT), CTL_T(KC_BSPC)
 165   ),
 166
 167
 168 //
 169 ///*
 170 // *  Directional Modifiers
 171 // * .-----------------------------------------------------------------------------------------.
 172 // * | TAB    |   up   |        | INS    |  CTRL  | SHIFT  | PgUp   | HOME   |  -     |  =     |
 173 // * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 174 // * | left   |  down  | right  | PrScr  | SHIFT  |  CTRL  | PgDn   | END    |  [     |  ]     |
 175 // * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 176 // * | P-Brk  |        |        |        |        |        |        | RGUI   | ALT    |  /     |
 177 // * '-----------------------------------------------------------------------------------------'
 178 // */
 179 //
 180 [DIR] = KEYMAP( /* Directional Modifiers */
 181   KC_TAB,  KC_UP,   KC_TRNS, KC_INS,  KC_LCTL, KC_RSFT, KC_PGUP, KC_HOME, KC_MINS, KC_EQL  ,
 182   KC_LEFT, KC_DOWN, KC_RGHT, KC_PSCR, KC_LSFT, KC_RCTL, KC_PGDN, KC_END,  KC_LBRC, KC_RBRC ,
 183   KC_PAUS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_RGUI, KC_LALT, KC_SLSH
 184 ),
 185 //
 186 // /*
 187 //  *  Numbers
 188 //  * .-----------------------------------------------------------------------------------------.
 189 //  * | F1     | F2     | F3     | F4     | F5     | F6     | F7     | F8     | F9     | F10    |
 190 //  * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 191 //  * | 1      | 2      | 3      | 4      | 5      | 6      | 7      | 8      | 9      | 0      |
 192 //  * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 193 //  * | F11    | F12    |        |        |        | ENTER  | SHIFT  | GUI    | ./ALT  | BKSC   |
 194 //  * |        |        |        |        |        |        |        |        |        |CTRLhold|
 195 //  * '-----------------------------------------------------------------------------------------'
 196 //  */
 197 //
 198 [NUM] = KEYMAP ( /* Numbers */
 199   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10  ,
 200   KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0    ,
 201   KC_F11,  KC_F12,  KC_TRNS, KC_TRNS, KC_TRNS, KC_ENT,  KC_RSFT, KC_RGUI, ALT_T(KC_DOT), CTL_T(KC_BSPC)
 202 ),
 203 //
 204 //
 205 //  /*
 206 //   *  ETC
 207 //   * .-----------------------------------------------------------------------------------------.
 208 //   * |  `     | mUP    |        |        |        | SHIFT  | mUp    | mDown  |        |  \     |
 209 //   * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 210 //   * | mLeft  | mDown  | mRight |        | SHIFT  |        | mBtn1  | mBtn2  |  ;     |  '     |
 211 //   * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 212 //   * | Sft//Cp|        |        |        |        | C-A-D  |        |        | ALT    |  DEL   |
 213 //   * '-----------------------------------------------------------------------------------------'
 214 //   */
 215 //
 216 [ETC] = KEYMAP( /* ETC */
 217   KC_GRV,  KC_MS_U, _______, _______, _______, KC_RSFT, KC_WH_U, KC_WH_D, _______, KC_BSLS ,
 218   KC_MS_L, KC_MS_D, KC_MS_R, KC_TRNS, KC_LSFT, KC_TRNS, KC_BTN1, KC_BTN2, KC_SCLN, KC_QUOT ,
 219   TD(TD_SFT_CAPS), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LALT(LCTL(KC_DEL)), KC_TRNS, KC_TRNS, KC_LALT, KC_DEL
 220  ),
 221 };