arne/vial-qmk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'qmk/master' into merge-2022-03-06

Browse Source
This commit is contained in:
Ilya Zhuravlev
2022-03-06 20:04:27 -06:00
parent 465dd1e7ce 30209de9fd
commit 3a3c93383f
7966 changed files with 179285 additions and 62739 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
keyboards/planck/ez/config.h
View File

@@ -183,8 +183,11 @@
#define TAPPING_TOGGLE 1
#define MOUSEKEY_INTERVAL 20
#define MOUSEKEY_DELAY 0
#define MOUSEKEY_TIME_TO_MAX 60
#define MOUSEKEY_MAX_SPEED 7
#define MOUSEKEY_WHEEL_DELAY 0
#define MOUSEKEY_INTERVAL 20
#define MOUSEKEY_DELAY 0
#define MOUSEKEY_TIME_TO_MAX 60
#define MOUSEKEY_MAX_SPEED 7
#define MOUSEKEY_WHEEL_DELAY 400
#define MOUSEKEY_WHEEL_INTERVAL MOUSEKEY_INTERVAL
#define MOUSEKEY_WHEEL_MAX_SPEED MOUSEKEY_MAX_SPEED
#define MOUSEKEY_WHEEL_TIME_TO_MAX MOUSEKEY_TIME_TO_MAX

12
keyboards/planck/ez/ez.c
View File

