Added option --maximumsize, using pixel-based selection rather than boundary-based so slop can no longer output a size of 0x0 (unless a window is that size and you somehow hover over it), improved render speed for slower laptops.

main.cpp

@@ -30,6 +30,59 @@ void printSelection( bool cancelled, int x, int y, int w, int h ) {
     }
 }
 
+void constrain( int sx, int sy, int ex, int ey, int padding, int minimumsize, int maximumsize, int* rsx, int* rsy, int* rex, int* rey ) {
+    if ( minimumsize > maximumsize && maximumsize > 0 ) {
+        fprintf( stderr, "Error: minimumsize is greater than maximumsize.\n" );
+        exit( 1 );
+    }
+    int x = std::min( sx, ex );
+    int y = std::min( sy, ey );
+    // We add one to make sure we select the pixel under the mouse.
+    int w = std::max( sx, ex ) - x + 1;
+    int h = std::max( sy, ey ) - y + 1;
+    // Make sure we don't turn inside out...
+    if ( w + padding*2 >= 0 ) {
+        x -= padding;
+        w += padding*2;
+    }
+    if ( h + padding*2 >= 0 ) {
+        y -= padding;
+        h += padding*2;
+    }
+    if ( w < minimumsize ) {
+        int diff = minimumsize - w;
+        w = minimumsize;
+        x -= diff/2;
+    }
+    if ( h < minimumsize ) {
+        int diff = minimumsize - h;
+        h = minimumsize;
+        y -= diff/2;
+    }
+    if ( maximumsize > 0 ) {
+        if ( w > maximumsize ) {
+            int diff = w;
+            w = maximumsize;
+            x += diff/2 - maximumsize/2;
+        }
+        if ( h > maximumsize ) {
+            int diff = h;
+            h = maximumsize;
+            y += diff/2 - maximumsize/2;
+        }
+    }
+    // Center around mouse if we have a fixed size.
+    if ( maximumsize == minimumsize && w == maximumsize && h == maximumsize ) {
+        x = ex - maximumsize/2;
+        y = ey - maximumsize/2;
+        xengine->setCursor( slop::Cross );
+    }
+    *rsx = x;
+    *rsy = y;
+    *rex = x + w;
+    *rey = y + h;
+}
+
 int main( int argc, char** argv ) {
     int err = options->parseOptions( argc, argv );
     if ( err ) {
@@ -56,6 +109,7 @@ int main( int argc, char** argv ) {
     int wmem = 0;
     int hmem = 0;
     int minimumsize = options->m_minimumsize;
+    int maximumsize = options->m_maximumsize;
 
     // First we set up the x interface and grab the mouse,
     // if we fail for either we exit immediately.
@@ -106,17 +160,18 @@ int main( int argc, char** argv ) {
                 if ( window != xengine->m_hoverWindow && tolerance > 0 ) {
                     slop::WindowRectangle t;
                     t.setGeometry( xengine->m_hoverWindow, decorations );
+                    t.applyPadding( padding );
+                    t.applyMinMaxSize( minimumsize, maximumsize );
                     // Make sure we only apply offsets to windows that we've forcibly removed decorations on.
                     if ( !selection ) {
                         selection = new slop::Rectangle( t.m_x,
                                                          t.m_y,
-                                                         t.m_width,
-                                                         t.m_height,
-                                                         borderSize, padding,
-                                                         minimumsize, minimumsize,
+                                                         t.m_x + t.m_width,
+                                                         t.m_y + t.m_height,
+                                                         borderSize,
                                                          r, g, b );
                     } else {
-                        selection->setGeo( t.m_x, t.m_y, t.m_width, t.m_height );
+                        selection->setGeo( t.m_x, t.m_y, t.m_x + t.m_width, t.m_y + t.m_height );
                     }
                     window = xengine->m_hoverWindow;
                 }
@@ -148,10 +203,10 @@ int main( int argc, char** argv ) {
                 if ( !selection ) {
                     selection = new slop::Rectangle( cx,
                                                      cy,
-                                                     xengine->m_mousex - cx,
-                                                     xengine->m_mousey - cy,
-                                                     borderSize, padding,
-                                                     minimumsize, minimumsize,
+                                                     // We add one because pixels start at 0
+                                                     xengine->m_mousex + 1,
+                                                     xengine->m_mousey + 1,
+                                                     borderSize,
                                                      r, g, b );
                 }
                 // If the user has let go of the mouse button, we'll just
@@ -165,14 +220,14 @@ int main( int argc, char** argv ) {
                 int h = xengine->m_mousey - cy;
                 if ( ( std::abs( w ) < tolerance && std::abs( h ) < tolerance ) ) {
                     // We make sure the selection rectangle stays on the window we had selected
-                    selection->setGeo( xmem, ymem, wmem, hmem );
+                    selection->setGeo( xmem, ymem, xmem + wmem, ymem + hmem );
                     xengine->setCursor( slop::Left );
                     continue;
                 }
                 // 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 ( selection->m_width == 0 && selection->m_height == 0 ) {
+                bool x = cx > xengine->m_mousex;
+                bool y = cy > xengine->m_mousey;
+                if ( selection->m_width <= 1 && selection->m_height <= 1 ) {
                     xengine->setCursor( slop::Cross );
                 } else if ( !x && !y ) {
                     xengine->setCursor( slop::LowerRightCorner );
@@ -183,18 +238,11 @@ int main( int argc, char** argv ) {
                 } 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 ( cx + w == xengine->getWidth() - 1 ) {
-                    w = xengine->getWidth() - cx;
-                }
-                if ( cy + h == xengine->getHeight() - 1 ) {
-                    h = xengine->getHeight() - cy;
-                }
+                // Apply padding and minimum size adjustments.
+                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.
-                // We use the function setDim since rectangles can't have negative widths,
-                // and because the rectangles have borders and padding to worry about.
-                selection->setGeo( cx, cy, w, h );
+                selection->setGeo( sx, sy, ex, ey );
                 break;
             }
             case 3: {
@@ -204,8 +252,8 @@ int main( int argc, char** argv ) {
                 // 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.
-                x = selection->m_x+selection->m_xoffset;
-                y = selection->m_y+selection->m_yoffset;
+                x = selection->m_x;
+                y = selection->m_y;
                 w = selection->m_width;
                 h = selection->m_height;
                 // Delete the rectangle, which will remove it from the screen.

options.cpp

@@ -3,7 +3,7 @@
 slop::Options* options = new slop::Options();
 
 slop::Options::Options() {
-    m_version = "v2.0.5";
+    m_version = "v2.0.6";
     m_borderSize = 10;
     m_padding = 0;
     m_xdisplay = ":0";
@@ -15,6 +15,7 @@ slop::Options::Options() {
     m_keyboard = true;
     m_decorations = true;
     m_minimumsize = 0;
+    m_maxsize = 0;
 }
 
 void slop::Options::printHelp() {
@@ -33,7 +34,8 @@ 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( "    -min=INT, --minimumsize=INT    sets the minimum output of width or height values, useful to avoid outputting 0\n" );
+    printf( "    -max=INT, --maxsize=INT        sets the maximum output of width or height values.\n" );
     printf( "                                   widths or heights.\n" );
     printf( "    -v, --version                  prints version.\n" );
     printf( "\n" );
@@ -61,11 +63,16 @@ int slop::Options::parseOptions( int argc, char** argv ) {
             if ( m_borderSize < 0 ) {
                 m_borderSize = 0;
             }
-        } else if ( matches( arg, "-m=", "--minimumsize=" ) ) {
+        } else if ( matches( arg, "-min=", "--minimumsize=" ) ) {
             int err = parseInt( arg, &m_minimumsize );
             if ( err ) {
                 return 1;
             }
+        } else if ( matches( arg, "-max=", "--minimumsize=" ) ) {
+            int err = parseInt( arg, &m_maximumsize );
+            if ( err ) {
+                return 1;
+            }
         } else if ( matches( arg, "-p=", "--padding=" ) ) {
             int err = parseInt( arg, &m_padding );
             if ( err ) {
@@ -116,6 +123,10 @@ int slop::Options::parseOptions( int argc, char** argv ) {
             return 1;
         }
     }
+    if ( m_minimumsize > m_maximumsize && m_maximumsize > 0 ) {
+        fprintf( stderr, "Error: minimumsize is greater than maximumsize.\n" );
+        return 1;
+    }
     return 0;
 }
 

options.hpp

@@ -16,6 +16,8 @@ public:
     int         m_padding;
     int         m_tolerance;
     int         m_minimumsize;
+    int         m_maximumsize;
+    int         m_maxsize;
     float       m_red;
     float       m_green;
     float       m_blue;

rectangle.cpp

@@ -14,24 +14,18 @@ slop::Rectangle::~Rectangle() {
     XEvent event;
     // Block until the window is actually completely removed.
     XIfEvent( xengine->m_display, &event, &isDestroyNotify, (XPointer)&m_window );
+    // Sleep for 0.1 seconds in hope that the screen actually cleared the window.
+    usleep( 10000 );
 }
 
-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;
+slop::Rectangle::Rectangle( int sx, int sy, int ex, int ey, int border, float r, float g, float b ) {
+    m_x = std::min( sx, ex );
+    m_y = std::min( sy, ey );
+    m_width = std::max( sx, ex ) - m_x;
+    m_height = std::max( sy, ey ) - m_y;
     m_border = border;
-    m_padding = padding;
     m_window = None;
 
-    // Convert the width, height, x, and y to coordinates that don't have negative values.
-    // (also adjust for padding and border size.)
-    constrain( width, height );
     // If we don't have a border, we don't exist, so just die.
     if ( m_border == 0 ) {
         return;
@@ -54,8 +48,8 @@ slop::Rectangle::Rectangle( int x, int y, int width, int height, int border, int
     attributes.event_mask = StructureNotifyMask;
     unsigned long valueMask = CWBackPixmap | CWBackPixel | CWOverrideRedirect | CWColormap | CWEventMask;
 
-    // Create the window offset by our generated offsets (see constrain( float, float ))
-    m_window = XCreateWindow( xengine->m_display, xengine->m_root, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border, m_width+m_border*2, m_height+m_border*2,
+    // Create the window
+    m_window = XCreateWindow( xengine->m_display, xengine->m_root, m_x-m_border, m_y-m_border, m_width+m_border*2, m_height+m_border*2,
                               0, CopyFromParent, InputOutput,
                               CopyFromParent, valueMask, &attributes );
 
@@ -75,63 +69,27 @@ slop::Rectangle::Rectangle( int x, int y, int width, int height, int border, int
     XMapWindow( xengine->m_display, m_window );
 }
 
-void slop::Rectangle::setPos( int x, int y ) {
-    if ( m_x == x && m_y == y ) {
-        return;
-    }
-    m_x = x;
-    m_y = y;
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
-    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
-}
-
-void slop::Rectangle::setDim( int w, int h ) {
-    if ( m_width == w && m_height == h ) {
-        return;
-    }
-
-    constrain( w, h );
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
-
-    // Change the window size and location to our generated offsets (see constrain( float, float ))
-    XResizeWindow( xengine->m_display, m_window, m_width+m_border*2, m_height+m_border*2 );
-    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
-    // Regenerate our hole
-    XRectangle rect;
-    rect.x = rect.y = 0;
-    rect.width = m_width+m_border*2;
-    rect.height = m_height+m_border*2;
-    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
-    // Then punch out another.
-    rect.x = rect.y = m_border;
-    rect.width = m_width;
-    rect.height = m_height;
-    XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
-}
-
-void slop::Rectangle::setGeo( int x, int y, int w, int h ) {
+void slop::Rectangle::setGeo( int sx, int sy, int ex, int ey ) {
+    int x = std::min( sx, ex );
+    int y = std::min( sy, ey );
+    int w = std::max( sx, ex ) - x;
+    int h = std::max( sy, ey ) - y;
     if ( m_x == x && m_y == y && m_width == w && m_height == h ) {
         return;
     }
 
     m_x = x;
     m_y = y;
-    constrain( w, h );
+    m_width = w;
+    m_height = h;
     // If we don't have a border, we don't exist, so just die.
     if ( m_border == 0 ) {
         return;
     }
 
-    // Change the window size and location to our generated offsets (see constrain( float, float ))
+    // Change the window size
     XResizeWindow( xengine->m_display, m_window, m_width+m_border*2, m_height+m_border*2 );
-    XMoveWindow( xengine->m_display, m_window, m_x+m_xoffset-m_border, m_y+m_yoffset-m_border );
-    // Regenerate our hole
+    // Fill up our old hole
     XRectangle rect;
     rect.x = rect.y = 0;
     rect.width = m_width+m_border*2;
@@ -142,44 +100,7 @@ void slop::Rectangle::setGeo( int x, int y, int w, int h ) {
     rect.width = m_width;
     rect.height = m_height;
     XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSubtract, 0);
-}
-
-// Keeps our rectangle's sizes all positive, so Xlib doesn't throw an exception.
-// It also keeps our values in absolute coordinates which is nice.
-void slop::Rectangle::constrain( int w, int h ) {
-    int pad = m_padding;
-    if ( pad < 0 && std::abs( w ) < std::abs( pad ) * 2 ) {
-        pad = 0;
-    }
-    if ( w < 0 ) {
-        m_flippedx = true;
-        m_xoffset = w - pad;
-        m_width = -w + pad * 2;
-    } else {
-        m_flippedx = false;
-        m_xoffset = -pad;
-        m_width = w + pad * 2;
-    }
-
-    pad = m_padding;
-    if ( pad < 0 && std::abs( h ) < std::abs( pad ) * 2 ) {
-        pad = 0;
-    }
-    if ( h < 0 ) {
-        m_flippedy = true;
-        m_yoffset = h - pad;
-        m_height = -h + pad * 2;
-    } else {
-        m_flippedy = false;
-        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;
-    }
+    XMoveWindow( xengine->m_display, m_window, m_x-m_border, m_y-m_border );
 }
 
 int slop::Rectangle::convertColor( float r, float g, float b ) {

rectangle.hpp

@@ -20,7 +20,7 @@ namespace slop {
 
 class Rectangle {
 public:
-            Rectangle( int x, int y, int width, int height, int border, int padding, int minimumwidth, int minimumheight, float r, float g, float b );
+            Rectangle( int sx, int sy, int ex, int ey, int border, float r, float g, float b );
             ~Rectangle();
     void    setPos( int x, int y );
     void    setDim( int w, int h );
@@ -29,16 +29,9 @@ public:
     XColor  m_color;
     int     m_x;
     int     m_y;
-    int     m_xoffset;
-    int     m_yoffset;
-    int     m_minimumwidth;
-    int     m_minimumheight;
     int     m_width;
     int     m_height;
     int     m_border;
-    int     m_padding;
-    bool    m_flippedx;
-    bool    m_flippedy;
 private:
     int     convertColor( float r, float g, float b );
     void    constrain( int w, int h );

x.cpp

@@ -268,6 +268,48 @@ void slop::XEngine::setCursor( slop::CursorType type ) {
                               xfontcursor, CurrentTime );
 }
 
+void slop::WindowRectangle::applyPadding( int padding ) {
+    if ( m_width + padding*2 >= 0 ) {
+        m_x -= padding;
+        m_width += padding*2;
+    }
+    if ( m_height + padding*2 >= 0 ) {
+        m_y -= padding;
+        m_height += padding*2;
+    }
+}
+
+void slop::WindowRectangle::applyMinMaxSize( int minimumsize, int maximumsize ) {
+    if ( minimumsize > maximumsize && maximumsize > 0 ) {
+        fprintf( stderr, "Error: minimumsize is greater than maximumsize.\n" );
+        exit( 1 );
+    }
+    if ( m_width < minimumsize ) {
+        int diff = minimumsize - m_width;
+        m_width = minimumsize;
+        m_x -= diff/2;
+    }
+    if ( m_height < minimumsize ) {
+        int diff = minimumsize - m_height;
+        m_height = minimumsize;
+        m_y -= diff/2;
+    }
+    if ( maximumsize > 0 ) {
+        if ( m_width > maximumsize ) {
+            int diff = m_width;
+            m_width = maximumsize;
+            // Center in the center of the window
+            m_x += diff/2 - maximumsize/2;
+        }
+        if ( m_height > maximumsize ) {
+            int diff = m_height;
+            m_height = maximumsize;
+            // Center in the center of the window
+            m_y += diff/2 - maximumsize/2;
+        }
+    }
+}
+
 void slop::WindowRectangle::setGeometry( Window win, bool decorations ) {
     if ( decorations ) {
         Window root, parent, test, junk;

x.hpp

@@ -38,6 +38,8 @@ public:
     unsigned int m_border;
     bool         m_decorations;
     void         setGeometry( Window win, bool decorations );
+    void         applyPadding( int padding );
+    void         applyMinMaxSize( int minimumsize, int maximumsize );
 };
 
 class XEngine {