1 files changed, 228 insertions, 0 deletions

diff --git a/noncore/apps/keyz-cfg/zkbcfg.cpp b/noncore/apps/keyz-cfg/zkbcfg.cpp
new file mode 100644
index 0000000..0992b9a
--- a/dev/null
+++ b/noncore/apps/keyz-cfg/zkbcfg.cpp
@@ -0,0 +1,228 @@
+#include <qfileinfo.h>
+
+#include "zkbcfg.h"
+
+
+// Implementation of XkbConfig class
+ZkbConfig::ZkbConfig(const QString& dir):path(dir) {
+}
+
+ZkbConfig::~ZkbConfig() {
+}
+
+bool ZkbConfig::load(const QString& file, Keymap& keymap, const QString& prefix) {
+        bool ret;
+        QFile f(path+"/"+file);
+        QFileInfo fi(f);
+
+        qDebug("start loading file=%s\n", (const char*) file.utf8());
+        if (includedFiles.find(fi.absFilePath()) != includedFiles.end()) {
+                return false;
+        }
+
+        includedFiles.insert(fi.absFilePath(), 1);
+        QXmlInputSource is(f);
+        QXmlSimpleReader reader;
+        ZkbHandler h(*this, keymap, prefix);
+
+        reader.setContentHandler(&h);
+        reader.setErrorHandler(this);
+        ret = reader.parse(is);
+        includedFiles.remove(fi.absFilePath());
+
+        qDebug("end loading file=%s : status=%s\n", (const char*) file.utf8(),
+                (const char*) err.utf8());
+        return ret;
+}
+
+bool ZkbConfig::warning(const QXmlParseException& e) {
+        QString tmp;
+
+        tmp.sprintf("%d: warning: %s\n", e.lineNumber(), 
+                (const char*) e.message().utf8());
+
+        err += tmp;
+
+        return true;
+}
+
+bool ZkbConfig::error(const QXmlParseException& e) {
+        QString tmp;
+
+        tmp.sprintf("%d: error: %s\n", e.lineNumber(), 
+                (const char*) e.message().utf8());
+
+        err += tmp;
+
+        return true;
+}
+
+bool ZkbConfig::fatalError(const QXmlParseException& e) {
+        QString tmp;
+
+        tmp.sprintf("%d: fatal error: %s\n", e.lineNumber(), 
+                (const char*) e.message().utf8());
+
+        err += tmp;
+
+        return false;
+}
+
+QString ZkbConfig::errorString() {
+        return err;
+}
+
+// Implementation of ZkbHandler
+ZkbHandler::ZkbHandler(ZkbConfig& z, Keymap& k, const QString& p):zkc(z), keymap(k), 
+        prefix(p), ardelay(-1), arperiod(-1), currentState(0), currentAction(0) {
+}
+
+ZkbHandler::~ZkbHandler() {
+}
+
+bool ZkbHandler::startKeymapElement(int ard, int arp, const QString&) {
+        ardelay = ard;
+        arperiod = arp;
+
+        return true;
+}
+
+bool ZkbHandler::startIncludeElement(const QString& file, 
+        const QString& pref) {
+
+        QString p = prefix;
+
+        if (!pref.isNull()) {
+                p += pref + ":";
+        }
+                
+
+        bool ret = zkc.load(file, keymap, p);
+        if (!ret) {
+                setError("Error including file: " + file);
+        }
+
+        return ret;
+}
+
+bool ZkbHandler::startLabelElement(const QString& label, 
+        const QString& state) {
+
+        if (!keymap.addLabel(label, prefix + state)) {
+                err = "label " + label + " already defined";
+                return false;
+        }
+
+        return true;
+}
+
+bool ZkbHandler::startStateElement(const QString& name, 
+        const QString& parentName, bool dflt) {
+
+        currentStateName = prefix + name;
+        currentState = keymap.getStateByName(currentStateName);
+
+        //qDebug("state name=%s\n", (const char*) currentStateName.utf8());
+
+        State* parent = 0;
+        if (!parentName.isEmpty()) {
+                QString pn = prefix + parentName;
+                parent = keymap.getStateByName(pn);
+                if (parent == 0) {
+                        err = currentStateName + 
+                                ": undefined parent state: " + pn;
+                        return false;
+                }
+        }
+
+        if (currentState == 0) {
+                currentState = new State(parent);
+                keymap.addState(currentStateName, currentState);
+        } else {
+                if (parent!=0) {
+                        currentState->setParent(parent);
+                }
+        }
+
+        if (dflt) {
+                keymap.setCurrentState(currentState);
+        }
+
+        return true;
+}
+
+bool ZkbHandler::startMapElement(int keycode, bool pressed) {
+        currentAction = currentState->get(keycode, pressed);
+        if (currentAction == 0) {
+                setError("keycode " + QString::number(keycode) + " not supported");
+                return false;
+        }
+
+        currentAction->setEvent(false);
+        currentAction->setState(0);
+
+        return true;
+}
+
+bool ZkbHandler::startEventElement(int keycode, int unicode, int modifiers, 
+        bool pressed, bool autorepeat) {
+
+        currentAction->setEvent(true);
+        currentAction->setKeycode(keycode);
+        currentAction->setUnicode(unicode);
+        currentAction->setModifiers(modifiers);
+        currentAction->setPressed(pressed);
+        currentAction->setAutorepeat(autorepeat);
+
+        return true;
+}
+
+bool ZkbHandler::startNextStateElement(const QString& state) {
+        State* s = keymap.getStateByName(prefix + state);
+        if (s == 0) {
+                setError("undefine state: " + prefix + state);
+                return false;
+        }
+
+        currentAction->setState(s);
+        return true;
+}
+
+
+bool ZkbHandler::endKeymapElement() {
+        if (ardelay > 0) {
+                keymap.setAutorepeatDelay(ardelay);
+        }
+
+        if (arperiod > 0) {
+                keymap.setAutorepeatPeriod(arperiod);
+        }
+        
+        return true;
+}
+
+bool ZkbHandler::endIncludeElement() {
+        return true;
+}
+
+bool ZkbHandler::endLabelElement() {
+        return true;
+}
+
+bool ZkbHandler::endStateElement() {
+        currentState = 0;
+        return true;
+}
+
+bool ZkbHandler::endMapElement() {
+        currentAction = 0;
+        return true;
+}
+
+bool ZkbHandler::endEventElement() {
+        return true;
+}
+
+bool ZkbHandler::endNextStateElement() {
+        return true;
+}