drashna/qmk_firmware
1
0
Fork 0
Code Activity Actions

Cleans up quantum/keymap situation, removes extra lufa folders (#416)

Browse source 
* sorts out keycodes

* move midi around

* remove mbed

* replaces keymap with qmk/keymap_common

* fixes keymap.h

* keymap, config, quantum rearrange

* removes unneeded lufa stuff
This commit is contained in:
Jack Humbert 2016-06-18 14:30:24 -04:00 • committed by GitHub
parent 1923cffd41
commit db32864ce7
5186 changed files with 2207 additions and 2306512 deletions
Download patch file Download diff file Expand all files Collapse all files

2
quantum/audio/audio.c
View file

@ -6,7 +6,7 @@
#include <avr/io.h>
#include "print.h"
#include "audio.h"
#include "keymap_common.h"
#include "keymap.h"
#include "eeconfig.h"

2
quantum/audio/audio_pwm.c
View file

@ -6,7 +6,7 @@
#include <avr/io.h>
#include "print.h"
#include "audio.h"
#include "keymap_common.h"
#include "keymap.h"
#include "eeconfig.h"

74
quantum/keycode_config.c Normal file
View file

@ -0,0 +1,74 @@
#include "keycode_config.h"
extern keymap_config_t keymap_config;
uint16_t keycode_config(uint16_t keycode) {
switch (keycode) {
case KC_CAPSLOCK:
case KC_LOCKING_CAPS:
if (keymap_config.swap_control_capslock || keymap_config.capslock_to_control) {
return KC_LCTL;
}
return keycode;
case KC_LCTL:
if (keymap_config.swap_control_capslock) {
return KC_CAPSLOCK;
}
return KC_LCTL;
case KC_LALT:
if (keymap_config.swap_lalt_lgui) {
if (keymap_config.no_gui) {
return KC_NO;
}
return KC_LGUI;
}
return KC_LALT;
case KC_LGUI:
if (keymap_config.swap_lalt_lgui) {
return KC_LALT;
}
if (keymap_config.no_gui) {
return KC_NO;
}
return KC_LGUI;
case KC_RALT:
if (keymap_config.swap_ralt_rgui) {
if (keymap_config.no_gui) {
return KC_NO;
}
return KC_RGUI;
}
return KC_RALT;
case KC_RGUI:
if (keymap_config.swap_ralt_rgui) {
return KC_RALT;
}
if (keymap_config.no_gui) {
return KC_NO;
}
return KC_RGUI;
case KC_GRAVE:
if (keymap_config.swap_grave_esc) {
return KC_ESC;
}
return KC_GRAVE;
case KC_ESC:
if (keymap_config.swap_grave_esc) {
return KC_GRAVE;
}
return KC_ESC;
case KC_BSLASH:
if (keymap_config.swap_backslash_backspace) {
return KC_BSPACE;
}
return KC_BSLASH;
case KC_BSPACE:
if (keymap_config.swap_backslash_backspace) {
return KC_BSLASH;
}
return KC_BSPACE;
default:
return keycode;
}
}

21
quantum/keycode_config.h Normal file
View file

@ -0,0 +1,21 @@
#include "eeconfig.h"
#include "keycode.h"
uint16_t keycode_config(uint16_t keycode);
/* NOTE: Not portable. Bit field order depends on implementation */
typedef union {
uint16_t raw;
struct {
bool swap_control_capslock:1;
bool capslock_to_control:1;
bool swap_lalt_lgui:1;
bool swap_ralt_rgui:1;
bool no_gui:1;
bool swap_grave_esc:1;
bool swap_backslash_backspace:1;
bool nkro:1;
};
} keymap_config_t;
keymap_config_t keymap_config;

163
quantum/keymap.c Normal file
View file

@ -0,0 +1,163 @@
/*
Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
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 "keymap.h"
#include "report.h"
#include "keycode.h"
#include "action_layer.h"
#include <util/delay.h>
#include "action.h"
#include "action_macro.h"
#include "debug.h"
#include "backlight.h"
#include "quantum.h"
#ifdef MIDI_ENABLE
#include "keymap_midi.h"
#endif
extern keymap_config_t keymap_config;
#include <stdio.h>
#include <inttypes.h>
/* converts key to action */
action_t action_for_key(uint8_t layer, keypos_t key)
{
// 16bit keycodes - important
uint16_t keycode = keymap_key_to_keycode(layer, key);
// keycode remapping
keycode = keycode_config(keycode);
action_t action;
uint8_t action_layer, when, mod;
switch (keycode) {
case KC_FN0 ... KC_FN31:
action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
break;
case KC_A ... KC_EXSEL:
case KC_LCTRL ... KC_RGUI:
action.code = ACTION_KEY(keycode);
break;
case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE:
action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode));
break;
case KC_AUDIO_MUTE ... KC_WWW_FAVORITES:
action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode));
break;
case KC_MS_UP ... KC_MS_ACCEL2:
action.code = ACTION_MOUSEKEY(keycode);
break;
case KC_TRNS:
action.code = ACTION_TRANSPARENT;
break;
case QK_MODS ... QK_MODS_MAX: ;
// Has a modifier
// Split it up
action.code = ACTION_MODS_KEY(keycode >> 8, keycode & 0xFF); // adds modifier to key
break;
case QK_FUNCTION ... QK_FUNCTION_MAX: ;
// Is a shortcut for function action_layer, pull last 12bits
// This means we have 4,096 FN macros at our disposal
action.code = pgm_read_word(&fn_actions[(int)keycode & 0xFFF]);
break;
case QK_MACRO ... QK_MACRO_MAX:
action.code = ACTION_MACRO(keycode & 0xFF);
break;
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
action.code = ACTION_LAYER_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF);
break;
case QK_TO ... QK_TO_MAX: ;
// Layer set "GOTO"
when = (keycode >> 0x4) & 0x3;
action_layer = keycode & 0xF;
action.code = ACTION_LAYER_SET(action_layer, when);
break;
case QK_MOMENTARY ... QK_MOMENTARY_MAX: ;
// Momentary action_layer
action_layer = keycode & 0xFF;
action.code = ACTION_LAYER_MOMENTARY(action_layer);
break;
case QK_DEF_LAYER ... QK_DEF_LAYER_MAX: ;
// Set default action_layer
action_layer = keycode & 0xFF;
action.code = ACTION_DEFAULT_LAYER_SET(action_layer);
break;
case QK_TOGGLE_LAYER ... QK_TOGGLE_LAYER_MAX: ;
// Set toggle
action_layer = keycode & 0xFF;
action.code = ACTION_LAYER_TOGGLE(action_layer);
break;
case QK_ONE_SHOT_LAYER ... QK_ONE_SHOT_LAYER_MAX: ;
// OSL(action_layer) - One-shot action_layer
action_layer = keycode & 0xFF;
action.code = ACTION_LAYER_ONESHOT(action_layer);
break;
case QK_ONE_SHOT_MOD ... QK_ONE_SHOT_MOD_MAX: ;
// OSM(mod) - One-shot mod
mod = keycode & 0xFF;
action.code = ACTION_MODS_ONESHOT(mod);
break;
case QK_MOD_TAP ... QK_MOD_TAP_MAX:
action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF);
break;
#ifdef BACKLIGHT_ENABLE
case BL_0 ... BL_15:
action.code = ACTION_BACKLIGHT_LEVEL(keycode - BL_0);
break;
case BL_DEC:
action.code = ACTION_BACKLIGHT_DECREASE();
break;
case BL_INC:
action.code = ACTION_BACKLIGHT_INCREASE();
break;
case BL_TOGG:
action.code = ACTION_BACKLIGHT_TOGGLE();
break;
case BL_STEP:
action.code = ACTION_BACKLIGHT_STEP();
break;
#endif
default:
action.code = ACTION_NO;
break;
}
return action;
}
/* Macro */
__attribute__ ((weak))
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
return MACRO_NONE;
}
/* Function */
__attribute__ ((weak))
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
}
/* translates key to keycode */
uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
// Read entire word (16bits)
return pgm_read_word(&keymaps[(layer)][(key.row)][(key.col)]);
}

