X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=util%2Fepist%2Fscreen.cc;h=7845e55f9489f8b11c2fa36cefe478584f74252b;hb=eca8fd764eeb631733cae2b171ca0787fca788d7;hp=281a093e3aa10745bee6978eb301b5a6b6302670;hpb=33cce0d97e6ec4ccf11775a450cb65f5938c88b7;p=chaz%2Fopenbox

diff --git a/util/epist/screen.cc b/util/epist/screen.cc
index 281a093e..7845e55f 100644
--- a/util/epist/screen.cc
+++ b/util/epist/screen.cc
@@ -1,5 +1,5 @@
-// -*- mode: C++; indent-tabs-mode: nil; -*-
-// screen.cc for Epistophy - a key handler for NETWM/EWMH window managers.
+// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
+// screen.cc for Epistrophy - a key handler for NETWM/EWMH window managers.
 // Copyright (c) 2002 - 2002 Ben Jansens <ben at orodu.net>
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
@@ -20,6 +20,17 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+/* A few comments about stacked cycling:
+ * When stacked cycling is turned on, the focused window is always at the top
+ * (front) of the list (_clients), EXCEPT for when we are in cycling mode.
+ * (_cycling is true) If we were to add the focused window to the top of the
+ * stack while we were cycling, we would end in a deadlock between 2 windows.
+ * When the modifiers are released, the window that has focus (but it's not
+ * at the top of the stack, since we are cycling) is placed at the top of the
+ * stack and raised.
+ * Hooray and Bummy. - Marius
+ */
+
 #ifdef    HAVE_CONFIG_H
 #  include "../../config.h"
 #endif // HAVE_CONFIG_H
@@ -33,6 +44,8 @@ extern "C" {
 #  include <sys/types.h>
 #  include <unistd.h>
 #endif // HAVE_UNISTD_H
+
+#include <X11/keysym.h>
 }
 
 #include <iostream>
@@ -48,29 +61,33 @@ using std::string;
 #include "../../src/XAtom.hh"
 #include "screen.hh"
 #include "epist.hh"
-
+#include "config.hh"
 
 screen::screen(epist *epist, int number) 
