diff --git a/src/icewmbg.cc b/src/icewmbg.cc
index 8712b0120..09be4ec86 100644
--- a/src/icewmbg.cc
+++ b/src/icewmbg.cc
@@ -43,7 +43,7 @@ class Cache {
     bool verbose;
 };
 
-class Background: public YXApplication, private YTimerListener {
+class Background: public YXApplication {
 public:
     Background(int *argc, char ***argv, bool verbose = false);
     ~Background();
diff --git a/src/movesize.cc b/src/movesize.cc
index 0a07914c1..4dc14bd47 100644
--- a/src/movesize.cc
+++ b/src/movesize.cc
@@ -698,85 +698,81 @@ bool YFrameWindow::handleKey(const XKeyEvent &key) {
                 break;
             }
         } else if (xapp->AltMask != 0) {
-            KeySym k = keyCodeToKeySym(key.keycode);
-            unsigned int m = KEY_MODMASK(key.state);
-            unsigned int vm = VMod(m);
-
             if (!isRollup() && !isIconic() &&
                 key.window != handle())
                 return true;
 
-            if (gKeyWinClose.eq(k, vm)) {
+            if (gKeyWinClose == key) {
                 actionPerformed(actionClose);
-            } else if (gKeyWinPrev.eq(k, vm)) {
+            } else if (gKeyWinPrev == key) {
                 wmPrevWindow();
-            } else if (gKeyWinMaximizeVert.eq(k, vm)) {
+            } else if (gKeyWinMaximizeVert == key) {
                 actionPerformed(actionMaximizeVert);
-            } else if (gKeyWinMaximizeHoriz.eq(k, vm)) {
+            } else if (gKeyWinMaximizeHoriz == key) {
                 actionPerformed(actionMaximizeHoriz);
-            } else if (gKeyWinRaise.eq(k, vm)) {
+            } else if (gKeyWinRaise == key) {
                 actionPerformed(actionRaise);
-            } else if (gKeyWinOccupyAll.eq(k, vm)) {
+            } else if (gKeyWinOccupyAll == key) {
                 actionPerformed(actionOccupyAllOrCurrent);
-            } else if (gKeyWinLower.eq(k, vm)) {
+            } else if (gKeyWinLower == key) {
                 actionPerformed(actionLower);
-            } else if (gKeyWinRestore.eq(k, vm)) {
+            } else if (gKeyWinRestore == key) {
                 actionPerformed(actionRestore);
-            } else if (gKeyWinNext.eq(k, vm)) {
+            } else if (gKeyWinNext == key) {
                 wmNextWindow();
-            } else if (gKeyWinMove.eq(k, vm)) {
+            } else if (gKeyWinMove == key) {
                 actionPerformed(actionMove);
-            } else if (gKeyWinSize.eq(k, vm)) {
+            } else if (gKeyWinSize == key) {
                 actionPerformed(actionSize);
-            } else if (gKeyWinMinimize.eq(k, vm)) {
+            } else if (gKeyWinMinimize == key) {
                 actionPerformed(actionMinimize);
-            } else if (gKeyWinMaximize.eq(k, vm)) {
+            } else if (gKeyWinMaximize == key) {
                 actionPerformed(actionMaximize);
-            } else if (gKeyWinHide.eq(k, vm)) {
+            } else if (gKeyWinHide == key) {
                 actionPerformed(actionHide);
-            } else if (gKeyWinRollup.eq(k, vm)) {
+            } else if (gKeyWinRollup == key) {
                 actionPerformed(actionRollup);
-            } else if (gKeyWinFullscreen.eq(k, vm)) {
+            } else if (gKeyWinFullscreen == key) {
                 actionPerformed(actionFullscreen);
-            } else if (gKeyWinMenu.eq(k, vm)) {
+            } else if (gKeyWinMenu == key) {
                 popupSystemMenu(this);
-            } else if (gKeyWinArrangeN.eq(k, vm)) {
+            } else if (gKeyWinArrangeN == key) {
                 if (canMove()) wmArrange(waTop, waCenter);
-            } else if (gKeyWinArrangeNE.eq(k, vm)) {
+            } else if (gKeyWinArrangeNE == key) {
                 if (canMove()) wmArrange(waTop, waRight);
-            } else if (gKeyWinArrangeE.eq(k, vm)) {
+            } else if (gKeyWinArrangeE == key) {
                 if (canMove()) wmArrange(waCenter, waRight);
-            } else if (gKeyWinArrangeSE.eq(k, vm)) {
+            } else if (gKeyWinArrangeSE == key) {
                 if (canMove()) wmArrange(waBottom, waRight);
-            } else if (gKeyWinArrangeS.eq(k, vm)) {
+            } else if (gKeyWinArrangeS == key) {
                 if (canMove()) wmArrange(waBottom, waCenter);
-            } else if (gKeyWinArrangeSW.eq(k, vm)) {
+            } else if (gKeyWinArrangeSW == key) {
                 if (canMove()) wmArrange(waBottom, waLeft);
-            } else if (gKeyWinArrangeW.eq(k, vm)) {
+            } else if (gKeyWinArrangeW == key) {
                 if (canMove()) wmArrange(waCenter, waLeft);
-            } else if (gKeyWinArrangeNW.eq(k, vm)) {
+            } else if (gKeyWinArrangeNW == key) {
                 if (canMove()) wmArrange(waTop, waLeft);
-            } else if (gKeyWinArrangeC.eq(k, vm)) {
+            } else if (gKeyWinArrangeC == key) {
                 if (canMove()) wmArrange(waCenter, waCenter);
-            } else if (gKeyWinTileLeft.eq(k, vm)) {
+            } else if (gKeyWinTileLeft == key) {
                 wmTile(actionTileLeft);
-            } else if (gKeyWinTileRight.eq(k, vm)) {
+            } else if (gKeyWinTileRight == key) {
                 wmTile(actionTileRight);
-            } else if (gKeyWinTileTop.eq(k, vm)) {
+            } else if (gKeyWinTileTop == key) {
                 wmTile(actionTileTop);
-            } else if (gKeyWinTileBottom.eq(k, vm)) {
+            } else if (gKeyWinTileBottom == key) {
                 wmTile(actionTileBottom);
-            } else if (gKeyWinTileTopLeft.eq(k, vm)) {
+            } else if (gKeyWinTileTopLeft == key) {
                 wmTile(actionTileTopLeft);
-            } else if (gKeyWinTileTopRight.eq(k, vm)) {
+            } else if (gKeyWinTileTopRight == key) {
                 wmTile(actionTileTopRight);
-            } else if (gKeyWinTileBottomLeft.eq(k, vm)) {
+            } else if (gKeyWinTileBottomLeft == key) {
                 wmTile(actionTileBottomLeft);
-            } else if (gKeyWinTileBottomRight.eq(k, vm)) {
+            } else if (gKeyWinTileBottomRight == key) {
                 wmTile(actionTileBottomRight);
-            } else if (gKeyWinTileCenter.eq(k, vm)) {
+            } else if (gKeyWinTileCenter == key) {
                 wmTile(actionTileCenter);
-            } else if (gKeyWinSmartPlace.eq(k, vm)) {
+            } else if (gKeyWinSmartPlace == key) {
                 if (canMove()) {
                     int newX = x();
                     int newY = y();
@@ -785,6 +781,9 @@ bool YFrameWindow::handleKey(const XKeyEvent &key) {
                     }
                 }
             } else if (isIconic() || isRollup()) {
+                KeySym k = keyCodeToKeySym(key.keycode);
+                unsigned m = KEY_MODMASK(key.state);
+
                 if (k == XK_Return || k == XK_KP_Enter) {
                     if (isMinimized())
                         wmMinimize();
diff --git a/src/wmapp.cc b/src/wmapp.cc
index 7f1543091..b3a39828a 100644
--- a/src/wmapp.cc
+++ b/src/wmapp.cc
@@ -717,6 +717,9 @@ bool YWMApp::handleTimer(YTimer *timer) {
         themeOnlyPath.clear();
         pathsTimer = null;
     }
+    else {
+        return super::handleTimer(timer);
+    }
 
     return false;
 }
@@ -1246,6 +1249,19 @@ static void showExtensions() {
             printf("%-9s unsupported\n", s);
         }
     }
+    int ka = XkbMajorVersion, ki = XkbMinorVersion;
+    if (XkbLibraryVersion(&ka, &ki)) {
+        ka = XkbMajorVersion, ki = XkbMinorVersion;
+        int ev = 0, er = 0;
+        if (XkbQueryExtension(xapp->display(), NULL, &ev, &er, &ka, &ki)) {
+            printf("%-9s %d.%-2d (%2d, %3d)\n", "xkeyboard", ka, ki, ev, er);
+        } else {
+            printf("%-9s unsupported\n", "xkeyboard");
+        }
+    } else {
+        printf("incompatible XKEYBOARD library %d.%d vs. %d.%d!\n",
+                ka, ki, XkbMajorVersion, XkbMinorVersion);
+    }
 }
 
 static int restartWM(const char* displayName, const char* overrideTheme) {
diff --git a/src/wmapp.h b/src/wmapp.h
index f4680e158..c5cb575c2 100644
--- a/src/wmapp.h
+++ b/src/wmapp.h
@@ -37,8 +37,7 @@ class YWMApp:
     public YSMApplication,
     public YActionListener,
     public YMsgBoxListener,
-    public YSMListener,
-    public YTimerListener
+    public YSMListener
 {
     typedef YSMApplication super;
 
diff --git a/src/wmcontainer.cc b/src/wmcontainer.cc
index 763408b18..f1e9083fd 100644
--- a/src/wmcontainer.cc
+++ b/src/wmcontainer.cc
@@ -51,12 +51,9 @@ void YClientContainer::handleButton(const XButtonEvent &button) {
     }
 
     if (clientMouseActions) {
-        unsigned int k = button.button + XK_Pointer_Button1 - 1;
-        unsigned int m = KEY_MODMASK(button.state);
-        unsigned int vm = VMod(m);
-
-        if (gMouseWinSize.eq(k, vm)) {
+        if (gMouseWinSize == button) {
             XAllowEvents(xapp->display(), AsyncPointer, CurrentTime);
+            NOTE(MouseWinSize);
 
             int px = button.x + x();
             int py = button.y + y();
@@ -84,7 +81,7 @@ void YClientContainer::handleButton(const XButtonEvent &button) {
             }
             return ;
         }
-        else if (gMouseWinMove.eq(k, vm)) {
+        else if (gMouseWinMove == button) {
             XAllowEvents(xapp->display(), AsyncPointer, CurrentTime);
 
             if (getFrame()->canMove()) {
@@ -96,14 +93,14 @@ void YClientContainer::handleButton(const XButtonEvent &button) {
             }
             return ;
         }
-        else if (gMouseWinRaise.eq(k, vm)
+        else if (gMouseWinRaise == button
             && (gMouseWinRaise != gMouseWinLower || getFrame()->canRaise()))
         {
             XAllowEvents(xapp->display(), AsyncPointer, CurrentTime);
             getFrame()->wmRaise();
             return ;
         }
-        else if (gMouseWinLower.eq(k, vm)) {
+        else if (gMouseWinLower == button) {
             XAllowEvents(xapp->display(), AsyncPointer, CurrentTime);
             getFrame()->wmLower();
             return ;
@@ -170,15 +167,12 @@ void YClientContainer::regrabMouse() {
 
 void YClientContainer::grabActions() {
     if (clientMouseActions && fHaveActionGrab == false) {
-        WMKey grab[] = { gMouseWinMove, gMouseWinSize,
-                         gMouseWinRaise, gMouseWinLower };
-        const int count = int ACOUNT(grab) - (gMouseWinRaise == gMouseWinLower);
-        for (int i = 0; i < count; ++i) {
-            int button = int(grab[i].key) - XK_Pointer_Button1 + Button1;
-            if (inrange(button, Button1, Button3)) {
-                grabVButton(button, grab[i].mod);
-            }
-        }
+        const Window win = handle();
+        gMouseWinMove.grab(win);
+        gMouseWinSize.grab(win);
+        gMouseWinRaise.grab(win);
+        if (gMouseWinLower != gMouseWinRaise)
+            gMouseWinLower.grab(win);
         fHaveActionGrab = true;
     }
 }
diff --git a/src/wmframe.cc b/src/wmframe.cc
index d2ce2f4cd..c77c03b75 100644
--- a/src/wmframe.cc
+++ b/src/wmframe.cc
@@ -617,44 +617,45 @@ void YFrameWindow::createPointerWindows() {
 }
 
 void YFrameWindow::grabKeys() {
-    XUngrabKey(xapp->display(), AnyKey, AnyModifier, handle());
-
-    grab(gKeyWinRaise);
-    grab(gKeyWinOccupyAll);
-    grab(gKeyWinLower);
-    grab(gKeyWinClose);
-    grab(gKeyWinRestore);
-    grab(gKeyWinNext);
-    grab(gKeyWinPrev);
-    grab(gKeyWinMove);
-    grab(gKeyWinSize);
-    grab(gKeyWinMinimize);
-    grab(gKeyWinMaximize);
-    grab(gKeyWinMaximizeVert);
-    grab(gKeyWinMaximizeHoriz);
-    grab(gKeyWinHide);
-    grab(gKeyWinRollup);
-    grab(gKeyWinFullscreen);
-    grab(gKeyWinMenu);
-    grab(gKeyWinArrangeN);
-    grab(gKeyWinArrangeNE);
-    grab(gKeyWinArrangeE);
-    grab(gKeyWinArrangeSE);
-    grab(gKeyWinArrangeS);
-    grab(gKeyWinArrangeSW);
-    grab(gKeyWinArrangeW);
-    grab(gKeyWinArrangeNW);
-    grab(gKeyWinArrangeC);
-    grab(gKeyWinTileLeft);
-    grab(gKeyWinTileRight);
-    grab(gKeyWinTileTop);
-    grab(gKeyWinTileBottom);
-    grab(gKeyWinTileTopLeft);
-    grab(gKeyWinTileTopRight);
-    grab(gKeyWinTileBottomLeft);
-    grab(gKeyWinTileBottomRight);
-    grab(gKeyWinTileCenter);
-    grab(gKeyWinSmartPlace);
+    const Window win = handle();
+    XUngrabKey(xapp->display(), AnyKey, AnyModifier, win);
+
+    gKeyWinRaise.grab(win);
+    gKeyWinOccupyAll.grab(win);
+    gKeyWinLower.grab(win);
+    gKeyWinClose.grab(win);
+    gKeyWinRestore.grab(win);
+    gKeyWinNext.grab(win);
+    gKeyWinPrev.grab(win);
+    gKeyWinMove.grab(win);
+    gKeyWinSize.grab(win);
+    gKeyWinMinimize.grab(win);
+    gKeyWinMaximize.grab(win);
+    gKeyWinMaximizeVert.grab(win);
+    gKeyWinMaximizeHoriz.grab(win);
+    gKeyWinHide.grab(win);
+    gKeyWinRollup.grab(win);
+    gKeyWinFullscreen.grab(win);
+    gKeyWinMenu.grab(win);
+    gKeyWinArrangeN.grab(win);
+    gKeyWinArrangeNE.grab(win);
+    gKeyWinArrangeE.grab(win);
+    gKeyWinArrangeSE.grab(win);
+    gKeyWinArrangeS.grab(win);
+    gKeyWinArrangeSW.grab(win);
+    gKeyWinArrangeW.grab(win);
+    gKeyWinArrangeNW.grab(win);
+    gKeyWinArrangeC.grab(win);
+    gKeyWinTileLeft.grab(win);
+    gKeyWinTileRight.grab(win);
+    gKeyWinTileTop.grab(win);
+    gKeyWinTileBottom.grab(win);
+    gKeyWinTileTopLeft.grab(win);
+    gKeyWinTileTopRight.grab(win);
+    gKeyWinTileBottomLeft.grab(win);
+    gKeyWinTileBottomRight.grab(win);
+    gKeyWinTileCenter.grab(win);
+    gKeyWinSmartPlace.grab(win);
 
     container()->regrabMouse();
 }
diff --git a/src/wmkey.cc b/src/wmkey.cc
index be4a343d1..8a3600210 100644
--- a/src/wmkey.cc
+++ b/src/wmkey.cc
@@ -3,11 +3,15 @@
 #include "yxapp.h"
 #include "yprefs.h"
 
+#define IS_XF86KEY(key) (0x1008FE01U <= key && key <= 0x1008FFFFU)
+#define IS_POINTER(key) (0x0000FEE0U <= key && key <= 0x0000FEFFU)
+
 bool WMKey::set(const char* arg) {
     bool change = false;
     if (isEmpty(arg)) {
         if (nonempty(name)) {
-            key = mod = xmod = kc = 0;
+            key = mod = 0;
+            xm[0] = xm[1] = kc[0] = kc[1] = 0;
             name = "";
             change = true;
             initial = true;
@@ -24,7 +28,7 @@ bool WMKey::set(const char* arg) {
             change = true;
             key = ks;
             mod = mo;
-            xmod = kc = 0;
+            xm[0] = xm[1] = kc[0] = kc[1] = 0;
         }
     }
     return change;
@@ -32,7 +36,8 @@ bool WMKey::set(const char* arg) {
 
 bool WMKey::parse() {
     if (nonempty(name)) {
-        key = mod = xmod = kc = 0;
+        key = mod = 0;
+        xm[0] = xm[1] = kc[0] = kc[1] = 0;
         return YConfig::parseKey(name, &key, &mod);
     } else {
         return false;
@@ -40,64 +45,112 @@ bool WMKey::parse() {
 }
 
 void WMKey::grab(int handle) {
-    if (mod && xmod == 0) {
-        unsigned short xm = 0;
+    if (mod && xm[0] == 0) {
+        unsigned short km = 0;
         bool ok = true;
         if (mod & kfShift)
-            xm |= ShiftMask;
+            km |= ShiftMask;
         if (mod & kfCtrl)
-            xm |= ControlMask;
+            km |= ControlMask;
         if (mod & kfAlt) {
             if (xapp->AltMask)
-                xm |= xapp->AltMask;
+                km |= xapp->AltMask;
             else
                 ok = false;
         }
         if (mod & kfMeta) {
             if (xapp->MetaMask)
-                xm |= xapp->MetaMask;
+                km |= xapp->MetaMask;
             else
                 ok = false;
         }
         if (mod & kfSuper) {
             if (xapp->SuperMask)
-                xm |= xapp->SuperMask;
+                km |= xapp->SuperMask;
             else
                 ok = false;
         }
         if (mod & kfHyper) {
             if (xapp->HyperMask)
-                xm |= xapp->HyperMask;
+                km |= xapp->HyperMask;
             else
                 ok = false;
         }
         if (mod & kfAltGr) {
             if (xapp->ModeSwitchMask)
-                xm |= xapp->ModeSwitchMask;
+                km |= xapp->ModeSwitchMask;
             else
                 ok = false;
         }
-        if (xm && ok) {
-            xmod = xm;
+        if (km && ok) {
+            xm[0] = xm[1] = km;
         } else {
             return;
         }
     }
-    if (kc == 0 && key) {
-        xapp->unshift(&key, &xmod);
-        kc = XKeysymToKeycode(xapp->display(), KeySym(key));
+    if (IS_POINTER(key)) {
+        int button = key - XK_Pointer_Button1 + Button1;
+        if (inrange(button, Button1, Button3)) {
+            if (hasbits(mod, kfAlt | kfCtrl) &&
+                modSuperIsCtrlAlt && xapp->WinMask) {
+                xm[1] = xapp->WinMask | (xm[0] & ~(ControlMask | xapp->AltMask));
+            }
+            unsigned short mods[8];
+            int count = 0;
+            for (int i = 0; i < 2; ++i) {
+                if (i == 0 || (xm[i] != xm[0] && xm[i])) {
+                    mods[count++] = xm[i];
+                    mods[count++] = xm[i] | LockMask;
+                    if (xapp->NumLockMask) {
+                        mods[count++] = xm[i] | xapp->NumLockMask;
+                        mods[count++] = xm[i] | xapp->NumLockMask | LockMask;
+                    }
+                }
+            }
+            for (int i = 0; i < count; ++i) {
+                XGrabButton(xapp->display(), unsigned(button), mods[i],
+                            handle, True, ButtonPressMask,
+                            GrabModeAsync, GrabModeAsync, None, None);
+            }
+        }
+        return;
     }
-    if (kc) {
+    if (kc[0] == 0 && key) {
+        YKeycodeMap map(xapp->getKeycodeMap());
+        if (map) {
+            const bool sh = ((' ' < key && key < 'a')
+                          || ('z' < key && key <= 0xFF)
+                          || IS_XF86KEY(key));
+            int n = 0;
+            for (int i = map.min; i <= map.max; i++) {
+                if (map.map[(i - map.min) * map.per] == key) {
+                    kc[n] = (unsigned char) (i & 0xFF);
+                    if (++n >= 2)
+                        break;
+                }
+                if (sh && map.map[(i - map.min) * map.per + 1] == key) {
+                    xm[n] |= ShiftMask;
+                    kc[n] = (unsigned char) (i & 0xFF);
+                    if (++n >= 2)
+                        break;
+                }
+            }
+        } else {
+            xapp->unshift(&key, &xm[0]);
+            kc[0] = XKeysymToKeycode(xapp->display(), KeySym(key));
+        }
+    }
+    for (int k = 0; k < 2 && kc[k]; ++k) {
         unsigned short mods[8];
         int count = 0;
-        mods[count++] = xmod;
-        mods[count++] = xmod | LockMask;
+        mods[count++] = xm[k];
+        mods[count++] = xm[k] | LockMask;
         if (xapp->NumLockMask) {
-            mods[count++] = xmod | xapp->NumLockMask;
-            mods[count++] = xmod | LockMask | xapp->NumLockMask;
+            mods[count++] = xm[k] | xapp->NumLockMask;
+            mods[count++] = xm[k] | LockMask | xapp->NumLockMask;
         }
         if (hasbits(mod, kfAlt | kfCtrl) && modSuperIsCtrlAlt && xapp->WinMask) {
-            unsigned short wmod = xmod;
+            unsigned short wmod = xm[k];
             wmod &= ~(ControlMask | xapp->AltMask);
             wmod |= xapp->WinMask;
             mods[count++] = wmod;
@@ -108,9 +161,19 @@ void WMKey::grab(int handle) {
             }
         }
         for (int i = 0; i < count; ++i) {
-            XGrabKey(xapp->display(), kc, mods[i], handle,
+            XGrabKey(xapp->display(), kc[k], mods[i], handle,
                      False, GrabModeAsync, GrabModeAsync);
         }
     }
 }
 
+bool WMKey::operator==(const XKeyEvent& x) const {
+    return (x.keycode == kc[0] && KEY_MODMASK(x.state) == xm[0])
+        || (x.keycode == kc[1] && KEY_MODMASK(x.state) == xm[1]);
+}
+
+bool WMKey::operator==(const XButtonEvent& b) const {
+    return (key == b.button - Button1 + XK_Pointer_Button1
+         && mod == desktop->VMod(KEY_MODMASK(b.state)));
+}
+
diff --git a/src/wmkey.h b/src/wmkey.h
index f58855262..6f4731b84 100644
--- a/src/wmkey.h
+++ b/src/wmkey.h
@@ -1,22 +1,31 @@
 #ifndef WMKEY_H
 #define WMKEY_H
 
+#include <X11/Xlib.h>
+
 struct WMKey {
-    unsigned key;
-    unsigned short mod, xmod;
     const char* name;
-    unsigned char kc;
+    unsigned key;
+    unsigned short mod, xm[2];
+    unsigned char kc[2];
     bool initial;
 
-    WMKey() : key(0), mod(0), xmod(0), name(""), kc(0), initial(true) { }
-    WMKey(char* s) : key(0), mod(0), xmod(0), name(s), kc(0), initial(false) {
-        parse(); }
+    WMKey() : name(""), key(0), mod(0), initial(true) {
+        xm[0] = xm[1] = kc[0] = kc[1] = 0;
+    }
+    WMKey(char* s) : name(s), key(0), mod(0), initial(false) {
+        xm[0] = xm[1] = kc[0] = kc[1] = 0;
+        parse();
+    }
     WMKey(unsigned k, unsigned short m, const char* s) :
-        key(k), mod(m), xmod(0), name(s), kc(0), initial(true) { }
+        name(s), key(k), mod(m), initial(true) {
+        xm[0] = xm[1] = kc[0] = kc[1] = 0;
+    }
 
-    bool eq(unsigned k, unsigned short m) const { return key == k && mod == m; }
-    bool operator==(const WMKey& o) const { return eq(o.key, o.mod); }
-    bool operator!=(const WMKey& o) const { return !eq(o.key, o.mod); }
+    bool operator==(const WMKey& o) const { return key == o.key && mod == o.mod; }
+    bool operator!=(const WMKey& o) const { return key != o.key || mod != o.mod; }
+    bool operator==(const XKeyEvent& x) const;
+    bool operator==(const XButtonEvent& b) const;
     bool parse();
     bool set(const char* arg);
     void grab(int handle);
diff --git a/src/wmmgr.cc b/src/wmmgr.cc
index 9e1748f81..3b3f33cec 100644
--- a/src/wmmgr.cc
+++ b/src/wmmgr.cc
@@ -172,82 +172,82 @@ void YWindowManager::ungrabServer() {
 }
 
 void YWindowManager::grabKeys() {
-    XUngrabKey(xapp->display(), AnyKey, AnyModifier, handle());
+    const Window win = handle();
+    XUngrabKey(xapp->display(), AnyKey, AnyModifier, win);
 
     ///if (taskBar && taskBar->addressBar())
-        grab(gKeySysAddressBar);
+        gKeySysAddressBar.grab(win);
     if (quickSwitch) {
-        grab(gKeySysSwitchNext);
-        grab(gKeySysSwitchLast);
-        grab(gKeySysSwitchClass);
-    }
-    grab(gKeySysWinNext);
-    grab(gKeySysWinPrev);
-    grab(gKeySysDialog);
-
-    grab(gKeySysWorkspacePrev);
-    grab(gKeySysWorkspaceNext);
-    grab(gKeySysWorkspaceLast);
-
-    grab(gKeySysWorkspacePrevTakeWin);
-    grab(gKeySysWorkspaceNextTakeWin);
-    grab(gKeySysWorkspaceLastTakeWin);
-
-    grab(gKeySysWinMenu);
-    grab(gKeySysMenu);
-    grab(gKeySysWindowList);
-    grab(gKeySysWinListMenu);
-
-    grab(gKeySysWorkspace1);
-    grab(gKeySysWorkspace2);
-    grab(gKeySysWorkspace3);
-    grab(gKeySysWorkspace4);
-    grab(gKeySysWorkspace5);
-    grab(gKeySysWorkspace6);
-    grab(gKeySysWorkspace7);
-    grab(gKeySysWorkspace8);
-    grab(gKeySysWorkspace9);
-    grab(gKeySysWorkspace10);
-    grab(gKeySysWorkspace11);
-    grab(gKeySysWorkspace12);
-
-    grab(gKeySysWorkspace1TakeWin);
-    grab(gKeySysWorkspace2TakeWin);
-    grab(gKeySysWorkspace3TakeWin);
-    grab(gKeySysWorkspace4TakeWin);
-    grab(gKeySysWorkspace5TakeWin);
-    grab(gKeySysWorkspace6TakeWin);
-    grab(gKeySysWorkspace7TakeWin);
-    grab(gKeySysWorkspace8TakeWin);
-    grab(gKeySysWorkspace9TakeWin);
-    grab(gKeySysWorkspace10TakeWin);
-    grab(gKeySysWorkspace11TakeWin);
-    grab(gKeySysWorkspace12TakeWin);
-
-    grab(gKeySysTileVertical);
-    grab(gKeySysTileHorizontal);
-    grab(gKeySysCascade);
-    grab(gKeySysArrange);
-    grab(gKeySysUndoArrange);
+        gKeySysSwitchNext.grab(win);
+        gKeySysSwitchLast.grab(win);
+        gKeySysSwitchClass.grab(win);
+    }
+    gKeySysWinNext.grab(win);
+    gKeySysWinPrev.grab(win);
+    gKeySysDialog.grab(win);
+
+    gKeySysWorkspacePrev.grab(win);
+    gKeySysWorkspaceNext.grab(win);
+    gKeySysWorkspaceLast.grab(win);
+
+    gKeySysWorkspacePrevTakeWin.grab(win);
+    gKeySysWorkspaceNextTakeWin.grab(win);
+    gKeySysWorkspaceLastTakeWin.grab(win);
+
+    gKeySysWinMenu.grab(win);
+    gKeySysMenu.grab(win);
+    gKeySysWindowList.grab(win);
+    gKeySysWinListMenu.grab(win);
+
+    gKeySysWorkspace1.grab(win);
+    gKeySysWorkspace2.grab(win);
+    gKeySysWorkspace3.grab(win);
+    gKeySysWorkspace4.grab(win);
+    gKeySysWorkspace5.grab(win);
+    gKeySysWorkspace6.grab(win);
+    gKeySysWorkspace7.grab(win);
+    gKeySysWorkspace8.grab(win);
+    gKeySysWorkspace9.grab(win);
+    gKeySysWorkspace10.grab(win);
+    gKeySysWorkspace11.grab(win);
+    gKeySysWorkspace12.grab(win);
+
+    gKeySysWorkspace1TakeWin.grab(win);
+    gKeySysWorkspace2TakeWin.grab(win);
+    gKeySysWorkspace3TakeWin.grab(win);
+    gKeySysWorkspace4TakeWin.grab(win);
+    gKeySysWorkspace5TakeWin.grab(win);
+    gKeySysWorkspace6TakeWin.grab(win);
+    gKeySysWorkspace7TakeWin.grab(win);
+    gKeySysWorkspace8TakeWin.grab(win);
+    gKeySysWorkspace9TakeWin.grab(win);
+    gKeySysWorkspace10TakeWin.grab(win);
+    gKeySysWorkspace11TakeWin.grab(win);
+    gKeySysWorkspace12TakeWin.grab(win);
+
+    gKeySysTileVertical.grab(win);
+    gKeySysTileHorizontal.grab(win);
+    gKeySysCascade.grab(win);
+    gKeySysArrange.grab(win);
+    gKeySysUndoArrange.grab(win);
 
     if (minimizeToDesktop)
-    grab(gKeySysArrangeIcons);
-    grab(gKeySysMinimizeAll);
-    grab(gKeySysHideAll);
+        gKeySysArrangeIcons.grab(win);
+    gKeySysMinimizeAll.grab(win);
+    gKeySysHideAll.grab(win);
 
-    grab(gKeySysShowDesktop);
+    gKeySysShowDesktop.grab(win);
     if (taskBar || showTaskBar) {
-        grab(gKeySysCollapseTaskBar);
-        grab(gKeyTaskBarSwitchNext);
-        grab(gKeyTaskBarSwitchPrev);
-        grab(gKeyTaskBarMoveNext);
-        grab(gKeyTaskBarMovePrev);
+        gKeySysCollapseTaskBar.grab(win);
+        gKeyTaskBarSwitchNext.grab(win);
+        gKeyTaskBarSwitchPrev.grab(win);
+        gKeyTaskBarMoveNext.grab(win);
+        gKeyTaskBarMovePrev.grab(win);
     }
     if (configKeyboards.nonempty())
-        grab(gKeySysKeyboardNext);
+        gKeySysKeyboardNext.grab(win);
 
     {
-        int win = handle();
         for (KProgram* kp : keyProgs) {
             kp->grab(win);
         }
@@ -256,13 +256,13 @@ void YWindowManager::grabKeys() {
         if (xapp->Win_L) {
             KeyCode keycode = XKeysymToKeycode(xapp->display(), xapp->Win_L);
             if (keycode != 0)
-                XGrabKey(xapp->display(), keycode, AnyModifier, desktop->handle(), False,
+                XGrabKey(xapp->display(), keycode, AnyModifier, win, False,
                          GrabModeAsync, GrabModeSync);
         }
         if (xapp->Win_R) {
             KeyCode keycode = XKeysymToKeycode(xapp->display(), xapp->Win_R);
             if (keycode != 0)
-                XGrabKey(xapp->display(), keycode, AnyModifier, desktop->handle(), False,
+                XGrabKey(xapp->display(), keycode, AnyModifier, win, False,
                          GrabModeAsync, GrabModeSync);
         }
     }
@@ -333,80 +333,78 @@ bool YWindowManager::switchWindowVisible() const {
     return fSwitchWindow && fSwitchWindow->visible();
 }
 
-bool YWindowManager::handleSwitchWorkspaceKey(const XKeyEvent& key,
-        KeySym k, unsigned vm)
-{
-    if (gKeySysWorkspacePrev.eq(k, vm)) {
+bool YWindowManager::handleSwitchWorkspaceKey(const XKeyEvent& key) {
+    if (gKeySysWorkspacePrev == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToPrevWorkspace(false);
         return true;
     }
-    else if (gKeySysWorkspaceNext.eq(k, vm)) {
+    else if (gKeySysWorkspaceNext == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToNextWorkspace(false);
         return true;
     }
-    else if (gKeySysWorkspaceLast.eq(k, vm)) {
+    else if (gKeySysWorkspaceLast == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToLastWorkspace(false);
         return true;
     }
-    else if (gKeySysWorkspace1.eq(k, vm)) {
+    else if (gKeySysWorkspace1 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(0, false);
         return true;
     }
-    else if (gKeySysWorkspace2.eq(k, vm)) {
+    else if (gKeySysWorkspace2 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(1, false);
         return true;
     }
-    else if (gKeySysWorkspace3.eq(k, vm)) {
+    else if (gKeySysWorkspace3 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(2, false);
         return true;
     }
-    else if (gKeySysWorkspace4.eq(k, vm)) {
+    else if (gKeySysWorkspace4 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(3, false);
         return true;
     }
-    else if (gKeySysWorkspace5.eq(k, vm)) {
+    else if (gKeySysWorkspace5 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(4, false);
         return true;
     }
-    else if (gKeySysWorkspace6.eq(k, vm)) {
+    else if (gKeySysWorkspace6 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(5, false);
         return true;
     }
-    else if (gKeySysWorkspace7.eq(k, vm)) {
+    else if (gKeySysWorkspace7 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(6, false);
         return true;
     }
-    else if (gKeySysWorkspace8.eq(k, vm)) {
+    else if (gKeySysWorkspace8 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(7, false);
         return true;
     }
-    else if (gKeySysWorkspace9.eq(k, vm)) {
+    else if (gKeySysWorkspace9 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(8, false);
         return true;
     }
-    else if (gKeySysWorkspace10.eq(k, vm)) {
+    else if (gKeySysWorkspace10 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(9, false);
         return true;
     }
-    else if (gKeySysWorkspace11.eq(k, vm)) {
+    else if (gKeySysWorkspace11 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(10, false);
         return true;
     }
-    else if (gKeySysWorkspace12.eq(k, vm)) {
+    else if (gKeySysWorkspace12 == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(11, false);
         return true;
@@ -414,30 +412,30 @@ bool YWindowManager::handleSwitchWorkspaceKey(const XKeyEvent& key,
     return false;
 }
 
-bool YWindowManager::handleWMKey(const XKeyEvent &key, KeySym k, unsigned vm) {
+bool YWindowManager::handleWMKey(const XKeyEvent& key) {
     YFrameWindow *frame = getFocus();
 
     for (KProgram* p : keyProgs) {
-        if (p->isKey(k, vm)) {
+        if (p->isKey(key)) {
             XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
             p->open(key.state);
             return true;
         }
     }
 
-    if (gKeySysSwitchNext.eq(k, vm)) {
+    if (gKeySysSwitchNext == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         if (getSwitchWindow())
             getSwitchWindow()->begin(true, key.state);
         return true;
     }
-    else if (gKeySysSwitchLast.eq(k, vm)) {
+    else if (gKeySysSwitchLast == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         if (getSwitchWindow())
             getSwitchWindow()->begin(false, key.state);
         return true;
     }
-    else if (gKeySysSwitchClass.eq(k, vm)) {
+    else if (gKeySysSwitchClass == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         if (getSwitchWindow()) {
             char *prop = frame && frame->client()->adopted()
@@ -446,161 +444,161 @@ bool YWindowManager::handleWMKey(const XKeyEvent &key, KeySym k, unsigned vm) {
         }
         return true;
     }
-    else if (gKeySysWinNext.eq(k, vm)) {
+    else if (gKeySysWinNext == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         if (frame) frame->wmNextWindow();
         return true;
-    } else if (gKeySysWinPrev.eq(k, vm)) {
+    } else if (gKeySysWinPrev == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         if (frame) frame->wmPrevWindow();
         return true;
-    } else if (gKeySysWinMenu.eq(k, vm)) {
+    } else if (gKeySysWinMenu == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         if (frame) frame->popupSystemMenu(this);
         return true;
-    } else if (gKeySysDialog.eq(k, vm)) {
+    } else if (gKeySysDialog == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionSysDialog);
         return true;
-    } else if (gKeySysWinListMenu.eq(k, vm)) {
+    } else if (gKeySysWinListMenu == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         popupWindowListMenu(this);
         return true;
-    } else if (gKeySysMenu.eq(k, vm)) {
+    } else if (gKeySysMenu == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         popupStartMenu(this);
         return true;
-    } else if (gKeySysWindowList.eq(k, vm)) {
+    } else if (gKeySysWindowList == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionWindowList, 0);
         return true;
     }
-    else if (handleSwitchWorkspaceKey(key, k, vm)) {
+    else if (handleSwitchWorkspaceKey(key)) {
         return true;
     }
-    else if (gKeySysWorkspacePrevTakeWin.eq(k, vm)) {
+    else if (gKeySysWorkspacePrevTakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToPrevWorkspace(true);
         return true;
-    } else if (gKeySysWorkspaceNextTakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspaceNextTakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToNextWorkspace(true);
         return true;
-    } else if (gKeySysWorkspaceLastTakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspaceLastTakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToLastWorkspace(true);
         return true;
-    } else if (gKeySysWorkspace1TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace1TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(0, true);
         return true;
-    } else if (gKeySysWorkspace2TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace2TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(1, true);
         return true;
-    } else if (gKeySysWorkspace3TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace3TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(2, true);
         return true;
-    } else if (gKeySysWorkspace4TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace4TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(3, true);
         return true;
-    } else if (gKeySysWorkspace5TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace5TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(4, true);
         return true;
-    } else if (gKeySysWorkspace6TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace6TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(5, true);
         return true;
-    } else if (gKeySysWorkspace7TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace7TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(6, true);
         return true;
-    } else if (gKeySysWorkspace8TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace8TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(7, true);
         return true;
-    } else if (gKeySysWorkspace9TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace9TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(8, true);
         return true;
-    } else if (gKeySysWorkspace10TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace10TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(9, true);
         return true;
-    } else if (gKeySysWorkspace11TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace11TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(10, true);
         return true;
-    } else if (gKeySysWorkspace12TakeWin.eq(k, vm)) {
+    } else if (gKeySysWorkspace12TakeWin == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         switchToWorkspace(11, true);
         return true;
-    } else if (gKeySysTileVertical.eq(k, vm)) {
+    } else if (gKeySysTileVertical == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionTileVertical, 0);
         return true;
-    } else if (gKeySysTileHorizontal.eq(k, vm)) {
+    } else if (gKeySysTileHorizontal == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionTileHorizontal, 0);
         return true;
-    } else if (gKeySysCascade.eq(k, vm)) {
+    } else if (gKeySysCascade == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionCascade, 0);
         return true;
-    } else if (gKeySysArrange.eq(k, vm)) {
+    } else if (gKeySysArrange == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionArrange, 0);
         return true;
-    } else if (gKeySysUndoArrange.eq(k, vm)) {
+    } else if (gKeySysUndoArrange == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionUndoArrange, 0);
         return true;
-    } else if (gKeySysArrangeIcons.eq(k, vm)) {
+    } else if (gKeySysArrangeIcons == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionArrangeIcons, 0);
         return true;
-    } else if (gKeySysMinimizeAll.eq(k, vm)) {
+    } else if (gKeySysMinimizeAll == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionMinimizeAll, 0);
         return true;
-    } else if (gKeySysHideAll.eq(k, vm)) {
+    } else if (gKeySysHideAll == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionHideAll, 0);
         return true;
-    } else if (gKeySysAddressBar.eq(k, vm)) {
+    } else if (gKeySysAddressBar == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         if (taskBar) {
             taskBar->showAddressBar();
             return true;
         }
-    } else if (gKeySysShowDesktop.eq(k, vm)) {
+    } else if (gKeySysShowDesktop == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionShowDesktop, 0);
         return true;
-    } else if (gKeySysCollapseTaskBar.eq(k, vm)) {
+    } else if (gKeySysCollapseTaskBar == key) {
         XAllowEvents(xapp->display(), AsyncKeyboard, key.time);
         wmActionListener->actionPerformed(actionCollapseTaskbar, 0);
         return true;
-    } else if (gKeyTaskBarSwitchPrev.eq(k, vm)) {
+    } else if (gKeyTaskBarSwitchPrev == key) {
         if (taskBar)
             taskBar->switchToPrev();
         return true;
-    } else if (gKeyTaskBarSwitchNext.eq(k, vm)) {
+    } else if (gKeyTaskBarSwitchNext == key) {
         if (taskBar)
             taskBar->switchToNext();
         return true;
-    } else if (gKeyTaskBarMovePrev.eq(k, vm)) {
+    } else if (gKeyTaskBarMovePrev == key) {
         if (taskBar)
             taskBar->movePrev();
         return true;
-    } else if (gKeyTaskBarMoveNext.eq(k, vm)) {
+    } else if (gKeyTaskBarMoveNext == key) {
         if (taskBar)
             taskBar->moveNext();
         return true;
-    } else if (gKeySysKeyboardNext.eq(k, vm)) {
+    } else if (gKeySysKeyboardNext == key) {
         if (configKeyboards.nonempty())
             setKeyboard((fDefaultKeyboard + 1) % configKeyboards.getCount());
         return true;
@@ -610,32 +608,22 @@ bool YWindowManager::handleWMKey(const XKeyEvent &key, KeySym k, unsigned vm) {
 
 bool YWindowManager::handleKey(const XKeyEvent &key) {
     if (key.type == KeyPress) {
-        KeySym k = keyCodeToKeySym(key.keycode);
-        unsigned int m = KEY_MODMASK(key.state);
-        unsigned int vm = VMod(m);
-
-        MSG(("down key: %lu, mod: %d", k, m));
-        bool handled = handleWMKey(key, k, vm);
-        if (xapp->WinMask && win95keys) {
-            if (handled) {
-            } else if (k == xapp->Win_L || k == xapp->Win_R) {
+        MSG(("down key: %u, mod: 0x%02x", key.keycode, key.state));
+        bool handled = handleWMKey(key);
+        if (handled == false && win95keys && xapp->WinMask) {
+            KeySym k = keyCodeToKeySym(key.keycode);
+            if (k == xapp->Win_L || k == xapp->Win_R) {
                 /// !!! needs sync grab
                 XAllowEvents(xapp->display(), SyncKeyboard, key.time);
-            } else { //if (m & xapp->WinMask) {
-                /// !!! needs sync grab
+            } else {
                 XAllowEvents(xapp->display(), ReplayKeyboard, key.time);
             }
         }
         return handled;
     } else if (key.type == KeyRelease) {
-        KeySym k = keyCodeToKeySym(key.keycode);
-        unsigned int m = KEY_MODMASK(key.state);
-
-        (void)m;
-#ifdef DEBUG
-        MSG(("up key: %lu, mod: %d", k, m));
-#endif
-        if (xapp->WinMask && win95keys) {
+        MSG(("up key: %u, mod: 0x%02x", key.keycode, key.state));
+        if (win95keys && xapp->WinMask) {
+            KeySym k = keyCodeToKeySym(key.keycode);
             if (k == xapp->Win_L || k == xapp->Win_R) {
                 /// !!! needs sync grab
                 XAllowEvents(xapp->display(), ReplayKeyboard, key.time);
@@ -687,12 +675,9 @@ void YWindowManager::handleButton(const XButtonEvent &button) {
         }
         else {
             // allow buttons to trigger actions from "keys" for #333.
-            KeySym k = button.button - Button1 + XK_Pointer_Button1;
-            unsigned int m = KEY_MODMASK(button.state);
-            unsigned int vm = VMod(m);
             for (KProgram* p : keyProgs) {
-                if (p->isKey(k, vm)) {
-                    p->open(m);
+                if (p->isButton(button)) {
+                    p->open(KEY_MODMASK(button.state));
                     break;
                 }
             }
@@ -3993,62 +3978,61 @@ bool YTopWindow::handleKey(const XKeyEvent& key) {
         xapp->AltMask)
     {
         YFrameWindow* f = fFrame;
-        KeySym k = keyCodeToKeySym(key.keycode);
-        unsigned m = KEY_MODMASK(key.state);
-        unsigned vm = VMod(m);
 
-        if (gKeyWinClose.eq(k, vm)) {
+        if (gKeyWinClose == key) {
             f->actionPerformed(actionClose);
         }
-        else if (gKeyWinPrev.eq(k, vm)) {
+        else if (gKeyWinPrev == key) {
             f->wmPrevWindow();
         }
-        else if (gKeyWinMaximizeVert.eq(k, vm)) {
+        else if (gKeyWinMaximizeVert == key) {
             f->actionPerformed(actionMaximizeVert);
         }
-        else if (gKeyWinMaximizeHoriz.eq(k, vm)) {
+        else if (gKeyWinMaximizeHoriz == key) {
             f->actionPerformed(actionMaximizeHoriz);
         }
-        else if (gKeyWinRaise.eq(k, vm)) {
+        else if (gKeyWinRaise == key) {
             f->actionPerformed(actionRaise);
         }
-        else if (gKeyWinOccupyAll.eq(k, vm)) {
+        else if (gKeyWinOccupyAll == key) {
             f->actionPerformed(actionOccupyAllOrCurrent);
         }
-        else if (gKeyWinLower.eq(k, vm)) {
+        else if (gKeyWinLower == key) {
             f->actionPerformed(actionLower);
         }
-        else if (gKeyWinRestore.eq(k, vm)) {
+        else if (gKeyWinRestore == key) {
             f->actionPerformed(actionRestore);
         }
-        else if (gKeyWinNext.eq(k, vm)) {
+        else if (gKeyWinNext == key) {
             f->wmNextWindow();
         }
-        else if (gKeyWinMove.eq(k, vm)) {
+        else if (gKeyWinMove == key) {
             f->actionPerformed(actionMove);
         }
-        else if (gKeyWinSize.eq(k, vm)) {
+        else if (gKeyWinSize == key) {
             f->actionPerformed(actionSize);
         }
-        else if (gKeyWinMinimize.eq(k, vm)) {
+        else if (gKeyWinMinimize == key) {
             f->actionPerformed(actionMinimize);
         }
-        else if (gKeyWinMaximize.eq(k, vm)) {
+        else if (gKeyWinMaximize == key) {
             f->actionPerformed(actionMaximize);
         }
-        else if (gKeyWinHide.eq(k, vm)) {
+        else if (gKeyWinHide == key) {
             f->actionPerformed(actionHide);
         }
-        else if (gKeyWinRollup.eq(k, vm)) {
+        else if (gKeyWinRollup == key) {
             f->actionPerformed(actionRollup);
         }
-        else if (gKeyWinFullscreen.eq(k, vm)) {
+        else if (gKeyWinFullscreen == key) {
             f->actionPerformed(actionFullscreen);
         }
-        else if (gKeyWinMenu.eq(k, vm)) {
+        else if (gKeyWinMenu == key) {
             f->popupSystemMenu(this);
         }
         else if (f->isIconic() || f->isRollup()) {
+            KeySym k = keyCodeToKeySym(key.keycode);
+            unsigned m = KEY_MODMASK(key.state);
             if ((k == XK_Menu) || (k == XK_F10 && m == ShiftMask)) {
                 f->popupSystemMenu(this);
             }
diff --git a/src/wmmgr.h b/src/wmmgr.h
index 7254177a2..9b67dd4f1 100644
--- a/src/wmmgr.h
+++ b/src/wmmgr.h
@@ -319,7 +319,7 @@ class YWindowManager:
     };
 
     const DesktopLayout& layout() const { return fLayout; }
-    bool handleSwitchWorkspaceKey(const XKeyEvent& key, KeySym k, unsigned vm);
+    bool handleSwitchWorkspaceKey(const XKeyEvent& key);
 
     int getSwitchScreen();
     bool switchWindowVisible() const;
@@ -340,7 +340,7 @@ class YWindowManager:
     YFrameClient* allocateClient(Window win, bool mapClient);
     YFrameWindow* allocateFrame(YFrameClient* client);
     void updateArea(int workspace, int screen_number, int l, int t, int r, int b);
-    bool handleWMKey(const XKeyEvent &key, KeySym k, unsigned vm);
+    bool handleWMKey(const XKeyEvent &key);
     void setWmState(WMState newWmState);
     void refresh();
 
diff --git a/src/wmminiicon.cc b/src/wmminiicon.cc
index 067b6786b..597c73a54 100644
--- a/src/wmminiicon.cc
+++ b/src/wmminiicon.cc
@@ -226,23 +226,24 @@ void MiniIcon::handleDrag(const XButtonEvent &down, const XMotionEvent &motion)
 
 bool MiniIcon::handleKey(const XKeyEvent& key) {
     if (key.type == KeyPress) {
-        KeySym k = keyCodeToKeySym(key.keycode);
-        unsigned int m = KEY_MODMASK(key.state);
-        unsigned int vm = VMod(m);
-        if (gKeyWinClose.eq(k, vm)) {
+        if (gKeyWinClose == key) {
             fFrame->actionPerformed(actionClose);
         }
-        else if (gKeyWinLower.eq(k, vm)) {
+        else if (gKeyWinLower == key) {
             fFrame->actionPerformed(actionLower);
         }
-        else if (gKeyWinRestore.eq(k, vm)) {
+        else if (gKeyWinRestore == key) {
             fFrame->actionPerformed(actionRestore);
         }
-        else if (k == XK_Return || k == XK_KP_Enter) {
-            fFrame->activate();
-        }
-        else if (k == XK_Menu || (k == XK_F10 && m == ShiftMask)) {
-            fFrame->popupSystemMenu(fFrame);
+        else {
+            KeySym k = keyCodeToKeySym(key.keycode);
+            unsigned m = KEY_MODMASK(key.state);
+            if (k == XK_Return || k == XK_KP_Enter) {
+                fFrame->activate();
+            }
+            else if (k == XK_Menu || (k == XK_F10 && m == ShiftMask)) {
+                fFrame->popupSystemMenu(fFrame);
+            }
         }
     }
     return true;
diff --git a/src/wmprog.cc b/src/wmprog.cc
index da44fe16a..b7d551d2a 100644
--- a/src/wmprog.cc
+++ b/src/wmprog.cc
@@ -133,7 +133,10 @@ class MenuProgSwitchItems: public ISwitchItems {
     virtual bool isEmpty() override {
         return menu->itemCount() == 0;
     }
-    virtual bool isKey(KeySym k, unsigned int mod) override {
+    virtual bool isKey(const XKeyEvent& key) override {
+        KeySym k = xapp->keyCodeToKeySym(key.keycode);
+        unsigned m = KEY_MODMASK(key.state);
+        unsigned mod = desktop->VMod(m);
         return k == this->key && mod == this->mod;
     }
     unsigned modifiers() override {
diff --git a/src/wmprog.h b/src/wmprog.h
index 7c0bf76d4..9731b1ca9 100644
--- a/src/wmprog.h
+++ b/src/wmprog.h
@@ -173,9 +173,8 @@ class KProgram {
     ~KProgram();
 
     void parse() { wm.parse(); }
-    bool isKey(KeySym key, unsigned mod) const {
-        return wm.eq(key, mod);
-    }
+    bool isKey(const XKeyEvent& x) const { return wm == x; }
+    bool isButton(const XButtonEvent& b) const { return wm == b; }
     void open(unsigned mods);
     void grab(int handle) { wm.grab(handle); }
 
diff --git a/src/wmswitch.cc b/src/wmswitch.cc
index 4de686597..af4e110ca 100644
--- a/src/wmswitch.cc
+++ b/src/wmswitch.cc
@@ -326,9 +326,8 @@ class WindowItemsCtrlr : public ISwitchItems
         return fActiveItem.frame;
     }
 
-    bool isKey(KeySym k, unsigned vm) override {
-        return gKeySysSwitchNext.eq(k, vm) || (fWMClass &&
-               gKeySysSwitchClass.eq(k, vm));
+    bool isKey(const XKeyEvent& x) override {
+        return gKeySysSwitchNext == x || (fWMClass && gKeySysSwitchClass == x);
     }
 
     unsigned modifiers() override {
@@ -947,24 +946,21 @@ void SwitchWindow::target(int delta) {
 
 bool SwitchWindow::handleKey(const XKeyEvent &key) {
     KeySym k = keyCodeToKeySym(key.keycode);
-    unsigned m = KEY_MODMASK(key.state);
-    unsigned vm = VMod(m);
-
     if (key.type == KeyPress) {
         keyPressed = k;
-        if (isKey(k, vm)) {
+        if (isKey(key)) {
             target(+1);
         }
-        else if (gKeySysSwitchLast.eq(k, vm)) {
+        else if (gKeySysSwitchLast == key) {
             target(-1);
         }
-        else if (gKeyWinClose.eq(k, vm)) {
+        else if (gKeyWinClose == key) {
             zItems->destroyTarget();
         }
         else if (k == XK_Return) {
             accept();
         }
-        else if (manager->handleSwitchWorkspaceKey(key, k, vm)) {
+        else if (manager->handleSwitchWorkspaceKey(key)) {
             bool change = (fWorkspace != manager->activeWorkspace());
             fWorkspace = manager->activeWorkspace();
             if ((change && !quickSwitchToAllWorkspaces) ||
@@ -1008,12 +1004,12 @@ bool SwitchWindow::handleKey(const XKeyEvent &key) {
             if (index < zItems->getCount())
                 target(index - zItems->getActiveItem());
         }
-        else if (zItems->isKey(k, vm) && !modDown(m)) {
+        else if (zItems->isKey(key) && !modDown(key.state)) {
             accept();
         }
     }
     else if (key.type == KeyRelease) {
-        if ((isKey(k, vm) && !modDown(m)) || isModKey(key.keycode)) {
+        if ((isKey(key) && !modDown(key.state)) || isModKey(key.keycode)) {
             accept();
         }
         else if (k == XK_Escape && k == keyPressed) {
@@ -1024,8 +1020,8 @@ bool SwitchWindow::handleKey(const XKeyEvent &key) {
     return true;
 }
 
-bool SwitchWindow::isKey(KeySym k, unsigned vm) {
-    return zItems->isKey(k, vm);
+bool SwitchWindow::isKey(const XKeyEvent& key) {
+    return zItems->isKey(key);
 }
 
 unsigned SwitchWindow::modifiers() {
diff --git a/src/wmswitch.h b/src/wmswitch.h
index 6be2ae561..b75d94922 100644
--- a/src/wmswitch.h
+++ b/src/wmswitch.h
@@ -40,7 +40,7 @@ class ISwitchItems
                     return false; }
     virtual void transfer(YFrameClient* client, YFrameWindow* frame) { }
 
-    virtual bool isKey(KeySym k, unsigned mod) = 0;
+    virtual bool isKey(const XKeyEvent& key) = 0;
     virtual unsigned modifiers() = 0;
 
     // Filter items by WM_CLASS
@@ -100,7 +100,7 @@ class SwitchWindow: public YPopupWindow {
 
     bool modDown(unsigned m);
     bool isModKey(KeyCode c);
-    bool isKey(KeySym k, unsigned mod);
+    bool isKey(const XKeyEvent& key);
     void target(int delta);
 
     void resize(int xiscreen, bool reposition);
diff --git a/src/ywindow.cc b/src/ywindow.cc
index d070354a5..69d47212c 100644
--- a/src/ywindow.cc
+++ b/src/ywindow.cc
@@ -1701,59 +1701,6 @@ YDesktop::~YDesktop() {
         desktop = nullptr;
 }
 
-void YWindow::grab(struct WMKey& wmkey) {
-    wmkey.grab(handle());
-}
-
-void YWindow::grabVButton(int button, unsigned int vm) {
-    unsigned m = 0;
-
-    if (vm & kfShift)
-        m |= ShiftMask;
-    if (vm & kfCtrl)
-        m |= ControlMask;
-    if (vm & kfAlt)
-        m |= xapp->AltMask;
-    if (vm & kfMeta)
-        m |= xapp->MetaMask;
-    if (vm & kfSuper)
-       m |= xapp->SuperMask;
-    if (vm & kfHyper)
-       m |= xapp->HyperMask;
-    if (vm & kfAltGr)
-       m |= xapp->ModeSwitchMask;
-
-    MSG(("grabVButton %d %d %d", button, vm, m));
-
-    if (button != 0 && (vm == 0 || m != 0)) {
-        if ((!(vm & kfMeta) || xapp->MetaMask) &&
-            (!(vm & kfAlt) || xapp->AltMask) &&
-           (!(vm & kfSuper) || xapp->SuperMask) &&
-            (!(vm & kfHyper) || xapp->HyperMask) &&
-            (!(vm & kfAltGr) || xapp->ModeSwitchMask))
-        {
-            grabButton(button, m);
-        }
-
-        // !!! recheck this
-        if (((vm & (kfAlt | kfCtrl)) == (kfAlt | kfCtrl)) &&
-            modSuperIsCtrlAlt &&
-            xapp->WinMask)
-        {
-            m = xapp->WinMask;
-            if (vm & kfShift)
-                m |= ShiftMask;
-            if (vm & kfSuper)
-                m |= xapp->SuperMask;
-            if (vm & kfHyper)
-                m |= xapp->HyperMask;
-            if (vm & kfAltGr)
-                m |= xapp->ModeSwitchMask;
-            grabButton(button, m);
-        }
-    }
-}
-
 unsigned YWindow::VMod(unsigned m) {
     unsigned vm = 0;
     unsigned m1 = m & ~xapp->WinMask;
diff --git a/src/ywindow.h b/src/ywindow.h
index c07c1a672..327b2c810 100644
--- a/src/ywindow.h
+++ b/src/ywindow.h
@@ -162,11 +162,9 @@ class YWindow : protected YWindowList, private YWindowNode {
     void setPointer(Cursor pointer);
     void grabKeyM(unsigned key, unsigned modifiers);
     void grabKey(unsigned key, unsigned modifiers);
-    void grab(struct WMKey& wmkey);
     unsigned VMod(unsigned modifiers);
     void grabButtonM(int button, unsigned modifiers);
     void grabButton(int button, unsigned modifiers);
-    void grabVButton(int button, unsigned vmodifiers);
 
     Window handle() { return (flags & wfCreated) ? fHandle : create(); }
     YWindow *parent() const { return fParent; }
diff --git a/src/yxapp.cc b/src/yxapp.cc
index e349cd2b8..b2564829c 100644
--- a/src/yxapp.cc
+++ b/src/yxapp.cc
@@ -24,6 +24,7 @@ YContext<YWindow> windowContext("windowContext", false);
 
 bool YXApplication::synchronizeX11;
 bool YXApplication::alphaBlending;
+bool YXApplication::xkbExtension;
 Window YXApplication::ignorable;
 
 Atom _XA_WM_CHANGE_STATE;
@@ -580,14 +581,6 @@ void YXApplication::initModifiers() {
 
     ButtonKeyMask = KeyMask | ButtonMask;
 
-#if 0
-    KeySym wl = XKeycodeToKeysym(app->display(), 115, 0);
-    KeySym wr = XKeycodeToKeysym(app->display(), 116, 0);
-
-    if (wl == XK_Super_L) {
-    } else if (wl == XK_Meta_L) {
-    }
-#endif
     // this will do for now, but we should actualy check the keycodes
     Win_L = Win_R = 0;
 
@@ -1149,6 +1142,9 @@ void YXApplication::initExtensions(Display* dpy) {
 #endif
 
     xshm.init(dpy, XShmQueryExtension, XShmQueryVersion);
+
+    int op = 0, ev = 0, er = 0, ma = XkbMajorVersion, mi = XkbMinorVersion;
+    xkbExtension = (XkbQueryExtension(dpy, &op, &ev, &er, &ma, &mi) == True);
 }
 
 YXApplication::~YXApplication() {
@@ -1433,10 +1429,25 @@ YKeycodeMap YXApplication::getKeycodeMap() {
         fKeycodeMap = XGetKeyboardMapping(xapp->display(), fKeycodeMin,
                                           fKeycodeMax - fKeycodeMin + 1,
                                           &fKeysymsPer);
+        if (fKeycodeMap) {
+            fKeycodeTimer->setTimer(2000L, this, true);
+        }
     }
     return YKeycodeMap(fKeycodeMap, fKeysymsPer, fKeycodeMin, fKeycodeMax);
 }
 
+bool YXApplication::handleTimer(YTimer* timer) {
+    if (timer == fKeycodeTimer) {
+        fKeycodeTimer = null;
+        if (fKeycodeMap) {
+            XFree(fKeycodeMap);
+            fKeycodeMap = nullptr;
+            fKeycodeMin = fKeycodeMax = fKeysymsPer = 0;
+        }
+    }
+    return false;
+}
+
 bool YXApplication::windowExists(Window handle) const {
     XWindowAttributes attributes;
     return XGetWindowAttributes(display(), handle, &attributes);
diff --git a/src/yxapp.h b/src/yxapp.h
index 7d781e251..cecb7774b 100644
--- a/src/yxapp.h
+++ b/src/yxapp.h
@@ -4,6 +4,7 @@
 #include "yapp.h"
 #include "ywindow.h"
 #include "ycursor.h"
+#include "ytimer.h"
 #include <X11/Xutil.h>
 
 #define KEY_MODMASK(x) ((x) & (xapp->KeyMask))
@@ -103,9 +104,10 @@ class YKeycodeMap {
     const int per, min, max;
     YKeycodeMap(KeySym* k, int p, int lo, int hi) :
         map(k), per(p), min(lo), max(hi) { }
+    operator bool() const { return map && 1 < max && 1 < per; }
 };
 
-class YXApplication: public YApplication {
+class YXApplication: public YApplication, protected YTimerListener {
 public:
     YXApplication(int *argc, char ***argv, const char *displayName = nullptr);
     virtual ~YXApplication();
@@ -172,6 +174,7 @@ class YXApplication: public YApplication {
 
     static bool alphaBlending;
     static bool synchronizeX11;
+    static bool xkbExtension;
 
     unsigned int AltMask;
     unsigned int MetaMask;
@@ -209,6 +212,7 @@ class YXApplication: public YApplication {
     virtual int handleError(XErrorEvent* xev);
     virtual Cursor getRightPointer() const { return None; }
     virtual void keyboardRemap() { }
+    virtual bool handleTimer(YTimer* timer);
 
 private:
     XRenderPictFormat* findFormat(int depth) const;
@@ -240,6 +244,7 @@ class YXApplication: public YApplication {
     YXPoll xfd;
     XIM fXIM;
 
+    lazy<YTimer> fKeycodeTimer;
     lazy<class YClipboard> fClip;
     YWindow *fXGrabWindow;
     YWindow *fGrabWindow;