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         } else if (self->transient_for != NULL) { /* transient of window */
1205             /* add to new parent */
1206             self->transient_for->transients =
1207                 g_slist_append(self->transient_for->transients, self);
1208         }
1209     }
1210 }
1211
1212 static void client_get_mwm_hints(ObClient *self)
1213 {
1214     guint num;
1215     guint32 *hints;
1216
1217     self->mwmhints.flags = 0; /* default to none */
1218
1219     if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
1220                     &hints, &num)) {
1221         if (num >= OB_MWM_ELEMENTS) {
1222             self->mwmhints.flags = hints[0];
1223             self->mwmhints.functions = hints[1];
1224             self->mwmhints.decorations = hints[2];
1225         }
1226         g_free(hints);
1227     }
1228 }
1229
1230 void client_get_type(ObClient *self)
1231 {
1232     guint num, i;
1233     guint32 *val;
1234
1235     self->type = -1;
1236
1237     if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
1238         /* use the first value that we know about in the array */
1239         for (i = 0; i < num; ++i) {
1240             if (val[i] == prop_atoms.net_wm_window_type_desktop)
1241                 self->type = OB_CLIENT_TYPE_DESKTOP;
1242             else if (val[i] == prop_atoms.net_wm_window_type_dock)
1243                 self->type = OB_CLIENT_TYPE_DOCK;
1244             else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
1245                 self->type = OB_CLIENT_TYPE_TOOLBAR;
1246             else if (val[i] == prop_atoms.net_wm_window_type_menu)
1247                 self->type = OB_CLIENT_TYPE_MENU;
1248             else if (val[i] == prop_atoms.net_wm_window_type_utility)
1249                 self->type = OB_CLIENT_TYPE_UTILITY;
1250             else if (val[i] == prop_atoms.net_wm_window_type_splash)
1251                 self->type = OB_CLIENT_TYPE_SPLASH;
1252             else if (val[i] == prop_atoms.net_wm_window_type_dialog)
1253                 self->type = OB_CLIENT_TYPE_DIALOG;
1254             else if (val[i] == prop_atoms.net_wm_window_type_normal)
1255                 self->type = OB_CLIENT_TYPE_NORMAL;
1256             else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
1257                 /* prevent this window from getting any decor or
1258                    functionality */
1259                 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
1260                                          OB_MWM_FLAG_DECORATIONS);
1261                 self->mwmhints.decorations = 0;
1262                 self->mwmhints.functions = 0;
1263             }
1264             if (self->type != (ObClientType) -1)
1265                 break; /* grab the first legit type */
1266         }
1267         g_free(val);
1268     }
1269
1270     if (self->type == (ObClientType) -1) {
1271         /*the window type hint was not set, which means we either classify
1272           ourself as a normal window or a dialog, depending on if we are a
1273           transient. */
1274         if (self->transient)
1275             self->type = OB_CLIENT_TYPE_DIALOG;
1276         else
1277             self->type = OB_CLIENT_TYPE_NORMAL;
1278     }
1279 }
1280
1281 void client_update_protocols(ObClient *self)
1282 {
1283     guint32 *proto;
1284     guint num_return, i;
1285
1286     self->focus_notify = FALSE;
1287     self->delete_window = FALSE;
1288
1289     if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1290         for (i = 0; i < num_return; ++i) {
1291             if (proto[i] == prop_atoms.wm_delete_window)
1292                 /* this means we can request the window to close */
1293                 self->delete_window = TRUE;
1294             else if (proto[i] == prop_atoms.wm_take_focus)
1295                 /* if this protocol is requested, then the window will be
1296                    notified whenever we want it to receive focus */
1297                 self->focus_notify = TRUE;
1298 #ifdef SYNC
1299             else if (proto[i] == prop_atoms.net_wm_sync_request)
1300                 /* if this protocol is requested, then resizing the
1301                    window will be synchronized between the frame and the
1302                    client */
1303                 self->sync_request = TRUE;
1304 #endif
1305         }
1306         g_free(proto);
1307     }
1308 }
1309
1310 #ifdef SYNC
1311 void client_update_sync_request_counter(ObClient *self)
1312 {
1313     guint32 i;
1314
1315     if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
1316         self->sync_counter = i;
1317     } else
1318         self->sync_counter = None;
1319 }
1320 #endif
1321
1322 static void client_get_gravity(ObClient *self)
1323 {
1324     XWindowAttributes wattrib;
1325     Status ret;
1326
1327     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
1328     g_assert(ret != BadWindow);
1329     self->gravity = wattrib.win_gravity;
1330 }
1331
1332 void client_get_colormap(ObClient *self)
1333 {
1334     XWindowAttributes wa;
1335
1336     if (XGetWindowAttributes(ob_display, self->window, &wa))
1337         client_update_colormap(self, wa.colormap);
1338 }
1339
1340 void client_update_colormap(ObClient *self, Colormap colormap)
1341 {
1342     self->colormap = colormap;
1343 }
1344
1345 void client_update_normal_hints(ObClient *self)
1346 {
1347     XSizeHints size;
1348     glong ret;
1349     gint oldgravity = self->gravity;
1350
1351     /* defaults */
1352     self->min_ratio = 0.0f;
1353     self->max_ratio = 0.0f;
1354     SIZE_SET(self->size_inc, 1, 1);
1355     SIZE_SET(self->base_size, 0, 0);
1356     SIZE_SET(self->min_size, 0, 0);
1357     SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1358
1359     /* get the hints from the window */
1360     if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1361         /* normal windows can't request placement! har har
1362         if (!client_normal(self))
1363         */
1364         self->positioned = (size.flags & (PPosition|USPosition));
1365
1366         if (size.flags & PWinGravity) {
1367             self->gravity = size.win_gravity;
1368
1369             /* if the client has a frame, i.e. has already been mapped and
1370                is changing its gravity */
1371             if (self->frame && self->gravity != oldgravity) {
1372                 /* move our idea of the client's position based on its new
1373                    gravity */
1374                 client_convert_gravity(self, oldgravity,
1375                                        &self->area.x, &self->area.y,
1376                                        self->area.width, self->area.height);
1377             }
1378         }
1379
1380         if (size.flags & PAspect) {
1381             if (size.min_aspect.y)
1382                 self->min_ratio =
1383                     (gfloat) size.min_aspect.x / size.min_aspect.y;
1384             if (size.max_aspect.y)
1385                 self->max_ratio =
1386                     (gfloat) size.max_aspect.x / size.max_aspect.y;
1387         }
1388
1389         if (size.flags & PMinSize)
1390             SIZE_SET(self->min_size, size.min_width, size.min_height);
1391
1392         if (size.flags & PMaxSize)
1393             SIZE_SET(self->max_size, size.max_width, size.max_height);
1394
1395         if (size.flags & PBaseSize)
1396             SIZE_SET(self->base_size, size.base_width, size.base_height);
1397
1398         if (size.flags & PResizeInc && size.width_inc && size.height_inc)
1399             SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1400     }
1401 }
1402
1403 void client_setup_decor_and_functions(ObClient *self)
1404 {
1405     /* start with everything (cept fullscreen) */
1406     self->decorations =
1407         (OB_FRAME_DECOR_TITLEBAR |
1408          OB_FRAME_DECOR_HANDLE |
1409          OB_FRAME_DECOR_GRIPS |
1410          OB_FRAME_DECOR_BORDER |
1411          OB_FRAME_DECOR_ICON |
1412          OB_FRAME_DECOR_ALLDESKTOPS |
1413          OB_FRAME_DECOR_ICONIFY |
1414          OB_FRAME_DECOR_MAXIMIZE |
1415          OB_FRAME_DECOR_SHADE |
1416          OB_FRAME_DECOR_CLOSE);
1417     self->functions =
1418         (OB_CLIENT_FUNC_RESIZE |
1419          OB_CLIENT_FUNC_MOVE |
1420          OB_CLIENT_FUNC_ICONIFY |
1421          OB_CLIENT_FUNC_MAXIMIZE |
1422          OB_CLIENT_FUNC_SHADE |
1423          OB_CLIENT_FUNC_CLOSE);
1424
1425     if (!(self->min_size.width < self->max_size.width ||
1426           self->min_size.height < self->max_size.height))
1427         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1428
1429     switch (self->type) {
1430     case OB_CLIENT_TYPE_NORMAL:
1431         /* normal windows retain all of the possible decorations and
1432            functionality, and are the only windows that you can fullscreen */
1433         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1434         break;
1435
1436     case OB_CLIENT_TYPE_DIALOG:
1437     case OB_CLIENT_TYPE_UTILITY:
1438         /* these windows cannot be maximized */
1439         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1440         break;
1441
1442     case OB_CLIENT_TYPE_MENU:
1443     case OB_CLIENT_TYPE_TOOLBAR:
1444         /* these windows get less functionality */
1445         self->functions &= ~(OB_CLIENT_FUNC_ICONIFY | OB_CLIENT_FUNC_RESIZE);
1446         break;
1447
1448     case OB_CLIENT_TYPE_DESKTOP:
1449     case OB_CLIENT_TYPE_DOCK:
1450     case OB_CLIENT_TYPE_SPLASH:
1451         /* none of these windows are manipulated by the window manager */
1452         self->decorations = 0;
1453         self->functions = 0;
1454         break;
1455     }
1456
1457     /* Mwm Hints are applied subtractively to what has already been chosen for
1458        decor and functionality */
1459     if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1460         if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1461             if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1462                    (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1463             {
1464                 /* if the mwm hints request no handle or title, then all
1465                    decorations are disabled, but keep the border if that's
1466                    specified */
1467                 if (self->mwmhints.decorations & OB_MWM_DECOR_BORDER)
1468                     self->decorations = OB_FRAME_DECOR_BORDER;
1469                 else
1470                     self->decorations = 0;
1471             }
1472         }
1473     }
1474
1475     if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1476         if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1477             if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1478                 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1479             if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1480                 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1481             /* dont let mwm hints kill any buttons
1482                if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1483                self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1484                if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1485                self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1486             */
1487             /* dont let mwm hints kill the close button
1488                if (! (self->mwmhints.functions & MwmFunc_Close))
1489                self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1490         }
1491     }
1492
1493     if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1494         self->decorations &= ~OB_FRAME_DECOR_SHADE;
1495     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1496         self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1497     if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1498         self->decorations &= ~OB_FRAME_DECOR_GRIPS;
1499
1500     /* can't maximize without moving/resizing */
1501     if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1502           (self->functions & OB_CLIENT_FUNC_MOVE) &&
1503           (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1504         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1505         self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1506     }
1507
1508     /* kill the handle on fully maxed windows */
1509     if (self->max_vert && self->max_horz)
1510         self->decorations &= ~OB_FRAME_DECOR_HANDLE;
1511
1512     /* finally, the user can have requested no decorations, which overrides
1513        everything (but doesnt give it a border if it doesnt have one) */
1514     if (self->undecorated) {
1515         if (config_theme_keepborder)
1516             self->decorations &= OB_FRAME_DECOR_BORDER;
1517         else
1518             self->decorations = 0;
1519     }
1520
1521     /* if we don't have a titlebar, then we cannot shade! */
1522     if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1523         self->functions &= ~OB_CLIENT_FUNC_SHADE;
1524
1525     /* now we need to check against rules for the client's current state */
1526     if (self->fullscreen) {
1527         self->functions &= (OB_CLIENT_FUNC_CLOSE |
1528                             OB_CLIENT_FUNC_FULLSCREEN |
1529                             OB_CLIENT_FUNC_ICONIFY);
1530         self->decorations = 0;
1531     }
1532
1533     client_change_allowed_actions(self);
1534
1535     if (self->frame) {
1536         /* adjust the client's decorations, etc. */
1537         client_reconfigure(self);
1538     }
1539 }
1540
1541 static void client_change_allowed_actions(ObClient *self)
1542 {
1543     gulong actions[9];
1544     gint num = 0;
1545
1546     /* desktop windows are kept on all desktops */
1547     if (self->type != OB_CLIENT_TYPE_DESKTOP)
1548         actions[num++] = prop_atoms.net_wm_action_change_desktop;
1549
1550     if (self->functions & OB_CLIENT_FUNC_SHADE)
1551         actions[num++] = prop_atoms.net_wm_action_shade;
1552     if (self->functions & OB_CLIENT_FUNC_CLOSE)
1553         actions[num++] = prop_atoms.net_wm_action_close;
1554     if (self->functions & OB_CLIENT_FUNC_MOVE)
1555         actions[num++] = prop_atoms.net_wm_action_move;
1556     if (self->functions & OB_CLIENT_FUNC_ICONIFY)
1557         actions[num++] = prop_atoms.net_wm_action_minimize;
1558     if (self->functions & OB_CLIENT_FUNC_RESIZE)
1559         actions[num++] = prop_atoms.net_wm_action_resize;
1560     if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
1561         actions[num++] = prop_atoms.net_wm_action_fullscreen;
1562     if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
1563         actions[num++] = prop_atoms.net_wm_action_maximize_horz;
1564         actions[num++] = prop_atoms.net_wm_action_maximize_vert;
1565     }
1566
1567     PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
1568
1569     /* make sure the window isn't breaking any rules now */
1570
1571     if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
1572         if (self->frame) client_shade(self, FALSE);
1573         else self->shaded = FALSE;
1574     }
1575     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
1576         if (self->frame) client_iconify(self, FALSE, TRUE);
1577         else self->iconic = FALSE;
1578     }
1579     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
1580         if (self->frame) client_fullscreen(self, FALSE);
1581         else self->fullscreen = FALSE;
1582     }
1583     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
1584                                                          self->max_vert)) {
1585         if (self->frame) client_maximize(self, FALSE, 0);
1586         else self->max_vert = self->max_horz = FALSE;
1587     }
1588 }
1589
1590 void client_reconfigure(ObClient *self)
1591 {
1592     /* by making this pass FALSE for user, we avoid the emacs event storm where
1593        every configurenotify causes an update in its normal hints, i think this
1594        is generally what we want anyways... */
1595     client_configure(self, self->area.x, self->area.y,
1596                      self->area.width, self->area.height, FALSE, TRUE);
1597 }
1598
1599 void client_update_wmhints(ObClient *self)
1600 {
1601     XWMHints *hints;
1602     GSList *it;
1603
1604     /* assume a window takes input if it doesnt specify */
1605     self->can_focus = TRUE;
1606
1607     if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
1608         gboolean ur;
1609
1610         if (hints->flags & InputHint)
1611             self->can_focus = hints->input;
1612
1613         /* only do this when first managing the window *AND* when we aren't
1614            starting up! */
1615         if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
1616             if (hints->flags & StateHint)
1617                 self->iconic = hints->initial_state == IconicState;
1618
1619         ur = self->urgent;
1620         self->urgent = (hints->flags & XUrgencyHint);
1621         if (self->urgent && !ur)
1622             client_hilite(self, TRUE);
1623         else if (!self->urgent && ur && self->demands_attention)
1624             client_hilite(self, FALSE);
1625
1626         if (!(hints->flags & WindowGroupHint))
1627             hints->window_group = None;
1628
1629         /* did the group state change? */
1630         if (hints->window_group !=
1631             (self->group ? self->group->leader : None)) {
1632             /* remove from the old group if there was one */
1633             if (self->group != NULL) {
1634                 /* remove transients of the group */
1635                 for (it = self->group->members; it; it = g_slist_next(it))
1636                     self->transients = g_slist_remove(self->transients,
1637                                                       it->data);
1638
1639                 /* remove myself from parents in the group */
1640                 if (self->transient_for == OB_TRAN_GROUP) {
1641                     for (it = self->group->members; it;
1642                          it = g_slist_next(it))
1643                     {
1644                         ObClient *c = it->data;
1645
1646                         if (c != self && !c->transient_for)
1647                             c->transients = g_slist_remove(c->transients,
1648                                                            self);
1649                     }
1650                 }
1651
1652                 group_remove(self->group, self);
1653                 self->group = NULL;
1654             }
1655             if (hints->window_group != None) {
1656                 self->group = group_add(hints->window_group, self);
1657
1658                 /* i can only have transients from the group if i am not
1659                    transient myself */
1660                 if (!self->transient_for) {
1661                     /* add other transients of the group that are already
1662                        set up */
1663                     for (it = self->group->members; it;
1664                          it = g_slist_next(it))
1665                     {
1666                         ObClient *c = it->data;
1667                         if (c != self && c->transient_for == OB_TRAN_GROUP)
1668                             self->transients =
1669                                 g_slist_append(self->transients, c);
1670                     }
1671                 }
1672             }
1673
1674             /* because the self->transient flag wont change from this call,
1675                we don't need to update the window's type and such, only its
1676                transient_for, and the transients lists of other windows in
1677                the group may be affected */
1678             client_update_transient_for(self);
1679         }
1680
1681         /* the WM_HINTS can contain an icon */
1682         client_update_icons(self);
1683
1684         XFree(hints);
1685     }
1686 }
1687
1688 void client_update_title(ObClient *self)
1689 {
1690     gchar *data = NULL;
1691     gchar *visible = NULL;
1692
1693     g_free(self->title);
1694
1695     /* try netwm */
1696     if (!PROP_GETS(self->window, net_wm_name, utf8, &data)) {
1697         /* try old x stuff */
1698         if (!(PROP_GETS(self->window, wm_name, locale, &data)
1699               || PROP_GETS(self->window, wm_name, utf8, &data))) {
1700             if (self->transient) {
1701                 /*
1702                   GNOME alert windows are not given titles:
1703                   http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1704                 */
1705                 data = g_strdup("");
1706             } else
1707                 data = g_strdup("Unnamed Window");
1708         }
1709     }
1710
1711     if (self->client_machine) {
1712         visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1713         g_free(data);
1714     } else
1715         visible = data;
1716
1717     PROP_SETS(self->window, net_wm_visible_name, visible);
1718     self->title = visible;
1719
1720     if (self->frame)
1721         frame_adjust_title(self->frame);
1722
1723     /* update the icon title */
1724     data = NULL;
1725     g_free(self->icon_title);
1726
1727     /* try netwm */
1728     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
1729         /* try old x stuff */
1730         if (!(PROP_GETS(self->window, wm_icon_name, locale, &data) ||
1731               PROP_GETS(self->window, wm_icon_name, utf8, &data)))
1732             data = g_strdup(self->title);
1733
1734     PROP_SETS(self->window, net_wm_visible_icon_name, data);
1735     self->icon_title = data;
1736 }
1737
1738 void client_update_class(ObClient *self)
1739 {
1740     gchar **data;
1741     gchar *s;
1742
1743     if (self->name) g_free(self->name);
1744     if (self->class) g_free(self->class);
1745     if (self->role) g_free(self->role);
1746
1747     self->name = self->class = self->role = NULL;
1748
1749     if (PROP_GETSS(self->window, wm_class, locale, &data)) {
1750         if (data[0]) {
1751             self->name = g_strdup(data[0]);
1752             if (data[1])
1753                 self->class = g_strdup(data[1]);
1754         }
1755         g_strfreev(data);
1756     }
1757
1758     if (PROP_GETS(self->window, wm_window_role, locale, &s))
1759         self->role = s;
1760
1761     if (self->name == NULL) self->name = g_strdup("");
1762     if (self->class == NULL) self->class = g_strdup("");
1763     if (self->role == NULL) self->role = g_strdup("");
1764 }
1765
1766 void client_update_strut(ObClient *self)
1767 {
1768     guint num;
1769     guint32 *data;
1770     gboolean got = FALSE;
1771     StrutPartial strut;
1772
1773     if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
1774                     &data, &num)) {
1775         if (num == 12) {
1776             got = TRUE;
1777             STRUT_PARTIAL_SET(strut,
1778                               data[0], data[2], data[1], data[3],
1779                               data[4], data[5], data[8], data[9],
1780                               data[6], data[7], data[10], data[11]);
1781         }
1782         g_free(data);
1783     }
1784
1785     if (!got &&
1786         PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
1787         if (num == 4) {
1788             const Rect *a;
1789
1790             got = TRUE;
1791
1792             /* use the screen's width/height */
1793             a = screen_physical_area();
1794
1795             STRUT_PARTIAL_SET(strut,
1796                               data[0], data[2], data[1], data[3],
1797                               a->y, a->y + a->height - 1,
1798                               a->x, a->x + a->width - 1,
1799                               a->y, a->y + a->height - 1,
1800                               a->x, a->x + a->width - 1);
1801         }
1802         g_free(data);
1803     }
1804
1805     if (!got)
1806         STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
1807                           0, 0, 0, 0, 0, 0, 0, 0);
1808
1809     if (!STRUT_EQUAL(strut, self->strut)) {
1810         self->strut = strut;
1811
1812         /* updating here is pointless while we're being mapped cuz we're not in
1813            the client list yet */
1814         if (self->frame)
1815             screen_update_areas();
1816     }
1817 }
1818
1819 void client_update_icons(ObClient *self)
1820 {
1821     guint num;
1822     guint32 *data;
1823     guint w, h, i, j;
1824
1825     for (i = 0; i < self->nicons; ++i)
1826         g_free(self->icons[i].data);
1827     if (self->nicons > 0)
1828         g_free(self->icons);
1829     self->nicons = 0;
1830
1831     if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
1832         /* figure out how many valid icons are in here */
1833         i = 0;
1834         while (num - i > 2) {
1835             w = data[i++];
1836             h = data[i++];
1837             i += w * h;
1838             if (i > num || w*h == 0) break;
1839             ++self->nicons;
1840         }
1841
1842         self->icons = g_new(ObClientIcon, self->nicons);
1843
1844         /* store the icons */
1845         i = 0;
1846         for (j = 0; j < self->nicons; ++j) {
1847             guint x, y, t;
1848
1849             w = self->icons[j].width = data[i++];
1850             h = self->icons[j].height = data[i++];
1851
1852             if (w*h == 0) continue;
1853
1854             self->icons[j].data = g_new(RrPixel32, w * h);
1855             for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
1856                 if (x >= w) {
1857                     x = 0;
1858                     ++y;
1859                 }
1860                 self->icons[j].data[t] =
1861                     (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
1862                     (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
1863                     (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
1864                     (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
1865             }
1866             g_assert(i <= num);
1867         }
1868
1869         g_free(data);
1870     } else {
1871         XWMHints *hints;
1872
1873         if ((hints = XGetWMHints(ob_display, self->window))) {
1874             if (hints->flags & IconPixmapHint) {
1875                 self->nicons++;
1876                 self->icons = g_new(ObClientIcon, self->nicons);
1877                 xerror_set_ignore(TRUE);
1878                 if (!RrPixmapToRGBA(ob_rr_inst,
1879                                     hints->icon_pixmap,
1880                                     (hints->flags & IconMaskHint ?
1881                                      hints->icon_mask : None),
1882                                     &self->icons[self->nicons-1].width,
1883                                     &self->icons[self->nicons-1].height,
1884                                     &self->icons[self->nicons-1].data)){
1885                     g_free(&self->icons[self->nicons-1]);
1886                     self->nicons--;
1887                 }
1888                 xerror_set_ignore(FALSE);
1889             }
1890             XFree(hints);
1891         }
1892     }
1893
1894     /* set the default icon onto the window
1895        in theory, this could be a race, but if a window doesn't set an icon
1896        or removes it entirely, it's not very likely it is going to set one
1897        right away afterwards */
1898     if (self->nicons == 0) {
1899         RrPixel32 *icon = ob_rr_theme->def_win_icon;
1900         gulong *data;
1901
1902         data = g_new(gulong, 48*48+2);
1903         data[0] = data[1] =  48;
1904         for (i = 0; i < 48*48; ++i)
1905             data[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
1906                 (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
1907                 (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
1908                 (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
1909         PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2);
1910         g_free(data);
1911     } else if (self->frame)
1912         /* don't draw the icon empty if we're just setting one now anyways,
1913            we'll get the property change any second */
1914         frame_adjust_icon(self->frame);
1915 }
1916
1917 void client_update_user_time(ObClient *self)
1918 {
1919     guint32 time;
1920
1921     if (PROP_GET32(self->window, net_wm_user_time, cardinal, &time)) {
1922         /* we set this every time, not just when it grows, because in practice
1923            sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes
1924            backward we don't want all windows to stop focusing. we'll just
1925            assume noone is setting times older than the last one, cuz that
1926            would be pretty stupid anyways
1927         */
1928         self->user_time = time;
1929
1930         /*
1931         ob_debug("window %s user time %u\n", self->title, time);
1932         */
1933     }
1934 }
1935
1936 static void client_get_client_machine(ObClient *self)
1937 {
1938     gchar *data = NULL;
1939     gchar localhost[128];
1940
1941     g_free(self->client_machine);
1942
1943     if (PROP_GETS(self->window, wm_client_machine, locale, &data)) {
1944         gethostname(localhost, 127);
1945         localhost[127] = '\0';
1946         if (strcmp(localhost, data))
1947             self->client_machine = data;
1948     }
1949 }
1950
1951 static void client_change_wm_state(ObClient *self)
1952 {
1953     gulong state[2];
1954     glong old;
1955
1956     old = self->wmstate;
1957
1958     if (self->shaded || self->iconic || !self->frame->visible)
1959         self->wmstate = IconicState;
1960     else
1961         self->wmstate = NormalState;
1962
1963     if (old != self->wmstate) {
1964         PROP_MSG(self->window, kde_wm_change_state,
1965                  self->wmstate, 1, 0, 0);
1966
1967         state[0] = self->wmstate;
1968         state[1] = None;
1969         PROP_SETA32(self->window, wm_state, wm_state, state, 2);
1970     }
1971 }
1972
1973 static void client_change_state(ObClient *self)
1974 {
1975     gulong netstate[11];
1976     guint num;
1977
1978     num = 0;
1979     if (self->modal)
1980         netstate[num++] = prop_atoms.net_wm_state_modal;
1981     if (self->shaded)
1982         netstate[num++] = prop_atoms.net_wm_state_shaded;
1983     if (self->iconic)
1984         netstate[num++] = prop_atoms.net_wm_state_hidden;
1985     if (self->skip_taskbar)
1986         netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
1987     if (self->skip_pager)
1988         netstate[num++] = prop_atoms.net_wm_state_skip_pager;
1989     if (self->fullscreen)
1990         netstate[num++] = prop_atoms.net_wm_state_fullscreen;
1991     if (self->max_vert)
1992         netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
1993     if (self->max_horz)
1994         netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
1995     if (self->above)
1996         netstate[num++] = prop_atoms.net_wm_state_above;
1997     if (self->below)
1998         netstate[num++] = prop_atoms.net_wm_state_below;
1999     if (self->demands_attention)
2000         netstate[num++] = prop_atoms.net_wm_state_demands_attention;
2001     if (self->undecorated)
2002         netstate[num++] = prop_atoms.ob_wm_state_undecorated;
2003     PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
2004
2005     if (self->frame)
2006         frame_adjust_state(self->frame);
2007 }
2008
2009 ObClient *client_search_focus_tree(ObClient *self)
2010 {
2011     GSList *it;
2012     ObClient *ret;
2013
2014     for (it = self->transients; it; it = g_slist_next(it)) {
2015         if (client_focused(it->data)) return it->data;
2016         if ((ret = client_search_focus_tree(it->data))) return ret;
2017     }
2018     return NULL;
2019 }
2020
2021 ObClient *client_search_focus_tree_full(ObClient *self)
2022 {
2023     if (self->transient_for) {
2024         if (self->transient_for != OB_TRAN_GROUP) {
2025             return client_search_focus_tree_full(self->transient_for);
2026         } else {
2027             GSList *it;
2028             gboolean recursed = FALSE;
2029
2030             for (it = self->group->members; it; it = g_slist_next(it))
2031                 if (!((ObClient*)it->data)->transient_for) {
2032                     ObClient *c;
2033                     if ((c = client_search_focus_tree_full(it->data)))
2034                         return c;
2035                     recursed = TRUE;
2036                 }
2037             if (recursed)
2038                 return NULL;
2039         }
2040     }
2041
2042     /* this function checks the whole tree, the client_search_focus_tree~
2043        does not, so we need to check this window */
2044     if (client_focused(self))
2045         return self;
2046     return client_search_focus_tree(self);
2047 }
2048
2049 static ObStackingLayer calc_layer(ObClient *self)
2050 {
2051     ObStackingLayer l;
2052
2053     if (self->fullscreen &&
2054         (client_focused(self) || client_search_focus_tree(self)))
2055         l = OB_STACKING_LAYER_FULLSCREEN;
2056     else if (self->type == OB_CLIENT_TYPE_DESKTOP)
2057         l = OB_STACKING_LAYER_DESKTOP;
2058     else if (self->type == OB_CLIENT_TYPE_DOCK) {
2059         if (self->below) l = OB_STACKING_LAYER_NORMAL;
2060         else l = OB_STACKING_LAYER_ABOVE;
2061     }
2062     else if (self->above) l = OB_STACKING_LAYER_ABOVE;
2063     else if (self->below) l = OB_STACKING_LAYER_BELOW;
2064     else l = OB_STACKING_LAYER_NORMAL;
2065
2066     return l;
2067 }
2068
2069 static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
2070                                         ObStackingLayer min, gboolean raised)
2071 {
2072     ObStackingLayer old, own;
2073     GSList *it;
2074
2075     old = self->layer;
2076     own = calc_layer(self);
2077     self->layer = MAX(own, min);
2078
2079     for (it = self->transients; it; it = g_slist_next(it))
2080         client_calc_layer_recursive(it->data, orig,
2081                                     self->layer,
2082                                     raised ? raised : self->layer != old);
2083
2084     if (!raised && self->layer != old)
2085         if (orig->frame) { /* only restack if the original window is managed */
2086             stacking_remove(CLIENT_AS_WINDOW(self));
2087             stacking_add(CLIENT_AS_WINDOW(self));
2088         }
2089 }
2090
2091 void client_calc_layer(ObClient *self)
2092 {
2093     ObClient *orig;
2094     GSList *it;
2095
2096     orig = self;
2097
2098     /* transients take on the layer of their parents */
2099     it = client_search_all_top_parents(self);
2100
2101     for (; it; it = g_slist_next(it))
2102         client_calc_layer_recursive(it->data, orig, 0, FALSE);
2103 }
2104
2105 gboolean client_should_show(ObClient *self)
2106 {
2107     if (self->iconic)
2108         return FALSE;
2109     if (client_normal(self) && screen_showing_desktop)
2110         return FALSE;
2111     /*
2112     if (self->transient_for) {
2113         if (self->transient_for != OB_TRAN_GROUP)
2114             return client_should_show(self->transient_for);
2115         else {
2116             GSList *it;
2117
2118             for (it = self->group->members; it; it = g_slist_next(it)) {
2119                 ObClient *c = it->data;
2120                 if (c != self && !c->transient_for) {
2121                     if (client_should_show(c))
2122                         return TRUE;
2123                 }
2124             }
2125         }
2126     }
2127     */
2128     if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
2129         return TRUE;
2130
2131     return FALSE;
2132 }
2133
2134 void client_show(ObClient *self)
2135 {
2136
2137     if (client_should_show(self)) {
2138         frame_show(self->frame);
2139     }
2140
2141     /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2142        needs to be in IconicState. This includes when it is on another
2143        desktop!
2144     */
2145     client_change_wm_state(self);
2146 }
2147
2148 void client_hide(ObClient *self)
2149 {
2150     if (!client_should_show(self)) {
2151         frame_hide(self->frame);
2152     }
2153
2154     /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2155        needs to be in IconicState. This includes when it is on another
2156        desktop!
2157     */
2158     client_change_wm_state(self);
2159 }
2160
2161 void client_showhide(ObClient *self)
2162 {
2163
2164     if (client_should_show(self)) {
2165         frame_show(self->frame);
2166     }
2167     else {
2168         frame_hide(self->frame);
2169     }
2170
2171     /* According to the ICCCM (sec 4.1.3.1) when a window is not visible, it
2172        needs to be in IconicState. This includes when it is on another
2173        desktop!
2174     */
2175     client_change_wm_state(self);
2176 }
2177
2178 gboolean client_normal(ObClient *self) {
2179     return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
2180               self->type == OB_CLIENT_TYPE_DOCK ||
2181               self->type == OB_CLIENT_TYPE_SPLASH);
2182 }
2183
2184 gboolean client_application(ObClient *self)
2185 {
2186     return (self->type == OB_CLIENT_TYPE_NORMAL ||
2187             self->type == OB_CLIENT_TYPE_DIALOG);
2188 }
2189
2190 static void client_apply_startup_state(ObClient *self, gint x, gint y)
2191 {
2192     gboolean pos = FALSE; /* has the window's position been configured? */
2193     gint ox, oy;
2194
2195     /* save the position, and set self->area for these to use */
2196     ox = self->area.x;
2197     oy = self->area.y;
2198     self->area.x = x;
2199     self->area.y = y;
2200
2201     /* set the desktop hint, to make sure that it always exists */
2202     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
2203
2204     /* these are in a carefully crafted order.. */
2205
2206     if (self->iconic) {
2207         self->iconic = FALSE;
2208         client_iconify(self, TRUE, FALSE);
2209     }
2210     if (self->fullscreen) {
2211         self->fullscreen = FALSE;
2212         client_fullscreen(self, TRUE);
2213         pos = TRUE;
2214     }
2215     if (self->undecorated) {
2216         self->undecorated = FALSE;
2217         client_set_undecorated(self, TRUE);
2218     }
2219     if (self->shaded) {
2220         self->shaded = FALSE;
2221         client_shade(self, TRUE);
2222     }
2223     if (self->demands_attention) {
2224         self->demands_attention = FALSE;
2225         client_hilite(self, TRUE);
2226     }
2227
2228     if (self->max_vert && self->max_horz) {
2229         self->max_vert = self->max_horz = FALSE;
2230         client_maximize(self, TRUE, 0);
2231         pos = TRUE;
2232     } else if (self->max_vert) {
2233         self->max_vert = FALSE;
2234         client_maximize(self, TRUE, 2);
2235         pos = TRUE;
2236     } else if (self->max_horz) {
2237         self->max_horz = FALSE;
2238         client_maximize(self, TRUE, 1);
2239         pos = TRUE;
2240     }
2241
2242     /* if the client didn't get positioned yet, then do so now
2243        call client_move even if the window is not being moved anywhere, because
2244        when we reparent it and decorate it, it is getting moved and we need to
2245        be telling it so with a ConfigureNotify event.
2246     */
2247     if (!pos) {
2248         /* use the saved position */
2249         self->area.x = ox;
2250         self->area.y = oy;
2251         client_move(self, x, y);
2252     }
2253
2254     /* nothing to do for the other states:
2255        skip_taskbar
2256        skip_pager
2257        modal
2258        above
2259        below
2260     */
2261 }
2262
2263 void client_convert_gravity(ObClient *self, gint gravity, gint *x, gint *y,
2264                             gint w, gint h)
2265 {
2266     gint oldg = self->gravity;
2267
2268     /* get the frame's position from the requested stuff */
2269     self->gravity = gravity;
2270     frame_client_gravity(self->frame, x, y, w, h);
2271     self->gravity = oldg;
2272
2273     /* get the client's position in its true gravity from that */
2274     frame_frame_gravity(self->frame, x, y, w, h);
2275 }
2276
2277 void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h,
2278                           gint *logicalw, gint *logicalh,
2279                           gboolean user)
2280 {
2281     Rect desired_area = {*x, *y, *w, *h};
2282
2283     /* make the frame recalculate its dimentions n shit without changing
2284        anything visible for real, this way the constraints below can work with
2285        the updated frame dimensions. */
2286     frame_adjust_area(self->frame, TRUE, TRUE, TRUE);
2287
2288     /* work within the prefered sizes given by the window */
2289     if (!(*w == self->area.width && *h == self->area.height)) {
2290         gint basew, baseh, minw, minh;
2291
2292         /* base size is substituted with min size if not specified */
2293         if (self->base_size.width || self->base_size.height) {
2294             basew = self->base_size.width;
2295             baseh = self->base_size.height;
2296         } else {
2297             basew = self->min_size.width;
2298             baseh = self->min_size.height;
2299         }
2300         /* min size is substituted with base size if not specified */
2301         if (self->min_size.width || self->min_size.height) {
2302             minw = self->min_size.width;
2303             minh = self->min_size.height;
2304         } else {
2305             minw = self->base_size.width;
2306             minh = self->base_size.height;
2307         }
2308
2309         /* if this is a user-requested resize, then check against min/max
2310            sizes */
2311
2312         /* smaller than min size or bigger than max size? */
2313         if (*w > self->max_size.width) *w = self->max_size.width;
2314         if (*w < minw) *w = minw;
2315         if (*h > self->max_size.height) *h = self->max_size.height;
2316         if (*h < minh) *h = minh;
2317
2318         *w -= basew;
2319         *h -= baseh;
2320
2321         /* keep to the increments */
2322         *w /= self->size_inc.width;
2323         *h /= self->size_inc.height;
2324
2325         /* you cannot resize to nothing */
2326         if (basew + *w < 1) *w = 1 - basew;
2327         if (baseh + *h < 1) *h = 1 - baseh;
2328
2329         /* save the logical size */
2330         *logicalw = self->size_inc.width > 1 ? *w : *w + basew;
2331         *logicalh = self->size_inc.height > 1 ? *h : *h + baseh;
2332
2333         *w *= self->size_inc.width;
2334         *h *= self->size_inc.height;
2335
2336         *w += basew;
2337         *h += baseh;
2338
2339         /* adjust the height to match the width for the aspect ratios.
2340            for this, min size is not substituted for base size ever. */
2341         *w -= self->base_size.width;
2342         *h -= self->base_size.height;
2343
2344         if (!self->fullscreen) {
2345             if (self->min_ratio)
2346                 if (*h * self->min_ratio > *w) {
2347                     *h = (gint)(*w / self->min_ratio);
2348
2349                     /* you cannot resize to nothing */
2350                     if (*h < 1) {
2351                         *h = 1;
2352                         *w = (gint)(*h * self->min_ratio);
2353                     }
2354                 }
2355             if (self->max_ratio)
2356                 if (*h * self->max_ratio < *w) {
2357                     *h = (gint)(*w / self->max_ratio);
2358
2359                     /* you cannot resize to nothing */
2360                     if (*h < 1) {
2361                         *h = 1;
2362                         *w = (gint)(*h * self->min_ratio);
2363                     }
2364                 }
2365         }
2366
2367         *w += self->base_size.width;
2368         *h += self->base_size.height;
2369     }
2370
2371     /* gets the frame's position */
2372     frame_client_gravity(self->frame, x, y, *w, *h);
2373
2374     /* these positions are frame positions, not client positions */
2375
2376     /* set the size and position if fullscreen */
2377     if (self->fullscreen) {
2378         Rect *a;
2379         guint i;
2380
2381         i = screen_find_monitor(&desired_area);
2382         a = screen_physical_area_monitor(i);
2383
2384         *x = a->x;
2385         *y = a->y;
2386         *w = a->width;
2387         *h = a->height;
2388
2389         user = FALSE; /* ignore if the client can't be moved/resized when it
2390                          is entering fullscreen */
2391     } else if (self->max_horz || self->max_vert) {
2392         Rect *a;
2393         guint i;
2394
2395         i = screen_find_monitor(&desired_area);
2396         a = screen_area_monitor(self->desktop, i);
2397
2398         /* set the size and position if maximized */
2399         if (self->max_horz) {
2400             *x = a->x;
2401             *w = a->width - self->frame->size.left - self->frame->size.right;
2402         }
2403         if (self->max_vert) {
2404             *y = a->y;
2405             *h = a->height - self->frame->size.top - self->frame->size.bottom;
2406         }
2407
2408         /* maximizing is not allowed if the user can't move+resize the window
2409          */
2410     }
2411
2412     /* gets the client's position */
2413     frame_frame_gravity(self->frame, x, y, *w, *h);
2414
2415     /* these override the above states! if you cant move you can't move! */
2416     if (user) {
2417         if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
2418             *x = self->area.x;
2419             *y = self->area.y;
2420         }
2421         if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
2422             *w = self->area.width;
2423             *h = self->area.height;
2424         }
2425     }
2426
2427     g_assert(*w > 0);
2428     g_assert(*h > 0);
2429 }
2430
2431
2432 void client_configure_full(ObClient *self, gint x, gint y, gint w, gint h,
2433                            gboolean user, gboolean final,
2434                            gboolean force_reply)
2435 {
2436     gint oldw, oldh, oldrx, oldry;
2437     gboolean send_resize_client;
2438     gboolean moved = FALSE, resized = FALSE, rootmoved = FALSE;
2439     guint fdecor = self->frame->decorations;
2440     gboolean fhorz = self->frame->max_horz;
2441     gint logicalw, logicalh;
2442
2443     /* find the new x, y, width, and height (and logical size) */
2444     client_try_configure(self, &x, &y, &w, &h, &logicalw, &logicalh, user);
2445
2446     /* set the logical size if things changed */
2447     if (!(w == self->area.width && h == self->area.height))
2448         SIZE_SET(self->logical_size, logicalw, logicalh);
2449
2450     /* figure out if we moved or resized or what */
2451     moved = x != self->area.x || y != self->area.y;
2452     resized = w != self->area.width || h != self->area.height;
2453
2454     oldw = self->area.width;
2455     oldh = self->area.height;
2456     RECT_SET(self->area, x, y, w, h);
2457
2458     /* for app-requested resizes, always resize if 'resized' is true.
2459        for user-requested ones, only resize if final is true, or when
2460        resizing in redraw mode */
2461     send_resize_client = ((!user && resized) ||
2462                           (user && (final ||
2463                                     (resized && config_resize_redraw))));
2464
2465     /* if the client is enlarging, then resize the client before the frame */
2466     if (send_resize_client && user && (w > oldw || h > oldh)) {
2467         XResizeWindow(ob_display, self->window, MAX(w, oldw), MAX(h, oldh));
2468         /* resize the plate to show the client padding color underneath */
2469         frame_adjust_client_area(self->frame);
2470     }
2471
2472     /* find the frame's dimensions and move/resize it */
2473     if (self->decorations != fdecor || self->max_horz != fhorz)
2474         moved = resized = TRUE;
2475     if (moved || resized)
2476         frame_adjust_area(self->frame, moved, resized, FALSE);
2477
2478     /* find the client's position relative to the root window */
2479     oldrx = self->root_pos.x;
2480     oldry = self->root_pos.y;
2481     rootmoved = (oldrx != (signed)(self->frame->area.x +
2482                                    self->frame->size.left -
2483                                    self->border_width) ||
2484                  oldry != (signed)(self->frame->area.y +
2485                                    self->frame->size.top -
2486                                    self->border_width));
2487
2488     if (force_reply || ((!user || (user && final)) && rootmoved))
2489     {
2490         XEvent event;
2491
2492         POINT_SET(self->root_pos,
2493                   self->frame->area.x + self->frame->size.left -
2494                   self->border_width,
2495                   self->frame->area.y + self->frame->size.top -
2496                   self->border_width);
2497
2498         event.type = ConfigureNotify;
2499         event.xconfigure.display = ob_display;
2500         event.xconfigure.event = self->window;
2501         event.xconfigure.window = self->window;
2502
2503         /* root window real coords */
2504         event.xconfigure.x = self->root_pos.x;
2505         event.xconfigure.y = self->root_pos.y;
2506         event.xconfigure.width = w;
2507         event.xconfigure.height = h;
2508         event.xconfigure.border_width = 0;
2509         event.xconfigure.above = self->frame->plate;
2510         event.xconfigure.override_redirect = FALSE;
2511         XSendEvent(event.xconfigure.display, event.xconfigure.window,
2512                    FALSE, StructureNotifyMask, &event);
2513     }
2514
2515     /* if the client is shrinking, then resize the frame before the client */
2516     if (send_resize_client && (!user || (w <= oldw || h <= oldh))) {
2517         /* resize the plate to show the client padding color underneath */
2518         frame_adjust_client_area(self->frame);
2519
2520         XResizeWindow(ob_display, self->window, w, h);
2521     }
2522
2523     XFlush(ob_display);
2524 }
2525
2526 void client_fullscreen(ObClient *self, gboolean fs)
2527 {
2528     gint x, y, w, h;
2529
2530     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
2531         self->fullscreen == fs) return;                   /* already done */
2532
2533     self->fullscreen = fs;
2534     client_change_state(self); /* change the state hints on the client */
2535     client_calc_layer(self);   /* and adjust out layer/stacking */
2536
2537     if (fs) {
2538         self->pre_fullscreen_area = self->area;
2539         /* if the window is maximized, its area isn't all that meaningful.
2540            save it's premax area instead. */
2541         if (self->max_horz) {
2542             self->pre_fullscreen_area.x = self->pre_max_area.x;
2543             self->pre_fullscreen_area.width = self->pre_max_area.width;
2544         }
2545         if (self->max_vert) {
2546             self->pre_fullscreen_area.y = self->pre_max_area.y;
2547             self->pre_fullscreen_area.height = self->pre_max_area.height;
2548         }
2549
2550         /* these are not actually used cuz client_configure will set them
2551            as appropriate when the window is fullscreened */
2552         x = y = w = h = 0;
2553     } else {
2554         Rect *a;
2555
2556         if (self->pre_fullscreen_area.width > 0 &&
2557             self->pre_fullscreen_area.height > 0)
2558         {
2559             x = self->pre_fullscreen_area.x;
2560             y = self->pre_fullscreen_area.y;
2561             w = self->pre_fullscreen_area.width;
2562             h = self->pre_fullscreen_area.height;
2563             RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
2564         } else {
2565             /* pick some fallbacks... */
2566             a = screen_area_monitor(self->desktop, 0);
2567             x = a->x + a->width / 4;
2568             y = a->y + a->height / 4;
2569             w = a->width / 2;
2570             h = a->height / 2;
2571         }
2572     }
2573
2574     client_setup_decor_and_functions(self);
2575
2576     client_move_resize(self, x, y, w, h);
2577
2578     /* try focus us when we go into fullscreen mode */
2579     client_focus(self);
2580 }
2581
2582 static void client_iconify_recursive(ObClient *self,
2583                                      gboolean iconic, gboolean curdesk)
2584 {
2585     GSList *it;
2586     gboolean changed = FALSE;
2587
2588
2589     if (self->iconic != iconic) {
2590         ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
2591                  self->window);
2592
2593         if (iconic) {
2594             if (self->functions & OB_CLIENT_FUNC_ICONIFY) {
2595                 self->iconic = iconic;
2596
2597                 /* update the focus lists.. iconic windows go to the bottom of
2598                    the list, put the new iconic window at the 'top of the
2599                    bottom'. */
2600                 focus_order_to_top(self);
2601
2602                 changed = TRUE;
2603             }
2604         } else {
2605             self->iconic = iconic;
2606
2607             if (curdesk)
2608                 client_set_desktop(self, screen_desktop, FALSE);
2609
2610             /* this puts it after the current focused window */
2611             focus_order_remove(self);
2612             focus_order_add_new(self);
2613
2614             changed = TRUE;
2615         }
2616     }
2617
2618     if (changed) {
2619         client_change_state(self);
2620         client_showhide(self);
2621         if (STRUT_EXISTS(self->strut))
2622             screen_update_areas();
2623     }
2624
2625     /* iconify all direct transients, and deiconify all transients
2626        (non-direct too) */
2627     for (it = self->transients; it; it = g_slist_next(it))
2628         if (it->data != self)
2629             if (client_is_direct_child(self, it->data) || !iconic)
2630                 client_iconify_recursive(it->data, iconic, curdesk);
2631 }
2632
2633 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk)
2634 {
2635     /* move up the transient chain as far as possible first */
2636     self = client_search_top_parent(self);
2637     client_iconify_recursive(self, iconic, curdesk);
2638 }
2639
2640 void client_maximize(ObClient *self, gboolean max, gint dir)
2641 {
2642     gint x, y, w, h;
2643
2644     g_assert(dir == 0 || dir == 1 || dir == 2);
2645     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
2646
2647     /* check if already done */
2648     if (max) {
2649         if (dir == 0 && self->max_horz && self->max_vert) return;
2650         if (dir == 1 && self->max_horz) return;
2651         if (dir == 2 && self->max_vert) return;
2652     } else {
2653         if (dir == 0 && !self->max_horz && !self->max_vert) return;
2654         if (dir == 1 && !self->max_horz) return;
2655         if (dir == 2 && !self->max_vert) return;
2656     }
2657
2658     /* we just tell it to configure in the same place and client_configure
2659        worries about filling the screen with the window */
2660     x = self->area.x;
2661     y = self->area.y;
2662     w = self->area.width;
2663     h = self->area.height;
2664
2665     if (max) {
2666         if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
2667             RECT_SET(self->pre_max_area,
2668                      self->area.x, self->pre_max_area.y,
2669                      self->area.width, self->pre_max_area.height);
2670         }
2671         if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
2672             RECT_SET(self->pre_max_area,
2673                      self->pre_max_area.x, self->area.y,
2674                      self->pre_max_area.width, self->area.height);
2675         }
2676     } else {
2677         Rect *a;
2678
2679         a = screen_area_monitor(self->desktop, 0);
2680         if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
2681             if (self->pre_max_area.width > 0) {
2682                 x = self->pre_max_area.x;
2683                 w = self->pre_max_area.width;
2684
2685                 RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
2686                          0, self->pre_max_area.height);
2687             } else {
2688                 /* pick some fallbacks... */
2689                 x = a->x + a->width / 4;
2690                 w = a->width / 2;
2691             }
2692         }
2693         if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
2694             if (self->pre_max_area.height > 0) {
2695                 y = self->pre_max_area.y;
2696                 h = self->pre_max_area.height;
2697
2698                 RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
2699                          self->pre_max_area.width, 0);
2700             } else {
2701                 /* pick some fallbacks... */
2702                 y = a->y + a->height / 4;
2703                 h = a->height / 2;
2704             }
2705         }
2706     }
2707
2708     if (dir == 0 || dir == 1) /* horz */
2709         self->max_horz = max;
2710     if (dir == 0 || dir == 2) /* vert */
2711         self->max_vert = max;
2712
2713     client_change_state(self); /* change the state hints on the client */
2714
2715     client_setup_decor_and_functions(self);
2716
2717     client_move_resize(self, x, y, w, h);
2718 }
2719
2720 void client_shade(ObClient *self, gboolean shade)
2721 {
2722     if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
2723          shade) ||                         /* can't shade */
2724         self->shaded == shade) return;     /* already done */
2725
2726     self->shaded = shade;
2727     client_change_state(self);
2728     client_change_wm_state(self); /* the window is being hidden/shown */
2729     /* resize the frame to just the titlebar */
2730     frame_adjust_area(self->frame, FALSE, FALSE, FALSE);
2731 }
2732
2733 void client_close(ObClient *self)
2734 {
2735     XEvent ce;
2736
2737     if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
2738
2739     /* in the case that the client provides no means to requesting that it
2740        close, we just kill it */
2741     if (!self->delete_window)
2742         client_kill(self);
2743
2744     /*
2745       XXX: itd be cool to do timeouts and shit here for killing the client's
2746       process off
2747       like... if the window is around after 5 seconds, then the close button
2748       turns a nice red, and if this function is called again, the client is
2749       explicitly killed.
2750     */
2751
2752     ce.xclient.type = ClientMessage;
2753     ce.xclient.message_type =  prop_atoms.wm_protocols;
2754     ce.xclient.display = ob_display;
2755     ce.xclient.window = self->window;
2756     ce.xclient.format = 32;
2757     ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
2758     ce.xclient.data.l[1] = event_curtime;
2759     ce.xclient.data.l[2] = 0l;
2760     ce.xclient.data.l[3] = 0l;
2761     ce.xclient.data.l[4] = 0l;
2762     XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
2763 }
2764
2765 void client_kill(ObClient *self)
2766 {
2767     XKillClient(ob_display, self->window);
2768 }
2769
2770 void client_hilite(ObClient *self, gboolean hilite)
2771 {
2772     if (self->demands_attention == hilite)
2773         return; /* no change */
2774
2775     /* don't allow focused windows to hilite */
2776     self->demands_attention = hilite && !client_focused(self);
2777     if (self->frame != NULL) { /* if we're mapping, just set the state */
2778         if (self->demands_attention)
2779             frame_flash_start(self->frame);
2780         else
2781             frame_flash_stop(self->frame);
2782         client_change_state(self);
2783     }
2784 }
2785
2786 void client_set_desktop_recursive(ObClient *self,
2787                                   guint target, gboolean donthide)
2788 {
2789     guint old;
2790     GSList *it;
2791
2792     if (target != self->desktop) {
2793
2794         ob_debug("Setting desktop %u\n", target+1);
2795
2796         g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
2797
2798         /* remove from the old desktop(s) */
2799         focus_order_remove(self);
2800
2801         old = self->desktop;
2802         self->desktop = target;
2803         PROP_SET32(self->window, net_wm_desktop, cardinal, target);
2804         /* the frame can display the current desktop state */
2805         frame_adjust_state(self->frame);
2806         /* 'move' the window to the new desktop */
2807         if (!donthide)
2808             client_showhide(self);
2809         /* raise if it was not already on the desktop */
2810         if (old != DESKTOP_ALL)
2811             client_raise(self);
2812         if (STRUT_EXISTS(self->strut))
2813             screen_update_areas();
2814
2815         /* add to the new desktop(s) */
2816         if (config_focus_new)
2817             focus_order_to_top(self);
2818         else
2819             focus_order_to_bottom(self);
2820     }
2821
2822     /* move all transients */
2823     for (it = self->transients; it; it = g_slist_next(it))
2824         if (it->data != self)
2825             if (client_is_direct_child(self, it->data))
2826                 client_set_desktop_recursive(it->data, target, donthide);
2827 }
2828
2829 void client_set_desktop(ObClient *self, guint target, gboolean donthide)
2830 {
2831     self = client_search_top_parent(self);
2832     client_set_desktop_recursive(self, target, donthide);
2833 }
2834
2835 gboolean client_is_direct_child(ObClient *parent, ObClient *child)
2836 {
2837     while (child != parent &&
2838            child->transient_for && child->transient_for != OB_TRAN_GROUP)
2839         child = child->transient_for;
2840     return child == parent;
2841 }
2842
2843 ObClient *client_search_modal_child(ObClient *self)
2844 {
2845     GSList *it;
2846     ObClient *ret;
2847
2848     for (it = self->transients; it; it = g_slist_next(it)) {
2849         ObClient *c = it->data;
2850         if ((ret = client_search_modal_child(c))) return ret;
2851         if (c->modal) return c;
2852     }
2853     return NULL;
2854 }
2855
2856 gboolean client_validate(ObClient *self)
2857 {
2858     XEvent e;
2859
2860     XSync(ob_display, FALSE); /* get all events on the server */
2861
2862     if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
2863         XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
2864         XPutBackEvent(ob_display, &e);
2865         return FALSE;
2866     }
2867
2868     return TRUE;
2869 }
2870
2871 void client_set_wm_state(ObClient *self, glong state)
2872 {
2873     if (state == self->wmstate) return; /* no change */
2874
2875     switch (state) {
2876     case IconicState:
2877         client_iconify(self, TRUE, TRUE);
2878         break;
2879     case NormalState:
2880         client_iconify(self, FALSE, TRUE);
2881         break;
2882     }
2883 }
2884
2885 void client_set_state(ObClient *self, Atom action, glong data1, glong data2)
2886 {
2887     gboolean shaded = self->shaded;
2888     gboolean fullscreen = self->fullscreen;
2889     gboolean undecorated = self->undecorated;
2890     gboolean max_horz = self->max_horz;
2891     gboolean max_vert = self->max_vert;
2892     gboolean modal = self->modal;
2893     gboolean iconic = self->iconic;
2894     gboolean demands_attention = self->demands_attention;
2895     gint i;
2896
2897     if (!(action == prop_atoms.net_wm_state_add ||
2898           action == prop_atoms.net_wm_state_remove ||
2899           action == prop_atoms.net_wm_state_toggle))
2900         /* an invalid action was passed to the client message, ignore it */
2901         return;
2902
2903     for (i = 0; i < 2; ++i) {
2904         Atom state = i == 0 ? data1 : data2;
2905
2906         if (!state) continue;
2907
2908         /* if toggling, then pick whether we're adding or removing */
2909         if (action == prop_atoms.net_wm_state_toggle) {
2910             if (state == prop_atoms.net_wm_state_modal)
2911                 action = modal ? prop_atoms.net_wm_state_remove :
2912                     prop_atoms.net_wm_state_add;
2913             else if (state == prop_atoms.net_wm_state_maximized_vert)
2914                 action = self->max_vert ? prop_atoms.net_wm_state_remove :
2915                     prop_atoms.net_wm_state_add;
2916             else if (state == prop_atoms.net_wm_state_maximized_horz)
2917                 action = self->max_horz ? prop_atoms.net_wm_state_remove :
2918                     prop_atoms.net_wm_state_add;
2919             else if (state == prop_atoms.net_wm_state_shaded)
2920                 action = shaded ? prop_atoms.net_wm_state_remove :
2921                     prop_atoms.net_wm_state_add;
2922             else if (state == prop_atoms.net_wm_state_skip_taskbar)
2923                 action = self->skip_taskbar ?
2924                     prop_atoms.net_wm_state_remove :
2925                     prop_atoms.net_wm_state_add;
2926             else if (state == prop_atoms.net_wm_state_skip_pager)
2927                 action = self->skip_pager ?
2928                     prop_atoms.net_wm_state_remove :
2929                     prop_atoms.net_wm_state_add;
2930             else if (state == prop_atoms.net_wm_state_hidden)
2931                 action = self->iconic ?
2932                     prop_atoms.net_wm_state_remove :
2933                     prop_atoms.net_wm_state_add;
2934             else if (state == prop_atoms.net_wm_state_fullscreen)
2935                 action = fullscreen ?
2936                     prop_atoms.net_wm_state_remove :
2937                     prop_atoms.net_wm_state_add;
2938             else if (state == prop_atoms.net_wm_state_above)
2939                 action = self->above ? prop_atoms.net_wm_state_remove :
2940                     prop_atoms.net_wm_state_add;
2941             else if (state == prop_atoms.net_wm_state_below)
2942                 action = self->below ? prop_atoms.net_wm_state_remove :
2943                     prop_atoms.net_wm_state_add;
2944             else if (state == prop_atoms.net_wm_state_demands_attention)
2945                 action = self->demands_attention ?
2946                     prop_atoms.net_wm_state_remove :
2947                     prop_atoms.net_wm_state_add;
2948             else if (state == prop_atoms.ob_wm_state_undecorated)
2949                 action = undecorated ? prop_atoms.net_wm_state_remove :
2950                     prop_atoms.net_wm_state_add;
2951         }
2952
2953         if (action == prop_atoms.net_wm_state_add) {
2954             if (state == prop_atoms.net_wm_state_modal) {
2955                 modal = TRUE;
2956             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
2957                 max_vert = TRUE;
2958             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
2959                 max_horz = TRUE;
2960             } else if (state == prop_atoms.net_wm_state_shaded) {
2961                 shaded = TRUE;
2962             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
2963                 self->skip_taskbar = TRUE;
2964             } else if (state == prop_atoms.net_wm_state_skip_pager) {
2965                 self->skip_pager = TRUE;
2966             } else if (state == prop_atoms.net_wm_state_hidden) {
2967                 iconic = TRUE;
2968             } else if (state == prop_atoms.net_wm_state_fullscreen) {
2969                 fullscreen = TRUE;
2970             } else if (state == prop_atoms.net_wm_state_above) {
2971                 self->above = TRUE;
2972                 self->below = FALSE;
2973             } else if (state == prop_atoms.net_wm_state_below) {
2974                 self->above = FALSE;
2975                 self->below = TRUE;
2976             } else if (state == prop_atoms.net_wm_state_demands_attention) {
2977                 demands_attention = TRUE;
2978             } else if (state == prop_atoms.ob_wm_state_undecorated) {
2979                 undecorated = TRUE;
2980             }
2981
2982         } else { /* action == prop_atoms.net_wm_state_remove */
2983             if (state == prop_atoms.net_wm_state_modal) {
2984                 modal = FALSE;
2985             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
2986                 max_vert = FALSE;
2987             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
2988                 max_horz = FALSE;
2989             } else if (state == prop_atoms.net_wm_state_shaded) {
2990                 shaded = FALSE;
2991             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
2992                 self->skip_taskbar = FALSE;
2993             } else if (state == prop_atoms.net_wm_state_skip_pager) {
2994                 self->skip_pager = FALSE;
2995             } else if (state == prop_atoms.net_wm_state_hidden) {
2996                 iconic = FALSE;
2997             } else if (state == prop_atoms.net_wm_state_fullscreen) {
2998                 fullscreen = FALSE;
2999             } else if (state == prop_atoms.net_wm_state_above) {
3000                 self->above = FALSE;
3001             } else if (state == prop_atoms.net_wm_state_below) {
3002                 self->below = FALSE;
3003             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3004                 demands_attention = FALSE;
3005             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3006                 undecorated = FALSE;
3007             }
3008         }
3009     }
3010     if (max_horz != self->max_horz || max_vert != self->max_vert) {
3011         if (max_horz != self->max_horz && max_vert != self->max_vert) {
3012             /* toggling both */
3013             if (max_horz == max_vert) { /* both going the same way */
3014                 client_maximize(self, max_horz, 0);
3015             } else {
3016                 client_maximize(self, max_horz, 1);
3017                 client_maximize(self, max_vert, 2);
3018             }
3019         } else {
3020             /* toggling one */
3021             if (max_horz != self->max_horz)
3022                 client_maximize(self, max_horz, 1);
3023             else
3024                 client_maximize(self, max_vert, 2);
3025         }
3026     }
3027     /* change fullscreen state before shading, as it will affect if the window
3028        can shade or not */
3029     if (fullscreen != self->fullscreen)
3030         client_fullscreen(self, fullscreen);
3031     if (shaded != self->shaded)
3032         client_shade(self, shaded);
3033     if (undecorated != self->undecorated)
3034         client_set_undecorated(self, undecorated);
3035     if (modal != self->modal) {
3036         self->modal = modal;
3037         /* when a window changes modality, then its stacking order with its
3038            transients needs to change */
3039         client_raise(self);
3040     }
3041     if (iconic != self->iconic)
3042         client_iconify(self, iconic, FALSE);
3043
3044     if (demands_attention != self->demands_attention)
3045         client_hilite(self, demands_attention);
3046
3047     client_change_state(self); /* change the hint to reflect these changes */
3048 }
3049
3050 ObClient *client_focus_target(ObClient *self)
3051 {
3052     ObClient *child = NULL;
3053
3054     child = client_search_modal_child(self);
3055     if (child) return child;
3056     return self;
3057 }
3058
3059 gboolean client_can_focus(ObClient *self)
3060 {
3061     XEvent ev;
3062
3063     /* choose the correct target */
3064     self = client_focus_target(self);
3065
3066     if (!self->frame->visible)
3067         return FALSE;
3068
3069     if (!(self->can_focus || self->focus_notify))
3070         return FALSE;
3071
3072     /* do a check to see if the window has already been unmapped or destroyed
3073        do this intelligently while watching out for unmaps we've generated
3074        (ignore_unmaps > 0) */
3075     if (XCheckTypedWindowEvent(ob_display, self->window,
3076                                DestroyNotify, &ev)) {
3077         XPutBackEvent(ob_display, &ev);
3078         return FALSE;
3079     }
3080     while (XCheckTypedWindowEvent(ob_display, self->window,
3081                                   UnmapNotify, &ev)) {
3082         if (self->ignore_unmaps) {
3083             self->ignore_unmaps--;
3084         } else {
3085             XPutBackEvent(ob_display, &ev);
3086             return FALSE;
3087         }
3088     }
3089
3090     return TRUE;
3091 }
3092
3093 gboolean client_focus(ObClient *self)
3094 {
3095     /* choose the correct target */
3096     self = client_focus_target(self);
3097
3098     if (!client_can_focus(self)) {
3099         if (!self->frame->visible) {
3100             /* update the focus lists */
3101             focus_order_to_top(self);
3102         }
3103         return FALSE;
3104     }
3105
3106     ob_debug_type(OB_DEBUG_FOCUS,
3107                   "Focusing client \"%s\" at time %u\n",
3108                   self->title, event_curtime);
3109
3110     if (self->can_focus) {
3111         /* This can cause a BadMatch error with CurrentTime, or if an app
3112            passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3113         xerror_set_ignore(TRUE);
3114         XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
3115                        event_curtime);
3116         xerror_set_ignore(FALSE);
3117     }
3118
3119     if (self->focus_notify) {
3120         XEvent ce;
3121         ce.xclient.type = ClientMessage;
3122         ce.xclient.message_type = prop_atoms.wm_protocols;
3123         ce.xclient.display = ob_display;
3124         ce.xclient.window = self->window;
3125         ce.xclient.format = 32;
3126         ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
3127         ce.xclient.data.l[1] = event_curtime;
3128         ce.xclient.data.l[2] = 0l;
3129         ce.xclient.data.l[3] = 0l;
3130         ce.xclient.data.l[4] = 0l;
3131         XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3132     }
3133
3134 #ifdef DEBUG_FOCUS
3135     ob_debug("%sively focusing %lx at %d\n",
3136              (self->can_focus ? "act" : "pass"),
3137              self->window, (gint) event_curtime);
3138 #endif
3139
3140     /* Cause the FocusIn to come back to us. Important for desktop switches,
3141        since otherwise we'll have no FocusIn on the queue and send it off to
3142        the focus_backup. */
3143     XSync(ob_display, FALSE);
3144     return TRUE;
3145 }
3146
3147 void client_activate(ObClient *self, gboolean here, gboolean user)
3148 {
3149     guint32 last_time = focus_client ? focus_client->user_time : CurrentTime;
3150
3151     /* XXX do some stuff here if user is false to determine if we really want
3152        to activate it or not (a parent or group member is currently
3153        active)?
3154     */
3155     ob_debug_type(OB_DEBUG_FOCUS,
3156                   "Want to activate window 0x%x with time %u (last time %u), "
3157                   "source=%s\n",
3158                   self->window, event_curtime, last_time,
3159                   (user ? "user" : "application"));
3160
3161     if (!user && event_curtime && last_time &&
3162         !event_time_after(event_curtime, last_time))
3163     {
3164         client_hilite(self, TRUE);
3165     } else {
3166         if (event_curtime != CurrentTime)
3167             self->user_time = event_curtime;
3168
3169         /* if using focus_delay, stop the timer now so that focus doesn't
3170            go moving on us */
3171         event_halt_focus_delay();
3172
3173         if (client_normal(self) && screen_showing_desktop)
3174             screen_show_desktop(FALSE);
3175         if (self->iconic)
3176             client_iconify(self, FALSE, here);
3177         if (self->desktop != DESKTOP_ALL &&
3178             self->desktop != screen_desktop) {
3179             if (here)
3180                 client_set_desktop(self, screen_desktop, FALSE);
3181             else
3182                 screen_set_desktop(self->desktop);
3183         } else if (!self->frame->visible)
3184             /* if its not visible for other reasons, then don't mess
3185                with it */
3186             return;
3187         if (self->shaded)
3188             client_shade(self, FALSE);
3189
3190         client_focus(self);
3191
3192         /* we do this as an action here. this is rather important. this is
3193            because we want the results from the focus change to take place
3194            BEFORE we go about raising the window. when a fullscreen window
3195            loses focus, we need this or else the raise wont be able to raise
3196            above the to-lose-focus fullscreen window. */
3197         client_raise(self);
3198     }
3199 }
3200
3201 void client_raise(ObClient *self)
3202 {
3203     action_run_string("Raise", self, CurrentTime);
3204 }
3205
3206 void client_lower(ObClient *self)
3207 {
3208     action_run_string("Lower", self, CurrentTime);
3209 }
3210
3211 gboolean client_focused(ObClient *self)
3212 {
3213     return self == focus_client;
3214 }
3215
3216 static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h)
3217 {
3218     guint i;
3219     /* si is the smallest image >= req */
3220     /* li is the largest image < req */
3221     gulong size, smallest = 0xffffffff, largest = 0, si = 0, li = 0;
3222
3223     if (!self->nicons) {
3224         ObClientIcon *parent = NULL;
3225
3226         if (self->transient_for) {
3227             if (self->transient_for != OB_TRAN_GROUP)
3228                 parent = client_icon_recursive(self->transient_for, w, h);
3229             else {
3230                 GSList *it;
3231                 for (it = self->group->members; it; it = g_slist_next(it)) {
3232                     ObClient *c = it->data;
3233                     if (c != self && !c->transient_for) {
3234                         if ((parent = client_icon_recursive(c, w, h)))
3235                             break;
3236                     }
3237                 }
3238             }
3239         }
3240
3241         return parent;
3242     }
3243
3244     for (i = 0; i < self->nicons; ++i) {
3245         size = self->icons[i].width * self->icons[i].height;
3246         if (size < smallest && size >= (unsigned)(w * h)) {
3247             smallest = size;
3248             si = i;
3249         }
3250         if (size > largest && size <= (unsigned)(w * h)) {
3251             largest = size;
3252             li = i;
3253         }
3254     }
3255     if (largest == 0) /* didnt find one smaller than the requested size */
3256         return &self->icons[si];
3257     return &self->icons[li];
3258 }
3259
3260 const ObClientIcon* client_icon(ObClient *self, gint w, gint h)
3261 {
3262     ObClientIcon *ret;
3263     static ObClientIcon deficon;
3264
3265     if (!(ret = client_icon_recursive(self, w, h))) {
3266         deficon.width = deficon.height = 48;
3267         deficon.data = ob_rr_theme->def_win_icon;
3268         ret = &deficon;
3269     }
3270     return ret;
3271 }
3272
3273 void client_set_layer(ObClient *self, gint layer)
3274 {
3275     if (layer < 0) {
3276         self->below = TRUE;
3277         self->above = FALSE;
3278     } else if (layer == 0) {
3279         self->below = self->above = FALSE;
3280     } else {
3281         self->below = FALSE;
3282         self->above = TRUE;
3283     }
3284     client_calc_layer(self);
3285     client_change_state(self); /* reflect this in the state hints */
3286 }
3287
3288 void client_set_undecorated(ObClient *self, gboolean undecorated)
3289 {
3290     if (self->undecorated != undecorated) {
3291         self->undecorated = undecorated;
3292         client_setup_decor_and_functions(self);
3293         /* Make sure the client knows it might have moved. Maybe there is a
3294          * better way of doing this so only one client_configure is sent, but
3295          * since 125 of these are sent per second when moving the window (with
3296          * user = FALSE) i doubt it matters much.
3297          */
3298         client_configure(self, self->area.x, self->area.y,
3299                          self->area.width, self->area.height, TRUE, TRUE);
3300         client_change_state(self); /* reflect this in the state hints */
3301     }
3302 }
3303
3304 guint client_monitor(ObClient *self)
3305 {
3306     return screen_find_monitor(&self->frame->area);
3307 }
3308
3309 ObClient *client_search_top_parent(ObClient *self)
3310 {
3311     while (self->transient_for && self->transient_for != OB_TRAN_GROUP &&
3312            client_normal(self))
3313         self = self->transient_for;
3314     return self;
3315 }
3316
3317 GSList *client_search_all_top_parents(ObClient *self)
3318 {
3319     GSList *ret = NULL;
3320
3321     /* move up the direct transient chain as far as possible */
3322     while (self->transient_for && self->transient_for != OB_TRAN_GROUP)
3323         self = self->transient_for;
3324
3325     if (!self->transient_for)
3326         ret = g_slist_prepend(ret, self);
3327     else {
3328             GSList *it;
3329
3330             g_assert(self->group);
3331
3332             for (it = self->group->members; it; it = g_slist_next(it)) {
3333                 ObClient *c = it->data;
3334
3335                 if (!c->transient_for && client_normal(c))
3336                     ret = g_slist_prepend(ret, c);
3337             }
3338
3339             if (ret == NULL) /* no group parents */
3340                 ret = g_slist_prepend(ret, self);
3341     }
3342
3343     return ret;
3344 }
3345
3346 ObClient *client_search_focus_parent(ObClient *self)
3347 {
3348     if (self->transient_for) {
3349         if (self->transient_for != OB_TRAN_GROUP) {
3350             if (client_focused(self->transient_for))
3351                 return self->transient_for;
3352         } else {
3353             GSList *it;
3354
3355             for (it = self->group->members; it; it = g_slist_next(it)) {
3356                 ObClient *c = it->data;
3357
3358                 /* checking transient_for prevents infinate loops! */
3359                 if (c != self && !c->transient_for)
3360                     if (client_focused(c))
3361                         return c;
3362             }
3363         }
3364     }
3365
3366     return NULL;
3367 }
3368
3369 ObClient *client_search_parent(ObClient *self, ObClient *search)
3370 {
3371     if (self->transient_for) {
3372         if (self->transient_for != OB_TRAN_GROUP) {
3373             if (self->transient_for == search)
3374                 return search;
3375         } else {
3376             GSList *it;
3377
3378             for (it = self->group->members; it; it = g_slist_next(it)) {
3379                 ObClient *c = it->data;
3380
3381                 /* checking transient_for prevents infinate loops! */
3382                 if (c != self && !c->transient_for)
3383                     if (c == search)
3384                         return search;
3385             }
3386         }
3387     }
3388
3389     return NULL;
3390 }
3391
3392 ObClient *client_search_transient(ObClient *self, ObClient *search)
3393 {
3394     GSList *sit;
3395
3396     for (sit = self->transients; sit; sit = g_slist_next(sit)) {
3397         if (sit->data == search)
3398             return search;
3399         if (client_search_transient(sit->data, search))
3400             return search;
3401     }
3402     return NULL;
3403 }
3404
3405 void client_update_sm_client_id(ObClient *self)
3406 {
3407     g_free(self->sm_client_id);
3408     self->sm_client_id = NULL;
3409
3410     if (!PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id) &&
3411         self->group)
3412         PROP_GETS(self->group->leader, sm_client_id, locale,
3413                   &self->sm_client_id);
3414 }
3415
3416 #define WANT_EDGE(cur, c) \
3417             if(cur == c)                                                      \
3418                 continue;                                                     \
3419             if(!client_normal(cur))                                   \
3420                 continue;                                                     \
3421             if(screen_desktop != cur->desktop && cur->desktop != DESKTOP_ALL) \
3422                 continue;                                                     \
3423             if(cur->iconic)                                                   \
3424                 continue;                                                     \
3425             if(cur->layer < c->layer && !config_resist_layers_below)          \
3426                 continue;
3427
3428 #define HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end) \
3429             if ((his_edge_start >= my_edge_start && \
3430                  his_edge_start <= my_edge_end) ||  \
3431                 (my_edge_start >= his_edge_start && \
3432                  my_edge_start <= his_edge_end))    \
3433                 dest = his_offset;
3434
3435 /* finds the nearest edge in the given direction from the current client
3436  * note to self: the edge is the -frame- edge (the actual one), not the
3437  * client edge.
3438  */
3439 gint client_directional_edge_search(ObClient *c, ObDirection dir, gboolean hang)
3440 {
3441     gint dest, monitor_dest;
3442     gint my_edge_start, my_edge_end, my_offset;
3443     GList *it;
3444     Rect *a, *monitor;
3445
3446     if(!client_list)
3447         return -1;
3448
3449     a = screen_area(c->desktop);
3450     monitor = screen_area_monitor(c->desktop, client_monitor(c));
3451
3452     switch(dir) {
3453     case OB_DIRECTION_NORTH:
3454         my_edge_start = c->frame->area.x;
3455         my_edge_end = c->frame->area.x + c->frame->area.width;
3456         my_offset = c->frame->area.y + (hang ? c->frame->area.height : 0);
3457
3458         /* default: top of screen */
3459         dest = a->y + (hang ? c->frame->area.height : 0);
3460         monitor_dest = monitor->y + (hang ? c->frame->area.height : 0);
3461         /* if the monitor edge comes before the screen edge, */
3462         /* use that as the destination instead. (For xinerama) */
3463         if (monitor_dest != dest && my_offset > monitor_dest)
3464             dest = monitor_dest;
3465
3466         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3467             gint his_edge_start, his_edge_end, his_offset;
3468             ObClient *cur = it->data;
3469
3470             WANT_EDGE(cur, c)
3471
3472             his_edge_start = cur->frame->area.x;
3473             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3474             his_offset = cur->frame->area.y +
3475                          (hang ? 0 : cur->frame->area.height);
3476
3477             if(his_offset + 1 > my_offset)
3478                 continue;
3479
3480             if(his_offset < dest)
3481                 continue;
3482
3483             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3484         }
3485         break;
3486     case OB_DIRECTION_SOUTH:
3487         my_edge_start = c->frame->area.x;
3488         my_edge_end = c->frame->area.x + c->frame->area.width;
3489         my_offset = c->frame->area.y + (hang ? 0 : c->frame->area.height);
3490
3491         /* default: bottom of screen */
3492         dest = a->y + a->height - (hang ? c->frame->area.height : 0);
3493         monitor_dest = monitor->y + monitor->height -
3494                        (hang ? c->frame->area.height : 0);
3495         /* if the monitor edge comes before the screen edge, */
3496         /* use that as the destination instead. (For xinerama) */
3497         if (monitor_dest != dest && my_offset < monitor_dest)
3498             dest = monitor_dest;
3499
3500         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3501             gint his_edge_start, his_edge_end, his_offset;
3502             ObClient *cur = it->data;
3503
3504             WANT_EDGE(cur, c)
3505
3506             his_edge_start = cur->frame->area.x;
3507             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3508             his_offset = cur->frame->area.y +
3509                          (hang ? cur->frame->area.height : 0);
3510
3511
3512             if(his_offset - 1 < my_offset)
3513                 continue;
3514
3515             if(his_offset > dest)
3516                 continue;
3517
3518             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3519         }
3520         break;
3521     case OB_DIRECTION_WEST:
3522         my_edge_start = c->frame->area.y;
3523         my_edge_end = c->frame->area.y + c->frame->area.height;
3524         my_offset = c->frame->area.x + (hang ? c->frame->area.width : 0);
3525
3526         /* default: leftmost egde of screen */
3527         dest = a->x + (hang ? c->frame->area.width : 0);
3528         monitor_dest = monitor->x + (hang ? c->frame->area.width : 0);
3529         /* if the monitor edge comes before the screen edge, */
3530         /* use that as the destination instead. (For xinerama) */
3531         if (monitor_dest != dest && my_offset > monitor_dest)
3532             dest = monitor_dest;
3533
3534         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3535             gint his_edge_start, his_edge_end, his_offset;
3536             ObClient *cur = it->data;
3537
3538             WANT_EDGE(cur, c)
3539
3540             his_edge_start = cur->frame->area.y;
3541             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3542             his_offset = cur->frame->area.x +
3543                          (hang ? 0 : cur->frame->area.width);
3544
3545             if(his_offset + 1 > my_offset)
3546                 continue;
3547
3548             if(his_offset < dest)
3549                 continue;
3550
3551             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3552         }
3553        break;
3554     case OB_DIRECTION_EAST:
3555         my_edge_start = c->frame->area.y;
3556         my_edge_end = c->frame->area.y + c->frame->area.height;
3557         my_offset = c->frame->area.x + (hang ? 0 : c->frame->area.width);
3558
3559         /* default: rightmost edge of screen */
3560         dest = a->x + a->width - (hang ? c->frame->area.width : 0);
3561         monitor_dest = monitor->x + monitor->width -
3562                        (hang ? c->frame->area.width : 0);
3563         /* if the monitor edge comes before the screen edge, */
3564         /* use that as the destination instead. (For xinerama) */
3565         if (monitor_dest != dest && my_offset < monitor_dest)
3566             dest = monitor_dest;
3567
3568         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3569             gint his_edge_start, his_edge_end, his_offset;
3570             ObClient *cur = it->data;
3571
3572             WANT_EDGE(cur, c)
3573
3574             his_edge_start = cur->frame->area.y;
3575             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3576             his_offset = cur->frame->area.x +
3577                          (hang ? cur->frame->area.width : 0);
3578
3579             if(his_offset - 1 < my_offset)
3580                 continue;
3581
3582             if(his_offset > dest)
3583                 continue;
3584
3585             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3586         }
3587         break;
3588     case OB_DIRECTION_NORTHEAST:
3589     case OB_DIRECTION_SOUTHEAST:
3590     case OB_DIRECTION_NORTHWEST:
3591     case OB_DIRECTION_SOUTHWEST:
3592         /* not implemented */
3593     default:
3594         g_assert_not_reached();
3595         dest = 0; /* suppress warning */
3596     }
3597     return dest;
3598 }
3599
3600 ObClient* client_under_pointer()
3601 {
3602     gint x, y;
3603     GList *it;
3604     ObClient *ret = NULL;
3605
3606     if (screen_pointer_pos(&x, &y)) {
3607         for (it = stacking_list; it; it = g_list_next(it)) {
3608             if (WINDOW_IS_CLIENT(it->data)) {
3609                 ObClient *c = WINDOW_AS_CLIENT(it->data);
3610                 if (c->frame->visible &&
3611                     RECT_CONTAINS(c->frame->area, x, y)) {
3612                     ret = c;
3613                     break;
3614                 }
3615             }
3616         }
3617     }
3618     return ret;
3619 }
3620
3621 gboolean client_has_group_siblings(ObClient *self)
3622 {
3623     return self->group && self->group->members->next;
3624 }
3625
3626 gboolean client_has_application_group_siblings(ObClient *self)
3627 {
3628     GSList *it;
3629
3630     if (!self->group) return FALSE;
3631
3632     for (it = self->group->members; it; it = g_slist_next(it)) {
3633         ObClient *c = it->data;
3634         if (c != self && client_application(c))
3635             return TRUE;
3636     }
3637     return FALSE;
3638 }