awesome/common/xutil.c

/*
 * common/xutil.c - X-related useful functions
 *
 * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
 *
 * 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.
 *
 */

/* asprintf() */
#define _GNU_SOURCE

#include <stdio.h>

#include <xcb/xcb.h>
#include <xcb/xcb_atom.h>

#include "common/util.h"
#include "common/xutil.h"

/** Get the string value of an atom.
 * \param conn X connection
 * \param w window
 * \param atoms atoms cache
 * \param atom the atom
 * \param text buffer to fill
 * \return true on sucess, falsse on failure
 */
bool
xutil_gettextprop(xcb_connection_t *conn, xcb_window_t w, xutil_atom_cache_t **atoms,
                  xcb_atom_t atom, char **text)
{
    xcb_get_property_cookie_t prop_c;
    xcb_get_property_reply_t *prop_r;
    void *prop_val;

    prop_c = xcb_get_property_unchecked(conn, false,
                                        w, atom,
                                        XCB_GET_PROPERTY_TYPE_ANY,
                                        0L, 1000000L);

    if(!text)
        return false;

    prop_r = xcb_get_property_reply(conn, prop_c, NULL);

    if(!prop_r || !prop_r->value_len || prop_r->format != 8)
    {
        p_delete(&prop_r);
        return false;
    }

    prop_val = xcb_get_property_value(prop_r);

    /* Check whether the returned property value is just an ascii
     * string or utf8 string.  At the moment it doesn't handle
     * COMPOUND_TEXT and multibyte but it's not needed...  */
    if(prop_r->type == STRING ||
       prop_r->type == xutil_intern_atom_reply(conn, atoms,
                                               xutil_intern_atom(conn, atoms,
                                                                 "UTF8_STRING")))
    {
        *text = p_new(char, prop_r->value_len + 1);
        /* use memcpy() because prop_val may not be \0 terminated */
        memcpy(*text, prop_val, prop_r->value_len);
        (*text)[prop_r->value_len] = '\0';
    }

    p_delete(&prop_r);

    return true;
}

void
xutil_getlockmask(xcb_connection_t *conn, xcb_key_symbols_t *keysyms,
                  unsigned int *numlockmask, unsigned int *shiftlockmask,
                  unsigned int *capslockmask)
{
    xcb_get_modifier_mapping_reply_t *modmap_r;
    xcb_keycode_t *modmap, kc;
    unsigned int mask;
    int i, j;

    modmap_r = xcb_get_modifier_mapping_reply(conn,
                                              xcb_get_modifier_mapping_unchecked(conn),
                                              NULL);

    modmap = xcb_get_modifier_mapping_keycodes(modmap_r);

    for(i = 0; i < 8; i++)
        for(j = 0; j < modmap_r->keycodes_per_modifier; j++)
        {
            kc = modmap[i * modmap_r->keycodes_per_modifier + j];
            mask = (1 << i);

            if(numlockmask != NULL
               && kc == xcb_key_symbols_get_keycode(keysyms, XK_Num_Lock))
                *numlockmask = mask;
            else if(shiftlockmask != NULL
                    && kc == xcb_key_symbols_get_keycode(keysyms, XK_Shift_Lock))
                *shiftlockmask = mask;
            else if(capslockmask != NULL
                    && kc == xcb_key_symbols_get_keycode(keysyms, XK_Caps_Lock))
                *capslockmask = mask;
        }

    p_delete(&modmap_r);
}

/** Equivalent to 'XGetTransientForHint' which is actually a
 * 'XGetWindowProperty' which gets the WM_TRANSIENT_FOR property of
 * the specified window
 * \param c X connection
 * \param win get the property from this window
 * \param prop_win returns the WM_TRANSIENT_FOR property of win
 * \return return true if successfull
 */
bool
xutil_get_transient_for_hint(xcb_connection_t *c, xcb_window_t win,
                             xcb_window_t *prop_win)
{
    xcb_get_property_reply_t *t_hint_r;

    /* Use checked because the error handler should not take care of
     * this error as we only return a boolean */
    t_hint_r = xcb_get_property_reply(c,
                                      xcb_get_property(c, false, win,
                                                       WM_TRANSIENT_FOR,
                                                       WINDOW, 0, 1),
                                      NULL);

    if(!t_hint_r || t_hint_r->type != WINDOW || t_hint_r->format != 32 ||
       t_hint_r->length == 0)
    {
        *prop_win = XCB_NONE;
        p_delete(&t_hint_r);
        return false;
    }

    *prop_win = *((xcb_window_t *) xcb_get_property_value(t_hint_r));
    p_delete(&t_hint_r);

    return true;
}

