Fixed a lot of accuracy issues.

It was due to the mouse in X11 selecting pixels one left and one above where you actually can put the mouse,
and doing some window border math wrong.
This caused you to be incapable of selecting the whole screen since the mouse can't position itself completely in the lower right corner,
and judging a window's reported size wrong.
I also made the tolerance option more functional; setting it to 0 will disable window selections.
Because of this I also removed the --nowindow option.

main.cpp

     timespec start, time;
     int cx = 0;
     int cy = 0;
+    int cxoffset = 0;
+    int cyoffset = 0;
+    int woffset = 0;
+    int hoffset = 0;
 
     // First we set up the x interface and grab the mouse,
     // if we fail for either we exit immediately.
                 // If xengine has found a window we're hovering over (or if it changed)
                 // 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_hoverXWindow && options->m_window ) {
+                if ( window != xengine->m_hoverXWindow && 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 = xengine->m_hoverWindow;
                     windowselection = new slop::Rectangle( t.m_x - t.m_border,
                                                          t.m_y - t.m_border,
-                                                         t.m_width + t.m_border,
-                                                         t.m_height + t.m_border,
+                                                         t.m_width + t.m_border * 2,
+                                                         t.m_height + t.m_border * 2,
                                                          borderSize, padding,
                                                          r, g, b );
                     xengine->addRect( windowselection );
                     break;
                 }
                 // Check to make sure the user actually wants to drag for a selection before creating a rectangle.
-                int w = xengine->m_mousex - cx + 1;
-                int h = xengine->m_mousey - cy + 1;
-                if ( ( std::abs( w ) > tolerance || std::abs( h ) > tolerance ) && !selection ) {
+                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 ( std::abs( w ) <= tolerance && std::abs( h ) <= tolerance ) {
+                } else if ( !selection ) {
                     continue;
                 }
-                // 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->setDim( w, h );
                 // 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;
                     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;
                     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 );
                 break;
             }
             case 3: {
                     h = selection->m_height;
                     // Delete the rectangle.
                     xengine->removeRect( selection );
-                    // If the user simply clicked (and thus made the width and height smaller than
-                    // our tolerance) or if we're not hovering over a window, just print the selection
-                    // rectangle's stuff.
-                    if ( w > tolerance || h > tolerance || xengine->m_hoverXWindow == None ) {
+                    // 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_hoverXWindow == None ) {
                         printf( "X=%i\n", x );
                         printf( "Y=%i\n", y );
                         printf( "W=%i\n", w );
                 }
                 // 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 ( options->m_window ) {
+                if ( tolerance > 0 ) {
                     slop::WindowRectangle t = xengine->m_hoverWindow;
                     x = t.m_x - padding - t.m_border;
                     y = t.m_y - padding - t.m_border;
-                    w = t.m_width + t.m_border + padding*2;
-                    h = t.m_height + t.m_border + padding*2;
+                    w = t.m_width + t.m_border * 2 + padding*2;
+                    h = t.m_height + t.m_border * 2 + padding*2;
                 } else {
                     x = cx;
                     y = cy;

options.cpp

     m_blue = 0;
     m_gracetime = 0.1;
     m_keyboard = true;
-    m_window = true;
 }
 
 void slop::Options::printHelp() {
     printf( "    -nkb, --nokeyboard             don't try to grab the keyboard. This may fix problems with certain window managers.\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.\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( "    -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( "    -g=FLOAT, --gracetime=FLOAT    set the amount of time before slop will check for keyboard cancellations in seconds.\n" );
-    printf( "    -nw, --nowindow                disable automatically selecting a whole window on single-clicks, and instead just select a single pixel.\n" );
     printf( "examples\n" );
     printf( "    slop -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5 -g=.2\n" );
 }
             }
         } else if ( matches( arg, "-nkb", "--nokeyboard" ) ) {
             m_keyboard = false;
-        } else if ( matches( arg, "-nw", "--nowindow" ) ) {
-            m_window = false;
         } else if ( matches( arg, "-h", "--help" ) ) {
             printHelp();
             return 2;

options.hpp

     std::string m_xdisplay;
     float       m_gracetime;
     bool        m_keyboard;
-    bool        m_window;
 private:
     int         parseInt( std::string arg, int* returnInt );
     int         parseFloat( std::string arg, float* returnFloat );