Added transparency suppport.

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
+    -c=COLOR, --color=COLOR        Set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT,FLOAT
     -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.
+                                   widths or heights.
     -v, --version                  prints version.
 
 Examples
-    $ # Gray, thick border for maximum visiblity.
-    $ slop -b=20 -c=0.5,0.5,0.5
+    $ # Gray, thick, transparent border for maximum visiblity.
+    $ slop -b=20 -c=0.5,0.5,0.5,0.8
 
     $ # Remove window decorations.
     $ slop -nd

main.cpp

     float r = options->m_red;
     float g = options->m_green;
     float b = options->m_blue;
+    float a = options->m_alpha;
     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,
-                                                         r, g, b );
+                                                         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,
-                                                     r, g, b );
+                                                     r, g, b, a );
                 }
                 // If the user has let go of the mouse button, we'll just
                 // continue to the next state.

options.cpp

 slop::Options* options = new slop::Options();
 
 slop::Options::Options() {
-    m_version = "v2.0.7";
+    m_version = "v2.0.8";
     m_borderSize = 10;
     m_padding = 0;
     m_xdisplay = ":0";
     m_red = 0;
     m_green = 0;
     m_blue = 0;
+    m_alpha = 1;
     m_gracetime = 0.4;
     m_keyboard = true;
     m_decorations = true;
     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\n" );
+    printf( "    -c=COLOR, --color=COLOR        Set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT,FLOAT\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( "    -v, --version                  prints version.\n" );
     printf( "\n" );
     printf( "Examples\n" );
-    printf( "    $ # Gray, thick border for maximum visiblity.\n" );
-    printf( "    $ slop -b=20 -c=0.5,0.5,0.5\n" );
+    printf( "    $ # Gray, thick, transparent border for maximum visiblity.\n" );
+    printf( "    $ slop -b=20 -c=0.5,0.5,0.5,0.8\n" );
     printf( "\n" );
     printf( "    $ # Remove window decorations.\n" );
     printf( "    $ slop -nd\n" );
                 return 1;
             }
         } else if ( matches( arg, "-c=", "--color=" ) ) {
-            int err = parseColor( arg, &m_red, &m_green, &m_blue );
+            int err = parseColor( arg, &m_red, &m_green, &m_blue, &m_alpha );
             if ( err ) {
                 return 1;
             }
     return 0;
 }
 
-int slop::Options::parseColor( std::string arg, float* r, float* g, float* b ) {
+int slop::Options::parseColor( std::string arg, float* r, float* g, float* b, float* a ) {
     std::string copy = arg;
     int find = copy.find( "=" );
     while( find != copy.npos ) {
 
     // Just in case we error out, grab the actual argument name into x.
     char* x = new char[ arg.size() ];
-    int num = sscanf( copy.c_str(), "%s %f %f %f", x, r, g, b );
-    if ( num != 4 ) {
+    // Just in case we didn't include an alpha value
+    *a = 1;
+    int num = sscanf( copy.c_str(), "%s %f %f %f %f", x, r, g, b, a );
+    if ( num != 4 && num != 5 ) {
         fprintf( stderr, "Error parsing command arguments near %s\n", arg.c_str() );
         fprintf( stderr, "Usage: %s=COLOR\n", x );
-        fprintf( stderr, "Example: %s=0,0,0 or %s=0.7,0.2,1\n", x, x );
+        fprintf( stderr, "Example: %s=0,0,0 or %s=0.7,0.2,1,0.5 or %s=1,1,1,0.8\n", x, x, x );
         fprintf( stderr, "Try -h or --help for help.\n" );
         delete[] x;
         return 1;

options.hpp

     float       m_red;
     float       m_green;
     float       m_blue;
+    float       m_alpha;
     std::string m_xdisplay;
     float       m_gracetime;
     bool        m_keyboard;
     int         parseFloat( std::string arg, float* returnFloat );
     int         parseString( std::string arg, std::string* returnString );
     int         parseGeometry( std::string arg, int* x, int* y, int* w, int* h );
-    int         parseColor( std::string arg, float* r, float* g, float* b );
+    int         parseColor( std::string arg, float* r, float* g, float* b, float* a );
     bool        matches( std::string arg, std::string shorthand, std::string longhand );
 };
 

rectangle.cpp

     usleep( 10000 );
 }
 
-slop::Rectangle::Rectangle( int sx, int sy, int ex, int ey, int border, float r, float g, float b ) {
+slop::Rectangle::Rectangle( int sx, int sy, int ex, int ey, int border, 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;
     // Set up the window so it's our color 
     attributes.background_pixmap = None;
     attributes.background_pixel = m_color.pixel;
+    attributes.border_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.
                               0, CopyFromParent, InputOutput,
                               CopyFromParent, valueMask, &attributes );
 
+    if ( a < 1 ) {
+        unsigned int cardinal_alpha = (unsigned int) (a * (unsigned int)-1) ;
+        XChangeProperty( xengine->m_display, m_window, XInternAtom( xengine->m_display, "_NET_WM_WINDOW_OPACITY", 0),
+                         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;

rectangle.hpp

 
 #include <X11/Xlib.h>
 #include <X11/extensions/shape.h>
+#include <X11/Xatom.h>
 
 #include <cstdlib>
 #include <cmath>
 
 class Rectangle {
 public:
-            Rectangle( int sx, int sy, int ex, int ey, int border, float r, float g, float b );
+            Rectangle( int sx, int sy, int ex, int ey, int border, float r, float g, float b, float a );
             ~Rectangle();
     void    setPos( int x, int y );
     void    setDim( int w, int h );