added some comments and separated options parsing to its own object

main.cpp

 #include <unistd.h>
 #include <cstdio>
 #include "x.hpp"
-
-int borderSize = 10;
-int padding = 0;
-std::string xserver = ":0";
-
-void printHelp() {
-    printf( "Usage: slrn [options]\n" );
-    printf( "Print user selected region to stdout.\n" );
-    printf( "\n" );
-    printf( "options\n" );
-    printf( "    -h, --help                     show this message.\n" );
-    printf( "    -b=INT, --bordersize=INT       set selection rectangle border size.\n" );
-    printf( "    -p=INT, --padding=INT          set padding size for selection.\n" );
-    printf( "    -x=STRING, --xdisplay=STRING   set x display (STRING must be hostname:number.screen_number format)\n" );
-    printf( "examples\n" );
-    printf( "    slrn -b=10 -x=:0 -p=-30\n" );
-}
-
-int parseOptions( int argc, char** argv ) {
-    for ( int i=0; i<argc; i++ ) {
-        std::string arg = argv[i];
-        if ( arg.substr( 0, 3 ) == "-b=" || arg.substr( 0, 13 ) == "--bordersize=" ) {
-            int find = arg.find( "=" );
-            if ( find != arg.npos ) {
-                arg.at( find ) = ' ';
-            }
-            int num = sscanf( arg.c_str(), "%*s %i", &borderSize );
-            if ( borderSize < 0 ) {
-                borderSize = 0;
-            }
-            if ( num != 1 ) {
-                printf( "Error parsing command arguments near %s\n", argv[i] );
-                printf( "Usage: -b=INT or --bordersize=INT\n" );
-                printf( "Example: -b=10 or --bordersize=12\n" );
-                return 1;
-            }
-        } else if ( arg.substr( 0, 3 ) == "-p=" || arg.substr( 0, 10 ) == "--padding=" ) {
-            int find = arg.find( "=" );
-            if ( find != arg.npos ) {
-                arg.at( find ) = ' ';
-            }
-            int num = sscanf( arg.c_str(), "%*s %i", &padding );
-            if ( num != 1 ) {
-                printf( "Error parsing command arguments near %s\n", argv[i] );
-                printf( "Usage: -p=INT or --padding=INT\n" );
-                printf( "Example: -p=0 or --padding=-12\n" );
-                return 1;
-            }
-        } else if ( arg.substr( 0, 3 ) == "-x=" || arg.substr( 0, 11 ) == "--xdisplay=" ) {
-            int find = arg.find( "=" );
-            if ( find != arg.npos ) {
-                arg.at( find ) = ' ';
-            }
-            char* x = new char[ arg.size() ];
-            int num = sscanf( arg.c_str(), "%*s %s", x );
-            if ( num != 1 ) {
-                printf( "Error parsing command arguments near %s\n", argv[i] );
-                printf( "Usage: -x=STRING or --xserver=STRING.\n" );
-                printf( "Example: -x=:0 or --xserver=winston:1.3\n" );
-                delete[] x;
-                return 1;
-            }
-            xserver = x;
-            delete[] x;
-        } else if ( arg == "-h" || arg == "--help" ) {
-            printHelp();
-            return 2;
-        } else {
-            if ( i == 0 ) {
-                continue;
-            }
-            printf( "Error: Unknown argument %s\n", argv[i] );
-            printf( "Try -h or --help for help.\n" );
-            return 1;
-        }
-    }
-    return 0;
-}
+#include "options.hpp"
 
 int main( int argc, char** argv ) {
-    int err = parseOptions( argc, argv );
+    int err = options->parseOptions( argc, argv );
     if ( err ) {
         return err;
     }
     int state = 0;
     bool running = true;
-    is::Rectangle* selection;
-    is::Rectangle* windowselection = NULL;
+    slrn::Rectangle* selection;
+    slrn::Rectangle* windowselection = NULL;
     Window window = None;
+    std::string xdisplay = options->m_xdisplay;
+    int padding = options->m_padding;
+    int borderSize = options->m_borderSize;
+    int tolerance = options->m_tolerance;
 
-    err = xengine->init( xserver.c_str() );
+    // 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 ) {
         return err;
     }
