summaryrefslogtreecommitdiff
path: root/quantum
diff options
context:
space:
mode:
Diffstat (limited to 'quantum')
-rw-r--r--quantum/audio/audio.h6
-rw-r--r--quantum/keymap.h2
-rw-r--r--quantum/keymap_midi.c109
-rw-r--r--quantum/matrix.c46
-rw-r--r--quantum/process_keycode/process_chording.c60
-rw-r--r--quantum/process_keycode/process_chording.h16
-rw-r--r--quantum/process_keycode/process_leader.c38
-rw-r--r--quantum/process_keycode/process_leader.h23
-rw-r--r--quantum/process_keycode/process_midi.c66
-rw-r--r--quantum/process_keycode/process_midi.h (renamed from quantum/keymap_midi.h)23
-rw-r--r--quantum/process_keycode/process_music.c171
-rw-r--r--quantum/process_keycode/process_music.h27
-rw-r--r--quantum/process_keycode/process_tap_dance.c90
-rw-r--r--quantum/process_keycode/process_tap_dance.h62
-rw-r--r--quantum/process_keycode/process_unicode.c57
-rw-r--r--quantum/process_keycode/process_unicode.h (renamed from quantum/unicode.h)28
-rw-r--r--quantum/quantum.c463
-rw-r--r--quantum/quantum.h61
18 files changed, 735 insertions, 613 deletions
diff --git a/quantum/audio/audio.h b/quantum/audio/audio.h
index 00d45f7ac1..47f326ea0a 100644
--- a/quantum/audio/audio.h
+++ b/quantum/audio/audio.h
@@ -1,3 +1,6 @@
+#ifndef AUDIO_H
+#define AUDIO_H
+
#include <stdint.h>
#include <stdbool.h>
#include <avr/io.h>
@@ -7,9 +10,6 @@
#include "voices.h"
#include "quantum.h"
-#ifndef AUDIO_H
-#define AUDIO_H
-
// Largely untested PWM audio mode (doesn't sound as good)
// #define PWM_AUDIO
diff --git a/quantum/keymap.h b/quantum/keymap.h
index 41fa394ab6..a994f4f2e5 100644
--- a/quantum/keymap.h
+++ b/quantum/keymap.h
@@ -77,6 +77,8 @@ enum quantum_keycodes {
#endif
QK_MOD_TAP = 0x6000,
QK_MOD_TAP_MAX = 0x6FFF,
+ QK_TAP_DANCE = 0x7100,
+ QK_TAP_DANCE_MAX = 0x71FF,
#ifdef UNICODE_ENABLE
QK_UNICODE = 0x8000,
QK_UNICODE_MAX = 0xFFFF,
diff --git a/quantum/keymap_midi.c b/quantum/keymap_midi.c
deleted file mode 100644
index 46049b9875..0000000000
--- a/quantum/keymap_midi.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-Copyright 2015 Jack Humbert <jack.humb@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "keymap.h"
-#include "keymap_midi.h"
-
-uint8_t starting_note = 0x0C;
-int offset = 7;
-
-void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
-{
- if (id != 0) {
- if (record->event.pressed) {
- midi_send_noteon(&midi_device, opt, (id & 0xFF), 127);
- } else {
- midi_send_noteoff(&midi_device, opt, (id & 0xFF), 127);
- }
- }
-
- if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
- if (record->event.pressed) {
- starting_note++;
- play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- midi_send_cc(&midi_device, 1, 0x7B, 0);
- midi_send_cc(&midi_device, 2, 0x7B, 0);
- midi_send_cc(&midi_device, 3, 0x7B, 0);
- midi_send_cc(&midi_device, 4, 0x7B, 0);
- return;
- } else {
- stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)));
- stop_all_notes();
- return;
- }
- }
- if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
- if (record->event.pressed) {
- starting_note--;
- play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- midi_send_cc(&midi_device, 1, 0x7B, 0);
- midi_send_cc(&midi_device, 2, 0x7B, 0);
- midi_send_cc(&midi_device, 3, 0x7B, 0);
- midi_send_cc(&midi_device, 4, 0x7B, 0);
- return;
- } else {
- stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[0 + offset])/12.0+(MATRIX_ROWS - 1)));
- stop_all_notes();
- return;
- }
- }
-
- if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
- offset++;
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- midi_send_cc(&midi_device, 1, 0x7B, 0);
- midi_send_cc(&midi_device, 2, 0x7B, 0);
- midi_send_cc(&midi_device, 3, 0x7B, 0);
- midi_send_cc(&midi_device, 4, 0x7B, 0);
- stop_all_notes();
- for (int i = 0; i <= 7; i++) {
- play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
- _delay_us(80000);
- stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)));
- _delay_us(8000);
- }
- return;
- }
- if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
- offset--;
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- midi_send_cc(&midi_device, 1, 0x7B, 0);
- midi_send_cc(&midi_device, 2, 0x7B, 0);
- midi_send_cc(&midi_device, 3, 0x7B, 0);
- midi_send_cc(&midi_device, 4, 0x7B, 0);
- stop_all_notes();
- for (int i = 0; i <= 7; i++) {
- play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)), 0xC);
- _delay_us(80000);
- stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[i + offset])/12.0+(MATRIX_ROWS - 1)));
- _delay_us(8000);
- }
- return;
- }
-
- if (record->event.pressed) {
- // midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
- // midi_send_noteon(&midi_device, 0, (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row), 127);
- play_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)), 0xF);
- } else {
- // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
- // midi_send_noteoff(&midi_device, 0, (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row), 127);
- stop_note(((double)261.626)*pow(2.0, -1.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)));
- }
-} \ No newline at end of file
diff --git a/quantum/matrix.c b/quantum/matrix.c
index 6e9f92727f..f5744658cf 100644
--- a/quantum/matrix.c
+++ b/quantum/matrix.c
@@ -86,29 +86,29 @@ uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
-void matrix_power_up(void) {
-#if DIODE_DIRECTION == COL2ROW
- for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
- /* DDRxn */
- _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
- toggle_row(r);
- }
- for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
- /* PORTxn */
- _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
- }
-#else
- for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
- /* DDRxn */
- _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
- toggle_col(c);
- }
- for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
- /* PORTxn */
- _SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
- }
-#endif
-}
+// void matrix_power_up(void) {
+// #if DIODE_DIRECTION == COL2ROW
+// for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+// /* DDRxn */
+// _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
+// toggle_row(r);
+// }
+// for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+// /* PORTxn */
+// _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
+// }
+// #else
+// for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
+// /* DDRxn */
+// _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
+// toggle_col(c);
+// }
+// for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
+// /* PORTxn */
+// _SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
+// }
+// #endif
+// }
void matrix_init(void) {
/* frees PORTF by setting the JTD bit twice within four cycles */
diff --git a/quantum/process_keycode/process_chording.c b/quantum/process_keycode/process_chording.c
new file mode 100644
index 0000000000..d7814629f3
--- /dev/null
+++ b/quantum/process_keycode/process_chording.c
@@ -0,0 +1,60 @@
+#include "process_chording.h"
+
+bool keys_chord(uint8_t keys[]) {
+ uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
+ bool pass = true;
+ uint8_t in = 0;
+ for (uint8_t i = 0; i < chord_key_count; i++) {
+ bool found = false;
+ for (uint8_t j = 0; j < keys_size; j++) {
+ if (chord_keys[i] == (keys[j] & 0xFF)) {
+ in++; // detects key in chord
+ found = true;
+ break;
+ }
+ }
+ if (found)
+ continue;
+ if (chord_keys[i] != 0) {
+ pass = false; // makes sure rest are blank
+ }
+ }
+ return (pass && (in == keys_size));
+}
+
+bool process_chording(uint16_t keycode, keyrecord_t *record) {
+ if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
+ if (record->event.pressed) {
+ if (!chording) {
+ chording = true;
+ for (uint8_t i = 0; i < CHORDING_MAX; i++)
+ chord_keys[i] = 0;
+ chord_key_count = 0;
+ chord_key_down = 0;
+ }
+ chord_keys[chord_key_count] = (keycode & 0xFF);
+ chord_key_count++;
+ chord_key_down++;
+ return false;
+ } else {
+ if (chording) {
+ chord_key_down--;
+ if (chord_key_down == 0) {
+ chording = false;
+ // Chord Dictionary
+ if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
+ register_code(KC_A);
+ unregister_code(KC_A);
+ return false;
+ }
+ for (uint8_t i = 0; i < chord_key_count; i++) {
+ register_code(chord_keys[i]);
+ unregister_code(chord_keys[i]);
+ return false;
+ }
+ }
+ }
+ }
+ }
+ return true;
+} \ No newline at end of file
diff --git a/quantum/process_keycode/process_chording.h b/quantum/process_keycode/process_chording.h
new file mode 100644
index 0000000000..49c97db3bc
--- /dev/null
+++ b/quantum/process_keycode/process_chording.h
@@ -0,0 +1,16 @@
+#ifndef PROCESS_CHORDING_H
+#define PROCESS_CHORDING_H
+
+#include "quantum.h"
+
+// Chording stuff
+#define CHORDING_MAX 4
+bool chording = false;
+
+uint8_t chord_keys[CHORDING_MAX] = {0};
+uint8_t chord_key_count = 0;
+uint8_t chord_key_down = 0;
+
+bool process_chording(uint16_t keycode, keyrecord_t *record);
+
+#endif \ No newline at end of file
diff --git a/quantum/process_keycode/process_leader.c b/quantum/process_keycode/process_leader.c
new file mode 100644
index 0000000000..e53d221e75
--- /dev/null
+++ b/quantum/process_keycode/process_leader.c
@@ -0,0 +1,38 @@
+#include "process_leader.h"
+
+__attribute__ ((weak))
+void leader_start(void) {}
+
+__attribute__ ((weak))
+void leader_end(void) {}
+
+// Leader key stuff
+bool leading = false;
+uint16_t leader_time = 0;
+
+uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
+uint8_t leader_sequence_size = 0;
+
+bool process_leader(uint16_t keycode, keyrecord_t *record) {
+ // Leader key set-up
+ if (record->event.pressed) {
+ if (!leading && keycode == KC_LEAD) {
+ leader_start();
+ leading = true;
+ leader_time = timer_read();
+ leader_sequence_size = 0;
+ leader_sequence[0] = 0;
+ leader_sequence[1] = 0;
+ leader_sequence[2] = 0;
+ leader_sequence[3] = 0;
+ leader_sequence[4] = 0;
+ return false;
+ }
+ if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
+ leader_sequence[leader_sequence_size] = keycode;
+ leader_sequence_size++;
+ return false;
+ }
+ }
+ return true;
+} \ No newline at end of file
diff --git a/quantum/process_keycode/process_leader.h b/quantum/process_keycode/process_leader.h
new file mode 100644
index 0000000000..c83db8abbd
--- /dev/null
+++ b/quantum/process_keycode/process_leader.h
@@ -0,0 +1,23 @@
+#ifndef PROCESS_LEADER_H
+#define PROCESS_LEADER_H
+
+#include "quantum.h"
+
+bool process_leader(uint16_t keycode, keyrecord_t *record);
+
+void leader_start(void);
+void leader_end(void);
+
+#ifndef LEADER_TIMEOUT
+ #define LEADER_TIMEOUT 200
+#endif
+#define SEQ_ONE_KEY(key) if (leader_sequence[0] == (key) && leader_sequence[1] == 0 && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_TWO_KEYS(key1, key2) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_THREE_KEYS(key1, key2, key3) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#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_DICTIONARY() if (leading && timer_elapsed(leader_time) > LEADER_TIMEOUT)
+
+#endif \ No newline at end of file
diff --git a/quantum/process_keycode/process_midi.c b/quantum/process_keycode/process_midi.c
new file mode 100644
index 0000000000..d6ab9c6264
--- /dev/null
+++ b/quantum/process_keycode/process_midi.c
@@ -0,0 +1,66 @@
+#include "process_midi.h"
+
+bool midi_activated = false;
+uint8_t starting_note = 0x0C;
+int offset = 7;
+
+bool process_midi(uint16_t keycode, keyrecord_t *record) {
+ if (keycode == MI_ON && record->event.pressed) {
+ midi_activated = true;
+ music_scale_user();
+ return false;
+ }
+
+ if (keycode == MI_OFF && record->event.pressed) {
+ midi_activated = false;
+ midi_send_cc(&midi_device, 0, 0x7B, 0);
+ return false;
+ }
+
+ if (midi_activated) {
+ if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
+ if (record->event.pressed) {
+ starting_note++; // Change key
+ midi_send_cc(&midi_device, 0, 0x7B, 0);
+ }
+ return false;
+ }
+ if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
+ if (record->event.pressed) {
+ starting_note--; // Change key
+ midi_send_cc(&midi_device, 0, 0x7B, 0);
+ }
+ return false;
+ }
+ if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
+ offset++; // Change scale
+ midi_send_cc(&midi_device, 0, 0x7B, 0);
+ return false;
+ }
+ if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
+ offset--; // Change scale
+ midi_send_cc(&midi_device, 0, 0x7B, 0);
+ return false;
+ }
+ // basic
+ // uint8_t note = (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row);
+ // advanced
+ // uint8_t note = (starting_note + record->event.key.col + offset)+12*(MATRIX_ROWS - record->event.key.row);
+ // guitar
+ uint8_t note = (starting_note + record->event.key.col + offset)+5*(MATRIX_ROWS - record->event.key.row);
+ // violin
+ // uint8_t note = (starting_note + record->event.key.col + offset)+7*(MATRIX_ROWS - record->event.key.row);
+
+ if (record->event.pressed) {
+ // midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+ midi_send_noteon(&midi_device, 0, note, 127);
+ } else {
+ // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
+ midi_send_noteoff(&midi_device, 0, note, 127);
+ }
+
+ if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
+ return false;
+ }
+ return true;
+} \ No newline at end of file
diff --git a/quantum/keymap_midi.h b/quantum/process_keycode/process_midi.h
index 3a2bf3afff..acd4fc1b16 100644
--- a/quantum/keymap_midi.h
+++ b/quantum/process_keycode/process_midi.h
@@ -1,24 +1,9 @@
-/*
-Copyright 2015 Jack Humbert <jack.humb@gmail.com>
+#ifndef PROCESS_MIDI_H
+#define PROCESS_MIDI_H
-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.
+#include "quantum.h"
-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_MIDI_H
-#define KEYMAP_MIDI_H
-
-#include <lufa.h>
+bool process_midi(uint16_t keycode, keyrecord_t *record);
#define MIDI(n) ((n) | 0x6000)
#define MIDI12 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000
diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c
new file mode 100644
index 0000000000..c8f3ddb900
--- /dev/null
+++ b/quantum/process_keycode/process_music.c
@@ -0,0 +1,171 @@
+#include "process_music.h"
+
+bool music_activated = false;
+uint8_t starting_note = 0x0C;
+int offset = 7;
+
+// music sequencer
+static bool music_sequence_recording = false;
+static bool music_sequence_playing = false;
+static float music_sequence[16] = {0};
+static uint8_t music_sequence_count = 0;
+static uint8_t music_sequence_position = 0;
+
+static uint16_t music_sequence_timer = 0;
+static uint16_t music_sequence_interval = 100;
+
+bool process_music(uint16_t keycode, keyrecord_t *record) {
+
+ if (keycode == AU_ON && record->event.pressed) {
+ audio_on();
+ return false;
+ }
+
+ if (keycode == AU_OFF && record->event.pressed) {
+ audio_off();
+ return false;
+ }
+
+ if (keycode == AU_TOG && record->event.pressed) {
+ if (is_audio_on())
+ {
+ audio_off();
+ }
+ else
+ {
+ audio_on();
+ }
+ return false;
+ }
+
+ if (keycode == MU_ON && record->event.pressed) {
+ music_on();
+ return false;
+ }
+
+ if (keycode == MU_OFF && record->event.pressed) {
+ music_off();
+ return false;
+ }
+
+ if (keycode == MU_TOG && record->event.pressed) {
+ if (music_activated)
+ {
+ music_off();
+ }
+ else
+ {
+ music_on();
+ }
+ return false;
+ }
+
+ if (keycode == MUV_IN && record->event.pressed) {
+ voice_iterate();
+ music_scale_user();
+ return false;
+ }
+
+ if (keycode == MUV_DE && record->event.pressed) {
+ voice_deiterate();
+ music_scale_user();
+ return false;
+ }
+
+ if (music_activated) {
+
+ if (keycode == KC_LCTL && record->event.pressed) { // Start recording
+ stop_all_notes();
+ music_sequence_recording = true;
+ music_sequence_playing = false;
+ music_sequence_count = 0;
+ return false;
+ }
+
+ if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
+ stop_all_notes();
+ music_sequence_recording = false;
+ music_sequence_playing = false;
+ return false;
+ }
+
+ if (keycode == KC_LGUI && record->event.pressed) { // Start playing
+ stop_all_notes();
+ music_sequence_recording = false;
+ music_sequence_playing = true;
+ music_sequence_position = 0;
+ music_sequence_timer = 0;
+ return false;
+ }
+
+ if (keycode == KC_UP) {
+ if (record->event.pressed)
+ music_sequence_interval-=10;
+ return false;
+ }
+
+ if (keycode == KC_DOWN) {
+ if (record->event.pressed)
+ music_sequence_interval+=10;
+ return false;
+ }
+
+ float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row));
+ if (record->event.pressed) {
+ play_note(freq, 0xF);
+ if (music_sequence_recording) {
+ music_sequence[music_sequence_count] = freq;
+ music_sequence_count++;
+ }
+ } else {
+ stop_note(freq);
+ }
+
+ if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
+ return false;
+ }
+ return true;
+}
+
+bool is_music_on(void) {
+ return (music_activated != 0);
+}
+
+void music_toggle(void) {
+ if (!music_activated) {
+ music_on();
+ } else {
+ music_off();
+ }
+}
+
+void music_on(void) {
+ music_activated = 1;
+ music_on_user();
+}
+
+void music_off(void) {
+ music_activated = 0;
+ stop_all_notes();
+}
+
+
+__attribute__ ((weak))
+void music_on_user() {}
+
+__attribute__ ((weak))
+void audio_on_user() {}
+
+__attribute__ ((weak))
+void music_scale_user() {}
+
+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();
+ stop_note(music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)]);
+ play_note(music_sequence[music_sequence_position], 0xF);
+ music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
+ }
+ }
+}
diff --git a/quantum/process_keycode/process_music.h b/quantum/process_keycode/process_music.h
new file mode 100644
index 0000000000..318b3e3875
--- /dev/null
+++ b/quantum/process_keycode/process_music.h
@@ -0,0 +1,27 @@
+#ifndef PROCESS_MUSIC_H
+#define PROCESS_MUSIC_H
+
+#include "quantum.h"
+
+bool process_music(uint16_t keycode, keyrecord_t *record);
+
+bool is_music_on(void);
+void music_toggle(void);
+void music_on(void);
+void music_off(void);
+
+void audio_on_user(void);
+void music_on_user(void);
+void music_scale_user(void);
+
+void matrix_scan_music(void);
+
+#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 \ No newline at end of file
diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
new file mode 100644
index 0000000000..9b172e1b6c
--- /dev/null
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -0,0 +1,90 @@
+#include "quantum.h"
+
+static qk_tap_dance_state_t qk_tap_dance_state;
+
+static void _process_tap_dance_action_pair (qk_tap_dance_state_t *state,
+ uint16_t kc1, uint16_t kc2) {
+ uint16_t kc;
+
+ if (state->count == 0)
+ return;
+
+ kc = (state->count == 1) ? kc1 : kc2;
+
+ register_code (kc);
+ unregister_code (kc);
+
+ if (state->count >= 2) {
+ reset_tap_dance (state);
+ }
+}
+
+static void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
+ qk_tap_dance_user_fn_t fn)
+{
+ fn(state);
+}
+
+void process_tap_dance_action (uint16_t keycode)
+{
+ uint16_t idx = keycode - QK_TAP_DANCE;
+ qk_tap_dance_action_t action;
+
+ action = tap_dance_actions[idx];
+
+ switch (action.type) {
+ case QK_TAP_DANCE_TYPE_PAIR:
+ _process_tap_dance_action_pair (&qk_tap_dance_state,
+ action.pair.kc1, action.pair.kc2);
+ break;
+ case QK_TAP_DANCE_TYPE_FN:
+ _process_tap_dance_action_fn (&qk_tap_dance_state, action.fn);
+ break;
+
+ default:
+ break;
+ }
+}
+
+bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
+ bool r = true;
+
+ switch(keycode) {
+ case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
+ if (qk_tap_dance_state.keycode && qk_tap_dance_state.keycode != keycode) {
+ process_tap_dance_action (qk_tap_dance_state.keycode);
+ } else {
+ r = false;
+ }
+
+ if (record->event.pressed) {
+ qk_tap_dance_state.keycode = keycode;
+ qk_tap_dance_state.timer = timer_read ();
+ qk_tap_dance_state.count++;
+ }
+ break;
+
+ default:
+ if (qk_tap_dance_state.keycode) {
+ process_tap_dance_action (qk_tap_dance_state.keycode);
+
+ reset_tap_dance (&qk_tap_dance_state);
+ }
+ break;
+ }
+
+ return r;
+}
+
+void matrix_scan_tap_dance () {
+ if (qk_tap_dance_state.keycode && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {
+ process_tap_dance_action (qk_tap_dance_state.keycode);
+
+ reset_tap_dance (&qk_tap_dance_state);
+ }
+}
+
+void reset_tap_dance (qk_tap_dance_state_t *state) {
+ state->keycode = 0;
+ state->count = 0;
+}
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
new file mode 100644
index 0000000000..b9d7c7fcf4
--- /dev/null
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -0,0 +1,62 @@
+#ifndef PROCESS_TAP_DANCE_H
+#define PROCESS_TAP_DANCE_H
+
+#ifdef TAP_DANCE_ENABLE
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+typedef struct
+{
+ uint8_t count;
+ uint16_t keycode;
+ uint16_t timer;
+} qk_tap_dance_state_t;
+
+#define TD(n) (QK_TAP_DANCE + n)
+
+typedef enum
+{
+ QK_TAP_DANCE_TYPE_PAIR,
+ QK_TAP_DANCE_TYPE_FN,
+} qk_tap_dance_type_t;
+
+typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state);
+
+typedef struct
+{
+ qk_tap_dance_type_t type;
+ union {
+ struct {
+ uint16_t kc1;
+ uint16_t kc2;
+ } pair;
+ qk_tap_dance_user_fn_t fn;
+ };
+} qk_tap_dance_action_t;
+
+#define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) { \
+ .type = QK_TAP_DANCE_TYPE_PAIR, \
+ .pair = { kc1, kc2 } \
+ }
+
+#define ACTION_TAP_DANCE_FN(user_fn) { \
+ .type = QK_TAP_DANCE_TYPE_FN, \
+ .fn = user_fn \
+ }
+
+extern const qk_tap_dance_action_t tap_dance_actions[];
+
+/* To be used internally */
+
+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);
+
+#else
+
+#define TD(n) KC_NO
+
+#endif
+
+#endif
diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
new file mode 100644
index 0000000000..ad5d7f86b7
--- /dev/null
+++ b/quantum/process_keycode/process_unicode.c
@@ -0,0 +1,57 @@
+#include "process_unicode.h"
+
+static uint8_t input_mode;
+
+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_mode(uint8_t os_target)
+{
+ input_mode = os_target;
+}
+
+bool process_unicode(uint16_t keycode, keyrecord_t *record) {
+ if (keycode > QK_UNICODE && record->event.pressed) {
+ uint16_t unicode = keycode & 0x7FFF;
+ 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);
+ break;
+ case UC_WIN:
+ register_code(KC_LALT);
+ register_code(KC_PPLS);
+ unregister_code(KC_PPLS);
+ break;
+ }
+ for(int i = 3; i >= 0; i--) {
+ uint8_t digit = ((unicode >> (i*4)) & 0xF);
+ register_code(hex_to_keycode(digit));
+ unregister_code(hex_to_keycode(digit));
+ }
+ switch(input_mode) {
+ case UC_OSX:
+ case UC_WIN:
+ unregister_code(KC_LALT);
+ break;
+ case UC_LNX:
+ unregister_code(KC_LCTL);
+ unregister_code(KC_LSFT);
+ break;
+ }
+ }
+ return true;
+} \ No newline at end of file
diff --git a/quantum/unicode.h b/quantum/process_keycode/process_unicode.h
index 756ec8bc3f..ca17f8f669 100644
--- a/quantum/unicode.h
+++ b/quantum/process_keycode/process_unicode.h
@@ -1,22 +1,16 @@
-/*
-Copyright 2016 Jack Humbert <jack.humb@gmail.com>
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef UNICODE_H
-#define UNICODE_H
+#ifndef PROCESS_UNICODE_H
+#define PROCESS_UNICODE_H
#include "quantum.h"
-#include <math.h>
+
+#define UC_OSX 0
+#define UC_LNX 1
+#define UC_WIN 2
+#define UC_BSD 3
+
+void set_unicode_input_mode(uint8_t os_target);
+
+bool process_unicode(uint16_t keycode, keyrecord_t *record);
#define UC_BSPC UC(0x0008)
diff --git a/quantum/quantum.c b/quantum/quantum.c
index 9c0f9691ff..270b976e36 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -15,54 +15,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true;
}
-__attribute__ ((weak))
-void leader_start(void) {}
-
-__attribute__ ((weak))
-void leader_end(void) {}
-
-uint8_t starting_note = 0x0C;
-int offset = 7;
-
-
-#ifdef AUDIO_ENABLE
- bool music_activated = false;
-
- // music sequencer
- static bool music_sequence_recording = false;
- static bool music_sequence_playing = false;
- static float music_sequence[16] = {0};
- static uint8_t music_sequence_count = 0;
- static uint8_t music_sequence_position = 0;
-
- static uint16_t music_sequence_timer = 0;
- static uint16_t music_sequence_interval = 100;
-
-#endif
-
-#ifdef MIDI_ENABLE
- bool midi_activated = false;
-#endif
-
-// Leader key stuff
-bool leading = false;
-uint16_t leader_time = 0;
-
-uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
-uint8_t leader_sequence_size = 0;
-
-// Chording stuff
-#define CHORDING_MAX 4
-bool chording = false;
-
-uint8_t chord_keys[CHORDING_MAX] = {0};
-uint8_t chord_key_count = 0;
-uint8_t chord_key_down = 0;
-
-#ifdef UNICODE_ENABLE
- static uint8_t input_mode;
-#endif
-
// Shift / paren setup
#ifndef LSPO_KEY
@@ -74,48 +26,6 @@ uint8_t chord_key_down = 0;
static bool shift_interrupted[2] = {0, 0};
-bool keys_chord(uint8_t keys[]) {
- uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
- bool pass = true;
- uint8_t in = 0;
- for (uint8_t i = 0; i < chord_key_count; i++) {
- bool found = false;
- for (uint8_t j = 0; j < keys_size; j++) {
- if (chord_keys[i] == (keys[j] & 0xFF)) {
- in++; // detects key in chord
- found = true;
- break;
- }
- }
- if (found)
- continue;
- if (chord_keys[i] != 0) {
- pass = false; // makes sure rest are blank
- }
- }
- return (pass && (in == keys_size));
-}
-
-#ifdef UNICODE_ENABLE
-
-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_mode(uint8_t os_target)
-{
- input_mode = os_target;
-}
-
-#endif
-
bool process_record_quantum(keyrecord_t *record) {
/* This gets the keycode from the key pressed */
@@ -136,9 +46,6 @@ bool process_record_quantum(keyrecord_t *record) {
keycode = keymap_key_to_keycode(layer_switch_get_layer(key), key);
#endif
- if (!process_record_kb(keycode, record))
- return false;
-
// This is how you use actions here
// if (keycode == KC_LEAD) {
// action_t action;
@@ -147,278 +54,30 @@ bool process_record_quantum(keyrecord_t *record) {
// return false;
// }
+ if (!(
+ process_record_kb(keycode, record) &&
#ifdef MIDI_ENABLE
- if (keycode == MI_ON && record->event.pressed) {
- midi_activated = true;
- music_scale_user();
- return false;
- }
-
- if (keycode == MI_OFF && record->event.pressed) {
- midi_activated = false;
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- return false;
- }
-
- if (midi_activated) {
- if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
- if (record->event.pressed) {
- starting_note++; // Change key
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- }
- return false;
- }
- if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
- if (record->event.pressed) {
- starting_note--; // Change key
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- }
- return false;
- }
- if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
- offset++; // Change scale
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- return false;
- }
- if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
- offset--; // Change scale
- midi_send_cc(&midi_device, 0, 0x7B, 0);
- return false;
- }
- // basic
- // uint8_t note = (starting_note + SCALE[record->event.key.col + offset])+12*(MATRIX_ROWS - record->event.key.row);
- // advanced
- // uint8_t note = (starting_note + record->event.key.col + offset)+12*(MATRIX_ROWS - record->event.key.row);
- // guitar
- uint8_t note = (starting_note + record->event.key.col + offset)+5*(MATRIX_ROWS - record->event.key.row);
- // violin
- // uint8_t note = (starting_note + record->event.key.col + offset)+7*(MATRIX_ROWS - record->event.key.row);
-
- if (record->event.pressed) {
- // midi_send_noteon(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
- midi_send_noteon(&midi_device, 0, note, 127);
- } else {
- // midi_send_noteoff(&midi_device, record->event.key.row, starting_note + SCALE[record->event.key.col], 127);
- midi_send_noteoff(&midi_device, 0, note, 127);
- }
-
- if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
- return false;
- }
+ process_midi(keycode, record) &&
#endif
-
#ifdef AUDIO_ENABLE
- if (keycode == AU_ON && record->event.pressed) {
- audio_on();
- return false;
- }
-
- if (keycode == AU_OFF && record->event.pressed) {
- audio_off();
- return false;
- }
-
- if (keycode == AU_TOG && record->event.pressed) {
- if (is_audio_on())
- {
- audio_off();
- }
- else
- {
- audio_on();
- }
- return false;
- }
-
- if (keycode == MU_ON && record->event.pressed) {
- music_on();
- return false;
- }
-
- if (keycode == MU_OFF && record->event.pressed) {
- music_off();
- return false;
- }
-
- if (keycode == MU_TOG && record->event.pressed) {
- if (music_activated)
- {
- music_off();
- }
- else
- {
- music_on();
- }
- return false;
- }
-
- if (keycode == MUV_IN && record->event.pressed) {
- voice_iterate();
- music_scale_user();
- return false;
- }
-
- if (keycode == MUV_DE && record->event.pressed) {
- voice_deiterate();
- music_scale_user();
- return false;
- }
-
- if (music_activated) {
-
- if (keycode == KC_LCTL && record->event.pressed) { // Start recording
- stop_all_notes();
- music_sequence_recording = true;
- music_sequence_playing = false;
- music_sequence_count = 0;
- return false;
- }
-
- if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
- stop_all_notes();
- music_sequence_recording = false;
- music_sequence_playing = false;
- return false;
- }
-
- if (keycode == KC_LGUI && record->event.pressed) { // Start playing
- stop_all_notes();
- music_sequence_recording = false;
- music_sequence_playing = true;
- music_sequence_position = 0;
- music_sequence_timer = 0;
- return false;
- }
-
- if (keycode == KC_UP) {
- if (record->event.pressed)
- music_sequence_interval-=10;
- return false;
- }
-
- if (keycode == KC_DOWN) {
- if (record->event.pressed)
- music_sequence_interval+=10;
- return false;
- }
-
- float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row));
- if (record->event.pressed) {
- play_note(freq, 0xF);
- if (music_sequence_recording) {
- music_sequence[music_sequence_count] = freq;
- music_sequence_count++;
- }
- } else {
- stop_note(freq);
- }
-
- if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
- return false;
- }
+ process_music(keycode, record) &&
#endif
-
-#ifndef DISABLE_LEADER
- // Leader key set-up
- if (record->event.pressed) {
- if (!leading && keycode == KC_LEAD) {
- leader_start();
- leading = true;
- leader_time = timer_read();
- leader_sequence_size = 0;
- leader_sequence[0] = 0;
- leader_sequence[1] = 0;
- leader_sequence[2] = 0;
- leader_sequence[3] = 0;
- leader_sequence[4] = 0;
- return false;
- }
- if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
- leader_sequence[leader_sequence_size] = keycode;
- leader_sequence_size++;
- return false;
- }
- }
-#endif
-
-#define DISABLE_CHORDING
-#ifndef DISABLE_CHORDING
-
- if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
- if (record->event.pressed) {
- if (!chording) {
- chording = true;
- for (uint8_t i = 0; i < CHORDING_MAX; i++)
- chord_keys[i] = 0;
- chord_key_count = 0;
- chord_key_down = 0;
- }
- chord_keys[chord_key_count] = (keycode & 0xFF);
- chord_key_count++;
- chord_key_down++;
- return false;
- } else {
- if (chording) {
- chord_key_down--;
- if (chord_key_down == 0) {
- chording = false;
- // Chord Dictionary
- if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
- register_code(KC_A);
- unregister_code(KC_A);
- return false;
- }
- for (uint8_t i = 0; i < chord_key_count; i++) {
- register_code(chord_keys[i]);
- unregister_code(chord_keys[i]);
- return false;
- }
- }
- }
- }
- }
-
-#endif
-
-#ifdef UNICODE_ENABLE
-
- if (keycode > QK_UNICODE && record->event.pressed) {
- uint16_t unicode = keycode & 0x7FFF;
- 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);
- break;
- case UC_WIN:
- register_code(KC_LALT);
- register_code(KC_PPLS);
- unregister_code(KC_PPLS);
- break;
- }
- for(int i = 3; i >= 0; i--) {
- uint8_t digit = ((unicode >> (i*4)) & 0xF);
- register_code(hex_to_keycode(digit));
- unregister_code(hex_to_keycode(digit));
- }
- switch(input_mode) {
- case UC_OSX:
- case UC_WIN:
- unregister_code(KC_LALT);
- break;
- case UC_LNX:
- unregister_code(KC_LCTL);
- unregister_code(KC_LSFT);
- break;
- }
+ #ifdef TAP_DANCE_ENABLE
+ process_tap_dance(keycode, record) &&
+ #endif
+ #ifndef DISABLE_LEADER
+ process_leader(keycode, record) &&
+ #endif
+ #ifndef DISABLE_CHORDING
+ process_chording(keycode, record) &&
+ #endif
+ #ifdef UNICODE_ENABLE
+ process_unicode(keycode, record) &&
+ #endif
+ true)) {
+ return false;
}
-#endif
-
// Shift / paren setup
switch(keycode) {
@@ -648,6 +307,44 @@ void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
}
}
+void tap_random_base64(void) {
+ #if defined(__AVR_ATmega32U4__)
+ uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
+ #else
+ uint8_t key = rand() % 64;
+ #endif
+ switch (key) {
+ case 0 ... 25:
+ register_code(KC_LSFT);
+ register_code(key + KC_A);
+ unregister_code(key + KC_A);
+ unregister_code(KC_LSFT);
+ break;
+ case 26 ... 51:
+ register_code(key - 26 + KC_A);
+ unregister_code(key - 26 + KC_A);
+ break;
+ case 52:
+ register_code(KC_0);
+ unregister_code(KC_0);
+ break;
+ case 53 ... 61:
+ register_code(key - 53 + KC_1);
+ unregister_code(key - 53 + KC_1);
+ break;
+ case 62:
+ register_code(KC_LSFT);
+ register_code(KC_EQL);
+ unregister_code(KC_EQL);
+ unregister_code(KC_LSFT);
+ break;
+ case 63:
+ register_code(KC_SLSH);
+ unregister_code(KC_SLSH);
+ break;
+ }
+}
+
void matrix_init_quantum() {
#ifdef BACKLIGHT_ENABLE
backlight_init_ports();
@@ -657,46 +354,15 @@ void matrix_init_quantum() {
void matrix_scan_quantum() {
#ifdef AUDIO_ENABLE
- if (music_sequence_playing) {
- if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
- music_sequence_timer = timer_read();
- stop_note(music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)]);
- play_note(music_sequence[music_sequence_position], 0xF);
- music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
- }
- }
-
+ matrix_scan_music();
#endif
+ #ifdef TAP_DANCE_ENABLE
+ matrix_scan_tap_dance();
+ #endif
matrix_scan_kb();
}
-#ifdef AUDIO_ENABLE
- bool is_music_on(void) {
- return (music_activated != 0);
- }
-
- void music_toggle(void) {
- if (!music_activated) {
- music_on();
- } else {
- music_off();
- }
- }
-
- void music_on(void) {
- music_activated = 1;
- music_on_user();
- }
-
- void music_off(void) {
- music_activated = 0;
- stop_all_notes();
- }
-
-#endif
-
-
#if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
static const uint8_t backlight_pin = BACKLIGHT_PIN;
@@ -1048,13 +714,4 @@ void startup_user() {}
__attribute__ ((weak))
void shutdown_user() {}
-__attribute__ ((weak))
-void music_on_user() {}
-
-__attribute__ ((weak))
-void audio_on_user() {}
-
-__attribute__ ((weak))
-void music_scale_user() {}
-
//------------------------------------------------------------------------------
diff --git a/quantum/quantum.h b/quantum/quantum.h
index 7795294d50..9b5d310bd4 100644
--- a/quantum/quantum.h
+++ b/quantum/quantum.h
@@ -10,15 +10,6 @@
#ifdef RGBLIGHT_ENABLE
#include "rgblight.h"
#endif
-#ifdef AUDIO_ENABLE
- #include "audio.h"
-#endif
-#ifdef MIDI_ENABLE
- #include <lufa.h>
-#endif
-#ifdef UNICODE_ENABLE
- #include "unicode.h"
-#endif
#include "action_layer.h"
#include "eeconfig.h"
@@ -31,6 +22,8 @@
#include <avr/interrupt.h>
#include "led.h"
#include "action_util.h"
+#include <stdlib.h>
+
extern uint32_t default_layer_state;
@@ -38,41 +31,39 @@ extern uint32_t default_layer_state;
extern uint32_t layer_state;
#endif
+#ifdef MIDI_ENABLE
+ #include <lufa.h>
+ #include "process_midi.h"
+#endif
+
#ifdef AUDIO_ENABLE
- bool music_activated;
+ #include "audio.h"
+ #include "process_music.h"
#endif
-#ifdef UNICODE_ENABLE
- #define UC_OSX 0
- #define UC_LNX 1
- #define UC_WIN 2
- #define UC_BSD 3
+#ifndef DISABLE_LEADER
+ #include "process_leader.h"
+#endif
- void set_unicode_input_mode(uint8_t os_target);
+#define DISABLE_CHORDING
+#ifndef DISABLE_CHORDING
+ #include "process_chording.h"
#endif
-#ifndef DISABLE_LEADER
- void leader_start(void);
- void leader_end(void);
-
- #ifndef LEADER_TIMEOUT
- #define LEADER_TIMEOUT 200
- #endif
- #define SEQ_ONE_KEY(key) if (leader_sequence[0] == (key) && leader_sequence[1] == 0 && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
- #define SEQ_TWO_KEYS(key1, key2) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
- #define SEQ_THREE_KEYS(key1, key2, key3) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == 0 && leader_sequence[4] == 0)
- #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_DICTIONARY() if (leading && timer_elapsed(leader_time) > LEADER_TIMEOUT)
+#ifdef UNICODE_ENABLE
+ #include "process_unicode.h"
#endif
+#include "process_tap_dance.h"
+
#define SEND_STRING(str) send_string(PSTR(str))
void send_string(const char *str);
// For tri-layer
void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3);
+
+void tap_random_base64(void);
+
#define IS_LAYER_ON(layer) (layer_state & (1UL << (layer)))
#define IS_LAYER_OFF(layer) (~layer_state & (1UL << (layer)))
@@ -84,16 +75,8 @@ bool process_action_kb(keyrecord_t *record);
bool process_record_kb(uint16_t keycode, keyrecord_t *record);
bool process_record_user(uint16_t keycode, keyrecord_t *record);
-bool is_music_on(void);
-void music_toggle(void);
-void music_on(void);
-void music_off(void);
-
void startup_user(void);
void shutdown_user(void);
-void audio_on_user(void);
-void music_on_user(void);
-void music_scale_user(void);
#ifdef BACKLIGHT_ENABLE
void backlight_init_ports(void);