darkkirb/qmk_firmware
1
0
Fork 0
forked from mirrors/qmk_firmware
Code Issues Pull requests Projects Releases Packages Wiki Activity

Bocaj - Third Annual Refactor (Redux) (#10295)

Browse source 
* Reset everything to upstream, reapply Bocaj changes

* Bocaj - address PR comments

* Just in time changes

* Bocaj - Several adjustments after using the layout for a while
This commit is contained in:
Jacob Jerrell 2020-12-06 00:30:27 -06:00 committed by GitHub
parent 6b1f96dca8
commit 3076f86dc1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
24 changed files with 1418 additions and 1007 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
layouts/community/ergodox/bocaj/config.h
View file

@ -1,6 +1,4 @@
#pragma once
#include QMK_KEYBOARD_CONFIG_H
#define LEADER_TIMEOUT 250
#define LEADER_PER_KEY_TIMING

311
layouts/community/ergodox/bocaj/keymap.c
View file

@ -1,5 +1,5 @@
/*
Copyright 2018 Jacob Jerrell <jacob.jerrell@gmail.com> @JacobJerrell
Copyright 2020 Jacob Jerrell <jacob.jerrell@gmail.com> @JacobJerrell
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -15,182 +15,161 @@ You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
#include "bocaj.h"
#define LAYOUT_ergodox_pretty_base( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \
) \
LAYOUT_ergodox_pretty_wrapper( \
KC_ESC, __________________NUMBER_LEFT_______________, JJ_ARRW, KC_MINS, __________________NUMBER_RIGHT______________, KC_EQUAL, \
KC_DEL, K01, K02, K03, K04, K05, KC_LPRN, KC_RPRN, K06, K07, K08, K09, K0A, KC_BSLASH, \
KC_NUMS, K11, SFT_T(K12), K13, ALT_T(K14), K15, K16, ALT_T(K17), K18, SFT_T(K19), K1A, KC_QUOT, \
OS_LSFT, CTL_T(K21), K22, K23, K24, K25, HYP_LBK, MEH_RBK, K26, K27, K28, K29, CTL_T(K2A), KC_RSFT, \
KC_GAME,KC_NUMS, TT(_LOWER), KC_UP, KC_LEFT, KC_RIGHT, KC_DOWN, UC_DISA,KC_GAME, KC_ADJS, \
KC_APP,KC_HOME, KC_END,KC_ESC, \
UC_FLIP, UC_TABL, \
KC_SPACE,KC_BSPACE,KC_LEAD, UC_SHRG,KC_TAB,KC_LWEN \
)
#define LAYOUT_ergodox_pretty_base_wrapper(...) LAYOUT_ergodox_pretty_base(__VA_ARGS__)
/*
* The `LAYOUT_ergodox_pretty_base` macro is a template to allow the use of
* identical modifiers for the default layouts (eg QWERTY, Colemak, Dvorak,
* etc), so that there is no need to set them up for each layout, and modify
* all of them if I want to change them. This helps to keep consistency and
* ease of use. K## is a placeholder to pass through the individual keycodes
*/
#define LAYOUT_ergodox_bocaj(...) WRAPPER_ergodox_bocaj(__VA_ARGS__)
#define LAYOUT_ergodox_bocaj_WIN(...) WRAPPER_ergodox_bocaj_WIN(__VA_ARGS__)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Workman - http://www.keyboard-layout-editor.com/#/gists/7a07cb982ec3597ba3e3d947554225f1
.---------------------------------------------. .---------------------------------------------.
| ESC | 1 | 2 | 3 | 4 | 5 | -> | ! - | 6 | 7 | 8 | 9 | 0 | = |
!-------+-----+-----+-----+-----+-------------! !-------+-----+-----+-----+-----+-----+-------!
| DEL | Q | D | R | W | B | ( | ! ) | J | F | U | P | ; | \ |
!-------+-----+-----+-----x-----x-----! ! ! !-----x-----x-----+-----+-----+-------!
| NUMS | A | S | H | T | G |-------! !-------! Y | N | E | O | I | ' |
!-------+-----+-----+-----x-----x-----! HYP ! ! MEH !-----x-----x-----+-----+-----+-------!
| SHIFT | Z | X | M | C | V | [ | ! ] | K | L | , | . | / | SHIFT |
'-------+-----+-----+-----+-----+-------------' '-------------+-----+-----+-----+-----+-------'
| | NUM | LWR | UP | LFT | .---------------. .---------------. ! RGT | DWN | |GAME | ADJ |
'------------------------------' | APP | HOME | ! PGUP | ESC | '------------------------------'
.-------+-------+-------! !-------+-------+-------.
! ! | END | ! PGDN | ! ENTER !
! SPACE ! BSPCE !-------! !-------! TAB ! / !
| | | COPY | ! PASTE | | LOWER |
'-----------------------' '-----------------------'
*/
[_WORKMAN] = LAYOUT_ergodox_pretty_base_wrapper(
_________________WORKMAN_L1_________________, _________________WORKMAN_R1_________________,
_________________WORKMAN_L2_________________, _________________WORKMAN_R2_________________,
_________________WORKMAN_L3_________________, _________________WORKMAN_R3_________________
),
[_WINWORKMAN] = LAYOUT_ergodox_pretty_base_wrapper(
_________________WORKMAN_L1_________________, _________________WORKMAN_R1_________________,
________________WWORKMAN_L2_________________, ________________WWORKMAN_R2_________________,
_________________WORKMAN_L3_________________, _________________WORKMAN_R3_________________
),
/* QWERTY - http://www.keyboard-layout-editor.com/#/gists/b6c016a22a9d31381a276a603a42fe5f
.---------------------------------------------. .---------------------------------------------.
| ESC | 1 | 2 | 3 | 4 | 5 | -> | ! - | 6 | 7 | 8 | 9 | 0 | = |
!-------+-----+-----+-----+-----+-------------! !-------+-----+-----+-----+-----+-----+-------!
| DEL | Q | W | E | R | T | ( | ! ) | Y | U | I | O | P | \ |
!-------+-----+-----+-----x-----x-----! ! ! !-----x-----x-----+-----+-----+-------!
| NUMS | A | S | D | F | G |-------! !-------! H | J | K | L | ; | ' |
!-------+-----+-----+-----x-----x-----! HYP ! ! MEH !-----x-----x-----+-----+-----+-------!
| SHIFT | Z | X | C | V | B | [ | ! ] | N | M | , | . | / | SHIFT |
'-------+-----+-----+-----+-----+-------------' '-------------+-----+-----+-----+-----+-------'
| GAME | NUM | LWR | UP | LFT | .---------------. .---------------. ! RGT | DWN | | | ADJ |
'------------------------------' | APP | HOME | ! PGUP | ESC | '------------------------------'
.-------+-------+-------! !-------+-------+-------.
! ! | END | ! PGDN | ! ENTER !
! SPACE ! BSPCE !-------! !-------! TAB ! / !
| | | COPY | ! PASTE | | LOWER |
'-----------------------' '-----------------------'
*/
[_QWERTY] = LAYOUT_ergodox_pretty_base_wrapper(
_________________QWERTY_L1__________________, _________________QWERTY_R1__________________,
_________________QWERTY_L2__________________, _________________QWERTY_R2__________________,
_________________QWERTY_L3__________________, _________________QWERTY_R3__________________
),
[_LOWER] = LAYOUT_ergodox_pretty_wrapper(
KC_F11 ,__________________FUNCTION_LEFT_____________, _______, _______, __________________FUNCTION_RIGHT____________, KC_F12,
_______, _______, _______, KC_UP, _______, _______, _______, _______, _______, KC_7, KC_8, KC_9, KC_PAST, _______,
LM_GRAVE, _______, KC_LEFT, KC_DOWN,KC_RIGHT, _______, _______, KC_4, KC_5, KC_6, KC_PPLS, _______,
OS_LSFT,____________________BLANK___________________, _______, _______, _______, KC_1, KC_2, KC_3, KC_PMNS, _______,
____________________BLANK___________________, KC_0, KC_PDOT, KC_COMM,KC_PEQL, _______,
_______, _______, _______, _______,
_______, _______,
_______, _______, _______, _______, _______, _______
),
/* Adjust - http://www.keyboard-layout-editor.com/#/gists/dedeae17b35a5d5f745a42aaea78f007
.---------------------------------------------. .---------------------------------------------.
| MAKE | | | | | | RESET | ! EPRM | | | | | | |
!-------+-----+-----+-----+-----+-------------! !-------+-----+-----+-----+-----+-----+-------!
| | | | | | | | ! | | | | | | |
!-------+-----+-----+-----x-----x-----! ! ! !-----x-----x-----+-----+-----+-------!
| | 🔇 | 🔉 | 🔊 | LCK | |-------! !-------! | | | | | QWRTY |
!-------+-----+-----+-----x-----x-----! ! ! !-----x-----x-----+-----+-----+-------!
| | | | | | | | ! | | | | | WIN | WRKMN |
'-------+-----+-----+-----+-----+-------------' '-------------+-----+-----+-----+-----+-------'
| | | | | | .---------------. .---------------. ! | | | | |
'------------------------------' | | | ! | | '------------------------------'
.-------+-------+-------! !-------+-------+-------.
! ! | | ! | ! !
! ! !-------! !-------! ! !
| | | | ! | | |
'-----------------------' '-----------------------'
*/
[_ADJUST] = LAYOUT_ergodox_pretty_wrapper(
KC_MAKE, ____________________BLANK___________________, KC_RST, KC_EPRM, ____________________BLANK___________________, XXXXXXX,
_______, ____________________BLANK___________________, _______, _______, ____________________BLANK___________________, XXXXXXX,
_______,KC__MUTE,KC__VOLDOWN,KC__VOLUP,MC_LOCK,_______, ____________________BLANK___________________, KC_MQWR,
_______, ____________________BLANK___________________, _______, _______, _______, _______, _______, _______, KC_WWRK, KC_MWRK,
____________________BLANK___________________, ____________________BLANK___________________,
_______, _______, _______, _______,
_______, _______,
_______, _______, _______, _______, _______, _______
),
[_DIABLO] = LAYOUT_ergodox_pretty_wrapper(
KC_ESC, KC_V, KC_D, KC_LALT, KC_NO, KC_NO, KC_NO, KC_NO, KC_F9, KC_F10, KC_F11, KC_F12, KC_NO, KC_NO,
KC_TAB, KC_S, KC_F, KC_I, KC_M, KC_T, KC_ENTER, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
KC_Q, KC_1, KC_2, KC_3, KC_4, KC_P, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
KC_LCTL, KC_D3_1, KC_D3_2, KC_D3_3, KC_D3_4, KC_Z, KC_LOCK, KC_NO, KC_N, KC_M, KC_NO, KC_NO, KC_NO, KC_NO,
_______, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, KC_NO,
KC_L, KC_J, KC_NO, KC_NO,
KC_F, KC_NO,
SFT_T(KC_SPACE), ALT_T(KC_Q), KC_DCLR, KC_PGDN, KC_DEL, KC_ENT
)
[_WORKMAN] = LAYOUT_ergodox_bocaj(
KC_ESC, ________________NUMBER_LEFT________________, KC_ARRW, KC_MINS, ________________NUMBER_RIGHT_______________, KC_EQUAL,
KC_DEL, _________________WORKMAN_L1________________, KC_LPRN, KC_RPRN, _________________WORKMAN_R1________________, KC_BSLS,
_______, _________________WORKMAN_L2________________, _________________WORKMAN_R2________________, KC_QUOT,
KC_LSFT, _________________WORKMAN_L3________________, KC_LBRC, KC_RBRC, _________________WORKMAN_R3________________, _______,
MO_MOD, KC_PGUP, KC_HOME, KC_UP, KC_LEFT, KC_RIGHT, KC_DOWN, KC_END, KC_PGDN, WORKMAN,
KC_APP,KC_HOME, /* <- LHS/RHS -> */ KC_END,KC_ESC,
KC_PGUP, /* <- LHS/RHS -> */ KC_PGDN,
KC_SPACE,KC_BSPACE,KC_LEAD, /* <- LHS/RHS -> */ KC_LOCK,KC_TAB,KC_ENTER
),
[_WWORKMAN] = LAYOUT_ergodox_bocaj_WIN(
KC_ESC, ________________NUMBER_LEFT________________, KC_ARRW, KC_MINS, ________________NUMBER_RIGHT_______________, KC_EQUAL,
KC_DEL, _________________WORKMAN_L1________________, KC_LPRN, KC_RPRN, _________________WORKMAN_R1________________, KC_BSLS,
_______, _________________WORKMAN_L2________________, _________________WORKMAN_R2________________, KC_QUOT,
KC_LSFT, _________________WORKMAN_L3________________, KC_LBRC, KC_RBRC, _________________WORKMAN_R3________________, _______,
MO_MOD, KC_PGUP, KC_HOME, KC_UP, KC_LEFT, KC_RIGHT, KC_DOWN, KC_END, KC_PGDN, WORKMAN,
KC_APP,KC_HOME, /* <- LHS/RHS -> */ KC_END,KC_ESC,
KC_PGUP, /* <- LHS/RHS -> */ KC_PGDN,
KC_SPACE,KC_BSPACE,KC_LEAD, /* <- LHS/RHS -> */ KC_LOCK,KC_TAB,KC_ENTER
),
[_LOWER] = LAYOUT_ergodox_bocaj(
KC_GRV, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, KC_UP, _______, _______, _______, _______, _______, KC_7, KC_8, KC_9, KC_BSLS, _______,
_______, _______, KC_LEFT, KC_DOWN, KC_RIGHT, _______, _______, KC_4, KC_5, KC_6, KC_ASTR, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, KC_1, KC_2, KC_3, KC_PLUS, _______,
_______, _______, _______, _______, _______, KC_0, KC_DOT, KC_COMM, KC_MINS, _______,
KC_APP,KC_HOME, /* <- LHS/RHS -> */ KC_END,KC_ESC,
KC_PGUP, /* <- LHS/RHS -> */ KC_PGDN,
KC_SPACE,KC_BSPACE,KC_LEAD, /* <- LHS/RHS -> */ KC_LOCK,KC_TAB,KC_ENTER
),
[_RAISE] = LAYOUT_ergodox_bocaj(
KC_TILD, _________________RAISE_L1__________________, _______, _______, _________________RAISE_R1__________________, _______,
KC_F11, _________________RAISE_L2__________________, _______, _______, _________________RAISE_R2__________________, KC_F12,
_______, _________________RAISE_L3__________________, _________________RAISE_R3__________________, _______,
_______, _______, KC_MRWD, KC_MPLY, KC_MFFD, _______, _______, _______, ___________________BLANK___________________, _______,
___________________BLANK___________________, ___________________BLANK___________________,
KC_APP,KC_HOME, /* <- LHS/RHS -> */ KC_END,KC_ESC,
KC_PGUP, /* <- LHS/RHS -> */ KC_PGDN,
KC_SPACE,KC_BSPACE,KC_LEAD, /* <- LHS/RHS -> */ KC_LOCK,KC_TAB,KC_ENTER
),
[_ADJUST] = LAYOUT_ergodox_pretty(
KC_MAKE, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_RST,
VRSN, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, EEP_RST,
_______, KC__MUTE, KC__VOLDOWN, KC__VOLUP, _______, KC_MNXT, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
KC_APP,KC_HOME, /* <- LHS/RHS -> */ KC_END,KC_ESC,
KC_PGUP, /* <- LHS/RHS -> */ KC_PGDN,
KC_SPACE,KC_BSPACE,KC_LEAD, /* <- LHS/RHS -> */ KC_LOCK,KC_TAB,KC_ENTER
),
// Wrapping Mouse-Wheel Keys with `X_T()` style functions seems
// to break the mouse button. So we can't use the wrapper here.
[_MOD] = LAYOUT_ergodox_pretty(
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, KC_WH_D, _______, _______, _______, _______, _______, _______, KC_MS_U, _______, _______, _______,
_______, _______, KC_WH_L, KC_WH_U, KC_WH_R, _______, _______, KC_MS_L, KC_MS_D, KC_MS_R, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, KC_ACL0, KC_ACL1, KC_ACL2, _______, _______, _______,
_______,_______, /* <- LHS/RHS -> */ _______,_______,
_______, /* <- LHS/RHS -> */ _______,
KC_BTN1,KC_BTN2,_______, /* <- LHS/RHS -> */ _______,KC_BTN3,KC_BTN4
)
};
// clang-format on
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
return true;
return true;
}
void matrix_init_keymap(void) {};
void matrix_scan_keymap(void) {
uint8_t modifiers = get_mods();
uint8_t led_usb_state = host_keyboard_leds();
uint8_t one_shot = get_oneshot_mods();
uint8_t layer = biton32(layer_state);
// Runs whenever there is a layer state change.
layer_state_t layer_state_set_keymap(layer_state_t state) {
ergodox_board_led_off();
ergodox_right_led_1_off();
ergodox_right_led_2_off();
ergodox_right_led_3_off();
ergodox_board_led_off();
ergodox_right_led_1_off();
ergodox_right_led_2_off();
ergodox_right_led_3_off();
uint8_t layer = get_highest_layer(state);
switch (layer) {
case _LOWER:
ergodox_right_led_3_on();
break;
case _MOD:
ergodox_right_led_2_on();
break;
case _RAISE:
ergodox_right_led_1_on();
break;
case _ADJUST:
ergodox_right_led_1_on();
ergodox_right_led_2_on();
break;
default:
break;
}
switch (layer) {
case _WORKMAN:
case _QWERTY:
case _WINWORKMAN:
if (modifiers & MODS_SHIFT_MASK || led_usb_state & (1<<USB_LED_CAPS_LOCK) || one_shot & MODS_SHIFT_MASK) {
ergodox_right_led_1_on();
ergodox_right_led_1_set( 25 );
}
if (modifiers & MODS_CTRL_MASK || one_shot & MODS_CTRL_MASK || modifiers & MODS_GUI_MASK || one_shot & MODS_GUI_MASK) {
if ((modifiers & MODS_CTRL_MASK || one_shot & MODS_CTRL_MASK) && (modifiers & MODS_GUI_MASK || one_shot & MODS_GUI_MASK)) {
ergodox_right_led_2_on();
ergodox_right_led_2_set( 50 );
} else {
ergodox_right_led_2_on();
ergodox_right_led_2_set( 10 );
}
}
if (modifiers & MODS_ALT_MASK || one_shot & MODS_ALT_MASK) {
ergodox_right_led_3_on();
ergodox_right_led_3_set( 10 );
}
break;
case _LOWER:
ergodox_right_led_3_on();
ergodox_right_led_3_set(10); // Default brightness is deadly in a dark room
break;
case _ADJUST:
ergodox_right_led_2_on();
ergodox_right_led_2_set(10);
break;
case _DIABLO:
ergodox_right_led_1_on();
ergodox_right_led_1_set(10);
break;
default:
// none
break;
}
ergodox_right_led_1_set(25);
ergodox_right_led_2_set(25);
ergodox_right_led_3_set(25);
return state;
};
void matrix_scan_keymap(void) {
uint8_t modifiers = get_mods();
uint8_t led_usb_state = host_keyboard_leds();
uint8_t one_shot = get_oneshot_mods();
uint8_t layer_is_workman = layer_state_is(_WORKMAN);
if ((modifiers) && (layer_is_workman)) {
if (modifiers & MODS_SHIFT_MASK || led_usb_state & (1<<USB_LED_CAPS_LOCK) || one_shot & MODS_SHIFT_MASK) {
ergodox_right_led_1_on();
ergodox_right_led_1_set( 25 );
} else {
ergodox_right_led_1_off();
}
if ((modifiers & MODS_CTRL_MASK || one_shot & MODS_CTRL_MASK) && (modifiers & MODS_GUI_MASK || one_shot & MODS_GUI_MASK)) {
ergodox_right_led_2_on();
ergodox_right_led_2_set( 50 );
} else if ((modifiers & MODS_CTRL_MASK || one_shot & MODS_CTRL_MASK) || (modifiers & MODS_GUI_MASK || one_shot & MODS_GUI_MASK)) {
ergodox_right_led_2_on();
ergodox_right_led_2_set( 10 );
} else {
ergodox_right_led_2_off();
}
if (modifiers & MODS_ALT_MASK || one_shot & MODS_ALT_MASK) {
ergodox_right_led_3_on();
ergodox_right_led_3_set( 10 );
} else {
ergodox_right_led_3_off();
}
} else if (!(modifiers) && (layer_is_workman)) {
ergodox_right_led_1_off();
ergodox_right_led_2_off();
ergodox_right_led_3_off();
}
};

47
layouts/community/ergodox/bocaj/readme.md
View file

@ -1,37 +1,28 @@
# Bocaj Layout
# Overview
While I've put my own spin on most things, much of the credit for these ideas belongs to Drashna and/or the people he derived things from. Please see his [layout](../drashna/) and [userspace](../../../../users/drashna/) for lots of ideas and inspiration.
This is my personal Ergodox EZ configuration, and my daily driver.
## Layers Overview
Most of the code resides in my userspace and is heavily based upon [Drashna's work](https://github.com/qmk/qmk_firmware/tree/master/users/drashna)... although considerably slimmed down.
* Default
* Workman
* Qwerty
* Windows Workman (swaps GUI and CTRL buttons)
* Lower
* F1-12 Top Row
* Grave / Layer Switch macro at Caps Lock position
* Navigation at QWERTY 'ESDF' position
* Numpad under right hand
* Adjust
* Volume Control
* Mac Lock Macro
* Make / Reset/ EEPROM keys
* Default Layer changing keys
* Diablo Layer
* Moved shortcuts within left hands reach
* Macros to spam 1-4 every ~1 second
* Shift in thumb cluster to prevent pinky fatique
## How to build
## LEDs Overview
Put simply:
`make ergodox_ez:bocaj`
* Used for _LOWER, _ADJUST, and _DIABLO layer indication
* Used for Ctrl/GUI, Shift, and Alt indication when on a default layer
On that note, I use a separate workspace when making changes to my layouts or userspace. In that repo, there is a tool that does this for me. See [JacobJerrell/qmk_layouts/tools/](https://github.com/JacobJerrell/qmk_layouts/tree/master/tools)
## Wrappers Overview
## Layers
While it isn't a novel idea, I feel the need to mention it because it really appeals to me as a person that doesn't like repetitive code.
* WORKMAN: No one uses this board but me and I've never had a reason to switch to QWERTY
* LOWER:
* Left: Grave and navigation arrows
* Right: Numpad
* RAISE:
* Symbols across the top, F-Keys on the second row
* ADJUST
* Audio control, make/reset/version macros
* MOD: mouse navigation
We've all come to know and love the pretty wrapper for Ergodox because it makes for such a beautiful, self-documenting keymap. In this keymap, we are building ontop of the pretty wrapper to wrap our default layers with our keys that aren't unique to the layer.
## Ergodox Specifics
Now you can wrap your keymap with `LAYOUT_ergodox_pretty_base_wrapper()` and only feed it the alpha keys, having the top, side, bottom, and thumb clusters automatically filled in. If you make a key to any of the top, side, bottom, or thumb cluster keys, it will propegate to all layers that have this wrapper, or have KC_TRNS keycodes in the same location
I don't have the underglow or backlit versions so the 3 LEDs on the right board are used for layer indication if not on the base layer. If you're on the base layer, they're used for mod-key indicators.

23
layouts/community/ergodox/bocaj/rules.mk
View file

@ -1,11 +1,14 @@
AUTO_SHIFT_ENABLE = no
COMMAND_ENABLE = no
SWAP_HANDS_ENABLE = no
TAP_DANCE_ENABLE = yes
EXTRAKEY_ENABLE = no
KEY_LOCK_ENABLE = yes
LEADER_ENABLE = yes
BOOTMAGIC_ENABLE = yes
TAP_DANCE_ENABLE = no
COMMAND_ENABLE = no # Commands for debug and configuration
CONSOLE_ENABLE = yes
SPACE_CADET_ENABLE = no
KEY_LOCK_ENABLE = yes
MOUSEKEY_ENABLE = yes
EXTRAKEY_ENABLE = yes
LEADER_ENABLE = yes
UNICODE_ENABLE = yes
UNICODEMAP_ENABLE = no
UCIS_ENABLE = no
UNICODE_ENABLE = no
UNICODEMAP_ENABLE = no
RGB_MATRIX_ENABLE = no
RGBLIGHT_ENABLE = no

109
layouts/community/ortho_4x12/bocaj/config.h Normal file
View file

@ -0,0 +1,109 @@
#pragma once
#define LEADER_TIMEOUT 250
#define LEADER_PER_KEY_TIMING
#if defined(RGBLIGHT_ENABLE) && !defined(RGBLED_NUM)
# if defined(KEYBOARD_planck_light)
# define RGB_DI_PIN A0
# define RGBLED_NUM 13 // Number of LEDs
# endif
# define RGBLIGHT_HUE_STEP 12
# define RGBLIGHT_SAT_STEP 12
# define RGBLIGHT_VAL_STEP 12
# define RGBLIGHT_EFFECT_KNIGHT_LENGTH 2
# define RGBLIGHT_EFFECT_SNAKE_LENGTH 2
# ifdef RGB_MATRIX_ENABLE
# define RGBLIGHT_DISABLE_KEYCODES
# endif
#endif // RGBLIGHT_ENABLE
#ifdef RGB_MATRIX_ENABLE
# define RGB_MATRIX_KEYPRESSES // reacts to keypresses (will slow down matrix scan by a lot)
// #define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (not recommened)
# define RGB_MATRIX_FRAMEBUFFER_EFFECTS
// #define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
// #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
# define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
# undef RGB_MATRIX_LED_PROCESS_LIMIT
# undef RGB_MATRIX_LED_FLUSH_LIMIT
#endif
#if defined(KEYBOARD_planck_ez)
# undef PRODUCT
# define PRODUCT Bocaj Hacked Planck EZ
#endif
#define EEPROM_I2C_RM24C512C
#define ENCODER_DIRECTION_FLIP
/*
* MIDI options
*/
/* Prevent use of disabled MIDI features in the keymap */
//#define MIDI_ENABLE_STRICT 1
/* enable basic MIDI features:
- MIDI notes can be sent when in Music mode is on
*/
// #define MIDI_BASIC
/* enable advanced MIDI features:
- MIDI notes can be added to the keymap
- Octave shift and transpose
- Virtual sustain, portamento, and modulation wheel
- etc.
*/
//#define MIDI_ADVANCED
/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
//#define MIDI_TONE_KEYCODE_OCTAVES 2
#define FB_ERM_LRA 1 /* For ERM:0 or LRA:1*/
#define FB_BRAKEFACTOR 6 /* For 1x:0, 2x:1, 3x:2, 4x:3, 6x:4, 8x:5, 16x:6, Disable Braking:7 */
#define FB_LOOPGAIN 1 /* For Low:0, Medium:1, High:2, Very High:3 */
/* default 3V ERM vibration motor voltage and library*/
#if FB_ERM_LRA == 0
# define RATED_VOLTAGE 3
# define V_RMS 2.3
# define V_PEAK 3.30
/* Library Selection */
# define LIB_SELECTION 4 /* For Empty:0' TS2200 library A to D:1-5, LRA Library: 6 */
/* default 2V LRA voltage and library */
#elif FB_ERM_LRA == 1
# define RATED_VOLTAGE 2
# define V_RMS 2.0
# define V_PEAK 2.85
# define F_LRA 200
/* Library Selection */
# define LIB_SELECTION 6 /* For Empty:0' TS2200 library A to D:1-5, LRA Library: 6 */
#endif
/* Control 1 register settings */
#define DRIVE_TIME 25
#define AC_COUPLE 0
#define STARTUP_BOOST 1
/* Control 2 Settings */
#define BIDIR_INPUT 1
#define BRAKE_STAB 1 /* Loopgain is reduced when braking is almost complete to improve stability */
#define SAMPLE_TIME 3
#define BLANKING_TIME 1
#define IDISS_TIME 1
/* Control 3 settings */
#define NG_THRESH 2
#define ERM_OPEN_LOOP 1
#define SUPPLY_COMP_DIS 0
#define DATA_FORMAT_RTO 0
#define LRA_DRIVE_MODE 0
#define N_PWM_ANALOG 0
#define LRA_OPEN_LOOP 0
/* Control 4 settings */
#define ZC_DET_TIME 0
#define AUTO_CAL_TIME 3

286
layouts/community/ortho_4x12/bocaj/keymap.c Normal file
View file

@ -0,0 +1,286 @@
/*
Copyright 2020 Jacob Jerrell <jacob.jerrell@gmail.com> @JacobJerrell
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bocaj.h"
#ifdef BACKLIGHT_ENABLE
enum planck_keycodes {
BACKLIT = NEW_SAFE_RANGE,
TH_LVL,
};
#else
# define BACKLIT OSM(MOD_LSFT)
enum planck_keycodes {
TH_LVL = NEW_SAFE_RANGE,
};
#endif
/*
* Tap/Hold Wrapper
* ,-----------------------------------------------------------------------------------.
* | | | | | | | | | | | | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | |Shift | Cmd | Alt | | | Alt | Cmd |Shift | | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | Ctrl | | | | | | | | | Ctrl | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | |Lower | |Raise | | | | |
* `-----------------------------------------------------------------------------------'
*/
#define LAYOUT_ortho_4x12_bocaj(...) WRAPPER_planck_bocaj(__VA_ARGS__)
/*
* Base Alphanumeric Wrapper + Tap/Hold Wrapper
* ,-----------------------------------------------------------------------------------.
* | Esc | | | | | | | | | | | - |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Tab | | | | | HYPR | MEH | | | | | ' |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Shift| | | | | | | | | | | TTMOD|
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | MOMOD| Lead | Up | Left |BkSpc | Space |Enter |Right | Down | XXX | XXX |
* `-----------------------------------------------------------------------------------'
*/
#define LAYOUT_ortho_4x12_bocaj_base(...) WRAPPER_planck_bocaj_base(__VA_ARGS__)
#define LAYOUT_ortho_4x12_bocaj_base_WIN(...) WRAPPER_planck_bocaj_base_WIN(__VA_ARGS__)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_WORKMAN] = LAYOUT_ortho_4x12_bocaj_base(
_________________WORKMAN_L1________________, _________________WORKMAN_R1________________,
_________________WORKMAN_L2________________, _________________WORKMAN_R2________________,
_________________WORKMAN_L3________________, _________________WORKMAN_R3________________
),
[_WWORKMAN] = LAYOUT_ortho_4x12_bocaj_base_WIN(
_________________WORKMAN_L1________________, _________________WORKMAN_R1________________,
_________________WORKMAN_L2________________, _________________WORKMAN_R2________________,
_________________WORKMAN_L3________________, _________________WORKMAN_R3________________
),
[_QWERTY] = LAYOUT_ortho_4x12_bocaj_base(
_________________QWERTY_L1_________________, _________________QWERTY_R1_________________,
_________________QWERTY_L2_________________, _________________QWERTY_R2_________________,
_________________QWERTY_L3_________________, _________________QWERTY_R3_________________
),
[_WQWERTY] = LAYOUT_ortho_4x12_bocaj_base_WIN(
_________________QWERTY_L1_________________, _________________QWERTY_R1_________________,
_________________QWERTY_L2_________________, _________________QWERTY_R2_________________,
_________________QWERTY_L3_________________, _________________QWERTY_R3_________________
),
[_LOWER] = LAYOUT_ortho_4x12_bocaj(
___________________LOWER_L1_EXT____________________, ___________________LOWER_R1_EXT____________________,
___________________LOWER_L2_EXT____________________, ___________________LOWER_R2_EXT____________________,
___________________LOWER_L3_EXT____________________, ___________________LOWER_R3_EXT____________________,
_______, _______, _______, _______, _______, _______, KC_0, KC_DOT, KC_COMM, _______, _______
),
[_RAISE] = LAYOUT_ortho_4x12_bocaj(
KC_TILD, _________________RAISE_L1__________________, _________________RAISE_R1__________________, KC_EQUAL,
KC_F11, _________________RAISE_L2__________________, _________________RAISE_R2__________________, KC_F12,
_______, _________________RAISE_L3__________________, _________________RAISE_R3__________________, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
),
[_ADJUST] = WRAPPER_ortho_4x12(
KC_MAKE, _________________ADJUST_L1_________________, _________________ADJUST_R1_________________, KC_RST,
VRSN, _________________ADJUST_L2_________________, _________________ADJUST_R2_________________, EEP_RST,
TH_LVL, _________________ADJUST_L3_________________, _________________ADJUST_R3_________________, RGB_IDL,
HPT_TOG, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
)
};
// clang-format on
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
#ifdef BACKLIGHT_ENABLE
case BACKLIT:
if (record->event.pressed) {
register_code(KC_RSFT);
# ifdef BACKLIGHT_ENABLE
backlight_step();
# endif
} else {
unregister_code(KC_RSFT);
}
break;
#endif
#ifdef KEYBOARD_planck_ez
case TH_LVL:
if (record->event.pressed) {
keyboard_config.led_level++;
if (keyboard_config.led_level > 4) {
keyboard_config.led_level = 0;
}
planck_ez_right_led_level((uint8_t)keyboard_config.led_level * 255 / 4);
planck_ez_left_led_level((uint8_t)keyboard_config.led_level * 255 / 4);
eeconfig_update_kb(keyboard_config.raw);
layer_state_set_kb(layer_state);
}
break;
#endif
}
return true;
}
bool music_mask_user(uint16_t keycode) {
switch (keycode) {
default:
return true;
}
}
#ifdef RGB_MATRIX_ENABLE
// clang-format off
void suspend_power_down_keymap(void) {
rgb_matrix_set_suspend_state(true);
}
void suspend_wakeup_init_keymap(void) {
rgb_matrix_set_suspend_state(false);
}
// clang-format on
void rgb_matrix_indicators_user(void) {
uint8_t this_mod = get_mods();
uint8_t this_led = host_keyboard_leds();
uint8_t this_osm = get_oneshot_mods();
bool is_ez;
# ifdef KEYBOARD_planck_ez
is_ez = true;
# endif
if (g_suspend_state || !rgb_matrix_config.enable) return;
# if defined(RGBLIGHT_ENABLE)
if (!userspace_config.rgb_layer_change)
# else
if (userspace_config.rgb_layer_change)
# endif
{
switch (get_highest_layer(layer_state)) {
case _MOD:
rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
case _RAISE:
rgb_matrix_layer_helper(HSV_BLUE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
case _LOWER:
rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
case _ADJUST:
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
default: {
bool mods_enabled = false;
switch (get_highest_layer(default_layer_state)) {
case _QWERTY:
rgb_matrix_layer_helper(HSV_CYAN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
case _WQWERTY:
rgb_matrix_layer_helper(HSV_BLUE, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
case _WORKMAN:
rgb_matrix_layer_helper(HSV_SPRINGGREEN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
case _WWORKMAN:
rgb_matrix_layer_helper(HSV_GREEN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER);
break;
}
break;
}
}
}
switch (get_highest_layer(default_layer_state)) {
case _QWERTY:
rgb_matrix_set_color(is_ez ? 41 : 42, 0x00, 0xFF, 0xFF);
break;
case _WORKMAN:
rgb_matrix_set_color(is_ez ? 41 : 42, 0xD9, 0xA5, 0x21);
break;
}
if ((this_mod | this_osm) & MODS_SHIFT_MASK || this_led & (1 << USB_LED_CAPS_LOCK)) {
rgb_matrix_set_color_row(0, 0x00, 0xFF, 0x00);
}
if ((this_mod | this_osm) & MODS_CTRL_MASK && (this_mod | this_osm) & MODS_GUI_MASK) {
rgb_matrix_set_color_row(1, 0xFF, 0xD9, 0xFF);
} else if ((this_mod | this_osm) & MODS_CTRL_MASK) {
rgb_matrix_set_color_row(1, 0xFF, 0x00, 0x00);
} else if ((this_mod | this_osm) & MODS_GUI_MASK) {
rgb_matrix_set_color_row(1, 0xFF, 0xD9, 0x00);
}
if ((this_mod | this_osm) & MODS_ALT_MASK) {
rgb_matrix_set_color_row(2, 0x00, 0x00, 0xFF);
}
}
#endif // RGB_MATRIX_INIT
void matrix_init_keymap(void) {}
#ifdef ENCODER_ENABLE
void encoder_update(bool clockwise) {
switch (get_highest_layer(layer_state)) {
case _RAISE:
clockwise ? tap_code(KC_VOLD) : tap_code(KC_VOLU);
break;
case _LOWER:
# ifdef RGB_MATRIX_ENABLE
clockwise ? rgb_matrix_step() : rgb_matrix_step_reverse();
# else
clockwise ? tap_code(KC_PGDN) : tap_code(KC_PGUP);
# endif
break;
case _ADJUST:
# ifdef AUDIO_CLICKY
clockwise ? clicky_freq_up() : clicky_freq_down();
# endif
break;
default:
clockwise ? tap_code(KC_DOWN) : tap_code(KC_UP);
}
# ifdef AUDIO_CLICKY
clicky_play();
# endif
}
#endif // ENCODER_ENABLE
#ifdef KEYBOARD_planck_ez
layer_state_t layer_state_set_keymap(layer_state_t state) {
planck_ez_left_led_off();
planck_ez_right_led_off();
switch (get_highest_layer(state)) {
case _LOWER:
planck_ez_left_led_on();
break;
case _RAISE:
planck_ez_right_led_on();
break;
case _ADJUST:
planck_ez_right_led_on();
planck_ez_left_led_on();
break;
default:
break;
}
return state;
}
#endif

23
layouts/community/ortho_4x12/bocaj/readme.md Normal file
View file

@ -0,0 +1,23 @@
# Overview
This is my Planck EZ layout, heavily based upon [my ergodox layout](../../ergodox/bocaj/).
I got this keyboard for two reasons:
1. QMK spoiled me and the Ergodox isn't incredibly portable (ok 3 reasons)
2. This can sit ontop of my janky Macbook Pro keyboard (disabled with Karabiner if the planck is connected) when I want to work from the couch.
## How to Build
Put simply:
`make planck/ez:bocaj`
On that note, I use a separate workspace when making changes to my layouts or userspace. In that repo, there is a tool that does this for me. See [JacobJerrell/qmk_layouts/tools/](https://github.com/JacobJerrell/qmk_layouts/tree/master/tools) until I get documentation finished (Write code first, define requirements second... right?).
## Layers
* WORKMAN/QWERTY: Default is workman, can be switched via the ADJUST layer. Idk why you would though.
* LOWER: Nums across the top, switches enter key to tab and tab key to delete. Symbols in the middle, remenascent of the ergodox
* RAISE: Symbols across the top, F-Keys on the 2nd row. Switches backspace to delete
* ADJUST: Computer Audio controls, RGB controls, Sound controls, macros, etc.
* MOD: Mouse controls under the left hand. Numpad under the right hand

44
layouts/community/ortho_4x12/bocaj/rules.mk Normal file
View file

@ -0,0 +1,44 @@
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
TAP_DANCE_ENABLE = no
SPACE_CADET_ENABLE = no
NKRO_ENABLE = yes
ifneq ($(strip $(KEYBOARD)), planck/rev6)
CONSOLE_ENABLE = no
COMMAND_ENABLE = no
ifeq ($(strip $(LAYOUT_HAS_RGB)), yes)
RGBLIGHT_ENABLE = yes
INDICATOR_LIGHTS = yes
RGBLIGHT_TWINKLE = yes
RGBLIGHT_STARTUP_ANIMATION = yes
endif
else
CONSOLE_ENABLE = yes
COMMAND_ENABLE = yes
RGBLIGHT_ENABLE = yes
RGBLIGHT_STARTUP_ANIMATION = yes
RGB_MATRIX_ENABLE = no
AUDIO_ENABLE = yes
EEPROM_DRIVER = i2c
endif
ifeq ($(strip $(KEYBOARD)), planck/light)
RGB_MATRIX_ENABLE = yes
RGBLIGHT_ENABLE = yes
RGBLIGHT_STARTUP_ANIMATION = yes
AUDIO_ENABLE = yes
# HAPTIC_ENABLE += SOLENOID
endif
ifeq ($(strip $(KEYBOARD)), planck/ez)
RGBLIGHT_ENABLE = no
# SERIAL_LINK_ENABLE = yes
ENCODER_ENABLE = yes
RGB_MATRIX_ENABLE = IS31FL3737
INDICATOR_LIGHTS = yes
RGBLIGHT_TWINKLE = yes
RGBLIGHT_STARTUP_ANIMATION = yes
CONSOLE_ENABLE = yes
COMMAND_ENABLE = yes
AUDIO_ENABLE = yes
endif

1
users/bocaj/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
secrets.c

24
users/bocaj/.gitlab-ci.yml Normal file
View file

@ -0,0 +1,24 @@
stages:
- test
QMK Firmware:
stage: test
variables:
GIT_SUBMODULE_STRATEGY: recursive
tags:
- linux
image: qmkfm/base_container
before_script:
- apt-get update -qy
- apt-get install -y build-essential avr-libc binutils-arm-none-eabi binutils-avr dfu-programmer dfu-util gcc gcc-arm-none-eabi git libnewlib-arm-none-eabi gcc-avr python3 unzip wget zip
- avr-gcc --version
- uname -a
script:
- make planck/rev6:default planck/rev5:default
- make all:bocaj -j2
artifacts:
name: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
paths:
- ./*.hex
- ./*.bin
expire_in: 1 month

305
users/bocaj/bocaj.c
View file

@ -1,5 +1,5 @@
/*
Copyright 2018 Jacob Jerrell <jacob.jerrell@gmail.com> @JacobJerrell
Copyright 2020 Jacob Jerrell <jacob.jerrell@gmail.com> @JacobJerrell
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -17,173 +17,194 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "bocaj.h"
#ifdef KEYBOARD_planck_ez
userspace_config_t userspace_config;
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
#define BOCAJ_UNICODE_MODE UC_OSX
#else
// set to 2 for UC_WIN, set to 4 for UC_WINC
#define BOCAJ_UNICODE_MODE 2
#endif
void tap(uint16_t keycode){ register_code(keycode); unregister_code(keycode); };
bool mod_key_press_timer(uint16_t code, uint16_t mod_code, bool pressed) {
static uint16_t this_timer;
if (pressed) {
this_timer = timer_read();
} else {
if (timer_elapsed(this_timer) < TAPPING_TERM) {
tap_code(code);
} else {
register_code(mod_code);
tap_code(code);
unregister_code(mod_code);
}
}
return false;
}
bool mod_key_press(uint16_t code, uint16_t mod_code, bool pressed, uint16_t this_timer) {
if (pressed) {
this_timer = timer_read();
} else {
if (timer_elapsed(this_timer) < TAPPING_TERM) {
tap_code(code);
} else {
register_code(mod_code);
tap_code(code);
unregister_code(mod_code);
}
}
return false;
}
void bootmagic_lite(void) {
matrix_scan();
#if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
wait_ms(DEBOUNCING_DELAY * 2);
#elif defined(DEBOUNCE) && DEBOUNCE > 0
wait_ms(DEBOUNCE * 2);
#else
wait_ms(30);
#endif
matrix_scan();
if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
bootloader_jump();
}
}
__attribute__((weak)) void keyboard_pre_init_keymap(void) {}
void keyboard_pre_init_user(void) {
#ifdef KEYBOARD_planck_ez
userspace_config.raw = eeconfig_read_user();
#endif
keyboard_pre_init_keymap();
}
// Add reconfigurable functions here, for keymap customization
// This allows for a global, userspace functions, and continued
// customization of the keymap. Use _keymap instead of _user
// functions in the keymaps
__attribute__ ((weak))
void matrix_init_keymap(void) {}
__attribute__ ((weak))
void startup_keymap(void) {}
__attribute__ ((weak))
void suspend_power_down_keymap(void) {}
__attribute__ ((weak))
void suspend_wakeup_init_keymap(void) {}
__attribute__ ((weak))
void matrix_scan_keymap(void) {}
__attribute__ ((weak))
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
return true;
}
__attribute__ ((weak))
void matrix_scan_secrets(void) {}
__attribute__ ((weak))
uint32_t layer_state_set_keymap (uint32_t state) {
return state;
}
__attribute__ ((weak))
uint32_t default_layer_state_set_keymap (uint32_t state) {
return state;
}
__attribute__ ((weak))
void led_set_keymap(uint8_t usb_led) {}
__attribute__((weak)) void matrix_init_keymap(void) {}
// Call user matrix init, set default RGB colors and then
// call the keymap's init function
void matrix_init_user(void) {
userspace_config.raw = eeconfig_read_user();
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
set_unicode_input_mode(BOCAJ_UNICODE_MODE);
get_unicode_input_mode();
#endif //UNICODE_ENABLE
matrix_init_keymap();
matrix_init_keymap();
}
void startup_user (void) {
startup_keymap();
__attribute__((weak)) void keyboard_post_init_keymap(void) {}
void keyboard_post_init_user(void) {
#if defined(RGB_MATRIX_ENABLE)
keyboard_post_init_rgb_matrix();
#endif
keyboard_post_init_keymap();
}
void suspend_power_down_user(void)
{
suspend_power_down_keymap();
__attribute__((weak)) void shutdown_keymap(void) {}
void rgb_matrix_update_pwm_buffers(void);
void shutdown_user(void) {
#ifdef RGB_MATRIX_ENABLE
rgb_matrix_set_color_all(0xFF, 0x00, 0x00);
rgb_matrix_update_pwm_buffers();
#endif // RGB_MATRIX_ENABLE
shutdown_keymap();
}
void suspend_wakeup_init_user(void)
{
suspend_wakeup_init_keymap();
#ifdef KEYBOARD_ergodox_ez
wait_ms(10);
#endif
}
__attribute__((weak)) void suspend_power_down_keymap(void) {}
void eeconfig_init_user(void) {
userspace_config.raw = 0;
eeconfig_update_user(userspace_config.raw);
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
set_unicode_input_mode(BOCAJ_UNICODE_MODE);
get_unicode_input_mode();
#else
eeprom_update_byte(EECONFIG_UNICODEMODE, BOCAJ_UNICODE_MODE);
#endif
}
void suspend_power_down_user(void) { suspend_power_down_keymap(); }
__attribute__((weak)) void suspend_wakeup_init_keymap(void) {}
void suspend_wakeup_init_user(void) { suspend_wakeup_init_keymap(); }
__attribute__((weak)) void matrix_scan_secrets(void) {}
__attribute__((weak)) void matrix_scan_keymap(void) {}
LEADER_EXTERNS();
// No global matrix scan code, so just run keymap's matrix
// scan function
void matrix_scan_user(void) {
static bool has_ran_yet;
if (!has_ran_yet) {
has_ran_yet = true;
startup_user();
}
LEADER_DICTIONARY() {
leading = false;
leader_end();
// Mac Save (Leader -> s)
SEQ_ONE_KEY(KC_S) {
SEND_STRING(SS_LGUI("s"));
static bool has_ran_yet;
if (!has_ran_yet) {
has_ran_yet = true;
startup_user();
}
// Mac copy line down (Leader -> d, d)
SEQ_TWO_KEYS(KC_D, KC_D) {
register_code(KC_LSHIFT);
register_code(KC_HOME);
unregister_code(KC_HOME);
unregister_code(KC_LSHIFT);
SEND_STRING(SS_LGUI("c"));
tap(KC_END);
tap(KC_ENTER);
SEND_STRING(SS_LGUI("v"));
LEADER_DICTIONARY() {
leading = false;
leader_end();
// Website Refresh / XCode "Run"
SEQ_ONE_KEY(KC_R) {
SEND_STRING(SS_LGUI("r"));
}
SEQ_TWO_KEYS(KC_B, KC_D) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION " Built at: " QMK_BUILDDATE);
}
#ifndef NO_SECRETS
matrix_scan_secrets();
#endif // !NO_SECRETS
}
#if defined(RGB_MATRIX_ENABLE)
matrix_scan_rgb_matrix();
#endif
// Mac copy line up (Leader -> u, u)
SEQ_TWO_KEYS(KC_U, KC_U) {
register_code(KC_LSHIFT);
register_code(KC_HOME);
unregister_code(KC_HOME);
unregister_code(KC_LSHIFT);
SEND_STRING(SS_LGUI("c"));
tap(KC_UP);
tap(KC_END);
tap(KC_ENTER);
SEND_STRING(SS_LGUI("v"));
}
// Mac VS Debug
SEQ_ONE_KEY(KC_D) {
tap(KC_F5);
}
// Mac VS Stop Debug
SEQ_TWO_KEYS(KC_S, KC_D) {
register_code(KC_LSHIFT);
tap(KC_F5);
unregister_code(KC_LSHIFT);
}
// Start Diablo 3
SEQ_ONE_KEY(KC_3) {
SEND_STRING(SS_LCTRL(" "));
SEND_STRING("Diablo");
tap(KC_ENTER);
}
SEQ_ONE_KEY(KC_B) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION " ");
tap(KC_ENTER);
SEND_STRING ("Built at: " QMK_BUILDDATE);
}
#ifndef NO_SECRETS
matrix_scan_secrets();
#endif // !NO_SECRETS
}
#ifdef TAP_DANCE_ENABLE // Run Diablo 3 macro checking code.
run_diablo_macro_check();
#endif // TAP_DANCE_ENABLE
matrix_scan_keymap();
matrix_scan_keymap();
}
__attribute__((weak)) layer_state_t layer_state_set_keymap(layer_state_t state) { return state; }
// on layer change, no matter where the change was initiated
// Then runs keymap's layer change check
layer_state_t layer_state_set_user(layer_state_t state) {
state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST);
#if defined(RGBLIGHT_ENABLE)
state = layer_state_set_rgb_light(state);
#endif // RGBLIGHT_ENABLE
return layer_state_set_keymap(state);
}
__attribute__((weak)) layer_state_t default_layer_state_set_keymap(layer_state_t state) { return state; }
// Runs state check and changes underglow color and animation
layer_state_t default_layer_state_set_user(layer_state_t state) {
state = default_layer_state_set_keymap(state);
#if 0
# if defined(RGB_MATRIX_ENABLE)
state = default_layer_state_set_rgb(state);
# endif // RGB_MATRIX_ENABLE
#endif
return state;
}
__attribute__((weak)) void led_set_keymap(uint8_t usb_led) {}
// Any custom LED code goes here.
// So far, I only have keyboard specific code,
// So nothing goes here.
void led_set_user(uint8_t usb_led) { led_set_keymap(usb_led); }
__attribute__((weak)) void eeconfig_init_keymap(void) {}
void eeconfig_init_user(void) {
#ifdef KEYBOARD_planck_ez
userspace_config.raw = 0;
# if defined(RGB_MATRIX_ENABLE)
userspace_config.rgb_layer_change = true;
# endif
eeconfig_update_user(userspace_config.raw);
#endif
eeconfig_init_keymap();
keyboard_init();
}
bool hasAllBitsInMask(uint8_t value, uint8_t mask) {
value &= 0xF;
mask &= 0xF;
return (value & mask) == mask;
}

100
users/bocaj/bocaj.h
View file

@ -1,5 +1,6 @@
/*
Copyright 2018 Jacob Jerrell <jacob.jerrell@gmail.com> @JacobJerrell
Copyright 2017 Christopher Courtney <drashna@live.com> @drashna
Copyright 2020 Jacob Jerrell <jacob.jerrell@gmail.com> @JacobJerrell
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -16,70 +17,57 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "quantum.h"
#include QMK_KEYBOARD_H
#include "version.h"
#include "eeprom.h"
#include "wrappers.h"
#include "process_records.h"
#ifdef TAP_DANCE_ENABLE
#include "tap_dances.h"
#endif // TAP_DANCE_ENABLE
/* Layer Names */
enum userspace_layers {
_WORKMAN = 0,
_WINWORKMAN,
_QWERTY,
_LOWER,
_ADJUST,
_DIABLO,
};
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
#define BOCAJ_UNICODE_MODE UC_OSX
#else
// set to 2 for UC_WIN, set to 4 for UC_WINC
#define BOCAJ_UNICODE_MODE 2
#include "wrappers.h"
#if defined(RGB_MATRIX_ENABLE)
# include "rgb_matrix_stuff.h"
#endif
/*
define modifiers here, since MOD_* doesn't seem to work for these
*/
/* Define layer names */
enum userspace_layers {
_WORKMAN = 0,
_QWERTY,
_WWORKMAN,
_WQWERTY,
_LOWER,
_RAISE,
_ADJUST,
_MOD,
LAYER_SAFE_RANGE,
};
#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT))
#define MODS_CTRL_MASK (MOD_BIT(KC_LCTL)|MOD_BIT(KC_RCTRL))
#define MODS_ALT_MASK (MOD_BIT(KC_LALT)|MOD_BIT(KC_RALT))
#define MODS_GUI_MASK (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
#define MODS_CTRL_MASK (MOD_BIT(KC_LCTL)|MOD_BIT(KC_RCTRL))
#define MODS_ALT_MASK (MOD_BIT(KC_LALT)|MOD_BIT(KC_RALT))
#define MODS_GUI_MASK (MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI))
bool mod_key_press_timer (uint16_t code, uint16_t mod_code, bool pressed);
bool mod_key_press (uint16_t code, uint16_t mod_code, bool pressed, uint16_t this_timer);
bool send_game_macro(const char *str, keyrecord_t *record, bool override);
void matrix_init_keymap(void);
void shutdown_keymap(void);
void suspend_power_down_keymap(void);
void suspend_wakeup_init_keymap(void);
void matrix_scan_keymap(void);
uint32_t layer_state_set_keymap (uint32_t state);
uint32_t default_layer_state_set_keymap (uint32_t state);
void led_set_keymap(uint8_t usb_led);
void eeconfig_init_keymap(void);
void tap(uint16_t keycode);
bool mod_key_press_timer(uint16_t code, uint16_t mod_code, bool pressed);
bool mod_key_press(uint16_t code, uint16_t mod_code, bool pressed, uint16_t this_timer);
void matrix_init_keymap(void);
void shutdown_keymap(void);
void suspend_power_down_keymap(void);
void suspend_wakeup_init_keymap(void);
void matrix_scan_keymap(void);
layer_state_t layer_state_set_keymap(layer_state_t state);
layer_state_t default_layer_state_set_keymap(layer_state_t state);
void led_set_keymap(uint8_t usb_led);
void eeconfig_init_keymap(void);
bool hasAllBitsInMask(uint8_t value, uint8_t mask);
// clang-format off
#ifdef KEYBOARD_planck_ez
typedef union {
uint8_t raw;
uint32_t raw;
struct {
bool rgb_layer_change :1;
bool rgb_matrix_idle_anim :1;
};
} userspace_config_t;
// clang-format on
extern userspace_config_t userspace_config;
// If Tap Dancing is enabled, we manage that here.
// If it is not, then we define the KC_D3_# codes gracefully
#ifdef TAP_DANCE_ENABLE
#define KC_D3_1 TD(TD_D3_1)
#define KC_D3_2 TD(TD_D3_2)
#define KC_D3_3 TD(TD_D3_3)
#define KC_D3_4 TD(TD_D3_4)
#else // !TAP_DANCE_ENABLE
#define KC_D3_1 KC_1
#define KC_D3_2 KC_2
#define KC_D3_3 KC_3
#define KC_D3_4 KC_4
#endif // TAP_DANCE_ENABLE
#endif

120
users/bocaj/config.h
View file

@ -1,8 +1,82 @@
#pragma once
#ifndef QMK_KEYS_PER_SCAN
#define QMK_KEYS_PER_SCAN 4
#endif // QMK KEYS PER SCAN
// Use custom magic number so that when switching branches, EEPROM always gets reset
#define EECONFIG_MAGIC_NUMBER (uint16_t)0x1339
/* Set Polling rate to 1000Hz */
#define USB_POLLING_INTERVAL_MS 1
#ifdef AUDIO_ENABLE
# define AUDIO_CLICKY
# define STARTUP_SONG SONG(RICK_ROLL)
# define GOODBYE_SONG SONG(SONIC_RING)
# define DEFAULT_LAYER_SONGS \
{ SONG(QWERTY_SOUND), SONG(COLEMAK_SOUND), SONG(DVORAK_SOUND), SONG(OVERWATCH_THEME) }
# define AUDIO_CLICKY_FREQ_RANDOMNESS 1.5f
# define UNICODE_SONG_MAC SONG(RICK_ROLL)
# define UNICODE_SONG_LNX SONG(RICK_ROLL)
# define UNICODE_SONG_WIN SONG(RICK_ROLL)
# define UNICODE_SONG_BSD SONG(RICK_ROLL)
# define UNICODE_SONG_WINC SONG(RICK_ROLL)
#endif // !AUDIO_ENABLE
#ifdef RGB_MATRIX_ENABLE
# define RGB_MATRIX_KEYPRESSES // reacts to keypresses (will slow down matrix scan by a lot)
// # define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (not recommened)
# define RGB_MATRIX_FRAMEBUFFER_EFFECTS
// # define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
# define RGB_DISABLE_WHEN_USB_SUSPENDED true // turn off effects when suspended
// # define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
// # define EECONFIG_RGB_MATRIX (uint32_t *)16
# if defined(__AVR__) && !defined(__AVR_AT90USB1286__)
# define DISABLE_RGB_MATRIX_ALPHAS_MODS
# define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
# define DISABLE_RGB_MATRIX_GRADIENT_LEFT_RIGHT
# define DISABLE_RGB_MATRIX_BREATHING
# define DISABLE_RGB_MATRIX_BAND_SAT
# define DISABLE_RGB_MATRIX_BAND_VAL
# define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT
# define DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL
# define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT
# define DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL
# define DISABLE_RGB_MATRIX_CYCLE_ALL
# define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
# define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN
# define DISABLE_RGB_MATRIX_CYCLE_OUT_IN
// # define DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
# define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
# define DISABLE_RGB_MATRIX_DUAL_BEACON
# define DISABLE_RGB_MATRIX_CYCLE_PINWHEEL
# define DISABLE_RGB_MATRIX_CYCLE_SPIRAL
# define DISABLE_RGB_MATRIX_RAINBOW_BEACON
# define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS
# define DISABLE_RGB_MATRIX_RAINDROPS
# define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
// # define DISABLE_RGB_MATRIX_TYPING_HEATMAP
# define DISABLE_RGB_MATRIX_DIGITAL_RAIN
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
# define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
# define DISABLE_RGB_MATRIX_SPLASH
# define DISABLE_RGB_MATRIX_MULTISPLASH
# define DISABLE_RGB_MATRIX_SOLID_SPLASH
# define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH
# endif // AVR
#endif // RGB_MATRIX_ENABLE
#ifdef QMK_KEYS_PER_SCAN
# undef QMK_KEYS_PER_SCAN
# define QMK_KEYS_PER_SCAN 1
#endif // !QMK_KEYS_PER_SCAN
// this makes it possible to do rolling combos (zx) with keys that
// convert to other keys on hold (z becomes ctrl when you hold it,
@ -10,24 +84,30 @@
// actually sends Ctrl-x. That's bad.)
#define IGNORE_MOD_TAP_INTERRUPT
#undef PERMISSIVE_HOLD
#define PREVENT_STUCK_MODIFIERS
//#define TAPPING_FORCE_HOLD
//#define RETRO_TAPPING
#define FORCE_NKRO
#ifndef TAPPING_TOGGLE
# define TAPPING_TOGGLE 1
#endif
#ifdef TAPPING_TERM
#undef TAPPING_TERM
#endif // TAPPING_TERM
#define TAPPING_TERM 175
# undef TAPPING_TERM
#endif // TAPPING_TERM
#if defined(KEYBOARD_ergodox_ez)
# define TAPPING_TERM 185
#else
# define TAPPING_TERM 175
#endif
#define RETRO_TAPPING
#define TAP_CODE_DELAY 5
// Disable action_get_macro and fn_actions, since we don't use these
// and it saves on space in the firmware.
#ifndef NO_DEBUG
#define NO_DEBUG
#endif // !NO_DEBUG
#if !defined(NO_PRINT) && !defined(CONSOLE_ENABLE)
#define NO_PRINT
#endif // !NO_PRINT
#define NO_ACTION_MACRO
#define NO_ACTION_FUNCTION
#define MACRO_TIMER 5
/* Disable unused and unneeded features to reduce on firmware size */
#ifdef LOCKING_SUPPORT_ENABLE
# undef LOCKING_SUPPORT_ENABLE
#endif
#ifdef LOCKING_RESYNC_ENABLE
# undef LOCKING_RESYNC_ENABLE
#endif

242
users/bocaj/process_records.c
View file

@ -1,149 +1,111 @@
#include "bocaj.h"
#include QMK_KEYBOARD_H
#include <print.h>
uint16_t copy_paste_timer;
uint16_t grave_layer_timer;
uint16_t heal_layer_timer;
__attribute__((weak)) bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { return true; }
__attribute__ ((weak))
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
return true;
}
__attribute__((weak)) bool process_record_secrets(uint16_t keycode, keyrecord_t *record) { return true; }
// Defines actions tor my global custom keycodes. Defined in bocaj.h file
// Then runs the _keymap's record handler if not processed here
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case KC_MWRK:
if (!record->event.pressed) {
set_single_persistent_default_layer(_WORKMAN);
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
set_unicode_input_mode(0);
#endif
layer_move(0);
ergodox_blink_all_leds();
}
break;
case KC_WWRK:
if (!record->event.pressed) {
set_single_persistent_default_layer(_WINWORKMAN);
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
set_unicode_input_mode(4);
#endif
layer_move(0);
ergodox_blink_all_leds();
}
break;
case KC_MQWR:
if (!record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
set_unicode_input_mode(0);
#endif
layer_move(0);
ergodox_blink_all_leds();
}
break;
case MC_LOCK:
if (!record->event.pressed) {
layer_move(0);
SEND_STRING(SS_LCTRL(SS_LGUI("q")));
}
break;
case KC_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader
if (!record->event.pressed) {
uint8_t temp_mod = get_mods();
uint8_t temp_osm = get_oneshot_mods();
clear_mods();
clear_oneshot_mods();
if (biton32(default_layer_state) == _WINWORKMAN) {
send_string_with_delay_P(PSTR("make " QMK_KEYBOARD ":" QMK_KEYMAP), 10);
} else {
send_string_with_delay_P(PSTR("util/docker_build.sh " QMK_KEYBOARD ":" QMK_KEYMAP), 10);
}
if (temp_mod & MODS_SHIFT_MASK) {
send_string_with_delay_P(PSTR(":teensy"), 10);
}
if (temp_mod & MODS_CTRL_MASK) {
send_string_with_delay_P(PSTR(" -j8 --output-sync"), 10);
}
send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), 10);
set_mods(temp_mod);
layer_move(0);
}
break;
case KC_DCLR: // reset all Diablo timers, disabling them
#ifdef TAP_DANCE_ENABLE
if (record->event.pressed) {
uint8_t dtime;
for (dtime = 0; dtime < 4; dtime++) {
diablo_key_time[dtime] = diablo_times[0];
}
}
#endif // TAP_DANCE_ENABLE
break;
case JJ_ARRW:
if (!record->event.pressed) {
SEND_STRING("->");
}
return false;
break;
case LM_GRAVE:
if (record->event.pressed) {
grave_layer_timer = timer_read();
} else {
if (timer_elapsed(grave_layer_timer) < TAPPING_TERM) {
uint8_t temp_mod = get_mods();
uint8_t one_shot = get_oneshot_mods();
clear_mods();
if (temp_mod & MODS_SHIFT_MASK || one_shot & MODS_SHIFT_MASK) {
register_code(KC_LSFT);
tap(KC_GRAVE);
unregister_code(KC_LSFT);
} else {
tap(KC_GRAVE);
}
set_mods(temp_mod);
} else {
layer_move(0);
}
}
return false;
break;
case KC_CCCV:
if (record->event.pressed) {
copy_paste_timer = timer_read();
} else {
if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) { // Hold, copy
SEND_STRING(SS_LGUI("c"));
} else {
SEND_STRING(SS_LGUI("v"));
}
}
return false;
break;
#ifdef UNICODE_ENABLE
case UC_FLIP: // (ノಠ痊ಠ)ノ彡┻━┻
if (record->event.pressed) {
send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B");
}
break;
case UC_TABL: // ┬─┬ノ( º _ ºノ)
if (record->event.pressed) {
send_unicode_hex_string("252C 2500 252C 30CE 0028 0020 00BA 0020 005F 0020 00BA 30CE 0029");
}
break;
case UC_SHRG: // ¯\_(ツ)_/¯
if (record->event.pressed) {
send_unicode_hex_string("00AF 005C 005F 0028 30C4 0029 005F 002F 00AF");
}
break;
case UC_DISA: // ಠ_ಠ
if (record->event.pressed) {
send_unicode_hex_string("0CA0 005F 0CA0");
}
break;
if (process_record_keymap(keycode, record) && process_record_secrets(keycode, record)
#ifdef RGB_MATRIX_ENABLE
&& process_record_user_rgb_matrix(keycode, record)
#endif
}
return process_record_keymap(keycode, record);
) {
switch (keycode) {
case KC_WORKMAN:
if (!record->event.pressed) {
uint8_t mods = mod_config(get_mods());
if (!mods) {
set_single_persistent_default_layer(_WORKMAN);
} else if (mods & (MODS_GUI_MASK | MODS_CTRL_MASK)) {
set_single_persistent_default_layer(_WWORKMAN);
}
}
return false;
break;
case KC_QWERTY:
if (!record->event.pressed) {
uint8_t mods = mod_config(get_mods());
if (!mods) {
set_single_persistent_default_layer(_QWERTY);
} else if (mods & (MODS_GUI_MASK | MODS_CTRL_MASK)) {
set_single_persistent_default_layer(_WQWERTY);
}
}
return false;
break;
case MC_ARRW:
if (!record->event.pressed) {
clear_mods();
send_string_with_delay_P(PSTR("->"), TAP_CODE_DELAY);
}
return false;
break;
case KC_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader
if (!record->event.pressed) {
clear_mods();
send_string_with_delay_P(PSTR("qmk compile "), TAP_CODE_DELAY);
send_string_with_delay_P(PSTR("-kb " QMK_KEYBOARD), TAP_CODE_DELAY);
send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), TAP_CODE_DELAY);
}
return false;
break;
case VRSN: // Prints firmware version
if (!record->event.pressed) {
send_string_with_delay_P(PSTR(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION ", Built on: " QMK_BUILDDATE), TAP_CODE_DELAY);
}
break;
#if defined(RGB_MATRIX_ENABLE)
case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal
if (!record->event.pressed) {
userspace_config.rgb_layer_change ^= 1;
dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change);
eeconfig_update_user(userspace_config.raw);
if (userspace_config.rgb_layer_change) {
rgblight_enable_noeeprom();
layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better)
} else {
rgblight_disable_noeeprom();
}
}
return false;
break;
case RGB_TOG:
if (!record->event.pressed) {
# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
rgb_matrix_toggle();
# endif
}
return false;
break;
case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions
if (!record->event.pressed) {
bool is_eeprom_updated;
# if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
if (userspace_config.rgb_matrix_idle_anim) {
userspace_config.rgb_matrix_idle_anim = false;
dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim);
is_eeprom_updated = true;
}
# endif
if (is_eeprom_updated) {
eeconfig_update_user(userspace_config.raw);
}
}
return false;
break;
#endif
}
}
#ifdef CONSOLE_ENABLE
uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
#endif
return true;
}

