Lots of changes here

Cleaned up code
Windows are now selected via EnterNotify events
Improved response time on rectangle drawing (no longer creates new rectangles when window selection changes, waits 0.01 seconds between re-drawing for xorg to catch up and display)
Removed offset settings as they seem useless
Added --version option
--nodecorations now doesn't attempt to actively search for the correct subwindow. Now it just allows for selection of subwindows. This should keep slop from crashing/not work properly on weird WMs like openbox, but may make it act a little unexpectedly since you can still click on decorations to include them.

README.md

 ```bash
 #!/bin/bash
 eval `slop`
-import -window root -crop "$W"x"$H"+$X+$Y ~/myimage.png
+import -window root -crop $G ~/myimage.png
 ```
 
 You can see my implementation of slop in a screenshooter here:
     -g=FLOAT, --gracetime=FLOAT    Set the amount of time before slop will check for keyboard cancellations
                                    in seconds.
     -nd, --nodecorations           attempts to remove decorations from window selections.
-    -o=GEOMETRY, --offset=GEOMETRY Offsets window selections, but only if --nodecorations is active and if the
-                                   window's decorations were successfully detected. Has a very specific use of
-                                   removing shadows from Gnome's window selections right now. GEOMETRY is in
-                                   format WxH+X+Y
+    -v, --version                  prints version.
 
 Examples
-    $ # gray, thick border for maximum visiblity.
+    $ # Gray, thick border for maximum visiblity.
     $ slop -b=20 -c=0.5,0.5,0.5
 
-    $ # Remove window decorations, but include the 28px titlebar. Useful to remove the arbitrarily sized shadows in Gnome where they are included in window geometry for whatever reason.
-    $ slop -nd -o=0x28+0-28
+    $ # Remove window decorations.
+    $ slop -nd
 
     $ # Disable window selections. Useful for selecting individual pixels.
     $ slop -t=0

main.cpp

 #include <unistd.h>
 #include <cstdio>
 #include "x.hpp"
+#include "rectangle.hpp"
 #include "options.hpp"
 
