#include <X11/Xlib-xcb.h>
#include <xcb/randr.h>
#include <xcb/xcb_icccm.h>
+#include <xcb/xcb_keysyms.h>
#include <X11/Xproto.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xrandr.h>
#endif
#endif
+#if defined(__OpenBSD__)
+#define xcb_icccm_wm_hints_t xcb_wm_hints_t
+#define xcb_icccm_get_wm_hints xcb_get_wm_hints
+#define xcb_icccm_get_wm_hints_reply xcb_get_wm_hints_reply
+#define XCB_ICCCM_WM_HINT_X_URGENCY XCB_WM_HINT_X_URGENCY
+#define XCB_ICCCM_WM_STATE_ICONIC XCB_WM_STATE_ICONIC
+#define XCB_ICCCM_WM_STATE_WITHDRAWN XCB_WM_STATE_WITHDRAWN
+#define XCB_ICCCM_WM_STATE_NORMAL XCB_WM_STATE_NORMAL
+#define xcb_icccm_get_wm_transient_for xcb_get_wm_transient_for
+#define xcb_icccm_get_wm_transient_for_reply xcb_get_wm_transient_for_reply
+#endif
+
/*#define SWM_DEBUG*/
#ifdef SWM_DEBUG
#define DPRINTF(x...) do { if (swm_debug) fprintf(stderr, x); } while (0)
unsigned char *get_win_name(xcb_window_t);
xcb_atom_t get_atom_from_string(const char *);
void map_window_raised(xcb_window_t);
+void do_sync(void);
+
+void
+do_sync(void)
+{
+ xcb_get_input_focus_cookie_t c;
+ xcb_get_input_focus_reply_t *r;
+
+ /* mimic XSync() */
+ c = xcb_get_input_focus(conn);
+ xcb_flush(conn);
+ r = xcb_get_input_focus_reply(conn, c, NULL);
+ if (r)
+ free(r);
+}
void
map_window_raised(xcb_window_t win)
{
uint32_t val = XCB_STACK_MODE_ABOVE;
- xcb_configure_window(conn, win,
+ xcb_configure_window(conn, win,
XCB_CONFIG_WINDOW_STACK_MODE, &val);
- xcb_map_window(conn, win);
+ xcb_map_window(conn, win);
xcb_flush(conn);
}
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);
int32_t v = 0, *vtmp;
xcb_atom_t iprop;
xcb_get_property_cookie_t pc;
- xcb_get_property_reply_t *pr;
+ xcb_get_property_reply_t *pr = NULL;
iprop = get_atom_from_string("_SWM_ICONIC");
if (iprop == XCB_ATOM_NONE)
0, 1);
pr = xcb_get_property_reply(conn, pc, NULL);
if (!pr)
- goto out;
+ goto out;
if (pr->type != XCB_ATOM_INTEGER || pr->format != 32)
goto out;
vtmp = xcb_get_property_value(pr);
int i, j, num_screens;
sup_list = get_atom_from_string("_NET_SUPPORTED");
-
+
for (i = 0; i < LENGTH(ewmh); i++)
ewmh[i].atom = get_atom_from_string(ewmh[i].name);
sup_check = get_atom_from_string("_NET_SUPPORTING_WM_CHECK");
sup_list = get_atom_from_string("_NET_SUPPORTED");
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
-
+
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,
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);
}
}
n = xcb_get_property_value_length(r);
for (i = 0; i < n; i++) {
- type = *((xcb_atom_t *)xcb_get_property_value(r));
+ type = *((xcb_atom_t *)xcb_get_property_value(r));
if (type == ewmh[_NET_WM_WINDOW_TYPE_NORMAL].atom)
break;
if (type == ewmh[_NET_WM_WINDOW_TYPE_DOCK].atom ||
if (!win->floating)
return (0);
- DNPRINTF(SWM_D_MISC, "ewmh_set_win_fullscreen: window: 0x%lx, "
+ DNPRINTF(SWM_D_MISC, "ewmh_set_win_fullscreen: window: 0x%x, "
"fullscreen %s\n", win->id, YESNO(fs));
if (fs) {
if (win->ewmh_flags & EWMH_F_SKIP_PAGER)
xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id,
ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1,
- &ewmh[_NET_WM_STATE_SKIP_PAGER].atom);
+ &ewmh[_NET_WM_STATE_SKIP_PAGER].atom);
if (win->ewmh_flags & EWMH_F_SKIP_TASKBAR)
xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id,
ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1,
r = xcb_get_property_reply(conn, c, NULL);
if (!r)
return;
-
+
states = xcb_get_property_value(r);
n = xcb_get_property_value_length(r);
struct ws_win *win;
uint16_t state;
xcb_get_window_attributes_cookie_t c;
- xcb_get_window_attributes_reply_t *r;
+ xcb_get_window_attributes_reply_t *wa;
if (r->ws == NULL) {
warnx("dumpwins: invalid workspace");
TAILQ_FOREACH(win, &r->ws->winlist, entry) {
state = getstate(win->id);
c = xcb_get_window_attributes(conn, win->id);
- r = xcb_get_window_attributes_reply(conn, c, NULL);
- if (r) {
+ wa = xcb_get_window_attributes_reply(conn, c, NULL);
+ if (wa) {
warnx("window: 0x%x, map_state: %d, state: %u, "
- "transient: 0x%x", win->id, wa.map_state,
+ "transient: 0x%x", win->id, wa->map_state,
state, win->transient);
- free(r);
- } else
+ free(wa);
+ } else
warnx("window: 0x%x, failed xcb_get_window_attributes",
win->id);
}
TAILQ_FOREACH(win, &r->ws->unmanagedlist, entry) {
state = getstate(win->id);
c = xcb_get_window_attributes(conn, win->id);
- r xcb_get_window_attributes_reply(conn, c, NULL);
- if (r) {
- warnx("window: 0x%lx, map_state: %d, state: %u, "
- "transient: 0x%lx", win->id, wa.map_state,
- state, win->transient);
- free(r);
+ wa = xcb_get_window_attributes_reply(conn, c, NULL);
+ if (wa) {
+ warnx("window: 0x%x, map_state: %d, state: %u, "
+ "transient: 0x%x", win->id, wa->map_state,
+ state, win->transient);
+ free(wa);
} else
- warnx("window: 0x%lx, failed XGetWindowAttributes",
+ warnx("window: 0x%x, failed xcb_get_window_attributes",
win->id);
}
unsigned int sidx, x, y, w, h;
int num_screens;
- num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ 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)
errx(1, "invalid custom region, "
"should be 'screen[<n>]:<n>x<n>+<n>+<n>");
int i, j, num_screens;
char b[8];
xcb_get_property_cookie_t c;
- xcb_wm_hints_t hints;
+ xcb_icccm_wm_hints_t hints;
for (i = 0; i < workspace_limit; i++)
urgent[i] = 0;
for (i = 0; i < num_screens; i++)
for (j = 0; j < workspace_limit; j++)
TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) {
- c = xcb_get_wm_hints(conn, win->id);
- if (xcb_get_wm_hints_reply(conn, c,
+ c = xcb_icccm_get_wm_hints(conn, win->id);
+ if (xcb_icccm_get_wm_hints_reply(conn, c,
&hints, NULL) == 0)
continue;
- if (hints.flags & XCB_WM_HINT_X_URGENCY)
+ if (hints.flags & XCB_ICCCM_WM_HINT_X_URGENCY)
urgent[j] = 1;
}
bar_toggle(struct swm_region *r, union arg *args)
{
struct swm_region *tmpr;
- int i, num_screens;
+ int i, num_screens;
DNPRINTF(SWM_D_BAR, "bar_toggle\n");
xcb_randr_select_input(conn, r->bar->id,
XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE);
-
+
if (bar_enabled)
map_window_raised(r->bar->id);
- DNPRINTF(SWM_D_BAR, "bar_setup: window: 0x%lx, (x,y) w x h: (%d,%d) "
+ DNPRINTF(SWM_D_BAR, "bar_setup: window: 0x%x, (x,y) w x h: (%d,%d) "
"%d x %d\n", WINID(r->bar), X(r->bar), Y(r->bar), WIDTH(r->bar),
HEIGHT(r->bar));
result = *((uint16_t *)xcb_get_property_value(r));
free(r);
}
-
+
return (result);
}
ev.type = aprot;
ev.format = 32;
ev.data.data32[0] = a;
- ev.data.data32[1] = XCB_CURRENT_TIME;
+ ev.data.data32[1] = XCB_CURRENT_TIME;
xcb_send_event(conn, False, win->id,
XCB_EVENT_MASK_NO_EVENT, (const char *)&ev);
+ xcb_flush(conn);
}
/* synthetic response to a ConfigureRequest when not making a change */
void
config_win(struct ws_win *win, XConfigureRequestEvent *ev)
{
- XConfigureEvent ce;
+ xcb_configure_notify_event_t ce;
if (win == NULL)
return;
/* send notification of unchanged state. */
- ce.type = ConfigureNotify;
+ bzero(&ce, sizeof(ce));
+ ce.response_type = XCB_CONFIGURE_NOTIFY;
ce.x = X(win);
ce.y = Y(win);
ce.width = WIDTH(win);
if (ev == NULL) {
/* EWMH */
- ce.display = display;
ce.event = win->id;
ce.window = win->id;
ce.border_width = BORDER(win);
- ce.above = None;
+ ce.above_sibling = XCB_WINDOW_NONE;
} else {
/* normal */
- ce.display = ev->display;
ce.event = ev->window;
ce.window = ev->window;
/* make response appear more WM_SIZE_HINTS-compliant */
if (win->sh_mask)
- DNPRINTF(SWM_D_MISC, "config_win: hints: window: 0x%lx,"
+ DNPRINTF(SWM_D_MISC, "config_win: hints: window: 0x%x,"
" sh_mask: %ld, min: %d x %d, max: %d x %d, inc: "
"%d x %d\n", win->id, win->sh_mask, SH_MIN_W(win),
SH_MIN_H(win), SH_MAX_W(win), SH_MAX_H(win),
ce.x += BORDER(win) - ev->border_width;
ce.y += BORDER(win) - ev->border_width;
ce.border_width = ev->border_width;
- ce.above = ev->above;
+ ce.above_sibling = ev->above;
}
- DNPRINTF(SWM_D_MISC, "config_win: ewmh: %s, window: 0x%lx, (x,y) w x h: "
+ DNPRINTF(SWM_D_MISC, "config_win: ewmh: %s, window: 0x%x, (x,y) w x h: "
"(%d,%d) %d x %d, border: %d\n", YESNO(ev == NULL), win->id, ce.x,
ce.y, ce.width, ce.height, ce.border_width);
- XSendEvent(display, win->id, False, StructureNotifyMask, (XEvent *)&ce);
+ xcb_send_event(conn, False, win->id, XCB_EVENT_MASK_STRUCTURE_NOTIFY,
+ (char *)&ce);
+ xcb_flush(conn);
}
int
return;
/* don't unmap again */
- if (getstate(win->id) == XCB_WM_STATE_ICONIC)
+ if (getstate(win->id) == XCB_ICCCM_WM_STATE_ICONIC)
return;
- set_win_state(win, XCB_WM_STATE_ICONIC);
+ set_win_state(win, XCB_ICCCM_WM_STATE_ICONIC);
xcb_unmap_window(conn, win->id);
xcb_change_window_attributes(conn, win->id,
struct ws_win *win;
int i, j, num_screens;
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
for (i = 0; i < num_screens; i++)
for (j = 0; j < workspace_limit; j++)
TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
}
void
-fake_keypress(struct ws_win *win, int keysym, int modifiers)
+fake_keypress(struct ws_win *win, xcb_keysym_t keysym, uint16_t modifiers)
{
- XKeyEvent event;
+ xcb_key_press_event_t event;
+ xcb_key_symbols_t *syms;
+ xcb_keycode_t *keycode;
if (win == NULL)
return;
- event.display = display; /* Ignored, but what the hell */
- event.window = win->id;
+ syms = xcb_key_symbols_alloc(conn);
+ keycode = xcb_key_symbols_get_keycode(syms, keysym);
+
+ event.event = win->id;
event.root = win->s->root;
- event.subwindow = None;
- event.time = CurrentTime;
- event.x = X(win);
- event.y = Y(win);
- event.x_root = 1;
- event.y_root = 1;
+ event.child = XCB_WINDOW_NONE;
+ event.time = XCB_CURRENT_TIME;
+ event.event_x = X(win);
+ event.event_y = Y(win);
+ event.root_x = 1;
+ event.root_y = 1;
event.same_screen = True;
- event.keycode = XKeysymToKeycode(display, keysym);
+ event.detail = *keycode;
event.state = modifiers;
- event.type = KeyPress;
- XSendEvent(event.display, event.window, True,
- KeyPressMask, (XEvent *)&event);
+ event.response_type = XCB_KEY_PRESS;
+ xcb_send_event(conn, win->id, True,
+ XCB_EVENT_MASK_KEY_PRESS, (char *)&event);
- event.type = KeyRelease;
- XSendEvent(event.display, event.window, True,
- KeyPressMask, (XEvent *)&event);
+ event.response_type = XCB_KEY_RELEASE;
+ xcb_send_event(conn, win->id, True,
+ XCB_EVENT_MASK_KEY_RELEASE, (char *)&event);
+ xcb_flush(conn);
+ xcb_key_symbols_free(syms);
}
void
XEvent cne;
xcb_window_t none = XCB_WINDOW_NONE;
- DNPRINTF(SWM_D_FOCUS, "unfocus_win: window: 0x%lx\n", WINID(win));
+ DNPRINTF(SWM_D_FOCUS, "unfocus_win: window: 0x%x\n", WINID(win));
if (win == NULL)
return;
xcb_get_input_focus_reply_t *r;
xcb_window_t cur_focus = XCB_WINDOW_NONE;
- DNPRINTF(SWM_D_FOCUS, "focus_win: window: 0x%lx\n", WINID(win));
+ DNPRINTF(SWM_D_FOCUS, "focus_win: window: 0x%x\n", WINID(win));
if (win == NULL)
return;
wl = &ws->winlist;
cur_focus = ws->focus;
- DNPRINTF(SWM_D_FOCUS, "focus_prev: window: 0x%lx, cur_focus: 0x%lx\n",
+ DNPRINTF(SWM_D_FOCUS, "focus_prev: window: 0x%x, cur_focus: 0x%x\n",
WINID(win), WINID(cur_focus));
/* pickle, just focus on whatever */
#endif
DNPRINTF(SWM_D_STACK, "stack: begin\n");
-
+
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
for (i = 0; i < num_screens; i++) {
#ifdef SWM_DEBUG
win->g_float.x -= X(r);
win->g_float.y -= Y(r);
win->g_floatvalid = 1;
- DNPRINTF(SWM_D_MISC, "store_float_geom: window: 0x%lx, g: (%d,%d)"
+ DNPRINTF(SWM_D_MISC, "store_float_geom: window: 0x%x, g: (%d,%d)"
" %d x %d, g_float: (%d,%d) %d x %d\n", win->id, X(win), Y(win),
WIDTH(win), HEIGHT(win), win->g_float.x, win->g_float.y,
win->g_float.w, win->g_float.h);
if (win == NULL)
return;
- DNPRINTF(SWM_D_MISC, "stack_floater: window: 0x%lx\n", win->id);
+ DNPRINTF(SWM_D_MISC, "stack_floater: window: 0x%x\n", win->id);
/*
* to allow windows to change their size (e.g. mplayer fs) only retrieve
if (win->ws->idx == wsid)
return;
- DNPRINTF(SWM_D_MOVE, "send_to_ws: window: 0x%lx\n", win->id);
+ DNPRINTF(SWM_D_MOVE, "send_to_ws: window: 0x%x\n", win->id);
ws = win->ws;
nws = &win->s->ws[wsid];
sw->gc = XCreateGC(display, w, 0, &gcv);
map_window_raised(w);
XSetForeground(display, sw->gc, r->s->c[SWM_S_COLOR_BAR].color);
-
+
DRAWSTRING(display, w, bar_fs, sw->gc, 2,
(bar_fs_extents->max_logical_extent.height -
lbox.height) / 2 - lbox.y, s, len);
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_BORDER_WIDTH;
wc[0] = X(win);
wc[1] = Y(win);
wc[2] = WIDTH(win);
if (win->ewmh_flags & EWMH_F_FULLSCREEN)
return;
- DNPRINTF(SWM_D_MOUSE, "resize: window: 0x%lx, floating: %s, "
- "transient: 0x%lx\n", win->id, YESNO(win->floating),
+ DNPRINTF(SWM_D_MOUSE, "resize: window: 0x%x, floating: %s, "
+ "transient: 0x%x\n", win->id, YESNO(win->floating),
win->transient);
if (!(win->transient != 0 || win->floating != 0))
/* not free, don't sync more than 120 times / second */
if ((ev.xmotion.time - time) > (1000 / 120) ) {
time = ev.xmotion.time;
- XSync(display, False);
+ do_sync();
update_window(win);
}
break;
}
} while (ev.type != ButtonRelease);
if (time) {
- XSync(display, False);
+ do_sync();
update_window(win);
}
store_float_geom(win,r);
if (win->ewmh_flags & EWMH_F_FULLSCREEN)
return;
- DNPRINTF(SWM_D_MOUSE, "move: window: 0x%lx, floating: %s, transient: "
- "0x%lx\n", win->id, YESNO(win->floating), win->transient);
+ DNPRINTF(SWM_D_MOUSE, "move: window: 0x%x, floating: %s, transient: "
+ "0x%x\n", win->id, YESNO(win->floating), win->transient);
/* in max_stack mode should only move transients */
if (win->ws->cur_layout == &layouts[SWM_MAX_STACK] && !win->transient)
/* not free, don't sync more than 120 times / second */
if ((ev.xmotion.time - time) > (1000 / 120) ) {
time = ev.xmotion.time;
- XSync(display, False);
+ do_sync();
update_window(win);
}
break;
}
} while (ev.type != ButtonRelease);
if (time) {
- XSync(display, False);
+ do_sync();
update_window(win);
}
store_float_geom(win, r);
- xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
+ xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
/* drain events */
drain_enter_notify();
if (TAILQ_EMPTY(&screens[k].rl))
continue;
xcb_ungrab_key(conn, XCB_GRAB_ANY, screens[k].root,
- XCB_MOD_MASK_ANY);
+ XCB_MOD_MASK_ANY);
RB_FOREACH(kp, key_tree, &keys) {
if ((code = XKeysymToKeycode(display, kp->keysym)))
for (j = 0; j < LENGTH(modifiers); j++)
xcb_grab_button(conn, False, 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);
+ XCB_BUTTON_MASK_ANY);
}
const char *quirkname[] = {
parent->child_trans = win;
else {
DNPRINTF(SWM_D_MISC, "set_child_transient: parent doesn't exist"
- " for 0x%lx trans 0x%lx\n", win->id, win->transient);
+ " for 0x%x trans 0x%x\n", win->id, win->transient);
if (win->hints == NULL) {
warnx("no hints for 0x%x", win->id);
struct pid_e *p;
struct quirk *qp;
uint32_t event_mask;
-
+
if ((win = find_window(id)) != NULL)
return (win); /* already being managed */
/* see if we are on the unmanaged list */
if ((win = find_unmanaged_window(id)) != NULL) {
DNPRINTF(SWM_D_MISC, "manage_window: previously unmanaged "
- "window: 0x%lx\n", win->id);
+ "window: 0x%x\n", win->id);
TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry);
if (win->transient)
set_child_transient(win, &trans);
if (trans) {
win->transient = trans;
set_child_transient(win, &trans);
- DNPRINTF(SWM_D_MISC, "manage_window: window: 0x%lx, "
- "transient: 0x%lx\n", win->id, win->transient);
+ DNPRINTF(SWM_D_MISC, "manage_window: window: 0x%x, "
+ "transient: 0x%x\n", win->id, win->transient);
}
/* get supported protocols */
win->floatmaxed = 0;
win->ewmh_flags = 0;
- DNPRINTF(SWM_D_MISC, "manage_window: window: 0x%lx, (x,y) w x h: "
+ DNPRINTF(SWM_D_MISC, "manage_window: window: 0x%x, (x,y) w x h: "
"(%d,%d) %d x %d, ws: %d\n", win->id, X(win), Y(win), WIDTH(win),
HEIGHT(win), ws->idx);
XCB_EVENT_MASK_STRUCTURE_NOTIFY;
xcb_change_window_attributes(conn, id, XCB_CW_EVENT_MASK, &event_mask);
-
+
/* floaters need to be mapped if they are in the current workspace */
if ((win->floating || win->transient) && (ws->idx == r->ws->idx))
map_window_raised(win->id);
void
free_window(struct ws_win *win)
{
- DNPRINTF(SWM_D_MISC, "free_window: window: 0x%lx\n", win->id);
+ DNPRINTF(SWM_D_MISC, "free_window: window: 0x%x\n", win->id);
if (win == NULL)
return;
/* needed for restart wm */
- set_win_state(win, XCB_WM_STATE_WITHDRAWN);
+ set_win_state(win, XCB_ICCCM_WM_STATE_WITHDRAWN);
TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry);
if (win == NULL)
return;
- DNPRINTF(SWM_D_MISC, "unmanage_window: window: 0x%lx\n", win->id);
+ DNPRINTF(SWM_D_MISC, "unmanage_window: window: 0x%x\n", win->id);
if (win->transient) {
parent = find_window(win->transient);
/* focus on root just in case */
screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT,
- screen->root, XCB_CURRENT_TIME);
-
+ screen->root, XCB_CURRENT_TIME);
+
focus_prev(win);
if (win->hints) {
void
focus_magic(struct ws_win *win)
{
- DNPRINTF(SWM_D_FOCUS, "focus_magic: window: 0x%lx\n", WINID(win));
+ DNPRINTF(SWM_D_FOCUS, "focus_magic: window: 0x%x\n", WINID(win));
if (win == NULL) {
/* if there are no windows clear the status-bar */
win = manage_window(ev->window);
if (win)
- set_win_state(win, XCB_WM_STATE_NORMAL);
+ set_win_state(win, XCB_ICCCM_WM_STATE_NORMAL);
/*
* focus_win can only set input focus on a mapped window.
if (win == NULL)
return;
- if (getstate(e->xunmap.window) == XCB_WM_STATE_NORMAL) {
+ if (getstate(e->xunmap.window) == XCB_ICCCM_WM_STATE_NORMAL) {
unmanage_window(win);
stack();
/* this causes an error if some other window manager is running */
XSelectInput(display, DefaultRootWindow(display),
SubstructureRedirectMask);
- XSync(display, False);
+ do_sync();
if (other_wm)
return (1);
XSetErrorHandler(xerror);
- XSync(display, False);
+ do_sync();
return (0);
}
#endif /* SWM_XRR_HAS_CRTC */
struct swm_region *r;
int num_screens;
- xcb_randr_get_screen_resources_cookie_t src;
- xcb_randr_get_screen_resources_reply_t *srr;
+ xcb_randr_get_screen_resources_current_cookie_t src;
+ xcb_randr_get_screen_resources_current_reply_t *srr;
xcb_randr_get_crtc_info_cookie_t cic;
- xcb_randr_get_crtc_info_reply_t *cir;
+ xcb_randr_get_crtc_info_reply_t *cir = NULL;
xcb_randr_crtc_t *crtc;
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
/* map virtual screens onto physical screens */
#ifdef SWM_XRR_HAS_CRTC
if (xrandr_support) {
- src = xcb_randr_get_screen_resources(conn, screens[i].root);
- srr = xcb_randr_get_screen_resources_reply(conn, src, NULL);
+ src = xcb_randr_get_screen_resources_current(conn,
+ screens[i].root);
+ srr = xcb_randr_get_screen_resources_current_reply(conn, src,
+ NULL);
if (srr == NULL)
new_region(&screens[i], 0, 0,
DisplayWidth(display, i),
DisplayHeight(display, i));
else
- ncrtc = srr->num_crtcs;
+ ncrtc = srr->num_crtcs;
for (c = 0; c < ncrtc; c++) {
- crtc = xcb_randr_get_screen_resources_crtcs(srr);
+ crtc = xcb_randr_get_screen_resources_current_crtcs(srr);
cic = xcb_randr_get_crtc_info(conn, crtc[c],
- XCB_CURRENT_TIME);
+ XCB_CURRENT_TIME);
cir = xcb_randr_get_crtc_info_reply(conn, cic, NULL);
if (cir && cir->num_outputs == 0)
continue;
if (srr)
free(srr);
if (cir)
- free(cir);
+ free(cir);
} else
#endif /* SWM_XRR_HAS_CRTC */
{
int no;
int i, j, num_screens;
uint16_t state, manage;
-
+
xcb_query_tree_cookie_t qtc;
xcb_query_tree_reply_t *qtr;
xcb_get_window_attributes_cookie_t c;
wins = xcb_query_tree_children(qtr);
no = xcb_query_tree_children_length(qtr);
/* attach windows to a region */
- /* normal windows */
+ /* normal windows */
for (j = 0; j < no; j++) {
c = xcb_get_window_attributes(conn, wins[j]);
r = xcb_get_window_attributes_reply(conn, c, NULL);
free(r);
continue;
}
-
- pc = xcb_get_wm_transient_for(conn, wins[j]);
- if (xcb_get_wm_transient_for_reply(conn, pc, &wins[j],
+
+ pc = xcb_icccm_get_wm_transient_for(conn, wins[j]);
+ if (xcb_icccm_get_wm_transient_for_reply(conn, pc, &wins[j],
NULL)) {
free(r);
continue;
}
state = getstate(wins[j]);
- manage = state == XCB_WM_STATE_ICONIC;
+ manage = state == XCB_ICCCM_WM_STATE_ICONIC;
if (r->map_state == XCB_MAP_STATE_VIEWABLE || manage)
manage_window(wins[j]);
free(r);
continue;
}
free(r);
-
+
state = getstate(wins[j]);
- manage = state == XCB_WM_STATE_ICONIC;
- pc = xcb_get_wm_transient_for(conn, wins[j]);
- if (xcb_get_wm_transient_for_reply(conn, pc, &wins[j],
+ manage = state == XCB_ICCCM_WM_STATE_ICONIC;
+ pc = xcb_icccm_get_wm_transient_for(conn, wins[j]);
+ if (xcb_icccm_get_wm_transient_for_reply(conn, pc, &wins[j],
NULL) && manage)
manage_window(wins[j]);
}
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,
- netwmcheck, utf8_string, 8, strlen("LG3D"), "LG3D");
+ netwmname, utf8_string, 8, strlen("LG3D"), "LG3D");
}
}
int xfd, i, num_screens;
fd_set rd;
struct sigaction sact;
-
+
start_argv = argv;
warnx("Welcome to spectrwm V%s Build: %s", SPECTRWM_VERSION, buildstr);
if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, "") ||
if (focus_mode == SWM_FOCUS_DEFAULT)
drain_enter_notify();
- xfd = xcb_get_file_descriptor(conn);
+ xfd = xcb_get_file_descriptor(conn);
while (running) {
while (XPending(display)) {
XNextEvent(display, &e);
if (screens[i].bar_gc != NULL)
XFreeGC(display, screens[i].bar_gc);
XFreeFontSet(display, bar_fs);
- xcb_disconnect(conn);
+ xcb_disconnect(conn);
XCloseDisplay(display);
return (0);