reduced time till slop responds to keyboard, and added options for it

main.cpp

         // "ticking" the xengine makes it process all queued events.
         xengine->tick();
         // If the user presses any key on the keyboard, exit the application.
-        // Make sure at least a half second has passed before allowing canceling
+        // Make sure at least options->m_gracetime has passed before allowing canceling
         double timei = double( time.tv_sec*1000000000L + time.tv_nsec )/1000000000.f;
         double starti = double( start.tv_sec*1000000000L + start.tv_nsec )/1000000000.f;
-        if ( timei - starti > 0.5 ) {
+        if ( timei - starti > options->m_gracetime ) {
             if ( xengine->m_keypressed ) {
                 printf( "X=0\n" );
                 printf( "Y=0\n" );
     // Clean up global classes.
     delete xengine;
     delete options;
+    // If we canceled the selection, return error.
+    if ( state == -1 ) {
+        return 1;
+    }
     return 0;
 }

options.cpp

     m_red = 0;
     m_green = 0;
     m_blue = 0;
+    m_gracetime = 0.1;
 }
 
 void slop::Options::printHelp() {
     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( "    -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( "examples\n" );
-    printf( "    slop -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5\n" );
+    printf( "    slop -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5 -g=.2\n" );
 }
 
 int slop::Options::parseOptions( int argc, char** argv ) {
             if ( m_tolerance < 0 ) {
                 m_tolerance = 0;
             }
+        } else if ( matches( arg, "-g=", "--gracetime=" ) ) {
+            int err = parseFloat( arg, &m_gracetime );
+            if ( err ) {
+                return 1;
+            }
+            if ( m_gracetime < 0 ) {
+                m_gracetime = 0;
+            }
         } else if ( matches( arg, "-x=", "--xdisplay=" ) ) {
             int err = parseString( arg, &m_xdisplay );
             if ( err ) {
     return 0;
 }
 
+int slop::Options::parseFloat( std::string arg, float* returnFloat ) {
+    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 %f", x, returnFloat );
+    if ( num != 2 ) {
+        fprintf( stderr, "Error parsing command arguments near %s\n", arg.c_str() );
+        fprintf( stderr, "Usage: %s=FLOAT\n", x );
+        fprintf( stderr, "Example: %s=3.14 or %s=-99\n", x, x );
+        fprintf( stderr, "Try -h or --help for help.\n" );
+        delete[] x;
+        return 1;
+    }
+    delete[] x;
+    return 0;
+}
+
 bool slop::Options::matches( std::string arg, std::string shorthand, std::string longhand ) {
     if ( arg.substr( 0, shorthand.size() ) == shorthand ||
          arg.substr( 0, longhand.size() ) == longhand ) {

options.hpp

     float       m_green;
     float       m_blue;
     std::string m_xdisplay;
+    float       m_gracetime;
 private:
     int         parseInt( std::string arg, int* returnInt );
+    int         parseFloat( std::string arg, float* returnFloat );
     int         parseString( std::string arg, std::string* returnString );
     int         parseColor( std::string arg, float* r, float* g, float* b );
     bool        matches( std::string arg, std::string shorthand, std::string longhand );