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