added no decoration flag

src/main.cpp

     SlopOptions* foo = new SlopOptions();
     options.getFloat("bordersize", 'b', foo->borderSize);
     options.getFloat("padding", 'p', foo->padding);
+    options.getFloat("tolerance", 't', foo->tolerance);
     glm::vec4 color = glm::vec4( foo->r, foo->g, foo->b, foo->a );
     options.getColor("color", 'c', color);
     foo->r = color.r;
     foo->b = color.b;
     foo->a = color.a;
     options.getBool("highlight", 'h', foo->highlight);
+    options.getBool("nodecorations", 'n', foo->nodecorations);
     return foo;
 }
 
                 case 'g':
                 case 'G': output << round(selection.w) << "x" << round(selection.h)
                           << "+" << round(selection.x) << "+" << round(selection.y); break;
+                case 'i':
+                case 'I': output << selection.id; break;
                 case '%': output << "%"; break;
-                default: throw new std::invalid_argument( std::string()+"Expected x, y, w, h, g, or % after % in format. Got `" + input[i+1] + "`." );
+                default: throw new std::invalid_argument( std::string()+"Expected x, y, w, h, g, i, or % after % in format. Got `" + input[i+1] + "`." );
              }
             i++;
             continue;
 
     // We want to validate our format option if we got one, we do that by just doing a dry run
     // on a fake selection.
-    SlopSelection selection(0,0,0,0);
+    SlopSelection selection(0,0,0,0,0);
     std::string format;
     bool gotFormat = options.getString("format", 'f', format);
     if ( gotFormat ) {
         return 0;
     }
     // Otherwise we default to an `eval` compatible format.
-    std::cout << formatOutput( "X=%x\nY=%y\nW=%w\nH=%h\nG=%g\n", selection );
+    std::cout << formatOutput( "X=%x\nY=%y\nW=%w\nH=%h\nG=%g\nID=%i\n", selection );
     return 0;
 }
 

src/mouse.cpp

                               xcursor, CurrentTime );
 }
 
-Mouse::Mouse(X11* x11) {
+Mouse::Mouse(X11* x11, bool nodecorations ) {
     this->x11 = x11;
     currentCursor = XC_cross;
     xcursor = XCreateFontCursor( x11->display, XC_cross );
     int mx, my;
     int wx, wy;
     unsigned int mask;
-    XQueryPointer( x11->display, x11->root, &root, &hoverWindow, &mx, &my, &wx, &wy, &mask );
+    if ( nodecorations ) {
+        // Get the deepest available window if we don't want decorations.
+        Window child = x11->root;
+        while( child ) {
+            hoverWindow = child;
+            XQueryPointer( x11->display, child, &root, &child, &mx, &my, &wx, &wy, &mask );
+        }
+    } else {
+        XQueryPointer( x11->display, x11->root, &root, &hoverWindow, &mx, &my, &wx, &wy, &mask );
+    }
+    selectAllInputs( x11->root, nodecorations );
 }
 
 Mouse::~Mouse() {
 	}
 }
 
+// This cheesy function makes sure we get all EnterNotify events on ALL the windows.
+void Mouse::selectAllInputs( Window win, bool nodecorations ) {
+    Window root, parent;
+    Window* children;
+    unsigned int nchildren;
+    XQueryTree( x11->display, win, &root, &parent, &children, &nchildren );
+    for ( unsigned int i=0;i<nchildren;i++ ) {
+            XSelectInput( x11->display, children[ i ], EnterWindowMask );
+        if ( nodecorations ) {
+            selectAllInputs( children[i], nodecorations );
+        }
+    }
+    free( children );
+}

src/mouse.hpp

     std::vector<glm::ivec2> buttons;
     Cursor xcursor;
     int currentCursor;
+    void selectAllInputs( Window win, bool nodecorations = false );
 public:
 	Window hoverWindow;
 	void update();
-    Mouse( X11* x11 );
+    Mouse( X11* x11, bool nodecorations );
     ~Mouse();
     void setCursor( int cursor );
     glm::vec2 getMousePos();

src/options.hpp

 #include <vector>
 #include <glm/glm.hpp>
 
-static std::string validStringArguments[] = { "bordersize", "padding", "color", "shader", "highlight", "format" };
-static char validCharArguments[] = { 'b', 'p', 'c', 's', 'h', 'f' };
+static std::string validStringArguments[] = { "bordersize", "padding", "color", "shader", "highlight", "format", "tolerance", "nodecorations", "nokeyboard" };
+static char validCharArguments[] = { 'b', 'p', 'c', 's', 'h', 'f', 't', 'n', 'k' };
 // 0 for flag, 1 for how many arguments to eat up
