Special command line option classes added

src/hyperion-remote/CMakeLists.txt

@@ -1,19 +1,22 @@
 cmake_minimum_required(VERSION 2.8)
 project(hyperion-remote)
 
-find_package(Qt4 REQUIRED QtCore QtNetwork)
+find_package(Qt4 REQUIRED QtCore QtGui QtNetwork)
 
 # The following I do not undrstand completely...
 # libQtCore.so uses some hardcoded library path inside which are incorrect after copying the file RPi file system
 # Therefor, an extra path is needed on which to find the required libraries
 LINK_DIRECTORIES(${LINK_DIRECTORIES} ${CMAKE_FIND_ROOT_PATH}/lib/arm-linux-gnueabihf)
 
-include_directories(${QT_INCLUDE_DIR})
+include_directories(${QT_INCLUDES})
 
-set(hyperion-remote_HEADERS)
+set(hyperion-remote_HEADERS
+    specialoptions.h
+    connection.h)
 
 set(hyperion-remote_SOURCES
-    hyperion-remote.cpp)
+    hyperion-remote.cpp
+    connection.cpp)
 
 qt4_wrap_cpp(HYPERION_REMOTE_MOC_SOURCES
     ${hyperion-remote_HEADERS})
@@ -25,6 +28,7 @@ add_executable(hyperion-remote
 
 qt4_use_modules(hyperion-remote
     Core
+    Gui
     Network)
 
 target_link_libraries(hyperion-remote

src/hyperion-remote/connection.cpp

@@ -0,0 +1,71 @@
+#include "connection.h"
+
+Connection::Connection(const std::string &address, bool printJson)
+{
+}
+
+Connection::~Connection()
+{
+}
+
+bool Connection::setColor(QColor color, int priority, int duration)
+{
+    std::cout << "Set color to " << color.red() << " " << color.green() << " " << color.blue() << std::endl;
+    return false;
+}
+
+bool Connection::setImage(QImage image, int priority, int duration)
+{
+    std::cout << "Set image has size: " << image.width() << "x" << image.height() << std::endl;
+    return false;
+}
+
+bool Connection::listPriorities()
+{
+    std::cout << "List priority channels" << std::endl;
+    return false;
+}
+
+bool Connection::clear(int priority)
+{
+    std::cout << "Clear priority channel " << priority << std::endl;
+    return false;
+}
+
+bool Connection::clearAll()
+{
+    std::cout << "Clear all priority channels" << std::endl;
+    return false;
+}
+
+bool Connection::setThreshold(double red, double green, double blue)
+{
+    return false;
+}
+
+bool Connection::setGamma(double red, double green, double blue)
+{
+    return false;
+}
+
+bool Connection::setBlacklevel(double red, double green, double blue)
+{
+    return false;
+}
+
+bool Connection::setWhitelevel(double red, double green, double blue)
+{
+    return false;
+}
+
+bool Connection::sendMessage(const Json::Value &message)
+{
+    if (_printJson)
+    {
+        std::cout << "Command:" << std::endl;
+        std::cout << message << std::endl;
+    }
+
+    return true;
+}
+

src/hyperion-remote/connection.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+#include <QColor>
+#include <QImage>
+
+#include <json/json.h>
+
+class Connection
+{
+public:
+    Connection(const std::string & address, bool printJson);
+    ~Connection();
+
+    bool setColor(QColor color, int priority, int duration);
+    bool setImage(QImage image, int priority, int duration);
+    bool listPriorities();
+    bool clear(int priority);
+    bool clearAll();
+    bool setThreshold(double red, double green, double blue);
+    bool setGamma(double red, double green, double blue);
+    bool setBlacklevel(double red, double green, double blue);
+    bool setWhitelevel(double red, double green, double blue);
+
+private:
+    bool sendMessage(const Json::Value & message);
+
+private:
+    bool _printJson;
+};

src/hyperion-remote/hyperion-remote.cpp

@@ -1,10 +1,25 @@
-#include <QDebug>
+#include <initializer_list>
+
 #include <QCoreApplication>
 
 #include <getoptPlusPlus/getoptpp.h>
 
+#include "specialoptions.h"
+#include "connection.h"
+
+
 using namespace vlofgren;
 
+int count(std::initializer_list<bool> values)
+{
+    int count = 0;
+    for (auto& value : values) {
+        if (value)
+            count++;
+    }
+    return count;
+}
+
 int main(int argc, const char * argv[])
 {
     // some settings
@@ -13,37 +28,96 @@ int main(int argc, const char * argv[])
 
     OptionsParser optionParser("Simple application to send a command to hyperion using the Json interface");
     ParameterSet & parameters = optionParser.getParameters();
-    StringParameter & argAddress    = parameters.add<StringParameter>('a', "address"   , QString("Set the address of the hyperion server [default: %1]").arg(defaultServerAddress).toAscii().constData());
-    IntParameter    & argPriority   = parameters.add<IntParameter>   ('p', "priority"  , QString("Use to the provided priority channel (the lower the number, the higher the priority) [default: %1]").arg(defaultPriority).toAscii().constData());
-    IntParameter    & argDuration   = parameters.add<IntParameter>   ('d', "duration"  , "Specify how long the leds should be switched on in millseconds. Without this parameter, the leds will be switched on without end time.");
-    StringParameter & argColor      = parameters.add<StringParameter>('c', "color"     , "Set all leds to a constant color (either RRGGBB hex value or a color name)");
-    StringParameter & argImage      = parameters.add<StringParameter>('i', "image"     , "Set the leds to the colors according to the given image file");
-    SwitchParameter & argList       = parameters.add<SwitchParameter>('l', "list"      , "List all priority channels which are in use");
-    SwitchParameter & argClear      = parameters.add<SwitchParameter>('x', "clear"     , "Clear data for the priority channel provided by the -p option");
-    SwitchParameter & argClearAll   = parameters.add<SwitchParameter>(0x0, "clear-all" , "Clear data for all priority channels");
-    DoubleParameter & argGamma      = parameters.add<DoubleParameter>('g', "gamma"     , "Set the gamma of the leds (requires 3 values)");
-    DoubleParameter & argThreshold  = parameters.add<DoubleParameter>('t', "threshold" , "Set the threshold of the leds (requires 3 values between 0.0 and 1.0)");
-    DoubleParameter & argBlacklevel = parameters.add<DoubleParameter>('b', "blacklevel", "Set the blacklevel of the leds (requires 3 values which are normally between 0.0 and 1.0)");
-    DoubleParameter & argWhitelevel = parameters.add<DoubleParameter>('w', "whitelevel", "Set the whitelevel of the leds (requires 3 values which are normally between 0.0 and 1.0)");
-    SwitchParameter & argPrint      = parameters.add<SwitchParameter>(0x0, "print"     , "Print the json input and output messages on stdout");
-    SwitchParameter & argHelp       = parameters.add<SwitchParameter>('h', "help"      , "Show this help message and exit");
+    StringParameter    & argAddress    = parameters.add<StringParameter>   ('a', "address"   , QString("Set the address of the hyperion server [default: %1]").arg(defaultServerAddress).toAscii().constData());
+    IntParameter       & argPriority   = parameters.add<IntParameter>      ('p', "priority"  , QString("Use to the provided priority channel (the lower the number, the higher the priority) [default: %1]").arg(defaultPriority).toAscii().constData());
+    IntParameter       & argDuration   = parameters.add<IntParameter>      ('d', "duration"  , "Specify how long the leds should be switched on in millseconds [default: infinity]");
+    ColorParameter     & argColor      = parameters.add<ColorParameter>    ('c', "color"     , "Set all leds to a constant color (either RRGGBB hex value or a color name)");
+    ImageParameter     & argImage      = parameters.add<ImageParameter>    ('i', "image"     , "Set the leds to the colors according to the given image file");
+    SwitchParameter<>  & argList       = parameters.add<SwitchParameter<> >('l', "list"      , "List all priority channels which are in use");
+    SwitchParameter<>  & argClear      = parameters.add<SwitchParameter<> >('x', "clear"     , "Clear data for the priority channel provided by the -p option");
+    SwitchParameter<>  & argClearAll   = parameters.add<SwitchParameter<> >(0x0, "clear-all" , "Clear data for all priority channels");
+    TransformParameter & argGamma      = parameters.add<TransformParameter>('g', "gamma"     , "Set the gamma of the leds (requires 3 values)");
+    TransformParameter & argThreshold  = parameters.add<TransformParameter>('t', "threshold" , "Set the threshold of the leds (requires 3 space seperated values between 0.0 and 1.0)");
+    TransformParameter & argBlacklevel = parameters.add<TransformParameter>('b', "blacklevel", "Set the blacklevel of the leds (requires 3 space seperated values which are normally between 0.0 and 1.0)");
+    TransformParameter & argWhitelevel = parameters.add<TransformParameter>('w', "whitelevel", "Set the whitelevel of the leds (requires 3 space seperated values which are normally between 0.0 and 1.0)");
+    SwitchParameter<>  & argPrint      = parameters.add<SwitchParameter<> >(0x0, "print"     , "Print the json input and output messages on stdout");
+    SwitchParameter<>  & argHelp       = parameters.add<SwitchParameter<> >('h', "help"      , "Show this help message and exit");
+
+    argAddress.setDefault(defaultServerAddress.toStdString());
+    argPriority.setDefault(defaultPriority);
+    argDuration.setDefault(-1);
+
     try
     {
         optionParser.parse(argc, argv);
     }
     catch (const std::runtime_error & e)
     {
-        qWarning() << e.what();
-        optionParser.usage();
+        std::cerr << e.what() << std::endl;
         return 1;
     }
 
+    // check if we need to display the usage
     if (argHelp.isSet())
     {
         optionParser.usage();
         return 0;
     }
 
+    // check if a color transform is set
+    bool colorTransform = argThreshold.isSet() || argGamma.isSet() || argBlacklevel.isSet() || argWhitelevel.isSet();
+
+    // check if exactly one command was given
+    int commandCount = count({argColor.isSet(), argImage.isSet(), argList.isSet(), argClear.isSet(), argClearAll.isSet(), colorTransform});
+    if (commandCount != 1)
+    {
+        if (commandCount == 0)
+        {
+            std::cerr << "No command found. Provide one of the following options:" << std::endl;
+        }
+        else
+        {
+            std::cerr << "Multiple commands found. Provide one of the following options:" << std::endl;
+        }
+        std::cerr << "  " << argColor.usageLine() << std::endl;
+        std::cerr << "  " << argImage.usageLine() << std::endl;
+        std::cerr << "  " << argList.usageLine() << std::endl;
+        std::cerr << "  " << argClear.usageLine() << std::endl;
+        std::cerr << "  " << argClearAll.usageLine() << std::endl;
+        std::cerr << "or one or more of the color transformations:" << std::endl;
+        std::cerr << "  " << argThreshold.usageLine() << std::endl;
+        std::cerr << "  " << argGamma.usageLine() << std::endl;
+        std::cerr << "  " << argBlacklevel.usageLine() << std::endl;
+        std::cerr << "  " << argWhitelevel.usageLine() << std::endl;
+        return 1;
+    }
+
+    Connection connection(argAddress.getValue(), argPrint.isSet());
+
+    // now execute the given command
+    if (argColor.isSet())
+    {
+        connection.setColor(argColor.getValue(), argPriority.getValue(), argDuration.getValue());
+    }
+    else if (argImage.isSet())
+    {
+        connection.setImage(argImage.getValue(), argPriority.getValue(), argDuration.getValue());
+    }
+    else if (argList.isSet())
+    {
+        connection.listPriorities();
+    }
+    else if (argClear.isSet())
+    {
+        connection.clear(argPriority.getValue());
+    }
+    else if (argClearAll.isSet())
+    {
+        connection.clearAll();
+    }
+    else if (colorTransform)
+    {
+    }
 
     return 0;
 }

src/hyperion-remote/specialoptions.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <QColor>
+#include <QImage>
+
+#include <getoptPlusPlus/getoptpp.h>
+
+struct ColorTransform
+{
+    double valueRed;
+    double valueGreen;
+    double valueBlue;
+};
+
+typedef vlofgren::PODParameter<QColor> ColorParameter;
+typedef vlofgren::PODParameter<QImage> ImageParameter;
+typedef vlofgren::PODParameter<ColorTransform> TransformParameter;
+
+namespace vlofgren {
+    template<>
+    QColor ColorParameter::validate(const std::string& s) throw (Parameter::ParameterRejected)
+    {
+        // Check if we can create the color by name
+        QColor color(s.c_str());
+        if (color.isValid())
+        {
+            return color;
+        }
+
+        // check if we can create the color by hex RRGGBB value
+        if (s.length() == 6 && isxdigit(s[0]) && isxdigit(s[1]) && isxdigit(s[2]) && isxdigit(s[3]) && isxdigit(s[4]) && isxdigit(s[5]))
+        {
+            bool ok = true;
+            int rgb[3];
+            for (int i = 0; i < 3 && ok; ++i)
+            {
+                QString colorComponent(s.substr(2*i, 2).c_str());
+                rgb[i] = colorComponent.toInt(&ok, 16);
+            }
+
+            // check if all components parsed succesfully
+            if (ok)
+            {
+                color.setRgb(rgb[0], rgb[1], rgb[2]);
+                return color;
+            }
+        }
+
+        std::stringstream errorMessage;
+        errorMessage << "Invalid color. A color is specified by a six lettered RRGGBB hex value or one of the following names:";
+        foreach (const QString & colorname, QColor::colorNames()) {
+            errorMessage << "\n  " << colorname.toStdString();
+        }
+        throw Parameter::ParameterRejected(errorMessage.str());
+
+        return color;
+    }
+
+    template<>
+    QImage ImageParameter::validate(const std::string& s) throw (Parameter::ParameterRejected)
+    {
+        QImage image(s.c_str());
+
+        if (image.isNull())
+        {
+            std::stringstream errorMessage;
+            errorMessage << "File " << s << " could not be opened as an image";
+            throw Parameter::ParameterRejected(errorMessage.str());
+        }
+
+        return image;
+    }
+
+    template<>
+    ColorTransform TransformParameter::validate(const std::string& s) throw (Parameter::ParameterRejected)
+    {
+        ColorTransform transform;
+
+        // s should be split in 3 parts
+        // seperators are either a ',' or a space
+        QStringList components = QString(s.c_str()).split(" ", QString::SkipEmptyParts);
+
+        if (components.size() == 3)
+        {
+            bool ok1, ok2, ok3;
+            transform.valueRed   = components[0].toDouble(&ok1);
+            transform.valueGreen = components[1].toDouble(&ok2);
+            transform.valueBlue  = components[2].toDouble(&ok3);
+
+            if (ok1 && ok2 && ok3)
+            {
+                return transform;
+            }
+        }
+
+        std::stringstream errorMessage;
+        errorMessage << "Argument " << s << " can not be parsed to 3 double values";
+        throw Parameter::ParameterRejected(errorMessage.str());
+
+        return transform;
+    }
+}