Merge branch 'slop-release-candidate'

.gitignore

@@ -1,2 +0,0 @@
-# These files are ignored since cmake generates them from cmdline.in
-src/cmdline.h

CMakeLists.txt

@@ -1,172 +1,74 @@
-cmake_minimum_required( VERSION 2.8 )
+cmake_minimum_required(VERSION 2.6)
 
-project( "slop" )
-set( slop_VERSION_MAJOR 4 )
-set( slop_VERSION_MINOR 3 )
-set( slop_VERSION_PATCH 21 )
-
-set( CMAKE_OPENGL_SUPPORT FALSE CACHE BOOL "Whether or not to compile with OpenGL, shaders, magnification, and theming support." )
-
-set( BIN_TARGET     "${PROJECT_NAME}" )
-if( NOT CMAKE_INSTALL_PREFIX )
-   set( CMAKE_INSTALL_PREFIX "/usr" )
+set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)")
+if ( NOT CMAKE_INSTALL_PREFIX )
+    set(CMAKE_INSTALL_PREFIX "/usr")
 endif()
 
-if( NOT INSTALL_PREFIX )
-   set( INSTALL_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, INSTALL_PREFIX should be \"/usr\"." )
-endif()
+project(slop)
 
-if( NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE )
-   set( CMAKE_BUILD_TYPE RelWithDebInfo )
-endif()
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/")
 
