key.c

   1 /*
   2  * key.c - Key bindings configuration management
   3  *
   4  * Copyright © 2008-2009 Julien Danjou <julien@danjou.info>
   5  * Copyright © 2008 Pierre Habouzit <madcoder@debian.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  */
  22
  23 /* XStringToKeysym() and XKeysymToString */
  24 #include <X11/Xlib.h>
  25
  26 /* XCB doesn't provide keysyms definition */
  27 #include <X11/keysym.h>
  28 #include <X11/XF86keysym.h>
  29
  30 #include "structs.h"
  31 #include "luaa.h"
  32 #include "common/xutil.h"
  33 #include "common/luaobject.h"
  34
  35 /** Grab key on a window.
  36  * \param win The window.
  37  * \param k The key.
  38  */
  39 static void
  40 window_grabkey(xcb_window_t win, keyb_t *k)
  41 {
  42     if(k->keycode)
  43         xcb_grab_key(globalconf.connection, true, win,
  44                      k->modifiers, k->keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
  45     else if(k->keysym)
  46     {
  47         xcb_keycode_t *keycodes = xcb_key_symbols_get_keycode(globalconf.keysyms, k->keysym);
  48         if(keycodes)
  49         {
  50             for(xcb_keycode_t *kc = keycodes; *kc; kc++)
  51                 xcb_grab_key(globalconf.connection, true, win,
  52                              k->modifiers, *kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
  53             p_delete(&keycodes);
  54         }
  55     }
  56 }
  57
  58 void
  59 window_grabkeys(xcb_window_t win, key_array_t *keys)
  60 {
  61     foreach(k, *keys)
  62         window_grabkey(win, *k);
  63 }
  64
  65 /** XCB equivalent of XLookupString which translate the keycode given
  66  * by PressEvent to a KeySym and a string
  67  * \todo use XKB!
  68  */
  69 static unsigned short const
  70 keysym_to_unicode_1a1_1ff[] =
  71 {
  72             0x0104, 0x02d8, 0x0141, 0x0000, 0x013d, 0x015a, 0x0000, /* 0x01a0-0x01a7 */
  73     0x0000, 0x0160, 0x015e, 0x0164, 0x0179, 0x0000, 0x017d, 0x017b, /* 0x01a8-0x01af */
  74     0x0000, 0x0105, 0x02db, 0x0142, 0x0000, 0x013e, 0x015b, 0x02c7, /* 0x01b0-0x01b7 */
  75     0x0000, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c, /* 0x01b8-0x01bf */
  76     0x0154, 0x0000, 0x0000, 0x0102, 0x0000, 0x0139, 0x0106, 0x0000, /* 0x01c0-0x01c7 */
  77     0x010c, 0x0000, 0x0118, 0x0000, 0x011a, 0x0000, 0x0000, 0x010e, /* 0x01c8-0x01cf */
  78     0x0110, 0x0143, 0x0147, 0x0000, 0x0000, 0x0150, 0x0000, 0x0000, /* 0x01d0-0x01d7 */
  79     0x0158, 0x016e, 0x0000, 0x0170, 0x0000, 0x0000, 0x0162, 0x0000, /* 0x01d8-0x01df */
  80     0x0155, 0x0000, 0x0000, 0x0103, 0x0000, 0x013a, 0x0107, 0x0000, /* 0x01e0-0x01e7 */
  81     0x010d, 0x0000, 0x0119, 0x0000, 0x011b, 0x0000, 0x0000, 0x010f, /* 0x01e8-0x01ef */
  82     0x0111, 0x0144, 0x0148, 0x0000, 0x0000, 0x0151, 0x0000, 0x0000, /* 0x01f0-0x01f7 */
  83     0x0159, 0x016f, 0x0000, 0x0171, 0x0000, 0x0000, 0x0163, 0x02d9  /* 0x01f8-0x01ff */
  84 };
  85
  86 static unsigned short const
  87 keysym_to_unicode_2a1_2fe[] =
  88 {
  89             0x0126, 0x0000, 0x0000, 0x0000, 0x0000, 0x0124, 0x0000, /* 0x02a0-0x02a7 */
  90     0x0000, 0x0130, 0x0000, 0x011e, 0x0134, 0x0000, 0x0000, 0x0000, /* 0x02a8-0x02af */
  91     0x0000, 0x0127, 0x0000, 0x0000, 0x0000, 0x0000, 0x0125, 0x0000, /* 0x02b0-0x02b7 */
  92     0x0000, 0x0131, 0x0000, 0x011f, 0x0135, 0x0000, 0x0000, 0x0000, /* 0x02b8-0x02bf */
  93     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x010a, 0x0108, 0x0000, /* 0x02c0-0x02c7 */
  94     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x02c8-0x02cf */
  95     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0120, 0x0000, 0x0000, /* 0x02d0-0x02d7 */
  96     0x011c, 0x0000, 0x0000, 0x0000, 0x0000, 0x016c, 0x015c, 0x0000, /* 0x02d8-0x02df */
  97     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x010b, 0x0109, 0x0000, /* 0x02e0-0x02e7 */
  98     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x02e8-0x02ef */
  99     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0121, 0x0000, 0x0000, /* 0x02f0-0x02f7 */
 100     0x011d, 0x0000, 0x0000, 0x0000, 0x0000, 0x016d, 0x015d          /* 0x02f8-0x02ff */
 101 };
 102
 103 static unsigned short const
 104 keysym_to_unicode_3a2_3fe[] =
 105 {
 106                     0x0138, 0x0156, 0x0000, 0x0128, 0x013b, 0x0000, /* 0x03a0-0x03a7 */
 107     0x0000, 0x0000, 0x0112, 0x0122, 0x0166, 0x0000, 0x0000, 0x0000, /* 0x03a8-0x03af */
 108     0x0000, 0x0000, 0x0000, 0x0157, 0x0000, 0x0129, 0x013c, 0x0000, /* 0x03b0-0x03b7 */
 109     0x0000, 0x0000, 0x0113, 0x0123, 0x0167, 0x014a, 0x0000, 0x014b, /* 0x03b8-0x03bf */
 110     0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x012e, /* 0x03c0-0x03c7 */
 111     0x0000, 0x0000, 0x0000, 0x0000, 0x0116, 0x0000, 0x0000, 0x012a, /* 0x03c8-0x03cf */
 112     0x0000, 0x0145, 0x014c, 0x0136, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x03d0-0x03d7 */
 113     0x0000, 0x0172, 0x0000, 0x0000, 0x0000, 0x0168, 0x016a, 0x0000, /* 0x03d8-0x03df */
 114     0x0101, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x012f, /* 0x03e0-0x03e7 */
 115     0x0000, 0x0000, 0x0000, 0x0000, 0x0117, 0x0000, 0x0000, 0x012b, /* 0x03e8-0x03ef */
 116     0x0000, 0x0146, 0x014d, 0x0137, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x03f0-0x03f7 */
 117     0x0000, 0x0173, 0x0000, 0x0000, 0x0000, 0x0169, 0x016b          /* 0x03f8-0x03ff */
 118 };
 119
 120 static unsigned short const
 121 keysym_to_unicode_4a1_4df[] =
 122 {
 123             0x3002, 0x3008, 0x3009, 0x3001, 0x30fb, 0x30f2, 0x30a1, /* 0x04a0-0x04a7 */
 124     0x30a3, 0x30a5, 0x30a7, 0x30a9, 0x30e3, 0x30e5, 0x30e7, 0x30c3, /* 0x04a8-0x04af */
 125     0x30fc, 0x30a2, 0x30a4, 0x30a6, 0x30a8, 0x30aa, 0x30ab, 0x30ad, /* 0x04b0-0x04b7 */
 126     0x30af, 0x30b1, 0x30b3, 0x30b5, 0x30b7, 0x30b9, 0x30bb, 0x30bd, /* 0x04b8-0x04bf */
 127     0x30bf, 0x30c1, 0x30c4, 0x30c6, 0x30c8, 0x30ca, 0x30cb, 0x30cc, /* 0x04c0-0x04c7 */
 128     0x30cd, 0x30ce, 0x30cf, 0x30d2, 0x30d5, 0x30d8, 0x30db, 0x30de, /* 0x04c8-0x04cf */
 129     0x30df, 0x30e0, 0x30e1, 0x30e2, 0x30e4, 0x30e6, 0x30e8, 0x30e9, /* 0x04d0-0x04d7 */
 130     0x30ea, 0x30eb, 0x30ec, 0x30ed, 0x30ef, 0x30f3, 0x309b, 0x309c  /* 0x04d8-0x04df */
 131 };
 132
 133 static unsigned short const
 134 keysym_to_unicode_590_5fe[] =
 135 {
 136     0x06f0, 0x06f1, 0x06f2, 0x06f3, 0x06f4, 0x06f5, 0x06f6, 0x06f7, /* 0x0590-0x0597 */
 137     0x06f8, 0x06f9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x0598-0x059f */
 138     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x066a, 0x0670, 0x0679, /* 0x05a0-0x05a7 */
 139
 140     0x067e, 0x0686, 0x0688, 0x0691, 0x060c, 0x0000, 0x06d4, 0x0000, /* 0x05ac-0x05af */
 141     0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667, /* 0x05b0-0x05b7 */
 142     0x0668, 0x0669, 0x0000, 0x061b, 0x0000, 0x0000, 0x0000, 0x061f, /* 0x05b8-0x05bf */
 143     0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, /* 0x05c0-0x05c7 */
 144     0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f, /* 0x05c8-0x05cf */
 145     0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, /* 0x05d0-0x05d7 */
 146     0x0638, 0x0639, 0x063a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x05d8-0x05df */
 147     0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, /* 0x05e0-0x05e7 */
 148     0x0648, 0x0649, 0x064a, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f, /* 0x05e8-0x05ef */
 149     0x0650, 0x0651, 0x0652, 0x0653, 0x0654, 0x0655, 0x0698, 0x06a4, /* 0x05f0-0x05f7 */
 150     0x06a9, 0x06af, 0x06ba, 0x06be, 0x06cc, 0x06d2, 0x06c1          /* 0x05f8-0x05fe */
 151 };
 152
 153 static unsigned short const
 154 keysym_to_unicode_680_6ff[] =
 155 {
 156     0x0492, 0x0496, 0x049a, 0x049c, 0x04a2, 0x04ae, 0x04b0, 0x04b2, /* 0x0680-0x0687 */
 157     0x04b6, 0x04b8, 0x04ba, 0x0000, 0x04d8, 0x04e2, 0x04e8, 0x04ee, /* 0x0688-0x068f */
 158     0x0493, 0x0497, 0x049b, 0x049d, 0x04a3, 0x04af, 0x04b1, 0x04b3, /* 0x0690-0x0697 */
 159     0x04b7, 0x04b9, 0x04bb, 0x0000, 0x04d9, 0x04e3, 0x04e9, 0x04ef, /* 0x0698-0x069f */
 160     0x0000, 0x0452, 0x0453, 0x0451, 0x0454, 0x0455, 0x0456, 0x0457, /* 0x06a0-0x06a7 */
 161     0x0458, 0x0459, 0x045a, 0x045b, 0x045c, 0x0491, 0x045e, 0x045f, /* 0x06a8-0x06af */
 162     0x2116, 0x0402, 0x0403, 0x0401, 0x0404, 0x0405, 0x0406, 0x0407, /* 0x06b0-0x06b7 */
 163     0x0408, 0x0409, 0x040a, 0x040b, 0x040c, 0x0490, 0x040e, 0x040f, /* 0x06b8-0x06bf */
 164     0x044e, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433, /* 0x06c0-0x06c7 */
 165     0x0445, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, /* 0x06c8-0x06cf */
 166     0x043f, 0x044f, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432, /* 0x06d0-0x06d7 */
 167     0x044c, 0x044b, 0x0437, 0x0448, 0x044d, 0x0449, 0x0447, 0x044a, /* 0x06d8-0x06df */
 168     0x042e, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413, /* 0x06e0-0x06e7 */
 169     0x0425, 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, /* 0x06e8-0x06ef */
 170     0x041f, 0x042f, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412, /* 0x06f0-0x06f7 */
 171     0x042c, 0x042b, 0x0417, 0x0428, 0x042d, 0x0429, 0x0427, 0x042a  /* 0x06f8-0x06ff */
 172 };
 173
 174 static unsigned short const
 175 keysym_to_unicode_7a1_7f9[] =
 176 {
 177             0x0386, 0x0388, 0x0389, 0x038a, 0x03aa, 0x0000, 0x038c, /* 0x07a0-0x07a7 */
 178     0x038e, 0x03ab, 0x0000, 0x038f, 0x0000, 0x0000, 0x0385, 0x2015, /* 0x07a8-0x07af */
 179     0x0000, 0x03ac, 0x03ad, 0x03ae, 0x03af, 0x03ca, 0x0390, 0x03cc, /* 0x07b0-0x07b7 */
 180     0x03cd, 0x03cb, 0x03b0, 0x03ce, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x07b8-0x07bf */
 181     0x0000, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, /* 0x07c0-0x07c7 */
 182     0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f, /* 0x07c8-0x07cf */
 183     0x03a0, 0x03a1, 0x03a3, 0x0000, 0x03a4, 0x03a5, 0x03a6, 0x03a7, /* 0x07d0-0x07d7 */
 184     0x03a8, 0x03a9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x07d8-0x07df */
 185     0x0000, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, /* 0x07e0-0x07e7 */
 186     0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, /* 0x07e8-0x07ef */
 187     0x03c0, 0x03c1, 0x03c3, 0x03c2, 0x03c4, 0x03c5, 0x03c6, 0x03c7, /* 0x07f0-0x07f7 */
 188     0x03c8, 0x03c9                                                  /* 0x07f8-0x07ff */
 189 };
 190
 191 static unsigned short const
 192 keysym_to_unicode_8a4_8fe[] =
 193 {
 194                                     0x2320, 0x2321, 0x0000, 0x231c, /* 0x08a0-0x08a7 */
 195     0x231d, 0x231e, 0x231f, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x08a8-0x08af */
 196     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x08b0-0x08b7 */
 197     0x0000, 0x0000, 0x0000, 0x0000, 0x2264, 0x2260, 0x2265, 0x222b, /* 0x08b8-0x08bf */
 198     0x2234, 0x0000, 0x221e, 0x0000, 0x0000, 0x2207, 0x0000, 0x0000, /* 0x08c0-0x08c7 */
 199     0x2245, 0x2246, 0x0000, 0x0000, 0x0000, 0x0000, 0x22a2, 0x0000, /* 0x08c8-0x08cf */
 200     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x221a, 0x0000, /* 0x08d0-0x08d7 */
 201     0x0000, 0x0000, 0x2282, 0x2283, 0x2229, 0x222a, 0x2227, 0x2228, /* 0x08d8-0x08df */
 202     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x08e0-0x08e7 */
 203     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x08e8-0x08ef */
 204     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0192, 0x0000, /* 0x08f0-0x08f7 */
 205     0x0000, 0x0000, 0x0000, 0x2190, 0x2191, 0x2192, 0x2193          /* 0x08f8-0x08ff */
 206 };
 207
 208 static unsigned short const
 209 keysym_to_unicode_9df_9f8[] =
 210 {
 211                                                             0x2422, /* 0x09d8-0x09df */
 212     0x2666, 0x25a6, 0x2409, 0x240c, 0x240d, 0x240a, 0x0000, 0x0000, /* 0x09e0-0x09e7 */
 213     0x240a, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x2500, /* 0x09e8-0x09ef */
 214     0x0000, 0x0000, 0x0000, 0x0000, 0x251c, 0x2524, 0x2534, 0x252c, /* 0x09f0-0x09f7 */
 215     0x2502                                                          /* 0x09f8-0x09ff */
 216 };
 217
 218 static unsigned short const
 219 keysym_to_unicode_aa1_afe[] =
 220 {
 221             0x2003, 0x2002, 0x2004, 0x2005, 0x2007, 0x2008, 0x2009, /* 0x0aa0-0x0aa7 */
 222     0x200a, 0x2014, 0x2013, 0x0000, 0x0000, 0x0000, 0x2026, 0x2025, /* 0x0aa8-0x0aaf */
 223     0x2153, 0x2154, 0x2155, 0x2156, 0x2157, 0x2158, 0x2159, 0x215a, /* 0x0ab0-0x0ab7 */
 224     0x2105, 0x0000, 0x0000, 0x2012, 0x2039, 0x2024, 0x203a, 0x0000, /* 0x0ab8-0x0abf */
 225     0x0000, 0x0000, 0x0000, 0x215b, 0x215c, 0x215d, 0x215e, 0x0000, /* 0x0ac0-0x0ac7 */
 226     0x0000, 0x2122, 0x2120, 0x0000, 0x25c1, 0x25b7, 0x25cb, 0x25ad, /* 0x0ac8-0x0acf */
 227     0x2018, 0x2019, 0x201c, 0x201d, 0x211e, 0x0000, 0x2032, 0x2033, /* 0x0ad0-0x0ad7 */
 228     0x0000, 0x271d, 0x0000, 0x220e, 0x25c2, 0x2023, 0x25cf, 0x25ac, /* 0x0ad8-0x0adf */
 229     0x25e6, 0x25ab, 0x25ae, 0x25b5, 0x25bf, 0x2606, 0x2022, 0x25aa, /* 0x0ae0-0x0ae7 */
 230     0x25b4, 0x25be, 0x261a, 0x261b, 0x2663, 0x2666, 0x2665, 0x0000, /* 0x0ae8-0x0aef */
 231     0x2720, 0x2020, 0x2021, 0x2713, 0x2612, 0x266f, 0x266d, 0x2642, /* 0x0af0-0x0af7 */
 232     0x2640, 0x2121, 0x2315, 0x2117, 0x2038, 0x201a, 0x201e          /* 0x0af8-0x0aff */
 233 };
 234
 235 /* none of the APL keysyms match the Unicode characters */
 236 static unsigned short const
 237 keysym_to_unicode_cdf_cfa[] =
 238 {
 239                                                             0x2017, /* 0x0cd8-0x0cdf */
 240     0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7, /* 0x0ce0-0x0ce7 */
 241     0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df, /* 0x0ce8-0x0cef */
 242     0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7, /* 0x0cf0-0x0cf7 */
 243     0x05e8, 0x05e9, 0x05ea                                          /* 0x0cf8-0x0cff */
 244 };
 245
 246 static unsigned short const
 247 keysym_to_unicode_da1_df9[] =
 248 {
 249             0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07, /* 0x0da0-0x0da7 */
 250     0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f, /* 0x0da8-0x0daf */
 251     0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17, /* 0x0db0-0x0db7 */
 252     0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f, /* 0x0db8-0x0dbf */
 253     0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27, /* 0x0dc0-0x0dc7 */
 254     0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f, /* 0x0dc8-0x0dcf */
 255     0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37, /* 0x0dd0-0x0dd7 */
 256     0x0e38, 0x0e39, 0x0e3a, 0x0000, 0x0000, 0x0000, 0x0e3e, 0x0e3f, /* 0x0dd8-0x0ddf */
 257     0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47, /* 0x0de0-0x0de7 */
 258     0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0000, 0x0000, /* 0x0de8-0x0def */
 259     0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57, /* 0x0df0-0x0df7 */
 260     0x0e58, 0x0e59                                                  /* 0x0df8-0x0dff */
 261 };
 262
 263 static unsigned short const
 264 keysym_to_unicode_ea0_eff[] =
 265 {
 266     0x0000, 0x1101, 0x1101, 0x11aa, 0x1102, 0x11ac, 0x11ad, 0x1103, /* 0x0ea0-0x0ea7 */
 267     0x1104, 0x1105, 0x11b0, 0x11b1, 0x11b2, 0x11b3, 0x11b4, 0x11b5, /* 0x0ea8-0x0eaf */
 268     0x11b6, 0x1106, 0x1107, 0x1108, 0x11b9, 0x1109, 0x110a, 0x110b, /* 0x0eb0-0x0eb7 */
 269     0x110c, 0x110d, 0x110e, 0x110f, 0x1110, 0x1111, 0x1112, 0x1161, /* 0x0eb8-0x0ebf */
 270     0x1162, 0x1163, 0x1164, 0x1165, 0x1166, 0x1167, 0x1168, 0x1169, /* 0x0ec0-0x0ec7 */
 271     0x116a, 0x116b, 0x116c, 0x116d, 0x116e, 0x116f, 0x1170, 0x1171, /* 0x0ec8-0x0ecf */
 272     0x1172, 0x1173, 0x1174, 0x1175, 0x11a8, 0x11a9, 0x11aa, 0x11ab, /* 0x0ed0-0x0ed7 */
 273     0x11ac, 0x11ad, 0x11ae, 0x11af, 0x11b0, 0x11b1, 0x11b2, 0x11b3, /* 0x0ed8-0x0edf */
 274     0x11b4, 0x11b5, 0x11b6, 0x11b7, 0x11b8, 0x11b9, 0x11ba, 0x11bb, /* 0x0ee0-0x0ee7 */
 275     0x11bc, 0x11bd, 0x11be, 0x11bf, 0x11c0, 0x11c1, 0x11c2, 0x0000, /* 0x0ee8-0x0eef */
 276     0x0000, 0x0000, 0x1140, 0x0000, 0x0000, 0x1159, 0x119e, 0x0000, /* 0x0ef0-0x0ef7 */
 277     0x11eb, 0x0000, 0x11f9, 0x0000, 0x0000, 0x0000, 0x0000, 0x20a9, /* 0x0ef8-0x0eff */
 278 };
 279
 280 static unsigned short const
 281 keysym_to_unicode_12a1_12fe[] =
 282 {
 283             0x1e02, 0x1e03, 0x0000, 0x0000, 0x0000, 0x1e0a, 0x0000, /* 0x12a0-0x12a7 */
 284     0x1e80, 0x0000, 0x1e82, 0x1e0b, 0x1ef2, 0x0000, 0x0000, 0x0000, /* 0x12a8-0x12af */
 285     0x1e1e, 0x1e1f, 0x0000, 0x0000, 0x1e40, 0x1e41, 0x0000, 0x1e56, /* 0x12b0-0x12b7 */
 286     0x1e81, 0x1e57, 0x1e83, 0x1e60, 0x1ef3, 0x1e84, 0x1e85, 0x1e61, /* 0x12b8-0x12bf */
 287     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x12c0-0x12c7 */
 288     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x12c8-0x12cf */
 289     0x0174, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1e6a, /* 0x12d0-0x12d7 */
 290     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0176, 0x0000, /* 0x12d8-0x12df */
 291     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x12e0-0x12e7 */
 292     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x12e8-0x12ef */
 293     0x0175, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1e6b, /* 0x12f0-0x12f7 */
 294     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0177          /* 0x12f0-0x12ff */
 295 };
 296
 297 static unsigned short const
 298 keysym_to_unicode_13bc_13be[] =
 299 {
 300                                     0x0152, 0x0153, 0x0178          /* 0x13b8-0x13bf */
 301 };
 302
 303 static unsigned short const
 304 keysym_to_unicode_14a1_14ff[] =
 305 {
 306             0x2741, 0x00a7, 0x0589, 0x0029, 0x0028, 0x00bb, 0x00ab, /* 0x14a0-0x14a7 */
 307     0x2014, 0x002e, 0x055d, 0x002c, 0x2013, 0x058a, 0x2026, 0x055c, /* 0x14a8-0x14af */
 308     0x055b, 0x055e, 0x0531, 0x0561, 0x0532, 0x0562, 0x0533, 0x0563, /* 0x14b0-0x14b7 */
 309     0x0534, 0x0564, 0x0535, 0x0565, 0x0536, 0x0566, 0x0537, 0x0567, /* 0x14b8-0x14bf */
 310     0x0538, 0x0568, 0x0539, 0x0569, 0x053a, 0x056a, 0x053b, 0x056b, /* 0x14c0-0x14c7 */
 311     0x053c, 0x056c, 0x053d, 0x056d, 0x053e, 0x056e, 0x053f, 0x056f, /* 0x14c8-0x14cf */
 312     0x0540, 0x0570, 0x0541, 0x0571, 0x0542, 0x0572, 0x0543, 0x0573, /* 0x14d0-0x14d7 */
 313     0x0544, 0x0574, 0x0545, 0x0575, 0x0546, 0x0576, 0x0547, 0x0577, /* 0x14d8-0x14df */
 314     0x0548, 0x0578, 0x0549, 0x0579, 0x054a, 0x057a, 0x054b, 0x057b, /* 0x14e0-0x14e7 */
 315     0x054c, 0x057c, 0x054d, 0x057d, 0x054e, 0x057e, 0x054f, 0x057f, /* 0x14e8-0x14ef */
 316     0x0550, 0x0580, 0x0551, 0x0581, 0x0552, 0x0582, 0x0553, 0x0583, /* 0x14f0-0x14f7 */
 317     0x0554, 0x0584, 0x0555, 0x0585, 0x0556, 0x0586, 0x2019, 0x0027, /* 0x14f8-0x14ff */
 318 };
 319
 320 static unsigned short const
 321 keysym_to_unicode_15d0_15f6[] =
 322 {
 323     0x10d0, 0x10d1, 0x10d2, 0x10d3, 0x10d4, 0x10d5, 0x10d6, 0x10d7, /* 0x15d0-0x15d7 */
 324     0x10d8, 0x10d9, 0x10da, 0x10db, 0x10dc, 0x10dd, 0x10de, 0x10df, /* 0x15d8-0x15df */
 325     0x10e0, 0x10e1, 0x10e2, 0x10e3, 0x10e4, 0x10e5, 0x10e6, 0x10e7, /* 0x15e0-0x15e7 */
 326     0x10e8, 0x10e9, 0x10ea, 0x10eb, 0x10ec, 0x10ed, 0x10ee, 0x10ef, /* 0x15e8-0x15ef */
 327     0x10f0, 0x10f1, 0x10f2, 0x10f3, 0x10f4, 0x10f5, 0x10f6          /* 0x15f0-0x15f7 */
 328 };
 329
 330 static unsigned short const
 331 keysym_to_unicode_16a0_16f6[] =
 332 {
 333     0x0000, 0x0000, 0xf0a2, 0x1e8a, 0x0000, 0xf0a5, 0x012c, 0xf0a7, /* 0x16a0-0x16a7 */
 334     0xf0a8, 0x01b5, 0x01e6, 0x0000, 0x0000, 0x0000, 0x0000, 0x019f, /* 0x16a8-0x16af */
 335     0x0000, 0x0000, 0xf0b2, 0x1e8b, 0x01d1, 0xf0b5, 0x012d, 0xf0b7, /* 0x16b0-0x16b7 */
 336     0xf0b8, 0x01b6, 0x01e7, 0x0000, 0x0000, 0x01d2, 0x0000, 0x0275, /* 0x16b8-0x16bf */
 337     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x018f, 0x0000, /* 0x16c0-0x16c7 */
 338     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x16c8-0x16cf */
 339     0x0000, 0x1e36, 0xf0d2, 0xf0d3, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x16d0-0x16d7 */
 340     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x16d8-0x16df */
 341     0x0000, 0x1e37, 0xf0e2, 0xf0e3, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x16e0-0x16e7 */
 342     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, /* 0x16e8-0x16ef */
 343     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0259          /* 0x16f0-0x16f6 */
 344 };
 345
 346 static unsigned short const
 347 keysym_to_unicode_1e9f_1eff[] =
 348 {
 349                                                             0x0303,
 350     0x1ea0, 0x1ea1, 0x1ea2, 0x1ea3, 0x1ea4, 0x1ea5, 0x1ea6, 0x1ea7, /* 0x1ea0-0x1ea7 */
 351     0x1ea8, 0x1ea9, 0x1eaa, 0x1eab, 0x1eac, 0x1ead, 0x1eae, 0x1eaf, /* 0x1ea8-0x1eaf */
 352     0x1eb0, 0x1eb1, 0x1eb2, 0x1eb3, 0x1eb4, 0x1eb5, 0x1eb6, 0x1eb7, /* 0x1eb0-0x1eb7 */
 353     0x1eb8, 0x1eb9, 0x1eba, 0x1ebb, 0x1ebc, 0x1ebd, 0x1ebe, 0x1ebf, /* 0x1eb8-0x1ebf */
 354     0x1ec0, 0x1ec1, 0x1ec2, 0x1ec3, 0x1ec4, 0x1ec5, 0x1ec6, 0x1ec7, /* 0x1ec0-0x1ec7 */
 355     0x1ec8, 0x1ec9, 0x1eca, 0x1ecb, 0x1ecc, 0x1ecd, 0x1ece, 0x1ecf, /* 0x1ec8-0x1ecf */
 356     0x1ed0, 0x1ed1, 0x1ed2, 0x1ed3, 0x1ed4, 0x1ed5, 0x1ed6, 0x1ed7, /* 0x1ed0-0x1ed7 */
 357     0x1ed8, 0x1ed9, 0x1eda, 0x1edb, 0x1edc, 0x1edd, 0x1ede, 0x1edf, /* 0x1ed8-0x1edf */
 358     0x1ee0, 0x1ee1, 0x1ee2, 0x1ee3, 0x1ee4, 0x1ee5, 0x1ee6, 0x1ee7, /* 0x1ee0-0x1ee7 */
 359     0x1ee8, 0x1ee9, 0x1eea, 0x1eeb, 0x1eec, 0x1eed, 0x1eee, 0x1eef, /* 0x1ee8-0x1eef */
 360     0x1ef0, 0x1ef1, 0x0300, 0x0301, 0x1ef4, 0x1ef5, 0x1ef6, 0x1ef7, /* 0x1ef0-0x1ef7 */
 361     0x1ef8, 0x1ef9, 0x01a0, 0x01a1, 0x01af, 0x01b0, 0x0309, 0x0323  /* 0x1ef8-0x1eff */
 362 };
 363
 364 static unsigned short const
 365 keysym_to_unicode_20a0_20ac[] =
 366 {
 367     0x20a0, 0x20a1, 0x20a2, 0x20a3, 0x20a4, 0x20a5, 0x20a6, 0x20a7, /* 0x20a0-0x20a7 */
 368     0x20a8, 0x20a9, 0x20aa, 0x20ab, 0x20ac                          /* 0x20a8-0x20af */
 369 };
 370
 371 static uint8_t const __utf8_mark[7] = {
 372     0x00, 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
 373 };
 374
 375 static int8_t const __utf32_clz_to_len[32] = {
 376     7,                  /* 0x80000000 */
 377     6, 6, 6, 6, 6,      /* 0x04000000 */
 378     5, 5, 5, 5, 5,      /* 0x00200000 */
 379     4, 4, 4, 4, 4,      /* 0x00010000 */
 380     3, 3, 3, 3, 3,      /* 0x00000800 */
 381     2, 2, 2, 2,         /* 0x00000080 */
 382     1, 1, 1, 1, 1, 1, 1 /* 0x00000001 */
 383 };
 384 #define utf8clen(c) __utf32_clz_to_len[__builtin_clz((uint32_t)(c) | 1)]
 385
 386 static bool
 387 keysym_to_utf8(char *buf, const xcb_keysym_t ksym)
 388 {
 389     unsigned int ksym_conv;
 390     int count;
 391
 392     /* Unicode keysym */
 393     if((ksym & 0xff000000) == 0x01000000)
 394         ksym_conv = ksym & 0x00ffffff;
 395     else if(ksym > 0 && ksym < 0x100)
 396         ksym_conv = ksym;
 397     else if(ksym > 0x1a0 && ksym < 0x200)
 398         ksym_conv = keysym_to_unicode_1a1_1ff[ksym - 0x1a1];
 399     else if(ksym > 0x2a0 && ksym < 0x2ff)
 400         ksym_conv = keysym_to_unicode_2a1_2fe[ksym - 0x2a1];
 401     else if(ksym > 0x3a1 && ksym < 0x3ff)
 402         ksym_conv = keysym_to_unicode_3a2_3fe[ksym - 0x3a2];
 403     else if(ksym > 0x4a0 && ksym < 0x4e0)
 404         ksym_conv = keysym_to_unicode_4a1_4df[ksym - 0x4a1];
 405     else if(ksym > 0x589 && ksym < 0x5ff)
 406         ksym_conv = keysym_to_unicode_590_5fe[ksym - 0x590];
 407     else if(ksym > 0x67f && ksym < 0x700)
 408         ksym_conv = keysym_to_unicode_680_6ff[ksym - 0x680];
 409     else if(ksym > 0x7a0 && ksym < 0x7fa)
 410         ksym_conv = keysym_to_unicode_7a1_7f9[ksym - 0x7a1];
 411     else if(ksym > 0x8a3 && ksym < 0x8ff)
 412         ksym_conv = keysym_to_unicode_8a4_8fe[ksym - 0x8a4];
 413     else if(ksym > 0x9de && ksym < 0x9f9)
 414         ksym_conv = keysym_to_unicode_9df_9f8[ksym - 0x9df];
 415     else if(ksym > 0xaa0 && ksym < 0xaff)
 416         ksym_conv = keysym_to_unicode_aa1_afe[ksym - 0xaa1];
 417     else if(ksym > 0xcde && ksym < 0xcfb)
 418         ksym_conv = keysym_to_unicode_cdf_cfa[ksym - 0xcdf];
 419     else if(ksym > 0xda0 && ksym < 0xdfa)
 420         ksym_conv = keysym_to_unicode_da1_df9[ksym - 0xda1];
 421     else if(ksym > 0xe9f && ksym < 0xf00)
 422         ksym_conv = keysym_to_unicode_ea0_eff[ksym - 0xea0];
 423     else if(ksym > 0x12a0 && ksym < 0x12ff)
 424         ksym_conv = keysym_to_unicode_12a1_12fe[ksym - 0x12a1];
 425     else if(ksym > 0x13bb && ksym < 0x13bf)
 426         ksym_conv = keysym_to_unicode_13bc_13be[ksym - 0x13bc];
 427     else if(ksym > 0x14a0 && ksym < 0x1500)
 428         ksym_conv = keysym_to_unicode_14a1_14ff[ksym - 0x14a1];
 429     else if(ksym > 0x15cf && ksym < 0x15f7)
 430         ksym_conv = keysym_to_unicode_15d0_15f6[ksym - 0x15d0];
 431     else if(ksym > 0x169f && ksym < 0x16f7)
 432         ksym_conv = keysym_to_unicode_16a0_16f6[ksym - 0x16a0];
 433     else if(ksym > 0x1e9e && ksym < 0x1f00)
 434         ksym_conv = keysym_to_unicode_1e9f_1eff[ksym - 0x1e9f];
 435     else if(ksym > 0x209f && ksym < 0x20ad)
 436         ksym_conv = keysym_to_unicode_20a0_20ac[ksym - 0x20a0];
 437     else
 438         return false;
 439
 440     count = utf8clen(ksym_conv);
 441     switch(count)
 442     {
 443       case 7: return false;
 444       case 6: buf[5] = (ksym_conv | 0x80) & 0xbf; ksym_conv >>= 6;
 445       case 5: buf[4] = (ksym_conv | 0x80) & 0xbf; ksym_conv >>= 6;
 446       case 4: buf[3] = (ksym_conv | 0x80) & 0xbf; ksym_conv >>= 6;
 447       case 3: buf[2] = (ksym_conv | 0x80) & 0xbf; ksym_conv >>= 6;
 448       case 2: buf[1] = (ksym_conv | 0x80) & 0xbf; ksym_conv >>= 6;
 449       case 1: buf[0] = (ksym_conv | __utf8_mark[count]);
 450     }
 451     buf[count] = '\0';
 452     return true;
 453 }
 454
 455 static bool
 456 keysym_to_str(char *buf, ssize_t len, const xcb_keysym_t ksym)
 457 {
 458     switch(ksym)
 459     {
 460 #define CASE(k)  case XK_##k: a_strcpy(buf, len, #k); return true
 461         CASE(BackSpace);
 462         CASE(Tab);
 463         CASE(Clear);
 464         CASE(Return);
 465         CASE(Pause);
 466         CASE(Scroll_Lock);
 467         CASE(Sys_Req);
 468         CASE(Escape);
 469         CASE(Delete);
 470
 471         CASE(Home);
 472         CASE(Left);
 473         CASE(Up);
 474         CASE(Right);
 475         CASE(Down);
 476         CASE(Page_Up);
 477         CASE(Page_Down);
 478         CASE(End);
 479         CASE(Begin);
 480
 481         CASE(Select);
 482         CASE(Print);
 483         CASE(Execute);
 484         CASE(Insert);
 485         CASE(Undo);
 486         CASE(Redo);
 487         CASE(Menu);
 488         CASE(Find);
 489         CASE(Cancel);
 490         CASE(Help);
 491         CASE(Break);
 492         CASE(Mode_switch);
 493         CASE(Num_Lock);
 494
 495       case XK_KP_Space:
 496         /* Patch encoding botch */
 497         buf[0] = XK_space & 0x7F;
 498         break;
 499         CASE(KP_Tab);
 500         CASE(KP_Enter);
 501         CASE(KP_F1);
 502         CASE(KP_F2);
 503         CASE(KP_F3);
 504         CASE(KP_F4);
 505         CASE(KP_Home);
 506         CASE(KP_Left);
 507         CASE(KP_Up);
 508         CASE(KP_Right);
 509         CASE(KP_Down);
 510         CASE(KP_Page_Up);
 511         CASE(KP_Page_Down);
 512         CASE(KP_End);
 513         CASE(KP_Begin);
 514         CASE(KP_Insert);
 515         CASE(KP_Delete);
 516         CASE(KP_Separator);
 517
 518         CASE(F1);  CASE(F2);  CASE(F3);  CASE(F4);  CASE(F5);  CASE(F6);
 519         CASE(F7);  CASE(F8);  CASE(F9);  CASE(F10); CASE(F11); CASE(F12);
 520         CASE(F13); CASE(F14); CASE(F15); CASE(F16); CASE(F17); CASE(F18);
 521         CASE(F19); CASE(F20); CASE(F21); CASE(F22); CASE(F23); CASE(F24);
 522         CASE(F25); CASE(F26); CASE(F27); CASE(F28); CASE(F29); CASE(F30);
 523         CASE(F31); CASE(F32); CASE(F33); CASE(F34); CASE(F35);
 524
 525         CASE(Shift_L);
 526         CASE(Shift_R);
 527         CASE(Control_L);
 528         CASE(Control_R);
 529         CASE(Caps_Lock);
 530         CASE(Shift_Lock);
 531
 532         CASE(Meta_L);
 533         CASE(Meta_R);
 534         CASE(Alt_L);
 535         CASE(Alt_R);
 536         CASE(Super_L);
 537         CASE(Super_R);
 538         CASE(Hyper_L);
 539         CASE(Hyper_R);
 540       default:
 541         buf[0] = ksym & 0x7F;
 542         break;
 543     }
 544
 545     buf[1] = '\0';
 546     return true;
 547 }
 548
 549 static bool
 550 keysym_to_xkb(char *buf, ssize_t len, const xcb_keysym_t ksym)
 551 {
 552     switch(ksym)
 553     {
 554         CASE(ISO_Lock);
 555         CASE(ISO_Level2_Latch);
 556         CASE(ISO_Level3_Shift);
 557         CASE(ISO_Level3_Latch);
 558         CASE(ISO_Level3_Lock);
 559         CASE(ISO_Level5_Shift);
 560         CASE(ISO_Level5_Latch);
 561         CASE(ISO_Level5_Lock);
 562         CASE(ISO_Group_Shift);
 563         CASE(ISO_Group_Latch);
 564         CASE(ISO_Group_Lock);
 565         CASE(ISO_Next_Group);
 566         CASE(ISO_Next_Group_Lock);
 567         CASE(ISO_Prev_Group);
 568         CASE(ISO_Prev_Group_Lock);
 569         CASE(ISO_First_Group);
 570         CASE(ISO_First_Group_Lock);
 571         CASE(ISO_Last_Group);
 572         CASE(ISO_Last_Group_Lock);
 573         CASE(ISO_Left_Tab);
 574         CASE(ISO_Move_Line_Up);
 575         CASE(ISO_Move_Line_Down);
 576         CASE(ISO_Partial_Line_Up);
 577         CASE(ISO_Partial_Line_Down);
 578         CASE(ISO_Partial_Space_Left);
 579         CASE(ISO_Partial_Space_Right);
 580         CASE(ISO_Set_Margin_Left);
 581         CASE(ISO_Set_Margin_Right);
 582         CASE(ISO_Release_Margin_Left);
 583         CASE(ISO_Release_Margin_Right);
 584         CASE(ISO_Release_Both_Margins);
 585         CASE(ISO_Fast_Cursor_Left);
 586         CASE(ISO_Fast_Cursor_Right);
 587         CASE(ISO_Fast_Cursor_Up);
 588         CASE(ISO_Fast_Cursor_Down);
 589         CASE(ISO_Continuous_Underline);
 590         CASE(ISO_Discontinuous_Underline);
 591         CASE(ISO_Emphasize);
 592         CASE(ISO_Center_Object);
 593         CASE(ISO_Enter);
 594         CASE(dead_grave);
 595         CASE(dead_acute);
 596         CASE(dead_circumflex);
 597         CASE(dead_tilde);
 598         CASE(dead_macron);
 599         CASE(dead_breve);
 600         CASE(dead_abovedot);
 601         CASE(dead_diaeresis);
 602         CASE(dead_abovering);
 603         CASE(dead_doubleacute);
 604         CASE(dead_caron);
 605         CASE(dead_cedilla);
 606         CASE(dead_ogonek);
 607         CASE(dead_iota);
 608         CASE(dead_voiced_sound);
 609         CASE(dead_semivoiced_sound);
 610         CASE(dead_belowdot);
 611         CASE(dead_hook);
 612         CASE(dead_horn);
 613         CASE(dead_stroke);
 614         CASE(dead_abovecomma);
 615         CASE(dead_abovereversedcomma);
 616         CASE(dead_doublegrave);
 617         CASE(dead_belowring);
 618         CASE(dead_belowmacron);
 619         CASE(dead_belowcircumflex);
 620         CASE(dead_belowtilde);
 621         CASE(dead_belowbreve);
 622         CASE(dead_belowdiaeresis);
 623         CASE(dead_invertedbreve);
 624         CASE(dead_belowcomma);
 625         CASE(dead_currency);
 626         CASE(dead_a);
 627         CASE(dead_A);
 628         CASE(dead_e);
 629         CASE(dead_E);
 630         CASE(dead_i);
 631         CASE(dead_I);
 632         CASE(dead_o);
 633         CASE(dead_O);
 634         CASE(dead_u);
 635         CASE(dead_U);
 636         CASE(dead_small_schwa);
 637         CASE(dead_capital_schwa);
 638         CASE(First_Virtual_Screen);
 639         CASE(Prev_Virtual_Screen);
 640         CASE(Next_Virtual_Screen);
 641         CASE(Last_Virtual_Screen);
 642         CASE(Terminate_Server);
 643         CASE(AccessX_Enable);
 644         CASE(AccessX_Feedback_Enable);
 645         CASE(RepeatKeys_Enable);
 646         CASE(SlowKeys_Enable);
 647         CASE(BounceKeys_Enable);
 648         CASE(StickyKeys_Enable);
 649         CASE(MouseKeys_Enable);
 650         CASE(MouseKeys_Accel_Enable);
 651         CASE(Overlay1_Enable);
 652         CASE(Overlay2_Enable);
 653         CASE(AudibleBell_Enable);
 654         CASE(Pointer_Left);
 655         CASE(Pointer_Right);
 656         CASE(Pointer_Up);
 657         CASE(Pointer_Down);
 658         CASE(Pointer_UpLeft);
 659         CASE(Pointer_UpRight);
 660         CASE(Pointer_DownLeft);
 661         CASE(Pointer_DownRight);
 662         CASE(Pointer_Button_Dflt);
 663         CASE(Pointer_Button1);
 664         CASE(Pointer_Button2);
 665         CASE(Pointer_Button3);
 666         CASE(Pointer_Button4);
 667         CASE(Pointer_Button5);
 668         CASE(Pointer_DblClick_Dflt);
 669         CASE(Pointer_DblClick1);
 670         CASE(Pointer_DblClick2);
 671         CASE(Pointer_DblClick3);
 672         CASE(Pointer_DblClick4);
 673         CASE(Pointer_DblClick5);
 674         CASE(Pointer_Drag_Dflt);
 675         CASE(Pointer_Drag1);
 676         CASE(Pointer_Drag2);
 677         CASE(Pointer_Drag3);
 678         CASE(Pointer_Drag4);
 679         CASE(Pointer_Drag5);
 680         CASE(Pointer_EnableKeys);
 681         CASE(Pointer_Accelerate);
 682         CASE(Pointer_DfltBtnNext);
 683         CASE(Pointer_DfltBtnPrev);
 684       default:
 685         return false;
 686     }
 687
 688     return true;
 689 }
 690 #undef CASE
 691
 692 static bool
 693 keysym_to_xf86(char *buf, ssize_t len, const xcb_keysym_t ksym)
 694 {
 695     switch(ksym)
 696     {
 697 #define CASE(k)  case XF86XK_##k: a_strcpy(buf, len, "XF86"); a_strcat(buf, len, #k); return true
 698         CASE(ModeLock);
 699         CASE(MonBrightnessUp);
 700         CASE(MonBrightnessDown);
 701         CASE(KbdLightOnOff);
 702         CASE(KbdBrightnessUp);
 703         CASE(KbdBrightnessDown);
 704         CASE(Standby);
 705         CASE(AudioLowerVolume);
 706         CASE(AudioMute);
 707         CASE(AudioRaiseVolume);
 708         CASE(AudioPlay);
 709         CASE(AudioStop);
 710         CASE(AudioPrev);
 711         CASE(AudioNext);
 712         CASE(HomePage);
 713         CASE(Mail);
 714         CASE(Start);
 715         CASE(Search);
 716         CASE(AudioRecord);
 717         CASE(Calculator);
 718         CASE(Memo);
 719         CASE(ToDoList);
 720         CASE(Calendar);
 721         CASE(PowerDown);
 722         CASE(ContrastAdjust);
 723         CASE(RockerUp);
 724         CASE(RockerDown);
 725         CASE(RockerEnter);
 726         CASE(Back);
 727         CASE(Forward);
 728         CASE(Stop);
 729         CASE(Refresh);
 730         CASE(PowerOff);
 731         CASE(WakeUp);
 732         CASE(Eject);
 733         CASE(ScreenSaver);
 734         CASE(WWW);
 735         CASE(Sleep);
 736         CASE(Favorites);
 737         CASE(AudioPause);
 738         CASE(AudioMedia);
 739         CASE(MyComputer);
 740         CASE(VendorHome);
 741         CASE(LightBulb);
 742         CASE(Shop);
 743         CASE(History);
 744         CASE(OpenURL);
 745         CASE(AddFavorite);
 746         CASE(HotLinks);
 747         CASE(BrightnessAdjust);
 748         CASE(Finance);
 749         CASE(Community);
 750         CASE(AudioRewind);
 751         CASE(BackForward);
 752         CASE(Launch0);
 753         CASE(Launch1);
 754         CASE(Launch2);
 755         CASE(Launch3);
 756         CASE(Launch4);
 757         CASE(Launch5);
 758         CASE(Launch6);
 759         CASE(Launch7);
 760         CASE(Launch8);
 761         CASE(Launch9);
 762         CASE(LaunchA);
 763         CASE(LaunchB);
 764         CASE(LaunchC);
 765         CASE(LaunchD);
 766         CASE(LaunchE);
 767         CASE(LaunchF);
 768         CASE(ApplicationLeft);
 769         CASE(ApplicationRight);
 770         CASE(Book);
 771         CASE(CD);
 772         CASE(Calculater);
 773         CASE(Clear);
 774         CASE(Close);
 775         CASE(Copy);
 776         CASE(Cut);
 777         CASE(Display);
 778         CASE(DOS);
 779         CASE(Documents);
 780         CASE(Excel);
 781         CASE(Explorer);
 782         CASE(Game);
 783         CASE(Go);
 784         CASE(iTouch);
 785         CASE(LogOff);
 786         CASE(Market);
 787         CASE(Meeting);
 788         CASE(MenuKB);
 789         CASE(MenuPB);
 790         CASE(MySites);
 791         CASE(New);
 792         CASE(News);
 793         CASE(OfficeHome);
 794         CASE(Open);
 795         CASE(Option);
 796         CASE(Paste);
 797         CASE(Phone);
 798         CASE(Q);
 799         CASE(Reply);
 800         CASE(Reload);
 801         CASE(RotateWindows);
 802         CASE(RotationPB);
 803         CASE(RotationKB);
 804         CASE(Save);
 805         CASE(ScrollUp);
 806         CASE(ScrollDown);
 807         CASE(ScrollClick);
 808         CASE(Send);
 809         CASE(Spell);
 810         CASE(SplitScreen);
 811         CASE(Support);
 812         CASE(TaskPane);
 813         CASE(Terminal);
 814         CASE(Tools);
 815         CASE(Travel);
 816         CASE(UserPB);
 817         CASE(User1KB);
 818         CASE(User2KB);
 819         CASE(Video);
 820         CASE(WheelButton);
 821         CASE(Word);
 822         CASE(Xfer);
 823         CASE(ZoomIn);
 824         CASE(ZoomOut);
 825         CASE(Away);
 826         CASE(Messenger);
 827         CASE(WebCam);
 828         CASE(MailForward);
 829         CASE(Pictures);
 830         CASE(Music);
 831         CASE(Battery);
 832         CASE(Bluetooth);
 833         CASE(WLAN);
 834         CASE(UWB);
 835         CASE(AudioForward);
 836         CASE(AudioRepeat);
 837         CASE(AudioRandomPlay);
 838         CASE(Subtitle);
 839         CASE(AudioCycleTrack);
 840         CASE(CycleAngle);
 841         CASE(FrameBack);
 842         CASE(FrameForward);
 843         CASE(Time);
 844         CASE(Select);
 845         CASE(View);
 846         CASE(TopMenu);
 847         CASE(Red);
 848         CASE(Green);
 849         CASE(Yellow);
 850         CASE(Blue);
 851         CASE(Suspend);
 852         CASE(Hibernate);
 853         CASE(Switch_VT_1);
 854         CASE(Switch_VT_2);
 855         CASE(Switch_VT_3);
 856         CASE(Switch_VT_4);
 857         CASE(Switch_VT_5);
 858         CASE(Switch_VT_6);
 859         CASE(Switch_VT_7);
 860         CASE(Switch_VT_8);
 861         CASE(Switch_VT_9);
 862         CASE(Switch_VT_10);
 863         CASE(Switch_VT_11);
 864         CASE(Switch_VT_12);
 865         CASE(Ungrab);
 866         CASE(ClearGrab);
 867         CASE(Next_VMode);
 868         CASE(Prev_VMode);
 869       default:
 870         return false;
 871     }
 872
 873     return true;
 874 }
 875 #undef CASE
 876
 877 bool
 878 key_press_lookup_string(xcb_keysym_t ksym,
 879                         char *buf, ssize_t buf_len)
 880 {
 881     /* Handle special KeySym (Tab, Newline...) */
 882     if((ksym & 0xffffff00) == 0xff00)
 883         return keysym_to_str(buf, buf_len, ksym);
 884     else if((ksym & 0xfffffe00) == 0xfe00)
 885         return keysym_to_xkb(buf, buf_len, ksym);
 886     else if((ksym & 0x1008F000) == 0x1008F000)
 887         return keysym_to_xf86(buf, buf_len, ksym);
 888
 889     /* Handle other KeySym (like unicode...) */
 890     return keysym_to_utf8(buf, ksym);
 891 }
 892
 893 /** Return the keysym from keycode.
 894  * \param detail The keycode received.
 895  * \param state The modifier state.
 896  * \return A keysym.
 897  */
 898 xcb_keysym_t
 899 key_getkeysym(xcb_keycode_t detail, uint16_t state)
 900 {
 901     xcb_keysym_t k0, k1;
 902
 903     /* 'col' (third parameter) is used to get the proper KeySym
 904      * according to modifier (XCB doesn't provide an equivalent to
 905      * XLookupString()).
 906      *
 907      * If Mode_Switch is ON we look into second group.
 908      */
 909     if(state & globalconf.modeswitchmask)
 910     {
 911         k0 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 2);
 912         k1 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 3);
 913     }
 914     else
 915     {
 916         k0 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 0);
 917         k1 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 1);
 918     }
 919
 920     /* If the second column does not exists use the first one. */
 921     if(k1 == XCB_NO_SYMBOL)
 922         k1 = k0;
 923
 924     /* The numlock modifier is on and the second KeySym is a keypad
 925      * KeySym */
 926     if((state & globalconf.numlockmask) && xcb_is_keypad_key(k1))
 927     {
 928         /* The Shift modifier is on, or if the Lock modifier is on and
 929          * is interpreted as ShiftLock, use the first KeySym */
 930         if((state & XCB_MOD_MASK_SHIFT)
 931            || (state & XCB_MOD_MASK_LOCK && (state & globalconf.shiftlockmask)))
 932             return k0;
 933         else
 934             return k1;
 935     }
 936
 937     /* The Shift and Lock modifers are both off, use the first
 938      * KeySym */
 939     else if(!(state & XCB_MOD_MASK_SHIFT) && !(state & XCB_MOD_MASK_LOCK))
 940         return k0;
 941
 942     /* The Shift modifier is off and the Lock modifier is on and is
 943      * interpreted as CapsLock */
 944     else if(!(state & XCB_MOD_MASK_SHIFT)
 945             && (state & XCB_MOD_MASK_LOCK && (state & globalconf.capslockmask)))
 946         /* The first Keysym is used but if that KeySym is lowercase
 947          * alphabetic, then the corresponding uppercase KeySym is used
 948          * instead */
 949         return k1;
 950
 951     /* The Shift modifier is on, and the Lock modifier is on and is
 952      * interpreted as CapsLock */
 953     else if((state & XCB_MOD_MASK_SHIFT)
 954             && (state & XCB_MOD_MASK_LOCK && (state & globalconf.capslockmask)))
 955         /* The second Keysym is used but if that KeySym is lowercase
 956          * alphabetic, then the corresponding uppercase KeySym is used
 957          * instead */
 958         return k1;
 959
 960     /* The Shift modifer is on, or the Lock modifier is on and is
 961      * interpreted as ShiftLock, or both */
 962     else if((state & XCB_MOD_MASK_SHIFT)
 963             || (state & XCB_MOD_MASK_LOCK && (state & globalconf.shiftlockmask)))
 964         return k1;
 965
 966     return XCB_NO_SYMBOL;
 967 }
 968
 969 static void
 970 luaA_keystore(lua_State *L, int ud, const char *str, ssize_t len)
 971 {
 972     keyb_t *key = luaA_checkudata(L, ud, &key_class);
 973     if(len)
 974     {
 975         if(*str != '#')
 976         {
 977             key->keysym = XStringToKeysym(str);
 978             if(!key->keysym)
 979             {
 980                 if(len == 1)
 981                     key->keysym = *str;
 982                 else
 983                     warn("there's no keysym named \"%s\"", str);
 984             }
 985             key->keycode = 0;
 986         }
 987         else
 988         {
 989             key->keycode = atoi(str + 1);
 990             key->keysym = 0;
 991         }
 992         luaA_object_emit_signal(L, ud, "property::key", 0);
 993     }
 994 }
 995
 996 /** Create a new key object.
 997  * \param L The Lua VM state.
 998  * \return The number of elements pushed on stack.
 999  */
