Super gross fix for issue 1609

Author: oddbookworm

src_c/event.c

@@ -58,6 +58,10 @@
 static int _custom_event = _PGE_CUSTOM_EVENT_INIT;
 static int _pg_event_is_init = 0;
 
+static uint8_t _key_events_blocked = 0U;
+static const uint8_t KEYUP_BLOCKED = 0x1;
+static const uint8_t KEYDOWN_BLOCKED = 0x2;
+
 /* Length of our unicode string in bytes. We need 1 to 3 bytes to store
  * our unicode data, so we use a length of 4, to include the NULL byte
  * at the end as well */
@@ -290,6 +294,7 @@ _pg_put_event_unicode(SDL_Event *event, const char *uni)
 #if SDL_VERSION_ATLEAST(3, 0, 0)
             scanunicode[i].key = event->key.scancode;
 #else
+            printf("Populating %d\n", i);
             scanunicode[i].key = event->key.keysym.scancode;
 #endif
             _pg_strip_utf8(uni, scanunicode[i].unicode);
@@ -302,6 +307,7 @@ _pg_put_event_unicode(SDL_Event *event, const char *uni)
 static PyObject *
 _pg_get_event_unicode(SDL_Event *event)
 {
+    printf("Event type: %d\n", event->type);
     /* We only deal with one byte here, but still declare an array to silence
      * compiler warnings. The other 3 bytes are unused */
     char c[4];
@@ -315,6 +321,7 @@ _pg_get_event_unicode(SDL_Event *event)
             if (event->type == SDL_KEYUP) {
                 /* mark the position as free real estate for other
                  * events to occupy. */
+                printf("clearing %d\n", i);
                 scanunicode[i].key = 0;
             }
             return PyUnicode_FromString(scanunicode[i].unicode);
@@ -325,6 +332,7 @@ _pg_get_event_unicode(SDL_Event *event)
     *c = _pg_unicode_from_event(event);
     if (_pg_put_event_unicode(event, c))
         return _pg_get_event_unicode(event);
+    printf("empty string\n");
     return PyUnicode_FromString("");
 }
 
@@ -1089,6 +1097,7 @@ dict_from_event(SDL_Event *event)
         case SDL_KEYDOWN:
         case SDL_KEYUP:
             PG_LOCK_EVFILTER_MUTEX
+            printf("Event Type (in switch): %d\n", event->type);
             /* this accesses state also accessed the event filter, so lock */
             _pg_insobj(dict, "unicode", _pg_get_event_unicode(event));
             PG_UNLOCK_EVFILTER_MUTEX
@@ -2330,6 +2339,7 @@ pg_event_set_allowed(PyObject *self, PyObject *obj)
     VIDEO_INIT_CHECK();
 
     if (obj == Py_None) {
+        _key_events_blocked = 0U;
         int i;
         for (i = SDL_FIRSTEVENT; i < SDL_LASTEVENT; i++) {
             PG_SetEventEnabled(i, SDL_TRUE);
@@ -2347,6 +2357,26 @@ pg_event_set_allowed(PyObject *self, PyObject *obj)
                 return NULL;
             }
             PG_SetEventEnabled(_pg_pgevent_proxify(type), SDL_TRUE);
+            if (type == SDL_KEYDOWN) {
+                _key_events_blocked &= ~KEYDOWN_BLOCKED;
+                printf("keydown allowed\n");
+
+                if (_key_events_blocked &= KEYUP_BLOCKED) {
+                    PG_SetEventEnabled(_pg_pgevent_proxify(SDL_KEYUP),
+                                       SDL_TRUE);
+                    printf("Forcing KEYUP allowed\n");
+                }
+            }
+            else if (type == SDL_KEYUP) {
+                _key_events_blocked &= ~KEYUP_BLOCKED;
+                printf("keyup allowed\n");
+
+                if (_key_events_blocked &= KEYDOWN_BLOCKED) {
+                    PG_SetEventEnabled(_pg_pgevent_proxify(SDL_KEYDOWN),
+                                       SDL_TRUE);
+                    printf("Forcing KEYDOWN allowed\n");
+                }
+            }
         }
         Py_DECREF(seq);
     }
@@ -2362,6 +2392,7 @@ pg_event_set_blocked(PyObject *self, PyObject *obj)
     VIDEO_INIT_CHECK();
 
     if (obj == Py_None) {
+        _key_events_blocked = (KEYDOWN_BLOCKED | KEYUP_BLOCKED);
         int i;
         /* Start at PGPOST_EVENTBEGIN */
         for (i = PGPOST_EVENTBEGIN; i < SDL_LASTEVENT; i++) {
@@ -2380,6 +2411,26 @@ pg_event_set_blocked(PyObject *self, PyObject *obj)
                 return NULL;
             }
             PG_SetEventEnabled(_pg_pgevent_proxify(type), SDL_FALSE);
+            if (type == SDL_KEYDOWN) {
+                _key_events_blocked |= KEYDOWN_BLOCKED;
+                printf("keydown blocked\n");
+
+                if (_key_events_blocked & KEYUP_BLOCKED) {
+                    PG_SetEventEnabled(_pg_pgevent_proxify(SDL_KEYUP),
+                                       SDL_FALSE);
+                    printf("Both are now blocked\n");
+                }
+            }
+            else if (type == SDL_KEYUP) {
+                _key_events_blocked |= KEYUP_BLOCKED;
+                printf("keyup blocked\n");
+
+                if (_key_events_blocked & KEYDOWN_BLOCKED) {
+                    PG_SetEventEnabled(_pg_pgevent_proxify(SDL_KEYDOWN),
+                                       SDL_FALSE);
+                    printf("Both are now blocked\n");
+                }
+            }
         }
         Py_DECREF(seq);
     }
@@ -2389,6 +2440,16 @@ pg_event_set_blocked(PyObject *self, PyObject *obj)
 #endif
     /* Never block PGE_KEYREPEAT too, its needed for pygame internal use */
     PG_SetEventEnabled(PGE_KEYREPEAT, SDL_TRUE);
+    /* If KEYUP is not blocked, don't block KEYDOWN */
+    if (!(_key_events_blocked & KEYUP_BLOCKED)) {
+        PG_SetEventEnabled(_pg_pgevent_proxify(SDL_KEYDOWN), SDL_TRUE);
+        printf("skipping block on keydown\n");
+    }
+    /* If KEYDOWN is not blocked, don't block KEYUP */
+    if (!(_key_events_blocked & KEYDOWN_BLOCKED)) {
+        PG_SetEventEnabled(_pg_pgevent_proxify(SDL_KEYUP), SDL_TRUE);
+        printf("skipping block on keyup\n");
+    }
     Py_RETURN_NONE;
 }