├── .gitignore ├── .gitmodules ├── Makefile ├── TODO ├── dasbob ├── config.h └── keymap.c ├── images ├── kyria.jpg ├── lily58.jpg ├── sweep-pink.jpg └── sweep-pro-red.jpg ├── kyria ├── config.h ├── keymap.c ├── readme.md └── rules.mk ├── lily58 ├── config.h ├── glcdfont.c ├── keymap.c ├── readme.md └── rules.mk ├── readme.md ├── sweep ├── config.h ├── keymap.c ├── readme.md └── rules.mk ├── totem ├── config.h ├── keymap.c ├── readme.md └── rules.mk └── user ├── combos.c ├── combos.def ├── config.h ├── custom_keycodes.h ├── custom_layers.h ├── features ├── casemodes.c ├── casemodes.h ├── oneshot.c ├── oneshot.h ├── swapper.c └── swapper.h ├── oled.c ├── oled.h ├── pket.c ├── pket.h ├── process_records.c ├── process_records.h ├── readme.md ├── rules.mk └── wrappers.h /.gitignore: -------------------------------------------------------------------------------- 1 | obj_* 2 | *.hex 3 | *.elf 4 | *.map 5 | build/ 6 | .DS_Store 7 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "qmk_firmware"] 2 | path = qmk_firmware 3 | url = https://github.com/qmk/qmk_firmware.git 4 | branch = master 5 | [submodule "qmk-config-totem"] 6 | path = qmk-config-totem 7 | url = https://github.com/patrick-elmquist/qmk-config-totem.git 8 | branch = main 9 | [submodule "qmk-config-dasbob"] 10 | path = qmk-config-dasbob 11 | url = https://github.com/patrick-elmquist/qmk-config-dasbob.git 12 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | USER = pket 2 | KEYBOARDS = lily58 kyria sweep totem dasbob 3 | 4 | # keyboard name 5 | NAME_lily58 = lily58 6 | NAME_kyria = splitkb/kyria/rev1 7 | NAME_sweep = ferris/sweep 8 | NAME_totem = totem 9 | NAME_dasbob = dasbob 10 | 11 | all: $(KEYBOARDS) 12 | 13 | .PHONY: $(KEYBOARDS) 14 | $(KEYBOARDS): 15 | # init submodule 16 | git submodule update --init --recursive 17 | git submodule update --remote 18 | # git submodule foreach make git-submodule 19 | 20 | # cleanup old symlinks 21 | rm -rf qmk-config-totem/totem/keymaps/$(USER) 22 | rm -rf qmk-config-dasbob/keymaps/$(USER) 23 | rm -rf qmk_firmware/keyboards/totem 24 | rm -rf qmk_firmware/keyboards/dasbob 25 | rm -rf qmk_firmware/keyboards/lily58/keymaps/$(USER) 26 | rm -rf qmk_firmware/keyboards/splitkb/kyria/keymaps/$(USER) 27 | rm -rf qmk_firmware/keyboards/ferris/keymaps/$(USER) 28 | rm -rf qmk_firmware/users/$(USER) 29 | 30 | # add new symlinks 31 | ln -s $(shell pwd)/qmk-config-totem/totem qmk_firmware/keyboards/totem 32 | ln -s $(shell pwd)/totem qmk-config-totem/totem/keymaps/$(USER) 33 | 34 | ln -s $(shell pwd)/qmk-config-dasbob/ qmk_firmware/keyboards/dasbob 35 | ln -s $(shell pwd)/dasbob qmk-config-dasbob/keymaps/$(USER) 36 | 37 | ln -s $(shell pwd)/lily58 qmk_firmware/keyboards/lily58/keymaps/$(USER) 38 | ln -s $(shell pwd)/kyria qmk_firmware/keyboards/splitkb/kyria/keymaps/$(USER) 39 | ln -s $(shell pwd)/sweep qmk_firmware/keyboards/ferris/keymaps/$(USER) 40 | ln -s $(shell pwd)/user qmk_firmware/users/$(USER) 41 | 42 | # run lint check 43 | # cd qmk_firmware; qmk lint -km $(USER) -kb $(NAME_$@) 44 | 45 | # run build 46 | make BUILD_DIR=$(shell pwd)/build -j1 -C qmk_firmware $(NAME_$@):$(USER) 47 | 48 | # cleanup symlinks 49 | rm -rf qmk-config-totem/totem/keymaps/$(USER) 50 | rm -rf qmk-config-dasbob/keymaps/$(USER) 51 | rm -rf qmk_firmware/keyboards/lily58/keymaps/$(USER) 52 | rm -rf qmk_firmware/keyboards/splitkb/kyria/keymaps/$(USER) 53 | rm -rf qmk_firmware/keyboards/ferris/keymaps/$(USER) 54 | rm -rf qmk_firmware/keyboards/totem 55 | rm -rf qmk_firmware/keyboards/dasbob 56 | rm -rf qmk_firmware/users/$(USER) 57 | 58 | clean: 59 | rm -rf qmk-config-totem/totem/keymaps/$(USER) 60 | rm -rf qmk-config-dasbob/keymaps/$(USER) 61 | rm -rf qmk_firmware/keyboards/lily58/keymaps/$(USER) 62 | rm -rf qmk_firmware/keyboards/splitkb/kyria/keymaps/$(USER) 63 | rm -rf qmk_firmware/keyboards/ferris/keymaps/$(USER) 64 | rm -rf qmk_firmware/keyboards/totem 65 | rm -rf qmk_firmware/keyboards/dasbob 66 | rm -rf qmk_firmware/users/$(USER) 67 | rm -rf ./build/ 68 | rm -rf ./qmk-config-totem/ 69 | rm -rf ./qmk-config-dasbob/ 70 | rm -rf ./qmk_firmware/ 71 | 72 | -------------------------------------------------------------------------------- /TODO: -------------------------------------------------------------------------------- 1 | TODO: 2 | - Evaluate Auto Shift 3 | - Replace custom caps word implementation with the built in one (if it makes sense) 4 | - Investigate if usb split detection has anything to do with it taking a disconnect/connect cycle for the keyboard to work 5 | - Hardware: add some solder to X and A switches on the Sweep 6 | - Investigate vertical combos for programming bigrams like ==, >=, <=, ?:, ?., -> etc 7 | - Add shortcuts for common VIM shortcuts like split, Ex etc 8 | - Should I add regular Caps word or is screaming snake enough? 9 | - Investigate why the cleanup of Sweep config.h messed up the home row mods 10 | 11 | 12 | - Move finger adjustments to config so that different keyboards can have different values. 13 | - Make some define to make different versions for Pro Red and Pink as it seems to be more 14 | sensitive with the Pinks. 15 | 16 | SYMBOLS 17 | 1234567890 18 | !@#$%^&* 19 | +-_/\|`~= 20 | <>(){}[]"' 21 | 22 | NAV 23 | hjkl 24 | 25 | ACTIONS 26 | Esc 27 | Tab 28 | Backspace 29 | Alt + backspace 30 | Enter 31 | Caps 32 | Screaming snake 33 | (Numword) 34 | (Snake, possibly leader key?) 35 | 36 | APPS 37 | Alfred 38 | iTerm 39 | Window switcher 40 | Application switch 41 | Window placement, left/right, full/restore, thirds 42 | 43 | OTHER 44 | In VIM setup bindings for sp,vsp and similar, will be easier with Ctrl back on home row 45 | -------------------------------------------------------------------------------- /dasbob/config.h: -------------------------------------------------------------------------------- 1 | #define AUDIO_CLICKY 2 | 3 | -------------------------------------------------------------------------------- /dasbob/keymap.c: -------------------------------------------------------------------------------- 1 | #include "pket.h" 2 | 3 | /* THIS FILE WAS GENERATED! 4 | * 5 | #include QMK_KEYBOARD_H 6 | * This file was generated by qmk json2c. You may or may not want to 7 | * edit it directly. 8 | */ 9 | 10 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 11 | [_COLEMAK] = LAYOUT_wrapper_3x5_3( 12 | ________________COLEMAK_L1_5_______________, ________________COLEMAK_R1_5_______________, 13 | ________________COLEMAK_L2_5_______________, ________________COLEMAK_R2_5_______________, 14 | ________________COLEMAK_L3_5_______________, ________________COLEMAK_R3_5_______________, 15 | _______THUMB_LEFT________, _______THUMB_RIGHT_______ 16 | ), 17 | 18 | [_GALLIUM] = LAYOUT_wrapper_3x5_3( 19 | ________________GALLIUM_L1_5_______________, ________________GALLIUM_R1_5_______________, 20 | ________________GALLIUM_L2_5_______________, ________________GALLIUM_R2_5_______________, 21 | ________________GALLIUM_L3_5_______________, ________________GALLIUM_R3_5_______________, 22 | _______THUMB_LEFT________, _______THUMB_RIGHT_______ 23 | ), 24 | 25 | [_GALLIUM_V2] = LAYOUT_wrapper_3x5_3( 26 | ________________GALLIUM_V2_L1_5____________, ________________GALLIUM_V2_R1_5____________, 27 | ________________GALLIUM_V2_L2_5____________, ________________GALLIUM_V2_R2_5____________, 28 | ________________GALLIUM_V2_L3_5____________, ________________GALLIUM_V2_R3_5____________, 29 | _______THUMB_LEFT________, _______THUMB_RIGHT_______ 30 | ), 31 | 32 | [_LOWER] = LAYOUT_wrapper_3x5_3( 33 | ________________LOWER__L1_5________________, ________________LOWER__R1_5________________, 34 | ________________LOWER__L2_5________________, ________________LOWER__R2_5________________, 35 | ________________LOWER__L3_5________________, ________________LOWER__R3_5________________, 36 | _______, _______, _______, KC_ENT, _______, _______ 37 | ), 38 | 39 | [_RAISE] = LAYOUT_wrapper_3x5_3( 40 | ________________RAISE__L1_5________________, ________________RAISE__R1_5________________, 41 | ________________RAISE__L2_5________________, ________________RAISE__R2_5________________, 42 | ________________RAISE__L3_5________________, ________________RAISE__R3_5________________, 43 | _______, _______, _______, _______, _______, _______ 44 | ), 45 | 46 | [_NAV] = LAYOUT_wrapper_3x5_3( 47 | ________________NAV_L1_5___________________, ________________NAV_R1_5___________________, 48 | ________________NAV_L2_5___________________, ________________NAV_R2_5___________________, 49 | ________________NAV_L3_5___________________, ________________NAV_R3_5___________________, 50 | _______, _______, _______, _______, _______, _______ 51 | ), 52 | 53 | [_SYSTEM] = LAYOUT_wrapper_3x5_3( 54 | ________________SYSTEM_L1_5________________, ________________SYSTEM_R1_5________________, 55 | ________________SYSTEM_L2_5________________, ________________SYSTEM_R2_5________________, 56 | ________________SYSTEM_L3_5________________, ________________SYSTEM_R3_5________________, 57 | _______, _______, _______, KC_ENT, _______, _______ 58 | ), 59 | 60 | [_ADJUST] = LAYOUT_wrapper_3x5_3( 61 | ________________ADJUST_L1_5________________, ________________ADJUST_R1_5________________, 62 | ________________ADJUST_L2_5________________, ________________ADJUST_R2_5________________, 63 | ________________ADJUST_L3_5________________, ________________ADJUST_R3_5________________, 64 | _______, _______, _______, _______, _______, _______ 65 | ) 66 | }; 67 | 68 | #ifdef OLED_ENABLE 69 | 70 | /* KEYBOARD PET START */ 71 | 72 | /* settings */ 73 | # define MIN_WALK_SPEED 10 74 | # define MIN_RUN_SPEED 40 75 | 76 | /* advanced settings */ 77 | # define ANIM_FRAME_DURATION 200 // how long each frame lasts in ms 78 | # define ANIM_SIZE 96 // number of bytes in array. If you change sprites, minimize for adequate firmware size. max is 1024 79 | 80 | /* timers */ 81 | uint32_t anim_timer = 0; 82 | 83 | /* current frame */ 84 | uint8_t current_frame = 0; 85 | 86 | /* status variables */ 87 | int current_wpm = 0; 88 | led_t led_usb_state; 89 | 90 | bool isSneaking = false; 91 | bool isJumping = false; 92 | bool showedJump = true; 93 | 94 | /* logic */ 95 | static void render_luna(int LUNA_X, int LUNA_Y) { 96 | /* Sit */ 97 | static const char PROGMEM sit[2][ANIM_SIZE] = {/* 'sit1', 32x22px */ 98 | { 99 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x68, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28, 0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 100 | }, 101 | 102 | /* 'sit2', 32x22px */ 103 | {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x90, 0x08, 0x18, 0x60, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0e, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28, 0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; 104 | 105 | /* Walk */ 106 | static const char PROGMEM walk[2][ANIM_SIZE] = {/* 'walk1', 32x22px */ 107 | { 108 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x90, 0x90, 0x90, 0xa0, 0xc0, 0x80, 0x80, 0x80, 0x70, 0x08, 0x14, 0x08, 0x90, 0x10, 0x10, 0x08, 0xa4, 0x78, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x08, 0xfc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x18, 0xea, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x03, 0x06, 0x18, 0x20, 0x20, 0x3c, 0x0c, 0x12, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 109 | }, 110 | 111 | /* 'walk2', 32x22px */ 112 | { 113 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x20, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x28, 0x10, 0x20, 0x20, 0x20, 0x10, 0x48, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x20, 0xf8, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x30, 0xd5, 0x20, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e, 0x02, 0x1c, 0x14, 0x08, 0x10, 0x20, 0x2c, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 114 | }}; 115 | 116 | /* Run */ 117 | static const char PROGMEM run[2][ANIM_SIZE] = {/* 'run1', 32x22px */ 118 | { 119 | 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x08, 0xc8, 0xb0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0xc4, 0xa4, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x58, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x09, 0x04, 0x04, 0x04, 0x04, 0x02, 0x03, 0x02, 0x01, 0x01, 0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 120 | }, 121 | 122 | /* 'run2', 32x22px */ 123 | { 124 | 0x00, 0x00, 0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x78, 0x28, 0x08, 0x10, 0x20, 0x30, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0xb0, 0x50, 0x55, 0x20, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x1e, 0x20, 0x20, 0x18, 0x0c, 0x14, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 125 | }}; 126 | 127 | /* Bark */ 128 | static const char PROGMEM bark[2][ANIM_SIZE] = {/* 'bark1', 32x22px */ 129 | { 130 | 0x00, 0xc0, 0x20, 0x10, 0xd0, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 131 | }, 132 | 133 | /* 'bark2', 32x22px */ 134 | { 135 | 0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x40, 0x2c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x20, 0x4a, 0x09, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 136 | }}; 137 | 138 | /* Sneak */ 139 | static const char PROGMEM sneak[2][ANIM_SIZE] = {/* 'sneak1', 32x22px */ 140 | { 141 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x40, 0x40, 0x80, 0x00, 0x80, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x21, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x04, 0x04, 0x04, 0x03, 0x01, 0x00, 0x00, 0x09, 0x01, 0x80, 0x80, 0xab, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x02, 0x06, 0x18, 0x20, 0x20, 0x38, 0x08, 0x10, 0x18, 0x04, 0x04, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 142 | }, 143 | 144 | /* 'sneak2', 32x22px */ 145 | { 146 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xa0, 0x20, 0x40, 0x80, 0xc0, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x41, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x40, 0x40, 0x55, 0x82, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e, 0x04, 0x18, 0x10, 0x08, 0x10, 0x20, 0x28, 0x34, 0x06, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 147 | }}; 148 | 149 | /* animation */ 150 | void animate_luna(void) { 151 | /* jump */ 152 | if (isJumping || !showedJump) { 153 | /* clear */ 154 | oled_set_cursor(LUNA_X, LUNA_Y + 2); 155 | oled_write(" ", false); 156 | 157 | oled_set_cursor(LUNA_X, LUNA_Y - 1); 158 | 159 | showedJump = true; 160 | } else { 161 | /* clear */ 162 | oled_set_cursor(LUNA_X, LUNA_Y - 1); 163 | oled_write(" ", false); 164 | 165 | oled_set_cursor(LUNA_X, LUNA_Y); 166 | } 167 | 168 | /* switch frame */ 169 | current_frame = (current_frame + 1) % 2; 170 | 171 | /* current status */ 172 | if (led_usb_state.caps_lock) { 173 | oled_write_raw_P(bark[current_frame], ANIM_SIZE); 174 | 175 | } else if (isSneaking) { 176 | oled_write_raw_P(sneak[current_frame], ANIM_SIZE); 177 | 178 | } else if (current_wpm <= MIN_WALK_SPEED) { 179 | oled_write_raw_P(sit[current_frame], ANIM_SIZE); 180 | 181 | } else if (current_wpm <= MIN_RUN_SPEED) { 182 | oled_write_raw_P(walk[current_frame], ANIM_SIZE); 183 | 184 | } else { 185 | oled_write_raw_P(run[current_frame], ANIM_SIZE); 186 | } 187 | } 188 | 189 | # if OLED_TIMEOUT > 0 190 | /* the animation prevents the normal timeout from occuring */ 191 | if (last_input_activity_elapsed() > OLED_TIMEOUT && last_led_activity_elapsed() > OLED_TIMEOUT) { 192 | oled_off(); 193 | return; 194 | } else { 195 | oled_on(); 196 | } 197 | # endif 198 | 199 | /* animation timer */ 200 | if (timer_elapsed32(anim_timer) > ANIM_FRAME_DURATION) { 201 | anim_timer = timer_read32(); 202 | animate_luna(); 203 | } 204 | } 205 | 206 | /* KEYBOARD PET END */ 207 | 208 | oled_rotation_t oled_init_user(oled_rotation_t rotation) { 209 | return OLED_ROTATION_270; 210 | // if (is_keyboard_master()) { 211 | // return OLED_ROTATION_270; 212 | // } else { 213 | // return OLED_ROTATION_0; 214 | // } 215 | } 216 | 217 | bool oled_task_user(void) { 218 | if (is_keyboard_master()) { 219 | current_wpm = get_current_wpm(); 220 | // static const char PROGMEM raw_logo[] = { 221 | // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 222 | // 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x90, 0x08, 0x18, 0x60, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0e, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 223 | // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28, 0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 224 | // }; 225 | render_empty_line(); 226 | render_default_layer_state(); 227 | render_luna(0, 10); 228 | 229 | char wpm_str[5]; 230 | oled_set_cursor(0, 13); 231 | wpm_str[4] = '\0'; 232 | wpm_str[3] = '0' + current_wpm % 10; 233 | wpm_str[2] = '0' + (current_wpm /= 10) % 10; 234 | wpm_str[1] = '0' + current_wpm / 10; 235 | wpm_str[0] = ' '; 236 | oled_write(wpm_str, false); 237 | 238 | oled_set_cursor(0, 14); 239 | oled_write(" wpm", false); 240 | // oled_set_cursor(0, 5); 241 | // oled_write_raw_P(raw_logo, sizeof(raw_logo)); 242 | } else { 243 | // static const char PROGMEM dasbob_logo[] = { 244 | // 0, 0, 0, 0, 0,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 0, 0, 0, 0, 0,128,128,128,192,192,192,192,192,192,192,192,192,192,192,128,128, 0, 0, 0, 0, 0, 0, 0,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 0, 0, 0, 0, 0,128,128,128,128,128,128,128,128,128,128,128,128,128, 0, 0, 0,128,128,128,128,128,192,192,192,192,192, 0, 0, 0,128,128,128,128,128,128,128,128,128, 0, 0, 0, 0,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 0, 0, 245 | // 0, 0,126,127,255,255,255,255,255,255,255,199,247,255,255,255,255,255,255,255,255,127,252,255,255,255,255,255,255,255,255,255, 15,127,255,255,255,255,255,255,255,255,254,248, 0,126,127,255,255,255,255,255,255,255,199,247,255,255,255,255,255,255,255,255,127,126,255,255,255,255,255,255,255,255,239,239,239,239,207,223,223,223,159, 63, 0, 7, 63,255,255,255,255,255,255,255,254, 14,254,255,255,255,255,255,255,255, 63,241,252,254,255,255,255,255,255,255,255, 31,255,255,255,255,255,255,255,255,255,255,128, 0, 246 | // 0, 0,126,255,255,255,255,255,255,255,255,227,255,255,255,255,255,255,255,255,255, 0, 15, 63,127,255,255,255,255,255,255,255,248,255,255,255,255,255,255,255,255,127, 63, 7, 0,126,255,255,255,255,255,255,255,255,227,255,255,255,255,255,255,255,255,255,128,252,253,249,249,251,251,251,251,251,255,255,255,255,255,255,255,255,127, 30, 0, 0, 0, 3, 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 7, 0, 63,255,255,255,255,255,255,255,255,255,248,255,255,255,255,255,255,255,255,255,255,255, 0, 247 | // 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 248 | // }; 249 | // oled_write_raw_P(dasbob_logo, sizeof(dasbob_logo)); 250 | 251 | oled_set_cursor(0, 10); 252 | render_mod_status_short(); 253 | oled_set_cursor(0, 13); 254 | render_case_mode_status(get_xcase_delimiter(), caps_word_enabled()); 255 | } 256 | 257 | return false; 258 | } 259 | 260 | #endif 261 | -------------------------------------------------------------------------------- /images/kyria.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/patrick-elmquist/qmk-keymaps/ceb6b298c26fb65a8be85a5a86d388ceac4b40a8/images/kyria.jpg -------------------------------------------------------------------------------- /images/lily58.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/patrick-elmquist/qmk-keymaps/ceb6b298c26fb65a8be85a5a86d388ceac4b40a8/images/lily58.jpg -------------------------------------------------------------------------------- /images/sweep-pink.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/patrick-elmquist/qmk-keymaps/ceb6b298c26fb65a8be85a5a86d388ceac4b40a8/images/sweep-pink.jpg -------------------------------------------------------------------------------- /images/sweep-pro-red.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/patrick-elmquist/qmk-keymaps/ceb6b298c26fb65a8be85a5a86d388ceac4b40a8/images/sweep-pro-red.jpg -------------------------------------------------------------------------------- /kyria/config.h: -------------------------------------------------------------------------------- 1 | /* Copyright 2019 Thomas Baart 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 . 15 | */ 16 | 17 | #pragma once 18 | 19 | // for refreshing secondary oled on layer 20 | #define SPLIT_LAYER_STATE_ENABLE 21 | 22 | #ifdef OLED_ENABLE 23 | #define OLED_DISPLAY_128X64 24 | #endif 25 | 26 | -------------------------------------------------------------------------------- /kyria/keymap.c: -------------------------------------------------------------------------------- 1 | /* Copyright 2019 Thomas Baart 2 | * Copyright 2021 Patrick Elmquist 3 | * 4 | * This program is free software: you can redistribute it and/or modify 5 | * it under the terms of the GNU General Public License as published by 6 | * the Free Software Foundation, either version 2 of the License, or 7 | * (at your option) any later version. 8 | * 9 | * This program is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | * GNU General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU General Public License 15 | * along with this program. If not, see . 16 | */ 17 | 18 | #include "pket.h" 19 | 20 | // TODO investigate if there are things in config.h that can be disabled 21 | // to regain some of that lost memory... 22 | // TODO investigate long press of combos, like long press J+L for = would 23 | // result in ==, and longpressing M+, for $ could result in ${} 24 | // ISSUES 25 | // - Callum mods don't work since the OS_RAISE key will reset the keys 26 | // when letting go. Need to add it as an exception. 27 | // - Noticing some strain in using combos a lot, might want to move 28 | // keys I use a lot to a layer instead. 29 | // - The combos for swe chars are not working out, I need something 30 | // better for that. 31 | // - Starting to consider moving BSPC back to a thumb key, also to 32 | // reduce strain in wrist/hand. 33 | // - Might want to remove the macros for single {()} but keep the 34 | // ones for pairs. By doing so, try shrinking the combos to be 35 | // next to each other. 36 | // - The combo for CMD-Z sucks, remove it and add a key in SYSTEM 37 | // - Add a CMD-W next to QUIT in SYSTEM 38 | // - Use combos more for things that trigger multiple chars instead 39 | // of single, if pressing two fingers for one symbol, might as 40 | // well keep it on a layer instead. 41 | // - Move QUOTES to a combo or at least away from the pinky. 42 | // - Add keys for screenshots, especially the one to clipboard 43 | // - Add keys for TickTick shortcuts 44 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 45 | 46 | [_COLEMAK] = LAYOUT_wrapper( 47 | _____________________COLEMAK_L1_____________________, _____________________COLEMAK_R1_____________________, 48 | _____________________COLEMAK_L2_____________________, _____________________COLEMAK_R2_____________________, 49 | _____________________COLEMAK_L3_____________________, CAPS, LOWER, SNK_SCM, BSP_WRD, _____________________COLEMAK_R3_____________________, 50 | KC_LGUI, RAISE, _______THUMB_LEFT________, _______THUMB_RIGHT_______, KC_LALT, KC_LGUI 51 | ), 52 | 53 | [_LOWER] = LAYOUT_wrapper( 54 | _____________________LOWER__L1______________________, _____________________LOWER__R1______________________, 55 | _____________________LOWER__L2______________________, _____________________LOWER__R2______________________, 56 | _____________________LOWER__L3______________________, _______, _______, _______, _______, _____________________LOWER__R3______________________, 57 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ 58 | ), 59 | 60 | [_RAISE] = LAYOUT_wrapper( 61 | _____________________RAISE__L1______________________, _____________________RAISE__R1______________________, 62 | _____________________RAISE__L2______________________, _____________________RAISE__R2______________________, 63 | _____________________RAISE__L3______________________, _______, _______, _______, _______, _____________________RAISE__R3______________________, 64 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ 65 | ), 66 | 67 | [_SYSTEM] = LAYOUT_wrapper( 68 | _____________________SYSTEM_L1______________________, _____________________SYSTEM_R1______________________, 69 | _____________________SYSTEM_L2______________________, _____________________SYSTEM_R2______________________, 70 | _____________________SYSTEM_L3______________________, _______, _______, _______, _______, _____________________SYSTEM_R3______________________, 71 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ 72 | ), 73 | 74 | [_ADJUST] = LAYOUT_wrapper( 75 | _____________________ADJUST_L1______________________, _____________________ADJUST_R1______________________, 76 | _____________________ADJUST_L2______________________, _____________________ADJUST_R2______________________, 77 | _____________________ADJUST_L3______________________, _______, _______, _______, _______, _____________________ADJUST_R3______________________, 78 | _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ 79 | ) 80 | }; 81 | 82 | #ifdef OLED_ENABLE 83 | 84 | // static void render_qmk_logo(void) { 85 | // static const char PROGMEM qmk_logo[] = { 86 | // 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94, 87 | // 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4, 88 | // 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0}; 89 | 90 | // oled_write_P(qmk_logo, false); 91 | // } 92 | 93 | // static void render_status(void) { 94 | // render_qmk_logo(); 95 | 96 | // render_empty_line(); 97 | 98 | // oled_write_P(PSTR(" Layer: "), false); 99 | // switch (get_highest_layer(layer_state)) { 100 | // case _COLEMAK: 101 | // oled_write_P(PSTR("Colemak\n"), false); 102 | // break; 103 | // case _LOWER: 104 | // oled_write_P(PSTR("Lower\n"), false); 105 | // break; 106 | // case _RAISE: 107 | // oled_write_P(PSTR("Raise\n"), false); 108 | // break; 109 | // case _SYSTEM: 110 | // oled_write_P(PSTR("System\n"), false); 111 | // break; 112 | // case _ADJUST: 113 | // oled_write_P(PSTR("Adjust\n"), false); 114 | // break; 115 | // default: 116 | // oled_write_P(PSTR("Undefined\n"), false); 117 | // } 118 | // render_case_mode_status(get_xcase_delimiter(), caps_word_enabled()); 119 | // render_combo_status(); 120 | // render_mod_status_short(); 121 | // } 122 | 123 | // void oled_task_user(void) { 124 | // if (is_keyboard_master()) { 125 | // render_status(); 126 | // } else { 127 | // switch (get_highest_layer(layer_state)) { 128 | // case _COLEMAK: 129 | // oled_write_P(PSTR("COLEMAK\n"), false); 130 | // render_empty_line(); 131 | // oled_write_P(PSTR("Q W F P B J L U Y ; \\\n"), false); 132 | // oled_write_P(PSTR("A R S T G M N E I O '\n"), false); 133 | // oled_write_P(PSTR("Z X C D V K H , . / -\n"), false); 134 | // break; 135 | // default: 136 | // render_empty_line(); 137 | // render_empty_line(); 138 | // render_empty_line(); 139 | // render_empty_line(); 140 | // render_empty_line(); 141 | // render_empty_line(); 142 | // render_empty_line(); 143 | // break; 144 | // } 145 | // } 146 | // } 147 | 148 | oled_rotation_t oled_init_user(oled_rotation_t rotation) { 149 | return OLED_ROTATION_180; 150 | } 151 | 152 | #endif 153 | 154 | -------------------------------------------------------------------------------- /kyria/readme.md: -------------------------------------------------------------------------------- 1 | Kyria 2 | 3 | https://splitkb.com/products/kyria-pcb-kit 4 | 5 | drawing 6 | -------------------------------------------------------------------------------- /kyria/rules.mk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/patrick-elmquist/qmk-keymaps/ceb6b298c26fb65a8be85a5a86d388ceac4b40a8/kyria/rules.mk -------------------------------------------------------------------------------- /lily58/config.h: -------------------------------------------------------------------------------- 1 | /* 2 | This is the c configuration file for the keymap 3 | 4 | Copyright 2012 Jun Wako 5 | Copyright 2015 Jack Humbert 6 | 7 | This program is free software: you can redistribute it and/or modify 8 | it under the terms of the GNU General Public License as published by 9 | the Free Software Foundation, either version 2 of the License, or 10 | (at your option) any later version. 11 | 12 | This program is distributed in the hope that it will be useful, 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | GNU General Public License for more details. 16 | 17 | You should have received a copy of the GNU General Public License 18 | along with this program. If not, see . 19 | */ 20 | 21 | #pragma once 22 | 23 | #define MASTER_LEFT 24 | 25 | #ifdef OLED_FONT_H 26 | #undef OLED_FONT_H 27 | #endif 28 | #define OLED_FONT_H "keyboards/lily58/keymaps/pket/glcdfont.c" 29 | -------------------------------------------------------------------------------- /lily58/glcdfont.c: -------------------------------------------------------------------------------- 1 | // This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0. 2 | // See gfxfont.h for newer custom bitmap font info. 3 | 4 | // Modified to show the Lily58 logo instead of the qmk logo 5 | #include "progmem.h" 6 | 7 | // Standard ASCII 5x7 font 8 | const unsigned char font[] PROGMEM = { 9 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 10 | 0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00, 11 | 0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00, 12 | 0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00, 13 | 0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00, 14 | 0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00, 15 | 0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00, 16 | 0x00, 0x18, 0x3C, 0x18, 0x00, 0x00, 17 | 0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00, 18 | 0x00, 0x18, 0x24, 0x18, 0x00, 0x00, 19 | 0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00, 20 | 0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00, 21 | 0x26, 0x29, 0x79, 0x29, 0x26, 0x00, 22 | 0x40, 0x7F, 0x05, 0x05, 0x07, 0x00, 23 | 0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00, 24 | 0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00, 25 | 0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00, 26 | 0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00, 27 | 0x14, 0x22, 0x7F, 0x22, 0x14, 0x00, 28 | 0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00, 29 | 0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00, 30 | 0x00, 0x66, 0x89, 0x95, 0x6A, 0x00, 31 | 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 32 | 0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00, 33 | 0x08, 0x04, 0x7E, 0x04, 0x08, 0x00, 34 | 0x10, 0x20, 0x7E, 0x20, 0x10, 0x00, 35 | 0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00, 36 | 0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00, 37 | 0x1E, 0x10, 0x10, 0x10, 0x10, 0x00, 38 | 0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00, 39 | 0x30, 0x38, 0x3E, 0x38, 0x30, 0x00, 40 | 0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00, 41 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 42 | 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, 43 | 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 44 | 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00, 45 | 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00, 46 | 0x23, 0x13, 0x08, 0x64, 0x62, 0x00, 47 | 0x36, 0x49, 0x56, 0x20, 0x50, 0x00, 48 | 0x00, 0x08, 0x07, 0x03, 0x00, 0x00, 49 | 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00, 50 | 0x00, 0x41, 0x22, 0x1C, 0x00, 0x00, 51 | 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00, 52 | 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 53 | 0x00, 0x80, 0x70, 0x30, 0x00, 0x00, 54 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 55 | 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 56 | 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 57 | 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 58 | 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00, 59 | 0x72, 0x49, 0x49, 0x49, 0x46, 0x00, 60 | 0x21, 0x41, 0x49, 0x4D, 0x33, 0x00, 61 | 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00, 62 | 0x27, 0x45, 0x45, 0x45, 0x39, 0x00, 63 | 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00, 64 | 0x41, 0x21, 0x11, 0x09, 0x07, 0x00, 65 | 0x36, 0x49, 0x49, 0x49, 0x36, 0x00, 66 | 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00, 67 | 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 68 | 0x00, 0x40, 0x34, 0x00, 0x00, 0x00, 69 | 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 70 | 0x14, 0x14, 0x14, 0x14, 0x14, 0x00, 71 | 0x00, 0x41, 0x22, 0x14, 0x08, 0x00, 72 | 0x02, 0x01, 0x59, 0x09, 0x06, 0x00, 73 | 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00, 74 | 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00, 75 | 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00, 76 | 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00, 77 | 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00, 78 | 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00, 79 | 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00, 80 | 0x3E, 0x41, 0x41, 0x51, 0x73, 0x00, 81 | 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 82 | 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00, 83 | 0x20, 0x40, 0x41, 0x3F, 0x01, 0x00, 84 | 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00, 85 | 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00, 86 | 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00, 87 | 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00, 88 | 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, 89 | 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00, 90 | 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00, 91 | 0x7F, 0x09, 0x19, 0x29, 0x46, 0x00, 92 | 0x26, 0x49, 0x49, 0x49, 0x32, 0x00, 93 | 0x03, 0x01, 0x7F, 0x01, 0x03, 0x00, 94 | 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00, 95 | 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00, 96 | 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00, 97 | 0x63, 0x14, 0x08, 0x14, 0x63, 0x00, 98 | 0x03, 0x04, 0x78, 0x04, 0x03, 0x00, 99 | 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00, 100 | 0x00, 0x7F, 0x41, 0x41, 0x41, 0x00, 101 | 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 102 | 0x00, 0x41, 0x41, 0x41, 0x7F, 0x00, 103 | 0x04, 0x02, 0x01, 0x02, 0x04, 0x00, 104 | 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 105 | 0x00, 0x03, 0x07, 0x08, 0x00, 0x00, 106 | 0x20, 0x54, 0x54, 0x78, 0x40, 0x00, 107 | 0x7F, 0x28, 0x44, 0x44, 0x38, 0x00, 108 | 0x38, 0x44, 0x44, 0x44, 0x28, 0x00, 109 | 0x38, 0x44, 0x44, 0x28, 0x7F, 0x00, 110 | 0x38, 0x54, 0x54, 0x54, 0x18, 0x00, 111 | 0x00, 0x08, 0x3E, 0x09, 0x02, 0x00, 112 | 0x58, 0xA4, 0xA4, 0x9C, 0x78, 0x00, 113 | 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, 114 | 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00, 115 | 0x20, 0x40, 0x40, 0x3D, 0x00, 0x00, 116 | 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 117 | 0x00, 0x41, 0x7F, 0x40, 0x00, 0x00, 118 | 0x7C, 0x04, 0x78, 0x04, 0x78, 0x00, 119 | 0x7C, 0x08, 0x04, 0x04, 0x78, 0x00, 120 | 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 121 | 0x7C, 0x18, 0x24, 0x24, 0x18, 0x00, 122 | 0x18, 0x24, 0x24, 0x18, 0x7C, 0x00, 123 | 0x7C, 0x08, 0x04, 0x04, 0x08, 0x00, 124 | 0x48, 0x54, 0x54, 0x54, 0x24, 0x00, 125 | 0x04, 0x04, 0x3F, 0x44, 0x24, 0x00, 126 | 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00, 127 | 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00, 128 | 0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00, 129 | 0x44, 0x28, 0x10, 0x28, 0x44, 0x00, 130 | 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00, 131 | 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00, 132 | 0x00, 0x08, 0x36, 0x41, 0x00, 0x00, 133 | 0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 134 | 0x00, 0x41, 0x36, 0x08, 0x00, 0x00, 135 | 0x02, 0x01, 0x02, 0x04, 0x02, 0x00, 136 | 0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00, 137 | 0x00, 0x00, 0xF0, 0xF8, 0x9C, 0x0C, 138 | 0x0C, 0x1C, 0xF8, 0xE0, 0x00, 0x00, 139 | 0x00, 0x00, 0xE0, 0xF8, 0x1C, 0x0C, 140 | 0x0C, 0x9C, 0xF8, 0xF0, 0x00, 0x00, 141 | 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 142 | 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 143 | 0x00, 0x00, 0x00, 0x80, 0xFC, 0xFC, 144 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 145 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 146 | 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x7E, 147 | 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 148 | 0x60, 0xE0, 0xE0, 0x00, 0x00, 0x00, 149 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 150 | 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x00, 151 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 152 | 0x00, 0x00, 0x00, 0xF0, 0xFC, 0xFC, 153 | 0xFC, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 154 | 0x1C, 0x1C, 0x1C, 0x00, 0x00, 0x00, 155 | 0x00, 0x00, 0x00, 0xC0, 0xF0, 0xF8, 156 | 0x38, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 157 | 0x1C, 0x3C, 0xF8, 0xF0, 0x80, 0x00, 158 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 159 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 160 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 161 | 0x00, 0x00, 0x02, 0x02, 0x06, 0x0C, 162 | 0x18, 0x32, 0x22, 0x22, 0x00, 0x00, 163 | 0x00, 0x00, 0x08, 0x0C, 0x7A, 0x41, 164 | 0x7A, 0x0C, 0x08, 0x00, 0x00, 0x00, 165 | 0x00, 0x3E, 0x20, 0x20, 0x00, 0x00, 166 | 0x00, 0x3E, 0x0A, 0x36, 0x00, 0x00, 167 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 168 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 169 | 0x00, 0x00, 0x00, 0x81, 0x81, 0xC3, 170 | 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 171 | 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 172 | 0xC3, 0x81, 0x81, 0x00, 0x00, 0x00, 173 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 174 | 0x01, 0x80, 0xC0, 0xE0, 0x70, 0x38, 175 | 0x1C, 0x0E, 0x07, 0x03, 0x01, 0x00, 176 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 177 | 0x00, 0x08, 0x1C, 0x3E, 0x77, 0xE3, 178 | 0xC1, 0x80, 0x00, 0x00, 0x00, 0x00, 179 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 180 | 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 181 | 0x00, 0x08, 0x1C, 0x3E, 0x77, 0xE3, 182 | 0xC1, 0x80, 0x00, 0x00, 0x00, 0x00, 183 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 184 | 0x00, 0x00, 0x00, 0x3F, 0x3F, 0x3F, 185 | 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x3C, 186 | 0x78, 0xF8, 0xF0, 0xE0, 0x80, 0x00, 187 | 0x00, 0x00, 0x00, 0xC3, 0xE7, 0xFF, 188 | 0x7E, 0x3C, 0x38, 0x78, 0x78, 0x70, 189 | 0x70, 0xF8, 0xFF, 0xDF, 0x87, 0x00, 190 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 191 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 192 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 193 | 0x00, 0x00, 0x30, 0x18, 0x0C, 0x06, 194 | 0x0C, 0x18, 0x30, 0x00, 0x00, 0x00, 195 | 0x00, 0x00, 0x77, 0x55, 0x7F, 0x14, 196 | 0x7F, 0x55, 0x77, 0x00, 0x00, 0x00, 197 | 0x00, 0x5E, 0x50, 0x50, 0x00, 0x00, 198 | 0x00, 0x5E, 0x4A, 0x56, 0x00, 0x00, 199 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 200 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 201 | 0x00, 0x00, 0x0F, 0x1F, 0x39, 0x30, 202 | 0x30, 0x18, 0x1F, 0x07, 0x00, 0x00, 203 | 0x00, 0x00, 0x07, 0x1F, 0x18, 0x30, 204 | 0x30, 0x39, 0x1F, 0x0F, 0x00, 0x00, 205 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 206 | 0x3F, 0x03, 0x01, 0x00, 0x00, 0x00, 207 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 208 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 209 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 210 | 0x01, 0x03, 0x07, 0x0E, 0x1C, 0x3F, 211 | 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 212 | 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 213 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 214 | 0x01, 0x03, 0x07, 0x0E, 0x1C, 0x00, 215 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 216 | 0x00, 0x00, 0x00, 0x70, 0xF0, 0xE0, 217 | 0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 0xE0, 218 | 0xF0, 0xF8, 0x7F, 0x3F, 0x0F, 0x00, 219 | 0x00, 0x00, 0x0F, 0x3F, 0x7F, 0xF9, 220 | 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 221 | 0xC0, 0xE0, 0xF9, 0x7F, 0x3F, 0x1F, 222 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 223 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 224 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 225 | 0x10, 0x18, 0x0C, 0x18, 0x10, 0x00, 226 | 0x08, 0x3C, 0x26, 0x3C, 0x08, 0x00, 227 | 0x04, 0x0C, 0x18, 0x34, 0x24, 0x00, 228 | 0x14, 0x3E, 0x14, 0x3E, 0x14, 0x00, 229 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 230 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 231 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 232 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 233 | }; 234 | -------------------------------------------------------------------------------- /lily58/keymap.c: -------------------------------------------------------------------------------- 1 | #include "pket.h" 2 | 3 | // TODO move enter and change thumb shift to one shot and perhaps toggle Word cap on double tap 4 | // TODO update the combo term since io and er seems to misfire 5 | // TODO can I solve the issues with CMD (SFT) + N by having OSM CMD and SFT on SPC and ENT 6 | // TODO make double tapping the number layer toggle NUMWORD 7 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 8 | 9 | [_COLEMAK] = LAYOUT_wrapper( \ 10 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, 11 | _____________________COLEMAK_L1_____________________, _____________________COLEMAK_R1_____________________, 12 | _____________________COLEMAK_L2_____________________, _____________________COLEMAK_R2_____________________, 13 | _____________________COLEMAK_L3_____________________, KC_LBRC, KC_RBRC, _____________________COLEMAK_R3_____________________, 14 | XXXXXXX, RAISE, SYSTEM, LOW_SPC, RAI_ENT, LOWER, LOWER, XXXXXXX 15 | ), 16 | 17 | [_LOWER] = LAYOUT_wrapper( \ 18 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, 19 | _____________________LOWER__L1______________________, _____________________LOWER__R1______________________, 20 | _____________________LOWER__L2______________________, _____________________LOWER__R2______________________, 21 | _____________________LOWER__L3______________________, _______, _______, _____________________LOWER__R3______________________, 22 | _______, _______, _______, _______, _______, _______, _______, _______ 23 | ), 24 | 25 | [_RAISE] = LAYOUT_wrapper( \ 26 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, 27 | _____________________RAISE__L1______________________, _____________________RAISE__R1______________________, 28 | _____________________RAISE__L2______________________, _____________________RAISE__R2______________________, 29 | _____________________RAISE__L3______________________, _______, _______, _____________________RAISE__R3______________________, 30 | _______, _______, _______, _______, _______, _______, _______, _______ 31 | ), 32 | 33 | [_ADJUST] = LAYOUT_wrapper( \ 34 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, 35 | _____________________ADJUST_L1______________________, _____________________ADJUST_R1______________________, 36 | _____________________ADJUST_L2______________________, _____________________ADJUST_R2______________________, 37 | _____________________ADJUST_L3______________________, _______, _______, _____________________ADJUST_R3______________________, 38 | _______, _______, _______, _______, _______, _______, _______, _______ 39 | ), 40 | 41 | [_SYSTEM] = LAYOUT_wrapper( \ 42 | XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, 43 | _____________________SYSTEM_L1______________________, _____________________SYSTEM_R1______________________, 44 | _____________________SYSTEM_L2______________________, _____________________SYSTEM_R2______________________, 45 | _____________________SYSTEM_L3______________________, _______, _______, _____________________SYSTEM_R3______________________, 46 | _______, _______, _______, _______, _______, _______, _______, _______ 47 | ) 48 | }; 49 | 50 | #ifdef OLED_ENABLE 51 | 52 | // void oled_task_user(void) { 53 | // if (is_keyboard_master()) { 54 | // render_empty_line(); 55 | // render_default_layer_state(); 56 | // render_empty_line(); 57 | // render_case_mode_status(get_xcase_delimiter(), caps_word_enabled()); 58 | // render_empty_line(); 59 | // render_keylogger_status(); 60 | // render_empty_line(); 61 | // render_combo_status(); 62 | // } else { 63 | // render_empty_line(); 64 | // render_modifier_status(); 65 | // } 66 | // } 67 | 68 | oled_rotation_t oled_init_user(oled_rotation_t rotation) { 69 | if (is_keyboard_master()) { 70 | return OLED_ROTATION_270; 71 | } else { 72 | return OLED_ROTATION_180; 73 | } 74 | } 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /lily58/readme.md: -------------------------------------------------------------------------------- 1 | Lily58 keymap 2 | 3 | https://mechboards.co.uk/products/lily58-kit 4 | 5 | ![](https://user-images.githubusercontent.com/1384547/131533204-2f39c186-c416-43ba-94ab-873f2c3387b3.JPG) 6 | -------------------------------------------------------------------------------- /lily58/rules.mk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/patrick-elmquist/qmk-keymaps/ceb6b298c26fb65a8be85a5a86d388ceac4b40a8/lily58/rules.mk -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # keymaps 2 | A user repository with my keymaps for QMK keyboards. 3 | 4 | I posted a guide for how to set this up: [Post@Medium](https://medium.com/@patrick.elmquist/separate-keymap-repo-for-qmk-136ff5a419bd) 5 | 6 | Keyboards: 7 | - DASBOB / Choc Nocturnal (no image) 8 | - Totem / Choc Pink (no image) 9 | - Ferris Sweep / Choc Purpz 10 | - Ferris Sweep / Choc Pink 11 | - Ferris Sweep / Choc Pro Red (spring swapped to 15g) 12 | - Kyria / Gateron Yellow 13 | - Lily58 / Boba U4 Silent 14 | 15 | drawingdrawingdrawingdrawing 16 | -------------------------------------------------------------------------------- /sweep/config.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2020 Pierre Chevalier 3 | 4 | This program is free software: you can redistribute it and/or modify 5 | it under the terms of the GNU General Public License as published by 6 | the Free Software Foundation, either version 2 of the License, or 7 | (at your option) any later version. 8 | 9 | This program is distributed in the hope that it will be useful, 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | GNU General Public License for more details. 13 | 14 | You should have received a copy of the GNU General Public License 15 | along with this program. If not, see . 16 | */ 17 | 18 | #pragma once 19 | 20 | #define PERMISSIVE_HOLD 21 | #define HOLD_ON_OTHER_KEY_PRESS 22 | // #define QUICK_TAP_TERM 0 23 | #define QUICK_TAP_TERM_PER_KEY 24 | 25 | #undef TAPPING_TERM 26 | #define TAPPING_TERM 170 27 | -------------------------------------------------------------------------------- /sweep/keymap.c: -------------------------------------------------------------------------------- 1 | /* Copyright 2022 Patrick Elmquist 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 . 15 | */ 16 | 17 | #include "pket.h" 18 | 19 | /* THIS FILE WAS GENERATED! 20 | * 21 | #include QMK_KEYBOARD_H 22 | * This file was generated by qmk json2c. You may or may not want to 23 | * edit it directly. 24 | */ 25 | 26 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 27 | [_COLEMAK] = LAYOUT_wrapper( 28 | ________________COLEMAK_L1_5_______________, ________________COLEMAK_R1_5_______________, 29 | ________________COLEMAK_L2_5_______________, ________________COLEMAK_R2_5_______________, 30 | ________________COLEMAK_L3_5_______________, ________________COLEMAK_R3_5_______________, 31 | ___THUMB_LEFT___, ___THUMB_RIGHT__ 32 | ), 33 | 34 | [_GALLIUM] = LAYOUT_wrapper( 35 | ________________GALLIUM_L1_5_______________, ________________GALLIUM_R1_5_______________, 36 | ________________GALLIUM_L2_5_______________, ________________GALLIUM_R2_5_______________, 37 | ________________GALLIUM_L3_5_______________, ________________GALLIUM_R3_5_______________, 38 | ___THUMB_LEFT___, ___THUMB_RIGHT__ 39 | ), 40 | 41 | [_LOWER] = LAYOUT_wrapper( 42 | ________________LOWER__L1_5________________, ________________LOWER__R1_5________________, 43 | ________________LOWER__L2_5________________, ________________LOWER__R2_5________________, 44 | ________________LOWER__L3_5________________, ________________LOWER__R3_5________________, 45 | _______, _______, KC_ENT, _______ 46 | ), 47 | 48 | [_RAISE] = LAYOUT_wrapper( 49 | ________________RAISE__L1_5________________, ________________RAISE__R1_5________________, 50 | ________________RAISE__L2_5________________, ________________RAISE__R2_5________________, 51 | ________________RAISE__L3_5________________, ________________RAISE__R3_5________________, 52 | _______, _______, _______, _______ 53 | ), 54 | 55 | [_NAV] = LAYOUT_wrapper( 56 | ________________NAV_L1_5___________________, ________________NAV_R1_5___________________, 57 | ________________NAV_L2_5___________________, ________________NAV_R2_5___________________, 58 | ________________NAV_L3_5___________________, ________________NAV_R3_5___________________, 59 | _______, _______, _______, _______ 60 | ), 61 | 62 | [_SYSTEM] = LAYOUT_wrapper( 63 | ________________SYSTEM_L1_5________________, ________________SYSTEM_R1_5________________, 64 | ________________SYSTEM_L2_5________________, ________________SYSTEM_R2_5________________, 65 | ________________SYSTEM_L3_5________________, ________________SYSTEM_R3_5________________, 66 | _______, _______, KC_ENT, _______ 67 | ), 68 | 69 | [_ADJUST] = LAYOUT_wrapper( 70 | ________________ADJUST_L1_5________________, ________________ADJUST_R1_5________________, 71 | ________________ADJUST_L2_5________________, ________________ADJUST_R2_5________________, 72 | ________________ADJUST_L3_5________________, ________________ADJUST_R3_5________________, 73 | _______, _______, _______, _______ 74 | ) 75 | }; 76 | 77 | -------------------------------------------------------------------------------- /sweep/readme.md: -------------------------------------------------------------------------------- 1 | Ferris Sweep 2 | 3 | https://github.com/davidphilipbarr/Sweep 4 | 5 | drawing 6 | -------------------------------------------------------------------------------- /sweep/rules.mk: -------------------------------------------------------------------------------- 1 | BOOTLOADER = atmel-dfu 2 | 3 | OLED_ENABLE = no # OLED display 4 | -------------------------------------------------------------------------------- /totem/config.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define MASTER_LEFT 4 | 5 | #define PERMISSIVE_HOLD 6 | #define HOLD_ON_OTHER_KEY_PRESS 7 | // #define QUICK_TAP_TERM 0 8 | #define QUICK_TAP_TERM_PER_KEY 9 | 10 | #undef TAPPING_TERM 11 | #define TAPPING_TERM 170 12 | -------------------------------------------------------------------------------- /totem/keymap.c: -------------------------------------------------------------------------------- 1 | /* Copyright 2022 Patrick Elmquist 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 . 15 | */ 16 | 17 | #include "pket.h" 18 | 19 | /* THIS FILE WAS GENERATED! 20 | * 21 | #include QMK_KEYBOARD_H 22 | * This file was generated by qmk json2c. You may or may not want to 23 | * edit it directly. 24 | */ 25 | 26 | const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 27 | [_COLEMAK] = LAYOUT_wrapper( 28 | ________________COLEMAK_L1_5_______________, ________________COLEMAK_R1_5_______________, 29 | ________________COLEMAK_L2_5_______________, ________________COLEMAK_R2_5_______________, 30 | KC_Q, ________________COLEMAK_L3_5_______________, ________________COLEMAK_R3_5_______________, KC_SCLN, 31 | _______THUMB_LEFT________, _______THUMB_RIGHT_______ 32 | ), 33 | 34 | [_GALLIUM] = LAYOUT_wrapper( 35 | ________________GALLIUM_L1_5_______________, ________________GALLIUM_R1_5_______________, 36 | ________________GALLIUM_L2_5_______________, ________________GALLIUM_R2_5_______________, 37 | KC_Q, ________________GALLIUM_L3_5_______________, ________________GALLIUM_R3_5_______________, KC_SCLN, 38 | _______THUMB_LEFT________, _______THUMB_RIGHT_______ 39 | ), 40 | 41 | [_GALLIUM_V2] = LAYOUT_wrapper( 42 | ________________GALLIUM_V2_L1_5____________, ________________GALLIUM_V2_R1_5____________, 43 | ________________GALLIUM_V2_L2_5____________, ________________GALLIUM_V2_R2_5____________, 44 | KC_Q, ________________GALLIUM_V2_L3_5____________, ________________GALLIUM_V2_R3_5____________, KC_SCLN, 45 | _______THUMB_LEFT________, _______THUMB_RIGHT_______ 46 | ), 47 | 48 | [_LOWER] = LAYOUT_wrapper( 49 | ________________LOWER__L1_5________________, ________________LOWER__R1_5________________, 50 | ________________LOWER__L2_5________________, ________________LOWER__R2_5________________, 51 | KC_Q, ________________LOWER__L3_5________________, ________________LOWER__R3_5________________, KC_SCLN, 52 | _______, _______, _______, KC_ENT, _______, _______ 53 | ), 54 | 55 | [_RAISE] = LAYOUT_wrapper( 56 | ________________RAISE__L1_5________________, ________________RAISE__R1_5________________, 57 | ________________RAISE__L2_5________________, ________________RAISE__R2_5________________, 58 | KC_Q, ________________RAISE__L3_5________________, ________________RAISE__R3_5________________, KC_SCLN, 59 | _______, _______, _______, _______, _______, _______ 60 | ), 61 | 62 | [_NAV] = LAYOUT_wrapper( 63 | ________________NAV_L1_5___________________, ________________NAV_R1_5___________________, 64 | ________________NAV_L2_5___________________, ________________NAV_R2_5___________________, 65 | KC_Q, ________________NAV_L3_5___________________, ________________NAV_R3_5___________________, KC_SCLN, 66 | _______, _______, _______, _______, _______, _______ 67 | ), 68 | 69 | [_SYSTEM] = LAYOUT_wrapper( 70 | ________________SYSTEM_L1_5________________, ________________SYSTEM_R1_5________________, 71 | ________________SYSTEM_L2_5________________, ________________SYSTEM_R2_5________________, 72 | KC_Q, ________________SYSTEM_L3_5________________, ________________SYSTEM_R3_5________________, KC_SCLN, 73 | _______, _______, _______, KC_ENT, _______, _______ 74 | ), 75 | 76 | [_ADJUST] = LAYOUT_wrapper( 77 | ________________ADJUST_L1_5________________, ________________ADJUST_R1_5________________, 78 | ________________ADJUST_L2_5________________, ________________ADJUST_R2_5________________, 79 | KC_Q, ________________ADJUST_L3_5________________, ________________ADJUST_R3_5________________, KC_SCLN, 80 | _______, _______, _______, _______, _______, _______ 81 | ) 82 | }; 83 | 84 | -------------------------------------------------------------------------------- /totem/readme.md: -------------------------------------------------------------------------------- 1 | Totem 2 | 3 | https://github.com/GEIGEIGEIST/TOTEM 4 | 5 | 6 | -------------------------------------------------------------------------------- /totem/rules.mk: -------------------------------------------------------------------------------- 1 | OLED_ENABLE = no # OLED display 2 | -------------------------------------------------------------------------------- /user/combos.c: -------------------------------------------------------------------------------- 1 | #include QMK_KEYBOARD_H 2 | #include "g/keymap_combo.h" 3 | #include "print.h" 4 | 5 | // Combo functions 6 | bool get_combo_must_tap(uint16_t index, combo_t *combo) { 7 | switch(index) { 8 | case HCOM_DQUOT: 9 | case VCB_LN: 10 | case VCB_NH: 11 | return false; 12 | } 13 | return true; 14 | } 15 | 16 | bool combo_should_trigger( 17 | uint16_t combo_index, 18 | combo_t *combo, 19 | uint16_t keycode, 20 | keyrecord_t *record 21 | ) { 22 | return true; 23 | } 24 | 25 | uint16_t get_combo_term(uint16_t index, combo_t *combo) { 26 | uint16_t term; 27 | switch (index) { 28 | case WP_CBR_PAIR: 29 | case WF_LCBR: 30 | case FP_RCBR: 31 | term = 45; 32 | break; 33 | 34 | case RAI_ENT: 35 | case RS_LPRN: 36 | case ST_RPRN: 37 | case RT_PRN_PAIR: 38 | 39 | case XC_COPY: 40 | case CD_PASTE: 41 | case LU_QUES_DOT: 42 | 43 | case LUY_SNAKE_SCREAM: 44 | term = 30; 45 | break; 46 | 47 | case VCB_LN: 48 | case VCB_NH: 49 | case XD_CUT: 50 | case ZX_UNDO: 51 | case UY_QUOT: 52 | case EI_TAB: 53 | case NI_EQL: 54 | term = 40; 55 | break; 56 | 57 | case NE_ESC: 58 | term = 50; 59 | break; 60 | 61 | case HCOM_DQUOT: 62 | case SWE_AO: 63 | case SWE_AE: 64 | case SWE_OE: 65 | term = 45; 66 | break; 67 | 68 | case LTGT_ARROW: 69 | case XCD_PASTE_SFT: 70 | case WFP_CBR_PAIR_IN: 71 | case RST_PRN_PAIR_IN: 72 | case NEI_ENT: 73 | 74 | default: 75 | term = 45; 76 | break; 77 | } 78 | return term; 79 | } 80 | 81 | -------------------------------------------------------------------------------- /user/combos.def: -------------------------------------------------------------------------------- 1 | // REMEMBER 2 | // All combos are based on Colemak DH layout, 3 | // even when using Canary or other layouts 4 | 5 | // ========== 6 | // LEFT_HAND 7 | // ========== 8 | 9 | // R3 10 | COMB(WF_LCBR, KC_LCBR, KC_W, KC_F) 11 | COMB(FP_RCBR, KC_RCBR, KC_F, KC_P) 12 | SUBS(WP_CBR_PAIR, "{}", KC_W, KC_P) 13 | COMB(WFP_CBR_PAIR_IN, CURLYS, KC_W, KC_F, KC_P) 14 | COMB(PB_PIPE, KC_PIPE, KC_P, KC_B) 15 | 16 | // R2 17 | COMB(RS_LPRN, KC_LPRN, HOME_R, HOME_S) 18 | COMB(ST_RPRN, KC_RPRN, HOME_S, HOME_T) 19 | SUBS(RT_PRN_PAIR, "()", HOME_R, HOME_T) 20 | COMB(RST_PRN_PAIR_IN, PARENS, HOME_R, HOME_S, HOME_T) 21 | 22 | // R1 23 | COMB(XC_COPY, LGUI(KC_C), KC_X, KC_C) 24 | COMB(CD_PASTE, LGUI(KC_V), KC_C, KC_D) 25 | COMB(XD_CUT, LGUI(KC_X), KC_X, KC_D) 26 | COMB(XCD_PASTE_SFT, LGUI(S(KC_V)), KC_X, KC_C, KC_D) 27 | COMB(ZX_UNDO, LGUI(KC_Z), KC_Z, KC_X) 28 | 29 | // ========== 30 | // RIGHT_HAND 31 | // ========== 32 | 33 | // R3 34 | COMB(JL_AMPR, KC_AMPR, KC_J, KC_L) 35 | SUBS(LU_QUES_DOT, "!=", KC_L, KC_U) 36 | COMB(UY_QUOT, S_QUOTE, KC_U, KC_Y) 37 | COMB(LUY_SNAKE_SCREAM, SNK_SCM, KC_L, KC_U, KC_Y) 38 | 39 | // R2 40 | COMB(NE_ESC, KC_ESC, HOME_N, HOME_E) 41 | COMB(EI_TAB, KC_TAB, HOME_E, HOME_I) 42 | COMB(NI_EQL, KC_EQL, HOME_N, HOME_I) 43 | COMB(NEI_ENT, KC_ENT, HOME_N, HOME_E, HOME_I) 44 | 45 | // R1 46 | COMB(HCOM_DQUOT, SNK_SCM, KC_H, KC_COMM) 47 | SUBS(LTGT_ARROW, "->", KC_COMM, KC_DOT) 48 | 49 | // Vertical 50 | COMB(VCB_LN, S_QUOTE, HOME_N, KC_L) 51 | COMB(VCB_NH, D_QUOTE, HOME_N, KC_H) 52 | COMB(VCB_UI, KC_BSLS, KC_U, HOME_I) 53 | 54 | // ========== 55 | // BOTH 56 | // ========== 57 | COMB(HCB_TN, CAPS, HOME_T, HOME_N) 58 | 59 | // ========== 60 | // SWE 61 | // ========== 62 | COMB(SWE_AO, SE_AO, HOME_A, HOME_O) 63 | COMB(SWE_AE, SE_AE, HOME_A, HOME_E) 64 | COMB(SWE_OE, SE_OE, HOME_O, HOME_E) 65 | // vim:ft=c 66 | -------------------------------------------------------------------------------- /user/config.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define TAPPING_TERM 200 4 | 5 | #define COMBO_TERM 35 6 | #define COMBO_TERM_PER_COMBO 7 | #define COMBO_MUST_TAP_PER_COMBO 8 | #define COMBO_ONLY_FROM_LAYER 0 9 | #define COMBO_SHOULD_TRIGGER 10 | 11 | #define TAPPING_TERM_PER_KEY 12 | #define PERMISSIVE_HOLD_PER_KEY 13 | #define QUICK_TAP_TERM_PER_KEY 14 | #define HOLD_ON_OTHER_KEY_PRESS_PER_KEY 15 | 16 | #define SPLIT_MODS_ENABLE 17 | 18 | #define THUMB_EXTRA 45 19 | #define INDEX_EXTRA 0 20 | #define LONG_EXTRA 0 21 | #define RING_EXTRA 0 22 | #define PINKY_EXTRA 0 23 | 24 | // Should reduce the total firmware footprint according to some blog post 25 | #define DISABLE_LEADER 26 | 27 | // Not supported without flto 28 | #define NO_ACTION_MACRO 29 | #define NO_ACTION_FUNCTION 30 | -------------------------------------------------------------------------------- /user/custom_keycodes.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include QMK_KEYBOARD_H 4 | 5 | enum custom_keycodes { 6 | SW_WIN = SAFE_RANGE, 7 | SW_APP, 8 | S_QUOTE, 9 | D_QUOTE, 10 | PARENS, 11 | BRCKETS, 12 | CURLYS, 13 | 14 | CAPS, 15 | CAMEL, 16 | SNAKE, 17 | SNK_SCM, 18 | 19 | REPEAT, 20 | 21 | SE_AO, 22 | SE_AE, 23 | SE_OE, 24 | NEW_SAFE_RANGE, 25 | }; 26 | 27 | #define LOWER MO(_LOWER) 28 | #define RAISE MO(_RAISE) 29 | #define SYSTEM MO(_SYSTEM) 30 | #define NUM MO(_NUM) 31 | 32 | #define QUIT RGUI(KC_Q) 33 | #define CLOSE RGUI(KC_W) 34 | #define RELOAD RGUI(KC_R) 35 | 36 | #define WIN_LFT C(A(KC_LEFT)) 37 | #define WIN_RGT C(A(KC_RGHT)) 38 | #define WIN_MAX C(A(KC_ENT)) 39 | #define WIN_RES C(A(KC_BSPC)) 40 | #define WIN_CEN C(A(KC_C)) 41 | 42 | #define BACK RGUI(KC_LBRC) 43 | #define FORWARD RGUI(KC_RBRC) 44 | 45 | #define ALFRED RGUI(KC_SPC) 46 | #define ITERM RGUI(KC_ESC) 47 | #define BSP_WRD LALT(KC_BSPC) 48 | 49 | #define LOW_ENT LT(_LOWER, KC_ENT) 50 | #define RAI_ENT LT(_RAISE, KC_ENT) 51 | #define RAI_ESC LT(_RAISE, KC_ESC) 52 | #define SYS_REP LT(_SYSTEM, KC_ENT) 53 | #define RAI_BSP LT(_RAISE, KC_BSPC) 54 | #define NAV_BSP LT(_NAV, KC_BSPC) 55 | #define LOW_SPC LT(_LOWER, KC_SPC) 56 | #define LOW_TAB LT(_LOWER, KC_TAB) 57 | #define RAI_ESC LT(_RAISE, KC_ESC) 58 | #define CTL_BSP LCTL_T(KC_BSPC) 59 | 60 | // Left-hand home row mods 61 | #define HOME_A LCTL_T(KC_A) 62 | #define HOME_R LALT_T(KC_R) 63 | #define HOME_S LGUI_T(KC_S) 64 | #define HOME_T LSFT_T(KC_T) 65 | 66 | // Right-hand home row mods 67 | #define HOME_N RSFT_T(KC_N) 68 | #define HOME_E RGUI_T(KC_E) 69 | #define HOME_I LALT_T(KC_I) 70 | #define HOME_O RCTL_T(KC_O) 71 | 72 | // Left-hand home row mods Canary 73 | #define CNRY_C LCTL_T(KC_C) 74 | 75 | // Right-hand home row mods Canary 76 | #define CNRY_A RCTL_T(KC_A) 77 | 78 | #define DFL_COL DF(_COLEMAK) 79 | #define DFL_GAL DF(_GALLIUM) 80 | #define DFL_GA2 DF(_GALLIUM_V2) 81 | 82 | -------------------------------------------------------------------------------- /user/custom_layers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | enum layers { 4 | _COLEMAK = 0, 5 | _GALLIUM, 6 | _GALLIUM_V2, 7 | _LOWER, 8 | _RAISE, 9 | _NAV, 10 | _SYSTEM, 11 | _ADJUST 12 | }; 13 | 14 | -------------------------------------------------------------------------------- /user/features/casemodes.c: -------------------------------------------------------------------------------- 1 | #include "casemodes.h" 2 | 3 | /* The caps word concept started with me @iaap on splitkb.com discord. 4 | * However it has been implemented and extended by many splitkb.com users: 5 | * - @theol0403 made many improvements to initial implementation 6 | * - @precondition used caps lock rather than shifting 7 | * - @dnaq his own implementation which also used caps lock 8 | * - @sevanteri added underscores on spaces 9 | * - @metheon extended on @sevanteri's work and added specific modes for 10 | * snake_case and SCREAMING_SNAKE_CASE 11 | * - @baffalop came up with the idea for xcase, which he implements in his own 12 | * repo, however this is implemented by @iaap with support also for one-shot-shift. 13 | * - @sevanteri 14 | * - fixed xcase waiting mode to allow more modified keys and keys from other layers. 15 | * - Added @baffalop's separator defaulting on first keypress, with a 16 | * configurable default separator and overrideable function to determine 17 | * if the default should be used. 18 | */ 19 | 20 | #ifndef DEFAULT_XCASE_SEPARATOR 21 | #define DEFAULT_XCASE_SEPARATOR KC_UNDS 22 | #endif 23 | 24 | #define IS_OSM(keycode) (keycode >= QK_ONE_SHOT_MOD && keycode <= QK_ONE_SHOT_MOD_MAX) 25 | 26 | // bool to keep track of the caps word state 27 | static bool caps_word_on = false; 28 | 29 | // enum to keep track of the xcase state 30 | static enum xcase_state xcase_state = XCASE_OFF; 31 | // the keycode of the xcase delimiter 32 | static uint16_t xcase_delimiter; 33 | // the number of keys to the last delimiter 34 | static int8_t distance_to_last_delim = -1; 35 | 36 | // Check whether caps word is on 37 | bool caps_word_enabled(void) { 38 | return caps_word_on; 39 | } 40 | 41 | // Enable caps word 42 | void enable_caps_word(void) { 43 | caps_word_on = true; 44 | #ifndef CAPSWORD_USE_SHIFT 45 | if (!host_keyboard_led_state().caps_lock) { 46 | tap_code(KC_CAPS); 47 | } 48 | #endif 49 | } 50 | 51 | // Disable caps word 52 | void disable_caps_word(void) { 53 | caps_word_on = false; 54 | #ifndef CAPSWORD_USE_SHIFT 55 | if (host_keyboard_led_state().caps_lock) { 56 | tap_code(KC_CAPS); 57 | } 58 | #else 59 | unregister_mods(MOD_LSFT); 60 | #endif 61 | } 62 | 63 | // Toggle caps word 64 | void toggle_caps_word(void) { 65 | if (caps_word_on) { 66 | disable_caps_word(); 67 | } 68 | else { 69 | enable_caps_word(); 70 | } 71 | } 72 | 73 | // Get xcase delimiter, KC_NO if OFF 74 | uint16_t get_xcase_delimiter(void) { 75 | return xcase_state == XCASE_ON ? xcase_delimiter : KC_NO; 76 | } 77 | 78 | // Get xcase state 79 | enum xcase_state get_xcase_state(void) { 80 | return xcase_state; 81 | } 82 | 83 | // Enable xcase and pickup the next keystroke as the delimiter 84 | void enable_xcase(void) { 85 | xcase_state = XCASE_WAIT; 86 | } 87 | 88 | // Enable xcase with the specified delimiter 89 | void enable_xcase_with(uint16_t delimiter) { 90 | xcase_state = XCASE_ON; 91 | xcase_delimiter = delimiter; 92 | distance_to_last_delim = -1; 93 | } 94 | 95 | // Disable xcase 96 | void disable_xcase(void) { 97 | xcase_state = XCASE_OFF; 98 | } 99 | 100 | // Place the current xcase delimiter 101 | static void place_delimiter(void) { 102 | if (IS_OSM(xcase_delimiter)) { 103 | // apparently set_oneshot_mods() is dumb and doesn't deal with handedness for you 104 | uint8_t mods = xcase_delimiter & 0x10 ? (xcase_delimiter & 0x0F) << 4 : xcase_delimiter & 0xFF; 105 | set_oneshot_mods(mods); 106 | } else { 107 | tap_code16(xcase_delimiter); 108 | } 109 | } 110 | 111 | // Removes a delimiter, used for double tap space exit 112 | static void remove_delimiter(void) { 113 | if (IS_OSM(xcase_delimiter)) { 114 | clear_oneshot_mods(); 115 | } else { 116 | tap_code(KC_BSPC); 117 | } 118 | } 119 | 120 | // overrideable function to determine whether the case mode should stop 121 | __attribute__ ((weak)) 122 | bool terminate_case_modes(uint16_t keycode, const keyrecord_t *record) { 123 | switch (keycode) { 124 | // Keycodes to ignore (don't disable caps word) 125 | case KC_A ... KC_Z: 126 | case KC_1 ... KC_0: 127 | case KC_MINS: 128 | case KC_UNDS: 129 | case KC_BSPC: 130 | // If mod chording disable the mods 131 | if (record->event.pressed && (get_mods() != 0)) { 132 | return true; 133 | } 134 | break; 135 | default: 136 | if (record->event.pressed) { 137 | return true; 138 | } 139 | break; 140 | } 141 | return false; 142 | } 143 | 144 | /* overrideable function to determine whether to use the default separator on 145 | * first keypress when waiting for the separator. */ 146 | __attribute__ ((weak)) 147 | bool use_default_xcase_separator(uint16_t keycode, const keyrecord_t *record) { 148 | // for example: 149 | /* switch (keycode) { */ 150 | /* case KC_A ... KC_Z: */ 151 | /* case KC_1 ... KC_0: */ 152 | /* return true; */ 153 | /* } */ 154 | return false; 155 | } 156 | 157 | bool process_case_modes(uint16_t keycode, const keyrecord_t *record) { 158 | if (caps_word_on || xcase_state) { 159 | if ((QK_MOD_TAP <= keycode && keycode <= QK_MOD_TAP_MAX) 160 | || (QK_LAYER_TAP <= keycode && keycode <= QK_LAYER_TAP_MAX)) { 161 | // Earlier return if this has not been considered tapped yet 162 | if (record->tap.count == 0) 163 | return true; 164 | keycode = keycode & 0xFF; 165 | } 166 | 167 | if (keycode >= QK_LAYER_TAP && keycode <= QK_ONE_SHOT_LAYER_MAX) { 168 | // let special keys and normal modifiers go through 169 | return true; 170 | } 171 | 172 | if (xcase_state == XCASE_WAIT) { 173 | // grab the next input to be the delimiter 174 | if (use_default_xcase_separator(keycode, record)) { 175 | enable_xcase_with(DEFAULT_XCASE_SEPARATOR); 176 | } 177 | else if (record->event.pressed) { 178 | // factor in mods 179 | if (get_mods() & MOD_MASK_SHIFT) { 180 | keycode = LSFT(keycode); 181 | } 182 | else if (get_mods() & MOD_BIT(KC_RALT)) { 183 | keycode = RALT(keycode); 184 | } 185 | enable_xcase_with(keycode); 186 | return false; 187 | } 188 | else { 189 | if (IS_OSM(keycode)) { 190 | // this catches the OSM release if no other key was pressed 191 | set_oneshot_mods(0); 192 | enable_xcase_with(keycode); 193 | return false; 194 | } 195 | // let other special keys go through 196 | return true; 197 | } 198 | } 199 | 200 | if (record->event.pressed) { 201 | // handle xcase mode 202 | if (xcase_state == XCASE_ON) { 203 | // place the delimiter if space is tapped 204 | if (keycode == KC_SPACE) { 205 | if (distance_to_last_delim != 0) { 206 | place_delimiter(); 207 | distance_to_last_delim = 0; 208 | return false; 209 | } 210 | // remove the delimiter and disable modes 211 | else { 212 | remove_delimiter(); 213 | disable_xcase(); 214 | disable_caps_word(); 215 | return true; 216 | } 217 | } 218 | // decrement distance to delimiter on back space 219 | else if (keycode == KC_BSPC) { 220 | --distance_to_last_delim; 221 | } 222 | // don't increment distance to last delim if negative 223 | else if (distance_to_last_delim >= 0) { 224 | // puts back a one shot delimiter if you we're back to the delimiter pos 225 | if (distance_to_last_delim == 0 && (IS_OSM(xcase_delimiter))) { 226 | place_delimiter(); 227 | } 228 | ++distance_to_last_delim; 229 | } 230 | 231 | } // end XCASE_ON 232 | 233 | // check if the case modes have been terminated 234 | if (terminate_case_modes(keycode, record)) { 235 | disable_caps_word(); 236 | disable_xcase(); 237 | } 238 | 239 | #ifdef CAPSWORD_USE_SHIFT 240 | else if (caps_word_on && keycode >= KC_A && keycode <= KC_Z){ 241 | tap_code16(LSFT(keycode)); 242 | return false; 243 | } 244 | #endif 245 | 246 | } // end if event.pressed 247 | 248 | return true; 249 | } 250 | return true; 251 | } 252 | -------------------------------------------------------------------------------- /user/features/casemodes.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include QMK_KEYBOARD_H 4 | 5 | // Check whether caps word is on 6 | bool caps_word_enabled(void); 7 | // Enable caps word 8 | void enable_caps_word(void); 9 | // Disable caps word 10 | void disable_caps_word(void); 11 | // Toggle caps word 12 | void toggle_caps_word(void); 13 | 14 | // enum for the xcase states 15 | enum xcase_state { 16 | XCASE_OFF = 0, // xcase is off 17 | XCASE_ON, // xcase is actively on 18 | XCASE_WAIT, // xcase is waiting for the delimiter input 19 | }; 20 | 21 | // Get current delimiter, defaults to KC_NO when off 22 | uint16_t get_xcase_delimiter(void); 23 | // Get xcase state 24 | enum xcase_state get_xcase_state(void); 25 | // Enable xcase and pickup the next keystroke as the delimiter 26 | void enable_xcase(void); 27 | // Enable xcase with the specified delimiter 28 | void enable_xcase_with(uint16_t delimiter); 29 | // Disable xcase 30 | void disable_xcase(void); 31 | 32 | // Function to be put in process user 33 | bool process_case_modes(uint16_t keycode, const keyrecord_t *record); 34 | -------------------------------------------------------------------------------- /user/features/oneshot.c: -------------------------------------------------------------------------------- 1 | #include "oneshot.h" 2 | 3 | void update_oneshot( 4 | oneshot_state *state, 5 | uint16_t mod, 6 | uint16_t trigger, 7 | uint16_t keycode, 8 | keyrecord_t *record 9 | ) { 10 | if (keycode == trigger) { 11 | if (record->event.pressed) { 12 | // Trigger keydown 13 | if (*state == os_up_unqueued) { 14 | register_code(mod); 15 | } 16 | *state = os_down_unused; 17 | } else { 18 | // Trigger keyup 19 | switch (*state) { 20 | case os_down_unused: 21 | // If we didn't use the mod while trigger was held, queue it. 22 | *state = os_up_queued; 23 | break; 24 | case os_down_used: 25 | // If we did use the mod while trigger was held, unregister it. 26 | *state = os_up_unqueued; 27 | unregister_code(mod); 28 | break; 29 | default: 30 | break; 31 | } 32 | } 33 | } else { 34 | if (record->event.pressed) { 35 | if (is_oneshot_cancel_key(keycode) && *state != os_up_unqueued) { 36 | // Cancel oneshot on designated cancel keydown. 37 | *state = os_up_unqueued; 38 | unregister_code(mod); 39 | } 40 | } else { 41 | if (!is_oneshot_ignored_key(keycode)) { 42 | // On non-ignored keyup, consider the oneshot used. 43 | switch (*state) { 44 | case os_down_unused: 45 | *state = os_down_used; 46 | break; 47 | case os_up_queued: 48 | *state = os_up_unqueued; 49 | unregister_code(mod); 50 | break; 51 | default: 52 | break; 53 | } 54 | } 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /user/features/oneshot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include QMK_KEYBOARD_H 4 | 5 | // Represents the four states a oneshot key can be in 6 | typedef enum { 7 | os_up_unqueued, 8 | os_up_queued, 9 | os_down_unused, 10 | os_down_used, 11 | } oneshot_state; 12 | 13 | // Custom oneshot mod implementation that doesn't rely on timers. If a mod is 14 | // used while it is held it will be unregistered on keyup as normal, otherwise 15 | // it will be queued and only released after the next non-mod keyup. 16 | void update_oneshot( 17 | oneshot_state *state, 18 | uint16_t mod, 19 | uint16_t trigger, 20 | uint16_t keycode, 21 | keyrecord_t *record 22 | ); 23 | 24 | // To be implemented by the consumer. Defines keys to cancel oneshot mods. 25 | bool is_oneshot_cancel_key(uint16_t keycode); 26 | 27 | // To be implemented by the consumer. Defines keys to ignore when determining 28 | // whether a oneshot mod has been used. Setting this to modifiers and layer 29 | // change keys allows stacking multiple oneshot modifiers, and carrying them 30 | // between layers. 31 | bool is_oneshot_ignored_key(uint16_t keycode); 32 | 33 | -------------------------------------------------------------------------------- /user/features/swapper.c: -------------------------------------------------------------------------------- 1 | #include "swapper.h" 2 | 3 | void update_swapper( 4 | bool *active, 5 | uint16_t cmdish, 6 | uint16_t tabish, 7 | uint16_t trigger, 8 | uint16_t keycode, 9 | keyrecord_t *record 10 | ) { 11 | if (keycode == trigger) { 12 | if (record->event.pressed) { 13 | if (!*active) { 14 | *active = true; 15 | register_code(cmdish); 16 | } 17 | register_code(tabish); 18 | } else { 19 | unregister_code(tabish); 20 | // don't unregister cmdish until some other key is hit or released 21 | } 22 | } else if (*active) { 23 | unregister_code(cmdish); 24 | *active = false; 25 | } 26 | } 27 | 28 | -------------------------------------------------------------------------------- /user/features/swapper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include QMK_KEYBOARD_H 4 | 5 | void update_swapper( 6 | bool *active, 7 | uint16_t cmdish, 8 | uint16_t tabish, 9 | uint16_t trigger, 10 | uint16_t keycode, 11 | keyrecord_t *record 12 | ); 13 | -------------------------------------------------------------------------------- /user/oled.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "oled.h" 3 | #include "custom_keycodes.h" 4 | #include "custom_layers.h" 5 | #include "features/casemodes.h" 6 | 7 | // Should perhaps check if these are already defined 8 | #define BLINK_TIMEOUT 10000 9 | #define BLINK_INTERVAL 500 10 | 11 | // ... same for this one! 12 | #define KEYLOG_LEN 6 13 | 14 | #define MOD_ICON_WIDTH 4 15 | #define MOD_ICON_HEIGHT 3 16 | 17 | static char keylog_str[KEYLOG_LEN] = { ' ', ' ', ' ', ' ', ' ', 0}; 18 | static uint16_t log_timer = 0; 19 | static bool blink_timeout = false; 20 | static char combo_str[6] = { ' ', ' ', ' ', ' ', ' ', 0}; 21 | static const char code_to_name[60] = { 22 | ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 23 | 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 24 | 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 25 | '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 26 | 'R', 'E', 'B', 'T', '_', '-', '=', '[', ']', '\\', 27 | '#', ';', '\'', '`', ',', '.', '/', ' ', ' ', ' ' 28 | }; 29 | 30 | void render_empty_line(void) { 31 | oled_write_ln_P(PSTR(""), false); 32 | } 33 | 34 | void render_case_mode_status(uint16_t delimiter, bool caps) { 35 | bool brief = true; 36 | #ifdef OLED_DISPLAY_128X64 37 | brief = false; 38 | oled_write_P(PSTR(" XCase: "), false); 39 | #else 40 | oled_write_P(PSTR("Case:"), false); 41 | #endif 42 | if (delimiter == KC_UNDS) { 43 | if (caps) { 44 | oled_write_ln_P(brief ? PSTR("SNAKE") : PSTR("SNAKE_SCREM"), false); 45 | } else { 46 | oled_write_ln_P(brief ? PSTR("snake") : PSTR("snake_case"), false); 47 | } 48 | } else if (delimiter == OSM(MOD_LSFT)) { 49 | oled_write_ln_P(brief ? PSTR("caMel") : PSTR("camelCase"), false); 50 | } else if (caps) { 51 | oled_write_ln_P(brief ? PSTR("UPPER") : PSTR("UPPERCASE"), false); 52 | } else { 53 | oled_write_ln_P(brief ? PSTR("lower") : PSTR("lowercase"), false); 54 | } 55 | } 56 | 57 | void render_keylogger_status(void) { 58 | #ifdef OLED_DISPLAY_128X64 59 | oled_write_P(PSTR(" Hist: "), false); 60 | #else 61 | oled_write_ln_P(PSTR("Hist."), false); 62 | #endif 63 | oled_write(keylog_str, false); 64 | } 65 | 66 | void render_default_layer_state(void) { 67 | if (timer_elapsed(log_timer) > BLINK_TIMEOUT) { 68 | blink_timeout = true; 69 | } 70 | 71 | bool blink = (timer_read() % 1000) < BLINK_INTERVAL || blink_timeout; 72 | 73 | oled_write_P(PSTR("$"), false); 74 | switch (get_highest_layer(layer_state)) { 75 | case _COLEMAK: 76 | oled_write_P(blink ? PSTR("_\n") : PSTR("\n"), false); 77 | return; 78 | case _GALLIUM: 79 | oled_write_P(PSTR("GAL"), false); 80 | break; 81 | case _GALLIUM_V2: 82 | oled_write_P(PSTR("GA2"), false); 83 | break; 84 | case _LOWER: 85 | oled_write_P(PSTR("LOW"), false); 86 | break; 87 | case _RAISE: 88 | oled_write_P(PSTR("RAI"), false); 89 | break; 90 | case _SYSTEM: 91 | oled_write_P(PSTR("SYS"), false); 92 | break; 93 | case _ADJUST: 94 | oled_write_P(PSTR("ADJ"), false); 95 | break; 96 | case _NAV: 97 | oled_write_P(PSTR("NAV"), false); 98 | break; 99 | default: 100 | oled_write_P(PSTR("-?-"), false); 101 | break; 102 | } 103 | oled_write_P(blink ? PSTR("_") : PSTR(" "), false); 104 | } 105 | 106 | void render_mod_icon(uint8_t loc, bool enabled, const char *icon, bool invert) { 107 | uint8_t col = 1 + loc * (MOD_ICON_WIDTH + 1); 108 | for (uint8_t i=0; i < MOD_ICON_HEIGHT; ++i) { 109 | oled_set_cursor(col, i); 110 | for (uint8_t j=0; j < MOD_ICON_WIDTH; ++j) { 111 | oled_write_char(enabled ? icon[i*MOD_ICON_WIDTH+j] : ' ', invert); 112 | } 113 | } 114 | } 115 | 116 | void render_mod_shift(uint8_t order, uint8_t mods) { 117 | static const char shift_icon[] = { 118 | 0x88, 0x89, 0x8A, 0x8B, 119 | 0xA8, 0xA9, 0xAA, 0xAB, 120 | 0xC8, 0xC9, 0xCA, 0xCB 121 | }; 122 | render_mod_icon(order, mods & MOD_MASK_SHIFT, shift_icon, false); 123 | } 124 | 125 | void render_mod_gui(uint8_t order, uint8_t mods) { 126 | static const char gui_icon[] = { 127 | 0x80, 0x81, 0x82, 0x83, 128 | 0xA0, 0xA1, 0xA2, 0xA3, 129 | 0xC0, 0xC1, 0xC2, 0xC3 130 | }; 131 | render_mod_icon(order, mods & MOD_MASK_GUI, gui_icon, false); 132 | } 133 | 134 | void render_mod_alt(uint8_t order, uint8_t mods) { 135 | static const char alt_icon[] = { 136 | 0x84, 0x85, 0x86, 0x87, 137 | 0xA4, 0xA5, 0xA6, 0xA7, 138 | 0xC4, 0xC5, 0xC6, 0xC7 139 | }; 140 | render_mod_icon(order, mods & MOD_MASK_ALT, alt_icon, false); 141 | } 142 | 143 | void render_mod_ctrl(uint8_t order, uint8_t mods) { 144 | static const char ctrl_icon[] = { 145 | 0x8C, 0x8D, ' ', ' ', 146 | 0xAC, 0xAD, ' ', ' ', 147 | 0xCC, 0xCD, ' ', ' ' 148 | }; 149 | render_mod_icon(order, mods & MOD_MASK_CTRL, ctrl_icon, false); 150 | } 151 | 152 | void render_mod_status_short(void) { 153 | uint8_t modifiers = get_mods(); 154 | #ifdef OLED_DISPLAY_128X64 155 | oled_write_P(PSTR(" Mods: "), false); 156 | #else 157 | oled_write_P(PSTR("Mods:"), false); 158 | #endif 159 | oled_write_P(PSTR("C"), (modifiers & MOD_MASK_CTRL)); 160 | oled_write_P(PSTR("A"), (modifiers & MOD_MASK_ALT)); 161 | oled_write_P(PSTR("G"), (modifiers & MOD_MASK_GUI)); 162 | oled_write_P(PSTR("S"), (modifiers & MOD_MASK_SHIFT)); 163 | oled_write_ln_P(PSTR(""), false); 164 | } 165 | 166 | void render_modifier_status(void) { 167 | uint8_t modifiers = get_mods(); 168 | uint8_t order = 0; // dynamic to making swap order less of a hassle 169 | render_mod_shift(order++, modifiers); 170 | render_mod_gui(order++, modifiers); 171 | render_mod_alt(order++, modifiers); 172 | render_mod_ctrl(order++, modifiers); 173 | } 174 | 175 | void render_combo_status(void) { 176 | #ifdef OLED_DISPLAY_128X64 177 | oled_write_P(PSTR(" Combo: "), false); 178 | #else 179 | oled_write_ln_P(PSTR("Combo"), false); 180 | #endif 181 | oled_write_ln(combo_str, false); 182 | } 183 | 184 | void append_keylog(uint16_t keycode) { 185 | if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) { 186 | keycode = keycode & 0xFF; 187 | } 188 | 189 | for (uint8_t i = KEYLOG_LEN - 1; i > 0; i--) { 190 | keylog_str[i] = keylog_str[i - 1]; 191 | } 192 | if (keycode < 60) { 193 | keylog_str[0] = code_to_name[keycode]; 194 | } 195 | keylog_str[KEYLOG_LEN - 1] = 0; 196 | 197 | log_timer = timer_read(); 198 | blink_timeout = false; 199 | } 200 | 201 | void update_combo_status(uint16_t combo_term, char id) { 202 | sprintf(combo_str, "%5u", combo_term); 203 | combo_str[0] = id; 204 | } 205 | 206 | -------------------------------------------------------------------------------- /user/oled.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include QMK_KEYBOARD_H 4 | #include "keycodes.h" 5 | 6 | void render_empty_line(void); 7 | 8 | void render_case_mode_status(uint16_t delimiter, bool caps); 9 | 10 | void render_keylogger_status(void); 11 | 12 | void render_default_layer_state(void); 13 | 14 | void render_mod_icon(uint8_t loc, bool enabled, const char *icon, bool invert); 15 | 16 | void render_mod_shift(uint8_t order, uint8_t mods); 17 | 18 | void render_mod_gui(uint8_t order, uint8_t mods); 19 | 20 | void render_mod_alt(uint8_t order, uint8_t mods); 21 | 22 | void render_mod_ctrl(uint8_t order, uint8_t mods); 23 | 24 | void render_mod_status_short(void); 25 | 26 | void render_modifier_status(void); 27 | 28 | void render_combo_status(void); 29 | 30 | // Append a keycode to the key log 31 | void append_keylog(uint16_t keycode); 32 | 33 | // Update the combo status 34 | void update_combo_status(uint16_t combo_term, char id); 35 | -------------------------------------------------------------------------------- /user/pket.c: -------------------------------------------------------------------------------- 1 | #include "pket.h" 2 | #include "print.h" 3 | #include "features/swapper.h" 4 | 5 | uint8_t mod_state; 6 | 7 | bool sw_win_active = false; 8 | bool sw_app_active = false; 9 | 10 | layer_state_t layer_state_set_user(layer_state_t state) { 11 | return update_tri_layer_state(state, _SYSTEM, _NAV, _ADJUST); 12 | } 13 | 14 | // Xcase functions 15 | bool terminate_case_modes(uint16_t keycode, const keyrecord_t *record) { 16 | switch (keycode) { 17 | // Keycodes to ignore (don't disable caps word) 18 | case KC_MINS: 19 | case KC_UNDS: 20 | case KC_BSPC: 21 | case CAPS: 22 | case SNK_SCM: 23 | case SNAKE: 24 | case KC_A ... KC_Z: 25 | case KC_1 ... KC_0: 26 | // If mod chording disable the mods 27 | if (record->event.pressed && (get_mods() != 0)) { 28 | return true; 29 | } 30 | break; 31 | default: 32 | if (record->event.pressed) { 33 | return true; 34 | } 35 | break; 36 | } 37 | return false; 38 | } 39 | 40 | // Tapping term 41 | uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { 42 | switch (keycode) { 43 | case HOME_R: 44 | case HOME_I: 45 | return TAPPING_TERM + RING_EXTRA; 46 | case CNRY_C: 47 | case CNRY_A: 48 | case HOME_A: 49 | case HOME_O: 50 | return TAPPING_TERM + PINKY_EXTRA; 51 | case HOME_S: 52 | case HOME_E: 53 | return TAPPING_TERM + LONG_EXTRA; 54 | case HOME_T: 55 | case HOME_N: 56 | return TAPPING_TERM + INDEX_EXTRA; 57 | case LOW_SPC: 58 | return TAPPING_TERM + THUMB_EXTRA; 59 | default: 60 | return TAPPING_TERM; 61 | } 62 | } 63 | 64 | bool get_permissive_hold(uint16_t keycode, keyrecord_t *record) { 65 | switch (keycode) { 66 | case LOW_SPC: 67 | case RAI_ENT: 68 | case RAI_BSP: 69 | case NAV_BSP: 70 | // Immediately select the hold action when another key is tapped. 71 | return true; 72 | default: 73 | // Do not select the hold action when another key is tapped. 74 | return false; 75 | } 76 | } 77 | 78 | uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { 79 | switch (keycode) { 80 | case HOME_A: 81 | case HOME_R: 82 | case HOME_S: 83 | case HOME_T: 84 | case HOME_N: 85 | case HOME_E: 86 | case HOME_I: 87 | case HOME_O: 88 | case CNRY_C: 89 | case CNRY_A: 90 | case RAI_ENT: 91 | case LOW_SPC: 92 | return 0; 93 | default: 94 | return TAPPING_TERM; 95 | } 96 | } 97 | 98 | bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { 99 | switch (keycode) { 100 | case QK_MOD_TAP ... QK_MOD_TAP_MAX: 101 | switch (keycode) { 102 | case HOME_A: 103 | case HOME_R: 104 | case HOME_S: 105 | case HOME_T: 106 | case HOME_N: 107 | case HOME_E: 108 | case HOME_I: 109 | case HOME_O: 110 | case CNRY_C: 111 | case CNRY_A: 112 | // Do not force the mod-tap key press to be handled as a modifier 113 | // if any other key was pressed while the mod-tap key is held down. 114 | return false; 115 | default: 116 | // Force the mod-tap key press to be handled as a modifier if any 117 | // other key was pressed while the mod-tap key is held down. 118 | return true; 119 | } 120 | default: 121 | // Do not select the hold action when another key is pressed. 122 | return false; 123 | } 124 | } 125 | 126 | bool process_record_user(uint16_t keycode, keyrecord_t *record) { 127 | #ifdef CONSOLE_ENABLE 128 | uprintf("key:0x%04X, row:%u, col:%u, layer:%u, down:%s, mods:0x%02X, osm:0x%02X, count:%u\n", 129 | keycode, 130 | record->event.key.row, 131 | record->event.key.col, 132 | get_highest_layer(layer_state), 133 | record->event.pressed ? "true" : "false", 134 | get_mods(), 135 | get_oneshot_mods(), 136 | record->tap.count 137 | ); 138 | #endif 139 | 140 | update_swapper(&sw_win_active, KC_LGUI, KC_TAB, SW_WIN, keycode, record); 141 | update_swapper(&sw_app_active, KC_LGUI, KC_GRV, SW_APP, keycode, record); 142 | 143 | if (!process_case_modes(keycode, record)) { 144 | return false; 145 | } 146 | 147 | static uint16_t single_quote_timer; 148 | static uint16_t double_quote_timer; 149 | 150 | if (record->event.pressed) { 151 | append_keylog(keycode); 152 | } 153 | 154 | mod_state = get_mods(); 155 | 156 | switch (keycode) { 157 | // TODO should perhaps add some fixes for GALLIUM rolls as well 158 | // TODO evalutate if the current home row fixes are an issue for GALLIUM 159 | case HOME_T: 160 | if (record->event.pressed && record->tap.count > 0) { 161 | if (get_mods() & MOD_BIT(KC_LGUI)) { 162 | unregister_mods(MOD_BIT(KC_LGUI)); 163 | tap_code(KC_S); 164 | tap_code(KC_T); 165 | add_mods(MOD_BIT(KC_LGUI)); 166 | return false; 167 | } 168 | } 169 | case HOME_R: 170 | if (record->event.pressed && record->tap.count > 0) { 171 | if (get_mods() & MOD_BIT(KC_LCTL)) { 172 | unregister_mods(MOD_BIT(KC_LCTL)); 173 | tap_code(KC_A); 174 | tap_code(KC_R); 175 | add_mods(MOD_BIT(KC_LCTL)); 176 | return false; 177 | } 178 | } 179 | return true; 180 | 181 | case HOME_E: 182 | if (record->event.pressed && record->tap.count > 0) { 183 | if (get_mods() & MOD_BIT(KC_RSFT)) { 184 | unregister_mods(MOD_BIT(KC_RSFT)); 185 | tap_code(KC_N); 186 | tap_code(KC_E); 187 | add_mods(MOD_BIT(KC_RSFT)); 188 | return false; 189 | } 190 | } 191 | return true; 192 | 193 | case HOME_N: 194 | if (record->event.pressed && record->tap.count > 0) { 195 | if (get_mods() & MOD_BIT(KC_RGUI)) { 196 | unregister_mods(MOD_BIT(KC_RGUI)); 197 | tap_code(KC_E); 198 | tap_code(KC_N); 199 | add_mods(MOD_BIT(KC_RGUI)); 200 | return false; 201 | } 202 | } 203 | return true; 204 | 205 | case KC_BSPC: { 206 | // Initialize a boolean variable that keeps track 207 | // of the delete key status: registered or not? 208 | // 209 | static bool delkey_registered; 210 | if (record->event.pressed) { 211 | // Detect the activation of either shift keys 212 | if (mod_state & MOD_MASK_SHIFT) { 213 | // First temporarily canceling both shifts so that 214 | // shift isn't applied to the KC_DEL keycode 215 | del_mods(MOD_MASK_SHIFT); 216 | register_code(KC_DEL); 217 | // Update the boolean variable to reflect the status of KC_DEL 218 | delkey_registered = true; 219 | // Reapplying modifier state so that the held shift key(s) 220 | // still work even after having tapped the Backspace/Delete key. 221 | set_mods(mod_state); 222 | return false; 223 | } 224 | } else { // on release of KC_BSPC 225 | // In case KC_DEL is still being sent even after the release of KC_BSPC 226 | if (delkey_registered) { 227 | unregister_code(KC_DEL); 228 | delkey_registered = false; 229 | return false; 230 | } 231 | } 232 | // Let QMK process the KC_BSPC keycode as usual outside of shift 233 | return true; 234 | } 235 | // TODO could I merge these like the swe chars? 236 | case S_QUOTE: 237 | if (record->event.pressed) { 238 | single_quote_timer = timer_read(); 239 | tap_code16(KC_QUOT); 240 | } else if (timer_elapsed(single_quote_timer) > TAPPING_TERM) { 241 | tap_code16(KC_QUOT); 242 | tap_code16(KC_LEFT); 243 | } 244 | return false; 245 | case D_QUOTE: 246 | if (record->event.pressed) { 247 | double_quote_timer = timer_read(); 248 | tap_code16(KC_DQUO); 249 | } else if (timer_elapsed(double_quote_timer) > TAPPING_TERM) { 250 | tap_code16(KC_DQUO); 251 | tap_code16(KC_LEFT); 252 | } 253 | return false; 254 | // TODO could I merge this three like swe chars? 255 | case CURLYS: 256 | if (record->event.pressed) { 257 | SEND_STRING("{ }"SS_TAP(X_LEFT)SS_TAP(X_LEFT)); 258 | } 259 | return false; 260 | case BRCKETS: 261 | if (record->event.pressed) { 262 | SEND_STRING("[]"SS_TAP(X_LEFT)); 263 | } 264 | return false; 265 | case PARENS: 266 | if (record->event.pressed) { 267 | SEND_STRING("()"SS_TAP(X_LEFT)); 268 | } 269 | return false; 270 | case SE_AO: 271 | if (record->event.pressed) { 272 | tap_code16(A(KC_A)); 273 | } 274 | return false; 275 | case SE_AE: 276 | case SE_OE: 277 | if (record->event.pressed) { 278 | uint8_t mod_state = get_mods(); 279 | if (mod_state & MOD_MASK_SHIFT) { 280 | del_mods(MOD_MASK_SHIFT); 281 | } 282 | tap_code16(A(KC_U)); 283 | set_mods(mod_state); 284 | tap_code16(keycode == SE_AE ? KC_A : KC_O); 285 | } 286 | return false; 287 | case CAPS: 288 | if (record->event.pressed) { 289 | toggle_caps_word(); 290 | } 291 | return false; 292 | // TODO these two are never used afaik 293 | case SNAKE: 294 | case CAMEL: 295 | if (record->event.pressed) { 296 | if (get_xcase_delimiter() != KC_NO) { 297 | disable_xcase(); 298 | } else { 299 | enable_xcase_with(keycode == SNAKE ? KC_UNDS : OSM(MOD_LSFT)); 300 | } 301 | } 302 | return false; 303 | case SNK_SCM: 304 | if (record->event.pressed) { 305 | if (get_xcase_delimiter() != KC_NO) { 306 | disable_xcase(); 307 | disable_caps_word(); 308 | } else { 309 | enable_caps_word(); 310 | enable_xcase_with(KC_UNDS); 311 | } 312 | } 313 | return false; 314 | } 315 | return true; 316 | } 317 | 318 | #ifdef OLED_ENABLE 319 | 320 | void suspend_power_down_user(void) { 321 | oled_off(); 322 | } 323 | 324 | #endif 325 | -------------------------------------------------------------------------------- /user/pket.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include QMK_KEYBOARD_H 3 | 4 | #include "custom_keycodes.h" 5 | #include "custom_layers.h" 6 | #include "wrappers.h" 7 | 8 | #include "features/swapper.h" 9 | #include "features/casemodes.h" 10 | #include "oled.h" 11 | 12 | -------------------------------------------------------------------------------- /user/process_records.c: -------------------------------------------------------------------------------- 1 | #include "pket.h" 2 | // #include "g/keymap_combo.h" 3 | #include "features/swapper.h" 4 | 5 | //uint8_t mod_state; 6 | 7 | //bool sw_win_active = false; 8 | //bool sw_app_active = false; 9 | 10 | //bool process_record_user(uint16_t keycode, keyrecord_t *record) { 11 | // #ifdef CONSOLE_ENABLE 12 | // uprintf("key:0x%04X, row:%u, col:%u, layer:%u, down:%s, mods:0x%02X, osm:0x%02X, count:%u\n", 13 | // keycode, 14 | // record->event.key.row, 15 | // record->event.key.col, 16 | // get_highest_layer(layer_state), 17 | // record->event.pressed ? "true" : "false", 18 | // get_mods(), 19 | // get_oneshot_mods(), 20 | // record->tap.count 21 | // ); 22 | // #endif 23 | 24 | // update_swapper(&sw_win_active, KC_LGUI, KC_TAB, SW_WIN, keycode, record); 25 | // update_swapper(&sw_app_active, KC_LGUI, KC_GRV, SW_APP, keycode, record); 26 | 27 | // if (!process_case_modes(keycode, record)) { 28 | // return false; 29 | // } 30 | 31 | // static uint16_t single_quote_timer; 32 | // static uint16_t double_quote_timer; 33 | 34 | // if (record->event.pressed) { 35 | // append_keylog(keycode); 36 | // } 37 | 38 | // mod_state = get_mods(); 39 | 40 | // switch (keycode) { 41 | // case HOME_T: 42 | // if (record->event.pressed && record->tap.count > 0) { 43 | // if (get_mods() & MOD_BIT(KC_LGUI)) { 44 | // unregister_mods(MOD_BIT(KC_LGUI)); 45 | // tap_code(KC_S); 46 | // tap_code(KC_T); 47 | // add_mods(MOD_BIT(KC_LGUI)); 48 | // return false; 49 | // } 50 | // if (layer_state_is(_CANARY)) { 51 | // // TODO evalutate if a version of this is needed for Canary 52 | // if (get_mods() & MOD_BIT(KC_LCTL)) { 53 | // unregister_mods(MOD_BIT(KC_LCTL)); 54 | // tap_code(KC_A); 55 | // tap_code(KC_T); 56 | // add_mods(MOD_BIT(KC_LCTL)); 57 | // return false; 58 | // } 59 | // } 60 | // } 61 | // case HOME_R: 62 | // if (record->event.pressed && record->tap.count > 0) { 63 | // if (get_mods() & MOD_BIT(KC_LCTL)) { 64 | // unregister_mods(MOD_BIT(KC_LCTL)); 65 | // tap_code(KC_A); 66 | // tap_code(KC_R); 67 | // add_mods(MOD_BIT(KC_LCTL)); 68 | // return false; 69 | // } 70 | // } 71 | // return true; 72 | 73 | // case HOME_E: 74 | // if (record->event.pressed && record->tap.count > 0) { 75 | // if (get_mods() & MOD_BIT(KC_RSFT)) { 76 | // unregister_mods(MOD_BIT(KC_RSFT)); 77 | // tap_code(KC_N); 78 | // tap_code(KC_E); 79 | // add_mods(MOD_BIT(KC_RSFT)); 80 | // return false; 81 | // } 82 | // } 83 | // return true; 84 | 85 | // case HOME_N: 86 | // if (record->event.pressed && record->tap.count > 0) { 87 | // if (get_mods() & MOD_BIT(KC_RGUI)) { 88 | // unregister_mods(MOD_BIT(KC_RGUI)); 89 | // tap_code(KC_E); 90 | // tap_code(KC_N); 91 | // add_mods(MOD_BIT(KC_RGUI)); 92 | // return false; 93 | // } 94 | // if (layer_state_is(_CANARY)) { 95 | // // TODO evalutate if a version of this is needed for Canary 96 | // if (get_mods() & MOD_BIT(KC_RCTL)) { 97 | // unregister_mods(MOD_BIT(KC_RCTL)); 98 | // tap_code(KC_O); 99 | // tap_code(KC_N); 100 | // add_mods(MOD_BIT(KC_RCTL)); 101 | // return false; 102 | // } 103 | // } 104 | // } 105 | // return true; 106 | 107 | // case KC_BSPC: { 108 | // // Initialize a boolean variable that keeps track 109 | // // of the delete key status: registered or not? 110 | // // 111 | // static bool delkey_registered; 112 | // if (record->event.pressed) { 113 | // // Detect the activation of either shift keys 114 | // if (mod_state & MOD_MASK_SHIFT) { 115 | // // First temporarily canceling both shifts so that 116 | // // shift isn't applied to the KC_DEL keycode 117 | // del_mods(MOD_MASK_SHIFT); 118 | // register_code(KC_DEL); 119 | // // Update the boolean variable to reflect the status of KC_DEL 120 | // delkey_registered = true; 121 | // // Reapplying modifier state so that the held shift key(s) 122 | // // still work even after having tapped the Backspace/Delete key. 123 | // set_mods(mod_state); 124 | // return false; 125 | // } 126 | // } else { // on release of KC_BSPC 127 | // // In case KC_DEL is still being sent even after the release of KC_BSPC 128 | // if (delkey_registered) { 129 | // unregister_code(KC_DEL); 130 | // delkey_registered = false; 131 | // return false; 132 | // } 133 | // } 134 | // // Let QMK process the KC_BSPC keycode as usual outside of shift 135 | // return true; 136 | // } 137 | // // TODO could I merge these like the swe chars? 138 | // case S_QUOTE: 139 | // if (record->event.pressed) { 140 | // single_quote_timer = timer_read(); 141 | // tap_code16(KC_QUOT); 142 | // } else if (timer_elapsed(single_quote_timer) > TAPPING_TERM) { 143 | // tap_code16(KC_QUOT); 144 | // tap_code16(KC_LEFT); 145 | // } 146 | // return false; 147 | // case D_QUOTE: 148 | // if (record->event.pressed) { 149 | // double_quote_timer = timer_read(); 150 | // tap_code16(KC_DQUO); 151 | // } else if (timer_elapsed(double_quote_timer) > TAPPING_TERM) { 152 | // tap_code16(KC_DQUO); 153 | // tap_code16(KC_LEFT); 154 | // } 155 | // return false; 156 | // // TODO could I merge this three like swe chars? 157 | // case CURLYS: 158 | // if (record->event.pressed) { 159 | // SEND_STRING("{}"SS_TAP(X_LEFT)); 160 | // } 161 | // return false; 162 | // case BRCKETS: 163 | // if (record->event.pressed) { 164 | // SEND_STRING("[]"SS_TAP(X_LEFT)); 165 | // } 166 | // return false; 167 | // case PARENS: 168 | // if (record->event.pressed) { 169 | // SEND_STRING("()"SS_TAP(X_LEFT)); 170 | // } 171 | // return false; 172 | // case SE_AO: 173 | // if (record->event.pressed) { 174 | // tap_code16(A(KC_A)); 175 | // } 176 | // return false; 177 | // case SE_AE: 178 | // case SE_OE: 179 | // if (record->event.pressed) { 180 | // uint8_t mod_state = get_mods(); 181 | // if (mod_state & MOD_MASK_SHIFT) { 182 | // del_mods(MOD_MASK_SHIFT); 183 | // } 184 | // tap_code16(A(KC_U)); 185 | // set_mods(mod_state); 186 | // tap_code16(keycode == SE_AE ? KC_A : KC_O); 187 | // } 188 | // return false; 189 | // case CAPS: 190 | // if (record->event.pressed) { 191 | // toggle_caps_word(); 192 | // } 193 | // return false; 194 | // // TODO these two are never used afaik 195 | // case SNAKE: 196 | // case CAMEL: 197 | // if (record->event.pressed) { 198 | // if (get_xcase_delimiter() != KC_NO) { 199 | // disable_xcase(); 200 | // } else { 201 | // enable_xcase_with(keycode == SNAKE ? KC_UNDS : OSM(MOD_LSFT)); 202 | // } 203 | // } 204 | // return false; 205 | // case SNK_SCM: 206 | // if (record->event.pressed) { 207 | // if (get_xcase_delimiter() != KC_NO) { 208 | // disable_xcase(); 209 | // disable_caps_word(); 210 | // } else { 211 | // enable_caps_word(); 212 | // enable_xcase_with(KC_UNDS); 213 | // } 214 | // } 215 | // return false; 216 | // } 217 | // return true; 218 | //} 219 | 220 | -------------------------------------------------------------------------------- /user/process_records.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/patrick-elmquist/qmk-keymaps/ceb6b298c26fb65a8be85a5a86d388ceac4b40a8/user/process_records.h -------------------------------------------------------------------------------- /user/readme.md: -------------------------------------------------------------------------------- 1 | User space for common code for my Lily58 and Kyria. 2 | 3 | TODO: 4 | * Standard combos work now but the custom ones needs to 5 | be moved from the lily keymap to the user space. 6 | 7 | * Fix the rest of the keymap, especially sort out the 8 | thumb buttons and move back to previous bspc... 9 | 10 | * Add combo debugging to the oled 11 | -------------------------------------------------------------------------------- /user/rules.mk: -------------------------------------------------------------------------------- 1 | VPATH += keyboards/gboards/ 2 | 3 | # Build Options 4 | # change to "no" to disable the options, or define them in the Makefile in 5 | # the appropriate keymap folder that will get included automatically 6 | # 7 | BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration 8 | MOUSEKEY_ENABLE = no # Mouse keys 9 | COMMAND_ENABLE = no # Commands for debug and configuration 10 | NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work 11 | BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality 12 | MIDI_ENABLE = no # MIDI controls 13 | # AUDIO_ENABLE = no # Audio output on port C6 14 | UNICODE_ENABLE = no # Unicode 15 | BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID 16 | RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. 17 | SWAP_HANDS_ENABLE = no # Enable one-hand typing 18 | ENCODER_ENABLE = no # Enables the use of one or more encoders 19 | AUTO_SHIFT_ENABLE = no 20 | WPM_ENABLE = yes 21 | TAP_DANCE_ENABLE = no 22 | DYNAMIC_MACRO_ENABLE = no 23 | RGB_MATRIX_ENABLE = no 24 | 25 | RAW_ENABLE = no 26 | SPACE_CADET_ENABLE = no 27 | POINTING_DEVICE_ENABLE = no 28 | GRAVE_ESC_ENABLE = no 29 | UNICODE_ENABLE = no 30 | CAPS_WORD_ENABLE = no 31 | 32 | CONSOLE_ENABLE = yes # Console for debug 33 | COMBO_ENABLE = yes 34 | EXTRAKEY_ENABLE = yes # Audio control and System control 35 | OLED_ENABLE = yes # OLED display 36 | LTO_ENABLE = yes 37 | 38 | # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE 39 | SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend 40 | 41 | # To use gboards combos 42 | INTROSPECTION_KEYMAP_C = combos.c 43 | 44 | SRC += ./pket.c 45 | SRC += ./features/casemodes.c 46 | SRC += ./features/swapper.c 47 | SRC += ./oled.c 48 | 49 | EXTRAFLAGS += -flto 50 | 51 | -------------------------------------------------------------------------------- /user/wrappers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "keycodes.h" 4 | 5 | // 5 column 6 | #define ________________COLEMAK_L1_5_______________ KC_Q, KC_W, KC_F, KC_P, KC_B 7 | #define ________________COLEMAK_L2_5_______________ HOME_A, HOME_R, HOME_S, HOME_T, KC_G 8 | #define ________________COLEMAK_L3_5_______________ KC_Z, KC_X, KC_C, KC_D, KC_V 9 | 10 | #define ________________COLEMAK_R1_5_______________ KC_J, KC_L, KC_U, KC_Y, KC_SCLN 11 | #define ________________COLEMAK_R2_5_______________ KC_M, HOME_N, HOME_E, HOME_I, HOME_O 12 | #define ________________COLEMAK_R3_5_______________ KC_K, KC_H, KC_COMM, KC_DOT, KC_SLSH 13 | 14 | #define ________________GALLIUM_L1_5_______________ KC_B, KC_L, KC_D, KC_C, KC_V 15 | #define ________________GALLIUM_L2_5_______________ KC_N, KC_R, KC_T, KC_S, KC_G 16 | #define ________________GALLIUM_L3_5_______________ KC_Q, KC_X, KC_M, KC_W, KC_Z 17 | 18 | #define ________________GALLIUM_R1_5_______________ KC_J, KC_Y, KC_O, KC_U, KC_SCLN 19 | #define ________________GALLIUM_R2_5_______________ KC_P, KC_H, KC_A, KC_E, KC_I 20 | #define ________________GALLIUM_R3_5_______________ KC_K, KC_F, KC_COMM, KC_DOT, KC_SLSH 21 | 22 | #define ________________GALLIUM_V2_L1_5____________ KC_B, KC_L, KC_D, KC_C, KC_V 23 | #define ________________GALLIUM_V2_L2_5____________ KC_N, KC_R, KC_T, KC_S, KC_G 24 | #define ________________GALLIUM_V2_L3_5____________ KC_Q, KC_X, KC_M, KC_W, KC_Z 25 | 26 | #define ________________GALLIUM_V2_R1_5____________ KC_J, KC_F, KC_O, KC_U, KC_SCLN 27 | #define ________________GALLIUM_V2_R2_5____________ KC_P, KC_H, KC_A, KC_E, KC_I 28 | #define ________________GALLIUM_V2_R3_5____________ KC_K, KC_Y, KC_COMM, KC_DOT, KC_SLSH 29 | 30 | #define ________________GRAPHITE_L1_5______________ KC_B, KC_L, KC_D, KC_W, KC_Z 31 | #define ________________GRAPHITE_L2_5______________ KC_N, KC_R, KC_T, KC_S, KC_G 32 | #define ________________GRAPHITE_L3_5______________ KC_Q, KC_X, KC_M, KC_C, KC_V 33 | 34 | #define ________________GRAPHITE_R1_5______________ KC_J, KC_F, KC_O, KC_U, KC_SCLN 35 | #define ________________GRAPHITE_R2_5______________ KC_Y, KC_H, KC_A, KC_E, KC_I 36 | #define ________________GRAPHITE_R3_5______________ KC_K, KC_P, KC_COMM, KC_DOT, KC_SLSH 37 | 38 | #define ________________LOWER__L1_5________________ KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC 39 | #define ________________LOWER__L2_5________________ _______, _______, _______, _______, KC_GRV 40 | #define ________________LOWER__L3_5________________ KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_TILD 41 | 42 | #define ________________LOWER__R1_5________________ KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN 43 | #define ________________LOWER__R2_5________________ KC_PLUS, KC_MINS, KC_SLSH, KC_COMM, KC_SCLN 44 | #define ________________LOWER__R3_5________________ KC_EQL, KC_UNDS, KC_COMM, KC_DOT, KC_SLSH 45 | 46 | #define ________________RAISE__L1_5________________ KC_1, KC_2, KC_3, KC_4, KC_5 47 | #define ________________RAISE__L2_5________________ KC_LT, KC_PERC, KC_LPRN, KC_LCBR, KC_LBRC 48 | #define ________________RAISE__L3_5________________ KC_GT, KC_DLR, KC_RPRN, KC_RCBR, KC_RBRC 49 | 50 | #define ________________RAISE__R1_5________________ KC_6, KC_7, KC_8, KC_9, KC_0 51 | #define ________________RAISE__R2_5________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX 52 | #define ________________RAISE__R3_5________________ XXXXXXX, KC_UNDS, _______, _______, _______ 53 | 54 | #define ________________NAV_L1_5___________________ KC_1, KC_2, KC_3, KC_4, KC_5 55 | #define ________________NAV_L2_5___________________ KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, KC_SCLN 56 | #define ________________NAV_L3_5___________________ KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, KC_COMM 57 | 58 | #define ________________NAV_R1_5___________________ KC_6, KC_7, KC_8, KC_9, KC_0 59 | #define ________________NAV_R2_5___________________ KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, XXXXXXX 60 | #define ________________NAV_R3_5___________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX 61 | 62 | #define ________________SYSTEM_L1_5________________ QUIT, CLOSE, SW_WIN, SW_APP, ITERM 63 | #define ________________SYSTEM_L2_5________________ _______, _______, _______, _______, ALFRED 64 | #define ________________SYSTEM_L3_5________________ _______, _______, _______, _______, _______ 65 | 66 | #define ________________SYSTEM_R1_5________________ KC_LSFT, _______, WIN_MAX, BACK, FORWARD 67 | #define ________________SYSTEM_R2_5________________ _______, WIN_LFT, WIN_CEN, WIN_RGT, _______ 68 | #define ________________SYSTEM_R3_5________________ _______, WIN_RES, _______, _______, _______ 69 | 70 | #define ________________ADJUST_L1_5________________ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5 71 | #define ________________ADJUST_L2_5________________ _______, KC_MPRV, KC_MPLY, KC_MNXT, KC_VOLU 72 | #define ________________ADJUST_L3_5________________ QK_BOOT, _______, _______, KC_MUTE, KC_VOLD 73 | 74 | #define ________________ADJUST_R1_5________________ KC_F6, KC_F7, KC_F8, KC_F9, KC_F10 75 | #define ________________ADJUST_R2_5________________ DFL_COL, CK_UP, CK_TOGG, CK_DOWN, KC_F11 76 | #define ________________ADJUST_R3_5________________ _______, DFL_GA2, DFL_GAL, _______, KC_F12 77 | 78 | #define ___THUMB_LEFT___ SYS_REP, LOW_SPC 79 | #define ___THUMB_RIGHT__ RAI_ESC, NAV_BSP 80 | 81 | #define _______THUMB_LEFT________ _______, SYS_REP, LOW_SPC 82 | #define _______THUMB_RIGHT_______ RAI_ENT, NAV_BSP, KC_COLN 83 | 84 | #define _______THUMB_LEFT_2______ SYS_REP, LOW_SPC, KC_ESC 85 | #define _______THUMB_RIGHT_2_____ RAI_ENT, NAV_BSP, KC_COLN 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | // 6 column 95 | #define _____________________COLEMAK_L1_____________________ KC_TAB, ________________COLEMAK_L1_5_______________ 96 | #define _____________________COLEMAK_L2_____________________ CTL_BSP, ________________COLEMAK_L2_5_______________ 97 | #define _____________________COLEMAK_L3_____________________ KC_LSFT, ________________COLEMAK_L3_5_______________ 98 | 99 | #define _____________________COLEMAK_R1_____________________ ________________COLEMAK_R1_5_______________, KC_BSLS 100 | #define _____________________COLEMAK_R2_____________________ ________________COLEMAK_R2_5_______________, KC_QUOT 101 | #define _____________________COLEMAK_R3_____________________ ________________COLEMAK_R3_5_______________, KC_MINS 102 | 103 | #define _____________________LOWER__L1______________________ _______, ________________LOWER__L1_5________________ 104 | #define _____________________LOWER__L2______________________ BSP_WRD, ________________LOWER__L2_5________________ 105 | #define _____________________LOWER__L3______________________ _______, ________________LOWER__L3_5________________ 106 | 107 | #define _____________________LOWER__R1______________________ ________________LOWER__R1_5________________, _______ 108 | #define _____________________LOWER__R2______________________ ________________LOWER__R2_5________________, _______ 109 | #define _____________________LOWER__R3______________________ ________________LOWER__R3_5________________, _______ 110 | 111 | #define _____________________RAISE__L1______________________ _______, ________________RAISE__L1_5________________ 112 | #define _____________________RAISE__L2______________________ _______, ________________RAISE__L2_5________________ 113 | #define _____________________RAISE__L3______________________ _______, ________________RAISE__L3_5________________ 114 | 115 | #define _____________________RAISE__R1______________________ ________________RAISE__R1_5________________, _______ 116 | #define _____________________RAISE__R2______________________ ________________RAISE__R2_5________________, D_QUOTE 117 | #define _____________________RAISE__R3______________________ ________________RAISE__R3_5________________, _______ 118 | 119 | #define _____________________SYSTEM_L1______________________ _______, ________________SYSTEM_L1_5________________ 120 | #define _____________________SYSTEM_L2______________________ _______, ________________SYSTEM_L2_5________________ 121 | #define _____________________SYSTEM_L3______________________ _______, ________________SYSTEM_L3_5________________ 122 | 123 | #define _____________________SYSTEM_R1______________________ ________________SYSTEM_R1_5________________, _______ 124 | #define _____________________SYSTEM_R2______________________ ________________SYSTEM_R2_5________________, _______ 125 | #define _____________________SYSTEM_R3______________________ ________________SYSTEM_R3_5________________, _______ 126 | 127 | #define _____________________ADJUST_L1______________________ _______, ________________ADJUST_L1_5________________ 128 | #define _____________________ADJUST_L2______________________ _______, ________________ADJUST_L2_5________________ 129 | #define _____________________ADJUST_L3______________________ _______, ________________ADJUST_L3_5________________ 130 | 131 | #define _____________________ADJUST_R1______________________ ________________ADJUST_R1_5________________, _______ 132 | #define _____________________ADJUST_R2______________________ ________________ADJUST_R2_5________________, _______ 133 | #define _____________________ADJUST_R3______________________ ________________ADJUST_R3_5________________, _______ 134 | 135 | #define _________MOD_LEFT________ RAISE, SYSTEM, KC_SPC 136 | #define _________MOD_RIGHT_______ RAISE, LOWER, KC_LGUI 137 | 138 | 139 | #define LAYOUT_wrapper(...) LAYOUT(__VA_ARGS__) 140 | #define LAYOUT_wrapper_3x5_3(...) LAYOUT_split_3x5_3(__VA_ARGS__) 141 | --------------------------------------------------------------------------------