aboutsummaryrefslogtreecommitdiff
path: root/users
diff options
context:
space:
mode:
authorTim Schumacher <twschum@gmail.com>2019-11-21 06:07:33 -0500
committerDrashna Jaelre <drashna@live.com>2019-11-21 03:07:33 -0800
commit84065e1d7458ad6b0a04a82fed4dfc69a4ded2b2 (patch)
treec3985a31591fb3f2c3252caf49d7751cd5d8cb10 /users
parent90bb7db48e658624c6c4609c832ac1451e4db98b (diff)
downloadqmk_firmware-84065e1d7458ad6b0a04a82fed4dfc69a4ded2b2.tar.gz
qmk_firmware-84065e1d7458ad6b0a04a82fed4dfc69a4ded2b2.zip
[Keymap] Add DZ60, Levinson keymaps, twschum user files (#7358)
* Adds layout for DZ60rev2 plate B, options 4 and 10 * Use KC_TRANS for layer keys * Format layer0 with visual key size layout * Add RGB controls; add start description; add KC_LOCK * Update comments on rules.mk for DZ60 * Gets keymap compiling * Fix wiring for shift on row 3 * Hold a with other key to send Ctrl-A before other key * Adds compile-time defined mac-compatability media keycodes * Adds logic in place for capturing taps (w/ timeout) * Add send_keys(...) which can send up to 64 nested keycodes * Implement send_keys callable with n repeats * Tweaks some of the keymap * Add reset keycode; add disable to custom shortcuts * Adds a special "off" layer where bonus mod goes to layer 0, every other key KC_NO * Adjust timeout; mousekey settings * Changes layout of Home,End,PgUp/Dn on the dedicated arrow keys L1/L2 * PoC on rgb lighted layer indication * Refactors color table defines * Adds logic for controlling layer lights * Only change state on one side of the event lol * Switch back to Tapping Toggle for layer 4 * Add custom config file for keyboard; TT and mousekey settings * Code cleanup; starting to refactor special ctrl tapping keys functions * Move defines and reak out functions * Remove debugging light * Adjust keymaps; add enter * Adds a couple custom macros * Add simplified version of keymap to help debug issues * Adds basi numpad configuration for levinson keyboard half * Use ANSI ctrl key as layer 1 for better one hand (`) * Adapt to new 8bit hue from #5547; layer enum use everywhere * Move custom code out to users/ space * Flip col pins, move key assignments to "left hand" * Update readme * Implement placeholder macros * Notes * Reduce tapping time for SFT_T(/) * Adds vim features; refactors things * Adds fork of the vim features written by xton * Use correct backspace keycode * Add VIM_ESC * Add "OFF" to the RGB/HSV definitions * Clean up rules, use new "OFF" definition * Add windows KC_CALCULATOR key to numpad * Reformat layers with better guide; change layer names * Add sleep key * Change timeout delay * Add a "code paste" which surrounds a ^V with ``` * Try removing shift tap on rshift / * Update macros * Update the "code paste" macro * Update keymap with reset, calc, equals * Update keyboards/dz60/keymaps/twschum_b_4_10_simple/keymap.c Co-Authored-By: Drashna Jaelre <drashna@live.com> * Update keyboards/dz60/keymaps/twschum_b_4_10/keymap.c Co-Authored-By: Drashna Jaelre <drashna@live.com> * Update users/twschum/twschum.c Co-Authored-By: Drashna Jaelre <drashna@live.com> * Update users/twschum/twschum.c Co-Authored-By: Drashna Jaelre <drashna@live.com> * Revert quantum/rgblight_list.h * Better name for split space layout; rename KEYMAP->LAYOUT * Rename KEYMAP->LAYOUT * Use simpler :flash command * Clean up layout files * Use qmk's MOD_MASK_CTRL * Sync lufa submodule * Cleanup from noroadsleft's PR comments * Modernize vim layer code
Diffstat (limited to 'users')
-rw-r--r--users/twschum/config.h0
-rw-r--r--users/twschum/readme.md14
-rw-r--r--users/twschum/rules.mk5
-rw-r--r--users/twschum/twschum.c257
-rw-r--r--users/twschum/twschum.h131
-rw-r--r--users/twschum/xtonhasvim.c593
-rw-r--r--users/twschum/xtonhasvim.h62
7 files changed, 1062 insertions, 0 deletions
diff --git a/users/twschum/config.h b/users/twschum/config.h
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/users/twschum/config.h
diff --git a/users/twschum/readme.md b/users/twschum/readme.md
new file mode 100644
index 000000000..b354e4b79
--- /dev/null
+++ b/users/twschum/readme.md
@@ -0,0 +1,14 @@
1Copyright 2019 Tim Schumacher <twschum@gmail.com> @twschum
2
3This program is free software: you can redistribute it and/or modify
4it under the terms of the GNU General Public License as published by
5the Free Software Foundation, either version 2 of the License, or
6(at your option) any later version.
7
8This program is distributed in the hope that it will be useful,
9but WITHOUT ANY WARRANTY; without even the implied warranty of
10MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11GNU General Public License for more details.
12
13You should have received a copy of the GNU General Public License
14along with this program. If not, see <http://www.gnu.org/licenses/>.
diff --git a/users/twschum/rules.mk b/users/twschum/rules.mk
new file mode 100644
index 000000000..9878e6f69
--- /dev/null
+++ b/users/twschum/rules.mk
@@ -0,0 +1,5 @@
1SRC += twschum.c
2SRC += xtonhasvim.c
3ifeq ($(strip $(FLASH_BOOTLOADER)), yes)
4 OPT_DEFS += -DFLASH_BOOTLOADER
5endif
diff --git a/users/twschum/twschum.c b/users/twschum/twschum.c
new file mode 100644
index 000000000..2d34f9571
--- /dev/null
+++ b/users/twschum/twschum.c
@@ -0,0 +1,257 @@
1#include "twschum.h"
2
3#ifdef TWSCHUM_TAPPING_CTRL_PREFIX
4// state for the great state machine of custom actions!
5#define TIMEOUT_DELAY 200 // ms
6static uint16_t idle_timer;
7static bool timeout_is_active = false;
8
9static bool ctrl_shortcuts_enabled_g = false;
10//static bool B_down = 0; // TODO just use top bit from count
11//static int8_t B_count = 0;
12
13#define N_TAPPING_CTRL_KEYS 2
14static struct Tapping_ctrl_key_t special_keys_g[N_TAPPING_CTRL_KEYS] = {
15 {false, 0, KC_B}, {false, 0, KC_A}
16};
17
18static inline void start_idle_timer(void) {
19 idle_timer = timer_read();
20 timeout_is_active = true;
21}
22static inline void clear_state_after_idle_timeout(void) {
23 idle_timer = 0;
24 timeout_is_active = false;
25
26 // send timed out plain keys from tapping ctrl mod
27 for (int i = 0; i < N_TAPPING_CTRL_KEYS; ++i) {
28 struct Tapping_ctrl_key_t* key = special_keys_g + i;
29 repeat_send_keys(key->count, key->keycode);
30 key->count = 0;
31 }
32}
33
34inline void matrix_scan_user(void) {
35 if (timeout_is_active && timer_elapsed(idle_timer) > TIMEOUT_DELAY) {
36 clear_state_after_idle_timeout();
37 }
38}
39
40static inline bool tap_ctrl_event(struct Tapping_ctrl_key_t* key, keyrecord_t* record) {
41 if (!ctrl_shortcuts_enabled_g) {
42 // normal operation, just send the plain keycode
43 if (record->event.pressed) {
44 register_code(key->keycode);
45 }
46 else {
47 unregister_code(key->keycode);
48 }
49 return false;
50 }
51 key->down = record->event.pressed;
52 // increment count and reset timer when key pressed
53 // start the timeout when released
54 if (key->down) {
55 ++(key->count);
56 timeout_is_active = false;
57 idle_timer = 0;
58 }
59 else {
60 if (key->count) {
61 start_idle_timer();
62 }
63 }
64 return false;
65}
66
67static inline bool tap_ctrl_other_pressed(void) {
68 for (int i = 0; i < N_TAPPING_CTRL_KEYS; ++i) {
69 struct Tapping_ctrl_key_t* key = special_keys_g + i;
70 if (key->count) {
71 if (key->down) {
72 // another key has been pressed while the leader key is down,
73 // so send number of ctrl-KEY combos before the other key
74 repeat_send_keys(key->count, KC_LCTL, key->keycode);
75 key->count = 0;
76 }
77 else {
78 // another key pressed after leader key released,
79 // need to send the plain keycode plus potential mods
80 if (get_mods() & MOD_MASK_CTRL) {
81 // make sure to send a shift if prssed
82 repeat_send_keys(key->count, KC_RSHIFT, key->keycode);
83 }
84 else {
85 repeat_send_keys(key->count, key->keycode);
86 }
87 key->count = 0;
88 }
89 return true; // will send the other keycode
90 }
91 }
92 return true; // safe default
93}
94#endif /* TWSCHUM_TAPPING_CTRL_PREFIX */
95
96
97/* Use RGB underglow to indicate layer
98 * https://docs.qmk.fm/reference/customizing-functionality
99 */
100// add to quantum/rgblight_list.h
101#ifdef RGBLIGHT_ENABLE
102static bool rgb_layers_enabled = true;
103static bool rgb_L0_enabled = false;
104
105layer_state_t layer_state_set_user(layer_state_t state) {
106 if (!rgb_layers_enabled) {
107 return state;
108 }
109 switch (get_highest_layer(state)) {
110 case _Base:
111 if (rgb_L0_enabled) {
112 rgblight_sethsv_noeeprom(_Base_HSV_ON);
113 }
114 else {
115 rgblight_sethsv_noeeprom(_Base_HSV_OFF);
116 }
117 break;
118 case _Vim:
119 rgblight_sethsv_noeeprom(_Vim_HSV);
120 break;
121 case _Fn:
122 rgblight_sethsv_noeeprom(_Fn_HSV);
123 break;
124 case _Nav:
125 rgblight_sethsv_noeeprom(_Nav_HSV);
126 break;
127 case _Num:
128 rgblight_sethsv_noeeprom(_Num_HSV);
129 break;
130 case _Cfg:
131 rgblight_sethsv_noeeprom(_Cfg_HSV);
132 break;
133 case _None:
134 rgblight_sethsv_noeeprom(_None_HSV);
135 break;
136 }
137 return state;
138}
139#endif /* RGBLIGHT_ENABLE */
140
141/* process_record_vimlayer: handles the VIM_ keycodes from xtonhasvim's vim
142 * emulation layer
143 * add process_record_keymap to allow specific keymap to still add keys
144 * Makes the callstack look like:
145 * process_record_
146 * _quantum
147 * _kb
148 * _user
149 * _keymap
150 * _vimlayer
151 */
152__attribute__ ((weak))
153bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
154 return true;
155}
156
157/* Return True to continue processing keycode, false to stop further processing
158 * process_record_keymap to be call by process_record_user in the vim addon */
159bool process_record_user(uint16_t keycode, keyrecord_t *record) {
160
161 /* keymap gets first whack, then vimlayer */
162 if(!process_record_keymap(keycode, record)) return false;
163 if(!process_record_vimlayer(keycode, record)) return false;
164
165 switch (keycode) {
166 /* KC_MAKE is a keycode to be used with any keymap
167 * Outputs `make <keyboard>:<keymap>`
168 * Holding shift will add the appropriate flashing command (:dfu,
169 * :teensy, :avrdude, :dfu-util) for a majority of keyboards.
170 * Holding control will add some commands that will speed up compiling
171 * time by processing multiple files at once
172 * For the boards that lack a shift key, or that you want to always
173 * attempt the flashing part, you can add FLASH_BOOTLOADER = yes to the
174 * rules.mk of that keymap.
175 */
176 case KC_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader
177 if (!record->event.pressed) {
178 uint8_t temp_mod = get_mods();
179 uint8_t temp_osm = get_oneshot_mods();
180 clear_mods(); clear_oneshot_mods();
181 SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP);
182 #ifndef FLASH_BOOTLOADER
183 if ( (temp_mod | temp_osm) & MOD_MASK_SHIFT ) {
184 SEND_STRING(":flash");
185 }
186 #endif
187 if ( (temp_mod | temp_osm) & MOD_MASK_CTRL) {
188 SEND_STRING(" -j8 --output-sync");
189 }
190 SEND_STRING(SS_TAP(X_ENTER));
191 set_mods(temp_mod);
192 }
193 break;
194
195 #ifdef RGBLIGHT_ENABLE
196 case TG_LAYER_RGB:
197 if (record->event.pressed) {
198 rgb_layers_enabled = !rgb_layers_enabled;
199 }
200 return false;
201 case TG_L0_RGB:
202 if (record->event.pressed) {
203 rgb_L0_enabled = !rgb_L0_enabled;
204 }
205 return false;
206 #endif
207
208 case SALT_CMD:
209 if (!record->event.pressed) {
210 SEND_STRING(SALT_CMD_MACRO);
211 }
212 return false;
213 case LESS_PD:
214 if (!record->event.pressed) {
215 SEND_STRING(LESS_PD_MACRO);
216 }
217 return false;
218 case CODE_PASTE:
219 if (!record->event.pressed) {
220 SEND_STRING(CODE_PASTE_MACRO);
221 }
222 return false;
223
224 #ifdef TWSCHUM_TAPPING_CTRL_PREFIX
225 case EN_CTRL_SHORTCUTS:
226 if (record->event.pressed) {
227 ctrl_shortcuts_enabled_g = !ctrl_shortcuts_enabled_g;
228 start_idle_timer(); // need to clear out state in some cases
229 }
230 return false;
231 case CTRL_A:
232 return tap_ctrl_event(&special_keys_g[1], record);
233 case CTRL_B:
234 return tap_ctrl_event(&special_keys_g[0], record);
235 default:
236 if (record->event.pressed) {
237 return tap_ctrl_other_pressed();
238 }
239 #endif
240 }
241 return true;
242}
243
244#ifdef RGBLIGHT_ENABLE
245void matrix_init_user(void) {
246 // called once on board init
247 rgblight_enable();
248}
249#endif
250
251void suspend_power_down_user(void) {
252 // TODO shut off backlighting
253}
254
255void suspend_wakeup_init_user(void) {
256 // TODO turn on backlighting
257}
diff --git a/users/twschum/twschum.h b/users/twschum/twschum.h
new file mode 100644
index 000000000..e8c9aeffc
--- /dev/null
+++ b/users/twschum/twschum.h
@@ -0,0 +1,131 @@
1#pragma once
2#include <stdarg.h>
3#include "quantum.h"
4#include "xtonhasvim.h"
5
6/**************************
7 * QMK Features Used
8 **************************
9 * RGBLIGHT_ENABLE
10 * - Adds layer indication via RGB underglow
11 * - see the `layer_definitions` enum and following _*_HSV #defines
12 *
13 *
14 *
15 **************************
16 * Custom Feature Flags
17 **************************
18 *
19 * TWSCHUM_TAPPING_CTRL_PREFIX
20 * - Adds feature that makes sending nested sequences of C-a, C-b[, C-b, ...]
21 * as simple as C-a b [b ...]
22 * - Not necessarily super useful outside specialized nested tmux sessions,
23 * but it was a fun state-machine to build
24 *
25 * TWSCHUM_VIM_LAYER
26 * - Fork of xtonhasvim, adding vim-emulation
27 *
28 * TWSCHUM_IS_MAC
29 * - Flag for handling media keys and other settings between OSX and Win/Unix
30 * without having to include bootmagic
31 *
32 **************************
33 * Features Wishlist
34 **************************
35 * use VIM_Q as macro recorder!
36 * Dynamic macros
37 * Leader functions
38 * Uniicode leader commands??? (symbolic unicode)
39 * Mac mode vs not: -probably bootmagic or use default with dynamic swap out here
40 * KC_MFFD(KC_MEDIA_FAST_FORWARD) and KC_MRWD(KC_MEDIA_REWIND) instead of KC_MNXT and KC_MPRV
41 */
42
43/* Each layer gets a color, overwritable per keyboard */
44enum layers_definitions {
45 _Base,
46 _Vim,
47 _Fn,
48 _Nav,
49 _Num,
50 _Cfg,
51 _None,
52};
53#ifdef RGBLIGHT_ENABLE
54#define _Base_HSV_ON HSV_WHITE
55#define _Base_HSV_OFF 0, 0, 0
56#define _Vim_HSV HSV_ORANGE
57#define _Fn_HSV HSV_GREEN
58#define _Nav_HSV HSV_AZURE
59#define _Num_HSV HSV_GOLD
60#define _Cfg_HSV HSV_RED
61#define _None_HSV HSV_WHITE
62#endif
63
64enum extra_keycodes {
65 TWSCHUM_START = VIM_SAFE_RANGE,
66 KC_MAKE, // types the make command for this keyboard
67#ifdef TWSCHUM_TAPPING_CTRL_PREFIX
68 CTRL_A,
69 CTRL_B,
70 EN_CTRL_SHORTCUTS,
71#endif
72#ifdef RGBLIGHT_ENABLE
73 TG_LAYER_RGB, // Toggle between standard RGB underglow, and RGB underglow to do layer indication
74 TG_L0_RGB, // Toggle color on or off of layer0
75#endif
76 SALT_CMD, // macro
77 LESS_PD, // macro
78 CODE_PASTE, // macro
79 KEYMAP_SAFE_RANGE, // range to start for the keymap
80};
81#define SALT_CMD_MACRO "sudo salt \\* cmd.run ''"SS_TAP(X_LEFT)
82#define LESS_PD_MACRO "sudo less /pipedream/cache/"
83// TODO mac vs linux
84#define CODE_PASTE_MACRO SS_LSFT("\n")"```"SS_LSFT("\n")SS_LALT("v")SS_LSFT("\n")"```"
85
86
87/* PP_NARG macro returns the number of arguments passed to it.
88 * https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s
89 */
90#define PP_NARG(...) PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
91#define PP_NARG_(...) PP_ARG_N(__VA_ARGS__)
92#define PP_MAX_ARGS 64
93#define PP_ARG_N( \
94 _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
95 _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
96 _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
97 _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
98 _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
99 _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
100 _61,_62,_63,N,...) N
101#define PP_RSEQ_N() 63,62,61,60, \
102 59,58,57,56,55,54,53,52,51,50, \
103 49,48,47,46,45,44,43,42,41,40, \
104 39,38,37,36,35,34,33,32,31,30, \
105 29,28,27,26,25,24,23,22,21,20, \
106 19,18,17,16,15,14,13,12,11,10, \
107 9,8,7,6,5,4,3,2,1,0
108
109#define send_keys(...) send_n_keys(PP_NARG(__VA_ARGS__), __VA_ARGS__)
110static inline void send_n_keys(int n, ...) {
111 uint8_t i = 0;
112 uint16_t keycodes[PP_MAX_ARGS];
113 va_list keys;
114 va_start(keys, n);
115 for (; i < n; ++i) {
116 keycodes[i] = (uint16_t)va_arg(keys, int); // cast suppresses warning
117 register_code(keycodes[i]);
118 }
119 for (; n > 0; --n) {
120 unregister_code(keycodes[n-1]);
121 }
122 va_end(keys);
123}
124#define repeat_send_keys(n, ...) {for (int i=0; i < n; ++i) {send_keys(__VA_ARGS__);}}
125
126/* State functions for nested c-a & c-b leader keystrokes */
127struct Tapping_ctrl_key_t {
128 bool down;
129 int8_t count;
130 const uint16_t keycode;
131};
diff --git a/users/twschum/xtonhasvim.c b/users/twschum/xtonhasvim.c
new file mode 100644
index 000000000..a1adf39f0
--- /dev/null
+++ b/users/twschum/xtonhasvim.c
@@ -0,0 +1,593 @@
1 /* Copyright 2015-2017 Christon DeWan *
2 * This program is free software: you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation, either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 */
15
16#include "xtonhasvim.h"
17
18
19uint16_t vstate = VIM_START;
20static bool yank_was_lines = false;
21static bool SHIFTED = false;
22static uint32_t mod_override_layer_state = 0;
23static uint16_t mod_override_triggering_key = 0;
24
25static void edit(void) { vstate = VIM_START; layer_clear(); }
26#define EDIT edit()
27
28
29static void simple_movement(uint16_t keycode) {
30 switch(keycode) {
31 case VIM_B:
32 register_code(KC_LALT);
33 tap_code16(LSFT(KC_LEFT)); // select to start of this word
34 unregister_code(KC_LALT);
35 break;
36 case VIM_E:
37 register_code(KC_LALT);
38 tap_code16(LSFT(KC_RIGHT)); // select to end of this word
39 unregister_code(KC_LALT);
40 break;
41 case VIM_H:
42 tap_code16(LSFT(KC_LEFT));
43 break;
44 case VIM_J:
45 tap_code16(LGUI(KC_LEFT));
46 tap_code16(LSFT(KC_DOWN));
47 tap_code16(LSFT(KC_DOWN));
48 break;
49 case VIM_K:
50 tap_code16(LGUI(KC_LEFT));
51 tap_code(KC_DOWN);
52 tap_code16(LSFT(KC_UP));
53 tap_code16(LSFT(KC_UP));
54 break;
55 case VIM_L:
56 tap_code16(LSFT(KC_RIGHT));
57 break;
58 case VIM_W:
59 register_code(KC_LALT);
60 tap_code16(LSFT(KC_RIGHT)); // select to end of this word
61 tap_code16(LSFT(KC_RIGHT)); // select to end of next word
62 tap_code16(LSFT(KC_LEFT)); // select to start of next word
63 unregister_code(KC_LALT);
64 break;
65 }
66}
67
68static void comma_period(uint16_t keycode) {
69 switch (keycode) {
70 case VIM_COMMA:
71 if (SHIFTED) {
72 // indent
73 tap_code16(LGUI(KC_LBRACKET));
74 } else {
75 // toggle comment
76 tap_code16(LGUI(KC_SLASH));
77 }
78 break;
79 case VIM_PERIOD:
80 if (SHIFTED) {
81 // outdent
82 tap_code16(LGUI(KC_RBRACKET));
83 }
84 break;
85 }
86}
87
88
89bool process_record_vimlayer(uint16_t keycode, keyrecord_t *record) {
90
91 /****** mod passthru *****/
92 if(record->event.pressed && layer_state_is(vim_cmd_layer()) && (IS_MOD(keycode) || keycode == LSFT(KC_LALT))) {
93 mod_override_layer_state = layer_state;
94 mod_override_triggering_key = keycode;
95 // TODO: change this to track key location instead
96 layer_clear();
97 return true; // let the event fall through...
98 }
99 if(mod_override_layer_state && !record->event.pressed && keycode == mod_override_triggering_key) {
100 layer_state_set(mod_override_layer_state);
101 mod_override_layer_state = 0;
102 mod_override_triggering_key = 0;
103 return true;
104 }
105
106 if (VIM_START <= keycode && keycode <= VIM_ESC) {
107 if(keycode == VIM_SHIFT) {
108 SHIFTED = record->event.pressed;
109 return false;
110 }
111
112 if (record->event.pressed) {
113 if(keycode == VIM_START) {
114 // entry from anywhere
115 layer_on(vim_cmd_layer());
116 vstate = VIM_START;
117
118 // reset state
119 yank_was_lines = false;
120 SHIFTED = false;
121 mod_override_layer_state = 0;
122 mod_override_triggering_key = 0;
123
124 return false;
125 }
126 switch(vstate) {
127 case VIM_START:
128 switch(keycode){
129 /*****************************
130 * ground state
131 *****************************/
132 case VIM_A:
133 if(SHIFTED) {
134 // tap_code16(LGUI(KC_RIGHT));
135 tap_code16(LCTL(KC_E));
136 } else {
137 tap_code(KC_RIGHT);
138 }
139 EDIT;
140 break;
141 case VIM_B:
142 register_code(KC_LALT);
143 register_code(KC_LEFT);
144 break;
145 case VIM_C:
146 if(SHIFTED) {
147 register_code(KC_LSHIFT);
148 tap_code16(LGUI(KC_RIGHT));
149 unregister_code(KC_LSHIFT);
150 tap_code16(LGUI(KC_X));
151 yank_was_lines = false;
152 EDIT;
153 } else {
154 vstate = VIM_C;
155 }
156 break;
157 case VIM_D:
158 if(SHIFTED) {
159 tap_code16(LCTL(KC_K));
160 } else {
161 vstate = VIM_D;
162 }
163 break;
164 case VIM_E:
165 register_code(KC_LALT);
166 register_code(KC_RIGHT);
167 break;
168 case VIM_G:
169 if(SHIFTED) {
170 tap_code(KC_END);
171 } else {
172 vstate = VIM_G;
173 }
174 break;
175 case VIM_H:
176 register_code(KC_LEFT);
177 break;
178 case VIM_I:
179 if(SHIFTED){
180 tap_code16(LCTL(KC_A));
181 }
182 EDIT;
183 break;
184 case VIM_J:
185 if(SHIFTED) {
186 tap_code16(LGUI(KC_RIGHT));
187 tap_code(KC_DEL);
188 } else {
189 register_code(KC_DOWN);
190 }
191 break;
192 case VIM_K:
193 register_code(KC_UP);
194 break;
195 case VIM_L:
196 register_code(KC_RIGHT);
197 break;
198 case VIM_O:
199 if(SHIFTED) {
200 tap_code16(LGUI(KC_LEFT));
201 tap_code(KC_ENTER);
202 tap_code(KC_UP);
203 EDIT;
204 } else {
205 tap_code16(LGUI(KC_RIGHT));
206 tap_code(KC_ENTER);
207 EDIT;
208 }
209 break;
210 case VIM_P:
211 if(SHIFTED) {
212 tap_code16(LGUI(KC_LEFT));
213 tap_code16(LGUI(KC_V));
214 } else {
215 if(yank_was_lines) {
216 tap_code16(LGUI(KC_RIGHT));
217 tap_code(KC_RIGHT);
218 tap_code16(LGUI(KC_V));
219 } else {
220 tap_code16(LGUI(KC_V));
221 }
222 }
223 break;
224 case VIM_S:
225 // s for substitute?
226 if(SHIFTED) {
227 tap_code16(LGUI(KC_LEFT));
228 register_code(KC_LSHIFT);
229 tap_code16(LGUI(KC_RIGHT));
230 unregister_code(KC_LSHIFT);
231 tap_code16(LGUI(KC_X));
232 yank_was_lines = false;
233 EDIT;
234 } else {
235 tap_code16(LSFT(KC_RIGHT));
236 tap_code16(LGUI(KC_X));
237 yank_was_lines = false;
238 EDIT;
239 }
240 break;
241 case VIM_U:
242 if(SHIFTED) {
243 register_code(KC_LSFT);
244 tap_code16(LGUI(KC_Z));
245 unregister_code(KC_LSHIFT);
246 } else {
247 tap_code16(LGUI(KC_Z));
248 }
249 break;
250 case VIM_V:
251 if(SHIFTED) {
252 tap_code16(LGUI(KC_LEFT));
253 tap_code16(LSFT(KC_DOWN));
254 vstate = VIM_VS;
255 } else {
256 vstate = VIM_V;
257 }
258 break;
259 case VIM_W:
260 register_code(KC_LALT);
261 tap_code(KC_RIGHT);
262 tap_code(KC_RIGHT);
263 tap_code(KC_LEFT);
264 unregister_code(KC_LALT);
265 break;
266 case VIM_X:
267 // tap_code16(LSFT(KC_RIGHT));
268 // tap_code16(LGUI(KC_X));
269 register_code(KC_DEL);
270 break;
271 case VIM_Y:
272 if(SHIFTED) {
273 tap_code16(LGUI(KC_LEFT));
274 tap_code16(LSFT(KC_DOWN));
275 tap_code16(LGUI(KC_C));
276 tap_code(KC_RIGHT);
277 yank_was_lines = true;
278 } else {
279 vstate = VIM_Y;
280 }
281 break;
282 case VIM_COMMA:
283 case VIM_PERIOD:
284 comma_period(keycode);
285 break;
286 }
287 break;
288 case VIM_C:
289 /*****************************
290 * c- ...for change. I never use this...
291 *****************************/
292 switch(keycode) {
293 case VIM_B:
294 case VIM_E:
295 case VIM_H:
296 case VIM_J:
297 case VIM_K:
298 case VIM_L:
299 case VIM_W:
300 simple_movement(keycode);
301 tap_code16(LGUI(KC_X));
302 yank_was_lines = false;
303 EDIT;
304 break;
305
306 case VIM_C:
307 tap_code16(LGUI(KC_LEFT));
308 register_code(KC_LSHIFT);
309 tap_code16(LGUI(KC_RIGHT));
310 unregister_code(KC_LSHIFT);
311 tap_code16(LGUI(KC_X));
312 yank_was_lines = false;
313 EDIT;
314 break;
315 case VIM_I:
316 vstate = VIM_CI;
317 break;
318 default:
319 vstate = VIM_START;
320 break;
321 }
322 break;
323 case VIM_CI:
324 /*****************************
325 * ci- ...change inner word
326 *****************************/
327 switch(keycode) {
328 case VIM_W:
329 tap_code16(LALT(KC_LEFT));
330 register_code(KC_LSHIFT);
331 tap_code16(LALT(KC_RIGHT));
332 unregister_code(KC_LSHIFT);
333 tap_code16(LGUI(KC_X));
334 yank_was_lines = false;
335 EDIT;
336 default:
337 vstate = VIM_START;
338 break;
339 }
340 break;
341 case VIM_D:
342 /*****************************
343 * d- ...delete stuff
344 *****************************/
345 switch(keycode) {
346 case VIM_B:
347 case VIM_E:
348 case VIM_H:
349 case VIM_J:
350 case VIM_K:
351 case VIM_L:
352 case VIM_W:
353 simple_movement(keycode);
354 tap_code16(LGUI(KC_X));
355 yank_was_lines = false;
356 vstate = VIM_START;
357 break;
358 case VIM_D:
359 tap_code16(LGUI(KC_LEFT));
360 tap_code16(LSFT(KC_DOWN));
361 tap_code16(LGUI(KC_X));
362 yank_was_lines = true;
363 vstate = VIM_START;
364 break;
365 case VIM_I:
366 vstate = VIM_DI;
367 break;
368 default:
369 vstate = VIM_START;
370 break;
371 }
372 break;
373 case VIM_DI:
374 /*****************************
375 * ci- ...delete a word... FROM THE INSIDE!
376 *****************************/
377 switch(keycode) {
378 case VIM_W:
379 tap_code16(LALT(KC_LEFT));
380 register_code(KC_LSHIFT);
381 tap_code16(LALT(KC_RIGHT));
382 unregister_code(KC_LSHIFT);
383 tap_code16(LGUI(KC_X));
384 yank_was_lines = false;
385 vstate = VIM_START;
386 default:
387 vstate = VIM_START;
388 break;
389 }
390 break;
391 case VIM_V:
392 /*****************************
393 * visual!
394 *****************************/
395 switch(keycode) {
396 case VIM_D:
397 case VIM_X:
398 tap_code16(LGUI(KC_X));
399 yank_was_lines = false;
400 vstate = VIM_START;
401 break;
402 case VIM_B:
403 register_code(KC_LALT);
404 register_code(KC_LSHIFT);
405 register_code(KC_LEFT);
406 // leave open for key repeat
407 break;
408 case VIM_E:
409 register_code(KC_LALT);
410 register_code(KC_LSHIFT);
411 register_code(KC_RIGHT);
412 // leave open for key repeat
413 break;
414 case VIM_H:
415 register_code(KC_LSHIFT);
416 register_code(KC_LEFT);
417 break;
418 case VIM_I:
419 vstate = VIM_VI;
420 break;
421 case VIM_J:
422 register_code(KC_LSHIFT);
423 register_code(KC_DOWN);
424 break;
425 case VIM_K:
426 register_code(KC_LSHIFT);
427 register_code(KC_UP);
428 break;
429 case VIM_L:
430 register_code(KC_LSHIFT);
431 register_code(KC_RIGHT);
432 break;
433 case VIM_W:
434 register_code(KC_LALT);
435 tap_code16(LSFT(KC_RIGHT)); // select to end of this word
436 tap_code16(LSFT(KC_RIGHT)); // select to end of next word
437 tap_code16(LSFT(KC_LEFT)); // select to start of next word
438 unregister_code(KC_LALT);
439 break;
440 case VIM_P:
441 tap_code16(LGUI(KC_V));
442 vstate = VIM_START;
443 break;
444 case VIM_Y:
445 tap_code16(LGUI(KC_C));
446 tap_code(KC_RIGHT);
447 yank_was_lines = false;
448 vstate = VIM_START;
449 break;
450 case VIM_V:
451 case VIM_ESC:
452 tap_code(KC_RIGHT);
453 vstate = VIM_START;
454 break;
455 case VIM_COMMA:
456 case VIM_PERIOD:
457 comma_period(keycode);
458 break;
459 default:
460 // do nothing
461 break;
462 }
463 break;
464 case VIM_VI:
465 /*****************************
466 * vi- ...select a word... FROM THE INSIDE!
467 *****************************/
468 switch(keycode) {
469 case VIM_W:
470 tap_code16(LALT(KC_LEFT));
471 register_code(KC_LSHIFT);
472 tap_code16(LALT(KC_RIGHT));
473 unregister_code(KC_LSHIFT);
474 vstate = VIM_V;
475 default:
476 // ignore
477 vstate = VIM_V;
478 break;
479 }
480 break;
481 case VIM_VS:
482 /*****************************
483 * visual line
484 *****************************/
485 switch(keycode) {
486 case VIM_D:
487 case VIM_X:
488 tap_code16(LGUI(KC_X));
489 yank_was_lines = true;
490 vstate = VIM_START;
491 break;
492 case VIM_J:
493 register_code(KC_LSHIFT);
494 register_code(KC_DOWN);
495 break;
496 case VIM_K:
497 register_code(KC_LSHIFT);
498 register_code(KC_UP);
499 break;
500 case VIM_Y:
501 tap_code16(LGUI(KC_C));
502 yank_was_lines = true;
503 tap_code(KC_RIGHT);
504 vstate = VIM_START;
505 break;
506 case VIM_P:
507 tap_code16(LGUI(KC_V));
508 vstate = VIM_START;
509 break;
510 case VIM_V:
511 case VIM_ESC:
512 tap_code(KC_RIGHT);
513 vstate = VIM_START;
514 break;
515 case VIM_COMMA:
516 case VIM_PERIOD:
517 comma_period(keycode);
518 break;
519 default:
520 // do nothing
521 break;
522 }
523 break;
524 case VIM_G:
525 /*****************************
526 * gg, and a grab-bag of other macros i find useful
527 *****************************/
528 switch(keycode) {
529 case VIM_G:
530 tap_code(KC_HOME);
531 break;
532 // codes b
533 case VIM_H:
534 tap_code16(LCTL(KC_A));
535 break;
536 case VIM_J:
537 register_code(KC_PGDN);
538 break;
539 case VIM_K:
540 register_code(KC_PGUP);
541 break;
542 case VIM_L:
543 tap_code16(LCTL(KC_E));
544 break;
545 default:
546 // do nothing
547 break;
548 }
549 vstate = VIM_START;
550 break;
551 case VIM_Y:
552 /*****************************
553 * yoink!
554 *****************************/
555 switch(keycode) {
556 case VIM_B:
557 case VIM_E:
558 case VIM_H:
559 case VIM_J:
560 case VIM_K:
561 case VIM_L:
562 case VIM_W:
563 simple_movement(keycode);
564 tap_code16(LGUI(KC_C));
565 tap_code(KC_RIGHT);
566 yank_was_lines = false;
567 break;
568 case VIM_Y:
569 tap_code16(LGUI(KC_LEFT));
570 tap_code16(LSFT(KC_DOWN));
571 tap_code16(LGUI(KC_C));
572 tap_code(KC_RIGHT);
573 yank_was_lines = true;
574 break;
575 default:
576 // NOTHING
577 break;
578 }
579 vstate = VIM_START;
580 break;
581 }
582 } else {
583 /************************
584 * key unregister_code events
585 ************************/
586 clear_keyboard();
587 }
588 return false;
589 } else {
590 return true;
591 }
592}
593
diff --git a/users/twschum/xtonhasvim.h b/users/twschum/xtonhasvim.h
new file mode 100644
index 000000000..fd9ebd4f0
--- /dev/null
+++ b/users/twschum/xtonhasvim.h
@@ -0,0 +1,62 @@
1 /* Copyright 2015-2017 Christon DeWan
2 *
3 * This program is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
16
17#ifndef USERSPACE
18#define USERSPACE
19
20#include QMK_KEYBOARD_H
21
22enum xtonhasvim_keycodes {
23 VIM_START = SAFE_RANGE, // bookend for vim states
24 VIM_A,
25 VIM_B,
26 VIM_C,
27 VIM_CI,
28 VIM_D,
29 VIM_DI,
30 VIM_E,
31 VIM_H,
32 VIM_G,
33 VIM_I,
34 VIM_J,
35 VIM_K,
36 VIM_L,
37 VIM_O,
38 VIM_P,
39 VIM_S,
40 VIM_U,
41 VIM_V,
42 VIM_VS, // visual-line
43 VIM_VI,
44 VIM_W,
45 VIM_X,
46 VIM_Y,
47 VIM_PERIOD, // to support indent/outdent
48 VIM_COMMA, // and toggle comments
49 VIM_SHIFT, // avoid side-effect of supporting real shift.
50 VIM_ESC, // bookend
51 VIM_SAFE_RANGE // start other keycodes here.
52};
53
54bool process_record_vimlayer(uint16_t keycode, keyrecord_t *record);
55
56// NOTE: Define this in keymap.c to return vim layer
57extern uint8_t vim_cmd_layer(void);
58
59extern uint16_t vstate;
60
61
62#endif
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-20 01:14:02 +0000