From ffa4c72a893b416da32efef80f4779b8bd48b4bb Mon Sep 17 00:00:00 2001 From: Priyadi Iman Nurcahyo Date: Wed, 19 Apr 2017 01:40:16 +0700 Subject: Faux clicky bug fixes --- quantum/fauxclicky.c | 15 ++++----------- quantum/fauxclicky.h | 10 +++++----- 2 files changed, 9 insertions(+), 16 deletions(-) (limited to 'quantum') diff --git a/quantum/fauxclicky.c b/quantum/fauxclicky.c index 13273e705..c3341ca33 100644 --- a/quantum/fauxclicky.c +++ b/quantum/fauxclicky.c @@ -20,13 +20,6 @@ along with this program. If not, see . #include #include -__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; @@ -48,13 +41,13 @@ void fauxclicky_stop() note_playing = false; } -void fauxclicky_play(float note[2]) { +void fauxclicky_play(float note[]) { 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); + FAUXCLICKY_TIMER_PERIOD = (uint16_t)(((float)F_CPU) / (note[0] * (float)FAUXCLICKY_CPU_PRESCALER)); + FAUXCLICKY_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (note[0] * (float)FAUXCLICKY_CPU_PRESCALER)) / (float)2); note_playing = true; - note_period = (note[1] / 16) * (60 / (float)FAUXCLICKY_TEMPO) * 100; // check this + note_period = (note[1] / (float)16) * ((float)60 / (float)FAUXCLICKY_TEMPO) * 1000; note_start = timer_read(); FAUXCLICKY_ENABLE_OUTPUT; } diff --git a/quantum/fauxclicky.h b/quantum/fauxclicky.h index 109bd0d83..1a8e188dd 100644 --- a/quantum/fauxclicky.h +++ b/quantum/fauxclicky.h @@ -21,11 +21,11 @@ along with this program. If not, see . #include "stdbool.h" __attribute__ ((weak)) -float fauxclicky_pressed_note[2]; +float fauxclicky_pressed_note[2] = MUSICAL_NOTE(_D4, 0.25); __attribute__ ((weak)) -float fauxclicky_released_note[2]; +float fauxclicky_released_note[2] = MUSICAL_NOTE(_C4, 0.125); __attribute__ ((weak)) -float fauxclicky_beep_note[2]; +float fauxclicky_beep_note[2] = MUSICAL_NOTE(_C4, 0.25); bool fauxclicky_enabled; @@ -73,11 +73,11 @@ bool fauxclicky_enabled; #endif #ifndef FAUXCLICKY_ENABLE_OUTPUT -#define FAUXCLICKY_ENABLE_OUTPUT TCCR3A |= _BV(COM3A1); +#define FAUXCLICKY_ENABLE_OUTPUT TCCR3A |= _BV(COM3A1) #endif #ifndef FAUXCLICKY_DISABLE_OUTPUT -#define FAUXCLICKY_DISABLE_OUTPUT TCCR3A &= ~(_BV(COM3A1) | _BV(COM3A0)); +#define FAUXCLICKY_DISABLE_OUTPUT TCCR3A &= ~(_BV(COM3A1) | _BV(COM3A0)) #endif #ifndef FAUXCLICKY_TIMER_PERIOD -- cgit v1.2.3 From 4ff40a551a310e9b29a5838f87a9db58c0e5767e Mon Sep 17 00:00:00 2001 From: Weiyi Lou Date: Sat, 29 Apr 2017 22:02:01 +1000 Subject: Add `DYN_REC_STOP` to dynamic macros Dynamic macro functionality is modified to check for `DYN_REC_STOP`, so that macro recording can be stopped with a designated key combination (e.g. `qs` or anything) instead of mandating the use of a `_DYN` layer. `_DYN` layer stopping can still be done by passing `DYN_REC_STOP` within `process_record_user()`: bool process_record_user(uint16_t keycode, keyrecord_t *record) { uint16_t macro_kc = (keycode == MO(_DYN) ? DYN_REC_STOP : keycode); if (!process_record_dynamic_macro(macro_kc, record)) { return false; } return true; } --- quantum/dynamic_macro.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index 64093f293..939816a59 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -40,6 +40,7 @@ enum dynamic_macro_keycodes { DYN_REC_START1 = DYNAMIC_MACRO_RANGE, DYN_REC_START2, + DYN_REC_STOP, DYN_MACRO_PLAY1, DYN_MACRO_PLAY2, }; @@ -209,9 +210,8 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) } else { /* A macro is being recorded right now. */ switch (keycode) { - case MO(_DYN): - /* Use the layer key used to access the macro recording as - * a stop button. */ + case DYN_REC_STOP: + /* Stop the macro recording. */ if (record->event.pressed) { /* Ignore the initial release * just after the recoding * starts. */ -- cgit v1.2.3 From 40fe30e4d6b521284fa3cb7ae217ebb6d013bcdf Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Wed, 3 May 2017 23:47:52 +0200 Subject: dynamic_macro.h: Ignore all the initial key releases Right after the user initiates the macro recording, they usually need to release some keys used to access the DYN_REC_START layers. It makes sense to ignore them. Note: The keys used to access the DYN_REC_STOP key are *not* ignored. --- quantum/dynamic_macro.h | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index 939816a59..1a8ec4032 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -97,17 +97,24 @@ void dynamic_macro_play( /** * Record a single key in a dynamic macro. * + * @param macro_buffer[in] The start of the used macro buffer. * @param macro_pointer[in,out] The current buffer position. * @param macro_end2[in] The end of the other macro which shouldn't be overwritten. * @param direction[in] Either +1 or -1, which way to iterate the buffer. * @param record[in] The current keypress. */ void dynamic_macro_record_key( + keyrecord_t *macro_buffer, keyrecord_t **macro_pointer, keyrecord_t *macro_end2, int8_t direction, keyrecord_t *record) { + /* If we've just started recording, ignore all the key releases. */ + if (!record->event.pressed && *macro_pointer == macro_buffer) { + return; + } + if (*macro_pointer + direction != macro_end2) { **macro_pointer = *record; *macro_pointer += direction; @@ -230,10 +237,10 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) /* Store the key in the macro buffer and process it normally. */ switch (macro_id) { case 1: - dynamic_macro_record_key(¯o_pointer, r_macro_end, +1, record); + dynamic_macro_record_key(macro_buffer, ¯o_pointer, r_macro_end, +1, record); break; case 2: - dynamic_macro_record_key(¯o_pointer, macro_end, -1, record); + dynamic_macro_record_key(r_macro_buffer, ¯o_pointer, macro_end, -1, record); break; } return true; -- cgit v1.2.3 From 5e2a9992783e584f66dfeef16abf9d31c976311a Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Thu, 4 May 2017 00:58:01 +0200 Subject: dynamic_macro.h: Always toggle the backlight twice as a notification Apparently sometimes the backlight was toggled only once and it was left on. --- quantum/dynamic_macro.h | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index 1a8ec4032..c9120897f 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -119,9 +119,7 @@ void dynamic_macro_record_key( **macro_pointer = *record; *macro_pointer += direction; } else { - /* Notify about the end of buffer. The blinks are paired - * because they should happen on both down and up events. */ - backlight_toggle(); + dynamic_macro_led_blink(); } } -- cgit v1.2.3 From 436d661775178fb62b46afdc3d755fdb413dcb35 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Thu, 4 May 2017 01:19:05 +0200 Subject: dynamic_macro.h: Fix an off-by-two error We need to check whether we just passed the after-the-end point of the other macro. Instead we were checking whether we are going to reach it now. --- quantum/dynamic_macro.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index c9120897f..9e7845c99 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -99,14 +99,14 @@ void dynamic_macro_play( * * @param macro_buffer[in] The start of the used macro buffer. * @param macro_pointer[in,out] The current buffer position. - * @param macro_end2[in] The end of the other macro which shouldn't be overwritten. + * @param macro2_end[in] The last buffer element it is safe to use before overwriting the other macro. * @param direction[in] Either +1 or -1, which way to iterate the buffer. * @param record[in] The current keypress. */ void dynamic_macro_record_key( keyrecord_t *macro_buffer, keyrecord_t **macro_pointer, - keyrecord_t *macro_end2, + keyrecord_t *macro2_end, int8_t direction, keyrecord_t *record) { @@ -115,7 +115,7 @@ void dynamic_macro_record_key( return; } - if (*macro_pointer + direction != macro_end2) { + if (*macro_pointer - direction != macro2_end) { **macro_pointer = *record; *macro_pointer += direction; } else { -- cgit v1.2.3 From 4b50ea15a954de2e6062aa7228bd1f9f76669ce7 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Thu, 4 May 2017 01:37:46 +0200 Subject: dynamic_macro.h: Do not save the keys being held when stopping the recording More specifically, we save them and then place the `macro_end` pointer before them so they are essentially ignored and the other macro may freely overwrite them. --- quantum/dynamic_macro.h | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index 9e7845c99..c4017aec9 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -127,10 +127,22 @@ void dynamic_macro_record_key( * End recording of the dynamic macro. Essentially just update the * pointer to the end of the macro. */ -void dynamic_macro_record_end(keyrecord_t *macro_pointer, keyrecord_t **macro_end) +void dynamic_macro_record_end( + keyrecord_t *macro_buffer, + keyrecord_t *macro_pointer, + int8_t direction, + keyrecord_t **macro_end) { dynamic_macro_led_blink(); + /* Do not save the keys being held when stopping the recording, + * i.e. the keys used to access the layer DYN_REC_STOP is on. + */ + while (macro_pointer != macro_buffer && + (macro_pointer - direction)->event.pressed) { + macro_pointer -= direction; + } + *macro_end = macro_pointer; } @@ -222,10 +234,10 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) * starts. */ switch (macro_id) { case 1: - dynamic_macro_record_end(macro_pointer, ¯o_end); + dynamic_macro_record_end(macro_buffer, macro_pointer, +1, ¯o_end); break; case 2: - dynamic_macro_record_end(macro_pointer, &r_macro_end); + dynamic_macro_record_end(r_macro_buffer, macro_pointer, -1, &r_macro_end); break; } macro_id = 0; -- cgit v1.2.3 From 8e94c9b4cba4cf3479154a11faacfa2bbad50098 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Thu, 4 May 2017 22:39:02 +0200 Subject: dynamic_macro.h: Make the documentation more clear --- quantum/dynamic_macro.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index c4017aec9..6aae7d230 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -99,7 +99,7 @@ void dynamic_macro_play( * * @param macro_buffer[in] The start of the used macro buffer. * @param macro_pointer[in,out] The current buffer position. - * @param macro2_end[in] The last buffer element it is safe to use before overwriting the other macro. + * @param macro2_end[in] The end of the other macro. * @param direction[in] Either +1 or -1, which way to iterate the buffer. * @param record[in] The current keypress. */ @@ -115,6 +115,9 @@ void dynamic_macro_record_key( return; } + /* The other end of the other macro is the last buffer element it + * is safe to use before overwriting the other macro. + */ if (*macro_pointer - direction != macro2_end) { **macro_pointer = *record; *macro_pointer += direction; @@ -170,7 +173,7 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) * ¯o_buffer macro_end * v v * +------------------------------------------------------------+ - * |>>>>>> MACRO1 >>>>>>| |<<<<<<<<<<<<< MACRO2 <<<<<<<<<<<<<| + * |>>>>>> MACRO1 >>>>>> <<<<<<<<<<<<< MACRO2 <<<<<<<<<<<<<| * +------------------------------------------------------------+ * ^ ^ * r_macro_end r_macro_buffer -- cgit v1.2.3 From 10a7cd7e5ae1affe226423dd94c6443f8cf64e22 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Thu, 4 May 2017 22:55:35 +0200 Subject: dynamic_macro.h: Add debug logs --- quantum/dynamic_macro.h | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index 6aae7d230..7dca30f07 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -53,6 +53,15 @@ void dynamic_macro_led_blink(void) backlight_toggle(); } +/* Convenience macros used for retrieving the debug info. All of them + * need a `direction` variable accessible at the call site. + */ +#define DYNAMIC_MACRO_CURRENT_SLOT() (direction > 0 ? 1 : 2) +#define DYNAMIC_MACRO_CURRENT_LENGTH(BEGIN, POINTER) \ + ((int)(direction * ((POINTER) - (BEGIN)))) +#define DYNAMIC_MACRO_CURRENT_CAPACITY(BEGIN, END2) \ + ((int)(direction * ((END2) - (BEGIN)) + 1)) + /** * Start recording of the dynamic macro. * @@ -62,6 +71,8 @@ void dynamic_macro_led_blink(void) void dynamic_macro_record_start( keyrecord_t **macro_pointer, keyrecord_t *macro_buffer) { + dprintln("dynamic macro recording: started"); + dynamic_macro_led_blink(); clear_keyboard(); @@ -79,6 +90,8 @@ void dynamic_macro_record_start( void dynamic_macro_play( keyrecord_t *macro_buffer, keyrecord_t *macro_end, int8_t direction) { + dprintf("dynamic macro: slot %d playback\n", DYNAMIC_MACRO_CURRENT_SLOT()); + uint32_t saved_layer_state = layer_state; clear_keyboard(); @@ -112,6 +125,7 @@ void dynamic_macro_record_key( { /* If we've just started recording, ignore all the key releases. */ if (!record->event.pressed && *macro_pointer == macro_buffer) { + dprintln("dynamic macro: ignoring a leading key-up event"); return; } @@ -124,6 +138,12 @@ void dynamic_macro_record_key( } else { dynamic_macro_led_blink(); } + + 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)); } /** @@ -143,9 +163,15 @@ void dynamic_macro_record_end( */ while (macro_pointer != macro_buffer && (macro_pointer - direction)->event.pressed) { + dprintln("dynamic macro: trimming a trailing key-down event"); macro_pointer -= direction; } + dprintf( + "dynamic macro: slot %d saved, length: %d\n", + DYNAMIC_MACRO_CURRENT_SLOT(), + DYNAMIC_MACRO_CURRENT_LENGTH(macro_buffer, macro_pointer)); + *macro_end = macro_pointer; } @@ -264,4 +290,8 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) return true; } +#undef DYNAMIC_MACRO_CURRENT_SLOT +#undef DYNAMIC_MACRO_CURRENT_LENGTH +#undef DYNAMIC_MACRO_CURRENT_CAPACITY + #endif -- cgit v1.2.3 From a1e156a3d20e10134ac01b4cc2eaf2c92c0d2f23 Mon Sep 17 00:00:00 2001 From: Wojciech Siewierski Date: Fri, 5 May 2017 00:11:24 +0200 Subject: dynamic_macro.h: Do not use backlight_toggle if backlight is disabled Fixes #1199. --- quantum/dynamic_macro.h | 2 ++ 1 file changed, 2 insertions(+) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index 7dca30f07..f242405de 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -48,9 +48,11 @@ enum dynamic_macro_keycodes { /* Blink the LEDs to notify the user about some event. */ void dynamic_macro_led_blink(void) { +#ifdef BACKLIGHT_ENABLE backlight_toggle(); _delay_ms(100); backlight_toggle(); +#endif } /* Convenience macros used for retrieving the debug info. All of them -- cgit v1.2.3 From eb660ef2184565c6bb69f1f67f7af8918d15688f Mon Sep 17 00:00:00 2001 From: Nick Choi Date: Mon, 15 May 2017 01:52:45 -0400 Subject: emoji support but --- quantum/process_keycode/process_unicodemap.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'quantum') diff --git a/quantum/process_keycode/process_unicodemap.c b/quantum/process_keycode/process_unicodemap.c index 0227fbdd7..75f35112b 100644 --- a/quantum/process_keycode/process_unicodemap.c +++ b/quantum/process_keycode/process_unicodemap.c @@ -49,7 +49,7 @@ 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 - QK_UNICODE_MAP; - uint32_t code = pgm_read_dword_far(&map[index]); + uint32_t code = pgm_read_dword(&map[index]); if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) { // Convert to UTF-16 surrogate pair code -= 0x10000; -- cgit v1.2.3 From e695b5a33b97cfb4f9dd8bc8ecaff8aa7e0f14cc Mon Sep 17 00:00:00 2001 From: Nick Choi Date: Thu, 25 May 2017 00:41:00 -0400 Subject: Added per case tapping term, updated FF-nikchi keymap. --- quantum/process_keycode/process_tap_dance.c | 10 ++++++++-- quantum/process_keycode/process_tap_dance.h | 4 ++-- 2 files changed, 10 insertions(+), 4 deletions(-) (limited to 'quantum') diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c index b807ec3c3..e58b6f2df 100644 --- a/quantum/process_keycode/process_tap_dance.c +++ b/quantum/process_keycode/process_tap_dance.c @@ -130,11 +130,17 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { void matrix_scan_tap_dance () { if (highest_td == -1) return; + int tap_user_defined; 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) { + if(action->user_data != NULL ) { + tap_user_defined = (int)action->user_data; + } + else{ + tap_user_defined = TAPPING_TERM; + } + if (action->state.count && timer_elapsed (action->state.timer) > tap_user_defined) { process_tap_dance_action_on_dance_finished (action); reset_tap_dance (&action->state); } diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index 330809f83..95d51f480 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -63,9 +63,9 @@ typedef struct .user_data = NULL, \ } -#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \ +#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) { \ .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \ - .user_data = NULL, \ + .user_data = (void *)(tap_specific_tapping_term), \ } extern qk_tap_dance_action_t tap_dance_actions[]; -- cgit v1.2.3 From aeb3a34636c614cd392cfc6268491a51a461df31 Mon Sep 17 00:00:00 2001 From: Nick Choi Date: Thu, 25 May 2017 16:26:30 -0400 Subject: moved specific tap term to its own function included custom_tapping_term in action struct --- quantum/process_keycode/process_tap_dance.c | 6 ++++-- quantum/process_keycode/process_tap_dance.h | 12 ++++++++++-- 2 files changed, 14 insertions(+), 4 deletions(-) (limited to 'quantum') diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c index e58b6f2df..2c7f6e937 100644 --- a/quantum/process_keycode/process_tap_dance.c +++ b/quantum/process_keycode/process_tap_dance.c @@ -127,6 +127,8 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { return true; } + + void matrix_scan_tap_dance () { if (highest_td == -1) return; @@ -134,8 +136,8 @@ void matrix_scan_tap_dance () { for (int i = 0; i <= highest_td; i++) { qk_tap_dance_action_t *action = &tap_dance_actions[i]; - if(action->user_data != NULL ) { - tap_user_defined = (int)action->user_data; + if(action->custom_tapping_term > 0 ) { + tap_user_defined = action->custom_tapping_term; } else{ tap_user_defined = TAPPING_TERM; diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index 95d51f480..a020f7991 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -44,6 +44,7 @@ typedef struct qk_tap_dance_user_fn_t on_reset; } fn; qk_tap_dance_state_t state; + uint16_t custom_tapping_term; void *user_data; } qk_tap_dance_action_t; @@ -63,9 +64,16 @@ typedef struct .user_data = NULL, \ } -#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) { \ +#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \ .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \ - .user_data = (void *)(tap_specific_tapping_term), \ + .user_data = NULL, \ + .custom_tapping_term = -1, \ + } + +#define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) { \ + .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \ + .user_data = NULL, \ + .custom_tapping_term = tap_specific_tapping_term, \ } extern qk_tap_dance_action_t tap_dance_actions[]; -- cgit v1.2.3 From 7c8b166cce8bf5df058913acc07cd6505f83684a Mon Sep 17 00:00:00 2001 From: Nick Choi Date: Thu, 25 May 2017 16:29:57 -0400 Subject: =?UTF-8?q?changed=20-1=20to=200=20can't=20have=20negative=20unsig?= =?UTF-8?q?ned=20ints=20=F0=9F=A4=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- quantum/process_keycode/process_tap_dance.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'quantum') diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index a020f7991..ef05ebda2 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -67,7 +67,7 @@ typedef struct #define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \ .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \ .user_data = NULL, \ - .custom_tapping_term = -1, \ + .custom_tapping_term = 0, \ } #define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) { \ -- cgit v1.2.3 From b3144112d3b0abb9bf1060185a001e2fb8d8196c Mon Sep 17 00:00:00 2001 From: Nick Choi Date: Thu, 25 May 2017 16:38:06 -0400 Subject: removed need to set customtapping term 0. defaults to 0 already --- quantum/process_keycode/process_tap_dance.h | 1 - 1 file changed, 1 deletion(-) (limited to 'quantum') diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index ef05ebda2..f42c154a0 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -67,7 +67,6 @@ typedef struct #define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \ .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \ .user_data = NULL, \ - .custom_tapping_term = 0, \ } #define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) { \ -- cgit v1.2.3 From 5393bc6f4eee3d3cb83997e5b03d8e5a5cea85d8 Mon Sep 17 00:00:00 2001 From: Nick Choi Date: Mon, 29 May 2017 21:25:50 -0400 Subject: switched to uint8 and 16 --- quantum/process_keycode/process_tap_dance.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'quantum') diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c index 2c7f6e937..4fd45810b 100644 --- a/quantum/process_keycode/process_tap_dance.c +++ b/quantum/process_keycode/process_tap_dance.c @@ -132,9 +132,9 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { void matrix_scan_tap_dance () { if (highest_td == -1) return; - int tap_user_defined; + uint16_t tap_user_defined; -for (int i = 0; i <= highest_td; i++) { +for (uint8_t i = 0; i <= highest_td; i++) { qk_tap_dance_action_t *action = &tap_dance_actions[i]; if(action->custom_tapping_term > 0 ) { tap_user_defined = action->custom_tapping_term; -- cgit v1.2.3 From 606e13a47ea3f4099e09c0a71294555163790c4a Mon Sep 17 00:00:00 2001 From: Daniel Shields Date: Thu, 11 May 2017 09:46:11 +0100 Subject: Prevent the recording of looping dynamic macros. If a macro play key is inadvertently recorded in a dynamic macro a loop is created and the macro will not terminate when played. This should be prevented. --- quantum/dynamic_macro.h | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'quantum') diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index f242405de..045ee95b5 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -274,6 +274,10 @@ bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) macro_id = 0; } return false; + case DYN_MACRO_PLAY1: + case DYN_MACRO_PLAY2: + dprintln("dynamic macro: ignoring macro play key while recording"); + return false; default: /* Store the key in the macro buffer and process it normally. */ switch (macro_id) { -- cgit v1.2.3