* Copyright (c) 2011-2012 Reginald Kennedy <rk@rejii.com>
* Copyright (c) 2011-2012 Lawrence Teo <lteo@lteo.net>
* Copyright (c) 2011-2012 Tiago Cunha <tcunha@gmx.com>
+ * Copyright (c) 2012 David Hill <dhill@mindcry.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
#include <unistd.h>
#include <util.h>
#include <X11/cursorfont.h>
-#include <X11/keysym.h>
-#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
-#include <X11/extensions/XTest.h>
-#include <xcb/xcb.h>
+#include <X11/Xft/Xft.h>
+#include <X11/Xlib-xcb.h>
#include <xcb/xcb_atom.h>
#include <xcb/xcb_aux.h>
#include <xcb/xcb_event.h>
#define DNPRINTF(n,x...)
#endif
-#define LENGTH(x) (int)(sizeof x / sizeof x[0])
+/* convert 8-bit to 16-bit */
+#define RGB_8_TO_16(col) ((col) << 8) + (col)
+
+#define PIXEL_TO_XRENDERCOLOR(px, xrc) \
+ xrc.red = RGB_8_TO_16((px) >> 16 & 0xff); \
+ xrc.green = RGB_8_TO_16((px) >> 8 & 0xff); \
+ xrc.blue = RGB_8_TO_16((px) & 0xff); \
+ xrc.alpha = 0xffff;
+
+#define LENGTH(x) (int)(sizeof (x) / sizeof (x)[0])
#define MODKEY Mod1Mask
-#define CLEANMASK(mask) (mask & ~(numlockmask | LockMask))
+#define CLEANMASK(mask) ((mask) & ~(numlockmask | LockMask))
#define BUTTONMASK (ButtonPressMask|ButtonReleaseMask)
#define MOUSEMASK (BUTTONMASK|PointerMotionMask)
#define SWM_PROPLEN (16)
#define Y(r) (r)->g.y
#define WIDTH(r) (r)->g.w
#define HEIGHT(r) (r)->g.h
-#define BORDER(w) (w->bordered ? border_width : 0)
+#define BORDER(w) ((w)->bordered ? border_width : 0)
#define MAX_X(r) ((r)->g.x + (r)->g.w)
#define MAX_Y(r) ((r)->g.y + (r)->g.h)
#define SH_MIN(w) (w)->sh.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE
xcb_atom_t a_utf8_string;
xcb_atom_t a_string;
xcb_atom_t a_swm_iconic;
+xcb_atom_t a_swm_ws;
volatile sig_atomic_t running = 1;
volatile sig_atomic_t restart_wm = 0;
int outputs = 0;
int xrandr_support;
int xrandr_eventbase;
unsigned int numlockmask = 0;
+
+Display *display;
xcb_connection_t *conn;
xcb_key_symbols_t *syms;
int verbose_layout = 0;
time_t time_started;
pid_t bar_pid;
-#if 0
-XFontSet bar_fs;
-XFontSetExtents *bar_fs_extents;
-#endif
+XftFont *bar_font;
char *bar_fonts;
+XftColor bar_font_color;
struct passwd *pwd;
/* layout manager data */
/* colors */
struct {
- uint32_t color;
+ uint32_t pixel;
char *name;
} c[SWM_S_COLOR_MAX];
xcb_atom_t get_atom_from_string(const char *);
xcb_screen_t *get_screen(int);
char *get_win_name(xcb_window_t);
-uint16_t getstate(xcb_window_t);
+uint32_t getstate(xcb_window_t);
void grabbuttons(struct ws_win *, int);
void map_window_raised(xcb_window_t);
void new_region(struct swm_screen *, int, int, int, int);
void store_float_geom(struct ws_win *, struct swm_region *);
void unmanage_window(struct ws_win *);
void update_window(struct ws_win *);
+#ifdef SWM_DEBUG
+char *get_atom_name(xcb_atom_t);
+#endif
-/* function definitions */
int
parse_rgb(const char *rgb, uint16_t *rr, uint16_t *gg, uint16_t *bb)
{
if (sscanf(rgb, "rgb:%x/%x/%x", &tmpr, &tmpg, &tmpb) != 3)
return (-1);
- *rr = tmpr << 8;
- *gg = tmpg << 8;
- *bb = tmpb << 8;
+ *rr = RGB_8_TO_16(tmpr);
+ *gg = RGB_8_TO_16(tmpg);
+ *bb = RGB_8_TO_16(tmpb);
return (0);
}
xcb_intern_atom_reply_t *r;
xcb_atom_t atom;
- c = xcb_intern_atom(conn, False, strlen(str), str);
+ c = xcb_intern_atom(conn, 0, strlen(str), str);
r = xcb_intern_atom_reply(conn, c, NULL);
if (r) {
atom = r->atom;
update_iconic(struct ws_win *win, int newv)
{
int32_t v = newv;
- xcb_atom_t iprop;
win->iconic = newv;
- iprop = get_atom_from_string("_SWM_ICONIC");
- if (iprop == XCB_ATOM_NONE)
- return;
-
if (newv)
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id,
- iprop, XCB_ATOM_INTEGER, 32, 1, &v);
+ a_swm_iconic, XCB_ATOM_INTEGER, 32, 1, &v);
else
- xcb_delete_property(conn, win->id, iprop);
+ xcb_delete_property(conn, win->id, a_swm_iconic);
}
int32_t
get_iconic(struct ws_win *win)
{
int32_t v = 0;
- xcb_atom_t iprop;
xcb_get_property_reply_t *pr = NULL;
- iprop = get_atom_from_string("_SWM_ICONIC");
- if (iprop == XCB_ATOM_NONE)
- goto out;
pr = xcb_get_property_reply(conn,
- xcb_get_property(conn, False, win->id, iprop, XCB_ATOM_INTEGER,
- 0, 1), NULL);
+ xcb_get_property(conn, 0, win->id, a_swm_iconic,
+ XCB_ATOM_INTEGER, 0, 1), NULL);
if (!pr)
goto out;
if (pr->type != XCB_ATOM_INTEGER || pr->format != 32)
for (i = 0; i < num_screens; i++) {
/* Get the support check window and destroy it */
- pc = xcb_get_property(conn, False, screens[i].root, sup_check,
+ pc = xcb_get_property(conn, 0, screens[i].root, sup_check,
XCB_ATOM_WINDOW, 0, 1);
pr = xcb_get_property_reply(conn, pc, NULL);
- if (pr) {
+ if (!pr)
+ continue;
+ if (pr->format == sup_check) {
id = *((xcb_window_t *)xcb_get_property_value(pr));
xcb_destroy_window(conn, id);
xcb_delete_property(conn, screens[i].root, sup_check);
xcb_delete_property(conn, screens[i].root, sup_list);
-
- free(pr);
}
+ free(pr);
}
}
xcb_get_property_cookie_t c;
xcb_get_property_reply_t *r;
- c = xcb_get_property(conn, False, win->id,
+ c = xcb_get_property(conn, 0, win->id,
ewmh[_NET_WM_WINDOW_TYPE].atom, XCB_ATOM_ATOM, 0, UINT32_MAX);
r = xcb_get_property_reply(conn, c, NULL);
if (!r)
if (win == NULL)
return;
+ DNPRINTF(SWM_D_PROP, "ewmh_update_win_state: window: 0x%x, state: %ld, "
+ "action: %ld\n", win->id, state, action);
+
if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom)
mask = EWMH_F_FULLSCREEN;
if (state == ewmh[_NET_WM_STATE_ABOVE].atom)
if (win->manual)
win->ewmh_flags |= SWM_F_MANUAL;
- c = xcb_get_property(conn, False, win->id, ewmh[_NET_WM_STATE].atom,
+ c = xcb_get_property(conn, 0, win->id, ewmh[_NET_WM_STATE].atom,
XCB_ATOM_ATOM, 0, UINT32_MAX);
r = xcb_get_property_reply(conn, c, NULL);
if (!r)
dumpwins(struct swm_region *r, union arg *args)
{
struct ws_win *win;
- uint16_t state;
+ uint32_t state;
xcb_get_window_attributes_cookie_t c;
xcb_get_window_attributes_reply_t *wa;
+ /* suppress unused warning since var is needed */
+ (void)args;
+
if (r->ws == NULL) {
warnx("dumpwins: invalid workspace");
return;
}
uint32_t
-name_to_color(const char *colorname)
+name_to_pixel(const char *colorname)
{
uint32_t result = 0;
char cname[32] = "#";
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
if (i > 0 && i <= num_screens) {
- screens[i - 1].c[c].color = name_to_color(val);
+ screens[i - 1].c[c].pixel = name_to_pixel(val);
free(screens[i - 1].c[c].name);
if ((screens[i - 1].c[c].name = strdup(val)) == NULL)
err(1, "strdup");
} else if (i == -1) {
for (i = 0; i < num_screens; i++) {
- screens[i].c[c].color = name_to_color(val);
+ screens[i].c[c].pixel = name_to_pixel(val);
free(screens[i].c[c].name);
if ((screens[i].c[c].name = strdup(val)) == NULL)
err(1, "strdup");
void
bar_print(struct swm_region *r, const char *s)
{
- size_t len;
- xcb_rectangle_t rect;
- uint32_t gcv[1];
+ size_t len;
+ xcb_rectangle_t rect;
+ uint32_t gcv[1];
+ int32_t x = 0;
+ XGlyphInfo info;
+ XftDraw *draw;
len = strlen(s);
- /* FIXME fix bar font position calculations */
-#if 0
- int x = 0;
- XRectangle ibox, lbox;
- XmbTextExtents(bar_fs, s, len, &ibox, &lbox);
+
+ XftTextExtentsUtf8(display, bar_font, (FcChar8 *)s, len, &info);
switch (bar_justify) {
case SWM_BAR_JUSTIFY_LEFT:
x = SWM_BAR_OFFSET;
break;
case SWM_BAR_JUSTIFY_CENTER:
- x = (WIDTH(r) - lbox.width) / 2;
+ x = (WIDTH(r) - info.width) / 2;
break;
case SWM_BAR_JUSTIFY_RIGHT:
- x = WIDTH(r) - lbox.width - SWM_BAR_OFFSET;
+ x = WIDTH(r) - info.width - SWM_BAR_OFFSET;
break;
}
if (x < SWM_BAR_OFFSET)
x = SWM_BAR_OFFSET;
-#endif
rect.x = 0;
rect.y = 0;
rect.height = HEIGHT(r->bar);
/* clear back buffer */
- gcv[0] = r->s->c[SWM_S_COLOR_BAR].color;
+ gcv[0] = r->s->c[SWM_S_COLOR_BAR].pixel;
xcb_change_gc(conn, r->s->bar_gc, XCB_GC_FOREGROUND, gcv);
xcb_poly_fill_rectangle(conn, r->bar->buffer, r->s->bar_gc,
sizeof(rect), &rect);
/* draw back buffer */
- gcv[0] = r->s->c[SWM_S_COLOR_BAR].color;
+ gcv[0] = r->s->c[SWM_S_COLOR_BAR].pixel;
xcb_change_gc(conn, r->s->bar_gc, XCB_GC_BACKGROUND, gcv);
- gcv[0] = r->s->c[SWM_S_COLOR_BAR_FONT].color;
+ gcv[0] = r->s->c[SWM_S_COLOR_BAR_FONT].pixel;
xcb_change_gc(conn, r->s->bar_gc, XCB_GC_FOREGROUND, gcv);
-#if 0
- xcb_image_text_8(conn, len, r->bar->buffer, r->s->bar_gc, x,
- (bar_fs_extents->max_logical_extent.height - lbox.height) / 2 -
- lbox.y, s);
-#else
- /* workaround */
- xcb_image_text_8(conn, len, r->bar->buffer, r->s->bar_gc, 4, 14, s);
-#endif
+
+ draw = XftDrawCreate(display, r->bar->buffer,
+ DefaultVisual(display, r->s->idx),
+ DefaultColormap(display, r->s->idx));
+
+ XftDrawStringUtf8(draw, &bar_font_color, bar_font, x,
+ (HEIGHT(r->bar) + bar_font->height) / 2 - bar_font->descent,
+ (FcChar8 *)s, len);
+
+ XftDrawDestroy(draw);
/* blt */
xcb_copy_area(conn, r->bar->buffer, r->bar->id, r->s->bar_gc, 0, 0,
void
bar_signal(int sig)
{
+ /* suppress unused warning since var is needed */
+ (void)sig;
+
bar_alarm = 1;
}
struct swm_region *tmpr;
int i, num_screens;
+ /* suppress unused warnings since vars are needed */
+ (void)r;
+ (void)args;
+
DNPRINTF(SWM_D_BAR, "bar_toggle\n");
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
TAILQ_FOREACH(r, &screens[i].rl, entry) {
if (r->bar == NULL)
continue;
- wa[0] = screens[i].c[SWM_S_COLOR_BAR].color;
- wa[1] = screens[i].c[SWM_S_COLOR_BAR_BORDER].color;
+ wa[0] = screens[i].c[SWM_S_COLOR_BAR].pixel;
+ wa[1] = screens[i].c[SWM_S_COLOR_BAR_BORDER].pixel;
xcb_change_window_attributes(conn, r->bar->id,
XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa);
}
void
bar_setup(struct swm_region *r)
{
- char *default_string;
- char **missing_charsets;
- int num_missing_charsets = 0;
- int i;
+ char *font, *fontpos;
+ int count;
xcb_screen_t *screen = get_screen(r->s->idx);
uint32_t wa[3];
+ XRenderColor color;
-#if 0
- if (bar_fs) {
- XFreeFontSet(display, bar_fs);
- bar_fs = NULL;
- }
-#endif
+ if (r->bar != NULL)
+ return;
if ((r->bar = calloc(1, sizeof(struct swm_bar))) == NULL)
err(1, "bar_setup: calloc: failed to allocate memory.");
-#if 0
- DNPRINTF(SWM_D_BAR, "bar_setup: loading bar_fonts: %s\n", bar_fonts);
- bar_fs = XCreateFontSet(display, bar_fonts, &missing_charsets,
- &num_missing_charsets, &default_string);*/
-
- if (num_missing_charsets > 0) {
- warnx("Unable to load charset(s):");
+ if (bar_font == NULL) {
+ while ((font = strsep(&bar_fonts, ",")) != NULL) {
+ if (*font == '\0')
+ continue;
- for (i = 0; i < num_missing_charsets; ++i)
- warnx("%s", missing_charsets[i]);
+ DNPRINTF(SWM_D_INIT, "bar_setup: try font %s\n", font);
- XFreeStringList(missing_charsets);
+ count = 0;
+ fontpos = font;
+ while ((fontpos = index(fontpos, '-'))) {
+ count++;
+ fontpos++;
+ }
- if (strcmp(default_string, ""))
- warnx("Glyphs from those sets will be replaced "
- "by '%s'.", default_string);
- else
- warnx("Glyphs from those sets won't be drawn.");
+ if (count == 14)
+ bar_font = XftFontOpenXlfd(display, r->s->idx,
+ font);
+ else
+ bar_font = XftFontOpenName(display, r->s->idx,
+ font);
+ if (!bar_font) {
+ warnx("unable to load font %s", font);
+ continue;
+ } else {
+ DNPRINTF(SWM_D_INIT, "successfully opened "
+ "font %s\n", font);
+ break;
+ }
+ }
}
- if (bar_fs == NULL)
- errx(1, "Error creating font set structure.");
+ if (bar_font == NULL)
+ errx(1, "unable to open a font");
- bar_fs_extents = XExtentsOfFontSet(bar_fs);
-
- bar_height = bar_fs_extents->max_logical_extent.height +
- 2 * bar_border_width;
+ bar_height = bar_font->height + 2 * bar_border_width;
if (bar_height < 1)
bar_height = 1;
-#else
- /* workaround */
- bar_height = 24;
-#endif
+
+ PIXEL_TO_XRENDERCOLOR(r->s->c[SWM_S_COLOR_BAR_FONT].pixel, color);
+
+ if (!XftColorAllocValue(display, DefaultVisual(display, r->s->idx),
+ DefaultColormap(display, r->s->idx), &color, &bar_font_color))
+ warn("unable to allocate Xft color");
+
X(r->bar) = X(r);
Y(r->bar) = bar_at_bottom ? (Y(r) + HEIGHT(r) - bar_height) : Y(r);
WIDTH(r->bar) = WIDTH(r) - 2 * bar_border_width;
HEIGHT(r->bar) = bar_height - 2 * bar_border_width;
r->bar->id = xcb_generate_id(conn);
- wa[0] = r->s->c[SWM_S_COLOR_BAR].color;
- wa[1] = r->s->c[SWM_S_COLOR_BAR_BORDER].color;
+ wa[0] = r->s->c[SWM_S_COLOR_BAR].pixel;
+ wa[1] = r->s->c[SWM_S_COLOR_BAR_BORDER].pixel;
wa[2] = XCB_EVENT_MASK_EXPOSURE;
- DNPRINTF(SWM_D_BAR, "bar_setup: create_window: (x,y) w x h: (%d,%d) "
- "%d x %d\n", X(r->bar), Y(r->bar), WIDTH(r->bar), HEIGHT(r->bar));
+
xcb_create_window(conn, XCB_COPY_FROM_PARENT, r->bar->id, r->s->root,
X(r->bar), Y(r->bar), WIDTH(r->bar), HEIGHT(r->bar),
bar_border_width, XCB_WINDOW_CLASS_INPUT_OUTPUT,
a_state, 32, 2, data);
}
-uint16_t
+uint32_t
getstate(xcb_window_t w)
{
- uint16_t result = 0;
+ uint32_t result = 0;
xcb_get_property_cookie_t c;
xcb_get_property_reply_t *r;
- c = xcb_get_property(conn, False, w, a_state, a_state, 0L, 2L);
+ c = xcb_get_property(conn, 0, w, a_state, a_state, 0L, 2L);
r = xcb_get_property_reply(conn, c, NULL);
if (r) {
- result = *((uint16_t *)xcb_get_property_value(r));
+ if (r->type == a_state && r->format == 32 && r->length == 2)
+ result = *((uint32_t *)xcb_get_property_value(r));
free(r);
}
void
version(struct swm_region *r, union arg *args)
{
+ /* suppress unused warnings since vars are needed */
+ (void)r;
+ (void)args;
+
bar_version = !bar_version;
if (bar_version)
snprintf(bar_vertext, sizeof bar_vertext,
ev.data.data32[0] = a;
ev.data.data32[1] = XCB_CURRENT_TIME;
- xcb_send_event(conn, False, win->id,
+ xcb_send_event(conn, 0, win->id,
XCB_EVENT_MASK_NO_EVENT, (const char *)&ev);
}
ce.y = Y(win);
ce.width = WIDTH(win);
ce.height = HEIGHT(win);
- ce.override_redirect = False;
+ ce.override_redirect = 0;
if (ev == NULL) {
/* EWMH */
"(%d,%d) %d x %d, border: %d\n", YESNO(ev == NULL), win->id, ce.x,
ce.y, ce.width, ce.height, ce.border_width);
- xcb_send_event(conn, False, win->id, XCB_EVENT_MASK_STRUCTURE_NOTIFY,
- (char *)&ce);
+ xcb_send_event(conn, 0, win->id, XCB_EVENT_MASK_STRUCTURE_NOTIFY,
+ (char *)&ce);
}
int
void
quit(struct swm_region *r, union arg *args)
{
+ /* suppress unused warnings since vars are needed */
+ (void)r;
+ (void)args;
+
DNPRINTF(SWM_D_MISC, "quit\n");
running = 0;
}
void
unmap_window(struct ws_win *win)
{
+ DNPRINTF(SWM_D_EVENT, "unmap_window: window: 0x%x\n", win->id);
+
if (win == NULL)
return;
xcb_unmap_window(conn, win->id);
xcb_change_window_attributes(conn, win->id,
- XCB_CW_BORDER_PIXEL, &win->s->c[SWM_S_COLOR_UNFOCUS].color);
+ XCB_CW_BORDER_PIXEL, &win->s->c[SWM_S_COLOR_UNFOCUS].pixel);
}
void
event.event_y = Y(win);
event.root_x = 1;
event.root_y = 1;
- event.same_screen = True;
+ event.same_screen = 1;
event.detail = *keycode;
event.state = modifiers;
event.response_type = XCB_KEY_PRESS;
- xcb_send_event(conn, True, win->id,
+ xcb_send_event(conn, 1, win->id,
XCB_EVENT_MASK_KEY_PRESS, (const char *)&event);
event.response_type = XCB_KEY_RELEASE;
- xcb_send_event(conn, True, win->id,
+ xcb_send_event(conn, 1, win->id,
XCB_EVENT_MASK_KEY_RELEASE, (const char *)&event);
+
+ free(keycode);
}
void
restart(struct swm_region *r, union arg *args)
{
+ /* suppress unused warning since var is needed */
+ (void)args;
+
DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]);
/* disable alarm because the following code may not be interrupted */
bar_extra = 1;
unmap_all();
+ XftFontClose(display, bar_font);
+ XftColorFree(display, DefaultVisual(display, r->s->idx),
+ DefaultColormap(display, r->s->idx), &bar_font_color);
xcb_key_symbols_free(syms);
xcb_flush(conn);
xcb_disconnect(conn);
return (NULL);
/* if we were looking for the parent return that window instead */
- if (r->parent == 0 || r->root == r->parent)
+ if (r->parent == 0 || r->root == r->parent) {
+ free(r);
return (NULL);
+ }
/* look for parent */
for (i = 0; i < num_screens; i++)
grabbuttons(win, 0);
xcb_change_window_attributes(conn, win->id, XCB_CW_BORDER_PIXEL,
- &win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
+ &win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].pixel);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root,
ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1, &none);
}
if ((cfw = find_window(cur_focus)) != NULL)
unfocus_win(cfw);
else {
+#if 0
/* use larger hammer since the window was killed somehow */
- /* TAILQ_FOREACH(cfw, &win->ws->winlist, entry)
+ TAILQ_FOREACH(cfw, &win->ws->winlist, entry)
if (cfw->ws && cfw->ws->r && cfw->ws->r->s)
xcb_change_window_attributes(conn, cfw->id,
XCB_CW_BORDER_PIXEL,
- &cfw->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);*/
+ &cfw->ws->r->s->c[SWM_S_COLOR_UNFOCUS].pixel);
+#endif
}
win->ws->focus = win;
win->id, XCB_CURRENT_TIME);
grabbuttons(win, 1);
xcb_change_window_attributes(conn, win->id,
- XCB_CW_BORDER_PIXEL,
- &win->ws->r->s->c[SWM_S_COLOR_FOCUS].color);
+ XCB_CW_BORDER_PIXEL,
+ &win->ws->r->s->c[SWM_S_COLOR_FOCUS].pixel);
if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS ||
win->ws->always_raise)
map_window_raised(win->id);
event_drain(XCB_ENTER_NOTIFY);
else
xcb_flush(conn);
+
+ DNPRINTF(SWM_D_WS, "switchws: done\n");
}
void
struct workspace *ws = r->ws;
union arg a;
+ /* suppress unused warning since var is needed */
+ (void)args;
+
DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx);
ws->cur_layout++;
int wsid = args->id;
struct ws_win *win = NULL, *parent;
struct workspace *ws, *nws;
- xcb_atom_t ws_idx_atom = XCB_ATOM_NONE;
char ws_idx_str[SWM_PROPLEN];
union arg a;
win->ws = nws;
/* Try to update the window's workspace property */
- ws_idx_atom = get_atom_from_string("_SWM_WS");
- if (ws_idx_atom &&
- snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) <
- SWM_PROPLEN) {
+ if (snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < SWM_PROPLEN) {
DNPRINTF(SWM_D_PROP, "send_to_ws: set property: _SWM_WS: %s\n",
ws_idx_str);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id,
- ws_idx_atom, XCB_ATOM_STRING, 8, strlen(ws_idx_str),
+ a_swm_ws, XCB_ATOM_STRING, 8, strlen(ws_idx_str),
ws_idx_str);
}
void
pressbutton(struct swm_region *r, union arg *args)
{
+ /* suppress unused warning since var is needed */
+ (void)r;
+
xcb_test_fake_input(conn, XCB_BUTTON_PRESS, args->id,
XCB_CURRENT_TIME, XCB_WINDOW_NONE, 0, 0, 0);
xcb_test_fake_input(conn, XCB_BUTTON_RELEASE, args->id,
void
raise_toggle(struct swm_region *r, union arg *args)
{
+ /* suppress unused warning since var is needed */
+ (void)args;
+
if (r == NULL || r->ws == NULL)
return;
{
union arg a;
+ /* suppress unused warning since var is needed */
+ (void)args;
+
if (r->ws->focus == NULL)
return;
unmap_window(r->ws->focus);
if (xcb_icccm_get_wm_name_reply(conn, c, &r, NULL)) {
if (r.name_len > 0) {
name = malloc(r.name_len + 1);
- if (!name) {
- xcb_icccm_get_text_property_reply_wipe(&r);
- return (NULL);
+ if (name) {
+ memcpy(name, r.name, r.name_len);
+ name[r.name_len] = '\0';
}
- memcpy(name, r.name, r.name_len);
- name[r.name_len] = '\0';
}
xcb_icccm_get_text_property_reply_wipe(&r);
}
char s[8];
FILE *lfile;
size_t len;
- XRectangle ibox, lbox;
+ XftDraw *draw;
+ XGlyphInfo info;
DNPRINTF(SWM_D_MISC, "search_win\n");
snprintf(s, sizeof s, "%d", i);
len = strlen(s);
- /* FIXME fix calculations */
-#if 0
- XmbTextExtents(bar_fs, s, len, &ibox, &lbox);
-#endif
+ XftTextExtentsUtf8(display, bar_font, (FcChar8 *)s, len, &info);
w = xcb_generate_id(conn);
- wa[0] = r->s->c[SWM_S_COLOR_FOCUS].color;
- wa[1] = r->s->c[SWM_S_COLOR_UNFOCUS].color;
-#if 0
+ wa[0] = r->s->c[SWM_S_COLOR_FOCUS].pixel;
+ wa[1] = r->s->c[SWM_S_COLOR_UNFOCUS].pixel;
xcb_create_window(conn, XCB_COPY_FROM_PARENT, w, win->id, 0, 0,
- lbox.width + 4, bar_fs_extents->max_logical_extent.height,
+ info.width + 4, bar_font->height + 4,
1, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT,
XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa);
-#else
- /* workaround */
- xcb_create_window(conn, XCB_COPY_FROM_PARENT, w, win->id, 0, 0,
- 22, 20, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT,
- XCB_COPY_FROM_PARENT, XCB_CW_BACK_PIXEL |
- XCB_CW_BORDER_PIXEL, wa);
-#endif
sw->indicator = w;
TAILQ_INSERT_TAIL(&search_wl, sw, entry);
sw->gc = xcb_generate_id(conn);
- gcv[0] = r->s->c[SWM_S_COLOR_BAR].color;
- gcv[1] = r->s->c[SWM_S_COLOR_FOCUS].color;
+ gcv[0] = r->s->c[SWM_S_COLOR_BAR].pixel;
+ gcv[1] = r->s->c[SWM_S_COLOR_FOCUS].pixel;
gcv[2] = 0;
xcb_create_gc(conn, sw->gc, w, XCB_GC_FOREGROUND |
XCB_GC_BACKGROUND | XCB_GC_GRAPHICS_EXPOSURES, gcv);
map_window_raised(w);
-#if 0
- xcb_image_text_8(conn, len, w, sw->gc, 2,
- (bar_fs_extents->max_logical_extent.height -
- lbox.height) / 2 - lbox.y, s);
-#else
- /* workaround */
- xcb_image_text_8(conn, len, w, sw->gc, 6, 14, s);
-#endif
+ draw = XftDrawCreate(display, w,
+ DefaultVisual(display, r->s->idx),
+ DefaultColormap(display, r->s->idx));
+
+ XftDrawStringUtf8(draw, &bar_font_color, bar_font, 2,
+ (HEIGHT(r->bar) + bar_font->height) / 2 - bar_font->descent,
+ (FcChar8 *)s, len);
+
+ XftDrawDestroy(draw);
DNPRINTF(SWM_D_MISC, "search_win: mapped window: 0x%x\n", w);
}
void
-search_resp_search_workspace(char *resp, unsigned long len)
+search_resp_search_workspace(char *resp)
{
char *p, *q;
int ws_idx;
}
void
-search_resp_search_window(char *resp, unsigned long len)
+search_resp_search_window(char *resp)
{
char *s;
int idx;
search_resp_name_workspace(resp, len);
break;
case SWM_SEARCH_SEARCH_WORKSPACE:
- search_resp_search_workspace(resp, len);
+ search_resp_search_workspace(resp);
break;
case SWM_SEARCH_SEARCH_WINDOW:
- search_resp_search_window(resp, len);
+ search_resp_search_window(resp);
break;
}
struct ws_win *win = r->ws->focus;
union arg a;
+ /* suppress unused warning since var is needed */
+ (void)args;
+
if (win == NULL)
return;
uint32_t wc[5];
mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
- XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
- XCB_CONFIG_WINDOW_BORDER_WIDTH;
+ XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
+ XCB_CONFIG_WINDOW_BORDER_WIDTH;
wc[0] = X(win);
wc[1] = Y(win);
wc[2] = WIDTH(win);
xcb_cursor_t cursor;
xcb_font_t cursor_font;
xcb_grab_pointer_cookie_t gpc;
- xcb_grab_pointer_reply_t *gpr;
xcb_query_pointer_reply_t *xpr;
xcb_generic_event_t *evt;
xcb_motion_notify_event_t *mne;
xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font,
shape, shape + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff);
- gpc = xcb_grab_pointer(conn, False, win->id, MOUSEMASK,
+ gpc = xcb_grab_pointer(conn, 0, win->id, MOUSEMASK,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE, cursor,
XCB_CURRENT_TIME),
- gpr = xcb_grab_pointer_reply(conn, gpc, NULL);
- if (!gpr) {
- xcb_free_cursor(conn, cursor);
- xcb_close_font(conn, cursor_font);
- free(xpr);
- return;
- }
xcb_flush(conn);
resizing = 1;
xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
xcb_free_cursor(conn, cursor);
xcb_close_font(conn, cursor_font);
- free(gpr);
free(xpr);
DNPRINTF(SWM_D_EVENT, "resize: done\n");
}
xcb_font_t cursor_font;
xcb_cursor_t cursor;
xcb_grab_pointer_cookie_t gpc;
- xcb_grab_pointer_reply_t *gpr;
xcb_query_pointer_reply_t *qpr;
xcb_generic_event_t *evt;
xcb_motion_notify_event_t *mne;
xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font,
XC_fleur, XC_fleur + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff);
- gpc = xcb_grab_pointer(conn, False, win->id, MOUSEMASK,
+ gpc = xcb_grab_pointer(conn, 0, win->id, MOUSEMASK,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
XCB_WINDOW_NONE, cursor, XCB_CURRENT_TIME);
- gpr = xcb_grab_pointer_reply(conn, gpc, NULL);
- if (!gpr) {
- xcb_free_cursor(conn, cursor);
- xcb_close_font(conn, cursor_font);
- return;
- }
/* get cursor offset from window root */
qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id),
int i;
char *ap, **real_args;
+ /* suppress unused warning since var is needed */
+ (void)args;
+
DNPRINTF(SWM_D_SPAWN, "spawn_expand: %s\n", spawn_name);
/* find program */
int
setconfspawn(char *selector, char *value, int flags)
{
+ /* suppress unused warning since var is needed */
+ (void)flags;
+
DNPRINTF(SWM_D_SPAWN, "setconfspawn: [%s] [%s]\n", selector, value);
setspawn(selector, value);
unsigned int mod;
KeySym ks;
struct spawn_prog *sp;
+
+ /* suppress unused warning since var is needed */
+ (void)flags;
+
DNPRINTF(SWM_D_KEY, "setconfbinding: enter\n");
if (selector == NULL) {
DNPRINTF(SWM_D_KEY, "setconfbinding: unbind %s\n", value);
setkeymapping(char *selector, char *value, int flags)
{
char keymapping_file[PATH_MAX];
+
+ /* suppress unused warnings since vars are needed */
+ (void)selector;
+ (void)flags;
+
DNPRINTF(SWM_D_KEY, "setkeymapping: enter\n");
if (value[0] == '~')
snprintf(keymapping_file, sizeof keymapping_file, "%s/%s",
{
unsigned int i, j;
xcb_get_modifier_mapping_reply_t *modmap_r;
- xcb_keycode_t *modmap, kc;
+ xcb_keycode_t *modmap, kc, *keycode;
DNPRINTF(SWM_D_MISC, "updatenumlockmask\n");
numlockmask = 0;
for (j = 0; j < modmap_r->keycodes_per_modifier; j++) {
kc = modmap[i * modmap_r->keycodes_per_modifier
+ j];
-
- if (kc == *((xcb_keycode_t *)xcb_key_symbols_get_keycode(syms,
- XK_Num_Lock)))
+ keycode = xcb_key_symbols_get_keycode(syms,
+ XK_Num_Lock);
+ if (kc == *keycode)
numlockmask = (1 << i);
+ free(keycode);
}
}
free(modmap_r);
if ((code = xcb_key_symbols_get_keycode(syms,
kp->keysym)))
for (j = 0; j < LENGTH(modifiers); j++)
- xcb_grab_key(conn, True,
+ xcb_grab_key(conn, 1,
screens[k].root,
kp->mod | modifiers[j],
*code, XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC);
+ free(code);
}
}
}
for (i = 0; i < LENGTH(buttons); i++)
if (buttons[i].action == client_click)
for (j = 0; j < LENGTH(modifiers); j++)
- xcb_grab_button(conn, False, win->id,
+ xcb_grab_button(conn, 0, win->id,
BUTTONMASK,
XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_SYNC,
buttons[i].button,
buttons[i].mask);
} else
- xcb_grab_button(conn, False, win->id, BUTTONMASK,
+ xcb_grab_button(conn, 0, win->id, BUTTONMASK,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_SYNC, XCB_WINDOW_NONE,
XCB_CURSOR_NONE, XCB_BUTTON_INDEX_ANY, XCB_BUTTON_MASK_ANY);
}
char *cp, *class, *name;
int retval;
unsigned long quirks;
+
+ /* suppress unused warning since var is needed */
+ (void)flags;
+
if (selector == NULL)
return (0);
if ((cp = strchr(selector, ':')) == NULL)
int i;
char *b;
+ /* suppress unused warning since var is needed */
+ (void)selector;
+
switch (flags) {
case SWM_S_BAR_ACTION:
free(bar_argv[0]);
if (asprintf(&bar_fonts, "%s,%s", value, bar_fonts) == -1)
err(1, "setconfvalue: asprintf: failed to allocate "
"memory for bar_fonts.");
-
free(b);
break;
case SWM_S_BAR_FORMAT:
int
setconfmodkey(char *selector, char *value, int flags)
{
+ /* suppress unused warnings since vars are needed */
+ (void)selector;
+ (void)flags;
+
if (!strncasecmp(value, "Mod1", strlen("Mod1")))
update_modkey(Mod1Mask);
else if (!strncasecmp(value, "Mod2", strlen("Mod2")))
int
setconfregion(char *selector, char *value, int flags)
{
+ /* suppress unused warnings since vars are needed */
+ (void)selector;
+ (void)flags;
+
custom_region(value);
return (0);
}
pid_t pid;
struct pid_e *p;
+ /* suppress unused warnings since vars are needed */
+ (void)selector;
+ (void)flags;
+
if (getenv("SWM_STARTED"))
return (0);
char s[1024];
struct workspace *ws;
+ /* suppress unused warnings since vars are needed */
+ (void)selector;
+ (void)flags;
+
if (getenv("SWM_STARTED"))
return (0);
if (apid == XCB_ATOM_NONE)
goto tryharder;
- pc = xcb_get_property(conn, False, win, apid, XCB_ATOM_CARDINAL, 0, 1);
+ pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_CARDINAL, 0, 1);
pr = xcb_get_property_reply(conn, pc, NULL);
if (!pr)
goto tryharder;
goto tryharder;
}
- ret = *((pid_t *)xcb_get_property_value(pr));
+ if (pr->type == apid && pr->format == 32)
+ ret = *((pid_t *)xcb_get_property_value(pr));
free(pr);
return (ret);
tryharder:
apid = get_atom_from_string("_SWM_PID");
- pc = xcb_get_property(conn, False, win, apid, XCB_ATOM_STRING,
+ pc = xcb_get_property(conn, 0, win, apid, XCB_ATOM_STRING,
0, SWM_PROPLEN);
pr = xcb_get_property_reply(conn, pc, NULL);
if (!pr)
return (0);
- if (pr->type != XCB_ATOM_STRING) {
+ if (pr->type != apid) {
free(pr);
return (0);
}
return (ret);
}
+int
+get_ws_idx(xcb_window_t id)
+{
+ int ws_idx = -1;
+ char *prop = NULL;
+ size_t proplen;
+ const char *errstr;
+ xcb_get_property_reply_t *gpr;
+
+ gpr = xcb_get_property_reply(conn,
+ xcb_get_property(conn, 0, id, a_swm_ws,
+ XCB_ATOM_STRING, 0, SWM_PROPLEN),
+ NULL);
+ if (!gpr)
+ return (-1);
+ if (gpr->type) {
+ proplen = xcb_get_property_value_length(gpr);
+ if (proplen > 0) {
+ prop = malloc(proplen + 1);
+ if (prop) {
+ memcpy(prop,
+ xcb_get_property_value(gpr),
+ proplen);
+ prop[proplen] = '\0';
+ }
+ }
+ }
+ free(gpr);
+
+ if (prop) {
+ DNPRINTF(SWM_D_PROP, "get_ws_idx: _SWM_WS: %s\n", prop);
+ ws_idx = (int)strtonum(prop, 0, workspace_limit - 1, &errstr);
+ if (errstr) {
+ DNPRINTF(SWM_D_PROP, "get_ws_idx: window: #%s: %s",
+ errstr, prop);
+ }
+ free(prop);
+ }
+
+ return ws_idx;
+}
+
struct ws_win *
manage_window(xcb_window_t id)
{
struct workspace *ws;
struct ws_win *win, *ww;
int ws_idx, border_me = 0;
- xcb_atom_t ws_idx_atom = XCB_ATOM_NONE;
char ws_idx_str[SWM_PROPLEN], *prop = NULL;
- size_t proplen;
struct swm_region *r;
- const char *errstr;
struct pid_e *p;
struct quirk *qp;
uint32_t event_mask, i;
- xcb_atom_t prot;
- xcb_get_property_reply_t *gpr;
xcb_icccm_get_wm_protocols_reply_t wpr;
+ xcb_icccm_get_wm_class_reply_t tmpch;
if ((win = find_window(id)) != NULL)
return (win); /* already being managed */
p = find_pid(window_get_pid(id));
/* Get all the window data in one shot */
- ws_idx_atom = get_atom_from_string("_SWM_WS");
- if (ws_idx_atom) {
- gpr = xcb_get_property_reply(conn,
- xcb_get_property(conn, False, id, ws_idx_atom,
- XCB_ATOM_STRING, 0, SWM_PROPLEN),
- NULL);
- if (gpr) {
- proplen = xcb_get_property_value_length(gpr);
- if (proplen > 0) {
- prop = malloc(proplen + 1);
- if (prop) {
- memcpy(prop,
- xcb_get_property_value(gpr),
- proplen);
- prop[proplen] = '\0';
- }
- }
- free(gpr);
- }
- }
+ ws_idx = get_ws_idx(id);
+
win->wa = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, id),
NULL);
"transient: 0x%x\n", win->id, win->transient);
}
- prot = get_atom_from_string("WM_PROTOCOLS");
-
/* get supported protocols */
if (xcb_icccm_get_wm_protocols_reply(conn,
- xcb_icccm_get_wm_protocols(conn, id, prot),
+ xcb_icccm_get_wm_protocols(conn, id, a_prot),
&wpr, NULL)) {
for (i = 0; i < wpr.atoms_len; i++) {
if (wpr.atoms[i] == a_takefocus)
TAILQ_REMOVE(&pidlist, p, entry);
free(p);
p = NULL;
- } else if (prop && win->transient == 0) {
- DNPRINTF(SWM_D_PROP, "manage_window: get _SWM_WS: %s\n", prop);
- ws_idx = (int)strtonum(prop, 0, workspace_limit - 1,
- &errstr);
- if (errstr) {
- DNPRINTF(SWM_D_EVENT, "manage_window: window: #%s: %s",
- errstr, prop);
- }
+ } else if (ws_idx != -1 && win->transient == 0) {
ws = &r->s->ws[ws_idx];
} else {
ws = r->ws;
constrain_window(win, r, 0);
/* Set window properties so we can remember this after reincarnation */
- if (ws_idx_atom && prop == NULL &&
- snprintf(ws_idx_str, SWM_PROPLEN, "%d", ws->idx) <
- SWM_PROPLEN) {
+ if (prop == NULL && snprintf(ws_idx_str, SWM_PROPLEN, "%d", ws->idx) <
+ SWM_PROPLEN) {
DNPRINTF(SWM_D_PROP, "manage_window: set _SWM_WS: %s\n",
ws_idx_str);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id,
- ws_idx_atom, XCB_ATOM_STRING, 8, strlen(ws_idx_str),
+ a_swm_ws, XCB_ATOM_STRING, 8, strlen(ws_idx_str),
ws_idx_str);
}
if (prop)
if (xcb_icccm_get_wm_class_reply(conn,
xcb_icccm_get_wm_class(conn, win->id),
- &win->ch, NULL)) {
+ &tmpch, NULL)) {
+ win->ch.class_name = tmpch.class_name;
+ win->ch.instance_name = tmpch.instance_name;
+
+ xcb_icccm_get_wm_class_reply_wipe(&tmpch);
+
DNPRINTF(SWM_D_CLASS, "manage_window: class: %s, name: %s\n",
win->ch.class_name, win->ch.instance_name);
if (win->wa)
free(win->wa);
-
- xcb_icccm_get_wm_class_reply_wipe(&win->ch);
-
+
kill_refs(win);
/* paint memory */
{
xcb_get_geometry_reply_t *wa;
-
wa = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, w), NULL);
+ if (!wa) {
+ DNPRINTF(SWM_D_MISC, "print_win_geom: window not found: 0x%x\n",
+ w);
+ return;
+ }
+
DNPRINTF(SWM_D_MISC, "print_win_geom: window: 0x%x, root: 0x%x, "
"depth: %u, (x,y) w x h: (%d,%d) %d x %d, border: %d\n",
w, wa->root, wa->depth, wa->x, wa->y, wa->width, wa->height,
char *
get_atom_name(xcb_atom_t atom)
{
- char *name;
+ char *name = NULL;
size_t len;
xcb_get_atom_name_reply_t *r;
- xcb_map_request_event_t mre;
r = xcb_get_atom_name_reply(conn,
xcb_get_atom_name(conn, atom),
if (name) {
memcpy(name, xcb_get_atom_name_name(r), len);
name[len] = '\0';
-
- return name;
}
}
free(r);
}
- return NULL;
+ return (name);
}
#endif
}
}
-/*void
+#if 0
+void
visibilitynotify(xcb_visibility_notify_event_t *e)
{
DNPRINTF(SWM_D_EVENT, "visibilitynotify: window: 0x%x\n",
e->window);
-}*/
+}
+#endif
void
clientmessage(xcb_client_message_event_t *e)
enable_wm(void)
{
int num_screens, i;
- const uint32_t val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
+ const uint32_t val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
xcb_screen_t *sc;
xcb_void_cookie_t wac;
xcb_generic_error_t *error;
DNPRINTF(SWM_D_INIT, "enable_wm: screen %d, root: 0x%x\n",
i, sc->root);
wac = xcb_change_window_attributes_checked(conn, sc->root,
- XCB_CW_EVENT_MASK, &val);
+ XCB_CW_EVENT_MASK, &val);
if ((error = xcb_request_check(conn, wac))) {
DNPRINTF(SWM_D_INIT, "enable_wm: error_code: %u\n",
error->error_code);
return;
} else
ncrtc = srr->num_crtcs;
+
+ crtc = xcb_randr_get_screen_resources_current_crtcs(srr);
for (c = 0; c < ncrtc; c++) {
- crtc = xcb_randr_get_screen_resources_current_crtcs(srr);
cic = xcb_randr_get_crtc_info(conn, crtc[c],
XCB_CURRENT_TIME);
cir = xcb_randr_get_crtc_info_reply(conn, cic, NULL);
DNPRINTF(SWM_D_EVENT, "screenchange: root: 0x%x\n", e->root);
-
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
/* silly event doesn't include the screen index */
for (i = 0; i < num_screens; i++)
xcb_get_window_attributes_reply_t *r;
xcb_get_property_cookie_t pc;
+ DNPRINTF(SWM_D_INIT, "grab_windows: begin\n");
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
for (i = 0; i < num_screens; i++) {
qtc = xcb_query_tree(conn, screens[i].root);
}
free(qtr);
}
+ DNPRINTF(SWM_D_INIT, "grab_windows: done\n");
}
void
"screens");
/* initial Xrandr setup */
- xrandr_support = False;
- c = xcb_randr_query_version(conn, True, True);
+ xrandr_support = 0;
+ c = xcb_randr_query_version(conn, 1, 1);
r = xcb_randr_query_version_reply(conn, c, NULL);
if (r) {
if (r->major_version >= 1)
- xrandr_support = True;
+ xrandr_support = 1;
free(r);
}
qep = xcb_get_extension_data(conn, &xcb_randr_id);
cursor = xcb_generate_id(conn);
xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font,
- XC_left_ptr, XC_left_ptr + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff);
+ XC_left_ptr, XC_left_ptr + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff);
wa[0] = cursor;
/* map physical screens */
a_utf8_string = get_atom_from_string("UTF8_STRING");
a_string = get_atom_from_string("STRING");
a_swm_iconic = get_atom_from_string("_SWM_ICONIC");
+ a_swm_ws = get_atom_from_string("_SWM_WS");
}
void
workaround(void)
{
int i, num_screens;
- xcb_atom_t netwmcheck, netwmname, utf8_string;
+ xcb_atom_t netwmcheck;
xcb_window_t root, win;
uint32_t wa[2];
/* work around sun jdk bugs, code from wmname */
netwmcheck = get_atom_from_string("_NET_SUPPORTING_WM_CHECK");
- netwmname = get_atom_from_string("_NET_WM_NAME");
- utf8_string = get_atom_from_string("UTF8_STRING");
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
for (i = 0; i < num_screens; i++) {
root = screens[i].root;
win = xcb_generate_id(conn);
- wa[0] = screens[i].c[SWM_S_COLOR_UNFOCUS].color;
- wa[1] = screens[i].c[SWM_S_COLOR_UNFOCUS].color;
+ wa[0] = screens[i].c[SWM_S_COLOR_UNFOCUS].pixel;
+ wa[1] = screens[i].c[SWM_S_COLOR_UNFOCUS].pixel;
xcb_create_window(conn, XCB_COPY_FROM_PARENT, win, 0, 0, 0, 1,
1, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT,
XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win,
netwmcheck, XCB_ATOM_WINDOW, 32, 1, &win);
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win,
- netwmname, utf8_string, 8, strlen("LG3D"), "LG3D");
+ a_netwmname, a_utf8_string, 8, strlen("LG3D"), "LG3D");
}
}
struct timeval tv;
fd_set rd;
+ /* suppress unused warning since var is needed */
+ (void)argc;
+
time_started = time(NULL);
start_argv = argv;
warnx("Welcome to spectrwm V%s Build: %s", SPECTRWM_VERSION, buildstr);
- if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, ""))
+ if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, ""))
warnx("no locale support");
/* handle some signals */
sact.sa_flags = SA_NOCLDSTOP;
sigaction(SIGCHLD, &sact, NULL);
- conn = xcb_connect(NULL, NULL);
+ if (!(display = XOpenDisplay(0)))
+ errx(1, "can not open display");
+
+ conn = XGetXCBConnection(display);
if (xcb_connection_has_error(conn))
errx(1, "can not get XCB connection");
+ XSetEventQueueOwner(display, XCBOwnsEventQueue);
+
xcb_prefetch_extension_data(conn, &xcb_randr_id);
xfd = xcb_get_file_descriptor(conn);
for (i = 0; i < num_screens; ++i)
if (screens[i].bar_gc != 0)
xcb_free_gc(conn, screens[i].bar_gc);
-#if 0
- XFreeFontSet(display, bar_fs);
-#endif
+
+ XftFontClose(display, bar_font);
+ XftColorFree(display, DefaultVisual(display, 0),
+ DefaultColormap(display, 0), &bar_font_color);
xcb_key_symbols_free(syms);
xcb_flush(conn);
xcb_disconnect(conn);