events: Remove unique events for top/bottom

NickeZ · NickeZ · commit 65f5b523885d · 2025-10-01T10:32:41.000+02:00
Refactor code to get rid of more events. Inline the event slider data
into the event.
diff --git a/src/touch/gestures.c b/src/touch/gestures.c
@@ -144,18 +144,6 @@ static void _reset_state(void)
     memset(_state, 0, sizeof(_state));
 }
 
-/**
- * Prepares the gestures data to be sent with an emitted event
- */
-static void _collect_gestures_data(
-    gestures_detection_state_t* state,
-    gestures_slider_data_t* slider_data)
-{
-    slider_data->position = state->position_current;
-    slider_data->diff = state->position_current - state->position_start;
-    slider_data->velocity = state->velocity_sum;
-}
-
 /********************************** GESTURE DETECTION **********************************/
 
 static bool _is_continuous_tap(uint8_t location)
@@ -194,59 +182,63 @@ static void _gesture_emit_event(uint8_t id, slider_location_t location)
     if (!_released_since_new_screen) {
         return;
     }
-    gestures_slider_data_t slider_data;
-    _collect_gestures_data(&_state[location], &slider_data);
-    event_t event = {.data = &slider_data, .id = id};
+    event_slider_data_t slider_data = {
+        .source = location,
+        .position = _state[location].position_current,
+        .diff = _state[location].position_current - _state[location].position_start,
+        .velocity = _state[location].velocity_sum,
+    };
+    event_t event = {.id = id, .data = slider_data};
     emit_event(&event);
 }
 
 static void _emit_continuous_slide_event(void)
 {
     if (_is_continuous_slide(top_slider)) {
-        _gesture_emit_event(EVENT_TOP_SLIDE, top_slider);
+        _gesture_emit_event(EVENT_SLIDE, top_slider);
     }
     if (_is_continuous_slide(bottom_slider)) {
-        _gesture_emit_event(EVENT_BOTTOM_SLIDE, bottom_slider);
+        _gesture_emit_event(EVENT_SLIDE, bottom_slider);
     }
 }
 
 static void _emit_slide_release_event(void)
 {
     if (_is_slide_released(top_slider)) {
-        _gesture_emit_event(EVENT_TOP_SLIDE_RELEASED, top_slider);
+        _gesture_emit_event(EVENT_SLIDE_RELEASED, top_slider);
     }
     if (_is_slide_released(bottom_slider)) {
-        _gesture_emit_event(EVENT_BOTTOM_SLIDE_RELEASED, bottom_slider);
+        _gesture_emit_event(EVENT_SLIDE_RELEASED, bottom_slider);
     }
 }
 
 static void _emit_long_tap_event(void)
 {
     if (_is_long_tap_release(top_slider)) {
-        _gesture_emit_event(EVENT_TOP_LONG_TAP, top_slider);
+        _gesture_emit_event(EVENT_LONG_TAP, top_slider);
     }
     if (_is_long_tap_release(bottom_slider)) {
-        _gesture_emit_event(EVENT_BOTTOM_LONG_TAP, bottom_slider);
+        _gesture_emit_event(EVENT_LONG_TAP, bottom_slider);
     }
 }
 
 static void _emit_short_tap_event(void)
 {
     if (_is_tap_release(top_slider)) {
-        _gesture_emit_event(EVENT_TOP_SHORT_TAP, top_slider);
+        _gesture_emit_event(EVENT_SHORT_TAP, top_slider);
     }
     if (_is_tap_release(bottom_slider)) {
-        _gesture_emit_event(EVENT_BOTTOM_SHORT_TAP, bottom_slider);
+        _gesture_emit_event(EVENT_SHORT_TAP, bottom_slider);
     }
 }
 
 static void _emit_continuous_tap_event(void)
 {
     if (_is_continuous_tap(top_slider)) {
-        _gesture_emit_event(EVENT_TOP_CONTINUOUS_TAP, top_slider);
+        _gesture_emit_event(EVENT_CONTINUOUS_TAP, top_slider);
     }
     if (_is_continuous_tap(bottom_slider)) {
-        _gesture_emit_event(EVENT_BOTTOM_CONTINUOUS_TAP, bottom_slider);
+        _gesture_emit_event(EVENT_CONTINUOUS_TAP, bottom_slider);
     }
 }
 
diff --git a/src/touch/gestures.h b/src/touch/gestures.h
@@ -33,12 +33,6 @@
 #define SLIDER_POSITION_ONE_THIRD (MAX_SLIDER_POS / 3)
 #define SLIDER_POSITION_TWO_THIRD (MAX_SLIDER_POS / 3 * 2)
 