-  : _clients(epist->clientsList()),
-    _active(epist->activeWindow()) {
+  : _clients(epist->clientsList()), _active(epist->activeWindow()),
+    _config(epist->getConfig()), _grabbed(true), _cycling(false),
+    _stacked_cycling(false)
+{
   _epist = epist;
   _xatom = _epist->xatom();
   _last_active = _clients.end();
   _number = number;
   _info = _epist->getScreenInfo(_number);
   _root = _info->getRootWindow();
-  
+
+  _config->getValue(Config::stackedCycling, _stacked_cycling);
+
   // find a window manager supporting NETWM, waiting for it to load if we must
   int count = 20;  // try for 20 seconds
   _managed = false;
   while (! (_epist->doShutdown() || _managed || count <= 0)) {
     if (! (_managed = findSupportingWM()))
-      usleep(1000);
+      sleep(1);
     --count;
   }
   if (_managed)
     cout << "Found compatible window manager '" << _wm_name << "' for screen "
-      << _number << ".\n";
+         << _number << ".\n";
   else {
     cout << "Unable to find a compatible window manager for screen " <<
       _number << ".\n";
@@ -121,11 +138,11 @@ void screen::processEvent(const XEvent &e) {
     // root window
     if (e.xproperty.atom == _xatom->getAtom(XAtom::net_number_of_desktops))
       updateNumDesktops();
-    if (e.xproperty.atom == _xatom->getAtom(XAtom::net_current_desktop))
+    else if (e.xproperty.atom == _xatom->getAtom(XAtom::net_current_desktop))
       updateActiveDesktop();
-    if (e.xproperty.atom == _xatom->getAtom(XAtom::net_active_window))
+    else if (e.xproperty.atom == _xatom->getAtom(XAtom::net_active_window))
       updateActiveWindow();
-    if (e.xproperty.atom == _xatom->getAtom(XAtom::net_client_list)) {
+    else if (e.xproperty.atom == _xatom->getAtom(XAtom::net_client_list)) {
       // catch any window unmaps first
       XEvent ev;
       if (XCheckTypedWindowEvent(_epist->getXDisplay(), e.xany.window,
@@ -141,172 +158,247 @@ void screen::processEvent(const XEvent &e) {
   case KeyPress:
     handleKeypress(e);
     break;
+
+  case KeyRelease:
+    handleKeyrelease(e);
+    break;
+
+  default:
+    break;
   }
 }
 
 void screen::handleKeypress(const XEvent &e) {
   int scrolllockMask, numlockMask;
-
-  ActionList::const_iterator it = _epist->actions().begin();
-  ActionList::const_iterator end = _epist->actions().end();
-
   _epist->getLockModifiers(numlockMask, scrolllockMask);
   
-  for (; it != end; ++it) {
-    unsigned int state = e.xkey.state & ~(LockMask|scrolllockMask|numlockMask);
+  // Mask out the lock modifiers. We want our keys to always work
+  // This should be made an option
+  unsigned int state = e.xkey.state & ~(LockMask|scrolllockMask|numlockMask);
+  keytree &ktree = _epist->getKeyTree();
+  const Action *it = ktree.getAction(e, state, this);
+
+  if (!it)
+    return;
+
+  switch (it->type()) {
+  case Action::nextScreen:
+    _epist->cycleScreen(_number, true);
+    return;
+
+  case Action::prevScreen:
+    _epist->cycleScreen(_number, false);
+    return;
+
+  case Action::nextWorkspace:
+    cycleWorkspace(true, it->number() != 0 ? it->number(): 1);
+    return;
+
+  case Action::prevWorkspace:
+    cycleWorkspace(false, it->number() != 0 ? it->number(): 1);
+    return;
+
+  case Action::nextWindow:
     
-    if (e.xkey.keycode == it->keycode() &&
-        state == it->modifierMask()) {
-      switch (it->type()) {
-      case Action::nextScreen:
-        _epist->cycleScreen(_number, true);
-        return;
+    cycleWindow(state, true, it->number() != 0 ? it->number(): 1);
+    return;
 
-      case Action::prevScreen:
-        _epist->cycleScreen(_number, false);
-        return;
+  case Action::prevWindow:
+    cycleWindow(state, false, it->number() != 0 ? it->number(): 1);
+    return;
 
-      case Action::nextWorkspace:
-        cycleWorkspace(true);
-        return;
+  case Action::nextWindowOnAllWorkspaces:
+    cycleWindow(state, true, it->number() != 0 ? it->number(): 1,  false, true);
+    return;
 
-      case Action::prevWorkspace:
-        cycleWorkspace(false);
-        return;
+  case Action::prevWindowOnAllWorkspaces:
+    cycleWindow(state, false, it->number() != 0 ? it->number(): 1, false, true);
+    return;
 
-      case Action::nextWindow:
-        cycleWindow(true);
-        return;
+  case Action::nextWindowOnAllScreens:
+    cycleWindow(state, true, it->number() != 0 ? it->number(): 1, true);
+    return;
 
-      case Action::prevWindow:
-        cycleWindow(false);
-        return;
+  case Action::prevWindowOnAllScreens:
+    cycleWindow(state, false, it->number() != 0 ? it->number(): 1, true);
+    return;
 
-      case Action::nextWindowOnAllWorkspaces:
-        cycleWindow(true, false, true);
-        return;
+  case Action::nextWindowOfClass:
+    cycleWindow(state, true, it->number() != 0 ? it->number(): 1,
+                false, false, true, it->string());
+    return;
 
-      case Action::prevWindowOnAllWorkspaces:
-        cycleWindow(false, false, true);
-        return;
+  case Action::prevWindowOfClass:
+    cycleWindow(state, false, it->number() != 0 ? it->number(): 1,
+                false, false, true, it->string());
+    return;
+      
+  case Action::nextWindowOfClassOnAllWorkspaces:
+    cycleWindow(state, true, it->number() != 0 ? it->number(): 1,
+                false, true, true, it->string());
+    return;
+      
+  case Action::prevWindowOfClassOnAllWorkspaces:
+    cycleWindow(state, false, it->number() != 0 ? it->number(): 1,
+                false, true, true, it->string());
+    return;
 
-      case Action::nextWindowOnAllScreens:
-        cycleWindow(true, true);
-        return;
+  case Action::changeWorkspace:
+    changeWorkspace(it->number());
+    return;
 
-      case Action::prevWindowOnAllScreens:
-        cycleWindow(false, true);
-        return;
+  case Action::upWorkspace:
+    changeWorkspaceVert(-1);
+    return;
 
-      case Action::nextWindowOfClass:
-        cycleWindow(true, false, false, true, it->string());
-        return;
+  case Action::downWorkspace:
+    changeWorkspaceVert(1);
+    return;
 
-      case Action::prevWindowOfClass:
-        cycleWindow(false, false, false, true, it->string());
-        return;
+  case Action::leftWorkspace:
+    changeWorkspaceHorz(-1);
+    return;
 
-      case Action::nextWindowOfClassOnAllWorkspaces:
-        cycleWindow(true, false, true, true, it->string());
-        return;
+  case Action::rightWorkspace:
+    changeWorkspaceHorz(1);
+    return;
 
-      case Action::prevWindowOfClassOnAllWorkspaces:
-        cycleWindow(false, false, true, true, it->string());
-        return;
+  case Action::execute:
+    execCommand(it->string());
+    return;
 
-      case Action::changeWorkspace:
-        changeWorkspace(it->number());
-        return;
+  case Action::showRootMenu:
+    _xatom->sendClientMessage(rootWindow(), XAtom::openbox_show_root_menu,
+                              None);
+    return;
 
-      case Action::execute:
-        execCommand(it->string());
-        return;
+  case Action::showWorkspaceMenu:
+    _xatom->sendClientMessage(rootWindow(), XAtom::openbox_show_workspace_menu,
+                              None);
+    return;
 
-      default:
-        break;
-      }
+  case Action::toggleGrabs: {
+    if (_grabbed) {
+      ktree.ungrabDefaults(this);
+      _grabbed = false;
+    } else {
+      ktree.grabDefaults(this);
+      _grabbed = true;
+    }
+    return;
+  }
 
-      // these actions require an active window
-      if (_active != _clients.end()) {
-        XWindow *window = *_active;
-
-        switch (it->type()) {
-        case Action::iconify:
-          window->iconify();
-          return;
-
-        case Action::close:
-          window->close();
-          return;
-
-        case Action::raise:
-          window->raise();
-          return;
-
-        case Action::lower:
-          window->lower();
-          return;
-
-        case Action::sendToWorkspace:
-          window->sendTo(it->number());
-          return;
-
-        case Action::toggleomnipresent:
-          if (window->desktop() == 0xffffffff)
-            window->sendTo(_active_desktop);
-          else
-            window->sendTo(0xffffffff);
-          return;
-
-        case Action::moveWindowUp:
-          window->move(window->x(), window->y() - it->number());
-          return;
+  default:
+    break;
+  }
+
+  // these actions require an active window
+  if (_active != _clients.end()) {
+    XWindow *window = *_active;
       
-        case Action::moveWindowDown:
-          window->move(window->x(), window->y() + it->number());
-          return;
+    switch (it->type()) {
+    case Action::iconify:
+      window->iconify();
+      return;
+
+    case Action::close:
+      window->close();
+      return;
+
+    case Action::raise:
+      window->raise();
+      return;
+
+    case Action::lower:
+      window->lower();
+      return;
+
+    case Action::sendToWorkspace:
+      window->sendTo(it->number());
+      return;
+
+    case Action::toggleOmnipresent:
+      if (window->desktop() == 0xffffffff)
+        window->sendTo(_active_desktop);
+      else
+        window->sendTo(0xffffffff);
+      return;
+
+    case Action::moveWindowUp:
+      window->move(window->x(), window->y() -
+                   (it->number() != 0 ? it->number(): 1));
+      return;
       
-        case Action::moveWindowLeft:
-          window->move(window->x() - it->number(), window->y());
-          return;
+    case Action::moveWindowDown:
+      window->move(window->x(), window->y() +
+                   (it->number() != 0 ? it->number(): 1));
+      return;
       
-        case Action::moveWindowRight:
-          window->move(window->x() + it->number(), window->y());
-          return;
+    case Action::moveWindowLeft:
+      window->move(window->x() - (it->number() != 0 ? it->number(): 1),
+                   window->y());
+      return;
       
-        case Action::resizeWindowWidth:
-          window->resize(window->width() + it->number(), window->height());
-          return;
+    case Action::moveWindowRight:
+      window->move(window->x() + (it->number() != 0 ? it->number(): 1),
+                   window->y());
+      return;
       
-        case Action::resizeWindowHeight:
-          window->resize(window->width(), window->height() + it->number());
-          return;
+    case Action::resizeWindowWidth:
+      window->resizeRel(it->number(), 0);
+      return;
       
-        case Action::toggleshade:
-          window->shade(! window->shaded());
-          return;
+    case Action::resizeWindowHeight:
+      window->resizeRel(0, it->number());
+      return;
       
-        case Action::toggleMaximizeHorizontal:
-          window->toggleMaximize(XWindow::Max_Horz);
-          return;
+    case Action::toggleShade:
+      window->shade(! window->shaded());
+      return;
       
-        case Action::toggleMaximizeVertical:
-          window->toggleMaximize(XWindow::Max_Vert);
-          return;
+    case Action::toggleMaximizeHorizontal:
+      window->toggleMaximize(XWindow::Max_Horz);
+      return;
       
-        case Action::toggleMaximizeFull:
-          window->toggleMaximize(XWindow::Max_Full);
-          return;
+    case Action::toggleMaximizeVertical:
+      window->toggleMaximize(XWindow::Max_Vert);
+      return;
       
-        default:
-          assert(false);  // unhandled action type!
-          break;
-        }
-      }
+    case Action::toggleMaximizeFull:
+      window->toggleMaximize(XWindow::Max_Full);
+      return;
+
+    case Action::toggleDecorations:
+      window->decorate(! window->decorated());
+      return;
+      
+    default:
+      assert(false);  // unhandled action type!
+      break;
     }
   }
 }
 
+
+void screen::handleKeyrelease(const XEvent &) {
+  // the only keyrelease event we care about (for now) is when we do stacked
+  // cycling and the modifier is released
+  if (_stacked_cycling && _cycling && nothingIsPressed()) {
+    XWindow *w = *_active;
+
+    // all modifiers have been released. ungrab the keyboard, move the
+    // focused window to the top of the Z-order and raise it
+    ungrabModifiers();
+
+    _clients.remove(w);
+    _clients.push_front(w);
+    w->raise();
+
+    _cycling = false;
+  }
+}
+
+
 // do we want to add this window to our list?
 bool screen::doAddWindow(Window window) const {
   assert(_managed);
@@ -376,7 +468,7 @@ void screen::updateClientList() {
         break;
     if (it == end) {  // didn't already exist
       if (doAddWindow(rootclients[i])) {
-//        cout << "Added window: 0x" << hex << rootclients[i] << dec << endl;
+        //        cout << "Added window: 0x" << hex << rootclients[i] << dec << endl;
         _clients.insert(insert_point, new XWindow(_epist, this,
                                                   rootclients[i]));
       }
@@ -396,7 +488,7 @@ void screen::updateClientList() {
       if (**it2 == rootclients[i])
         break;
     if (i == num)  { // no longer exists
-//      cout << "Removed window: 0x" << hex << (*it2)->window() << dec << endl;
+      //      cout << "Removed window: 0x" << hex << (*it2)->window() << dec << endl;
       // watch for the active and last-active window
       if (it2 == _active)
         _active = _clients.end();
@@ -441,35 +533,37 @@ void screen::updateActiveWindow() {
       break;
     }
   }
+
   _active = it;
+
+  /* if we're not cycling and a window gets focus, add it to the top of the
+   * cycle stack.
+   */
+  if (_stacked_cycling && !_cycling) {
+    _clients.remove(*_active);
+    _clients.push_front(*_active);
+  }
+
   if (it != end)
     _last_active = it;
 
-/*  cout << "Active window is now: ";
-  if (_active == _clients.end()) cout << "None\n";
-  else cout << "0x" << hex << (*_active)->window() << dec << endl;
-*/
+  /*  cout << "Active window is now: ";
+      if (_active == _clients.end()) cout << "None\n";
+      else cout << "0x" << hex << (*_active)->window() << dec << endl;
+  */
 }
 
 
 void screen::execCommand(const string &cmd) const {
   pid_t pid;
   if ((pid = fork()) == 0) {
-    extern char **environ;
-
-    char *const argv[] = {
-      "sh",
-      "-c",
-      const_cast<char *>(cmd.c_str()),
-      0
-    };
     // make the command run on the correct screen
     if (putenv(const_cast<char*>(_info->displayString().c_str()))) {
       cout << "warning: couldn't set environment variable 'DISPLAY'\n";
       perror("putenv()");
     }
-    execve("/bin/sh", argv, environ);
-    exit(127);
+    execl("/bin/sh", "sh", "-c", cmd.c_str(), NULL);
+    exit(-1);
   } else if (pid == -1) {
     cout << _epist->getApplicationName() <<
       ": Could not fork a process for executing a command\n";
@@ -477,68 +571,104 @@ void screen::execCommand(const string &cmd) const {
 }
 
 
-void screen::cycleWindow(const bool forward, const bool allscreens,
+void screen::cycleWindow(unsigned int state, const bool forward,
+                         const int increment, const bool allscreens,
                          const bool alldesktops, const bool sameclass,
-                         const string &cn) const {
+                         const string &cn)
+{
   assert(_managed);
+  assert(increment > 0);
 
   if (_clients.empty()) return;
-  
+
   string classname(cn);
   if (sameclass && classname.empty() && _active != _clients.end())
     classname = (*_active)->appClass();
 
   WindowList::const_iterator target = _active,
-                             first = _active,
-                             begin = _clients.begin(),
-                             end = _clients.end();
- 
-  do {
-    if (forward) {
-      if (target == end) {
-        target = begin;
-      } else {
-        ++target;
-        if (target == end)
+    begin = _clients.begin(),
+    end = _clients.end();
+
+  XWindow *t = 0;
+  
+  for (int x = 0; x < increment; ++x) {
+    while (1) {
+      if (forward) {
+        if (target == end) {
           target = begin;
+        } else {
+          ++target;
+        }
+      } else {
+        if (target == begin)
+          target = end;
+        --target;
       }
-    } else {
-      if (target == begin)
-        target = end;
-      --target;
+
+      // must be no window to focus
+      if (target == _active)
+        return;
+
+      // start back at the beginning of the loop
+      if (target == end)
+        continue;
+
+      // determine if this window is invalid for cycling to
+      t = *target;
+      if (t->iconic()) continue;
+      if (! allscreens && t->getScreen() != this) continue;
+      if (! alldesktops && ! (t->desktop() == _active_desktop ||
+                              t->desktop() == 0xffffffff)) continue;
+      if (sameclass && ! classname.empty() &&
+          t->appClass() != classname) continue;
+      if (! t->canFocus()) continue;
+
+      // found a good window so break out of the while, and perhaps continue
+      // with the for loop
+      break;
     }
+  }
 
-    // must be no window to focus
-    if (target == first)
-      return;
-  } while ((*target)->iconic() ||
-           (! allscreens && (*target)->getScreen() != this) ||
-           (! alldesktops &&
-            (*target)->desktop() != _active_desktop &&
-            (*target)->desktop() != 0xffffffff) ||
-           (sameclass && ! classname.empty() &&
-            (*target)->appClass() != classname));
-  
-  if (target != _clients.end())
-    (*target)->focus();
+  // phew. we found the window, so focus it.
+  if (_stacked_cycling && state) {
+    if (!_cycling) {
+      // grab modifiers so we can intercept KeyReleases from them
+      grabModifiers();
+      _cycling = true;
+    }
+
+    // if the window is on another desktop, we can't use XSetInputFocus, since
+    // it doesn't imply a workspace change.
+    if (t->desktop() == _active_desktop || t->desktop() == 0xffffffff)
+      t->focus(false); // focus, but don't raise
+    else
+      t->focus(); // change workspace and focus
+  }  
+  else {
+    t->focus();
+  }
 }
 
 
-void screen::cycleWorkspace(const bool forward, const bool loop) const {
+void screen::cycleWorkspace(const bool forward, const int increment,
+                            const bool loop) const {
   assert(_managed);
+  assert(increment > 0);
 
   unsigned int destination = _active_desktop;
 
-  if (forward) {
-    if (destination < _num_desktops - 1)
-      ++destination;
-    else if (loop)
-      destination = 0;
-  } else {
-    if (destination > 0)
-      --destination;
-    else if (loop)
-      destination = _num_desktops - 1;
+  for (int x = 0; x < increment; ++x) {
+    if (forward) {
+      if (destination < _num_desktops - 1)
+        ++destination;
+      else if (loop)
+        destination = 0;
+    } else {
+      if (destination > 0)
+        --destination;
+      else if (loop)
+        destination = _num_desktops - 1;
+    }
   }
 
   if (destination != _active_desktop) 
@@ -552,6 +682,71 @@ void screen::changeWorkspace(const int num) const {
   _xatom->sendClientMessage(_root, XAtom::net_current_desktop, _root, num);
 }
 
+void screen::changeWorkspaceVert(const int num) const {
+  assert(_managed);
+  int width = 0;
+  int num_desktops = (signed)_num_desktops;
+  int active_desktop = (signed)_active_desktop;
+  int wnum = 0;
+
+  _config->getValue(Config::workspaceColumns, width);
+
+  if (width > num_desktops || width <= 0)
+    return;
+
+  // a cookie to the person that makes this pretty
+  if (num < 0) {
+    wnum = active_desktop - width;
+    if (wnum < 0) {
+      wnum = num_desktops/width * width + active_desktop;
+      if (wnum >= num_desktops)
+        wnum = num_desktops - 1;
+    }
+  }
+  else {
+    wnum = active_desktop + width;
+    if (wnum >= num_desktops) {
+      wnum = (active_desktop + width) % num_desktops - 1;
+      if (wnum < 0)
+        wnum = 0;
+    }
+  }
+  changeWorkspace(wnum);
+}
+
+void screen::changeWorkspaceHorz(const int num) const {
+  assert(_managed);
+  int width = 0;
+  int num_desktops = (signed)_num_desktops;
+  int active_desktop = (signed)_active_desktop;
+  int wnum = 0;
+
+  _config->getValue(Config::workspaceColumns, width);
+
+  if (width > num_desktops || width <= 0)
+    return;
+
+  if (num < 0) {
+    if (active_desktop % width != 0)
+      changeWorkspace(active_desktop - 1);
+    else {
+      wnum = active_desktop + width - 1;
+      if (wnum >= num_desktops)
+        wnum = num_desktops - 1;
+    }
+  }
+  else {
+    if (active_desktop % width != width - 1) {
+      wnum = active_desktop + 1;
+      if (wnum >= num_desktops)
+        wnum = num_desktops / width * width;
+    }
+    else
+      wnum = active_desktop - width + 1;
+  }
+  changeWorkspace(wnum);
+}
+
 void screen::grabKey(const KeyCode keyCode, const int modifierMask) const {
 
   Display *display = _epist->getXDisplay();
@@ -585,3 +780,50 @@ void screen::grabKey(const KeyCode keyCode, const int modifierMask) const {
            modifierMask|numlockMask|LockMask|scrolllockMask,
            _root, True, GrabModeAsync, GrabModeAsync);
 }
+
+void screen::ungrabKey(const KeyCode keyCode, const int modifierMask) const {
+
+  Display *display = _epist->getXDisplay();
+  int numlockMask, scrolllockMask;
+
+  _epist->getLockModifiers(numlockMask, scrolllockMask);
+
+  XUngrabKey(display, keyCode, modifierMask, _root);
+  XUngrabKey(display, keyCode, modifierMask|LockMask, _root);
+  XUngrabKey(display, keyCode, modifierMask|scrolllockMask, _root);
+  XUngrabKey(display, keyCode, modifierMask|numlockMask, _root);
+  XUngrabKey(display, keyCode, modifierMask|LockMask|scrolllockMask, _root);
+  XUngrabKey(display, keyCode, modifierMask|scrolllockMask|numlockMask, _root);
+  XUngrabKey(display, keyCode, modifierMask|numlockMask|LockMask, _root);
+  XUngrabKey(display, keyCode, modifierMask|numlockMask|LockMask|
+             scrolllockMask, _root);
+}
+
+
+void screen::grabModifiers() const {
+  Display *display = _epist->getXDisplay();
+
+  XGrabKeyboard(display, rootWindow(), True, GrabModeAsync,
+                GrabModeAsync, CurrentTime);
+}
+
+
+void screen::ungrabModifiers() const {
+  Display *display = _epist->getXDisplay();
+
+  XUngrabKeyboard(display, CurrentTime);
+}
+
+
+bool screen::nothingIsPressed(void) const
+{
+  char keys[32];
+  XQueryKeymap(_epist->getXDisplay(), keys);
+
+  for (int i = 0; i < 32; ++i) {
+    if (keys[i] != 0)
+      return false;
+  }
+
+  return true;
+}