/** Send an unchecked InternAtom request if it is not already in the
 * cache, in the second case it stores the cache entry (an ordered
 * linked-list)
 * \param c X connection
 * \param atoms atoms cache
 * \param property atom name
 * \return a request structure
 */
xutil_intern_atom_request_t
xutil_intern_atom(xcb_connection_t *c, xutil_atom_cache_t **atoms,
                  const char *name)
{
    xutil_intern_atom_request_t atom_req;
    xutil_atom_cache_t *atom_next;
    int cmp_cache;

    atom_req.name = a_strdup(name);

    /* Check if this atom is present in the cache ordered
     * linked-list */
    for(atom_next = *atoms;
        atom_next && (cmp_cache = a_strcmp(name, atom_next->name)) >= 0;
        atom_next = atom_cache_list_next(NULL, atom_next))
        if(cmp_cache == 0)
        {
            atom_req.cache_hit = true;
            atom_req.cache = atom_next;
            return atom_req;
        }

    /* Otherwise send an InternAtom request to the server */
    atom_req.cache_hit = false;
    atom_req.cookie = xcb_intern_atom_unchecked(c, false, a_strlen(name),
                                                name);

    return atom_req;
}

/** Treat the reply which may be a cache entry or a reply from
 * InternAtom request (cookie), in the second case, add the atom to
 * the cache
 * \param c X connection
 * \param atoms atoms cache
 * \param atom_req atom request
 * \return a brand new xcb_atom_t
 */
xcb_atom_t
xutil_intern_atom_reply(xcb_connection_t *c, xutil_atom_cache_t **atoms,
                        xutil_intern_atom_request_t atom_req)
{
    xcb_intern_atom_reply_t *atom_rep;
    xutil_atom_cache_t *atom_cache, *atom_next;

    /* If the atom is present in the cache, just returns the
     * atom... */
    if(atom_req.cache_hit)
        return atom_req.cache->atom;

    /* Get the reply from InternAtom request */
    if(!(atom_rep = xcb_intern_atom_reply(c, atom_req.cookie, NULL)))
        return 0;

    /* Create a new atom cache entry */
    atom_cache = p_new(xutil_atom_cache_t, 1);
    atom_cache->atom = atom_rep->atom;
    atom_cache->name = atom_req.name;

    /* Add the entry in the list at the beginning of the cache list */
    if(*atoms == NULL || a_strcmp(atom_req.name, (*atoms)->name) < 0)
        atom_cache_list_push(atoms, atom_cache);
    /* Otherwise insert it at the proper position in the cache list
     * according to its name */
    else
    {
        for(atom_next = *atoms;
            atom_next && atom_next->next && a_strcmp(atom_req.name, atom_next->next->name) > 0;
            atom_next = atom_cache_list_next(NULL, atom_next));

        atom_cache_list_attach_after(atom_next, atom_cache);
    }

    p_delete(&atom_rep);

    return atom_cache->atom;
}

/* Delete a cache entry
 * \param entry cache entry
 */
void
xutil_atom_cache_delete(xutil_atom_cache_t **entry)
{
    p_delete(&(*entry)->name);
    p_delete(entry);
}

class_hint_t *
xutil_get_class_hint(xcb_connection_t *conn, xcb_window_t win)
{
    xcb_get_property_reply_t *class_hint_r;
    xcb_get_property_cookie_t class_hint_c;
    char *data;
    int len_name, len_class;
    class_hint_t *ch;

    class_hint_c = xcb_get_property_unchecked(conn, false, win, WM_CLASS,
                                              STRING, 0L, 2048L);
    ch = p_new(class_hint_t, 1);

    class_hint_r = xcb_get_property_reply(conn, class_hint_c, NULL);

    if(!class_hint_r
       || class_hint_r->type != STRING
       || class_hint_r->format != 8)
    {
        p_delete(&class_hint_r);
	return NULL;
    }

    data = xcb_get_property_value(class_hint_r);

    len_name = a_strlen(data);
    len_class = a_strlen(data + len_name + 1);

    ch->res_name = a_strndup(data, len_name);
    ch->res_class = a_strndup(data + len_name + 1, len_class);

    p_delete(&class_hint_r);

    return ch;
}

/* Number of different errors */
#define ERRORS_NBR 256

/* Number of different events */
#define EVENTS_NBR 126

