layout.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
   6 unsigned int master = MASTER;
   7 unsigned int nmaster = NMASTER;
   8 unsigned int blw = 0;
   9 Layout *lt = NULL;
  10
  11 /* static */
  12
  13 static unsigned int nlayouts = 0;
  14
  15 static void
  16 tile(void) {
  17         unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;
  18         Client *c;
  19
  20         for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
  21                 n++;
  22         /* window geoms */
  23         mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
  24         mw = (n > nmaster) ? (waw * master) / 1000 : waw;
  25         th = (n > nmaster) ? wah / (n - nmaster) : 0;
  26         tw = waw - mw;
  27
  28         for(i = 0, c = clients; c; c = c->next)
  29                 if(isvisible(c)) {
  30                         if(c->isbanned)
  31                                 XMoveWindow(dpy, c->win, c->x, c->y);
  32                         c->isbanned = False;
  33                         if(c->isversatile)
  34                                 continue;
  35                         c->ismax = False;
  36                         nx = wax;
  37                         ny = way;
  38                         if(i < nmaster) {
  39                                 ny += i * mh;
  40                                 nw = mw - 2 * BORDERPX;
  41                                 nh = mh - 2 * BORDERPX;
  42                         }
  43                         else {  /* tile window */
  44                                 nx += mw;
  45                                 nw = tw - 2 * BORDERPX;
  46                                 if(th > 2 * BORDERPX) {
  47                                         ny += (i - nmaster) * th;
  48                                         nh = th - 2 * BORDERPX;
  49                                 }
  50                                 else /* fallback if th <= 2 * BORDERPX */
  51                                         nh = wah - 2 * BORDERPX;
  52                         }
  53                         resize(c, nx, ny, nw, nh, False);
  54                         i++;
  55                 }
  56                 else {
  57                         c->isbanned = True;
  58                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
  59                 }
  60         if(!sel || !isvisible(sel)) {
  61                 for(c = stack; c && !isvisible(c); c = c->snext);
  62                 focus(c);
  63         }
  64         restack();
  65 }
  66
  67 LAYOUTS
  68
  69 /* extern */
  70
  71 void
  72 incnmaster(Arg *arg) {
  73         if((lt->arrange != tile) || (nmaster + arg->i < 1)
  74         || (wah / (nmaster + arg->i) <= 2 * BORDERPX))
  75                 return;
  76         nmaster += arg->i;
  77         if(sel)
  78                 lt->arrange();
  79         else
  80                 drawstatus();
  81 }
  82
  83 void
  84 initlayouts(void) {
  85         unsigned int i, w;
  86
  87         lt = &layout[0];
  88         nlayouts = sizeof layout / sizeof layout[0];
  89         for(blw = i = 0; i < nlayouts; i++) {
  90                 w = textw(layout[i].symbol);
  91                 if(w > blw)
  92                         blw = w;
  93         }
  94 }
  95
  96 void
  97 resizemaster(Arg *arg) {
  98         if(lt->arrange != tile)
  99                 return;
 100         if(arg->i == 0)
 101                 master = MASTER;
 102         else {
 103                 if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX
 104                 || waw * (master + arg->i) / 1000 <= 2 * BORDERPX)
 105                         return;
 106                 master += arg->i;
 107         }
 108         lt->arrange();
 109 }
 110
 111 void
 112 restack(void) {
 113         Client *c;
 114         XEvent ev;
 115
 116         drawstatus();
 117         if(!sel)
 118                 return;
 119         if(sel->isversatile || lt->arrange == versatile)
 120                 XRaiseWindow(dpy, sel->win);
 121         if(lt->arrange != versatile) {
 122                 if(!sel->isversatile)
 123                         XLowerWindow(dpy, sel->win);
 124                 for(c = nexttiled(clients); c; c = nexttiled(c->next)) {
 125                         if(c == sel)
 126                                 continue;
 127                         XLowerWindow(dpy, c->win);
 128                 }
 129         }
 130         XSync(dpy, False);
 131         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 132 }
 133
 134 void
 135 setlayout(Arg *arg) {
 136         unsigned int i;
 137
 138         if(arg->i == -1) {
 139                 for(i = 0; i < nlayouts && lt != &layout[i]; i++);
 140                 if(i == nlayouts - 1)
 141                         lt = &layout[0];
 142                 else
 143                         lt = &layout[++i];
 144         }
 145         else {
 146                 if(arg->i < 0 || arg->i >= nlayouts)
 147                         return;
 148                 lt = &layout[arg->i];
 149         }
 150         if(sel)
 151                 lt->arrange();
 152         else
 153                 drawstatus();
 154 }
 155
 156 void
 157 toggleversatile(Arg *arg) {
 158         if(!sel || lt->arrange == versatile)
 159                 return;
 160         sel->isversatile = !sel->isversatile;
 161         lt->arrange();
 162 }
 163
 164 void
 165 versatile(void) {
 166         Client *c;
 167
 168         for(c = clients; c; c = c->next) {
 169                 if(isvisible(c)) {
 170                         if(c->isbanned)
 171                                 XMoveWindow(dpy, c->win, c->x, c->y);
 172                         c->isbanned = False;
 173                         resize(c, c->x, c->y, c->w, c->h, True);
 174                 }
 175                 else {
 176                         c->isbanned = True;
 177                         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
 178                 }
 179         }
 180         if(!sel || !isvisible(sel)) {
 181                 for(c = stack; c && !isvisible(c); c = c->snext);
 182                 focus(c);
 183         }
 184         restack();
 185 }