file modified to follow lua syntax, change suffix accordingly

[awesome.git] / key.c

/*
 * key.c - Key bindings configuration management
 *
 * Copyright © 2008 Julien Danjou <julien@danjou.info>
 * Copyright © 2008 Pierre Habouzit <madcoder@debian.org>
 *
 * 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 <X11/Xlib.h>

#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 Mode_Switch is ON we look into second group.
     */
    if(state & globalconf.modeswitchmask)
    {
        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_NO_SYMBOL)
        k1 = k0;

    /* The numlock modifier is on and the second KeySym is a keypad
     * KeySym */
    if((state & globalconf.numlockmask) && 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 && (state & globalconf.shiftlockmask)))
            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 && (state & globalconf.capslockmask)))
        /* 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 && (state & globalconf.capslockmask)))
        /* 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 && (state & globalconf.shiftlockmask)))
        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 },
};