HCoop / jackhill / qmk / firmware.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
backlight breathing overhaul (#2187)
[jackhill/qmk/firmware.git] / keyboards / preonic / keymaps / zach / zach_common_functions.c
1 #ifndef ZACH_COMMON_FUNCTIONS
2 #define ZACH_COMMON_FUNCTIONS
3 #include "eeconfig.h"
4 #include "action_layer.h"
5 #include "keymap_colemak.h"
6 extern keymap_config_t keymap_config;
7
8 // Fillers to make layering more clear
9 #define _______ KC_TRNS
10 #define XXXXXXX KC_NO
11 #define C(n) RCTL(n)
12 #define CADKEY RCTL(RALT(KC_DEL))
13
14 void tap(uint16_t keycode){
15 register_code(keycode);
16 unregister_code(keycode);
17 };
18
19 void persistent_default_layer_set(uint16_t default_layer){
20 eeconfig_update_default_layer(default_layer);
21 default_layer_set(default_layer);
22 };
23
24 // Automatic number generation of important keywords
25 enum my_keycodes{
26 // Layer numbers
27 _COLEMAK = 0,
28 _SWCOLE,
29 _RAISE,
30 _LOWER,
31 _ADJUST,
32 _UNICODES,
33 // These use process_record_user()
34 COLEMAK = SAFE_RANGE,
35 SWCOLE,
36 LOWER,
37 RAISE,
38 SHFT_CAP,
39 CTRLB,
40 CPYPST,
41 FACE,
42 UNIWIN,
43 UNILIN,
44 DISFACE,
45 TFLIP,
46 TPUT,
47 SHRUG,
48 RANDIG,
49 // Tap_Dance nums
50 RAI = 0,
51 LOW,
52 SUP
53 };
54
55 #ifdef AUDIO_ENABLE
56 #include "audio.h"
57 float tone_startup[][2] = SONG(STARTUP_SOUND);
58 float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
59 float tone_colemak[][2] = SONG(COLEMAK_SOUND);
60 float tone_swcole[][2] = SONG(QWERTY_SOUND);
61 float tone_capslock_on[][2] = SONG(CAPS_LOCK_ON_SOUND);
62 float tone_capslock_off[][2] = SONG(CAPS_LOCK_OFF_SOUND);
63 float tone_ctrl_mod[][2] = SONG(COIN_SOUND);
64 float tone_copy[][2] = SONG(SCROLL_LOCK_ON_SOUND);
65 float tone_paste[][2] = SONG(SCROLL_LOCK_OFF_SOUND);
66 float uniwin[][2] = SONG(UNICODE_WINDOWS);
67 float unilin[][2] = SONG(UNICODE_LINUX);
68 #endif
69
70 #ifdef TAP_DANCE_ENABLE
71 #define TAPPING_TERM 200
72
73 void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called on each tap
74 switch(state->count){ // Only turn the layer on once
75 case 1:
76 layer_off(_UNICODES);
77 layer_on(_RAISE);
78 update_tri_layer(_LOWER, _RAISE, _ADJUST);
79 break;
80 }
81 };
82 void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release
83 switch(state->count){
84 case 1: // Normal action. Turn off layers
85 layer_off(_RAISE);
86 update_tri_layer(_LOWER, _RAISE, _ADJUST);
87 layer_off(_UNICODES);
88 break;
89 }
90 };
91 /////////////////////////////////////////////////////////////////////
92 void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called on tap
93 switch(state->count){
94 case 1: // Turn on lower
95 layer_off(_UNICODES);
96 layer_on(_LOWER);
97 update_tri_layer(_LOWER, _RAISE, _ADJUST);
98 break;
99 }
100 };
101 void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release
102 switch(state->count){
103 case 1: // Normal action. Turn off layers
104 layer_off(_LOWER);
105 update_tri_layer(_LOWER, _RAISE, _ADJUST);
106 layer_off(_UNICODES);
107 break;
108 case 2: // Turn on _UNICODES layer
109 layer_off(_LOWER);
110 update_tri_layer(_LOWER, _RAISE, _ADJUST);
111 layer_on(_UNICODES);
112 #ifdef AUDIO_ENABLE
113 PLAY_SONG(tone_ctrl_mod);
114 #endif
115 break;
116 }
117 };
118 /////////////////////////////////////////////////////////////////////
119 void dance_super_press(qk_tap_dance_state_t *state, void *user_data){ // Called on down
120 if(state->count == 1){
121 register_code(KC_LGUI);
122 }
123 }
124 void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Called on timeout
125 switch(state->count){
126 case 2:
127 register_code(KC_LGUI);
128 tap(KC_L);
129 unregister_code(KC_LGUI);
130 break;
131 }
132 }
133 void dance_super_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on up
134 unregister_code(KC_LGUI);
135 }
136
137 qk_tap_dance_action_t tap_dance_actions[] = {
138 [RAI] = ACTION_TAP_DANCE_FN_ADVANCED(dance_raise_press, NULL, dance_raise_lift),
139 [LOW] = ACTION_TAP_DANCE_FN_ADVANCED(dance_lower_press, NULL, dance_lower_lift),
140 [SUP] = ACTION_TAP_DANCE_FN_ADVANCED(dance_super_press, dance_super_done, dance_super_lift)
141 };
142 #endif
143
144 //#ifdef UNICODE_ENABLE
145 // Unicode shortcuts
146 #define IBANG X(0x203D)
147 #define RAROW X(0x2192)
148 #define LAROW X(0x2190)
149 #define DEGREE X(0x00B0)
150 #define OMEGA X(0x03A9)
151 #define WOMEGA X(0x03C9)
152 #define MICRO X(0x00B5)
153 #define PLUMIN X(0x00B1)
154 #define SUPA2 X(0x00B2)
155 #define ROMAN1 X(0x2160)
156 #define ROMAN2 X(0x2161)
157 #define ROMAN3 X(0x2162)
158 #define ROMAN4 X(0x2163)
159 #define ROMAN5 X(0x2164)
160 #define ROMAN6 X(0x2165)
161 #define ROMAN7 X(0x2166)
162 #define roman1 X(0x2170)
163 #define roman2 X(0x2171)
164 #define roman3 X(0x2172)
165 #define roman4 X(0x2173)
166 #define roman5 X(0x2174)
167 #define roman6 X(0x2175)
168 #define roman7 X(0x2176)
169
170 #ifdef UNICODEMAP_ENABLE // For Unicode characters larger than 0x8000. Send with X(<unicode>)
171 enum Ext_Unicode{
172 PENGUIN = 0,
173 BOAR,
174 MONKEY,
175 DRAGON,
176 CHICK,
177 TUMBLER
178 };
179 const uint32_t PROGMEM unicode_map[] = {
180 [PENGUIN] = 0x1F427,
181 [BOAR] = 0x1F417,
182 [MONKEY] = 0x1F412,
183 [DRAGON] = 0x1F409,
184 [CHICK] = 0x1F425,
185 [TUMBLER] = 0x1F943
186 };
187 #define PENGY X(PENGUIN)
188 #define BOARY X(BOAR)
189 #define MNKY X(MONKEY)
190 #define DRGN X(DRAGON)
191 #define DUCK X(CHICK)
192 #define TMBL X(TUMBLER)
193 #endif
194
195 //#endif
196
197 static uint16_t key_timer;
198 static uint8_t caps_status = 0;
199 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
200 switch (keycode) {
201 case COLEMAK:
202 if(record->event.pressed){
203 persistent_default_layer_set(1UL<<_COLEMAK);
204 #ifdef AUDIO_ENABLE
205 PLAY_SONG(tone_colemak);
206 #endif
207 }
208 return false;
209 break;
210 case SWCOLE:
211 if(record->event.pressed){
212 persistent_default_layer_set(1UL<<_SWCOLE);
213 #ifdef AUDIO_ENABLE
214 PLAY_SONG(tone_swcole);
215 #endif
216 }
217 return false;
218 break;
219 case RAISE:
220 if(record->event.pressed){
221 layer_on(_RAISE);
222 update_tri_layer(_LOWER, _RAISE, _ADJUST);
223 } else {
224 layer_off(_RAISE);
225 update_tri_layer(_LOWER, _RAISE, _ADJUST);
226 }
227 return false;
228 break;
229 case LOWER:
230 if(record->event.pressed){
231 layer_on(_LOWER);
232 update_tri_layer(_LOWER, _RAISE, _ADJUST);
233 } else {
234 layer_off(_LOWER);
235 update_tri_layer(_LOWER, _RAISE, _ADJUST);
236 }
237 return false;
238 break;
239 case SHFT_CAP:
240 if(record->event.pressed){
241 key_timer = timer_read(); // if the key is being pressed, we start the timer.
242 register_code(KC_LSHIFT);
243 } else { // this means the key was just released (tap or "held down")
244 if(timer_elapsed(key_timer) < 152){ // Time in ms, the threshold we pick for counting something as a tap.
245 tap(KC_CAPS);
246 if(caps_status == 0){
247 caps_status = 1;
248 #ifdef AUDIO_ENABLE
249 PLAY_SONG(tone_capslock_on);
250 #endif
251 } else {
252 caps_status = 0;
253 #ifdef AUDIO_ENABLE
254 PLAY_SONG(tone_capslock_off);
255 #endif
256 }
257 }
258 unregister_code(KC_LSHIFT);
259 }
260 return false;
261 break;
262 case CTRLB: // Control-B on tap (bold)
263 if(record->event.pressed){
264 key_timer = timer_read(); // if the key is being pressed, we start the timer.
265 register_code(KC_LCTL);
266 } else { // this means the key was just released (tap or "held down")
267 if (timer_elapsed(key_timer) < 152) { // Time in ms, the threshold we pick for counting something as a tap.
268 tap(KC_B);
269 #ifdef AUDIO_ENABLE
270 PLAY_SONG(tone_ctrl_mod);
271 #endif
272 #ifdef BACKLIGHT_BREATHING
273 breathing_period_set(2);
274 breathing_pulse();
275 #endif
276 }
277 unregister_code(KC_LCTL);
278 }
279 return false;
280 break;
281 case CPYPST: // One key copy/paste
282 if(record->event.pressed){
283 key_timer = timer_read();
284 } else {
285 if (timer_elapsed(key_timer) > 152) { // Hold, copy
286 register_code(KC_LCTL);
287 tap(KC_C);
288 unregister_code(KC_LCTL);
289 #ifdef AUDIO_ENABLE
290 PLAY_SONG(tone_copy);
291 #endif
292 } else { // Tap, paste
293 register_code(KC_LCTL);
294 tap(KC_V);
295 unregister_code(KC_LCTL);
296 #ifdef AUDIO_ENABLE
297 PLAY_SONG(tone_paste);
298 #endif
299 }
300 }
301 return false;
302 break;
303 #ifdef UNICODE_ENABLE
304 case UNIWIN:
305 if(record->event.pressed){
306 set_unicode_input_mode(UC_WIN);
307 #ifdef AUDIO_ENABLE
308 PLAY_SONG(uniwin);
309 #endif
310 }
311 return false;
312 break;
313 case UNILIN:
314 if(record->event.pressed){
315 set_unicode_input_mode(UC_LNX);
316 #ifdef AUDIO_ENABLE
317 PLAY_SONG(unilin);
318 #endif
319 }
320 return false;
321 break;
322 case DISFACE: // ಠ_ಠ
323 if(record->event.pressed){
324 process_unicode((0x0CA0|QK_UNICODE), record); // Eye
325 register_code(KC_RSFT);
326 tap(KC_MINS);
327 unregister_code(KC_RSFT);
328 process_unicode((0x0CA0|QK_UNICODE), record); // Eye
329 }
330 return false;
331 break;
332 case TFLIP: // (╯°□°)╯ ︵ ┻━┻
333 if(record->event.pressed){
334 register_code(KC_RSFT);
335 tap(KC_9);
336 unregister_code(KC_RSFT);
337 process_unicode((0x256F|QK_UNICODE), record); // Arm
338 process_unicode((0x00B0|QK_UNICODE), record); // Eye
339 process_unicode((0x25A1|QK_UNICODE), record); // Mouth
340 process_unicode((0x00B0|QK_UNICODE), record); // Eye
341 register_code(KC_RSFT);
342 tap(KC_0);
343 unregister_code(KC_RSFT);
344 process_unicode((0x256F|QK_UNICODE), record); // Arm
345 tap(KC_SPC);
346 process_unicode((0x0361|QK_UNICODE), record); // Flippy
347 tap(KC_SPC);
348 process_unicode((0x253B|QK_UNICODE), record); // Table
349 process_unicode((0x2501|QK_UNICODE), record); // Table
350 process_unicode((0x253B|QK_UNICODE), record); // Table
351 }
352 return false;
353 break;
354 case TPUT: // ┬──┬ ノ( ゜-゜ノ)
355 if(record->event.pressed){
356 process_unicode((0x252C|QK_UNICODE), record); // Table
357 process_unicode((0x2500|QK_UNICODE), record); // Table
358 process_unicode((0x2500|QK_UNICODE), record); // Table
359 process_unicode((0x252C|QK_UNICODE), record); // Table
360 tap(KC_SPC);
361 process_unicode((0x30CE|QK_UNICODE), record); // Arm
362 register_code(KC_RSFT);
363 tap(KC_9);
364 unregister_code(KC_RSFT);
365 tap(KC_SPC);
366 process_unicode((0x309C|QK_UNICODE), record); // Eye
367 tap(KC_MINS);
368 process_unicode((0x309C|QK_UNICODE), record); // Eye
369 process_unicode((0x30CE|QK_UNICODE), record); // Arm
370 register_code(KC_RSFT);
371 tap(KC_0);
372 unregister_code(KC_RSFT);
373 }
374 return false;
375 break;
376 case SHRUG: // ¯\_(ツ)_/¯
377 if(record->event.pressed){
378 process_unicode((0x00AF|QK_UNICODE), record); // Hand
379 tap(KC_BSLS); // Arm
380 register_code(KC_RSFT);
381 tap(KC_UNDS); // Arm
382 tap(KC_LPRN); // Head
383 unregister_code(KC_RSFT);
384 process_unicode((0x30C4|QK_UNICODE), record); // Face
385 register_code(KC_RSFT);
386 tap(KC_RPRN); // Head
387 tap(KC_UNDS); // Arm
388 unregister_code(KC_RSFT);
389 tap(KC_SLSH); // Arm
390 process_unicode((0x00AF|QK_UNICODE), record); // Hand
391 }
392 return false;
393 break;
394 #endif
395 case FACE: // (o_O)
396 if(record->event.pressed){
397 register_code(KC_RSFT);
398 tap(KC_LPRN);
399 unregister_code(KC_RSFT);
400 tap(KC_O);
401 register_code(KC_RSFT);
402 tap(KC_UNDS);
403 tap(KC_O);
404 tap(KC_RPRN);
405 unregister_code(KC_RSFT);
406 }
407 return false;
408 break;
409 case RANDIG:
410 if (record->event.pressed) {
411 tap_random_base64();
412 }
413 return false;
414 break;
415 }
416 return true;
417 };
418
419 void matrix_init_user(void){ // Run once at startup
420 #ifdef AUDIO_ENABLE
421 _delay_ms(50); // gets rid of tick
422 PLAY_SONG(tone_startup);
423 #endif
424 }
425
426 #ifdef AUDIO_ENABLE
427 void play_goodbye_tone(void){
428 PLAY_SONG(tone_goodbye);
429 _delay_ms(150);
430 }
431
432 void shutdown_user(){
433 PLAY_SONG(tone_goodbye);
434 _delay_ms(150);
435 stop_all_notes();
436 }
437
438 void music_on_user(void){ // Run when the music layer is turned on
439 PLAY_SONG(tone_startup);
440 }
441
442 void music_off_user(void){ // Run when music is turned off
443 PLAY_SONG(tone_goodbye);
444 }
445 #endif
446
447 #endif
QMK Keyboard Firmware