#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_SIZE_HINT_P_MIN_SIZE XCB_SIZE_HINT_P_MIN_SIZE
+#define XCB_ICCCM_SIZE_HINT_P_MAX_SIZE XCB_SIZE_HINT_P_MAX_SIZE
+#define XCB_ICCCM_SIZE_HINT_P_RESIZE_INC XCB_SIZE_HINT_P_RESIZE_INC
#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_text_property_reply_t xcb_get_text_property_reply_t
+#define xcb_icccm_get_text_property_reply_wipe xcb_get_text_property_reply_wipe
+#define xcb_icccm_get_wm_class xcb_get_wm_class
+#define xcb_icccm_get_wm_class_reply xcb_get_wm_class_reply
+#define xcb_icccm_get_wm_class_reply_t xcb_get_wm_class_reply_t
+#define xcb_icccm_get_wm_class_reply_wipe xcb_get_wm_class_reply_wipe
+#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_get_wm_name xcb_get_wm_name
#define xcb_icccm_get_wm_name_reply xcb_get_wm_name_reply
+#define xcb_icccm_get_wm_normal_hints xcb_get_wm_normal_hints
+#define xcb_icccm_get_wm_normal_hints_reply xcb_get_wm_normal_hints_reply
+#define xcb_icccm_get_wm_protocols xcb_get_wm_protocols
+#define xcb_icccm_get_wm_protocols_reply xcb_get_wm_protocols_reply
+#define xcb_icccm_get_wm_protocols_reply_t xcb_get_wm_protocols_reply_t
+#define xcb_icccm_get_wm_protocols_reply_wipe xcb_get_wm_protocols_reply_wipe
#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
+#define xcb_icccm_wm_hints_t xcb_wm_hints_t
#endif
/*#define SWM_DEBUG*/
#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_mask & PMinSize
+#define SH_MIN(w) (w)->sh.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE
#define SH_MIN_W(w) (w)->sh.min_width
#define SH_MIN_H(w) (w)->sh.min_height
-#define SH_MAX(w) (w)->sh_mask & PMaxSize
+#define SH_MAX(w) (w)->sh.flags & XCB_ICCCM_SIZE_HINT_P_MAX_SIZE
#define SH_MAX_W(w) (w)->sh.max_width
#define SH_MAX_H(w) (w)->sh.max_height
-#define SH_INC(w) (w)->sh_mask & PResizeInc
+#define SH_INC(w) (w)->sh.flags & XCB_ICCCM_SIZE_HINT_P_RESIZE_INC
#define SH_INC_W(w) (w)->sh.width_inc
#define SH_INC_H(w) (w)->sh.height_inc
#define SWM_MAX_FONT_STEPS (3)
unsigned int numlockmask = 0;
Display *display;
xcb_connection_t *conn;
+xcb_key_symbols_t *syms;
int cycle_empty = 0;
int cycle_visible = 0;
struct workspace *ws; /* always valid */
struct swm_screen *s; /* always valid, never changes */
xcb_get_geometry_reply_t *wa;
- XSizeHints sh;
- long sh_mask;
- xcb_get_wm_class_reply_t ch;
- xcb_wm_hints_t hints;
+ xcb_size_hints_t sh;
+ xcb_icccm_get_wm_class_reply_t ch;
+ xcb_icccm_wm_hints_t hints;
};
TAILQ_HEAD(ws_win_list, ws_win);
sizeof(rect), &rect);
/* draw back buffer */
+ gcv[0] = r->s->c[SWM_S_COLOR_BAR].color;
+ 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);
xcb_image_text_8(conn, len, r->bar->buffer, r->s->bar_gc, x,
drain_enter_notify(void)
{
int i = 0;
+ XEvent cne;
- while (xcb_poll_for_event(conn))
+ while (XCheckMaskEvent(display, EnterWindowMask, &cne))
i++;
DNPRINTF(SWM_D_EVENT, "drain_enter_notify: drained: %d\n", i);
ce.window = ev->window;
/* make response appear more WM_SIZE_HINTS-compliant */
- if (win->sh_mask)
+ if (win->sh.flags)
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.flags: %u, min: %d x %d, max: %d x %d, inc: "
+ "%d x %d\n", win->id, win->sh.flags, SH_MIN_W(win),
SH_MIN_H(win), SH_MAX_W(win), SH_MAX_H(win),
SH_INC_W(win), SH_INC_H(win));
fake_keypress(struct ws_win *win, xcb_keysym_t keysym, uint16_t modifiers)
{
xcb_key_press_event_t event;
- xcb_key_symbols_t *syms;
xcb_keycode_t *keycode;
if (win == NULL)
return;
- syms = xcb_key_symbols_alloc(conn);
keycode = xcb_key_symbols_get_keycode(syms, keysym);
event.event = win->id;
xcb_send_event(conn, True, win->id,
XCB_EVENT_MASK_KEY_RELEASE, (char *)&event);
xcb_flush(conn);
-
- xcb_key_symbols_free(syms);
}
void
bar_extra_stop();
bar_extra = 1;
unmap_all();
- XCloseDisplay(display);
+
+ xcb_key_symbols_free(syms);
+ xcb_flush(conn);
+ xcb_disconnect(conn);
+
execvp(start_argv[0], start_argv);
warn("execvp failed");
quit(NULL, NULL);
void
stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
{
- XWindowAttributes wa;
struct swm_geometry win_g, r_g = *g;
struct ws_win *win, *fs_win = NULL;
int i, j, s, stacks;
int split, colno, winno, mwin, msize, mscale;
int remain, missing, v_slice, reconfigure;
int bordered = 1;
+ xcb_get_window_attributes_reply_t *war;
DNPRINTF(SWM_D_STACK, "stack_master: workspace: %d, rot: %s, "
"flip: %s\n", ws->idx, YESNO(rot), YESNO(flip));
update_window(win);
}
- if (XGetWindowAttributes(display, win->id, &wa))
- if (wa.map_state == IsUnmapped)
+ war = xcb_get_window_attributes_reply(conn,
+ xcb_get_window_attributes(conn, win->id),
+ NULL);
+ if (war) {
+ if (war->map_state == XCB_MAP_STATE_UNMAPPED)
map_window_raised(win->id);
+ free(war);
+ }
last_h = win_g.h;
i++;
{
char *name = NULL;
xcb_get_property_cookie_t c;
- xcb_get_text_property_reply_t r;
+ xcb_icccm_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);
- if (!name) {
- xcb_get_text_property_reply_wipe(&r);
- return (NULL);
+ if (r.name_len > 0) {
+ name = malloc(r.name_len + 1);
+ if (!name) {
+ xcb_icccm_get_text_property_reply_wipe(&r);
+ return (NULL);
+ }
+ 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_get_text_property_reply_wipe(&r);
+ xcb_icccm_get_text_property_reply_wipe(&r);
}
return (name);
void
updatenumlockmask(void)
{
- unsigned int i, j;
- XModifierKeymap *modmap;
+ unsigned int i, j;
+ xcb_get_modifier_mapping_reply_t *modmap_r;
+ xcb_keycode_t *modmap, kc;
DNPRINTF(SWM_D_MISC, "updatenumlockmask\n");
numlockmask = 0;
- modmap = XGetModifierMapping(display);
- for (i = 0; i < 8; i++)
- for (j = 0; j < modmap->max_keypermod; j++)
- if (modmap->modifiermap[i * modmap->max_keypermod + j]
- == XKeysymToKeycode(display, XK_Num_Lock))
- numlockmask = (1 << i);
- XFreeModifiermap(modmap);
+ modmap_r = xcb_get_modifier_mapping_reply(conn,
+ xcb_get_modifier_mapping(conn),
+ NULL);
+ if (modmap_r) {
+ modmap = xcb_get_modifier_mapping_keycodes(modmap_r);
+ for (i = 0; i < 8; i++) {
+ for (j = 0; j < modmap_r->keycodes_per_modifier; j++) {
+ kc = modmap[i * modmap_r->keycodes_per_modifier
+ + j];
+
+ if (kc == *((xcb_keycode_t *)xcb_key_symbols_get_keycode(syms,
+ XK_Num_Lock)))
+ numlockmask = (1 << i);
+ }
+ }
+ free(modmap_r);
+ }
}
void
{
int num_screens;
unsigned int j, k;
- KeyCode code;
+ xcb_keycode_t *code;
unsigned int modifiers[] =
{ 0, LockMask, numlockmask, numlockmask | LockMask };
struct key *kp;
xcb_ungrab_key(conn, XCB_GRAB_ANY, screens[k].root,
XCB_MOD_MASK_ANY);
RB_FOREACH(kp, key_tree, &keys) {
- if ((code = XKeysymToKeycode(display, kp->keysym)))
+ if ((code = xcb_key_symbols_get_keycode(syms,
+ kp->keysym)))
for (j = 0; j < LENGTH(modifiers); j++)
- XGrabKey(display, code,
+ xcb_grab_key(conn, True,
+ screens[k].root,
kp->mod | modifiers[j],
- screens[k].root, True,
- GrabModeAsync, GrabModeAsync);
+ *code, XCB_GRAB_MODE_ASYNC,
+ XCB_GRAB_MODE_ASYNC);
}
}
}
struct ws_win *parent, *w;
struct swm_region *r;
struct workspace *ws;
- xcb_wm_hints_t wmh;
+ xcb_icccm_wm_hints_t wmh;
parent = find_window(win->transient);
if (parent)
int i, 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;
uint32_t event_mask;
xcb_atom_t prot;
xcb_get_property_reply_t *gpr;
- xcb_get_wm_protocols_reply_t wpr;
+ xcb_icccm_get_wm_protocols_reply_t wpr;
if ((win = find_window(id)) != NULL)
return (win); /* already being managed */
XCB_ATOM_STRING, 0, SWM_PROPLEN),
NULL);
if (gpr) {
- prop = malloc(xcb_get_property_value_length(gpr) + 1);
- if (prop) {
- memcpy(prop, xcb_get_property_value(gpr),
- xcb_get_property_value_length(gpr));
- prop[xcb_get_property_value_length(gpr)] = '\0';
+ 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);
}
-
}
win->wa = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, id),
NULL);
- XGetWMNormalHints(display, id, &win->sh, &win->sh_mask);
+ xcb_icccm_get_wm_normal_hints_reply(conn,
+ xcb_icccm_get_wm_normal_hints(conn, id),
+ &win->sh, NULL);
xcb_icccm_get_wm_hints_reply(conn,
xcb_icccm_get_wm_hints(conn, id),
&win->hints, NULL);
- xcb_get_wm_transient_for_reply(conn,
- xcb_get_wm_transient_for(conn, id),
+ xcb_icccm_get_wm_transient_for_reply(conn,
+ xcb_icccm_get_wm_transient_for(conn, id),
&trans, NULL);
if (trans) {
win->transient = trans;
"transient: 0x%x\n", win->id, win->transient);
}
- prot = xcb_atom_get_fast_reply(conn,
- xcb_atom_get_fast(conn, False, strlen("WM_PROTOCOLS"),
- "WM_PROTOCOLS"),
- NULL);
+ prot = get_atom_from_string("WM_PROTOCOLS");
+
/* get supported protocols */
- if (xcb_get_wm_protocols_reply(conn,
- xcb_get_wm_protocols(conn, id, prot),
+ if (xcb_icccm_get_wm_protocols_reply(conn,
+ 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] == adelete)
win->can_delete = 1;
}
- xcb_get_wm_protocols_reply_wipe(&wpr);
+ xcb_icccm_get_wm_protocols_reply_wipe(&wpr);
}
win->iconic = get_iconic(win);
ewmh_autoquirk(win);
- if (xcb_get_wm_class_reply(conn,
- xcb_get_wm_class(conn, win->id),
+ if (xcb_icccm_get_wm_class_reply(conn,
+ xcb_icccm_get_wm_class(conn, win->id),
&win->ch, NULL)) {
DNPRINTF(SWM_D_CLASS, "manage_window: class: %s, name: %s\n",
- win->ch.class, win->ch.instance_name);
+ win->ch.class_name, win->ch.instance_name);
/* java is retarded so treat it special */
if (strstr(win->ch.instance_name, "sun-awt")) {
if (win->wa)
free(win->wa);
- xcb_get_wm_class_reply_wipe(&win->ch);
+ xcb_icccm_get_wm_class_reply_wipe(&win->ch);
kill_refs(win);
{
XConfigureRequestEvent *ev = &e->xconfigurerequest;
struct ws_win *win;
- int new = 0;
- XWindowChanges wc;
+ int new = 0, i = 0;
+ uint16_t mask = 0;
+ uint32_t wc[7];
if ((win = find_window(ev->window)) == NULL)
if ((win = find_unmanaged_window(ev->window)) == NULL)
new = 1;
if (new) {
- bzero(&wc, sizeof wc);
- wc.x = ev->x;
- wc.y = ev->y;
- wc.width = ev->width;
- wc.height = ev->height;
- wc.border_width = ev->border_width;
- wc.sibling = ev->above;
- wc.stack_mode = ev->detail;
+ if (ev->value_mask & XCB_CONFIG_WINDOW_X) {
+ mask |= XCB_CONFIG_WINDOW_X;
+ wc[i++] = ev->x;
+ }
+ if (ev->value_mask & XCB_CONFIG_WINDOW_Y) {
+ mask |= XCB_CONFIG_WINDOW_Y;
+ wc[i++] = ev->y;
+ }
+ if (ev->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
+ mask |= XCB_CONFIG_WINDOW_WIDTH;
+ wc[i++] = ev->width;
+ }
+ if (ev->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
+ mask |= XCB_CONFIG_WINDOW_HEIGHT;
+ wc[i++] = ev->height;
+ }
+ if (ev->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
+ mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
+ wc[i++] = ev->border_width;
+ }
+ if (ev->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
+ mask |= XCB_CONFIG_WINDOW_SIBLING;
+ wc[i++] = ev->above;
+ }
+ if (ev->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
+ mask |= XCB_CONFIG_WINDOW_STACK_MODE;
+ wc[i++] = ev->detail;
+ }
DNPRINTF(SWM_D_EVENT, "configurerequest: new window: 0x%lx, "
"new: %s, (x,y) w x h: (%d,%d) %d x %d\n", ev->window,
- YESNO(new), wc.x, wc.y, wc.width, wc.height);
+ YESNO(new), wc[0], wc[1], wc[2], wc[3]);
- XConfigureWindow(display, ev->window, ev->value_mask, &wc);
+ xcb_configure_window(conn, ev->window, mask, wc);
} else if ((!win->manual || win->quirks & SWM_Q_ANYWHERE) &&
- !(win->sh_mask & EWMH_F_FULLSCREEN)) {
+ !(win->ewmh_flags & EWMH_F_FULLSCREEN)) {
win->g_float.x = ev->x - X(win->ws->r);
win->g_float.y = ev->y - Y(win->ws->r);
win->g_float.w = ev->width;
win = find_window(e->xconfigure.window);
if (win) {
- XGetWMNormalHints(display, win->id, &win->sh, &win->sh_mask);
+ xcb_icccm_get_wm_normal_hints_reply(conn,
+ xcb_icccm_get_wm_normal_hints(conn, win->id),
+ &win->sh, NULL);
adjust_font(win);
if (font_adjusted)
stack();
struct ws_win *win;
XPropertyEvent *ev = &e->xproperty;
#ifdef SWM_DEBUG
- xcb_get_atom_name_reply_t *r;
+ char *name;
+ size_t len;
+ xcb_get_atom_name_reply_t *r;
r = xcb_get_atom_name_reply(conn,
xcb_get_atom_name(conn, ev->atom),
NULL);
if (r) {
- DNPRINTF(SWM_D_EVENT,
- "propertynotify: window: 0x%x, atom: %s\n",
- ev->window, );
+ len = xcb_get_atom_name_name_length(r);
+ if (len > 0) {
+ name = malloc(len + 1);
+ if (name) {
+ memcpy(name, xcb_get_atom_name_name(r), len);
+ name[len] = '\0';
+
+ DNPRINTF(SWM_D_EVENT,
+ "propertynotify: window: 0x%lx, "
+ "atom: %s\n",
+ ev->window, name);
+ free(name);
+ }
+ }
free(r);
}
#endif
switch (ev->atom) {
#if 0
- case XA_WM_NORMAL_HINTS:
- long mask;
- XGetWMNormalHints(display, win->id, &win->sh, &mask);
+ 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 & PMinSize) {
+ 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 XA_WM_CLASS:
- case XA_WM_NAME:
+ case XCB_ATOM_WM_CLASS:
+ case XCB_ATOM_WM_NAME:
bar_update();
break;
default:
SubstructureNotifyMask, &cne))
;
/* resend unmap because we ated it */
- XUnmapWindow(display, e->xunmap.window);
+ xcb_unmap_window(conn, e->xunmap.window);
}
if (focus_mode == SWM_FOCUS_DEFAULT)
if (pwd == NULL)
errx(1, "invalid user: %d", getuid());
+ syms = xcb_key_symbols_alloc(conn);
+ if (syms == NULL)
+ errx(1, "unable to allocate key symbols");
+
setup_globals();
setup_screens();
setup_keys();
if (screens[i].bar_gc != 0)
xcb_free_gc(conn, screens[i].bar_gc);
XFreeFontSet(display, bar_fs);
+
+ xcb_key_symbols_free(syms);
xcb_disconnect(conn);
- XCloseDisplay(display);
return (0);
}
Got questions, comments, patches, etc.? Contact Jason Woofenden