moved over wayland port

CMakeLists.txt

@@ -1,172 +1,72 @@
-cmake_minimum_required( VERSION 2.8 )
+#Change this if you need to target a specific CMake version
+cmake_minimum_required(VERSION 3.1)
 
-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" )
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)" FORCE)
 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()
-
-if( NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE )
-   set( CMAKE_BUILD_TYPE RelWithDebInfo )
+if( NOT CMAKE_INSTALL_PREFIX )
+    set( CMAKE_INSTALL_PREFIX "/usr" )
 endif()
 
-# 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." )
+if( NOT SHADER_PREFIX )
+    set( SHADER_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "The path where slop thinks it resides in, so that it can find the shaders. This is not necessarily the CMAKE_INSTALL_PREFIX. For example if the shaders will exist in /usr/share/slop-wayland, SHADER_PREFIX should be \"/usr\"." )
 endif()
 
-# 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()
+project(slop-wayland)
 
-# 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" )
-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()
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED on)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall -Wno-missing-braces")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/")
 
-# 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" )
+include_directories("${PROJECT_BINARY_DIR}")
 
-# 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" )
+# Define sources and executable
+set(EXECUTABLE_NAME "slop-wayland")
 
-# Sources
-if( CMAKE_OPENGL_SUPPORT )
-    set( source
-         src/cmdline.c
-         src/selectrectangle.cpp
-         src/glselectrectangle.cpp
-         src/shader.cpp
+set( source
+         src/wayland.cpp
+         src/window.cpp
+         src/mouse.cpp
+         src/keyboard.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/options.cpp
+         src/gl_core_3_3.c
+         src/shader.cpp
+         src/slopstates.cpp
+         src/slop.cpp
+         src/rectangle.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 )
+add_executable(${EXECUTABLE_NAME} ${source})
 
-set( CMAKE_CXX_FLAGS
-     "${CMAKE_CXX_FLAGS} ${CMAKE_IMLIB2_CXX_FLAGS}" )
 
-# Includes
-include_directories( "${X11_INCLUDE_DIR}"
-                     "${XEXT_INCLUDE_DIR}" )
+# Detect and add SFML
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" )
+#Find any version 2.X of SFML
+#See the FindSFML.cmake file for additional details and instructions
+find_package(Wayland REQUIRED)
+find_package(EGL REQUIRED)
+find_package(OpenGL REQUIRED)
+find_package(GLM REQUIRED)
 
-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} )
-endif()
+include_directories(${WAYLAND_CLIENT_INCLUDE_DIR}
+                    ${WAYLAND_CURSOR_INCLUDE_DIR}
+                    ${WAYLAND_EGL_INCLUDE_DIR}
+                    ${EGL_INCLUDE_DIR}
+                    ${GLM_INCLUDE_DIR}
+                    ${OPENGL_INCLUDE_DIR})
 
-# 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()
+target_link_libraries(${EXECUTABLE_NAME} ${WAYLAND_CLIENT_LIBRARIES}
+                      ${WAYLAND_CURSOR_LIBRARIES}
+                      ${WAYLAND_EGL_LIBRARIES}
+                      ${EGL_LIBRARIES}
+                      ${OPENGL_LIBRARIES})
 
+# Install targets
+install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
+install( DIRECTORY "${CMAKE_SOURCE_DIR}/share" DESTINATION "${CMAKE_INSTALL_PREFIX}" )
 
-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()
+add_definitions(-DSHADER_PREFIX="${SHADER_PREFIX}")

README.md

