manage.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 *clpattern;
  20         const char *tpattern;
  21         Bool isfloat;
  22 } Rule;
  23
  24 typedef struct {
  25         regex_t *clregex;
  26         regex_t *tregex;
  27 } RReg;
  28
  29 TAGS
  30 RULES
  31
  32 static RReg *rreg = NULL;
  33 static unsigned int len = 0;
  34
  35 static Client *
  36 nextmanaged(Client *c) {
  37         for(; c && (c->isfloat || !isvisible(c)); c = c->next);
  38         return c;
  39 }
  40
  41 static void
  42 togglemax(Client *c) {
  43         XEvent ev;
  44
  45         if(c->isfixed)
  46                 return;
  47         if((c->ismax = !c->ismax)) {
  48                 c->rx = c->x;
  49                 c->ry = c->y;
  50                 c->rw = c->w;
  51                 c->rh = c->h;
  52                 resize(c, wax, way, waw - 2 * BORDERPX, wah - 2 * BORDERPX, True);
  53         }
  54         else
  55                 resize(c, c->rx, c->ry, c->rw, c->rh, True);
  56         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
  57 }
  58
  59 /* extern */
  60
  61 void
  62 attach(Client *c) {
  63         if(clients)
  64                 clients->prev = c;
  65         c->next = clients;
  66         clients = c;
  67 }
  68
  69 void
  70 attachstack(Client *c) {
  71         c->snext = stack;
  72         stack = c;
  73 }
  74
  75 void
  76 compileregexps(void) {
  77         unsigned int i;
  78         regex_t *reg;
  79
  80         if(rreg)
  81                 return;
  82         len = sizeof rule / sizeof rule[0];
  83         rreg = emallocz(len * sizeof(RReg));
  84         for(i = 0; i < len; i++) {
  85                 if(rule[i].clpattern) {
  86                         reg = emallocz(sizeof(regex_t));
  87                         if(regcomp(reg, rule[i].clpattern, REG_EXTENDED))
  88                                 free(reg);
  89                         else
  90                                 rreg[i].clregex = reg;
  91                 }
  92                 if(rule[i].tpattern) {
  93                         reg = emallocz(sizeof(regex_t));
  94                         if(regcomp(reg, rule[i].tpattern, REG_EXTENDED))
  95                                 free(reg);
  96                         else
  97                                 rreg[i].tregex = reg;
  98                 }
  99         }
 100 }
 101
 102 void
 103 detach(Client *c) {
 104         if(c->prev)
 105                 c->prev->next = c->next;
 106         if(c->next)
 107                 c->next->prev = c->prev;
 108         if(c == clients)
 109                 clients = c->next;
 110         c->next = c->prev = NULL;
 111 }
 112
 113 void
 114 detachstack(Client *c) {
 115         Client **tc;
 116         for(tc=&stack; *tc && *tc != c; tc=&(*tc)->snext);
 117         *tc = c->snext;
 118 }
 119
 120 void
 121 dofloat(void) {
 122         Client *c;
 123
 124         for(c = clients; c; c = c->next) {
 125                 if(isvisible(c)) {
 126                         if(c->isbanned)
 127                                 XMoveWindow(dpy, c->win, c->x, c->y);
 128                         c->isbanned = False;
 129                         resize(c, c->x, c->y, c->w, c->h, True);
 130                 }
 131                 else {
 132                         c->isbanned = True;
 133                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
 134                 }
 135         }
 136         if(!sel || !isvisible(sel)) {
 137                 for(c = stack; c && !isvisible(c); c = c->snext);
 138                 focus(c);
 139         }
 140         restack();
 141 }
 142 void
 143 dotile(void) {
 144         unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;
 145         Client *c;
 146
 147         for(n = 0, c = nextmanaged(clients); c; c = nextmanaged(c->next))
 148                 n++;
 149         /* window geoms */
 150         mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
 151         mw = (n > nmaster) ? (waw * master) / 1000 : waw;
 152         th = (n > nmaster) ? wah / (n - nmaster) : 0;
 153         tw = waw - mw;
 154
 155         for(i = 0, c = clients; c; c = c->next)
 156                 if(isvisible(c)) {
 157                         if(c->isbanned)
 158                                 XMoveWindow(dpy, c->win, c->x, c->y);
 159                         c->isbanned = False;
 160                         if(c->isfloat)
 161                                 continue;
 162                         c->ismax = False;
 163                         nx = wax;
 164                         ny = way;
 165                         if(i < nmaster) {
 166                                 ny += i * mh;
 167                                 nw = mw - 2 * BORDERPX;
 168                                 nh = mh - 2 * BORDERPX;
 169                         }
 170                         else {  /* tile window */
 171                                 nx += mw;
 172                                 nw = tw - 2 * BORDERPX;
 173                                 if(th > 2 * BORDERPX) {
 174                                         ny += (i - nmaster) * th;
 175                                         nh = th - 2 * BORDERPX;
 176                                 }
 177                                 else /* fallback if th <= 2 * BORDERPX */
 178                                         nh = wah - 2 * BORDERPX;
 179                         }
 180                         resize(c, nx, ny, nw, nh, False);
 181                         i++;
 182                 }
 183                 else {
 184                         c->isbanned = True;
 185                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
 186                 }
 187         if(!sel || !isvisible(sel)) {
 188                 for(c = stack; c && !isvisible(c); c = c->snext);
 189                 focus(c);
 190         }
 191         restack();
 192 }
 193
 194 void
 195 focusnext(Arg *arg) {
 196         Client *c;
 197
 198         if(!sel)
 199                 return;
 200         for(c = sel->next; c && !isvisible(c); c = c->next);
 201         if(!c)
 202                 for(c = clients; c && !isvisible(c); c = c->next);
 203         if(c) {
 204                 focus(c);
 205                 restack();
 206         }
 207 }
 208
 209 void
 210 focusprev(Arg *arg) {
 211         Client *c;
 212
 213         if(!sel)
 214                 return;
 215         for(c = sel->prev; c && !isvisible(c); c = c->prev);
 216         if(!c) {
 217                 for(c = clients; c && c->next; c = c->next);
 218                 for(; c && !isvisible(c); c = c->prev);
 219         }
 220         if(c) {
 221                 focus(c);
 222                 restack();
 223         }
 224 }
 225
 226 Client *
 227 getclient(Window w) {
 228         Client *c;
 229
 230         for(c = clients; c; c = c->next)
 231                 if(c->win == w)
 232                         return c;
 233         return NULL;
 234 }
 235
 236 void
 237 incnmaster(Arg *arg) {
 238         if((arrange == dofloat) || (nmaster + arg->i < 1)
 239         || (wah / (nmaster + arg->i) <= 2 * BORDERPX))
 240                 return;
 241         nmaster += arg->i;
 242         if(sel)
 243                 arrange();
 244         else
 245                 drawstatus();
 246 }
 247
 248 Bool
 249 isvisible(Client *c) {
 250         unsigned int i;
 251
 252         for(i = 0; i < ntags; i++)
 253                 if(c->tags[i] && seltag[i])
 254                         return True;
 255         return False;
 256 }
 257
 258 void
 259 resizemaster(Arg *arg) {
 260         if(arrange != dotile)
 261                 return;
 262         if(arg->i == 0)
 263                 master = MASTER;
 264         else {
 265                 if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX
 266                 || waw * (master + arg->i) / 1000 <= 2 * BORDERPX)
 267                         return;
 268                 master += arg->i;
 269         }
 270         arrange();
 271 }
 272
 273 void
 274 restack(void) {
 275         Client *c;
 276         XEvent ev;
 277
 278         drawstatus();
 279         if(!sel)
 280                 return;
 281         if(sel->isfloat || arrange == dofloat)
 282                 XRaiseWindow(dpy, sel->win);
 283         if(arrange != dofloat) {
 284                 if(!sel->isfloat)
 285                         XLowerWindow(dpy, sel->win);
 286                 for(c = nextmanaged(clients); c; c = nextmanaged(c->next)) {
 287                         if(c == sel)
 288                                 continue;
 289                         XLowerWindow(dpy, c->win);
 290                 }
 291         }
 292         XSync(dpy, False);
 293         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 294 }
 295
 296 void
 297 settags(Client *c, Client *trans) {
 298         char prop[512];
 299         unsigned int i, j;
 300         regmatch_t tmp;
 301         Bool matched = trans != NULL;
 302         XClassHint ch = { 0 };
 303
 304         if(matched)
 305                 for(i = 0; i < ntags; i++)
 306                         c->tags[i] = trans->tags[i];
 307         else {
 308                 XGetClassHint(dpy, c->win, &ch);
 309                 snprintf(prop, sizeof prop, "%s:%s:%s",
 310                                 ch.res_class ? ch.res_class : "",
 311                                 ch.res_name ? ch.res_name : "", c->name);
 312                 for(i = 0; i < len; i++)
 313                         if(rreg[i].clregex && !regexec(rreg[i].clregex, prop, 1, &tmp, 0)) {
 314                                 c->isfloat = rule[i].isfloat;
 315                                 for(j = 0; rreg[i].tregex && j < ntags; j++) {
 316                                         if(!regexec(rreg[i].tregex, tags[j], 1, &tmp, 0)) {
 317                                                 matched = True;
 318                                                 c->tags[j] = True;
 319                                         }
 320                                 }
 321                         }
 322                 if(ch.res_class)
 323                         XFree(ch.res_class);
 324                 if(ch.res_name)
 325                         XFree(ch.res_name);
 326         }
 327         if(!matched)
 328                 for(i = 0; i < ntags; i++)
 329                         c->tags[i] = seltag[i];
 330 }
 331
 332 void
 333 tag(Arg *arg) {
 334         unsigned int i;
 335
 336         if(!sel)
 337                 return;
 338         for(i = 0; i < ntags; i++)
 339                 sel->tags[i] = (arg->i == -1) ? True : False;
 340         if(arg->i >= 0 && arg->i < ntags)
 341                 sel->tags[arg->i] = True;
 342         arrange();
 343 }
 344
 345 void
 346 togglefloat(Arg *arg) {
 347         if(!sel || arrange == dofloat)
 348                 return;
 349         sel->isfloat = !sel->isfloat;
 350         arrange();
 351 }
 352
 353 void
 354 toggletag(Arg *arg) {
 355         unsigned int i;
 356
 357         if(!sel)
 358                 return;
 359         sel->tags[arg->i] = !sel->tags[arg->i];
 360         for(i = 0; i < ntags && !sel->tags[i]; i++);
 361         if(i == ntags)
 362                 sel->tags[arg->i] = True;
 363         arrange();
 364 }
 365
 366 void
 367 togglemode(Arg *arg) {
 368         arrange = (arrange == dofloat) ? dotile : dofloat;
 369         if(sel)
 370                 arrange();
 371         else
 372                 drawstatus();
 373 }
 374
 375 void
 376 toggleview(Arg *arg) {
 377         unsigned int i;
 378
 379         seltag[arg->i] = !seltag[arg->i];
 380         for(i = 0; i < ntags && !seltag[i]; i++);
 381         if(i == ntags)
 382                 seltag[arg->i] = True; /* cannot toggle last view */
 383         arrange();
 384 }
 385
 386 void
 387 view(Arg *arg) {
 388         unsigned int i;
 389
 390         for(i = 0; i < ntags; i++)
 391                 seltag[i] = (arg->i == -1) ? True : False;
 392         if(arg->i >= 0 && arg->i < ntags)
 393                 seltag[arg->i] = True;
 394         arrange();
 395 }
 396
 397 void
 398 zoom(Arg *arg) {
 399         unsigned int n;
 400         Client *c;
 401
 402         if(!sel)
 403                 return;
 404         if(sel->isfloat || (arrange == dofloat)) {
 405                 togglemax(sel);
 406                 return;
 407         }
 408         for(n = 0, c = nextmanaged(clients); c; c = nextmanaged(c->next))
 409                 n++;
 410
 411         if((c = sel) == nextmanaged(clients))
 412                 if(!(c = nextmanaged(c->next)))
 413                         return;
 414         detach(c);
 415         attach(c);
 416         focus(c);
 417         arrange();
 418 }