| 
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -129,7 +129,7 @@ typedef struct { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																/* function declarations */ | 
																 | 
																 | 
																/* function declarations */ | 
															
														
														
													
														
															
																 | 
																 | 
																static void applyrules(Client *c); | 
																 | 
																 | 
																static void applyrules(Client *c); | 
															
														
														
													
														
															
																 | 
																 | 
																static void applysizehints(Client *c, int *w, int *h); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h); | 
															
														
														
													
														
															
																 | 
																 | 
																static void arrange(void); | 
																 | 
																 | 
																static void arrange(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void attach(Client *c); | 
																 | 
																 | 
																static void attach(Client *c); | 
															
														
														
													
														
															
																 | 
																 | 
																static void attachstack(Client *c); | 
																 | 
																 | 
																static void attachstack(Client *c); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -252,6 +252,7 @@ applyrules(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																	XClassHint ch = { 0 }; | 
																 | 
																 | 
																	XClassHint ch = { 0 }; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	/* rule matching */ | 
																 | 
																 | 
																	/* rule matching */ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->isfloating = c->tags = 0; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(XGetClassHint(dpy, c->win, &ch)) { | 
																 | 
																 | 
																	if(XGetClassHint(dpy, c->win, &ch)) { | 
															
														
														
													
														
															
																 | 
																 | 
																		for(i = 0; i < LENGTH(rules); i++) { | 
																 | 
																 | 
																		for(i = 0; i < LENGTH(rules); i++) { | 
															
														
														
													
														
															
																 | 
																 | 
																			r = &rules[i]; | 
																 | 
																 | 
																			r = &rules[i]; | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -259,7 +260,7 @@ applyrules(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																			&& (!r->class || (ch.res_class && strstr(ch.res_class, r->class))) | 
																 | 
																 | 
																			&& (!r->class || (ch.res_class && strstr(ch.res_class, r->class))) | 
															
														
														
													
														
															
																 | 
																 | 
																			&& (!r->instance || (ch.res_name && strstr(ch.res_name, r->instance)))) { | 
																 | 
																 | 
																			&& (!r->instance || (ch.res_name && strstr(ch.res_name, r->instance)))) { | 
															
														
														
													
														
															
																 | 
																 | 
																				c->isfloating = r->isfloating; | 
																 | 
																 | 
																				c->isfloating = r->isfloating; | 
															
														
														
													
														
															
																 | 
																 | 
																				c->tags |= r->tags & TAGMASK ? r->tags & TAGMASK : tagset[seltags];  | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				c->tags |= r->tags;  | 
															
														
														
													
														
															
																 | 
																 | 
																			} | 
																 | 
																 | 
																			} | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																		if(ch.res_class) | 
																 | 
																 | 
																		if(ch.res_class) | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -267,60 +268,72 @@ applyrules(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(ch.res_name) | 
																 | 
																 | 
																		if(ch.res_name) | 
															
														
														
													
														
															
																 | 
																 | 
																			XFree(ch.res_name); | 
																 | 
																 | 
																			XFree(ch.res_name); | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	if(!c->tags) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		c->tags = tagset[seltags]; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->tags = c->tags & TAGMASK ? c->tags & TAGMASK : tagset[seltags]; | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																applysizehints(Client *c, int *w, int *h) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																Bool | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																applysizehints(Client *c, int *x, int *y, int *w, int *h) { | 
															
														
														
													
														
															
																 | 
																 | 
																	Bool baseismin; | 
																 | 
																 | 
																	Bool baseismin; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(!resizehints && !c->isfloating) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	/* see last two sentences in ICCCM 4.1.2.3 */ | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	baseismin = c->basew == c->minw && c->baseh == c->minh; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	/* set minimum possible */ | 
																 | 
																 | 
																	/* set minimum possible */ | 
															
														
														
													
														
															
																 | 
																 | 
																	*w = MAX(1, *w); | 
																 | 
																 | 
																	*w = MAX(1, *w); | 
															
														
														
													
														
															
																 | 
																 | 
																	*h = MAX(1, *h); | 
																 | 
																 | 
																	*h = MAX(1, *h); | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(!baseismin) { /* temporarily remove base dimensions */ | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*w -= c->basew; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*h -= c->baseh; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(*x > sx + sw) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*x = sw - WIDTH(c); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(*y > sy + sh) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*y = sh - HEIGHT(c); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(*x + *w + 2 * c->bw < sx) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*x = sx; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(*y + *h + 2 * c->bw < sy) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*y = sy; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(*h < bh) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*h = bh; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(*w < bh) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*w = bh; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(resizehints || c->isfloating) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		/* 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 */ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*w -= c->basew; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*h -= c->baseh; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	/* adjust for aspect limits */ | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->mina > 0 && c->maxa > 0) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		if(c->maxa < (float)*w / *h) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			*w = *h * c->maxa; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		else if(c->mina < (float)*h / *w) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																			*h = *w * c->mina; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		/* adjust for aspect limits */ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(c->mina > 0 && c->maxa > 0) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			if(c->maxa < (float)*w / *h) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				*w = *h * c->maxa; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			else if(c->mina < (float)*h / *w) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				*h = *w * c->mina; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(baseismin) { /* increment calculation requires this */ | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*w -= c->basew; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*h -= c->baseh; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(baseismin) { /* increment calculation requires this */ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*w -= c->basew; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*h -= c->baseh; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	/* adjust for increment value */ | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->incw) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*w -= *w % c->incw; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->inch) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*h -= *h % c->inch; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		/* adjust for increment value */ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(c->incw) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*w -= *w % c->incw; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(c->inch) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*h -= *h % c->inch; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	/* restore base dimensions */ | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	*w += c->basew; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	*h += c->baseh; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		/* restore base dimensions */ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*w += c->basew; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*h += c->baseh; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	*w = MAX(*w, c->minw); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	*h = MAX(*h, c->minh); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*w = MAX(*w, c->minw); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		*h = MAX(*h, c->minh); | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->maxw) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*w = MIN(*w, c->maxw); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(c->maxw) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*w = MIN(*w, c->maxw); | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->maxh) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		*h = MIN(*h, c->maxh); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(c->maxh) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			*h = MIN(*h, c->maxh); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	return *x != c->x || *y != c->y || *w != c->w || *h != c->h; | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1005,8 +1018,6 @@ movemouse(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																	None, cursor[CurMove], CurrentTime) != GrabSuccess) | 
																 | 
																 | 
																	None, cursor[CurMove], CurrentTime) != GrabSuccess) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	XQueryPointer(dpy, root, &dummy, &dummy, &x, &y, &di, &di, &dui); | 
																 | 
																 | 
																	XQueryPointer(dpy, root, &dummy, &dummy, &x, &y, &di, &di, &dui); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(usegrab) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		XGrabServer(dpy); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	do { | 
																 | 
																 | 
																	do { | 
															
														
														
													
														
															
																 | 
																 | 
																		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev); | 
																 | 
																 | 
																		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev); | 
															
														
														
													
														
															
																 | 
																 | 
																		switch (ev.type) { | 
																 | 
																 | 
																		switch (ev.type) { | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1037,8 +1048,6 @@ movemouse(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	while(ev.type != ButtonRelease); | 
																 | 
																 | 
																	while(ev.type != ButtonRelease); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(usegrab) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		XUngrabServer(dpy); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	XUngrabPointer(dpy, CurrentTime); | 
																 | 
																 | 
																	XUngrabPointer(dpy, CurrentTime); | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1091,22 +1100,7 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																resize(Client *c, int x, int y, int w, int h) { | 
																 | 
																 | 
																resize(Client *c, int x, int y, int w, int h) { | 
															
														
														
													
														
															
																 | 
																 | 
																	XWindowChanges wc; | 
																 | 
																 | 
																	XWindowChanges wc; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	applysizehints(c, &w, &h); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(w <= 0 || h <= 0) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(x > sx + sw) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		x = sw - WIDTH(c); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(y > sy + sh) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		y = sh - HEIGHT(c); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(x + w + 2 * c->bw < sx) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		x = sx; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(y + h + 2 * c->bw < sy) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		y = sy; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(h < bh) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		h = bh; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(w < bh) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		w = bh; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->x != x || c->y != y || c->w != w || c->h != h) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(applysizehints(c, &x, &y, &w, &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; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1135,8 +1129,6 @@ resizemouse(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																	None, cursor[CurResize], CurrentTime) != GrabSuccess) | 
																 | 
																 | 
																	None, cursor[CurResize], CurrentTime) != GrabSuccess) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1); | 
																 | 
																 | 
																	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(usegrab) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		XGrabServer(dpy); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	do { | 
																 | 
																 | 
																	do { | 
															
														
														
													
														
															
																 | 
																 | 
																		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev); | 
																 | 
																 | 
																		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev); | 
															
														
														
													
														
															
																 | 
																 | 
																		switch(ev.type) { | 
																 | 
																 | 
																		switch(ev.type) { | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1161,8 +1153,6 @@ resizemouse(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	while(ev.type != ButtonRelease); | 
																 | 
																 | 
																	while(ev.type != ButtonRelease); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(usegrab) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		XUngrabServer(dpy); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1); | 
																 | 
																 | 
																	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, 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)); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																	
																 | 
																
  |