Added error handler that catches the non-fatal BadAccess error, added a DestroyNotify blocker that waits for the window to be destroyed before actually shutting down, and now we're using SFML's way of detecting keyboard presses.

main.cpp

         double timei = double( time.tv_sec*1000000000L + time.tv_nsec )/1000000000.f;
         double starti = double( start.tv_sec*1000000000L + start.tv_nsec )/1000000000.f;
         if ( timei - starti > options->m_gracetime ) {
-            if ( xengine->m_keypressed ) {
+            if ( xengine->anyKeyPressed() && keyboard || xengine->mouseDown( 3 ) ) {
                 printf( "X=0\n" );
                 printf( "Y=0\n" );
                 printf( "W=0\n" );
                 state = -1;
                 running = false;
             }
-        } else {
-            xengine->m_keypressed = false;
-        }
-        if ( xengine->mouseDown( 3 ) ) {
-            printf( "X=0\n" );
-            printf( "Y=0\n" );
-            printf( "W=0\n" );
-            printf( "H=0\n" );
-            fprintf( stderr, "User right-clicked. Canceled selection.\n" );
-            state = -1;
-            running = false;
         }
         // Our adorable little state manager will handle what state we're in.
         switch ( state ) {
     xengine->releaseCursor();
     xengine->releaseKeyboard();
     // Try to process any last-second requests.
-    xengine->tick();
+    //xengine->tick();
     // Clean up global classes.
     delete xengine;
     delete options;
-    // Wait to make sure X11 cleans up our window before we end.
-    usleep( 100000 );
     // If we canceled the selection, return error.
     if ( state == -1 ) {
         return 1;

options.cpp

     m_red = 0;
     m_green = 0;
     m_blue = 0;
-    m_gracetime = 0.1;
+    m_gracetime = 0.3;
     m_keyboard = true;
 }
 
     printf( "\n" );
     printf( "options\n" );
     printf( "    -h, --help                     show this message.\n" );
-    printf( "    -nkb, --nokeyboard             don't try to grab the keyboard. This may fix problems with certain window managers.\n" );
+    printf( "    -nkb, --nokeyboard             disables the ability to cancel selections with the keyboard.\n" );
     printf( "    -b=INT, --bordersize=INT       set selection rectangle border size.\n" );
     printf( "    -p=INT, --padding=INT          set padding size for selection.\n" );
     printf( "    -t=INT, --tolerance=INT        if you have a shaky mouse, increasing this value will make slop detect single clicks better. Rather than interpreting your shaky clicks as region selections. Setting to zero will disable window selections.\n" );
     printf( "    -c=COLOR, --color=COLOR        set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT\n" );
     printf( "    -g=FLOAT, --gracetime=FLOAT    set the amount of time before slop will check for keyboard cancellations in seconds.\n" );
     printf( "examples\n" );
-    printf( "    slop -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5 -g=.2\n" );
+    printf( "    slop -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5 -g=.3\n" );
 }
 
 int slop::Options::parseOptions( int argc, char** argv ) {

x.cpp

 
 slop::XEngine* xengine = new slop::XEngine();
 
+static Bool isDestroyNotify( Display* dpy, XEvent* ev, XPointer win ) {
+    return ev->type == DestroyNotify && ev->xdestroywindow.window == *((Window*)win);
+}
+
+int slop::XEngineErrorHandler( Display* dpy, XErrorEvent* event ) {
+    // Ignore XGrabKeyboard BadAccess errors
+    // 31 = XGrabKeyboard's request code
+    if ( event->request_code == 31 && event->error_code == BadAccess ) {
+        return 0;
+    }
+    // Otherwise call the default error handler
+    return slop::OldXErrorHandler( dpy, event );
+}
+
 slop::XEngine::XEngine() {
-    m_keypressed = false;
     m_display = NULL;
     m_visual = NULL;
     m_screen = NULL;
     m_root      = DefaultRootWindow( m_display );
 
     m_good = true;
+    slop::OldXErrorHandler = XSetErrorHandler( slop::XEngineErrorHandler );
     return 0;
 }
 
+bool slop::XEngine::anyKeyPressed() {
+    if ( !m_good ) {
+        return false;
+    }
+    // Thanks to SFML for some reliable key state grabbing.
+    // Get the whole keyboard state
+    char keys[ 32 ];
+    XQueryKeymap( m_display, keys );
+    // Each bit indicates a different key, 1 for pressed, 0 otherwise.
+    // Every bit should be 0 if nothing is pressed.
+    for ( unsigned int i = 0; i < 32; i++ ) {
+        if ( keys[ i ] != 0 ) {
+            return true;
+        }
+    }
+    return false;
+}
+
 int slop::XEngine::grabKeyboard() {
     if ( !m_good ) {
         return 1;
     }
-    XGrabKey( m_display, AnyKey, AnyModifier, m_root, False, GrabModeAsync, GrabModeAsync );
-    // For whatever we fail to grab the keyboard 100% of the time if slop is launched in the background.
-    /*int err = XGrabKeyboard( m_display, m_root, False,
-                             GrabModeAsync, GrabModeAsync, CurrentTime );
-    if ( err != GrabSuccess ) {
-        fprintf( stderr, "Error: Failed to grab X keyboard.\n" );
-        fprintf( stderr, "This can be caused by launching slop incorrectly.\n" );
-        fprintf( stderr, "gnome-session launches it fine from keyboard binds.\n" );
-        return 1;
-    }*/
+    XGrabKeyboard( m_display, m_root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
     return 0;
 }
 
                 }
                 break;
             }
-            // For this particular utility, we only care if a key is pressed.
-            // I'm too lazy to implement an actual keyhandler for that.
+            // Due to X11 really hating applications grabbing the keyboard, we use XQueryKeymap to check for downed keys elsewhere.
             case KeyPress: {
-                m_keypressed = true;
                 break;
             }
-            // Since we also don't care if it's released, do nothing! yay
             case KeyRelease: {
-                //m_keypressed = false;
                 break;
             }
             default: break;
     }
     //XFreeColors( xengine->m_display, xengine->m_colormap, m_color.pixel, 1,
     // Attempt to move window offscreen before trying to remove it.
