| 
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -57,7 +57,8 @@ | 
															
														
														
													
														
															
																 | 
																 | 
																/* enums */ | 
																 | 
																 | 
																/* enums */ | 
															
														
														
													
														
															
																 | 
																 | 
																enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */ | 
																 | 
																 | 
																enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */ | 
															
														
														
													
														
															
																 | 
																 | 
																enum { ColBorder, ColFG, ColBG, ColLast };              /* color */ | 
																 | 
																 | 
																enum { ColBorder, ColFG, ColBG, ColLast };              /* color */ | 
															
														
														
													
														
															
																 | 
																 | 
																enum { NetSupported, NetWMName, NetWMState, NetLast };  /* EWMH atoms */ | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																enum { NetSupported, NetWMName, NetWMState, | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																       NetWMFullscreen, NetLast };                      /* EWMH atoms */ | 
															
														
														
													
														
															
																 | 
																 | 
																enum { WMProtocols, WMDelete, WMState, WMLast };        /* default atoms */ | 
																 | 
																 | 
																enum { WMProtocols, WMDelete, WMState, WMLast };        /* default atoms */ | 
															
														
														
													
														
															
																 | 
																 | 
																enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, | 
																 | 
																 | 
																enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, | 
															
														
														
													
														
															
																 | 
																 | 
																       ClkClientWin, ClkRootWin, ClkLast };             /* clicks */ | 
																 | 
																 | 
																       ClkClientWin, ClkRootWin, ClkLast };             /* clicks */ | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -83,10 +84,11 @@ struct Client { | 
															
														
														
													
														
															
																 | 
																 | 
																	char name[256]; | 
																 | 
																 | 
																	char name[256]; | 
															
														
														
													
														
															
																 | 
																 | 
																	float mina, maxa; | 
																 | 
																 | 
																	float mina, maxa; | 
															
														
														
													
														
															
																 | 
																 | 
																	int x, y, w, h; | 
																 | 
																 | 
																	int x, y, w, h; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	int oldx, oldy, oldw, oldh; | 
															
														
														
													
														
															
																 | 
																 | 
																	int basew, baseh, incw, inch, maxw, maxh, minw, minh; | 
																 | 
																 | 
																	int basew, baseh, incw, inch, maxw, maxh, minw, minh; | 
															
														
														
													
														
															
																 | 
																 | 
																	int bw, oldbw; | 
																 | 
																 | 
																	int bw, oldbw; | 
															
														
														
													
														
															
																 | 
																 | 
																	unsigned int tags; | 
																 | 
																 | 
																	unsigned int tags; | 
															
														
														
													
														
															
																 | 
																 | 
																	Bool isfixed, isfloating, isurgent; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	Bool isfixed, isfloating, isurgent, oldstate; | 
															
														
														
													
														
															
																 | 
																 | 
																	Client *next; | 
																 | 
																 | 
																	Client *next; | 
															
														
														
													
														
															
																 | 
																 | 
																	Client *snext; | 
																 | 
																 | 
																	Client *snext; | 
															
														
														
													
														
															
																 | 
																 | 
																	Monitor *mon; | 
																 | 
																 | 
																	Monitor *mon; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -161,6 +163,7 @@ static void checkotherwm(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void cleanup(void); | 
																 | 
																 | 
																static void cleanup(void); | 
															
														
														
													
														
															
																 | 
																 | 
																static void cleanupmon(Monitor *mon); | 
																 | 
																 | 
																static void cleanupmon(Monitor *mon); | 
															
														
														
													
														
															
																 | 
																 | 
																static void clearurgent(Client *c); | 
																 | 
																 | 
																static void clearurgent(Client *c); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																static void clientmessage(XEvent *e); | 
															
														
														
													
														
															
																 | 
																 | 
																static void configure(Client *c); | 
																 | 
																 | 
																static void configure(Client *c); | 
															
														
														
													
														
															
																 | 
																 | 
																static void configurenotify(XEvent *e); | 
																 | 
																 | 
																static void configurenotify(XEvent *e); | 
															
														
														
													
														
															
																 | 
																 | 
																static void configurerequest(XEvent *e); | 
																 | 
																 | 
																static void configurerequest(XEvent *e); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -200,6 +203,7 @@ static Monitor *ptrtomon(int x, int y); | 
															
														
														
													
														
															
																 | 
																 | 
																static void propertynotify(XEvent *e); | 
																 | 
																 | 
																static void propertynotify(XEvent *e); | 
															
														
														
													
														
															
																 | 
																 | 
																static void quit(const Arg *arg); | 
																 | 
																 | 
																static void quit(const Arg *arg); | 
															
														
														
													
														
															
																 | 
																 | 
																static void resize(Client *c, int x, int y, int w, int h, Bool interact); | 
																 | 
																 | 
																static void resize(Client *c, int x, int y, int w, int h, Bool interact); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																static void resizeclient(Client *c, int x, int y, int w, int h); | 
															
														
														
													
														
															
																 | 
																 | 
																static void resizemouse(const Arg *arg); | 
																 | 
																 | 
																static void resizemouse(const Arg *arg); | 
															
														
														
													
														
															
																 | 
																 | 
																static void restack(Monitor *m); | 
																 | 
																 | 
																static void restack(Monitor *m); | 
															
														
														
													
														
															
																 | 
																 | 
																static void run(void); | 
																 | 
																 | 
																static void run(void); | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -220,7 +224,7 @@ static void togglebar(const Arg *arg); | 
															
														
														
													
														
															
																 | 
																 | 
																static void togglefloating(const Arg *arg); | 
																 | 
																 | 
																static void togglefloating(const Arg *arg); | 
															
														
														
													
														
															
																 | 
																 | 
																static void toggletag(const Arg *arg); | 
																 | 
																 | 
																static void toggletag(const Arg *arg); | 
															
														
														
													
														
															
																 | 
																 | 
																static void toggleview(const Arg *arg); | 
																 | 
																 | 
																static void toggleview(const Arg *arg); | 
															
														
														
													
														
															
																 | 
																 | 
																static void unfocus(Client *c); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																static void unfocus(Client *c, Bool setfocus); | 
															
														
														
													
														
															
																 | 
																 | 
																static void unmanage(Client *c, Bool destroyed); | 
																 | 
																 | 
																static void unmanage(Client *c, Bool destroyed); | 
															
														
														
													
														
															
																 | 
																 | 
																static void unmapnotify(XEvent *e); | 
																 | 
																 | 
																static void unmapnotify(XEvent *e); | 
															
														
														
													
														
															
																 | 
																 | 
																static Bool updategeom(void); | 
																 | 
																 | 
																static Bool updategeom(void); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -249,6 +253,7 @@ static int (*xerrorxlib)(Display *, XErrorEvent *); | 
															
														
														
													
														
															
																 | 
																 | 
																static unsigned int numlockmask = 0; | 
																 | 
																 | 
																static unsigned int numlockmask = 0; | 
															
														
														
													
														
															
																 | 
																 | 
																static void (*handler[LASTEvent]) (XEvent *) = { | 
																 | 
																 | 
																static void (*handler[LASTEvent]) (XEvent *) = { | 
															
														
														
													
														
															
																 | 
																 | 
																	[ButtonPress] = buttonpress, | 
																 | 
																 | 
																	[ButtonPress] = buttonpress, | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	[ClientMessage] = clientmessage, | 
															
														
														
													
														
															
																 | 
																 | 
																	[ConfigureRequest] = configurerequest, | 
																 | 
																 | 
																	[ConfigureRequest] = configurerequest, | 
															
														
														
													
														
															
																 | 
																 | 
																	[ConfigureNotify] = configurenotify, | 
																 | 
																 | 
																	[ConfigureNotify] = configurenotify, | 
															
														
														
													
														
															
																 | 
																 | 
																	[DestroyNotify] = destroynotify, | 
																 | 
																 | 
																	[DestroyNotify] = destroynotify, | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -423,7 +428,7 @@ buttonpress(XEvent *e) { | 
															
														
														
													
														
															
																 | 
																 | 
																	click = ClkRootWin; | 
																 | 
																 | 
																	click = ClkRootWin; | 
															
														
														
													
														
															
																 | 
																 | 
																	/* focus monitor if necessary */ | 
																 | 
																 | 
																	/* focus monitor if necessary */ | 
															
														
														
													
														
															
																 | 
																 | 
																	if((m = wintomon(ev->window)) && m != selmon) { | 
																 | 
																 | 
																	if((m = wintomon(ev->window)) && m != selmon) { | 
															
														
														
													
														
															
																 | 
																 | 
																		unfocus(selmon->sel); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		unfocus(selmon->sel, True); | 
															
														
														
													
														
															
																 | 
																 | 
																		selmon = m; | 
																 | 
																 | 
																		selmon = m; | 
															
														
														
													
														
															
																 | 
																 | 
																		focus(NULL); | 
																 | 
																 | 
																		focus(NULL); | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -792,7 +797,7 @@ enternotify(XEvent *e) { | 
															
														
														
													
														
															
																 | 
																 | 
																	if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root) | 
																 | 
																 | 
																	if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	if((m = wintomon(ev->window)) && m != selmon) { | 
																 | 
																 | 
																	if((m = wintomon(ev->window)) && m != selmon) { | 
															
														
														
													
														
															
																 | 
																 | 
																		unfocus(selmon->sel); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		unfocus(selmon->sel, True); | 
															
														
														
													
														
															
																 | 
																 | 
																		selmon = m; | 
																 | 
																 | 
																		selmon = m; | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	if((c = wintoclient(ev->window))) | 
																 | 
																 | 
																	if((c = wintoclient(ev->window))) | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -814,8 +819,9 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																focus(Client *c) { | 
																 | 
																 | 
																focus(Client *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																	if(!c || !ISVISIBLE(c)) | 
																 | 
																 | 
																	if(!c || !ISVISIBLE(c)) | 
															
														
														
													
														
															
																 | 
																 | 
																		for(c = selmon->stack; c && !ISVISIBLE(c); c = c->snext); | 
																 | 
																 | 
																		for(c = selmon->stack; c && !ISVISIBLE(c); c = c->snext); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(selmon->sel) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		unfocus(selmon->sel); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	/* was if(selmon->sel) */ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(selmon->sel && selmon->sel != c) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		unfocus(selmon->sel, False); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c) { | 
																 | 
																 | 
																	if(c) { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(c->mon != selmon) | 
																 | 
																 | 
																		if(c->mon != selmon) | 
															
														
														
													
														
															
																 | 
																 | 
																			selmon = c->mon; | 
																 | 
																 | 
																			selmon = c->mon; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -849,7 +855,7 @@ focusmon(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	if((m = dirtomon(arg->i)) == selmon) | 
																 | 
																 | 
																	if((m = dirtomon(arg->i)) == selmon) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	unfocus(selmon->sel); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	unfocus(selmon->sel, True); | 
															
														
														
													
														
															
																 | 
																 | 
																	selmon = m; | 
																 | 
																 | 
																	selmon = m; | 
															
														
														
													
														
															
																 | 
																 | 
																	focus(NULL); | 
																 | 
																 | 
																	focus(NULL); | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -901,15 +907,14 @@ getrootptr(int *x, int *y) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																long | 
																 | 
																 | 
																long | 
															
														
														
													
														
															
																 | 
																 | 
																getstate(Window w) { | 
																 | 
																 | 
																getstate(Window w) { | 
															
														
														
													
														
															
																 | 
																 | 
																	int format, status; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	int format; | 
															
														
														
													
														
															
																 | 
																 | 
																	long result = -1; | 
																 | 
																 | 
																	long result = -1; | 
															
														
														
													
														
															
																 | 
																 | 
																	unsigned char *p = NULL; | 
																 | 
																 | 
																	unsigned char *p = NULL; | 
															
														
														
													
														
															
																 | 
																 | 
																	unsigned long n, extra; | 
																 | 
																 | 
																	unsigned long n, extra; | 
															
														
														
													
														
															
																 | 
																 | 
																	Atom real; | 
																 | 
																 | 
																	Atom real; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	status = XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState], | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	                            &real, &format, &n, &extra, (unsigned char **)&p); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(status != Success) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState], | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	                      &real, &format, &n, &extra, (unsigned char **)&p) != Success) | 
															
														
														
													
														
															
																 | 
																 | 
																		return -1; | 
																 | 
																 | 
																		return -1; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(n != 0) | 
																 | 
																 | 
																	if(n != 0) | 
															
														
														
													
														
															
																 | 
																 | 
																		result = *p; | 
																 | 
																 | 
																		result = *p; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1110,12 +1115,13 @@ manage(Window w, XWindowAttributes *wa) { | 
															
														
														
													
														
															
																 | 
																 | 
																		applyrules(c); | 
																 | 
																 | 
																		applyrules(c); | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	/* geometry */ | 
																 | 
																 | 
																	/* geometry */ | 
															
														
														
													
														
															
																 | 
																 | 
																	c->x = wa->x + c->mon->wx; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	c->y = wa->y + c->mon->wy; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	c->w = wa->width; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	c->h = wa->height; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->x = c->oldx = wa->x + c->mon->wx; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->y = c->oldy = wa->y + c->mon->wy; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->w = c->oldw = wa->width; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->h = c->oldh = wa->height; | 
															
														
														
													
														
															
																 | 
																 | 
																	c->oldbw = wa->border_width; | 
																 | 
																 | 
																	c->oldbw = wa->border_width; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->w == c->mon->mw && c->h == c->mon->mh) { | 
																 | 
																 | 
																	if(c->w == c->mon->mw && c->h == c->mon->mh) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		c->isfloating = 1; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->x = c->mon->mx; | 
																 | 
																 | 
																		c->x = c->mon->mx; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->y = c->mon->my; | 
																 | 
																 | 
																		c->y = c->mon->my; | 
															
														
														
													
														
															
																 | 
																 | 
																		c->bw = 0; | 
																 | 
																 | 
																		c->bw = 0; | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1139,7 +1145,7 @@ manage(Window w, XWindowAttributes *wa) { | 
															
														
														
													
														
															
																 | 
																 | 
																	XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask); | 
																 | 
																 | 
																	XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask); | 
															
														
														
													
														
															
																 | 
																 | 
																	grabbuttons(c, False); | 
																 | 
																 | 
																	grabbuttons(c, False); | 
															
														
														
													
														
															
																 | 
																 | 
																	if(!c->isfloating) | 
																 | 
																 | 
																	if(!c->isfloating) | 
															
														
														
													
														
															
																 | 
																 | 
																		c->isfloating = trans != None || c->isfixed; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		c->isfloating = c->oldstate = trans != None || c->isfixed; | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->isfloating) | 
																 | 
																 | 
																	if(c->isfloating) | 
															
														
														
													
														
															
																 | 
																 | 
																		XRaiseWindow(dpy, c->win); | 
																 | 
																 | 
																		XRaiseWindow(dpy, c->win); | 
															
														
														
													
														
															
																 | 
																 | 
																	attach(c); | 
																 | 
																 | 
																	attach(c); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1291,6 +1297,39 @@ propertynotify(XEvent *e) { | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																clientmessage(XEvent *e) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	XClientMessageEvent *cme = &e->xclient; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	Client *c; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if((c = wintoclient(cme->window)) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	&& (cme->message_type == netatom[NetWMState] && cme->data.l[1] == netatom[NetWMFullscreen])) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	{ | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(cme->data.l[0]) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			XChangeProperty(dpy, cme->window, netatom[NetWMState], XA_ATOM, 32, | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			                PropModeReplace, (unsigned char*)&netatom[NetWMFullscreen], 1); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->oldstate = c->isfloating; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->oldbw = c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->bw = 0; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->isfloating = 1; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			resizeclient(c, c->mon->mx, c->mon->my, c->mon->mw, c->mon->mh); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			XRaiseWindow(dpy, c->win); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		else { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			XChangeProperty(dpy, cme->window, netatom[NetWMState], XA_ATOM, 32, | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			                PropModeReplace, (unsigned char*)0, 0); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->isfloating = c->oldstate; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->bw = c->oldbw; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->x = c->oldx; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->y = c->oldy; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->w = c->oldw; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			c->h = c->oldh; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			resizeclient(c, c->x, c->y, c->w, c->h); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			arrange(c->mon); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																quit(const Arg *arg) { | 
																 | 
																 | 
																quit(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																	running = False; | 
																 | 
																 | 
																	running = False; | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1298,18 +1337,22 @@ quit(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																resize(Client *c, int x, int y, int w, int h, Bool interact) { | 
																 | 
																 | 
																resize(Client *c, int x, int y, int w, int h, Bool interact) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(applysizehints(c, &x, &y, &w, &h, interact)) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		resizeclient(c, x, y, w, h); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																resizeclient(Client *c, int x, int y, int w, int h) { | 
															
														
														
													
														
															
																 | 
																 | 
																	XWindowChanges wc; | 
																 | 
																 | 
																	XWindowChanges wc; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(applysizehints(c, &x, &y, &w, &h, interact)) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		c->x = wc.x = x; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		c->y = wc.y = y; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		c->w = wc.width = w; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		c->h = wc.height = h; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		wc.border_width = c->bw; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		XConfigureWindow(dpy, c->win, CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		configure(c); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		XSync(dpy, False); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->oldx = c->x; c->x = wc.x = x; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->oldy = c->y; c->y = wc.y = y; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->oldw = c->w; c->w = wc.width = w; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	c->oldh = c->h; c->h = wc.height = h; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	wc.border_width = c->bw; | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	XConfigureWindow(dpy, c->win, CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	configure(c); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	XSync(dpy, False); | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1427,7 +1470,7 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																sendmon(Client *c, Monitor *m) { | 
																 | 
																 | 
																sendmon(Client *c, Monitor *m) { | 
															
														
														
													
														
															
																 | 
																 | 
																	if(c->mon == m) | 
																 | 
																 | 
																	if(c->mon == m) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	unfocus(c); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	unfocus(c, True); | 
															
														
														
													
														
															
																 | 
																 | 
																	detach(c); | 
																 | 
																 | 
																	detach(c); | 
															
														
														
													
														
															
																 | 
																 | 
																	detachstack(c); | 
																 | 
																 | 
																	detachstack(c); | 
															
														
														
													
														
															
																 | 
																 | 
																	c->mon = m; | 
																 | 
																 | 
																	c->mon = m; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1495,6 +1538,7 @@ setup(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																	netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False); | 
																 | 
																 | 
																	netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False); | 
															
														
														
													
														
															
																 | 
																 | 
																	netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False); | 
																 | 
																 | 
																	netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False); | 
															
														
														
													
														
															
																 | 
																 | 
																	netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False); | 
																 | 
																 | 
																	netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	netatom[NetWMFullscreen] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False); | 
															
														
														
													
														
															
																 | 
																 | 
																	/* init cursors */ | 
																 | 
																 | 
																	/* init cursors */ | 
															
														
														
													
														
															
																 | 
																 | 
																	cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr); | 
																 | 
																 | 
																	cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr); | 
															
														
														
													
														
															
																 | 
																 | 
																	cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing); | 
																 | 
																 | 
																	cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1663,12 +1707,13 @@ toggleview(const Arg *arg) { | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
														
															
																 | 
																 | 
																unfocus(Client *c) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																unfocus(Client *c, Bool setfocus) { | 
															
														
														
													
														
															
																 | 
																 | 
																	if(!c) | 
																 | 
																 | 
																	if(!c) | 
															
														
														
													
														
															
																 | 
																 | 
																		return; | 
																 | 
																 | 
																		return; | 
															
														
														
													
														
															
																 | 
																 | 
																	grabbuttons(c, False); | 
																 | 
																 | 
																	grabbuttons(c, False); | 
															
														
														
													
														
															
																 | 
																 | 
																	XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]); | 
																 | 
																 | 
																	XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]); | 
															
														
														
													
														
															
																 | 
																 | 
																	XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime); | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(setfocus) | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime); | 
															
														
														
													
														
															
																 | 
																 | 
																} | 
																 | 
																 | 
																} | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																void | 
																 | 
																 | 
																void | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																	
																 | 
																
  |