aboutsummaryrefslogtreecommitdiff
path: root/quantum/process_keycode
diff options
context:
space:
mode:
authorNick Brassel <[email protected]>2024-08-26 10:01:57 +1000
committerNick Brassel <[email protected]>2024-08-26 10:01:57 +1000
commit5d76c5280dc0aff398cdce19fa54d0e0725c418d (patch)
tree40026340f0d524a6006f18f01ef988e15d271075 /quantum/process_keycode
parente6a898e3eea3521d3f0497ee26937d5269d78fb7 (diff)
parent81dcf2b547bacc42bd9cf8ccaccd3d7164e69926 (diff)
downloadqmk_firmware-5d76c5280dc0aff398cdce19fa54d0e0725c418d.tar.gz
qmk_firmware-5d76c5280dc0aff398cdce19fa54d0e0725c418d.zip
Merge branch 'develop'0.26.0
Diffstat (limited to 'quantum/process_keycode')
-rw-r--r--quantum/process_keycode/process_dynamic_macro.c52
-rw-r--r--quantum/process_keycode/process_dynamic_macro.h14
-rw-r--r--quantum/process_keycode/process_key_override.c10
-rw-r--r--quantum/process_keycode/process_key_override.h5
-rw-r--r--quantum/process_keycode/process_rgb_matrix.c101
-rw-r--r--quantum/process_keycode/process_rgb_matrix.h10
-rw-r--r--quantum/process_keycode/process_tap_dance.c12
-rw-r--r--quantum/process_keycode/process_tap_dance.h4
-rw-r--r--quantum/process_keycode/process_underglow.c91
-rw-r--r--quantum/process_keycode/process_underglow.h10
10 files changed, 271 insertions, 38 deletions
diff --git a/quantum/process_keycode/process_dynamic_macro.c b/quantum/process_keycode/process_dynamic_macro.c
index 214cd80a87..f8e8256ac8 100644
--- a/quantum/process_keycode/process_dynamic_macro.c
+++ b/quantum/process_keycode/process_dynamic_macro.c
@@ -38,20 +38,44 @@ void dynamic_macro_led_blink(void) {
/* User hooks for Dynamic Macros */
-__attribute__((weak)) void dynamic_macro_record_start_user(int8_t direction) {
+__attribute__((weak)) bool dynamic_macro_record_start_kb(int8_t direction) {
+ return dynamic_macro_record_start_user(direction);
+}
+
+__attribute__((weak)) bool dynamic_macro_record_start_user(int8_t direction) {
dynamic_macro_led_blink();
+ return true;
+}
+
+__attribute__((weak)) bool dynamic_macro_play_kb(int8_t direction) {
+ return dynamic_macro_play_user(direction);
}
-__attribute__((weak)) void dynamic_macro_play_user(int8_t direction) {
+__attribute__((weak)) bool dynamic_macro_play_user(int8_t direction) {
dynamic_macro_led_blink();
+ return true;
+}
+
+__attribute__((weak)) bool dynamic_macro_record_key_kb(int8_t direction, keyrecord_t *record) {
+ return dynamic_macro_record_key_user(direction, record);
}
-__attribute__((weak)) void dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record) {
+__attribute__((weak)) bool dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record) {
dynamic_macro_led_blink();
+ return true;
+}
+
+__attribute__((weak)) bool dynamic_macro_record_end_kb(int8_t direction) {
+ return dynamic_macro_record_end_user(direction);
}
-__attribute__((weak)) void dynamic_macro_record_end_user(int8_t direction) {
+__attribute__((weak)) bool dynamic_macro_record_end_user(int8_t direction) {
dynamic_macro_led_blink();
+ return true;
+}
+
+__attribute__((weak)) bool dynamic_macro_valid_key_kb(uint16_t keycode, keyrecord_t *record) {
+ return dynamic_macro_valid_key_user(keycode, record);
}
__attribute__((weak)) bool dynamic_macro_valid_key_user(uint16_t keycode, keyrecord_t *record) {
@@ -74,7 +98,7 @@ __attribute__((weak)) bool dynamic_macro_valid_key_user(uint16_t keycode, keyrec
void dynamic_macro_record_start(keyrecord_t **macro_pointer, keyrecord_t *macro_buffer, int8_t direction) {
dprintln("dynamic macro recording: started");
- dynamic_macro_record_start_user(direction);
+ dynamic_macro_record_start_kb(direction);
clear_keyboard();
layer_clear();
@@ -108,7 +132,7 @@ void dynamic_macro_play(keyrecord_t *macro_buffer, keyrecord_t *macro_end, int8_
layer_state_set(saved_layer_state);
- dynamic_macro_play_user(direction);
+ dynamic_macro_play_kb(direction);
}
/**
@@ -134,7 +158,7 @@ void dynamic_macro_record_key(keyrecord_t *macro_buffer, keyrecord_t **macro_poi
**macro_pointer = *record;
*macro_pointer += direction;
}
- dynamic_macro_record_key_user(direction, record);
+ dynamic_macro_record_key_kb(direction, record);
dprintf("dynamic macro: slot %d length: %d/%d\n", DYNAMIC_MACRO_CURRENT_SLOT(), DYNAMIC_MACRO_CURRENT_LENGTH(macro_buffer, *macro_pointer), DYNAMIC_MACRO_CURRENT_CAPACITY(macro_buffer, macro2_end));
}
@@ -144,7 +168,7 @@ void dynamic_macro_record_key(keyrecord_t *macro_buffer, keyrecord_t **macro_poi
* pointer to the end of the macro.
*/
void dynamic_macro_record_end(keyrecord_t *macro_buffer, keyrecord_t *macro_pointer, int8_t direction, keyrecord_t **macro_end) {
- dynamic_macro_record_end_user(direction);
+ dynamic_macro_record_end_kb(direction);
/* Do not save the keys being held when stopping the recording,
* i.e. the keys used to access the layer DM_RSTP is on.
@@ -220,15 +244,7 @@ void dynamic_macro_stop_recording(void) {
macro_id = 0;
}
-/* Handle the key events related to the dynamic macros. Should be
- * called from process_record_user() like this:
- *
- * bool process_record_user(uint16_t keycode, keyrecord_t *record) {
- * if (!process_record_dynamic_macro(keycode, record)) {
- * return false;
- * }
- * <...THE REST OF THE FUNCTION...>
- * }
+/* Handle the key events related to the dynamic macros.
*/
bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) {
if (macro_id == 0) {
@@ -271,7 +287,7 @@ bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) {
return false;
#endif
default:
- if (dynamic_macro_valid_key_user(keycode, record)) {
+ if (dynamic_macro_valid_key_kb(keycode, record)) {
/* Store the key in the macro buffer and process it normally. */
switch (macro_id) {
case 1:
diff --git a/quantum/process_keycode/process_dynamic_macro.h b/quantum/process_keycode/process_dynamic_macro.h
index 2f10733cae..984fc0cd41 100644
--- a/quantum/process_keycode/process_dynamic_macro.h
+++ b/quantum/process_keycode/process_dynamic_macro.h
@@ -37,8 +37,14 @@
void dynamic_macro_led_blink(void);
bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record);
-void dynamic_macro_record_start_user(int8_t direction);
-void dynamic_macro_play_user(int8_t direction);
-void dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record);
-void dynamic_macro_record_end_user(int8_t direction);
+bool dynamic_macro_record_start_kb(int8_t direction);
+bool dynamic_macro_record_start_user(int8_t direction);
+bool dynamic_macro_play_kb(int8_t direction);
+bool dynamic_macro_play_user(int8_t direction);
+bool dynamic_macro_record_key_kb(int8_t direction, keyrecord_t *record);
+bool dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record);
+bool dynamic_macro_record_end_kb(int8_t direction);
+bool dynamic_macro_record_end_user(int8_t direction);
+bool dynamic_macro_valid_key_kb(uint16_t keycode, keyrecord_t *record);
+bool dynamic_macro_valid_key_user(uint16_t keycode, keyrecord_t *record);
void dynamic_macro_stop_recording(void);
diff --git a/quantum/process_keycode/process_key_override.c b/quantum/process_keycode/process_key_override.c
index 264e2562b8..ce30477ee8 100644
--- a/quantum/process_keycode/process_key_override.c
+++ b/quantum/process_keycode/process_key_override.c
@@ -23,6 +23,7 @@
#include "action_util.h"
#include "quantum.h"
#include "quantum_keycodes.h"
+#include "keymap_introspection.h"
#ifndef KEY_OVERRIDE_REPEAT_DELAY
# define KEY_OVERRIDE_REPEAT_DELAY 500
@@ -83,9 +84,6 @@ static uint16_t deferred_register = 0;
// TODO: in future maybe save in EEPROM?
static bool enabled = true;
-// Public variables
-__attribute__((weak)) const key_override_t **key_overrides = NULL;
-
// Forward decls
static const key_override_t *clear_active_override(const bool allow_reregister);
@@ -247,12 +245,12 @@ static bool check_activation_event(const key_override_t *override, const bool ke
/** Iterates through the list of key overrides and tries activating each, until it finds one that activates or reaches the end of overrides. Returns true if the key action for `keycode` should be sent */
static bool try_activating_override(const uint16_t keycode, const uint8_t layer, const bool key_down, const bool is_mod, const uint8_t active_mods, bool *activated) {
- if (key_overrides == NULL) {
+ if (key_override_count() == 0) {
return true;
}
- for (uint8_t i = 0;; i++) {
- const key_override_t *const override = key_overrides[i];
+ for (uint8_t i = 0; i < key_override_count(); i++) {
+ const key_override_t *const override = key_override_get(i);
// End of array
if (override == NULL) {
diff --git a/quantum/process_keycode/process_key_override.h b/quantum/process_keycode/process_key_override.h
index 3e37c7e63a..9ec84dbe6e 100644
--- a/quantum/process_keycode/process_key_override.h
+++ b/quantum/process_keycode/process_key_override.h
@@ -55,7 +55,7 @@ typedef enum {
} ko_option_t;
/** Defines a single key override */
-typedef struct {
+typedef struct key_override_t {
// The non-modifier keycode that triggers the override. This keycode, and the necessary modifiers (trigger_mods) must be pressed to activate this override. Set this to the keycode of the key that should activate the override. Set to KC_NO to require only the necessary modifiers to be pressed and no non-modifier.
uint16_t trigger;
@@ -87,9 +87,6 @@ typedef struct {
bool *enabled;
} key_override_t;
-/** Define this as a null-terminated array of pointers to key overrides. These key overrides will be used by qmk. */
-extern const key_override_t **key_overrides;
-
/** Turns key overrides on */
void key_override_on(void);
diff --git a/quantum/process_keycode/process_rgb_matrix.c b/quantum/process_keycode/process_rgb_matrix.c
new file mode 100644
index 0000000000..fd2aa1a0c7
--- /dev/null
+++ b/quantum/process_keycode/process_rgb_matrix.c
@@ -0,0 +1,101 @@
+// Copyright 2024 QMK
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "process_rgb_matrix.h"
+#include "rgb_matrix.h"
+#include "action_util.h"
+#include "keycodes.h"
+#include "modifiers.h"
+
+bool process_rgb_matrix(uint16_t keycode, keyrecord_t *record) {
+#ifdef RGB_TRIGGER_ON_KEYDOWN
+ if (record->event.pressed) {
+#else
+ if (!record->event.pressed) {
+#endif
+ bool shifted = get_mods() & MOD_MASK_SHIFT;
+ switch (keycode) {
+ case QK_RGB_MATRIX_ON:
+ rgb_matrix_enable();
+ return false;
+ case QK_RGB_MATRIX_OFF:
+ rgb_matrix_disable();
+ return false;
+ case QK_RGB_MATRIX_TOGGLE:
+ rgb_matrix_toggle();
+ return false;
+ case QK_RGB_MATRIX_MODE_NEXT:
+ if (shifted) {
+ rgb_matrix_step_reverse();
+ } else {
+ rgb_matrix_step();
+ }
+ return false;
+ case QK_RGB_MATRIX_MODE_PREVIOUS:
+ if (shifted) {
+ rgb_matrix_step();
+ } else {
+ rgb_matrix_step_reverse();
+ }
+ return false;
+ case QK_RGB_MATRIX_HUE_UP:
+ if (shifted) {
+ rgb_matrix_decrease_hue();
+ } else {
+ rgb_matrix_increase_hue();
+ }
+ return false;
+ case QK_RGB_MATRIX_HUE_DOWN:
+ if (shifted) {
+ rgb_matrix_increase_hue();
+ } else {
+ rgb_matrix_decrease_hue();
+ }
+ return false;
+ case QK_RGB_MATRIX_SATURATION_UP:
+ if (shifted) {
+ rgb_matrix_decrease_sat();
+ } else {
+ rgb_matrix_increase_sat();
+ }
+ return false;
+ case QK_RGB_MATRIX_SATURATION_DOWN:
+ if (shifted) {
+ rgb_matrix_increase_sat();
+ } else {
+ rgb_matrix_decrease_sat();
+ }
+ return false;
+ case QK_RGB_MATRIX_VALUE_UP:
+ if (shifted) {
+ rgb_matrix_decrease_val();
+ } else {
+ rgb_matrix_increase_val();
+ }
+ return false;
+ case QK_RGB_MATRIX_VALUE_DOWN:
+ if (shifted) {
+ rgb_matrix_increase_val();
+ } else {
+ rgb_matrix_decrease_val();
+ }
+ return false;
+ case QK_RGB_MATRIX_SPEED_UP:
+ if (shifted) {
+ rgb_matrix_decrease_speed();
+ } else {
+ rgb_matrix_increase_speed();
+ }
+ return false;
+ case QK_RGB_MATRIX_SPEED_DOWN:
+ if (shifted) {
+ rgb_matrix_increase_speed();
+ } else {
+ rgb_matrix_decrease_speed();
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
diff --git a/quantum/process_keycode/process_rgb_matrix.h b/quantum/process_keycode/process_rgb_matrix.h
new file mode 100644
index 0000000000..a02bf57b5f
--- /dev/null
+++ b/quantum/process_keycode/process_rgb_matrix.h
@@ -0,0 +1,10 @@
+// Copyright 2024 QMK
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "action.h"
+
+bool process_rgb_matrix(uint16_t keycode, keyrecord_t *record);
diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
index ce3b8fc81f..11df62763d 100644
--- a/quantum/process_keycode/process_tap_dance.c
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -21,6 +21,7 @@
#include "action_util.h"
#include "timer.h"
#include "wait.h"
+#include "keymap_introspection.h"
static uint16_t active_td;
static uint16_t last_tap_time;
@@ -133,7 +134,7 @@ bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
if (!active_td || keycode == active_td) return false;
- action = &tap_dance_actions[QK_TAP_DANCE_GET_INDEX(active_td)];
+ action = tap_dance_get(QK_TAP_DANCE_GET_INDEX(active_td));
action->state.interrupted = true;
action->state.interrupting_keycode = keycode;
process_tap_dance_action_on_dance_finished(action);
@@ -150,11 +151,16 @@ bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
}
bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
+ int td_index;
tap_dance_action_t *action;
switch (keycode) {
case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
- action = &tap_dance_actions[QK_TAP_DANCE_GET_INDEX(keycode)];
+ td_index = QK_TAP_DANCE_GET_INDEX(keycode);
+ if (td_index >= tap_dance_count()) {
+ return false;
+ }
+ action = tap_dance_get(td_index);
action->state.pressed = record->event.pressed;
if (record->event.pressed) {
@@ -182,7 +188,7 @@ void tap_dance_task(void) {
if (!active_td || timer_elapsed(last_tap_time) <= GET_TAPPING_TERM(active_td, &(keyrecord_t){})) return;
- action = &tap_dance_actions[QK_TAP_DANCE_GET_INDEX(active_td)];
+ action = tap_dance_get(QK_TAP_DANCE_GET_INDEX(active_td));
if (!action->state.interrupted) {
process_tap_dance_action_on_dance_finished(action);
}
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
index c0137c14a3..5cccbdf439 100644
--- a/quantum/process_keycode/process_tap_dance.h
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -35,7 +35,7 @@ typedef struct {
typedef void (*tap_dance_user_fn_t)(tap_dance_state_t *state, void *user_data);
-typedef struct {
+typedef struct tap_dance_action_t {
tap_dance_state_t state;
struct {
tap_dance_user_fn_t on_each_tap;
@@ -78,8 +78,6 @@ typedef struct {
#define TD_INDEX(code) QK_TAP_DANCE_GET_INDEX(code)
#define TAP_DANCE_KEYCODE(state) TD(((tap_dance_action_t *)state) - tap_dance_actions)
-extern tap_dance_action_t tap_dance_actions[];
-
void reset_tap_dance(tap_dance_state_t *state);
/* To be used internally */
diff --git a/quantum/process_keycode/process_underglow.c b/quantum/process_keycode/process_underglow.c
new file mode 100644
index 0000000000..779672ac07
--- /dev/null
+++ b/quantum/process_keycode/process_underglow.c
@@ -0,0 +1,91 @@
+// Copyright 2024 QMK
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "process_underglow.h"
+#include "rgblight.h"
+#include "action_util.h"
+#include "keycodes.h"
+#include "modifiers.h"
+
+bool process_underglow(uint16_t keycode, keyrecord_t *record) {
+ if (record->event.pressed) {
+ uint8_t shifted = get_mods() & MOD_MASK_SHIFT;
+ switch (keycode) {
+ case QK_UNDERGLOW_TOGGLE:
+ rgblight_toggle();
+ return false;
+ case QK_UNDERGLOW_MODE_NEXT:
+ if (shifted) {
+ rgblight_step_reverse();
+ } else {
+ rgblight_step();
+ }
+ return false;
+ case QK_UNDERGLOW_MODE_PREVIOUS:
+ if (shifted) {
+ rgblight_step();
+ } else {
+ rgblight_step_reverse();
+ }
+ return false;
+ case QK_UNDERGLOW_HUE_UP:
+ if (shifted) {
+ rgblight_decrease_hue();
+ } else {
+ rgblight_increase_hue();
+ }
+ return false;
+ case QK_UNDERGLOW_HUE_DOWN:
+ if (shifted) {
+ rgblight_increase_hue();
+ } else {
+ rgblight_decrease_hue();
+ }
+ return false;
+ case QK_UNDERGLOW_SATURATION_UP:
+ if (shifted) {
+ rgblight_decrease_sat();
+ } else {
+ rgblight_increase_sat();
+ }
+ return false;
+ case QK_UNDERGLOW_SATURATION_DOWN:
+ if (shifted) {
+ rgblight_increase_sat();
+ } else {
+ rgblight_decrease_sat();
+ }
+ return false;
+ case QK_UNDERGLOW_VALUE_UP:
+ if (shifted) {
+ rgblight_decrease_val();
+ } else {
+ rgblight_increase_val();
+ }
+ return false;
+ case QK_UNDERGLOW_VALUE_DOWN:
+ if (shifted) {
+ rgblight_increase_hue();
+ } else {
+ rgblight_decrease_hue();
+ }
+ return false;
+ case QK_UNDERGLOW_SPEED_UP:
+ if (shifted) {
+ rgblight_decrease_speed();
+ } else {
+ rgblight_increase_speed();
+ }
+ return false;
+ case QK_UNDERGLOW_SPEED_DOWN:
+ if (shifted) {
+ rgblight_increase_speed();
+ } else {
+ rgblight_decrease_speed();
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
diff --git a/quantum/process_keycode/process_underglow.h b/quantum/process_keycode/process_underglow.h
new file mode 100644
index 0000000000..b409cafbb8
--- /dev/null
+++ b/quantum/process_keycode/process_underglow.h
@@ -0,0 +1,10 @@
+// Copyright 2024 QMK
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "action.h"
+
+bool process_underglow(uint16_t keycode, keyrecord_t *record);