Add multi-callback regression test and release event callback dicts

Register PRESSED/RELEASED/CLICKED on one object in test_lvgl_cpython
to guard against add_event_cb clobbering regressions. Document fast
incremental rebuilds via setup.py build_ext --inplace. Release
per-registration callback dicts on event removal and object DELETE in
lvpy_runtime, with peek helpers for remove_event_cb wrappers.

Author: bdbarnett

README.md

@@ -212,7 +212,7 @@ Phases 1–7 are enabled in the generator today. Smoke tests in `test_lvgl_cpyth
 - **Display OO API**: no methods on `lv_display_t` wrappers; use `lv.display_*` module functions.
 - **Prototype aliasing**: some widget `tp_methods` entries may point at the wrong C function when LVGL reuses prototypes; prefer module-level names when in doubt.
 - **`C_Pointer` helper struct**: emitted late; a runtime stub is used until helper emission is complete.
-- **Callback lifetime**: Python wrappers clear `lv_obj->user_data` on dealloc; long-running apps should keep references to objects that register callbacks.
+- **Callback lifetime**: Per-registration callback dicts (`add_event_cb` with `user_data=None`) are released when the event is removed or the object is deleted. Python wrappers clear `lv_obj->user_data` on dealloc; long-running apps should still keep references to objects that register callbacks.
 
 ## Development
 
@@ -224,6 +224,14 @@ cd ../lv_cpython_mod && .venv/bin/pip install -e .
 .venv/bin/python test_lvgl_cpython.py
 ```
 