+void printSelection( bool cancelled, int x, int y, int w, int h ) {
+    printf( "X=%i\n", x );
+    printf( "Y=%i\n", y );
+    printf( "W=%i\n", w );
+    printf( "H=%i\n", h );
+    printf( "G=%ix%i", w, h );
+    if ( x >= 0 ) {
+        printf( "+%i", x );
+    } else {
+        // Negative is already included
+        printf( "%i", x );
+    }
+    if ( y >= 0 ) {
+        printf( "+%i", y );
+    } else {
+        // Negative is already included
+        printf( "%i", y );
+    }
+    printf( "\n" );
+    if ( cancelled ) {
+        printf( "Cancel=true\n" );
+    } else {
+        printf( "Cancel=false\n" );
+    }
+}
+
 int main( int argc, char** argv ) {
     int err = options->parseOptions( argc, argv );
     if ( err ) {
     int state = 0;
     bool running = true;
     slop::Rectangle* selection = NULL;
-    slop::Rectangle* windowselection = NULL;
     Window window = None;
     std::string xdisplay = options->m_xdisplay;
     int padding = options->m_padding;
     timespec start, time;
     int cx = 0;
     int cy = 0;
-    int cxoffset = 0;
-    int cyoffset = 0;
-    int woffset = 0;
-    int hoffset = 0;
+    int xmem = 0;
+    int ymem = 0;
+    int wmem = 0;
+    int hmem = 0;
 
     // First we set up the x interface and grab the mouse,
     // if we fail for either we exit immediately.
     err = xengine->init( xdisplay.c_str() );
     if ( err ) {
-        printf( "X=0\n" );
-        printf( "Y=0\n" );
-        printf( "W=0\n" );
-        printf( "H=0\n" );
+        printSelection( true, 0, 0, 0, 0 );
         return err;
     }
     err = xengine->grabCursor( slop::Cross );
     if ( err ) {
-        printf( "X=0\n" );
-        printf( "Y=0\n" );
-        printf( "W=0\n" );
-        printf( "H=0\n" );
+        printSelection( true, 0, 0, 0, 0 );
         return err;
     }
     if ( keyboard ) {
         err = xengine->grabKeyboard();
         if ( err ) {
-            printf( "X=0\n" );
-            printf( "Y=0\n" );
-            printf( "W=0\n" );
-            printf( "H=0\n" );
+            printSelection( true, 0, 0, 0, 0 );
             return err;
         }
     }
         double starti = double( start.tv_sec*1000000000L + start.tv_nsec )/1000000000.f;
         if ( timei - starti > options->m_gracetime ) {
             if ( xengine->anyKeyPressed() && keyboard || xengine->mouseDown( 3 ) ) {
-                printf( "X=0\n" );
-                printf( "Y=0\n" );
-                printf( "W=0\n" );
-                printf( "H=0\n" );
+                printSelection( true, 0, 0, 0, 0 );
                 fprintf( stderr, "User pressed key. Canceled selection.\n" );
                 state = -1;
                 running = false;
                 // create a rectangle around it so the user knows he/she can click on it.
                 // --but only if the user wants us to
                 if ( window != xengine->m_hoverWindow && tolerance > 0 ) {
-                    // Make sure to delete the old selection rectangle.
-                    if ( windowselection ) {
-                        xengine->removeRect( windowselection ); // removeRect also dealloc's the rectangle for us.
-                    }
                     slop::WindowRectangle t;
                     t.setGeometry( xengine->m_hoverWindow, decorations );
                     // Make sure we only apply offsets to windows that we've forcibly removed decorations on.
-                    if ( !t.m_decorations ) {
-                        windowselection = new slop::Rectangle( t.m_x + options->m_offsetx,
-                                                               t.m_y + options->m_offsety,
-                                                               t.m_width + options->m_offsetw,
-                                                               t.m_height + options->m_offseth,
-                                                               borderSize, padding,
-                                                               r, g, b );
+                    if ( !selection ) {
+                        selection = new slop::Rectangle( t.m_x,
+                                                         t.m_y,
+                                                         t.m_width,
+                                                         t.m_height,
+                                                         borderSize, padding,
+                                                         r, g, b );
                     } else {
-                        windowselection = new slop::Rectangle( t.m_x,
-                                                               t.m_y,
-                                                               t.m_width,
-                                                               t.m_height,
-                                                               borderSize, padding,
-                                                               r, g, b );
+                        selection->setGeo( t.m_x, t.m_y, t.m_width, t.m_height );
                     }
-                    xengine->addRect( windowselection );
                     window = xengine->m_hoverWindow;
                 }
-                // If the user clicked, remove the old selection rectangle and then
-                // move on to the next state.
+                // If the user clicked we move on to the next state.
                 if ( xengine->mouseDown( 1 ) ) {
-                    if ( windowselection ) {
-                        xengine->removeRect( windowselection );
-                    }
                     state++;
                 }
                 break;
                 // Set the mouse position of where we clicked, used so that click tolerance doesn't affect the rectangle's position.
                 cx = xengine->m_mousex;
                 cy = xengine->m_mousey;
+                // Also remember where the original selection was
+                if ( selection ) {
+                    xmem = selection->m_x;
+                    ymem = selection->m_y;
+                    wmem = selection->m_width;
+                    hmem = selection->m_height;
+                } else {
+                    xmem = cx;
+                    ymem = cy;
+                }
                 state++;
                 break;
             }
             case 2: {
+                // It's possible that our selection doesn't exist still, lets make sure it actually gets created here.
+                if ( !selection ) {
+                    selection = new slop::Rectangle( cx,
+                                                     cy,
+                                                     xengine->m_mousex - cx,
+                                                     xengine->m_mousey - cy,
+                                                     borderSize, padding,
+                                                     r, g, b );
+                }
                 // If the user has let go of the mouse button, we'll just
                 // continue to the next state.
                 if ( !xengine->mouseDown( 1 ) ) {
                     state++;
                     break;
                 }
-                // Check to make sure the user actually wants to drag for a selection before creating a rectangle.
+                // Check to make sure the user actually wants to drag for a selection before moving things around.
                 int w = xengine->m_mousex - cx;
                 int h = xengine->m_mousey - cy;
-                if ( ( std::abs( w ) >= tolerance || std::abs( h ) >= tolerance ) && !selection ) {
-                    selection = new slop::Rectangle( cx, cy, 0, 0, borderSize, padding, r, g, b );
-                    xengine->addRect( selection );
-                } else if ( !selection ) {
+                if ( ( std::abs( w ) < tolerance && std::abs( h ) < tolerance ) ) {
+                    // We make sure the selection rectangle stays on the window we had selected
+                    selection->setGeo( xmem, ymem, wmem, hmem );
+                    xengine->setCursor( slop::Left );
                     continue;
                 }
                 // We also detect which way the user is pulling and set the mouse icon accordingly.
-                // and offset the rectangle to be accurate, this is because the mouse actually selects a pixel up and to the left.
                 bool x = selection->m_flippedx;
                 bool y = selection->m_flippedy;
-                if ( !x && !y ) {
-                    cxoffset = 0;
-                    cyoffset = 0;
-                    woffset = 1;
-                    hoffset = 1;
+                if ( selection->m_width == 0 && selection->m_height == 0 ) {
+                    xengine->setCursor( slop::Cross );
+                } else if ( !x && !y ) {
                     xengine->setCursor( slop::LowerRightCorner );
                 } else if ( x && !y ) {
-                    cxoffset = 1;
-                    cyoffset = 0;
-                    woffset = -1;
-                    hoffset = 1;
                     xengine->setCursor( slop::LowerLeftCorner );
                 } else if ( !x && y ) {
-                    cxoffset = 0;
-                    cyoffset = 1;
-                    woffset = 1;
-                    hoffset = -1;
                     xengine->setCursor( slop::UpperRightCorner );
-                } else {
-                    cxoffset = 1;
-                    cyoffset = 1;
-                    woffset = -1;
-                    hoffset = -1;
+                } else if ( x && y ) {
                     xengine->setCursor( slop::UpperLeftCorner );
                 }
                 // Set the selection rectangle's dimensions to mouse movement.
                 // We use the function setDim since rectangles can't have negative widths,
                 // and because the rectangles have borders and padding to worry about.
-                selection->setPos( cx + cxoffset, cy + cyoffset );
-                selection->setDim( w + woffset, h + hoffset );
+                selection->setGeo( cx, cy, w, h );
                 break;
             }
             case 3: {
                 int x, y, w, h;
                 // Exit the utility after this state runs once.
                 running = false;
-                if ( selection ) {
-                    // We pull the dimensions and positions from the selection rectangle.
-                    // The selection rectangle automatically converts the positions and
-                    // dimensions to absolute coordinates when we set them earilier.
-                    x = selection->m_x+selection->m_xoffset;
-                    y = selection->m_y+selection->m_yoffset;
-                    w = selection->m_width;
-                    h = selection->m_height;
-                    // Delete the rectangle.
-                    xengine->removeRect( selection );
-                    // if we're not hovering over a window, or our selection is larger than our tolerance
-                    // just print the selection.
-                    if ( w >= tolerance || h >= tolerance || xengine->m_hoverWindow == None ) {
-                        printf( "X=%i\n", x );
-                        printf( "Y=%i\n", y );
-                        printf( "W=%i\n", w );
-                        printf( "H=%i\n", h );
-                        break;
-                    }
-                }
-                // Otherwise lets grab the window's dimensions and use those (with padding).
-                // --but only if the user lets us, if the user doesn't just select a single pixel there.
-                if ( tolerance > 0 ) {
-                    slop::WindowRectangle t;
-                    t.setGeometry( xengine->m_hoverWindow, decorations );
-                    // Make sure we only apply offsets to windows that we've forcibly removed decorations on.
-                    if ( !t.m_decorations ) {
-                        x = t.m_x - padding + options->m_offsetx;
-                        y = t.m_y - padding + options->m_offsety;
-                        w = t.m_width + padding * 2 + options->m_offsetw;
-                        h = t.m_height + padding * 2 + options->m_offseth;
-                    } else {
-                        x = t.m_x - padding;
-                        y = t.m_y - padding;
-                        w = t.m_width + padding * 2;
-                        h = t.m_height + padding * 2;
-                    }
-                } else {
-                    x = cx;
-                    y = cy;
-                    w = 1;
-                    h = 1;
-                }
-                printf( "X=%i\n", x );
-                printf( "Y=%i\n", y );
-                printf( "W=%i\n", w );
-                printf( "H=%i\n", h );
+                // We pull the dimensions and positions from the selection rectangle.
+                // The selection rectangle automatically converts the positions and
+                // dimensions to absolute coordinates when we set them earilier.
+                x = selection->m_x+selection->m_xoffset;
+                y = selection->m_y+selection->m_yoffset;
+                w = selection->m_width;
+                h = selection->m_height;
+                // Delete the rectangle, which will remove it from the screen.
+                delete selection;
+                // Print the selection :)
+                printSelection( false, x, y, w, h );
                 break;
             }
         }
-        // No need to max out CPU
-        // FIXME: This could be adjusted to measure how much time has passed,
-        // we may very well need to max out the CPU if someone has a really- really
-        // bad computer.
-        usleep( 1000 );
+        // This sleep is required because drawing the rectangles is a very expensive task that acts really weird with Xorg when called as fast as possible.
+        // 0.01 seconds
+        usleep( 10000 );
     }
     xengine->releaseCursor();
     xengine->releaseKeyboard();

options.cpp

 slop::Options* options = new slop::Options();
 
 slop::Options::Options() {
+    m_version = "2.0.0";
     m_borderSize = 10;
     m_padding = 0;
     m_xdisplay = ":0";
     m_red = 0;
     m_green = 0;
     m_blue = 0;
-    m_gracetime = 0.3;
+    m_gracetime = 0.4;
     m_keyboard = true;
     m_decorations = true;
-    m_offsetx = 0;
-    m_offsety = 0;
-    m_offsetw = 0;
-    m_offseth = 0;
 }
 
 void slop::Options::printHelp() {
     printf( "    -g=FLOAT, --gracetime=FLOAT    Set the amount of time before slop will check for keyboard cancellations\n" );
     printf( "                                   in seconds.\n" );
     printf( "    -nd, --nodecorations           attempts to remove decorations from window selections.\n" );
-    printf( "    -o=GEOMETRY, --offset=GEOMETRY Offsets window selections, but only if --nodecorations is active and if the\n" );
-    printf( "                                   window's decorations were successfully detected. Has a very specific use of\n" );
-    printf( "                                   removing shadows from Gnome's window selections right now. GEOMETRY is in\n" );
-    printf( "                                   format WxH+X+Y\n" );
+    printf( "    -v, --version                  prints version.\n" );
     printf( "\n" );
     printf( "Examples\n" );
-    printf( "    $ # gray, thick border for maximum visiblity.\n" );
+    printf( "    $ # Gray, thick border for maximum visiblity.\n" );
     printf( "    $ slop -b=20 -c=0.5,0.5,0.5\n" );
     printf( "\n" );
-    printf( "    $ # Remove window decorations, but include the 28px titlebar. Useful to remove the arbitrarily sized shadows in Gnome where they are included in window geometry for whatever reason.\n" );
-    printf( "    $ slop -nd -o=0x28+0-28\n" );
+    printf( "    $ # Remove window decorations.\n" );
+    printf( "    $ slop -nd\n" );
     printf( "\n" );
     printf( "    $ # Disable window selections. Useful for selecting individual pixels.\n" );
     printf( "    $ slop -t=0\n" );
             if ( m_borderSize < 0 ) {
                 m_borderSize = 0;
             }
-        } else if ( matches( arg, "-o=", "--offset=" ) ) {
-            int err = parseGeometry( arg, &m_offsetx, &m_offsety, &m_offsetw, &m_offseth );
-            if ( err ) {
-                return 1;
-            }
         } else if ( matches( arg, "-p=", "--padding=" ) ) {
             int err = parseInt( arg, &m_padding );
             if ( err ) {
         } else if ( matches( arg, "-h", "--help" ) ) {
             printHelp();
             return 2;
+        } else if ( matches( arg, "-v", "--version" ) ) {
+            printf( "slop %s\n", m_version.c_str() );
+            return 2;
         } else {
             if ( i == 0 ) {
                 continue;

options.hpp

     int         parseOptions( int argc, char** argv );
     void        printHelp();
 
+    std::string m_version;
     int         m_borderSize;
     int         m_padding;
     int         m_tolerance;
     float       m_gracetime;
     bool        m_keyboard;
     bool        m_decorations;
-    int         m_offsetx;
-    int         m_offsety;
-    int         m_offsetw;
-    int         m_offseth;
 private:
     int         parseInt( std::string arg, int* returnInt );
     int         parseFloat( std::string arg, float* returnFloat );

rectangle.cpp

+#include "rectangle.hpp"
+
+static Bool isDestroyNotify( Display* dpy, XEvent* ev, XPointer win ) {
+    return ev->type == DestroyNotify && ev->xdestroywindow.window == *((Window*)win);
+}
+
+slop::Rectangle::~Rectangle() {
+    if ( m_window == None ) {
+        return;
+    }
+    // Free up our color.
+    XFreeColors( xengine->m_display, xengine->m_colormap, &m_color.pixel, 1, 0 );
+    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 ) {
+    m_xoffset = 0;
+    m_yoffset = 0;
+    m_x = x;
+    m_y = y;
+    m_width = width;
+    m_height = height;
+    m_border = border;
+    m_padding = padding;
+    m_window = None;
+
+    // Convert the width, height, x, and y to coordinates that don't have negative values.
+    // (also adjust for padding and border size.)
+    constrain( width, height );
+    // If we don't have a border, we don't exist, so just die.
+    if ( m_border == 0 ) {
+        return;
+    }
+
+    // This sets up m_color
+    int err = convertColor( r, g, b );
+    if ( err ) {
+        fprintf( stderr, "Couldn't allocate color of value %f,%f,%f!\n", r, g, b );
+    }
+    XSetWindowAttributes attributes;
+    // Set up the window so it's our color 
+    attributes.background_pixmap = None;
+    attributes.background_pixel = m_color.pixel;
+    // Not actually sure what this does, but it keeps the window from bugging out :u.
+    attributes.override_redirect = True;
+    // We must use our color map, because that's where our color is allocated.
+    attributes.colormap = xengine->m_colormap;
+    // 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,
+                              0, CopyFromParent, InputOutput,
+                              CopyFromParent, valueMask, &attributes );
+
+    // Now punch a hole into it so it looks like a selection rectangle!
+    XRectangle rect;
+    rect.x = rect.y = m_border;
+    rect.width = m_width;
+    rect.height = m_height;
+
+    XClassHint classhints;
+    char name[] = "slop";
+    classhints.res_name = name;
+    classhints.res_class = name;
+    XSetClassHint( xengine->m_display, m_window, &classhints );
+
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
+    XMapWindow( xengine->m_display, m_window );
+}
+
+void slop::Rectangle::setPos( int x, int y ) {
+    if ( m_x == x && m_y == y ) {
+        return;
+    }
+    m_x = x;
+    m_y = y;
+    // If we don't have a border, we don't exist, so just die.
+    if ( m_border == 0 ) {
+        return;
+    }
+    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
+}
+
+void slop::Rectangle::setDim( int w, int h ) {
+    if ( m_width == w && m_height == h ) {
+        return;
+    }
+
+    constrain( w, h );
+    // If we don't have a border, we don't exist, so just die.
+    if ( m_border == 0 ) {
+        return;
+    }
+
+    // Change the window size and location to our generated offsets (see constrain( float, float ))
+    XResizeWindow( xengine->m_display, m_window, m_width+m_border*2, m_height+m_border*2 );
+    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
+    // Regenerate our hole
+    XRectangle rect;
+    rect.x = rect.y = 0;
+    rect.width = m_width+m_border*2;
+    rect.height = m_height+m_border*2;
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
+    // Then punch out another.
+    rect.x = rect.y = m_border;
+    rect.width = m_width;
+    rect.height = m_height;
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
+}
+
+void slop::Rectangle::setGeo( int x, int y, int w, int h ) {
+    if ( m_x == x && m_y == y && m_width == w && m_height == h ) {
+        return;
+    }
+
+    m_x = x;
+    m_y = y;
+    constrain( w, h );
+    // If we don't have a border, we don't exist, so just die.
+    if ( m_border == 0 ) {
+        return;
+    }
+
+    // Change the window size and location to our generated offsets (see constrain( float, float ))
+    XResizeWindow( xengine->m_display, m_window, m_width+m_border*2, m_height+m_border*2 );
+    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
+    // Regenerate our hole
+    XRectangle rect;
+    rect.x = rect.y = 0;
+    rect.width = m_width+m_border*2;
+    rect.height = m_height+m_border*2;
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
+    // Then punch out another.
+    rect.x = rect.y = m_border;
+    rect.width = m_width;
+    rect.height = m_height;
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
+}
+
+// Keeps our rectangle's sizes all positive, so Xlib doesn't throw an exception.
+// It also keeps our values in absolute coordinates which is nice.
+void slop::Rectangle::constrain( int w, int h ) {
+    int pad = m_padding;
+    if ( pad < 0 && std::abs( w ) < std::abs( pad ) * 2 ) {
+        pad = 0;
+    }
+    if ( w < 0 ) {
+        m_flippedx = true;
+        m_xoffset = w - pad;
+        m_width = -w + pad * 2;
+    } else {
+        m_flippedx = false;
+        m_xoffset = -pad;
+        m_width = w + pad * 2;
+    }
+
+    pad = m_padding;
+    if ( pad < 0 && std::abs( h ) < std::abs( pad ) * 2 ) {
+        pad = 0;
+    }
+    if ( h < 0 ) {
+        m_flippedy = true;
+        m_yoffset = h - pad;
+        m_height = -h + pad * 2;
+    } else {
+        m_flippedy = false;
+        m_yoffset = -pad;
+        m_height = h + pad * 2;
+    }
+}
+
+int slop::Rectangle::convertColor( float r, float g, float b ) {
+    // Convert float colors to shorts.
+    short red   = short( floor( r * 65535.f ) );
+    short green = short( floor( g * 65535.f ) );
+    short blue  = short( floor( b * 65535.f ) );
+    XColor color;
+    color.red = red;
+    color.green = green;
+    color.blue = blue;
+    int err = XAllocColor( xengine->m_display, xengine->m_colormap, &color );
+    if ( err == BadColor ) {
+        return err;
+    }
+    m_color = color;
+    return 0;
+}

rectangle.hpp

+// rectangle.hpp: handles creating rectangles on screen.
+
+#ifndef IS_RECTANGLE_H_
+#define IS_RECTANGLE_H_
+
+#include "x.hpp"
+
+#include <unistd.h>
+
+#include <X11/Xlib.h>
+#include <X11/extensions/shape.h>
+
+#include <cstdlib>
+#include <cmath>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+namespace slop {
+
+class Rectangle {
+public:
+            Rectangle( int x, int y, int width, int height, int border, int padding, float r, float g, float b );
+            ~Rectangle();
+    void    setPos( int x, int y );
+    void    setDim( int w, int h );
+    void    setGeo( int x, int y, int w, int h );
+    Window  m_window;
+    XColor  m_color;
+    int     m_x;
+    int     m_y;
+    int     m_xoffset;
+    int     m_yoffset;
+    int     m_width;
+    int     m_height;
+    int     m_border;
+    int     m_padding;
+    bool    m_flippedx;
+    bool    m_flippedy;
+private:
+    int     convertColor( float r, float g, float b );
+    void    constrain( int w, int h );
+};
+
+}
+
+#endif // IS_RECTANGLE_H_

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, we can work without it.
     // 31 = XGrabKeyboard's request code
     if ( event->request_code == 31 && event->error_code == BadAccess ) {
+        fprintf( stderr, "_X Error \"BadAccess\" for XGrabKeyboard ignored...\n" );
         return 0;
     }
     // Everything else should be fatal as I don't like undefined behavior.
             XFreeCursor( m_display, m_cursors[i] );
         }
     }
-    for ( unsigned int i=0; i<m_rects.size(); i++ ) {
-        delete m_rects.at( i );
-    }
     XCloseDisplay( m_display );
 }
 
-// We need to keep track of the rectangle windows, so that they don't override our "focus"d windows.
-void slop::XEngine::addRect( Rectangle* rect ) {
-    m_rects.push_back( rect );
-}
-
-void slop::XEngine::removeRect( Rectangle* rect ) {
-    for ( unsigned int i=0; i<m_rects.size(); i++ ) {
-        if ( m_rects.at( i ) == rect ) {
-            m_rects.erase( m_rects.begin() + i );
-            i--;
-            delete rect;
-            return;
-        }
-    }
-}
-
 bool slop::XEngine::mouseDown( unsigned int button ) {
     if ( button >= m_mouse.size() ) {
         return false;
 
     m_good = true;
     XSetErrorHandler( slop::XEngineErrorHandler );
+    selectAllInputs( m_root, EnterWindowMask );
     return 0;
 }
 
     if ( !m_good ) {
         return 1;
     }
-    XGrabKeyboard( m_display, m_root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
+    int err = XGrabKeyboard( m_display, m_root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
+    if ( err != GrabSuccess ) {
+        fprintf( stderr, "Warning: Failed to grab X keyboard.\n" );
+        fprintf( stderr, "         This happens when something's already grabbed your keybaord.\n" );
+        fprintf( stderr, "         slop should still run properly though.\n" );
+        return 1;
+    }
     return 0;
 }
 
     return 0;
 }
 
+void slop::XEngine::selectAllInputs( Window win, long event_mask) {
+    Window root, parent;
+    Window* children;
+    unsigned int nchildren;
+    XQueryTree( m_display, win, &root, &parent, &children, &nchildren );
+    for ( unsigned int i=0;i<nchildren;i++ ) {
+        XSelectInput( m_display, children[ i ], event_mask );
+        selectAllInputs( children[ i ], event_mask );
+    }
+}
+
 // Grabs the cursor, be wary that setCursor changes the mouse masks.
 int slop::XEngine::grabCursor( slop::CursorType type ) {
     if ( !m_good ) {
         return 1;
     }
     int xfontcursor = getCursor( type );
-    int err = XGrabPointer( m_display, m_root, False,
-                            PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
-                            GrabModeAsync, GrabModeAsync, m_root, xfontcursor, CurrentTime );
+    int err = XGrabPointer( m_display, m_root, True,
+                            PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask,
+                            GrabModeAsync, GrabModeAsync, None, xfontcursor, CurrentTime );
     if ( err != GrabSuccess ) {
         fprintf( stderr, "Error: Failed to grab X cursor.\n" );
-        fprintf( stderr, "This can be caused by launching slop incorrectly.\n" );
-        fprintf( stderr, "gnome-session launches it fine from keyboard binds.\n" );
+        fprintf( stderr, "       This can be caused by launching slop weirdly.\n" );
         return 1;
     }
-
     // Quickly set the mouse position so we don't have to worry about x11 generating an event.
     Window root, child;
     int mx, my;
     m_mousex = mx;
     m_mousey = my;
 
-    // Oh and while we're at it, make sure we set the window we're hoving over as well.
-    updateHoverWindow( child );
+    // Get the deepest available window.
+    Window test = child;
+    while( test ) {
+        child = test;
+        XQueryPointer( m_display, child, &root, &test, &mx, &my, &wx, &wy, &mask );
+    }
+    m_hoverWindow = child;
     return 0;
 }
 
                 }
                 break;
             }
+            case EnterNotify: {
+                if ( event.xcrossing.subwindow != None ) {
+                    m_hoverWindow = event.xcrossing.subwindow;
+                } else {
+                    m_hoverWindow = event.xcrossing.window;
+                }
+                break;
+            }
+            case LeaveNotify: {
+                break;
+            }
             case ButtonRelease: {
                 if ( m_mouse.size() > event.xbutton.button ) {
                     m_mouse.at( event.xbutton.button ) = false;
             default: break;
         }
     }
-
-    // Since I couldn't get Xlib to send EnterNotify or LeaveNotify events, we need to query the underlying window every frame.
-    updateHoverWindow();
 }
 
 // This converts an enum into a preallocated cursor, the cursor will automatically deallocate itself on ~XEngine
 }
 
 void slop::WindowRectangle::setGeometry( Window win, bool decorations ) {
-    Window junk;
     if ( decorations ) {
+        Window root, parent, test, junk;
+        Window* childlist;
+        unsigned int ujunk;
         unsigned int depth;
-        XGetGeometry( xengine->m_display, win, &junk,
-                      &(m_x), &(m_y),
-                      &(m_width), &(m_height),
-                      &(m_border), &depth );
-        // We make sure we include borders, since we want decorations.
-        m_width += m_border * 2;
-        m_height += m_border * 2;
-        m_decorations = true;
+        // Try to find the actual decorations.
+        test = win;
+        int status = XQueryTree( xengine->m_display, test, &root, &parent, &childlist, &ujunk);
+        while( parent != root ) {
+            if ( !parent || !status ) {
+                break;
+            }
+            test = parent;
+            status = XQueryTree( xengine->m_display, test, &root, &parent, &childlist, &ujunk);
+        }
+        // Once found, proceed normally.
+        if ( test && parent == root && status ) {
+            XWindowAttributes attr;
+            XGetWindowAttributes( xengine->m_display, test, &attr );
+            m_width = attr.width;
+            m_height = attr.height;
+            m_border = attr.border_width;
+            XTranslateCoordinates( xengine->m_display, test, attr.root, -attr.border_width, -attr.border_width, &(m_x), &(m_y), &junk );
+            // We make sure we include borders, since we want decorations.
+            m_width += m_border * 2;
+            m_height += m_border * 2;
+        }
         return;
     }
-    Window root;
-    Window* children = NULL;
-    unsigned int childcount;
-    // Try to get the first child of the specified window, to avoid decorations.
-    XQueryTree( xengine->m_display, win, &root, &junk, &children, &childcount );
-    if ( childcount == 1 && children ) {
-        win = children[ 0 ];
-        m_decorations = false;
-    } else {
-        //fprintf( stderr, "Warning: slop couldn't determine how to remove decorations, continuing without removing decorations...\n" );
-        m_decorations = true;
-    }
+    Window junk;
+    // Now here we should be able to just use whatever we get.
     XWindowAttributes attr;
     // We use XGetWindowAttributes to know our root window.
     XGetWindowAttributes( xengine->m_display, win, &attr );
     m_border = attr.border_width;
     XTranslateCoordinates( xengine->m_display, win, attr.root, -attr.border_width, -attr.border_width, &(m_x), &(m_y), &junk );
 }
