17 /* static */ |
17 /* static */ |
18 |
18 |
19 typedef struct { |
19 typedef struct { |
20 const char *prop; |
20 const char *prop; |
21 const char *tags; |
21 const char *tags; |
22 Bool isfloat; |
22 Bool swimming; |
23 } Rule; |
23 } Rule; |
24 |
24 |
25 typedef struct { |
25 typedef struct { |
26 regex_t *propregex; |
26 regex_t *propregex; |
27 regex_t *tagregex; |
27 regex_t *tagregex; |
28 } Regs; |
28 } Regs; |
29 |
29 |
30 LAYOUTS |
|
31 TAGS |
30 TAGS |
32 RULES |
31 RULES |
33 |
32 |
34 static Regs *regs = NULL; |
33 static Regs *regs = NULL; |
35 static unsigned int nrules = 0; |
34 static unsigned int nrules = 0; |
36 static unsigned int nlayouts = 0; |
35 static unsigned int nlayouts = 0; |
37 |
36 |
38 /* extern */ |
37 static void |
39 |
38 tile(void) { |
40 void |
|
41 compileregs(void) { |
|
42 unsigned int i; |
|
43 regex_t *reg; |
|
44 |
|
45 if(regs) |
|
46 return; |
|
47 nrules = sizeof rule / sizeof rule[0]; |
|
48 regs = emallocz(nrules * sizeof(Regs)); |
|
49 for(i = 0; i < nrules; i++) { |
|
50 if(rule[i].prop) { |
|
51 reg = emallocz(sizeof(regex_t)); |
|
52 if(regcomp(reg, rule[i].prop, REG_EXTENDED)) |
|
53 free(reg); |
|
54 else |
|
55 regs[i].propregex = reg; |
|
56 } |
|
57 if(rule[i].tags) { |
|
58 reg = emallocz(sizeof(regex_t)); |
|
59 if(regcomp(reg, rule[i].tags, REG_EXTENDED)) |
|
60 free(reg); |
|
61 else |
|
62 regs[i].tagregex = reg; |
|
63 } |
|
64 } |
|
65 } |
|
66 |
|
67 void |
|
68 dofloat(void) { |
|
69 Client *c; |
|
70 |
|
71 for(c = clients; c; c = c->next) { |
|
72 if(isvisible(c)) { |
|
73 if(c->isbanned) |
|
74 XMoveWindow(dpy, c->win, c->x, c->y); |
|
75 c->isbanned = False; |
|
76 resize(c, c->x, c->y, c->w, c->h, True); |
|
77 } |
|
78 else { |
|
79 c->isbanned = True; |
|
80 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y); |
|
81 } |
|
82 } |
|
83 if(!sel || !isvisible(sel)) { |
|
84 for(c = stack; c && !isvisible(c); c = c->snext); |
|
85 focus(c); |
|
86 } |
|
87 restack(); |
|
88 } |
|
89 |
|
90 void |
|
91 dotile(void) { |
|
92 unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th; |
39 unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th; |
93 Client *c; |
40 Client *c; |
94 |
41 |
95 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next)) |
42 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next)) |
96 n++; |
43 n++; |
137 focus(c); |
84 focus(c); |
138 } |
85 } |
139 restack(); |
86 restack(); |
140 } |
87 } |
141 |
88 |
|
89 LAYOUTS |
|
90 |
|
91 /* extern */ |
|
92 |
|
93 void |
|
94 compileregs(void) { |
|
95 unsigned int i; |
|
96 regex_t *reg; |
|
97 |
|
98 if(regs) |
|
99 return; |
|
100 nrules = sizeof rule / sizeof rule[0]; |
|
101 regs = emallocz(nrules * sizeof(Regs)); |
|
102 for(i = 0; i < nrules; i++) { |
|
103 if(rule[i].prop) { |
|
104 reg = emallocz(sizeof(regex_t)); |
|
105 if(regcomp(reg, rule[i].prop, REG_EXTENDED)) |
|
106 free(reg); |
|
107 else |
|
108 regs[i].propregex = reg; |
|
109 } |
|
110 if(rule[i].tags) { |
|
111 reg = emallocz(sizeof(regex_t)); |
|
112 if(regcomp(reg, rule[i].tags, REG_EXTENDED)) |
|
113 free(reg); |
|
114 else |
|
115 regs[i].tagregex = reg; |
|
116 } |
|
117 } |
|
118 } |
|
119 |
142 void |
120 void |
143 incnmaster(Arg *arg) { |
121 incnmaster(Arg *arg) { |
144 if((lt->arrange == dofloat) || (nmaster + arg->i < 1) |
122 if((lt->arrange != tile) || (nmaster + arg->i < 1) |
145 || (wah / (nmaster + arg->i) <= 2 * BORDERPX)) |
123 || (wah / (nmaster + arg->i) <= 2 * BORDERPX)) |
146 return; |
124 return; |
147 nmaster += arg->i; |
125 nmaster += arg->i; |
148 if(sel) |
126 if(sel) |
149 lt->arrange(); |
127 lt->arrange(); |
195 XEvent ev; |
173 XEvent ev; |
196 |
174 |
197 drawstatus(); |
175 drawstatus(); |
198 if(!sel) |
176 if(!sel) |
199 return; |
177 return; |
200 if(sel->isfloat || lt->arrange == dofloat) |
178 if(sel->swimming || lt->arrange == swim) |
201 XRaiseWindow(dpy, sel->win); |
179 XRaiseWindow(dpy, sel->win); |
202 if(lt->arrange != dofloat) { |
180 if(lt->arrange != swim) { |
203 if(!sel->isfloat) |
181 if(!sel->swimming) |
204 XLowerWindow(dpy, sel->win); |
182 XLowerWindow(dpy, sel->win); |
205 for(c = nexttiled(clients); c; c = nexttiled(c->next)) { |
183 for(c = nexttiled(clients); c; c = nexttiled(c->next)) { |
206 if(c == sel) |
184 if(c == sel) |
207 continue; |
185 continue; |
208 XLowerWindow(dpy, c->win); |
186 XLowerWindow(dpy, c->win); |
228 snprintf(prop, sizeof prop, "%s:%s:%s", |
206 snprintf(prop, sizeof prop, "%s:%s:%s", |
229 ch.res_class ? ch.res_class : "", |
207 ch.res_class ? ch.res_class : "", |
230 ch.res_name ? ch.res_name : "", c->name); |
208 ch.res_name ? ch.res_name : "", c->name); |
231 for(i = 0; i < nrules; i++) |
209 for(i = 0; i < nrules; i++) |
232 if(regs[i].propregex && !regexec(regs[i].propregex, prop, 1, &tmp, 0)) { |
210 if(regs[i].propregex && !regexec(regs[i].propregex, prop, 1, &tmp, 0)) { |
233 c->isfloat = rule[i].isfloat; |
211 c->swimming = rule[i].swimming; |
234 for(j = 0; regs[i].tagregex && j < ntags; j++) { |
212 for(j = 0; regs[i].tagregex && j < ntags; j++) { |
235 if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) { |
213 if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) { |
236 matched = True; |
214 matched = True; |
237 c->tags[j] = True; |
215 c->tags[j] = True; |
238 } |
216 } |
247 for(i = 0; i < ntags; i++) |
225 for(i = 0; i < ntags; i++) |
248 c->tags[i] = seltag[i]; |
226 c->tags[i] = seltag[i]; |
249 } |
227 } |
250 |
228 |
251 void |
229 void |
|
230 swim(void) { |
|
231 Client *c; |
|
232 |
|
233 for(c = clients; c; c = c->next) { |
|
234 if(isvisible(c)) { |
|
235 if(c->isbanned) |
|
236 XMoveWindow(dpy, c->win, c->x, c->y); |
|
237 c->isbanned = False; |
|
238 resize(c, c->x, c->y, c->w, c->h, True); |
|
239 } |
|
240 else { |
|
241 c->isbanned = True; |
|
242 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y); |
|
243 } |
|
244 } |
|
245 if(!sel || !isvisible(sel)) { |
|
246 for(c = stack; c && !isvisible(c); c = c->snext); |
|
247 focus(c); |
|
248 } |
|
249 restack(); |
|
250 } |
|
251 |
|
252 void |
252 tag(Arg *arg) { |
253 tag(Arg *arg) { |
253 unsigned int i; |
254 unsigned int i; |
254 |
255 |
255 if(!sel) |
256 if(!sel) |
256 return; |
257 return; |