#include <util.h>
#include <X11/cursorfont.h>
#include <X11/keysym.h>
-#include <X11/Xatom.h>
-#include <X11/XKBlib.h>
-#include <X11/Xlib-xcb.h>
-#include <X11/Xproto.h>
-#include <X11/Xutil.h>
+#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
#include <X11/extensions/XTest.h>
-#include <xcb/randr.h>
+#include <xcb/xcb.h>
#include <xcb/xcb_atom.h>
#include <xcb/xcb_aux.h>
#include <xcb/xcb_event.h>
#include <xcb/xcb_icccm.h>
#include <xcb/xcb_keysyms.h>
#include <xcb/xtest.h>
+#include <xcb/randr.h>
/* local includes */
#include "version.h"
#endif
char **start_argv;
-xcb_atom_t astate;
-xcb_atom_t aprot;
-xcb_atom_t adelete;
-xcb_atom_t takefocus;
+xcb_atom_t a_state;
+xcb_atom_t a_prot;
+xcb_atom_t a_delete;
+xcb_atom_t a_takefocus;
xcb_atom_t a_wmname;
xcb_atom_t a_netwmname;
xcb_atom_t a_utf8_string;
volatile sig_atomic_t restart_wm = 0;
int outputs = 0;
/*int last_focus_event = FocusOut;*/
-int (*xerrorxlib)(Display *, XErrorEvent *);
int other_wm;
int ss_enabled = 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
char *bar_fonts;
struct passwd *pwd;
-#define SWM_MENU_FN (2)
-#define SWM_MENU_NB (4)
-#define SWM_MENU_NF (6)
-#define SWM_MENU_SB (8)
-#define SWM_MENU_SF (10)
-
/* layout manager data */
struct swm_geometry {
int x;
{
uint32_t i, n;
xcb_atom_t *type;
-
xcb_get_property_cookie_t c;
xcb_get_property_reply_t *r;
void
custom_region(char *val)
{
- unsigned int sidx, x, y, w, h;
- int num_screens;
+ unsigned int x, y, w, h;
+ int sidx, num_screens;
xcb_screen_t *screen;
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
- if (sscanf(val, "screen[%u]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5)
+ if (sscanf(val, "screen[%d]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5)
errx(1, "invalid custom region, "
"should be 'screen[<n>]:<n>x<n>+<n>+<n>");
if (sidx < 1 || sidx > num_screens)
XRectangle ibox, lbox;
len = strlen(s);
+ /* FIXME fix bar font position calculations */
+#if 0
XmbTextExtents(bar_fs, s, len, &ibox, &lbox);
switch (bar_justify) {
if (x < SWM_BAR_OFFSET)
x = SWM_BAR_OFFSET;
+#endif
rect.x = 0;
rect.y = 0;
xcb_change_gc(conn, r->s->bar_gc, XCB_GC_BACKGROUND, gcv);
gcv[0] = r->s->c[SWM_S_COLOR_BAR_FONT].color;
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
/* blt */
xcb_copy_area(conn, r->bar->buffer, r->bar->id, r->s->bar_gc, 0, 0,
xcb_screen_t *screen = get_screen(r->s->idx);
uint32_t wa[3];
+#if 0
if (bar_fs) {
XFreeFontSet(display, bar_fs);
bar_fs = NULL;
}
+#endif
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);
+ &num_missing_charsets, &default_string);*/
if (num_missing_charsets > 0) {
warnx("Unable to load charset(s):");
if (bar_height < 1)
bar_height = 1;
-
+#else
+ /* workaround */
+ bar_height = 24;
+#endif
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;
wa[0] = r->s->c[SWM_S_COLOR_BAR].color;
wa[1] = r->s->c[SWM_S_COLOR_BAR_BORDER].color;
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,
if (win == NULL)
return;
- xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, astate,
- astate, 32, 2, data);
+ xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id, a_state,
+ a_state, 32, 2, data);
}
uint16_t
xcb_get_property_cookie_t c;
xcb_get_property_reply_t *r;
- c = xcb_get_property(conn, False, w, astate, astate, 0L, 2L);
+ c = xcb_get_property(conn, False, w, a_state, a_state, 0L, 2L);
r = xcb_get_property_reply(conn, c, NULL);
if (r) {
bzero(&ev, sizeof ev);
ev.response_type = XCB_CLIENT_MESSAGE;
ev.window = win->id;
- ev.type = aprot;
+ ev.type = a_prot;
ev.format = 32;
ev.data.data32[0] = a;
ev.data.data32[1] = XCB_CURRENT_TIME;
event.response_type = XCB_KEY_PRESS;
xcb_send_event(conn, True, win->id,
- XCB_EVENT_MASK_KEY_PRESS, (char *)&event);
+ XCB_EVENT_MASK_KEY_PRESS, (const char *)&event);
event.response_type = XCB_KEY_RELEASE;
xcb_send_event(conn, True, win->id,
- XCB_EVENT_MASK_KEY_RELEASE, (char *)&event);
+ XCB_EVENT_MASK_KEY_RELEASE, (const char *)&event);
}
void
struct swm_region *
root_to_region(xcb_window_t root)
{
- struct swm_region *r = NULL;
- int i, num_screens;
+ struct swm_region *r = NULL;
+ int i, num_screens;
xcb_query_pointer_reply_t *qpr;
DNPRINTF(SWM_D_MISC, "root_to_region: window: 0x%x\n", root);
{
struct ws_win *win;
int i, j, num_screens;
- xcb_query_tree_cookie_t c;
xcb_query_tree_reply_t *r;
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
if (id == win->id)
return (win);
- c = xcb_query_tree(conn, id);
- r = xcb_query_tree_reply(conn, c, NULL);
+ r = xcb_query_tree_reply(conn, xcb_query_tree(conn, id), NULL);
if (!r)
return (NULL);
DNPRINTF(SWM_D_MISC, "spawn: %s\n", args->argv[0]);
- if (display)
- close(xcb_get_file_descriptor(conn));
+ close(xcb_get_file_descriptor(conn));
setenv("LD_PRELOAD", SWM_LIB, 1);
focus_win(struct ws_win *win)
{
struct ws_win *cfw = NULL;
- xcb_get_input_focus_cookie_t c;
xcb_get_input_focus_reply_t *r;
xcb_window_t cur_focus = XCB_WINDOW_NONE;
return;
}
- c = xcb_get_input_focus(conn);
- r = xcb_get_input_focus_reply(conn, c, NULL);
+ r = xcb_get_input_focus_reply(conn, xcb_get_input_focus(conn), NULL);
if (r) {
cur_focus = r->focus;
free(r);
}
void
+event_drain(uint8_t rt)
+{
+ xcb_generic_event_t *evt;
+
+ xcb_flush(conn);
+ while ((evt = xcb_poll_for_event(conn))) {
+ if (XCB_EVENT_RESPONSE_TYPE(evt) != rt)
+ event_handle(evt);
+
+ free(evt);
+ }
+}
+
+void
switchws(struct swm_region *r, union arg *args)
{
int wsid = args->id, unmap_old = 0;
TAILQ_FOREACH(win, &old_ws->winlist, entry)
unmap_window(win);
- xcb_flush(conn);
+ if (focus_mode == SWM_FOCUS_DEFAULT)
+ event_drain(XCB_ENTER_NOTIFY);
+ else
+ xcb_flush(conn);
}
void
ws->cur_layout = &layouts[0];
stack();
+ bar_update();
- a.id = SWM_ARG_ID_FOCUSCUR;
+ if (focus_mode == SWM_FOCUS_DEFAULT)
+ event_drain(XCB_ENTER_NOTIFY);
+ a.id = SWM_ARG_ID_FOCUSCUR;
focus(r, &a);
}
if (font_adjusted)
font_adjusted--;
+ if (focus_mode == SWM_FOCUS_DEFAULT)
+ event_drain(XCB_ENTER_NOTIFY);
+
DNPRINTF(SWM_D_STACK, "stack: end\n");
}
FILE *lfile;
size_t len;
XRectangle ibox, lbox;
+
DNPRINTF(SWM_D_MISC, "search_win\n");
search_r = r;
snprintf(s, sizeof s, "%d", i);
len = strlen(s);
+ /* FIXME fix calculations */
+#if 0
XmbTextExtents(bar_fs, s, len, &ibox, &lbox);
+#endif
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
xcb_create_window(conn, XCB_COPY_FROM_PARENT, w, win->id, 0, 0,
lbox.width + 4, bar_fs_extents->max_logical_extent.height,
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);
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
DNPRINTF(SWM_D_MISC, "search_win: mapped window: 0x%x\n", w);
xcb_kill_client(conn, r->ws->focus->id);
else
if (r->ws->focus->can_delete)
- client_msg(r->ws->focus, adelete);
+ client_msg(r->ws->focus, a_delete);
xcb_flush(conn);
}
}
xcb_flush(conn);
+ event_drain(XCB_ENTER_NOTIFY);
}
void
xcb_flush(conn);
resizing = 1;
while ((evt = xcb_wait_for_event(conn)) && resizing) {
- /*
- XMaskEvent(display, MOUSEMASK | ExposureMask |
- SubstructureRedirectMask, &ev);
- */
switch (XCB_EVENT_RESPONSE_TYPE(evt)) {
case XCB_BUTTON_RELEASE:
DNPRINTF(SWM_D_EVENT, "resize: BUTTON_RELEASE\n");
return (1);
}
cp = keystr;
- *ks = NoSymbol;
+ *ks = XCB_NO_SYMBOL;
*mod = 0;
while ((name = strsep(&cp, SWM_KEY_WS)) != NULL) {
DNPRINTF(SWM_D_KEY, "parsekeys: key [%s]\n", name);
else {
*ks = XStringToKeysym(name);
XConvertCase(*ks, ks, &uks);
- if (ks == NoSymbol) {
+ if (ks == XCB_NO_SYMBOL) {
DNPRINTF(SWM_D_KEY,
"parsekeys: invalid key %s\n",
name);
void
grabkeys(void)
{
- int num_screens;
- unsigned int j, k;
+ int num_screens, k;
+ unsigned int j;
xcb_keycode_t *code;
unsigned int modifiers[] =
{ 0, LockMask, numlockmask, numlockmask | LockMask };
xcb_window_t trans = XCB_WINDOW_NONE;
struct workspace *ws;
struct ws_win *win, *ww;
- int i, ws_idx, border_me = 0;
+ 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;
const char *errstr;
struct pid_e *p;
struct quirk *qp;
- uint32_t event_mask;
+ 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_protocols(conn, id, prot),
&wpr, NULL)) {
for (i = 0; i < wpr.atoms_len; i++) {
- if (wpr.atoms[i] == takefocus)
+ if (wpr.atoms[i] == a_takefocus)
win->take_focus = 1;
- if (wpr.atoms[i] == adelete)
+ if (wpr.atoms[i] == a_delete)
win->can_delete = 1;
}
xcb_icccm_get_wm_protocols_reply_wipe(&wpr);
if (win->java) {
focus_win(win->child_trans);
if (win->child_trans->take_focus)
- client_msg(win, takefocus);
+ client_msg(win, a_takefocus);
} else {
/* make sure transient hasn't disappeared */
if (validate_win(win->child_trans) == 0) {
focus_win(win->child_trans);
if (win->child_trans->take_focus)
- client_msg(win->child_trans, takefocus);
+ client_msg(win->child_trans,
+ a_takefocus);
} else {
win->child_trans = NULL;
focus_win(win);
if (win->take_focus)
- client_msg(win, takefocus);
+ client_msg(win, a_takefocus);
}
}
} else {
/* regular focus */
focus_win(win);
if (win->take_focus)
- client_msg(win, takefocus);
+ client_msg(win, a_takefocus);
}
}
void
keypress(xcb_key_press_event_t *e)
{
- KeySym keysym;
+ xcb_keysym_t keysym;
struct key *kp;
- keysym = XkbKeycodeToKeysym(display, (KeyCode)e->detail, 0, 0);
+ keysym = xcb_key_press_lookup_keysym(syms, e, 0);
- DNPRINTF(SWM_D_EVENT, "keypress: %u\n", e->detail);
+ DNPRINTF(SWM_D_EVENT, "keypress: %u %u\n", e->detail, keysym);
if ((kp = key_lookup(CLEANMASK(e->state), keysym)) == NULL)
return;
buttonpress(xcb_button_press_event_t *e)
{
struct ws_win *win;
- int i, action;
+ int i;
+ unsigned int action;
DNPRINTF(SWM_D_EVENT, "buttonpress: window 0x%x, detail: %u\n",
e->event, e->detail);
enternotify(xcb_enter_notify_event_t *e)
{
struct ws_win *win;
-#if 0
- struct ws_win *w;
- Window focus_return;
- int revert_to_return;
-#endif
DNPRINTF(SWM_D_FOCUS, "enternotify: window: 0x%x, mode: %d, detail: "
"%d, root: 0x%x, subwindow: 0x%x, same_screen_focus: %s, "
"state: %d\n", e->event, e->mode, e->detail, e->root,
case SWM_FOCUS_FOLLOW:
break;
case SWM_FOCUS_SYNERGY:
-#if 0
- /*
- * all these checks need to be in this order because the
- * XCheckTypedWindowEvent relies on weeding out the previous events
- *
- * making this code an option would enable a follow mouse for focus
- * feature
- */
-
- /*
- * state is set when we are switching workspaces and focus is set when
- * the window or a subwindow already has focus (occurs during restart).
- *
- * Only honor the focus flag if last_focus_event is not FocusOut,
- * this allows spectrwm to continue to control focus when another
- * program is also playing with it.
- */
- if (ev->state || (ev->focus && last_focus_event != FocusOut)) {
- DNPRINTF(SWM_D_EVENT, "ignoring enternotify: focus\n");
- return;
- }
-
- /*
- * happens when a window is created or destroyed and the border
- * crosses the mouse pointer and when switching ws
- *
- * we need the subwindow test to see if we came from root in order
- * to give focus to floaters
- */
- if (ev->mode == NotifyNormal && ev->detail == NotifyVirtual &&
- ev->subwindow == 0) {
- DNPRINTF(SWM_D_EVENT, "ignoring enternotify: NotifyVirtual\n");
- return;
- }
-
- /* this window already has focus */
- if (ev->mode == NotifyNormal && ev->detail == NotifyInferior) {
- DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win has focus\n");
- return;
- }
-
- /* this window is being deleted or moved to another ws */
- if (XCheckTypedWindowEvent(display, ev->window, ConfigureNotify,
- &cne) == True) {
- DNPRINTF(SWM_D_EVENT, "ignoring enternotify: configurenotify\n");
- XPutBackEvent(display, &cne);
- return;
- }
-
- if ((win = find_window(ev->window)) == NULL) {
- DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win == NULL\n");
- return;
- }
-
- /*
- * In fullstack kill all enters unless they come from a different ws
- * (i.e. another region) or focus has been grabbed externally.
- */
- if (win->ws->cur_layout->flags & SWM_L_FOCUSPREV &&
- last_focus_event != FocusOut) {
- XGetInputFocus(display, &focus_return, &revert_to_return);
- if ((w = find_window(focus_return)) == NULL ||
- w->ws == win->ws) {
- DNPRINTF(SWM_D_EVENT, "ignoring event: fullstack\n");
- return;
- }
- }
-#endif
break;
}
}
switch (e->atom) {
-#if 0
- case XCB_ATOM_WM_NORMAL_HINTS:
- xcb_icccm_get_wm_normal_hints(conn,
- xcb_iccom_get_wm_normal_hints(conn, win->id),
- &win->sh, NULL);
- warnx("normal hints: flag 0x%x", win->sh.flags);
- if (win->sh.flags & XCB_SIZE_HINT_P_MIN_SIZE) {
- WIDTH(win) = win->sh.min_width;
- HEIGHT(win) = win->sh.min_height;
- warnx("min %d %d", WIDTH(win), HEIGHT(win));
- }
- XMoveResizeWindow(display, win->id,
- X(win), Y(win), WIDTH(win), HEIGHT(win));
-#endif
case XCB_ATOM_WM_CLASS:
case XCB_ATOM_WM_NAME:
bar_update();
if (e->type == ewmh[_NET_CLOSE_WINDOW].atom) {
DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_CLOSE_WINDOW\n");
if (win->can_delete)
- client_msg(win, adelete);
+ client_msg(win, a_delete);
else
xcb_kill_client(conn, win->id);
}
xcb_flush(conn);
}
-int
-xerror_start(Display *d, XErrorEvent *ee)
-{
- other_wm = 1;
- return (-1);
-}
-
-int
-xerror(Display *d, XErrorEvent *ee)
-{
- /* warnx("error: %p %p", display, ee); */
- return (-1);
-}
-
-int
+void
active_wm(void)
{
- other_wm = 0;
- xerrorxlib = XSetErrorHandler(xerror_start);
+ int num_screens, i;
+ const uint32_t val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
+ xcb_screen_t *sc;
/* this causes an error if some other window manager is running */
- XSelectInput(display, DefaultRootWindow(display),
- SubstructureRedirectMask);
- do_sync();
- if (other_wm)
- return (1);
-
- XSetErrorHandler(xerror);
- do_sync();
- return (0);
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++) {
+ sc = get_screen(i);
+ xcb_change_window_attributes(conn, sc->root,
+ XCB_CW_EVENT_MASK, &val);
+ }
}
void
screens[i].idx = i;
TAILQ_INIT(&screens[i].rl);
TAILQ_INIT(&screens[i].orl);
- screens[i].root = RootWindow(display, i);
+ screens[i].root = get_screen(i)->root;
/* set default colors */
setscreencolor("red", i + 1, SWM_S_COLOR_FOCUS);
if ((clock_format = strdup("%a %b %d %R %Z %Y")) == NULL)
err(1, "setup_globals: strdup: failed to allocate memory.");
+
+ if ((syms = xcb_key_symbols_alloc(conn)) == NULL)
+ errx(1, "unable to allocate key symbols");
+
+ a_state = get_atom_from_string("WM_STATE");
+ a_prot = get_atom_from_string("WM_PROTOCOLS");
+ a_delete = get_atom_from_string("WM_DELETE_WINDOW");
+ a_takefocus = get_atom_from_string("WM_TAKE_FOCUS");
+ a_wmname = get_atom_from_string("WM_NAME");
+ a_netwmname = get_atom_from_string("_NET_WM_NAME");
+ 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");
}
void
start_argv = argv;
warnx("Welcome to spectrwm V%s Build: %s", SPECTRWM_VERSION, buildstr);
- if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, "") ||
- !XSupportsLocale())
+ if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, ""))
warnx("no locale support");
- if (!X_HAVE_UTF8_STRING)
- warnx("no UTF-8 support");
-
- if (!(display = XOpenDisplay(0)))
- errx(1, "can not open display");
-
/* handle some signals */
bzero(&sact, sizeof(sact));
sigemptyset(&sact.sa_mask);
sact.sa_flags = SA_NOCLDSTOP;
sigaction(SIGCHLD, &sact, NULL);
- conn = XGetXCBConnection(display);
+ conn = xcb_connect(NULL, NULL);
if (xcb_connection_has_error(conn))
errx(1, "can not get XCB connection");
+ xcb_prefetch_extension_data(conn, &xcb_randr_id);
xfd = xcb_get_file_descriptor(conn);
- syms = xcb_key_symbols_alloc(conn);
- if (!syms)
- errx(1, "unable to allocate key symbols");
-
- astate = get_atom_from_string("WM_STATE");
- aprot = get_atom_from_string("WM_PROTOCOLS");
- adelete = get_atom_from_string("WM_DELETE_WINDOW");
- takefocus = get_atom_from_string("WM_TAKE_FOCUS");
- a_wmname = get_atom_from_string("WM_NAME");
- a_netwmname = get_atom_from_string("_NET_WM_NAME");
- 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");
/* look for local and global conf file */
pwd = getpwuid(getuid());
free(evt);
}
- if (active_wm())
- errx(1, "other wm running");
-
+ active_wm();
xcb_aux_sync(conn);
+ if (xcb_poll_for_event(conn) != NULL)
+ errx(1, "another window manager is currently running");
+
setup_globals();
setup_screens();
setup_keys();
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
xcb_key_symbols_free(syms);
xcb_disconnect(conn);
Got questions, comments, patches, etc.? Contact Jason Woofenden