Switched to using a POSIX compliant argument parser. This will break scripts! sorry

CMakeLists.txt

@@ -21,7 +21,7 @@ endif()
 
 include_directories("${PROJECT_BINARY_DIR}")
 
-add_definitions(-DSLOP_VERSION="v5.3.38")
+add_definitions(-DSLOP_VERSION="v6.3.38")
 
 # The names have to be unique unfortunately.
 set(EXECUTABLE_NAME "slop")
@@ -44,8 +44,7 @@ add_library(${LIBRARY_NAME} SHARED  src/mouse.cpp
 set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
 set_property(TARGET ${LIBRARY_NAME} PROPERTY CXX_STANDARD 11)
 
-add_executable(${EXECUTABLE_NAME} src/options.cpp
-                                  src/main.cpp)
+add_executable(${EXECUTABLE_NAME} src/main.cpp)
 
 set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
 set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD 11)

README.md

@@ -86,21 +86,21 @@ Shaders are loaded from the `--shader` flag in slop. They are delimited by comma
 Enough chatting about it though, here's some example shaders you can copy from [shaderexamples](https://github.com/naelstrof/slop/tree/master/shaderexamples) to `~/.config/slop` to try out!
 
 The files listed to the right of the `|` are the required files for the command to the left to work correctly.