315
quantum/keymap.h Normal file
View file

@ -0,0 +1,315 @@
/*
Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
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/>.
*/
#ifndef KEYMAP_H
#define KEYMAP_H
#include <stdint.h>
#include <stdbool.h>
#include "action.h"
#include <avr/pgmspace.h>
#include "keycode.h"
#include "action_macro.h"
#include "report.h"
#include "host.h"
// #include "print.h"
#include "debug.h"
#include "keycode_config.h"
/* translates key to keycode */
uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key);
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint16_t keycode);
extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
extern const uint16_t fn_actions[];
enum quantum_keycodes {
// Ranges used in shortucuts - not to be used directly
QK_TMK = 0x0000,
QK_TMK_MAX = 0x00FF,
QK_MODS = 0x0100,
QK_LCTL = 0x0100,
QK_LSFT = 0x0200,
QK_LALT = 0x0400,
QK_LGUI = 0x0800,
QK_RCTL = 0x1100,
QK_RSFT = 0x1200,
QK_RALT = 0x1400,
QK_RGUI = 0x1800,
QK_MODS_MAX = 0x1FFF,
QK_FUNCTION = 0x2000,
QK_FUNCTION_MAX = 0x2FFF,
QK_MACRO = 0x3000,
QK_MACRO_MAX = 0x3FFF,
QK_LAYER_TAP = 0x4000,
QK_LAYER_TAP_MAX = 0x4FFF,
QK_TO = 0x5000,
QK_TO_MAX = 0x50FF,
QK_MOMENTARY = 0x5100,
QK_MOMENTARY_MAX = 0x51FF,
QK_DEF_LAYER = 0x5200,
QK_DEF_LAYER_MAX = 0x52FF,
QK_TOGGLE_LAYER = 0x5300,
QK_TOGGLE_LAYER_MAX = 0x53FF,
QK_ONE_SHOT_LAYER = 0x5400,
QK_ONE_SHOT_LAYER_MAX = 0x54FF,
QK_ONE_SHOT_MOD = 0x5500,
QK_ONE_SHOT_MOD_MAX = 0x55FF,
#ifndef DISABLE_CHORDING
QK_CHORDING = 0x5600,
QK_CHORDING_MAX = 0x56FF,
#endif
QK_MOD_TAP = 0x6000,
QK_MOD_TAP_MAX = 0x6FFF,
#ifdef UNICODE_ENABLE
QK_UNICODE = 0x8000,
QK_UNICODE_MAX = 0xFFFF,
#endif
// Loose keycodes - to be used directly
RESET = 0x7000,
DEBUG,
MAGIC_SWAP_CONTROL_CAPSLOCK,
MAGIC_CAPSLOCK_TO_CONTROL,
MAGIC_SWAP_LALT_LGUI,
MAGIC_SWAP_RALT_RGUI,
MAGIC_NO_GUI,
MAGIC_SWAP_GRAVE_ESC,
MAGIC_SWAP_BACKSLASH_BACKSPACE,
MAGIC_HOST_NKRO,
MAGIC_SWAP_ALT_GUI,
MAGIC_UNSWAP_CONTROL_CAPSLOCK,
MAGIC_UNCAPSLOCK_TO_CONTROL,
MAGIC_UNSWAP_LALT_LGUI,
MAGIC_UNSWAP_RALT_RGUI,
MAGIC_UNNO_GUI,
MAGIC_UNSWAP_GRAVE_ESC,
MAGIC_UNSWAP_BACKSLASH_BACKSPACE,
MAGIC_UNHOST_NKRO,
MAGIC_UNSWAP_ALT_GUI,
// Leader key
#ifndef DISABLE_LEADER
KC_LEAD,
#endif
// Audio on/off/toggle
AU_ON,
AU_OFF,
AU_TOG,
// Music mode on/off/toggle
MU_ON,
MU_OFF,
MU_TOG,
// Music voice iterate
MUV_IN,
MUV_DE,
// Midi mode on/off
MI_ON,
MI_OFF,
// Backlight functionality
BL_0,
BL_1,
BL_2,
BL_3,
BL_4,
BL_5,
BL_6,
BL_7,
BL_8,
BL_9,
BL_10,
BL_11,
BL_12,
BL_13,
BL_14,
BL_15,
BL_DEC,
BL_INC,
BL_TOGG,
BL_STEP,
// Left shift, open paren
KC_LSPO,
// Right shift, close paren
KC_RSPC,
};
// Ability to use mods in layouts
#define LCTL(kc) (kc | QK_LCTL)
#define LSFT(kc) (kc | QK_LSFT)
#define LALT(kc) (kc | QK_LALT)
#define LGUI(kc) (kc | QK_LGUI)
#define RCTL(kc) (kc | QK_RCTL)
#define RSFT(kc) (kc | QK_RSFT)
#define RALT(kc) (kc | QK_RALT)
#define RGUI(kc) (kc | QK_RGUI)
#define HYPR(kc) (kc | QK_LCTL | QK_LSFT | QK_LALT | QK_LGUI)
#define MEH(kc) (kc | QK_LCTL | QK_LSFT | QK_LALT)
#define LCAG(kc) (kc | QK_LCTL | QK_LALT | QK_LGUI)
#define MOD_HYPR 0xf
#define MOD_MEH 0x7
// Aliases for shifted symbols
// Each key has a 4-letter code, and some have longer aliases too.
// While the long aliases are descriptive, the 4-letter codes
// make for nicer grid layouts (everything lines up), and are
// the preferred style for Quantum.
#define KC_TILD LSFT(KC_GRV) // ~
#define KC_TILDE KC_TILD
#define KC_EXLM LSFT(KC_1) // !
#define KC_EXCLAIM KC_EXLM
#define KC_AT LSFT(KC_2) // @
#define KC_HASH LSFT(KC_3) // #
#define KC_DLR LSFT(KC_4) // $
#define KC_DOLLAR KC_DLR
#define KC_PERC LSFT(KC_5) // %
#define KC_PERCENT KC_PERC
#define KC_CIRC LSFT(KC_6) // ^
#define KC_CIRCUMFLEX KC_CIRC
#define KC_AMPR LSFT(KC_7) // &
#define KC_AMPERSAND KC_AMPR
#define KC_ASTR LSFT(KC_8) // *
#define KC_ASTERISK KC_ASTR
#define KC_LPRN LSFT(KC_9) // (
#define KC_LEFT_PAREN KC_LPRN
#define KC_RPRN LSFT(KC_0) // )
#define KC_RIGHT_PAREN KC_RPRN
#define KC_UNDS LSFT(KC_MINS) // _
#define KC_UNDERSCORE KC_UNDS
#define KC_PLUS LSFT(KC_EQL) // +
#define KC_LCBR LSFT(KC_LBRC) // {
#define KC_LEFT_CURLY_BRACE KC_LCBR
#define KC_RCBR LSFT(KC_RBRC) // }
#define KC_RIGHT_CURLY_BRACE KC_RCBR
#define KC_LABK LSFT(KC_COMM) // <
#define KC_LEFT_ANGLE_BRACKET KC_LABK
#define KC_RABK LSFT(KC_DOT) // >
#define KC_RIGHT_ANGLE_BRACKET KC_RABK
#define KC_COLN LSFT(KC_SCLN) // :
#define KC_COLON KC_COLN
#define KC_PIPE LSFT(KC_BSLS) // |
#define KC_LT LSFT(KC_COMM) // <
#define KC_GT LSFT(KC_DOT) // >
#define KC_QUES LSFT(KC_SLSH) // ?
#define KC_QUESTION KC_QUES
#define KC_DQT LSFT(KC_QUOT) // "
#define KC_DOUBLE_QUOTE KC_DQT
#define KC_DQUO KC_DQT
#define KC_DELT KC_DELETE // Del key (four letter code)
// Alias for function layers than expand past FN31
#define FUNC(kc) (kc | QK_FUNCTION)
// Aliases
#define S(kc) LSFT(kc)
#define F(kc) FUNC(kc)
#define M(kc) (kc | QK_MACRO)
#define MACRODOWN(...) (record->event.pressed ? MACRO(__VA_ARGS__) : MACRO_NONE)
// L-ayer, T-ap - 256 keycode max, 16 layer max
#define LT(layer, kc) (kc | QK_LAYER_TAP | ((layer & 0xF) << 8))
#define AG_SWAP MAGIC_SWAP_ALT_GUI
#define AG_NORM MAGIC_UNSWAP_ALT_GUI
#define BL_ON BL_9
#define BL_OFF BL_0
// GOTO layer - 16 layers max
// when:
// ON_PRESS = 1
// ON_RELEASE = 2
// Unless you have a good reason not to do so, prefer ON_PRESS (1) as your default.
#define TO(layer, when) (layer | QK_TO | (when << 0x4))
// Momentary switch layer - 256 layer max
#define MO(layer) (layer | QK_MOMENTARY)
// Set default layer - 256 layer max
#define DF(layer) (layer | QK_DEF_LAYER)
// Toggle to layer - 256 layer max
#define TG(layer) (layer | QK_TOGGLE_LAYER)
// One-shot layer - 256 layer max
#define OSL(layer) (layer | QK_ONE_SHOT_LAYER)
// One-shot mod
#define OSM(layer) (layer | QK_ONE_SHOT_MOD)
// M-od, T-ap - 256 keycode max
#define MT(mod, kc) (kc | QK_MOD_TAP | ((mod & 0xF) << 8))
#define CTL_T(kc) MT(MOD_LCTL, kc)
#define SFT_T(kc) MT(MOD_LSFT, kc)
#define ALT_T(kc) MT(MOD_LALT, kc)
#define GUI_T(kc) MT(MOD_LGUI, kc)
#define C_S_T(kc) MT(MOD_LCTL | MOD_LSFT, kc) // Control + Shift e.g. for gnome-terminal
#define MEH_T(kc) MT(MOD_LCTL | MOD_LSFT | MOD_LALT, kc) // Meh is a less hyper version of the Hyper key -- doesn't include Win or Cmd, so just alt+shift+ctrl
#define LCAG_T(kc) MT(MOD_LCTL | MOD_LALT | MOD_LGUI, kc) // Left control alt and gui
#define ALL_T(kc) MT(MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI, kc) // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/
// Dedicated keycode versions for Hyper and Meh, if you want to use them as standalone keys rather than mod-tap
#define KC_HYPR HYPR(KC_NO)
#define KC_MEH MEH(KC_NO)
#ifdef UNICODE_ENABLE
// For sending unicode codes.
// You may not send codes over 7FFF -- this supports most of UTF8.
// To have a key that sends out Œ, go UC(0x0152)
#define UNICODE(n) (n | QK_UNICODE)
#define UC(n) UNICODE(n)
#endif
#endif

