#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_name xcb_get_wm_name
+#define xcb_icccm_get_wm_name_reply xcb_get_wm_name_reply
+#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)
void constrain_window(struct ws_win *, struct swm_region *, int);
void update_window(struct ws_win *);
void spawn_select(struct swm_region *, union arg *, char *, int *);
-unsigned char *get_win_name(xcb_window_t);
+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);
+xcb_screen_t *get_screen(int);
+
+xcb_screen_t *
+get_screen(int screen)
+{
+ xcb_screen_iterator_t i;
+
+ i = xcb_setup_roots_iterator(xcb_get_setup(conn));
+ for (; i.rem; --screen, xcb_screen_next(&i))
+ if (screen == 0)
+ return (i.data);
+
+ return (NULL);
+}
+
+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);
}
xcb_atom_t
return (XCB_ATOM_NONE);
}
-int
-get_property(Window id, Atom atom, long count, Atom type, unsigned long *nitems,
- unsigned long *nbytes, unsigned char **data)
-{
- int format, status;
- unsigned long *nbytes_ret, *nitems_ret;
- unsigned long nbytes_tmp, nitems_tmp;
- Atom real;
-
- nbytes_ret = nbytes != NULL ? nbytes : &nbytes_tmp;
- nitems_ret = nitems != NULL ? nitems : &nitems_tmp;
-
- status = XGetWindowProperty(display, id, atom, 0L, count, False, type,
- &real, &format, nitems_ret, nbytes_ret, data);
-
- if (status != Success)
- return (False);
- if (real != type)
- return (False);
-
- return (True);
-}
-
void
update_iconic(struct ws_win *win, int 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);
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);
void
dumpwins(struct swm_region *r, union arg *args)
{
- struct ws_win *win;
- uint16_t state;
- XWindowAttributes wa;
+ struct ws_win *win;
+ uint16_t state;
+ xcb_get_window_attributes_cookie_t c;
+ xcb_get_window_attributes_reply_t *wa;
if (r->ws == NULL) {
warnx("dumpwins: invalid workspace");
}
warnx("=== managed window list ws %02d ===", r->ws->idx);
-
TAILQ_FOREACH(win, &r->ws->winlist, entry) {
state = getstate(win->id);
- if (!XGetWindowAttributes(display, win->id, &wa))
- warnx("window: 0x%lx, failed XGetWindowAttributes",
+ c = xcb_get_window_attributes(conn, win->id);
+ 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%x, failed xcb_get_window_attributes",
win->id);
- warnx("window: 0x%lx, map_state: %d, state: %u, "
- "transient: 0x%lx", win->id, wa.map_state, state,
- win->transient);
}
warnx("===== unmanaged window list =====");
TAILQ_FOREACH(win, &r->ws->unmanagedlist, entry) {
state = getstate(win->id);
- if (!XGetWindowAttributes(display, win->id, &wa))
- warnx("window: 0x%lx, failed XGetWindowAttributes",
+ c = xcb_get_window_attributes(conn, win->id);
+ 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%x, failed xcb_get_window_attributes",
win->id);
- warnx("window: 0x%lx, map_state: %d, state: %u, "
- "transient: 0x%lx", win->id, wa.map_state, state,
- win->transient);
}
warnx("=================================");
{
unsigned int sidx, x, y, w, h;
int num_screens;
+ xcb_screen_t *screen;
- 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>");
sidx, num_screens);
sidx--;
+ screen = get_screen(sidx);
if (w < 1 || h < 1)
errx(1, "region %ux%u+%u+%u too small", w, h, x, y);
- if (x > DisplayWidth(display, sidx) ||
- y > DisplayHeight(display, sidx) ||
- w + x > DisplayWidth(display, sidx) ||
- h + y > DisplayHeight(display, sidx)) {
+ if (x > screen->width_in_pixels ||
+ y > screen->height_in_pixels ||
+ w + x > screen->width_in_pixels ||
+ h + y > screen->height_in_pixels) {
warnx("ignoring region %ux%u+%u+%u - not within screen "
"boundaries (%ux%u)", w, h, x, y,
- DisplayWidth(display, sidx), DisplayHeight(display, sidx));
+ screen->width_in_pixels, screen->height_in_pixels);
return;
}
void
bar_window_name(char *s, size_t sz, struct swm_region *r)
{
- unsigned char *title;
+ char *title;
if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
return;
return;
strlcat(s, (char *)title, sz);
- XFree(title);
+ free(title);
}
int urgent[SWM_WS_MAX];
void
bar_urgent(char *s, size_t sz)
{
- XWMHints *wmh = NULL;
struct ws_win *win;
int i, j, num_screens;
char b[8];
+ xcb_get_property_cookie_t c;
+ 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) {
- wmh = XGetWMHints(display, win->id);
- if (wmh == NULL)
+ c = xcb_icccm_get_wm_hints(conn, win->id);
+ if (xcb_icccm_get_wm_hints_reply(conn, c,
+ &hints, NULL) == 0)
continue;
-
- if (wmh->flags & XUrgencyHint)
+ if (hints.flags & XCB_ICCCM_WM_HINT_X_URGENCY)
urgent[j] = 1;
- XFree(wmh);
}
for (i = 0; i < workspace_limit; i++) {
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");
char **missing_charsets;
int num_missing_charsets = 0;
int i;
+ xcb_screen_t *screen = get_screen(r->s->idx);
if (bar_fs) {
XFreeFontSet(display, bar_fs);
r->s->c[SWM_S_COLOR_BAR].color);
r->bar->buffer = XCreatePixmap(display, r->bar->id, WIDTH(r->bar),
- HEIGHT(r->bar), DefaultDepth(display, r->s->idx));
+ HEIGHT(r->bar), screen->root_depth);
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, True, win->id,
+ 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, True, win->id,
+ 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];
focus(r, &a);
}
-unsigned char *
+char *
get_win_name(xcb_window_t win)
{
- unsigned char *prop = NULL;
- unsigned long nbytes, nitems;
-
- /* try _NET_WM_NAME first */
- if (get_property(win, a_netwmname, 0L, a_utf8_string, NULL, &nbytes,
- &prop)) {
- XFree(prop);
- if (get_property(win, a_netwmname, nbytes, a_utf8_string,
- &nitems, NULL, &prop))
- return (prop);
+ char *name = NULL;
+ xcb_get_property_cookie_t c;
+ xcb_get_text_property_reply_t r;
+
+ c = xcb_icccm_get_wm_name(conn, win);
+ if (xcb_icccm_get_wm_name_reply(conn, c, &r, NULL)) {
+ name = malloc((r.name_len + 1) * sizeof(char *));
+ if (!name) {
+ xcb_get_text_property_reply_wipe(&r);
+ return (NULL);
+ }
+ memcpy(name, r.name, r.name_len * sizeof(char *));
+ name[r.name_len] = '\0';
}
- /* fallback to WM_NAME */
- if (!get_property(win, a_wmname, 0L, a_string, NULL, &nbytes, &prop))
- return (NULL);
- XFree(prop);
- if (get_property(win, a_wmname, nbytes, a_string, &nitems, NULL, &prop))
- return (prop);
+ xcb_get_text_property_reply_wipe(&r);
- return (NULL);
+ return (name);
}
void
{
struct ws_win *win;
FILE *lfile;
- unsigned char *name;
+ char *name;
int count = 0;
DNPRINTF(SWM_D_MISC, "uniconify\n");
if (name == NULL)
continue;
fprintf(lfile, "%s.%u\n", name, win->id);
- XFree(name);
+ free(name);
}
fclose(lfile);
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);
void
search_resp_uniconify(char *resp, unsigned long len)
{
- unsigned char *name;
+ char *name;
struct ws_win *win;
char *s;
if (name == NULL)
continue;
if (asprintf(&s, "%s.%u", name, win->id) == -1) {
- XFree(name);
+ free(name);
continue;
}
- XFree(name);
+ free(name);
if (strncmp(s, resp, len) == 0) {
/* XXX this should be a callback to generalize */
update_iconic(win, 0);
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);
const char *errstr;
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);
update_window(win);
}
- XSelectInput(display, id, EnterWindowMask | FocusChangeMask |
- PropertyChangeMask | StructureNotifyMask);
+ event_mask = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_FOCUS_CHANGE |
+ XCB_EVENT_MASK_PROPERTY_CHANGE |
+ 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))
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);
}
scan_xrandr(int i)
{
#ifdef SWM_XRR_HAS_CRTC
- int c;
- int ncrtc = 0;
+ int c;
+ int ncrtc = 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_crtc_info_cookie_t cic;
- xcb_randr_get_crtc_info_reply_t *cir;
- xcb_randr_crtc_t *crtc;
+ struct swm_region *r;
+ int num_screens;
+ 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 = NULL;
+ xcb_randr_crtc_t *crtc;
+ xcb_screen_t *screen = get_screen(i);
num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
if (i >= num_screens)
/* 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));
+ screen->width_in_pixels,
+ screen->height_in_pixels);
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 (cir == NULL || cir->mode == 0)
new_region(&screens[i], 0, 0,
- DisplayWidth(display, i),
- DisplayHeight(display, i));
+ screen->width_in_pixels,
+ screen->height_in_pixels);
else
new_region(&screens[i],
cir->x, cir->y, cir->width, cir->height);
if (srr)
free(srr);
if (cir)
- free(cir);
+ free(cir);
} else
#endif /* SWM_XRR_HAS_CRTC */
{
- new_region(&screens[i], 0, 0, DisplayWidth(display, i),
- DisplayHeight(display, i));
+ new_region(&screens[i], 0, 0, screen->width_in_pixels,
+ screen->height_in_pixels);
}
}
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]);
}
setup_screens(void)
{
int i, j, k, num_screens;
- int errorbase;
struct workspace *ws;
XGCValues gcv;
-
+ const xcb_query_extension_reply_t *qep;
xcb_randr_query_version_cookie_t c;
xcb_randr_query_version_reply_t *r;
"screens");
/* initial Xrandr setup */
- xrandr_support = XRRQueryExtension(display,
- &xrandr_eventbase, &errorbase);
- if (xrandr_support) {
- c = xcb_randr_query_version(conn, True, False);
- r = xcb_randr_query_version_reply(conn, c, NULL);
- if (r) {
- if (r->major_version < 1)
- xrandr_support = 0;
- free(r);
- } else
- xrandr_support = 0;
+ xrandr_support = False;
+ c = xcb_randr_query_version(conn, True, True);
+ r = xcb_randr_query_version_reply(conn, c, NULL);
+ if (r) {
+ if (r->major_version >= 1)
+ xrandr_support = True;
+ free(r);
}
+ qep = xcb_get_extension_data(conn, &xcb_randr_id);
+ xrandr_eventbase = qep->first_event;
/* map physical screens */
for (i = 0; i < num_screens; i++) {
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;
- xcb_generic_event_t *evt;
-
+
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 ((evt = xcb_poll_for_event(conn)) == 0) {
+ while (XPending(display)) {
XNextEvent(display, &e);
if (running == 0)
goto done;
xrandr_geteventname(&e), e.type);
switch (e.type - xrandr_eventbase) {
- case RRScreenChangeNotify:
+ case XCB_RANDR_SCREEN_CHANGE_NOTIFY:
screenchange(&e);
break;
default:
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);