Removed yet another dependency

CMakeLists.txt

 #Change this if you need to target a specific CMake version
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 2.6)
 
 set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)")
 if ( NOT CMAKE_INSTALL_PREFIX )
 project(slop)
 add_definitions(-DSLOP_VERSION="v5.3.21")
 
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_STANDARD_REQUIRED on)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall -Wno-missing-braces")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/")
 
 include_directories("${PROJECT_BINARY_DIR}")
 find_package(GLM REQUIRED)
 find_package(GLX REQUIRED)
 find_package(X11 REQUIRED)
-find_package(XExt REQUIRED) 
 
 include_directories(${X11_INCLUDE_DIR}
                     ${GLM_INCLUDE_DIR}

modules/FindXExt.cmake

-# - Find XExt
-# Find the XExtension libraries (WARNING: It's geared and tested specifically for the XShape extension though)
-#
-#  This module defines the following variables:
-#     XEXT_FOUND        - 1 if XEXT_INCLUDE_DIR & XEXT_LIBRARY are found, 0 otherwise
-#     XEXT_INCLUDE_DIR  - where to find Xlib.h, etc.
-#     XEXT_LIBRARY      - the X11 library
-#
-
-find_path( XEXT_INCLUDE_DIR
-           NAMES X11/extensions/shape.h
-           PATH_SUFFIXES X11/extensions
-           DOC "The XExtension include directory" )
-
-find_library( XEXT_LIBRARY
-              NAMES Xext
-              PATHS /usr/lib /lib
-              DOC "The XExtension library" )
-
-if( XEXT_INCLUDE_DIR AND XEXT_LIBRARY )
-    set( XEXT_FOUND 1 )
-else()
-    set( XEXT_FOUND 0 )
-endif()
-
-mark_as_advanced( XEXT_INCLUDE_DIR XEXT_LIBRARY )

src/main.cpp

 	std::cout << "                                  --color is set to a transparent color.\n";
 	std::cout << "                                  (default=off)\n";
 	std::cout << "      --shader=STRING           Sets the shader to load and use from\n";
-	std::cout << "                                  ~/.config/slop/ or /usr/share/.\n";
+	std::cout << "                                  ~/.config/slop/\n";
 	std::cout << "                                  (default=`simple')\n";
 	std::cout << "  -f, --format=STRING           Set the output format string. Format specifiers\n";
 	std::cout << "                                  are %x, %y, %w, %h, %i, %g, and %c.\n";
 	std::cout << "    $ # Classic Windows XP selection.\n";
 	std::cout << "    $ slop -l -c 0.3,0.4,0.6,0.4\n";
 	std::cout << "\n";
-	std::cout << "    $ # Wiggle wiggle!\n";
-	std::cout << "    $ slop --opengl --shader wiggle\n";
-	std::cout << "\n";
 	std::cout << "    $ # Change output format to use safer parsing\n";
 	std::cout << "    $ slopoutput=$(slop -f \"%x %y %w %h\")\n";
 	std::cout << "    $ X=$(echo $slopoutput | awk '{print $1}')\n";

src/mouse.cpp

                               xcursor, CurrentTime );
 }
 
-Mouse::Mouse(X11* x11, bool nodecorations ) {
+Mouse::Mouse(X11* x11, bool nodecorations, Window ignoreWindow ) {
     this->x11 = x11;
     currentCursor = XC_cross;
     xcursor = XCreateFontCursor( x11->display, XC_cross );
     XGrabPointer( x11->display, x11->root, True,
                   PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
                   GrabModeAsync, GrabModeAsync, None, xcursor, CurrentTime );
-
-    Window root;
-    int mx, my;
-    int wx, wy;
-    unsigned int 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 );
+    this->nodecorations = nodecorations;
+    this->ignoreWindow = ignoreWindow;
+    hoverWindow = findWindow(x11->root);
 }
 
 Mouse::~Mouse() {
     while ( XCheckTypedEvent( x11->display, ButtonPress, &event ) ) {
 		setButton( event.xbutton.button, 1 );
 	}
+    bool findNewWindow = false;
+    while ( XCheckTypedEvent( x11->display, MotionNotify, &event ) ) {
+        findNewWindow = true;
+	}
+    if ( findNewWindow ) {
+        hoverWindow = findWindow(x11->root);
+    }
     while ( XCheckTypedEvent( x11->display, ButtonRelease, &event ) ) {
 		setButton( event.xbutton.button, 0 );
 	}
 	}
 }
 
