drashna/qmk_firmware
1
0
Fork 0
Code Activity Actions

clang-format changes

Browse source
This commit is contained in:
skullY 2019-08-30 11:19:03 -07:00 • committed by skullydazed
parent 61af76a10d
commit b624f32f94
502 changed files with 32259 additions and 39062 deletions
Download patch file Download diff file Expand all files Collapse all files

31
quantum/process_keycode/process_audio.c
View file

@ -2,30 +2,28 @@
#include "process_audio.h"
#ifndef VOICE_CHANGE_SONG
#define VOICE_CHANGE_SONG SONG(VOICE_CHANGE_SOUND)
# define VOICE_CHANGE_SONG SONG(VOICE_CHANGE_SOUND)
#endif
float voice_change_song[][2] = VOICE_CHANGE_SONG;
#ifndef PITCH_STANDARD_A
#define PITCH_STANDARD_A 440.0f
# define PITCH_STANDARD_A 440.0f
#endif
float compute_freq_for_midi_note(uint8_t note)
{
float compute_freq_for_midi_note(uint8_t note) {
// https://en.wikipedia.org/wiki/MIDI_tuning_standard
return pow(2.0, (note - 69) / 12.0) * PITCH_STANDARD_A;
}
bool process_audio(uint16_t keycode, keyrecord_t *record) {
if (keycode == AU_ON && record->event.pressed) {
audio_on();
return false;
audio_on();
return false;
}
if (keycode == AU_OFF && record->event.pressed) {
audio_off();
return false;
audio_off();
return false;
}
if (keycode == AU_TOG && record->event.pressed) {
@ -52,17 +50,10 @@ bool process_audio(uint16_t keycode, keyrecord_t *record) {
return true;
}
void process_audio_noteon(uint8_t note) {
play_note(compute_freq_for_midi_note(note), 0xF);
}
void process_audio_noteon(uint8_t note) { play_note(compute_freq_for_midi_note(note), 0xF); }
void process_audio_noteoff(uint8_t note) {
stop_note(compute_freq_for_midi_note(note));
}
void process_audio_noteoff(uint8_t note) { stop_note(compute_freq_for_midi_note(note)); }
void process_audio_all_notes_off(void) {
stop_all_notes();
}
void process_audio_all_notes_off(void) { stop_all_notes(); }
__attribute__ ((weak))
void audio_on_user() {}
__attribute__((weak)) void audio_on_user() {}

284
quantum/process_keycode/process_auto_shift.c
View file

@ -16,195 +16,185 @@
#ifdef AUTO_SHIFT_ENABLE
#include <stdio.h>
# include <stdio.h>
#include "process_auto_shift.h"
# include "process_auto_shift.h"
#define TAP(key) \
register_code(key); \
unregister_code(key)
# define TAP(key) \
register_code(key); \
unregister_code(key)
#define TAP_WITH_MOD(mod, key) \
register_code(mod); \
register_code(key); \
unregister_code(key); \
unregister_code(mod)
# define TAP_WITH_MOD(mod, key) \
register_code(mod); \
register_code(key); \
unregister_code(key); \
unregister_code(mod)
uint16_t autoshift_time = 0;
uint16_t autoshift_time = 0;
uint16_t autoshift_timeout = AUTO_SHIFT_TIMEOUT;
uint16_t autoshift_lastkey = KC_NO;
void autoshift_timer_report(void) {
char display[8];
char display[8];
snprintf(display, 8, "\n%d\n", autoshift_timeout);
snprintf(display, 8, "\n%d\n", autoshift_timeout);
send_string((const char *)display);
send_string((const char *)display);
}
void autoshift_on(uint16_t keycode) {
autoshift_time = timer_read();
autoshift_lastkey = keycode;
autoshift_time = timer_read();
autoshift_lastkey = keycode;
}
void autoshift_flush(void) {
if (autoshift_lastkey != KC_NO) {
uint16_t elapsed = timer_elapsed(autoshift_time);
if (autoshift_lastkey != KC_NO) {
uint16_t elapsed = timer_elapsed(autoshift_time);
if (elapsed > autoshift_timeout) {
register_code(KC_LSFT);
if (elapsed > autoshift_timeout) {
register_code(KC_LSFT);
}
register_code(autoshift_lastkey);
unregister_code(autoshift_lastkey);
if (elapsed > autoshift_timeout) {
unregister_code(KC_LSFT);
}
autoshift_time = 0;
autoshift_lastkey = KC_NO;
}
register_code(autoshift_lastkey);
unregister_code(autoshift_lastkey);
if (elapsed > autoshift_timeout) {
unregister_code(KC_LSFT);
}
autoshift_time = 0;
autoshift_lastkey = KC_NO;
}
}
bool autoshift_enabled = true;
void autoshift_enable(void) {
autoshift_enabled = true;
}
void autoshift_enable(void) { autoshift_enabled = true; }
void autoshift_disable(void) {
autoshift_enabled = false;
autoshift_flush();
autoshift_enabled = false;
autoshift_flush();
}
void autoshift_toggle(void) {
if (autoshift_enabled) {
autoshift_enabled = false;
autoshift_flush();
}
else {
autoshift_enabled = true;
}
if (autoshift_enabled) {
autoshift_enabled = false;
autoshift_flush();
} else {
autoshift_enabled = true;
}
}
bool autoshift_state(void) {
return autoshift_enabled;
}
bool autoshift_state(void) { return autoshift_enabled; }
bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
#ifndef AUTO_SHIFT_MODIFIERS
static uint8_t any_mod_pressed;
#endif
# ifndef AUTO_SHIFT_MODIFIERS
static uint8_t any_mod_pressed;
# endif
if (record->event.pressed) {
switch (keycode) {
case KC_ASUP:
autoshift_timeout += 5;
return false;
if (record->event.pressed) {
switch (keycode) {
case KC_ASUP:
autoshift_timeout += 5;
return false;
case KC_ASDN:
autoshift_timeout -= 5;
return false;
case KC_ASDN:
autoshift_timeout -= 5;
return false;
case KC_ASRP:
autoshift_timer_report();
return false;
case KC_ASRP:
autoshift_timer_report();
return false;
case KC_ASTG:
autoshift_toggle();
return false;
case KC_ASON:
autoshift_enable();
return false;
case KC_ASOFF:
autoshift_disable();
return false;
case KC_ASTG:
autoshift_toggle();
return false;
case KC_ASON:
autoshift_enable();
return false;
case KC_ASOFF:
autoshift_disable();
return false;
#ifndef NO_AUTO_SHIFT_ALPHA
case KC_A:
case KC_B:
case KC_C:
case KC_D:
case KC_E:
case KC_F:
case KC_G:
case KC_H:
case KC_I:
case KC_J:
case KC_K:
case KC_L:
case KC_M:
case KC_N:
case KC_O:
case KC_P:
case KC_Q:
case KC_R:
case KC_S:
case KC_T:
case KC_U:
case KC_V:
case KC_W:
case KC_X:
case KC_Y:
case KC_Z:
#endif
#ifndef NO_AUTO_SHIFT_NUMERIC
case KC_1:
case KC_2:
case KC_3:
case KC_4:
case KC_5:
case KC_6:
case KC_7:
case KC_8:
case KC_9:
case KC_0:
#endif
#ifndef NO_AUTO_SHIFT_SPECIAL
case KC_MINUS:
case KC_EQL:
case KC_TAB:
case KC_LBRC:
case KC_RBRC:
case KC_BSLS:
case KC_SCLN:
case KC_QUOT:
case KC_COMM:
case KC_DOT:
case KC_SLSH:
case KC_GRAVE:
case KC_NONUS_BSLASH:
case KC_NONUS_HASH:
#endif
# ifndef NO_AUTO_SHIFT_ALPHA
case KC_A:
case KC_B:
case KC_C:
case KC_D:
case KC_E:
case KC_F:
case KC_G:
case KC_H:
case KC_I:
case KC_J:
case KC_K:
case KC_L:
case KC_M:
case KC_N:
case KC_O:
case KC_P:
case KC_Q:
case KC_R:
case KC_S:
case KC_T:
case KC_U:
case KC_V:
case KC_W:
case KC_X:
case KC_Y:
case KC_Z:
# endif
# ifndef NO_AUTO_SHIFT_NUMERIC
case KC_1:
case KC_2:
case KC_3:
case KC_4:
case KC_5:
case KC_6:
case KC_7:
case KC_8:
case KC_9:
case KC_0:
# endif
# ifndef NO_AUTO_SHIFT_SPECIAL
case KC_MINUS:
case KC_EQL:
case KC_TAB:
case KC_LBRC:
case KC_RBRC:
case KC_BSLS:
case KC_SCLN:
case KC_QUOT:
case KC_COMM:
case KC_DOT:
case KC_SLSH:
case KC_GRAVE:
case KC_NONUS_BSLASH:
case KC_NONUS_HASH:
# endif
autoshift_flush();
if (!autoshift_enabled) return true;
autoshift_flush();
if (!autoshift_enabled) return true;
#ifndef AUTO_SHIFT_MODIFIERS
any_mod_pressed = get_mods() & (
MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)|
MOD_BIT(KC_LALT)|MOD_BIT(KC_RALT)|
MOD_BIT(KC_LCTL)|MOD_BIT(KC_RCTL)|
MOD_BIT(KC_LSFT)|MOD_BIT(KC_RSFT)
);
# ifndef AUTO_SHIFT_MODIFIERS
any_mod_pressed = get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI) | MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT) | MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL) | MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT));
if (any_mod_pressed) {
return true;
if (any_mod_pressed) {
return true;
}
# endif
autoshift_on(keycode);
return false;
default:
autoshift_flush();
return true;
}
#endif
autoshift_on(keycode);
return false;
default:
} else {
autoshift_flush();
return true;
}
} else {
autoshift_flush();
}
return true;
return true;
}
#endif

2
quantum/process_keycode/process_auto_shift.h
View file

@ -20,7 +20,7 @@
#include "quantum.h"
#ifndef AUTO_SHIFT_TIMEOUT
#define AUTO_SHIFT_TIMEOUT 175
# define AUTO_SHIFT_TIMEOUT 175
#endif
bool process_auto_shift(uint16_t keycode, keyrecord_t *record);

139
quantum/process_keycode/process_clicky.c
View file

