Subversion Repositories tpanel

/*

 * Copyright (C) 2020, 2021 by Andreas Theofilu <andreas@theosys.at>

 *

 * This program 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.

 *

 * This program 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 this program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 */

#include "tamxcommands.h"

#include "terror.h"

#include "tresources.h"

#include "tconfig.h"

using std::string;

using std::vector;

typedef struct CMD_DEFINATIONS

{

    string cmd;

    bool hasChannels{false};

    bool hasPars{false};

    char separator{0};

}CMD_DEFINATIONS;

CMD_DEFINATIONS cmdDefinations[] = {

    { "@WLD", false, true, ',' },

    { "@AFP", false, true, ',' },

    { "@GCE", false, true, ',' },

    { "@APG", false, true, ';' },

    { "@CPG", false, true, ',' },

    { "@DPG", false, true, ';' },

    { "@PDR", false, true, ';' },

    { "@PHE", false, true, ';' },

    { "@PHP", false, true, ';' },

    { "@PHT", false, true, ';' },

    { "@PPA", false, true, ',' },

    { "@PPF", false, true, ';' },

    { "@PPG", false, true, ';' },

    { "@PPK", false, true, ',' },

    { "@PPM", false, true, ';' },

    { "@PPN", false, true, ';' },

    { "@PPT", false, true, ';' },

    { "@PPX", false, false, '\0' },

    { "@PSE", false, true, ';' },

    { "@PSP", false, true, ';' },

    { "@PST", false, true, ';' },

    { "PAGE", false, true, ',' },

    { "PPOF", false, true, ';' },

    { "PPOG", false, true, ';' },

    { "PPON", false, true, ';' },

    { "^ANI", true, true, ',' },

    { "^APF", true, true, ',' },

    { "^BAT", true, true, ',' },

    { "^BAU", true, true, ',' },

    { "^BCB", true, true, ',' },

    { "?BCB", true, true, ',' },

    { "^BCF", true, true, ',' },

    { "?BCF", true, true, ',' },

    { "^BCT", true, true, ',' },

    { "?BCT", true, true, ',' },

    { "^BDO", true, true, ',' },

    { "^BFB", true, true, ',' },

    { "^BIM", true, true, ',' },

    { "^BLN", true, true, ',' },

    { "^BMC", true, true, ',' },

    { "^BMF", true, true, ',' },

    { "^BMI", true, true, ',' },

    { "^BML", true, true, ',' },

    { "^BMP", true, true, ',' },

    { "?BMP", true, true, ',' },

    { "^BNC", true, true, ',' },

    { "^BNN", true, true, ',' },

    { "^BNT", true, true, ',' },

    { "^BOP", true, true, ',' },

    { "?BOP", true, true, ',' },

    { "^BOR", true, true, ',' },

    { "^BOS", true, true, ',' },

    { "^BPP", true, true, ',' },

    { "^BRD", true, true, ',' },

    { "?BRD", true, true, ',' },

    { "^BSF", true, true, ',' },

    { "^BSP", true, true, ',' },

    { "^BSM", true, false, ',' },

    { "^BSO", true, true, ',' },

    { "^BVL", true, true, ',' },

    { "^BVN", false, true, ',' },

    { "^BVP", true, true, ',' },

    { "^BVT", true, true, ',' },

    { "^BWW", true, true, ',' },

    { "?BWW", true, true, ',' },

    { "^CPF", true, false, ',' },

    { "^DLD", false, false, ',' },

    { "^DPF", true, true, ',' },

    { "^ENA", true, true, ',' },

    { "^FON", true, true, ',' },

    { "?FON", true, true, ',' },

    { "^GDI", true, true, ',' },

    { "^GIV", true, true, ',' },

    { "^GLH", true, true, ',' },

    { "^GLL", true, true, ',' },

    { "^GRD", true, true, ',' },

    { "^GRU", true, true, ',' },

    { "^GSC", true, true, ',' },

    { "^GSN", true, true, ',' },

    { "^ICO", true, true, ',' },

    { "?ICO", true, true, ',' },

    { "^IRM", false, true, ',' },

    { "^JSB", true, true, ',' },

    { "?JSB", true, true, ',' },

    { "^JSI", true, true, ',' },

    { "?JSI", true, true, ',' },

    { "^JST", true, true, ',' },

    { "?JST", true, true, ',' },

    { "^MBT", false, false, ',' },

    { "^MDC", false, false, ',' },

    { "^SHO", true, true, ',' },

    { "^TEC", true, true, ',' },

    { "?TEC", true, true, ',' },

    { "^TEF", true, true, ',' },

    { "?TEF", true, true, ',' },

    { "^TOP", false, true, ',' },

    { "^TXT", true, true, ',' },

    { "?TXT", true, true, ',' },

    { "^UNI", true, true, ',' },

    { "^LPC", false, true, ',' },

    { "^LPR", false, true, ',' },

    { "^LPS", false, true, ',' },

    { "ABEEP", false, false, ',' },

    { "ADBEEP", false, false, ',' },

    { "@AKB", false, true, ';' },

    { "AKEYB", false, true, ',' },

    { "AKEYP", false, true, ',' },

    { "AKEYR", false, true, ',' },

    { "@AKP", false, true, ';' },

    { "@AKR", false, false, ',' },

    { "BEEP", false, false, ',' },

    { "BRIT", false, true, ',' },

    { "@BRT", false, true, ',' },

    { "DBEEP", false, false, ',' },

    { "@EKP", false, true, ';' },

    { "PKEYP", false, true, ',' },

    { "@PKP", false, true, ';' },

    { "SETUP", false, false, ',' },

    { "SHUTDOWN", false, false, ',' },

    { "SLEEP", false, false, ',' },

    { "@SOU", false, true, ',' },

    { "@TKP", false, true, ';' },

    { "TPAGEON", false, false, ',' },

    { "TPAGEOFF", false, false, ',' },

    { "@VKB", false, false, ',' },

    { "WAKE", false, false, ',' },

    { "^CAL", false, false, ',' },

    { "^KPS", false, true, ',' },

    { "^VKS", false, true, ',' },

    { "@PWD", false, true, ',' },

    { "^PWD", false, true, ',' },

    { "^BBR", true, true, ',' },

    { "^RAF", false, true, ',' },

    { "^RFR", false, true, ',' },

    { "^RMF", false, true, ',' },

    { "^RSR", false, true, ',' },

    { "^MODEL?", false, false, ',' },

    { "^ICS", false, true, ',' },

    { "^ICE", false, false, ',' },

    { "^ICM", false, true, ',' },

    { "^PHN", false, true, ',' },

    { "?PHN", false, true, ',' },

    { "LEVON", false, false, ',' },

    { "RXON", false, false, ',' },

    { "ON", false, true, ',' },

    { "OFF", false, true, ',' },

    { "LEVEL", false, true, ',' },

    { "BLINK", false, true, ',' },

    { "", false, false, '\0' }

};

