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