mirrors/qmk_userspace
1
0
Fork 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2025-11-03 10:20:07 -05:00
Code Issues Projects Releases Packages Wiki Activity

modularize features

Browse source
This commit is contained in:
Pablo Ontiveros 2025-08-29 12:34:11 -06:00
commit 82203a8a05
9 changed files with 743 additions and 694 deletions
Download patch file Download diff file Expand all files Collapse all files

3
.claude/settings.local.json
View file

@ -11,7 +11,8 @@
"WebFetch(domain:raw.githubusercontent.com)",
"Bash(curl:*)",
"WebSearch",
"WebFetch(domain:docs.qmk.fm)"
"WebFetch(domain:docs.qmk.fm)",
"Bash(rm:*)"
],
"deny": [],
"ask": [],

27
keyboards/crkbd/rev1/keymaps/pones/combos.c Normal file
View file

@ -0,0 +1,27 @@
#include QMK_KEYBOARD_H
#include "custom_keycodes.h"
// Home row modifiers (refer to keymap.c for primary definitions)
#define HM_A LGUI_T(KC_A)
#define HM_S LALT_T(KC_S)
#define HM_D LCTL_T(KC_D)
#define HM_F LSFT_T(KC_F)
#define HM_J RSFT_T(KC_J)
#define HM_K RCTL_T(KC_K)
#define HM_L LALT_T(KC_L)
#define HM_SCLN RGUI_T(KC_SCLN)
// Combo definitions
const uint16_t PROGMEM combo_esc[] = {HM_J, HM_K, COMBO_END};
const uint16_t PROGMEM combo_tab[] = {HM_D, HM_F, COMBO_END};
const uint16_t PROGMEM del_word_r[] = {HM_K, HM_L, COMBO_END};
const uint16_t PROGMEM del_word_l[] = {HM_S, HM_D, COMBO_END};
const uint16_t PROGMEM combo_enter[] = {KC_COMM, KC_DOT, COMBO_END};
combo_t key_combos[] = {
COMBO(combo_esc, KC_ESC),
COMBO(combo_tab, KC_TAB),
COMBO(del_word_r, C(KC_BSPC)),
COMBO(del_word_l, C(KC_DEL)),
COMBO(combo_enter, KC_ENTER),
};

15
keyboards/crkbd/rev1/keymaps/pones/custom_keycodes.h Normal file
View file

@ -0,0 +1,15 @@
#pragma once
#include QMK_KEYBOARD_H
// Custom keycodes
enum custom_keycodes {
DV_ARR = SAFE_RANGE, // Arrow function: =>
DV_CMNT, // VS Code: Toggle line comment (Ctrl+K, C)
DV_UNCMT, // VS Code: Toggle uncomment (Ctrl+K, U)
DV_SELLN, // Select entire line (Home, Home, Shift+End)
DV_REFS, // VS Code: Find all references (Ctrl+K, R)
WI_MAX, // Windows: Maximize window (Alt+Space, Shift+X)
KVM_PREV, // KVM switch: Previous computer (Ctrl, Ctrl, Page Up)
KVM_NEXT, // KVM switch: Next computer (Ctrl, Ctrl, Page Down)
};

805
keyboards/crkbd/rev1/keymaps/pones/keymap.c
View file

