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