logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

keymap.c (33759B)

    

  1. #include QMK_KEYBOARD_H
  3. enum {
  4.     LAYER_NORM_BASE,
  5.     LAYER_NORM_EXTENSION,
  6.     LAYER_RACE_BASE,
  7.     LAYER_RACE_EXTENSION,
  8.     LAYER_LEGACY_BASE,
  9.     LAYER_LEGACY_EXTENSION,
  10.     LAYER_CONTROL,
  11.     LAYER_WINDOW,
  12.     LAYER_DESKTOP,
  13.     NUMBER_OF_LAYERS,
  14. };
  16. bool temporary[NUMBER_OF_LAYERS] = {
  17.     [LAYER_NORM_BASE] = false,
  18.     [LAYER_NORM_EXTENSION] = true,
  19.     [LAYER_RACE_BASE] = false,
  20.     [LAYER_RACE_EXTENSION] = true,
  21.     [LAYER_LEGACY_BASE] = false,
  22.     [LAYER_LEGACY_EXTENSION] = true,
  23.     [LAYER_CONTROL] = false,
  24.     [LAYER_WINDOW] = true,
  25.     [LAYER_DESKTOP] = false,
  26. };
  28. #define KEY_FORWARD_LAYER(a) SAFE_RANGE + a
  30. enum{
  31.     DANCE_PGDN_BOTTOM,
  32.     DANCE_PGUP_TOP,
  33. };
  35. tap_dance_action_t tap_dance_actions[] = {
  36.     [DANCE_PGDN_BOTTOM] = ACTION_TAP_DANCE_DOUBLE(KC_PGDN, LGUI(KC_DOWN)),
  37.     [DANCE_PGUP_TOP] = ACTION_TAP_DANCE_DOUBLE(KC_PGUP, LGUI(KC_UP)),
  38. };
  40. #define KEY_DANCE(a) TD(a)
  42. enum custom_keycodes {
  43.     KEY_BACK_LAYER = SAFE_RANGE + NUMBER_OF_LAYERS,
  44.     KEY_INSERT_LINE_START,
  45.     KEY_INSERT_HERE,
  46.     KEY_INSERT_LINE_END,
  47.     KEY_CREATE_PREVIOUS_LINE,
  48.     KEY_CREATE_NEXT_LINE,
  49.     KEY_CUT_WORD,
  50.     KEY_CUT_LINE,
  51.     KEY_CUT_SELECTION,
  52. };
  54. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  55.     [LAYER_NORM_BASE] = LAYOUT_default_splitspace(
  56.         KC_GRAVE, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KEY_DANCE(DANCE_PGDN_BOTTOM), KEY_DANCE(DANCE_PGUP_TOP), KC_NO, KEY_CUT_LINE, KEY_FORWARD_LAYER(LAYER_RACE_BASE),
  57.         KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_LCBR, KC_RCBR, KC_BSLS, KEY_FORWARD_LAYER(LAYER_LEGACY_BASE),
  58.         KC_CAPS, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT, KC_ENT, KEY_FORWARD_LAYER(LAYER_DESKTOP),
  59.         KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_NO, LCTL(KC_LEFT),
  60.         KC_LCTL, KC_LGUI, KC_LALT, KEY_FORWARD_LAYER(LAYER_NORM_EXTENSION), KEY_FORWARD_LAYER(LAYER_CONTROL), KC_SPC, KC_RALT, KC_RGUI, KC_NO, KC_NO, LCTL(KC_RIGHT)),
  61.     [LAYER_NORM_EXTENSION] = LAYOUT_default_splitspace(
  62.         LGUI(LSFT(KC_4)), KC_NO, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_MPLY, KC_MUTE, KC_VOLD, KC_VOLU, KC_NO, LCTL(KC_C), KEY_FORWARD_LAYER(LAYER_RACE_BASE),
  63.         KEY_FORWARD_LAYER(LAYER_WINDOW), LGUI(KC_SPC), LCTL(KC_SPC), KC_ESC, KC_TILD, KC_EXLM, KC_PEQL, KC_PLUS, KC_MINUS, KC_PIPE, KC_COLN, KC_LCBR, KC_RCBR, KEY_CREATE_PREVIOUS_LINE, KEY_FORWARD_LAYER(LAYER_LEGACY_BASE),
  64.         KEY_CUT_WORD, LALT(KC_LEFT), LALT(KC_RIGHT), KC_BSPC, LGUI(KC_LEFT), LCTL(KC_E), KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, LGUI(KC_V), KC_DQUO, KEY_CREATE_NEXT_LINE, KEY_FORWARD_LAYER(LAYER_DESKTOP),
  65.         KC_LSFT, LGUI(KC_Z), KEY_CUT_SELECTION, KC_LPRN, KC_RPRN, KC_UNDS, KC_LBRC, KC_RBRC, KC_LT, KC_GT, KC_QUES, KC_RSFT, KC_NO, LCTL(KC_LEFT),
  66.         KC_LCTL, KC_LGUI, KC_LALT, KC_NO, KEY_FORWARD_LAYER(LAYER_CONTROL), KC_SPC, KC_RALT, KC_RGUI, KC_NO, QK_BOOT, LCTL(KC_RIGHT)),
  67.     [LAYER_RACE_BASE] = LAYOUT_default_splitspace(
  68.         KC_NO, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_NO, KC_NO, KC_NO, KC_NO, KEY_BACK_LAYER,
  69.         KC_NO, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_LCBR, KC_RCBR, KC_BSLS, KC_NO,
  70.         KC_CAPS, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT, KC_ENT, KC_NO,
  71.         KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_NO, KC_NO,
  72.         KC_NO, KC_NO, KC_NO, KEY_FORWARD_LAYER(LAYER_RACE_EXTENSION), KC_NO, KC_SPC, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO),
  73.     [LAYER_RACE_EXTENSION] = LAYOUT_default_splitspace(
  74.         KC_NO, KC_1, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_9, KC_0, KC_NO, KC_NO, KC_NO, KEY_CUT_LINE, KEY_BACK_LAYER,
  75.         KC_NO, KC_Q, KC_W, KC_F, KC_TILD, KC_EXLM, KC_PEQL, KC_PLUS, KC_MINUS, KC_PIPE, KC_COLN, KC_LCBR, KC_RCBR, KC_BSLS, KC_NO,
  76.         KEY_CUT_LINE, KC_A, KC_R, KC_BSPC, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_DQUO, KC_ENT, KC_NO,
  77.         KC_LSFT, KC_Z, KC_X, KC_LPRN, KC_RPRN, KC_UNDS, KC_LBRC, KC_RBRC, KC_LT, KC_GT, KC_QUES, KC_RSFT, KC_NO, KC_NO,
  78.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_SPC, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO),
  79.     [LAYER_LEGACY_BASE] = LAYOUT_default_splitspace(
  80.         KC_GRAVE, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KEY_DANCE(DANCE_PGDN_BOTTOM), KEY_DANCE(DANCE_PGUP_TOP), KC_NO, KEY_CUT_LINE, KC_NO,
  81.         KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LCBR, KC_RCBR, KC_BSLS, KEY_BACK_LAYER,
  82.         KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KEY_FORWARD_LAYER(LAYER_DESKTOP),
  83.         KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_NO, LCTL(KC_LEFT),
  84.         KC_LCTL, KC_LGUI, KC_LALT, KEY_FORWARD_LAYER(LAYER_LEGACY_EXTENSION), KEY_FORWARD_LAYER(LAYER_CONTROL), KC_SPC, KC_RALT, KC_RGUI, KC_NO, KC_NO, LCTL(KC_RIGHT)),
  85.     [LAYER_LEGACY_EXTENSION] = LAYOUT_default_splitspace(
  86.         LGUI(LSFT(KC_4)), KC_NO, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_MPLY, KC_MUTE, KC_VOLD, KC_VOLU, KC_NO, LCTL(KC_C), KC_NO,
  87.         KEY_FORWARD_LAYER(LAYER_WINDOW), LGUI(KC_SPC), LCTL(KC_SPC), KC_ESC, KC_TILD, KC_EXLM, KC_PEQL, KC_PLUS, KC_MINUS, KC_PIPE, KC_COLN, KC_LCBR, KC_RCBR, KEY_CREATE_PREVIOUS_LINE, KEY_BACK_LAYER,
  88.         KEY_CUT_WORD, LALT(KC_LEFT), LALT(KC_RIGHT), KC_BSPC, LGUI(KC_LEFT), LCTL(KC_E), KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, LGUI(KC_V), KC_DQUO, KEY_CREATE_NEXT_LINE, KEY_FORWARD_LAYER(LAYER_DESKTOP),
  89.         KC_LSFT, LGUI(KC_Z), KEY_CUT_SELECTION, KC_LPRN, KC_RPRN, KC_UNDS, KC_LBRC, KC_RBRC, KC_LT, KC_GT, KC_QUES, KC_RSFT, KC_NO, LCTL(KC_LEFT),
  90.         KC_LCTL, KC_LGUI, KC_LALT, KC_NO, KEY_FORWARD_LAYER(LAYER_CONTROL), KC_SPC, KC_RALT, KC_RGUI, KC_NO, KC_NO, LCTL(KC_RIGHT)),
  91.     [LAYER_CONTROL] = LAYOUT_default_splitspace(
  92.         KC_NO, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
  93.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KEY_INSERT_LINE_START, KEY_INSERT_HERE, KEY_INSERT_LINE_END, KC_NO, KC_NO, KC_NO, KEY_CREATE_PREVIOUS_LINE, KC_NO,
  94.         KEY_CUT_WORD, LALT(KC_LEFT), LALT(KC_RIGHT), KC_BSPC, LGUI(KC_LEFT), LCTL(KC_E), KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, LGUI(KC_V), KC_NO, KEY_CREATE_NEXT_LINE, KC_NO,
  95.         KC_LSFT, LGUI(KC_Z), KEY_CUT_SELECTION, LGUI(KC_C), LGUI(KC_V), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_RSFT, KC_NO, KC_NO,
  96.         KC_NO, KC_NO, KC_NO, KC_NO, KEY_BACK_LAYER, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO),
  97.     [LAYER_WINDOW] = LAYOUT_default_splitspace(
  98.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
  99.         KEY_BACK_LAYER, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
  100.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, KC_NO, KC_NO, KEY_BACK_LAYER, KC_NO,
  101.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
  102.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KEY_BACK_LAYER, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO),
  103.     [LAYER_DESKTOP] = LAYOUT_default_splitspace(
  104.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
  105.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
  106.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, LCTL(KC_LEFT), KC_NO, KC_NO, LCTL(KC_RIGHT), KC_NO, KC_NO, KEY_BACK_LAYER, KEY_BACK_LAYER,
  107.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
  108.         KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KEY_BACK_LAYER, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO),
  109. };
  111. int layers[16];
  113. struct {
  114.     bool back;
  115. } common_layer_data;
  116. struct {
  117.     int operator, multiplier;
  118. } layer_control_data;
  120. struct {
  121.     int start_time;
  122. } layer_window_data;
  124. bool handle_layer_key(uint16_t key, keyrecord_t* record) {
  125.     switch (layers[layers[0] + 1]) {
  126.         case LAYER_CONTROL:
  127.             switch (key) {
  128.                 case KC_0:
  129.                     if (record->event.pressed) {
  130.                         layer_control_data.multiplier = layer_control_data.multiplier * 10;
  131.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  132.                     }
  133.                     return false;
  134.                 case KC_1:
  135.                     if (record->event.pressed) {
  136.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 1;
  137.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  138.                     }
  139.                     return false;
  140.                 case KC_2:
  141.                     if (record->event.pressed) {
  142.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 2;
  143.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  144.                     }
  145.                     return false;
  146.                 case KC_3:
  147.                     if (record->event.pressed) {
  148.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 3;
  149.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  150.                     }
  151.                     return false;
  152.                 case KC_4:
  153.                     if (record->event.pressed) {
  154.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 4;
  155.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  156.                     }
  157.                     return false;
  158.                 case KC_5:
  159.                     if (record->event.pressed) {
  160.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 5;
  161.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  162.                     }
  163.                     return false;
  164.                 case KC_6:
  165.                     if (record->event.pressed) {
  166.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 6;
  167.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  168.                     }
  169.                     return false;
  170.                 case KC_7:
  171.                     if (record->event.pressed) {
  172.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 7;
  173.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  174.                     }
  175.                     return false;
  176.                 case KC_8:
  177.                     if (record->event.pressed) {
  178.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 8;
  179.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  180.                     }
  181.                     return false;
  182.                 case KC_9:
  183.                     if (record->event.pressed) {
  184.                         layer_control_data.multiplier = layer_control_data.multiplier * 10 + 9;
  185.                         if (layer_control_data.multiplier < 0) layer_control_data.multiplier = 0;
  186.                     }
  187.                     return false;
  188.                 case KEY_INSERT_LINE_START:
  189.                     if (record->event.pressed) common_layer_data.back = true;
  190.                     return true;
  191.                 case KEY_INSERT_HERE:
  192.                     if (record->event.pressed) common_layer_data.back = true;
  193.                     return true;
  194.                 case KEY_INSERT_LINE_END:
  195.                     if (record->event.pressed) common_layer_data.back = true;
  196.                     return true;
  197.                 case KEY_CREATE_PREVIOUS_LINE:
  198.                     if (record->event.pressed) common_layer_data.back = true;
  199.                     return true;
  200.                 case KEY_CUT_WORD:
  201.                     if (record->event.pressed) {
  202.                         if (layer_control_data.operator== - 1) {
  203.                             register_code(KC_LALT);
  204.                             tap_code(KC_LEFT);
  205.                             tap_code(KC_RIGHT);
  206.                             unregister_code(KC_LALT);
  207.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(LALT(KC_LEFT)));
  208.                             tap_code16(LGUI(KC_X));
  209.                         }
  210.                         layer_control_data.multiplier = 0;
  211.                         layer_control_data.operator   = - 1;
  212.                     }
  213.                     return false;
  214.                 case LALT(KC_LEFT):
  215.                     if (layer_control_data.operator== - 1 && layer_control_data.multiplier == 0) return true;
  216.                     if (record->event.pressed) {
  217.                         if (layer_control_data.operator== - 1)
  218.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LALT(KC_LEFT));
  219.                         else if (layer_control_data.operator== KC_BSPC) {
  220.                             register_code(KC_LALT);
  221.                             tap_code(KC_LEFT);
  222.                             tap_code(KC_RIGHT);
  223.                             unregister_code(KC_LALT);
  224.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(LALT(KC_LEFT)));
  225.                             tap_code16(LGUI(KC_X));
  226.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  227.                             register_code(KC_LALT);
  228.                             tap_code(KC_LEFT);
  229.                             tap_code(KC_RIGHT);
  230.                             unregister_code(KC_LALT);
  231.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(LALT(KC_LEFT)));
  232.                             tap_code16(LGUI(KC_C));
  233.                             tap_code(KC_RIGHT);
  234.                         }
  235.                         layer_control_data.multiplier = 0;
  236.                         layer_control_data.operator   = - 1;
  237.                     }
  238.                     return false;
  239.                 case LALT(KC_RIGHT):
  240.                     if (layer_control_data.operator== - 1 && layer_control_data.multiplier == 0) return true;
  241.                     if (record->event.pressed) {
  242.                         if (layer_control_data.operator== - 1)
  243.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LALT(KC_RIGHT));
  244.                         else if (layer_control_data.operator== KC_BSPC) {
  245.                             register_code(KC_LALT);
  246.                             tap_code(KC_RIGHT);
  247.                             tap_code(KC_LEFT);
  248.                             unregister_code(KC_LALT);
  249.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(LALT(KC_RIGHT)));
  250.                             tap_code16(LGUI(KC_X));
  251.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  252.                             register_code(KC_LALT);
  253.                             tap_code(KC_RIGHT);
  254.                             tap_code(KC_LEFT);
  255.                             unregister_code(KC_LALT);
  256.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(LALT(KC_RIGHT)));
  257.                             tap_code16(LGUI(KC_C));
  258.                             tap_code(KC_LEFT);
  259.                         }
  260.                         layer_control_data.multiplier = 0;
  261.                         layer_control_data.operator   = - 1;
  262.                     }
  263.                     return false;
  264.                 case LGUI(KC_LEFT):
  265.                     if (record->event.pressed) {
  266.                         if (layer_control_data.operator== - 1)
  267.                             tap_code16(LGUI(KC_LEFT));
  268.                         else if (layer_control_data.operator== KC_BSPC) {
  269.                             tap_code16(LSFT(LGUI(KC_LEFT)));
  270.                             tap_code16(LGUI(KC_X));
  271.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  272.                             tap_code16(LSFT(LGUI(KC_LEFT)));
  273.                             tap_code16(LGUI(KC_C));
  274.                             tap_code(KC_RIGHT);
  275.                         }
  276.                         layer_control_data.multiplier = 0;
  277.                         layer_control_data.operator   = - 1;
  278.                     }
  279.                     return false;
  280.                 case LCTL(KC_E):
  281.                     if (record->event.pressed) {
  282.                         if (layer_control_data.operator== - 1)
  283.                             tap_code16(LCTL(KC_E));
  284.                         else if (layer_control_data.operator== KC_BSPC) {
  285.                             tap_code16(LSFT(LCTL(KC_E)));
  286.                             tap_code16(LGUI(KC_X));
  287.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  288.                             tap_code16(LSFT(LCTL(KC_E)));
  289.                             tap_code16(LGUI(KC_C));
  290.                             tap_code(KC_LEFT);
  291.                         }
  292.                         layer_control_data.multiplier = 0;
  293.                         layer_control_data.operator   = - 1;
  294.                     }
  295.                     return false;
  296.                 case KC_BSPC:
  297.                     if (record->event.pressed) {
  298.                         if (get_mods() & MOD_MASK_SHIFT) {
  299.                             unregister_code(KC_LSFT);
  300.                             tap_code16(LGUI(KC_X));
  301.                             register_code(KC_LSFT);
  302.                             layer_control_data.multiplier = 0;
  303.                             layer_control_data.operator   = - 1;
  304.                         } else if (layer_control_data.operator== - 1)
  305.                             layer_control_data.operator= KC_BSPC;
  306.                         else {
  307.                             if (layer_control_data.operator== KC_BSPC) {
  308.                                 tap_code16(LCTL(KC_A));
  309.                                 for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_DOWN));
  310.                                 tap_code16(LGUI(KC_X));
  311.                             }
  312.                             layer_control_data.multiplier = 0;
  313.                             layer_control_data.operator   = - 1;
  314.                         }
  315.                     }
  316.                     return false;
  317.                 case KC_LEFT:
  318.                     if (layer_control_data.operator== - 1 && layer_control_data.multiplier == 0) return true;
  319.                     if (record->event.pressed) {
  320.                         if (layer_control_data.operator== - 1)
  321.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code(KC_LEFT);
  322.                         else if (layer_control_data.operator== KC_BSPC) {
  323.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_LEFT));
  324.                             tap_code16(LGUI(KC_X));
  325.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  326.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_LEFT));
  327.                             tap_code16(LGUI(KC_C));
  328.                             tap_code(KC_RIGHT);
  329.                         }
  330.                         layer_control_data.multiplier = 0;
  331.                         layer_control_data.operator   = - 1;
  332.                     }
  333.                     return false;
  334.                 case KC_DOWN:
  335.                     if (layer_control_data.operator== - 1 && layer_control_data.multiplier == 0) return true;
  336.                     if (record->event.pressed) {
  337.                         if (layer_control_data.operator== - 1)
  338.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code(KC_DOWN);
  339.                         else if (layer_control_data.operator== KC_BSPC) {
  340.                             tap_code16(LCTL(KC_A));
  341.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_DOWN));
  342.                             tap_code16(LGUI(KC_X));
  343.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  344.                             tap_code16(LCTL(KC_A));
  345.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_DOWN));
  346.                             tap_code16(LGUI(KC_C));
  347.                             tap_code(KC_LEFT);
  348.                         }
  349.                         layer_control_data.multiplier = 0;
  350.                         layer_control_data.operator   = - 1;
  351.                     }
  352.                     return false;
  353.                 case KC_UP:
  354.                     if (layer_control_data.operator== - 1 && layer_control_data.multiplier == 0) return true;
  355.                     if (record->event.pressed) {
  356.                         if (layer_control_data.operator== - 1)
  357.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code(KC_UP);
  358.                         else if (layer_control_data.operator== KC_BSPC) {
  359.                             tap_code16(LCTL(KC_E));
  360.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_UP));
  361.                             tap_code16(LSFT(LCTL(KC_E)));
  362.                             tap_code16(LGUI(KC_X));
  363.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  364.                             tap_code16(LCTL(KC_E));
  365.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_UP));
  366.                             tap_code16(LSFT(LCTL(KC_E)));
  367.                             tap_code16(LGUI(KC_C));
  368.                             tap_code(KC_RIGHT);
  369.                         }
  370.                         layer_control_data.multiplier = 0;
  371.                         layer_control_data.operator   = - 1;
  372.                     }
  373.                     return false;
  374.                 case KC_RIGHT:
  375.                     if (layer_control_data.operator== - 1 && layer_control_data.multiplier == 0) return true;
  376.                     if (record->event.pressed) {
  377.                         if (layer_control_data.operator== - 1)
  378.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code(KC_RIGHT);
  379.                         else if (layer_control_data.operator== KC_BSPC) {
  380.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_RIGHT));
  381.                             tap_code16(LGUI(KC_X));
  382.                         } else if (layer_control_data.operator== LGUI(KC_C)) {
  383.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_RIGHT));
  384.                             tap_code16(LGUI(KC_C));
  385.                             tap_code(KC_LEFT);
  386.                         }
  387.                         layer_control_data.multiplier = 0;
  388.                         layer_control_data.operator   = - 1;
  389.                     }
  390.                     return false;
  391.                 case KEY_CREATE_NEXT_LINE:
  392.                     if (record->event.pressed) common_layer_data.back = true;
  393.                     return true;
  394.                 case LGUI(KC_Z):
  395.                     if (layer_control_data.operator== - 1 && layer_control_data.multiplier == 0) return true;
  396.                     if (record->event.pressed) {
  397.                         if (layer_control_data.operator== - 1)
  398.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LGUI(KC_Z));
  399.                         layer_control_data.multiplier = 0;
  400.                         layer_control_data.operator   = - 1;
  401.                     }
  402.                     return false;
  403.                 case LGUI(KC_C):
  404.                     if (record->event.pressed) {
  405.                         if (get_mods() & MOD_MASK_SHIFT) {
  406.                             unregister_code(KC_LSFT);
  407.                             tap_code16(LGUI(KC_C));
  408.                             register_code(KC_LSFT);
  409.                             layer_control_data.multiplier = 0;
  410.                             layer_control_data.operator   = - 1;
  411.                         } else if (layer_control_data.operator== - 1)
  412.                             layer_control_data.operator= LGUI(KC_C);
  413.                         else {
  414.                             if (layer_control_data.operator== LGUI(KC_C)) {
  415.                                 tap_code16(LCTL(KC_A));
  416.                                 for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LSFT(KC_DOWN));
  417.                                 tap_code16(LGUI(KC_C));
  418.                                 tap_code(KC_LEFT);
  419.                             }
  420.                             layer_control_data.multiplier = 0;
  421.                             layer_control_data.operator   = - 1;
  422.                         }
  423.                     }
  424.                     return false;
  425.                 case LGUI(KC_V):
  426.                     if (record->event.pressed) {
  427.                         if (get_mods() & MOD_MASK_SHIFT) {
  428.                             unregister_code(KC_LSFT);
  429.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LGUI(KC_V));
  430.                             register_code(KC_LSFT);
  431.                             layer_control_data.multiplier = 0;
  432.                             layer_control_data.operator   = - 1;
  433.                         } else {
  434.                             for (int i = 0; i < (layer_control_data.multiplier ? layer_control_data.multiplier : 1); ++i) tap_code16(LGUI(KC_V));
  435.                             layer_control_data.multiplier = 0;
  436.                             layer_control_data.operator   = - 1;
  437.                         }
  438.                     }
  439.                     return false;
  440.             }
  441.             layer_control_data.multiplier = 0;
  442.             layer_control_data.operator   = - 1;
  443.             return true;
  444.         case LAYER_WINDOW:
  445.             switch (key) {
  446.                 case SAFE_RANGE + LAYER_WINDOW:
  447.                     if (!record->event.pressed) {
  448.                         if (timer_elapsed(layer_window_data.start_time) < 200)
  449.                             temporary[LAYER_WINDOW] = true;
  450.                         else
  451.                             temporary[LAYER_WINDOW] = false;
  452.                     }
  453.                     return true;
  454.                 case KEY_BACK_LAYER:
  455.                     if (record->event.pressed) tap_code(KC_ENTER);
  456.                     return true;
  457.             }
  458.             return true;
  459.         case LAYER_DESKTOP:
  460.             switch (key) {
  461.                 case KEY_BACK_LAYER:
  462.                     if (record->event.pressed) tap_code16(LCTL(KC_UP));
  463.                     return true;
  464.             }
  465.             return true;
  466.     }
  467.     return true;
  468. }
  470. void handle_layer_start(void) {
  471.     rgblight_disable_noeeprom();
  472.     switch (layers[layers[0] + 1]) {
  473.         case LAYER_RACE_BASE:
  474.         case LAYER_RACE_EXTENSION:
  475.             rgblight_enable_noeeprom();
  476.             rgblight_sethsv_noeeprom(HSV_GREEN);
  477.             rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT);
  478.             return;
  479.         case LAYER_LEGACY_BASE:
  480.         case LAYER_LEGACY_EXTENSION:
  481.             rgblight_enable_noeeprom();
  482.             rgblight_sethsv_noeeprom(HSV_RED);
  483.             rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT);
  484.             return;
  485.         case LAYER_CONTROL:
  486.             layer_control_data.operator   = - 1;
  487.             layer_control_data.multiplier = 0;
  488.             rgblight_enable_noeeprom();
  489.             rgblight_sethsv_noeeprom(HSV_BLUE);
  490.             rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT);
  491.             return;
  492.         case LAYER_WINDOW:
  493.             register_code(KC_LGUI);
  494.             tap_code(KC_TAB);
  495.             layer_window_data.start_time = timer_read();
  496.             return;
  497.         case LAYER_DESKTOP:
  498.             tap_code16(LCTL(KC_UP));
  499.             return;
  500.     }
  501. }
  503. void handle_layer_return(void) {
  504.     rgblight_disable_noeeprom();
  505.     switch (layers[layers[0] + 1]) {
  506.         case LAYER_RACE_BASE:
  507.         case LAYER_RACE_EXTENSION:
  508.             rgblight_enable_noeeprom();
  509.             rgblight_sethsv_noeeprom(HSV_GREEN);
  510.             rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT);
  511.             return;
  512.         case LAYER_LEGACY_BASE:
  513.         case LAYER_LEGACY_EXTENSION:
  514.             rgblight_enable_noeeprom();
  515.             rgblight_sethsv_noeeprom(HSV_RED);
  516.             rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT);
  517.             return;
  518.         case LAYER_CONTROL:
  519.             layer_control_data.operator   = - 1;
  520.             layer_control_data.multiplier = 0;
  521.             rgblight_enable_noeeprom();
  522.             rgblight_sethsv_noeeprom(HSV_BLUE);
  523.             rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT);
  524.             return;
  525.     }
  526. }
  528. void handle_layer_end(void) {
  529.     switch (layers[layers[0] + 1]) {
  530.         case LAYER_WINDOW:
  531.             unregister_code(KC_LGUI);
  532.             return;
  533.     }
  534. }
  536. void update_layer(void) {
  537.     layer_clear();
  538.     common_layer_data.back = false;
  539.     layer_on(layers[layers[0] + 1]);
  540. }
  542. bool handle_call_key(uint16_t key, keyrecord_t* record) {
  543.     switch (key) {
  544.         case KEY_BACK_LAYER:
  545.             if (record->event.pressed) {
  546.                 if (layers[0]) {
  547.                     handle_layer_end();
  548.                     --layers[0];
  549.                     update_layer();
  550.                     handle_layer_return();
  551.                 }
  552.             }
  553.             return false;
  554.     }
  555.     if (key >= SAFE_RANGE && key < SAFE_RANGE + NUMBER_OF_LAYERS) {
  556.         int new_layer = key - SAFE_RANGE;
  557.         if (record->event.pressed) {
  558.             if (layers[layers[0] + 1] != new_layer) {
  559.                 if (temporary[layers[layers[0] + 1]]) {
  560.                     handle_layer_end();
  561.                     layers[layers[0] + 1] = new_layer;
  562.                 } else
  563.                     layers[++layers[0] + 1] = new_layer;
  564.                 update_layer();
  565.                 handle_layer_start();
  566.             }
  567.         } else {
  568.             if (layers[layers[0] + 1] == new_layer && temporary[layers[layers[0] + 1]]) {
  569.                 handle_layer_end();
  570.                 --layers[0];
  571.                 update_layer();
  572.                 handle_layer_return();
  573.             }
  574.         }
  575.         return false;
  576.     }
  577.     if (common_layer_data.back) {
  578.         if (layers[0]) {
  579.             handle_layer_end();
  580.             --layers[0];
  581.             update_layer();
  582.             handle_layer_return();
  583.         }
  584.     }
  585.     return true;
  586. }
  588. bool handle_common_key(uint16_t key, keyrecord_t* record) {
  589.     switch (key) {
  590.         case KEY_INSERT_LINE_START:
  591.             if (record->event.pressed) tap_code16(LGUI(KC_LEFT));
  592.             return false;
  593.         case KEY_INSERT_HERE:
  594.             return false;
  595.         case KEY_INSERT_LINE_END:
  596.             if (record->event.pressed) tap_code16(LGUI(KC_RIGHT));
  597.             return false;
  598.         case KEY_CREATE_PREVIOUS_LINE:
  599.             if (record->event.pressed) {
  600.                 tap_code16(LGUI(KC_LEFT));
  601.                 tap_code(KC_ENTER);
  602.                 tap_code(KC_UP);
  603.             }
  604.             return false;
  605.         case KEY_CREATE_NEXT_LINE:
  606.             if (record->event.pressed) {
  607.                 tap_code16(LGUI(KC_RIGHT));
  608.                 tap_code(KC_ENTER);
  609.             }
  610.             return false;
  611.         case KEY_CUT_WORD:
  612.             if (record->event.pressed) {
  613.                 register_code(KC_LALT);
  614.                 tap_code(KC_LEFT);
  615.                 tap_code(KC_RIGHT);
  616.                 unregister_code(KC_LALT);
  617.                 tap_code16(LSFT(LALT(KC_LEFT)));
  618.                 tap_code16(LGUI(KC_X));
  619.             }
  620.             return false;
  621.         case KEY_CUT_LINE:
  622.             if (record->event.pressed) {
  623.                 tap_code16(LGUI(KC_RIGHT));
  624.                 tap_code16(LSFT(LGUI(KC_LEFT)));
  625.                 tap_code16(LGUI(KC_X));
  626.             }
  627.             return false;
  628.         case KEY_CUT_SELECTION:
  629.             if (record->event.pressed) {
  630.                 if (get_mods() & MOD_MASK_SHIFT) {
  631.                     unregister_code(KC_LSFT);
  632.                     tap_code16(LGUI(KC_X));
  633.                     register_code(KC_LSFT);
  634.                 } else
  635.                     tap_code16(LGUI(KC_X));
  636.             }
  637.             return false;
  638.     }
  639.     return true;
  640. }
  642. bool process_record_user(uint16_t key, keyrecord_t* record) {
  643.     if (!handle_layer_key(key, record)) return false;
  644.     if (!handle_call_key(key, record)) return false;
  645.     return handle_common_key(key, record);
  646. }
  648. void keyboard_post_init_user(void) {
  649.     rgblight_disable_noeeprom();
  650.     rgb_matrix_disable();
  651.     common_layer_data.back = false;
  652. }