layout.c

   1 /* © 2006-2007 Anselm R. Garbe <garbeam at gmail dot com>
   2  * © 2006-2007 Sander van Dijk <a dot h dot vandijk at gmail dot com>
   3  * © 2006-2007 Jukka Salmi <jukka at salmi dot ch>
   4  * © 2007 Premysl Hruby <dfenze at gmail dot com>
   5  * © 2007 Szabolcs Nagy <nszabolcs at gmail dot com>
   6  * See LICENSE file for license details. */
   7 #include "dwm.h"
   8 #include <stdlib.h>
   9
  10 unsigned int blw = 0;
  11 Layout *lt = NULL;
  12
  13 /* static */
  14
  15 static unsigned int nlayouts = 0;
  16 static unsigned int masterw = MASTERWIDTH;
  17 static unsigned int nmaster = NMASTER;
  18
  19 static void
  20 ban(Client *c) {
  21         if (c->isbanned)
  22                 return;
  23         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
  24         c->isbanned = True;
  25 }
  26
  27 static void
  28 unban(Client *c) {
  29         if (!c->isbanned)
  30                 return;
  31         XMoveWindow(dpy, c->win, c->x, c->y);
  32         c->isbanned = False;
  33 }
  34
  35 static void
  36 tile(void) {
  37         unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;
  38         Client *c;
  39
  40         for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
  41                 n++;
  42         /* window geoms */
  43         mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
  44         mw = (n > nmaster) ? (waw * masterw) / 1000 : waw;
  45         th = (n > nmaster) ? wah / (n - nmaster) : 0;
  46         tw = waw - mw;
  47
  48         for(i = 0, c = clients; c; c = c->next)
  49                 if(isvisible(c)) {
  50                         unban(c);
  51                         if(c->isfloating)
  52                                 continue;
  53                         c->ismax = False;
  54                         nx = wax;
  55                         ny = way;
  56                         if(i < nmaster) {
  57                                 ny += i * mh;
  58                                 nw = mw - 2 * c->border;
  59                                 nh = mh;
  60                                 if(i + 1 == (n < nmaster ? n : nmaster)) /* remainder */
  61                                         nh = wah - mh * i;
  62                                 nh -= 2 * c->border;
  63                         }
  64                         else {  /* tile window */
  65                                 nx += mw;
  66                                 nw = tw - 2 * c->border;
  67                                 if(th > 2 * c->border) {
  68                                         ny += (i - nmaster) * th;
  69                                         nh = th;
  70                                         if(i + 1 == n) /* remainder */
  71                                                 nh = wah - th * (i - nmaster);
  72                                         nh -= 2 * c->border;
  73                                 }
  74                                 else /* fallback if th <= 2 * c->border */
  75                                         nh = wah - 2 * c->border;
  76                         }
  77                         resize(c, nx, ny, nw, nh, False);
  78                         i++;
  79                 }
  80                 else
  81                         ban(c);
  82         focus(NULL);
  83         restack();
  84 }
  85
  86 LAYOUTS
  87
  88 /* extern */
  89
  90 void
  91 floating(void) {
  92         Client *c;
  93
  94         for(c = clients; c; c = c->next)
  95                 if(isvisible(c)) {
  96                         if(c->isbanned)
  97                                 XMoveWindow(dpy, c->win, c->x, c->y);
  98                         c->isbanned = False;
  99                         resize(c, c->x, c->y, c->w, c->h, True);
 100                 }
 101                 else
 102                         ban(c);
 103         focus(NULL);
 104         restack();
 105 }
 106
 107 void
 108 focusclient(const char *arg) {
 109         Client *c;
 110
 111         if(!sel || !arg)
 112                 return;
 113         if(atoi(arg) < 0) {
 114                 for(c = sel->prev; c && !isvisible(c); c = c->prev);
 115                 if(!c) {
 116                         for(c = clients; c && c->next; c = c->next);
 117                         for(; c && !isvisible(c); c = c->prev);
 118                 }
 119         }
 120         else {
 121                 for(c = sel->next; c && !isvisible(c); c = c->next);
 122                 if(!c)
 123                         for(c = clients; c && !isvisible(c); c = c->next);
 124         }
 125         if(c) {
 126                 focus(c);
 127                 restack();
 128         }
 129 }
 130
 131 void
 132 incmasterw(const char *arg) {
 133         int i;
 134         if(lt->arrange != tile)
 135                 return;
 136         if(!arg)
 137                 masterw = MASTERWIDTH;
 138         else {
 139                 i = atoi(arg);
 140                 if(waw * (masterw + i) / 1000 >= waw - 2 * BORDERPX
 141                 || waw * (masterw + i) / 1000 <= 2 * BORDERPX)
 142                         return;
 143                 masterw += i;
 144         }
 145         lt->arrange();
 146 }
 147
 148 void
 149 incnmaster(const char *arg) {
 150         int i;
 151
 152         if(!arg)
 153                 nmaster = NMASTER;
 154         else {
 155                 i = atoi(arg);
 156                 if((lt->arrange != tile) || (nmaster + i < 1)
 157                 || (wah / (nmaster + i) <= 2 * BORDERPX))
 158                         return;
 159                 nmaster += i;
 160         }
 161         if(sel)
 162                 lt->arrange();
 163         else
 164                 drawstatus();
 165 }
 166
 167 void
 168 initlayouts(void) {
 169         unsigned int i, w;
 170
 171         lt = &layout[0];
 172         nlayouts = sizeof layout / sizeof layout[0];
 173         for(blw = i = 0; i < nlayouts; i++) {
 174                 w = textw(layout[i].symbol);
 175                 if(w > blw)
 176                         blw = w;
 177         }
 178 }
 179
 180 Client *
 181 nexttiled(Client *c) {
 182         for(; c && (c->isfloating || !isvisible(c)); c = c->next);
 183         return c;
 184 }
 185
 186 void
 187 restack(void) {
 188         Client *c;
 189         XEvent ev;
 190
 191         drawstatus();
 192         if(!sel)
 193                 return;
 194         if(sel->isfloating || lt->arrange == floating)
 195                 XRaiseWindow(dpy, sel->win);
 196         if(lt->arrange != floating) {
 197                 if(!sel->isfloating)
 198                         XLowerWindow(dpy, sel->win);
 199                 for(c = nexttiled(clients); c; c = nexttiled(c->next)) {
 200                         if(c == sel)
 201                                 continue;
 202                         XLowerWindow(dpy, c->win);
 203                 }
 204         }
 205         XSync(dpy, False);
 206         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 207 }
 208
 209 void
 210 setlayout(const char *arg) {
 211         int i;
 212
 213         if(!arg) {
 214                 lt++;
 215                 if(lt == layout + nlayouts)
 216                         lt = layout;
 217         }
 218         else {
 219                 i = atoi(arg);
 220                 if(i < 0 || i >= nlayouts)
 221                         return;
 222                 lt = &layout[i];
 223         }
 224         if(sel)
 225                 lt->arrange();
 226         else
 227                 drawstatus();
 228 }
 229
 230 void
 231 togglebar(const char *arg) {
 232         if(bpos == BarOff)
 233                 bpos = (BARPOS == BarOff) ? BarTop : BARPOS;
 234         else
 235                 bpos = BarOff;
 236         updatebarpos();
 237         lt->arrange();
 238 }
 239
 240 void
 241 togglemax(const char *arg) {
 242         XEvent ev;
 243
 244         if(!sel || (lt->arrange != floating && !sel->isfloating) || sel->isfixed)
 245                 return;
 246         if((sel->ismax = !sel->ismax)) {
 247                 sel->rx = sel->x;
 248                 sel->ry = sel->y;
 249                 sel->rw = sel->w;
 250                 sel->rh = sel->h;
 251                 resize(sel, wax, way, waw - 2 * BORDERPX, wah - 2 * BORDERPX, True);
 252         }
 253         else
 254                 resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, True);
 255         drawstatus();
 256         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 257 }
 258
 259 void
 260 zoom(const char *arg) {
 261         Client *c;
 262
 263         if(!sel || lt->arrange == floating || sel->isfloating)
 264                 return;
 265         if((c = sel) == nexttiled(clients))
 266                 if(!(c = nexttiled(c->next)))
 267                         return;
 268         detach(c);
 269         attach(c);
 270         focus(c);
 271         lt->arrange();
 272 }