changing the interface to support pure C

src/main.cpp

 
 using namespace slop;
 
-template<typename Out>
-static void split(const std::string &s, char delim, Out result) {
-    std::stringstream ss;
-    ss.str(s);
-    std::string item;
-    while (std::getline(ss, item, delim)) {
-        *(result++) = item;
-    }
-}
-
-static std::vector<std::string> split(const std::string &s, char delim) {
-    std::vector<std::string> elems;
-    split(s, delim, std::back_inserter(elems));
-    return elems;
-}
-
 glm::vec4 parseColor( std::string value ) {
     std::string valuecopy = value;
     glm::vec4 found;
 SlopOptions* getOptions( cxxopts::Options& options ) {
     slop::SlopOptions* foo = new slop::SlopOptions();
     if ( options.count( "bordersize" ) > 0 ) {
-        foo->borderSize = options["bordersize"].as<float>();
+        foo->border = options["bordersize"].as<float>();
     }
     if ( options.count( "padding" ) > 0 ) {
         foo->padding = options["padding"].as<float>();
         foo->nokeyboard = options["nokeyboard"].as<bool>();
     }
     if ( options.count( "xdisplay" ) > 0 ) {
-        foo->xdisplay = options["xdisplay"].as<std::string>();
+        std::string xdisplay = options["xdisplay"].as<std::string>();
+        char* cxdisplay = new char[xdisplay.length()+1];
+        memcpy( cxdisplay, xdisplay.c_str(), xdisplay.length() );
+        cxdisplay[xdisplay.length()]='\0';
+        foo->xdisplay = cxdisplay;
     }
-    std::string shaders = "textured";
     if ( options.count( "shader" ) > 0 ) {
-        shaders = options["shader"].as<std::string>();
+        std::string shaders = options["shader"].as<std::string>();
+        char* cshaders = new char[shaders.length()+1];
+        memcpy( cshaders, shaders.c_str(), shaders.length() );
+        cshaders[shaders.length()]='\0';
+        foo->shaders = cshaders;
     }
-    foo->shaders = split( shaders, ',' );
     if ( options.count( "noopengl" ) > 0 ) {
         foo->noopengl = options["noopengl"].as<bool>();
     }
     if ( options.count( "highlight" ) > 0 ) {
         foo->highlight = options["highlight"].as<bool>();
     }
+    if ( options.count( "quiet" ) > 0 ) {
+        foo->quiet = options["quiet"].as<bool>();
+    }
     if ( options.count( "nodecorations" ) > 0 ) {
         foo->nodecorations = options["nodecorations"].as<int>();
         if ( foo->nodecorations < 0 || foo->nodecorations > 2 ) {
     return foo;
 }
 
-std::string formatOutput( std::string input, SlopSelection selection, bool cancelled ) {
+std::string formatOutput( std::string input, SlopSelection selection ) {
     std::stringstream output;
     for( unsigned int i=0;i<input.length();i++) {
         if ( input[i] == '%' ) {
                 case 'w':
                 case 'W': output << round(selection.w); break;
                 case 'c':
-                case 'C': output << cancelled; break;
+                case 'C': output << selection.cancelled; break;
                 case 'h':
                 case 'H': output << round(selection.h); break;
                 case 'g':
     options.parse_positional("positional");
     options.parse(argc, argv);
     // Options just validates all of our input from argv
-    bool quiet = false;
-    if ( options.count( "quiet" ) > 0 ) {
-        quiet = options["quiet"].as<bool>();
-    }
     auto& positional = options["positional"].as<std::vector<std::string>>();
     if ( positional.size() > 0 ) {
         throw new std::invalid_argument("Unexpected positional argument: " + positional[0]);
 
     // We want to validate our format option if we got one, we do that by just doing a dry run
     // on a fake selection.
-    SlopSelection selection(0,0,0,0,0);
+    SlopSelection selection(0,0,0,0,0,true);
     std::string format;
     bool gotFormat = options.count( "format" ) > 0;
     if ( gotFormat ) {
         format = options["format"].as<std::string>();
-        formatOutput( format, selection, false );
+        formatOutput( format, selection );
     }
 
     // Finally we do the real selection.
-    bool cancelled = false;
-    selection = SlopSelect(parsedOptions, &cancelled, quiet);
+    selection = SlopSelect(parsedOptions);
     
     // Here we're done with the parsed option data.
     delete parsedOptions;
     // We know if we cancelled or not
-    if ( cancelled ) {
-        if ( !quiet ) {
+    if ( selection.cancelled ) {
+        if ( !parsedOptions->quiet ) {
             std::cerr << "Selection was cancelled by keystroke or right-click.\n";
         }
         return 1;
     }
     // If we recieved a format option, we output the specified output.
     if ( gotFormat ) {
-        std::cout << formatOutput( format, selection, cancelled );
+        std::cout << formatOutput( format, selection );
         return 0;
     }
-    std::cout << formatOutput( "%g\n", selection, cancelled );
+    std::cout << formatOutput( "%g\n", selection );
     return 0;
 }
 

src/slop.cpp

 
 #include <chrono>
 #include <thread>
+#include <string>
+#include <vector>
 
 #include <stdlib.h>
 
 Keyboard* keyboard;
 Resource* resource;
 
-SlopSelection GLSlopSelect( slop::SlopOptions* options, bool* cancelled, slop::SlopWindow* window );
-SlopSelection XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled);
+SlopSelection GLSlopSelect( slop::SlopOptions* options, slop::SlopWindow* window );
+SlopSelection XShapeSlopSelect( slop::SlopOptions* options );
 
 static int TmpXError(Display * d, XErrorEvent * ev) {
     return 0;
 
 }
 
+template<typename Out>
+static void split(const std::string &s, char delim, Out result) {
+    std::stringstream ss;
+    ss.str(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+        *(result++) = item;
+    }
+}
+
+static std::vector<std::string> split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    split(s, delim, std::back_inserter(elems));
+    return elems;
+}
+
+
 using namespace slop;
 
+char slop_default_xdisplay[] = ":0";
+char slop_default_shaders[] = "textured";
+
 // Defaults!
 slop::SlopOptions::SlopOptions() {
-    borderSize = 1;
+    border = 1;
     nokeyboard = false;
     noopengl = false;
     nodecorations = false;
     tolerance = 2;
     padding = 0;
-    shaders.push_back("textured");
+    shaders = slop_default_shaders;
     highlight = false;
     r = 0.5;
     g = 0.5;
     b = 0.5;
     a = 1;
+    quiet = false;
 
-    char * envdisplay = getenv("DISPLAY");
-    if (envdisplay == NULL)
-        xdisplay = ":0";
-    else
+    char* envdisplay = getenv("DISPLAY");
+    if (envdisplay == NULL) {
+        xdisplay = slop_default_xdisplay;
+    } else {
         xdisplay = envdisplay;
+    }
 }
 
-slop::SlopSelection::SlopSelection( float x, float y, float w, float h, int id ) {
+slop::SlopSelection::SlopSelection( float x, float y, float w, float h, int id, bool cancelled ) {
     this->x = x;
     this->y = y;
     this->w = w;
     this->h = h;
     this->id = id;
+    this->cancelled = cancelled;
 }
 
-slop::SlopSelection slop::SlopSelect( slop::SlopOptions* options, bool* cancelled, bool quiet) {
-    slop::SlopSelection returnval(0,0,0,0,0);
+slop::SlopSelection slop::SlopSelect( slop::SlopOptions* options ) {
+    slop::SlopSelection returnval(0,0,0,0,0,true);
     bool deleteOptions = false;
     if ( !options ) {
         deleteOptions = true;
     }
     if ( !success ) {
         // If we fail, we launch the XShape version of slop.
-        if ( !quiet && !options->noopengl ) {
+        if ( !options->quiet && !options->noopengl ) {
             if ( errorstring.length() <= 0 ) {
                 errorstring += "Failed to launch OpenGL context, --shader parameter will be ignored.\n";
                 std::cerr << errorstring;
                 std::cerr << errorstring;
             }
         }
-        returnval = slop::XShapeSlopSelect( options, cancelled );
+        returnval = slop::XShapeSlopSelect( options );
     } else {
-        returnval = slop::GLSlopSelect( options, cancelled, window );
+        returnval = slop::GLSlopSelect( options, window );
     }
     delete x11;
     delete slop::resource;
     return returnval;
 }
 
-slop::SlopSelection slop::XShapeSlopSelect( slop::SlopOptions* options, bool* cancelled ) {
+slop::SlopSelection slop::XShapeSlopSelect( slop::SlopOptions* options ) {
     // Init our little state machine, memory is a tad of a misnomer
-    slop::SlopMemory* memory = new slop::SlopMemory( options, new XShapeRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
+    bool cancelled = false;
+    slop::SlopMemory* memory = new slop::SlopMemory( options, new XShapeRectangle(glm::vec2(0,0), glm::vec2(0,0), options->border, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
     slop::mouse = new slop::Mouse( x11, options->nodecorations, ((XShapeRectangle*)memory->rectangle)->window );
 
     // We have no GL context, so the matrix is useless...
         // Then we draw the framebuffer to the screen
         if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) {
             memory->running = false;
-            if ( cancelled ) {
-                *cancelled = true;
-            }
-        } else {
-            *cancelled = false;
+            cancelled = true;
         }
     }
 
         tries++;
     }
     // Finally return the data.
-    return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow );
+    return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow, cancelled );
 }
 
-slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, bool* cancelled, SlopWindow* window ) {
+slop::SlopSelection slop::GLSlopSelect( slop::SlopOptions* options, SlopWindow* window ) {
+    bool cancelled = false;
     slop::mouse = new slop::Mouse( x11, options->nodecorations, window->window );
 
     std::string vert = "#version 120\nattribute vec2 position;\nattribute vec2 uv;\nvarying vec2 uvCoord;\nvoid main()\n{\nuvCoord = uv;\ngl_Position = vec4(position,0,1);\n}\n";
     std::string frag = "#version 120\nuniform sampler2D texture;\nvarying vec2 uvCoord;\nvoid main()\n {\ngl_FragColor = texture2D( texture, uvCoord );\n}\n";
     slop::Shader* textured = new slop::Shader( vert, frag, false );
     std::vector<slop::Shader*> shaders;
-    for( int i=0;i<options->shaders.size();i++ ) {
-        std::string sn = options->shaders[i];
+    std::vector<std::string> stringShaders = split( options->shaders, ',' );
+    for( int i=0;i<stringShaders.size();i++ ) {
+        std::string sn = stringShaders[i];
         if ( sn != "textured" ) {
             shaders.push_back( new slop::Shader( sn + ".vert", sn + ".frag" ) );
         } else {
         }
     }
     // Init our little state machine, memory is a tad of a misnomer
-    slop::SlopMemory* memory = new slop::SlopMemory( options, new GLRectangle(glm::vec2(0,0), glm::vec2(0,0), options->borderSize, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
+    slop::SlopMemory* memory = new slop::SlopMemory( options, new GLRectangle(glm::vec2(0,0), glm::vec2(0,0), options->border, options->padding, glm::vec4( options->r, options->g, options->b, options->a ), options->highlight) );
 
     slop::Framebuffer* pingpong = new slop::Framebuffer(WidthOfScreen(x11->screen), HeightOfScreen(x11->screen));
 
         }
         if ( (!options->nokeyboard && slop::keyboard->anyKeyDown()) || slop::mouse->getButton( 3 ) ) {
             memory->running = false;
-            if ( cancelled ) {
-                *cancelled = true;
-            }
-        } else {
-            *cancelled = false;
+            cancelled = true;
         }
     }
 
         tries++;
     }
     // Finally return the data.
-    return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow );
+    return slop::SlopSelection( output.x, output.y, output.z, output.w, selectedWindow, cancelled );
 }

src/slop.hpp

 #ifndef N_SLOP_H_
 #define N_SLOP_H_
 
-#include <string>
-#include <vector>
-
 namespace slop {
 
 class SlopOptions {
 public:
     SlopOptions();
-    float borderSize;
+    bool quiet;
+    float border;
     float padding;
     float tolerance;
     bool highlight;
     bool noopengl;
     bool nokeyboard;
     int nodecorations;
-    std::vector<std::string> shaders;
+    char* shaders;
     float r;
     float g;
     float b;
     float a;
-    std::string xdisplay;
+    char* xdisplay;
 };
 
 class SlopSelection {
 public:
-    SlopSelection( float x, float y, float w, float h, int id );
+    SlopSelection( float x, float y, float w, float h, int id, bool cancelled );
+    bool cancelled;
     float x;
     float y;
     float w;
     int id;
 };
 
-SlopSelection SlopSelect( SlopOptions* options = NULL, bool* cancelled = NULL, bool quiet = false );
+SlopSelection SlopSelect( SlopOptions* options = NULL );
 
 }