Added ability to move starting points of selections with arrow keys, and made pressing enter accept the current selection rather than cancel it.

CMakeLists.txt

 project( "slop" )
 set( slop_VERSION_MAJOR 3 )
 set( slop_VERSION_MINOR 1 )
-set( slop_VERSION_PATCH 9 )
+set( slop_VERSION_PATCH 10 )
 
 set( BIN_TARGET     "${PROJECT_NAME}" )
 set( CMAKE_INSTALL_PREFIX "/usr/bin" )

README.md

 help
 ----
 ```text
-slop v3.1.9
+slop v3.1.10
 
 Copyright (C) 2014 Dalton Nell, Slop Contributors
 (https://github.com/naelstrof/slop/graphs/contributors)
     $ Y=$(echo $slopoutput | awk '{print $2}')
     $ W=$(echo $slopoutput | awk '{print $3}')
     $ H=$(echo $slopoutput | awk '{print $4}')
+
+Tips
+    * You can use the arrow keys to move the starting point of a
+drag-selection, just in case you missed it by a few pixels.
+    * If you don't like a selection: you can cancel it by right-clicking
+regardless of which options are enabled or disabled for slop.
+    * If slop doesn't seem to select a window accurately, the problem could be
+because of decorations getting in the way. Try enabling the --nodecorations
+flag.
 ```

src/cmdline.c

   "      --max=INT                 Set the maximum output of width or height\n                                  values. Setting min and max to the same value\n                                  disables drag selections.  (default=`0')",
   "  -l, --highlight               Instead of outlining selections, slop\n                                  highlights it. This is only useful when\n                                  --color is set to a transparent color.\n                                  (default=off)",
   "  -f, --format=STRING           Set the output format string. Format specifiers\n                                  are %x, %y, %w, %h, %i, %g, and %c.\n                                  (default=`X=%x\\nY=%y\\nW=%w\\nH=%h\\nG=%g\\nID=%i\\nCancel=%c\\n')",
-  "\nExamples\n    $ # Gray, thick, transparent border for maximum visiblity.\n    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n\n    $ # Remove window decorations.\n    $ slop --nodecorations\n\n    $ # Disable window selections. Useful for selecting individual pixels.\n    $ slop -t 0\n\n    $ # Classic Windows XP selection.\n    $ slop -l -c 0.3,0.4,0.6,0.4\n\n    $ # Change output format to use safer parsing\n    $ slopoutput=$(slop -f \"%x %y %w %h\")\n    $ X=$(echo $slopoutput | awk '{print $1}')\n    $ Y=$(echo $slopoutput | awk '{print $2}')\n    $ W=$(echo $slopoutput | awk '{print $3}')\n    $ H=$(echo $slopoutput | awk '{print $4}')\n",
+  "\nExamples\n    $ # Gray, thick, transparent border for maximum visiblity.\n    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n\n    $ # Remove window decorations.\n    $ slop --nodecorations\n\n    $ # Disable window selections. Useful for selecting individual pixels.\n    $ slop -t 0\n\n    $ # Classic Windows XP selection.\n    $ slop -l -c 0.3,0.4,0.6,0.4\n\n    $ # Change output format to use safer parsing\n    $ slopoutput=$(slop -f \"%x %y %w %h\")\n    $ X=$(echo $slopoutput | awk '{print $1}')\n    $ Y=$(echo $slopoutput | awk '{print $2}')\n    $ W=$(echo $slopoutput | awk '{print $3}')\n    $ H=$(echo $slopoutput | awk '{print $4}')\n\nTips\n    * You can use the arrow keys to move the starting point of a\ndrag-selection, just in case you missed it by a few pixels.\n    * If you don't like a selection: you can cancel it by right-clicking\nregardless of which options are enabled or disabled for slop.\n    * If slop doesn't seem to select a window accurately, the problem could be\nbecause of decorations getting in the way. Try enabling the --nodecorations\nflag.\n",
     0
 };
 

src/main.cpp

 #include <unistd.h>
 #include <cstdio>
 #include <sstream>
+
 #include "x.hpp"
 #include "rectangle.hpp"
 #include "cmdline.h"
     *rey = y + h;
 }
 