323
quantum/keymap_common.c
View file

@ -1,323 +0,0 @@
/*
Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
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 "keymap_common.h"
#include "report.h"
#include "keycode.h"
#include "action_layer.h"
#include <util/delay.h>
#include "action.h"
#include "action_macro.h"
#include "debug.h"
#include "backlight.h"
#include "bootloader.h"
#include "eeconfig.h"
#include "quantum.h"
#ifdef MIDI_ENABLE
#include "keymap_midi.h"
#endif
extern keymap_config_t keymap_config;
#include <stdio.h>
#include <inttypes.h>
#ifdef AUDIO_ENABLE
#include "audio.h"
#endif /* AUDIO_ENABLE */
static action_t keycode_to_action(uint16_t keycode);
/* converts key to action */
action_t action_for_key(uint8_t layer, keypos_t key)
{
// 16bit keycodes - important
uint16_t keycode = keymap_key_to_keycode(layer, key);
switch (keycode) {
case KC_FN0 ... KC_FN31:
return keymap_fn_to_action(keycode);
case KC_CAPSLOCK:
case KC_LOCKING_CAPS:
if (keymap_config.swap_control_capslock || keymap_config.capslock_to_control) {
return keycode_to_action(KC_LCTL);
}
return keycode_to_action(keycode);
case KC_LCTL:
if (keymap_config.swap_control_capslock) {
return keycode_to_action(KC_CAPSLOCK);
}
return keycode_to_action(KC_LCTL);
case KC_LALT:
if (keymap_config.swap_lalt_lgui) {
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_LGUI);
}
return keycode_to_action(KC_LALT);
case KC_LGUI:
if (keymap_config.swap_lalt_lgui) {
return keycode_to_action(KC_LALT);
}
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_LGUI);
case KC_RALT:
if (keymap_config.swap_ralt_rgui) {
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_RGUI);
}
return keycode_to_action(KC_RALT);
case KC_RGUI:
if (keymap_config.swap_ralt_rgui) {
return keycode_to_action(KC_RALT);
}
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_RGUI);
case KC_GRAVE:
if (keymap_config.swap_grave_esc) {
return keycode_to_action(KC_ESC);
}
return keycode_to_action(KC_GRAVE);
case KC_ESC:
if (keymap_config.swap_grave_esc) {
return keycode_to_action(KC_GRAVE);
}
return keycode_to_action(KC_ESC);
case KC_BSLASH:
if (keymap_config.swap_backslash_backspace) {
return keycode_to_action(KC_BSPACE);
}
return keycode_to_action(KC_BSLASH);
case KC_BSPACE:
if (keymap_config.swap_backslash_backspace) {
return keycode_to_action(KC_BSLASH);
}
return keycode_to_action(KC_BSPACE);
default:
return keycode_to_action(keycode);
}
}
/* Macro */
__attribute__ ((weak))
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
return MACRO_NONE;
}
/* Function */
__attribute__ ((weak))
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
}
/* translates keycode to action */
static action_t keycode_to_action(uint16_t keycode)
{
action_t action;
switch (keycode) {
case KC_A ... KC_EXSEL:
case KC_LCTRL ... KC_RGUI:
action.code = ACTION_KEY(keycode);
break;
case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE:
action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode));
break;
case KC_AUDIO_MUTE ... KC_WWW_FAVORITES:
action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode));
break;
case KC_MS_UP ... KC_MS_ACCEL2:
action.code = ACTION_MOUSEKEY(keycode);
break;
case KC_TRNS:
action.code = ACTION_TRANSPARENT;
break;
case LCTL(0) ... 0x1FFF: ;
// Has a modifier
// Split it up
action.code = ACTION_MODS_KEY(keycode >> 8, keycode & 0xFF); // adds modifier to key
break;
case FUNC(0) ... FUNC(0xFFF): ;
// Is a shortcut for function layer, pull last 12bits
// This means we have 4,096 FN macros at our disposal
return keymap_func_to_action(keycode & 0xFFF);
break;
case M(0) ... M(0xFF):
action.code = ACTION_MACRO(keycode & 0xFF);
break;
case LT(0, 0) ... LT(0xFF, 0xF):
action.code = ACTION_LAYER_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF);
break;
#ifdef BACKLIGHT_ENABLE
case BL_0 ... BL_15:
action.code = ACTION_BACKLIGHT_LEVEL(keycode & 0x000F);
break;
case BL_DEC:
action.code = ACTION_BACKLIGHT_DECREASE();
break;
case BL_INC:
action.code = ACTION_BACKLIGHT_INCREASE();
break;
case BL_TOGG:
action.code = ACTION_BACKLIGHT_TOGGLE();
break;
case BL_STEP:
action.code = ACTION_BACKLIGHT_STEP();
break;
#endif
case RESET: ; // RESET is 0x5000, which is why this is here
clear_keyboard();
#ifdef AUDIO_ENABLE
stop_all_notes();
shutdown_user();
#endif
_delay_ms(250);
#ifdef ATREUS_ASTAR
*(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
#endif
bootloader_jump();
break;
case DEBUG: ; // DEBUG is 0x5001
print("\nDEBUG: enabled.\n");
debug_enable = true;
break;
case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_UNSWAP_ALT_GUI:
// MAGIC actions (BOOTMAGIC without the boot)
if (!eeconfig_is_enabled()) {
eeconfig_init();
}
/* keymap config */
keymap_config.raw = eeconfig_read_keymap();
if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) {
keymap_config.swap_control_capslock = 1;
} else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) {
keymap_config.capslock_to_control = 1;
} else if (keycode == MAGIC_SWAP_LALT_LGUI) {
keymap_config.swap_lalt_lgui = 1;
} else if (keycode == MAGIC_SWAP_RALT_RGUI) {
keymap_config.swap_ralt_rgui = 1;
} else if (keycode == MAGIC_NO_GUI) {
keymap_config.no_gui = 1;
} else if (keycode == MAGIC_SWAP_GRAVE_ESC) {
keymap_config.swap_grave_esc = 1;
} else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) {
keymap_config.swap_backslash_backspace = 1;
} else if (keycode == MAGIC_HOST_NKRO) {
keymap_config.nkro = 1;
} else if (keycode == MAGIC_SWAP_ALT_GUI) {
keymap_config.swap_lalt_lgui = 1;
keymap_config.swap_ralt_rgui = 1;
}
/* UNs */
else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) {
keymap_config.swap_control_capslock = 0;
} else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) {
keymap_config.capslock_to_control = 0;
} else if (keycode == MAGIC_UNSWAP_LALT_LGUI) {
keymap_config.swap_lalt_lgui = 0;
} else if (keycode == MAGIC_UNSWAP_RALT_RGUI) {
keymap_config.swap_ralt_rgui = 0;
} else if (keycode == MAGIC_UNNO_GUI) {
keymap_config.no_gui = 0;
} else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) {
keymap_config.swap_grave_esc = 0;
} else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) {
keymap_config.swap_backslash_backspace = 0;
} else if (keycode == MAGIC_UNHOST_NKRO) {
keymap_config.nkro = 0;
} else if (keycode == MAGIC_UNSWAP_ALT_GUI) {
keymap_config.swap_lalt_lgui = 0;
keymap_config.swap_ralt_rgui = 0;
}
eeconfig_update_keymap(keymap_config.raw);
break;
case TO(0, 1) ... OSM(0xFF): ;
// Layer movement shortcuts
// See .h to see constraints/usage
int type = (keycode >> 0x8) & 0xF;
if (type == 0x1) {
// Layer set "GOTO"
int when = (keycode >> 0x4) & 0x3;
int layer = keycode & 0xF;
action.code = ACTION_LAYER_SET(layer, when);
} else if (type == 0x2) {
// Momentary layer
int layer = keycode & 0xFF;
action.code = ACTION_LAYER_MOMENTARY(layer);
} else if (type == 0x3) {
// Set default layer
int layer = keycode & 0xFF;
action.code = ACTION_DEFAULT_LAYER_SET(layer);
} else if (type == 0x4) {
// Set default layer
int layer = keycode & 0xFF;
action.code = ACTION_LAYER_TOGGLE(layer);
} else if (type == 0x5) {
// OSL(layer) - One-shot layer
int layer = keycode & 0xFF;
action.code = ACTION_LAYER_ONESHOT(layer);
} else if (type == 0x6) {
// OSM(mod) - One-shot mod
int mod = keycode & 0xFF;
action.code = ACTION_MODS_ONESHOT(mod);
}
break;
case MT(0, 0) ... MT(0xF, 0xFF):
action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF);
break;
default:
action.code = ACTION_NO;
break;
}
return action;
}
/* translates key to keycode */
uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
// Read entire word (16bits)
return pgm_read_word(&keymaps[(layer)][(key.row)][(key.col)]);
}
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint16_t keycode)
{
return (action_t){ .code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]) };
}
action_t keymap_func_to_action(uint16_t keycode)
{
// For FUNC without 8bit limit
return (action_t){ .code = pgm_read_word(&fn_actions[(int)keycode]) };
}
void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
layer_on(layer3);
} else {
layer_off(layer3);
}
}