+After the first full build, incremental rebuilds are much faster (only changed sources such as `generated/lvpy.c` are recompiled). From `lv_cpython_mod`, with `setuptools` and `wheel` installed in the target venv:
+
+```bash
+.venv/bin/python setup.py build_ext --inplace
+```
+
+With an editable install (`pip install -e .`), the updated `.so` / `.pyd` beside this repo is picked up immediately — no reinstall step needed.
+
 Generator work lives in the [`lv_bindings`](https://github.com/PyDevices/lv_bindings) repository (`binding/emit_py_native.py`, `binding/emit_py_cp.py`, `binding/emit_cpython.py`). Runtime fixes and CPython-specific behavior belong here in `lvpy_runtime.c`.
 
 ## Related projects

lvpy_runtime.c

@@ -511,13 +511,7 @@ static PyObject *py_C_Pointer_new(PyTypeObject *type, PyObject *args, PyObject *
     return make_new_lv_struct(type, args, kwds, 0);
 }
 
-static void py_lv_delete_cb(lv_event_t *e)
-{
-    lv_obj_t *lv_obj = lv_event_get_target(e);
-    if (!lv_obj) return;
-    py_lv_obj_t *self = (py_lv_obj_t *)lv_obj->user_data;
-    if (self) self->lv_obj = NULL;
-}
+static void py_lv_delete_cb(lv_event_t *e);
 
 PyTypeObject *py_get_base_obj_type(void)
 {
@@ -621,6 +615,113 @@ PyObject *get_callback_dict_from_user_data(void *user_data)
     return mp_get_callbacks(obj);
 }
 
+int lvpy_is_per_registration_callback_dict(void *user_data)
+{
+    if (!user_data) return 0;
+    PyObject *obj = (PyObject *)user_data;
+    if (!PyDict_Check(obj)) return 0;
+    PyTypeObject *base = py_get_base_obj_type();
+    if (base && PyObject_TypeCheck(obj, base)) return 0;
+    return 1;
+}
+
+void lvpy_release_callback_user_data(void *user_data)
+{
+    if (lvpy_is_per_registration_callback_dict(user_data)) {
+        Py_DECREF((PyObject *)user_data);
+    }
+}
+
+static void *lvpy_peek_event_dsc_list_cb_user_data(
+    uint32_t count,
+    lv_event_dsc_t *(*get_dsc)(uint32_t index, void *ctx),
+    void *ctx,
+    lv_event_cb_t cb,
+    void *specific_user_data)
+{
+    for (uint32_t i = 0; i < count; i++) {
+        lv_event_dsc_t *dsc = get_dsc(i, ctx);
+        if (!dsc) continue;
+        if (lv_event_dsc_get_cb(dsc) != cb) continue;
+        void *ud = lv_event_dsc_get_user_data(dsc);
+        if (specific_user_data != NULL && ud != specific_user_data) continue;
+        return ud;
+    }
+    return NULL;
+}
+
+typedef struct {
+    lv_obj_t *obj;
+} lvpy_obj_peek_ctx;
+
+static lv_event_dsc_t *lvpy_obj_peek_get_dsc(uint32_t index, void *ctx)
+{
+    lvpy_obj_peek_ctx *c = (lvpy_obj_peek_ctx *)ctx;
+    return lv_obj_get_event_dsc(c->obj, index);
+}
+
+void *lvpy_peek_obj_event_cb_user_data(lv_obj_t *obj, lv_event_cb_t cb, void *specific_user_data)
+{
+    if (!obj) return NULL;
+    lvpy_obj_peek_ctx ctx = {obj};
+    return lvpy_peek_event_dsc_list_cb_user_data(
+        lv_obj_get_event_count(obj), lvpy_obj_peek_get_dsc, &ctx, cb, specific_user_data);
+}
+
+typedef struct {
+    lv_display_t *disp;
+} lvpy_display_peek_ctx;
+
+static lv_event_dsc_t *lvpy_display_peek_get_dsc(uint32_t index, void *ctx)
+{
+    lvpy_display_peek_ctx *c = (lvpy_display_peek_ctx *)ctx;
+    return lv_display_get_event_dsc(c->disp, index);
+}
+
+void *lvpy_peek_display_event_cb_user_data(lv_display_t *disp, lv_event_cb_t cb, void *specific_user_data)
+{
+    if (!disp) return NULL;
+    lvpy_display_peek_ctx ctx = {disp};
+    return lvpy_peek_event_dsc_list_cb_user_data(
+        lv_display_get_event_count(disp), lvpy_display_peek_get_dsc, &ctx, cb, specific_user_data);
+}
+
+typedef struct {
+    lv_indev_t *indev;
+} lvpy_indev_peek_ctx;
+
+static lv_event_dsc_t *lvpy_indev_peek_get_dsc(uint32_t index, void *ctx)
+{
+    lvpy_indev_peek_ctx *c = (lvpy_indev_peek_ctx *)ctx;
+    return lv_indev_get_event_dsc(c->indev, index);
+}
+
+void *lvpy_peek_indev_event_cb_user_data(lv_indev_t *indev, lv_event_cb_t cb, void *specific_user_data)
+{
+    if (!indev) return NULL;
+    lvpy_indev_peek_ctx ctx = {indev};
+    return lvpy_peek_event_dsc_list_cb_user_data(
+        lv_indev_get_event_count(indev), lvpy_indev_peek_get_dsc, &ctx, cb, specific_user_data);
+}
+
+static void py_lv_delete_cb(lv_event_t *e)
+{
+    PyGILState_STATE gstate = PyGILState_Ensure();
+    lv_obj_t *lv_obj = lv_event_get_target(e);
+    if (lv_obj) {
+        uint32_t count = lv_obj_get_event_count(lv_obj);
+        for (uint32_t i = 0; i < count; i++) {
+            lv_event_dsc_t *dsc = lv_obj_get_event_dsc(lv_obj, i);
+            if (dsc) {
+                lvpy_release_callback_user_data(lv_event_dsc_get_user_data(dsc));
+            }
+        }
+        py_lv_obj_t *self = (py_lv_obj_t *)lv_obj->user_data;
+        if (self) self->lv_obj = NULL;
+    }
+    PyGILState_Release(gstate);
+}
+
 void *mp_lv_callback(PyObject *py_callback, void *lv_callback, const char *callback_name,
     void **user_data_ptr, void *containing_struct,
     void *(*get_user_data)(void *), void (*set_user_data)(void *, void *))

lvpy_runtime.h

@@ -95,6 +95,13 @@ PyObject *mp_get_callbacks(PyObject *obj);
 void lvpy_dealloc_obj(py_lv_obj_t *self);
 PyObject *get_callback_dict_from_user_data(void *user_data);
 
+/* Per-registration callback dicts (add_event_cb with user_data=None) are Py_INCREF'd in mp_lv_callback. */
+int lvpy_is_per_registration_callback_dict(void *user_data);
+void lvpy_release_callback_user_data(void *user_data);
+void *lvpy_peek_obj_event_cb_user_data(lv_obj_t *obj, lv_event_cb_t cb, void *specific_user_data);
+void *lvpy_peek_display_event_cb_user_data(lv_display_t *disp, lv_event_cb_t cb, void *specific_user_data);
+void *lvpy_peek_indev_event_cb_user_data(lv_indev_t *indev, lv_event_cb_t cb, void *specific_user_data);
+
 void *mp_lv_callback(PyObject *py_callback, void *lv_callback, const char *callback_name,
     void **user_data_ptr, void *containing_struct,
     void *(*get_user_data)(void *), void (*set_user_data)(void *, void *));

test_lvgl_cpython.py

@@ -130,6 +130,40 @@ def on_button_clicked(event):
     print("OK: screen and button event callbacks")
 
 
+def test_multi_callbacks(lv):
+    """Multiple add_event_cb registrations on one object must not clobber each other."""
+    scr = lv.screen_active()
+    btn = lv.button(scr)
+    btn.set_size(80, 40)
+    fired = []
+
+    def mk(name):
+        def cb(event):
+            fired.append((name, event.get_code()))
+
+        return cb
+
+    for name, code in (
+        ("PRESSED", lv.EVENT.PRESSED),
+        ("RELEASED", lv.EVENT.RELEASED),
+        ("CLICKED", lv.EVENT.CLICKED),
+    ):
+        btn.add_event_cb(mk(name), code, None)
+
+    btn.send_event(lv.EVENT.PRESSED, None)
+    btn.send_event(lv.EVENT.CLICKED, None)
+    btn.send_event(lv.EVENT.RELEASED, None)
+
+    expected = [
+        ("PRESSED", lv.EVENT.PRESSED),
+        ("CLICKED", lv.EVENT.CLICKED),
+        ("RELEASED", lv.EVENT.RELEASED),
+    ]
+    if fired != expected:
+        _fail(f"multi-callback dispatch mismatch: got {fired!r}, expected {expected!r}")
+    print("OK: multiple filtered callbacks on one object")
+
+
 def test_event_callback(lv):
     test_callbacks(lv)
 
@@ -181,6 +215,7 @@ def main():
         test_blob_dereference(lv)
         test_widget(lv)
         test_callbacks(lv)
+        test_multi_callbacks(lv)
     finally:
         lv.deinit()