CMD_DEFINATIONS& findCmdDefines(const string& cmd)

{

    DECL_TRACER("findCmdDefines(const string& cmd)");

    int i = 0;

    while (cmdDefinations[i].cmd.length() > 0)

    {

        if (cmdDefinations[i].cmd.compare(cmd) == 0)

            return cmdDefinations[i];

        i++;

    }

    return cmdDefinations[i];

}

TAmxCommands::TAmxCommands()

{

    DECL_TRACER("TAmxCommands::TAmxCommands()");

    readMap();

}

TAmxCommands::~TAmxCommands()

{

    DECL_TRACER("TAmxCommands::~TAmxCommands()");

}

bool TAmxCommands::readMap()

{

    DECL_TRACER("TAmxCommands::readMap()");

    makeFileName(TConfig::getProjectPath(), "map.xma");

    string path;

    vector<string> elements = { "cm", "am", "lm", "bm", "sm", "strm", "pm" };

    if (isValidFile())

        path = getFileName();

    TReadXML reader(path);

    if (TError::isError())

        return false;

    vector<string>::iterator mapIter;

    for (mapIter = elements.begin(); mapIter != elements.end(); mapIter++)

    {

        reader.findElement(*mapIter);

        if (!reader.success())

        {

            MSG_ERROR("Element \"" << *mapIter << "\" was not found!");

            TError::setError();

            return false;

        }

        MAP_T map;

        MAP_BM_T mapBm;

        MAP_PM_T mapPm;

        mxml_node_t *node = reader.getFirstChild();

        while (node)

        {

            string el = reader.getElementName(node);

            if (el.compare("me") == 0)

            {

                mxml_node_t *n = reader.getFirstChild(node);

                while (n)

                {

                    string e = reader.getElementName(n);

                    if (mapIter->compare("cm") == 0 || mapIter->compare("am") == 0 ||

                        mapIter->compare("lm") == 0 || mapIter->compare("strm") == 0)

                    {

                        if (e.compare("p") == 0)

                            map.p = reader.getIntFromNode(n);

                        else if (e.compare("c") == 0)

                            map.c = reader.getIntFromNode(n);

                        else if (e.compare("ax") == 0)

                            map.ax = reader.getIntFromNode(n);

                        else if (e.compare("pg") == 0)

                            map.pg = reader.getIntFromNode(n);

                        else if (e.compare("bt") == 0)

                            map.bt = reader.getIntFromNode(n);

                        else if (e.compare("pn") == 0)

                            map.pn = reader.getTextFromNode(n);

                        else if (e.compare("bn") == 0)

                            map.bn = reader.getTextFromNode(n);

                    }

                    else if (mapIter->compare("bm") == 0)

                    {

                        mxml_node_t *no = reader.getFirstChild(n);

                        while (no)

                        {

                            string im = reader.getElementName(no);

                            if (im.compare("i") == 0)

                                mapBm.i = reader.getTextFromNode(no);

                            else if (im.compare("id") == 0)

                                mapBm.id = reader.getIntFromNode(no);

                            else if (im.compare("rt") == 0)

                                mapBm.rt = reader.getIntFromNode(no);

                            else if (im.compare("pg") == 0)

                                mapBm.pg = reader.getIntFromNode(no);

                            else if (im.compare("bt") == 0)

                                mapBm.bt = reader.getIntFromNode(no);

                            else if (im.compare("st") == 0)

                                mapBm.st = reader.getIntFromNode(no);

                            else if (im.compare("sl") == 0)

                                mapBm.sl = reader.getIntFromNode(no);

                            else if (im.compare("pn") == 0)

                                mapBm.pn = reader.getTextFromNode(no);

                            else if (im.compare("bn") == 0)

                                mapBm.bn = reader.getTextFromNode(no);

                            no = reader.getNextChild(no);

                        }

                        mMap.map_bm.push_back(mapBm);

                    }

                    else if (mapIter->compare("sm") == 0)

                    {

                        if (e.compare("i") == 0)

                            mMap.map_sm.push_back(reader.getTextFromNode(n));

                    }

                    else if (mapIter->compare("pm") == 0)

                    {

                        if (e.compare("a") == 0)

                            mapPm.a = reader.getIntFromNode(n);

                        else if (e.compare("t") == 0)

                            mapPm.t = reader.getTextFromNode(n);

                        else if (e.compare("pg") == 0)

                            mapPm.pg = reader.getIntFromNode(n);

                        else if (e.compare("bt") == 0)

                            mapPm.bt = reader.getIntFromNode(n);

                        else if (e.compare("pn") == 0)

                            mapPm.pn = reader.getTextFromNode(n);

                        else if (e.compare("bn") == 0)

                            mapPm.bn = reader.getTextFromNode(n);

                    }

                    n = reader.getNextChild(n);

                }

                if (mapIter->compare("cm") == 0)

                    mMap.map_cm.push_back(map);

                else if (mapIter->compare("am") == 0)

                    mMap.map_am.push_back(map);

                else if (mapIter->compare("lm") == 0)

                    mMap.map_lm.push_back(map);

                else if (mapIter->compare("strm") == 0)

                    mMap.map_strm.push_back(map);

                else if (mapIter->compare("pm") == 0)

                    mMap.map_pm.push_back(mapPm);

            }

            node = reader.getNextChild();

        }

    }

    return true;

}