-    err = xengine->grabCursor( is::Cross );
+    err = xengine->grabCursor( slrn::Cross );
     if ( err ) {
         return err;
     }
     while ( running ) {
+        // "ticking" the xengine makes it process all queued events.
         xengine->tick();
         if ( xengine->mouseDown( 3 ) ) {
             printf( "X=0\n" );
             state = -1;
             running = false;
         }
+        // Our adorable little state manager will handle what state we're in.
         switch ( state ) {
             default: {
                 break;
             }
             case 0: {
+                // 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.
                 if ( window != xengine->m_hoverXWindow ) {
+                    // Make sure to delete the old selection rectangle.
                     if ( windowselection ) {
-                        xengine->removeRect( windowselection );
+                        xengine->removeRect( windowselection ); // removeRect also dealloc's the rectangle for us.
                     }
-                    is::WindowRectangle t = xengine->m_hoverWindow;
-                    windowselection = new is::Rectangle( t.m_x - t.m_border,
+                    slrn::WindowRectangle t = xengine->m_hoverWindow;
+                    windowselection = new slrn::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,
                     xengine->addRect( windowselection );
                     window = xengine->m_hoverXWindow;
                 }
+                // If the user clicked, remove the old selection rectangle and then
+                // move on to the next state.
                 if ( xengine->mouseDown( 1 ) ) {
                     if ( windowselection ) {
                         xengine->removeRect( windowselection );
                 break;
             }
             case 1: {
-                selection = new is::Rectangle( xengine->m_mousex, xengine->m_mousey, 0, 0, borderSize, padding );
+                // Simply create a new rectangle at the mouse position and move on
+                // to the next state.
+                selection = new slrn::Rectangle( xengine->m_mousex, xengine->m_mousey, 0, 0, borderSize, padding );
                 xengine->addRect( selection );
                 state++;
                 break;
             }
             case 2: {
+                // If the user has let go of the mouse button, we'll just
+                // continue to the next state.
                 if ( !xengine->mouseDown( 1 ) ) {
                     state++;
                     break;
                 }
+                // 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( xengine->m_mousex - selection->m_x, xengine->m_mousey - selection->m_y );
+                // We also detect which way the user is pulling and set the mouse icon accordingly.
                 bool x = selection->m_flippedx;
                 bool y = selection->m_flippedy;
                 if ( !x && !y ) {
-                    xengine->setCursor( is::LowerRightCorner );
+                    xengine->setCursor( slrn::LowerRightCorner );
                 } else if ( x && !y ) {
-                    xengine->setCursor( is::LowerLeftCorner );
+                    xengine->setCursor( slrn::LowerLeftCorner );
                 } else if ( !x && y ) {
-                    xengine->setCursor( is::UpperRightCorner );
+                    xengine->setCursor( slrn::UpperRightCorner );
                 } else {
-                    xengine->setCursor( is::UpperLeftCorner );
+                    xengine->setCursor( slrn::UpperLeftCorner );
                 }
 
                 break;
             }
             case 3: {
+                // 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.
                 int x = selection->m_x+selection->m_xoffset;
                 int y = selection->m_y+selection->m_yoffset;
                 int w = selection->m_width;
                 int h = selection->m_height;
+                // Delete the rectangle.
                 xengine->removeRect( selection );
+                // Exit the utility after this state runs once.
                 running = false;
-                if ( w || h || xengine->m_hoverXWindow == None ) {
+                // 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 ) {
                     printf( "X=%i\n", x );
                     printf( "Y=%i\n", y );
                     printf( "W=%i\n", w + 1 );
                     printf( "H=%i\n", h + 1 );
                     break;
                 }
-                is::WindowRectangle t = xengine->m_hoverWindow;
+                // Otherwise lets grab the window's dimensions and use those (with padding).
+                slrn::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;
                 break;
             }
         }
-        // No need to max out CPU--
+        // 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 );
     }
+    // Clean up global classes.
     delete xengine;
+    delete options;
     return 0;
 }

makefile

 CC=g++
 CFLAGS=-O2 -g
 LDFLAGS=-lX11 -lXext
-SOURCES=main.cpp x.cpp
+SOURCES=main.cpp x.cpp options.cpp
 OBJECTS=$(SOURCES:.cpp=.o)
 EXECUTABLE=slrn
 

options.cpp

+#include "options.hpp"
+
+slrn::Options* options = new slrn::Options();
+
+slrn::Options::Options() {
+    m_borderSize = 10;
+    m_padding = 0;
+    m_xdisplay = ":0";
+    m_tolerance = 4;
+}
+
+void slrn::Options::printHelp() {
+    printf( "Usage: slrn [options]\n" );
+    printf( "Print user selected region to stdout.\n" );
+    printf( "\n" );
+    printf( "options\n" );
+    printf( "    -h, --help                     show this message.\n" );
+    printf( "    -b=INT, --bordersize=INT       set selection rectangle border size.\n" );
+    printf( "    -p=INT, --m_padding=INT        set m_padding size for selection.\n" );
+    printf( "    -t=INT, --tolerance=INT        if you have a shaky mouse, increasing this value will make slrn detect single clicks better. Rather than interpreting your shaky clicks as region selections.\n" );
+    printf( "    -x=STRING, --xdisplay=STRING   set x display (STRING must be hostname:number.screen_number format)\n" );
+    printf( "examples\n" );
+    printf( "    slrn -b=10 -x=:0 -p=-30 -t=4\n" );
+}
+
+int slrn::Options::parseOptions( int argc, char** argv ) {
+    // Simple command parsing. Just uses sscanf to read each argument.
+    // It looks complicated because you have to have spaces for delimiters for sscanf.
+    for ( int i=0; i<argc; i++ ) {
+        std::string arg = argv[i];
+        if ( matches( arg, "--b=", "--bordersize=" ) ) {
+            int err = parseInt( arg, &m_borderSize );
+            if ( err ) {
+                return 1;
+            }
+            if ( m_borderSize < 0 ) {
+                m_borderSize = 0;
+            }
+        } else if ( matches( arg, "-p=", "--padding=" ) ) {
+            int err = parseInt( arg, &m_padding );
+            if ( err ) {
+                return 1;
+            }
+        } else if ( matches( arg, "-t=", "--tolerance=" ) ) {
+            int err = parseInt( arg, &m_tolerance );
+            if ( err ) {
+                return 1;
+            }
+            if ( m_tolerance < 0 ) {
+                m_tolerance = 0;
+            }
+        } else if ( matches( arg, "-x=", "--xdisplay=" ) ) {
+            int err = parseString( arg, &m_xdisplay );
+            if ( err ) {
+                return 1;
+            }
+        } else if ( arg == "-h" || arg == "--help" ) {
+            printHelp();
+            return 2;
+        } else {
+            if ( i == 0 ) {
+                continue;
+            }
+            printf( "Error: Unknown argument %s\n", argv[i] );
+            printf( "Try -h or --help for help.\n" );
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int slrn::Options::parseInt( std::string arg, int* returnInt ) {
+    std::string copy = arg;
+    int find = copy.find( "=" );
+    if ( find != copy.npos ) {
+        copy.at( find ) = ' ';
+    }
+    // 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 %i", x, returnInt );
+    if ( num != 2 ) {
+        printf( "Error parsing command arguments near %s\n", arg.c_str() );
+        printf( "Usage: %s=INT\n", x );
+        printf( "Example: %s=10 or %s=-12\n", x, x );
+        printf( "Try -h or --help for help.\n" );
+        delete[] x;
+        return 1;
+    }
+    delete[] x;
+    return 0;
+}
+
+bool slrn::Options::matches( std::string arg, std::string shorthand, std::string longhand ) {
+    if ( arg.substr( 0, shorthand.size() ) == shorthand ||
+         arg.substr( 0, longhand.size() ) == longhand ) {
+        return true;
+    }
+    return false;
+}
+
+int slrn::Options::parseString( std::string arg, std::string* returnString ) {
+    std::string copy = arg;
+    int find = copy.find( "=" );
+    if ( find != copy.npos ) {
+        copy.at( find ) = ' ';
+    }
+    // Just in case we error out, grab the actual argument name into x.
+    char* x = new char[ arg.size() ];
+    char* y = new char[ arg.size() ];
+    int num = sscanf( copy.c_str(), "%s %s", x, y );
+    if ( num != 2 ) {
+        printf( "Error parsing command arguments near %s\n", arg.c_str() );
+        printf( "Usage: %s=STRING\n", x );
+        printf( "Example: %s=:0 or %s=hostname:0.1\n", x, x );
+        printf( "Try -h or --help for help.\n" );
+        delete[] x;
+        delete[] y;
+        return 1;
+    }
+    *returnString = y;
+    delete[] x;
+    delete[] y;
+    return 0;
+}

options.hpp

+#ifndef IS_OPTIONS_H_
+
+#include <string>
+#include <cstdio>
+
+namespace slrn {
+
+class Options {
+public:
+                Options();
+    int         parseOptions( int argc, char** argv );
+    void        printHelp();
+
+    int         m_borderSize;
+    int         m_padding;
+    int         m_tolerance;
+    std::string m_xdisplay;
+private:
+    int         parseInt( std::string arg, int* returnInt );
+    int         parseString( std::string arg, std::string* returnString );
+    bool        matches( std::string arg, std::string shorthand, std::string longhand );
+};
+
+}
+
+extern slrn::Options* options;
+
+#endif // IS_OPTIONS_H_

x.cpp

 #include "x.hpp"
 
-is::XEngine* xengine = new is::XEngine();
+slrn::XEngine* xengine = new slrn::XEngine();
 
-is::XEngine::XEngine() {
+slrn::XEngine::XEngine() {
     m_display = NULL;
     m_visual = NULL;
     m_screen = NULL;
     m_hoverXWindow = None;
 }
 
-is::XEngine::~XEngine() {
+slrn::XEngine::~XEngine() {
     if ( !m_good ) {
         return;
     }
     XCloseDisplay( m_display );
 }
 
-void is::XEngine::addRect( Rectangle* rect ) {
+void slrn::XEngine::addRect( Rectangle* rect ) {
     m_rects.push_back( rect );
 }
 
-void is::XEngine::removeRect( Rectangle* rect ) {
+void slrn::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 );
     }
 }
 
-bool is::XEngine::mouseDown( unsigned int button ) {
+bool slrn::XEngine::mouseDown( unsigned int button ) {
     if ( button >= m_mouse.size() ) {
         return false;
     }
     return m_mouse.at( button );
 }
 
-int is::XEngine::init( std::string display ) {
+int slrn::XEngine::init( std::string display ) {
     // Initialize display
     m_display = XOpenDisplay( display.c_str() );
     if ( !m_display ) {
     return 0;
 }
 
-int is::XEngine::grabCursor( is::CursorType type ) {
+int slrn::XEngine::grabCursor( slrn::CursorType type ) {
     if ( !m_good ) {
         return 1;
     }
                             PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
                             GrabModeAsync, GrabModeAsync, m_root, xfontcursor, CurrentTime );
     if ( err != GrabSuccess ) {
-        printf( "Failed to grab X cursor\n" );
+        printf( "Failed to grab X cursor.\n" );
         return 1;
     }
 
     return 0;
 }
 
-int is::XEngine::releaseCursor() {
+int slrn::XEngine::releaseCursor() {
     if ( !m_good ) {
         return 1;
     }
     return 0;
 }
 
-void is::XEngine::tick() {
+void slrn::XEngine::tick() {
     if ( !m_good ) {
         return;
     }
     updateHoverWindow();
 }
 
-Cursor is::XEngine::getCursor( is::CursorType type ) {
+Cursor slrn::XEngine::getCursor( slrn::CursorType type ) {
     int xfontcursor;
     switch ( type ) {
         default:
     return newcursor;
 }
 
-void is::XEngine::setCursor( is::CursorType type ) {
+void slrn::XEngine::setCursor( slrn::CursorType type ) {
     if ( !m_good ) {
         return;
     }
                               xfontcursor, CurrentTime );
 }
 
-is::Rectangle::~Rectangle() {
+slrn::Rectangle::~Rectangle() {
     //XFreeGC( xengine->m_display, m_gc );
     if ( m_window == None ) {
         return;
     XDestroyWindow( xengine->m_display, m_window );
 }
 
-is::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding ) {
+slrn::Rectangle::Rectangle( int x, int y, int width, int height, int border, int padding ) {
     m_xoffset = 0;
     m_yoffset = 0;
     m_x = x;
     XMapWindow( xengine->m_display, m_window );
 }
 
-void is::Rectangle::setPos( int x, int y ) {
+void slrn::Rectangle::setPos( int x, int y ) {
     if ( m_x == x && m_y == y ) {
         return;
     }
     XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset, m_y+m_yoffset );
 }
 
-void is::Rectangle::setDim( int w, int h ) {
+void slrn::Rectangle::setDim( int w, int h ) {
     if ( m_width == w && m_height == h ) {
         return;
     }
     XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
 }
 
-void is::XEngine::updateHoverWindow() {
+void slrn::XEngine::updateHoverWindow() {
     Window root, child;
     int mx, my;
     int wx, wy;
                   &(m_hoverWindow.m_border), &depth );
 }
 
-void is::XEngine::updateHoverWindow( Window child ) {
+void slrn::XEngine::updateHoverWindow( Window child ) {
     if ( m_hoverXWindow == child ) {
         return;
     }
 }
 
 // Keeps our rectangle's sizes all positive, so Xlib doesn't throw an exception.
-void is::Rectangle::constrain( int w, int h ) {
+void slrn::Rectangle::constrain( int w, int h ) {
     int pad = m_padding;
     if ( pad < 0 && std::abs( w ) < std::abs( pad )*2 ) {
         pad = 0;

x.hpp

 #include <string>
 #include <vector>
 
-namespace is {
+namespace slrn {
 
 enum CursorType {
     Left,
                         ~XEngine();
     int                 init( std::string display );
     void                tick();
-    int                 grabCursor( is::CursorType type );
+    int                 grabCursor( slrn::CursorType type );
     int                 releaseCursor();
-    void                setCursor( is::CursorType type );
+    void                setCursor( slrn::CursorType type );
     void                drawRect( int x, int y, unsigned int w, unsigned int h );
     void                addRect( Rectangle* rect );
     void                removeRect( Rectangle* rect );
     bool                m_good;
     std::vector<Cursor> m_cursors;
     std::vector<Rectangle*> m_rects;
-    Cursor              getCursor( is::CursorType type );
+    Cursor              getCursor( slrn::CursorType type );
 };
 
 }
 
-extern is::XEngine* xengine;
+extern slrn::XEngine* xengine;
 
 #endif // IS_X_H_