@ -14,141 +14,164 @@
* along with this program . If not , see < http : //www.gnu.org/licenses/>.
* along with this program . If not , see < http : //www.gnu.org/licenses/>.
*/
*/
# include "process_combo.h"
# include "print.h" # include "print.h"
# include "process_combo.h"
__attribute__ ( ( weak ) ) combo_t key_combos [ COMBO_COUNT ] = {
__attribute__ ( ( weak ) )
combo_t key_combos [ COMBO_COUNT ] = {
} ; } ;
__attribute__ ( ( weak ) ) __attribute__ ( ( weak ) ) void process_combo_event ( uint8_t combo_index ,
void process_combo_event ( uint8_t combo_index , bool pressed ) { bool pressed ) { }
}
static uint16_t timer = 0 ;
static uint8_t current_combo_index = 0 ; static uint8_t current_combo_index = 0 ;
static bool drop_buffer = false ;
static bool is_active = false ;
static inline void send_combo ( uint16_t action , bool pressed ) static uint8_t buffer_size = 0 ;
{
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 - > is_active ;
if ( record - > event . pressed ) {
KEY_STATE_DOWN ( index ) ;
if ( is_combo_active ) {
if ( ALL_COMBO_KEYS_ARE_DOWN ) { /* Combo was pressed */
send_combo ( combo - > keycode , true ) ;
combo - > is_active = false ;
} else { /* Combo key was pressed */
combo - > timer = timer_read ( ) ;
combo - > is_active = true ;
# ifdef COMBO_ALLOW_ACTION_KEYS # ifdef COMBO_ALLOW_ACTION_KEYS
combo - > prev_record = * record ; static keyrecord_t key_buffer [ MAX_COMBO_LENGTH ] ;
# else # else
combo - > prev_key = keycode ; static uint16_t key_buffer [ MAX_COMBO_LENGTH ] ;
# endif # endif
}
}
static inline void send_combo ( uint16_t action , bool pressed ) {
if ( action ) {
if ( pressed ) {
register_code16 ( action ) ;
} else {
} else {
if ( ALL_COMBO_KEYS_ARE_DOWN ) { /* Combo was released */
unregister_code16 ( action ) ;
send_combo ( combo - > keycode , false ) ;
}
}
} else {
process_combo_event ( current_combo_index , pressed ) ;
}
}
if ( is_combo_active ) { /* Combo key was tapped */
static inline void dump_key_buffer ( bool emit ) {
if ( buffer_size = = 0 ) {
return ;
}
if ( emit ) {
for ( uint8_t i = 0 ; i < buffer_size ; i + + ) {
# ifdef COMBO_ALLOW_ACTION_KEYS # ifdef COMBO_ALLOW_ACTION_KEYS
record - > event . pressed = true ;
const action_t action = store_or_get_action ( key_buffer [ i ] . event . pressed ,
process_action ( record , store_or_get_action ( record - > event . pressed , record - > event . key ) ) ;
key_buffer [ i ] . event . key ) ;
record - > event . pressed = false ;
process_action ( & ( key_buffer [ i ] ) , action ) ;
process_action ( record , store_or_get_action ( record - > event . pressed , record - > event . key ) ) ;
# else # else
register_code16 ( keycode ) ;
register_code16 ( key_buffer [ i ] ) ;
send_keyboard_report ( ) ;
send_keyboard_report ( ) ;
unregister_code16 ( keycode ) ;
# endif # endif
combo - > is_active = false ;
combo - > timer = 0 ;
}
KEY_STATE_UP ( index ) ;
}
}
}
if ( NO_COMBO_KEYS_ARE_DOWN ) {
buffer_size = 0 ;
combo - > is_active = true ;
combo - > timer = 0 ;
}
return is_combo_active ;
} }
bool process_combo ( uint16_t keycode , keyrecord_t * record ) # define ALL_COMBO_KEYS_ARE_DOWN (((1 << count) - 1) == combo->state)
{ # define KEY_STATE_DOWN(key) \
bool is_combo_key = false ;
do { \
combo - > state | = ( 1 < < key ) ; \
} while ( 0 )
# define KEY_STATE_UP(key) \
do { \
combo - > state & = ~ ( 1 < < key ) ; \
} while ( 0 )
static bool process_single_combo ( combo_t * combo , uint16_t keycode ,
keyrecord_t * record ) {
uint8_t count = 0 ;
uint8_t index = - 1 ;
/* Find index of keycode and number of combo keys */
for ( const uint16_t * keys = combo - > keys ; ; + + count ) {
uint16_t key = pgm_read_word ( & keys [ count ] ) ;
if ( keycode = = key )
index = count ;
if ( COMBO_END = = key )
break ;
}
/* Continue processing if not a combo key */
if ( - 1 = = ( int8_t ) index )
return false ;
bool is_combo_active = is_active ;
if ( record - > event . pressed ) {
KEY_STATE_DOWN ( index ) ;
if ( is_combo_active ) {
if ( ALL_COMBO_KEYS_ARE_DOWN ) { /* Combo was pressed */
send_combo ( combo - > keycode , true ) ;
drop_buffer = true ;
}
}
} else {
if ( ALL_COMBO_KEYS_ARE_DOWN ) { /* Combo was released */
send_combo ( combo - > keycode , false ) ;
} else {
/* continue processing without immediately returning */
is_combo_active = false ;
}
for ( current_combo_index = 0 ; current_combo_index < COMBO_COUNT ; + + current_combo_index ) {
KEY_STATE_UP ( index ) ;
combo_t * combo = & key_combos [ current_combo_index ] ;
}
is_combo_key | = process_single_combo ( combo , keycode , record ) ;
}
return ! is_combo_key ;
return is_combo_active ;
} }
void matrix_scan_combo ( void ) # define NO_COMBO_KEYS_ARE_DOWN (0 == combo->state)
{
for ( int i = 0 ; i < COMBO_COUNT ; + + i ) {
bool process_combo ( uint16_t keycode , keyrecord_t * record ) {
// Do not treat the (weak) key_combos too strict.
bool is_combo_key = false ;
# pragma GCC diagnostic push
drop_buffer = false ;
# pragma GCC diagnostic ignored "-Warray-bounds"
bool no_combo_keys_pressed = false ;
combo_t * combo = & key_combos [ i ] ;
# pragma GCC diagnostic pop
for ( current_combo_index = 0 ; current_combo_index < COMBO_COUNT ;
if ( combo - > is_active & &
+ + current_combo_index ) {
combo - > timer & &
combo_t * combo = & key_combos [ current_combo_index ] ;
timer_elapsed ( combo - > timer ) > COMBO_TERM ) {
is_combo_key | = process_single_combo ( combo , keycode , record ) ;
no_combo_keys_pressed | = NO_COMBO_KEYS_ARE_DOWN ;
/* This disables the combo, meaning key events for this
}
* combo will be handled by the next processors in the chain
*/
if ( drop_buffer ) {
combo - > is_active = false ;
/* buffer is only dropped when we complete a combo, so we refresh the timer
* here */
timer = timer_read ( ) ;
dump_key_buffer ( false ) ;
} else if ( ! is_combo_key ) {
/* if no combos claim the key we need to emit the keybuffer */
dump_key_buffer ( true ) ;
// reset state if there are no combo keys pressed at all
if ( no_combo_keys_pressed ) {
timer = 0 ;
is_active = true ;
}
} else if ( record - > event . pressed & & is_active ) {
/* otherwise the key is consumed and placed in the buffer */
timer = timer_read ( ) ;
if ( buffer_size < MAX_COMBO_LENGTH ) {
# ifdef COMBO_ALLOW_ACTION_KEYS # ifdef COMBO_ALLOW_ACTION_KEYS
process_action ( & combo - > prev_record ,
key_buffer [ buffer_size + + ] = * record ;
store_or_get_action ( combo - > prev_record . event . pressed ,
combo - > prev_record . event . key ) ) ;
# else # else
unregister_code16 ( combo - > prev_key ) ;
key_buffer [ buffer_size + + ] = keycode ;
register_code16 ( combo - > prev_key ) ;
# endif # endif
}
}
}
}
return ! is_combo_key ;
}
void matrix_scan_combo ( void ) {
if ( is_active & & timer & & timer_elapsed ( timer ) > COMBO_TERM ) {
/* This disables the combo, meaning key events for this
* combo will be handled by the next processors in the chain
*/
is_active = false ;
dump_key_buffer ( true ) ;
}
} }
Bob
6 years ago
committed by