Now slop will just fallback to the xshape extension if opengl fails.

CMakeLists.txt

     set(CMAKE_INSTALL_PREFIX "/usr")
 endif()
 
-if ( NOT SLOP_LEGACY_MODE )
-    set(SLOP_LEGACY_MODE FALSE CACHE BOOL "Legacy mode requires the XShape extension, is laggy, isn't guaranteed to be invisible on shutdown, isn't guaranteed to support opacity, doesn't support custom shaders, and requires C++11 for the sleep_for functions. Though it still might be desired since it doesn't require OpenGL to use. Your choice <:o)")
-endif()
-
 project(slop)
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/")
 # The names have to be unique unfortunately.
 set(EXECUTABLE_NAME "slop")
 set(LIBRARY_NAME "slopy")
-set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" )
-
-if ( SLOP_LEGACY_MODE )
-    add_definitions(-DSLOP_LEGACY_MODE=true)
-    add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
-                                        src/keyboard.cpp
-                                        src/x.cpp
-                                        src/slopstates.cpp
-                                        src/windowhelper.cpp
-                                        src/resource.cpp
-                                        src/xslop.cpp
-                                        src/xshaperectangle.cpp)
-    set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD 11)
-    set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
 
-    add_executable(${EXECUTABLE_NAME} src/options.cpp
-                                      src/main.cpp)
+add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
+                                    src/keyboard.cpp
+                                    src/x.cpp
+                                    src/slopstates.cpp
+                                    src/framebuffer.cpp
+                                    src/windowhelper.cpp
+                                    src/resource.cpp
+                                    src/gl_core_3_3.c
+                                    src/shader.cpp
+                                    src/window.cpp
+                                    src/slop.cpp
+                                    src/rectangle.cpp
+                                    src/xshaperectangle.cpp
+                                    src/glrectangle.cpp)
+
+set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD 11)
+set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
+
+add_executable(${EXECUTABLE_NAME} src/options.cpp
+                                  src/main.cpp)
 
