some progress

CMakeLists.txt

@@ -10,10 +10,10 @@ if( NOT CMAKE_INSTALL_PREFIX )
 endif()
 
 if( NOT SHADER_PREFIX )
-    set( SHADER_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "The path where slop thinks it resides in, so that it can find the shaders. This is not necessarily the CMAKE_INSTALL_PREFIX. For example if the shaders will exist in /usr/share/slop-wayland, SHADER_PREFIX should be \"/usr\"." )
+    set( SHADER_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "The path where slop thinks it resides in, so that it can find the shaders. This is not necessarily the CMAKE_INSTALL_PREFIX. For example if the shaders will exist in /usr/share/slop, SHADER_PREFIX should be \"/usr\"." )
 endif()
 
-project(slop-wayland)
+project(slop)
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED on)
@@ -23,22 +23,21 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/")
 include_directories("${PROJECT_BINARY_DIR}")
 
 # Define sources and executable
-set(EXECUTABLE_NAME "slop-wayland")
-
-set( source
-         src/wayland.cpp
-         src/window.cpp
-         src/mouse.cpp
-         src/keyboard.cpp
-         src/framebuffer.cpp
-         src/resource.cpp
-         src/options.cpp
-         src/gl_core_3_3.c
-         src/shader.cpp
-         src/slopstates.cpp
-         src/slop.cpp
-         src/rectangle.cpp
-         src/main.cpp )
+set(EXECUTABLE_NAME "slop")
+
+set( source src/x.cpp
+            src/window.cpp
+            src/mouse.cpp
+            src/keyboard.cpp
+            src/framebuffer.cpp
+            src/resource.cpp
+            src/options.cpp
+            src/gl_core_3_3.c
+            src/shader.cpp
+            src/slopstates.cpp
+            src/slop.cpp
+            src/rectangle.cpp
+            src/main.cpp )
 
 add_executable(${EXECUTABLE_NAME} ${source})
 
@@ -47,23 +46,32 @@ add_executable(${EXECUTABLE_NAME} ${source})
 set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" )
 #Find any version 2.X of SFML
 #See the FindSFML.cmake file for additional details and instructions
-find_package(Wayland REQUIRED)
-find_package(EGL REQUIRED)
 find_package(OpenGL REQUIRED)
 find_package(GLM REQUIRED)
+find_package(GLX REQUIRED)
+find_package(X11 REQUIRED)
+find_package(XExt REQUIRED) 
+find_package(XRender REQUIRED)
+find_package(RT) 
 
