kb01/zmk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

uncrustify

Browse source
This commit is contained in:
Okke Formsma 2020-08-31 22:39:32 +02:00
parent 95361f37ea
commit c2540cb999
1 changed files with 359 additions and 342 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

135
app/src/behaviors/behavior_tap_hold.c
View file

@ -39,8 +39,8 @@ typedef k_timeout_t (*timer_func)();
struct behavior_tap_hold_config { struct behavior_tap_hold_config {
timer_func tapping_term_ms; timer_func tapping_term_ms;
struct behavior_tap_hold_behaviors* behaviors; struct behavior_tap_hold_behaviors *behaviors;
char* flavor; char *flavor;
}; };
// this data is specific for each tap-hold // this data is specific for each tap-hold
@ -58,13 +58,14 @@ struct active_tap_hold {
// not NULL, most events are captured in captured_events. // not NULL, most events are captured in captured_events.
// After the tap_hold is decided, it will stay in the active_tap_holds until // After the tap_hold is decided, it will stay in the active_tap_holds until
// its key-up has been processed and the delayed work is cleaned up. // its key-up has been processed and the delayed work is cleaned up.
struct active_tap_hold* undecided_tap_hold = NULL; struct active_tap_hold *undecided_tap_hold = NULL;
struct active_tap_hold active_tap_holds[ZMK_BHV_TAP_HOLD_MAX_HELD] = {}; struct active_tap_hold active_tap_holds[ZMK_BHV_TAP_HOLD_MAX_HELD] = {};
// We capture most position_state_changed events and some modifiers_state_changed events. // We capture most position_state_changed events and some modifiers_state_changed events.
const struct zmk_event_header* captured_events[ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS] = {}; const struct zmk_event_header *captured_events[ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS] = {};
/************************************************************ CAPTURED POSITION HELPER FUNCTIONS */ /************************************************************ CAPTURED POSITION HELPER FUNCTIONS */
static int capture_event(const struct zmk_event_header* event) { static int capture_event(const struct zmk_event_header *event)
{
for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS; i++) { for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS; i++) {
if (captured_events[i] == NULL) { if (captured_events[i] == NULL) {
captured_events[i] = event; captured_events[i] = event;
@ -74,7 +75,8 @@ static int capture_event(const struct zmk_event_header* event) {
return -ENOMEM; return -ENOMEM;
} }
static struct position_state_changed* find_captured_keydown_event(u32_t position){ static struct position_state_changed *find_captured_keydown_event(u32_t position)
{
struct position_state_changed *last_match = NULL; struct position_state_changed *last_match = NULL;
for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS; i++) { for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS; i++) {
const struct zmk_event_header *eh = captured_events[i]; const struct zmk_event_header *eh = captured_events[i];
@ -84,16 +86,16 @@ static struct position_state_changed* find_captured_keydown_event(u32_t position
if (!is_position_state_changed(eh)) { if (!is_position_state_changed(eh)) {
continue; continue;
} }
struct position_state_changed* position_event = cast_position_state_changed(eh); struct position_state_changed *position_event = cast_position_state_changed(eh);
if (position_event->position == position && position_event->state) { if (position_event->position == position && position_event->state) {
last_match = position_event; last_match = position_event;
} }
} }
return last_match; return last_match;
} }
static void release_captured_events() { static void release_captured_events()
{
if (undecided_tap_hold != NULL) { if (undecided_tap_hold != NULL) {
return; return;
} }
@ -123,16 +125,16 @@ static void release_captured_events() {
// mt2_up event is not captured but causes release of mt2 behavior // mt2_up event is not captured but causes release of mt2 behavior
// [k1_down, k1_up, null, null, null, ...] // [k1_down, k1_up, null, null, null, ...]
// now mt2 will start releasing it's own captured positions. // now mt2 will start releasing it's own captured positions.
for(int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS; i++) { for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_CAPTURED_EVENTS; i++) {
const struct zmk_event_header* captured_event = captured_events[i]; const struct zmk_event_header *captured_event = captured_events[i];
if(captured_event == NULL) { if (captured_event == NULL) {
return; return;
} }
captured_events[i] = NULL; captured_events[i] = NULL;
if(undecided_tap_hold != NULL) { if (undecided_tap_hold != NULL) {
k_msleep(10); k_msleep(10);
} }
if(is_position_state_changed(captured_event)) { if (is_position_state_changed(captured_event)) {
struct position_state_changed *position_event = cast_position_state_changed(captured_event); struct position_state_changed *position_event = cast_position_state_changed(captured_event);
LOG_DBG("Releasing key position event for position %d %s", position_event->position, (position_event->state ? "pressed" : "released")); LOG_DBG("Releasing key position event for position %d %s", position_event->position, (position_event->state ? "pressed" : "released"));
} else { } else {
@ -146,7 +148,8 @@ static void release_captured_events() {
/************************************************************ ACTIVE TAP HOLD HELPER FUNCTIONS */ /************************************************************ ACTIVE TAP HOLD HELPER FUNCTIONS */
static struct active_tap_hold* find_tap_hold(u32_t position) { static struct active_tap_hold *find_tap_hold(u32_t position)
{
for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_HELD; i++) { for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_HELD; i++) {
if (active_tap_holds[i].position == position) { if (active_tap_holds[i].position == position) {
return &active_tap_holds[i]; return &active_tap_holds[i];
@ -155,7 +158,8 @@ static struct active_tap_hold* find_tap_hold(u32_t position) {
return NULL; return NULL;
} }
static struct active_tap_hold* store_tap_hold(u32_t position, const struct behavior_tap_hold_config* config) { static struct active_tap_hold *store_tap_hold(u32_t position, const struct behavior_tap_hold_config *config)
{
for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_HELD; i++) { for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_HELD; i++) {
if (active_tap_holds[i].position != ZMK_BHV_TAP_HOLD_POSITION_NOT_USED) { if (active_tap_holds[i].position != ZMK_BHV_TAP_HOLD_POSITION_NOT_USED) {
continue; continue;
@ -169,22 +173,24 @@ static struct active_tap_hold* store_tap_hold(u32_t position, const struct behav
return NULL; return NULL;
} }
static void clear_tap_hold(struct active_tap_hold * tap_hold) { static void clear_tap_hold(struct active_tap_hold *tap_hold)
{
tap_hold->position = ZMK_BHV_TAP_HOLD_POSITION_NOT_USED; tap_hold->position = ZMK_BHV_TAP_HOLD_POSITION_NOT_USED;
tap_hold->is_decided = false; tap_hold->is_decided = false;
tap_hold->is_hold = false; tap_hold->is_hold = false;
tap_hold->work_is_cancelled= false; tap_hold->work_is_cancelled = false;
} }
enum decision_moment{ enum decision_moment {
TH_KEY_UP = 0, TH_KEY_UP = 0,
TH_OTHER_KEY_DOWN = 1, TH_OTHER_KEY_DOWN = 1,
TH_OTHER_KEY_UP = 2, TH_OTHER_KEY_UP = 2,
TH_TIMER_EVENT = 3, TH_TIMER_EVENT = 3,
}; };
static void decide_balanced(struct active_tap_hold * tap_hold, enum decision_moment event) { static void decide_balanced(struct active_tap_hold *tap_hold, enum decision_moment event)
switch(event) { {
switch (event) {
case TH_KEY_UP: case TH_KEY_UP:
tap_hold->is_hold = 0; tap_hold->is_hold = 0;
tap_hold->is_decided = true; tap_hold->is_decided = true;
@ -201,8 +207,9 @@ static void decide_balanced(struct active_tap_hold * tap_hold, enum decision_mom
} }
} }
static void decide_tap_preferred(struct active_tap_hold * tap_hold, enum decision_moment event) { static void decide_tap_preferred(struct active_tap_hold *tap_hold, enum decision_moment event)
switch(event) { {
switch (event) {
case TH_KEY_UP: case TH_KEY_UP:
tap_hold->is_hold = 0; tap_hold->is_hold = 0;
tap_hold->is_decided = true; tap_hold->is_decided = true;
@ -215,8 +222,9 @@ static void decide_tap_preferred(struct active_tap_hold * tap_hold, enum decisio
} }
} }
static void decide_hold_preferred(struct active_tap_hold * tap_hold, enum decision_moment event) { static void decide_hold_preferred(struct active_tap_hold *tap_hold, enum decision_moment event)
switch(event) { {
switch (event) {
case TH_KEY_UP: case TH_KEY_UP:
tap_hold->is_hold = 0; tap_hold->is_hold = 0;
tap_hold->is_decided = true; tap_hold->is_decided = true;
@ -233,32 +241,31 @@ static void decide_hold_preferred(struct active_tap_hold * tap_hold, enum decisi
} }
} }
static void decide_tap_hold(struct active_tap_hold * tap_hold, enum decision_moment event) static void decide_tap_hold(struct active_tap_hold *tap_hold, enum decision_moment event)
{ {
if (tap_hold->is_decided) { if (tap_hold->is_decided) {
return; return;
} }
if(tap_hold != undecided_tap_hold) { if (tap_hold != undecided_tap_hold) {
LOG_DBG("ERROR found undecided tap hold that is not the active tap hold"); LOG_DBG("ERROR found undecided tap hold that is not the active tap hold");
return; return;
} }
char* flavor = tap_hold->config->flavor; char *flavor = tap_hold->config->flavor;
if(strcmp(flavor, "balanced") == 0) { if (strcmp(flavor, "balanced") == 0) {
decide_balanced(tap_hold, event); decide_balanced(tap_hold, event);
} else if(strcmp(flavor, "tap-preferred") == 0) { } else if (strcmp(flavor, "tap-preferred") == 0) {
decide_tap_preferred(tap_hold, event); decide_tap_preferred(tap_hold, event);
} else if(strcmp(flavor, "hold-preferred") == 0) { } else if (strcmp(flavor, "hold-preferred") == 0) {
decide_hold_preferred(tap_hold, event); decide_hold_preferred(tap_hold, event);
} }
if(!tap_hold->is_decided) { if (!tap_hold->is_decided) {
return; return;
} }
LOG_DBG("%d decided %s (%s event %d)", tap_hold->position, tap_hold->is_hold?"hold":"tap", flavor, event); LOG_DBG("%d decided %s (%s event %d)", tap_hold->position, tap_hold->is_hold ? "hold" : "tap", flavor, event);
undecided_tap_hold = NULL; undecided_tap_hold = NULL;
struct zmk_behavior_binding *behavior; struct zmk_behavior_binding *behavior;
@ -277,7 +284,7 @@ static int on_tap_hold_binding_pressed(struct device *dev, u32_t position, u32_t
{ {
const struct behavior_tap_hold_config *cfg = dev->config_info; const struct behavior_tap_hold_config *cfg = dev->config_info;
if(undecided_tap_hold != NULL) { if (undecided_tap_hold != NULL) {
LOG_DBG("ERROR another tap-hold behavior is undecided."); LOG_DBG("ERROR another tap-hold behavior is undecided.");
// if this happens, make sure the behavior events occur AFTER other position events. // if this happens, make sure the behavior events occur AFTER other position events.
return 0; return 0;
@ -293,7 +300,7 @@ static int on_tap_hold_binding_pressed(struct device *dev, u32_t position, u32_t
undecided_tap_hold = tap_hold; undecided_tap_hold = tap_hold;
k_delayed_work_submit(&tap_hold->work, cfg->tapping_term_ms()); k_delayed_work_submit(&tap_hold->work, cfg->tapping_term_ms());
//todo: once we get timing info for keypresses, start the timer relative to the original keypress // todo: once we get timing info for keypresses, start the timer relative to the original keypress
// don't forget to simulate a timer-event before the event after that time was handled. // don't forget to simulate a timer-event before the event after that time was handled.
return 0; return 0;
@ -302,7 +309,8 @@ static int on_tap_hold_binding_pressed(struct device *dev, u32_t position, u32_t
static int on_tap_hold_binding_released(struct device *dev, u32_t position, u32_t _, u32_t __) static int on_tap_hold_binding_released(struct device *dev, u32_t position, u32_t _, u32_t __)
{ {
struct active_tap_hold *tap_hold = find_tap_hold(position); struct active_tap_hold *tap_hold = find_tap_hold(position);
if(tap_hold == NULL) {
if (tap_hold == NULL) {
LOG_ERR("ACTIVE_TAP_HOLD_CLEANED_UP_TOO_EARLY"); LOG_ERR("ACTIVE_TAP_HOLD_CLEANED_UP_TOO_EARLY");
return 0; return 0;
} }
@ -320,7 +328,7 @@ static int on_tap_hold_binding_released(struct device *dev, u32_t position, u32_
struct device *behavior_device = device_get_binding(behavior->behavior_dev); struct device *behavior_device = device_get_binding(behavior->behavior_dev);
behavior_keymap_binding_released(behavior_device, tap_hold->position, behavior->param1, behavior->param2); behavior_keymap_binding_released(behavior_device, tap_hold->position, behavior->param1, behavior->param2);
if(work_cancel_result == -EINPROGRESS) { if (work_cancel_result == -EINPROGRESS) {
// let the timer handler clean up // let the timer handler clean up
// if we'd clear now, the timer may call back for an uninitialized active_tap_hold. // if we'd clear now, the timer may call back for an uninitialized active_tap_hold.
LOG_DBG("%d tap-hold timer work in event queue", position); LOG_DBG("%d tap-hold timer work in event queue", position);
@ -339,19 +347,20 @@ static const struct behavior_driver_api behavior_tap_hold_driver_api = {
}; };
static int position_state_changed_listener(const struct zmk_event_header *eh) { static int position_state_changed_listener(const struct zmk_event_header *eh)
struct position_state_changed* ev = cast_position_state_changed(eh); {
struct position_state_changed *ev = cast_position_state_changed(eh);
if(undecided_tap_hold == NULL) { if (undecided_tap_hold == NULL) {
LOG_DBG("%d bubble (no undecided tap_hold active)", ev->position); LOG_DBG("%d bubble (no undecided tap_hold active)", ev->position);
return 0; return 0;
} }
if(undecided_tap_hold->position == ev->position) { if (undecided_tap_hold->position == ev->position) {
if(ev->state) { //keydown if (ev->state) { // keydown
LOG_ERR("tap-hold listener should be called before before most other listeners!"); LOG_ERR("tap-hold listener should be called before before most other listeners!");
return 0; return 0;
} else { //keyup } else { // keyup
LOG_DBG("%d bubble undecided tap-hold keyrelease event", undecided_tap_hold->position); LOG_DBG("%d bubble undecided tap-hold keyrelease event", undecided_tap_hold->position);
return 0; return 0;
} }
@ -360,42 +369,46 @@ static int position_state_changed_listener(const struct zmk_event_header *eh) {
if (!ev->state && find_captured_keydown_event(ev->position) == NULL) { if (!ev->state && find_captured_keydown_event(ev->position) == NULL) {
// no keydown event has been captured, let it bubble. // no keydown event has been captured, let it bubble.
// we'll catch modifiers later in modifier_state_changed_listener // we'll catch modifiers later in modifier_state_changed_listener
LOG_DBG("%d bubbling %d %s event", undecided_tap_hold->position, ev->position, ev->state?"down":"up"); LOG_DBG("%d bubbling %d %s event", undecided_tap_hold->position, ev->position, ev->state ? "down" : "up");
return 0; return 0;
} }
LOG_DBG("%d capturing %d %s event", undecided_tap_hold->position, ev->position, ev->state?"down":"up"); LOG_DBG("%d capturing %d %s event", undecided_tap_hold->position, ev->position, ev->state ? "down" : "up");
capture_event(eh); capture_event(eh);
decide_tap_hold(undecided_tap_hold, ev->state ? TH_OTHER_KEY_DOWN : TH_OTHER_KEY_UP); decide_tap_hold(undecided_tap_hold, ev->state ? TH_OTHER_KEY_DOWN : TH_OTHER_KEY_UP);
return ZMK_EV_EVENT_CAPTURED; return ZMK_EV_EVENT_CAPTURED;
} }
static bool is_mod(struct keycode_state_changed* ev) { static bool is_mod(struct keycode_state_changed *ev)
{
return ev->usage_page == USAGE_KEYPAD && ev->keycode >= LCTL && ev->keycode <= RGUI; return ev->usage_page == USAGE_KEYPAD && ev->keycode >= LCTL && ev->keycode <= RGUI;
} }
static int keycode_state_changed_listener(const struct zmk_event_header *eh) { static int keycode_state_changed_listener(const struct zmk_event_header *eh)
{
// we want to catch layer-up events too... how? // we want to catch layer-up events too... how?
struct keycode_state_changed* ev = cast_keycode_state_changed(eh); struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
if(undecided_tap_hold == NULL) {
//LOG_DBG("0x%02X bubble (no undecided tap_hold active)", ev->keycode); if (undecided_tap_hold == NULL) {
// LOG_DBG("0x%02X bubble (no undecided tap_hold active)", ev->keycode);
return 0; return 0;
} }
if(!is_mod(ev)) { if (!is_mod(ev)) {
//LOG_DBG("0x%02X bubble (not a mod)", ev->keycode); // LOG_DBG("0x%02X bubble (not a mod)", ev->keycode);
return 0; return 0;
} }
// only key-up events will bubble through position_state_changed_listener // only key-up events will bubble through position_state_changed_listener
// if a undecided_tap_hold is active. // if a undecided_tap_hold is active.
LOG_DBG("%d capturing 0x%02X %s event", undecided_tap_hold->position, ev->keycode, ev->state?"down":"up"); LOG_DBG("%d capturing 0x%02X %s event", undecided_tap_hold->position, ev->keycode, ev->state ? "down" : "up");
capture_event(eh); capture_event(eh);
return ZMK_EV_EVENT_CAPTURED; return ZMK_EV_EVENT_CAPTURED;
} }
int behavior_tap_hold_listener(const struct zmk_event_header *eh) { int behavior_tap_hold_listener(const struct zmk_event_header *eh)
{
if (is_position_state_changed(eh)) { if (is_position_state_changed(eh)) {
return position_state_changed_listener(eh); return position_state_changed_listener(eh);
} else if (is_keycode_state_changed(eh)) { } else if (is_keycode_state_changed(eh)) {
@ -413,7 +426,8 @@ ZMK_SUBSCRIPTION(behavior_tap_hold, keycode_state_changed);
void behavior_tap_hold_timer_work_handler(struct k_work *item) void behavior_tap_hold_timer_work_handler(struct k_work *item)
{ {
struct active_tap_hold *tap_hold = CONTAINER_OF(item, struct active_tap_hold, work); struct active_tap_hold *tap_hold = CONTAINER_OF(item, struct active_tap_hold, work);
if(tap_hold->work_is_cancelled) {
if (tap_hold->work_is_cancelled) {
clear_tap_hold(tap_hold); clear_tap_hold(tap_hold);
} else { } else {
decide_tap_hold(tap_hold, TH_TIMER_EVENT); decide_tap_hold(tap_hold, TH_TIMER_EVENT);
@ -423,7 +437,8 @@ void behavior_tap_hold_timer_work_handler(struct k_work *item)
static int behavior_tap_hold_init(struct device *dev) static int behavior_tap_hold_init(struct device *dev)
{ {
static bool init_first_run = true; static bool init_first_run = true;
if(init_first_run) {
if (init_first_run) {
for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_HELD; i++) { for (int i = 0; i < ZMK_BHV_TAP_HOLD_MAX_HELD; i++) {
k_delayed_work_init(&active_tap_holds[i].work, behavior_tap_hold_timer_work_handler); k_delayed_work_init(&active_tap_holds[i].work, behavior_tap_hold_timer_work_handler);
active_tap_holds[i].position = ZMK_BHV_TAP_HOLD_POSITION_NOT_USED; active_tap_holds[i].position = ZMK_BHV_TAP_HOLD_POSITION_NOT_USED;
@ -438,7 +453,8 @@ static struct behavior_tap_hold_data behavior_tap_hold_data;
/************************************************************ NODE CONFIG */ /************************************************************ NODE CONFIG */
#define _TRANSFORM_ENTRY(idx, node) \ #define _TRANSFORM_ENTRY(idx, node) \
{ .behavior_dev = DT_LABEL(DT_INST_PHANDLE_BY_IDX(node, bindings, idx)), \ { \
.behavior_dev = DT_LABEL(DT_INST_PHANDLE_BY_IDX(node, bindings, idx)), \
.param1 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param1), (0), (DT_INST_PHA_BY_IDX(node, bindings, idx, param1))), \ .param1 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param1), (0), (DT_INST_PHA_BY_IDX(node, bindings, idx, param1))), \
.param2 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param2), (0), (DT_INST_PHA_BY_IDX(node, bindings, idx, param2))), \ .param2 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param2), (0), (DT_INST_PHA_BY_IDX(node, bindings, idx, param2))), \
}, },
@ -454,7 +470,8 @@ static struct behavior_tap_hold_data behavior_tap_hold_data;
.tapping_term_ms = &behavior_tap_hold_config_##n##_gettime, \ .tapping_term_ms = &behavior_tap_hold_config_##n##_gettime, \
.flavor = DT_INST_PROP(n, flavor), \ .flavor = DT_INST_PROP(n, flavor), \
}; \ }; \
DEVICE_AND_API_INIT(behavior_tap_hold_##n, DT_INST_LABEL(n), behavior_tap_hold_init, \ DEVICE_AND_API_INIT( \
behavior_tap_hold_##n, DT_INST_LABEL(n), behavior_tap_hold_init, \
&behavior_tap_hold_data, \ &behavior_tap_hold_data, \
&behavior_tap_hold_config_##n, \ &behavior_tap_hold_config_##n, \
APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, \ APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, \