-    # Detect and add cmake modules
-    find_package(GLM REQUIRED)
-    find_package(X11 REQUIRED)
-    find_package(XExt REQUIRED)
-    include_directories(${X11_INCLUDE_DIR}
-                        ${GLM_INCLUDE_DIR}
-                        ${XEXT_INCLUDE_DIR})
-    target_link_libraries(${EXECUTABLE_NAME} ${X11_LIBRARIES}
-                                             ${GLM_LIBRARIES}
-                                             ${XEXT_LIBRARIES}
-                                             ${LIBRARY_NAME})
-    # Install targets
-    install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
-    install( TARGETS ${LIBRARY_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/lib" )
-    install( FILES ${CMAKE_SOURCE_DIR}/src/slop.hpp DESTINATION "${CMAKE_INSTALL_PREFIX}/include" )
-else()
-    add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
-                                        src/keyboard.cpp
-                                        src/x.cpp
-                                        src/slopstates.cpp
-                                        src/framebuffer.cpp
-                                        src/windowhelper.cpp
-                                        src/resource.cpp
-                                        src/gl_core_3_3.c
-                                        src/shader.cpp
-                                        src/window.cpp
-                                        src/glslop.cpp
-                                        src/rectangle.cpp)
-
-    add_executable(${EXECUTABLE_NAME} src/options.cpp
-                                      src/main.cpp)
-
-    # Detect and add cmake modules
-    find_package(GLM REQUIRED)
-    find_package(X11 REQUIRED)
-    find_package(GLX REQUIRED)
-    find_package(OpenGL REQUIRED)
-    include_directories(${X11_INCLUDE_DIR}
-                        ${GLM_INCLUDE_DIR}
-                        ${GLX_INCLUDE_DIR}
-                        ${OPENGL_INCLUDE_DIR})
-    target_link_libraries(${EXECUTABLE_NAME} ${X11_LIBRARIES}
-                                             ${GLM_LIBRARIES}
-                                             ${OPENGL_LIBRARIES}
-                                             ${GLX_LIBRARY}
-                                             ${LIBRARY_NAME})
-    # Install targets
-    install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
-    install( TARGETS ${LIBRARY_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/lib" )
-    install( FILES ${CMAKE_SOURCE_DIR}/src/slop.hpp DESTINATION "${CMAKE_INSTALL_PREFIX}/include" )
-endif()
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" )
+find_package(GLM REQUIRED)
+find_package(X11 REQUIRED)
+find_package(XExt REQUIRED)
+find_package(GLX REQUIRED)
+find_package(OpenGL REQUIRED)
+include_directories(${X11_INCLUDE_DIR}
+                    ${GLM_INCLUDE_DIR}
+                    ${XEXT_INCLUDE_DIR}
+                    ${GLX_INCLUDE_DIR}
+                    ${OPENGL_INCLUDE_DIR})
+
+target_link_libraries(${EXECUTABLE_NAME} ${X11_LIBRARIES}
+                                         ${GLM_LIBRARIES}
+                                         ${OPENGL_LIBRARIES}
+                                         ${GLX_LIBRARY}
+                                         ${XEXT_LIBRARIES}
+                                         ${LIBRARY_NAME})
+
+install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
+install( TARGETS ${LIBRARY_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/lib" )
+install( FILES ${CMAKE_SOURCE_DIR}/src/slop.hpp DESTINATION "${CMAKE_INSTALL_PREFIX}/include" )

src/glrectangle.cpp

+#include "glrectangle.hpp"
+
+GLRectangle::GLRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
+    this->color = color;
+    this->border = border;
+    this->padding = padding;
+    this->highlight = highlight;
+    // Find each corner of the rectangle
+    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    // Offset the inner corners by the padding.
+    ul = ul + glm::vec2(-padding,padding);
+    bl = bl + glm::vec2(-padding,-padding);
+    ur = ur + glm::vec2(padding,padding);
+    br = br + glm::vec2(padding,-padding);
+    // Create the outer corners by offsetting the inner by the bordersize
+    oul = ul + glm::vec2(-border,border);
+    obl = bl + glm::vec2(-border,-border);
+    our = ur + glm::vec2(border,border);
+    obr = br + glm::vec2(border,-border);
+    generateBuffers();
+    std::string vert = "#version 130\nin vec2 position;\nuniform mat4 projection;\nvoid main() {\ngl_Position = projection*vec4(position,0,1);\n }";
+    std::string frag = "#version 130\nuniform vec4 color;\nout vec4 outColor;\nvoid main() {\noutColor = color;\n}";
+
+    shader = new Shader( vert, frag, false );
+}
+
+void GLRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+    // Find each corner of the rectangle
+    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    // Offset the inner corners by the padding.
+    ul = ul + glm::vec2(-padding,padding);
+    bl = bl + glm::vec2(-padding,-padding);
+    ur = ur + glm::vec2(padding,padding);
+    br = br + glm::vec2(padding,-padding);
+    // Create the outer corners by offsetting the inner by the bordersize
+    oul = ul + glm::vec2(-border,border);
+    obl = bl + glm::vec2(-border,-border);
+    our = ur + glm::vec2(border,border);
+    obr = br + glm::vec2(border,-border);
+    generateBuffers();
+}
+
+void GLRectangle::generateBuffers() {
+    std::vector<glm::vec2> rectangle_verts;
+    std::vector<glm::vec2> rectangle_uvs;
+    std::vector<glm::vec2> corner_verts;
+    std::vector<glm::vec2> corner_uvs;
+    std::vector<glm::vec2> center_verts;
+    std::vector<glm::vec2> center_uvs;
+
+    // Top left corner
+    corner_verts.push_back( oul );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( ul );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( ul + glm::vec2( -border, 0 ) );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( oul );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( ul + glm::vec2( 0, border ) );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( ul );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Top right corner
+    corner_verts.push_back( ur + glm::vec2( 0, border ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( ur + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( ur );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( ur + glm::vec2( 0, border ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( our );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( ur + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Bottom left corner
+    corner_verts.push_back( bl + glm::vec2( -border, 0 ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( obl + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( obl );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( bl + glm::vec2( -border, 0 ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( bl );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( bl + glm::vec2( 0, -border ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Bottom right corner
+    corner_verts.push_back( br );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( obr );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( br + glm::vec2( 0, -border ) );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( br );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( br + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( obr );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Left GLRectangle
+    rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( bl + glm::vec2( -border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ul );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    // Right GLRectangle
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( br + glm::vec2( border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( br );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ur + glm::vec2( border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( br + glm::vec2( border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    // Top GLRectangle
+    rectangle_verts.push_back( ul + glm::vec2( 0, border ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( ul );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( ul + glm::vec2( 0, border ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ur + glm::vec2( 0, border ) );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    // Bot GLRectangle
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( br + glm::vec2( 0, -border ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( bl + glm::vec2( 0, -border ) );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( br );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( br + glm::vec2( 0, -border ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    center_verts.push_back( ul );
+    center_uvs.push_back( glm::vec2(0, 1) );
+    center_verts.push_back( br );
+    center_uvs.push_back( glm::vec2(1, 0) );
+    center_verts.push_back( bl );
+    center_uvs.push_back( glm::vec2(0, 0) );
+
+    center_verts.push_back( ul );
+    center_uvs.push_back( glm::vec2(0, 1) );
+    center_verts.push_back( ur );
+    center_uvs.push_back( glm::vec2(1, 1) );
+    center_verts.push_back( br );
+    center_uvs.push_back( glm::vec2(1, 0) );
+
+    glGenBuffers( 6, (GLuint*)&buffer );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_verts );
+    glBufferData( GL_ARRAY_BUFFER, corner_verts.size() * sizeof( glm::vec2 ), &corner_verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_uvs );
+    glBufferData( GL_ARRAY_BUFFER, corner_uvs.size() * sizeof( glm::vec2 ), &corner_uvs[0], GL_STATIC_DRAW );
+
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_verts );
+    glBufferData( GL_ARRAY_BUFFER, rectangle_verts.size() * sizeof( glm::vec2 ), &rectangle_verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
+    glBufferData( GL_ARRAY_BUFFER, rectangle_uvs.size() * sizeof( glm::vec2 ), &rectangle_uvs[0], GL_STATIC_DRAW );
+
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.center_verts );
+    glBufferData( GL_ARRAY_BUFFER, center_verts.size() * sizeof( glm::vec2 ), &center_verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
+    glBufferData( GL_ARRAY_BUFFER, center_uvs.size() * sizeof( glm::vec2 ), &center_uvs[0], GL_STATIC_DRAW );
+    corner_vertCount = corner_verts.size();
+    rectangle_vertCount = rectangle_verts.size();
+    center_vertCount = center_verts.size();
+}
+
+GLRectangle::~GLRectangle() {
+    delete shader;
+    glDeleteBuffers( 6, (GLuint*)&buffer );
+}
+
+void GLRectangle::draw( glm::mat4& matrix ) {
+    glEnable( GL_BLEND );
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    shader->bind();
+    shader->setParameter( "projection", matrix );
+    if ( highlight ) {
+        // Draw the center of the highlight
+        shader->setParameter( "color", color );
+        shader->setAttribute( "position", buffer.center_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, center_vertCount );
+        // Set the color to have no alpha, then draw the borders.
+        glm::vec4 fullAlpha = glm::vec4(color.r,color.g,color.b,1);
+        shader->setParameter( "color", fullAlpha );
+        shader->setAttribute( "position", buffer.corner_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
+        shader->setAttribute( "position", buffer.rectangle_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
+    } else {
+        shader->setParameter( "color", color );
+        shader->setAttribute( "position", buffer.corner_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
+        shader->setAttribute( "position", buffer.rectangle_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
+    }
+    shader->unbind();
+    glDisable( GL_BLEND );
+}
+
+glm::vec4 GLRectangle::getRect() {
+    return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
+}

src/glrectangle.hpp

+/* rectangle.hpp: generates a vertex mesh and draws it.
+ *
+ * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
+ *
+ * This file is part of Slop.
+ *
+ * Slop is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Slop is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef N_GLRECTANGLE_H_
+#define N_GLRECTANGLE_H_
+
+#include "gl_core_3_3.h"
+#include <iostream>
+#include <glm/glm.hpp>
+#include <GL/gl.h>
+#include <vector>
+
+#include "shader.hpp"
+#include "rectangle.hpp"
+
+struct RectangleBuffer {
+    unsigned int corner_verts;
+    unsigned int corner_uvs;
+    unsigned int rectangle_verts;
+    unsigned int rectangle_uvs;
+    unsigned int center_verts;
+    unsigned int center_uvs;
+};
+
+class GLRectangle : public Rectangle {
+private:
+    glm::vec2 ul, oul;
+    glm::vec2 bl, obl;
+    glm::vec2 ur, our;
+    glm::vec2 br, obr;
+    bool highlight;
+    void generateBuffers();
+    RectangleBuffer buffer;
+    unsigned int corner_vertCount;
+    unsigned int rectangle_vertCount;
+    unsigned int center_vertCount;
+    float border;
+    float padding;
+    Shader* shader;
+    glm::vec4 color;
+public:
+    glm::vec4 getRect();
+    GLRectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false );
+    ~GLRectangle();
+    void setPoints( glm::vec2 p1, glm::vec2 p2 );
+    void draw(glm::mat4& matrix);
+};
+
+#endif // N_RECTANGLE_H_

src/glslop.cpp

-#include "slop.hpp"
-
-#include "slopstates.hpp"
-#include "mouse.hpp"
-#include "resource.hpp"
-#include "keyboard.hpp"
-
-#include "window.hpp"
-#include "shader.hpp"
-#include "framebuffer.hpp"
-#include "rectangle.hpp"
-
-
-X11* x11;
-Mouse* mouse;
-Keyboard* keyboard;
-Resource* resource;
-
-// Defaults!
-SlopOptions::SlopOptions() {
-    borderSize = 1;
-    nodecorations = false;
-    tolerance = 2;
-    padding = 0;
-    shader = "textured";
-    highlight = false;
-    xdisplay = ":0";
-    r = 0.5;
-    g = 0.5;
-    b = 0.5;
-    a = 1;
-}
-
-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;
-}
-
-SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
-    bool deleteOptions = false;
-    if ( !options ) {
-        deleteOptions = true;
-        options = new SlopOptions();
-    }
-    resource = new Resource();
-    // Set up x11 temporarily
-    x11 = new X11(options->xdisplay);
-    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 );
-    }
-
-    // Init our little state machine, memory is a tad of a misnomer
-    SlopMemory memory( options );
-
-    // This is where we'll run through all of our stuffs
-    while( memory.running ) {
-        mouse->update();
-        keyboard->update();
-        // We move our statemachine forward.
-        memory.update( 1 );
-
-        // Then we draw our junk to a framebuffer.
-        window->framebuffer->bind();
-        glClearColor (0.0, 0.0, 0.0, 0.0);
-        glClear (GL_COLOR_BUFFER_BIT);
-        memory.draw( window->camera );
-        window->framebuffer->unbind();
-
-        // Then we draw the framebuffer to the screen
-        window->framebuffer->draw();
-        window->display();
-        GLenum err = glGetError();
-        if ( err != GL_NO_ERROR ) {
-            throw err;
-        }
-        if ( keyboard->anyKeyDown() || mouse->getButton( 3 ) ) {
-            memory.running = false;
-            if ( cancelled ) {
-                *cancelled = true;
-            }
-        } else {
-            *cancelled = false;
-        }
-    }
-
-    // Now we should have a selection! We parse everything we know about it here.
-    glm::vec4 output = memory.rectangle->getRect();
-
-    // Lets now clear both front and back buffers before closing.
-    // hopefully it'll be completely transparent while closing!
-    glClearColor (0.0, 0.0, 0.0, 0.0);
-    glClear (GL_COLOR_BUFFER_BIT);
-    window->display();
-    glClear (GL_COLOR_BUFFER_BIT);
-    window->display();
-    // Then we clean up.
-    delete window;
-    delete mouse;
-    delete x11;
-    delete resource;
-    if ( deleteOptions ) {
-        delete options;
-    }
-    // Finally return the data.
-    return SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
-}

src/main.cpp

     options.getColor("color", 'c', color);
     options.getBool("nokeyboard", 'k', foo->nokeyboard);
     options.getString( "xdisplay", 'x', foo->xdisplay );
-#ifndef SLOP_LEGACY_MODE
     options.getString( "shader", 's', foo->shader );
-#endif
     foo->r = color.r;
     foo->g = color.g;
     foo->b = color.b;
 	std::cout << "                                  highlights it. This is only useful when\n";
 	std::cout << "                                  --color is set to a transparent color.\n";
 	std::cout << "                                  (default=off)\n";
-#ifndef SLOP_LEGACY_MODE
 	std::cout << "      --shader=STRING           Sets the shader to load and use from\n";
 	std::cout << "                                  ~/.config/slop/\n";
-#endif
 	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";

src/rectangle.cpp

 #include "rectangle.hpp"
 
-Rectangle::Rectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
-    this->color = color;
-    this->border = border;
-    this->padding = padding;
-    this->highlight = highlight;
-    // Find each corner of the rectangle
-    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
-    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
-    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
-    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
-    // Offset the inner corners by the padding.
-    ul = ul + glm::vec2(-padding,padding);
-    bl = bl + glm::vec2(-padding,-padding);
-    ur = ur + glm::vec2(padding,padding);
-    br = br + glm::vec2(padding,-padding);
-    // Create the outer corners by offsetting the inner by the bordersize
-    oul = ul + glm::vec2(-border,border);
-    obl = bl + glm::vec2(-border,-border);
-    our = ur + glm::vec2(border,border);
-    obr = br + glm::vec2(border,-border);
-    generateBuffers();
-    std::string vert = "#version 130\nin vec2 position;\nuniform mat4 projection;\nvoid main() {\ngl_Position = projection*vec4(position,0,1);\n }";
-    std::string frag = "#version 130\nuniform vec4 color;\nout vec4 outColor;\nvoid main() {\noutColor = color;\n}";
-
-    shader = new Shader( vert, frag, false );
-}
-
-void Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
-    // Find each corner of the rectangle
-    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
-    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
-    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
-    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
-    // Offset the inner corners by the padding.
-    ul = ul + glm::vec2(-padding,padding);
-    bl = bl + glm::vec2(-padding,-padding);
-    ur = ur + glm::vec2(padding,padding);
-    br = br + glm::vec2(padding,-padding);
-    // Create the outer corners by offsetting the inner by the bordersize
-    oul = ul + glm::vec2(-border,border);
-    obl = bl + glm::vec2(-border,-border);
-    our = ur + glm::vec2(border,border);
-    obr = br + glm::vec2(border,-border);
-    generateBuffers();
-}
-
-void Rectangle::generateBuffers() {
-    std::vector<glm::vec2> rectangle_verts;
-    std::vector<glm::vec2> rectangle_uvs;
-    std::vector<glm::vec2> corner_verts;
-    std::vector<glm::vec2> corner_uvs;
-    std::vector<glm::vec2> center_verts;
-    std::vector<glm::vec2> center_uvs;
-
-    // Top left corner
-    corner_verts.push_back( oul );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( ul );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-    corner_verts.push_back( ul + glm::vec2( -border, 0 ) );
-    corner_uvs.push_back( glm::vec2(0, 0) );
-
-    corner_verts.push_back( oul );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( ul + glm::vec2( 0, border ) );
-    corner_uvs.push_back( glm::vec2(1, 1) );
-    corner_verts.push_back( ul );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-
-    // Top right corner
-    corner_verts.push_back( ur + glm::vec2( 0, border ) );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( ur + glm::vec2( border, 0 ) );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-    corner_verts.push_back( ur );
-    corner_uvs.push_back( glm::vec2(0, 0) );
-
-    corner_verts.push_back( ur + glm::vec2( 0, border ) );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( our );
-    corner_uvs.push_back( glm::vec2(1, 1) );
-    corner_verts.push_back( ur + glm::vec2( border, 0 ) );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-
-    // Bottom left corner
-    corner_verts.push_back( bl + glm::vec2( -border, 0 ) );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( obl + glm::vec2( border, 0 ) );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-    corner_verts.push_back( obl );
-    corner_uvs.push_back( glm::vec2(0, 0) );
-
-    corner_verts.push_back( bl + glm::vec2( -border, 0 ) );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( bl );
-    corner_uvs.push_back( glm::vec2(1, 1) );
-    corner_verts.push_back( bl + glm::vec2( 0, -border ) );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-
-    // Bottom right corner
-    corner_verts.push_back( br );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( obr );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-    corner_verts.push_back( br + glm::vec2( 0, -border ) );
-    corner_uvs.push_back( glm::vec2(0, 0) );
-
-    corner_verts.push_back( br );
-    corner_uvs.push_back( glm::vec2(0, 1) );
-    corner_verts.push_back( br + glm::vec2( border, 0 ) );
-    corner_uvs.push_back( glm::vec2(1, 1) );
-    corner_verts.push_back( obr );
-    corner_uvs.push_back( glm::vec2(1, 0) );
-
-    // Left Rectangle
-    rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( bl );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-    rectangle_verts.push_back( bl + glm::vec2( -border, 0 ) );
-    rectangle_uvs.push_back( glm::vec2(0, 0) );
-
-    rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( ul );
-    rectangle_uvs.push_back( glm::vec2(1, 1) );
-    rectangle_verts.push_back( bl );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-
-    // Right Rectangle
-    rectangle_verts.push_back( ur );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( br + glm::vec2( border, 0 ) );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-    rectangle_verts.push_back( br );
-    rectangle_uvs.push_back( glm::vec2(0, 0) );
-
-    rectangle_verts.push_back( ur );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( ur + glm::vec2( border, 0 ) );
-    rectangle_uvs.push_back( glm::vec2(1, 1) );
-    rectangle_verts.push_back( br + glm::vec2( border, 0 ) );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-
-    // Top Rectangle
-    rectangle_verts.push_back( ul + glm::vec2( 0, border ) );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( ur );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-    rectangle_verts.push_back( ul );
-    rectangle_uvs.push_back( glm::vec2(0, 0) );
-
-    rectangle_verts.push_back( ul + glm::vec2( 0, border ) );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( ur + glm::vec2( 0, border ) );
-    rectangle_uvs.push_back( glm::vec2(1, 1) );
-    rectangle_verts.push_back( ur );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-
-    // Bot Rectangle
-    rectangle_verts.push_back( bl );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( br + glm::vec2( 0, -border ) );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-    rectangle_verts.push_back( bl + glm::vec2( 0, -border ) );
-    rectangle_uvs.push_back( glm::vec2(0, 0) );
-
-    rectangle_verts.push_back( bl );
-    rectangle_uvs.push_back( glm::vec2(0, 1) );
-    rectangle_verts.push_back( br );
-    rectangle_uvs.push_back( glm::vec2(1, 1) );
-    rectangle_verts.push_back( br + glm::vec2( 0, -border ) );
-    rectangle_uvs.push_back( glm::vec2(1, 0) );
-
-    center_verts.push_back( ul );
-    center_uvs.push_back( glm::vec2(0, 1) );
-    center_verts.push_back( br );
-    center_uvs.push_back( glm::vec2(1, 0) );
-    center_verts.push_back( bl );
-    center_uvs.push_back( glm::vec2(0, 0) );
-
-    center_verts.push_back( ul );
-    center_uvs.push_back( glm::vec2(0, 1) );
-    center_verts.push_back( ur );
-    center_uvs.push_back( glm::vec2(1, 1) );
-    center_verts.push_back( br );
-    center_uvs.push_back( glm::vec2(1, 0) );
-
-    glGenBuffers( 6, (GLuint*)&buffer );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_verts );
-    glBufferData( GL_ARRAY_BUFFER, corner_verts.size() * sizeof( glm::vec2 ), &corner_verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_uvs );
-    glBufferData( GL_ARRAY_BUFFER, corner_uvs.size() * sizeof( glm::vec2 ), &corner_uvs[0], GL_STATIC_DRAW );
-
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_verts );
-    glBufferData( GL_ARRAY_BUFFER, rectangle_verts.size() * sizeof( glm::vec2 ), &rectangle_verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
-    glBufferData( GL_ARRAY_BUFFER, rectangle_uvs.size() * sizeof( glm::vec2 ), &rectangle_uvs[0], GL_STATIC_DRAW );
-
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.center_verts );
-    glBufferData( GL_ARRAY_BUFFER, center_verts.size() * sizeof( glm::vec2 ), &center_verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
-    glBufferData( GL_ARRAY_BUFFER, center_uvs.size() * sizeof( glm::vec2 ), &center_uvs[0], GL_STATIC_DRAW );
-    corner_vertCount = corner_verts.size();
-    rectangle_vertCount = rectangle_verts.size();
-    center_vertCount = center_verts.size();
+Rectangle::Rectangle() {
 }
-
 Rectangle::~Rectangle() {
-    delete shader;
-    glDeleteBuffers( 6, (GLuint*)&buffer );
 }
-
-void Rectangle::draw( glm::mat4& matrix ) {
-    glEnable( GL_BLEND );
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    shader->bind();
-    shader->setParameter( "projection", matrix );
-    if ( highlight ) {
-        // Draw the center of the highlight
-        shader->setParameter( "color", color );
-        shader->setAttribute( "position", buffer.center_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, center_vertCount );
-        // Set the color to have no alpha, then draw the borders.
-        glm::vec4 fullAlpha = glm::vec4(color.r,color.g,color.b,1);
-        shader->setParameter( "color", fullAlpha );
-        shader->setAttribute( "position", buffer.corner_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
-        shader->setAttribute( "position", buffer.rectangle_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
-    } else {
-        shader->setParameter( "color", color );
-        shader->setAttribute( "position", buffer.corner_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
-        shader->setAttribute( "position", buffer.rectangle_verts, 2 );
-        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
-    }
-    shader->unbind();
-    glDisable( GL_BLEND );
+void Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+}
+void Rectangle::draw(glm::mat4& matrix) {
 }
-
 glm::vec4 Rectangle::getRect() {
-    return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
+    return glm::vec4();
 }

src/rectangle.hpp

-/* rectangle.hpp: generates a vertex mesh and draws it.
+/* rectangle.hpp: Rectangle generic
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
 #ifndef N_RECTANGLE_H_
 #define N_RECTANGLE_H_
 
-#include "gl_core_3_3.h"
-#include <iostream>
 #include <glm/glm.hpp>
-#include <GL/gl.h>
-#include <vector>
-
-#include "shader.hpp"
-
-struct RectangleBuffer {
-    unsigned int corner_verts;
-    unsigned int corner_uvs;
-    unsigned int rectangle_verts;
-    unsigned int rectangle_uvs;
-    unsigned int center_verts;
-    unsigned int center_uvs;
-};
 
 class Rectangle {
-private:
-    glm::vec2 ul, oul;
-    glm::vec2 bl, obl;
-    glm::vec2 ur, our;
-    glm::vec2 br, obr;
-    bool highlight;
-    void generateBuffers();
-    RectangleBuffer buffer;
-    unsigned int corner_vertCount;
-    unsigned int rectangle_vertCount;
-    unsigned int center_vertCount;
-    float border;
-    float padding;
-    Shader* shader;
-    glm::vec4 color;
 public:
-    glm::vec4 getRect();
-    Rectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false );
-    ~Rectangle();
-    void setPoints( glm::vec2 p1, glm::vec2 p2 );
-    void draw(glm::mat4& matrix);
+    Rectangle();
+    virtual glm::vec4 getRect();
+    virtual ~Rectangle();
+    virtual void setPoints( glm::vec2 p1, glm::vec2 p2 );
+    virtual void draw(glm::mat4& matrix);
 };
 
 #endif // N_RECTANGLE_H_

src/slop.cpp

+#include "slop.hpp"
+
+X11* x11;
+Mouse* mouse;
+Keyboard* keyboard;
+Resource* resource;
+
+// Defaults!
+SlopOptions::SlopOptions() {
+    borderSize = 1;
+    nodecorations = false;
+    tolerance = 2;
+    padding = 0;
+    shader = "textured";
+    highlight = false;
+    xdisplay = ":0";
+    r = 0.5;
+    g = 0.5;
+    b = 0.5;
+    a = 1;
+}
+
+SlopSelection::SlopSelection( float x, float y, float w, float h, int id ) {
+    this->x = x;
+    this->y = y;
+    this->w = w;
+    this->h = h;
+    this->id = id;
+}
+
+SlopSelection GLSlopSelect( SlopOptions* options, bool* cancelled, SlopWindow* window );
+SlopSelection XShapeSlopSelect( SlopOptions* options, bool* cancelled);
+
+SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
+    SlopSelection returnval(0,0,0,0,0);
+    bool deleteOptions = false;
+    if ( !options ) {
+        deleteOptions = true;
+        options = new SlopOptions();
+    }
+    resource = new Resource();
+    // Set up x11 temporarily
+    x11 = new X11(options->xdisplay);
+    keyboard = new Keyboard( x11 );
+    // First we try to make an OpenGL enabled window
+    bool success = false;
+    SlopWindow* window;
+    try {
+        window = new SlopWindow();
+        success = true;
+    } catch (...) {
+        success = false;
+    }
+    if ( !success ) {
+        // If we fail, we launch the XShape version of slop.
+        std::cerr << "Failed to launch OpenGL context, --shader parameter will be ignored.\n";
+        returnval = XShapeSlopSelect( options, cancelled );
+    } else {
+        returnval = GLSlopSelect( options, cancelled, window );
+    }
+    delete x11;
+    delete resource;
+    if ( deleteOptions ) {
+        delete options;
+    }
+    return returnval;
+}
+
+SlopSelection XShapeSlopSelect( SlopOptions* options, bool* cancelled ) {
+    // Init our little state machine, memory is a tad of a misnomer
+    SlopMemory memory( options, new XShapeRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
+    mouse = new Mouse( x11, options->nodecorations, ((XShapeRectangle*)memory.rectangle)->window );
+
+    // We have no GL context, so the matrix is useless...
+    glm::mat4 fake;
+    // This is where we'll run through all of our stuffs
+    while( memory.running ) {
+        mouse->update();
+        keyboard->update();
+        // We move our statemachine forward.
+        memory.update( 1 );
+
+        // We don't actually draw anything, but the state machine uses
+        // this to know when to spawn the window.
+        memory.draw( fake );
+
+        // X11 explodes if we update as fast as possible, here's a tiny sleep.
+        XFlush(x11->display);
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+        // Then we draw the framebuffer to the screen
+        if ( keyboard->anyKeyDown() || mouse->getButton( 3 ) ) {
+            memory.running = false;
+            if ( cancelled ) {
+                *cancelled = true;
+            }
+        } else {
+            *cancelled = false;
+        }
+    }
+
+    // Now we should have a selection! We parse everything we know about it here.
+    glm::vec4 output = memory.rectangle->getRect();
+
+    // Lets now clear both front and back buffers before closing.
+    // hopefully it'll be completely transparent while closing!
+    // Then we clean up.
+    delete mouse;
+    // Finally return the data.
+    return SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
+}
+
+SlopSelection GLSlopSelect( SlopOptions* options, bool* cancelled, SlopWindow* window ) {
+    mouse = new Mouse( x11, options->nodecorations, window->window );
+
+    if ( options->shader != "textured" ) {
+        window->framebuffer->setShader( options->shader );
+    }
+
+    // Init our little state machine, memory is a tad of a misnomer
+    SlopMemory memory( options, new GLRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
+
+    // This is where we'll run through all of our stuffs
+    while( memory.running ) {
+        mouse->update();
+        keyboard->update();
+        // We move our statemachine forward.
+        memory.update( 1 );
+
+        // Then we draw our junk to a framebuffer.
+        window->framebuffer->bind();
+        glClearColor (0.0, 0.0, 0.0, 0.0);
+        glClear (GL_COLOR_BUFFER_BIT);
+        memory.draw( window->camera );
+        window->framebuffer->unbind();
+
+        // Then we draw the framebuffer to the screen
+        window->framebuffer->draw();
+        window->display();
+        GLenum err = glGetError();
+        if ( err != GL_NO_ERROR ) {
+            throw err;
+        }
+        if ( keyboard->anyKeyDown() || mouse->getButton( 3 ) ) {
+            memory.running = false;
+            if ( cancelled ) {
+                *cancelled = true;
+            }
+        } else {
+            *cancelled = false;
+        }
+    }
+
+    // Now we should have a selection! We parse everything we know about it here.
+    glm::vec4 output = memory.rectangle->getRect();
+
+    // Lets now clear both front and back buffers before closing.
+    // hopefully it'll be completely transparent while closing!
+    glClearColor (0.0, 0.0, 0.0, 0.0);
+    glClear (GL_COLOR_BUFFER_BIT);
+    window->display();
+    glClear (GL_COLOR_BUFFER_BIT);
+    window->display();
+    // Then we clean up.
+    delete window;
+    delete mouse;
+    // Finally return the data.
+    return SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
+}

src/slop.hpp

 #define N_SLOP_H_
 
 #include <string>
+#include <chrono>
+#include <thread>
+
+#include "slopstates.hpp"
+#include "mouse.hpp"
+#include "resource.hpp"
+#include "keyboard.hpp"
+
+#include "window.hpp"
+#include "shader.hpp"
+#include "framebuffer.hpp"
+#include "glrectangle.hpp"
+#include "xshaperectangle.hpp"
 
 class SlopOptions {
 public:

src/slopstates.cpp

 #include "slopstates.hpp"
 
-SlopMemory::SlopMemory( SlopOptions* options ) {
+SlopMemory::SlopMemory( SlopOptions* options, Rectangle* rect ) {
     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);
+    rectangle = rect;
     selectedWindow = x11->root;
     state->onEnter( *this );
 }

src/slopstates.hpp

 #endif
 
 class SlopMemory;
+class SlopOptions;
 
 class SlopState {
 public:
     SlopState* state;
     SlopState* nextState;
 public:
-    SlopMemory( SlopOptions* options );
+    SlopMemory( SlopOptions* options, Rectangle* rect );
     ~SlopMemory();
     Window selectedWindow;
     bool running;
     void draw( glm::mat4& matrix );
 };
 
-
 #endif // N_SLOPSTATES_H_

src/xshaperectangle.cpp

 #include "xshaperectangle.hpp"
 
-Rectangle::Rectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
+XShapeRectangle::XShapeRectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
     this->color = convertColor( color );
     this->border = border;
     this->padding = padding;
     createdWindow = false;
 }
 
-void Rectangle::createWindow() {
+void XShapeRectangle::createWindow() {
     if ( createdWindow ) {
         return;
     }
     createdWindow = true;
 }
 
-void Rectangle::generateHoles() {
+void XShapeRectangle::generateHoles() {
     if ( !highlight ) {
         XRectangle rects[4];
         // Left
     XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
 }
 
-void Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+void XShapeRectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
     // Find each corner of the rectangle
     ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
     bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
     generateHoles();
 }
 
-Rectangle::~Rectangle() {
+XShapeRectangle::~XShapeRectangle() {
 }
 
-void Rectangle::draw( glm::mat4& matrix ) {
+void XShapeRectangle::draw( glm::mat4& matrix ) {
     // We don't want to be visible until we're asked to draw.
     createWindow();
 }
 
-glm::vec4 Rectangle::getRect() {
+glm::vec4 XShapeRectangle::getRect() {
     return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
 }
 
-XColor Rectangle::convertColor( glm::vec4 color ) {
+XColor XShapeRectangle::convertColor( glm::vec4 color ) {
     // Convert float colors to shorts.
     short red   = short( floor( color.r * 65535.f ) );
     short green = short( floor( color.g * 65535.f ) );

src/xshaperectangle.hpp

 #include <X11/extensions/shape.h>
 
 #include "x.hpp"
+#include "rectangle.hpp"
 
-class Rectangle {
+class XShapeRectangle : public Rectangle {
 private:
     glm::vec2 ul, oul;
     glm::vec2 bl, obl;
 public:
     Window window;
     glm::vec4 getRect();
-    Rectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false );
-    ~Rectangle();
+    XShapeRectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false );
+    ~XShapeRectangle();
     void setPoints( glm::vec2 p1, glm::vec2 p2 );
     void draw(glm::mat4& matrix);
 };

src/xslop.cpp

-#include "slop.hpp"
-
-#include "slopstates.hpp"
-#include "mouse.hpp"
-#include "resource.hpp"
-#include "keyboard.hpp"
-#include <chrono>
-#include <thread>
-#include "xshaperectangle.hpp"
-
-X11* x11;
-Mouse* mouse;
-Keyboard* keyboard;
-Resource* resource;
-
-// Defaults!
-SlopOptions::SlopOptions() {
-    borderSize = 1;
-    nodecorations = false;
-    tolerance = 2;
-    padding = 0;
-    highlight = false;
-    xdisplay = ":0";
-    r = 0.5;
-    g = 0.5;
-    b = 0.5;
-    a = 1;
-}
-
-SlopSelection::SlopSelection( float x, float y, float w, float h, int id ) {
-    this->x = x;
-    this->y = y;
-    this->w = w;
-    this->h = h;
-    this->id = id;
-}
-
-SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
-    bool deleteOptions = false;
-    if ( !options ) {
-        deleteOptions = true;
-        options = new SlopOptions();
-    }
-    resource = new Resource();
-    // Set up x11 temporarily
-    x11 = new X11(options->xdisplay);
-    keyboard = new Keyboard( x11 );
-
-    // Init our little state machine, memory is a tad of a misnomer
-    SlopMemory memory( options );
-    mouse = new Mouse( x11, options->nodecorations, memory.rectangle->window );
-
-    glm::mat4 fake;
-    // This is where we'll run through all of our stuffs
-    while( memory.running ) {
-        mouse->update();
-        keyboard->update();
-        // We move our statemachine forward.
-        memory.update( 1 );
-
-        // We don't actually draw anything, but the state machine uses
-        // this to know when to spawn the window.
-        memory.draw( fake );
-
-        // X11 explodes if we update as fast as possible, here's a tiny sleep.
-        XFlush(x11->display);
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-        // Then we draw the framebuffer to the screen
-        if ( keyboard->anyKeyDown() || mouse->getButton( 3 ) ) {
-            memory.running = false;
-            if ( cancelled ) {
-                *cancelled = true;
-            }
-        } else {
-            *cancelled = false;
-        }
-    }
-
-    // Now we should have a selection! We parse everything we know about it here.
-    glm::vec4 output = memory.rectangle->getRect();
-
-    // Lets now clear both front and back buffers before closing.
-    // hopefully it'll be completely transparent while closing!
-    // Then we clean up.
-    delete mouse;
-    delete x11;
-    delete resource;
-    if ( deleteOptions ) {
-        delete options;
-    }
-    // Finally return the data.
-    return SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
-}