-static unsigned int isFlagArgument[] = { false, false, false, false, true, false };
-static unsigned int validArgumentCount = 6;
+static unsigned int isFlagArgument[] = { false, false, false, false, true, false, false, true, true };
+static unsigned int validArgumentCount = 9;
 static unsigned int maxFloatingValues = 0;
 
 class Options {

src/slop.cpp

 // Defaults!
 SlopOptions::SlopOptions() {
     borderSize = 1;
+    nodecorations = false;
+    tolerance = 4;
     padding = 0;
     shader = "textured";
     highlight = false;
     a = 1;
 }
 
-SlopSelection::SlopSelection( float x, float y, float w, float h ) {
+SlopSelection::SlopSelection( float x, float y, float w, float h, Window id ) {
     this->x = x;
     this->y = y;
     this->w = w;
     this->h = h;
+    this->id = id;
 }
 
 SlopMemory::SlopMemory( SlopOptions* options ) {
     running = true;
     state = (SlopState*)new SlopStart();
     nextState = NULL;
+    tolerance = options->tolerance;
+    nodecorations = options->nodecorations;
     rectangle = new Rectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight);
+    selectedWindow = x11->root;
     state->onEnter( *this );
 }
 
         options = new SlopOptions();
     }
     resource = new Resource();
-    // Set up wayland temporarily
+    // Set up x11 temporarily
     x11 = new X11(":0");
-    mouse = new Mouse( x11 );
+    mouse = new Mouse( x11, options->nodecorations );
     keyboard = new Keyboard( x11 );
 
     // Set up window with GL context
     glClearColor (0.0, 0.0, 0.0, 0.0);
     glClear (GL_COLOR_BUFFER_BIT);
     window->display();
-    glClearColor (0.0, 0.0, 0.0, 0.0);
     glClear (GL_COLOR_BUFFER_BIT);
     window->display();
     // Then we clean up.
         delete options;
     }
     // Finally return the data.
-    return SlopSelection( output.x, output.y, output.z+1, output.w+1 );
+    return SlopSelection( output.x, output.y, output.z+1, output.w+1, memory.selectedWindow );
 }

src/slop.hpp

     SlopOptions();
     float borderSize;
     float padding;
+    float tolerance;
     bool highlight;
+    bool nodecorations;
     std::string shader;
     float r;
     float g;
 
 class SlopSelection {
 public:
-    SlopSelection( float x, float y, float w, float h );
+    SlopSelection( float x, float y, float w, float h, Window id );
     float x;
     float y;
     float w;
     float h;
+    Window id;
 };
 
 class SlopMemory {
 public:
     SlopMemory( SlopOptions* options );
     ~SlopMemory();
+    Window selectedWindow;
     bool running;
+    float tolerance;
+    bool nodecorations;
     Rectangle* rectangle;
     void setState( SlopState* state );
     void update( double dt );

src/slopstates.cpp

         startPos = mouse->getMousePos();
         setStartPos = true;
     }
-    if ( setStartPos && glm::distance( startPos, mouse->getMousePos() ) > 4 ) {
+    if ( setStartPos && glm::distance( startPos, mouse->getMousePos() ) >= memory.tolerance ) {
         memory.setState( (SlopState*)new SlopStartDrag( startPos ) );
     }
     if ( mouse->hoverWindow != None ) {
-        glm::vec4 rect = getWindowGeometry( mouse->hoverWindow, true );
+        glm::vec4 rect = getWindowGeometry( mouse->hoverWindow, memory.nodecorations );
         memory.rectangle->setPoints( glm::vec2( (float)rect.x, (float)rect.y ), glm::vec2( (float)rect.x+rect.z, (float)rect.y+rect.w ) );
     }
     if ( setStartPos && !mouse->getButton( 1 ) ) {
+        memory.selectedWindow = mouse->hoverWindow;
         memory.setState( (SlopState*)new SlopEndDrag() );
     }
 }
 
 void SlopStart::draw( SlopMemory& memory, glm::mat4 matrix ) {
-    memory.rectangle->draw( matrix );
+    if ( memory.tolerance > 0 ) {
+        memory.rectangle->draw( matrix );
+    }
 }
 
 SlopStartDrag::SlopStartDrag( glm::vec2 point ) {

src/x.cpp

     screen = ScreenOfDisplay( display, DefaultScreen( display ) );
     visual = DefaultVisual( display, XScreenNumberOfScreen( screen ) );
     root = DefaultRootWindow( display );
-    selectAllInputs( root );
 }
 
 X11::~X11() {
     XCloseDisplay( display );
 }
-
-// This cheesy function makes sure we get all EnterNotify events on ALL the windows.
-void X11::selectAllInputs( Window win ) {
-    Window root, parent;
-    Window* children;
-    unsigned int nchildren;
-    XQueryTree( display, win, &root, &parent, &children, &nchildren );
-    for ( unsigned int i=0;i<nchildren;i++ ) {
-        XSelectInput( display, children[ i ], EnterWindowMask );
-        selectAllInputs( children[i] );
-    }
-    free( children );
-}

src/x.hpp

 #include <stdexcept>
 
 class X11 {
-private:
-    void selectAllInputs( Window win );
 public:
     X11( std::string displayName );
     ~X11();