vector<string> TAmxCommands::getFields(string& msg, char sep)

{

    DECL_TRACER("TAmxCommands::getFields(string& msg, char sep)");

    vector<string> flds;

    bool bStr = false;

    string part;

    for (size_t i = 0; i < msg.length(); i++)

    {

        if (msg.at(i) == sep && !bStr)

        {

            flds.push_back(part);

            part.clear();

            continue;

        }

        else if (msg.at(i) == '\'' && !bStr)

            bStr = true;

        else if (msg.at(i) == '\'' && bStr)

            bStr = false;

        else

            part.append(msg.substr(i, 1));

    }

    if (!part.empty())

        flds.push_back(part);

    if (TStreamError::checkFilter(LOG_DEBUG))

    {

        MSG_DEBUG("Found fields:");

        vector<string>::iterator iter;

        int i = 1;

        for (iter = flds.begin(); iter != flds.end(); iter++)

        {

            MSG_DEBUG("    " << i << ": " << *iter);

            i++;

        }

    }

    return flds;

}

vector<MAP_T> TAmxCommands::findButtons(int port, vector<int>& channels, MAP_TYPE mt)

{

    DECL_TRACER("TAmxCommands::findButtons(int port, vector<int>& channels, MAP_TYPE mt)");

    vector<MAP_T> map;

    vector<int>::iterator iter;

    if (channels.empty())

    {

        MSG_WARNING("Got empty channel list!");

        return map;

    }

    vector<MAP_T> localMap;

    switch (mt)

    {

        case TYPE_AM:   localMap = mMap.map_am; break;

        case TYPE_CM:   localMap = mMap.map_cm; break;

        case TYPE_LM:   localMap = mMap.map_lm; break;

    }

    if (localMap.empty())

    {

        MSG_WARNING("The internal list of elements is empty!")

        return map;

    }

    for (iter = channels.begin(); iter != channels.end(); iter++)

    {

        vector<MAP_T>::iterator mapIter;

        for (mapIter = localMap.begin(); mapIter != localMap.end(); mapIter++)

        {

            if (mapIter->p == port && mapIter->c == *iter)

                map.push_back(*mapIter);

        }

    }

    MSG_DEBUG("Found " << map.size() << " buttons.");

    return map;

}

