#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)
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);
}
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);
"transient: 0x%x", win->id, wa->map_state,
state, win->transient);
free(wa);
- } else
+ } else
warnx("window: 0x%x, failed xcb_get_window_attributes",
win->id);
}
c = xcb_get_window_attributes(conn, win->id);
wa = xcb_get_window_attributes_reply(conn, c, NULL);
if (wa) {
- warnx("window: 0x%lx, map_state: %d, state: %u, "
- "transient: 0x%lx", win->id, wa->map_state,
- state, win->transient);
+ 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",
{
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;
if ((title = get_win_name(r->ws->focus->id)) == NULL)
return;
- strlcat(s, (char *)title, sz);
- XFree(title);
+ strlcat(s, title, sz);
+ free(title);
}
int urgent[SWM_WS_MAX];
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");
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);
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)
if (win == NULL)
return;
-
+
syms = xcb_key_symbols_alloc(conn);
keycode = xcb_key_symbols_get_keycode(syms, keysym);
-
+
event.event = win->id;
event.root = win->s->root;
event.child = XCB_WINDOW_NONE;
event.root_x = 1;
event.root_y = 1;
event.same_screen = True;
- event.detail = *keycode;
+ event.detail = *keycode;
event.state = modifiers;
event.response_type = XCB_KEY_PRESS;
- xcb_send_event(conn, win->id, True,
+ xcb_send_event(conn, True, win->id,
XCB_EVENT_MASK_KEY_PRESS, (char *)&event);
event.response_type = XCB_KEY_RELEASE;
- xcb_send_event(conn, win->id, True,
+ xcb_send_event(conn, True, win->id,
XCB_EVENT_MASK_KEY_RELEASE, (char *)&event);
xcb_flush(conn);
-
+
xcb_key_symbols_free(syms);
}
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);
+ if (!name) {
+ xcb_get_text_property_reply_wipe(&r);
+ return (NULL);
+ }
+ memcpy(name, r.name, r.name_len);
+ 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;
- do_sync();
+ do_sync();
update_window(win);
}
break;
}
} while (ev.type != ButtonRelease);
if (time) {
- do_sync();
+ 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;
- do_sync();
+ do_sync();
update_window(win);
}
break;
}
} while (ev.type != ButtonRelease);
if (time) {
- do_sync();
+ 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);
- do_sync();
+ do_sync();
if (other_wm)
return (1);
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);
- if (srr == 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;
+ screen->width_in_pixels,
+ screen->height_in_pixels);
+ return;
+ } else
+ 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)
+ if (cir == NULL)
continue;
+ if (cir->num_outputs == 0) {
+ free(cir);
+ continue;
+ }
- if (cir == NULL || cir->mode == 0)
+ if (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);
+ free(cir);
}
- if (srr)
- free(srr);
- if (cir)
- free(cir);
+ free(srr);
} 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]);
}
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);
Got questions, comments, patches, etc.? Contact Jason Woofenden