1 /* See LICENSE file for copyright and license details. */

     2 #include "dwm.h"

     3 #include <regex.h>

     4 #include <stdio.h>

     5 #include <stdlib.h>

     6 #include <string.h>

     7 #include <X11/Xutil.h>

     8 

     9 /* static */

    10 

    11 typedef struct {

    12 	const char *symbol;

    13 	void (*arrange)(void);

    14 } Layout;

    15 

    16 typedef struct {

    17 	const char *prop;

    18 	const char *tags;

    19 	Bool isfloating;

    20 } Rule;

    21 

    22 typedef struct {

    23 	regex_t *propregex;

    24 	regex_t *tagregex;

    25 } Regs;

    26 

    27 TAGS

    28 RULES

    29 

    30 static unsigned int nrules = 0;

    31 static unsigned int nlayouts = 0;

    32 static unsigned int ltidx = 0; /* default */

    33 static Regs *regs = NULL;

    34 

    35 static unsigned int

    36 idxoftag(const char *tag) {

    37 	unsigned int i;

    38 

    39 	for(i = 0; i < ntags; i++)

    40 		if(tags[i] == tag)

    41 			return i;

    42 	return 0;

    43 }

    44 

    45 static void

    46 floating(void) { /* default floating layout */

    47 	Client *c;

    48 

    49 	for(c = clients; c; c = c->next)

    50 		if(isvisible(c))

    51 			resize(c, c->x, c->y, c->w, c->h, True);

    52 }

    53 

    54 LAYOUTS

    55 

    56 /* extern */

    57 

    58 unsigned int blw = 0;

    59 

    60 void

    61 applyrules(Client *c) {

    62 	static char buf[512];

    63 	unsigned int i, j;

    64 	regmatch_t tmp;

    65 	Bool matched = False;

    66 	XClassHint ch = { 0 };

    67 

    68 	/* rule matching */

    69 	XGetClassHint(dpy, c->win, &ch);

    70 	snprintf(buf, sizeof buf, "%s:%s:%s",

    71 			ch.res_class ? ch.res_class : "",

    72 			ch.res_name ? ch.res_name : "", c->name);

    73 	for(i = 0; i < nrules; i++)

    74 		if(regs[i].propregex && !regexec(regs[i].propregex, buf, 1, &tmp, 0)) {

    75 			c->isfloating = rules[i].isfloating;

    76 			for(j = 0; regs[i].tagregex && j < ntags; j++) {

    77 				if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) {

    78 					matched = True;

    79 					c->tags[j] = True;

    80 				}

    81 			}

    82 		}

    83 	if(ch.res_class)

    84 		XFree(ch.res_class);

    85 	if(ch.res_name)

    86 		XFree(ch.res_name);

    87 	if(!matched)

    88 		for(i = 0; i < ntags; i++)

    89 			c->tags[i] = seltags[i];

    90 }

    91 

    92 void

    93 arrange(void) {

    94 	Client *c;

    95 

    96 	for(c = clients; c; c = c->next)

    97 		if(isvisible(c))

    98 			unban(c);

    99 		else

   100 			ban(c);

   101 	layouts[ltidx].arrange();

   102 	focus(NULL);

   103 	restack();

   104 }

   105 

   106 void

   107 compileregs(void) {

   108 	unsigned int i;

   109 	regex_t *reg;

   110 

   111 	if(regs)

   112 		return;

   113 	nrules = sizeof rules / sizeof rules[0];

   114 	regs = emallocz(nrules * sizeof(Regs));

   115 	for(i = 0; i < nrules; i++) {

   116 		if(rules[i].prop) {

   117 			reg = emallocz(sizeof(regex_t));

   118 			if(regcomp(reg, rules[i].prop, REG_EXTENDED))

   119 				free(reg);

   120 			else

   121 				regs[i].propregex = reg;

   122 		}

   123 		if(rules[i].tags) {

   124 			reg = emallocz(sizeof(regex_t));

   125 			if(regcomp(reg, rules[i].tags, REG_EXTENDED))

   126 				free(reg);

   127 			else

   128 				regs[i].tagregex = reg;

   129 		}

   130 	}

   131 }

   132 

   133 void

   134 focusnext(const char *arg) {

   135 	Client *c;

   136 

   137 	if(!sel)

   138 		return;

   139 	for(c = sel->next; c && !isvisible(c); c = c->next);

   140 	if(!c)

   141 		for(c = clients; c && !isvisible(c); c = c->next);

   142 	if(c) {

   143 		focus(c);

   144 		restack();

   145 	}

   146 }

   147 

   148 void

   149 focusprev(const char *arg) {

   150 	Client *c;

   151 

   152 	if(!sel)

   153 		return;

   154 	for(c = sel->prev; c && !isvisible(c); c = c->prev);

   155 	if(!c) {

   156 		for(c = clients; c && c->next; c = c->next);

   157 		for(; c && !isvisible(c); c = c->prev);

   158 	}

   159 	if(c) {

   160 		focus(c);

   161 		restack();

   162 	}

   163 }

   164 

   165 const char *

   166 getsymbol(void)

   167 {

   168 	return layouts[ltidx].symbol;

   169 }

   170 

   171 void

   172 initlayouts(void) {

   173 	unsigned int i, w;

   174 

   175 	nlayouts = sizeof layouts / sizeof layouts[0];

   176 	for(blw = i = 0; i < nlayouts; i++) {

   177 		w = textw(layouts[i].symbol);

   178 		if(w > blw)

   179 			blw = w;

   180 	}

   181 }

   182 

   183 Bool

   184 isfloating(void) {

   185 	return layouts[ltidx].arrange == floating;

   186 }

   187 

   188 Bool

   189 isarrange(void (*func)())

   190 {

   191 	return func == layouts[ltidx].arrange;

   192 }

   193 

   194 Bool

   195 isvisible(Client *c) {

   196 	unsigned int i;

   197 

   198 	for(i = 0; i < ntags; i++)

   199 		if(c->tags[i] && seltags[i])

   200 			return True;

   201 	return False;

   202 }

   203 

   204 Client *

   205 nexttiled(Client *c) {

   206 	for(; c && (c->isfloating || !isvisible(c)); c = c->next);

   207 	return c;

   208 }

   209 

   210 void

   211 restack(void) {

   212 	Client *c;

   213 	XEvent ev;

   214 	XWindowChanges wc;

   215 

   216 	drawbar();

   217 	if(!sel)

   218 		return;

   219 	if(sel->isfloating || isfloating())

   220 		XRaiseWindow(dpy, sel->win);

   221 	if(!isfloating()) {

   222 		wc.stack_mode = Below;

   223 		wc.sibling = barwin;

   224 		if(!sel->isfloating) {

   225 			XConfigureWindow(dpy, sel->win, CWSibling | CWStackMode, &wc);

   226 			wc.sibling = sel->win;

   227 		}

   228 		for(c = nexttiled(clients); c; c = nexttiled(c->next)) {

   229 			if(c == sel)

   230 				continue;

   231 			XConfigureWindow(dpy, c->win, CWSibling | CWStackMode, &wc);

   232 			wc.sibling = c->win;

   233 		}

   234 	}

   235 	XSync(dpy, False);

   236 	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));

   237 }

   238 

   239 void

   240 setlayout(const char *arg) {

   241 	unsigned int i;

   242 

   243 	if(!arg) {

   244 		if(++ltidx == nlayouts)

   245 			ltidx = 0;;

   246 	}

   247 	else {

   248 		for(i = 0; i < nlayouts; i++)

   249 			if(!strcmp(arg, layouts[i].symbol))

   250 				break;

   251 		if(i == nlayouts)

   252 			return;

   253 		ltidx = i;

   254 	}

   255 	if(sel)

   256 		arrange();

   257 	else

   258 		drawbar();

   259 }

   260 

   261 void

   262 tag(const char *arg) {

   263 	unsigned int i;

   264 

   265 	if(!sel)

   266 		return;

   267 	for(i = 0; i < ntags; i++)

   268 		sel->tags[i] = arg == NULL;

   269 	i = idxoftag(arg);

   270 	if(i >= 0 && i < ntags)

   271 		sel->tags[i] = True;

   272 	arrange();

   273 }

   274 

   275 void

   276 togglefloating(const char *arg) {

   277 	if(!sel)

   278 		return;

   279 	sel->isfloating = !sel->isfloating;

   280 	if(sel->isfloating)

   281 		resize(sel, sel->x, sel->y, sel->w, sel->h, True);

   282 	arrange();

   283 }

   284 

   285 void

   286 togglemax(const char *arg) {

   287 	XEvent ev;

   288 

   289 	if(!sel || (!isfloating() && !sel->isfloating) || sel->isfixed)

   290 		return;

   291 	if((sel->ismax = !sel->ismax)) {

   292 		sel->rx = sel->x;

   293 		sel->ry = sel->y;

   294 		sel->rw = sel->w;

   295 		sel->rh = sel->h;

   296 		resize(sel, wax, way, waw - 2 * sel->border, wah - 2 * sel->border, True);

   297 	}

   298 	else

   299 		resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, True);

   300 	drawbar();

   301 	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));

   302 }

   303 

   304 void

   305 toggletag(const char *arg) {

   306 	unsigned int i, j;

   307 

   308 	if(!sel)

   309 		return;

   310 	i = idxoftag(arg);

   311 	sel->tags[i] = !sel->tags[i];

   312 	for(j = 0; j < ntags && !sel->tags[j]; j++);

   313 	if(j == ntags)

   314 		sel->tags[i] = True;

   315 	arrange();

   316 }

   317 

   318 void

   319 toggleview(const char *arg) {

   320 	unsigned int i, j;

   321 

   322 	i = idxoftag(arg);

   323 	seltags[i] = !seltags[i];

   324 	for(j = 0; j < ntags && !seltags[j]; j++);

   325 	if(j == ntags)

   326 		seltags[i] = True; /* cannot toggle last view */

   327 	arrange();

   328 }

   329 

   330 void

   331 view(const char *arg) {

   332 	unsigned int i;

   333 

   334 	for(i = 0; i < ntags; i++)

   335 		seltags[i] = arg == NULL;

   336 	i = idxoftag(arg);

   337 	if(i >= 0 && i < ntags)

   338 		seltags[i] = True;

   339 	arrange();

   340 }