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