Added optional CMake flag CMAKE_OPENGL_SUPPORT to enable slop's OpenGL implementation.

CMakeLists.txt

 set( slop_VERSION_MINOR 2 )
 set( slop_VERSION_PATCH 16 )
 
+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" )
 add_custom_target( README.md "./generateReadme.sh" DEPENDS "slop" )
 
 # Sources
-set( source
-     src/cmdline.c
-     src/selectrectangle.cpp
-     src/glselectrectangle.cpp
-     src/shader.cpp
-     src/framebuffer.cpp
-     src/resource.cpp
-     src/xselectrectangle.cpp
-     src/x.cpp
-     src/main.cpp )
+if( CMAKE_OPENGL_SUPPORT )
+    set( source
+         src/cmdline.c
+         src/selectrectangle.cpp
+         src/glselectrectangle.cpp
+         src/shader.cpp
+         src/framebuffer.cpp
+         src/resource.cpp
+         src/xselectrectangle.cpp
+         src/x.cpp
+         src/main.cpp )
+else()
+    set( source
+         src/cmdline.c
+         src/selectrectangle.cpp
+         src/xselectrectangle.cpp
+         src/x.cpp
+         src/main.cpp )
+endif()
 
 # Obtain library paths and make sure they exist.
 set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmakemodules" )
+find_package( Imlib2    REQUIRED )
 find_package( X11       REQUIRED )
 find_package( XExt      REQUIRED )
 find_package( OpenGL    REQUIRED )
 find_package( GLX       REQUIRED )
 find_package( XRender   REQUIRED )
 find_package( XRandr    REQUIRED )
-find_package( DevIL     REQUIRED )
 find_package( GLEW      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
      "${CMAKE_CXX_FLAGS} ${CMAKE_IMLIB2_CXX_FLAGS}" )
 
 # Includes
+include_directories( "${X11_INCLUDE_DIR}"
+                     "${XEXT_INCLUDE_DIR}" )
+
+if ( CMAKE_OPENGL_SUPPORT )
+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( ${X11_INCLUDE_DIR}
-                         ${XEXT_INCLUDE_DIR}
-                         ${XRANDR_INCLUDE_DIR}
-                         ${OPENGL_INCLUDE_DIR}
-                         ${IL_INCLUDE_DIR}
-                         ${GLX_INCLUDE_DIR}
-                         ${GLEW_INCLUDE_DIRS}
-                         ${XRENDER_INCLUDE_DIRS}
-                         ${RT_INCLUDE_DIR} )
-else()
-    include_directories( ${X11_INCLUDE_DIR}
-                         ${OPENGL_INCLUDE_DIR}
-                         ${IL_INCLUDE_DIR}
-                         ${GLEW_INCLUDE_DIRS}
-                         ${GLX_INCLUDE_DIR}
-                         ${XEXT_INCLUDE_DIR} )
+    include_directories( ${RT_INCLUDE_DIR} )
 endif()
 
 # Executable
 add_executable( "${BIN_TARGET}" ${source} )
 
 # Libraries
-if ( RT_LIBRARY )
+target_link_libraries( "${BIN_TARGET}"
+                       ${X11_LIBRARIES}
+                       "${XEXT_LIBRARY}" )
+
+if ( CMAKE_OPENGL_SUPPORT )
     target_link_libraries( "${BIN_TARGET}"
-                           ${X11_LIBRARIES}
+                           ${IMLIB2_LIBRARIES}
                            ${OPENGL_LIBRARIES}
-                           ${IL_LIBRARIES}
-                           ${ILUT_LIBRARIES}
                            ${GLX_LIBRARIES}
                            ${GLEW_LIBRARIES}
                            ${XRENDER_LIBRARIES}
-                           "${XEXT_LIBRARY}"
-                           "${XRANDR_LIBRARY}"
-                           "${RT_LIBRARY}" )
-else()
+                           "${XRANDR_LIBRARY}" )
+endif()
+
+
+if ( RT_LIBRARY )
     target_link_libraries( "${BIN_TARGET}"
-                           ${OPENGL_LIBRARIES}
-                           ${IL_LIBRARIES}
-                           ${ILUT_LIBRARIES}
-                           ${GLEW_LIBRARIES}
-                           ${GLX_LIBRARIES}
-                           ${X11_LIBRARIES}
-                           "${XEXT_LIBRARY}" )
+                           "${RT_LIBRARY}" )
 endif()
 
 install( TARGETS ${BIN_TARGET}
          DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )
 
