Added SLOP_OPENGL flag that makes OpenGL optional. (You shouldn't want this.)

CMakeLists.txt

 cmake_minimum_required(VERSION 3.1.3)
 
 set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)")
+
 if ( NOT CMAKE_INSTALL_PREFIX )
     set(CMAKE_INSTALL_PREFIX "/usr")
 endif()
 
+# This should really never be disabled. The pure-X mode of slop is very expensive and buggy.
+# It also doesn't work on Wayland. Though if a system is never running a compositor, or
+# doesn't have OpenGL, this could remove some linking dependencies I suppose.
+set( SLOP_OPENGL TRUE CACHE BOOL "To enable or disable OpenGL support." )
+if ( SLOP_OPENGL )
+  add_definitions(-DSLOP_OPENGL="True")
+endif()
+
 project(slop)
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/")
 
 include_directories("${PROJECT_BINARY_DIR}")
 
-add_definitions(-DSLOP_VERSION="v7.3.48")
+add_definitions(-DSLOP_VERSION="v7.3.49")
 
 # The names have to be unique unfortunately.
 set(EXECUTABLE_NAME "slop")
 set(LIBRARY_NAME "slopy")
 
-add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
-                                    src/keyboard.cpp
-                                    src/x.cpp
-                                    src/slopstates.cpp
-                                    src/framebuffer.cpp
-                                    src/resource.cpp
-                                    src/shader.cpp
-                                    src/window.cpp
-                                    src/slop.cpp
-                                    src/rectangle.cpp
-                                    src/xshaperectangle.cpp
-                                    src/glrectangle.cpp)
+
+if ( SLOP_OPENGL )
+  add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
+                                      src/keyboard.cpp
+                                      src/x.cpp
+                                      src/slopstates.cpp
+                                      src/resource.cpp
+                                      src/slop.cpp
+                                      src/rectangle.cpp
+                                      src/xshaperectangle.cpp
+                                      src/shader.cpp
+                                      src/window.cpp
+                                      src/framebuffer.cpp
+                                      src/glrectangle.cpp)
+else()
+  add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
+                                      src/keyboard.cpp
+                                      src/x.cpp
+                                      src/slopstates.cpp
+                                      src/resource.cpp
+                                      src/slop.cpp
+                                      src/rectangle.cpp
+                                      src/xshaperectangle.cpp)
+endif()
 
 set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
 set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD 11)
 
 set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" )
 
-find_package(GLEW REQUIRED)
 find_package(GLM REQUIRED)
 find_package(X11 REQUIRED)
 find_package(XExt REQUIRED)
-find_package(GLX REQUIRED)
-find_package(OpenGL REQUIRED)
-find_package(XRender REQUIRED)
-# Ahhhh, finally this eliminates the segfault on preload.
-find_package(Threads REQUIRED)
+
+if ( SLOP_OPENGL )
+  find_package(GLEW REQUIRED)
+  find_package(OpenGL REQUIRED)
+  find_package(GLX REQUIRED)
+  find_package(XRender REQUIRED)
+  # Ahhhh, finally this eliminates the segfault on preload.
+  find_package(Threads REQUIRED)
+endif()
 
 include_directories(${X11_INCLUDE_DIR}
-                    ${GLEW_INCLUDE_DIR}
                     ${GLM_INCLUDE_DIR}
-                    ${XEXT_INCLUDE_DIR}
-                    ${GLX_INCLUDE_DIR}
-                    ${XRENDER_INCLUDE_DIR}
-                    ${OPENGL_INCLUDE_DIR})
+                    ${GLX_INCLUDE_DIR})
 
 target_link_libraries(${LIBRARY_NAME} ${X11_LIBRARIES}
-                                      ${CMAKE_THREAD_LIBS_INIT} 
                                       ${GLM_LIBRARIES}
-                                      ${OPENGL_LIBRARIES}
-                                      ${GLX_LIBRARY}
-                                      ${XRENDER_LIBRARY}
-                                      ${XEXT_LIBRARIES}
-                                      ${GLEW_LIBRARIES})
+                                      ${XEXT_LIBRARIES})
+
+if ( SLOP_OPENGL )
+  include_directories( ${XEXT_INCLUDE_DIR}
+                       ${GLEW_INCLUDE_DIR}
+                       ${XRENDER_INCLUDE_DIR}
+                       ${OPENGL_INCLUDE_DIR} )
+  target_link_libraries(${LIBRARY_NAME} ${OPENGL_LIBRARIES}
+                                        ${XRENDER_LIBRARY}
+                                        ${CMAKE_THREAD_LIBS_INIT} 
+                                        ${GLX_LIBRARY}
+                                        ${GLEW_LIBRARIES})
+endif()
 
 target_link_libraries(${EXECUTABLE_NAME} ${LIBRARY_NAME} )
 
-find_package(ICU COMPONENTS uc)
-set( SLOP_UNICODE TRUE CACHE BOOL "To enable or disable unicode support." )
-if ( SLOP_UNICODE AND ICU_FOUND )
-    # ICU is required for old nvidia drivers to work for whatever reason.
+if( CMAKE<3.7 )
+  message( WARNING "CMake version is below 3.7, CMake version >= 3.7 is required for unicode support." )
+else()
+  find_package(ICU COMPONENTS uc)
+  set( SLOP_UNICODE TRUE CACHE BOOL "To enable or disable unicode support." )
+  if ( SLOP_UNICODE AND ICU_FOUND )
     add_definitions(-DCXXOPTS_USE_UNICODE)
     include_directories( ${ICU_INCLUDE_DIR} )
     target_link_libraries(${EXECUTABLE_NAME} ${ICU_UC_LIBRARIES} )
+  endif()
 endif()
 
 install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )

src/slop.cpp

+#ifdef SLOP_OPENGL
 #include <GL/glew.h>
 #include <GL/gl.h>
+#endif
 
 #include <chrono>
 #include <thread>
 #include "resource.hpp"
 #include "keyboard.hpp"
 
+#ifdef SLOP_OPENGL
 #include "window.hpp"
 #include "shader.hpp"
 #include "framebuffer.hpp"
 #include "glrectangle.hpp"
+#endif
+
 #include "xshaperectangle.hpp"
 #include "slop.hpp"
 
 Keyboard* keyboard;
 Resource* resource;
 
+#ifdef SLOP_OPENGL
 SlopSelection GLSlopSelect( slop::SlopOptions* options, slop::SlopWindow* window );
+#endif
 SlopSelection XShapeSlopSelect( slop::SlopOptions* options );
 
 static int TmpXError(Display * d, XErrorEvent * ev) {
         keyboard = new Keyboard( x11 );
         XSetErrorHandler(ph);
     }
+#ifdef SLOP_OPENGL
     bool success = false;
     std::string errorstring = "";
     SlopWindow* window;
                 std::cerr << errorstring;
             }
         }
+#endif // SLOP_OPENGL
         returnval = slop::XShapeSlopSelect( options );
+#ifdef SLOP_OPENGL
     } else {
         returnval = slop::GLSlopSelect( options, window );
     }
+#endif
     delete x11;
     delete slop::resource;
     if ( deleteOptions ) {
     return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow, cancelled );
 }
 
+#ifdef SLOP_OPENGL
 slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, SlopWindow* window ) {
     bool cancelled = false;
     slop::mouse = new slop::Mouse( x11, options->nodecorations, window->window );
     // Finally return the data.
     return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow, cancelled );
 }
+#endif
 
 extern "C" struct slop_options slop_options_default() {
     struct slop_options options;