@ -1,780 +1,203 @@
#include QMK_KEYBOARD_H
#include "tap_dance.h"
#include "custom_keycodes.h"
// Fancy zones keycodes
#define FZ_EXT G(S(KC_UP)) // Expand window vertically
#define FZ_LFT G(KC_LEFT) // Move window to previous area
#define FZ_RGT G(KC_RIGHT) // Move window to next area
#define VD_NXT G(C(KC_LEFT)) // Move window to previous area
#define VD_PRV G(C(KC_RIGHT)) // Move window to next area
// Fancy Zones keycodes (Windows PowerToys)
#define FZ_EXT G(S(KC_UP)) // Expand window vertically to fill screen
#define FZ_LFT G(KC_LEFT) // Move window to previous zone/area
#define FZ_RGT G(KC_RIGHT) // Move window to next zone/area
#define VD_NXT G(C(KC_LEFT)) // Virtual Desktop: Switch to previous desktop
#define VD_PRV G(C(KC_RIGHT)) // Virtual Desktop: Switch to next desktop
// Word navigation and selection keycodes
#define C_LFT C(KC_LEFT) // Move to previous word
#define C_RGT C(KC_RIGHT) // Move to next word
#define C_UP C(KC_HOME)
#define C_DWN C(KC_END)
#define CS_LFT C(S(KC_LEFT)) // Select previous word
#define CS_RGT C(S(KC_RIGHT)) // Select next word
#define CS_UP C(S(KC_UP))
#define CS_DWN C(S(KC_DOWN))
#define S_PGUP S(KC_PGUP)
#define S_PGDW S(KC_PGDN)
#define LN_UP A(KC_UP) // Move line up
#define LN_DN A(KC_DOWN) // Move line down
// Word navigation and text selection keycodes
#define C_LFT C(KC_LEFT) // Move cursor to previous word
#define C_RGT C(KC_RIGHT) // Move cursor to next word
#define C_UP C(KC_HOME) // Move cursor to beginning of document
#define C_DWN C(KC_END) // Move cursor to end of document
#define CS_LFT C(S(KC_LEFT)) // Select previous word
#define CS_RGT C(S(KC_RIGHT)) // Select next word
#define CS_UP C(S(KC_UP)) // Select from cursor to start of paragraph
#define CS_DWN C(S(KC_DOWN)) // Select from cursor to end of paragraph
#define S_PGUP S(KC_PGUP) // Select page up
#define S_PGDW S(KC_PGDN) // Select page down
#define LN_UP A(KC_UP) // Move line up (VS Code)
#define LN_DN A(KC_DOWN) // Move line down (VS Code)
// Windows management keycodes
#define WD_CLO C(KC_F4) // Close document or tab
#define WI_CLO A(KC_F4) // Close window
// Window management keycodes
#define WD_CLO C(KC_F4) // Close current document/tab
#define WI_CLO A(KC_F4) // Close current window
// Shorthand macros and keycodes
#define DV_TRM C(KC_GRV) // VS Code terminal
#define DV_NTRM C(S(KC_GRV)) // VS Code new terminal
#define DV_CTRM C(KC_PGDN) // VS Code cycle terminal
#define DV_BLD C(S(KC_B)) // VS build
#define DV_BRKP KC_F9 // VS breakpoint
#define DV_SOUT S(KC_F11) // VS Step Out
#define DV_SIN KC_F11 // VS Step Into
#define DV_SOVR KC_F10 // VS Step Over
#define DV_IMPL C(KC_F12) // VS Go to Implementation
#define DV_NXER C(S(KC_F12)) // VS Next error
#define DV_NVFW C(S(KC_MINUS)) // VS Navigate forward
#define DV_NVBW C(KC_MINUS) // VS Navigate backwards
#define CS_P C(S(KC_P))
#define CS_V C(S(KC_V))
#define CS_F C(S(KC_F))
#define CS_S C(S(KC_S))
// VS Code development shortcuts
#define DV_TRM C(KC_GRV) // Toggle integrated terminal
#define DV_NTRM C(S(KC_GRV)) // Create new terminal
#define DV_CTRM C(KC_PGDN) // Cycle through terminals
#define DV_BLD C(S(KC_B)) // Build/compile project
#define DV_BRKP KC_F9 // Toggle breakpoint
#define DV_SOUT S(KC_F11) // Step out of function (debugging)
#define DV_SIN KC_F11 // Step into function (debugging)
#define DV_SOVR KC_F10 // Step over line (debugging)
#define DV_IMPL C(KC_F12) // Go to implementation
#define DV_NXER C(S(KC_F12)) // Go to next error
#define DV_NVFW C(S(KC_MINUS)) // Navigate forward in history
#define DV_NVBW C(KC_MINUS) // Navigate backward in history
#define CS_P C(S(KC_P)) // Command palette
#define CS_V C(S(KC_V)) // Paste from clipboard history
#define CS_F C(S(KC_F)) // Find in files
#define CS_S C(S(KC_S)) // Save as
// Left-hand home row mods
#define HM_A LGUI_T(KC_A)
#define HM_S LALT_T(KC_S)
#define HM_D LCTL_T(KC_D)
#define HM_F LSFT_T(KC_F)
// Left-hand home row modifiers (GUI/Alt/Ctrl/Shift on A/S/D/F)
#define HM_A LGUI_T(KC_A) // A key: tap for 'a', hold for GUI/Win key
#define HM_S LALT_T(KC_S) // S key: tap for 's', hold for Alt
#define HM_D LCTL_T(KC_D) // D key: tap for 'd', hold for Ctrl
#define HM_F LSFT_T(KC_F) // F key: tap for 'f', hold for Shift
// Right-hand home row mods
#define HM_J RSFT_T(KC_J)
#define HM_K RCTL_T(KC_K)
#define HM_L LALT_T(KC_L)
#define HM_SCLN RGUI_T(KC_SCLN)
// Right-hand home row modifiers (Shift/Ctrl/Alt/GUI on J/K/L/;)
#define HM_J RSFT_T(KC_J) // J key: tap for 'j', hold for Shift
#define HM_K RCTL_T(KC_K) // K key: tap for 'k', hold for Ctrl
#define HM_L LALT_T(KC_L) // L key: tap for 'l', hold for Alt
#define HM_SCLN RGUI_T(KC_SCLN) // ; key: tap for ';', hold for GUI/Win key
// Layer names and their purposes
enum layer_names {
_QWERTY,
_NUMBER,
_SYMBOL,
_SYMBOL2,
_SYMBOL_NEW,
_NAV,
_FUNC,
_DEV,
_UTIL,
_MEDIA,
_QWERTY, // Base QWERTY layer with home row mods
_NUMBER, // Number pad and arithmetic operators
_SYMBOL, // Basic symbols and brackets (legacy)
_SYMBOL2, // Additional symbols (@, #, $, %, etc.)
_SYMBOL_NEW, // New symbols layer with tap dance functionality
_NAV, // Navigation keys (arrows, page up/down, word movement)
_FUNC, // Function keys (F1-F12)
_DEV, // Development shortcuts (VS Code specific)
_UTIL, // Utility functions (RGB controls, etc.)
_MEDIA, // Media controls and mouse keys
};
// Tap dance definitions
enum tap_dances {
TD_J_BRACES, // { | {} | }
TD_K_PARENS, // ( | () | ("") | () => {} | )
TD_SC_ANGLES, // < | <> | <= | >
TD_L_BRACKETS, // [ | [] | [0] | ]
TD_EQ_PLUS, // = | == | += | +
TD_SL_BACK, // / | // | backslash
TD_MN_UNDER, // - | -- | => | _
TD_AM_PIPE, // & | && | || | |
TD_EX_QUEST, // ! | != | ?
};
#define L_SPC LT(_NUMBER, KC_SPACE)
#define L_TAB LT(_SYMBOL_NEW, KC_TAB)
#define L_ESC LT(_SYMBOL, KC_ESCAPE)
#define L_ENT LT(_DEV, KC_ENTER)
#define L_DEL LT(_MEDIA, KC_DEL)
#define L_BK LT(_FUNC, KC_BSPC)
#define L_Z LT(_NAV, KC_Z)
#define L_QUOT LT(_UTIL, KC_QUOT)
// Combo definitions
const uint16_t PROGMEM combo_esc[] = {HM_J, HM_K, COMBO_END};
const uint16_t PROGMEM combo_tab[] = {HM_D, HM_F, COMBO_END};
const uint16_t PROGMEM del_word_r[] = {HM_K, HM_L, COMBO_END};
const uint16_t PROGMEM del_word_l[] = {HM_S, HM_D, COMBO_END};
const uint16_t PROGMEM combo_enter[] = {KC_COMM, KC_DOT, COMBO_END};
combo_t key_combos[] = {
COMBO(combo_esc, KC_ESC),
COMBO(combo_tab, KC_TAB),
COMBO(del_word_r, C(KC_BSPC)),
COMBO(del_word_l, C(KC_DEL)),
COMBO(combo_enter, KC_ENTER),
};
enum custom_keycodes {
DV_ARR = SAFE_RANGE, // Print C# lambda arrow
DV_CMNT, // Comment line
DV_UNCMT, // Uncomment line
DV_SELLN, // Select line
DV_REFS, // Find references
WI_MAX, // Maximize window
KVM_PREV, // KVM previous port
KVM_NEXT, // KVM next port
};
// Tap dance functions
void td_j_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_RCBR); // Hold = }
} else {
register_code16(KC_LCBR); // 1 tap = {
}
break;
case 2:
SEND_STRING("{}");
tap_code(KC_LEFT); // 2 taps = {}←
break;
case 3:
register_code16(KC_RCBR); // 3 taps = }
break;
}
}
void td_j_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_RCBR);
} else {
unregister_code16(KC_LCBR);
}
break;
case 3:
unregister_code16(KC_RCBR);
break;
}
}
void td_k_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_RPRN); // Hold = )
} else {
register_code16(KC_LPRN); // 1 tap = (
}
break;
case 2:
SEND_STRING("()");
tap_code(KC_LEFT); // 2 taps = ()←
break;
case 3:
SEND_STRING("(\"\")");
tap_code(KC_LEFT);
tap_code(KC_LEFT); // 3 taps = ("")←←
break;
case 4:
SEND_STRING("() => {}");
tap_code(KC_LEFT); // 4 taps = () => {}←
break;
case 5:
register_code16(KC_RPRN); // 5 taps = )
break;
}
}
void td_k_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_RPRN);
} else {
unregister_code16(KC_LPRN);
}
break;
case 5:
unregister_code16(KC_RPRN);
break;
}
}
void td_sc_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_GT); // Hold = >
} else {
register_code16(KC_LT); // 1 tap = <
}
break;
case 2:
SEND_STRING("<>");
tap_code(KC_LEFT); // 2 taps = <>←
break;
case 3:
SEND_STRING("<="); // 3 taps = <=
break;
}
}
void td_sc_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_GT);
} else {
unregister_code16(KC_LT);
}
break;
}
}
void td_l_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_RBRC); // Hold = ]
} else {
register_code16(KC_LBRC); // 1 tap = [
}
break;
case 2:
SEND_STRING("[]");
tap_code(KC_LEFT); // 2 taps = []←
break;
case 3:
SEND_STRING("[0]");
tap_code(KC_LEFT); // 3 taps = [0]←
break;
case 4:
register_code16(KC_RBRC); // 4 taps = ]
break;
}
}
void td_l_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_RBRC);
} else {
unregister_code16(KC_LBRC);
}
break;
case 4:
unregister_code16(KC_RBRC);
break;
}
}
void td_eq_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_EQL); // 1 tap = =
break;
case 2:
SEND_STRING("=="); // 2 taps = ==
break;
case 3:
SEND_STRING("+="); // 3 taps = +=
break;
case 4:
register_code16(KC_PLUS); // 4 taps = +
break;
}
}
void td_eq_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_EQL);
break;
case 4:
unregister_code16(KC_PLUS);
break;
}
}
void td_sl_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_SLSH); // 1 tap = /
break;
case 2:
SEND_STRING("//"); // 2 taps = //
break;
case 3:
register_code16(KC_BSLS); // 3 taps = backslash
break;
}
}
void td_sl_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_SLSH);
break;
case 3:
unregister_code16(KC_BSLS);
break;
}
}
void td_mn_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_MINS); // 1 tap = -
break;
case 2:
SEND_STRING("--"); // 2 taps = --
break;
case 3:
SEND_STRING("=>"); // 3 taps = =>
break;
case 4:
register_code16(KC_UNDS); // 4 taps = _
break;
}
}
void td_mn_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_MINS);
break;
case 4:
unregister_code16(KC_UNDS);
break;
}
}
void td_am_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_AMPR); // 1 tap = &
break;
case 2:
SEND_STRING("&&"); // 2 taps = &&
break;
case 3:
SEND_STRING("||"); // 3 taps = ||
break;
case 4:
register_code16(KC_PIPE); // 4 taps = |
break;
}
}
void td_am_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_AMPR);
break;
case 4:
unregister_code16(KC_PIPE);
break;
}
}
void td_ex_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_EXLM); // 1 tap = !
break;
case 2:
SEND_STRING("!="); // 2 taps = !=
break;
case 3:
register_code16(KC_QUES); // 3 taps = ?
break;
}
}
void td_ex_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_EXLM);
break;
case 3:
unregister_code16(KC_QUES);
break;
}
}
// Tap dance actions
tap_dance_action_t tap_dance_actions[] = {
[TD_J_BRACES] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_j_finished, td_j_reset),
[TD_K_PARENS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_k_finished, td_k_reset),
[TD_SC_ANGLES] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_sc_finished, td_sc_reset),
[TD_L_BRACKETS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_l_finished, td_l_reset),
[TD_EQ_PLUS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_eq_finished, td_eq_reset),
[TD_SL_BACK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_sl_finished, td_sl_reset),
[TD_MN_UNDER] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_mn_finished, td_mn_reset),
[TD_AM_PIPE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_am_finished, td_am_reset),
[TD_EX_QUEST] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_ex_finished, td_ex_reset),
};
// Layer-tap definitions (tap for key, hold to access layer)
#define L_SPC LT(_NUMBER, KC_SPACE) // Space: tap for space, hold for numbers layer
#define L_TAB LT(_SYMBOL_NEW, KC_TAB) // Tab: tap for tab, hold for new symbols layer
#define L_ESC LT(_SYMBOL, KC_ESCAPE) // Escape: tap for escape, hold for symbols layer
#define L_ENT LT(_DEV, KC_ENTER) // Enter: tap for enter, hold for development layer
#define L_DEL LT(_MEDIA, KC_DEL) // Delete: tap for delete, hold for media layer
#define L_BK LT(_FUNC, KC_BSPC) // Backspace: tap for backspace, hold for function keys layer
#define L_Z LT(_NAV, KC_Z) // Z: tap for 'z', hold for navigation layer
#define L_QUOT LT(_UTIL, KC_QUOT) // Quote: tap for quote, hold for utilities layer
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, HM_A, HM_S, HM_D, HM_F, KC_G, KC_H, HM_J, HM_K, HM_L, HM_SCLN, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, L_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, L_QUOT, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
L_ESC, L_TAB, L_SPC, L_ENT, L_BK, L_DEL
//`--------------------------' `--------------------------'
),
[_NUMBER] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, C(KC_Z), C(KC_X), C(KC_C), C(KC_V),RCS(KC_V), XXXXXXX, KC_7, KC_8, KC_9, KC_ASTR, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_LGUI, KC_LALT, KC_LCTL, KC_LSFT, XXXXXXX, KC_EQL, KC_4, KC_5, KC_6, KC_PLUS, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, KC_BTN2, KC_BTN1, XXXXXXX, XXXXXXX, KC_1, KC_2, KC_3, KC_SLSH, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, KC_MINUS, KC_DOT, KC_0
//`--------------------------' `--------------------------'
),
[_SYMBOL] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_SLSH, KC_LBRC, KC_RBRC, KC_BSLS, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_LGUI, KC_LALT, KC_LCTL, KC_LSFT, XXXXXXX, KC_AMPR,KC_MINUS, KC_LPRN, KC_RPRN, KC_EXLM, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PIPE, KC_UNDS, KC_LCBR, KC_RCBR, KC_QUES, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, KC_EQL, KC_LT, KC_GT
//`--------------------------' `--------------------------'
),
[_SYMBOL2] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_LGUI, KC_LALT, KC_LCTL, KC_LSFT, XXXXXXX, XXXXXXX, KC_AT, KC_HASH, KC_DLR, KC_PERC, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_GRV, KC_CIRC, KC_TILD, DV_ARR, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
//`--------------------------' `--------------------------'
),
[_SYMBOL_NEW] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_GRV,TD(TD_AM_PIPE), KC_ASTR, TD(TD_SL_BACK), KC_CIRC, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_LGUI, KC_LALT, KC_LCTL, KC_LSFT, XXXXXXX, TD(TD_EQ_PLUS),TD(TD_J_BRACES),TD(TD_K_PARENS),TD(TD_SC_ANGLES),TD(TD_L_BRACKETS), XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_TILD,TD(TD_MN_UNDER), KC_COLN,TD(TD_EX_QUEST), KC_PERC, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, KC_AT, KC_HASH, KC_DLR
//`--------------------------' `--------------------------'
),
[_NAV] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_HOME, KC_UP, KC_END, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_LGUI, KC_LALT, KC_LCTL, KC_LSFT, XXXXXXX, KC_PGUP, KC_LEFT, KC_DOWN,KC_RIGHT, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PGDN, C_LFT, XXXXXXX, C_RGT, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, DV_SELLN, XXXXXXX, XXXXXXX
//`--------------------------' `--------------------------'
),
[_DEV] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, DV_TRM, DV_NVBW, DV_NVFW, DV_CMNT,DV_UNCMT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, DV_BRKP, DV_SOUT, DV_SIN, DV_SOVR, DV_BLD, XXXXXXX, KC_LSFT, KC_LCTL, KC_LALT, KC_LGUI, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, DV_NXER, XXXXXXX, DV_REFS, DV_IMPL, KC_F5, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
//`--------------------------' `--------------------------'
),
[_FUNC] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, KC_PSCR, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_F5, KC_F6, KC_F7, KC_F8, KC_PAUS, XXXXXXX, KC_LSFT, KC_LCTL, KC_LALT, KC_LGUI, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_INS, KC_CAPS, XXXXXXX, XXXXXXX, XXXXXXX
//`--------------------------' `--------------------------'
),
[_MEDIA] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, XXXXXXX, KC_WH_D, KC_MS_U, KC_WH_U, KC_MPRV, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_VOLU, KC_MS_L, KC_MS_D, KC_MS_R, KC_MPLY, XXXXXXX, KC_LSFT, KC_LCTL, KC_LALT, KC_LGUI, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, KC_VOLD, XXXXXXX, KC_BTN2, KC_BTN1, KC_MNXT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX,KVM_PREV,KVM_NEXT, XXXXXXX, XXXXXXX, XXXXXXX
//`--------------------------' `--------------------------'
),
[_UTIL] = LAYOUT_split_3x6_3(
//,-----------------------------------------------------. ,-----------------------------------------------------.
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_SPI, RGB_SPD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_MOD,RGB_RMOD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_VAI, RGB_VAD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX
//`--------------------------' `--------------------------'
)
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
switch (keycode) {
case DV_ARR:
SEND_STRING("=>");
break;
case DV_CMNT:
SEND_STRING(SS_LCTL("kc"));
break;
case DV_UNCMT:
SEND_STRING(SS_LCTL("ku"));
break;
case DV_REFS:
SEND_STRING(SS_LCTL("kr"));
break;
case DV_SELLN:
tap_code16(KC_HOME);
tap_code16(KC_HOME);
tap_code16(S(KC_END));
break;
case WI_MAX:
tap_code16(A(KC_SPC));
tap_code16(S(KC_X));
break;
case KVM_PREV:
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_PGUP);
break;
case KVM_NEXT:
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_PGDN);
break;
}
}
// Combo definitions (press multiple keys simultaneously for action)
const uint16_t PROGMEM combo_esc[] = {HM_J, HM_K, COMBO_END}; // J+K = Escape
const uint16_t PROGMEM combo_tab[] = {HM_D, HM_F, COMBO_END}; // D+F = Tab
const uint16_t PROGMEM del_word_r[] = {HM_K, HM_L, COMBO_END}; // K+L = Delete word right
const uint16_t PROGMEM del_word_l[] = {HM_S, HM_D, COMBO_END}; // S+D = Delete word left
const uint16_t PROGMEM combo_enter[] = {KC_COMM, KC_DOT, COMBO_END}; // ,+. = Enter
return true;
combo_t key_combos[] = {
COMBO(combo_esc, KC_ESC), // J+K combo produces Escape
COMBO(combo_tab, KC_TAB), // D+F combo produces Tab
COMBO(del_word_r, C(KC_BSPC)), // K+L combo deletes word to the right
COMBO(del_word_l, C(KC_DEL)), // S+D combo deletes word to the left
COMBO(combo_enter, KC_ENTER), // ,+. combo produces Enter
};
// Per-key tapping term optimization
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case TD_J_BRACES:
case TD_K_PARENS: return 180; // Index/middle fingers more responsive
case TD_L_BRACKETS: return 220; // Pinky finger needs more time
case TD_SC_ANGLES: return 200; // Ring finger standard
case HM_F: case HM_J: return 180; // Strong index fingers
case HM_A: case HM_SCLN: return 250; // Weak pinkies need more time
default: return TAPPING_TERM;
}
}
// Tap dance function declarations (defined in tap_dance.c)
void td_j_finished(tap_dance_state_t *state, void *user_data);
void td_j_reset(tap_dance_state_t *state, void *user_data);
void td_k_finished(tap_dance_state_t *state, void *user_data);
void td_k_reset(tap_dance_state_t *state, void *user_data);
void td_sc_finished(tap_dance_state_t *state, void *user_data);
void td_sc_reset(tap_dance_state_t *state, void *user_data);
void td_l_finished(tap_dance_state_t *state, void *user_data);
void td_l_reset(tap_dance_state_t *state, void *user_data);
void td_eq_finished(tap_dance_state_t *state, void *user_data);
void td_eq_reset(tap_dance_state_t *state, void *user_data);
void td_sl_finished(tap_dance_state_t *state, void *user_data);
void td_sl_reset(tap_dance_state_t *state, void *user_data);
void td_mn_finished(tap_dance_state_t *state, void *user_data);
void td_mn_reset(tap_dance_state_t *state, void *user_data);
void td_am_finished(tap_dance_state_t *state, void *user_data);
void td_am_reset(tap_dance_state_t *state, void *user_data);
void td_ex_finished(tap_dance_state_t *state, void *user_data);
void td_ex_reset(tap_dance_state_t *state, void *user_data);
#ifdef OLED_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; }
void render_space(void) {
oled_write_P(PSTR(" "), false);
}
void render_mod_status_gui_alt(uint8_t modifiers) {
static const char PROGMEM gui_off_1[] = {0x85, 0x86, 0};
static const char PROGMEM gui_off_2[] = {0xa5, 0xa6, 0};
static const char PROGMEM gui_on_1[] = {0x8d, 0x8e, 0};
static const char PROGMEM gui_on_2[] = {0xad, 0xae, 0};
static const char PROGMEM alt_off_1[] = {0x87, 0x88, 0};
static const char PROGMEM alt_off_2[] = {0xa7, 0xa8, 0};
static const char PROGMEM alt_on_1[] = {0x8f, 0x90, 0};
static const char PROGMEM alt_on_2[] = {0xaf, 0xb0, 0};
// fillers between the modifier icons bleed into the icon frames
static const char PROGMEM off_off_1[] = {0xc5, 0};
static const char PROGMEM off_off_2[] = {0xc6, 0};
static const char PROGMEM on_off_1[] = {0xc7, 0};
static const char PROGMEM on_off_2[] = {0xc8, 0};
static const char PROGMEM off_on_1[] = {0xc9, 0};
static const char PROGMEM off_on_2[] = {0xca, 0};
static const char PROGMEM on_on_1[] = {0xcb, 0};
static const char PROGMEM on_on_2[] = {0xcc, 0};
if(modifiers & MOD_MASK_GUI) {
oled_write_P(gui_on_1, false);
} else {
oled_write_P(gui_off_1, false);
}
if ((modifiers & MOD_MASK_GUI) && (modifiers & MOD_MASK_ALT)) {
oled_write_P(on_on_1, false);
} else if(modifiers & MOD_MASK_GUI) {
oled_write_P(on_off_1, false);
} else if(modifiers & MOD_MASK_ALT) {
oled_write_P(off_on_1, false);
} else {
oled_write_P(off_off_1, false);
}
if(modifiers & MOD_MASK_ALT) {
oled_write_P(alt_on_1, false);
} else {
oled_write_P(alt_off_1, false);
}
if(modifiers & MOD_MASK_GUI) {
oled_write_P(gui_on_2, false);
} else {
oled_write_P(gui_off_2, false);
}
if (modifiers & MOD_MASK_GUI & MOD_MASK_ALT) {
oled_write_P(on_on_2, false);
} else if(modifiers & MOD_MASK_GUI) {
oled_write_P(on_off_2, false);
} else if(modifiers & MOD_MASK_ALT) {
oled_write_P(off_on_2, false);
} else {
oled_write_P(off_off_2, false);
}
if(modifiers & MOD_MASK_ALT) {
oled_write_P(alt_on_2, false);
} else {
oled_write_P(alt_off_2, false);
}
}
void render_mod_status_ctrl_shift(uint8_t modifiers) {
static const char PROGMEM ctrl_off_1[] = {0x89, 0x8a, 0};
static const char PROGMEM ctrl_off_2[] = {0xa9, 0xaa, 0};
static const char PROGMEM ctrl_on_1[] = {0x91, 0x92, 0};
static const char PROGMEM ctrl_on_2[] = {0xb1, 0xb2, 0};
static const char PROGMEM shift_off_1[] = {0x8b, 0x8c, 0};
static const char PROGMEM shift_off_2[] = {0xab, 0xac, 0};
static const char PROGMEM shift_on_1[] = {0xcd, 0xce, 0};
static const char PROGMEM shift_on_2[] = {0xcf, 0xd0, 0};
// fillers between the modifier icons bleed into the icon frames
static const char PROGMEM off_off_1[] = {0xc5, 0};
static const char PROGMEM off_off_2[] = {0xc6, 0};
static const char PROGMEM on_off_1[] = {0xc7, 0};
static const char PROGMEM on_off_2[] = {0xc8, 0};
static const char PROGMEM off_on_1[] = {0xc9, 0};
static const char PROGMEM off_on_2[] = {0xca, 0};
static const char PROGMEM on_on_1[] = {0xcb, 0};
static const char PROGMEM on_on_2[] = {0xcc, 0};
if(modifiers & MOD_MASK_CTRL) {
oled_write_P(ctrl_on_1, false);
} else {
oled_write_P(ctrl_off_1, false);
}
if ((modifiers & MOD_MASK_CTRL) && (modifiers & MOD_MASK_SHIFT)) {
oled_write_P(on_on_1, false);
} else if(modifiers & MOD_MASK_CTRL) {
oled_write_P(on_off_1, false);
} else if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(off_on_1, false);
} else {
oled_write_P(off_off_1, false);
}
if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(shift_on_1, false);
} else {
oled_write_P(shift_off_1, false);
}
if(modifiers & MOD_MASK_CTRL) {
oled_write_P(ctrl_on_2, false);
} else {
oled_write_P(ctrl_off_2, false);
}
if (modifiers & MOD_MASK_CTRL & MOD_MASK_SHIFT) {
oled_write_P(on_on_2, false);
} else if(modifiers & MOD_MASK_CTRL) {
oled_write_P(on_off_2, false);
} else if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(off_on_2, false);
} else {
oled_write_P(off_off_2, false);
}
if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(shift_on_2, false);
} else {
oled_write_P(shift_off_2, false);
}
}
void render_logo(void) {
static const char PROGMEM corne_logo[] = {
0x80, 0x81, 0x82, 0x83, 0x84,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0};
oled_write_P(corne_logo, false);
oled_write_P(PSTR("corne"), false);
}
void render_layer_state(void) {
static const char PROGMEM default_layer[] = {
0x20, 0x94, 0x95, 0x96, 0x20,
0x20, 0xb4, 0xb5, 0xb6, 0x20,
0x20, 0xd4, 0xd5, 0xd6, 0x20, 0};
static const char PROGMEM raise_layer[] = {
0x20, 0x97, 0x98, 0x99, 0x20,
0x20, 0xb7, 0xb8, 0xb9, 0x20,
0x20, 0xd7, 0xd8, 0xd9, 0x20, 0};
static const char PROGMEM lower_layer[] = {
0x20, 0x9a, 0x9b, 0x9c, 0x20,
0x20, 0xba, 0xbb, 0xbc, 0x20,
0x20, 0xda, 0xdb, 0xdc, 0x20, 0};
static const char PROGMEM adjust_layer[] = {
0x20, 0x9d, 0x9e, 0x9f, 0x20,
0x20, 0xbd, 0xbe, 0xbf, 0x20,
0x20, 0xdd, 0xde, 0xdf, 0x20, 0};
if(layer_state_is(_DEV)) {
oled_write_P(adjust_layer, false);
} else if(layer_state_is(_NUMBER)) {
oled_write_P(lower_layer, false);
} else if(layer_state_is(_SYMBOL)) {
oled_write_P(raise_layer, false);
} else {
oled_write_P(default_layer, false);
}
}
bool oled_task_user(void) {
// Renders the current keyboard state (layers and mods)
render_logo();
render_space();
render_layer_state();
render_space();
render_mod_status_gui_alt(get_mods()|get_oneshot_mods());
render_mod_status_ctrl_shift(get_mods()|get_oneshot_mods());
return false;
}
#endif
// Tap dance actions (different actions based on number of taps)
tap_dance_action_t tap_dance_actions[] = {
[TD_J_BRACES] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_j_finished, td_j_reset), // { | {} | }
[TD_K_PARENS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_k_finished, td_k_reset), // ( | () | ("") | () => {} | )
[TD_SC_ANGLES] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_sc_finished, td_sc_reset), // < | <> | <=
[TD_L_BRACKETS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_l_finished, td_l_reset), // [ | [] | [0] | ]
[TD_EQ_PLUS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_eq_finished, td_eq_reset), // = | == | += | +
[TD_SL_BACK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_sl_finished, td_sl_reset), // / | // | backslash
[TD_MN_UNDER] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_mn_finished, td_mn_reset), // - | -- | => | _
[TD_AM_PIPE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_am_finished, td_am_reset), // & | && | || | |
[TD_EX_QUEST] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_ex_finished, td_ex_reset), // ! | != | ?
};