-typedef struct {
-    int16_t diff;
-    uint16_t position;
-    int32_t velocity;
-} gestures_slider_data_t;
-
 /**
  * Detects a gestures and calls the respective callback.
  * @param[in] reset The flag indicates whether the gesture history should be
diff --git a/src/ui/components/button.c b/src/ui/components/button.c
@@ -59,18 +59,13 @@ static void _render(component_t* component)
 static void _on_event(const event_t* event, component_t* component)
 {
     button_data_t* data = (button_data_t*)component->data;
-    const gestures_slider_data_t* slider_data = (const gestures_slider_data_t*)event->data;
-    if (data->span_over_slider) {
-        if (event->id ==
-            ((data->location == top_slider) ? EVENT_TOP_SHORT_TAP : EVENT_BOTTOM_SHORT_TAP)) {
+    if (event->id == EVENT_SHORT_TAP && event->data.source == data->location) {
+        if (data->span_over_slider) {
             data->callback(component);
-        }
-    } else {
-        if (event->id ==
-                ((data->location == top_slider) ? EVENT_TOP_SHORT_TAP : EVENT_BOTTOM_SHORT_TAP) &&
-            slider_data->position >= component->position.left * MAX_SLIDER_POS / SCREEN_WIDTH &&
-            slider_data->position <= (component->position.left + component->dimension.width) *
-                                         MAX_SLIDER_POS / SCREEN_WIDTH) {
+        } else if (
+            event->data.position >= component->position.left * MAX_SLIDER_POS / SCREEN_WIDTH &&
+            event->data.position <= (component->position.left + component->dimension.width) *
+                                        MAX_SLIDER_POS / SCREEN_WIDTH) {
             data->callback(component);
         }
     }
diff --git a/src/ui/components/confirm_gesture.c b/src/ui/components/confirm_gesture.c
@@ -100,41 +100,32 @@ static void _render(component_t* component)
  */
 static void _on_event(const event_t* event, component_t* component)
 {
-    // Avoid type casting to unknown events
-    if (event->id != EVENT_TOP_SLIDE_RELEASED && event->id != EVENT_BOTTOM_SLIDE_RELEASED &&
-        event->id != EVENT_TOP_CONTINUOUS_TAP && event->id != EVENT_BOTTOM_CONTINUOUS_TAP &&
-        event->id != EVENT_TOP_SHORT_TAP && event->id != EVENT_BOTTOM_SHORT_TAP &&
-        event->id != EVENT_TOP_LONG_TAP && event->id != EVENT_BOTTOM_LONG_TAP &&
-        event->id != EVENT_TOP_SLIDE && event->id != EVENT_BOTTOM_SLIDE) {
-        return;
-    }
     confirm_data_t* data = (confirm_data_t*)component->data;
-    const gestures_slider_data_t* slider_data = (const gestures_slider_data_t*)event->data;
 
     switch (event->id) {
-    case EVENT_TOP_SLIDE_RELEASED:
-        data->active_top = false;
-        break;
-    case EVENT_TOP_CONTINUOUS_TAP:
-        if (slider_data->position > SLIDER_POSITION_TWO_THIRD &&
-            slider_data->position <= MAX_SLIDER_POS) {
-            data->active_top = true;
+    case EVENT_SLIDE_RELEASED:
+        if (event->data.source == top_slider) {
+            data->active_top = false;
+        } else {
+            data->active_bottom = false;
         }
         break;
-    case EVENT_TOP_SHORT_TAP:
-        data->active_top = false;
-        break;
-    case EVENT_BOTTOM_SLIDE_RELEASED:
-        data->active_bottom = false;
-        break;
-    case EVENT_BOTTOM_CONTINUOUS_TAP:
-        if (slider_data->position > SLIDER_POSITION_TWO_THIRD &&
-            slider_data->position <= MAX_SLIDER_POS) {
-            data->active_bottom = true;
+    case EVENT_CONTINUOUS_TAP:
+        if (event->data.position > SLIDER_POSITION_TWO_THIRD &&
+            event->data.position <= MAX_SLIDER_POS) {
+            if (event->data.source == top_slider) {
+                data->active_top = true;
+            } else {
+                data->active_bottom = true;
+            }
         }
         break;
-    case EVENT_BOTTOM_SHORT_TAP:
-        data->active_bottom = false;
+    case EVENT_SHORT_TAP:
+        if (event->data.source == top_slider) {
+            data->active_top = false;
+        } else {
+            data->active_bottom = false;
+        }
         break;
     default:
         break;
diff --git a/src/ui/components/icon_button.c b/src/ui/components/icon_button.c
@@ -106,16 +106,9 @@ static void _on_event(const event_t* event, component_t* component)
 
     // Return if the slider event is on the wrong slider
     switch (event->id) {
-    case EVENT_TOP_SHORT_TAP:
-    case EVENT_TOP_CONTINUOUS_TAP:
-        if (data->location != top_slider) {
-            data->active = false;
-            return;
-        }
-        break;
-    case EVENT_BOTTOM_SHORT_TAP:
-    case EVENT_BOTTOM_CONTINUOUS_TAP:
-        if (data->location != bottom_slider) {
+    case EVENT_SHORT_TAP:
+    case EVENT_CONTINUOUS_TAP:
+        if (event->data.source != data->location) {
             data->active = false;
             return;
         }
@@ -127,17 +120,16 @@ static void _on_event(const event_t* event, component_t* component)
 
     // Return if the slider position is away from the button
     // Only slider events reach here, so ok to typescast event->data
-    const gestures_slider_data_t* slider_data = (const gestures_slider_data_t*)event->data;
     switch (data->type) {
     case ICON_BUTTON_CHECK:
     case ICON_BUTTON_NEXT:
-        if (slider_data->position < SLIDER_POSITION_TWO_THIRD) {
+        if (event->data.position < SLIDER_POSITION_TWO_THIRD) {
             data->active = false;
             return;
         }
         break;
     case ICON_BUTTON_CROSS:
-        if (slider_data->position >= SLIDER_POSITION_ONE_THIRD) {
+        if (event->data.position >= SLIDER_POSITION_ONE_THIRD) {
             data->active = false;
             return;
         }
@@ -151,8 +143,7 @@ static void _on_event(const event_t* event, component_t* component)
 
     // Call the callback on short tap
     switch (event->id) {
-    case EVENT_TOP_SHORT_TAP:
-    case EVENT_BOTTOM_SHORT_TAP:
+    case EVENT_SHORT_TAP:
         if (data->callback) {
             data->callback(data->user_data);
         }
diff --git a/src/ui/components/keyboard_switch.c b/src/ui/components/keyboard_switch.c
@@ -90,18 +90,19 @@ static void _render(component_t* component)
 static void _on_event(const event_t* event, component_t* component)
 {
     keyboard_switch_data_t* ks_data = (keyboard_switch_data_t*)component->data;
-    const gestures_slider_data_t* slider_data = (const gestures_slider_data_t*)event->data;
     switch (event->id) {
-    case EVENT_TOP_CONTINUOUS_TAP:
-        if (ks_data->location == top_slider && slider_data->position > SLIDER_POSITION_ONE_THIRD &&
-            slider_data->position <= SLIDER_POSITION_TWO_THIRD) {
+    case EVENT_CONTINUOUS_TAP:
+        if (event->data.source == top_slider && ks_data->location == top_slider &&
+            event->data.position > SLIDER_POSITION_ONE_THIRD &&
+            event->data.position <= SLIDER_POSITION_TWO_THIRD) {
             ks_data->active = true;
             break;
         }
         /* FALLTHROUGH */
-    case EVENT_TOP_SHORT_TAP:
-        if (ks_data->location == top_slider && slider_data->position > SLIDER_POSITION_ONE_THIRD &&
-            slider_data->position <= SLIDER_POSITION_TWO_THIRD) {
+    case EVENT_SHORT_TAP:
+        if (event->data.source == top_slider && ks_data->location == top_slider &&
+            event->data.position > SLIDER_POSITION_ONE_THIRD &&
+            event->data.position <= SLIDER_POSITION_TWO_THIRD) {
             ks_data->active = false;
             switch (ks_data->mode) {
             case LOWER_CASE:
diff --git a/src/ui/components/label.c b/src/ui/components/label.c
@@ -138,36 +138,35 @@ static void _render(component_t* component)
 static void _on_event(const event_t* event, component_t* component)
 {
     data_t* data = (data_t*)component->data;
+    if (event->data.source != bottom_slider) {
+        return;
+    }
     if (data->scrollable) {
         switch (event->id) {
-        case EVENT_BOTTOM_SLIDE: {
-            const gestures_slider_data_t* slider_data = (const gestures_slider_data_t*)event->data;
+        case EVENT_SLIDE: {
             // Variable scroll speed
             int16_t margin = SCREEN_WIDTH / 5;
-            data->slider_position_diff += SIGMOID(slider_data->velocity);
+            data->slider_position_diff += SIGMOID(event->data.velocity);
             data->text_position = data->text_position_last + (int16_t)data->slider_position_diff;
             data->text_position = MIN(
                 component->dimension.width / 2 + margin,
                 MAX(-margin - component->dimension.width / 2 + SCREEN_WIDTH, data->text_position));
-            data->slider_position = slider_data->position;
+            data->slider_position = event->data.position;
             data->slider_is_touched = true;
             data->slider_was_touched = true;
             break;
         }
-
-        case EVENT_BOTTOM_SLIDE_RELEASED:
+        case EVENT_SLIDE_RELEASED:
             data->text_position_last = data->text_position;
             data->slider_position_diff = 0;
             data->slider_is_touched = false;
             break;
 
-        case EVENT_BOTTOM_CONTINUOUS_TAP: {
-            const gestures_slider_data_t* slider_data = (const gestures_slider_data_t*)event->data;
-            data->slider_position = slider_data->position;
+        case EVENT_CONTINUOUS_TAP:
+            data->slider_position = event->data.position;
             data->slider_is_touched = true;
             data->slider_was_touched = true;
             break;
-        }
         default:
             break;
         }
diff --git a/src/ui/components/left_arrow.c b/src/ui/components/left_arrow.c
@@ -60,33 +60,21 @@ static void _render(component_t* component)
 static void _on_event(const event_t* event, component_t* component)
 {
     left_arrow_data_t* data = (left_arrow_data_t*)component->data;
-    const gestures_slider_data_t* slider_data = (const gestures_slider_data_t*)event->data;
+    if (event->data.source != data->location) {
+        return;
+    }
     switch (event->id) {
-    case EVENT_TOP_SHORT_TAP:
-    case EVENT_BOTTOM_SHORT_TAP:
-        if (data->location == top_slider && event->id == EVENT_BOTTOM_SHORT_TAP) {
-            break;
-        }
-        if (data->location == bottom_slider && event->id == EVENT_TOP_SHORT_TAP) {
-            break;
-        }
-        if (slider_data->position <= SLIDER_POSITION_ONE_THIRD) {
+    case EVENT_SHORT_TAP:
+        if (event->data.position <= SLIDER_POSITION_ONE_THIRD) {
             data->active = false;
             if (data->callback) {
                 data->callback(data->user_data);
             }
             break;
         }
         /* FALLTHROUGH */
-    case EVENT_TOP_CONTINUOUS_TAP:
-    case EVENT_BOTTOM_CONTINUOUS_TAP:
-        if (data->location == top_slider && event->id == EVENT_BOTTOM_CONTINUOUS_TAP) {
-            break;
-        }
-        if (data->location == bottom_slider && event->id == EVENT_TOP_CONTINUOUS_TAP) {
-            break;
-        }
-        if (slider_data->position <= SLIDER_POSITION_ONE_THIRD) {
+    case EVENT_CONTINUOUS_TAP:
+        if (event->data.position <= SLIDER_POSITION_ONE_THIRD) {
             data->active = true;
             break;
         }
diff --git a/src/ui/components/right_arrow.c b/src/ui/components/right_arrow.c
diff --git a/src/ui/components/trinary_input_char.c b/src/ui/components/trinary_input_char.c
diff --git a/src/ui/event.h b/src/ui/event.h
diff --git a/src/ui/event_handler.c b/src/ui/event_handler.c

Original file line number	Diff line number	Diff line change
`@@ -144,18 +144,6 @@ static void _reset_state(void)`
`144`	`144`	`memset(_state, 0, sizeof(_state));`
`145`	`145`	`}`
`146`	`146`
`147`		`-/**`
`148`		`- * Prepares the gestures data to be sent with an emitted event`
`149`		`- */`
`150`		`-static void _collect_gestures_data(`
`151`		`- gestures_detection_state_t* state,`
`152`		`- gestures_slider_data_t* slider_data)`
`153`		`-{`
`154`		`- slider_data->position = state->position_current;`
`155`		`- slider_data->diff = state->position_current - state->position_start;`
`156`		`- slider_data->velocity = state->velocity_sum;`
`157`		`-}`
`158`		`-`
`159`	`147`	`/******************************** GESTURE DETECTION ********************************/`
`160`	`148`
`161`	`149`	`static bool _is_continuous_tap(uint8_t location)`
`@@ -194,59 +182,63 @@ static void _gesture_emit_event(uint8_t id, slider_location_t location)`
`194`	`182`	`if (!_released_since_new_screen) {`
`195`	`183`	`return;`
`196`	`184`	`}`
`197`		`- gestures_slider_data_t slider_data;`
`198`		`- _collect_gestures_data(&_state[location], &slider_data);`
`199`		`- event_t event = {.data = &slider_data, .id = id};`
	`185`	`+ event_slider_data_t slider_data = {`
	`186`	`+ .source = location,`
	`187`	`+ .position = _state[location].position_current,`
	`188`	`+ .diff = _state[location].position_current - _state[location].position_start,`
	`189`	`+ .velocity = _state[location].velocity_sum,`
	`190`	`+ };`
	`191`	`+ event_t event = {.id = id, .data = slider_data};`
`200`	`192`	`emit_event(&event);`
`201`	`193`	`}`
`202`	`194`
`203`	`195`	`static void _emit_continuous_slide_event(void)`
`204`	`196`	`{`
`205`	`197`	`if (_is_continuous_slide(top_slider)) {`
`206`		`- _gesture_emit_event(EVENT_TOP_SLIDE, top_slider);`
	`198`	`+ _gesture_emit_event(EVENT_SLIDE, top_slider);`
`207`	`199`	`}`
`208`	`200`	`if (_is_continuous_slide(bottom_slider)) {`
`209`		`- _gesture_emit_event(EVENT_BOTTOM_SLIDE, bottom_slider);`
	`201`	`+ _gesture_emit_event(EVENT_SLIDE, bottom_slider);`
`210`	`202`	`}`
`211`	`203`	`}`
`212`	`204`
`213`	`205`	`static void _emit_slide_release_event(void)`
`214`	`206`	`{`
`215`	`207`	`if (_is_slide_released(top_slider)) {`
`216`		`- _gesture_emit_event(EVENT_TOP_SLIDE_RELEASED, top_slider);`
	`208`	`+ _gesture_emit_event(EVENT_SLIDE_RELEASED, top_slider);`
`217`	`209`	`}`
`218`	`210`	`if (_is_slide_released(bottom_slider)) {`
`219`		`- _gesture_emit_event(EVENT_BOTTOM_SLIDE_RELEASED, bottom_slider);`
	`211`	`+ _gesture_emit_event(EVENT_SLIDE_RELEASED, bottom_slider);`
`220`	`212`	`}`
`221`	`213`	`}`
`222`	`214`
`223`	`215`	`static void _emit_long_tap_event(void)`
`224`	`216`	`{`
`225`	`217`	`if (_is_long_tap_release(top_slider)) {`
`226`		`- _gesture_emit_event(EVENT_TOP_LONG_TAP, top_slider);`
	`218`	`+ _gesture_emit_event(EVENT_LONG_TAP, top_slider);`
`227`	`219`	`}`
`228`	`220`	`if (_is_long_tap_release(bottom_slider)) {`
`229`		`- _gesture_emit_event(EVENT_BOTTOM_LONG_TAP, bottom_slider);`
	`221`	`+ _gesture_emit_event(EVENT_LONG_TAP, bottom_slider);`
`230`	`222`	`}`
`231`	`223`	`}`
`232`	`224`
`233`	`225`	`static void _emit_short_tap_event(void)`
`234`	`226`	`{`
`235`	`227`	`if (_is_tap_release(top_slider)) {`
`236`		`- _gesture_emit_event(EVENT_TOP_SHORT_TAP, top_slider);`
	`228`	`+ _gesture_emit_event(EVENT_SHORT_TAP, top_slider);`
`237`	`229`	`}`
`238`	`230`	`if (_is_tap_release(bottom_slider)) {`
`239`		`- _gesture_emit_event(EVENT_BOTTOM_SHORT_TAP, bottom_slider);`
	`231`	`+ _gesture_emit_event(EVENT_SHORT_TAP, bottom_slider);`
`240`	`232`	`}`
`241`	`233`	`}`
`242`	`234`
`243`	`235`	`static void _emit_continuous_tap_event(void)`
`244`	`236`	`{`
`245`	`237`	`if (_is_continuous_tap(top_slider)) {`
`246`		`- _gesture_emit_event(EVENT_TOP_CONTINUOUS_TAP, top_slider);`
	`238`	`+ _gesture_emit_event(EVENT_CONTINUOUS_TAP, top_slider);`
`247`	`239`	`}`
`248`	`240`	`if (_is_continuous_tap(bottom_slider)) {`
`249`		`- _gesture_emit_event(EVENT_BOTTOM_CONTINUOUS_TAP, bottom_slider);`
	`241`	`+ _gesture_emit_event(EVENT_CONTINUOUS_TAP, bottom_slider);`
`250`	`242`	`}`
`251`	`243`	`}`
`252`	`244`