drashna/qmk_firmware
1
0
Fork 0
Code Activity Actions

Remove obvious user keymaps, keyboards/{b,c}* edition. (#22693)

Browse source
This commit is contained in:
Nick Brassel 2023-12-18 16:05:50 +11:00 • committed by GitHub
parent f25226453f
commit d235352504
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
621 changed files with 0 additions and 40804 deletions
Download patch file Download diff file Expand all files Collapse all files

72
keyboards/jkeys_design/gentleman65/keymaps/briianpowell/features/custom_shift_keys.c
View file

@ -1,72 +0,0 @@
// Copyright 2021-2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/**
* @file custom_shift_keys.c
* @brief Custom Shift Keys implementation
*
* For full documentation, see
* <https://getreuer.info/posts/keyboards/custom-shift-keys>
*/
#include "custom_shift_keys.h"
bool process_custom_shift_keys(uint16_t keycode, keyrecord_t *record) {
static uint16_t registered_keycode = KC_NO;
// If a custom shift key is registered, then this event is either releasing
// it or manipulating another key at the same time. Either way, we release
// the currently registered key.
if (registered_keycode != KC_NO) {
unregister_code16(registered_keycode);
registered_keycode = KC_NO;
}
if (record->event.pressed) { // Press event.
const uint8_t mods = get_mods();
#ifndef NO_ACTION_ONESHOT
if ((mods | get_weak_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT) {
#else
if ((mods | get_weak_mods()) & MOD_MASK_SHIFT) { // Shift is held.
#endif // NO_ACTION_ONESHOT
// Continue default handling if this is a tap-hold key being held.
if ((IS_QK_MOD_TAP(keycode) || IS_QK_LAYER_TAP(keycode)) && record->tap.count == 0) {
return true;
}
// Search for a custom shift key whose keycode is `keycode`.
for (int i = 0; i < NUM_CUSTOM_SHIFT_KEYS; ++i) {
if (keycode == custom_shift_keys[i].keycode) {
registered_keycode = custom_shift_keys[i].shifted_keycode;
if (IS_QK_MODS(registered_keycode) && // Should keycode be shifted?
(QK_MODS_GET_MODS(registered_keycode) & MOD_LSFT) != 0) {
register_code16(registered_keycode); // If so, press it directly.
} else {
// Otherwise cancel shift mods, press the key, and restore mods.
del_weak_mods(MOD_MASK_SHIFT);
#ifndef NO_ACTION_ONESHOT
del_oneshot_mods(MOD_MASK_SHIFT);
#endif // NO_ACTION_ONESHOT
unregister_mods(MOD_MASK_SHIFT);
register_code16(registered_keycode);
set_mods(mods);
}
return false;
}
}
}
}
return true; // Continue with default handling.
}

99
keyboards/jkeys_design/gentleman65/keymaps/briianpowell/features/custom_shift_keys.h
View file

@ -1,99 +0,0 @@
// Copyright 2021-2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/**
* @file custom_shift_keys.h
* @brief Custom shift keys: customize what keycode is produced when shifted.
*
* Overview
* --------
*
* This library implements custom shift keys, keys where you can customize
* what keycode is produced when shifted.
*
* Step 1: In your keymap.c, define a table of custom shift keys like
*
* #include "features/custom_shift_keys.h"
*
* const custom_shift_key_t custom_shift_keys[] = {
* {KC_DOT , KC_QUES}, // Shift . is ?
* {KC_COMM, KC_EXLM}, // Shift , is !
* {KC_MINS, KC_EQL }, // Shift - is =
* {KC_COLN, KC_SCLN}, // Shift : is ;
* };
*
* Each row defines one key. The first field is the keycode as it appears in
* your layout and determines what is typed normally. The second entry is what
* you want the key to type when shifted.
*
* Step 2: Handle custom shift keys from your `process_record_user` function as
*
* bool process_record_user(uint16_t keycode, keyrecord_t* record) {
* if (!process_custom_shift_keys(keycode, record)) { return false; }
* // Your macros ...
*
* return true;
* }
*
* Step 3: add `features/custom_shift_keys.c` to your rules.mk as
*
* SRC += features/custom_shift_keys.c
*
*
* For full documentation, see
* <https://getreuer.info/posts/keyboards/custom-shift-keys>
*/
#pragma once
#include "quantum.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Custom shift key entry. The `keycode` field is the keycode as it appears in
* your layout and determines what is typed normally. The `shifted_keycode` is
* what you want the key to type when shifted.
*/
typedef struct {
uint16_t keycode;
uint16_t shifted_keycode;
} custom_shift_key_t;
/** Table of custom shift keys. */
extern const custom_shift_key_t custom_shift_keys[];
/** Number of entries in the `custom_shift_keys` table. */
extern uint8_t NUM_CUSTOM_SHIFT_KEYS;
/**
* Handler function for custom shift keys.
*
* In keymap.c, call this function from your `process_record_user` function as
*
* #include "features/custom_shift_keys.h"
*
* bool process_record_user(uint16_t keycode, keyrecord_t* record) {
* if (!process_custom_shift_keys(keycode, record)) { return false; }
* // Your macros ...
*
* return true;
* }
*/
bool process_custom_shift_keys(uint16_t keycode, keyrecord_t *record);
#ifdef __cplusplus
}
#endif

103
keyboards/jkeys_design/gentleman65/keymaps/briianpowell/keymap.c
View file

@ -1,103 +0,0 @@
/* Copyright 2021 Omar Afzal
*
* 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 QMK_KEYBOARD_H
#include "features/custom_shift_keys.h"
#define FN_ESC LT(_FUNC, KC_ESC)
enum gentleman_layers {
_QWERTY,
_WORKMAN,
_FUNC,
};
enum gentleman_keycodes {
QWERTY = SAFE_RANGE,
WORKMAN,
FUNC,
};
const custom_shift_key_t custom_shift_keys[] = {{KC_ESC, KC_TILD}};
uint8_t NUM_CUSTOM_SHIFT_KEYS = sizeof(custom_shift_keys) / sizeof(custom_shift_key_t);
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_65_ansi_rwkl_split_bs(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_BSPC, KC_TRNS,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL,
FN_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGUP,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_PGDN,
KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT
),
[_WORKMAN] = LAYOUT_65_ansi_rwkl_split_bs(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_BSPC, KC_TRNS,
KC_TAB, KC_Q, KC_D, KC_R, KC_W, KC_B, KC_J, KC_F, KC_U, KC_P, KC_SCLN, KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL,
FN_ESC, KC_A, KC_S, KC_H, KC_T, KC_G, KC_Y, KC_N, KC_E, KC_O, KC_I, KC_QUOT, KC_ENT, KC_PGUP,
KC_LSFT, KC_Z, KC_X, KC_M, KC_C, KC_V, KC_K, KC_L, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_PGDN,
KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT
),
[_FUNC] = LAYOUT_65_ansi_rwkl_split_bs(
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_TRNS, KC_TRNS, QK_BOOT,
KC_TRNS, KC_WH_U, KC_BTN1, KC_MS_U, KC_BTN2, KC_TRNS, KC_TRNS, KC_TRNS, KC_UP, AG_NORM, AG_SWAP, QWERTY, WORKMAN, KC_TRNS, KC_INS,
KC_TRNS, KC_WH_D, KC_MS_L, KC_MS_D, KC_MS_R, KC_TRNS, KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_HOME, KC_END, KC_TRNS, KC_HOME,
KC_TRNS, KC_WH_L, KC_BTN3, KC_WH_R, KC_TRNS, RGB_TOG, RGB_MOD, RGB_VAI, RGB_VAD, RGB_SAI, RGB_SAD, KC_TRNS, RGB_HUI, KC_END,
KC_TRNS, KC_TRNS, KC_TRNS, KC_MPLY, KC_TRNS, KC_TRNS, KC_MPRV, RGB_HUD, KC_MNXT
),
};
bool encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) {
switch (get_highest_layer(layer_state)) {
case _FUNC:
// Vertical Scroll
clockwise ? tap_code(KC_WH_D) : tap_code(KC_WH_U);
return false;
break;
default:
// Horizontal Scroll
if ((get_mods() & MOD_BIT(KC_LSFT)) == MOD_BIT(KC_LSFT)) {
clockwise ? tap_code(KC_WH_D) : tap_code(KC_WH_U);
return false;
}
// Volume
clockwise ? tap_code(KC_AUDIO_VOL_UP) : tap_code(KC_AUDIO_VOL_DOWN);
break;
}
}
return false;
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (!process_custom_shift_keys(keycode, record)) {
return false;
}
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
return false;
case WORKMAN:
if (record->event.pressed) {
set_single_persistent_default_layer(_WORKMAN);
}
return false;
}
return true;
}

14
keyboards/jkeys_design/gentleman65/keymaps/briianpowell/readme.md
View file

@ -1,14 +0,0 @@
# Gentleman65 Keyboard Compilation
## Features
- Base Layers
- QWERTY
- Workman
- Entertainment Keys
## Building and flashing
```
make jkeys_design/gentleman65:briianpowell:flash
```

1
keyboards/jkeys_design/gentleman65/keymaps/briianpowell/rules.mk
View file

@ -1 +0,0 @@
SRC += features/custom_shift_keys.c