292
quantum/keymap_common.h
View file

@ -1,292 +0,0 @@
/*
Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
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/>.
*/
#ifndef KEYMAP_H
#define KEYMAP_H
#include <stdint.h>
#include <stdbool.h>
#include "action.h"
#include <avr/pgmspace.h>
#include "keycode.h"
#include "keymap.h"
#include "action_macro.h"
#include "report.h"
#include "host.h"
// #include "print.h"
#include "debug.h"
/* NOTE: Not portable. Bit field order depends on implementation */
typedef union {
uint16_t raw;
struct {
bool swap_control_capslock:1;
bool capslock_to_control:1;
bool swap_lalt_lgui:1;
bool swap_ralt_rgui:1;
bool no_gui:1;
bool swap_grave_esc:1;
bool swap_backslash_backspace:1;
bool nkro:1;
};
} keymap_config_t;
/* translates key to keycode */
uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key);
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint16_t keycode);
/* translates Fn keycode to action */
action_t keymap_func_to_action(uint16_t keycode);
extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
extern const uint16_t fn_actions[];
// Ability to use mods in layouts
#define LCTL(kc) kc | 0x0100
#define LSFT(kc) kc | 0x0200
#define LALT(kc) kc | 0x0400
#define LGUI(kc) kc | 0x0800
#define HYPR(kc) kc | 0x0F00
#define MEH(kc) kc | 0x0700
#define LCAG(kc) kc | 0x0D00 // Modifier Ctrl Alt and GUI
#define MOD_HYPR 0xf
#define MOD_MEH 0x7
#define RCTL(kc) kc | 0x1100
#define RSFT(kc) kc | 0x1200
#define RALT(kc) kc | 0x1400
#define RGUI(kc) kc | 0x1800
// Aliases for shifted symbols
// Each key has a 4-letter code, and some have longer aliases too.
// While the long aliases are descriptive, the 4-letter codes
// make for nicer grid layouts (everything lines up), and are
// the preferred style for Quantum.
#define KC_TILD LSFT(KC_GRV) // ~
#define KC_TILDE KC_TILD
#define KC_EXLM LSFT(KC_1) // !
#define KC_EXCLAIM KC_EXLM
#define KC_AT LSFT(KC_2) // @
#define KC_HASH LSFT(KC_3) // #
#define KC_DLR LSFT(KC_4) // $
#define KC_DOLLAR KC_DLR
#define KC_PERC LSFT(KC_5) // %
#define KC_PERCENT KC_PERC
#define KC_CIRC LSFT(KC_6) // ^
#define KC_CIRCUMFLEX KC_CIRC
#define KC_AMPR LSFT(KC_7) // &
#define KC_AMPERSAND KC_AMPR
#define KC_ASTR LSFT(KC_8) // *
#define KC_ASTERISK KC_ASTR
#define KC_LPRN LSFT(KC_9) // (
#define KC_LEFT_PAREN KC_LPRN
#define KC_RPRN LSFT(KC_0) // )
#define KC_RIGHT_PAREN KC_RPRN
#define KC_UNDS LSFT(KC_MINS) // _
#define KC_UNDERSCORE KC_UNDS
#define KC_PLUS LSFT(KC_EQL) // +
#define KC_LCBR LSFT(KC_LBRC) // {
#define KC_LEFT_CURLY_BRACE KC_LCBR
#define KC_RCBR LSFT(KC_RBRC) // }
#define KC_RIGHT_CURLY_BRACE KC_RCBR
#define KC_LABK LSFT(KC_COMM) // <
#define KC_LEFT_ANGLE_BRACKET KC_LABK
#define KC_RABK LSFT(KC_DOT) // >
#define KC_RIGHT_ANGLE_BRACKET KC_RABK
#define KC_COLN LSFT(KC_SCLN) // :
#define KC_COLON KC_COLN
#define KC_PIPE LSFT(KC_BSLS) // |
#define KC_LT LSFT(KC_COMM) // <
#define KC_GT LSFT(KC_DOT) // >
#define KC_QUES LSFT(KC_SLSH) // ?
#define KC_QUESTION KC_QUES
#define KC_DQT LSFT(KC_QUOT) // "
#define KC_DOUBLE_QUOTE KC_DQT
#define KC_DQUO KC_DQT
#define KC_DELT KC_DELETE // Del key (four letter code)
// Alias for function layers than expand past FN31
#define FUNC(kc) kc | 0x2000
// Aliases
#define S(kc) LSFT(kc)
#define F(kc) FUNC(kc)
#define M(kc) (kc | 0x3000)
#define MACRODOWN(...) (record->event.pressed ? MACRO(__VA_ARGS__) : MACRO_NONE)
// 0x3100+ is free
// L-ayer, T-ap - 256 keycode max, 16 layer max
#define LT(layer, kc) (kc | 0x4000 | ((layer & 0xF) << 8))
#define RESET 0x5000
#define DEBUG 0x5001
// MAGIC keycodes
#define MAGIC_SWAP_CONTROL_CAPSLOCK 0x5002
#define MAGIC_UNSWAP_CONTROL_CAPSLOCK 0x5003
#define MAGIC_CAPSLOCK_TO_CONTROL 0x5004
#define MAGIC_UNCAPSLOCK_TO_CONTROL 0x5005
#define MAGIC_SWAP_LALT_LGUI 0x5006
#define MAGIC_UNSWAP_LALT_LGUI 0x5007
#define MAGIC_SWAP_RALT_RGUI 0x5008
#define MAGIC_UNSWAP_RALT_RGUI 0x5009
#define MAGIC_NO_GUI 0x500a
#define MAGIC_UNNO_GUI 0x500b
#define MAGIC_SWAP_GRAVE_ESC 0x500c
#define MAGIC_UNSWAP_GRAVE_ESC 0x500d
#define MAGIC_SWAP_BACKSLASH_BACKSPACE 0x500e
#define MAGIC_UNSWAP_BACKSLASH_BACKSPACE 0x500f
#define MAGIC_HOST_NKRO 0x5010
#define MAGIC_UNHOST_NKRO 0x5011
#define MAGIC_SWAP_ALT_GUI 0x5012
#define MAGIC_UNSWAP_ALT_GUI 0x5013
#define AG_SWAP MAGIC_SWAP_ALT_GUI
#define AG_NORM MAGIC_UNSWAP_ALT_GUI
#define KC_LEAD 0x5014
// Audio on/off
#define AU_ON 0x5020
#define AU_OFF 0x5021
#define AU_TOG 0x5022
// Music mode on/off
#define MU_ON 0x5023
#define MU_OFF 0x5024
#define MU_TOG 0x5025
// Music voice iterate
#define MUV_IN 0x5026
#define MUV_DE 0x5027
// Midi mode on/off
#define MI_ON 0x5028
#define MI_OFF 0x5029
// These affect the backlight (if your keyboard has one).
// We don't need to comment them out if your keyboard doesn't have a backlight,
// since they don't take up any space.
#define BL_ON 0x5079
#define BL_OFF 0x5070
#define BL_0 0x5070
#define BL_1 0x5071
#define BL_2 0x5072
#define BL_3 0x5073
#define BL_4 0x5074
#define BL_5 0x5075
#define BL_6 0x5076
#define BL_7 0x5077
#define BL_8 0x5078
#define BL_9 0x5079
#define BL_10 0x507A
#define BL_11 0x507B
#define BL_12 0x507C
#define BL_13 0x507D
#define BL_14 0x507E
#define BL_15 0x507F
#define BL_DEC 0x5080
#define BL_INC 0x5081
#define BL_TOGG 0x5082
#define BL_STEP 0x5083
#define KC_LSPO 0x5084 // Left shift, open parens when tapped
#define KC_RSPC 0x5085 // Right shift, close parens when tapped
// GOTO layer - 16 layers max
// when:
// ON_PRESS = 1
// ON_RELEASE = 2
// Unless you have a good reason not to do so, prefer ON_PRESS (1) as your default.
#define TO(layer, when) (layer | 0x5100 | (when << 0x4))
// Momentary switch layer - 256 layer max
#define MO(layer) (layer | 0x5200)
// Set default layer - 256 layer max
#define DF(layer) (layer | 0x5300)
// Toggle to layer - 256 layer max
#define TG(layer) (layer | 0x5400)
// One-shot layer - 256 layer max
#define OSL(layer) (layer | 0x5500)
// One-shot mod
#define OSM(layer) (layer | 0x5600)
// chording is currently at 0x57xx
// M-od, T-ap - 256 keycode max
#define MT(mod, kc) (kc | 0x7000 | ((mod & 0xF) << 8))
#define CTL_T(kc) MT(0x1, kc)
#define SFT_T(kc) MT(0x2, kc)
#define ALT_T(kc) MT(0x4, kc)
#define GUI_T(kc) MT(0x8, kc)
#define C_S_T(kc) MT(0x3, kc) // Control + Shift e.g. for gnome-terminal
#define MEH_T(kc) MT(0x7, kc) // Meh is a less hyper version of the Hyper key -- doesn't include Win or Cmd, so just alt+shift+ctrl
#define LCAG_T(kc) MT(0xD, kc) // Left control alt and gui
#define ALL_T(kc) MT(0xF, kc) // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/
// Dedicated keycode versions for Hyper and Meh, if you want to use them as standalone keys rather than mod-tap
#define KC_HYPR HYPR(KC_NO)
#define KC_MEH MEH(KC_NO)
#ifdef UNICODE_ENABLE
// For sending unicode codes.
// You may not send codes over 7FFF -- this supports most of UTF8.
// To have a key that sends out Œ, go UC(0x0152)
#define UNICODE(n) (n | 0x8000)
#define UC(n) UNICODE(n)
#endif
// For tri-layer
void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3);
#define IS_LAYER_ON(layer) (layer_state & (1UL << (layer)))
#define IS_LAYER_OFF(layer) (~layer_state & (1UL << (layer)))
#endif