@ -3,104 +3,111 @@
#ifdef AUDIO_CLICKY
#ifndef AUDIO_CLICKY_DELAY_DURATION
#define AUDIO_CLICKY_DELAY_DURATION 1
#endif // !AUDIO_CLICKY_DELAY_DURATION
#ifndef AUDIO_CLICKY_FREQ_DEFAULT
#define AUDIO_CLICKY_FREQ_DEFAULT 440.0f
#endif // !AUDIO_CLICKY_FREQ_DEFAULT
#ifndef AUDIO_CLICKY_FREQ_MIN
#define AUDIO_CLICKY_FREQ_MIN 65.0f
#endif // !AUDIO_CLICKY_FREQ_MIN
#ifndef AUDIO_CLICKY_FREQ_MAX
#define AUDIO_CLICKY_FREQ_MAX 1500.0f
#endif // !AUDIO_CLICKY_FREQ_MAX
#ifndef AUDIO_CLICKY_FREQ_FACTOR
#define AUDIO_CLICKY_FREQ_FACTOR 1.18921f
#endif // !AUDIO_CLICKY_FREQ_FACTOR
#ifndef AUDIO_CLICKY_FREQ_RANDOMNESS
#define AUDIO_CLICKY_FREQ_RANDOMNESS 0.05f
#endif // !AUDIO_CLICKY_FREQ_RANDOMNESS
# ifndef AUDIO_CLICKY_DELAY_DURATION
# define AUDIO_CLICKY_DELAY_DURATION 1
# endif // !AUDIO_CLICKY_DELAY_DURATION
# ifndef AUDIO_CLICKY_FREQ_DEFAULT
# define AUDIO_CLICKY_FREQ_DEFAULT 440.0f
# endif // !AUDIO_CLICKY_FREQ_DEFAULT
# ifndef AUDIO_CLICKY_FREQ_MIN
# define AUDIO_CLICKY_FREQ_MIN 65.0f
# endif // !AUDIO_CLICKY_FREQ_MIN
# ifndef AUDIO_CLICKY_FREQ_MAX
# define AUDIO_CLICKY_FREQ_MAX 1500.0f
# endif // !AUDIO_CLICKY_FREQ_MAX
# ifndef AUDIO_CLICKY_FREQ_FACTOR
# define AUDIO_CLICKY_FREQ_FACTOR 1.18921f
# endif // !AUDIO_CLICKY_FREQ_FACTOR
# ifndef AUDIO_CLICKY_FREQ_RANDOMNESS
# define AUDIO_CLICKY_FREQ_RANDOMNESS 0.05f
# endif // !AUDIO_CLICKY_FREQ_RANDOMNESS
float clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT;
float clicky_rand = AUDIO_CLICKY_FREQ_RANDOMNESS;
// the first "note" is an intentional delay; the 2nd and 3rd notes are the "clicky"
float clicky_song[][2] = {{AUDIO_CLICKY_FREQ_MIN, AUDIO_CLICKY_DELAY_DURATION}, {AUDIO_CLICKY_FREQ_DEFAULT, 3}, {AUDIO_CLICKY_FREQ_DEFAULT, 1}}; // 3 and 1 --> durations
float clicky_song[][2] = {{AUDIO_CLICKY_FREQ_MIN, AUDIO_CLICKY_DELAY_DURATION}, {AUDIO_CLICKY_FREQ_DEFAULT, 3}, {AUDIO_CLICKY_FREQ_DEFAULT, 1}}; // 3 and 1 --> durations
extern audio_config_t audio_config;
#ifndef NO_MUSIC_MODE
# ifndef NO_MUSIC_MODE
extern bool music_activated;
extern bool midi_activated;
#endif // !NO_MUSIC_MODE
# endif // !NO_MUSIC_MODE
void clicky_play(void) {
#ifndef NO_MUSIC_MODE
if (music_activated || midi_activated || !audio_config.enable) return;
#endif // !NO_MUSIC_MODE
clicky_song[1][0] = 2.0f * clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) );
clicky_song[2][0] = clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) );
PLAY_SONG(clicky_song);
# ifndef NO_MUSIC_MODE
if (music_activated || midi_activated || !audio_config.enable) return;
# endif // !NO_MUSIC_MODE
clicky_song[1][0] = 2.0f * clicky_freq * (1.0f + clicky_rand * (((float)rand()) / ((float)(RAND_MAX))));
clicky_song[2][0] = clicky_freq * (1.0f + clicky_rand * (((float)rand()) / ((float)(RAND_MAX))));
PLAY_SONG(clicky_song);
}
void clicky_freq_up(void) {
float new_freq = clicky_freq * AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq < AUDIO_CLICKY_FREQ_MAX) {
clicky_freq = new_freq;
}
float new_freq = clicky_freq * AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq < AUDIO_CLICKY_FREQ_MAX) {
clicky_freq = new_freq;
}
}
void clicky_freq_down(void) {
float new_freq = clicky_freq / AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq > AUDIO_CLICKY_FREQ_MIN) {
clicky_freq = new_freq;
}
float new_freq = clicky_freq / AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq > AUDIO_CLICKY_FREQ_MIN) {
clicky_freq = new_freq;
}
}
void clicky_freq_reset(void) {
clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT;
}
void clicky_freq_reset(void) { clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT; }
void clicky_toggle(void) {
audio_config.clicky_enable ^= 1;
eeconfig_update_audio(audio_config.raw);
audio_config.clicky_enable ^= 1;
eeconfig_update_audio(audio_config.raw);
}
void clicky_on(void) {
audio_config.clicky_enable = 1;
eeconfig_update_audio(audio_config.raw);
audio_config.clicky_enable = 1;
eeconfig_update_audio(audio_config.raw);
}
void clicky_off(void) {
audio_config.clicky_enable = 0;
eeconfig_update_audio(audio_config.raw);
audio_config.clicky_enable = 0;
eeconfig_update_audio(audio_config.raw);
}
bool is_clicky_on(void) {
return (audio_config.clicky_enable != 0);
}
bool is_clicky_on(void) { return (audio_config.clicky_enable != 0); }
bool process_clicky(uint16_t keycode, keyrecord_t *record) {
if (keycode == CLICKY_TOGGLE && record->event.pressed) { clicky_toggle(); }
if (keycode == CLICKY_ENABLE && record->event.pressed) { clicky_on(); }
if (keycode == CLICKY_DISABLE && record->event.pressed) { clicky_off(); }
if (keycode == CLICKY_RESET && record->event.pressed) { clicky_freq_reset(); }
if (keycode == CLICKY_UP && record->event.pressed) { clicky_freq_up(); }
if (keycode == CLICKY_DOWN && record->event.pressed) { clicky_freq_down(); }
if (audio_config.enable && audio_config.clicky_enable) {
if (record->event.pressed) { // Leave this separate so it's easier to add upstroke sound
if (keycode != AU_OFF && keycode != AU_TOG) { // DO NOT PLAY if audio will be disabled, and causes issuse on ARM
clicky_play();
}
if (keycode == CLICKY_TOGGLE && record->event.pressed) {
clicky_toggle();
}
}
return true;
if (keycode == CLICKY_ENABLE && record->event.pressed) {
clicky_on();
}
if (keycode == CLICKY_DISABLE && record->event.pressed) {
clicky_off();
}
if (keycode == CLICKY_RESET && record->event.pressed) {
clicky_freq_reset();
}
if (keycode == CLICKY_UP && record->event.pressed) {
clicky_freq_up();
}
if (keycode == CLICKY_DOWN && record->event.pressed) {
clicky_freq_down();
}
if (audio_config.enable && audio_config.clicky_enable) {
if (record->event.pressed) { // Leave this separate so it's easier to add upstroke sound
if (keycode != AU_OFF && keycode != AU_TOG) { // DO NOT PLAY if audio will be disabled, and causes issuse on ARM
clicky_play();
}
}
}
return true;
}
#endif //AUDIO_CLICKY
#endif // AUDIO_CLICKY

265
quantum/process_keycode/process_combo.c
View file

@ -21,14 +21,13 @@ __attribute__((weak)) combo_t key_combos[COMBO_COUNT] = {
};
__attribute__((weak)) void process_combo_event(uint8_t combo_index,
bool pressed) {}
__attribute__((weak)) void process_combo_event(uint8_t combo_index, bool pressed) {}
static uint16_t timer = 0;
static uint8_t current_combo_index = 0;
static bool drop_buffer = false;
static bool is_active = false;
static bool b_combo_enable = true; // defaults to enabled
static uint16_t timer = 0;
static uint8_t current_combo_index = 0;
static bool drop_buffer = false;
static bool is_active = false;
static bool b_combo_enable = true; // defaults to enabled
static uint8_t buffer_size = 0;
#ifdef COMBO_ALLOW_ACTION_KEYS
@ -38,171 +37,163 @@ static uint16_t key_buffer[MAX_COMBO_LENGTH];
#endif
static inline void send_combo(uint16_t action, bool pressed) {
if (action) {
if (pressed) {
register_code16(action);
if (action) {
if (pressed) {
register_code16(action);
} else {
unregister_code16(action);
}
} else {
unregister_code16(action);
process_combo_event(current_combo_index, pressed);
}
} else {
process_combo_event(current_combo_index, pressed);
}
}
static inline void dump_key_buffer(bool emit) {
if (buffer_size == 0) {
return;
}
if (emit) {
for (uint8_t i = 0; i < buffer_size; i++) {
#ifdef COMBO_ALLOW_ACTION_KEYS
const action_t action = store_or_get_action(key_buffer[i].event.pressed,
key_buffer[i].event.key);
process_action(&(key_buffer[i]), action);
#else
register_code16(key_buffer[i]);
send_keyboard_report();
#endif
if (buffer_size == 0) {
return;
}
}
buffer_size = 0;
if (emit) {
for (uint8_t i = 0; i < buffer_size; i++) {
#ifdef COMBO_ALLOW_ACTION_KEYS
const action_t action = store_or_get_action(key_buffer[i].event.pressed, key_buffer[i].event.key);
process_action(&(key_buffer[i]), action);
#else
register_code16(key_buffer[i]);
send_keyboard_report();
#endif
}
}
buffer_size = 0;
}
#define ALL_COMBO_KEYS_ARE_DOWN (((1 << count) - 1) == combo->state)
#define KEY_STATE_DOWN(key) \
do { \
combo->state |= (1 << key); \
} while (0)
#define KEY_STATE_UP(key) \
do { \
combo->state &= ~(1 << key); \
} while (0)
#define KEY_STATE_DOWN(key) \
do { \
combo->state |= (1 << key); \
} while (0)
#define KEY_STATE_UP(key) \
do { \
combo->state &= ~(1 << key); \
} while (0)
static bool process_single_combo(combo_t *combo, uint16_t keycode,
keyrecord_t *record) {
uint8_t count = 0;
uint8_t index = -1;
/* Find index of keycode and number of combo keys */
for (const uint16_t *keys = combo->keys;; ++count) {
uint16_t key = pgm_read_word(&keys[count]);
if (keycode == key)
index = count;
if (COMBO_END == key)
break;
}
/* Continue processing if not a combo key */
if (-1 == (int8_t)index)
return false;
bool is_combo_active = is_active;
if (record->event.pressed) {
KEY_STATE_DOWN(index);
if (is_combo_active) {
if (ALL_COMBO_KEYS_ARE_DOWN) { /* Combo was pressed */
send_combo(combo->keycode, true);
drop_buffer = true;
}
static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *record) {
uint8_t count = 0;
uint8_t index = -1;
/* Find index of keycode and number of combo keys */
for (const uint16_t *keys = combo->keys;; ++count) {
uint16_t key = pgm_read_word(&keys[count]);
if (keycode == key) index = count;
if (COMBO_END == key) break;
}
} else {
if (ALL_COMBO_KEYS_ARE_DOWN) { /* Combo was released */
send_combo(combo->keycode, false);
/* Continue processing if not a combo key */
if (-1 == (int8_t)index) return false;
bool is_combo_active = is_active;
if (record->event.pressed) {
KEY_STATE_DOWN(index);
if (is_combo_active) {
if (ALL_COMBO_KEYS_ARE_DOWN) { /* Combo was pressed */
send_combo(combo->keycode, true);
drop_buffer = true;
}
}
} else {
/* continue processing without immediately returning */
is_combo_active = false;
if (ALL_COMBO_KEYS_ARE_DOWN) { /* Combo was released */
send_combo(combo->keycode, false);
} else {
/* continue processing without immediately returning */
is_combo_active = false;
}
KEY_STATE_UP(index);
}
KEY_STATE_UP(index);
}
return is_combo_active;
return is_combo_active;
}
#define NO_COMBO_KEYS_ARE_DOWN (0 == combo->state)
bool process_combo(uint16_t keycode, keyrecord_t *record) {
bool is_combo_key = false;
drop_buffer = false;
bool no_combo_keys_pressed = true;
bool is_combo_key = false;
drop_buffer = false;
bool no_combo_keys_pressed = true;
if (keycode == CMB_ON && record->event.pressed) {
combo_enable();
return true;
}
if (keycode == CMB_OFF && record->event.pressed) {
combo_disable();
return true;
}
if (keycode == CMB_TOG && record->event.pressed) {
combo_toggle();
return true;
}
if (!is_combo_enabled()) { return true; }
for (current_combo_index = 0; current_combo_index < COMBO_COUNT;
++current_combo_index) {
combo_t *combo = &key_combos[current_combo_index];
is_combo_key |= process_single_combo(combo, keycode, record);
no_combo_keys_pressed = no_combo_keys_pressed && NO_COMBO_KEYS_ARE_DOWN;
}
if (drop_buffer) {
/* buffer is only dropped when we complete a combo, so we refresh the timer
* here */
timer = timer_read();
dump_key_buffer(false);
} else if (!is_combo_key) {
/* if no combos claim the key we need to emit the keybuffer */
dump_key_buffer(true);
// reset state if there are no combo keys pressed at all
if (no_combo_keys_pressed) {
timer = 0;
is_active = true;
if (keycode == CMB_ON && record->event.pressed) {
combo_enable();
return true;
}
} else if (record->event.pressed && is_active) {
/* otherwise the key is consumed and placed in the buffer */
timer = timer_read();
if (buffer_size < MAX_COMBO_LENGTH) {
if (keycode == CMB_OFF && record->event.pressed) {
combo_disable();
return true;
}
if (keycode == CMB_TOG && record->event.pressed) {
combo_toggle();
return true;
}
if (!is_combo_enabled()) {
return true;
}
for (current_combo_index = 0; current_combo_index < COMBO_COUNT; ++current_combo_index) {
combo_t *combo = &key_combos[current_combo_index];
is_combo_key |= process_single_combo(combo, keycode, record);
no_combo_keys_pressed = no_combo_keys_pressed && NO_COMBO_KEYS_ARE_DOWN;
}
if (drop_buffer) {
/* buffer is only dropped when we complete a combo, so we refresh the timer
* here */
timer = timer_read();
dump_key_buffer(false);
} else if (!is_combo_key) {
/* if no combos claim the key we need to emit the keybuffer */
dump_key_buffer(true);
// reset state if there are no combo keys pressed at all
if (no_combo_keys_pressed) {
timer = 0;
is_active = true;
}
} else if (record->event.pressed && is_active) {
/* otherwise the key is consumed and placed in the buffer */
timer = timer_read();
if (buffer_size < MAX_COMBO_LENGTH) {
#ifdef COMBO_ALLOW_ACTION_KEYS
key_buffer[buffer_size++] = *record;
key_buffer[buffer_size++] = *record;
#else
key_buffer[buffer_size++] = keycode;
key_buffer[buffer_size++] = keycode;
#endif
}
}
}
return !is_combo_key;
return !is_combo_key;
}
void matrix_scan_combo(void) {
if (b_combo_enable && is_active && timer && timer_elapsed(timer) > COMBO_TERM) {
/* This disables the combo, meaning key events for this
* combo will be handled by the next processors in the chain
*/
is_active = false;
dump_key_buffer(true);
}
if (b_combo_enable && is_active && timer && timer_elapsed(timer) > COMBO_TERM) {
/* This disables the combo, meaning key events for this
* combo will be handled by the next processors in the chain
*/
is_active = false;
dump_key_buffer(true);
}
}
void combo_enable(void) {
b_combo_enable = true;
}
void combo_enable(void) { b_combo_enable = true; }
void combo_disable(void) {
b_combo_enable = is_active = false;
timer = 0;
timer = 0;
dump_key_buffer(true);
}
void combo_toggle(void) {
@ -213,6 +204,4 @@ void combo_toggle(void) {
}
}
bool is_combo_enabled(void) {
return b_combo_enable;
}
bool is_combo_enabled(void) { return b_combo_enable; }

28
quantum/process_keycode/process_combo.h
View file

@ -22,36 +22,36 @@
#include <stdint.h>
#ifdef EXTRA_EXTRA_LONG_COMBOS
#define MAX_COMBO_LENGTH 32
# define MAX_COMBO_LENGTH 32
#elif EXTRA_LONG_COMBOS
#define MAX_COMBO_LENGTH 16
# define MAX_COMBO_LENGTH 16
#else
#define MAX_COMBO_LENGTH 8
# define MAX_COMBO_LENGTH 8
#endif
typedef struct {
const uint16_t *keys;
uint16_t keycode;
const uint16_t *keys;
uint16_t keycode;
#ifdef EXTRA_EXTRA_LONG_COMBOS
uint32_t state;
uint32_t state;
#elif EXTRA_LONG_COMBOS
uint16_t state;
uint16_t state;
#else
uint8_t state;
uint8_t state;
#endif
} combo_t;
#define COMBO(ck, ca) \
{ .keys = &(ck)[0], .keycode = (ca) }
#define COMBO_ACTION(ck) \
{ .keys = &(ck)[0] }
#define COMBO(ck, ca) \
{ .keys = &(ck)[0], .keycode = (ca) }
#define COMBO_ACTION(ck) \
{ .keys = &(ck)[0] }
#define COMBO_END 0
#ifndef COMBO_COUNT
#define COMBO_COUNT 0
# define COMBO_COUNT 0
#endif
#ifndef COMBO_TERM
#define COMBO_TERM TAPPING_TERM
# define COMBO_TERM TAPPING_TERM
#endif
bool process_combo(uint16_t keycode, keyrecord_t *record);

48
quantum/process_keycode/process_key_lock.c
View file

@ -19,36 +19,33 @@
#include "process_key_lock.h"
#define BV_64(shift) (((uint64_t)1) << (shift))
#define GET_KEY_ARRAY(code) (((code) < 0x40) ? key_state[0] : \
((code) < 0x80) ? key_state[1] : \
((code) < 0xC0) ? key_state[2] : key_state[3])
#define GET_CODE_INDEX(code) (((code) < 0x40) ? (code) : \
((code) < 0x80) ? (code) - 0x40 : \
((code) < 0xC0) ? (code) - 0x80 : (code) - 0xC0)
#define KEY_STATE(code) (GET_KEY_ARRAY(code) & BV_64(GET_CODE_INDEX(code))) == BV_64(GET_CODE_INDEX(code))
#define SET_KEY_ARRAY_STATE(code, val) do { \
switch (code) { \
case 0x00 ... 0x3F: \
key_state[0] = (val); \
break; \
case 0x40 ... 0x7F: \
key_state[1] = (val); \
break; \
case 0x80 ... 0xBF: \
key_state[2] = (val); \
break; \
case 0xC0 ... 0xFF: \
key_state[3] = (val); \
break; \
} \
} while(0)
#define GET_KEY_ARRAY(code) (((code) < 0x40) ? key_state[0] : ((code) < 0x80) ? key_state[1] : ((code) < 0xC0) ? key_state[2] : key_state[3])
#define GET_CODE_INDEX(code) (((code) < 0x40) ? (code) : ((code) < 0x80) ? (code)-0x40 : ((code) < 0xC0) ? (code)-0x80 : (code)-0xC0)
#define KEY_STATE(code) (GET_KEY_ARRAY(code) & BV_64(GET_CODE_INDEX(code))) == BV_64(GET_CODE_INDEX(code))
#define SET_KEY_ARRAY_STATE(code, val) \
do { \
switch (code) { \
case 0x00 ... 0x3F: \
key_state[0] = (val); \
break; \
case 0x40 ... 0x7F: \
key_state[1] = (val); \
break; \
case 0x80 ... 0xBF: \
key_state[2] = (val); \
break; \
case 0xC0 ... 0xFF: \
key_state[3] = (val); \
break; \
} \
} while (0)
#define SET_KEY_STATE(code) SET_KEY_ARRAY_STATE(code, (GET_KEY_ARRAY(code) | BV_64(GET_CODE_INDEX(code))))
#define UNSET_KEY_STATE(code) SET_KEY_ARRAY_STATE(code, (GET_KEY_ARRAY(code)) & ~(BV_64(GET_CODE_INDEX(code))))
#define IS_STANDARD_KEYCODE(code) ((code) <= 0xFF)
// Locked key state. This is an array of 256 bits, one for each of the standard keys supported qmk.
uint64_t key_state[4] = { 0x0, 0x0, 0x0, 0x0 };
bool watching = false;
uint64_t key_state[4] = {0x0, 0x0, 0x0, 0x0};
bool watching = false;
// Translate any OSM keycodes back to their unmasked versions.
static inline uint16_t translate_keycode(uint16_t keycode) {
@ -135,4 +132,3 @@ bool process_key_lock(uint16_t *keycode, keyrecord_t *record) {
return !(IS_STANDARD_KEYCODE(translated_keycode) && KEY_STATE(translated_keycode));
}
}

2
quantum/process_keycode/process_key_lock.h
View file

@ -21,4 +21,4 @@
bool process_key_lock(uint16_t *keycode, keyrecord_t *record);
#endif // PROCESS_KEY_LOCK_H
#endif // PROCESS_KEY_LOCK_H

86
quantum/process_keycode/process_leader.c
View file

@ -16,64 +16,64 @@
#ifdef LEADER_ENABLE
#include "process_leader.h"
#include <string.h>
# include "process_leader.h"
# include <string.h>
#ifndef LEADER_TIMEOUT
#define LEADER_TIMEOUT 300
#endif
# ifndef LEADER_TIMEOUT
# define LEADER_TIMEOUT 300
# endif
__attribute__ ((weak))
void leader_start(void) {}
__attribute__((weak)) void leader_start(void) {}
__attribute__ ((weak))
void leader_end(void) {}
__attribute__((weak)) void leader_end(void) {}
// Leader key stuff
bool leading = false;
bool leading = false;
uint16_t leader_time = 0;
uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
uint8_t leader_sequence_size = 0;
uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
uint8_t leader_sequence_size = 0;
void qk_leader_start(void) {
if (leading) { return; }
leader_start();
leading = true;
leader_time = timer_read();
leader_sequence_size = 0;
memset(leader_sequence, 0, sizeof(leader_sequence));
if (leading) {
return;
}
leader_start();
leading = true;
leader_time = timer_read();
leader_sequence_size = 0;
memset(leader_sequence, 0, sizeof(leader_sequence));
}
bool process_leader(uint16_t keycode, keyrecord_t *record) {
// Leader key set-up
if (record->event.pressed) {
if (leading) {
if (timer_elapsed(leader_time) < LEADER_TIMEOUT) {
#ifndef LEADER_KEY_STRICT_KEY_PROCESSING
if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) {
keycode = keycode & 0xFF;
}
#endif // LEADER_KEY_STRICT_KEY_PROCESSING
if ( leader_sequence_size < ( sizeof(leader_sequence) / sizeof(leader_sequence[0]) ) ) {
leader_sequence[leader_sequence_size] = keycode;
leader_sequence_size++;
// Leader key set-up
if (record->event.pressed) {
if (leading) {
if (timer_elapsed(leader_time) < LEADER_TIMEOUT) {
# ifndef LEADER_KEY_STRICT_KEY_PROCESSING
if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) {
keycode = keycode & 0xFF;
}
# endif // LEADER_KEY_STRICT_KEY_PROCESSING
if (leader_sequence_size < (sizeof(leader_sequence) / sizeof(leader_sequence[0]))) {
leader_sequence[leader_sequence_size] = keycode;
leader_sequence_size++;
} else {
leading = false;
leader_end();
}
# ifdef LEADER_PER_KEY_TIMING
leader_time = timer_read();
# endif
return false;
}
} else {
leading = false;
leader_end();
if (keycode == KC_LEAD) {
qk_leader_start();
}
}
#ifdef LEADER_PER_KEY_TIMING
leader_time = timer_read();
#endif
return false;
}
} else {
if (keycode == KC_LEAD) {
qk_leader_start();
}
}
}
return true;
return true;
}
#endif

7
quantum/process_keycode/process_leader.h
View file

@ -19,7 +19,6 @@
#include "quantum.h"
bool process_leader(uint16_t keycode, keyrecord_t *record);
void leader_start(void);
@ -32,7 +31,11 @@ void qk_leader_start(void);
#define SEQ_FOUR_KEYS(key1, key2, key3, key4) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == 0)
#define SEQ_FIVE_KEYS(key1, key2, key3, key4, key5) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == (key5))
#define LEADER_EXTERNS() extern bool leading; extern uint16_t leader_time; extern uint16_t leader_sequence[5]; extern uint8_t leader_sequence_size
#define LEADER_EXTERNS() \
extern bool leading; \
extern uint16_t leader_time; \
extern uint16_t leader_sequence[5]; \
extern uint8_t leader_sequence_size
#define LEADER_DICTIONARY() if (leading && timer_elapsed(leader_time) > LEADER_TIMEOUT)
#endif

115
quantum/process_keycode/process_midi.c
View file

@ -16,86 +16,65 @@
#include "process_midi.h"
#ifdef MIDI_ENABLE
#include <LUFA/Drivers/USB/USB.h>
#include "midi.h"
#include "qmk_midi.h"
# include <LUFA/Drivers/USB/USB.h>
# include "midi.h"
# include "qmk_midi.h"
#ifdef MIDI_BASIC
# ifdef MIDI_BASIC
void process_midi_basic_noteon(uint8_t note)
{
midi_send_noteon(&midi_device, 0, note, 127);
}
void process_midi_basic_noteon(uint8_t note) { midi_send_noteon(&midi_device, 0, note, 127); }
void process_midi_basic_noteoff(uint8_t note)
{
midi_send_noteoff(&midi_device, 0, note, 0);
}
void process_midi_basic_noteoff(uint8_t note) { midi_send_noteoff(&midi_device, 0, note, 0); }
void process_midi_all_notes_off(void)
{
midi_send_cc(&midi_device, 0, 0x7B, 0);
}
void process_midi_all_notes_off(void) { midi_send_cc(&midi_device, 0, 0x7B, 0); }
#endif // MIDI_BASIC
# endif // MIDI_BASIC
#ifdef MIDI_ADVANCED
# ifdef MIDI_ADVANCED
#include "timer.h"
# include "timer.h"
static uint8_t tone_status[MIDI_TONE_COUNT];
static uint8_t midi_modulation;
static int8_t midi_modulation_step;
static uint8_t midi_modulation;
static int8_t midi_modulation_step;
static uint16_t midi_modulation_timer;
midi_config_t midi_config;
midi_config_t midi_config;
inline uint8_t compute_velocity(uint8_t setting)
{
return (setting + 1) * (128 / (MIDI_VELOCITY_MAX - MIDI_VELOCITY_MIN + 1));
}
inline uint8_t compute_velocity(uint8_t setting) { return (setting + 1) * (128 / (MIDI_VELOCITY_MAX - MIDI_VELOCITY_MIN + 1)); }
void midi_init(void)
{
midi_config.octave = MI_OCT_2 - MIDI_OCTAVE_MIN;
midi_config.transpose = 0;
midi_config.velocity = (MIDI_VELOCITY_MAX - MIDI_VELOCITY_MIN);
midi_config.channel = 0;
void midi_init(void) {
midi_config.octave = MI_OCT_2 - MIDI_OCTAVE_MIN;
midi_config.transpose = 0;
midi_config.velocity = (MIDI_VELOCITY_MAX - MIDI_VELOCITY_MIN);
midi_config.channel = 0;
midi_config.modulation_interval = 8;
for (uint8_t i = 0; i < MIDI_TONE_COUNT; i++)
{
for (uint8_t i = 0; i < MIDI_TONE_COUNT; i++) {
tone_status[i] = MIDI_INVALID_NOTE;
}
midi_modulation = 0;
midi_modulation_step = 0;
midi_modulation = 0;
midi_modulation_step = 0;
midi_modulation_timer = 0;
}
uint8_t midi_compute_note(uint16_t keycode)
{
return 12 * midi_config.octave + (keycode - MIDI_TONE_MIN) + midi_config.transpose;
}
uint8_t midi_compute_note(uint16_t keycode) { return 12 * midi_config.octave + (keycode - MIDI_TONE_MIN) + midi_config.transpose; }
bool process_midi(uint16_t keycode, keyrecord_t *record)
{
bool process_midi(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case MIDI_TONE_MIN ... MIDI_TONE_MAX:
{
uint8_t channel = midi_config.channel;
uint8_t tone = keycode - MIDI_TONE_MIN;
case MIDI_TONE_MIN ... MIDI_TONE_MAX: {
uint8_t channel = midi_config.channel;
uint8_t tone = keycode - MIDI_TONE_MIN;
uint8_t velocity = compute_velocity(midi_config.velocity);
if (record->event.pressed) {
uint8_t note = midi_compute_note(keycode);
midi_send_noteon(&midi_device, channel, note, velocity);
dprintf("midi noteon channel:%d note:%d velocity:%d\n", channel, note, velocity);
tone_status[tone] = note;
}
else {
} else {
uint8_t note = tone_status[tone];
if (note != MIDI_INVALID_NOTE)
{
if (note != MIDI_INVALID_NOTE) {
midi_send_noteoff(&midi_device, channel, note, velocity);
dprintf("midi noteoff channel:%d note:%d velocity:%d\n", channel, note, velocity);
}
@ -137,8 +116,7 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
if (record->event.pressed && midi_config.transpose < (MIDI_TRANSPOSE_MAX - MI_TRNS_0)) {
const bool positive = midi_config.transpose > 0;
midi_config.transpose++;
if (positive && midi_config.transpose < 0)
midi_config.transpose--;
if (positive && midi_config.transpose < 0) midi_config.transpose--;
dprintf("midi transpose %d\n", midi_config.transpose);
}
return false;
@ -211,8 +189,7 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
if (record->event.pressed) {
midi_config.modulation_interval++;
// prevent overflow
if (midi_config.modulation_interval == 0)
midi_config.modulation_interval--;
if (midi_config.modulation_interval == 0) midi_config.modulation_interval--;
dprintf("midi modulation interval %d\n", midi_config.modulation_interval);
}
return false;
@ -226,8 +203,7 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
if (record->event.pressed) {
midi_send_pitchbend(&midi_device, midi_config.channel, -0x2000);
dprintf("midi pitchbend channel:%d amount:%d\n", midi_config.channel, -0x2000);
}
else {
} else {
midi_send_pitchbend(&midi_device, midi_config.channel, 0);
dprintf("midi pitchbend channel:%d amount:%d\n", midi_config.channel, 0);
}
@ -236,8 +212,7 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
if (record->event.pressed) {
midi_send_pitchbend(&midi_device, midi_config.channel, 0x1fff);
dprintf("midi pitchbend channel:%d amount:%d\n", midi_config.channel, 0x1fff);
}
else {
} else {
midi_send_pitchbend(&midi_device, midi_config.channel, 0);
dprintf("midi pitchbend channel:%d amount:%d\n", midi_config.channel, 0);
}
@ -247,35 +222,29 @@ bool process_midi(uint16_t keycode, keyrecord_t *record)
return true;
}
#endif // MIDI_ADVANCED
# endif // MIDI_ADVANCED
void midi_task(void)
{
void midi_task(void) {
midi_device_process(&midi_device);
#ifdef MIDI_ADVANCED
if (timer_elapsed(midi_modulation_timer) < midi_config.modulation_interval)
return;
# ifdef MIDI_ADVANCED
if (timer_elapsed(midi_modulation_timer) < midi_config.modulation_interval) return;
midi_modulation_timer = timer_read();
if (midi_modulation_step != 0)
{
if (midi_modulation_step != 0) {
dprintf("midi modulation %d\n", midi_modulation);
midi_send_cc(&midi_device, midi_config.channel, 0x1, midi_modulation);
if (midi_modulation_step < 0 && midi_modulation < -midi_modulation_step) {
midi_modulation = 0;
midi_modulation = 0;
midi_modulation_step = 0;
return;
}
midi_modulation += midi_modulation_step;
if (midi_modulation > 127)
midi_modulation = 127;
if (midi_modulation > 127) midi_modulation = 127;
}
#endif
# endif
}
#endif // MIDI_ENABLE
#endif // MIDI_ENABLE

30
quantum/process_keycode/process_midi.h
View file

@ -21,24 +21,24 @@
#ifdef MIDI_ENABLE
#ifdef MIDI_BASIC
# ifdef MIDI_BASIC
void process_midi_basic_noteon(uint8_t note);
void process_midi_basic_noteoff(uint8_t note);
void process_midi_all_notes_off(void);
#endif
# endif
void midi_task(void);
#ifdef MIDI_ADVANCED
# ifdef MIDI_ADVANCED
typedef union {
uint32_t raw;
struct {
uint8_t octave :4;
int8_t transpose :4;
uint8_t velocity :4;
uint8_t channel :4;
uint8_t modulation_interval :4;
};
uint32_t raw;
struct {
uint8_t octave : 4;
int8_t transpose : 4;
uint8_t velocity : 4;
uint8_t channel : 4;
uint8_t modulation_interval : 4;
};
} midi_config_t;
extern midi_config_t midi_config;
@ -46,12 +46,12 @@ extern midi_config_t midi_config;
void midi_init(void);
bool process_midi(uint16_t keycode, keyrecord_t *record);
#define MIDI_INVALID_NOTE 0xFF
#define MIDI_TONE_COUNT (MIDI_TONE_MAX - MIDI_TONE_MIN + 1)
# define MIDI_INVALID_NOTE 0xFF
# define MIDI_TONE_COUNT (MIDI_TONE_MAX - MIDI_TONE_MIN + 1)
uint8_t midi_compute_note(uint16_t keycode);
#endif // MIDI_ADVANCED
# endif // MIDI_ADVANCED
#endif // MIDI_ENABLE
#endif // MIDI_ENABLE
#endif

350
quantum/process_keycode/process_music.c
View file

@ -16,103 +16,91 @@
#include "process_music.h"
#ifdef AUDIO_ENABLE
#include "process_audio.h"
# include "process_audio.h"
#endif
#if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
#include "process_midi.h"
# include "process_midi.h"
#endif
#if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
bool music_activated = false;
bool midi_activated = false;
bool music_activated = false;
bool midi_activated = false;
uint8_t music_starting_note = 0x0C;
int music_offset = 7;
uint8_t music_mode = MUSIC_MODE_MAJOR;
int music_offset = 7;
uint8_t music_mode = MUSIC_MODE_MAJOR;
// music sequencer
static bool music_sequence_recording = false;
static bool music_sequence_recorded = false;
static bool music_sequence_playing = false;
static uint8_t music_sequence[16] = {0};
static uint8_t music_sequence_count = 0;
static uint8_t music_sequence_position = 0;
static bool music_sequence_recording = false;
static bool music_sequence_recorded = false;
static bool music_sequence_playing = false;
static uint8_t 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_timer = 0;
static uint16_t music_sequence_interval = 100;
#ifdef AUDIO_ENABLE
#ifndef MUSIC_ON_SONG
#define MUSIC_ON_SONG SONG(MUSIC_ON_SOUND)
#endif
#ifndef MUSIC_OFF_SONG
#define MUSIC_OFF_SONG SONG(MUSIC_OFF_SOUND)
#endif
#ifndef MIDI_ON_SONG
#define MIDI_ON_SONG SONG(MUSIC_ON_SOUND)
#endif
#ifndef MIDI_OFF_SONG
#define MIDI_OFF_SONG SONG(MUSIC_OFF_SOUND)
#endif
#ifndef CHROMATIC_SONG
#define CHROMATIC_SONG SONG(CHROMATIC_SOUND)
#endif
#ifndef GUITAR_SONG
#define GUITAR_SONG SONG(GUITAR_SOUND)
#endif
#ifndef VIOLIN_SONG
#define VIOLIN_SONG SONG(VIOLIN_SOUND)
#endif
#ifndef MAJOR_SONG
#define MAJOR_SONG SONG(MAJOR_SOUND)
#endif
float music_mode_songs[NUMBER_OF_MODES][5][2] = {
CHROMATIC_SONG,
GUITAR_SONG,
VIOLIN_SONG,
MAJOR_SONG
};
float music_on_song[][2] = MUSIC_ON_SONG;
float music_off_song[][2] = MUSIC_OFF_SONG;
float midi_on_song[][2] = MIDI_ON_SONG;
float midi_off_song[][2] = MIDI_OFF_SONG;
#endif
# ifdef AUDIO_ENABLE
# ifndef MUSIC_ON_SONG
# define MUSIC_ON_SONG SONG(MUSIC_ON_SOUND)
# endif
# ifndef MUSIC_OFF_SONG
# define MUSIC_OFF_SONG SONG(MUSIC_OFF_SOUND)
# endif
# ifndef MIDI_ON_SONG
# define MIDI_ON_SONG SONG(MUSIC_ON_SOUND)
# endif
# ifndef MIDI_OFF_SONG
# define MIDI_OFF_SONG SONG(MUSIC_OFF_SOUND)
# endif
# ifndef CHROMATIC_SONG
# define CHROMATIC_SONG SONG(CHROMATIC_SOUND)
# endif
# ifndef GUITAR_SONG
# define GUITAR_SONG SONG(GUITAR_SOUND)
# endif
# ifndef VIOLIN_SONG
# define VIOLIN_SONG SONG(VIOLIN_SOUND)
# endif
# ifndef MAJOR_SONG
# define MAJOR_SONG SONG(MAJOR_SOUND)
# endif
float music_mode_songs[NUMBER_OF_MODES][5][2] = {CHROMATIC_SONG, GUITAR_SONG, VIOLIN_SONG, MAJOR_SONG};
float music_on_song[][2] = MUSIC_ON_SONG;
float music_off_song[][2] = MUSIC_OFF_SONG;
float midi_on_song[][2] = MIDI_ON_SONG;
float midi_off_song[][2] = MIDI_OFF_SONG;
# endif
static void music_noteon(uint8_t note) {
#ifdef AUDIO_ENABLE
if (music_activated)
process_audio_noteon(note);
#endif
#if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
if (midi_activated)
process_midi_basic_noteon(note);
#endif
# ifdef AUDIO_ENABLE
if (music_activated) process_audio_noteon(note);
# endif
# if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
if (midi_activated) process_midi_basic_noteon(note);
# endif
}
static void music_noteoff(uint8_t note) {
#ifdef AUDIO_ENABLE
if (music_activated)
process_audio_noteoff(note);
#endif
#if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
if (midi_activated)
process_midi_basic_noteoff(note);
#endif
# ifdef AUDIO_ENABLE
if (music_activated) process_audio_noteoff(note);
# endif
# if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
if (midi_activated) process_midi_basic_noteoff(note);
# endif
}
void music_all_notes_off(void) {
#ifdef AUDIO_ENABLE
if (music_activated)
process_audio_all_notes_off();
#endif
#if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
if (midi_activated)
process_midi_all_notes_off();
#endif
# ifdef AUDIO_ENABLE
if (music_activated) process_audio_all_notes_off();
# endif
# if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
if (midi_activated) process_midi_all_notes_off();
# endif
}
bool process_music(uint16_t keycode, keyrecord_t *record) {
if (keycode == MU_ON && record->event.pressed) {
music_on();
return false;
@ -152,110 +140,101 @@ bool process_music(uint16_t keycode, keyrecord_t *record) {
}
if (keycode == MU_MOD && record->event.pressed) {
music_mode_cycle();
return false;
music_mode_cycle();
return false;
}
if (music_activated || midi_activated) {
if (record->event.pressed) {
if (keycode == KC_LCTL) { // Start recording
music_all_notes_off();
music_sequence_recording = true;
music_sequence_recorded = false;
music_sequence_playing = false;
music_sequence_count = 0;
return false;
if (record->event.pressed) {
if (keycode == KC_LCTL) { // Start recording
music_all_notes_off();
music_sequence_recording = true;
music_sequence_recorded = false;
music_sequence_playing = false;
music_sequence_count = 0;
return false;
}
if (keycode == KC_LALT) { // Stop recording/playing
music_all_notes_off();
if (music_sequence_recording) { // was recording
music_sequence_recorded = true;
}
music_sequence_recording = false;
music_sequence_playing = false;
return false;
}
if (keycode == KC_LGUI && music_sequence_recorded) { // Start playing
music_all_notes_off();
music_sequence_recording = false;
music_sequence_playing = true;
music_sequence_position = 0;
music_sequence_timer = 0;
return false;
}
if (keycode == KC_UP) {
music_sequence_interval -= 10;
return false;
}
if (keycode == KC_DOWN) {
music_sequence_interval += 10;
return false;
}
}
if (keycode == KC_LALT) { // Stop recording/playing
music_all_notes_off();
if (music_sequence_recording) { // was recording
music_sequence_recorded = true;
}
music_sequence_recording = false;
music_sequence_playing = false;
return false;
}
if (keycode == KC_LGUI && music_sequence_recorded) { // Start playing
music_all_notes_off();
music_sequence_recording = false;
music_sequence_playing = true;
music_sequence_position = 0;
music_sequence_timer = 0;
return false;
}
if (keycode == KC_UP) {
music_sequence_interval-=10;
return false;
}
if (keycode == KC_DOWN) {
music_sequence_interval+=10;
return false;
}
}
uint8_t note = 36;
#ifdef MUSIC_MAP
uint8_t note = 36;
# ifdef MUSIC_MAP
if (music_mode == MUSIC_MODE_CHROMATIC) {
note = music_starting_note + music_offset + 36 + music_map[record->event.key.row][record->event.key.col];
note = music_starting_note + music_offset + 36 + music_map[record->event.key.row][record->event.key.col];
} else {
uint8_t position = music_map[record->event.key.row][record->event.key.col];
note = music_starting_note + music_offset + 36 + SCALE[position % 12] + (position / 12)*12;
uint8_t position = music_map[record->event.key.row][record->event.key.col];
note = music_starting_note + music_offset + 36 + SCALE[position % 12] + (position / 12) * 12;
}
#else
# else
if (music_mode == MUSIC_MODE_CHROMATIC)
note = (music_starting_note + record->event.key.col + music_offset - 3)+12*(MATRIX_ROWS - record->event.key.row);
note = (music_starting_note + record->event.key.col + music_offset - 3) + 12 * (MATRIX_ROWS - record->event.key.row);
else if (music_mode == MUSIC_MODE_GUITAR)
note = (music_starting_note + record->event.key.col + music_offset + 32)+5*(MATRIX_ROWS - record->event.key.row);
note = (music_starting_note + record->event.key.col + music_offset + 32) + 5 * (MATRIX_ROWS - record->event.key.row);
else if (music_mode == MUSIC_MODE_VIOLIN)
note = (music_starting_note + record->event.key.col + music_offset + 32)+7*(MATRIX_ROWS - record->event.key.row);
note = (music_starting_note + record->event.key.col + music_offset + 32) + 7 * (MATRIX_ROWS - record->event.key.row);
else if (music_mode == MUSIC_MODE_MAJOR)
note = (music_starting_note + SCALE[record->event.key.col + music_offset] - 3)+12*(MATRIX_ROWS - record->event.key.row);
note = (music_starting_note + SCALE[record->event.key.col + music_offset] - 3) + 12 * (MATRIX_ROWS - record->event.key.row);
else
note = music_starting_note;
#endif
note = music_starting_note;
# endif
if (record->event.pressed) {
music_noteon(note);
if (music_sequence_recording) {
music_sequence[music_sequence_count] = note;
music_sequence_count++;
if (record->event.pressed) {
music_noteon(note);
if (music_sequence_recording) {
music_sequence[music_sequence_count] = note;
music_sequence_count++;
}
} else {
music_noteoff(note);
}
} else {
music_noteoff(note);
}
if (music_mask(keycode))
return false;
if (music_mask(keycode)) return false;
}
return true;
}
bool music_mask(uint16_t keycode) {
#ifdef MUSIC_MASK
# ifdef MUSIC_MASK
return MUSIC_MASK;
#else
# else
return music_mask_kb(keycode);
#endif
# endif
}
__attribute__((weak))
bool music_mask_kb(uint16_t keycode) {
return music_mask_user(keycode);
}
__attribute__((weak)) bool music_mask_kb(uint16_t keycode) { return music_mask_user(keycode); }
__attribute__((weak))
bool music_mask_user(uint16_t keycode) {
return keycode < 0xFF;
}
__attribute__((weak)) bool music_mask_user(uint16_t keycode) { return keycode < 0xFF; }
bool is_music_on(void) {
return (music_activated != 0);
}
bool is_music_on(void) { return (music_activated != 0); }
void music_toggle(void) {
if (!music_activated) {
@ -267,23 +246,21 @@ void music_toggle(void) {
void music_on(void) {
music_activated = 1;
#ifdef AUDIO_ENABLE
PLAY_SONG(music_on_song);
#endif
# ifdef AUDIO_ENABLE
PLAY_SONG(music_on_song);
# endif
music_on_user();
}
void music_off(void) {
music_all_notes_off();
music_activated = 0;
#ifdef AUDIO_ENABLE
PLAY_SONG(music_off_song);
#endif
# ifdef AUDIO_ENABLE
PLAY_SONG(music_off_song);
# endif
}
bool is_midi_on(void) {
return (midi_activated != 0);
}
bool is_midi_on(void) { return (midi_activated != 0); }
void midi_toggle(void) {
if (!midi_activated) {
@ -295,50 +272,47 @@ void midi_toggle(void) {
void midi_on(void) {
midi_activated = 1;
#ifdef AUDIO_ENABLE
PLAY_SONG(midi_on_song);
#endif
# ifdef AUDIO_ENABLE
PLAY_SONG(midi_on_song);
# endif
midi_on_user();
}
void midi_off(void) {
#if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
process_midi_all_notes_off();
#endif
# if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
process_midi_all_notes_off();
# endif
midi_activated = 0;
#ifdef AUDIO_ENABLE
PLAY_SONG(midi_off_song);
#endif
# ifdef AUDIO_ENABLE
PLAY_SONG(midi_off_song);
# endif
}
void music_mode_cycle(void) {
music_all_notes_off();
music_mode = (music_mode + 1) % NUMBER_OF_MODES;
#ifdef AUDIO_ENABLE
music_all_notes_off();
music_mode = (music_mode + 1) % NUMBER_OF_MODES;
# ifdef AUDIO_ENABLE
PLAY_SONG(music_mode_songs[music_mode]);
#endif
# endif
}
void matrix_scan_music(void) {
if (music_sequence_playing) {
if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
music_sequence_timer = timer_read();
uint8_t prev_note = music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)];
uint8_t next_note = music_sequence[music_sequence_position];
music_noteoff(prev_note);
music_noteon(next_note);
music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
if (music_sequence_playing) {
if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
music_sequence_timer = timer_read();
uint8_t prev_note = music_sequence[(music_sequence_position - 1 < 0) ? (music_sequence_position - 1 + music_sequence_count) : (music_sequence_position - 1)];
uint8_t next_note = music_sequence[music_sequence_position];
music_noteoff(prev_note);
music_noteon(next_note);
music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
}
}
}
}
__attribute__ ((weak))
void music_on_user() {}
__attribute__((weak)) void music_on_user() {}
__attribute__ ((weak))
void midi_on_user() {}
__attribute__((weak)) void midi_on_user() {}
__attribute__ ((weak))
void music_scale_user() {}
__attribute__((weak)) void music_scale_user() {}
#endif // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
#endif // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))

28
quantum/process_keycode/process_music.h
View file

@ -21,18 +21,11 @@
#if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
enum music_modes {
MUSIC_MODE_CHROMATIC,
MUSIC_MODE_GUITAR,
MUSIC_MODE_VIOLIN,
MUSIC_MODE_MAJOR,
NUMBER_OF_MODES
};
enum music_modes { MUSIC_MODE_CHROMATIC, MUSIC_MODE_GUITAR, MUSIC_MODE_VIOLIN, MUSIC_MODE_MAJOR, NUMBER_OF_MODES };
#ifdef MUSIC_MAP
extern const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS];
#endif
# ifdef MUSIC_MAP
extern const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS];
# endif
bool process_music(uint16_t keycode, keyrecord_t *record);
@ -58,14 +51,11 @@ bool music_mask(uint16_t keycode);
bool music_mask_kb(uint16_t keycode);
bool music_mask_user(uint16_t keycode);
#ifndef SCALE
#define SCALE (int8_t []){ 0 + (12*0), 2 + (12*0), 4 + (12*0), 5 + (12*0), 7 + (12*0), 9 + (12*0), 11 + (12*0), \
0 + (12*1), 2 + (12*1), 4 + (12*1), 5 + (12*1), 7 + (12*1), 9 + (12*1), 11 + (12*1), \
0 + (12*2), 2 + (12*2), 4 + (12*2), 5 + (12*2), 7 + (12*2), 9 + (12*2), 11 + (12*2), \
0 + (12*3), 2 + (12*3), 4 + (12*3), 5 + (12*3), 7 + (12*3), 9 + (12*3), 11 + (12*3), \
0 + (12*4), 2 + (12*4), 4 + (12*4), 5 + (12*4), 7 + (12*4), 9 + (12*4), 11 + (12*4), }
#endif
# ifndef SCALE
# define SCALE \
(int8_t[]) { 0 + (12 * 0), 2 + (12 * 0), 4 + (12 * 0), 5 + (12 * 0), 7 + (12 * 0), 9 + (12 * 0), 11 + (12 * 0), 0 + (12 * 1), 2 + (12 * 1), 4 + (12 * 1), 5 + (12 * 1), 7 + (12 * 1), 9 + (12 * 1), 11 + (12 * 1), 0 + (12 * 2), 2 + (12 * 2), 4 + (12 * 2), 5 + (12 * 2), 7 + (12 * 2), 9 + (12 * 2), 11 + (12 * 2), 0 + (12 * 3), 2 + (12 * 3), 4 + (12 * 3), 5 + (12 * 3), 7 + (12 * 3), 9 + (12 * 3), 11 + (12 * 3), 0 + (12 * 4), 2 + (12 * 4), 4 + (12 * 4), 5 + (12 * 4), 7 + (12 * 4), 9 + (12 * 4), 11 + (12 * 4), }
# endif
#endif // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
#endif // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
#endif

443
quantum/process_keycode/process_printer.c
View file

@ -17,17 +17,15 @@
#include "process_printer.h"
#include "action_util.h"
bool printing_enabled = false;
uint8_t character_shift = 0;
bool printing_enabled = false;
uint8_t character_shift = 0;
void enable_printing(void) {
printing_enabled = true;
serial_init();
printing_enabled = true;
serial_init();
}
void disable_printing(void) {
printing_enabled = false;
}
void disable_printing(void) { printing_enabled = false; }
uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
@ -36,235 +34,232 @@ uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0
// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
void print_char(char c) {
USB_Disable();
serial_send(c);
USB_Init();
USB_Disable();
serial_send(c);
USB_Init();
}
void print_string(char c[]) {
for(uint8_t i = 0; i < strlen(c); i++)
print_char(c[i]);
for (uint8_t i = 0; i < strlen(c); i++) print_char(c[i]);
}
void print_box_string(const char text[]) {
size_t len = strlen(text);
char out[len * 3 + 8];
out[0] = 0xDA;
for (uint8_t i = 0; i < len; i++) {
out[i+1] = 0xC4;
}
out[len + 1] = 0xBF;
out[len + 2] = '\n';
size_t len = strlen(text);
char out[len * 3 + 8];
out[0] = 0xDA;
for (uint8_t i = 0; i < len; i++) {
out[i + 1] = 0xC4;
}
out[len + 1] = 0xBF;
out[len + 2] = '\n';
out[len + 3] = 0xB3;
for (uint8_t i = 0; i < len; i++) {
out[len + 4 + i] = text[i];
}
out[len * 2 + 4] = 0xB3;
out[len * 2 + 5] = '\n';
out[len + 3] = 0xB3;
for (uint8_t i = 0; i < len; i++) {
out[len + 4 + i] = text[i];
}
out[len * 2 + 4] = 0xB3;
out[len * 2 + 5] = '\n';
out[len * 2 + 6] = 0xC0;
for (uint8_t i = 0; i < len; i++) {
out[len * 2 + 7 + i] = 0xC4;
}
out[len * 3 + 7] = 0xD9;
out[len * 3 + 8] = '\n';
out[len * 2 + 6] = 0xC0;
for (uint8_t i = 0; i < len; i++) {
out[len * 2 + 7 + i] = 0xC4;
}
out[len * 3 + 7] = 0xD9;
out[len * 3 + 8] = '\n';
print_string(out);
print_string(out);
}
bool process_printer(uint16_t keycode, keyrecord_t *record) {
if (keycode == PRINT_ON) {
enable_printing();
return false;
}
if (keycode == PRINT_OFF) {
disable_printing();
return false;
}
if (keycode == PRINT_ON) {
enable_printing();
return false;
}
if (keycode == PRINT_OFF) {
disable_printing();
return false;
}
if (printing_enabled) {
switch(keycode) {
case KC_EXLM ... KC_RPRN:
case KC_UNDS:
case KC_PLUS:
case KC_LCBR:
case KC_RCBR:
case KC_PIPE:
case KC_TILD:
keycode &= 0xFF;
case KC_LSFT:
case KC_RSFT:
if (record->event.pressed) {
character_shift++;
} else {
character_shift--;
}
return false;
break;
}
switch(keycode) {
case KC_F1:
if (record->event.pressed) {
print_box_string("This is a line of text!");
}
return false;
case KC_ESC:
if (record->event.pressed) {
print_char(0x1B);
}
return false;
break;
case KC_SPC:
if (record->event.pressed) {
print_char(0x20);
}
return false;
break;
case KC_A ... KC_Z:
if (record->event.pressed) {
if (character_shift) {
print_char(0x41 + (keycode - KC_A));
} else {
print_char(0x61 + (keycode - KC_A));
}
}
return false;
break;
case KC_1 ... KC_0:
if (record->event.pressed) {
if (character_shift) {
print_char(shifted_numbers[keycode - KC_1]);
} else {
print_char(0x30 + ((keycode - KC_1 + 1) % 10));
}
}
return false;
break;
case KC_ENT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x0C);
} else {
print_char(0x0A);
}
}
return false;
break;
case KC_BSPC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x18);
} else {
print_char(0x1A);
}
}
return false;
break;
case KC_DOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3E);
} else {
print_char(0x2E);
}
}
return false;
break;
case KC_COMM:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3C);
} else {
print_char(0x2C);
}
}
return false;
break;
case KC_SLSH:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3F);
} else {
print_char(0x2F);
}
}
return false;
break;
case KC_QUOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x22);
} else {
print_char(0x27);
}
}
return false;
break;
case KC_GRV:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7E);
} else {
print_char(0x60);
}
}
return false;
break;
case KC_MINS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x5F);
} else {
print_char(0x2D);
}
}
return false;
break;
case KC_EQL:
if (record->event.pressed) {
if (character_shift) {
print_char(0x2B);
} else {
print_char(0x3D);
}
}
return false;
break;
case KC_LBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7B);
} else {
print_char(0x5B);
}
}
return false;
break;
case KC_RBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7D);
} else {
print_char(0x5D);
}
}
return false;
break;
case KC_BSLS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7C);
} else {
print_char(0x5C);
}
}
return false;
break;
}
}
return true;
if (printing_enabled) {
switch (keycode) {
case KC_EXLM ... KC_RPRN:
case KC_UNDS:
case KC_PLUS:
case KC_LCBR:
case KC_RCBR:
case KC_PIPE:
case KC_TILD:
keycode &= 0xFF;
case KC_LSFT:
case KC_RSFT:
if (record->event.pressed) {
character_shift++;
} else {
character_shift--;
}
return false;
break;
}
switch (keycode) {
case KC_F1:
if (record->event.pressed) {
print_box_string("This is a line of text!");
}
return false;
case KC_ESC:
if (record->event.pressed) {
print_char(0x1B);
}
return false;
break;
case KC_SPC:
if (record->event.pressed) {
print_char(0x20);
}
return false;
break;
case KC_A ... KC_Z:
if (record->event.pressed) {
if (character_shift) {
print_char(0x41 + (keycode - KC_A));
} else {
print_char(0x61 + (keycode - KC_A));
}
}
return false;
break;
case KC_1 ... KC_0:
if (record->event.pressed) {
if (character_shift) {
print_char(shifted_numbers[keycode - KC_1]);
} else {
print_char(0x30 + ((keycode - KC_1 + 1) % 10));
}
}
return false;
break;
case KC_ENT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x0C);
} else {
print_char(0x0A);
}
}
return false;
break;
case KC_BSPC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x18);
} else {
print_char(0x1A);
}
}
return false;
break;
case KC_DOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3E);
} else {
print_char(0x2E);
}
}
return false;
break;
case KC_COMM:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3C);
} else {
print_char(0x2C);
}
}
return false;
break;
case KC_SLSH:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3F);
} else {
print_char(0x2F);
}
}
return false;
break;
case KC_QUOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x22);
} else {
print_char(0x27);
}
}
return false;
break;
case KC_GRV:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7E);
} else {
print_char(0x60);
}
}
return false;
break;
case KC_MINS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x5F);
} else {
print_char(0x2D);
}
}
return false;
break;
case KC_EQL:
if (record->event.pressed) {
if (character_shift) {
print_char(0x2B);
} else {
print_char(0x3D);
}
}
return false;
break;
case KC_LBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7B);
} else {
print_char(0x5B);
}
}
return false;
break;
case KC_RBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7D);
} else {
print_char(0x5D);
}
}
return false;
break;
case KC_BSLS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7C);
} else {
print_char(0x5C);
}
}
return false;
break;
}
}
return true;
}

