screen.c

   1 /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com>
   2  * See LICENSE file for license details.
   3  */
   4 #include "dwm.h"
   5 #include <regex.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #include <X11/Xutil.h>
  11
  12 unsigned int master = MASTER;
  13 unsigned int nmaster = NMASTER;
  14 unsigned int blw = 0;
  15 Layout *lt = NULL;
  16
  17 /* static */
  18
  19 typedef struct {
  20         const char *prop;
  21         const char *tags;
  22         Bool isversatile;
  23 } Rule;
  24
  25 typedef struct {
  26         regex_t *propregex;
  27         regex_t *tagregex;
  28 } Regs;
  29
  30 TAGS
  31 RULES
  32
  33 static Regs *regs = NULL;
  34 static unsigned int nrules = 0;
  35 static unsigned int nlayouts = 0;
  36
  37 static void
  38 tile(void) {
  39         unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;
  40         Client *c;
  41
  42         for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
  43                 n++;
  44         /* window geoms */
  45         mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
  46         mw = (n > nmaster) ? (waw * master) / 1000 : waw;
  47         th = (n > nmaster) ? wah / (n - nmaster) : 0;
  48         tw = waw - mw;
  49
  50         for(i = 0, c = clients; c; c = c->next)
  51                 if(isvisible(c)) {
  52                         if(c->isbanned)
  53                                 XMoveWindow(dpy, c->win, c->x, c->y);
  54                         c->isbanned = False;
  55                         if(c->isversatile)
  56                                 continue;
  57                         c->ismax = False;
  58                         nx = wax;
  59                         ny = way;
  60                         if(i < nmaster) {
  61                                 ny += i * mh;
  62                                 nw = mw - 2 * BORDERPX;
  63                                 nh = mh - 2 * BORDERPX;
  64                         }
  65                         else {  /* tile window */
  66                                 nx += mw;
  67                                 nw = tw - 2 * BORDERPX;
  68                                 if(th > 2 * BORDERPX) {
  69                                         ny += (i - nmaster) * th;
  70                                         nh = th - 2 * BORDERPX;
  71                                 }
  72                                 else /* fallback if th <= 2 * BORDERPX */
  73                                         nh = wah - 2 * BORDERPX;
  74                         }
  75                         resize(c, nx, ny, nw, nh, False);
  76                         i++;
  77                 }
  78                 else {
  79                         c->isbanned = True;
  80                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
  81                 }
  82         if(!sel || !isvisible(sel)) {
  83                 for(c = stack; c && !isvisible(c); c = c->snext);
  84                 focus(c);
  85         }
  86         restack();
  87 }
  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
 120 void
 121 incnmaster(Arg *arg) {
 122         if((lt->arrange != tile) || (nmaster + arg->i < 1)
 123         || (wah / (nmaster + arg->i) <= 2 * BORDERPX))
 124                 return;
 125         nmaster += arg->i;
 126         if(sel)
 127                 lt->arrange();
 128         else
 129                 drawstatus();
 130 }
 131
 132 void
 133 initlayouts(void) {
 134         unsigned int i, w;
 135
 136         lt = &layout[0];
 137         nlayouts = sizeof layout / sizeof layout[0];
 138         for(blw = i = 0; i < nlayouts; i++) {
 139                 w = textw(layout[i].symbol);
 140                 if(w > blw)
 141                         blw = w;
 142         }
 143 }
 144
 145 Bool
 146 isvisible(Client *c) {
 147         unsigned int i;
 148
 149         for(i = 0; i < ntags; i++)
 150                 if(c->tags[i] && seltag[i])
 151                         return True;
 152         return False;
 153 }
 154
 155 void
 156 resizemaster(Arg *arg) {
 157         if(lt->arrange != tile)
 158                 return;
 159         if(arg->i == 0)
 160                 master = MASTER;
 161         else {
 162                 if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX
 163                 || waw * (master + arg->i) / 1000 <= 2 * BORDERPX)
 164                         return;
 165                 master += arg->i;
 166         }
 167         lt->arrange();
 168 }
 169
 170 void
 171 restack(void) {
 172         Client *c;
 173         XEvent ev;
 174
 175         drawstatus();
 176         if(!sel)
 177                 return;
 178         if(sel->isversatile || lt->arrange == versatile)
 179                 XRaiseWindow(dpy, sel->win);
 180         if(lt->arrange != versatile) {
 181                 if(!sel->isversatile)
 182                         XLowerWindow(dpy, sel->win);
 183                 for(c = nexttiled(clients); c; c = nexttiled(c->next)) {
 184                         if(c == sel)
 185                                 continue;
 186                         XLowerWindow(dpy, c->win);
 187                 }
 188         }
 189         XSync(dpy, False);
 190         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 191 }
 192
 193 void
 194 setlayout(Arg *arg) {
 195         unsigned int i;
 196
 197         if(arg->i == -1) {
 198                 for(i = 0; i < nlayouts && lt != &layout[i]; i++);
 199                 if(i == nlayouts - 1)
 200                         lt = &layout[0];
 201                 else
 202                         lt = &layout[++i];
 203         }
 204         else {
 205                 if(arg->i < 0 || arg->i >= nlayouts)
 206                         return;
 207                 lt = &layout[arg->i];
 208         }
 209         if(sel)
 210                 lt->arrange();
 211         else
 212                 drawstatus();
 213 }
 214
 215 void
 216 settags(Client *c, Client *trans) {
 217         char prop[512];
 218         unsigned int i, j;
 219         regmatch_t tmp;
 220         Bool matched = trans != NULL;
 221         XClassHint ch = { 0 };
 222
 223         if(matched)
 224                 for(i = 0; i < ntags; i++)
 225                         c->tags[i] = trans->tags[i];
 226         else {
 227                 XGetClassHint(dpy, c->win, &ch);
 228                 snprintf(prop, sizeof prop, "%s:%s:%s",
 229                                 ch.res_class ? ch.res_class : "",
 230                                 ch.res_name ? ch.res_name : "", c->name);
 231                 for(i = 0; i < nrules; i++)
 232                         if(regs[i].propregex && !regexec(regs[i].propregex, prop, 1, &tmp, 0)) {
 233                                 c->isversatile = rule[i].isversatile;
 234                                 for(j = 0; regs[i].tagregex && j < ntags; j++) {
 235                                         if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) {
 236                                                 matched = True;
 237                                                 c->tags[j] = True;
 238                                         }
 239                                 }
 240                         }
 241                 if(ch.res_class)
 242                         XFree(ch.res_class);
 243                 if(ch.res_name)
 244                         XFree(ch.res_name);
 245         }
 246         if(!matched)
 247                 for(i = 0; i < ntags; i++)
 248                         c->tags[i] = seltag[i];
 249 }
 250
 251 void
 252 tag(Arg *arg) {
 253         unsigned int i;
 254
 255         if(!sel)
 256                 return;
 257         for(i = 0; i < ntags; i++)
 258                 sel->tags[i] = (arg->i == -1) ? True : False;
 259         if(arg->i >= 0 && arg->i < ntags)
 260                 sel->tags[arg->i] = True;
 261         lt->arrange();
 262 }
 263
 264 void
 265 toggletag(Arg *arg) {
 266         unsigned int i;
 267
 268         if(!sel)
 269                 return;
 270         sel->tags[arg->i] = !sel->tags[arg->i];
 271         for(i = 0; i < ntags && !sel->tags[i]; i++);
 272         if(i == ntags)
 273                 sel->tags[arg->i] = True;
 274         lt->arrange();
 275 }
 276
 277 void
 278 toggleversatile(Arg *arg) {
 279         if(!sel || lt->arrange == versatile)
 280                 return;
 281         sel->isversatile = !sel->isversatile;
 282         lt->arrange();
 283 }
 284
 285 void
 286 toggleview(Arg *arg) {
 287         unsigned int i;
 288
 289         seltag[arg->i] = !seltag[arg->i];
 290         for(i = 0; i < ntags && !seltag[i]; i++);
 291         if(i == ntags)
 292                 seltag[arg->i] = True; /* cannot toggle last view */
 293         lt->arrange();
 294 }
 295
 296 void
 297 versatile(void) {
 298         Client *c;
 299
 300         for(c = clients; c; c = c->next) {
 301                 if(isvisible(c)) {
 302                         if(c->isbanned)
 303                                 XMoveWindow(dpy, c->win, c->x, c->y);
 304                         c->isbanned = False;
 305                         resize(c, c->x, c->y, c->w, c->h, True);
 306                 }
 307                 else {
 308                         c->isbanned = True;
 309                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
 310                 }
 311         }
 312         if(!sel || !isvisible(sel)) {
 313                 for(c = stack; c && !isvisible(c); c = c->snext);
 314                 focus(c);
 315         }
 316         restack();
 317 }
 318
 319 void
 320 view(Arg *arg) {
 321         unsigned int i;
 322
 323         for(i = 0; i < ntags; i++)
 324                 seltag[i] = (arg->i == -1) ? True : False;
 325         if(arg->i >= 0 && arg->i < ntags)
 326                 seltag[arg->i] = True;
 327         lt->arrange();
 328 }