openbox/client.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    client.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "client.h"
  21 #include "debug.h"
  22 #include "startupnotify.h"
  23 #include "dock.h"
  24 #include "xerror.h"
  25 #include "screen.h"
  26 #include "moveresize.h"
  27 #include "place.h"
  28 #include "prop.h"
  29 #include "extensions.h"
  30 #include "frame.h"
  31 #include "session.h"
  32 #include "event.h"
  33 #include "grab.h"
  34 #include "focus.h"
  35 #include "propwin.h"
  36 #include "stacking.h"
  37 #include "openbox.h"
  38 #include "group.h"
  39 #include "config.h"
  40 #include "menuframe.h"
  41 #include "keyboard.h"
  42 #include "mouse.h"
  43 #include "render/render.h"
  44
  45 #ifdef HAVE_UNISTD_H
  46 #  include <unistd.h>
  47 #endif
  48
  49 #include <glib.h>
  50 #include <X11/Xutil.h>
  51
  52 /*! The event mask to grab on client windows */
  53 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
  54                           ColormapChangeMask)
  55
  56 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
  57                                 ButtonMotionMask)
  58
  59 typedef struct
  60 {
  61     ObClientCallback func;
  62     gpointer data;
  63 } ClientCallback;
  64
  65 GList            *client_list          = NULL;
  66
  67 static GSList *client_destroy_notifies = NULL;
  68
  69 static void client_get_all(ObClient *self, gboolean real);
  70 static void client_get_startup_id(ObClient *self);
  71 static void client_get_session_ids(ObClient *self);
  72 static void client_get_area(ObClient *self);
  73 static void client_get_desktop(ObClient *self);
  74 static void client_get_state(ObClient *self);
  75 static void client_get_shaped(ObClient *self);
  76 static void client_get_mwm_hints(ObClient *self);
  77 static void client_get_colormap(ObClient *self);
  78 static void client_change_allowed_actions(ObClient *self);
  79 static void client_change_state(ObClient *self);
  80 static void client_change_wm_state(ObClient *self);
  81 static void client_apply_startup_state(ObClient *self,
  82                                        gint x, gint y, gint w, gint h);
  83 static void client_restore_session_state(ObClient *self);
  84 static gboolean client_restore_session_stacking(ObClient *self);
  85 static ObAppSettings *client_get_settings_state(ObClient *self);
  86 static void client_update_transient_tree(ObClient *self,
  87                                          ObGroup *oldgroup, ObGroup *newgroup,
  88                                          gboolean oldgtran, gboolean newgtran,
  89                                          ObClient* oldparent,
  90                                          ObClient *newparent);
  91 static void client_present(ObClient *self, gboolean here, gboolean raise);
  92 static GSList *client_search_all_top_parents_internal(ObClient *self,
  93                                                       gboolean bylayer,
  94                                                       ObStackingLayer layer);
  95 static void client_call_notifies(ObClient *self, GSList *list);
  96
  97
  98 void client_startup(gboolean reconfig)
  99 {
 100     if (reconfig) return;
 101
 102     client_set_list();
 103 }
 104
 105 void client_shutdown(gboolean reconfig)
 106 {
 107     if (reconfig) return;
 108 }
 109
 110 static void client_call_notifies(ObClient *self, GSList *list)
 111 {
 112     GSList *it;
 113
 114     for (it = list; it; it = g_slist_next(it)) {
 115         ClientCallback *d = it->data;
 116         d->func(self, d->data);
 117     }
 118 }
 119
 120 void client_add_destroy_notify(ObClientCallback func, gpointer data)
 121 {
 122     ClientCallback *d = g_new(ClientCallback, 1);
 123     d->func = func;
 124     d->data = data;
 125     client_destroy_notifies = g_slist_prepend(client_destroy_notifies, d);
 126 }
 127
 128 void client_remove_destroy_notify(ObClientCallback func)
 129 {
 130     GSList *it;
 131
 132     for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
 133         ClientCallback *d = it->data;
 134         if (d->func == func) {
 135             g_free(d);
 136             client_destroy_notifies =
 137                 g_slist_delete_link(client_destroy_notifies, it);
 138             break;
 139         }
 140     }
 141 }
 142
 143 void client_set_list()
 144 {
 145     Window *windows, *win_it;
 146     GList *it;
 147     guint size = g_list_length(client_list);
 148
 149     /* create an array of the window ids */
 150     if (size > 0) {
 151         windows = g_new(Window, size);
 152         win_it = windows;
 153         for (it = client_list; it; it = g_list_next(it), ++win_it)
 154             *win_it = ((ObClient*)it->data)->window;
 155     } else
 156         windows = NULL;
 157
 158     PROP_SETA32(RootWindow(ob_display, ob_screen),
 159                 net_client_list, window, (gulong*)windows, size);
 160
 161     if (windows)
 162         g_free(windows);
 163
 164     stacking_set_list();
 165 }
 166
 167 void client_manage_all()
 168 {
 169     guint i, j, nchild;
 170     Window w, *children;
 171     XWMHints *wmhints;
 172     XWindowAttributes attrib;
 173
 174     XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
 175                &w, &w, &children, &nchild);
 176
 177     /* remove all icon windows from the list */
 178     for (i = 0; i < nchild; i++) {
 179         if (children[i] == None) continue;
 180         wmhints = XGetWMHints(ob_display, children[i]);
 181         if (wmhints) {
 182             if ((wmhints->flags & IconWindowHint) &&
 183                 (wmhints->icon_window != children[i]))
 184                 for (j = 0; j < nchild; j++)
 185                     if (children[j] == wmhints->icon_window) {
 186                         children[j] = None;
 187                         break;
 188                     }
 189             XFree(wmhints);
 190         }
 191     }
 192
 193     for (i = 0; i < nchild; ++i) {
 194         if (children[i] == None)
 195             continue;
 196         if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
 197             if (attrib.override_redirect) continue;
 198
 199             if (attrib.map_state != IsUnmapped)
 200                 client_manage(children[i]);
 201         }
 202     }
 203     XFree(children);
 204 }
 205
 206 void client_manage(Window window)
 207 {
 208     ObClient *self;
 209     XEvent e;
 210     XWindowAttributes attrib;
 211     XSetWindowAttributes attrib_set;
 212     XWMHints *wmhint;
 213     gboolean activate = FALSE;
 214     ObAppSettings *settings;
 215     gint placex, placey, placew, placeh;
 216     gboolean transient = FALSE;
 217
 218     grab_server(TRUE);
 219
 220     /* check if it has already been unmapped by the time we started
 221        mapping. the grab does a sync so we don't have to here */
 222     if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
 223         XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e))
 224     {
 225         XPutBackEvent(ob_display, &e);
 226
 227         ob_debug("Trying to manage unmapped window. Aborting that.\n");
 228         grab_server(FALSE);
 229         return; /* don't manage it */
 230     }
 231
 232     /* make sure it isn't an override-redirect window */
 233     if (!XGetWindowAttributes(ob_display, window, &attrib) ||
 234         attrib.override_redirect)
 235     {
 236         grab_server(FALSE);
 237         return; /* don't manage it */
 238     }
 239
 240     /* is the window a docking app */
 241     if ((wmhint = XGetWMHints(ob_display, window))) {
 242         if ((wmhint->flags & StateHint) &&
 243             wmhint->initial_state == WithdrawnState)
 244         {
 245             dock_add(window, wmhint);
 246             grab_server(FALSE);
 247             XFree(wmhint);
 248             return;
 249         }
 250         XFree(wmhint);
 251     }
 252
 253     ob_debug("Managing window: 0x%lx\n", window);
 254
 255     /* choose the events we want to receive on the CLIENT window */
 256     attrib_set.event_mask = CLIENT_EVENTMASK;
 257     attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
 258     XChangeWindowAttributes(ob_display, window,
 259                             CWEventMask|CWDontPropagate, &attrib_set);
 260
 261     /* create the ObClient struct, and populate it from the hints on the
 262        window */
 263     self = g_new0(ObClient, 1);
 264     self->obwin.type = Window_Client;
 265     self->window = window;
 266
 267     /* non-zero defaults */
 268     self->wmstate = WithdrawnState; /* make sure it gets updated first time */
 269     self->gravity = NorthWestGravity;
 270     self->desktop = screen_num_desktops; /* always an invalid value */
 271     self->user_time = focus_client ? focus_client->user_time : CurrentTime;
 272
 273     /* get all the stuff off the window */
 274     client_get_all(self, TRUE);
 275
 276     /* specify that if we exit, the window should not be destroyed and
 277        should be reparented back to root automatically */
 278     XChangeSaveSet(ob_display, window, SetModeInsert);
 279
 280     /* create the decoration frame for the client window */
 281     self->frame = frame_new(self);
 282
 283     frame_grab_client(self->frame);
 284
 285     /* we've grabbed everything and set everything that we need to at mapping
 286        time now */
 287     grab_server(FALSE);
 288
 289     /* per-app settings override stuff from client_get_all, and return the
 290        settings for other uses too. the returned settings is a shallow copy,
 291        that needs to be freed with g_free(). */
 292     settings = client_get_settings_state(self);
 293     /* the session should get the last say though */
 294     client_restore_session_state(self);
 295
 296     /* now we have all of the window's information so we can set this up */
 297     client_setup_decor_and_functions(self, FALSE);
 298
 299     {
 300         Time t = sn_app_started(self->startup_id, self->class);
 301         if (t) self->user_time = t;
 302     }
 303
 304     /* do this after we have a frame.. it uses the frame to help determine the
 305        WM_STATE to apply. */
 306     client_change_state(self);
 307
 308     /* add ourselves to the focus order */
 309     focus_order_add_new(self);
 310
 311     /* do this to add ourselves to the stacking list in a non-intrusive way */
 312     client_calc_layer(self);
 313
 314     /* focus the new window? */
 315     if (ob_state() != OB_STATE_STARTING &&
 316         (!self->session || self->session->focused) &&
 317         !self->iconic &&
 318         /* this means focus=true for window is same as config_focus_new=true */
 319         ((config_focus_new || (settings && settings->focus == 1)) ||
 320          client_search_focus_tree_full(self)) &&
 321         /* this checks for focus=false for the window */
 322         (!settings || settings->focus != 0) &&
 323         /* note the check against type Normal/Dialog/Utility,
 324            not client_normal(self), which would also include other types.
 325            in this case we want more strict rules for focus */
 326         (self->type == OB_CLIENT_TYPE_NORMAL ||
 327          self->type == OB_CLIENT_TYPE_UTILITY ||
 328          self->type == OB_CLIENT_TYPE_DIALOG))
 329     {
 330         activate = TRUE;
 331     }
 332
 333     /* remove the client's border */
 334     XSetWindowBorderWidth(ob_display, self->window, 0);
 335
 336     /* adjust the frame to the client's size before showing or placing
 337        the window */
 338     frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
 339     frame_adjust_client_area(self->frame);
 340
 341     /* where the frame was placed is where the window was originally */
 342     placex = self->area.x;
 343     placey = self->area.y;
 344     placew = self->area.width;
 345     placeh = self->area.height;
 346
 347     /* figure out placement for the window if the window is new */
 348     if (ob_state() == OB_STATE_RUNNING) {
 349         ob_debug("Positioned: %s @ %d %d\n",
 350                  (!self->positioned ? "no" :
 351                   (self->positioned == PPosition ? "program specified" :
 352                    (self->positioned == USPosition ? "user specified" :
 353                     (self->positioned == (PPosition | USPosition) ?
 354                      "program + user specified" :
 355                      "BADNESS !?")))), placex, placey);
 356
 357         ob_debug("Sized: %s @ %d %d\n",
 358                  (!self->sized ? "no" :
 359                   (self->sized == PSize ? "program specified" :
 360                    (self->sized == USSize ? "user specified" :
 361                     (self->sized == (PSize | USSize) ?
 362                      "program + user specified" :
 363                      "BADNESS !?")))), placew, placeh);
 364
 365         /* splash screens are also returned as TRUE for transient,
 366            and so will be forced on screen below */
 367         transient = place_client(self, &placex, &placey, settings);
 368
 369         /* make sure the window is visible. */
 370         client_find_onscreen(self, &placex, &placey, placew, placeh,
 371                              /* non-normal clients has less rules, and
 372                                 windows that are being restored from a
 373                                 session do also. we can assume you want
 374                                 it back where you saved it. Clients saying
 375                                 they placed themselves are subjected to
 376                                 harder rules, ones that are placed by
 377                                 place.c or by the user are allowed partially
 378                                 off-screen and on xinerama divides (ie,
 379                                 it is up to the placement routines to avoid
 380                                 the xinerama divides)
 381
 382                                 splash screens get "transient" set to TRUE by
 383                                 the place_client call
 384                              */
 385                              ob_state() == OB_STATE_RUNNING &&
 386                              (transient ||
 387                               (!(self->positioned & USPosition) &&
 388                                client_normal(self) &&
 389                                !self->session)));
 390     }
 391
 392     /* if the window isn't user-sized, then make it fit inside
 393        the visible screen area on its monitor. Use basically the same rules
 394        for forcing the window on screen in the client_find_onscreen call.
 395
 396        do this after place_client, it chooses the monitor!
 397
 398        splash screens get "transient" set to TRUE by
 399        the place_client call
 400     */
 401     if (ob_state() == OB_STATE_RUNNING &&
 402         (transient ||
 403          (!(self->sized & USSize) &&
 404           client_normal(self) &&
 405           !self->session)))
 406     {
 407         /* make a copy to modify */
 408         Rect a = *screen_area_monitor(self->desktop, client_monitor(self));
 409
 410         /* shrink by the frame's area */
 411         a.width -= self->frame->size.left + self->frame->size.right;
 412         a.height -= self->frame->size.top + self->frame->size.bottom;
 413
 414         /* fit the window inside the area */
 415         if (placew > a.width || self->area.height > a.height) {
 416             placew = MIN(self->area.width, a.width);
 417             placeh = MIN(self->area.height, a.height);
 418
 419             ob_debug("setting window size to %dx%d\n",
 420                      self->area.width, self->area.height);
 421         }
 422     }
 423
 424
 425     ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
 426              "some restrictions may apply\n",
 427              self->window, placex, placey, placew, placeh);
 428     if (self->session)
 429         ob_debug("  but session requested %d, %d  %d x %d instead, "
 430                  "overriding\n",
 431                  self->session->x, self->session->y,
 432                  self->session->w, self->session->h);
 433
 434     /* do this after the window is placed, so the premax/prefullscreen numbers
 435        won't be all wacko!!
 436
 437        this also places the window
 438     */
 439     client_apply_startup_state(self, placex, placey, placew, placeh);
 440
 441     if (activate) {
 442         guint32 last_time = focus_client ?
 443             focus_client->user_time : CurrentTime;
 444
 445         /* This is focus stealing prevention */
 446         ob_debug_type(OB_DEBUG_FOCUS,
 447                       "Want to focus new window 0x%x with time %u "
 448                       "(last time %u)\n",
 449                       self->window, self->user_time, last_time);
 450
 451         /* if it's on another desktop */
 452         if (!(self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
 453             && /* the timestamp is from before you changed desktops */
 454             self->user_time && screen_desktop_user_time &&
 455             !event_time_after(self->user_time, screen_desktop_user_time))
 456         {
 457             activate = FALSE;
 458             ob_debug_type(OB_DEBUG_FOCUS,
 459                           "Not focusing the window because its on another "
 460                           "desktop\n");
 461         }
 462         /* If something is focused, and it's not our relative... */
 463         else if (focus_client && client_search_focus_tree_full(self) == NULL &&
 464                  client_search_focus_group_full(self) == NULL)
 465         {
 466             /* If time stamp is old, don't steal focus */
 467             if (self->user_time && last_time &&
 468                 !event_time_after(self->user_time, last_time))
 469             {
 470                 activate = FALSE;
 471                 ob_debug_type(OB_DEBUG_FOCUS,
 472                               "Not focusing the window because the time is "
 473                               "too old\n");
 474             }
 475             /* If its a transient (and parents aren't focused) and the time
 476                is ambiguous (either the current focus target doesn't have
 477                a timestamp, or they are the same (we probably inherited it
 478                from them) */
 479             else if (client_has_parent(self) &&
 480                      (!last_time || self->user_time == last_time))
 481             {
 482                 activate = FALSE;
 483                 ob_debug_type(OB_DEBUG_FOCUS,
 484                               "Not focusing the window because it is a "
 485                               "transient, and the time is very ambiguous\n");
 486             }
 487             /* Don't steal focus from globally active clients.
 488                I stole this idea from KWin. It seems nice.
 489              */
 490             else if (!(focus_client->can_focus ||
 491                        focus_client->focus_notify))
 492             {
 493                 activate = FALSE;
 494                 ob_debug_type(OB_DEBUG_FOCUS,
 495                               "Not focusing the window because a globally "
 496                               "active client has focus\n");
 497             }
 498             /* Don't move focus if it's not going to go to this window
 499                anyway */
 500             else if (client_focus_target(self) != self) {
 501                 activate = FALSE;
 502                 ob_debug_type(OB_DEBUG_FOCUS,
 503                               "Not focusing the window because another window "
 504                               "would get the focus anyway\n");
 505             }
 506         }
 507
 508         if (!activate) {
 509             ob_debug_type(OB_DEBUG_FOCUS,
 510                           "Focus stealing prevention activated for %s with "
 511                           "time %u (last time %u)\n",
 512                           self->title, self->user_time, last_time);
 513             /* if the client isn't focused, then hilite it so the user
 514                knows it is there */
 515             client_hilite(self, TRUE);
 516         }
 517     }
 518     else {
 519         /* This may look rather odd. Well it's because new windows are added
 520            to the stacking order non-intrusively. If we're not going to focus
 521            the new window or hilite it, then we raise it to the top. This will
 522            take affect for things that don't get focused like splash screens.
 523            Also if you don't have focus_new enabled, then it's going to get
 524            raised to the top. Legacy begets legacy I guess?
 525         */
 526         if (!client_restore_session_stacking(self))
 527             stacking_raise(CLIENT_AS_WINDOW(self));
 528     }
 529
 530     mouse_grab_for_client(self, TRUE);
 531
 532     /* this has to happen before we try focus the window, but we want it to
 533        happen after the client's stacking has been determined or it looks bad
 534     */
 535     client_show(self);
 536
 537     if (activate) {
 538         gboolean stacked = client_restore_session_stacking(self);
 539         client_present(self, FALSE, !stacked);
 540     }
 541
 542     /* add to client list/map */
 543     client_list = g_list_append(client_list, self);
 544     g_hash_table_insert(window_map, &self->window, self);
 545
 546     /* this has to happen after we're in the client_list */
 547     if (STRUT_EXISTS(self->strut))
 548         screen_update_areas();
 549
 550     /* update the list hints */
 551     client_set_list();
 552
 553     /* free the ObAppSettings shallow copy */
 554     g_free(settings);
 555
 556     ob_debug("Managed window 0x%lx plate 0x%x (%s)\n",
 557              window, self->frame->window, self->class);
 558
 559     return;
 560 }
 561
 562
 563 ObClient *client_fake_manage(Window window)
 564 {
 565     ObClient *self;
 566     ObAppSettings *settings;
 567
 568     ob_debug("Pretend-managing window: %lx\n", window);
 569
 570     /* do this minimal stuff to figure out the client's decorations */
 571
 572     self = g_new0(ObClient, 1);
 573     self->window = window;
 574
 575     client_get_all(self, FALSE);
 576     /* per-app settings override stuff, and return the settings for other
 577        uses too. this returns a shallow copy that needs to be freed */
 578     settings = client_get_settings_state(self);
 579
 580     client_setup_decor_and_functions(self, FALSE);
 581
 582     /* create the decoration frame for the client window and adjust its size */
 583     self->frame = frame_new(self);
 584     frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
 585
 586     ob_debug("gave extents left %d right %d top %d bottom %d\n",
 587              self->frame->size.left, self->frame->size.right,
 588              self->frame->size.top, self->frame->size.bottom);
 589
 590     /* free the ObAppSettings shallow copy */
 591     g_free(settings);
 592
 593     return self;
 594 }
 595
 596 void client_unmanage_all()
 597 {
 598     while (client_list != NULL)
 599         client_unmanage(client_list->data);
 600 }
 601
 602 void client_unmanage(ObClient *self)
 603 {
 604     guint j;
 605     GSList *it;
 606     gulong ignore_start;
 607
 608     ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n",
 609              self->window, self->frame->window,
 610              self->class, self->title ? self->title : "");
 611
 612     g_assert(self != NULL);
 613
 614     /* we dont want events no more. do this before hiding the frame so we
 615        don't generate more events */
 616     XSelectInput(ob_display, self->window, NoEventMask);
 617
 618     /* ignore enter events from the unmap so it doesnt mess with the focus */
 619     if (!client_focused(self) || !config_focus_under_mouse)
 620         ignore_start = event_start_ignore_all_enters();
 621
 622     frame_hide(self->frame);
 623     /* flush to send the hide to the server quickly */
 624     XFlush(ob_display);
 625
 626     if (!client_focused(self) || !config_focus_under_mouse)
 627         event_end_ignore_all_enters(ignore_start);
 628
 629     mouse_grab_for_client(self, FALSE);
 630
 631     /* remove the window from our save set */
 632     XChangeSaveSet(ob_display, self->window, SetModeDelete);
 633
 634     /* kill the property windows */
 635     propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self);
 636
 637     /* update the focus lists */
 638     focus_order_remove(self);
 639     if (client_focused(self)) {
 640         /* don't leave an invalid focus_client */
 641         focus_client = NULL;
 642     }
 643
 644     client_list = g_list_remove(client_list, self);
 645     stacking_remove(self);
 646     g_hash_table_remove(window_map, &self->window);
 647
 648     /* once the client is out of the list, update the struts to remove its
 649        influence */
 650     if (STRUT_EXISTS(self->strut))
 651         screen_update_areas();
 652
 653     client_call_notifies(self, client_destroy_notifies);
 654
 655     /* tell our parent(s) that we're gone */
 656     for (it = self->parents; it; it = g_slist_next(it))
 657         ((ObClient*)it->data)->transients =
 658             g_slist_remove(((ObClient*)it->data)->transients,self);
 659
 660     /* tell our transients that we're gone */
 661     for (it = self->transients; it; it = g_slist_next(it)) {
 662         ((ObClient*)it->data)->parents =
 663             g_slist_remove(((ObClient*)it->data)->parents, self);
 664         /* we could be keeping our children in a higher layer */
 665         client_calc_layer(it->data);
 666     }
 667
 668     /* remove from its group */
 669     if (self->group) {
 670         group_remove(self->group, self);
 671         self->group = NULL;
 672     }
 673
 674     /* restore the window's original geometry so it is not lost */
 675     {
 676         Rect a;
 677
 678         a = self->area;
 679
 680         if (self->fullscreen)
 681             a = self->pre_fullscreen_area;
 682         else if (self->max_horz || self->max_vert) {
 683             if (self->max_horz) {
 684                 a.x = self->pre_max_area.x;
 685                 a.width = self->pre_max_area.width;
 686             }
 687             if (self->max_vert) {
 688                 a.y = self->pre_max_area.y;
 689                 a.height = self->pre_max_area.height;
 690             }
 691         }
 692
 693         self->fullscreen = self->max_horz = self->max_vert = FALSE;
 694         /* let it be moved and resized no matter what */
 695         self->functions = OB_CLIENT_FUNC_MOVE | OB_CLIENT_FUNC_RESIZE;
 696         self->decorations = 0; /* unmanaged windows have no decor */
 697
 698         /* give the client its border back */
 699         XSetWindowBorderWidth(ob_display, self->window, self->border_width);
 700
 701         client_move_resize(self, a.x, a.y, a.width, a.height);
 702     }
 703
 704     /* reparent the window out of the frame, and free the frame */
 705     frame_release_client(self->frame);
 706     frame_free(self->frame);
 707     self->frame = NULL;
 708
 709     if (ob_state() != OB_STATE_EXITING) {
 710         /* these values should not be persisted across a window
 711            unmapping/mapping */
 712         PROP_ERASE(self->window, net_wm_desktop);
 713         PROP_ERASE(self->window, net_wm_state);
 714         PROP_ERASE(self->window, wm_state);
 715     } else {
 716         /* if we're left in an unmapped state, the client wont be mapped.
 717            this is bad, since we will no longer be managing the window on
 718            restart */
 719         XMapWindow(ob_display, self->window);
 720     }
 721
 722     /* update the list hints */
 723     client_set_list();
 724
 725     ob_debug("Unmanaged window 0x%lx\n", self->window);
 726
 727     /* free all data allocated in the client struct */
 728     g_slist_free(self->transients);
 729     for (j = 0; j < self->nicons; ++j)
 730         g_free(self->icons[j].data);
 731     if (self->nicons > 0)
 732         g_free(self->icons);
 733     g_free(self->wm_command);
 734     g_free(self->title);
 735     g_free(self->icon_title);
 736     g_free(self->name);
 737     g_free(self->class);
 738     g_free(self->role);
 739     g_free(self->client_machine);
 740     g_free(self->sm_client_id);
 741     g_free(self);
 742 }
 743
 744 void client_fake_unmanage(ObClient *self)
 745 {
 746     /* this is all that got allocated to get the decorations */
 747
 748     frame_free(self->frame);
 749     g_free(self);
 750 }
 751
 752 /*! Returns a new structure containing the per-app settings for this client.
 753   The returned structure needs to be freed with g_free. */
 754 static ObAppSettings *client_get_settings_state(ObClient *self)
 755 {
 756     ObAppSettings *settings;
 757     GSList *it;
 758
 759     settings = config_create_app_settings();
 760
 761     for (it = config_per_app_settings; it; it = g_slist_next(it)) {
 762         ObAppSettings *app = it->data;
 763         gboolean match = TRUE;
 764
 765         g_assert(app->name != NULL || app->class != NULL);
 766
 767         /* we know that either name or class is not NULL so it will have to
 768            match to use the rule */
 769         if (app->name &&
 770             !g_pattern_match(app->name, strlen(self->name), self->name, NULL))
 771             match = FALSE;
 772         else if (app->class &&
 773                 !g_pattern_match(app->class,
 774                                  strlen(self->class), self->class, NULL))
 775             match = FALSE;
 776         else if (app->role &&
 777                  !g_pattern_match(app->role,
 778                                   strlen(self->role), self->role, NULL))
 779             match = FALSE;
 780
 781         if (match) {
 782             ob_debug("Window matching: %s\n", app->name);
 783
 784             /* copy the settings to our struct, overriding the existing
 785                settings if they are not defaults */
 786             config_app_settings_copy_non_defaults(app, settings);
 787         }
 788     }
 789
 790     if (settings->shade != -1)
 791         self->shaded = !!settings->shade;
 792     if (settings->decor != -1)
 793         self->undecorated = !settings->decor;
 794     if (settings->iconic != -1)
 795         self->iconic = !!settings->iconic;
 796     if (settings->skip_pager != -1)
 797         self->skip_pager = !!settings->skip_pager;
 798     if (settings->skip_taskbar != -1)
 799         self->skip_taskbar = !!settings->skip_taskbar;
 800
 801     if (settings->max_vert != -1)
 802         self->max_vert = !!settings->max_vert;
 803     if (settings->max_horz != -1)
 804         self->max_horz = !!settings->max_horz;
 805
 806     if (settings->fullscreen != -1)
 807         self->fullscreen = !!settings->fullscreen;
 808
 809     if (settings->desktop) {
 810         if (settings->desktop == DESKTOP_ALL)
 811             self->desktop = settings->desktop;
 812         else if (settings->desktop > 0 &&
 813                  settings->desktop <= screen_num_desktops)
 814             self->desktop = settings->desktop - 1;
 815     }
 816
 817     if (settings->layer == -1) {
 818         self->below = TRUE;
 819         self->above = FALSE;
 820     }
 821     else if (settings->layer == 0) {
 822         self->below = FALSE;
 823         self->above = FALSE;
 824     }
 825     else if (settings->layer == 1) {
 826         self->below = FALSE;
 827         self->above = TRUE;
 828     }
 829     return settings;
 830 }
 831
 832 static void client_restore_session_state(ObClient *self)
 833 {
 834     GList *it;
 835
 836     ob_debug_type(OB_DEBUG_SM,
 837                   "Restore session for client %s\n", self->title);
 838
 839     if (!(it = session_state_find(self))) {
 840         ob_debug_type(OB_DEBUG_SM,
 841                       "Session data not found for client %s\n", self->title);
 842         return;
 843     }
 844
 845     self->session = it->data;
 846
 847     ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s\n",
 848                   self->title);
 849
 850     RECT_SET_POINT(self->area, self->session->x, self->session->y);
 851     self->positioned = USPosition;
 852     self->sized = USSize;
 853     if (self->session->w > 0)
 854         self->area.width = self->session->w;
 855     if (self->session->h > 0)
 856         self->area.height = self->session->h;
 857     XResizeWindow(ob_display, self->window,
 858                   self->area.width, self->area.height);
 859
 860     self->desktop = (self->session->desktop == DESKTOP_ALL ?
 861                      self->session->desktop :
 862                      MIN(screen_num_desktops - 1, self->session->desktop));
 863     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
 864
 865     self->shaded = self->session->shaded;
 866     self->iconic = self->session->iconic;
 867     self->skip_pager = self->session->skip_pager;
 868     self->skip_taskbar = self->session->skip_taskbar;
 869     self->fullscreen = self->session->fullscreen;
 870     self->above = self->session->above;
 871     self->below = self->session->below;
 872     self->max_horz = self->session->max_horz;
 873     self->max_vert = self->session->max_vert;
 874     self->undecorated = self->session->undecorated;
 875 }
 876
 877 static gboolean client_restore_session_stacking(ObClient *self)
 878 {
 879     GList *it, *mypos;
 880
 881     if (!self->session) return FALSE;
 882
 883     mypos = g_list_find(session_saved_state, self->session);
 884     if (!mypos) return FALSE;
 885
 886     /* start above me and look for the first client */
 887     for (it = g_list_previous(mypos); it; it = g_list_previous(it)) {
 888         GList *cit;
 889
 890         for (cit = client_list; cit; cit = g_list_next(cit)) {
 891             ObClient *c = cit->data;
 892             /* found a client that was in the session, so go below it */
 893             if (c->session == it->data) {
 894                 stacking_below(CLIENT_AS_WINDOW(self),
 895                                CLIENT_AS_WINDOW(cit->data));
 896                 return TRUE;
 897             }
 898         }
 899     }
 900     return FALSE;
 901 }
 902
 903 void client_move_onscreen(ObClient *self, gboolean rude)
 904 {
 905     gint x = self->area.x;
 906     gint y = self->area.y;
 907     if (client_find_onscreen(self, &x, &y,
 908                              self->area.width,
 909                              self->area.height, rude)) {
 910         client_move(self, x, y);
 911     }
 912 }
 913
 914 gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h,
 915                               gboolean rude)
 916 {
 917     Rect *mon_a, *all_a;
 918     gint ox = *x, oy = *y;
 919     gboolean rudel = rude, ruder = rude, rudet = rude, rudeb = rude;
 920     gint fw, fh;
 921     Rect desired;
 922
 923     RECT_SET(desired, *x, *y, w, h);
 924     all_a = screen_area(self->desktop);
 925     mon_a = screen_area_monitor(self->desktop, screen_find_monitor(&desired));
 926
 927     /* get where the frame would be */
 928     frame_client_gravity(self->frame, x, y, w, h);
 929
 930     /* get the requested size of the window with decorations */
 931     fw = self->frame->size.left + w + self->frame->size.right;
 932     fh = self->frame->size.top + h + self->frame->size.bottom;
 933
 934     /* This makes sure windows aren't entirely outside of the screen so you
 935        can't see them at all.
 936        It makes sure 10% of the window is on the screen at least. At don't let
 937        it move itself off the top of the screen, which would hide the titlebar
 938        on you. (The user can still do this if they want too, it's only limiting
 939        the application.
 940
 941        XXX watch for xinerama dead areas...
 942     */
 943     if (client_normal(self)) {
 944         if (!self->strut.right && *x + fw/10 >= all_a->x + all_a->width - 1)
 945             *x = all_a->x + all_a->width - fw/10;
 946         if (!self->strut.bottom && *y + fh/10 >= all_a->y + all_a->height - 1)
 947             *y = all_a->y + all_a->height - fh/10;
 948         if (!self->strut.left && *x + fw*9/10 - 1 < all_a->x)
 949             *x = all_a->x - fw*9/10;
 950         if (!self->strut.top && *y + fh*9/10 - 1 < all_a->y)
 951             *y = all_a->y - fw*9/10;
 952     }
 953
 954     /* If rudeness wasn't requested, then figure out of the client is currently
 955        entirely on the screen. If it is, and the position isn't changing by
 956        request, and it is enlarging, then be rude even though it wasn't
 957        requested */
 958     if (!rude) {
 959         Point oldtl, oldtr, oldbl, oldbr;
 960         Point newtl, newtr, newbl, newbr;
 961         gboolean stationary_l, stationary_r, stationary_t, stationary_b;
 962
 963         POINT_SET(oldtl, self->frame->area.x, self->frame->area.y);
 964         POINT_SET(oldbr, self->frame->area.x + self->frame->area.width - 1,
 965                   self->frame->area.y + self->frame->area.height - 1);
 966         POINT_SET(oldtr, oldbr.x, oldtl.y);
 967         POINT_SET(oldbl, oldtl.x, oldbr.y);
 968
 969         POINT_SET(newtl, *x, *y);
 970         POINT_SET(newbr, *x + fw - 1, *y + fh - 1);
 971         POINT_SET(newtr, newbr.x, newtl.y);
 972         POINT_SET(newbl, newtl.x, newbr.y);
 973
 974         /* is it moving or just resizing from some corner? */
 975         stationary_l = oldtl.x == newtl.x;
 976         stationary_r = oldtr.x == newtr.x;
 977         stationary_t = oldtl.y == newtl.y;
 978         stationary_b = oldbl.y == newbl.y;
 979
 980         /* if left edge is growing and didnt move right edge */
 981         if (stationary_r && newtl.x < oldtl.x)
 982             rudel = TRUE;
 983         /* if right edge is growing and didnt move left edge */
 984         if (stationary_l && newtr.x > oldtr.x)
 985             ruder = TRUE;
 986         /* if top edge is growing and didnt move bottom edge */
 987         if (stationary_b && newtl.y < oldtl.y)
 988             rudet = TRUE;
 989         /* if bottom edge is growing and didnt move top edge */
 990         if (stationary_t && newbl.y > oldbl.y)
 991             rudeb = TRUE;
 992     }
 993
 994     /* This here doesn't let windows even a pixel outside the struts/screen.
 995      * When called from client_manage, programs placing themselves are
 996      * forced completely onscreen, while things like
 997      * xterm -geometry resolution-width/2 will work fine. Trying to
 998      * place it completely offscreen will be handled in the above code.
 999      * Sorry for this confused comment, i am tired. */
1000     if (rudel && !self->strut.left && *x < mon_a->x) *x = mon_a->x;
1001     if (ruder && !self->strut.right && *x + fw > mon_a->x + mon_a->width)
1002         *x = mon_a->x + MAX(0, mon_a->width - fw);
1003
1004     if (rudet && !self->strut.top && *y < mon_a->y) *y = mon_a->y;
1005     if (rudeb && !self->strut.bottom && *y + fh > mon_a->y + mon_a->height)
1006         *y = mon_a->y + MAX(0, mon_a->height - fh);
1007
1008     /* get where the client should be */
1009     frame_frame_gravity(self->frame, x, y, w, h);
1010
1011     return ox != *x || oy != *y;
1012 }
1013
1014 static void client_get_all(ObClient *self, gboolean real)
1015 {
1016     /* this is needed for the frame to set itself up */
1017     client_get_area(self);
1018
1019     /* these things can change the decor and functions of the window */
1020
1021     client_get_mwm_hints(self);
1022     /* this can change the mwmhints for special cases */
1023     client_get_type_and_transientness(self);
1024     client_get_state(self);
1025     client_update_normal_hints(self);
1026
1027     /* get the session related properties, these can change decorations
1028        from per-app settings */
1029     client_get_session_ids(self);
1030
1031     /* now we got everything that can affect the decorations */
1032     if (!real)
1033         return;
1034
1035     /* get this early so we have it for debugging */
1036     client_update_title(self);
1037
1038     client_update_protocols(self);
1039
1040     client_update_wmhints(self);
1041     /* this may have already been called from client_update_wmhints */
1042     if (!self->parents && !self->transient_for_group)
1043         client_update_transient_for(self);
1044
1045     client_get_startup_id(self);
1046     client_get_desktop(self);/* uses transient data/group/startup id if a
1047                                 desktop is not specified */
1048     client_get_shaped(self);
1049
1050     {
1051         /* a couple type-based defaults for new windows */
1052
1053         /* this makes sure that these windows appear on all desktops */
1054         if (self->type == OB_CLIENT_TYPE_DESKTOP)
1055             self->desktop = DESKTOP_ALL;
1056     }
1057
1058 #ifdef SYNC
1059     client_update_sync_request_counter(self);
1060 #endif
1061
1062     client_get_colormap(self);
1063     client_update_strut(self);
1064     client_update_icons(self);
1065     client_update_user_time_window(self);
1066     if (!self->user_time_window) /* check if this would have been called */
1067         client_update_user_time(self);
1068     client_update_icon_geometry(self);
1069 }
1070
1071 static void client_get_startup_id(ObClient *self)
1072 {
1073     if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id)))
1074         if (self->group)
1075             PROP_GETS(self->group->leader,
1076                       net_startup_id, utf8, &self->startup_id);
1077 }
1078
1079 static void client_get_area(ObClient *self)
1080 {
1081     XWindowAttributes wattrib;
1082     Status ret;
1083
1084     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
1085     g_assert(ret != BadWindow);
1086
1087     RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
1088     POINT_SET(self->root_pos, wattrib.x, wattrib.y);
1089     self->border_width = wattrib.border_width;
1090
1091     ob_debug("client area: %d %d  %d %d  bw %d\n", wattrib.x, wattrib.y,
1092              wattrib.width, wattrib.height, wattrib.border_width);
1093 }
1094
1095 static void client_get_desktop(ObClient *self)
1096 {
1097     guint32 d = screen_num_desktops; /* an always-invalid value */
1098
1099     if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
1100         if (d >= screen_num_desktops && d != DESKTOP_ALL)
1101             self->desktop = screen_num_desktops - 1;
1102         else
1103             self->desktop = d;
1104         ob_debug("client requested desktop 0x%x\n", self->desktop);
1105     } else {
1106         GSList *it;
1107         gboolean first = TRUE;
1108         guint all = screen_num_desktops; /* not a valid value */
1109
1110         /* if they are all on one desktop, then open it on the
1111            same desktop */
1112         for (it = self->parents; it; it = g_slist_next(it)) {
1113             ObClient *c = it->data;
1114
1115             if (c->desktop == DESKTOP_ALL) continue;
1116
1117             if (first) {
1118                 all = c->desktop;
1119                 first = FALSE;
1120             }
1121             else if (all != c->desktop)
1122                 all = screen_num_desktops; /* make it invalid */
1123         }
1124         if (all != screen_num_desktops) {
1125             self->desktop = all;
1126
1127             ob_debug("client desktop set from parents: 0x%x\n",
1128                      self->desktop);
1129         }
1130         /* try get from the startup-notification protocol */
1131         else if (sn_get_desktop(self->startup_id, &self->desktop)) {
1132             if (self->desktop >= screen_num_desktops &&
1133                 self->desktop != DESKTOP_ALL)
1134                 self->desktop = screen_num_desktops - 1;
1135             ob_debug("client desktop set from startup-notification: 0x%x\n",
1136                      self->desktop);
1137         }
1138         /* defaults to the current desktop */
1139         else {
1140             self->desktop = screen_desktop;
1141             ob_debug("client desktop set to the current desktop: %d\n",
1142                      self->desktop);
1143         }
1144     }
1145 }
1146
1147 static void client_get_state(ObClient *self)
1148 {
1149     guint32 *state;
1150     guint num;
1151
1152     if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) {
1153         gulong i;
1154         for (i = 0; i < num; ++i) {
1155             if (state[i] == prop_atoms.net_wm_state_modal)
1156                 self->modal = TRUE;
1157             else if (state[i] == prop_atoms.net_wm_state_shaded)
1158                 self->shaded = TRUE;
1159             else if (state[i] == prop_atoms.net_wm_state_hidden)
1160                 self->iconic = TRUE;
1161             else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
1162                 self->skip_taskbar = TRUE;
1163             else if (state[i] == prop_atoms.net_wm_state_skip_pager)
1164                 self->skip_pager = TRUE;
1165             else if (state[i] == prop_atoms.net_wm_state_fullscreen)
1166                 self->fullscreen = TRUE;
1167             else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
1168                 self->max_vert = TRUE;
1169             else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
1170                 self->max_horz = TRUE;
1171             else if (state[i] == prop_atoms.net_wm_state_above)
1172                 self->above = TRUE;
1173             else if (state[i] == prop_atoms.net_wm_state_below)
1174                 self->below = TRUE;
1175             else if (state[i] == prop_atoms.net_wm_state_demands_attention)
1176                 self->demands_attention = TRUE;
1177             else if (state[i] == prop_atoms.ob_wm_state_undecorated)
1178                 self->undecorated = TRUE;
1179         }
1180
1181         g_free(state);
1182     }
1183 }
1184
1185 static void client_get_shaped(ObClient *self)
1186 {
1187     self->shaped = FALSE;
1188 #ifdef   SHAPE
1189     if (extensions_shape) {
1190         gint foo;
1191         guint ufoo;
1192         gint s;
1193
1194         XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
1195
1196         XShapeQueryExtents(ob_display, self->window, &s, &foo,
1197                            &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
1198                            &ufoo);
1199         self->shaped = (s != 0);
1200     }
1201 #endif
1202 }
1203
1204 void client_update_transient_for(ObClient *self)
1205 {
1206     Window t = None;
1207     ObClient *target = NULL;
1208     gboolean trangroup = FALSE;
1209
1210     if (XGetTransientForHint(ob_display, self->window, &t)) {
1211         if (t != self->window) { /* cant be transient to itself! */
1212             target = g_hash_table_lookup(window_map, &t);
1213             /* if this happens then we need to check for it*/
1214             g_assert(target != self);
1215             if (target && !WINDOW_IS_CLIENT(target)) {
1216                 /* this can happen when a dialog is a child of
1217                    a dockapp, for example */
1218                 target = NULL;
1219             }
1220         }
1221
1222         /* Setting the transient_for to Root is actually illegal, however
1223            applications from time have done this to specify transient for
1224            their group */
1225         if (!target && self->group && t == RootWindow(ob_display, ob_screen))
1226             trangroup = TRUE;
1227     } else if (self->group && self->transient)
1228         trangroup = TRUE;
1229
1230     client_update_transient_tree(self, self->group, self->group,
1231                                  self->transient_for_group, trangroup,
1232                                  client_direct_parent(self), target);
1233     self->transient_for_group = trangroup;
1234
1235 }
1236
1237 static void client_update_transient_tree(ObClient *self,
1238                                          ObGroup *oldgroup, ObGroup *newgroup,
1239                                          gboolean oldgtran, gboolean newgtran,
1240                                          ObClient* oldparent,
1241                                          ObClient *newparent)
1242 {
1243     GSList *it, *next;
1244     ObClient *c;
1245
1246     g_assert(!oldgtran || oldgroup);
1247     g_assert(!newgtran || newgroup);
1248     g_assert((!oldgtran && !oldparent) ||
1249              (oldgtran && !oldparent) ||
1250              (!oldgtran && oldparent));
1251     g_assert((!newgtran && !newparent) ||
1252              (newgtran && !newparent) ||
1253              (!newgtran && newparent));
1254
1255     /* * *
1256       Group transient windows are not allowed to have other group
1257       transient windows as their children.
1258       * * */
1259
1260
1261     /* No change has occured */
1262     if (oldgroup == newgroup &&
1263         oldgtran == newgtran &&
1264         oldparent == newparent) return;
1265
1266     /** Remove the client from the transient tree wherever it has changed **/
1267
1268     /* If the window is becoming a direct transient for a window in its group
1269        then any group transients which were our children and are now becoming
1270        our parents need to stop being our children.
1271
1272        Group transients can't be children of group transients already, but
1273        we could have any number of direct parents above up, any of which could
1274        be transient for the group, and we need to remove it from our children.
1275     */
1276     if (!oldgtran && oldparent != newparent && newparent != NULL &&
1277         newgroup != NULL && newgroup == oldgroup &&
1278         client_normal(newparent))
1279     {
1280         ObClient *look = client_search_top_direct_parent(newparent);
1281         self->transients = g_slist_remove(self->transients, look);
1282         look->parents = g_slist_remove(look->parents, self);
1283     }
1284
1285
1286     /* If the group changed, or if we are just becoming transient for the
1287        group, then we need to remove any old group transient windows
1288        from our children. But if we were already transient for the group, then
1289        other group transients are not our children. */
1290     if ((oldgroup != newgroup || (newgtran && oldgtran != newgtran)) &&
1291         oldgroup != NULL && !oldgtran)
1292     {
1293         for (it = self->transients; it; it = next) {
1294             next = g_slist_next(it);
1295             c = it->data;
1296             if (c->group == oldgroup && client_normal(self)) {
1297                 self->transients = g_slist_delete_link(self->transients, it);
1298                 c->parents = g_slist_remove(c->parents, self);
1299             }
1300         }
1301     }
1302
1303     /* If we used to be transient for a group and now we are not, or we're
1304        transient for a new group, then we need to remove ourselves from all
1305        our ex-parents */
1306     if (oldgtran && (oldgroup != newgroup || oldgtran != newgtran))
1307     {
1308         for (it = self->parents; it; it = next) {
1309             next = g_slist_next(it);
1310             c = it->data;
1311             if (!c->transient_for_group && client_normal(c)) {
1312                 c->transients = g_slist_remove(c->transients, self);
1313                 self->parents = g_slist_delete_link(self->parents, it);
1314             }
1315         }
1316     }
1317     /* If we used to be transient for a single window and we are no longer
1318        transient for it, then we need to remove ourself from its children */
1319     else if (oldparent && oldparent != newparent &&
1320              client_normal(oldparent))
1321     {
1322         oldparent->transients = g_slist_remove(oldparent->transients, self);
1323         self->parents = g_slist_remove(self->parents, oldparent);
1324     }
1325
1326     /** Re-add the client to the transient tree wherever it has changed **/
1327
1328     /* If we're now transient for a group and we weren't transient for it
1329        before then we need to add ourselves to all our new parents */
1330     if (newgtran && (oldgroup != newgroup || oldgtran != newgtran))
1331     {
1332         for (it = oldgroup->members; it; it = g_slist_next(it)) {
1333             c = it->data;
1334             if (c != self && !c->transient_for_group && client_normal(c))
1335             {
1336                 c->transients = g_slist_prepend(c->transients, self);
1337                 self->parents = g_slist_prepend(self->parents, c);
1338             }
1339         }
1340     }
1341     /* If we are now transient for a single window which we weren't before,
1342        we need to add ourselves to its children
1343
1344        WARNING: Cyclical transient ness is possible if two windows are
1345        transient for eachother.
1346     */
1347     else if (newparent && newparent != oldparent &&
1348              /* don't make ourself its child if it is already our child */
1349              !client_is_direct_child(self, newparent) &&
1350              client_normal(newparent))
1351     {
1352         newparent->transients = g_slist_prepend(newparent->transients, self);
1353         self->parents = g_slist_prepend(self->parents, newparent);
1354     }
1355
1356     /* If the group changed then we need to add any new group transient
1357        windows to our children. But if we're transient for the group, then
1358        other group transients are not our children.
1359
1360        WARNING: Cyclical transient-ness is possible. For e.g. if:
1361        A is transient for the group
1362        B is transient for A
1363        C is transient for B
1364        A can't be transient for C or we have a cycle
1365     */
1366     if (oldgroup != newgroup && newgroup != NULL && !newgtran &&
1367         client_normal(self))
1368     {
1369         for (it = newgroup->members; it; it = g_slist_next(it)) {
1370             c = it->data;
1371             if (c != self && c->transient_for_group &&
1372                 /* Don't make it our child if it is already our parent */
1373                 !client_is_direct_child(c, self))
1374             {
1375                 self->transients = g_slist_prepend(self->transients, c);
1376                 c->parents = g_slist_prepend(c->parents, self);
1377             }
1378         }
1379     }
1380 }
1381
1382 static void client_get_mwm_hints(ObClient *self)
1383 {
1384     guint num;
1385     guint32 *hints;
1386
1387     self->mwmhints.flags = 0; /* default to none */
1388
1389     if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
1390                     &hints, &num)) {
1391         if (num >= OB_MWM_ELEMENTS) {
1392             self->mwmhints.flags = hints[0];
1393             self->mwmhints.functions = hints[1];
1394             self->mwmhints.decorations = hints[2];
1395         }
1396         g_free(hints);
1397     }
1398 }
1399
1400 void client_get_type_and_transientness(ObClient *self)
1401 {
1402     guint num, i;
1403     guint32 *val;
1404     Window t;
1405
1406     self->type = -1;
1407     self->transient = FALSE;
1408
1409     if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
1410         /* use the first value that we know about in the array */
1411         for (i = 0; i < num; ++i) {
1412             if (val[i] == prop_atoms.net_wm_window_type_desktop)
1413                 self->type = OB_CLIENT_TYPE_DESKTOP;
1414             else if (val[i] == prop_atoms.net_wm_window_type_dock)
1415                 self->type = OB_CLIENT_TYPE_DOCK;
1416             else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
1417                 self->type = OB_CLIENT_TYPE_TOOLBAR;
1418             else if (val[i] == prop_atoms.net_wm_window_type_menu)
1419                 self->type = OB_CLIENT_TYPE_MENU;
1420             else if (val[i] == prop_atoms.net_wm_window_type_utility)
1421                 self->type = OB_CLIENT_TYPE_UTILITY;
1422             else if (val[i] == prop_atoms.net_wm_window_type_splash)
1423                 self->type = OB_CLIENT_TYPE_SPLASH;
1424             else if (val[i] == prop_atoms.net_wm_window_type_dialog)
1425                 self->type = OB_CLIENT_TYPE_DIALOG;
1426             else if (val[i] == prop_atoms.net_wm_window_type_normal)
1427                 self->type = OB_CLIENT_TYPE_NORMAL;
1428             else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
1429                 /* prevent this window from getting any decor or
1430                    functionality */
1431                 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
1432                                          OB_MWM_FLAG_DECORATIONS);
1433                 self->mwmhints.decorations = 0;
1434                 self->mwmhints.functions = 0;
1435             }
1436             if (self->type != (ObClientType) -1)
1437                 break; /* grab the first legit type */
1438         }
1439         g_free(val);
1440     }
1441
1442     if (XGetTransientForHint(ob_display, self->window, &t))
1443         self->transient = TRUE;
1444
1445     if (self->type == (ObClientType) -1) {
1446         /*the window type hint was not set, which means we either classify
1447           ourself as a normal window or a dialog, depending on if we are a
1448           transient. */
1449         if (self->transient)
1450             self->type = OB_CLIENT_TYPE_DIALOG;
1451         else
1452             self->type = OB_CLIENT_TYPE_NORMAL;
1453     }
1454
1455     /* then, based on our type, we can update our transientness.. */
1456     if (self->type == OB_CLIENT_TYPE_DIALOG ||
1457         self->type == OB_CLIENT_TYPE_TOOLBAR ||
1458         self->type == OB_CLIENT_TYPE_MENU ||
1459         self->type == OB_CLIENT_TYPE_UTILITY)
1460     {
1461         self->transient = TRUE;
1462     }
1463 }
1464
1465 void client_update_protocols(ObClient *self)
1466 {
1467     guint32 *proto;
1468     guint num_return, i;
1469
1470     self->focus_notify = FALSE;
1471     self->delete_window = FALSE;
1472
1473     if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1474         for (i = 0; i < num_return; ++i) {
1475             if (proto[i] == prop_atoms.wm_delete_window)
1476                 /* this means we can request the window to close */
1477                 self->delete_window = TRUE;
1478             else if (proto[i] == prop_atoms.wm_take_focus)
1479                 /* if this protocol is requested, then the window will be
1480                    notified whenever we want it to receive focus */
1481                 self->focus_notify = TRUE;
1482 #ifdef SYNC
1483             else if (proto[i] == prop_atoms.net_wm_sync_request)
1484                 /* if this protocol is requested, then resizing the
1485                    window will be synchronized between the frame and the
1486                    client */
1487                 self->sync_request = TRUE;
1488 #endif
1489         }
1490         g_free(proto);
1491     }
1492 }
1493
1494 #ifdef SYNC
1495 void client_update_sync_request_counter(ObClient *self)
1496 {
1497     guint32 i;
1498
1499     if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
1500         self->sync_counter = i;
1501     } else
1502         self->sync_counter = None;
1503 }
1504 #endif
1505
1506 void client_get_colormap(ObClient *self)
1507 {
1508     XWindowAttributes wa;
1509
1510     if (XGetWindowAttributes(ob_display, self->window, &wa))
1511         client_update_colormap(self, wa.colormap);
1512 }
1513
1514 void client_update_colormap(ObClient *self, Colormap colormap)
1515 {
1516     if (colormap == self->colormap) return;
1517
1518     ob_debug("Setting client %s colormap: 0x%x\n", self->title, colormap);
1519
1520     if (client_focused(self)) {
1521         screen_install_colormap(self, FALSE); /* uninstall old one */
1522         self->colormap = colormap;
1523         screen_install_colormap(self, FALSE); /* install new one */
1524     } else
1525         self->colormap = colormap;
1526 }
1527
1528 void client_update_normal_hints(ObClient *self)
1529 {
1530     XSizeHints size;
1531     glong ret;
1532
1533     /* defaults */
1534     self->min_ratio = 0.0f;
1535     self->max_ratio = 0.0f;
1536     SIZE_SET(self->size_inc, 1, 1);
1537     SIZE_SET(self->base_size, 0, 0);
1538     SIZE_SET(self->min_size, 0, 0);
1539     SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1540
1541     /* get the hints from the window */
1542     if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1543         /* normal windows can't request placement! har har
1544         if (!client_normal(self))
1545         */
1546         self->positioned = (size.flags & (PPosition|USPosition));
1547         self->sized = (size.flags & (PSize|USSize));
1548
1549         if (size.flags & PWinGravity)
1550             self->gravity = size.win_gravity;
1551
1552         if (size.flags & PAspect) {
1553             if (size.min_aspect.y)
1554                 self->min_ratio =
1555                     (gfloat) size.min_aspect.x / size.min_aspect.y;
1556             if (size.max_aspect.y)
1557                 self->max_ratio =
1558                     (gfloat) size.max_aspect.x / size.max_aspect.y;
1559         }
1560
1561         if (size.flags & PMinSize)
1562             SIZE_SET(self->min_size, size.min_width, size.min_height);
1563
1564         if (size.flags & PMaxSize)
1565             SIZE_SET(self->max_size, size.max_width, size.max_height);
1566
1567         if (size.flags & PBaseSize)
1568             SIZE_SET(self->base_size, size.base_width, size.base_height);
1569
1570         if (size.flags & PResizeInc && size.width_inc && size.height_inc)
1571             SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1572     }
1573 }
1574
1575 void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
1576 {
1577     /* start with everything (cept fullscreen) */
1578     self->decorations =
1579         (OB_FRAME_DECOR_TITLEBAR |
1580          OB_FRAME_DECOR_HANDLE |
1581          OB_FRAME_DECOR_GRIPS |
1582          OB_FRAME_DECOR_BORDER |
1583          OB_FRAME_DECOR_ICON |
1584          OB_FRAME_DECOR_ALLDESKTOPS |
1585          OB_FRAME_DECOR_ICONIFY |
1586          OB_FRAME_DECOR_MAXIMIZE |
1587          OB_FRAME_DECOR_SHADE |
1588          OB_FRAME_DECOR_CLOSE);
1589     self->functions =
1590         (OB_CLIENT_FUNC_RESIZE |
1591          OB_CLIENT_FUNC_MOVE |
1592          OB_CLIENT_FUNC_ICONIFY |
1593          OB_CLIENT_FUNC_MAXIMIZE |
1594          OB_CLIENT_FUNC_SHADE |
1595          OB_CLIENT_FUNC_CLOSE |
1596          OB_CLIENT_FUNC_BELOW |
1597          OB_CLIENT_FUNC_ABOVE |
1598          OB_CLIENT_FUNC_UNDECORATE);
1599
1600     if (!(self->min_size.width < self->max_size.width ||
1601           self->min_size.height < self->max_size.height))
1602         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1603
1604     switch (self->type) {
1605     case OB_CLIENT_TYPE_NORMAL:
1606         /* normal windows retain all of the possible decorations and
1607            functionality, and are the only windows that you can fullscreen */
1608         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1609         break;
1610
1611     case OB_CLIENT_TYPE_DIALOG:
1612     case OB_CLIENT_TYPE_UTILITY:
1613         /* these windows don't have anything added or removed by default */
1614         break;
1615
1616     case OB_CLIENT_TYPE_MENU:
1617     case OB_CLIENT_TYPE_TOOLBAR:
1618         /* these windows can't iconify or maximize */
1619         self->decorations &= ~(OB_FRAME_DECOR_ICONIFY |
1620                                OB_FRAME_DECOR_MAXIMIZE);
1621         self->functions &= ~(OB_CLIENT_FUNC_ICONIFY |
1622                              OB_CLIENT_FUNC_MAXIMIZE);
1623         break;
1624
1625     case OB_CLIENT_TYPE_SPLASH:
1626         /* these don't get get any decorations, and the only thing you can
1627            do with them is move them */
1628         self->decorations = 0;
1629         self->functions = OB_CLIENT_FUNC_MOVE;
1630         break;
1631
1632     case OB_CLIENT_TYPE_DESKTOP:
1633         /* these windows are not manipulated by the window manager */
1634         self->decorations = 0;
1635         self->functions = 0;
1636         break;
1637
1638     case OB_CLIENT_TYPE_DOCK:
1639         /* these windows are not manipulated by the window manager, but they
1640            can set below layer which has a special meaning */
1641         self->decorations = 0;
1642         self->functions = OB_CLIENT_FUNC_BELOW;
1643         break;
1644     }
1645
1646     /* Mwm Hints are applied subtractively to what has already been chosen for
1647        decor and functionality */
1648     if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1649         if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1650             if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1651                    (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1652             {
1653                 /* if the mwm hints request no handle or title, then all
1654                    decorations are disabled, but keep the border if that's
1655                    specified */
1656                 if (self->mwmhints.decorations & OB_MWM_DECOR_BORDER)
1657                     self->decorations = OB_FRAME_DECOR_BORDER;
1658                 else
1659                     self->decorations = 0;
1660             }
1661         }
1662     }
1663
1664     if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1665         if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1666             if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1667                 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1668             if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1669                 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1670             /* dont let mwm hints kill any buttons
1671                if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1672                self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1673                if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1674                self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1675             */
1676             /* dont let mwm hints kill the close button
1677                if (! (self->mwmhints.functions & MwmFunc_Close))
1678                self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1679         }
1680     }
1681
1682     if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1683         self->decorations &= ~OB_FRAME_DECOR_SHADE;
1684     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1685         self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1686     if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1687         self->decorations &= ~(OB_FRAME_DECOR_GRIPS | OB_FRAME_DECOR_HANDLE);
1688
1689     /* can't maximize without moving/resizing */
1690     if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1691           (self->functions & OB_CLIENT_FUNC_MOVE) &&
1692           (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1693         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1694         self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1695     }
1696
1697     if (self->max_horz && self->max_vert) {
1698         /* you can't resize fully maximized windows */
1699         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1700         /* kill the handle on fully maxed windows */
1701         self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
1702     }
1703
1704     /* If there are no decorations to remove, don't allow the user to try
1705        toggle the state */
1706     if (self->decorations == 0)
1707         self->functions &= ~OB_CLIENT_FUNC_UNDECORATE;
1708
1709     /* finally, the user can have requested no decorations, which overrides
1710        everything (but doesnt give it a border if it doesnt have one) */
1711     if (self->undecorated) {
1712         if (config_theme_keepborder)
1713             self->decorations &= OB_FRAME_DECOR_BORDER;
1714         else
1715             self->decorations = 0;
1716     }
1717
1718     /* if we don't have a titlebar, then we cannot shade! */
1719     if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1720         self->functions &= ~OB_CLIENT_FUNC_SHADE;
1721
1722     /* now we need to check against rules for the client's current state */
1723     if (self->fullscreen) {
1724         self->functions &= (OB_CLIENT_FUNC_CLOSE |
1725                             OB_CLIENT_FUNC_FULLSCREEN |
1726                             OB_CLIENT_FUNC_ICONIFY);
1727         self->decorations = 0;
1728     }
1729
1730     client_change_allowed_actions(self);
1731
1732     if (reconfig)
1733         client_reconfigure(self);
1734 }
1735
1736 static void client_change_allowed_actions(ObClient *self)
1737 {
1738     gulong actions[12];
1739     gint num = 0;
1740
1741     /* desktop windows are kept on all desktops */
1742     if (self->type != OB_CLIENT_TYPE_DESKTOP)
1743         actions[num++] = prop_atoms.net_wm_action_change_desktop;
1744
1745     if (self->functions & OB_CLIENT_FUNC_SHADE)
1746         actions[num++] = prop_atoms.net_wm_action_shade;
1747     if (self->functions & OB_CLIENT_FUNC_CLOSE)
1748         actions[num++] = prop_atoms.net_wm_action_close;
1749     if (self->functions & OB_CLIENT_FUNC_MOVE)
1750         actions[num++] = prop_atoms.net_wm_action_move;
1751     if (self->functions & OB_CLIENT_FUNC_ICONIFY)
1752         actions[num++] = prop_atoms.net_wm_action_minimize;
1753     if (self->functions & OB_CLIENT_FUNC_RESIZE)
1754         actions[num++] = prop_atoms.net_wm_action_resize;
1755     if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
1756         actions[num++] = prop_atoms.net_wm_action_fullscreen;
1757     if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
1758         actions[num++] = prop_atoms.net_wm_action_maximize_horz;
1759         actions[num++] = prop_atoms.net_wm_action_maximize_vert;
1760     }
1761     if (self->functions & OB_CLIENT_FUNC_ABOVE)
1762         actions[num++] = prop_atoms.net_wm_action_above;
1763     if (self->functions & OB_CLIENT_FUNC_BELOW)
1764         actions[num++] = prop_atoms.net_wm_action_below;
1765     if (self->functions & OB_CLIENT_FUNC_UNDECORATE)
1766         actions[num++] = prop_atoms.ob_wm_action_undecorate;
1767
1768     PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
1769
1770     /* make sure the window isn't breaking any rules now */
1771
1772     if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
1773         if (self->frame) client_shade(self, FALSE);
1774         else self->shaded = FALSE;
1775     }
1776     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
1777         if (self->frame) client_iconify(self, FALSE, TRUE, FALSE);
1778         else self->iconic = FALSE;
1779     }
1780     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
1781         if (self->frame) client_fullscreen(self, FALSE);
1782         else self->fullscreen = FALSE;
1783     }
1784     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
1785                                                          self->max_vert)) {
1786         if (self->frame) client_maximize(self, FALSE, 0);
1787         else self->max_vert = self->max_horz = FALSE;
1788     }
1789 }
1790
1791 void client_reconfigure(ObClient *self)
1792 {
1793     client_configure(self, self->area.x, self->area.y,
1794                      self->area.width, self->area.height,
1795                      FALSE, TRUE);
1796 }
1797
1798 void client_update_wmhints(ObClient *self)
1799 {
1800     XWMHints *hints;
1801
1802     /* assume a window takes input if it doesnt specify */
1803     self->can_focus = TRUE;
1804
1805     if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
1806         gboolean ur;
1807
1808         if (hints->flags & InputHint)
1809             self->can_focus = hints->input;
1810
1811         /* only do this when first managing the window *AND* when we aren't
1812            starting up! */
1813         if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
1814             if (hints->flags & StateHint)
1815                 self->iconic = hints->initial_state == IconicState;
1816
1817         ur = self->urgent;
1818         self->urgent = (hints->flags & XUrgencyHint);
1819         if (self->urgent && !ur)
1820             client_hilite(self, TRUE);
1821         else if (!self->urgent && ur && self->demands_attention)
1822             client_hilite(self, FALSE);
1823
1824         if (!(hints->flags & WindowGroupHint))
1825             hints->window_group = None;
1826
1827         /* did the group state change? */
1828         if (hints->window_group !=
1829             (self->group ? self->group->leader : None))
1830         {
1831             ObGroup *oldgroup = self->group;
1832
1833             /* remove from the old group if there was one */
1834             if (self->group != NULL) {
1835                 group_remove(self->group, self);
1836                 self->group = NULL;
1837             }
1838
1839             /* add ourself to the group if we have one */
1840             if (hints->window_group != None) {
1841                 self->group = group_add(hints->window_group, self);
1842             }
1843
1844             /* Put ourselves into the new group's transient tree, and remove
1845                ourselves from the old group's */
1846             client_update_transient_tree(self, oldgroup, self->group,
1847                                          self->transient_for_group,
1848                                          self->transient_for_group,
1849                                          client_direct_parent(self),
1850                                          client_direct_parent(self));
1851
1852             /* Lastly, being in a group, or not, can change if the window is
1853                transient for anything.
1854
1855                The logic for this is:
1856                self->transient = TRUE always if the window wants to be
1857                transient for something, even if transient_for was NULL because
1858                it wasn't in a group before.
1859
1860                If parents was NULL and oldgroup was NULL we can assume
1861                that when we add the new group, it will become transient for
1862                something.
1863
1864                If transient_for_group is TRUE, then it must have already
1865                had a group. If it is getting a new group, the above call to
1866                client_update_transient_tree has already taken care of
1867                everything ! If it is losing all group status then it will
1868                no longer be transient for anything and that needs to be
1869                updated.
1870             */
1871             if (self->transient &&
1872                 ((self->parents == NULL && oldgroup == NULL) ||
1873                  (self->transient_for_group && !self->group)))
1874                 client_update_transient_for(self);
1875         }
1876
1877         /* the WM_HINTS can contain an icon */
1878         if (hints->flags & IconPixmapHint)
1879             client_update_icons(self);
1880
1881         XFree(hints);
1882     }
1883 }
1884
1885 void client_update_title(ObClient *self)
1886 {
1887     gchar *data = NULL;
1888     gchar *visible = NULL;
1889
1890     g_free(self->title);
1891
1892     /* try netwm */
1893     if (!PROP_GETS(self->window, net_wm_name, utf8, &data)) {
1894         /* try old x stuff */
1895         if (!(PROP_GETS(self->window, wm_name, locale, &data)
1896               || PROP_GETS(self->window, wm_name, utf8, &data))) {
1897             if (self->transient) {
1898                 /*
1899                   GNOME alert windows are not given titles:
1900                   http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1901                 */
1902                 data = g_strdup("");
1903             } else
1904                 data = g_strdup("Unnamed Window");
1905         }
1906     }
1907
1908     if (self->client_machine) {
1909         visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1910         g_free(data);
1911     } else
1912         visible = data;
1913
1914     PROP_SETS(self->window, net_wm_visible_name, visible);
1915     self->title = visible;
1916
1917     if (self->frame)
1918         frame_adjust_title(self->frame);
1919
1920     /* update the icon title */
1921     data = NULL;
1922     g_free(self->icon_title);
1923
1924     /* try netwm */
1925     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
1926         /* try old x stuff */
1927         if (!(PROP_GETS(self->window, wm_icon_name, locale, &data) ||
1928               PROP_GETS(self->window, wm_icon_name, utf8, &data)))
1929             data = g_strdup(self->title);
1930
1931     if (self->client_machine) {
1932         visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1933         g_free(data);
1934     } else
1935         visible = data;
1936
1937     PROP_SETS(self->window, net_wm_visible_icon_name, visible);
1938     self->icon_title = visible;
1939 }
1940
1941 void client_update_strut(ObClient *self)
1942 {
1943     guint num;
1944     guint32 *data;
1945     gboolean got = FALSE;
1946     StrutPartial strut;
1947
1948     if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
1949                     &data, &num)) {
1950         if (num == 12) {
1951             got = TRUE;
1952             STRUT_PARTIAL_SET(strut,
1953                               data[0], data[2], data[1], data[3],
1954                               data[4], data[5], data[8], data[9],
1955                               data[6], data[7], data[10], data[11]);
1956         }
1957         g_free(data);
1958     }
1959
1960     if (!got &&
1961         PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
1962         if (num == 4) {
1963             const Rect *a;
1964
1965             got = TRUE;
1966
1967             /* use the screen's width/height */
1968             a = screen_physical_area();
1969
1970             STRUT_PARTIAL_SET(strut,
1971                               data[0], data[2], data[1], data[3],
1972                               a->y, a->y + a->height - 1,
1973                               a->x, a->x + a->width - 1,
1974                               a->y, a->y + a->height - 1,
1975                               a->x, a->x + a->width - 1);
1976         }
1977         g_free(data);
1978     }
1979
1980     if (!got)
1981         STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
1982                           0, 0, 0, 0, 0, 0, 0, 0);
1983
1984     if (!STRUT_EQUAL(strut, self->strut)) {
1985         self->strut = strut;
1986
1987         /* updating here is pointless while we're being mapped cuz we're not in
1988            the client list yet */
1989         if (self->frame)
1990             screen_update_areas();
1991     }
1992 }
1993
1994 void client_update_icons(ObClient *self)
1995 {
1996     guint num;
1997     guint32 *data;
1998     guint w, h, i, j;
1999
2000     for (i = 0; i < self->nicons; ++i)
2001         g_free(self->icons[i].data);
2002     if (self->nicons > 0)
2003         g_free(self->icons);
2004     self->nicons = 0;
2005
2006     if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
2007         /* figure out how many valid icons are in here */
2008         i = 0;
2009         while (num - i > 2) {
2010             w = data[i++];
2011             h = data[i++];
2012             i += w * h;
2013             if (i > num || w*h == 0) break;
2014             ++self->nicons;
2015         }
2016
2017         self->icons = g_new(ObClientIcon, self->nicons);
2018
2019         /* store the icons */
2020         i = 0;
2021         for (j = 0; j < self->nicons; ++j) {
2022             guint x, y, t;
2023
2024             w = self->icons[j].width = data[i++];
2025             h = self->icons[j].height = data[i++];
2026
2027             if (w*h == 0) continue;
2028
2029             self->icons[j].data = g_new(RrPixel32, w * h);
2030             for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
2031                 if (x >= w) {
2032                     x = 0;
2033                     ++y;
2034                 }
2035                 self->icons[j].data[t] =
2036                     (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
2037                     (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
2038                     (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
2039                     (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
2040             }
2041             g_assert(i <= num);
2042         }
2043
2044         g_free(data);
2045     } else {
2046         XWMHints *hints;
2047
2048         if ((hints = XGetWMHints(ob_display, self->window))) {
2049             if (hints->flags & IconPixmapHint) {
2050                 self->nicons++;
2051                 self->icons = g_new(ObClientIcon, self->nicons);
2052                 xerror_set_ignore(TRUE);
2053                 if (!RrPixmapToRGBA(ob_rr_inst,
2054                                     hints->icon_pixmap,
2055                                     (hints->flags & IconMaskHint ?
2056                                      hints->icon_mask : None),
2057                                     &self->icons[self->nicons-1].width,
2058                                     &self->icons[self->nicons-1].height,
2059                                     &self->icons[self->nicons-1].data)){
2060                     g_free(&self->icons[self->nicons-1]);
2061                     self->nicons--;
2062                 }
2063                 xerror_set_ignore(FALSE);
2064             }
2065             XFree(hints);
2066         }
2067     }
2068
2069     /* set the default icon onto the window
2070        in theory, this could be a race, but if a window doesn't set an icon
2071        or removes it entirely, it's not very likely it is going to set one
2072        right away afterwards */
2073     if (self->nicons == 0) {
2074         RrPixel32 *icon = ob_rr_theme->def_win_icon;
2075         gulong *data;
2076
2077         data = g_new(gulong, 48*48+2);
2078         data[0] = data[1] =  48;
2079         for (i = 0; i < 48*48; ++i)
2080             data[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
2081                 (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
2082                 (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
2083                 (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
2084         PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2);
2085         g_free(data);
2086     } else if (self->frame)
2087         /* don't draw the icon empty if we're just setting one now anyways,
2088            we'll get the property change any second */
2089         frame_adjust_icon(self->frame);
2090 }
2091
2092 void client_update_user_time(ObClient *self)
2093 {
2094     guint32 time;
2095     gboolean got = FALSE;
2096
2097     if (self->user_time_window)
2098         got = PROP_GET32(self->user_time_window,
2099                          net_wm_user_time, cardinal, &time);
2100     if (!got)
2101         got = PROP_GET32(self->window, net_wm_user_time, cardinal, &time);
2102
2103     if (got) {
2104         /* we set this every time, not just when it grows, because in practice
2105            sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes
2106            backward we don't want all windows to stop focusing. we'll just
2107            assume noone is setting times older than the last one, cuz that
2108            would be pretty stupid anyways
2109         */
2110         self->user_time = time;
2111
2112         /*ob_debug("window %s user time %u\n", self->title, time);*/
2113     }
2114 }
2115
2116 void client_update_user_time_window(ObClient *self)
2117 {
2118     guint32 w;
2119
2120     if (!PROP_GET32(self->window, net_wm_user_time_window, window, &w))
2121         w = None;
2122
2123     if (w != self->user_time_window) {
2124         /* remove the old window */
2125         propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self);
2126         self->user_time_window = None;
2127
2128         if (self->group && self->group->leader == w) {
2129             ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
2130                           "_NET_WM_USER_TYPE_WINDOW to its group leader\n");
2131             /* do it anyways..? */
2132         }
2133         else if (w == self->window) {
2134             ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
2135                           "_NET_WM_USER_TIME_WINDOW to itself\n");
2136             w = None; /* don't do it */
2137         }
2138
2139         /* add the new window */
2140         propwin_add(w, OB_PROPWIN_USER_TIME, self);
2141         self->user_time_window = w;
2142
2143         /* and update from it */
2144         client_update_user_time(self);
2145     }
2146 }
2147
2148 void client_update_icon_geometry(ObClient *self)
2149 {
2150     guint num;
2151     guint32 *data;
2152
2153     RECT_SET(self->icon_geometry, 0, 0, 0, 0);
2154
2155     if (PROP_GETA32(self->window, net_wm_icon_geometry, cardinal, &data, &num)
2156         && num == 4)
2157     {
2158         /* don't let them set it with an area < 0 */
2159         RECT_SET(self->icon_geometry, data[0], data[1],
2160                  MAX(data[2],0), MAX(data[3],0));
2161     }
2162 }
2163
2164 static void client_get_session_ids(ObClient *self)
2165 {
2166     guint32 leader;
2167     gboolean got;
2168     gchar *s;
2169     gchar **ss;
2170
2171     if (!PROP_GET32(self->window, wm_client_leader, window, &leader))
2172         leader = None;
2173
2174     /* get the SM_CLIENT_ID */
2175     got = FALSE;
2176     if (leader)
2177         got = PROP_GETS(leader, sm_client_id, locale, &self->sm_client_id);
2178     if (!got)
2179         PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id);
2180
2181     /* get the WM_CLASS (name and class). make them "" if they are not
2182        provided */
2183     got = FALSE;
2184     if (leader)
2185         got = PROP_GETSS(leader, wm_class, locale, &ss);
2186     if (!got)
2187         got = PROP_GETSS(self->window, wm_class, locale, &ss);
2188
2189     if (got) {
2190         if (ss[0]) {
2191             self->name = g_strdup(ss[0]);
2192             if (ss[1])
2193                 self->class = g_strdup(ss[1]);
2194         }
2195         g_strfreev(ss);
2196     }
2197
2198     if (self->name == NULL) self->name = g_strdup("");
2199     if (self->class == NULL) self->class = g_strdup("");
2200
2201     /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
2202     got = FALSE;
2203     if (leader)
2204         got = PROP_GETS(leader, wm_window_role, locale, &s);
2205     if (!got)
2206         got = PROP_GETS(self->window, wm_window_role, locale, &s);
2207
2208     if (got)
2209         self->role = s;
2210     else
2211         self->role = g_strdup("");
2212
2213     /* get the WM_COMMAND */
2214     got = FALSE;
2215
2216     if (leader)
2217         got = PROP_GETSS(leader, wm_command, locale, &ss);
2218     if (!got)
2219         got = PROP_GETSS(self->window, wm_command, locale, &ss);
2220
2221     if (got) {
2222         /* merge/mash them all together */
2223         gchar *merge = NULL;
2224         gint i;
2225
2226         for (i = 0; ss[i]; ++i) {
2227             gchar *tmp = merge;
2228             if (merge)
2229                 merge = g_strconcat(merge, ss[i], NULL);
2230             else
2231                 merge = g_strconcat(ss[i], NULL);
2232             g_free(tmp);
2233         }
2234         g_strfreev(ss);
2235
2236         self->wm_command = merge;
2237     }
2238
2239     /* get the WM_CLIENT_MACHINE */
2240     got = FALSE;
2241     if (leader)
2242         got = PROP_GETS(leader, wm_client_machine, locale, &s);
2243     if (!got)
2244         got = PROP_GETS(self->window, wm_client_machine, locale, &s);
2245
2246     if (got) {
2247         gchar localhost[128];
2248
2249         gethostname(localhost, 127);
2250         localhost[127] = '\0';
2251         if (strcmp(localhost, s) != 0)
2252             self->client_machine = s;
2253         else
2254             g_free(s);
2255     }
2256 }
2257
2258 static void client_change_wm_state(ObClient *self)
2259 {
2260     gulong state[2];
2261     glong old;
2262
2263     old = self->wmstate;
2264
2265     if (self->shaded || self->iconic ||
2266         (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop))
2267     {
2268         self->wmstate = IconicState;
2269     } else
2270         self->wmstate = NormalState;
2271
2272     if (old != self->wmstate) {
2273         PROP_MSG(self->window, kde_wm_change_state,
2274                  self->wmstate, 1, 0, 0);
2275
2276         state[0] = self->wmstate;
2277         state[1] = None;
2278         PROP_SETA32(self->window, wm_state, wm_state, state, 2);
2279     }
2280 }
2281
2282 static void client_change_state(ObClient *self)
2283 {
2284     gulong netstate[12];
2285     guint num;
2286
2287     num = 0;
2288     if (self->modal)
2289         netstate[num++] = prop_atoms.net_wm_state_modal;
2290     if (self->shaded)
2291         netstate[num++] = prop_atoms.net_wm_state_shaded;
2292     if (self->iconic)
2293         netstate[num++] = prop_atoms.net_wm_state_hidden;
2294     if (self->skip_taskbar)
2295         netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
2296     if (self->skip_pager)
2297         netstate[num++] = prop_atoms.net_wm_state_skip_pager;
2298     if (self->fullscreen)
2299         netstate[num++] = prop_atoms.net_wm_state_fullscreen;
2300     if (self->max_vert)
2301         netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
2302     if (self->max_horz)
2303         netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
2304     if (self->above)
2305         netstate[num++] = prop_atoms.net_wm_state_above;
2306     if (self->below)
2307         netstate[num++] = prop_atoms.net_wm_state_below;
2308     if (self->demands_attention)
2309         netstate[num++] = prop_atoms.net_wm_state_demands_attention;
2310     if (self->undecorated)
2311         netstate[num++] = prop_atoms.ob_wm_state_undecorated;
2312     PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
2313
2314     if (self->frame)
2315         frame_adjust_state(self->frame);
2316 }
2317
2318 ObClient *client_search_focus_tree(ObClient *self)
2319 {
2320     GSList *it;
2321     ObClient *ret;
2322
2323     for (it = self->transients; it; it = g_slist_next(it)) {
2324         if (client_focused(it->data)) return it->data;
2325         if ((ret = client_search_focus_tree(it->data))) return ret;
2326     }
2327     return NULL;
2328 }
2329
2330 ObClient *client_search_focus_tree_full(ObClient *self)
2331 {
2332     if (self->parents) {
2333         GSList *it;
2334
2335         for (it = self->parents; it; it = g_slist_next(it)) {
2336             ObClient *c = it->data;
2337             if ((c = client_search_focus_tree_full(it->data))) return c;
2338         }
2339
2340         return NULL;
2341     }
2342     else {
2343         /* this function checks the whole tree, the client_search_focus_tree
2344            does not, so we need to check this window */
2345         if (client_focused(self))
2346             return self;
2347         return client_search_focus_tree(self);
2348     }
2349 }
2350
2351 ObClient *client_search_focus_group_full(ObClient *self)
2352 {
2353     GSList *it;
2354
2355     if (self->group) {
2356         for (it = self->group->members; it; it = g_slist_next(it)) {
2357             ObClient *c = it->data;
2358
2359             if (client_focused(c)) return c;
2360             if ((c = client_search_focus_tree(it->data))) return c;
2361         }
2362     } else
2363         if (client_focused(self)) return self;
2364     return NULL;
2365 }
2366
2367 gboolean client_has_parent(ObClient *self)
2368 {
2369     return self->parents != NULL;
2370 }
2371
2372 static ObStackingLayer calc_layer(ObClient *self)
2373 {
2374     ObStackingLayer l;
2375
2376     if (self->type == OB_CLIENT_TYPE_DESKTOP)
2377         l = OB_STACKING_LAYER_DESKTOP;
2378     else if (self->type == OB_CLIENT_TYPE_DOCK) {
2379         if (self->below) l = OB_STACKING_LAYER_NORMAL;
2380         else l = OB_STACKING_LAYER_ABOVE;
2381     }
2382     else if ((self->fullscreen ||
2383               /* No decorations and fills the monitor = oldskool fullscreen.
2384                  But not for maximized windows.
2385               */
2386               (self->decorations == 0 &&
2387                !(self->max_horz && self->max_vert) &&
2388                RECT_EQUAL(self->area,
2389                           *screen_physical_area_monitor
2390                           (client_monitor(self))))) &&
2391              (client_focused(self) || client_search_focus_tree(self)))
2392         l = OB_STACKING_LAYER_FULLSCREEN;
2393     else if (self->above) l = OB_STACKING_LAYER_ABOVE;
2394     else if (self->below) l = OB_STACKING_LAYER_BELOW;
2395     else l = OB_STACKING_LAYER_NORMAL;
2396
2397     return l;
2398 }
2399
2400 static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
2401                                         ObStackingLayer min)
2402 {
2403     ObStackingLayer old, own;
2404     GSList *it;
2405
2406     old = self->layer;
2407     own = calc_layer(self);
2408     self->layer = MAX(own, min);
2409
2410     if (self->layer != old) {
2411         stacking_remove(CLIENT_AS_WINDOW(self));
2412         stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
2413     }
2414
2415     for (it = self->transients; it; it = g_slist_next(it))
2416         client_calc_layer_recursive(it->data, orig,
2417                                     self->layer);
2418 }
2419
2420 void client_calc_layer(ObClient *self)
2421 {
2422     ObClient *orig;
2423     GSList *it;
2424
2425     orig = self;
2426
2427     /* transients take on the layer of their parents */
2428     it = client_search_all_top_parents(self);
2429
2430     for (; it; it = g_slist_next(it))
2431         client_calc_layer_recursive(it->data, orig, 0);
2432 }
2433
2434 gboolean client_should_show(ObClient *self)
2435 {
2436     if (self->iconic)
2437         return FALSE;
2438     if (client_normal(self) && screen_showing_desktop)
2439         return FALSE;
2440     if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
2441         return TRUE;
2442
2443     return FALSE;
2444 }
2445
2446 gboolean client_show(ObClient *self)
2447 {
2448     gboolean show = FALSE;
2449
2450     if (client_should_show(self)) {
2451         frame_show(self->frame);
2452         show = TRUE;
2453
2454         /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2455            it needs to be in IconicState. This includes when it is on another
2456            desktop!
2457         */
2458         client_change_wm_state(self);
2459     }
2460     return show;
2461 }
2462
2463 gboolean client_hide(ObClient *self)
2464 {
2465     gboolean hide = FALSE;
2466
2467     if (!client_should_show(self)) {
2468         if (self == focus_client) {
2469             /* if there is a grab going on, then we need to cancel it. if we
2470                move focus during the grab, applications will get
2471                NotifyWhileGrabbed events and ignore them !
2472
2473                actions should not rely on being able to move focus during an
2474                interactive grab.
2475             */
2476             event_cancel_all_key_grabs();
2477         }
2478
2479         frame_hide(self->frame);
2480         hide = TRUE;
2481
2482         /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2483            it needs to be in IconicState. This includes when it is on another
2484            desktop!
2485         */
2486         client_change_wm_state(self);
2487     }
2488     return hide;
2489 }
2490
2491 void client_showhide(ObClient *self)
2492 {
2493     if (!client_show(self))
2494         client_hide(self);
2495 }
2496
2497 gboolean client_normal(ObClient *self) {
2498     return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
2499               self->type == OB_CLIENT_TYPE_DOCK ||
2500               self->type == OB_CLIENT_TYPE_SPLASH);
2501 }
2502
2503 gboolean client_helper(ObClient *self)
2504 {
2505     return (self->type == OB_CLIENT_TYPE_UTILITY ||
2506             self->type == OB_CLIENT_TYPE_MENU ||
2507             self->type == OB_CLIENT_TYPE_TOOLBAR);
2508 }
2509
2510 gboolean client_mouse_focusable(ObClient *self)
2511 {
2512     return !(self->type == OB_CLIENT_TYPE_MENU ||
2513              self->type == OB_CLIENT_TYPE_TOOLBAR ||
2514              self->type == OB_CLIENT_TYPE_SPLASH ||
2515              self->type == OB_CLIENT_TYPE_DOCK);
2516 }
2517
2518 gboolean client_enter_focusable(ObClient *self)
2519 {
2520     /* you can focus desktops but it shouldn't on enter */
2521     return (client_mouse_focusable(self) &&
2522             self->type != OB_CLIENT_TYPE_DESKTOP);
2523 }
2524
2525
2526 static void client_apply_startup_state(ObClient *self,
2527                                        gint x, gint y, gint w, gint h)
2528 {
2529     /* save the states that we are going to apply */
2530     gboolean iconic = self->iconic;
2531     gboolean fullscreen = self->fullscreen;
2532     gboolean undecorated = self->undecorated;
2533     gboolean shaded = self->shaded;
2534     gboolean demands_attention = self->demands_attention;
2535     gboolean max_horz = self->max_horz;
2536     gboolean max_vert = self->max_vert;
2537     Rect oldarea;
2538     gint l;
2539
2540     /* turn them all off in the client, so they won't affect the window
2541        being placed */
2542     self->iconic = self->fullscreen = self->undecorated = self->shaded =
2543         self->demands_attention = self->max_horz = self->max_vert = FALSE;
2544
2545     /* move the client to its placed position, or it it's already there,
2546        generate a ConfigureNotify telling the client where it is.
2547
2548        do this after adjusting the frame. otherwise it gets all weird and
2549        clients don't work right
2550
2551        do this before applying the states so they have the correct
2552        pre-max/pre-fullscreen values
2553     */
2554     client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE);
2555     ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
2556              self->window, self->area.x, self->area.y,
2557              self->area.width, self->area.height);
2558     oldarea = self->area;              /* save the area */
2559     RECT_SET(self->area, x, y, w, h);  /* put where it should be for the premax stuff */
2560
2561     /* apply the states. these are in a carefully crafted order.. */
2562
2563     if (iconic)
2564         client_iconify(self, TRUE, FALSE, TRUE);
2565     if (fullscreen)
2566         client_fullscreen(self, TRUE);
2567     if (undecorated)
2568         client_set_undecorated(self, TRUE);
2569     if (shaded)
2570         client_shade(self, TRUE);
2571     if (demands_attention)
2572         client_hilite(self, TRUE);
2573
2574     if (max_vert && max_horz)
2575         client_maximize(self, TRUE, 0);
2576     else if (max_vert)
2577         client_maximize(self, TRUE, 2);
2578     else if (max_horz)
2579         client_maximize(self, TRUE, 1);
2580
2581     /* if the window hasn't been configured yet, then do so now */
2582     if (!fullscreen && !max_vert && !max_horz) {
2583         self->area = oldarea;
2584         client_configure(self, x, y, w, h, FALSE, TRUE);
2585     }
2586
2587     /* set the desktop hint, to make sure that it always exists */
2588     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
2589
2590     /* nothing to do for the other states:
2591        skip_taskbar
2592        skip_pager
2593        modal
2594        above
2595        below
2596     */
2597 }
2598
2599 void client_gravity_resize_w(ObClient *self, gint *x, gint oldw, gint neww)
2600 {
2601     /* these should be the current values. this is for when you're not moving,
2602        just resizing */
2603     g_assert(*x == self->area.x);
2604     g_assert(oldw == self->area.width);
2605
2606     /* horizontal */
2607     switch (self->gravity) {
2608     default:
2609     case NorthWestGravity:
2610     case WestGravity:
2611     case SouthWestGravity:
2612     case StaticGravity:
2613     case ForgetGravity:
2614         break;
2615     case NorthGravity:
2616     case CenterGravity:
2617     case SouthGravity:
2618         *x -= (neww - oldw) / 2;
2619         break;
2620     case NorthEastGravity:
2621     case EastGravity:
2622     case SouthEastGravity:
2623         *x -= neww - oldw;
2624         break;
2625     }
2626 }
2627
2628 void client_gravity_resize_h(ObClient *self, gint *y, gint oldh, gint newh)
2629 {
2630     /* these should be the current values. this is for when you're not moving,
2631        just resizing */
2632     g_assert(*y == self->area.y);
2633     g_assert(oldh == self->area.height);
2634
2635     /* vertical */
2636     switch (self->gravity) {
2637     default:
2638     case NorthWestGravity:
2639     case NorthGravity:
2640     case NorthEastGravity:
2641     case StaticGravity:
2642     case ForgetGravity:
2643         break;
2644     case WestGravity:
2645     case CenterGravity:
2646     case EastGravity:
2647         *y -= (newh - oldh) / 2;
2648         break;
2649     case SouthWestGravity:
2650     case SouthGravity:
2651     case SouthEastGravity:
2652         *y -= newh - oldh;
2653         break;
2654     }
2655 }
2656
2657 void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h,
2658                           gint *logicalw, gint *logicalh,
2659                           gboolean user)
2660 {
2661     Rect desired_area = {*x, *y, *w, *h};
2662
2663     /* make the frame recalculate its dimentions n shit without changing
2664        anything visible for real, this way the constraints below can work with
2665        the updated frame dimensions. */
2666     frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
2667
2668     /* work within the prefered sizes given by the window */
2669     if (!(*w == self->area.width && *h == self->area.height)) {
2670         gint basew, baseh, minw, minh;
2671
2672         /* base size is substituted with min size if not specified */
2673         if (self->base_size.width || self->base_size.height) {
2674             basew = self->base_size.width;
2675             baseh = self->base_size.height;
2676         } else {
2677             basew = self->min_size.width;
2678             baseh = self->min_size.height;
2679         }
2680         /* min size is substituted with base size if not specified */
2681         if (self->min_size.width || self->min_size.height) {
2682             minw = self->min_size.width;
2683             minh = self->min_size.height;
2684         } else {
2685             minw = self->base_size.width;
2686             minh = self->base_size.height;
2687         }
2688
2689         /* if this is a user-requested resize, then check against min/max
2690            sizes */
2691
2692         /* smaller than min size or bigger than max size? */
2693         if (*w > self->max_size.width) *w = self->max_size.width;
2694         if (*w < minw) *w = minw;
2695         if (*h > self->max_size.height) *h = self->max_size.height;
2696         if (*h < minh) *h = minh;
2697
2698         *w -= basew;
2699         *h -= baseh;
2700
2701         /* keep to the increments */
2702         *w /= self->size_inc.width;
2703         *h /= self->size_inc.height;
2704
2705         /* you cannot resize to nothing */
2706         if (basew + *w < 1) *w = 1 - basew;
2707         if (baseh + *h < 1) *h = 1 - baseh;
2708
2709         /* save the logical size */
2710         *logicalw = self->size_inc.width > 1 ? *w : *w + basew;
2711         *logicalh = self->size_inc.height > 1 ? *h : *h + baseh;
2712
2713         *w *= self->size_inc.width;
2714         *h *= self->size_inc.height;
2715
2716         *w += basew;
2717         *h += baseh;
2718
2719         /* adjust the height to match the width for the aspect ratios.
2720            for this, min size is not substituted for base size ever. */
2721         *w -= self->base_size.width;
2722         *h -= self->base_size.height;
2723
2724         if (!self->fullscreen) {
2725             if (self->min_ratio)
2726                 if (*h * self->min_ratio > *w) {
2727                     *h = (gint)(*w / self->min_ratio);
2728
2729                     /* you cannot resize to nothing */
2730                     if (*h < 1) {
2731                         *h = 1;
2732                         *w = (gint)(*h * self->min_ratio);
2733                     }
2734                 }
2735             if (self->max_ratio)
2736                 if (*h * self->max_ratio < *w) {
2737                     *h = (gint)(*w / self->max_ratio);
2738
2739                     /* you cannot resize to nothing */
2740                     if (*h < 1) {
2741                         *h = 1;
2742                         *w = (gint)(*h * self->min_ratio);
2743                     }
2744                 }
2745         }
2746
2747         *w += self->base_size.width;
2748         *h += self->base_size.height;
2749     }
2750
2751     /* gets the frame's position */
2752     frame_client_gravity(self->frame, x, y, *w, *h);
2753
2754     /* these positions are frame positions, not client positions */
2755
2756     /* set the size and position if fullscreen */
2757     if (self->fullscreen) {
2758         Rect *a;
2759         guint i;
2760
2761         i = screen_find_monitor(&desired_area);
2762         a = screen_physical_area_monitor(i);
2763
2764         *x = a->x;
2765         *y = a->y;
2766         *w = a->width;
2767         *h = a->height;
2768
2769         user = FALSE; /* ignore if the client can't be moved/resized when it
2770                          is fullscreening */
2771     } else if (self->max_horz || self->max_vert) {
2772         Rect *a;
2773         guint i;
2774
2775         i = screen_find_monitor(&desired_area);
2776         a = screen_area_monitor(self->desktop, i);
2777
2778         /* set the size and position if maximized */
2779         if (self->max_horz) {
2780             *x = a->x;
2781             *w = a->width - self->frame->size.left - self->frame->size.right;
2782         }
2783         if (self->max_vert) {
2784             *y = a->y;
2785             *h = a->height - self->frame->size.top - self->frame->size.bottom;
2786         }
2787
2788         user = FALSE; /* ignore if the client can't be moved/resized when it
2789                          is maximizing */
2790     }
2791
2792     /* gets the client's position */
2793     frame_frame_gravity(self->frame, x, y, *w, *h);
2794
2795     /* these override the above states! if you cant move you can't move! */
2796     if (user) {
2797         if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
2798             *x = self->area.x;
2799             *y = self->area.y;
2800         }
2801         if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
2802             *w = self->area.width;
2803             *h = self->area.height;
2804         }
2805     }
2806
2807     g_assert(*w > 0);
2808     g_assert(*h > 0);
2809 }
2810
2811
2812 void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
2813                       gboolean user, gboolean final)
2814 {
2815     gint oldw, oldh;
2816     gboolean send_resize_client;
2817     gboolean moved = FALSE, resized = FALSE;
2818     gboolean fmoved, fresized;
2819     guint fdecor = self->frame->decorations;
2820     gboolean fhorz = self->frame->max_horz;
2821     gboolean fvert = self->frame->max_vert;
2822     gint logicalw, logicalh;
2823
2824     /* find the new x, y, width, and height (and logical size) */
2825     client_try_configure(self, &x, &y, &w, &h, &logicalw, &logicalh, user);
2826
2827     /* set the logical size if things changed */
2828     if (!(w == self->area.width && h == self->area.height))
2829         SIZE_SET(self->logical_size, logicalw, logicalh);
2830
2831     /* figure out if we moved or resized or what */
2832     moved = (x != self->area.x || y != self->area.y);
2833     resized = (w != self->area.width || h != self->area.height);
2834
2835     oldw = self->area.width;
2836     oldh = self->area.height;
2837     RECT_SET(self->area, x, y, w, h);
2838
2839     /* for app-requested resizes, always resize if 'resized' is true.
2840        for user-requested ones, only resize if final is true, or when
2841        resizing in redraw mode */
2842     send_resize_client = ((!user && resized) ||
2843                           (user && (final ||
2844                                     (resized && config_resize_redraw))));
2845
2846     /* if the client is enlarging, then resize the client before the frame */
2847     if (send_resize_client && (w > oldw || h > oldh)) {
2848         XMoveResizeWindow(ob_display, self->window,
2849                           self->frame->size.left, self->frame->size.top,
2850                           MAX(w, oldw), MAX(h, oldh));
2851         frame_adjust_client_area(self->frame);
2852     }
2853
2854     /* find the frame's dimensions and move/resize it */
2855     fmoved = moved;
2856     fresized = resized;
2857
2858     /* if decorations changed, then readjust everything for the frame */
2859     if (self->decorations != fdecor ||
2860         self->max_horz != fhorz || self->max_vert != fvert)
2861     {
2862         fmoved = fresized = TRUE;
2863     }
2864
2865     /* adjust the frame */
2866     if (fmoved || fresized)
2867         frame_adjust_area(self->frame, fmoved, fresized, FALSE);
2868
2869     /* This is kinda tricky and should not be changed.. let me explain!
2870
2871        When user = FALSE, then the request is coming from the application
2872        itself, and we are more strict about when to send a synthetic
2873        ConfigureNotify.  We strictly follow the rules of the ICCCM sec 4.1.5
2874        in this case.
2875
2876        When user = TRUE, then the request is coming from "us", like when we
2877        maximize a window or sometihng.  In this case we are more lenient.  We
2878        used to follow the same rules as above, but _Java_ Swing can't handle
2879        this. So just to appease Swing, when user = TRUE, we always send
2880        a synthetic ConfigureNotify to give the window its root coordinates.
2881     */
2882     if ((!user && !resized) || (user && final))
2883     {
2884         XEvent event;
2885
2886         /* we have reset the client to 0 border width, so don't include
2887            it in these coords */
2888         POINT_SET(self->root_pos,
2889                   self->frame->area.x + self->frame->size.left -
2890                   self->border_width,
2891                   self->frame->area.y + self->frame->size.top -
2892                   self->border_width);
2893
2894         event.type = ConfigureNotify;
2895         event.xconfigure.display = ob_display;
2896         event.xconfigure.event = self->window;
2897         event.xconfigure.window = self->window;
2898
2899         ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
2900                  self->title, self->root_pos.x, self->root_pos.y, w, h);
2901
2902         /* root window real coords */
2903         event.xconfigure.x = self->root_pos.x;
2904         event.xconfigure.y = self->root_pos.y;
2905         event.xconfigure.width = w;
2906         event.xconfigure.height = h;
2907         event.xconfigure.border_width = self->border_width;
2908         event.xconfigure.above = None;
2909         event.xconfigure.override_redirect = FALSE;
2910         XSendEvent(event.xconfigure.display, event.xconfigure.window,
2911                    FALSE, StructureNotifyMask, &event);
2912     }
2913
2914     /* if the client is shrinking, then resize the frame before the client.
2915
2916        both of these resize sections may run, because the top one only resizes
2917        in the direction that is growing
2918      */
2919     if (send_resize_client && (w <= oldw || h <= oldh)) {
2920         frame_adjust_client_area(self->frame);
2921         XMoveResizeWindow(ob_display, self->window,
2922                           self->frame->size.left, self->frame->size.top, w, h);
2923     }
2924
2925     XFlush(ob_display);
2926 }
2927
2928 void client_fullscreen(ObClient *self, gboolean fs)
2929 {
2930     gint x, y, w, h;
2931
2932     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
2933         self->fullscreen == fs) return;                   /* already done */
2934
2935     self->fullscreen = fs;
2936     client_change_state(self); /* change the state hints on the client */
2937
2938     if (fs) {
2939         self->pre_fullscreen_area = self->area;
2940         /* if the window is maximized, its area isn't all that meaningful.
2941            save it's premax area instead. */
2942         if (self->max_horz) {
2943             self->pre_fullscreen_area.x = self->pre_max_area.x;
2944             self->pre_fullscreen_area.width = self->pre_max_area.width;
2945         }
2946         if (self->max_vert) {
2947             self->pre_fullscreen_area.y = self->pre_max_area.y;
2948             self->pre_fullscreen_area.height = self->pre_max_area.height;
2949         }
2950
2951         /* these will help configure_full figure out where to fullscreen
2952            the window */
2953         x = self->area.x;
2954         y = self->area.y;
2955         w = self->area.width;
2956         h = self->area.height;
2957     } else {
2958         g_assert(self->pre_fullscreen_area.width > 0 &&
2959                  self->pre_fullscreen_area.height > 0);
2960
2961         x = self->pre_fullscreen_area.x;
2962         y = self->pre_fullscreen_area.y;
2963         w = self->pre_fullscreen_area.width;
2964         h = self->pre_fullscreen_area.height;
2965         RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
2966     }
2967
2968     client_setup_decor_and_functions(self, FALSE);
2969     client_move_resize(self, x, y, w, h);
2970
2971     /* and adjust our layer/stacking. do this after resizing the window,
2972        and applying decorations, because windows which fill the screen are
2973        considered "fullscreen" and it affects their layer */
2974     client_calc_layer(self);
2975
2976     if (fs) {
2977         /* try focus us when we go into fullscreen mode */
2978         client_focus(self);
2979     }
2980 }
2981
2982 static void client_iconify_recursive(ObClient *self,
2983                                      gboolean iconic, gboolean curdesk,
2984                                      gboolean hide_animation)
2985 {
2986     GSList *it;
2987     gboolean changed = FALSE;
2988
2989
2990     if (self->iconic != iconic) {
2991         ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
2992                  self->window);
2993
2994         if (iconic) {
2995             /* don't let non-normal windows iconify along with their parents
2996                or whatever */
2997             if (client_normal(self)) {
2998                 self->iconic = iconic;
2999
3000                 /* update the focus lists.. iconic windows go to the bottom of
3001                    the list */
3002                 focus_order_to_bottom(self);
3003
3004                 changed = TRUE;
3005             }
3006         } else {
3007             self->iconic = iconic;
3008
3009             if (curdesk && self->desktop != screen_desktop &&
3010                 self->desktop != DESKTOP_ALL)
3011                 client_set_desktop(self, screen_desktop, FALSE);
3012
3013             /* this puts it after the current focused window */
3014             focus_order_remove(self);
3015             focus_order_add_new(self);
3016
3017             changed = TRUE;
3018         }
3019     }
3020
3021     if (changed) {
3022         client_change_state(self);
3023         if (config_animate_iconify && !hide_animation)
3024             frame_begin_iconify_animation(self->frame, iconic);
3025         /* do this after starting the animation so it doesn't flash */
3026         client_showhide(self);
3027     }
3028
3029     /* iconify all direct transients, and deiconify all transients
3030        (non-direct too) */
3031     for (it = self->transients; it; it = g_slist_next(it))
3032         if (it->data != self)
3033             if (client_is_direct_child(self, it->data) || !iconic)
3034                 client_iconify_recursive(it->data, iconic, curdesk,
3035                                          hide_animation);
3036 }
3037
3038 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk,
3039                     gboolean hide_animation)
3040 {
3041     if (self->functions & OB_CLIENT_FUNC_ICONIFY || !iconic) {
3042         /* move up the transient chain as far as possible first */
3043         self = client_search_top_direct_parent(self);
3044         client_iconify_recursive(self, iconic, curdesk, hide_animation);
3045     }
3046 }
3047
3048 void client_maximize(ObClient *self, gboolean max, gint dir)
3049 {
3050     gint x, y, w, h;
3051
3052     g_assert(dir == 0 || dir == 1 || dir == 2);
3053     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
3054
3055     /* check if already done */
3056     if (max) {
3057         if (dir == 0 && self->max_horz && self->max_vert) return;
3058         if (dir == 1 && self->max_horz) return;
3059         if (dir == 2 && self->max_vert) return;
3060     } else {
3061         if (dir == 0 && !self->max_horz && !self->max_vert) return;
3062         if (dir == 1 && !self->max_horz) return;
3063         if (dir == 2 && !self->max_vert) return;
3064     }
3065
3066     /* these will help configure_full figure out which screen to fill with
3067        the window */
3068     x = self->area.x;
3069     y = self->area.y;
3070     w = self->area.width;
3071     h = self->area.height;
3072
3073     if (max) {
3074         if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
3075             RECT_SET(self->pre_max_area,
3076                      self->area.x, self->pre_max_area.y,
3077                      self->area.width, self->pre_max_area.height);
3078         }
3079         if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
3080             RECT_SET(self->pre_max_area,
3081                      self->pre_max_area.x, self->area.y,
3082                      self->pre_max_area.width, self->area.height);
3083         }
3084     } else {
3085         if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
3086             g_assert(self->pre_max_area.width > 0);
3087
3088             x = self->pre_max_area.x;
3089             w = self->pre_max_area.width;
3090
3091             RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
3092                      0, self->pre_max_area.height);
3093         }
3094         if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
3095             g_assert(self->pre_max_area.height > 0);
3096
3097             y = self->pre_max_area.y;
3098             h = self->pre_max_area.height;
3099
3100             RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
3101                      self->pre_max_area.width, 0);
3102         }
3103     }
3104
3105     if (dir == 0 || dir == 1) /* horz */
3106         self->max_horz = max;
3107     if (dir == 0 || dir == 2) /* vert */
3108         self->max_vert = max;
3109
3110     client_change_state(self); /* change the state hints on the client */
3111
3112     client_setup_decor_and_functions(self, FALSE);
3113     client_move_resize(self, x, y, w, h);
3114 }
3115
3116 void client_shade(ObClient *self, gboolean shade)
3117 {
3118     if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
3119          shade) ||                         /* can't shade */
3120         self->shaded == shade) return;     /* already done */
3121
3122     self->shaded = shade;
3123     client_change_state(self);
3124     client_change_wm_state(self); /* the window is being hidden/shown */
3125     /* resize the frame to just the titlebar */
3126     frame_adjust_area(self->frame, FALSE, FALSE, FALSE);
3127 }
3128
3129 void client_close(ObClient *self)
3130 {
3131     XEvent ce;
3132
3133     if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
3134
3135     /* in the case that the client provides no means to requesting that it
3136        close, we just kill it */
3137     if (!self->delete_window)
3138         client_kill(self);
3139
3140     /*
3141       XXX: itd be cool to do timeouts and shit here for killing the client's
3142       process off
3143       like... if the window is around after 5 seconds, then the close button
3144       turns a nice red, and if this function is called again, the client is
3145       explicitly killed.
3146     */
3147
3148     ce.xclient.type = ClientMessage;
3149     ce.xclient.message_type =  prop_atoms.wm_protocols;
3150     ce.xclient.display = ob_display;
3151     ce.xclient.window = self->window;
3152     ce.xclient.format = 32;
3153     ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
3154     ce.xclient.data.l[1] = event_curtime;
3155     ce.xclient.data.l[2] = 0l;
3156     ce.xclient.data.l[3] = 0l;
3157     ce.xclient.data.l[4] = 0l;
3158     XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3159 }
3160
3161 void client_kill(ObClient *self)
3162 {
3163     XKillClient(ob_display, self->window);
3164 }
3165
3166 void client_hilite(ObClient *self, gboolean hilite)
3167 {
3168     if (self->demands_attention == hilite)
3169         return; /* no change */
3170
3171     /* don't allow focused windows to hilite */
3172     self->demands_attention = hilite && !client_focused(self);
3173     if (self->frame != NULL) { /* if we're mapping, just set the state */
3174         if (self->demands_attention)
3175             frame_flash_start(self->frame);
3176         else
3177             frame_flash_stop(self->frame);
3178         client_change_state(self);
3179     }
3180 }
3181
3182 void client_set_desktop_recursive(ObClient *self,
3183                                   guint target,
3184                                   gboolean donthide)
3185 {
3186     guint old;
3187     GSList *it;
3188
3189     if (target != self->desktop && self->type != OB_CLIENT_TYPE_DESKTOP) {
3190
3191         ob_debug("Setting desktop %u\n", target+1);
3192
3193         g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
3194
3195         old = self->desktop;
3196         self->desktop = target;
3197         PROP_SET32(self->window, net_wm_desktop, cardinal, target);
3198         /* the frame can display the current desktop state */
3199         frame_adjust_state(self->frame);
3200         /* 'move' the window to the new desktop */
3201         if (!donthide)
3202             client_showhide(self);
3203         /* raise if it was not already on the desktop */
3204         if (old != DESKTOP_ALL)
3205             stacking_raise(CLIENT_AS_WINDOW(self));
3206         if (STRUT_EXISTS(self->strut))
3207             screen_update_areas();
3208     }
3209
3210     /* move all transients */
3211     for (it = self->transients; it; it = g_slist_next(it))
3212         if (it->data != self)
3213             if (client_is_direct_child(self, it->data))
3214                 client_set_desktop_recursive(it->data, target, donthide);
3215 }
3216
3217 void client_set_desktop(ObClient *self, guint target, gboolean donthide)
3218 {
3219     self = client_search_top_direct_parent(self);
3220     client_set_desktop_recursive(self, target, donthide);
3221 }
3222
3223 gboolean client_is_direct_child(ObClient *parent, ObClient *child)
3224 {
3225     while (child != parent && (child = client_direct_parent(child)));
3226     return child == parent;
3227 }
3228
3229 ObClient *client_search_modal_child(ObClient *self)
3230 {
3231     GSList *it;
3232     ObClient *ret;
3233
3234     for (it = self->transients; it; it = g_slist_next(it)) {
3235         ObClient *c = it->data;
3236         if ((ret = client_search_modal_child(c))) return ret;
3237         if (c->modal) return c;
3238     }
3239     return NULL;
3240 }
3241
3242 gboolean client_validate(ObClient *self)
3243 {
3244     XEvent e;
3245
3246     XSync(ob_display, FALSE); /* get all events on the server */
3247
3248     if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
3249         XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
3250         XPutBackEvent(ob_display, &e);
3251         return FALSE;
3252     }
3253
3254     return TRUE;
3255 }
3256
3257 void client_set_wm_state(ObClient *self, glong state)
3258 {
3259     if (state == self->wmstate) return; /* no change */
3260
3261     switch (state) {
3262     case IconicState:
3263         client_iconify(self, TRUE, TRUE, FALSE);
3264         break;
3265     case NormalState:
3266         client_iconify(self, FALSE, TRUE, FALSE);
3267         break;
3268     }
3269 }
3270
3271 void client_set_state(ObClient *self, Atom action, glong data1, glong data2)
3272 {
3273     gboolean shaded = self->shaded;
3274     gboolean fullscreen = self->fullscreen;
3275     gboolean undecorated = self->undecorated;
3276     gboolean max_horz = self->max_horz;
3277     gboolean max_vert = self->max_vert;
3278     gboolean modal = self->modal;
3279     gboolean iconic = self->iconic;
3280     gboolean demands_attention = self->demands_attention;
3281     gboolean above = self->above;
3282     gboolean below = self->below;
3283     gint i;
3284
3285     if (!(action == prop_atoms.net_wm_state_add ||
3286           action == prop_atoms.net_wm_state_remove ||
3287           action == prop_atoms.net_wm_state_toggle))
3288         /* an invalid action was passed to the client message, ignore it */
3289         return;
3290
3291     for (i = 0; i < 2; ++i) {
3292         Atom state = i == 0 ? data1 : data2;
3293
3294         if (!state) continue;
3295
3296         /* if toggling, then pick whether we're adding or removing */
3297         if (action == prop_atoms.net_wm_state_toggle) {
3298             if (state == prop_atoms.net_wm_state_modal)
3299                 action = modal ? prop_atoms.net_wm_state_remove :
3300                     prop_atoms.net_wm_state_add;
3301             else if (state == prop_atoms.net_wm_state_maximized_vert)
3302                 action = self->max_vert ? prop_atoms.net_wm_state_remove :
3303                     prop_atoms.net_wm_state_add;
3304             else if (state == prop_atoms.net_wm_state_maximized_horz)
3305                 action = self->max_horz ? prop_atoms.net_wm_state_remove :
3306                     prop_atoms.net_wm_state_add;
3307             else if (state == prop_atoms.net_wm_state_shaded)
3308                 action = shaded ? prop_atoms.net_wm_state_remove :
3309                     prop_atoms.net_wm_state_add;
3310             else if (state == prop_atoms.net_wm_state_skip_taskbar)
3311                 action = self->skip_taskbar ?
3312                     prop_atoms.net_wm_state_remove :
3313                     prop_atoms.net_wm_state_add;
3314             else if (state == prop_atoms.net_wm_state_skip_pager)
3315                 action = self->skip_pager ?
3316                     prop_atoms.net_wm_state_remove :
3317                     prop_atoms.net_wm_state_add;
3318             else if (state == prop_atoms.net_wm_state_hidden)
3319                 action = self->iconic ?
3320                     prop_atoms.net_wm_state_remove :
3321                     prop_atoms.net_wm_state_add;
3322             else if (state == prop_atoms.net_wm_state_fullscreen)
3323                 action = fullscreen ?
3324                     prop_atoms.net_wm_state_remove :
3325                     prop_atoms.net_wm_state_add;
3326             else if (state == prop_atoms.net_wm_state_above)
3327                 action = self->above ? prop_atoms.net_wm_state_remove :
3328                     prop_atoms.net_wm_state_add;
3329             else if (state == prop_atoms.net_wm_state_below)
3330                 action = self->below ? prop_atoms.net_wm_state_remove :
3331                     prop_atoms.net_wm_state_add;
3332             else if (state == prop_atoms.net_wm_state_demands_attention)
3333                 action = self->demands_attention ?
3334                     prop_atoms.net_wm_state_remove :
3335                     prop_atoms.net_wm_state_add;
3336             else if (state == prop_atoms.ob_wm_state_undecorated)
3337                 action = undecorated ? prop_atoms.net_wm_state_remove :
3338                     prop_atoms.net_wm_state_add;
3339         }
3340
3341         if (action == prop_atoms.net_wm_state_add) {
3342             if (state == prop_atoms.net_wm_state_modal) {
3343                 modal = TRUE;
3344             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3345                 max_vert = TRUE;
3346             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3347                 max_horz = TRUE;
3348             } else if (state == prop_atoms.net_wm_state_shaded) {
3349                 shaded = TRUE;
3350             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3351                 self->skip_taskbar = TRUE;
3352             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3353                 self->skip_pager = TRUE;
3354             } else if (state == prop_atoms.net_wm_state_hidden) {
3355                 iconic = TRUE;
3356             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3357                 fullscreen = TRUE;
3358             } else if (state == prop_atoms.net_wm_state_above) {
3359                 above = TRUE;
3360                 below = FALSE;
3361             } else if (state == prop_atoms.net_wm_state_below) {
3362                 above = FALSE;
3363                 below = TRUE;
3364             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3365                 demands_attention = TRUE;
3366             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3367                 undecorated = TRUE;
3368             }
3369
3370         } else { /* action == prop_atoms.net_wm_state_remove */
3371             if (state == prop_atoms.net_wm_state_modal) {
3372                 modal = FALSE;
3373             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3374                 max_vert = FALSE;
3375             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3376                 max_horz = FALSE;
3377             } else if (state == prop_atoms.net_wm_state_shaded) {
3378                 shaded = FALSE;
3379             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3380                 self->skip_taskbar = FALSE;
3381             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3382                 self->skip_pager = FALSE;
3383             } else if (state == prop_atoms.net_wm_state_hidden) {
3384                 iconic = FALSE;
3385             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3386                 fullscreen = FALSE;
3387             } else if (state == prop_atoms.net_wm_state_above) {
3388                 above = FALSE;
3389             } else if (state == prop_atoms.net_wm_state_below) {
3390                 below = FALSE;
3391             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3392                 demands_attention = FALSE;
3393             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3394                 undecorated = FALSE;
3395             }
3396         }
3397     }
3398
3399     if (max_horz != self->max_horz || max_vert != self->max_vert) {
3400         if (max_horz != self->max_horz && max_vert != self->max_vert) {
3401             /* toggling both */
3402             if (max_horz == max_vert) { /* both going the same way */
3403                 client_maximize(self, max_horz, 0);
3404             } else {
3405                 client_maximize(self, max_horz, 1);
3406                 client_maximize(self, max_vert, 2);
3407             }
3408         } else {
3409             /* toggling one */
3410             if (max_horz != self->max_horz)
3411                 client_maximize(self, max_horz, 1);
3412             else
3413                 client_maximize(self, max_vert, 2);
3414         }
3415     }
3416     /* change fullscreen state before shading, as it will affect if the window
3417        can shade or not */
3418     if (fullscreen != self->fullscreen)
3419         client_fullscreen(self, fullscreen);
3420     if (shaded != self->shaded)
3421         client_shade(self, shaded);
3422     if (undecorated != self->undecorated)
3423         client_set_undecorated(self, undecorated);
3424     if (above != self->above || below != self->below) {
3425         self->above = above;
3426         self->below = below;
3427         client_calc_layer(self);
3428     }
3429
3430     if (modal != self->modal) {
3431         self->modal = modal;
3432         /* when a window changes modality, then its stacking order with its
3433            transients needs to change */
3434         stacking_raise(CLIENT_AS_WINDOW(self));
3435
3436         /* it also may get focused. if something is focused that shouldn't
3437            be focused anymore, then move the focus */
3438         if (focus_client && client_focus_target(focus_client) != focus_client)
3439             client_focus(focus_client);
3440     }
3441
3442     if (iconic != self->iconic)
3443         client_iconify(self, iconic, FALSE, FALSE);
3444
3445     if (demands_attention != self->demands_attention)
3446         client_hilite(self, demands_attention);
3447
3448     client_change_state(self); /* change the hint to reflect these changes */
3449 }
3450
3451 ObClient *client_focus_target(ObClient *self)
3452 {
3453     ObClient *child = NULL;
3454
3455     child = client_search_modal_child(self);
3456     if (child) return child;
3457     return self;
3458 }
3459
3460 gboolean client_can_focus(ObClient *self)
3461 {
3462     /* choose the correct target */
3463     self = client_focus_target(self);
3464
3465     if (!self->frame->visible)
3466         return FALSE;
3467
3468     if (!(self->can_focus || self->focus_notify))
3469         return FALSE;
3470
3471     return TRUE;
3472 }
3473
3474 gboolean client_focus(ObClient *self)
3475 {
3476     /* we might not focus this window, so if we have modal children which would
3477        be focused instead, bring them to this desktop */
3478     client_bring_modal_windows(self);
3479
3480     /* choose the correct target */
3481     self = client_focus_target(self);
3482
3483     if (!client_can_focus(self)) {
3484         ob_debug_type(OB_DEBUG_FOCUS,
3485                       "Client %s can't be focused\n", self->title);
3486         return FALSE;
3487     }
3488
3489     ob_debug_type(OB_DEBUG_FOCUS,
3490                   "Focusing client \"%s\" (0x%x) at time %u\n",
3491                   self->title, self->window, event_curtime);
3492
3493     /* if there is a grab going on, then we need to cancel it. if we move
3494        focus during the grab, applications will get NotifyWhileGrabbed events
3495        and ignore them !
3496
3497        actions should not rely on being able to move focus during an
3498        interactive grab.
3499     */
3500     event_cancel_all_key_grabs();
3501
3502     xerror_set_ignore(TRUE);
3503     xerror_occured = FALSE;
3504
3505     if (self->can_focus) {
3506         /* This can cause a BadMatch error with CurrentTime, or if an app
3507            passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3508         XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
3509                        event_curtime);
3510     }
3511
3512     if (self->focus_notify) {
3513         XEvent ce;
3514         ce.xclient.type = ClientMessage;
3515         ce.xclient.message_type = prop_atoms.wm_protocols;
3516         ce.xclient.display = ob_display;
3517         ce.xclient.window = self->window;
3518         ce.xclient.format = 32;
3519         ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
3520         ce.xclient.data.l[1] = event_curtime;
3521         ce.xclient.data.l[2] = 0l;
3522         ce.xclient.data.l[3] = 0l;
3523         ce.xclient.data.l[4] = 0l;
3524         XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3525     }
3526
3527     xerror_set_ignore(FALSE);
3528
3529     ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d\n", xerror_occured);
3530     return !xerror_occured;
3531 }
3532
3533 /*! Present the client to the user.
3534   @param raise If the client should be raised or not. You should only set
3535                raise to false if you don't care if the window is completely
3536                hidden.
3537 */
3538 static void client_present(ObClient *self, gboolean here, gboolean raise)
3539 {
3540     /* if using focus_delay, stop the timer now so that focus doesn't
3541        go moving on us */
3542     event_halt_focus_delay();
3543
3544     if (client_normal(self) && screen_showing_desktop)
3545         screen_show_desktop(FALSE, self);
3546     if (self->iconic)
3547         client_iconify(self, FALSE, here, FALSE);
3548     if (self->desktop != DESKTOP_ALL &&
3549         self->desktop != screen_desktop)
3550     {
3551         if (here)
3552             client_set_desktop(self, screen_desktop, FALSE);
3553         else
3554             screen_set_desktop(self->desktop, FALSE);
3555     } else if (!self->frame->visible)
3556         /* if its not visible for other reasons, then don't mess
3557            with it */
3558         return;
3559     if (self->shaded)
3560         client_shade(self, FALSE);
3561     if (raise)
3562         stacking_raise(CLIENT_AS_WINDOW(self));
3563
3564     client_focus(self);
3565 }
3566
3567 void client_activate(ObClient *self, gboolean here, gboolean user)
3568 {
3569     guint32 last_time = focus_client ? focus_client->user_time : CurrentTime;
3570     gboolean allow = FALSE;
3571
3572     /* if the request came from the user, or if nothing is focused, then grant
3573        the request.
3574        if the currently focused app doesn't set a user_time, then it can't
3575        benefit from any focus stealing prevention.
3576     */
3577     if (user || !focus_client || !last_time)
3578         allow = TRUE;
3579     /* otherwise, if they didn't give a time stamp or if it is too old, they
3580        don't get focus */
3581     else
3582         allow = event_curtime && event_time_after(event_curtime, last_time);
3583
3584     ob_debug_type(OB_DEBUG_FOCUS,
3585                   "Want to activate window 0x%x with time %u (last time %u), "
3586                   "source=%s allowing? %d\n",
3587                   self->window, event_curtime, last_time,
3588                   (user ? "user" : "application"), allow);
3589
3590     if (allow)
3591         client_present(self, here, TRUE);
3592     else
3593         /* don't focus it but tell the user it wants attention */
3594         client_hilite(self, TRUE);
3595 }
3596
3597 static void client_bring_windows_recursive(ObClient *self,
3598                                            guint desktop,
3599                                            gboolean helpers,
3600                                            gboolean modals,
3601                                            gboolean iconic)
3602 {
3603     GSList *it;
3604
3605     for (it = self->transients; it; it = g_slist_next(it))
3606         client_bring_windows_recursive(it->data, desktop,
3607                                        helpers, modals, iconic);
3608
3609     if (((helpers && client_helper(self)) ||
3610          (modals && self->modal)) &&
3611         ((self->desktop != desktop && self->desktop != DESKTOP_ALL) ||
3612          (iconic && self->iconic)))
3613     {
3614         if (iconic && self->iconic)
3615             client_iconify(self, FALSE, TRUE, FALSE);
3616         else
3617             client_set_desktop(self, desktop, FALSE);
3618     }
3619 }
3620
3621 void client_bring_helper_windows(ObClient *self)
3622 {
3623     client_bring_windows_recursive(self, self->desktop, TRUE, FALSE, FALSE);
3624 }
3625
3626 void client_bring_modal_windows(ObClient *self)
3627 {
3628     client_bring_windows_recursive(self, self->desktop, FALSE, TRUE, TRUE);
3629 }
3630
3631 gboolean client_focused(ObClient *self)
3632 {
3633     return self == focus_client;
3634 }
3635
3636 static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h)
3637 {
3638     guint i;
3639     gulong min_diff, min_i;
3640
3641     if (!self->nicons) {
3642         ObClientIcon *parent = NULL;
3643         GSList *it;
3644
3645         for (it = self->parents; it; it = g_slist_next(it)) {
3646             ObClient *c = it->data;
3647             if ((parent = client_icon_recursive(c, w, h)))
3648                 break;
3649         }
3650
3651         return parent;
3652     }
3653
3654     /* some kind of crappy approximation to find the icon closest in size to
3655        what we requested, but icons are generally all the same ratio as
3656        eachother so it's good enough. */
3657
3658     min_diff = ABS(self->icons[0].width - w) + ABS(self->icons[0].height - h);
3659     min_i = 0;
3660
3661     for (i = 1; i < self->nicons; ++i) {
3662         gulong diff;
3663
3664         diff = ABS(self->icons[i].width - w) + ABS(self->icons[i].height - h);
3665         if (diff < min_diff) {
3666             min_diff = diff;
3667             min_i = i;
3668         }
3669     }
3670     return &self->icons[min_i];
3671 }
3672
3673 const ObClientIcon* client_icon(ObClient *self, gint w, gint h)
3674 {
3675     ObClientIcon *ret;
3676     static ObClientIcon deficon;
3677
3678     if (!(ret = client_icon_recursive(self, w, h))) {
3679         deficon.width = deficon.height = 48;
3680         deficon.data = ob_rr_theme->def_win_icon;
3681         ret = &deficon;
3682     }
3683     return ret;
3684 }
3685
3686 void client_set_layer(ObClient *self, gint layer)
3687 {
3688     if (layer < 0) {
3689         self->below = TRUE;
3690         self->above = FALSE;
3691     } else if (layer == 0) {
3692         self->below = self->above = FALSE;
3693     } else {
3694         self->below = FALSE;
3695         self->above = TRUE;
3696     }
3697     client_calc_layer(self);
3698     client_change_state(self); /* reflect this in the state hints */
3699 }
3700
3701 void client_set_undecorated(ObClient *self, gboolean undecorated)
3702 {
3703     if (self->undecorated != undecorated &&
3704         /* don't let it undecorate if the function is missing, but let
3705            it redecorate */
3706         (self->functions & OB_CLIENT_FUNC_UNDECORATE || !undecorated))
3707     {
3708         self->undecorated = undecorated;
3709         client_setup_decor_and_functions(self, TRUE);
3710         client_change_state(self); /* reflect this in the state hints */
3711     }
3712 }
3713
3714 guint client_monitor(ObClient *self)
3715 {
3716     return screen_find_monitor(&self->frame->area);
3717 }
3718
3719 ObClient *client_direct_parent(ObClient *self)
3720 {
3721     if (!self->parents) return NULL;
3722     if (self->transient_for_group) return NULL;
3723     return self->parents->data;
3724 }
3725
3726 ObClient *client_search_top_direct_parent(ObClient *self)
3727 {
3728     ObClient *p;
3729     while ((p = client_direct_parent(self))) self = p;
3730     return self;
3731 }
3732
3733 static GSList *client_search_all_top_parents_internal(ObClient *self,
3734                                                       gboolean bylayer,
3735                                                       ObStackingLayer layer)
3736 {
3737     GSList *ret;
3738     ObClient *p;
3739
3740     /* move up the direct transient chain as far as possible */
3741     while ((p = client_direct_parent(self)) &&
3742            (!bylayer || p->layer == layer))
3743         self = p;
3744
3745     if (!self->parents)
3746         ret = g_slist_prepend(NULL, self);
3747     else
3748         ret = g_slist_copy(self->parents);
3749
3750     return ret;
3751 }
3752
3753 GSList *client_search_all_top_parents(ObClient *self)
3754 {
3755     return client_search_all_top_parents_internal(self, FALSE, 0);
3756 }
3757
3758 GSList *client_search_all_top_parents_layer(ObClient *self)
3759 {
3760     return client_search_all_top_parents_internal(self, TRUE, self->layer);
3761 }
3762
3763 ObClient *client_search_focus_parent(ObClient *self)
3764 {
3765     GSList *it;
3766
3767     for (it = self->parents; it; it = g_slist_next(it))
3768         if (client_focused(it->data)) return it->data;
3769
3770     return NULL;
3771 }
3772
3773 ObClient *client_search_parent(ObClient *self, ObClient *search)
3774 {
3775     GSList *it;
3776
3777     for (it = self->parents; it; it = g_slist_next(it))
3778         if (it->data == search) return search;
3779
3780     return NULL;
3781 }
3782
3783 ObClient *client_search_transient(ObClient *self, ObClient *search)
3784 {
3785     GSList *sit;
3786
3787     for (sit = self->transients; sit; sit = g_slist_next(sit)) {
3788         if (sit->data == search)
3789             return search;
3790         if (client_search_transient(sit->data, search))
3791             return search;
3792     }
3793     return NULL;
3794 }
3795
3796 #define WANT_EDGE(cur, c) \
3797             if (cur == c)                                                     \
3798                 continue;                                                     \
3799             if (c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL &&  \
3800                 cur->desktop != screen_desktop)                               \
3801                 continue;                                                     \
3802             if (cur->iconic)                                                  \
3803                 continue;
3804
3805 #define HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end) \
3806             if ((his_edge_start >= my_edge_start && \
3807                  his_edge_start <= my_edge_end) ||  \
3808                 (my_edge_start >= his_edge_start && \
3809                  my_edge_start <= his_edge_end))    \
3810                 dest = his_offset;
3811
3812 /* finds the nearest edge in the given direction from the current client
3813  * note to self: the edge is the -frame- edge (the actual one), not the
3814  * client edge.
3815  */
3816 gint client_directional_edge_search(ObClient *c, ObDirection dir, gboolean hang)
3817 {
3818     gint dest, monitor_dest;
3819     gint my_edge_start, my_edge_end, my_offset;
3820     GList *it;
3821     Rect *a, *monitor;
3822
3823     if(!client_list)
3824         return -1;
3825
3826     a = screen_area(c->desktop);
3827     monitor = screen_area_monitor(c->desktop, client_monitor(c));
3828
3829     switch(dir) {
3830     case OB_DIRECTION_NORTH:
3831         my_edge_start = c->frame->area.x;
3832         my_edge_end = c->frame->area.x + c->frame->area.width;
3833         my_offset = c->frame->area.y + (hang ? c->frame->area.height : 0);
3834
3835         /* default: top of screen */
3836         dest = a->y + (hang ? c->frame->area.height : 0);
3837         monitor_dest = monitor->y + (hang ? c->frame->area.height : 0);
3838         /* if the monitor edge comes before the screen edge, */
3839         /* use that as the destination instead. (For xinerama) */
3840         if (monitor_dest != dest && my_offset > monitor_dest)
3841             dest = monitor_dest;
3842
3843         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3844             gint his_edge_start, his_edge_end, his_offset;
3845             ObClient *cur = it->data;
3846
3847             WANT_EDGE(cur, c)
3848
3849             his_edge_start = cur->frame->area.x;
3850             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3851             his_offset = cur->frame->area.y +
3852                          (hang ? 0 : cur->frame->area.height);
3853
3854             if(his_offset + 1 > my_offset)
3855                 continue;
3856
3857             if(his_offset < dest)
3858                 continue;
3859
3860             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3861         }
3862         break;
3863     case OB_DIRECTION_SOUTH:
3864         my_edge_start = c->frame->area.x;
3865         my_edge_end = c->frame->area.x + c->frame->area.width;
3866         my_offset = c->frame->area.y + (hang ? 0 : c->frame->area.height);
3867
3868         /* default: bottom of screen */
3869         dest = a->y + a->height - (hang ? c->frame->area.height : 0);
3870         monitor_dest = monitor->y + monitor->height -
3871                        (hang ? c->frame->area.height : 0);
3872         /* if the monitor edge comes before the screen edge, */
3873         /* use that as the destination instead. (For xinerama) */
3874         if (monitor_dest != dest && my_offset < monitor_dest)
3875             dest = monitor_dest;
3876
3877         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3878             gint his_edge_start, his_edge_end, his_offset;
3879             ObClient *cur = it->data;
3880
3881             WANT_EDGE(cur, c)
3882
3883             his_edge_start = cur->frame->area.x;
3884             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3885             his_offset = cur->frame->area.y +
3886                          (hang ? cur->frame->area.height : 0);
3887
3888
3889             if(his_offset - 1 < my_offset)
3890                 continue;
3891
3892             if(his_offset > dest)
3893                 continue;
3894
3895             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3896         }
3897         break;
3898     case OB_DIRECTION_WEST:
3899         my_edge_start = c->frame->area.y;
3900         my_edge_end = c->frame->area.y + c->frame->area.height;
3901         my_offset = c->frame->area.x + (hang ? c->frame->area.width : 0);
3902
3903         /* default: leftmost egde of screen */
3904         dest = a->x + (hang ? c->frame->area.width : 0);
3905         monitor_dest = monitor->x + (hang ? c->frame->area.width : 0);
3906         /* if the monitor edge comes before the screen edge, */
3907         /* use that as the destination instead. (For xinerama) */
3908         if (monitor_dest != dest && my_offset > monitor_dest)
3909             dest = monitor_dest;
3910
3911         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3912             gint his_edge_start, his_edge_end, his_offset;
3913             ObClient *cur = it->data;
3914
3915             WANT_EDGE(cur, c)
3916
3917             his_edge_start = cur->frame->area.y;
3918             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3919             his_offset = cur->frame->area.x +
3920                          (hang ? 0 : cur->frame->area.width);
3921
3922             if(his_offset + 1 > my_offset)
3923                 continue;
3924
3925             if(his_offset < dest)
3926                 continue;
3927
3928             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3929         }
3930        break;
3931     case OB_DIRECTION_EAST:
3932         my_edge_start = c->frame->area.y;
3933         my_edge_end = c->frame->area.y + c->frame->area.height;
3934         my_offset = c->frame->area.x + (hang ? 0 : c->frame->area.width);
3935
3936         /* default: rightmost edge of screen */
3937         dest = a->x + a->width - (hang ? c->frame->area.width : 0);
3938         monitor_dest = monitor->x + monitor->width -
3939                        (hang ? c->frame->area.width : 0);
3940         /* if the monitor edge comes before the screen edge, */
3941         /* use that as the destination instead. (For xinerama) */
3942         if (monitor_dest != dest && my_offset < monitor_dest)
3943             dest = monitor_dest;
3944
3945         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3946             gint his_edge_start, his_edge_end, his_offset;
3947             ObClient *cur = it->data;
3948
3949             WANT_EDGE(cur, c)
3950
3951             his_edge_start = cur->frame->area.y;
3952             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3953             his_offset = cur->frame->area.x +
3954                          (hang ? cur->frame->area.width : 0);
3955
3956             if(his_offset - 1 < my_offset)
3957                 continue;
3958
3959             if(his_offset > dest)
3960                 continue;
3961
3962             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3963         }
3964         break;
3965     case OB_DIRECTION_NORTHEAST:
3966     case OB_DIRECTION_SOUTHEAST:
3967     case OB_DIRECTION_NORTHWEST:
3968     case OB_DIRECTION_SOUTHWEST:
3969         /* not implemented */
3970     default:
3971         g_assert_not_reached();
3972         dest = 0; /* suppress warning */
3973     }
3974     return dest;
3975 }
3976
3977 ObClient* client_under_pointer()
3978 {
3979     gint x, y;
3980     GList *it;
3981     ObClient *ret = NULL;
3982
3983     if (screen_pointer_pos(&x, &y)) {
3984         for (it = stacking_list; it; it = g_list_next(it)) {
3985             if (WINDOW_IS_CLIENT(it->data)) {
3986                 ObClient *c = WINDOW_AS_CLIENT(it->data);
3987                 if (c->frame->visible &&
3988                     /* ignore all animating windows */
3989                     !frame_iconify_animating(c->frame) &&
3990                     RECT_CONTAINS(c->frame->area, x, y))
3991                 {
3992                     ret = c;
3993                     break;
3994                 }
3995             }
3996         }
3997     }
3998     return ret;
3999 }
4000
4001 gboolean client_has_group_siblings(ObClient *self)
4002 {
4003     return self->group && self->group->members->next;
4004 }