1000 static int
1001 luaA_key_new(lua_State *L)
1002 {
1003     size_t len;
1004     keyb_t *k;
1005     const char *key;
1006
1007     /* compat code */
1008     if(lua_istable(L, 2) && lua_isstring(L, 3))
1009     {
1010         luaA_deprecate(L, "new syntax");
1011
1012         /* be sure there's 5 arguments */
1013         lua_settop(L, 5);
1014
1015         /* arg 2 is key mod table */
1016         luaA_checktable(L, 2);
1017         /* arg 3 is key */
1018         key = luaL_checklstring(L, 3, &len);
1019
1020         if(!lua_isnil(L, 4))
1021             luaA_checkfunction(L, 4);
1022
1023         if(!lua_isnil(L, 5))
1024             luaA_checkfunction(L, 5);
1025
1026         k = key_new(L);
1027         luaA_keystore(L, -1, key, len);
1028         k->modifiers = luaA_tomodifiers(L, 2);
1029
1030         if(!lua_isnil(L, 4))
1031         {
1032             lua_pushvalue(L, 4);
1033             luaA_object_add_signal(L, -2, "press", -1);
1034         }
1035
1036         if(!lua_isnil(L, 5))
1037         {
1038             lua_pushvalue(L, 5);
1039             luaA_object_add_signal(L, -2, "release", -1);
1040         }
1041
1042         return 1;
1043     }
1044
1045     return luaA_class_new(L, &key_class);
1046 }
1047
1048 /** Set a key array with a Lua table.
1049  * \param L The Lua VM state.
1050  * \param oidx The index of the object to store items into.
1051  * \param idx The index of the Lua table.
1052  * \param keys The array key to fill.
1053  */
1054 void
1055 luaA_key_array_set(lua_State *L, int oidx, int idx, key_array_t *keys)
1056 {
1057     luaA_checktable(L, idx);
1058
1059     foreach(key, *keys)
1060         luaA_object_unref_item(L, oidx, *key);
1061
1062     key_array_wipe(keys);
1063     key_array_init(keys);
1064
1065     lua_pushnil(L);
1066     while(lua_next(L, idx))
1067         if(luaA_toudata(L, -1, &key_class))
1068             key_array_append(keys, luaA_object_ref_item(L, oidx, -1));
1069         else
1070             lua_pop(L, 1);
1071 }
1072
1073 /** Push an array of key as an Lua table onto the stack.
1074  * \param L The Lua VM state.
1075  * \param oidx The index of the object to get items from.
1076  * \param keys The key array to push.
1077  * \return The number of elements pushed on stack.
1078  */
1079 int
1080 luaA_key_array_get(lua_State *L, int oidx, key_array_t *keys)
1081 {
1082     lua_createtable(L, keys->len, 0);
1083     for(int i = 0; i < keys->len; i++)
1084     {
1085         luaA_object_push_item(L, oidx, keys->tab[i]);
1086         lua_rawseti(L, -2, i + 1);
1087     }
1088     return 1;
1089 }
1090
1091 /** Push a modifier set to a Lua table.
1092  * \param L The Lua VM state.
1093  * \param modifiers The modifier.
1094  * \return The number of elements pushed on stack.
1095  */
1096 int
1097 luaA_pushmodifiers(lua_State *L, uint16_t modifiers)
1098 {
1099     lua_newtable(L);
1100     {
1101         int i = 1;
1102         for(uint32_t maski = XCB_MOD_MASK_SHIFT; maski <= XCB_BUTTON_MASK_ANY; maski <<= 1)
1103             if(maski & modifiers)
1104             {
1105                 const char *mod;
1106                 size_t slen;
1107                 xutil_key_mask_tostr(maski, &mod, &slen);
1108                 lua_pushlstring(L, mod, slen);
1109                 lua_rawseti(L, -2, i++);
1110             }
1111     }
1112     return 1;
1113 }
1114
1115 /** Take a modifier table from the stack and return modifiers mask.
1116  * \param L The Lua VM state.
1117  * \param ud The index of the table.
1118  * \return The mask value.
1119  */
1120 uint16_t
1121 luaA_tomodifiers(lua_State *L, int ud)
1122 {
1123     luaA_checktable(L, ud);
1124     ssize_t len = lua_objlen(L, ud);
1125     uint16_t mod = XCB_NONE;
1126     for(int i = 1; i <= len; i++)
1127     {
1128         lua_rawgeti(L, ud, i);
1129         size_t blen;
1130         const char *key = luaL_checklstring(L, -1, &blen);
1131         mod |= xutil_key_mask_fromstr(key, blen);
1132         lua_pop(L, 1);
1133     }
1134     return mod;
1135 }
1136
1137 static int
1138 luaA_key_set_modifiers(lua_State *L, keyb_t *k)
1139 {
1140     k->modifiers = luaA_tomodifiers(L, -1);
1141     luaA_object_emit_signal(L, -3, "property::modifiers", 0);
1142     return 0;
1143 }
1144
1145 LUA_OBJECT_EXPORT_PROPERTY(key, keyb_t, modifiers, luaA_pushmodifiers)
1146
1147 static int
1148 luaA_key_get_key(lua_State *L, keyb_t *k)
1149 {
1150     if(k->keycode)
1151     {
1152         char buf[12];
1153         int slen = snprintf(buf, sizeof(buf), "#%u", k->keycode);
1154         lua_pushlstring(L, buf, slen);
1155     }
1156     else
1157     {
1158         char buf[MAX(MB_LEN_MAX, 32)];
1159         if(!key_press_lookup_string(k->keysym, buf, countof(buf)))
1160             return 0;
1161
1162         lua_pushstring(L, buf);
1163     }
1164     return 1;
1165 }
1166
1167 static int
1168 luaA_key_get_keysym(lua_State *L, keyb_t *k)
1169 {
1170     lua_pushstring(L, XKeysymToString(k->keysym));
1171     return 1;
1172 }
1173
1174 static int
1175 luaA_key_set_key(lua_State *L, keyb_t *k)
1176 {
1177     size_t klen;
1178     const char *key = luaL_checklstring(L, -1, &klen);
1179     luaA_keystore(L, -3, key, klen);
1180     return 0;
1181 }
1182
1183 void
1184 key_class_setup(lua_State *L)
1185 {
1186     static const struct luaL_reg key_methods[] =
1187     {
1188         LUA_CLASS_METHODS(key)
1189         { "__call", luaA_key_new },
1190         { NULL, NULL }
1191     };
1192
1193     static const struct luaL_reg key_meta[] =
1194     {
1195         LUA_OBJECT_META(key)
1196         LUA_CLASS_META
1197         { "__gc", luaA_object_gc },
1198         { NULL, NULL },
1199     };
1200
1201     luaA_class_setup(L, &key_class, "key", (lua_class_allocator_t) key_new,
1202                      luaA_class_index_miss_property, luaA_class_newindex_miss_property,
1203                      key_methods, key_meta);
1204     luaA_class_add_property(&key_class, A_TK_KEY,
1205                             (lua_class_propfunc_t) luaA_key_set_key,
1206                             (lua_class_propfunc_t) luaA_key_get_key,
1207                             (lua_class_propfunc_t) luaA_key_set_key);
1208     luaA_class_add_property(&key_class, A_TK_KEYSYM,
1209                             NULL,
1210                             (lua_class_propfunc_t) luaA_key_get_keysym,
1211                             NULL);
1212     luaA_class_add_property(&key_class, A_TK_MODIFIERS,
1213                             (lua_class_propfunc_t) luaA_key_set_modifiers,
1214                             (lua_class_propfunc_t) luaA_key_get_modifiers,
1215                             (lua_class_propfunc_t) luaA_key_set_modifiers);
1216 }
1217
1218 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80