435
quantum/process_keycode/process_printer_bb.c
View file

@ -17,44 +17,29 @@
#include "process_printer.h"
#include "action_util.h"
bool printing_enabled = false;
uint8_t character_shift = 0;
bool printing_enabled = false;
uint8_t character_shift = 0;
#define SERIAL_PIN_DDR DDRD
#define SERIAL_PIN_PORT PORTD
#define SERIAL_PIN_MASK _BV(PD3)
#define SERIAL_DELAY 52
inline static
void serial_delay(void) {
_delay_us(SERIAL_DELAY);
}
inline static void serial_delay(void) { _delay_us(SERIAL_DELAY); }
inline static
void serial_high(void) {
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
inline static void serial_high(void) { SERIAL_PIN_PORT |= SERIAL_PIN_MASK; }
inline static
void serial_low(void) {
SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
}
inline static
void serial_output(void) {
SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
}
inline static void serial_low(void) { SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK; }
inline static void serial_output(void) { SERIAL_PIN_DDR |= SERIAL_PIN_MASK; }
void enable_printing() {
printing_enabled = true;
serial_output();
serial_high();
printing_enabled = true;
serial_output();
serial_high();
}
void disable_printing() {
printing_enabled = false;
}
void disable_printing() { printing_enabled = false; }
uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
@ -63,214 +48,212 @@ uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0
// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
void print_char(char c) {
uint8_t b = 8;
serial_output();
while( b-- ) {
if(c & (1 << b)) {
serial_high();
} else {
serial_low();
uint8_t b = 8;
serial_output();
while (b--) {
if (c & (1 << b)) {
serial_high();
} else {
serial_low();
}
serial_delay();
}
serial_delay();
}
}
void print_string(char c[]) {
for(uint8_t i = 0; i < strlen(c); i++)
print_char(c[i]);
for (uint8_t i = 0; i < strlen(c); i++) print_char(c[i]);
}
bool process_printer(uint16_t keycode, keyrecord_t *record) {
if (keycode == PRINT_ON) {
enable_printing();
return false;
}
if (keycode == PRINT_OFF) {
disable_printing();
return false;
}
if (keycode == PRINT_ON) {
enable_printing();
return false;
}
if (keycode == PRINT_OFF) {
disable_printing();
return false;
}
if (printing_enabled) {
switch(keycode) {
case KC_EXLM ... KC_RPRN:
case KC_UNDS:
case KC_PLUS:
case KC_LCBR:
case KC_RCBR:
case KC_PIPE:
case KC_TILD:
keycode &= 0xFF;
case KC_LSFT:
case KC_RSFT:
if (record->event.pressed) {
character_shift++;
} else {
character_shift--;
}
return false;
break;
}
switch(keycode) {
case KC_F1:
if (record->event.pressed) {
print_string("This is a line of text!\n\n\n");
}
return false;
case KC_ESC:
if (record->event.pressed) {
print_char(0x1B);
}
return false;
break;
case KC_SPC:
if (record->event.pressed) {
print_char(0x20);
}
return false;
break;
case KC_A ... KC_Z:
if (record->event.pressed) {
if (character_shift) {
print_char(0x41 + (keycode - KC_A));
} else {
print_char(0x61 + (keycode - KC_A));
}
}
return false;
break;
case KC_1 ... KC_0:
if (record->event.pressed) {
if (character_shift) {
print_char(shifted_numbers[keycode - KC_1]);
} else {
print_char(0x30 + ((keycode - KC_1 + 1) % 10));
}
}
return false;
break;
case KC_ENT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x0C);
} else {
print_char(0x0A);
}
}
return false;
break;
case KC_BSPC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x18);
} else {
print_char(0x1A);
}
}
return false;
break;
case KC_DOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3E);
} else {
print_char(0x2E);
}
}
return false;
break;
case KC_COMM:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3C);
} else {
print_char(0x2C);
}
}
return false;
break;
case KC_SLSH:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3F);
} else {
print_char(0x2F);
}
}
return false;
break;
case KC_QUOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x22);
} else {
print_char(0x27);
}
}
return false;
break;
case KC_GRV:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7E);
} else {
print_char(0x60);
}
}
return false;
break;
case KC_MINS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x5F);
} else {
print_char(0x2D);
}
}
return false;
break;
case KC_EQL:
if (record->event.pressed) {
if (character_shift) {
print_char(0x2B);
} else {
print_char(0x3D);
}
}
return false;
break;
case KC_LBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7B);
} else {
print_char(0x5B);
}
}
return false;
break;
case KC_RBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7D);
} else {
print_char(0x5D);
}
}
return false;
break;
case KC_BSLS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7C);
} else {
print_char(0x5C);
}
}
return false;
break;
}
}
return true;
if (printing_enabled) {
switch (keycode) {
case KC_EXLM ... KC_RPRN:
case KC_UNDS:
case KC_PLUS:
case KC_LCBR:
case KC_RCBR:
case KC_PIPE:
case KC_TILD:
keycode &= 0xFF;
case KC_LSFT:
case KC_RSFT:
if (record->event.pressed) {
character_shift++;
} else {
character_shift--;
}
return false;
break;
}
switch (keycode) {
case KC_F1:
if (record->event.pressed) {
print_string("This is a line of text!\n\n\n");
}
return false;
case KC_ESC:
if (record->event.pressed) {
print_char(0x1B);
}
return false;
break;
case KC_SPC:
if (record->event.pressed) {
print_char(0x20);
}
return false;
break;
case KC_A ... KC_Z:
if (record->event.pressed) {
if (character_shift) {
print_char(0x41 + (keycode - KC_A));
} else {
print_char(0x61 + (keycode - KC_A));
}
}
return false;
break;
case KC_1 ... KC_0:
if (record->event.pressed) {
if (character_shift) {
print_char(shifted_numbers[keycode - KC_1]);
} else {
print_char(0x30 + ((keycode - KC_1 + 1) % 10));
}
}
return false;
break;
case KC_ENT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x0C);
} else {
print_char(0x0A);
}
}
return false;
break;
case KC_BSPC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x18);
} else {
print_char(0x1A);
}
}
return false;
break;
case KC_DOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3E);
} else {
print_char(0x2E);
}
}
return false;
break;
case KC_COMM:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3C);
} else {
print_char(0x2C);
}
}
return false;
break;
case KC_SLSH:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3F);
} else {
print_char(0x2F);
}
}
return false;
break;
case KC_QUOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x22);
} else {
print_char(0x27);
}
}
return false;
break;
case KC_GRV:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7E);
} else {
print_char(0x60);
}
}
return false;
break;
case KC_MINS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x5F);
} else {
print_char(0x2D);
}
}
return false;
break;
case KC_EQL:
if (record->event.pressed) {
if (character_shift) {
print_char(0x2B);
} else {
print_char(0x3D);
}
}
return false;
break;
case KC_LBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7B);
} else {
print_char(0x5B);
}
}
return false;
break;
case KC_RBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7D);
} else {
print_char(0x5D);
}
}
return false;
break;
case KC_BSLS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7C);
} else {
print_char(0x5C);
}
}
return false;
break;
}
}
return true;
}

