awesome/xkb.c

/*
 * xkb.c - keyboard layout control functions
 *
 * Copyright © 2015 Aleksey Fedotov <lexa@cfotr.com>
 *
 * 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.
 *
 */

/**
 * @module awesome
 */

#include "xkb.h"
#include "globalconf.h"
#include <xcb/xkb.h>
#include <xkbcommon/xkbcommon.h>
#include <xkbcommon/xkbcommon-x11.h>

/**
 * Switch keyboard layout.
 *
 * @function xkb_set_layout_group
 * @tparam integer num keyboard layout number, integer from 0 to 3
 */
int
luaA_xkb_set_layout_group(lua_State *L)
{
    unsigned group = luaL_checkinteger(L, 1);
    xcb_xkb_latch_lock_state (globalconf.connection, XCB_XKB_ID_USE_CORE_KBD,
                              0, 0, true, group, 0, 0, 0);
    return 0;
}

/**
 * Get current layout number.
 *
 * @function xkb_get_layout_group
 * @treturn integer num Current layout number, integer from 0 to 3.
 */
int
luaA_xkb_get_layout_group(lua_State *L)
{
    xcb_xkb_get_state_cookie_t state_c;
    state_c = xcb_xkb_get_state_unchecked (globalconf.connection,
                                           XCB_XKB_ID_USE_CORE_KBD);
    xcb_xkb_get_state_reply_t* state_r;
    state_r = xcb_xkb_get_state_reply (globalconf.connection,
                                       state_c, NULL);
    if (!state_r)
    {
        free(state_r);
        return 0;
    }
    lua_pushinteger(L, state_r->group);
    free(state_r);
    return 1;
}

/**
 * Get layout short names.
 *
 * @function xkb_get_group_names
 * @treturn string A string describing the current layout settings,
 *   e.g.: 'pc+us+de:2+inet(evdev)+group(alt_shift_toggle)+ctrl(nocaps)'
 */
int
luaA_xkb_get_group_names(lua_State *L)
{
    xcb_xkb_get_names_cookie_t name_c;
    name_c = xcb_xkb_get_names_unchecked (globalconf.connection,
                                          XCB_XKB_ID_USE_CORE_KBD,
                                          XCB_XKB_NAME_DETAIL_SYMBOLS);
    xcb_xkb_get_names_reply_t* name_r;
    name_r = xcb_xkb_get_names_reply (globalconf.connection, name_c, NULL);

    if (!name_r)
    {
        luaA_warn(L, "Failed to get xkb symbols name");
        return 0;
    }

    xcb_xkb_get_names_value_list_t name_list;
    void *buffer = xcb_xkb_get_names_value_list(name_r);
    xcb_xkb_get_names_value_list_unpack (
        buffer, name_r->nTypes, name_r->indicators,
        name_r->virtualMods, name_r->groupNames, name_r->nKeys,
        name_r->nKeyAliases, name_r->nRadioGroups, name_r->which,
        &name_list);

    xcb_get_atom_name_cookie_t atom_name_c;
    atom_name_c = xcb_get_atom_name_unchecked(globalconf.connection, name_list.symbolsName);
    xcb_get_atom_name_reply_t *atom_name_r;
    atom_name_r = xcb_get_atom_name_reply(globalconf.connection, atom_name_c, NULL);
    if (!atom_name_r) {
        luaA_warn(L, "Failed to get atom symbols name");
        free(name_r);
        return 0;
    }

    const char *name = xcb_get_atom_name_name(atom_name_r);
    size_t name_len = xcb_get_atom_name_name_length(atom_name_r);
    lua_pushlstring(L, name, name_len);

    free(atom_name_r);
    free(name_r);
    return 1;
}

/** Fill globalconf.xkb_state based on connection and context
*/
static void
xkb_fill_state(void)
{
    xcb_connection_t *conn = globalconf.connection;

    int32_t device_id = xkb_x11_get_core_keyboard_device_id(conn);
    if (device_id == -1)
        fatal("Failed while getting XKB device id");

    struct xkb_keymap *xkb_keymap = xkb_x11_keymap_new_from_device(
                                globalconf.xkb_ctx,
                                conn,
                                device_id,
                                XKB_KEYMAP_COMPILE_NO_FLAGS);


    if (!xkb_keymap)
        fatal("Failed while getting XKB keymap from device");

    globalconf.xkb_state = xkb_x11_state_new_from_device(xkb_keymap,
                                                         conn,
                                                         device_id);
    if (!globalconf.xkb_state)
        fatal("Failed while getting XKB state from device");

    /* xkb_keymap is no longer referenced directly; decreasing refcount */
    xkb_keymap_unref(xkb_keymap);
}


