Added highlight feature, and now events fall through slop windows.

README.md

     -t=INT, --tolerance=INT        How far in pixels the mouse can move after clicking and still be detected
                                    as a normal click. Setting to zero will disable window selections.
     -x=STRING, --xdisplay=STRING   Set x display (STRING must be hostname:number.screen_number format)
-    -c=COLOR, --color=COLOR        Set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT,FLOAT
+    -c=COLOR, --color=COLOR        Set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT,FLOAT.
+                                   takes RGBA or RGB.
     -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.
-    -min=INT, --minimumsize=INT    sets the minimum output of width or height values, useful to avoid outputting 0
-    -max=INT, --maximumsize=INT    sets the maximum output of width or height values.
+    -nd, --nodecorations           Attempts to remove decorations from window selections.
+    -min=INT, --minimumsize=INT    Sets the minimum output of width or height values, useful to avoid outputting 0
+    -max=INT, --maximumsize=INT    Sets the maximum output of width or height values.
                                    widths or heights.
+    -hi, --highlight               Instead of outlining the selection, slop highlights it. Only useful when
+                                   used with a --color with an alpha under 1.
     -v, --version                  prints version.
 
 Examples
 
     $ # Disable window selections. Useful for selecting individual pixels.
     $ slop -t=0
+
+    $ # Classic Windows XP selection.
+    $ slop -hi -c=0.2,0.4,0.5,0.4
 ```

main.cpp

     float g = options->m_green;
     float b = options->m_blue;
     float a = options->m_alpha;
+    bool highlight = options->m_highlight;
     bool keyboard = options->m_keyboard;
     bool decorations = options->m_decorations;
     timespec start, time;
                                                          t.m_x + t.m_width,
                                                          t.m_y + t.m_height,
                                                          borderSize,
+                                                         highlight,
                                                          r, g, b, a );
                     } else {
                         selection->setGeo( t.m_x, t.m_y, t.m_x + t.m_width, t.m_y + t.m_height );
                                                      xengine->m_mousex + 1,
                                                      xengine->m_mousey + 1,
                                                      borderSize,
+                                                     highlight,
                                                      r, g, b, a );
                 }
                 // If the user has let go of the mouse button, we'll just

options.cpp

 slop::Options* options = new slop::Options();
 
 slop::Options::Options() {
-    m_version = "v2.0.8";
+    m_version = "v2.0.9";
+    m_highlight = false;
     m_borderSize = 10;
     m_padding = 0;
     m_xdisplay = ":0";
     printf( "    -t=INT, --tolerance=INT        How far in pixels the mouse can move after clicking and still be detected\n" );
     printf( "                                   as a normal click. Setting to zero will disable window selections.\n" );
     printf( "    -x=STRING, --xdisplay=STRING   Set x display (STRING must be hostname:number.screen_number format)\n" );
-    printf( "    -c=COLOR, --color=COLOR        Set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT,FLOAT\n" );
+    printf( "    -c=COLOR, --color=COLOR        Set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT,FLOAT.\n" );
+    printf( "                                   takes RGBA or RGB.\n" );
     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( "    -min=INT, --minimumsize=INT    sets the minimum output of width or height values, useful to avoid outputting 0\n" );
-    printf( "    -max=INT, --maximumsize=INT    sets the maximum output of width or height values.\n" );
+    printf( "    -nd, --nodecorations           Attempts to remove decorations from window selections.\n" );
+    printf( "    -min=INT, --minimumsize=INT    Sets the minimum output of width or height values, useful to avoid outputting 0\n" );
+    printf( "    -max=INT, --maximumsize=INT    Sets the maximum output of width or height values.\n" );
     printf( "                                   widths or heights.\n" );
+    printf( "    -hi, --highlight               Instead of outlining the selection, slop highlights it. Only useful when\n" );
+    printf( "                                   used with a --color with an alpha under 1.\n" );
     printf( "    -v, --version                  prints version.\n" );
     printf( "\n" );
     printf( "Examples\n" );
     printf( "\n" );
     printf( "    $ # Disable window selections. Useful for selecting individual pixels.\n" );
     printf( "    $ slop -t=0\n" );
+    printf( "\n" );
+    printf( "    $ # Classic Windows XP selection.\n" );
+    printf( "    $ slop -hi -c=0.2,0.4,0.5,0.4\n" );
 }
 
 int slop::Options::parseOptions( int argc, char** argv ) {
             m_keyboard = false;
         } else if ( matches( arg, "-nd", "--nodecorations" ) ) {
             m_decorations = false;
+        } else if ( matches( arg, "-hi", "--highlight" ) ) {
+            m_highlight = true;
         } else if ( matches( arg, "-h", "--help" ) ) {
             printHelp();
             return 2;

options.hpp

     float       m_gracetime;
     bool        m_keyboard;
     bool        m_decorations;
+    bool        m_highlight;
 private:
     int         parseInt( std::string arg, int* returnInt );
     int         parseFloat( std::string arg, float* returnFloat );

rectangle.cpp

     usleep( 10000 );
 }
 
-slop::Rectangle::Rectangle( int sx, int sy, int ex, int ey, int border, float r, float g, float b, float a ) {
+slop::Rectangle::Rectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a ) {
     m_x = std::min( sx, ex );
     m_y = std::min( sy, ey );
     m_width = std::max( sx, ex ) - m_x;
     m_height = std::max( sy, ey ) - m_y;
     m_border = border;
     m_window = None;
+    m_highlight = highlight;
 
     // If we don't have a border, we don't exist, so just die.
     if ( m_border == 0 ) {
         return;
     }
 
+    if ( m_highlight ) {
+        m_border = 0;
+    }
+
     // This sets up m_color
     int err = convertColor( r, g, b );
     if ( err ) {
                          XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&cardinal_alpha, 1 );
     }
 
-    // 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);
+    // Now punch a hole into it so it looks like a selection rectangle, but only if we're not highlighting.
+    if ( !m_highlight ) {
+        XRectangle rect;
+        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);
+    }
+    // Make it so all input falls through
+    XRectangle rect;
+    rect.x = rect.y = rect.width = rect.height = 0;
+    XShapeCombineRectangles( xengine->m_display, m_window, ShapeInput, 0, 0, &rect, 1, ShapeSet, 0);
     XMapWindow( xengine->m_display, m_window );
 }
 
     m_y = y;
     m_width = w;
     m_height = h;
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
 
     // Change the window size
     XResizeWindow( xengine->m_display, m_window, m_width+m_border*2, m_height+m_border*2 );
-    // Fill up our old 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);
+    if ( m_border > 0 ) {
+        // Fill up our old 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);
+        // Then make it so all input falls through.
+        rect.x = rect.y = rect.width = rect.height = 0;
+        XShapeCombineRectangles( xengine->m_display, m_window, ShapeInput, 0, 0, &rect, 1, ShapeSet, 0);
+    }
     XMoveWindow( xengine->m_display, m_window, m_x-m_border, m_y-m_border );
 }
 

rectangle.hpp

 
 class Rectangle {
 public:
-            Rectangle( int sx, int sy, int ex, int ey, int border, float r, float g, float b, float a );
+            Rectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a );
             ~Rectangle();
     void    setPos( int x, int y );
     void    setDim( int w, int h );
     int     m_width;
     int     m_height;
     int     m_border;
+    bool    m_highlight;
 private:
     int     convertColor( float r, float g, float b );
     void    constrain( int w, int h );

x.cpp

     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, "         This happens when something has already grabbed your keybaord.\n" );
         fprintf( stderr, "         slop should still run properly though.\n" );
         return 1;
     }

x.hpp

 #include <X11/cursorfont.h>
 #include <X11/extensions/shape.h>
 
+#include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <cstdio>