| 
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -69,7 +69,7 @@ struct Client { | 
															
														
														
													
														
															
																 | 
																 | 
																	int basew, baseh, incw, inch, maxw, maxh, minw, minh; | 
																 | 
																 | 
																	int basew, baseh, incw, inch, maxw, maxh, minw, minh; | 
															
														
														
													
														
															
																 | 
																 | 
																	int minax, maxax, minay, maxay; | 
																 | 
																 | 
																	int minax, maxax, minay, maxay; | 
															
														
														
													
														
															
																 | 
																 | 
																	long flags; | 
																 | 
																 | 
																	long flags; | 
															
														
														
													
														
															
																 | 
																 | 
																	unsigned int border, oldborder; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	unsigned int bw, oldbw; | 
															
														
														
													
														
															
																 | 
																 | 
																	Bool isbanned, isfixed, isfloating, isurgent; | 
																 | 
																 | 
																	Bool isbanned, isfixed, isfloating, isurgent; | 
															
														
														
													
														
															
																 | 
																 | 
																	Bool *tags; | 
																 | 
																 | 
																	Bool *tags; | 
															
														
														
													
														
															
																 | 
																 | 
																	Client *next; | 
																 | 
																 | 
																	Client *next; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -413,7 +413,7 @@ configure(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																	ce.y = c->y; | 
																 | 
																 | 
																	ce.y = c->y; | 
															
														
														
													
														
															
																 | 
																 | 
																	ce.width = c->w; | 
																 | 
																 | 
																	ce.width = c->w; | 
															
														
														
													
														
															
																 | 
																 | 
																	ce.height = c->h; | 
																 | 
																 | 
																	ce.height = c->h; | 
															
														
														
													
														
															
																 | 
																 | 
																	ce.border_width = c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	ce.border_width = c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																	ce.above = None; | 
																 | 
																 | 
																	ce.above = None; | 
															
														
														
													
														
															
																 | 
																 | 
																	ce.override_redirect = False; | 
																 | 
																 | 
																	ce.override_redirect = False; | 
															
														
														
													
														
															
																 | 
																 | 
																	XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ce); | 
																 | 
																 | 
																	XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ce); | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -435,7 +435,7 @@ configurerequest(XEvent *e) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if((c = getclient(ev->window))) { | 
																 | 
																 | 
																	if((c = getclient(ev->window))) { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(ev->value_mask & CWBorderWidth) | 
																 | 
																 | 
																		if(ev->value_mask & CWBorderWidth) | 
															
														
														
													
														
															
																 | 
																 | 
																			c->border = ev->border_width; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->bw = ev->border_width; | 
															
														
														
													
														
															
																 | 
																 | 
																		if(c->isfixed || c->isfloating || lt->isfloating) { | 
																 | 
																 | 
																		if(c->isfixed || c->isfloating || lt->isfloating) { | 
															
														
														
													
														
															
																 | 
																 | 
																			if(ev->value_mask & CWX) | 
																 | 
																 | 
																			if(ev->value_mask & CWX) | 
															
														
														
													
														
															
																 | 
																 | 
																				c->x = sx + ev->x; | 
																 | 
																 | 
																				c->x = sx + ev->x; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1000,25 +1000,25 @@ manage(Window w, XWindowAttributes *wa) { | 
															
														
														
													
														
															
																 | 
																 | 
																	c->y = wa->y; | 
																 | 
																 | 
																	c->y = wa->y; | 
															
														
														
													
														
															
																 | 
																 | 
																	c->w = wa->width; | 
																 | 
																 | 
																	c->w = wa->width; | 
															
														
														
													
														
															
																 | 
																 | 
																	c->h = wa->height; | 
																 | 
																 | 
																	c->h = wa->height; | 
															
														
														
													
														
															
																 | 
																 | 
																	c->oldborder = wa->border_width; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->oldbw = wa->border_width; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->w == sw && c->h == sh) { | 
																 | 
																 | 
																	if(c->w == sw && c->h == sh) { | 
															
														
														
													
														
															
																 | 
																 | 
																		c->x = sx; | 
																 | 
																 | 
																		c->x = sx; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->y = sy; | 
																 | 
																 | 
																		c->y = sy; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->border = wa->border_width; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		c->bw = wa->border_width; | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	else { | 
																 | 
																 | 
																	else { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(c->x + c->w + 2 * c->border > wx + ww) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			c->x = wx + ww - c->w - 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		if(c->y + c->h + 2 * c->border > wy + wh) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			c->y = wy + wh - c->h - 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(c->x + c->w + 2 * c->bw > wx + ww) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->x = wx + ww - c->w - 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(c->y + c->h + 2 * c->bw > wy + wh) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->y = wy + wh - c->h - 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																		if(c->x < wx) | 
																 | 
																 | 
																		if(c->x < wx) | 
															
														
														
													
														
															
																 | 
																 | 
																			c->x = wx; | 
																 | 
																 | 
																			c->x = wx; | 
															
														
														
													
														
															
																 | 
																 | 
																		if(c->y < wy) | 
																 | 
																 | 
																		if(c->y < wy) | 
															
														
														
													
														
															
																 | 
																 | 
																			c->y = wy; | 
																 | 
																 | 
																			c->y = wy; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->border = BORDERPX; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		c->bw = BORDERPX; | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	wc.border_width = c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	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]); | 
															
														
														
													
														
															
																 | 
																 | 
																	configure(c); /* propagates border_width, if size doesn't change */ | 
																 | 
																 | 
																	configure(c); /* propagates border_width, if size doesn't change */ | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1071,7 +1071,7 @@ monocle(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	for(c = clients; c; c = c->next) | 
																 | 
																 | 
																	for(c = clients; c; c = c->next) | 
															
														
														
													
														
															
																 | 
																 | 
																		if(isvisible(c)) | 
																 | 
																 | 
																		if(isvisible(c)) | 
															
														
														
													
														
															
																 | 
																 | 
																			resize(c, mox, moy, mow, moh, RESIZEHINTS); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			resize(c, mox, moy, mow - 2 * c->bw, moh - 2 * c->bw, RESIZEHINTS); | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1104,12 +1104,12 @@ movemouse(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																			ny = ocy + (ev.xmotion.y - y1); | 
																 | 
																 | 
																			ny = ocy + (ev.xmotion.y - y1); | 
															
														
														
													
														
															
																 | 
																 | 
																			if(abs(wx - nx) < SNAP) | 
																 | 
																 | 
																			if(abs(wx - nx) < SNAP) | 
															
														
														
													
														
															
																 | 
																 | 
																				nx = wx; | 
																 | 
																 | 
																				nx = wx; | 
															
														
														
													
														
															
																 | 
																 | 
																			else if(abs((wx + ww) - (nx + c->w + 2 * c->border)) < SNAP) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																				nx = wx + ww - c->w - 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			else if(abs((wx + ww) - (nx + c->w + 2 * c->bw)) < SNAP) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				nx = wx + ww - c->w - 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																			if(abs(wy - ny) < SNAP) | 
																 | 
																 | 
																			if(abs(wy - ny) < SNAP) | 
															
														
														
													
														
															
																 | 
																 | 
																				ny = wy; | 
																 | 
																 | 
																				ny = wy; | 
															
														
														
													
														
															
																 | 
																 | 
																			else if(abs((wy + wh) - (ny + c->h + 2 * c->border)) < SNAP) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																				ny = wy + wh - c->h - 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			else if(abs((wy + wh) - (ny + c->h + 2 * c->bw)) < SNAP) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				ny = wy + wh - c->h - 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																			if(!c->isfloating && !lt->isfloating && (abs(nx - c->x) > SNAP || abs(ny - c->y) > SNAP)) | 
																 | 
																 | 
																			if(!c->isfloating && !lt->isfloating && (abs(nx - c->x) > SNAP || abs(ny - c->y) > SNAP)) | 
															
														
														
													
														
															
																 | 
																 | 
																				togglefloating(NULL); | 
																 | 
																 | 
																				togglefloating(NULL); | 
															
														
														
													
														
															
																 | 
																 | 
																			if((lt->isfloating) || c->isfloating) | 
																 | 
																 | 
																			if((lt->isfloating) || c->isfloating) | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1219,19 +1219,19 @@ resize(Client *c, int x, int y, int w, int h, Bool sizehints) { | 
															
														
														
													
														
															
																 | 
																 | 
																	if(w <= 0 || h <= 0) | 
																 | 
																 | 
																	if(w <= 0 || h <= 0) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(x > sx + sw) | 
																 | 
																 | 
																	if(x > sx + sw) | 
															
														
														
													
														
															
																 | 
																 | 
																		x = sw - w - 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		x = sw - w - 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(y > sy + sh) | 
																 | 
																 | 
																	if(y > sy + sh) | 
															
														
														
													
														
															
																 | 
																 | 
																		y = sh - h - 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(x + w + 2 * c->border < sx) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		y = sh - h - 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(x + w + 2 * c->bw < sx) | 
															
														
														
													
														
															
																 | 
																 | 
																		x = sx; | 
																 | 
																 | 
																		x = sx; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(y + h + 2 * c->border < sy) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(y + h + 2 * c->bw < sy) | 
															
														
														
													
														
															
																 | 
																 | 
																		y = sy; | 
																 | 
																 | 
																		y = sy; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->x != x || c->y != y || c->w != w || c->h != h) { | 
																 | 
																 | 
																	if(c->x != x || c->y != y || c->w != w || c->h != h) { | 
															
														
														
													
														
															
																 | 
																 | 
																		c->x = wc.x = x; | 
																 | 
																 | 
																		c->x = wc.x = x; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->y = wc.y = y; | 
																 | 
																 | 
																		c->y = wc.y = y; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->w = wc.width = w; | 
																 | 
																 | 
																		c->w = wc.width = w; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->h = wc.height = h; | 
																 | 
																 | 
																		c->h = wc.height = h; | 
															
														
														
													
														
															
																 | 
																 | 
																		wc.border_width = c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		wc.border_width = c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																		XConfigureWindow(dpy, c->win, | 
																 | 
																 | 
																		XConfigureWindow(dpy, c->win, | 
															
														
														
													
														
															
																 | 
																 | 
																				CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc); | 
																 | 
																 | 
																				CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc); | 
															
														
														
													
														
															
																 | 
																 | 
																		configure(c); | 
																 | 
																 | 
																		configure(c); | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1250,13 +1250,13 @@ resizemouse(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync, | 
																 | 
																 | 
																	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync, | 
															
														
														
													
														
															
																 | 
																 | 
																			None, cursor[CurResize], CurrentTime) != GrabSuccess) | 
																 | 
																 | 
																			None, cursor[CurResize], CurrentTime) != GrabSuccess) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1); | 
															
														
														
													
														
															
																 | 
																 | 
																	for(;;) { | 
																 | 
																 | 
																	for(;;) { | 
															
														
														
													
														
															
																 | 
																 | 
																		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask , &ev); | 
																 | 
																 | 
																		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask , &ev); | 
															
														
														
													
														
															
																 | 
																 | 
																		switch(ev.type) { | 
																 | 
																 | 
																		switch(ev.type) { | 
															
														
														
													
														
															
																 | 
																 | 
																		case ButtonRelease: | 
																 | 
																 | 
																		case ButtonRelease: | 
															
														
														
													
														
															
																 | 
																 | 
																			XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, | 
																 | 
																 | 
																			XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, | 
															
														
														
													
														
															
																 | 
																 | 
																					c->w + c->border - 1, c->h + c->border - 1); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																					c->w + c->bw - 1, c->h + c->bw - 1); | 
															
														
														
													
														
															
																 | 
																 | 
																			XUngrabPointer(dpy, CurrentTime); | 
																 | 
																 | 
																			XUngrabPointer(dpy, CurrentTime); | 
															
														
														
													
														
															
																 | 
																 | 
																			while(XCheckMaskEvent(dpy, EnterWindowMask, &ev)); | 
																 | 
																 | 
																			while(XCheckMaskEvent(dpy, EnterWindowMask, &ev)); | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																			return; | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1267,9 +1267,9 @@ resizemouse(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case MotionNotify: | 
																 | 
																 | 
																		case MotionNotify: | 
															
														
														
													
														
															
																 | 
																 | 
																			XSync(dpy, False); | 
																 | 
																 | 
																			XSync(dpy, False); | 
															
														
														
													
														
															
																 | 
																 | 
																			if((nw = ev.xmotion.x - ocx - 2 * c->border + 1) <= 0) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			if((nw = ev.xmotion.x - ocx - 2 * c->bw + 1) <= 0) | 
															
														
														
													
														
															
																 | 
																 | 
																				nw = 1; | 
																 | 
																 | 
																				nw = 1; | 
															
														
														
													
														
															
																 | 
																 | 
																			if((nh = ev.xmotion.y - ocy - 2 * c->border + 1) <= 0) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			if((nh = ev.xmotion.y - ocy - 2 * c->bw + 1) <= 0) | 
															
														
														
													
														
															
																 | 
																 | 
																				nh = 1; | 
																 | 
																 | 
																				nh = 1; | 
															
														
														
													
														
															
																 | 
																 | 
																			if(!c->isfloating && !lt->isfloating && (abs(nw - c->w) > SNAP || abs(nh - c->h) > SNAP)) | 
																 | 
																 | 
																			if(!c->isfloating && !lt->isfloating && (abs(nw - c->w) > SNAP || abs(nh - c->h) > SNAP)) | 
															
														
														
													
														
															
																 | 
																 | 
																				togglefloating(NULL); | 
																 | 
																 | 
																				togglefloating(NULL); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1608,11 +1608,11 @@ tileh(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	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++) { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(i + 1 == n) /* remainder */ | 
																 | 
																 | 
																		if(i + 1 == n) /* remainder */ | 
															
														
														
													
														
															
																 | 
																 | 
																			tileresize(c, x, ty, (tx + tw) - x - 2 * c->border, th - 2 * c->border); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			tileresize(c, x, ty, (tx + tw) - x - 2 * c->bw, th - 2 * c->bw); | 
															
														
														
													
														
															
																 | 
																 | 
																		else | 
																 | 
																 | 
																		else | 
															
														
														
													
														
															
																 | 
																 | 
																			tileresize(c, x, ty, w - 2 * c->border, th - 2 * c->border); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			tileresize(c, x, ty, w - 2 * c->bw, th - 2 * c->bw); | 
															
														
														
													
														
															
																 | 
																 | 
																		if(w != tw) | 
																 | 
																 | 
																		if(w != tw) | 
															
														
														
													
														
															
																 | 
																 | 
																			x = c->x + c->w + 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			x = c->x + c->w + 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1621,9 +1621,9 @@ tilemaster(unsigned int n) { | 
															
														
														
													
														
															
																 | 
																 | 
																	Client *c = nexttiled(clients); | 
																 | 
																 | 
																	Client *c = nexttiled(clients); | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(n == 1) | 
																 | 
																 | 
																	if(n == 1) | 
															
														
														
													
														
															
																 | 
																 | 
																		tileresize(c, mox, moy, mow - 2 * c->border, moh - 2 * c->border); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		tileresize(c, mox, moy, mow - 2 * c->bw, moh - 2 * c->bw); | 
															
														
														
													
														
															
																 | 
																 | 
																	else | 
																 | 
																 | 
																	else | 
															
														
														
													
														
															
																 | 
																 | 
																		tileresize(c, mx, my, mw - 2 * c->border, mh - 2 * c->border); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		tileresize(c, mx, my, mw - 2 * c->bw, mh - 2 * c->bw); | 
															
														
														
													
														
															
																 | 
																 | 
																	return c; | 
																 | 
																 | 
																	return c; | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1654,11 +1654,11 @@ tilev(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	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++) { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(i + 1 == n) /* remainder */ | 
																 | 
																 | 
																		if(i + 1 == n) /* remainder */ | 
															
														
														
													
														
															
																 | 
																 | 
																			tileresize(c, tx, y, tw - 2 * c->border, (ty + th) - y - 2 * c->border); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			tileresize(c, tx, y, tw - 2 * c->bw, (ty + th) - y - 2 * c->bw); | 
															
														
														
													
														
															
																 | 
																 | 
																		else | 
																 | 
																 | 
																		else | 
															
														
														
													
														
															
																 | 
																 | 
																			tileresize(c, tx, y, tw - 2 * c->border, h - 2 * c->border); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			tileresize(c, tx, y, tw - 2 * c->bw, h - 2 * c->bw); | 
															
														
														
													
														
															
																 | 
																 | 
																		if(h != th) | 
																 | 
																 | 
																		if(h != th) | 
															
														
														
													
														
															
																 | 
																 | 
																			y = c->y + c->h + 2 * c->border; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			y = c->y + c->h + 2 * c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1710,7 +1710,7 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																unmanage(Client *c) { | 
																 | 
																 | 
																unmanage(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																	XWindowChanges wc; | 
																 | 
																 | 
																	XWindowChanges wc; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	wc.border_width = c->oldborder; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	wc.border_width = c->oldbw; | 
															
														
														
													
														
															
																 | 
																 | 
																	/* The server grab construct avoids race conditions. */ | 
																 | 
																 | 
																	/* The server grab construct avoids race conditions. */ | 
															
														
														
													
														
															
																 | 
																 | 
																	XGrabServer(dpy); | 
																 | 
																 | 
																	XGrabServer(dpy); | 
															
														
														
													
														
															
																 | 
																 | 
																	XSetErrorHandler(xerrordummy); | 
																 | 
																 | 
																	XSetErrorHandler(xerrordummy); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																	
																 | 
																
  |