API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 17th, 2018
123
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.67 KB | None | 0 0
raw download clone embed print report
  1. #include "atreus.h"
  2.  
  3. // Each layer gets a name for readability, which is then used in the keymap matrix below.
  4. // The underscores don't mean anything - you can have a layer called STUFF or any other name.
  5. // Layer names don't all need to be of the same length, obviously, and you can also skip them
  6. // entirely and just use numbers.
  7. #define _QW 0
  8. #define _RS 1
  9. #define _LW 2
  10. #define _M 3
  11.  
  12. enum {
  13. TD_ESC_CAPS,
  14. TD_AKSENT,
  15. TD_PGEND,
  16. TD_PGHOME,
  17. CT_CLN,
  18. CT_CLNR,
  19. SINGLE_TAP = 1,
  20. SINGLE_HOLD = 2,
  21. DOUBLE_TAP = 3,
  22. DOUBLE_HOLD = 4,
  23. DOUBLE_SINGLE_TAP = 5,
  24. TRIPLE_TAP = 6,
  25. TRIPLE_HOLD = 7,
  26. X_TAP_DANCE,
  27. X_TAP_DANCE2,
  28. X_TAP_DANCE3
  29.  
  30. };
  31.  
  32. typedef struct {
  33. bool is_press_action;
  34. int state;
  35. } tap;
  36.  
  37. int cur_dance (qk_tap_dance_state_t *state) {
  38. if (state->count == 1) {
  39. if (state->interrupted || !state->pressed) return SINGLE_TAP;
  40. //key has not been interrupted, but they key is still held. Means you want to send a 'HOLD'.
  41. else return SINGLE_HOLD;
  42. }
  43. else if (state->count == 2) {
  44. /*
  45. * DOUBLE_SINGLE_TAP is to distinguish between typing "pepper", and actually wanting a double tap
  46. * action when hitting 'pp'. Suggested use case for this return value is when you want to send two
  47. * keystrokes of the key, and not the 'double tap' action/macro.
  48. */
  49. if (state->interrupted) return DOUBLE_SINGLE_TAP;
  50. else if (state->pressed) return DOUBLE_HOLD;
  51. else return DOUBLE_TAP;
  52. }
  53. //Assumes no one is trying to type the same letter three times (at least not quickly).
  54. //If your tap dance key is 'KC_W', and you want to type "www." quickly - then you will need to add
  55. //an exception here to return a 'TRIPLE_SINGLE_TAP', and define that enum just like 'DOUBLE_SINGLE_TAP'
  56. if (state->count == 3) {
  57. if (state->interrupted || !state->pressed) return TRIPLE_TAP;
  58. else return TRIPLE_HOLD;
  59. }
  60. else return 8; //magic number. At some point this method will expand to work for more presses
  61. }
  62.  
  63. //**************** Definitions needed for quad function to work *********************//
  64.  
  65. //instanalize an instance of 'tap' for the 'x' tap dance.
  66.  
  67. static tap xtap_state = {
  68. .is_press_action = true,
  69. .state = 0
  70. };
  71.  
  72. void x_finished (qk_tap_dance_state_t *state, void *user_data) {
  73. xtap_state.state = cur_dance(state);
  74. switch (xtap_state.state) {
  75. case SINGLE_TAP: register_code(KC_LSFT); register_code(KC_8); break;
  76. case SINGLE_HOLD: register_code(KC_LSFT); register_code(KC_8); break;
  77. case DOUBLE_TAP: register_code(KC_RALT); register_code(KC_8); break;
  78. case DOUBLE_HOLD: register_code(KC_RALT); register_code(KC_8); break;
  79. case DOUBLE_SINGLE_TAP: register_code(KC_RALT); register_code(KC_8); break;
  80. case TRIPLE_HOLD: register_code(KC_RALT); register_code(KC_7); break;
  81. case TRIPLE_TAP: register_code(KC_RALT); register_code(KC_7);
  82. }
  83. }
  84. void x_reset (qk_tap_dance_state_t *state, void *user_data) {
  85. switch (xtap_state.state) {
  86. case SINGLE_TAP: unregister_code(KC_LSFT); unregister_code(KC_8); break;
  87. case SINGLE_HOLD: unregister_code(KC_LSFT); unregister_code(KC_8); break;
  88. case DOUBLE_TAP: unregister_code(KC_RALT); unregister_code(KC_8); break;
  89. case DOUBLE_HOLD: unregister_code(KC_RALT); unregister_code(KC_8); break;
  90. case DOUBLE_SINGLE_TAP: unregister_code(KC_RALT); unregister_code(KC_8); break;
  91. case TRIPLE_HOLD: unregister_code(KC_RALT); unregister_code(KC_7); break;
  92. case TRIPLE_TAP: unregister_code(KC_RALT); unregister_code(KC_7);
  93. }
  94.  
  95. xtap_state.state = 0;
  96. }
  97.  
  98. void x_finished2 (qk_tap_dance_state_t *state, void *user_data) {
  99. xtap_state.state = cur_dance(state);
  100. switch (xtap_state.state) {
  101. case SINGLE_TAP: register_code(KC_LSFT); register_code(KC_9); break;
  102. case SINGLE_HOLD: register_code(KC_LSFT); register_code(KC_9); break;
  103. case DOUBLE_TAP: register_code(KC_RALT); register_code(KC_9); break;
  104. case DOUBLE_HOLD: register_code(KC_RALT); register_code(KC_9); break;
  105. case DOUBLE_SINGLE_TAP: register_code(KC_RALT); register_code(KC_9); break;
  106. case TRIPLE_HOLD: register_code(KC_RALT); register_code(KC_0); break;
  107. case TRIPLE_TAP: register_code(KC_RALT); register_code(KC_0);
  108. }
  109. }
  110. void x_reset2 (qk_tap_dance_state_t *state, void *user_data) {
  111. switch (xtap_state.state) {
  112. case SINGLE_TAP: unregister_code(KC_LSFT); unregister_code(KC_9); break;
  113. case SINGLE_HOLD: unregister_code(KC_LSFT); unregister_code(KC_9); break;
  114. case DOUBLE_TAP: unregister_code(KC_RALT); unregister_code(KC_9); break;
  115. case DOUBLE_HOLD: unregister_code(KC_RALT); unregister_code(KC_9); break;
  116. case DOUBLE_SINGLE_TAP: unregister_code(KC_RALT); unregister_code(KC_9); break;
  117. case TRIPLE_HOLD: unregister_code(KC_RALT); unregister_code(KC_0); break;
  118. case TRIPLE_TAP: unregister_code(KC_RALT); unregister_code(KC_0);
  119. }
  120. xtap_state.state = 0;
  121. }
  122.  
  123. void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) {
  124. if (state->count == 1) {
  125. register_code (KC_LSFT);
  126. register_code (KC_8);
  127. } else {
  128. register_code (KC_RALT);
  129. register_code (KC_8);
  130. }
  131. }
  132.  
  133. void dance_cln_reset (qk_tap_dance_state_t *state, void *user_data) {
  134. if (state->count == 1) {
  135. unregister_code (KC_LSFT);
  136. unregister_code (KC_8);
  137. } else {
  138. unregister_code (KC_RALT);
  139. unregister_code (KC_8);
  140. }
  141. }
  142.  
  143. void dance_cln_finishedr (qk_tap_dance_state_t *state, void *user_data) {
  144. if (state->count == 1) {
  145. register_code (KC_LSFT);
  146. register_code (KC_9);
  147. } else {
  148. register_code (KC_RALT);
  149. register_code (KC_9);
  150. }
  151. }
  152.  
  153. void dance_cln_resetr (qk_tap_dance_state_t *state, void *user_data) {
  154. if (state->count == 1) {
  155. unregister_code (KC_LSFT);
  156. unregister_code (KC_9);
  157. } else {
  158. unregister_code (KC_RALT);
  159. unregister_code (KC_9);
  160. }
  161. }
  162.  
  163. void dance_aksent_finished (qk_tap_dance_state_t *state, void *user_data) {
  164. if (state->count == 1) {
  165. register_code (KC_EQL);
  166. } else {
  167. register_code (KC_RALT);
  168. register_code (KC_EQL);
  169. }
  170. }
  171.  
  172. void dance_aksent_reset (qk_tap_dance_state_t *state, void *user_data) {
  173. if (state->count == 1) {
  174. unregister_code (KC_EQL);
  175. } else {
  176. unregister_code (KC_RALT);
  177. unregister_code (KC_EQL);
  178. }
  179. }
  180.  
  181. void newTabSearch1 (qk_tap_dance_state_t *state, void *user_data) {
  182. if (state->count == 1) {
  183. register_code(KC_LGUI);
  184. } else {
  185. register_code(KC_LCTL);
  186. register_code(KC_C);
  187. unregister_code(KC_C);
  188. register_code(KC_T);
  189. unregister_code(KC_T);
  190. register_code(KC_V);
  191. unregister_code(KC_V);
  192. unregister_code(KC_LCTL);
  193. register_code(KC_ENTER);
  194. unregister_code(KC_ENTER);
  195. }
  196. }
  197.  
  198. void newTabSearch2 (qk_tap_dance_state_t *state, void *user_data) {
  199. if (state->count == 1) {
  200. unregister_code(KC_LGUI);
  201. }
  202. }
  203.  
  204. qk_tap_dance_action_t tap_dance_actions[] = {
  205. [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS),
  206. [TD_AKSENT] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_aksent_finished, dance_aksent_reset),
  207. [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset),
  208. [CT_CLNR] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finishedr, dance_cln_resetr),
  209. [TD_PGEND] = ACTION_TAP_DANCE_DOUBLE(KC_PGDN, KC_END),
  210. [TD_PGHOME] = ACTION_TAP_DANCE_DOUBLE(KC_PGUP, KC_HOME),
  211. [X_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset),
  212. [X_TAP_DANCE2] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished2, x_reset2),
  213. [X_TAP_DANCE3] = ACTION_TAP_DANCE_FN_ADVANCED(NULL,newTabSearch1,newTabSearch2)
  214.  
  215. };
  216.  
  217.  
  218.  
  219. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  220. [_QW] = KEYMAP( /* Qwerty */
  221. KC_Q, KC_W, KC_F, KC_P, KC_B, KC_J, KC_L, KC_U, KC_Y, KC_LBRC ,
  222. KC_A, KC_R, KC_S, KC_T, KC_G, KC_K, KC_N, KC_E, KC_I, KC_O ,
  223. KC_Z, KC_X, KC_C, KC_D, KC_V, KC_M, KC_H, KC_COMM, KC_DOT, KC_MINS,
  224. KC_LCTL, KC_TAB, TD(X_TAP_DANCE3), KC_LSFT, KC_BSPC, TD(TD_ESC_CAPS) , KC_LALT, KC_SPC, MO(_RS), KC_SLSH, KC_RALT, KC_ENT ),
  225.  
  226. [_RS] = KEYMAP( /* [> RAISE <] */
  227. KC_EXLM, KC_AT, KC_UP, KC_NUBS, KC_RBRC, TD(TD_PGHOME), KC_7, KC_8, KC_9, KC_SCLN ,
  228. KC_HASH, KC_LEFT, KC_DOWN, KC_RIGHT, LSFT(KC_5), TD(TD_PGEND), KC_4, KC_5, KC_6, KC_QUOT,
  229. TD(X_TAP_DANCE), TD(X_TAP_DANCE2), KC_GRV, LSFT(KC_0), LSFT(KC_7), LALT(KC_F4),KC_1, KC_2, KC_3, KC_BSLS ,
  230. KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_DEL, TO(_LW), KC_TRNS, KC_TRNS, KC_TRNS, KC_0, KC_TRNS, TD(TD_AKSENT) ),
  231.  
  232. [_LW] = KEYMAP( /* [> LOWER <] */
  233. KC_INS, KC_HOME, KC_VOLU, KC_END, KC_PGUP, KC_UP, KC_F7, KC_F8, KC_F9, KC_F10 ,
  234. KC_MPLY, KC_MPRV, KC_VOLD, KC_MNXT, KC_PGDN, KC_DOWN, KC_F4, KC_F5, KC_F6, KC_F11 ,
  235. KC_PSCR, KC_TRNS, KC_TRNS, KC_TRNS, RESET, KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F12 ,
  236. KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(_M), KC_TRNS, KC_TRNS, KC_TRNS, TO(_QW), KC_TRNS, KC_TRNS, KC_TRNS ),
  237.  
  238. [_M] = KEYMAP( /* [> LOWER <] */
  239. KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO ,
  240. M(0), M(1), M(2), M(3), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO ,
  241. KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO ,
  242. KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, TO(_QW), KC_TRNS, KC_TRNS, KC_TRNS )
  243. };
  244.  
  245. const uint16_t PROGMEM fn_actions[] = {
  246.  
  247. };
  248.  
  249. const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
  250. {
  251. switch(id) {
  252. case 0:
  253. if (record->event.pressed) {
  254. SEND_STRING("hidden");
  255. break;
  256. }
  257. case 1:
  258. if (record->event.pressed) {
  259. SEND_STRING("hidden");
  260. break;
  261. }
  262.  
  263. case 2:
  264. if (record->event.pressed) {
  265. SEND_STRING("hidden");
  266. }
  267.  
  268. case 3:
  269. if (record->event.pressed) {
  270. SEND_STRING("hidden");
  271. break;
  272. }
  273. case 4:
  274. if (record->event.pressed) {
  275. SEND_STRING("test");
  276. // register_code(KC_LCTL);
  277. // register_code(KC_T);
  278. // unregister_code(KC_T);
  279. // register_code(KC_V);
  280. // unregister_code(KC_V);
  281. // unregister_code(KC_LCTL);
  282. // register_code(KC_ENTER);
  283. // unregister_code(KC_ENTER);
  284. break;
  285. }
  286. }
  287. return MACRO_NONE;
  288. };
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!