-# Linux compiler initialization.
-if ( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR
-     "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR
-     "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel" )
-     set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-unused-parameter" )
-     set( CMAKE_CXX_FLAGS_DEBUG "-Wextra -pedantic-errors -O0 -g" )
-     set( CMAKE_CXX_FLAGS_RELEASE "-O2" )
-     set( CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g" )
-         # -Wall:   Enable all warnings.
-         # -Wextra: Enable some more warnings.
-         # -Werror: Have errors on warnings.
-         # -pedantic-errors: Even more errors.
-         # -Wno-unused-parameter: Prevent unused variable warning. (Several functions are required to have unecessary variables because X11.)
-else()
-    message( FATAL_ERROR "Your operating system isn't supported yet! CMake will now exit." )
-endif()
+set( CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Directory where man pages reside. (/usr/share/man, /usr/local/share/man, etc.)" )
 
-# Add a check target for our makefile.
-find_program( CPPCHECK_EXECUTABLE cppcheck
-              DOC "A tool for static C/C++ code analysis." )
-if (CPPCHECK_EXECUTABLE)
-    add_custom_target( "check"
-                       COMMAND "${CPPCHECK_EXECUTABLE}" "--enable=all" "*"
-                       WORKING_DIRECTORY src VERBATIM )
-endif()
+set( CMAKE_COMPRESS_MAN TRUE CACHE BOOL "Whether or not to compress the man pages for install." )
 
-# Here we generate some of our code if we can. I package it pre-generated
-# so nobody has to go find and install gengetopt if they don't want to.
-find_program( GENGETOPT_EXECUTABLE gengetopt
-              DOC "A tool to generate code to grab command line options." )
-find_program( SED_EXECUTABLE sed )
-if ( GENGETOPT_EXECUTABLE AND SED_EXECUTABLE )
-    message( "-- Regenerating cmdline.in" )
-    # gengetopt generates cmdline.h, then we move it to cmdline.in.
-    execute_process( COMMAND "${GENGETOPT_EXECUTABLE}" "--input=options.ggo"
-                     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/src" )
-    file( RENAME "${CMAKE_CURRENT_SOURCE_DIR}/src/cmdline.h" "${CMAKE_CURRENT_SOURCE_DIR}/src/cmdline.in" )
-    # Due to a bug in gengetopt, we have to manually insert some code.
-    # Replace the first instance of REPLACEME with some text.
-    # Eight backslashes = two in the code because of how many instances of escaping is happening.
-    execute_process( COMMAND "${SED_EXECUTABLE}" "-i" "0,/REPLACEME/{s/REPLACEME/X=%x\\\\\\\\nY=%y\\\\\\\\nW=%w\\\\\\\\nH=%h\\\\\\\\nG=%g\\\\\\\\nID=%i\\\\\\\\nCancel=%c\\\\\\\\n/}" "cmdline.c"
-                     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/src" )
-    # Then replace remaining instances.
-    execute_process( COMMAND "${SED_EXECUTABLE}" "-i" "s/REPLACEME/X=%x\\\\nY=%y\\\\nW=%w\\\\nH=%h\\\\nG=%g\\\\nID=%i\\\\nCancel=%c\\\\n/" "cmdline.c"
-                     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/src" )
+if ( CMAKE_COMPRESS_MAN )
+    set( MANTARGET "slop.1.gz" )
 else()
-    message( "Warning: Command gengetopt or sed not found! Won't regenerate command line code. (If you're just compiling this doesn't matter.)" )
-endif()
-
-# By default our src/options.ggo has our cmake versions variables for
-# the 'version ""' line. We replace them here.
-# The ${CMAKE_SOURCE_DIR} is there to fix problems with OpenBSD's out-of-source build black magic.
-configure_file( "src/cmdline.in" "${CMAKE_SOURCE_DIR}/src/cmdline.h" )
-
-# This allows for "make README.md" to be ran to update the README's help
-# section automatically. We don't add it to ALL because running arbitrary
-# scripts is unsafe and I don't know if systems will actually have it
-# be executbable.
-add_custom_target( README.md "./generateReadme.sh" DEPENDS "slop" )
-
-# Sources
-if( CMAKE_OPENGL_SUPPORT )
-    set( source
-         src/cmdline.c
-         src/selectrectangle.cpp
-         src/glselectrectangle.cpp
-         src/shader.cpp
-         src/framebuffer.cpp
-         src/resource.cpp
-         src/xselectrectangle.cpp
-         src/x.cpp
-         src/main.cpp )
-else()
-    set( source
-         src/cmdline.c
-         src/selectrectangle.cpp
-         src/xselectrectangle.cpp
-         src/x.cpp
-         src/main.cpp )
-endif()
-
-# Obtain library paths and make sure they exist.
-set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmakemodules" )
-find_package( Imlib2    REQUIRED )
-find_package( X11       REQUIRED )
-find_package( XExt      REQUIRED )
-# This library is needed only for Ubuntu it seems, some platforms don't even
-# ship with it. I couldn't find a way to do a test compile to check if librt
-# was needed, so instead I just didn't mark it as REQUIRED.
-find_package( RT )
-
-set( CMAKE_CXX_FLAGS
-     "${CMAKE_CXX_FLAGS} ${CMAKE_IMLIB2_CXX_FLAGS}" )
-
-# Includes
-include_directories( "${X11_INCLUDE_DIR}"
-                     "${XEXT_INCLUDE_DIR}" )
-
-if ( CMAKE_OPENGL_SUPPORT )
-find_package( OpenGL    REQUIRED )
-find_package( GLX       REQUIRED )
-find_package( XRender   REQUIRED )
-find_package( XRandr    REQUIRED )
-find_package( GLEW      REQUIRED )
-include_directories( "${IMLIB2_INCLUDE_DIR}"
-                     "${XRANDR_INCLUDE_DIR}"
-                     "${OPENGL_INCLUDE_DIR}"
-                     "${GLX_INCLUDE_DIR}"
-                     ${GLEW_INCLUDE_DIRS}
-                     ${XRENDER_INCLUDE_DIRS} )
-endif()
-
-if ( RT_INCLUDE_DIR )
-    include_directories( ${RT_INCLUDE_DIR} )
+    set( MANTARGET "slop.1" )
 endif()
 
-# Executable
-add_executable( "${BIN_TARGET}" ${source} )
-
-# Libraries
-target_link_libraries( "${BIN_TARGET}"
-                       ${X11_LIBRARIES}
-                       "${XEXT_LIBRARY}" )
-
-if ( CMAKE_OPENGL_SUPPORT )
-    target_link_libraries( "${BIN_TARGET}"
-                           ${IMLIB2_LIBRARIES}
-                           ${OPENGL_LIBRARIES}
-                           ${GLX_LIBRARIES}
-                           ${GLEW_LIBRARIES}
-                           ${XRENDER_LIBRARIES}
-                           "${XRANDR_LIBRARY}" )
-endif()
-
-
-if ( RT_LIBRARY )
-    target_link_libraries( "${BIN_TARGET}"
-                           "${RT_LIBRARY}" )
-endif()
-
-install( TARGETS ${BIN_TARGET}
-         DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
-
-add_definitions(-DINSTALL_PREFIX="${INSTALL_PREFIX}")
-
-if( CMAKE_OPENGL_SUPPORT )
-    install( DIRECTORY "${CMAKE_SOURCE_DIR}/share"
-             DESTINATION "${CMAKE_INSTALL_PREFIX}" )
-    add_definitions(-DOPENGL_ENABLED=1)
-endif()
+include_directories("${PROJECT_BINARY_DIR}")
+
+add_definitions(-DSLOP_VERSION="v5.3.21")
+
+# The names have to be unique unfortunately.
+set(EXECUTABLE_NAME "slop")
+set(LIBRARY_NAME "slopy")
+
+add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
+                                    src/keyboard.cpp
+                                    src/x.cpp
+                                    src/slopstates.cpp
+                                    src/framebuffer.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)
+
+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" COMPONENT development )
+install( FILES "${CMAKE_SOURCE_DIR}/${MANTARGET}" DESTINATION  "${CMAKE_INSTALL_MANDIR}/man1" COMPONENT doc )

README.md

@@ -1,53 +1,35 @@
 # slop
-
-slop (Select Operation) is an application that queries for a selection from the user and prints the region to stdout. It grabs the mouse and turns it into a crosshair, lets the user click and drag to make a selection (or click on a window) while drawing a pretty box around it, then finally prints the selection's dimensions to stdout.
+slop (Select Operation) is an application that queries for a selection from the user and prints the region to stdout.
 
 ## Features
 * Hovering over a window will cause a selection rectangle to appear over it.
-* Clicking on a window makes slop return the dimensions of the window.
-* Clicking and dragging causes a selection rectangle to appear, renders pretty well (compared to scrot). And will return the dimensions of that rectangle in absolute screen coords.
-* On startup it turns your cursor into a crosshair, then adjusts the cursor into angles as you drag the selection rectangle.
+* Clicking on a window makes slop return the dimensions of the window, and it's ID.
+* OpenGL accelerated graphics where possible.
 * Supports simple arguments:
     * Change selection rectangle border size.
     * Select X display.
-    * Set padding size, even negative padding sizes!
-    * Set click tolerance for if you have a shaky mouse.
+    * Set padding size.
+    * Force window, or pixel selections with the tolerance flag.
     * Set the color of the selection rectangles to match your theme! (Even supports transparency!)
     * Remove window decorations from selections.
-* Supports OpenGL hardware acceleration.
-* Supports textured themes.
-* Supports programmable shaders.
-* Supports a magnifying glass.
+* Supports custom programmable shaders.
 
-## Practical applications
+## Practical Applications
 slop can be used to create a video recording script in only two lines of code.
 ```bash
 #!/bin/bash
-eval $(slop)
+read -r X Y W H G ID < <(slop -f "%x %y %w %h %g %i")
 ffmpeg -f x11grab -s "$W"x"$H" -i :0.0+$X,$Y -f alsa -i pulse ~/myfile.webm
 ```
-slop lets you select a region or window and ffmpeg will record it in the format of your choice!
-Combined with keybinds and a server on your filesystem you can make a really neat and unobtrusive screenshooter.
 
 You can also take images using imagemagick like so:
 ```bash
 #!/bin/bash
-eval $(slop)
+read -r G < <(slop -f "%g")
 import -window root -crop $G ~/myimage.png
 ```
 If you don't like ImageMagick's import: Check out [maim](https://github.com/naelstrof/maim) for a better screenshot utility.
 
-You can see my implementation of slop in a screenshooter here:
-https://gist.github.com/naelstrof/6530959
-
-For those of you who don't want eval to be an integral part of slop (Could be dangerous if I were evil!): You can change the output format and parse it manually like so:
-```bash
-#!/bin/bash
-read -r X Y W H G ID < <(slop -f "%x %y %w %h %g %i")
-maim -g "$G" -i "$ID"
-ffmpeg -f x11grab -s "$W"x"$H" -i ":0.0+$X,$Y" -f alsa -i pulse ~/myfile.webm
-```
-
 ## Lets see some action
 Ok. Here's a comparison between 'scrot -s's selection and slop's:
 
@@ -71,152 +53,16 @@ While slop not only looks nicer, it's impossible for it to end up in screenshots
 * [Debian: slop](https://packages.debian.org/sid/slop)
 * Please make a package for slop on your favorite system, and make a pull request to add it to this list.
 
-
 ### Install using CMake (Requires CMake)
 
-*Note: Dependencies should be installed first: libxext, imlib2, mesa, libxrender, libxrandr, glew and glm.*
+*Note: Dependencies should be installed first: libxext, OpenGL, and glm.*
 
 ```bash
 git clone https://github.com/naelstrof/slop.git
 cd slop
-cmake -DCMAKE_OPENGL_SUPPORT=true ./
+cmake -DCMAKE_INSTALL_PREFIX="/usr" ./
 make && sudo make install
 ```
 
-Make sure to check out and install [maim](https://github.com/naelstrof/maim) too if you want a proper screenshot utility.
-
-## Configuration
-Ever since slop had OpenGL support, it now has quite a few customizations that can be done.
-
-*Note: Configuration directories are located at __${XDG\_CONFIG\_HOME}/slop__ or __${CMAKE\_INSTALL\_PREFIX}/share/slop__, whichever comes first. These will be refferred to as __~/.config/slop__ and __/usr/share/slop__ respectively from here on.*
-
 ### Shaders
-[![Demo Shaders](http://farmpolice.com/content/images/slop_demo.gif)](http://farmpolice.com/content/videos/8a5c37c4.webm)
-
-*Click for video*
-
-Slop supports shaders that are loaded from the configuration directories.
-They're all completely programmable, but they do lack some features like chaining right now.
-To configure the shaders or create your own, first copy the global configuration folder to your ~/.config folder like so:
-```bash
-cp -r /usr/share/slop ~/.config
-```
-Then edit or add new shaders at ~/.config/slop as if you were editing the originals, slop will reflect the changes on restart.
-If there's any missing features in the shaders: don't hesitate to make an issue to request them, and feel free to make your own shaders and submit a pull request to see if it can be officially included!
-
-### Themes
-![Demo Themes](http://farmpolice.com/content/images/1436653680.png)
-Slop has primitive support for texture themes, I've included a poorly made *gothic* theme that you can test with `slop --opengl --theme gothic`.
-To create your own you'll have to copy the configuration directory, just like with the shaders above, like so:
-```bash
-cp -r /usr/share/slop ~/.config
-```
-The theme names are taken from the folder names, the files inside represent the corresponding textures. For example *~/config/gothic/corner\_tr.png* would correspond to the top right square texture in a gothic themed selection.
-The theming is still missing offset configuration, and is quite limiting in design. Themes probably won't be flushed out further unless someone makes an issue to request more features.
-Feel free to make your own themes and submit a pull request to see if it can be officially included!
-
-help
-----
-```text
-slop v4.3.21
-
-Copyright (C) 2014 Dalton Nell, Slop Contributors
-(https://github.com/naelstrof/slop/graphs/contributors)
-
-Usage: slop [options]
-
-slop (Select Operation) is an application that queries for a selection from the
-user and prints the region to stdout.
-
-  -h, --help                    Print help and exit
-  -V, --version                 Print version and exit
-Options
-      --xdisplay=hostname:number.screen_number
-                                Sets the x display.
-      --nokeyboard              Disables the ability to cancel selections with
-                                  the keyboard.  (default=off)
-  -b, --bordersize=INT          Set the selection rectangle's thickness. Does
-                                  nothing when --highlight is enabled.
-                                  (default=`5')
-  -p, --padding=INT             Set the padding size of the selection. Can be
-                                  negative.  (default=`0')
-  -t, --tolerance=INT           How far in pixels the mouse can move after
-                                  clicking and still be detected as a normal
-                                  click instead of a click and drag. Setting
-                                  this to 0 will disable window selections.
-                                  (default=`2')
-  -g, --gracetime=FLOAT         Set the amount of time before slop will check
-                                  for keyboard cancellations in seconds.
-                                  (default=`0.4')
-  -c, --color=FLOAT,FLOAT,FLOAT,FLOAT
-                                Set the selection rectangle's color. Supports
-                                  RGB or RGBA values.
-                                  (default=`0.5,0.5,0.5,1')
-  -n, --nodecorations           Attempt to select child windows in order to
-                                  avoid window decorations.  (default=off)
-      --min=INT                 Set the minimum output of width or height
-                                  values. This is useful to avoid outputting 0.
-                                  Setting min and max to the same value
-                                  disables drag selections.  (default=`0')
-      --max=INT                 Set the maximum output of width or height
-                                  values. Setting min and max to the same value
-                                  disables drag selections.  (default=`0')
-  -l, --highlight               Instead of outlining selections, slop
-                                  highlights it. This is only useful when
-                                  --color is set to a transparent color.
-                                  (default=off)
-      --opengl                  Enable hardware acceleration. Only works with
-                                  modern systems that are also running a
-                                  compositor.  (default=off)
-      --magnify                 Display a magnifying glass when --opengl is
-                                  also enabled.  (default=off)
-      --magstrength=FLOAT       Sets how many times the magnification window
-                                  size is multiplied.  (default=`4')
-      --magpixels=INT           Sets how many pixels are displayed in the
-                                  magnification. The less pixels the bigger the
-                                  magnification.  (default=`64')
-      --theme=STRING            Sets the theme of the selection, using textures
-                                  from ~/.config/slop/ or /usr/share/.
-                                  (default=`none')
-      --shader=STRING           Sets the shader to load and use from
-                                  ~/.config/slop/ or /usr/share/.
-                                  (default=`simple')
-  -f, --format=STRING           Set the output format string. Format specifiers
-                                  are %x, %y, %w, %h, %i, %g, and %c.
-                                  (default=`X=%x\nY=%y\nW=%w\nH=%h\nG=%g\nID=%i\nCancel=%c\n')
-
-Examples
-    $ # Gray, thick, transparent border for maximum visiblity.
-    $ slop -b 20 -c 0.5,0.5,0.5,0.8
-
-    $ # Remove window decorations.
-    $ slop --nodecorations
-
-    $ # Disable window selections. Useful for selecting individual pixels.
-    $ slop -t 0
-
-    $ # Classic Windows XP selection.
-    $ slop -l -c 0.3,0.4,0.6,0.4
-
-    $ # Wiggle wiggle!
-    $ slop --opengl --shader wiggle
-
-    $ # Edgy textures or something.
-    $ slop --opengl --theme gothic
-
-    $ # Change output format to use safer parsing
-    $ slopoutput=$(slop -f "%x %y %w %h")
-    $ X=$(echo $slopoutput | awk '{print $1}')
-    $ Y=$(echo $slopoutput | awk '{print $2}')
-    $ W=$(echo $slopoutput | awk '{print $3}')
-    $ H=$(echo $slopoutput | awk '{print $4}')
-
-Tips
-    * You can use the arrow keys to move the starting point of a
-drag-selection, just in case you missed it by a few pixels.
-    * If you don't like a selection: you can cancel it by right-clicking
-regardless of which options are enabled or disabled for slop.
-    * If slop doesn't seem to select a window accurately, the problem could be
-because of decorations getting in the way. Try enabling the --nodecorations
-flag.
-```
+These are implemented, but not flushed out. I haven't gotten around to writing some tutorials on them. So check back later!

cmakemodules/FindImlib2.cmake

@@ -1,91 +0,0 @@
-#
-# This module finds if IMLIB2 is available and determines where the
-# include files and libraries are.
-# On Unix/Linux it relies on the output of imlib2-config.
-# This code sets the following variables:
-#
-#
-#
-# IMLIB2_FOUND              = system has IMLIB2 lib
-#
-# IMLIB2_LIBRARIES          = full path to the libraries
-#    on Unix/Linux with additional linker flags from "imlib2-config --libs"
-#
-# CMAKE_IMLIB2_CXX_FLAGS    = Unix compiler flags for IMLIB2, essentially "`imlib2-config --cxxflags`"
-#
-# IMLIB2_INCLUDE_DIR        = where to find headers
-#
-# IMLIB2_LINK_DIRECTORIES   = link directories, useful for rpath on Unix
-#
-#
-# author Jan Woetzel and Jan-Friso Evers
-# www.mip.informatik.uni-kiel.de/~jw
-
-IF(WIN32)
-    MESSAGE("FindIMLIB2.cmake: IMLIB2 not (yet) supported on WIN32")
-    SET(IMLIB2_FOUND OFF	)
-ELSE(WIN32)
-    IF(UNIX)
-        SET(IMLIB2_CONFIG_PREFER_PATH "$ENV{IMLIB2_HOME}/bin" CACHE STRING "preferred path to imlib2")
-        FIND_PROGRAM(IMLIB2_CONFIG imlib2-config
-                     ${IMLIB2_CONFIG_PREFER_PATH}
-                     /usr/bin/
-                     /opt/gnome/bin/)
-
-        IF (IMLIB2_CONFIG)
-            # OK, found imlib2-config.
-            # set CXXFLAGS to be fed into CXX_FLAGS by the user:
-            SET(IMLIB2_CXX_FLAGS "`${IMLIB2_CONFIG} --cflags`")
-
-            # set INCLUDE_DIRS to prefix+include
-            EXEC_PROGRAM(${IMLIB2_CONFIG}
-            ARGS --prefix
-            OUTPUT_VARIABLE IMLIB2_PREFIX)
-            SET(IMLIB2_INCLUDE_DIR ${IMLIB2_PREFIX}/include CACHE STRING INTERNAL)
-
-            # extract link dirs for rpath
-            EXEC_PROGRAM(${IMLIB2_CONFIG}
-                         ARGS --libs
-                         OUTPUT_VARIABLE IMLIB2_CONFIG_LIBS)
-
-            # set link libraries and link flags
-            #SET(IMLIB2_LIBRARIES "`${IMLIB2_CONFIG} --libs`")
-            SET(IMLIB2_LIBRARIES ${IMLIB2_CONFIG_LIBS})
-
-            # split off the link dirs (for rpath)
-            # use regular expression to match wildcard equivalent "-L*<endchar>"
-            # with <endchar> is a space or a semicolon
-            STRING(REGEX MATCHALL "[-][L]([^ ;])+"
-                   IMLIB2_LINK_DIRECTORIES_WITH_PREFIX
-                   "${IMLIB2_CONFIG_LIBS}")
-            #MESSAGE("DBG  IMLIB2_LINK_DIRECTORIES_WITH_PREFIX=${IMLIB2_LINK_DIRECTORIES_WITH_PREFIX}")
-
-            # remove prefix -L because we need the pure directory for LINK_DIRECTORIES
-            # replace -L by ; because the separator seems to be lost otherwise (bug or feature?)
-            IF (IMLIB2_LINK_DIRECTORIES_WITH_PREFIX)
-                STRING(REGEX REPLACE "[-][L]" ";" IMLIB2_LINK_DIRECTORIES ${IMLIB2_LINK_DIRECTORIES_WITH_PREFIX} )
-                #MESSAGE("DBG  IMLIB2_LINK_DIRECTORIES=${IMLIB2_LINK_DIRECTORIES}")
-            ENDIF (IMLIB2_LINK_DIRECTORIES_WITH_PREFIX)
-
-            # replace space separated string by semicolon separated vector to make 
-            # it work with LINK_DIRECTORIES
-            SEPARATE_ARGUMENTS(IMLIB2_LINK_DIRECTORIES)
-
-            MARK_AS_ADVANCED(IMLIB2_CXX_FLAGS
-                             IMLIB2_INCLUDE_DIR
-                             IMLIB2_LIBRARIES
-                             IMLIB2_LINK_DIRECTORIES
-                             IMLIB2_CONFIG_PREFER_PATH
-                             IMLIB2_CONFIG)
-
-        ELSE(IMLIB2_CONFIG)
-            MESSAGE( "FindIMLIB2.cmake: imlib2-config not found. Please set it manually. IMLIB2_CONFIG=${IMLIB2_CONFIG}")
-        ENDIF(IMLIB2_CONFIG)
-    ENDIF(UNIX)
-ENDIF(WIN32)
-
-IF(IMLIB2_LIBRARIES)
-    IF(IMLIB2_INCLUDE_DIR OR IMLIB2_CXX_FLAGS)
-        SET(IMLIB2_FOUND 1)
-    ENDIF(IMLIB2_INCLUDE_DIR OR IMLIB2_CXX_FLAGS)
-ENDIF(IMLIB2_LIBRARIES)

cmakemodules/FindRT.cmake

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

cmakemodules/FindXRandr.cmake

@@ -1,26 +0,0 @@
-# - Find XRandr
-# Find the XRandr libraries
-#
-#  This module defines the following variables:
-#     XRANDR_FOUND        - 1 if XRANDR_INCLUDE_DIR & XRANDR_LIBRARY are found, 0 otherwise
-#     XRANDR_INCLUDE_DIR  - where to find Xlib.h, etc.
-#     XRANDR_LIBRARY      - the X11 library
-#
-
-find_path( XRANDR_INCLUDE_DIR
-           NAMES X11/extensions/Xrandr.h
-           PATH_SUFFIXES X11/extensions
-           DOC "The XRandr include directory" )
-
-find_library( XRANDR_LIBRARY
-              NAMES Xrandr
-              PATHS /usr/lib /lib
-              DOC "The XRandr library" )
-
-if( XRANDR_INCLUDE_DIR AND XRANDR_LIBRARY )
-    set( XRANDR_FOUND 1 )
-else()
-    set( XRANDR_FOUND 0 )
-endif()
-
-mark_as_advanced( XRANDR_INCLUDE_DIR XRANDR_LIBRARY )

cmakemodules/FindXRender.cmake

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

generateReadme.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-# generateReadme.sh: Regenerates the help section of the README.md using output from ./slop --help.
-
-# Remove help section
-sed -i '/^help/,/^```$/d' README.md
-
-# Add the help section again.
-echo 'help' >> README.md
-echo '----' >> README.md
-echo '```text' >> README.md
-echo "$(./slop --help)" >> README.md
-echo '```' >> README.md

modules/FindGLM.cmake

@@ -0,0 +1,52 @@
+#
+# Find GLM
+#
+# Try to find GLM : OpenGL Mathematics.
+# This module defines 
+# - GLM_INCLUDE_DIRS
+# - GLM_FOUND
+#
+# The following variables can be set as arguments for the module.
+# - GLM_ROOT_DIR : Root library directory of GLM 
+#
+# References:
+# - https://github.com/Groovounet/glm/blob/master/util/FindGLM.cmake
+# - https://bitbucket.org/alfonse/gltut/src/28636298c1c0/glm-0.9.0.7/FindGLM.cmake
+#
+
+# Additional modules
+include(FindPackageHandleStandardArgs)
+
+if (WIN32)
+	# Find include files
+	find_path(
+		GLM_INCLUDE_DIR
+		NAMES glm/glm.hpp
+		PATHS
+		$ENV{PROGRAMFILES}/include
+		${GLM_ROOT_DIR}/include
+		DOC "The directory where glm/glm.hpp resides")
+else()
+	# Find include files
+	find_path(
+		GLM_INCLUDE_DIR
+		NAMES glm/glm.hpp
+		PATHS
+		/usr/include
+		/usr/local/include
+		/sw/include
+		/opt/local/include
+		${GLM_ROOT_DIR}/include
+		DOC "The directory where glm/glm.hpp resides")
+endif()
+
+# Handle REQUIRD argument, define *_FOUND variable
+find_package_handle_standard_args(GLM DEFAULT_MSG GLM_INCLUDE_DIR)
+
+# Define GLM_INCLUDE_DIRS
+if (GLM_FOUND)
+	set(GLM_INCLUDE_DIRS ${GLM_INCLUDE_DIR})
+endif()
+
+# Hide some variables
+mark_as_advanced(GLM_INCLUDE_DIR)

share/slop/cross.frag

@@ -1,38 +0,0 @@
-#version 120
-
-uniform sampler2D texture;
-uniform sampler2D desktop;
-uniform int desktopWidth;
-uniform int desktopHeight;
-uniform float time;
-
-varying vec2 uvCoord;
-
-void main() {
-    float stitching_size = 6.0;
-    int invert = 0;
-
-    float size = stitching_size;
-    vec2 cPos = uvCoord * vec2(desktopWidth, desktopHeight);
-    vec2 tlPos = floor(cPos / vec2(size, size));
-    tlPos *= size;
-    int remX = int(mod(cPos.x, size));
-    int remY = int(mod(cPos.y, size));
-    if (remX == 0 && remY == 0)
-    tlPos = cPos;
-    vec2 blPos = tlPos;
-    blPos.y += (size - 1.0);
-    if ((remX == remY) || (((int(cPos.x) - int(blPos.x)) == (int(blPos.y) - int(cPos.y))))) {
-        if (invert == 1) {
-            gl_FragColor = vec4(0.2, 0.15, 0.05, 1.0);
-        } else {
-            gl_FragColor = texture2D(texture, tlPos * vec2(1.0/desktopWidth, 1.0/desktopHeight)) * 1.4;
-        }
-    } else {
-        if (invert == 1) {
-            gl_FragColor = texture2D(texture, tlPos * vec2(1.0/desktopWidth, 1.0/desktopHeight)) * 1.4;
-        } else {
-            gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
-        }
-    }
-}

share/slop/cross.vert

@@ -1,12 +0,0 @@
-#version 120
-
-attribute vec2 vertex;
-attribute vec2 uv;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    uvCoord = uv;
-	gl_Position = vec4(vertex,0,1);
-}

share/slop/gothic/corner_bl.png

@@ -1 +0,0 @@
-corner_tl.png

share/slop/gothic/corner_br.png

@@ -1 +0,0 @@
-corner_tl.png

share/slop/gothic/corner_tr.png

@@ -1 +0,0 @@
-corner_tl.png

share/slop/hippie.frag

@@ -1,30 +0,0 @@
-#version 120
-
-uniform sampler2D texture;
-uniform sampler2D desktop;
-uniform int desktopWidth;
-uniform int desktopHeight;
-uniform float time;
-
-varying vec2 uvCoord;
-
-const float pi = 3.14159265f;
-
-vec3 color(float x) {
-    return max(min(sin(vec3(x,x+pi*2.0/3.0,x+pi*4.0/3.0))+0.5,1.0),0.0);
-}
-
-void main() {
-    vec2 resolution = vec2( desktopWidth, desktopHeight );
-    vec2 pos = (( gl_FragCoord.xy / resolution.xy )-0.5)*resolution.xy/resolution.x*4.0;
-    pos+=normalize(pos);
-    pos.xy+=sin(pos.yx*10.0)*0.1;
-    float r=(2.0/(dot(pos,pos)*10.0+1.0));
-    vec2 rr=vec2(cos(r),sin(r));
-    pos=pos.xy*rr.xx+pos.yx*rr.yy*vec2(-1.0,1.0);
-    float f=(length(pos)*10.0)+time;
-    //f=acos((pos.x/length(pos)*0.5+0.5)*pi);
-    f+=sin(atan(pos.y,pos.x)*7.0)*5.0;
-    float alpha = texture2D(texture,uvCoord).a;
-    gl_FragColor = vec4(color(f),alpha);
-}

share/slop/hippie.vert

@@ -1,12 +0,0 @@
-#version 120
-
-attribute vec2 vertex;
-attribute vec2 uv;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    uvCoord = uv;
-	gl_Position = vec4(vertex,0,1);
-}

share/slop/invert.frag

@@ -1,16 +0,0 @@
-#version 120
-
-uniform sampler2D texture;
-uniform sampler2D desktop;
-uniform int desktopWidth;
-uniform int desktopHeight;
-uniform float time;
-
-varying vec2 uvCoord;
-
-void main() {
-    vec2 uv = vec2( uvCoord.x, -uvCoord.y );
-    vec4 color = texture2D(desktop,uv);
-    float alpha = texture2D(texture,uvCoord).a;
-    gl_FragColor = vec4( 1.0 - color.r, 1.0 - color.g, 1.0 - color.b, alpha );
-}

share/slop/invert.vert

@@ -1,13 +0,0 @@
-#version 120
-
-attribute vec2 vertex;
-attribute vec2 uv;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    uvCoord = uv;
-    gl_Position = vec4(vertex,0,1);
-}
-

share/slop/refract.frag

@@ -1,83 +0,0 @@
-#version 120
-
-uniform sampler2D texture;
-uniform sampler2D desktop;
-uniform int desktopWidth;
-uniform int desktopHeight;
-uniform float time;
-
-varying vec2 uvCoord;
-
-vec2 getDesktopUV( vec2 uv ) {
-    // Desktop image is upside-down, blame X11 lmao
-    uv.y = -uv.y;
-    return uv;
-}
-
-const float pi = 3.14159265f;
-
-void main() {
-    float sigma = 5;
-    float numBlurPixelsPerSide = 2.0f;
-    float blurMultiplier = 2.0f;
-
-    vec2 tc = uvCoord.xy;
-    vec2 p = -1.0 + 2.0 * tc;
-    float len = length(p);
-    vec2 offset = (p/len)*cos(len*12.0-time*4.0)*0.005;
-
-    // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
-    float blurSize = 1.f/desktopWidth*blurMultiplier;
-    vec2 blurMultiplyVec      = vec2(0.0f, 1.0f);
-    vec3 incrementalGaussian;
-    incrementalGaussian.x = 1.0f / (sqrt(2.0f * pi) * sigma);
-    incrementalGaussian.y = exp(-0.5f / (sigma * sigma));
-    incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
-
-    vec4 avgValue = vec4(0.0f, 0.0f, 0.0f, 0.0f);
-    float coefficientSum = 0.0f;
-
-    // Take the central sample first...
-    vec4 color = texture2D( desktop, getDesktopUV( uvCoord.xy ) + offset );
-    color.a = texture2D( texture, uvCoord.xy ).a;
-    avgValue += color * incrementalGaussian.x;
-    coefficientSum += incrementalGaussian.x;
-    incrementalGaussian.xy *= incrementalGaussian.yz;
-
-    // Go through the remaining 8 vertical samples (4 on each side of the center)
-    for (float i = 1.0f; i <= numBlurPixelsPerSide; i++) {
-        vec2 uv = (uvCoord.xy - i * blurSize * blurMultiplyVec);
-        color = texture2D( desktop, getDesktopUV( uv ) + offset );
-        color.a = texture2D( texture, uv ).a;
-        avgValue += color * incrementalGaussian.x;
-        uv = (uvCoord.xy + i * blurSize * blurMultiplyVec);
-        color = texture2D( desktop, getDesktopUV( uv ) + offset );
-        color.a = texture2D( texture, uv ).a;
-        avgValue += color * incrementalGaussian.x;
-        coefficientSum += 2 * incrementalGaussian.x;
-        incrementalGaussian.xy *= incrementalGaussian.yz;
-    }
-
-    //Reset
-    blurSize = 1.f/desktopWidth*blurMultiplier;
-    blurMultiplyVec      = vec2(1.0f, 0.0f);
-    incrementalGaussian.x = 1.0f / (sqrt(2.0f * pi) * sigma);
-    incrementalGaussian.y = exp(-0.5f / (sigma * sigma));
-    incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
-
-    // Go through the remaining 8 horizontal samples (4 on each side of the center)
-    for (float i = 1.0f; i <= numBlurPixelsPerSide; i++) {
-        vec2 uv = (uvCoord.xy - i * blurSize * blurMultiplyVec);
-        vec4 color = texture2D( desktop, getDesktopUV( uv ) + offset );
-        color.a = texture2D( texture, uv ).a;
-        avgValue += color * incrementalGaussian.x;
-        uv = (uvCoord.xy + i * blurSize * blurMultiplyVec);
-        color = texture2D( desktop, getDesktopUV( uv ) + offset );
-        color.a = texture2D( texture, uv ).a;
-        avgValue += color * incrementalGaussian.x;
-        coefficientSum += 2 * incrementalGaussian.x;
-        incrementalGaussian.xy *= incrementalGaussian.yz;
-    }
-
-    gl_FragColor = avgValue / coefficientSum;
-}

share/slop/refract.vert

@@ -1,12 +0,0 @@
-#version 120
-
-attribute vec2 vertex;
-attribute vec2 uv;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    uvCoord = uv;
-	gl_Position = vec4(vertex,0,1);
-}

share/slop/ripple.frag

@@ -1,17 +0,0 @@
-#version 120
-
-uniform sampler2D texture;
-uniform sampler2D desktop;
-uniform int desktopWidth;
-uniform int desktopHeight;
-uniform float time;
-
-varying vec2 uvCoord;
-
-void main() {
-    vec2 tc = uvCoord.xy;
-    vec2 p = -1.0 + 2.0 * tc;
-    float len = length(p);
-    vec2 uv = tc + (p/len)*cos(len*12.0-time*4.0)*0.02;
-    gl_FragColor = texture2D(texture,uv);
-}

share/slop/ripple.vert

@@ -1,13 +0,0 @@
-#version 120
-
-attribute vec2 vertex;
-attribute vec2 uv;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    uvCoord = uv;
-    gl_Position = vec4(vertex,0,1);
-}
-

share/slop/simple.frag

@@ -1,12 +0,0 @@
-#version 120
-
-uniform sampler2D texture;
-uniform sampler2D desktop;
-uniform float time;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    gl_FragColor = texture2D( texture, uvCoord );
-}

share/slop/simple.vert

@@ -1,12 +0,0 @@
-#version 120
-
-attribute vec2 vertex;
-attribute vec2 uv;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    uvCoord = uv;
-	gl_Position = vec4(vertex,0,1);
-}

share/slop/wiggle.frag

@@ -1,20 +0,0 @@
-#version 120
-
-uniform sampler2D texture;
-uniform sampler2D desktop;
-uniform int desktopWidth;
-uniform int desktopHeight;
-uniform float time;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    // Higher strength means bigger wobble
-    float strength = 8;
-    // Higher speed means faster wobble
-    float speed = 2;
-    float x = uvCoord.x + (sin( time*speed + uvCoord.y * desktopHeight/strength ) + 0.5)/desktopWidth*strength;
-    float y = uvCoord.y + (cos( time*speed + uvCoord.x * desktopWidth/strength ) + 0.5)/desktopHeight*strength;
-    gl_FragColor = texture2D( texture, vec2( x, y ) );
-}

share/slop/wiggle.vert

@@ -1,12 +0,0 @@
-#version 120
-
-attribute vec2 vertex;
-attribute vec2 uv;
-
-varying vec2 uvCoord;
-
-void main()
-{
-    uvCoord = uv;
-	gl_Position = vec4(vertex,0,1);
-}

slop.1

@@ -0,0 +1,74 @@
+.\" Manpage for slop.
+.\" Contact naelstrof@gmail.com to correct errors or typos.
+.TH SLOP 1 2017-03-21 Linux "slop man page"
+.SH NAME
+slop \- select operation
+.SH SYNOPSIS
+slop [-klqn] [OPTIONS]
+.SH DESCRIPTION
+slop is an application that queries for a selection from the user and prints the region to stdout. It grabs the mouse and turns it into a crosshair, lets the user click and drag to make a selection (or click on a window) while drawing a pretty box around it, then finally prints the selection's dimensions to stdout.
+.SH OPTIONS
+.TP
+.BR \-h ", " \-\-help
+Print help and exit.
+.TP
+.BR \-v ", " \-\-version
+Print version and exit.
+.TP
+.BR \-x ", " \-\-xdisplay=\fIhostname:number.screen_number\fR
+Sets the xdisplay to use.
+.TP
+.BR \-b ", " \-\-bordersize=\fIFLOAT\fR
+Sets the selection rectangle's thickness.
+.TP
+.BR \-p ", " \-\-padding=\fIFLOAT\fR
+Sets the padding size for the selection, this can be negative.
+.TP
+.BR \-t ", " \-\-tolerance=\fIFLOAT\fR
+How far in pixels the mouse can move after clicking, and still be detected as a normal click instead of a click-and-drag. Setting this to 0 will disable window selections. Alternatively setting it to 9999999 would force a window selection.
+.TP
+.BR \-c ", " \-\-color=\fIFLOAT,FLOAT,FLOAT,FLOAT\fR
+Sets the selection rectangle's color. Supports RGB or RGBA input. Depending on the system's window manager/OpenGL support, the opacity may be ignored.
+.TP
+.BR \-r ", " \-\-shader=\fISTRING\fR
+This sets the vertex shader, and fragment shader combo to use when drawing the final framebuffer to the screen. This obviously only works when OpenGL is enabled. The shaders are loaded from ~/.config/slop. See https://github.com/naelstrof/slop for more information on how to create your own shaders.
+.TP
+.BR \-f ", " \-\-format=\fISTRING\fR
+Sets the output format for slop. Format specifiers are %x, %y, %w, %h, %i, and %g. If actual percentage signs are desired in output, use a double percentage sign like so `%%`.
+.TP
+.BR \-n ", " \-\-nodecorations=INT
+Sets the level of aggressiveness when trying to remove window decroations. `0' is off, `1' will try lightly to remove decorations, and `2' will recursively descend into the root tree until it gets the deepest available visible child under the mouse. Defaults to `0'.
+.TP
+.BR \-l ", " \-\-highlight
+Instead of outlining a selection, slop will highlight it instead. This is particularly useful if the color is set to an opacity lower than 1.
+.TP
+.BR \-q ", " \-\-quiet
+Disable any unnecessary cerr output. Any warnings simply won't print.
+.TP
+.BR \-k ", " \-\-nokeyboard
+Disables the ability to cancel selections with the keyboard.
+.SH EXAMPLES
+To emulate a windows XP selection, you can use something like this:
+.PP
+.nf
+.RS
+slop --highlight --tolerance=0 --color=0.3,0.4,0.6,0.4
+.RE
+.fi
+.PP
+In order to avoid using
+.BR eval(1)
+in your scripts (pretty big security issue), you can use slop like this instead:
+.PP
+.nf
+.RS
+read -r X Y W H G ID < <(slop -f "%x %y %w %h %g %i")
+.RE
+.fi
+.PP
+.SH SEE ALSO
+.BR maim(1) 
+.SH BUGS
+No known bugs.
+.SH AUTHOR
+Dalton Nell (naelstrof@gmail.com)

src/cmdline.c

@@ -1,893 +0,0 @@
-/*
-  File autogenerated by gengetopt version 2.22.6
-  generated with the following command:
-  /usr/bin/gengetopt --input=options.ggo 
-
-  The developers of gengetopt consider the fixed text that goes in all
-  gengetopt output files to be in the public domain:
-  we make no copyright claims on it.
-*/
-
-/* If we use autoconf.  */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef FIX_UNUSED
-#define FIX_UNUSED(X) (void) (X) /* avoid warnings for unused params */
-#endif
-
-#include <getopt.h>
-
-#include "cmdline.h"
-
-const char *gengetopt_args_info_purpose = "";
-
-const char *gengetopt_args_info_usage = "Usage: slop [options]";
-
-const char *gengetopt_args_info_versiontext = "Copyright (C) 2014 Dalton Nell, Slop Contributors\n(https://github.com/naelstrof/slop/graphs/contributors)";
-
-const char *gengetopt_args_info_description = "slop (Select Operation) is an application that queries for a selection from the\nuser and prints the region to stdout.";
-
-const char *gengetopt_args_info_help[] = {
-  "  -h, --help                    Print help and exit",
-  "  -V, --version                 Print version and exit",
-  "Options",
-  "      --xdisplay=hostname:number.screen_number\n                                Sets the x display.",
-  "      --nokeyboard              Disables the ability to cancel selections with\n                                  the keyboard.  (default=off)",
-  "  -b, --bordersize=INT          Set the selection rectangle's thickness. Does\n                                  nothing when --highlight is enabled.\n                                  (default=`5')",
-  "  -p, --padding=INT             Set the padding size of the selection. Can be\n                                  negative.  (default=`0')",
-  "  -t, --tolerance=INT           How far in pixels the mouse can move after\n                                  clicking and still be detected as a normal\n                                  click instead of a click and drag. Setting\n                                  this to 0 will disable window selections.\n                                  (default=`2')",
-  "  -g, --gracetime=FLOAT         Set the amount of time before slop will check\n                                  for keyboard cancellations in seconds.\n                                  (default=`0.4')",
-  "  -c, --color=FLOAT,FLOAT,FLOAT,FLOAT\n                                Set the selection rectangle's color. Supports\n                                  RGB or RGBA values.\n                                  (default=`0.5,0.5,0.5,1')",
-  "  -n, --nodecorations           Attempt to select child windows in order to\n                                  avoid window decorations.  (default=off)",
-  "      --min=INT                 Set the minimum output of width or height\n                                  values. This is useful to avoid outputting 0.\n                                  Setting min and max to the same value\n                                  disables drag selections.  (default=`0')",
-  "      --max=INT                 Set the maximum output of width or height\n                                  values. Setting min and max to the same value\n                                  disables drag selections.  (default=`0')",
-  "  -l, --highlight               Instead of outlining selections, slop\n                                  highlights it. This is only useful when\n                                  --color is set to a transparent color.\n                                  (default=off)",
-  "      --opengl                  Enable hardware acceleration. Only works with\n                                  modern systems that are also running a\n                                  compositor.  (default=off)",
-  "      --magnify                 Display a magnifying glass when --opengl is\n                                  also enabled.  (default=off)",
-  "      --magstrength=FLOAT       Sets how many times the magnification window\n                                  size is multiplied.  (default=`4')",
-  "      --magpixels=INT           Sets how many pixels are displayed in the\n                                  magnification. The less pixels the bigger the\n                                  magnification.  (default=`64')",
-  "      --theme=STRING            Sets the theme of the selection, using textures\n                                  from ~/.config/slop/ or /usr/share/.\n                                  (default=`none')",
-  "      --shader=STRING           Sets the shader to load and use from\n                                  ~/.config/slop/ or /usr/share/.\n                                  (default=`simple')",
-  "  -f, --format=STRING           Set the output format string. Format specifiers\n                                  are %x, %y, %w, %h, %i, %g, and %c.\n                                  (default=`X=%x\\nY=%y\\nW=%w\\nH=%h\\nG=%g\\nID=%i\\nCancel=%c\\n')",
-  "\nExamples\n    $ # Gray, thick, transparent border for maximum visiblity.\n    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n\n    $ # Remove window decorations.\n    $ slop --nodecorations\n\n    $ # Disable window selections. Useful for selecting individual pixels.\n    $ slop -t 0\n\n    $ # Classic Windows XP selection.\n    $ slop -l -c 0.3,0.4,0.6,0.4\n\n    $ # Wiggle wiggle!\n    $ slop --opengl --shader wiggle\n\n    $ # Edgy textures or something.\n    $ slop --opengl --theme gothic\n\n    $ # Change output format to use safer parsing\n    $ slopoutput=$(slop -f \"%x %y %w %h\")\n    $ X=$(echo $slopoutput | awk '{print $1}')\n    $ Y=$(echo $slopoutput | awk '{print $2}')\n    $ W=$(echo $slopoutput | awk '{print $3}')\n    $ H=$(echo $slopoutput | awk '{print $4}')\n\nTips\n    * You can use the arrow keys to move the starting point of a\ndrag-selection, just in case you missed it by a few pixels.\n    * If you don't like a selection: you can cancel it by right-clicking\nregardless of which options are enabled or disabled for slop.\n    * If slop doesn't seem to select a window accurately, the problem could be\nbecause of decorations getting in the way. Try enabling the --nodecorations\nflag.\n",
-    0
-};
-
-typedef enum {ARG_NO
-  , ARG_FLAG
-  , ARG_STRING
-  , ARG_INT
-  , ARG_FLOAT
-} cmdline_parser_arg_type;
-
-static
-void clear_given (struct gengetopt_args_info *args_info);
-static
-void clear_args (struct gengetopt_args_info *args_info);
-
-static int
-cmdline_parser_internal (int argc, char **argv, struct gengetopt_args_info *args_info,
-                        struct cmdline_parser_params *params, const char *additional_error);
-
-
-static char *
-gengetopt_strdup (const char *s);
-
-static
-void clear_given (struct gengetopt_args_info *args_info)
-{
-  args_info->help_given = 0 ;
-  args_info->version_given = 0 ;
-  args_info->xdisplay_given = 0 ;
-  args_info->nokeyboard_given = 0 ;
-  args_info->bordersize_given = 0 ;
-  args_info->padding_given = 0 ;
-  args_info->tolerance_given = 0 ;
-  args_info->gracetime_given = 0 ;
-  args_info->color_given = 0 ;
-  args_info->nodecorations_given = 0 ;
-  args_info->min_given = 0 ;
-  args_info->max_given = 0 ;
-  args_info->highlight_given = 0 ;
-  args_info->opengl_given = 0 ;
-  args_info->magnify_given = 0 ;
-  args_info->magstrength_given = 0 ;
-  args_info->magpixels_given = 0 ;
-  args_info->theme_given = 0 ;
-  args_info->shader_given = 0 ;
-  args_info->format_given = 0 ;
-}
-
-static
-void clear_args (struct gengetopt_args_info *args_info)
-{
-  FIX_UNUSED (args_info);
-  args_info->xdisplay_arg = NULL;
-  args_info->xdisplay_orig = NULL;
-  args_info->nokeyboard_flag = 0;
-  args_info->bordersize_arg = 5;
-  args_info->bordersize_orig = NULL;
-  args_info->padding_arg = 0;
-  args_info->padding_orig = NULL;
-  args_info->tolerance_arg = 2;
-  args_info->tolerance_orig = NULL;
-  args_info->gracetime_arg = gengetopt_strdup ("0.4");
-  args_info->gracetime_orig = NULL;
-  args_info->color_arg = gengetopt_strdup ("0.5,0.5,0.5,1");
-  args_info->color_orig = NULL;
-  args_info->nodecorations_flag = 0;
-  args_info->min_arg = 0;
-  args_info->min_orig = NULL;
-  args_info->max_arg = 0;
-  args_info->max_orig = NULL;
-  args_info->highlight_flag = 0;
-  args_info->opengl_flag = 0;
-  args_info->magnify_flag = 0;
-  args_info->magstrength_arg = 4;
-  args_info->magstrength_orig = NULL;
-  args_info->magpixels_arg = 64;
-  args_info->magpixels_orig = NULL;
-  args_info->theme_arg = gengetopt_strdup ("none");
-  args_info->theme_orig = NULL;
-  args_info->shader_arg = gengetopt_strdup ("simple");
-  args_info->shader_orig = NULL;
-  args_info->format_arg = gengetopt_strdup ("X=%x\nY=%y\nW=%w\nH=%h\nG=%g\nID=%i\nCancel=%c\n");
-  args_info->format_orig = NULL;
-  
-}
-
-static
-void init_args_info(struct gengetopt_args_info *args_info)
-{
-
-
-  args_info->help_help = gengetopt_args_info_help[0] ;
-  args_info->version_help = gengetopt_args_info_help[1] ;
-  args_info->xdisplay_help = gengetopt_args_info_help[3] ;
-  args_info->nokeyboard_help = gengetopt_args_info_help[4] ;
-  args_info->bordersize_help = gengetopt_args_info_help[5] ;
-  args_info->padding_help = gengetopt_args_info_help[6] ;
-  args_info->tolerance_help = gengetopt_args_info_help[7] ;
-  args_info->gracetime_help = gengetopt_args_info_help[8] ;
-  args_info->color_help = gengetopt_args_info_help[9] ;
-  args_info->nodecorations_help = gengetopt_args_info_help[10] ;
-  args_info->min_help = gengetopt_args_info_help[11] ;
-  args_info->max_help = gengetopt_args_info_help[12] ;
-  args_info->highlight_help = gengetopt_args_info_help[13] ;
-  args_info->opengl_help = gengetopt_args_info_help[14] ;
-  args_info->magnify_help = gengetopt_args_info_help[15] ;
-  args_info->magstrength_help = gengetopt_args_info_help[16] ;
-  args_info->magpixels_help = gengetopt_args_info_help[17] ;
-  args_info->theme_help = gengetopt_args_info_help[18] ;
-  args_info->shader_help = gengetopt_args_info_help[19] ;
-  args_info->format_help = gengetopt_args_info_help[20] ;
-  
-}
-
-void
-cmdline_parser_print_version (void)
-{
-  printf ("%s %s\n",
-     (strlen(CMDLINE_PARSER_PACKAGE_NAME) ? CMDLINE_PARSER_PACKAGE_NAME : CMDLINE_PARSER_PACKAGE),
-     CMDLINE_PARSER_VERSION);
-
-  if (strlen(gengetopt_args_info_versiontext) > 0)
-    printf("\n%s\n", gengetopt_args_info_versiontext);
-}
-
-static void print_help_common(void) {
-  cmdline_parser_print_version ();
-
-  if (strlen(gengetopt_args_info_purpose) > 0)
-    printf("\n%s\n", gengetopt_args_info_purpose);
-
-  if (strlen(gengetopt_args_info_usage) > 0)
-    printf("\n%s\n", gengetopt_args_info_usage);
-
-  printf("\n");
-
-  if (strlen(gengetopt_args_info_description) > 0)
-    printf("%s\n\n", gengetopt_args_info_description);
-}
-
-void
-cmdline_parser_print_help (void)
-{
-  int i = 0;
-  print_help_common();
-  while (gengetopt_args_info_help[i])
-    printf("%s\n", gengetopt_args_info_help[i++]);
-}
-
-void
-cmdline_parser_init (struct gengetopt_args_info *args_info)
-{
-  clear_given (args_info);
-  clear_args (args_info);
-  init_args_info (args_info);
-}
-
-void
-cmdline_parser_params_init(struct cmdline_parser_params *params)
-{
-  if (params)
-    { 
-      params->override = 0;
-      params->initialize = 1;
-      params->check_required = 1;
-      params->check_ambiguity = 0;
-      params->print_errors = 1;
-    }
-}
-
-struct cmdline_parser_params *
-cmdline_parser_params_create(void)
-{
-  struct cmdline_parser_params *params = 
-    (struct cmdline_parser_params *)malloc(sizeof(struct cmdline_parser_params));
-  cmdline_parser_params_init(params);  
-  return params;
-}
-
-static void
-free_string_field (char **s)
-{
-  if (*s)
-    {
-      free (*s);
-      *s = 0;
-    }
-}
-
-
-static void
-cmdline_parser_release (struct gengetopt_args_info *args_info)
-{
-
-  free_string_field (&(args_info->xdisplay_arg));
-  free_string_field (&(args_info->xdisplay_orig));
-  free_string_field (&(args_info->bordersize_orig));
-  free_string_field (&(args_info->padding_orig));
-  free_string_field (&(args_info->tolerance_orig));
-  free_string_field (&(args_info->gracetime_arg));
-  free_string_field (&(args_info->gracetime_orig));
-  free_string_field (&(args_info->color_arg));
-  free_string_field (&(args_info->color_orig));
-  free_string_field (&(args_info->min_orig));
-  free_string_field (&(args_info->max_orig));
-  free_string_field (&(args_info->magstrength_orig));
-  free_string_field (&(args_info->magpixels_orig));
-  free_string_field (&(args_info->theme_arg));
-  free_string_field (&(args_info->theme_orig));
-  free_string_field (&(args_info->shader_arg));
-  free_string_field (&(args_info->shader_orig));
-  free_string_field (&(args_info->format_arg));
-  free_string_field (&(args_info->format_orig));
-  
-  
-
-  clear_given (args_info);
-}
-
-
-static void
-write_into_file(FILE *outfile, const char *opt, const char *arg, const char *values[])
-{
-  FIX_UNUSED (values);
-  if (arg) {
-    fprintf(outfile, "%s=\"%s\"\n", opt, arg);
-  } else {
-    fprintf(outfile, "%s\n", opt);
-  }
-}
-
-
-int
-cmdline_parser_dump(FILE *outfile, struct gengetopt_args_info *args_info)
-{
-  int i = 0;
-
-  if (!outfile)
-    {
-      fprintf (stderr, "%s: cannot dump options to stream\n", CMDLINE_PARSER_PACKAGE);
-      return EXIT_FAILURE;
-    }
-
-  if (args_info->help_given)
-    write_into_file(outfile, "help", 0, 0 );
-  if (args_info->version_given)
-    write_into_file(outfile, "version", 0, 0 );
-  if (args_info->xdisplay_given)
-    write_into_file(outfile, "xdisplay", args_info->xdisplay_orig, 0);
-  if (args_info->nokeyboard_given)
-    write_into_file(outfile, "nokeyboard", 0, 0 );
-  if (args_info->bordersize_given)
-    write_into_file(outfile, "bordersize", args_info->bordersize_orig, 0);
-  if (args_info->padding_given)
-    write_into_file(outfile, "padding", args_info->padding_orig, 0);
-  if (args_info->tolerance_given)
-    write_into_file(outfile, "tolerance", args_info->tolerance_orig, 0);
-  if (args_info->gracetime_given)
-    write_into_file(outfile, "gracetime", args_info->gracetime_orig, 0);
-  if (args_info->color_given)
-    write_into_file(outfile, "color", args_info->color_orig, 0);
-  if (args_info->nodecorations_given)
-    write_into_file(outfile, "nodecorations", 0, 0 );
-  if (args_info->min_given)
-    write_into_file(outfile, "min", args_info->min_orig, 0);
-  if (args_info->max_given)
-    write_into_file(outfile, "max", args_info->max_orig, 0);
-  if (args_info->highlight_given)
-    write_into_file(outfile, "highlight", 0, 0 );
-  if (args_info->opengl_given)
-    write_into_file(outfile, "opengl", 0, 0 );
-  if (args_info->magnify_given)
-    write_into_file(outfile, "magnify", 0, 0 );
-  if (args_info->magstrength_given)
-    write_into_file(outfile, "magstrength", args_info->magstrength_orig, 0);
-  if (args_info->magpixels_given)
-    write_into_file(outfile, "magpixels", args_info->magpixels_orig, 0);
-  if (args_info->theme_given)
-    write_into_file(outfile, "theme", args_info->theme_orig, 0);
-  if (args_info->shader_given)
-    write_into_file(outfile, "shader", args_info->shader_orig, 0);
-  if (args_info->format_given)
-    write_into_file(outfile, "format", args_info->format_orig, 0);
-  
-
-  i = EXIT_SUCCESS;
-  return i;
-}
-
-int
-cmdline_parser_file_save(const char *filename, struct gengetopt_args_info *args_info)
-{
-  FILE *outfile;
-  int i = 0;
-
-  outfile = fopen(filename, "w");
-
-  if (!outfile)
-    {
-      fprintf (stderr, "%s: cannot open file for writing: %s\n", CMDLINE_PARSER_PACKAGE, filename);
-      return EXIT_FAILURE;
-    }
-
-  i = cmdline_parser_dump(outfile, args_info);
-  fclose (outfile);
-
-  return i;
-}
-
-void
-cmdline_parser_free (struct gengetopt_args_info *args_info)
-{
-  cmdline_parser_release (args_info);
-}
-
-/** @brief replacement of strdup, which is not standard */
-char *
-gengetopt_strdup (const char *s)
-{
-  char *result = 0;
-  if (!s)
-    return result;
-
-  result = (char*)malloc(strlen(s) + 1);
-  if (result == (char*)0)
-    return (char*)0;
-  strcpy(result, s);
-  return result;
-}
-
-int
-cmdline_parser (int argc, char **argv, struct gengetopt_args_info *args_info)
-{
-  return cmdline_parser2 (argc, argv, args_info, 0, 1, 1);
-}
-
-int
-cmdline_parser_ext (int argc, char **argv, struct gengetopt_args_info *args_info,
-                   struct cmdline_parser_params *params)
-{
-  int result;
-  result = cmdline_parser_internal (argc, argv, args_info, params, 0);
-
-  if (result == EXIT_FAILURE)
-    {
-      cmdline_parser_free (args_info);
-      exit (EXIT_FAILURE);
-    }
-  
-  return result;
-}
-
-int
-cmdline_parser2 (int argc, char **argv, struct gengetopt_args_info *args_info, int override, int initialize, int check_required)
-{
-  int result;
-  struct cmdline_parser_params params;
-  
-  params.override = override;
-  params.initialize = initialize;
-  params.check_required = check_required;
-  params.check_ambiguity = 0;
-  params.print_errors = 1;
-
-  result = cmdline_parser_internal (argc, argv, args_info, &params, 0);
-
-  if (result == EXIT_FAILURE)
-    {
-      cmdline_parser_free (args_info);
-      exit (EXIT_FAILURE);
-    }
-  
-  return result;
-}
-
-int
-cmdline_parser_required (struct gengetopt_args_info *args_info, const char *prog_name)
-{
-  FIX_UNUSED (args_info);
-  FIX_UNUSED (prog_name);
-  return EXIT_SUCCESS;
-}
-
-
-static char *package_name = 0;
-
-/**
- * @brief updates an option
- * @param field the generic pointer to the field to update
- * @param orig_field the pointer to the orig field
- * @param field_given the pointer to the number of occurrence of this option
- * @param prev_given the pointer to the number of occurrence already seen
- * @param value the argument for this option (if null no arg was specified)
- * @param possible_values the possible values for this option (if specified)
- * @param default_value the default value (in case the option only accepts fixed values)
- * @param arg_type the type of this option
- * @param check_ambiguity @see cmdline_parser_params.check_ambiguity
- * @param override @see cmdline_parser_params.override
- * @param no_free whether to free a possible previous value
- * @param multiple_option whether this is a multiple option
- * @param long_opt the corresponding long option
- * @param short_opt the corresponding short option (or '-' if none)
- * @param additional_error possible further error specification
- */
-static
-int update_arg(void *field, char **orig_field,
-               unsigned int *field_given, unsigned int *prev_given, 
-               char *value, const char *possible_values[],
-               const char *default_value,
-               cmdline_parser_arg_type arg_type,
-               int check_ambiguity, int override,
-               int no_free, int multiple_option,
-               const char *long_opt, char short_opt,
-               const char *additional_error)
-{
-  char *stop_char = 0;
-  const char *val = value;
-  int found;
-  char **string_field;
-  FIX_UNUSED (field);
-
-  stop_char = 0;
-  found = 0;
-
-  if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given)))
-    {
-      if (short_opt != '-')
-        fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n", 
-               package_name, long_opt, short_opt,
-               (additional_error ? additional_error : ""));
-      else
-        fprintf (stderr, "%s: `--%s' option given more than once%s\n", 
-               package_name, long_opt,
-               (additional_error ? additional_error : ""));
-      return 1; /* failure */
-    }
-
-  FIX_UNUSED (default_value);
-    
-  if (field_given && *field_given && ! override)
-    return 0;
-  if (prev_given)
-    (*prev_given)++;
-  if (field_given)
-    (*field_given)++;
-  if (possible_values)
-    val = possible_values[found];
-
-  switch(arg_type) {
-  case ARG_FLAG:
-    *((int *)field) = !*((int *)field);
-    break;
-  case ARG_INT:
-    if (val) *((int *)field) = strtol (val, &stop_char, 0);
-    break;
-  case ARG_FLOAT:
-    if (val) *((float *)field) = (float)strtod (val, &stop_char);
-    break;
-  case ARG_STRING:
-    if (val) {
-      string_field = (char **)field;
-      if (!no_free && *string_field)
-        free (*string_field); /* free previous string */
-      *string_field = gengetopt_strdup (val);
-    }
-    break;
-  default:
-    break;
-  };
-
-  /* check numeric conversion */
-  switch(arg_type) {
-  case ARG_INT:
-  case ARG_FLOAT:
-    if (val && !(stop_char && *stop_char == '\0')) {
-      fprintf(stderr, "%s: invalid numeric value: %s\n", package_name, val);
-      return 1; /* failure */
-    }
-    break;
-  default:
-    ;
-  };
-
-  /* store the original value */
-  switch(arg_type) {
-  case ARG_NO:
-  case ARG_FLAG:
-    break;
-  default:
-    if (value && orig_field) {
-      if (no_free) {
-        *orig_field = value;
-      } else {
-        if (*orig_field)
-          free (*orig_field); /* free previous string */
-        *orig_field = gengetopt_strdup (value);
-      }
-    }
-  };
-
-  return 0; /* OK */
-}
-
-
-int
-cmdline_parser_internal (
-  int argc, char **argv, struct gengetopt_args_info *args_info,
-                        struct cmdline_parser_params *params, const char *additional_error)
-{
-  int c;	/* Character of the parsed option.  */
-
-  int error_occurred = 0;
-  struct gengetopt_args_info local_args_info;
-  
-  int override;
-  int initialize;
-  int check_required;
-  int check_ambiguity;
-  
-  package_name = argv[0];
-  
-  override = params->override;
-  initialize = params->initialize;
-  check_required = params->check_required;
-  check_ambiguity = params->check_ambiguity;
-
-  if (initialize)
-    cmdline_parser_init (args_info);
-
-  cmdline_parser_init (&local_args_info);
-
-  optarg = 0;
-  optind = 0;
-  opterr = params->print_errors;
-  optopt = '?';
-
-  while (1)
-    {
-      int option_index = 0;
-
-      static struct option long_options[] = {
-        { "help",	0, NULL, 'h' },
-        { "version",	0, NULL, 'V' },
-        { "xdisplay",	1, NULL, 0 },
-        { "nokeyboard",	0, NULL, 0 },
-        { "bordersize",	1, NULL, 'b' },
-        { "padding",	1, NULL, 'p' },
-        { "tolerance",	1, NULL, 't' },
-        { "gracetime",	1, NULL, 'g' },
-        { "color",	1, NULL, 'c' },
-        { "nodecorations",	0, NULL, 'n' },
-        { "min",	1, NULL, 0 },
-        { "max",	1, NULL, 0 },
-        { "highlight",	0, NULL, 'l' },
-        { "opengl",	0, NULL, 0 },
-        { "magnify",	0, NULL, 0 },
-        { "magstrength",	1, NULL, 0 },
-        { "magpixels",	1, NULL, 0 },
-        { "theme",	1, NULL, 0 },
-        { "shader",	1, NULL, 0 },
-        { "format",	1, NULL, 'f' },
-        { 0,  0, 0, 0 }
-      };
-
-      c = getopt_long (argc, argv, "hVb:p:t:g:c:nlf:", long_options, &option_index);
-
-      if (c == -1) break;	/* Exit from `while (1)' loop.  */
-
-      switch (c)
-        {
-        case 'h':	/* Print help and exit.  */
-          cmdline_parser_print_help ();
-          cmdline_parser_free (&local_args_info);
-          exit (EXIT_SUCCESS);
-
-        case 'V':	/* Print version and exit.  */
-          cmdline_parser_print_version ();
-          cmdline_parser_free (&local_args_info);
-          exit (EXIT_SUCCESS);
-
-        case 'b':	/* Set the selection rectangle's thickness. Does nothing when --highlight is enabled..  */
-        
-        
-          if (update_arg( (void *)&(args_info->bordersize_arg), 
-               &(args_info->bordersize_orig), &(args_info->bordersize_given),
-              &(local_args_info.bordersize_given), optarg, 0, "5", ARG_INT,
-              check_ambiguity, override, 0, 0,
-              "bordersize", 'b',
-              additional_error))
-            goto failure;
-        
-          break;
-        case 'p':	/* Set the padding size of the selection. Can be negative..  */
-        
-        
-          if (update_arg( (void *)&(args_info->padding_arg), 
-               &(args_info->padding_orig), &(args_info->padding_given),
-              &(local_args_info.padding_given), optarg, 0, "0", ARG_INT,
-              check_ambiguity, override, 0, 0,
-              "padding", 'p',
-              additional_error))
-            goto failure;
-        
-          break;
-        case 't':	/* How far in pixels the mouse can move after clicking and still be detected as a normal click instead of a click and drag. Setting this to 0 will disable window selections..  */
-        
-        
-          if (update_arg( (void *)&(args_info->tolerance_arg), 
-               &(args_info->tolerance_orig), &(args_info->tolerance_given),
-              &(local_args_info.tolerance_given), optarg, 0, "2", ARG_INT,
-              check_ambiguity, override, 0, 0,
-              "tolerance", 't',
-              additional_error))
-            goto failure;
-        
-          break;
-        case 'g':	/* Set the amount of time before slop will check for keyboard cancellations in seconds..  */
-        
-        
-          if (update_arg( (void *)&(args_info->gracetime_arg), 
-               &(args_info->gracetime_orig), &(args_info->gracetime_given),
-              &(local_args_info.gracetime_given), optarg, 0, "0.4", ARG_STRING,
-              check_ambiguity, override, 0, 0,
-              "gracetime", 'g',
-              additional_error))
-            goto failure;
-        
-          break;
-        case 'c':	/* Set the selection rectangle's color. Supports RGB or RGBA values..  */
-        
-        
-          if (update_arg( (void *)&(args_info->color_arg), 
-               &(args_info->color_orig), &(args_info->color_given),
-              &(local_args_info.color_given), optarg, 0, "0.5,0.5,0.5,1", ARG_STRING,
-              check_ambiguity, override, 0, 0,
-              "color", 'c',
-              additional_error))
-            goto failure;
-        
-          break;
-        case 'n':	/* Attempt to select child windows in order to avoid window decorations..  */
-        
-        
-          if (update_arg((void *)&(args_info->nodecorations_flag), 0, &(args_info->nodecorations_given),
-              &(local_args_info.nodecorations_given), optarg, 0, 0, ARG_FLAG,
-              check_ambiguity, override, 1, 0, "nodecorations", 'n',
-              additional_error))
-            goto failure;
-        
-          break;
-        case 'l':	/* Instead of outlining selections, slop highlights it. This is only useful when --color is set to a transparent color..  */
-        
-        
-          if (update_arg((void *)&(args_info->highlight_flag), 0, &(args_info->highlight_given),
-              &(local_args_info.highlight_given), optarg, 0, 0, ARG_FLAG,
-              check_ambiguity, override, 1, 0, "highlight", 'l',
-              additional_error))
-            goto failure;
-        
-          break;
-        case 'f':	/* Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c..  */
-        
-        
-          if (update_arg( (void *)&(args_info->format_arg), 
-               &(args_info->format_orig), &(args_info->format_given),
-              &(local_args_info.format_given), optarg, 0, "X=%x\nY=%y\nW=%w\nH=%h\nG=%g\nID=%i\nCancel=%c\n", ARG_STRING,
-              check_ambiguity, override, 0, 0,
-              "format", 'f',
-              additional_error))
-            goto failure;
-        
-          break;
-
-        case 0:	/* Long option with no short option */
-          /* Sets the x display..  */
-          if (strcmp (long_options[option_index].name, "xdisplay") == 0)
-          {
-          
-          
-            if (update_arg( (void *)&(args_info->xdisplay_arg), 
-                 &(args_info->xdisplay_orig), &(args_info->xdisplay_given),
-                &(local_args_info.xdisplay_given), optarg, 0, 0, ARG_STRING,
-                check_ambiguity, override, 0, 0,
-                "xdisplay", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Disables the ability to cancel selections with the keyboard..  */
-          else if (strcmp (long_options[option_index].name, "nokeyboard") == 0)
-          {
-          
-          
-            if (update_arg((void *)&(args_info->nokeyboard_flag), 0, &(args_info->nokeyboard_given),
-                &(local_args_info.nokeyboard_given), optarg, 0, 0, ARG_FLAG,
-                check_ambiguity, override, 1, 0, "nokeyboard", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Set the minimum output of width or height values. This is useful to avoid outputting 0. Setting min and max to the same value disables drag selections..  */
-          else if (strcmp (long_options[option_index].name, "min") == 0)
-          {
-          
-          
-            if (update_arg( (void *)&(args_info->min_arg), 
-                 &(args_info->min_orig), &(args_info->min_given),
-                &(local_args_info.min_given), optarg, 0, "0", ARG_INT,
-                check_ambiguity, override, 0, 0,
-                "min", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Set the maximum output of width or height values. Setting min and max to the same value disables drag selections..  */
-          else if (strcmp (long_options[option_index].name, "max") == 0)
-          {
-          
-          
-            if (update_arg( (void *)&(args_info->max_arg), 
-                 &(args_info->max_orig), &(args_info->max_given),
-                &(local_args_info.max_given), optarg, 0, "0", ARG_INT,
-                check_ambiguity, override, 0, 0,
-                "max", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Enable hardware acceleration. Only works with modern systems that are also running a compositor..  */
-          else if (strcmp (long_options[option_index].name, "opengl") == 0)
-          {
-          
-          
-            if (update_arg((void *)&(args_info->opengl_flag), 0, &(args_info->opengl_given),
-                &(local_args_info.opengl_given), optarg, 0, 0, ARG_FLAG,
-                check_ambiguity, override, 1, 0, "opengl", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Display a magnifying glass when --opengl is also enabled..  */
-          else if (strcmp (long_options[option_index].name, "magnify") == 0)
-          {
-          
-          
-            if (update_arg((void *)&(args_info->magnify_flag), 0, &(args_info->magnify_given),
-                &(local_args_info.magnify_given), optarg, 0, 0, ARG_FLAG,
-                check_ambiguity, override, 1, 0, "magnify", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Sets how many times the magnification window size is multiplied..  */
-          else if (strcmp (long_options[option_index].name, "magstrength") == 0)
-          {
-          
-          
-            if (update_arg( (void *)&(args_info->magstrength_arg), 
-                 &(args_info->magstrength_orig), &(args_info->magstrength_given),
-                &(local_args_info.magstrength_given), optarg, 0, "4", ARG_FLOAT,
-                check_ambiguity, override, 0, 0,
-                "magstrength", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification..  */
-          else if (strcmp (long_options[option_index].name, "magpixels") == 0)
-          {
-          
-          
-            if (update_arg( (void *)&(args_info->magpixels_arg), 
-                 &(args_info->magpixels_orig), &(args_info->magpixels_given),
-                &(local_args_info.magpixels_given), optarg, 0, "64", ARG_INT,
-                check_ambiguity, override, 0, 0,
-                "magpixels", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/..  */
-          else if (strcmp (long_options[option_index].name, "theme") == 0)
-          {
-          
-          
-            if (update_arg( (void *)&(args_info->theme_arg), 
-                 &(args_info->theme_orig), &(args_info->theme_given),
-                &(local_args_info.theme_given), optarg, 0, "none", ARG_STRING,
-                check_ambiguity, override, 0, 0,
-                "theme", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          /* Sets the shader to load and use from ~/.config/slop/ or /usr/share/..  */
-          else if (strcmp (long_options[option_index].name, "shader") == 0)
-          {
-          
-          
-            if (update_arg( (void *)&(args_info->shader_arg), 
-                 &(args_info->shader_orig), &(args_info->shader_given),
-                &(local_args_info.shader_given), optarg, 0, "simple", ARG_STRING,
-                check_ambiguity, override, 0, 0,
-                "shader", '-',
-                additional_error))
-              goto failure;
-          
-          }
-          
-          break;
-        case '?':	/* Invalid option.  */
-          /* `getopt_long' already printed an error message.  */
-          goto failure;
-
-        default:	/* bug: option not considered.  */
-          fprintf (stderr, "%s: option unknown: %c%s\n", CMDLINE_PARSER_PACKAGE, c, (additional_error ? additional_error : ""));
-          abort ();
-        } /* switch */
-    } /* while */
-
-
-
-
-  cmdline_parser_release (&local_args_info);
-
-  if ( error_occurred )
-    return (EXIT_FAILURE);
-
-  return 0;
-
-failure:
-  
-  cmdline_parser_release (&local_args_info);
-  return (EXIT_FAILURE);
-}

src/cmdline.in

@@ -1,240 +0,0 @@
-/** @file cmdline.h
- *  @brief The header file for the command line option parser
- *  generated by GNU Gengetopt version 2.22.6
- *  http://www.gnu.org/software/gengetopt.
- *  DO NOT modify this file, since it can be overwritten
- *  @author GNU Gengetopt by Lorenzo Bettini */
-
-#ifndef CMDLINE_H
-#define CMDLINE_H
-
-/* If we use autoconf.  */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stdio.h> /* for FILE */
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#ifndef CMDLINE_PARSER_PACKAGE
-/** @brief the program name (used for printing errors) */
-#define CMDLINE_PARSER_PACKAGE "slop"
-#endif
-
-#ifndef CMDLINE_PARSER_PACKAGE_NAME
-/** @brief the complete program name (used for help and version) */
-#define CMDLINE_PARSER_PACKAGE_NAME "slop"
-#endif
-
-#ifndef CMDLINE_PARSER_VERSION
-/** @brief the program version */
-#define CMDLINE_PARSER_VERSION "v@slop_VERSION_MAJOR@.@slop_VERSION_MINOR@.@slop_VERSION_PATCH@"
-#endif
-
-/** @brief Where the command line options are stored */
-struct gengetopt_args_info
-{
-  const char *help_help; /**< @brief Print help and exit help description.  */
-  const char *version_help; /**< @brief Print version and exit help description.  */
-  char * xdisplay_arg;	/**< @brief Sets the x display..  */
-  char * xdisplay_orig;	/**< @brief Sets the x display. original value given at command line.  */
-  const char *xdisplay_help; /**< @brief Sets the x display. help description.  */
-  int nokeyboard_flag;	/**< @brief Disables the ability to cancel selections with the keyboard. (default=off).  */
-  const char *nokeyboard_help; /**< @brief Disables the ability to cancel selections with the keyboard. help description.  */
-  int bordersize_arg;	/**< @brief Set the selection rectangle's thickness. Does nothing when --highlight is enabled. (default='5').  */
-  char * bordersize_orig;	/**< @brief Set the selection rectangle's thickness. Does nothing when --highlight is enabled. original value given at command line.  */
-  const char *bordersize_help; /**< @brief Set the selection rectangle's thickness. Does nothing when --highlight is enabled. help description.  */
-  int padding_arg;	/**< @brief Set the padding size of the selection. Can be negative. (default='0').  */
-  char * padding_orig;	/**< @brief Set the padding size of the selection. Can be negative. original value given at command line.  */
-  const char *padding_help; /**< @brief Set the padding size of the selection. Can be negative. help description.  */
-  int tolerance_arg;	/**< @brief How far in pixels the mouse can move after clicking and still be detected as a normal click instead of a click and drag. Setting this to 0 will disable window selections. (default='2').  */
-  char * tolerance_orig;	/**< @brief How far in pixels the mouse can move after clicking and still be detected as a normal click instead of a click and drag. Setting this to 0 will disable window selections. original value given at command line.  */
-  const char *tolerance_help; /**< @brief How far in pixels the mouse can move after clicking and still be detected as a normal click instead of a click and drag. Setting this to 0 will disable window selections. help description.  */
-  char * gracetime_arg;	/**< @brief Set the amount of time before slop will check for keyboard cancellations in seconds. (default='0.4').  */
-  char * gracetime_orig;	/**< @brief Set the amount of time before slop will check for keyboard cancellations in seconds. original value given at command line.  */
-  const char *gracetime_help; /**< @brief Set the amount of time before slop will check for keyboard cancellations in seconds. help description.  */
-  char * color_arg;	/**< @brief Set the selection rectangle's color. Supports RGB or RGBA values. (default='0.5,0.5,0.5,1').  */
-  char * color_orig;	/**< @brief Set the selection rectangle's color. Supports RGB or RGBA values. original value given at command line.  */
-  const char *color_help; /**< @brief Set the selection rectangle's color. Supports RGB or RGBA values. help description.  */
-  int nodecorations_flag;	/**< @brief Attempt to select child windows in order to avoid window decorations. (default=off).  */
-  const char *nodecorations_help; /**< @brief Attempt to select child windows in order to avoid window decorations. help description.  */
-  int min_arg;	/**< @brief Set the minimum output of width or height values. This is useful to avoid outputting 0. Setting min and max to the same value disables drag selections. (default='0').  */
-  char * min_orig;	/**< @brief Set the minimum output of width or height values. This is useful to avoid outputting 0. Setting min and max to the same value disables drag selections. original value given at command line.  */
-  const char *min_help; /**< @brief Set the minimum output of width or height values. This is useful to avoid outputting 0. Setting min and max to the same value disables drag selections. help description.  */
-  int max_arg;	/**< @brief Set the maximum output of width or height values. Setting min and max to the same value disables drag selections. (default='0').  */
-  char * max_orig;	/**< @brief Set the maximum output of width or height values. Setting min and max to the same value disables drag selections. original value given at command line.  */
-  const char *max_help; /**< @brief Set the maximum output of width or height values. Setting min and max to the same value disables drag selections. help description.  */
-  int highlight_flag;	/**< @brief Instead of outlining selections, slop highlights it. This is only useful when --color is set to a transparent color. (default=off).  */
-  const char *highlight_help; /**< @brief Instead of outlining selections, slop highlights it. This is only useful when --color is set to a transparent color. help description.  */
-  int opengl_flag;	/**< @brief Enable hardware acceleration. Only works with modern systems that are also running a compositor. (default=off).  */
-  const char *opengl_help; /**< @brief Enable hardware acceleration. Only works with modern systems that are also running a compositor. help description.  */
-  int magnify_flag;	/**< @brief Display a magnifying glass when --opengl is also enabled. (default=off).  */
-  const char *magnify_help; /**< @brief Display a magnifying glass when --opengl is also enabled. help description.  */
-  float magstrength_arg;	/**< @brief Sets how many times the magnification window size is multiplied. (default='4').  */
-  char * magstrength_orig;	/**< @brief Sets how many times the magnification window size is multiplied. original value given at command line.  */
-  const char *magstrength_help; /**< @brief Sets how many times the magnification window size is multiplied. help description.  */
-  int magpixels_arg;	/**< @brief Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification. (default='64').  */
-  char * magpixels_orig;	/**< @brief Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification. original value given at command line.  */
-  const char *magpixels_help; /**< @brief Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification. help description.  */
-  char * theme_arg;	/**< @brief Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/. (default='none').  */
-  char * theme_orig;	/**< @brief Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/. original value given at command line.  */
-  const char *theme_help; /**< @brief Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/. help description.  */
-  char * shader_arg;	/**< @brief Sets the shader to load and use from ~/.config/slop/ or /usr/share/. (default='simple').  */
-  char * shader_orig;	/**< @brief Sets the shader to load and use from ~/.config/slop/ or /usr/share/. original value given at command line.  */
-  const char *shader_help; /**< @brief Sets the shader to load and use from ~/.config/slop/ or /usr/share/. help description.  */
-  char * format_arg;	/**< @brief Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c. (default='REPLACEME').  */
-  char * format_orig;	/**< @brief Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c. original value given at command line.  */
-  const char *format_help; /**< @brief Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c. help description.  */
-  
-  unsigned int help_given ;	/**< @brief Whether help was given.  */
-  unsigned int version_given ;	/**< @brief Whether version was given.  */
-  unsigned int xdisplay_given ;	/**< @brief Whether xdisplay was given.  */
-  unsigned int nokeyboard_given ;	/**< @brief Whether nokeyboard was given.  */
-  unsigned int bordersize_given ;	/**< @brief Whether bordersize was given.  */
-  unsigned int padding_given ;	/**< @brief Whether padding was given.  */
-  unsigned int tolerance_given ;	/**< @brief Whether tolerance was given.  */
-  unsigned int gracetime_given ;	/**< @brief Whether gracetime was given.  */
-  unsigned int color_given ;	/**< @brief Whether color was given.  */
-  unsigned int nodecorations_given ;	/**< @brief Whether nodecorations was given.  */
-  unsigned int min_given ;	/**< @brief Whether min was given.  */
-  unsigned int max_given ;	/**< @brief Whether max was given.  */
-  unsigned int highlight_given ;	/**< @brief Whether highlight was given.  */
-  unsigned int opengl_given ;	/**< @brief Whether opengl was given.  */
-  unsigned int magnify_given ;	/**< @brief Whether magnify was given.  */
-  unsigned int magstrength_given ;	/**< @brief Whether magstrength was given.  */
-  unsigned int magpixels_given ;	/**< @brief Whether magpixels was given.  */
-  unsigned int theme_given ;	/**< @brief Whether theme was given.  */
-  unsigned int shader_given ;	/**< @brief Whether shader was given.  */
-  unsigned int format_given ;	/**< @brief Whether format was given.  */
-
-} ;
-
-/** @brief The additional parameters to pass to parser functions */
-struct cmdline_parser_params
-{
-  int override; /**< @brief whether to override possibly already present options (default 0) */
-  int initialize; /**< @brief whether to initialize the option structure gengetopt_args_info (default 1) */
-  int check_required; /**< @brief whether to check that all required options were provided (default 1) */
-  int check_ambiguity; /**< @brief whether to check for options already specified in the option structure gengetopt_args_info (default 0) */
-  int print_errors; /**< @brief whether getopt_long should print an error message for a bad option (default 1) */
-} ;
-
-/** @brief the purpose string of the program */
-extern const char *gengetopt_args_info_purpose;
-/** @brief the usage string of the program */
-extern const char *gengetopt_args_info_usage;
-/** @brief the description string of the program */
-extern const char *gengetopt_args_info_description;
-/** @brief all the lines making the help output */
-extern const char *gengetopt_args_info_help[];
-
-/**
- * The command line parser
- * @param argc the number of command line options
- * @param argv the command line options
- * @param args_info the structure where option information will be stored
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser (int argc, char **argv,
-  struct gengetopt_args_info *args_info);
-
-/**
- * The command line parser (version with additional parameters - deprecated)
- * @param argc the number of command line options
- * @param argv the command line options
- * @param args_info the structure where option information will be stored
- * @param override whether to override possibly already present options
- * @param initialize whether to initialize the option structure my_args_info
- * @param check_required whether to check that all required options were provided
- * @return 0 if everything went fine, NON 0 if an error took place
- * @deprecated use cmdline_parser_ext() instead
- */
-int cmdline_parser2 (int argc, char **argv,
-  struct gengetopt_args_info *args_info,
-  int override, int initialize, int check_required);
-
-/**
- * The command line parser (version with additional parameters)
- * @param argc the number of command line options
- * @param argv the command line options
- * @param args_info the structure where option information will be stored
- * @param params additional parameters for the parser
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser_ext (int argc, char **argv,
-  struct gengetopt_args_info *args_info,
-  struct cmdline_parser_params *params);
-
-/**
- * Save the contents of the option struct into an already open FILE stream.
- * @param outfile the stream where to dump options
- * @param args_info the option struct to dump
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser_dump(FILE *outfile,
-  struct gengetopt_args_info *args_info);
-
-/**
- * Save the contents of the option struct into a (text) file.
- * This file can be read by the config file parser (if generated by gengetopt)
- * @param filename the file where to save
- * @param args_info the option struct to save
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser_file_save(const char *filename,
-  struct gengetopt_args_info *args_info);
-
-/**
- * Print the help
- */
-void cmdline_parser_print_help(void);
-/**
- * Print the version
- */
-void cmdline_parser_print_version(void);
-
-/**
- * Initializes all the fields a cmdline_parser_params structure 
- * to their default values
- * @param params the structure to initialize
- */
-void cmdline_parser_params_init(struct cmdline_parser_params *params);
-
-/**
- * Allocates dynamically a cmdline_parser_params structure and initializes
- * all its fields to their default values
- * @return the created and initialized cmdline_parser_params structure
- */
-struct cmdline_parser_params *cmdline_parser_params_create(void);
-
-/**
- * Initializes the passed gengetopt_args_info structure's fields
- * (also set default values for options that have a default)
- * @param args_info the structure to initialize
- */
-void cmdline_parser_init (struct gengetopt_args_info *args_info);
-/**
- * Deallocates the string fields of the gengetopt_args_info structure
- * (but does not deallocate the structure itself)
- * @param args_info the structure to deallocate
- */
-void cmdline_parser_free (struct gengetopt_args_info *args_info);
-
-/**
- * Checks that all the required options were specified
- * @param args_info the structure to check
- * @param prog_name the name of the program that will be used to print
- *   possible errors
- * @return
- */
-int cmdline_parser_required (struct gengetopt_args_info *args_info,
-  const char *prog_name);
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* CMDLINE_H */

src/framebuffer.cpp

@@ -1,444 +1,86 @@
 #include "framebuffer.hpp"
 
-slop::Framebuffer::Framebuffer() {
-    m_shader = new slop::Shader( "simple", resource->getRealPath( "simple.vert" ), resource->getRealPath( "simple.frag" ) );
-    generatedBuffers = false;
-    m_width = 0;
-    m_height = 0;
-    m_flags = (slop::Framebuffer::buffers)0;
-    m_depth = 0;
-    m_stencil = 0;
-    m_frame = 0;
-    m_buffers[0] = 0;
-    m_buffers[1] = 0;
-    m_texture = 0;
-}
-
-void slop::Framebuffer::setShader( std::string shader ) {
-    delete m_shader;
-    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
-}
-
-slop::Framebuffer::Framebuffer( unsigned int width, unsigned int height, unsigned char flags, std::string shader ) {
-    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
-    generatedBuffers = false;
-    m_width = width;
-    m_height = height;
-    m_flags = flags;
-    if ( m_flags & stencil && m_flags & depth ) {
-        fprintf( stderr, "Most hardware doesn't support using a FBO with a depth and stencil attached! Condensing them to one render buffer..." );
-    }
-    if ( GLEW_VERSION_3_0 ) {
-        glGenFramebuffers( 1, &m_frame );
-        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
-        if ( m_flags & color ) {
-            glGenTextures( 1, &m_texture );
-            glBindTexture( GL_TEXTURE_2D, m_texture );
-            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
-            glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 );
-        }
-
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glGenRenderbuffers( 1, &m_depth );
-            glBindRenderbuffer( GL_RENDERBUFFER, m_depth );
-            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_width, m_height );
-            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth );
-        }
-
-        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
-        if ( m_flags & stencil ) {
-            glGenRenderbuffers( 1, &m_stencil );
-            glBindRenderbuffer( GL_RENDERBUFFER, m_stencil );
-            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_width, m_height );
-            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
-            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
-        }
-        check();
-        //Make sure we unbind when we're done.
-        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glGenFramebuffersEXT( 1, &m_frame );
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
+slop::Framebuffer::Framebuffer( int w, int h ) {
+    std::string vert = "#version 130\nattribute vec2 position;\nattribute vec2 uv;\nvarying vec2 uvCoord;\nvoid main()\n{\nuvCoord = uv;\ngl_Position = vec4(position,0,1);\n}\n";
+    std::string frag = "#version 130\nuniform sampler2D texture;\nvarying vec2 uvCoord;\nout vec4 outColor;void main()\n{\noutColor = texture2D( texture, uvCoord );\n}\n";
+    shader = new Shader( vert, frag, false );
+    glGenFramebuffers( 1, &fbuffer );
+    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
+    glGenTextures(1, &image);
+    glBindTexture(GL_TEXTURE_2D, image);
+    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);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    // generate our vertex and uv buffers
+    std::vector<glm::vec2> verts;
+    std::vector<glm::vec2> uvs;
 
-        if ( m_flags & color ) {
-            glGenTextures( 1, &m_texture );
-            glBindTexture( GL_TEXTURE_2D, m_texture );
-            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
-            glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 );
-        }
+    verts.push_back( glm::vec2(1,1) );
+    uvs.push_back( glm::vec2( 1, 1 ) );
+    verts.push_back( glm::vec2(-1,-1) );
+    uvs.push_back( glm::vec2( 0, 0 ) );
+    verts.push_back( glm::vec2(-1,1) );
+    uvs.push_back( glm::vec2( 0, 1 ) );
+    verts.push_back( glm::vec2(-1,-1) );
+    uvs.push_back( glm::vec2( 0, 0 ) );
+    verts.push_back( glm::vec2(1,1) );
+    uvs.push_back( glm::vec2( 1, 1 ) );
+    verts.push_back( glm::vec2(1,-1) );
+    uvs.push_back( glm::vec2( 1, 0 ) );
 
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glGenRenderbuffersEXT( 1, &m_depth );
-            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_depth );
-            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_width, m_height );
-            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depth );
-        }
+    glGenBuffers( 2, buffers );
+    glBindBuffer( GL_ARRAY_BUFFER, buffers[0] );
+    glBufferData( GL_ARRAY_BUFFER, verts.size() * sizeof( glm::vec2 ), &verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, buffers[1] );
+    glBufferData( GL_ARRAY_BUFFER, uvs.size() * sizeof( glm::vec2 ), &uvs[0], GL_STATIC_DRAW );
+    vertCount = verts.size();
+}
 
-        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
-        if ( m_flags & stencil ) {
-            glGenRenderbuffersEXT( 1, &m_stencil );
-            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_stencil );
-            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, m_width, m_height );
-            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
-            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
-        }
-        check();
-        //Make sure we unbind when we're done.
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
-    } else {
-        throw std::runtime_error( "Error: Failed to create framebuffer! You need OpenGL 3.0 or the GL_EXT_framebuffer_object extension!" );
-    }
+void slop::Framebuffer::setShader( std::string name ) {
+    delete shader;
+    shader = new Shader( name + ".vert", name + ".frag" );
 }
 
 slop::Framebuffer::~Framebuffer() {
-    if ( GLEW_VERSION_3_0 ) {
-        glDeleteFramebuffers( 1, &m_frame );
-        if ( m_flags & color ) {
-            glDeleteTextures( 1, &m_texture );
-        }
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glDeleteRenderbuffers( 1, &m_depth );
-        }
-        if ( m_flags & stencil ) {
-            glDeleteRenderbuffers( 1, &m_stencil );
-        }
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glDeleteFramebuffersEXT( 1, &m_frame );
-        if ( m_flags & color ) {
-            glDeleteTextures( 1, &m_texture );
-        }
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glDeleteRenderbuffersEXT( 1, &m_depth );
-        }
-        if ( m_flags & stencil ) {
-            glDeleteRenderbuffersEXT( 1, &m_stencil );
-        }
-    }
-    if ( generatedBuffers ) {
-        glDeleteBuffers( 2, m_buffers );
-    }
-    delete m_shader;
+    glDeleteTextures(1, &image);
+    glDeleteFramebuffers(1,&fbuffer);
+    glDeleteBuffers(2,buffers);
+    delete shader;
 }
 
-void slop::Framebuffer::bind() {
-    if ( GLEW_VERSION_3_0 ) {
-        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
-    }
+void slop::Framebuffer::resize( int w, int h ) {
+    // Regenerate the image
+    glDeleteTextures(1, &image);
+    glBindTexture(GL_TEXTURE_2D, image);
+    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);
+
+    // Re-bind it to the framebuffer
+    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
+    glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, image, 0);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-void slop::Framebuffer::unbind() {
-    if ( GLEW_VERSION_3_0 ) {
-        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
-    }
+void slop::Framebuffer::bind() {
+    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
 }
 
-void slop::Framebuffer::createFromTexture( unsigned int texture, std::string shader ) {
-    // First make sure we're empty.
-    if ( GLEW_VERSION_3_0 ) {
-        glDeleteFramebuffers( 1, &m_frame );
-        if ( m_flags & color ) {
-            glDeleteTextures( 1, &m_texture );
-        }
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glDeleteRenderbuffers( 1, &m_depth );
-        }
-        if ( m_flags & stencil ) {
-            glDeleteRenderbuffers( 1, &m_stencil );
-        }
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glDeleteFramebuffersEXT( 1, &m_frame );
-        if ( m_flags & color ) {
-            glDeleteTextures( 1, &m_texture );
-        }
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glDeleteRenderbuffersEXT( 1, &m_depth );
-        }
-        if ( m_flags & stencil ) {
-            glDeleteRenderbuffersEXT( 1, &m_stencil );
-        }
-    }
-    delete m_shader;
-    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
-    // Set flags to 0 so we don't delete the texture on deconstruction.
-    m_flags = 0;
-    m_texture = texture;
-    if ( GLEW_VERSION_3_0 ) {
-        glGenFramebuffers( 1, &m_frame );
-        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
-        glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 );
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glGenFramebuffersEXT( 1, &m_frame );
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
-        glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 );
-    }
-    check();
+void slop::Framebuffer::unbind() {
     glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 }
 
-void slop::Framebuffer::create( unsigned int width, unsigned int height, unsigned char flags, std::string shader ) {
-    if ( m_width == width && m_height == height && m_flags == flags ) {
-        return;
-    }
-    delete m_shader;
-    m_shader = new slop::Shader( shader, resource->getRealPath( shader + ".vert" ), resource->getRealPath( shader + ".frag" ) );
-    if ( GLEW_VERSION_3_0 ) {
-        glDeleteFramebuffers( 1, &m_frame );
-        if ( m_flags & color ) {
-            glDeleteTextures( 1, &m_texture );
-        }
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glDeleteRenderbuffers( 1, &m_depth );
-        }
-        if ( m_flags & stencil ) {
-            glDeleteRenderbuffers( 1, &m_stencil );
-        }
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glDeleteFramebuffersEXT( 1, &m_frame );
-        if ( m_flags & color ) {
-            glDeleteTextures( 1, &m_texture );
-        }
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glDeleteRenderbuffersEXT( 1, &m_depth );
-        }
-        if ( m_flags & stencil ) {
-            glDeleteRenderbuffersEXT( 1, &m_stencil );
-        }
-    }
-    m_flags = flags;
-    m_width = width;
-    m_height = height;
-    if ( GLEW_VERSION_3_0 ) {
-        glGenFramebuffers( 1, &m_frame );
-        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
-
-        if ( m_flags & color ) {
-            glGenTextures( 1, &m_texture );
-            glBindTexture( GL_TEXTURE_2D, m_texture );
-            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
-            glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0 );
-        }
-
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glGenRenderbuffers( 1, &m_depth );
-            glBindRenderbuffer( GL_RENDERBUFFER, m_depth );
-            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_width, m_height );
-            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depth );
-        }
-
-        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
-        if ( m_flags & stencil ) {
-            glGenRenderbuffers( 1, &m_stencil );
-            glBindRenderbuffer( GL_RENDERBUFFER, m_stencil );
-            glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_width, m_height );
-            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
-            glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencil );
-        }
-        //Make sure we unbind when we're done.
-        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glGenFramebuffersEXT( 1, &m_frame );
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
-
-        if ( m_flags & color ) {
-            glGenTextures( 1, &m_texture );
-            glBindTexture( GL_TEXTURE_2D, m_texture );
-            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
-           glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
-            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
-            glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0 );
-        }
-
-        if ( m_flags & depth && !( m_flags & stencil ) ) {
-            glGenRenderbuffersEXT( 1, &m_depth );
-            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_depth );
-            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, m_width, m_height );
-            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depth );
-        }
-
-        //This is the only way I could get a proper stencil buffer, by making a GL_DEPTH_STENCIL attachment to both points.
-        if ( m_flags & stencil ) {
-            glGenRenderbuffersEXT( 1, &m_stencil );
-            glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_stencil );
-            glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, m_width, m_height );
-            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
-            glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_stencil );
-        }
-        //Make sure we unbind when we're done.
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
-    }
-}
-
-void slop::Framebuffer::check()
-{
-    if ( GLEW_VERSION_3_0 ) {
-        glBindFramebuffer( GL_FRAMEBUFFER, m_frame );
-        unsigned int err = glCheckFramebufferStatus( GL_FRAMEBUFFER );
-        if ( err == GL_FRAMEBUFFER_COMPLETE ) {
-            return;
-        }
-        fprintf( stderr, "Error: Framebuffer failed a check procedure for reason: " );
-        switch ( err ) {
-            case GL_FRAMEBUFFER_UNDEFINED: {
-                fprintf( stderr, "GL_FRAMEBUFFER_UNDEFINED\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_UNSUPPORTED: {
-                fprintf( stderr, "GL_FRAMEBUFFER_UNSUPPORTED\n" );
-                break;
-            }
-            default: {
-                fprintf( stderr, "UNKNOWN\n" );
-                break;
-            }
-        }
-        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frame );
-        unsigned int err = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
-        if ( err == GL_FRAMEBUFFER_COMPLETE_EXT ) {
-            return;
-        }
-        switch ( err ) {
-            /* Apparently doesn't exist as an extension.
-               case GL_FRAMEBUFFER_UNDEFINED_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_UNDEFINED_EXT\n" );
-                break;
-            }*/
-            case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT\n" );
-                break;
-            }
-            case GL_FRAMEBUFFER_UNSUPPORTED_EXT: {
-                fprintf( stderr, "GL_FRAMEBUFFER_UNSUPPORTED_EXT\n" );
-                break;
-            }
-            default: {
-                fprintf( stderr, "Unknown framebuffer error!\n" );
-                break;
-            }
-        }
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
-    }
-}
-
-void slop::Framebuffer::generateBuffers() {
-    if ( generatedBuffers ) {
-        return;
-    }
-    std::vector<glm::vec2> verts;
-    std::vector<glm::vec2> uvs;
-    verts.push_back( glm::vec2( -1, -1 ) );
-    verts.push_back( glm::vec2( 1, -1 ) );
-    verts.push_back( glm::vec2( 1, 1 ) );
-    verts.push_back( glm::vec2( -1, 1 ) );
-    uvs.push_back( glm::vec2( 0, 0 ) );
-    uvs.push_back( glm::vec2( 1, 0 ) );
-    uvs.push_back( glm::vec2( 1, 1 ) );
-    uvs.push_back( glm::vec2( 0, 1 ) );
-
-    glGenBuffers( 2, m_buffers );
-    glBindBuffer( GL_ARRAY_BUFFER, m_buffers[0] );
-    glBufferData( GL_ARRAY_BUFFER, verts.size() * sizeof( glm::vec2 ), &verts[0], GL_STATIC_DRAW );
-    glBindBuffer( GL_ARRAY_BUFFER, m_buffers[1] );
-    glBufferData( GL_ARRAY_BUFFER, uvs.size() * sizeof( glm::vec2 ), &uvs[0], GL_STATIC_DRAW );
-    generatedBuffers = true;
-}
-
-void slop::Framebuffer::clear( glm::vec4 clearcolor, unsigned char flags ) {
-    // FIXME: This should auto-bind and unbind, but I was too lazy to find out how to push and pop gl states.
-    unsigned int colorbit = 0;
-    if ( flags & color ) {
-        colorbit = colorbit | GL_COLOR_BUFFER_BIT;
-    }
-    if ( m_flags & depth && flags & depth ) {
-        colorbit = colorbit | GL_DEPTH_BUFFER_BIT;
-    }
-    if ( m_flags & stencil && flags & stencil) {
-        colorbit = colorbit | GL_STENCIL_BUFFER_BIT;
-    }
-    glClearColor( clearcolor.x, clearcolor.y, clearcolor.z, clearcolor.w );
-    glClear( colorbit );
-}
-
-void slop::Framebuffer::draw( float time, unsigned int desktop ) {
-    if ( !( m_flags & color ) ) {
-        return;
-    }
-
-    generateBuffers();
-
-    //slop::Shader* shader = shaders->get( "simple" );
-    m_shader->bind();
-    m_shader->setParameter( "texture", 0 );
-    m_shader->setParameter( "desktop", 1 );
-    m_shader->setParameter( "time", time );
-    m_shader->setParameter( "desktopWidth", (int)xengine->getWidth() );
-    m_shader->setParameter( "desktopHeight", (int)xengine->getHeight() );
-    m_shader->setAttribute( "vertex", m_buffers[0], 2 );
-    m_shader->setAttribute( "uv", m_buffers[1], 2 );
-
-    glActiveTexture(GL_TEXTURE0 + 0);
-    glBindTexture( GL_TEXTURE_2D, m_texture );
-    glActiveTexture(GL_TEXTURE0 + 1);
-    glBindTexture( GL_TEXTURE_2D, desktop );
-    glActiveTexture(GL_TEXTURE0 + 0);
+void slop::Framebuffer::draw(){
+    shader->bind();
+    shader->setParameter( "texture", 0 );
+    shader->setAttribute( "position", buffers[0], 2 );
+    shader->setAttribute( "uv", buffers[1], 2 );
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture( GL_TEXTURE_2D, image );
     glEnable( GL_TEXTURE_2D );
-    glDrawArrays( GL_QUADS, 0, 4 );
+    glDrawArrays( GL_TRIANGLES, 0, vertCount );
     glDisable( GL_TEXTURE_2D );
-
-    m_shader->unbind();
+    shader->unbind();
 }

src/framebuffer.hpp

@@ -1,51 +1,52 @@
-#ifndef IS_FRAMEBUFFER_H_
-#define IS_FRAMEBUFFER_H_
+/* framebuffer.hpp: Creates and manages an off-screen framebuffer. Uses supplied shader to draw it to the screen.
+ *
+ * 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/>.
+ */
 
-#include <GL/glew.h>
-#include <GL/gl.h>
+#ifndef N_FRAMEBUFFER_H_
+#define N_FRAMEBUFFER_H_
+
+#include "gl_core_3_3.h"
 #include <glm/glm.hpp>
-#include <stdexcept>
+#include <GL/gl.h>
+#include <vector>
 
-#include "x.hpp"
 #include "shader.hpp"
-#include "resource.hpp"
 
 namespace slop {
 
-class Framebuffer
-{
+class Framebuffer {
+private:
+    unsigned int fbuffer;
+    unsigned int image;
+    unsigned int buffers[2];
+    unsigned int vertCount;
+    Shader* shader;
 public:
-    enum buffers
-    {
-        color = 0x01,
-        depth = 0x02,
-        stencil = 0x04
-    };
-    Framebuffer();
-    Framebuffer( unsigned int width, unsigned int height, unsigned char flags = color, std::string shader = "simple" );
+    Framebuffer( int w, int h );
     ~Framebuffer();
-    void create( unsigned int width, unsigned int height, unsigned char flags = color, std::string shader = "simple" );
-    void createFromTexture( unsigned int texture, std::string shader = "simple" );
-    void setShader( std::string shader = "simple" );
-    void clear( glm::vec4 color = glm::vec4( 0, 0, 0, 1 ), unsigned char flags = color | depth | stencil );
+    void setShader( std::string );
+    void draw();
+    void resize( int w, int h );
     void bind();
     void unbind();
-    void draw( float time, unsigned int image );
-    unsigned int m_texture;
-    unsigned int m_depth;
-    unsigned int m_stencil;
-    slop::Shader* m_shader;
-private:
-    unsigned int m_width;
-    unsigned int m_height;
-    void check();
-    void generateBuffers();
-    unsigned char m_flags;
-    bool generatedBuffers;
-    unsigned int m_frame;
-    unsigned int m_buffers[2];
 };
 
 }
 
-#endif //IS_FRAMEBUFFER_H_
+#endif

src/glrectangle.cpp

@@ -0,0 +1,246 @@
+#include "glrectangle.hpp"
+
+slop::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 slop::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 slop::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();
+}
+
+slop::GLRectangle::~GLRectangle() {
+    delete shader;
+    glDeleteBuffers( 6, (GLuint*)&buffer );
+}
+
+void slop::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 slop::GLRectangle::getRect() {
+    return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
+}

src/glrectangle.hpp

@@ -0,0 +1,70 @@
+/* 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"
+
+namespace slop {
+
+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/glselectrectangle.cpp

@@ -1,683 +0,0 @@
-/* glrectangle.hpp: Handles creating hardware accelerated rectangles on the screen using X11 and OpenGL.
- *
- * 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/>.
- */
-#include "glselectrectangle.hpp"
-
-static Bool isDestroyNotify( Display* dpy, XEvent* ev, XPointer win ) {
-    return ev->type == DestroyNotify && ev->xdestroywindow.window == *((Window*)win);
-}
-
-slop::GLSelectRectangle::~GLSelectRectangle() {
-    if ( m_window == None ) {
-        return;
-    }
-    xengine->freeCRTCS( m_monitors );
-    delete m_framebuffer;
-    // Try to erase the window before destroying it.
-    glClearColor( 0, 0, 0, 0 );
-    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
-    glXSwapBuffers( xengine->m_display, m_glxWindow );
-    // Sleep for 0.1 seconds in hope that the rectangle was erased.
-    usleep( 10000 );
-    XDestroyWindow( xengine->m_display, m_window );
-    XEvent event;
-    // Block until the window is actually completely removed.
-    XIfEvent( xengine->m_display, &event, &isDestroyNotify, (XPointer)&m_window );
-    // Sleep for 0.1 seconds in hope that the screen actually cleared the window.
-    usleep( 10000 );
-}
-
-void slop::GLSelectRectangle::constrainWithinMonitor( int* x, int* y, int* w, int* h ) {
-    m_offsetx = 0;
-    m_offsety = 0;
-    m_offsetw = 0;
-    m_offseth = 0;
-    for ( unsigned int i=0;i<m_monitors.size();i++ ) {
-        XRRCrtcInfo* monitor = m_monitors[ i ];
-        if ( !((int)xengine->m_mousex >= (int)monitor->x && (int)xengine->m_mousey >= (int)monitor->y &&
-               (int)xengine->m_mousex <= (int)(monitor->x+monitor->width) && (int)xengine->m_mousey <= (int)(monitor->y+monitor->height) ) ) {
-            continue;
-        }
-        if ( (int)*x < (int)monitor->x ) {
-            m_offsetx = monitor->x-*x;
-            *w += *x-monitor->x;
-            *x = monitor->x;
-        }
-        if ( (int)(*x+*w) >= (int)(monitor->x+monitor->width) ) {
-            m_offsetw = (monitor->width-1-(*x-monitor->x+*w));
-            *w = monitor->width-1-(*x-monitor->x);
-        }
-        if ( (int)*y < (int)monitor->y ) {
-            m_offsety = monitor->y-*y;
-            *h += *y-monitor->y;
-            *y = monitor->y;
-        }
-        if ( (int)(*y+*h) >= (int)(monitor->y+monitor->height) ) {
-            m_offseth = (monitor->height-1-(*y-monitor->y+*h));
-            *h = monitor->height-1-(*y-monitor->y);
-        }
-        break;
-    }
-    m_offsetx *= m_glassSize;
-    m_offsety *= m_glassSize;
-    m_offsetw *= m_glassSize;
-    m_offseth *= m_glassSize;
-}
-
-void slop::GLSelectRectangle::setShader( std::string shader ) {
-    m_shader = shader;
-    m_framebuffer->setShader( shader );
-}
-
-void slop::GLSelectRectangle::setMagnifySettings( bool on, float magstrength, unsigned int pixels ) {
-    m_glassSize = magstrength;
-    m_glassPixels = pixels;
-    m_glassEnabled = on;
-    m_glassx = xengine->m_mousex;
-    m_glassy = xengine->m_mousey;
-    m_realglassx = xengine->m_mousex;
-    m_realglassy = xengine->m_mousey;
-}
-
-void slop::GLSelectRectangle::pushOut( int* x, int* y, int w, int h, int rx, int ry, int rw, int rh ) {
-    // AABB to test for collision
-    if (!(
-          *x < rx + rw &&
-          *x + w > rx &&
-          *y < ry + rh &&
-          h + *y > ry
-       )) {
-        // No collision, so we do nothing.
-        return;
-    }
-    // Otherwise we find an optimal angle to push ourselves out at.
-    int centerx = rx+rw/2;
-    int centery = ry+rh/2;
-    float ang = -atan2( (float)(*y+(float)h/2.f)-(float)centery, (float)(*x+(float)w/2.f)-(float)centerx );
-    float pi = 3.1415926535897;
-    float upright = pi/2 - atan( (2.f*float(rx+rw)-2.f*(float)centerx)/(float)rh );
-    float upleft = pi/2 - atan( (2.f*(float)rx-2.f*(float)centerx)/(float)rh );
-    float downright = -upright;
-    float downleft = -upleft;
-    if ( ang >= upright && ang <= upleft ) {
-        *x = centerx + ((rh*cos(ang))/(2*sin(ang))) - w/2;
-        *y = centery - rh/2 - h;
-    } else if ( ang <= downright && ang >= downleft) {
-        *x = centerx - ((rh*cos(ang))/(2*sin(ang))) - w/2;
-        *y = centery + rh/2;
-    } else if ( ang < downleft || ang > upleft ) {
-        *x = centerx - rw/2 - w;
-        *y = centery + (rw*sin(ang))/(2*cos(ang)) - h/2;
-    } else {
-        *x = centerx + rw/2;
-        *y = centery - (rw*sin(ang))/(2*cos(ang)) - h/2;
-    }
-}
-
-void slop::GLSelectRectangle::pushIn( int* x, int* y, int w, int h, int rx, int ry, int rw, int rh ) {
-    if ( *x > rx && *y > ry &&
-         *x+w < rx+rw && *y+h < ry+rh ) {
-        // We're already fully contained...
-        return;
-    }
-    // Otherwise we find an optimal angle to push ourselves in at.
-    int centerx = rx+rw/2;
-    int centery = ry+rh/2;
-    float ang = -atan2( (float)(*y+(float)h/2.f)-(float)centery, (float)(*x+(float)w/2.f)-(float)centerx );
-    float pi = 3.1415926535897;
-    float upright = pi/2 - atan( (2.f*float(rx+rw)-2.f*(float)centerx)/(float)rh );
-    float upleft = pi/2 - atan( (2.f*(float)rx-2.f*(float)centerx)/(float)rh );
-    float downright = -upright;
-    float downleft = -upleft;
-    if ( ang >= upright && ang <= upleft ) {
-        *x = centerx + ((rh*cos(ang))/(2*sin(ang))) - w/2;
-        *y = centery - rh/2;
-    } else if ( ang <= downright && ang >= downleft) {
-        *x = centerx - ((rh*cos(ang))/(2*sin(ang))) - w/2;
-        *y = centery + rh/2 - h;
-    } else if ( ang < downleft || ang > upleft ) {
-        *x = centerx - rw/2;
-        *y = centery + (rw*sin(ang))/(2*cos(ang)) - h/2;
-    } else {
-        *x = centerx + rw/2 - w;
-        *y = centery - (rw*sin(ang))/(2*cos(ang)) - h/2;
-    }
-    if ( !(*x > rx && *y > ry &&
-         *x+w < rx+rw && *y+h < ry+rh) ) {
-        if ( *x+w > rx+rw ) {
-            *x -= w/2;
-        }
-        if ( *x < rx ) {
-            *x += w/2;
-        }
-        if ( *y+h > ry+rh ) {
-            *y -= h/2;
-        }
-        if ( *y < ry ) {
-            *y += h/2;
-        }
-    }
-}
-
-void slop::GLSelectRectangle::findOptimalGlassPosition() {
-    // Try to move the glass next to the mouse.
-    m_glassx = xengine->m_mousex+m_glassPixels/2+5-m_glassBorder;
-    m_glassy = xengine->m_mousey+m_glassPixels/2+5-m_glassBorder;
-    XRectangle view, selection, combined;
-    view.x = xengine->m_mousex-(m_glassPixels+1+m_glassBorder)/2;
-    view.y = xengine->m_mousey-(m_glassPixels+1+m_glassBorder)/2;
-    view.width = m_glassPixels+1;
-    view.height = m_glassPixels+1;
-    selection.x = m_x-m_border;
-    selection.y = m_y-m_border;
-    selection.width = m_width+m_border*2;
-    selection.height = m_height+m_border*2;
-    combined.x = std::min( selection.x, view.x );
-    combined.y = std::min( selection.y, view.y );
-    combined.width = selection.width + std::max( selection.x-view.x, (view.x+view.width)-(selection.x+selection.width) );
-    combined.height = selection.height + std::max( selection.y-view.y, (view.y+view.height)-(selection.y+selection.height) );
-    for ( unsigned int i=0;i<m_monitors.size();i++ ) {
-        XRRCrtcInfo* monitor = m_monitors[ i ];
-        // Push the glass inside the monitor the mouse is on.
-        if ( (int)xengine->m_mousex >= (int)monitor->x && (int)xengine->m_mousex <= (int)(monitor->x + monitor->width) &&
-             (int)xengine->m_mousey >= (int)monitor->y && (int)xengine->m_mousey <= (int)(monitor->y + monitor->height) ) {
-            pushIn( &m_glassx, &m_glassy, m_glassPixels*m_glassSize+m_glassBorder*2, m_glassPixels*m_glassSize+m_glassBorder*2, monitor->x, monitor->y, monitor->width, monitor->height );
-            break;
-        }
-    }
-    // Push the glass outside of the selection, but only if we are left clicking, and always keep it out of the "shot"
-    if ( xengine->getCursor() != slop::Left ) {
-        pushOut( &m_glassx, &m_glassy, m_glassPixels*m_glassSize+m_glassBorder*2, m_glassPixels*m_glassSize+m_glassBorder*2, combined.x, combined.y, combined.width, combined.height );
-    } else {
-        pushOut( &m_glassx, &m_glassy, m_glassPixels*m_glassSize+m_glassBorder*2, m_glassPixels*m_glassSize+m_glassBorder*2, view.x, view.y, view.width, view.height );
-    }
-    m_glassx += m_glassBorder;
-    m_glassy += m_glassBorder;
-}
-
-void slop::GLSelectRectangle::generateMagnifyingGlass() {
-    int x = xengine->m_mousex-m_glassPixels/2;
-    int y = xengine->m_mousey-m_glassPixels/2;
-    bool fx = xengine->m_mousex < m_x+m_width/2;
-    bool fy = xengine->m_mousey < m_y+m_height/2;
-    // Mouse behavior SUCKS
-    if ( !fx && !fy ) {
-        x += 1;
-        y += 1;
-    } else if ( fx && !fy ) {
-        y += 1;
-    } else if ( !fx && fy ) {
-        x += 1;
-    }
-    int w = m_glassPixels;
-    int h = m_glassPixels;
-    constrainWithinMonitor( &x, &y, &w, &h );
-    XImage* image = XGetImage( xengine->m_display, xengine->m_root, x, y, w, h, 0xffffffff, ZPixmap );
-    glEnable(GL_TEXTURE_2D);
-    glGenTextures(1, &m_texid);
-    glBindTexture(GL_TEXTURE_2D, m_texid);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)(&(image->data[0])));
-    XDestroyImage( image );
-    glDisable(GL_TEXTURE_2D);
-}
-
-void slop::GLSelectRectangle::setTheme( bool on, std::string name ) {
-    if ( !on || name == "none" ) {
-        return;
-    }
-    std::string root = resource->getRealPath( name );
-    std::string tl = root + "/corner_tl.png";
-    std::string bl = root + "/corner_bl.png";
-    std::string tr = root + "/corner_tr.png";
-    std::string br = root + "/corner_br.png";
-    std::string straight = root + "/straight.png";
-    // One of the textures didn't exist, so we cancel the theme.
-    if (!resource->validatePath( tl ) ||
-        !resource->validatePath( bl ) ||
-        !resource->validatePath( tr ) ||
-        !resource->validatePath( br ) ||
-        !resource->validatePath( straight ) ) {
-        fprintf( stderr, "One of the textures was missing in the theme... disabling.\n" );
-        return;
-    }
-    // Otherwise we load each one :)
-    loadImage( &(m_cornerids[0]), tl );
-    loadImage( &(m_cornerids[1]), tr );
-    loadImage( &(m_cornerids[2]), bl );
-    loadImage( &(m_cornerids[3]), br );
-    loadImage( &(m_straightid), straight );
-    glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &m_straightwidth );
-    glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &m_straightheight );
-    m_themed = on;
-}
-
-unsigned int slop::GLSelectRectangle::loadImage( unsigned int* texture, std::string path ) {
-    glActiveTexture(GL_TEXTURE0);
-    glEnable(GL_TEXTURE_2D);
-    glGenTextures( 1, texture );
-    glBindTexture( GL_TEXTURE_2D, *texture );
-    Imlib_Load_Error err;
-    Imlib_Image image = imlib_load_image_with_error_return( path.c_str(), &err );
-    if ( err != IMLIB_LOAD_ERROR_NONE ) {
-        std::string message = "Failed to load image: ";
-        message += path;
-        message += "\n\t";
-        switch( err ) {
-            default: {
-                message += "unknown error ";
-                message += (int)err;
-                message += "\n";
-                break;
-            }
-            case IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS:
-                message += "out of file descriptors\n";
-                break;
-            case IMLIB_LOAD_ERROR_OUT_OF_MEMORY:
-                message += "out of memory\n";
-                break;
-            case IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS:
-                message += "path contains too many symbolic links\n";
-                break;
-            case IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE:
-                message += "path points outside address space\n";
-                break;
-            case IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY:
-                message += "path component is not a directory\n";
-                break;
-            case IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT:
-                message += "path component is non-existant (~ isn't expanded inside quotes!)\n";
-                break;
-            case IMLIB_LOAD_ERROR_PATH_TOO_LONG:
-                message += "path is too long\n";
-                break;
-            case IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT:
-                message += "no loader for file format (unsupported format)\n";
-                break;
-            case IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE: {
-                message += "not enough disk space\n";
-                break;
-            }
-            case IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST: {
-                message += "file does not exist\n";
-                break;
-            }
-            case IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY: {
-                message += "file is a directory\n";
-                break;
-            }
-            case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE:
-            case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ: {
-                message += "permission denied\n";
-                break;
-            }
-        }
-        throw std::runtime_error( message.c_str() );
-        return *texture;
-    }
-    imlib_context_set_image( image );
-    DATA32* data = imlib_image_get_data_for_reading_only();
-    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, imlib_image_get_width(), imlib_image_get_height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)data );
-    if ( GLEW_VERSION_3_0 ) {
-        glHint( GL_GENERATE_MIPMAP_HINT, GL_NICEST );
-        glGenerateMipmap( GL_TEXTURE_2D );
-        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
-        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR );
-    } else {
-        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
-        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
-    }
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-    imlib_free_image();
-    glDisable(GL_TEXTURE_2D);
-    return *texture;
-}
-
-
-
-slop::GLSelectRectangle::GLSelectRectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a ) {
-    m_x = std::min( sx, ex );
-    m_y = std::min( sy, ey );
-    m_width = std::max( sx, ex ) - m_x;
-    m_height = std::max( sy, ey ) - m_y;
-    m_r = r;
-    m_g = g;
-    m_b = b;
-    m_a = a;
-    m_border = border;
-    m_window = None;
-    m_highlight = highlight;
-    m_glassPixels = 64;
-    m_glassx = xengine->m_mousex;
-    m_glassy = xengine->m_mousey;
-    m_realglassx = xengine->m_mousex;
-    m_realglassy = xengine->m_mousey;
-    m_glassSize = 4;
-    m_glassBorder = 1;
-    m_monitors = xengine->getCRTCS();
-    m_themed = false;
-    m_shader = "simple";
-    m_time = 0;
-
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
-
-    if ( m_highlight ) {
-        m_border = 0;
-    }
-
-    static int visdata[] = {
-        GLX_RENDER_TYPE, GLX_RGBA_BIT,
-        GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
-        GLX_DOUBLEBUFFER, True,
-        GLX_RED_SIZE, 8,
-        GLX_GREEN_SIZE, 8,
-        GLX_BLUE_SIZE, 8,
-        GLX_ALPHA_SIZE, 8,
-        GLX_DEPTH_SIZE, 16,
-        None
-    };
-
-    int numfbconfigs = 0;
-    GLXFBConfig* fbconfigs = glXChooseFBConfig( xengine->m_display,  DefaultScreen( xengine->m_display ), visdata, &numfbconfigs );
-    m_fbconfig = 0;
-    for ( int i=0; i<numfbconfigs; i++ ) {
-        m_visual = (XVisualInfo*)glXGetVisualFromFBConfig( xengine->m_display, fbconfigs[i] );
-        if ( !m_visual ) {
-            continue;
-        }
-        m_pictFormat = XRenderFindVisualFormat( xengine->m_display, m_visual->visual );
-        if ( !m_pictFormat ) {
-            continue;
-        }
-        m_fbconfig = fbconfigs[i];
-        if ( m_pictFormat->direct.alphaMask > 0 ) {
-            break;
-        }
-    }
-
-    if ( !m_fbconfig ) {
-        fprintf( stderr, "Couldn't find a matching FB config for a transparent OpenGL window!\n");
-    }
-
-    m_cmap = XCreateColormap( xengine->m_display, xengine->m_root, m_visual->visual, AllocNone );
-
-    XSetWindowAttributes attributes;
-    attributes.colormap = m_cmap;
-    attributes.background_pixmap = None;
-    attributes.border_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 | CWEventMask | CWBackPixmap | CWColormap | CWBorderPixel;
-
-
-    // Create the window
-    m_window = XCreateWindow( xengine->m_display, xengine->m_root, 0, 0, xengine->getWidth(), xengine->getHeight(),
-                              0, m_visual->depth, InputOutput,
-                              m_visual->visual, valueMask, &attributes );
-
-    if ( !m_window ) {
-        fprintf( stderr, "Couldn't create a GL window!\n");
-    }
-
-    m_glxWindow = m_window;
-
-    static char title[] = "OpenGL 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 = xengine->getWidth();
-    sizehints.height = xengine->getHeight();
-    sizehints.flags = USPosition | USSize;
-    XClassHint classhints;
-    char name[] = "slop";
-    classhints.res_name = name;
-    classhints.res_class = name;
-    XSetClassHint( xengine->m_display, m_window, &classhints );
-    XSetWMProperties( xengine->m_display, m_window, &textprop, &textprop, NULL, 0, &sizehints, startup_state, NULL );
-    XFree( startup_state );
-
-    // Make it so all input falls through
-    XRectangle rect;
-    rect.x = rect.y = rect.width = rect.height = 0;
-    XShapeCombineRectangles( xengine->m_display, m_window, ShapeInput, 0, 0, &rect, 1, ShapeSet, 0);
-
-    XMapWindow( xengine->m_display, m_window );
-
-    int dummy;
-    if ( !glXQueryExtension( xengine->m_display, &dummy, &dummy ) ) {
-        fprintf( stderr, "OpenGL is not supported!\n" );
-    }
-    m_renderContext = glXCreateNewContext( xengine->m_display, m_fbconfig, GLX_RGBA_TYPE, 0, True );
-    if ( !m_renderContext ) {
-        fprintf( stderr, "Failed to create a GL context.\n" );
-    }
-    if ( !glXMakeContextCurrent( xengine->m_display, m_glxWindow, m_glxWindow, m_renderContext ) ) {
-        fprintf( stderr, "Failed to attach GL context to window!\n" );
-    }
-    GLenum err = glewInit();
-    if ( GLEW_OK != err ) {
-        /* Problem: glewInit failed, something is seriously wrong. */
-        fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
-    }
-
-    // Get an image of the entire desktop for use in shaders.
-    XImage* image = XGetImage( xengine->m_display, xengine->m_root, 0, 0, xengine->getWidth(), xengine->getHeight(), 0xffffffff, ZPixmap );
-    glEnable(GL_TEXTURE_2D);
-    glGenTextures(1, &m_desktop);
-    glBindTexture(GL_TEXTURE_2D, m_desktop);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, xengine->getWidth(), xengine->getHeight(), 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)(&(image->data[0])));
-    XDestroyImage( image );
-
-    glDisable(GL_TEXTURE_2D);
-    m_framebuffer = new slop::Framebuffer( xengine->getWidth(), xengine->getHeight(), slop::Framebuffer::color, m_shader );
-    m_framebuffer->bind();
-    glEnable( GL_BLEND );
-    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
-    glClearColor( 0, 0, 0, 0 );
-    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
-    glXSwapBuffers( xengine->m_display, m_glxWindow );
-    m_framebuffer->unbind();
-}
-
-void slop::GLSelectRectangle::setGeo( int sx, int sy, int ex, int ey ) {
-    int x = std::min( sx, ex );
-    int y = std::min( sy, ey );
-    int w = std::max( sx, ex ) - x;
-    int h = std::max( sy, ey ) - y;
-
-    m_x = x;
-    m_y = y;
-    m_width = w;
-    m_height = h;
-}
-
-void slop::GLSelectRectangle::update( double dt ) {
-    m_time += dt;
-    m_framebuffer->bind();
-    glViewport( 0, 0, xengine->getWidth(), xengine->getHeight() );
-
-    glClearColor( 0, 0, 0, 0 );
-    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
-
-    glMatrixMode( GL_PROJECTION );
-    glLoadIdentity();
-    glOrtho( 0, xengine->getWidth(), xengine->getHeight(), 0, 1, -1 );
-
-    glMatrixMode( GL_MODELVIEW );
-    glLoadIdentity();
-
-    if ( !m_themed ) {
-        glColor4f( m_r, m_g, m_b, m_a );
-        if ( m_highlight ) {
-            glRecti( m_x-m_border, m_y+m_height+m_border, m_x+m_width+m_border, m_y-m_border );
-        } else {
-            glRecti( m_x-m_border, m_y, m_x+m_width+m_border, m_y-m_border );
-            glRecti( m_x-m_border, m_y+m_height, m_x+m_width+m_border, m_y+m_height+m_border );
-            glRecti( m_x-m_border, m_y, m_x, m_y+m_height );
-            glRecti( m_x+m_width, m_y, m_x+m_width+m_border, m_y+m_height );
-        }
-    } else {
-        glColor4f( m_r, m_g, m_b, m_a );
-        glEnable( GL_TEXTURE_2D );
-        if ( !m_highlight ) {
-            glBindTexture( GL_TEXTURE_2D, m_straightid );
-            float something = (float)(m_border)/(float)m_straightheight;
-            float txoffset = (((float)m_width+m_border)/(float)m_straightwidth)/something;
-            float tyoffset = (((float)m_height+m_border)/(float)m_straightwidth)/something;
-            //float ratio = ((float)m_straightwidth/(float)m_straightheight);
-            glBegin( GL_QUADS );
-            // straight top
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border/2, m_y-m_border );
-            glTexCoord2f(txoffset, 0.0); glVertex2f( m_x+m_width+m_border/2, m_y-m_border );
-            glTexCoord2f(txoffset, 1.0); glVertex2f( m_x+m_width+m_border/2, m_y );
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border/2, m_y );
-            // straight bot
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border/2, m_y+m_height );
-            glTexCoord2f(txoffset, 0.0); glVertex2f( m_x+m_width+m_border/2, m_y+m_height );
-            glTexCoord2f(txoffset, 1.0); glVertex2f( m_x+m_width+m_border/2, m_y+m_height+m_border );
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border/2, m_y+m_height+m_border );
-            // straight left
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border, m_y-m_border/2 );
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x, m_y-m_border/2 );
-            glTexCoord2f(tyoffset, 0.0); glVertex2f( m_x, m_y+m_height+m_border/2 );
-            glTexCoord2f(tyoffset, 1.0); glVertex2f( m_x-m_border, m_y+m_height+m_border/2 );
-            // straight right
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x+m_width, m_y-m_border/2 );
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y-m_border/2 );
-            glTexCoord2f(tyoffset, 0.0); glVertex2f( m_x+m_width+m_border, m_y+m_height+m_border/2 );
-            glTexCoord2f(tyoffset, 1.0); glVertex2f( m_x+m_width, m_y+m_height+m_border/2 );
-            glEnd();
-            // top left corner
-            glBindTexture( GL_TEXTURE_2D, m_cornerids[0] );
-            glBegin( GL_QUADS );
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y-m_border );
-            glTexCoord2f(1.0, 0.0); glVertex2f( m_x, m_y-m_border );
-            glTexCoord2f(1.0, 1.0); glVertex2f( m_x, m_y );
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border, m_y );
-            glEnd();
-            // top right
-            glBindTexture( GL_TEXTURE_2D, m_cornerids[1] );
-            glBegin( GL_QUADS );
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width, m_y-m_border );
-            glTexCoord2f(1.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y-m_border );
-            glTexCoord2f(1.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y );
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x+m_width, m_y );
-            glEnd();
-            // bottom left
-            glBindTexture( GL_TEXTURE_2D, m_cornerids[2] );
-            glBegin( GL_QUADS );
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y+m_height );
-            glTexCoord2f(1.0, 0.0); glVertex2f( m_x, m_y+m_height );
-            glTexCoord2f(1.0, 1.0); glVertex2f( m_x, m_y+m_height+m_border );
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border, m_y+m_height+m_border );
-            glEnd();
-            // bottom right
-            glBindTexture( GL_TEXTURE_2D, m_cornerids[2] );
-            glBegin( GL_QUADS );
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width, m_y+m_height );
-            glTexCoord2f(1.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y+m_height );
-            glTexCoord2f(1.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y+m_height+m_border );
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x+m_width, m_y+m_height+m_border );
-            glEnd();
-        } else {
-            glBindTexture( GL_TEXTURE_2D, m_cornerids[0] );
-            glBegin( GL_QUADS );
-            // straight top
-            glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border, m_y+m_border+m_height );
-            glTexCoord2f(1.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y+m_border+m_height );
-            glTexCoord2f(1.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y-m_border );
-            glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y-m_border );
-            glEnd();
-        }
-        glDisable( GL_TEXTURE_2D );
-    }
-
-    m_framebuffer->unbind();
-
-    glClearColor( 0, 0, 0, 0 );
-    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
-
-    m_framebuffer->draw( (float) m_time, m_desktop );
-
-    if ( m_glassEnabled ) {
-        generateMagnifyingGlass();
-        findOptimalGlassPosition();
-
-        // Takes .1 second to reach the real position. Used for easing.
-        m_realglassx -= float(m_realglassx - (float)m_glassx) * dt * 10;
-        m_realglassy -= float(m_realglassy - (float)m_glassy) * dt * 10;
-
-        // Black outline...
-
-        glColor4f( 0, 0, 0, 1 );
-        glBegin( GL_QUADS );
-        glTexCoord2f(0.0, 1.0); glVertex3f( m_realglassx+m_offsetx-m_glassBorder,                               m_realglassy+(m_glassSize*m_glassPixels)+m_offseth+m_glassBorder, 0.0);
-        glTexCoord2f(1.0, 1.0); glVertex3f( m_realglassx+(m_glassSize*m_glassPixels)+m_offsetw+m_glassBorder,   m_realglassy+(m_glassSize*m_glassPixels)+m_offseth+1, 0.0);
-        glTexCoord2f(1.0, 0.0); glVertex3f( m_realglassx+(m_glassSize*m_glassPixels)+m_offsetw+m_glassBorder,   m_realglassy+m_offsety-m_glassBorder, 0.0);
-        glTexCoord2f(0.0, 0.0); glVertex3f( m_realglassx+m_offsetx-m_glassBorder,                               m_realglassy+m_offsety-m_glassBorder, 0.0);
-        glEnd();
-
-        glEnable( GL_TEXTURE_2D );
-        glBindTexture( GL_TEXTURE_2D, m_texid );
-        glColor4f( 1, 1, 1, 1 );
-        glBegin( GL_QUADS );
-        glTexCoord2f(0.0, 1.0); glVertex3f( m_realglassx+m_offsetx,                             m_realglassy+(m_glassSize*m_glassPixels)+m_offseth, 0.0);
-        glTexCoord2f(1.0, 1.0); glVertex3f( m_realglassx+(m_glassSize*m_glassPixels)+m_offsetw, m_realglassy+(m_glassSize*m_glassPixels)+m_offseth, 0.0);
-        glTexCoord2f(1.0, 0.0); glVertex3f( m_realglassx+(m_glassSize*m_glassPixels)+m_offsetw, m_realglassy+m_offsety, 0.0);
-        glTexCoord2f(0.0, 0.0); glVertex3f( m_realglassx+m_offsetx,                             m_realglassy+m_offsety, 0.0);
-        glEnd();
-        glDisable( GL_TEXTURE_2D );
-
-        glLogicOp(GL_INVERT);
-        glEnable(GL_COLOR_LOGIC_OP);
-        glLineWidth( 2 );
-        glColor4f( 0, 0, 0, 1 );
-        glBegin( GL_LINES );
-        float cx = m_realglassx+(m_glassSize*m_glassPixels)/2;
-        float cy = m_realglassy+(m_glassSize*m_glassPixels)/2;
-        glVertex3f( cx-5, cy, 0 );
-        glVertex3f( cx+5, cy, 0 );
-        glVertex3f( cx, cy-5, 0 );
-        glVertex3f( cx, cy+5, 0 );
-        glEnd();
-        glLogicOp(GL_NOOP);
-        glDisable(GL_COLOR_LOGIC_OP);
-    }
-
-    glXSwapBuffers( xengine->m_display, m_glxWindow );
-}

