logo

qmk_firmware

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

keymap.c (8726B)

    

  1. /* Copyright 2019 niltea
  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. #ifdef OLED_ENABLE
  18.   #include <string.h>
  19.   #include "lib/oled_helper.h"
  20. #endif
  22. enum layerID {
  23.   MAC_CS_1 = 0,
  24.   MAC_CS_2,
  25.   MAC_PS_1,
  26.   MAC_PS_2,
  27.   WIN_CS_1,
  28.   WIN_CS_2,
  29.   WIN_PS_1,
  30.   WIN_PS_2,
  31.   IOS_CS_1,
  32.   IOS_CS_2,
  33.   SETTING,
  34. };
  36. #define Mac_CS PDF(MAC_CS_1)
  37. #define Mac_PS PDF(MAC_PS_1)
  38. #define Win_CS PDF(WIN_CS_1)
  39. #define Win_PS PDF(WIN_PS_1)
  40. #define IOS_CS PDF(IOS_CS_1)
  42. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  43.     // Mac
  44.     // Clip Studio
  45.     [MAC_CS_1] = LAYOUT(
  46.       KC_TAB,       LGUI(KC_A), KC_E,         KC_P,          LGUI(KC_0),
  47.       MO(MAC_CS_2), KC_M,       KC_BSPC,      KC_B,          KC_HYPR,
  48.                     KC_LSFT,    KC_LGUI,      LGUI(KC_Z),    KC_SPC
  49.     ),
  50.     [MAC_CS_2] = LAYOUT(
  51.       MO(SETTING),  KC_ESC,     KC_G,         KC_R,          LGUI(KC_GRV),
  52.       _______,      LGUI(KC_D), KC_K,         KC_F,          LGUI(KC_S),
  53.                     KC_LALT,    KC_I,         SGUI(KC_Z),    KC_H
  54.     ),
  55.     // Photoshop
  56.     [MAC_PS_1] = LAYOUT(
  57.       KC_TAB,       LGUI(KC_A), KC_E,         KC_B,          LGUI(KC_1),
  58.       MO(MAC_PS_2), KC_L,       LGUI(KC_DEL), LGUI(KC_QUOT), KC_MEH,
  59.                     KC_LSFT,    KC_LGUI,      LGUI(KC_Z),    KC_SPC
  60.     ),
  61.     [MAC_PS_2] = LAYOUT(
  62.       MO(SETTING),  KC_ESC,     KC_G,         KC_R,          KC_ESC,
  63.       _______,      LGUI(KC_D), KC_V,         LGUI(KC_T),    LGUI(KC_S),
  64.                     KC_LALT,    KC_I,         SGUI(KC_Z),    KC_H
  65.     ),
  67.     // Windows
  68.     // Clip Studio
  69.     [WIN_CS_1] = LAYOUT(
  70.       KC_TAB,       LCTL(KC_A), KC_E,         KC_P,          LCTL(KC_0),
  71.       MO(WIN_CS_2), KC_M,       KC_BSPC,      KC_B,          KC_HYPR,
  72.                     KC_LSFT,    KC_LCTL,      LCTL(KC_Z),    KC_SPC
  73.     ),
  74.     [WIN_CS_2] = LAYOUT(
  75.       MO(SETTING),  KC_ESC,     KC_G,         KC_R,          LCTL(KC_GRV),
  76.       _______,      LCTL(KC_D), KC_K,         KC_F,          LCTL(KC_S),
  77.                     KC_LALT,    KC_I,         C(S(KC_Z)),    KC_H
  78.     ),
  79.     // Photoshop
  80.     [WIN_PS_1] = LAYOUT(
  81.       KC_TAB,       LCTL(KC_A), KC_E,         KC_B,          LCTL(KC_1),
  82.       MO(WIN_PS_2), KC_L,       LCTL(KC_DEL), LCTL(KC_QUOT), KC_MEH,
  83.                     KC_LSFT,    KC_LCTL,      LCTL(KC_Z),    KC_SPC
  84.     ),
  85.     [WIN_PS_2] = LAYOUT(
  86.       MO(SETTING),  KC_ESC,     KC_G,         KC_R,          KC_ESC,
  87.       _______,      LCTL(KC_D), KC_V,         LCTL(KC_T),    LCTL(KC_S),
  88.                     KC_LALT,    KC_I,         C(S(KC_Z)),    KC_H
  89.     ),
  90.     // iOS
  91.     // Clip Studio
  92.     [IOS_CS_1] = LAYOUT(
  93.       KC_TAB,       LGUI(KC_A), KC_E,         KC_P,          LGUI(KC_0),
  94.       MO(IOS_CS_2), KC_M,       KC_BSPC,      KC_B,          LGUI(KC_LALT),
  95.                     KC_LSFT,    KC_LGUI,      LGUI(KC_Z),    KC_SPC
  96.     ),
  97.     [IOS_CS_2] = LAYOUT(
  98.       MO(SETTING),  KC_ESC,     KC_G,         KC_R,          LGUI(KC_EQL),
  99.       _______,      LGUI(KC_D), KC_K,         KC_F,          LGUI(KC_S),
  100.                     KC_LALT,    KC_I,         SGUI(KC_Z),    KC_H
  101.     ),
  102.     [SETTING] = LAYOUT(
  103.       _______, IOS_CS, Win_CS, Mac_CS, KC_NO,
  104.       _______, KC_NO,  Win_PS, Mac_PS, KC_NO,
  105.                KC_NO,  KC_NO,  KC_NO,  KC_NO
  106.     ),
  107. };
  109. bool encoder_update_user(uint8_t index, bool clockwise) {
  110.   uint8_t currentDefault = get_highest_layer(default_layer_state);
  111.   uint8_t currentLayer = get_highest_layer(layer_state);
  112.   if (index == 0) { /* the upper encoder */
  113.     switch (currentDefault) {
  114.       case MAC_CS_1:
  115.         if (currentLayer % 2 == 0) {
  116.           // default layer
  117.           // Zoom
  118.           tap_code16(!clockwise ? G(KC_MINS) : G(KC_EQL));
  119.         } else {
  120.           // Fn Layer
  121.           // rotate canvas
  122.           tap_code(!clockwise ? KC_MINS : KC_QUOT);
  123.         }
  124.         break;
  125.       case MAC_PS_1:
  126.         if (currentLayer % 2 == 0) {
  127.           // default layer
  128.           // Zoom
  129.           tap_code16(!clockwise ? G(KC_MINS) : G(KC_EQL));
  130.         } else {
  131.           // Fn Layer
  132.           // undo / redo
  133.           tap_code16(!clockwise ? G(KC_Z) : S(G(KC_Z)));
  134.         }
  135.         break;
  136.       case WIN_CS_1:
  137.         if (currentLayer % 2 == 0) {
  138.           // default layer
  139.           // Zoom
  140.           tap_code16(!clockwise ? C(KC_MINS) : C(KC_EQL));
  141.         } else {
  142.           // Fn Layer
  143.           // rotate canvas
  144.           tap_code(!clockwise ? KC_MINS : KC_QUOT);
  145.         }
  146.         break;
  147.       case WIN_PS_1:
  148.         if (currentLayer % 2 == 0) {
  149.           // default layer
  150.           // Zoom
  151.           tap_code16(!clockwise ? C(KC_MINS) : C(KC_SCLN));
  152.         } else {
  153.           // Fn Layer
  154.           // undo / redo
  155.           tap_code16(!clockwise ? C(KC_Z) : C(S(KC_Z)));
  156.         }
  157.         break;
  158.       case IOS_CS_1:
  159.         if (currentLayer % 2 == 0) {
  160.           // default layer
  161.           // Zoom
  162.           tap_code16(!clockwise ? G(KC_MINS) : G(KC_SCLN));
  163.         } else {
  164.           // Fn Layer
  165.           // rotate canvas
  166.           tap_code(!clockwise ? KC_MINS : KC_EQL);
  167.         }
  168.         break;
  169.       default:
  170.         break;
  171.     }
  172.   } else if (index == 1) { /* the lower encoder */
  173.     switch (currentDefault) {
  174.       case MAC_CS_1:
  175.         if (currentLayer % 2 == 0) {
  176.           // default layer
  177.           // size of brush
  178.           tap_code(!clockwise ? KC_LBRC : KC_RBRC);
  179.         } else {
  180.           // Fn Layer
  181.           // opacity of brush
  182.           tap_code16(!clockwise ? G(KC_LBRC) : G(KC_RBRC));
  183.         }
  184.         break;
  185.       case MAC_PS_1:
  186.         if (currentLayer % 2 == 0) {
  187.           // default layer
  188.           // size of brush
  189.           tap_code(!clockwise ? KC_LBRC : KC_RBRC);
  190.         } else {
  191.           // Fn Layer
  192.           // opacity of brush
  193.           tap_code16(!clockwise ? KC_LCBR : KC_RCBR);
  194.         }
  195.         break;
  196.       case WIN_CS_1:
  197.         if (currentLayer % 2 == 0) {
  198.           // default layer
  199.           // rotate canvas
  200.           tap_code(!clockwise ? KC_LBRC : KC_RBRC);
  201.         } else {
  202.           // Fn Layer
  203.           // opacity of brush
  204.           tap_code16(!clockwise ? C(KC_LBRC) : C(KC_RBRC));
  205.         }
  206.         break;
  207.       case WIN_PS_1:
  208.         if (currentLayer % 2 == 0) {
  209.           // default layer
  210.           // rotate canvas
  211.           tap_code(!clockwise ? KC_LBRC : KC_RBRC);
  212.         } else {
  213.           // Fn Layer
  214.           // opacity of brush
  215.           tap_code16(!clockwise ? KC_LCBR : KC_RCBR);
  216.         }
  217.         break;
  218.       case IOS_CS_1:
  219.         if (currentLayer % 2 == 0) {
  220.           // default layer
  221.           // size of brush
  222.           tap_code(!clockwise ? KC_RBRC : KC_BSLS);
  223.         } else {
  224.           // Fn Layer
  225.           // opacity of brush
  226.           tap_code16(!clockwise ? G(KC_RBRC) : G(KC_BSLS));
  227.         }
  228.         break;
  229.       default:
  230.         break;
  231.     }
  232.   }
  233.     return true;
  234. }
  236. // OLED Display
  237. #ifdef OLED_ENABLE
  238. bool oled_task_user(void) {
  239.   // get layer Number
  240.   uint8_t currentDefault = get_highest_layer(default_layer_state);
  241.   uint8_t currentLayer = get_highest_layer(layer_state);
  242.   // write OS mode / 1st line of the logo
  243.   switch (currentDefault) {
  244.     case MAC_CS_1:
  245.     case MAC_PS_1:
  246.       render_row(0, "Mac ");
  247.       break;
  248.     case WIN_CS_1:
  249.     case WIN_PS_1:
  250.       render_row(0, "Win ");
  251.       break;
  252.     case IOS_CS_1:
  253.       render_row(0, "iOS ");
  254.       break;
  255.     default:
  256.       render_row(0, "    ");
  257.   }
  259.   // write Application mode / 2nd line of the logo
  260.   switch (currentDefault) {
  261.     case MAC_CS_1:
  262.     case WIN_CS_1:
  263.     case IOS_CS_1:
  264.       render_row(1, "A:CS");
  265.       break;
  266.     case MAC_PS_1:
  267.     case WIN_PS_1:
  268.       render_row(1, "A:Ps");
  269.       break;
  270.     default:
  271.       render_row(1, "    ");
  272.   }
  274.   if (currentLayer == SETTING) {
  275.     // 3rd & 4th line of the logo
  276.     render_row(2, "****");
  277.     render_row(3, "LSEL");
  278.   } else {
  279.     // Layer Status / 3rd line of the logo
  280.     if (currentLayer % 2 == 0) {
  281.       // default layer
  282.       render_row(2, "L:DF");
  283.     } else {
  284.       // Fn Layer
  285.       render_row(2, "L:Fn");
  286.     }
  287.     // pressed key / 4th line of the logo
  288.     render_row(3, "    ");
  289.   }
  290.     return false;
  291. }
  292. #endif // #ifdef OLED_ENABLE