70
keyboards/crkbd/rev1/keymaps/pones/macros.c Normal file
View file

@ -0,0 +1,70 @@
#include QMK_KEYBOARD_H
#include "tap_dance.h"
#include "custom_keycodes.h"
// Home row modifiers (refer to keymap.c for primary definitions)
#define HM_A LGUI_T(KC_A)
#define HM_S LALT_T(KC_S)
#define HM_D LCTL_T(KC_D)
#define HM_F LSFT_T(KC_F)
#define HM_J RSFT_T(KC_J)
#define HM_K RCTL_T(KC_K)
#define HM_L LALT_T(KC_L)
#define HM_SCLN RGUI_T(KC_SCLN)
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
switch (keycode) {
case DV_ARR:
SEND_STRING("=>");
break;
case DV_CMNT:
SEND_STRING(SS_LCTL("kc"));
break;
case DV_UNCMT:
SEND_STRING(SS_LCTL("ku"));
break;
case DV_REFS:
SEND_STRING(SS_LCTL("kr"));
break;
case DV_SELLN:
tap_code16(KC_HOME);
tap_code16(KC_HOME);
tap_code16(S(KC_END));
break;
case WI_MAX:
tap_code16(A(KC_SPC));
tap_code16(S(KC_X));
break;
case KVM_PREV:
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_PGUP);
break;
case KVM_NEXT:
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_RCTL);
wait_ms(50);
tap_code16(KC_PGDN);
break;
}
}
return true;
}
// Per-key tapping term optimization
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case TD_J_BRACES:
case TD_K_PARENS: return 180;
case TD_L_BRACKETS: return 220;
case TD_SC_ANGLES: return 200;
case HM_F: case HM_J: return 180;
case HM_A: case HM_SCLN: return 250;
default: return TAPPING_TERM;
}
}