62
users/bocaj/process_records.h
View file

@ -2,49 +2,43 @@
#include "bocaj.h"
#if defined(KEYMAP_SAFE_RANGE)
#define PLACEHOLDER_SAFE_RANGE KEYMAP_SAFE_RANGE
# define PLACEHOLDER_SAFE_RANGE KEYMAP_SAFE_RANGE
#else
#define PLACEHOLDER_SAFE_RANGE SAFE_RANGE
# define PLACEHOLDER_SAFE_RANGE SAFE_RANGE
#endif
enum userspace_custom_keycodes {
KC_EPRM = PLACEHOLDER_SAFE_RANGE, // can always be here
KC_MWRK,
KC_WWRK,
KC_MQWR,
KC_VRSN,
LM_GRAVE, // Shift if held, layer change if tapped
JJ_COPY,
JJ_PSTE,
JJ_ARRW,
KC_CCCV,
MC_LOCK,
KC_DCLR,
KC_MAKE,
UC_FLIP, // (ಠ痊ಠ)┻━┻
UC_TABL, // ┬─┬ノ( º _ ºノ)
UC_SHRG, // ¯\_(ツ)_/¯
UC_DISA, // ಠ_ಠ
NEW_SAFE_RANGE //use "NEWPLACEHOLDER for keymap specific codes
VRSN = PLACEHOLDER_SAFE_RANGE, // Prints QMK Firmware and board info
KC_WORKMAN, // Sets default layer to WORKMAN
KC_QWERTY, // Sets default layer to QWERTY
// KC_COLEMAK, // Sets default layer to COLEMAK
// KC_DVORAK, // Sets default layer to DVORAK
KC_MAKE, // Run keyboard's customized make command
KC_RGB_T, // Toggles RGB Layer Indication mode
RGB_IDL, // RGB Idling animations
MC_ARRW, // ->
UC_FLIP, // (ಠ痊ಠ)┻━┻
UC_TABL, // ┬─┬ノ( º _ ºノ)
UC_SHRG, // ¯\_(ツ)_/¯
UC_DISA, // ಠ_ಠ
NEW_SAFE_RANGE // use "NEWPLACEHOLDER for keymap specific codes
};
bool process_record_secrets(uint16_t keycode, keyrecord_t *record);
bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
// One Shot
#define OS_LSFT OSM(MOD_LSFT)
#define QWERTY KC_QWERTY
#define WORKMAN KC_WORKMAN
// Space Cadet Hyper/Meh and [/]
#define KC_ARRW MC_ARRW
#define KC_RST RESET
#define MO_MOD MO(_MOD)
#define ALT_APP ALT_T(KC_APP)
#define HYP_LBK ALL_T(KC_LBRACKET)
#define MEH_RBK MEH_T(KC_RBRACKET)
#define HYP_LPR ALL_T(KC_LPRN)
#define MEH_RPR MEH_T(KC_RPRN)
#define GUI_CTR(os, kc) MT( (os == 0) ? (MOD_LGUI) : (MOD_LCTL), kc )
// Layout beauti-/simpli-fication
#define KC_LWEN LT(_LOWER, KC_ENTER)
#define KC_ADJS TT(_ADJUST)
#define KC_NUMS TT(_LOWER)
#define KC_GAME TT(_DIABLO)
// Other Keycodes
#define KC_RST RESET
#define KC_BS KC_BSLASH
#define MG_NKRO MAGIC_TOGGLE_NKRO

