API tools faq
paste
Guest User

qmk

a guest
Apr 13th, 2021
102
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.49 KB | None | 0 0
raw download clone embed print report
  1. /* Copyright 2020 cfbender
  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 QMK_KEYBOARD_H
  17.  
  18. #define _mediaControl 0
  19. #define _mayaControl 1
  20. #define _psControl 2
  21. #define _layerSelector 3
  22. #define _codingControl 4
  23. #define _codingControlV1 5
  24. #define _codingControlV2 6
  25.  
  26.  
  27. #define SAVE LCTL(KC_S)
  28. #define OPEN LCTL(KC_O)
  29. #define COPY LCTL(KC_C)
  30. #define PAST LCTL(KC_V)
  31. #define CUNDO LCTL(LALT(KC_Z))
  32. #define INVERT LCTL(LSFT(KC_I))
  33. #define NLAYER LSFT(LCTL(KC_N))
  34. #define UNDO LCTL(KC_Z)
  35. #define TRANS LCTL(KC_T)
  36. #define ALIGNL LCTL(LSFT(KC_L))
  37. #define ALIGNC LCTL(LSFT(KC_C))
  38. #define ALIGNR LCTL(LSFT(KC_R))
  39. #define BRINGF LCTL(KC_RBRC)
  40. #define BRINGB LCTL(KC_LBRC)
  41.  
  42. // Illustrator layer shortcuts.
  43. #define SHAPE LSFT(KC_M)
  44. #define RULER LCTL(LALT(KC_R))
  45.  
  46. // Premiere layer shortcuts.
  47. #define REDO LCTL(LSFT(KC_Z))
  48. #define EXPORT LCTL(KC_M)
  49. #define IMPORT LCTL(KC_I)
  50. #define PCOPY LCTL(KC_V)
  51. #define PPASTE LCTL(LSFT(KC_V))
  52.  
  53. // Experience Design layer shortcuts. (can be used with others too.)
  54. #define NEW LCTL(KC_N)
  55. #define LOCK LCTL(KC_L)
  56. #define SYMB LCTL(KC_K)
  57. #define HIDE LCTL(KC_SCLN)
  58. #define REPEAT LCTL(KC_R)
  59. #define MASK LCTL(LSFT(KC_M))
  60. #define GROUP LCTL(KC_G)
  61. #define UNGRP LCTL(LSFT(KC_G))
  62. #define VIEW LCTL(KC_TAB)
  63. #define HORZ LSFT(KC_C)
  64. #define VERT LSFT(KC_M)
  65. //static uint8_t current_layer = 0;
  66. enum { TD_RGB = 0 };
  67. enum { TD_Layer = 1 };
  68. enum my_keycodes { CC_LayerSwitch = SAFE_RANGE, CC_runCodeAll, CC_runCodeSelection, CC_MAYA_runCodeAll, CC_MAYA_runCodeSelection,CC_smartCMD1 };
  69. void encoder_update_user(uint8_t index, bool clockwise) {
  70.         if (index == 0) {
  71.             switch (biton32(layer_state)) {
  72.                 case 6:
  73.                     if (clockwise) {
  74.                         tap_code(KC_RIGHT);
  75.                     } else {
  76.                         tap_code(KC_LEFT);
  77.                     }
  78.                     break;
  79.                 case 5:
  80.                     if (clockwise) {
  81.                         tap_code(KC_DOWN);
  82.                     } else {
  83.                         tap_code(KC_UP);
  84.                     }
  85.                     break;
  86.                 case 4:
  87.                     if (clockwise) {
  88.                         tap_code16(C(KC_Y));
  89.                     } else {
  90.                         tap_code16(C(KC_Z));
  91.                     }
  92.                     break;
  93.                 case 3:
  94.                     if (clockwise) {
  95.                         tap_code(KC_VOLU);
  96.                     } else {
  97.                         tap_code(KC_VOLD);
  98.                     }
  99.                     break;
  100.                 case 2:
  101.                     if (clockwise) {
  102.                         tap_code16(LCTL(LSFT(KC_Z)));
  103.                     } else {
  104.                         tap_code16(LCTL(KC_Z));
  105.                     }
  106.                     break;
  107.                 case 1:
  108.                     if (clockwise) {
  109.                         tap_code16(C(KC_Y));
  110.                     } else {
  111.                         tap_code16(C(KC_Z));
  112.                     }
  113.                     break;
  114.                 default:
  115.                     if (clockwise) {
  116.                         tap_code(KC_VOLU);
  117.                     } else {
  118.                         tap_code(KC_VOLD);
  119.                     }
  120.                     break;
  121.             }
  122.         }
  123. }
  124.  
  125.  
  126.  
  127. //void keyboard_post_init_user(void) {
  128.     // Customise these values to desired behaviour
  129.     //debug_enable = true;
  130.     //debug_matrix = true;
  131.     //debug_keyboard=true;
  132.     // debug_mouse=true;
  133. //}
  134. /*
  135. bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  136.     switch (keycode) {
  137.         case KC_PGUP:
  138.             if (record->event.pressed) {
  139.                 if (current_layer == HIGHEST_LAYER) {
  140.                     for (int i = 1; i <= HIGHEST_LAYER; i++) {
  141.                         layer_off(i);
  142.                     }
  143.                     current_layer = 0;
  144.                 } else {
  145.                     current_layer++;
  146.                     layer_on(current_layer);
  147.                 }
  148.             }
  149.             return false;
  150.         case KC_PGDOWN:
  151.             if (record->event.pressed) {
  152.                 if (current_layer == 0) {
  153.                     for (int i = 1; i <= HIGHEST_LAYER; i++) {
  154.                         layer_on(i);
  155.                     }
  156.                     current_layer = HIGHEST_LAYER;
  157.                 } else {
  158.                     layer_off(current_layer);
  159.                     current_layer--;
  160.                 }
  161.             }
  162.             return false;
  163.         default:
  164.             return true;
  165.     }
  166. }
  167. */
  168.  
  169. void dance_rgb_finished(qk_tap_dance_state_t *state, void *user_data) {
  170.     if (state->count == 1) {
  171.         register_code(KC_MEDIA_PREV_TRACK);
  172.         unregister_code(KC_MEDIA_PREV_TRACK);
  173.     } else if (state->count == 2) {
  174.         register_code(KC_MEDIA_NEXT_TRACK);
  175.         unregister_code(KC_MEDIA_NEXT_TRACK);        
  176.     } else if (state->count == 3) {
  177.         //smart command test
  178.         register_code(KC_LCTRL);
  179.         register_code(KC_LSHIFT);
  180.         register_code(KC_S);
  181.         unregister_code(KC_LCTRL);
  182.         unregister_code(KC_LSHIFT);
  183.         unregister_code(KC_S);
  184.     }
  185. }
  186. void layerChange(qk_tap_dance_state_t *state, void *user_data) {
  187.     if (state->count == 1) {
  188.         //register_code(KC_PGUP);
  189.         //unregister_code(KC_PGUP);
  190.         //layer_move(_layerSelector);
  191.         switch (biton32(layer_state)) {
  192.             case 6:
  193.                 layer_move(_codingControl);
  194.                 break;
  195.             case 5:
  196.                 layer_move(_codingControlV2);
  197.                 break;
  198.             case 3:
  199.                 rgblight_toggle();
  200.                 break;
  201.             case 2:
  202.                 register_code(KC_B);
  203.                 unregister_code(KC_B);
  204.                 break;
  205.             case 1:
  206.                 register_code(KC_LCTRL);
  207.                 register_code(KC_A);
  208.                 unregister_code(KC_LCTRL);
  209.                 unregister_code(KC_A);
  210.                 break;
  211.             default:
  212.                 register_code(KC_AUDIO_MUTE);
  213.                 unregister_code(KC_AUDIO_MUTE);
  214.                 break;
  215.         }
  216.         //rgblight_toggle();
  217.         //rgblight_sethsv_noeeprom(HSV_PURPLE);
  218.     } else if (state->count == 2) {
  219.         //register_code(KC_PGDOWN);
  220.         //unregister_code(KC_PGDOWN);
  221.         switch (biton32(layer_state)) {
  222.             case 6:
  223.                 layer_move(_codingControl);
  224.                 break;
  225.             case 3:
  226.                 rgblight_toggle();
  227.                 break;
  228.             case 2:
  229.                 register_code(KC_B);
  230.                 unregister_code(KC_B);
  231.                 break;
  232.             case 1:
  233.                 register_code(KC_LCTRL);
  234.                 register_code(KC_A);
  235.                 unregister_code(KC_LCTRL);
  236.                 unregister_code(KC_A);
  237.                 break;
  238.             default:
  239.                 register_code(KC_AUDIO_MUTE);
  240.                 unregister_code(KC_AUDIO_MUTE);
  241.                 break;
  242.         }
  243.         //rgblight_mode(1);
  244.         // rgblight_sethsv_noeeprom(HSV_BLUE);
  245.     }
  246. }
  247. // All tap dance functions would go here. Only showing this one.
  248. qk_tap_dance_action_t tap_dance_actions[] = {[TD_RGB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_rgb_finished, NULL),
  249. [TD_Layer] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, layerChange, NULL)};
  250. //
  251. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {  // buttion closest to usb is first
  252.     [_mediaControl] = LAYOUT(CC_LayerSwitch, TD(TD_RGB), KC_MEDIA_PLAY_PAUSE, KC_PGUP, KC_PGDN),
  253.     [_mayaControl]   = LAYOUT(CC_LayerSwitch, KC_F8, KC_F9, CC_MAYA_runCodeSelection,CC_MAYA_runCodeAll),
  254.     [_psControl]     = LAYOUT(CC_LayerSwitch, OPEN, SAVE, COPY, PAST),
  255.     [_layerSelector] = LAYOUT(TD(TD_RGB), TO(_mediaControl), TO(_mayaControl), TO(_codingControl), TO(_psControl) ),
  256.     [_codingControl] = LAYOUT(CC_LayerSwitch, COPY, PAST, CC_runCodeSelection,CC_runCodeAll),
  257.     [_codingControlV1] = LAYOUT(TD(TD_Layer), COPY, PAST, CC_runCodeSelection,CC_runCodeAll),
  258.     [_codingControlV2] = LAYOUT(TD(TD_Layer), COPY, PAST, CC_runCodeSelection,CC_runCodeAll),
  259. };
  260.  
  261.  
  262. layer_state_t layer_state_set_user(layer_state_t state) {
  263.     switch (get_highest_layer(state)) {
  264.         case _codingControlV2:
  265.             rgblight_mode(17);
  266.             rgblight_sethsv_noeeprom(HSV_GOLD);
  267.             break;
  268.         case _codingControlV1:
  269.             rgblight_mode(16);
  270.             rgblight_sethsv_noeeprom(HSV_GOLD);
  271.             break;
  272.         case _codingControl:
  273.             rgblight_mode(1);
  274.             rgblight_sethsv_noeeprom(HSV_GOLD);
  275.             break;
  276.         case _layerSelector:
  277.             rgblight_mode(18);
  278.             rgblight_sethsv_noeeprom(HSV_WHITE);
  279.             break;
  280.         case _mediaControl:
  281.             rgblight_mode(9);
  282.             rgblight_sethsv_noeeprom(HSV_BLUE);
  283.             break;
  284.         case _mayaControl:
  285.             rgblight_mode(1);
  286.             rgblight_sethsv_noeeprom(HSV_AZURE);
  287.             break;
  288.         case _psControl:
  289.             rgblight_mode(1);
  290.             rgblight_sethsv_noeeprom(HSV_BLUE);
  291.             break;
  292.         default:  //  for any other layers, or the default layer
  293.             rgblight_mode(9);
  294.             rgblight_sethsv_noeeprom(HSV_BLUE);
  295.             break;
  296.     }
  297.     return state;
  298. }
  299. static uint16_t key_timer;
  300. bool            process_record_user(uint16_t keycode, keyrecord_t *record) {
  301.     switch (keycode) {
  302.         case KC_MEDIA_PLAY_PAUSE:
  303.             if (record->event.pressed) {
  304.                 key_timer = timer_read();  // start the timer
  305.                 return false;              // return false to keep the 1 from being sent
  306.             } else {
  307.                 // If key was held
  308.                 if (timer_elapsed(key_timer) > 200) {
  309.                     register_code(KC_LCTRL);
  310.                     register_code(KC_LSHIFT);
  311.                     register_code(KC_D);
  312.                     unregister_code(KC_LCTRL);
  313.                     unregister_code(KC_LSHIFT);
  314.                     unregister_code(KC_D);
  315.                     return false;
  316.                 } else {
  317.                     // if key was tapped
  318.                     register_code(KC_MEDIA_PLAY_PAUSE);
  319.                     unregister_code(KC_MEDIA_PLAY_PAUSE);
  320.                     return true;
  321.                 }
  322.             }
  323.         case CC_MAYA_runCodeSelection:
  324.             if (record->event.pressed) {
  325.                 key_timer = timer_read();  // start the timer
  326.                 return false;              // return false to keep the 1 from being sent
  327.             } else {
  328.                 // If key was held
  329.                 if (timer_elapsed(key_timer) > 200) {
  330.                     tap_code16(LCTL(KC_ENTER));
  331.                     return false;
  332.                 } else {
  333.                     // if key was tapped
  334.                     register_code(KC_F10);
  335.                     unregister_code(KC_F10);
  336.                     return true;
  337.                 }
  338.             }
  339.         case CC_MAYA_runCodeAll:
  340.             if (record->event.pressed) {
  341.                 key_timer = timer_read();  // start the timer
  342.                 return false;              // return false to keep the 1 from being sent
  343.             } else {
  344.                 // If key was held
  345.                 if (timer_elapsed(key_timer) > 200) {
  346.                     tap_code16(LCTL(KC_A));
  347.                     tap_code16(LCTL(KC_ENTER));
  348.                     return false;
  349.                 } else {
  350.                     // if key was tapped
  351.                     register_code(KC_F11);
  352.                     unregister_code(KC_F11);
  353.                     return true;
  354.                 }
  355.             }
  356.         case CC_runCodeSelection:
  357.             if (record->event.pressed) {
  358.                 key_timer = timer_read();  // start the timer
  359.                 return false;              // return false to keep the 1 from being sent
  360.             } else {
  361.                 // If key was held
  362.                 if (timer_elapsed(key_timer) > 200) {
  363.                     tap_code16(LCTL(KC_ENTER));
  364.                     return false;
  365.                 } else {
  366.                     // if key was tapped
  367.                     register_code(KC_PGDN);
  368.                     unregister_code(KC_PGDN);
  369.                     return true;
  370.                 }
  371.             }
  372.         case CC_runCodeAll:
  373.             if (record->event.pressed) {
  374.                 key_timer = timer_read();  // start the timer
  375.                 return false;              // return false to keep the 1 from being sent
  376.             } else {
  377.                 // If key was held
  378.                 if (timer_elapsed(key_timer) > 200) {
  379.                     tap_code16(LCTL(KC_A));
  380.                     tap_code16(LCTL(KC_ENTER));
  381.                     return false;
  382.                 } else {
  383.                     // if key was tapped
  384.                     register_code(KC_PGUP);
  385.                     unregister_code(KC_PGUP);
  386.                     return true;
  387.                 }
  388.             }
  389.         case KC_PGUP:
  390.             if (record->event.pressed) {
  391.                 key_timer = timer_read();  // start the timer
  392.                 return false;              // return false to keep the 1 from being sent
  393.             } else {
  394.                 // If key was held
  395.                 if (timer_elapsed(key_timer) > 200) {
  396.                     register_code(KC_LSHIFT);
  397.                     register_code(KC_DEL);
  398.                     unregister_code(KC_LSHIFT);
  399.                     unregister_code(KC_DEL);
  400.                     return false;
  401.                 } else {
  402.                     // if key was tapped
  403.                     register_code(KC_PGUP);
  404.                     unregister_code(KC_PGUP);
  405.                     return true;
  406.                 }
  407.             }
  408.             break;
  409.         case KC_PGDN:
  410.             if (record->event.pressed) {
  411.                 key_timer = timer_read();  // start the timer
  412.                 return false;               // return false to keep the 1 from being sent
  413.             } else {
  414.                 // If key was held
  415.                 if (timer_elapsed(key_timer) > 200) {
  416.                     register_code(KC_LCTRL);
  417.                     register_code(KC_LALT);
  418.                     register_code(KC_DEL);
  419.                     unregister_code(KC_LCTRL);
  420.                     unregister_code(KC_LALT);
  421.                     unregister_code(KC_DEL);
  422.                     return false;
  423.                 } else {
  424.                     // if key was tapped
  425.                     register_code(KC_PGDN);
  426.                     unregister_code(KC_PGDN);
  427.                     return true;
  428.                 }
  429.             }
  430.             break;
  431.         case CC_LayerSwitch:
  432.             if (record->event.pressed) {
  433.                 key_timer = timer_read();  // start the timer
  434.                 return false;              // return false to keep the 1 from being sent
  435.             } else {
  436.                 // If key was held
  437.                 if (timer_elapsed(key_timer) > 300) {
  438.                     layer_move(_layerSelector);
  439.                     return false;
  440.                 } else {
  441.                     // if key was tapped
  442.                     switch (biton32(layer_state)) {
  443.                         case 4:
  444.                             layer_move(_codingControlV1);
  445.                             break;
  446.                         case 3:
  447.                             rgblight_toggle();
  448.                             break;
  449.                         case 2:
  450.                             register_code(KC_B);
  451.                             unregister_code(KC_B);
  452.                             break;
  453.                         case 1:
  454.                             register_code(KC_LCTRL);
  455.                             register_code(KC_A);
  456.                             unregister_code(KC_LCTRL);
  457.                             unregister_code(KC_A);
  458.                             break;
  459.                         default:
  460.                             register_code(KC_AUDIO_MUTE);
  461.                             unregister_code(KC_AUDIO_MUTE);
  462.                             break;}
  463.                     return true;
  464.                 }
  465.             }
  466.             break;
  467.     }
  468.     return true;
  469. };
  470.  
  471. /*
  472. // Runs constantly in the background, in a loop.
  473. void matrix_scan_user(void) {
  474.     uint8_t layer = biton32(layer_state);
  475.  
  476.     // INSERT CODE HERE: turn off all leds
  477.  
  478.     switch (layer) {
  479.         case _mediaControl:
  480.             rgblight_sethsv_noeeprom(HSV_WHITE);
  481.             // INSERT CODE HERE: turn on leds that correspond to YOUR_LAYER_1
  482.             break;
  483.         case _mayaControl:
  484.             rgblight_sethsv_noeeprom(HSV_AZURE);
  485.             // INSERT CODE HERE: turn on leds that correspond to YOUR_LAYER_2
  486.             break;
  487.             // add case for each layer
  488.         case _psControl:
  489.             rgblight_sethsv_noeeprom(HSV_BLUE);
  490.             // INSERT CODE HERE: turn on leds that correspond to YOUR_LAYER_2
  491.             break;
  492.             // add case for each layer
  493.     }
  494. };
  495. */
  496.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!