-install( DIRECTORY "${CMAKE_SOURCE_DIR}/share"
-         DESTINATION "${CMAKE_INSTALL_PREFIX}" )
-
 add_definitions(-DINSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}")
+
+if( CMAKE_OPENGL_SUPPORT )
+    install( DIRECTORY "${CMAKE_SOURCE_DIR}/share"
+             DESTINATION "${CMAKE_INSTALL_PREFIX}" )
+    add_definitions(-DOPENGL_ENABLED=1)
+endif()

cmakemodules/FindImlib2.cmake

+#
+# 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)

src/framebuffer.cpp

         //Make sure we unbind when we're done.
         glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
     } else {
-        fprintf( stderr, "Error: Failed to create framebuffer! You need OpenGL 3.0 or the GL_EXT_framebuffer_object extension!\n" );
+        throw std::runtime_error( "Error: Failed to create framebuffer! You need OpenGL 3.0 or the GL_EXT_framebuffer_object extension!" );
     }
 }
 

src/glselectrectangle.cpp

     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 );
 }
 
 void slop::GLSelectRectangle::setTheme( bool on, std::string name ) {
-    if ( !on ) {
+    if ( !on || name == "none" ) {
         return;
     }
     std::string root = resource->getRealPath( name );
         return;
     }
     // Otherwise we load each one :)
-    ilInit();
-    ilutInit();
-    ilutRenderer(ILUT_OPENGL);
-    ILuint corner;
-    ilGenImages( 1, &corner );
-    ilBindImage( corner );
-    ilLoadImage( tl.c_str() );
-    m_cornerids[0] = ilutGLBindMipmaps();
-    ilLoadImage( tr.c_str() );
-    m_cornerids[1] = ilutGLBindMipmaps();
-    ilLoadImage( bl.c_str() );
-    m_cornerids[2] = ilutGLBindMipmaps();
-    ilLoadImage( br.c_str() );
-    m_cornerids[3] = ilutGLBindMipmaps();
-    ilLoadImage( straight.c_str() );
-    m_straightwidth = ilGetInteger( IL_IMAGE_WIDTH );
-    m_straightheight = ilGetInteger( IL_IMAGE_HEIGHT );
-    m_straightid = ilutGLBindMipmaps();
-    // And clean up after.
-    ilDeleteImages( 1, &corner );
+    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 );
         //float ratio = ((float)m_straightwidth/(float)m_straightheight);
         glBegin( GL_QUADS );
         // straight top