-// This cheesy function makes sure we get all EnterNotify events on ALL the windows.
-void Mouse::selectAllInputs( Window win, bool nodecorations ) {
+Window Mouse::findWindow( Window foo ) {
+    glm::vec2 pos = getMousePos();
     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 );
+    Window selectedWindow;
+    XQueryTree( x11->display, foo, &root, &parent, &children, &nchildren );
+    // The children are ordered, so we traverse backwards.
+    if ( !children || nchildren <= 0 ) {
+        return foo;
+    }
+    for( int i=nchildren-1;i>=0;i-- ) {
+        if ( children[i] == ignoreWindow ) {
+            continue;
+        }
+        glm::vec4 rect = getWindowGeometry(children[i], false);
+        float a = pos.x - rect.x;
+        float b = pos.y - rect.y;
+        if ( a <= rect.z && a >= 0 ) {
+            if ( b <= rect.w && b >= 0 ) {
+                selectedWindow = children[i];
+                if ( !nodecorations ) {
+                    XFree(children);
+                    return selectedWindow;
+                } else {
+                    XFree(children);
+                    return findWindow( selectedWindow );
+                }
+            }
         }
     }
-    free( children );
+    return foo;
 }

src/mouse.hpp

 #include <iostream>
 
 #include "x.hpp"
+#include "windowhelper.hpp"
 
 class Mouse {
 private:
     std::vector<glm::ivec2> buttons;
     Cursor xcursor;
     int currentCursor;
-    void selectAllInputs( Window win, bool nodecorations = false );
+    Window findWindow( Window foo );
+    bool nodecorations;
+    Window ignoreWindow;
 public:
 	Window hoverWindow;
 	void update();
-    Mouse( X11* x11, bool nodecorations );
+    Mouse( X11* x11, bool nodecorations, Window ignoreWindow );
     ~Mouse();
     void setCursor( int cursor );
     glm::vec2 getMousePos();

src/slop.cpp

     resource = new Resource();
     // Set up x11 temporarily
     x11 = new X11(options->xdisplay);
-    mouse = new Mouse( x11, options->nodecorations );
     keyboard = new Keyboard( x11 );
 
     // Set up window with GL context
     SlopWindow* window = new SlopWindow();
 
+    mouse = new Mouse( x11, options->nodecorations, window->window );
+
     if ( options->shader != "textured" ) {
         window->framebuffer->setShader( options->shader );
     }

src/window.cpp

     glViewport( 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
     camera = glm::ortho( 0.0f, (float)WidthOfScreen( x11->screen ), (float)HeightOfScreen( x11->screen ), 0.0f, -1.0f, 1.0f);
 
-    // Make it so all input falls through
-    XRectangle rect;
-    rect.x = rect.y = rect.width = rect.height = 0; 
-    XShapeCombineRectangles( x11->display, window, ShapeInput, 0, 0, &rect, 1, ShapeSet, 0);
-
     // Last, we actually display the window <:o)
 	XMapWindow( x11->display, window );
 }

src/window.hpp

 #include <glm/gtc/matrix_transform.hpp>
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
-#include <X11/extensions/shape.h>
 
 #include "x.hpp"
 #include "framebuffer.hpp"

src/windowhelper.cpp

 #include "windowhelper.hpp"
 
-glm::vec4 getWindowGeometry( Window win, bool removeDecoration ) {
+glm::vec4 getWindowGeometry( Window win, bool removeDecoration) {
     XWindowAttributes attr;         
     XGetWindowAttributes( x11->display, win, &attr );
     unsigned int width = attr.width;