vector<MAP_T> TAmxCommands::findBargraphs(int port, vector<int>& channels)

{

    DECL_TRACER("TAmxCommands::findBargraphs(int port, vector<int>& channels)");

    vector<MAP_T> map;

    vector<int>::iterator iter;

    for (iter = channels.begin(); iter != channels.end(); iter++)

    {

        vector<MAP_T>::iterator mapIter;

        for (mapIter = mMap.map_lm.begin(); mapIter != mMap.map_lm.end(); mapIter++)

        {

            if (mapIter->p == port && mapIter->c == *iter)

                map.push_back(*mapIter);

        }

    }

    MSG_DEBUG("Found " << map.size() << " buttons.");

    return map;

}

bool TAmxCommands::parseCommand(int device, int port, const string& cmd)

{

    DECL_TRACER("TAmxCommands::parseCommand(int device, int port, const string& cmd)");

    if (device != TConfig::getChannel())    // This should never happens!

    {

        MSG_WARNING("Command is for device " << device << ", but this device is " << TConfig::getChannel());

    }

    vector<CMD_TABLE>::iterator iter;

    size_t pos = cmd.find_first_of("-");

    if (pos != string::npos)

    {

        MSG_TRACE("Parsing for device <" << device << ":" << port << ":" << TConfig::getSystem() << "> the command: " << cmd.substr(0, pos));

    }

    else

    {

        MSG_TRACE("Parsing for device <" << device << ":" << port << ":" << TConfig::getSystem() << "> the command: " << cmd);

    }

    if (pos != string::npos)    // Command with parameters

    {

        string bef = cmd.substr(0, pos);

        string rest = cmd.substr(pos + 1);

        for (iter = mCmdTable.begin(); iter != mCmdTable.end(); iter++)

        {

            iter->channels.clear();

            iter->pars.clear();

            if (iter->cmd.compare(bef) == 0 && iter->command)

            {

                CMD_DEFINATIONS cdef = findCmdDefines(bef);

                if (cdef.cmd.empty())

                {

                    MSG_WARNING("Command \"" << bef << "\" not found in command table! Ignoring it.");

                    continue;

                }

                if (cdef.hasChannels || cdef.hasPars)

                {

                    vector<string> parts = getFields(rest, cdef.separator);

                    if (cdef.hasChannels)

                        extractChannels(parts[0], &iter->channels);

                    if (cdef.hasPars)

                    {

                        MSG_DEBUG("Command may have parameters. Found " << parts.size() << " parameters.");

                        if (parts.size() > 0)

                        {

                            vector<string>::iterator piter;

                            int cnt = 0;

                            for (piter = parts.begin(); piter != parts.end(); piter++)

                            {

                                if (cdef.hasChannels && !cnt)

                                {

                                    cnt++;

                                    continue;

                                }

                                iter->pars.push_back(*piter);

                                cnt++;

                            }

                        }

                        else

                            iter->pars.push_back(rest);

                    }

                }

                iter->command(port, iter->channels, iter->pars);

                return true;

            }

        }

    }

    else        // Command without parameter

    {

        for (iter = mCmdTable.begin(); iter != mCmdTable.end(); iter++)

        {

            if (iter->cmd.compare(cmd) == 0 && iter->command)

            {

                iter->command(port, iter->channels, iter->pars);

                return true;

            }

        }

    }

    MSG_WARNING("Command \"" << cmd << "\" currently not supported!");

    return false;

}

