getting closer

CMakeLists.txt

 find_package(GLX REQUIRED)
 find_package(X11 REQUIRED)
 find_package(XExt REQUIRED) 
-find_package(XRender REQUIRED)
-find_package(RT) 
 
 include_directories(${X11_INCLUDE_DIR}
                     ${GLM_INCLUDE_DIR}
                     ${GLX_INCLUDE_DIR}
-                    ${XRENDER_INCLUDE_DIRS}
                     ${OPENGL_INCLUDE_DIR})
 
-if ( RT_INCLUDE_DIR )
-    include_directories(${RT_INCLUDE_DIR})
-endif()
-
 target_link_libraries(${EXECUTABLE_NAME} ${X11_LIBRARIES}
                                          ${GLX_LIBRARIES}
-                                         ${XRENDER_LIBRARIES}
                                          ${OPENGL_LIBRARIES})
-if ( RT_LIBRARY )
-    target_link_libraries(${EXECUTABLE_NAME} ${RT_LIBRARY})
-endif()
-
 
 # Install targets
 install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )

modules/FindRT.cmake

-# - Find rt
-# Find the rt libraries, this is to fix ubuntu not having clock_gettime defined without it.
-#
-#  This module defines the following variables:
-#     RT_FOUND        - 1 if RT_INCLUDE_DIR & RT_LIBRARY are found, 0 otherwise
-#     RT_INCLUDE_DIR  - where to find Xlib.h, etc.
-#     RT_LIBRARY      - the X11 library
-#
-
-find_path( RT_INCLUDE_DIR
-           NAMES time.h )
-
-find_library( RT_LIBRARY
-              NAMES rt
-              PATHS /usr/lib /lib )
-
-if( RT_INCLUDE_DIR AND RT_LIBRARY )
-    set( RT_FOUND 1 )
-else()
-    set( RT_FOUND 0 )
-endif()
-
-mark_as_advanced( RT_INCLUDE_DIR RT_LIBRARY )

modules/FindXRender.cmake

-# - Find XRender
-# Find the XRender libraries
-#
-# This module defines the following variables:
-#   XRENDER_FOUND - true if XRENDER_INCLUDE_DIR & XRENDER_LIBRARY are found
-#   XRENDER_LIBRARIES - Set when Xrender_LIBRARY is found
-#   XRENDER_INCLUDE_DIRS - Set when Xrender_INCLUDE_DIR is found
-#
-#   XRENDER_INCLUDE_DIR - where to find Xrender.h, etc.
-#   XRENDER_LIBRARY - the Xrender library
-#
-
-#=============================================================================
-# Copyright 2013 Corey Clayton <can.of.tuna@gmail.com>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#=============================================================================
-
-find_path(XRENDER_INCLUDE_DIR NAMES X11/extensions/Xrender.h
-          PATHS /opt/X11/include
-          DOC "The Xrender include directory")
-
-find_library(XRENDER_LIBRARY NAMES Xrender
-          PATHS /opt/X11/lib
-          DOC "The Xrender library")
-
-include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(Xrender DEFAULT_MSG XRENDER_LIBRARY XRENDER_INCLUDE_DIR)
-
-if(XRENDER_FOUND)
-
-    set(XRENDER_LIBRARIES ${XRENDER_LIBRARY})
-    set(XRENDER_INCLUDE_DIRS ${XRENDER_INCLUDE_DIR})
-
-endif()
-
-mark_as_advanced(XRENDER_INCLUDE_DIR XRENDER_LIBRARY)