@@ -106,16 +106,6 @@ led_config_t g_led_config = { {
1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1
} };
void suspend_power_down_kb(void) {
rgb_matrix_set_color_all(0, 0, 0);
rgb_matrix_set_suspend_state(true);
suspend_power_down_user();
}
void suspend_wakeup_init_kb(void) {
rgb_matrix_set_suspend_state(false);
suspend_wakeup_init_user();
}
#endif
/* Left B9 Right B8 */
@@ -259,7 +249,7 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
planck_ez_left_led_off();
planck_ez_right_led_off();
state = layer_state_set_user(state);
uint8_t layer = biton32(state);
uint8_t layer = get_highest_layer(state);
switch (layer) {
case PLANCK_EZ_LED_LOWER:
planck_ez_left_led_on();

7
keyboards/planck/ez/rules.mk
View File

@@ -11,10 +11,11 @@ BOOTMAGIC_ENABLE = yes # Enable Bootmagic Lite
MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration
COMMAND_ENABLE = yes # Commands for debug and configuration
NKRO_ENABLE = yes # Enable N-Key Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
AUDIO_ENABLE = yes # Audio output
AUDIO_DRIVER = dac_additive
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight.
ENCODER_ENABLE = yes
@@ -26,3 +27,5 @@ LAYOUTS_HAS_RGB = no
RGB_MATRIX_SUPPORTED = yes
RGBLIGHT_SUPPORTED = no
BAKCLIGHT_SUPPORTED = no
MOUSE_SHARED_EP = no

21
keyboards/planck/keymaps/ajp10304/readme.md
View File

@@ -22,6 +22,15 @@ Refer to the README.md of the keyboard you want to flash.
| Shft | Z | X | C | V | B | N | M | ,< | .> | /? | Shft |
| Fn | Ctrl | Alt | GUI |Lower | Bksp |Space |Raise | Shift| MENU | Ctrl | Fn2 |
##### Main Colemak-DHm Layer
| | | | | | | | | | | | |
| ---- |:----:| :---:|:---:|:-----:|:----:|:-----:|:-----:|:-----:|:----:|:----:| ----:|
| Esc | Q | W | F | P | B | J | L | U | Y | ;: | Bksp |
| Tab | A | R | S | T | G | M | N | E | I | O | Enter|
| Shft | Z | X | C | D | V | K | H | ,< | .> | /? | Shft |
| Fn | Ctrl | Alt | GUI | Lower | Bksp | Space | Raise | Shift | MENU | Ctrl | Fn2 |
##### Function Layer
Activated when `fn` held in the above `qwerty` layer.
@@ -73,12 +82,12 @@ To finish the recording, press STOP. To replay the macro, press either PLAY1 or
* MAC: Toggle MAC OS extensions to layers. This allows MLWR to be enabled with LOWER,
MRSE with RAISE, MFNC with FUNC and MFNC2 with FUNC2 respectively.
| | | | | | | | | | | | |
| :---: |:----:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:|
| ???? | Reset|Qwerty| | | REC1 | REC2 | | | | | Del |
| CAPS | | | | | PLAY1|PLAY2 | Mute | Vol+ | Play | | |
| MAC | | | | | STOP1|STOP2 | Prev | Vol- | Next | | |
| | | | | | | | | DYN | | | |
| | | | | | | | | | | | |
| :---: |:----:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:|:-------:|
| ???? | Reset|Qwerty| | | REC1 | REC2 | | | | | Del |
| CAPS | | | | | PLAY1|PLAY2 | Mute | Vol+ | Play | | Qwerty |
| MAC | | | | | STOP1|STOP2 | Prev | Vol- | Next | | Colemak |
| | | | | | | | | DYN | | | |
##### Function 2 Layer
Activated when `fn` held in the above `qwerty` layer.

5
keyboards/planck/keymaps/ariccb/.vscode/settings.json vendored Normal file
View File

@@ -0,0 +1,5 @@
{
"files.associations": {
"select_word.h": "c"
}
}

56
keyboards/planck/keymaps/ariccb/config.h Normal file
View File

@@ -0,0 +1,56 @@
/* Copyright 2015-2021 Jack Humbert
*
* 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/>.
*/
#pragma once
#ifdef AUDIO_ENABLE
# define STARTUP_SONG SONG(PLANCK_SOUND)
// #define STARTUP_SONG SONG(NO_SOUND)
# define DEFAULT_LAYER_SONGS \
{ SONG(QWERTY_SOUND), SONG(COLEMAK_SOUND), SONG(DVORAK_SOUND) }
#endif
/*
* MIDI options
*/
/* 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
#define TAPPING_TERM 150
#define IGNORE_MOD_TAP_INTERRUPT
// #define IGNORE_MOD_TAP_INTERRUPT
// #define HOLD_ON_OTHER_KEY_PRESS
#define COMBO_TERM 20
#define MOUSEKEY_INTERVAL 16 //Time between cursor movements in milliseconds.
//If the refresh rate of your display is 60Hz, you could set it to 16 (1/60). As this raises the cursor speed significantly, you may want to lower MOUSEKEY_MAX_SPEED
#define MOUSEKEY_MAX_SPEED 8 //Maximum cursor speed at which acceleration stops
#define MOUSEKEY_TIME_TO_MAX 50 //Time until maximum scroll speed is reached
#define MOUSEKEY_DELAY 100 //Delay between pressing a movement key and cursor movement
#define MOUSEKEY_MOVE_DELTA 8 //Step size

122
keyboards/planck/keymaps/ariccb/features/caps_word.c Normal file
View File

@@ -0,0 +1,122 @@
// 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.
//
//
// For full documentation, see
// https://getreuer.info/posts/keyboards/caps-word
#include "caps_word.h"
static bool caps_word_active = false;
bool process_caps_word(uint16_t keycode, keyrecord_t* record) {
#ifndef NO_ACTION_ONESHOT
const uint8_t mods = get_mods() | get_oneshot_mods();
#else
const uint8_t mods = get_mods();
#endif // NO_ACTION_ONESHOT
if (!caps_word_active) {
// Pressing both shift keys at the same time enables caps word.
if ((mods & MOD_MASK_SHIFT) == MOD_MASK_SHIFT) {
caps_word_set(true); // Activate Caps Word.
return false;
}
return true;
}
if (!record->event.pressed) { return true; }
if (!(mods & ~MOD_MASK_SHIFT)) {
switch (keycode) {
// Ignore MO, TO, TG, TT, and OSL layer switch keys.
case QK_MOMENTARY ... QK_MOMENTARY + 255:
case QK_TO ... QK_TO + 255:
case QK_TOGGLE_LAYER ... QK_TOGGLE_LAYER + 255:
case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE + 255:
case QK_ONE_SHOT_LAYER ... QK_ONE_SHOT_LAYER + 255:
return true;
#ifndef NO_ACTION_TAPPING
case QK_MOD_TAP ... QK_MOD_TAP_MAX:
if (record->tap.count == 0) {
// Deactivate if a mod becomes active through holding a mod-tap key.
caps_word_set(false);
return true;
}
keycode &= 0xff;
break;
#ifndef NO_ACTION_LAYER
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
#endif // NO_ACTION_LAYER
if (record->tap.count == 0) { return true; }
keycode &= 0xff;
break;
#endif // NO_ACTION_TAPPING
#ifdef SWAP_HANDS_ENABLE
case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX:
if (keycode > 0x56F0 || record->tap.count == 0) { return true; }
keycode &= 0xff;
break;
#endif // SWAP_HANDS_ENABLE
}
if (caps_word_press_user(keycode)) {
return true;
}
}
caps_word_set(false); // Deactivate Caps Word.
return true;
}
void caps_word_set(bool active) {
if (active != caps_word_active) {
if (active) {
clear_mods();
#ifndef NO_ACTION_ONESHOT
clear_oneshot_mods();
#endif // NO_ACTION_ONESHOT
}
caps_word_active = active;
caps_word_set_user(active);
}
}
bool caps_word_get(void) { return caps_word_active; }
__attribute__((weak)) void caps_word_set_user(bool active) {}
__attribute__((weak)) bool caps_word_press_user(uint16_t keycode) {
switch (keycode) {
// Keycodes that continue Caps Word, with shift applied.
case KC_A ... KC_Z:
add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to the next key.
return true;
// Keycodes that continue Caps Word, without shifting.
case KC_1 ... KC_0:
case KC_P1 ... KC_P0:
case KC_BSPC:
case KC_MINS:
case KC_UNDS:
return true;
default:
return false; // Deactivate Caps Word.
}
}

101
keyboards/planck/keymaps/ariccb/features/caps_word.h Normal file
View File

@@ -0,0 +1,101 @@
// 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.
//
//
// Caps Word, activated by pressing both shift keys at the same time.
//
// This library implements "Caps Word", which is like conventional Caps Lock,
// but automatically disables itself at the end of the word. This is useful for
// typing all-caps identifiers like `MOD_MASK_ALT`.
//
// Caps Word is activated by pressing the left and right shift keys at the same
// time. This way you don't need a dedicated key for using Caps Word. I've
// tested that this works as expected with one-shot mods and Space Cadet Shift.
// If your shift keys are mod-taps, activate Caps Word by holding both shift
// mod-tap keys until the tapping term, release them, then begin typing.
//
// For full documentation, see
// https://getreuer.info/posts/keyboards/caps-word
#pragma once
#include QMK_KEYBOARD_H
// Call this function from `process_record_user()` to implement Caps Word.
bool process_caps_word(uint16_t keycode, keyrecord_t* record);
// Activates or deactivates Caps Word. For instance activate Caps Word with a
// combo by defining a `COMBO_ACTION` that calls `caps_word_set(true)`:
//
// void process_combo_event(uint16_t combo_index, bool pressed) {
// switch(combo_index) {
// case CAPS_COMBO:
// if (pressed) {
// caps_word_set(true); // Activate Caps Word.
// }
// break;
//
// // Other combos...
// }
// }
void caps_word_set(bool active);
// Returns whether Caps Word is currently active.
bool caps_word_get(void);
// An optional callback that gets called when Caps Word turns on or off. This is
// useful to represent the current Caps Word state, e.g. by setting an LED or
// playing a sound. In your keymap, define
//
// void caps_word_set_user(bool active) {
// if (active) {
// // Do something when Caps Word activates.
// } else {
// // Do something when Caps Word deactivates.
// }
// }
void caps_word_set_user(bool active);
// An optional callback which is called on every key press while Caps Word is
// active. When the key should be shifted (that is, a letter key), the callback
// should call `add_weak_mods(MOD_BIT(KC_LSFT))` to shift the key. The callback
// also determines whether the key should continue Caps Word. Returning true
// continues the current "word", while returning false is "word breaking" and
// deactivates Caps Word. The default callback is
//
// bool caps_word_press_user(uint16_t keycode) {
// switch (keycode) {
// // Keycodes that continue Caps Word, with shift applied.
// case KC_A ... KC_Z:
// add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to the next key.
// return true;
//
// // Keycodes that continue Caps Word, without shifting.
// case KC_1 ... KC_0:
// case KC_BSPC:
// case KC_MINS:
// case KC_UNDS:
// return true;
//
// default:
// return false; // Deactivate Caps Word.
// }
// }
//
// To customize, copy the above function into your keymap and add/remove
// keycodes to the above cases.
//
// NOTE: Outside of this callback, you can use `caps_word_set(false)` to
// deactivate Caps Word.
bool caps_word_press_user(uint16_t keycode);

110
keyboards/planck/keymaps/ariccb/features/select_word.c Normal file
View File

@@ -0,0 +1,110 @@
// Copyright 2021 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.
//
//
// For full documentation, see
// https://getreuer.info/posts/keyboards/select-word
#include "select_word.h"
// Mac users, uncomment this line:
// #define MAC_HOTKEYS
enum { STATE_NONE, STATE_SELECTED, STATE_WORD, STATE_FIRST_LINE, STATE_LINE };
bool process_select_word(uint16_t keycode, keyrecord_t* record,
uint16_t sel_keycode) {
static uint8_t state = STATE_NONE;
if (keycode == KC_LSFT || keycode == KC_RSFT) { return true; }
if (keycode == sel_keycode && record->event.pressed) { // On key press.
const uint8_t mods = get_mods();
#ifndef NO_ACTION_ONESHOT
const uint8_t all_mods = mods | get_oneshot_mods();
#else
const uint8_t all_mods = mods;
#endif // NO_ACTION_ONESHOT
if ((all_mods & MOD_MASK_SHIFT) == 0) { // Select word.
#ifdef MAC_HOTKEYS
register_code(KC_LALT);
#else
register_code(KC_LCTL);
#endif // MAC_HOTKEYS
if (state == STATE_NONE) {
tap_code(KC_RGHT);
tap_code(KC_LEFT);
}
register_code(KC_LSFT);
register_code(KC_RGHT);
state = STATE_WORD;
} else { // Select line.
if (state == STATE_NONE) {
clear_mods();
#ifndef NO_ACTION_ONESHOT
clear_oneshot_mods();
#endif // NO_ACTION_ONESHOT
#ifdef MAC_HOTKEYS
register_code16(LCTL(KC_A));
tap_code16(LSFT(KC_E));
unregister_code16(LCTL(KC_A));
#else
tap_code(KC_HOME);
tap_code16(LSFT(KC_END));
#endif // MAC_HOTKEYS
set_mods(mods);
state = STATE_FIRST_LINE;
} else {
register_code(KC_DOWN);
state = STATE_LINE;
}
}
return false;
}
// `sel_keycode` was released, or another key was pressed.
switch (state) {
case STATE_WORD:
unregister_code(KC_RGHT);
unregister_code(KC_LSFT);
#ifdef MAC_HOTKEYS
unregister_code(KC_LALT);
#else
unregister_code(KC_LCTL);
#endif // MAC_HOTKEYS
state = STATE_SELECTED;
break;
case STATE_FIRST_LINE:
state = STATE_SELECTED;
break;
case STATE_LINE:
unregister_code(KC_DOWN);
state = STATE_SELECTED;
break;
case STATE_SELECTED:
if (keycode == KC_ESC) {
tap_code(KC_RGHT);
state = STATE_NONE;
return false;
}
// Fallthrough.
default:
state = STATE_NONE;
}
return true;
}

37
keyboards/planck/keymaps/ariccb/features/select_word.h Normal file
View File

@@ -0,0 +1,37 @@
// Copyright 2021 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.
//
//
// Select word/line button.
//
// Implements a button that selects the current word, assuming conventional text
// editor hotkeys. Pressing it again extends the selection to the following
// word. The effect is similar to word selection (W) in the Kakoune editor.
//
// Pressing the button with shift selects the current line, and pressing the
// button again extends the selection to the following line.
//
// Note for Mac users: Windows/Linux editing hotkeys are assumed by default.
// Uncomment the `#define MAC_HOTKEYS` line in select_word.c for Mac hotkeys.
// The Mac implementation is untested, let me know if it has problems.
//
// For full documentation, see
// https://getreuer.info/posts/keyboards/select-word
#pragma once
#include QMK_KEYBOARD_H
bool process_select_word(uint16_t keycode, keyrecord_t* record,
uint16_t sel_keycode);

664
keyboards/planck/keymaps/ariccb/keymap.c Normal file
View File

@@ -0,0 +1,664 @@
/* Copyright 2021 Aric Crosson Bouwers
*
* 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 "muse.h"
#include "features/select_word.h"
#include "features/caps_word.h"
// using the Word Selection QMK Macro by Pascal Getreuer, found here: https://getreuer.info/posts/keyboards/select-word/index.html
// THANKS Pascal for such amazing functionality!!
// Each layer gets a name for readability, which is then used in the keymap matrix below.
// The underscores don't mean anything - you can have a layer called STUFF or any other name.
// Layer names don't all need to be of the same length, obviously, and you can also skip them
// entirely and just use numbers.
#define _QWERTY 0
#define _COLEMAK_VCP 1
#define _LOWER 2
#define _RAISE 3
#define _NUMPAD 4
#define _FN 5
#define _ADJUST 6
#define _GAMING 7
#define MICMUTE LALT(KC_M)
#define DESKTR LGUI(LCTL(KC_RGHT)) // move one virtual desktop to the right
#define DESKTL LGUI(LCTL(KC_LEFT)) // move one virtual desktop to the left
#define MTLCTL_F9 MT(MOD_LCTL, KC_F9)
#define MTLSFT_F10 MT(MOD_LSFT, KC_F10)
#define MTLALT_F11 MT(MOD_LALT, KC_F11)
#define MTLGUI_Z MT(MOD_LGUI, KC_Z)
#define MTLALT_PL MT(MOD_LALT, KC_MPLY)
#define MTLALT_NXT MT(MOD_LALT, KC_MNXT)
#define MTENTER MT(MOD_LCTL, KC_ENT)
#define MTRSFTBSLS MT(MOD_RSFT, KC_BSLS)
#define MTRCTLQUO MT(MOD_RCTL, KC_QUOT)
#define MTTAB MT(MOD_LCTL | MOD_LGUI | MOD_LALT, KC_TAB)
#define LTESC LT(_FN, KC_ESC)
#define MTPLAY MT(MOD_RALT, KC_MPLY)
#define KC_COPY LCTL(KC_C)
#define KC_CUT LCTL(KC_X)
#define KC_PASTE LCTL(KC_V)
#define KC_WINPASTE LGUI(KC_V)
#define KC_PTXT LCTL(LSFT(KC_V))
#define KC_UNDO LCTL(KC_Z)
#define KC_REDO LCTL(KC_Y)
enum planck_keycodes {
QWERTY = SAFE_RANGE,
COLEMAK_VCP,
LOWER,
RAISE,
FN,
ADJUST,
NUMPAD,
GAMING,
EXT_NUM,
EXT_GAMING,
SELWORD,
BRACES,
BRACES2,
ARROW,
ALT_TAB
};
// Define a type for as many tap dance states as you need
typedef enum {
TD_NONE,
TD_UNKNOWN,
TD_SINGLE_TAP,
TD_SINGLE_HOLD,
TD_DOUBLE_TAP
} td_state_t;
typedef struct {
bool is_press_action;
td_state_t state;
} td_tap_t;
// Our custom tap dance keys; add any other tap dance keys to this enum
enum {
UNDS_LOWER,
PLAY_RAISE
};
// Declare the functions to be used with your tap dance key(s)
// Function associated with all tap dances
td_state_t cur_dance(qk_tap_dance_state_t *state);
// Functions associated with individual tap dances
void usl_finished(qk_tap_dance_state_t *state, void *user_data);
void usl_reset(qk_tap_dance_state_t *state, void *user_data);
/* ----------------------------------------------------------------------------------------------------------------------------- */
// This is a completely modified layout that stikes a balance between muscle memory for keys, where I was coming from a standard
// Qwerty keyboard, and efficiency gained by using layers. I've switched tab and esc because it's more natural to me this way, and
// added layer switch on hold functionality for each key. Enter has moved to the key beside LOWER, to allow usage while still having
// the right hand on the mouse.
// Lower incorporates a numpad on the right side, and all of the symbols included on the left. There is logic for the symbols needed for
// calculators and math are located around the numpad, and coding symbols are placed in easy to remember spots.
// CAPS has moved to the Fn layer, and a few additional shortcut modifiers like CTRL_ALT_UP and DOWN for adding additional cursors in VSCode.
// Play/Pause has a prime spot on the base layer, and the Fn version skips to next track
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* MIT Layout (QWERTY)
*
* ,------------------------------------------------------------------------.
* |FN,Esc| q | w | e | r | t | y | u | i | o | p |Bsp |
* |------------------------------------------------------------------------|
|CSW,Tab| a | s | d | f | g | h | j | k | l | ; |Ctl,'|
* |------------------------------------------------------------------------|
* |Shift |Win,z| x | c | v | b | n | m | , | . | / |Sft,\|
* |------------------------------------------------------------------------|
* | | | |Ctl,Ent|LOWER| Space |RAISE|Alt,Play| | | |
* `------------------------------------------------------------------------'
*/
[_QWERTY] = LAYOUT_planck_grid( /* QWERTY */
LTESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
MTTAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, MTRCTLQUO,
KC_LSFT, MTLGUI_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, MTRSFTBSLS,
KC_NO, KC_NO, KC_NO, MTENTER, TD(UNDS_LOWER), KC_SPC, KC_SPC, MO(3), MTLALT_PL, KC_NO, KC_NO, KC_NO
),
/* MIT Layout (COLEMAK_VCP)
*
* ,------------------------------------------------------------------------.
* |FN,ESC| q | w | f | d | b | j | l | u | y | ; | Bsp |
* |------------------------------------------------------------------------|
|CSW,Tab| a | r | s | t | g | m | n | e | i | o |Ctl,'|
* |------------------------------------------------------------------------|
* |Shift |Win,z| x | v | c | p | k | h | , | . | / |Sft,\|
* |------------------------------------------------------------------------|
* | | | |Ctl,Ent|LWR,_| Space |RAISE|Alt,Play| | | |
* `------------------------------------------------------------------------'
*/
[_COLEMAK_VCP] = LAYOUT_planck_grid( /* COLEMAK_VCP */
LTESC, KC_Q, KC_W, KC_F, KC_D, KC_B, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC,
MTTAB, KC_A, KC_R, KC_S, KC_T, KC_G, KC_M, KC_N, KC_E, KC_I, KC_O, MTRCTLQUO,
KC_LSFT, MTLGUI_Z, KC_X, KC_V, KC_C, KC_P, KC_K, KC_H, KC_COMM, KC_DOT, KC_SLSH, MTRSFTBSLS,
KC_NO, KC_NO, KC_NO, MTENTER, TD(UNDS_LOWER), KC_SPC, KC_SPC, MO(3), MTLALT_PL, KC_NO, KC_NO, KC_NO
),
/* MIT Layout (RAISE)
*
* ,----------------------------------------------------------------------------.
* | ~ | ! | | | | | | Cut | Undo| Redo|P2TXT| Bsp |
* |----------------------------------------------------------------------------|
* | |Menu | | | | |ARROW |SELWORD|Copy|Paste|WinPst| " |
* |----------------------------------------------------------------------------|
* | |Vol+ |Vol- | Mute| | |Braces|Braces2| < | > | ? | ! |
* |----------------------------------------------------------------------------|
* | | | | |Adjust| | | | | | |
* `----------------------------------------------------------------------------'
*/
[_RAISE] = LAYOUT_planck_grid( /* RAISE */
KC_TILD, KC_EXLM, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_CUT, KC_UNDO, KC_REDO, KC_PTXT, KC_BSPC,
KC_TRNS, KC_APP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, ARROW, SELWORD, KC_COPY, KC_PASTE, KC_WINPASTE, KC_DQUO,
KC_TRNS, KC_VOLU, KC_VOLD, KC_MUTE, KC_TRNS, KC_TRNS, BRACES, BRACES2, KC_LABK, KC_RABK, KC_QUES, KC_EXLM,
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MO(6), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_NO
),
/* MIT Layout (LOWER)
* XZ
* ,-----------------------------------------------------------------------.
* | ` | ! | # | $ | < | > | : | 7 | 8 | 9 | = | Bsp |
* |-----------------------------------------------------------------------|
* | ' | _ | ^ | % | ( | ) | M | 4 | 5 | 6 | - | + |
* |-----------------------------------------------------------------------|
* |Shift| | | & | " | { | } | @ | 1 | 2 | 3 | / | * |
* |-----------------------------------------------------------------------|
* | | | | | | |MO(6),0| . | | | |
* `-----------------------------------------------------------------------'
*/
[_LOWER] = LAYOUT_planck_grid( /* LOWER */
KC_GRV, KC_EXLM, KC_HASH, KC_DLR, KC_LABK, KC_RABK, KC_COLN, KC_P7, KC_P8, KC_P9, KC_EQL, KC_BSPC,
KC_QUOT, KC_UNDS, KC_CIRC, KC_PERC, KC_LPRN, KC_RPRN, KC_M, KC_P4, KC_P5, KC_P6, KC_PMNS, KC_PPLS,
KC_TRNS, KC_PIPE, KC_AMPR, KC_DQUO, KC_LCBR, KC_RCBR, KC_AT, KC_P1, KC_P2, KC_P3, KC_PSLS, KC_PAST,
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_P0, KC_PDOT, KC_NO, KC_NO, KC_NO
),
/* MIT Layout (GAMING)
*.
* ,-----------------------------------------------------------------------.
* |ESC,`| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |EXIT GAMING|
* |-----------------------------------------------------------------------|
* | TAB | Q | W | E | R | T | I | 4 | 5 | 6 | - | + |
* |-----------------------------------------------------------------------|
* |Shift| A | S | D | F | G | K | 1 | 2 | 3 | / | * |
* |-----------------------------------------------------------------------|
* | | | | Ctl | Alt | SPACE | 0 | . | | | |
* `-----------------------------------------------------------------------'
*/
[_GAMING] = LAYOUT_planck_grid( /* GAMING */
KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_P8, KC_9, KC_0, EXT_GAMING,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_I, KC_P4, KC_P5, KC_P6, KC_PMNS, KC_PPLS,
KC_LSFT, KC_A, KC_S, KC_D, KC_F, KC_G, KC_K, KC_P1, KC_P2, KC_P3, KC_PSLS, KC_PAST,
KC_NO, KC_NO, KC_NO, KC_LCTL, KC_LALT, KC_SPC, KC_SPC, KC_P0, KC_PDOT, KC_NO, KC_NO, KC_NO
),
/* MIT Layout (FN)
*
* ,----------------------------------------------------------------------------.
* | |Ctl,F9 |Sft,F10|Alt,F11| F12 |MyComp|Calc |home | up | end |PrtScr| Del |
* |-----------------------------------------------------------------------------|
* | | F5 | F6 | F7 | F8 |DeskL |DeskR |left | down |right|ScrLck| CAPS|
* |-----------------------------------------------------------------------------|
* | | F1 | F2 | F3 | F4 |ALT_TAB|MicM |pgup |LCA_dn| pgdn|Pse/Brk| Ins|
* |-----------------------------------------------------------------------------|
* | | | | | | | |Alt,MNext| | | |
* `-----------------------------------------------------------------------------'
*/
[_FN] = LAYOUT_planck_grid( /* FUNCTION */
KC_TRNS, MTLCTL_F9, MTLSFT_F10, MTLALT_F11, KC_F12, KC_MYCM, KC_CALC, KC_HOME, KC_UP, KC_END, KC_PSCR, KC_DEL,
KC_TRNS, KC_F5, KC_F6, KC_F7, KC_F8, DESKTL, DESKTR, KC_LEFT, KC_DOWN, KC_RGHT, KC_SLCK, KC_CAPS,
KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F4, ALT_TAB, MICMUTE, KC_PGUP, LCA(KC_DOWN), KC_PGDN, KC_PAUSE, KC_INS,
KC_NO, KC_NO, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, MTLALT_NXT, KC_NO, KC_NO, KC_NO
),
/* MIT Layout (ADJUST)
*
* ,-----------------------------------------------------------------------------.
* |RGBtog|Ms3 | Ms2 |MsUp | Ms1 | Hue+| Hue- | Sat+| Sat- |Brt+ |Brt- | RESET|
* |-----------------------------------------------------------------------------|
* |RGBMod| MWL | MsL |MDn |MsR |GAMING| |AU_ON|AU_OFF|MU_ON|MU_OF| DEBUG|
* |-----------------------------------------------------------------------------|
* | |MWLft|MWUp |NWDn |NWRght|QWERTY|CMK_VCP|MI_ON|MI_OF | | |MU_Mod|
* |-----------------------------------------------------------------------------|
* | | | |SLEEP| | | | | | | |
* `-----------------------------------------------------------------------------'
*/
[_ADJUST] = LAYOUT_planck_grid( /* ADJUST LAYER */
RGB_TOG, KC_BTN3, KC_BTN2, KC_MS_U, KC_BTN1, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, RESET,
RGB_MOD, KC_NO, KC_MS_L, KC_MS_D, KC_MS_R, GAMING, KC_NO, AU_ON, AU_OFF, MU_ON, MU_OFF, DEBUG,
KC_TRNS, KC_WH_L, KC_WH_U, KC_WH_D, KC_WH_R, QWERTY, COLEMAK_VCP, MI_ON, MI_OFF, KC_TRNS, KC_TRNS, MU_MOD,
KC_NO, KC_NO, KC_NO, KC_SLEP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_NO
)
};
#ifdef AUDIO_ENABLE
float layerswitch_song[][2] = SONG(PLANCK_SOUND);
float tone_startup[][2] = SONG(STARTUP_SOUND);
float tone_qwerty[][2] = SONG(QWERTY_SOUND);
float tone_COLEMAK_VCP[][2] = SONG(COLEMAK_SOUND);
float music_scale[][2] = SONG(MUSIC_SCALE_SOUND);
float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
#endif
bool is_alt_tab_active = false;
layer_state_t layer_state_set_user(layer_state_t state) {
static bool is_this_layer_on = false;
if (layer_state_cmp(state, 4) != is_this_layer_on) {
is_this_layer_on = layer_state_cmp(state, 4);
if (is_this_layer_on) {
PLAY_SONG(layerswitch_song);
}
else {
stop_all_notes();
}
}
if (is_alt_tab_active) {
unregister_code(KC_LALT);
is_alt_tab_active = false;
}
return state;
switch (get_highest_layer(state)) {
case _ADJUST:
rgblight_setrgb (0xFF, 0x00, 0x00);
break;
case _LOWER:
rgblight_setrgb (0x00, 0x00, 0xFF);
break;
case _NUMPAD:
rgblight_setrgb (0x00, 0x00, 0xFF);
break;
case _RAISE:
rgblight_setrgb (0x7A, 0x00, 0xFF);
break;
case _FN:
rgblight_setrgb (0x00, 0xFF, 0x00);
break;
default: // for any other layers, or the default layer
rgblight_setrgb (0xFF, 0xFF, 0xFF);
break;
}
return state;
}
// void dance_media (qk_tap_dance_state_t *state, void *user_data)
// if (state->count == 1) {
// tap_code(KC_MPLY);
// } else if (state->count == 2) {
// tap_code (KC_MNXT);
// } else if (state->count == 3) {
// tap_code(KC_MPRV);
// } else {
// reset_tap_dance (state);
// }
// }
// qk_tap_dance_action_t tap_dance_actions[] = {
// [0] = ACTION_TAP_DANCE_FN (dance_media),
// };
// Determine the current tap dance state
td_state_t cur_dance(qk_tap_dance_state_t *state) {
if (state->interrupted) return TD_SINGLE_HOLD;
if (state->count == 1) {
if (!state->pressed) return TD_SINGLE_TAP;
else return TD_SINGLE_HOLD;
} else if (state->count == 2) return TD_DOUBLE_TAP;
else return TD_UNKNOWN;
}
// Initialize tap structure associated with example tap dance key
static td_tap_t usl_tap_state = {
.is_press_action = true,
.state = TD_NONE
};
// Functions that control what our tap dance key does
void usl_finished(qk_tap_dance_state_t *state, void *user_data) {
usl_tap_state.state = cur_dance(state);
switch (usl_tap_state.state) {
case TD_SINGLE_TAP:
tap_code16(KC_UNDS);
break;
case TD_SINGLE_HOLD:
layer_on(_LOWER);
// update_tri_layer(_LOWER, _RAISE, _ADJUST);
break;
case TD_DOUBLE_TAP:
// Check to see if the layer is already set
if (layer_state_is(_LOWER)) {
// If already set, then switch it off
layer_off(_LOWER);
#ifdef AUDIO_ENABLE
PLAY_SONG(tone_goodbye);
#endif
} else {
// If not already set, then switch the layer on
layer_on(_LOWER);
#ifdef AUDIO_ENABLE
PLAY_SONG(layerswitch_song);
#endif
}
break;
default:
break;
}
}
void usl_reset(qk_tap_dance_state_t *state, void *user_data) {
// If the key was held down and now is released then switch off the layer
if (usl_tap_state.state == TD_SINGLE_HOLD) {
layer_off(_LOWER);
// update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
usl_tap_state.state = TD_NONE;
}
// Associate our tap dance key with its functionality
qk_tap_dance_action_t tap_dance_actions[] = {
[UNDS_LOWER] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, usl_finished, usl_reset, 175)
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (!process_select_word(keycode, record, SELWORD)) { return false; }
if (!process_caps_word(keycode, record)) { return false; }
const uint8_t mods = get_mods();
const uint8_t oneshot_mods = get_oneshot_mods();
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
return false;
break;
case KC_CAPS:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
PLAY_SONG(tone_qwerty);
#endif
register_code(KC_CAPS);
}
return false;
break;
case GAMING:
if (record->event.pressed) {
layer_off(_RAISE);
layer_off(_LOWER);
layer_off(_ADJUST);
layer_on(_GAMING);
#ifdef AUDIO_ENABLE
PLAY_SONG(layerswitch_song);
#endif
}
return false;
break;
case EXT_GAMING:
if (record->event.pressed) {
layer_off(_GAMING);
#ifdef AUDIO_ENABLE
PLAY_SONG(tone_goodbye);
#endif
}
return false;
break;
case COLEMAK_VCP:
if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK_VCP);
}
return false;
break;
case BRACES: // Types (), or {}, and puts cursor between braces.
if (record->event.pressed) {
clear_mods(); // Temporarily disable mods.
clear_oneshot_mods();
if ((mods | oneshot_mods) & MOD_MASK_SHIFT) {
SEND_STRING("{}");
} else {
SEND_STRING("<>");
}
tap_code(KC_LEFT); // Move cursor between braces.
set_mods(mods); // Restore mods.
}
return false;
case BRACES2: // Types [], or <>, and puts cursor between braces.
if (record->event.pressed) {
clear_mods(); // Temporarily disable mods.
clear_oneshot_mods();
if ((mods | oneshot_mods) & MOD_MASK_SHIFT) {
SEND_STRING("()");
} else {
SEND_STRING("[]");
}
tap_code(KC_LEFT); // Move cursor between braces.
set_mods(mods); // Restore mods.
}
return false;
case ARROW: // Arrow macro, types -> or =>.
if (record->event.pressed) {
if ((mods | oneshot_mods) & MOD_MASK_SHIFT) { // Is shift held?
del_mods(MOD_MASK_SHIFT); // Temporarily delete shift.
del_oneshot_mods(MOD_MASK_SHIFT);
SEND_STRING("->");
set_mods(mods); // Restore mods.
} else {
SEND_STRING("=>");
}
}
return false;
case ALT_TAB: // super alt tab macro
if (record->event.pressed) {
if (!is_alt_tab_active) {
is_alt_tab_active = true;
register_code(KC_LALT);
}
register_code(KC_TAB);
} else {
unregister_code(KC_TAB);
}
return false;
break;
}
return true;
}
enum combo_events {
EM_EMAIL,
EM_WORK_EMAIL,
HTML_P,
HTML_TITLE,
HTML_DIV,
HTML_HTML,
HTML_HEAD,
HTML_BODY,
HTML_FOOTER,
HTML_A_HREF,
HTML_IMG,
CSS_STYLE,
HTML_GENERIC_TAG,
CTLRGHT,
CTLLEFT,
COMBO_LENGTH
};
uint16_t COMBO_LEN = COMBO_LENGTH; // remove the COMBO_COUNT define and use this instead!
const uint16_t PROGMEM email_combo[] = {KC_E, KC_M, COMBO_END};
const uint16_t PROGMEM email_work_combo[] = {KC_E, KC_K, COMBO_END};
const uint16_t PROGMEM html_p_combo[] = {KC_P, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_title_combo[] = {KC_T, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_div_combo[] = {KC_D, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_html_combo[] = {KC_Q, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_head_combo[] = {KC_W, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_body_combo[] = {KC_R, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_footer_combo[] = {KC_X, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_a_href_combo[] = {KC_A, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_img_combo[] = {KC_F, KC_DOT, COMBO_END};
const uint16_t PROGMEM css_style_combo[] = {KC_S, KC_DOT, COMBO_END};
const uint16_t PROGMEM html_generic_tag_combo[] = {KC_G, KC_DOT, COMBO_END};
const uint16_t PROGMEM ctrrght_combo[] = {KC_RGHT, KC_DOWN, COMBO_END};
const uint16_t PROGMEM ctrleft_combo[] = {KC_LEFT, KC_DOWN, COMBO_END};
// const uint8_t combo_mods = get_mods();
// const uint8_t combo_oneshot_mods = get_oneshot_mods();
combo_t key_combos[] = {
[EM_EMAIL] = COMBO_ACTION(email_combo),
[EM_WORK_EMAIL] = COMBO_ACTION(email_work_combo),
[HTML_P] = COMBO_ACTION(html_p_combo),
[HTML_TITLE] = COMBO_ACTION(html_title_combo),
[HTML_DIV] = COMBO_ACTION(html_div_combo),
[HTML_HTML] = COMBO_ACTION(html_html_combo),
[HTML_HEAD] = COMBO_ACTION(html_head_combo),
[HTML_BODY] = COMBO_ACTION(html_body_combo),
[HTML_FOOTER] = COMBO_ACTION(html_footer_combo),
[HTML_A_HREF] = COMBO_ACTION(html_a_href_combo),
[HTML_IMG] = COMBO_ACTION(html_img_combo),
[CSS_STYLE] = COMBO_ACTION(css_style_combo),
[HTML_GENERIC_TAG] = COMBO_ACTION(html_generic_tag_combo),
[CTLRGHT] = COMBO_ACTION(ctrrght_combo),
[CTLLEFT] = COMBO_ACTION(ctrleft_combo),
};
/* COMBO_ACTION(x) is same as COMBO(x, KC_NO) */
void process_combo_event(uint16_t combo_index, bool pressed) {
switch(combo_index) {
case EM_EMAIL:
if (pressed) {
SEND_STRING("aricbouwers@outlook.com");
}
break;
case EM_WORK_EMAIL:
if (pressed) {
SEND_STRING("acrossonbouwers@rjc.ca");
}
break;
case HTML_DIV:
if (pressed) {
SEND_STRING("<div></div>");
for (int i = 0; i < 6; i++) {
tap_code16(KC_LEFT);
}
}
break;
case HTML_P:
if (pressed) {
SEND_STRING("<p></p>");
for (int i = 0; i < 4; i++) {
tap_code16(KC_LEFT);
}
}
break;
case HTML_TITLE:
if (pressed) {
SEND_STRING("<title></title>");
for (int i = 0; i < 8; i++) {
tap_code16(KC_LEFT);
}
}
break;
case CSS_STYLE:
if (pressed) {
SEND_STRING("<style></style>");
for (int i = 0; i < 8; i++) {
tap_code16(KC_LEFT);
}
}
break;
case HTML_HTML:
if (pressed) {
SEND_STRING("<html lang=\"en\"></html>");
for (int i = 0; i < 7; i++) {
tap_code16(KC_LEFT);
}
}
break;
case HTML_HEAD:
if (pressed) {
SEND_STRING("<head></head>");
for (int i = 0; i < 7; i++) {
tap_code16(KC_LEFT);
}
}
break;
case HTML_BODY:
if (pressed) {
SEND_STRING("<body></body>");
for (int i = 0; i < 7; i++) {
tap_code16(KC_LEFT);
}
}
break;
case HTML_FOOTER:
if (pressed) {
SEND_STRING("<footer></footer>");
for (int i = 0; i < 9; i++) {
tap_code16(KC_LEFT);
}
}
break;
case HTML_A_HREF:
if (pressed) {
SEND_STRING("<a href=\"link_goes_here\">name_of_link_goes_here</a>");
tap_code16(KC_HOME);
for (int i = 0; i < 10; i++) {
tap_code16(KC_RGHT);
}
}
break;
case HTML_IMG:
if (pressed) {
SEND_STRING("<img src=\"image_source_or_link_goes_here\" alt=\"name_if_cant_load\" width=\"num_pixels\" height=\"num_pixels\">");
tap_code16(KC_HOME);
for (int i = 0; i < 11; i++) {
tap_code16(KC_RGHT);
}
}
break;
case HTML_GENERIC_TAG:
if (pressed) {
SEND_STRING("<TAG></TAG>");
tap_code16(KC_ESC);
for (int i = 0; i < 9; i++) {
tap_code16(KC_LEFT);
}
tap_code16(LCTL(KC_D));
tap_code16(LCTL(KC_D));
tap_code16(KC_BSPC);
}
break;
case CTLLEFT:
if (pressed) {
tap_code16(C(KC_LEFT));
}
break;
case CTLRGHT:
if (pressed) {
tap_code16(C(KC_RGHT));
}
break;
}
}

78
keyboards/planck/keymaps/ariccb/readme.md Normal file
View File

@@ -0,0 +1,78 @@
```
QWERTY LAYER
* ,------------------------------------------------------------------------.
* |FN,Esc| q | w | e | r | t | y | u | i | o | p |Bsp |
* |------------------------------------------------------------------------|
|CSW,Tab| a | s | d | f | g | h | j | k | l | ; |Ctl,'|
* |------------------------------------------------------------------------|
* |Shift |Win,z| x | c | v | b | n | m | , | . | / |Sft,\|
* |------------------------------------------------------------------------|
* | | | |Ctl,Ent|LOWER| Space |RAISE|Alt,Play| | | |
* `------------------------------------------------------------------------'
COLEMAK_VCP(default) LAYER
* ,------------------------------------------------------------------------.
* |FN,ESC| q | w | f | d | b | j | l | u | y | ; | Bsp |
* |------------------------------------------------------------------------|
|CSW,Tab| a | r | s | t | g | m | n | e | i | o |Ctl,'|
* |------------------------------------------------------------------------|
* |Shift |Win,z| x | v | c | p | k | h | , | . | / |Sft,\|
* |------------------------------------------------------------------------|
* | | | |Ctl,Ent|LWR,_| Space |RAISE|Alt,Play| | | |
* `------------------------------------------------------------------------'
LOWER LAYER
* ,-----------------------------------------------------------------------.
* | ` | ! | # | $ | < | > | : | 7 | 8 | 9 | = | Bsp |
* |-----------------------------------------------------------------------|
* | ' | _ | ^ | % | ( | ) | M | 4 | 5 | 6 | - | + |
* |-----------------------------------------------------------------------|
* |Shift| | | & | " | { | } | @ | 1 | 2 | 3 | / | * |
* |-----------------------------------------------------------------------|
* | | | | | | |MO(6),0| . | | | |
* `-----------------------------------------------------------------------'
RAISED LAYER
* ,-----------------------------------------------------------------------------.
* | ~ | ! | | | | | | Cut | Undo| Redo|P2TXT| Bsp |
* |-----------------------------------------------------------------------------|
* | |Menu | | | | | ARROW |SELWORD|Copy|Paste|WinPst| " |
* |-----------------------------------------------------------------------------|
* | |Vol+ |Vol- | Mute| | | Braces|Braces2| < | > | ? | ! |
* |-----------------------------------------------------------------------------|
* | | | | |Adjust| | | | | | |
* `-----------------------------------------------------------------------------'
FN LAYER
* ,----------------------------------------------------------------------------.
* | |Ctl,F9 |Sft,F10|Alt,F11| F12 |MyComp|Calc |home | up | end |PrtScr| Del |
* |-----------------------------------------------------------------------------|
* | | F5 | F6 | F7 | F8 |DeskL |DeskR |left | down |right|ScrLck| CAPS|
* |-----------------------------------------------------------------------------|
* | | F1 | F2 | F3 | F4 |ALT_TAB| MicM|pgup |LCA_dn| pgdn|Pse/Brk| Ins|
* |-----------------------------------------------------------------------------|
* | | | | | | | |Alt,MNext| | | |
* `-----------------------------------------------------------------------------'
GAMING LAYER
* ,-----------------------------------------------------------------------.
* |ESC,`| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |EXIT GAMING|
* |-----------------------------------------------------------------------|
* | TAB | Q | W | E | R | T | I | 4 | 5 | 6 | - | + |
* |-----------------------------------------------------------------------|
* |Shift| A | S | D | F | G | K | 1 | 2 | 3 | / | * |
* |-----------------------------------------------------------------------|
* | | | | Ctl | Alt | SPACE | 0 | . | | | |
* `-----------------------------------------------------------------------'
ADJUST LAYER
* ,-----------------------------------------------------------------------------.
* |RGBtog|Ms3 | Ms2 |MsUp | Ms1 | Hue+| Hue- | Sat+| Sat- |Brt+ |Brt- | RESET|
* |-----------------------------------------------------------------------------|
* |RGBMod| MWL | MsL |MDn |MsR |GAMING| |AU_ON|AU_OFF|MU_ON|MU_OF| DEBUG|
* |-----------------------------------------------------------------------------|
* | |MWLft|MWUp |NWDn |NWRght|QWERTY|CMK_VCP|MI_ON|MI_OF | | |MU_Mod|
* |-----------------------------------------------------------------------------|
* | | | |SLEEP| | | | | | | |
* `-----------------------------------------------------------------------------'
```

10
keyboards/planck/keymaps/ariccb/rules.mk Normal file
View File

@@ -0,0 +1,10 @@
BOOTMAGIC_ENABLE = no
CONSOLE_ENABLE = no
BACKLIGHT_ENABLE = yes
MIDI_ENABLE = yes
TAP_DANCE_ENABLE = yes
DIP_SWITCH_ENABLE = no
COMBO_ENABLE = yes
SRC += features/select_word.c
SRC += features/caps_word.c

6
keyboards/planck/keymaps/default/keymap.c
View File

@@ -46,7 +46,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* ,-----------------------------------------------------------------------------------.
* | Tab | Q | W | E | R | T | Y | U | I | O | P | Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Esc | A | S | D | F | G | H | J | K | L | ; | " |
* | Esc | A | S | D | F | G | H | J | K | L | ; | ' |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | N | M | , | . | / |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
@@ -64,7 +64,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* ,-----------------------------------------------------------------------------------.
* | Tab | Q | W | F | P | G | J | L | U | Y | ; | Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Esc | A | R | S | T | D | H | N | E | I | O | " |
* | Esc | A | R | S | T | D | H | N | E | I | O | ' |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | K | M | , | . | / |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
@@ -80,7 +80,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Dvorak
* ,-----------------------------------------------------------------------------------.
* | Tab | " | , | . | P | Y | F | G | C | R | L | Bksp |
* | Tab | ' | , | . | P | Y | F | G | C | R | L | Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Esc | A | O | E | U | I | D | H | T | N | S | / |
* |------+------+------+------+------+------+------+------+------+------+------+------|

50
keyboards/planck/keymaps/inkwell/config.h Normal file
View File

@@ -0,0 +1,50 @@
/* Copyright 2021 Kevin Hartley
*
* 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/>.
*/
#pragma once
#ifdef AUDIO_ENABLE
#define STARTUP_SONG SONG(PLANCK_SOUND)
// #define STARTUP_SONG SONG(NO_SOUND)
#define DEFAULT_LAYER_SONGS { SONG(QWERTY_SOUND), \
SONG(COLEMAK_SOUND), \
SONG(DVORAK_SOUND) \
}
#endif
/*
* MIDI options
*/
/* 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
// Most tactile encoders have detents every 4 stages
#define ENCODER_RESOLUTION 4
#define MOUSEKEY_WHEEL_TIME_TO_MAX 10
#define MOUSEKEY_MAX_SPEED 12

182
keyboards/planck/keymaps/inkwell/keymap.c Normal file
View File

@@ -0,0 +1,182 @@
/* Copyright 2015-2017 Jack Humbert
*
* 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 "muse.h"
enum planck_layers {
_QWERTY,
_LOWER,
_RAISE,
_ADJUST
};
#define LOWER MO(_LOWER)
#define RAISE MO(_RAISE)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Qwerty
* ,-----------------------------------------------------------------------------------.
* | Tab | Q | W | E | R | T | Y | U | I | O | P | Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Esc | A | S | D | F | G | H | J | K | L | ; | " |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | N | M | , | . | / |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | ECDR | Ctrl | Alt | GUI |Space |Lower |Raise |Space | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_QWERTY] = LAYOUT_planck_grid(
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT,
RSFT_T(KC_MPLY), KC_LCTL, KC_LALT, KC_LGUI, KC_SPC, LOWER, RAISE, KC_SPC, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
/* Lower
* v-------NUM PAD------v
* ,-----------------------------------------------------------------------------------.
* | ` | ! | @ | # | * | / | 7 | 8 | 9 | ( | ) | Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Del | $ | % | ^ | + | - | 4 | 5 | 6 | [ | ] | = |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* |Shift | & | ? | : | ~ | . | 1 | 2 | 3 | < | > |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | ECDR | Ctrl | Alt | GUI |Space |Lower |Raise | 0 | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_LOWER] = LAYOUT_planck_grid(
KC_GRV, KC_EXLM, KC_AT, KC_HASH, KC_ASTR, KC_PSLS, KC_7, KC_8, KC_9, KC_LPRN, KC_RPRN, KC_BSPC,
KC_ESC, KC_DLR, KC_PERC, KC_CIRC, KC_PLUS, KC_MINS, KC_4, KC_5, KC_6, KC_LBRC, KC_RBRC, KC_PEQL,
KC_LSFT, KC_AMPR, KC_QUES, KC_COLN, KC_TILD, KC_DOT, KC_1, KC_2, KC_3, KC_LABK, KC_RABK, KC_ENT,
RSFT_T(KC_MPLY), KC_LCTL, KC_LALT, KC_LGUI, KC_SPC, LOWER, RAISE, KC_0, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
/* Raise
* ,-----------------------------------------------------------------------------------.
* |SLEEP | BR- | BR+ | << | PLAY | >> | MUTE | VOL- | VOL+ | ( | ) | Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Del | F1 | F2 | F3 | F4 | F5 | F6 | " | \ | [ | ] | = |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* |Shift | F7 | F8 | F9 | F10 | F11 | F12 | ? | : | < | > |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | ECDR | Ctrl | Alt | GUI |Space |Lower |Raise |Space | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_RAISE] = LAYOUT_planck_grid(
KC_SLEP, KC_BRID, KC_BRIU, KC_MPRV, KC_MPLY, KC_MNXT, KC_MUTE, KC__VOLDOWN, KC__VOLUP, KC_LPRN, KC_RPRN, KC_BSPC,
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_DQT, KC_BSLS, KC_LBRC, KC_RBRC, KC_PEQL,
KC_LSFT, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_QUES, KC_COLN, KC_LABK, KC_RABK, KC_ENT,
RSFT_T(KC_MPLY), KC_LCTL, KC_LALT, KC_LGUI, KC_SPC, LOWER, RAISE, KC_SPC, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
/* Adjust (Lower + Raise)
* v--------MOUSE CONTROL------v
* ,-----------------------------------------------------------------------------------.
* |Reset | | | | | | |MSE-1 |MSE-2 |MSE-S0|MSE-S1| Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | CALC | MAIL | MDIA |Debug | | |MSE-L |MSE-D |MSE-U |MSE-R |RGB-TG|
* |------+------+------+------+------+------+------+------+------+------+------+------|
* |Shift | | | | | | | | | | |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | ECDR | Ctrl | Alt | GUI |Space |Lower |Raise |Space | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_ADJUST] = LAYOUT_planck_grid(
RESET, _______, _______, _______, _______, _______, _______, KC_BTN1, KC_MS_BTN2, KC_ACL1, KC_ACL2, KC_BSPC ,
_______, KC_CALC, KC_MAIL, KC_MSEL, DEBUG, _______, _______, KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, RGB_TOG,
KC_LSFT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_ENT,
RSFT_T(KC_MPLY), KC_LCTL, KC_LALT, KC_LGUI, KC_SPC, LOWER, RAISE, KC_SPC, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
)
};
#ifdef AUDIO_ENABLE
float plover_song[][2] = SONG(PLOVER_SOUND);
float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND);
#endif
layer_state_t layer_state_set_user(layer_state_t state) {
return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
}
bool encoder_update_user(uint8_t index, bool clockwise) {
if (IS_LAYER_ON(_RAISE)) {
if (get_mods() & MOD_BIT(KC_RSFT)) {
// ZOOM
// Store which mods are held
uint8_t mod_state = get_mods();
// Ignore all shift keys
del_mods(MOD_MASK_SHIFT);
if (clockwise) {
tap_code16(LGUI(KC_PPLS));
} else {
tap_code16(LGUI(KC_PMNS));
}
// Add back shift keys
set_mods(mod_state);
} else if (get_mods() & MOD_BIT(KC_LSFT)) {
// SCROLL X
uint8_t mod_state = get_mods();
del_mods(MOD_MASK_SHIFT);
if (clockwise) {
tap_code16(KC_WH_L);
} else {
tap_code16(KC_WH_R);
}
set_mods(mod_state);
} else {
// SCROLL Y
if (clockwise) {
tap_code(KC_WH_U);
} else {
tap_code(KC_WH_D);
}
}
} else {
if (get_mods() & MOD_BIT(KC_RSFT)) {
// ZOOM
uint8_t mod_state = get_mods();
del_mods(MOD_MASK_SHIFT);
if (clockwise) {
tap_code16(LGUI(KC_PPLS));
} else {
tap_code16(LGUI(KC_PMNS));
}
set_mods(mod_state);
} else if (get_mods() & MOD_BIT(KC_LSFT)) {
// BRIGHTNESS
uint8_t mod_state = get_mods();
del_mods(MOD_MASK_SHIFT);
if (clockwise) {
tap_code16(KC_PAUSE);
} else {
tap_code16(KC_SCROLLLOCK);
}
set_mods(mod_state);
} else {
// VOLUME
if (clockwise) {
tap_code(KC__VOLUP);
} else {
tap_code(KC__VOLDOWN);
}
}
}
return true;
}

19
keyboards/planck/keymaps/inkwell/readme.md Normal file
View File

@@ -0,0 +1,19 @@
# The Inkwell Planck Layout
*/
Plank keymap with Base, Lower, Raise, and Adjust layers, and 1 encoder.
Features:
- Number Pad
- Symbol Pad
- Function Pad
- Programming utilities: ()[]{}<>
- Mouse Control
- Encoder:
- Volume (default turn)
- Brightness (shift+turn)
- Scroll Y(RSE+turn)
- Scroll X (RSE+shift+turn)
- Zoom (push+turn)
- Play/Pause (double click)
/*

3
keyboards/planck/keymaps/inkwell/rules.mk Normal file
View File

@@ -0,0 +1,3 @@
SRC += muse.c
ENCODER_ENABLE = yes
EXTRAKEY_ENABLE = yes

34
keyboards/planck/keymaps/jimmysjolund/keymap.c
View File

@@ -53,23 +53,23 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | Brite| Ctrl | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
/* Qwerty - jimmysjolund 2021-09-22
/* Qwerty - jimmysjolund 2022-02-06
* ,-----------------------------------------------------------------------------------.
* | Esc | Q | W | E | R | T | Y | U | I | O | P | Bksp |
* | ` | Q | W | E | R | T | Y | U | I | O | P | Del |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Tab | A | S | D | F | G | H | J | K | L | ; | " |
* |Raise | A | S | D | F | G | H | J | K | L | ; | " |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | N | M | , | . | / |Shift |
* |Lower | Z | X | C | V | B | N | M | , | . | / |Shift |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Del | Ctrl | GUI | Alt |Lower |Raise |Enter |Space |AltGr | Down | Up |Enter |
* | Esc | Tab | GUI |Shift | Bksp | Ctrl |Enter |Space |AltGr | Alt | Down | Up |
* `-----------------------------------------------------------------------------------'
*/
[_QWERTY] = LAYOUT_planck_grid(
KC_ESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
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_DEL, KC_LCTL, KC_LGUI, KC_LALT, LOWER, RAISE, KC_ENT, KC_SPC, KC_ALGR, KC_DOWN, KC_UP, KC_ENT
KC_GRV, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_DEL,
RAISE, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
LOWER, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT,
KC_ESC, KC_TAB, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_ENT, KC_SPC, KC_ALGR, KC_LALT, KC_DOWN, KC_UP
),
/* Colemak Original
@@ -85,20 +85,20 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
*/
/* Colemak jimmysjolund
* ,-----------------------------------------------------------------------------------.
* | Esc | Q | W | F | P | G | J | L | U | Y | ; | Bksp |
* | ` | Q | W | F | P | G | J | L | U | Y | ; | Del |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Tab | A | R | S | T | D | H | N | E | I | O | " |
* |Raise | A | R | S | T | D | H | N | E | I | O | " |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | K | M | , | . | / |Shift |
* |Lower | Z | X | C | V | B | K | M | , | . | / |Shift |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Del | Ctrl | GUI | Alt |Lower |Raise |Enter |Space |AltGr | Down | Up |Enter |
* | Esc | Tab | GUI |Shift | Bksp | Ctrl |Enter |Space |AltGr | Alt | Down | Up |
* `-----------------------------------------------------------------------------------'
*/
[_COLEMAK] = LAYOUT_planck_grid(
KC_ESC, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC,
KC_TAB, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT,
KC_DEL, KC_LCTL, KC_LGUI, KC_LALT, LOWER, RAISE, KC_ENT, KC_SPC, KC_ALGR, KC_DOWN, KC_UP, KC_ENT
KC_GRV, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_DEL,
RAISE, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT,
LOWER, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT,
KC_ESC, KC_TAB, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_ENT, KC_SPC, KC_ALGR, KC_LALT, KC_DOWN, KC_UP
),
/* Dvorak

59
keyboards/planck/keymaps/masoncowen/keymap.c Normal file
View File

@@ -0,0 +1,59 @@
/* Copyright 2021 masoncowen
*
* 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
enum planck_layers {
_ZWFP,
_NUMNAV
};
enum planck_keycodes {
ZWFP = SAFE_RANGE,
NUMNAV
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_ZWFP] = LAYOUT_planck_grid(
KC_Z , KC_W , KC_F , KC_P , KC_Q , KC_NO , KC_NO , KC_J , KC_L , KC_U , KC_Y , OSL(_NUMNAV) ,
KC_A , KC_R , KC_S , KC_T , KC_G , KC_NO , KC_NO , KC_M , KC_N , KC_E , KC_I , KC_O ,
KC_X , KC_V , KC_C , KC_D , KC_B , KC_NO , KC_NO , KC_K , KC_H , KC_DOT , KC_COMM , KC_SCLN ,
KC_NO , KC_NO , KC_ESC , KC_SPC , OSM(MOD_LCTL) , KC_NO , KC_NO , KC_BSPC , OSM(MOD_LSFT) , OSM(MOD_LALT) , KC_NO , KC_NO
),
//TRANSPARENT keys are to be decided on
[_NUMNAV] = LAYOUT_planck_grid(
KC_PPLS , KC_4 , KC_5 , KC_6 , KC_PAST , KC_NO , KC_NO , KC_BSLS , KC_HOME , KC_PGDN , KC_PGUP , KC_END ,
KC_0 , KC_1 , KC_2 , KC_3 , KC_PENT , KC_NO , KC_NO , KC_NUHS , KC_LEFT , KC_DOWN , KC_UP , KC_RIGHT ,
KC_PMNS , KC_7 , KC_8 , KC_9 , KC_PSLS , KC_NO , KC_NO , KC_QUOT , , _______ , _______ , _______ ,
KC_NO , KC_NO , _______ , _______ , _______ , KC_NO , KC_NO , _______ , _______ , _______ , KC_NO , KC_NO
)
};
const key_override_t delete_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_BSPC, KC_DEL);
const key_override_t enter_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_ESC, KC_ENTER);
const key_override_t tab_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_SPC, KC_TAB);
const key_override_t **key_overrides = (const key_override_t *[]){
&delete_key_override,
&enter_key_override,
&tab_key_override,
NULL
};

46
keyboards/planck/keymaps/masoncowen/readme.md Normal file
View File

@@ -0,0 +1,46 @@
# ZWFP Layout Notes
## About
ZWFP is a layout largely based on Colemak Mod-DH.
The layout rotates the QZXVB keys for the following reasons:
* XCV are brought together.
* One design goal of colemak was to keep ZXCV close together as they are commonly uses control shortcuts.
* Mod-dh moved D to where the V key was as that position was too ergonomic for an infrequent letter like V.
* XCV benefit more from being together are Cut-Copy-Paste are more related than Undo (which Z commonly represents).
* B is returned to its QWERTY position.
* This was an unintentional benefit.
* The original rotation of QZXV moved Q to a better position than B despite being was less frequent.
* This is based off the grid on [the colemak mod-dh page](https://colemakmods.github.io/mod-dh/model.html).
* This needs more testing, and may be reverted as despite the above mentioned grid, the current Q position feels easier than the current B position.
* Based off [the layout analyser](https://colemakmods.github.io/mod-dh/analyze.html) its slightly better.
* I like being different.
## Todo
* Work out punctuation locations.
* Figure out what the thumb cluster is doing.
* I've somewhat settled on left home-row (centre) thumb key is space and right is shift OSL.
* Maybe a deadkey instead of using shift-/alt- key overrides?
* [Repeat key](https://www.jonashietala.se/blog/2021/09/05/t-34-0/)
* Move Home, End, PgDn and PgUp to a kc/ko/dk with the arrow keys.
### Keys still to add
* A reset key, cba with finding small pokey things to use at the back.
* Shifted numbers \(not including $^\*\)
* Dedicated Pipe |
* Dedicated Underscore \(\_\)
* Backslash \(\\\) and shifted \(Don't forget to use NOUS\)
* Square brackets \(\[ \]\) and shifted
* Dedicated question mark
* Backtick (`) and shifted
* Function keys 1-12
#### Obscure keys to add just for completeness
* Normal Minus and Equals \(Don't know if they are needed or not \)
* Function keys 13-24
* Capslock \(Not sure if multi-tapping OSL actually counts as a caps lock for shift\)
* Numlock, Scrolllock and the Locking lock keys
* Keypad characters
* Command Keys in general
* International Keys
* Right Modifiers
* Windows keys for either side

1
keyboards/planck/keymaps/masoncowen/rules.mk Normal file
View File

@@ -0,0 +1 @@
KEY_OVERRIDE_ENABLE = yes

2
keyboards/planck/keymaps/oryx/keymap.c
View File

@@ -91,7 +91,7 @@ void set_layer_color(int layer) {
}
void rgb_matrix_indicators_user(void) {
if (g_suspend_state || keyboard_config.disable_layer_led) {
if (keyboard_config.disable_layer_led) {
return;
}
switch (biton32(layer_state)) {

2
keyboards/planck/keymaps/oryx/rules.mk
View File

@@ -3,5 +3,7 @@
CONSOLE_ENABLE = no
COMMAND_ENABLE = no
MOUSEKEY_ENABLE = no
RGBLIGHT_ENABLE = no
RGB_MATRIX_ENABLE = yes
WEBUSB_ENABLE = yes
ORYX_ENABLE = yes

12
keyboards/planck/keymaps/thermal_printer/config.h
View File

@@ -1,9 +1,4 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
#include "../../config.h"
#define SERIAL_UART_BAUD 19200
#pragma once
/*
* MIDI options
@@ -21,8 +16,3 @@
- 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
#endif

20
keyboards/planck/planck.c
View File

@@ -27,3 +27,23 @@ const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_planck_grid(
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
);
#ifdef ENCODER_ENABLE
bool encoder_update_kb(uint8_t index, bool clockwise) {
if (!encoder_update_user(index, clockwise)) { return false; }
if (get_highest_layer(layer_state) > 0) {
if (clockwise) {
tap_code_delay(KC_VOLU, 10);
} else {
tap_code_delay(KC_VOLD, 10);
}
} else {
if (clockwise) {
tap_code(KC_PGDN);
} else {
tap_code(KC_PGUP);
}
}
return true;
}
#endif