-
-slop::Rectangle::~Rectangle() {
-    //XFreeGC( xengine->m_display, m_gc );
-    if ( m_window == None ) {
-        return;
-    }
-    //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 );
-    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 ) {
-    m_xoffset = 0;
-    m_yoffset = 0;
-    m_x = x;
-    m_y = y;
-    m_width = width;
-    m_height = height;
-    m_border = border;
-    m_padding = padding;
-    m_window = None;
-
-    // Convert the width, height, x, and y to coordinates that don't have negative values.
-    // (also adjust for padding and border size.)
-    constrain( width, height );
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
-
-    // This sets up m_color
-    int err = convertColor( r, g, b );
-    if ( err ) {
-        fprintf( stderr, "Couldn't allocate color of value %f,%f,%f!\n", r, g, b );
-    }
-    XSetWindowAttributes attributes;
-    // Set up the window so it's our color 
-    attributes.background_pixmap = None;
-    attributes.background_pixel = m_color.pixel;
-    // Not actually sure what this does, but it keeps the window from bugging out :u.
-    attributes.override_redirect = True;
-    // We must use our color map, because that's where our color is allocated.
-    attributes.colormap = xengine->m_colormap;
-    // 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,
-                              0, CopyFromParent, InputOutput,
-                              CopyFromParent, valueMask, &attributes );
-
-    // Now punch a hole into it so it looks like a selection rectangle!
-    XRectangle rect;
-    rect.x = rect.y = m_border;
-    rect.width = m_width;
-    rect.height = m_height;
-
-    XClassHint classhints;
-    char name[] = "slop";
-    classhints.res_name = name;
-    classhints.res_class = name;
-    XSetClassHint( xengine->m_display, m_window, &classhints );
-
-    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
-    XMapWindow( xengine->m_display, m_window );
-}
-
-void slop::Rectangle::setPos( int x, int y ) {
-    if ( m_x == x && m_y == y ) {
-        return;
-    }
-    m_x = x;
-    m_y = y;
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
-    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
-}
-
-void slop::Rectangle::setDim( int w, int h ) {
-    if ( m_width == w && m_height == h ) {
-        return;
-    }
-
-    constrain( w, h );
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
-
-    // Change the window size and location to our generated offsets (see constrain( float, float ))
-    XResizeWindow( xengine->m_display, m_window, m_width+m_border*2, m_height+m_border*2 );
-    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
-    // Regenerate our hole
-    XRectangle rect;
-    rect.x = rect.y = 0;
-    rect.width = m_width+m_border*2;
-    rect.height = m_height+m_border*2;
-    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
-    // Then punch out another.
-    rect.x = rect.y = m_border;
-    rect.width = m_width;
-    rect.height = m_height;
-    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
-}
-
-void slop::XEngine::updateHoverWindow() {
-    Window root, hoverwin;
-    int mx, my;
-    int wx, wy;
-    unsigned int mask;
-    // Query the pointer for the child window, the child window is basically the window we're hovering over.
-    XQueryPointer( m_display, m_root, &root, &hoverwin, &mx, &my, &wx, &wy, &mask );
-    // If we already know that we're hovering over it, do nothing.
-    if ( m_hoverWindow == hoverwin ) {
-        return;
-    }
-    // Make sure we can't select one of our selection rectangles, that's just weird.
-    for ( unsigned int i=0; i<m_rects.size(); i++ ) {
-        if ( m_rects.at( i )->m_window == hoverwin ) {
-            return;
-        }
-    }
-    m_hoverWindow = hoverwin;
-}
-
-void slop::XEngine::updateHoverWindow( Window hoverwin ) {
-    // Same thing as updateHoverWindow but it uses the specified child.
-    // It's used when we first grab the cursor so it's slightly more effecient
-    // than calling XQueryPointer twice.
-    if ( m_hoverWindow == hoverwin ) {
-        return;
-    }
-    for ( unsigned int i=0; i<m_rects.size(); i++ ) {
-        if ( m_rects.at( i )->m_window == hoverwin ) {
-            return;
-        }
-    }
-    m_hoverWindow = hoverwin;
-}
-
-// Keeps our rectangle's sizes all positive, so Xlib doesn't throw an exception.
-// It also keeps our values in absolute coordinates which is nice.
-void slop::Rectangle::constrain( int w, int h ) {
-    int pad = m_padding;
-    if ( pad < 0 && std::abs( w ) < std::abs( pad )*2 ) {
-        pad = 0;
-    }
-    if ( w < 0 ) {
-        m_flippedx = true;
-        m_xoffset = w - pad;
-        m_width = -w + pad*2;
-    } else {
-        m_flippedx = false;
-        m_xoffset = -pad;
-        m_width = w + pad*2;
-    }
-
-    pad = m_padding;
-    if ( pad < 0 && std::abs( h ) < std::abs( pad )*2 ) {
-        pad = 0;
-    }
-    if ( h < 0 ) {
-        m_flippedy = true;
-        m_yoffset = h - pad;
-        m_height = -h + pad*2;
-    } else {
-        m_flippedy = false;
-        m_yoffset = -pad;
-        m_height = h + pad*2;
-    }
-}
-
-int slop::Rectangle::convertColor( float r, float g, float b ) {
-    // Convert float colors to shorts.
-    short red   = short( floor( r * 65535.f ) );
-    short green = short( floor( g * 65535.f ) );
-    short blue  = short( floor( b * 65535.f ) );
-    XColor color;
-    color.red = red;
-    color.green = green;
-    color.blue = blue;
-    // I don't deallocate this anywhere, I think X handles it ???
-    int err = XAllocColor( xengine->m_display, xengine->m_colormap, &color );
-    if ( err == BadColor ) {
-        return err;
-    }
-    m_color = color;
-    return 0;
-}

