mirrors/qmk_userspace
1
0
Fork 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2025-06-01 03:50:08 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Cleanup and Adding more overrides

Browse source 
- Updated documentation and standardize identation formatting
- Added numpad key overrides to get function keys
- got rid of function layer
This commit is contained in:
Victor 2024-05-10 00:00:37 -05:00
parent 7c923a5c4a
commit fdfc997c28
Failed to generate hash of commit
19 changed files with 143 additions and 394 deletions
Download patch file Download diff file Expand all files Collapse all files

5
users/t4corun/features/capsword.c
View file

@ -3,9 +3,12 @@
//static bool caps_word_state = false;
bool caps_word_press_user(uint16_t keycode) {
switch (keycode) {
// Keycodes that continue Caps Word, with shift applied.
case KC_A ... KC_Z:
case KC_MINS:
add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to next key.
return true;
@ -19,5 +22,7 @@ bool caps_word_press_user(uint16_t keycode) {
default:
return false; // Deactivate Caps Word.
}
}

21
users/t4corun/features/combo.c
View file

@ -17,30 +17,24 @@ bool get_combo_must_tap(uint16_t index, combo_t *combo) {
default:
return false;
}
}
bool combo_should_trigger(uint16_t combo_index, combo_t *combo, uint16_t keycode, keyrecord_t *record) {
// disable all combos on config layer
if ( get_highest_layer(layer_state) == _CONFIG ) {
return false;
}
if ( get_highest_layer(layer_state) == _CONFIG ) return false;
switch (combo_index) {
case KEY_ENT:
if ( get_highest_layer(layer_state) == _SYMBOL ) {
return false;
}
break;
if ( get_highest_layer(layer_state) == _SYMBOL ) return false;
case KEY_TAB:
if ( get_highest_layer(layer_state) == _NAVIGATION ||
get_highest_layer(layer_state) == _SYMBOL ) {
return false;
}
break;
get_highest_layer(layer_state) == _SYMBOL ) return false;
case MOUSE_BUTTON1:
case MOUSE_BUTTON2:
@ -48,10 +42,7 @@ bool combo_should_trigger(uint16_t combo_index, combo_t *combo, uint16_t keycode
case MOUSE_BUTTON4:
case MOUSE_BUTTON5:
case MOUSE_DRGTOG:
if ( get_highest_layer(layer_state) > _DEFAULT_LAYER_1 ) {
return false;
}
break;
if ( get_highest_layer(layer_state) > _DEFAULT_LAYER_1 ) return false;
}

1
users/t4corun/features/combo.h
View file

@ -34,6 +34,7 @@ enum combos {
KEY_BSPC,
COMBO_LENGTH
};

27
users/t4corun/features/keyoverride.c
View file

@ -15,10 +15,35 @@ Intentionally did not convert all the override/autoshit tap holds to this format
const key_override_t delete_override = ko_make_basic(MOD_MASK_SHIFT, KC_BSPC, KC_DEL);
const key_override_t media_next_override = ko_make_basic(MOD_MASK_SHIFT, KC_MNXT, KC_MPRV);
const key_override_t **key_overrides = (const key_override_t *[]){
const key_override_t f1_override = ko_make_with_layers(MOD_MASK_CSA, KC_1, KC_F1, _NUMBER);
const key_override_t f2_override = ko_make_with_layers(MOD_MASK_CSA, KC_2, KC_F2, _NUMBER);
const key_override_t f3_override = ko_make_with_layers(MOD_MASK_CSA, KC_3, KC_F3, _NUMBER);
const key_override_t f4_override = ko_make_with_layers(MOD_MASK_CSA, KC_4, KC_F4, _NUMBER);
const key_override_t f5_override = ko_make_with_layers(MOD_MASK_CSA, KC_5, KC_F5, _NUMBER);
const key_override_t f6_override = ko_make_with_layers(MOD_MASK_CSA, KC_6, KC_F6, _NUMBER);
const key_override_t f7_override = ko_make_with_layers(MOD_MASK_CSA, KC_7, KC_F7, _NUMBER);
const key_override_t f8_override = ko_make_with_layers(MOD_MASK_CSA, KC_8, KC_F8, _NUMBER);
const key_override_t f9_override = ko_make_with_layers(MOD_MASK_CSA, KC_9, KC_F9, _NUMBER);
const key_override_t f10_override = ko_make_with_layers(MOD_MASK_CSA, KC_COMM, KC_F10, _NUMBER);
const key_override_t f11_override = ko_make_with_layers(MOD_MASK_CSA, KC_DOT, KC_F11, _NUMBER);
const key_override_t f12_override = ko_make_with_layers(MOD_MASK_CSA, TR_MINS, KC_F12, _NUMBER);
const key_override_t **key_overrides = (const key_override_t *[]) {
&delete_override,
&media_next_override,
&f1_override,
&f2_override,
&f3_override,
&f4_override,
&f5_override,
&f6_override,
&f7_override,
&f8_override,
&f9_override,
&f10_override,
&f11_override,
&f12_override,
NULL // Null terminate the array of overrides!
};

38
users/t4corun/features/oled.c
View file

@ -1,19 +1,27 @@
#include "oled.h"
void render_crkbd_logo(void) {
oled_write_P(crkbd_logo, false);
}
void render_rollow_logo(void) {
oled_write_raw_P(rollow_logo, sizeof(rollow_logo));
}
void render_qmk_logo(void) {
oled_write_raw_P(qmk_logo, sizeof(qmk_logo));
}
void render_default_layer_state(void) {
oled_write_P(PSTR(OLED_RENDER_LAYOUT_NAME), false);
switch (get_highest_layer(default_layer_state)) {
case _QWERTY:
@ -27,32 +35,38 @@ void render_default_layer_state(void) {
case _GAME:
oled_write_P(PSTR(OLED_RENDER_LAYOUT_GAME), false);
break;
}
}
void render_layer_state(void) {
oled_write_P(PSTR(OLED_RENDER_LAYER_NAME), false);
oled_write_P(PSTR(OLED_RENDER_LAYER_BASE), get_highest_layer(layer_state) == FIRST_DEFAULT_LAYER);
oled_write_P(PSTR(OLED_RENDER_LAYER_NAVIGATION), get_highest_layer(layer_state) == _NAVIGATION);
oled_write_P(PSTR(OLED_RENDER_LAYER_NUMBER), get_highest_layer(layer_state) == _NUMBER);
oled_write_P(PSTR(OLED_RENDER_LAYER_SYMBOL), get_highest_layer(layer_state) == _SYMBOL);
oled_write_P(PSTR(OLED_RENDER_LAYER_FUNCTION), get_highest_layer(layer_state) == _FUNCTION);
//oled_write_P(PSTR(OLED_RENDER_LAYER_FUNCTION), get_highest_layer(layer_state) == _FUNCTION);
oled_write_P(PSTR(OLED_RENDER_LAYER_CONFIG), get_highest_layer(layer_state) == _CONFIG);
}
void render_keylock_status(void) {
oled_write_P(PSTR(OLED_RENDER_KEYLOCK_NAME), false);
oled_write_P(PSTR(" "), false);
oled_write_P(PSTR("N"), host_keyboard_led_state().num_lock);
oled_write_P(PSTR("C"), host_keyboard_led_state().caps_lock || is_caps_word_on() );
oled_write_ln_P(PSTR("S"), host_keyboard_led_state().scroll_lock );
}
void render_mod_status(void) {
uint8_t current_mod = get_mods();
uint8_t current_osm = get_oneshot_mods();
@ -68,6 +82,7 @@ void render_mod_status(void) {
oled_write_P(PSTR("C"), isCtrl );
oled_write_P(PSTR("A"), isAlt );
oled_write_P(PSTR("G"), isGUI );
}
@ -82,26 +97,39 @@ void render_oled_main(void) {
bool oled_task_user(void) {
if (is_keyboard_master()) {
render_oled_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
} else {
#if defined( KEYBOARD_barbellboards_rollow )
#if defined(KEYBOARD_barbellboards_rollow)
render_rollow_logo();
#elif defined( KEYBOARD_crkbd )
#elif defined(KEYBOARD_crkbd)
render_crkbd_logo();
#else
render_qmk_logo();
#endif
}
return false;
}
oled_rotation_t oled_init_user(oled_rotation_t rotation) {
if (is_keyboard_master()) {
return OLED_ROTATION_270;
} else {
return OLED_ROTATION_0;
}
}

2
users/t4corun/features/oled.h
View file

@ -15,7 +15,7 @@
#define OLED_RENDER_LAYER_NAVIGATION " Nav "
#define OLED_RENDER_LAYER_NUMBER " Num "
#define OLED_RENDER_LAYER_SYMBOL " Sym "
#define OLED_RENDER_LAYER_FUNCTION " Fun "
//#define OLED_RENDER_LAYER_FUNCTION " Fun "
#define OLED_RENDER_LAYER_CONFIG " Cfg "
void render_crkbd_logo(void);

159
users/t4corun/features/taphold.c
View file

@ -1,33 +1,5 @@
#include "taphold.h"
/*
void single_tap(uint16_t key, uint16_t altkey, bool isHold) {
isHold ? tap_code16(altkey) : tap_code16(key);
}
void double_tap(uint16_t key, uint16_t altkey, uint32_t ms) {
bool isShift = ( (get_mods() & MOD_BIT(KC_LSFT)) || (get_oneshot_mods() & MOD_BIT(KC_LSFT)) );
isShift ? tap_code16(LSFT(key)) : tap_code16(key);
wait_ms(ms);
isShift ? tap_code16(LSFT(altkey)) : tap_code16(altkey);
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms) {
bool isShift = ( (get_mods() & MOD_BIT(KC_LSFT)) || (get_oneshot_mods() & MOD_BIT(KC_LSFT)) );
isShift ? tap_code16(LSFT(left)) : tap_code16(left);
wait_ms(ms);
isShift ? tap_code16(LSFT(right)) : tap_code16(right);
wait_ms(ms);
tap_code16(KC_LEFT);
}
*/
void single_tap(uint16_t key) {
tap_code16(key);
}
void double_tap(uint16_t key, uint32_t ms) {
@ -49,9 +21,6 @@ void insert_brackets(uint16_t left, uint16_t right, uint32_t ms) {
bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t hold_keycode, int mode) {
// https://getreuer.info/posts/keyboards/triggers/index.html#tap-vs.-long-press
if (record->tap.count > 0) { // Key is being tapped
// register on press, unregister on release
@ -78,131 +47,3 @@ bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t ho
return false;
}
/*
// here we can have the holds be more complex, like sending "" when you hold "
bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode) {
// tap is record->tap.count && record->event.pressed
// hold is record->event.pressed
// just saving this to handle mods
// bool isShift = ( (get_mods() & MOD_BIT(KC_LSFT)) || (get_oneshot_mods() & MOD_BIT(KC_LSFT)) );
// isShift ? insert_brackets(LSFT(key), LSFT(altkey)) : insert_brackets(key, altkey);
bool isHold = false;
if (record->tap.count && record->event.pressed) {
switch(keycode) {
case TR_LCBR:
single_tap(TAPHOLD_LCBR, isHold); break;
case TR_LABK:
single_tap(TAPHOLD_LABK, isHold); break;
case TR_LBRC:
single_tap(TAPHOLD_LBRC, isHold); break;
case TR_LPRN:
single_tap(TAPHOLD_LPRN, isHold); break;
case TR_DQUO:
single_tap(TAPHOLD_DQUO, isHold); break;
case TR_SQUO:
single_tap(TAPHOLD_SQUO, isHold); break;
case TR_BSLS:
single_tap(TAPHOLD_BSLS, isHold); break;
case TR_SLSH:
single_tap(TAPHOLD_SLSH, isHold); break;
case TR_PIPE:
single_tap(TAPHOLD_PIPE, isHold); break;
case TR_COMM:
single_tap(TAPHOLD_COMM, isHold); break;
case TR_DOT:
single_tap(TAPHOLD_DOT, isHold); break;
case TR_PERC:
single_tap(TAPHOLD_PERC, isHold); break;
case TR_EQL:
single_tap(TAPHOLD_EQL, isHold); break;
case TR_MINS:
single_tap(TAPHOLD_MINS, isHold); break;
case TR_GRV:
single_tap(TAPHOLD_GRV, isHold); break;
case TR_SCLN:
single_tap(TAPHOLD_SCLN, isHold); break;
case TR_QUOT:
single_tap(TAPHOLD_QUOT, isHold); break;
}
return false;
} else if (record->tap.count == 0 && record->event.pressed) {
isHold = true;
switch(keycode) {
// Brackets: open and close brackets and put the cursor inside
case TR_LCBR:
insert_brackets(TAPHOLD_LCBR, WAIT_DELAY); break;
case TR_LABK:
insert_brackets(TAPHOLD_LABK, WAIT_DELAY); break;
case TR_LBRC:
insert_brackets(TAPHOLD_LBRC, WAIT_DELAY); break;
case TR_LPRN:
insert_brackets(TAPHOLD_LPRN, WAIT_DELAY); break;
case TR_DQUO:
insert_brackets(TAPHOLD_DQUO, WAIT_DELAY); break;
case TR_SQUO:
insert_brackets(TAPHOLD_SQUO, WAIT_DELAY); break;
// double tap
case TR_BSLS:
double_tap(TAPHOLD_BSLS, WAIT_DELAY); break;
case TR_SLSH:
double_tap(TAPHOLD_SLSH, WAIT_DELAY); break;
case TR_PIPE:
double_tap(TAPHOLD_PIPE, WAIT_DELAY); break;
// custom override without holding shift
case TR_COMM:
single_tap(TAPHOLD_COMM, isHold); break;
case TR_DOT:
single_tap(TAPHOLD_DOT, isHold); break;
case TR_PERC:
single_tap(TAPHOLD_PERC, isHold); break;
// simulates auto-shift
case TR_EQL:
single_tap(TAPHOLD_EQL, isHold); break;
case TR_MINS:
single_tap(TAPHOLD_MINS, isHold); break;
case TR_GRV:
single_tap(TAPHOLD_GRV, isHold); break;
case TR_SCLN:
single_tap(TAPHOLD_SCLN, isHold); break;
case TR_QUOT:
single_tap(TAPHOLD_QUOT, isHold); break;
}
return false;
}
return true; // Continue default handling.
}
*/

47
users/t4corun/features/taphold.h
View file

@ -1,52 +1,7 @@
#pragma once
#include "t4corun.h"
/*
void single_tap(uint16_t key, uint16_t altkey, bool isHold);
void double_tap(uint16_t key, uint16_t altkey, uint32_t ms);
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms);
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms);
bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode);
*/
void single_tap(uint16_t key);
void double_tap(uint16_t key, uint32_t ms);
void insert_brackets(uint16_t left, uint16_t right, uint32_t ms);
bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t hold_keycode, int mode);
/* the first element is the alt key (tap action)
* the second is altkey (hold action usually)
*
* I was doing a switch statement to assign these each time, but this is faster
* and easier to maintain
*/
/*
// Brackets: open and close brackets and put the cursor inside
#define TAPHOLD_LCBR KC_LCBR, KC_RCBR
#define TAPHOLD_LABK KC_LABK, KC_RABK
#define TAPHOLD_LBRC KC_LBRC, KC_RBRC
#define TAPHOLD_LPRN KC_LPRN, KC_RPRN
#define TAPHOLD_DQUO KC_DQUO, KC_DQUO
#define TAPHOLD_SQUO KC_QUOT, KC_QUOT
// double tap
#define TAPHOLD_BSLS KC_BSLS, KC_BSLS
#define TAPHOLD_SLSH KC_SLSH, KC_SLSH
#define TAPHOLD_PIPE KC_PIPE, KC_PIPE
// Custom override without holding shift
#define TAPHOLD_COMM KC_COMM, KC_LPRN
#define TAPHOLD_DOT KC_DOT, KC_RPRN
#define TAPHOLD_PERC KC_PERC, KC_CIRC
// auto shift
#define TAPHOLD_EQL KC_EQL, KC_PLUS
#define TAPHOLD_MINS KC_MINS, KC_UNDS
#define TAPHOLD_GRV KC_GRV, KC_TILD
#define TAPHOLD_SCLN KC_SCLN, KC_COLN
#define TAPHOLD_QUOT KC_QUOT, KC_DQUO
*/
bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t hold_keycode, int mode);

1
users/t4corun/features/tapping.c
View file

@ -8,7 +8,6 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
return TAPPING_TERM + 60;
default:
//uprintf("tapping term: %d \n", TAPPING_TERM);
return TAPPING_TERM;
}