client.c

   1 /*
   2  * client.c - client management
   3  *
   4  * Copyright © 2007 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <X11/Xatom.h>
  24 #include <X11/Xutil.h>
  25 #include <X11/extensions/shape.h>
  26
  27 #include "screen.h"
  28 #include "awesome.h"
  29 #include "layout.h"
  30 #include "tag.h"
  31
  32 #include "layouts/floating.h"
  33
  34 /* extern */
  35 extern Client *clients, *sel, *stack;   /* global client list and stack */
  36
  37 /** Attach client stack to clients stacks
  38  * \param c the client
  39  */
  40 static inline void
  41 attachstack(Client * c)
  42 {
  43     c->snext = stack;
  44     stack = c;
  45 }
  46
  47 /** Detach client from stack
  48  * \param c the client
  49  */
  50 static inline void
  51 detachstack(Client * c)
  52 {
  53     Client **tc;
  54
  55     for(tc = &stack; *tc && *tc != c; tc = &(*tc)->snext);
  56     *tc = c->snext;
  57 }
  58
  59 /** Grab or ungrab buttons when a client is focused
  60  * \param c client
  61  * \param focused True if client is focused
  62  * \param modkey Mod key mask
  63  * \param numlockmask Numlock mask
  64  */
  65 static void
  66 grabbuttons(Client * c, Bool focused, KeySym modkey, unsigned int numlockmask)
  67 {
  68     XUngrabButton(c->display, AnyButton, AnyModifier, c->win);
  69
  70     if(focused)
  71     {
  72         XGrabButton(c->display, Button1, modkey, c->win, False, BUTTONMASK,
  73                     GrabModeAsync, GrabModeSync, None, None);
  74         XGrabButton(c->display, Button1, modkey | LockMask, c->win, False,
  75                     BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  76         XGrabButton(c->display, Button1, modkey | numlockmask, c->win, False,
  77                     BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  78         XGrabButton(c->display, Button1, modkey | numlockmask | LockMask,
  79                     c->win, False, BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  80
  81         XGrabButton(c->display, Button2, modkey, c->win, False, BUTTONMASK,
  82                     GrabModeAsync, GrabModeSync, None, None);
  83         XGrabButton(c->display, Button2, modkey | LockMask, c->win, False,
  84                     BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  85         XGrabButton(c->display, Button2, modkey | numlockmask, c->win, False,
  86                     BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  87         XGrabButton(c->display, Button2, modkey | numlockmask | LockMask,
  88                     c->win, False, BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  89
  90         XGrabButton(c->display, Button3, modkey, c->win, False, BUTTONMASK,
  91                     GrabModeAsync, GrabModeSync, None, None);
  92         XGrabButton(c->display, Button3, modkey | LockMask, c->win, False,
  93                     BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  94         XGrabButton(c->display, Button3, modkey | numlockmask, c->win, False,
  95                     BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  96         XGrabButton(c->display, Button3, modkey | numlockmask | LockMask,
  97                     c->win, False, BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
  98
  99         XUngrabButton(c->display, AnyButton, AnyModifier, DefaultRootWindow(c->display));
 100     }
 101     else
 102     {
 103         XGrabButton(c->display, AnyButton, AnyModifier, c->win, False, BUTTONMASK,
 104                     GrabModeAsync, GrabModeSync, None, None);
 105         XGrabButton(c->display, Button4, NoSymbol, DefaultRootWindow(c->display), False, BUTTONMASK,
 106                     GrabModeAsync, GrabModeSync, None, None);
 107         XGrabButton(c->display, Button4, LockMask, DefaultRootWindow(c->display), False, BUTTONMASK,
 108                     GrabModeAsync, GrabModeSync, None, None);
 109         XGrabButton(c->display, Button4, numlockmask, DefaultRootWindow(c->display), False, BUTTONMASK,
 110                     GrabModeAsync, GrabModeSync, None, None);
 111         XGrabButton(c->display, Button4, numlockmask | LockMask, DefaultRootWindow(c->display), False, BUTTONMASK,
 112                     GrabModeAsync, GrabModeSync, None, None);
 113
 114         XGrabButton(c->display, Button5, NoSymbol, DefaultRootWindow(c->display), False, BUTTONMASK,
 115                     GrabModeAsync, GrabModeSync, None, None);
 116         XGrabButton(c->display, Button5, LockMask, DefaultRootWindow(c->display), False, BUTTONMASK,
 117                     GrabModeAsync, GrabModeSync, None, None);
 118         XGrabButton(c->display, Button5, numlockmask, DefaultRootWindow(c->display), False, BUTTONMASK,
 119                     GrabModeAsync, GrabModeSync, None, None);
 120         XGrabButton(c->display, Button5, numlockmask | LockMask, DefaultRootWindow(c->display), False, BUTTONMASK,
 121                     GrabModeAsync, GrabModeSync, None, None);
 122
 123     }
 124 }
 125
 126 /** Check if client supports protocol WM_DELETE_WINDOW
 127  * \param c the client
 128  * \return True if client has WM_DELETE_WINDOW
 129  */
 130 static Bool
 131 isprotodel(Client * c)
 132 {
 133     int i, n;
 134     Atom *protocols;
 135     Bool ret = False;
 136
 137     if(XGetWMProtocols(c->display, c->win, &protocols, &n))
 138     {
 139         for(i = 0; !ret && i < n; i++)
 140             if(protocols[i] == XInternAtom(c->display, "WM_DELETE_WINDOW", False))
 141                 ret = True;
 142         XFree(protocols);
 143     }
 144     return ret;
 145 }
 146
 147 /** Set client WM_STATE property
 148  * \param c the client
 149  * \param state no idea
 150  */
 151 static void
 152 setclientstate(Client * c, long state)
 153 {
 154     long data[] = { state, None };
 155
 156     XChangeProperty(c->display, c->win, XInternAtom(c->display, "WM_STATE", False),
 157                     XInternAtom(c->display, "WM_STATE", False),  32,
 158                     PropModeReplace, (unsigned char *) data, 2);
 159 }
 160
 161 /** Set client transparency using composite
 162  * \param c client
 163  * \param opacity opacity percentage
 164  */
 165 static void
 166 setclienttrans(Client *c, double opacity)
 167 {
 168     unsigned int real_opacity = 0xffffffff;
 169
 170     if(opacity >= 0 && opacity <= 100)
 171     {
 172         real_opacity = ((opacity / 100.0) * 0xffffffff);
 173         XChangeProperty(c->display, c->win,
 174                         XInternAtom(c->display, "_NET_WM_WINDOW_OPACITY", False),
 175                         XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &real_opacity, 1L);
 176     }
 177     else
 178         XDeleteProperty(c->display, c->win, XInternAtom(c->display, "_NET_WM_WINDOW_OPACITY", False));
 179
 180     XSync(c->display, False);
 181 }
 182
 183 /** Attach client to the beginning of the clients stack
 184  * \param c the client
 185  */
 186 inline void
 187 attach(Client * c)
 188 {
 189     if(clients)
 190         clients->prev = c;
 191     c->next = clients;
 192     clients = c;
 193 }
 194
 195 inline void
 196 updatetitle(Client * c)
 197 {
 198     if(!xgettextprop(c->display, c->win, XInternAtom(c->display, "_NET_WM_NAME", False), c->name, sizeof c->name))
 199         xgettextprop(c->display, c->win, XInternAtom(c->display, "WM_NAME", False), c->name, sizeof c->name);
 200 }
 201
 202 /** Ban client
 203  * \param c the client
 204  */
 205 void
 206 ban(Client * c)
 207 {
 208     if(c->isbanned)
 209         return;
 210     XUnmapWindow(c->display, c->win);
 211     setclientstate(c, IconicState);
 212     c->isbanned = True;
 213     c->unmapped++;
 214 }
 215
 216 /** Configure client
 217  * \param c the client
 218  */
 219 void
 220 configure(Client * c)
 221 {
 222     XConfigureEvent ce;
 223
 224     ce.type = ConfigureNotify;
 225     ce.display = c->display;
 226     ce.event = c->win;
 227     ce.window = c->win;
 228     ce.x = c->x;
 229     ce.y = c->y;
 230     ce.width = c->w;
 231     ce.height = c->h;
 232     ce.border_width = c->border;
 233     ce.above = None;
 234     ce.override_redirect = False;
 235     XSendEvent(c->display, c->win, False, StructureNotifyMask, (XEvent *) & ce);
 236 }
 237
 238 void
 239 detach(Client * c)
 240 {
 241     if(c->prev)
 242         c->prev->next = c->next;
 243     if(c->next)
 244         c->next->prev = c->prev;
 245     if(c == clients)
 246         clients = c->next;
 247     c->next = c->prev = NULL;
 248 }
 249
 250 /** Give focus to client, or to first client if c is NULL
 251  * \param disp Display ref
 252  * \param drawcontext drawcontext ref
 253  * \param c client
 254  * \param selscreen True if current screen is selected
 255  * \param awesomeconf awesome config
 256  */
 257 void
 258 focus(Display *disp, DC *drawcontext, Client * c, Bool selscreen, awesome_config *awesomeconf)
 259 {
 260     /* if c is NULL or invisible, take next client in the stack */
 261     if((!c && selscreen) || (c && !isvisible(c, awesomeconf->selected_tags, awesomeconf->ntags)))
 262         for(c = stack; c && !isvisible(c, awesomeconf->selected_tags, awesomeconf->ntags); c = c->snext);
 263
 264     /* if a client was selected but it's not the current client, unfocus it */
 265     if(sel && sel != c)
 266     {
 267         grabbuttons(sel, False, awesomeconf->modkey, awesomeconf->numlockmask);
 268         XSetWindowBorder(sel->display, sel->win, drawcontext->norm[ColBorder]);
 269         setclienttrans(sel, awesomeconf->opacity_unfocused);
 270     }
 271     if(c)
 272     {
 273         detachstack(c);
 274         attachstack(c);
 275         grabbuttons(c, True, awesomeconf->modkey, awesomeconf->numlockmask);
 276     }
 277     if(!selscreen)
 278         return;
 279     sel = c;
 280     drawstatus(disp, drawcontext, awesomeconf);
 281     if(sel)
 282     {
 283         XSetWindowBorder(sel->display, sel->win, drawcontext->sel[ColBorder]);
 284         XSetInputFocus(sel->display, sel->win, RevertToPointerRoot, CurrentTime);
 285         for(c = stack; c; c = c->snext)
 286             if(c != sel)
 287                 setclienttrans(c, awesomeconf->opacity_unfocused);
 288         setclienttrans(sel, -1);
 289     }
 290     else
 291         XSetInputFocus(disp, DefaultRootWindow(disp), RevertToPointerRoot, CurrentTime);
 292 }
 293
 294 /** Kill selected client
 295  * \param disp Display ref
 296  * \param awesomeconf awesome config
 297  * \param arg unused
 298  * \ingroup ui_callback
 299  */
 300 void
 301 uicb_killclient(Display *disp __attribute__ ((unused)),
 302                 DC *drawcontext __attribute__ ((unused)),
 303                 awesome_config *awesomeconf __attribute__ ((unused)),
 304                 const char *arg __attribute__ ((unused)))
 305 {
 306     XEvent ev;
 307
 308     if(!sel)
 309         return;
 310     if(isprotodel(sel))
 311     {
 312         ev.type = ClientMessage;
 313         ev.xclient.window = sel->win;
 314         ev.xclient.message_type = XInternAtom(disp, "WM_PROTOCOLS", False);
 315         ev.xclient.format = 32;
 316         ev.xclient.data.l[0] = XInternAtom(disp, "WM_DELETE_WINDOW", False);
 317         ev.xclient.data.l[1] = CurrentTime;
 318         XSendEvent(sel->display, sel->win, False, NoEventMask, &ev);
 319     }
 320     else
 321         XKillClient(sel->display, sel->win);
 322 }
 323
 324 static Bool
 325 loadprops(Client * c, int ntags)
 326 {
 327     int i;
 328     char *prop;
 329     Bool result = False;
 330
 331     prop = p_new(char, ntags + 2);
 332
 333     if(xgettextprop(c->display, c->win, AWESOMEPROPS_ATOM(c->display), prop, ntags + 2))
 334     {
 335         for(i = 0; i < ntags && prop[i]; i++)
 336             if((c->tags[i] = prop[i] == '1'))
 337                 result = True;
 338         if(i <= ntags && prop[i])
 339             c->isfloating = prop[i] == '1';
 340     }
 341
 342     p_delete(&prop);
 343
 344     return result;
 345 }
 346
 347 void
 348 manage(Display * disp, DC *drawcontext, Window w, XWindowAttributes * wa, awesome_config *awesomeconf)
 349 {
 350     int i;
 351     Client *c, *t = NULL;
 352     Window trans;
 353     Status rettrans;
 354     XWindowChanges wc;
 355
 356     c = p_new(Client, 1);
 357     c->tags = p_new(Bool, awesomeconf->ntags);
 358     c->win = w;
 359     c->ftview = True;
 360     c->x = c->rw = wa->x;
 361     c->y = c->ry = wa->y;
 362     c->w = c->rw = wa->width;
 363     c->h = c->rh = wa->height;
 364     c->oldborder = wa->border_width;
 365     c->display = disp;
 366     if(c->w == DisplayWidth(disp, DefaultScreen(disp))
 367        && c->h == DisplayHeight(disp, DefaultScreen(disp)))
 368     {
 369         c->x = 0;
 370         c->y = 0;
 371         c->border = wa->border_width;
 372     }
 373     else
 374     {
 375         ScreenInfo *si = get_display_info(disp, awesomeconf->statusbar);
 376
 377         if(c->x + c->w + 2 * c->border > si->x_org + si->width)
 378             c->x = c->rx = si->x_org + si->width - c->w - 2 * c->border;
 379         if(c->y + c->h + 2 * c->border > si->y_org + si->height)
 380             c->y = c->ry = si->y_org + si->height - c->h - 2 * c->border;
 381         if(c->x < si->x_org)
 382             c->x = c->rx = si->x_org;
 383         if(c->y < si->y_org)
 384             c->y = c->ry = si->y_org;
 385         c->border = awesomeconf->borderpx;
 386         XFree(si);
 387     }
 388     wc.border_width = c->border;
 389     XConfigureWindow(disp, w, CWBorderWidth, &wc);
 390     XSetWindowBorder(disp, w, drawcontext->norm[ColBorder]);
 391     configure(c);               /* propagates border_width, if size doesn't change */
 392     updatesizehints(c);
 393     XSelectInput(disp, w, StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
 394     if(awesomeconf->have_shape)
 395     {
 396         XShapeSelectInput(disp, w, ShapeNotifyMask);
 397         set_shape(c);
 398     }
 399     grabbuttons(c, False, awesomeconf->modkey, awesomeconf->numlockmask);
 400     updatetitle(c);
 401     if((rettrans = XGetTransientForHint(disp, w, &trans) == Success))
 402         for(t = clients; t && t->win != trans; t = t->next);
 403     if(t)
 404         for(i = 0; i < awesomeconf->ntags; i++)
 405             c->tags[i] = t->tags[i];
 406     if(!loadprops(c, awesomeconf->ntags))
 407         applyrules(c, awesomeconf);
 408     if(!c->isfloating)
 409         c->isfloating = (rettrans == Success) || c->isfixed;
 410     saveprops(c, awesomeconf->ntags);
 411     attach(c);
 412     attachstack(c);
 413     XMoveResizeWindow(disp, c->win, c->x, c->y, c->w, c->h);     /* some windows require this */
 414     ban(c);
 415     arrange(disp, drawcontext, awesomeconf);
 416 }
 417
 418 void
 419 resize(Client * c, int x, int y, int w, int h, Bool sizehints)
 420 {
 421     double dx, dy, max, min, ratio;
 422     XWindowChanges wc;
 423
 424     if(sizehints)
 425     {
 426         if(c->minay > 0 && c->maxay > 0 && (h - c->baseh) > 0 && (w - c->basew) > 0)
 427         {
 428             dx = (double) (w - c->basew);
 429             dy = (double) (h - c->baseh);
 430             min = (double) (c->minax) / (double) (c->minay);
 431             max = (double) (c->maxax) / (double) (c->maxay);
 432             ratio = dx / dy;
 433             if(max > 0 && min > 0 && ratio > 0)
 434             {
 435                 if(ratio < min)
 436                 {
 437                     dy = (dx * min + dy) / (min * min + 1);
 438                     dx = dy * min;
 439                     w = (int) dx + c->basew;
 440                     h = (int) dy + c->baseh;
 441                 }
 442                 else if(ratio > max)
 443                 {
 444                     dy = (dx * min + dy) / (max * max + 1);
 445                     dx = dy * min;
 446                     w = (int) dx + c->basew;
 447                     h = (int) dy + c->baseh;
 448                 }
 449             }
 450         }
 451         if(c->minw && w < c->minw)
 452             w = c->minw;
 453         if(c->minh && h < c->minh)
 454             h = c->minh;
 455         if(c->maxw && w > c->maxw)
 456             w = c->maxw;
 457         if(c->maxh && h > c->maxh)
 458             h = c->maxh;
 459         if(c->incw)
 460             w -= (w - c->basew) % c->incw;
 461         if(c->inch)
 462             h -= (h - c->baseh) % c->inch;
 463     }
 464     if(w <= 0 || h <= 0)
 465         return;
 466     /* offscreen appearance fixes */
 467     if(x > DisplayWidth(c->display, DefaultScreen(c->display)))
 468         x = DisplayWidth(c->display, DefaultScreen(c->display)) - w - 2 * c->border;
 469     if(y > DisplayHeight(c->display, DefaultScreen(c->display)))
 470         y = DisplayHeight(c->display, DefaultScreen(c->display)) - h - 2 * c->border;
 471     if(x + w + 2 * c->border < 0)
 472         x = 0;
 473     if(y + h + 2 * c->border < 0)
 474         y = 0;
 475     if(c->x != x || c->y != y || c->w != w || c->h != h)
 476     {
 477         c->x = wc.x = x;
 478         c->y = wc.y = y;
 479         c->w = wc.width = w;
 480         c->h = wc.height = h;
 481         wc.border_width = c->border;
 482         XConfigureWindow(c->display, c->win, CWX | CWY | CWWidth | CWHeight | CWBorderWidth, &wc);
 483         configure(c);
 484         XSync(c->display, False);
 485     }
 486 }
 487
 488 void
 489 uicb_moveresize(Display *disp __attribute__ ((unused)),
 490                 DC *drawcontext __attribute__ ((unused)),
 491                 awesome_config *awesomeconf,
 492                 const char *arg)
 493 {
 494     int x, y, w, h, nx, ny, nw, nh, ox, oy, ow, oh;
 495     char xabs, yabs, wabs, habs;
 496     int mx, my, dx, dy, nmx, nmy;
 497     unsigned int dui;
 498     Window dummy;
 499
 500     if(!IS_ARRANGE(floating))
 501         if(!sel || !sel->isfloating || sel->isfixed || !arg)
 502             return;
 503     if(sscanf(arg, "%d%c %d%c %d%c %d%c", &x, &xabs, &y, &yabs, &w, &wabs, &h, &habs) != 8)
 504         return;
 505     nx = xabs == 'x' ? sel->x + x : x;
 506     ny = yabs == 'y' ? sel->y + y : y;
 507     nw = wabs == 'w' ? sel->w + w : w;
 508     nh = habs == 'h' ? sel->h + h : h;
 509
 510     ox = sel->x;
 511     oy = sel->y;
 512     ow = sel->w;
 513     oh = sel->h;
 514
 515     Bool xqp = XQueryPointer(sel->display, DefaultRootWindow(sel->display), &dummy, &dummy, &mx, &my, &dx, &dy, &dui);
 516     resize(sel, nx, ny, nw, nh, True);
 517     if (xqp && ox <= mx && (ox + ow) >= mx && oy <= my && (oy + oh) >= my)
 518     {
 519         nmx = mx-ox+sel->w-ow-1 < 0 ? 0 : mx-ox+sel->w-ow-1;
 520         nmy = my-oy+sel->h-oh-1 < 0 ? 0 : my-oy+sel->h-oh-1;
 521         XWarpPointer(sel->display, None, sel->win, 0, 0, 0, 0, nmx, nmy);
 522     }
 523 }
 524
 525 void
 526 saveprops(Client * c, int ntags)
 527 {
 528     int i;
 529     char *prop;
 530
 531     prop = p_new(char, ntags + 2);
 532
 533     for(i = 0; i < ntags; i++)
 534         prop[i] = c->tags[i] ? '1' : '0';
 535
 536     if(i <= ntags)
 537         prop[i] = c->isfloating ? '1' : '0';
 538
 539     prop[++i] = '\0';
 540
 541     XChangeProperty(c->display, c->win, AWESOMEPROPS_ATOM(c->display), XA_STRING, 8,
 542                     PropModeReplace, (unsigned char *) prop, i);
 543
 544     p_delete(&prop);
 545 }
 546
 547 void
 548 unban(Client * c)
 549 {
 550     if(!c->isbanned)
 551         return;
 552     XMapWindow(c->display, c->win);
 553     setclientstate(c, NormalState);
 554     c->isbanned = False;
 555 }
 556
 557 void
 558 unmanage(Client * c, DC *drawcontext, long state, awesome_config *awesomeconf)
 559 {
 560     XWindowChanges wc;
 561
 562     wc.border_width = c->oldborder;
 563     /* The server grab construct avoids race conditions. */
 564     XGrabServer(c->display);
 565     XConfigureWindow(c->display, c->win, CWBorderWidth, &wc);  /* restore border */
 566     detach(c);
 567     detachstack(c);
 568     if(sel == c)
 569         focus(c->display, drawcontext, NULL, True, awesomeconf);
 570     XUngrabButton(c->display, AnyButton, AnyModifier, c->win);
 571     setclientstate(c, state);
 572     XSync(c->display, False);
 573     XSetErrorHandler(xerror);
 574     XUngrabServer(c->display);
 575     if(state != NormalState)
 576         arrange(c->display, drawcontext, awesomeconf);
 577     p_delete(&c->tags);
 578     p_delete(&c);
 579 }
 580
 581 void
 582 updatesizehints(Client * c)
 583 {
 584     long msize;
 585     XSizeHints size;
 586
 587     if(!XGetWMNormalHints(c->display, c->win, &size, &msize) || !size.flags)
 588         size.flags = PSize;
 589     c->flags = size.flags;
 590     if(c->flags & PBaseSize)
 591     {
 592         c->basew = size.base_width;
 593         c->baseh = size.base_height;
 594     }
 595     else if(c->flags & PMinSize)
 596     {
 597         c->basew = size.min_width;
 598         c->baseh = size.min_height;
 599     }
 600     else
 601         c->basew = c->baseh = 0;
 602     if(c->flags & PResizeInc)
 603     {
 604         c->incw = size.width_inc;
 605         c->inch = size.height_inc;
 606     }
 607     else
 608         c->incw = c->inch = 0;
 609
 610     if(c->flags & PMaxSize)
 611     {
 612         c->maxw = size.max_width;
 613         c->maxh = size.max_height;
 614     }
 615     else
 616         c->maxw = c->maxh = 0;
 617
 618     if(c->flags & PMinSize)
 619     {
 620         c->minw = size.min_width;
 621         c->minh = size.min_height;
 622     }
 623     else if(c->flags & PBaseSize)
 624     {
 625         c->minw = size.base_width;
 626         c->minh = size.base_height;
 627     }
 628     else
 629         c->minw = c->minh = 0;
 630
 631     if(c->flags & PAspect)
 632     {
 633         c->minax = size.min_aspect.x;
 634         c->maxax = size.max_aspect.x;
 635         c->minay = size.min_aspect.y;
 636         c->maxay = size.max_aspect.y;
 637     }
 638     else
 639         c->minax = c->maxax = c->minay = c->maxay = 0;
 640
 641     c->isfixed = (c->maxw && c->minw && c->maxh && c->minh
 642                   && c->maxw == c->minw && c->maxh == c->minh);
 643 }
 644
 645 void
 646 set_shape(Client *c)
 647 {
 648     int bounding_shaped;
 649     int i, b;  unsigned int u;  /* dummies */
 650     /* Logic to decide if we have a shaped window cribbed from fvwm-2.5.10. */
 651     if (XShapeQueryExtents(c->display, c->win, &bounding_shaped, &i, &i,
 652                            &u, &u, &b, &i, &i, &u, &u) && bounding_shaped)
 653         XShapeCombineShape(c->display, DefaultRootWindow(c->display), ShapeBounding, 0, 0, c->win, ShapeBounding, ShapeSet);
 654 }
 655
 656 void
 657 uicb_settrans(Display *disp __attribute__ ((unused)),
 658               DC *drawcontext __attribute__ ((unused)),
 659               awesome_config *awesomeconf __attribute__ ((unused)),
 660               const char *arg)
 661 {
 662     double delta = 100.0, current_opacity = 0.0;
 663     unsigned char *data;
 664     Atom actual;
 665     int format;
 666     unsigned long n, left;
 667     unsigned int current_opacity_raw = 0;
 668     int set_prop = 0;
 669
 670     if(!sel)
 671         return;
 672
 673     XGetWindowProperty(sel->display, sel->win, XInternAtom(sel->display, "_NET_WM_WINDOW_OPACITY", False),
 674                        0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left,
 675                        (unsigned char **) &data);
 676     if(data)
 677     {
 678         memcpy(&current_opacity_raw, data, sizeof(unsigned int));
 679         XFree(data);
 680         current_opacity = (current_opacity_raw * 100.0) / 0xffffffff;
 681     }
 682     else
 683         set_prop = 1;
 684
 685     delta = compute_new_value_from_arg(arg, current_opacity);
 686
 687     if(delta <= 0.0)
 688         delta = 0.0;
 689     else if(delta > 100.0)
 690     {
 691         delta = 100.0;
 692         set_prop = 1;
 693     }
 694
 695     if(delta == 100.0 && !set_prop)
 696         setclienttrans(sel, -1);
 697     else
 698         setclienttrans(sel, delta);
 699 }