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