aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--common/action.c172
-rw-r--r--common/action.h148
-rw-r--r--common/command.c1
-rw-r--r--common/layer_switch.c90
-rw-r--r--common/layer_switch.h42
-rw-r--r--keyboard/gh60/config.h3
-rw-r--r--keyboard/gh60/keymap.c44
-rw-r--r--keyboard/hhkb/config.h3
8 files changed, 102 insertions, 401 deletions
diff --git a/common/action.c b/common/action.c
index 07a3a64d6..ef04851b1 100644
--- a/common/action.c
+++ b/common/action.c
@@ -56,7 +56,6 @@ void process_action(keyrecord_t *record)
56 56
57 action_t action = layer_switch_get_action(event.key); 57 action_t action = layer_switch_get_action(event.key);
58 debug("ACTION: "); debug_action(action); 58 debug("ACTION: "); debug_action(action);
59 debug(" overlays: "); overlay_debug();
60 debug(" keymaps: "); keymap_debug(); 59 debug(" keymaps: "); keymap_debug();
61 debug(" default_layer: "); debug_dec(default_layer); debug("\n"); 60 debug(" default_layer: "); debug_dec(default_layer); debug("\n");
62 61
@@ -199,31 +198,28 @@ void process_action(keyrecord_t *record)
199 } 198 }
200 break; 199 break;
201#endif 200#endif
202#ifndef NO_ACTION_KEYMAP 201#ifndef NO_ACTION_LAYER
203 case ACT_KEYMAP: 202 case ACT_LAYER:
203 case ACT_LAYER1:
204 switch (action.layer.code) { 204 switch (action.layer.code) {
205 /* Keymap clear */ 205 /* Keymap clear */
206 case OP_RESET: 206 case OP_RESET:
207 switch (action.layer.val & 0x03) { 207 switch (action.layer.val & 0x03) {
208 case 0: 208 case 0:
209 // NOTE: reserved 209 // NOTE: reserved
210 overlay_clear();
211 keymap_clear(); 210 keymap_clear();
212 break; 211 break;
213 case ON_PRESS: 212 case ON_PRESS:
214 if (event.pressed) { 213 if (event.pressed) {
215 overlay_clear();
216 keymap_clear(); 214 keymap_clear();
217 } 215 }
218 break; 216 break;
219 case ON_RELEASE: 217 case ON_RELEASE:
220 if (!event.pressed) { 218 if (!event.pressed) {
221 overlay_clear();
222 keymap_clear(); 219 keymap_clear();
223 } 220 }
224 break; 221 break;
225 case ON_BOTH: 222 case ON_BOTH:
226 overlay_clear();
227 keymap_clear(); 223 keymap_clear();
228 break; 224 break;
229 /* NOTE: 4-7 rserved */ 225 /* NOTE: 4-7 rserved */
@@ -362,161 +358,6 @@ void process_action(keyrecord_t *record)
362 } 358 }
363 break; 359 break;
364#endif 360#endif
365#ifndef NO_ACTION_OVERLAY
366 case ACT_OVERLAY:
367 switch (action.layer.code) {
368 // Overlay Invert bit4
369 case OP_INV4 | 0:
370 if (action.layer.val == 0) {
371 // NOTE: reserved for future use
372 overlay_clear();
373 } else {
374 overlay_set(overlay_stat ^ action.layer.val);
375 }
376 break;
377 case OP_INV4 | 1:
378 if (action.layer.val == 0) {
379 // on pressed
380 if (event.pressed) overlay_clear();
381 } else {
382 overlay_set(overlay_stat ^ action.layer.val<<4);
383 }
384 break;
385 case OP_INV4 | 2:
386 if (action.layer.val == 0) {
387 // on released
388 if (!event.pressed) overlay_clear();
389 } else {
390 overlay_set(overlay_stat ^ action.layer.val<<8);
391 }
392 break;
393 case OP_INV4 | 3:
394 if (action.layer.val == 0) {
395 // on both
396 overlay_clear();
397 } else {
398 overlay_set(overlay_stat ^ action.layer.val<<12);
399 }
400 break;
401
402 /* Overlay Bit invert */
403 case OP_INV:
404 /* with tap toggle */
405 if (event.pressed) {
406 if (tap_count < TAPPING_TOGGLE) {
407 debug("OVERLAY_INV: tap toggle(press).\n");
408 overlay_invert(action.layer.val);
409 }
410 } else {
411 if (tap_count <= TAPPING_TOGGLE) {
412 debug("OVERLAY_INV: tap toggle(release).\n");
413 overlay_invert(action.layer.val);
414 }
415 }
416 break;
417 case (OP_INV | ON_PRESS):
418 if (event.pressed) {
419 overlay_invert(action.layer.val);
420 }
421 break;
422 case (OP_INV | ON_RELEASE):
423 if (!event.pressed) {
424 overlay_invert(action.layer.val);
425 }
426 break;
427 case (OP_INV | ON_BOTH):
428 overlay_invert(action.layer.val);
429 break;
430
431 /* Overlay Bit on */
432 case OP_ON:
433 if (event.pressed) {
434 overlay_on(action.layer.val);
435 } else {
436 overlay_off(action.layer.val);
437 }
438 break;
439 case (OP_ON | ON_PRESS):
440 if (event.pressed) {
441 overlay_on(action.layer.val);
442 }
443 break;
444 case (OP_ON | ON_RELEASE):
445 if (!event.pressed) {
446 overlay_on(action.layer.val);
447 }
448 break;
449 case (OP_ON | ON_BOTH):
450 overlay_on(action.layer.val);
451 break;
452
453 /* Overlay Bit off */
454 case OP_OFF:
455 if (event.pressed) {
456 overlay_off(action.layer.val);
457 } else {
458 overlay_on(action.layer.val);
459 }
460 break;
461 case (OP_OFF | ON_PRESS):
462 if (event.pressed) {
463 overlay_off(action.layer.val);
464 }
465 break;
466 case (OP_OFF | ON_RELEASE):
467 if (!event.pressed) {
468 overlay_off(action.layer.val);
469 }
470 break;
471 case (OP_OFF | ON_BOTH):
472 overlay_off(action.layer.val);
473 break;
474
475 /* Overlay Bit set */
476 case OP_SET:
477 if (event.pressed) {
478 overlay_move(action.layer.val);
479 } else {
480 overlay_clear();
481 }
482 break;
483 case (OP_SET | ON_PRESS):
484 if (event.pressed) {
485 overlay_move(action.layer.val);
486 }
487 break;
488 case (OP_SET | ON_RELEASE):
489 if (!event.pressed) {
490 overlay_move(action.layer.val);
491 }
492 break;
493 case (OP_SET | ON_BOTH):
494 overlay_move(action.layer.val);
495 break;
496
497 /* Overlay Bit invert with tap key */
498 default:
499 if (event.pressed) {
500 if (tap_count > 0) {
501 debug("OVERLAY_TAP_KEY: Tap: register_code\n");
502 register_code(action.layer.code);
503 } else {
504 debug("OVERLAY_TAP_KEY: No tap: On on press\n");
505 overlay_on(action.layer.val);
506 }
507 } else {
508 if (tap_count > 0) {
509 debug("OVERLAY_TAP_KEY: Tap: unregister_code\n");
510 unregister_code(action.layer.code);
511 } else {
512 debug("OVERLAY_TAP_KEY: No tap: Off on release\n");
513 overlay_off(action.layer.val);
514 }
515 }
516 break;
517 }
518 break;
519#endif
520 /* Extentions */ 361 /* Extentions */
521#ifndef NO_ACTION_MACRO 362#ifndef NO_ACTION_MACRO
522 case ACT_MACRO: 363 case ACT_MACRO:
@@ -668,8 +509,7 @@ bool is_tap_key(key_t key)
668 case ACT_LMODS_TAP: 509 case ACT_LMODS_TAP:
669 case ACT_RMODS_TAP: 510 case ACT_RMODS_TAP:
670 return true; 511 return true;
671 case ACT_KEYMAP: 512 case ACT_LAYER:
672 case ACT_OVERLAY:
673 switch (action.layer.code) { 513 switch (action.layer.code) {
674 case 0x04 ... 0xEF: /* tap key */ 514 case 0x04 ... 0xEF: /* tap key */
675 case OP_INV: 515 case OP_INV:
@@ -714,8 +554,8 @@ void debug_action(action_t action)
714 case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break; 554 case ACT_RMODS_TAP: debug("ACT_RMODS_TAP"); break;
715 case ACT_USAGE: debug("ACT_USAGE"); break; 555 case ACT_USAGE: debug("ACT_USAGE"); break;
716 case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break; 556 case ACT_MOUSEKEY: debug("ACT_MOUSEKEY"); break;
717 case ACT_KEYMAP: debug("ACT_KEYMAP"); break; 557 case ACT_LAYER: debug("ACT_LAYER"); break;
718 case ACT_OVERLAY: debug("ACT_OVERLAY"); break; 558 case ACT_LAYER_BITOP: debug("ACT_LAYER_BITOP"); break;
719 case ACT_MACRO: debug("ACT_MACRO"); break; 559 case ACT_MACRO: debug("ACT_MACRO"); break;
720 case ACT_COMMAND: debug("ACT_COMMAND"); break; 560 case ACT_COMMAND: debug("ACT_COMMAND"); break;
721 case ACT_FUNCTION: debug("ACT_FUNCTION"); break; 561 case ACT_FUNCTION: debug("ACT_FUNCTION"); break;
diff --git a/common/action.h b/common/action.h
index a6cb45384..2c4f306a4 100644
--- a/common/action.h
+++ b/common/action.h
@@ -65,8 +65,8 @@ typedef union {
65 } key; 65 } key;
66 struct action_layer { 66 struct action_layer {
67 uint8_t code :8; 67 uint8_t code :8;
68 uint8_t val :4; 68 uint8_t val :5;
69 uint8_t kind :4; 69 uint8_t kind :3;
70 } layer; 70 } layer;
71 struct action_usage { 71 struct action_usage {
72 uint16_t code :10; 72 uint16_t code :10;
@@ -170,35 +170,42 @@ void debug_action(action_t action);
170 * 170 *
171 * Layer Actions(10XX) 171 * Layer Actions(10XX)
172 * ------------------- 172 * -------------------
173 * ACT_KEYMAP: 173 * ACT_LAYER:
174 * 1000|--xx|0000 0000 Clear keyamp and overlay 174 * 1000|--xx|0000 0000 Clear keyamp
175 * 1000|LLLL|0000 00xx Reset default layer and clear keymap and overlay 175 * 100X|LLLL|0000 00xx Reset default layer and clear keymap
176 * 1000|LLLL| keycode Invert with tap key 176 * 100X|LLLL| keycode Invert with tap key
177 * 1000|LLLL|1111 0000 Invert with tap toggle 177 * 100X|LLLL|1111 0000 Invert with tap toggle
178 * 1000|LLLL|1111 00xx Invert[^= 1<<L] 178 * 100X|LLLL|1111 00xx Invert[^= 1<<L]
179 * 1000|LLLL|1111 0100 On/Off 179 * 100X|LLLL|1111 0100 On/Off
180 * 1000|LLLL|1111 01xx On[|= 1<<L] 180 * 100X|LLLL|1111 01xx On[|= 1<<L]
181 * 1000|LLLL|1111 1000 Off/On 181 * 100X|LLLL|1111 1000 Off/On
182 * 1000|LLLL|1111 10xx Off[&= ~(1<<L)] 182 * 100X|LLLL|1111 10xx Off[&= ~(1<<L)]
183 * 1000|LLLL|1111 1100 Set/Clear 183 * 100X|LLLL|1111 1100 Set/Clear
184 * 1000|LLLL|1111 11xx Set[= 1<<L] 184 * 100X|LLLL|1111 11xx Set[= 1<<L]
185 * default layer: 0-15(4bit) 185 * XLLLL: Layer 0-31
186 * xx: On {00:for special use, 01:press, 10:release, 11:both} 186 * xx: On {00:for special use, 01:press, 10:release, 11:both}
187 * 187 *
188 * ACT_OVERLAY: 188 * ACT_LAYER_BITOP:
189 * 1011|0000|0000 0000 Clear overlay 189 * 101B|Booo|xxxx xxxx bit operation
190 * 1011|LLLL|0000 00ss Invert 4-bit chunk [^= L<<(4*ss)] 190 * BB: operand. which part of layer state bits
191 * 1011|LLLL| keycode Invert with tap key 191 * 00: 0-7th bit
192 * 1011|LLLL|1111 0000 Invert with tap toggle 192 * 01: 8-15th bit
193 * 1011|LLLL|1111 00xx Invert[^= 1<<L] 193 * 10: 16-23th bit
194 * 1011|LLLL|1111 0100 On/Off(momentary) 194 * 11: 24-31th bit
195 * 1011|LLLL|1111 01xx On[|= 1<<L] 195 * ooo: operation.
196 * 1011|LLLL|1111 1000 Off/On 196 * 000: AND
197 * 1011|LLLL|1111 10xx Off[&= ~(1<<L)] 197 * 001: OR
198 * 1011|LLLL|1111 1100 Set/Clear 198 * 010: XOR
199 * 1011|LLLL|1111 11xx Set[= 1<<L] 199 * 011:
200 * overlays: 16-layer on/off status(16bit) 200 * 100: LSHIFT
201 * xx: On {00:for special use, 01:press, 10:release, 11:both} 201 * 101: RSHIFT
202 * 110:
203 * 111:
204 * bbbb bbbb: bits
205 * layer_state |= (((layer_state>>(0bBB*8)) & 0xff) BITOP 0bxxxxxxxx)<<(0bBB*8)
206 * layer_state: 32-bit layer switch state
207 *
208 *
202 * 209 *
203 * 210 *
204 * Extensions(11XX) 211 * Extensions(11XX)
@@ -216,16 +223,20 @@ void debug_action(action_t action);
216 * 223 *
217 */ 224 */
218enum action_kind_id { 225enum action_kind_id {
226 ACT_MODS = 0b0000,
219 ACT_LMODS = 0b0000, 227 ACT_LMODS = 0b0000,
220 ACT_RMODS = 0b0001, 228 ACT_RMODS = 0b0001,
229 ACT_MODS_TAP = 0b0010,
221 ACT_LMODS_TAP = 0b0010, 230 ACT_LMODS_TAP = 0b0010,
222 ACT_RMODS_TAP = 0b0011, 231 ACT_RMODS_TAP = 0b0011,
223 232
224 ACT_USAGE = 0b0100, 233 ACT_USAGE = 0b0100,
225 ACT_MOUSEKEY = 0b0101, 234 ACT_MOUSEKEY = 0b0101,
226 235
227 ACT_KEYMAP = 0b1000, 236 ACT_LAYER = 0b1000,
228 ACT_OVERLAY = 0b1001, 237 ACT_LAYER1 = 0b1001,
238 ACT_LAYER_BITOP = 0b1010,
239 ACT_LAYER1_BITOP = 0b1011,
229 240
230 ACT_MACRO = 0b1100, 241 ACT_MACRO = 0b1100,
231 ACT_COMMAND = 0b1110, 242 ACT_COMMAND = 0b1110,
@@ -285,12 +296,14 @@ enum usage_pages {
285 * Set layer = (1<<layer) 296 * Set layer = (1<<layer)
286 * Clear layer = 0 297 * Clear layer = 0
287 */ 298 */
288enum layer_params { 299enum layer_param_on {
289 ON_PRESS = 1, 300 ON_PRESS = 1,
290 ON_RELEASE = 2, 301 ON_RELEASE = 2,
291 ON_BOTH = 3, 302 ON_BOTH = 3,
303};
292 304
293 OP_RESET = 0x00, 305enum layer_pram_op {
306 OP_RESET = 0x00,
294 OP_INV4 = 0x00, 307 OP_INV4 = 0x00,
295 OP_INV = 0xF0, 308 OP_INV = 0xF0,
296 OP_ON = 0xF4, 309 OP_ON = 0xF4,
@@ -298,56 +311,49 @@ enum layer_params {
298 OP_SET = 0xFC, 311 OP_SET = 0xFC,
299}; 312};
300 313
314enum layer_pram_bitop {
315 BITOP_AND,
316 BITOP_OR,
317 BITOP_XOR,
318 BITOP_LSHIFT,
319 BITOP_RSHIFT,
320};
321
301/* 322/*
302 * Default Layer 323 * Default Layer
303 */ 324 */
304#define ACTION_DEFAULT_LAYER ACTION(ACT_KEYMAP, ON_RELEASE<<8 | OP_RESET | 0) 325#define ACTION_DEFAULT_LAYER ACTION(ACT_LAYER, ON_RELEASE<<8 | OP_RESET | 0)
305#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_TO(layer, ON_RELEASE) 326#define ACTION_DEFAULT_LAYER_SET(layer) ACTION_DEFAULT_LAYER_TO(layer, ON_RELEASE)
306#define ACTION_DEFAULT_LAYER_TO(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | (on)) 327#define ACTION_DEFAULT_LAYER_TO(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_RESET | (on))
328
307/* 329/*
308 * Keymap Layer 330 * Keymap Layer
309 */ 331 */
310#define ACTION_KEYMAP_MOMENTARY(layer) ACTION_KEYMAP_ON_OFF(layer) 332#define ACTION_LAYER_MOMENTARY(layer) ACTION_LAYER_ON_OFF(layer)
311#define ACTION_KEYMAP_TOGGLE(layer) ACTION_KEYMAP_INV(layer, ON_RELEASE) 333#define ACTION_LAYER_TOGGLE(layer) ACTION_LAYER_INV(layer, ON_RELEASE)
312/* Keymap Invert */ 334/* Keymap Invert */
313#define ACTION_KEYMAP_INV(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | (on)) 335#define ACTION_LAYER_INV(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_INV | (on))
314#define ACTION_KEYMAP_TAP_TOGGLE(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | 0) 336#define ACTION_LAYER_TAP_TOGGLE(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_INV | 0)
315/* Keymap On */ 337/* Keymap On */
316#define ACTION_KEYMAP_ON(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | (on)) 338#define ACTION_LAYER_ON(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_ON | (on))
317#define ACTION_KEYMAP_ON_OFF(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON | 0) 339#define ACTION_LAYER_ON_OFF(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_ON | 0)
318/* Keymap Off */ 340/* Keymap Off */
319#define ACTION_KEYMAP_OFF(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | (on)) 341#define ACTION_LAYER_OFF(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_OFF | (on))
320#define ACTION_KEYMAP_OFF_ON(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | 0) 342#define ACTION_LAYER_OFF_ON(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_OFF | 0)
321/* Keymap Set */ 343/* Keymap Set */
322#define ACTION_KEYMAP_SET(layer, on) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | (on)) 344#define ACTION_LAYER_SET(layer, on) ACTION(ACT_LAYER, (layer)<<8 | OP_SET | (on))
323#define ACTION_KEYMAP_SET_CLEAR(layer) ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | 0) 345#define ACTION_LAYER_SET_CLEAR(layer) ACTION(ACT_LAYER, (layer)<<8 | OP_SET | 0)
324/* Keymap Invert with tap key */ 346/* Keymap Invert with tap key */
325#define ACTION_KEYMAP_TAP_KEY(layer, key) ACTION(ACT_KEYMAP, (layer)<<8 | (key)) 347#define ACTION_LAYER_TAP_KEY(layer, key) ACTION(ACT_LAYER, (layer)<<8 | (key))
326 348
327/* 349/* Layer BitOp: 101|BB|ooo|xxxxxxxx */
328 * Overlay Layer 350#define ACTION_LAYER_BITOP(op, part, bits) (ACT_LAYER_BITOP<<12 | (part&0x3)<<11 | (op&0x7)<<8 | bits)
329 */ 351#define ACTION_LAYER_AND(part, bits) ACTION_LAYER_BITOP(BITOP_AND, part, bits)
330#define ACTION_OVERLAY_MOMENTARY(layer) ACTION_OVERLAY_ON_OFF(layer) 352#define ACTION_LAYER_OR(part, bits) ACTION_LAYER_BITOP(BITOP_OR, part, bits)
331#define ACTION_OVERLAY_TOGGLE(layer) ACTION_OVERLAY_INV(layer, ON_RELEASE) 353#define ACTION_LAYER_XOR(part, bits) ACTION_LAYER_BITOP(BITOP_XOR, part, bits)
332/* Overlay Clear */ 354#define ACTION_LAYER_LSHIFT(part, bits) ACTION_LAYER_BITOP(BITOP_LSHIFT, part, bits)
333#define ACTION_OVERLAY_CLEAR(on) ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | (on)) 355#define ACTION_LAYER_RSHIFT(part, bits) ACTION_LAYER_BITOP(BITOP_RSHIFT, part, bits)
334/* Overlay Invert 4-bit chunk */ 356
335#define ACTION_OVERLAY_INV4(bits, shift) ACTION(ACT_OVERLAY, (bits)<<8 | OP_INV4 | shift)
336/* Overlay Invert */
337#define ACTION_OVERLAY_INV(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | (on))
338#define ACTION_OVERLAY_TAP_TOGGLE(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | 0)
339/* Overlay On */
340#define ACTION_OVERLAY_ON(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | (on))
341#define ACTION_OVERLAY_ON_OFF(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON | 0)
342/* Overlay Off */
343#define ACTION_OVERLAY_OFF(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | (on))
344#define ACTION_OVERLAY_OFF_ON(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | 0)
345/* Overlay Set */
346#define ACTION_OVERLAY_SET(layer, on) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | (on))
347#define ACTION_OVERLAY_SET_CLEAR(layer) ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | 0)
348/* Overlay Invert with tap key */
349#define ACTION_OVERLAY_TAP_KEY(layer, key) ACTION(ACT_OVERLAY, (layer)<<8 | (key))
350
351 357
352/* 358/*
353 * Extensions 359 * Extensions
diff --git a/common/command.c b/common/command.c
index b29333883..e197a8f80 100644
--- a/common/command.c
+++ b/common/command.c
@@ -575,6 +575,5 @@ static void switch_default_layer(uint8_t layer)
575{ 575{
576 print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n"); 576 print("switch_default_layer: "); print_dec(default_layer); print(" to "); print_dec(layer); print("\n");
577 default_layer_set(layer); 577 default_layer_set(layer);
578 overlay_clear();
579 clear_keyboard(); 578 clear_keyboard();
580} 579}
diff --git a/common/layer_switch.c b/common/layer_switch.c
index a5d426a89..359e6b9d8 100644
--- a/common/layer_switch.c
+++ b/common/layer_switch.c
@@ -24,7 +24,7 @@ void default_layer_set(uint8_t layer)
24} 24}
25 25
26 26
27#ifndef NO_ACTION_KEYMAP 27#ifndef NO_ACTION_LAYER
28/* 28/*
29 * Keymap Layer (0-15) 29 * Keymap Layer (0-15)
30 */ 30 */
@@ -100,98 +100,12 @@ void keymap_debug(void)
100 100
101 101
102 102
103#ifndef NO_ACTION_OVERLAY
104/*
105 * Overlay Layer (16-31 = 0-15|0x10)
106 */
107uint16_t overlay_stat = 0;
108
109/* return highest layer whose state is on */
110uint8_t overlay_get_layer(void)
111{
112 return biton16(overlay_stat);
113}
114
115static void overlay_stat_set(uint16_t stat)
116{
117 debug("overlay: ");
118 overlay_debug(); debug(" to ");
119
120 overlay_stat = stat;
121
122 overlay_debug(); debug("\n");
123
124 clear_keyboard_but_mods(); // To avoid stuck keys
125}
126
127void overlay_clear(void)
128{
129 overlay_stat_set(0);
130}
131
132
133void overlay_set(uint16_t stat)
134{
135 overlay_stat_set(stat);
136}
137
138void overlay_move(uint8_t layer)
139{
140 overlay_stat_set(1<<layer);
141}
142
143void overlay_on(uint8_t layer)
144{
145 overlay_stat_set(overlay_stat | (1<<layer));
146}
147
148void overlay_off(uint8_t layer)
149{
150 overlay_stat_set(overlay_stat & ~(1<<layer));
151}
152
153void overlay_invert(uint8_t layer)
154{
155 overlay_stat_set(overlay_stat ^ (1<<layer));
156}
157
158void overlay_or(uint16_t stat)
159{
160 overlay_stat_set(overlay_stat | stat);
161}
162void overlay_and(uint16_t stat)
163{
164 overlay_stat_set(overlay_stat & stat);
165}
166void overlay_xor(uint16_t stat)
167{
168 overlay_stat_set(overlay_stat ^ stat);
169}
170
171void overlay_debug(void)
172{
173 debug_hex16(overlay_stat); debug("("); debug_dec(overlay_get_layer()); debug(")");
174}
175#endif
176
177action_t layer_switch_get_action(key_t key) 103action_t layer_switch_get_action(key_t key)
178{ 104{
179 action_t action; 105 action_t action;
180 action.code = ACTION_TRANSPARENT; 106 action.code = ACTION_TRANSPARENT;
181 107
182#ifndef NO_ACTION_OVERLAY 108#ifndef NO_ACTION_LAYER
183 /* overlay: top layer first */
184 for (int8_t i = 15; i >= 0; i--) {
185 if (overlay_stat & (1<<i)) {
186 action = action_for_key(i | OVERLAY_BIT, key);
187 if (action.code != ACTION_TRANSPARENT) {
188 return action;
189 }
190 }
191 }
192#endif
193
194#ifndef NO_ACTION_KEYMAP
195 /* keymap: top layer first */ 109 /* keymap: top layer first */
196 for (int8_t i = 15; i >= 0; i--) { 110 for (int8_t i = 15; i >= 0; i--) {
197 if (keymap_stat & (1<<i)) { 111 if (keymap_stat & (1<<i)) {
diff --git a/common/layer_switch.h b/common/layer_switch.h
index eb4cf61ba..423dafb5b 100644
--- a/common/layer_switch.h
+++ b/common/layer_switch.h
@@ -22,11 +22,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
22#include "action.h" 22#include "action.h"
23 23
24 24
25/* overlays are asigned at layer 16-31 */
26#define OVERLAY_BIT 0x10
27#define OVERLAY_MASK 0x0F
28
29
30/* 25/*
31 * Default Layer 26 * Default Layer
32 */ 27 */
@@ -38,7 +33,7 @@ void default_layer_set(uint8_t layer);
38/* 33/*
39 * Keymap Layer 34 * Keymap Layer
40 */ 35 */
41#ifndef NO_ACTION_KEYMAP 36#ifndef NO_ACTION_LAYER
42extern uint16_t keymap_stat; 37extern uint16_t keymap_stat;
43/* return current active layer */ 38/* return current active layer */
44uint8_t keymap_get_layer(void); 39uint8_t keymap_get_layer(void);
@@ -69,41 +64,6 @@ void keymap_debug(void);
69#endif 64#endif
70 65
71 66
72/*
73 * Overlay Layer
74 */
75#ifndef NO_ACTION_OVERLAY
76extern uint16_t overlay_stat;
77/* return current active layer */
78uint8_t overlay_get_layer(void);
79void overlay_clear(void);
80void overlay_set(uint16_t stat);
81void overlay_move(uint8_t layer);
82void overlay_on(uint8_t layer);
83void overlay_off(uint8_t layer);
84void overlay_invert(uint8_t layer);
85/* bitwise operation */
86void overlay_or(uint16_t stat);
87void overlay_and(uint16_t stat);
88void overlay_xor(uint16_t stat);
89void overlay_debug(void);
90#else
91#define overlay_stat 0
92#define overlay_get_layer()
93#define overlay_clear()
94#define overlay_set(stat)
95#define overlay_move(layer)
96#define overlay_on(layer)
97#define overlay_off(layer)
98#define overlay_invert(layer)
99#define overlay_or(stat)
100#define overlay_and(stat)
101#define overlay_xor(stat)
102#define overlay_debug()
103#endif
104
105
106
107/* return action depending on current layer status */ 67/* return action depending on current layer status */
108action_t layer_switch_get_action(key_t key); 68action_t layer_switch_get_action(key_t key);
109 69
diff --git a/keyboard/gh60/config.h b/keyboard/gh60/config.h
index fbe587081..567b126b6 100644
--- a/keyboard/gh60/config.h
+++ b/keyboard/gh60/config.h
@@ -61,8 +61,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
61//#define NO_PRINT 61//#define NO_PRINT
62 62
63/* disable action features */ 63/* disable action features */
64//#define NO_ACTION_KEYMAP 64//#define NO_ACTION_LAYER
65//#define NO_ACTION_OVERLAY
66//#define NO_ACTION_TAPPING 65//#define NO_ACTION_TAPPING
67//#define NO_ACTION_ONESHOT 66//#define NO_ACTION_ONESHOT
68//#define NO_ACTION_MACRO 67//#define NO_ACTION_MACRO
diff --git a/keyboard/gh60/keymap.c b/keyboard/gh60/keymap.c
index d6af16961..2f41ad4fd 100644
--- a/keyboard/gh60/keymap.c
+++ b/keyboard/gh60/keymap.c
@@ -91,7 +91,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
91 ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ 91 ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \
92 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \ 92 TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \
93 LCTL,A, S, D, F, G, H, J, K, L, FN2, QUOT, ENT, \ 93 LCTL,A, S, D, F, G, H, J, K, L, FN2, QUOT, ENT, \
94 LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, RSFT, \ 94 LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN1, FN9, \
95 LCTL,LGUI,LALT, SPC, RALT,FN3, FN3, FN0), 95 LCTL,LGUI,LALT, SPC, RALT,FN3, FN3, FN0),
96 /* Keymap 1: colemak */ 96 /* Keymap 1: colemak */
97 KEYMAP_ANSI( 97 KEYMAP_ANSI(
@@ -198,54 +198,38 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
198 TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), 198 TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS),
199}; 199};
200 200
201static const uint8_t PROGMEM overlays[][MATRIX_ROWS][MATRIX_COLS] = {};
202
203/* 201/*
204 * Fn action definition 202 * Fn action definition
205 */ 203 */
206static const uint16_t PROGMEM fn_actions[] = { 204static const uint16_t PROGMEM fn_actions[] = {
207 [0] = ACTION_KEYMAP_MOMENTARY(4), 205 [0] = ACTION_LAYER_MOMENTARY(4),
208 [1] = ACTION_KEYMAP_TAP_KEY(5, KC_SLASH), 206 [1] = ACTION_LAYER_TAP_KEY(5, KC_SLASH),
209 [2] = ACTION_KEYMAP_TAP_KEY(6, KC_SCLN), 207 [2] = ACTION_LAYER_TAP_KEY(6, KC_SCLN),
210 [3] = ACTION_KEYMAP_MOMENTARY(6), 208 [3] = ACTION_LAYER_MOMENTARY(6),
211 [4] = ACTION_KEYMAP_MOMENTARY(7), // to Layout selector 209 [4] = ACTION_LAYER_MOMENTARY(7), // to Layout selector
212 [5] = ACTION_DEFAULT_LAYER_SET(0), // set qwerty layout 210 [5] = ACTION_DEFAULT_LAYER_SET(0), // set qwerty layout
213 [6] = ACTION_DEFAULT_LAYER_SET(1), // set colemak layout 211 [6] = ACTION_DEFAULT_LAYER_SET(1), // set colemak layout
214 [7] = ACTION_DEFAULT_LAYER_SET(2), // set dvorak layout 212 [7] = ACTION_DEFAULT_LAYER_SET(2), // set dvorak layout
215 [8] = ACTION_DEFAULT_LAYER_SET(3), // set workman layout 213 [8] = ACTION_DEFAULT_LAYER_SET(3), // set workman layout
214 [9] = ACTION_RMOD_TAP_KEY(KC_RSFT, KC_GRV),
216}; 215};
217#endif 216#endif
218 217
219 218
220 219
221#define KEYMAPS_SIZE (sizeof(keymaps) / sizeof(keymaps[0])) 220#define KEYMAPS_SIZE (sizeof(keymaps) / sizeof(keymaps[0]))
222#define OVERLAYS_SIZE (sizeof(overlays) / sizeof(overlays[0]))
223#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0])) 221#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))
224 222
225/* translates key to keycode */ 223/* translates key to keycode */
226uint8_t keymap_key_to_keycode(uint8_t layer, key_t key) 224uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
227{ 225{
228 /* Overlay: 16-31(OVERLAY_BIT(0x10) | overlay_layer) */ 226 if (layer < KEYMAPS_SIZE) {
229 if (layer & OVERLAY_BIT) { 227 return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
230 layer &= OVERLAY_MASK; 228 } else {
231 if (layer < OVERLAYS_SIZE) { 229 // XXX: this may cuaes bootlaoder_jump inconsistent fail.
232 return pgm_read_byte(&overlays[(layer)][(key.row)][(key.col)]); 230 //debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n");
233 } else { 231 // fall back to layer 0
234 // XXX: this may cuaes bootlaoder_jump incositent fail. 232 return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
235 //debug("key_to_keycode: overlay "); debug_dec(layer); debug(" is invalid.\n");
236 return KC_TRANSPARENT;
237 }
238 }
239 /* Keymap: 0-15 */
240 else {
241 if (layer < KEYMAPS_SIZE) {
242 return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
243 } else {
244 // XXX: this may cuaes bootlaoder_jump incositent fail.
245 //debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n");
246 // fall back to layer 0
247 return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
248 }
249 } 233 }
250} 234}
251 235
diff --git a/keyboard/hhkb/config.h b/keyboard/hhkb/config.h
index 6e26edbef..9df86126e 100644
--- a/keyboard/hhkb/config.h
+++ b/keyboard/hhkb/config.h
@@ -74,8 +74,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
74//#define NO_PRINT 74//#define NO_PRINT
75 75
76/* disable action features */ 76/* disable action features */
77//#define NO_ACTION_KEYMAP 77//#define NO_ACTION_LAYER
78//#define NO_ACTION_OVERLAY
79//#define NO_ACTION_TAPPING 78//#define NO_ACTION_TAPPING
80//#define NO_ACTION_ONESHOT 79//#define NO_ACTION_ONESHOT
81//#define NO_ACTION_MACRO 80//#define NO_ACTION_MACRO
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-21 18:39:33 +0000