2
quantum/keymap_extras/keymap_bepo.h
View file

@ -2,7 +2,7 @@
#ifndef KEYMAP_BEPO_H
#define KEYMAP_BEPO_H
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#ifndef ALTGR

2
quantum/keymap_extras/keymap_colemak.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_COLEMAK_H
#define KEYMAP_COLEMAK_H
#include "keymap_common.h"
#include "keymap.h"
// For software implementation of colemak
#define CM_Q KC_Q
#define CM_W KC_W

2
quantum/keymap_extras/keymap_dvorak.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_DVORAK_H
#define KEYMAP_DVORAK_H
#include "keymap_common.h"
#include "keymap.h"
// Normal characters
#define DV_GRV KC_GRV

2
quantum/keymap_extras/keymap_fr_ch.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_FR_CH
#define KEYMAP_FR_CH
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#define ALGR(kc) kc | 0x1400

2
quantum/keymap_extras/keymap_french.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_FRENCH_H
#define KEYMAP_FRENCH_H
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#define ALGR(kc) kc | 0x1400

2
quantum/keymap_extras/keymap_french_osx.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_FRENCH_OSX_H
#define KEYMAP_FRENCH_OSX_H
#include "keymap_common.h"
#include "keymap.h"
// Normal characters
#define FR_AT KC_GRV

