40 files changed, 13021 insertions, 0 deletions
diff --git a/apps/Settings/keyz-cfg.desktop b/apps/Settings/keyz-cfg.desktop new file mode 100644 index 0000000..104eb73 --- a/dev/null +++ b/apps/Settings/keyz-cfg.desktop @@ -0,0 +1,6 @@ +[Desktop Entry] +Comment=keyz configurator +Exec=keyz-cfg +Icon=keyz-cfg +Type=Application +Name=keyz configurator diff --git a/noncore/applets/zkbapplet/config.in b/noncore/applets/zkbapplet/config.in new file mode 100644 index 0000000..19d6597 --- a/dev/null +++ b/noncore/applets/zkbapplet/config.in @@ -0,0 +1,4 @@ + config ZKBAPPLET + boolean "zkbapplet (switch keyboard layout on the fly)" + default "n" + depends ( LIBQPE || LIBQPE-X11 ) && KEYZCFG diff --git a/noncore/applets/zkbapplet/zkbapplet.control b/noncore/applets/zkbapplet/zkbapplet.control new file mode 100644 index 0000000..973373f --- a/dev/null +++ b/noncore/applets/zkbapplet/zkbapplet.control @@ -0,0 +1,9 @@ +Package: zkbapplet +Files: plugins/applets/libzkbapplet.so* pics/zkb-disabled.png share/zkb/*.xml +Priority: optional +Section: opie/applets +Maintainer: Rajko Albrecht <alwin@handhelds.org> +Architecture: arm +Depends: task-opie-minimal, key-cfg +Description: ZKB Applet +Version: 0.6.0-$EXTRAVERSION diff --git a/noncore/applets/zkbapplet/zkbapplet.cpp b/noncore/applets/zkbapplet/zkbapplet.cpp new file mode 100644 index 0000000..6c71568 --- a/dev/null +++ b/noncore/applets/zkbapplet/zkbapplet.cpp @@ -0,0 +1,49 @@ +#include <stdio.h> +#include <qlabel.h> +#include <qbutton.h> +#include <qwindowsystem_qws.h> +#include "zkbapplet.h" +#include "zkbwidget.h" + + +ZkbApplet::ZkbApplet() : app(0){ +} + +ZkbApplet::~ZkbApplet() +{ + if (app) delete app; +} + +QWidget* ZkbApplet::applet(QWidget* parent) { + if (app == 0) { + app = new ZkbWidget(parent); + } + + return app; +} + +int ZkbApplet::position() const { + return 8; +} + +QRESULT ZkbApplet::queryInterface(const QUuid& uuid, QUnknownInterface** iface) { + + *iface = 0; + if (uuid == IID_QUnknown) { + *iface = this; + } else if (uuid == IID_TaskbarApplet) { + *iface = this; + } else { + return QS_FALSE; + } + + if (*iface) { + (*iface)->addRef(); + } + + return QS_OK; +} + +Q_EXPORT_INTERFACE() { + Q_CREATE_INSTANCE(ZkbApplet) +} diff --git a/noncore/applets/zkbapplet/zkbapplet.h b/noncore/applets/zkbapplet/zkbapplet.h new file mode 100644 index 0000000..fcf03b5 --- a/dev/null +++ b/noncore/applets/zkbapplet/zkbapplet.h @@ -0,0 +1,23 @@ +#include "qpe/taskbarappletinterface.h" + +#ifndef ZKBAPPLET_H +#define ZKBAPPLET_H + +class ZkbWidget; + +class ZkbApplet : public TaskbarAppletInterface { +public: + ZkbApplet(); + virtual ~ZkbApplet(); + + QRESULT queryInterface(const QUuid&, QUnknownInterface**); + Q_REFCOUNT + + virtual QWidget* applet(QWidget*); + virtual int position() const; + +protected: + ZkbWidget* app; +}; + +#endif diff --git a/noncore/applets/zkbapplet/zkbapplet.pro b/noncore/applets/zkbapplet/zkbapplet.pro new file mode 100644 index 0000000..22615d0 --- a/dev/null +++ b/noncore/applets/zkbapplet/zkbapplet.pro @@ -0,0 +1,22 @@ +TEMPLATE = lib +CONFIG += qt plugin warn_on release +HEADERS = zkbapplet.h\ + zkbwidget.h \ + ../../apps/keyz-cfg/zkbcfg.h \ + ../../apps/keyz-cfg/zkbnames.h \ + ../../apps/keyz-cfg/zkbxml.h \ + ../../apps/keyz-cfg/zkb.h +SOURCES = zkbapplet.cpp \ + zkbwidget.cpp \ + ../../apps/keyz-cfg/zkbcfg.cpp \ + ../../apps/keyz-cfg/zkbnames.cpp \ + ../../apps/keyz-cfg/zkbxml.cpp \ + ../../apps/keyz-cfg/zkb.cpp +TARGET = zkbapplet +DESTDIR = $(OPIEDIR)/plugins/applets +INCLUDEPATH += $(OPIEDIR)/include ../../apps/keyz-cfg +DEPENDPATH += ../$(OPIEDIR)/include +VERSION = 0.6.0 +LIBS += -lqpe + +include ( $(OPIEDIR)/include.pro ) diff --git a/noncore/applets/zkbapplet/zkbwidget.cpp b/noncore/applets/zkbapplet/zkbwidget.cpp new file mode 100644 index 0000000..05a76e7 --- a/dev/null +++ b/noncore/applets/zkbapplet/zkbwidget.cpp @@ -0,0 +1,150 @@ +#include <qpe/qcopenvelope_qws.h> +#include <qpe/applnk.h> +#include <qpe/qpeapplication.h> +#include <qpe/resource.h> +#include <stdio.h> +#include <unistd.h> +#include "zkbwidget.h" +#include "zkbcfg.h" + +ZkbWidget::ZkbWidget(QWidget* parent):QLabel(parent),keymap(0), + disabled(Resource::loadPixmap("zkb-disabled")) { + + labels = new QPopupMenu(); + connect(labels, SIGNAL(activated(int)), this, + SLOT(labelChanged(int))); + + loadKeymap(); + + channel = new QCopChannel("QPE/zkb", this); + connect(channel, SIGNAL(received(const QCString&, const QByteArray&)), + this, SLOT(signalReceived(const QCString&, const QByteArray&))); + setFixedWidth ( AppLnk::smallIconSize() ); + setFixedHeight ( AppLnk::smallIconSize() ); +} + +ZkbWidget::~ZkbWidget() { +} + +bool ZkbWidget::loadKeymap() { + ZkbConfig c(QPEApplication::qpeDir()+"/share/zkb"); + QFontMetrics fm(font()); + + if (keymap != 0) { + delete keymap; + keymap = 0; + } + + Keymap* km = new Keymap(); + + if (!c.load("zkb.xml", *km, "")) { + delete km; + setPixmap(disabled); + return false; + } + + connect(km, SIGNAL(stateChanged(const QString&)), + this, SLOT(stateChanged(const QString&))); + + qwsServer->setKeyboardFilter(km); + + Keymap* oldkm = keymap; + keymap = km; + + if (oldkm != 0) { + delete oldkm; + } + + setText(keymap->getCurrentLabel()); + + labels->clear(); + QStringList l = keymap->listLabels(); + labels->insertItem(disabled, 0, 0); + int n = 1; + w = 0; + for(QStringList::Iterator it = l.begin(); it != l.end(); + ++it, n++) { + +// printf("label: %s\n", (const char*) (*it).utf8()); + + labels->insertItem(*it, n, n); + int lw = fm.width(*it); + if (lw > w) { + w = lw; + } + } + + if (w == 0) { + hide(); + } else { + show(); + } + return true; +} + +QSize ZkbWidget::sizeHint() const { + return QSize(AppLnk::smallIconSize(),AppLnk::smallIconSize()); +} + +void ZkbWidget::stateChanged(const QString& s) { +// qDebug("stateChanged: %s\n", (const char*) s.utf8()); + setText(s); +} + +void ZkbWidget::labelChanged(int id) { + if (id == 0) { + keymap->disable(); + setPixmap(disabled); + return; + } + + keymap->enable(); + + QStringList l = keymap->listLabels(); + QString lbl = l[id-1]; + +// printf("labelChanged: %s\n", (const char*) lbl.utf8()); + State* state = keymap->getStateByLabel(lbl); + if (state != 0) { + keymap->setCurrentState(state); + setText(lbl); + } +} + +void ZkbWidget::mouseReleaseEvent(QMouseEvent*) { + QSize sh = labels->sizeHint(); + QPoint p = mapToGlobal(QPoint((width()-sh.width())/2,-sh.height())); + labels->exec(p); +} + +void ZkbWidget::signalReceived(const QCString& msg, const QByteArray& data) { + QDataStream stream(data, IO_ReadOnly); + + if (msg == "enable()") { + keymap->enable(); + } else if (msg == "disable()") { + keymap->disable(); + } else if (msg == "reload()") { + QCopEnvelope("QPE/System", "busy()"); + QTimer::singleShot(0, this, SLOT(reload())); + } else if (msg == "switch(QString)") { + QString lbl; + stream >> lbl; + + if (keymap != 0) { + State* state = keymap->getStateByLabel(lbl); + if (state != 0) { + keymap->setCurrentState(state); + setText(lbl); + } + } + } else if (msg == "debug(QString)") { + QString flag; + stream >> flag; + } +} + +void ZkbWidget::reload() { + loadKeymap(); + QCopEnvelope("QPE/System", "notBusy()"); +} diff --git a/noncore/applets/zkbapplet/zkbwidget.h b/noncore/applets/zkbapplet/zkbwidget.h new file mode 100644 index 0000000..a943563 --- a/dev/null +++ b/noncore/applets/zkbapplet/zkbwidget.h @@ -0,0 +1,38 @@ +#ifndef ZKBWIDGET_H +#define ZKBWIDGET_H + +#include <qwidget.h> +#include <qlabel.h> +#include <qpopupmenu.h> +#include <qpixmap.h> +#include <qcopchannel_qws.h> + +#include "zkb.h" + +class ZkbWidget : public QLabel { +Q_OBJECT + +public: + ZkbWidget(QWidget* parent); + ~ZkbWidget(); + + QSize sizeHint() const; + +protected: + QLabel* label; + Keymap* keymap; + QPopupMenu* labels; + QCopChannel* channel; + int w, h; + QPixmap disabled; + + bool loadKeymap(); + void mouseReleaseEvent(QMouseEvent*); + +protected slots: + void stateChanged(const QString&); + void labelChanged(int id); + void signalReceived(const QCString& msg, const QByteArray& data); + void reload(); +}; +#endif diff --git a/noncore/apps/keyz-cfg/cfgdlg.cpp b/noncore/apps/keyz-cfg/cfgdlg.cpp new file mode 100644 index 0000000..863f21e --- a/dev/null +++ b/noncore/apps/keyz-cfg/cfgdlg.cpp @@ -0,0 +1,131 @@ + +#include <qdir.h> +#include <qpe/qpeapplication.h> +#include <qpe/qcopenvelope_qws.h> +#include <unistd.h> +#include "cfgdlg.h" + +CfgDlg::CfgDlg(QWidget* parent, CfgFile* cf, QApplication* app):QDialog(parent), cfile(cf), application(app) { + setCaption(tr("keyz configurator")); + + QGridLayout* gl = new QGridLayout(this, 7, 5, 5, 5); + + QLabel* flabel = new QLabel("Available Keymaps", this); + files = new QListBox(this); + QPushButton* addButton = new QPushButton(">>", this); //add->setText("Add"); + connect(addButton, SIGNAL(clicked()), this, SLOT(add())); + QLabel* klabel = new QLabel("Selected Keymaps", this); + keymaps = new QListBox(this); + connect(keymaps, SIGNAL(highlighted(const QString&)), this, SLOT(keymapHighlighted(const QString&))); + QPushButton* delButton = new QPushButton("<<", this); //del->setText("Delete"); + connect(delButton, SIGNAL(clicked()), this, SLOT(del())); + QPushButton* slabelButton = new QPushButton("Set Label", this); //apply->setText("Apply"); + connect(slabelButton, SIGNAL(clicked()), this, SLOT(setLabel())); + QLabel* l = new QLabel("Label", this); + label = new QLineEdit(this); + QLabel* adlabel = new QLabel("Auto Repeat Delay (ms)", this); + QLabel* aplabel = new QLabel("Auto Repeat Period (ms)", this); + ad = new QSpinBox(50, 5000, 5, this); + ap = new QSpinBox(0, 5000, 5, this); + +// QLabel* adms = new QLabel("ms", this); +// QLabel* apms = new QLabel("ms", this); + +// QCheckBox* enable = new QCheckBox("Enable", t); + + gl->setColStretch(0, 1); + gl->setColStretch(1, 1); + gl->setColStretch(3, 1); + gl->setColStretch(4, 1); + gl->setRowStretch(3, 1); + gl->addMultiCellWidget(flabel, 0, 0, 0, 1); + gl->addMultiCellWidget(klabel, 0, 0, 3, 4); + gl->addMultiCellWidget(files, 1, 3, 0, 1); + gl->addMultiCellWidget(keymaps, 1, 3, 3, 4); + gl->addWidget(addButton, 1, 2); + gl->addWidget(delButton, 2, 2); + + gl->addWidget(l, 4, 0); + gl->addWidget(label, 4, 1); + gl->addMultiCellWidget(slabelButton, 4, 4, 3, 4); + + gl->addMultiCellWidget(adlabel, 5, 5, 0, 2); + gl->addMultiCellWidget(ad, 5, 5, 3, 4); +// gl->addWidget(adms, 5, 3); + + gl->addMultiCellWidget(aplabel, 6, 6, 0, 2); + gl->addMultiCellWidget(ap, 6, 6, 3, 4); + +// gl->addWidget(apms, 6, 3); + + QList<CfgEntry>& e = cfile->getEntries(); + + for(uint i = 0; i < e.count(); i++) { + CfgEntry* entry = e.at(i); + keymaps->insertItem(entry->getFile()); + m.insert(entry->getFile(), entry->getLabel()); + } + + QDir dir(QPEApplication::qpeDir()+"/share/zkb", "*.xml"); + QStringList flist = dir.entryList(); + QStringList::Iterator sit; + for(sit = flist.begin(); sit != flist.end(); ++sit) { + if (*sit != "common.xml" && *sit != "zkb.xml" && m.find(*sit) == m.end()) { + files->insertItem(*sit); + } + } + + ad->setValue(cfile->getAutorepeatDelay()); + ap->setValue(cfile->getAutorepeatPeriod()); + +// gl->addMultiCellWidget(enable, 7, 7, 0, 4); +} + +CfgDlg::~CfgDlg() { +} + +void CfgDlg::add() { + if (!files->currentText().isEmpty()) { + QString t = files->currentText(); + files->removeItem(files->currentItem()); + keymaps->insertItem(t); + cfile->replaceEntry(t, ""); + m.replace(t, ""); + } +} + +void CfgDlg::del() { + if (!keymaps->currentText().isEmpty()) { + QString t = keymaps->currentText(); + keymaps->removeItem(keymaps->currentItem()); + cfile->deleteEntry(t); + files->insertItem(t); + m.remove(files->currentText()); + } +} + +void CfgDlg::setLabel() { + if (!keymaps->currentText().isEmpty()) { + cfile->replaceEntry(keymaps->currentText(), + label->text()); + m.replace(keymaps->currentText(), label->text()); + } +} + +void CfgDlg::keymapHighlighted(const QString&text) { + label->setText(*m.find(text)); +} + + +void CfgDlg::accept() { + cfile->setAutorepeatDelay(ad->value()); + cfile->setAutorepeatPeriod(ap->value()); + + CfgParser p; + p.save(QPEApplication::qpeDir()+"/share/zkb/zkb.xml", *cfile); + QCopEnvelope("QPE/zkb", "reload()"); + + QDialog::accept(); + parentWidget()->close(false); +} + diff --git a/noncore/apps/keyz-cfg/cfgdlg.h b/noncore/apps/keyz-cfg/cfgdlg.h new file mode 100644 index 0000000..16732ee --- a/dev/null +++ b/noncore/apps/keyz-cfg/cfgdlg.h @@ -0,0 +1,39 @@ +#include <qlabel.h> +#include <qlistbox.h> +#include <qpushbutton.h> +#include <qlineedit.h> +#include <qlayout.h> +#include <qcheckbox.h> +#include <qspinbox.h> +#include <qdialog.h> +#include <qapplication.h> + +#include "cfgfile.h" + +class CfgDlg : public QDialog { +Q_OBJECT + +public: + CfgDlg(QWidget* parent, CfgFile* cfile, QApplication *); + virtual ~CfgDlg(); + +protected: + CfgFile* cfile; + QApplication* application; + + QMap<QString, QString> m; + + QListBox* files; + QListBox* keymaps; + QLineEdit* label; + QSpinBox* ap; + QSpinBox* ad; + + virtual void accept(); + +protected slots: + void add(); + void del(); + void setLabel(); + void keymapHighlighted(const QString&); +}; diff --git a/noncore/apps/keyz-cfg/cfgfile.cpp b/noncore/apps/keyz-cfg/cfgfile.cpp new file mode 100644 index 0000000..b0dc968 --- a/dev/null +++ b/noncore/apps/keyz-cfg/cfgfile.cpp @@ -0,0 +1,338 @@ +#include <qmessagebox.h> +#include "cfgfile.h" + +// CfgEntry implementation +CfgEntry::CfgEntry() { +} + +CfgEntry::CfgEntry(const QString& f, const QString& l): + file(f), label(l) { +} + +const QString& CfgEntry::getFile() const { + return file; +} + +void CfgEntry::setFile(const QString& f) { + file = f; +} + +const QString& CfgEntry::getLabel() const { + return label; +} + +void CfgEntry::setLabel(const QString& f) { + label = f; +} + +// CfgFile implementation +CfgFile::CfgFile():ardelay(400), arperiod(80) { +} + +CfgFile::~CfgFile() { +} + +QList<CfgEntry>& CfgFile::getEntries() { + return entries; +} + +bool CfgFile::replaceEntry(const QString& file, const QString& label, int index) { + deleteEntry(file); + + CfgEntry* entry = new CfgEntry(file, label); + if (index >= 0) { + entries.insert(index, entry); + } else { + entries.append(entry); + } + + return true; +} + +bool CfgFile::deleteEntry(const QString& file) { + for(int i = 0; i < (int) entries.count(); i++) { + CfgEntry* entry = entries.at(i); + if (entry->getFile() == file) { + entries.remove(i); + return true; + } + } + return false; +} + +int CfgFile::getAutorepeatDelay() const { + return ardelay; +} + +void CfgFile::setAutorepeatDelay(int n) { + ardelay = n; +} + +int CfgFile::getAutorepeatPeriod() const { + return arperiod; +} + +void CfgFile::setAutorepeatPeriod(int n) { + arperiod = n; +} + +// CfgParser implementation +CfgParser::CfgParser() { +} + +bool CfgParser::load(QString file, CfgFile& cfg) { + QFile f(file); + QXmlInputSource is(f); + QXmlSimpleReader reader; + CfgHandler p(*this); + + reader.setErrorHandler(this); + reader.setContentHandler(&p); + + err = ""; + ardelay = -1; + arperiod = -1; + reader.parse(is); + + if (!err.isEmpty()) { + qDebug(err); + return false; + } + + QMap<QString, QString>::Iterator fit, lit; + for(uint i = 0; i < includeList.count(); i++) { + QString file = *includeList.at(i); + fit = includes.find(file); + QString prefix = fit.data(); + QString label = ""; + + qDebug("include: file=" + fit.key() + ", prefix=" + fit.data()); + lit = labels.find(prefix+":*"); + if (lit != labels.end()) { + label = lit.data(); + } + + cfg.replaceEntry(file, label); + } + + if (ardelay != -1) { + cfg.setAutorepeatDelay(ardelay); + } + + if (arperiod != -1) { + cfg.setAutorepeatPeriod(arperiod); + } + + return true; +} + +bool CfgParser::save(QString file, CfgFile& cfg) { + FILE* f = fopen((const char*) file.local8Bit(), "w"); + + fprintf(f, "<keymap autorepeat-delay=\"%d\" autorepeat-period=\"%d\" " + "author=\"keyzcfg\">\n", cfg.getAutorepeatDelay(), + cfg.getAutorepeatPeriod()); + + QList<CfgEntry>& entries = cfg.getEntries(); + int n; + + for(n=0; n < (int) entries.count(); n++) { + CfgEntry* entry = entries.at(n); + QString l = entry->getLabel(); + if (!l.isEmpty()) { + fprintf(f, "\t<label name=\"%s\" state=\"km%d:*\"/>\n", + (const char*) l.utf8(), n); + } + } + + for(n=0; n < (int) entries.count(); n++) { + CfgEntry* entry = entries.at(n); + fprintf(f, "\t<include file=\"%s\" prefix=\"km%d\"/>\n", + (const char*) entry->getFile().utf8(), n); + } + + int k = n-1; + char* states[] = { "LShift", "LShift-Caps", "LShift-Num", + "LShift-Num-Caps", 0}; + + for(n=0; n < (int) entries.count(); n++) { + QString nstate = "km" + QString::number(n+1); + if (n == k) { + nstate = "km" + QString::number(0); + } + + for(int i = 0; states[i] != 0; i++) { + fprintf(f, "\t<state name=\"km%d:%s\">\n", + n, states[i]); + fprintf(f, "\t\t<map keycode=\"Middle\" pressed=\"true\">\n"); + fprintf(f, "\t\t\t<next-state name=\"%s:%s\"/>\n", + (const char*) nstate.utf8(), states[i]); + fprintf(f, "\t\t</map>\n\t</state>\n\n"); + } + } + + fprintf(f, "\t<state name=\"km0:Normal\" default=\"true\"/>\n"); + + fprintf(f, "</keymap>"); + fclose(f); + return true; +} + +CfgParser::~CfgParser() { +} + +int CfgParser::getAutorepeatDelay() const { + return ardelay; +} + +void CfgParser::setAutorepeatDelay(int n) { + ardelay = n; +} + +int CfgParser::getAutorepeatPeriod() const { + return arperiod; +} + +void CfgParser::setAutorepeatPeriod(int n) { + arperiod = n; +} + +void CfgParser::addLabel(const QString& name, const QString& state) { + labels.insert(state, name); + labelList.append(&labels.find(state).data()); +} + +void CfgParser::addFile(const QString& file, const QString& prefix) { + includes.insert(file, prefix); + includeList.append(&includes.find(file).key()); +} + +QString CfgParser::errorString() { + return err; +} + +bool CfgParser::warning(const QXmlParseException& e) { + QString tmp; + + tmp.sprintf("%d: warning: %s\n", e.lineNumber(), + (const char*) e.message().utf8()); + + err += tmp; + + return true; +} + +bool CfgParser::error(const QXmlParseException& e) { + QString tmp; + + tmp.sprintf("%d: error: %s\n", e.lineNumber(), + (const char*) e.message().utf8()); + + err += tmp; + + return true; +} + +bool CfgParser::fatalError(const QXmlParseException& e) { + QString tmp; + + tmp.sprintf("%d: fatal error: %s\n", e.lineNumber(), + (const char*) e.message().utf8()); + + err += tmp; + + return false; +} + +// CfgHandler implementation +CfgHandler::CfgHandler(CfgParser& c):cfg(c) { +} + +CfgHandler::~CfgHandler() { +} + +bool CfgHandler::startKeymapElement(int ard, int arp, const QString& author) { + if (author != "keyzcfg") { + bool ret; + ret = QMessageBox::warning(0, "keyz configurator", + "Your zkb.xml doesn't seem created by keyz configurator.\n" + "By using keyz configurator you may loose your current " + "configuration\n Do you want to continue\n\n", + "Yes", "No", 0, 0, 1); + + if (ret != 0) { + err = "cancelled by user"; + return false; + } + } + + if (ard != -1) { + cfg.setAutorepeatDelay(ard); + } + + if (arp != -1) { + cfg.setAutorepeatPeriod(arp); + } + + return true; +} + +bool CfgHandler::startIncludeElement(const QString& file, + const QString& pref) { + + cfg.addFile(file, pref); + return true; +} + +bool CfgHandler::startLabelElement(const QString& label, + const QString& state) { + + cfg.addLabel(label, state); + return true; +} + +bool CfgHandler::startStateElement(const QString&, const QString&, bool) { + + return true; +} + +bool CfgHandler::startMapElement(int, bool) { + return true; +} + +bool CfgHandler::startEventElement(int, int, int, bool, bool) { + return true; +} + +bool CfgHandler::startNextStateElement(const QString&) { + return true; +} + + +bool CfgHandler::endKeymapElement() { + return true; +} + +bool CfgHandler::endIncludeElement() { + return true; +} + +bool CfgHandler::endLabelElement() { + return true; +} + +bool CfgHandler::endStateElement() { + return true; +} + +bool CfgHandler::endMapElement() { + return true; +} + +bool CfgHandler::endEventElement() { + return true; +} + +bool CfgHandler::endNextStateElement() { + return true; +} diff --git a/noncore/apps/keyz-cfg/cfgfile.h b/noncore/apps/keyz-cfg/cfgfile.h new file mode 100644 index 0000000..9759900 --- a/dev/null +++ b/noncore/apps/keyz-cfg/cfgfile.h @@ -0,0 +1,106 @@ +#ifndef CFGFILE_H +#define CFGFILE_H + +#include <qlist.h> +#include "zkbxml.h" + +class CfgEntry { +public: + CfgEntry(); + CfgEntry(const QString& file, const QString& label); + + const QString& getFile() const; + void setFile(const QString& f); + const QString& getLabel() const; + void setLabel(const QString& l); + +protected: + QString file; + QString label; +}; + +class CfgFile { +public: + CfgFile(); + ~CfgFile(); + + QList<CfgEntry>& getEntries(); + bool replaceEntry(const QString& file, const QString& label, + int index = -1); + bool deleteEntry(const QString& file); + + int getAutorepeatDelay() const; + void setAutorepeatDelay(int); + int getAutorepeatPeriod() const; + void setAutorepeatPeriod(int); + +protected: + QList<CfgEntry> entries; + int ardelay; + int arperiod; +}; + +class CfgParser : public QXmlErrorHandler { +public: + CfgParser(); + virtual ~CfgParser(); + + bool load(QString file, CfgFile& cfg); + bool save(QString file, CfgFile& cfg); + + void addLabel(const QString& name, const QString& state); + void addFile(const QString& file, const QString& prefix); + + int getAutorepeatDelay() const; + void setAutorepeatDelay(int); + int getAutorepeatPeriod() const; + void setAutorepeatPeriod(int); + + virtual bool warning(const QXmlParseException& e); + virtual bool error(const QXmlParseException& e); + virtual bool fatalError(const QXmlParseException& e); + virtual QString errorString(); + + QString getError(); + +protected: + QString err; + QMap<QString, QString> labels; + QMap<QString, QString> includes; + QList<QString> labelList; + QList<QString> includeList; + int ardelay; + int arperiod; +}; + +class CfgHandler : public ZkbXmlHandler { +public: + CfgHandler(CfgParser &); + virtual ~CfgHandler(); + +protected: + CfgParser& cfg; + + virtual bool startKeymapElement(int ardelay, int arperiod, + const QString& author); + virtual bool startIncludeElement(const QString& file, + const QString& prfix); + virtual bool startLabelElement(const QString& label, + const QString& state); + virtual bool startStateElement(const QString& name, + const QString& parent, bool dflt); + virtual bool startMapElement(int key, bool pressed); + virtual bool startEventElement(int keycode, int unicode, int modifiers, + bool pressed, bool autorepeat); + virtual bool startNextStateElement(const QString& state); + + virtual bool endKeymapElement(); + virtual bool endIncludeElement(); + virtual bool endLabelElement(); + virtual bool endStateElement(); + virtual bool endMapElement(); + virtual bool endEventElement(); + virtual bool endNextStateElement(); +}; + +#endif diff --git a/noncore/apps/keyz-cfg/config.in b/noncore/apps/keyz-cfg/config.in new file mode 100644 index 0000000..319bc1e --- a/dev/null +++ b/noncore/apps/keyz-cfg/config.in @@ -0,0 +1,4 @@ + config KEYZCFG + boolean "keyz-cfg (configuration tool for keyz applett)" + default "n" + depends ( LIBQPE || LIBQPE-X11 ) diff --git a/noncore/apps/keyz-cfg/keyz-cfg.control b/noncore/apps/keyz-cfg/keyz-cfg.control new file mode 100644 index 0000000..2a74b33 --- a/dev/null +++ b/noncore/apps/keyz-cfg/keyz-cfg.control @@ -0,0 +1,9 @@ +Package: keyz-cfg +Files: bin/keyz-cfg apps/Settings/key-cfg.desktop pics/keyz-cfg.png share/zkb/zkb.xml.sample +Priority: optional +Section: opie/applications +Maintainer: Rajko Albrecht <alwin@handhelds.org> +Architecture: arm +Depends: task-opie-minimal +Description: Keyz configuration program +Version: 0.6.0-$EXTRAVERSION diff --git a/noncore/apps/keyz-cfg/keyz-cfg.postinst b/noncore/apps/keyz-cfg/keyz-cfg.postinst new file mode 100755 index 0000000..c7d1cf4 --- a/dev/null +++ b/noncore/apps/keyz-cfg/keyz-cfg.postinst @@ -0,0 +1,3 @@ +#!/bin/sh + +test -f $OPIEDIR/share/zkb/zkb.xml || cp $OPIEDIR/share/zkb/zkb.xml.sample $OPIEDIR/share/zkb/zkb.xml diff --git a/noncore/apps/keyz-cfg/keyz-cfg.pro b/noncore/apps/keyz-cfg/keyz-cfg.pro new file mode 100644 index 0000000..cbaf718 --- a/dev/null +++ b/noncore/apps/keyz-cfg/keyz-cfg.pro @@ -0,0 +1,24 @@ +TEMPLATE = app +DESTDIR = $(OPIEDIR)/bin +CONFIG = qt warn_on release +HEADERS = zkb.h \ + zkbcfg.h \ + zkbnames.h \ + zkbxml.h \ + cfgdlg.h \ + cfgfile.h + +SOURCES = main.cpp \ + cfgdlg.cpp \ + cfgfile.cpp \ + zkb.cpp \ + zkbcfg.cpp \ + zkbnames.cpp \ + zkbxml.cpp + +INCLUDEPATH += $(OPIEDIR)/include +DEPENDPATH += $(OPIEDIR)/include +LIBS += -lqpe +TARGET = keyz-cfg + +include ( $(OPIEDIR)/include.pro ) diff --git a/noncore/apps/keyz-cfg/main.cpp b/noncore/apps/keyz-cfg/main.cpp new file mode 100644 index 0000000..264db20 --- a/dev/null +++ b/noncore/apps/keyz-cfg/main.cpp @@ -0,0 +1,24 @@ +#include <stdio.h> +#include <qpe/qpeapplication.h> +#include <qpe/qcopenvelope_qws.h> +#include <qmainwindow.h> + +#include "cfgfile.h" +#include "cfgdlg.h" + +int main( int argc, char **argv ) { + QPEApplication app(argc, argv); + CfgFile cfile; + CfgParser cp; + cp.load(QPEApplication::qpeDir()+"/share/zkb/zkb.xml", cfile); + + QMainWindow m; + CfgDlg c(&m, &cfile, &app); + app.showMainWidget(&m); + m.hide(); + c.showMaximized(); + + int ret = app.exec(); + + return ret; +} diff --git a/noncore/apps/keyz-cfg/zkb.cpp b/noncore/apps/keyz-cfg/zkb.cpp new file mode 100644 index 0000000..abe1f5f --- a/dev/null +++ b/noncore/apps/keyz-cfg/zkb.cpp @@ -0,0 +1,590 @@ +#include <qnamespace.h> +#include "zkb.h" +#include <stdio.h> + +// Implementation of Action class +Action::Action():state(0), keycode(0), unicode(0), flags(0) { +} + +Action::Action(State* s, ushort kc, ushort uni, int f): + state(s), keycode(kc), unicode(uni), flags(f) { +} + +Action::~Action() { +} + +State* Action::getState() const { + return state; +} + +void Action::setState(State* s) { + state = s; + setDefined(true); +} + +bool Action::hasEvent() const { + return flags & Event; +} + +void Action::setEvent(bool e) { + flags = (flags & ~Event) | ((e) ? Event : 0); + + if (e) { + setDefined(true); + } else { + if (state == 0) { + setDefined(false); + } + } +} + +bool Action::isDefined() const { + return flags & Defined; +} + +void Action::setDefined(bool d) { + flags = (flags & ~Defined) | ((d) ? Defined : 0); +} + +int Action::getKeycode() const { + return keycode; +} + +void Action::setKeycode(int c) { + keycode = (ushort) c; + setEvent(true); +} + +int Action::getUnicode() const { + return unicode; +} + +void Action::setUnicode(int u) { + unicode = (ushort) u; + setEvent(true); +} + +int Action::getModifiers() const { + int ret = 0; + if (flags & Shift_Mod) { + ret |= Qt::ShiftButton; + } + + if (flags & Ctrl_Mod) { + ret |= Qt::ControlButton; + } + + if (flags & Alt_Mod) { + ret |= Qt::AltButton; + } + + if (flags & Keypad_Mod) { + ret |= Qt::Keypad; + } + + return ret; +} + +void Action::setModifiers(int m) { + int n = 0; + + if (m & Qt::ShiftButton) { + n |= Shift_Mod; + } + + if (m & Qt::ControlButton) { + n |= Ctrl_Mod; + } + + if (m & Qt::AltButton) { + n |= Alt_Mod; + } + + if (m & Qt::Keypad) { + n |= Keypad_Mod; + } + + flags = flags & ~Mod_Bits | n; + setEvent(true); +} + +bool Action::isPressed() const { + return (flags & Press) != 0; +} + +void Action::setPressed(bool p) { + flags = (flags & ~Press) | ((p) ? Press : 0); + setEvent(true); +} + +bool Action::isAutorepeat() const { + return (flags & Autorepeat) != 0; +} + +void Action::setAutorepeat(bool p) { + flags = (flags & ~Autorepeat) | ((p) ? Autorepeat : 0); + setEvent(true); +} + +// Implementation of State class +const short State::x1[] = { /* from 0x20 to 0x5f */ + 31, 0, 28, 3, 5, 6, 9, 28, /* 0x20 - 0x27 */ + 11, 26, 10, 13, 26, 1, 29, 27, /* 0x28 - 0x2f */ + 15, 16, 22, 4, 17, 19, 24, 20, /* 0x30 - 0x37 */ + 8, 14, 29, 26, 29, 12, 32, 27, /* 0x38 - 0x3f */ + 18, 0, 1, 2, 3, 4, 5, 6, /* 0x40 - 0x47 */ + 7, 8, 9, 10, 11, 12, 13, 14, /* 0x48 - 0x4f */ + 15, 16, 17, 18, 19, 20, 21, 22, /* 0x50 - 0x57 */ + 23, 24, 25, 30, -1, 26, 28, 7, /* 0x58 - 0x5f */ + 31, -1, -1, -1, -1, -1, -1, -1, /* 0x60 - 0x67 */ + -1, -1, -1, -1, -1, -1, -1, -1, /* 0x68 - 0x6f */ + -1, -1, -1, -1, -1, -1, -1, -1, /* 0x70 - 0x77 */ + -1, -1, -1, 29, 31, 32, 32, 28, /* 0x78 - 0x7f */ +}; + +const short State::x2[] = { /* from 0x1000 to 0x1057*/ + 42, 36, -1, 30, 32, -1, -1, -1, /* 0x1000 - 0x1007 */ + -1, -1, -1, -1, -1, -1, -1, -1, /* 0x1008 - 0x100f */ + -1, -1, 44, 45, 46, 47, -1, -1, /* 0x1010 - 0x1017 */ + -1, -1, -1, -1, -1, -1, -1, -1, /* 0x1018 - 0x101f */ + 33, 35, 34, -1, 36, 27, -1, -1, /* 0x1020 - 0x1027 */ + -1, -1, -1, -1, -1, -1, -1, -1, /* 0x1028 - 0x102f */ + -1, -1, -1, -1, -1, -1, -1, -1, /* 0x1030 - 0x1037 */ + 37, 38, 40, 39, 41, -1, -1, -1, /* 0x1038 - 0x103f */ + -1, -1, -1, -1, -1, 35, -1, -1, /* 0x1040 - 0x1047 */ + -1, -1, -1, -1, -1, 48, -1, -1, /* 0x1048 - 0x104f */ + 43, 49, 50, -1, -1, -1, -1, -1, /* 0x1050 - 0x1057 */ +}; + +State::State(State* p):parent(p), keys(0) { + keys = new Action[Key_Max * 2 + 1]; +} + +State::State(const State& s) { + parent = s.parent; + keys = new Action[Key_Max * 2 + 1]; + memcpy(keys, s.keys, sizeof(Action) * (Key_Max * 2 + 1)); +} + +State::~State() { + if (keys!=0) { + delete [] keys; + } +} + +Action* State::get(int keycode, bool pressed, bool follow) const { + Action* ret = 0; + int n = translateKeycode(keycode); + + if (n != -1 && keys != 0) { + if (pressed) { + n += Key_Max; + } + ret = &keys[n]; + } + + if (ret==0 || !ret->isDefined()) { + if (follow && parent!=0) { + ret = parent->get(keycode, pressed, follow); + } + } + + return ret; +} + +bool State::set(int keycode, bool pressed, Action& action) { + int n = translateKeycode(keycode); + + if (n==-1 || keys==0) { + return false; + } + + if (pressed) { + n += Key_Max + 1; + } + + keys[n] = action; + return true; +} + +State* State::getParent() const { + return parent; +} + +void State::setParent(State* s) { + parent = s; +} + +int State::translateKeycode(int keycode) const { + if (keycode < 0x20) { + return -1; + } + + if (keycode < 0x80) { + return x1[keycode - 0x20]; + } + + if (keycode < 0x1000) { + return -1; + } + + if (keycode < 0x1057) { + return x2[keycode - 0x1000]; + } + + return -1; +} + +// Implementation of Keymap class +Keymap::Keymap():enabled(true), currentState(0), autoRepeatAction(0), repeater(this) { + repeatDelay=400; + repeatPeriod=80; + connect(&repeater, SIGNAL(timeout()), this, SLOT(autoRepeat())); +} + +Keymap::~Keymap() { + QMap<QString, State*>::Iterator it; + for(it = states.begin(); it != states.end(); ++it) { + delete it.data(); + } + states.clear(); +} + +bool Keymap::filter(int unicode, int keycode, int modifiers, + bool isPress, bool autoRepeat) { + + qDebug("filter: >>> unicode=%x, keycode=%x, modifiers=%x, " + "ispressed=%x\n", unicode, keycode, modifiers, isPress); + + if (!enabled) { + return false; + } + + // the second check is workaround to make suspend work if + // the user pressed it right after he did resume. for some + // reason the event sent by qt has autoRepeat true in this + // case + if (autoRepeat && keycode != 4177) { + return true; + } + + (void) unicode; (void) modifiers; + + Action* action = currentState->get(keycode, isPress, true); + if (action==0 || !action->isDefined()) { + return true; + } + + if (action->hasEvent()) { + qDebug("filter:<<< unicode=%x, keycode=%x, modifiers=%x, " + "ispressed=%x\n", action->getUnicode(), + action->getKeycode(), action->getModifiers(), + action->isPressed()); + + QWSServer::sendKeyEvent(action->getUnicode(), + action->getKeycode(), action->getModifiers(), + action->isPressed(), false); + } + + if (action->isAutorepeat()) { + autoRepeatAction = action; + repeater.start(repeatDelay, TRUE); + } else { + autoRepeatAction = 0; + } + + State* nstate = action->getState(); + if (nstate != 0) { + setCurrentState(nstate); + QString lbl = getCurrentLabel(); + if (!lbl.isEmpty()) { + emit stateChanged(lbl); + } + } + + + return true; +} + +void Keymap::enable() { + enabled = true; +} + +void Keymap::disable() { + enabled = false; +} + +QStringList Keymap::listStates() { + QStringList ret; + + QMap<QString, State*>::Iterator it; + for(it = states.begin(); it != states.end(); ++it) { + ret.append(it.key()); + } + + return ret; +} + +State* Keymap::getStateByName(const QString& name) { + QMap<QString, State*>::Iterator it = states.find(name); + + if (it == states.end()) { + return 0; + } + + return it.data(); +} + +QStringList Keymap::listLabels() { + QStringList ret; + + for(uint i = 0; i < labelList.count(); i++) { + ret.append(*labelList.at(i)); + } + + return ret; +} + +State* Keymap::getStateByLabel(const QString& label) { + QMap<QString, QString>::Iterator lit = labels.find(label); + State* state = 0; + + if (lit == labels.end()) { + return 0; + } + + QString name = lit.data(); + + int n = name.find(":*"); + if (n>=0 && n==(int)(name.length()-2)) { + name=name.left(name.length() - 1); + + n = currentStateName.findRev(":"); + if (n >= 0) { + name += currentStateName.mid(n+1); + } + } + +// qDebug("look for: %s\n", (const char*) name.utf8()); + QMap<QString, State*>::Iterator sit = states.find(name); + if (sit != states.end()) { + state = sit.data(); + } + + return state; +} + +bool Keymap::addState(const QString& name, State* state) { + if (states.find(name) != states.end()) { + return false; + } + + states.insert(name, state); + lsmapInSync = false; + + if (currentState == 0) { + setCurrentState(state); + } + + return true; +} + +State* Keymap::getCurrentState() const { + return currentState; +} + +QString Keymap::getCurrentLabel() { + return currentLabel; +} + +bool Keymap::setCurrentState(State* state) { + QMap<QString, State*>::Iterator it; + for(it = states.begin(); it != states.end(); ++it) { + State* s = it.data(); + if (s == state) { + currentState = s; + currentStateName = it.key(); + + qDebug("state changed: %s\n", (const char*) + currentStateName.utf8()); + + if (!lsmapInSync) { + generateLabelStateMaps(); + } + + QMap<State*, QString>::Iterator tit; + tit = stateLabelMap.find(state); + if (tit != stateLabelMap.end()) { + currentLabel = tit.data(); + } else { +// qDebug("no label for: " + currentStateName + "\n"); + currentLabel = ""; + } + + return true; + } + } + + return false; +} + +bool Keymap::removeState(const QString& name, bool force) { + QMap<QString, State*>::Iterator it = states.find(name); + + if (it == states.end()) { + return false; + } + + State* state = it.data(); + QList<Action> acts = findStateUsage(state); + + if (!acts.isEmpty()) { + if (!force) { + return false; + } else { + for(Action* a = acts.first(); a != 0; a = acts.next()) { + a->setState(0); + } + } + } + + if (state == currentState) { + if (states.begin() != states.end()) { + setCurrentState(states.begin().data()); + } + } + + states.remove(it); + delete state; + + lsmapInSync = false; + + return true; +} + +void Keymap::autoRepeat() { + if (autoRepeatAction != 0) { + qDebug("filter:<<< unicode=%x, keycode=%x, modifiers=%x, " + "ispressed=%x\n", autoRepeatAction->getUnicode(), + autoRepeatAction->getKeycode(), + autoRepeatAction->getModifiers(), + autoRepeatAction->isPressed()); + + QWSServer::sendKeyEvent(autoRepeatAction->getUnicode(), + autoRepeatAction->getKeycode(), + autoRepeatAction->getModifiers(), + autoRepeatAction->isPressed(), true); + } + + repeater.start(repeatPeriod, TRUE); +} + +bool Keymap::addLabel(const QString& label, const QString& state, int index) { + if (labels.find(label) != labels.end()) { + return false; + } + + labels.insert(label, state); + const QString& l = labels.find(label).key(); + if (index == -1) { + labelList.append(l); + } else { + labelList.insert(labelList.at(index), l); + } + + lsmapInSync = false; + + return true; +} + +bool Keymap::removeLabel(const QString& label) { + + if (labels.find(label) == labels.end()) { + return false; + } + + labels.remove(label); + labelList.remove(label); + lsmapInSync = false; + + if (label == currentLabel) { + currentLabel = ""; + } + + return true; +} + +int Keymap::getAutorepeatDelay() const { + return repeatDelay; +} + +void Keymap::setAutorepeatDelay(int n) { + repeatDelay = n; +} + +int Keymap::getAutorepeatPeriod() const { + return repeatPeriod; +} + +void Keymap::setAutorepeatPeriod(int n) { + repeatPeriod = n; +} + +QList<Action> Keymap::findStateUsage(State* s) { + QList<Action> ret; + + QMap<QString, State*>::Iterator it; + for(it = states.begin(); it != states.end(); ++it) { + State* state = it.data(); + + for(int i = 0; i < 0x1100; i++) { + Action* action = state->get(i, false); + if (action!=0 && action->getState()==s) { + ret.append(action); + } + + action = state->get(i, true); + if (action!=0 && action->getState()==s) { + ret.append(action); + } + } + } + + return ret; +} + +void Keymap::generateLabelStateMaps() { + stateLabelMap.clear(); + + QMap<QString, QString>::Iterator lit; + for(lit = labels.begin(); lit != labels.end(); ++lit) { + QString label = lit.key(); + QString name = lit.data(); + + bool wc = false; + int n = name.find("*"); + if (n>=0 && n==(int)(name.length()-1)) { + name=name.left(name.length() - 1); + wc = true; + } + + QMap<QString, State*>::Iterator sit; + for(sit = states.begin(); sit != states.end(); ++sit) { + QString sname = sit.key(); + State* state = sit.data(); + + if (sname.length() < name.length()) { + continue; + } + + if (sname.left(name.length()) == name) { + if (wc || sname.length()==name.length()) { + stateLabelMap.insert(state, label); + } + + } + } + } + + lsmapInSync = true; +} diff --git a/noncore/apps/keyz-cfg/zkb.h b/noncore/apps/keyz-cfg/zkb.h new file mode 100644 index 0000000..deff869 --- a/dev/null +++ b/noncore/apps/keyz-cfg/zkb.h @@ -0,0 +1,205 @@ +#ifndef ZKB_H +#define ZKB_H + +#include <qstring.h> +#include <qstringlist.h> +#include <qmap.h> +#include <qwindowsystem_qws.h> +#include <qkeyboard_qws.h> +#include <qtimer.h> +#include <stdio.h> + +class State; + +class Action { +protected: + State* state; + ushort keycode; + ushort unicode; + int flags; + + enum { + Shift_Mod = 1, + Ctrl_Mod = 2, + Alt_Mod = 4, + Keypad_Mod = 8, + Mod_Bits = 15, + Press = 16, + Autorepeat = 32, + Event = 64, + Defined = 128, + }; + + void setDefined(bool); + +public: + Action(); + Action(State*, ushort, ushort, int); + ~Action(); + + State* getState() const; + void setState(State*); + + bool hasEvent() const; + void setEvent(bool); + + bool isDefined() const; + + int getKeycode() const; + void setKeycode(int); + + int getUnicode() const; + void setUnicode(int); + + int getModifiers() const; + void setModifiers(int m); + + bool isPressed() const; + void setPressed(bool); + + bool isAutorepeat() const; + void setAutorepeat(bool); +}; + +class State { +protected: + State* parent; + Action* keys; + + enum { + Key_a=0, + Key_b=1, + Key_c=2, + Key_d=3, + Key_e=4, + Key_f=5, + Key_g=6, + Key_h=7, + Key_i=8, + Key_j=9, + Key_k=10, + Key_l=11, + Key_m=12, + Key_n=13, + Key_o=14, + Key_p=15, + Key_q=16, + Key_r=17, + Key_s=18, + Key_t=19, + Key_u=20, + Key_v=21, + Key_w=22, + Key_x=23, + Key_y=24, + Key_z=25, + Key_Comma=26, + Key_Slash=27, + Key_Quote=28, + Key_Dot=29, + Key_Backspace=30, + Key_Space=31, + Key_Enter=32, + Key_LeftShift=33, + Key_RightShift=34, + Key_Fn=35, + Key_Tab=36, + Key_Calendar=37, + Key_Addressbook=38, + Key_Home=39, + Key_Menu=40, + Key_Mail=41, + Key_Cancel=42, + Key_OK=43, + Key_Left=44, + Key_Up=45, + Key_Right=46, + Key_Down=47, + Key_Middle=48, + Key_Off=49, + Key_Light=50, + + Key_Max=51 + }; + + static const short x1[]; + static const short x2[]; + + int translateKeycode(int keycode) const; + +public: + State(State* parent=0); + State(const State&); + ~State(); + + Action* get(int keycode, bool pressed, bool follow = false) const; + bool set(int keycode, bool pressed, Action& action); + + State* getParent() const; + void setParent(State*); +}; + +class Keymap : public QObject, public QWSServer::KeyboardFilter { +Q_OBJECT + +public: + Keymap(); + virtual ~Keymap(); + + virtual bool filter(int unicode, int keycode, int modifiers, + bool isPress, bool autoRepeat); + + void enable(); + void disable(); + + QStringList listStates(); + State* getStateByName(const QString& name); + + QStringList listLabels(); + State* getStateByLabel(const QString& label); + + bool addState(const QString& name, State* state); + bool removeState(const QString& name, bool force = false); + bool setCurrentState(State*); + State* getCurrentState() const; + QString getCurrentLabel(); + + bool addLabel(const QString& label, const QString& state, + int index=-1); + bool removeLabel(const QString& label); + + int getAutorepeatDelay() const; + void setAutorepeatDelay(int); + + int getAutorepeatPeriod() const; + void setAutorepeatPeriod(int); + +signals: + void stateChanged(const QString& name); + +protected slots: + void autoRepeat(); + +protected: + QMap<QString, State*> states; + QMap<QString, QString> labels; + QStringList labelList; + + QMap<State*,QString> stateLabelMap; + bool lsmapInSync; + + bool enabled; + State* currentState; + QString currentStateName; + QString currentLabel; + Action* autoRepeatAction; + + int repeatDelay; + int repeatPeriod; + QTimer repeater; + + QList<Action> findStateUsage(State* s); + void generateLabelStateMaps(); +}; + +#endif 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; +} diff --git a/noncore/apps/keyz-cfg/zkbcfg.h b/noncore/apps/keyz-cfg/zkbcfg.h new file mode 100644 index 0000000..dc1ac07 --- a/dev/null +++ b/noncore/apps/keyz-cfg/zkbcfg.h @@ -0,0 +1,69 @@ +#ifndef ZKBCFG_H +#define ZKBCFG_H + +#include <qxml.h> +#include "zkb.h" +#include "zkbxml.h" + +class ZkbConfig : public QXmlErrorHandler { +public: + ZkbConfig(const QString& dir); + virtual ~ZkbConfig(); + + bool load(const QString& file, Keymap& keymap, const QString& prefix); + + virtual bool warning(const QXmlParseException& e); + virtual bool error(const QXmlParseException& e); + virtual bool fatalError(const QXmlParseException& e); + virtual QString errorString(); + +protected: + QString path; + QMap<QString, int> includedFiles; + QString err; +}; + +class ZkbHandler : public ZkbXmlHandler { +public: + ZkbHandler(ZkbConfig& zkc, Keymap& keymap, const QString& prefix); + virtual ~ZkbHandler(); + +protected: + ZkbConfig& zkc; + Keymap& keymap; + QString prefix; + + // stuff for keymap tag + int ardelay; + int arperiod; + + // stuff for state tag + QString currentStateName; + State* currentState; + + // stuff for map tag + Action* currentAction; + + virtual bool startKeymapElement(int ardelay, int arperiod, + const QString& author); + virtual bool startIncludeElement(const QString& file, + const QString& prfix); + virtual bool startLabelElement(const QString& label, + const QString& state); + virtual bool startStateElement(const QString& name, + const QString& parent, bool dflt); + virtual bool startMapElement(int key, bool pressed); + virtual bool startEventElement(int keycode, int unicode, int modifiers, + bool pressed, bool autorepeat); + virtual bool startNextStateElement(const QString& state); + + virtual bool endKeymapElement(); + virtual bool endIncludeElement(); + virtual bool endLabelElement(); + virtual bool endStateElement(); + virtual bool endMapElement(); + virtual bool endEventElement(); + virtual bool endNextStateElement(); +}; + +#endif diff --git a/noncore/apps/keyz-cfg/zkbnames.cpp b/noncore/apps/keyz-cfg/zkbnames.cpp new file mode 100644 index 0000000..fec3a2e --- a/dev/null +++ b/noncore/apps/keyz-cfg/zkbnames.cpp @@ -0,0 +1,450 @@ +#ifdef USE_ZKB_NAMES + +#include <qmap.h> +#include <qstring.h> + +#include "zkbnames.h" + +QString Null_String((const char*) 0); + +// Implementation of KeyNames +static struct { + int key; + char *name; +} Key_Names[] = { + { 32, "Space" }, + { 39, "Apostrophe" }, + { 44, "Comma" }, + { 46, "Period" }, + { 47, "Slash" }, + { 65, "A" }, + { 66, "B" }, + { 67, "C" }, + { 68, "D" }, + { 69, "E" }, + { 70, "F" }, + { 71, "G" }, + { 72, "H" }, + { 73, "I" }, + { 74, "J" }, + { 75, "K" }, + { 76, "L" }, + { 77, "M" }, + { 78, "N" }, + { 79, "O" }, + { 80, "P" }, + { 81, "Q" }, + { 82, "R" }, + { 83, "S" }, + { 84, "T" }, + { 85, "U" }, + { 86, "V" }, + { 87, "W" }, + { 88, "X" }, + { 89, "Y" }, + { 90, "Z" }, + { 4096, "Cancel" }, + { 4097, "Tab" }, + { 4099, "Backspace" }, + { 4100, "Enter" }, + { 4114, "Left" }, + { 4115, "Up" }, + { 4116, "Right" }, + { 4117, "Down" }, + { 4128, "Left Shift" }, + { 4130, "Right Shift" }, + { 4152, "Calendar" }, + { 4153, "Addressbook" }, + { 4154, "Menu" }, + { 4155, "Home" }, + { 4156, "Mail" }, + { 4165, "Fn" }, + { 4173, "Middle" }, + { 4176, "OK" }, + { 4177, "Off" }, + { 4178, "Light" }, + { 0, 0 } +}; + +static QMap<QString, int> kn_map; +static QMap<int, QString> kn_rmap; + +void init_kn_maps() { + int i = 0; + while (Key_Names[i].name != 0) { + int key = Key_Names[i].key; + QString name(Key_Names[i].name); + + kn_map.insert(name, key); + kn_rmap.insert(key, name); + i++; + } +} + +int KeyNames::find(const QString& key) { + if (kn_map.isEmpty()) { + init_kn_maps(); + } + + QMap<QString, int>::Iterator it = kn_map.find(key); + if (it == kn_map.end()) { + return -1; + } else { + return it.data(); + } +} + +const QString& KeyNames::find(int k) { + if (kn_map.isEmpty()) { + init_kn_maps(); + } + + QMap<int, QString>::Iterator it = kn_rmap.find(k); + if (it == kn_rmap.end()) { + return Null_String; + } else { + return it.data(); + } +} + +// Implementation of ModifierNames +struct { + int value; + char* name; +} Modifier_Names[] = { + { 8, "Shift" }, + { 16, "Control" }, + { 32, "Alt" }, + { 0x4000, "Keypad" }, + { 0, 0 } +}; + +static QMap<QString, int> mn_map; +static QMap<int, QString> mn_rmap; + +void init_mn_maps() { + int i = 0; + while (Modifier_Names[i].name != 0) { + int value = Modifier_Names[i].value; + QString name(Modifier_Names[i].name); + + mn_map.insert(name, value); + mn_rmap.insert(value, name); + i++; + } +} + +int ModifierNames::find(const QString& key) { + if (mn_map.isEmpty()) { + init_mn_maps(); + } + + QMap<QString, int>::Iterator it = mn_map.find(key); + if (it == mn_map.end()) { + return -1; + } else { + return it.data(); + } +} + +const QString& ModifierNames::find(int k) { + if (mn_map.isEmpty()) { + init_mn_maps(); + } + + QMap<int, QString>::Iterator it = mn_rmap.find(k); + if (it == mn_rmap.end()) { + return Null_String; + } else { + return it.data(); + } +} + +// Implementation of KeycodeNames + +struct { + char* name; + int keycode; +} Keycode_Names[] = { + { "Escape", 0x1000 }, + { "Tab", 0x1001 }, + { "Backtab", 0x1002 }, + { "Backspace", 0x1003 }, + { "BackSpace", 0x1003 }, + { "Return", 0x1004 }, + { "Enter", 0x1005 }, + { "Insert", 0x1006 }, + { "Delete", 0x1007 }, + { "Pause", 0x1008 }, + { "Print", 0x1009 }, + { "SysReq", 0x100a }, + { "Home", 0x1010 }, + { "End", 0x1011 }, + { "Left", 0x1012 }, + { "Up", 0x1013 }, + { "Right", 0x1014 }, + { "Down", 0x1015 }, + { "Prior", 0x1016 }, + { "PageUp", 0x1016 }, + { "Next", 0x1017 }, + { "PageDown", 0x1017 }, + { "Shift", 0x1020 }, + { "Control", 0x1021 }, + { "Meta", 0x1022 }, + { "Alt", 0x1023 }, + { "CapsLock", 0x1024 }, + { "NumLock", 0x1025 }, + { "ScrollLock", 0x1026 }, + { "F1", 0x1030 }, + { "F2", 0x1031 }, + { "F3", 0x1032 }, + { "F4", 0x1033 }, + { "F5", 0x1034 }, + { "F6", 0x1035 }, + { "F7", 0x1036 }, + { "F8", 0x1037 }, + { "F9", 0x1038 }, + { "F10", 0x1039 }, + { "F11", 0x103a }, + { "F12", 0x103b }, + { "F13", 0x103c }, + { "F14", 0x103d }, + { "F15", 0x103e }, + { "F16", 0x103f }, + { "F17", 0x1040 }, + { "F18", 0x1041 }, + { "F19", 0x1042 }, + { "F20", 0x1043 }, + { "F21", 0x1044 }, + { "F22", 0x1045 }, + { "F23", 0x1046 }, + { "F24", 0x1047 }, + { "F25", 0x1048 }, + { "F26", 0x1049 }, + { "F27", 0x104a }, + { "F28", 0x104b }, + { "F29", 0x104c }, + { "F30", 0x104d }, + { "F31", 0x104e }, + { "F32", 0x104f }, + { "F33", 0x1050 }, + { "F34", 0x1051 }, + { "F35", 0x1052 }, + { "Super_L", 0x1053 }, + { "Super_R", 0x1054 }, + { "Menu", 0x1055 }, + { "Hyper_L", 0x1056 }, + { "Hyper_R", 0x1057 }, + { "Help", 0x1058 }, + { "Space", 0x20 }, + { "Any", 0x20 }, + { "Exclam", 0x21 }, + { "QuoteDbl", 0x22 }, + { "NumberSign", 0x23 }, + { "Dollar", 0x24 }, + { "Percent", 0x25 }, + { "Ampersand", 0x26 }, + { "Apostrophe", 0x27 }, + { "ParenLeft", 0x28 }, + { "ParenRight", 0x29 }, + { "Asterisk", 0x2a }, + { "Plus", 0x2b }, + { "Comma", 0x2c }, + { "Minus", 0x2d }, + { "Period", 0x2e }, + { "Slash", 0x2f }, + { "0", 0x30 }, + { "1", 0x31 }, + { "2", 0x32 }, + { "3", 0x33 }, + { "4", 0x34 }, + { "5", 0x35 }, + { "6", 0x36 }, + { "7", 0x37 }, + { "8", 0x38 }, + { "9", 0x39 }, + { "Colon", 0x3a }, + { "Semicolon", 0x3b }, + { "Less", 0x3c }, + { "Equal", 0x3d }, + { "Greater", 0x3e }, + { "Question", 0x3f }, + { "At", 0x40 }, + { "A", 0x41 }, + { "B", 0x42 }, + { "C", 0x43 }, + { "D", 0x44 }, + { "E", 0x45 }, + { "F", 0x46 }, + { "G", 0x47 }, + { "H", 0x48 }, + { "I", 0x49 }, + { "J", 0x4a }, + { "K", 0x4b }, + { "L", 0x4c }, + { "M", 0x4d }, + { "N", 0x4e }, + { "O", 0x4f }, + { "P", 0x50 }, + { "Q", 0x51 }, + { "R", 0x52 }, + { "S", 0x53 }, + { "T", 0x54 }, + { "U", 0x55 }, + { "V", 0x56 }, + { "W", 0x57 }, + { "X", 0x58 }, + { "Y", 0x59 }, + { "Z", 0x5a }, + { "BracketLeft", 0x5b }, + { "Backslash", 0x5c }, + { "BracketRight", 0x5d }, + { "AsciiCircum", 0x5e }, + { "Underscore", 0x5f }, + { "QuoteLeft", 0x60 }, + { "BraceLeft", 0x7b }, + { "Bar", 0x7c }, + { "BraceRight", 0x7d }, + { "AsciiTilde", 0x7e }, + { "nobreakspace", 0x0a0 }, + { "exclamdown", 0x0a1 }, + { "cent", 0x0a2 }, + { "sterling", 0x0a3 }, + { "currency", 0x0a4 }, + { "yen", 0x0a5 }, + { "brokenbar", 0x0a6 }, + { "section", 0x0a7 }, + { "diaeresis", 0x0a8 }, + { "copyright", 0x0a9 }, + { "ordfeminine", 0x0aa }, + { "guillemotleft", 0x0ab }, + { "notsign", 0x0ac }, + { "hyphen", 0x0ad }, + { "registered", 0x0ae }, + { "macron", 0x0af }, + { "degree", 0x0b0 }, + { "plusminus", 0x0b1 }, + { "twosuperior", 0x0b2 }, + { "threesuperior", 0x0b3 }, + { "acute", 0x0b4 }, + { "mu", 0x0b5 }, + { "paragraph", 0x0b6 }, + { "periodcentered", 0x0b7 }, + { "cedilla", 0x0b8 }, + { "onesuperior", 0x0b9 }, + { "masculine", 0x0ba }, + { "guillemotright", 0x0bb }, + { "onequarter", 0x0bc }, + { "onehalf", 0x0bd }, + { "threequarters", 0x0be }, + { "questiondown", 0x0bf }, + { "Agrave", 0x0c0 }, + { "Aacute", 0x0c1 }, + { "Acircumflex", 0x0c2 }, + { "Atilde", 0x0c3 }, + { "Adiaeresis", 0x0c4 }, + { "Aring", 0x0c5 }, + { "AE", 0x0c6 }, + { "Ccedilla", 0x0c7 }, + { "Egrave", 0x0c8 }, + { "Eacute", 0x0c9 }, + { "Ecircumflex", 0x0ca }, + { "Ediaeresis", 0x0cb }, + { "Igrave", 0x0cc }, + { "Iacute", 0x0cd }, + { "Icircumflex", 0x0ce }, + { "Idiaeresis", 0x0cf }, + { "ETH", 0x0d0 }, + { "Ntilde", 0x0d1 }, + { "Ograve", 0x0d2 }, + { "Oacute", 0x0d3 }, + { "Ocircumflex", 0x0d4 }, + { "Otilde", 0x0d5 }, + { "Odiaeresis", 0x0d6 }, + { "multiply", 0x0d7 }, + { "Ooblique", 0x0d8 }, + { "Ugrave", 0x0d9 }, + { "Uacute", 0x0da }, + { "Ucircumflex", 0x0db }, + { "Udiaeresis", 0x0dc }, + { "Yacute", 0x0dd }, + { "THORN", 0x0de }, + { "ssharp", 0x0df }, + { "agrave", 0x0e0 }, + { "aacute", 0x0e1 }, + { "acircumflex", 0x0e2 }, + { "atilde", 0x0e3 }, + { "adiaeresis", 0x0e4 }, + { "aring", 0x0e5 }, + { "ae", 0x0e6 }, + { "ccedilla", 0x0e7 }, + { "egrave", 0x0e8 }, + { "eacute", 0x0e9 }, + { "ecircumflex", 0x0ea }, + { "ediaeresis", 0x0eb }, + { "igrave", 0x0ec }, + { "iacute", 0x0ed }, + { "icircumflex", 0x0ee }, + { "idiaeresis", 0x0ef }, + { "eth", 0x0f0 }, + { "ntilde", 0x0f1 }, + { "ograve", 0x0f2 }, + { "oacute", 0x0f3 }, + { "ocircumflex", 0x0f4 }, + { "otilde", 0x0f5 }, + { "odiaeresis", 0x0f6 }, + { "division", 0x0f7 }, + { "oslash", 0x0f8 }, + { "ugrave", 0x0f9 }, + { "uacute", 0x0fa }, + { "ucircumflex", 0x0fb }, + { "udiaeresis", 0x0fc }, + { "yacute", 0x0fd }, + { "thorn", 0x0fe }, + { "ydiaeresis", 0x0ff }, + { "unknown", 0xffff }, + { 0, 0} +}; + +static QMap<QString, int> kcn_map; +static QMap<int, QString> kcn_rmap; + +void init_kcn_maps() { + int i = 0; + while (Keycode_Names[i].name != 0) { + int keycode = Keycode_Names[i].keycode; + QString name(Keycode_Names[i].name); + + kcn_map.insert(name, keycode); + kcn_rmap.insert(keycode, name); + i++; + } +} + +int KeycodeNames::find(const QString& key) { + if (kcn_map.isEmpty()) { + init_kcn_maps(); + } + + QMap<QString, int>::Iterator it = kcn_map.find(key); + if (it == kcn_map.end()) { + return -1; + } else { + return it.data(); + } +} + +const QString& KeycodeNames::find(int k) { + if (kcn_map.isEmpty()) { + init_kcn_maps(); + } + + QMap<int, QString>::Iterator it = kcn_rmap.find(k); + if (it == kcn_rmap.end()) { + return Null_String; + } else { + return it.data(); + } +} + +#endif diff --git a/noncore/apps/keyz-cfg/zkbnames.h b/noncore/apps/keyz-cfg/zkbnames.h new file mode 100644 index 0000000..58462ff --- a/dev/null +++ b/noncore/apps/keyz-cfg/zkbnames.h @@ -0,0 +1,27 @@ +#ifndef ZKBNAMES_H +#define ZKBNAMES_H + +#ifdef USE_ZKB_NAMES + +#include <qstring.h> + +class KeyNames { +public: + static int find(const QString& key); + static const QString& find(int); +}; + +class KeycodeNames { +public: + static int find(const QString& key); + static const QString& find(int); +}; + +class ModifierNames { +public: + static int find(const QString& key); + static const QString& find(int); +}; + +#endif +#endif diff --git a/noncore/apps/keyz-cfg/zkbxml.cpp b/noncore/apps/keyz-cfg/zkbxml.cpp new file mode 100644 index 0000000..76472cb --- a/dev/null +++ b/noncore/apps/keyz-cfg/zkbxml.cpp @@ -0,0 +1,587 @@ +#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; + +#ifdef USE_ZKB_NAMES + ret = KeyNames::find(s); + if (ret == -1) { + setError("Invalid value: " + s); + } + +#else + ret = str2uint(s); +#endif + + return ret; +} + +int ZkbXmlHandler::str2modifier(const QString& val) { + int ret; + +#ifdef USE_ZKB_NAMES + 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()); +#else + ret = str2uint(val); +#endif + + 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; + +#ifdef USE_ZKB_NAMES + ret = KeycodeNames::find(s); + if (ret == -1) { + setError("Invalid value: " + s); + } + +#else + ret = str2uint(s); +#endif + + 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; +} diff --git a/noncore/apps/keyz-cfg/zkbxml.h b/noncore/apps/keyz-cfg/zkbxml.h new file mode 100644 index 0000000..2b15cbb --- a/dev/null +++ b/noncore/apps/keyz-cfg/zkbxml.h @@ -0,0 +1,68 @@ +#ifndef ZKBXML_H +#define ZKBXML_H + +#include <qxml.h> + +class ZkbXmlHandler : public QXmlDefaultHandler { +public: + ZkbXmlHandler(); + virtual ~ZkbXmlHandler(); + + virtual bool startElement(const QString&, const QString&, + const QString& name, const QXmlAttributes& attr); + + virtual bool endElement(const QString&, const QString&, + const QString& name); + + virtual QString errorString(); + +protected: + QString err; + QStringList elements; + + virtual bool startKeymapElement(int ardelay, int arperiod, + const QString& author); + virtual bool startIncludeElement(const QString& file, + const QString& prfix); + virtual bool startLabelElement(const QString& label, + const QString& state); + virtual bool startStateElement(const QString& name, + const QString& parent, bool dflt); + virtual bool startMapElement(int key, bool pressed); + virtual bool startEventElement(int keycode, int unicode, int modifiers, + bool pressed, bool autorepeat); + virtual bool startNextStateElement(const QString& state); + + virtual bool endKeymapElement(); + virtual bool endIncludeElement(); + virtual bool endLabelElement(); + virtual bool endStateElement(); + virtual bool endMapElement(); + virtual bool endEventElement(); + virtual bool endNextStateElement(); + + bool start_keymap(const QXmlAttributes&); + bool start_include(const QXmlAttributes&); + bool start_label(const QXmlAttributes&); + bool start_state(const QXmlAttributes&); + bool start_map(const QXmlAttributes&); + bool start_event(const QXmlAttributes&); + bool start_next_state(const QXmlAttributes&); + bool end_keymap(); + bool end_include(); + bool end_label(); + bool end_state(); + bool end_map(); + bool end_event(); + bool end_next_state(); + + void setError(const QString&); + int str2key(const QString&); + int str2modifier(const QString&); + bool str2bool(const QString&); + int str2unicode(const QString&); + int str2keycode(const QString&); + int str2uint(const QString&); +}; + +#endif @@ -1,205 +1,207 @@ CONFIG_ADDRESSBOOK core/pim/addressbook addressbook.pro CONFIG_ADVANCEDFM noncore/apps/advancedfm advancedfm.pro CONFIG_APPEARANCE2 noncore/settings/appearance2 appearance2.pro CONFIG_APPLET_EXAMPLE examples/applet example.pro CONFIG_APPSKEY noncore/settings/appskey appskey.pro CONFIG_AQPKG noncore/settings/aqpkg aqpkg.pro CONFIG_AUTOROTATEAPPLET noncore/applets/autorotateapplet autorotateapplet.pro CONFIG_BACKGAMMON noncore/games/backgammon backgammon.pro CONFIG_BACKUP noncore/settings/backup backup.pro CONFIG_BARTENDER noncore/apps/opie-bartender bartender.pro CONFIG_BATTERYAPPLET core/applets/batteryapplet batteryapplet.pro CONFIG_BEND noncore/unsupported/mail2/bend bend.pro CONFIG_BIGSCREEN_EXAMPLE libopie/big-screen/example osplitter_mail.pro CONFIG_BINARY noncore/tools/calc2/binary binary.pro CONFIG_BLUE-PIN noncore/net/opietooth/blue-pin blue-pin.pro CONFIG_BOUNCE noncore/games/bounce bounce.pro CONFIG_BUTTON-SETTINGS core/settings/button button.pro CONFIG_BUZZWORD noncore/games/buzzword buzzword.pro CONFIG_CALC2 noncore/tools/calc2 calc.pro CONFIG_CALCULATOR noncore/tools/calculator calculator.pro CONFIG_CALIBRATE core/apps/calibrate calibrate.pro CONFIG_CAMERA noncore/multimedia/camera camera.pro CONFIG_CARDMON core/applets/cardmon cardmon.pro CONFIG_CHECKBOOK noncore/apps/checkbook checkbook.pro CONFIG_CITYTIME core/settings/citytime citytime.pro CONFIG_CLIPBOARDAPPLET core/applets/clipboardapplet clipboardapplet.pro CONFIG_CLOCKAPPLET core/applets/clockapplet clockapplet.pro CONFIG_CLOCK noncore/tools/clock clock.pro CONFIG_CONFEDIT noncore/apps/confedit confedit.pro CONFIG_DASHER inputmethods/dasher dasher.pro CONFIG_DATEBOOK core/pim/datebook datebook.pro CONFIG_DECO_FLAT noncore/decorations/flat flat.pro CONFIG_DECO_LIQUID noncore/decorations/liquid liquid.pro CONFIG_DECO_POLISHED noncore/decorations/polished polished.pro CONFIG_DICTIONARY noncore/apps/dictionary dictionary.pro CONFIG_DOCTAB noncore/settings/doctab doctab.pro CONFIG_DRAWPAD noncore/graphics/drawpad drawpad.pro CONFIG_DVORAK inputmethods/dvorak dvorak.pro CONFIG_EMBEDDEDKONSOLE core/apps/embeddedkonsole embeddedkonsole.pro CONFIG_EUROCONV noncore/tools/euroconv/ euroconv.pro CONFIG_EXAMPLE_BOARD examples/inputmethod example.pro CONFIG_EXAMPLE_MENU examples/menuapplet menuapplet.pro CONFIG_EXAMPLE_VPN examples/networksettings example.pro CONFIG_FIFTEEN noncore/games/fifteen fifteen.pro CONFIG_FILEBROWSER noncore/unsupported/filebrowser filebrowser.pro CONFIG_FLAT noncore/styles/flat flat.pro CONFIG_FORMATTER noncore/tools/formatter formatter.pro CONFIG_FREETYPE freetype freetype.pro CONFIG_FRESH noncore/styles/fresh fresh.pro CONFIG_FTPLIB noncore/net/ftplib ftplib.pro CONFIG_GO noncore/games/go go.pro CONFIG_GSMTOOL noncore/unsupported/gsmtool gsmtool.pro CONFIG_HANDWRITING inputmethods/handwriting handwriting.pro CONFIG_HELPBROWSER core/apps/helpbrowser helpbrowser.pro CONFIG_HOMEAPPLET core/applets/homeapplet homeapplet.pro CONFIG_INTERFACES noncore/settings/networksettings/interfaces interfaces.pro CONFIG_IRDAAPPLET core/applets/irdaapplet irdaapplet.pro CONFIG_JUMPX inputmethods/jumpx jumpx.pro CONFIG_KBILL noncore/games/kbill kbill.pro CONFIG_KCHECKERS noncore/games/kcheckers kcheckers.pro CONFIG_KEYBOARD inputmethods/keyboard keyboard.pro CONFIG_KEYPEBBLE noncore/comm/keypebble keypebble.pro CONFIG_KEYVIEW development/keyview keyview.pro +CONFIG_KEYZCFG noncore/apps/keyz-cfg keyz-cfg.pro CONFIG_KJUMPX inputmethods/kjumpx kjumpx.pro CONFIG_KPACMAN noncore/games/kpacman kpacman.pro CONFIG_LANGUAGE noncore/settings/language language.pro CONFIG_LAUNCHER_CORE core/launcher server.pro CONFIG_LAUNCHER-SETTINGS core/settings/launcher launcher.pro CONFIG_LIBFFMPEG core/multimedia/opieplayer/libffmpeg libffmpeg.pro CONFIG_LIBFLASH core/multimedia/opieplayer/libflash libflash.pro CONFIG_LIBKATE noncore/apps/tinykate/libkate libkate.pro CONFIG_LIBMAD core/multimedia/opieplayer/libmad libmad.pro CONFIG_LIBMAIL noncore/unsupported/mail2/libmail libmail.pro CONFIG_LIBMAILWRAPPER noncore/net/mail/libmailwrapper libmailwrapper.pro CONFIG_LIBMPEG3 core/multimedia/opieplayer/libmpeg3 libmpeg3.pro CONFIG_LIBOPIE2CORE libopie2/opiecore opiecore.pro CONFIG_LIBOPIE2DB libopie2/opiedb opiedb.pro CONFIG_LIBOPIE2EXAMPLES libopie2/examples examples.pro CONFIG_LIBOPIE2MM libopie2/opiemm opiemm.pro CONFIG_LIBOPIE2NET libopie2/opienet opienet.pro CONFIG_LIBOPIE2PIM libopie2/opiepim opiepim.pro CONFIG_LIBOPIE2UI libopie2/opieui opieui.pro CONFIG_LIBOPIE libopie libopie.pro CONFIG_LIBOPIE_PIM libopie/pim pim.pro CONFIG_LIBOPIETOOTH noncore/net/opietooth/lib lib.pro CONFIG_LIBQPE library library.pro CONFIG_LIBQPE-X11 x11/libqpe-x11 libqpe-x11.pro CONFIG_LIBQTAUX libqtaux libqtaux.pro CONFIG_LIBSQL libsql libsql.pro CONFIG_LIBTREMOR core/multimedia/opieplayer/vorbis/tremor tremor.pro CONFIG_LIBTREMORPLUGIN core/multimedia/opieplayer/vorbis libtremor.pro CONFIG_LIGHT-AND-POWER core/settings/light-and-power light-and-power.pro CONFIG_LIQUID noncore/styles/liquid liquid.pro CONFIG_LOGOUTAPPLET core/applets/logoutapplet logoutapplet.pro CONFIG_MAIL3 noncore/net/mail mail.pro CONFIG_MAILAPPLET noncore/net/mail/taskbarapplet taskbarapplet.pro CONFIG_MAILIT noncore/unsupported/mailit mailit.pro CONFIG_MAIN_TAB_EXAMPLE examples/main-tab example.pro CONFIG_MEDIUMMOUNT noncore/settings/mediummount mediummount.pro CONFIG_MEMORYAPPLET noncore/applets/memoryapplet memoryapplet.pro CONFIG_METAL noncore/styles/metal metal.pro CONFIG_MINDBREAKER noncore/games/mindbreaker mindbreaker.pro CONFIG_MINESWEEP noncore/games/minesweep minesweep.pro CONFIG_MOBILEMSG noncore/comm/mobilemsg mobilemsg.pro CONFIG_MODPLUG core/multimedia/opieplayer/modplug modplug.pro CONFIG_MULTIKEYAPPLET core/applets/multikeyapplet multikeyapplet.pro CONFIG_MULTIKEY inputmethods/multikey multikey.pro CONFIG_NETSYSTEMTIME noncore/settings/netsystemtime netsystemtime.pro CONFIG_NETWORKAPPLET noncore/applets/networkapplet networkapplet.pro CONFIG_NETWORKSETUP noncore/settings/networksettings networksettings.pro CONFIG_NOTESAPPLET noncore/applets/notesapplet notesapplet.pro CONFIG_OAPP core/apps/oapp oapp.pro CONFIG_OBEX core/applets/obex2 obex.pro CONFIG_ODICT noncore/apps/odict odict.pro CONFIG_OIPKG noncore/unsupported/oipkg oipkg.pro CONFIG_OPIEALARM core/opiealarm CONFIG_OPIE-CONSOLE noncore/apps/opie-console opie-console.pro CONFIG_OPIEFTP noncore/net/opieftp opieftp.pro CONFIG_OPIEIRC noncore/net/opieirc opieirc.pro CONFIG_OPIE-LOGIN core/opie-login opie-login.pro CONFIG_OPIEMAIL2 noncore/unsupported/mail2 mail.pro CONFIG_OPIEPLAYER2 noncore/multimedia/opieplayer2 opieplayer2.pro CONFIG_OPIEPLAYER core/multimedia/opieplayer opieplayer.pro CONFIG_OPIE-RDESKTOP noncore/net/opierdesktop opierdesktop.pro CONFIG_OPIE-READER noncore/apps/opie-reader opie-reader.pro CONFIG_OPIEREC noncore/multimedia/opierec opierec.pro CONFIG_OPIE-SHEET noncore/apps/opie-sheet opie-sheet.pro CONFIG_OPIE-SH noncore/tools/opie-sh opie-sh.pro CONFIG_OPIETOOTH-APPLET noncore/net/opietooth/applet applet.pro CONFIG_OPIETOOTH-MANAGER noncore/net/opietooth/manager manager.pro CONFIG_OPIE-WRITE noncore/apps/opie-write opie-write.pro CONFIG_OSEARCH core/pim/osearch osearch.pro CONFIG_OXYGEN noncore/apps/oxygen oxygen.pro CONFIG_PACKAGEMANAGER noncore/settings/packagemanager packagemanager.pro CONFIG_PARASHOOT noncore/games/parashoot parashoot.pro CONFIG_PICKBOARD inputmethods/pickboard pickboard.pro CONFIG_POWERCHORD noncore/multimedia/powerchord powerchord.pro CONFIG_PPP noncore/settings/networksettings/ppp ppp.pro CONFIG_QASHMONEY noncore/apps/qashmoney qashmoney.pro CONFIG_QASTEROIDS noncore/games/qasteroids qasteroids.pro CONFIG_QCOP core/apps/qcop qcop.pro CONFIG_QPDF noncore/unsupported/qpdf qpdf.pro CONFIG_QUICKLAUNCHER core/tools/quicklauncher quicklauncher.pro CONFIG_QWS core/qws qws.pro CONFIG_REMOTE noncore/tools/remote remote.pro CONFIG_RESTARTAPPLET2 core/applets/restartapplet2 restartapplet2.pro CONFIG_RESTARTAPPLET core/applets/restartapplet restartapplet.pro CONFIG_ROTATEAPPLET core/applets/rotateapplet rotateapplet.pro CONFIG_ROTATION noncore/settings/rotation rotation.pro CONFIG_RUNAPPLET core/applets/runapplet runapplet.pro CONFIG_SCREENSHOTAPPLET core/applets/screenshotapplet screenshotapplet.pro CONFIG_SECURITY core/settings/security security.pro CONFIG_SFCAVE noncore/games/sfcave sfcave.pro CONFIG_SFCAVE-SDL noncore/games/sfcave-sdl sfcave-sdl.pro CONFIG_SHOWIMG noncore/multimedia/showimg showimg.pro CONFIG_SIMPLE_EXAMPLE examples/simple example.pro CONFIG_SIMPLE_ICON examples/simple-icon example.pro CONFIG_SIMPLE_MAIN examples/simple-main example.pro CONFIG_SIMPLE noncore/tools/calc2/simple simple.pro CONFIG_SIMPLE_PIM examples/simple-pim example.pro CONFIG_SINGLE single single.pro CONFIG_SNAKE noncore/games/snake snake.pro CONFIG_SOLITAIRE noncore/games/solitaire solitaire.pro CONFIG_SOUND noncore/settings/sound sound.pro CONFIG_SSHKEYS noncore/settings/sshkeys sshkeys.pro CONFIG_SUSPENDAPPLET core/applets/suspendapplet suspendapplet.pro CONFIG_SYSINFO noncore/settings/sysinfo sysinfo.pro CONFIG_TABLEVIEWER noncore/apps/tableviewer tableviewer.pro CONFIG_TABMANAGER noncore/settings/tabmanager tabmanager.pro CONFIG_TABOAPP core/apps/taboapp taboapp.pro CONFIG_TEST libsql/test test.pro CONFIG_TEST noncore/apps/opie-console/test test.pro CONFIG_TETRIX noncore/games/tetrix tetrix.pro CONFIG_TEXTEDIT core/apps/textedit textedit.pro CONFIG_THEME noncore/styles/theme theme.pro CONFIG_TICTAC noncore/games/tictac tictac.pro CONFIG_TINYKATE noncore/apps/tinykate tinykate.pro CONFIG_TODAY_ADDRESSBOOK core/pim/today/plugins/addressbook addressbook.pro CONFIG_TODAY core/pim/today today.pro CONFIG_TODAY_DATEBOOK core/pim/today/plugins/datebook datebook.pro CONFIG_TODAY_EXAMPLE examples/todayplugin example.pro CONFIG_TODAY_FORTUNE noncore/todayplugins/fortune fortune.pro CONFIG_TODAY_MAIL core/pim/today/plugins/mail mail.pro CONFIG_TODAY_STOCKTICKERLIB noncore/todayplugins/stockticker/stocktickerlib stocktickerlib.pro CONFIG_TODAY_STOCKTICKER noncore/todayplugins/stockticker/stockticker stockticker.pro CONFIG_TODAY_TODOLIST core/pim/today/plugins/todolist todolist.pro CONFIG_TODAY_WEATHER noncore/todayplugins/weather weather.pro CONFIG_TODO core/pim/todo todo.pro CONFIG_TONLEITER noncore/multimedia/tonleiter tonleiter.pro CONFIG_TRACKER noncore/multimedia/tracker tracker.pro CONFIG_UBROWSER noncore/net/ubrowser ubrowser.pro CONFIG_UNIKEYBOARD inputmethods/unikeyboard unikeyboard.pro CONFIG_USERMANAGER noncore/settings/usermanager usermanager.pro CONFIG_VMEMO core/applets/vmemo vmemo.pro CONFIG_VOLUMEAPPLET core/applets/volumeapplet volumeapplet.pro CONFIG_VTAPPLET core/applets/vtapplet vtapplet.pro CONFIG_WAVPLUGIN core/multimedia/opieplayer/wavplugin wavplugin.pro CONFIG_WELLENREITER noncore/net/wellenreiter wellenreiter.pro CONFIG_WIRELESSAPPLET noncore/applets/wirelessapplet wirelessapplet.pro CONFIG_WLAN noncore/settings/networksettings/wlan wlan.pro CONFIG_WORDGAME noncore/games/wordgame wordgame.pro CONFIG_YATZEE noncore/games/oyatzee oyatzee.pro +CONFIG_ZKBAPPLET noncore/applets/zkbapplet zkbapplet.pro CONFIG_ZLINES noncore/games/zlines zlines.pro CONFIG_ZSAFE noncore/apps/zsafe zsafe.pro CONFIG_ZSAME noncore/games/zsame zsame.pro diff --git a/pics/keyz-cfg.png b/pics/keyz-cfg.png Binary files differnew file mode 100644 index 0000000..2855f5f --- a/dev/null +++ b/pics/keyz-cfg.png diff --git a/pics/zkb-disabled.png b/pics/zkb-disabled.png Binary files differnew file mode 100644 index 0000000..f64a4cd --- a/dev/null +++ b/pics/zkb-disabled.png diff --git a/share/zkb/bg.xml b/share/zkb/bg.xml new file mode 100644 index 0000000..b2c0b06 --- a/dev/null +++ b/share/zkb/bg.xml @@ -0,0 +1,494 @@ +<keymap> + +<include file="common.xml"/> + +<state name="LShift-RShift" parent="common"/> +<state name="LShift-RShift-Caps" parent="common"/> + +<state name="LShift"> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="RShift"> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="1096" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="1097" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="1096" pressed="false"/> + </map> + + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="1097" pressed="false"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="LShift-Caps"> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-Num"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Num"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Caps"> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="1064" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="1065" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="1064" pressed="false"/> + </map> + + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="1065" pressed="false"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-RShift"> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="1064" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="1065" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="1064" pressed="false"/> + </map> + + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="1065" pressed="false"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift"/> + </map> +</state> + +<state name="LShift-RShift-Caps"> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="1096" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="1097" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="1096" pressed="false"/> + </map> + + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="1097" pressed="false"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-Caps"/> + </map> +</state> + +<state name="upper-case"> + <map keycode="Apostrophe" pressed="true"> + <event keycode="QuoteDbl" unicode="1068" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Semicolon" unicode="59" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Colon" unicode="58" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Question" unicode="1070" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="1040" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="1041" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="1062" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="1044" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="1045" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="1060" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="1043" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="1061" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="1048" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="1049" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="1050" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="1051" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="1052" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="1053" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="1054" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="1055" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="1071" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="1056" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="1057" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="1058" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="1059" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="1046" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="1042" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="1063" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="1066" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="1047" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="QuoteDbl" unicode="1068" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Semicolon" unicode="59" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Colon" unicode="58" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Question" unicode="1070" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="1040" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="1041" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="1062" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="1044" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="1045" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="1060" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="1043" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="1061" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="1048" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="1049" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="1050" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="1051" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="1052" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="1053" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="1054" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="1055" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="1071" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="1056" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="1057" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="1058" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="1059" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="1046" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="1042" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="1063" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="1066" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="1047" pressed="false"/> + </map> +</state> + +<state name="lower-case"> + <map keycode="Apostrophe" pressed="true"> + <event keycode="Apostrophe" unicode="1100" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="44" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Period" unicode="46" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Slash" unicode="1102" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="1072" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="1073" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="1094" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="1076" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="1077" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="1092" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="1075" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="1093" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="1080" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="1081" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="1082" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="1083" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="1084" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="1085" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="1086" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="1087" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="1103" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="1088" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="1089" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="1090" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="1091" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="1078" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="1074" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="1095" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="1098" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="1079" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="Apostrophe" unicode="1100" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="44" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Period" unicode="46" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Slash" unicode="1102" modifiers="Shift" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="1072" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="1073" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="1094" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="1076" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="1077" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="1092" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="1075" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="1093" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="1080" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="1081" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="1082" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="1083" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="1084" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="1085" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="1086" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="1087" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="1103" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="1088" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="1089" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="1090" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="1091" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="1078" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="1074" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="1095" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="1098" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="1079" pressed="false"/> + </map> +</state> + +</keymap> diff --git a/share/zkb/bg.xml.num b/share/zkb/bg.xml.num new file mode 100644 index 0000000..91fe872 --- a/dev/null +++ b/share/zkb/bg.xml.num @@ -0,0 +1,506 @@ +<keymap> + +<include file="common.xml"/> + +<state name="LShift-RShift" parent="common"/> +<state name="LShift-RShift-Caps" parent="common"/> + +<state name="LShift"> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="RShift"> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="1096" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="44" pressed="true"> + <event keycode="44" unicode="1097" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="1096" modifiers="0" pressed="false" autorepeat="false"/> + </map> + + <map keycode="44" pressed="false"> + <event keycode="44" unicode="1097" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="LShift-Caps"> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-Num"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Num"/> + </map> + + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Caps"> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="1064" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="44" pressed="true"> + <event keycode="44" unicode="1065" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="1064" modifiers="0" pressed="false" autorepeat="false"/> + </map> + + <map keycode="44" pressed="false"> + <event keycode="44" unicode="1065" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-RShift"> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="1064" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="44" pressed="true"> + <event keycode="44" unicode="1065" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="1064" modifiers="0" pressed="false" autorepeat="false"/> + </map> + + <map keycode="44" pressed="false"> + <event keycode="44" unicode="1065" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="RShift"/> + </map> + + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift"/> + </map> +</state> + +<state name="LShift-RShift-Caps"> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="1096" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="44" pressed="true"> + <event keycode="44" unicode="1097" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="1096" modifiers="0" pressed="false" autorepeat="false"/> + </map> + + <map keycode="44" pressed="false"> + <event keycode="44" unicode="1097" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-Caps"/> + </map> +</state> + +<state name="upper-case"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="32" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="39" unicode="1068" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="44" unicode="44" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="46" unicode="46" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="47" unicode="1070" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="65" unicode="1040" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="66" unicode="1041" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="1062" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="68" unicode="1044" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="1045" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="70" unicode="1060" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="71" unicode="1043" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="72" unicode="1061" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="73" unicode="1048" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="74" unicode="1049" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="75" unicode="1050" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="1051" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="77" unicode="1052" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="78" unicode="1053" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="79" unicode="1054" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="80" unicode="1055" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="81" unicode="1071" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="82" unicode="1056" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="83" unicode="1057" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="84" unicode="1058" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="85" unicode="1059" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="86" unicode="1046" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="87" unicode="1042" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="88" unicode="1063" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="89" unicode="1066" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="1047" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="32" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="39" unicode="1068" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="44" unicode="44" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="46" unicode="46" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="47" pressed="false"> + <event keycode="47" unicode="1070" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="65" unicode="1040" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="66" unicode="1041" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="1062" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="68" unicode="1044" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="69" unicode="1045" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="70" unicode="1060" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="71" unicode="1043" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="72" unicode="1061" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="73" unicode="1048" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="74" unicode="1049" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="75" unicode="1050" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="1051" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="77" unicode="1052" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="78" unicode="1053" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="79" unicode="1054" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="80" unicode="1055" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="81" unicode="1071" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="82" unicode="1056" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="83" unicode="1057" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="84" unicode="1058" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="85" unicode="1059" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="86" unicode="1046" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="87" unicode="1042" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="88" unicode="1063" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="89" unicode="1066" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="1047" modifiers="0" pressed="false" autorepeat="false"/> + </map> +</state> + +<state name="lower-case"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="32" modifiers="8" pressed="true" autorepeat="false"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="34" unicode="1100" modifiers="8" pressed="true" autorepeat="false"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="59" unicode="59" modifiers="8" pressed="true" autorepeat="false"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="58" unicode="58" modifiers="8" pressed="true" autorepeat="false"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="63" unicode="1102" modifiers="8" pressed="true" autorepeat="false"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="65" unicode="1072" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="66" unicode="1073" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="1094" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="68" unicode="1076" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="1077" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="70" unicode="1092" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="71" unicode="1075" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="72" unicode="1093" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="73" unicode="1080" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="74" unicode="1081" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="75" unicode="1082" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="1083" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="77" unicode="1084" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="78" unicode="1085" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="79" unicode="1086" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="80" unicode="1087" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="81" unicode="1103" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="82" unicode="1088" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="83" unicode="1089" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="84" unicode="1090" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="85" unicode="1091" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="86" unicode="1078" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="87" unicode="1074" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="88" unicode="1095" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="89" unicode="1098" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="1079" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="32" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="34" unicode="1100" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="59" unicode="59" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="58" unicode="58" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="47" pressed="false"> + <event keycode="63" unicode="1102" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="65" unicode="1072" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="66" unicode="1073" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="1094" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="68" unicode="1076" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="69" unicode="1077" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="70" unicode="1092" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="71" unicode="1075" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="72" unicode="1093" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="73" unicode="1080" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="74" unicode="1081" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="75" unicode="1082" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="1083" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="77" unicode="1084" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="78" unicode="1085" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="79" unicode="1086" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="80" unicode="1087" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="81" unicode="1103" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="82" unicode="1088" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="83" unicode="1089" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="84" unicode="1090" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="85" unicode="1091" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="86" unicode="1078" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="87" unicode="1074" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="88" unicode="1095" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="89" unicode="1098" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="1079" modifiers="0" pressed="false" autorepeat="false"/> + </map> +</state> + +</keymap> diff --git a/share/zkb/common.xml b/share/zkb/common.xml new file mode 100644 index 0000000..255e677 --- a/dev/null +++ b/share/zkb/common.xml @@ -0,0 +1,2121 @@ +<keymap> + +<!-- State Declarations --> + +<state name="common"/> +<state name="lower-case" parent="common"/> +<state name="upper-case" parent="common"/> +<state name="number" parent="common"/> +<state name="control" parent="common"/> +<state name="alt" parent="common"/> + +<state name="Normal" parent="lower-case"/> +<state name="LShift" parent="upper-case"/> +<state name="RShift" parent="upper-case"/> +<state name="Fn" parent="number"/> +<state name="Num" parent="number"/> +<state name="Caps" parent="upper-case"/> +<state name="iFn"/> +<state name="sFn" parent="number"/> + +<state name="LShift-Fn" parent="control"/> +<state name="RShift-Fn" parent="alt"/> +<state name="LShift-Caps" parent="lower-case"/> +<state name="LShift-Num" parent="number"/> +<state name="RShift-Caps" parent="lower-case"/> +<state name="RShift-Num" parent="number"/> +<state name="Fn-Num" parent="number"/> +<state name="Fn-Caps" parent="number"/> +<state name="Num-Caps" parent="number"/> +<state name="Caps-iFn"/> +<state name="Caps-sFn" parent="sFn"/> + +<state name="LShift-Fn-Caps" parent="control"/> +<state name="LShift-Fn-Num" parent="control"/> +<state name="LShift-Num-Caps" parent="number"/> +<state name="RShift-Fn-Caps" parent="control"/> +<state name="RShift-Fn-Num" parent="control"/> +<state name="RShift-Num-Caps" parent="number"/> +<state name="Fn-Num-Caps" parent="number"/> +<state name="LShift-Fn-Num-Caps" parent="control"/> +<state name="RShift-Fn-Num-Caps" parent="control"/> + +<state name="Normal" default="true"> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Shift" pressed="true"/> + <next-state name="LShift"/> + </map> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" modifiers="Shift" pressed="true"/> + <next-state name="RShift"/> + </map> + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="iFn"/> + </map> +</state> + +<state name="LShift"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn"/> + </map> +</state> + +<state name="RShift"> + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn"/> + </map> +</state> + +<state name="Fn"> + <map keycode="Space" pressed="true"> + <event keycode="Bar" unicode="124" pressed="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="AsciiTilde" unicode="126" pressed="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="ParenRight" unicode="41" pressed="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Less" unicode="60" pressed="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Num"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="3" modifiers="Control" pressed="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="22" modifiers="Control" pressed="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="24" modifiers="Control" pressed="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Bar" unicode="124" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="AsciiTilde" unicode="126" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="ParenRight" unicode="41" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Less" unicode="60" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="3" modifiers="Control" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="22" modifiers="Control" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="24" modifiers="Control" pressed="false"/> + </map> + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn"/> + </map> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn"/> + </map> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="Normal"/> + </map> +</state> + +<state name="Num"> + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="Fn-Num"/> + </map> +</state> + +<state name="Caps"> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Shift" pressed="true"/> + <next-state name="LShift-Caps"/> + </map> + + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="true"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="Caps-iFn"/> + </map> +</state> + +<state name="LShift-Fn"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Fn"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" modifiers="Shift" pressed="false"/> + <next-state name="LShift"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" modifiers="Control|Shift" pressed="true"/> + <next-state name="LShift-Fn-Caps"/> + </map> + + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Fn"> + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="Fn"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" modifiers="Shift" pressed="false"/> + <next-state name="RShift"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn-Caps"/> + </map> + + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" modifiers="Alt" pressed="true"/> + <next-state name="RShift-Fn-Num"/> + </map> +</state> + +<state name="LShift-Caps"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Caps"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Caps"/> + </map> +</state> + +<state name="LShift-Num"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Num"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Caps"> + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="Caps"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn-Caps"/> + </map> +</state> + +<state name="RShift-Num"> + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="Num"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="RShift-Fn-Caps"/> + </map> +</state> + +<state name="Fn-Num"> + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Fn"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Num-Caps"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="false"/> + <next-state name="Num"/> + </map> +</state> + +<state name="Fn-Caps"> + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Num-Caps"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Fn"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + +<state name="Num-Caps"> + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="Fn-Num-Caps"/> + </map> +</state> + +<state name="LShift-Fn-Caps"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" modifiers="Shift" pressed="false"/> + <next-state name="LShift-Caps"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn"/> + </map> +</state> + +<state name="LShift-Fn-Num"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Fn-Num"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="false"/> + <next-state name="LShift-Num"/> + </map> + + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn"/> + </map> +</state> + +<state name="LShift-Num-Caps"> + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num-Caps"/> + </map> + + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Num-Caps"/> + </map> +</state> + +<state name="RShift-Fn-Caps"> + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" modifiers="Shift" pressed="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn"/> + </map> +</state> + +<state name="RShift-Fn-Num"> + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="Fn-Num"/> + </map> + + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="false"/> + <next-state name="RShift-Num"/> + </map> + + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn"/> + </map> +</state> + +<state name="RShift-Num-Caps"> + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="RShift-Fn-Num-Caps"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="true"/> + <next-state name="Num-Caps"/> + </map> +</state> + +<state name="Fn-Num-Caps"> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="false"/> + <next-state name="Num-Caps"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Num"/> + </map> + + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Caps"/> + </map> + + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num-Caps"/> + </map> + + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" modifiers="Alt" pressed="true"/> + <next-state name="RShift-Fn-Num-Caps"/> + </map> +</state> + +<state name="LShift-Fn-Num-Caps"> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="false"/> + <next-state name="LShift-Num-Caps"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num"/> + </map> + + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" modifiers="Control|Shift" pressed="true"/> + <next-state name="LShift-Fn-Caps"/> + </map> + + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Fn-Num-Caps"/> + </map> +</state> + +<state name="RShift-Fn-Num-Caps"> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="false"/> + <next-state name="RShift-Num-Caps"/> + </map> + + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" modifiers="Alt" pressed="true"/> + <next-state name="RShift-Fn-Num"/> + </map> + + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn-Caps"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="Fn-Num-Caps"/> + </map> +</state> + +<state name="common"> + <map keycode="Space" pressed="true"> + <event keycode="Space" unicode="32" pressed="true" autorepeat="true"/> + </map> + <map keycode="Cancel" pressed="true"> + <event keycode="Escape" unicode="27" pressed="true" autorepeat="true"/> + </map> + <map keycode="Tab" pressed="true"> + <event keycode="Tab" unicode="9" pressed="true" autorepeat="true"/> + </map> + <map keycode="Backspace" pressed="true"> + <event keycode="Backspace" unicode="127" pressed="true" autorepeat="true"/> + </map> + <map keycode="Enter" pressed="true"> + <event keycode="Return" unicode="13" pressed="true" autorepeat="true"/> + </map> + <map keycode="Left" pressed="true"> + <event keycode="Left" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Up" pressed="true"> + <event keycode="Up" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Right" pressed="true"> + <event keycode="Right" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Down" pressed="true"> + <event keycode="Down" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Calendar" pressed="true"> + <event keycode="F9" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Addressbook" pressed="true"> + <event keycode="F10" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Menu" pressed="true"> + <event keycode="F11" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Home" pressed="true"> + <event keycode="F12" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Mail" pressed="true"> + <event keycode="F13" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Middle" pressed="true"> + <event keycode="F30" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="OK" pressed="true"> + <event keycode="F33" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Off" pressed="true"> + <event keycode="F34" unicode="-1" pressed="true"/> + </map> + <map keycode="Light" pressed="true"> + <event keycode="F35" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Space" unicode="32" pressed="false" autorepeat="true"/> + </map> + <map keycode="Cancel" pressed="false"> + <event keycode="Escape" unicode="27" pressed="false"/> + </map> + <map keycode="Tab" pressed="false"> + <event keycode="Tab" unicode="9" pressed="false"/> + </map> + <map keycode="Backspace" pressed="false"> + <event keycode="Backspace" unicode="127" pressed="false"/> + </map> + <map keycode="Enter" pressed="false"> + <event keycode="Return" unicode="13" pressed="false"/> + </map> + <map keycode="Left" pressed="false"> + <event keycode="Left" unicode="-1" pressed="false"/> + </map> + <map keycode="Up" pressed="false"> + <event keycode="Up" unicode="-1" pressed="false"/> + </map> + <map keycode="Right" pressed="false"> + <event keycode="Right" unicode="-1" pressed="false"/> + </map> + <map keycode="Down" pressed="false"> + <event keycode="Down" unicode="-1" pressed="false"/> + </map> + <map keycode="Calendar" pressed="false"> + <event keycode="F9" unicode="-1" pressed="false"/> + </map> + <map keycode="Addressbook" pressed="false"> + <event keycode="F10" unicode="-1" pressed="false"/> + </map> + <map keycode="Menu" pressed="false"> + <event keycode="F11" unicode="-1" pressed="false"/> + </map> + <map keycode="Home" pressed="false"> + <event keycode="F12" unicode="-1" pressed="false"/> + </map> + <map keycode="Mail" pressed="false"> + <event keycode="F13" unicode="-1" pressed="false"/> + </map> + <map keycode="Middle" pressed="false"> + <event keycode="F30" unicode="-1" pressed="false"/> + </map> + <map keycode="OK" pressed="false"> + <event keycode="F33" unicode="-1" pressed="false"/> + </map> + <map keycode="Off" pressed="false"> + <event keycode="F34" unicode="-1" pressed="false"/> + </map> + <map keycode="Light" pressed="false"> + <event keycode="F35" unicode="-1" pressed="false"/> + </map> +</state> + +<state name="number"> + <map keycode="Space" pressed="true"> + <event keycode="Space" unicode="32" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="Apostrophe" unicode="39" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="44" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Period" unicode="46" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="Exclam" unicode="33" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="Minus" unicode="45" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="NumberSign" unicode="35" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="3" unicode="51" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="Dollar" unicode="36" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="Percent" unicode="37" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="Underscore" unicode="95" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="8" unicode="56" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="Ampersand" unicode="38" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="Asterisk" unicode="42" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="ParenLeft" unicode="40" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="Equal" unicode="61" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="Plus" unicode="43" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="9" unicode="57" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="0" unicode="48" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="1" unicode="49" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="4" unicode="52" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="At" unicode="64" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="5" unicode="53" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="7" unicode="55" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="2" unicode="50" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="6" unicode="54" pressed="true" autorepeat="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Space" unicode="32" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="Apostrophe" unicode="39" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="44" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Period" unicode="46" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="Exclam" unicode="33" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="Minus" unicode="45" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="NumberSign" unicode="35" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="3" unicode="51" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="Dollar" unicode="36" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="Percent" unicode="37" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="Underscore" unicode="95" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="8" unicode="56" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="Ampersand" unicode="38" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="Asterisk" unicode="42" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="ParenLeft" unicode="40" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="Equal" unicode="61" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="Plus" unicode="43" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="9" unicode="57" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="0" unicode="48" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="1" unicode="49" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="4" unicode="52" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="At" unicode="64" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="5" unicode="53" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="7" unicode="55" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="2" unicode="50" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="6" unicode="54" pressed="false"/> + </map> +</state> + +<state name="control"> + <map keycode="Space" pressed="true"> + <event keycode="QuoteLeft" unicode="96" modifiers="Control" pressed="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="AsciiCircum" unicode="94" modifiers="Control" pressed="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="BraceLeft" unicode="123" modifiers="Control" pressed="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="BracketRight" unicode="93" modifiers="Control" pressed="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="1" modifiers="Control" pressed="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="2" modifiers="Control" pressed="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="3" modifiers="Control" pressed="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="4" modifiers="Control" pressed="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="5" modifiers="Control" pressed="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="6" modifiers="Control" pressed="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="7" modifiers="Control" pressed="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="8" modifiers="Control" pressed="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="9" modifiers="Control" pressed="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="10" modifiers="Control" pressed="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="11" modifiers="Control" pressed="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="12" modifiers="Control" pressed="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="13" modifiers="Control" pressed="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="14" modifiers="Control" pressed="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="15" modifiers="Control" pressed="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="16" modifiers="Control" pressed="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="17" modifiers="Control" pressed="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="18" modifiers="Control" pressed="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="19" modifiers="Control" pressed="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="20" modifiers="Control" pressed="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="21" modifiers="Control" pressed="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="22" modifiers="Control" pressed="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="23" modifiers="Control" pressed="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="24" modifiers="Control" pressed="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="25" modifiers="Control" pressed="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="26" modifiers="Control" pressed="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="QuoteLeft" unicode="96" modifiers="Control" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="AsciiCircum" unicode="94" modifiers="Control" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="BraceLeft" unicode="123" modifiers="Control" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="BracketRight" unicode="93" modifiers="Control" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="1" modifiers="Control" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="2" modifiers="Control" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="3" modifiers="Control" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="4" modifiers="Control" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="5" modifiers="Control" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="6" modifiers="Control" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="7" modifiers="Control" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="8" modifiers="Control" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="9" modifiers="Control" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="10" modifiers="Control" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="11" modifiers="Control" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="12" modifiers="Control" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="13" modifiers="Control" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="14" modifiers="Control" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="15" modifiers="Control" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="16" modifiers="Control" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="17" modifiers="Control" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="18" modifiers="Control" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="19" modifiers="Control" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="20" modifiers="Control" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="21" modifiers="Control" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="22" modifiers="Control" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="23" modifiers="Control" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="24" modifiers="Control" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="25" modifiers="Control" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="26" modifiers="Control" pressed="false"/> + </map> +</state> + +<state name="alt"> + <map keycode="Space" pressed="true"> + <event keycode="Space" unicode="96" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="AsciiCircum" unicode="94" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="BraceLeft" unicode="123" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="BracketRight" unicode="93" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="Exclam" unicode="65" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="Minus" unicode="66" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="NumberSign" unicode="67" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="3" unicode="68" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="Dollar" unicode="69" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="Percent" unicode="70" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="Underscore" unicode="71" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="8" unicode="72" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="8" unicode="73" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="Ampersand" unicode="74" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="Asterisk" unicode="75" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="ParenLeft" unicode="76" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="Equal" unicode="77" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="Plus" unicode="78" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="9" unicode="79" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="0" unicode="80" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="1" unicode="81" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="4" unicode="82" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="At" unicode="83" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="5" unicode="84" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="7" unicode="85" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="2" unicode="86" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="6" unicode="87" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="Bar" unicode="88" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="AsciiTilde" unicode="89" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="90" modifiers="Alt|Shift" pressed="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Space" unicode="96" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="AsciiCircum" unicode="94" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="BraceLeft" unicode="123" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="BracketRight" unicode="93" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="Exclam" unicode="65" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="Minus" unicode="66" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="NumberSign" unicode="67" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="3" unicode="68" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="Dollar" unicode="69" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="Percent" unicode="70" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="Underscore" unicode="71" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="8" unicode="72" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="8" unicode="73" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="Ampersand" unicode="74" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="Asterisk" unicode="75" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="ParenLeft" unicode="76" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="Equal" unicode="77" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="Plus" unicode="78" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="9" unicode="79" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="0" unicode="80" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="1" unicode="81" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="4" unicode="82" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="At" unicode="83" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="5" unicode="84" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="7" unicode="85" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="2" unicode="86" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="6" unicode="87" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="Bar" unicode="88" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="AsciiTilde" unicode="89" modifiers="Alt|Shift" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="90" modifiers="Alt|Shift" pressed="false"/> + </map> +</state> + +<state name="iFn"> + <map keycode="Space" pressed="true"> + <event keycode="Bar" unicode="124" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="AsciiTilde" unicode="126" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="ParenRight" unicode="41" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Less" unicode="60" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Num"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="Exclam" unicode="33" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="Minus" unicode="45" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="3" modifiers="Control" pressed="true"/> + <next-state name="Fn"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="NumberSign" unicode="35" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="3" unicode="51" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="Dollar" unicode="36" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="Percent" unicode="37" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="Underscore" unicode="95" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="8" unicode="56" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="Ampersand" unicode="38" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="Asterisk" unicode="42" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="ParenLeft" unicode="40" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="Equal" unicode="61" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="Plus" unicode="43" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="9" unicode="57" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="0" unicode="48" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="1" unicode="49" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="4" unicode="52" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="At" unicode="64" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="5" unicode="53" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="7" unicode="55" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="22" modifiers="Control" pressed="true"/> + <next-state name="Fn"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="2" unicode="50" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="24" modifiers="Control" pressed="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="6" unicode="54" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn"/> + </map> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Bar" unicode="124" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="AsciiTilde" unicode="126" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="ParenRight" unicode="41" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Less" unicode="60" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="Exclam" unicode="33" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="Minus" unicode="45" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="3" modifiers="Control" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="NumberSign" unicode="35" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="3" unicode="51" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="Dollar" unicode="36" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="Percent" unicode="37" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="Underscore" unicode="95" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="8" unicode="56" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="Ampersand" unicode="38" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="Asterisk" unicode="42" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="ParenLeft" unicode="40" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="Equal" unicode="61" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="Plus" unicode="43" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="9" unicode="57" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="0" unicode="48" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="1" unicode="49" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="4" unicode="52" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="At" unicode="64" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="5" unicode="53" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="7" unicode="55" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="22" modifiers="Control" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="2" unicode="50" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="24" modifiers="Control" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="6" unicode="54" pressed="false"/> + <next-state name="Fn"/> + </map> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="sFn"/> + </map> +</state> + +<state name="sFn"> + <map keycode="Space" pressed="true"> + <event keycode="Bar" unicode="124" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="AsciiTilde" unicode="126" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="ParenRight" unicode="41" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Less" unicode="60" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Num"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="Exclam" unicode="33" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="Minus" unicode="45" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="3" modifiers="Control" pressed="true"/> + <next-state name="Normal"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="NumberSign" unicode="35" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="3" unicode="51" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="Dollar" unicode="36" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="Percent" unicode="37" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="Underscore" unicode="95" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="8" unicode="56" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="Ampersand" unicode="38" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="Asterisk" unicode="42" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="ParenLeft" unicode="40" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="Equal" unicode="61" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="Plus" unicode="43" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="9" unicode="57" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="0" unicode="48" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="1" unicode="49" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="4" unicode="52" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="At" unicode="64" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="5" unicode="53" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="7" unicode="55" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="22" modifiers="Control" pressed="true"/> + <next-state name="Normal"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="2" unicode="50" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="24" modifiers="Control" pressed="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="6" unicode="54" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift"/> + </map> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Bar" unicode="124" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="AsciiTilde" unicode="126" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="ParenRight" unicode="41" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Less" unicode="60" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="Exclam" unicode="33" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="Minus" unicode="45" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="3" modifiers="Control" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="NumberSign" unicode="35" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="3" unicode="51" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="Dollar" unicode="36" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="Percent" unicode="37" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="Underscore" unicode="95" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="8" unicode="56" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="Ampersand" unicode="38" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="Asterisk" unicode="42" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="ParenLeft" unicode="40" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="Equal" unicode="61" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="Plus" unicode="43" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="9" unicode="57" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="0" unicode="48" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="1" unicode="49" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="4" unicode="52" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="At" unicode="64" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="5" unicode="53" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="7" unicode="55" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="22" modifiers="Control" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="2" unicode="50" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="24" modifiers="Control" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="6" unicode="54" pressed="false"/> + <next-state name="Normal"/> + </map> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="iFn"/> + </map> +</state> + +<state name="Caps-iFn"> + <map keycode="Space" pressed="true"> + <event keycode="Bar" unicode="124" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="AsciiTilde" unicode="126" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="ParenRight" unicode="41" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Less" unicode="60" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Fn-Num"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="Exclam" unicode="33" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="Minus" unicode="45" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="3" modifiers="Control" pressed="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="NumberSign" unicode="35" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="3" unicode="51" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="Dollar" unicode="36" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="Percent" unicode="37" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="Underscore" unicode="95" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="8" unicode="56" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="Ampersand" unicode="38" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="Asterisk" unicode="42" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="ParenLeft" unicode="40" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="Equal" unicode="61" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="Plus" unicode="43" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="9" unicode="57" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="0" unicode="48" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="1" unicode="49" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="4" unicode="52" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="At" unicode="64" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="5" unicode="53" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="7" unicode="55" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="22" modifiers="Control" pressed="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="2" unicode="50" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="24" modifiers="Control" pressed="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="6" unicode="54" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Fn"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Caps"/> + </map> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Fn-Caps"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Bar" unicode="124" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="AsciiTilde" unicode="126" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="ParenRight" unicode="41" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Less" unicode="60" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="Exclam" unicode="33" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="Minus" unicode="45" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="3" modifiers="Control" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="NumberSign" unicode="35" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="3" unicode="51" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="Dollar" unicode="36" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="Percent" unicode="37" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="Underscore" unicode="95" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="8" unicode="56" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="Ampersand" unicode="38" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="Asterisk" unicode="42" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="ParenLeft" unicode="40" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="Equal" unicode="61" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="Plus" unicode="43" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="9" unicode="57" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="0" unicode="48" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="1" unicode="49" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="4" unicode="52" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="At" unicode="64" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="5" unicode="53" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="7" unicode="55" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="22" modifiers="Control" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="2" unicode="50" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="24" modifiers="Control" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="6" unicode="54" pressed="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="Caps-sFn"/> + </map> +</state> + +<state name="Caps-sFn"> + <map keycode="Space" pressed="true"> + <event keycode="Bar" unicode="124" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="AsciiTilde" unicode="126" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="ParenRight" unicode="41" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Less" unicode="60" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="NumLock" unicode="-1" pressed="true"/> + <next-state name="Num"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="Exclam" unicode="33" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="Minus" unicode="45" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="3" modifiers="Control" pressed="true"/> + <next-state name="Caps"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="NumberSign" unicode="35" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="3" unicode="51" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="Dollar" unicode="36" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="Percent" unicode="37" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="Underscore" unicode="95" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="8" unicode="56" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="Ampersand" unicode="38" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="Asterisk" unicode="42" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="ParenLeft" unicode="40" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="Equal" unicode="61" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="Plus" unicode="43" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="9" unicode="57" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="0" unicode="48" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="1" unicode="49" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="4" unicode="52" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="At" unicode="64" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="5" unicode="53" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="7" unicode="55" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="22" modifiers="Control" pressed="true"/> + <next-state name="Caps"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="2" unicode="50" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="24" modifiers="Control" pressed="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="6" unicode="54" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="Tab" pressed="true"> + <event keycode="CapsLock" unicode="-1" pressed="true"/> + <next-state name="Normal"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Caps"/> + </map> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" modifiers="Alt|Shift" pressed="true"/> + <next-state name="RShift-Caps"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Bar" unicode="124" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="AsciiTilde" unicode="126" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="ParenRight" unicode="41" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Less" unicode="60" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="Exclam" unicode="33" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="Minus" unicode="45" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="3" modifiers="Control" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="NumberSign" unicode="35" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="3" unicode="51" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="Dollar" unicode="36" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="Percent" unicode="37" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="Underscore" unicode="95" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="8" unicode="56" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="Ampersand" unicode="38" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="Asterisk" unicode="42" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="ParenLeft" unicode="40" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="Equal" unicode="61" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="Plus" unicode="43" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="9" unicode="57" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="0" unicode="48" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="1" unicode="49" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="4" unicode="52" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="At" unicode="64" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="5" unicode="53" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="7" unicode="55" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="22" modifiers="Control" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="2" unicode="50" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="24" modifiers="Control" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="6" unicode="54" pressed="false"/> + <next-state name="Caps"/> + </map> + <map keycode="Fn" pressed="false"> + <event keycode="F22" unicode="-1" pressed="true"/> + <next-state name="Caps-iFn"/> + </map> +</state> + +</keymap> diff --git a/share/zkb/common.xml.num b/share/zkb/common.xml.num new file mode 100644 index 0000000..ff4c450 --- a/dev/null +++ b/share/zkb/common.xml.num @@ -0,0 +1,2115 @@ +<keymap> + +<!-- State Declarations --> + +<state name="common"/> +<state name="lower-case" parent="common"/> +<state name="upper-case" parent="common"/> +<state name="number" parent="common"/> +<state name="control" parent="common"/> +<state name="alt" parent="common"/> + +<state name="Normal" parent="lower-case"/> +<state name="LShift" parent="upper-case"/> +<state name="RShift" parent="upper-case"/> +<state name="Fn" parent="number"/> +<state name="Num" parent="number"/> +<state name="Caps" parent="upper-case"/> +<state name="iFn"/> +<state name="sFn" parent="number"/> + +<state name="LShift-Fn" parent="control"/> +<state name="RShift-Fn" parent="alt"/> +<state name="LShift-Caps" parent="lower-case"/> +<state name="LShift-Num" parent="number"/> +<state name="RShift-Caps" parent="lower-case"/> +<state name="RShift-Num" parent="number"/> +<state name="Fn-Num" parent="number"/> +<state name="Fn-Caps" parent="number"/> +<state name="Num-Caps" parent="number"/> +<state name="Caps-iFn"/> +<state name="Caps-sFn" parent="sFn"/> + +<state name="LShift-Fn-Caps" parent="control"/> +<state name="LShift-Fn-Num" parent="control"/> +<state name="LShift-Num-Caps" parent="number"/> +<state name="RShift-Fn-Caps" parent="control"/> +<state name="RShift-Fn-Num" parent="control"/> +<state name="RShift-Num-Caps" parent="number"/> +<state name="Fn-Num-Caps" parent="number"/> +<state name="LShift-Fn-Num-Caps" parent="control"/> +<state name="RShift-Fn-Num-Caps" parent="control"/> + +<state name="Normal" default="true"> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="8" pressed="true" autorepeat="false"/> + <next-state name="LShift"/> + </map> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="8" pressed="true" autorepeat="false"/> + <next-state name="RShift"/> + </map> + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="iFn"/> + </map> +</state> + +<state name="LShift"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn"/> + </map> +</state> + +<state name="RShift"> + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn"/> + </map> +</state> + +<state name="Fn"> + <map keycode="32" pressed="true"> + <event keycode="124" unicode="124" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="126" unicode="126" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="41" unicode="41" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="60" unicode="60" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="3" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="22" unicode="22" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="24" unicode="24" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="124" unicode="124" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="126" unicode="126" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="41" unicode="41" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="60" unicode="60" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="3" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="22" unicode="22" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="24" unicode="24" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn"/> + </map> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn"/> + </map> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Normal"/> + </map> +</state> + +<state name="Num"> + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num"/> + </map> +</state> + +<state name="Caps"> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="8" pressed="true" autorepeat="false"/> + <next-state name="LShift-Caps"/> + </map> + + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Caps-iFn"/> + </map> +</state> + +<state name="LShift-Fn"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="8" pressed="false" autorepeat="false"/> + <next-state name="LShift"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="24" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Caps"/> + </map> + + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Fn"> + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="8" pressed="false" autorepeat="false"/> + <next-state name="RShift"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Caps"/> + </map> + + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="32" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Num"/> + </map> +</state> + +<state name="LShift-Caps"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Caps"/> + </map> +</state> + +<state name="LShift-Num"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Num"/> + </map> + + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Caps"> + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Caps"/> + </map> +</state> + +<state name="RShift-Num"> + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Num"/> + </map> + + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Caps"/> + </map> +</state> + +<state name="Fn-Num"> + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num-Caps"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Num"/> + </map> +</state> + +<state name="Fn-Caps"> + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num-Caps"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> +</state> + +<state name="Num-Caps"> + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num-Caps"/> + </map> +</state> + +<state name="LShift-Fn-Caps"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="8" pressed="false" autorepeat="false"/> + <next-state name="LShift-Caps"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn"/> + </map> +</state> + +<state name="LShift-Fn-Num"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Num"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-Num"/> + </map> + + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn"/> + </map> +</state> + +<state name="LShift-Num-Caps"> + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Num-Caps"/> + </map> + + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Num-Caps"/> + </map> +</state> + +<state name="RShift-Fn-Caps"> + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="8" pressed="false" autorepeat="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn"/> + </map> +</state> + +<state name="RShift-Fn-Num"> + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Num"/> + </map> + + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="RShift-Num"/> + </map> + + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn"/> + </map> +</state> + +<state name="RShift-Num-Caps"> + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Num-Caps"/> + </map> + + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Num-Caps"/> + </map> +</state> + +<state name="Fn-Num-Caps"> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Num-Caps"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num"/> + </map> + + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Num-Caps"/> + </map> + + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="32" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Num-Caps"/> + </map> +</state> + +<state name="LShift-Fn-Num-Caps"> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-Num-Caps"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Num"/> + </map> + + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="24" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Caps"/> + </map> + + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Num-Caps"/> + </map> +</state> + +<state name="RShift-Fn-Num-Caps"> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="RShift-Num-Caps"/> + </map> + + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="32" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Num"/> + </map> + + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Caps"/> + </map> + + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Num-Caps"/> + </map> +</state> + +<state name="common"> + <map keycode="4096" pressed="true"> + <event keycode="4096" unicode="27" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4097" pressed="true"> + <event keycode="4097" unicode="9" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4099" pressed="true"> + <event keycode="4099" unicode="127" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4100" pressed="true"> + <event keycode="4100" unicode="13" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4114" pressed="true"> + <event keycode="4114" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4115" pressed="true"> + <event keycode="4115" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4116" pressed="true"> + <event keycode="4116" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4117" pressed="true"> + <event keycode="4117" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4152" pressed="true"> + <event keycode="4152" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4153" pressed="true"> + <event keycode="4153" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4154" pressed="true"> + <event keycode="4154" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4155" pressed="true"> + <event keycode="4155" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4156" pressed="true"> + <event keycode="4156" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4173" pressed="true"> + <event keycode="4173" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4176" pressed="true"> + <event keycode="4176" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4177" pressed="true"> + <event keycode="4177" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + </map> + <map keycode="4178" pressed="true"> + <event keycode="4178" unicode="-1" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="4096" pressed="false"> + <event keycode="4096" unicode="27" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4097" pressed="false"> + <event keycode="4097" unicode="9" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4099" pressed="false"> + <event keycode="4099" unicode="127" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4100" pressed="false"> + <event keycode="4100" unicode="13" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4114" pressed="false"> + <event keycode="4114" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4115" pressed="false"> + <event keycode="4115" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4116" pressed="false"> + <event keycode="4116" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4117" pressed="false"> + <event keycode="4117" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4152" pressed="false"> + <event keycode="4152" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4153" pressed="false"> + <event keycode="4153" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4154" pressed="false"> + <event keycode="4154" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4155" pressed="false"> + <event keycode="4155" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4156" pressed="false"> + <event keycode="4156" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4173" pressed="false"> + <event keycode="4173" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4176" pressed="false"> + <event keycode="4176" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4177" pressed="false"> + <event keycode="4177" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="4178" pressed="false"> + <event keycode="4178" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + </map> +</state> + +<state name="number"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="32" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="39" unicode="39" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="44" unicode="44" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="46" unicode="46" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="33" unicode="33" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="45" unicode="45" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="35" unicode="35" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="51" unicode="51" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="36" unicode="36" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="37" unicode="37" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="95" unicode="95" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="56" unicode="56" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="38" unicode="38" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="42" unicode="42" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="40" unicode="40" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="61" unicode="61" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="43" unicode="43" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="57" unicode="57" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="48" unicode="48" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="49" unicode="49" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="52" unicode="52" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="64" unicode="64" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="53" unicode="53" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="55" unicode="55" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="50" unicode="50" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="54" unicode="54" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="32" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="39" unicode="39" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="44" unicode="44" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="46" unicode="46" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="33" unicode="33" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="45" unicode="45" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="35" unicode="35" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="51" unicode="51" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="36" unicode="36" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="37" unicode="37" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="95" unicode="95" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="56" unicode="56" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="38" unicode="38" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="42" unicode="42" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="40" unicode="40" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="61" unicode="61" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="43" unicode="43" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="57" unicode="57" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="48" unicode="48" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="49" unicode="49" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="52" unicode="52" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="64" unicode="64" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="53" unicode="53" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="55" unicode="55" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="50" unicode="50" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="54" unicode="54" modifiers="0" pressed="false" autorepeat="false"/> + </map> +</state> + +<state name="control"> + <map keycode="32" pressed="true"> + <event keycode="96" unicode="96" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="94" unicode="94" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="123" unicode="123" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="93" unicode="93" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="65" unicode="1" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="66" unicode="2" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="3" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="68" unicode="4" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="5" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="70" unicode="6" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="71" unicode="7" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="72" unicode="8" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="73" unicode="9" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="74" unicode="10" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="75" unicode="11" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="12" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="77" unicode="13" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="78" unicode="14" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="79" unicode="15" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="80" unicode="16" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="81" unicode="17" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="82" unicode="18" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="83" unicode="19" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="84" unicode="20" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="85" unicode="21" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="86" unicode="22" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="87" unicode="23" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="88" unicode="24" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="89" unicode="25" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="26" modifiers="16" pressed="true" autorepeat="false"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="96" unicode="96" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="94" unicode="94" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="123" unicode="123" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="93" unicode="93" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="65" unicode="1" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="66" unicode="2" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="3" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="68" unicode="4" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="69" unicode="5" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="70" unicode="6" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="71" unicode="7" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="72" unicode="8" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="73" unicode="9" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="74" unicode="10" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="75" unicode="11" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="12" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="77" unicode="13" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="78" unicode="14" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="79" unicode="15" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="80" unicode="16" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="81" unicode="17" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="82" unicode="18" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="83" unicode="19" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="84" unicode="20" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="85" unicode="21" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="86" unicode="22" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="87" unicode="23" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="88" unicode="24" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="89" unicode="25" modifiers="16" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="26" modifiers="16" pressed="false" autorepeat="false"/> + </map> +</state> + +<state name="alt"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="96" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="94" unicode="94" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="123" unicode="123" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="93" unicode="93" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="33" unicode="65" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="45" unicode="66" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="35" unicode="67" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="51" unicode="68" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="36" unicode="69" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="37" unicode="70" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="95" unicode="71" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="56" unicode="72" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="56" unicode="73" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="38" unicode="74" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="42" unicode="75" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="40" unicode="76" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="61" unicode="77" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="43" unicode="78" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="57" unicode="79" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="48" unicode="80" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="49" unicode="81" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="52" unicode="82" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="64" unicode="83" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="53" unicode="84" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="55" unicode="85" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="50" unicode="86" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="54" unicode="87" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="124" unicode="88" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="126" unicode="89" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="90" modifiers="40" pressed="true" autorepeat="false"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="96" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="94" unicode="94" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="123" unicode="123" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="93" unicode="93" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="33" unicode="65" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="45" unicode="66" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="35" unicode="67" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="51" unicode="68" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="36" unicode="69" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="37" unicode="70" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="95" unicode="71" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="56" unicode="72" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="56" unicode="73" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="38" unicode="74" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="42" unicode="75" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="40" unicode="76" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="61" unicode="77" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="43" unicode="78" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="57" unicode="79" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="48" unicode="80" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="49" unicode="81" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="52" unicode="82" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="64" unicode="83" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="53" unicode="84" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="55" unicode="85" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="50" unicode="86" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="54" unicode="87" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="124" unicode="88" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="126" unicode="89" modifiers="40" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="90" modifiers="40" pressed="false" autorepeat="false"/> + </map> +</state> + +<state name="iFn"> + <map keycode="32" pressed="true"> + <event keycode="124" unicode="124" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="126" unicode="126" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="41" unicode="41" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="60" unicode="60" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="33" unicode="33" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="45" unicode="45" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="3" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="35" unicode="35" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="51" unicode="51" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="36" unicode="36" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="37" unicode="37" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="95" unicode="95" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="56" unicode="56" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="38" unicode="38" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="42" unicode="42" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="40" unicode="40" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="61" unicode="61" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="43" unicode="43" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="57" unicode="57" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="48" unicode="48" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="49" unicode="49" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="52" unicode="52" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="64" unicode="64" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="53" unicode="53" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="55" unicode="55" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="22" unicode="22" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="50" unicode="50" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="24" unicode="24" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="54" unicode="54" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn"/> + </map> + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn"/> + </map> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="124" unicode="124" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="126" unicode="126" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="41" unicode="41" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="60" unicode="60" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="33" unicode="33" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="45" unicode="45" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="3" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="35" unicode="35" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="51" unicode="51" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="36" unicode="36" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="37" unicode="37" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="95" unicode="95" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="56" unicode="56" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="38" unicode="38" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="42" unicode="42" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="40" unicode="40" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="61" unicode="61" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="43" unicode="43" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="57" unicode="57" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="48" unicode="48" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="49" unicode="49" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="52" unicode="52" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="64" unicode="64" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="53" unicode="53" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="55" unicode="55" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="22" unicode="22" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="50" unicode="50" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="24" unicode="24" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="54" unicode="54" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="sFn"/> + </map> +</state> + +<state name="sFn"> + <map keycode="32" pressed="true"> + <event keycode="124" unicode="124" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="126" unicode="126" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="41" unicode="41" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="60" unicode="60" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Num"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="33" unicode="33" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="45" unicode="45" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="3" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="35" unicode="35" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="51" unicode="51" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="36" unicode="36" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="37" unicode="37" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="95" unicode="95" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="56" unicode="56" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="38" unicode="38" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="42" unicode="42" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="40" unicode="40" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="61" unicode="61" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="43" unicode="43" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="57" unicode="57" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="48" unicode="48" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="49" unicode="49" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="52" unicode="52" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="64" unicode="64" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="53" unicode="53" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="55" unicode="55" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="22" unicode="22" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="50" unicode="50" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="24" unicode="24" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="54" unicode="54" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Normal"/> + </map> + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift"/> + </map> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="124" unicode="124" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="126" unicode="126" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="41" unicode="41" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="60" unicode="60" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="33" unicode="33" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="45" unicode="45" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="3" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="35" unicode="35" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="51" unicode="51" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="36" unicode="36" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="37" unicode="37" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="95" unicode="95" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="56" unicode="56" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="38" unicode="38" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="42" unicode="42" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="40" unicode="40" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="61" unicode="61" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="43" unicode="43" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="57" unicode="57" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="48" unicode="48" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="49" unicode="49" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="52" unicode="52" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="64" unicode="64" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="53" unicode="53" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="55" unicode="55" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="22" unicode="22" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="50" unicode="50" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="24" unicode="24" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="54" unicode="54" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="iFn"/> + </map> +</state> + +<state name="Caps-iFn"> + <map keycode="32" pressed="true"> + <event keycode="124" unicode="124" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="126" unicode="126" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="41" unicode="41" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="60" unicode="60" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn-Num"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="33" unicode="33" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="45" unicode="45" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="3" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="35" unicode="35" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="51" unicode="51" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="36" unicode="36" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="37" unicode="37" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="95" unicode="95" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="56" unicode="56" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="38" unicode="38" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="42" unicode="42" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="40" unicode="40" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="61" unicode="61" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="43" unicode="43" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="57" unicode="57" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="48" unicode="48" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="49" unicode="49" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="52" unicode="52" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="64" unicode="64" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="53" unicode="53" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="55" unicode="55" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="22" unicode="22" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="50" unicode="50" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="24" unicode="24" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="54" unicode="54" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Fn"/> + </map> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Caps"/> + </map> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Fn-Caps"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="124" unicode="124" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="126" unicode="126" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="41" unicode="41" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="60" unicode="60" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="33" unicode="33" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="45" unicode="45" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="3" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="35" unicode="35" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="51" unicode="51" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="36" unicode="36" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="37" unicode="37" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="95" unicode="95" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="56" unicode="56" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="38" unicode="38" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="42" unicode="42" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="40" unicode="40" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="61" unicode="61" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="43" unicode="43" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="57" unicode="57" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="48" unicode="48" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="49" unicode="49" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="52" unicode="52" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="64" unicode="64" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="53" unicode="53" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="55" unicode="55" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="22" unicode="22" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="50" unicode="50" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="24" unicode="24" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="54" unicode="54" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Fn-Caps"/> + </map> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Caps-sFn"/> + </map> +</state> + +<state name="Caps-sFn"> + <map keycode="32" pressed="true"> + <event keycode="124" unicode="124" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="126" unicode="126" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="41" unicode="41" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="60" unicode="60" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="4133" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Num"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="33" unicode="33" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="45" unicode="45" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="3" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="35" unicode="35" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="51" unicode="51" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="36" unicode="36" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="37" unicode="37" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="95" unicode="95" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="56" unicode="56" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="38" unicode="38" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="42" unicode="42" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="40" unicode="40" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="61" unicode="61" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="43" unicode="43" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="57" unicode="57" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="48" unicode="48" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="49" unicode="49" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="52" unicode="52" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="64" unicode="64" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="53" unicode="53" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="55" unicode="55" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="22" unicode="22" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="50" unicode="50" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="24" unicode="24" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="54" unicode="54" modifiers="0" pressed="true" autorepeat="true"/> + <next-state name="Caps"/> + </map> + <map keycode="4097" pressed="true"> + <event keycode="4132" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Normal"/> + </map> + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Caps"/> + </map> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="40" pressed="true" autorepeat="false"/> + <next-state name="RShift-Caps"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="124" unicode="124" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="126" unicode="126" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="41" unicode="41" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="60" unicode="60" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="33" unicode="33" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="45" unicode="45" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="3" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="35" unicode="35" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="51" unicode="51" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="36" unicode="36" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="37" unicode="37" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="95" unicode="95" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="56" unicode="56" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="38" unicode="38" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="42" unicode="42" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="40" unicode="40" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="61" unicode="61" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="43" unicode="43" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="57" unicode="57" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="48" unicode="48" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="49" unicode="49" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="52" unicode="52" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="64" unicode="64" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="53" unicode="53" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="55" unicode="55" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="22" unicode="22" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="50" unicode="50" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="24" unicode="24" modifiers="16" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="54" unicode="54" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Caps"/> + </map> + <map keycode="4165" pressed="false"> + <event keycode="4165" unicode="-1" modifiers="0" pressed="true" autorepeat="false"/> + <next-state name="Caps-iFn"/> + </map> +</state> + +</keymap> diff --git a/share/zkb/de.xml b/share/zkb/de.xml new file mode 100644 index 0000000..679ebc3 --- a/dev/null +++ b/share/zkb/de.xml @@ -0,0 +1,617 @@ +<keymap> + +<include file="common.xml"/> + +<state name="LShift-RShift" parent="common"/> +<state name="LShift-RShift-Caps" parent="common"/> + +<state name="LShift"> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="RShift"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="8364" pressed="true" autorepeat="true"/> + </map> + + <map keycode="O" pressed="true"> + <event keycode="O" unicode="223" pressed="true" autorepeat="true"/> + </map> + + <map keycode="L" pressed="true"> + <event keycode="L" unicode="252" pressed="true" autorepeat="true"/> + </map> + + <map keycode="M" pressed="true"> + <event keycode="M" unicode="246" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="228" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="8364" pressed="false"/> + </map> + + <map keycode="O" pressed="false"> + <event keycode="O" unicode="223" pressed="false"/> + </map> + + <map keycode="L" pressed="false"> + <event keycode="L" unicode="252" pressed="false"/> + </map> + + <map keycode="M" pressed="false"> + <event keycode="M" unicode="246" pressed="false"/> + </map> + + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="228" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="LShift-Caps"> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="true"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-Num"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Num"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Caps"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="8364" pressed="true" autorepeat="true"/> + </map> + + <map keycode="O" pressed="true"> + <event keycode="O" unicode="223" pressed="true" autorepeat="true"/> + </map> + + <map keycode="L" pressed="true"> + <event keycode="L" unicode="220" pressed="true" autorepeat="true"/> + </map> + + <map keycode="M" pressed="true"> + <event keycode="M" unicode="214" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="196" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="8364" pressed="false"/> + </map> + + <map keycode="O" pressed="false"> + <event keycode="O" unicode="223" pressed="false"/> + </map> + + <map keycode="L" pressed="false"> + <event keycode="L" unicode="220" pressed="false"/> + </map> + + <map keycode="M" pressed="false"> + <event keycode="M" unicode="214" pressed="false"/> + </map> + + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="196" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-RShift"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="8364" pressed="true" autorepeat="true"/> + </map> + + <map keycode="O" pressed="true"> + <event keycode="O" unicode="223" pressed="true" autorepeat="true"/> + </map> + + <map keycode="L" pressed="true"> + <event keycode="L" unicode="220" pressed="true" autorepeat="true"/> + </map> + + <map keycode="M" pressed="true"> + <event keycode="M" unicode="214" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="196" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="8364" pressed="false"/> + </map> + + <map keycode="O" pressed="false"> + <event keycode="O" unicode="223" pressed="false"/> + </map> + + <map keycode="L" pressed="false"> + <event keycode="L" unicode="220" pressed="false"/> + </map> + + <map keycode="M" pressed="false"> + <event keycode="M" unicode="214" pressed="false"/> + </map> + + <map keycode="Period" pressed="false"> + <event keycode="Period" unicode="196" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift"/> + </map> +</state> + +<state name="LShift-RShift-Caps"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="8364" pressed="true" autorepeat="true"/> + </map> + + <map keycode="O" pressed="true"> + <event keycode="O" unicode="223" pressed="true" autorepeat="true"/> + </map> + + <map keycode="L" pressed="true"> + <event keycode="L" unicode="252" pressed="true" autorepeat="true"/> + </map> + + <map keycode="M" pressed="true"> + <event keycode="M" unicode="246" pressed="true" autorepeat="true"/> + </map> + + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="228" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="8364" pressed="false"/> + </map> + + <map keycode="O" pressed="false"> + <event keycode="O" unicode="223" pressed="false"/> + </map> + + <map keycode="L" pressed="false"> + <event keycode="L" unicode="252" pressed="false"/> + </map> + + <map keycode="M" pressed="false"> + <event keycode="M" unicode="246" pressed="false"/> + </map> + + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="228" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-Caps"/> + </map> +</state> + +<state name="Caps"> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="true"/> + <next-state name="RShift-Caps"/> + </map> +</state> + +<state name="lower-case"> + <map keycode="Space" pressed="true"> + <event keycode="Space" unicode="32" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="Apostrophe" unicode="39" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="44" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Period" unicode="46" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Slash" unicode="47" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="97" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="98" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="99" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="100" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="101" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="102" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="103" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="104" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="105" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="106" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="107" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="108" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="109" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="110" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="111" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="112" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="113" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="114" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="115" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="116" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="117" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="118" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="119" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="120" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="122" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="121" pressed="true" autorepeat="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Space" unicode="32" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="Apostrophe" unicode="39" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="44" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Period" unicode="46" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Slash" unicode="47" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="97" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="98" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="99" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="100" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="101" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="102" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="103" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="104" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="105" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="106" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="107" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="108" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="109" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="110" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="111" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="112" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="113" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="114" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="115" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="116" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="117" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="118" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="119" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="120" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="122" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="121" pressed="false"/> + </map> +</state> + +<state name="upper-case"> + <map keycode="Space" pressed="true"> + <event keycode="Space" unicode="32" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="QuoteDbl" unicode="34" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Semicolon" unicode="59" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Colon" unicode="58" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Question" unicode="63" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="65" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="66" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="67" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="68" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="69" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="70" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="71" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="72" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="73" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="74" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="75" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="76" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="77" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="78" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="79" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="80" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="81" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="82" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="83" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="84" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="85" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="86" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="87" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="88" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="90" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="89" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Space" unicode="32" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="QuoteDbl" unicode="34" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Semicolon" unicode="59" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Colon" unicode="58" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Question" unicode="63" modifiers="Shift" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="65" modifiers="Shift" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="66" modifiers="Shift" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="67" modifiers="Shift" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="68" modifiers="Shift" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="69" modifiers="Shift" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="70" modifiers="Shift" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="71" modifiers="Shift" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="72" modifiers="Shift" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="73" modifiers="Shift" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="74" modifiers="Shift" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="75" modifiers="Shift" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="76" modifiers="Shift" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="77" modifiers="Shift" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="78" modifiers="Shift" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="79" modifiers="Shift" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="80" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="81" modifiers="Shift" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="82" modifiers="Shift" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="83" modifiers="Shift" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="84" modifiers="Shift" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="85" modifiers="Shift" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="86" modifiers="Shift" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="87" modifiers="Shift" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="88" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="90" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="89" modifiers="Shift" pressed="false"/> + </map> +</state> + +</keymap>
\ No newline at end of file diff --git a/share/zkb/de.xml.num b/share/zkb/de.xml.num new file mode 100644 index 0000000..15ebf11 --- a/dev/null +++ b/share/zkb/de.xml.num @@ -0,0 +1,618 @@ +<keymap> + +<include file="common.xml"/> + +<state name="LShift-RShift" parent="common"/> +<state name="LShift-RShift-Caps" parent="common"/> + +<state name="LShift"> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="RShift"> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="8364" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="79" pressed="true"> + <event keycode="79" unicode="223" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="76" pressed="true"> + <event keycode="76" unicode="252" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="77" pressed="true"> + <event keycode="77" unicode="246" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="46" pressed="true"> + <event keycode="46" unicode="228" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="69" pressed="false"> + <event keycode="69" unicode="8364" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="79" pressed="false"> + <event keycode="79" unicode="223" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="76" pressed="false"> + <event keycode="76" unicode="252" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="77" pressed="false"> + <event keycode="77" unicode="246" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="46" pressed="false"> + <event keycode="46" unicode="228" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="LShift-Caps"> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-Num"> + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="Num"/> + </map> + + <map keycode="4165" pressed="true"> + <event keycode="4165" unicode="-1" modifiers="16" pressed="true" autorepeat="false"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Caps"> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="8364" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="79" pressed="true"> + <event keycode="79" unicode="223" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="76" pressed="true"> + <event keycode="76" unicode="220" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="77" pressed="true"> + <event keycode="77" unicode="214" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="46" pressed="true"> + <event keycode="46" unicode="196" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="69" pressed="false"> + <event keycode="69" unicode="8364" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="79" pressed="false"> + <event keycode="79" unicode="223" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="76" pressed="false"> + <event keycode="76" unicode="220" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="77" pressed="false"> + <event keycode="77" unicode="214" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="46" pressed="false"> + <event keycode="46" unicode="196" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="4128" pressed="true"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-RShift"> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="8364" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="79" pressed="true"> + <event keycode="79" unicode="223" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="76" pressed="true"> + <event keycode="76" unicode="220" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="77" pressed="true"> + <event keycode="77" unicode="214" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="46" pressed="true"> + <event keycode="46" unicode="196" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="69" pressed="false"> + <event keycode="69" unicode="8364" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="79" pressed="false"> + <event keycode="79" unicode="223" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="76" pressed="false"> + <event keycode="76" unicode="220" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="77" pressed="false"> + <event keycode="77" unicode="214" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="46" pressed="false"> + <event keycode="46" unicode="196" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="RShift"/> + </map> + + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift"/> + </map> +</state> + +<state name="LShift-RShift-Caps"> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="8364" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="79" pressed="true"> + <event keycode="79" unicode="223" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="76" pressed="true"> + <event keycode="76" unicode="252" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="77" pressed="true"> + <event keycode="77" unicode="246" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="46" pressed="true"> + <event keycode="46" unicode="228" modifiers="0" pressed="true" autorepeat="true"/> + </map> + + <map keycode="69" pressed="false"> + <event keycode="69" unicode="8364" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="79" pressed="false"> + <event keycode="79" unicode="223" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="76" pressed="false"> + <event keycode="76" unicode="252" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="77" pressed="false"> + <event keycode="77" unicode="246" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="46" pressed="false"> + <event keycode="46" unicode="228" modifiers="0" pressed="false" autorepeat="true"/> + </map> + + <map keycode="4128" pressed="false"> + <event keycode="4128" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="4130" pressed="false"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="LShift-Caps"/> + </map> +</state> + +<state name="Caps"> + <map keycode="4130" pressed="true"> + <event keycode="4130" unicode="-1" modifiers="0" pressed="false" autorepeat="false"/> + <next-state name="RShift-Caps"/> + </map> +</state> + +<state name="lower-case"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="32" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="39" unicode="39" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="44" unicode="44" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="46" unicode="46" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="47" unicode="47" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="65" unicode="97" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="66" unicode="98" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="99" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="68" unicode="100" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="101" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="70" unicode="102" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="71" unicode="103" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="72" unicode="104" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="73" unicode="105" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="74" unicode="106" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="75" unicode="107" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="108" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="77" unicode="109" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="78" unicode="110" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="79" unicode="111" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="80" unicode="112" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="81" unicode="113" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="82" unicode="114" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="83" unicode="115" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="84" unicode="116" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="85" unicode="117" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="86" unicode="118" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="87" unicode="119" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="88" unicode="120" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="89" unicode="121" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="122" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="32" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="39" unicode="39" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="44" unicode="44" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="46" unicode="46" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="47" pressed="false"> + <event keycode="47" unicode="47" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="65" unicode="97" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="66" unicode="98" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="99" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="68" unicode="100" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="69" unicode="101" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="70" unicode="102" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="71" unicode="103" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="72" unicode="104" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="73" unicode="105" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="74" unicode="106" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="75" unicode="107" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="108" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="77" unicode="109" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="78" unicode="110" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="79" unicode="111" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="80" unicode="112" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="81" unicode="113" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="82" unicode="114" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="83" unicode="115" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="84" unicode="116" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="85" unicode="117" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="86" unicode="118" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="87" unicode="119" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="88" unicode="120" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="89" unicode="121" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="122" modifiers="0" pressed="false" autorepeat="false"/> + </map> +</state> + +<state name="upper-case"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="32" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="34" unicode="34" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="59" unicode="59" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="58" unicode="58" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="63" unicode="63" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="65" unicode="65" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="66" unicode="66" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="67" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="68" unicode="68" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="69" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="70" unicode="70" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="71" unicode="71" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="72" unicode="72" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="73" unicode="73" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="74" unicode="74" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="75" unicode="75" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="76" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="77" unicode="77" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="78" unicode="78" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="79" unicode="79" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="80" unicode="80" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="81" unicode="81" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="82" unicode="82" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="83" unicode="83" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="84" unicode="84" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="85" unicode="85" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="86" unicode="86" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="87" unicode="87" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="88" unicode="88" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="89" unicode="89" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="90" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="32" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="34" unicode="34" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="58" unicode="58" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="59" unicode="59" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="47" pressed="false"> + <event keycode="63" unicode="63" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="65" unicode="65" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="66" unicode="66" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="67" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="68" unicode="68" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="69" unicode="69" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="70" unicode="70" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="71" unicode="71" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="72" unicode="72" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="73" unicode="73" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="74" unicode="74" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="75" unicode="75" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="76" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="77" unicode="77" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="78" unicode="78" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="79" unicode="79" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="80" unicode="80" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="81" unicode="81" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="82" unicode="82" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="83" unicode="83" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="84" unicode="84" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="85" unicode="85" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="86" unicode="86" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="87" unicode="87" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="88" unicode="88" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="89" unicode="89" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="90" modifiers="8" pressed="false" autorepeat="false"/> + </map> +</state> + + +</keymap> diff --git a/share/zkb/en.xml b/share/zkb/en.xml new file mode 100644 index 0000000..0b1c345 --- a/dev/null +++ b/share/zkb/en.xml @@ -0,0 +1,383 @@ +<keymap> + +<include file="common.xml"/> + +<state name="lower-case"> + <map keycode="Space" pressed="true"> + <event keycode="Space" unicode="32" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="Apostrophe" unicode="39" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Comma" unicode="44" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Period" unicode="46" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Slash" unicode="47" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="97" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="98" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="99" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="100" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="101" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="102" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="103" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="104" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="105" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="106" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="107" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="108" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="109" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="110" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="111" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="112" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="113" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="114" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="115" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="116" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="117" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="118" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="119" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="120" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="121" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="122" pressed="true" autorepeat="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Space" unicode="32" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="Apostrophe" unicode="39" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Comma" unicode="44" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Period" unicode="46" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Slash" unicode="47" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="97" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="98" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="99" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="100" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="101" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="102" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="103" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="104" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="105" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="106" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="107" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="108" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="109" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="110" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="111" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="112" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="113" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="114" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="115" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="116" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="117" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="118" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="119" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="120" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="121" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="122" pressed="false"/> + </map> +</state> + +<state name="upper-case"> + <map keycode="Space" pressed="true"> + <event keycode="Space" unicode="32" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <event keycode="QuoteDbl" unicode="34" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Semicolon" unicode="59" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Colon" unicode="58" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Question" unicode="63" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="65" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="66" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="67" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="68" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="69" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="70" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="71" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="72" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="73" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="74" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="75" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="76" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="77" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="78" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="79" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="80" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="81" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="82" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="83" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="84" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="85" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="86" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="87" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="88" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="89" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="90" modifiers="Shift" pressed="true" autorepeat="true"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Space" unicode="32" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="QuoteDbl" unicode="34" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Semicolon" unicode="59" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Colon" unicode="58" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Question" unicode="63" modifiers="Shift" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="65" modifiers="Shift" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="66" modifiers="Shift" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="67" modifiers="Shift" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="68" modifiers="Shift" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="69" modifiers="Shift" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="70" modifiers="Shift" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="71" modifiers="Shift" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="72" modifiers="Shift" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="73" modifiers="Shift" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="74" modifiers="Shift" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="75" modifiers="Shift" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="76" modifiers="Shift" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="77" modifiers="Shift" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="78" modifiers="Shift" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="79" modifiers="Shift" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="80" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="81" modifiers="Shift" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="82" modifiers="Shift" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="83" modifiers="Shift" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="84" modifiers="Shift" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="85" modifiers="Shift" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="86" modifiers="Shift" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="87" modifiers="Shift" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="88" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="89" modifiers="Shift" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="90" modifiers="Shift" pressed="false"/> + </map> +</state> + +</keymap> diff --git a/share/zkb/en.xml.num b/share/zkb/en.xml.num new file mode 100644 index 0000000..0ffd57b --- a/dev/null +++ b/share/zkb/en.xml.num @@ -0,0 +1,383 @@ +<keymap> + +<include file="common.xml"/> + +<state name="lower-case"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="32" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="39" unicode="39" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="44" unicode="44" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="46" unicode="46" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="47" unicode="47" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="65" unicode="97" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="66" unicode="98" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="99" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="68" unicode="100" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="101" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="70" unicode="102" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="71" unicode="103" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="72" unicode="104" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="73" unicode="105" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="74" unicode="106" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="75" unicode="107" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="108" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="77" unicode="109" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="78" unicode="110" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="79" unicode="111" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="80" unicode="112" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="81" unicode="113" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="82" unicode="114" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="83" unicode="115" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="84" unicode="116" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="85" unicode="117" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="86" unicode="118" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="87" unicode="119" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="88" unicode="120" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="89" unicode="121" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="122" modifiers="0" pressed="true" autorepeat="true"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="32" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="39" unicode="39" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="44" unicode="44" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="46" unicode="46" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="47" pressed="false"> + <event keycode="47" unicode="47" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="65" unicode="97" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="66" unicode="98" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="99" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="68" unicode="100" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="69" unicode="101" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="70" unicode="102" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="71" unicode="103" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="72" unicode="104" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="73" unicode="105" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="74" unicode="106" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="75" unicode="107" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="108" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="77" unicode="109" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="78" unicode="110" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="79" unicode="111" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="80" unicode="112" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="81" unicode="113" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="82" unicode="114" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="83" unicode="115" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="84" unicode="116" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="85" unicode="117" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="86" unicode="118" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="87" unicode="119" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="88" unicode="120" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="89" unicode="121" modifiers="0" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="122" modifiers="0" pressed="false" autorepeat="false"/> + </map> +</state> + +<state name="upper-case"> + <map keycode="32" pressed="true"> + <event keycode="32" unicode="32" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="39" pressed="true"> + <event keycode="34" unicode="34" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="44" pressed="true"> + <event keycode="59" unicode="59" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="46" pressed="true"> + <event keycode="58" unicode="58" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="47" pressed="true"> + <event keycode="63" unicode="63" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="65" pressed="true"> + <event keycode="65" unicode="65" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="66" pressed="true"> + <event keycode="66" unicode="66" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="67" pressed="true"> + <event keycode="67" unicode="67" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="68" pressed="true"> + <event keycode="68" unicode="68" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="69" pressed="true"> + <event keycode="69" unicode="69" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="70" pressed="true"> + <event keycode="70" unicode="70" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="71" pressed="true"> + <event keycode="71" unicode="71" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="72" pressed="true"> + <event keycode="72" unicode="72" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="73" pressed="true"> + <event keycode="73" unicode="73" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="74" pressed="true"> + <event keycode="74" unicode="74" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="75" pressed="true"> + <event keycode="75" unicode="75" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="76" pressed="true"> + <event keycode="76" unicode="76" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="77" pressed="true"> + <event keycode="77" unicode="77" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="78" pressed="true"> + <event keycode="78" unicode="78" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="79" pressed="true"> + <event keycode="79" unicode="79" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="80" pressed="true"> + <event keycode="80" unicode="80" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="81" pressed="true"> + <event keycode="81" unicode="81" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="82" pressed="true"> + <event keycode="82" unicode="82" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="83" pressed="true"> + <event keycode="83" unicode="83" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="84" pressed="true"> + <event keycode="84" unicode="84" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="85" pressed="true"> + <event keycode="85" unicode="85" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="86" pressed="true"> + <event keycode="86" unicode="86" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="87" pressed="true"> + <event keycode="87" unicode="87" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="88" pressed="true"> + <event keycode="88" unicode="88" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="89" pressed="true"> + <event keycode="89" unicode="89" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="90" pressed="true"> + <event keycode="90" unicode="90" modifiers="8" pressed="true" autorepeat="true"/> + </map> + <map keycode="32" pressed="false"> + <event keycode="32" unicode="32" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="39" pressed="false"> + <event keycode="34" unicode="34" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="44" pressed="false"> + <event keycode="58" unicode="58" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="46" pressed="false"> + <event keycode="59" unicode="59" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="47" pressed="false"> + <event keycode="63" unicode="63" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="65" pressed="false"> + <event keycode="65" unicode="65" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="66" pressed="false"> + <event keycode="66" unicode="66" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="67" pressed="false"> + <event keycode="67" unicode="67" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="68" pressed="false"> + <event keycode="68" unicode="68" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="69" pressed="false"> + <event keycode="69" unicode="69" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="70" pressed="false"> + <event keycode="70" unicode="70" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="71" pressed="false"> + <event keycode="71" unicode="71" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="72" pressed="false"> + <event keycode="72" unicode="72" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="73" pressed="false"> + <event keycode="73" unicode="73" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="74" pressed="false"> + <event keycode="74" unicode="74" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="75" pressed="false"> + <event keycode="75" unicode="75" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="76" pressed="false"> + <event keycode="76" unicode="76" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="77" pressed="false"> + <event keycode="77" unicode="77" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="78" pressed="false"> + <event keycode="78" unicode="78" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="79" pressed="false"> + <event keycode="79" unicode="79" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="80" pressed="false"> + <event keycode="80" unicode="80" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="81" pressed="false"> + <event keycode="81" unicode="81" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="82" pressed="false"> + <event keycode="82" unicode="82" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="83" pressed="false"> + <event keycode="83" unicode="83" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="84" pressed="false"> + <event keycode="84" unicode="84" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="85" pressed="false"> + <event keycode="85" unicode="85" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="86" pressed="false"> + <event keycode="86" unicode="86" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="87" pressed="false"> + <event keycode="87" unicode="87" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="88" pressed="false"> + <event keycode="88" unicode="88" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="89" pressed="false"> + <event keycode="89" unicode="89" modifiers="8" pressed="false" autorepeat="false"/> + </map> + <map keycode="90" pressed="false"> + <event keycode="90" unicode="90" modifiers="8" pressed="false" autorepeat="false"/> + </map> +</state> + +</keymap> diff --git a/share/zkb/latin1.xml b/share/zkb/latin1.xml new file mode 100644 index 0000000..ec57746 --- a/dev/null +++ b/share/zkb/latin1.xml @@ -0,0 +1,1927 @@ +<keymap> + +<!-- +Zaurus Keyboard definition for Latin1 characters. +================================================ +This keyboard should allow the entry of all characters used in latin +languages like French or Spanish. + +The following rules are implemented: +- Right Shift activate dead keys that allows to compose accentuated characters. +- Keep Right Shift or press Left Shift to change case of letter +- Space can be used to abort a key composition and return to Normal state, printing +the accent. + +- Keys not defined are inherited from parent mapping. + +Key composition +=============== +Use the Right Shift with one of the following keys to compose accentuated +characters. + Key Action (Mnemonic) + / Accute accent (same slant) + ' Grave accent (no backslash!) + , Cedilla (a comma under the C) + V Circumflex accent (reversed circumflex) + J Ligature (Join letters) + B Trema (Near circumflex) + N Tilde (Same shape on N) ******* Bound to M due to a bug in the definition! + I Inversed (Inversed !) + +All accents are in the same area, around Space bar. + + +Keyboard navigation (not implemented yet) +=================== +To be put into common.xml. Use either Right of Left Shift: + <- Home + -> End + ^ PageUp + v PageDown + + +Report bugs or comments to Pierre Métras <admin@alterna.tv> +Version 0.1 - 20020901 +--> + +<!-- The base is English mapping --> +<include file="en.xml"/> + + +<state name="RShift-Accute" parent="RShift"/> +<state name="RShift-Accute-Lower" parent="Normal"/> +<state name="RShift-Caps-Accute" parent="Caps"/> +<state name="RShift-Caps-Accute-Upper" parent="RShift-Caps"/> + +<state name="RShift-Grave" parent="RShift"/> +<state name="RShift-Grave-Lower" parent="Normal"/> +<state name="RShift-Caps-Grave" parent="Caps"/> +<state name="RShift-Caps-Grave-Upper" parent="RShift-Caps"/> + +<state name="RShift-Circumflex" parent="RShift"/> +<state name="RShift-Circumflex-Lower" parent="Normal"/> +<state name="RShift-Caps-Circumflex" parent="Caps"/> +<state name="RShift-Caps-Circumflex-Upper" parent="RShift-Caps"/> + +<state name="RShift-Cedilla" parent="RShift"/> +<state name="RShift-Cedilla-Lower" parent="Normal"/> +<state name="RShift-Caps-Cedilla" parent="Caps"/> +<state name="RShift-Caps-Cedilla-Upper" parent="RShift-Caps"/> + +<state name="RShift-Ligature" parent="RShift"/> +<state name="RShift-Ligature-Lower" parent="Normal"/> +<state name="RShift-Caps-Ligature" parent="Caps"/> +<state name="RShift-Caps-Ligature-Upper" parent="RShift-Caps"/> + +<state name="RShift-Trema" parent="RShift"/> +<state name="RShift-Trema-Lower" parent="Normal"/> +<state name="RShift-Caps-Trema" parent="Caps"/> +<state name="RShift-Caps-Trema-Upper" parent="RShift-Caps"/> + +<state name="RShift-Tilde" parent="RShift"/> +<state name="RShift-Tilde-Lower" parent="Normal"/> +<state name="RShift-Caps-Tilde" parent="Caps"/> +<state name="RShift-Caps-Tilde-Upper" parent="RShift-Caps"/> + +<state name="RShift-Inversed" parent="RShift"/> +<state name="RShift-Caps-Inversed" parent="Caps"/> + + + +<!-- TO BE PLACED INTO COMMON --> +<!-- START: EXTENDED KEY NAVIGATION --> +<state name="LShift"> + <map keycode="Left" pressed="true"> + <event keycode="Home" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Left" pressed="false"> + <event keycode="Home" unicode="-1" pressed="false"/> + </map> + + <map keycode="Up" pressed="true"> + <event keycode="PageUp" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Up" pressed="false"> + <event keycode="PageUp" unicode="-1" pressed="false"/> + </map> + + <map keycode="Right" pressed="true"> + <event keycode="End" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Right" pressed="false"> + <event keycode="End" unicode="-1" pressed="false"/> + </map> + + <map keycode="Down" pressed="true"> + <event keycode="PageDown" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Down" pressed="false"> + <event keycode="PageDown" unicode="-1" pressed="false"/> + </map> +</state> +<state name="RShift"> + <map keycode="Left" pressed="true"> + <event keycode="Home" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Left" pressed="false"> + <event keycode="Home" unicode="-1" pressed="false"/> + </map> + + <map keycode="Up" pressed="true"> + <event keycode="PageUp" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Up" pressed="false"> + <event keycode="PageUp" unicode="-1" pressed="false"/> + </map> + + <map keycode="Right" pressed="true"> + <event keycode="End" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Right" pressed="false"> + <event keycode="End" unicode="-1" pressed="false"/> + </map> + + <map keycode="Down" pressed="true"> + <event keycode="PageDown" unicode="-1" pressed="true" autorepeat="true"/> + </map> + <map keycode="Down" pressed="false"> + <event keycode="PageDown" unicode="-1" pressed="false"/> + </map> +</state> +<!-- END: EXTENDED KEY NAVIGATION --> + + + +<!-- RShift activate dead keys --> +<state name="RShift"> + <map keycode="Slash" pressed="true"> + <next-state name="RShift-Accute"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <next-state name="RShift-Grave"/> + </map> + <map keycode="Comma" pressed="true"> + <next-state name="RShift-Cedilla"/> + </map> + <map keycode="J" pressed="true"> + <next-state name="RShift-Ligature"/> + </map> + <map keycode="V" pressed="true"> + <next-state name="RShift-Circumflex"/> + </map> + <map keycode="B" pressed="true"> + <next-state name="RShift-Trema"/> + </map> + <map keycode="M" pressed="true"> + <next-state name="RShift-Tilde"/> + </map> + <map keycode="I" pressed="true"> + <next-state name="RShift-Inversed"/> + </map> +</state> + + +<!-- RShift activate dead keys in CAPS mode --> +<state name="RShift-Caps"> + <map keycode="Slash" pressed="true"> + <next-state name="RShift-Caps-Accute"/> + </map> + <map keycode="Apostrophe" pressed="true"> + <next-state name="RShift-Caps-Grave"/> + </map> + <map keycode="Comma" pressed="true"> + <next-state name="RShift-Caps-Cedilla"/> + </map> + <map keycode="J" pressed="true"> + <next-state name="RShift-Caps-Ligature"/> + </map> + <map keycode="V" pressed="true"> + <next-state name="RShift-Caps-Circumflex"/> + </map> + <map keycode="B" pressed="true"> + <next-state name="RShift-Caps-Trema"/> + </map> + <map keycode="M" pressed="true"> + <next-state name="RShift-Caps-Tilde"/> + </map> + <map keycode="I" pressed="true"> + <next-state name="RShift-Caps-Inversed"/> + </map> +</state> + + +<!-- Accute Accentuated Upper-Case Characters: Á, É... because we still press Shift --> +<state name="RShift-Accute"> + <!-- RS + (/) + A = Á --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC1" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC1" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + E = É --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xC9" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xC9" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + I = Í --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCD" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCD" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + O = Ó --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD3" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD3" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + U = Ú --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xDA" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xDA" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + Y = Ý --> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0xDD" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0xDD" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Release shift to do lower-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Accute-Lower"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Accute-Lower"/> + </map> + + <!-- Abort operation: print ´ --> + <map keycode="Space" pressed="true"> + <event keycode="Slash" unicode="0xB4" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Slash" unicode="0xB4" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Accute Accentuated Lower-Case Characters: á, é... because we have released RShift --> +<state name="RShift-Accute-Lower"> + <!-- RS + (/) + A = á --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE1" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE1" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + E = é --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xE9" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xE9" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + I = í --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xED" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xED" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + O = ó --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF3" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF3" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + U = ú --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xFA" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xFA" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (/) + Y = ý --> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0xFD" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0xFD" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- Simple shift second time goes Upper-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Accute"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Accute"/> + </map> + + <!-- Abort operation: print ´ --> + <map keycode="Space" pressed="true"> + <event keycode="Slash" unicode="0xB4" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Slash" unicode="0xB4" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Accute Accentuated Lower-Case Characters: á, é... because we still press Shift and we are in Caps --> +<state name="RShift-Caps-Accute"> + <!-- Caps + RS + (/) + A = á --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE1" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE1" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + E = é --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xE9" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xE9" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + I = í --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xED" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xED" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + O = ó --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF3" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF3" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + U = ú --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xFA" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xFA" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + Y = ý --> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0xFD" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0xFD" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Release shift to go upper-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Accute-Upper"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Accute-Upper"/> + </map> + + <!-- Abort operation: print ´ --> + <map keycode="Space" pressed="true"> + <event keycode="Slash" unicode="0xB4" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Slash" unicode="0xB4" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +<!-- Accute Accentuated Upper-Case Characters: Á, É... because we have released RShift but we are in Caps --> +<state name="RShift-Caps-Accute-Upper"> + <!-- Caps + RS + (/) + A = Á --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC1" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC1" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + E = É --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xC9" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xC9" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + I = Í --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCD" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCD" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + O = Ó --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD3" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD3" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + U = Ú --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xDA" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xDA" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (/) + Y = Ý --> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0xDD" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0xDD" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Simple shift second time goes Lower-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Accute"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Accute"/> + </map> + + <!-- Abort operation: print ´ --> + <map keycode="Space" pressed="true"> + <event keycode="Slash" unicode="0xB4" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Slash" unicode="0xB4" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + + + +<!-- Grave Accentuated Upper-Case Characters: À, È, Ì... because we still press Shift --> +<state name="RShift-Grave"> + <!-- RS + (') + A = À --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC0" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC0" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + E = È --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xC8" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xC8" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + I = Ì --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCC" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCC" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + O = Ò --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD2" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD2" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + U = Ù --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xD9" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xD9" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Release shift to do lower-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Grave-Lower"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Grave-Lower"/> + </map> + + <!-- Abort operation: print ` --> + <map keycode="Space" pressed="true"> + <event keycode="Apostrophe" unicode="0x60" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Apostrophe" unicode="0x60" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Grave Accentuated Lower-Case Characters: à, è, ì... because we have released RShift --> +<state name="RShift-Grave-Lower"> + <!-- RS + (') + A = à --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE0" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE0" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + E = è --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xE8" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xE8" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + I = ì --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xEC" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xEC" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + O = ò --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF2" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF2" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (') + U = ù --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xF9" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xF9" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- Simple shift second time goes Upper-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Grave"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Grave"/> + </map> + + <!-- Abort operation: print ` --> + <map keycode="Space" pressed="true"> + <event keycode="Apostrophe" unicode="0x60" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Apostrophe" unicode="0x60" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Grave Accentuated Lower-Case Characters: à, è... because we still press Shift and we are in Caps --> +<state name="RShift-Caps-Grave"> + <!-- Caps + RS + (') + A = à --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE0" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE0" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + E = è --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xE8" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xE8" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + I = ì --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xEC" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xEC" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + O = ò --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF2" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF2" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + U = ú --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xF9" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xF9" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Release shift to go upper-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Grave-Upper"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Grave-Upper"/> + </map> + + <!-- Abort operation: print ` --> + <map keycode="Space" pressed="true"> + <event keycode="Apostrophe" unicode="0x60" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Apostrophe" unicode="0x60" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +<!-- Grave Accentuated Upper-Case Characters: À, È, Ì... because we have released RShift and we are in Caps --> +<state name="RShift-Caps-Grave-Upper"> + <!-- Caps + RS + (') + A = À --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC0" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC0" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + E = È --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xC8" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xC8" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + I = Ì --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCC" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCC" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + O = Ò --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD2" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD2" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (') + U = Ù --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xD9" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xD9" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Simple shift second time goes Lower-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Grave"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Grave"/> + </map> + + <!-- Abort operation: print ` --> + <map keycode="Space" pressed="true"> + <event keycode="Apostrophe" unicode="0x60" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Apostrophe" unicode="0x60" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + + + +<!-- Circumflex Accentuated Upper-Case Characters: Â, Ê, Î... because we still press Shift --> +<state name="RShift-Circumflex"> + <!-- RS + (V) + A =  --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC2" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC2" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + E = Ê --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xCA" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xCA" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + I = Î --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCE" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCE" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + O = Ô --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD4" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD4" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + U = Û --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xDB" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xDB" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Release shift to do lower-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Circumflex-Lower"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Circumflex-Lower"/> + </map> + + <!-- Abort operation: print ^ --> + <map keycode="Space" pressed="true"> + <event keycode="V" unicode="0x5E" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="V" unicode="0x5E" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Circumflex Accentuated Lower-Case Characters: â, ê, î... because we have released RShift --> +<state name="RShift-Circumflex-Lower"> + <!-- RS + (V) + A = â --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE2" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE2" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + E = ê --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xEA" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xEA" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + I = î --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xEE" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xEE" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + O = ô --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF4" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF4" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (V) + U = û --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xFB" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xFB" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- Simple shift second time goes Upper-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Circumflex"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Circumflex"/> + </map> + + <!-- Abort operation: print ^ --> + <map keycode="Space" pressed="true"> + <event keycode="V" unicode="0x5E" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="V" unicode="0x5E" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Circumflex Accentuated Lower-Case Characters: â, ê... because we still press Shift and we are in Caps --> +<state name="RShift-Caps-Circumflex"> + <!-- Caps + RS + (V) + A = â --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE2" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE2" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + E = ê --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xEA" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xEA" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + I = î --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xEE" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xEE" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + O = ô --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF4" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF4" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + U = û --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xFB" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xFB" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Release shift to go upper-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Circumflex-Upper"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Circumflex-Upper"/> + </map> + + <!-- Abort operation: print ^ --> + <map keycode="Space" pressed="true"> + <event keycode="V" unicode="0x5E" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="V" unicode="0x5E" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +<!-- Circumflex Accentuated Upper-Case Characters: Â, Ê, Î... because we have released RShift and we are in Caps --> +<state name="RShift-Caps-Circumflex-Upper"> + <!-- Caps + RS + (V) + A =  --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC2" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC2" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + E = Ê --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xCA" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xCA" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + I = Î --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCE" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCE" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + O = Ô --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD4" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD4" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (V) + U = Û --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xDB" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xDB" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Simple shift second time goes Lower-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Circumflex"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Circumflex"/> + </map> + + <!-- Abort operation: print ^ --> + <map keycode="Space" pressed="true"> + <event keycode="V" unicode="0x5E" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="V" unicode="0x5E" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + + + +<!-- Cedilla Upper-Case Characters: Ç... because we still press Shift --> +<state name="RShift-Cedilla"> + <!-- RS + (,) + C = Ç --> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="0xC7" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="0xC7" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Release shift to do lower-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Cedilla-Lower"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Cedilla-Lower"/> + </map> + + <!-- Abort operation: print ¸ --> + <map keycode="Space" pressed="true"> + <event keycode="Comma" unicode="0xB8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Comma" unicode="0xB8" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Cedilla Lower-Case Characters: ç... because we have released RShift --> +<state name="RShift-Cedilla-Lower"> + <!-- RS + (,) + C = ç --> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="0xE7" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="0xE7" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- Simple shift second time goes Upper-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Cedilla"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Cedilla"/> + </map> + + <!-- Abort operation: print ¸ --> + <map keycode="Space" pressed="true"> + <event keycode="Comma" unicode="0xB8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Comma" unicode="0xB8" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Cedilla Lower-Case Characters: ç... because we still press Shift and we are in Caps --> +<state name="RShift-Caps-Cedilla"> + <!-- Caps + RS + (,) + C = ç --> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="0xE7" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="0xE7" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Release shift to go upper-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Cedilla-Upper"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Cedilla-Upper"/> + </map> + + <!-- Abort operation: print ¸ --> + <map keycode="Space" pressed="true"> + <event keycode="Comma" unicode="0xB8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Comma" unicode="0xB8" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +<!-- Cedilla Upper-Case Characters: Ç... because we have released RShift but we are in Caps --> +<state name="RShift-Caps-Cedilla-Upper"> + <!-- Caps + RS + (,) + C = Ç --> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="0xC7" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="0xC7" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Simple shift second time goes Lower-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Cedilla"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Cedilla"/> + </map> + + <!-- Abort operation: print ¸ --> + <map keycode="Space" pressed="true"> + <event keycode="Comma" unicode="0xB8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="Comma" unicode="0xB8" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + + + +<!-- Ligatured Upper-Case Characters: Æ, Œ ... because we still press Shift --> +<state name="RShift-Ligature"> + <!-- RS + (J) + A = Æ --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC6" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC6" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (J) + O = Œ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0x152" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0x152" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Release shift to do lower-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Ligature-Lower"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Ligature-Lower"/> + </map> + + <!-- Abort operation: print J --> + <map keycode="Space" pressed="true"> + <event keycode="J" unicode="0x4A" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="J" unicode="0x4A" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Ligatured Lower-Case Characters: æ, œ... because we have released RShift --> +<state name="RShift-Ligature-Lower"> + <!-- RS + (J) + A = æ --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE6" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE6" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (J) + O = œ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0x153" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0x153" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- Simple shift second time goes Upper-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Ligature"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Ligature"/> + </map> + + <!-- Abort operation: print j --> + <map keycode="Space" pressed="true"> + <event keycode="J" unicode="0x6A" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="J" unicode="0x6A" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Ligatured Lower-Case Characters: æ, œ... because we still press Shift and we are in Caps --> +<state name="RShift-Caps-Ligature"> + <!-- Caps + RS + (J) + A = æ --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE6" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE6" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (J) + O = œ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0x153" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0x153" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Release shift to go upper-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Ligature-Upper"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Ligature-Upper"/> + </map> + + <!-- Abort operation: print j --> + <map keycode="Space" pressed="true"> + <event keycode="J" unicode="0x6A" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="J" unicode="0x6A" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +<!-- Ligatured Upper-Case Characters: Æ, Œ... because we have released RShift but we are in Caps --> +<state name="RShift-Caps-Ligature-Upper"> + <!-- Caps + RS + (J) + A = Æ --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC6" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC6" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (J) + O = Œ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0x152" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0x152" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Simple shift second time goes Lower-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Ligature"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Ligature"/> + </map> + + <!-- Abort operation: print J --> + <map keycode="Space" pressed="true"> + <event keycode="J" unicode="0x4A" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="J" unicode="0x4A" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + + + +<!-- Trema Accentuated Upper-Case Characters: Ä, Ë... because we still press Shift --> +<state name="RShift-Trema"> + <!-- RS + (B) + A = Ä --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC4" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC4" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + E = Ë --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xCB" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xCB" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + I = Ï --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCF" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCF" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + O = Ö --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD6" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD6" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + U = Ü --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xDC" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xDC" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Release shift to do lower-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Trema-Lower"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Trema-Lower"/> + </map> + + <!-- Abort operation: print ¨ --> + <map keycode="Space" pressed="true"> + <event keycode="B" unicode="0xA8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="B" unicode="0xA8" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Trema Accentuated Lower-Case Characters: ä, ë... because we have released RShift --> +<state name="RShift-Trema-Lower"> + <!-- RS + (B) + A = ä --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE4" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE4" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + E = ë --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xEB" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xEB" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + I = ï --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xEF" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xEF" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + O = ö --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF6" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF6" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + U = ü --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xFC" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xFC" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (B) + Y = ÿ --> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0xFF" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0xFF" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- Simple shift second time goes Upper-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Trema"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Trema"/> + </map> + + <!-- Abort operation: print ¨ --> + <map keycode="Space" pressed="true"> + <event keycode="B" unicode="0xA8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="B" unicode="0xA8" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Trema Accentuated Lower-Case Characters: ä, ë... because we still press Shift and we are in Caps --> +<state name="RShift-Caps-Trema"> + <!-- Caps + RS + (B) + A = ä --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE4" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE4" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + E = ë --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xEB" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xEB" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + I = ï --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xEF" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xEF" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + O = ö --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF6" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF6" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + U = ü --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xFC" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xFC" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + Y = ÿ --> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0xFF" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0xFF" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Release shift to go upper-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Trema-Upper"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Trema-Upper"/> + </map> + + <!-- Abort operation: print ¨ --> + <map keycode="Space" pressed="true"> + <event keycode="B" unicode="0xA8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="B" unicode="0xA8" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +<!-- Trema Accentuated Upper-Case Characters: Ä, Ë... because we have released RShift but we are in Caps --> +<state name="RShift-Caps-Trema-Upper"> + <!-- Caps + RS + (B) + A = Ä --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC4" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC4" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + E = Ë --> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0xCB" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0xCB" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + I = Ï --> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0xCF" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0xCF" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + O = Ö --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD6" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD6" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (B) + U = Ü --> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0xDC" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0xDC" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Simple shift second time goes Lower-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Trema"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Trema"/> + </map> + + <!-- Abort operation: print ¨ --> + <map keycode="Space" pressed="true"> + <event keycode="B" unicode="0xA8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="B" unicode="0xA8" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + + + +<!-- Tilde Upper-Case Characters: Ã, Ñ... because we still press Shift --> +<state name="RShift-Tilde"> + <!-- RS + (N) + A = à --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC3" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC3" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (N) + N = Ñ --> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="0xD1" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="0xD1" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (N) + O = Õ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD5" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD5" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Release shift to do lower-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Tilde-Lower"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Tilde-Lower"/> + </map> + + <!-- Abort operation: print ~ --> + <map keycode="Space" pressed="true"> + <event keycode="N" unicode="0x7E" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="N" unicode="0x7E" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Tilde Lower-Case Characters: ã, ñ, õ... because we have released RShift --> +<state name="RShift-Tilde-Lower"> + <!-- RS + (N) + A = ã --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE3" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE3" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (N) + N = ñ --> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="0xF1" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="0xF1" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (N) + O = õ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF5" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF5" pressed="false"/> + <next-state name="Normal"/> + </map> + + <!-- Simple shift second time goes Upper-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Tilde"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Tilde"/> + </map> + + <!-- Abort operation: print ¨ --> + <map keycode="Space" pressed="true"> + <event keycode="B" unicode="0xA8" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="B" unicode="0xA8" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Tilde Lower-Case Characters: ã, ñ, õ... because we still press Shift and we are in Caps --> +<state name="RShift-Caps-Tilde"> + <!-- Caps + RS + (N) + A = ã --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xE3" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xE3" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (N) + N = ñ --> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="0xF1" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="0xF1" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (N) + O = õ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xF5" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xF5" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Release shift to go upper-case --> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Tilde-Upper"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Tilde-Upper"/> + </map> + + <!-- Abort operation: print ~ --> + <map keycode="Space" pressed="true"> + <event keycode="N" unicode="0x7E" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="N" unicode="0x7E" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +<!-- Tilde Upper-Case Characters: Ã, Ñ, Õ... because we have released RShift but we are in Caps --> +<state name="RShift-Caps-Tilde-Upper"> + <!-- Caps + RS + (N) + A = à --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xC3" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xC3" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (N) + N = Ñ --> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="0xD1" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="0xD1" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (N) + O = Õ --> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0xD5" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0xD5" pressed="false" modifiers="Shift"/> + <next-state name="Caps"/> + </map> + + <!-- Simple shift second time goes Lower-Case --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Tilde"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Tilde"/> + </map> + + <!-- Abort operation: print ~ --> + <map keycode="Space" pressed="true"> + <event keycode="N" unicode="0x7E" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="N" unicode="0x7E" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + + + +<!-- Inversed Characters: ¡, ¿... --> +<state name="RShift-Inversed"> + <!-- RS + (I) + A = ¡ --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xA1" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xA1" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- RS + (I) + / = ¿ --> + <map keycode="Slash" pressed="true"> + <event keycode="Slash" unicode="0xBF" pressed="true" modifiers="Shift" autorepeat="true"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="0xBF" pressed="false" modifiers="Shift"/> + <next-state name="Normal"/> + </map> + + <!-- Shift has no action --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Inversed"/> + </map> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Inversed"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Inversed"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Inversed"/> + </map> + + <!-- Abort operation: print ¬ --> + <map keycode="Space" pressed="true"> + <event keycode="I" unicode="0xAC" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="I" unicode="0xAC" pressed="false"/> + <next-state name="Normal"/> + </map> +</state> + + +<!-- Inversed Characters: ¡, ¿... --> +<state name="RShift-Caps-Inversed"> + <!-- Caps + RS + (I) + A = ¡ --> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0xA1" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0xA1" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Caps + RS + (I) + / = ¿ --> + <map keycode="Slash" pressed="true"> + <event keycode="Slash" unicode="0xBF" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Slash" unicode="0xBF" pressed="false"/> + <next-state name="Caps"/> + </map> + + <!-- Shift has no effect --> + <map keycode="Right Shift" pressed="true"> + <next-state name="RShift-Caps-Inversed"/> + </map> + <map keycode="Right Shift" pressed="false"> + <next-state name="RShift-Caps-Inversed"/> + </map> + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="true" modifiers="Shift"/> + <next-state name="RShift-Caps-Inversed"/> + </map> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps-Inversed"/> + </map> + + <!-- Abort operation: print ¬ --> + <map keycode="Space" pressed="true"> + <event keycode="I" unicode="0xAC" pressed="true" autorepeat="false"/> + </map> + <map keycode="Space" pressed="false"> + <event keycode="I" unicode="0xAC" pressed="false"/> + <next-state name="Caps"/> + </map> +</state> + + +</keymap> diff --git a/share/zkb/ru.xml b/share/zkb/ru.xml new file mode 100644 index 0000000..f0cc214 --- a/dev/null +++ b/share/zkb/ru.xml @@ -0,0 +1,542 @@ +<keymap> + +<include file="common.xml"/> + +<state name="LShift-RShift" parent="common"/> +<state name="LShift-RShift-Caps" parent="common"/> + +<state name="LShift"> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="RShift"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0x44D" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="0x436" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0x44E" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0x44C" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0x44D" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="0x436" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0x44E" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0x44C" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift"/> + </map> +</state> + +<state name="LShift-Caps"> + <map keycode="Right Shift" pressed="true"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-Num"> + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="Num"/> + </map> + + <map keycode="Fn" pressed="true"> + <event keycode="F22" unicode="-1" modifiers="Control" pressed="true"/> + <next-state name="LShift-Fn-Num"/> + </map> +</state> + +<state name="RShift-Caps"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0x42D" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="0x416" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0x42E" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0x42C" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0x42D" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="0x416" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0x42E" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0x42C" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="true"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="LShift-RShift-Caps"/> + </map> +</state> + +<state name="LShift-RShift"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0x42D" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="0x416" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0x42E" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0x42C" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0x42D" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="0x416" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0x42E" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0x42C" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift"/> + </map> +</state> + +<state name="LShift-RShift-Caps"> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0x44D" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="0x436" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0x44E" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0x44C" pressed="true" autorepeat="true"/> + </map> + + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0x44D" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="0x436" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0x44E" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0x44C" pressed="false"/> + </map> + + <map keycode="Left Shift" pressed="false"> + <event keycode="Shift" unicode="-1" pressed="false"/> + <next-state name="RShift-Caps"/> + </map> + + <map keycode="Right Shift" pressed="false"> + <event keycode="Meta" unicode="-1" pressed="false"/> + <next-state name="LShift-Caps"/> + </map> +</state> + +<state name="upper-case"> + <map keycode="Apostrophe" pressed="true"> + <event keycode="QuoteDbl" unicode="34" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Semicolon" unicode="59" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Colon" unicode="58" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Question" unicode="63" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0x410" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="0x411" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="0x426" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="0x414" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0x415" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="0x424" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="0x413" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="0x425" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0x418" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="0x419" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="0x41A" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="0x41B" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="0x41C" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="0x41D" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0x41E" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="0x41F" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="0x42F" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="0x420" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="0x421" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="0x422" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0x423" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="0x412" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="0x428" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="0x427" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0x42B" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="0x417" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="QuoteDbl" unicode="34" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Semicolon" unicode="59" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Colon" unicode="58" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Question" unicode="63" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0x410" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="0x411" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="0x426" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="0x414" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0x415" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="0x424" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="0x413" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="0x425" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0x418" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="0x419" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="0x41A" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="0x41B" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="0x41C" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="0x41D" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0x41E" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="0x41F" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="0x42F" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="0x420" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="0x421" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="0x422" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0x423" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="0x412" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="0x428" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="0x427" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0x42B" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="0x417" pressed="false"/> + </map> +</state> + +<state name="lower-case"> + <map keycode="Apostrophe" pressed="true"> + <event keycode="QuoteDbl" unicode="34" pressed="true" autorepeat="true"/> + </map> + <map keycode="Comma" pressed="true"> + <event keycode="Semicolon" unicode="59" pressed="true" autorepeat="true"/> + </map> + <map keycode="Period" pressed="true"> + <event keycode="Colon" unicode="58" pressed="true" autorepeat="true"/> + </map> + <map keycode="Slash" pressed="true"> + <event keycode="Question" unicode="63" pressed="true" autorepeat="true"/> + </map> + <map keycode="A" pressed="true"> + <event keycode="A" unicode="0x430" pressed="true" autorepeat="true"/> + </map> + <map keycode="B" pressed="true"> + <event keycode="B" unicode="0x431" pressed="true" autorepeat="true"/> + </map> + <map keycode="C" pressed="true"> + <event keycode="C" unicode="0x446" pressed="true" autorepeat="true"/> + </map> + <map keycode="D" pressed="true"> + <event keycode="D" unicode="0x434" pressed="true" autorepeat="true"/> + </map> + <map keycode="E" pressed="true"> + <event keycode="E" unicode="0x435" pressed="true" autorepeat="true"/> + </map> + <map keycode="F" pressed="true"> + <event keycode="F" unicode="0x444" pressed="true" autorepeat="true"/> + </map> + <map keycode="G" pressed="true"> + <event keycode="G" unicode="0x433" pressed="true" autorepeat="true"/> + </map> + <map keycode="H" pressed="true"> + <event keycode="H" unicode="0x445" pressed="true" autorepeat="true"/> + </map> + <map keycode="I" pressed="true"> + <event keycode="I" unicode="0x438" pressed="true" autorepeat="true"/> + </map> + <map keycode="J" pressed="true"> + <event keycode="J" unicode="0x439" pressed="true" autorepeat="true"/> + </map> + <map keycode="K" pressed="true"> + <event keycode="K" unicode="0x43A" pressed="true" autorepeat="true"/> + </map> + <map keycode="L" pressed="true"> + <event keycode="L" unicode="0x43B" pressed="true" autorepeat="true"/> + </map> + <map keycode="M" pressed="true"> + <event keycode="M" unicode="0x43C" pressed="true" autorepeat="true"/> + </map> + <map keycode="N" pressed="true"> + <event keycode="N" unicode="0x43D" pressed="true" autorepeat="true"/> + </map> + <map keycode="O" pressed="true"> + <event keycode="O" unicode="0x43E" pressed="true" autorepeat="true"/> + </map> + <map keycode="P" pressed="true"> + <event keycode="P" unicode="0x43F" pressed="true" autorepeat="true"/> + </map> + <map keycode="Q" pressed="true"> + <event keycode="Q" unicode="0x44F" pressed="true" autorepeat="true"/> + </map> + <map keycode="R" pressed="true"> + <event keycode="R" unicode="0x440" pressed="true" autorepeat="true"/> + </map> + <map keycode="S" pressed="true"> + <event keycode="S" unicode="0x441" pressed="true" autorepeat="true"/> + </map> + <map keycode="T" pressed="true"> + <event keycode="T" unicode="0x442" pressed="true" autorepeat="true"/> + </map> + <map keycode="U" pressed="true"> + <event keycode="U" unicode="0x443" pressed="true" autorepeat="true"/> + </map> + <map keycode="V" pressed="true"> + <event keycode="V" unicode="0x432" pressed="true" autorepeat="true"/> + </map> + <map keycode="W" pressed="true"> + <event keycode="W" unicode="0x448" pressed="true" autorepeat="true"/> + </map> + <map keycode="X" pressed="true"> + <event keycode="X" unicode="0x447" pressed="true" autorepeat="true"/> + </map> + <map keycode="Y" pressed="true"> + <event keycode="Y" unicode="0x44B" pressed="true" autorepeat="true"/> + </map> + <map keycode="Z" pressed="true"> + <event keycode="Z" unicode="0x437" pressed="true" autorepeat="true"/> + </map> + <map keycode="Apostrophe" pressed="false"> + <event keycode="QuoteDbl" unicode="34" pressed="false"/> + </map> + <map keycode="Comma" pressed="false"> + <event keycode="Semicolon" unicode="59" pressed="false"/> + </map> + <map keycode="Period" pressed="false"> + <event keycode="Colon" unicode="58" pressed="false"/> + </map> + <map keycode="Slash" pressed="false"> + <event keycode="Question" unicode="63" pressed="false"/> + </map> + <map keycode="A" pressed="false"> + <event keycode="A" unicode="0x430" pressed="false"/> + </map> + <map keycode="B" pressed="false"> + <event keycode="B" unicode="0x431" pressed="false"/> + </map> + <map keycode="C" pressed="false"> + <event keycode="C" unicode="0x446" pressed="false"/> + </map> + <map keycode="D" pressed="false"> + <event keycode="D" unicode="0x434" pressed="false"/> + </map> + <map keycode="E" pressed="false"> + <event keycode="E" unicode="0x435" pressed="false"/> + </map> + <map keycode="F" pressed="false"> + <event keycode="F" unicode="0x444" pressed="false"/> + </map> + <map keycode="G" pressed="false"> + <event keycode="G" unicode="0x433" pressed="false"/> + </map> + <map keycode="H" pressed="false"> + <event keycode="H" unicode="0x445" pressed="false"/> + </map> + <map keycode="I" pressed="false"> + <event keycode="I" unicode="0x438" pressed="false"/> + </map> + <map keycode="J" pressed="false"> + <event keycode="J" unicode="0x439" pressed="false"/> + </map> + <map keycode="K" pressed="false"> + <event keycode="K" unicode="0x43A" pressed="false"/> + </map> + <map keycode="L" pressed="false"> + <event keycode="L" unicode="0x43B" pressed="false"/> + </map> + <map keycode="M" pressed="false"> + <event keycode="M" unicode="0x43C" pressed="false"/> + </map> + <map keycode="N" pressed="false"> + <event keycode="N" unicode="0x43D" pressed="false"/> + </map> + <map keycode="O" pressed="false"> + <event keycode="O" unicode="0x43E" pressed="false"/> + </map> + <map keycode="P" pressed="false"> + <event keycode="P" unicode="0x43F" pressed="false"/> + </map> + <map keycode="Q" pressed="false"> + <event keycode="Q" unicode="0x44F" pressed="false"/> + </map> + <map keycode="R" pressed="false"> + <event keycode="R" unicode="0x440" pressed="false"/> + </map> + <map keycode="S" pressed="false"> + <event keycode="S" unicode="0x441" pressed="false"/> + </map> + <map keycode="T" pressed="false"> + <event keycode="T" unicode="0x442" pressed="false"/> + </map> + <map keycode="U" pressed="false"> + <event keycode="U" unicode="0x443" pressed="false"/> + </map> + <map keycode="V" pressed="false"> + <event keycode="V" unicode="0x432" pressed="false"/> + </map> + <map keycode="W" pressed="false"> + <event keycode="W" unicode="0x448" pressed="false"/> + </map> + <map keycode="X" pressed="false"> + <event keycode="X" unicode="0x447" pressed="false"/> + </map> + <map keycode="Y" pressed="false"> + <event keycode="Y" unicode="0x44B" pressed="false"/> + </map> + <map keycode="Z" pressed="false"> + <event keycode="Z" unicode="0x437" pressed="false"/> + </map> +</state> + +</keymap> diff --git a/share/zkb/zkb.xml.sample b/share/zkb/zkb.xml.sample new file mode 100644 index 0000000..7fc07a9 --- a/dev/null +++ b/share/zkb/zkb.xml.sample @@ -0,0 +1,55 @@ +<keymap autorepeat-delay="400" autorepeat-period="80" author="keyzcfg"> + <label name="EN" state="km0:*"/> + <label name="BG" state="km1:*"/> + <include file="en.xml" prefix="km0"/> + <include file="bg.xml" prefix="km1"/> + <state name="km0:LShift"> + <map keycode="Middle" pressed="true"> + <next-state name="km1:LShift"/> + </map> + </state> + + <state name="km0:LShift-Caps"> + <map keycode="Middle" pressed="true"> + <next-state name="km1:LShift-Caps"/> + </map> + </state> + + <state name="km0:LShift-Num"> + <map keycode="Middle" pressed="true"> + <next-state name="km1:LShift-Num"/> + </map> + </state> + + <state name="km0:LShift-Num-Caps"> + <map keycode="Middle" pressed="true"> + <next-state name="km1:LShift-Num-Caps"/> + </map> + </state> + + <state name="km1:LShift"> + <map keycode="Middle" pressed="true"> + <next-state name="km0:LShift"/> + </map> + </state> + + <state name="km1:LShift-Caps"> + <map keycode="Middle" pressed="true"> + <next-state name="km0:LShift-Caps"/> + </map> + </state> + + <state name="km1:LShift-Num"> + <map keycode="Middle" pressed="true"> + <next-state name="km0:LShift-Num"/> + </map> + </state> + + <state name="km1:LShift-Num-Caps"> + <map keycode="Middle" pressed="true"> + <next-state name="km0:LShift-Num-Caps"/> + </map> + </state> + + <state name="km0:Normal" default="true"/> +</keymap> diff --git a/share/zkb/zkb.xml.sample.num b/share/zkb/zkb.xml.sample.num new file mode 100644 index 0000000..667e6a5 --- a/dev/null +++ b/share/zkb/zkb.xml.sample.num @@ -0,0 +1,55 @@ +<keymap autorepeat-delay="400" autorepeat-period="80" author="keyzcfg"> + <label name="EN" state="km0:*"/> + <label name="BG" state="km1:*"/> + <include file="en.xml" prefix="km0"/> + <include file="bg.xml" prefix="km1"/> + <state name="km0:LShift"> + <map keycode="4173" pressed="true"> + <next-state name="km1:LShift"/> + </map> + </state> + + <state name="km0:LShift-Caps"> + <map keycode="4173" pressed="true"> + <next-state name="km1:LShift-Caps"/> + </map> + </state> + + <state name="km0:LShift-Num"> + <map keycode="4173" pressed="true"> + <next-state name="km1:LShift-Num"/> + </map> + </state> + + <state name="km0:LShift-Num-Caps"> + <map keycode="4173" pressed="true"> + <next-state name="km1:LShift-Num-Caps"/> + </map> + </state> + + <state name="km1:LShift"> + <map keycode="4173" pressed="true"> + <next-state name="km0:LShift"/> + </map> + </state> + + <state name="km1:LShift-Caps"> + <map keycode="4173" pressed="true"> + <next-state name="km0:LShift-Caps"/> + </map> + </state> + + <state name="km1:LShift-Num"> + <map keycode="4173" pressed="true"> + <next-state name="km0:LShift-Num"/> + </map> + </state> + + <state name="km1:LShift-Num-Caps"> + <map keycode="4173" pressed="true"> + <next-state name="km0:LShift-Num-Caps"/> + </map> + </state> + + <state name="km0:Normal" default="true"/> +</keymap>
\ No newline at end of file |
