client.c

   1 /*
   2  * (C)opyright MMVI Anselm R. Garbe <garbeam at gmail dot com>
   3  * See LICENSE file for license details.
   4  */
   5
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <X11/Xatom.h>
  10 #include <X11/Xutil.h>
  11
  12 #include "dwm.h"
  13
  14 void (*arrange)(Arg *) = tiling;
  15
  16 static Rule rule[] = {
  17         /* class                        instance        tags                                            floating */
  18         { "Firefox-bin",        "Gecko",        { [Twww] = "www" },                     False },
  19 };
  20
  21 static Client *
  22 next(Client *c)
  23 {
  24         for(; c && !c->tags[tsel]; c = c->next);
  25         return c;
  26 }
  27
  28 void
  29 zoom(Arg *arg)
  30 {
  31         Client **l, *c;
  32
  33         if(!sel)
  34                 return;
  35
  36         if(sel == next(clients) && sel->next)  {
  37                 if((c = next(sel->next)))
  38                         sel = c;
  39         }
  40
  41         for(l = &clients; *l && *l != sel; l = &(*l)->next);
  42         *l = sel->next;
  43
  44         sel->next = clients; /* pop */
  45         clients = sel;
  46         arrange(NULL);
  47         focus(sel);
  48 }
  49
  50 void
  51 max(Arg *arg)
  52 {
  53         if(!sel)
  54                 return;
  55         sel->x = sx;
  56         sel->y = sy + bh;
  57         sel->w = sw - 2 * sel->border;
  58         sel->h = sh - 2 * sel->border - bh;
  59         craise(sel);
  60         resize(sel, False);
  61 }
  62
  63 void
  64 view(Arg *arg)
  65 {
  66         Client *c;
  67
  68         tsel = arg->i;
  69         arrange(NULL);
  70
  71         for(c = clients; c; c = next(c->next))
  72                 draw_client(c);
  73         draw_bar();
  74 }
  75
  76 void
  77 tappend(Arg *arg)
  78 {
  79         if(!sel)
  80                 return;
  81
  82         sel->tags[arg->i] = tags[arg->i];
  83         arrange(NULL);
  84 }
  85
  86 void
  87 ttrunc(Arg *arg)
  88 {
  89         int i;
  90         if(!sel)
  91                 return;
  92
  93         for(i = 0; i < TLast; i++)
  94                 sel->tags[i] = NULL;
  95         tappend(arg);
  96 }
  97
  98 static void
  99 ban_client(Client *c)
 100 {
 101         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
 102         XMoveWindow(dpy, c->title, c->tx + 2 * sw, c->ty);
 103 }
 104
 105 void
 106 floating(Arg *arg)
 107 {
 108         Client *c;
 109
 110         arrange = floating;
 111         for(c = clients; c; c = c->next) {
 112                 if(c->tags[tsel])
 113                         resize(c, True);
 114                 else
 115                         ban_client(c);
 116         }
 117         if(sel && !sel->tags[tsel]) {
 118                 if((sel = next(clients))) {
 119                         craise(sel);
 120                         focus(sel);
 121                 }
 122         }
 123 }
 124
 125 void
 126 tiling(Arg *arg)
 127 {
 128         Client *c;
 129         int n, i, w, h;
 130
 131         w = sw - mw;
 132         arrange = tiling;
 133         for(n = 0, c = clients; c; c = c->next)
 134                 if(c->tags[tsel] && !c->floating)
 135                         n++;
 136
 137         if(n > 1)
 138                 h = (sh - bh) / (n - 1);
 139         else
 140                 h = sh - bh;
 141
 142         for(i = 0, c = clients; c; c = c->next) {
 143                 if(c->tags[tsel]) {
 144                         if(c->floating) {
 145                                 craise(c);
 146                                 resize(c, True);
 147                                 continue;
 148                         }
 149                         if(n == 1) {
 150                                 c->x = sx;
 151                                 c->y = sy + bh;
 152                                 c->w = sw - 2 * c->border;
 153                                 c->h = sh - 2 * c->border - bh;
 154                         }
 155                         else if(i == 0) {
 156                                 c->x = sx;
 157                                 c->y = sy + bh;
 158                                 c->w = mw - 2 * c->border;
 159                                 c->h = sh - 2 * c->border - bh;
 160                         }
 161                         else {
 162                                 c->x = sx + mw;
 163                                 c->y = sy + (i - 1) * h + bh;
 164                                 c->w = w - 2 * c->border;
 165                                 c->h = h - 2 * c->border;
 166                         }
 167                         resize(c, False);
 168                         i++;
 169                 }
 170                 else
 171                         ban_client(c);
 172         }
 173         if(!sel || (sel && !sel->tags[tsel])) {
 174                 if((sel = next(clients))) {
 175                         craise(sel);
 176                         focus(sel);
 177                 }
 178         }
 179 }
 180
 181 void
 182 prevc(Arg *arg)
 183 {
 184         Client *c;
 185
 186         if(!sel)
 187                 return;
 188
 189         if((c = sel->revert && sel->revert->tags[tsel] ? sel->revert : NULL)) {
 190                 craise(c);
 191                 focus(c);
 192         }
 193 }
 194
 195 void
 196 nextc(Arg *arg)
 197 {
 198         Client *c;
 199
 200         if(!sel)
 201                 return;
 202
 203         if(!(c = next(sel->next)))
 204                 c = next(clients);
 205         if(c) {
 206                 craise(c);
 207                 c->revert = sel;
 208                 focus(c);
 209         }
 210 }
 211
 212 void
 213 ckill(Arg *arg)
 214 {
 215         if(!sel)
 216                 return;
 217         if(sel->proto & WM_PROTOCOL_DELWIN)
 218                 send_message(sel->win, wm_atom[WMProtocols], wm_atom[WMDelete]);
 219         else
 220                 XKillClient(dpy, sel->win);
 221 }
 222
 223 static void
 224 resize_title(Client *c)
 225 {
 226         int i;
 227
 228         c->tw = 0;
 229         for(i = 0; i < TLast; i++)
 230                 if(c->tags[i])
 231                         c->tw += textw(c->tags[i]) + dc.font.height;
 232         c->tw += textw(c->name) + dc.font.height;
 233         if(c->tw > c->w)
 234                 c->tw = c->w + 2;
 235         c->tx = c->x + c->w - c->tw + 2;
 236         c->ty = c->y;
 237         XMoveResizeWindow(dpy, c->title, c->tx, c->ty, c->tw, c->th);
 238 }
 239
 240 void
 241 update_name(Client *c)
 242 {
 243         XTextProperty name;
 244         int n;
 245         char **list = NULL;
 246
 247         name.nitems = 0;
 248         c->name[0] = 0;
 249         XGetTextProperty(dpy, c->win, &name, net_atom[NetWMName]);
 250         if(!name.nitems)
 251                 XGetWMName(dpy, c->win, &name);
 252         if(!name.nitems)
 253                 return;
 254         if(name.encoding == XA_STRING)
 255                 strncpy(c->name, (char *)name.value, sizeof(c->name));
 256         else {
 257                 if(XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Success
 258                                 && n > 0 && *list)
 259                 {
 260                         strncpy(c->name, *list, sizeof(c->name));
 261                         XFreeStringList(list);
 262                 }
 263         }
 264         XFree(name.value);
 265         resize_title(c);
 266 }
 267
 268 void
 269 update_size(Client *c)
 270 {
 271         XSizeHints size;
 272         long msize;
 273         if(!XGetWMNormalHints(dpy, c->win, &size, &msize) || !size.flags)
 274                 size.flags = PSize;
 275         c->flags = size.flags;
 276         if(c->flags & PBaseSize) {
 277                 c->basew = size.base_width;
 278                 c->baseh = size.base_height;
 279         }
 280         else
 281                 c->basew = c->baseh = 0;
 282         if(c->flags & PResizeInc) {
 283                 c->incw = size.width_inc;
 284                 c->inch = size.height_inc;
 285         }
 286         else
 287                 c->incw = c->inch = 0;
 288         if(c->flags & PMaxSize) {
 289                 c->maxw = size.max_width;
 290                 c->maxh = size.max_height;
 291         }
 292         else
 293                 c->maxw = c->maxh = 0;
 294         if(c->flags & PMinSize) {
 295                 c->minw = size.min_width;
 296                 c->minh = size.min_height;
 297         }
 298         else
 299                 c->minw = c->minh = 0;
 300         if(c->flags & PWinGravity)
 301                 c->grav = size.win_gravity;
 302         else
 303                 c->grav = NorthWestGravity;
 304 }
 305
 306 void
 307 craise(Client *c)
 308 {
 309         XRaiseWindow(dpy, c->win);
 310         XRaiseWindow(dpy, c->title);
 311 }
 312
 313 void
 314 lower(Client *c)
 315 {
 316         XLowerWindow(dpy, c->title);
 317         XLowerWindow(dpy, c->win);
 318 }
 319
 320 void
 321 focus(Client *c)
 322 {
 323         Client *old = sel;
 324         XEvent ev;
 325
 326         XFlush(dpy);
 327         sel = c;
 328         if(old && old != c)
 329                 draw_client(old);
 330         draw_client(c);
 331         XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
 332         XFlush(dpy);
 333         while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 334 }
 335
 336 static void
 337 init_tags(Client *c)
 338 {
 339         XClassHint ch;
 340         static unsigned int len = rule ? sizeof(rule) / sizeof(rule[0]) : 0;
 341         unsigned int i, j;
 342         Bool matched = False;
 343
 344         if(!len) {
 345                 c->tags[tsel] = tags[tsel];
 346                 return;
 347         }
 348
 349         if(XGetClassHint(dpy, c->win, &ch)) {
 350                 if(ch.res_class && ch.res_name) {
 351                         for(i = 0; i < len; i++)
 352                                 if(!strncmp(rule[i].class, ch.res_class, sizeof(rule[i].class))
 353                                         && !strncmp(rule[i].instance, ch.res_name, sizeof(rule[i].instance)))
 354                                 {
 355                                         for(j = 0; j < TLast; j++)
 356                                                 c->tags[j] = rule[i].tags[j];
 357                                         c->floating = rule[i].floating;
 358                                         matched = True;
 359                                         break;
 360                                 }
 361                 }
 362                 if(ch.res_class)
 363                         XFree(ch.res_class);
 364                 if(ch.res_name)
 365                         XFree(ch.res_name);
 366         }
 367
 368         if(!matched)
 369                 c->tags[tsel] = tags[tsel];
 370 }
 371
 372 void
 373 manage(Window w, XWindowAttributes *wa)
 374 {
 375         Client *c, **l;
 376         XSetWindowAttributes twa;
 377         Window trans;
 378
 379         c = emallocz(sizeof(Client));
 380         c->win = w;
 381         c->tx = c->x = wa->x;
 382         c->ty = c->y = wa->y;
 383         if(c->y < bh)
 384                 c->ty = c->y += bh;
 385         c->tw = c->w = wa->width;
 386         c->h = wa->height;
 387         c->th = bh;
 388         c->border = 1;
 389         c->proto = win_proto(c->win);
 390         update_size(c);
 391         XSelectInput(dpy, c->win,
 392                         StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
 393         XGetTransientForHint(dpy, c->win, &trans);
 394         twa.override_redirect = 1;
 395         twa.background_pixmap = ParentRelative;
 396         twa.event_mask = ExposureMask;
 397
 398         c->title = XCreateWindow(dpy, root, c->tx, c->ty, c->tw, c->th,
 399                         0, DefaultDepth(dpy, screen), CopyFromParent,
 400                         DefaultVisual(dpy, screen),
 401                         CWOverrideRedirect | CWBackPixmap | CWEventMask, &twa);
 402
 403         update_name(c);
 404         init_tags(c);
 405
 406         for(l = &clients; *l; l = &(*l)->next);
 407         c->next = *l; /* *l == nil */
 408         *l = c;
 409
 410         XGrabButton(dpy, Button1, Mod1Mask, c->win, False, ButtonPressMask,
 411                         GrabModeAsync, GrabModeSync, None, None);
 412         XGrabButton(dpy, Button2, Mod1Mask, c->win, False, ButtonPressMask,
 413                         GrabModeAsync, GrabModeSync, None, None);
 414         XGrabButton(dpy, Button3, Mod1Mask, c->win, False, ButtonPressMask,
 415                         GrabModeAsync, GrabModeSync, None, None);
 416
 417         if(!c->floating)
 418                 c->floating = trans
 419                         || ((c->maxw == c->minw) && (c->maxh == c->minh));
 420
 421         arrange(NULL);
 422         /* mapping the window now prevents flicker */
 423         if(c->tags[tsel]) {
 424                 XMapRaised(dpy, c->win);
 425                 XMapRaised(dpy, c->title);
 426                 focus(c);
 427         }
 428         else {
 429                 ban_client(c);
 430                 XMapRaised(dpy, c->win);
 431                 XMapRaised(dpy, c->title);
 432         }
 433 }
 434
 435 void
 436 gravitate(Client *c, Bool invert)
 437 {
 438         int dx = 0, dy = 0;
 439
 440         switch(c->grav) {
 441         case StaticGravity:
 442         case NorthWestGravity:
 443         case NorthGravity:
 444         case NorthEastGravity:
 445                 dy = c->border;
 446                 break;
 447         case EastGravity:
 448         case CenterGravity:
 449         case WestGravity:
 450                 dy = -(c->h / 2) + c->border;
 451                 break;
 452         case SouthEastGravity:
 453         case SouthGravity:
 454         case SouthWestGravity:
 455                 dy = -c->h;
 456                 break;
 457         default:
 458                 break;
 459         }
 460
 461         switch (c->grav) {
 462         case StaticGravity:
 463         case NorthWestGravity:
 464         case WestGravity:
 465         case SouthWestGravity:
 466                 dx = c->border;
 467                 break;
 468         case NorthGravity:
 469         case CenterGravity:
 470         case SouthGravity:
 471                 dx = -(c->w / 2) + c->border;
 472                 break;
 473         case NorthEastGravity:
 474         case EastGravity:
 475         case SouthEastGravity:
 476                 dx = -(c->w + c->border);
 477                 break;
 478         default:
 479                 break;
 480         }
 481
 482         if(invert) {
 483                 dx = -dx;
 484                 dy = -dy;
 485         }
 486         c->x += dx;
 487         c->y += dy;
 488 }
 489
 490
 491 void
 492 resize(Client *c, Bool inc)
 493 {
 494         XConfigureEvent e;
 495
 496         if(inc) {
 497                 if(c->incw)
 498                         c->w -= (c->w - c->basew) % c->incw;
 499                 if(c->inch)
 500                         c->h -= (c->h - c->baseh) % c->inch;
 501         }
 502         if(c->x > sw) /* might happen on restart */
 503                 c->x = sw - c->w;
 504         if(c->y > sh)
 505                 c->ty = c->y = sh - c->h;
 506         if(c->minw && c->w < c->minw)
 507                 c->w = c->minw;
 508         if(c->minh && c->h < c->minh)
 509                 c->h = c->minh;
 510         if(c->maxw && c->w > c->maxw)
 511                 c->w = c->maxw;
 512         if(c->maxh && c->h > c->maxh)
 513                 c->h = c->maxh;
 514         resize_title(c);
 515         XSetWindowBorderWidth(dpy, c->win, 1);
 516         XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h);
 517         e.type = ConfigureNotify;
 518         e.event = c->win;
 519         e.window = c->win;
 520         e.x = c->x;
 521         e.y = c->y;
 522         e.width = c->w;
 523         e.height = c->h;
 524         e.border_width = c->border;
 525         e.above = None;
 526         e.override_redirect = False;
 527         XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&e);
 528         XFlush(dpy);
 529 }
 530
 531 static int
 532 dummy_error_handler(Display *dsply, XErrorEvent *err)
 533 {
 534         return 0;
 535 }
 536
 537 void
 538 unmanage(Client *c)
 539 {
 540         Client **l;
 541
 542         XGrabServer(dpy);
 543         XSetErrorHandler(dummy_error_handler);
 544
 545         XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
 546         XDestroyWindow(dpy, c->title);
 547
 548         for(l = &clients; *l && *l != c; l = &(*l)->next);
 549         *l = c->next;
 550         for(l = &clients; *l; l = &(*l)->next)
 551                 if((*l)->revert == c)
 552                         (*l)->revert = NULL;
 553         if(sel == c)
 554                 sel = sel->revert ? sel->revert : clients;
 555
 556         free(c);
 557
 558         XFlush(dpy);
 559         XSetErrorHandler(error_handler);
 560         XUngrabServer(dpy);
 561         arrange(NULL);
 562         if(sel)
 563                 focus(sel);
 564 }
 565
 566 Client *
 567 gettitle(Window w)
 568 {
 569         Client *c;
 570         for(c = clients; c; c = c->next)
 571                 if(c->title == w)
 572                         return c;
 573         return NULL;
 574 }
 575
 576 Client *
 577 getclient(Window w)
 578 {
 579         Client *c;
 580         for(c = clients; c; c = c->next)
 581                 if(c->win == w)
 582                         return c;
 583         return NULL;
 584 }
 585
 586 void
 587 draw_client(Client *c)
 588 {
 589         int i;
 590         if(c == sel) {
 591                 draw_bar();
 592                 XUnmapWindow(dpy, c->title);
 593                 XSetWindowBorder(dpy, c->win, dc.fg);
 594                 return;
 595         }
 596
 597         XSetWindowBorder(dpy, c->win, dc.bg);
 598         XMapWindow(dpy, c->title);
 599
 600         dc.x = dc.y = 0;
 601
 602         dc.w = 0;
 603         for(i = 0; i < TLast; i++) {
 604                 if(c->tags[i]) {
 605                         dc.x += dc.w;
 606                         dc.w = textw(c->tags[i]) + dc.font.height;
 607                         drawtext(c->tags[i], False, True);
 608                 }
 609         }
 610         dc.x += dc.w;
 611         dc.w = textw(c->name) + dc.font.height;
 612         drawtext(c->name, False, True);
 613         XCopyArea(dpy, dc.drawable, c->title, dc.gc,
 614                         0, 0, c->tw, c->th, 0, 0);
 615         XFlush(dpy);
 616 }