1 files changed, 573 insertions, 0 deletions

diff --git a/noncore/applets/zkbapplet/keyzcfg/zkbxml.cpp b/noncore/applets/zkbapplet/keyzcfg/zkbxml.cpp
new file mode 100644
index 0000000..5b0084c
--- a/dev/null
+++ b/noncore/applets/zkbapplet/keyzcfg/zkbxml.cpp
@@ -0,0 +1,573 @@
+#include "zkbxml.h"
+#include "zkbnames.h"
+
+static QString Keymap_Tag("keymap");
+static QString Include_Tag("include");
+static QString Label_Tag("label");
+static QString State_Tag("state");
+static QString Map_Tag("map");
+static QString Event_Tag("event");
+static QString NextState_Tag("next-state");
+
+ZkbXmlHandler::ZkbXmlHandler() {
+}
+
+ZkbXmlHandler::~ZkbXmlHandler() {
+}
+
+bool ZkbXmlHandler::startElement(const QString&, const QString&, 
+        const QString& name, const QXmlAttributes& attr) {
+
+        bool ret = false;
+
+        if (name == Keymap_Tag) {
+                ret = start_keymap(attr);
+        } else if (name == Include_Tag) {
+                ret = start_include(attr);
+        } else if (name == Label_Tag) {
+                ret = start_label(attr);
+        } else if (name == State_Tag) {
+                ret = start_state(attr);
+        } else if (name == Map_Tag) {
+                ret = start_map(attr);
+        } else if (name == Event_Tag) {
+                ret = start_event(attr);
+        } else if (name == NextState_Tag) {
+                ret = start_next_state(attr);
+        }
+
+        elements.prepend(name);
+
+        return ret;
+}
+
+bool ZkbXmlHandler::endElement(const QString&, const QString&, 
+        const QString& name) {
+
+        bool ret = false;
+
+        elements.remove(elements.begin());
+
+        if (name == Keymap_Tag) {
+                ret = end_keymap();
+        } else if (name == Include_Tag) {
+                ret = end_include();
+        } else if (name == Label_Tag) {
+                ret = end_label();
+        } else if (name == State_Tag) {
+                ret = end_state();
+        } else if (name == Map_Tag) {
+                ret = end_map();
+        } else if (name == Event_Tag) {
+                ret = end_event();
+        } else if (name == NextState_Tag) {
+                ret = end_next_state();
+        }
+
+        return ret;
+}
+
+QString ZkbXmlHandler::errorString() {
+        return err;
+}
+
+bool ZkbXmlHandler::startKeymapElement(int ardelay, int arperiod, const QString& author) {
+        return false;
+}
+
+bool ZkbXmlHandler::startIncludeElement(const QString& file, 
+        const QString& prefix) {
+
+        return false;
+}
+
+bool ZkbXmlHandler::startLabelElement(const QString& label, 
+        const QString& state) {
+
+        return false;
+}
+
+bool ZkbXmlHandler::startStateElement(const QString& name, 
+        const QString& parent, bool dflt) {
+
+        return false;
+}
+
+bool ZkbXmlHandler::startMapElement(int keycode, bool pressed) {
+        return false;
+}
+
+bool ZkbXmlHandler::startEventElement(int keycode, int unicode, int modifiers, 
+        bool pressed, bool autorepeat) {
+
+        return false;
+}
+
+bool ZkbXmlHandler::startNextStateElement(const QString& state) {
+        return false;
+}
+
+
+bool ZkbXmlHandler::endKeymapElement() {
+        return false;
+}
+
+bool ZkbXmlHandler::endIncludeElement() {
+        return false;
+}
+
+bool ZkbXmlHandler::endLabelElement() {
+        return false;
+}
+
+bool ZkbXmlHandler::endStateElement() {
+        return false;
+}
+
+bool ZkbXmlHandler::endMapElement() {
+        return false;
+}
+
+bool ZkbXmlHandler::endEventElement() {
+        return false;
+}
+
+bool ZkbXmlHandler::endNextStateElement() {
+        return false;
+}
+
+
+bool ZkbXmlHandler::start_keymap(const QXmlAttributes& attr) {
+        int nattr = 0;
+        int didx = attr.index("autorepeat-delay");
+        int pidx = attr.index("autorepeat-period");
+        int aidx = attr.index("author");
+        int ard = -1;
+        int arp = -1;
+        QString author;
+
+        if (!elements.isEmpty()) {
+                setError("keymap element should be top-level element");
+                return false;
+        }
+
+        if (didx >= 0) {
+                QString s = attr.value(didx);
+                bool ok;
+
+                ard = s.toInt(&ok);
+                if (!ok) {
+                        setError("Invalid autorepeat-delay value: " + s);
+                        return false;
+                }
+
+                nattr++;
+        }
+
+        if (pidx >= 0) {
+                QString s = attr.value(pidx);
+                bool ok;
+
+                arp = s.toInt(&ok);
+                if (!ok) {
+                        setError("Invalid autorepeat-period value: " + s);
+                        return false;
+                }
+
+                nattr++;
+        }
+
+        if (aidx >= 0) {
+                author = attr.value(aidx);
+                nattr++;
+        }
+
+        if (attr.length() > nattr) {
+                setError("Unsupported attributes");
+                return false;
+        }
+
+        return startKeymapElement(ard, arp, author);
+}
+
+bool ZkbXmlHandler::start_include(const QXmlAttributes& attr) {
+        int nattr = 0;
+        int fidx = attr.index("file");
+        int pidx = attr.index("prefix");
+        QString file;
+        QString prefix((const char*) 0);
+
+        if (elements.first() != Keymap_Tag) {
+                setError("include element should be used only "
+                        "within keymap element");
+                return false;
+        }
+
+        if (fidx >= 0) {
+                file = attr.value(fidx);
+                nattr++;
+        } else {
+                setError("Missing file attribute");
+                return false;
+        }
+
+        if (pidx >= 0) {
+                prefix = attr.value(pidx);
+                nattr++;
+        }
+
+        if (attr.length() > nattr) {
+                setError("Unsupported attributes");
+                return false;
+        }
+
+        return startIncludeElement(file, prefix);
+}
+
+bool ZkbXmlHandler::start_label(const QXmlAttributes& attr) {
+        int nattr = 0;
+        int nidx = attr.index("name");
+        int sidx = attr.index("state");
+        QString name;
+        QString state;
+
+        if (elements.first() != Keymap_Tag) {
+                setError("label element should be used only "
+                        "within keymap element");
+                return false;
+        }
+
+        if (nidx >= 0) {
+                name = attr.value(nidx);
+                nattr++;
+        } else {
+                setError("Missing name attribute");
+                return false;
+        }
+
+        if (sidx >= 0) {
+                state = attr.value(sidx);
+                nattr++;
+        } else {
+                setError("Missing name attribute");
+                return false;
+        }
+
+        if (attr.length() > nattr) {
+                setError("Unsupported attributes");
+                return false;
+        }
+
+        return startLabelElement(name, state);
+}
+
+bool ZkbXmlHandler::start_state(const QXmlAttributes& attr) {
+        int nattr = 0;
+        int nidx = attr.index("name");
+        int pidx = attr.index("parent");
+        int didx = attr.index("default");
+        QString name;
+        QString parent((const char*) 0);
+        bool dflt = false;
+
+        if (elements.first() != Keymap_Tag) {
+                setError("state element should be used only "
+                        "within keymap element");
+                return false;
+        }
+
+        if (nidx >= 0) {
+                name = attr.value(nidx);
+                nattr++;
+        } else {
+                setError("Missing name attribute");
+                return false;
+        }
+
+        if (pidx >= 0) {
+                parent = attr.value(pidx);
+                nattr++;
+        }
+
+        if (didx >= 0) {
+                dflt = str2bool(attr.value(didx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+
+                nattr++;
+        }
+
+        if (attr.length() > nattr) {
+                setError("Unsupported attributes");
+                return false;
+        }
+
+        return startStateElement(name, parent, dflt);
+}
+
+bool ZkbXmlHandler::start_map(const QXmlAttributes& attr) {
+        int nattr = 0;
+        int kidx = attr.index("keycode");
+        int pidx = attr.index("pressed");
+        int key;
+        bool pressed;
+
+        if (elements.first() != State_Tag) {
+                setError("map element should be used only "
+                        "within state element");
+                return false;
+        }
+
+        if (kidx >= 0) {
+                key = str2key(attr.value(kidx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+                nattr++;
+        } else {
+                setError("Missing keycode attribute");
+                return false;
+        }
+
+        if (pidx >= 0) {
+                pressed = str2bool(attr.value(pidx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+                nattr++;
+        } else {
+                setError("Missing pressed attribute");
+                return false;
+        }
+
+        if (attr.length() > nattr) {
+                setError("Unsupported attributes");
+                return false;
+        }
+
+        return startMapElement(key, pressed);
+}
+
+bool ZkbXmlHandler::start_event(const QXmlAttributes& attr) {
+        int nattr = 0;
+        int kidx = attr.index("keycode");
+        int pidx = attr.index("pressed");
+        int uidx = attr.index("unicode");
+        int midx = attr.index("modifiers");
+        int aidx = attr.index("autorepeat");
+
+        int keycode;
+        int unicode;
+        int modifiers = 0;
+        bool pressed;
+        bool autorepeat = false;
+
+        if (elements.first() != Map_Tag) {
+                setError("event element should be used only "
+                        "within map element");
+                return false;
+        }
+
+        if (kidx >= 0) {
+                keycode = str2keycode(attr.value(kidx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+                nattr++;
+        } else {
+                setError("Missing keycode attribute");
+                return false;
+        }
+
+        if (uidx >= 0) {
+                unicode = str2unicode(attr.value(uidx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+                nattr++;
+        } else {
+                setError("Missing unicode attribute");
+                return false;
+        }
+
+        if (midx >= 0) {
+                modifiers = str2modifier(attr.value(midx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+                nattr++;
+        }
+
+        if (pidx >= 0) {
+                pressed = str2bool(attr.value(pidx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+                nattr++;
+        } else {
+                setError("Missing pressed attribute");
+                return false;
+        }
+
+        if (aidx >= 0) {
+                autorepeat = str2bool(attr.value(aidx));
+                if (!err.isEmpty()) {
+                        return false;
+                }
+                nattr++;
+        }
+
+        if (attr.length() > nattr) {
+                setError("Unsupported attributes");
+                return false;
+        }
+
+        return startEventElement(keycode, unicode, modifiers, pressed, 
+                autorepeat);
+}
+
+bool ZkbXmlHandler::start_next_state(const QXmlAttributes& attr) {
+        int nattr = 0;
+        int nidx = attr.index("name");
+        QString name;
+
+        if (elements.first() != Map_Tag) {
+                setError("next-state element should be used only "
+                        "within map element");
+                return false;
+        }
+
+        if (nidx >= 0) {
+                name = attr.value(nidx);
+                nattr++;
+        } else {
+                setError("Missing name attribute");
+                return false;
+        }
+
+        if (attr.length() > nattr) {
+                setError("Unsupported attributes");
+                return false;
+        }
+
+        return startNextStateElement(name);
+}
+
+bool ZkbXmlHandler::end_keymap() {
+        return endKeymapElement();
+}
+
+bool ZkbXmlHandler::end_include() {
+        return endIncludeElement();
+}
+
+bool ZkbXmlHandler::end_label() {
+        return endLabelElement();
+}
+
+bool ZkbXmlHandler::end_state() {
+        return endStateElement();
+}
+
+bool ZkbXmlHandler::end_map() {
+        return endMapElement();
+}
+
+bool ZkbXmlHandler::end_event() {
+        return endEventElement();
+}
+
+bool ZkbXmlHandler::end_next_state() {
+        return endNextStateElement();
+}
+
+void ZkbXmlHandler::setError(const QString& e) {
+        err = e;
+}
+
+int ZkbXmlHandler::str2key(const QString& s) {
+        int ret;
+
+        ret = KeyNames::find(s);
+        if (ret == -1) {
+                setError("Invalid value: " + s);
+        }
+
+        return ret;
+}
+
+int ZkbXmlHandler::str2modifier(const QString& val) {
+        int ret;
+
+        int n, i;
+        ret = 0;
+        n = 0;
+        do {
+                i = val.find('|', n);
+                if (i < 0) {
+                        i = val.length();
+                }
+
+                QString s = val.mid(n, i - n);
+                int v = ModifierNames::find(s.stripWhiteSpace());
+
+                if (v == -1) {
+                        setError("Invalid value: " + val);
+                        return -1;
+                }
+
+                ret |= v;
+                n = i + 1;
+        } while (n < val.length());
+
+        return ret;
+}
+
+bool ZkbXmlHandler::str2bool(const QString& s) {
+        if (s == "true") {
+                return true;
+        } else {
+                return false;
+        }
+}
+
+int ZkbXmlHandler::str2unicode(const QString& s) {
+        return str2uint(s);
+}
+
+int ZkbXmlHandler::str2keycode(const QString& s) {
+        int ret;
+
+        ret = KeycodeNames::find(s);
+        if (ret == -1) {
+                setError("Invalid value: " + s);
+        }
+
+        return ret;
+}
+
+int ZkbXmlHandler::str2uint(const QString& s) {
+        int ret;
+        bool ok;
+        QString val = s;
+        int r;
+
+        if (val.left(2) == "0x") {
+                val = s.mid(2);
+                r = 16;
+        } else if (val.left(1) == "0") {
+                val = s.mid(1);
+                r = 8;
+        } else {
+                r = 10;
+        }
+
+        ret = val.toInt(&ok, r);
+        if (!ok) {
+                setError("Invalid value: " + s);
+                ret = -1;
+        }
+
+        return ret;
+}