src/glselectrectangle.hpp

@@ -1,102 +0,0 @@
-/* glselectrectangle.hpp: Handles creating hardware accelerated rectangles on the screen using X11 and OpenGL.
- *
- * 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 IS_GL_SELECT_RECTANGLE_H_
-#define IS_GL_SELECT_RECTANGLE_H_
-
-#include "x.hpp"
-#include "selectrectangle.hpp"
-#include "resource.hpp"
-#include "framebuffer.hpp"
-
-#include <unistd.h>
-
-#include <Imlib2.h>
-#include <GL/gl.h>
-#include <GL/glx.h>
-#include <GL/glew.h>
-#include <GL/glxext.h>
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#include <X11/extensions/Xrender.h>
-#include <X11/Xutil.h>
-
-#include <cstdlib>
-#include <cmath>
-#include <cstdio>
-#include <string>
-#include <vector>
-
-namespace slop {
-
-class GLSelectRectangle: public SelectRectangle {
-public:
-                        GLSelectRectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a );
-                        ~GLSelectRectangle();
-    void                setGeo( int x, int y, int w, int h );
-    void                update( double dt );
-    void                generateMagnifyingGlass();
-    void                setMagnifySettings( bool on, float magstrength, unsigned int pixels );
-    void                pushIn( int* x, int* y, int w, int h, int rx, int ry, int rw, int rh );
-    void                pushOut( int* x, int* y, int w, int h, int rx, int ry, int rw, int rh );
-    void                findOptimalGlassPosition();
-    void                constrainWithinMonitor( int* x, int* y, int* w, int* h );
-    void                setTheme( bool on, std::string name );
-    void                setShader( std::string name );
-    float               m_r;
-    float               m_g;
-    float               m_b;
-    float               m_a;
-    GLXFBConfig         m_fbconfig;
-    XVisualInfo*        m_visual;
-    XRenderPictFormat*  m_pictFormat;
-    GLXContext          m_renderContext;
-    GLXWindow           m_glxWindow;
-    Colormap            m_cmap;
-    bool                m_themed;
-    unsigned int        m_texid;
-    unsigned int        m_cornerids[4];
-    unsigned int        m_straightid;
-    int                 m_straightwidth;
-    int                 m_straightheight;
-    int                 m_offsetx;
-    int                 m_offsety;
-    int                 m_offsetw;
-    int                 m_offseth;
-    unsigned int        m_desktop;
-    unsigned int        m_glassPixels;
-    float               m_glassSize;
-    int                 m_glassBorder;
-    float               m_realglassx;
-    float               m_realglassy;
-    int                 m_glassx;
-    int                 m_glassy;
-    bool                m_glassEnabled;
-    double              m_time;
-    std::string         m_shader;
-    std::vector<XRRCrtcInfo*> m_monitors;
-    slop::Framebuffer*  m_framebuffer;
-private:
-    unsigned int loadImage( unsigned int* texture, std::string path );
-};
-
-}
-
-#endif // IS_GL_SELECT_RECTANGLE_H_

src/keyboard.cpp

@@ -0,0 +1,53 @@
+#include "keyboard.hpp"
+
+bool slop::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;
+    }
+}
+
+bool slop::Keyboard::anyKeyDown() {
+    return keyDown;
+}
+
+void slop::Keyboard::update() {
+    char keys[32];
+    XQueryKeymap( x11->display, keys );
+    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];
+    }
+}
+
+slop::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" );
+    }
+    XQueryKeymap( x11->display, deltaState );
+    keyDown = false;
+}
+
+slop::Keyboard::~Keyboard() {
+    XUngrabKeyboard( x11->display, CurrentTime );
+}

src/selectrectangle.cpp → src/keyboard.hpp

@@ -1,4 +1,4 @@
-/* selectrectangle.cpp: Handles creating rectangles on the screen.
+/* keyboard.hpp: Interfaces with x11 to grab key press information.
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -17,20 +17,29 @@
  * You should have received a copy of the GNU General Public License
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "selectrectangle.hpp"
 
-bool slop::isSelectRectangleSupported() {
-    int event_base;
-    int error_base;
-    return XShapeQueryExtension( xengine->m_display, &event_base, &error_base );
-}
+#ifndef N_KEYBOARD_H_
+#define N_KEYBOARD_H_
 
-slop::SelectRectangle::~SelectRectangle() {
-}
+#include "x.hpp"
 
-void slop::SelectRectangle::update( double dt ) {
-}
+namespace slop {
+
+class Keyboard {
+private:
+    char deltaState[32];
+    X11* x11;
+    bool keyDown;
+public:
+    Keyboard( X11* x11 );
+    ~Keyboard();
+    void update();
+    bool getKey( KeySym key );
+    bool anyKeyDown();
+};
+
+extern Keyboard* keyboard;
 
-void slop::SelectRectangle::setGeo( int sx, int sy, int ex, int ey ) {
-    fprintf( stderr, "Tried to use a class function that's meant to be overridden!\n");
 }
+
+#endif // N_KEYBOARD_H_

src/main.cpp

@@ -1,4 +1,4 @@
-/* main.cpp
+/* main.cpp: parses options, runs slop, prints results.
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -17,554 +17,194 @@
  * You should have received a copy of the GNU General Public License
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <unistd.h>
-#include <time.h>
-#include <cstdio>
-#include <sstream>
-#include <stdexcept>
-
-#ifdef __MACH__
-#include <mach/clock.h>
-#include <mach/mach.h>
-#endif
 
-#include "x.hpp"
-#include "selectrectangle.hpp"
-#ifdef OPENGL_ENABLED
-#include "glselectrectangle.hpp"
-#endif //OPENGL_ENABLED
-#include "xselectrectangle.hpp"
-#include "cmdline.h"
+#include <iostream>
+#include <sstream>
+#include "slop.hpp"
+#include "options.hpp"
 
-// Work around lack of clock_gettime in OSX
-// https://gist.github.com/jbenet/1087739
-void current_utc_time(struct timespec *ts) {
-    #ifdef __MACH__
-        // OS X does not have clock_gettime, use clock_get_time
-        clock_serv_t cclock;
-        mach_timespec_t mts;
-        host_get_clock_service( mach_host_self(), CALENDAR_CLOCK, &cclock );
-        clock_get_time( cclock, &mts );
-        mach_port_deallocate( mach_task_self(), cclock );
-        ts->tv_sec = mts.tv_sec;
-        ts->tv_nsec = mts.tv_nsec;
-    #else
-        clock_gettime( CLOCK_REALTIME, ts );
-    #endif
-}
+using namespace slop;
 
-int printSelection( std::string format, bool cancelled, int x, int y, int w, int h, int window ) {
-    size_t pos = 0;
-    while ( ( pos = format.find( "%", pos ) ) != std::string::npos ) {
-        if ( pos + 1 > format.size() ) {
-            fprintf( stderr, "Format error: %% found at the end of format string.\n" );
-            return EXIT_FAILURE;
-        }
-        std::stringstream foo;
-        switch( format[ pos + 1 ] ) {
-            case '%':
-                format.replace( pos, 2, "%" );
-                pos += 1;
-                break;
-            case 'x':
-            case 'X':
-                foo << x;
-                format.replace( pos, 2, foo.str() );
-                break;
-            case 'y':
-            case 'Y':
-                foo << y;
-                format.replace( pos, 2, foo.str() );
-                break;
-            case 'w':
-            case 'W':
-                foo << w;
-                format.replace( pos, 2, foo.str() );
-                break;
-            case 'h':
-            case 'H':
-                foo << h;
-                format.replace( pos, 2, foo.str() );
-                break;
-            case 'g':
-            case 'G':
-                foo << w << 'x' << h << '+' << x << '+' << y;
-                format.replace( pos, 2, foo.str() );
-                break;
-            case 'i':
-            case 'I':
-                foo << window;
-                format.replace( pos, 2, foo.str() );
-                break;
-            case 'c':
-            case 'C':
-                format.replace( pos, 2, cancelled ? "true" : "false" );
-                break;
-            default:
-                fprintf( stderr, "Format error: %%%c is an unknown replacement identifier.\n", format[ pos + 1 ] );
-                fprintf( stderr, "Valid replacements: %%x, %%y, %%w, %%h, %%i, %%c, %%.\n" );
-                return EXIT_FAILURE;
-                break;
-        }
-    }
-    pos = 0;
-    while ( ( pos = format.find( "\\", pos ) ) != std::string::npos ) {
-        if ( pos + 1 > format.size() ) {
-            break;
-        }
-        if ( format[ pos + 1 ] == 'n' ) {
-            format.replace( pos, 2, "\n" );
-        }
-        pos = pos + 1;
-    }
-    printf( "%s", format.c_str() );
-    return EXIT_SUCCESS;
+SlopOptions* getOptions( Options& options ) {
+    SlopOptions* foo = new SlopOptions();
+    options.getFloat("bordersize", 'b', foo->borderSize);
+    options.getFloat("padding", 'p', foo->padding);
+    options.getFloat("tolerance", 't', foo->tolerance);
+    glm::vec4 color = glm::vec4( foo->r, foo->g, foo->b, foo->a );
+    options.getColor("color", 'c', color);
+    options.getBool("nokeyboard", 'k', foo->nokeyboard);
+    options.getString( "xdisplay", 'x', foo->xdisplay );
+    options.getString( "shader", 's', foo->shader );
+    foo->r = color.r;
+    foo->g = color.g;
+    foo->b = color.b;
+    foo->a = color.a;
+    options.getBool("highlight", 'l', foo->highlight);
+    options.getInt("nodecorations", 'n', foo->nodecorations);
+    return foo;
 }
 
-int parseColor( std::string arg, float* r, float* g, float* b, float* a ) {
-    std::string copy = arg;
-    int find = copy.find( "," );
-    while( find != (int)copy.npos ) {
-        copy.at( find ) = ' ';
-        find = copy.find( "," );
-    }
-
-    // Just in case we didn't include an alpha value
-    *a = 1;
-    int num = sscanf( copy.c_str(), "%f %f %f %f", r, g, b, a );
-    if ( num != 3 && num != 4 ) {
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
-}
-
-void constrain( int sx, int sy, int ex, int ey, int padding, int minimumsize, int maximumsize, int* rsx, int* rsy, int* rex, int* rey ) {
-    if ( minimumsize > maximumsize && maximumsize > 0 ) {
-        fprintf( stderr, "Error: minimumsize is greater than maximumsize.\n" );
-        exit( 1 );
-    }
-    int x = std::min( sx, ex );
-    int y = std::min( sy, ey );
-    // We add one to make sure we select the pixel under the mouse.
-    int w = std::max( sx, ex ) - x + 1;
-    int h = std::max( sy, ey ) - y + 1;
-    // Make sure we don't turn inside out...
-    if ( w + padding*2 >= 0 ) {
-        x -= padding;
-        w += padding*2;
-    }
-    if ( h + padding*2 >= 0 ) {
-        y -= padding;
-        h += padding*2;
-    }
-    if ( w < minimumsize ) {
-        int diff = minimumsize - w;
-        w = minimumsize;
-        x -= diff/2;
-    }
-    if ( h < minimumsize ) {
-        int diff = minimumsize - h;
-        h = minimumsize;
-        y -= diff/2;
-    }
-    if ( maximumsize > 0 ) {
-        if ( w > maximumsize ) {
-            int diff = w;
-            w = maximumsize;
-            x += diff/2 - maximumsize/2;
-        }
-        if ( h > maximumsize ) {
-            int diff = h;
-            h = maximumsize;
-            y += diff/2 - maximumsize/2;
+std::string formatOutput( std::string input, SlopSelection selection, bool cancelled ) {
+    std::stringstream output;
+    for( unsigned int i=0;i<input.length();i++) {
+        if ( input[i] == '%' ) {
+            if ( input.length() <= i+1 ) {
+                throw new std::invalid_argument( "Expected character after `%`, got END." );
+            }
+            switch( input[i+1] ) {
+                case 'x':
+                case 'X': output << round(selection.x); break;
+                case 'y':
+                case 'Y': output << round(selection.y); break;
+                case 'w':
+                case 'W': output << round(selection.w); break;
+                case 'c':
+                case 'C': output << cancelled; break;
+                case 'h':
+                case 'H': output << round(selection.h); break;
+                case 'g':
+                case 'G': output << round(selection.w) << "x" << round(selection.h)
+                          << "+" << round(selection.x) << "+" << round(selection.y); break;
+                case 'i':
+                case 'I': output << selection.id; break;
+                case '%': output << "%"; break;
+                default: throw new std::invalid_argument( std::string()+"Expected x, y, w, h, g, i, c, or % after % in format. Got `" + input[i+1] + "`." );
+             }
+            i++;
+            continue;
         }
+        output << input[i];
     }
-    // Center around mouse if we have a fixed size.
-    if ( maximumsize == minimumsize && w == maximumsize && h == maximumsize ) {
-        x = ex - maximumsize/2;
-        y = ey - maximumsize/2;
-    }
-    *rsx = x;
-    *rsy = y;
-    *rex = x + w;
-    *rey = y + h;
+    return output.str();
 }
 
-// Some complicated key detection to replicate key repeating
-bool keyRepeat( KeySym key, double curtime, double repeatdelay, double* time, bool* memory ) {
-    if ( xengine->keyPressed( key ) != *memory ) {
-        if ( xengine->keyPressed( key ) ) {
-            *memory = true;
-            *time = curtime;
-            return true;
-        } else {
-            *memory = false;
-        }
-    }
-    if ( xengine->keyPressed( key ) && curtime - *time > repeatdelay ) {
-        return true;
-    }
-    return false;
+void printHelp() {
+    std::cout << "slop v5.3.21\n";
+    std::cout << "\n";
+    std::cout << "Copyright (C) 2017 Dalton Nell, Slop Contributors\n";
+    std::cout << "(https://github.com/naelstrof/slop/graphs/contributors)\n";
+    std::cout << "Usage: slop [options]\n";
+    std::cout << "\n";
+    std::cout << "slop (Select Operation) is an application that queries for a selection from the\n";
+    std::cout << "user and prints the region to stdout.\n";
+    std::cout << "\n";
+    std::cout << "-h, --help                    Print help and exit\n";
+    std::cout << "-v, --version                 Print version and exit\n";
+    std::cout << "Options\n";
+    std::cout << "  -x, --xdisplay=hostname:number.screen_number\n";
+    std::cout << "                                Sets the x display.\n";
+	std::cout << "  -k, --nokeyboard              Disables the ability to cancel selections with\n";
+	std::cout << "                                  the keyboard.  (default=off)\n";
+	std::cout << "  -b, --bordersize=FLOAT        Set the selection rectangle's thickness.\n";
+	std::cout << "                                  (default=`1')\n";
+	std::cout << "  -p, --padding=FLOAT           Set the padding size of the selection. Can be\n";
+	std::cout << "                                  negative.  (default=`0')\n";
+	std::cout << "  -t, --tolerance=FLOAT         How far in pixels the mouse can move after\n";
+	std::cout << "                                  clicking and still be detected as a normal\n";
+	std::cout << "                                  click instead of a click and drag. Setting\n";
+	std::cout << "                                  this to 0 will disable window selections.\n";
+	std::cout << "                                  Alternatively setting it to 999999 would.\n";
+	std::cout << "                                  only allow for window selections.\n";
+	std::cout << "                                  (default=`2')\n";
+	std::cout << "  -c, --color=FLOAT,FLOAT,FLOAT,FLOAT\n";
+	std::cout << "                                Set the selection rectangle's color. Supports\n";
+	std::cout << "                                  RGB or RGBA values.\n";
+	std::cout << "                                  (default=`0.5,0.5,0.5,1')\n";
+	std::cout << "  -n, --nodecorations=INT       Attempt to select child windows in order to\n";
+	std::cout << "                                  avoid window decorations. Setting this to\n";
+    std::cout << "                                  1 will enable a light attempt to\n";
+    std::cout << "                                  remove decorations. Setting this to 2 will\n";
+    std::cout << "                                  enable aggressive decoration removal.\n";
+    std::cout << "                                  (default=`0')\n";
+	std::cout << "  -q, --quiet                   Disable any unnecessary cerr output. Any\n";
+	std::cout << "                                  warnings simply won't print.\n";
+	std::cout << "  -l, --highlight               Instead of outlining selections, slop\n";
+	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";
+	std::cout << "  -r, --shader=STRING           Sets the shader to load and use from\n";
+	std::cout << "                                  ~/.config/slop/\n";
+	std::cout << "  -f, --format=STRING           Set the output format string. Format specifiers\n";
+	std::cout << "                                  are %x, %y, %w, %h, %i, %g, and %c.\n";
+	std::cout << "                                  (default=`%g\n')\n";
+	std::cout << "Examples\n";
+	std::cout << "    $ # Gray, thick, transparent border for maximum visiblity.\n";
+	std::cout << "    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n";
+	std::cout << "\n";
+	std::cout << "    $ # Remove window decorations.\n";
+	std::cout << "    $ slop --nodecorations\n";
+	std::cout << "\n";
+	std::cout << "    $ # Disable window selections. Useful for selecting individual pixels.\n";
+	std::cout << "    $ slop -t 0\n";
+	std::cout << "\n";
+	std::cout << "    $ # Classic Windows XP selection.\n";
+	std::cout << "    $ slop -l -c 0.3,0.4,0.6,0.4\n";
+	std::cout << "\n";
+	std::cout << "    $ # Read slop output for use in scripts.\n";
+	std::cout << "    $ read -r X Y W H G ID < <(slop -f '%x %y %w %h %g %i')\n";
+	std::cout << "\n";
+	std::cout << "Tips\n";
+	std::cout << "    * If you don't like a selection: you can cancel it by right-clicking\n";
+	std::cout << "regardless of which options are enabled or disabled for slop.\n";
+	std::cout << "    * If slop doesn't seem to select a window accurately, the problem could be\n";
+	std::cout << "because of decorations getting in the way. Try enabling the --nodecorations\n";
+	std::cout << "flag.\n";
 }
 
 int app( int argc, char** argv ) {
-    gengetopt_args_info options;
-    int err = cmdline_parser( argc, argv, &options );
-    if ( err != EXIT_SUCCESS ) {
-        return EXIT_FAILURE;
-    }
-    int state = 0;
-    bool running = true;
-    bool opengl = options.opengl_flag;
-    slop::SelectRectangle* selection = NULL;
-    Window window = None;
-    Window windowmemory = None;
-    std::string xdisplay;
-    if ( options.xdisplay_given ) {
-        xdisplay = options.xdisplay_arg;
-    } else {
-        // If we weren't specifically given a xdisplay, we try
-        // to parse it from environment variables
-        char* display = getenv( "DISPLAY" );
-        if ( display ) {
-            xdisplay = display;
-        } else {
-            fprintf( stderr, "Warning: Failed to parse environment variable: DISPLAY. Using \":0\" instead.\n" );
-            xdisplay = ":0";
-        }
-    }
-    int padding = options.padding_arg;
-    int borderSize = options.bordersize_arg;
-    int tolerance = options.tolerance_arg;
-    float r, g, b, a;
-    err = parseColor( options.color_arg, &r, &g, &b, &a );
-    if ( err != EXIT_SUCCESS ) {
-        fprintf( stderr, "Error parsing color %s\n", options.color_arg );
-        return EXIT_FAILURE;
-    }
-    float gracetime;
-    err = sscanf( options.gracetime_arg, "%f", &gracetime );
-    if ( err != 1 ) {
-        fprintf( stderr, "Error parsing %s as a float for gracetime!\n", options.gracetime_arg );
-        return EXIT_FAILURE;
-    }
-    bool highlight = options.highlight_flag;
-    bool keyboard = !options.nokeyboard_flag;
-    bool decorations = !options.nodecorations_flag;
-    bool themeon = (bool)options.theme_given;
-    std::string theme = options.theme_arg;
-#ifdef OPENGL_ENABLED
-    bool shadergiven = (bool)options.shader_given;
-#endif
-    std::string shader = options.shader_arg;
-    struct timespec start, time;
-    int xoffset = 0;
-    int yoffset = 0;
-    int cx = 0;
-    int cy = 0;
-    int xmem = 0;
-    int ymem = 0;
-    int wmem = 0;
-    int hmem = 0;
-    int minimumsize = options.min_arg;
-    int maximumsize = options.max_arg;
-    bool pressedMemory[4];
-    double pressedTime[4];
-    for ( int i=0;i<4;i++ ) {
-        pressedMemory[ i ] = false;
-        pressedTime[ i ] = 0;
-    }
-    std::string format = options.format_arg;
-    bool magenabled = options.magnify_flag;
-#ifdef OPENGL_ENABLED
-    float magstrength = options.magstrength_arg;
-    if ( options.magpixels_arg < 0 ) {
-        fprintf( stderr, "Error: --magpixels < 0, it's an unsigned integer you twat. Stop trying to underflow me!\n" );
-        return EXIT_FAILURE;
-    }
-    unsigned int magpixels = (unsigned int)options.magpixels_arg;
-#endif
-    cmdline_parser_free( &options );
-#ifndef OPENGL_ENABLED
-    if ( opengl || themeon || magenabled ) {
-        throw std::runtime_error( "Slop wasn't compiled with OpenGL support, so themes, magnifications, and shaders are disabled! Try compiling it with the CMAKE_OPENGL_SUPPORT set to true." );
-    }
-#else // OPENGL_ENABLED
-    if ( ( themeon || magenabled || shadergiven ) && !opengl ) {
-        throw std::runtime_error( "Slop needs --opengl enabled to use themes, shaders, or magnifications." );
-    }
-#endif
+    // Options just validates all of our input from argv
+    Options options( argc, argv );
+    bool quiet = false;
+    options.getBool( "quiet", 'q', quiet );
+    bool help = false;
+    if ( options.getBool( "help", 'h', help ) ) {
+        printHelp();
+        return 0;
+    }
+    if ( options.getBool( "version", 'v', help ) ) {
+        std::cout << SLOP_VERSION << "\n";
+        return 0;
+    }
+    // We then parse the options into something slop can understand.
+    SlopOptions* parsedOptions = getOptions( options );
 
-    // First we set up the x interface and grab the mouse,
-    // if we fail for either we exit immediately.
-    err = xengine->init( xdisplay.c_str() );
-    if ( err != EXIT_SUCCESS ) {
-        printSelection( format, true, 0, 0, 0, 0, None );
-        return EXIT_FAILURE;
-    }
-    if ( !slop::isSelectRectangleSupported() ) {
-        fprintf( stderr, "Error: Your X server doesn't support the XShape extension. There's nothing slop can do about this!\n" );
-        fprintf( stderr, "  Try updating X and making sure you have XExtensions installed. (/usr/lib/libXext.so, /usr/include/X11/extensions/shape.h)\n" );
-        return EXIT_FAILURE;
-    }
-    err = xengine->grabCursor( slop::Cross, gracetime );
-    if ( err != EXIT_SUCCESS ) {
-        printSelection( format, true, 0, 0, 0, 0, None );
-        return EXIT_FAILURE;
+    // We want to validate our format option if we got one, we do that by just doing a dry run
+    // on a fake selection.
+    SlopSelection selection(0,0,0,0,0);
+    std::string format;
+    bool gotFormat = options.getString("format", 'f', format);
+    if ( gotFormat ) {
+        formatOutput( format, selection, false );
     }
-    if ( keyboard ) {
-        err = xengine->grabKeyboard();
-        if ( err ) {
-            fprintf( stderr, "Warning: Failed to grab the keyboard. This is non-fatal, keyboard presses might fall through to other applications.\n" );
-        }
-    }
-    current_utc_time( &start );
-    double deltatime = 0;
-    double curtime = double( start.tv_sec*1000000000L + start.tv_nsec )/1000000000.f;
-    while ( running ) {
-        current_utc_time( &time );
-        // "ticking" the xengine makes it process all queued events.
-        xengine->tick();
-        // If the user presses any key on the keyboard, exit the application.
-        // Make sure at least gracetime has passed before allowing canceling
-        double newtime = double( time.tv_sec*1000000000L + time.tv_nsec )/1000000000.f;
-        deltatime = newtime-curtime;
-        curtime = newtime;
-        double starttime = double( start.tv_sec*1000000000L + start.tv_nsec )/1000000000.f;
-        if ( curtime - starttime > gracetime ) {
-            if ( keyRepeat( XK_Up, curtime, 0.5, &pressedTime[ 0 ], &pressedMemory[ 0 ] ) ) {
-                yoffset -= 1;
-            }
-            if ( keyRepeat( XK_Down, curtime, 0.5, &pressedTime[ 1 ], &pressedMemory[ 1 ] ) ) {
-                yoffset += 1;
-            }
-            if ( keyRepeat( XK_Left, curtime, 0.5, &pressedTime[ 2 ], &pressedMemory[ 2 ] ) ) {
-                xoffset -= 1;
-            }
-            if ( keyRepeat( XK_Right, curtime, 0.5, &pressedTime[ 3 ], &pressedMemory[ 3 ] ) ) {
-                xoffset += 1;
-            }
-            // If we pressed enter we move the state onward.
-            if ( xengine->keyPressed( XK_Return ) ) {
-                // If we're highlight windows, just select the active window.
-                if ( state == 0 ) {
-                    state = 1;
-                // If we're making a custom selection, select the custom selection.
-                } else if ( state == 2 ) {
-                    state = 3;
-                }
-            }
-            // If we press any key other than the arrow keys or enter key, we shut down!
-            if ( !( xengine->keyPressed( XK_Up ) || xengine->keyPressed( XK_Down ) || xengine->keyPressed( XK_Left ) || xengine->keyPressed( XK_Right ) ) &&
-                !( xengine->keyPressed( XK_Return ) ) &&
-                ( ( xengine->anyKeyPressed() && keyboard ) || xengine->mouseDown( 3 ) ) ) {
-                printSelection( format, true, 0, 0, 0, 0, None );
-                fprintf( stderr, "User pressed key. Canceled selection.\n" );
-                state = -1;
-                running = false;
-            }
-        }
-        // Our adorable little state manager will handle what state we're in.
-        switch ( state ) {
-            default: {
-                break;
-            }
-            case 0: {
-                // If xengine has found a window we're hovering over (or if it changed)
-                // create a rectangle around it so the user knows he/she can click on it.
-                // --but only if the user wants us to
-                if ( window != xengine->m_hoverWindow && tolerance > 0 ) {
-                    slop::WindowRectangle t;
-                    t.setGeometry( xengine->m_hoverWindow, decorations );
-                    t.applyPadding( padding );
-                    t.applyMinMaxSize( minimumsize, maximumsize );
-                    // Make sure we only apply offsets to windows that we've forcibly removed decorations on.
-                    if ( !selection ) {
-#ifdef OPENGL_ENABLED
-                        if ( opengl ) {
-                            selection = new slop::GLSelectRectangle( t.m_x, t.m_y,
-                                                                     t.m_x + t.m_width,
-                                                                     t.m_y + t.m_height,
-                                                                     borderSize,
-                                                                     highlight,
-                                                                     r, g, b, a );
-                            // Haha why is this so hard to cast?
-                            ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
-                            ((slop::GLSelectRectangle*)(selection))->setTheme( themeon, theme );
-                            ((slop::GLSelectRectangle*)(selection))->setShader( shader );
-                        } else {
-#endif // OPENGL_ENABLED
-                            selection = new slop::XSelectRectangle( t.m_x, t.m_y,
-                                                                    t.m_x + t.m_width,
-                                                                    t.m_y + t.m_height,
-                                                                    borderSize,
-                                                                    highlight,
-                                                                    r, g, b, a );
-#ifdef OPENGL_ENABLED
-                        }
-#endif // OPENGL_ENABLED
-                    } else {
-                        selection->setGeo( t.m_x, t.m_y, t.m_x + t.m_width, t.m_y + t.m_height );
-                    }
-                    //window = xengine->m_hoverWindow;
-                    // Since WindowRectangle can select different windows depending on click location...
-                    window = t.getWindow();
-                }
-                if ( selection ) {
-                    selection->update( deltatime );
-                }
-                // If the user clicked we move on to the next state.
-                if ( xengine->mouseDown( 1 ) ) {
-                    state++;
-                }
-                break;
-            }
-            case 1: {
-                // Set the mouse position of where we clicked, used so that click tolerance doesn't affect the rectangle's position.
-                cx = xengine->m_mousex;
-                cy = xengine->m_mousey;
-                // Make sure we don't have un-seen applied offsets.
-                xoffset = 0;
-                yoffset = 0;
-                // Also remember where the original selection was
-                if ( selection ) {
-                    xmem = selection->m_x;
-                    ymem = selection->m_y;
-                    wmem = selection->m_width;
-                    hmem = selection->m_height;
-                } else {
-                    xmem = cx;
-                    ymem = cy;
-                }
-                state++;
-                break;
-            }
-            case 2: {
-                // It's possible that our selection doesn't exist still, lets make sure it actually gets created here.
-                if ( !selection ) {
-                    int sx, sy, ex, ey;
-                    constrain( cx, cy, xengine->m_mousex, xengine->m_mousey, padding, minimumsize, maximumsize, &sx, &sy, &ex, &ey );
-#ifdef OPENGL_ENABLED
-                    if ( opengl ) {
-                        selection = new slop::GLSelectRectangle( sx, sy,
-                                                                 ex, ey,
-                                                                 borderSize,
-                                                                 highlight,
-                                                                 r, g, b, a );
-                        // Haha why is this so hard to cast?
-                        ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
-                        ((slop::GLSelectRectangle*)(selection))->setTheme( themeon, theme );
-                        ((slop::GLSelectRectangle*)(selection))->setShader( shader );
-                    } else {
-#endif // OPENGL_ENABLED
-                        selection = new slop::XSelectRectangle( sx, sy,
-                                                                ex, ey,
-                                                                borderSize,
-                                                                highlight,
-                                                                r, g, b, a );
-#ifdef OPENGL_ENABLED
-                    }
-#endif // OPENGL_ENABLED
-                }
-                windowmemory = window;
-                // If the user has let go of the mouse button, we'll just
-                // continue to the next state.
-                if ( !xengine->mouseDown( 1 ) ) {
-                    state++;
-                    break;
-                }
-                // Check to make sure the user actually wants to drag for a selection before moving things around.
-                int w = xengine->m_mousex - cx;
-                int h = xengine->m_mousey - cy;
-                if ( ( std::abs( w ) < tolerance && std::abs( h ) < tolerance ) ) {
-                    // We make sure the selection rectangle stays on the window we had selected
-                    selection->setGeo( xmem, ymem, xmem + wmem, ymem + hmem );
-                    selection->update( deltatime );
-                    xengine->setCursor( slop::Left );
-                    // Make sure
-                    window = windowmemory;
-                    continue;
-                }
-                // If we're not selecting a window.
-                windowmemory = window;
-                window = None;
-                // We also detect which way the user is pulling and set the mouse icon accordingly.
-                bool x = cx > xengine->m_mousex;
-                bool y = cy > xengine->m_mousey;
-                if ( ( selection->m_width <= 1 && selection->m_height <= 1 ) || ( minimumsize == maximumsize && minimumsize != 0 && maximumsize != 0 ) ) {
-                    xengine->setCursor( slop::Cross );
-                } else if ( !x && !y ) {
-                    xengine->setCursor( slop::LowerRightCorner );
-                } else if ( x && !y ) {
-                    xengine->setCursor( slop::LowerLeftCorner );
-                } else if ( !x && y ) {
-                    xengine->setCursor( slop::UpperRightCorner );
-                } else if ( x && y ) {
-                    xengine->setCursor( slop::UpperLeftCorner );
-                }
-                // Apply padding and minimum size adjustments.
-                int sx, sy, ex, ey;
-                constrain( cx, cy, xengine->m_mousex, xengine->m_mousey, padding, minimumsize, maximumsize, &sx, &sy, &ex, &ey );
-                // Set the selection rectangle's dimensions to mouse movement.
-                selection->setGeo( sx + xoffset, sy + yoffset, ex, ey );
-                selection->update( deltatime );
-                break;
-            }
-            case 3: {
-                int x, y, w, h;
-                // Exit the utility after this state runs once.
-                running = false;
-                // We pull the dimensions and positions from the selection rectangle.
-                // The selection rectangle automatically converts the positions and
-                // dimensions to absolute coordinates when we set them earilier.
-                x = selection->m_x;
-                y = selection->m_y;
-                w = selection->m_width;
-                h = selection->m_height;
-                // Delete the rectangle, which will remove it from the screen.
-                delete selection;
-                // Make sure if no window was specifically specified, that we output the root window.
-                Window temp = window;
-                if ( temp == None ) {
-                    temp = xengine->m_root;
-                }
-                // Print the selection :)
-                printSelection( format, false, x, y, w, h, temp );
-                break;
-            }
+
+    // Finally we do the real selection.
+    bool cancelled = false;
+    selection = SlopSelect(parsedOptions, &cancelled, quiet);
+    
+    // Here we're done with the parsed option data.
+    delete parsedOptions;
+    // We know if we cancelled or not
+    if ( cancelled ) {
+        if ( !quiet ) {
+            std::cerr << "Selection was cancelled by keystroke or right-click.\n";
         }
-        // This sleep is required because drawing the rectangles is a very expensive task that acts really weird with Xorg when called as fast as possible.
-        // 0.01 seconds
-        usleep( 10000 );
+        return 1;
     }
-    xengine->releaseCursor();
-    xengine->releaseKeyboard();
-    // Try to process any last-second requests.
-    //xengine->tick();
-    // Clean up global classes.
-    delete xengine;
-    // Sleep for 0.05 seconds to ensure everything was cleaned up. (Without this, slop's window often shows up in screenshots.)
-    usleep( 50000 );
-    // If we canceled the selection, return error.
-    if ( state == -1 ) {
-        return EXIT_FAILURE;
+    // If we recieved a format option, we output the specified output.
+    if ( gotFormat ) {
+        std::cout << formatOutput( format, selection, cancelled );
+        return 0;
     }
-    return EXIT_SUCCESS;
+    std::cout << formatOutput( "%g\n", selection, cancelled );
+    return 0;
 }
 
 int main( int argc, char** argv ) {
     try {
         return app( argc, argv );
-    } catch( std::bad_alloc const& exception ) {
-        fprintf( stderr, "Couldn't allocate enough memory! No space left in RAM." );
-    } catch( std::exception const& exception ) {
-        fprintf( stderr, "Unhandled Exception Thrown: %s\n", exception.what() );
-    } catch( std::string err ) {
-        fprintf( stderr, "Unhandled Exception Thrown: %s\n", err.c_str() );
-    } catch( char* err ) {
-        fprintf( stderr, "Unhandled Exception Thrown: %s\n", err );
-    } catch( ... ) {
-        fprintf( stderr, "Unknown Exception Thrown!\n" );
-    }
-    return EXIT_FAILURE;
+    } catch( std::exception* e ) {
+        std::cerr << "Slop encountered an error:\n" << e->what() << "\n";
+        return 1;
+    } // let the operating system handle any other kind of exception.
+    return 1;
 }

src/mouse.cpp

@@ -0,0 +1,125 @@
+#include "mouse.hpp"
+
+void slop::Mouse::setButton( int button, int state ) {
+    for (unsigned int i=0;i<buttons.size();i++ ) {
+        if ( buttons[i].x == button ) {
+            buttons[i].y = state;
+            return;
+        }
+    }
+    buttons.push_back(glm::ivec2(button,state));
+}
+
+int slop::Mouse::getButton( int button ) {
+    for (unsigned int i=0;i<buttons.size();i++ ) {
+        if ( buttons[i].x == button ) {
+            return buttons[i].y;
+        }
+    }
+    return 0;
+}
+
+glm::vec2 slop::Mouse::getMousePos() {
+    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 slop::Mouse::setCursor( int cursor ) {
+    if ( currentCursor == cursor ) {
+        return;
+    }
+    XFreeCursor( x11->display, xcursor );
+    xcursor = XCreateFontCursor( x11->display, cursor );
+    XChangeActivePointerGrab( x11->display,
+                              PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
+                              xcursor, CurrentTime );
+}
+
+slop::Mouse::Mouse(X11* x11, int nodecorations, Window ignoreWindow ) {
+    this->x11 = x11;
+    currentCursor = XC_cross;
+    xcursor = XCreateFontCursor( x11->display, XC_cross );
+    hoverWindow = None;
+    XGrabPointer( x11->display, x11->root, True,
+                  PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
+                  GrabModeAsync, GrabModeAsync, None, xcursor, CurrentTime );
+    this->nodecorations = nodecorations;
+    this->ignoreWindow = ignoreWindow;
+    hoverWindow = findWindow(x11->root);
+}
+
+slop::Mouse::~Mouse() {
+	XUngrabPointer( x11->display, CurrentTime );
+}
+
+void slop::Mouse::update() {
+    XEvent event;
+    while ( XCheckTypedEvent( x11->display, ButtonPress, &event ) ) {
+		setButton( event.xbutton.button, 1 );
+	}
+    bool findNewWindow = false;
+    while ( XCheckTypedEvent( x11->display, MotionNotify, &event ) ) {
+        findNewWindow = true;
+	}
+    if ( findNewWindow ) {
+        hoverWindow = findWindow(x11->root);
+    }
+    while ( XCheckTypedEvent( x11->display, ButtonRelease, &event ) ) {
+		setButton( event.xbutton.button, 0 );
+	}
+    while ( XCheckTypedEvent( x11->display, EnterNotify, &event ) ) {
+        hoverWindow = event.xcrossing.window;
+	}
+}
+
+Window slop::Mouse::findWindow( Window foo ) {
+    glm::vec2 pos = getMousePos();
+    Window root, parent;
+    Window* children;
+    unsigned int nchildren;
+    Window selectedWindow;
+    XQueryTree( x11->display, foo, &root, &parent, &children, &nchildren );
+    if ( !children || nchildren <= 0 ) {
+        return foo;
+    }
+    // The children are ordered, so we traverse backwards.
+    for( int i=nchildren-1;i>=0;i-- ) {
+        if ( children[i] == ignoreWindow ) {
+            continue;
+        }
+        // We need to make sure the window isn't something that currently isn't mapped.
+        XWindowAttributes attr;         
+        XGetWindowAttributes( x11->display, children[i], &attr );
+        if ( attr.map_state != IsViewable ) {
+            continue;
+        }
+        glm::vec4 rect = getWindowGeometry(children[i], false);
+        float a = pos.x - rect.x;
+        float b = pos.y - rect.y;
+        if ( a <= rect.z && a >= 0 ) {
+            if ( b <= rect.w && b >= 0 ) {
+                selectedWindow = children[i];
+                switch( nodecorations ) {
+                    case 0:
+                        XFree(children);
+                        return selectedWindow;
+                    case 1:
+                        XFree(children);
+                        //return findWindow( selectedWindow );
+                        XQueryTree( x11->display, selectedWindow, &root, &parent, &children, &nchildren );
+                        if ( !children || nchildren <= 0 ) {
+                            return selectedWindow;
+                        }
+                        return children[nchildren-1];
+                    case 2:
+                        return findWindow( selectedWindow );
+                }
+            }
+        }
+    }
+    return foo;
+}

src/mouse.hpp

@@ -0,0 +1,57 @@
+/* mouse.hpp: Interfaces with x11 to grab mouse information.
+ *
+ * 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_MOUSE_H_
+#define N_MOUSE_H_
+
+#include <vector>
+#include <glm/glm.hpp>
+#include <X11/cursorfont.h>
+#include <iostream>
+
+#include "x.hpp"
+
+namespace slop {
+
+class Mouse {
+private:
+    X11* x11;
+    std::vector<glm::ivec2> buttons;
+    Cursor xcursor;
+    int currentCursor;
+    Window findWindow( Window foo );
+    int nodecorations;
+    Window ignoreWindow;
+public:
+	Window hoverWindow;
+	void update();
+    Mouse( X11* x11, int nodecorations, Window ignoreWindow );
+    ~Mouse();
+    void setCursor( int cursor );
+    glm::vec2 getMousePos();
+    void setButton( int button, int state );
+    int getButton( int button );
+};
+
+extern Mouse* mouse;
+
+}
+
+#endif // N_MOUSE_H_

src/options.cpp

@@ -0,0 +1,233 @@
+#include "options.hpp"
+
+Options::Options( int argc, char** argv ) {
+    validArguments.push_back( Argument( "bordersize",   'b', false ) );
+    validArguments.push_back( Argument( "padding",      'p', false ) );
+    validArguments.push_back( Argument( "color",        'c', false ) );
+    validArguments.push_back( Argument( "shader",       'r', false ) );
+    validArguments.push_back( Argument( "highlight",    'h', true ) );
+    validArguments.push_back( Argument( "format",       'f', false ) );
+    validArguments.push_back( Argument( "tolerance",    't', false ) );
+    validArguments.push_back( Argument( "nodecorations", 'n', false ) );
+    validArguments.push_back( Argument( "nokeyboard",   'k', true ) );
+    validArguments.push_back( Argument( "help",         'h', true ) );
+    validArguments.push_back( Argument( "xdisplay",     'x', false ) );
+    validArguments.push_back( Argument( "version",      'v', true ) );
+    validArguments.push_back( Argument( "quiet",        'q', true ) );
+    validate( argc, argv );
+}
+
+
+int Options::validateStringOption( int argc, char** argv, int argumentIndex ) {
+    std::string argument = argv[argumentIndex];
+    unsigned int index = 0;
+    while( index < validArguments.size() ) {
+        Argument& check = validArguments[index];
+        for( unsigned int i=0;i<check.name.length();i++ ) {
+            if ( check.name[i] != argument[i+2] ) {
+                break;
+            }
+            if ( i == check.name.length()-1 ) {
+                if ( !check.isFlagArgument && argument.find("=") == std::string::npos ) {
+                    throw new std::invalid_argument("Expected `=` after " + arguments[i]);
+                }
+                if ( check.isFlagArgument && i+3 != argument.length() ) {
+                    throw new std::invalid_argument("Trailing characters on flag " + argument );
+                }
+                return parseStringOption( argc, argv, argumentIndex, index );
+            }
+        }
+        index++;
+    }
+    throw new std::invalid_argument("Invalid argument " + argument);
+    return 0;
+}
+
+int Options::parseCharOption( int argc, char** argv, int argumentIndex, int validIndex ) {
+    std::string argument = argv[argumentIndex];
+    Argument& check = validArguments[validIndex];
+    // If we're a flag, we take no arguments, nor do we allow = signs or whatever.
+    if ( check.isFlagArgument ) {
+        if ( argument != std::string()+"-"+check.cname ) {
+            for( int o=1;o<argument.length();o++ ) {
+                bool isValid = false;
+                for( int i=0;i<validArguments.size()&&!isValid;i++ ) {
+                    if ( argument[o] == check.cname ) {
+                        if ( check.isFlagArgument ) {
+                            isValid = true;
+                            arguments.push_back( std::string()+check.cname );
+                            values.push_back("");
+                            break;
+                        } else {
+                            throw new std::invalid_argument( std::string()+"Truncating non-flag arguments is not allowed. Split this up: `" + argument + "`." );
+                        }
+                    }
+                }
+                if (!isValid) {
+                    throw new std::invalid_argument( std::string()+"Unexpected characters around flag `" + argument + "`." );
+                }
+            }
+            return 1;
+        } else {
+            arguments.push_back( std::string()+argument[1] );
+            values.push_back("");
+            return 1;
+        }
+    }
+    arguments.push_back( std::string()+argument[1] );
+    // If they supplied the parameters with spaces
+    if ( argument == std::string()+"-"+check.cname ) {
+        values.push_back(argv[argumentIndex+1]);
+        return 2;
+    }
+    // If they didn't supply the parameters with spaces
+    if ( argument[2] == '=' ) {
+        values.push_back(argument.substr(3));
+        return 1;
+    }
+    values.push_back(argument.substr(2));
+    return 1;
+}
+
+int Options::parseStringOption( int argc, char** argv, int argumentIndex, int validIndex ) {
+    std::string argument = argv[argumentIndex];
+    if ( validArguments[validIndex].isFlagArgument ) {
+        arguments.push_back( argument.substr(2) );
+        values.push_back("");
+        return 1;
+    }
+    arguments.push_back( argument.substr(2,argument.find_first_of('=')) );
+    values.push_back(argument.substr(argument.find_first_of('=')));
+    return 1;
+}
+
+int Options::validateCharOption( int argc, char** argv, int argumentIndex ) {
+    std::string argument = argv[argumentIndex];
+    unsigned int index = 0;
+    while( index < validArguments.size() ) {
+        char check = validArguments[index].cname;
+        if ( argument.length() < 2 ) {
+            continue;
+        }
+        if ( check == argument[1] && ( argument.find("=") == 2 || argument.find('=') == std::string::npos ) && argument[0] == '-' ) {
+            return parseCharOption( argc, argv, argumentIndex, index );
+        }
+        index++;
+    }
+    throw new std::invalid_argument("Invalid argument `" + argument + "`.");
+    return 0;
+}
+
+void Options::validate( int argc, char** argv ) {
+    for ( int i=1;i<argc;) {
+        std::string argument = argv[i];
+        if ( argument[0] != '-' ) {
+            floatingValues.push_back( argument );
+            if ( floatingValues.size() > maxFloatingValues ) {
+                throw new std::invalid_argument("Unexpected floating value `" + argument + "`. Forget to specify an option?" );
+            }
+            i++;
+            continue;
+        }
+        if ( argument[0] == '-' && argument[1] == '-' ) {
+            i += validateStringOption( argc, argv, i );
+            continue;
+        }
+        i += validateCharOption( argc, argv, i );
+    }
+}
+
+bool Options::getFloat( std::string name, char namec, float& found ) {
+    for( unsigned int i=0;i<arguments.size();i++ ) {
+        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
+            std::string::size_type sz;
+            float retvar;
+            try {
+                retvar = std::stof(values[i],&sz);
+            } catch ( ... ) {
+                throw new std::invalid_argument("Unable to parse `" + arguments[i] + "`'s value `" + values[i] + "` as a float.");
+            }
+            if ( sz != values[i].length() ) {
+                throw new std::invalid_argument("Unable to parse `" + arguments[i] + "`'s value `" + values[i] + "` as a float.");
+            }
+            found = retvar;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Options::getInt( std::string name, char namec, int& found ) {
+    for( unsigned int i=0;i<arguments.size();i++ ) {
+        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
+            if ( arguments[i].size() > 1 && arguments[i].find("=") == std::string::npos ) {
+                throw new std::invalid_argument("Expected `=` after " + arguments[i]);
+            }
+            std::string::size_type sz;
+            float retvar;
+            try {
+                retvar = std::stoi(values[i],&sz);
+            } catch ( ... ) {
+                throw new std::invalid_argument("Unable to parse " + arguments[i] + "'s value " + values[i] + " as an integer.");
+            }
+            if ( sz != values[i].length() ) {
+                throw new std::invalid_argument("Unable to parse " + arguments[i] + "'s value " + values[i] + " as an integer.");
+            }
+            found = retvar;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Options::getString( std::string name, char namec, std::string& found ) {
+    for( unsigned int i=0;i<arguments.size();i++ ) {
+        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
+            found = values[i];
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Options::getColor( std::string name, char namec, glm::vec4& found ) {
+    for( unsigned int i=0;i<arguments.size();i++ ) {
+        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
+            std::string::size_type sz;
+            std::string value = values[i];
+            try {
+                found[0] = std::stof(value,&sz);
+                value = value.substr(sz+1);
+                found[1] = std::stof(value,&sz);
+                value = value.substr(sz+1);
+                found[2] = std::stof(value,&sz);
+                if ( value.size() != sz ) {
+                    value = value.substr(sz+1);
+                    found[3] = std::stof(value,&sz);
+                    if ( value.size() != sz ) {
+                        throw "dur";
+                    }
+                } else {
+                    found[3] = 1;
+                }
+            } catch ( ... ) {
+                throw new std::invalid_argument("Unable to parse `" + arguments[i] + "`'s value `" + values[i] + "` as a color. Should be in the format r,g,b or r,g,b,a. Like 1,1,1,1.");
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Options::getBool( std::string name, char namec, bool& found ) {
+    for( unsigned int i=0;i<arguments.size();i++ ) {
+        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
+            if ( values[i] != "" ) {
+                throw new std::invalid_argument("Unexpected value `" + values[i] + "` for flag argument `" + arguments[i] + "`.");
+            }
+            found = true;
+            return true;
+        }
+    }
+    return false;
+}

src/options.ggo

@@ -1,125 +0,0 @@
-package "slop"
-version "v@slop_VERSION_MAJOR@.@slop_VERSION_MINOR@.@slop_VERSION_PATCH@"
-usage "slop [options]"
-description "slop (Select Operation) is an application that queries for a selection from the user and prints the region to stdout."
-versiontext "Copyright (C) 2014 Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors)"
-
-text "Options"
-
-option "xdisplay" - "Sets the x display."
-    string
-    typestr="hostname:number.screen_number"
-    optional
-
-option "nokeyboard" - "Disables the ability to cancel selections with the keyboard."
-    flag
-    off
-
-option "bordersize" b "Set the selection rectangle's thickness. Does nothing when --highlight is enabled."
-    int
-    default="5"
-    optional
-
-option "padding" p "Set the padding size of the selection. Can be negative."
-    int
-    default="0"
-    optional
-
-option "tolerance" t "How far in pixels the mouse can move after clicking and still be detected as a normal click instead of a click and drag. Setting this to 0 will disable window selections."
-    int
-    default="2"
-    optional
-
-option "gracetime" g "Set the amount of time before slop will check for keyboard cancellations in seconds."
-    string
-    typestr="FLOAT"
-    default="0.4"
-    optional
-
-option "color" c "Set the selection rectangle's color. Supports RGB or RGBA values."
-    string
-    typestr="FLOAT,FLOAT,FLOAT,FLOAT"
-    default="0.5,0.5,0.5,1"
-    optional
-
-option "nodecorations" n "Attempt to select child windows in order to avoid window decorations."
-    flag
-    off
-
-option "min" - "Set the minimum output of width or height values. This is useful to avoid outputting 0. Setting min and max to the same value disables drag selections."
-    int
-    default="0"
-    optional
-
-option "max" - "Set the maximum output of width or height values. Setting min and max to the same value disables drag selections."
-    int
-    default="0"
-    optional
-
-option "highlight" l "Instead of outlining selections, slop highlights it. This is only useful when --color is set to a transparent color."
-    flag
-    off
-
-option "opengl" - "Enable hardware acceleration. Only works with modern systems that are also running a compositor."
-    flag
-    off
-
-option "magnify" - "Display a magnifying glass when --opengl is also enabled."
-    flag
-    off
-
-option "magstrength" - "Sets how many times the magnification window size is multiplied."
-    float
-    default="4"
-    optional
-
-option "magpixels" - "Sets how many pixels are displayed in the magnification. The less pixels the bigger the magnification."
-    int
-    default="64"
-    optional
-
-option "theme" - "Sets the theme of the selection, using textures from ~/.config/slop/ or /usr/share/."
-    string
-    default="none"
-    optional
-
-option "shader" - "Sets the shader to load and use from ~/.config/slop/ or /usr/share/."
-    string
-    default="simple"
-    optional
-
-option "format" f "Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c."
-    string
-    default="REPLACEME"
-    optional
-
-text "\nExamples\n"
-text "    $ # Gray, thick, transparent border for maximum visiblity.\n"
-text "    $ slop -b 20 -c 0.5,0.5,0.5,0.8\n"
-text "\n"
-text "    $ # Remove window decorations.\n"
-text "    $ slop --nodecorations\n"
-text "\n"
-text "    $ # Disable window selections. Useful for selecting individual pixels.\n"
-text "    $ slop -t 0\n"
-text "\n"
-text "    $ # Classic Windows XP selection.\n"
-text "    $ slop -l -c 0.3,0.4,0.6,0.4\n"
-text "\n"
-text "    $ # Wiggle wiggle!\n"
-text "    $ slop --opengl --shader wiggle\n"
-text "\n"
-text "    $ # Edgy textures or something.\n"
-text "    $ slop --opengl --theme gothic\n"
-text "\n"
-text "    $ # Change output format to use safer parsing\n"
-text "    $ slopoutput=$(slop -f \"%x %y %w %h\")\n"
-text "    $ X=$(echo $slopoutput | awk '{print $1}')\n"
-text "    $ Y=$(echo $slopoutput | awk '{print $2}')\n"
-text "    $ W=$(echo $slopoutput | awk '{print $3}')\n"
-text "    $ H=$(echo $slopoutput | awk '{print $4}')\n"
-
-text "\nTips\n"
-text "    * You can use the arrow keys to move the starting point of a drag-selection, just in case you missed it by a few pixels.\n"
-text "    * If you don't like a selection: you can cancel it by right-clicking regardless of which options are enabled or disabled for slop.\n"
-text "    * If slop doesn't seem to select a window accurately, the problem could be because of decorations getting in the way. Try enabling the --nodecorations flag.\n"

src/options.hpp

@@ -0,0 +1,61 @@
+/* options.hpp: parses arguments from the commandline.
+ *
+ * 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_OPTIONS_H_
+#define N_OPTIONS_H_
+
+#include <iostream>
+#include <string>
+#include <exception>
+#include <stdexcept>
+#include <vector>
+#include <glm/glm.hpp>
+
+class Argument {
+public:
+    std::string name;
+    char cname;
+    bool isFlagArgument;
+    Argument( std::string name, char cname, bool isFlagArgument ) : name(name), cname(cname), isFlagArgument(isFlagArgument) {}
+};
+
+static std::vector<Argument> validArguments;
+static unsigned int maxFloatingValues = 0;
+
+class Options {
+private:
+    std::vector<std::string> arguments;
+    std::vector<std::string> values;
+    std::vector<std::string> floatingValues;
+    int parseCharOption( int argc, char** argv, int argumentIndex, int validIndex );
+    int parseStringOption( int argc, char** argv, int argumentIndex, int validIndex );
+    int validateStringOption( int argc, char** argv, int argumentIndex );
+    int validateCharOption( int argc, char** argv, int argumentIndex );
+    void validate( int argc, char** argv );
+public:
+    Options( int argc, char** argv );
+    bool getFloat( std::string name, char namec, float& found );
+    bool getInt( std::string name, char namec, int& found );
+    bool getString( std::string name, char namec, std::string& found );
+    bool getColor( std::string name, char namec, glm::vec4& found );
+    bool getBool( std::string name, char namec, bool& found );
+};
+
+#endif // N_OPTIONS_H_

src/rectangle.cpp

@@ -0,0 +1,13 @@
+#include "rectangle.hpp"
+
+slop::Rectangle::Rectangle() {
+}
+slop::Rectangle::~Rectangle() {
+}
+void slop::Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+}
+void slop::Rectangle::draw(glm::mat4& matrix) {
+}
+glm::vec4 slop::Rectangle::getRect() {
+    return glm::vec4();
+}

src/rectangle.hpp

@@ -0,0 +1,39 @@
+/* rectangle.hpp: Rectangle generic
+ *
+ * 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_RECTANGLE_H_
+#define N_RECTANGLE_H_
+
+#include <glm/glm.hpp>
+
+namespace slop {
+
+class Rectangle {
+public:
+    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/resource.cpp

@@ -1,4 +1,4 @@
-/* resource.cpp: Handles getting resources like textures and stuff.
+/* resource.cpp: Handles converting local paths to full paths.
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -20,52 +20,35 @@
 
 #include "resource.hpp"
 
-slop::Resource* resource = new slop::Resource();
-
 slop::Resource::Resource() {
     // Find the configuration directory.
     // usually ~/.config/slop and /usr/share/slop
     char* config = getenv( "XDG_CONFIG_HOME" );
     if ( config == NULL ) {
         char* home = getpwuid(getuid())->pw_dir;
-        m_usrconfig += home;
-        m_usrconfig += "/.config/slop/";
-        m_sysconfig = INSTALL_PREFIX;
-        m_sysconfig += "/share/slop/";
+        usrconfig += home;
+        usrconfig += "/.config/slop/";
         return;
     }
-    m_usrconfig += config;
-    m_usrconfig += "/slop/";
-    m_sysconfig = INSTALL_PREFIX;
-    m_sysconfig += "/share/slop/";
+    usrconfig += config;
+    usrconfig += "/slop/";
 }
 
 std::string slop::Resource::getRealPath( std::string localpath ) {
-    if ( validatePath( m_usrconfig + localpath ) ) {
-        return m_usrconfig + localpath;
-    }
-    if ( validatePath( m_sysconfig + localpath ) ) {
-        return m_sysconfig + localpath;
+    if ( validatePath( usrconfig + localpath ) ) {
+        return usrconfig + localpath;
     }
-    std::string err = "The file or folder " + localpath + " was not found in either " + m_sysconfig + " or " + m_usrconfig + "\n";
-    throw err;
+    std::string err = "The file or folder " + localpath + " was not found in " + usrconfig + "\n";
+    throw new std::runtime_error(err);
     return localpath;
 }
 
 bool slop::Resource::validatePath( std::string path ) {
-
     struct stat st;
-
     const char* dirname = path.c_str();
     if ( stat( dirname, &st ) != 0 ) {
         return false;
     }
-    // No read permissions.
-    //if ( !(st.st_mode & S_IROTH) &&
-         //(st.st_uid != getuid() || !(st.st_mode & S_IRUSR)) &&
-         //(st.st_gid != getgid() || !(st.st_mode & S_IRGRP)) ) {
-        //return false;
-    //}
     // Lookin' good!
     return true;
 }

src/resource.hpp

@@ -18,9 +18,10 @@
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef IS_RESOURCE_H_
-#define IS_RESOURCE_H_
+#ifndef N_RESOURCE_H_
+#define N_RESOURCE_H_
 
+#include <stdexcept>
 #include <stdlib.h>
 #include <cassert>
 #include <cstdio>
@@ -36,18 +37,15 @@ namespace slop {
 
 class Resource {
 public:
-
-                    Resource();
-                    ~Resource();
-    std::string     getRealPath( std::string localpath );
-    bool            validatePath( std::string path );
+    Resource();
+    std::string getRealPath( std::string localpath );
 private:
-    std::string     m_usrconfig;
-    std::string     m_sysconfig;
+    bool validatePath( std::string path );
+    std::string usrconfig;
 };
 
-}
+extern Resource* resource;
 
-extern slop::Resource* resource;
+}
 
 #endif // IS_RESOURCE_H_

src/shader.cpp

@@ -1,55 +1,67 @@
 #include "shader.hpp"
 
-slop::Shader::Shader( std::string name, std::string vert, std::string frag, std::string type ) {
-    m_name = name;
-    // Set up the type of the shader, this is read by render to know what kind of matricies it needs.
-    if ( type == "perspective" ) {
-        m_type = 0;
-    } else if ( type == "orthographic" ) {
-        m_type = 1;
+slop::Shader::Shader( std::string vert, std::string frag, bool file ) {
+    std::string vert_contents;
+    std::string frag_contents;
+    if ( file ) {
+        vert = resource->getRealPath(vert);
+        frag = resource->getRealPath(frag);
+        std::ifstream v( vert.c_str() );
+        vert_contents = std::string((std::istreambuf_iterator<char>(v)),
+                                   std::istreambuf_iterator<char>());
+        std::ifstream f( frag.c_str() );
+        frag_contents = std::string((std::istreambuf_iterator<char>(f)),
+                                  std::istreambuf_iterator<char>());
     } else {
-        m_type = -1;
+        vert_contents = vert;
+        frag_contents = frag;
     }
-    m_good = false;
-    // Create the program to link to.
-    m_program = glCreateProgram();
-
-    std::ifstream v( vert.c_str() );
-    std::string vert_contents((std::istreambuf_iterator<char>(v)),
-                               std::istreambuf_iterator<char>());
-    std::ifstream f( frag.c_str() );
-    std::string frag_contents((std::istreambuf_iterator<char>(f)),
-                              std::istreambuf_iterator<char>());
 
     const char* vertsrc = vert_contents.c_str();
     const char* fragsrc = frag_contents.c_str();
 
+    // Create the program to link to.
+    program = glCreateProgram();
+    
+    if ( vert_contents.length() <= 0 ) {
+        std::string errstring = "Failed to open file (or is empty) `" + vert + "`.\n";
+        throw new std::runtime_error(errstring);
+    }
+
+    if ( frag_contents.length() <= 0 ) {
+        std::string errstring = "Failed to open file (or is empty) `" + frag + "`.\n";
+        throw new std::runtime_error(errstring);
+    }
+
     // Compile both shaders.
     unsigned int vertShader = glCreateShader( GL_VERTEX_SHADER );
     glShaderSource( vertShader, 1, &vertsrc , NULL );
-    int err = compile( vertShader );
+    std::string errortxt;
+    int err = compile( vertShader, errortxt );
 
     if ( err ) {
-        fprintf( stderr, "Failed to compile shader %s.\n", vert.c_str() );
+        std::string errstring = "Failed to compile shader `" + vert + "`:\n" + errortxt;
+        throw new std::runtime_error(errstring);
         glDeleteShader( vertShader );
         return;
     }
 
     unsigned int fragShader = glCreateShader( GL_FRAGMENT_SHADER );
     glShaderSource( fragShader, 1, &fragsrc, NULL );
-    err = compile( fragShader );
+    err = compile( fragShader, errortxt );
     if ( err ) {
-        fprintf( stderr, "Failed to compile shader %s.\n", frag.c_str() );
+        std::string errstring = "Failed to compile shader `" + frag + "`:\n" + errortxt;
+        throw new std::runtime_error(errstring);
         glDeleteShader( vertShader );
         glDeleteShader( fragShader );
         return;
     }
 
-
     // Then attempt to link them to this shader.
-    err = link( vertShader, fragShader );
+    err = link( vertShader, fragShader, errortxt );
     if ( err ) {
-        fprintf( stderr, "Failed to link shader %s.\n", name.c_str() );
+        std::string errstring = "Failed to link shader `" + vert + "` and  `" + frag + "`:\n" + errortxt;
+        throw new std::runtime_error(errstring);
         glDeleteShader( vertShader );
         glDeleteShader( fragShader );
         return;
@@ -58,54 +70,53 @@ slop::Shader::Shader( std::string name, std::string vert, std::string frag, std:
     // Clean up :)
     glDeleteShader( vertShader );
     glDeleteShader( fragShader );
-    m_good = true;
     glUseProgram( 0 );
 }
 
 slop::Shader::~Shader() {
-    glDeleteProgram( m_program );
+    glDeleteProgram( program );
 }
 
 unsigned int slop::Shader::getProgram() {
-    return m_program;
+    return program;
 }
 
 void slop::Shader::bind() {
-    glUseProgram( m_program );
+    glUseProgram( program );
 }
 
-int slop::Shader::compile( unsigned int shader ) {
+int slop::Shader::compile( unsigned int shader, std::string& error ) {
     glCompileShader( shader );
 
     // Compiling the shader is the easy part, all this junk down here is for printing the error it might generate.
-    int result;
+    int result = GL_FALSE;
     int logLength;
     glGetShaderiv( shader, GL_COMPILE_STATUS, &result );
     glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logLength );
     if ( result == GL_FALSE ) {
         char* errormsg = new char[ logLength ];
         glGetShaderInfoLog( shader, logLength, NULL, errormsg );
-        fprintf( stderr, "%s\n", errormsg );
+        error = errormsg;
         delete[] errormsg;
         return 1;
     }
     return 0;
 }
 
-int slop::Shader::link( unsigned int vertshader, unsigned int fragshader ) {
-    glAttachShader( m_program, vertshader );
-    glAttachShader( m_program, fragshader );
-    glLinkProgram( m_program );
+int slop::Shader::link( unsigned int vertshader, unsigned int fragshader, std::string& error ) {
+    glAttachShader( program, vertshader );
+    glAttachShader( program, fragshader );
+    glLinkProgram( program );
 
     // Linking the shader is the easy part, all this junk down here is for printing the error it might generate.
-    int result;
+    int result = GL_FALSE;
     int logLength;
-    glGetProgramiv( m_program, GL_LINK_STATUS, &result);
-    glGetProgramiv( m_program, GL_INFO_LOG_LENGTH, &logLength);
+    glGetProgramiv( program, GL_LINK_STATUS, &result);
+    glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logLength);
     if ( result == GL_FALSE ) {
         char* errormsg = new char[ logLength ];
-        glGetProgramInfoLog( m_program, logLength, NULL, errormsg );
-        fprintf( stderr, "%s\n", errormsg );
+        glGetProgramInfoLog( program, logLength, NULL, errormsg );
+        error = errormsg;
         delete[] errormsg;
         return 1;
     }
@@ -113,60 +124,42 @@ int slop::Shader::link( unsigned int vertshader, unsigned int fragshader ) {
 }
 
 unsigned int slop::Shader::getUniformLocation( std::string name ) {
-    if ( !m_good ) {
-        return 0;
-    }
-    glUseProgram( m_program );
-    return glGetUniformLocation( m_program, name.c_str() );
+    glUseProgram( program );
+    return glGetUniformLocation( program, name.c_str() );
 }
 
 void slop::Shader::setParameter( std::string name, int foo ) {
-    if ( !m_good ) {
-        return;
-    }
     glUniform1i( getUniformLocation( name ), foo );
 }
 
 void slop::Shader::setParameter( std::string name, float foo ) {
-    if ( !m_good ) {
-        return;
-    }
     glUniform1f( getUniformLocation( name ), foo );
 }
 
-void slop::Shader::setParameter( std::string name, glm::mat4 foo ) {
-    if ( !m_good ) {
-        return;
-    }
+void slop::Shader::setParameter( std::string name, glm::mat4& foo ) {
     glUniformMatrix4fv( getUniformLocation( name ), 1, GL_FALSE, glm::value_ptr( foo ) );
 }
 
 void slop::Shader::setParameter( std::string name, glm::vec4 foo ) {
-    if ( !m_good ) {
-        return;
-    }
     glUniform4f( getUniformLocation( name ), foo.x, foo.y, foo.z, foo.w );
 }
 
 void slop::Shader::setParameter( std::string name, glm::vec2 foo ) {
-    if ( !m_good ) {
-        return;
-    }
     glUniform2f( getUniformLocation( name ), foo.x, foo.y );
 }
 
 void slop::Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) {
-    unsigned int a = glGetAttribLocation( m_program, name.c_str() );
+    unsigned int a = glGetAttribLocation( program, name.c_str() );
     glEnableVertexAttribArray( a );
     glBindBuffer( GL_ARRAY_BUFFER, buffer );
     glVertexAttribPointer( a, stepsize, GL_FLOAT, GL_FALSE, 0, NULL );
-    m_activeattribs.push_back( a );
+    activeAttributes.push_back( a );
 }
 
 void slop::Shader::unbind() {
-    for ( unsigned int i=0; i<m_activeattribs.size(); i++ ) {
-        glDisableVertexAttribArray( m_activeattribs[i] );
+    for ( unsigned int i=0; i<activeAttributes.size(); i++ ) {
+        glDisableVertexAttribArray( activeAttributes[i] );
     }
-    m_activeattribs.clear();
+    activeAttributes.clear();
     glUseProgram( 0 );
 }

src/shader.hpp

@@ -1,48 +1,62 @@
-// shader.hpp: Loads shaders into opengl
+/* shader.hpp: Handles compiling shaders.
+ *
+ * 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 IS_SHADER_H_
-#define IS_SHADER_H_
+#ifndef N_SHADER_H_
+#define N_SHADER_H_
 
-#include <string>
-#include <cstdio>
+#include <fstream>
 #include <vector>
-#ifdef OPENGL_ENABLED
+#include <string>
+#include <exception>
+
+#include "gl_core_3_3.h"
 #include <glm/glm.hpp>
 #include <glm/gtc/type_ptr.hpp>
-#include <GL/glew.h>
-#endif
-#include <string>
-#include <fstream>
-#include <streambuf>
+#include <EGL/egl.h>
+#include <GL/gl.h>
+
+#include "resource.hpp"
 
 namespace slop {
 
 class Shader {
 public:
-    Shader( std::string name, std::string vert, std::string frag, std::string shadertype = "other" );
+    Shader( std::string vert, std::string frag, bool file = true );
     ~Shader();
     unsigned int    getProgram();
-    std::string     m_name;
     void            bind();
     void            unbind();
     void            setParameter( std::string name, int foo );
     void            setParameter( std::string name, float foo );
-#ifdef OPENGL_ENABLED
-    void            setParameter( std::string name, glm::mat4 foo );
+    void            setParameter( std::string name, glm::mat4& foo );
     void            setParameter( std::string name, glm::vec4 foo );
     void            setParameter( std::string name, glm::vec2 foo );
-#endif
     void            setAttribute( std::string name, unsigned int buffer, unsigned int stepsize );
-    int             m_type;
 private:
-    std::vector<unsigned int>   m_activeattribs;
-    bool                        m_good;
+    std::vector<unsigned int>   activeAttributes;
     unsigned int                getUniformLocation( std::string );
-    int                         compile( unsigned int shader );
-    int                         link( unsigned int vert, unsigned int frag );
-    unsigned int                m_program;
+    int                         compile( unsigned int shader, std::string& error );
+    int                         link( unsigned int vert, unsigned int frag, std::string& error );
+    unsigned int                program;
 };
 
-};
+}
 
-#endif // IS_SHADER_H_
+#endif // N_SHADER_H_

src/slop.cpp

@@ -0,0 +1,202 @@
+#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"
+#include "slop.hpp"
+
+namespace slop {
+
+X11* x11;
+Mouse* mouse;
+Keyboard* keyboard;
+Resource* resource;
+
+SlopSelection GLSlopSelect( slop::SlopOptions* options, bool* cancelled, slop::SlopWindow* window );
+SlopSelection XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled);
+
+}
+
+using namespace slop;
+
+// Defaults!
+slop::SlopOptions::SlopOptions() {
+    borderSize = 1;
+    nokeyboard = false;
+    nodecorations = false;
+    tolerance = 2;
+    padding = 0;
+    shader = "textured";
+    highlight = false;
+    xdisplay = ":0";
+    r = 0.5;
+    g = 0.5;
+    b = 0.5;
+    a = 1;
+}
+
+slop::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;
+}
+
+slop::SlopSelection slop::SlopSelect( slop::SlopOptions* options, bool* cancelled, bool quiet) {
+    slop::SlopSelection returnval(0,0,0,0,0);
+    bool deleteOptions = false;
+    if ( !options ) {
+        deleteOptions = true;
+        options = new slop::SlopOptions();
+    }
+    resource = new Resource();
+    // Set up x11 temporarily
+    x11 = new X11(options->xdisplay);
+    keyboard = new Keyboard( x11 );
+    bool success = false;
+    std::string errorstring = "";
+    SlopWindow* window;
+    // First we check if we have a compositor available
+	if ( x11->hasCompositor() ) {
+        // If we have a compositor, we try using OpenGL
+        try {
+            window = new SlopWindow();
+            success = true;
+        } catch (...) {
+            success = false;
+        }
+    } else {
+        errorstring += "Failed to detect a compositor, OpenGL hardware-accelleration disabled...\n";
+    }
+    if ( !success ) {
+        // If we fail, we launch the XShape version of slop.
+        if ( !quiet ) {
+            if ( errorstring.length() <= 0 ) {
+                errorstring += "Failed to launch OpenGL context, --shader parameter will be ignored.\n";
+                std::cerr << errorstring;
+            } else {
+                std::cerr << errorstring;
+            }
+        }
+        returnval = slop::XShapeSlopSelect( options, cancelled );
+    } else {
+        returnval = slop::GLSlopSelect( options, cancelled, window );
+    }
+    delete x11;
+    delete slop::resource;
+    if ( deleteOptions ) {
+        delete options;
+    }
+    return returnval;
+}
+
+slop::SlopSelection slop::XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled ) {
+    // Init our little state machine, memory is a tad of a misnomer
+    slop::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) );
+    slop::mouse = new slop::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 ) {
+        slop::mouse->update();
+        slop::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 ( (slop::keyboard->anyKeyDown() && !options->nokeyboard) || slop::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 slop::mouse;
+    // Finally return the data.
+    return slop::SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
+}
+
+slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, bool* cancelled, SlopWindow* window ) {
+    slop::mouse = new slop::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
+    slop::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 ) {
+        slop::mouse->update();
+        slop::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 ( (slop::keyboard->anyKeyDown() && !options->nokeyboard) || slop::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 slop::mouse;
+    // Finally return the data.
+    return slop::SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
+}

src/slop.hpp

@@ -0,0 +1,60 @@
+/* glslop.hpp: exposes an opengl selection interface
+ *
+ * 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_SLOP_H_
+#define N_SLOP_H_
+
+#include <string>
+
+namespace slop {
+
+class SlopOptions {
+public:
+    SlopOptions();
+    float borderSize;
+    float padding;
+    float tolerance;
+    bool highlight;
+    bool nokeyboard;
+    int nodecorations;
+    std::string shader;
+    float r;
+    float g;
+    float b;
+    float a;
+    std::string xdisplay;
+};
+
+class SlopSelection {
+public:
+    SlopSelection( float x, float y, float w, float h, int id );
+    float x;
+    float y;
+    float w;
+    float h;
+// This is an X11 Window ID
+    int id;
+};
+
+SlopSelection SlopSelect( SlopOptions* options = NULL, bool* cancelled = NULL, bool quiet = false );
+
+}
+
+#endif // N_SLOP_H_

src/slopstates.cpp

@@ -0,0 +1,122 @@
+#include "slopstates.hpp"
+
+using namespace slop;
+
+slop::SlopMemory::SlopMemory( SlopOptions* options, Rectangle* rect ) {
+    running = true;
+    state = (SlopState*)new SlopStart();
+    nextState = NULL;
+    tolerance = options->tolerance;
+    nodecorations = options->nodecorations;
+    rectangle = rect;
+    selectedWindow = x11->root;
+    state->onEnter( *this );
+}
+
+slop::SlopMemory::~SlopMemory() {
+    delete state;
+    if ( nextState ) {
+        delete nextState;
+    }
+    delete rectangle;
+}
+
+void slop::SlopMemory::update( double dt ) {
+    state->update( *this, dt );
+    if ( nextState ) {
+        state->onExit( *this );
+        delete state;
+        state = nextState;
+        state->onEnter( *this );
+        nextState = NULL;
+    }
+}
+
+void slop::SlopMemory::setState( SlopState* state ) {
+    if ( nextState ) {
+        delete nextState;
+    }
+    nextState = state;
+}
+
+void slop::SlopMemory::draw( glm::mat4& matrix ) {
+    state->draw( *this, matrix );
+}
+
+
+slop::SlopState::~SlopState() {
+}
+void slop::SlopState::onEnter( SlopMemory& memory ) {
+}
+void slop::SlopState::onExit( SlopMemory& memory ) {
+}
+void slop::SlopState::update( SlopMemory& memory, double dt ) {
+}
+void slop::SlopState::draw( SlopMemory& memory, glm::mat4 matrix ) {
+}
+
+void slop::SlopStart::onEnter( SlopMemory& memory ) {
+    setStartPos = false;
+}
+void slop::SlopStart::update( SlopMemory& memory, double dt ) {
+    if ( mouse->getButton( 1 ) && !setStartPos ) {
+        startPos = mouse->getMousePos();
+        setStartPos = true;
+    }
+    if ( setStartPos && glm::distance( startPos, mouse->getMousePos() ) >= memory.tolerance ) {
+        memory.setState( (SlopState*)new SlopStartDrag( startPos ) );
+    }
+    if ( mouse->hoverWindow != None ) {
+        glm::vec4 rect = getWindowGeometry( mouse->hoverWindow, memory.nodecorations );
+        memory.rectangle->setPoints( glm::vec2( (float)rect.x, (float)rect.y ), glm::vec2( (float)rect.x+rect.z, (float)rect.y+rect.w ) );
+    }
+    if ( setStartPos && !mouse->getButton( 1 ) ) {
+        memory.selectedWindow = mouse->hoverWindow;
+        memory.setState( (SlopState*)new SlopEndDrag() );
+    }
+}
+
+void slop::SlopStart::draw( SlopMemory& memory, glm::mat4 matrix ) {
+    if ( memory.tolerance > 0 ) {
+        memory.rectangle->draw( matrix );
+    }
+}
+
+slop::SlopStartDrag::SlopStartDrag( glm::vec2 point ) {
+    startPoint = point;
+}
+
+void slop::SlopStartDrag::onEnter( SlopMemory& memory ) {
+    memory.rectangle->setPoints(startPoint, startPoint);
+}
+
+void slop::SlopStartDrag::update( SlopMemory& memory, double dt ) {
+    char a = startPoint.y > mouse->getMousePos().y;
+    char b = startPoint.x > mouse->getMousePos().x;
+    char c = (a << 1) | b;
+    switch ( c ) {
+        case 0: mouse->setCursor( XC_lr_angle );
+                memory.rectangle->setPoints(startPoint+glm::vec2(0,0), mouse->getMousePos()+glm::vec2(1,1));
+                break;
+        case 1: mouse->setCursor( XC_ll_angle );
+                memory.rectangle->setPoints(startPoint+glm::vec2(0,0), mouse->getMousePos()+glm::vec2(1,1));
+                break;
+        case 2: mouse->setCursor( XC_ur_angle );
+                memory.rectangle->setPoints(startPoint+glm::vec2(0,1), mouse->getMousePos()+glm::vec2(1,0));
+                break;
+        case 3: mouse->setCursor( XC_ul_angle );
+                memory.rectangle->setPoints(startPoint+glm::vec2(1,1), mouse->getMousePos()+glm::vec2(0,0));
+                break;
+    }
+    if ( !mouse->getButton( 1 ) ) {
+        memory.setState( (SlopState*)new SlopEndDrag() );
+    }
+}
+
+void slop::SlopStartDrag::draw( SlopMemory& memory, glm::mat4 matrix ) {
+    memory.rectangle->draw( matrix );
+}
+
+void slop::SlopEndDrag::onEnter( SlopMemory& memory ) {
+    memory.running = false;
+}

src/slopstates.hpp

@@ -0,0 +1,87 @@
+/* slopstates.hpp: State machine stuffs.
+ *
+ * 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_SLOPSTATES_H_
+#define N_SLOPSTATES_H_
+
+#include "mouse.hpp"
+#include "slop.hpp"
+
+#include "rectangle.hpp"
+
+namespace slop {
+
+class SlopMemory;
+class SlopOptions;
+
+class SlopState {
+public:
+    virtual ~SlopState();
+    virtual void onEnter( SlopMemory& memory );
+    virtual void onExit( SlopMemory& memory );
+    virtual void update( SlopMemory& memory, double dt );
+    virtual void draw( SlopMemory& memory, glm::mat4 matrix );
+};
+
+class SlopStart : SlopState {
+private:
+    bool setStartPos;
+    glm::vec2 startPos;
+public:
+    virtual void onEnter( SlopMemory& memory );
+    virtual void update( SlopMemory& memory, double dt );
+    virtual void draw( SlopMemory& memory, glm::mat4 matrix );
+};
+
+class SlopStartDrag : SlopState {
+private:
+    glm::vec2 startPoint;
+public:
+    SlopStartDrag( glm::vec2 point );
+    virtual void onEnter( SlopMemory& memory );
+    virtual void update( SlopMemory& memory, double dt );
+    virtual void draw( SlopMemory& memory, glm::mat4 matrix );
+};
+
+class SlopEndDrag : SlopState {
+public:
+    virtual void onEnter( SlopMemory& memory );
+};
+
+class SlopMemory {
+private:
+    SlopState* state;
+    SlopState* nextState;
+public:
+    SlopMemory( SlopOptions* options, Rectangle* rect );
+    ~SlopMemory();
+    Window selectedWindow;
+    bool running;
+    float tolerance;
+    bool nodecorations;
+    Rectangle* rectangle;
+    void setState( SlopState* state );
+    void update( double dt );
+    void draw( glm::mat4& matrix );
+};
+
+}
+
+#endif // N_SLOPSTATES_H_

src/window.cpp

@@ -0,0 +1,94 @@
+#include "window.hpp"
+
+using namespace slop;
+
+slop::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;
+
+
+    // Create the window
+    window = XCreateWindow( slop::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.");
+    }
+    framebuffer = new Framebuffer( WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ) );
+
+    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);
+
+    // Last, we actually display the window <:o)
+	XMapWindow( x11->display, window );
+}
+
+slop::SlopWindow::~SlopWindow() {
+    delete framebuffer;
+    // 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();
+    glXDestroyContext( x11->display, context );
+    XDestroyWindow( x11->display, window );
+}
+
+void slop::SlopWindow::display() {
+    glXSwapBuffers( x11->display, window );
+    glXWaitGL();
+}
+
+void slop::SlopWindow::setCurrent() {
+    glXMakeCurrent( x11->display, window, context ) ;
+}

src/selectrectangle.hpp → src/window.hpp

@@ -1,4 +1,4 @@
-/* selectrectangle.hpp: Handles creating rectangles on the screen.
+/* window.hpp: Spawns and manages windows. By default it creates an OpenGL context with them.
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -18,43 +18,38 @@
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef IS_SELECT_RECTANGLE_H_
-#define IS_SELECT_RECTANGLE_H_
+#ifndef N_WINDOW_H_
+#define N_WINDOW_H_
 
-#include "x.hpp"
-#include "selectrectangle.hpp"
-#include "shader.hpp"
-
-#include <unistd.h>
-
-#include <X11/Xlib.h>
-#include <X11/extensions/shape.h>
+#include <string>
+#include <exception>
+
+#include <iostream>
+#include "gl_core_3_3.h"
+#include <GL/gl.h>
+#include <GL/glx.h>
+#include <glm/gtc/matrix_transform.hpp>
+#include <X11/Xutil.h>
 #include <X11/Xatom.h>
 
-#include <cstdlib>
-#include <cmath>
-#include <cstdio>
-#include <string>
-#include <vector>
+#include "x.hpp"
+#include "framebuffer.hpp"
 
 namespace slop {
 
-class SelectRectangle {
+class SlopWindow {
 public:
-    virtual ~SelectRectangle();
-    virtual void    setGeo( int x, int y, int w, int h );
-    virtual void    update( double dt );
-    Window          m_window;
-    int             m_x;
-    int             m_y;
-    int             m_width;
-    int             m_height;
-    int             m_border;
-    bool            m_highlight;
+    Framebuffer* framebuffer;
+    int width, height;
+    glm::mat4 camera;
+    GLXWindow window;
+    GLXContext context;
+    SlopWindow();
+    ~SlopWindow();
+    void setCurrent();
+    void display();
 };
 
-bool isSelectRectangleSupported();
-
 }
 
-#endif // IS_SELECT_RECTANGLE_H_
+#endif // N_WINDOW_H_

src/x.cpp

@@ -1,453 +1,60 @@
-/* x.cpp: Handles starting and managing X.
- *
- * 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/>.
- */
 #include "x.hpp"
 