+// Some complicated key detection to replicate key repeating
+bool keyRepeat( KeySym key, double curtime, double repeatdelay, double* time, bool* memory ) {
+    if ( xengine->keyPressed( key ) != *memory ) {
+        if ( xengine->keyPressed( key ) ) {
+            *memory = true;
+            *time = curtime;
+            return true;
+        } else {
+            *memory = false;
+        }
+    }
+    if ( xengine->keyPressed( key ) && curtime - *time > repeatdelay ) {
+        return true;
+    }
+    return false;
+}
+
 int app( int argc, char** argv ) {
     gengetopt_args_info options;
     int err = cmdline_parser( argc, argv, &options );
     bool keyboard = !options.nokeyboard_flag;
     bool decorations = !options.nodecorations_flag;
     timespec start, time;
+    int xoffset = 0;
+    int yoffset = 0;
     int cx = 0;
     int cy = 0;
     int xmem = 0;
     int hmem = 0;
     int minimumsize = options.min_arg;
     int maximumsize = options.max_arg;
+    bool pressedMemory[4];
+    double pressedTime[4];
+    for ( int i=0;i<4;i++ ) {
+        pressedMemory[ i ] = false;
+        pressedTime[ i ] = 0;
+    }
     std::string format = options.format_arg;
     cmdline_parser_free( &options );
 
         xengine->tick();
         // If the user presses any key on the keyboard, exit the application.
         // Make sure at least 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 > gracetime ) {
-            if ( ( xengine->anyKeyPressed() && keyboard ) || xengine->mouseDown( 3 ) ) {
+        double curtime = double( time.tv_sec*1000000000L + time.tv_nsec )/1000000000.f;
+        double starttime = double( start.tv_sec*1000000000L + start.tv_nsec )/1000000000.f;
+        if ( curtime - starttime > gracetime ) {
+            if ( keyRepeat( XK_Up, curtime, 0.5, &pressedTime[ 0 ], &pressedMemory[ 0 ] ) ) {
+                yoffset -= 1;
+            }
+            if ( keyRepeat( XK_Down, curtime, 0.5, &pressedTime[ 1 ], &pressedMemory[ 1 ] ) ) {
+                yoffset += 1;
+            }
+            if ( keyRepeat( XK_Left, curtime, 0.5, &pressedTime[ 2 ], &pressedMemory[ 2 ] ) ) {
+                xoffset -= 1;
+            }
+            if ( keyRepeat( XK_Right, curtime, 0.5, &pressedTime[ 3 ], &pressedMemory[ 3 ] ) ) {
+                xoffset += 1;
+            }
+            // If we pressed enter we move the state onward.
+            if ( xengine->keyPressed( XK_Return ) ) {
+                // If we're highlight windows, just select the active window.
+                if ( state == 0 ) {
+                    state = 1;
+                // If we're making a custom selection, select the custom selection.
+                } else if ( state == 2 ) {
+                    state = 3;
+                }
+            }
+            // If we press any key other than the arrow keys or enter key, we shut down!
+            if ( !( xengine->keyPressed( XK_Up ) || xengine->keyPressed( XK_Down ) || xengine->keyPressed( XK_Left ) || xengine->keyPressed( XK_Right ) ) &&
+                !( xengine->keyPressed( XK_Return ) ) &&
+                ( ( xengine->anyKeyPressed() && keyboard ) || xengine->mouseDown( 3 ) ) ) {
                 printSelection( format, true, 0, 0, 0, 0, None );
                 fprintf( stderr, "User pressed key. Canceled selection.\n" );
                 state = -1;
                 // Set the mouse position of where we clicked, used so that click tolerance doesn't affect the rectangle's position.
                 cx = xengine->m_mousex;
                 cy = xengine->m_mousey;
+                // Make sure we don't have un-seen applied offsets.
+                xoffset = 0;
+                yoffset = 0;
                 // Also remember where the original selection was
                 if ( selection ) {
                     xmem = selection->m_x;
                 int sx, sy, ex, ey;
                 constrain( cx, cy, xengine->m_mousex, xengine->m_mousey, padding, minimumsize, maximumsize, &sx, &sy, &ex, &ey );
                 // Set the selection rectangle's dimensions to mouse movement.
-                selection->setGeo( sx, sy, ex, ey );
+                selection->setGeo( sx + xoffset, sy + yoffset, ex, ey );
                 break;
             }
             case 3: {

src/options.ggo

 text "    $ Y=$(echo $slopoutput | awk '{print $2}')\n"
 text "    $ W=$(echo $slopoutput | awk '{print $3}')\n"
 text "    $ H=$(echo $slopoutput | awk '{print $4}')\n"
+
+text "\nTips\n"
+text "    * You can use the arrow keys to move the starting point of a drag-selection, just in case you missed it by a few pixels.\n"
+text "    * If you don't like a selection: you can cancel it by right-clicking regardless of which options are enabled or disabled for slop.\n"
+text "    * If slop doesn't seem to select a window accurately, the problem could be because of decorations getting in the way. Try enabling the --nodecorations flag.\n"

src/x.cpp

     return EXIT_SUCCESS;
 }
 
+bool slop::XEngine::keyPressed( KeySym key ) {
+    KeyCode keycode = XKeysymToKeycode( m_display, key );
+    if ( keycode != 0 ) {
+        // Get the whole keyboard state
+        char keys[32];
+        XQueryKeymap( m_display, keys );
+        // Check our keycode
+        return ( keys[ keycode / 8 ] & ( 1 << ( keycode % 8 ) ) ) != 0;
+    } else {
+        return false;
+    }
+}
+
 bool slop::XEngine::anyKeyPressed() {
     if ( !m_good ) {
         return false;

src/x.hpp

     int                 grabCursor( slop::CursorType type );
     int                 grabKeyboard();
     bool                anyKeyPressed();
+    bool                keyPressed( KeySym key );
     int                 releaseCursor();
     int                 releaseKeyboard();
     void                setCursor( slop::CursorType type );