Diffstat (limited to 'noncore/applets/keyhelper/keyhelperapplet/config') (more/less context) (ignore whitespace changes)
14 files changed, 816 insertions, 0 deletions
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.cpp new file mode 100644 index 0000000..84bb375 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.cpp @@ -0,0 +1,80 @@ +#include "ExtensionsHandler.h" + +void ExtensionsHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent) +{ + m_parser = parser; + m_parent = parent; + m_parser->setContentHandler(this); +} + +bool ExtensionsHandler::startElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */, + const QXmlAttributes& attr) +{ + if(localName == "define"){ + /* ÊÑ¿ô½é´ü²½ */ + m_kind = QString::null; + m_code = -1; + //m_mask = 0; + m_modlist.clear(); + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i).lower() == "key"){ + /* keyname */ + if(attr.value(i) == "All"){ + m_code = 0; + } else { + m_code = KeyNames::getCode(attr.value(i)); + } + } else if(attr.localName(i).lower() == "code"){ + /* keycode */ + m_code = KHUtil::hex2int(attr.value(i).lower()); + } else if(attr.localName(i).lower() == "kind"){ + /* extension kind */ + m_kind = attr.value(i); + } + } + } else if(localName == "modifier"){ + /* modifier keys */ + for(int i=0; i<attr.length(); i++){ + if(attr.value(i).lower() == "on"){ + m_modlist.append(attr.localName(i)); + //m_mask |= m_pModifiers->getMask(attr.localName(i)); + } + } + } + return(true); +} + +bool ExtensionsHandler::endElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */) +{ + if(localName == "define"){ +#if 0 + if(m_kind != QString::null + && (m_code > 0 || m_modlist.isEmpty() == false)){ +#else + if(m_kind != QString::null && m_code >= 0){ +#endif + /* assign extension */ + int keymask = 0; + QValueList<int> modcodes; + for(QStringList::Iterator it=m_modlist.begin(); + it!=m_modlist.end(); ++it){ + keymask |= m_pModifiers->getMask(*it); + qDebug("mask[%s][%x][%s]", m_kind.latin1(), keymask, (*it).latin1()); + int code = KeyNames::getCode(*it); + if(code > 0){ + modcodes.append(code); + } + } + m_pExtensions->assign(m_kind, m_code, keymask, modcodes); + } + } else if(localName == "extensions"){ + m_pExtensions->init(); + /* return parent */ + m_parser->setContentHandler(m_parent); + } + return(true); +} diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.h new file mode 100644 index 0000000..cc2422b --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.h @@ -0,0 +1,48 @@ +#ifndef _EXTENSIONS_HANDLER_H_ +#define _EXTENSIONS_HANDLER_H_ + +#include <qstring.h> +#include <qstringlist.h> +#include <qvaluelist.h> +#include <qxml.h> +#include "KeyModifiers.h" +#include "KeyExtensions.h" +#include "KeyNames.h" +#include "KHUtil.h" + +class ExtensionsHandler : public QXmlDefaultHandler +{ +public: + void dispose(QXmlReader* parser, QXmlContentHandler* parent); + + void setKeyModifiers(KeyModifiers* mod) + { + m_pModifiers = mod; + } + void setKeyExtensions(KeyExtensions* ext) + { + m_pExtensions = ext; + } + + bool startElement(const QString& namespaceURI, + const QString& localName, + const QString& qName, + const QXmlAttributes& atts); + bool endElement(const QString& namespaceURI, + const QString& localName, + const QString& qName); +private: + QXmlContentHandler* m_parent; + QXmlReader* m_parser; + + KeyModifiers* m_pModifiers; + KeyExtensions* m_pExtensions; + + QString m_kind; + int m_code; + QStringList m_modlist; + //int m_mask; + +}; + +#endif /* _EXTENSIONS_HANDLER_H_ */ diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.cpp new file mode 100644 index 0000000..e1faf18 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.cpp @@ -0,0 +1,38 @@ +#include "KeycfgErrorHandler.h" + +void KeycfgErrorHandler::setErrorString(const QString& header, + const QXmlParseException& exception) +{ + m_errstr = header; + m_errstr.append(": "); + m_errstr.append(exception.message()); + m_errstr.append(" ["); + m_errstr.append(QString::number(exception.lineNumber())); + m_errstr.append(", "); + m_errstr.append(QString::number(exception.columnNumber())); + m_errstr.append("]"); + qWarning(m_errstr.latin1()); +} + +bool KeycfgErrorHandler::warning(const QXmlParseException& exception) +{ + setErrorString("warning", exception); + return(true); +} + +bool KeycfgErrorHandler::error(const QXmlParseException& exception) +{ + setErrorString("error", exception); + return(false); +} + +bool KeycfgErrorHandler::fatalError(const QXmlParseException& exception) +{ + setErrorString("fatal", exception); + return(false); +} + +QString KeycfgErrorHandler::errorString() +{ + return(m_errstr); +} diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.h new file mode 100644 index 0000000..61e7e70 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.h @@ -0,0 +1,23 @@ +#ifndef _KEYCFG_ERROR_HANDLER_H_ +#define _KEYCFG_ERROR_HANDLER_H_ + +#include <qstring.h> +#include <qxml.h> + +class KeycfgErrorHandler : public QXmlErrorHandler +{ +public: + KeycfgErrorHandler(){} + virtual ~KeycfgErrorHandler(){} + + bool warning(const QXmlParseException& exception); + bool error(const QXmlParseException& exception); + bool fatalError(const QXmlParseException& exception); + QString errorString(); +private: + void setErrorString(const QString& header, + const QXmlParseException& exception); + QString m_errstr; +}; + +#endif /* _KEYCFG_ERROR_HANDLER_H_ */ diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.cpp new file mode 100644 index 0000000..a342e36 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.cpp @@ -0,0 +1,43 @@ +#include "KeycfgHandler.h" + +KeycfgHandler::KeycfgHandler(QXmlReader* parser) + : QXmlDefaultHandler() +{ + m_parser = parser; + m_pModHandler = new ModifiersHandler(); + m_pMapHandler = new MappingsHandler(); + m_pExtHandler = new ExtensionsHandler(); + m_pRepHandler = new RepeaterHandler(); +} + +KeycfgHandler::~KeycfgHandler() +{ + delete m_pModHandler; + delete m_pMapHandler; + delete m_pExtHandler; + delete m_pRepHandler; +} + +bool KeycfgHandler::startElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */, + const QXmlAttributes& /* attr */) +{ + if(localName == "modifiers"){ + m_pModHandler->setKeyModifiers(m_pModifiers); + m_pModHandler->setKeyMappings(m_pMappings); + m_pModHandler->dispose(m_parser, this); + } else if(localName == "mappings"){ + m_pMapHandler->setKeyModifiers(m_pModifiers); + m_pMapHandler->setKeyMappings(m_pMappings); + m_pMapHandler->dispose(m_parser, this); + } else if(localName == "extensions"){ + m_pExtHandler->setKeyModifiers(m_pModifiers); + m_pExtHandler->setKeyExtensions(m_pExtensions); + m_pExtHandler->dispose(m_parser, this); + } else if(localName == "repeater"){ + m_pRepHandler->setKeyRepeater(m_pRepeater); + m_pRepHandler->dispose(m_parser, this); + } + return(true); +} diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.h new file mode 100644 index 0000000..9ddded3 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.h @@ -0,0 +1,56 @@ +#ifndef _KEYCFG_HANDLER_H_ +#define _KEYCFG_HANDLER_H_ + +#include <qxml.h> +#include <qstring.h> +#include "ModifiersHandler.h" +#include "MappingsHandler.h" +#include "ExtensionsHandler.h" +#include "RepeaterHandler.h" + +class KeycfgHandler : public QXmlDefaultHandler +{ +public: + KeycfgHandler(QXmlReader* parser); + ~KeycfgHandler(); + + void dispose(QXmlReader* parser, QXmlContentHandler* parent); + + void setKeyModifiers(KeyModifiers* mod) + { + m_pModifiers = mod; + } + void setKeyMappings(KeyMappings* map) + { + m_pMappings = map; + } + void setKeyExtensions(KeyExtensions* ext) + { + m_pExtensions = ext; + } + void setKeyRepeater(KeyRepeater* rep) + { + m_pRepeater = rep; + } + + + bool startElement(const QString& namespaceURI, + const QString& localName, + const QString& qName, + const QXmlAttributes& atts); +private: + QXmlContentHandler* m_parent; + QXmlReader* m_parser; + + ModifiersHandler* m_pModHandler; + MappingsHandler* m_pMapHandler; + ExtensionsHandler* m_pExtHandler; + RepeaterHandler* m_pRepHandler; + + KeyModifiers* m_pModifiers; + KeyMappings* m_pMappings; + KeyExtensions* m_pExtensions; + KeyRepeater* m_pRepeater; +}; + +#endif /* _KEYCFG_HANDLER_H_ */ diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.cpp new file mode 100644 index 0000000..44b4b2f --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.cpp @@ -0,0 +1,70 @@ +#include "KeycfgReader.h" + +KeycfgReader::KeycfgReader() +{ + qDebug("KeycfgReader::KeycfgReader()"); +} + +KeycfgReader::~KeycfgReader() +{ + qDebug("KeycfgReader::~KeycfgReader()"); +} + +bool KeycfgReader::load() +{ + QString file; + ConfigEx& cfg = ConfigEx::getInstance("keyhelper"); + + cfg.setGroup("Global"); + + file = cfg.readEntry("XmlFile"); + if(file.length() == 0 || !QFile::exists(file)){ + /* default */ + file = QDir::homeDirPath() + "/Settings/keyhelper.xml"; + } + return(load(file)); +} + +bool KeycfgReader::load(const QString& path) +{ + bool success = false; + + KeyNames::reset(); + + QXmlSimpleReader parser; + KeycfgHandler handler(&parser); + KeycfgErrorHandler errhandler; + QFile file(path); + + qWarning("KeycfgReader::load()[%s]", path.latin1()); + + if(file.exists()){ + QXmlInputSource source(file); + + handler.setKeyModifiers(m_pModifiers); + handler.setKeyMappings(m_pMappings); + handler.setKeyExtensions(m_pExtensions); + handler.setKeyRepeater(m_pRepeater); + + parser.setContentHandler(&handler); + parser.setErrorHandler(&errhandler); + success = parser.parse(source); + + file.close(); + } + + if(success){ + m_pModifiers->statistics(); + m_pMappings->statistics(); + m_pExtensions->statistics(); + m_pRepeater->statistics(); + } else { + m_pModifiers->reset(); + m_pMappings->reset(); + m_pExtensions->reset(); + m_pRepeater->reset(); + } + KeyNames::clearCode(); + + return(success); +} diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.h b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.h new file mode 100644 index 0000000..8624a01 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.h @@ -0,0 +1,46 @@ +#ifndef _KEYCFG_READER_H_ +#define _KEYCFG_READER_H_ + +#include <stdlib.h> +#include <qxml.h> +#include <qstring.h> +#include <qdir.h> +#include "KeycfgHandler.h" +#include "KeycfgErrorHandler.h" +#include "KeyNames.h" +#include "ConfigEx.h" + +class KeycfgReader +{ +public: + KeycfgReader(); + ~KeycfgReader(); + + bool load(); + bool load(const QString& path); + + inline void setKeyModifiers(KeyModifiers* mod) + { + m_pModifiers = mod; + } + inline void setKeyMappings(KeyMappings* map) + { + m_pMappings = map; + } + inline void setKeyExtensions(KeyExtensions* ext) + { + m_pExtensions = ext; + } + inline void setKeyRepeater(KeyRepeater* rep) + { + m_pRepeater = rep; + } + +private: + KeyModifiers* m_pModifiers; + KeyMappings* m_pMappings; + KeyExtensions* m_pExtensions; + KeyRepeater* m_pRepeater; +}; + +#endif /* _KEYCFG_READER_H_ */ diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.cpp new file mode 100644 index 0000000..3680fbf --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.cpp @@ -0,0 +1,102 @@ +#include "MappingsHandler.h" + +void MappingsHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent) +{ + m_parser = parser; + m_parent = parent; + m_parser->setContentHandler(this); +} + +bool MappingsHandler::startElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */, + const QXmlAttributes& attr) +{ + if(localName == "define"){ + /* ÊÑ¿ô½é´ü²½ */ + m_code = 0; + m_mask = 0; + m_mapcode = 0; + m_unicode = 0; + m_mapmodifiers.clear(); + m_mapunicodes.clear(); + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i).lower() == "key"){ + /* keyname */ + m_code = KeyNames::getCode(attr.value(i)); + } else if(attr.localName(i).lower() == "code"){ + /* keycode */ + m_code = KHUtil::hex2int(attr.value(i).lower()); + } + } + } else if(localName == "modifier"){ + /* modifier keys */ + for(int i=0; i<attr.length(); i++){ + if(attr.value(i).lower() == "on"){ + m_mask |= m_pModifiers->getMask(attr.localName(i)); + } + } + } else if(localName == "map"){ + /* mapping key */ + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i).lower() == "key"){ + /* keyname */ + m_mapcode = KeyNames::getCode(attr.value(i)); + } else if(attr.localName(i).lower() == "code"){ + /* keycode */ + m_mapcode = KHUtil::hex2int(attr.value(i).lower()); + } + } + } else if(localName == "map_modifier"){ + /* mapping modifiers */ + for(int i=0; i<attr.length(); i++){ + m_mapmodifiers[attr.localName(i)] = attr.value(i); + } + } else if(localName == "map_unicode"){ + /* mapping unicodes */ + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i).lower() == "char"){ + /* unicode char */ + m_unicode = attr.value(i)[0].unicode(); + } else if(attr.localName(i).lower() == "code"){ + /* unicode code */ + m_unicode = KHUtil::hex2int(attr.value(i).lower()); + } else { + m_mapunicodes[attr.localName(i)] = attr.value(i); + } + } + } + return(true); +} + +bool MappingsHandler::endElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */) +{ + if(localName == "define"){ + if(m_code > 0){ + /* assign mapping */ + m_pMappings->assign(m_code, m_mask, m_mapcode); + + for(QMap<QString,QString>::Iterator it=m_mapmodifiers.begin(); + it!=m_mapmodifiers.end(); ++it){ + /* assign mapping modifier state */ + m_pMappings->assignModifier(it.key(), it.data()); + } + + if(m_unicode > 0){ + m_pMappings->assignUnicode(m_unicode); + } else { + for(QMap<QString,QString>::Iterator it=m_mapunicodes.begin(); + it!=m_mapunicodes.end(); ++it){ + /* assign mapping unicode */ + m_pMappings->assignUnicode(it.key(), it.data()); + } + } + } + } else if(localName == "mappings"){ + /* return parent */ + m_parser->setContentHandler(m_parent); + } + return(true); +} diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.h new file mode 100644 index 0000000..d899ea2 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.h @@ -0,0 +1,48 @@ +#ifndef _MAPPINGS_HANDLER_H_ +#define _MAPPINGS_HANDLER_H_ + +#include <qxml.h> +#include <qstring.h> +#include <qmap.h> +#include "KeyModifiers.h" +#include "KeyMappings.h" +#include "KeyNames.h" +#include "KHUtil.h" + +class MappingsHandler : public QXmlDefaultHandler +{ +public: + void dispose(QXmlReader* parser, QXmlContentHandler* parent); + + void setKeyModifiers(KeyModifiers* mod) + { + m_pModifiers = mod; + } + void setKeyMappings(KeyMappings* map) + { + m_pMappings = map; + } + + bool startElement(const QString& namespaceURI, + const QString& localName, + const QString& qName, + const QXmlAttributes& atts); + bool endElement(const QString& namespaceURI, + const QString& localName, + const QString& qName); +private: + QXmlContentHandler* m_parent; + QXmlReader* m_parser; + + KeyModifiers* m_pModifiers; + KeyMappings* m_pMappings; + + int m_code; + int m_mask; + int m_mapcode; + int m_unicode; + QMap<QString,QString> m_mapmodifiers; + QMap<QString,QString> m_mapunicodes; +}; + +#endif /* _MAPPINGS_HANDLER_H_ */ diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.cpp new file mode 100644 index 0000000..b2cde92 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.cpp @@ -0,0 +1,99 @@ +#include "ModifiersHandler.h" + +void ModifiersHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent) +{ + m_parser = parser; + m_parent = parent; + m_parser->setContentHandler(this); +} + +bool ModifiersHandler::startElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */, + const QXmlAttributes& attr) +{ + if(localName == "define"){ + /* ÊÑ¿ô½é´ü²½ */ + m_type = QString::null; + m_code = 0; + m_mask = 0; + m_release.clear(); + m_toggle = false; + m_mapping = false; + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i).lower() == "key"){ + /* keyname */ + m_code = KeyNames::getCode(attr.value(i)); + } else if(attr.localName(i).lower() == "code"){ + /* keycode */ + m_code = KHUtil::hex2int(attr.value(i).lower()); + } else if(attr.localName(i).lower() == "type"){ + /* modifier type */ + m_type = attr.value(i); + } else if(attr.localName(i).lower() == "mapping"){ + /* auto mapping */ + if(attr.value(i).lower() == "true"){ + m_mapping = true; + } + } else if(attr.localName(i).lower() == "toggle"){ + /* toggle mode */ + if(attr.value(i).lower() == "true"){ + m_toggle = true; + } + } + } + } else if(localName == "modifier"){ + /* modifier keys */ + for(int i=0; i<attr.length(); i++){ + if(attr.value(i).lower() == "on"){ + m_mask |= m_pModifiers->getMask(attr.localName(i)); + } + } + } else if(localName == "release"){ + /* release keys */ + int code = 0; + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i) == "key"){ + /* keyname */ + code = KeyNames::getCode(attr.value(i)); + } else if(attr.localName(i) == "code"){ + /* keycode */ + code = KHUtil::hex2int(attr.value(i).lower()); + } + } + if(code > 0){ + m_release.append(code); + } + } + return(true); +} + +bool ModifiersHandler::endElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */) +{ + if(localName == "define"){ + if(m_type != QString::null && m_code > 0){ + /* assign modifier */ + m_pModifiers->assign(m_type, m_code, m_mask, m_toggle); + for(QValueList<int>::Iterator it=m_release.begin(); + it!=m_release.end(); ++it){ + /* assign modifier release keys */ + m_pModifiers->assignRelease(*it); + } + int code = KeyNames::getCode(m_type); + if(code <= 0){ + qDebug("setCode[%s][%x]", m_type.latin1(), m_code); + KeyNames::setCode(m_type, m_code); + } + if(m_mapping){ + /* auto mapping */ + m_pMappings->assign(m_code, m_mask, code, 0); + } + } + } else if(localName == "modifiers"){ + /* return parent */ + m_parser->setContentHandler(m_parent); + } + return(true); +} diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.h new file mode 100644 index 0000000..e2d8785 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.h @@ -0,0 +1,48 @@ +#ifndef _MODIFIERS_HANDLER_H_ +#define _MODIFIERS_HANDLER_H_ + +#include <qstring.h> +#include <qvaluelist.h> +#include <qxml.h> +#include "KeyModifiers.h" +#include "KeyMappings.h" +#include "KeyNames.h" +#include "KHUtil.h" + +class ModifiersHandler : public QXmlDefaultHandler +{ +public: + void dispose(QXmlReader* parser, QXmlContentHandler* parent); + + void setKeyModifiers(KeyModifiers* mod) + { + m_pModifiers = mod; + } + void setKeyMappings(KeyMappings* map) + { + m_pMappings = map; + } + + bool startElement(const QString& namespaceURI, + const QString& localName, + const QString& qName, + const QXmlAttributes& atts); + bool endElement(const QString& namespaceURI, + const QString& localName, + const QString& qName); +private: + QXmlContentHandler* m_parent; + QXmlReader* m_parser; + + KeyModifiers* m_pModifiers; + KeyMappings* m_pMappings; + + QString m_type; + int m_code; + int m_mask; + QValueList<int> m_release; + bool m_mapping; + bool m_toggle; +}; + +#endif /* _MODIFIERS_HANDLER_H_ */ diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.cpp new file mode 100644 index 0000000..aeae761 --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.cpp @@ -0,0 +1,76 @@ +#include "RepeaterHandler.h" + +void RepeaterHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent) +{ + m_parser = parser; + m_parent = parent; + m_parser->setContentHandler(this); +} + +bool RepeaterHandler::startElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */, + const QXmlAttributes& attr) +{ + if(localName == "repeat"){ + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i).lower() == "delay"){ + bool ok; + int delay = attr.value(i).toInt(&ok); + if(ok){ + m_pRepeater->setDelay(delay); + } + } else if(attr.localName(i).lower() == "period"){ + bool ok; + int period = attr.value(i).toInt(&ok); + if(ok){ + m_pRepeater->setPeriod(period); + } + } else if(attr.localName(i).lower() == "mode"){ + /* default mode */ + bool ok; + int mode = attr.value(i).toInt(&ok); + if(ok){ + m_pRepeater->setMode(mode); + } + } + } + } else if(localName == "define"){ + /* ÊÑ¿ô½é´ü²½ */ + m_code = 0; + m_enable = true; + for(int i=0; i<attr.length(); i++){ + if(attr.localName(i).lower() == "key"){ + /* keyname */ + m_code = KeyNames::getCode(attr.value(i)); + } else if(attr.localName(i).lower() == "code"){ + /* keycode */ + m_code = KHUtil::hex2int(attr.value(i).lower()); + } else if(attr.localName(i).lower() == "enable"){ + /* enable/disable */ + if(attr.value(i).lower() == "false"){ + m_enable = false; + } else { + m_enable = true; + } + } + } + } + return(true); +} + +bool RepeaterHandler::endElement(const QString& /* namespaceURI */, + const QString& localName, + const QString& /* qName */) +{ + if(localName == "define"){ + if(m_code > 0){ + /* set repeat enable/disable */ + m_pRepeater->setRepeatable(m_code, m_enable); + } + } else if(localName == "repeater"){ + /* return parent */ + m_parser->setContentHandler(m_parent); + } + return(true); +} diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.h new file mode 100644 index 0000000..d25583b --- a/dev/null +++ b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.h @@ -0,0 +1,39 @@ +#ifndef _REPEATER_HANDLER_H_ +#define _REPEATER_HANDLER_H_ + +#include <qstring.h> +#include <qvaluelist.h> +#include <qxml.h> +#include "KeyRepeater.h" +#include "KeyNames.h" +#include "KHUtil.h" + +class RepeaterHandler : public QXmlDefaultHandler +{ +public: + void dispose(QXmlReader* parser, QXmlContentHandler* parent); + + void setKeyRepeater(KeyRepeater* rep) + { + m_pRepeater = rep; + } + + bool startElement(const QString& namespaceURI, + const QString& localName, + const QString& qName, + const QXmlAttributes& atts); + bool endElement(const QString& namespaceURI, + const QString& localName, + const QString& qName); +private: + QXmlContentHandler* m_parent; + QXmlReader* m_parser; + + KeyRepeater* m_pRepeater; + + int m_code; + bool m_enable; + +}; + +#endif /* _REPEATER_HANDLER_H_ */ |