Added an experimental magnifying glass for --opengl only.

CMakeLists.txt

 find_package( OpenGL    REQUIRED )
 find_package( GLX       REQUIRED )
 find_package( XRender   REQUIRED )
+find_package( XRandr    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}
+                         ${XRANDR_INCLUDE_DIR}
                          ${OPENGL_INCLUDE_DIR}
                          ${GLX_INCLUDE_DIR}
                          ${XRENDER_INCLUDE_DIRS}
                            ${GLX_LIBRARIES}
                            ${XRENDER_LIBRARIES}
                            "${XEXT_LIBRARY}"
+                           "${XRANDR_LIBRARY}"
                            "${RT_LIBRARY}" )
 else()
     target_link_libraries( "${BIN_TARGET}"

cmakemodules/FindGLX.cmake

+# 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/FindXRandr.cmake

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

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

src/cmdline.c

   "      --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')",
   "  -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
   , ARG_FLAG
   , ARG_STRING
   , ARG_INT
+  , ARG_FLOAT
 } cmdline_parser_arg_type;
 
 static
   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->format_given = 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->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->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->format_help = gengetopt_args_info_help[15] ;
+  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->format_help = gengetopt_args_info_help[18] ;
   
 }
 
   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->format_arg));
   free_string_field (&(args_info->format_orig));
   
     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->format_given)
     write_into_file(outfile, "format", args_info->format_orig, 0);
   
   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;
   /* 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 */
         { "max",	1, NULL, 0 },
         { "highlight",	0, NULL, 'l' },
         { "opengl",	0, NULL, 0 },
+        { "magnify",	0, NULL, 0 },
+        { "magstrength",	1, NULL, 0 },
+        { "magpixels",	1, NULL, 0 },
         { "format",	1, NULL, 'f' },
         { 0,  0, 0, 0 }
       };
                 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;
+          
           }
           
           break;

src/cmdline.in

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

src/glselectrectangle.cpp

     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::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;
+    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);
+}
+
 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_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();
 
     // If we don't have a border, we don't exist, so just die.
     if ( m_border == 0 ) {
     m_y = y;
     m_width = w;
     m_height = h;
-    glDrawBuffer( GL_BACK );
+}
+
+void slop::GLSelectRectangle::update( double dt ) {
     glViewport( 0, 0, xengine->getWidth(), xengine->getHeight() );
 
     glClearColor( 0, 0, 0, 0 );
     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 );
 
+    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

                         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 );
     float               m_r;
     float               m_g;
     float               m_b;
     GLXContext          m_renderContext;
     GLXWindow           m_glxWindow;
     Colormap            m_cmap;
+    unsigned int        m_texid;
+    int                 m_offsetx;
+    int                 m_offsety;
+    int                 m_offsetw;
+    int                 m_offseth;
+    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;
+    std::vector<XRRCrtcInfo*> m_monitors;
 };
 
 }

src/main.cpp

         pressedTime[ i ] = 0;
     }
     std::string format = options.format_arg;
+    bool magenabled = options.magnify_flag;
+    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;
     cmdline_parser_free( &options );
 
     // First we set up the x interface and grab the mouse,
         }
     }
     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 curtime = double( time.tv_sec*1000000000L + time.tv_nsec )/1000000000.f;
+        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 ] ) ) {
                                                                      borderSize,
                                                                      highlight,
                                                                      r, g, b, a );
+                            // Haha why is this so hard to cast?
+                            ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
                         } else {
                             selection = new slop::XSelectRectangle( t.m_x, t.m_y,
                                                                     t.m_x + t.m_width,
                     // 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++;
                                                                  borderSize,
                                                                  highlight,
                                                                  r, g, b, a );
+                        // Haha why is this so hard to cast?
+                        ((slop::GLSelectRectangle*)(selection))->setMagnifySettings( magenabled, magstrength, magpixels );
                     } else {
                         selection = new slop::XSelectRectangle( sx, sy,
                                                                 ex, ey,
                 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;
                 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->setGeo( sx + xoffset, sy + yoffset, ex-1, ey-1 );
+                selection->update( deltatime );
                 break;
             }
             case 3: {

src/options.ggo

     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 "format" f "Set the output format string. Format specifiers are %x, %y, %w, %h, %i, %g, and %c."
     string
     default="REPLACEME"

src/selectrectangle.cpp

 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

 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;

src/x.cpp

     //m_root      = RootWindow     ( m_display, XScreenNumberOfScreen( m_screen ) );
     m_root      = DefaultRootWindow( m_display );
 
+    m_res = XRRGetScreenResourcesCurrent( m_display, m_root);
+
     m_good = true;
     XSetErrorHandler( slop::XEngineErrorHandler );
     selectAllInputs( m_root, EnterWindowMask );
     return EXIT_SUCCESS;
 }
 
+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;
+}
+
 bool slop::XEngine::keyPressed( KeySym key ) {
     KeyCode keycode = XKeysymToKeycode( m_display, key );
     if ( keycode != 0 ) {
     if ( !m_good ) {
         return EXIT_FAILURE;
     }
-    int xfontcursor = getCursor( type );
+    int xfontcursor = makeCursor( type );
     int err = XGrabPointer( m_display, m_root, True,
                             PointerMotionMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask,
                             GrabModeAsync, GrabModeAsync, None, xfontcursor, CurrentTime );
 }
 
 // This converts an enum into a preallocated cursor, the cursor will automatically deallocate itself on ~XEngine
-Cursor slop::XEngine::getCursor( slop::CursorType type ) {
+Cursor slop::XEngine::makeCursor( slop::CursorType type ) {
     int xfontcursor;
     switch ( type ) {
         default:
     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;
     }
-    Cursor xfontcursor = getCursor( type );
+    m_currentCursor = type;
+    Cursor xfontcursor = makeCursor( type );
     XChangeActivePointerGrab( m_display,
                               PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
                               xfontcursor, CurrentTime );

src/x.hpp

 #include <X11/Xlib.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/shape.h>
+#include <X11/extensions/Xrandr.h>
 
 #include <stdlib.h>
 #include <cstring>
     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();
+    std::vector<XRRCrtcInfo*>        getCRTCS();
+    void                freeCRTCS( std::vector<XRRCrtcInfo*> monitors );
     int                 m_mousex;
     int                 m_mousey;
     Display*            m_display;
     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              getCursor( slop::CursorType type );
+    Cursor              makeCursor( slop::CursorType type );
     void                selectAllInputs( Window win, long event_mask);
 };