struct ws_win {
TAILQ_ENTRY(ws_win) entry;
- Window id;
- Window transient;
+ xcb_window_t id;
+ xcb_window_t transient;
struct ws_win *child_trans; /* transient child window */
struct swm_geometry g; /* current geometry */
struct swm_geometry g_float; /* region coordinates */
void plain_stacker(struct workspace *);
void fancy_stacker(struct workspace *);
-struct ws_win *find_window(Window);
+struct ws_win *find_window(xcb_window_t);
void grabbuttons(struct ws_win *, int);
void new_region(struct swm_screen *, int, int, int, int);
void unmanage_window(struct ws_win *);
-long getstate(Window);
+long getstate(xcb_window_t);
int conf_load(char *, int);
int idx; /* screen index */
struct swm_region_list rl; /* list of regions on this screen */
struct swm_region_list orl; /* list of old regions */
- Window root;
+ xcb_window_t root;
struct workspace ws[SWM_WS_MAX];
/* colors */
};
struct ewmh_hint {
- char *name;
- Atom atom;
+ char *name;
+ xcb_atom_t atom;
} ewmh[SWM_EWMH_HINT_MAX] = {
/* must be in same order as in the enum */
- {"_NET_ACTIVE_WINDOW", None},
- {"_NET_CLOSE_WINDOW", None},
- {"_NET_MOVERESIZE_WINDOW", None},
- {"_NET_WM_ACTION_CLOSE", None},
- {"_NET_WM_ACTION_FULLSCREEN", None},
- {"_NET_WM_ACTION_MOVE", None},
- {"_NET_WM_ACTION_RESIZE", None},
- {"_NET_WM_ALLOWED_ACTIONS", None},
- {"_NET_WM_STATE", None},
- {"_NET_WM_STATE_ABOVE", None},
- {"_NET_WM_STATE_FULLSCREEN", None},
- {"_NET_WM_STATE_HIDDEN", None},
- {"_NET_WM_STATE_MAXIMIZED_HORZ", None},
- {"_NET_WM_STATE_MAXIMIZED_VERT", None},
- {"_NET_WM_STATE_SKIP_PAGER", None},
- {"_NET_WM_STATE_SKIP_TASKBAR", None},
- {"_NET_WM_WINDOW_TYPE", None},
- {"_NET_WM_WINDOW_TYPE_DIALOG", None},
- {"_NET_WM_WINDOW_TYPE_DOCK", None},
- {"_NET_WM_WINDOW_TYPE_NORMAL", None},
- {"_NET_WM_WINDOW_TYPE_SPLASH", None},
- {"_NET_WM_WINDOW_TYPE_TOOLBAR", None},
- {"_NET_WM_WINDOW_TYPE_UTILITY", None},
- {"_SWM_WM_STATE_MANUAL", None},
+ {"_NET_ACTIVE_WINDOW", XCB_ATOM_NONE},
+ {"_NET_CLOSE_WINDOW", XCB_ATOM_NONE},
+ {"_NET_MOVERESIZE_WINDOW", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_CLOSE", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_FULLSCREEN", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_MOVE", XCB_ATOM_NONE},
+ {"_NET_WM_ACTION_RESIZE", XCB_ATOM_NONE},
+ {"_NET_WM_ALLOWED_ACTIONS", XCB_ATOM_NONE},
+ {"_NET_WM_STATE", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_ABOVE", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_FULLSCREEN", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_HIDDEN", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_MAXIMIZED_HORZ", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_MAXIMIZED_VERT", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_SKIP_PAGER", XCB_ATOM_NONE},
+ {"_NET_WM_STATE_SKIP_TASKBAR", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_DIALOG", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_DOCK", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_NORMAL", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_SPLASH", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_TOOLBAR", XCB_ATOM_NONE},
+ {"_NET_WM_WINDOW_TYPE_UTILITY", XCB_ATOM_NONE},
+ {"_SWM_WM_STATE_MANUAL", XCB_ATOM_NONE},
};
void store_float_geom(struct ws_win *, struct swm_region *);
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(Window);
+unsigned char *get_win_name(xcb_window_t);
int
get_property(Window id, Atom atom, long count, Atom type, unsigned long *nitems,
void
teardown_ewmh(void)
{
- int i, success;
+ int i, success, num_screens;
unsigned char *data = NULL;
unsigned long n;
Atom sup_check, sup_list;
sup_check = XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
sup_list = XInternAtom(display, "_NET_SUPPORTED", False);
- for (i = 0; i < ScreenCount(display); i++) {
+ 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 */
success = get_property(screens[i].root, sup_check, 1, XA_WINDOW,
&n, NULL, &data);
void
ewmh_update_actions(struct ws_win *win)
{
- Atom actions[SWM_EWMH_ACTION_COUNT_MAX];
+ xcb_atom_t actions[SWM_EWMH_ACTION_COUNT_MAX];
int n = 0;
if (win == NULL)
actions[n++] = ewmh[_NET_WM_ACTION_RESIZE].atom;
}
- XChangeProperty(display, win->id, ewmh[_NET_WM_ALLOWED_ACTIONS].atom,
- XA_ATOM, 32, PropModeReplace, (unsigned char *)actions, n);
+ xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id,
+ ewmh[_NET_WM_ALLOWED_ACTIONS].atom, XCB_ATOM_ATOM, 32, 1,
+ actions);
}
#define _NET_WM_STATE_REMOVE 0 /* remove/unset property */
win->ewmh_flags & EWMH_F_FULLSCREEN))
win->ewmh_flags = orig_flags; /* revert */
- XDeleteProperty(display, win->id, ewmh[_NET_WM_STATE].atom);
+ xcb_delete_property(conn, win->id, ewmh[_NET_WM_STATE].atom);
if (win->ewmh_flags & EWMH_F_FULLSCREEN)
- XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
- XA_ATOM, 32, PropModeAppend,
- (unsigned char *)&ewmh[_NET_WM_STATE_FULLSCREEN].atom, 1);
+ xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id,
+ ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1,
+ &ewmh[_NET_WM_STATE_FULLSCREEN].atom);
if (win->ewmh_flags & EWMH_F_SKIP_PAGER)
- XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
- XA_ATOM, 32, PropModeAppend,
- (unsigned char *)&ewmh[_NET_WM_STATE_SKIP_PAGER].atom, 1);
+ 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);
if (win->ewmh_flags & EWMH_F_SKIP_TASKBAR)
- XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
- XA_ATOM, 32, PropModeAppend,
- (unsigned char *)&ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom, 1);
+ 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_TASKBAR].atom);
if (win->ewmh_flags & EWMH_F_ABOVE)
- XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
- XA_ATOM, 32, PropModeAppend,
- (unsigned char *)&ewmh[_NET_WM_STATE_ABOVE].atom, 1);
+ xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id,
+ ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1,
+ &ewmh[_NET_WM_STATE_ABOVE].atom);
if (win->ewmh_flags & SWM_F_MANUAL)
- XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
- XA_ATOM, 32, PropModeAppend,
- (unsigned char *)&ewmh[_SWM_WM_STATE_MANUAL].atom, 1);
+ xcb_change_property(conn, XCB_PROP_MODE_APPEND, win->id,
+ ewmh[_NET_WM_STATE].atom, XCB_ATOM_ATOM, 32, 1,
+ &ewmh[_SWM_WM_STATE_MANUAL].atom);
}
void
return (NULL);
}
-unsigned long
-name_to_color(char *colorname)
+uint32_t
+name_to_color(const char *colorname)
{
- Colormap cmap;
- Status status;
- XColor screen_def, exact_def;
- unsigned long result = 0;
- char cname[32] = "#";
+ uint32_t result = 0;
+ char cname[32] = "#";
+ xcb_screen_t *screen;
+ xcb_colormap_t cmap;
+ xcb_alloc_named_color_cookie_t c;
+ xcb_alloc_named_color_reply_t *r;
- cmap = DefaultColormap(display, screens[0].idx);
- status = XAllocNamedColor(display, cmap, colorname,
- &screen_def, &exact_def);
- if (!status) {
+ /* XXX - does not support rgb:/RR/GG/BB
+ * will need to use xcb_alloc_color
+ */
+ screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
+ cmap = screen->default_colormap;
+
+ c = xcb_alloc_named_color(conn, cmap, strlen(colorname), colorname);
+ r = xcb_alloc_named_color_reply(conn, c, NULL);
+ if (!r) {
strlcat(cname, colorname + 2, sizeof cname - 1);
- status = XAllocNamedColor(display, cmap, cname, &screen_def,
- &exact_def);
+ c = xcb_alloc_named_color(conn, cmap, strlen(cname),
+ cname);
+ r = xcb_alloc_named_color_reply(conn, c, NULL);
}
- if (status)
- result = screen_def.pixel;
- else
+ if (r) {
+ result = r->pixel;
+ free(r);
+ } else
warnx("color '%s' not found", colorname);
return (result);
{
XWMHints *wmh = NULL;
struct ws_win *win;
- int i, j;
+ int i, j, num_screens;
char b[8];
for (i = 0; i < workspace_limit; i++)
urgent[i] = 0;
- for (i = 0; i < ScreenCount(display); i++)
+ 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) {
wmh = XGetWMHints(display, win->id);
{
char fmtexp[SWM_BAR_MAX], fmtnew[SWM_BAR_MAX];
char fmtrep[SWM_BAR_MAX];
- int i;
+ int i, num_screens;
struct swm_region *r;
/* expand the format by first passing it through strftime(3) */
bar_fmt_expand(fmtexp, sizeof fmtexp);
- for (i = 0; i < ScreenCount(display); i++) {
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++) {
TAILQ_FOREACH(r, &screens[i].rl, entry) {
if (r->bar == NULL)
continue;
bar_toggle(struct swm_region *r, union arg *args)
{
struct swm_region *tmpr;
- int i, sc = ScreenCount(display);
+ int i, num_screens;
DNPRINTF(SWM_D_BAR, "bar_toggle\n");
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
if (bar_enabled) {
- for (i = 0; i < sc; i++)
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
if (tmpr->bar)
XUnmapWindow(display, tmpr->bar->id);
} else {
- for (i = 0; i < sc; i++)
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
if (tmpr->bar)
XMapRaised(display, tmpr->bar->id);
{
XSetWindowAttributes wa;
struct swm_region *r;
- int i;
+ int i, num_screens;
/* do this here because the conf file is in memory */
if (bar_extra && bar_extra_running == 0 && bar_argv[0]) {
}
bzero(&wa, sizeof wa);
- for (i = 0; i < ScreenCount(display); i++)
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry) {
if (r->bar == NULL)
continue;
}
long
-getstate(Window w)
+getstate(xcb_window_t w)
{
long result = -1;
unsigned char *p = NULL;
unmap_all(void)
{
struct ws_win *win;
- int i, j;
+ int i, j, num_screens;
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < num_screens; i++)
for (j = 0; j < workspace_limit; j++)
TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
unmap_window(win);
{
struct swm_region *r = NULL;
Window rr, cr;
- int i, x, y, wx, wy;
+ int i, x, y, wx, wy, num_screens;
unsigned int mask;
DNPRINTF(SWM_D_MISC, "root_to_region: window: 0x%lx\n", root);
- for (i = 0; i < ScreenCount(display); i++)
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
if (screens[i].root == root)
break;
find_unmanaged_window(Window id)
{
struct ws_win *win;
- int i, j;
+ int i, j, num_screens;
- for (i = 0; i < ScreenCount(display); i++)
+ 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].unmanagedlist,
entry)
}
struct ws_win *
-find_window(Window id)
+find_window(xcb_window_t id)
{
struct ws_win *win;
Window wrr, wpr, *wcr = NULL;
- int i, j;
+ int i, j, num_screens;
unsigned int nc;
- for (i = 0; i < ScreenCount(display); i++)
+ 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 (id == win->id)
return (NULL);
/* look for parent */
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < num_screens; i++)
for (j = 0; j < workspace_limit; j++)
TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
if (wpr == win->id)
void
kill_refs(struct ws_win *win)
{
- int i, x;
+ int i, x, num_screens;
struct swm_region *r;
struct workspace *ws;
if (win == NULL)
return;
- for (i = 0; i < ScreenCount(display); i++)
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry)
for (x = 0; x < workspace_limit; x++) {
ws = &r->s->ws[x];
struct ws_win *win;
struct workspace *ws;
struct swm_region *r;
- int i, x;
+ int i, x, num_screens;
if (testwin == NULL)
return (0);
- for (i = 0; i < ScreenCount(display); i++)
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry)
for (x = 0; x < workspace_limit; x++) {
ws = &r->s->ws[x];
{
struct swm_region *r;
struct workspace *ws;
- int i, x;
+ int i, x, num_screens;
/* validate all ws */
- for (i = 0; i < ScreenCount(display); i++)
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry)
for (x = 0; x < workspace_limit; x++) {
ws = &r->s->ws[x];
unfocus_win(struct ws_win *win)
{
XEvent cne;
- Window none = None;
+ xcb_window_t none = XCB_WINDOW_NONE;
DNPRINTF(SWM_D_FOCUS, "unfocus_win: window: 0x%lx\n", WINID(win));
XSetWindowBorder(display, win->id,
win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
- XChangeProperty(display, win->s->root,
- ewmh[_NET_ACTIVE_WINDOW].atom, XA_WINDOW, 32,
- PropModeReplace, (unsigned char *)&none, 1);
+ xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->s->root,
+ ewmh[_NET_ACTIVE_WINDOW].atom, XCB_ATOM_WINDOW, 32, 1,
+ &none);
}
void
unfocus_all(void)
{
struct ws_win *win;
- int i, j;
+ int i, j, num_screens;
DNPRINTF(SWM_D_FOCUS, "unfocus_all\n");
- for (i = 0; i < ScreenCount(display); i++)
+ 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)
unfocus_win(win);
{
struct swm_region *rr = NULL;
union arg a;
- int i, x, y;
+ int i, x, y, num_screens;
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
/* do nothing if we don't have more than one screen */
- if (!(ScreenCount(display) > 1 || outputs > 1))
+ if (!(num_screens > 1 || outputs > 1))
return;
i = r->s->idx;
stack(void) {
struct swm_geometry g;
struct swm_region *r;
- int i;
+ int i, num_screens;
#ifdef SWM_DEBUG
int j;
#endif
DNPRINTF(SWM_D_STACK, "stack: begin\n");
-
- for (i = 0; i < ScreenCount(display); i++) {
+
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++) {
#ifdef SWM_DEBUG
j = 0;
#endif
{
struct swm_geometry gg = *g;
struct ws_win *win, *wintrans = NULL, *parent = NULL;
- int winno;
+ int winno, num_screens;
DNPRINTF(SWM_D_STACK, "max_stack: workspace: %d\n", ws->idx);
if (winno == 0 && count_win(ws, 1) == 0)
return;
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
TAILQ_FOREACH(win, &ws->winlist, entry) {
if (win->transient) {
wintrans = win;
}
/* unmap only if we don't have multi screen */
if (win != ws->focus)
- if (!(ScreenCount(display) > 1 || outputs > 1))
+ if (!(num_screens > 1 || outputs > 1))
unmap_window(win);
}
}
unsigned char *
-get_win_name(Window win)
+get_win_name(xcb_window_t win)
{
unsigned char *prop = NULL;
unsigned long nbytes, nitems;
name = get_win_name(win->id);
if (name == NULL)
continue;
- fprintf(lfile, "%s.%lu\n", name, win->id);
+ fprintf(lfile, "%s.%u\n", name, win->id);
XFree(name);
}
name = get_win_name(win->id);
if (name == NULL)
continue;
- if (asprintf(&s, "%s.%lu", name, win->id) == -1) {
+ if (asprintf(&s, "%s.%u", name, win->id) == -1) {
XFree(name);
continue;
}
void
update_window(struct ws_win *win)
{
- unsigned int mask;
- XWindowChanges wc;
-
- bzero(&wc, sizeof wc);
- mask = CWBorderWidth | CWWidth | CWHeight | CWX | CWY;
+ uint16_t mask;
+ uint32_t wc[5];
- wc.border_width = BORDER(win);
- wc.x = X(win);
- wc.y = Y(win);
- wc.width = WIDTH(win);
- wc.height = HEIGHT(win);
+ mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
+ XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
+ XCB_CONFIG_WINDOW_BORDER_WIDTH;
+ wc[0] = X(win);
+ wc[1] = Y(win);
+ wc[2] = WIDTH(win);
+ wc[3] = HEIGHT(win);
+ wc[4] = BORDER(win);
- DNPRINTF(SWM_D_EVENT, "update_window: window: 0x%lx, (x,y) w x h: "
- "(%d,%d) %d x %d, bordered: %s\n", win->id, wc.x, wc.y, wc.width,
- wc.height, YESNO(win->bordered));
+ DNPRINTF(SWM_D_EVENT, "update_window: window: 0x%x, (x,y) w x h: "
+ "(%d,%d) %d x %d, bordered: %s\n", win->id, wc[0], wc[1], wc[2],
+ wc[3], YESNO(win->bordered));
- XConfigureWindow(display, win->id, mask, &wc);
+ xcb_configure_window(conn, win->id, mask, wc);
}
#define SWM_RESIZE_STEPS (50)
void
grabkeys(void)
{
+ int num_screens;
unsigned int j, k;
KeyCode code;
unsigned int modifiers[] =
DNPRINTF(SWM_D_MISC, "grabkeys\n");
updatenumlockmask();
- for (k = 0; k < ScreenCount(display); k++) {
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (k = 0; k < num_screens; k++) {
if (TAILQ_EMPTY(&screens[k].rl))
continue;
XUngrabKey(display, AnyKey, AnyModifier, screens[k].root);
{ 0, LockMask, numlockmask, numlockmask|LockMask };
updatenumlockmask();
- XUngrabButton(display, AnyButton, AnyModifier, win->id);
+ xcb_ungrab_button(conn, XCB_BUTTON_INDEX_ANY, win->id,
+ XCB_BUTTON_MASK_ANY);
if (focused) {
for (i = 0; i < LENGTH(buttons); i++)
if (buttons[i].action == client_click)
for (j = 0; j < LENGTH(modifiers); j++)
- XGrabButton(display, buttons[i].button,
- buttons[i].mask | modifiers[j],
- win->id, False, BUTTONMASK,
- GrabModeAsync, GrabModeSync, None,
- None);
+ xcb_grab_button(conn, False, win->id,
+ BUTTONMASK,
+ XCB_GRAB_MODE_ASYNC,
+ XCB_GRAB_MODE_SYNC,
+ XCB_WINDOW_NONE,
+ XCB_CURSOR_NONE,
+ buttons[i].button,
+ buttons[i].mask);
} else
- XGrabButton(display, AnyButton, AnyModifier, win->id, False,
- BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
+ 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);
}
const char *quirkname[] = {
setlayout(char *selector, char *value, int flags)
{
int ws_id, i, x, mg, ma, si, raise, f = 0;
- int st = SWM_V_STACK;
+ int st = SWM_V_STACK, num_screens;
char s[1024];
struct workspace *ws;
"<master_grow>:<master_add>:<stack_inc>:<always_raise>:"
"<type>'");
- for (i = 0; i < ScreenCount(display); i++) {
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++) {
ws = (struct workspace *)&screens[i].ws;
ws[ws_id].cur_layout = &layouts[st];
" for 0x%lx trans 0x%lx\n", win->id, win->transient);
if (win->hints == NULL) {
- warnx("no hints for 0x%lx", win->id);
+ warnx("no hints for 0x%x", win->id);
return;
}
XFree(wmh);
if ((wmh = XGetWMHints(display, w->id)) == NULL) {
- warnx("can't get hints for 0x%lx", w->id);
+ warnx("can't get hints for 0x%x", w->id);
continue;
}
win->transient = w->id;
*trans = w->id;
DNPRINTF(SWM_D_MISC, "set_child_transient: asjusting "
- "transient to 0x%lx\n", win->transient);
+ "transient to 0x%x\n", win->transient);
break;
}
}
void
visibilitynotify(XEvent *e)
{
- int i;
+ int i, num_screens;
struct swm_region *r;
DNPRINTF(SWM_D_EVENT, "visibilitynotify: window: 0x%lx\n",
e->xvisibility.window);
- if (e->xvisibility.state == VisibilityUnobscured)
- for (i = 0; i < ScreenCount(display); i++)
+
+ if (e->xvisibility.state == VisibilityUnobscured) {
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry)
if (e->xvisibility.window == WINID(r->bar))
bar_update();
+ }
}
void
int ncrtc = 0;
#endif /* SWM_XRR_HAS_CRTC */
struct swm_region *r;
+ int num_screens;
-
- if (i >= ScreenCount(display))
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ if (i >= num_screens)
errx(1, "scan_xrandr: invalid screen");
/* remove any old regions */
screenchange(XEvent *e) {
XRRScreenChangeNotifyEvent *xe = (XRRScreenChangeNotifyEvent *)e;
struct swm_region *r;
- int i;
+ int i, num_screens;
DNPRINTF(SWM_D_EVENT, "screenchange: root: 0x%lx\n", xe->root);
if (!XRRUpdateConfiguration(e))
return;
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
/* silly event doesn't include the screen index */
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < num_screens; i++)
if (screens[i].root == xe->root)
break;
- if (i >= ScreenCount(display))
+ if (i >= num_screens)
errx(1, "screenchange: screen not found");
/* brute force for now, just re-enumerate the regions */
scan_xrandr(i);
/* add bars to all regions */
- for (i = 0; i < ScreenCount(display); i++)
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry)
bar_setup(r);
stack();
Window d1, d2, *wins = NULL;
XWindowAttributes wa;
unsigned int no;
- int i, j;
+ int i, j, num_screens;
long state, manage;
- for (i = 0; i < ScreenCount(display); i++) {
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++) {
if (!XQueryTree(display, screens[i].root, &d1, &d2, &wins, &no))
continue;
void
workaround(void)
{
- int i;
+ int i, num_screens;
Atom netwmcheck, netwmname, utf8_string;
Window root, win;
netwmcheck = XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
netwmname = XInternAtom(display, "_NET_WM_NAME", False);
utf8_string = XInternAtom(display, "UTF8_STRING", False);
- for (i = 0; i < ScreenCount(display); i++) {
+
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++) {
root = screens[i].root;
win = XCreateSimpleWindow(display,root, 0, 0, 1, 1, 0,
screens[i].c[SWM_S_COLOR_UNFOCUS].color,
char conf[PATH_MAX], *cfile = NULL;
struct stat sb;
XEvent e;
- int xfd, i;
+ int xfd, i, num_screens;
fd_set rd;
struct sigaction sact;
setenv("SWM_STARTED", "YES", 1);
/* setup all bars */
- for (i = 0; i < ScreenCount(display); i++)
+ num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
+ for (i = 0; i < num_screens; i++)
TAILQ_FOREACH(r, &screens[i].rl, entry) {
if (winfocus == NULL)
winfocus = TAILQ_FIRST(&r->ws->winlist);
continue;
}
/* move pointer to first screen if multi screen */
- if (ScreenCount(display) > 1 || outputs > 1)
+ if (num_screens > 1 || outputs > 1)
XWarpPointer(display, None, rr->s[0].root,
0, 0, 0, 0, X(rr),
Y(rr) + (bar_enabled ? bar_height : 0));
teardown_ewmh();
bar_extra_stop();
- for (i = 0; i < ScreenCount(display); ++i)
+ for (i = 0; i < num_screens; ++i)
if (screens[i].bar_gc != NULL)
XFreeGC(display, screens[i].bar_gc);
Got questions, comments, patches, etc.? Contact Jason Woofenden