|  | @@ -330,16 +330,13 @@ applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact) {
 | 
											
												
													
														|  |  		*h = bh;
 |  |  		*h = bh;
 | 
											
												
													
														|  |  	if(*w < bh)
 |  |  	if(*w < bh)
 | 
											
												
													
														|  |  		*w = bh;
 |  |  		*w = bh;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	if(resizehints || c->isfloating) {
 |  |  	if(resizehints || c->isfloating) {
 | 
											
												
													
														|  |  		/* see last two sentences in ICCCM 4.1.2.3 */
 |  |  		/* see last two sentences in ICCCM 4.1.2.3 */
 | 
											
												
													
														|  |  		baseismin = c->basew == c->minw && c->baseh == c->minh;
 |  |  		baseismin = c->basew == c->minw && c->baseh == c->minh;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		if(!baseismin) { /* temporarily remove base dimensions */
 |  |  		if(!baseismin) { /* temporarily remove base dimensions */
 | 
											
												
													
														|  |  			*w -= c->basew;
 |  |  			*w -= c->basew;
 | 
											
												
													
														|  |  			*h -= c->baseh;
 |  |  			*h -= c->baseh;
 | 
											
												
													
														|  |  		}
 |  |  		}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		/* adjust for aspect limits */
 |  |  		/* adjust for aspect limits */
 | 
											
												
													
														|  |  		if(c->mina > 0 && c->maxa > 0) {
 |  |  		if(c->mina > 0 && c->maxa > 0) {
 | 
											
												
													
														|  |  			if(c->maxa < (float)*w / *h)
 |  |  			if(c->maxa < (float)*w / *h)
 | 
											
										
											
												
													
														|  | @@ -347,28 +344,22 @@ applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact) {
 | 
											
												
													
														|  |  			else if(c->mina < (float)*h / *w)
 |  |  			else if(c->mina < (float)*h / *w)
 | 
											
												
													
														|  |  				*h = *w * c->mina;
 |  |  				*h = *w * c->mina;
 | 
											
												
													
														|  |  		}
 |  |  		}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		if(baseismin) { /* increment calculation requires this */
 |  |  		if(baseismin) { /* increment calculation requires this */
 | 
											
												
													
														|  |  			*w -= c->basew;
 |  |  			*w -= c->basew;
 | 
											
												
													
														|  |  			*h -= c->baseh;
 |  |  			*h -= c->baseh;
 | 
											
												
													
														|  |  		}
 |  |  		}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		/* adjust for increment value */
 |  |  		/* adjust for increment value */
 | 
											
												
													
														|  |  		if(c->incw)
 |  |  		if(c->incw)
 | 
											
												
													
														|  |  			*w -= *w % c->incw;
 |  |  			*w -= *w % c->incw;
 | 
											
												
													
														|  |  		if(c->inch)
 |  |  		if(c->inch)
 | 
											
												
													
														|  |  			*h -= *h % c->inch;
 |  |  			*h -= *h % c->inch;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		/* restore base dimensions */
 |  |  		/* restore base dimensions */
 | 
											
												
													
														|  |  		*w += c->basew;
 |  |  		*w += c->basew;
 | 
											
												
													
														|  |  		*h += c->baseh;
 |  |  		*h += c->baseh;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		*w = MAX(*w, c->minw);
 |  |  		*w = MAX(*w, c->minw);
 | 
											
												
													
														|  |  		*h = MAX(*h, c->minh);
 |  |  		*h = MAX(*h, c->minh);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		if(c->maxw)
 |  |  		if(c->maxw)
 | 
											
												
													
														|  |  			*w = MIN(*w, c->maxw);
 |  |  			*w = MIN(*w, c->maxw);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		if(c->maxh)
 |  |  		if(c->maxh)
 | 
											
												
													
														|  |  			*h = MIN(*h, c->maxh);
 |  |  			*h = MIN(*h, c->maxh);
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
										
											
												
													
														|  | @@ -438,7 +429,6 @@ buttonpress(XEvent *e) {
 | 
											
												
													
														|  |  		focus(c);
 |  |  		focus(c);
 | 
											
												
													
														|  |  		click = ClkClientWin;
 |  |  		click = ClkClientWin;
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	for(i = 0; i < LENGTH(buttons); i++)
 |  |  	for(i = 0; i < LENGTH(buttons); i++)
 | 
											
												
													
														|  |  		if(click == buttons[i].click && buttons[i].func && buttons[i].button == ev->button
 |  |  		if(click == buttons[i].click && buttons[i].func && buttons[i].button == ev->button
 | 
											
												
													
														|  |  		   && CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))
 |  |  		   && CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))
 | 
											
										
											
												
													
														|  | @@ -449,7 +439,6 @@ void
 | 
											
												
													
														|  |  checkotherwm(void) {
 |  |  checkotherwm(void) {
 | 
											
												
													
														|  |  	otherwm = False;
 |  |  	otherwm = False;
 | 
											
												
													
														|  |  	xerrorxlib = XSetErrorHandler(xerrorstart);
 |  |  	xerrorxlib = XSetErrorHandler(xerrorstart);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* this causes an error if some other window manager is running */
 |  |  	/* this causes an error if some other window manager is running */
 | 
											
												
													
														|  |  	XSelectInput(dpy, DefaultRootWindow(dpy), SubstructureRedirectMask);
 |  |  	XSelectInput(dpy, DefaultRootWindow(dpy), SubstructureRedirectMask);
 | 
											
												
													
														|  |  	XSync(dpy, False);
 |  |  	XSync(dpy, False);
 | 
											
										
											
												
													
														|  | @@ -644,7 +633,6 @@ drawbar(Monitor *m) {
 | 
											
												
													
														|  |  		if(c->isurgent)
 |  |  		if(c->isurgent)
 | 
											
												
													
														|  |  			urg |= c->tags;
 |  |  			urg |= c->tags;
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	dc.x = 0;
 |  |  	dc.x = 0;
 | 
											
												
													
														|  |  	if(mons->next) { /* more than a single monitor */
 |  |  	if(mons->next) { /* more than a single monitor */
 | 
											
												
													
														|  |  		dc.w = TEXTW(monsyms[m->screen_number]);
 |  |  		dc.w = TEXTW(monsyms[m->screen_number]);
 | 
											
										
											
												
													
														|  | @@ -676,9 +664,8 @@ drawbar(Monitor *m) {
 | 
											
												
													
														|  |  		}
 |  |  		}
 | 
											
												
													
														|  |  		drawtext(stext, dc.norm, False);
 |  |  		drawtext(stext, dc.norm, False);
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -	else {
 |  | 
 | 
											
												
													
														|  | 
 |  | +	else
 | 
											
												
													
														|  |  		dc.x = m->ww;
 |  |  		dc.x = m->ww;
 | 
											
												
													
														|  | -	}
 |  | 
 | 
											
												
													
														|  |  	if((dc.w = dc.x - x) > bh) {
 |  |  	if((dc.w = dc.x - x) > bh) {
 | 
											
												
													
														|  |  		dc.x = x;
 |  |  		dc.x = x;
 | 
											
												
													
														|  |  		if(m->sel) {
 |  |  		if(m->sel) {
 | 
											
										
											
												
													
														|  | @@ -860,6 +847,7 @@ getrootpointer(int *x, int *y) {
 | 
											
												
													
														|  |  	int di;
 |  |  	int di;
 | 
											
												
													
														|  |  	unsigned int dui;
 |  |  	unsigned int dui;
 | 
											
												
													
														|  |  	Window dummy;
 |  |  	Window dummy;
 | 
											
												
													
														|  | 
 |  | +
 | 
											
												
													
														|  |  	return XQueryPointer(dpy, root, &dummy, &dummy, x, y, &di, &di, &dui);
 |  |  	return XQueryPointer(dpy, root, &dummy, &dummy, x, y, &di, &di, &dui);
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
										
											
												
													
														|  | @@ -931,7 +919,7 @@ grabbuttons(Client *c, Bool focused) {
 | 
											
												
													
														|  |  void
 |  |  void
 | 
											
												
													
														|  |  grabkeys(void) {
 |  |  grabkeys(void) {
 | 
											
												
													
														|  |  	updatenumlockmask();
 |  |  	updatenumlockmask();
 | 
											
												
													
														|  | -	{ /* grab keys */
 |  | 
 | 
											
												
													
														|  | 
 |  | +	{
 | 
											
												
													
														|  |  		unsigned int i, j;
 |  |  		unsigned int i, j;
 | 
											
												
													
														|  |  		unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
 |  |  		unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
 | 
											
												
													
														|  |  		KeyCode code;
 |  |  		KeyCode code;
 | 
											
										
											
												
													
														|  | @@ -1050,7 +1038,6 @@ manage(Window w, XWindowAttributes *wa) {
 | 
											
												
													
														|  |  		die("fatal: could not malloc() %u bytes\n", sizeof(Client));
 |  |  		die("fatal: could not malloc() %u bytes\n", sizeof(Client));
 | 
											
												
													
														|  |  	*c = cz;
 |  |  	*c = cz;
 | 
											
												
													
														|  |  	c->win = w;
 |  |  	c->win = w;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	if(XGetTransientForHint(dpy, w, &trans))
 |  |  	if(XGetTransientForHint(dpy, w, &trans))
 | 
											
												
													
														|  |  		t = wintoclient(trans);
 |  |  		t = wintoclient(trans);
 | 
											
												
													
														|  |  	if(t) {
 |  |  	if(t) {
 | 
											
										
											
												
													
														|  | @@ -1061,7 +1048,6 @@ manage(Window w, XWindowAttributes *wa) {
 | 
											
												
													
														|  |  		c->mon = selmon;
 |  |  		c->mon = selmon;
 | 
											
												
													
														|  |  		applyrules(c);
 |  |  		applyrules(c);
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* geometry */
 |  |  	/* geometry */
 | 
											
												
													
														|  |  	c->x = wa->x + c->mon->wx;
 |  |  	c->x = wa->x + c->mon->wx;
 | 
											
												
													
														|  |  	c->y = wa->y + c->mon->wy;
 |  |  	c->y = wa->y + c->mon->wy;
 | 
											
										
											
												
													
														|  | @@ -1084,7 +1070,6 @@ manage(Window w, XWindowAttributes *wa) {
 | 
											
												
													
														|  |  		           && (c->x + (c->w / 2) < c->mon->wx + c->mon->ww)) ? bh : c->mon->my);
 |  |  		           && (c->x + (c->w / 2) < c->mon->wx + c->mon->ww)) ? bh : c->mon->my);
 | 
											
												
													
														|  |  		c->bw = borderpx;
 |  |  		c->bw = borderpx;
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	wc.border_width = c->bw;
 |  |  	wc.border_width = c->bw;
 | 
											
												
													
														|  |  	XConfigureWindow(dpy, w, CWBorderWidth, &wc);
 |  |  	XConfigureWindow(dpy, w, CWBorderWidth, &wc);
 | 
											
												
													
														|  |  	XSetWindowBorder(dpy, w, dc.norm[ColBorder]);
 |  |  	XSetWindowBorder(dpy, w, dc.norm[ColBorder]);
 | 
											
										
											
												
													
														|  | @@ -1290,7 +1275,6 @@ resizemouse(const Arg *arg) {
 | 
											
												
													
														|  |  		case MotionNotify:
 |  |  		case MotionNotify:
 | 
											
												
													
														|  |  			nw = MAX(ev.xmotion.x - ocx - 2 * c->bw + 1, 1);
 |  |  			nw = MAX(ev.xmotion.x - ocx - 2 * c->bw + 1, 1);
 | 
											
												
													
														|  |  			nh = MAX(ev.xmotion.y - ocy - 2 * c->bw + 1, 1);
 |  |  			nh = MAX(ev.xmotion.y - ocy - 2 * c->bw + 1, 1);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  			if(snap && nw >= selmon->wx && nw <= selmon->wx + selmon->ww
 |  |  			if(snap && nw >= selmon->wx && nw <= selmon->wx + selmon->ww
 | 
											
												
													
														|  |  			        && nh >= selmon->wy && nh <= selmon->wy + selmon->wh) {
 |  |  			        && nh >= selmon->wy && nh <= selmon->wy + selmon->wh) {
 | 
											
												
													
														|  |  				if(!c->isfloating && lt[selmon->sellt]->arrange
 |  |  				if(!c->isfloating && lt[selmon->sellt]->arrange
 | 
											
										
											
												
													
														|  | @@ -1440,19 +1424,16 @@ setup(void) {
 | 
											
												
													
														|  |  	lt[0] = &layouts[0];
 |  |  	lt[0] = &layouts[0];
 | 
											
												
													
														|  |  	lt[1] = &layouts[1 % LENGTH(layouts)];
 |  |  	lt[1] = &layouts[1 % LENGTH(layouts)];
 | 
											
												
													
														|  |  	updategeom();
 |  |  	updategeom();
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* init atoms */
 |  |  	/* init atoms */
 | 
											
												
													
														|  |  	wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
 |  |  	wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
 | 
											
												
													
														|  |  	wmatom[WMDelete] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
 |  |  	wmatom[WMDelete] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
 | 
											
												
													
														|  |  	wmatom[WMState] = XInternAtom(dpy, "WM_STATE", False);
 |  |  	wmatom[WMState] = XInternAtom(dpy, "WM_STATE", False);
 | 
											
												
													
														|  |  	netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False);
 |  |  	netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False);
 | 
											
												
													
														|  |  	netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
 |  |  	netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* init cursors */
 |  |  	/* init cursors */
 | 
											
												
													
														|  |  	cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr);
 |  |  	cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr);
 | 
											
												
													
														|  |  	cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing);
 |  |  	cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing);
 | 
											
												
													
														|  |  	cursor[CurMove] = XCreateFontCursor(dpy, XC_fleur);
 |  |  	cursor[CurMove] = XCreateFontCursor(dpy, XC_fleur);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* init appearance */
 |  |  	/* init appearance */
 | 
											
												
													
														|  |  	dc.norm[ColBorder] = getcolor(normbordercolor);
 |  |  	dc.norm[ColBorder] = getcolor(normbordercolor);
 | 
											
												
													
														|  |  	dc.norm[ColBG] = getcolor(normbgcolor);
 |  |  	dc.norm[ColBG] = getcolor(normbgcolor);
 | 
											
										
											
												
													
														|  | @@ -1465,7 +1446,6 @@ setup(void) {
 | 
											
												
													
														|  |  	XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
 |  |  	XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
 | 
											
												
													
														|  |  	if(!dc.font.set)
 |  |  	if(!dc.font.set)
 | 
											
												
													
														|  |  		XSetFont(dpy, dc.gc, dc.font.xfont->fid);
 |  |  		XSetFont(dpy, dc.gc, dc.font.xfont->fid);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* init bars */
 |  |  	/* init bars */
 | 
											
												
													
														|  |  	for(blw = i = 0; LENGTH(layouts) > 1 && i < LENGTH(layouts); i++) {
 |  |  	for(blw = i = 0; LENGTH(layouts) > 1 && i < LENGTH(layouts); i++) {
 | 
											
												
													
														|  |  		w = TEXTW(layouts[i].symbol);
 |  |  		w = TEXTW(layouts[i].symbol);
 | 
											
										
											
												
													
														|  | @@ -1473,11 +1453,9 @@ setup(void) {
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  |  	updatebars();
 |  |  	updatebars();
 | 
											
												
													
														|  |  	updatestatus();
 |  |  	updatestatus();
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* EWMH support per view */
 |  |  	/* EWMH support per view */
 | 
											
												
													
														|  |  	XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
 |  |  	XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
 | 
											
												
													
														|  |  			PropModeReplace, (unsigned char *) netatom, NetLast);
 |  |  			PropModeReplace, (unsigned char *) netatom, NetLast);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* select for events */
 |  |  	/* select for events */
 | 
											
												
													
														|  |  	wa.cursor = cursor[CurNormal];
 |  |  	wa.cursor = cursor[CurNormal];
 | 
											
												
													
														|  |  	wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask|ButtonPressMask
 |  |  	wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask|ButtonPressMask
 | 
											
										
											
												
													
														|  | @@ -1485,7 +1463,6 @@ setup(void) {
 | 
											
												
													
														|  |  			|PropertyChangeMask;
 |  |  			|PropertyChangeMask;
 | 
											
												
													
														|  |  	XChangeWindowAttributes(dpy, root, CWEventMask|CWCursor, &wa);
 |  |  	XChangeWindowAttributes(dpy, root, CWEventMask|CWCursor, &wa);
 | 
											
												
													
														|  |  	XSelectInput(dpy, root, wa.event_mask);
 |  |  	XSelectInput(dpy, root, wa.event_mask);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	grabkeys();
 |  |  	grabkeys();
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
												
													
														|  |  
 |  |  
 | 
											
										
											
												
													
														|  | @@ -1562,15 +1539,12 @@ tile(Monitor *m) {
 | 
											
												
													
														|  |  	for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
 |  |  	for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
 | 
											
												
													
														|  |  	if(n == 0)
 |  |  	if(n == 0)
 | 
											
												
													
														|  |  		return;
 |  |  		return;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* master */
 |  |  	/* master */
 | 
											
												
													
														|  |  	c = nexttiled(m->clients);
 |  |  	c = nexttiled(m->clients);
 | 
											
												
													
														|  |  	mw = m->mfact * m->ww;
 |  |  	mw = m->mfact * m->ww;
 | 
											
												
													
														|  |  	resize(c, m->wx, m->wy, (n == 1 ? m->ww : mw) - 2 * c->bw, m->wh - 2 * c->bw, False);
 |  |  	resize(c, m->wx, m->wy, (n == 1 ? m->ww : mw) - 2 * c->bw, m->wh - 2 * c->bw, False);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	if(--n == 0)
 |  |  	if(--n == 0)
 | 
											
												
													
														|  |  		return;
 |  |  		return;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* tile stack */
 |  |  	/* tile stack */
 | 
											
												
													
														|  |  	x = (m->wx + mw > c->x + c->w) ? c->x + c->w + 2 * c->bw : m->wx + mw;
 |  |  	x = (m->wx + mw > c->x + c->w) ? c->x + c->w + 2 * c->bw : m->wx + mw;
 | 
											
												
													
														|  |  	y = m->wy;
 |  |  	y = m->wy;
 | 
											
										
											
												
													
														|  | @@ -1578,7 +1552,6 @@ tile(Monitor *m) {
 | 
											
												
													
														|  |  	h = m->wh / n;
 |  |  	h = m->wh / n;
 | 
											
												
													
														|  |  	if(h < bh)
 |  |  	if(h < bh)
 | 
											
												
													
														|  |  		h = m->wh;
 |  |  		h = m->wh;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	for(i = 0, c = nexttiled(c->next); c; c = nexttiled(c->next), i++) {
 |  |  	for(i = 0, c = nexttiled(c->next); c; c = nexttiled(c->next), i++) {
 | 
											
												
													
														|  |  		resize(c, x, y, w - 2 * c->bw, /* remainder */ ((i + 1 == n)
 |  |  		resize(c, x, y, w - 2 * c->bw, /* remainder */ ((i + 1 == n)
 | 
											
												
													
														|  |  		       ? m->wy + m->wh - y - 2 * c->bw : h - 2 * c->bw), False);
 |  |  		       ? m->wy + m->wh - y - 2 * c->bw : h - 2 * c->bw), False);
 | 
											
										
											
												
													
														|  | @@ -1612,7 +1585,6 @@ toggletag(const Arg *arg) {
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  |  	if(!selmon->sel)
 |  |  	if(!selmon->sel)
 | 
											
												
													
														|  |  		return;
 |  |  		return;
 | 
											
												
													
														|  | -	
 |  | 
 | 
											
												
													
														|  |  	mask = selmon->sel->tags ^ (arg->ui & TAGMASK);
 |  |  	mask = selmon->sel->tags ^ (arg->ui & TAGMASK);
 | 
											
												
													
														|  |  	if(mask) {
 |  |  	if(mask) {
 | 
											
												
													
														|  |  		selmon->sel->tags = mask;
 |  |  		selmon->sel->tags = mask;
 | 
											
										
											
												
													
														|  | @@ -1677,10 +1649,8 @@ updatebars(void) {
 | 
											
												
													
														|  |  	wa.override_redirect = True;
 |  |  	wa.override_redirect = True;
 | 
											
												
													
														|  |  	wa.background_pixmap = ParentRelative;
 |  |  	wa.background_pixmap = ParentRelative;
 | 
											
												
													
														|  |  	wa.event_mask = ButtonPressMask|ExposureMask;
 |  |  	wa.event_mask = ButtonPressMask|ExposureMask;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	for(m = mons; m; m = m->next) {
 |  |  	for(m = mons; m; m = m->next) {
 | 
											
												
													
														|  |  		m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),
 |  |  		m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		                          CopyFromParent, DefaultVisual(dpy, screen),
 |  |  		                          CopyFromParent, DefaultVisual(dpy, screen),
 | 
											
												
													
														|  |  		                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
 |  |  		                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
 | 
											
												
													
														|  |  		XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
 |  |  		XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
 | 
											
										
											
												
													
														|  | @@ -1719,7 +1689,6 @@ updategeom(void) {
 | 
											
												
													
														|  |  		m->next = newmons;
 |  |  		m->next = newmons;
 | 
											
												
													
														|  |  		newmons = m;
 |  |  		newmons = m;
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* initialise monitor(s) */
 |  |  	/* initialise monitor(s) */
 | 
											
												
													
														|  |  #ifdef XINERAMA
 |  |  #ifdef XINERAMA
 | 
											
												
													
														|  |  	if(XineramaIsActive(dpy)) {
 |  |  	if(XineramaIsActive(dpy)) {
 | 
											
										
											
												
													
														|  | @@ -1742,7 +1711,6 @@ updategeom(void) {
 | 
											
												
													
														|  |  		m->mw = m->ww = sw;
 |  |  		m->mw = m->ww = sw;
 | 
											
												
													
														|  |  		m->mh = m->wh = sh;
 |  |  		m->mh = m->wh = sh;
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* bar geometry setup */
 |  |  	/* bar geometry setup */
 | 
											
												
													
														|  |  	for(m = newmons; m; m = m->next) {
 |  |  	for(m = newmons; m; m = m->next) {
 | 
											
												
													
														|  |  		m->sel = m->stack = m->clients = NULL;
 |  |  		m->sel = m->stack = m->clients = NULL;
 | 
											
										
											
												
													
														|  | @@ -1754,7 +1722,6 @@ updategeom(void) {
 | 
											
												
													
														|  |  		m->topbar = TOPBAR;
 |  |  		m->topbar = TOPBAR;
 | 
											
												
													
														|  |  		updatebarpos(m);
 |  |  		updatebarpos(m);
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* reassign left over clients of disappeared monitors */
 |  |  	/* reassign left over clients of disappeared monitors */
 | 
											
												
													
														|  |  	for(tm = mons; tm; tm = tm->next)
 |  |  	for(tm = mons; tm; tm = tm->next)
 | 
											
												
													
														|  |  		while(tm->clients) {
 |  |  		while(tm->clients) {
 | 
											
										
											
												
													
														|  | @@ -1765,7 +1732,6 @@ updategeom(void) {
 | 
											
												
													
														|  |  			attach(c);
 |  |  			attach(c);
 | 
											
												
													
														|  |  			attachstack(c);
 |  |  			attachstack(c);
 | 
											
												
													
														|  |  		}
 |  |  		}
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	/* select focused monitor */
 |  |  	/* select focused monitor */
 | 
											
												
													
														|  |  	cleanupmons();
 |  |  	cleanupmons();
 | 
											
												
													
														|  |  	selmon = mons = newmons;
 |  |  	selmon = mons = newmons;
 | 
											
										
											
												
													
														|  | @@ -1861,7 +1827,6 @@ updatewmhints(Client *c) {
 | 
											
												
													
														|  |  		}
 |  |  		}
 | 
											
												
													
														|  |  		else
 |  |  		else
 | 
											
												
													
														|  |  			c->isurgent = (wmh->flags & XUrgencyHint) ? True : False;
 |  |  			c->isurgent = (wmh->flags & XUrgencyHint) ? True : False;
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  		XFree(wmh);
 |  |  		XFree(wmh);
 | 
											
												
													
														|  |  	}
 |  |  	}
 | 
											
												
													
														|  |  }
 |  |  }
 | 
											
										
											
												
													
														|  | @@ -1941,7 +1906,9 @@ void
 | 
											
												
													
														|  |  zoom(const Arg *arg) {
 |  |  zoom(const Arg *arg) {
 | 
											
												
													
														|  |  	Client *c = selmon->sel;
 |  |  	Client *c = selmon->sel;
 | 
											
												
													
														|  |  
 |  |  
 | 
											
												
													
														|  | -	if(!lt[selmon->sellt]->arrange || lt[selmon->sellt]->arrange == monocle || (selmon->sel && selmon->sel->isfloating))
 |  | 
 | 
											
												
													
														|  | 
 |  | +	if(!lt[selmon->sellt]->arrange
 | 
											
												
													
														|  | 
 |  | +	|| lt[selmon->sellt]->arrange == monocle
 | 
											
												
													
														|  | 
 |  | +	|| (selmon->sel && selmon->sel->isfloating))
 | 
											
												
													
														|  |  		return;
 |  |  		return;
 | 
											
												
													
														|  |  	if(c == nexttiled(selmon->clients))
 |  |  	if(c == nexttiled(selmon->clients))
 | 
											
												
													
														|  |  		if(!c || !(c = nexttiled(c->next)))
 |  |  		if(!c || !(c = nexttiled(c->next)))
 | 
											
										
											
												
													
														|  | @@ -1958,19 +1925,15 @@ main(int argc, char *argv[]) {
 | 
											
												
													
														|  |  		die("dwm-"VERSION", © 2006-2009 dwm engineers, see LICENSE for details\n");
 |  |  		die("dwm-"VERSION", © 2006-2009 dwm engineers, see LICENSE for details\n");
 | 
											
												
													
														|  |  	else if(argc != 1)
 |  |  	else if(argc != 1)
 | 
											
												
													
														|  |  		die("usage: dwm [-v]\n");
 |  |  		die("usage: dwm [-v]\n");
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
 |  |  	if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
 | 
											
												
													
														|  |  		fputs("warning: no locale support\n", stderr);
 |  |  		fputs("warning: no locale support\n", stderr);
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	if(!(dpy = XOpenDisplay(NULL)))
 |  |  	if(!(dpy = XOpenDisplay(NULL)))
 | 
											
												
													
														|  |  		die("dwm: cannot open display\n");
 |  |  		die("dwm: cannot open display\n");
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	checkotherwm();
 |  |  	checkotherwm();
 | 
											
												
													
														|  |  	setup();
 |  |  	setup();
 | 
											
												
													
														|  |  	scan();
 |  |  	scan();
 | 
											
												
													
														|  |  	run();
 |  |  	run();
 | 
											
												
													
														|  |  	cleanup();
 |  |  	cleanup();
 | 
											
												
													
														|  | -
 |  | 
 | 
											
												
													
														|  |  	XCloseDisplay(dpy);
 |  |  	XCloseDisplay(dpy);
 | 
											
												
													
														|  |  	return 0;
 |  |  	return 0;
 | 
											
												
													
														|  |  }
 |  |  }
 |