bool TAmxCommands::extractChannels(const string& schan, vector<int>* ch)

{

    DECL_TRACER("TAmxCommands::extractChannels(const string& schan, vector<int>* ch)");

    if (!ch || schan.empty())

        return false;

    if (schan.find("&") == string::npos && schan.find(".") == string::npos)

    {

        int c = atoi(schan.c_str());

        ch->push_back(c);

        return true;

    }

    if (schan.find("&") != string::npos)

    {

        vector<string> parts = StrSplit(schan, "&");

        vector<string>::iterator iter;

        for (iter = parts.begin(); iter != parts.end(); iter++)

        {

            if (iter->find(".") != string::npos)

            {

                vector<string> p2 = StrSplit(*iter, ".");

                vector<string>::iterator piter;

                for (piter = p2.begin(); piter != p2.end(); piter++)

                    ch->push_back(atoi(piter->c_str()));

            }

            else

                ch->push_back(atoi(iter->c_str()));

        }

    }

    else

    {

        vector<string> parts = StrSplit(schan, ".");

        vector<string>::iterator iter;

        for (iter = parts.begin(); iter != parts.end(); iter++)

            ch->push_back(atoi(iter->c_str()));

    }

    return true;

}

void TAmxCommands::registerCommand(std::function<void (int port, vector<int>& channels, vector<string>& pars)> command, const string& name)

{

    DECL_TRACER("TAmxCommands::registerCommand(std::function<void (vector<int>& channels, vector<string>& pars)> command, const string& name)");

    vector<CMD_TABLE>::iterator iter;

    for (iter = mCmdTable.begin(); iter != mCmdTable.end(); iter++)

    {

        if (iter->cmd.compare(name) == 0)

        {

            iter->command = command;

            iter->channels.clear();

            iter->pars.clear();

            return;

        }

    }

    CMD_TABLE ctbl;

    ctbl.cmd = name;

    ctbl.command = command;

    mCmdTable.push_back(ctbl);

}