tcode-style consistency - dwm - [fork] customized build of dwm, the dynamic win… | |
git clone git://src.adamsgaard.dk/dwm | |
Log | |
Files | |
Refs | |
README | |
LICENSE | |
--- | |
commit 5ed9c481968a45f5032f1011d92ab8d5237aeba1 | |
parent 3c91283ede911916452345d545435b08dce9d556 | |
Author: Hiltjo Posthuma <[email protected]> | |
Date: Sun, 8 Nov 2015 23:11:48 +0100 | |
code-style consistency | |
Diffstat: | |
M dwm.c | 936 +++++++++++++++++------------… | |
1 file changed, 503 insertions(+), 433 deletions(-) | |
--- | |
diff --git a/dwm.c b/dwm.c | |
t@@ -275,7 +275,8 @@ struct NumTags { char limitexceeded[LENGTH(tags) > 31 ? -1… | |
/* function implementations */ | |
void | |
-applyrules(Client *c) { | |
+applyrules(Client *c) | |
+{ | |
const char *class, *instance; | |
unsigned int i; | |
const Rule *r; | |
t@@ -289,126 +290,131 @@ applyrules(Client *c) { | |
class = ch.res_class ? ch.res_class : broken; | |
instance = ch.res_name ? ch.res_name : broken; | |
- for(i = 0; i < LENGTH(rules); i++) { | |
+ for (i = 0; i < LENGTH(rules); i++) { | |
r = &rules[i]; | |
- if((!r->title || strstr(c->name, r->title)) | |
+ if ((!r->title || strstr(c->name, r->title)) | |
&& (!r->class || strstr(class, r->class)) | |
&& (!r->instance || strstr(instance, r->instance))) | |
{ | |
c->isfloating = r->isfloating; | |
c->tags |= r->tags; | |
- for(m = mons; m && m->num != r->monitor; m = m->next); | |
- if(m) | |
+ for (m = mons; m && m->num != r->monitor; m = m->next); | |
+ if (m) | |
c->mon = m; | |
} | |
} | |
- if(ch.res_class) | |
+ if (ch.res_class) | |
XFree(ch.res_class); | |
- if(ch.res_name) | |
+ if (ch.res_name) | |
XFree(ch.res_name); | |
c->tags = c->tags & TAGMASK ? c->tags & TAGMASK : c->mon->tagset[c->mo… | |
} | |
int | |
-applysizehints(Client *c, int *x, int *y, int *w, int *h, int interact) { | |
+applysizehints(Client *c, int *x, int *y, int *w, int *h, int interact) | |
+{ | |
int baseismin; | |
Monitor *m = c->mon; | |
/* set minimum possible */ | |
*w = MAX(1, *w); | |
*h = MAX(1, *h); | |
- if(interact) { | |
- if(*x > sw) | |
+ if (interact) { | |
+ if (*x > sw) | |
*x = sw - WIDTH(c); | |
- if(*y > sh) | |
+ if (*y > sh) | |
*y = sh - HEIGHT(c); | |
- if(*x + *w + 2 * c->bw < 0) | |
+ if (*x + *w + 2 * c->bw < 0) | |
*x = 0; | |
- if(*y + *h + 2 * c->bw < 0) | |
+ if (*y + *h + 2 * c->bw < 0) | |
*y = 0; | |
- } | |
- else { | |
- if(*x >= m->wx + m->ww) | |
+ } else { | |
+ if (*x >= m->wx + m->ww) | |
*x = m->wx + m->ww - WIDTH(c); | |
- if(*y >= m->wy + m->wh) | |
+ if (*y >= m->wy + m->wh) | |
*y = m->wy + m->wh - HEIGHT(c); | |
- if(*x + *w + 2 * c->bw <= m->wx) | |
+ if (*x + *w + 2 * c->bw <= m->wx) | |
*x = m->wx; | |
- if(*y + *h + 2 * c->bw <= m->wy) | |
+ if (*y + *h + 2 * c->bw <= m->wy) | |
*y = m->wy; | |
} | |
- if(*h < bh) | |
+ if (*h < bh) | |
*h = bh; | |
- if(*w < bh) | |
+ if (*w < bh) | |
*w = bh; | |
- if(resizehints || c->isfloating || !c->mon->lt[c->mon->sellt]->arrange… | |
+ if (resizehints || c->isfloating || !c->mon->lt[c->mon->sellt]->arrang… | |
/* see last two sentences in ICCCM 4.1.2.3 */ | |
baseismin = c->basew == c->minw && c->baseh == c->minh; | |
- if(!baseismin) { /* temporarily remove base dimensions */ | |
+ if (!baseismin) { /* temporarily remove base dimensions */ | |
*w -= c->basew; | |
*h -= c->baseh; | |
} | |
/* adjust for aspect limits */ | |
- if(c->mina > 0 && c->maxa > 0) { | |
- if(c->maxa < (float)*w / *h) | |
+ if (c->mina > 0 && c->maxa > 0) { | |
+ if (c->maxa < (float)*w / *h) | |
*w = *h * c->maxa + 0.5; | |
- else if(c->mina < (float)*h / *w) | |
+ else if (c->mina < (float)*h / *w) | |
*h = *w * c->mina + 0.5; | |
} | |
- if(baseismin) { /* increment calculation requires this */ | |
+ if (baseismin) { /* increment calculation requires this */ | |
*w -= c->basew; | |
*h -= c->baseh; | |
} | |
/* adjust for increment value */ | |
- if(c->incw) | |
+ if (c->incw) | |
*w -= *w % c->incw; | |
- if(c->inch) | |
+ if (c->inch) | |
*h -= *h % c->inch; | |
/* restore base dimensions */ | |
*w = MAX(*w + c->basew, c->minw); | |
*h = MAX(*h + c->baseh, c->minh); | |
- if(c->maxw) | |
+ if (c->maxw) | |
*w = MIN(*w, c->maxw); | |
- if(c->maxh) | |
+ if (c->maxh) | |
*h = MIN(*h, c->maxh); | |
} | |
return *x != c->x || *y != c->y || *w != c->w || *h != c->h; | |
} | |
void | |
-arrange(Monitor *m) { | |
- if(m) | |
+arrange(Monitor *m) | |
+{ | |
+ if (m) | |
showhide(m->stack); | |
- else for(m = mons; m; m = m->next) | |
+ else for (m = mons; m; m = m->next) | |
showhide(m->stack); | |
- if(m) { | |
+ if (m) { | |
arrangemon(m); | |
restack(m); | |
- } else for(m = mons; m; m = m->next) | |
+ } else for (m = mons; m; m = m->next) | |
arrangemon(m); | |
} | |
void | |
-arrangemon(Monitor *m) { | |
+arrangemon(Monitor *m) | |
+{ | |
strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol); | |
- if(m->lt[m->sellt]->arrange) | |
+ if (m->lt[m->sellt]->arrange) | |
m->lt[m->sellt]->arrange(m); | |
} | |
void | |
-attach(Client *c) { | |
+attach(Client *c) | |
+{ | |
c->next = c->mon->clients; | |
c->mon->clients = c; | |
} | |
void | |
-attachstack(Client *c) { | |
+attachstack(Client *c) | |
+{ | |
c->snext = c->mon->stack; | |
c->mon->stack = c; | |
} | |
void | |
-buttonpress(XEvent *e) { | |
+buttonpress(XEvent *e) | |
+{ | |
unsigned int i, x, click; | |
Arg arg = {0}; | |
Client *c; | |
t@@ -417,39 +423,38 @@ buttonpress(XEvent *e) { | |
click = ClkRootWin; | |
/* focus monitor if necessary */ | |
- if((m = wintomon(ev->window)) && m != selmon) { | |
+ if ((m = wintomon(ev->window)) && m != selmon) { | |
unfocus(selmon->sel, 1); | |
selmon = m; | |
focus(NULL); | |
} | |
- if(ev->window == selmon->barwin) { | |
+ if (ev->window == selmon->barwin) { | |
i = x = 0; | |
do | |
x += TEXTW(tags[i]); | |
- while(ev->x >= x && ++i < LENGTH(tags)); | |
- if(i < LENGTH(tags)) { | |
+ while (ev->x >= x && ++i < LENGTH(tags)); | |
+ if (i < LENGTH(tags)) { | |
click = ClkTagBar; | |
arg.ui = 1 << i; | |
- } | |
- else if(ev->x < x + blw) | |
+ } else if (ev->x < x + blw) | |
click = ClkLtSymbol; | |
- else if(ev->x > selmon->ww - TEXTW(stext)) | |
+ else if (ev->x > selmon->ww - TEXTW(stext)) | |
click = ClkStatusText; | |
else | |
click = ClkWinTitle; | |
- } | |
- else if((c = wintoclient(ev->window))) { | |
+ } else if ((c = wintoclient(ev->window))) { | |
focus(c); | |
click = ClkClientWin; | |
} | |
- for(i = 0; i < LENGTH(buttons); i++) | |
- if(click == buttons[i].click && buttons[i].func && buttons[i].… | |
+ for (i = 0; i < LENGTH(buttons); i++) | |
+ if (click == buttons[i].click && buttons[i].func && buttons[i]… | |
&& CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state)) | |
buttons[i].func(click == ClkTagBar && buttons[i].arg.i… | |
} | |
void | |
-checkotherwm(void) { | |
+checkotherwm(void) | |
+{ | |
xerrorxlib = XSetErrorHandler(xerrorstart); | |
/* this causes an error if some other window manager is running */ | |
XSelectInput(dpy, DefaultRootWindow(dpy), SubstructureRedirectMask); | |
t@@ -459,7 +464,8 @@ checkotherwm(void) { | |
} | |
void | |
-cleanup(void) { | |
+cleanup(void) | |
+{ | |
Arg a = {.ui = ~0}; | |
Layout foo = { "", NULL }; | |
Monitor *m; | |
t@@ -467,15 +473,15 @@ cleanup(void) { | |
view(&a); | |
selmon->lt[selmon->sellt] = &foo; | |
- for(m = mons; m; m = m->next) | |
- while(m->stack) | |
+ for (m = mons; m; m = m->next) | |
+ while (m->stack) | |
unmanage(m->stack, 0); | |
XUngrabKey(dpy, AnyKey, AnyModifier, root); | |
- while(mons) | |
+ while (mons) | |
cleanupmon(mons); | |
- for(i = 0; i < CurLast; i++) | |
+ for (i = 0; i < CurLast; i++) | |
drw_cur_free(drw, cursor[i]); | |
- for(i = 0; i < SchemeLast; i++) { | |
+ for (i = 0; i < SchemeLast; i++) { | |
drw_clr_free(scheme[i].border); | |
drw_clr_free(scheme[i].bg); | |
drw_clr_free(scheme[i].fg); | |
t@@ -487,13 +493,14 @@ cleanup(void) { | |
} | |
void | |
-cleanupmon(Monitor *mon) { | |
+cleanupmon(Monitor *mon) | |
+{ | |
Monitor *m; | |
- if(mon == mons) | |
+ if (mon == mons) | |
mons = mons->next; | |
else { | |
- for(m = mons; m && m->next != mon; m = m->next); | |
+ for (m = mons; m && m->next != mon; m = m->next); | |
m->next = mon->next; | |
} | |
XUnmapWindow(dpy, mon->barwin); | |
t@@ -502,11 +509,12 @@ cleanupmon(Monitor *mon) { | |
} | |
void | |
-clearurgent(Client *c) { | |
+clearurgent(Client *c) | |
+{ | |
XWMHints *wmh; | |
c->isurgent = 0; | |
- if(!(wmh = XGetWMHints(dpy, c->win))) | |
+ if (!(wmh = XGetWMHints(dpy, c->win))) | |
return; | |
wmh->flags &= ~XUrgencyHint; | |
XSetWMHints(dpy, c->win, wmh); | |
t@@ -514,19 +522,19 @@ clearurgent(Client *c) { | |
} | |
void | |
-clientmessage(XEvent *e) { | |
+clientmessage(XEvent *e) | |
+{ | |
XClientMessageEvent *cme = &e->xclient; | |
Client *c = wintoclient(cme->window); | |
- if(!c) | |
+ if (!c) | |
return; | |
- if(cme->message_type == netatom[NetWMState]) { | |
- if(cme->data.l[1] == netatom[NetWMFullscreen] || cme->data.l[2… | |
+ if (cme->message_type == netatom[NetWMState]) { | |
+ if (cme->data.l[1] == netatom[NetWMFullscreen] || cme->data.l[… | |
setfullscreen(c, (cme->data.l[0] == 1 /* _NET_WM_STATE… | |
|| (cme->data.l[0] == 2 /* _NET_WM_STATE… | |
- } | |
- else if(cme->message_type == netatom[NetActiveWindow]) { | |
- if(!ISVISIBLE(c)) { | |
+ } else if (cme->message_type == netatom[NetActiveWindow]) { | |
+ if (!ISVISIBLE(c)) { | |
c->mon->seltags ^= 1; | |
c->mon->tagset[c->mon->seltags] = c->tags; | |
} | |
t@@ -535,7 +543,8 @@ clientmessage(XEvent *e) { | |
} | |
void | |
-configure(Client *c) { | |
+configure(Client *c) | |
+{ | |
XConfigureEvent ce; | |
ce.type = ConfigureNotify; | |
t@@ -553,20 +562,21 @@ configure(Client *c) { | |
} | |
void | |
-configurenotify(XEvent *e) { | |
+configurenotify(XEvent *e) | |
+{ | |
Monitor *m; | |
XConfigureEvent *ev = &e->xconfigure; | |
int dirty; | |
/* TODO: updategeom handling sucks, needs to be simplified */ | |
- if(ev->window == root) { | |
+ if (ev->window == root) { | |
dirty = (sw != ev->width || sh != ev->height); | |
sw = ev->width; | |
sh = ev->height; | |
- if(updategeom() || dirty) { | |
+ if (updategeom() || dirty) { | |
drw_resize(drw, sw, bh); | |
updatebars(); | |
- for(m = mons; m; m = m->next) | |
+ for (m = mons; m; m = m->next) | |
XMoveResizeWindow(dpy, m->barwin, m->wx, m->by… | |
focus(NULL); | |
arrange(NULL); | |
t@@ -575,46 +585,45 @@ configurenotify(XEvent *e) { | |
} | |
void | |
-configurerequest(XEvent *e) { | |
+configurerequest(XEvent *e) | |
+{ | |
Client *c; | |
Monitor *m; | |
XConfigureRequestEvent *ev = &e->xconfigurerequest; | |
XWindowChanges wc; | |
- if((c = wintoclient(ev->window))) { | |
- if(ev->value_mask & CWBorderWidth) | |
+ if ((c = wintoclient(ev->window))) { | |
+ if (ev->value_mask & CWBorderWidth) | |
c->bw = ev->border_width; | |
- else if(c->isfloating || !selmon->lt[selmon->sellt]->arrange) { | |
+ else if (c->isfloating || !selmon->lt[selmon->sellt]->arrange)… | |
m = c->mon; | |
- if(ev->value_mask & CWX) { | |
+ if (ev->value_mask & CWX) { | |
c->oldx = c->x; | |
c->x = m->mx + ev->x; | |
} | |
- if(ev->value_mask & CWY) { | |
+ if (ev->value_mask & CWY) { | |
c->oldy = c->y; | |
c->y = m->my + ev->y; | |
} | |
- if(ev->value_mask & CWWidth) { | |
+ if (ev->value_mask & CWWidth) { | |
c->oldw = c->w; | |
c->w = ev->width; | |
} | |
- if(ev->value_mask & CWHeight) { | |
+ if (ev->value_mask & CWHeight) { | |
c->oldh = c->h; | |
c->h = ev->height; | |
} | |
- if((c->x + c->w) > m->mx + m->mw && c->isfloating) | |
+ if ((c->x + c->w) > m->mx + m->mw && c->isfloating) | |
c->x = m->mx + (m->mw / 2 - WIDTH(c) / 2); /* … | |
- if((c->y + c->h) > m->my + m->mh && c->isfloating) | |
+ if ((c->y + c->h) > m->my + m->mh && c->isfloating) | |
c->y = m->my + (m->mh / 2 - HEIGHT(c) / 2); /*… | |
- if((ev->value_mask & (CWX|CWY)) && !(ev->value_mask & … | |
+ if ((ev->value_mask & (CWX|CWY)) && !(ev->value_mask &… | |
configure(c); | |
- if(ISVISIBLE(c)) | |
+ if (ISVISIBLE(c)) | |
XMoveResizeWindow(dpy, c->win, c->x, c->y, c->… | |
- } | |
- else | |
+ } else | |
configure(c); | |
- } | |
- else { | |
+ } else { | |
wc.x = ev->x; | |
wc.y = ev->y; | |
wc.width = ev->width; | |
t@@ -628,7 +637,8 @@ configurerequest(XEvent *e) { | |
} | |
Monitor * | |
-createmon(void) { | |
+createmon(void) | |
+{ | |
Monitor *m; | |
m = ecalloc(1, sizeof(Monitor)); | |
t@@ -644,65 +654,69 @@ createmon(void) { | |
} | |
void | |
-destroynotify(XEvent *e) { | |
+destroynotify(XEvent *e) | |
+{ | |
Client *c; | |
XDestroyWindowEvent *ev = &e->xdestroywindow; | |
- if((c = wintoclient(ev->window))) | |
+ if ((c = wintoclient(ev->window))) | |
unmanage(c, 1); | |
} | |
void | |
-detach(Client *c) { | |
+detach(Client *c) | |
+{ | |
Client **tc; | |
- for(tc = &c->mon->clients; *tc && *tc != c; tc = &(*tc)->next); | |
+ for (tc = &c->mon->clients; *tc && *tc != c; tc = &(*tc)->next); | |
*tc = c->next; | |
} | |
void | |
-detachstack(Client *c) { | |
+detachstack(Client *c) | |
+{ | |
Client **tc, *t; | |
- for(tc = &c->mon->stack; *tc && *tc != c; tc = &(*tc)->snext); | |
+ for (tc = &c->mon->stack; *tc && *tc != c; tc = &(*tc)->snext); | |
*tc = c->snext; | |
- if(c == c->mon->sel) { | |
- for(t = c->mon->stack; t && !ISVISIBLE(t); t = t->snext); | |
+ if (c == c->mon->sel) { | |
+ for (t = c->mon->stack; t && !ISVISIBLE(t); t = t->snext); | |
c->mon->sel = t; | |
} | |
} | |
Monitor * | |
-dirtomon(int dir) { | |
+dirtomon(int dir) | |
+{ | |
Monitor *m = NULL; | |
- if(dir > 0) { | |
- if(!(m = selmon->next)) | |
+ if (dir > 0) { | |
+ if (!(m = selmon->next)) | |
m = mons; | |
- } | |
- else if(selmon == mons) | |
- for(m = mons; m->next; m = m->next); | |
+ } else if (selmon == mons) | |
+ for (m = mons; m->next; m = m->next); | |
else | |
- for(m = mons; m->next != selmon; m = m->next); | |
+ for (m = mons; m->next != selmon; m = m->next); | |
return m; | |
} | |
void | |
-drawbar(Monitor *m) { | |
+drawbar(Monitor *m) | |
+{ | |
int x, xx, w, dx; | |
unsigned int i, occ = 0, urg = 0; | |
Client *c; | |
dx = (drw->fonts[0]->ascent + drw->fonts[0]->descent + 2) / 4; | |
- for(c = m->clients; c; c = c->next) { | |
+ for (c = m->clients; c; c = c->next) { | |
occ |= c->tags; | |
- if(c->isurgent) | |
+ if (c->isurgent) | |
urg |= c->tags; | |
} | |
x = 0; | |
- for(i = 0; i < LENGTH(tags); i++) { | |
+ for (i = 0; i < LENGTH(tags); i++) { | |
w = TEXTW(tags[i]); | |
drw_setscheme(drw, m->tagset[m->seltags] & 1 << i ? &scheme[Sc… | |
drw_text(drw, x, 0, w, bh, tags[i], urg & 1 << i); | |
t@@ -715,25 +729,23 @@ drawbar(Monitor *m) { | |
drw_text(drw, x, 0, w, bh, m->ltsymbol, 0); | |
x += w; | |
xx = x; | |
- if(m == selmon) { /* status is only drawn on selected monitor */ | |
+ if (m == selmon) { /* status is only drawn on selected monitor */ | |
w = TEXTW(stext); | |
x = m->ww - w; | |
- if(x < xx) { | |
+ if (x < xx) { | |
x = xx; | |
w = m->ww - xx; | |
} | |
drw_text(drw, x, 0, w, bh, stext, 0); | |
- } | |
- else | |
+ } else | |
x = m->ww; | |
- if((w = x - xx) > bh) { | |
+ if ((w = x - xx) > bh) { | |
x = xx; | |
- if(m->sel) { | |
+ if (m->sel) { | |
drw_setscheme(drw, m == selmon ? &scheme[SchemeSel] : … | |
drw_text(drw, x, 0, w, bh, m->sel->name, 0); | |
drw_rect(drw, x + 1, 1, dx, dx, m->sel->isfixed, m->se… | |
- } | |
- else { | |
+ } else { | |
drw_setscheme(drw, &scheme[SchemeNorm]); | |
drw_rect(drw, x, 0, w, bh, 1, 0, 1); | |
} | |
t@@ -742,60 +754,62 @@ drawbar(Monitor *m) { | |
} | |
void | |
-drawbars(void) { | |
+drawbars(void) | |
+{ | |
Monitor *m; | |
- for(m = mons; m; m = m->next) | |
+ for (m = mons; m; m = m->next) | |
drawbar(m); | |
} | |
void | |
-enternotify(XEvent *e) { | |
+enternotify(XEvent *e) | |
+{ | |
Client *c; | |
Monitor *m; | |
XCrossingEvent *ev = &e->xcrossing; | |
- if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->w… | |
+ if ((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->… | |
return; | |
c = wintoclient(ev->window); | |
m = c ? c->mon : wintomon(ev->window); | |
- if(m != selmon) { | |
+ if (m != selmon) { | |
unfocus(selmon->sel, 1); | |
selmon = m; | |
- } | |
- else if(!c || c == selmon->sel) | |
+ } else if (!c || c == selmon->sel) | |
return; | |
focus(c); | |
} | |
void | |
-expose(XEvent *e) { | |
+expose(XEvent *e) | |
+{ | |
Monitor *m; | |
XExposeEvent *ev = &e->xexpose; | |
- if(ev->count == 0 && (m = wintomon(ev->window))) | |
+ if (ev->count == 0 && (m = wintomon(ev->window))) | |
drawbar(m); | |
} | |
void | |
-focus(Client *c) { | |
- if(!c || !ISVISIBLE(c)) | |
- for(c = selmon->stack; c && !ISVISIBLE(c); c = c->snext); | |
- /* was if(selmon->sel) */ | |
- if(selmon->sel && selmon->sel != c) | |
+focus(Client *c) | |
+{ | |
+ if (!c || !ISVISIBLE(c)) | |
+ for (c = selmon->stack; c && !ISVISIBLE(c); c = c->snext); | |
+ /* was if (selmon->sel) */ | |
+ if (selmon->sel && selmon->sel != c) | |
unfocus(selmon->sel, 0); | |
- if(c) { | |
- if(c->mon != selmon) | |
+ if (c) { | |
+ if (c->mon != selmon) | |
selmon = c->mon; | |
- if(c->isurgent) | |
+ if (c->isurgent) | |
clearurgent(c); | |
detachstack(c); | |
attachstack(c); | |
grabbuttons(c, 1); | |
XSetWindowBorder(dpy, c->win, scheme[SchemeSel].border->pix); | |
setfocus(c); | |
- } | |
- else { | |
+ } else { | |
XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime); | |
XDeleteProperty(dpy, root, netatom[NetActiveWindow]); | |
} | |
t@@ -803,21 +817,24 @@ focus(Client *c) { | |
drawbars(); | |
} | |
+/* there are some broken focus acquiring clients */ | |
void | |
-focusin(XEvent *e) { /* there are some broken focus acquiring clients */ | |
+focusin(XEvent *e) | |
+{ | |
XFocusChangeEvent *ev = &e->xfocus; | |
- if(selmon->sel && ev->window != selmon->sel->win) | |
+ if (selmon->sel && ev->window != selmon->sel->win) | |
setfocus(selmon->sel); | |
} | |
void | |
-focusmon(const Arg *arg) { | |
+focusmon(const Arg *arg) | |
+{ | |
Monitor *m; | |
- if(!mons->next) | |
+ if (!mons->next) | |
return; | |
- if((m = dirtomon(arg->i)) == selmon) | |
+ if ((m = dirtomon(arg->i)) == selmon) | |
return; | |
unfocus(selmon->sel, 0); /* s/1/0/ fixes input focus issues | |
in gedit and anjuta */ | |
t@@ -826,39 +843,40 @@ focusmon(const Arg *arg) { | |
} | |
void | |
-focusstack(const Arg *arg) { | |
+focusstack(const Arg *arg) | |
+{ | |
Client *c = NULL, *i; | |
- if(!selmon->sel) | |
+ if (!selmon->sel) | |
return; | |
- if(arg->i > 0) { | |
- for(c = selmon->sel->next; c && !ISVISIBLE(c); c = c->next); | |
- if(!c) | |
- for(c = selmon->clients; c && !ISVISIBLE(c); c = c->ne… | |
- } | |
- else { | |
- for(i = selmon->clients; i != selmon->sel; i = i->next) | |
- if(ISVISIBLE(i)) | |
+ if (arg->i > 0) { | |
+ for (c = selmon->sel->next; c && !ISVISIBLE(c); c = c->next); | |
+ if (!c) | |
+ for (c = selmon->clients; c && !ISVISIBLE(c); c = c->n… | |
+ } else { | |
+ for (i = selmon->clients; i != selmon->sel; i = i->next) | |
+ if (ISVISIBLE(i)) | |
c = i; | |
- if(!c) | |
- for(; i; i = i->next) | |
- if(ISVISIBLE(i)) | |
+ if (!c) | |
+ for (; i; i = i->next) | |
+ if (ISVISIBLE(i)) | |
c = i; | |
} | |
- if(c) { | |
+ if (c) { | |
focus(c); | |
restack(selmon); | |
} | |
} | |
Atom | |
-getatomprop(Client *c, Atom prop) { | |
+getatomprop(Client *c, Atom prop) | |
+{ | |
int di; | |
unsigned long dl; | |
unsigned char *p = NULL; | |
Atom da, atom = None; | |
- if(XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_AT… | |
+ if (XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_A… | |
&da, &di, &dl, &dl, &p) == Success && p) { | |
atom = *(Atom *)p; | |
XFree(p); | |
t@@ -867,7 +885,8 @@ getatomprop(Client *c, Atom prop) { | |
} | |
int | |
-getrootptr(int *x, int *y) { | |
+getrootptr(int *x, int *y) | |
+{ | |
int di; | |
unsigned int dui; | |
Window dummy; | |
t@@ -876,38 +895,40 @@ getrootptr(int *x, int *y) { | |
} | |
long | |
-getstate(Window w) { | |
+getstate(Window w) | |
+{ | |
int format; | |
long result = -1; | |
unsigned char *p = NULL; | |
unsigned long n, extra; | |
Atom real; | |
- if(XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[W… | |
+ if (XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[… | |
&real, &format, &n, &extra, (unsigned char **)&p… | |
return -1; | |
- if(n != 0) | |
+ if (n != 0) | |
result = *p; | |
XFree(p); | |
return result; | |
} | |
int | |
-gettextprop(Window w, Atom atom, char *text, unsigned int size) { | |
+gettextprop(Window w, Atom atom, char *text, unsigned int size) | |
+{ | |
char **list = NULL; | |
int n; | |
XTextProperty name; | |
- if(!text || size == 0) | |
+ if (!text || size == 0) | |
return 0; | |
text[0] = '\0'; | |
XGetTextProperty(dpy, w, &name, atom); | |
- if(!name.nitems) | |
+ if (!name.nitems) | |
return 0; | |
- if(name.encoding == XA_STRING) | |
+ if (name.encoding == XA_STRING) | |
strncpy(text, (char *)name.value, size - 1); | |
else { | |
- if(XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Success… | |
+ if (XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Succes… | |
strncpy(text, *list, size - 1); | |
XFreeStringList(list); | |
} | |
t@@ -918,29 +939,30 @@ gettextprop(Window w, Atom atom, char *text, unsigned in… | |
} | |
void | |
-grabbuttons(Client *c, int focused) { | |
+grabbuttons(Client *c, int focused) | |
+{ | |
updatenumlockmask(); | |
{ | |
unsigned int i, j; | |
unsigned int modifiers[] = { 0, LockMask, numlockmask, numlock… | |
XUngrabButton(dpy, AnyButton, AnyModifier, c->win); | |
- if(focused) { | |
- for(i = 0; i < LENGTH(buttons); i++) | |
- if(buttons[i].click == ClkClientWin) | |
- for(j = 0; j < LENGTH(modifiers); j++) | |
+ if (focused) { | |
+ for (i = 0; i < LENGTH(buttons); i++) | |
+ if (buttons[i].click == ClkClientWin) | |
+ for (j = 0; j < LENGTH(modifiers); j++) | |
XGrabButton(dpy, buttons[i].bu… | |
buttons[i].mask | … | |
c->win, False, BUT… | |
GrabModeAsync, Gra… | |
- } | |
- else | |
+ } else | |
XGrabButton(dpy, AnyButton, AnyModifier, c->win, False, | |
BUTTONMASK, GrabModeAsync, GrabModeSync, N… | |
} | |
} | |
void | |
-grabkeys(void) { | |
+grabkeys(void) | |
+{ | |
updatenumlockmask(); | |
{ | |
unsigned int i, j; | |
t@@ -948,25 +970,27 @@ grabkeys(void) { | |
KeyCode code; | |
XUngrabKey(dpy, AnyKey, AnyModifier, root); | |
- for(i = 0; i < LENGTH(keys); i++) | |
- if((code = XKeysymToKeycode(dpy, keys[i].keysym))) | |
- for(j = 0; j < LENGTH(modifiers); j++) | |
+ for (i = 0; i < LENGTH(keys); i++) | |
+ if ((code = XKeysymToKeycode(dpy, keys[i].keysym))) | |
+ for (j = 0; j < LENGTH(modifiers); j++) | |
XGrabKey(dpy, code, keys[i].mod | modi… | |
True, GrabModeAsync, GrabMode… | |
} | |
} | |
void | |
-incnmaster(const Arg *arg) { | |
+incnmaster(const Arg *arg) | |
+{ | |
selmon->nmaster = MAX(selmon->nmaster + arg->i, 0); | |
arrange(selmon); | |
} | |
#ifdef XINERAMA | |
static int | |
-isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info) { | |
- while(n--) | |
- if(unique[n].x_org == info->x_org && unique[n].y_org == info->… | |
+isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info) | |
+{ | |
+ while (n--) | |
+ if (unique[n].x_org == info->x_org && unique[n].y_org == info-… | |
&& unique[n].width == info->width && unique[n].height == info-… | |
return 0; | |
return 1; | |
t@@ -974,25 +998,27 @@ isuniquegeom(XineramaScreenInfo *unique, size_t n, Xiner… | |
#endif /* XINERAMA */ | |
void | |
-keypress(XEvent *e) { | |
+keypress(XEvent *e) | |
+{ | |
unsigned int i; | |
KeySym keysym; | |
XKeyEvent *ev; | |
ev = &e->xkey; | |
keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0); | |
- for(i = 0; i < LENGTH(keys); i++) | |
- if(keysym == keys[i].keysym | |
+ for (i = 0; i < LENGTH(keys); i++) | |
+ if (keysym == keys[i].keysym | |
&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state) | |
&& keys[i].func) | |
keys[i].func(&(keys[i].arg)); | |
} | |
void | |
-killclient(const Arg *arg) { | |
- if(!selmon->sel) | |
+killclient(const Arg *arg) | |
+{ | |
+ if (!selmon->sel) | |
return; | |
- if(!sendevent(selmon->sel, wmatom[WMDelete])) { | |
+ if (!sendevent(selmon->sel, wmatom[WMDelete])) { | |
XGrabServer(dpy); | |
XSetErrorHandler(xerrordummy); | |
XSetCloseDownMode(dpy, DestroyAll); | |
t@@ -1004,7 +1030,8 @@ killclient(const Arg *arg) { | |
} | |
void | |
-manage(Window w, XWindowAttributes *wa) { | |
+manage(Window w, XWindowAttributes *wa) | |
+{ | |
Client *c, *t = NULL; | |
Window trans = None; | |
XWindowChanges wc; | |
t@@ -1012,11 +1039,10 @@ manage(Window w, XWindowAttributes *wa) { | |
c = ecalloc(1, sizeof(Client)); | |
c->win = w; | |
updatetitle(c); | |
- if(XGetTransientForHint(dpy, w, &trans) && (t = wintoclient(trans))) { | |
+ if (XGetTransientForHint(dpy, w, &trans) && (t = wintoclient(trans))) { | |
c->mon = t->mon; | |
c->tags = t->tags; | |
- } | |
- else { | |
+ } else { | |
c->mon = selmon; | |
applyrules(c); | |
} | |
t@@ -1027,9 +1053,9 @@ manage(Window w, XWindowAttributes *wa) { | |
c->h = c->oldh = wa->height; | |
c->oldbw = wa->border_width; | |
- if(c->x + WIDTH(c) > c->mon->mx + c->mon->mw) | |
+ if (c->x + WIDTH(c) > c->mon->mx + c->mon->mw) | |
c->x = c->mon->mx + c->mon->mw - WIDTH(c); | |
- if(c->y + HEIGHT(c) > c->mon->my + c->mon->mh) | |
+ if (c->y + HEIGHT(c) > c->mon->my + c->mon->mh) | |
c->y = c->mon->my + c->mon->mh - HEIGHT(c); | |
c->x = MAX(c->x, c->mon->mx); | |
/* only fix client y-offset, if the client center might cover the bar … | |
t@@ -1046,9 +1072,9 @@ manage(Window w, XWindowAttributes *wa) { | |
updatewmhints(c); | |
XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMas… | |
grabbuttons(c, 0); | |
- if(!c->isfloating) | |
+ if (!c->isfloating) | |
c->isfloating = c->oldstate = trans != None || c->isfixed; | |
- if(c->isfloating) | |
+ if (c->isfloating) | |
XRaiseWindow(dpy, c->win); | |
attach(c); | |
attachstack(c); | |
t@@ -1065,50 +1091,54 @@ manage(Window w, XWindowAttributes *wa) { | |
} | |
void | |
-mappingnotify(XEvent *e) { | |
+mappingnotify(XEvent *e) | |
+{ | |
XMappingEvent *ev = &e->xmapping; | |
XRefreshKeyboardMapping(ev); | |
- if(ev->request == MappingKeyboard) | |
+ if (ev->request == MappingKeyboard) | |
grabkeys(); | |
} | |
void | |
-maprequest(XEvent *e) { | |
+maprequest(XEvent *e) | |
+{ | |
static XWindowAttributes wa; | |
XMapRequestEvent *ev = &e->xmaprequest; | |
- if(!XGetWindowAttributes(dpy, ev->window, &wa)) | |
+ if (!XGetWindowAttributes(dpy, ev->window, &wa)) | |
return; | |
- if(wa.override_redirect) | |
+ if (wa.override_redirect) | |
return; | |
- if(!wintoclient(ev->window)) | |
+ if (!wintoclient(ev->window)) | |
manage(ev->window, &wa); | |
} | |
void | |
-monocle(Monitor *m) { | |
+monocle(Monitor *m) | |
+{ | |
unsigned int n = 0; | |
Client *c; | |
- for(c = m->clients; c; c = c->next) | |
- if(ISVISIBLE(c)) | |
+ for (c = m->clients; c; c = c->next) | |
+ if (ISVISIBLE(c)) | |
n++; | |
- if(n > 0) /* override layout symbol */ | |
+ if (n > 0) /* override layout symbol */ | |
snprintf(m->ltsymbol, sizeof m->ltsymbol, "[%d]", n); | |
- for(c = nexttiled(m->clients); c; c = nexttiled(c->next)) | |
+ for (c = nexttiled(m->clients); c; c = nexttiled(c->next)) | |
resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, … | |
} | |
void | |
-motionnotify(XEvent *e) { | |
+motionnotify(XEvent *e) | |
+{ | |
static Monitor *mon = NULL; | |
Monitor *m; | |
XMotionEvent *ev = &e->xmotion; | |
- if(ev->window != root) | |
+ if (ev->window != root) | |
return; | |
- if((m = recttomon(ev->x_root, ev->y_root, 1, 1)) != mon && mon) { | |
+ if ((m = recttomon(ev->x_root, ev->y_root, 1, 1)) != mon && mon) { | |
unfocus(selmon->sel, 1); | |
selmon = m; | |
focus(NULL); | |
t@@ -1117,24 +1147,25 @@ motionnotify(XEvent *e) { | |
} | |
void | |
-movemouse(const Arg *arg) { | |
+movemouse(const Arg *arg) | |
+{ | |
int x, y, ocx, ocy, nx, ny; | |
Client *c; | |
Monitor *m; | |
XEvent ev; | |
Time lasttime = 0; | |
- if(!(c = selmon->sel)) | |
+ if (!(c = selmon->sel)) | |
return; | |
- if(c->isfullscreen) /* no support moving fullscreen windows by mouse */ | |
+ if (c->isfullscreen) /* no support moving fullscreen windows by mouse … | |
return; | |
restack(selmon); | |
ocx = c->x; | |
ocy = c->y; | |
- if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAs… | |
+ if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeA… | |
None, cursor[CurMove]->cursor, CurrentTime) != GrabSuccess) | |
return; | |
- if(!getrootptr(&x, &y)) | |
+ if (!getrootptr(&x, &y)) | |
return; | |
do { | |
XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMas… | |
t@@ -1151,27 +1182,27 @@ movemouse(const Arg *arg) { | |
nx = ocx + (ev.xmotion.x - x); | |
ny = ocy + (ev.xmotion.y - y); | |
- if(nx >= selmon->wx && nx <= selmon->wx + selmon->ww | |
+ if (nx >= selmon->wx && nx <= selmon->wx + selmon->ww | |
&& ny >= selmon->wy && ny <= selmon->wy + selmon->wh) { | |
- if(abs(selmon->wx - nx) < snap) | |
+ if (abs(selmon->wx - nx) < snap) | |
nx = selmon->wx; | |
- else if(abs((selmon->wx + selmon->ww) - (nx + … | |
+ else if (abs((selmon->wx + selmon->ww) - (nx +… | |
nx = selmon->wx + selmon->ww - WIDTH(c… | |
- if(abs(selmon->wy - ny) < snap) | |
+ if (abs(selmon->wy - ny) < snap) | |
ny = selmon->wy; | |
- else if(abs((selmon->wy + selmon->wh) - (ny + … | |
+ else if (abs((selmon->wy + selmon->wh) - (ny +… | |
ny = selmon->wy + selmon->wh - HEIGHT(… | |
- if(!c->isfloating && selmon->lt[selmon->sellt]… | |
+ if (!c->isfloating && selmon->lt[selmon->sellt… | |
&& (abs(nx - c->x) > snap || abs(ny - c->y) > … | |
togglefloating(NULL); | |
} | |
- if(!selmon->lt[selmon->sellt]->arrange || c->isfloatin… | |
+ if (!selmon->lt[selmon->sellt]->arrange || c->isfloati… | |
resize(c, nx, ny, c->w, c->h, 1); | |
break; | |
} | |
- } while(ev.type != ButtonRelease); | |
+ } while (ev.type != ButtonRelease); | |
XUngrabPointer(dpy, CurrentTime); | |
- if((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) { | |
+ if ((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) { | |
sendmon(c, m); | |
selmon = m; | |
focus(NULL); | |
t@@ -1179,13 +1210,15 @@ movemouse(const Arg *arg) { | |
} | |
Client * | |
-nexttiled(Client *c) { | |
- for(; c && (c->isfloating || !ISVISIBLE(c)); c = c->next); | |
+nexttiled(Client *c) | |
+{ | |
+ for (; c && (c->isfloating || !ISVISIBLE(c)); c = c->next); | |
return c; | |
} | |
void | |
-pop(Client *c) { | |
+pop(Client *c) | |
+{ | |
detach(c); | |
attach(c); | |
focus(c); | |
t@@ -1193,20 +1226,21 @@ pop(Client *c) { | |
} | |
void | |
-propertynotify(XEvent *e) { | |
+propertynotify(XEvent *e) | |
+{ | |
Client *c; | |
Window trans; | |
XPropertyEvent *ev = &e->xproperty; | |
- if((ev->window == root) && (ev->atom == XA_WM_NAME)) | |
+ if ((ev->window == root) && (ev->atom == XA_WM_NAME)) | |
updatestatus(); | |
- else if(ev->state == PropertyDelete) | |
+ else if (ev->state == PropertyDelete) | |
return; /* ignore */ | |
- else if((c = wintoclient(ev->window))) { | |
+ else if ((c = wintoclient(ev->window))) { | |
switch(ev->atom) { | |
default: break; | |
case XA_WM_TRANSIENT_FOR: | |
- if(!c->isfloating && (XGetTransientForHint(dpy, c->win… | |
+ if (!c->isfloating && (XGetTransientForHint(dpy, c->wi… | |
(c->isfloating = (wintoclient(trans)) != NULL)) | |
arrange(c->mon); | |
break; | |
t@@ -1218,28 +1252,30 @@ propertynotify(XEvent *e) { | |
drawbars(); | |
break; | |
} | |
- if(ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) { | |
+ if (ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) { | |
updatetitle(c); | |
- if(c == c->mon->sel) | |
+ if (c == c->mon->sel) | |
drawbar(c->mon); | |
} | |
- if(ev->atom == netatom[NetWMWindowType]) | |
+ if (ev->atom == netatom[NetWMWindowType]) | |
updatewindowtype(c); | |
} | |
} | |
void | |
-quit(const Arg *arg) { | |
+quit(const Arg *arg) | |
+{ | |
running = 0; | |
} | |
Monitor * | |
-recttomon(int x, int y, int w, int h) { | |
+recttomon(int x, int y, int w, int h) | |
+{ | |
Monitor *m, *r = selmon; | |
int a, area = 0; | |
- for(m = mons; m; m = m->next) | |
- if((a = INTERSECT(x, y, w, h, m)) > area) { | |
+ for (m = mons; m; m = m->next) | |
+ if ((a = INTERSECT(x, y, w, h, m)) > area) { | |
area = a; | |
r = m; | |
} | |
t@@ -1247,13 +1283,15 @@ recttomon(int x, int y, int w, int h) { | |
} | |
void | |
-resize(Client *c, int x, int y, int w, int h, int interact) { | |
- if(applysizehints(c, &x, &y, &w, &h, interact)) | |
+resize(Client *c, int x, int y, int w, int h, int interact) | |
+{ | |
+ if (applysizehints(c, &x, &y, &w, &h, interact)) | |
resizeclient(c, x, y, w, h); | |
} | |
void | |
-resizeclient(Client *c, int x, int y, int w, int h) { | |
+resizeclient(Client *c, int x, int y, int w, int h) | |
+{ | |
XWindowChanges wc; | |
c->oldx = c->x; c->x = wc.x = x; | |
t@@ -1267,21 +1305,22 @@ resizeclient(Client *c, int x, int y, int w, int h) { | |
} | |
void | |
-resizemouse(const Arg *arg) { | |
+resizemouse(const Arg *arg) | |
+{ | |
int ocx, ocy, nw, nh; | |
Client *c; | |
Monitor *m; | |
XEvent ev; | |
Time lasttime = 0; | |
- if(!(c = selmon->sel)) | |
+ if (!(c = selmon->sel)) | |
return; | |
- if(c->isfullscreen) /* no support resizing fullscreen windows by mouse… | |
+ if (c->isfullscreen) /* no support resizing fullscreen windows by mous… | |
return; | |
restack(selmon); | |
ocx = c->x; | |
ocy = c->y; | |
- if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAs… | |
+ if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeA… | |
None, cursor[CurResize]->cursor, CurrentTime) != GrabS… | |
return; | |
XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c… | |
t@@ -1300,22 +1339,22 @@ resizemouse(const Arg *arg) { | |
nw = MAX(ev.xmotion.x - ocx - 2 * c->bw + 1, 1); | |
nh = MAX(ev.xmotion.y - ocy - 2 * c->bw + 1, 1); | |
- if(c->mon->wx + nw >= selmon->wx && c->mon->wx + nw <=… | |
+ if (c->mon->wx + nw >= selmon->wx && c->mon->wx + nw <… | |
&& c->mon->wy + nh >= selmon->wy && c->mon->wy + nh <=… | |
{ | |
- if(!c->isfloating && selmon->lt[selmon->sellt]… | |
+ if (!c->isfloating && selmon->lt[selmon->sellt… | |
&& (abs(nw - c->w) > snap || abs(nh - c->h) > … | |
togglefloating(NULL); | |
} | |
- if(!selmon->lt[selmon->sellt]->arrange || c->isfloatin… | |
+ if (!selmon->lt[selmon->sellt]->arrange || c->isfloati… | |
resize(c, c->x, c->y, nw, nh, 1); | |
break; | |
} | |
- } while(ev.type != ButtonRelease); | |
+ } while (ev.type != ButtonRelease); | |
XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c… | |
XUngrabPointer(dpy, CurrentTime); | |
- while(XCheckMaskEvent(dpy, EnterWindowMask, &ev)); | |
- if((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) { | |
+ while (XCheckMaskEvent(dpy, EnterWindowMask, &ev)); | |
+ if ((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) { | |
sendmon(c, m); | |
selmon = m; | |
focus(NULL); | |
t@@ -1323,68 +1362,72 @@ resizemouse(const Arg *arg) { | |
} | |
void | |
-restack(Monitor *m) { | |
+restack(Monitor *m) | |
+{ | |
Client *c; | |
XEvent ev; | |
XWindowChanges wc; | |
drawbar(m); | |
- if(!m->sel) | |
+ if (!m->sel) | |
return; | |
- if(m->sel->isfloating || !m->lt[m->sellt]->arrange) | |
+ if (m->sel->isfloating || !m->lt[m->sellt]->arrange) | |
XRaiseWindow(dpy, m->sel->win); | |
- if(m->lt[m->sellt]->arrange) { | |
+ if (m->lt[m->sellt]->arrange) { | |
wc.stack_mode = Below; | |
wc.sibling = m->barwin; | |
- for(c = m->stack; c; c = c->snext) | |
- if(!c->isfloating && ISVISIBLE(c)) { | |
+ for (c = m->stack; c; c = c->snext) | |
+ if (!c->isfloating && ISVISIBLE(c)) { | |
XConfigureWindow(dpy, c->win, CWSibling|CWStac… | |
wc.sibling = c->win; | |
} | |
} | |
XSync(dpy, False); | |
- while(XCheckMaskEvent(dpy, EnterWindowMask, &ev)); | |
+ while (XCheckMaskEvent(dpy, EnterWindowMask, &ev)); | |
} | |
void | |
-run(void) { | |
+run(void) | |
+{ | |
XEvent ev; | |
/* main event loop */ | |
XSync(dpy, False); | |
- while(running && !XNextEvent(dpy, &ev)) | |
- if(handler[ev.type]) | |
+ while (running && !XNextEvent(dpy, &ev)) | |
+ if (handler[ev.type]) | |
handler[ev.type](&ev); /* call handler */ | |
} | |
void | |
-scan(void) { | |
+scan(void) | |
+{ | |
unsigned int i, num; | |
Window d1, d2, *wins = NULL; | |
XWindowAttributes wa; | |
- if(XQueryTree(dpy, root, &d1, &d2, &wins, &num)) { | |
- for(i = 0; i < num; i++) { | |
- if(!XGetWindowAttributes(dpy, wins[i], &wa) | |
+ if (XQueryTree(dpy, root, &d1, &d2, &wins, &num)) { | |
+ for (i = 0; i < num; i++) { | |
+ if (!XGetWindowAttributes(dpy, wins[i], &wa) | |
|| wa.override_redirect || XGetTransientForHint(dpy, w… | |
continue; | |
- if(wa.map_state == IsViewable || getstate(wins[i]) == … | |
+ if (wa.map_state == IsViewable || getstate(wins[i]) ==… | |
manage(wins[i], &wa); | |
} | |
- for(i = 0; i < num; i++) { /* now the transients */ | |
- if(!XGetWindowAttributes(dpy, wins[i], &wa)) | |
+ for (i = 0; i < num; i++) { /* now the transients */ | |
+ if (!XGetWindowAttributes(dpy, wins[i], &wa)) | |
continue; | |
- if(XGetTransientForHint(dpy, wins[i], &d1) | |
+ if (XGetTransientForHint(dpy, wins[i], &d1) | |
&& (wa.map_state == IsViewable || getstate(wins[i]) ==… | |
manage(wins[i], &wa); | |
} | |
- if(wins) | |
+ if (wins) | |
XFree(wins); | |
} | |
} | |
void | |
-sendmon(Client *c, Monitor *m) { | |
- if(c->mon == m) | |
+sendmon(Client *c, Monitor *m) | |
+{ | |
+ if (c->mon == m) | |
return; | |
unfocus(c, 1); | |
detach(c); | |
t@@ -1398,7 +1441,8 @@ sendmon(Client *c, Monitor *m) { | |
} | |
void | |
-setclientstate(Client *c, long state) { | |
+setclientstate(Client *c, long state) | |
+{ | |
long data[] = { state, None }; | |
XChangeProperty(dpy, c->win, wmatom[WMState], wmatom[WMState], 32, | |
t@@ -1406,18 +1450,19 @@ setclientstate(Client *c, long state) { | |
} | |
int | |
-sendevent(Client *c, Atom proto) { | |
+sendevent(Client *c, Atom proto) | |
+{ | |
int n; | |
Atom *protocols; | |
int exists = 0; | |
XEvent ev; | |
- if(XGetWMProtocols(dpy, c->win, &protocols, &n)) { | |
- while(!exists && n--) | |
+ if (XGetWMProtocols(dpy, c->win, &protocols, &n)) { | |
+ while (!exists && n--) | |
exists = protocols[n] == proto; | |
XFree(protocols); | |
} | |
- if(exists) { | |
+ if (exists) { | |
ev.type = ClientMessage; | |
ev.xclient.window = c->win; | |
ev.xclient.message_type = wmatom[WMProtocols]; | |
t@@ -1430,8 +1475,9 @@ sendevent(Client *c, Atom proto) { | |
} | |
void | |
-setfocus(Client *c) { | |
- if(!c->neverfocus) { | |
+setfocus(Client *c) | |
+{ | |
+ if (!c->neverfocus) { | |
XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime); | |
XChangeProperty(dpy, root, netatom[NetActiveWindow], | |
XA_WINDOW, 32, PropModeReplace, | |
t@@ -1441,8 +1487,9 @@ setfocus(Client *c) { | |
} | |
void | |
-setfullscreen(Client *c, int fullscreen) { | |
- if(fullscreen && !c->isfullscreen) { | |
+setfullscreen(Client *c, int fullscreen) | |
+{ | |
+ if (fullscreen && !c->isfullscreen) { | |
XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32, | |
PropModeReplace, (unsigned char*)&netatom[NetW… | |
c->isfullscreen = 1; | |
t@@ -1452,8 +1499,7 @@ setfullscreen(Client *c, int fullscreen) { | |
c->isfloating = 1; | |
resizeclient(c, c->mon->mx, c->mon->my, c->mon->mw, c->mon->mh… | |
XRaiseWindow(dpy, c->win); | |
- } | |
- else if(!fullscreen && c->isfullscreen){ | |
+ } else if (!fullscreen && c->isfullscreen){ | |
XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32, | |
PropModeReplace, (unsigned char*)0, 0); | |
c->isfullscreen = 0; | |
t@@ -1469,13 +1515,14 @@ setfullscreen(Client *c, int fullscreen) { | |
} | |
void | |
-setlayout(const Arg *arg) { | |
- if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt]) | |
+setlayout(const Arg *arg) | |
+{ | |
+ if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt]) | |
selmon->sellt ^= 1; | |
- if(arg && arg->v) | |
+ if (arg && arg->v) | |
selmon->lt[selmon->sellt] = (Layout *)arg->v; | |
strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof se… | |
- if(selmon->sel) | |
+ if (selmon->sel) | |
arrange(selmon); | |
else | |
drawbar(selmon); | |
t@@ -1483,20 +1530,22 @@ setlayout(const Arg *arg) { | |
/* arg > 1.0 will set mfact absolutly */ | |
void | |
-setmfact(const Arg *arg) { | |
+setmfact(const Arg *arg) | |
+{ | |
float f; | |
- if(!arg || !selmon->lt[selmon->sellt]->arrange) | |
+ if (!arg || !selmon->lt[selmon->sellt]->arrange) | |
return; | |
f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0; | |
- if(f < 0.1 || f > 0.9) | |
+ if (f < 0.1 || f > 0.9) | |
return; | |
selmon->mfact = f; | |
arrange(selmon); | |
} | |
void | |
-setup(void) { | |
+setup(void) | |
+{ | |
XSetWindowAttributes wa; | |
/* clean up any zombies immediately */ | |
t@@ -1555,34 +1604,38 @@ setup(void) { | |
} | |
void | |
-showhide(Client *c) { | |
- if(!c) | |
+showhide(Client *c) | |
+{ | |
+ if (!c) | |
return; | |
- if(ISVISIBLE(c)) { /* show clients top down */ | |
+ if (ISVISIBLE(c)) { | |
+ /* show clients top down */ | |
XMoveWindow(dpy, c->win, c->x, c->y); | |
- if((!c->mon->lt[c->mon->sellt]->arrange || c->isfloating) && !… | |
+ if ((!c->mon->lt[c->mon->sellt]->arrange || c->isfloating) && … | |
resize(c, c->x, c->y, c->w, c->h, 0); | |
showhide(c->snext); | |
- } | |
- else { /* hide clients bottom up */ | |
+ } else { | |
+ /* hide clients bottom up */ | |
showhide(c->snext); | |
XMoveWindow(dpy, c->win, WIDTH(c) * -2, c->y); | |
} | |
} | |
void | |
-sigchld(int unused) { | |
- if(signal(SIGCHLD, sigchld) == SIG_ERR) | |
+sigchld(int unused) | |
+{ | |
+ if (signal(SIGCHLD, sigchld) == SIG_ERR) | |
die("can't install SIGCHLD handler:"); | |
- while(0 < waitpid(-1, NULL, WNOHANG)); | |
+ while (0 < waitpid(-1, NULL, WNOHANG)); | |
} | |
void | |
-spawn(const Arg *arg) { | |
- if(arg->v == dmenucmd) | |
+spawn(const Arg *arg) | |
+{ | |
+ if (arg->v == dmenucmd) | |
dmenumon[0] = '0' + selmon->num; | |
- if(fork() == 0) { | |
- if(dpy) | |
+ if (fork() == 0) { | |
+ if (dpy) | |
close(ConnectionNumber(dpy)); | |
setsid(); | |
execvp(((char **)arg->v)[0], (char **)arg->v); | |
t@@ -1593,8 +1646,9 @@ spawn(const Arg *arg) { | |
} | |
void | |
-tag(const Arg *arg) { | |
- if(selmon->sel && arg->ui & TAGMASK) { | |
+tag(const Arg *arg) | |
+{ | |
+ if (selmon->sel && arg->ui & TAGMASK) { | |
selmon->sel->tags = arg->ui & TAGMASK; | |
focus(NULL); | |
arrange(selmon); | |
t@@ -1602,32 +1656,33 @@ tag(const Arg *arg) { | |
} | |
void | |
-tagmon(const Arg *arg) { | |
- if(!selmon->sel || !mons->next) | |
+tagmon(const Arg *arg) | |
+{ | |
+ if (!selmon->sel || !mons->next) | |
return; | |
sendmon(selmon->sel, dirtomon(arg->i)); | |
} | |
void | |
-tile(Monitor *m) { | |
+tile(Monitor *m) | |
+{ | |
unsigned int i, n, h, mw, my, ty; | |
Client *c; | |
- for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++); | |
- if(n == 0) | |
+ for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++); | |
+ if (n == 0) | |
return; | |
- if(n > m->nmaster) | |
+ if (n > m->nmaster) | |
mw = m->nmaster ? m->ww * m->mfact : 0; | |
else | |
mw = m->ww; | |
- for(i = my = ty = 0, c = nexttiled(m->clients); c; c = nexttiled(c->ne… | |
- if(i < m->nmaster) { | |
+ for (i = my = ty = 0, c = nexttiled(m->clients); c; c = nexttiled(c->n… | |
+ if (i < m->nmaster) { | |
h = (m->wh - my) / (MIN(n, m->nmaster) - i); | |
resize(c, m->wx, m->wy + my, mw - (2*c->bw), h - (2*c-… | |
my += HEIGHT(c); | |
- } | |
- else { | |
+ } else { | |
h = (m->wh - ty) / (n - i); | |
resize(c, m->wx + mw, m->wy + ty, m->ww - mw - (2*c->b… | |
ty += HEIGHT(c); | |
t@@ -1635,7 +1690,8 @@ tile(Monitor *m) { | |
} | |
void | |
-togglebar(const Arg *arg) { | |
+togglebar(const Arg *arg) | |
+{ | |
selmon->showbar = !selmon->showbar; | |
updatebarpos(selmon); | |
XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon-… | |
t@@ -1643,26 +1699,28 @@ togglebar(const Arg *arg) { | |
} | |
void | |
-togglefloating(const Arg *arg) { | |
- if(!selmon->sel) | |
+togglefloating(const Arg *arg) | |
+{ | |
+ if (!selmon->sel) | |
return; | |
- if(selmon->sel->isfullscreen) /* no support for fullscreen windows */ | |
+ if (selmon->sel->isfullscreen) /* no support for fullscreen windows */ | |
return; | |
selmon->sel->isfloating = !selmon->sel->isfloating || selmon->sel->isf… | |
- if(selmon->sel->isfloating) | |
+ if (selmon->sel->isfloating) | |
resize(selmon->sel, selmon->sel->x, selmon->sel->y, | |
selmon->sel->w, selmon->sel->h, 0); | |
arrange(selmon); | |
} | |
void | |
-toggletag(const Arg *arg) { | |
+toggletag(const Arg *arg) | |
+{ | |
unsigned int newtags; | |
- if(!selmon->sel) | |
+ if (!selmon->sel) | |
return; | |
newtags = selmon->sel->tags ^ (arg->ui & TAGMASK); | |
- if(newtags) { | |
+ if (newtags) { | |
selmon->sel->tags = newtags; | |
focus(NULL); | |
arrange(selmon); | |
t@@ -1670,10 +1728,11 @@ toggletag(const Arg *arg) { | |
} | |
void | |
-toggleview(const Arg *arg) { | |
+toggleview(const Arg *arg) | |
+{ | |
unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & … | |
- if(newtagset) { | |
+ if (newtagset) { | |
selmon->tagset[selmon->seltags] = newtagset; | |
focus(NULL); | |
arrange(selmon); | |
t@@ -1681,26 +1740,28 @@ toggleview(const Arg *arg) { | |
} | |
void | |
-unfocus(Client *c, int setfocus) { | |
- if(!c) | |
+unfocus(Client *c, int setfocus) | |
+{ | |
+ if (!c) | |
return; | |
grabbuttons(c, 0); | |
XSetWindowBorder(dpy, c->win, scheme[SchemeNorm].border->pix); | |
- if(setfocus) { | |
+ if (setfocus) { | |
XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime); | |
XDeleteProperty(dpy, root, netatom[NetActiveWindow]); | |
} | |
} | |
void | |
-unmanage(Client *c, int destroyed) { | |
+unmanage(Client *c, int destroyed) | |
+{ | |
Monitor *m = c->mon; | |
XWindowChanges wc; | |
/* The server grab construct avoids race conditions. */ | |
detach(c); | |
detachstack(c); | |
- if(!destroyed) { | |
+ if (!destroyed) { | |
wc.border_width = c->oldbw; | |
XGrabServer(dpy); | |
XSetErrorHandler(xerrordummy); | |
t@@ -1718,12 +1779,13 @@ unmanage(Client *c, int destroyed) { | |
} | |
void | |
-unmapnotify(XEvent *e) { | |
+unmapnotify(XEvent *e) | |
+{ | |
Client *c; | |
XUnmapEvent *ev = &e->xunmap; | |
- if((c = wintoclient(ev->window))) { | |
- if(ev->send_event) | |
+ if ((c = wintoclient(ev->window))) { | |
+ if (ev->send_event) | |
setclientstate(c, WithdrawnState); | |
else | |
unmanage(c, 0); | |
t@@ -1731,14 +1793,15 @@ unmapnotify(XEvent *e) { | |
} | |
void | |
-updatebars(void) { | |
+updatebars(void) | |
+{ | |
Monitor *m; | |
XSetWindowAttributes wa = { | |
.override_redirect = True, | |
.background_pixmap = ParentRelative, | |
.event_mask = ButtonPressMask|ExposureMask | |
}; | |
- for(m = mons; m; m = m->next) { | |
+ for (m = mons; m; m = m->next) { | |
if (m->barwin) | |
continue; | |
m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, … | |
t@@ -1750,61 +1813,63 @@ updatebars(void) { | |
} | |
void | |
-updatebarpos(Monitor *m) { | |
+updatebarpos(Monitor *m) | |
+{ | |
m->wy = m->my; | |
m->wh = m->mh; | |
- if(m->showbar) { | |
+ if (m->showbar) { | |
m->wh -= bh; | |
m->by = m->topbar ? m->wy : m->wy + m->wh; | |
m->wy = m->topbar ? m->wy + bh : m->wy; | |
- } | |
- else | |
+ } else | |
m->by = -bh; | |
} | |
void | |
-updateclientlist() { | |
+updateclientlist() | |
+{ | |
Client *c; | |
Monitor *m; | |
XDeleteProperty(dpy, root, netatom[NetClientList]); | |
- for(m = mons; m; m = m->next) | |
- for(c = m->clients; c; c = c->next) | |
+ for (m = mons; m; m = m->next) | |
+ for (c = m->clients; c; c = c->next) | |
XChangeProperty(dpy, root, netatom[NetClientList], | |
XA_WINDOW, 32, PropModeAppend, | |
(unsigned char *) &(c->win), 1); | |
} | |
int | |
-updategeom(void) { | |
+updategeom(void) | |
+{ | |
int dirty = 0; | |
#ifdef XINERAMA | |
- if(XineramaIsActive(dpy)) { | |
+ if (XineramaIsActive(dpy)) { | |
int i, j, n, nn; | |
Client *c; | |
Monitor *m; | |
XineramaScreenInfo *info = XineramaQueryScreens(dpy, &nn); | |
XineramaScreenInfo *unique = NULL; | |
- for(n = 0, m = mons; m; m = m->next, n++); | |
+ for (n = 0, m = mons; m; m = m->next, n++); | |
/* only consider unique geometries as separate screens */ | |
unique = ecalloc(nn, sizeof(XineramaScreenInfo)); | |
- for(i = 0, j = 0; i < nn; i++) | |
- if(isuniquegeom(unique, j, &info[i])) | |
+ for (i = 0, j = 0; i < nn; i++) | |
+ if (isuniquegeom(unique, j, &info[i])) | |
memcpy(&unique[j++], &info[i], sizeof(Xinerama… | |
XFree(info); | |
nn = j; | |
- if(n <= nn) { | |
- for(i = 0; i < (nn - n); i++) { /* new monitors availa… | |
- for(m = mons; m && m->next; m = m->next); | |
- if(m) | |
+ if (n <= nn) { | |
+ for (i = 0; i < (nn - n); i++) { /* new monitors avail… | |
+ for (m = mons; m && m->next; m = m->next); | |
+ if (m) | |
m->next = createmon(); | |
else | |
mons = createmon(); | |
} | |
- for(i = 0, m = mons; i < nn && m; m = m->next, i++) | |
- if(i >= n | |
+ for (i = 0, m = mons; i < nn && m; m = m->next, i++) | |
+ if (i >= n | |
|| (unique[i].x_org != m->mx || unique[i].y_or… | |
|| unique[i].width != m->mw || unique[i].h… | |
{ | |
t@@ -1816,11 +1881,11 @@ updategeom(void) { | |
m->mh = m->wh = unique[i].height; | |
updatebarpos(m); | |
} | |
- } | |
- else { /* less monitors available nn < n */ | |
- for(i = nn; i < n; i++) { | |
- for(m = mons; m && m->next; m = m->next); | |
- while(m->clients) { | |
+ } else { | |
+ /* less monitors available nn < n */ | |
+ for (i = nn; i < n; i++) { | |
+ for (m = mons; m && m->next; m = m->next); | |
+ while (m->clients) { | |
dirty = 1; | |
c = m->clients; | |
m->clients = c->next; | |
t@@ -1829,27 +1894,26 @@ updategeom(void) { | |
attach(c); | |
attachstack(c); | |
} | |
- if(m == selmon) | |
+ if (m == selmon) | |
selmon = mons; | |
cleanupmon(m); | |
} | |
} | |
free(unique); | |
- } | |
- else | |
+ } else | |
#endif /* XINERAMA */ | |
/* default monitor setup */ | |
{ | |
- if(!mons) | |
+ if (!mons) | |
mons = createmon(); | |
- if(mons->mw != sw || mons->mh != sh) { | |
+ if (mons->mw != sw || mons->mh != sh) { | |
dirty = 1; | |
mons->mw = mons->ww = sw; | |
mons->mh = mons->wh = sh; | |
updatebarpos(mons); | |
} | |
} | |
- if(dirty) { | |
+ if (dirty) { | |
selmon = mons; | |
selmon = wintomon(root); | |
} | |
t@@ -1857,108 +1921,106 @@ updategeom(void) { | |
} | |
void | |
-updatenumlockmask(void) { | |
+updatenumlockmask(void) | |
+{ | |
unsigned int i, j; | |
XModifierKeymap *modmap; | |
numlockmask = 0; | |
modmap = XGetModifierMapping(dpy); | |
- for(i = 0; i < 8; i++) | |
- for(j = 0; j < modmap->max_keypermod; j++) | |
- if(modmap->modifiermap[i * modmap->max_keypermod + j] | |
+ for (i = 0; i < 8; i++) | |
+ for (j = 0; j < modmap->max_keypermod; j++) | |
+ if (modmap->modifiermap[i * modmap->max_keypermod + j] | |
== XKeysymToKeycode(dpy, XK_Num_Lock)) | |
numlockmask = (1 << i); | |
XFreeModifiermap(modmap); | |
} | |
void | |
-updatesizehints(Client *c) { | |
+updatesizehints(Client *c) | |
+{ | |
long msize; | |
XSizeHints size; | |
- if(!XGetWMNormalHints(dpy, c->win, &size, &msize)) | |
+ if (!XGetWMNormalHints(dpy, c->win, &size, &msize)) | |
/* size is uninitialized, ensure that size.flags aren't used */ | |
size.flags = PSize; | |
- if(size.flags & PBaseSize) { | |
+ if (size.flags & PBaseSize) { | |
c->basew = size.base_width; | |
c->baseh = size.base_height; | |
- } | |
- else if(size.flags & PMinSize) { | |
+ } else if (size.flags & PMinSize) { | |
c->basew = size.min_width; | |
c->baseh = size.min_height; | |
- } | |
- else | |
+ } else | |
c->basew = c->baseh = 0; | |
- if(size.flags & PResizeInc) { | |
+ if (size.flags & PResizeInc) { | |
c->incw = size.width_inc; | |
c->inch = size.height_inc; | |
- } | |
- else | |
+ } else | |
c->incw = c->inch = 0; | |
- if(size.flags & PMaxSize) { | |
+ if (size.flags & PMaxSize) { | |
c->maxw = size.max_width; | |
c->maxh = size.max_height; | |
- } | |
- else | |
+ } else | |
c->maxw = c->maxh = 0; | |
- if(size.flags & PMinSize) { | |
+ if (size.flags & PMinSize) { | |
c->minw = size.min_width; | |
c->minh = size.min_height; | |
- } | |
- else if(size.flags & PBaseSize) { | |
+ } else if (size.flags & PBaseSize) { | |
c->minw = size.base_width; | |
c->minh = size.base_height; | |
- } | |
- else | |
+ } else | |
c->minw = c->minh = 0; | |
- if(size.flags & PAspect) { | |
+ if (size.flags & PAspect) { | |
c->mina = (float)size.min_aspect.y / size.min_aspect.x; | |
c->maxa = (float)size.max_aspect.x / size.max_aspect.y; | |
- } | |
- else | |
+ } else | |
c->maxa = c->mina = 0.0; | |
c->isfixed = (c->maxw && c->minw && c->maxh && c->minh | |
&& c->maxw == c->minw && c->maxh == c->minh); | |
} | |
void | |
-updatetitle(Client *c) { | |
- if(!gettextprop(c->win, netatom[NetWMName], c->name, sizeof c->name)) | |
+updatetitle(Client *c) | |
+{ | |
+ if (!gettextprop(c->win, netatom[NetWMName], c->name, sizeof c->name)) | |
gettextprop(c->win, XA_WM_NAME, c->name, sizeof c->name); | |
- if(c->name[0] == '\0') /* hack to mark broken clients */ | |
+ if (c->name[0] == '\0') /* hack to mark broken clients */ | |
strcpy(c->name, broken); | |
} | |
void | |
-updatestatus(void) { | |
- if(!gettextprop(root, XA_WM_NAME, stext, sizeof(stext))) | |
+updatestatus(void) | |
+{ | |
+ if (!gettextprop(root, XA_WM_NAME, stext, sizeof(stext))) | |
strcpy(stext, "dwm-"VERSION); | |
drawbar(selmon); | |
} | |
void | |
-updatewindowtype(Client *c) { | |
+updatewindowtype(Client *c) | |
+{ | |
Atom state = getatomprop(c, netatom[NetWMState]); | |
Atom wtype = getatomprop(c, netatom[NetWMWindowType]); | |
- if(state == netatom[NetWMFullscreen]) | |
+ if (state == netatom[NetWMFullscreen]) | |
setfullscreen(c, 1); | |
- if(wtype == netatom[NetWMWindowTypeDialog]) | |
+ if (wtype == netatom[NetWMWindowTypeDialog]) | |
c->isfloating = 1; | |
} | |
void | |
-updatewmhints(Client *c) { | |
+updatewmhints(Client *c) | |
+{ | |
XWMHints *wmh; | |
- if((wmh = XGetWMHints(dpy, c->win))) { | |
- if(c == selmon->sel && wmh->flags & XUrgencyHint) { | |
+ if ((wmh = XGetWMHints(dpy, c->win))) { | |
+ if (c == selmon->sel && wmh->flags & XUrgencyHint) { | |
wmh->flags &= ~XUrgencyHint; | |
XSetWMHints(dpy, c->win, wmh); | |
- } | |
- else | |
+ } else | |
c->isurgent = (wmh->flags & XUrgencyHint) ? 1 : 0; | |
- if(wmh->flags & InputHint) | |
+ if (wmh->flags & InputHint) | |
c->neverfocus = !wmh->input; | |
else | |
c->neverfocus = 0; | |
t@@ -1967,40 +2029,43 @@ updatewmhints(Client *c) { | |
} | |
void | |
-view(const Arg *arg) { | |
- if((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags]) | |
+view(const Arg *arg) | |
+{ | |
+ if ((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags]) | |
return; | |
selmon->seltags ^= 1; /* toggle sel tagset */ | |
- if(arg->ui & TAGMASK) | |
+ if (arg->ui & TAGMASK) | |
selmon->tagset[selmon->seltags] = arg->ui & TAGMASK; | |
focus(NULL); | |
arrange(selmon); | |
} | |
Client * | |
-wintoclient(Window w) { | |
+wintoclient(Window w) | |
+{ | |
Client *c; | |
Monitor *m; | |
- for(m = mons; m; m = m->next) | |
- for(c = m->clients; c; c = c->next) | |
- if(c->win == w) | |
+ for (m = mons; m; m = m->next) | |
+ for (c = m->clients; c; c = c->next) | |
+ if (c->win == w) | |
return c; | |
return NULL; | |
} | |
Monitor * | |
-wintomon(Window w) { | |
+wintomon(Window w) | |
+{ | |
int x, y; | |
Client *c; | |
Monitor *m; | |
- if(w == root && getrootptr(&x, &y)) | |
+ if (w == root && getrootptr(&x, &y)) | |
return recttomon(x, y, 1, 1); | |
- for(m = mons; m; m = m->next) | |
- if(w == m->barwin) | |
+ for (m = mons; m; m = m->next) | |
+ if (w == m->barwin) | |
return m; | |
- if((c = wintoclient(w))) | |
+ if ((c = wintoclient(w))) | |
return c->mon; | |
return selmon; | |
} | |
t@@ -2009,8 +2074,9 @@ wintomon(Window w) { | |
* ignored (especially on UnmapNotify's). Other types of errors call Xlibs | |
* default error handler, which may call exit. */ | |
int | |
-xerror(Display *dpy, XErrorEvent *ee) { | |
- if(ee->error_code == BadWindow | |
+xerror(Display *dpy, XErrorEvent *ee) | |
+{ | |
+ if (ee->error_code == BadWindow | |
|| (ee->request_code == X_SetInputFocus && ee->error_code == BadMatch) | |
|| (ee->request_code == X_PolyText8 && ee->error_code == BadDrawable) | |
|| (ee->request_code == X_PolyFillRectangle && ee->error_code == BadDr… | |
t@@ -2026,40 +2092,44 @@ xerror(Display *dpy, XErrorEvent *ee) { | |
} | |
int | |
-xerrordummy(Display *dpy, XErrorEvent *ee) { | |
+xerrordummy(Display *dpy, XErrorEvent *ee) | |
+{ | |
return 0; | |
} | |
/* Startup Error handler to check if another window manager | |
* is already running. */ | |
int | |
-xerrorstart(Display *dpy, XErrorEvent *ee) { | |
+xerrorstart(Display *dpy, XErrorEvent *ee) | |
+{ | |
die("dwm: another window manager is already running\n"); | |
return -1; | |
} | |
void | |
-zoom(const Arg *arg) { | |
+zoom(const Arg *arg) | |
+{ | |
Client *c = selmon->sel; | |
- if(!selmon->lt[selmon->sellt]->arrange | |
+ if (!selmon->lt[selmon->sellt]->arrange | |
|| (selmon->sel && selmon->sel->isfloating)) | |
return; | |
- if(c == nexttiled(selmon->clients)) | |
- if(!c || !(c = nexttiled(c->next))) | |
+ if (c == nexttiled(selmon->clients)) | |
+ if (!c || !(c = nexttiled(c->next))) | |
return; | |
pop(c); | |
} | |
int | |
-main(int argc, char *argv[]) { | |
- if(argc == 2 && !strcmp("-v", argv[1])) | |
- die("dwm-"VERSION", © 2006-2015 dwm engineers, see LICENSE fo… | |
- else if(argc != 1) | |
+main(int argc, char *argv[]) | |
+{ | |
+ if (argc == 2 && !strcmp("-v", argv[1])) | |
+ die("dwm-"VERSION "\n"); | |
+ else if (argc != 1) | |
die("usage: dwm [-v]\n"); | |
- if(!setlocale(LC_CTYPE, "") || !XSupportsLocale()) | |
+ if (!setlocale(LC_CTYPE, "") || !XSupportsLocale()) | |
fputs("warning: no locale support\n", stderr); | |
- if(!(dpy = XOpenDisplay(NULL))) | |
+ if (!(dpy = XOpenDisplay(NULL))) | |
die("dwm: cannot open display\n"); | |
checkotherwm(); | |
setup(); |