Added a --nodecoration window selection feature, and a way to offset selections that had decorations removed.

README.md

 * Supports simple arguments:
     * Change selection rectangle border size.
     * Select X display.
-    * Set padding size, even to negative padding sizes!
+    * Set padding size, even negative padding sizes!
     * Set click tolerance for if you have a shaky mouse.
     * Set the color of the selection rectangles to match your theme!
+    * Remove window decorations from selections.
 
 practical applications
 ----------------------
 ![slopgood](http://farmpolice.com/content/images/slrn_good.png)
 
 You can see scrot leaves garbage lines over the things you're trying to screenshot!
-While slop not only looks nicer, it's impossible for it to end up in screenshots or recordings because it shuts down before ffmpeg or imagemagick can take a picture.
+While slop not only looks nicer, it's impossible for it to end up in screenshots or recordings because it waits for DestroyNotify events before completely shutting down. Only after the window is completely destroyed can ffmpeg or imagemagick take a picture.
+
+help
+----
+```text
+Usage: slop [options]
+Print user selected region to stdout. Pressing keys or right-clicking cancels selection.
+
+Options
+    -h, --help                     Show this message.
+    -nkb, --nokeyboard             Disables the ability to cancel selections with the keyboard.
+    -b=INT, --bordersize=INT       Set selection rectangle border size.
+    -p=INT, --padding=INT          Set padding size for selection.
+    -t=INT, --tolerance=INT        How far in pixels the mouse can move after clicking and still be detected
+                                   as a normal click. Setting to zero will disable window selections.
+    -x=STRING, --xdisplay=STRING   Set x display (STRING must be hostname:number.screen_number format)
+    -c=COLOR, --color=COLOR        Set selection rectangle color, COLOR is in format FLOAT,FLOAT,FLOAT
+    -g=FLOAT, --gracetime=FLOAT    Set the amount of time before slop will check for keyboard cancellations
+                                   in seconds.
+    -nd, --nodecorations           attempts to remove decorations from window selections.
+    -o=GEOMETRY, --offset=GEOMETRY Offsets window selections, but only if --nodecorations is active and if the
+                                   window's decorations were successfully detected. Has a very specific use of
+                                   removing shadows from Gnome's window selections right now. GEOMETRY is in
+                                   format WxH+X+Y
+
+Examples
+    $ # gray, thick border for maximum visiblity.
+    $ slop -b=20 -c=0.5,0.5,0.5
+
+    $ # Remove window decorations, but include the 28px titlebar. Useful to remove the arbitrarily sized shadows in Gnome where they are included in window geometry for whatever reason.
+    $ slop -nd -o=0x28+0-28
+
+    $ # Disable window selections. Useful for selecting individual pixels.
+    $ slop -t=0
+```

main.cpp

     float g = options->m_green;
     float b = options->m_blue;
     bool keyboard = options->m_keyboard;
+    bool decorations = options->m_decorations;
     timespec start, time;
     int cx = 0;
     int cy = 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.
                 // --but only if the user wants us to
-                if ( window != xengine->m_hoverXWindow && tolerance > 0 ) {
+                if ( window != xengine->m_hoverWindow && 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_y,
-                                                         t.m_width + t.m_border * 2,
-                                                         t.m_height + t.m_border * 2,
-                                                         borderSize, padding,
-                                                         r, g, b );
+                    slop::WindowRectangle t;
+                    t.setGeometry( xengine->m_hoverWindow, decorations );
+                    // Make sure we only apply offsets to windows that we've forcibly removed decorations on.
+                    if ( !t.m_decorations ) {
+                        windowselection = new slop::Rectangle( t.m_x + options->m_offsetx,
+                                                               t.m_y + options->m_offsety,
+                                                               t.m_width + options->m_offsetw,
+                                                               t.m_height + options->m_offseth,
+                                                               borderSize, padding,
+                                                               r, g, b );
+                    } else {
+                        windowselection = new slop::Rectangle( t.m_x,
+                                                               t.m_y,
+                                                               t.m_width,
+                                                               t.m_height,
+                                                               borderSize, padding,
+                                                               r, g, b );
+                    }
                     xengine->addRect( windowselection );
-                    window = xengine->m_hoverXWindow;
+                    window = xengine->m_hoverWindow;
                 }
                 // If the user clicked, remove the old selection rectangle and then
                 // move on to the next state.
                     xengine->removeRect( selection );
                     // 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 ) {
+                    if ( w >= tolerance || h >= tolerance || xengine->m_hoverWindow == 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 ( tolerance > 0 ) {
-                    slop::WindowRectangle t = xengine->m_hoverWindow;
-                    x = t.m_x - padding;
-                    y = t.m_y - padding;
-                    w = t.m_width + t.m_border * 2 + padding * 2;
-                    h = t.m_height + t.m_border * 2 + padding * 2;
+                    slop::WindowRectangle t;
+                    t.setGeometry( xengine->m_hoverWindow, decorations );
+                    // Make sure we only apply offsets to windows that we've forcibly removed decorations on.
+                    if ( !t.m_decorations ) {
+                        x = t.m_x - padding + options->m_offsetx;
+                        y = t.m_y - padding + options->m_offsety;
+                        w = t.m_width + padding * 2 + options->m_offsetw;
+                        h = t.m_height + padding * 2 + options->m_offseth;
+                    } else {
+                        x = t.m_x - padding;
+                        y = t.m_y - padding;
+                        w = t.m_width + padding * 2;
+                        h = t.m_height + padding * 2;
+                    }
                 } else {
                     x = cx;
                     y = cy;

options.cpp

     m_blue = 0;
     m_gracetime = 0.3;
     m_keyboard = true;
+    m_decorations = true;
+    m_offsetx = 0;
+    m_offsety = 0;
+    m_offsetw = 0;
+    m_offseth = 0;
 }
 
 void slop::Options::printHelp() {
     printf( "Usage: slop [options]\n" );
     printf( "Print user selected region to stdout. Pressing keys or right-clicking cancels selection.\n" );
     printf( "\n" );
-    printf( "options\n" );
-    printf( "    -h, --help                     show this message.\n" );
-    printf( "    -nkb, --nokeyboard             disables the ability to cancel selections with the keyboard.\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. 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( "examples\n" );
-    printf( "    slop -b=10 -x=:0 -p=-30 -t=4 -c=0.5,0.5,0.5 -g=.3\n" );
+    printf( "Options\n" );
+    printf( "    -h, --help                     Show this message.\n" );
+    printf( "    -nkb, --nokeyboard             Disables the ability to cancel selections with the keyboard.\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        How far in pixels the mouse can move after clicking and still be detected\n" );
+    printf( "                                   as a normal click. 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\n" );
+    printf( "                                   in seconds.\n" );
+    printf( "    -nd, --nodecorations           attempts to remove decorations from window selections.\n" );
+    printf( "    -o=GEOMETRY, --offset=GEOMETRY Offsets window selections, but only if --nodecorations is active and if the\n" );
+    printf( "                                   window's decorations were successfully detected. Has a very specific use of\n" );
+    printf( "                                   removing shadows from Gnome's window selections right now. GEOMETRY is in\n" );
+    printf( "                                   format WxH+X+Y\n" );
+    printf( "\n" );
+    printf( "Examples\n" );
+    printf( "    $ # gray, thick border for maximum visiblity.\n" );
+    printf( "    $ slop -b=20 -c=0.5,0.5,0.5\n" );
+    printf( "\n" );
+    printf( "    $ # Remove window decorations, but include the 28px titlebar. Useful to remove the arbitrarily sized shadows in Gnome where they are included in window geometry for whatever reason.\n" );
+    printf( "    $ slop -nd -o=0x28+0-28\n" );
+    printf( "\n" );
+    printf( "    $ # Disable window selections. Useful for selecting individual pixels.\n" );
+    printf( "    $ slop -t=0\n" );
 }
 
 int slop::Options::parseOptions( int argc, char** argv ) {
             if ( m_borderSize < 0 ) {
                 m_borderSize = 0;
             }
+        } else if ( matches( arg, "-o=", "--offset=" ) ) {
+            int err = parseGeometry( arg, &m_offsetx, &m_offsety, &m_offsetw, &m_offseth );
+            if ( err ) {
+                return 1;
+            }
         } else if ( matches( arg, "-p=", "--padding=" ) ) {
             int err = parseInt( arg, &m_padding );
             if ( err ) {
             }
         } else if ( matches( arg, "-nkb", "--nokeyboard" ) ) {
             m_keyboard = false;
+        } else if ( matches( arg, "-nd", "--nodecorations" ) ) {
+            m_decorations = false;
         } else if ( matches( arg, "-h", "--help" ) ) {
             printHelp();
             return 2;
     delete[] x;
     return 0;
 }
+
+int slop::Options::parseGeometry( std::string arg, int* x, int* y, int* w, int* h ) {
+    std::string copy = arg;
+    // Replace the first =, all x's and +'s with spaces.
+    int find = copy.find( "=" );
+    while( find != copy.npos ) {
+        copy.at( find ) = ' ';
+        find = copy.find( "x" );
+    }
+    find = copy.find( "+" );
+    while( find != copy.npos ) {
+        copy.at( find ) = ' ';
+        find = copy.find( "+" );
+    }
+
+    // Just in case we error out, grab the actual argument name into x.
+    char* foo = new char[ arg.size() ];
+    int num = sscanf( copy.c_str(), "%s %d %d %d %d", foo, w, h, x, y );
+    if ( num != 5 ) {
+        fprintf( stderr, "Error parsing command arguments near %s\n", arg.c_str() );
+        fprintf( stderr, "Usage: %s=GEOMETRY\n", foo );
+        fprintf( stderr, "Example: %s=1920x1080+0+0 or %s=256x256+100+-200\n", foo, foo );
+        fprintf( stderr, "Try -h or --help for help.\n" );
+        delete[] foo;
+        return 1;
+    }
+    delete[] foo;
+    return 0;
+}

options.hpp

     std::string m_xdisplay;
     float       m_gracetime;
     bool        m_keyboard;
+    bool        m_decorations;
+    int         m_offsetx;
+    int         m_offsety;
+    int         m_offsetw;
+    int         m_offseth;
 private:
     int         parseInt( std::string arg, int* returnInt );
     int         parseFloat( std::string arg, float* returnFloat );
     int         parseString( std::string arg, std::string* returnString );
+    int         parseGeometry( std::string arg, int* x, int* y, int* w, int* h );
     int         parseColor( std::string arg, float* r, float* g, float* b );
     bool        matches( std::string arg, std::string shorthand, std::string longhand );
 };

x.cpp

     m_good = false;
     m_mousex = -1;
     m_mousey = -1;
-    m_hoverXWindow = None;
+    m_hoverWindow = None;
 }
 
 slop::XEngine::~XEngine() {
                               xfontcursor, CurrentTime );
 }
 