179
quantum/process_keycode/process_space_cadet.c
View file

@ -16,150 +16,149 @@
#include "process_space_cadet.h"
#ifndef TAPPING_TERM
#define TAPPING_TERM 200
# define TAPPING_TERM 200
#endif
// ********** OBSOLETE DEFINES, STOP USING! (pls?) **********
// Shift / paren setup
#ifndef LSPO_KEY
#define LSPO_KEY KC_9
# define LSPO_KEY KC_9
#endif
#ifndef RSPC_KEY
#define RSPC_KEY KC_0
# define RSPC_KEY KC_0
#endif
// Shift / Enter setup
#ifndef SFTENT_KEY
#define SFTENT_KEY KC_ENT
# define SFTENT_KEY KC_ENT
#endif
#ifdef DISABLE_SPACE_CADET_MODIFIER
#ifndef LSPO_MOD
#define LSPO_MOD KC_TRNS
#endif
#ifndef RSPC_MOD
#define RSPC_MOD KC_TRNS
#endif
# ifndef LSPO_MOD
# define LSPO_MOD KC_TRNS
# endif
# ifndef RSPC_MOD
# define RSPC_MOD KC_TRNS
# endif
#else
#ifndef LSPO_MOD
#define LSPO_MOD KC_LSFT
#endif
#ifndef RSPC_MOD
#define RSPC_MOD KC_RSFT
#endif
# ifndef LSPO_MOD
# define LSPO_MOD KC_LSFT
# endif
# ifndef RSPC_MOD
# define RSPC_MOD KC_RSFT
# endif
#endif
// **********************************************************
// Shift / paren setup
#ifndef LSPO_KEYS
#define LSPO_KEYS KC_LSFT, LSPO_MOD, LSPO_KEY
# define LSPO_KEYS KC_LSFT, LSPO_MOD, LSPO_KEY
#endif
#ifndef RSPC_KEYS
#define RSPC_KEYS KC_RSFT, RSPC_MOD, RSPC_KEY
# define RSPC_KEYS KC_RSFT, RSPC_MOD, RSPC_KEY
#endif
// Control / paren setup
#ifndef LCPO_KEYS
#define LCPO_KEYS KC_LCTL, KC_LSFT, KC_9
# define LCPO_KEYS KC_LCTL, KC_LSFT, KC_9
#endif
#ifndef RCPC_KEYS
#define RCPC_KEYS KC_RCTL, KC_RSFT, KC_0
# define RCPC_KEYS KC_RCTL, KC_RSFT, KC_0
#endif
// Alt / paren setup
#ifndef LAPO_KEYS
#define LAPO_KEYS KC_LALT, KC_LSFT, KC_9
# define LAPO_KEYS KC_LALT, KC_LSFT, KC_9
#endif
#ifndef RAPC_KEYS
#define RAPC_KEYS KC_RALT, KC_RSFT, KC_0
# define RAPC_KEYS KC_RALT, KC_RSFT, KC_0
#endif
// Shift / Enter setup
#ifndef SFTENT_KEYS
#define SFTENT_KEYS KC_RSFT, KC_TRNS, SFTENT_KEY
# define SFTENT_KEYS KC_RSFT, KC_TRNS, SFTENT_KEY
#endif
static uint8_t sc_last = 0;
static uint8_t sc_last = 0;
static uint16_t sc_timer = 0;
#ifdef SPACE_CADET_MODIFIER_CARRYOVER
static uint8_t sc_mods = 0;
#endif
void perform_space_cadet(keyrecord_t *record, uint8_t holdMod, uint8_t tapMod, uint8_t keycode) {
if (record->event.pressed) {
sc_last = holdMod;
sc_timer = timer_read ();
if (record->event.pressed) {
sc_last = holdMod;
sc_timer = timer_read();
#ifdef SPACE_CADET_MODIFIER_CARRYOVER
sc_mods = get_mods();
sc_mods = get_mods();
#endif
if (IS_MOD(holdMod)) {
register_mods(MOD_BIT(holdMod));
}
}
else {
if (sc_last == holdMod && timer_elapsed(sc_timer) < TAPPING_TERM) {
if (holdMod != tapMod) {
if (IS_MOD(holdMod)) {
unregister_mods(MOD_BIT(holdMod));
register_mods(MOD_BIT(holdMod));
}
if (IS_MOD(tapMod)) {
register_mods(MOD_BIT(tapMod));
}
}
#ifdef SPACE_CADET_MODIFIER_CARRYOVER
set_weak_mods(sc_mods);
#endif
tap_code(keycode);
#ifdef SPACE_CADET_MODIFIER_CARRYOVER
clear_weak_mods();
#endif
if (IS_MOD(tapMod)) {
unregister_mods(MOD_BIT(tapMod));
}
} else {
if (IS_MOD(holdMod)) {
unregister_mods(MOD_BIT(holdMod));
}
if (sc_last == holdMod && timer_elapsed(sc_timer) < TAPPING_TERM) {
if (holdMod != tapMod) {
if (IS_MOD(holdMod)) {
unregister_mods(MOD_BIT(holdMod));
}
if (IS_MOD(tapMod)) {
register_mods(MOD_BIT(tapMod));
}
}
#ifdef SPACE_CADET_MODIFIER_CARRYOVER
set_weak_mods(sc_mods);
#endif
tap_code(keycode);
#ifdef SPACE_CADET_MODIFIER_CARRYOVER
clear_weak_mods();
#endif
if (IS_MOD(tapMod)) {
unregister_mods(MOD_BIT(tapMod));
}
} else {
if (IS_MOD(holdMod)) {
unregister_mods(MOD_BIT(holdMod));
}
}
}
}
}
bool process_space_cadet(uint16_t keycode, keyrecord_t *record) {
switch(keycode) {
case KC_LSPO: {
perform_space_cadet(record, LSPO_KEYS);
return false;
switch (keycode) {
case KC_LSPO: {
perform_space_cadet(record, LSPO_KEYS);
return false;
}
case KC_RSPC: {
perform_space_cadet(record, RSPC_KEYS);
return false;
}
case KC_LCPO: {
perform_space_cadet(record, LCPO_KEYS);
return false;
}
case KC_RCPC: {
perform_space_cadet(record, RCPC_KEYS);
return false;
}
case KC_LAPO: {
perform_space_cadet(record, LAPO_KEYS);
return false;
}
case KC_RAPC: {
perform_space_cadet(record, RAPC_KEYS);
return false;
}
case KC_SFTENT: {
perform_space_cadet(record, SFTENT_KEYS);
return false;
}
default: {
if (record->event.pressed) {
sc_last = 0;
}
break;
}
}
case KC_RSPC: {
perform_space_cadet(record, RSPC_KEYS);
return false;
}
case KC_LCPO: {
perform_space_cadet(record, LCPO_KEYS);
return false;
}
case KC_RCPC: {
perform_space_cadet(record, RCPC_KEYS);
return false;
}
case KC_LAPO: {
perform_space_cadet(record, LAPO_KEYS);
return false;
}
case KC_RAPC: {
perform_space_cadet(record, RAPC_KEYS);
return false;
}
case KC_SFTENT: {
perform_space_cadet(record, SFTENT_KEYS);
return false;
}
default: {
if (record->event.pressed) {
sc_last = 0;
}
break;
}
}
return true;
return true;
}

204
quantum/process_keycode/process_steno.c
View file

@ -58,150 +58,136 @@
#define GEMINI_STATE_SIZE 6
#define MAX_STATE_SIZE GEMINI_STATE_SIZE
static uint8_t state[MAX_STATE_SIZE] = {0};
static uint8_t chord[MAX_STATE_SIZE] = {0};
static int8_t pressed = 0;
static uint8_t state[MAX_STATE_SIZE] = {0};
static uint8_t chord[MAX_STATE_SIZE] = {0};
static int8_t pressed = 0;
static steno_mode_t mode;
static const uint8_t boltmap[64] PROGMEM = {
TXB_NUL, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM,
TXB_S_L, TXB_S_L, TXB_T_L, TXB_K_L, TXB_P_L, TXB_W_L, TXB_H_L,
TXB_R_L, TXB_A_L, TXB_O_L, TXB_STR, TXB_STR, TXB_NUL, TXB_NUL,
TXB_NUL, TXB_STR, TXB_STR, TXB_E_R, TXB_U_R, TXB_F_R, TXB_R_R,
TXB_P_R, TXB_B_R, TXB_L_R, TXB_G_R, TXB_T_R, TXB_S_R, TXB_D_R,
TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_Z_R
};
static const uint8_t boltmap[64] PROGMEM = {TXB_NUL, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_S_L, TXB_S_L, TXB_T_L, TXB_K_L, TXB_P_L, TXB_W_L, TXB_H_L, TXB_R_L, TXB_A_L, TXB_O_L, TXB_STR, TXB_STR, TXB_NUL, TXB_NUL, TXB_NUL, TXB_STR, TXB_STR, TXB_E_R, TXB_U_R, TXB_F_R, TXB_R_R, TXB_P_R, TXB_B_R, TXB_L_R, TXB_G_R, TXB_T_R, TXB_S_R, TXB_D_R, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_NUM, TXB_Z_R};
static void steno_clear_state(void) {
memset(state, 0, sizeof(state));
memset(chord, 0, sizeof(chord));
memset(state, 0, sizeof(state));
memset(chord, 0, sizeof(chord));
}
static void send_steno_state(uint8_t size, bool send_empty) {
for (uint8_t i = 0; i < size; ++i) {
if (chord[i] || send_empty) {
virtser_send(chord[i]);
for (uint8_t i = 0; i < size; ++i) {
if (chord[i] || send_empty) {
virtser_send(chord[i]);
}
}
}
}
void steno_init() {
if (!eeconfig_is_enabled()) {
eeconfig_init();
}
mode = eeprom_read_byte(EECONFIG_STENOMODE);
if (!eeconfig_is_enabled()) {
eeconfig_init();
}
mode = eeprom_read_byte(EECONFIG_STENOMODE);
}
void steno_set_mode(steno_mode_t new_mode) {
steno_clear_state();
mode = new_mode;
eeprom_update_byte(EECONFIG_STENOMODE, mode);
steno_clear_state();
mode = new_mode;
eeprom_update_byte(EECONFIG_STENOMODE, mode);
}
/* override to intercept chords right before they get sent.
* return zero to suppress normal sending behavior.
*/
__attribute__ ((weak))
bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { return true; }
__attribute__((weak)) bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { return true; }
__attribute__ ((weak))
bool postprocess_steno_user(uint16_t keycode, keyrecord_t *record, steno_mode_t mode, uint8_t chord[6], int8_t pressed) { return true; }
__attribute__((weak)) bool postprocess_steno_user(uint16_t keycode, keyrecord_t *record, steno_mode_t mode, uint8_t chord[6], int8_t pressed) { return true; }
__attribute__ ((weak))
bool process_steno_user(uint16_t keycode, keyrecord_t *record) { return true; }
__attribute__((weak)) bool process_steno_user(uint16_t keycode, keyrecord_t *record) { return true; }
static void send_steno_chord(void) {
if (send_steno_chord_user(mode, chord)) {
switch(mode) {
case STENO_MODE_BOLT:
send_steno_state(BOLT_STATE_SIZE, false);
virtser_send(0); // terminating byte
break;
case STENO_MODE_GEMINI:
chord[0] |= 0x80; // Indicate start of packet
send_steno_state(GEMINI_STATE_SIZE, true);
break;
if (send_steno_chord_user(mode, chord)) {
switch (mode) {
case STENO_MODE_BOLT:
send_steno_state(BOLT_STATE_SIZE, false);
virtser_send(0); // terminating byte
break;
case STENO_MODE_GEMINI:
chord[0] |= 0x80; // Indicate start of packet
send_steno_state(GEMINI_STATE_SIZE, true);
break;
}
}
}
steno_clear_state();
steno_clear_state();
}
uint8_t *steno_get_state(void) {
return &state[0];
}
uint8_t *steno_get_state(void) { return &state[0]; }
uint8_t *steno_get_chord(void) {
return &chord[0];
}
uint8_t *steno_get_chord(void) { return &chord[0]; }
static bool update_state_bolt(uint8_t key, bool press) {
uint8_t boltcode = pgm_read_byte(boltmap + key);
if (press) {
state[TXB_GET_GROUP(boltcode)] |= boltcode;
chord[TXB_GET_GROUP(boltcode)] |= boltcode;
} else {
state[TXB_GET_GROUP(boltcode)] &= ~boltcode;
}
return false;
uint8_t boltcode = pgm_read_byte(boltmap + key);
if (press) {
state[TXB_GET_GROUP(boltcode)] |= boltcode;
chord[TXB_GET_GROUP(boltcode)] |= boltcode;
} else {
state[TXB_GET_GROUP(boltcode)] &= ~boltcode;
}
return false;
}
static bool update_state_gemini(uint8_t key, bool press) {
int idx = key / 7;
uint8_t bit = 1 << (6 - (key % 7));
if (press) {
state[idx] |= bit;
chord[idx] |= bit;
} else {
state[idx] &= ~bit;
}
return false;
int idx = key / 7;
uint8_t bit = 1 << (6 - (key % 7));
if (press) {
state[idx] |= bit;
chord[idx] |= bit;
} else {
state[idx] &= ~bit;
}
return false;
}
bool process_steno(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QK_STENO_BOLT:
if (!process_steno_user(keycode, record)) {
return false;
}
if (IS_PRESSED(record->event)) {
steno_set_mode(STENO_MODE_BOLT);
}
return false;
switch (keycode) {
case QK_STENO_BOLT:
if (!process_steno_user(keycode, record)) {
return false;
}
if (IS_PRESSED(record->event)) {
steno_set_mode(STENO_MODE_BOLT);
}
return false;
case QK_STENO_GEMINI:
if (!process_steno_user(keycode, record)) {
return false;
}
if (IS_PRESSED(record->event)) {
steno_set_mode(STENO_MODE_GEMINI);
}
return false;
case QK_STENO_GEMINI:
if (!process_steno_user(keycode, record)) {
return false;
}
if (IS_PRESSED(record->event)) {
steno_set_mode(STENO_MODE_GEMINI);
}
return false;
case STN__MIN...STN__MAX:
if (!process_steno_user(keycode, record)) {
return false;
}
switch(mode) {
case STENO_MODE_BOLT:
update_state_bolt(keycode - QK_STENO, IS_PRESSED(record->event));
break;
case STENO_MODE_GEMINI:
update_state_gemini(keycode - QK_STENO, IS_PRESSED(record->event));
break;
}
// allow postprocessing hooks
if (postprocess_steno_user(keycode, record, mode, chord, pressed)) {
if (IS_PRESSED(record->event)) {
++pressed;
} else {
--pressed;
if (pressed <= 0) {
pressed = 0;
send_steno_chord();
}
}
}
return false;
}
return true;
case STN__MIN ... STN__MAX:
if (!process_steno_user(keycode, record)) {
return false;
}
switch (mode) {
case STENO_MODE_BOLT:
update_state_bolt(keycode - QK_STENO, IS_PRESSED(record->event));
break;
case STENO_MODE_GEMINI:
update_state_gemini(keycode - QK_STENO, IS_PRESSED(record->event));
break;
}
// allow postprocessing hooks
if (postprocess_steno_user(keycode, record, mode, chord, pressed)) {
if (IS_PRESSED(record->event)) {
++pressed;
} else {
--pressed;
if (pressed <= 0) {
pressed = 0;
send_steno_chord();
}
}
}
return false;
}
return true;
}

8
quantum/process_keycode/process_steno.h
View file

@ -19,14 +19,14 @@
#include "quantum.h"
#if defined(STENO_ENABLE) && !defined(VIRTSER_ENABLE)
#error "must have virtser enabled to use steno"
# error "must have virtser enabled to use steno"
#endif
typedef enum { STENO_MODE_BOLT, STENO_MODE_GEMINI } steno_mode_t;
bool process_steno(uint16_t keycode, keyrecord_t *record);
void steno_init(void);
void steno_set_mode(steno_mode_t mode);
bool process_steno(uint16_t keycode, keyrecord_t *record);
void steno_init(void);
void steno_set_mode(steno_mode_t mode);
uint8_t *steno_get_state(void);
uint8_t *steno_get_chord(void);

256
quantum/process_keycode/process_tap_dance.c
View file

@ -17,7 +17,7 @@
#include "action_tapping.h"
#ifndef TAPPING_TERM
#define TAPPING_TERM 200
# define TAPPING_TERM 200
#endif
#ifndef NO_ACTION_ONESHOT
@ -25,191 +25,173 @@ uint8_t get_oneshot_mods(void);
#endif
static uint16_t last_td;
static int8_t highest_td = -1;
static int8_t highest_td = -1;
void qk_tap_dance_pair_on_each_tap (qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
void qk_tap_dance_pair_on_each_tap(qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
if (state->count == 2) {
register_code16 (pair->kc2);
state->finished = true;
}
if (state->count == 2) {
register_code16(pair->kc2);
state->finished = true;
}
}
void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
void qk_tap_dance_pair_finished(qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
if (state->count == 1) {
register_code16 (pair->kc1);
} else if (state->count == 2) {
register_code16 (pair->kc2);
}
if (state->count == 1) {
register_code16(pair->kc1);
} else if (state->count == 2) {
register_code16(pair->kc2);
}
}
void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
void qk_tap_dance_pair_reset(qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
if (state->count == 1) {
unregister_code16 (pair->kc1);
} else if (state->count == 2) {
unregister_code16 (pair->kc2);
}
if (state->count == 1) {
unregister_code16(pair->kc1);
} else if (state->count == 2) {
unregister_code16(pair->kc2);
}
}
void qk_tap_dance_dual_role_on_each_tap (qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
void qk_tap_dance_dual_role_on_each_tap(qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
if (state->count == 2) {
layer_move (pair->layer);
state->finished = true;
}
if (state->count == 2) {
layer_move(pair->layer);
state->finished = true;
}
}
void qk_tap_dance_dual_role_finished (qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
if (state->count == 1) {
register_code16 (pair->kc);
} else if (state->count == 2) {
layer_move (pair->layer);
}
if (state->count == 1) {
register_code16(pair->kc);
} else if (state->count == 2) {
layer_move(pair->layer);
}
}
void qk_tap_dance_dual_role_reset (qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
void qk_tap_dance_dual_role_reset(qk_tap_dance_state_t *state, void *user_data) {
qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data;
if (state->count == 1) {
unregister_code16 (pair->kc);
}
if (state->count == 1) {
unregister_code16(pair->kc);
}
}
static inline void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
void *user_data,
qk_tap_dance_user_fn_t fn)
{
if (fn) {
fn(state, user_data);
}
static inline void _process_tap_dance_action_fn(qk_tap_dance_state_t *state, void *user_data, qk_tap_dance_user_fn_t fn) {
if (fn) {
fn(state, user_data);
}
}
static inline void process_tap_dance_action_on_each_tap (qk_tap_dance_action_t *action)
{
_process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_each_tap);
static inline void process_tap_dance_action_on_each_tap(qk_tap_dance_action_t *action) { _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_each_tap); }
static inline void process_tap_dance_action_on_dance_finished(qk_tap_dance_action_t *action) {
if (action->state.finished) return;
action->state.finished = true;
add_mods(action->state.oneshot_mods);
add_weak_mods(action->state.weak_mods);
send_keyboard_report();
_process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_dance_finished);
}
static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_action_t *action)
{
if (action->state.finished)
return;
action->state.finished = true;
add_mods(action->state.oneshot_mods);
add_weak_mods(action->state.weak_mods);
send_keyboard_report();
_process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_dance_finished);
}
static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t *action)
{
_process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_reset);
del_mods(action->state.oneshot_mods);
del_weak_mods(action->state.weak_mods);
send_keyboard_report();
static inline void process_tap_dance_action_on_reset(qk_tap_dance_action_t *action) {
_process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_reset);
del_mods(action->state.oneshot_mods);
del_weak_mods(action->state.weak_mods);
send_keyboard_report();
}
void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
qk_tap_dance_action_t *action;
qk_tap_dance_action_t *action;
if (!record->event.pressed)
return;
if (!record->event.pressed) return;
if (highest_td == -1)
return;
if (highest_td == -1) return;
for (int i = 0; i <= highest_td; i++) {
action = &tap_dance_actions[i];
if (action->state.count) {
if (keycode == action->state.keycode && keycode == last_td)
continue;
action->state.interrupted = true;
action->state.interrupting_keycode = keycode;
process_tap_dance_action_on_dance_finished (action);
reset_tap_dance (&action->state);
for (int i = 0; i <= highest_td; i++) {
action = &tap_dance_actions[i];
if (action->state.count) {
if (keycode == action->state.keycode && keycode == last_td) continue;
action->state.interrupted = true;
action->state.interrupting_keycode = keycode;
process_tap_dance_action_on_dance_finished(action);
reset_tap_dance(&action->state);
}
}
}
}
bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
uint16_t idx = keycode - QK_TAP_DANCE;
qk_tap_dance_action_t *action;
uint16_t idx = keycode - QK_TAP_DANCE;
qk_tap_dance_action_t *action;
switch(keycode) {
case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
if ((int16_t)idx > highest_td)
highest_td = idx;
action = &tap_dance_actions[idx];
switch (keycode) {
case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
if ((int16_t)idx > highest_td) highest_td = idx;
action = &tap_dance_actions[idx];
action->state.pressed = record->event.pressed;
if (record->event.pressed) {
action->state.keycode = keycode;
action->state.count++;
action->state.timer = timer_read();
action->state.pressed = record->event.pressed;
if (record->event.pressed) {
action->state.keycode = keycode;
action->state.count++;
action->state.timer = timer_read();
#ifndef NO_ACTION_ONESHOT
action->state.oneshot_mods = get_oneshot_mods();
action->state.oneshot_mods = get_oneshot_mods();
#else
action->state.oneshot_mods = 0;
action->state.oneshot_mods = 0;
#endif
action->state.weak_mods = get_mods();
action->state.weak_mods |= get_weak_mods();
process_tap_dance_action_on_each_tap (action);
action->state.weak_mods = get_mods();
action->state.weak_mods |= get_weak_mods();
process_tap_dance_action_on_each_tap(action);
last_td = keycode;
} else {
if (action->state.count && action->state.finished) {
reset_tap_dance (&action->state);
}
last_td = keycode;
} else {
if (action->state.count && action->state.finished) {
reset_tap_dance(&action->state);
}
}
break;
}
break;
}
return true;
return true;
}
void matrix_scan_tap_dance() {
if (highest_td == -1) return;
uint16_t tap_user_defined;
void matrix_scan_tap_dance () {
if (highest_td == -1)
return;
uint16_t tap_user_defined;
for (uint8_t i = 0; i <= highest_td; i++) {
qk_tap_dance_action_t *action = &tap_dance_actions[i];
if(action->custom_tapping_term > 0 ) {
tap_user_defined = action->custom_tapping_term;
for (uint8_t i = 0; i <= highest_td; i++) {
qk_tap_dance_action_t *action = &tap_dance_actions[i];
if (action->custom_tapping_term > 0) {
tap_user_defined = action->custom_tapping_term;
} else {
tap_user_defined = TAPPING_TERM;
}
if (action->state.count && timer_elapsed(action->state.timer) > tap_user_defined) {
process_tap_dance_action_on_dance_finished(action);
reset_tap_dance(&action->state);
}
}
else{
tap_user_defined = TAPPING_TERM;
}
if (action->state.count && timer_elapsed (action->state.timer) > tap_user_defined) {
process_tap_dance_action_on_dance_finished (action);
reset_tap_dance (&action->state);
}
}
}
void reset_tap_dance (qk_tap_dance_state_t *state) {
qk_tap_dance_action_t *action;
void reset_tap_dance(qk_tap_dance_state_t *state) {
qk_tap_dance_action_t *action;
if (state->pressed)
return;
if (state->pressed) return;
action = &tap_dance_actions[state->keycode - QK_TAP_DANCE];
action = &tap_dance_actions[state->keycode - QK_TAP_DANCE];
process_tap_dance_action_on_reset (action);
process_tap_dance_action_on_reset(action);
state->count = 0;
state->interrupted = false;
state->finished = false;
state->interrupting_keycode = 0;
last_td = 0;
state->count = 0;
state->interrupted = false;
state->finished = false;
state->interrupting_keycode = 0;
last_td = 0;
}

111
quantum/process_keycode/process_tap_dance.h
View file

@ -18,75 +18,60 @@
#ifdef TAP_DANCE_ENABLE
#include <stdbool.h>
#include <inttypes.h>
# include <stdbool.h>
# include <inttypes.h>
typedef struct
{
uint8_t count;
uint8_t oneshot_mods;
uint8_t weak_mods;
uint16_t keycode;
uint16_t interrupting_keycode;
uint16_t timer;
bool interrupted;
bool pressed;
bool finished;
typedef struct {
uint8_t count;
uint8_t oneshot_mods;
uint8_t weak_mods;
uint16_t keycode;
uint16_t interrupting_keycode;
uint16_t timer;
bool interrupted;
bool pressed;
bool finished;
} qk_tap_dance_state_t;
#define TD(n) (QK_TAP_DANCE | ((n) & 0xFF))
# define TD(n) (QK_TAP_DANCE | ((n)&0xFF))
typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state, void *user_data);
typedef void (*qk_tap_dance_user_fn_t)(qk_tap_dance_state_t *state, void *user_data);
typedef struct
{
struct {
qk_tap_dance_user_fn_t on_each_tap;
qk_tap_dance_user_fn_t on_dance_finished;
qk_tap_dance_user_fn_t on_reset;
} fn;
qk_tap_dance_state_t state;
uint16_t custom_tapping_term;
void *user_data;
typedef struct {
struct {
qk_tap_dance_user_fn_t on_each_tap;
qk_tap_dance_user_fn_t on_dance_finished;
qk_tap_dance_user_fn_t on_reset;
} fn;
qk_tap_dance_state_t state;
uint16_t custom_tapping_term;
void * user_data;
} qk_tap_dance_action_t;
typedef struct
{
uint16_t kc1;
uint16_t kc2;
typedef struct {
uint16_t kc1;
uint16_t kc2;
} qk_tap_dance_pair_t;
typedef struct
{
uint16_t kc;
uint8_t layer;
typedef struct {
uint16_t kc;
uint8_t layer;
} qk_tap_dance_dual_role_t;
#define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) { \
.fn = { qk_tap_dance_pair_on_each_tap, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset }, \
.user_data = (void *)&((qk_tap_dance_pair_t) { kc1, kc2 }), \
}
# define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) \
{ .fn = {qk_tap_dance_pair_on_each_tap, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset}, .user_data = (void *)&((qk_tap_dance_pair_t){kc1, kc2}), }
#define ACTION_TAP_DANCE_DUAL_ROLE(kc, layer) { \
.fn = { qk_tap_dance_dual_role_on_each_tap, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset }, \
.user_data = (void *)&((qk_tap_dance_dual_role_t) { kc, layer }), \
}
# define ACTION_TAP_DANCE_DUAL_ROLE(kc, layer) \
{ .fn = {qk_tap_dance_dual_role_on_each_tap, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset}, .user_data = (void *)&((qk_tap_dance_dual_role_t){kc, layer}), }
#define ACTION_TAP_DANCE_FN(user_fn) { \
.fn = { NULL, user_fn, NULL }, \
.user_data = NULL, \
}
# define ACTION_TAP_DANCE_FN(user_fn) \
{ .fn = {NULL, user_fn, NULL}, .user_data = NULL, }
#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \
.fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \
.user_data = NULL, \
}
# define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) \
{ .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset}, .user_data = NULL, }
#define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) { \
.fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \
.user_data = NULL, \
.custom_tapping_term = tap_specific_tapping_term, \
}
# define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) \
{ .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset}, .user_data = NULL, .custom_tapping_term = tap_specific_tapping_term, }
extern qk_tap_dance_action_t tap_dance_actions[];
@ -94,20 +79,20 @@ extern qk_tap_dance_action_t tap_dance_actions[];
void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record);
bool process_tap_dance(uint16_t keycode, keyrecord_t *record);
void matrix_scan_tap_dance (void);
void reset_tap_dance (qk_tap_dance_state_t *state);
void matrix_scan_tap_dance(void);
void reset_tap_dance(qk_tap_dance_state_t *state);
void qk_tap_dance_pair_on_each_tap (qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_pair_on_each_tap(qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_pair_finished(qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_pair_reset(qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_dual_role_on_each_tap (qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_dual_role_finished (qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_dual_role_reset (qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_dual_role_on_each_tap(qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_data);
void qk_tap_dance_dual_role_reset(qk_tap_dance_state_t *state, void *user_data);
#else
#define TD(n) KC_NO
# define TD(n) KC_NO
#endif

267
quantum/process_keycode/process_terminal.c
View file

@ -21,62 +21,45 @@
#include <math.h>
#ifndef CMD_BUFF_SIZE
#define CMD_BUFF_SIZE 5
# define CMD_BUFF_SIZE 5
#endif
bool terminal_enabled = false;
char buffer[80] = "";
char buffer[80] = "";
char cmd_buffer[CMD_BUFF_SIZE][80];
bool cmd_buffer_enabled = true; //replace with ifdef?
char newline[2] = "\n";
bool cmd_buffer_enabled = true; // replace with ifdef?
char newline[2] = "\n";
char arguments[6][20];
bool firstTime = true;
short int current_cmd_buffer_pos = 0; //used for up/down arrows - keeps track of where you are in the command buffer
short int current_cmd_buffer_pos = 0; // used for up/down arrows - keeps track of where you are in the command buffer
__attribute__ ((weak))
const char terminal_prompt[8] = "> ";
__attribute__((weak)) const char terminal_prompt[8] = "> ";
#ifdef AUDIO_ENABLE
#ifndef TERMINAL_SONG
#define TERMINAL_SONG SONG(TERMINAL_SOUND)
#endif
float terminal_song[][2] = TERMINAL_SONG;
#define TERMINAL_BELL() PLAY_SONG(terminal_song)
# ifndef TERMINAL_SONG
# define TERMINAL_SONG SONG(TERMINAL_SOUND)
# endif
float terminal_song[][2] = TERMINAL_SONG;
# define TERMINAL_BELL() PLAY_SONG(terminal_song)
#else
#define TERMINAL_BELL()
# define TERMINAL_BELL()
#endif
__attribute__ ((weak))
const char keycode_to_ascii_lut[58] = {
0, 0, 0, 0,
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 0, 0, 0, '\t',
' ', '-', '=', '[', ']', '\\', 0, ';', '\'', '`', ',', '.', '/'
};
__attribute__((weak)) const char keycode_to_ascii_lut[58] = {0, 0, 0, 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 0, 0, 0, '\t', ' ', '-', '=', '[', ']', '\\', 0, ';', '\'', '`', ',', '.', '/'};
__attribute__ ((weak))
const char shifted_keycode_to_ascii_lut[58] = {
0, 0, 0, 0,
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'!', '@', '#', '$', '%', '^', '&', '*', '(', ')', 0, 0, 0, '\t',
' ', '_', '+', '{', '}', '|', 0, ':', '\'', '~', '<', '>', '?'
};
__attribute__((weak)) const char shifted_keycode_to_ascii_lut[58] = {0, 0, 0, 0, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', 0, 0, 0, '\t', ' ', '_', '+', '{', '}', '|', 0, ':', '\'', '~', '<', '>', '?'};
struct stringcase {
char* string;
char *string;
void (*func)(void);
} typedef stringcase;
void enable_terminal(void) {
terminal_enabled = true;
strcpy(buffer, "");
memset(cmd_buffer,0,CMD_BUFF_SIZE * 80);
for (int i = 0; i < 6; i++)
strcpy(arguments[i], "");
memset(cmd_buffer, 0, CMD_BUFF_SIZE * 80);
for (int i = 0; i < 6; i++) strcpy(arguments[i], "");
// select all text to start over
// SEND_STRING(SS_LCTRL("a"));
send_string(terminal_prompt);
@ -88,41 +71,41 @@ void disable_terminal(void) {
}
void push_to_cmd_buffer(void) {
if (cmd_buffer_enabled) {
if (cmd_buffer == NULL) {
return;
} else {
if (firstTime) {
firstTime = false;
strcpy(cmd_buffer[0],buffer);
return;
}
if (cmd_buffer_enabled) {
if (cmd_buffer == NULL) {
return;
} else {
if (firstTime) {
firstTime = false;
strcpy(cmd_buffer[0], buffer);
return;
}
for (int i= CMD_BUFF_SIZE - 1;i > 0 ;--i) {
strncpy(cmd_buffer[i],cmd_buffer[i-1],80);
}
for (int i = CMD_BUFF_SIZE - 1; i > 0; --i) {
strncpy(cmd_buffer[i], cmd_buffer[i - 1], 80);
}
strcpy(cmd_buffer[0],buffer);
strcpy(cmd_buffer[0], buffer);
return;
return;
}
}
}
}
void terminal_about(void) {
SEND_STRING("QMK Firmware\n");
SEND_STRING(" v");
SEND_STRING(QMK_VERSION);
SEND_STRING("\n"SS_TAP(X_HOME)" Built: ");
SEND_STRING("\n" SS_TAP(X_HOME) " Built: ");
SEND_STRING(QMK_BUILDDATE);
send_string(newline);
#ifdef TERMINAL_HELP
if (strlen(arguments[1]) != 0) {
SEND_STRING("You entered: ");
send_string(arguments[1]);
send_string(newline);
}
#endif
#ifdef TERMINAL_HELP
if (strlen(arguments[1]) != 0) {
SEND_STRING("You entered: ");
send_string(arguments[1]);
send_string(newline);
}
#endif
}
void terminal_help(void);
@ -131,11 +114,11 @@ extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
void terminal_keycode(void) {
if (strlen(arguments[1]) != 0 && strlen(arguments[2]) != 0 && strlen(arguments[3]) != 0) {
char keycode_dec[5];
char keycode_hex[5];
uint16_t layer = strtol(arguments[1], (char **)NULL, 10);
uint16_t row = strtol(arguments[2], (char **)NULL, 10);
uint16_t col = strtol(arguments[3], (char **)NULL, 10);
char keycode_dec[5];
char keycode_hex[5];
uint16_t layer = strtol(arguments[1], (char **)NULL, 10);
uint16_t row = strtol(arguments[2], (char **)NULL, 10);
uint16_t col = strtol(arguments[3], (char **)NULL, 10);
uint16_t keycode = pgm_read_word(&keymaps[layer][row][col]);
itoa(keycode, keycode_dec, 10);
itoa(keycode, keycode_hex, 16);
@ -145,9 +128,9 @@ void terminal_keycode(void) {
send_string(keycode_dec);
SEND_STRING(")\n");
} else {
#ifdef TERMINAL_HELP
SEND_STRING("usage: keycode <layer> <row> <col>\n");
#endif
#ifdef TERMINAL_HELP
SEND_STRING("usage: keycode <layer> <row> <col>\n");
#endif
}
}
@ -157,53 +140,44 @@ void terminal_keymap(void) {
for (int r = 0; r < MATRIX_ROWS; r++) {
for (int c = 0; c < MATRIX_COLS; c++) {
uint16_t keycode = pgm_read_word(&keymaps[layer][r][c]);
char keycode_s[8];
char keycode_s[8];
sprintf(keycode_s, "0x%04x,", keycode);
send_string(keycode_s);
}
send_string(newline);
}
} else {
#ifdef TERMINAL_HELP
SEND_STRING("usage: keymap <layer>\n");
#endif
#ifdef TERMINAL_HELP
SEND_STRING("usage: keymap <layer>\n");
#endif
}
}
void print_cmd_buff(void) {
/* without the below wait, a race condition can occur wherein the
buffer can be printed before it has been fully moved */
wait_ms(250);
for(int i=0;i<CMD_BUFF_SIZE;i++){
char tmpChar = ' ';
itoa(i ,&tmpChar,10);
const char * tmpCnstCharStr = &tmpChar; //because sned_string wont take a normal char *
send_string(tmpCnstCharStr);
SEND_STRING(". ");
send_string(cmd_buffer[i]);
SEND_STRING("\n");
}
/* without the below wait, a race condition can occur wherein the
buffer can be printed before it has been fully moved */
wait_ms(250);
for (int i = 0; i < CMD_BUFF_SIZE; i++) {
char tmpChar = ' ';
itoa(i, &tmpChar, 10);
const char *tmpCnstCharStr = &tmpChar; // because sned_string wont take a normal char *
send_string(tmpCnstCharStr);
SEND_STRING(". ");
send_string(cmd_buffer[i]);
SEND_STRING("\n");
}
}
void flush_cmd_buffer(void) {
memset(cmd_buffer,0,CMD_BUFF_SIZE * 80);
SEND_STRING("Buffer Cleared!\n");
memset(cmd_buffer, 0, CMD_BUFF_SIZE * 80);
SEND_STRING("Buffer Cleared!\n");
}
stringcase terminal_cases[] = {
{ "about", terminal_about },
{ "help", terminal_help },
{ "keycode", terminal_keycode },
{ "keymap", terminal_keymap },
{ "flush-buffer" , flush_cmd_buffer},
{ "print-buffer" , print_cmd_buff},
{ "exit", disable_terminal }
};
stringcase terminal_cases[] = {{"about", terminal_about}, {"help", terminal_help}, {"keycode", terminal_keycode}, {"keymap", terminal_keymap}, {"flush-buffer", flush_cmd_buffer}, {"print-buffer", print_cmd_buff}, {"exit", disable_terminal}};
void terminal_help(void) {
SEND_STRING("commands available:\n ");
for( stringcase* case_p = terminal_cases; case_p != terminal_cases + sizeof( terminal_cases ) / sizeof( terminal_cases[0] ); case_p++ ) {
for (stringcase *case_p = terminal_cases; case_p != terminal_cases + sizeof(terminal_cases) / sizeof(terminal_cases[0]); case_p++) {
send_string(case_p->string);
SEND_STRING(" ");
}
@ -211,7 +185,7 @@ void terminal_help(void) {
}
void command_not_found(void) {
wait_ms(50); //sometimes buffer isnt grabbed quick enough
wait_ms(50); // sometimes buffer isnt grabbed quick enough
SEND_STRING("command \"");
send_string(buffer);
SEND_STRING("\" not found\n");
@ -221,9 +195,9 @@ void process_terminal_command(void) {
// we capture return bc of the order of events, so we need to manually send a newline
send_string(newline);
char * pch;
char * pch;
uint8_t i = 0;
pch = strtok(buffer, " ");
pch = strtok(buffer, " ");
while (pch != NULL) {
strcpy(arguments[i], pch);
pch = strtok(NULL, " ");
@ -231,38 +205,32 @@ void process_terminal_command(void) {
}
bool command_found = false;
for( stringcase* case_p = terminal_cases; case_p != terminal_cases + sizeof( terminal_cases ) / sizeof( terminal_cases[0] ); case_p++ ) {
if( 0 == strcmp( case_p->string, buffer ) ) {
for (stringcase *case_p = terminal_cases; case_p != terminal_cases + sizeof(terminal_cases) / sizeof(terminal_cases[0]); case_p++) {
if (0 == strcmp(case_p->string, buffer)) {
command_found = true;
(*case_p->func)();
break;
}
}
if (!command_found)
command_not_found();
if (!command_found) command_not_found();
if (terminal_enabled) {
strcpy(buffer, "");
for (int i = 0; i < 6; i++)
strcpy(arguments[i], "");
for (int i = 0; i < 6; i++) strcpy(arguments[i], "");
SEND_STRING(SS_TAP(X_HOME));
send_string(terminal_prompt);
}
}
void check_pos(void) {
if (current_cmd_buffer_pos >= CMD_BUFF_SIZE) { //if over the top, move it back down to the top of the buffer so you can climb back down...
current_cmd_buffer_pos = CMD_BUFF_SIZE - 1;
} else if (current_cmd_buffer_pos < 0) { //...and if you fall under the bottom of the buffer, reset back to 0 so you can climb back up
current_cmd_buffer_pos = 0;
}
if (current_cmd_buffer_pos >= CMD_BUFF_SIZE) { // if over the top, move it back down to the top of the buffer so you can climb back down...
current_cmd_buffer_pos = CMD_BUFF_SIZE - 1;
} else if (current_cmd_buffer_pos < 0) { //...and if you fall under the bottom of the buffer, reset back to 0 so you can climb back up
current_cmd_buffer_pos = 0;
}
}
bool process_terminal(uint16_t keycode, keyrecord_t *record) {
if (keycode == TERM_ON && record->event.pressed) {
enable_terminal();
return false;
@ -280,59 +248,66 @@ bool process_terminal(uint16_t keycode, keyrecord_t *record) {
if (keycode < 256) {
uint8_t str_len;
char char_to_add;
char char_to_add;
switch (keycode) {
case KC_ENTER:
case KC_KP_ENTER:
push_to_cmd_buffer();
current_cmd_buffer_pos = 0;
process_terminal_command();
return false; break;
return false;
break;
case KC_ESC:
SEND_STRING("\n");
enable_terminal();
return false; break;
return false;
break;
case KC_BSPC:
str_len = strlen(buffer);
if (str_len > 0) {
buffer[str_len-1] = 0;
buffer[str_len - 1] = 0;
return true;
} else {
TERMINAL_BELL();
return false;
} break;
}
break;
case KC_LEFT:
return false; break;
return false;
break;
case KC_RIGHT:
return false; break;
case KC_UP: // 0 = recent
check_pos(); //check our current buffer position is valid
if (current_cmd_buffer_pos <= CMD_BUFF_SIZE - 1) { //once we get to the top, dont do anything
str_len = strlen(buffer);
for(int i= 0;i < str_len ;++i) {
send_string(SS_TAP(X_BSPACE)); //clear w/e is on the line already
//process_terminal(KC_BSPC,record);
}
strncpy(buffer,cmd_buffer[current_cmd_buffer_pos],80);
return false;
break;
case KC_UP: // 0 = recent
check_pos(); // check our current buffer position is valid
if (current_cmd_buffer_pos <= CMD_BUFF_SIZE - 1) { // once we get to the top, dont do anything
str_len = strlen(buffer);
for (int i = 0; i < str_len; ++i) {
send_string(SS_TAP(X_BSPACE)); // clear w/e is on the line already
// process_terminal(KC_BSPC,record);
}
strncpy(buffer, cmd_buffer[current_cmd_buffer_pos], 80);
send_string(buffer);
++current_cmd_buffer_pos; //get ready to access the above cmd if up/down is pressed again
}
return false; break;
send_string(buffer);
++current_cmd_buffer_pos; // get ready to access the above cmd if up/down is pressed again
}
return false;
break;
case KC_DOWN:
check_pos();
if (current_cmd_buffer_pos >= 0) { //once we get to the bottom, dont do anything
str_len = strlen(buffer);
for(int i= 0;i < str_len ;++i) {
send_string(SS_TAP(X_BSPACE)); //clear w/e is on the line already
//process_terminal(KC_BSPC,record);
}
strncpy(buffer,cmd_buffer[current_cmd_buffer_pos],79);
check_pos();
if (current_cmd_buffer_pos >= 0) { // once we get to the bottom, dont do anything
str_len = strlen(buffer);
for (int i = 0; i < str_len; ++i) {
send_string(SS_TAP(X_BSPACE)); // clear w/e is on the line already
// process_terminal(KC_BSPC,record);
}
strncpy(buffer, cmd_buffer[current_cmd_buffer_pos], 79);
send_string(buffer);
--current_cmd_buffer_pos; //get ready to access the above cmd if down/up is pressed again
send_string(buffer);
--current_cmd_buffer_pos; // get ready to access the above cmd if down/up is pressed again
}
return false; break;
return false;
break;
default:
if (keycode <= 58) {
char_to_add = 0;
@ -344,11 +319,9 @@ bool process_terminal(uint16_t keycode, keyrecord_t *record) {
if (char_to_add != 0) {
strncat(buffer, &char_to_add, 1);
}
} break;
}
break;
}
}
}
return true;

2
quantum/process_keycode/process_terminal.h
View file

@ -22,6 +22,6 @@
extern const char keycode_to_ascii_lut[58];
extern const char shifted_keycode_to_ascii_lut[58];
extern const char terminal_prompt[8];
bool process_terminal(uint16_t keycode, keyrecord_t *record);
bool process_terminal(uint16_t keycode, keyrecord_t *record);
#endif

223
quantum/process_keycode/process_ucis.c
View file

@ -19,144 +19,133 @@
qk_ucis_state_t qk_ucis_state;
void qk_ucis_start(void) {
qk_ucis_state.count = 0;
qk_ucis_state.in_progress = true;
qk_ucis_state.count = 0;
qk_ucis_state.in_progress = true;
qk_ucis_start_user();
qk_ucis_start_user();
}
__attribute__((weak))
void qk_ucis_start_user(void) {
unicode_input_start();
register_hex(0x2328);
unicode_input_finish();
__attribute__((weak)) void qk_ucis_start_user(void) {
unicode_input_start();
register_hex(0x2328);
unicode_input_finish();
}
__attribute__((weak))
void qk_ucis_success(uint8_t symbol_index) {
}
__attribute__((weak)) void qk_ucis_success(uint8_t symbol_index) {}
static bool is_uni_seq(char *seq) {
uint8_t i;
uint8_t i;
for (i = 0; seq[i]; i++) {
uint16_t code;
if (('1' <= seq[i]) && (seq[i] <= '0'))
code = seq[i] - '1' + KC_1;
else
code = seq[i] - 'a' + KC_A;
for (i = 0; seq[i]; i++) {
uint16_t code;
if (('1' <= seq[i]) && (seq[i] <= '0'))
code = seq[i] - '1' + KC_1;
else
code = seq[i] - 'a' + KC_A;
if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
return false;
}
if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code) return false;
}
return (qk_ucis_state.codes[i] == KC_ENT ||
qk_ucis_state.codes[i] == KC_SPC);
return (qk_ucis_state.codes[i] == KC_ENT || qk_ucis_state.codes[i] == KC_SPC);
}
__attribute__((weak))
void qk_ucis_symbol_fallback (void) {
for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
uint8_t code = qk_ucis_state.codes[i];
register_code(code);
unregister_code(code);
wait_ms(UNICODE_TYPE_DELAY);
}
__attribute__((weak)) void qk_ucis_symbol_fallback(void) {
for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
uint8_t code = qk_ucis_state.codes[i];
register_code(code);
unregister_code(code);
wait_ms(UNICODE_TYPE_DELAY);
}
}
__attribute__((weak))
void qk_ucis_cancel(void) {
}
__attribute__((weak)) void qk_ucis_cancel(void) {}
void register_ucis(const char *hex) {
for(int i = 0; hex[i]; i++) {
uint8_t kc = 0;
char c = hex[i];
for (int i = 0; hex[i]; i++) {
uint8_t kc = 0;
char c = hex[i];
switch (c) {
case '0':
kc = KC_0;
break;
case '1' ... '9':
kc = c - '1' + KC_1;
break;
case 'a' ... 'f':
kc = c - 'a' + KC_A;
break;
case 'A' ... 'F':
kc = c - 'A' + KC_A;
break;
}
switch (c) {
case '0':
kc = KC_0;
break;
case '1' ... '9':
kc = c - '1' + KC_1;
break;
case 'a' ... 'f':
kc = c - 'a' + KC_A;
break;
case 'A' ... 'F':
kc = c - 'A' + KC_A;
break;
}
if (kc) {
register_code (kc);
unregister_code (kc);
wait_ms (UNICODE_TYPE_DELAY);
if (kc) {
register_code(kc);
unregister_code(kc);
wait_ms(UNICODE_TYPE_DELAY);
}
}
}
}
bool process_ucis (uint16_t keycode, keyrecord_t *record) {
uint8_t i;
bool process_ucis(uint16_t keycode, keyrecord_t *record) {
uint8_t i;
if (!qk_ucis_state.in_progress)
if (!qk_ucis_state.in_progress) return true;
if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH && !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
return false;
}
if (!record->event.pressed) return true;
qk_ucis_state.codes[qk_ucis_state.count] = keycode;
qk_ucis_state.count++;
if (keycode == KC_BSPC) {
if (qk_ucis_state.count >= 2) {
qk_ucis_state.count -= 2;
return true;
} else {
qk_ucis_state.count--;
return false;
}
}
if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
bool symbol_found = false;
for (i = qk_ucis_state.count; i > 0; i--) {
register_code(KC_BSPC);
unregister_code(KC_BSPC);
wait_ms(UNICODE_TYPE_DELAY);
}
if (keycode == KC_ESC) {
qk_ucis_state.in_progress = false;
qk_ucis_cancel();
return false;
}
unicode_input_start();
for (i = 0; ucis_symbol_table[i].symbol; i++) {
if (is_uni_seq(ucis_symbol_table[i].symbol)) {
symbol_found = true;
register_ucis(ucis_symbol_table[i].code + 2);
break;
}
}
if (!symbol_found) {
qk_ucis_symbol_fallback();
}
unicode_input_finish();
if (symbol_found) {
qk_ucis_success(i);
}
qk_ucis_state.in_progress = false;
return false;
}
return true;
if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
!(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
return false;
}
if (!record->event.pressed)
return true;
qk_ucis_state.codes[qk_ucis_state.count] = keycode;
qk_ucis_state.count++;
if (keycode == KC_BSPC) {
if (qk_ucis_state.count >= 2) {
qk_ucis_state.count -= 2;
return true;
} else {
qk_ucis_state.count--;
return false;
}
}
if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
bool symbol_found = false;
for (i = qk_ucis_state.count; i > 0; i--) {
register_code (KC_BSPC);
unregister_code (KC_BSPC);
wait_ms(UNICODE_TYPE_DELAY);
}
if (keycode == KC_ESC) {
qk_ucis_state.in_progress = false;
qk_ucis_cancel();
return false;
}
unicode_input_start();
for (i = 0; ucis_symbol_table[i].symbol; i++) {
if (is_uni_seq (ucis_symbol_table[i].symbol)) {
symbol_found = true;
register_ucis(ucis_symbol_table[i].code + 2);
break;
}
}
if (!symbol_found) {
qk_ucis_symbol_fallback();
}
unicode_input_finish();
if (symbol_found) {
qk_ucis_success(i);
}
qk_ucis_state.in_progress = false;
return false;
}
return true;
}

24
quantum/process_keycode/process_ucis.h
View file

@ -20,30 +20,34 @@
#include "process_unicode_common.h"
#ifndef UCIS_MAX_SYMBOL_LENGTH
#define UCIS_MAX_SYMBOL_LENGTH 32
# define UCIS_MAX_SYMBOL_LENGTH 32
#endif
typedef struct {
char *symbol;
char *code;
char *symbol;
char *code;
} qk_ucis_symbol_t;
typedef struct {
uint8_t count;
uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
bool in_progress:1;
uint8_t count;
uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
bool in_progress : 1;
} qk_ucis_state_t;
extern qk_ucis_state_t qk_ucis_state;
#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
#define UCIS_SYM(name, code) {name, #code}
#define UCIS_TABLE(...) \
{ \
__VA_ARGS__, { NULL, NULL } \
}
#define UCIS_SYM(name, code) \
{ name, #code }
extern const qk_ucis_symbol_t ucis_symbol_table[];
void qk_ucis_start(void);
void qk_ucis_start_user(void);
void qk_ucis_symbol_fallback (void);
void qk_ucis_symbol_fallback(void);
void qk_ucis_success(uint8_t symbol_index);
void register_ucis(const char *hex);
bool process_ucis (uint16_t keycode, keyrecord_t *record);
bool process_ucis(uint16_t keycode, keyrecord_t *record);

12
quantum/process_keycode/process_unicode.c
View file

@ -19,10 +19,10 @@
#include "eeprom.h"
bool process_unicode(uint16_t keycode, keyrecord_t *record) {
if (keycode >= QK_UNICODE && keycode <= QK_UNICODE_MAX && record->event.pressed) {
unicode_input_start();
register_hex(keycode & 0x7FFF);
unicode_input_finish();
}
return true;
if (keycode >= QK_UNICODE && keycode <= QK_UNICODE_MAX && record->event.pressed) {
unicode_input_start();
register_hex(keycode & 0x7FFF);
unicode_input_finish();
}
return true;
}

315
quantum/process_keycode/process_unicode_common.c
View file

@ -23,220 +23,215 @@ unicode_config_t unicode_config;
uint8_t unicode_saved_mods;
#if UNICODE_SELECTED_MODES != -1
static uint8_t selected[] = { UNICODE_SELECTED_MODES };
static uint8_t selected[] = {UNICODE_SELECTED_MODES};
static uint8_t selected_count = sizeof selected / sizeof *selected;
static uint8_t selected_index;
#endif
void unicode_input_mode_init(void) {
unicode_config.raw = eeprom_read_byte(EECONFIG_UNICODEMODE);
unicode_config.raw = eeprom_read_byte(EECONFIG_UNICODEMODE);
#if UNICODE_SELECTED_MODES != -1
#if UNICODE_CYCLE_PERSIST
// Find input_mode in selected modes
uint8_t i;
for (i = 0; i < selected_count; i++) {
if (selected[i] == unicode_config.input_mode) {
selected_index = i;
break;
# if UNICODE_CYCLE_PERSIST
// Find input_mode in selected modes
uint8_t i;
for (i = 0; i < selected_count; i++) {
if (selected[i] == unicode_config.input_mode) {
selected_index = i;
break;
}
}
}
if (i == selected_count) {
// Not found: input_mode isn't selected, change to one that is
if (i == selected_count) {
// Not found: input_mode isn't selected, change to one that is
unicode_config.input_mode = selected[selected_index = 0];
}
# else
// Always change to the first selected input mode
unicode_config.input_mode = selected[selected_index = 0];
}
#else
// Always change to the first selected input mode
unicode_config.input_mode = selected[selected_index = 0];
#endif
# endif
#endif
dprintf("Unicode input mode init to: %u\n", unicode_config.input_mode);
dprintf("Unicode input mode init to: %u\n", unicode_config.input_mode);
}
uint8_t get_unicode_input_mode(void) {
return unicode_config.input_mode;
}
uint8_t get_unicode_input_mode(void) { return unicode_config.input_mode; }
void set_unicode_input_mode(uint8_t mode) {
unicode_config.input_mode = mode;
persist_unicode_input_mode();
dprintf("Unicode input mode set to: %u\n", unicode_config.input_mode);
unicode_config.input_mode = mode;
persist_unicode_input_mode();
dprintf("Unicode input mode set to: %u\n", unicode_config.input_mode);
}
void cycle_unicode_input_mode(uint8_t offset) {
#if UNICODE_SELECTED_MODES != -1
selected_index = (selected_index + offset) % selected_count;
unicode_config.input_mode = selected[selected_index];
#if UNICODE_CYCLE_PERSIST
persist_unicode_input_mode();
#endif
dprintf("Unicode input mode cycle to: %u\n", unicode_config.input_mode);
selected_index = (selected_index + offset) % selected_count;
unicode_config.input_mode = selected[selected_index];
# if UNICODE_CYCLE_PERSIST
persist_unicode_input_mode();
# endif
dprintf("Unicode input mode cycle to: %u\n", unicode_config.input_mode);
#endif
}
void persist_unicode_input_mode(void) {
eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode);
void persist_unicode_input_mode(void) { eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode); }
__attribute__((weak)) void unicode_input_start(void) {
unicode_saved_mods = get_mods(); // Save current mods
clear_mods(); // Unregister mods to start from a clean state
switch (unicode_config.input_mode) {
case UC_OSX:
register_code(UNICODE_KEY_OSX);
break;
case UC_LNX:
tap_code16(UNICODE_KEY_LNX);
break;
case UC_WIN:
register_code(KC_LALT);
tap_code(KC_PPLS);
break;
case UC_WINC:
tap_code(UNICODE_KEY_WINC);
tap_code(KC_U);
break;
}
wait_ms(UNICODE_TYPE_DELAY);
}
__attribute__((weak))
void unicode_input_start(void) {
unicode_saved_mods = get_mods(); // Save current mods
clear_mods(); // Unregister mods to start from a clean state
__attribute__((weak)) void unicode_input_finish(void) {
switch (unicode_config.input_mode) {
case UC_OSX:
unregister_code(UNICODE_KEY_OSX);
break;
case UC_LNX:
tap_code(KC_SPC);
break;
case UC_WIN:
unregister_code(KC_LALT);
break;
case UC_WINC:
tap_code(KC_ENTER);
break;
}
switch (unicode_config.input_mode) {
case UC_OSX:
register_code(UNICODE_KEY_OSX);
break;
case UC_LNX:
tap_code16(UNICODE_KEY_LNX);
break;
case UC_WIN:
register_code(KC_LALT);
tap_code(KC_PPLS);
break;
case UC_WINC:
tap_code(UNICODE_KEY_WINC);
tap_code(KC_U);
break;
}
wait_ms(UNICODE_TYPE_DELAY);
set_mods(unicode_saved_mods); // Reregister previously set mods
}
__attribute__((weak))
void unicode_input_finish(void) {
switch (unicode_config.input_mode) {
case UC_OSX:
unregister_code(UNICODE_KEY_OSX);
break;
case UC_LNX:
tap_code(KC_SPC);
break;
case UC_WIN:
unregister_code(KC_LALT);
break;
case UC_WINC:
tap_code(KC_ENTER);
break;
}
__attribute__((weak)) void unicode_input_cancel(void) {
switch (unicode_config.input_mode) {
case UC_OSX:
unregister_code(UNICODE_KEY_OSX);
break;
case UC_LNX:
case UC_WINC:
tap_code(KC_ESC);
break;
case UC_WIN:
unregister_code(KC_LALT);
break;
}
set_mods(unicode_saved_mods); // Reregister previously set mods
set_mods(unicode_saved_mods); // Reregister previously set mods
}
__attribute__((weak))
void unicode_input_cancel(void) {
switch (unicode_config.input_mode) {
case UC_OSX:
unregister_code(UNICODE_KEY_OSX);
break;
case UC_LNX:
case UC_WINC:
tap_code(KC_ESC);
break;
case UC_WIN:
unregister_code(KC_LALT);
break;
}
set_mods(unicode_saved_mods); // Reregister previously set mods
}
__attribute__((weak))
uint16_t hex_to_keycode(uint8_t hex) {
if (hex == 0x0) {
return KC_0;
} else if (hex < 0xA) {
return KC_1 + (hex - 0x1);
} else {
return KC_A + (hex - 0xA);
}
__attribute__((weak)) uint16_t hex_to_keycode(uint8_t hex) {
if (hex == 0x0) {
return KC_0;
} else if (hex < 0xA) {
return KC_1 + (hex - 0x1);
} else {
return KC_A + (hex - 0xA);
}
}
void register_hex(uint16_t hex) {
for(int i = 3; i >= 0; i--) {
uint8_t digit = ((hex >> (i*4)) & 0xF);
tap_code(hex_to_keycode(digit));
}
for (int i = 3; i >= 0; i--) {
uint8_t digit = ((hex >> (i * 4)) & 0xF);
tap_code(hex_to_keycode(digit));
}
}
void send_unicode_hex_string(const char *str) {
if (!str) { return; }
while (*str) {
// Find the next code point (token) in the string
for (; *str == ' '; str++);
size_t n = strcspn(str, " "); // Length of the current token
char code_point[n+1];
strncpy(code_point, str, n);
code_point[n] = '\0'; // Make sure it's null-terminated
// Normalize the code point: make all hex digits lowercase
for (char *p = code_point; *p; p++) {
*p = tolower((unsigned char)*p);
if (!str) {
return;
}
// Send the code point as a Unicode input string
unicode_input_start();
send_string(code_point);
unicode_input_finish();
while (*str) {
// Find the next code point (token) in the string
for (; *str == ' '; str++)
;
size_t n = strcspn(str, " "); // Length of the current token
char code_point[n + 1];
strncpy(code_point, str, n);
code_point[n] = '\0'; // Make sure it's null-terminated
str += n; // Move to the first ' ' (or '\0') after the current token
}
// Normalize the code point: make all hex digits lowercase
for (char *p = code_point; *p; p++) {
*p = tolower((unsigned char)*p);
}
// Send the code point as a Unicode input string
unicode_input_start();
send_string(code_point);
unicode_input_finish();
str += n; // Move to the first ' ' (or '\0') after the current token
}
}
bool process_unicode_common(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
switch (keycode) {
case UNICODE_MODE_FORWARD:
cycle_unicode_input_mode(+1);
break;
case UNICODE_MODE_REVERSE:
cycle_unicode_input_mode(-1);
break;
if (record->event.pressed) {
switch (keycode) {
case UNICODE_MODE_FORWARD:
cycle_unicode_input_mode(+1);
break;
case UNICODE_MODE_REVERSE:
cycle_unicode_input_mode(-1);
break;
case UNICODE_MODE_OSX:
set_unicode_input_mode(UC_OSX);
case UNICODE_MODE_OSX:
set_unicode_input_mode(UC_OSX);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_OSX)
static float song_osx[][2] = UNICODE_SONG_OSX;
PLAY_SONG(song_osx);
static float song_osx[][2] = UNICODE_SONG_OSX;
PLAY_SONG(song_osx);
#endif
break;
case UNICODE_MODE_LNX:
set_unicode_input_mode(UC_LNX);
break;
case UNICODE_MODE_LNX:
set_unicode_input_mode(UC_LNX);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_LNX)
static float song_lnx[][2] = UNICODE_SONG_LNX;
PLAY_SONG(song_lnx);
static float song_lnx[][2] = UNICODE_SONG_LNX;
PLAY_SONG(song_lnx);
#endif
break;
case UNICODE_MODE_WIN:
set_unicode_input_mode(UC_WIN);
break;
case UNICODE_MODE_WIN:
set_unicode_input_mode(UC_WIN);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WIN)
static float song_win[][2] = UNICODE_SONG_WIN;
PLAY_SONG(song_win);
static float song_win[][2] = UNICODE_SONG_WIN;
PLAY_SONG(song_win);
#endif
break;
case UNICODE_MODE_BSD:
set_unicode_input_mode(UC_BSD);
break;
case UNICODE_MODE_BSD:
set_unicode_input_mode(UC_BSD);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_BSD)
static float song_bsd[][2] = UNICODE_SONG_BSD;
PLAY_SONG(song_bsd);
static float song_bsd[][2] = UNICODE_SONG_BSD;
PLAY_SONG(song_bsd);
#endif
break;
case UNICODE_MODE_WINC:
set_unicode_input_mode(UC_WINC);
break;
case UNICODE_MODE_WINC:
set_unicode_input_mode(UC_WINC);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WINC)
static float song_winc[][2] = UNICODE_SONG_WINC;
PLAY_SONG(song_winc);
static float song_winc[][2] = UNICODE_SONG_WINC;
PLAY_SONG(song_winc);
#endif
break;
break;
}
}
}
#if defined(UNICODE_ENABLE)
return process_unicode(keycode, record);
#if defined(UNICODE_ENABLE)
return process_unicode(keycode, record);
#elif defined(UNICODEMAP_ENABLE)
return process_unicodemap(keycode, record);
return process_unicodemap(keycode, record);
#elif defined(UCIS_ENABLE)
return process_ucis(keycode, record);
return process_ucis(keycode, record);
#else
return true;
return true;
#endif
}

232
quantum/process_keycode/process_unicode_common.h
View file

@ -19,60 +19,60 @@
#include "quantum.h"
#if defined(UNICODE_ENABLE) + defined(UNICODEMAP_ENABLE) + defined(UCIS_ENABLE) > 1
#error "Cannot enable more than one Unicode method (UNICODE, UNICODEMAP, UCIS) at the same time"
# error "Cannot enable more than one Unicode method (UNICODE, UNICODEMAP, UCIS) at the same time"
#endif
// Keycodes used for starting Unicode input on different platforms
#ifndef UNICODE_KEY_OSX
#define UNICODE_KEY_OSX KC_LALT
# define UNICODE_KEY_OSX KC_LALT
#endif
#ifndef UNICODE_KEY_LNX
#define UNICODE_KEY_LNX LCTL(LSFT(KC_U))
# define UNICODE_KEY_LNX LCTL(LSFT(KC_U))
#endif
#ifndef UNICODE_KEY_WINC
#define UNICODE_KEY_WINC KC_RALT
# define UNICODE_KEY_WINC KC_RALT
#endif
// Comma-delimited, ordered list of input modes selected for use (e.g. in cycle)
// Example: #define UNICODE_SELECTED_MODES UC_WINC, UC_LNX
#ifndef UNICODE_SELECTED_MODES
#define UNICODE_SELECTED_MODES -1
# define UNICODE_SELECTED_MODES -1
#endif
// Whether input mode changes in cycle should be written to EEPROM
#ifndef UNICODE_CYCLE_PERSIST
#define UNICODE_CYCLE_PERSIST true
# define UNICODE_CYCLE_PERSIST true
#endif
// Delay between starting Unicode input and sending a sequence, in ms
#ifndef UNICODE_TYPE_DELAY
#define UNICODE_TYPE_DELAY 10
# define UNICODE_TYPE_DELAY 10
#endif
enum unicode_input_modes {
UC_OSX, // Mac OS X using Unicode Hex Input
UC_LNX, // Linux using IBus
UC_WIN, // Windows using EnableHexNumpad
UC_BSD, // BSD (not implemented)
UC_WINC, // Windows using WinCompose (https://github.com/samhocevar/wincompose)
UC__COUNT // Number of available input modes (always leave at the end)
UC_OSX, // Mac OS X using Unicode Hex Input
UC_LNX, // Linux using IBus
UC_WIN, // Windows using EnableHexNumpad
UC_BSD, // BSD (not implemented)
UC_WINC, // Windows using WinCompose (https://github.com/samhocevar/wincompose)
UC__COUNT // Number of available input modes (always leave at the end)
};
typedef union {
uint32_t raw;
struct {
uint8_t input_mode : 8;
};
uint32_t raw;
struct {
uint8_t input_mode : 8;
};
} unicode_config_t;
extern unicode_config_t unicode_config;
extern uint8_t unicode_saved_mods;
void unicode_input_mode_init(void);
void unicode_input_mode_init(void);
uint8_t get_unicode_input_mode(void);
void set_unicode_input_mode(uint8_t mode);
void cycle_unicode_input_mode(uint8_t offset);
void persist_unicode_input_mode(void);
void set_unicode_input_mode(uint8_t mode);
void cycle_unicode_input_mode(uint8_t offset);
void persist_unicode_input_mode(void);
void unicode_input_start(void);
void unicode_input_finish(void);
@ -83,108 +83,108 @@ void send_unicode_hex_string(const char *str);
bool process_unicode_common(uint16_t keycode, keyrecord_t *record);
#define UC_BSPC UC(0x0008)
#define UC_SPC UC(0x0020)
#define UC_BSPC UC(0x0008)
#define UC_SPC UC(0x0020)
#define UC_EXLM UC(0x0021)
#define UC_DQUT UC(0x0022)
#define UC_HASH UC(0x0023)
#define UC_DLR UC(0x0024)
#define UC_PERC UC(0x0025)
#define UC_AMPR UC(0x0026)
#define UC_QUOT UC(0x0027)
#define UC_LPRN UC(0x0028)
#define UC_RPRN UC(0x0029)
#define UC_ASTR UC(0x002A)
#define UC_PLUS UC(0x002B)
#define UC_COMM UC(0x002C)
#define UC_DASH UC(0x002D)
#define UC_DOT UC(0x002E)
#define UC_SLSH UC(0x002F)
#define UC_EXLM UC(0x0021)
#define UC_DQUT UC(0x0022)
#define UC_HASH UC(0x0023)
#define UC_DLR UC(0x0024)
#define UC_PERC UC(0x0025)
#define UC_AMPR UC(0x0026)
#define UC_QUOT UC(0x0027)
#define UC_LPRN UC(0x0028)
#define UC_RPRN UC(0x0029)
#define UC_ASTR UC(0x002A)
#define UC_PLUS UC(0x002B)
#define UC_COMM UC(0x002C)
#define UC_DASH UC(0x002D)
#define UC_DOT UC(0x002E)
#define UC_SLSH UC(0x002F)
#define UC_0 UC(0x0030)
#define UC_1 UC(0x0031)
#define UC_2 UC(0x0032)
#define UC_3 UC(0x0033)
#define UC_4 UC(0x0034)
#define UC_5 UC(0x0035)
#define UC_6 UC(0x0036)
#define UC_7 UC(0x0037)
#define UC_8 UC(0x0038)
#define UC_9 UC(0x0039)
#define UC_0 UC(0x0030)
#define UC_1 UC(0x0031)
#define UC_2 UC(0x0032)
#define UC_3 UC(0x0033)
#define UC_4 UC(0x0034)
#define UC_5 UC(0x0035)
#define UC_6 UC(0x0036)
#define UC_7 UC(0x0037)
#define UC_8 UC(0x0038)
#define UC_9 UC(0x0039)
#define UC_COLN UC(0x003A)
#define UC_SCLN UC(0x003B)
#define UC_LT UC(0x003C)
#define UC_EQL UC(0x003D)
#define UC_GT UC(0x003E)
#define UC_QUES UC(0x003F)
#define UC_AT UC(0x0040)
#define UC_LT UC(0x003C)
#define UC_EQL UC(0x003D)
#define UC_GT UC(0x003E)
#define UC_QUES UC(0x003F)
#define UC_AT UC(0x0040)
#define UC_A UC(0x0041)
#define UC_B UC(0x0042)
#define UC_C UC(0x0043)
#define UC_D UC(0x0044)
#define UC_E UC(0x0045)
#define UC_F UC(0x0046)
#define UC_G UC(0x0047)
#define UC_H UC(0x0048)
#define UC_I UC(0x0049)
#define UC_J UC(0x004A)
#define UC_K UC(0x004B)
#define UC_L UC(0x004C)
#define UC_M UC(0x004D)
#define UC_N UC(0x004E)
#define UC_O UC(0x004F)
#define UC_P UC(0x0050)
#define UC_Q UC(0x0051)
#define UC_R UC(0x0052)
#define UC_S UC(0x0053)
#define UC_T UC(0x0054)
#define UC_U UC(0x0055)
#define UC_V UC(0x0056)
#define UC_W UC(0x0057)
#define UC_X UC(0x0058)
#define UC_Y UC(0x0059)
#define UC_Z UC(0x005A)
#define UC_A UC(0x0041)
#define UC_B UC(0x0042)
#define UC_C UC(0x0043)
#define UC_D UC(0x0044)
#define UC_E UC(0x0045)
#define UC_F UC(0x0046)
#define UC_G UC(0x0047)
#define UC_H UC(0x0048)
#define UC_I UC(0x0049)
#define UC_J UC(0x004A)
#define UC_K UC(0x004B)
#define UC_L UC(0x004C)
#define UC_M UC(0x004D)
#define UC_N UC(0x004E)
#define UC_O UC(0x004F)
#define UC_P UC(0x0050)
#define UC_Q UC(0x0051)
#define UC_R UC(0x0052)
#define UC_S UC(0x0053)
#define UC_T UC(0x0054)
#define UC_U UC(0x0055)
#define UC_V UC(0x0056)
#define UC_W UC(0x0057)
#define UC_X UC(0x0058)
#define UC_Y UC(0x0059)
#define UC_Z UC(0x005A)
#define UC_LBRC UC(0x005B)
#define UC_BSLS UC(0x005C)
#define UC_RBRC UC(0x005D)
#define UC_CIRM UC(0x005E)
#define UC_UNDR UC(0x005F)
#define UC_LBRC UC(0x005B)
#define UC_BSLS UC(0x005C)
#define UC_RBRC UC(0x005D)
#define UC_CIRM UC(0x005E)
#define UC_UNDR UC(0x005F)
#define UC_GRV UC(0x0060)
#define UC_GRV UC(0x0060)
#define UC_a UC(0x0061)
#define UC_b UC(0x0062)
#define UC_c UC(0x0063)
#define UC_d UC(0x0064)
#define UC_e UC(0x0065)
#define UC_f UC(0x0066)
#define UC_g UC(0x0067)
#define UC_h UC(0x0068)
#define UC_i UC(0x0069)
#define UC_j UC(0x006A)
#define UC_k UC(0x006B)
#define UC_l UC(0x006C)
#define UC_m UC(0x006D)
#define UC_n UC(0x006E)
#define UC_o UC(0x006F)
#define UC_p UC(0x0070)
#define UC_q UC(0x0071)
#define UC_r UC(0x0072)
#define UC_s UC(0x0073)
#define UC_t UC(0x0074)
#define UC_u UC(0x0075)
#define UC_v UC(0x0076)
#define UC_w UC(0x0077)
#define UC_x UC(0x0078)
#define UC_y UC(0x0079)
#define UC_z UC(0x007A)
#define UC_a UC(0x0061)
#define UC_b UC(0x0062)
#define UC_c UC(0x0063)
#define UC_d UC(0x0064)
#define UC_e UC(0x0065)
#define UC_f UC(0x0066)
#define UC_g UC(0x0067)
#define UC_h UC(0x0068)
#define UC_i UC(0x0069)
#define UC_j UC(0x006A)
#define UC_k UC(0x006B)
#define UC_l UC(0x006C)
#define UC_m UC(0x006D)
#define UC_n UC(0x006E)
#define UC_o UC(0x006F)
#define UC_p UC(0x0070)
#define UC_q UC(0x0071)
#define UC_r UC(0x0072)
#define UC_s UC(0x0073)
#define UC_t UC(0x0074)
#define UC_u UC(0x0075)
#define UC_v UC(0x0076)
#define UC_w UC(0x0077)
#define UC_x UC(0x0078)
#define UC_y UC(0x0079)
#define UC_z UC(0x007A)
#define UC_LCBR UC(0x007B)
#define UC_PIPE UC(0x007C)
#define UC_RCBR UC(0x007D)
#define UC_TILD UC(0x007E)
#define UC_DEL UC(0x007F)
#define UC_LCBR UC(0x007B)
#define UC_PIPE UC(0x007C)
#define UC_RCBR UC(0x007D)
#define UC_TILD UC(0x007E)
#define UC_DEL UC(0x007F)

95
quantum/process_keycode/process_unicodemap.c
View file

@ -17,62 +17,63 @@
#include "process_unicodemap.h"
void register_hex32(uint32_t hex) {
bool onzerostart = true;
for(int i = 7; i >= 0; i--) {
if (i <= 3) {
onzerostart = false;
bool onzerostart = true;
for (int i = 7; i >= 0; i--) {
if (i <= 3) {
onzerostart = false;
}
uint8_t digit = ((hex >> (i * 4)) & 0xF);
if (digit == 0) {
if (!onzerostart) {
register_code(hex_to_keycode(digit));
unregister_code(hex_to_keycode(digit));
}
} else {
register_code(hex_to_keycode(digit));
unregister_code(hex_to_keycode(digit));
onzerostart = false;
}
}
uint8_t digit = ((hex >> (i*4)) & 0xF);
if (digit == 0) {
if (!onzerostart) {
register_code(hex_to_keycode(digit));
unregister_code(hex_to_keycode(digit));
}
} else {
register_code(hex_to_keycode(digit));
unregister_code(hex_to_keycode(digit));
onzerostart = false;
}
}
}
__attribute__((weak))
uint16_t unicodemap_index(uint16_t keycode) {
if (keycode >= QK_UNICODEMAP_PAIR) {
// Keycode is a pair: extract index based on Shift / Caps Lock state
uint16_t index = keycode - QK_UNICODEMAP_PAIR;
__attribute__((weak)) uint16_t unicodemap_index(uint16_t keycode) {
if (keycode >= QK_UNICODEMAP_PAIR) {
// Keycode is a pair: extract index based on Shift / Caps Lock state
uint16_t index = keycode - QK_UNICODEMAP_PAIR;
bool shift = unicode_saved_mods & MOD_MASK_SHIFT, caps = IS_HOST_LED_ON(USB_LED_CAPS_LOCK);
if (shift ^ caps) { index >>= 7; }
bool shift = unicode_saved_mods & MOD_MASK_SHIFT, caps = IS_HOST_LED_ON(USB_LED_CAPS_LOCK);
if (shift ^ caps) {
index >>= 7;
}
return index & 0x7F;
} else {
// Keycode is a regular index
return keycode - QK_UNICODEMAP;
}
return index & 0x7F;
} else {
// Keycode is a regular index
return keycode - QK_UNICODEMAP;
}
}
bool process_unicodemap(uint16_t keycode, keyrecord_t *record) {
if (keycode >= QK_UNICODEMAP && keycode <= QK_UNICODEMAP_PAIR_MAX && record->event.pressed) {
unicode_input_start();
if (keycode >= QK_UNICODEMAP && keycode <= QK_UNICODEMAP_PAIR_MAX && record->event.pressed) {
unicode_input_start();
uint32_t code = pgm_read_dword(unicode_map + unicodemap_index(keycode));
uint8_t input_mode = get_unicode_input_mode();
uint32_t code = pgm_read_dword(unicode_map + unicodemap_index(keycode));
uint8_t input_mode = get_unicode_input_mode();
if (code > 0x10FFFF || (code > 0xFFFF && input_mode == UC_WIN)) {
// Character is out of range supported by the platform
unicode_input_cancel();
} else if (code > 0xFFFF && input_mode == UC_OSX) {
// Convert to UTF-16 surrogate pair on Mac
code -= 0x10000;
uint32_t lo = code & 0x3FF, hi = (code & 0xFFC00) >> 10;
register_hex32(hi + 0xD800);
register_hex32(lo + 0xDC00);
unicode_input_finish();
} else {
register_hex32(code);
unicode_input_finish();
if (code > 0x10FFFF || (code > 0xFFFF && input_mode == UC_WIN)) {
// Character is out of range supported by the platform
unicode_input_cancel();
} else if (code > 0xFFFF && input_mode == UC_OSX) {
// Convert to UTF-16 surrogate pair on Mac
code -= 0x10000;
uint32_t lo = code & 0x3FF, hi = (code & 0xFFC00) >> 10;
register_hex32(hi + 0xD800);
register_hex32(lo + 0xDC00);
unicode_input_finish();
} else {
register_hex32(code);
unicode_input_finish();
}
}
}
return true;
return true;
}

4
quantum/process_keycode/process_unicodemap.h
View file

@ -20,6 +20,6 @@
extern const uint32_t PROGMEM unicode_map[];
void register_hex32(uint32_t hex);
void register_hex32(uint32_t hex);
uint16_t unicodemap_index(uint16_t keycode);
bool process_unicodemap(uint16_t keycode, keyrecord_t *record);
bool process_unicodemap(uint16_t keycode, keyrecord_t *record);