added a prototype legacy mode

CMakeLists.txt

@@ -1,4 +1,3 @@
-#Change this if you need to target a specific CMake version
 cmake_minimum_required(VERSION 2.6)
 
 set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build (Debug or Release)")
@@ -6,8 +5,16 @@ if ( NOT CMAKE_INSTALL_PREFIX )
     set(CMAKE_INSTALL_PREFIX "/usr")
 endif()
 
+if ( NOT SLOP_LEGACY_MODE )
+    set(SLOP_LEGACY_MODE FALSE CACHE BOOL "Legacy mode requires the XShape extension, is laggy, isn't guaranteed to be invisible on shutdown, isn't guaranteed to support opacity, and doesn't support custom shaders. Though it still might be desired since it doesn't require OpenGL to use.")
+endif()
+
 project(slop)
+
 add_definitions(-DSLOP_VERSION="v5.3.21")
+if ( SLOP_LEGACY_MODE )
+    add_definitions(-DSLOP_LEGACY_MODE=true)
+endif()
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/bin/")
 
@@ -17,40 +24,53 @@ include_directories("${PROJECT_BINARY_DIR}")
 set(EXECUTABLE_NAME "slop")
 
 set( source src/x.cpp
-            src/window.cpp
             src/windowhelper.cpp
             src/mouse.cpp
             src/keyboard.cpp
-            src/framebuffer.cpp
             src/resource.cpp
             src/options.cpp
-            src/gl_core_3_3.c
-            src/shader.cpp
             src/slopstates.cpp
-            src/slop.cpp
-            src/rectangle.cpp
             src/main.cpp )
 
-add_executable(${EXECUTABLE_NAME} ${source})
+if ( SLOP_LEGACY_MODE )
+    set ( source ${source}
+                 src/xslop.cpp
+                 src/xshaperectangle.cpp )
+else()
+    set ( source ${source}
+                 src/window.cpp
+                 src/glslop.cpp
+                 src/rectangle.cpp
+                 src/framebuffer.cpp
+                 src/gl_core_3_3.c
+                 src/shader.cpp )
+endif()
 
+add_executable(${EXECUTABLE_NAME} ${source})
 
-# Detect and add SFML
+# Detect and add cmake modules
 set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/modules" )
-#Find any version 2.X of SFML
-#See the FindSFML.cmake file for additional details and instructions
-find_package(OpenGL REQUIRED)
 find_package(GLM REQUIRED)
