forgot remove some ifdefs

3 files changed, 0 insertions, 21 deletions

diff --git a/noncore/apps/keyz-cfg/zkbnames.cpp b/noncore/apps/keyz-cfg/zkbnames.cpp
index fec3a2e..c20a114 100644
--- a/noncore/apps/keyz-cfg/zkbnames.cpp
+++ b/noncore/apps/keyz-cfg/zkbnames.cpp
@@ -1,450 +1,447 @@
-#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
index 58462ff..0d1e7f5 100644
--- a/noncore/apps/keyz-cfg/zkbnames.h
+++ b/noncore/apps/keyz-cfg/zkbnames.h
@@ -1,27 +1,23 @@
 #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
index 76472cb..5b0084c 100644
--- a/noncore/apps/keyz-cfg/zkbxml.cpp
+++ b/noncore/apps/keyz-cfg/zkbxml.cpp
@@ -1,587 +1,573 @@
 #include "zkbxml.h"
 #include "zkbnames.h"
 
 static QString Keymap_Tag("keymap");
 static QString Include_Tag("include");
 static QString Label_Tag("label");
 static QString State_Tag("state");
 static QString Map_Tag("map");
 static QString Event_Tag("event");
 static QString NextState_Tag("next-state");
 
 ZkbXmlHandler::ZkbXmlHandler() {
 }
 
 ZkbXmlHandler::~ZkbXmlHandler() {
 }
 
 bool ZkbXmlHandler::startElement(const QString&, const QString&, 
         const QString& name, const QXmlAttributes& attr) {
 
         bool ret = false;
 
         if (name == Keymap_Tag) {
                 ret = start_keymap(attr);
         } else if (name == Include_Tag) {
                 ret = start_include(attr);
         } else if (name == Label_Tag) {
                 ret = start_label(attr);
         } else if (name == State_Tag) {
                 ret = start_state(attr);
         } else if (name == Map_Tag) {
                 ret = start_map(attr);
         } else if (name == Event_Tag) {
                 ret = start_event(attr);
         } else if (name == NextState_Tag) {
                 ret = start_next_state(attr);
         }
 
         elements.prepend(name);
 
         return ret;
 }
 
 bool ZkbXmlHandler::endElement(const QString&, const QString&, 
         const QString& name) {
 
         bool ret = false;
 
         elements.remove(elements.begin());
 
         if (name == Keymap_Tag) {
                 ret = end_keymap();
         } else if (name == Include_Tag) {
                 ret = end_include();
         } else if (name == Label_Tag) {
                 ret = end_label();
         } else if (name == State_Tag) {
                 ret = end_state();
         } else if (name == Map_Tag) {
                 ret = end_map();
         } else if (name == Event_Tag) {
                 ret = end_event();
         } else if (name == NextState_Tag) {
                 ret = end_next_state();
         }
 
         return ret;
 }
 
 QString ZkbXmlHandler::errorString() {
         return err;
 }
 
 bool ZkbXmlHandler::startKeymapElement(int ardelay, int arperiod, const QString& author) {
         return false;
 }
 
 bool ZkbXmlHandler::startIncludeElement(const QString& file, 
         const QString& prefix) {
 
         return false;
 }
 
 bool ZkbXmlHandler::startLabelElement(const QString& label, 
         const QString& state) {
 
         return false;
 }
 
 bool ZkbXmlHandler::startStateElement(const QString& name, 
         const QString& parent, bool dflt) {
 
         return false;
 }
 
 bool ZkbXmlHandler::startMapElement(int keycode, bool pressed) {
         return false;
 }
 
 bool ZkbXmlHandler::startEventElement(int keycode, int unicode, int modifiers, 
         bool pressed, bool autorepeat) {
 
         return false;
 }
 
 bool ZkbXmlHandler::startNextStateElement(const QString& state) {
         return false;
 }
 
 
 bool ZkbXmlHandler::endKeymapElement() {
         return false;
 }
 
 bool ZkbXmlHandler::endIncludeElement() {
         return false;
 }
 
 bool ZkbXmlHandler::endLabelElement() {
         return false;
 }
 
 bool ZkbXmlHandler::endStateElement() {
         return false;
 }
 
 bool ZkbXmlHandler::endMapElement() {
         return false;
 }
 
 bool ZkbXmlHandler::endEventElement() {
         return false;
 }
 
 bool ZkbXmlHandler::endNextStateElement() {
         return false;
 }
 
 
 bool ZkbXmlHandler::start_keymap(const QXmlAttributes& attr) {
         int nattr = 0;
         int didx = attr.index("autorepeat-delay");
         int pidx = attr.index("autorepeat-period");
         int aidx = attr.index("author");
         int ard = -1;
         int arp = -1;
         QString author;
 
         if (!elements.isEmpty()) {
                 setError("keymap element should be top-level element");
                 return false;
         }
 
         if (didx >= 0) {
                 QString s = attr.value(didx);
                 bool ok;
 
                 ard = s.toInt(&ok);
                 if (!ok) {
                         setError("Invalid autorepeat-delay value: " + s);
                         return false;
                 }
 
                 nattr++;
         }
 
         if (pidx >= 0) {
                 QString s = attr.value(pidx);
                 bool ok;
 
                 arp = s.toInt(&ok);
                 if (!ok) {
                         setError("Invalid autorepeat-period value: " + s);
                         return false;
                 }
 
                 nattr++;
         }
 
         if (aidx >= 0) {
                 author = attr.value(aidx);
                 nattr++;
         }
 
         if (attr.length() > nattr) {
                 setError("Unsupported attributes");
                 return false;
         }
 
         return startKeymapElement(ard, arp, author);
 }
 
 bool ZkbXmlHandler::start_include(const QXmlAttributes& attr) {
         int nattr = 0;
         int fidx = attr.index("file");
         int pidx = attr.index("prefix");
         QString file;
         QString prefix((const char*) 0);
 
         if (elements.first() != Keymap_Tag) {
                 setError("include element should be used only "
                         "within keymap element");
                 return false;
         }
 
         if (fidx >= 0) {
                 file = attr.value(fidx);
                 nattr++;
         } else {
                 setError("Missing file attribute");
                 return false;
         }
 
         if (pidx >= 0) {
                 prefix = attr.value(pidx);
                 nattr++;
         }
 
         if (attr.length() > nattr) {
                 setError("Unsupported attributes");
                 return false;
         }
 
         return startIncludeElement(file, prefix);
 }
 
 bool ZkbXmlHandler::start_label(const QXmlAttributes& attr) {
         int nattr = 0;
         int nidx = attr.index("name");
         int sidx = attr.index("state");
         QString name;
         QString state;
 
         if (elements.first() != Keymap_Tag) {
                 setError("label element should be used only "
                         "within keymap element");
                 return false;
         }
 
         if (nidx >= 0) {
                 name = attr.value(nidx);
                 nattr++;
         } else {
                 setError("Missing name attribute");
                 return false;
         }
 
         if (sidx >= 0) {
                 state = attr.value(sidx);
                 nattr++;
         } else {
                 setError("Missing name attribute");
                 return false;
         }
 
         if (attr.length() > nattr) {
                 setError("Unsupported attributes");
                 return false;
         }
 
         return startLabelElement(name, state);
 }
 
 bool ZkbXmlHandler::start_state(const QXmlAttributes& attr) {
         int nattr = 0;
         int nidx = attr.index("name");
         int pidx = attr.index("parent");
         int didx = attr.index("default");
         QString name;
         QString parent((const char*) 0);
         bool dflt = false;
 
         if (elements.first() != Keymap_Tag) {
                 setError("state element should be used only "
                         "within keymap element");
                 return false;
         }
 
         if (nidx >= 0) {
                 name = attr.value(nidx);
                 nattr++;
         } else {
                 setError("Missing name attribute");
                 return false;
         }
 
         if (pidx >= 0) {
                 parent = attr.value(pidx);
                 nattr++;
         }
 
         if (didx >= 0) {
                 dflt = str2bool(attr.value(didx));
                 if (!err.isEmpty()) {
                         return false;
                 }
 
                 nattr++;
         }
 
         if (attr.length() > nattr) {
                 setError("Unsupported attributes");
                 return false;
         }
 
         return startStateElement(name, parent, dflt);
 }
 
 bool ZkbXmlHandler::start_map(const QXmlAttributes& attr) {
         int nattr = 0;
         int kidx = attr.index("keycode");
         int pidx = attr.index("pressed");
         int key;
         bool pressed;
 
         if (elements.first() != State_Tag) {
                 setError("map element should be used only "
                         "within state element");
                 return false;
         }
 
         if (kidx >= 0) {
                 key = str2key(attr.value(kidx));
                 if (!err.isEmpty()) {
                         return false;
                 }
                 nattr++;
         } else {
                 setError("Missing keycode attribute");
                 return false;
         }
 
         if (pidx >= 0) {
                 pressed = str2bool(attr.value(pidx));
                 if (!err.isEmpty()) {
                         return false;
                 }
                 nattr++;
         } else {
                 setError("Missing pressed attribute");
                 return false;
         }
 
         if (attr.length() > nattr) {
                 setError("Unsupported attributes");
                 return false;
         }
 
         return startMapElement(key, pressed);
 }
 
 bool ZkbXmlHandler::start_event(const QXmlAttributes& attr) {
         int nattr = 0;
         int kidx = attr.index("keycode");
         int pidx = attr.index("pressed");
         int uidx = attr.index("unicode");
         int midx = attr.index("modifiers");
         int aidx = attr.index("autorepeat");
 
         int keycode;
         int unicode;
         int modifiers = 0;
         bool pressed;
         bool autorepeat = false;
 
         if (elements.first() != Map_Tag) {
                 setError("event element should be used only "
                         "within map element");
                 return false;
         }
 
         if (kidx >= 0) {
                 keycode = str2keycode(attr.value(kidx));
                 if (!err.isEmpty()) {
                         return false;
                 }
                 nattr++;
         } else {
                 setError("Missing keycode attribute");
                 return false;
         }
 
         if (uidx >= 0) {
                 unicode = str2unicode(attr.value(uidx));
                 if (!err.isEmpty()) {
                         return false;
                 }
                 nattr++;
         } else {
                 setError("Missing unicode attribute");
                 return false;
         }
 
         if (midx >= 0) {
                 modifiers = str2modifier(attr.value(midx));
                 if (!err.isEmpty()) {
                         return false;
                 }
                 nattr++;
         }
 
         if (pidx >= 0) {
                 pressed = str2bool(attr.value(pidx));
                 if (!err.isEmpty()) {
                         return false;
                 }
                 nattr++;
         } else {
                 setError("Missing pressed attribute");
                 return false;
         }
 
         if (aidx >= 0) {
                 autorepeat = str2bool(attr.value(aidx));
                 if (!err.isEmpty()) {
                         return false;
                 }
                 nattr++;
         }
 
         if (attr.length() > nattr) {
                 setError("Unsupported attributes");
                 return false;
         }
 
         return startEventElement(keycode, unicode, modifiers, pressed, 
                 autorepeat);
 }
 
 bool ZkbXmlHandler::start_next_state(const QXmlAttributes& attr) {
         int nattr = 0;
         int nidx = attr.index("name");
         QString name;
 
         if (elements.first() != Map_Tag) {
                 setError("next-state element should be used only "
                         "within map element");
                 return false;
         }
 
         if (nidx >= 0) {
                 name = attr.value(nidx);
                 nattr++;
         } else {
                 setError("Missing name attribute");
                 return false;
         }
 
         if (attr.length() > nattr) {
                 setError("Unsupported attributes");
                 return false;
         }
 
         return startNextStateElement(name);
 }
 
 bool ZkbXmlHandler::end_keymap() {
         return endKeymapElement();
 }
 
 bool ZkbXmlHandler::end_include() {
         return endIncludeElement();
 }
 
 bool ZkbXmlHandler::end_label() {
         return endLabelElement();
 }
 
 bool ZkbXmlHandler::end_state() {
         return endStateElement();
 }
 
 bool ZkbXmlHandler::end_map() {
         return endMapElement();
 }
 
 bool ZkbXmlHandler::end_event() {
         return endEventElement();
 }
 
 bool ZkbXmlHandler::end_next_state() {
         return endNextStateElement();
 }
 
 void ZkbXmlHandler::setError(const QString& e) {
         err = e;
 }
 
 int ZkbXmlHandler::str2key(const QString& s) {
         int ret;
 
-#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;
 }