void
xutil_set_error_handler_catch_all(xcb_event_handlers_t *evenths,
                                  xcb_generic_error_handler_t handler,
                                  void *data)
{
    int err_num;
    for(err_num = 0; err_num < ERRORS_NBR; err_num++)
	xcb_set_error_handler(evenths, err_num, handler, data);
}

const char *
xutil_error_label[] =
{
    "Success",
    "BadRequest",
    "BadValue",
    "BadWindow",
    "BadPixmap",
    "BadAtom",
    "BadCursor",
    "BadFont",
    "BadMatch",
    "BadDrawable",
    "BadAccess",
    "BadAlloc",
    "BadColor",
    "BadGC",
    "BadIDChoice",
    "BadName",
    "BadLength",
    "BadImplementation",
};

const char *
xutil_request_label[] =
{
    "None",
    "CreateWindow",
    "ChangeWindowAttributes",
    "GetWindowAttributes",
    "DestroyWindow",
    "DestroySubwindows",
    "ChangeSaveSet",
    "ReparentWindow",
    "MapWindow",
    "MapSubwindows",
    "UnmapWindow",
    "UnmapSubwindows",
    "ConfigureWindow",
    "CirculateWindow",
    "GetGeometry",
    "QueryTree",
    "InternAtom",
    "GetAtomName",
    "ChangeProperty",
    "DeleteProperty",
    "GetProperty",
    "ListProperties",
    "SetSelectionOwner",
    "GetSelectionOwner",
    "ConvertSelection",
    "SendEvent",
    "GrabPointer",
    "UngrabPointer",
    "GrabButton",
    "UngrabButton",
    "ChangeActivePointerGrab",
    "GrabKeyboard",
    "UngrabKeyboard",
    "GrabKey",
    "UngrabKey",
    "AllowEvents",
    "GrabServer",
    "UngrabServer",
    "QueryPointer",
    "GetMotionEvents",
    "TranslateCoords",
    "WarpPointer",
    "SetInputFocus",
    "GetInputFocus",
    "QueryKeymap",
    "OpenFont",
    "CloseFont",
    "QueryFont",
    "QueryTextExtents",
    "ListFonts",
    "ListFontsWithInfo",
    "SetFontPath",
    "GetFontPath",
    "CreatePixmap",
    "FreePixmap",
    "CreateGC",
    "ChangeGC",
    "CopyGC",
    "SetDashes",
    "SetClipRectangles",
    "FreeGC",
    "ClearArea",
    "CopyArea",
    "CopyPlane",
    "PolyPoint",
    "PolyLine",
    "PolySegment",
    "PolyRectangle",
    "PolyArc",
    "FillPoly",
    "PolyFillRectangle",
    "PolyFillArc",
    "PutImage",
    "GetImage",
    "PolyText",
    "PolyText",
    "ImageText",
    "ImageText",
    "CreateColormap",
    "FreeColormap",
    "CopyColormapAndFree",
    "InstallColormap",
    "UninstallColormap",
    "ListInstalledColormaps",
    "AllocColor",
    "AllocNamedColor",
    "AllocColorCells",
    "AllocColorPlanes",
    "FreeColors",
    "StoreColors",
    "StoreNamedColor",
    "QueryColors",
    "LookupColor",
    "CreateCursor",
    "CreateGlyphCursor",
    "FreeCursor",
    "RecolorCursor",
    "QueryBestSize",
    "QueryExtension",
    "ListExtensions",
    "ChangeKeyboardMapping",
    "GetKeyboardMapping",
    "ChangeKeyboardControl",
    "GetKeyboardControl",
    "Bell",
    "ChangePointerControl",
    "GetPointerControl",
    "SetScreenSaver",
    "GetScreenSaver",
    "ChangeHosts",
    "ListHosts",
    "SetAccessControl",
    "SetCloseDownMode",
    "KillClient",
    "RotateProperties",
    "ForceScreenSaver",
    "SetPointerMapping",
    "GetPointerMapping",
    "SetModifierMapping",
    "GetModifierMapping",
    "major 120",
    "major 121",
    "major 122",
    "major 123",
    "major 124",
    "major 125",
    "major 126",
    "NoOperation",
};