-        glTexCoord2f(0.0, 1.0); glVertex2f( m_x-m_border/2, m_y-m_border );
-        glTexCoord2f(txoffset, 1.0); glVertex2f( m_x+m_width+m_border/2, m_y-m_border );
-        glTexCoord2f(txoffset, 0.0); glVertex2f( m_x+m_width+m_border/2, m_y );
-        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border/2, m_y );
+        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, 1.0); glVertex2f( m_x-m_border/2, m_y+m_height );
-        glTexCoord2f(txoffset, 1.0); glVertex2f( m_x+m_width+m_border/2, m_y+m_height );
-        glTexCoord2f(txoffset, 0.0); glVertex2f( m_x+m_width+m_border/2, m_y+m_height+m_border );
-        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border/2, m_y+m_height+m_border );
+        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, 0.0); glVertex2f( m_x-m_border, m_y-m_border/2 );
-        glTexCoord2f(0.0, 1.0); glVertex2f( m_x, m_y-m_border/2 );
-        glTexCoord2f(tyoffset, 1.0); glVertex2f( m_x, m_y+m_height+m_border/2 );
-        glTexCoord2f(tyoffset, 0.0); glVertex2f( m_x-m_border, m_y+m_height+m_border/2 );
+        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, 0.0); glVertex2f( m_x+m_width, m_y-m_border/2 );
-        glTexCoord2f(0.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y-m_border/2 );
-        glTexCoord2f(tyoffset, 1.0); glVertex2f( m_x+m_width+m_border, m_y+m_height+m_border/2 );
-        glTexCoord2f(tyoffset, 0.0); glVertex2f( m_x+m_width, m_y+m_height+m_border/2 );
+        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, 1.0); glVertex2f( m_x-m_border, m_y-m_border );
-        glTexCoord2f(1.0, 1.0); glVertex2f( m_x, m_y-m_border );
-        glTexCoord2f(1.0, 0.0); glVertex2f( m_x, m_y );
-        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y );
+        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, 1.0); glVertex2f( m_x+m_width, m_y-m_border );
-        glTexCoord2f(1.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y-m_border );
-        glTexCoord2f(1.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y );
-        glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width, m_y );
+        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, 1.0); glVertex2f( m_x-m_border, m_y+m_height );
-        glTexCoord2f(1.0, 1.0); glVertex2f( m_x, m_y+m_height );
-        glTexCoord2f(1.0, 0.0); glVertex2f( m_x, m_y+m_height+m_border );
-        glTexCoord2f(0.0, 0.0); glVertex2f( m_x-m_border, m_y+m_height+m_border );
+        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, 1.0); glVertex2f( m_x+m_width, m_y+m_height );
-        glTexCoord2f(1.0, 1.0); glVertex2f( m_x+m_width+m_border, m_y+m_height );
-        glTexCoord2f(1.0, 0.0); glVertex2f( m_x+m_width+m_border, m_y+m_height+m_border );
-        glTexCoord2f(0.0, 0.0); glVertex2f( m_x+m_width, m_y+m_height+m_border );
+        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();
     }
 

src/glselectrectangle.hpp

 
 #include <unistd.h>
 
+#include <Imlib2.h>
 #include <GL/gl.h>
 #include <GL/glx.h>
 #include <GL/glew.h>
 #include <GL/glxext.h>
-#define ILUT_USE_OPENGL
-#include <IL/il.h>
-#include <IL/ilut.h>
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/Xrender.h>
     unsigned int        m_texid;
     unsigned int        m_cornerids[4];
     unsigned int        m_straightid;
-    unsigned int        m_straightwidth;
-    unsigned int        m_straightheight;
+    int                 m_straightwidth;
+    int                 m_straightheight;
     int                 m_offsetx;
     int                 m_offsety;
     int                 m_offsetw;
     std::string         m_shader;
     std::vector<XRRCrtcInfo*> m_monitors;
     slop::Framebuffer*  m_framebuffer;
+private:
+    unsigned int loadImage( unsigned int* texture, std::string path );
 };
 
 }

src/main.cpp

 #include <cstdio>
 #include <sstream>
 #include <execinfo.h>
+#include <stdexcept>
 
 #ifdef __MACH__
 #include <mach/clock.h>
 
 #include "x.hpp"
 #include "selectrectangle.hpp"
+#ifdef OPENGL_ENABLED
 #include "glselectrectangle.hpp"
+#endif //OPENGL_ENABLED
 #include "xselectrectangle.hpp"
 #include "cmdline.h"
 
     bool decorations = !options.nodecorations_flag;
     bool themeon = (bool)options.theme_given;
     std::string theme = options.theme_arg;
+    bool shadergiven = (bool)options.shader_given;
     std::string shader = options.shader_arg;
     struct timespec start, time;
     int xoffset = 0;
     }
     unsigned int magpixels = (unsigned int)options.magpixels_arg;
     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_ENABLED 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
 
     // First we set up the x interface and grab the mouse,
     // if we fail for either we exit immediately.
                     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,
                             ((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 );
                     }
                 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,
                         ((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
         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" );
     }

src/x.cpp

     //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 );
     return EXIT_SUCCESS;
 }
 
+#ifdef OPENGL_ENABLED
 std::vector<XRRCrtcInfo*> slop::XEngine::getCRTCS() {
     std::vector<XRRCrtcInfo*> monitors;
     if ( !m_res ) {
     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 ) {

src/x.hpp

     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;