101
users/bocaj/readme.md
View file

@ -1,102 +1,5 @@
# Overview
My personal QMK userspace. First, I must say that the credit for a majority of the code found here belongs to Drashna and/or the people he derived his code from. My Ergodox layout is briefly described in its respective folder. As for explaining this userspace, you could honestly go to Drashna's userspace and read his well put together readme. Regardless, I am mostly writing this as an excercise for myself to better understand what is going on, and where applicable, describe things that I innovated on my own.
This is my personal userspace file. Most of my code exists here, as it's heavily shared.
## Bocaj.c
### Unicode
I've always had difficulty implementing unicode in QMK, all of this code is literally copy/pasted from Drashna's userspace and lies dormant here until I can take the time to figure it out.
Update: Got it to work in Mac OS which is more important to me than Windows (probably pretty easy to figure out at this point). So I'm a happy table flipping person now!
(ノಠ痊ಠ)ノ彡┻━┻
┬─┬ノ( º _ ºノ)
### Tap Macro
Not sure why this doesn't exist in QMK already (maybe it does?)
```c
void tap(uint16_t keycode){ register_code(keycode); unregister_code(keycode); };
```
### *_keymap functions
We're running *_user functions in the userspace, that way we can add to or reconfigure at the keyboard level. Any *_user functions should call the equivalent *_keymap function at the end. If the *_keymap function isn't defined in the keymap, the `__attribute__ ((weak))` will prevent build problems.
### Startup/Suspend/Shutdown Functions
I have no idea what these do. Non-Ergodox keyboard functions?
### Matrix Scan User
Leader key defines, Diablo macro ancillary function, run matrix_scan_keymap.
#### Leader Key
I've always been interested in this feature, but I've had 0 experience with applications that have similar behavior. My implementation seeks to implement features that I feel VS2017 lacks
## Secrets
Hacked Drashna's secret macro implementation to work with the leader key instead.
TODO: Finish documentation
## Bocaj.h
Layer defines, some macro ancillary defines, setup Diablo macros and failsafe
## Process_Records.c/.h
Again, taking ideas from Drashna to make maintenance simpler. A couple of things that I'm proud of here, but nothing really ground breaking.
* Features
* Change default layer
* KC_MWRK, KC_WWRK, KC_MQWR
* MacOS Lock Screen Macro
* Make macro (Credit: Drashna)
* Need to reconfigure so it runs the docker command if one of the Mac OS layers are default because the AVR install fails on the corporate laptop
* Arrow macro (->) because I find myself telling people how to get to something quite frequently and typing this manually requires moving the right hand to the top-left of the ergodox and then to the bottom right, which feels unnatural.
* LM_GRAVE
* While combining _NUMS and _LOWER, I also needed a place to put F1-12 keys. This required me to relocate the grave key. The most comfortable place to put it was over a key that I frequently use to toggle the numpad. I do have other ways to get to/from this layer but my mind has been wired to use them for different workflows, so I would sit here frozen for a moment trying to tell my fingers where to go
* How it works
* A timer starts when pressed down
* If the timer at release was less than the TAPPING_TERM define
* Get mods
* If Shift was held or one-shot shift was active
* Send `~`
* Else
* Send `
* Else (timer at released was greater than the TAPPING_TERM define)
* Move to the default layer
* KC_CCCV
* Another neat idea I found in Drashna's userspace... highly underutilized in my layout but the inspiration for LM_GRAVE was obviously derived from this code
* Unicode stuff
* All I've ever wanted was a table-flip macro... I managed to get about half of it to work before I gave up and disabled it
## Send_Unicode.c/.h
I have some basic understanding of this, Drashna may already have it documented in his userspace. I'll put it in my own words when I get around to making it work and understanding it better.
## Tap_Dances.c/h
Again, building on Drashna's userspace organization to simplify maintenance of a heavily configured layout. This is all the stuff for the Diablo 3 macros that spam a given skill (1-4) every ~1 second
## Wrappers.h
Traditionally, you would put all of this into the \<username>.h file. But I liked the idea of separating it to simplify modification in the future.
### GUI_CTR(os, kc)
A notable mention in this file is the GUI_CTR(os, kc) custom keycode defined in process_records.h as:
```c
#define GUI_CTR(os, kc) MT( (os == 0) ? (MOD_LGUI) : (MOD_LCTL), kc )
```
I tried several things before coming to this one-liner conclusion. I believe it is quite elegant and it definitely solves the problem I had (separate wrappers for Windows/MacOS layers). But I would love to make this into something more intuitive, like a macro that detects which layer you're on and sends the applicable hotkey when held, or keycode when tapped. Ultimately, I was too tired of thinking about it to come up with a solution like that at this time.
Anyhow, if you set `os == 1`, it sends the Windows CTRL hotkey when held. If you set `os == 0`, it sends the Mac OS GUI hotkey when held. If tapped, it sends the keycode.
This is effectively a slightly more advanced `MOD_T(kc)` keycode.
The template was taken from [Drashna's userspace](https://github.com/qmk/qmk_firmware/tree/master/users/drashna). There isn't much if anything in this userspace that warrants documentation he hasn't already covered.

106
users/bocaj/rgb_matrix_stuff.c Normal file
View file

@ -0,0 +1,106 @@
#include "bocaj.h"
#include "lib/lib8tion/lib8tion.h"
extern led_config_t g_led_config;
static uint32_t hypno_timer;
#if defined(SPLIT_KEYBOARD) || defined(KEYBOARD_ergodox_ez) || defined(KEYBOARD_crkbd)
# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN_DUAL
#else
# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN
#endif
void rgb_matrix_set_color_row(uint8_t row, uint8_t red, uint8_t green, uint8_t blue) {
#ifdef KEYBOARD_planck_ez
if (row > 2) {
row = 0;
}
uint8_t row_multiplier = row * 12;
rgb_matrix_set_color(1 + row_multiplier, red, green, blue);
rgb_matrix_set_color(2 + row_multiplier, red, green, blue);
rgb_matrix_set_color(3 + row_multiplier, red, green, blue);
rgb_matrix_set_color(4 + row_multiplier, red, green, blue);
rgb_matrix_set_color(5 + row_multiplier, red, green, blue);
rgb_matrix_set_color(6 + row_multiplier, red, green, blue);
rgb_matrix_set_color(7 + row_multiplier, red, green, blue);
rgb_matrix_set_color(8 + row_multiplier, red, green, blue);
rgb_matrix_set_color(9 + row_multiplier, red, green, blue);
rgb_matrix_set_color(10 + row_multiplier, red, green, blue);
#endif
}
void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type) {
HSV hsv = {hue, sat, val};
if (hsv.v > rgb_matrix_get_val()) {
hsv.v = rgb_matrix_get_val();
}
switch (mode) {
case 1: // breathing
{
uint16_t time = scale16by8(g_rgb_timer, speed / 8);
hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v);
RGB rgb = hsv_to_rgb(hsv);
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
}
}
break;
}
default: // Solid Color
{
RGB rgb = hsv_to_rgb(hsv);
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
}
}
break;
}
}
}
__attribute__((weak)) void rgb_matrix_indicator_keymap(void) {}
void matrix_scan_rgb_matrix(void) {
#if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_TYPING_HEATMAP && timer_elapsed32(hypno_timer) > 15000) {
rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE);
}
#endif
rgb_matrix_indicator_keymap();
}
void keyboard_post_init_rgb_matrix(void) {
#if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
if (userspace_config.rgb_matrix_idle_anim) {
rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE);
}
#endif
}
bool process_record_user_rgb_matrix(uint16_t keycode, keyrecord_t *record) {
#if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
hypno_timer = timer_read32();
if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_REST_MODE) {
rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP);
}
#endif
switch (keycode) {
case RGB_IDL:
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
if (record->event.pressed) {
userspace_config.rgb_matrix_idle_anim ^= 1;
dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim);
eeconfig_update_user(userspace_config.raw);
if (userspace_config.rgb_matrix_idle_anim) {
rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP);
}
}
#endif
break;
}
return true;
}

10
users/bocaj/rgb_matrix_stuff.h Normal file
View file

@ -0,0 +1,10 @@
#pragma once
#include "quantum.h"
bool process_record_user_rgb_matrix(uint16_t keycode, keyrecord_t *record);
void keyboard_post_init_rgb_matrix(void);
void matrix_scan_rgb_matrix(void);
void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue);
void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type);
void rgb_matrix_set_color_row(uint8_t row, uint8_t red, uint8_t green, uint8_t blue);

47
users/bocaj/rules.mk
View file

@ -1,33 +1,26 @@
SRC += bocaj.c \
process_records.c
ifneq ("$(wildcard $(USER_PATH)/secrets.c)","")
SRC += secrets.c
LEADER_ENABLE = yes
MOUSEKEY_ENABLE = yes
EXTRAKEY_ENABLE = yes
ifneq ($(PLATFORM),CHIBIOS)
LTO_ENABLE = yes
endif
SPACE_CADET_ENABLE = no
GRAVE_ESC_ENABLE = no
ifneq ($(strip $(NO_SECRETS)), yes)
ifneq ("$(wildcard $(USER_PATH)/secrets.c)","")
SRC += secrets.c
endif
ifeq ($(strip $(NO_SECRETS)), lite)
OPT_DEFS += -DNO_SECRETS
endif
endif
ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
SRC += tap_dances.c
endif
# Caused problems when building via docker on Mac OS
# EXTRAFLAGS += -flto
ifeq ($(strip $(NO_SECRETS)), yes)
OPT_DEFS += -DNO_SECRETS
endif
ifeq ($(strip $(MACROS_ENABLED)), yes)
OPT_DEFS += -DMACROS_ENABLED
endif
ifeq ($(strip $(UCIS_ENABLE)), yes)
SRC += send_unicode.c
endif
ifeq ($(strip $(UNICODEMAP_ENABLE)), yes)
SRC += send_unicode.c
endif
ifeq ($(strip $(UNICODE_ENABLE)), yes)
SRC += send_unicode.c
RGB_MATRIX_ENABLE ?= no
ifneq ($(strip $(RGB_MATRIX_ENABLE)), no)
SRC += rgb_matrix_stuff.c
endif

106
users/bocaj/send_unicode.c
View file

@ -1,106 +0,0 @@
// Written by konstantin: vomindoraan
#include "send_unicode.h"
#include <ctype.h>
#include <string.h>
__attribute__((weak))
void send_unicode_hex_string(const char* str) {
if (!str) { return; } // Safety net
while (*str) {
// Find the next code point (token) in the string
for (; *str == ' '; str++);
size_t n = strcspn(str, " "); // Length of the current token
char code_point[n+1];
strncpy(code_point, str, n);
code_point[n] = '\0'; // Make sure it's null-terminated
// Normalize the code point: make all hex digits lowercase
for (char *p = code_point; *p; p++) {
*p = tolower((unsigned char)*p);
}
// Send the code point as a Unicode input string
unicode_input_start();
send_string(code_point);
unicode_input_finish();
str += n; // Move to the first ' ' (or '\0') after the current token
}
}
// (ノಠ痊ಠ)ノ彡┻━┻
// send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B");
//Old code
// (╯°□°)╯ ︵ ┻━┻
#if 0
register_code(KC_RSFT);
tap(KC_9);
unregister_code(KC_RSFT);
process_unicode((0x256F | QK_UNICODE), record); // Arm
process_unicode((0x00B0 | QK_UNICODE), record); // Eye
process_unicode((0x25A1 | QK_UNICODE), record); // Mouth
process_unicode((0x00B0 | QK_UNICODE), record); // Eye
register_code(KC_RSFT);
tap(KC_0);
unregister_code(KC_RSFT);
process_unicode((0x256F | QK_UNICODE), record); // Arm
tap(KC_SPC);
process_unicode((0x0361 | QK_UNICODE), record); // Flippy
tap(KC_SPC);
process_unicode((0x253B | QK_UNICODE), record); // Table
process_unicode((0x2501 | QK_UNICODE), record); // Table
process_unicode((0x253B | QK_UNICODE), record); // Table
#endif
// If you need a good converter: https://r12a.github.io/app-conversion/
uint8_t saved_mods;
void unicode_input_start (void) {
// save current mods
saved_mods = get_mods(); // Save current mods
clear_mods(); // Unregister mods to start from a clean state
switch(get_unicode_input_mode()) {
case UC_OSX:
register_code(KC_LALT);
break;
case UC_LNX:
register_code(KC_LCTL);
register_code(KC_LSFT);
register_code(KC_U);
unregister_code(KC_U);
unregister_code(KC_LSFT);
unregister_code(KC_LCTL);
break;
case UC_WIN:
register_code(KC_LALT);
register_code(KC_PPLS);
unregister_code(KC_PPLS);
break;
case UC_WINC:
register_code(KC_RALT);
unregister_code(KC_RALT);
register_code(KC_U);
unregister_code(KC_U);
break;
}
wait_ms(UNICODE_TYPE_DELAY);
}
void unicode_input_finish (void) {
switch(get_unicode_input_mode()) {
case UC_OSX:
case UC_WIN:
unregister_code(KC_LALT);
break;
case UC_LNX:
register_code(KC_SPC);
unregister_code(KC_SPC);
break;
}
set_mods(saved_mods); // Reregister previously set mods
}

71
users/bocaj/send_unicode.h
View file

@ -1,71 +0,0 @@
#pragma once
#include "quantum.h"
void send_unicode_hex_string(const char* str);
/* use X(n) to call the */
#ifdef UNICODEMAP_ENABLE
enum unicode_name {
THINK, // thinking face 🤔
GRIN, // grinning face 😊
SMRK, // smirk 😏
WEARY, // good shit 😩
UNAMU, // unamused 😒
SNEK, // snke 🐍
PENGUIN, // 🐧
DRAGON, // 🐉
MONKEY, // 🐒
CHICK, // 🐥
BOAR, // 🐗
OKOK, // 👌
EFFU, // 🖕
INUP, // 👆
THUP, // 👍
THDN, // 👎
BBB, // dat B 🅱
POO, // poop 💩
HUNDR, // 100 💯
EGGPL, // EGGPLANT 🍆
WATER, // wet 💦
TUMBLER, // 🥃
LIT, // fire 🔥
BANG, // ‽
IRONY, // ⸮
DEGREE // °
};
const uint32_t PROGMEM unicode_map[] = {
[THINK] = 0x1F914,
[GRIN] = 0x1F600,
[BBB] = 0x1F171,
[POO] = 0x1F4A9,
[HUNDR] = 0x1F4AF,
[SMRK] = 0x1F60F,
[WEARY] = 0x1F629,
[EGGPL] = 0x1F346,
[WATER] = 0x1F4A6,
[LIT] = 0x1F525,
[UNAMU] = 0x1F612,
[SNEK] = 0x1F40D,
[PENGUIN] = 0x1F427,
[BOAR] = 0x1F417,
[MONKEY] = 0x1F412,
[CHICK] = 0x1F425,
[DRAGON] = 0x1F409,
[OKOK] = 0x1F44C,
[EFFU] = 0x1F595,
[INUP] = 0x1F446,
[THDN] = 0x1F44E,
[THUP] = 0x1F44D,
[TUMBLER] = 0x1F943,
[BANG] = 0x0203D,
[IRONY] = 0x02E2E,
[DEGREE] = 0x000B0
};
#endif // UNICODEMAP_ENABLE

64
users/bocaj/tap_dances.c
View file

@ -1,64 +0,0 @@
#include "tap_dances.h"
//define diablo macro timer variables
uint16_t diablo_timer[4];
uint8_t diablo_times[] = { 0, 1, 3, 5, 10, 30 };
uint8_t diablo_key_time[4];
// has the correct number of seconds elapsed (as defined by diablo_times)
bool check_dtimer(uint8_t dtimer) { return (timer_elapsed(diablo_timer[dtimer]) < (diablo_key_time[dtimer] * 1000)) ? false : true; };
// Cycle through the times for the macro, starting at 0, for disabled.
// Max of six values, so don't exceed
void diablo_tapdance_master(qk_tap_dance_state_t *state, void *user_data, uint8_t diablo_key) {
if (state->count >= 7) {
diablo_key_time[diablo_key] = diablo_times[0];
reset_tap_dance(state);
} else {
diablo_key_time[diablo_key] = diablo_times[state->count - 1];
}
}
// Would rather have one function for all of this, but no idea how to do that...
void diablo_tapdance1(qk_tap_dance_state_t *state, void *user_data) { diablo_tapdance_master(state, user_data, 0); }
void diablo_tapdance2(qk_tap_dance_state_t *state, void *user_data) { diablo_tapdance_master(state, user_data, 1); }
void diablo_tapdance3(qk_tap_dance_state_t *state, void *user_data) { diablo_tapdance_master(state, user_data, 2); }
void diablo_tapdance4(qk_tap_dance_state_t *state, void *user_data) { diablo_tapdance_master(state, user_data, 3); }
//Tap Dance Definitions
qk_tap_dance_action_t tap_dance_actions[] = {
// tap once to disable, and more to enable timed micros
[TD_D3_1] = ACTION_TAP_DANCE_FN(diablo_tapdance1),
[TD_D3_2] = ACTION_TAP_DANCE_FN(diablo_tapdance2),
[TD_D3_3] = ACTION_TAP_DANCE_FN(diablo_tapdance3),
[TD_D3_4] = ACTION_TAP_DANCE_FN(diablo_tapdance4),
};
// Sends the key press to system, but only if on the Diablo layer
void send_diablo_keystroke(uint8_t diablo_key) {
if (biton32(layer_state) == _DIABLO) {
switch (diablo_key) {
case 0:
tap(KC_1); break;
case 1:
tap(KC_2); break;
case 2:
tap(KC_3); break;
case 3:
tap(KC_4); break;
}
}
}
// Checks each of the 4 timers/keys to see if enough time has elapsed
// Runs the "send string" command if enough time has passed, and resets the timer.
void run_diablo_macro_check(void) {
uint8_t dtime;
for (dtime = 0; dtime < 4; dtime++) {
if (check_dtimer(dtime) && diablo_key_time[dtime]) {
diablo_timer[dtime] = timer_read();
send_diablo_keystroke(dtime);
}
}
}

19
users/bocaj/tap_dances.h
View file

@ -1,19 +0,0 @@
#pragma once
#include "bocaj.h"
//define diablo macro timer variables
extern uint16_t diablo_timer[4];
extern uint8_t diablo_times[];
extern uint8_t diablo_key_time[4];
void run_diablo_macro_check(void);
#ifdef TAP_DANCE_ENABLE
enum {
TD_D3_1 = 0,
TD_D3_2,
TD_D3_3,
TD_D3_4
};
#endif // TAP_DANCE_ENABLE

202
users/bocaj/wrappers.h
View file

@ -1,37 +1,193 @@
#pragma once
#include "bocaj.h"
/*
Since our quirky block definitions are basically a list of comma separated
arguments, we need a wrapper in order for these definitions to be
expanded before being used as arguments to the LAYOUT_xxx macro.
*/
#if (!defined(LAYOUT) && defined(KEYMAP))
#define LAYOUT KEYMAP
# define LAYOUT KEYMAP
#endif
#define LAYOUT_ergodox_wrapper(...) LAYOUT_ergodox(__VA_ARGS__)
#define LAYOUT_ergodox_pretty_wrapper(...) LAYOUT_ergodox_pretty(__VA_ARGS__)
// clang-format off
#define WRAPPER_ergodox_pretty(...) LAYOUT_ergodox_pretty(__VA_ARGS__)
#define WRAPPER_ortho_4x12(...) LAYOUT_planck_mit(__VA_ARGS__)
#define _________________QWERTY_L1__________________ KC_Q, KC_W, KC_E, KC_R, KC_T
#define _________________QWERTY_L2__________________ KC_A, KC_S, GUI_CTR(0, KC_D), KC_F, KC_G
#define _________________QWERTY_L3__________________ KC_Z, KC_X, KC_C, KC_V, KC_B
/* ---------- LEFT HAND ----------- ---------- RIGHT HAND ---------- */
#define WRAPPER_ergodox_bocaj( \
L00,L01,L02,L03,L04,L05,L06, R00,R01,R02,R03,R04,R05,R06, \
L10,L11,L12,L13,L14,L15,L16, R10,R11,R12,R13,R14,R15,R16, \
L20,L21,L22,L23,L24,L25, R21,R22,R23,R24,R25,R26, \
L30,L31,L32,L33,L34,L35,L36, R30,R31,R32,R33,R34,R35,R36, \
L40,L41,L42,L43,L44, R42,R43,R44,R45,R46, \
L55,L56, R50,R51, \
L54, R52, \
L53,L52,L51, R55,R54,R53 ) \
WRAPPER_ergodox_pretty( \
L00, L01, L02, L03, L04, L05, L06, R00, R01, R02, R03, R04, R05, R06, \
L10, L11, L12, L13, L14, L15, L16, R10, R11, R12, R13, R14, R15, R16, \
L20, L21, SFT_T(L22), GUI_T(L23), ALT_T(L24), L25, R21, ALT_T(R22), GUI_T(R23), SFT_T(R24), R25, R26, \
L30, CTL_T(L31), L32, L33, L34, L35, ALL_T(L36), MEH_T(R30), R31, R32, R33, R34, CTL_T(R35), R36, \
L40, L41, L42, L43, L44, R42, R43, R44, R45, R46, \
L55,L56, /* <- LHS/RHS -> */ R50,R51, \
L54, /* <- LHS/RHS -> */ R52, \
LT(_LOWER, L53),L52,L51, /* <- LHS/RHS -> */ R55,R54,LT(_RAISE, R53) \
)
#define _________________QWERTY_R1__________________ KC_Y, KC_U, KC_I, KC_O, KC_P
#define _________________QWERTY_R2__________________ KC_H, KC_J, GUI_CTR(0, KC_K), KC_L, KC_SCLN
#define _________________QWERTY_R3__________________ KC_N, KC_M, KC_COMM, KC_DOT, KC_SLASH
#define WRAPPER_ergodox_bocaj_WIN( \
L00,L01,L02,L03,L04,L05,L06, R00,R01,R02,R03,R04,R05,R06, \
L10,L11,L12,L13,L14,L15,L16, R10,R11,R12,R13,R14,R15,R16, \
L20,L21,L22,L23,L24,L25, R21,R22,R23,R24,R25,R26, \
L30,L31,L32,L33,L34,L35,L36, R30,R31,R32,R33,R34,R35,R36, \
L40,L41,L42,L43,L44, R42,R43,R44,R45,R46, \
L55,L56, R50,R51, \
L54, R52, \
L53,L52,L51, R55,R54,R53 ) \
WRAPPER_ergodox_pretty( \
L00, L01, L02, L03, L04, L05, L06, R00, R01, R02, R03, R04, R05, R06, \
L10, L11, L12, L13, L14, L15, L16, R10, R11, R12, R13, R14, R15, R16, \
L20, L21, SFT_T(L22), CTL_T(L23), ALT_T(L24), L25, R21, ALT_T(R22), CTL_T(R23), SFT_T(R24), R25, R26, \
L30, GUI_T(L31), L32, L33, L34, L35, ALL_T(L36), MEH_T(R30), R31, R32, R33, R34, GUI_T(R35), R36, \
L40, L41, L42, L43, L44, R42, R43, R44, R45, R46, \
L55,L56, /* <- LHS/RHS -> */ R50,R51, \
L54, /* <- LHS/RHS -> */ R52, \
LT(_LOWER, L53),L52,L51, /* <- LHS/RHS -> */ R55,R54,LT(_RAISE, R53) \
)
// Hardware Driven Workman
#define _________________WORKMAN_L1_________________ KC_Q, KC_D, KC_R, KC_W, KC_B
#define _________________WORKMAN_L2_________________ KC_A, KC_S, GUI_CTR(0, KC_H), KC_T, KC_G // GUI_CTR(0, kc) behaves as GUI_T(kc)
#define ________________WWORKMAN_L2_________________ KC_A, KC_S, GUI_CTR(1, KC_H), KC_T, KC_G // GUI_CTR(1, kc) behaves as CTR_T(kc)
#define _________________WORKMAN_L3_________________ KC_Z, KC_X, KC_M, KC_C, KC_V
/*
Planck EZ Wrappers
*/
#define WRAPPER_planck_bocaj( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, \
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, \
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, \
K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B \
)\
WRAPPER_ortho_4x12( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, \
K11, K12, SFT_T(K13), GUI_T(K14), ALT_T(K15), K16, K17, ALT_T(K18), GUI_T(K19), SFT_T(K1A), K1B, K1C, \
K21, CTL_T(K22), K23, K24, K25, K26, K27, K28, K29, K2A, CTL_T(K2B), K2C, \
K31, K32, K33, K34, LT(_LOWER, K35), K36, LT(_RAISE, K37), K38, K39, K3A, K3B )
#define _________________WORKMAN_R1_________________ KC_J, KC_F, KC_U, KC_P, KC_SCLN
#define _________________WORKMAN_R2_________________ KC_Y, KC_N, GUI_CTR(0, KC_E), KC_O, KC_I // GUI_CTR(0, kc) behaves as GUI_T(kc)
#define ________________WWORKMAN_R2_________________ KC_Y, KC_N, GUI_CTR(1, KC_E), KC_O, KC_I // GUI_CTR(1, kc) behaves as CTR_T(kc)
#define _________________WORKMAN_R3_________________ KC_K, KC_L, KC_COMM, KC_DOT, KC_SLASH
#define WRAPPER_planck_bocaj_WIN( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, \
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, \
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, \
K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B \
)\
WRAPPER_ortho_4x12( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, \
K11, K12, SFT_T(K13), CTL_T(K14), ALT_T(K15), K16, K17, ALT_T(K18), CTL_T(K19), SFT_T(K1A), K1B, K1C, \
K21, GUI_T(K22), K23, K24, K25, K26, K27, K28, K29, K2A, GUI_T(K2B), K2C, \
K31, K32, K33, K34, LT(_LOWER, K35), K36, LT(_RAISE, K37), K38, K39, K3A, K3B )
#define WRAPPER_planck_bocaj_base( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \
) \
WRAPPER_planck_bocaj( \
KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \
KC_TAB, K11, K12, K13, K14, ALL_T(K15), MEH_T(K16), K17, K18, K19, K1A, KC_QUOT, \
KC_LSFT, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, _______, \
_______, KC_LEAD, KC_UP, KC_LEFT, KC_BSPC, KC_SPC, KC_ENTER, KC_RIGHT, KC_DOWN, QWERTY, WORKMAN \
)
#define __________________NUMBER_LEFT_______________ KC_1, KC_2, KC_3, KC_4, KC_5
#define __________________NUMBER_RIGHT______________ KC_6, KC_7, KC_8, KC_9, KC_0
#define WRAPPER_planck_bocaj_base_WIN( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \
) \
WRAPPER_planck_bocaj_WIN( \
KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \
KC_TAB, K11, K12, K13, K14, ALL_T(K15), MEH_T(K16), K17, K18, K19, K1A, KC_QUOT, \
KC_LSFT, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, _______, \
_______, KC_LEAD, KC_UP, KC_LEFT, KC_BSPC, KC_SPC, KC_ENTER, KC_RIGHT, KC_DOWN, QWERTY, WORKMAN \
)
#define __________________FUNCTION_LEFT_____________ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5
#define __________________FUNCTION_RIGHT____________ KC_F6, KC_F7, KC_F8, KC_F9, KC_F10
/*
Blocks for each of the four major keyboard layouts
Organized so we can quickly adapt and modify all of them
at once, rather than for each keyboard, one at a time.
And this allows for much cleaner blocks in the keymaps.
For instance Tap/Hold for Control on all of the layouts
#define ____________________BLANK___________________ KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
NOTE: These are all the same length. If you do a search/replace
then you need to add/remove underscores to keep the
lengths consistent.
*/
#define _________________QWERTY_L1_________________ KC_Q, KC_W, KC_E, KC_R, KC_T
#define _________________QWERTY_L2_________________ KC_A, KC_S, KC_D, KC_F, KC_G
#define _________________QWERTY_L3_________________ KC_Z, KC_X, KC_C, KC_V, KC_B
#define _________________QWERTY_R1_________________ KC_Y, KC_U, KC_I, KC_O, KC_P
#define _________________QWERTY_R2_________________ KC_H, KC_J, KC_K, KC_L, KC_SCLN
#define _________________QWERTY_R3_________________ KC_N, KC_M, KC_COMM, KC_DOT, KC_SLASH
#define _________________COLEMAK_L1________________ KC_Q, KC_W, KC_F, KC_P, KC_G
#define _________________COLEMAK_L2________________ KC_A, KC_R, KC_S, KC_T, KC_D
#define _________________COLEMAK_L3________________ KC_Z, KC_X, KC_C, KC_V, KC_B
#define _________________COLEMAK_R1________________ KC_J, KC_L, KC_U, KC_Y, KC_SCLN
#define _________________COLEMAK_R2________________ KC_H, KC_N, KC_E, KC_I, KC_O
#define _________________COLEMAK_R3________________ KC_K, KC_M, KC_COMM, KC_DOT, KC_SLASH
#define _________________DVORAK_L1_________________ KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y
#define _________________DVORAK_L2_________________ KC_A, KC_O, KC_E, KC_U, KC_I
#define _________________DVORAK_L3_________________ KC_SCLN, KC_Q, KC_J, KC_K, KC_X
#define _________________DVORAK_R1_________________ KC_F, KC_G, KC_C, KC_R, KC_L
#define _________________DVORAK_R2_________________ KC_D, KC_H, KC_T, KC_N, KC_S
#define _________________DVORAK_R3_________________ KC_B, KC_M, KC_W, KC_V, KC_Z
#define _________________WORKMAN_L1________________ KC_Q, KC_D, KC_R, KC_W, KC_B
#define _________________WORKMAN_L2________________ KC_A, KC_S, KC_H, KC_T, KC_G
#define _________________WORKMAN_L3________________ KC_Z, KC_X, KC_M, KC_C, KC_V
#define _________________WORKMAN_R1________________ KC_J, KC_F, KC_U, KC_P, KC_SCLN
#define _________________WORKMAN_R2________________ KC_Y, KC_N, KC_E, KC_O, KC_I
#define _________________WORKMAN_R3________________ KC_K, KC_L, KC_COMM, KC_DOT, KC_SLASH
#define ________________NUMBER_LEFT________________ KC_1, KC_2, KC_3, KC_4, KC_5
#define ________________NUMBER_RIGHT_______________ KC_6, KC_7, KC_8, KC_9, KC_0
#define _________________FUNC_LEFT_________________ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5
#define _________________FUNC_RIGHT________________ KC_F6, KC_F7, KC_F8, KC_F9, KC_F10
#define ___________________BLANK___________________ _______, _______, _______, _______, _______
#define _________________UNDEFINED_________________ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
#define ___________________LOWER_L1_EXT____________________ KC_GRV, _______, _______, KC_UP, _______, KC_ARRW
#define ___________________LOWER_L2_EXT____________________ KC_DEL, _______, KC_LEFT, KC_DOWN, KC_RGHT, KC_LPRN
#define ___________________LOWER_L3_EXT____________________ _______, _______, _______, _______, _______, KC_LBRC
#define ___________________LOWER_R1_EXT____________________ KC_MINS, KC_7, KC_8, KC_9, KC_PLUS, KC_EQUAL
#define ___________________LOWER_R2_EXT____________________ KC_RPRN, KC_4, KC_5, KC_6, KC_ASTR, KC_BSLS
#define ___________________LOWER_R3_EXT____________________ KC_RBRC, KC_1, KC_2, KC_3, KC_SLSH, _______
// #define _________________LOWER_L1__________________ ________________NUMBER_LEFT________________
// #define _________________LOWER_L2__________________ _______, _______, _______, _______, KC_LPRN
// #define _________________LOWER_L3__________________ _______, _______, _______, KC_ARRW, KC_LBRC
// #define _________________LOWER_R1__________________ ________________NUMBER_RIGHT_______________
// #define _________________LOWER_R2__________________ KC_RPRN, _______, _______, _______, _______
// #define _________________LOWER_R3__________________ KC_RBRC, _______, _______, _______, _______
#define _________________RAISE_L1__________________ KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC
#define _________________RAISE_L2__________________ _________________FUNC_LEFT_________________
#define _________________RAISE_L3__________________ ___________________BLANK___________________
#define _________________RAISE_R1__________________ KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN
#define _________________RAISE_R2__________________ _________________FUNC_RIGHT________________
#define _________________RAISE_R3__________________ ___________________BLANK___________________
#define _________________ADJUST_L1_________________ RGB_MOD, RGB_HUI, RGB_SAI, RGB_VAI, RGB_TOG
#define _________________ADJUST_L2_________________ KC__MUTE, KC__VOLDOWN, KC__VOLUP, _______, KC_MNXT
#define _________________ADJUST_L3_________________ RGB_RMOD, RGB_HUD, RGB_SAD, RGB_VAD, KC_RGB_T
#define _________________ADJUST_R1_________________ ___________________BLANK___________________
#define _________________ADJUST_R2_________________ CG_SWAP, WORKMAN, QWERTY, _______, _______
#define _________________ADJUST_R3_________________ MU_TOG , CK_TOGG, AU_ON, AU_OFF, CG_NORM
// clang-format on