/* * key.c - Key bindings configuration management * * Copyright © 2008 Julien Danjou * Copyright © 2008 Pierre Habouzit * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * */ /* XStringToKeysym() and XKeysymToString()*/ #include #include "structs.h" #include "common/xutil.h" #include "common/tokenize.h" LUA_OBJECT_FUNCS(keyb_t, key, "key") static void key_unref_simplified(keyb_t **b) { key_unref(globalconf.L, *b); } ARRAY_FUNCS(keyb_t *, key, key_unref_simplified) DO_LUA_TOSTRING(keyb_t, key, "key") /** Garbage collect a key. * \param L The Lua VM state. * \return 0. */ static int luaA_key_gc(lua_State *L) { keyb_t *kbp = luaL_checkudata(L, 1, "key"); luaL_unref(globalconf.L, LUA_REGISTRYINDEX, kbp->press); luaL_unref(globalconf.L, LUA_REGISTRYINDEX, kbp->release); return 0; } /** Grab key on a window. * \param win The window. * \param k The key. */ static void window_grabkey(xcb_window_t win, keyb_t *k) { if(k->keycode) xcb_grab_key(globalconf.connection, true, win, k->mod, k->keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); else if(k->keysym) { xcb_keycode_t *keycodes = xcb_key_symbols_get_keycode(globalconf.keysyms, k->keysym); if(keycodes) { for(xcb_keycode_t *kc = keycodes; *kc; kc++) xcb_grab_key(globalconf.connection, true, win, k->mod, *kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); p_delete(&keycodes); } } } void window_grabkeys(xcb_window_t win, key_array_t *keys) { foreach(k, *keys) window_grabkey(win, *k); } /** Return the keysym from keycode. * \param detail The keycode received. * \param state The modifier state. * \return A keysym. */ xcb_keysym_t key_getkeysym(xcb_keycode_t detail, uint16_t state) { xcb_keysym_t k0, k1; /* 'col' (third parameter) is used to get the proper KeySym * according to modifier (XCB doesn't provide an equivalent to * XLookupString()). * * If Mod5 is ON we look into second group. */ if(state & XCB_MOD_MASK_5) { k0 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 2); k1 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 3); } else { k0 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 0); k1 = xcb_key_symbols_get_keysym(globalconf.keysyms, detail, 1); } /* If the second column does not exists use the first one. */ if(k1 == XCB_NONE) k1 = k0; /* The numlock modifier is on and the second KeySym is a keypad * KeySym */ if((state & XCB_MOD_MASK_2) && xcb_is_keypad_key(k1)) { /* The Shift modifier is on, or if the Lock modifier is on and * is interpreted as ShiftLock, use the first KeySym */ if((state & XCB_MOD_MASK_SHIFT) || (state & XCB_MOD_MASK_LOCK)) return k0; else return k1; } /* The Shift and Lock modifers are both off, use the first * KeySym */ else if(!(state & XCB_MOD_MASK_SHIFT) && !(state & XCB_MOD_MASK_LOCK)) return k0; /* The Shift modifier is off and the Lock modifier is on and is * interpreted as CapsLock */ else if(!(state & XCB_MOD_MASK_SHIFT) && (state & XCB_MOD_MASK_LOCK)) /* The first Keysym is used but if that KeySym is lowercase * alphabetic, then the corresponding uppercase KeySym is used * instead */ return k1; /* The Shift modifier is on, and the Lock modifier is on and is * interpreted as CapsLock */ else if((state & XCB_MOD_MASK_SHIFT) && (state & XCB_MOD_MASK_LOCK)) /* The second Keysym is used but if that KeySym is lowercase * alphabetic, then the corresponding uppercase KeySym is used * instead */ return k1; /* The Shift modifer is on, or the Lock modifier is on and is * interpreted as ShiftLock, or both */ else if((state & XCB_MOD_MASK_SHIFT) || (state & XCB_MOD_MASK_LOCK)) return k1; return XCB_NO_SYMBOL; } static void luaA_keystore(keyb_t *key, const char *str, ssize_t len) { if(len) { if(*str != '#') { key->keysym = XStringToKeysym(str); if(!key->keysym) { if(len == 1) key->keysym = *str; else warn("there's no keysym named \"%s\"", str); } } else key->keycode = atoi(str + 1); } } /** Define a global key binding. This key binding will always be available. * \param L The Lua VM state. * * \luastack * \lparam A table with modifier keys: can be Control or Ctrl, Shift, Lock, * Mod1, Mod2, Mod3, Mod4, Mod5 or Any. * \lparam A key name. * \lparam A function to execute on key press. * \lparam A function to execute on key release. * \lreturn The key. */ static int luaA_key_new(lua_State *L) { size_t len; keyb_t *k; const char *key; luaA_ref press = LUA_REFNIL, release = LUA_REFNIL; /* arg 2 is key mod table */ luaA_checktable(L, 2); /* arg 3 is key */ key = luaL_checklstring(L, 3, &len); if(!lua_isnil(L, 4)) luaA_registerfct(L, 4, &press); if(lua_gettop(L) == 5 && !lua_isnil(L, 5)) luaA_registerfct(L, 5, &release); k = key_new(L); luaA_keystore(k, key, len); k->press = press; k->release = release; luaA_setmodifiers(L, 2, &k->mod); return 1; } /** Set a key array with a Lua table. * \param L The Lua VM state. * \param idx The index of the Lua table. * \param keys The array key to fill. */ void luaA_key_array_set(lua_State *L, int idx, key_array_t *keys) { luaA_checktable(L, idx); key_array_wipe(keys); key_array_init(keys); lua_pushnil(L); while(lua_next(L, idx)) key_array_append(keys, key_ref(L)); } /** Push an array of key as an Lua table onto the stack. * \param L The Lua VM state. * \param keys The key array to push. * \return The number of elements pushed on stack. */ int luaA_key_array_get(lua_State *L, key_array_t *keys) { lua_createtable(L, keys->len, 0); for(int i = 0; i < keys->len; i++) { key_push(L, keys->tab[i]); lua_rawseti(L, -2, i + 1); } return 1; } /** Push a modifier set to a Lua table. * \param L The Lua VM state. * \param mod The modifier. * \return The number of elements pushed on stack. */ int luaA_pushmodifiers(lua_State *L, uint16_t modifiers) { lua_newtable(L); { int i = 1; for(uint32_t maski = XCB_MOD_MASK_SHIFT; maski <= XCB_BUTTON_MASK_ANY; maski <<= 1) if(maski & modifiers) { const char *mod; size_t slen; xutil_key_mask_tostr(maski, &mod, &slen); lua_pushlstring(L, mod, slen); lua_rawseti(L, -2, i++); } } return 1; } /** Take a modifier table from the stack and set modifiers in mod. * \param L The Lua VM state. * \param ud The index of the table. * \param mod Where to set the modifiers. */ void luaA_setmodifiers(lua_State *L, int ud, uint16_t *mod) { luaA_checktable(L, ud); ssize_t len = lua_objlen(L, ud); for(int i = 1; i <= len; i++) { lua_rawgeti(L, ud, i); size_t blen; const char *key = luaL_checklstring(L, -1, &blen); *mod |= xutil_key_mask_fromstr(key, blen); lua_pop(L, 1); } } /** Key object. * \param L The Lua VM state. * \return The number of elements pushed on stack. * \luastack * \lfield key The key to press to triggers an event. * \lfield modifiers The modifier key that should be pressed while the key is * pressed. An array with all the modifiers. Valid modifiers are: Any, Mod1, * Mod2, Mod3, Mod4, Mod5, Shift, Lock and Control. * \lfield press The function which is called when the key combination is pressed. * \lfield release The function which is called when the key combination is released. */ static int luaA_key_index(lua_State *L) { size_t len; keyb_t *k = luaL_checkudata(L, 1, "key"); const char *attr = luaL_checklstring(L, 2, &len); if(luaA_usemetatable(L, 1, 2)) return 1; switch(a_tokenize(attr, len)) { case A_TK_KEY: if(k->keycode) { char buf[12]; int slen = snprintf(buf, sizeof(buf), "#%u", k->keycode); lua_pushlstring(L, buf, slen); } else lua_pushstring(L, XKeysymToString(k->keysym)); break; case A_TK_MODIFIERS: luaA_pushmodifiers(L, k->mod); break; case A_TK_PRESS: lua_rawgeti(L, LUA_REGISTRYINDEX, k->press); break; case A_TK_RELEASE: lua_rawgeti(L, LUA_REGISTRYINDEX, k->release); break; default: break; } return 1; } /** Key object newindex. * \param L The Lua VM state. * \return The number of elements pushed on stack. */ static int luaA_key_newindex(lua_State *L) { size_t len; keyb_t *k = luaL_checkudata(L, 1, "key"); const char *attr = luaL_checklstring(L, 2, &len); switch(a_tokenize(attr, len)) { case A_TK_KEY: { size_t klen; const char *key = luaL_checklstring(L, 3, &klen); luaA_keystore(k, key, klen); } break; case A_TK_MODIFIERS: luaA_setmodifiers(L, 3, &k->mod); break; case A_TK_PRESS: luaA_registerfct(L, 3, &k->press); break; case A_TK_RELEASE: luaA_registerfct(L, 3, &k->release); break; default: break; } return 0; } const struct luaL_reg awesome_key_methods[] = { { "__call", luaA_key_new }, { NULL, NULL } }; const struct luaL_reg awesome_key_meta[] = { { "__tostring", luaA_key_tostring }, { "__index", luaA_key_index }, { "__newindex", luaA_key_newindex }, { "__gc", luaA_key_gc }, { NULL, NULL }, };