fixed! freeze X event queue instead of buffering

[dwm.git] / dwm.c

diff --git a/dwm.c b/dwm.c
index aa8a8f5..e66ace8 100644 (file)
--- a/dwm.c
+++ b/dwm.c
@@ -201,7 +201,6 @@ static void restack(Monitor *m);
 static void run(void);
 static void scan(void);
 static Bool sendevent(Client *c, Atom proto);
-static void send_keycode(KeyCode key, unsigned int state);
 static void sendmon(Client *c, Monitor *m);
 static void setclientstate(Client *c, long state);
 static void setfocus(Client *c);
@@ -243,12 +242,6 @@ static int xerrorstart(Display *dpy, XErrorEvent *ee);
 static void zoom(const Arg *arg);
 
 /* variables */
-typedef struct {
-       KeyCode keycode;
-       unsigned int state;
-} BufferedKey;
-static BufferedKey key_buffer[200];
-static int key_buffer_len = 0;
 static Bool key_buffering = False;
 static const char broken[] = "broken";
 static char stext[256];
@@ -1064,7 +1057,19 @@ void
 grabkeys(void) {
        updatenumlockmask();
        //XUngrabKey(dpy, AnyKey, AnyModifier, root);
-       XGrabKey(dpy, AnyKey, AnyModifier, root, True, GrabModeAsync, GrabModeAsync);
+       {
+               unsigned int i, j;
+               unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
+               KeyCode code;
+
+               XUngrabKey(dpy, AnyKey, AnyModifier, root);
+               for(i = 0; i < LENGTH(keys); i++)
+                       if((code = XKeysymToKeycode(dpy, keys[i].keysym)))
+                               for(j = 0; j < LENGTH(modifiers); j++)
+                                       XGrabKey(dpy, code, keys[i].mod | modifiers[j], root,
+                                                True, GrabModeAsync,
+                                                keys[i].func == kbspawn ? GrabModeSync : GrabModeAsync);
+       }
 }
 
 void
@@ -1085,58 +1090,18 @@ isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info) {
 #endif /* XINERAMA */
 
 void
-send_keycode(KeyCode key, unsigned int state) {
-       XKeyEvent event;
-       if(!selmon->sel) {
-               return;
-       }
-       event.display = dpy;
-       event.root = root;
-       event.window = selmon->sel->win;
-       event.subwindow = None;
-       event.same_screen = True;
-       event.x = 1;
-       event.y = 1;
-       event.x_root = 1;
-       event.y_root = 1;
-       event.time = CurrentTime;
-       event.state = state; // modifiers
-       event.keycode = key;
-       event.type = KeyPress;
-       XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
-       event.type = KeyRelease;
-       XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
-}
-
-void
 keypress(XEvent *e) {
        unsigned int i;
        KeySym keysym;
        XKeyEvent *ev;
-       Bool called = False;
 
        ev = &e->xkey;
        keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
-       for(i = 0; i < LENGTH(keys); i++)
+       for(i = 0; i < LENGTH(keys); i++) {
                if(keysym == keys[i].keysym
                && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
                && keys[i].func) {
                        keys[i].func(&(keys[i].arg));
-                       called = True;
-               }
-       if(!called) {
-               if(key_buffering) {
-                       if(key_buffer_len == LENGTH(key_buffer)) {
-                               // buffer full, bail
-                               key_buffer_len = 0;
-                               key_buffering = False;
-                       } else {
-                               key_buffer[key_buffer_len].keycode = (KeyCode)ev->keycode;
-                               key_buffer[key_buffer_len].state = (KeyCode)ev->state;
-                               key_buffer_len += 1;
-                       }
-               } else {
-                       send_keycode(ev->keycode, ev->state);
                }
        }
 }
@@ -1161,7 +1126,6 @@ manage(Window w, XWindowAttributes *wa) {
        Client *c, *t = NULL;
        Window trans = None;
        XWindowChanges wc;
-       int i;
 
        if(!(c = calloc(1, sizeof(Client))))
                die("fatal: could not malloc() %u bytes\n", sizeof(Client));
@@ -1224,19 +1188,15 @@ manage(Window w, XWindowAttributes *wa) {
        XMapWindow(dpy, c->win);
        focus(c);
        if(key_buffering) {
-               if(key_buffer_len > 0) {
-                       for(i = 0; i < key_buffer_len; ++i) {
-                               send_keycode(key_buffer[i].keycode, key_buffer[i].state);
-                       }
-               }
-               key_buffer_len = 0;
                key_buffering = False;
+               XAllowEvents(dpy, AsyncKeyboard, CurrentTime);
        }
 }
 
 void
 mappingnotify(XEvent *e) {
        XMappingEvent *ev = &e->xmapping;
+       // fprintf(stderr, "MapNotify\n");
 
        XRefreshKeyboardMapping(ev);
        if(ev->request == MappingKeyboard)
@@ -1248,11 +1208,10 @@ maprequest(XEvent *e) {
        static XWindowAttributes wa;
        XMapRequestEvent *ev = &e->xmaprequest;
 
+       // fprintf(stderr, "MapRequest\n");
        if(!XGetWindowAttributes(dpy, ev->window, &wa))
                return;
        if(wa.override_redirect) {
-               key_buffer_len = 0;
-               key_buffering = False;
                return;
        }
        if(!wintoclient(ev->window))
@@ -1550,9 +1509,14 @@ run(void) {
        XEvent ev;
        /* main event loop */
        XSync(dpy, False);
-       while(running && !XNextEvent(dpy, &ev))
-               if(handler[ev.type])
+       while(running && !XNextEvent(dpy, &ev)) {
+               if(handler[ev.type]) {
+                       // fprintf(stderr, "handling event type %i\n", ev.type);
                        handler[ev.type](&ev); /* call handler */
+               } else {
+                       // fprintf(stderr, "evt type %i\n", ev.type);
+               }
+       }
 }
 
 void
@@ -1781,7 +1745,6 @@ sigchld(int unused) {
 void
 kbspawn(const Arg *arg) {
        key_buffering = True;
-       key_buffer_len = 0;
        spawn(arg);
 }