x.hpp

     void         setGeometry( Window win, bool decorations );
 };
 
-class Rectangle {
-public:
-            Rectangle( int x, int y, int width, int height, int border, int padding, float r, float g, float b );
-            ~Rectangle();
-    void    setPos( int x, int y );
-    void    setDim( int w, int h );
-    Window  m_window;
-    int     m_x;
-    int     m_y;
-    int     m_xoffset;
-    int     m_yoffset;
-    int     m_width;
-    int     m_height;
-    int     m_border;
-    int     m_padding;
-    XColor  m_color;
-    bool    m_flippedx;
-    bool    m_flippedy;
-private:
-    int     convertColor( float r, float g, float b );
-    void    constrain( int w, int h );
-};
-
 class XEngine {
 public:
                         XEngine();
     int                 releaseKeyboard();
     void                setCursor( slop::CursorType type );
     void                drawRect( int x, int y, unsigned int w, unsigned int h );
-    void                addRect( Rectangle* rect );
-    void                removeRect( Rectangle* rect );
+    int                 m_mousex;
+    int                 m_mousey;
     Display*            m_display;
     Visual*             m_visual;
     Screen*             m_screen;
     Colormap            m_colormap;
     Window              m_root;
-    int                 m_mousex;
-    int                 m_mousey;
+    Window              m_hoverWindow;
     std::vector<bool>   m_mouse;
     bool                mouseDown( unsigned int button );
-    Window              m_hoverWindow;
     bool                m_keypressed;
 private:
-    void                updateHoverWindow();
-    void                updateHoverWindow( Window child );
     bool                m_good;
     std::vector<Cursor> m_cursors;
-    std::vector<Rectangle*> m_rects;
     Cursor              getCursor( slop::CursorType type );
+    void                selectAllInputs( Window win, long event_mask);
 };
 
 int XEngineErrorHandler( Display* dpy, XErrorEvent* event );