xutil_error_t *
xutil_get_error(const xcb_generic_error_t *e)
{
    if(e->response_type != 0)
        /* This is not an error, this _should_ not happen */
        return NULL;

    xutil_error_t *err = p_new(xutil_error_t, 1);

    /*
     * Get the request code,  taken from 'xcb-util/wm'. I can't figure
     * out  how it  works BTW,  seems to  get a  byte in  'pad' member
     * (second byte in second element of the array)
     */
    err->request_code = *((uint8_t *) e + 10);

    /* Extensions  generally provide  their  own requests  so we  just
     * store the request code */
    if(err->request_code >= (sizeof(xutil_request_label) / sizeof(char *)))
        asprintf(&err->request_label, "%d", err->request_code);
    else
        err->request_label = a_strdup(xutil_request_label[err->request_code]);

    /* Extensions may also define their  own errors, so just store the
     * error_code */
    if(e->error_code >= (sizeof(xutil_error_label) / sizeof(char *)))
        asprintf(&err->error_label, "%d", e->error_code);
    else
        err->error_label = a_strdup(xutil_error_label[e->error_code]);

    return err;
}

void
xutil_delete_error(xutil_error_t *err)
{
    p_delete(&err->error_label);
    p_delete(&err->request_label);
    p_delete(&err);
}

/** Link a name to a key symbol */
typedef struct
{
    const char *name;
    xcb_keysym_t keysym;
} keymod_t;

xcb_keysym_t
xutil_keymask_fromstr(const char *keyname)
{
    /** List of keyname and corresponding X11 mask codes */
    static const keymod_t KeyModList[] =
    {
        { "Shift", XCB_MOD_MASK_SHIFT },
        { "Lock", XCB_MOD_MASK_LOCK },
        { "Control", XCB_MOD_MASK_CONTROL },
        { "Ctrl", XCB_MOD_MASK_CONTROL },
        { "Mod1", XCB_MOD_MASK_1 },
        { "Mod2", XCB_MOD_MASK_2 },
        { "Mod3", XCB_MOD_MASK_3 },
        { "Mod4", XCB_MOD_MASK_4 },
        { "Mod5", XCB_MOD_MASK_5 },
        { NULL, XCB_NO_SYMBOL }
    };
    int i;

    if(keyname)
        for(i = 0; KeyModList[i].name; i++)
            if(!a_strcmp(keyname, KeyModList[i].name))
                 return KeyModList[i].keysym;

    return XCB_NO_SYMBOL;

}

/** Permit to use mouse with many more buttons */
#ifndef XCB_BUTTON_INDEX_6
#define XCB_BUTTON_INDEX_6 6
#endif
#ifndef XCB_BUTTON_INDEX_7
#define XCB_BUTTON_INDEX_7 7
#endif
#ifndef XCB_BUTTON_INDEX_8
#define XCB_BUTTON_INDEX_8 8
#endif
#ifndef XCB_BUTTON_INDEX_9
#define XCB_BUTTON_INDEX_9 9
#endif

/** Link a name to a mouse button symbol */
typedef struct
{
    int id;
    unsigned int button;
} mouse_button_t;

/** Lookup for a mouse button from its index.
 * \param button Mouse button index.
 * \return Mouse button or 0 if not found.
 */
unsigned int
xutil_button_fromint(int button)
{
    /** List of button name and corresponding X11 mask codes */
    static const mouse_button_t mouse_button_list[] =
    {
        { 1, XCB_BUTTON_INDEX_1 },
        { 2, XCB_BUTTON_INDEX_2 },
        { 3, XCB_BUTTON_INDEX_3 },
        { 4, XCB_BUTTON_INDEX_4 },
        { 5, XCB_BUTTON_INDEX_5 },
        { 6, XCB_BUTTON_INDEX_6 },
        { 7, XCB_BUTTON_INDEX_7 },
        { 8, XCB_BUTTON_INDEX_8 },
        { 9, XCB_BUTTON_INDEX_9 }
    };

    if(button >= 1 && button <= countof(mouse_button_list))
        return mouse_button_list[button - 1].button;

    return 0;
}

/** Equivalent to 'XCreateFontCursor()', error are handled by the
 * default current error handler.
 * \param cursor_font Type of cursor to use.
 * \return Allocated cursor font.
 */
xcb_cursor_t
xutil_cursor_new(xcb_connection_t *conn, unsigned int cursor_font)
{
    xcb_font_t font;
    xcb_cursor_t cursor;

    /* Get the font for the cursor*/
    font = xcb_generate_id(conn);
    xcb_open_font(conn, font, a_strlen("cursor"), "cursor");

    cursor = xcb_generate_id(conn);
    xcb_create_glyph_cursor(conn, cursor, font, font,
                            cursor_font, cursor_font + 1,
                            0, 0, 0,
                            65535, 65535, 65535);

    return cursor;
}

// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80