-slop::XEngine* xengine = new slop::XEngine();
+using namespace slop;
 
-int slop::XEngineErrorHandler( Display* dpy, XErrorEvent* event ) {
-    // Ignore XGrabKeyboard BadAccess errors, we can work without it.
-    // 31 = XGrabKeyboard's request code
-    if ( event->request_code == 31 && event->error_code == BadAccess ) {
-        fprintf( stderr, "_X Error \"BadAccess\" for XGrabKeyboard ignored...\n" );
-        return EXIT_SUCCESS;
-    }
-    // Ignore XQueryKeymap BadValue errors, we can work without it.
-    // 128 = XShape request code, not sure why XQueryKeymap generates this?
-    if ( event->request_code == 128 && event->error_code == BadValue ) {
-        fprintf( stderr, "_X Error \"BadValue\" for XQueryKeymap ignored...\n" );
-        return EXIT_SUCCESS;
-    }
-    // Everything else should be fatal as I don't like undefined behavior.
-    char buffer[1024];
-    XGetErrorText( dpy, event->error_code, buffer, 1024 );
-    fprintf( stderr,
-             "_X Error of failed request: %s\n_  Error code of failed request: %3d\n_  Major opcode of failed request: %3d\n_  Minor opcode of failed request: %3d\n_  Serial number of failed request: %5li\n_  Current serial number in output stream:?????\n",
-             buffer,
-             event->error_code,
-             event->request_code,
-             event->minor_code,
-             event->serial );
-    exit(1);
-}
-
-unsigned int slop::XEngine::getWidth() {
-    if ( !m_good ) {
-        return -1;
-    }
-    return WidthOfScreen( m_screen );
-}
-
-unsigned int slop::XEngine::getHeight() {
-    if ( !m_good ) {
-        return -1;
-    }
-    return HeightOfScreen( m_screen );
-}
-
-slop::XEngine::XEngine() {
-    m_keypressed = false;
-    m_display = NULL;
-    m_visual = NULL;
-    m_screen = NULL;
-    m_good = false;
-    m_mousex = -1;
-    m_mousey = -1;
-    m_hoverWindow = None;
-}
-
-slop::XEngine::~XEngine() {
-    if ( !m_good ) {
-        return;
-    }
-    for ( unsigned int i=0; i<m_cursors.size(); i++ ) {
-        if ( m_cursors.at( i ) ) {
-            XFreeCursor( m_display, m_cursors[i] );
-        }
-    }
-    XCloseDisplay( m_display );
-}
-
-bool slop::XEngine::mouseDown( unsigned int button ) {
-    if ( button >= m_mouse.size() ) {
-        return false;
-    }
-    return m_mouse.at( button );
-}
-
-int slop::XEngine::init( std::string display ) {
+glm::vec4 slop::getWindowGeometry( Window win, bool removeDecoration) {
+    XWindowAttributes attr;         
+    XGetWindowAttributes( x11->display, win, &attr );
+    unsigned int width = attr.width;           
+    unsigned int height = attr.height;         
+    unsigned int border = attr.border_width;   
+    int x, y;
+    Window junk;
+    XTranslateCoordinates( x11->display, win, attr.root, -attr.border_width, -attr.border_width, &x, &y, &junk );
+    if ( !removeDecoration ) {
+        width += border*2;
+        height += border*2;
+        return glm::vec4( x, y, width, height );
+    }
+    // This is required to be defined by the window manager, so we can assume it exists.
+    Atom actual_type;
+    int actual_format;
+    unsigned long nitems, bytes_after;
+    unsigned char *data;
+    int result = XGetWindowProperty(x11->display, win,
+                                    XInternAtom(x11->display, "_NET_FRAME_EXTENTS", true),
+                                    0, 4, False, AnyPropertyType, 
+                                    &actual_type, &actual_format, &nitems, &bytes_after, &data);
+    if ( result == Success ) {
+        // Make sure we got the data we expect...
+        if ((nitems == 4) && (bytes_after == 0)) {
+            x += (int)data[0];
+            width -= (int)data[1];
+            y += (int)data[2];
+            height -= (int)data[3];
+        }
+    }
+    return glm::vec4( x, y, width, height );
+}
+
+bool X11::hasCompositor() {
+    std::stringstream prop_name;
+    prop_name << "_NET_WM_CM_S" << XScreenNumberOfScreen( screen );
+    Atom prop_atom = XInternAtom(display, prop_name.str().c_str(), False);
+    return XGetSelectionOwner(display, prop_atom) != None;
+}
+
+X11::X11( std::string displayName ) {
     // Initialize display
-    m_display = XOpenDisplay( display.c_str() );
-    if ( !m_display ) {
-        fprintf( stderr, "Error: Failed to open X display %s\n", display.c_str() );
-        return EXIT_FAILURE;
+    display = XOpenDisplay( displayName.c_str() );
+    if ( !display ) {
+        throw new std::runtime_error(std::string("Error: Failed to open X display: ") + displayName );
     }
-    m_screen    = ScreenOfDisplay( m_display, DefaultScreen( m_display ) );
-    m_visual    = DefaultVisual  ( m_display, XScreenNumberOfScreen( m_screen ) );
-    m_colormap  = DefaultColormap( m_display, XScreenNumberOfScreen( m_screen ) );
-    //m_root      = RootWindow     ( m_display, XScreenNumberOfScreen( m_screen ) );
-    m_root      = DefaultRootWindow( m_display );
-
-#ifdef OPENGL_ENABLED
-    m_res = XRRGetScreenResourcesCurrent( m_display, m_root);
-#endif // OPENGL_ENABLED
-
-    m_good = true;
-    XSetErrorHandler( slop::XEngineErrorHandler );
-    selectAllInputs( m_root, EnterWindowMask );
-    return EXIT_SUCCESS;
+    screen = ScreenOfDisplay( display, DefaultScreen( display ) );
+    visual = DefaultVisual( display, XScreenNumberOfScreen( screen ) );
+    root = DefaultRootWindow( display );
 }
 
-#ifdef OPENGL_ENABLED
-std::vector<XRRCrtcInfo*> slop::XEngine::getCRTCS() {
-    std::vector<XRRCrtcInfo*> monitors;
-    if ( !m_res ) {
-        return monitors;
-    }
-    for ( int i=0;i<m_res->ncrtc;i++ ) {
-        monitors.push_back( XRRGetCrtcInfo( m_display, m_res, m_res->crtcs[ i ] ) );
-    }
-    return monitors;
-}
-
-void slop::XEngine::freeCRTCS( std::vector<XRRCrtcInfo*> monitors ) {
-    for ( unsigned int i=0;i<monitors.size();i++ ) {
-        XRRFreeCrtcInfo( monitors[ i ] );
-    }
-}
-#endif // OPENGL_ENABLED
-
-bool slop::XEngine::keyPressed( KeySym key ) {
-    KeyCode keycode = XKeysymToKeycode( m_display, key );
-    if ( keycode != 0 ) {
-        // Get the whole keyboard state
-        char keys[32];
-        XQueryKeymap( m_display, keys );
-        // Check our keycode
-        return ( keys[ keycode / 8 ] & ( 1 << ( keycode % 8 ) ) ) != 0;
-    } else {
-        return false;
-    }
-}
-
-bool slop::XEngine::anyKeyPressed() {
-    if ( !m_good ) {
-        return false;
-    }
-    // Thanks to SFML for some reliable key state grabbing.
-    // Get the whole keyboard state
-    char keys[ 32 ];
-    XQueryKeymap( m_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;
-        }
-    }
-    return false;
-}
-
-int slop::XEngine::grabKeyboard() {
-    if ( !m_good ) {
-        return EXIT_FAILURE;
-    }
-    int err = XGrabKeyboard( m_display, m_root, False, GrabModeAsync, GrabModeAsync, CurrentTime );
-    if ( err != GrabSuccess ) {
-        fprintf( stderr, "Warning: Failed to grab X keyboard.\n" );
-        fprintf( stderr, "         This happens when something has already grabbed your keybaord.\n" );
-        fprintf( stderr, "         slop should still run properly though.\n" );
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
-}
-
-int slop::XEngine::releaseKeyboard() {
-    if ( !m_good ) {
-        return EXIT_FAILURE;
-    }
-    XUngrabKeyboard( m_display, CurrentTime );
-    return EXIT_SUCCESS;
-}
-
-void slop::XEngine::selectAllInputs( Window win, long event_mask) {
-    Window root, parent;
-    Window* children;
-    unsigned int nchildren;
-    XQueryTree( m_display, win, &root, &parent, &children, &nchildren );
-    for ( unsigned int i=0;i<nchildren;i++ ) {
-        XSelectInput( m_display, children[ i ], event_mask );
-        selectAllInputs( children[ i ], event_mask );
-    }
-    free( children );
-}
-
-// Grabs the cursor, be wary that setCursor changes the mouse masks.
-// waittime is how long grabCursor can repeatedly try to grab the cursor, if it fails to grab.
-// This is because tiling window managers like i3 grab the mouse while holding down certain keys,
-// while these certain keys also launch slop.
-int slop::XEngine::grabCursor( slop::CursorType type, double waittime ) {
-    if ( !m_good ) {
-        return EXIT_FAILURE;
-    }
-    int xfontcursor = makeCursor( type );
-    int err = XGrabPointer( m_display, m_root, True,
-                            PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
-                            GrabModeAsync, GrabModeAsync, None, xfontcursor, CurrentTime );
-    double accumulationtime = 0;
-    int timestep = 10000; // in microseconds
-    while ( err != GrabSuccess && accumulationtime < waittime ) {
-        err = XGrabPointer( m_display, m_root, True,
-                            PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
-                            GrabModeAsync, GrabModeAsync, None, xfontcursor, CurrentTime );
-        usleep( timestep );
-        accumulationtime += double( timestep/1000000.f );
-    }
-    if ( err != GrabSuccess ) {
-        fprintf( stderr, "Error: Failed to grab X cursor.\n" );
-        switch( err ) {
-            case 1:
-                fprintf( stderr, "       The cursor is already grabbed by another application.\n" );
-                break;
-            case 2:
-                fprintf( stderr, "       The cursor grab was initiated at an invalid time (in the past?) .\n" );
-                break;
-            case 3:
-                fprintf( stderr, "       The cursor is not viewable or outside of the bounds of the root window.\n" );
-                break;
-            case 4:
-                fprintf( stderr, "       The grab is frozen already by an active grab by another application.\n" );
-                break;
-            default:
-                break;
-        }
-        fprintf( stderr, "       This can be caused by launching slop weirdly.\n" );
-        return EXIT_FAILURE;
-    }
-    // Quickly set the mouse position so we don't have to worry about x11 generating an event.
-    Window root, child;
-    int mx, my;
-    int wx, wy;
-    unsigned int mask;
-    XQueryPointer( m_display, m_root, &root, &child, &mx, &my, &wx, &wy, &mask );
-    m_mousex = mx;
-    m_mousey = my;
-
-    // Get the deepest available window.
-    Window test = child;
-    while( test ) {
-        child = test;
-        XQueryPointer( m_display, child, &root, &test, &mx, &my, &wx, &wy, &mask );
-    }
-    m_hoverWindow = child;
-    return EXIT_SUCCESS;
-}
-
-int slop::XEngine::releaseCursor() {
-    if ( !m_good ) {
-        return EXIT_FAILURE;
-    }
-    XUngrabPointer( m_display, CurrentTime );
-    return EXIT_SUCCESS;
-}
-
-void slop::XEngine::tick() {
-    if ( !m_good ) {
-        return;
-    }
-    XEvent event;
-    while ( XPending( m_display ) ) {
-        XNextEvent( m_display, &event );
-        switch ( event.type ) {
-            case MotionNotify: {
-                m_mousex = event.xmotion.x;
-                m_mousey = event.xmotion.y;
-                break;
-            }
-            case ButtonPress: {
-                // Our pitiful mouse manager--
-                if ( m_mouse.size() > event.xbutton.button ) {
-                    m_mouse.at( event.xbutton.button ) = true;
-                } else {
-                    m_mouse.resize( event.xbutton.button+2, false );
-                    m_mouse.at( event.xbutton.button ) = true;
-                }
-                break;
-            }
-            case EnterNotify: {
-                if ( event.xcrossing.subwindow != None ) {
-                    m_hoverWindow = event.xcrossing.subwindow;
-                } else {
-                    m_hoverWindow = event.xcrossing.window;
-                }
-                break;
-            }
-            case ButtonRelease: {
-                if ( m_mouse.size() > event.xbutton.button ) {
-                    m_mouse.at( event.xbutton.button ) = false;
-                } else {
-                    m_mouse.resize( event.xbutton.button+2, false );
-                    m_mouse.at( event.xbutton.button ) = false;
-                }
-                break;
-            }
-            default: break;
-        }
-    }
-}
-
-// This converts an enum into a preallocated cursor, the cursor will automatically deallocate itself on ~XEngine
-Cursor slop::XEngine::makeCursor( slop::CursorType type ) {
-    int xfontcursor;
-    switch ( type ) {
-        default:
-        case Left:                  xfontcursor = XC_left_ptr; break;
-        case Crosshair:             xfontcursor = XC_crosshair; break;
-        case Cross:                 xfontcursor = XC_cross; break;
-        case UpperLeftCorner:       xfontcursor = XC_ul_angle; break;
-        case UpperRightCorner:      xfontcursor = XC_ur_angle; break;
-        case LowerLeftCorner:       xfontcursor = XC_ll_angle; break;
-        case LowerRightCorner:      xfontcursor = XC_lr_angle; break;
-        case Dot:                   xfontcursor = XC_dot; break;
-        case Box:                   xfontcursor = 40; break;
-    }
-    Cursor newcursor = 0;
-    if ( m_cursors.size() > (unsigned int)xfontcursor ) {
-        newcursor = m_cursors.at( xfontcursor );
-    }
-    if ( !newcursor ) {
-        newcursor = XCreateFontCursor( m_display, xfontcursor );
-        m_cursors.resize( xfontcursor+2, 0 );
-        m_cursors.at( xfontcursor ) = newcursor;
-    }
-    return newcursor;
-}
-
-slop::CursorType slop::XEngine::getCursor() {
-    if ( m_currentCursor ) {
-        return m_currentCursor;
-    } else {
-        return slop::Left;
-    }
-}
-
-// Swaps out the current cursor, bewary that XChangeActivePointerGrab also resets masks, so if you change the mouse masks on grab you need to change them here too.
-void slop::XEngine::setCursor( slop::CursorType type ) {
-    if ( !m_good ) {
-        return;
-    }
-    m_currentCursor = type;
-    Cursor xfontcursor = makeCursor( type );
-    XChangeActivePointerGrab( m_display,
-                              PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
-                              xfontcursor, CurrentTime );
-}
-
-void slop::WindowRectangle::applyPadding( int padding ) {
-    if ( (int)m_width + padding*2 >= 0 ) {
-        m_x -= padding;
-        m_width += padding*2;
-    }
-    if ( (int)m_height + padding*2 >= 0 ) {
-        m_y -= padding;
-        m_height += padding*2;
-    }
-}
-
-Window slop::WindowRectangle::getWindow() {
-    return m_window;
-}
-
-void slop::WindowRectangle::applyMinMaxSize( unsigned int minimumsize, unsigned int maximumsize ) {
-    if ( minimumsize > maximumsize && maximumsize > 0 ) {
-        fprintf( stderr, "Error: minimumsize is greater than maximumsize.\n" );
-        exit( 1 );
-    }
-    if ( m_width < minimumsize ) {
-        int diff = minimumsize - m_width;
-        m_width = minimumsize;
-        m_x -= diff/2;
-    }
-    if ( m_height < minimumsize ) {
-        int diff = minimumsize - m_height;
-        m_height = minimumsize;
-        m_y -= diff/2;
-    }
-    if ( maximumsize > 0 ) {
-        if ( m_width > maximumsize ) {
-            int diff = m_width;
-            m_width = maximumsize;
-            // Center in the center of the window
-            m_x += diff/2 - maximumsize/2;
-        }
-        if ( m_height > maximumsize ) {
-            int diff = m_height;
-            m_height = maximumsize;
-            // Center in the center of the window
-            m_y += diff/2 - maximumsize/2;
-        }
-    }
-}
-
-void slop::WindowRectangle::setGeometry( Window win, bool decorations ) {
-    if ( decorations ) {
-        Window root, parent, test, junk;
-        Window* childlist;
-        unsigned int ujunk;
-        // Try to find the actual decorations.
-        test = win;
-        int status = XQueryTree( xengine->m_display, test, &root, &parent, &childlist, &ujunk);
-        free( childlist );
-        while( parent != root ) {
-            if ( !parent || !status ) {
-                break;
-            }
-            test = parent;
-            status = XQueryTree( xengine->m_display, test, &root, &parent, &childlist, &ujunk);
-            free( childlist );
-        }
-        // test contains the window we're screenshotting.
-        m_window = test;
-        // Once found, proceed normally.
-        if ( test && parent == root && status ) {
-            XWindowAttributes attr;
-            XGetWindowAttributes( xengine->m_display, test, &attr );
-            m_width = attr.width;
-            m_height = attr.height;
-            m_border = attr.border_width;
-            XTranslateCoordinates( xengine->m_display, test, attr.root, -attr.border_width, -attr.border_width, &(m_x), &(m_y), &junk );
-            // We make sure we include borders, since we want decorations.
-            m_width += m_border * 2;
-            m_height += m_border * 2;
-        }
-        return;
-    }
-    Window junk;
-    // Now here we should be able to just use whatever we get.
-    XWindowAttributes attr;
-    // We use XGetWindowAttributes to know our root window.
-    XGetWindowAttributes( xengine->m_display, win, &attr );
-    //m_x = attr.x;
-    //m_y = attr.y;
-    m_width = attr.width;
-    m_height = attr.height;
-    m_border = attr.border_width;
-    XTranslateCoordinates( xengine->m_display, win, attr.root, -attr.border_width, -attr.border_width, &(m_x), &(m_y), &junk );
-    m_window = win;
+X11::~X11() {
+    XCloseDisplay( display );
 }

src/x.hpp

@@ -1,4 +1,4 @@
-/* x.hpp: Handles starting and managing X.
+/* x.hpp: initializes x11
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -18,98 +18,34 @@
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef IS_X_H_
-#define IS_X_H_
-
-#include <unistd.h>
+#ifndef N_X_H_
+#define N_X_H_
 
+#include <iostream>
 #include <X11/Xlib.h>
-#include <X11/cursorfont.h>
-#include <X11/extensions/shape.h>
-#include <X11/extensions/Xrandr.h>
-
-#include <stdlib.h>
-#include <cstring>
-#include <cstdlib>
-#include <cmath>
-#include <cstdio>
 #include <string>
-#include <vector>
+#include <sstream>
+#include <stdexcept>
+#include <X11/Xatom.h>
+#include <glm/glm.hpp>
 
 namespace slop {
 
-enum CursorType {
-    Left,
-    Crosshair,
-    Cross,
-    UpperLeftCorner,
-    UpperRightCorner,
-    LowerRightCorner,
-    LowerLeftCorner,
-    Dot,
-    Box
-};
+glm::vec4 getWindowGeometry( Window win, bool removeDecoration );
 
-class WindowRectangle {
+class X11 {
 public:
-    int          m_x;
-    int          m_y;
-    unsigned int m_width;
-    unsigned int m_height;
-    unsigned int m_border;
-    Window       m_window;
-    bool         m_decorations;
-    Window       getWindow();
-    void         setGeometry( Window win, bool decorations );
-    void         applyPadding( int padding );
-    void         applyMinMaxSize( unsigned int minimumsize, unsigned int maximumsize );
+    bool hasCompositor();
+    X11( std::string displayName );
+    ~X11();
+    Display* display;
+    Visual* visual;
+    Screen* screen;
+    Window root;
 };
 
-class XEngine {
-public:
-                        XEngine();
-                        ~XEngine();
-    int                 init( std::string display );
-    void                tick();
-    int                 grabCursor( slop::CursorType type, double waittime );
-    int                 grabKeyboard();
-    bool                anyKeyPressed();
-    bool                keyPressed( KeySym key );
-    int                 releaseCursor();
-    int                 releaseKeyboard();
-    void                setCursor( slop::CursorType type );
-    slop::CursorType    getCursor();
-    void                drawRect( int x, int y, unsigned int w, unsigned int h );
-    unsigned int        getWidth();
-    unsigned int        getHeight();
-#ifdef OPENGL_ENABLED
-    std::vector<XRRCrtcInfo*>        getCRTCS();
-    void                freeCRTCS( std::vector<XRRCrtcInfo*> monitors );
-#endif // OPENGL_ENABLED
-    int                 m_mousex;
-    int                 m_mousey;
-    Display*            m_display;
-    Visual*             m_visual;
-    Screen*             m_screen;
-    Colormap            m_colormap;
-    Window              m_root;
-    Window              m_hoverWindow;
-    std::vector<bool>   m_mouse;
-    bool                mouseDown( unsigned int button );
-    bool                m_keypressed;
-    XRRScreenResources* m_res;
-private:
-    slop::CursorType    m_currentCursor;
-    bool                m_good;
-    std::vector<Cursor> m_cursors;
-    Cursor              makeCursor( slop::CursorType type );
-    void                selectAllInputs( Window win, long event_mask);
-};
-
-int XEngineErrorHandler( Display* dpy, XErrorEvent* event );
+extern X11* x11;
 
 }
 
-extern slop::XEngine* xengine;
-
-#endif // IS_X_H_
+#endif

src/xselectrectangle.cpp

@@ -1,189 +0,0 @@
-/* xselectrectangle.cpp: Handles creating rectangles on the screen in pure X11.
- *
- * 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/>.
- */
-#include "xselectrectangle.hpp"
-
-static Bool isDestroyNotify( Display* dpy, XEvent* ev, XPointer win ) {
-    return ev->type == DestroyNotify && ev->xdestroywindow.window == *((Window*)win);
-}
-
-slop::XSelectRectangle::~XSelectRectangle() {
-    if ( m_window == None ) {
-        return;
-    }
-    // Try to erase the window before destroying it.
-    XSetWindowBackground( xengine->m_display, m_window, 0 );
-    XClearWindow( xengine->m_display, m_window );
-    // Sleep for 0.1 seconds in hope that the rectangle was erased.
-    usleep( 10000 );
-    // Free up our color.
-    XFreeColors( xengine->m_display, xengine->m_colormap, &m_color.pixel, 1, 0 );
-    XDestroyWindow( xengine->m_display, m_window );
-    XEvent event;
-    // Block until the window is actually completely removed.
-    XIfEvent( xengine->m_display, &event, &isDestroyNotify, (XPointer)&m_window );
-    // Sleep for 0.1 seconds in hope that the screen actually cleared the window.
-    usleep( 10000 );
-}
-
-slop::XSelectRectangle::XSelectRectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a ) {
-    m_x = std::min( sx, ex );
-    m_y = std::min( sy, ey );
-    m_width = std::max( sx, ex ) - m_x;
-    m_height = std::max( sy, ey ) - m_y;
-    m_border = border;
-    m_window = None;
-    m_highlight = highlight;
-
-    // If we don't have a border, we don't exist, so just die.
-    if ( m_border == 0 ) {
-        return;
-    }
-
-    if ( m_highlight ) {
-        m_border = 0;
-    }
-
-    m_color = convertColor( r, g, b );
-    XSetWindowAttributes attributes;
-    // Set up the window so it's our color 
-    attributes.background_pixel = m_color.pixel;
-    // 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 = CWBackPixel | CWOverrideRedirect | CWEventMask;
-
-    // Create the window
-    m_window = XCreateWindow( xengine->m_display, xengine->m_root, 0, 0, xengine->getWidth(), xengine->getHeight(),
-                              0, CopyFromParent, InputOutput,
-                              CopyFromParent, valueMask, &attributes );
-
-
-    if ( a < 1 ) {
-        // Change the window opacity
-        unsigned int cardinal_alpha = (unsigned int) (a * (unsigned int)-1) ;
-        XChangeProperty( xengine->m_display, m_window, XInternAtom( xengine->m_display, "_NET_WM_WINDOW_OPACITY", 0),
-                         XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&cardinal_alpha, 1 );
-    }
-
-    XClassHint classhints;
-    char name[] = "slop";
-    classhints.res_name = name;
-    classhints.res_class = name;
-    XSetClassHint( xengine->m_display, m_window, &classhints );
-
-    // Now punch a hole into it so it looks like a selection rectangle, but only if we're not highlighting.
-    if ( !m_highlight ) {
-        XRectangle rects[4];
-        // Left
-        rects[0].x = m_x-m_border;
-        rects[0].y = m_y-m_border;
-        rects[0].width = m_border;
-        rects[0].height = m_height+m_border*2;
-        // Top
-        rects[1].x = m_x;
-        rects[1].y = m_y-m_border;
-        rects[1].width = m_width+m_border;
-        rects[1].height = m_border;
-        // Right
-        rects[2].x = m_x+m_width;
-        rects[2].y = m_y-m_border;
-        rects[2].width = m_border;
-        rects[2].height = m_height+m_border*2;
-        // Bottom
-        rects[3].x = m_x;
-        rects[3].y = m_y+m_height;
-        rects[3].width = m_width+m_border;
-        rects[3].height = m_border;
-        XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, rects, 4, ShapeSet, 0);
-    } else {
-        XRectangle rect;
-        rect.x = m_x;
-        rect.y = m_y;
-        rect.width = m_width;
-        rect.height = m_height;
-        XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
-    }
-    // Make it so all input falls through
-    XRectangle rect;
-    rect.x = rect.y = rect.width = rect.height = 0;
-    XShapeCombineRectangles( xengine->m_display, m_window, ShapeInput, 0, 0, &rect, 1, ShapeSet, 0);
-    XMapWindow( xengine->m_display, m_window );
-}
-
-void slop::XSelectRectangle::setGeo( int sx, int sy, int ex, int ey ) {
-    int x = std::min( sx, ex );
-    int y = std::min( sy, ey );
-    int w = std::max( sx, ex ) - x;
-    int h = std::max( sy, ey ) - y;
-
-    // Only resize or move if we have to, because they're oddly expensive.
-    m_x = x;
-    m_y = y;
-    m_width = w;
-    m_height = h;
-    if ( m_border > 0 ) {
-        XRectangle rects[4];
-        // Left
-        rects[0].x = m_x-m_border;
-        rects[0].y = m_y-m_border;
-        rects[0].width = m_border;
-        rects[0].height = m_height+m_border*2;
-        // Top
-        rects[1].x = m_x;
-        rects[1].y = m_y-m_border;
-        rects[1].width = m_width+m_border;
-        rects[1].height = m_border;
-        // Right
-        rects[2].x = m_x+m_width;
-        rects[2].y = m_y-m_border;
-        rects[2].width = m_border;
-        rects[2].height = m_height+m_border*2;
-        // Bottom
-        rects[3].x = m_x;
-        rects[3].y = m_y+m_height;
-        rects[3].width = m_width+m_border;
-        rects[3].height = m_border;
-        XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, rects, 4, ShapeSet, 0);
-    } else {
-        XRectangle rect;
-        rect.x = m_x;
-        rect.y = m_y;
-        rect.width = m_width;
-        rect.height = m_height;
-        XShapeCombineRectangles( xengine->m_display, m_window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
-    }
-}
-
-XColor slop::XSelectRectangle::convertColor( float r, float g, float b ) {
-    // Convert float colors to shorts.
-    short red   = short( floor( r * 65535.f ) );
-    short green = short( floor( g * 65535.f ) );
-    short blue  = short( floor( b * 65535.f ) );
-    XColor color;
-    color.red = red;
-    color.green = green;
-    color.blue = blue;
-    int err = XAllocColor( xengine->m_display, xengine->m_colormap, &color );
-    if ( err == BadColor ) {
-        fprintf( stderr, "Couldn't allocate color of value %f,%f,%f!\n", r, g, b );
-    }
-    return color;
-}

src/xshaperectangle.cpp

@@ -0,0 +1,141 @@
+#include "xshaperectangle.hpp"
+
+slop::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;
+    this->highlight = highlight;
+    this->alpha = color.a;
+    // 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);
+
+    XSetWindowAttributes attributes;
+    // Set up the window so it's our color 
+    attributes.background_pixel = this->color.pixel;
+    // 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 = CWBackPixel | CWOverrideRedirect | CWEventMask;
+    // Create the window
+    window = XCreateWindow( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ),
+                              0, CopyFromParent, InputOutput,
+                              CopyFromParent, valueMask, &attributes );
+    if ( alpha < 1 ) {
+        // Change the window opacity
+        unsigned int cardinal_alpha = (unsigned int) (alpha * (unsigned int)-1) ;
+        XChangeProperty( x11->display, window, XInternAtom( x11->display, "_NET_WM_WINDOW_OPACITY", 0),
+                         XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&cardinal_alpha, 1 );
+    }
+    // Set the class hint, and title to "slop"
+    XClassHint classhints;
+    char name[] = "slop";
+    classhints.res_name = name;
+    classhints.res_class = name;
+    XSetClassHint( x11->display, window, &classhints );
+    // Now punch a hole into it so it looks like a selection rectangle, but only if we're not highlighting.
+    generateHoles();
+    createdWindow = false;
+}
+
+void slop::XShapeRectangle::createWindow() {
+    if ( createdWindow ) {
+        return;
+    }
+	XMapWindow( x11->display, window );
+    createdWindow = true;
+}
+
+void slop::XShapeRectangle::generateHoles() {
+    if ( !highlight ) {
+        XRectangle rects[4];
+        // Left
+        rects[0].x = oul.x;
+        rects[0].y = obl.y;
+        rects[0].width = border;
+        rects[0].height = oul.y-obl.y;
+        // Top
+        rects[1].x = ul.x;
+        rects[1].y = obl.y;
+        rects[1].width = ur.x-ul.x;
+        rects[1].height = border;
+        // Right
+        rects[2].x = ur.x;
+        rects[2].y = obr.y;
+        rects[2].width = border;
+        rects[2].height = our.y - obr.y;
+        // Bottom
+        rects[3].x = bl.x;
+        rects[3].y = ul.y;
+        rects[3].width = br.x-bl.x;
+        rects[3].height = border;
+        XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, rects, 4, ShapeSet, 0);
+        return;
+    }
+    XRectangle rect;
+    rect.x = oul.x;
+    rect.y = obl.y;
+    rect.width = our.x-oul.x;
+    rect.height = oul.y-obl.y;
+    XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
+}
+
+void slop::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 ) ) ;
+    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);
+    generateHoles();
+}
+
+slop::XShapeRectangle::~XShapeRectangle() {
+}
+
+void slop::XShapeRectangle::draw( glm::mat4& matrix ) {
+    // We don't want to be visible until we're asked to draw.
+    createWindow();
+}
+
+glm::vec4 slop::XShapeRectangle::getRect() {
+    return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
+}
+
+XColor slop::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 ) );
+    short blue  = short( floor( color.b * 65535.f ) );
+    XColor xc;
+    xc.red = red;
+    xc.green = green;
+    xc.blue = blue;
+    int err = XAllocColor( x11->display, DefaultColormap( x11->display, XScreenNumberOfScreen( x11->screen ) ), &xc );
+    if ( err == BadColor ) {
+        throw new std::runtime_error(std::string("Couldn't allocate a color"));
+    }
+    return xc;
+}

