openbox/client.c

   1 #include "client.h"
   2 #include "screen.h"
   3 #include "prop.h"
   4 #include "extensions.h"
   5 #include "frame.h"
   6 #include "engine.h"
   7 #include "event.h"
   8 #include "focus.h"
   9 #include "stacking.h"
  10 #include "pointer.h"
  11 #include "hooks.h"
  12 #include "openboxwrap.h"
  13 #include "clientwrap.h"
  14
  15 #include <X11/Xutil.h>
  16
  17 /*! The event mask to grab on client windows */
  18 #define CLIENT_EVENTMASK (PropertyChangeMask | FocusChangeMask | \
  19                           StructureNotifyMask)
  20
  21 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
  22                                 ButtonMotionMask)
  23
  24 GSList     *client_list      = NULL;
  25 GHashTable *client_map       = NULL;
  26
  27 static void client_get_all(Client *self);
  28 static void client_toggle_border(Client *self, gboolean show);
  29 static void client_get_area(Client *self);
  30 static void client_get_desktop(Client *self);
  31 static void client_get_state(Client *self);
  32 static void client_get_shaped(Client *self);
  33 static void client_get_mwm_hints(Client *self);
  34 static void client_get_gravity(Client *self);
  35 static void client_change_allowed_actions(Client *self);
  36 static void client_change_state(Client *self);
  37 static Client *search_focus_tree(Client *node, Client *skip);
  38 static void client_apply_startup_state(Client *self);
  39 static Client *search_modal_tree(Client *node, Client *skip);
  40
  41 static guint map_hash(Window w) { return w; }
  42 static gboolean map_key_comp(Window w1, Window w2) { return w1 == w2; }
  43
  44 void client_startup()
  45 {
  46     client_map = g_hash_table_new((GHashFunc)map_hash,
  47                                   (GEqualFunc)map_key_comp);
  48     client_set_list();
  49 }
  50
  51 void client_shutdown()
  52 {
  53     g_hash_table_destroy(client_map);
  54 }
  55
  56 void client_set_list()
  57 {
  58     Window *windows, *win_it;
  59     GSList *it;
  60     guint size = g_slist_length(client_list);
  61
  62     /* create an array of the window ids */
  63     if (size > 0) {
  64         windows = g_new(Window, size);
  65         win_it = windows;
  66         for (it = client_list; it != NULL; it = it->next, ++win_it)
  67             *win_it = ((Client*)it->data)->window;
  68     } else
  69         windows = NULL;
  70
  71     PROP_SET32A(ob_root, net_client_list, window, windows, size);
  72
  73     if (windows)
  74         g_free(windows);
  75
  76     stacking_set_list();
  77 }
  78
  79 void client_manage_all()
  80 {
  81     unsigned int i, j, nchild;
  82     Window w, *children;
  83     XWMHints *wmhints;
  84     XWindowAttributes attrib;
  85
  86     XQueryTree(ob_display, ob_root, &w, &w, &children, &nchild);
  87
  88     /* remove all icon windows from the list */
  89     for (i = 0; i < nchild; i++) {
  90         if (children[i] == None) continue;
  91         wmhints = XGetWMHints(ob_display, children[i]);
  92         if (wmhints) {
  93             if ((wmhints->flags & IconWindowHint) &&
  94                 (wmhints->icon_window != children[i]))
  95                 for (j = 0; j < nchild; j++)
  96                     if (children[j] == wmhints->icon_window) {
  97                         children[j] = None;
  98                         break;
  99                     }
 100             XFree(wmhints);
 101         }
 102     }
 103
 104     for (i = 0; i < nchild; ++i) {
 105         if (children[i] == None)
 106             continue;
 107         if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
 108             if (attrib.override_redirect) continue;
 109
 110             if (attrib.map_state != IsUnmapped)
 111                 client_manage(children[i]);
 112         }
 113     }
 114     XFree(children);
 115 }
 116
 117 void client_manage(Window window)
 118 {
 119     Client *client;
 120     XEvent e;
 121     XWindowAttributes attrib;
 122     XSetWindowAttributes attrib_set;
 123 /*    XWMHints *wmhint; */
 124     PyObject *cw;
 125
 126     XGrabServer(ob_display);
 127     XSync(ob_display, FALSE);
 128
 129     /* check if it has already been unmapped by the time we started mapping
 130        the grab does a sync so we don't have to here */
 131     if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
 132         XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e)) {
 133         XPutBackEvent(ob_display, &e);
 134
 135         XUngrabServer(ob_display);
 136         XFlush(ob_display);
 137         return; /* don't manage it */
 138     }
 139
 140     /* make sure it isn't an override-redirect window */
 141     if (!XGetWindowAttributes(ob_display, window, &attrib) ||
 142         attrib.override_redirect) {
 143         XUngrabServer(ob_display);
 144         XFlush(ob_display);
 145         return; /* don't manage it */
 146     }
 147
 148 /*    /\* is the window a docking app *\/
 149     if ((wmhint = XGetWMHints(ob_display, window))) {
 150         if ((wmhint->flags & StateHint) &&
 151             wmhint->initial_state == WithdrawnState) {
 152             /\* XXX: make dock apps work! *\/
 153             XUngrabServer(ob_display);
 154             XFlush(ob_display);
 155             XFree(wmhint);
 156             return;
 157         }
 158         XFree(wmhint);
 159     }
 160 */
 161
 162     /* choose the events we want to receive on the CLIENT window */
 163     attrib_set.event_mask = CLIENT_EVENTMASK;
 164     attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
 165     XChangeWindowAttributes(ob_display, window,
 166                             CWEventMask|CWDontPropagate, &attrib_set);
 167
 168
 169     /* create the Client struct, and populate it from the hints on the
 170        window */
 171     client = g_new(Client, 1);
 172     client->window = window;
 173     client_get_all(client);
 174
 175     /* remove the client's border (and adjust re gravity) */
 176     client_toggle_border(client, FALSE);
 177
 178     /* specify that if we exit, the window should not be destroyed and should
 179        be reparented back to root automatically */
 180     XChangeSaveSet(ob_display, window, SetModeInsert);
 181
 182     /* create the decoration frame for the client window */
 183     client->frame = engine_frame_new();
 184
 185     engine_frame_grab_client(client->frame, client);
 186
 187     client_apply_startup_state(client);
 188
 189     XUngrabServer(ob_display);
 190     XFlush(ob_display);
 191
 192     client_list = g_slist_append(client_list, client);
 193     stacking_list = g_list_append(stacking_list, client);
 194     g_hash_table_insert(client_map, (gpointer)window, client);
 195
 196     stacking_raise(client);
 197
 198     screen_update_struts();
 199
 200     /* add to the python list */
 201     cw = clientwrap_new(client);
 202     PyList_Append(openboxwrap_obj->client_list, cw);
 203     Py_DECREF(cw);
 204
 205     HOOKFIRECLIENT(managed, client);
 206
 207     client_showhide(client);
 208
 209     /* grab all mouse bindings */
 210     pointer_grab_all(client, TRUE);
 211
 212     /* update the list hints */
 213     client_set_list();
 214
 215     g_message("Managed window 0x%lx", window);
 216 }
 217
 218 void client_unmanage_all()
 219 {
 220     while (client_list != NULL)
 221         client_unmanage(client_list->data);
 222 }
 223
 224 void client_unmanage(Client *client)
 225 {
 226     int j, seq;
 227     PyObject *cw;
 228     GSList *it;
 229
 230     g_message("Unmanaging window: %lx", client->window);
 231
 232     HOOKFIRECLIENT(closed, client);
 233
 234     /* remove the window from our save set */
 235     XChangeSaveSet(ob_display, client->window, SetModeDelete);
 236
 237     /* we dont want events no more */
 238     XSelectInput(ob_display, client->window, NoEventMask);
 239
 240     /* ungrab any mouse bindings */
 241     pointer_grab_all(client, FALSE);
 242
 243     engine_frame_hide(client->frame);
 244
 245     /* give the client its border back */
 246     client_toggle_border(client, TRUE);
 247
 248     /* reparent the window out of the frame, and free the frame */
 249     engine_frame_release_client(client->frame, client);
 250
 251     client_list = g_slist_remove(client_list, client);
 252     stacking_list = g_list_remove(stacking_list, client);
 253     g_hash_table_remove(client_map, (gpointer)client->window);
 254
 255     /* once the client is out of the list, update the struts to remove it's
 256        influence */
 257     screen_update_struts();
 258
 259     /* remove from the python list */
 260     cw = clientwrap_new(client);
 261     seq = PySequence_Index(openboxwrap_obj->client_list, cw);
 262     if (seq == -1)
 263         PyErr_Clear();
 264     else
 265         PySequence_DelItem(openboxwrap_obj->client_list, seq);
 266     Py_DECREF(cw);
 267
 268     /* notify the wrapper that its useless now */
 269     if (client->wrap != NULL)
 270         client->wrap->client = NULL;
 271
 272     /* tell our parent that we're gone */
 273     if (client->transient_for != NULL)
 274         client->transient_for->transients =
 275             g_slist_remove(client->transient_for->transients, client);
 276
 277     /* tell our transients that we're gone */
 278     for (it = client->transients; it != NULL; it = it->next) {
 279         ((Client*)it->data)->transient_for = NULL;
 280         client_calc_layer(it->data);
 281     }
 282
 283     /* unfocus the client (calls the focus callbacks) (we're out of the
 284      transient lists already, so being modal doesn't matter) */
 285     if (client->focused)
 286         client_unfocus(client);
 287
 288     if (ob_state != State_Exiting) {
 289         /* these values should not be persisted across a window
 290            unmapping/mapping */
 291         prop_erase(client->window, prop_atoms.net_wm_desktop);
 292         prop_erase(client->window, prop_atoms.net_wm_state);
 293     } else {
 294         /* if we're left in an iconic state, the client wont be mapped. this is
 295            bad, since we will no longer be managing the window on restart */
 296         if (client->iconic)
 297             XMapWindow(ob_display, client->window);
 298     }
 299
 300     /* free all data allocated in the client struct */
 301     g_slist_free(client->transients);
 302     for (j = 0; j < client->nicons; ++j)
 303         g_free(client->icons[j].data);
 304     if (client->nicons > 0)
 305         g_free(client->icons);
 306     g_free(client->title);
 307     g_free(client->icon_title);
 308     g_free(client->res_name);
 309     g_free(client->res_class);
 310     g_free(client->role);
 311     g_free(client);
 312
 313     /* update the list hints */
 314     client_set_list();
 315 }
 316
 317 static void client_toggle_border(Client *self, gboolean show)
 318 {
 319     /* adjust our idea of where the client is, based on its border. When the
 320        border is removed, the client should now be considered to be in a
 321        different position.
 322        when re-adding the border to the client, the same operation needs to be
 323        reversed. */
 324     int oldx = self->area.x, oldy = self->area.y;
 325     int x = oldx, y = oldy;
 326     switch(self->gravity) {
 327     default:
 328     case NorthWestGravity:
 329     case WestGravity:
 330     case SouthWestGravity:
 331         break;
 332     case NorthEastGravity:
 333     case EastGravity:
 334     case SouthEastGravity:
 335         if (show) x -= self->border_width * 2;
 336         else      x += self->border_width * 2;
 337         break;
 338     case NorthGravity:
 339     case SouthGravity:
 340     case CenterGravity:
 341     case ForgetGravity:
 342     case StaticGravity:
 343         if (show) x -= self->border_width;
 344         else      x += self->border_width;
 345         break;
 346     }
 347     switch(self->gravity) {
 348     default:
 349     case NorthWestGravity:
 350     case NorthGravity:
 351     case NorthEastGravity:
 352         break;
 353     case SouthWestGravity:
 354     case SouthGravity:
 355     case SouthEastGravity:
 356         if (show) y -= self->border_width * 2;
 357         else      y += self->border_width * 2;
 358         break;
 359     case WestGravity:
 360     case EastGravity:
 361     case CenterGravity:
 362     case ForgetGravity:
 363     case StaticGravity:
 364         if (show) y -= self->border_width;
 365         else      y += self->border_width;
 366         break;
 367     }
 368     self->area.x = x;
 369     self->area.y = y;
 370
 371     if (show) {
 372         XSetWindowBorderWidth(ob_display, self->window, self->border_width);
 373
 374         /* move the client so it is back it the right spot _with_ its
 375            border! */
 376         if (x != oldx || y != oldy)
 377             XMoveWindow(ob_display, self->window, x, y);
 378     } else
 379         XSetWindowBorderWidth(ob_display, self->window, 0);
 380 }
 381
 382
 383 static void client_get_all(Client *self)
 384 {
 385     /* update EVERYTHING!! */
 386
 387     self->ignore_unmaps = 0;
 388
 389     /* defaults */
 390     self->frame = NULL;
 391     self->title = self->icon_title = NULL;
 392     self->res_name = self->res_class = self->role = NULL;
 393     self->wmstate = NormalState;
 394     self->focused = FALSE;
 395     self->transient = FALSE;
 396     self->transients = NULL;
 397     self->transient_for = NULL;
 398     self->layer = -1;
 399     self->urgent = FALSE;
 400     self->positioned = FALSE;
 401     self->disabled_decorations = 0;
 402     self->group = None;
 403     self->nicons = 0;
 404     self->wrap = NULL;
 405
 406     client_get_area(self);
 407     client_get_desktop(self);
 408     client_get_state(self);
 409     client_get_shaped(self);
 410
 411     client_update_transient_for(self);
 412     client_get_mwm_hints(self);
 413     client_get_type(self);/* this can change the mwmhints for special cases */
 414
 415     client_update_protocols(self);
 416
 417     client_get_gravity(self); /* get the attribute gravity */
 418     client_update_normal_hints(self); /* this may override the attribute
 419                                          gravity */
 420
 421     /* got the type, the mwmhints, the protocols, and the normal hints
 422        (min/max sizes), so we're ready to set up the decorations/functions */
 423     client_setup_decor_and_functions(self);
 424
 425     client_update_wmhints(self);
 426     client_update_title(self);
 427     client_update_icon_title(self);
 428     client_update_class(self);
 429     client_update_strut(self);
 430     client_update_icons(self);
 431     client_update_kwm_icon(self);
 432
 433     /* this makes sure that these windows appear on all desktops */
 434     if (self->type == Type_Desktop)
 435         self->desktop = DESKTOP_ALL;
 436
 437     /* set the desktop hint, to make sure that it always exists, and to
 438        reflect any changes we've made here */
 439     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
 440
 441     client_change_state(self);
 442 }
 443
 444 static void client_get_area(Client *self)
 445 {
 446     XWindowAttributes wattrib;
 447     Status ret;
 448
 449     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
 450     g_assert(ret != BadWindow);
 451
 452     RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
 453     self->border_width = wattrib.border_width;
 454 }
 455
 456 static void client_get_desktop(Client *self)
 457 {
 458     unsigned int d;
 459
 460     if (PROP_GET32(self->window, net_wm_desktop, cardinal, d)) {
 461         if (d >= screen_num_desktops && d != DESKTOP_ALL)
 462             d = screen_num_desktops - 1;
 463         self->desktop = d;
 464     } else {
 465         /* defaults to the current desktop */
 466         self->desktop = screen_desktop;
 467     }
 468 }
 469
 470 static void client_get_state(Client *self)
 471 {
 472     gulong *state;
 473     gulong num;
 474
 475     self->modal = self->shaded = self->max_horz = self->max_vert =
 476         self->fullscreen = self->above = self->below = self->iconic =
 477         self->skip_taskbar = self->skip_pager = FALSE;
 478
 479     if (PROP_GET32U(self->window, net_wm_state, atom, state, num)) {
 480         gulong i;
 481         for (i = 0; i < num; ++i) {
 482             if (state[i] == prop_atoms.net_wm_state_modal)
 483                 self->modal = TRUE;
 484             else if (state[i] == prop_atoms.net_wm_state_shaded)
 485                 self->shaded = TRUE;
 486             else if (state[i] == prop_atoms.net_wm_state_hidden)
 487                 self->iconic = TRUE;
 488             else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
 489                 self->skip_taskbar = TRUE;
 490             else if (state[i] == prop_atoms.net_wm_state_skip_pager)
 491                 self->skip_pager = TRUE;
 492             else if (state[i] == prop_atoms.net_wm_state_fullscreen)
 493                 self->fullscreen = TRUE;
 494             else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
 495                 self->max_vert = TRUE;
 496             else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
 497                 self->max_horz = TRUE;
 498             else if (state[i] == prop_atoms.net_wm_state_above)
 499                 self->above = TRUE;
 500             else if (state[i] == prop_atoms.net_wm_state_below)
 501                 self->below = TRUE;
 502         }
 503
 504         g_free(state);
 505     }
 506 }
 507
 508 static void client_get_shaped(Client *self)
 509 {
 510     self->shaped = FALSE;
 511 #ifdef   SHAPE
 512     if (extensions_shape) {
 513         int foo;
 514         guint ufoo;
 515         int s;
 516
 517         XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
 518
 519         XShapeQueryExtents(ob_display, self->window, &s, &foo,
 520                            &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
 521                            &ufoo);
 522         self->shaped = (s != 0);
 523     }
 524 #endif
 525 }
 526
 527 void client_update_transient_for(Client *self)
 528 {
 529     Window t = None;
 530     Client *c = NULL;
 531
 532     if (XGetTransientForHint(ob_display, self->window, &t) &&
 533         t != self->window) { /* cant be transient to itself! */
 534         self->transient = TRUE;
 535         c = g_hash_table_lookup(client_map, (gpointer)t);
 536         g_assert(c != self);/* if this happens then we need to check for it*/
 537
 538         if (!c /*XXX: && _group*/) {
 539             /* not transient to a client, see if it is transient for a
 540                group */
 541             if (/*t == _group->leader() || */
 542                 t == None ||
 543                 t == ob_root) {
 544                 /* window is a transient for its group! */
 545                 /* XXX: for now this is treated as non-transient.
 546                    this needs to be fixed! */
 547             }
 548         }
 549     } else
 550         self->transient = FALSE;
 551
 552     /* if anything has changed... */
 553     if (c != self->transient_for) {
 554         if (self->transient_for)
 555             /* remove from old parent */
 556             g_slist_remove(self->transient_for->transients, self);
 557         self->transient_for = c;
 558         if (self->transient_for)
 559             /* add to new parent */
 560             g_slist_append(self->transient_for->transients, self);
 561     }
 562 }
 563
 564 static void client_get_mwm_hints(Client *self)
 565 {
 566     unsigned long num;
 567     unsigned long *hints;
 568
 569     self->mwmhints.flags = 0; /* default to none */
 570
 571     if (PROP_GET32U(self->window, motif_wm_hints, motif_wm_hints, hints, num)) {
 572         if (num >= MWM_ELEMENTS) {
 573             self->mwmhints.flags = hints[0];
 574             self->mwmhints.functions = hints[1];
 575             self->mwmhints.decorations = hints[2];
 576         }
 577         g_free(hints);
 578     }
 579 }
 580
 581 void client_get_type(Client *self)
 582 {
 583     gulong *val, num, i;
 584
 585     self->type = -1;
 586
 587     if (PROP_GET32U(self->window, net_wm_window_type, atom, val, num)) {
 588         /* use the first value that we know about in the array */
 589         for (i = 0; i < num; ++i) {
 590             if (val[i] == prop_atoms.net_wm_window_type_desktop)
 591                 self->type = Type_Desktop;
 592             else if (val[i] == prop_atoms.net_wm_window_type_dock)
 593                 self->type = Type_Dock;
 594             else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
 595                 self->type = Type_Toolbar;
 596             else if (val[i] == prop_atoms.net_wm_window_type_menu)
 597                 self->type = Type_Menu;
 598             else if (val[i] == prop_atoms.net_wm_window_type_utility)
 599                 self->type = Type_Utility;
 600             else if (val[i] == prop_atoms.net_wm_window_type_splash)
 601                 self->type = Type_Splash;
 602             else if (val[i] == prop_atoms.net_wm_window_type_dialog)
 603                 self->type = Type_Dialog;
 604             else if (val[i] == prop_atoms.net_wm_window_type_normal)
 605                 self->type = Type_Normal;
 606             else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
 607                 /* prevent this window from getting any decor or
 608                    functionality */
 609                 self->mwmhints.flags &= (MwmFlag_Functions |
 610                                          MwmFlag_Decorations);
 611                 self->mwmhints.decorations = 0;
 612                 self->mwmhints.functions = 0;
 613             }
 614             if (self->type != (WindowType) -1)
 615                 break; /* grab the first legit type */
 616         }
 617         g_free(val);
 618     }
 619
 620     if (self->type == (WindowType) -1) {
 621         /*the window type hint was not set, which means we either classify
 622           ourself as a normal window or a dialog, depending on if we are a
 623           transient. */
 624         if (self->transient)
 625             self->type = Type_Dialog;
 626         else
 627             self->type = Type_Normal;
 628     }
 629 }
 630
 631 void client_update_protocols(Client *self)
 632 {
 633     Atom *proto;
 634     gulong num_return, i;
 635
 636     self->focus_notify = FALSE;
 637     self->delete_window = FALSE;
 638
 639     if (PROP_GET32U(self->window, wm_protocols, atom, proto, num_return)) {
 640         for (i = 0; i < num_return; ++i) {
 641             if (proto[i] == prop_atoms.wm_delete_window) {
 642                 /* this means we can request the window to close */
 643                 self->delete_window = TRUE;
 644             } else if (proto[i] == prop_atoms.wm_take_focus)
 645                 /* if this protocol is requested, then the window will be
 646                    notified whenever we want it to receive focus */
 647                 self->focus_notify = TRUE;
 648         }
 649         g_free(proto);
 650     }
 651 }
 652
 653 static void client_get_gravity(Client *self)
 654 {
 655     XWindowAttributes wattrib;
 656     Status ret;
 657
 658     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
 659     g_assert(ret != BadWindow);
 660     self->gravity = wattrib.win_gravity;
 661 }
 662
 663 void client_update_normal_hints(Client *self)
 664 {
 665     XSizeHints size;
 666     long ret;
 667     int oldgravity = self->gravity;
 668
 669     /* defaults */
 670     self->min_ratio = 0.0f;
 671     self->max_ratio = 0.0f;
 672     SIZE_SET(self->size_inc, 1, 1);
 673     SIZE_SET(self->base_size, 0, 0);
 674     SIZE_SET(self->min_size, 0, 0);
 675     SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
 676
 677     /* get the hints from the window */
 678     if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
 679         self->positioned = (size.flags & (PPosition|USPosition));
 680
 681         if (size.flags & PWinGravity) {
 682             self->gravity = size.win_gravity;
 683
 684             /* if the client has a frame, i.e. has already been mapped and
 685                is changing its gravity */
 686             if (self->frame && self->gravity != oldgravity) {
 687                 /* move our idea of the client's position based on its new
 688                    gravity */
 689                 self->area.x = self->frame->area.x;
 690                 self->area.y = self->frame->area.y;
 691                 frame_frame_gravity(self->frame, &self->area.x, &self->area.y);
 692             }
 693         }
 694
 695         if (size.flags & PAspect) {
 696             if (size.min_aspect.y)
 697                 self->min_ratio = (float)size.min_aspect.x / size.min_aspect.y;
 698             if (size.max_aspect.y)
 699                 self->max_ratio = (float)size.max_aspect.x / size.max_aspect.y;
 700         }
 701
 702         if (size.flags & PMinSize)
 703             SIZE_SET(self->min_size, size.min_width, size.min_height);
 704
 705         if (size.flags & PMaxSize)
 706             SIZE_SET(self->max_size, size.max_width, size.max_height);
 707
 708         if (size.flags & PBaseSize)
 709             SIZE_SET(self->base_size, size.base_width, size.base_height);
 710
 711         if (size.flags & PResizeInc)
 712             SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
 713     }
 714 }
 715
 716 void client_setup_decor_and_functions(Client *self)
 717 {
 718     /* start with everything (cept fullscreen) */
 719     self->decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
 720         Decor_Icon | Decor_AllDesktops | Decor_Iconify | Decor_Maximize;
 721     self->functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
 722         Func_Shade;
 723     if (self->delete_window) {
 724         self->decorations |= Decor_Close;
 725         self->functions |= Func_Close;
 726     }
 727
 728     if (!(self->min_size.width < self->max_size.width ||
 729           self->min_size.height < self->max_size.height)) {
 730         self->decorations &= ~(Decor_Maximize | Decor_Handle);
 731         self->functions &= ~(Func_Resize | Func_Maximize);
 732     }
 733
 734     switch (self->type) {
 735     case Type_Normal:
 736         /* normal windows retain all of the possible decorations and
 737            functionality, and are the only windows that you can fullscreen */
 738         self->functions |= Func_Fullscreen;
 739         break;
 740
 741     case Type_Dialog:
 742         /* dialogs cannot be maximized */
 743         self->decorations &= ~Decor_Maximize;
 744         self->functions &= ~Func_Maximize;
 745         break;
 746
 747     case Type_Menu:
 748     case Type_Toolbar:
 749     case Type_Utility:
 750         /* these windows get less functionality */
 751         self->decorations &= ~(Decor_Iconify | Decor_Handle);
 752         self->functions &= ~(Func_Iconify | Func_Resize);
 753         break;
 754
 755     case Type_Desktop:
 756     case Type_Dock:
 757     case Type_Splash:
 758         /* none of these windows are manipulated by the window manager */
 759         self->decorations = 0;
 760         self->functions = 0;
 761         break;
 762     }
 763
 764     /* Mwm Hints are applied subtractively to what has already been chosen for
 765        decor and functionality */
 766     if (self->mwmhints.flags & MwmFlag_Decorations) {
 767         if (! (self->mwmhints.decorations & MwmDecor_All)) {
 768             if (! (self->mwmhints.decorations & MwmDecor_Border))
 769                 self->decorations &= ~Decor_Border;
 770             if (! (self->mwmhints.decorations & MwmDecor_Handle))
 771                 self->decorations &= ~Decor_Handle;
 772             if (! (self->mwmhints.decorations & MwmDecor_Title))
 773                 self->decorations &= ~Decor_Titlebar;
 774             if (! (self->mwmhints.decorations & MwmDecor_Iconify))
 775                 self->decorations &= ~Decor_Iconify;
 776             if (! (self->mwmhints.decorations & MwmDecor_Maximize))
 777                 self->decorations &= ~Decor_Maximize;
 778         }
 779     }
 780
 781     if (self->mwmhints.flags & MwmFlag_Functions) {
 782         if (! (self->mwmhints.functions & MwmFunc_All)) {
 783             if (! (self->mwmhints.functions & MwmFunc_Resize))
 784                 self->functions &= ~Func_Resize;
 785             if (! (self->mwmhints.functions & MwmFunc_Move))
 786                 self->functions &= ~Func_Move;
 787             if (! (self->mwmhints.functions & MwmFunc_Iconify))
 788                 self->functions &= ~Func_Iconify;
 789             if (! (self->mwmhints.functions & MwmFunc_Maximize))
 790                 self->functions &= ~Func_Maximize;
 791             /* dont let mwm hints kill the close button
 792                if (! (self->mwmhints.functions & MwmFunc_Close))
 793                self->functions &= ~Func_Close; */
 794         }
 795     }
 796
 797     /* can't maximize without moving/resizing */
 798     if (!((self->functions & Func_Move) && (self->functions & Func_Resize)))
 799         self->functions &= ~Func_Maximize;
 800
 801     /* finally, user specified disabled decorations are applied to subtract
 802        decorations */
 803     if (self->disabled_decorations & Decor_Titlebar)
 804         self->decorations &= ~Decor_Titlebar;
 805     if (self->disabled_decorations & Decor_Handle)
 806         self->decorations &= ~Decor_Handle;
 807     if (self->disabled_decorations & Decor_Border)
 808         self->decorations &= ~Decor_Border;
 809     if (self->disabled_decorations & Decor_Iconify)
 810         self->decorations &= ~Decor_Iconify;
 811     if (self->disabled_decorations & Decor_Maximize)
 812         self->decorations &= ~Decor_Maximize;
 813     if (self->disabled_decorations & Decor_AllDesktops)
 814         self->decorations &= ~Decor_AllDesktops;
 815     if (self->disabled_decorations & Decor_Close)
 816         self->decorations &= ~Decor_Close;
 817
 818     /* if we don't have a titlebar, then we cannot shade! */
 819     if (!(self->decorations & Decor_Titlebar))
 820         self->functions &= ~Func_Shade;
 821
 822     client_change_allowed_actions(self);
 823
 824     if (self->frame) {
 825         /* change the decors on the frame */
 826         engine_frame_adjust_size(self->frame);
 827         /* with more/less decorations, we may need to be repositioned */
 828         engine_frame_adjust_position(self->frame);
 829         /* with new decor, the window's maximized size may change */
 830         client_remaximize(self);
 831     }
 832 }
 833
 834 static void client_change_allowed_actions(Client *self)
 835 {
 836     Atom actions[9];
 837     int num = 0;
 838
 839     actions[num++] = prop_atoms.net_wm_action_change_desktop;
 840
 841     if (self->functions & Func_Shade)
 842         actions[num++] = prop_atoms.net_wm_action_shade;
 843     if (self->functions & Func_Close)
 844         actions[num++] = prop_atoms.net_wm_action_close;
 845     if (self->functions & Func_Move)
 846         actions[num++] = prop_atoms.net_wm_action_move;
 847     if (self->functions & Func_Iconify)
 848         actions[num++] = prop_atoms.net_wm_action_minimize;
 849     if (self->functions & Func_Resize)
 850         actions[num++] = prop_atoms.net_wm_action_resize;
 851     if (self->functions & Func_Fullscreen)
 852         actions[num++] = prop_atoms.net_wm_action_fullscreen;
 853     if (self->functions & Func_Maximize) {
 854         actions[num++] = prop_atoms.net_wm_action_maximize_horz;
 855         actions[num++] = prop_atoms.net_wm_action_maximize_vert;
 856     }
 857
 858     PROP_SET32A(self->window, net_wm_allowed_actions, atom, actions, num);
 859
 860     /* make sure the window isn't breaking any rules now */
 861
 862     if (!(self->functions & Func_Shade) && self->shaded) {
 863         if (self->frame) client_shade(self, FALSE);
 864         else self->shaded = FALSE;
 865     }
 866     if (!(self->functions & Func_Iconify) && self->iconic) {
 867         if (self->frame) client_iconify(self, FALSE, TRUE);
 868         else self->iconic = FALSE;
 869     }
 870     if (!(self->functions & Func_Fullscreen) && self->fullscreen) {
 871         if (self->frame) client_fullscreen(self, FALSE, TRUE);
 872         else self->fullscreen = FALSE;
 873     }
 874     if (!(self->functions & Func_Maximize) && (self->max_horz ||
 875                                                self->max_vert)) {
 876         if (self->frame) client_maximize(self, FALSE, 0, TRUE);
 877         else self->max_vert = self->max_horz = FALSE;
 878     }
 879 }
 880
 881 void client_remaximize(Client *self)
 882 {
 883     int dir;
 884     if (self->max_horz && self->max_vert)
 885         dir = 0;
 886     else if (self->max_horz)
 887         dir = 1;
 888     else if (self->max_vert)
 889         dir = 2;
 890     else
 891         return; /* not maximized */
 892     self->max_horz = self->max_vert = FALSE;
 893     client_maximize(self, TRUE, dir, FALSE);
 894 }
 895
 896 void client_update_wmhints(Client *self)
 897 {
 898     XWMHints *hints;
 899     gboolean ur = FALSE;
 900
 901     /* assume a window takes input if it doesnt specify */
 902     self->can_focus = TRUE;
 903
 904     if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
 905         if (hints->flags & InputHint)
 906             self->can_focus = hints->input;
 907
 908         /* only do this when starting! */
 909         if (ob_state == State_Starting && (hints->flags & StateHint))
 910             self->iconic = hints->initial_state == IconicState;
 911
 912         if (hints->flags & XUrgencyHint)
 913             ur = TRUE;
 914
 915         if (hints->flags & WindowGroupHint) {
 916             if (hints->window_group != self->group) {
 917                 /* XXX: remove from the old group if there was one */
 918                 self->group = hints->window_group;
 919                 /* XXX: do stuff with the group */
 920             }
 921         } else /* no group! */
 922             self->group = None;
 923
 924         if (hints->flags & IconPixmapHint) {
 925             client_update_kwm_icon(self);
 926             /* try get the kwm icon first, this is a fallback only */
 927             if (self->pixmap_icon == None) {
 928                 self->pixmap_icon = hints->icon_pixmap;
 929                 if (hints->flags & IconMaskHint)
 930                     self->pixmap_icon_mask = hints->icon_mask;
 931                 else
 932                     self->pixmap_icon_mask = None;
 933
 934                 if (self->frame)
 935                     engine_frame_adjust_icon(self->frame);
 936             }
 937         }
 938
 939         XFree(hints);
 940     }
 941
 942     if (ur != self->urgent) {
 943         self->urgent = ur;
 944         g_message("Urgent Hint for 0x%lx: %s\n", self->window,
 945                   ur ? "ON" : "OFF");
 946         /* fire the urgent callback if we're mapped, otherwise, wait until
 947            after we're mapped */
 948         if (self->frame)
 949             HOOKFIRECLIENT(urgent, self);
 950     }
 951 }
 952
 953 void client_update_title(Client *self)
 954 {
 955     gchar *data = NULL;
 956
 957     if (self->title != NULL)
 958         g_free(self->title);
 959
 960     /* try netwm */
 961     if (!PROP_GETS(self->window, net_wm_name, utf8, data)) {
 962         /* try old x stuff */
 963         if (PROP_GETS(self->window, wm_name, string, data)) {
 964             /* convert it to UTF-8 */
 965             gsize r, w;
 966             gchar *u;
 967
 968             u = g_locale_to_utf8(data, -1, &r, &w, NULL);
 969             if (u == NULL) {
 970                 g_warning("Unable to convert string to UTF-8");
 971             } else {
 972                 g_free(data);
 973                 data = u;
 974             }
 975         }
 976         if (data == NULL)
 977             data = g_strdup("Unnamed Window");
 978
 979         PROP_SETS(self->window, net_wm_visible_name, utf8, data);
 980     }
 981
 982     self->title = data;
 983
 984     if (self->frame)
 985         engine_frame_adjust_title(self->frame);
 986 }
 987
 988 void client_update_icon_title(Client *self)
 989 {
 990     gchar *data = NULL;
 991
 992     if (self->icon_title != NULL)
 993         g_free(self->icon_title);
 994
 995     /* try netwm */
 996     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, data)) {
 997         /* try old x stuff */
 998         if (PROP_GETS(self->window, wm_icon_name, string, data)) {
 999             /* convert it to UTF-8 */
1000             gsize r, w;
1001             gchar *u;
1002
1003             u = g_locale_to_utf8(data, -1, &r, &w, NULL);
1004             if (u == NULL) {
1005                 g_warning("Unable to convert string to UTF-8");
1006             } else {
1007                 g_free(data);
1008                 data = u;
1009             }
1010         }
1011         if (data == NULL)
1012             data = g_strdup("Unnamed Window");
1013
1014         PROP_SETS(self->window, net_wm_visible_icon_name, utf8, data);
1015     }
1016
1017     self->icon_title = data;
1018 }
1019
1020 void client_update_class(Client *self)
1021 {
1022     GPtrArray *data;
1023     gchar *s;
1024     guint i;
1025
1026     if (self->res_name) g_free(self->res_name);
1027     if (self->res_class) g_free(self->res_class);
1028     if (self->role) g_free(self->role);
1029
1030     self->res_name = self->res_class = self->role = NULL;
1031
1032     data = g_ptr_array_new();
1033
1034     if (PROP_GETSA(self->window, wm_class, string, data)) {
1035         if (data->len > 0)
1036             self->res_name = g_strdup(g_ptr_array_index(data, 0));
1037         if (data->len > 1)
1038             self->res_class = g_strdup(g_ptr_array_index(data, 1));
1039     }
1040
1041     for (i = 0; i < data->len; ++i)
1042         g_free(g_ptr_array_index(data, i));
1043     g_ptr_array_free(data, TRUE);
1044
1045     if (PROP_GETS(self->window, wm_window_role, string, s))
1046         self->role = g_strdup(s);
1047
1048     if (self->res_name == NULL) self->res_name = g_strdup("");
1049     if (self->res_class == NULL) self->res_class = g_strdup("");
1050     if (self->role == NULL) self->role = g_strdup("");
1051 }
1052
1053 void client_update_strut(Client *self)
1054 {
1055     gulong *data;
1056
1057     if (PROP_GET32A(self->window, net_wm_strut, cardinal, data, 4)) {
1058         STRUT_SET(self->strut, data[0], data[1], data[2], data[3]);
1059         g_free(data);
1060     } else
1061         STRUT_SET(self->strut, 0, 0, 0, 0);
1062
1063     /* updating here is pointless while we're being mapped cuz we're not in
1064        the client list yet */
1065     if (self->frame)
1066         screen_update_struts();
1067 }
1068
1069 void client_update_icons(Client *self)
1070 {
1071     unsigned long num;
1072     unsigned long *data;
1073     unsigned long w, h, i;
1074     int j;
1075
1076     for (j = 0; j < self->nicons; ++j)
1077         g_free(self->icons[j].data);
1078     if (self->nicons > 0)
1079         g_free(self->icons);
1080     self->nicons = 0;
1081
1082     if (PROP_GET32U(self->window, net_wm_icon, cardinal, data, num)) {
1083         /* figure out how many valid icons are in here */
1084         i = 0;
1085         while (num - i > 2) {
1086             w = data[i++];
1087             h = data[i++];
1088             i += w * h;
1089             if (i > num) break;
1090             ++self->nicons;
1091         }
1092
1093         self->icons = g_new(Icon, self->nicons);
1094
1095         /* store the icons */
1096         i = 0;
1097         for (j = 0; j < self->nicons; ++j) {
1098             w = self->icons[j].w = data[i++];
1099             h = self->icons[j].h = data[i++];
1100             self->icons[j].data =
1101                 g_memdup(&data[i], w * h * sizeof(gulong));
1102             i += w * h;
1103             g_assert(i <= num);
1104         }
1105
1106         g_free(data);
1107     }
1108
1109     if (self->nicons <= 0) {
1110         self->nicons = 1;
1111         self->icons = g_new0(Icon, 1);
1112     }
1113
1114     if (self->frame)
1115         engine_frame_adjust_icon(self->frame);
1116 }
1117
1118 void client_update_kwm_icon(Client *self)
1119 {
1120     Pixmap *data;
1121
1122     if (PROP_GET32A(self->window, kwm_win_icon, kwm_win_icon, data, 2)) {
1123         self->pixmap_icon = data[0];
1124         self->pixmap_icon_mask = data[1];
1125         g_free(data);
1126     } else {
1127         self->pixmap_icon = self->pixmap_icon_mask = None;
1128     }
1129     if (self->frame)
1130         engine_frame_adjust_icon(self->frame);
1131 }
1132
1133 static void client_change_state(Client *self)
1134 {
1135     unsigned long state[2];
1136     Atom netstate[10];
1137     int num;
1138
1139     state[0] = self->wmstate;
1140     state[1] = None;
1141     PROP_SET32A(self->window, wm_state, wm_state, state, 2);
1142
1143     num = 0;
1144     if (self->modal)
1145         netstate[num++] = prop_atoms.net_wm_state_modal;
1146     if (self->shaded)
1147         netstate[num++] = prop_atoms.net_wm_state_shaded;
1148     if (self->iconic)
1149         netstate[num++] = prop_atoms.net_wm_state_hidden;
1150     if (self->skip_taskbar)
1151         netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
1152     if (self->skip_pager)
1153         netstate[num++] = prop_atoms.net_wm_state_skip_pager;
1154     if (self->fullscreen)
1155         netstate[num++] = prop_atoms.net_wm_state_fullscreen;
1156     if (self->max_vert)
1157         netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
1158     if (self->max_horz)
1159         netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
1160     if (self->above)
1161         netstate[num++] = prop_atoms.net_wm_state_above;
1162     if (self->below)
1163         netstate[num++] = prop_atoms.net_wm_state_below;
1164     PROP_SET32A(self->window, net_wm_state, atom, netstate, num);
1165
1166     client_calc_layer(self);
1167
1168     if (self->frame)
1169         engine_frame_adjust_state(self->frame);
1170 }
1171
1172 static Client *search_focus_tree(Client *node, Client *skip)
1173 {
1174     GSList *it;
1175     Client *ret;
1176
1177     for (it = node->transients; it != NULL; it = g_slist_next(it)) {
1178         Client *c = it->data;
1179         if (c == skip) continue; /* circular? */
1180         if ((ret = search_focus_tree(c, skip))) return ret;
1181         if (c->focused) return c;
1182     }
1183     return NULL;
1184 }
1185
1186 void client_calc_layer(Client *self)
1187 {
1188     StackLayer l;
1189     gboolean fs;
1190     Client *c;
1191
1192     /* are we fullscreen, or do we have a fullscreen transient parent? */
1193     c = self;
1194     fs = FALSE;
1195     while (c) {
1196         if (c->fullscreen) {
1197             fs = TRUE;
1198             break;
1199         }
1200         c = c->transient_for;
1201     }
1202     if (!fs && self->fullscreen) {
1203         /* is one of our transients focused? */
1204         c = search_focus_tree(self, self);
1205         if (c != NULL) fs = TRUE;
1206     }
1207
1208     if (self->iconic) l = Layer_Icon;
1209     else if (fs) l = Layer_Fullscreen;
1210     else if (self->type == Type_Desktop) l = Layer_Desktop;
1211     else if (self->type == Type_Dock) {
1212         if (!self->below) l = Layer_Top;
1213         else l = Layer_Normal;
1214     }
1215     else if (self->above) l = Layer_Above;
1216     else if (self->below) l = Layer_Below;
1217     else l = Layer_Normal;
1218
1219     if (l != self->layer) {
1220         self->layer = l;
1221         if (self->frame)
1222             stacking_raise(self);
1223     }
1224 }
1225
1226 gboolean client_should_show(Client *self)
1227 {
1228     if (self->iconic) return FALSE;
1229     else if (!(self->desktop == screen_desktop ||
1230                self->desktop == DESKTOP_ALL)) return FALSE;
1231     else if (client_normal(self) && screen_showing_desktop) return FALSE;
1232
1233     return TRUE;
1234 }
1235
1236 void client_showhide(Client *self)
1237 {
1238
1239     if (client_should_show(self))
1240         engine_frame_show(self->frame);
1241     else
1242         engine_frame_hide(self->frame);
1243
1244     HOOKFIRECLIENT(visible, self);
1245 }
1246
1247 gboolean client_normal(Client *self) {
1248     return ! (self->type == Type_Desktop || self->type == Type_Dock ||
1249               self->type == Type_Splash);
1250 }
1251
1252 static void client_apply_startup_state(Client *self)
1253 {
1254     /* these are in a carefully crafted order.. */
1255
1256     if (self->iconic) {
1257         self->iconic = FALSE;
1258         client_iconify(self, TRUE, FALSE);
1259     }
1260     if (self->fullscreen) {
1261         self->fullscreen = FALSE;
1262         client_fullscreen(self, TRUE, FALSE);
1263     }
1264     if (self->shaded) {
1265         self->shaded = FALSE;
1266         client_shade(self, TRUE);
1267     }
1268     if (self->urgent)
1269         HOOKFIRECLIENT(urgent, self);
1270
1271     if (self->max_vert && self->max_horz) {
1272         self->max_vert = self->max_horz = FALSE;
1273         client_maximize(self, TRUE, 0, FALSE);
1274     } else if (self->max_vert) {
1275         self->max_vert = FALSE;
1276         client_maximize(self, TRUE, 2, FALSE);
1277     } else if (self->max_horz) {
1278         self->max_horz = FALSE;
1279         client_maximize(self, TRUE, 1, FALSE);
1280     }
1281
1282     /* nothing to do for the other states:
1283        skip_taskbar
1284        skip_pager
1285        modal
1286        above
1287        below
1288     */
1289 }
1290
1291 void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
1292                       gboolean user, gboolean final)
1293 {
1294     gboolean moved = FALSE, resized = FALSE;
1295
1296     w -= self->base_size.width;
1297     h -= self->base_size.height;
1298
1299     if (user) {
1300         /* for interactive resizing. have to move half an increment in each
1301            direction. */
1302
1303         /* how far we are towards the next size inc */
1304         int mw = w % self->size_inc.width;
1305         int mh = h % self->size_inc.height;
1306         /* amount to add */
1307         int aw = self->size_inc.width / 2;
1308         int ah = self->size_inc.height / 2;
1309         /* don't let us move into a new size increment */
1310         if (mw + aw >= self->size_inc.width)
1311             aw = self->size_inc.width - mw - 1;
1312         if (mh + ah >= self->size_inc.height)
1313             ah = self->size_inc.height - mh - 1;
1314         w += aw;
1315         h += ah;
1316
1317         /* if this is a user-requested resize, then check against min/max
1318            sizes and aspect ratios */
1319
1320         /* smaller than min size or bigger than max size? */
1321         if (w > self->max_size.width) w = self->max_size.width;
1322         if (w < self->min_size.width) w = self->min_size.width;
1323         if (h > self->max_size.height) h = self->max_size.height;
1324         if (h < self->min_size.height) h = self->min_size.height;
1325
1326         /* adjust the height ot match the width for the aspect ratios */
1327         if (self->min_ratio)
1328             if (h * self->min_ratio > w) h = (int)(w / self->min_ratio);
1329         if (self->max_ratio)
1330             if (h * self->max_ratio < w) h = (int)(w / self->max_ratio);
1331     }
1332
1333     /* keep to the increments */
1334     w /= self->size_inc.width;
1335     h /= self->size_inc.height;
1336
1337     /* you cannot resize to nothing */
1338     if (w < 1) w = 1;
1339     if (h < 1) h = 1;
1340
1341     /* store the logical size */
1342     SIZE_SET(self->logical_size, w, h);
1343
1344     w *= self->size_inc.width;
1345     h *= self->size_inc.height;
1346
1347     w += self->base_size.width;
1348     h += self->base_size.height;
1349
1350     switch (anchor) {
1351     case Corner_TopLeft:
1352         break;
1353     case Corner_TopRight:
1354         x -= w - self->area.width;
1355         break;
1356     case Corner_BottomLeft:
1357         y -= h - self->area.height;
1358         break;
1359     case Corner_BottomRight:
1360         x -= w - self->area.width;
1361         y -= h - self->area.height;
1362         break;
1363     }
1364
1365     moved = x != self->area.x || y != self->area.y;
1366     resized = w != self->area.width || h != self->area.height;
1367
1368     RECT_SET(self->area, x, y, w, h);
1369
1370     if (resized)
1371         XResizeWindow(ob_display, self->window, w, h);
1372
1373     /* move/resize the frame to match the request */
1374     if (self->frame) {
1375         /* Adjust the size and then the position, as required by the EWMH */
1376         if (resized)
1377             engine_frame_adjust_size(self->frame);
1378         if (moved) {
1379             engine_frame_adjust_position(self->frame);
1380
1381             if (!user || final) {
1382                 XEvent event;
1383                 event.type = ConfigureNotify;
1384                 event.xconfigure.display = ob_display;
1385                 event.xconfigure.event = self->window;
1386                 event.xconfigure.window = self->window;
1387
1388                 /* root window coords with border in mind */
1389                 event.xconfigure.x = x - self->border_width +
1390                     self->frame->size.left;
1391                 event.xconfigure.y = y - self->border_width +
1392                     self->frame->size.top;
1393
1394                 event.xconfigure.width = self->area.width;
1395                 event.xconfigure.height = self->area.height;
1396                 event.xconfigure.border_width = self->border_width;
1397                 event.xconfigure.above = self->frame->plate;
1398                 event.xconfigure.override_redirect = FALSE;
1399                 XSendEvent(event.xconfigure.display, event.xconfigure.window,
1400                            FALSE, StructureNotifyMask, &event);
1401             }
1402         }
1403     }
1404 }
1405
1406 void client_fullscreen(Client *self, gboolean fs, gboolean savearea)
1407 {
1408     static int saved_func, saved_decor;
1409     int x, y, w, h;
1410
1411     if (!(self->functions & Func_Fullscreen) || /* can't */
1412         self->fullscreen == fs) return;         /* already done */
1413
1414     self->fullscreen = fs;
1415     client_change_state(self); /* change the state hints on the client */
1416
1417     if (fs) {
1418         /* save the functions and remove them */
1419         saved_func = self->functions;
1420         self->functions &= (Func_Close | Func_Fullscreen |
1421                             Func_Iconify);
1422         /* save the decorations and remove them */
1423         saved_decor = self->decorations;
1424         self->decorations = 0;
1425         if (savearea) {
1426             long dimensions[4];
1427             dimensions[0] = self->area.x;
1428             dimensions[1] = self->area.y;
1429             dimensions[2] = self->area.width;
1430             dimensions[3] = self->area.height;
1431
1432             PROP_SET32A(self->window, openbox_premax, cardinal,
1433                         dimensions, 4);
1434         }
1435         x = 0;
1436         y = 0;
1437         w = screen_physical_size.width;
1438         h = screen_physical_size.height;
1439     } else {
1440         long *dimensions;
1441
1442         self->functions = saved_func;
1443         self->decorations = saved_decor;
1444
1445         if (PROP_GET32A(self->window, openbox_premax, cardinal,
1446                         dimensions, 4)) {
1447             x = dimensions[0];
1448             y = dimensions[1];
1449             w = dimensions[2];
1450             h = dimensions[3];
1451             g_free(dimensions);
1452         } else {
1453             /* pick some fallbacks... */
1454             x = screen_area(self->desktop)->x +
1455                 screen_area(self->desktop)->width / 4;
1456             y = screen_area(self->desktop)->y +
1457                 screen_area(self->desktop)->height / 4;
1458             w = screen_area(self->desktop)->width / 2;
1459             h = screen_area(self->desktop)->height / 2;
1460         }
1461     }
1462
1463     client_change_allowed_actions(self); /* based on the new _functions */
1464
1465     /* when fullscreening, don't obey things like increments, fill the
1466        screen */
1467     client_configure(self, Corner_TopLeft, x, y, w, h, !fs, TRUE);
1468
1469     /* raise (back) into our stacking layer */
1470     stacking_raise(self);
1471
1472     /* try focus us when we go into fullscreen mode */
1473     client_focus(self);
1474 }
1475
1476 void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
1477 {
1478     if (self->iconic == iconic) return; /* nothing to do */
1479
1480     g_message("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
1481               self->window);
1482
1483     self->iconic = iconic;
1484
1485     if (iconic) {
1486         self->wmstate = IconicState;
1487         self->ignore_unmaps++;
1488         /* we unmap the client itself so that we can get MapRequest events,
1489            and because the ICCCM tells us to! */
1490         XUnmapWindow(ob_display, self->window);
1491     } else {
1492         if (curdesk)
1493             client_set_desktop(self, screen_desktop);
1494         self->wmstate = self->shaded ? IconicState : NormalState;
1495         XMapWindow(ob_display, self->window);
1496     }
1497     client_change_state(self);
1498     client_showhide(self);
1499     screen_update_struts();
1500 }
1501
1502 void client_maximize(Client *self, gboolean max, int dir, gboolean savearea)
1503 {
1504     int x, y, w, h;
1505
1506     g_assert(dir == 0 || dir == 1 || dir == 2);
1507     if (!(self->functions & Func_Maximize)) return; /* can't */
1508
1509     /* check if already done */
1510     if (max) {
1511         if (dir == 0 && self->max_horz && self->max_vert) return;
1512         if (dir == 1 && self->max_horz) return;
1513         if (dir == 2 && self->max_vert) return;
1514     } else {
1515         if (dir == 0 && !self->max_horz && !self->max_vert) return;
1516         if (dir == 1 && !self->max_horz) return;
1517         if (dir == 2 && !self->max_vert) return;
1518     }
1519
1520     /* work with the frame's coords */
1521     x = self->frame->area.x;
1522     y = self->frame->area.y;
1523     w = self->area.width;
1524     h = self->area.height;
1525
1526     if (max) {
1527         if (savearea) {
1528             long dimensions[4];
1529             long *readdim;
1530
1531             dimensions[0] = x;
1532             dimensions[1] = y;
1533             dimensions[2] = w;
1534             dimensions[3] = h;
1535
1536             /* get the property off the window and use it for the dimensions
1537                we are already maxed on */
1538             if (PROP_GET32A(self->window, openbox_premax, cardinal,
1539                             readdim, 4)) {
1540                 if (self->max_horz) {
1541                     dimensions[0] = readdim[0];
1542                     dimensions[2] = readdim[2];
1543                 }
1544                 if (self->max_vert) {
1545                     dimensions[1] = readdim[1];
1546                     dimensions[3] = readdim[3];
1547                 }
1548                 g_free(readdim);
1549             }
1550
1551             PROP_SET32A(self->window, openbox_premax, cardinal,
1552                         dimensions, 4);
1553         }
1554         if (dir == 0 || dir == 1) { /* horz */
1555             x = screen_area(self->desktop)->x - self->frame->size.left;
1556             w = screen_area(self->desktop)->x +
1557                 screen_area(self->desktop)->width;
1558         }
1559         if (dir == 0 || dir == 2) { /* vert */
1560             y = screen_area(self->desktop)->y;
1561             h = screen_area(self->desktop)->y +
1562                 screen_area(self->desktop)->height -
1563                 self->frame->size.top - self->frame->size.bottom;
1564         }
1565     } else {
1566         long *dimensions;
1567
1568         if (PROP_GET32A(self->window, openbox_premax, cardinal,
1569                         dimensions, 4)) {
1570             if (dir == 0 || dir == 1) { /* horz */
1571                 x = dimensions[0];
1572                 w = dimensions[2];
1573             }
1574             if (dir == 0 || dir == 2) { /* vert */
1575                 y = dimensions[1];
1576                 h = dimensions[3];
1577             }
1578             g_free(dimensions);
1579         } else {
1580             /* pick some fallbacks... */
1581             if (dir == 0 || dir == 1) { /* horz */
1582                 x = screen_area(self->desktop)->x +
1583                     screen_area(self->desktop)->width / 4;
1584                 w = screen_area(self->desktop)->width / 2;
1585             }
1586             if (dir == 0 || dir == 2) { /* vert */
1587                 y = screen_area(self->desktop)->y +
1588                     screen_area(self->desktop)->height / 4;
1589                 h = screen_area(self->desktop)->height / 2;
1590             }
1591         }
1592     }
1593
1594     if (dir == 0 || dir == 1) /* horz */
1595         self->max_horz = max;
1596     if (dir == 0 || dir == 2) /* vert */
1597         self->max_vert = max;
1598
1599     if (!self->max_horz && !self->max_vert)
1600         PROP_ERASE(self->window, openbox_premax);
1601
1602     client_change_state(self); /* change the state hints on the client */
1603
1604     /* figure out where the client should be going */
1605     frame_frame_gravity(self->frame, &x, &y);
1606     client_configure(self, Corner_TopLeft, x, y, w, h, TRUE, TRUE);
1607 }
1608
1609 void client_shade(Client *self, gboolean shade)
1610 {
1611     if (!(self->functions & Func_Shade) || /* can't */
1612         self->shaded == shade) return;     /* already done */
1613
1614     /* when we're iconic, don't change the wmstate */
1615     if (!self->iconic)
1616         self->wmstate = shade ? IconicState : NormalState;
1617     self->shaded = shade;
1618     client_change_state(self);
1619     engine_frame_adjust_size(self->frame);
1620 }
1621
1622 void client_close(Client *self)
1623 {
1624     XEvent ce;
1625
1626     if (!(self->functions & Func_Close)) return;
1627
1628     /*
1629       XXX: itd be cool to do timeouts and shit here for killing the client's
1630       process off
1631       like... if the window is around after 5 seconds, then the close button
1632       turns a nice red, and if this function is called again, the client is
1633       explicitly killed.
1634     */
1635
1636     ce.xclient.type = ClientMessage;
1637     ce.xclient.message_type =  prop_atoms.wm_protocols;
1638     ce.xclient.display = ob_display;
1639     ce.xclient.window = self->window;
1640     ce.xclient.format = 32;
1641     ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
1642     ce.xclient.data.l[1] = CurrentTime;
1643     ce.xclient.data.l[2] = 0l;
1644     ce.xclient.data.l[3] = 0l;
1645     ce.xclient.data.l[4] = 0l;
1646     XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
1647 }
1648
1649 void client_set_desktop(Client *self, unsigned int target)
1650 {
1651     if (target == self->desktop) return;
1652
1653     g_message("Setting desktop %u\n", target);
1654
1655     if (!(target < screen_num_desktops ||
1656           target == DESKTOP_ALL))
1657         return;
1658
1659     self->desktop = target;
1660     PROP_SET32(self->window, net_wm_desktop, cardinal, target);
1661     /* the frame can display the current desktop state */
1662     engine_frame_adjust_state(self->frame);
1663     /* 'move' the window to the new desktop */
1664     client_showhide(self);
1665     screen_update_struts();
1666 }
1667
1668 static Client *search_modal_tree(Client *node, Client *skip)
1669 {
1670     GSList *it;
1671     Client *ret;
1672
1673     for (it = node->transients; it != NULL; it = it->next) {
1674         Client *c = it->data;
1675         if (c == skip) continue; /* circular? */
1676         if ((ret = search_modal_tree(c, skip))) return ret;
1677         if (c->modal) return c;
1678     }
1679     return NULL;
1680 }
1681
1682 Client *client_find_modal_child(Client *self)
1683 {
1684     return search_modal_tree(self, self);
1685 }
1686
1687 gboolean client_validate(Client *self)
1688 {
1689     XEvent e;
1690
1691     XSync(ob_display, FALSE); /* get all events on the server */
1692
1693     if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
1694         XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
1695         XPutBackEvent(ob_display, &e);
1696         return FALSE;
1697     }
1698
1699     return TRUE;
1700 }
1701
1702 void client_set_wm_state(Client *self, long state)
1703 {
1704     if (state == self->wmstate) return; /* no change */
1705
1706     switch (state) {
1707     case IconicState:
1708         client_iconify(self, TRUE, TRUE);
1709         break;
1710     case NormalState:
1711         client_iconify(self, FALSE, TRUE);
1712         break;
1713     }
1714 }
1715
1716 void client_set_state(Client *self, Atom action, long data1, long data2)
1717 {
1718     gboolean shaded = self->shaded;
1719     gboolean fullscreen = self->fullscreen;
1720     gboolean max_horz = self->max_horz;
1721     gboolean max_vert = self->max_vert;
1722     int i;
1723
1724     if (!(action == prop_atoms.net_wm_state_add ||
1725           action == prop_atoms.net_wm_state_remove ||
1726           action == prop_atoms.net_wm_state_toggle))
1727         /* an invalid action was passed to the client message, ignore it */
1728         return;
1729
1730     for (i = 0; i < 2; ++i) {
1731         Atom state = i == 0 ? data1 : data2;
1732
1733         if (!state) continue;
1734
1735         /* if toggling, then pick whether we're adding or removing */
1736         if (action == prop_atoms.net_wm_state_toggle) {
1737             if (state == prop_atoms.net_wm_state_modal)
1738                 action = self->modal ? prop_atoms.net_wm_state_remove :
1739                     prop_atoms.net_wm_state_add;
1740             else if (state == prop_atoms.net_wm_state_maximized_vert)
1741                 action = self->max_vert ? prop_atoms.net_wm_state_remove :
1742                     prop_atoms.net_wm_state_add;
1743             else if (state == prop_atoms.net_wm_state_maximized_horz)
1744                 action = self->max_horz ? prop_atoms.net_wm_state_remove :
1745                     prop_atoms.net_wm_state_add;
1746             else if (state == prop_atoms.net_wm_state_shaded)
1747                 action = self->shaded ? prop_atoms.net_wm_state_remove :
1748                     prop_atoms.net_wm_state_add;
1749             else if (state == prop_atoms.net_wm_state_skip_taskbar)
1750                 action = self->skip_taskbar ?
1751                     prop_atoms.net_wm_state_remove :
1752                     prop_atoms.net_wm_state_add;
1753             else if (state == prop_atoms.net_wm_state_skip_pager)
1754                 action = self->skip_pager ?
1755                     prop_atoms.net_wm_state_remove :
1756                     prop_atoms.net_wm_state_add;
1757             else if (state == prop_atoms.net_wm_state_fullscreen)
1758                 action = self->fullscreen ?
1759                     prop_atoms.net_wm_state_remove :
1760                     prop_atoms.net_wm_state_add;
1761             else if (state == prop_atoms.net_wm_state_above)
1762                 action = self->above ? prop_atoms.net_wm_state_remove :
1763                     prop_atoms.net_wm_state_add;
1764             else if (state == prop_atoms.net_wm_state_below)
1765                 action = self->below ? prop_atoms.net_wm_state_remove :
1766                     prop_atoms.net_wm_state_add;
1767         }
1768
1769         if (action == prop_atoms.net_wm_state_add) {
1770             if (state == prop_atoms.net_wm_state_modal) {
1771                 /* XXX raise here or something? */
1772                 self->modal = TRUE;
1773             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
1774                 max_vert = TRUE;
1775             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
1776                 max_horz = TRUE;
1777             } else if (state == prop_atoms.net_wm_state_shaded) {
1778                 shaded = TRUE;
1779             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
1780                 self->skip_taskbar = TRUE;
1781             } else if (state == prop_atoms.net_wm_state_skip_pager) {
1782                 self->skip_pager = TRUE;
1783             } else if (state == prop_atoms.net_wm_state_fullscreen) {
1784                 fullscreen = TRUE;
1785             } else if (state == prop_atoms.net_wm_state_above) {
1786                 self->above = TRUE;
1787             } else if (state == prop_atoms.net_wm_state_below) {
1788                 self->below = TRUE;
1789             }
1790
1791         } else { /* action == prop_atoms.net_wm_state_remove */
1792             if (state == prop_atoms.net_wm_state_modal) {
1793                 self->modal = FALSE;
1794             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
1795                 max_vert = FALSE;
1796             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
1797                 max_horz = FALSE;
1798             } else if (state == prop_atoms.net_wm_state_shaded) {
1799                 shaded = FALSE;
1800             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
1801                 self->skip_taskbar = FALSE;
1802             } else if (state == prop_atoms.net_wm_state_skip_pager) {
1803                 self->skip_pager = FALSE;
1804             } else if (state == prop_atoms.net_wm_state_fullscreen) {
1805                 fullscreen = FALSE;
1806             } else if (state == prop_atoms.net_wm_state_above) {
1807                 self->above = FALSE;
1808             } else if (state == prop_atoms.net_wm_state_below) {
1809                 self->below = FALSE;
1810             }
1811         }
1812     }
1813     if (max_horz != self->max_horz || max_vert != self->max_vert) {
1814         if (max_horz != self->max_horz && max_vert != self->max_vert) {
1815             /* toggling both */
1816             if (max_horz == max_vert) { /* both going the same way */
1817                 client_maximize(self, max_horz, 0, TRUE);
1818             } else {
1819                 client_maximize(self, max_horz, 1, TRUE);
1820                 client_maximize(self, max_vert, 2, TRUE);
1821             }
1822         } else {
1823             /* toggling one */
1824             if (max_horz != self->max_horz)
1825                 client_maximize(self, max_horz, 1, TRUE);
1826             else
1827                 client_maximize(self, max_vert, 2, TRUE);
1828         }
1829     }
1830     /* change fullscreen state before shading, as it will affect if the window
1831        can shade or not */
1832     if (fullscreen != self->fullscreen)
1833         client_fullscreen(self, fullscreen, TRUE);
1834     if (shaded != self->shaded)
1835         client_shade(self, shaded);
1836     client_calc_layer(self);
1837     client_change_state(self); /* change the hint to relect these changes */
1838 }
1839
1840 gboolean client_focus(Client *self)
1841 {
1842     XEvent ev;
1843     Client *child;
1844
1845     /* if we have a modal child, then focus it, not us */
1846     child = client_find_modal_child(self);
1847     if (child)
1848         return client_focus(child);
1849
1850     /* won't try focus if the client doesn't want it, or if the window isn't
1851        visible on the screen */
1852     if (!(self->frame->visible &&
1853           (self->can_focus || self->focus_notify)))
1854         return FALSE;
1855
1856     /* do a check to see if the window has already been unmapped or destroyed
1857        do this intelligently while watching out for unmaps we've generated
1858        (ignore_unmaps > 0) */
1859     if (XCheckTypedWindowEvent(ob_display, self->window,
1860                                DestroyNotify, &ev)) {
1861         XPutBackEvent(ob_display, &ev);
1862         return FALSE;
1863     }
1864     while (XCheckTypedWindowEvent(ob_display, self->window,
1865                                   UnmapNotify, &ev)) {
1866         if (self->ignore_unmaps) {
1867             self->ignore_unmaps--;
1868         } else {
1869             XPutBackEvent(ob_display, &ev);
1870             return FALSE;
1871         }
1872     }
1873
1874     if (self->can_focus)
1875         XSetInputFocus(ob_display, self->window, RevertToNone, CurrentTime);
1876
1877     if (self->focus_notify) {
1878         XEvent ce;
1879         ce.xclient.type = ClientMessage;
1880         ce.xclient.message_type = prop_atoms.wm_protocols;
1881         ce.xclient.display = ob_display;
1882         ce.xclient.window = self->window;
1883         ce.xclient.format = 32;
1884         ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
1885         ce.xclient.data.l[1] = event_lasttime;
1886         ce.xclient.data.l[2] = 0l;
1887         ce.xclient.data.l[3] = 0l;
1888         ce.xclient.data.l[4] = 0l;
1889         XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
1890     }
1891
1892     /*XSync(ob_display, FALSE); XXX Why sync? */
1893     return TRUE;
1894 }
1895
1896 void client_unfocus(Client *self)
1897 {
1898     g_assert(focus_client == self);
1899     focus_set_client(NULL);
1900 }