awesomewm-mirrors
/
awesome
mirror of https://github.com/awesomeWM/awesome.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
awesome/common/xutil.c

612 lines
16 KiB
C
Raw Blame History

/*
* 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 name 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 conn The connection to the X server.
* \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
Reference in New Issue View Git Blame Copy Permalink