+void slop::WindowRectangle::setGeometry( Window win, bool decorations ) {
+    Window junk;
+    if ( decorations ) {
+        unsigned int depth;
+        XGetGeometry( xengine->m_display, win, &junk,
+                      &(m_x), &(m_y),
+                      &(m_width), &(m_height),
+                      &(m_border), &depth );
+        // We make sure we include borders, since we want decorations.
+        m_width += m_border * 2;
+        m_height += m_border * 2;
+        m_decorations = true;
+        return;
+    }
+    Window root;
+    Window* children = NULL;
+    unsigned int childcount;
+    // Try to get the first child of the specified window, to avoid decorations.
+    XQueryTree( xengine->m_display, win, &root, &junk, &children, &childcount );
+    if ( childcount == 1 && children ) {
+        win = children[ 0 ];
+        m_decorations = false;
+    } else {
+        //fprintf( stderr, "Warning: slop couldn't determine how to remove decorations, continuing without removing decorations...\n" );
+        m_decorations = true;
+    }
+    XWindowAttributes attr;
+    // We use XGetWindowAttributes to know our root window.
+    XGetWindowAttributes( xengine->m_display, win, &attr );
+    //m_x = attr.x;
+    //m_y = attr.y;
+    m_width = attr.width;
+    m_height = attr.height;
+    m_border = attr.border_width;
+    XTranslateCoordinates( xengine->m_display, win, attr.root, -attr.border_width, -attr.border_width, &(m_x), &(m_y), &junk );
+}
+
 slop::Rectangle::~Rectangle() {
     //XFreeGC( xengine->m_display, m_gc );
     if ( m_window == None ) {
 }
 
 void slop::XEngine::updateHoverWindow() {
-    Window root, child;
+    Window root, hoverwin;
     int mx, my;
     int wx, wy;
     unsigned int mask;
     // Query the pointer for the child window, the child window is basically the window we're hovering over.
-    XQueryPointer( m_display, m_root, &root, &child, &mx, &my, &wx, &wy, &mask );
+    XQueryPointer( m_display, m_root, &root, &hoverwin, &mx, &my, &wx, &wy, &mask );
     // If we already know that we're hovering over it, do nothing.
-    if ( m_hoverXWindow == child ) {
+    if ( m_hoverWindow == hoverwin ) {
         return;
     }
     // Make sure we can't select one of our selection rectangles, that's just weird.
     for ( unsigned int i=0; i<m_rects.size(); i++ ) {
-        if ( m_rects.at( i )->m_window == child ) {
+        if ( m_rects.at( i )->m_window == hoverwin ) {
             return;
         }
     }
-    m_hoverXWindow = child;
-    if ( child == None ) {
-        return;
-    }
-    // Generate the geometry values so we can use them if needed.
-    unsigned int depth;
-    XGetGeometry( m_display, child, &root,
-                  &(m_hoverWindow.m_x), &(m_hoverWindow.m_y),
-                  &(m_hoverWindow.m_width), &(m_hoverWindow.m_height),
-                  &(m_hoverWindow.m_border), &depth );
+    m_hoverWindow = hoverwin;
 }
 
-void slop::XEngine::updateHoverWindow( Window child ) {
+void slop::XEngine::updateHoverWindow( Window hoverwin ) {
     // Same thing as updateHoverWindow but it uses the specified child.
     // It's used when we first grab the cursor so it's slightly more effecient
     // than calling XQueryPointer twice.
-    if ( m_hoverXWindow == child ) {
+    if ( m_hoverWindow == hoverwin ) {
         return;
     }
     for ( unsigned int i=0; i<m_rects.size(); i++ ) {
-        if ( m_rects.at( i )->m_window == child ) {
+        if ( m_rects.at( i )->m_window == hoverwin ) {
             return;
         }
     }
-    m_hoverXWindow = child;
-    if ( child == None ) {
-        return;
-    }
-    unsigned int depth;
-    Window root;
-    XGetGeometry( m_display, child, &root,
-                  &(m_hoverWindow.m_x), &(m_hoverWindow.m_y),
-                  &(m_hoverWindow.m_width), &(m_hoverWindow.m_height),
-                  &(m_hoverWindow.m_border), &depth );
+    m_hoverWindow = hoverwin;
 }
 
 // Keeps our rectangle's sizes all positive, so Xlib doesn't throw an exception.

x.hpp

 
 class WindowRectangle {
 public:
-    int m_x;
-    int m_y;
+    int          m_x;
+    int          m_y;
     unsigned int m_width;
     unsigned int m_height;
     unsigned int m_border;
+    bool         m_decorations;
+    void         setGeometry( Window win, bool decorations );
 };
 
 class Rectangle {
     int                 init( std::string display );
     void                tick();
     int                 grabCursor( slop::CursorType type );
-    int                grabKeyboard();
+    int                 grabKeyboard();
     bool                anyKeyPressed();
     int                 releaseCursor();
     int                 releaseKeyboard();
     int                 m_mousey;
     std::vector<bool>   m_mouse;
     bool                mouseDown( unsigned int button );
-    WindowRectangle     m_hoverWindow;
-    Window              m_hoverXWindow;
+    Window              m_hoverWindow;
     bool                m_keypressed;
 private:
     void                updateHoverWindow();