refactor(core): Extra event payloads to own types, refactor API.

* Make it easier to use *just* event payloads by defining the data,
  and then having event manager macros generate "wrapper structs"
* Improve is_*/cast_* APIs to hide details of full event struct.
* Create `zmk_event_t` typedef to pass to event handlers.
* Bring event names inline w/ consistent `zmk_` prefix.

1 files changed, 27 insertions, 22 deletions

diff --git a/app/include/zmk/event_manager.h b/app/include/zmk/event_manager.h
index e5b6ed5..8fc3f19 100644
--- a/app/include/zmk/event_manager.h
+++ b/app/include/zmk/event_manager.h
@@ -14,16 +14,16 @@ struct zmk_event_type {
     const char *name;
 };
 
-struct zmk_event_header {
+typedef struct {
     const struct zmk_event_type *event;
     uint8_t last_listener_index;
-};
+} zmk_event_t;
 
 #define ZMK_EV_EVENT_BUBBLE 0
 #define ZMK_EV_EVENT_HANDLED 1
 #define ZMK_EV_EVENT_CAPTURED 2
 
-typedef int (*zmk_listener_callback_t)(const struct zmk_event_header *eh);
+typedef int (*zmk_listener_callback_t)(const zmk_event_t *eh);
 struct zmk_listener {
     zmk_listener_callback_t callback;
 };
@@ -34,25 +34,29 @@ struct zmk_event_subscription {
 };
 
 #define ZMK_EVENT_DECLARE(event_type)                                                              \
-    struct event_type *new_##event_type();                                                         \
-    bool is_##event_type(const struct zmk_event_header *eh);                                       \
-    struct event_type *cast_##event_type(const struct zmk_event_header *eh);                       \
+    struct event_type##_event {                                                                    \
+        zmk_event_t header;                                                                        \
+        struct event_type data;                                                                    \
+    };                                                                                             \
+    struct event_type##_event *new_##event_type(struct event_type);                                \
+    bool is_##event_type(const zmk_event_t *eh);                                                   \
+    struct event_type *cast_##event_type(const zmk_event_t *eh);                                   \
     extern const struct zmk_event_type zmk_event_##event_type;
 
 #define ZMK_EVENT_IMPL(event_type)                                                                 \
     const struct zmk_event_type zmk_event_##event_type = {.name = STRINGIFY(event_type)};          \
     const struct zmk_event_type *zmk_event_ref_##event_type __used                                 \
         __attribute__((__section__(".event_type"))) = &zmk_event_##event_type;                     \
-    struct event_type *new_##event_type() {                                                        \
-        struct event_type *ev = (struct event_type *)k_malloc(sizeof(struct event_type));          \
+    struct event_type##_event *new_##event_type(struct event_type data) {                          \
+        struct event_type##_event *ev =                                                            \
+            (struct event_type##_event *)k_malloc(sizeof(struct event_type##_event));              \
         ev->header.event = &zmk_event_##event_type;                                                \
+        ev->data = data;                                                                           \
         return ev;                                                                                 \
     };                                                                                             \
-    bool is_##event_type(const struct zmk_event_header *eh) {                                      \
-        return eh->event == &zmk_event_##event_type;                                               \
-    };                                                                                             \
-    struct event_type *cast_##event_type(const struct zmk_event_header *eh) {                      \
-        return (struct event_type *)eh;                                                            \
+    bool is_##event_type(const zmk_event_t *eh) { return eh->event == &zmk_event_##event_type; };  \
+    struct event_type *cast_##event_type(const zmk_event_t *eh) {                                  \
+        return &((struct event_type##_event *)eh)->data;                                           \
     };
 
 #define ZMK_LISTENER(mod, cb) const struct zmk_listener zmk_listener_##mod = {.callback = cb};
@@ -65,18 +69,19 @@ struct zmk_event_subscription {
             .listener = &zmk_listener_##mod,                                                       \
     };
 
-#define ZMK_EVENT_RAISE(ev) zmk_event_manager_raise((struct zmk_event_header *)ev);
+#define ZMK_EVENT_RAISE(ev) zmk_event_manager_raise((zmk_event_t *)ev);
 
 #define ZMK_EVENT_RAISE_AFTER(ev, mod)                                                             \
-    zmk_event_manager_raise_after((struct zmk_event_header *)ev, &zmk_listener_##mod);
+    zmk_event_manager_raise_after((zmk_event_t *)ev, &zmk_listener_##mod);
 
 #define ZMK_EVENT_RAISE_AT(ev, mod)                                                                \
-    zmk_event_manager_raise_at((struct zmk_event_header *)ev, &zmk_listener_##mod);
+    zmk_event_manager_raise_at((zmk_event_t *)ev, &zmk_listener_##mod);
+
+#define ZMK_EVENT_RELEASE(ev) zmk_event_manager_release((zmk_event_t *)ev);
 
-#define ZMK_EVENT_RELEASE(ev) zmk_event_manager_release((struct zmk_event_header *)ev);
+#define ZMK_EVENT_FREE(ev) k_free((void *)ev);
 
-int zmk_event_manager_raise(struct zmk_event_header *event);
-int zmk_event_manager_raise_after(struct zmk_event_header *event,
-                                  const struct zmk_listener *listener);
-int zmk_event_manager_raise_at(struct zmk_event_header *event, const struct zmk_listener *listener);
-int zmk_event_manager_release(struct zmk_event_header *event);
+int zmk_event_manager_raise(zmk_event_t *event);
+int zmk_event_manager_raise_after(zmk_event_t *event, const struct zmk_listener *listener);
+int zmk_event_manager_raise_at(zmk_event_t *event, const struct zmk_listener *listener);
+int zmk_event_manager_release(zmk_event_t *event);
\ No newline at end of file