/** Loads xkb context, state and keymap to globalconf.
 * These variables should be freed by xkb_free_keymap() afterwards
*/
static void
xkb_init_keymap(void)
{
    globalconf.xkb_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
    if (!globalconf.xkb_ctx)
        fatal("Failed while getting XKB context");

    xkb_fill_state();
}

/** Frees xkb context, state and keymap from globalconf.
 * This should be used when these variables will not be used anymore
 */
static void
xkb_free_keymap(void)
{
    xkb_state_unref(globalconf.xkb_state);
    xkb_context_unref(globalconf.xkb_ctx);
}

/** Rereads the state of keyboard from X.
 * This call should be used after receiving NewKeyboardNotify or MapNotify,
 * as written in http://xkbcommon.org/doc/current/group__x11.html
 */
static void
xkb_reload_keymap(void)
{
    xkb_state_unref(globalconf.xkb_state);
    xkb_fill_state();
}

/** The xkb notify event handler.
 * \param event The event.
 */
void
event_handle_xkb_notify(xcb_generic_event_t* event)
{
    lua_State *L = globalconf_get_lua_State();

    /* The pad0 field of xcb_generic_event_t contains the event sub-type,
     * unfortunately xkb doesn't provide a usable struct for getting this in a
     * nicer way*/
    switch (event->pad0)
    {
      case XCB_XKB_NEW_KEYBOARD_NOTIFY:
        {
          xcb_xkb_new_keyboard_notify_event_t *new_keyboard_event = (void*)event;

          xkb_reload_keymap();

          if (new_keyboard_event->changed & XCB_XKB_NKN_DETAIL_KEYCODES)
          {
              signal_object_emit(L, &global_signals, "xkb::map_changed", 0);
          }
          break;
        }
      case XCB_XKB_MAP_NOTIFY:
        {
          xkb_reload_keymap();
          signal_object_emit(L, &global_signals, "xkb::map_changed", 0);
          break;
        }
      case XCB_XKB_STATE_NOTIFY:
        {
          xcb_xkb_state_notify_event_t *state_notify_event = (void*)event;

          xkb_state_update_mask(globalconf.xkb_state,
                                state_notify_event->baseMods,
                                state_notify_event->latchedMods,
                                state_notify_event->lockedMods,
                                state_notify_event->baseGroup,
                                state_notify_event->latchedGroup,
                                state_notify_event->lockedGroup);

          if (state_notify_event->changed & XCB_XKB_STATE_PART_GROUP_STATE)
          {
              lua_pushnumber(L, state_notify_event->group);
              signal_object_emit(L, &global_signals, "xkb::group_changed", 1);
          }

          break;
        }
    }
}

/** Initialize XKB support
 * This call allocates resources, that should be freed by calling xkb_free()
 */
void
xkb_init(void)
{

    int success_xkb = xkb_x11_setup_xkb_extension(globalconf.connection,
                                              XKB_X11_MIN_MAJOR_XKB_VERSION,
                                              XKB_X11_MIN_MINOR_XKB_VERSION,
                                              0,
                                              NULL,
                                              NULL,
                                              NULL,
                                              NULL);


    if (!success_xkb) {
        fatal("XKB not found or not supported");
    }

    uint16_t map = XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY;

    //
    // These maps are provided to allow key remapping,
    // that could be used in awesome
    //
    uint16_t map_parts = XCB_XKB_MAP_PART_KEY_TYPES |
                         XCB_XKB_MAP_PART_KEY_SYMS |
                         XCB_XKB_MAP_PART_MODIFIER_MAP |
                         XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
                         XCB_XKB_MAP_PART_KEY_ACTIONS |
                         XCB_XKB_MAP_PART_KEY_BEHAVIORS |
                         XCB_XKB_MAP_PART_VIRTUAL_MODS |
                         XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP;

    /* Enable detectable auto-repeat, but ignore failures */
    xcb_discard_reply(globalconf.connection,
            xcb_xkb_per_client_flags(globalconf.connection,
                                     XCB_XKB_ID_USE_CORE_KBD,
                                     XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT,
                                     XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT,
                                     0,
                                     0,
                                     0)
            .sequence);

    xcb_xkb_select_events(globalconf.connection,
                          XCB_XKB_ID_USE_CORE_KBD,
                          map,
                          0,
                          map,
                          map_parts,
                          map_parts,
                          0);

    /* load keymap to use when resolving keypresses */
    xkb_init_keymap();
}

/** Frees resources allocated by xkb_init()
 */
void
xkb_free(void)
{
    // unsubscribe from all events
    xcb_xkb_select_events(globalconf.connection,
                          XCB_XKB_ID_USE_CORE_KBD,
                          0,
                          0,
                          0,
                          0,
                          0,
                          0);
    xkb_free_keymap();
}