client.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 <stdlib.h>
   6 #include <string.h>
   7 #include <X11/Xatom.h>
   8 #include <X11/Xutil.h>
   9
  10 /* static */
  11
  12 static void
  13 grabbuttons(Client *c, Bool focused) {
  14         XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
  15
  16         if(focused) {
  17                 XGrabButton(dpy, Button1, MODKEY, c->win, False, BUTTONMASK,
  18                                 GrabModeAsync, GrabModeSync, None, None);
  19                 XGrabButton(dpy, Button1, MODKEY | LockMask, c->win, False, BUTTONMASK,
  20                                 GrabModeAsync, GrabModeSync, None, None);
  21                 XGrabButton(dpy, Button1, MODKEY | numlockmask, c->win, False, BUTTONMASK,
  22                                 GrabModeAsync, GrabModeSync, None, None);
  23                 XGrabButton(dpy, Button1, MODKEY | numlockmask | LockMask, c->win, False, BUTTONMASK,
  24                                 GrabModeAsync, GrabModeSync, None, None);
  25
  26                 XGrabButton(dpy, Button2, MODKEY, c->win, False, BUTTONMASK,
  27                                 GrabModeAsync, GrabModeSync, None, None);
  28                 XGrabButton(dpy, Button2, MODKEY | LockMask, c->win, False, BUTTONMASK,
  29                                 GrabModeAsync, GrabModeSync, None, None);
  30                 XGrabButton(dpy, Button2, MODKEY | numlockmask, c->win, False, BUTTONMASK,
  31                                 GrabModeAsync, GrabModeSync, None, None);
  32                 XGrabButton(dpy, Button2, MODKEY | numlockmask | LockMask, c->win, False, BUTTONMASK,
  33                                 GrabModeAsync, GrabModeSync, None, None);
  34
  35                 XGrabButton(dpy, Button3, MODKEY, c->win, False, BUTTONMASK,
  36                                 GrabModeAsync, GrabModeSync, None, None);
  37                 XGrabButton(dpy, Button3, MODKEY | LockMask, c->win, False, BUTTONMASK,
  38                                 GrabModeAsync, GrabModeSync, None, None);
  39                 XGrabButton(dpy, Button3, MODKEY | numlockmask, c->win, False, BUTTONMASK,
  40                                 GrabModeAsync, GrabModeSync, None, None);
  41                 XGrabButton(dpy, Button3, MODKEY | numlockmask | LockMask, c->win, False, BUTTONMASK,
  42                                 GrabModeAsync, GrabModeSync, None, None);
  43         }
  44         else
  45                 XGrabButton(dpy, AnyButton, AnyModifier, c->win, False, BUTTONMASK,
  46                                 GrabModeAsync, GrabModeSync, None, None);
  47 }
  48
  49 static void
  50 setclientstate(Client *c, long state) {
  51         long data[] = {state, None};
  52         XChangeProperty(dpy, c->win, wmatom[WMState], wmatom[WMState], 32,
  53                         PropModeReplace, (unsigned char *)data, 2);
  54 }
  55
  56 static int
  57 xerrordummy(Display *dsply, XErrorEvent *ee) {
  58         return 0;
  59 }
  60
  61 /* extern */
  62
  63 void
  64 attach(Client *c) {
  65         if(clients)
  66                 clients->prev = c;
  67         c->next = clients;
  68         clients = c;
  69 }
  70
  71 void
  72 attachstack(Client *c) {
  73         c->snext = stack;
  74         stack = c;
  75 }
  76
  77 void
  78 configure(Client *c) {
  79         XConfigureEvent ce;
  80
  81         ce.type = ConfigureNotify;
  82         ce.display = dpy;
  83         ce.event = c->win;
  84         ce.window = c->win;
  85         ce.x = c->x;
  86         ce.y = c->y;
  87         ce.width = c->w;
  88         ce.height = c->h;
  89         ce.border_width = c->border;
  90         ce.above = None;
  91         ce.override_redirect = False;
  92         XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ce);
  93 }
  94
  95 void
  96 detach(Client *c) {
  97         if(c->prev)
  98                 c->prev->next = c->next;
  99         if(c->next)
 100                 c->next->prev = c->prev;
 101         if(c == clients)
 102                 clients = c->next;
 103         c->next = c->prev = NULL;
 104 }
 105
 106 void
 107 detachstack(Client *c) {
 108         Client **tc;
 109         for(tc=&stack; *tc && *tc != c; tc=&(*tc)->snext);
 110         *tc = c->snext;
 111 }
 112
 113 void
 114 focus(Client *c) {
 115         if(c && !isvisible(c))
 116                 return;
 117         if(sel && sel != c) {
 118                 grabbuttons(sel, False);
 119                 XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);
 120         }
 121         if(c) {
 122                 detachstack(c);
 123                 attachstack(c);
 124                 grabbuttons(c, True);
 125         }
 126         sel = c;
 127         drawstatus();
 128         if(!selscreen)
 129                 return;
 130         if(c) {
 131                 XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
 132                 XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
 133         }
 134         else
 135                 XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
 136 }
 137
 138 Client *
 139 getclient(Window w) {
 140         Client *c;
 141
 142         for(c = clients; c; c = c->next)
 143                 if(c->win == w)
 144                         return c;
 145         return NULL;
 146 }
 147
 148 Bool
 149 isprotodel(Client *c) {
 150         int i, n;
 151         Atom *protocols;
 152         Bool ret = False;
 153
 154         if(XGetWMProtocols(dpy, c->win, &protocols, &n)) {
 155                 for(i = 0; !ret && i < n; i++)
 156                         if(protocols[i] == wmatom[WMDelete])
 157                                 ret = True;
 158                 XFree(protocols);
 159         }
 160         return ret;
 161 }
 162
 163 void
 164 killclient(Arg *arg) {
 165         if(!sel)
 166                 return;
 167         if(isprotodel(sel))
 168                 sendevent(sel->win, wmatom[WMProtocols], wmatom[WMDelete]);
 169         else
 170                 XKillClient(dpy, sel->win);
 171 }
 172
 173 void
 174 manage(Window w, XWindowAttributes *wa) {
 175         Client *c, *t;
 176         Window trans;
 177         XWindowChanges wc;
 178
 179         c = emallocz(sizeof(Client));
 180         c->tags = emallocz(ntags * sizeof(Bool));
 181         c->win = w;
 182         c->x = wa->x;
 183         c->y = wa->y;
 184         c->w = wa->width;
 185         c->h = wa->height;
 186         if(c->w == sw && c->h == sh) {
 187                 c->border = 0;
 188                 c->x = sx;
 189                 c->y = sy;
 190         }
 191         else {
 192                 c->border = BORDERPX;
 193                 if(c->x + c->w + 2 * c->border > wax + waw)
 194                         c->x = wax + waw - c->w - 2 * c->border;
 195                 if(c->y + c->h + 2 * c->border > way + wah)
 196                         c->y = way + wah - c->h - 2 * c->border;
 197                 if(c->x < wax)
 198                         c->x = wax;
 199                 if(c->y < way)
 200                         c->y = way;
 201         }
 202         updatesizehints(c);
 203         XSelectInput(dpy, c->win,
 204                 StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
 205         XGetTransientForHint(dpy, c->win, &trans);
 206         grabbuttons(c, False);
 207         wc.border_width = c->border;
 208         XConfigureWindow(dpy, c->win, CWBorderWidth, &wc);
 209         XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]);
 210         configure(c); /* propagates border_width, if size doesn't change */
 211         updatetitle(c);
 212         t = getclient(trans);
 213         settags(c, t);
 214         if(!c->isfloat)
 215                 c->isfloat = (t != 0) || c->isfixed;
 216         attach(c);
 217         attachstack(c);
 218         c->isbanned = True;
 219         XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
 220         XMapWindow(dpy, c->win);
 221         setclientstate(c, NormalState);
 222         if(isvisible(c))
 223                 focus(c);
 224         arrange();
 225 }
 226
 227 void
 228 resize(Client *c, int x, int y, int w, int h, Bool sizehints) {
 229         float actual, dx, dy, max, min;
 230         XWindowChanges wc;
 231
 232         if(w <= 0 || h <= 0)
 233                 return;
 234         if(sizehints) {
 235                 if(c->minw && w < c->minw)
 236                         w = c->minw;
 237                 if(c->minh && h < c->minh)
 238                         h = c->minh;
 239                 if(c->maxw && w > c->maxw)
 240                         w = c->maxw;
 241                 if(c->maxh && h > c->maxh)
 242                         h = c->maxh;
 243                 /* inspired by algorithm from fluxbox */
 244                 if(c->minay > 0 && c->maxay && (h - c->baseh) > 0) {
 245                         dx = (float)(w - c->basew);
 246                         dy = (float)(h - c->baseh);
 247                         min = (float)(c->minax) / (float)(c->minay);
 248                         max = (float)(c->maxax) / (float)(c->maxay);
 249                         actual = dx / dy;
 250                         if(max > 0 && min > 0 && actual > 0) {
 251                                 if(actual < min) {
 252                                         dy = (dx * min + dy) / (min * min + 1);
 253                                         dx = dy * min;
 254                                         w = (int)dx + c->basew;
 255                                         h = (int)dy + c->baseh;
 256                                 }
 257                                 else if(actual > max) {
 258                                         dy = (dx * min + dy) / (max * max + 1);
 259                                         dx = dy * min;
 260                                         w = (int)dx + c->basew;
 261                                         h = (int)dy + c->baseh;
 262                                 }
 263                         }
 264                 }
 265                 if(c->incw)
 266                         w -= (w - c->basew) % c->incw;
 267                 if(c->inch)
 268                         h -= (h - c->baseh) % c->inch;
 269         }
 270         if(w == sw && h == sh)
 271                 c->border = 0;
 272         else
 273                 c->border = BORDERPX;
 274         /* offscreen appearance fixes */
 275         if(x > sw)
 276                 x = sw - w - 2 * c->border;
 277         if(y > sh)
 278                 y = sh - h - 2 * c->border;
 279         if(x + w + 2 * c->border < sx)
 280                 x = sx;
 281         if(y + h + 2 * c->border < sy)
 282                 y = sy;
 283         if(c->x != x || c->y != y || c->w != w || c->h != h) {
 284                 c->x = wc.x = x;
 285                 c->y = wc.y = y;
 286                 c->w = wc.width = w;
 287                 c->h = wc.height = h;
 288                 wc.border_width = c->border;
 289                 XConfigureWindow(dpy, c->win, CWX | CWY | CWWidth | CWHeight | CWBorderWidth, &wc);
 290                 configure(c);
 291                 XSync(dpy, False);
 292         }
 293 }
 294
 295 void
 296 updatesizehints(Client *c) {
 297         long msize;
 298         XSizeHints size;
 299
 300         if(!XGetWMNormalHints(dpy, c->win, &size, &msize) || !size.flags)
 301                 size.flags = PSize;
 302         c->flags = size.flags;
 303         if(c->flags & PBaseSize) {
 304                 c->basew = size.base_width;
 305                 c->baseh = size.base_height;
 306         }
 307         else
 308                 c->basew = c->baseh = 0;
 309         if(c->flags & PResizeInc) {
 310                 c->incw = size.width_inc;
 311                 c->inch = size.height_inc;
 312         }
 313         else
 314                 c->incw = c->inch = 0;
 315         if(c->flags & PMaxSize) {
 316                 c->maxw = size.max_width;
 317                 c->maxh = size.max_height;
 318         }
 319         else
 320                 c->maxw = c->maxh = 0;
 321         if(c->flags & PMinSize) {
 322                 c->minw = size.min_width;
 323                 c->minh = size.min_height;
 324         }
 325         else
 326                 c->minw = c->minh = 0;
 327         if(c->flags & PAspect) {
 328                 c->minax = size.min_aspect.x;
 329                 c->minay = size.min_aspect.y;
 330                 c->maxax = size.max_aspect.x;
 331                 c->maxay = size.max_aspect.y;
 332         }
 333         else
 334                 c->minax = c->minay = c->maxax = c->maxay = 0;
 335         c->isfixed = (c->maxw && c->minw && c->maxh && c->minh
 336                         && c->maxw == c->minw && c->maxh == c->minh);
 337 }
 338
 339 void
 340 updatetitle(Client *c) {
 341         char **list = NULL;
 342         int n;
 343         XTextProperty name;
 344
 345         name.nitems = 0;
 346         c->name[0] = 0;
 347         XGetTextProperty(dpy, c->win, &name, netatom[NetWMName]);
 348         if(!name.nitems)
 349                 XGetWMName(dpy, c->win, &name);
 350         if(!name.nitems)
 351                 return;
 352         if(name.encoding == XA_STRING)
 353                 strncpy(c->name, (char *)name.value, sizeof c->name);
 354         else {
 355                 if(XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Success
 356                 && n > 0 && *list)
 357                 {
 358                         strncpy(c->name, *list, sizeof c->name);
 359                         XFreeStringList(list);
 360                 }
 361         }
 362         XFree(name.value);
 363 }
 364
 365 void
 366 unmanage(Client *c) {
 367         Client *nc;
 368
 369         /* The server grab construct avoids race conditions. */
 370         XGrabServer(dpy);
 371         XSetErrorHandler(xerrordummy);
 372         detach(c);
 373         detachstack(c);
 374         if(sel == c) {
 375                 for(nc = stack; nc && !isvisible(nc); nc = nc->snext);
 376                 focus(nc);
 377         }
 378         XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
 379         setclientstate(c, WithdrawnState);
 380         free(c->tags);
 381         free(c);
 382         XSync(dpy, False);
 383         XSetErrorHandler(xerror);
 384         XUngrabServer(dpy);
 385         arrange();
 386 }