Added a workaround for being incapable of selecting the bottom right corner of pixels, and added option --minimumsize for those who don't want to accidentally select a 0x0 size selection.

main.cpp

     int ymem = 0;
     int wmem = 0;
     int hmem = 0;
+    int minimumsize = options->m_minimumsize;
 
     // First we set up the x interface and grab the mouse,
     // if we fail for either we exit immediately.
                                                          t.m_width,
                                                          t.m_height,
                                                          borderSize, padding,
+                                                         minimumsize, minimumsize,
                                                          r, g, b );
                     } else {
                         selection->setGeo( t.m_x, t.m_y, t.m_width, t.m_height );
                                                      xengine->m_mousex - cx,
                                                      xengine->m_mousey - cy,
                                                      borderSize, padding,
+                                                     minimumsize, minimumsize,
                                                      r, g, b );
                 }
                 // If the user has let go of the mouse button, we'll just
                 } else if ( x && y ) {
                     xengine->setCursor( slop::UpperLeftCorner );
                 }
+                // We're 100% accurate, but the mouse can't select the very bottom row or very right column of pixels.
+                // We detect if either are 1 pixel off and attempt to correct it.
+                if ( w == xengine->getWidth() - 1 ) {
+                    w = xengine->getWidth();
+                }
+                if ( h == xengine->getHeight() - 1 ) {
+                    h = xengine->getHeight();
+                }
                 // 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.

options.cpp

 slop::Options* options = new slop::Options();
 
 slop::Options::Options() {
-    m_version = "v2.0.2";
+    m_version = "v2.0.4";
     m_borderSize = 10;
     m_padding = 0;
     m_xdisplay = ":0";
-    m_tolerance = 4;
+    m_tolerance = 2;
     m_red = 0;
     m_green = 0;
     m_blue = 0;
     m_gracetime = 0.4;
     m_keyboard = true;
     m_decorations = true;
+    m_minimumsize = 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( "    -m=INT, --minimumsize=INT      sets the minimum output of width or height values, useful to avoid outputting 0\n" );
+    printf( "                                   widths or heights.\n" );
     printf( "    -v, --version                  prints version.\n" );
     printf( "\n" );
     printf( "Examples\n" );
             if ( m_borderSize < 0 ) {
                 m_borderSize = 0;
             }
+        } else if ( matches( arg, "-m=", "--minimumsize=" ) ) {
+            int err = parseInt( arg, &m_minimumsize );
+            if ( err ) {
+                return 1;
+            }
         } else if ( matches( arg, "-p=", "--padding=" ) ) {
             int err = parseInt( arg, &m_padding );
             if ( err ) {

options.hpp

     int         m_borderSize;
     int         m_padding;
     int         m_tolerance;
+    int         m_minimumsize;
     float       m_red;
     float       m_green;
     float       m_blue;

rectangle.cpp

     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 ) {
+slop::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding, int minimumwidth, int minimumheight, 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_minimumwidth = minimumwidth;
+    m_minimumheight = minimumheight;
     m_border = border;
     m_padding = padding;
     m_window = None;
         m_yoffset = -pad;
         m_height = h + pad * 2;
     }
+    if ( m_width < m_minimumwidth ) {
+        m_width = m_minimumwidth;
+    }
+    if ( m_height < m_minimumheight ) {
+        m_height = m_minimumheight;
+    }
 }
 
 int slop::Rectangle::convertColor( float r, float g, float b ) {

rectangle.hpp

 
 class Rectangle {
 public:
-            Rectangle( int x, int y, int width, int height, int border, int padding, float r, float g, float b );
+            Rectangle( int x, int y, int width, int height, int border, int padding, int minimumwidth, int minimumheight, float r, float g, float b );
             ~Rectangle();
     void    setPos( int x, int y );
     void    setDim( int w, int h );
     int     m_y;
     int     m_xoffset;
     int     m_yoffset;
+    int     m_minimumwidth;
+    int     m_minimumheight;
     int     m_width;
     int     m_height;
     int     m_border;

x.cpp

     exit(1);
 }
 
+int slop::XEngine::getWidth() {
+    if ( !m_good ) {
+        return -1;
+    }
+    return (int)WidthOfScreen( m_screen );
+}
+
+int slop::XEngine::getHeight() {
+    if ( !m_good ) {
+        return -1;
+    }
+    return (int)HeightOfScreen( m_screen );
+}
+
 slop::XEngine::XEngine() {
     m_display = NULL;
     m_visual = NULL;
         case UpperRightCorner:      xfontcursor = XC_ur_angle; break;
         case LowerLeftCorner:       xfontcursor = XC_ll_angle; break;
         case LowerRightCorner:      xfontcursor = XC_lr_angle; break;
+        case Dot:                   xfontcursor = XC_dot; break;
+        case Box:                   xfontcursor = 40; break;
     }
     Cursor newcursor = 0;
     if ( m_cursors.size() > xfontcursor ) {

x.hpp

     UpperLeftCorner,
     UpperRightCorner,
     LowerRightCorner,
-    LowerLeftCorner
+    LowerLeftCorner,
+    Dot,
+    Box
 };
 
 class WindowRectangle {
     int                 releaseKeyboard();
     void                setCursor( slop::CursorType type );
     void                drawRect( int x, int y, unsigned int w, unsigned int h );
+    int                 getWidth();
+    int                 getHeight();
     int                 m_mousex;
     int                 m_mousey;
     Display*            m_display;