@@ -1,220 +0,0 @@
-# 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.
-
-## 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.
-* 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 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.
-
-## Practical applications
-slop can be used to create a video recording script in only two lines of code.
-```bash
-#!/bin/bash
-eval $(slop)
-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)
-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:
-![scrotbad](http://farmpolice.com/content/images/2014-10-14-12:08:24.png)
-![slopgood](http://farmpolice.com/content/images/2014-10-14-12:14:51.png)
-
-You can see scrot leaves garbage lines over the things you're trying to screenshot!
-While slop not only looks nicer, it's impossible for it to end up in screenshots or recordings because it waits for DestroyNotify events before completely shutting down. Only after the window is completely destroyed can anything take a screenshot.
-
-## how to install
-
-### Install using your Package Manager (Preferred)
-
-* [Arch Linux: community/slop](https://www.archlinux.org/packages/community/x86_64/slop/)
-* [Void Linux: slop](https://github.com/voidlinux/void-packages/blob/24ac22af44018e2598047e5ef7fd3522efa79db5/srcpkgs/slop/template)
-* [FreeBSD: x11/slop](http://www.freshports.org/x11/slop/)
-* [OpenBSD: graphics/slop](http://openports.se/graphics/slop)
-* [CRUX: 6c37/slop](https://github.com/6c37/crux-ports/tree/3.2/slop)
-* [Gentoo: x11-misc/slop](https://packages.gentoo.org/packages/x11-misc/slop)
-* [GNU Guix: slop](https://www.gnu.org/software/guix/packages/#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.*
-
-```bash
-git clone https://github.com/naelstrof/slop.git
-cd slop
-cmake -DCMAKE_OPENGL_SUPPORT=true ./
-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.
-```

cmakemodules/FindGLX.cmake

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

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/FindXExt.cmake

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

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/FindEGL.cmake

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

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

modules/FindWayland.cmake

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

share/slop-wayland/simple.frag

@@ -0,0 +1,9 @@
+#version 130
+
+uniform vec4 color;
+out vec4 outColor;
+
+void main()
+{
+    outColor = color;
+}

share/slop-wayland/simple.vert

@@ -0,0 +1,9 @@
+#version 130
+
+in vec2 position;
+uniform mat4 projection;
+
+void main()
+{
+    gl_Position = projection*vec4(position,0,1);
+}

share/slop-wayland/textured.frag

@@ -0,0 +1,13 @@
+#version 130
+
+uniform sampler2D texture;
+
+varying vec2 uvCoord;
+
+out vec4 outColor;
+
+void main()
+{
+    outColor = texture2D( texture, uvCoord );
+}
+

share/slop/cross.vert → share/slop-wayland/textured.vert

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

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/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);
-}

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,84 @@
 #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 );
-
-        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 );
-        }
-
-        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 );
-        }
-        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!" );
-    }
-}
-
-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;
-}
-
-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::unbind() {
-    if ( GLEW_VERSION_3_0 ) {
-        glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-    } else if ( GLEW_EXT_framebuffer_object ) {
-        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
-    }
-}
-
-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();
-    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;
-    }
+Framebuffer::Framebuffer( int w, int h ) {
+    shader = new Shader( "textured.vert", "textured.frag" );
+    glGenFramebuffers( 1, &fbuffer );
+    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
+    glGenTextures(1, &image);
+    glBindTexture(GL_TEXTURE_2D, image);
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+    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;
-    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 ) );
+
+    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 ) );
 
-    glGenBuffers( 2, m_buffers );
-    glBindBuffer( GL_ARRAY_BUFFER, m_buffers[0] );
+    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, m_buffers[1] );
+    glBindBuffer( GL_ARRAY_BUFFER, buffers[1] );
     glBufferData( GL_ARRAY_BUFFER, uvs.size() * sizeof( glm::vec2 ), &uvs[0], GL_STATIC_DRAW );
-    generatedBuffers = true;
+    vertCount = verts.size();
 }
 
-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 Framebuffer::setShader( std::string name ) {
+    delete shader;
+    shader = new Shader( name + ".vert", name + ".frag" );
 }
 
-void slop::Framebuffer::draw( float time, unsigned int desktop ) {
-    if ( !( m_flags & color ) ) {
-        return;
-    }
+Framebuffer::~Framebuffer() {
+    glDeleteTextures(1, &image);
+    glDeleteFramebuffers(1,&fbuffer);
+    glDeleteBuffers(2,buffers);
+    delete shader;
+}
 
-    generateBuffers();
+void 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);
+}
 
-    //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 );
+void Framebuffer::bind() {
+    glBindFramebuffer( GL_FRAMEBUFFER, fbuffer );
+}
 
-    glActiveTexture(GL_TEXTURE0 + 0);
-    glBindTexture( GL_TEXTURE_2D, m_texture );
-    glActiveTexture(GL_TEXTURE0 + 1);
-    glBindTexture( GL_TEXTURE_2D, desktop );
-    glActiveTexture(GL_TEXTURE0 + 0);
+void Framebuffer::unbind() {
+    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+}
+
+void 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,28 @@
-#ifndef IS_FRAMEBUFFER_H_
-#define IS_FRAMEBUFFER_H_
+#ifndef N_FRAMEBUFFER_H_
+#define N_FRAMEBUFFER_H_
 
-#include <GL/glew.h>
-#include <GL/gl.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/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,58 @@
+#include "keyboard.hpp"
+
+static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {
+}
+
+static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface, struct wl_array *keys) {
+}
+
+static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {
+}
+
+static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t state) {
+    Keyboard* kb = (Keyboard*)data;
+    kb->setKey( key, state );
+}
+
+static void keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {
+}
+
+static const struct wl_keyboard_listener keyboard_listener = {
+    keyboard_handle_keymap,
+    keyboard_handle_enter,
+    keyboard_handle_leave,
+    keyboard_handle_key,
+    keyboard_handle_modifiers,
+};
+
+Keyboard::Keyboard(Wayland* wayland) {
+    wl_keyboard_add_listener(wl_seat_get_keyboard(wayland->seat), &keyboard_listener, this);
+}
+
+void Keyboard::setKey( int key, int state ) {
+    for (unsigned int i=0;i<keys.size();i++ ) {
+        if ( keys[i].x == key ) {
+            keys[i].y = state;
+            return;
+        }
+    }
+    keys.push_back(glm::ivec2(key,state));
+}
+
+int Keyboard::getKey( int button ) {
+    for (unsigned int i=0;i<keys.size();i++ ) {
+        if ( keys[i].x == button ) {
+            return keys[i].y;
+        }
+    }
+    return 0;
+}
+
+bool Keyboard::anyKeyDown() {
+    for ( glm::ivec2 combo : keys ) {
+        if ( combo.y == 1 ) {
+            return true;
+        }
+    }
+    return false;
+}

src/keyboard.hpp

@@ -0,0 +1,22 @@
+#ifndef N_KEYBOARD_H_
+#define N_KEYBOARD_H_
+
+
+#include <glm/glm.hpp>
+#include <wayland-client.h>
+#include <vector>
+#include "wayland.hpp"
+
+class Keyboard {
+private:
+    std::vector<glm::ivec2> keys;
+public:
+    Keyboard( Wayland* wayland );
+    void setKey( int key, int state );
+    int getKey( int key );
+    bool anyKeyDown();
+};
+
+extern Keyboard* keyboard;
+
+#endif // N_KEYBOARD_H_

src/main.cpp

@@ -1,570 +1,94 @@
-/* main.cpp
- *
- * 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 <unistd.h>
-#include <time.h>
-#include <cstdio>
+#include <iostream>
 #include <sstream>
-#include <stdexcept>
+#include "slop.hpp"
+#include "options.hpp"
 
-#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"
-
-// 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
-}
-
-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;
-}
-
-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;
+SlopOptions* getOptions( Options& options ) {
+    SlopOptions* foo = new SlopOptions();
+    options.getFloat("bordersize", 'b', foo->borderSize);
+    options.getFloat("padding", 'p', foo->padding);
+    glm::vec4 color = glm::vec4( foo->r, foo->g, foo->b, foo->a );
+    options.getColor("color", 'c', color);
+    foo->r = color.r;
+    foo->g = color.g;
+    foo->b = color.b;
+    foo->a = color.a;
+    options.getBool("highlight", 'h', foo->highlight);
+    return foo;
 }
 
-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;
-        }
-    }
-    // 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;
-}
-
-// 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;
+std::string formatOutput( std::string input, SlopSelection selection ) {
+    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 '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 '%': output << "%"; break;
+                default: throw new std::invalid_argument( std::string()+"Expected x, y, w, h, g, or % after % in format. Got `" + input[i+1] + "`." );
+             }
+            i++;
+            continue;
         }
+        output << input[i];
     }
-    if ( xengine->keyPressed( key ) && curtime - *time > repeatdelay ) {
-        return true;
-    }
-    return false;
+    return output.str();
 }
 
 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 );
+    // 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;
+    // 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);
+    std::string format;
+    bool gotFormat = options.getString("format", 'f', format);
+    if ( gotFormat ) {
+        formatOutput( format, selection );
     }
-    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;
-    }
-    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;
-            }
-        }
-        // 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 );
-    }
-    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;
-    }
-    return EXIT_SUCCESS;
+
+    // Finally we do the real selection.
+    bool cancelled = false;
+    selection = SlopSelect(parsedOptions, &cancelled);
+    
+    // Here we're done with the parsed option data.
+    delete parsedOptions;
+    // We know if we cancelled or not
+    if ( cancelled ) {
+        std::cerr << "Selection was cancelled by keystroke or right-click.\n";
+        return 1;
+    }
+    // If we recieved a format option, we output the specified output.
+    if ( gotFormat ) {
+        std::cout << formatOutput( format, selection );
+        return 0;
+    }
+    // Otherwise we default to an `eval` compatible format.
+    std::cout << formatOutput( "X=%x\nY=%y\nW=%w\nH=%h\nG=%g\n", selection );
+    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,111 @@
+#include "mouse.hpp"
+
+static void pointer_handle_enter(void *data, struct wl_pointer *pointer,
+		                         uint32_t serial, struct wl_surface *surface,
+		                         wl_fixed_t sx_w, wl_fixed_t sy_w) {
+    Mouse* m = (Mouse*)data;
+	float sx = wl_fixed_to_double(sx_w);
+	float sy = wl_fixed_to_double(sy_w);
+    m->setMousePos( sx, sy );
+    m->serial = serial;
+    m->pointer = pointer;
+    struct wl_cursor_image *image = m->cursor->images[0];
+    wl_pointer_set_cursor(pointer, serial, m->surface, image->hotspot_x, image->hotspot_y);
+}
+
+static void pointer_handle_leave(void *data, struct wl_pointer *pointer,
+		                         uint32_t serial, struct wl_surface *surface) {
+}
+
+static void pointer_handle_motion(void *data, struct wl_pointer *pointer,
+		                          uint32_t time, wl_fixed_t sx_w, wl_fixed_t sy_w)
+{
+    Mouse* m = (Mouse*)data;
+	float sx = wl_fixed_to_double(sx_w);
+	float sy = wl_fixed_to_double(sy_w);
+    m->pointer = pointer;
+    m->setMousePos( sx, sy );
+}
+
+static void pointer_handle_button(void *data, struct wl_pointer *pointer, uint32_t serial,
+                                  uint32_t time, uint32_t button, uint32_t state_w) {
+    Mouse* m = (Mouse*)data;
+    m->pointer = pointer;
+    m->setButton( button, state_w );
+}
+
+static void pointer_handle_axis(void *data, struct wl_pointer *pointer,
+		                        uint32_t time, uint32_t axis, wl_fixed_t value) {
+}
+
+static const struct wl_pointer_listener pointer_listener = {
+	pointer_handle_enter,
+	pointer_handle_leave,
+	pointer_handle_motion,
+	pointer_handle_button,
+	pointer_handle_axis,
+};
+
+void Mouse::setButton( int button, int state ) {
+    for (unsigned int i=0;i<buttons.size();i++ ) {
+        if ( buttons[i].x == button ) {
+            buttons[i].y = state;
+            return;
+        }
+    }
+    buttons.push_back(glm::ivec2(button,state));
+}
+
+int Mouse::getButton( int button ) {
+    for (unsigned int i=0;i<buttons.size();i++ ) {
+        if ( buttons[i].x == button ) {
+            return buttons[i].y;
+        }
+    }
+    return 0;
+}
+
+void Mouse::setMousePos(float x, float y) {
+    this->x = x;
+    this->y = y;
+}
+
+glm::vec2 Mouse::getMousePos() {
+    return glm::vec2( x, y );
+}
+
+void Mouse::setCursor( std::string name ) {
+    if ( name == currentMouseCursor ) {
+        return;
+    }
+    // First we gotta delete the old mouse surface.
+    wl_surface_destroy( surface );
+
+    // Then we get the new cursor image.
+    cursor = wl_cursor_theme_get_cursor(theme, name.c_str());
+    struct wl_cursor_image *image = cursor->images[0];
+    struct wl_buffer *cursor_buf = wl_cursor_image_get_buffer(image);
+    
+    // Then we create the new surface
+    surface = wl_compositor_create_surface(wayland->compositor);
+    wl_surface_attach(surface, cursor_buf, 0, 0);
+    wl_surface_damage(surface, 0, 0, image->width, image->height);
+    wl_surface_commit(surface);
+
+    // Finally assign the surface as a pointer
+    wl_pointer_set_cursor(pointer, serial, surface, image->hotspot_x, image->hotspot_y);
+}
+
+Mouse::Mouse(Wayland* wayland) {
+    wl_pointer_add_listener(wl_seat_get_pointer(wayland->seat), &pointer_listener, this);
+    theme = wl_cursor_theme_load("default", 16, wayland->shm );
+    cursor = wl_cursor_theme_get_cursor(theme, "cross");
+    std::string currentMouseCursor = "cross";
+
+    surface = wl_compositor_create_surface(wayland->compositor);
+    struct wl_cursor_image *image = cursor->images[0];
+    struct wl_buffer *cursor_buf = wl_cursor_image_get_buffer(image);
+    wl_surface_attach(surface, cursor_buf, 0, 0);
+    wl_surface_damage(surface, 0, 0, image->width, image->height);
+    wl_surface_commit(surface);
+}

src/mouse.hpp

@@ -0,0 +1,32 @@
+#ifndef N_MOUSE_H_
+#define N_MOUSE_H_
+
+#include <wayland-client.h>
+#include <wayland-cursor.h>
+#include <vector>
+#include <glm/glm.hpp>
+#include "linux/input-event-codes.h"
+#include "wayland.hpp"
+
+class Mouse {
+private:
+    wl_cursor_theme* theme;
+    float x,y;
+    std::vector<glm::ivec2> buttons;
+    std::string currentMouseCursor;
+public:
+    wl_surface* surface;
+    wl_cursor* cursor;
+    wl_pointer* pointer;
+    int serial;
+    Mouse( Wayland* wayland );
+    void setMousePos( float x, float y );
+    void setCursor( std::string name );
+    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,199 @@
+#include "options.hpp"
+
+int Options::validateStringOption( int argc, char** argv, int argumentIndex ) {
+    std::string argument = argv[argumentIndex];
+    unsigned int index = 0;
+    while( index < validArgumentCount ) {
+        std::string& check = validStringArguments[index];
+        for( unsigned int i=0;i<check.length();i++ ) {
+            if ( check[i] != argument[i+2] ) {
+                break;
+            }
+            if ( i == check.length()-1 ) {
+                if ( !isFlagArgument[index] && argument.find("=") == std::string::npos ) {
+                    throw new std::invalid_argument("Expected `=` after " + arguments[i]);
+                }
+                if ( argument[i+3] != '=' ) {
+                    break;
+                }
+                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];
+    // If we're a flag, we take no arguments, nor do we allow = signs or whatever.
+    if ( isFlagArgument[validIndex] ) {
+        if ( argument != std::string()+"-"+validCharArguments[validIndex] ) {
+            throw new std::invalid_argument( std::string()+"Unexpected characters around flag `" + argument + "`." );
+            return 0;
+        } 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()+"-"+validCharArguments[validIndex] ) {
+        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 ( isFlagArgument[validIndex] ) {
+        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 < validArgumentCount ) {
+        char check = validCharArguments[index];
+        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?" );
+            }
+        }
+        if ( argument[0] == '-' && argument[1] == '-' ) {
+            i += validateStringOption( argc, argv, i );
+            continue;
+        }
+        i += validateCharOption( argc, argv, i );
+    }
+}
+
+Options::Options( int argc, char** argv ) {
+    validate( argc, argv );
+}
+
+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,37 @@
+#ifndef N_OPTIONS_H_
+#define N_OPTIONS_H_
+
+#include <iostream>
+#include <string>
+#include <exception>
+#include <stdexcept>
+#include <vector>
+#include <glm/glm.hpp>
+
+static std::string validStringArguments[] = { "borderSize", "padding", "color", "shader", "highlight", "format" };
+static char validCharArguments[] = { 'b', 'p', 'c', 's', 'h', 'f' };
+// 0 for flag, 1 for how many arguments to eat up
+static unsigned int isFlagArgument[] = { false, false, false, false, true, false };
+static unsigned int validArgumentCount = 6;
+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,243 @@
+#include "rectangle.hpp"
+
+Rectangle::Rectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
+    this->color = color;
+    this->border = border;
+    this->padding = padding;
+    this->highlight = highlight;
+    // Find each corner of the rectangle
+    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    // Offset the inner corners by the padding.
+    ul = ul + glm::vec2(-padding,padding);
+    bl = bl + glm::vec2(-padding,-padding);
+    ur = ur + glm::vec2(padding,padding);
+    br = br + glm::vec2(padding,-padding);
+    // Create the outer corners by offsetting the inner by the bordersize
+    oul = ul + glm::vec2(-border,border);
+    obl = bl + glm::vec2(-border,-border);
+    our = ur + glm::vec2(border,border);
+    obr = br + glm::vec2(border,-border);
+    generateBuffers();
+    shader = new Shader( "simple.vert", "simple.frag" );
+}
+
+void Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+    // Find each corner of the rectangle
+    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    // Offset the inner corners by the padding.
+    ul = ul + glm::vec2(-padding,padding);
+    bl = bl + glm::vec2(-padding,-padding);
+    ur = ur + glm::vec2(padding,padding);
+    br = br + glm::vec2(padding,-padding);
+    // Create the outer corners by offsetting the inner by the bordersize
+    oul = ul + glm::vec2(-border,border);
+    obl = bl + glm::vec2(-border,-border);
+    our = ur + glm::vec2(border,border);
+    obr = br + glm::vec2(border,-border);
+    generateBuffers();
+}
+
+void Rectangle::generateBuffers() {
+    std::vector<glm::vec2> rectangle_verts;
+    std::vector<glm::vec2> rectangle_uvs;
+    std::vector<glm::vec2> corner_verts;
+    std::vector<glm::vec2> corner_uvs;
+    std::vector<glm::vec2> center_verts;
+    std::vector<glm::vec2> center_uvs;
+
+    // Top left corner
+    corner_verts.push_back( oul );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( ul );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( ul + glm::vec2( -border, 0 ) );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( oul );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( ul + glm::vec2( 0, border ) );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( ul );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Top right corner
+    corner_verts.push_back( ur + glm::vec2( 0, border ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( ur + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( ur );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( ur + glm::vec2( 0, border ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( our );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( ur + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Bottom left corner
+    corner_verts.push_back( bl + glm::vec2( -border, 0 ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( obl + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( obl );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( bl + glm::vec2( -border, 0 ) );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( bl );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( bl + glm::vec2( 0, -border ) );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Bottom right corner
+    corner_verts.push_back( br );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( obr );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+    corner_verts.push_back( br + glm::vec2( 0, -border ) );
+    corner_uvs.push_back( glm::vec2(0, 0) );
+
+    corner_verts.push_back( br );
+    corner_uvs.push_back( glm::vec2(0, 1) );
+    corner_verts.push_back( br + glm::vec2( border, 0 ) );
+    corner_uvs.push_back( glm::vec2(1, 1) );
+    corner_verts.push_back( obr );
+    corner_uvs.push_back( glm::vec2(1, 0) );
+
+    // Left Rectangle
+    rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( bl + glm::vec2( -border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( ul + glm::vec2( -border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ul );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    // Right Rectangle
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( br + glm::vec2( border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( br );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ur + glm::vec2( border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( br + glm::vec2( border, 0 ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    // Top Rectangle
+    rectangle_verts.push_back( ul + glm::vec2( 0, border ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( ul );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( ul + glm::vec2( 0, border ) );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( ur + glm::vec2( 0, border ) );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( ur );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    // Bot Rectangle
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( br + glm::vec2( 0, -border ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+    rectangle_verts.push_back( bl + glm::vec2( 0, -border ) );
+    rectangle_uvs.push_back( glm::vec2(0, 0) );
+
+    rectangle_verts.push_back( bl );
+    rectangle_uvs.push_back( glm::vec2(0, 1) );
+    rectangle_verts.push_back( br );
+    rectangle_uvs.push_back( glm::vec2(1, 1) );
+    rectangle_verts.push_back( br + glm::vec2( 0, -border ) );
+    rectangle_uvs.push_back( glm::vec2(1, 0) );
+
+    center_verts.push_back( ul );
+    center_uvs.push_back( glm::vec2(0, 1) );
+    center_verts.push_back( br );
+    center_uvs.push_back( glm::vec2(1, 0) );
+    center_verts.push_back( bl );
+    center_uvs.push_back( glm::vec2(0, 0) );
+
+    center_verts.push_back( ul );
+    center_uvs.push_back( glm::vec2(0, 1) );
+    center_verts.push_back( ur );
+    center_uvs.push_back( glm::vec2(1, 1) );
+    center_verts.push_back( br );
+    center_uvs.push_back( glm::vec2(1, 0) );
+
+    glGenBuffers( 6, (GLuint*)&buffer );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_verts );
+    glBufferData( GL_ARRAY_BUFFER, corner_verts.size() * sizeof( glm::vec2 ), &corner_verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.corner_uvs );
+    glBufferData( GL_ARRAY_BUFFER, corner_uvs.size() * sizeof( glm::vec2 ), &corner_uvs[0], GL_STATIC_DRAW );
+
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_verts );
+    glBufferData( GL_ARRAY_BUFFER, rectangle_verts.size() * sizeof( glm::vec2 ), &rectangle_verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
+    glBufferData( GL_ARRAY_BUFFER, rectangle_uvs.size() * sizeof( glm::vec2 ), &rectangle_uvs[0], GL_STATIC_DRAW );
+
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.center_verts );
+    glBufferData( GL_ARRAY_BUFFER, center_verts.size() * sizeof( glm::vec2 ), &center_verts[0], GL_STATIC_DRAW );
+    glBindBuffer( GL_ARRAY_BUFFER, buffer.rectangle_uvs );
+    glBufferData( GL_ARRAY_BUFFER, center_uvs.size() * sizeof( glm::vec2 ), &center_uvs[0], GL_STATIC_DRAW );
+    corner_vertCount = corner_verts.size();
+    rectangle_vertCount = rectangle_verts.size();
+    center_vertCount = center_verts.size();
+}
+
+Rectangle::~Rectangle() {
+    delete shader;
+    glDeleteBuffers( 6, (GLuint*)&buffer );
+}
+
+void Rectangle::draw( glm::mat4& matrix ) {
+    glEnable( GL_BLEND );
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    shader->bind();
+    shader->setParameter( "projection", matrix );
+    if ( highlight ) {
+        // Draw the center of the highlight
+        shader->setParameter( "color", color );
+        shader->setAttribute( "position", buffer.center_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, center_vertCount );
+        // Set the color to have no alpha, then draw the borders.
+        glm::vec4 fullAlpha = glm::vec4(color.r,color.g,color.b,1);
+        shader->setParameter( "color", fullAlpha );
+        shader->setAttribute( "position", buffer.corner_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
+        shader->setAttribute( "position", buffer.rectangle_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
+    } else {
+        shader->setParameter( "color", color );
+        shader->setAttribute( "position", buffer.corner_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, corner_vertCount );
+        shader->setAttribute( "position", buffer.rectangle_verts, 2 );
+        glDrawArrays(GL_TRIANGLES, 0, rectangle_vertCount );
+    }
+    shader->unbind();
+    glDisable( GL_BLEND );
+}
+
+glm::vec4 Rectangle::getRect() {
+    return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
+}

src/rectangle.hpp

@@ -0,0 +1,45 @@
+#ifndef N_RECTANGLE_H_
+#define N_RECTANGLE_H_
+
+#include "gl_core_3_3.h"
+#include <iostream>
+#include <glm/glm.hpp>
+#include <GL/gl.h>
+#include <vector>
+
+#include "shader.hpp"
+
+struct RectangleBuffer {
+    unsigned int corner_verts;
+    unsigned int corner_uvs;
+    unsigned int rectangle_verts;
+    unsigned int rectangle_uvs;
+    unsigned int center_verts;
+    unsigned int center_uvs;
+};
+
+class Rectangle {
+private:
+    glm::vec2 ul, oul;
+    glm::vec2 bl, obl;
+    glm::vec2 ur, our;
+    glm::vec2 br, obr;
+    bool highlight;
+    void generateBuffers();
+    RectangleBuffer buffer;
+    unsigned int corner_vertCount;
+    unsigned int rectangle_vertCount;
+    unsigned int center_vertCount;
+    float border;
+    float padding;
+    Shader* shader;
+    glm::vec4 color;
+public:
+    glm::vec4 getRect();
+    Rectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false );
+    ~Rectangle();
+    void setPoints( glm::vec2 p1, glm::vec2 p2 );
+    void draw(glm::mat4& matrix);
+};
+
+#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,43 @@
 
 #include "resource.hpp"
 
-slop::Resource* resource = new slop::Resource();
-
-slop::Resource::Resource() {
+Resource::Resource() {
     // Find the configuration directory.
-    // usually ~/.config/slop and /usr/share/slop
+    // usually ~/.config/slop-wayland and /usr/share/slop-wayland
     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-wayland/";
+        // SHADER_PREFIX is defined within the CMakeLists.txt
+        sysconfig = SHADER_PREFIX;
+        sysconfig += "/share/slop-wayland/";
         return;
     }
-    m_usrconfig += config;
-    m_usrconfig += "/slop/";
-    m_sysconfig = INSTALL_PREFIX;
-    m_sysconfig += "/share/slop/";
+    usrconfig += config;
+    usrconfig += "/slop-wayland/";
+    sysconfig = SHADER_PREFIX;
+    sysconfig += "/share/slop-wayland/";
 }
 
-std::string slop::Resource::getRealPath( std::string localpath ) {
-    if ( validatePath( m_usrconfig + localpath ) ) {
-        return m_usrconfig + localpath;
+std::string Resource::getRealPath( std::string localpath ) {
+    if ( validatePath( usrconfig + localpath ) ) {
+        return usrconfig + localpath;
     }
-    if ( validatePath( m_sysconfig + localpath ) ) {
-        return m_sysconfig + localpath;
+    if ( validatePath( sysconfig + localpath ) ) {
+        return sysconfig + 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 either " + sysconfig + " or " + usrconfig + "\n";
+    throw std::runtime_error(err);
     return localpath;
 }
 
-bool slop::Resource::validatePath( std::string path ) {
-
+bool 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>
@@ -32,22 +33,16 @@
 #include <sys/stat.h>
 #include <pwd.h>
 
-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;
+    std::string sysconfig;
 };
 
-}
-
-extern slop::Resource* resource;
+extern Resource* resource;
 
 #endif // IS_RESOURCE_H_

src/selectrectangle.cpp

@@ -1,36 +0,0 @@
-/* selectrectangle.cpp: Handles creating rectangles on 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 "selectrectangle.hpp"
-
-bool slop::isSelectRectangleSupported() {
-    int event_base;
-    int error_base;
-    return XShapeQueryExtension( xengine->m_display, &event_base, &error_base );
-}
-
-slop::SelectRectangle::~SelectRectangle() {
-}
-
-void slop::SelectRectangle::update( double dt ) {
-}
-
-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");
-}

src/selectrectangle.hpp

@@ -1,60 +0,0 @@
-/* selectrectangle.hpp: Handles creating rectangles on 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/>.
- */
-
-#ifndef IS_SELECT_RECTANGLE_H_
-#define IS_SELECT_RECTANGLE_H_
-
-#include "x.hpp"
-#include "selectrectangle.hpp"
-#include "shader.hpp"
-
-#include <unistd.h>
-
-#include <X11/Xlib.h>
-#include <X11/extensions/shape.h>
-#include <X11/Xatom.h>
-
-#include <cstdlib>
-#include <cmath>
-#include <cstdio>
-#include <string>
-#include <vector>
-
-namespace slop {
-
-class SelectRectangle {
-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;
-};
-
-bool isSelectRectangleSupported();
-
-}
-
-#endif // IS_SELECT_RECTANGLE_H_

src/shader.cpp

@@ -1,15 +1,8 @@
 #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;
-    } else {
-        m_type = -1;
-    }
+Shader::Shader( std::string vert, std::string frag) {
+    vert = resource->getRealPath(vert);
+    frag = resource->getRealPath(frag);
     m_good = false;
     // Create the program to link to.
     m_program = glCreateProgram();
@@ -23,33 +16,46 @@ slop::Shader::Shader( std::string name, std::string vert, std::string frag, std:
 
     const char* vertsrc = vert_contents.c_str();
     const char* fragsrc = frag_contents.c_str();
+    
+    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;
@@ -62,57 +68,57 @@ slop::Shader::Shader( std::string name, std::string vert, std::string frag, std:
     glUseProgram( 0 );
 }
 
-slop::Shader::~Shader() {
+Shader::~Shader() {
     glDeleteProgram( m_program );
 }
 
-unsigned int slop::Shader::getProgram() {
+unsigned int Shader::getProgram() {
     return m_program;
 }
 
-void slop::Shader::bind() {
+void Shader::bind() {
     glUseProgram( m_program );
 }
 
-int slop::Shader::compile( unsigned int shader ) {
+int 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 ) {
+int Shader::link( unsigned int vertshader, unsigned int fragshader, std::string& error ) {
     glAttachShader( m_program, vertshader );
     glAttachShader( m_program, fragshader );
     glLinkProgram( m_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);
     if ( result == GL_FALSE ) {
         char* errormsg = new char[ logLength ];
         glGetProgramInfoLog( m_program, logLength, NULL, errormsg );
-        fprintf( stderr, "%s\n", errormsg );
+        error = errormsg;
         delete[] errormsg;
         return 1;
     }
     return 0;
 }
 
-unsigned int slop::Shader::getUniformLocation( std::string name ) {
+unsigned int Shader::getUniformLocation( std::string name ) {
     if ( !m_good ) {
         return 0;
     }
@@ -120,42 +126,42 @@ unsigned int slop::Shader::getUniformLocation( std::string name ) {
     return glGetUniformLocation( m_program, name.c_str() );
 }
 
-void slop::Shader::setParameter( std::string name, int foo ) {
+void Shader::setParameter( std::string name, int foo ) {
     if ( !m_good ) {
         return;
     }
     glUniform1i( getUniformLocation( name ), foo );
 }
 
-void slop::Shader::setParameter( std::string name, float foo ) {
+void 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 ) {
+void Shader::setParameter( std::string name, glm::mat4& foo ) {
     if ( !m_good ) {
         return;
     }
     glUniformMatrix4fv( getUniformLocation( name ), 1, GL_FALSE, glm::value_ptr( foo ) );
 }
 
-void slop::Shader::setParameter( std::string name, glm::vec4 foo ) {
+void 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 ) {
+void 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 ) {
+void Shader::setAttribute( std::string name, unsigned int buffer, unsigned int stepsize ) {
     unsigned int a = glGetAttribLocation( m_program, name.c_str() );
     glEnableVertexAttribArray( a );
     glBindBuffer( GL_ARRAY_BUFFER, buffer );
@@ -163,7 +169,7 @@ void slop::Shader::setAttribute( std::string name, unsigned int buffer, unsigned
     m_activeattribs.push_back( a );
 }
 
-void slop::Shader::unbind() {
+void Shader::unbind() {
     for ( unsigned int i=0; i<m_activeattribs.size(); i++ ) {
         glDisableVertexAttribArray( m_activeattribs[i] );
     }

src/shader.hpp

@@ -1,48 +1,39 @@
-// shader.hpp: Loads shaders into opengl
+#ifndef N_SHADER_H_
+#define N_SHADER_H_
 
-#ifndef IS_SHADER_H_
-#define IS_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>
 
-namespace slop {
+#include "resource.hpp"
 
 class Shader {
 public:
-    Shader( std::string name, std::string vert, std::string frag, std::string shadertype = "other" );
+    Shader( std::string vert, std::string frag );
     ~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;
     unsigned int                getUniformLocation( std::string );
-    int                         compile( unsigned int shader );
-    int                         link( unsigned int vert, unsigned int frag );
+    int                         compile( unsigned int shader, std::string& error );
+    int                         link( unsigned int vert, unsigned int frag, std::string& error );
     unsigned int                m_program;
 };
 
-};
-
-#endif // IS_SHADER_H_
+#endif // N_SHADER_H_

src/slop.cpp

@@ -0,0 +1,141 @@
+#include "slop.hpp"
+
+Wayland* wayland;
+Mouse* mouse;
+Keyboard* keyboard;
+Resource* resource;
+
+// Defaults!
+SlopOptions::SlopOptions() {
+    borderSize = 1;
+    padding = 0;
+    shader = "textured";
+    highlight = false;
+    r = 0.5;
+    g = 0.5;
+    b = 0.5;
+    a = 1;
+}
+
+SlopSelection::SlopSelection( float x, float y, float w, float h ) {
+    this->x = x;
+    this->y = y;
+    this->w = w;
+    this->h = h;
+}
+
+SlopMemory::SlopMemory( SlopOptions* options ) {
+    running = true;
+    state = (SlopState*)new SlopStart();
+    nextState = NULL;
+    rectangle = new Rectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight);
+}
+
+SlopMemory::~SlopMemory() {
+    delete state;
+    if ( nextState ) {
+        delete nextState;
+    }
+    delete rectangle;
+}
+
+void SlopMemory::update( double dt ) {
+    state->update( *this, dt );
+    if ( nextState ) {
+        state->onExit( *this );
+        delete state;
+        state = nextState;
+        state->onEnter( *this );
+        nextState = NULL;
+    }
+}
+
+void SlopMemory::setState( SlopState* state ) {
+    if ( nextState ) {
+        delete nextState;
+    }
+    nextState = state;
+}
+
+void SlopMemory::draw( glm::mat4& matrix ) {
+    state->draw( *this, matrix );
+}
+
+SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
+    bool deleteOptions = false;
+    if ( !options ) {
+        deleteOptions = true;
+        options = new SlopOptions();
+    }
+    resource = new Resource();
+    // Set up wayland temporarily
+    wayland = new Wayland();
+    wayland->init();
+    mouse = new Mouse( wayland );
+    keyboard = new Keyboard( wayland );
+
+    // Set up window with GL context
+    Window* window = new Window( 1, 1 );
+    window->setTitle("slop");
+    window->setClass("slop");
+    window->setFullScreen();
+    window->setCurrent();
+
+    window->framebuffer->setShader( options->shader );
+
+    // Init our little state machine, memory is a tad of a misnomer
+    SlopMemory memory( options );
+
+    // This is where we'll run through all of our stuffs
+    //FIXME: We need to sync up with wayland's draw pings so that we don't overdraw ever...
+    while( memory.running ) {
+        // This is specifically for wayland updates.
+        wl_display_dispatch_pending(wayland->display);
+        memory.update( 1 );
+
+        // Then we draw our junk to a framebuffer.
+        window->framebuffer->bind();
+        glClearColor (0.0, 0.0, 0.0, 0.0);
+        glClear (GL_COLOR_BUFFER_BIT);
+        memory.draw( window->camera );
+        window->framebuffer->unbind();
+
+        // Then we draw the framebuffer to the screen
+        window->framebuffer->draw();
+        window->display();
+        GLenum err = glGetError();
+        if ( err != GL_NO_ERROR ) {
+            throw err;
+        }
+        if ( keyboard->anyKeyDown() || mouse->getButton( BTN_RIGHT ) ) {
+            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();
+    glClearColor (0.0, 0.0, 0.0, 0.0);
+    glClear (GL_COLOR_BUFFER_BIT);
+    window->display();
+    // Then we clean up.
+    delete window;
+    delete mouse;
+    delete wayland;
+    delete resource;
+    if ( deleteOptions ) {
+        delete options;
+    }
+    // Finally return the data.
+    return SlopSelection( output.x, output.y, output.z+1, output.w+1 );
+}

src/slop.hpp

@@ -0,0 +1,55 @@
+#ifndef N_SLOP_H_
+#define N_SLOP_H_
+
+#include <string>
+
+#include "window.hpp"
+#include "shader.hpp"
+#include "framebuffer.hpp"
+#include "rectangle.hpp"
+#include "slopstates.hpp"
+#include "keyboard.hpp"
+#include "mouse.hpp"
+#include "resource.hpp"
+
+class SlopState;
+
+class SlopOptions {
+public:
+    SlopOptions();
+    float borderSize;
+    float padding;
+    bool highlight;
+    std::string shader;
+    float r;
+    float g;
+    float b;
+    float a;
+};
+
+class SlopSelection {
+public:
+    SlopSelection( float x, float y, float w, float h );
+    float x;
+    float y;
+    float w;
+    float h;
+};
+
+class SlopMemory {
+private:
+    SlopState* state;
+    SlopState* nextState;
+public:
+    SlopMemory( SlopOptions* options );
+    ~SlopMemory();
+    bool running;
+    Rectangle* rectangle;
+    void setState( SlopState* state );
+    void update( double dt );
+    void draw( glm::mat4& matrix );
+};
+
+SlopSelection SlopSelect( SlopOptions* options = NULL, bool* cancelled = NULL );
+
+#endif // N_SLOP_H_

src/slopstates.cpp

@@ -0,0 +1,51 @@
+#include "slopstates.hpp"
+
+SlopState::~SlopState() {
+}
+void SlopState::onEnter( SlopMemory& memory ) {
+}
+void SlopState::onExit( SlopMemory& memory ) {
+}
+void SlopState::update( SlopMemory& memory, double dt ) {
+}
+void SlopState::draw( SlopMemory& memory, glm::mat4 matrix ) {
+}
+
+// Start
+void SlopStart::update( SlopMemory& memory, double dt ) {
+    if ( mouse->getButton( BTN_LEFT ) ) {
+        memory.setState( (SlopState*)new SlopStartDrag( mouse->getMousePos() ) );
+    }
+}
+
+SlopStartDrag::SlopStartDrag( glm::vec2 point ) {
+    startPoint = point;
+}
+
+void SlopStartDrag::onEnter( SlopMemory& memory ) {
+    memory.rectangle->setPoints(startPoint, startPoint);
+}
+
+void SlopStartDrag::update( SlopMemory& memory, double dt ) {
+    memory.rectangle->setPoints(startPoint, mouse->getMousePos());
+    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( "lr_angle" ); break;
+        case 1: mouse->setCursor( "ll_angle" ); break;
+        case 2: mouse->setCursor( "ur_angle" ); break;
+        case 3: mouse->setCursor( "ul_angle" ); break;
+    }
+    if ( !mouse->getButton( BTN_LEFT ) ) {
+        memory.setState( (SlopState*)new SlopEndDrag() );
+    }
+}
+
+void SlopStartDrag::draw( SlopMemory& memory, glm::mat4 matrix ) {
+    memory.rectangle->draw( matrix );
+}
+
+void SlopEndDrag::onEnter( SlopMemory& memory ) {
+    memory.running = false;
+}

src/slopstates.hpp

@@ -0,0 +1,39 @@
+#ifndef N_SLOPSTATES_H_
+#define N_SLOPSTATES_H_
+
+#include "mouse.hpp"
+#include "rectangle.hpp"
+#include "slop.hpp"
+
+class SlopMemory;
+
+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 {
+public:
+    virtual void update( SlopMemory& memory, double dt );
+};
+
+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 );
+};
+
+#endif // N_SLOPSTATES_H_

src/wayland.cpp

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

src/wayland.hpp

@@ -0,0 +1,36 @@
+#ifndef N_WAYLAND_H_
+#define N_WAYLAND_H_
+
+#include <wayland-client.h>
+#include <wayland-egl.h>
+#include <EGL/egl.h>
+#include <string>
+#include <iostream>
+#include <vector>
+#include <glm/glm.hpp>
+
+//#include <mutter/meta/compositor-mutter.h>
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+class Wayland {
+public:
+    Wayland();
+    ~Wayland();
+    void init();
+    wl_display* display;
+    wl_compositor* compositor;
+    wl_seat* seat;
+    wl_shell* shell;
+    wl_shm* shm;
+    wl_output* output;
+    EGLDisplay egl_display;
+    glm::vec2 mousepos;
+    std::vector<glm::vec4> getWindows();
+};
+
+extern Wayland* wayland;
+
+#endif // N_WAYLAND_H_

src/window.cpp

@@ -0,0 +1,80 @@
+#include "window.hpp"
+
+static void shell_surface_ping (void *data, struct wl_shell_surface *shell_surface, uint32_t serial) {
+	wl_shell_surface_pong (shell_surface, serial);
+}
+static void shell_surface_configure (void *data, struct wl_shell_surface *shell_surface, uint32_t edges, int32_t width, int32_t height) {
+	Window* window = (Window*)data;
+	wl_egl_window_resize (window->egl_window, width, height, 0, 0);
+    window->camera = glm::ortho( 0.0f, (float)width, (float)height, 0.0f, -1.0f, 1.0f);
+    window->width = width;
+    window->height = height;
+    glViewport(0,0,width,height);
+    window->framebuffer->resize( width, height );
+}
+static void shell_surface_popup_done (void *data, struct wl_shell_surface *shell_surface) {
+	
+}
+static struct wl_shell_surface_listener shell_surface_listener = {&shell_surface_ping, &shell_surface_configure, &shell_surface_popup_done};
+
+Window::Window( unsigned int w, unsigned int h ) {
+    eglBindAPI (EGL_OPENGL_API);
+	EGLint attributes[] = {
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+		EGL_RED_SIZE, 8,
+		EGL_GREEN_SIZE, 8,
+		EGL_BLUE_SIZE, 8,
+		EGL_ALPHA_SIZE, 8,
+	EGL_NONE};
+    camera = glm::ortho( 0.0f, (float)w, (float)h, 0.0f, -1.0f, 1.0f);
+	EGLConfig config;
+	EGLint num_config;
+	eglChooseConfig (wayland->egl_display, attributes, &config, 1, &num_config);
+	egl_context = eglCreateContext (wayland->egl_display, config, EGL_NO_CONTEXT, NULL);
+	
+	surface = wl_compositor_create_surface (wayland->compositor);
+	shell_surface = wl_shell_get_shell_surface (wayland->shell, surface);
+	wl_shell_surface_add_listener (shell_surface, &shell_surface_listener, this);
+	wl_shell_surface_set_toplevel (shell_surface);
+	egl_window = wl_egl_window_create (surface, w, h);
+	egl_surface = eglCreateWindowSurface (wayland->egl_display, config, egl_window, NULL);
+    if(ogl_LoadFunctions() == ogl_LOAD_FAILED)
+    {
+        throw new std::runtime_error("Failed to load function pointers for OpenGL.");
+    }
+    setCurrent();
+    framebuffer = new Framebuffer( w, h );
+}
+
+Window::~Window() {
+    delete framebuffer;
+	eglDestroySurface (wayland->egl_display, egl_surface);
+	wl_egl_window_destroy (egl_window);
+	wl_surface_destroy (surface);
+	wl_shell_surface_destroy (shell_surface);
+	eglDestroyContext (wayland->egl_display, egl_context);
+}
+
+void Window::display() {
+	if (!eglSwapBuffers(wayland->egl_display, egl_surface)) {
+        throw new std::runtime_error("Failed to swap buffers.");
+    }
+}
+
+void Window::setFullScreen() {
+	wl_shell_surface_set_fullscreen(shell_surface, WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, NULL);
+}
+
+void Window::setCurrent() {
+	if (!eglMakeCurrent (wayland->egl_display, egl_surface, egl_surface, egl_context)) {
+        throw new std::runtime_error("Failed set EGL's current surface for rendering.");
+    }
+}
+
+void Window::setTitle(std::string title) {
+	wl_shell_surface_set_title(shell_surface, title.c_str());
+}
+
+void Window::setClass(std::string title) {
+	wl_shell_surface_set_class(shell_surface, title.c_str());
+}

src/window.hpp

@@ -0,0 +1,36 @@
+#ifndef N_WINDOW_H_
+#define N_WINDOW_H_
+
+#include <string>
+#include <exception>
+
+#include "gl_core_3_3.h"
+#include "wayland.hpp"
+//#include <GL/glew.h>
+#include <wayland-egl.h>
+#include <EGL/egl.h>
+#include <GL/gl.h>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include "framebuffer.hpp"
+
+class Window {
+public:
+    Framebuffer* framebuffer;
+    int width, height;
+    glm::mat4 camera;
+    Window( unsigned int w, unsigned int h );
+    ~Window();
+    void setFullScreen();
+    void setCurrent();
+    void setTitle( std::string title );
+    void setClass( std::string c );
+    void display();
+    EGLContext egl_context;
+    struct wl_surface *surface;
+    struct wl_shell_surface *shell_surface;
+    struct wl_egl_window *egl_window;
+    EGLSurface egl_surface;
+};
+
+#endif // N_WINDOW_H_

src/x.cpp

@@ -1,453 +0,0 @@
-/* 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();
-
-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 ) {
-    // 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;
-    }
-    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;
-}
-
-#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;
-}

src/x.hpp

@@ -1,115 +0,0 @@
-/* x.hpp: 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/>.
- */
-
-#ifndef IS_X_H_
-#define IS_X_H_
-
-#include <unistd.h>
-
-#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>
-
-namespace slop {
-
-enum CursorType {
-    Left,
-    Crosshair,
-    Cross,
-    UpperLeftCorner,
-    UpperRightCorner,
-    LowerRightCorner,
-    LowerLeftCorner,
-    Dot,
-    Box
-};
-
-class WindowRectangle {
-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 );
-};
-
-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 slop::XEngine* xengine;
-
-#endif // IS_X_H_

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/xselectrectangle.hpp

@@ -1,56 +0,0 @@
-/* xselectrectangle.hpp: 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/>.
- */
-
-#ifndef IS_X_SELECT_RECTANGLE_H_
-#define IS_X_SELECT_RECTANGLE_H_
-
-#include "x.hpp"
-#include "selectrectangle.hpp"
-
-#include <unistd.h>
-
-#include <X11/Xlib.h>
-#include <X11/extensions/shape.h>
-#include <X11/Xatom.h>
-
-#include <cstdlib>
-#include <cmath>
-#include <cstdio>
-#include <string>
-#include <vector>
-
-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;
-private:
-    XColor  convertColor( float r, float g, float b );
-    void    constrain( int w, int h );
-};
-
-}
-
-#endif // IS_X_SELECT_RECTANGLE_H_