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 void (*arrange)(void) = DEFMODE;
  13 unsigned int master = MASTER;
  14 unsigned int nmaster = NMASTER;
  15
  16 /* static */
  17
  18 typedef struct {
  19         const char *prop;
  20         const char *tags;
  21         Bool isfloat;
  22 } Rule;
  23
  24 typedef struct {
  25         regex_t *propregex;
  26         regex_t *tagregex;
  27 } Regexps;
  28
  29 TAGS
  30 RULES
  31
  32 static Regexps *regexps = NULL;
  33 static unsigned int len = 0;
  34
  35 /* extern */
  36
  37 void
  38 compileregexps(void) {
  39         unsigned int i;
  40         regex_t *reg;
  41
  42         if(regexps)
  43                 return;
  44         len = sizeof rule / sizeof rule[0];
  45         regexps = emallocz(len * sizeof(Regexps));
  46         for(i = 0; i < len; i++) {
  47                 if(rule[i].prop) {
  48                         reg = emallocz(sizeof(regex_t));
  49                         if(regcomp(reg, rule[i].prop, REG_EXTENDED))
  50                                 free(reg);
  51                         else
  52                                 regexps[i].propregex = reg;
  53                 }
  54                 if(rule[i].tags) {
  55                         reg = emallocz(sizeof(regex_t));
  56                         if(regcomp(reg, rule[i].tags, REG_EXTENDED))
  57                                 free(reg);
  58                         else
  59                                 regexps[i].tagregex = reg;
  60                 }
  61         }
  62 }
  63
  64 void
  65 dofloat(void) {
  66         Client *c;
  67
  68         for(c = clients; c; c = c->next) {
  69                 if(isvisible(c)) {
  70                         if(c->isbanned)
  71                                 XMoveWindow(dpy, c->win, c->x, c->y);
  72                         c->isbanned = False;
  73                         resize(c, c->x, c->y, c->w, c->h, True);
  74                 }
  75                 else {
  76                         c->isbanned = True;
  77                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
  78                 }
  79         }
  80         if(!sel || !isvisible(sel)) {
  81                 for(c = stack; c && !isvisible(c); c = c->snext);
  82                 focus(c);
  83         }
  84         restack();
  85 }
  86 void
  87 dotile(void) {
  88         unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;
  89         Client *c;
  90
  91         for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
  92                 n++;
  93         /* window geoms */
  94         mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
  95         mw = (n > nmaster) ? (waw * master) / 1000 : waw;
  96         th = (n > nmaster) ? wah / (n - nmaster) : 0;
  97         tw = waw - mw;
  98
  99         for(i = 0, c = clients; c; c = c->next)
 100                 if(isvisible(c)) {
 101                         if(c->isbanned)
 102                                 XMoveWindow(dpy, c->win, c->x, c->y);
 103                         c->isbanned = False;
 104                         if(c->isfloat)
 105                                 continue;
 106                         c->ismax = False;
 107                         nx = wax;
 108                         ny = way;
 109                         if(i < nmaster) {
 110                                 ny += i * mh;
 111                                 nw = mw - 2 * BORDERPX;
 112                                 nh = mh - 2 * BORDERPX;
 113                         }
 114                         else {  /* tile window */
 115                                 nx += mw;
 116                                 nw = tw - 2 * BORDERPX;
 117                                 if(th > 2 * BORDERPX) {
 118                                         ny += (i - nmaster) * th;
 119                                         nh = th - 2 * BORDERPX;
 120                                 }
 121                                 else /* fallback if th <= 2 * BORDERPX */
 122                                         nh = wah - 2 * BORDERPX;
 123                         }
 124                         resize(c, nx, ny, nw, nh, False);
 125                         i++;
 126                 }
 127                 else {
 128                         c->isbanned = True;
 129                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
 130                 }
 131         if(!sel || !isvisible(sel)) {
 132                 for(c = stack; c && !isvisible(c); c = c->snext);
 133                 focus(c);
 134         }
 135         restack();
 136 }
 137
 138 void
 139 incnmaster(Arg *arg) {
 140         if((arrange == dofloat) || (nmaster + arg->i < 1)
 141         || (wah / (nmaster + arg->i) <= 2 * BORDERPX))
 142                 return;
 143         nmaster += arg->i;
 144         if(sel)
 145                 arrange();
 146         else
 147                 drawstatus();
 148 }
 149
 150 Bool
 151 isvisible(Client *c) {
 152         unsigned int i;
 153
 154         for(i = 0; i < ntags; i++)
 155                 if(c->tags[i] && seltag[i])
 156                         return True;
 157         return False;
 158 }
 159
 160 void
 161 resizemaster(Arg *arg) {
 162         if(arrange != dotile)
 163                 return;
 164         if(arg->i == 0)
 165                 master = MASTER;
 166         else {
 167                 if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX
 168                 || waw * (master + arg->i) / 1000 <= 2 * BORDERPX)
 169                         return;
 170                 master += arg->i;
 171         }
 172         arrange();
 173 }
 174
 175 void
 176 restack(void) {
 177         Client *c;
 178         XEvent ev;
 179
 180         drawstatus();
 181         if(!sel)
 182                 return;
 183         if(sel->isfloat || arrange == dofloat)
 184                 XRaiseWindow(dpy, sel->win);
 185         if(arrange != dofloat) {
 186                 if(!sel->isfloat)
 187                         XLowerWindow(dpy, sel->win);
 188                 for(c = nexttiled(clients); c; c = nexttiled(c->next)) {
 189                         if(c == sel)
 190                                 continue;
 191                         XLowerWindow(dpy, c->win);
 192                 }
 193         }
 194         XSync(dpy, False);
 195         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 196 }
 197
 198 void
 199 settags(Client *c, Client *trans) {
 200         char prop[512];
 201         unsigned int i, j;
 202         regmatch_t tmp;
 203         Bool matched = trans != NULL;
 204         XClassHint ch = { 0 };
 205
 206         if(matched)
 207                 for(i = 0; i < ntags; i++)
 208                         c->tags[i] = trans->tags[i];
 209         else {
 210                 XGetClassHint(dpy, c->win, &ch);
 211                 snprintf(prop, sizeof prop, "%s:%s:%s",
 212                                 ch.res_class ? ch.res_class : "",
 213                                 ch.res_name ? ch.res_name : "", c->name);
 214                 for(i = 0; i < len; i++)
 215                         if(regexps[i].propregex && !regexec(regexps[i].propregex, prop, 1, &tmp, 0)) {
 216                                 c->isfloat = rule[i].isfloat;
 217                                 for(j = 0; regexps[i].tagregex && j < ntags; j++) {
 218                                         if(!regexec(regexps[i].tagregex, tags[j], 1, &tmp, 0)) {
 219                                                 matched = True;
 220                                                 c->tags[j] = True;
 221                                         }
 222                                 }
 223                         }
 224                 if(ch.res_class)
 225                         XFree(ch.res_class);
 226                 if(ch.res_name)
 227                         XFree(ch.res_name);
 228         }
 229         if(!matched)
 230                 for(i = 0; i < ntags; i++)
 231                         c->tags[i] = seltag[i];
 232 }
 233
 234 void
 235 tag(Arg *arg) {
 236         unsigned int i;
 237
 238         if(!sel)
 239                 return;
 240         for(i = 0; i < ntags; i++)
 241                 sel->tags[i] = (arg->i == -1) ? True : False;
 242         if(arg->i >= 0 && arg->i < ntags)
 243                 sel->tags[arg->i] = True;
 244         arrange();
 245 }
 246
 247 void
 248 togglefloat(Arg *arg) {
 249         if(!sel || arrange == dofloat)
 250                 return;
 251         sel->isfloat = !sel->isfloat;
 252         arrange();
 253 }
 254
 255 void
 256 toggletag(Arg *arg) {
 257         unsigned int i;
 258
 259         if(!sel)
 260                 return;
 261         sel->tags[arg->i] = !sel->tags[arg->i];
 262         for(i = 0; i < ntags && !sel->tags[i]; i++);
 263         if(i == ntags)
 264                 sel->tags[arg->i] = True;
 265         arrange();
 266 }
 267
 268 void
 269 togglemode(Arg *arg) {
 270         arrange = (arrange == dofloat) ? dotile : dofloat;
 271         if(sel)
 272                 arrange();
 273         else
 274                 drawstatus();
 275 }
 276
 277 void
 278 toggleview(Arg *arg) {
 279         unsigned int i;
 280
 281         seltag[arg->i] = !seltag[arg->i];
 282         for(i = 0; i < ntags && !seltag[i]; i++);
 283         if(i == ntags)
 284                 seltag[arg->i] = True; /* cannot toggle last view */
 285         arrange();
 286 }
 287
 288 void
 289 view(Arg *arg) {
 290         unsigned int i;
 291
 292         for(i = 0; i < ntags; i++)
 293                 seltag[i] = (arg->i == -1) ? True : False;
 294         if(arg->i >= 0 && arg->i < ntags)
 295                 seltag[arg->i] = True;
 296         arrange();
 297 }