204
keyboards/crkbd/rev1/keymaps/pones/oled.c Normal file
View file

@ -0,0 +1,204 @@
#include QMK_KEYBOARD_H
#ifdef OLED_ENABLE
// Layer names
enum layer_names {
_QWERTY,
_NUMBER,
_SYMBOL,
_SYMBOL2,
_SYMBOL_NEW,
_NAV,
_FUNC,
_DEV,
_UTIL,
_MEDIA,
};
oled_rotation_t oled_init_user(oled_rotation_t rotation) {
return OLED_ROTATION_270;
}
void render_space(void) {
oled_write_P(PSTR(" "), false);
}
void render_mod_status_gui_alt(uint8_t modifiers) {
static const char PROGMEM gui_off_1[] = {0x85, 0x86, 0};
static const char PROGMEM gui_off_2[] = {0xa5, 0xa6, 0};
static const char PROGMEM gui_on_1[] = {0x8d, 0x8e, 0};
static const char PROGMEM gui_on_2[] = {0xad, 0xae, 0};
static const char PROGMEM alt_off_1[] = {0x87, 0x88, 0};
static const char PROGMEM alt_off_2[] = {0xa7, 0xa8, 0};
static const char PROGMEM alt_on_1[] = {0x8f, 0x90, 0};
static const char PROGMEM alt_on_2[] = {0xaf, 0xb0, 0};
static const char PROGMEM off_off_1[] = {0xc5, 0};
static const char PROGMEM off_off_2[] = {0xc6, 0};
static const char PROGMEM on_off_1[] = {0xc7, 0};
static const char PROGMEM on_off_2[] = {0xc8, 0};
static const char PROGMEM off_on_1[] = {0xc9, 0};
static const char PROGMEM off_on_2[] = {0xca, 0};
static const char PROGMEM on_on_1[] = {0xcb, 0};
static const char PROGMEM on_on_2[] = {0xcc, 0};
if(modifiers & MOD_MASK_GUI) {
oled_write_P(gui_on_1, false);
} else {
oled_write_P(gui_off_1, false);
}
if ((modifiers & MOD_MASK_GUI) && (modifiers & MOD_MASK_ALT)) {
oled_write_P(on_on_1, false);
} else if(modifiers & MOD_MASK_GUI) {
oled_write_P(on_off_1, false);
} else if(modifiers & MOD_MASK_ALT) {
oled_write_P(off_on_1, false);
} else {
oled_write_P(off_off_1, false);
}
if(modifiers & MOD_MASK_ALT) {
oled_write_P(alt_on_1, false);
} else {
oled_write_P(alt_off_1, false);
}
if(modifiers & MOD_MASK_GUI) {
oled_write_P(gui_on_2, false);
} else {
oled_write_P(gui_off_2, false);
}
if (modifiers & MOD_MASK_GUI & MOD_MASK_ALT) {
oled_write_P(on_on_2, false);
} else if(modifiers & MOD_MASK_GUI) {
oled_write_P(on_off_2, false);
} else if(modifiers & MOD_MASK_ALT) {
oled_write_P(off_on_2, false);
} else {
oled_write_P(off_off_2, false);
}
if(modifiers & MOD_MASK_ALT) {
oled_write_P(alt_on_2, false);
} else {
oled_write_P(alt_off_2, false);
}
}
void render_mod_status_ctrl_shift(uint8_t modifiers) {
static const char PROGMEM ctrl_off_1[] = {0x89, 0x8a, 0};
static const char PROGMEM ctrl_off_2[] = {0xa9, 0xaa, 0};
static const char PROGMEM ctrl_on_1[] = {0x91, 0x92, 0};
static const char PROGMEM ctrl_on_2[] = {0xb1, 0xb2, 0};
static const char PROGMEM shift_off_1[] = {0x8b, 0x8c, 0};
static const char PROGMEM shift_off_2[] = {0xab, 0xac, 0};
static const char PROGMEM shift_on_1[] = {0xcd, 0xce, 0};
static const char PROGMEM shift_on_2[] = {0xcf, 0xd0, 0};
static const char PROGMEM off_off_1[] = {0xc5, 0};
static const char PROGMEM off_off_2[] = {0xc6, 0};
static const char PROGMEM on_off_1[] = {0xc7, 0};
static const char PROGMEM on_off_2[] = {0xc8, 0};
static const char PROGMEM off_on_1[] = {0xc9, 0};
static const char PROGMEM off_on_2[] = {0xca, 0};
static const char PROGMEM on_on_1[] = {0xcb, 0};
static const char PROGMEM on_on_2[] = {0xcc, 0};
if(modifiers & MOD_MASK_CTRL) {
oled_write_P(ctrl_on_1, false);
} else {
oled_write_P(ctrl_off_1, false);
}
if ((modifiers & MOD_MASK_CTRL) && (modifiers & MOD_MASK_SHIFT)) {
oled_write_P(on_on_1, false);
} else if(modifiers & MOD_MASK_CTRL) {
oled_write_P(on_off_1, false);
} else if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(off_on_1, false);
} else {
oled_write_P(off_off_1, false);
}
if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(shift_on_1, false);
} else {
oled_write_P(shift_off_1, false);
}
if(modifiers & MOD_MASK_CTRL) {
oled_write_P(ctrl_on_2, false);
} else {
oled_write_P(ctrl_off_2, false);
}
if (modifiers & MOD_MASK_CTRL & MOD_MASK_SHIFT) {
oled_write_P(on_on_2, false);
} else if(modifiers & MOD_MASK_CTRL) {
oled_write_P(on_off_2, false);
} else if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(off_on_2, false);
} else {
oled_write_P(off_off_2, false);
}
if(modifiers & MOD_MASK_SHIFT) {
oled_write_P(shift_on_2, false);
} else {
oled_write_P(shift_off_2, false);
}
}
void render_logo(void) {
static const char PROGMEM corne_logo[] = {
0x80, 0x81, 0x82, 0x83, 0x84,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0};
oled_write_P(corne_logo, false);
oled_write_P(PSTR("corne"), false);
}
void render_layer_state(void) {
static const char PROGMEM default_layer[] = {
0x20, 0x94, 0x95, 0x96, 0x20,
0x20, 0xb4, 0xb5, 0xb6, 0x20,
0x20, 0xd4, 0xd5, 0xd6, 0x20, 0};
static const char PROGMEM raise_layer[] = {
0x20, 0x97, 0x98, 0x99, 0x20,
0x20, 0xb7, 0xb8, 0xb9, 0x20,
0x20, 0xd7, 0xd8, 0xd9, 0x20, 0};
static const char PROGMEM lower_layer[] = {
0x20, 0x9a, 0x9b, 0x9c, 0x20,
0x20, 0xba, 0xbb, 0xbc, 0x20,
0x20, 0xda, 0xdb, 0xdc, 0x20, 0};
static const char PROGMEM adjust_layer[] = {
0x20, 0x9d, 0x9e, 0x9f, 0x20,
0x20, 0xbd, 0xbe, 0xbf, 0x20,
0x20, 0xdd, 0xde, 0xdf, 0x20, 0};
if(layer_state_is(_DEV)) {
oled_write_P(adjust_layer, false);
} else if(layer_state_is(_NUMBER)) {
oled_write_P(lower_layer, false);
} else if(layer_state_is(_SYMBOL)) {
oled_write_P(raise_layer, false);
} else {
oled_write_P(default_layer, false);
}
}
bool oled_task_user(void) {
render_logo();
render_space();
render_layer_state();
render_space();
render_mod_status_gui_alt(get_mods()|get_oneshot_mods());
render_mod_status_ctrl_shift(get_mods()|get_oneshot_mods());
return false;
}
#endif