src/keyboard.cpp

 }
 
 bool Keyboard::anyKeyDown() {
-    // Thanks to SFML for some reliable key state grabbing.
-    // Get the whole keyboard state
-    char keys[ 32 ];
+    return keyDown;
+}
+
+void Keyboard::update() {
+    char keys[32];
     XQueryKeymap( x11->display, keys );
-    // Each bit indicates a different key, 1 for pressed, 0 otherwise.
-    // Every bit should be 0 if nothing is pressed.
-    for ( unsigned int i = 0; i < 32; i++ ) {
-        if ( keys[ i ] != 0 ) {
-            return true;
+    keyDown = false;
+    for ( int i=0;i<32;i++ ) {
+        if ( deltaState[i] == keys[i] ) {
+            continue;
+        }
+        // Found a key in a group of 4 that's different
+        char a = deltaState[i];
+        char b = keys[i];
+        // Find the "different" bits
+        char c = a^b;
+        // A new key was pressed since the last update.
+        if ( c && b&c ) {
+            keyDown = true;
         }
+        deltaState[i] = keys[i];
     }
-    return false;
 }
 
 Keyboard::Keyboard( X11* x11 ) {
     if ( err != GrabSuccess ) {
         throw new std::runtime_error( "Failed to grab keyboard.\n" );
     }
+    XQueryKeymap( x11->display, deltaState );
+    keyDown = false;
 }
 
 Keyboard::~Keyboard() {

src/keyboard.hpp

 
 class Keyboard {
 private:
+    char deltaState[32];
     X11* x11;
+    bool keyDown;
 public:
     Keyboard( X11* x11 );
     ~Keyboard();
+    void update();
     bool getKey( KeySym key );
     bool anyKeyDown();
 };

src/mouse.cpp

 	XUngrabPointer( x11->display, CurrentTime );
 }
 
-void Mouse::tick() {
+void Mouse::update() {
     XEvent event;
     while ( XCheckTypedEvent( x11->display, ButtonPress, &event ) ) {
 		setButton( event.xbutton.button, 1 );
 		setButton( event.xbutton.button, 0 );
 	}
     while ( XCheckTypedEvent( x11->display, EnterNotify, &event ) ) {
-		if ( event.xcrossing.subwindow != None ) {
-			hoverWindow = event.xcrossing.subwindow;
-		} else {
-			hoverWindow = event.xcrossing.window;
-		}
+        subWindow = event.xcrossing.subwindow;
+        hoverWindow = event.xcrossing.window;
+        std::cout << hoverWindow << "\n";
 	}
 }
 

src/mouse.hpp

 #include <vector>
 #include <glm/glm.hpp>
 #include <X11/cursorfont.h>
+#include <iostream>
 
 #include "x.hpp"
 
     int currentCursor;
 public:
 	Window hoverWindow;
-	void tick();
+	Window subWindow;
+	void update();
     Mouse( X11* x11 );
     ~Mouse();
     void setCursor( int cursor );

src/slop.cpp

     SlopMemory memory( options );
 
     // This is where we'll run through all of our stuffs
-    //FIXME: We need to sync up with wayland's draw pings so that we don't overdraw ever...
     while( memory.running ) {
-        mouse->tick();
+        mouse->update();
+        keyboard->update();
         // We move our statemachine forward.
         memory.update( 1 );
 
         if ( err != GL_NO_ERROR ) {
             throw err;
         }
-        if ( keyboard->anyKeyDown() || mouse->getButton( 2 ) ) {
+        if ( keyboard->anyKeyDown() || mouse->getButton( 3 ) ) {
             memory.running = false;
             if ( cancelled ) {
                 *cancelled = true;

src/window.cpp

         throw new std::runtime_error("Failed to load function pointers for OpenGL.");
     }
     framebuffer = new Framebuffer( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
-	XMapWindow( x11->display, window );
+
+    // Then we do a basic double clear (double buffered).
     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);
+    glClearColor( 0, 0, 0, 0 );
+    glClear( GL_COLOR_BUFFER_BIT );
+    display();
+
+    // 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 );
 }
 
 SlopWindow::~SlopWindow() {

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/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

 #ifndef N_X_H_
 #define N_X_H_
 
+#include <iostream>
 #include <X11/Xlib.h>
 #include <string>
 #include <stdexcept>
 
 class X11 {
 private:
+    void selectAllInputs( Window win );
 public:
     X11( std::string displayName );
     ~X11();