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