-include_directories(${WAYLAND_CLIENT_INCLUDE_DIR}
-                    ${WAYLAND_CURSOR_INCLUDE_DIR}
-                    ${WAYLAND_EGL_INCLUDE_DIR}
-                    ${EGL_INCLUDE_DIR}
+include_directories(${X11_INCLUDE_DIR}
                     ${GLM_INCLUDE_DIR}
+                    ${GLX_INCLUDE_DIR}
+                    ${XRENDER_INCLUDE_DIRS}
                     ${OPENGL_INCLUDE_DIR})
 
-target_link_libraries(${EXECUTABLE_NAME} ${WAYLAND_CLIENT_LIBRARIES}
-                      ${WAYLAND_CURSOR_LIBRARIES}
-                      ${WAYLAND_EGL_LIBRARIES}
-                      ${EGL_LIBRARIES}
-                      ${OPENGL_LIBRARIES})
+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/FindEGL.cmake

@@ -1,53 +0,0 @@
-# - Try to Find EGL
-# Once done, this will define
-#
-#  EGL_FOUND - system has EGL installed.
-#  EGL_INCLUDE_DIRS - directories which contain the EGL headers.
-#  EGL_LIBRARIES - libraries required to link against EGL.
-#  EGL_DEFINITIONS - Compiler switches required for using EGL.
-#
-# Copyright (C) 2012 Intel Corporation. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-# 1.  Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-# 2.  Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS
-# IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-find_package(PkgConfig)
-
-pkg_check_modules(PC_EGL egl)
-
-if (PC_EGL_FOUND)
-    set(EGL_DEFINITIONS ${PC_EGL_CFLAGS_OTHER})
-endif ()
-
-find_path(EGL_INCLUDE_DIRS NAMES EGL/egl.h
-    HINTS ${PC_EGL_INCLUDEDIR} ${PC_EGL_INCLUDE_DIRS}
-)
-
-set(EGL_NAMES ${EGL_NAMES} egl EGL)
-find_library(EGL_LIBRARIES NAMES ${EGL_NAMES}
-    HINTS ${PC_EGL_LIBDIR} ${PC_EGL_LIBRARY_DIRS}
-)
-
-include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(EGL DEFAULT_MSG EGL_INCLUDE_DIRS EGL_LIBRARIES)
-
-mark_as_advanced(EGL_INCLUDE_DIRS EGL_LIBRARIES)

modules/FindGLX.cmake

@@ -0,0 +1,44 @@
+# Try to find GLX. Once done, this will define:
+#
+#   GLX_FOUND - variable which returns the result of the search
+#   GLX_INCLUDE_DIRS - list of include directories
+#   GLX_LIBRARIES - options for the linker
+
+#=============================================================================
+# Copyright 2012 Benjamin Eikel
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+find_package(PkgConfig)
+pkg_check_modules(PC_GLX QUIET glx)
+
+find_path(GLX_INCLUDE_DIR
+    GL/glx.h
+    HINTS ${PC_GLX_INCLUDEDIR} ${PC_GLX_INCLUDE_DIRS}
+)
+find_library(GLX_LIBRARY
+    GL
+    HINTS ${PC_GLX_LIBDIR} ${PC_GLX_LIBRARY_DIRS}
+)
+
+set(GLX_INCLUDE_DIRS ${GLX_INCLUDE_DIR})
+set(GLX_LIBRARIES ${GLX_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GLX DEFAULT_MSG
+    GLX_INCLUDE_DIR
+    GLX_LIBRARY
+)
+
+mark_as_advanced(
+    GLX_INCLUDE_DIR
+    GLX_LIBRARY
+)

modules/FindRT.cmake

@@ -0,0 +1,23 @@
+# - 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/FindWayland.cmake

@@ -1,67 +0,0 @@
-# Try to find Wayland on a Unix system
-#
-# This will define:
-#
-#   WAYLAND_FOUND       - True if Wayland is found
-#   WAYLAND_LIBRARIES   - Link these to use Wayland
-#   WAYLAND_INCLUDE_DIR - Include directory for Wayland
-#   WAYLAND_DEFINITIONS - Compiler flags for using Wayland
-#
-# In addition the following more fine grained variables will be defined:
-#
-#   WAYLAND_CLIENT_FOUND  WAYLAND_CLIENT_INCLUDE_DIR  WAYLAND_CLIENT_LIBRARIES
-#   WAYLAND_SERVER_FOUND  WAYLAND_SERVER_INCLUDE_DIR  WAYLAND_SERVER_LIBRARIES
-#   WAYLAND_EGL_FOUND     WAYLAND_EGL_INCLUDE_DIR     WAYLAND_EGL_LIBRARIES
-#   WAYLAND_CURSOR_FOUND  WAYLAND_CURSOR_INCLUDE_DIR  WAYLAND_CURSOR_LIBRARIES
-#
-# Copyright (c) 2013 Martin Gräßlin <mgraesslin@kde.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-IF (NOT WIN32)
-  IF (WAYLAND_INCLUDE_DIR AND WAYLAND_LIBRARIES)
-    # In the cache already
-    SET(WAYLAND_FIND_QUIETLY TRUE)
-  ENDIF ()
-
-  # Use pkg-config to get the directories and then use these values
-  # in the FIND_PATH() and FIND_LIBRARY() calls
-  FIND_PACKAGE(PkgConfig)
-  PKG_CHECK_MODULES(PKG_WAYLAND QUIET wayland-client wayland-server wayland-egl wayland-cursor)
-
-  SET(WAYLAND_DEFINITIONS ${PKG_WAYLAND_CFLAGS})
-
-  FIND_PATH(WAYLAND_CLIENT_INCLUDE_DIR  NAMES wayland-client.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-  FIND_PATH(WAYLAND_SERVER_INCLUDE_DIR  NAMES wayland-server.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-  FIND_PATH(WAYLAND_EGL_INCLUDE_DIR     NAMES wayland-egl.h    HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-  FIND_PATH(WAYLAND_CURSOR_INCLUDE_DIR  NAMES wayland-cursor.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-
-  FIND_LIBRARY(WAYLAND_CLIENT_LIBRARIES NAMES wayland-client   HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-  FIND_LIBRARY(WAYLAND_SERVER_LIBRARIES NAMES wayland-server   HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-  FIND_LIBRARY(WAYLAND_EGL_LIBRARIES    NAMES wayland-egl      HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-  FIND_LIBRARY(WAYLAND_CURSOR_LIBRARIES NAMES wayland-cursor   HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-
-  set(WAYLAND_INCLUDE_DIR ${WAYLAND_CLIENT_INCLUDE_DIR} ${WAYLAND_SERVER_INCLUDE_DIR} ${WAYLAND_EGL_INCLUDE_DIR} ${WAYLAND_CURSOR_INCLUDE_DIR})
-
-  set(WAYLAND_LIBRARIES ${WAYLAND_CLIENT_LIBRARIES} ${WAYLAND_SERVER_LIBRARIES} ${WAYLAND_EGL_LIBRARIES} ${WAYLAND_CURSOR_LIBRARIES})
-
-  list(REMOVE_DUPLICATES WAYLAND_INCLUDE_DIR)
-
-  include(FindPackageHandleStandardArgs)
-
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CLIENT  DEFAULT_MSG  WAYLAND_CLIENT_LIBRARIES  WAYLAND_CLIENT_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_SERVER  DEFAULT_MSG  WAYLAND_SERVER_LIBRARIES  WAYLAND_SERVER_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_EGL     DEFAULT_MSG  WAYLAND_EGL_LIBRARIES     WAYLAND_EGL_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CURSOR  DEFAULT_MSG  WAYLAND_CURSOR_LIBRARIES  WAYLAND_CURSOR_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND         DEFAULT_MSG  WAYLAND_LIBRARIES         WAYLAND_INCLUDE_DIR)
-
-  MARK_AS_ADVANCED(
-        WAYLAND_INCLUDE_DIR         WAYLAND_LIBRARIES
-        WAYLAND_CLIENT_INCLUDE_DIR  WAYLAND_CLIENT_LIBRARIES
-        WAYLAND_SERVER_INCLUDE_DIR  WAYLAND_SERVER_LIBRARIES
-        WAYLAND_EGL_INCLUDE_DIR     WAYLAND_EGL_LIBRARIES
-        WAYLAND_CURSOR_INCLUDE_DIR  WAYLAND_CURSOR_LIBRARIES
-  )
-
-ENDIF ()

modules/FindXExt.cmake

@@ -0,0 +1,26 @@
+# - 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 )

modules/FindXRender.cmake

@@ -0,0 +1,47 @@
+# - 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/framebuffer.cpp

@@ -6,7 +6,7 @@ Framebuffer::Framebuffer( int w, int h ) {
     glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
     glGenTextures(1, &image);
     glBindTexture(GL_TEXTURE_2D, image);
-    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, image, 0);

src/keyboard.cpp

@@ -1,58 +1,41 @@
 #include "keyboard.hpp"
 
-static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {
-}
-
-static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface, struct wl_array *keys) {
-}
-
-static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {
-}
-
-static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t state) {
-    Keyboard* kb = (Keyboard*)data;
-    kb->setKey( key, state );
-}
-
-static void keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {
-}
-
-static const struct wl_keyboard_listener keyboard_listener = {
-    keyboard_handle_keymap,
-    keyboard_handle_enter,
-    keyboard_handle_leave,
-    keyboard_handle_key,
-    keyboard_handle_modifiers,
-};
-
-Keyboard::Keyboard(Wayland* wayland) {
-    wl_keyboard_add_listener(wl_seat_get_keyboard(wayland->seat), &keyboard_listener, this);
+bool Keyboard::getKey( KeySym key ) {
+    KeyCode keycode = XKeysymToKeycode( x11->display, key );
+    if ( keycode != 0 ) {
+        // Get the whole keyboard state
+        char keys[32];
+        XQueryKeymap( x11->display, keys );
+        // Check our keycode
+        return ( keys[ keycode / 8 ] & ( 1 << ( keycode % 8 ) ) ) != 0;
+    } else {
+        return false;
+    }
 }
 
-void Keyboard::setKey( int key, int state ) {
-    for (unsigned int i=0;i<keys.size();i++ ) {
-        if ( keys[i].x == key ) {
-            keys[i].y = state;
-            return;
+bool Keyboard::anyKeyDown() {
+    // Thanks to SFML for some reliable key state grabbing.
+    // Get the whole keyboard state
+    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;
         }
     }
-    keys.push_back(glm::ivec2(key,state));
+    return false;
 }
 
-int Keyboard::getKey( int button ) {
-    for (unsigned int i=0;i<keys.size();i++ ) {
-        if ( keys[i].x == button ) {
-            return keys[i].y;
-        }
+Keyboard::Keyboard( X11* x11 ) {
+    this->x11 = x11;
+    int err = XGrabKeyboard( x11->display, x11->root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
+    if ( err != GrabSuccess ) {
+        throw new std::runtime_error( "Failed to grab keyboard.\n" );
     }
-    return 0;
 }
 
-bool Keyboard::anyKeyDown() {
-    for ( glm::ivec2 combo : keys ) {
-        if ( combo.y == 1 ) {
-            return true;
-        }
-    }
-    return false;
+Keyboard::~Keyboard() {
+    XUngrabKeyboard( x11->display, CurrentTime );
 }

src/keyboard.hpp

@@ -1,4 +1,4 @@
-/* keyboard.hpp: Interfaces with wayland to grab key press information.
+/* keyboard.hpp: Interfaces with x11 to grab key press information.
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -21,18 +21,15 @@
 #ifndef N_KEYBOARD_H_
 #define N_KEYBOARD_H_
 
-#include <glm/glm.hpp>
-#include <wayland-client.h>
-#include <vector>
-#include "wayland.hpp"
+#include "x.hpp"
 
 class Keyboard {
 private:
-    std::vector<glm::ivec2> keys;
+    X11* x11;
 public:
-    Keyboard( Wayland* wayland );
-    void setKey( int key, int state );
-    int getKey( int key );
+    Keyboard( X11* x11 );
+    ~Keyboard();
+    bool getKey( KeySym key );
     bool anyKeyDown();
 };
 

src/mouse.cpp

@@ -1,51 +1,5 @@
 #include "mouse.hpp"
 
-static void pointer_handle_enter(void *data, struct wl_pointer *pointer,
-		                         uint32_t serial, struct wl_surface *surface,
-		                         wl_fixed_t sx_w, wl_fixed_t sy_w) {
-    Mouse* m = (Mouse*)data;
-	float sx = wl_fixed_to_double(sx_w);
-	float sy = wl_fixed_to_double(sy_w);
-    m->setMousePos( sx, sy );
-    m->serial = serial;
-    m->pointer = pointer;
-    struct wl_cursor_image *image = m->cursor->images[0];
-    wl_pointer_set_cursor(pointer, serial, m->surface, image->hotspot_x, image->hotspot_y);
-}
-
-static void pointer_handle_leave(void *data, struct wl_pointer *pointer,
-		                         uint32_t serial, struct wl_surface *surface) {
-}
-
-static void pointer_handle_motion(void *data, struct wl_pointer *pointer,
-		                          uint32_t time, wl_fixed_t sx_w, wl_fixed_t sy_w)
-{
-    Mouse* m = (Mouse*)data;
-	float sx = wl_fixed_to_double(sx_w);
-	float sy = wl_fixed_to_double(sy_w);
-    m->pointer = pointer;
-    m->setMousePos( sx, sy );
-}
-
-static void pointer_handle_button(void *data, struct wl_pointer *pointer, uint32_t serial,
-                                  uint32_t time, uint32_t button, uint32_t state_w) {
-    Mouse* m = (Mouse*)data;
-    m->pointer = pointer;
-    m->setButton( button, state_w );
-}
-
-static void pointer_handle_axis(void *data, struct wl_pointer *pointer,
-		                        uint32_t time, uint32_t axis, wl_fixed_t value) {
-}
-
-static const struct wl_pointer_listener pointer_listener = {
-	pointer_handle_enter,
-	pointer_handle_leave,
-	pointer_handle_motion,
-	pointer_handle_button,
-	pointer_handle_axis,
-};
-
 void Mouse::setButton( int button, int state ) {
     for (unsigned int i=0;i<buttons.size();i++ ) {
         if ( buttons[i].x == button ) {
@@ -65,47 +19,53 @@ int Mouse::getButton( int button ) {
     return 0;
 }
 
-void Mouse::setMousePos(float x, float y) {
-    this->x = x;
-    this->y = y;
-}
-
 glm::vec2 Mouse::getMousePos() {
-    return glm::vec2( x, y );
+    Window root, child;
+    int mx, my;
+    int wx, wy;
+    unsigned int mask;
+    XQueryPointer( x11->display, x11->root, &root, &child, &mx, &my, &wx, &wy, &mask );
+    return glm::vec2( mx, my );
 }
 
-void Mouse::setCursor( std::string name ) {
-    if ( name == currentMouseCursor ) {
+void Mouse::setCursor( int cursor ) {
+    if ( currentCursor == cursor ) {
         return;
     }
-    // First we gotta delete the old mouse surface.
-    wl_surface_destroy( surface );
-
-    // Then we get the new cursor image.
-    cursor = wl_cursor_theme_get_cursor(theme, name.c_str());
-    struct wl_cursor_image *image = cursor->images[0];
-    struct wl_buffer *cursor_buf = wl_cursor_image_get_buffer(image);
-    
-    // Then we create the new surface
-    surface = wl_compositor_create_surface(wayland->compositor);
-    wl_surface_attach(surface, cursor_buf, 0, 0);
-    wl_surface_damage(surface, 0, 0, image->width, image->height);
-    wl_surface_commit(surface);
+    XFreeCursor( x11->display, xcursor );
+    xcursor = XCreateFontCursor( x11->display, cursor );
+    XChangeActivePointerGrab( x11->display,
+                              PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
+                              xcursor, CurrentTime );
+}
 
-    // Finally assign the surface as a pointer
-    wl_pointer_set_cursor(pointer, serial, surface, image->hotspot_x, image->hotspot_y);
+Mouse::Mouse(X11* x11) {
+    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 );
 }
 
-Mouse::Mouse(Wayland* wayland) {
-    wl_pointer_add_listener(wl_seat_get_pointer(wayland->seat), &pointer_listener, this);
-    theme = wl_cursor_theme_load("default", 16, wayland->shm );
-    cursor = wl_cursor_theme_get_cursor(theme, "cross");
-    std::string currentMouseCursor = "cross";
+Mouse::~Mouse() {
+	XUngrabPointer( x11->display, CurrentTime );
+}
 
-    surface = wl_compositor_create_surface(wayland->compositor);
-    struct wl_cursor_image *image = cursor->images[0];
-    struct wl_buffer *cursor_buf = wl_cursor_image_get_buffer(image);
-    wl_surface_attach(surface, cursor_buf, 0, 0);
-    wl_surface_damage(surface, 0, 0, image->width, image->height);
-    wl_surface_commit(surface);
+void Mouse::tick() {
+    XEvent event;
+    while ( XCheckTypedEvent( x11->display, ButtonPress, &event ) ) {
+		setButton( event.xbutton.button, 1 );
+	}
+    while ( XCheckTypedEvent( x11->display, ButtonRelease, &event ) ) {
+		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;
+		}
+	}
 }
+

src/mouse.hpp

@@ -1,4 +1,4 @@
-/* mouse.hpp: Interfaces with wayland to grab mouse information.
+/* mouse.hpp: Interfaces with x11 to grab mouse information.
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -21,27 +21,24 @@
 #ifndef N_MOUSE_H_
 #define N_MOUSE_H_
 
-#include <wayland-client.h>
-#include <wayland-cursor.h>
 #include <vector>
 #include <glm/glm.hpp>
-#include "linux/input-event-codes.h"
-#include "wayland.hpp"
+#include <X11/cursorfont.h>
+
+#include "x.hpp"
 
 class Mouse {
 private:
-    wl_cursor_theme* theme;
-    float x,y;
+    X11* x11;
     std::vector<glm::ivec2> buttons;
-    std::string currentMouseCursor;
+    Cursor xcursor;
+    int currentCursor;
 public:
-    wl_surface* surface;
-    wl_cursor* cursor;
-    wl_pointer* pointer;
-    int serial;
-    Mouse( Wayland* wayland );
-    void setMousePos( float x, float y );
-    void setCursor( std::string name );
+	Window hoverWindow;
+	void tick();
+    Mouse( X11* x11 );
+    ~Mouse();
+    void setCursor( int cursor );
     glm::vec2 getMousePos();
     void setButton( int button, int state );
     int getButton( int button );

src/resource.cpp

@@ -22,21 +22,21 @@
 
 Resource::Resource() {
     // Find the configuration directory.
-    // usually ~/.config/slop-wayland and /usr/share/slop-wayland
+    // usually ~/.config/slop and /usr/share/slop
     char* config = getenv( "XDG_CONFIG_HOME" );
     if ( config == NULL ) {
         char* home = getpwuid(getuid())->pw_dir;
         usrconfig += home;
-        usrconfig += "/.config/slop-wayland/";
-        // SHADER_PREFIX is defined within the CMakeLists.txt
+        usrconfig += "/.config/slop/";
+        // SHADER_PREFIX is defined by the user within CMake, defaults to `/usr`.
         sysconfig = SHADER_PREFIX;
-        sysconfig += "/share/slop-wayland/";
+        sysconfig += "/share/slop/";
         return;
     }
     usrconfig += config;
-    usrconfig += "/slop-wayland/";
+    usrconfig += "/slop/";
     sysconfig = SHADER_PREFIX;
-    sysconfig += "/share/slop-wayland/";
+    sysconfig += "/share/slop/";
 }
 
 std::string Resource::getRealPath( std::string localpath ) {

src/slop.cpp

@@ -1,6 +1,6 @@
 #include "slop.hpp"
 
-Wayland* wayland;
+X11* x11;
 Mouse* mouse;
 Keyboard* keyboard;
 Resource* resource;
@@ -69,17 +69,12 @@ SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
     }
     resource = new Resource();
     // Set up wayland temporarily
-    wayland = new Wayland();
-    wayland->init();
-    mouse = new Mouse( wayland );
-    keyboard = new Keyboard( wayland );
+    x11 = new X11(":0");
+    mouse = new Mouse( x11 );
+    keyboard = new Keyboard( x11 );
 
     // Set up window with GL context
-    Window* window = new Window( 1, 1 );
-    window->setTitle("slop");
-    window->setClass("slop");
-    window->setFullScreen();
-    window->setCurrent();
+    SlopWindow* window = new SlopWindow();
 
     window->framebuffer->setShader( options->shader );
 
@@ -89,8 +84,7 @@ SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
     // 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 ) {
-        // This is specifically for wayland updates.
-        wl_display_dispatch_pending(wayland->display);
+        mouse->tick();
         // We move our statemachine forward.
         memory.update( 1 );
 
@@ -108,7 +102,7 @@ SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
         if ( err != GL_NO_ERROR ) {
             throw err;
         }
-        if ( keyboard->anyKeyDown() || mouse->getButton( BTN_RIGHT ) ) {
+        if ( keyboard->anyKeyDown() || mouse->getButton( 2 ) ) {
             memory.running = false;
             if ( cancelled ) {
                 *cancelled = true;
@@ -132,7 +126,7 @@ SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
     // Then we clean up.
     delete window;
     delete mouse;
-    delete wayland;
+    delete x11;
     delete resource;
     if ( deleteOptions ) {
         delete options;

src/slopstates.cpp

@@ -13,7 +13,7 @@ void SlopState::draw( SlopMemory& memory, glm::mat4 matrix ) {
 
 // Start
 void SlopStart::update( SlopMemory& memory, double dt ) {
-    if ( mouse->getButton( BTN_LEFT ) ) {
+    if ( mouse->getButton( 1 ) ) {
         memory.setState( (SlopState*)new SlopStartDrag( mouse->getMousePos() ) );
     }
 }
@@ -32,12 +32,12 @@ void SlopStartDrag::update( SlopMemory& memory, double dt ) {
     char b = startPoint.x > mouse->getMousePos().x;
     char c = (a << 1) | b;
     switch ( c ) {
-        case 0: mouse->setCursor( "lr_angle" ); break;
-        case 1: mouse->setCursor( "ll_angle" ); break;
-        case 2: mouse->setCursor( "ur_angle" ); break;
-        case 3: mouse->setCursor( "ul_angle" ); break;
+        case 0: mouse->setCursor( XC_lr_angle ); break;
+        case 1: mouse->setCursor( XC_ll_angle ); break;
+        case 2: mouse->setCursor( XC_ur_angle ); break;
+        case 3: mouse->setCursor( XC_ul_angle ); break;
     }
-    if ( !mouse->getButton( BTN_LEFT ) ) {
+    if ( !mouse->getButton( 1 ) ) {
         memory.setState( (SlopState*)new SlopEndDrag() );
     }
 }

src/wayland.cpp

@@ -1,55 +0,0 @@
-#include "wayland.hpp"
-
-static void global_registry_handler(void *data, wl_registry* registry,
-                                    uint32_t id, const char* interface, uint32_t version) {
-    //std::cout << "Got register " << interface << " with id " << id << "\n";
-    if (std::string(interface) == "wl_compositor") {
-        wayland->compositor = (wl_compositor*)wl_registry_bind(registry, id, &wl_compositor_interface, 1);
-    } else if(std::string(interface) == "wl_shell") {
-        wayland->shell = (wl_shell*)wl_registry_bind(registry, id, &wl_shell_interface, 1);
-    } else if(std::string(interface) == "wl_shm") {
-        wayland->shm = (wl_shm*)wl_registry_bind(registry, id, &wl_shm_interface, 1);
-    } else if(std::string(interface) == "wl_seat") {
-        wayland->seat = (wl_seat*)wl_registry_bind(registry, id, &wl_seat_interface, 1);
-    } else if(std::string(interface) == "wl_output") {
-        wayland->output = (wl_output*)wl_registry_bind(registry, id, &wl_output_interface, 1);
-        //wl_list_insert(&output_list, &output->link);
-        //wl_output_add_listener(output->output, &output_listener, output);
-    }
-}
-
-static void global_registry_remover(void *data, struct wl_registry *registry, uint32_t id) {
-}
-
-static const struct wl_registry_listener registry_listener = {
-    global_registry_handler,
-    global_registry_remover
-};
-
-Wayland::Wayland() {
-    display = wl_display_connect(NULL);
-    if (!display) {
-        throw new std::runtime_error("Failed to connect to display.");
-    }
-}
-
-Wayland::~Wayland() {
-    wl_display_disconnect(display);
-}
-
-void Wayland::init() {
-    struct wl_registry *registry = wl_display_get_registry(display);
-    wl_registry_add_listener(registry, &registry_listener, NULL);
-
-    wl_display_dispatch(display);
-    wl_display_roundtrip(display);
-    if (!compositor) {
-        throw new std::runtime_error("Can't find compositor.");
-    }
-
-    egl_display = eglGetDisplay( display );
-    eglInitialize( egl_display, NULL, NULL );
-    if ( !egl_display ) {
-        throw new std::runtime_error("Failed to initialize EGL! (Thats the graphics stuff.)");
-    }
-}

src/window.cpp

@@ -1,80 +1,88 @@
 #include "window.hpp"
 
-static void shell_surface_ping (void *data, struct wl_shell_surface *shell_surface, uint32_t serial) {
-	wl_shell_surface_pong (shell_surface, serial);
-}
-static void shell_surface_configure (void *data, struct wl_shell_surface *shell_surface, uint32_t edges, int32_t width, int32_t height) {
-	Window* window = (Window*)data;
-	wl_egl_window_resize (window->egl_window, width, height, 0, 0);
-    window->camera = glm::ortho( 0.0f, (float)width, (float)height, 0.0f, -1.0f, 1.0f);
-    window->width = width;
-    window->height = height;
-    glViewport(0,0,width,height);
-    window->framebuffer->resize( width, height );
-}
-static void shell_surface_popup_done (void *data, struct wl_shell_surface *shell_surface) {
-	
-}
-static struct wl_shell_surface_listener shell_surface_listener = {&shell_surface_ping, &shell_surface_configure, &shell_surface_popup_done};
+SlopWindow::SlopWindow() {
+    XVisualInfo visual;
+    XMatchVisualInfo(x11->display, DefaultScreen(x11->display), 32, TrueColor, &visual);
+
+    XSetWindowAttributes attributes;
+    attributes.colormap = XCreateColormap( x11->display, x11->root, visual.visual, AllocNone );
+    attributes.background_pixmap = None;
+    attributes.border_pixel = 0;
+    // Disable window decorations.
+    attributes.override_redirect = True;
+    // Make sure we know when we've been successfully destroyed later!
+    //attributes.event_mask = StructureNotifyMask;
+    unsigned long valueMask = CWOverrideRedirect | CWColormap | CWBackPixmap | CWBorderPixel;
+
 
-Window::Window( unsigned int w, unsigned int h ) {
-    eglBindAPI (EGL_OPENGL_API);
-	EGLint attributes[] = {
-        EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
-		EGL_RED_SIZE, 8,
-		EGL_GREEN_SIZE, 8,
-		EGL_BLUE_SIZE, 8,
-		EGL_ALPHA_SIZE, 8,
-	EGL_NONE};
-    camera = glm::ortho( 0.0f, (float)w, (float)h, 0.0f, -1.0f, 1.0f);
-	EGLConfig config;
-	EGLint num_config;
-	eglChooseConfig (wayland->egl_display, attributes, &config, 1, &num_config);
-	egl_context = eglCreateContext (wayland->egl_display, config, EGL_NO_CONTEXT, NULL);
-	
-	surface = wl_compositor_create_surface (wayland->compositor);
-	shell_surface = wl_shell_get_shell_surface (wayland->shell, surface);
-	wl_shell_surface_add_listener (shell_surface, &shell_surface_listener, this);
-	wl_shell_surface_set_toplevel (shell_surface);
-	egl_window = wl_egl_window_create (surface, w, h);
-	egl_surface = eglCreateWindowSurface (wayland->egl_display, config, egl_window, NULL);
+    // Create the window
+    window = XCreateWindow( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ),
+                            0, visual.depth, InputOutput,
+                            visual.visual, valueMask, &attributes );
+
+    if ( !window ) {
+        throw new std::runtime_error( "Couldn't create a GL window!" );
+    }
+
+	// Prep some hints for the window
+    static char title[] = "slop";
+    XWMHints* startup_state = XAllocWMHints();
+    startup_state->initial_state = NormalState;
+    startup_state->flags = StateHint;
+    XTextProperty textprop;
+    textprop.value = (unsigned char*)title;
+    textprop.encoding = XA_STRING;
+    textprop.format = 8;
+    textprop.nitems = strlen( title );
+    XSizeHints sizehints;
+    sizehints.x = 0;
+    sizehints.y = 0;
+    sizehints.width = WidthOfScreen( x11->screen );
+    sizehints.height = HeightOfScreen( x11->screen );
+    sizehints.flags = USPosition | USSize;
+    XClassHint classhints;
+    char name[] = "slop";
+    classhints.res_name = name;
+    classhints.res_class = name;
+	// Finally send it all over...
+    XSetClassHint( x11->display, window, &classhints );
+    XSetWMProperties( x11->display, window, &textprop, &textprop, NULL, 0, &sizehints, startup_state, NULL );
+    XFree( startup_state );
+
+    // Load up a opengl context
+    context = glXCreateContext( x11->display, &visual, 0, True );
+    if ( !context ) {
+		throw new std::runtime_error( "Failed to create an OpenGL context." );
+    }
+    setCurrent();
+    // Finally we grab some OpenGL 3.3 stuffs.
     if(ogl_LoadFunctions() == ogl_LOAD_FAILED)
     {
         throw new std::runtime_error("Failed to load function pointers for OpenGL.");
     }
-    setCurrent();
-    framebuffer = new Framebuffer( w, h );
+    framebuffer = new Framebuffer( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
+	XMapWindow( x11->display, window );
+    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);
 }
 
-Window::~Window() {
+SlopWindow::~SlopWindow() {
     delete framebuffer;
-	eglDestroySurface (wayland->egl_display, egl_surface);
-	wl_egl_window_destroy (egl_window);
-	wl_surface_destroy (surface);
-	wl_shell_surface_destroy (shell_surface);
-	eglDestroyContext (wayland->egl_display, egl_context);
-}
-
-void Window::display() {
-	if (!eglSwapBuffers(wayland->egl_display, egl_surface)) {
-        throw new std::runtime_error("Failed to swap buffers.");
-    }
-}
-
-void Window::setFullScreen() {
-	wl_shell_surface_set_fullscreen(shell_surface, WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, NULL);
-}
-
-void Window::setCurrent() {
-	if (!eglMakeCurrent (wayland->egl_display, egl_surface, egl_surface, egl_context)) {
-        throw new std::runtime_error("Failed set EGL's current surface for rendering.");
-    }
+    // Try to erase the window before destroying it.
+    glClearColor( 0, 0, 0, 0 );
+    glClear( GL_COLOR_BUFFER_BIT );
+    display();
+    glClearColor( 0, 0, 0, 0 );
+    glClear( GL_COLOR_BUFFER_BIT );
+    display();
+    XDestroyWindow( x11->display, window );
 }
 
-void Window::setTitle(std::string title) {
-	wl_shell_surface_set_title(shell_surface, title.c_str());
+void SlopWindow::display() {
+    glXSwapBuffers( x11->display, window );
+    glXWaitGL();
 }
 
-void Window::setClass(std::string title) {
-	wl_shell_surface_set_class(shell_surface, title.c_str());
+void SlopWindow::setCurrent() {
+    glXMakeCurrent( x11->display, window, context ) ;
 }

src/window.hpp

@@ -24,33 +24,29 @@
 #include <string>
 #include <exception>
 
+#include <iostream>
 #include "gl_core_3_3.h"
-#include "wayland.hpp"
-//#include <GL/glew.h>
-#include <wayland-egl.h>
-#include <EGL/egl.h>
 #include <GL/gl.h>
+#include <GL/glx.h>
 #include <glm/gtc/matrix_transform.hpp>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
 
+#include "x.hpp"
 #include "framebuffer.hpp"
 
-class Window {
+// Gotta name it SlopWindow since Window and GLXWindow are taken... :/
+class SlopWindow {
 public:
     Framebuffer* framebuffer;
     int width, height;
     glm::mat4 camera;
-    Window( unsigned int w, unsigned int h );
-    ~Window();
-    void setFullScreen();
+    GLXWindow window;
+    GLXContext context;
+    SlopWindow();
+    ~SlopWindow();
     void setCurrent();
-    void setTitle( std::string title );
-    void setClass( std::string c );
     void display();
-    EGLContext egl_context;
-    struct wl_surface *surface;
-    struct wl_shell_surface *shell_surface;
-    struct wl_egl_window *egl_window;
-    EGLSurface egl_surface;
 };
 
 #endif // N_WINDOW_H_

src/x.cpp

@@ -0,0 +1,16 @@
+#include "x.hpp"
+
+X11::X11( std::string displayName ) {
+    // Initialize display
+    display = XOpenDisplay( displayName.c_str() );
+    if ( !display ) {
+        throw new std::runtime_error(std::string("Error: Failed to open X display: ") + displayName );
+    }
+    screen = ScreenOfDisplay( display, DefaultScreen( display ) );
+    visual = DefaultVisual( display, XScreenNumberOfScreen( screen ) );
+    root = DefaultRootWindow( display );
+}
+
+X11::~X11() {
+    XCloseDisplay( display );
+}

src/wayland.hpp → src/x.hpp

@@ -1,4 +1,4 @@
-/* wayland.hpp: Interfaces with wayland to get keyboard, mouse, windows...
+/* x.hpp: initializes x11
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -18,39 +18,24 @@
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef N_WAYLAND_H_
-#define N_WAYLAND_H_
+#ifndef N_X_H_
+#define N_X_H_
 
-#include <wayland-client.h>
-#include <wayland-egl.h>
-#include <EGL/egl.h>
+#include <X11/Xlib.h>
 #include <string>
-#include <iostream>
-#include <vector>
-#include <glm/glm.hpp>
+#include <stdexcept>
 
-//#include <mutter/meta/compositor-mutter.h>
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-class Wayland {
+class X11 {
+private:
 public:
-    Wayland();
-    ~Wayland();
-    void init();
-    wl_display* display;
-    wl_compositor* compositor;
-    wl_seat* seat;
-    wl_shell* shell;
-    wl_shm* shm;
-    wl_output* output;
-    EGLDisplay egl_display;
-    glm::vec2 mousepos;
-    std::vector<glm::vec4> getWindows();
+    X11( std::string displayName );
+    ~X11();
+    Display* display;
+    Visual* visual;
+    Screen* screen;
+    Window root;
 };
 
-extern Wayland* wayland;
+extern X11* x11;
 
-#endif // N_WAYLAND_H_
+#endif