-    XResizeWindow( xengine->m_display, m_window, 1, 1 );
-    XMoveWindow( xengine->m_display, m_window, 0, 0 );
-    XUnmapWindow( xengine->m_display, m_window );
+    //XResizeWindow( xengine->m_display, m_window, 1, 1 );
+    //XMoveWindow( xengine->m_display, m_window, 0, 0 );
+    //XUnmapWindow( xengine->m_display, m_window );
     XDestroyWindow( xengine->m_display, m_window );
+    XEvent event;
+    // Block until the window is actually completely removed.
+    XIfEvent( xengine->m_display, &event, &isDestroyNotify, (XPointer)&m_window );
 }
 
 slop::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding, float r, float g, float b ) {
     attributes.override_redirect = True;
     // We must use our color map, because that's where our color is allocated.
     attributes.colormap = xengine->m_colormap;
-    unsigned long valueMask = CWBackPixmap | CWBackPixel | CWOverrideRedirect | CWColormap;
+    // Make sure we know when we've been successfully destroyed later!
+    attributes.event_mask = StructureNotifyMask;
+    unsigned long valueMask = CWBackPixmap | CWBackPixel | CWOverrideRedirect | CWColormap | CWEventMask;
 
     // Create the window offset by our generated offsets (see constrain( float, float ))
     m_window = XCreateWindow( xengine->m_display, xengine->m_root, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border, m_width+m_border*2, m_height+m_border*2,

x.hpp

 #include <X11/cursorfont.h>
 #include <X11/extensions/shape.h>
 
+#include <cstdlib>
 #include <cmath>
 #include <cstdio>
 #include <string>
     int                 init( std::string display );
     void                tick();
     int                 grabCursor( slop::CursorType type );
-    int                 grabKeyboard();
+    int                grabKeyboard();
+    bool                anyKeyPressed();
     int                 releaseCursor();
     int                 releaseKeyboard();
     void                setCursor( slop::CursorType type );
     Cursor              getCursor( slop::CursorType type );
 };
 
+int XEngineErrorHandler( Display* dpy, XErrorEvent* event );
+XErrorHandler OldXErrorHandler;
+
 }
 
 extern slop::XEngine* xengine;