API tools faq
paste
Advertisement
arch-toto

Untitled

arch-toto
Mar 8th, 2023 (edited)
1,028
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.32 KB | None | 0 0
raw download clone embed print report
  1. #include QMK_KEYBOARD_H
  2. #include "oneshot.h"
  3. #include "swapper.h"
  4. #include "keymap_spanish_dvorak.h"
  5. #include <stdio.h>
  6. #define HOME G(KC_LEFT)
  7. #define END G(KC_RGHT)
  8. #define FWD G(KC_RBRC)
  9. #define BACK G(KC_LBRC)
  10. //#define  G(S(KC_LBRC))
  11. #define TABR G(S(KC_RBRC))
  12. #define SPCL A(G(KC_LEFT))
  13. #define SPC_R A(G(KC_RGHT))
  14. #define LA_SYM MO(SYM)
  15. #define LA_NAV MO(NAV)
  16. #define KC_CAD LCA(KC_DEL)
  17. #define uint32_t LAUGH
  18. enum layers {
  19.    BASE,
  20.     SYM,
  21.     NAV,
  22.     NUM,
  23.     MOU
  24. };
  25.  
  26. // enum combo_events {
  27. //     //CP_LINE,
  28. //     //CP_WORD,
  29. //     KC
  30. // };
  31. enum keycodes {
  32.     // Custom oneshot mod implementation with no timers.
  33.     OS_SHFT = SAFE_RANGE,
  34.     OS_CTRL,
  35.     OS_ALT,
  36.     OS_CMD,
  37.     SW_WIN,  // Switch to next window         (cmd-tab)
  38.     CTRL_KC,
  39.     SW_LANG, // Switch to next input language (ctl-spc)
  40.     SW_TAB,
  41.     MAIL,
  42.     LAUGH,
  43.     CAD
  44. };
  45.  
  46. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  47.     [BASE] = LAYOUT_split_3x5_3(
  48.     KC_ESC,    KC_COMM,    KC_DOT,    KC_P,    KC_Y,      KC_F,     KC_G,    KC_C,    KC_R,    KC_L,
  49.     KC_A,         KC_O,      KC_E,    KC_U,    KC_I,      KC_D,     KC_H,    KC_T,    KC_N,    KC_S,
  50.     KC_SCLN,      KC_Q,      KC_J,    KC_K,    KC_X,      KC_B,     KC_M,    KC_W,    KC_V,    KC_Z,
  51.                             LAUGH,  LA_NAV,  KC_SPC,      KC_BSPC,  LA_SYM,  MAIL
  52.     ),
  53.    
  54.     [SYM] = LAYOUT_split_3x5_3(
  55.       KC_EXLM,   KC_AT, KC_HASH,  KC_DLR, KC_PERC,           KC_LPRN, KC_RPRN,   KC_LT,   KC_GT, KC_CIRC,
  56.       KC_UNDS, KC_PLUS, KC_AMPR, KC_ASTR,  KC_EQL,           KC_QUES, XXXXXXX,  OS_ALT,  OS_CTRL, OS_SHFT,
  57.       KC_QUOT, KC_MINS, KC_PIPE, KC_BSLS, KC_SLSH,           KC_LBRC, KC_RBRC,  KC_GRV, KC_TILD, KC_DQUO,
  58.                           _______, _______, KC_SPC,         KC_ENT, _______, _______
  59.     ),
  60.    
  61.     [NAV] = LAYOUT_split_3x5_3(
  62.          KC_TAB,  SW_WIN,   SW_TAB,    TABR,    KC_VOLU,           XXXXXXX, KC_HOME,   KC_UP,  KC_END, KC_DEL,
  63.         OS_SHFT, OS_CTRL,   OS_ALT,   OS_CMD,    KC_VOLD,          KC_CAPS, KC_LEFT, KC_DOWN, KC_RGHT, KC_ENT,
  64.         XXXXXXX, XXXXXXX,   BACK,    XXXXXXX,    XXXXXXX,          CTRL_KC, KC_PGDN, KC_PGUP, SW_LANG, KC_CAD,
  65.                                _______,  _______, KC_SPC,          KC_ENT, _______, _______
  66.     ),
  67.  
  68.     [NUM] = LAYOUT_split_3x5_3(
  69.     KC_9,       KC_7,    KC_5,    KC_3,    KC_1,        KC_0,    KC_2,    KC_4,    KC_6,    KC_8,
  70.     OS_SHFT, OS_CTRL,  OS_ALT,  OS_CMD,  KC_F11,        KC_F10,  OS_CMD,  OS_ALT,  OS_CTRL, OS_SHFT,
  71.     KC_F7,     KC_F5,   KC_F3,   KC_F1,   KC_F9,        KC_F8,   KC_F12,  KC_F2,   KC_F4,   KC_F6,
  72.                         _______,  _______, _______, _______, _______, _______
  73.     ),
  74.    
  75.     [MOU] = LAYOUT_split_3x5_3(
  76.     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,        XXXXXXX, XXXXXXX, KC_MS_U, XXXXXXX, XXXXXXX,
  77.     XXXXXXX, XXXXXXX, XXXXXXX, OS_SHFT, XXXXXXX,        XXXXXXX, KC_MS_L, KC_MS_D, KC_MS_R, KC_BTN2,
  78.     XXXXXXX, XXXXXXX, XXXXXXX, OS_CTRL, XXXXXXX,        XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
  79.                         _______,  _______, _______, _______, KC_BTN1, _______
  80.     ),
  81. };
  82.  
  83. //const uint16_t PROGMEM copyL[] = {KC_G, KC_C, COMBO_END};
  84. //const uint16_t PROGMEM copyW[] = {KC_C, KC_W, COMBO_END};
  85. //const uint16_t PROGMEM ctkc[]   = {CTRL_KC, COMBO_END};
  86.  
  87. // combo_t key_combos[COMBO_COUNT] = {
  88. // //    [CP_LINE] = COMBO_ACTION(copyL),
  89. // //    [CP_WORD] = COMBO_ACTION(copyW),
  90. // //    COMBO(save, LCTL(KC_S)),
  91. // //    COMBO(paste, LCTL(KC_V)),
  92. // //    COMBO(del, LCTL(KC_BSPC)),
  93. // //    [KC] = COMBO_ACTION(ctkc),
  94. // };
  95.  
  96. // void process_combo_event(uint16_t combo_index, bool pressed) {
  97. //   switch(combo_index) {
  98. //     case CP_LINE:
  99. //       if (pressed) {
  100. //         tap_code16(S(KC_HOME));
  101. //         tap_code16(LCTL(KC_C));
  102. //         tap_code16(S(KC_END));
  103. //       }
  104. //       break;
  105. //     case CP_WORD:
  106. //       if (pressed) {
  107. //         tap_code16(LCTL(KC_RIGHT));
  108. //         tap_code16(LCTL(KC_C));
  109. //         tap_code16(S(KC_END));
  110. //       }
  111. //       break;
  112. //     case KC:
  113. //       if (pressed) {
  114. //         tap_code16(LCTL(KC_K));
  115. //         tap_code16(LCTL(KC_C));
  116. //       }
  117. //       break;
  118. //   }
  119. // };
  120.  
  121.  
  122. bool is_oneshot_cancel_key(uint16_t keycode) {
  123.     switch (keycode) {
  124.     case LA_SYM:
  125.     case LA_NAV:
  126.         return true;
  127.     default:
  128.         return false;
  129.     }
  130. }
  131.  
  132. bool is_oneshot_ignored_key(uint16_t keycode) {
  133.     switch (keycode) {
  134.     case LA_SYM:
  135.     case LA_NAV:
  136.     case KC_LSFT:
  137.     case OS_SHFT:
  138.     case OS_CTRL:
  139.     case OS_ALT:
  140.     case OS_CMD:
  141.         return true;
  142.     default:
  143.         return false;
  144.     }
  145. }
  146.  
  147. bool sw_ctrltab = false;
  148. bool sw_lang_active = false;
  149. bool sw_ctb = false;
  150.  
  151. oneshot_state os_shft_state = os_up_unqueued;
  152. oneshot_state os_ctrl_state = os_up_unqueued;
  153. oneshot_state os_alt_state = os_up_unqueued;
  154. oneshot_state os_cmd_state = os_up_unqueued;
  155.  
  156. bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  157.     update_swapper(
  158.         &sw_ctrltab, KC_LALT, KC_TAB, SW_WIN,
  159.         keycode, record
  160.     );
  161.     update_swapper(
  162.         &sw_lang_active, KC_LGUI, KC_SPC, SW_LANG,
  163.         keycode, record
  164.     );
  165.     update_swapper2(
  166.         &sw_ctb, KC_LCTL, KC_K, KC_C, SW_TAB,
  167.         keycode, record
  168.     );
  169.     update_oneshot(
  170.         &os_shft_state, KC_LSFT, OS_SHFT,
  171.         keycode, record
  172.     );
  173.     update_oneshot(
  174.         &os_ctrl_state, KC_LCTL, OS_CTRL,
  175.         keycode, record
  176.     );
  177.     update_oneshot(
  178.         &os_alt_state, KC_LALT, OS_ALT,
  179.         keycode, record
  180.     );
  181.     update_oneshot(
  182.         &os_cmd_state, KC_LCMD, OS_CMD,
  183.         keycode, record
  184.     );
  185.  
  186.         switch(keycode){
  187.         case MAIL:
  188.             if(record->event.pressed){
  189.             SEND_STRING("test@gmail.com"); 
  190.             }
  191.             else{
  192.                 clear_keyboard();
  193.             }
  194.             break;
  195.         case LAUGH:
  196.             if(record->event.pressed){
  197.             SEND_STRING("hahaha"); 
  198.             }
  199.             else{
  200.                 clear_keyboard();
  201.             }
  202.             break;
  203.     }
  204.    
  205.     return true;
  206. }
  207.  
  208. layer_state_t layer_state_set_user(layer_state_t state) {
  209.     state = update_tri_layer_state(state, SYM, NAV, NUM);
  210.     state = update_tri_layer_state(state, LAUGH, NAV, MOU);
  211.     return state;
  212. }
  213.  
  214. #ifdef OLED_ENABLE
  215. oled_rotation_t oled_init_user(oled_rotation_t rotation) {
  216.   if (!is_keyboard_master()) {
  217.     // return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
  218.     return OLED_ROTATION_180;
  219.   }
  220.   return rotation;
  221. }
  222.  
  223. #define L_BASE 0
  224. #define L_LOWER 2
  225. #define L_RAISE 4
  226. #define L_ADJUST 8
  227.  
  228. void oled_render_layer_state(void) {
  229.     // oled_write_P(PSTR("Layer: "), false);
  230.     switch (layer_state) {
  231.         case L_BASE:
  232.             oled_write_ln_P(PSTR("BASE"), false);
  233.             break;
  234.         case L_LOWER:
  235.             oled_write_ln_P(PSTR("SYM"), false);
  236.             break;
  237.         case L_RAISE:
  238.             oled_write_ln_P(PSTR("NAV"), false);
  239.             break;
  240.         case L_ADJUST:
  241.         case L_ADJUST|L_LOWER:
  242.         case L_ADJUST|L_RAISE:
  243.         case L_ADJUST|L_LOWER|L_RAISE:
  244.             oled_write_ln_P(PSTR("NUM"), false);
  245.             break;
  246.     }
  247. }
  248.  
  249. char keylog_str[24] = {};
  250.  
  251. const char code_to_name[60] = {
  252.     ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f',
  253.     'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
  254.     'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
  255.     '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
  256.     'R', 'E', 'B', 'T', '_', '-', '=', '[', ']', '\\',
  257.     '#', ';', '\'', '`', ',', '.', '/', ' ', ' ', ' '};
  258.  
  259. void set_keylog(uint16_t keycode, keyrecord_t *record) {
  260.   char name = ' ';
  261.     if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) ||
  262.         (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) { keycode = keycode & 0xFF; }
  263.   if (keycode < 60) {
  264.     name = code_to_name[keycode];
  265.   }
  266.  
  267.   // update keylog
  268.   snprintf(keylog_str, sizeof(keylog_str), "%dx%d, k%2d : %c",
  269.            record->event.key.row, record->event.key.col,
  270.            keycode, name);
  271. }
  272.  
  273. void oled_render_keylog(void) {
  274.     oled_write(keylog_str, false);
  275. }
  276.  
  277. void render_bootmagic_status(bool status) {
  278.     /* Show Ctrl-Gui Swap options */
  279.     static const char PROGMEM logo[][2][3] = {
  280.         {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
  281.         {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
  282.     };
  283.     if (status) {
  284.         oled_write_ln_P(logo[0][0], false);
  285.         oled_write_ln_P(logo[0][1], false);
  286.     } else {
  287.         oled_write_ln_P(logo[1][0], false);
  288.         oled_write_ln_P(logo[1][1], false);
  289.     }
  290. }
  291.  
  292. void oled_render_logo(void) {
  293.     static const char PROGMEM crkbd_logo[] = {
  294.         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94,
  295.         0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4,
  296.         0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4,
  297.         0};
  298.     oled_write_P(crkbd_logo, false);
  299. }
  300.  
  301. bool oled_task_user(void) {
  302.     if (is_keyboard_master()) {
  303.         oled_render_layer_state();
  304.         oled_render_keylog();
  305.     } else {
  306.         oled_render_logo();
  307.     }
  308.     return false;
  309. }
  310.  
  311. #endif // OLED_ENABLE
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!