12
keyboards/crkbd/rev1/keymaps/pones/rules.mk
View file

@ -5,13 +5,21 @@ CAPS_WORD_ENABLE = no
VIA_ENABLE = no
DYNAMIC_TAPPING_TERM_ENABLE = yes
RGBLIGHT_ENABLE = no
RGB_MATRIX_ENABLE = no
RGB_MATRIX_ENABLE = yes
OLED_ENABLE = yes
CONSOLE_ENABLE = no
COMMAND_ENABLE = no
MOUSEKEY_ENABLE = yes
MOUSEKEY_ENABLE = no
SPACE_CADET_ENABLE = no
GRAVE_ESC_ENABLE = no
MAGIC_ENABLE = no
COMBO_ENABLE = yes
TAP_DANCE_ENABLE = yes
# Include feature source files
SRC += tap_dance.c
SRC += macros.c
ifeq ($(strip $(OLED_ENABLE)), yes)
SRC += oled.c
endif

285
keyboards/crkbd/rev1/keymaps/pones/tap_dance.c Normal file
View file

@ -0,0 +1,285 @@
#include QMK_KEYBOARD_H
#include "tap_dance.h"
// Tap dance functions
void td_j_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_RCBR); // Hold = }
} else {
register_code16(KC_LCBR); // 1 tap = {
}
break;
case 2:
SEND_STRING("{}");
tap_code(KC_LEFT); // 2 taps = {}←
break;
case 3:
register_code16(KC_RCBR); // 3 taps = }
break;
}
}
void td_j_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_RCBR);
} else {
unregister_code16(KC_LCBR);
}
break;
case 3:
unregister_code16(KC_RCBR);
break;
}
}
void td_k_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_RPRN); // Hold = )
} else {
register_code16(KC_LPRN); // 1 tap = (
}
break;
case 2:
SEND_STRING("()");
tap_code(KC_LEFT); // 2 taps = ()←
break;
case 3:
SEND_STRING("(\"\")");
tap_code(KC_LEFT);
tap_code(KC_LEFT); // 3 taps = ("")←←
break;
case 4:
SEND_STRING("() => {}");
tap_code(KC_LEFT); // 4 taps = () => {}←
break;
case 5:
register_code16(KC_RPRN); // 5 taps = )
break;
}
}
void td_k_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_RPRN);
} else {
unregister_code16(KC_LPRN);
}
break;
case 5:
unregister_code16(KC_RPRN);
break;
}
}
void td_sc_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_GT); // Hold = >
} else {
register_code16(KC_LT); // 1 tap = <
}
break;
case 2:
SEND_STRING("<>");
tap_code(KC_LEFT); // 2 taps = <>←
break;
case 3:
SEND_STRING("<="); // 3 taps = <=
break;
}
}
void td_sc_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_GT);
} else {
unregister_code16(KC_LT);
}
break;
}
}
void td_l_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
register_code16(KC_RBRC); // Hold = ]
} else {
register_code16(KC_LBRC); // 1 tap = [
}
break;
case 2:
SEND_STRING("[]");
tap_code(KC_LEFT); // 2 taps = []←
break;
case 3:
SEND_STRING("[0]");
tap_code(KC_LEFT); // 3 taps = [0]←
break;
case 4:
register_code16(KC_RBRC); // 4 taps = ]
break;
}
}
void td_l_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
if (state->pressed) {
unregister_code16(KC_RBRC);
} else {
unregister_code16(KC_LBRC);
}
break;
case 4:
unregister_code16(KC_RBRC);
break;
}
}
void td_eq_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_EQL); // 1 tap = =
break;
case 2:
SEND_STRING("=="); // 2 taps = ==
break;
case 3:
SEND_STRING("+="); // 3 taps = +=
break;
case 4:
register_code16(KC_PLUS); // 4 taps = +
break;
}
}
void td_eq_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_EQL);
break;
case 4:
unregister_code16(KC_PLUS);
break;
}
}
void td_sl_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_SLSH); // 1 tap = /
break;
case 2:
SEND_STRING("//"); // 2 taps = //
break;
case 3:
register_code16(KC_BSLS); // 3 taps = backslash
break;
}
}
void td_sl_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_SLSH);
break;
case 3:
unregister_code16(KC_BSLS);
break;
}
}
void td_mn_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_MINS); // 1 tap = -
break;
case 2:
SEND_STRING("--"); // 2 taps = --
break;
case 3:
SEND_STRING("=>"); // 3 taps = =>
break;
case 4:
register_code16(KC_UNDS); // 4 taps = _
break;
}
}
void td_mn_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_MINS);
break;
case 4:
unregister_code16(KC_UNDS);
break;
}
}
void td_am_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_AMPR); // 1 tap = &
break;
case 2:
SEND_STRING("&&"); // 2 taps = &&
break;
case 3:
SEND_STRING("||"); // 3 taps = ||
break;
case 4:
register_code16(KC_PIPE); // 4 taps = |
break;
}
}
void td_am_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_AMPR);
break;
case 4:
unregister_code16(KC_PIPE);
break;
}
}
void td_ex_finished(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
register_code16(KC_EXLM); // 1 tap = !
break;
case 2:
SEND_STRING("!="); // 2 taps = !=
break;
case 3:
register_code16(KC_QUES); // 3 taps = ?
break;
}
}
void td_ex_reset(tap_dance_state_t *state, void *user_data) {
switch (state->count) {
case 1:
unregister_code16(KC_EXLM);
break;
case 3:
unregister_code16(KC_QUES);
break;
}
}
// Tap dance actions array is now defined in keymap.c

16
keyboards/crkbd/rev1/keymaps/pones/tap_dance.h Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include QMK_KEYBOARD_H
// Tap dance definitions
enum tap_dances {
TD_J_BRACES, // { | {} | }
TD_K_PARENS, // ( | () | ("") | () => {} | )
TD_SC_ANGLES, // < | <> | <= | >
TD_L_BRACKETS, // [ | [] | [0] | ]
TD_EQ_PLUS, // = | == | += | +
TD_SL_BACK, // / | // | backslash
TD_MN_UNDER, // - | -- | => | _
TD_AM_PIPE, // & | && | || | |
TD_EX_QUEST, // ! | != | ?
};