view.c

   1 /*
   2  * (C)opyright MMVI Anselm R. Garbe <garbeam at gmail dot com>
   3  * See LICENSE file for license details.
   4  */
   5 #include "dwm.h"
   6
   7 /* static */
   8
   9 static Client *
  10 minclient(void) {
  11         Client *c, *min;
  12
  13         if((clients && clients->isfloat) || arrange == dofloat)
  14                 return clients; /* don't touch floating order */
  15         for(min = c = clients; c; c = c->next)
  16                 if(c->weight < min->weight)
  17                         min = c;
  18         return min;
  19 }
  20
  21 static Client *
  22 nexttiled(Client *c) {
  23         for(c = getnext(c); c && c->isfloat; c = getnext(c->next));
  24         return c;
  25 }
  26
  27 static void
  28 reorder(void) {
  29         Client *c, *newclients, *tail;
  30
  31         newclients = tail = NULL;
  32         while((c = minclient())) {
  33                 detach(c);
  34                 if(tail) {
  35                         c->prev = tail;
  36                         tail->next = c;
  37                         tail = c;
  38                 }
  39                 else
  40                         tail = newclients = c;
  41         }
  42         clients = newclients;
  43 }
  44
  45 static void
  46 togglemax(Client *c)
  47 {
  48         XEvent ev;
  49         if((c->ismax = !c->ismax)) {
  50                 c->rx = c->x; c->x = sx;
  51                 c->ry = c->y; c->y = bh;
  52                 c->rw = c->w; c->w = sw - 2 * BORDERPX;
  53                 c->rh = c->h; c->h = sh - bh - 2 * BORDERPX;
  54         }
  55         else {
  56                 c->x = c->rx;
  57                 c->y = c->ry;
  58                 c->w = c->rw;
  59                 c->h = c->rh;
  60         }
  61         resize(c, True, TopLeft);
  62         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
  63 }
  64
  65 /* extern */
  66
  67 void (*arrange)(Arg *) = DEFMODE;
  68 StackPos stackpos = STACKPOS;
  69
  70 void
  71 detach(Client *c) {
  72         if(c->prev)
  73                 c->prev->next = c->next;
  74         if(c->next)
  75                 c->next->prev = c->prev;
  76         if(c == clients)
  77                 clients = c->next;
  78         c->next = c->prev = NULL;
  79 }
  80
  81 void
  82 dofloat(Arg *arg) {
  83         Client *c;
  84
  85         for(c = clients; c; c = c->next) {
  86                 if(isvisible(c)) {
  87                         resize(c, True, TopLeft);
  88                 }
  89                 else
  90                         ban(c);
  91         }
  92         if(!sel || !isvisible(sel)) {
  93                 for(c = stack; c && !isvisible(c); c = c->snext);
  94                 focus(c);
  95         }
  96         restack();
  97 }
  98
  99 /* This algorithm is based on a (M)aster area and a (S)tacking area.
 100  * It supports following arrangements:
 101  *      SSMMM   MMMMM   MMMSS
 102  *      SSMMM   SSSSS   MMMSS
 103  */
 104 void
 105 dotile(Arg *arg) {
 106         int i, n, stackw, stackh, tw, th;
 107         Client *c;
 108
 109         for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
 110                 n++;
 111
 112         if(stackpos == StackBottom) {
 113                 stackw = sw;
 114                 stackh = sh - bh - master;
 115         }
 116         else {
 117                 stackw = sw - master;
 118                 stackh = sh - bh;
 119         }
 120
 121         tw = stackw;
 122         if(n > 1)
 123                 th = stackh / (n - 1);
 124         else
 125                 th = stackh;
 126
 127         for(i = 0, c = clients; c; c = c->next) {
 128                 if(isvisible(c)) {
 129                         if(c->isfloat) {
 130                                 resize(c, True, TopLeft);
 131                                 continue;
 132                         }
 133                         c->ismax = False;
 134                         if(n == 1) { /* only 1 window */
 135                                 c->x = sx;
 136                                 c->y = sy + bh;
 137                                 c->w = sw - 2 * BORDERPX;
 138                                 c->h = sh - 2 * BORDERPX - bh;
 139                         }
 140                         else if(i == 0) { /* master window */
 141                                 switch(stackpos) {
 142                                 case StackLeft:
 143                                         c->x = sx + stackw;
 144                                         c->y = sy + bh;
 145                                         c->w = master - 2 * BORDERPX;
 146                                         c->h = sh - bh - 2 * BORDERPX;
 147                                         break;
 148                                 case StackBottom:
 149                                         c->x = sx;
 150                                         c->y = sy + bh;
 151                                         c->w = sw - 2 * BORDERPX;
 152                                         c->h = master - 2 * BORDERPX;
 153                                         break;
 154                                 case StackRight:
 155                                         c->x = sx;
 156                                         c->y = sy + bh;
 157                                         c->w = master - 2 * BORDERPX;
 158                                         c->h = sh - bh - 2 * BORDERPX;
 159                                         break;
 160                                 }
 161                         }
 162                         else if(th > bh) {
 163                                 /* tile window */
 164                                 c->w = tw - 2 * BORDERPX;
 165                                 c->h = th - 2 * BORDERPX;
 166                                 switch(stackpos) {
 167                                 case StackLeft:
 168                                         c->x = sx;
 169                                         c->y = sy + (i - 1) * th + bh;
 170                                         if(i + 1 == n)
 171                                                 c->h = sh - c->y - 2 * BORDERPX;
 172                                         break;
 173                                 case StackBottom:
 174                                         c->x = sx;
 175                                         c->y = sy + master + (i - 1) * th + bh;
 176                                         if(i + 1 == n)
 177                                                 c->h = sh - c->y - 2 * BORDERPX;
 178                                         break;
 179                                 case StackRight:
 180                                         c->x = sx + master;
 181                                         c->y = sy + (i - 1) * th + bh;
 182                                         if(i + 1 == n)
 183                                                 c->h = sh - c->y - 2 * BORDERPX;
 184                                         break;
 185                                 }
 186                         }
 187                         else { /* fallback if th < bh */
 188                                 c->w = stackw - 2 * BORDERPX;
 189                                 c->h = stackh - 2 * BORDERPX;
 190                                 switch(stackpos) {
 191                                 case StackLeft:
 192                                         c->x = sx;
 193                                         c->y = sy + bh;
 194                                         break;
 195                                 case StackBottom:
 196                                         c->x = sx;
 197                                         c->y = sy + master + bh;
 198                                         break;
 199                                 case StackRight:
 200                                         c->x = sx + master;
 201                                         c->y = sy + bh;
 202                                         break;
 203                                 }
 204                         }
 205                         resize(c, False, TopLeft);
 206                         i++;
 207                 }
 208                 else
 209                         ban(c);
 210         }
 211         if(!sel || !isvisible(sel)) {
 212                 for(c = stack; c && !isvisible(c); c = c->snext);
 213                 focus(c);
 214         }
 215         restack();
 216 }
 217
 218 void
 219 focusnext(Arg *arg) {
 220         Client *c;
 221
 222         if(!sel)
 223                 return;
 224
 225         if(!(c = getnext(sel->next)))
 226                 c = getnext(clients);
 227         if(c) {
 228                 focus(c);
 229                 restack();
 230         }
 231 }
 232
 233 void
 234 focusprev(Arg *arg) {
 235         Client *c;
 236
 237         if(!sel)
 238                 return;
 239
 240         if(!(c = getprev(sel->prev))) {
 241                 for(c = clients; c && c->next; c = c->next);
 242                 c = getprev(c);
 243         }
 244         if(c) {
 245                 focus(c);
 246                 restack();
 247         }
 248 }
 249
 250 Bool
 251 isvisible(Client *c) {
 252         unsigned int i;
 253
 254         for(i = 0; i < ntags; i++)
 255                 if(c->tags[i] && seltag[i])
 256                         return True;
 257         return False;
 258 }
 259
 260 void
 261 resizecol(Arg *arg) {
 262         int s;
 263         unsigned int n;
 264         Client *c;
 265
 266         for(n = 0, c = clients; c; c = c->next)
 267                 if(isvisible(c) && !c->isfloat)
 268                         n++;
 269         if(!sel || sel->isfloat || n < 2 || (arrange == dofloat))
 270                 return;
 271
 272         s = stackpos == StackBottom ? sh - bh : sw;
 273         if(sel == getnext(clients)) {
 274                 if(master + arg->i > s - MINW || master + arg->i < MINW)
 275                         return;
 276                 master += arg->i;
 277         }
 278         else {
 279                 if(master - arg->i > s - MINW || master - arg->i < MINW)
 280                         return;
 281                 master -= arg->i;
 282         }
 283         arrange(NULL);
 284 }
 285
 286 void
 287 restack(void) {
 288         Client *c;
 289         XEvent ev;
 290
 291         if(!sel) {
 292                 drawstatus();
 293                 return;
 294         }
 295         if(sel->isfloat || arrange == dofloat) {
 296                 XRaiseWindow(dpy, sel->win);
 297                 XRaiseWindow(dpy, sel->twin);
 298         }
 299         if(arrange != dofloat) {
 300                 if(!sel->isfloat) {
 301                         XLowerWindow(dpy, sel->twin);
 302                         XLowerWindow(dpy, sel->win);
 303                 }
 304                 for(c = nexttiled(clients); c; c = nexttiled(c->next)) {
 305                         if(c == sel)
 306                                 continue;
 307                         XLowerWindow(dpy, c->twin);
 308                         XLowerWindow(dpy, c->win);
 309                 }
 310         }
 311         drawall();
 312         XSync(dpy, False);
 313         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 314 }
 315
 316 void
 317 togglemode(Arg *arg) {
 318         arrange = (arrange == dofloat) ? dotile : dofloat;
 319         if(sel)
 320                 arrange(NULL);
 321         else
 322                 drawstatus();
 323 }
 324
 325 void
 326 toggleview(Arg *arg) {
 327         unsigned int i;
 328
 329         seltag[arg->i] = !seltag[arg->i];
 330         for(i = 0; i < ntags && !seltag[i]; i++);
 331         if(i == ntags)
 332                 seltag[arg->i] = True; /* cannot toggle last view */
 333         reorder();
 334         arrange(NULL);
 335 }
 336
 337 void
 338 togglestackpos(Arg *arg) {
 339         if(arrange == dofloat)
 340                 return;
 341         if(stackpos == StackBottom)
 342                 stackpos = STACKPOS;
 343         else
 344                 stackpos = StackBottom;
 345         master = ((stackpos == StackBottom ? sh - bh : sw) * MASTER) / 100;
 346         arrange(NULL);
 347 }
 348
 349 void
 350 view(Arg *arg) {
 351         unsigned int i;
 352
 353         for(i = 0; i < ntags; i++)
 354                 seltag[i] = False;
 355         seltag[arg->i] = True;
 356         reorder();
 357         arrange(NULL);
 358 }
 359
 360 void
 361 viewall(Arg *arg) {
 362         unsigned int i;
 363
 364         for(i = 0; i < ntags; i++)
 365                 seltag[i] = True;
 366         reorder();
 367         arrange(NULL);
 368 }
 369
 370
 371
 372 void
 373 zoom(Arg *arg) {
 374         unsigned int n;
 375         Client *c;
 376
 377         if(!sel)
 378                 return;
 379
 380         if(sel->isfloat || (arrange == dofloat)) {
 381                 togglemax(sel);
 382                 return;
 383         }
 384
 385         for(n = 0, c = clients; c; c = c->next)
 386                 if(isvisible(c) && !c->isfloat)
 387                         n++;
 388         if(n < 2 || (arrange == dofloat))
 389                 return;
 390
 391         if((c = sel) == nexttiled(clients))
 392                 if(!(c = nexttiled(c->next)))
 393                         return;
 394         detach(c);
 395         if(clients)
 396                 clients->prev = c;
 397         c->next = clients;
 398         clients = c;
 399         focus(c);
 400         arrange(NULL);
 401 }