-find_package(GLX REQUIRED)
 find_package(X11 REQUIRED)
 
 include_directories(${X11_INCLUDE_DIR}
-                    ${GLM_INCLUDE_DIR}
-                    ${GLX_INCLUDE_DIR}
-                    ${OPENGL_INCLUDE_DIR})
-
+                    ${GLM_INCLUDE_DIR})
 target_link_libraries(${EXECUTABLE_NAME} ${X11_LIBRARIES}
-                                         ${GLX_LIBRARIES}
-                                         ${OPENGL_LIBRARIES})
+                                         ${GLM_LIBRARIES})
+
+# Either we require OpenGL, or we require the XShape extension.
+if ( SLOP_LEGACY_MODE )
+    find_package(XExt REQUIRED)
+    include_directories(${XEXT_INCLUDE_DIR})
+    target_link_libraries(${EXECUTABLE_NAME} ${XEXT_LIBRARIES})
+else()
+    find_package(GLX REQUIRED)
+    find_package(OpenGL REQUIRED)
+    include_directories(${GLX_INCLUDE_DIR}
+                        ${OPENGL_INCLUDE_DIR})
+    target_link_libraries(${EXECUTABLE_NAME} ${OPENGL_LIBRARIES}
+                                             ${GLX_LIBRARY})
+endif()
 
 # Install targets
 install( TARGETS ${EXECUTABLE_NAME} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" )

src/slop.cpp → src/glslop.cpp

@@ -1,4 +1,4 @@
-#include "slop.hpp"
+#include "glslop.hpp"
 
 X11* x11;
 Mouse* mouse;

src/slop.hpp → src/glslop.hpp

@@ -1,4 +1,4 @@
-/* slop.hpp: exposes a selection interface
+/* glslop.hpp: exposes an opengl selection interface
  *
  * Copyright (C) 2014: Dalton Nell, Slop Contributors (https://github.com/naelstrof/slop/graphs/contributors).
  *

src/main.cpp

@@ -20,7 +20,11 @@
 
 #include <iostream>
 #include <sstream>
-#include "slop.hpp"
+#ifdef SLOP_LEGACY_MODE
+#include "xslop.hpp"
+#else
+#include "glslop.hpp"
+#endif
 #include "options.hpp"
 
 SlopOptions* getOptions( Options& options ) {
@@ -31,12 +35,14 @@ SlopOptions* getOptions( Options& options ) {
     glm::vec4 color = glm::vec4( foo->r, foo->g, foo->b, foo->a );
     options.getColor("color", 'c', color);
     options.getString( "xdisplay", 'x', foo->xdisplay );
+#ifndef SLOP_LEGACY_MODE
     options.getString( "shader", 's', foo->shader );
+#endif
     foo->r = color.r;
     foo->g = color.g;
     foo->b = color.b;
     foo->a = color.a;
-    options.getBool("highlight", 'h', foo->highlight);
+    options.getBool("highlight", 'l', foo->highlight);
     options.getBool("nodecorations", 'n', foo->nodecorations);
     return foo;
 }
@@ -111,8 +117,10 @@ void printHelp() {
 	std::cout << "                                  highlights it. This is only useful when\n";
 	std::cout << "                                  --color is set to a transparent color.\n";
 	std::cout << "                                  (default=off)\n";
+#ifndef SLOP_LEGACY_MODE
 	std::cout << "      --shader=STRING           Sets the shader to load and use from\n";
 	std::cout << "                                  ~/.config/slop/\n";
+#endif
 	std::cout << "                                  (default=`simple')\n";
 	std::cout << "  -f, --format=STRING           Set the output format string. Format specifiers\n";
 	std::cout << "                                  are %x, %y, %w, %h, %i, %g, and %c.\n";

src/options.hpp

@@ -29,7 +29,7 @@
 #include <glm/glm.hpp>
 
 static std::string validStringArguments[] = { "bordersize", "padding", "color", "shader", "highlight", "format", "tolerance", "nodecorations", "nokeyboard", "help", "xdisplay", "version" };
-static char validCharArguments[] = { 'b', 'p', 'c', 's', 'h', 'f', 't', 'n', 'k', 'h', 'x', 'v' };
+static char validCharArguments[] = { 'b', 'p', 'c', 's', 'l', 'f', 't', 'n', 'k', 'h', 'x', 'v' };
 static unsigned int isFlagArgument[] = { false, false, false, false, true, false, false, true, true, true, false, true };
 static unsigned int validArgumentCount = 12;
 static unsigned int maxFloatingValues = 0;

src/slopstates.hpp

@@ -22,9 +22,15 @@
 #define N_SLOPSTATES_H_
 
 #include "mouse.hpp"
-#include "rectangle.hpp"
 #include "windowhelper.hpp"
-#include "slop.hpp"
+
+#ifdef SLOP_LEGACY_MODE
+#include "xslop.hpp"
+#include "xshaperectangle.hpp"
+#else
+#include "glslop.hpp"
+#include "rectangle.hpp"
+#endif
 
 class SlopMemory;
 

src/xshaperectangle.cpp

@@ -0,0 +1,141 @@
+#include "xshaperectangle.hpp"
+
+Rectangle::Rectangle( glm::vec2 p1, glm::vec2 p2, float border, float padding, glm::vec4 color, bool highlight ) {
+    this->color = convertColor( color );
+    this->border = border;
+    this->padding = padding;
+    this->highlight = highlight;
+    this->alpha = color.a;
+    // Find each corner of the rectangle
+    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    // Offset the inner corners by the padding.
+    ul = ul + glm::vec2(-padding,padding);
+    bl = bl + glm::vec2(-padding,-padding);
+    ur = ur + glm::vec2(padding,padding);
+    br = br + glm::vec2(padding,-padding);
+    // Create the outer corners by offsetting the inner by the bordersize
+    oul = ul + glm::vec2(-border,border);
+    obl = bl + glm::vec2(-border,-border);
+    our = ur + glm::vec2(border,border);
+    obr = br + glm::vec2(border,-border);
+
+    XSetWindowAttributes attributes;
+    // Set up the window so it's our color 
+    attributes.background_pixel = this->color.pixel;
+    // Disable window decorations.
+    attributes.override_redirect = True;
+    // Make sure we know when we've been successfully destroyed later!
+    attributes.event_mask = StructureNotifyMask;
+    unsigned long valueMask = CWBackPixel | CWOverrideRedirect | CWEventMask;
+    // Create the window
+    window = XCreateWindow( x11->display, x11->root, 0, 0, WidthOfScreen( x11->screen ), HeightOfScreen( x11->screen ),
+                              0, CopyFromParent, InputOutput,
+                              CopyFromParent, valueMask, &attributes );
+    if ( alpha < 1 ) {
+        // Change the window opacity
+        unsigned int cardinal_alpha = (unsigned int) (alpha * (unsigned int)-1) ;
+        XChangeProperty( x11->display, window, XInternAtom( x11->display, "_NET_WM_WINDOW_OPACITY", 0),
+                         XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&cardinal_alpha, 1 );
+    }
+    // Set the class hint, and title to "slop"
+    XClassHint classhints;
+    char name[] = "slop";
+    classhints.res_name = name;
+    classhints.res_class = name;
+    XSetClassHint( x11->display, window, &classhints );
+    // Now punch a hole into it so it looks like a selection rectangle, but only if we're not highlighting.
+    generateHoles();
+    createdWindow = false;
+}
+
+void Rectangle::createWindow() {
+    if ( createdWindow ) {
+        return;
+    }
+	XMapWindow( x11->display, window );
+    createdWindow = true;
+}
+
+void Rectangle::generateHoles() {
+    if ( !highlight ) {
+        XRectangle rects[4];
+        // Left
+        rects[0].x = oul.x;
+        rects[0].y = obl.y;
+        rects[0].width = border;
+        rects[0].height = oul.y-obl.y;
+        // Top
+        rects[1].x = ul.x;
+        rects[1].y = obl.y;
+        rects[1].width = ur.x-ul.x;
+        rects[1].height = border;
+        // Right
+        rects[2].x = ur.x;
+        rects[2].y = obr.y;
+        rects[2].width = border;
+        rects[2].height = our.y - obr.y;
+        // Bottom
+        rects[3].x = bl.x;
+        rects[3].y = ul.y;
+        rects[3].width = br.x-bl.x;
+        rects[3].height = border;
+        XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, rects, 4, ShapeSet, 0);
+        return;
+    }
+    XRectangle rect;
+    rect.x = oul.x;
+    rect.y = obl.y;
+    rect.width = our.x-oul.x;
+    rect.height = oul.y-obl.y;
+    XShapeCombineRectangles( x11->display, window, ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
+}
+
+void Rectangle::setPoints( glm::vec2 p1, glm::vec2 p2 ) {
+    // Find each corner of the rectangle
+    ul = glm::vec2( glm::min( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    bl = glm::vec2( glm::min( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    ur = glm::vec2( glm::max( p1.x, p2.x ), glm::max( p1.y, p2.y ) ) ;
+    br = glm::vec2( glm::max( p1.x, p2.x ), glm::min( p1.y, p2.y ) ) ;
+    // Offset the inner corners by the padding.
+    ul = ul + glm::vec2(-padding,padding);
+    bl = bl + glm::vec2(-padding,-padding);
+    ur = ur + glm::vec2(padding,padding);
+    br = br + glm::vec2(padding,-padding);
+    // Create the outer corners by offsetting the inner by the bordersize
+    oul = ul + glm::vec2(-border,border);
+    obl = bl + glm::vec2(-border,-border);
+    our = ur + glm::vec2(border,border);
+    obr = br + glm::vec2(border,-border);
+    generateHoles();
+}
+
+Rectangle::~Rectangle() {
+}
+
+void Rectangle::draw( glm::mat4& matrix ) {
+    // We don't want to be visible until we're asked to draw.
+    createWindow();
+}
+
+glm::vec4 Rectangle::getRect() {
+    return glm::vec4( bl.x, bl.y, ur.x-ul.x, ul.y-bl.y );
+}
+
+XColor Rectangle::convertColor( glm::vec4 color ) {
+    // Convert float colors to shorts.
+    short red   = short( floor( color.r * 65535.f ) );
+    short green = short( floor( color.g * 65535.f ) );
+    short blue  = short( floor( color.b * 65535.f ) );
+    XColor xc;
+    xc.red = red;
+    xc.green = green;
+    xc.blue = blue;
+    int err = XAllocColor( x11->display, DefaultColormap( x11->display, XScreenNumberOfScreen( x11->screen ) ), &xc );
+    if ( err == BadColor ) {
+        throw new std::runtime_error(std::string("Couldn't allocate a color"));
+    }
+    return xc;
+}

src/xshaperectangle.hpp

@@ -0,0 +1,58 @@
+/* xshaperectangle.hpp: A rectangle that doesn't use OpenGL to function.
+ *
+ * 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 N_XSHAPERECTANGLE_H_
+#define N_XSHAPERECTANGLE_H_
+
+#include <iostream>
+#include <glm/glm.hpp>
+#include <vector>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/shape.h>
+
+#include "x.hpp"
+
+class Rectangle {
+private:
+    glm::vec2 ul, oul;
+    glm::vec2 bl, obl;
+    glm::vec2 ur, our;
+    glm::vec2 br, obr;
+    bool createdWindow;
+    bool highlight;
+    float border;
+    float padding;
+    XColor color;
+    float alpha;
+    XColor convertColor( glm::vec4 color );
+    void generateHoles();
+    void createWindow();
+public:
+    Window window;
+    glm::vec4 getRect();
+    Rectangle(glm::vec2 p1, glm::vec2 p2, float border = 1, float padding = 0, glm::vec4 color = glm::vec4(1,1,1,1), bool highlight = false );
+    ~Rectangle();
+    void setPoints( glm::vec2 p1, glm::vec2 p2 );
+    void draw(glm::mat4& matrix);
+};
+
+#endif // N_XSHAPERECTANGLE_H_

src/xslop.cpp

@@ -0,0 +1,127 @@
+#include "xslop.hpp"
+
+X11* x11;
+Mouse* mouse;
+Keyboard* keyboard;
+Resource* resource;
+
+// Defaults!
+SlopOptions::SlopOptions() {
+    borderSize = 1;
+    nodecorations = false;
+    tolerance = 2;
+    padding = 0;
+    highlight = false;
+    xdisplay = ":0";
+    r = 0.5;
+    g = 0.5;
+    b = 0.5;
+    a = 1;
+}
+
+SlopSelection::SlopSelection( float x, float y, float w, float h, Window id ) {
+    this->x = x;
+    this->y = y;
+    this->w = w;
+    this->h = h;
+    this->id = id;
+}
+
+SlopMemory::SlopMemory( SlopOptions* options ) {
+    running = true;
+    state = (SlopState*)new SlopStart();
+    nextState = NULL;
+    tolerance = options->tolerance;
+    nodecorations = options->nodecorations;
+    rectangle = new Rectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight);
+    selectedWindow = x11->root;
+    state->onEnter( *this );
+}
+
+SlopMemory::~SlopMemory() {
+    delete state;
+    if ( nextState ) {
+        delete nextState;
+    }
+    delete rectangle;
+}
+
+void SlopMemory::update( double dt ) {
+    state->update( *this, dt );
+    if ( nextState ) {
+        state->onExit( *this );
+        delete state;
+        state = nextState;
+        state->onEnter( *this );
+        nextState = NULL;
+    }
+}
+
+void SlopMemory::setState( SlopState* state ) {
+    if ( nextState ) {
+        delete nextState;
+    }
+    nextState = state;
+}
+
+void SlopMemory::draw( glm::mat4& matrix ) {
+    state->draw( *this, matrix );
+}
+
+SlopSelection SlopSelect( SlopOptions* options, bool* cancelled ) {
+    bool deleteOptions = false;
+    if ( !options ) {
+        deleteOptions = true;
+        options = new SlopOptions();
+    }
+    resource = new Resource();
+    // Set up x11 temporarily
+    x11 = new X11(options->xdisplay);
+    keyboard = new Keyboard( x11 );
+
+    // Init our little state machine, memory is a tad of a misnomer
+    SlopMemory memory( options );
+    mouse = new Mouse( x11, options->nodecorations, memory.rectangle->window );
+
+    glm::mat4 fake;
+    // This is where we'll run through all of our stuffs
+    while( memory.running ) {
+        mouse->update();
+        keyboard->update();
+        // We move our statemachine forward.
+        memory.update( 1 );
+
+        // We don't actually draw anything, but the state machine uses
+        // this to know when to spawn the window.
+        memory.draw( fake );
+
+        // X11 explodes if we update as fast as possible, here's a tiny sleep.
+        //std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        XFlush(x11->display);
+
+        // Then we draw the framebuffer to the screen
+        if ( keyboard->anyKeyDown() || mouse->getButton( 3 ) ) {
+            memory.running = false;
+            if ( cancelled ) {
+                *cancelled = true;
+            }
+        } else {
+            *cancelled = false;
+        }
+    }
+
+    // Now we should have a selection! We parse everything we know about it here.
+    glm::vec4 output = memory.rectangle->getRect();
+
+    // Lets now clear both front and back buffers before closing.
+    // hopefully it'll be completely transparent while closing!
+    // Then we clean up.
+    delete mouse;
+    delete x11;
+    delete resource;
+    if ( deleteOptions ) {
+        delete options;
+    }
+    // Finally return the data.
+    return SlopSelection( output.x, output.y, output.z, output.w, memory.selectedWindow );
+}

src/xslop.hpp

@@ -0,0 +1,80 @@
+/* slop.hpp: exposes a selection interface
+ *
+ * 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 N_SLOP_H_
+#define N_SLOP_H_
+
+#include <string>
+#include <chrono>
+#include <thread>
+
+#include "xshaperectangle.hpp"
+#include "slopstates.hpp"
+#include "keyboard.hpp"
+#include "mouse.hpp"
+#include "resource.hpp"
+
+class SlopState;
+
+class SlopOptions {
+public:
+    SlopOptions();
+    float borderSize;
+    float padding;
+    float tolerance;
+    bool highlight;
+    bool nodecorations;
+    float r;
+    float g;
+    float b;
+    float a;
+    std::string xdisplay;
+};
+
+class SlopSelection {
+public:
+    SlopSelection( float x, float y, float w, float h, Window id );
+    float x;
+    float y;
+    float w;
+    float h;
+    Window id;
+};
+
+class SlopMemory {
+private:
+    SlopState* state;
+    SlopState* nextState;
+public:
+    SlopMemory( SlopOptions* options );
+    ~SlopMemory();
+    Window selectedWindow;
+    bool running;
+    float tolerance;
+    bool nodecorations;
+    Rectangle* rectangle;
+    void setState( SlopState* state );
+    void update( double dt );
+    void draw( glm::mat4& matrix );
+};
+
+SlopSelection SlopSelect( SlopOptions* options = NULL, bool* cancelled = NULL );
+
+#endif // N_SLOP_H_