src/xselectrectangle.hpp → src/xshaperectangle.hpp

@@ -1,4 +1,4 @@
-/* xselectrectangle.hpp: Handles creating rectangles on the screen in pure X11.
+/* xshaperectangle.hpp: A rectangle that doesn't use OpenGL to function.
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *
@@ -18,39 +18,46 @@
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef IS_X_SELECT_RECTANGLE_H_
-#define IS_X_SELECT_RECTANGLE_H_
-
-#include "x.hpp"
-#include "selectrectangle.hpp"
-
-#include <unistd.h>
+#ifndef N_XSHAPERECTANGLE_H_
+#define N_XSHAPERECTANGLE_H_
 
+#include <iostream>
+#include <glm/glm.hpp>
+#include <vector>
 #include <X11/Xlib.h>
-#include <X11/extensions/shape.h>
 #include <X11/Xatom.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/shape.h>
 
-#include <cstdlib>
-#include <cmath>
-#include <cstdio>
-#include <string>
-#include <vector>
+#include "x.hpp"
+#include "rectangle.hpp"
 
 namespace slop {
 
-class XSelectRectangle: public SelectRectangle {
-public:
-            XSelectRectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a );
-            ~XSelectRectangle();
-    void    setPos( int x, int y );
-    void    setDim( int w, int h );
-    void    setGeo( int x, int y, int w, int h );
-    XColor  m_color;
+class XShapeRectangle : public Rectangle {
 private:
-    XColor  convertColor( float r, float g, float b );
-    void    constrain( int w, int h );
+    glm::vec2 ul, oul;
+    glm::vec2 bl, obl;
+    glm::vec2 ur, our;
+    glm::vec2 br, obr;
+    bool createdWindow;
+    bool highlight;
+    float border;
+    float padding;
+    XColor color;
+    float alpha;
+    XColor convertColor( glm::vec4 color );
+    void generateHoles();
+    void createWindow();
+public:
+    Window window;
+    glm::vec4 getRect();
+    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);
 };
 
 }
 
-#endif // IS_X_SELECT_RECTANGLE_H_
+#endif // N_XSHAPERECTANGLE_H_