Added experimental OpenGL rendering. Use --opengl to activate it.

CMakeLists.txt

 
 project( "slop" )
 set( slop_VERSION_MAJOR 4 )
-set( slop_VERSION_MINOR 1 )
+set( slop_VERSION_MINOR 2 )
 set( slop_VERSION_PATCH 16 )
 
 set( BIN_TARGET     "${PROJECT_NAME}" )
 # Sources
 set( source
      src/cmdline.c
-     src/rectangle.cpp
+     src/selectrectangle.cpp
+     src/glselectrectangle.cpp
+     src/xselectrectangle.cpp
      src/x.cpp
      src/main.cpp )
 
 set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmakemodules" )
 find_package( X11       REQUIRED )
 find_package( XExt      REQUIRED )
+find_package( OpenGL    REQUIRED )
+find_package( GLX       REQUIRED )
+find_package( XRender   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.
 if ( RT_INCLUDE_DIR )
     include_directories( ${X11_INCLUDE_DIR}
                          ${XEXT_INCLUDE_DIR}
+                         ${OPENGL_INCLUDE_DIR}
+                         ${GLX_INCLUDE_DIR}
+                         ${XRENDER_INCLUDE_DIRS}
                          ${RT_INCLUDE_DIR} )
 else()
     include_directories( ${X11_INCLUDE_DIR}
+                         ${OPENGL_INCLUDE_DIR}
+                         ${GLX_INCLUDE_DIR}
                          ${XEXT_INCLUDE_DIR} )
 endif()
 
 if ( RT_LIBRARY )
     target_link_libraries( "${BIN_TARGET}"
                            ${X11_LIBRARIES}
+                           ${OPENGL_LIBRARIES}
+                           ${GLX_LIBRARIES}
+                           ${XRENDER_LIBRARIES}
                            "${XEXT_LIBRARY}"
                            "${RT_LIBRARY}" )
 else()
     target_link_libraries( "${BIN_TARGET}"
+                           ${OPENGL_LIBRARIES}
+                           ${GLX_LIBRARIES}
                            ${X11_LIBRARIES}
                            "${XEXT_LIBRARY}" )
 endif()

README.md

 help
 ----
 ```text
-slop v4.1.16
+slop v4.2.16
 
 Copyright (C) 2014 Dalton Nell, Slop Contributors
 (https://github.com/naelstrof/slop/graphs/contributors)
                                   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)
   -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')

src/cmdline.c

   "      --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)",
   "  -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    $ # 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
   args_info->min_given = 0 ;
   args_info->max_given = 0 ;
   args_info->highlight_given = 0 ;
+  args_info->opengl_given = 0 ;
   args_info->format_given = 0 ;
 }
 
   args_info->max_arg = 0;
   args_info->max_orig = NULL;
   args_info->highlight_flag = 0;
+  args_info->opengl_flag = 0;
   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;
   
   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->format_help = gengetopt_args_info_help[14] ;
+  args_info->opengl_help = gengetopt_args_info_help[14] ;
+  args_info->format_help = gengetopt_args_info_help[15] ;
   
 }
 
     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->format_given)
     write_into_file(outfile, "format", args_info->format_orig, 0);
   
         { "min",	1, NULL, 0 },
         { "max",	1, NULL, 0 },
         { "highlight",	0, NULL, 'l' },
+        { "opengl",	0, NULL, 0 },
         { "format",	1, NULL, 'f' },
         { 0,  0, 0, 0 }
       };
                 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;
+          
           }
           
           break;

src/cmdline.in

   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.  */
   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 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 format_given ;	/**< @brief Whether format was given.  */
 
 } ;

src/glselectrectangle.cpp

+/* 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;
+    }
+    // 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 );
+}
+
+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;
+
+    // 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" );
+    }
+    glClearColor( 0, 0, 0, 0 );
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+    glXSwapBuffers( xengine->m_display, m_glxWindow );
+}
+
+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;
+    glDrawBuffer( GL_BACK );
+    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();
+
+    glEnable( GL_BLEND );
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glColor4f( m_r, m_g, m_b, m_a );
+    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 );
+
+    glXSwapBuffers( xengine->m_display, m_glxWindow );
+}

src/glselectrectangle.hpp

+/* 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 <unistd.h>
+
+#include <GL/gl.h>
+#include <GL/glx.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 );
+    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;
+};
+
+}
+
+#endif // IS_GL_SELECT_RECTANGLE_H_

src/main.cpp

 #endif
 
 #include "x.hpp"
-#include "rectangle.hpp"
+#include "selectrectangle.hpp"
+#include "glselectrectangle.hpp"
+#include "xselectrectangle.hpp"
 #include "cmdline.h"
 
 // Work around lack of clock_gettime in OSX
     }
     int state = 0;
     bool running = true;
-    slop::Rectangle* selection = NULL;
+    bool opengl = options.opengl_flag;
+    slop::SelectRectangle* selection = NULL;
     Window window = None;
     Window windowmemory = None;
     std::string xdisplay;
         printSelection( format, true, 0, 0, 0, 0, None );
         return EXIT_FAILURE;
     }
-    if ( !slop::isRectangleSupported() ) {
+    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;
                     t.applyMinMaxSize( minimumsize, maximumsize );
                     // Make sure we only apply offsets to windows that we've forcibly removed decorations on.
                     if ( !selection ) {
-                        selection = new slop::Rectangle( t.m_x,
-                                                         t.m_y,
-                                                         t.m_x + t.m_width,
-                                                         t.m_y + t.m_height,
-                                                         borderSize,
-                                                         highlight,
-                                                         r, g, b, a );
+                        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 );
+                        } else {
+                            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 );
+                        }
                     } 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 );
-                    selection = new slop::Rectangle( sx,
-                                                     sy,
-                                                     ex,
-                                                     ey,
-                                                     borderSize,
-                                                     highlight,
-                                                     r, g, b, a );
+                    if ( opengl ) {
+                        selection = new slop::GLSelectRectangle( sx, sy,
+                                                                 ex, ey,
+                                                                 borderSize,
+                                                                 highlight,
+                                                                 r, g, b, a );
+                    } else {
+                        selection = new slop::XSelectRectangle( sx, sy,
+                                                                ex, ey,
+                                                                borderSize,
+                                                                highlight,
+                                                                r, g, b, a );
+                    }
                 }
                 windowmemory = window;
                 // If the user has let go of the mouse button, we'll just

src/options.ggo

     flag
     off
 
+option "opengl" - "Enable hardware acceleration. Only works with modern systems that are also running a compositor."
+    flag
+    off
+
 option "format" f "Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c."
     string
     default="REPLACEME"

src/selectrectangle.cpp

+/* 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::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

+/* 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 <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 );
+    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/rectangle.cpp → src/xselectrectangle.cpp

-/* rectangle.cpp: Handles creating rectangles on the screen.
+/* 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).
  *
  * You should have received a copy of the GNU General Public License
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "rectangle.hpp"
+#include "xselectrectangle.hpp"
 
 static Bool isDestroyNotify( Display* dpy, XEvent* ev, XPointer win ) {
     return ev->type == DestroyNotify && ev->xdestroywindow.window == *((Window*)win);
 }
 
-slop::Rectangle::~Rectangle() {
+slop::XSelectRectangle::~XSelectRectangle() {
     if ( m_window == None ) {
         return;
     }
     usleep( 10000 );
 }
 
-slop::Rectangle::Rectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a ) {
+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;
     XMapWindow( xengine->m_display, m_window );
 }
 
-void slop::Rectangle::setGeo( int sx, int sy, int ex, int ey ) {
+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;
     }
 }
 
-XColor slop::Rectangle::convertColor( float r, float g, float b ) {
+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 ) );
     }
     return color;
 }
-
-bool slop::isRectangleSupported() {
-    int event_base;
-    int error_base;
-    return XShapeQueryExtension( xengine->m_display, &event_base, &error_base );
-}

src/rectangle.hpp → src/xselectrectangle.hpp

-/* rectangle.hpp: Handles creating rectangles on the screen.
+/* 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).
  *
  * along with Slop.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef IS_RECTANGLE_H_
-#define IS_RECTANGLE_H_
+#ifndef IS_X_SELECT_RECTANGLE_H_
+#define IS_X_SELECT_RECTANGLE_H_
 
 #include "x.hpp"
+#include "selectrectangle.hpp"
 
 #include <unistd.h>
 
 
 namespace slop {
 
-class Rectangle {
+class XSelectRectangle: public SelectRectangle {
 public:
-            Rectangle( int sx, int sy, int ex, int ey, int border, bool highlight, float r, float g, float b, float a );
-            ~Rectangle();
+            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 );
     void    constrain( int w, int h );
 };
 
-bool isRectangleSupported();
-
 }
 
-#endif // IS_RECTANGLE_H_
+#endif // IS_X_SELECT_RECTANGLE_H_