2
quantum/keymap_extras/keymap_german.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_GERMAN
#define KEYMAP_GERMAN
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#define ALGR(kc) kc | 0x1400

2
quantum/keymap_extras/keymap_german_ch.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_SWISS_GERMAN
#define KEYMAP_SWISS_GERMAN
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#define ALGR(kc) kc | 0x1400

2
quantum/keymap_extras/keymap_german_osx.h
View file

@ -4,7 +4,7 @@
#ifdef KEYMAP_GERMAN
#warning redefining german keys
#endif
#include "keymap_common.h"
#include "keymap.h"
// Alt gr

2
quantum/keymap_extras/keymap_neo2.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_NEO2
#define KEYMAP_NEO2
#include "keymap_common.h"
#include "keymap.h"
#include "keymap_extras/keymap_german.h"
#define NEO_A KC_D

2
quantum/keymap_extras/keymap_nordic.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_NORDIC_H
#define KEYMAP_NORDIC_H
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#define ALGR(kc) kc | 0x1400

2
quantum/keymap_extras/keymap_plover.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_PLOVER_H
#define KEYMAP_PLOVER_H
#include "keymap_common.h"
#include "keymap.h"
#define PV_NUM KC_1
#define PV_LS KC_Q

2
quantum/keymap_extras/keymap_spanish.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_SPANISH_H
#define KEYMAP_SPANISH_H
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#define ALGR(kc) kc | 0x1400