-* `slop -rblur1,blur2 -b100` | `~/.config/slop/{blur1,blur2}{.frag,.vert}`
+* `slop -r blur1,blur2 -b 100` | `~/.config/slop/{blur1,blur2}{.frag,.vert}`
 
 ![slop blur](https://my.mixtape.moe/bvsrzr.png)
 
-* `slop -rwiggle -b10` | `~/.config/slop/wiggle{.frag,.vert}`
+* `slop -r wiggle -b 10` | `~/.config/slop/wiggle{.frag,.vert}`
 
 ![slop animation](http://i.giphy.com/12vjSbFZ0CWDW8.gif)
 
 And all together now...
-* `slop -rblur1,blur2,wiggle -b50 -c1,1,1` | `~/.config/slop/{blur1,blur2,wiggle}{.frag,.vert}`
+* `slop -r blur1,blur2,wiggle -b 50 -c 1,1,1` | `~/.config/slop/{blur1,blur2,wiggle}{.frag,.vert}`
 
 ![slop animation](http://i.giphy.com/kfBLafeJfLs2Y.gif)
 
 Finally here's an example of a magnifying glass.
-* `slop -rcrosshair` | `~/.config/slop/crosshair{.frag,.vert}`
+* `slop -r crosshair` | `~/.config/slop/crosshair{.frag,.vert}`
 
 ![slop animation](http://i.giphy.com/2xy0fC2LOFQfm.gif)
 

src/main.cpp

@@ -20,8 +20,12 @@
 
 #include <iostream>
 #include <sstream>
+#include <string>
+#include <vector>
+#include <glm/glm.hpp>
+
+#include "cxxopts.hpp"
 #include "slop.hpp"
-#include "options.hpp"
 
 using namespace slop;
 
@@ -34,41 +38,79 @@ static void split(const std::string &s, char delim, Out result) {
         *(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;
 }
 
-SlopOptions* getOptions( Options& options ) {
-    SlopOptions* foo = new SlopOptions();
-    options.getFloat("bordersize", 'b', foo->borderSize);
-    options.getFloat("padding", 'p', foo->padding);
-    options.getFloat("tolerance", 't', foo->tolerance);
+glm::vec4 parseColor( std::string value ) {
+    std::string valuecopy = value;
+    glm::vec4 found;
+    std::string::size_type sz;
+    try {
+        found[0] = std::stof(value,&sz);
+        value = value.substr(sz+1);
+        found[1] = std::stof(value,&sz);
+        value = value.substr(sz+1);
+        found[2] = std::stof(value,&sz);
+        if ( value.size() != sz ) {
+            value = value.substr(sz+1);
+            found[3] = std::stof(value,&sz);
+            if ( value.size() != sz ) {
+                throw "dur";
+            }
+        } else {
+            found[3] = 1;
+        }
+    } catch ( ... ) {
+        throw new std::invalid_argument("Unable to parse value `" + valuecopy + "` as a color. Should be in the format r,g,b or r,g,b,a. Like 1,1,1,1.");
+    }
+    return found;
+}
+
+SlopOptions* getOptions( cxxopts::Options& options ) {
+    slop::SlopOptions* foo = new slop::SlopOptions();
+    if ( options.count( "bordersize" ) > 0 ) {
+        foo->borderSize = options["bordersize"].as<float>();
+    }
+    if ( options.count( "padding" ) > 0 ) {
+        foo->padding = options["padding"].as<float>();
+    }
+    if ( options.count( "tolerance" ) > 0 ) {
+        foo->tolerance = options["tolerance"].as<float>();
+    }
     glm::vec4 color = glm::vec4( foo->r, foo->g, foo->b, foo->a );
-    options.getColor("color", 'c', color);
-    options.getBool("nokeyboard", 'k', foo->nokeyboard);
-    options.getBool("noopengl", 'o', foo->noopengl);
-    options.getString( "xdisplay", 'x', foo->xdisplay );
-    std::string shaders = "textured";
-    options.getString( "shader", 'r', shaders );
-    foo->shaders = split( shaders, ',' );
+    if ( options.count( "color" ) > 0 ) {
+        color = parseColor( options["color"].as<std::string>() );
+    }
     foo->r = color.r;
     foo->g = color.g;
     foo->b = color.b;
     foo->a = color.a;
-    options.getBool("highlight", 'l', foo->highlight);
-    try {
-        bool test = false;
-        options.getBool("nodecorations", 'n', test);
-        if ( test ) {
-            foo->nodecorations = 1;
-        }
-    } catch( ... ) {
-        options.getInt("nodecorations", 'n', foo->nodecorations);
+    if ( options.count( "nokeyboard" ) > 0 ) {
+        foo->nokeyboard = options["nokeyboard"].as<bool>();
+    }
+    if ( options.count( "xdisplay" ) > 0 ) {
+        foo->xdisplay = options["xdisplay"].as<std::string>();
     }
-    if ( foo->nodecorations < 0 || foo->nodecorations > 2 ) {
-        throw new std::invalid_argument( "--nodecorations must be between 0 and 2. Or be used as a flag." );
+    std::string shaders = "textured";
+    if ( options.count( "shader" ) > 0 ) {
+        shaders = options["shader"].as<std::string>();
+    }
+    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( "nodecorations" ) > 0 ) {
+        foo->nodecorations = options["nodecorations"].as<int>();
+        if ( foo->nodecorations < 0 || foo->nodecorations > 2 ) {
+            throw new std::invalid_argument( "--nodecorations must be between 0 and 2. Or be used as a flag." );
+        }
     }
     return foo;
 }
@@ -184,16 +226,42 @@ void printHelp() {
 }
 
 int app( int argc, char** argv ) {
+    cxxopts::Options options("maim", "Screenshot application.");
+    options.add_options()
+    ("h,help", "Print help and exit.")
+    ("v,version", "Print version and exit.")
+    ("x,xdisplay", "Sets the xdisplay to use", cxxopts::value<std::string>())
+    ("f,format", "Sets the output format for slop. Format specifiers are  %x, %y, %w, %h, %i, %c, and %g. If actual percentage signs are desired in output, use a double percentage sign like so `%%`.", cxxopts::value<std::string>())
+    ("b,bordersize", "Sets the selection rectangle's thickness.", cxxopts::value<float>())
+    ("p,padding", "Sets the padding size for the selection, this can be negative.", cxxopts::value<float>())
+    ("t,tolerance", "How far in pixels the mouse can move after clicking, and still be detected as a normal click instead of a click-and-drag. Setting this to 0 will disable window selections. Alternatively setting it to 9999999 would force a window selection.", cxxopts::value<float>())
+    ("c,color", "Sets  the  selection  rectangle's  color.  Supports  RGB or RGBA input. Depending on the system's window manager/OpenGL  support, the opacity may be ignored.", cxxopts::value<std::string>())
+    ("r,shader", "This  sets  the  vertex shader, and fragment shader combo to use when drawing the final framebuffer to the screen. This obviously only  works  when OpenGL is enabled. The shaders are loaded from ~/.config/maim. See https://github.com/naelstrof/slop for more information on how to create your own shaders.", cxxopts::value<std::string>())
+    ("n,nodecorations", "Sets the level of aggressiveness when trying to remove window decroations. `0' is off, `1' will try lightly to remove decorations, and `2' will recursively descend into the root tree until it gets the deepest available visible child under the mouse. Defaults to `0'.", cxxopts::value<int>()->implicit_value("1"))
+    ("l,highlight", "Instead of outlining a selection, maim will highlight it instead. This is particularly useful if the color is set to an opacity lower than 1.")
+    ("q,quiet", "Disable any unnecessary cerr output. Any warnings or info simply won't print.")
+    ("k,nokeyboard", "Disables the ability to cancel selections with the keyboard.")
+    ("o,noopengl", "Disables graphics hardware acceleration.")
+    ;
+    options.parse(argc, argv);
     // Options just validates all of our input from argv
-    Options options( argc, argv );
     bool quiet = false;
-    options.getBool( "quiet", 'q', quiet );
+    if ( options.count( "quiet" ) > 0 ) {
+        quiet = options["quiet"].as<bool>();
+    }
     bool help = false;
-    if ( options.getBool( "help", 'h', help ) ) {
+    if ( options.count( "help" ) > 0 ) {
+        help = options["help"].as<bool>();
+    }
+    if ( help ) {
         printHelp();
         return 0;
     }
-    if ( options.getBool( "version", 'v', help ) ) {
+    bool version = false;
+    if ( options.count( "version" ) > 0 ) {
+        version = options["version"].as<bool>();
+    }
+    if ( version ) {
         std::cout << SLOP_VERSION << "\n";
         return 0;
     }
@@ -204,8 +272,9 @@ int app( int argc, char** argv ) {
     // on a fake selection.
     SlopSelection selection(0,0,0,0,0);
     std::string format;
-    bool gotFormat = options.getString("format", 'f', format);
+    bool gotFormat = options.count( "format" ) > 0;
     if ( gotFormat ) {
+        format = options["format"].as<std::string>();
         formatOutput( format, selection, false );
     }
 

src/options.cpp

@@ -1,246 +0,0 @@
-#include "options.hpp"
-
-Options::Options( int argc, char** argv ) {
-    validArguments.push_back( Argument( "nodecorations", 'n', true ) );
-    validArguments.push_back( Argument( "bordersize",   'b', false ) );
-    validArguments.push_back( Argument( "padding",      'p', false ) );
-    validArguments.push_back( Argument( "color",        'c', false ) );
-    validArguments.push_back( Argument( "shader",       'r', false ) );
-    validArguments.push_back( Argument( "highlight",    'l', true ) );
-    validArguments.push_back( Argument( "format",       'f', false ) );
-    validArguments.push_back( Argument( "tolerance",    't', false ) );
-    validArguments.push_back( Argument( "nokeyboard",   'k', true ) );
-    validArguments.push_back( Argument( "noopengl",     'o', true ) );
-    validArguments.push_back( Argument( "help",         'h', true ) );
-    validArguments.push_back( Argument( "xdisplay",     'x', false ) );
-    validArguments.push_back( Argument( "version",      'v', true ) );
-    validArguments.push_back( Argument( "quiet",        'q', true ) );
-    try {
-        validate( argc, argv );
-    } catch( ... ) {
-        arguments.clear();
-        values.clear();
-        floatingValues.clear();
-        validArguments[0].isFlagArgument = false;
-        validate( argc, argv );
-    }
-}
-
-
-int Options::validateStringOption( int argc, char** argv, int argumentIndex ) {
-    std::string argument = argv[argumentIndex];
-    unsigned int index = 0;
-    while( index < validArguments.size() ) {
-        Argument& check = validArguments[index];
-        for( unsigned int i=0;i<check.name.length();i++ ) {
-            if ( check.name[i] != argument[i+2] ) {
-                break;
-            }
-            if ( i == check.name.length()-1 ) {
-                if ( !check.isFlagArgument && argument.find("=") == std::string::npos ) {
-                    throw new std::invalid_argument("Expected `=` after " + argument);
-                }
-                if ( check.isFlagArgument && i+3 != argument.length() ) {
-                    throw new std::invalid_argument("Trailing characters on flag " + argument );
-                }
-                return parseStringOption( argc, argv, argumentIndex, index );
-            }
-        }
-        index++;
-    }
-    throw new std::invalid_argument("Invalid argument " + argument);
-    return 0;
-}
-
-int Options::parseCharOption( int argc, char** argv, int argumentIndex, int validIndex ) {
-    std::string argument = argv[argumentIndex];
-    Argument& check = validArguments[validIndex];
-    // If we're a flag, we take no arguments, nor do we allow = signs or whatever.
-    if ( check.isFlagArgument ) {
-        if ( argument != std::string()+"-"+check.cname ) {
-            for( int o=1;o<argument.length();o++ ) {
-                bool isValid = false;
-                for( int i=0;i<validArguments.size()&&!isValid;i++ ) {
-                    if ( argument[o] == check.cname ) {
-                        if ( check.isFlagArgument ) {
-                            isValid = true;
-                            arguments.push_back( std::string()+check.cname );
-                            values.push_back("");
-                            break;
-                        } else {
-                            throw new std::invalid_argument( std::string()+"Truncating non-flag arguments is not allowed. Split this up: `" + argument + "`." );
-                        }
-                    }
-                }
-                if (!isValid) {
-                    throw new std::invalid_argument( std::string()+"Unexpected characters around flag `" + argument + "`." );
-                }
-            }
-            return 1;
-        } else {
-            arguments.push_back( std::string()+argument[1] );
-            values.push_back("");
-            return 1;
-        }
-    }
-    arguments.push_back( std::string()+argument[1] );
-    // If they supplied the parameters with spaces
-    if ( argument == std::string()+"-"+check.cname ) {
-        if ( argumentIndex+1 < argc ) {
-            values.push_back(argv[argumentIndex+1]);
-        } else {
-            values.push_back("");
-        }
-        return 2;
-    }
-    // If they didn't supply the parameters with spaces
-    if ( argument[2] == '=' ) {
-        values.push_back(argument.substr(3));
-        return 1;
-    }
-    values.push_back(argument.substr(2));
-    return 1;
-}
-
-int Options::parseStringOption( int argc, char** argv, int argumentIndex, int validIndex ) {
-    std::string argument = argv[argumentIndex];
-    if ( validArguments[validIndex].isFlagArgument ) {
-        arguments.push_back( argument.substr(2) );
-        values.push_back("");
-        return 1;
-    }
-    arguments.push_back( argument.substr(2,argument.find_first_of('=')) );
-    values.push_back(argument.substr(argument.find_first_of('=')));
-    return 1;
-}
-
-int Options::validateCharOption( int argc, char** argv, int argumentIndex ) {
-    std::string argument = argv[argumentIndex];
-    unsigned int index = 0;
-    while( index < validArguments.size() ) {
-        char check = validArguments[index].cname;
-        if ( argument.length() < 2 ) {
-            continue;
-        }
-        if ( check == argument[1] && ( argument.find("=") == 2 || argument.find('=') == std::string::npos ) && argument[0] == '-' ) {
-            return parseCharOption( argc, argv, argumentIndex, index );
-        }
-        index++;
-    }
-    throw new std::invalid_argument("Invalid argument `" + argument + "`.");
-    return 0;
-}
-
-void Options::validate( int argc, char** argv ) {
-    for ( int i=1;i<argc;) {
-        std::string argument = argv[i];
-        if ( argument[0] != '-' ) {
-            floatingValues.push_back( argument );
-            if ( floatingValues.size() > maxFloatingValues ) {
-                throw new std::invalid_argument("Unexpected floating value `" + argument + "`. Forget to specify an option?" );
-            }
-            i++;
-            continue;
-        }
-        if ( argument[0] == '-' && argument[1] == '-' ) {
-            i += validateStringOption( argc, argv, i );
-            continue;
-        }
-        i += validateCharOption( argc, argv, i );
-    }
-}
-
-bool Options::getFloat( std::string name, char namec, float& found ) {
-    for( unsigned int i=0;i<arguments.size();i++ ) {
-        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
-            std::string::size_type sz;
-            float retvar;
-            try {
-                retvar = std::stof(values[i],&sz);
-            } catch ( ... ) {
-                throw new std::invalid_argument("Unable to parse `" + arguments[i] + "`'s value `" + values[i] + "` as a float.");
-            }
-            if ( sz != values[i].length() ) {
-                throw new std::invalid_argument("Unable to parse `" + arguments[i] + "`'s value `" + values[i] + "` as a float.");
-            }
-            found = retvar;
-            return true;
-        }
-    }
-    return false;
-}
-
-bool Options::getInt( std::string name, char namec, int& found ) {
-    for( unsigned int i=0;i<arguments.size();i++ ) {
-        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
-            if ( arguments[i].size() > 1 && arguments[i].find("=") == std::string::npos ) {
-                throw new std::invalid_argument("Expected `=` after " + arguments[i]);
-            }
-            std::string::size_type sz;
-            float retvar;
-            try {
-                retvar = std::stoi(values[i],&sz);
-            } catch ( ... ) {
-                throw new std::invalid_argument("Unable to parse " + arguments[i] + "'s value " + values[i] + " as an integer.");
-            }
-            if ( sz != values[i].length() ) {
-                throw new std::invalid_argument("Unable to parse " + arguments[i] + "'s value " + values[i] + " as an integer.");
-            }
-            found = retvar;
-            return true;
-        }
-    }
-    return false;
-}
-
-bool Options::getString( std::string name, char namec, std::string& found ) {
-    for( unsigned int i=0;i<arguments.size();i++ ) {
-        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
-            found = values[i];
-            return true;
-        }
-    }
-    return false;
-}
-
-bool Options::getColor( std::string name, char namec, glm::vec4& found ) {
-    for( unsigned int i=0;i<arguments.size();i++ ) {
-        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
-            std::string::size_type sz;
-            std::string value = values[i];
-            try {
-                found[0] = std::stof(value,&sz);
-                value = value.substr(sz+1);
-                found[1] = std::stof(value,&sz);
-                value = value.substr(sz+1);
-                found[2] = std::stof(value,&sz);
-                if ( value.size() != sz ) {
-                    value = value.substr(sz+1);
-                    found[3] = std::stof(value,&sz);
-                    if ( value.size() != sz ) {
-                        throw "dur";
-                    }
-                } else {
-                    found[3] = 1;
-                }
-            } catch ( ... ) {
-                throw new std::invalid_argument("Unable to parse `" + arguments[i] + "`'s value `" + values[i] + "` as a color. Should be in the format r,g,b or r,g,b,a. Like 1,1,1,1.");
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-bool Options::getBool( std::string name, char namec, bool& found ) {
-    for( unsigned int i=0;i<arguments.size();i++ ) {
-        if ( arguments[i] == name || arguments[i] == std::string("")+namec ) {
-            if ( values[i] != "" ) {
-                throw new std::invalid_argument("Unexpected value `" + values[i] + "` for flag argument `" + arguments[i] + "`.");
-            }
-            found = true;
-            return true;
-        }
-    }
-    return false;
-}

src/options.hpp

@@ -1,61 +0,0 @@
-/* options.hpp: parses arguments from the commandline.
- *
- * 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_OPTIONS_H_
-#define N_OPTIONS_H_
-
-#include <iostream>
-#include <string>
-#include <exception>
-#include <stdexcept>
-#include <vector>
-#include <glm/glm.hpp>
-
-class Argument {
-public:
-    std::string name;
-    char cname;
-    bool isFlagArgument;
-    Argument( std::string name, char cname, bool isFlagArgument ) : name(name), cname(cname), isFlagArgument(isFlagArgument) {}
-};
-
-static std::vector<Argument> validArguments;
-static unsigned int maxFloatingValues = 0;
-
-class Options {
-private:
-    std::vector<std::string> arguments;
-    std::vector<std::string> values;
-    std::vector<std::string> floatingValues;
-    int parseCharOption( int argc, char** argv, int argumentIndex, int validIndex );
-    int parseStringOption( int argc, char** argv, int argumentIndex, int validIndex );
-    int validateStringOption( int argc, char** argv, int argumentIndex );
-    int validateCharOption( int argc, char** argv, int argumentIndex );
-    void validate( int argc, char** argv );
-public:
-    Options( int argc, char** argv );
-    bool getFloat( std::string name, char namec, float& found );
-    bool getInt( std::string name, char namec, int& found );
-    bool getString( std::string name, char namec, std::string& found );
-    bool getColor( std::string name, char namec, glm::vec4& found );
-    bool getBool( std::string name, char namec, bool& found );
-};
-
-#endif // N_OPTIONS_H_