summaryrefslogtreecommitdiff
path: root/quantum
diff options
context:
space:
mode:
authordbroqua <dbroqua@mousur.org>2017-04-02 23:27:57 +0200
committerdbroqua <dbroqua@mousur.org>2017-04-02 23:27:57 +0200
commite7347ff0de93ff823462b3ff2b4136b44dc576c0 (patch)
tree286e2a78fee74eb370641a981d2c81c8e02942b4 /quantum
parent9e72b7e7e97f9ae92c7eb1de66aa03cad047baf6 (diff)
parent24ec8f509703cbaf9de7b41d251dbb7fcd339559 (diff)
Merge remote-tracking branch 'origin/master'
Diffstat (limited to 'quantum')
-rw-r--r--quantum/audio/voices.c1
-rw-r--r--quantum/config_common.h6
-rw-r--r--quantum/fauxclicky.c68
-rw-r--r--quantum/fauxclicky.h99
-rw-r--r--quantum/keymap_common.c10
-rw-r--r--quantum/keymap_extras/keymap_br_abnt2.h16
-rw-r--r--quantum/keymap_extras/keymap_french.h4
-rwxr-xr-xquantum/light_ws2812.c6
-rw-r--r--quantum/matrix.c14
-rw-r--r--quantum/process_keycode/process_combo.c134
-rw-r--r--quantum/process_keycode/process_combo.h43
-rw-r--r--quantum/process_keycode/process_tap_dance.c7
-rw-r--r--quantum/process_keycode/process_tap_dance.h1
-rw-r--r--quantum/process_keycode/process_ucis.c133
-rw-r--r--quantum/process_keycode/process_ucis.h35
-rw-r--r--quantum/process_keycode/process_unicode.c276
-rw-r--r--quantum/process_keycode/process_unicode.h160
-rw-r--r--quantum/process_keycode/process_unicode_common.c85
-rw-r--r--quantum/process_keycode/process_unicode_common.h132
-rw-r--r--quantum/process_keycode/process_unicodemap.c56
-rw-r--r--quantum/process_keycode/process_unicodemap.h9
-rw-r--r--quantum/quantum.c204
-rw-r--r--quantum/quantum.h15
-rw-r--r--quantum/quantum_keycodes.h58
-rw-r--r--quantum/rgblight.c35
-rw-r--r--quantum/rgblight.h11
-rw-r--r--quantum/template/config.h2
-rw-r--r--quantum/template/rules.mk1
28 files changed, 1120 insertions, 501 deletions
diff --git a/quantum/audio/voices.c b/quantum/audio/voices.c
index 8326e91eaa..c2edb75f01 100644
--- a/quantum/audio/voices.c
+++ b/quantum/audio/voices.c
@@ -24,6 +24,7 @@ void voice_deiterate() {
float voice_envelope(float frequency) {
// envelope_index ranges from 0 to 0xFFFF, which is preserved at 880.0 Hz
+ __attribute__ ((unused))
uint16_t compensated_index = (uint16_t)((float)envelope_index * (880.0 / frequency));
switch (voice) {
diff --git a/quantum/config_common.h b/quantum/config_common.h
index 4bdb2065d9..28f68b9c70 100644
--- a/quantum/config_common.h
+++ b/quantum/config_common.h
@@ -2,8 +2,10 @@
#define CONFIG_DEFINITIONS_H
/* diode directions */
-#define COL2ROW 0
-#define ROW2COL 1
+#define COL2ROW 0
+#define ROW2COL 1
+#define CUSTOM_MATRIX 2 /* Disables built-in matrix scanning code */
+
/* I/O pins */
#ifndef F0
#define B0 0x30
diff --git a/quantum/fauxclicky.c b/quantum/fauxclicky.c
new file mode 100644
index 0000000000..13273e7058
--- /dev/null
+++ b/quantum/fauxclicky.c
@@ -0,0 +1,68 @@
+/*
+Copyright 2017 Priyadi Iman Nurcahyo
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <avr/interrupt.h>
+#include <avr/io.h>
+#include <timer.h>
+#include <fauxclicky.h>
+#include <stdbool.h>
+#include <musical_notes.h>
+
+__attribute__ ((weak))
+float fauxclicky_pressed_note[2] = MUSICAL_NOTE(_F3, 2);
+__attribute__ ((weak))
+float fauxclicky_released_note[2] = MUSICAL_NOTE(_A3, 2);
+__attribute__ ((weak))
+float fauxclicky_beep_note[2] = MUSICAL_NOTE(_C3, 2);
+
+bool fauxclicky_enabled = true;
+uint16_t note_start = 0;
+bool note_playing = false;
+uint16_t note_period = 0;
+
+void fauxclicky_init()
+{
+ // Set port PC6 (OC3A and /OC4A) as output
+ DDRC |= _BV(PORTC6);
+
+ // TCCR3A / TCCR3B: Timer/Counter #3 Control Registers
+ TCCR3A = (0 << COM3A1) | (0 << COM3A0) | (1 << WGM31) | (0 << WGM30);
+ TCCR3B = (1 << WGM33) | (1 << WGM32) | (0 << CS32) | (1 << CS31) | (0 << CS30);
+}
+
+void fauxclicky_stop()
+{
+ FAUXCLICKY_DISABLE_OUTPUT;
+ note_playing = false;
+}
+
+void fauxclicky_play(float note[2]) {
+ if (!fauxclicky_enabled) return;
+ if (note_playing) fauxclicky_stop();
+ FAUXCLICKY_TIMER_PERIOD = (uint16_t)(((float)F_CPU) / (note[0] * FAUXCLICKY_CPU_PRESCALER));
+ FAUXCLICKY_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (note[0] * FAUXCLICKY_CPU_PRESCALER)) / 2);
+ note_playing = true;
+ note_period = (note[1] / 16) * (60 / (float)FAUXCLICKY_TEMPO) * 100; // check this
+ note_start = timer_read();
+ FAUXCLICKY_ENABLE_OUTPUT;
+}
+
+void fauxclicky_check() {
+ if (!note_playing) return;
+
+ if (timer_elapsed(note_start) > note_period) {
+ fauxclicky_stop();
+ }
+}
diff --git a/quantum/fauxclicky.h b/quantum/fauxclicky.h
new file mode 100644
index 0000000000..109bd0d83e
--- /dev/null
+++ b/quantum/fauxclicky.h
@@ -0,0 +1,99 @@
+/*
+Copyright 2017 Priyadi Iman Nurcahyo
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef AUDIO_ENABLE
+#error "AUDIO_ENABLE and FAUXCLICKY_ENABLE cannot be both enabled"
+#endif
+
+#include "musical_notes.h"
+#include "stdbool.h"
+
+__attribute__ ((weak))
+float fauxclicky_pressed_note[2];
+__attribute__ ((weak))
+float fauxclicky_released_note[2];
+__attribute__ ((weak))
+float fauxclicky_beep_note[2];
+
+bool fauxclicky_enabled;
+
+//
+// tempo in BPM
+//
+
+#ifndef FAUXCLICKY_TEMPO
+#define FAUXCLICKY_TEMPO TEMPO_DEFAULT
+#endif
+
+// beep on press
+#define FAUXCLICKY_ACTION_PRESS fauxclicky_play(fauxclicky_pressed_note)
+
+// beep on release
+#define FAUXCLICKY_ACTION_RELEASE fauxclicky_play(fauxclicky_released_note)
+
+// general purpose beep
+#define FAUXCLICKY_BEEP fauxclicky_play(fauxclicky_beep_note)
+
+// enable
+#define FAUXCLICKY_ON fauxclicky_enabled = true
+
+// disable
+#define FAUXCLICKY_OFF do { \
+ fauxclicky_enabled = false; \
+ fauxclicky_stop(); \
+} while (0)
+
+// toggle
+#define FAUXCLICKY_TOGGLE do { \
+ if (fauxclicky_enabled) { \
+ FAUXCLICKY_OFF; \
+ } else { \
+ FAUXCLICKY_ON; \
+ } \
+} while (0)
+
+//
+// pin configuration
+//
+
+#ifndef FAUXCLICKY_CPU_PRESCALER
+#define FAUXCLICKY_CPU_PRESCALER 8
+#endif
+
+#ifndef FAUXCLICKY_ENABLE_OUTPUT
+#define FAUXCLICKY_ENABLE_OUTPUT TCCR3A |= _BV(COM3A1);
+#endif
+
+#ifndef FAUXCLICKY_DISABLE_OUTPUT
+#define FAUXCLICKY_DISABLE_OUTPUT TCCR3A &= ~(_BV(COM3A1) | _BV(COM3A0));
+#endif
+
+#ifndef FAUXCLICKY_TIMER_PERIOD
+#define FAUXCLICKY_TIMER_PERIOD ICR3
+#endif
+
+#ifndef FAUXCLICKY_DUTY_CYCLE
+#define FAUXCLICKY_DUTY_CYCLE OCR3A
+#endif
+
+//
+// definitions
+//
+
+void fauxclicky_init(void);
+void fauxclicky_stop(void);
+void fauxclicky_play(float note[2]);
+void fauxclicky_check(void);
+
diff --git a/quantum/keymap_common.c b/quantum/keymap_common.c
index eced3d2bba..002eabd85e 100644
--- a/quantum/keymap_common.c
+++ b/quantum/keymap_common.c
@@ -80,7 +80,10 @@ action_t action_for_key(uint8_t layer, keypos_t key)
action.code = keymap_function_id_to_action( (int)keycode & 0xFFF );
break;
case QK_MACRO ... QK_MACRO_MAX:
- action.code = ACTION_MACRO(keycode & 0xFF);
+ if (keycode & 0x800) // tap macros have upper bit set
+ action.code = ACTION_MACRO_TAP(keycode & 0xFF);
+ else
+ action.code = ACTION_MACRO(keycode & 0xFF);
break;
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
action.code = ACTION_LAYER_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF);
@@ -116,8 +119,11 @@ action_t action_for_key(uint8_t layer, keypos_t key)
mod = keycode & 0xFF;
action.code = ACTION_MODS_ONESHOT(mod);
break;
+ case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX:
+ action.code = ACTION_LAYER_TAP_TOGGLE(keycode & 0xFF);
+ break;
case QK_MOD_TAP ... QK_MOD_TAP_MAX:
- action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0xF, keycode & 0xFF);
+ action.code = ACTION_MODS_TAP_KEY((keycode >> 0x8) & 0x1F, keycode & 0xFF);
break;
#ifdef BACKLIGHT_ENABLE
case BL_0 ... BL_15:
diff --git a/quantum/keymap_extras/keymap_br_abnt2.h b/quantum/keymap_extras/keymap_br_abnt2.h
index 0df177721d..b001139dd4 100644
--- a/quantum/keymap_extras/keymap_br_abnt2.h
+++ b/quantum/keymap_extras/keymap_br_abnt2.h
@@ -1,3 +1,19 @@
+/* Copyright 2017 Potiguar Faga
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
#ifndef KEYMAP_BR_ABNT2_H
#define KEYMAP_BR_ABNT2_H
diff --git a/quantum/keymap_extras/keymap_french.h b/quantum/keymap_extras/keymap_french.h
index 834c69650e..401bbdf644 100644
--- a/quantum/keymap_extras/keymap_french.h
+++ b/quantum/keymap_extras/keymap_french.h
@@ -4,7 +4,9 @@
#include "keymap.h"
// Alt gr
+#ifndef ALGR
#define ALGR(kc) RALT(kc)
+#endif
#define NO_ALGR KC_RALT
// Normal characters
@@ -72,7 +74,7 @@
#define FR_PIPE ALGR(KC_6)
#define FR_GRV ALGR(KC_7)
#define FR_BSLS ALGR(KC_8)
-#define FR_CIRC ALGR(KC_9)
+#define FR_CCIRC ALGR(KC_9)
#define FR_AT ALGR(KC_0)
#define FR_RBRC ALGR(FR_RPRN)
#define FR_RCBR ALGR(FR_EQL)
diff --git a/quantum/light_ws2812.c b/quantum/light_ws2812.c
index a883b13884..55bdd9cd81 100755
--- a/quantum/light_ws2812.c
+++ b/quantum/light_ws2812.c
@@ -70,7 +70,7 @@ void I2C_WriteBit(unsigned char c)
// Inits bitbanging port, must be called before using the functions below
//
-void I2C_Init()
+void I2C_Init(void)
{
I2C_PORT &= ~ ((1 << I2C_DAT) | (1 << I2C_CLK));
@@ -82,7 +82,7 @@ void I2C_Init()
// Send a START Condition
//
-void I2C_Start()
+void I2C_Start(void)
{
// set both to high at the same time
I2C_DDR &= ~ ((1 << I2C_DAT) | (1 << I2C_CLK));
@@ -97,7 +97,7 @@ void I2C_Start()
// Send a STOP Condition
//
-void I2C_Stop()
+void I2C_Stop(void)
{
I2C_CLOCK_HI();
_delay_us(I2C_DELAY);
diff --git a/quantum/matrix.c b/quantum/matrix.c
index 07eb87bc36..ac523482ad 100644
--- a/quantum/matrix.c
+++ b/quantum/matrix.c
@@ -60,13 +60,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
extern const matrix_row_t matrix_mask[];
#endif
+#if (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
-static matrix_row_t matrix_raw[MATRIX_ROWS];
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
@@ -76,7 +77,7 @@ static matrix_row_t matrix_debouncing[MATRIX_ROWS];
static void unselect_rows(void);
static void select_row(uint8_t row);
static void unselect_row(uint8_t row);
-#else // ROW2COL
+#elif (DIODE_DIRECTION == ROW2COL)
static void init_rows(void);
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
static void unselect_cols(void);
@@ -133,7 +134,7 @@ uint8_t matrix_cols(void) {
// /* PORTxn */
// _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
// }
-// #else
+// #elif (DIODE_DIRECTION == ROW2COL)
// for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
// /* DDRxn */
// _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
@@ -158,7 +159,7 @@ void matrix_init(void) {
#if (DIODE_DIRECTION == COL2ROW)
unselect_rows();
init_cols();
-#else // ROW2COL
+#elif (DIODE_DIRECTION == ROW2COL)
unselect_cols();
init_rows();
#endif
@@ -166,7 +167,6 @@ void matrix_init(void) {
// initialize matrix state: all keys off
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
- matrix_raw[i] = 0;
matrix_debouncing[i] = 0;
}
@@ -194,7 +194,7 @@ uint8_t matrix_scan(void)
}
-#else // ROW2COL
+#elif (DIODE_DIRECTION == ROW2COL)
// Set col, read rows
for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
@@ -336,7 +336,7 @@ static void unselect_rows(void)
}
}
-#else // ROW2COL
+#elif (DIODE_DIRECTION == ROW2COL)
static void init_rows(void)
{
diff --git a/quantum/process_keycode/process_combo.c b/quantum/process_keycode/process_combo.c
new file mode 100644
index 0000000000..e2189ad98b
--- /dev/null
+++ b/quantum/process_keycode/process_combo.c
@@ -0,0 +1,134 @@
+#include "process_combo.h"
+#include "print.h"
+
+
+#define COMBO_TIMER_ELAPSED -1
+
+
+__attribute__ ((weak))
+combo_t key_combos[] = {
+
+};
+
+__attribute__ ((weak))
+void process_combo_event(uint8_t combo_index, bool pressed) {
+
+}
+
+static uint8_t current_combo_index = 0;
+
+static inline void send_combo(uint16_t action, bool pressed)
+{
+ if (action) {
+ if (pressed) {
+ register_code16(action);
+ } else {
+ unregister_code16(action);
+ }
+ } else {
+ process_combo_event(current_combo_index, pressed);
+ }
+}
+
+#define ALL_COMBO_KEYS_ARE_DOWN (((1<<count)-1) == combo->state)
+#define NO_COMBO_KEYS_ARE_DOWN (0 == 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)
+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;
+ }
+
+ /* Return if not a combo key */
+ if (-1 == (int8_t)index) return false;
+
+ /* The combos timer is used to signal whether the combo is active */
+ bool is_combo_active = COMBO_TIMER_ELAPSED == combo->timer ? false : true;
+
+ 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);
+ combo->timer = COMBO_TIMER_ELAPSED;
+ } else { /* Combo key was pressed */
+ combo->timer = timer_read();
+#ifdef COMBO_ALLOW_ACTION_KEYS
+ combo->prev_record = *record;
+#else
+ combo->prev_key = keycode;
+#endif
+ }
+ }
+ } else {
+ if (ALL_COMBO_KEYS_ARE_DOWN) { /* Combo was released */
+ send_combo(combo->keycode, false);
+ }
+
+ if (is_combo_active) { /* Combo key was tapped */
+#ifdef COMBO_ALLOW_ACTION_KEYS
+ record->event.pressed = true;
+ process_action(record, store_or_get_action(record->event.pressed, record->event.key));
+ record->event.pressed = false;
+ process_action(record, store_or_get_action(record->event.pressed, record->event.key));
+#else
+ register_code16(keycode);
+ send_keyboard_report();
+ unregister_code16(keycode);
+#endif
+ combo->timer = 0;
+ }
+
+ KEY_STATE_UP(index);
+ }
+
+ if (NO_COMBO_KEYS_ARE_DOWN) {
+ combo->timer = 0;
+ }
+
+ return is_combo_active;
+}
+
+bool process_combo(uint16_t keycode, keyrecord_t *record)
+{
+ bool is_combo_key = false;
+
+ 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);
+ }
+
+ return !is_combo_key;
+}
+
+void matrix_scan_combo(void)
+{
+ for (int i = 0; i < COMBO_COUNT; ++i) {
+ combo_t *combo = &key_combos[i];
+ if (combo->timer &&
+ combo->timer != COMBO_TIMER_ELAPSED &&
+ timer_elapsed(combo->timer) > COMBO_TERM) {
+
+ /* This disables the combo, meaning key events for this
+ * combo will be handled by the next processors in the chain
+ */
+ combo->timer = COMBO_TIMER_ELAPSED;
+
+#ifdef COMBO_ALLOW_ACTION_KEYS
+ process_action(&combo->prev_record,
+ store_or_get_action(combo->prev_record.event.pressed,
+ combo->prev_record.event.key));
+#else
+ unregister_code16(combo->prev_key);
+ register_code16(combo->prev_key);
+#endif
+ }
+ }
+}
diff --git a/quantum/process_keycode/process_combo.h b/quantum/process_keycode/process_combo.h
new file mode 100644
index 0000000000..847f2b7376
--- /dev/null
+++ b/quantum/process_keycode/process_combo.h
@@ -0,0 +1,43 @@
+#ifndef PROCESS_COMBO_H
+#define PROCESS_COMBO_H
+
+#include <stdint.h>
+#include "progmem.h"
+#include "quantum.h"
+
+typedef struct
+{
+ const uint16_t *keys;
+ uint16_t keycode;
+#ifdef EXTRA_EXTRA_LONG_COMBOS
+ uint32_t state;
+#elif EXTRA_LONG_COMBOS
+ uint16_t state;
+#else
+ uint8_t state;
+#endif
+ uint16_t timer;
+#ifdef COMBO_ALLOW_ACTION_KEYS
+ keyrecord_t prev_record;
+#else
+ uint16_t prev_key;
+#endif
+} combo_t;
+
+
+#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
+#endif
+#ifndef COMBO_TERM
+#define COMBO_TERM TAPPING_TERM
+#endif
+
+bool process_combo(uint16_t keycode, keyrecord_t *record);
+void matrix_scan_combo(void);
+void process_combo_event(uint8_t combo_index, bool pressed);
+
+#endif
diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index 6ae362c4c2..403dca5380 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -43,12 +43,16 @@ static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_acti
if (action->state.finished)
return;
action->state.finished = true;
+ add_mods(action->state.oneshot_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);
+ send_keyboard_report();
}
bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
@@ -70,6 +74,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
action->state.keycode = keycode;
action->state.count++;
action->state.timer = timer_read();
+ action->state.oneshot_mods = get_oneshot_mods();
process_tap_dance_action_on_each_tap (action);
if (last_td && last_td != keycode) {
@@ -109,7 +114,7 @@ void matrix_scan_tap_dance () {
if (highest_td == -1)
return;
- for (int i = 0; i <= highest_td; i++) {
+for (int i = 0; i <= highest_td; i++) {
qk_tap_dance_action_t *action = &tap_dance_actions[i];
if (action->state.count && timer_elapsed (action->state.timer) > TAPPING_TERM) {
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index f753cbba66..726752ecc7 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -9,6 +9,7 @@
typedef struct
{
uint8_t count;
+ uint8_t oneshot_mods;
uint16_t keycode;
uint16_t timer;
bool interrupted;
diff --git a/quantum/process_keycode/process_ucis.c b/quantum/process_keycode/process_ucis.c
new file mode 100644
index 0000000000..4ad2533b08
--- /dev/null
+++ b/quantum/process_keycode/process_ucis.c
@@ -0,0 +1,133 @@
+#include "process_ucis.h"
+
+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_start_user();
+}
+
+__attribute__((weak))
+void qk_ucis_start_user(void) {
+ unicode_input_start();
+ register_hex(0x2328);
+ unicode_input_finish();
+}
+
+static bool is_uni_seq(char *seq) {
+ 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;
+
+ 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);
+}
+
+__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);
+ }
+}
+
+void register_ucis(const char *hex) {
+ 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;
+ }
+
+ 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;
+
+ 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;
+ 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();
+
+ qk_ucis_state.in_progress = false;
+ return false;
+ }
+ return true;
+} \ No newline at end of file
diff --git a/quantum/process_keycode/process_ucis.h b/quantum/process_keycode/process_ucis.h
new file mode 100644
index 0000000000..4332f57b35
--- /dev/null
+++ b/quantum/process_keycode/process_ucis.h
@@ -0,0 +1,35 @@
+#ifndef PROCESS_UCIS_H
+#define PROCESS_UCIS_H
+
+#include "quantum.h"
+#include "process_unicode_common.h"
+
+#ifndef UCIS_MAX_SYMBOL_LENGTH
+#define UCIS_MAX_SYMBOL_LENGTH 32
+#endif
+
+typedef struct {
+ char *symbol;
+ char *code;
+} qk_ucis_symbol_t;
+
+typedef struct {
+ 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}
+
+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 register_ucis(const char *hex);
+bool process_ucis (uint16_t keycode, keyrecord_t *record);
+
+#endif
diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
index a30e93ae32..ccae6fdcad 100644
--- a/quantum/process_keycode/process_unicode.c
+++ b/quantum/process_keycode/process_unicode.c
@@ -1,103 +1,6 @@
#include "process_unicode.h"
#include "action_util.h"
-static uint8_t input_mode;
-uint8_t 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);
- }
-}
-
-void set_unicode_input_mode(uint8_t os_target)
-{
- input_mode = os_target;
-}
-
-uint8_t get_unicode_input_mode(void) {
- return input_mode;
-}
-
-__attribute__((weak))
-void unicode_input_start (void) {
- // save current mods
- mods = keyboard_report->mods;
-
- // unregister all mods to start from clean state
- if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
- if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
- if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
- if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
- if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
- if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
- if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
- if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
-
- switch(input_mode) {
- case UC_OSX:
- register_code(KC_LALT);
- break;
- case UC_LNX:
- register_code(KC_LCTL);
- register_code(KC_LSFT);
- register_code(KC_U);
- unregister_code(KC_U);
- unregister_code(KC_LSFT);
- unregister_code(KC_LCTL);
- break;
- case UC_WIN:
- register_code(KC_LALT);
- register_code(KC_PPLS);
- unregister_code(KC_PPLS);
- break;
- case UC_WINC:
- register_code(KC_RALT);
- unregister_code(KC_RALT);
- register_code(KC_U);
- unregister_code(KC_U);
- }
- wait_ms(UNICODE_TYPE_DELAY);
-}
-
-__attribute__((weak))
-void unicode_input_finish (void) {
- switch(input_mode) {
- case UC_OSX:
- case UC_WIN:
- unregister_code(KC_LALT);
- break;
- case UC_LNX:
- register_code(KC_SPC);
- unregister_code(KC_SPC);
- break;
- }
-
- // reregister previously set mods
- if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
- if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
- if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
- if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
- if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
- if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
- if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
- if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
-}
-
-void register_hex(uint16_t hex) {
- for(int i = 3; i >= 0; i--) {
- uint8_t digit = ((hex >> (i*4)) & 0xF);
- register_code(hex_to_keycode(digit));
- unregister_code(hex_to_keycode(digit));
- }
-}
-
bool process_unicode(uint16_t keycode, keyrecord_t *record) {
if (keycode > QK_UNICODE && record->event.pressed) {
uint16_t unicode = keycode & 0x7FFF;
@@ -108,182 +11,3 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
return true;
}
-#ifdef UNICODEMAP_ENABLE
-__attribute__((weak))
-const uint32_t PROGMEM unicode_map[] = {
-};
-
-void register_hex32(uint32_t hex) {
- uint8_t onzerostart = 1;
- for(int i = 7; i >= 0; i--) {
- if (i <= 3) {
- onzerostart = 0;
- }
- uint8_t digit = ((hex >> (i*4)) & 0xF);
- if (digit == 0) {
- if (onzerostart == 0) {
- 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 = 0;
- }
- }
-}
-
-__attribute__((weak))
-void unicode_map_input_error() {}
-
-bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
- if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
- const uint32_t* map = unicode_map;
- uint16_t index = keycode & 0x7FF;
- uint32_t code = pgm_read_dword_far(&map[index]);
- if ((code > 0xFFFF && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
- // when character is out of range supported by the OS
- unicode_map_input_error();
- } else {
- unicode_input_start();
- register_hex32(code);
- unicode_input_finish();
- }
- }
- return true;
-}
-#endif
-
-#ifdef UCIS_ENABLE
-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_start_user();
-}
-
-__attribute__((weak))
-void qk_ucis_start_user(void) {
- unicode_input_start();
- register_hex(0x2328);
- unicode_input_finish();
-}
-
-static bool is_uni_seq(char *seq) {
- 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;
-
- 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);
-}
-
-__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);
- }
-}
-
-void register_ucis(const char *hex) {
- 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;
- }
-
- 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;
-
- 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;
- 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();
-
- qk_ucis_state.in_progress = false;
- return false;
- }
- return true;
-}
-#endif
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
index f17cfa6cf2..4c21f11eb9 100644
--- a/quantum/process_keycode/process_unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -2,166 +2,8 @@
#define PROCESS_UNICODE_H
#include "quantum.h"
-
-#define UC_OSX 0 // Mac OS X
-#define UC_LNX 1 // Linux
-#define UC_WIN 2 // Windows 'HexNumpad'
-#define UC_BSD 3 // BSD (not implemented)
-#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
-
-#ifndef UNICODE_TYPE_DELAY
-#define UNICODE_TYPE_DELAY 10
-#endif
-
-void set_unicode_input_mode(uint8_t os_target);
-uint8_t get_unicode_input_mode(void);
-void unicode_input_start(void);
-void unicode_input_finish(void);
-void register_hex(uint16_t hex);
+#include "process_unicode_common.h"
bool process_unicode(uint16_t keycode, keyrecord_t *record);
-#ifdef UNICODEMAP_ENABLE
-void unicode_map_input_error(void);
-bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
-#endif
-
-#ifdef UCIS_ENABLE
-#ifndef UCIS_MAX_SYMBOL_LENGTH
-#define UCIS_MAX_SYMBOL_LENGTH 32
-#endif
-
-typedef struct {
- char *symbol;
- char *code;
-} qk_ucis_symbol_t;
-
-typedef struct {
- 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}
-
-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 register_ucis(const char *hex);
-bool process_ucis (uint16_t keycode, keyrecord_t *record);
-
-#endif
-
-#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_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_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_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_LCBR UC(0x007B)
-#define UC_PIPE UC(0x007C)
-#define UC_RCBR UC(0x007D)
-#define UC_TILD UC(0x007E)
-#define UC_DEL UC(0x007F)
-
#endif
diff --git a/quantum/process_keycode/process_unicode_common.c b/quantum/process_keycode/process_unicode_common.c
new file mode 100644
index 0000000000..31bc3b7ab3
--- /dev/null
+++ b/quantum/process_keycode/process_unicode_common.c
@@ -0,0 +1,85 @@
+#include "process_unicode_common.h"
+
+uint8_t mods;
+
+void set_unicode_input_mode(uint8_t os_target)
+{
+ input_mode = os_target;
+}
+
+uint8_t get_unicode_input_mode(void) {
+ return input_mode;
+}
+
+__attribute__((weak))
+void unicode_input_start (void) {
+ // save current mods
+ mods = keyboard_report->mods;
+
+ // unregister all mods to start from clean state
+ if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
+ if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
+ if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
+ if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
+ if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
+ if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
+ if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
+ if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
+
+ switch(input_mode) {
+ case UC_OSX:
+ register_code(KC_LALT);
+ break;
+ case UC_LNX:
+ register_code(KC_LCTL);
+ register_code(KC_LSFT);
+ register_code(KC_U);
+ unregister_code(KC_U);
+ unregister_code(KC_LSFT);
+ unregister_code(KC_LCTL);
+ break;
+ case UC_WIN:
+ register_code(KC_LALT);
+ register_code(KC_PPLS);
+ unregister_code(KC_PPLS);
+ break;
+ case UC_WINC:
+ register_code(KC_RALT);
+ unregister_code(KC_RALT);
+ register_code(KC_U);
+ unregister_code(KC_U);
+ }
+ wait_ms(UNICODE_TYPE_DELAY);
+}
+
+__attribute__((weak))
+void unicode_input_finish (void) {
+ switch(input_mode) {
+ case UC_OSX:
+ case UC_WIN:
+ unregister_code(KC_LALT);
+ break;
+ case UC_LNX:
+ register_code(KC_SPC);
+ unregister_code(KC_SPC);
+ break;
+ }
+
+ // reregister previously set mods
+ if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
+ if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
+ if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
+ if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
+ if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
+ if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
+ if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
+ if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
+}
+
+void register_hex(uint16_t hex) {
+ for(int i = 3; i >= 0; i--) {
+ uint8_t digit = ((hex >> (i*4)) & 0xF);
+ register_code(hex_to_keycode(digit));
+ unregister_code(hex_to_keycode(digit));
+ }
+} \ No newline at end of file
diff --git a/quantum/process_keycode/process_unicode_common.h b/quantum/process_keycode/process_unicode_common.h
new file mode 100644
index 0000000000..864693cdd0
--- /dev/null
+++ b/quantum/process_keycode/process_unicode_common.h
@@ -0,0 +1,132 @@
+#ifndef PROCESS_UNICODE_COMMON_H
+#define PROCESS_UNICODE_COMMON_H
+
+#include "quantum.h"
+
+#ifndef UNICODE_TYPE_DELAY
+#define UNICODE_TYPE_DELAY 10
+#endif
+
+__attribute__ ((unused))
+static uint8_t input_mode;
+
+void set_unicode_input_mode(uint8_t os_target);
+uint8_t get_unicode_input_mode(void);
+void unicode_input_start(void);
+void unicode_input_finish(void);
+void register_hex(uint16_t hex);
+
+#define UC_OSX 0 // Mac OS X
+#define UC_LNX 1 // Linux
+#define UC_WIN 2 // Windows 'HexNumpad'
+#define UC_BSD 3 // BSD (not implemented)
+#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
+
+#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_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_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_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_LCBR UC(0x007B)
+#define UC_PIPE UC(0x007C)
+#define UC_RCBR UC(0x007D)
+#define UC_TILD UC(0x007E)
+#define UC_DEL UC(0x007F)
+
+#endif \ No newline at end of file
diff --git a/quantum/process_keycode/process_unicodemap.c b/quantum/process_keycode/process_unicodemap.c
new file mode 100644
index 0000000000..68a593a186
--- /dev/null
+++ b/quantum/process_keycode/process_unicodemap.c
@@ -0,0 +1,56 @@
+#include "process_unicodemap.h"
+#include "process_unicode_common.h"
+
+__attribute__((weak))
+const uint32_t PROGMEM unicode_map[] = {
+};
+
+void register_hex32(uint32_t hex) {
+ 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;
+ }
+ }
+}
+
+__attribute__((weak))
+void unicode_map_input_error() {}
+
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
+ uint8_t input_mode = get_unicode_input_mode();
+ if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
+ const uint32_t* map = unicode_map;
+ uint16_t index = keycode - QK_UNICODE_MAP;
+ uint32_t code = pgm_read_dword_far(&map[index]);
+ if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
+ // Convert to UTF-16 surrogate pair
+ code -= 0x10000;
+ uint32_t lo = code & 0x3ff;
+ uint32_t hi = (code & 0xffc00) >> 10;
+ unicode_input_start();
+ register_hex32(hi + 0xd800);
+ register_hex32(lo + 0xdc00);
+ unicode_input_finish();
+ } else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
+ // when character is out of range supported by the OS
+ unicode_map_input_error();
+ } else {
+ unicode_input_start();
+ register_hex32(code);
+ unicode_input_finish();
+ }
+ }
+ return true;
+} \ No newline at end of file
diff --git a/quantum/process_keycode/process_unicodemap.h b/quantum/process_keycode/process_unicodemap.h
new file mode 100644
index 0000000000..64a7a01090
--- /dev/null
+++ b/quantum/process_keycode/process_unicodemap.h
@@ -0,0 +1,9 @@
+#ifndef PROCESS_UNICODEMAP_H
+#define PROCESS_UNICODEMAP_H
+
+#include "quantum.h"
+#include "process_unicode_common.h"
+
+void unicode_map_input_error(void);
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
+#endif \ No newline at end of file
diff --git a/quantum/quantum.c b/quantum/quantum.c
index 63ffe2074e..4a6d0355fa 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -1,9 +1,16 @@
#include "quantum.h"
+#ifdef PROTOCOL_LUFA
+#include "outputselect.h"
+#endif
#ifndef TAPPING_TERM
#define TAPPING_TERM 200
#endif
+#ifdef FAUXCLICKY_ENABLE
+#include "fauxclicky.h"
+#endif
+
static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
switch (code) {
case QK_MODS ... QK_MODS_MAX:
@@ -33,14 +40,42 @@ static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
f(KC_RGUI);
}
+static inline void qk_register_weak_mods(uint8_t kc) {
+ add_weak_mods(MOD_BIT(kc));
+ send_keyboard_report();
+}
+
+static inline void qk_unregister_weak_mods(uint8_t kc) {
+ del_weak_mods(MOD_BIT(kc));
+ send_keyboard_report();
+}
+
+static inline void qk_register_mods(uint8_t kc) {
+ add_weak_mods(MOD_BIT(kc));
+ send_keyboard_report();
+}
+
+static inline void qk_unregister_mods(uint8_t kc) {
+ del_weak_mods(MOD_BIT(kc));
+ send_keyboard_report();
+}
+
void register_code16 (uint16_t code) {
- do_code16 (code, register_code);
+ if (IS_MOD(code) || code == KC_NO) {
+ do_code16 (code, qk_register_mods);
+ } else {
+ do_code16 (code, qk_register_weak_mods);
+ }
register_code (code);
}
void unregister_code16 (uint16_t code) {
unregister_code (code);
- do_code16 (code, unregister_code);
+ if (IS_MOD(code) || code == KC_NO) {
+ do_code16 (code, qk_unregister_mods);
+ } else {
+ do_code16 (code, qk_unregister_weak_mods);
+ }
}
__attribute__ ((weak))
@@ -130,6 +165,9 @@ bool process_record_quantum(keyrecord_t *record) {
#ifndef DISABLE_CHORDING
process_chording(keycode, record) &&
#endif
+ #ifdef COMBO_ENABLE
+ process_combo(keycode, record) &&
+ #endif
#ifdef UNICODE_ENABLE
process_unicode(keycode, record) &&
#endif
@@ -162,6 +200,26 @@ bool process_record_quantum(keyrecord_t *record) {
}
return false;
break;
+ #ifdef FAUXCLICKY_ENABLE
+ case FC_TOG:
+ if (record->event.pressed) {
+ FAUXCLICKY_TOGGLE;
+ }
+ return false;
+ break;
+ case FC_ON:
+ if (record->event.pressed) {
+ FAUXCLICKY_ON;
+ }
+ return false;
+ break;
+ case FC_OFF:
+ if (record->event.pressed) {
+ FAUXCLICKY_OFF;
+ }
+ return false;
+ break;
+ #endif
#ifdef RGBLIGHT_ENABLE
case RGB_TOG:
if (record->event.pressed) {
@@ -212,6 +270,36 @@ bool process_record_quantum(keyrecord_t *record) {
return false;
break;
#endif
+ #ifdef PROTOCOL_LUFA
+ case OUT_AUTO:
+ if (record->event.pressed) {
+ set_output(OUTPUT_AUTO);
+ }
+ return false;
+ break;
+ case OUT_USB:
+ if (record->event.pressed) {
+ set_output(OUTPUT_USB);
+ }
+ return false;
+ break;
+ #ifdef BLUETOOTH_ENABLE
+ case OUT_BT:
+ if (record->event.pressed) {
+ set_output(OUTPUT_BLUETOOTH);
+ }
+ return false;
+ break;
+ #endif
+ #ifdef ADAFRUIT_BLE_ENABLE
+ case OUT_BLE:
+ if (record->event.pressed) {
+ set_output(OUTPUT_ADAFRUIT_BLE);
+ }
+ return false;
+ break;
+ #endif
+ #endif
case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
if (record->event.pressed) {
// MAGIC actions (BOOTMAGIC without the boot)
@@ -508,6 +596,11 @@ void matrix_scan_quantum() {
#ifdef TAP_DANCE_ENABLE
matrix_scan_tap_dance();
#endif
+
+ #ifdef COMBO_ENABLE
+ matrix_scan_combo();
+ #endif
+
matrix_scan_kb();
}
@@ -525,34 +618,45 @@ static const uint8_t backlight_pin = BACKLIGHT_PIN;
# define COM1x1 COM1A1
# define OCR1x OCR1A
#else
-# error "Backlight pin not supported - use B5, B6, or B7"
+# define NO_BACKLIGHT_CLOCK
+#endif
+
+#ifndef BACKLIGHT_ON_STATE
+#define BACKLIGHT_ON_STATE 0
#endif
__attribute__ ((weak))
void backlight_init_ports(void)
{
- // Setup backlight pin as output and output low.
+ // Setup backlight pin as output and output to on state.
// DDRx |= n
_SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
- // PORTx &= ~n
- _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
+ #if BACKLIGHT_ON_STATE == 0
+ // PORTx &= ~n
+ _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
+ #else
+ // PORTx |= n
+ _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
+ #endif
- // Use full 16-bit resolution.
- ICR1 = 0xFFFF;
+ #ifndef NO_BACKLIGHT_CLOCK
+ // Use full 16-bit resolution.
+ ICR1 = 0xFFFF;
- // I could write a wall of text here to explain... but TL;DW
- // Go read the ATmega32u4 datasheet.
- // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
+ // I could write a wall of text here to explain... but TL;DW
+ // Go read the ATmega32u4 datasheet.
+ // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
- // Pin PB7 = OCR1C (Timer 1, Channel C)
- // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
- // (i.e. start high, go low when counter matches.)
- // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
- // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
+ // Pin PB7 = OCR1C (Timer 1, Channel C)
+ // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
+ // (i.e. start high, go low when counter matches.)
+ // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
+ // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
- TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
- TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
+ TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
+ TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
+ #endif
backlight_init();
#ifdef BACKLIGHT_BREATHING
@@ -564,24 +668,43 @@ __attribute__ ((weak))
void backlight_set(uint8_t level)
{
// Prevent backlight blink on lowest level
- // PORTx &= ~n
- _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
+ #if BACKLIGHT_ON_STATE == 0
+ // PORTx &= ~n
+ _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
+ #else
+ // PORTx |= n
+ _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
+ #endif
if ( level == 0 ) {
- // Turn off PWM control on backlight pin, revert to output low.
- TCCR1A &= ~(_BV(COM1x1));
- OCR1x = 0x0;
- } else if ( level == BACKLIGHT_LEVELS ) {
- // Turn on PWM control of backlight pin
- TCCR1A |= _BV(COM1x1);
- // Set the brightness
- OCR1x = 0xFFFF;
- } else {
- // Turn on PWM control of backlight pin
- TCCR1A |= _BV(COM1x1);
- // Set the brightness
- OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
- }
+ #ifndef NO_BACKLIGHT_CLOCK
+ // Turn off PWM control on backlight pin, revert to output low.
+ TCCR1A &= ~(_BV(COM1x1));
+ OCR1x = 0x0;
+ #else
+ #if BACKLIGHT_ON_STATE == 0
+ // PORTx |= n
+ _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
+ #else
+ // PORTx &= ~n
+ _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
+ #endif
+ #endif
+ }
+ #ifndef NO_BACKLIGHT_CLOCK
+ else if ( level == BACKLIGHT_LEVELS ) {
+ // Turn on PWM control of backlight pin
+ TCCR1A |= _BV(COM1x1);
+ // Set the brightness
+ OCR1x = 0xFFFF;
+ }
+ else {
+ // Turn on PWM control of backlight pin
+ TCCR1A |= _BV(COM1x1);
+ // Set the brightness
+ OCR1x = 0xFFFF >> ((BACKLIGHT_LEVELS - level) * ((BACKLIGHT_LEVELS + 1) / 2));
+ }
+ #endif
#ifdef BACKLIGHT_BREATHING
breathing_intensity_default();
@@ -849,6 +972,19 @@ void send_nibble(uint8_t number) {
}
}
+
+__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 api_send_unicode(uint32_t unicode) {
#ifdef API_ENABLE
uint8_t chunk[4];
diff --git a/quantum/quantum.h b/quantum/quantum.h
index e6adf974ab..580d51202a 100644
--- a/quantum/quantum.h
+++ b/quantum/quantum.h
@@ -15,7 +15,6 @@
#ifdef RGBLIGHT_ENABLE
#include "rgblight.h"
#endif
-
#include "action_layer.h"
#include "eeconfig.h"
#include <stddef.h>
@@ -57,12 +56,24 @@ extern uint32_t default_layer_state;
#include "process_unicode.h"
#endif
+#ifdef UCIS_ENABLE
+ #include "process_ucis.h"
+#endif
+
+#ifdef UNICODEMAP_ENABLE
+ #include "process_unicodemap.h"
+#endif
+
#include "process_tap_dance.h"
#ifdef PRINTING_ENABLE
#include "process_printer.h"
#endif
+#ifdef COMBO_ENABLE
+ #include "process_combo.h"
+#endif
+
#define SEND_STRING(str) send_string(PSTR(str))
void send_string(const char *str);
@@ -114,7 +125,7 @@ void send_dword(uint32_t number);
void send_word(uint16_t number);
void send_byte(uint8_t number);
void send_nibble(uint8_t number);
-
+uint16_t hex_to_keycode(uint8_t hex);
void led_set_user(uint8_t usb_led);
void led_set_kb(uint8_t usb_led);
diff --git a/quantum/quantum_keycodes.h b/quantum/quantum_keycodes.h
index 4853655f95..63b626926d 100644
--- a/quantum/quantum_keycodes.h
+++ b/quantum/quantum_keycodes.h
@@ -39,22 +39,27 @@ enum quantum_keycodes {
QK_CHORDING = 0x5600,
QK_CHORDING_MAX = 0x56FF,
#endif
+ QK_TAP_DANCE = 0x5700,
+ QK_TAP_DANCE_MAX = 0x57FF,
+ QK_LAYER_TAP_TOGGLE = 0x5800,
+ QK_LAYER_TAP_TOGGLE_MAX = 0x58FF,
QK_MOD_TAP = 0x6000,
- QK_MOD_TAP_MAX = 0x6FFF,
- QK_TAP_DANCE = 0x7100,
- QK_TAP_DANCE_MAX = 0x71FF,
-#ifdef UNICODEMAP_ENABLE
- QK_UNICODE_MAP = 0x7800,
- QK_UNICODE_MAP_MAX = 0x7FFF,
+ QK_MOD_TAP_MAX = 0x7FFF,
+#if defined(UNICODEMAP_ENABLE) && defined(UNICODE_ENABLE)
+ #error "Cannot enable both UNICODEMAP && UNICODE"
#endif
#ifdef UNICODE_ENABLE
QK_UNICODE = 0x8000,
QK_UNICODE_MAX = 0xFFFF,
#endif
+#ifdef UNICODEMAP_ENABLE
+ QK_UNICODE_MAP = 0x8000,
+ QK_UNICODE_MAP_MAX = 0x83FF,
+#endif
// Loose keycodes - to be used directly
- RESET = 0x7000,
+ RESET = 0x5C00,
DEBUG,
MAGIC_SWAP_CONTROL_CAPSLOCK,
MAGIC_CAPSLOCK_TO_CONTROL,
@@ -86,6 +91,13 @@ enum quantum_keycodes {
AU_OFF,
AU_TOG,
+#ifdef FAUXCLICKY_ENABLE
+ // Faux clicky
+ FC_ON,
+ FC_OFF,
+ FC_TOG,
+#endif
+
// Music mode on/off/toggle
MU_ON,
MU_OFF,
@@ -141,6 +153,16 @@ enum quantum_keycodes {
PRINT_ON,
PRINT_OFF,
+ // output selection
+ OUT_AUTO,
+ OUT_USB,
+#ifdef BLUETOOTH_ENABLE
+ OUT_BT,
+#endif
+#ifdef ADAFRUIT_BLE_ENABLE
+ OUT_BLE,
+#endif
+
// always leave at the end
SAFE_RANGE
};
@@ -246,8 +268,10 @@ enum quantum_keycodes {
#define M(kc) (kc | QK_MACRO)
+#define MACROTAP(kc) (kc | QK_MACRO | FUNC_TAP<<8)
#define MACRODOWN(...) (record->event.pressed ? MACRO(__VA_ARGS__) : MACRO_NONE)
+
// L-ayer, T-ap - 256 keycode max, 16 layer max
#define LT(layer, kc) (kc | QK_LAYER_TAP | ((layer & 0xF) << 8))
@@ -285,15 +309,33 @@ enum quantum_keycodes {
// One-shot mod
#define OSM(mod) (mod | QK_ONE_SHOT_MOD)
+// Layer tap-toggle
+#define TT(layer) (layer | QK_LAYER_TAP_TOGGLE)
+
// M-od, T-ap - 256 keycode max
-#define MT(mod, kc) (kc | QK_MOD_TAP | ((mod & 0xF) << 8))
+#define MT(mod, kc) (kc | QK_MOD_TAP | ((mod & 0x1F) << 8))
+
#define CTL_T(kc) MT(MOD_LCTL, kc)
+#define LCTL_T(kc) MT(MOD_LCTL, kc)
+#define RCTL_T(kc) MT(MOD_RCTL, kc)
+
#define SFT_T(kc) MT(MOD_LSFT, kc)
+#define LSFT_T(kc) MT(MOD_LSFT, kc)
+#define RSFT_T(kc) MT(MOD_RSFT, kc)
+
#define ALT_T(kc) MT(MOD_LALT, kc)
+#define LALT_T(kc) MT(MOD_LALT, kc)
+#define RALT_T(kc) MT(MOD_RALT, kc)
+#define ALGR_T(kc) MT(MOD_RALT, kc) // dual-function AltGR
+
#define GUI_T(kc) MT(MOD_LGUI, kc)
+#define LGUI_T(kc) MT(MOD_LGUI, kc)
+#define RGUI_T(kc) MT(MOD_RGUI, kc)
+
#define C_S_T(kc) MT((MOD_LCTL | MOD_LSFT), kc) // Control + Shift e.g. for gnome-terminal
#define MEH_T(kc) MT((MOD_LCTL | MOD_LSFT | MOD_LALT), kc) // Meh is a less hyper version of the Hyper key -- doesn't include Win or Cmd, so just alt+shift+ctrl
#define LCAG_T(kc) MT((MOD_LCTL | MOD_LALT | MOD_LGUI), kc) // Left control alt and gui
+#define RCAG_T(kc) MT((MOD_RCTL | MOD_RALT | MOD_RGUI), kc) // Right control alt and gui
#define ALL_T(kc) MT((MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI), kc) // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/
#define SCMD_T(kc) MT((MOD_LGUI | MOD_LSFT), kc)
#define SWIN_T(kc) SCMD_T(kc)
diff --git a/quantum/rgblight.c b/quantum/rgblight.c
index 52a09817a1..dd1b91c63c 100644
--- a/quantum/rgblight.c
+++ b/quantum/rgblight.c
@@ -66,6 +66,8 @@ __attribute__ ((weak))
const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
__attribute__ ((weak))
const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {100, 50, 20};
+__attribute__ ((weak))
+const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
rgblight_config_t rgblight_config;
rgblight_config_t inmem_config;
@@ -219,6 +221,14 @@ void rgblight_step(void) {
}
rgblight_mode(mode);
}
+void rgblight_step_reverse(void) {
+ uint8_t mode = 0;
+ mode = rgblight_config.mode - 1;
+ if (mode < 1) {
+ mode = RGBLIGHT_MODES;
+ }
+ rgblight_mode(mode);
+}
void rgblight_mode(uint8_t mode) {
if (!rgblight_config.enable) {
@@ -237,7 +247,7 @@ void rgblight_mode(uint8_t mode) {
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_disable();
#endif
- } else if (rgblight_config.mode >= 2 && rgblight_config.mode <= 23) {
+ } else if (rgblight_config.mode >= 2 && rgblight_config.mode <= 24) {
// MODE 2-5, breathing
// MODE 6-8, rainbow mood
// MODE 9-14, rainbow swirl
@@ -247,6 +257,12 @@ void rgblight_mode(uint8_t mode) {
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_enable();
#endif
+ } else if (rgblight_config.mode >= 25 && rgblight_config.mode <= 34) {
+ // MODE 25-34, static gradient
+
+ #ifdef RGBLIGHT_ANIMATIONS
+ rgblight_timer_disable();
+ #endif
}
rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
}
@@ -350,6 +366,17 @@ void rgblight_sethsv(uint16_t hue, uint8_t sat, uint8_t val) {
} else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 14) {
// rainbow mood and rainbow swirl, ignore the change of hue
hue = rgblight_config.hue;
+ } else if (rgblight_config.mode >= 25 && rgblight_config.mode <= 34) {
+ // static gradient
+ uint16_t _hue;
+ int8_t direction = ((rgblight_config.mode - 25) % 2) ? -1 : 1;
+ uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[(rgblight_config.mode - 25) / 2]);
+ for (uint8_t i = 0; i < RGBLED_NUM; i++) {
+ _hue = (range / RGBLED_NUM * i * direction + hue + 360) % 360;
+ dprintf("rgblight rainbow set hsv: %u,%u,%d,%u\n", i, _hue, direction, range);
+ sethsv(_hue, sat, val, (LED_TYPE *)&led[i]);
+ }
+ rgblight_set();
}
}
rgblight_config.hue = hue;
@@ -450,7 +477,7 @@ void rgblight_task(void) {
} else if (rgblight_config.mode >= 21 && rgblight_config.mode <= 23) {
// mode = 21 to 23, knight mode
rgblight_effect_knight(rgblight_config.mode - 21);
- } else {
+ } else if (rgblight_config.mode == 24) {
// mode = 24, christmas mode
rgblight_effect_christmas();
}
@@ -604,13 +631,13 @@ void rgblight_effect_christmas(void) {
static uint16_t last_timer = 0;
uint16_t hue;
uint8_t i;
- if (timer_elapsed(last_timer) < 1000) {
+ if (timer_elapsed(last_timer) < RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL) {
return;
}
last_timer = timer_read();
current_offset = (current_offset + 1) % 2;
for (i = 0; i < RGBLED_NUM; i++) {
- hue = 0 + ((RGBLED_NUM * (i + current_offset)) % 2) * 80;
+ hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + current_offset) % 2) * 120;
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}
rgblight_set();
diff --git a/quantum/rgblight.h b/quantum/rgblight.h
index 726b8de72e..2b3e791bf8 100644
--- a/quantum/rgblight.h
+++ b/quantum/rgblight.h
@@ -2,7 +2,7 @@
#define RGBLIGHT_H
#ifdef RGBLIGHT_ANIMATIONS
- #define RGBLIGHT_MODES 24
+ #define RGBLIGHT_MODES 34
#else
#define RGBLIGHT_MODES 1
#endif
@@ -22,6 +22,14 @@
#define RGBLIGHT_EFFECT_DUALKNIGHT_LENGTH 4
#endif
+#ifndef RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL
+#define RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL 1000
+#endif
+
+#ifndef RGBLIGHT_EFFECT_CHRISTMAS_STEP
+#define RGBLIGHT_EFFECT_CHRISTMAS_STEP 2
+#endif
+
#ifndef RGBLIGHT_HUE_STEP
#define RGBLIGHT_HUE_STEP 10
#endif
@@ -65,6 +73,7 @@ void rgblight_decrease(void);
void rgblight_toggle(void);
void rgblight_enable(void);
void rgblight_step(void);
+void rgblight_step_reverse(void);
void rgblight_mode(uint8_t mode);
void rgblight_set(void);
void rgblight_update_dword(uint32_t dword);
diff --git a/quantum/template/config.h b/quantum/template/config.h
index b02f0c7ebc..c61c4a6181 100644
--- a/quantum/template/config.h
+++ b/quantum/template/config.h
@@ -46,7 +46,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_COL_PINS { F1, F0, B0 }
#define UNUSED_PINS
-/* COL2ROW or ROW2COL */
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
#define DIODE_DIRECTION COL2ROW
// #define BACKLIGHT_PIN B7
diff --git a/quantum/template/rules.mk b/quantum/template/rules.mk
index 55898147dd..bad3387bf4 100644
--- a/quantum/template/rules.mk
+++ b/quantum/template/rules.mk
@@ -65,3 +65,4 @@ MIDI_ENABLE ?= no # MIDI controls
UNICODE_ENABLE ?= no # Unicode
BLUETOOTH_ENABLE ?= no # Enable Bluetooth with the Adafruit EZ-Key HID
AUDIO_ENABLE ?= no # Audio output on port C6
+FAUXCLICKY_ENABLE ?= no # Use buzzer to emulate clicky switches