2
quantum/keymap_extras/keymap_uk.h
View file

@ -1,7 +1,7 @@
#ifndef KEYMAP_UK_H
#define KEYMAP_UK_H
#include "keymap_common.h"
#include "keymap.h"
// Alt gr
#define ALGR(kc) kc | 0x1400

2
quantum/keymap_midi.c
View file

@ -15,7 +15,7 @@ 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 "keymap_common.h"
#include "keymap.h"
#include "keymap_midi.h"
uint8_t starting_note = 0x0C;

183
quantum/quantum.c
View file

@ -1,5 +1,4 @@
#include "quantum.h"
#include "timer.h"
__attribute__ ((weak))
void matrix_init_kb(void) {}
@ -35,15 +34,15 @@ int offset = 7;
#ifdef AUDIO_ENABLE
bool music_activated = false;
// music sequencer
static bool music_sequence_recording = false;
static bool music_sequence_playing = false;
static float music_sequence[16] = {0};
static uint8_t music_sequence_count = 0;
static uint8_t music_sequence_position = 0;
// music sequencer
static bool music_sequence_recording = false;
static bool music_sequence_playing = false;
static float music_sequence[16] = {0};
static uint8_t music_sequence_count = 0;
static uint8_t music_sequence_position = 0;
static uint16_t music_sequence_timer = 0;
static uint16_t music_sequence_interval = 100;
static uint16_t music_sequence_timer = 0;
static uint16_t music_sequence_interval = 100;
#endif
@ -172,10 +171,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (record->event.pressed) {
starting_note++; // Change key
midi_send_cc(&midi_device, 0, 0x7B, 0);
// midi_send_cc(&midi_device, 1, 0x7B, 0);
// midi_send_cc(&midi_device, 2, 0x7B, 0);
// midi_send_cc(&midi_device, 3, 0x7B, 0);
// midi_send_cc(&midi_device, 4, 0x7B, 0);
}
return false;
}
@ -183,29 +178,17 @@ bool process_record_quantum(keyrecord_t *record) {
if (record->event.pressed) {
starting_note--; // Change key
midi_send_cc(&midi_device, 0, 0x7B, 0);
// midi_send_cc(&midi_device, 1, 0x7B, 0);
// midi_send_cc(&midi_device, 2, 0x7B, 0);
// midi_send_cc(&midi_device, 3, 0x7B, 0);
// midi_send_cc(&midi_device, 4, 0x7B, 0);
}
return false;
}
if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
offset++; // Change scale
midi_send_cc(&midi_device, 0, 0x7B, 0);
// midi_send_cc(&midi_device, 1, 0x7B, 0);
// midi_send_cc(&midi_device, 2, 0x7B, 0);
// midi_send_cc(&midi_device, 3, 0x7B, 0);
// midi_send_cc(&midi_device, 4, 0x7B, 0);
return false;
}
if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
offset--; // Change scale
midi_send_cc(&midi_device, 0, 0x7B, 0);
// midi_send_cc(&midi_device, 1, 0x7B, 0);
// midi_send_cc(&midi_device, 2, 0x7B, 0);
// midi_send_cc(&midi_device, 3, 0x7B, 0);
// midi_send_cc(&midi_device, 4, 0x7B, 0);
return false;
}
// basic
@ -365,7 +348,7 @@ bool process_record_quantum(keyrecord_t *record) {
#define DISABLE_CHORDING
#ifndef DISABLE_CHORDING
if (keycode >= 0x5700 && keycode <= 0x57FF) {
if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
if (record->event.pressed) {
if (!chording) {
chording = true;
@ -403,7 +386,7 @@ bool process_record_quantum(keyrecord_t *record) {
#ifdef UNICODE_ENABLE
if (keycode > UNICODE(0) && record->event.pressed) {
if (keycode > QK_UNICODE && record->event.pressed) {
uint16_t unicode = keycode & 0x7FFF;
switch(input_mode) {
case UC_OSX:
@ -443,42 +426,117 @@ bool process_record_quantum(keyrecord_t *record) {
// Shift / paren setup
switch(keycode) {
case RESET:
if (record->event.pressed) {
clear_keyboard();
#ifdef AUDIO_ENABLE
stop_all_notes();
shutdown_user();
#endif
_delay_ms(250);
#ifdef ATREUS_ASTAR
*(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
#endif
bootloader_jump();
return false;
}
break;
case DEBUG:
if (record->event.pressed) {
print("\nDEBUG: enabled.\n");
debug_enable = true;
return false;
}
break;
case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_UNSWAP_ALT_GUI:
if (record->event.pressed) {
// MAGIC actions (BOOTMAGIC without the boot)
if (!eeconfig_is_enabled()) {
eeconfig_init();
}
/* keymap config */
keymap_config.raw = eeconfig_read_keymap();
if (keycode == MAGIC_SWAP_CONTROL_CAPSLOCK) {
keymap_config.swap_control_capslock = 1;
} else if (keycode == MAGIC_CAPSLOCK_TO_CONTROL) {
keymap_config.capslock_to_control = 1;
} else if (keycode == MAGIC_SWAP_LALT_LGUI) {
keymap_config.swap_lalt_lgui = 1;
} else if (keycode == MAGIC_SWAP_RALT_RGUI) {
keymap_config.swap_ralt_rgui = 1;
} else if (keycode == MAGIC_NO_GUI) {
keymap_config.no_gui = 1;
} else if (keycode == MAGIC_SWAP_GRAVE_ESC) {
keymap_config.swap_grave_esc = 1;
} else if (keycode == MAGIC_SWAP_BACKSLASH_BACKSPACE) {
keymap_config.swap_backslash_backspace = 1;
} else if (keycode == MAGIC_HOST_NKRO) {
keymap_config.nkro = 1;
} else if (keycode == MAGIC_SWAP_ALT_GUI) {
keymap_config.swap_lalt_lgui = 1;
keymap_config.swap_ralt_rgui = 1;
}
/* UNs */
else if (keycode == MAGIC_UNSWAP_CONTROL_CAPSLOCK) {
keymap_config.swap_control_capslock = 0;
} else if (keycode == MAGIC_UNCAPSLOCK_TO_CONTROL) {
keymap_config.capslock_to_control = 0;
} else if (keycode == MAGIC_UNSWAP_LALT_LGUI) {
keymap_config.swap_lalt_lgui = 0;
} else if (keycode == MAGIC_UNSWAP_RALT_RGUI) {
keymap_config.swap_ralt_rgui = 0;
} else if (keycode == MAGIC_UNNO_GUI) {
keymap_config.no_gui = 0;
} else if (keycode == MAGIC_UNSWAP_GRAVE_ESC) {
keymap_config.swap_grave_esc = 0;
} else if (keycode == MAGIC_UNSWAP_BACKSLASH_BACKSPACE) {
keymap_config.swap_backslash_backspace = 0;
} else if (keycode == MAGIC_UNHOST_NKRO) {
keymap_config.nkro = 0;
} else if (keycode == MAGIC_UNSWAP_ALT_GUI) {
keymap_config.swap_lalt_lgui = 0;
keymap_config.swap_ralt_rgui = 0;
}
eeconfig_update_keymap(keymap_config.raw);
return false;
}
break;
case KC_LSPO: {
if (record->event.pressed) {
shift_interrupted[0] = false;
register_mods(MOD_LSFT);
}
else {
if (!shift_interrupted[0]) {
register_code(LSPO_KEY);
unregister_code(LSPO_KEY);
}
unregister_mods(MOD_LSFT);
}
return false;
break;
}
if (record->event.pressed) {
shift_interrupted[0] = false;
register_mods(MOD_LSFT);
}
else {
if (!shift_interrupted[0]) {
register_code(LSPO_KEY);
unregister_code(LSPO_KEY);
}
unregister_mods(MOD_LSFT);
}
return false;
break;
}
case KC_RSPC: {
if (record->event.pressed) {
shift_interrupted[1] = false;
register_mods(MOD_RSFT);
}
else {
if (!shift_interrupted[1]) {
register_code(RSPC_KEY);
unregister_code(RSPC_KEY);
}
unregister_mods(MOD_RSFT);
}
return false;
break;
}
if (record->event.pressed) {
shift_interrupted[1] = false;
register_mods(MOD_RSFT);
}
else {
if (!shift_interrupted[1]) {
register_code(RSPC_KEY);
unregister_code(RSPC_KEY);
}
unregister_mods(MOD_RSFT);
}
return false;
break;
}
default: {
shift_interrupted[0] = true;
shift_interrupted[1] = true;
break;
}
shift_interrupted[0] = true;
shift_interrupted[1] = true;
break;
}
}
return process_action_kb(record);
@ -586,6 +644,13 @@ void send_string(const char *str) {
}
}
void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
layer_on(layer3);
} else {
layer_off(layer3);
}
}
void matrix_init_quantum() {
matrix_init_kb();

13
quantum/quantum.h
View file

@ -3,7 +3,7 @@
#include <avr/pgmspace.h>
#include "matrix.h"
#include "keymap_common.h"
#include "keymap.h"
#ifdef BACKLIGHT_ENABLE
#include "backlight.h"
#endif
@ -25,8 +25,8 @@
#include <stddef.h>
#include <avr/io.h>
#include <util/delay.h>
#define SEND_STRING(str) send_string(PSTR(str))
#include "bootloader.h"
#include "timer.h"
extern uint32_t default_layer_state;
@ -62,15 +62,20 @@ extern uint32_t default_layer_state;
#define LEADER_DICTIONARY() if (leading && timer_elapsed(leader_time) > LEADER_TIMEOUT)
#endif
#define SEND_STRING(str) send_string(PSTR(str))
void send_string(const char *str);
// For tri-layer
void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3);
#define IS_LAYER_ON(layer) (layer_state & (1UL << (layer)))
#define IS_LAYER_OFF(layer) (~layer_state & (1UL << (layer)))
void matrix_init_kb(void);
void matrix_scan_kb(void);
bool process_action_kb(keyrecord_t *record);
bool process_record_kb(uint16_t keycode, keyrecord_t *record);
bool process_record_user(uint16_t keycode, keyrecord_t *record);
bool is_music_on(void);
void music_toggle(void);
void music_on(void);

2
quantum/template/template.h
View file

@ -2,7 +2,7 @@
#define %KEYBOARD_UPPERCASE%_H
#include "matrix.h"
#include "keymap_common.h"
#include "keymap.h"
#ifdef BACKLIGHT_ENABLE
#include "backlight.h"
#endif