openbox/client.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    client.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "client.h"
  21 #include "debug.h"
  22 #include "startupnotify.h"
  23 #include "dock.h"
  24 #include "xerror.h"
  25 #include "screen.h"
  26 #include "moveresize.h"
  27 #include "ping.h"
  28 #include "place.h"
  29 #include "prop.h"
  30 #include "extensions.h"
  31 #include "frame.h"
  32 #include "session.h"
  33 #include "event.h"
  34 #include "grab.h"
  35 #include "focus.h"
  36 #include "stacking.h"
  37 #include "openbox.h"
  38 #include "group.h"
  39 #include "config.h"
  40 #include "menuframe.h"
  41 #include "keyboard.h"
  42 #include "mouse.h"
  43 #include "render/render.h"
  44 #include "gettext.h"
  45
  46 #ifdef HAVE_UNISTD_H
  47 #  include <unistd.h>
  48 #endif
  49
  50 #ifdef HAVE_SIGNAL_H
  51 #  include <signal.h> /* for kill() */
  52 #endif
  53
  54 #include <glib.h>
  55 #include <X11/Xutil.h>
  56
  57 /*! The event mask to grab on client windows */
  58 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
  59                           ColormapChangeMask)
  60
  61 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
  62                                 ButtonMotionMask)
  63
  64 typedef struct
  65 {
  66     ObClientCallback func;
  67     gpointer data;
  68 } ClientCallback;
  69
  70 GList            *client_list          = NULL;
  71
  72 static GSList *client_destroy_notifies = NULL;
  73
  74 static void client_get_all(ObClient *self, gboolean real);
  75 static void client_get_startup_id(ObClient *self);
  76 static void client_get_session_ids(ObClient *self);
  77 static void client_get_area(ObClient *self);
  78 static void client_get_desktop(ObClient *self);
  79 static void client_get_state(ObClient *self);
  80 static void client_get_shaped(ObClient *self);
  81 static void client_get_mwm_hints(ObClient *self);
  82 static void client_get_colormap(ObClient *self);
  83 static void client_set_desktop_recursive(ObClient *self,
  84                                          guint target,
  85                                          gboolean donthide,
  86                                          gboolean dontraise);
  87 static void client_change_allowed_actions(ObClient *self);
  88 static void client_change_state(ObClient *self);
  89 static void client_change_wm_state(ObClient *self);
  90 static void client_apply_startup_state(ObClient *self,
  91                                        gint x, gint y, gint w, gint h);
  92 static void client_restore_session_state(ObClient *self);
  93 static gboolean client_restore_session_stacking(ObClient *self);
  94 static ObAppSettings *client_get_settings_state(ObClient *self);
  95 static void client_update_transient_tree(ObClient *self,
  96                                          ObGroup *oldgroup, ObGroup *newgroup,
  97                                          gboolean oldgtran, gboolean newgtran,
  98                                          ObClient* oldparent,
  99                                          ObClient *newparent);
 100 static void client_present(ObClient *self, gboolean here, gboolean raise,
 101                            gboolean unshade);
 102 static GSList *client_search_all_top_parents_internal(ObClient *self,
 103                                                       gboolean bylayer,
 104                                                       ObStackingLayer layer);
 105 static void client_call_notifies(ObClient *self, GSList *list);
 106 static void client_ping_event(ObClient *self, gboolean dead);
 107
 108
 109 void client_startup(gboolean reconfig)
 110 {
 111     if (reconfig) return;
 112
 113     client_set_list();
 114 }
 115
 116 void client_shutdown(gboolean reconfig)
 117 {
 118     if (reconfig) return;
 119 }
 120
 121 static void client_call_notifies(ObClient *self, GSList *list)
 122 {
 123     GSList *it;
 124
 125     for (it = list; it; it = g_slist_next(it)) {
 126         ClientCallback *d = it->data;
 127         d->func(self, d->data);
 128     }
 129 }
 130
 131 void client_add_destroy_notify(ObClientCallback func, gpointer data)
 132 {
 133     ClientCallback *d = g_new(ClientCallback, 1);
 134     d->func = func;
 135     d->data = data;
 136     client_destroy_notifies = g_slist_prepend(client_destroy_notifies, d);
 137 }
 138
 139 void client_remove_destroy_notify(ObClientCallback func)
 140 {
 141     GSList *it;
 142
 143     for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
 144         ClientCallback *d = it->data;
 145         if (d->func == func) {
 146             g_free(d);
 147             client_destroy_notifies =
 148                 g_slist_delete_link(client_destroy_notifies, it);
 149             break;
 150         }
 151     }
 152 }
 153
 154 void client_set_list(void)
 155 {
 156     Window *windows, *win_it;
 157     GList *it;
 158     guint size = g_list_length(client_list);
 159
 160     /* create an array of the window ids */
 161     if (size > 0) {
 162         windows = g_new(Window, size);
 163         win_it = windows;
 164         for (it = client_list; it; it = g_list_next(it), ++win_it)
 165             *win_it = ((ObClient*)it->data)->window;
 166     } else
 167         windows = NULL;
 168
 169     PROP_SETA32(RootWindow(ob_display, ob_screen),
 170                 net_client_list, window, (gulong*)windows, size);
 171
 172     if (windows)
 173         g_free(windows);
 174
 175     stacking_set_list();
 176 }
 177
 178 void client_manage_all(void)
 179 {
 180     guint i, j, nchild;
 181     Window w, *children;
 182     XWMHints *wmhints;
 183     XWindowAttributes attrib;
 184
 185     XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
 186                &w, &w, &children, &nchild);
 187
 188     /* remove all icon windows from the list */
 189     for (i = 0; i < nchild; i++) {
 190         if (children[i] == None) continue;
 191         wmhints = XGetWMHints(ob_display, children[i]);
 192         if (wmhints) {
 193             if ((wmhints->flags & IconWindowHint) &&
 194                 (wmhints->icon_window != children[i]))
 195                 for (j = 0; j < nchild; j++)
 196                     if (children[j] == wmhints->icon_window) {
 197                         children[j] = None;
 198                         break;
 199                     }
 200             XFree(wmhints);
 201         }
 202     }
 203
 204     /* manage windows in reverse order from how they were originally mapped.
 205        this is an attempt to manage children windows before their parents, so
 206        that when the parent is mapped, it can find the child */
 207     for (i = 0; i < nchild; ++i) {
 208         if (children[i] == None)
 209             continue;
 210         if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
 211             if (attrib.override_redirect) continue;
 212
 213             if (attrib.map_state != IsUnmapped)
 214                 client_manage(children[i]);
 215         }
 216     }
 217     XFree(children);
 218 }
 219
 220 void client_manage(Window window)
 221 {
 222     ObClient *self;
 223     XEvent e;
 224     XWindowAttributes attrib;
 225     XSetWindowAttributes attrib_set;
 226     XWMHints *wmhint;
 227     gboolean activate = FALSE;
 228     ObAppSettings *settings;
 229     gboolean transient = FALSE;
 230     Rect place, *monitor;
 231     Time launch_time, map_time;
 232
 233     grab_server(TRUE);
 234
 235     /* check if it has already been unmapped by the time we started
 236        mapping. the grab does a sync so we don't have to here */
 237     if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
 238         XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e))
 239     {
 240         XPutBackEvent(ob_display, &e);
 241
 242         ob_debug("Trying to manage unmapped window. Aborting that.\n");
 243         grab_server(FALSE);
 244         return; /* don't manage it */
 245     }
 246
 247     /* make sure it isn't an override-redirect window */
 248     if (!XGetWindowAttributes(ob_display, window, &attrib) ||
 249         attrib.override_redirect)
 250     {
 251         grab_server(FALSE);
 252         return; /* don't manage it */
 253     }
 254
 255     /* is the window a docking app */
 256     if ((wmhint = XGetWMHints(ob_display, window))) {
 257         if ((wmhint->flags & StateHint) &&
 258             wmhint->initial_state == WithdrawnState)
 259         {
 260             dock_add(window, wmhint);
 261             grab_server(FALSE);
 262             XFree(wmhint);
 263             return;
 264         }
 265         XFree(wmhint);
 266     }
 267
 268     ob_debug("Managing window: 0x%lx\n", window);
 269
 270     map_time = event_get_server_time();
 271
 272     /* choose the events we want to receive on the CLIENT window */
 273     attrib_set.event_mask = CLIENT_EVENTMASK;
 274     attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
 275     XChangeWindowAttributes(ob_display, window,
 276                             CWEventMask|CWDontPropagate, &attrib_set);
 277
 278     /* create the ObClient struct, and populate it from the hints on the
 279        window */
 280     self = g_new0(ObClient, 1);
 281     self->obwin.type = Window_Client;
 282     self->window = window;
 283
 284     /* non-zero defaults */
 285     self->wmstate = WithdrawnState; /* make sure it gets updated first time */
 286     self->gravity = NorthWestGravity;
 287     self->desktop = screen_num_desktops; /* always an invalid value */
 288
 289     /* get all the stuff off the window */
 290     client_get_all(self, TRUE);
 291
 292     ob_debug("Window type: %d\n", self->type);
 293     ob_debug("Window group: 0x%x\n", self->group?self->group->leader:0);
 294
 295     /* now we have all of the window's information so we can set this up.
 296        do this before creating the frame, so it can tell that we are still
 297        mapping and doesn't go applying things right away */
 298     client_setup_decor_and_functions(self, FALSE);
 299
 300     /* specify that if we exit, the window should not be destroyed and
 301        should be reparented back to root automatically */
 302     XChangeSaveSet(ob_display, window, SetModeInsert);
 303
 304     /* create the decoration frame for the client window */
 305     self->frame = frame_new(self);
 306
 307     frame_grab_client(self->frame);
 308
 309     /* we've grabbed everything and set everything that we need to at mapping
 310        time now */
 311     grab_server(FALSE);
 312
 313     /* per-app settings override stuff from client_get_all, and return the
 314        settings for other uses too. the returned settings is a shallow copy,
 315        that needs to be freed with g_free(). */
 316     settings = client_get_settings_state(self);
 317     /* the session should get the last say though */
 318     client_restore_session_state(self);
 319
 320     /* tell startup notification that this app started */
 321     launch_time = sn_app_started(self->startup_id, self->class, self->name);
 322
 323     /* do this after we have a frame.. it uses the frame to help determine the
 324        WM_STATE to apply. */
 325     client_change_state(self);
 326
 327     /* add ourselves to the focus order */
 328     focus_order_add_new(self);
 329
 330     /* do this to add ourselves to the stacking list in a non-intrusive way */
 331     client_calc_layer(self);
 332
 333     /* focus the new window? */
 334     if (ob_state() != OB_STATE_STARTING &&
 335         (!self->session || self->session->focused) &&
 336         /* this means focus=true for window is same as config_focus_new=true */
 337         ((config_focus_new || (settings && settings->focus == 1)) ||
 338          client_search_focus_tree_full(self)) &&
 339         /* this checks for focus=false for the window */
 340         (!settings || settings->focus != 0) &&
 341         focus_valid_target(self, FALSE, FALSE, TRUE, FALSE, FALSE))
 342     {
 343         activate = TRUE;
 344     }
 345
 346     /* remove the client's border */
 347     XSetWindowBorderWidth(ob_display, self->window, 0);
 348
 349     /* adjust the frame to the client's size before showing or placing
 350        the window */
 351     frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
 352     frame_adjust_client_area(self->frame);
 353
 354     /* where the frame was placed is where the window was originally */
 355     place = self->area;
 356     monitor = screen_physical_area_monitor(screen_find_monitor(&place));
 357
 358     /* figure out placement for the window if the window is new */
 359     if (ob_state() == OB_STATE_RUNNING) {
 360         ob_debug("Positioned: %s @ %d %d\n",
 361                  (!self->positioned ? "no" :
 362                   (self->positioned == PPosition ? "program specified" :
 363                    (self->positioned == USPosition ? "user specified" :
 364                     (self->positioned == (PPosition | USPosition) ?
 365                      "program + user specified" :
 366                      "BADNESS !?")))), place.x, place.y);
 367
 368         ob_debug("Sized: %s @ %d %d\n",
 369                  (!self->sized ? "no" :
 370                   (self->sized == PSize ? "program specified" :
 371                    (self->sized == USSize ? "user specified" :
 372                     (self->sized == (PSize | USSize) ?
 373                      "program + user specified" :
 374                      "BADNESS !?")))), place.width, place.height);
 375
 376         /* splash screens are also returned as TRUE for transient,
 377            and so will be forced on screen below */
 378         transient = place_client(self, &place.x, &place.y, settings);
 379
 380         /* make sure the window is visible. */
 381         client_find_onscreen(self, &place.x, &place.y,
 382                              place.width, place.height,
 383                              /* non-normal clients has less rules, and
 384                                 windows that are being restored from a
 385                                 session do also. we can assume you want
 386                                 it back where you saved it. Clients saying
 387                                 they placed themselves are subjected to
 388                                 harder rules, ones that are placed by
 389                                 place.c or by the user are allowed partially
 390                                 off-screen and on xinerama divides (ie,
 391                                 it is up to the placement routines to avoid
 392                                 the xinerama divides)
 393
 394                                 splash screens get "transient" set to TRUE by
 395                                 the place_client call
 396                              */
 397                              ob_state() == OB_STATE_RUNNING &&
 398                              (transient ||
 399                               (!((self->positioned & USPosition) ||
 400                                  (settings && settings->pos_given)) &&
 401                                client_normal(self) &&
 402                                !self->session &&
 403                                /* don't move oldschool fullscreen windows to
 404                                   fit inside the struts (fixes Acroread, which
 405                                   makes its fullscreen window fit the screen
 406                                   but it is not USSize'd or USPosition'd) */
 407                                !(self->decorations == 0 &&
 408                                  RECT_EQUAL(place, *monitor)))));
 409     }
 410
 411     /* if the window isn't user-sized, then make it fit inside
 412        the visible screen area on its monitor. Use basically the same rules
 413        for forcing the window on screen in the client_find_onscreen call.
 414
 415        do this after place_client, it chooses the monitor!
 416
 417        splash screens get "transient" set to TRUE by
 418        the place_client call
 419     */
 420     if (ob_state() == OB_STATE_RUNNING &&
 421         (transient ||
 422          (!(self->sized & USSize || self->positioned & USPosition) &&
 423           client_normal(self) &&
 424           !self->session &&
 425           /* don't shrink oldschool fullscreen windows to fit inside the
 426              struts (fixes Acroread, which makes its fullscreen window
 427              fit the screen but it is not USSize'd or USPosition'd) */
 428           !(self->decorations == 0 && RECT_EQUAL(place, *monitor)))))
 429     {
 430         Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &place);
 431
 432         /* get the size of the frame */
 433         place.width += self->frame->size.left + self->frame->size.right;
 434         place.height += self->frame->size.top + self->frame->size.bottom;
 435
 436         /* fit the window inside the area */
 437         place.width = MIN(place.width, a->width);
 438         place.height = MIN(place.height, a->height);
 439
 440         ob_debug("setting window size to %dx%d\n", place.width, place.height);
 441
 442         /* get the size of the client back */
 443         place.width -= self->frame->size.left + self->frame->size.right;
 444         place.height -= self->frame->size.top + self->frame->size.bottom;
 445
 446         g_free(a);
 447     }
 448
 449     ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
 450              "some restrictions may apply\n",
 451              self->window, place.x, place.y, place.width, place.height);
 452     if (self->session)
 453         ob_debug("  but session requested %d, %d  %d x %d instead, "
 454                  "overriding\n",
 455                  self->session->x, self->session->y,
 456                  self->session->w, self->session->h);
 457
 458     /* do this after the window is placed, so the premax/prefullscreen numbers
 459        won't be all wacko!!
 460
 461        this also places the window
 462     */
 463     client_apply_startup_state(self, place.x, place.y,
 464                                place.width, place.height);
 465
 466     g_free(monitor);
 467     monitor = NULL;
 468
 469     ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s\n",
 470                   activate ? "yes" : "no");
 471     if (activate) {
 472         gboolean raise = FALSE;
 473
 474         /* This is focus stealing prevention */
 475         ob_debug_type(OB_DEBUG_FOCUS,
 476                       "Want to focus new window 0x%x at time %u "
 477                       "launched at %u (last user interaction time %u)\n",
 478                       self->window, map_time, launch_time,
 479                       event_last_user_time);
 480
 481         if (menu_frame_visible || moveresize_in_progress) {
 482             activate = FALSE;
 483             raise = TRUE;
 484             ob_debug_type(OB_DEBUG_FOCUS,
 485                           "Not focusing the window because the user is inside "
 486                           "an Openbox menu or is move/resizing a window and "
 487                           "we don't want to interrupt them\n");
 488         }
 489
 490         /* if it's on another desktop */
 491         else if (!(self->desktop == screen_desktop ||
 492                    self->desktop == DESKTOP_ALL) &&
 493                  /* the timestamp is from before you changed desktops */
 494                  launch_time && screen_desktop_user_time &&
 495                  !event_time_after(launch_time, screen_desktop_user_time))
 496         {
 497             activate = FALSE;
 498             raise = TRUE;
 499             ob_debug_type(OB_DEBUG_FOCUS,
 500                           "Not focusing the window because its on another "
 501                           "desktop\n");
 502         }
 503         /* If something is focused, and it's not our relative... */
 504         else if (focus_client && client_search_focus_tree_full(self) == NULL &&
 505                  client_search_focus_group_full(self) == NULL)
 506         {
 507             /* If the user is working in another window right now, then don't
 508                steal focus */
 509             if (event_last_user_time && launch_time &&
 510                 event_time_after(event_last_user_time, launch_time) &&
 511                 event_last_user_time != launch_time &&
 512                 event_time_after(event_last_user_time,
 513                                  map_time - OB_EVENT_USER_TIME_DELAY))
 514             {
 515                 activate = FALSE;
 516                 ob_debug_type(OB_DEBUG_FOCUS,
 517                               "Not focusing the window because the user is "
 518                               "working in another window\n");
 519             }
 520             /* If its a transient (and its parents aren't focused) */
 521             else if (client_has_parent(self)) {
 522                 activate = FALSE;
 523                 ob_debug_type(OB_DEBUG_FOCUS,
 524                               "Not focusing the window because it is a "
 525                               "transient, and its relatives aren't focused\n");
 526             }
 527             /* Don't steal focus from globally active clients.
 528                I stole this idea from KWin. It seems nice.
 529              */
 530             else if (!(focus_client->can_focus ||
 531                        focus_client->focus_notify))
 532             {
 533                 activate = FALSE;
 534                 ob_debug_type(OB_DEBUG_FOCUS,
 535                               "Not focusing the window because a globally "
 536                               "active client has focus\n");
 537             }
 538             /* Don't move focus if it's not going to go to this window
 539                anyway */
 540             else if (client_focus_target(self) != self) {
 541                 activate = FALSE;
 542                 raise = TRUE;
 543                 ob_debug_type(OB_DEBUG_FOCUS,
 544                               "Not focusing the window because another window "
 545                               "would get the focus anyway\n");
 546             }
 547             else if (!(self->desktop == screen_desktop ||
 548                        self->desktop == DESKTOP_ALL))
 549             {
 550                 activate = FALSE;
 551                 raise = TRUE;
 552                 ob_debug_type(OB_DEBUG_FOCUS,
 553                               "Not focusing the window because it is on "
 554                               "another desktop and no relatives are focused ");
 555             }
 556         }
 557
 558         if (!activate) {
 559             ob_debug_type(OB_DEBUG_FOCUS,
 560                           "Focus stealing prevention activated for %s at "
 561                           "time %u (last user interactioon time %u)\n",
 562                           self->title, map_time, event_last_user_time);
 563             /* if the client isn't focused, then hilite it so the user
 564                knows it is there */
 565             client_hilite(self, TRUE);
 566             /* we may want to raise it even tho we're not activating it */
 567             if (raise && !client_restore_session_stacking(self))
 568                 stacking_raise(CLIENT_AS_WINDOW(self));
 569         }
 570     }
 571     else {
 572         /* This may look rather odd. Well it's because new windows are added
 573            to the stacking order non-intrusively. If we're not going to focus
 574            the new window or hilite it, then we raise it to the top. This will
 575            take affect for things that don't get focused like splash screens.
 576            Also if you don't have focus_new enabled, then it's going to get
 577            raised to the top. Legacy begets legacy I guess?
 578         */
 579         if (!client_restore_session_stacking(self))
 580             stacking_raise(CLIENT_AS_WINDOW(self));
 581     }
 582
 583     mouse_grab_for_client(self, TRUE);
 584
 585     /* this has to happen before we try focus the window, but we want it to
 586        happen after the client's stacking has been determined or it looks bad
 587     */
 588     {
 589         gulong ignore_start;
 590         if (!config_focus_under_mouse)
 591             ignore_start = event_start_ignore_all_enters();
 592
 593         client_show(self);
 594
 595         if (!config_focus_under_mouse)
 596             event_end_ignore_all_enters(ignore_start);
 597     }
 598
 599     if (activate) {
 600         gboolean stacked = client_restore_session_stacking(self);
 601         client_present(self, FALSE, !stacked, TRUE);
 602     }
 603
 604     /* add to client list/map */
 605     client_list = g_list_append(client_list, self);
 606     g_hash_table_insert(window_map, &self->window, self);
 607
 608     /* this has to happen after we're in the client_list */
 609     if (STRUT_EXISTS(self->strut))
 610         screen_update_areas();
 611
 612     /* update the list hints */
 613     client_set_list();
 614
 615     /* watch for when the application stops responding.  only do this for
 616        normal windows, i.e. windows which have titlebars and close buttons
 617        and things like that.
 618        we don't need to stop pinging on unmanage, because it will be handled
 619        automatically by the destroy callback!
 620     */
 621     if (self->ping && client_normal(self))
 622         ping_start(self, client_ping_event);
 623
 624     /* free the ObAppSettings shallow copy */
 625     g_free(settings);
 626
 627     ob_debug("Managed window 0x%lx plate 0x%x (%s)\n",
 628              window, self->frame->window, self->class);
 629
 630     return;
 631 }
 632
 633
 634 ObClient *client_fake_manage(Window window)
 635 {
 636     ObClient *self;
 637     ObAppSettings *settings;
 638
 639     ob_debug("Pretend-managing window: %lx\n", window);
 640
 641     /* do this minimal stuff to figure out the client's decorations */
 642
 643     self = g_new0(ObClient, 1);
 644     self->window = window;
 645
 646     client_get_all(self, FALSE);
 647     /* per-app settings override stuff, and return the settings for other
 648        uses too. this returns a shallow copy that needs to be freed */
 649     settings = client_get_settings_state(self);
 650
 651     client_setup_decor_and_functions(self, FALSE);
 652
 653     /* create the decoration frame for the client window and adjust its size */
 654     self->frame = frame_new(self);
 655     frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
 656
 657     ob_debug("gave extents left %d right %d top %d bottom %d\n",
 658              self->frame->size.left, self->frame->size.right,
 659              self->frame->size.top, self->frame->size.bottom);
 660
 661     /* free the ObAppSettings shallow copy */
 662     g_free(settings);
 663
 664     return self;
 665 }
 666
 667 void client_unmanage_all(void)
 668 {
 669     while (client_list != NULL)
 670         client_unmanage(client_list->data);
 671 }
 672
 673 void client_unmanage(ObClient *self)
 674 {
 675     guint j;
 676     GSList *it;
 677     gulong ignore_start;
 678
 679     ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n",
 680              self->window, self->frame->window,
 681              self->class, self->title ? self->title : "");
 682
 683     g_assert(self != NULL);
 684
 685     /* we dont want events no more. do this before hiding the frame so we
 686        don't generate more events */
 687     XSelectInput(ob_display, self->window, NoEventMask);
 688
 689     /* ignore enter events from the unmap so it doesnt mess with the focus */
 690     if (!config_focus_under_mouse)
 691         ignore_start = event_start_ignore_all_enters();
 692
 693     frame_hide(self->frame);
 694     /* flush to send the hide to the server quickly */
 695     XFlush(ob_display);
 696
 697     if (!config_focus_under_mouse)
 698         event_end_ignore_all_enters(ignore_start);
 699
 700     mouse_grab_for_client(self, FALSE);
 701
 702     /* remove the window from our save set */
 703     XChangeSaveSet(ob_display, self->window, SetModeDelete);
 704
 705     /* update the focus lists */
 706     focus_order_remove(self);
 707     if (client_focused(self)) {
 708         /* don't leave an invalid focus_client */
 709         focus_client = NULL;
 710     }
 711
 712     client_list = g_list_remove(client_list, self);
 713     stacking_remove(self);
 714     g_hash_table_remove(window_map, &self->window);
 715
 716     /* once the client is out of the list, update the struts to remove its
 717        influence */
 718     if (STRUT_EXISTS(self->strut))
 719         screen_update_areas();
 720
 721     client_call_notifies(self, client_destroy_notifies);
 722
 723     /* tell our parent(s) that we're gone */
 724     for (it = self->parents; it; it = g_slist_next(it))
 725         ((ObClient*)it->data)->transients =
 726             g_slist_remove(((ObClient*)it->data)->transients,self);
 727
 728     /* tell our transients that we're gone */
 729     for (it = self->transients; it; it = g_slist_next(it)) {
 730         ((ObClient*)it->data)->parents =
 731             g_slist_remove(((ObClient*)it->data)->parents, self);
 732         /* we could be keeping our children in a higher layer */
 733         client_calc_layer(it->data);
 734     }
 735
 736     /* remove from its group */
 737     if (self->group) {
 738         group_remove(self->group, self);
 739         self->group = NULL;
 740     }
 741
 742     /* restore the window's original geometry so it is not lost */
 743     {
 744         Rect a;
 745
 746         a = self->area;
 747
 748         if (self->fullscreen)
 749             a = self->pre_fullscreen_area;
 750         else if (self->max_horz || self->max_vert) {
 751             if (self->max_horz) {
 752                 a.x = self->pre_max_area.x;
 753                 a.width = self->pre_max_area.width;
 754             }
 755             if (self->max_vert) {
 756                 a.y = self->pre_max_area.y;
 757                 a.height = self->pre_max_area.height;
 758             }
 759         }
 760
 761         self->fullscreen = self->max_horz = self->max_vert = FALSE;
 762         /* let it be moved and resized no matter what */
 763         self->functions = OB_CLIENT_FUNC_MOVE | OB_CLIENT_FUNC_RESIZE;
 764         self->decorations = 0; /* unmanaged windows have no decor */
 765
 766         /* give the client its border back */
 767         XSetWindowBorderWidth(ob_display, self->window, self->border_width);
 768
 769         client_move_resize(self, a.x, a.y, a.width, a.height);
 770     }
 771
 772     /* reparent the window out of the frame, and free the frame */
 773     frame_release_client(self->frame);
 774     frame_free(self->frame);
 775     self->frame = NULL;
 776
 777     if (ob_state() != OB_STATE_EXITING) {
 778         /* these values should not be persisted across a window
 779            unmapping/mapping */
 780         PROP_ERASE(self->window, net_wm_desktop);
 781         PROP_ERASE(self->window, net_wm_state);
 782         PROP_ERASE(self->window, wm_state);
 783     } else {
 784         /* if we're left in an unmapped state, the client wont be mapped.
 785            this is bad, since we will no longer be managing the window on
 786            restart */
 787         XMapWindow(ob_display, self->window);
 788     }
 789
 790     /* these should not be left on the window ever.  other window managers
 791        don't necessarily use them and it will mess them up (like compiz) */
 792     PROP_ERASE(self->window, net_wm_visible_name);
 793     PROP_ERASE(self->window, net_wm_visible_icon_name);
 794
 795     /* update the list hints */
 796     client_set_list();
 797
 798     ob_debug("Unmanaged window 0x%lx\n", self->window);
 799
 800     /* free all data allocated in the client struct */
 801     g_slist_free(self->transients);
 802     for (j = 0; j < self->nicons; ++j)
 803         g_free(self->icons[j].data);
 804     if (self->nicons > 0)
 805         g_free(self->icons);
 806     g_free(self->startup_id);
 807     g_free(self->wm_command);
 808     g_free(self->title);
 809     g_free(self->icon_title);
 810     g_free(self->name);
 811     g_free(self->class);
 812     g_free(self->role);
 813     g_free(self->client_machine);
 814     g_free(self->sm_client_id);
 815     g_free(self);
 816 }
 817
 818 void client_fake_unmanage(ObClient *self)
 819 {
 820     /* this is all that got allocated to get the decorations */
 821
 822     frame_free(self->frame);
 823     g_free(self);
 824 }
 825
 826 /*! Returns a new structure containing the per-app settings for this client.
 827   The returned structure needs to be freed with g_free. */
 828 static ObAppSettings *client_get_settings_state(ObClient *self)
 829 {
 830     ObAppSettings *settings;
 831     GSList *it;
 832
 833     settings = config_create_app_settings();
 834
 835     for (it = config_per_app_settings; it; it = g_slist_next(it)) {
 836         ObAppSettings *app = it->data;
 837         gboolean match = TRUE;
 838
 839         g_assert(app->name != NULL || app->class != NULL);
 840
 841         /* we know that either name or class is not NULL so it will have to
 842            match to use the rule */
 843         if (app->name &&
 844             !g_pattern_match(app->name, strlen(self->name), self->name, NULL))
 845             match = FALSE;
 846         else if (app->class &&
 847                 !g_pattern_match(app->class,
 848                                  strlen(self->class), self->class, NULL))
 849             match = FALSE;
 850         else if (app->role &&
 851                  !g_pattern_match(app->role,
 852                                   strlen(self->role), self->role, NULL))
 853             match = FALSE;
 854
 855         if (match) {
 856             ob_debug("Window matching: %s\n", app->name);
 857
 858             /* copy the settings to our struct, overriding the existing
 859                settings if they are not defaults */
 860             config_app_settings_copy_non_defaults(app, settings);
 861         }
 862     }
 863
 864     if (settings->shade != -1)
 865         self->shaded = !!settings->shade;
 866     if (settings->decor != -1)
 867         self->undecorated = !settings->decor;
 868     if (settings->iconic != -1)
 869         self->iconic = !!settings->iconic;
 870     if (settings->skip_pager != -1)
 871         self->skip_pager = !!settings->skip_pager;
 872     if (settings->skip_taskbar != -1)
 873         self->skip_taskbar = !!settings->skip_taskbar;
 874
 875     if (settings->max_vert != -1)
 876         self->max_vert = !!settings->max_vert;
 877     if (settings->max_horz != -1)
 878         self->max_horz = !!settings->max_horz;
 879
 880     if (settings->fullscreen != -1)
 881         self->fullscreen = !!settings->fullscreen;
 882
 883     if (settings->desktop) {
 884         if (settings->desktop == DESKTOP_ALL)
 885             self->desktop = settings->desktop;
 886         else if (settings->desktop > 0 &&
 887                  settings->desktop <= screen_num_desktops)
 888             self->desktop = settings->desktop - 1;
 889     }
 890
 891     if (settings->layer == -1) {
 892         self->below = TRUE;
 893         self->above = FALSE;
 894     }
 895     else if (settings->layer == 0) {
 896         self->below = FALSE;
 897         self->above = FALSE;
 898     }
 899     else if (settings->layer == 1) {
 900         self->below = FALSE;
 901         self->above = TRUE;
 902     }
 903     return settings;
 904 }
 905
 906 static void client_restore_session_state(ObClient *self)
 907 {
 908     GList *it;
 909
 910     ob_debug_type(OB_DEBUG_SM,
 911                   "Restore session for client %s\n", self->title);
 912
 913     if (!(it = session_state_find(self))) {
 914         ob_debug_type(OB_DEBUG_SM,
 915                       "Session data not found for client %s\n", self->title);
 916         return;
 917     }
 918
 919     self->session = it->data;
 920
 921     ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s\n",
 922                   self->title);
 923
 924     RECT_SET_POINT(self->area, self->session->x, self->session->y);
 925     self->positioned = USPosition;
 926     self->sized = USSize;
 927     if (self->session->w > 0)
 928         self->area.width = self->session->w;
 929     if (self->session->h > 0)
 930         self->area.height = self->session->h;
 931     XResizeWindow(ob_display, self->window,
 932                   self->area.width, self->area.height);
 933
 934     self->desktop = (self->session->desktop == DESKTOP_ALL ?
 935                      self->session->desktop :
 936                      MIN(screen_num_desktops - 1, self->session->desktop));
 937     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
 938
 939     self->shaded = self->session->shaded;
 940     self->iconic = self->session->iconic;
 941     self->skip_pager = self->session->skip_pager;
 942     self->skip_taskbar = self->session->skip_taskbar;
 943     self->fullscreen = self->session->fullscreen;
 944     self->above = self->session->above;
 945     self->below = self->session->below;
 946     self->max_horz = self->session->max_horz;
 947     self->max_vert = self->session->max_vert;
 948     self->undecorated = self->session->undecorated;
 949 }
 950
 951 static gboolean client_restore_session_stacking(ObClient *self)
 952 {
 953     GList *it, *mypos;
 954
 955     if (!self->session) return FALSE;
 956
 957     mypos = g_list_find(session_saved_state, self->session);
 958     if (!mypos) return FALSE;
 959
 960     /* start above me and look for the first client */
 961     for (it = g_list_previous(mypos); it; it = g_list_previous(it)) {
 962         GList *cit;
 963
 964         for (cit = client_list; cit; cit = g_list_next(cit)) {
 965             ObClient *c = cit->data;
 966             /* found a client that was in the session, so go below it */
 967             if (c->session == it->data) {
 968                 stacking_below(CLIENT_AS_WINDOW(self),
 969                                CLIENT_AS_WINDOW(cit->data));
 970                 return TRUE;
 971             }
 972         }
 973     }
 974     return FALSE;
 975 }
 976
 977 void client_move_onscreen(ObClient *self, gboolean rude)
 978 {
 979     gint x = self->area.x;
 980     gint y = self->area.y;
 981     if (client_find_onscreen(self, &x, &y,
 982                              self->area.width,
 983                              self->area.height, rude)) {
 984         client_move(self, x, y);
 985     }
 986 }
 987
 988 gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h,
 989                               gboolean rude)
 990 {
 991     gint ox = *x, oy = *y;
 992     gboolean rudel = rude, ruder = rude, rudet = rude, rudeb = rude;
 993     gint fw, fh;
 994     Rect desired;
 995     guint i;
 996
 997     RECT_SET(desired, *x, *y, w, h);
 998     frame_rect_to_frame(self->frame, &desired);
 999
1000     /* get where the frame would be */
1001     frame_client_gravity(self->frame, x, y);
1002
1003     /* get the requested size of the window with decorations */
1004     fw = self->frame->size.left + w + self->frame->size.right;
1005     fh = self->frame->size.top + h + self->frame->size.bottom;
1006
1007     /* If rudeness wasn't requested, then still be rude in a given direction
1008        if the client is not moving, only resizing in that direction */
1009     if (!rude) {
1010         Point oldtl, oldtr, oldbl, oldbr;
1011         Point newtl, newtr, newbl, newbr;
1012         gboolean stationary_l, stationary_r, stationary_t, stationary_b;
1013
1014         POINT_SET(oldtl, self->frame->area.x, self->frame->area.y);
1015         POINT_SET(oldbr, self->frame->area.x + self->frame->area.width - 1,
1016                   self->frame->area.y + self->frame->area.height - 1);
1017         POINT_SET(oldtr, oldbr.x, oldtl.y);
1018         POINT_SET(oldbl, oldtl.x, oldbr.y);
1019
1020         POINT_SET(newtl, *x, *y);
1021         POINT_SET(newbr, *x + fw - 1, *y + fh - 1);
1022         POINT_SET(newtr, newbr.x, newtl.y);
1023         POINT_SET(newbl, newtl.x, newbr.y);
1024
1025         /* is it moving or just resizing from some corner? */
1026         stationary_l = oldtl.x == newtl.x;
1027         stationary_r = oldtr.x == newtr.x;
1028         stationary_t = oldtl.y == newtl.y;
1029         stationary_b = oldbl.y == newbl.y;
1030
1031         /* if left edge is growing and didnt move right edge */
1032         if (stationary_r && newtl.x < oldtl.x)
1033             rudel = TRUE;
1034         /* if right edge is growing and didnt move left edge */
1035         if (stationary_l && newtr.x > oldtr.x)
1036             ruder = TRUE;
1037         /* if top edge is growing and didnt move bottom edge */
1038         if (stationary_b && newtl.y < oldtl.y)
1039             rudet = TRUE;
1040         /* if bottom edge is growing and didnt move top edge */
1041         if (stationary_t && newbl.y > oldbl.y)
1042             rudeb = TRUE;
1043     }
1044
1045     for (i = 0; i < screen_num_monitors; ++i) {
1046         Rect *a;
1047
1048         if (!screen_physical_area_monitor_contains(i, &desired)) {
1049             if (i < screen_num_monitors - 1)
1050                 continue;
1051
1052             /* the window is not inside any monitor! so just use the first
1053                one */
1054             a = screen_area(self->desktop, 0, NULL);
1055         } else
1056             a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &desired);
1057
1058         /* This makes sure windows aren't entirely outside of the screen so you
1059            can't see them at all.
1060            It makes sure 10% of the window is on the screen at least. At don't
1061            let it move itself off the top of the screen, which would hide the
1062            titlebar on you. (The user can still do this if they want too, it's
1063            only limiting the application.
1064         */
1065         if (client_normal(self)) {
1066             if (!self->strut.right && *x + fw/10 >= a->x + a->width - 1)
1067                 *x = a->x + a->width - fw/10;
1068             if (!self->strut.bottom && *y + fh/10 >= a->y + a->height - 1)
1069                 *y = a->y + a->height - fh/10;
1070             if (!self->strut.left && *x + fw*9/10 - 1 < a->x)
1071                 *x = a->x - fw*9/10;
1072             if (!self->strut.top && *y + fh*9/10 - 1 < a->y)
1073                 *y = a->y - fh*9/10;
1074         }
1075
1076         /* This here doesn't let windows even a pixel outside the
1077            struts/screen. When called from client_manage, programs placing
1078            themselves are forced completely onscreen, while things like
1079            xterm -geometry resolution-width/2 will work fine. Trying to
1080            place it completely offscreen will be handled in the above code.
1081            Sorry for this confused comment, i am tired. */
1082         if (rudel && !self->strut.left && *x < a->x) *x = a->x;
1083         if (ruder && !self->strut.right && *x + fw > a->x + a->width)
1084             *x = a->x + MAX(0, a->width - fw);
1085
1086         if (rudet && !self->strut.top && *y < a->y) *y = a->y;
1087         if (rudeb && !self->strut.bottom && *y + fh > a->y + a->height)
1088             *y = a->y + MAX(0, a->height - fh);
1089
1090         g_free(a);
1091     }
1092
1093     /* get where the client should be */
1094     frame_frame_gravity(self->frame, x, y);
1095
1096     return ox != *x || oy != *y;
1097 }
1098
1099 static void client_get_all(ObClient *self, gboolean real)
1100 {
1101     /* this is needed for the frame to set itself up */
1102     client_get_area(self);
1103
1104     /* these things can change the decor and functions of the window */
1105
1106     client_get_mwm_hints(self);
1107     /* this can change the mwmhints for special cases */
1108     client_get_type_and_transientness(self);
1109     client_get_state(self);
1110     client_update_normal_hints(self);
1111
1112     /* get the session related properties, these can change decorations
1113        from per-app settings */
1114     client_get_session_ids(self);
1115
1116     /* now we got everything that can affect the decorations */
1117     if (!real)
1118         return;
1119
1120     /* get this early so we have it for debugging */
1121     client_update_title(self);
1122
1123     client_update_protocols(self);
1124
1125     client_update_wmhints(self);
1126     /* this may have already been called from client_update_wmhints */
1127     if (!self->parents && !self->transient_for_group)
1128         client_update_transient_for(self);
1129
1130     client_get_startup_id(self);
1131     client_get_desktop(self);/* uses transient data/group/startup id if a
1132                                 desktop is not specified */
1133     client_get_shaped(self);
1134
1135     {
1136         /* a couple type-based defaults for new windows */
1137
1138         /* this makes sure that these windows appear on all desktops */
1139         if (self->type == OB_CLIENT_TYPE_DESKTOP)
1140             self->desktop = DESKTOP_ALL;
1141     }
1142
1143 #ifdef SYNC
1144     client_update_sync_request_counter(self);
1145 #endif
1146
1147     client_get_colormap(self);
1148     client_update_strut(self);
1149     client_update_icons(self);
1150     client_update_icon_geometry(self);
1151 }
1152
1153 static void client_get_startup_id(ObClient *self)
1154 {
1155     if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id)))
1156         if (self->group)
1157             PROP_GETS(self->group->leader,
1158                       net_startup_id, utf8, &self->startup_id);
1159 }
1160
1161 static void client_get_area(ObClient *self)
1162 {
1163     XWindowAttributes wattrib;
1164     Status ret;
1165
1166     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
1167     g_assert(ret != BadWindow);
1168
1169     RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
1170     POINT_SET(self->root_pos, wattrib.x, wattrib.y);
1171     self->border_width = wattrib.border_width;
1172
1173     ob_debug("client area: %d %d  %d %d  bw %d\n", wattrib.x, wattrib.y,
1174              wattrib.width, wattrib.height, wattrib.border_width);
1175 }
1176
1177 static void client_get_desktop(ObClient *self)
1178 {
1179     guint32 d = screen_num_desktops; /* an always-invalid value */
1180
1181     if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
1182         if (d >= screen_num_desktops && d != DESKTOP_ALL)
1183             self->desktop = screen_num_desktops - 1;
1184         else
1185             self->desktop = d;
1186         ob_debug("client requested desktop 0x%x\n", self->desktop);
1187     } else {
1188         GSList *it;
1189         gboolean first = TRUE;
1190         guint all = screen_num_desktops; /* not a valid value */
1191
1192         /* if they are all on one desktop, then open it on the
1193            same desktop */
1194         for (it = self->parents; it; it = g_slist_next(it)) {
1195             ObClient *c = it->data;
1196
1197             if (c->desktop == DESKTOP_ALL) continue;
1198
1199             if (first) {
1200                 all = c->desktop;
1201                 first = FALSE;
1202             }
1203             else if (all != c->desktop)
1204                 all = screen_num_desktops; /* make it invalid */
1205         }
1206         if (all != screen_num_desktops) {
1207             self->desktop = all;
1208
1209             ob_debug("client desktop set from parents: 0x%x\n",
1210                      self->desktop);
1211         }
1212         /* try get from the startup-notification protocol */
1213         else if (sn_get_desktop(self->startup_id, &self->desktop)) {
1214             if (self->desktop >= screen_num_desktops &&
1215                 self->desktop != DESKTOP_ALL)
1216                 self->desktop = screen_num_desktops - 1;
1217             ob_debug("client desktop set from startup-notification: 0x%x\n",
1218                      self->desktop);
1219         }
1220         /* defaults to the current desktop */
1221         else {
1222             self->desktop = screen_desktop;
1223             ob_debug("client desktop set to the current desktop: %d\n",
1224                      self->desktop);
1225         }
1226     }
1227 }
1228
1229 static void client_get_state(ObClient *self)
1230 {
1231     guint32 *state;
1232     guint num;
1233
1234     if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) {
1235         gulong i;
1236         for (i = 0; i < num; ++i) {
1237             if (state[i] == prop_atoms.net_wm_state_modal)
1238                 self->modal = TRUE;
1239             else if (state[i] == prop_atoms.net_wm_state_shaded)
1240                 self->shaded = TRUE;
1241             else if (state[i] == prop_atoms.net_wm_state_hidden)
1242                 self->iconic = TRUE;
1243             else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
1244                 self->skip_taskbar = TRUE;
1245             else if (state[i] == prop_atoms.net_wm_state_skip_pager)
1246                 self->skip_pager = TRUE;
1247             else if (state[i] == prop_atoms.net_wm_state_fullscreen)
1248                 self->fullscreen = TRUE;
1249             else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
1250                 self->max_vert = TRUE;
1251             else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
1252                 self->max_horz = TRUE;
1253             else if (state[i] == prop_atoms.net_wm_state_above)
1254                 self->above = TRUE;
1255             else if (state[i] == prop_atoms.net_wm_state_below)
1256                 self->below = TRUE;
1257             else if (state[i] == prop_atoms.net_wm_state_demands_attention)
1258                 self->demands_attention = TRUE;
1259             else if (state[i] == prop_atoms.ob_wm_state_undecorated)
1260                 self->undecorated = TRUE;
1261         }
1262
1263         g_free(state);
1264     }
1265 }
1266
1267 static void client_get_shaped(ObClient *self)
1268 {
1269     self->shaped = FALSE;
1270 #ifdef   SHAPE
1271     if (extensions_shape) {
1272         gint foo;
1273         guint ufoo;
1274         gint s;
1275
1276         XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
1277
1278         XShapeQueryExtents(ob_display, self->window, &s, &foo,
1279                            &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
1280                            &ufoo);
1281         self->shaped = (s != 0);
1282     }
1283 #endif
1284 }
1285
1286 void client_update_transient_for(ObClient *self)
1287 {
1288     Window t = None;
1289     ObClient *target = NULL;
1290     gboolean trangroup = FALSE;
1291
1292     if (XGetTransientForHint(ob_display, self->window, &t)) {
1293         if (t != self->window) { /* cant be transient to itself! */
1294             target = g_hash_table_lookup(window_map, &t);
1295             /* if this happens then we need to check for it*/
1296             g_assert(target != self);
1297             if (target && !WINDOW_IS_CLIENT(target)) {
1298                 /* this can happen when a dialog is a child of
1299                    a dockapp, for example */
1300                 target = NULL;
1301             }
1302         }
1303
1304         /* Setting the transient_for to Root is actually illegal, however
1305            applications from time have done this to specify transient for
1306            their group */
1307         if (!target && self->group && t == RootWindow(ob_display, ob_screen))
1308             trangroup = TRUE;
1309     } else if (self->group && self->transient)
1310         trangroup = TRUE;
1311
1312     client_update_transient_tree(self, self->group, self->group,
1313                                  self->transient_for_group, trangroup,
1314                                  client_direct_parent(self), target);
1315     self->transient_for_group = trangroup;
1316
1317 }
1318
1319 static void client_update_transient_tree(ObClient *self,
1320                                          ObGroup *oldgroup, ObGroup *newgroup,
1321                                          gboolean oldgtran, gboolean newgtran,
1322                                          ObClient* oldparent,
1323                                          ObClient *newparent)
1324 {
1325     GSList *it, *next;
1326     ObClient *c;
1327
1328     g_assert(!oldgtran || oldgroup);
1329     g_assert(!newgtran || newgroup);
1330     g_assert((!oldgtran && !oldparent) ||
1331              (oldgtran && !oldparent) ||
1332              (!oldgtran && oldparent));
1333     g_assert((!newgtran && !newparent) ||
1334              (newgtran && !newparent) ||
1335              (!newgtran && newparent));
1336
1337     /* * *
1338       Group transient windows are not allowed to have other group
1339       transient windows as their children.
1340       * * */
1341
1342
1343     /* No change has occured */
1344     if (oldgroup == newgroup &&
1345         oldgtran == newgtran &&
1346         oldparent == newparent) return;
1347
1348     /** Remove the client from the transient tree **/
1349
1350     for (it = self->transients; it; it = next) {
1351         next = g_slist_next(it);
1352         c = it->data;
1353         self->transients = g_slist_delete_link(self->transients, it);
1354         c->parents = g_slist_remove(c->parents, self);
1355     }
1356     for (it = self->parents; it; it = next) {
1357         next = g_slist_next(it);
1358         c = it->data;
1359         self->parents = g_slist_delete_link(self->parents, it);
1360         c->transients = g_slist_remove(c->transients, self);
1361     }
1362
1363     /** Re-add the client to the transient tree **/
1364
1365     /* If we're transient for a group then we need to add ourselves to all our
1366        parents */
1367     if (newgtran) {
1368         for (it = newgroup->members; it; it = g_slist_next(it)) {
1369             c = it->data;
1370             if (c != self &&
1371                 !client_search_top_direct_parent(c)->transient_for_group &&
1372                 client_normal(c))
1373             {
1374                 c->transients = g_slist_prepend(c->transients, self);
1375                 self->parents = g_slist_prepend(self->parents, c);
1376             }
1377         }
1378     }
1379
1380     /* If we are now transient for a single window we need to add ourselves to
1381        its children
1382
1383        WARNING: Cyclical transient ness is possible if two windows are
1384        transient for eachother.
1385     */
1386     else if (newparent &&
1387              /* don't make ourself its child if it is already our child */
1388              !client_is_direct_child(self, newparent) &&
1389              client_normal(newparent))
1390     {
1391         newparent->transients = g_slist_prepend(newparent->transients, self);
1392         self->parents = g_slist_prepend(self->parents, newparent);
1393     }
1394
1395     /* Add any group transient windows to our children. But if we're transient
1396        for the group, then other group transients are not our children.
1397
1398        WARNING: Cyclical transient-ness is possible. For e.g. if:
1399        A is transient for the group
1400        B is transient for A
1401        C is transient for B
1402        A can't be transient for C or we have a cycle
1403     */
1404     if (!newgtran && newgroup &&
1405         (!newparent ||
1406          !client_search_top_direct_parent(newparent)->transient_for_group) &&
1407         client_normal(self))
1408     {
1409         for (it = newgroup->members; it; it = g_slist_next(it)) {
1410             c = it->data;
1411             if (c != self && c->transient_for_group &&
1412                 /* Don't make it our child if it is already our parent */
1413                 !client_is_direct_child(c, self))
1414             {
1415                 self->transients = g_slist_prepend(self->transients, c);
1416                 c->parents = g_slist_prepend(c->parents, self);
1417             }
1418         }
1419     }
1420
1421     /** If we change our group transient-ness, our children change their
1422         effect group transient-ness, which affects how they relate to other
1423         group windows **/
1424
1425     for (it = self->transients; it; it = g_slist_next(it)) {
1426         c = it->data;
1427         if (!c->transient_for_group)
1428             client_update_transient_tree(c, c->group, c->group,
1429                                          c->transient_for_group,
1430                                          c->transient_for_group,
1431                                          client_direct_parent(c),
1432                                          client_direct_parent(c));
1433     }
1434 }
1435
1436 static void client_get_mwm_hints(ObClient *self)
1437 {
1438     guint num;
1439     guint32 *hints;
1440
1441     self->mwmhints.flags = 0; /* default to none */
1442
1443     if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
1444                     &hints, &num)) {
1445         if (num >= OB_MWM_ELEMENTS) {
1446             self->mwmhints.flags = hints[0];
1447             self->mwmhints.functions = hints[1];
1448             self->mwmhints.decorations = hints[2];
1449         }
1450         g_free(hints);
1451     }
1452 }
1453
1454 void client_get_type_and_transientness(ObClient *self)
1455 {
1456     guint num, i;
1457     guint32 *val;
1458     Window t;
1459
1460     self->type = -1;
1461     self->transient = FALSE;
1462
1463     if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
1464         /* use the first value that we know about in the array */
1465         for (i = 0; i < num; ++i) {
1466             if (val[i] == prop_atoms.net_wm_window_type_desktop)
1467                 self->type = OB_CLIENT_TYPE_DESKTOP;
1468             else if (val[i] == prop_atoms.net_wm_window_type_dock)
1469                 self->type = OB_CLIENT_TYPE_DOCK;
1470             else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
1471                 self->type = OB_CLIENT_TYPE_TOOLBAR;
1472             else if (val[i] == prop_atoms.net_wm_window_type_menu)
1473                 self->type = OB_CLIENT_TYPE_MENU;
1474             else if (val[i] == prop_atoms.net_wm_window_type_utility)
1475                 self->type = OB_CLIENT_TYPE_UTILITY;
1476             else if (val[i] == prop_atoms.net_wm_window_type_splash)
1477                 self->type = OB_CLIENT_TYPE_SPLASH;
1478             else if (val[i] == prop_atoms.net_wm_window_type_dialog)
1479                 self->type = OB_CLIENT_TYPE_DIALOG;
1480             else if (val[i] == prop_atoms.net_wm_window_type_normal)
1481                 self->type = OB_CLIENT_TYPE_NORMAL;
1482             else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
1483                 /* prevent this window from getting any decor or
1484                    functionality */
1485                 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
1486                                          OB_MWM_FLAG_DECORATIONS);
1487                 self->mwmhints.decorations = 0;
1488                 self->mwmhints.functions = 0;
1489             }
1490             if (self->type != (ObClientType) -1)
1491                 break; /* grab the first legit type */
1492         }
1493         g_free(val);
1494     }
1495
1496     if (XGetTransientForHint(ob_display, self->window, &t))
1497         self->transient = TRUE;
1498
1499     if (self->type == (ObClientType) -1) {
1500         /*the window type hint was not set, which means we either classify
1501           ourself as a normal window or a dialog, depending on if we are a
1502           transient. */
1503         if (self->transient)
1504             self->type = OB_CLIENT_TYPE_DIALOG;
1505         else
1506             self->type = OB_CLIENT_TYPE_NORMAL;
1507     }
1508
1509     /* then, based on our type, we can update our transientness.. */
1510     if (self->type == OB_CLIENT_TYPE_DIALOG ||
1511         self->type == OB_CLIENT_TYPE_TOOLBAR ||
1512         self->type == OB_CLIENT_TYPE_MENU ||
1513         self->type == OB_CLIENT_TYPE_UTILITY)
1514     {
1515         self->transient = TRUE;
1516     }
1517 }
1518
1519 void client_update_protocols(ObClient *self)
1520 {
1521     guint32 *proto;
1522     guint num_return, i;
1523
1524     self->focus_notify = FALSE;
1525     self->delete_window = FALSE;
1526
1527     if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1528         for (i = 0; i < num_return; ++i) {
1529             if (proto[i] == prop_atoms.wm_delete_window)
1530                 /* this means we can request the window to close */
1531                 self->delete_window = TRUE;
1532             else if (proto[i] == prop_atoms.wm_take_focus)
1533                 /* if this protocol is requested, then the window will be
1534                    notified whenever we want it to receive focus */
1535                 self->focus_notify = TRUE;
1536             else if (proto[i] == prop_atoms.net_wm_ping)
1537                 /* if this protocol is requested, then the window will allow
1538                    pings to determine if it is still alive */
1539                 self->ping = TRUE;
1540 #ifdef SYNC
1541             else if (proto[i] == prop_atoms.net_wm_sync_request)
1542                 /* if this protocol is requested, then resizing the
1543                    window will be synchronized between the frame and the
1544                    client */
1545                 self->sync_request = TRUE;
1546 #endif
1547         }
1548         g_free(proto);
1549     }
1550 }
1551
1552 #ifdef SYNC
1553 void client_update_sync_request_counter(ObClient *self)
1554 {
1555     guint32 i;
1556
1557     if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
1558         self->sync_counter = i;
1559     } else
1560         self->sync_counter = None;
1561 }
1562 #endif
1563
1564 static void client_get_colormap(ObClient *self)
1565 {
1566     XWindowAttributes wa;
1567
1568     if (XGetWindowAttributes(ob_display, self->window, &wa))
1569         client_update_colormap(self, wa.colormap);
1570 }
1571
1572 void client_update_colormap(ObClient *self, Colormap colormap)
1573 {
1574     if (colormap == self->colormap) return;
1575
1576     ob_debug("Setting client %s colormap: 0x%x\n", self->title, colormap);
1577
1578     if (client_focused(self)) {
1579         screen_install_colormap(self, FALSE); /* uninstall old one */
1580         self->colormap = colormap;
1581         screen_install_colormap(self, FALSE); /* install new one */
1582     } else
1583         self->colormap = colormap;
1584 }
1585
1586 void client_update_normal_hints(ObClient *self)
1587 {
1588     XSizeHints size;
1589     glong ret;
1590
1591     /* defaults */
1592     self->min_ratio = 0.0f;
1593     self->max_ratio = 0.0f;
1594     SIZE_SET(self->size_inc, 1, 1);
1595     SIZE_SET(self->base_size, 0, 0);
1596     SIZE_SET(self->min_size, 0, 0);
1597     SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1598
1599     /* get the hints from the window */
1600     if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1601         /* normal windows can't request placement! har har
1602         if (!client_normal(self))
1603         */
1604         self->positioned = (size.flags & (PPosition|USPosition));
1605         self->sized = (size.flags & (PSize|USSize));
1606
1607         if (size.flags & PWinGravity)
1608             self->gravity = size.win_gravity;
1609
1610         if (size.flags & PAspect) {
1611             if (size.min_aspect.y)
1612                 self->min_ratio =
1613                     (gfloat) size.min_aspect.x / size.min_aspect.y;
1614             if (size.max_aspect.y)
1615                 self->max_ratio =
1616                     (gfloat) size.max_aspect.x / size.max_aspect.y;
1617         }
1618
1619         if (size.flags & PMinSize)
1620             SIZE_SET(self->min_size, size.min_width, size.min_height);
1621
1622         if (size.flags & PMaxSize)
1623             SIZE_SET(self->max_size, size.max_width, size.max_height);
1624
1625         if (size.flags & PBaseSize)
1626             SIZE_SET(self->base_size, size.base_width, size.base_height);
1627
1628         if (size.flags & PResizeInc && size.width_inc && size.height_inc)
1629             SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1630
1631         ob_debug("Normal hints: min size (%d %d) max size (%d %d)\n   "
1632                  "size inc (%d %d) base size (%d %d)\n",
1633                  self->min_size.width, self->min_size.height,
1634                  self->max_size.width, self->max_size.height,
1635                  self->size_inc.width, self->size_inc.height,
1636                  self->base_size.width, self->base_size.height);
1637     }
1638     else
1639         ob_debug("Normal hints: not set\n");
1640 }
1641
1642 void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
1643 {
1644     /* start with everything (cept fullscreen) */
1645     self->decorations =
1646         (OB_FRAME_DECOR_TITLEBAR |
1647          OB_FRAME_DECOR_HANDLE |
1648          OB_FRAME_DECOR_GRIPS |
1649          OB_FRAME_DECOR_BORDER |
1650          OB_FRAME_DECOR_ICON |
1651          OB_FRAME_DECOR_ALLDESKTOPS |
1652          OB_FRAME_DECOR_ICONIFY |
1653          OB_FRAME_DECOR_MAXIMIZE |
1654          OB_FRAME_DECOR_SHADE |
1655          OB_FRAME_DECOR_CLOSE);
1656     self->functions =
1657         (OB_CLIENT_FUNC_RESIZE |
1658          OB_CLIENT_FUNC_MOVE |
1659          OB_CLIENT_FUNC_ICONIFY |
1660          OB_CLIENT_FUNC_MAXIMIZE |
1661          OB_CLIENT_FUNC_SHADE |
1662          OB_CLIENT_FUNC_CLOSE |
1663          OB_CLIENT_FUNC_BELOW |
1664          OB_CLIENT_FUNC_ABOVE |
1665          OB_CLIENT_FUNC_UNDECORATE);
1666
1667     if (!(self->min_size.width < self->max_size.width ||
1668           self->min_size.height < self->max_size.height))
1669         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1670
1671     switch (self->type) {
1672     case OB_CLIENT_TYPE_NORMAL:
1673         /* normal windows retain all of the possible decorations and
1674            functionality, and can be fullscreen */
1675         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1676         break;
1677
1678     case OB_CLIENT_TYPE_DIALOG:
1679         /* sometimes apps make dialog windows fullscreen for some reason (for
1680            e.g. kpdf does this..) */
1681         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1682         break;
1683
1684     case OB_CLIENT_TYPE_UTILITY:
1685         /* these windows don't have anything added or removed by default */
1686         break;
1687
1688     case OB_CLIENT_TYPE_MENU:
1689     case OB_CLIENT_TYPE_TOOLBAR:
1690         /* these windows can't iconify or maximize */
1691         self->decorations &= ~(OB_FRAME_DECOR_ICONIFY |
1692                                OB_FRAME_DECOR_MAXIMIZE);
1693         self->functions &= ~(OB_CLIENT_FUNC_ICONIFY |
1694                              OB_CLIENT_FUNC_MAXIMIZE);
1695         break;
1696
1697     case OB_CLIENT_TYPE_SPLASH:
1698         /* these don't get get any decorations, and the only thing you can
1699            do with them is move them */
1700         self->decorations = 0;
1701         self->functions = OB_CLIENT_FUNC_MOVE;
1702         break;
1703
1704     case OB_CLIENT_TYPE_DESKTOP:
1705         /* these windows are not manipulated by the window manager */
1706         self->decorations = 0;
1707         self->functions = 0;
1708         break;
1709
1710     case OB_CLIENT_TYPE_DOCK:
1711         /* these windows are not manipulated by the window manager, but they
1712            can set below layer which has a special meaning */
1713         self->decorations = 0;
1714         self->functions = OB_CLIENT_FUNC_BELOW;
1715         break;
1716     }
1717
1718     /* Mwm Hints are applied subtractively to what has already been chosen for
1719        decor and functionality */
1720     if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1721         if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1722             if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1723                    (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1724             {
1725                 /* if the mwm hints request no handle or title, then all
1726                    decorations are disabled, but keep the border if that's
1727                    specified */
1728                 if (self->mwmhints.decorations & OB_MWM_DECOR_BORDER)
1729                     self->decorations = OB_FRAME_DECOR_BORDER;
1730                 else
1731                     self->decorations = 0;
1732             }
1733         }
1734     }
1735
1736     if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1737         if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1738             if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1739                 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1740             if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1741                 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1742             /* dont let mwm hints kill any buttons
1743                if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1744                self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1745                if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1746                self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1747             */
1748             /* dont let mwm hints kill the close button
1749                if (! (self->mwmhints.functions & MwmFunc_Close))
1750                self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1751         }
1752     }
1753
1754     if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1755         self->decorations &= ~OB_FRAME_DECOR_SHADE;
1756     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1757         self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1758     if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1759         self->decorations &= ~(OB_FRAME_DECOR_GRIPS | OB_FRAME_DECOR_HANDLE);
1760
1761     /* can't maximize without moving/resizing */
1762     if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1763           (self->functions & OB_CLIENT_FUNC_MOVE) &&
1764           (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1765         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1766         self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1767     }
1768
1769     if (self->max_horz && self->max_vert) {
1770         /* you can't resize fully maximized windows */
1771         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1772         /* kill the handle on fully maxed windows */
1773         self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
1774     }
1775
1776     /* If there are no decorations to remove, don't allow the user to try
1777        toggle the state */
1778     if (self->decorations == 0)
1779         self->functions &= ~OB_CLIENT_FUNC_UNDECORATE;
1780
1781     /* finally, the user can have requested no decorations, which overrides
1782        everything (but doesnt give it a border if it doesnt have one) */
1783     if (self->undecorated)
1784         self->decorations = 0;
1785
1786     /* if we don't have a titlebar, then we cannot shade! */
1787     if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1788         self->functions &= ~OB_CLIENT_FUNC_SHADE;
1789
1790     /* now we need to check against rules for the client's current state */
1791     if (self->fullscreen) {
1792         self->functions &= (OB_CLIENT_FUNC_CLOSE |
1793                             OB_CLIENT_FUNC_FULLSCREEN |
1794                             OB_CLIENT_FUNC_ICONIFY);
1795         self->decorations = 0;
1796     }
1797
1798     client_change_allowed_actions(self);
1799
1800     if (reconfig)
1801         /* force reconfigure to make sure decorations are updated */
1802         client_reconfigure(self, TRUE);
1803 }
1804
1805 static void client_change_allowed_actions(ObClient *self)
1806 {
1807     gulong actions[12];
1808     gint num = 0;
1809
1810     /* desktop windows are kept on all desktops */
1811     if (self->type != OB_CLIENT_TYPE_DESKTOP)
1812         actions[num++] = prop_atoms.net_wm_action_change_desktop;
1813
1814     if (self->functions & OB_CLIENT_FUNC_SHADE)
1815         actions[num++] = prop_atoms.net_wm_action_shade;
1816     if (self->functions & OB_CLIENT_FUNC_CLOSE)
1817         actions[num++] = prop_atoms.net_wm_action_close;
1818     if (self->functions & OB_CLIENT_FUNC_MOVE)
1819         actions[num++] = prop_atoms.net_wm_action_move;
1820     if (self->functions & OB_CLIENT_FUNC_ICONIFY)
1821         actions[num++] = prop_atoms.net_wm_action_minimize;
1822     if (self->functions & OB_CLIENT_FUNC_RESIZE)
1823         actions[num++] = prop_atoms.net_wm_action_resize;
1824     if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
1825         actions[num++] = prop_atoms.net_wm_action_fullscreen;
1826     if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
1827         actions[num++] = prop_atoms.net_wm_action_maximize_horz;
1828         actions[num++] = prop_atoms.net_wm_action_maximize_vert;
1829     }
1830     if (self->functions & OB_CLIENT_FUNC_ABOVE)
1831         actions[num++] = prop_atoms.net_wm_action_above;
1832     if (self->functions & OB_CLIENT_FUNC_BELOW)
1833         actions[num++] = prop_atoms.net_wm_action_below;
1834     if (self->functions & OB_CLIENT_FUNC_UNDECORATE)
1835         actions[num++] = prop_atoms.ob_wm_action_undecorate;
1836
1837     PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
1838
1839    /* make sure the window isn't breaking any rules now
1840
1841    don't check ICONIFY here.  just cuz a window can't iconify doesnt mean
1842    it can't be iconified with its parent
1843    */
1844
1845     if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
1846         if (self->frame) client_shade(self, FALSE);
1847         else self->shaded = FALSE;
1848     }
1849     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
1850         if (self->frame) client_fullscreen(self, FALSE);
1851         else self->fullscreen = FALSE;
1852     }
1853     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
1854                                                          self->max_vert)) {
1855         if (self->frame) client_maximize(self, FALSE, 0);
1856         else self->max_vert = self->max_horz = FALSE;
1857     }
1858 }
1859
1860 void client_update_wmhints(ObClient *self)
1861 {
1862     XWMHints *hints;
1863
1864     /* assume a window takes input if it doesnt specify */
1865     self->can_focus = TRUE;
1866
1867     if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
1868         gboolean ur;
1869
1870         if (hints->flags & InputHint)
1871             self->can_focus = hints->input;
1872
1873         /* only do this when first managing the window *AND* when we aren't
1874            starting up! */
1875         if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
1876             if (hints->flags & StateHint)
1877                 self->iconic = hints->initial_state == IconicState;
1878
1879         ur = self->urgent;
1880         self->urgent = (hints->flags & XUrgencyHint);
1881         if (self->urgent && !ur)
1882             client_hilite(self, TRUE);
1883         else if (!self->urgent && ur && self->demands_attention)
1884             client_hilite(self, FALSE);
1885
1886         if (!(hints->flags & WindowGroupHint))
1887             hints->window_group = None;
1888
1889         /* did the group state change? */
1890         if (hints->window_group !=
1891             (self->group ? self->group->leader : None))
1892         {
1893             ObGroup *oldgroup = self->group;
1894
1895             /* remove from the old group if there was one */
1896             if (self->group != NULL) {
1897                 group_remove(self->group, self);
1898                 self->group = NULL;
1899             }
1900
1901             /* add ourself to the group if we have one */
1902             if (hints->window_group != None) {
1903                 self->group = group_add(hints->window_group, self);
1904             }
1905
1906             /* Put ourselves into the new group's transient tree, and remove
1907                ourselves from the old group's */
1908             client_update_transient_tree(self, oldgroup, self->group,
1909                                          self->transient_for_group,
1910                                          self->transient_for_group,
1911                                          client_direct_parent(self),
1912                                          client_direct_parent(self));
1913
1914             /* Lastly, being in a group, or not, can change if the window is
1915                transient for anything.
1916
1917                The logic for this is:
1918                self->transient = TRUE always if the window wants to be
1919                transient for something, even if transient_for was NULL because
1920                it wasn't in a group before.
1921
1922                If parents was NULL and oldgroup was NULL we can assume
1923                that when we add the new group, it will become transient for
1924                something.
1925
1926                If transient_for_group is TRUE, then it must have already
1927                had a group. If it is getting a new group, the above call to
1928                client_update_transient_tree has already taken care of
1929                everything ! If it is losing all group status then it will
1930                no longer be transient for anything and that needs to be
1931                updated.
1932             */
1933             if (self->transient &&
1934                 ((self->parents == NULL && oldgroup == NULL) ||
1935                  (self->transient_for_group && !self->group)))
1936                 client_update_transient_for(self);
1937         }
1938
1939         /* the WM_HINTS can contain an icon */
1940         if (hints->flags & IconPixmapHint)
1941             client_update_icons(self);
1942
1943         XFree(hints);
1944     }
1945 }
1946
1947 void client_update_title(ObClient *self)
1948 {
1949     gchar *data = NULL;
1950     gchar *visible = NULL;
1951
1952     g_free(self->title);
1953
1954     /* try netwm */
1955     if (!PROP_GETS(self->window, net_wm_name, utf8, &data)) {
1956         /* try old x stuff */
1957         if (!(PROP_GETS(self->window, wm_name, locale, &data)
1958               || PROP_GETS(self->window, wm_name, utf8, &data))) {
1959             if (self->transient) {
1960     /*
1961     GNOME alert windows are not given titles:
1962     http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1963     */
1964                 data = g_strdup("");
1965             } else
1966                 data = g_strdup("Unnamed Window");
1967         }
1968     }
1969
1970     if (self->client_machine) {
1971         visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1972         g_free(data);
1973     } else
1974         visible = data;
1975
1976     if (self->not_responding) {
1977         data = visible;
1978         if (self->close_tried_term)
1979             visible = g_strdup_printf("%s - [%s]", data, _("Killing..."));
1980         else
1981             visible = g_strdup_printf("%s - [%s]", data, _("Not Responding"));
1982         g_free(data);
1983     }
1984
1985     PROP_SETS(self->window, net_wm_visible_name, visible);
1986     self->title = visible;
1987
1988     if (self->frame)
1989         frame_adjust_title(self->frame);
1990
1991     /* update the icon title */
1992     data = NULL;
1993     g_free(self->icon_title);
1994
1995     /* try netwm */
1996     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
1997         /* try old x stuff */
1998         if (!(PROP_GETS(self->window, wm_icon_name, locale, &data) ||
1999               PROP_GETS(self->window, wm_icon_name, utf8, &data)))
2000             data = g_strdup(self->title);
2001
2002     if (self->client_machine) {
2003         visible = g_strdup_printf("%s (%s)", data, self->client_machine);
2004         g_free(data);
2005     } else
2006         visible = data;
2007
2008     if (self->not_responding) {
2009         data = visible;
2010         if (self->close_tried_term)
2011             visible = g_strdup_printf("%s - [%s]", data, _("Killing..."));
2012         else
2013             visible = g_strdup_printf("%s - [%s]", data, _("Not Responding"));
2014         g_free(data);
2015     }
2016
2017     PROP_SETS(self->window, net_wm_visible_icon_name, visible);
2018     self->icon_title = visible;
2019 }
2020
2021 void client_update_strut(ObClient *self)
2022 {
2023     guint num;
2024     guint32 *data;
2025     gboolean got = FALSE;
2026     StrutPartial strut;
2027
2028     if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
2029                     &data, &num)) {
2030         if (num == 12) {
2031             got = TRUE;
2032             STRUT_PARTIAL_SET(strut,
2033                               data[0], data[2], data[1], data[3],
2034                               data[4], data[5], data[8], data[9],
2035                               data[6], data[7], data[10], data[11]);
2036         }
2037         g_free(data);
2038     }
2039
2040     if (!got &&
2041         PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
2042         if (num == 4) {
2043             Rect *a;
2044
2045             got = TRUE;
2046
2047             /* use the screen's width/height */
2048             a = screen_physical_area_all_monitors();
2049
2050             STRUT_PARTIAL_SET(strut,
2051                               data[0], data[2], data[1], data[3],
2052                               a->y, a->y + a->height - 1,
2053                               a->x, a->x + a->width - 1,
2054                               a->y, a->y + a->height - 1,
2055                               a->x, a->x + a->width - 1);
2056             g_free(a);
2057         }
2058         g_free(data);
2059     }
2060
2061     if (!got)
2062         STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
2063                           0, 0, 0, 0, 0, 0, 0, 0);
2064
2065     if (!STRUT_EQUAL(strut, self->strut)) {
2066         self->strut = strut;
2067
2068         /* updating here is pointless while we're being mapped cuz we're not in
2069            the client list yet */
2070         if (self->frame)
2071             screen_update_areas();
2072     }
2073 }
2074
2075 /* Avoid storing icons above this size if possible */
2076 #define AVOID_ABOVE 64
2077
2078 void client_update_icons(ObClient *self)
2079 {
2080     guint num;
2081     guint32 *data;
2082     guint w, h, i, j;
2083     guint num_seen;  /* number of icons present */
2084     guint num_small_seen;  /* number of icons small enough present */
2085     guint smallest, smallest_area;
2086
2087     for (i = 0; i < self->nicons; ++i)
2088         g_free(self->icons[i].data);
2089     if (self->nicons > 0)
2090         g_free(self->icons);
2091     self->nicons = 0;
2092
2093     if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
2094         /* figure out how many valid icons are in here */
2095         i = 0;
2096         num_seen = num_small_seen = 0;
2097         smallest = smallest_area = 0;
2098         if (num > 2)
2099             while (i < num) {
2100                 w = data[i++];
2101                 h = data[i++];
2102                 i += w * h;
2103                 /* watch for it being too small for the specified size, or for
2104                    zero sized icons. */
2105                 if (i > num || w == 0 || h == 0) break;
2106
2107                 if (!smallest_area || w*h < smallest_area) {
2108                     smallest = num_seen;
2109                     smallest_area = w*h;
2110                 }
2111                 ++num_seen;
2112                 if (w <= AVOID_ABOVE && h <= AVOID_ABOVE)
2113                     ++num_small_seen;
2114             }
2115         if (num_small_seen > 0)
2116             self->nicons = num_small_seen;
2117         else if (num_seen)
2118             self->nicons = 1;
2119
2120         self->icons = g_new(ObClientIcon, self->nicons);
2121
2122         /* store the icons */
2123         i = 0;
2124         for (j = 0; j < self->nicons;) {
2125             guint x, y, t;
2126
2127             w = self->icons[j].width = data[i++];
2128             h = self->icons[j].height = data[i++];
2129
2130             /* if there are some icons smaller than the threshold, we're
2131                skipping all the ones above */
2132             if (num_small_seen > 0) {
2133                 if (w > AVOID_ABOVE || h > AVOID_ABOVE) {
2134                     i += w*h;
2135                     continue;
2136                 }
2137             }
2138             /* if there were no icons smaller than the threshold, then we are
2139                only taking the smallest available one we saw */
2140             else if (j != smallest) {
2141                 i += w*h;
2142                 continue;
2143             }
2144
2145             self->icons[j].data = g_new(RrPixel32, w * h);
2146             for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
2147                 if (x >= w) {
2148                     x = 0;
2149                     ++y;
2150                 }
2151                 self->icons[j].data[t] =
2152                     (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
2153                     (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
2154                     (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
2155                     (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
2156             }
2157             g_assert(i <= num);
2158
2159             ++j;
2160         }
2161
2162         g_free(data);
2163     } else {
2164         XWMHints *hints;
2165
2166         if ((hints = XGetWMHints(ob_display, self->window))) {
2167             if (hints->flags & IconPixmapHint) {
2168                 self->nicons = 1;
2169                 self->icons = g_new(ObClientIcon, self->nicons);
2170                 xerror_set_ignore(TRUE);
2171                 if (!RrPixmapToRGBA(ob_rr_inst,
2172                                     hints->icon_pixmap,
2173                                     (hints->flags & IconMaskHint ?
2174                                      hints->icon_mask : None),
2175                                     &self->icons[0].width,
2176                                     &self->icons[0].height,
2177                                     &self->icons[0].data))
2178                 {
2179                     g_free(self->icons);
2180                     self->nicons = 0;
2181                 }
2182                 xerror_set_ignore(FALSE);
2183             }
2184             XFree(hints);
2185         }
2186     }
2187
2188     /* set the default icon onto the window
2189        in theory, this could be a race, but if a window doesn't set an icon
2190        or removes it entirely, it's not very likely it is going to set one
2191        right away afterwards
2192
2193        if it has parents, then one of them will have an icon already
2194     */
2195     if (self->nicons == 0 && !self->parents) {
2196         RrPixel32 *icon = ob_rr_theme->def_win_icon;
2197         gulong *data;
2198
2199         data = g_new(gulong, 48*48+2);
2200         data[0] = data[1] =  48;
2201         for (i = 0; i < 48*48; ++i)
2202             data[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
2203                 (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
2204                 (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
2205                 (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
2206         PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2);
2207         g_free(data);
2208     } else if (self->frame)
2209         /* don't draw the icon empty if we're just setting one now anyways,
2210            we'll get the property change any second */
2211         frame_adjust_icon(self->frame);
2212 }
2213
2214 void client_update_icon_geometry(ObClient *self)
2215 {
2216     guint num;
2217     guint32 *data;
2218
2219     RECT_SET(self->icon_geometry, 0, 0, 0, 0);
2220
2221     if (PROP_GETA32(self->window, net_wm_icon_geometry, cardinal, &data, &num))
2222     {
2223         if (num == 4)
2224             /* don't let them set it with an area < 0 */
2225             RECT_SET(self->icon_geometry, data[0], data[1],
2226                      MAX(data[2],0), MAX(data[3],0));
2227         g_free(data);
2228     }
2229 }
2230
2231 static void client_get_session_ids(ObClient *self)
2232 {
2233     guint32 leader;
2234     gboolean got;
2235     gchar *s;
2236     gchar **ss;
2237
2238     if (!PROP_GET32(self->window, wm_client_leader, window, &leader))
2239         leader = None;
2240
2241     /* get the SM_CLIENT_ID */
2242     got = FALSE;
2243     if (leader)
2244         got = PROP_GETS(leader, sm_client_id, locale, &self->sm_client_id);
2245     if (!got)
2246         PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id);
2247
2248     /* get the WM_CLASS (name and class). make them "" if they are not
2249        provided */
2250     got = FALSE;
2251     if (leader)
2252         got = PROP_GETSS(leader, wm_class, locale, &ss);
2253     if (!got)
2254         got = PROP_GETSS(self->window, wm_class, locale, &ss);
2255
2256     if (got) {
2257         if (ss[0]) {
2258             self->name = g_strdup(ss[0]);
2259             if (ss[1])
2260                 self->class = g_strdup(ss[1]);
2261         }
2262         g_strfreev(ss);
2263     }
2264
2265     if (self->name == NULL) self->name = g_strdup("");
2266     if (self->class == NULL) self->class = g_strdup("");
2267
2268     /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
2269     got = FALSE;
2270     if (leader)
2271         got = PROP_GETS(leader, wm_window_role, locale, &s);
2272     if (!got)
2273         got = PROP_GETS(self->window, wm_window_role, locale, &s);
2274
2275     if (got)
2276         self->role = s;
2277     else
2278         self->role = g_strdup("");
2279
2280     /* get the WM_COMMAND */
2281     got = FALSE;
2282
2283     if (leader)
2284         got = PROP_GETSS(leader, wm_command, locale, &ss);
2285     if (!got)
2286         got = PROP_GETSS(self->window, wm_command, locale, &ss);
2287
2288     if (got) {
2289         /* merge/mash them all together */
2290         gchar *merge = NULL;
2291         gint i;
2292
2293         for (i = 0; ss[i]; ++i) {
2294             gchar *tmp = merge;
2295             if (merge)
2296                 merge = g_strconcat(merge, ss[i], NULL);
2297             else
2298                 merge = g_strconcat(ss[i], NULL);
2299             g_free(tmp);
2300         }
2301         g_strfreev(ss);
2302
2303         self->wm_command = merge;
2304     }
2305
2306     /* get the WM_CLIENT_MACHINE */
2307     got = FALSE;
2308     if (leader)
2309         got = PROP_GETS(leader, wm_client_machine, locale, &s);
2310     if (!got)
2311         got = PROP_GETS(self->window, wm_client_machine, locale, &s);
2312
2313     if (got) {
2314         gchar localhost[128];
2315         guint32 pid;
2316
2317         gethostname(localhost, 127);
2318         localhost[127] = '\0';
2319         if (strcmp(localhost, s) != 0)
2320             self->client_machine = s;
2321         else
2322             g_free(s);
2323
2324         /* see if it has the PID set too (the PID requires that the
2325            WM_CLIENT_MACHINE be set) */
2326         if (PROP_GET32(self->window, net_wm_pid, cardinal, &pid))
2327             self->pid = pid;
2328     }
2329 }
2330
2331 static void client_change_wm_state(ObClient *self)
2332 {
2333     gulong state[2];
2334     glong old;
2335
2336     old = self->wmstate;
2337
2338     if (self->shaded || self->iconic ||
2339         (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop))
2340     {
2341         self->wmstate = IconicState;
2342     } else
2343         self->wmstate = NormalState;
2344
2345     if (old != self->wmstate) {
2346         PROP_MSG(self->window, kde_wm_change_state,
2347                  self->wmstate, 1, 0, 0);
2348
2349         state[0] = self->wmstate;
2350         state[1] = None;
2351         PROP_SETA32(self->window, wm_state, wm_state, state, 2);
2352     }
2353 }
2354
2355 static void client_change_state(ObClient *self)
2356 {
2357     gulong netstate[12];
2358     guint num;
2359
2360     num = 0;
2361     if (self->modal)
2362         netstate[num++] = prop_atoms.net_wm_state_modal;
2363     if (self->shaded)
2364         netstate[num++] = prop_atoms.net_wm_state_shaded;
2365     if (self->iconic)
2366         netstate[num++] = prop_atoms.net_wm_state_hidden;
2367     if (self->skip_taskbar)
2368         netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
2369     if (self->skip_pager)
2370         netstate[num++] = prop_atoms.net_wm_state_skip_pager;
2371     if (self->fullscreen)
2372         netstate[num++] = prop_atoms.net_wm_state_fullscreen;
2373     if (self->max_vert)
2374         netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
2375     if (self->max_horz)
2376         netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
2377     if (self->above)
2378         netstate[num++] = prop_atoms.net_wm_state_above;
2379     if (self->below)
2380         netstate[num++] = prop_atoms.net_wm_state_below;
2381     if (self->demands_attention)
2382         netstate[num++] = prop_atoms.net_wm_state_demands_attention;
2383     if (self->undecorated)
2384         netstate[num++] = prop_atoms.ob_wm_state_undecorated;
2385     PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
2386
2387     if (self->frame)
2388         frame_adjust_state(self->frame);
2389 }
2390
2391 ObClient *client_search_focus_tree(ObClient *self)
2392 {
2393     GSList *it;
2394     ObClient *ret;
2395
2396     for (it = self->transients; it; it = g_slist_next(it)) {
2397         if (client_focused(it->data)) return it->data;
2398         if ((ret = client_search_focus_tree(it->data))) return ret;
2399     }
2400     return NULL;
2401 }
2402
2403 ObClient *client_search_focus_tree_full(ObClient *self)
2404 {
2405     if (self->parents) {
2406         GSList *it;
2407
2408         for (it = self->parents; it; it = g_slist_next(it)) {
2409             ObClient *c = it->data;
2410             if ((c = client_search_focus_tree_full(it->data))) return c;
2411         }
2412
2413         return NULL;
2414     }
2415     else {
2416         /* this function checks the whole tree, the client_search_focus_tree
2417            does not, so we need to check this window */
2418         if (client_focused(self))
2419             return self;
2420         return client_search_focus_tree(self);
2421     }
2422 }
2423
2424 ObClient *client_search_focus_group_full(ObClient *self)
2425 {
2426     GSList *it;
2427
2428     if (self->group) {
2429         for (it = self->group->members; it; it = g_slist_next(it)) {
2430             ObClient *c = it->data;
2431
2432             if (client_focused(c)) return c;
2433             if ((c = client_search_focus_tree(it->data))) return c;
2434         }
2435     } else
2436         if (client_focused(self)) return self;
2437     return NULL;
2438 }
2439
2440 gboolean client_has_parent(ObClient *self)
2441 {
2442     return self->parents != NULL;
2443 }
2444
2445 static ObStackingLayer calc_layer(ObClient *self)
2446 {
2447     ObStackingLayer l;
2448     Rect *monitor;
2449
2450     monitor = screen_physical_area_monitor(client_monitor(self));
2451
2452     if (self->type == OB_CLIENT_TYPE_DESKTOP)
2453         l = OB_STACKING_LAYER_DESKTOP;
2454     else if (self->type == OB_CLIENT_TYPE_DOCK) {
2455         if (self->below) l = OB_STACKING_LAYER_NORMAL;
2456         else l = OB_STACKING_LAYER_ABOVE;
2457     }
2458     else if ((self->fullscreen ||
2459               /* No decorations and fills the monitor = oldskool fullscreen.
2460                  But not for maximized windows.
2461               */
2462               (self->decorations == 0 &&
2463                !(self->max_horz && self->max_vert) &&
2464                RECT_EQUAL(self->area, *monitor))) &&
2465              (client_focused(self) || client_search_focus_tree(self)))
2466         l = OB_STACKING_LAYER_FULLSCREEN;
2467     else if (self->above) l = OB_STACKING_LAYER_ABOVE;
2468     else if (self->below) l = OB_STACKING_LAYER_BELOW;
2469     else l = OB_STACKING_LAYER_NORMAL;
2470
2471     g_free(monitor);
2472
2473     return l;
2474 }
2475
2476 static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
2477                                         ObStackingLayer min)
2478 {
2479     ObStackingLayer old, own;
2480     GSList *it;
2481
2482     old = self->layer;
2483     own = calc_layer(self);
2484     self->layer = MAX(own, min);
2485
2486     if (self->layer != old) {
2487         stacking_remove(CLIENT_AS_WINDOW(self));
2488         stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
2489     }
2490
2491     for (it = self->transients; it; it = g_slist_next(it))
2492         client_calc_layer_recursive(it->data, orig,
2493                                     self->layer);
2494 }
2495
2496 void client_calc_layer(ObClient *self)
2497 {
2498     ObClient *orig;
2499     GSList *it;
2500
2501     orig = self;
2502
2503     /* transients take on the layer of their parents */
2504     it = client_search_all_top_parents(self);
2505
2506     for (; it; it = g_slist_next(it))
2507         client_calc_layer_recursive(it->data, orig, 0);
2508 }
2509
2510 gboolean client_should_show(ObClient *self)
2511 {
2512     if (self->iconic)
2513         return FALSE;
2514     if (client_normal(self) && screen_showing_desktop)
2515         return FALSE;
2516     if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
2517         return TRUE;
2518
2519     return FALSE;
2520 }
2521
2522 gboolean client_show(ObClient *self)
2523 {
2524     gboolean show = FALSE;
2525
2526     if (client_should_show(self)) {
2527         frame_show(self->frame);
2528         show = TRUE;
2529
2530         /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2531            it needs to be in IconicState. This includes when it is on another
2532            desktop!
2533         */
2534         client_change_wm_state(self);
2535     }
2536     return show;
2537 }
2538
2539 gboolean client_hide(ObClient *self)
2540 {
2541     gboolean hide = FALSE;
2542
2543     if (!client_should_show(self)) {
2544         if (self == focus_client) {
2545             /* if there is a grab going on, then we need to cancel it. if we
2546                move focus during the grab, applications will get
2547                NotifyWhileGrabbed events and ignore them !
2548
2549                actions should not rely on being able to move focus during an
2550                interactive grab.
2551             */
2552             event_cancel_all_key_grabs();
2553         }
2554
2555         /* We don't need to ignore enter events here.
2556            The window can hide/iconify in 3 different ways:
2557            1 - through an x message. in this case we ignore all enter events
2558                caused by responding to the x message (unless underMouse)
2559            2 - by a keyboard action. in this case we ignore all enter events
2560                caused by the action
2561            3 - by a mouse action. in this case they are doing stuff with the
2562                mouse and focus _should_ move.
2563
2564            Also in action_end, we simulate an enter event that can't be ignored
2565            so trying to ignore them is futile in case 3 anyways
2566         */
2567
2568         frame_hide(self->frame);
2569         hide = TRUE;
2570
2571         /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2572            it needs to be in IconicState. This includes when it is on another
2573            desktop!
2574         */
2575         client_change_wm_state(self);
2576     }
2577     return hide;
2578 }
2579
2580 void client_showhide(ObClient *self)
2581 {
2582     if (!client_show(self))
2583         client_hide(self);
2584 }
2585
2586 gboolean client_normal(ObClient *self) {
2587     return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
2588               self->type == OB_CLIENT_TYPE_DOCK ||
2589               self->type == OB_CLIENT_TYPE_SPLASH);
2590 }
2591
2592 gboolean client_helper(ObClient *self)
2593 {
2594     return (self->type == OB_CLIENT_TYPE_UTILITY ||
2595             self->type == OB_CLIENT_TYPE_MENU ||
2596             self->type == OB_CLIENT_TYPE_TOOLBAR);
2597 }
2598
2599 gboolean client_mouse_focusable(ObClient *self)
2600 {
2601     return !(self->type == OB_CLIENT_TYPE_MENU ||
2602              self->type == OB_CLIENT_TYPE_TOOLBAR ||
2603              self->type == OB_CLIENT_TYPE_SPLASH ||
2604              self->type == OB_CLIENT_TYPE_DOCK);
2605 }
2606
2607 gboolean client_enter_focusable(ObClient *self)
2608 {
2609     /* you can focus desktops but it shouldn't on enter */
2610     return (client_mouse_focusable(self) &&
2611             self->type != OB_CLIENT_TYPE_DESKTOP);
2612 }
2613
2614
2615 static void client_apply_startup_state(ObClient *self,
2616                                        gint x, gint y, gint w, gint h)
2617 {
2618     /* save the states that we are going to apply */
2619     gboolean iconic = self->iconic;
2620     gboolean fullscreen = self->fullscreen;
2621     gboolean undecorated = self->undecorated;
2622     gboolean shaded = self->shaded;
2623     gboolean demands_attention = self->demands_attention;
2624     gboolean max_horz = self->max_horz;
2625     gboolean max_vert = self->max_vert;
2626     Rect oldarea;
2627     gint l;
2628
2629     /* turn them all off in the client, so they won't affect the window
2630        being placed */
2631     self->iconic = self->fullscreen = self->undecorated = self->shaded =
2632         self->demands_attention = self->max_horz = self->max_vert = FALSE;
2633
2634     /* move the client to its placed position, or it it's already there,
2635        generate a ConfigureNotify telling the client where it is.
2636
2637        do this after adjusting the frame. otherwise it gets all weird and
2638        clients don't work right
2639
2640        do this before applying the states so they have the correct
2641        pre-max/pre-fullscreen values
2642     */
2643     client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE);
2644     ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
2645              self->window, x, y, w, h);
2646     /* save the area, and make it where it should be for the premax stuff */
2647     oldarea = self->area;
2648     RECT_SET(self->area, x, y, w, h);
2649
2650     /* apply the states. these are in a carefully crafted order.. */
2651
2652     if (iconic)
2653         client_iconify(self, TRUE, FALSE, TRUE);
2654     if (fullscreen)
2655         client_fullscreen(self, TRUE);
2656     if (undecorated)
2657         client_set_undecorated(self, TRUE);
2658     if (shaded)
2659         client_shade(self, TRUE);
2660     if (demands_attention)
2661         client_hilite(self, TRUE);
2662
2663     if (max_vert && max_horz)
2664         client_maximize(self, TRUE, 0);
2665     else if (max_vert)
2666         client_maximize(self, TRUE, 2);
2667     else if (max_horz)
2668         client_maximize(self, TRUE, 1);
2669
2670     /* if the window hasn't been configured yet, then do so now, in fact the
2671        x,y,w,h may _not_ be the same as the area rect, which can end up
2672        meaning that the client isn't properly moved/resized by the fullscreen
2673        function
2674        pho can cause this because it maps at size of the screen but not 0,0
2675        so openbox moves it on screen to 0,0 (thus x,y=0,0 and area.x,y don't).
2676        then fullscreen'ing makes it go to 0,0 which it thinks it already is at
2677        cuz thats where the pre-fullscreen will be. however the actual area is
2678        not, so this needs to be called even if we have fullscreened/maxed
2679     */
2680     self->area = oldarea;
2681     client_configure(self, x, y, w, h, FALSE, TRUE, FALSE);
2682
2683     /* set the desktop hint, to make sure that it always exists */
2684     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
2685
2686     /* nothing to do for the other states:
2687        skip_taskbar
2688        skip_pager
2689        modal
2690        above
2691        below
2692     */
2693 }
2694
2695 void client_gravity_resize_w(ObClient *self, gint *x, gint oldw, gint neww)
2696 {
2697     /* these should be the current values. this is for when you're not moving,
2698        just resizing */
2699     g_assert(*x == self->area.x);
2700     g_assert(oldw == self->area.width);
2701
2702     /* horizontal */
2703     switch (self->gravity) {
2704     default:
2705     case NorthWestGravity:
2706     case WestGravity:
2707     case SouthWestGravity:
2708     case StaticGravity:
2709     case ForgetGravity:
2710         break;
2711     case NorthGravity:
2712     case CenterGravity:
2713     case SouthGravity:
2714         *x -= (neww - oldw) / 2;
2715         break;
2716     case NorthEastGravity:
2717     case EastGravity:
2718     case SouthEastGravity:
2719         *x -= neww - oldw;
2720         break;
2721     }
2722 }
2723
2724 void client_gravity_resize_h(ObClient *self, gint *y, gint oldh, gint newh)
2725 {
2726     /* these should be the current values. this is for when you're not moving,
2727        just resizing */
2728     g_assert(*y == self->area.y);
2729     g_assert(oldh == self->area.height);
2730
2731     /* vertical */
2732     switch (self->gravity) {
2733     default:
2734     case NorthWestGravity:
2735     case NorthGravity:
2736     case NorthEastGravity:
2737     case StaticGravity:
2738     case ForgetGravity:
2739         break;
2740     case WestGravity:
2741     case CenterGravity:
2742     case EastGravity:
2743         *y -= (newh - oldh) / 2;
2744         break;
2745     case SouthWestGravity:
2746     case SouthGravity:
2747     case SouthEastGravity:
2748         *y -= newh - oldh;
2749         break;
2750     }
2751 }
2752
2753 void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h,
2754                           gint *logicalw, gint *logicalh,
2755                           gboolean user)
2756 {
2757     Rect desired = {*x, *y, *w, *h};
2758     frame_rect_to_frame(self->frame, &desired);
2759
2760     /* make the frame recalculate its dimentions n shit without changing
2761        anything visible for real, this way the constraints below can work with
2762        the updated frame dimensions. */
2763     frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
2764
2765     /* gets the frame's position */
2766     frame_client_gravity(self->frame, x, y);
2767
2768     /* these positions are frame positions, not client positions */
2769
2770     /* set the size and position if fullscreen */
2771     if (self->fullscreen) {
2772         Rect *a;
2773         guint i;
2774
2775         i = screen_find_monitor(&desired);
2776         a = screen_physical_area_monitor(i);
2777
2778         *x = a->x;
2779         *y = a->y;
2780         *w = a->width;
2781         *h = a->height;
2782
2783         user = FALSE; /* ignore if the client can't be moved/resized when it
2784                          is fullscreening */
2785
2786         g_free(a);
2787     } else if (self->max_horz || self->max_vert) {
2788         Rect *a;
2789         guint i;
2790
2791         /* use all possible struts when maximizing to the full screen */
2792         i = screen_find_monitor(&desired);
2793         a = screen_area(self->desktop, i,
2794                         (self->max_horz && self->max_vert ? NULL : &desired));
2795
2796         /* set the size and position if maximized */
2797         if (self->max_horz) {
2798             *x = a->x;
2799             *w = a->width - self->frame->size.left - self->frame->size.right;
2800         }
2801         if (self->max_vert) {
2802             *y = a->y;
2803             *h = a->height - self->frame->size.top - self->frame->size.bottom;
2804         }
2805
2806         user = FALSE; /* ignore if the client can't be moved/resized when it
2807                          is maximizing */
2808
2809         g_free(a);
2810     }
2811
2812     /* gets the client's position */
2813     frame_frame_gravity(self->frame, x, y);
2814
2815     /* work within the prefered sizes given by the window */
2816     if (!(*w == self->area.width && *h == self->area.height)) {
2817         gint basew, baseh, minw, minh;
2818         gint incw, inch;
2819         gfloat minratio, maxratio;
2820
2821         incw = self->fullscreen || self->max_horz ? 1 : self->size_inc.width;
2822         inch = self->fullscreen || self->max_vert ? 1 : self->size_inc.height;
2823         minratio = self->fullscreen || (self->max_horz && self->max_vert) ?
2824             0 : self->min_ratio;
2825         maxratio = self->fullscreen || (self->max_horz && self->max_vert) ?
2826             0 : self->max_ratio;
2827
2828         /* base size is substituted with min size if not specified */
2829         if (self->base_size.width || self->base_size.height) {
2830             basew = self->base_size.width;
2831             baseh = self->base_size.height;
2832         } else {
2833             basew = self->min_size.width;
2834             baseh = self->min_size.height;
2835         }
2836         /* min size is substituted with base size if not specified */
2837         if (self->min_size.width || self->min_size.height) {
2838             minw = self->min_size.width;
2839             minh = self->min_size.height;
2840         } else {
2841             minw = self->base_size.width;
2842             minh = self->base_size.height;
2843         }
2844
2845         /* if this is a user-requested resize, then check against min/max
2846            sizes */
2847
2848         /* smaller than min size or bigger than max size? */
2849         if (*w > self->max_size.width) *w = self->max_size.width;
2850         if (*w < minw) *w = minw;
2851         if (*h > self->max_size.height) *h = self->max_size.height;
2852         if (*h < minh) *h = minh;
2853
2854         *w -= basew;
2855         *h -= baseh;
2856
2857         /* keep to the increments */
2858         *w /= incw;
2859         *h /= inch;
2860
2861         /* you cannot resize to nothing */
2862         if (basew + *w < 1) *w = 1 - basew;
2863         if (baseh + *h < 1) *h = 1 - baseh;
2864
2865         /* save the logical size */
2866         *logicalw = incw > 1 ? *w : *w + basew;
2867         *logicalh = inch > 1 ? *h : *h + baseh;
2868
2869         *w *= incw;
2870         *h *= inch;
2871
2872         *w += basew;
2873         *h += baseh;
2874
2875         /* adjust the height to match the width for the aspect ratios.
2876            for this, min size is not substituted for base size ever. */
2877         *w -= self->base_size.width;
2878         *h -= self->base_size.height;
2879
2880         if (minratio)
2881             if (*h * minratio > *w) {
2882                 *h = (gint)(*w / minratio);
2883
2884                 /* you cannot resize to nothing */
2885                 if (*h < 1) {
2886                     *h = 1;
2887                     *w = (gint)(*h * minratio);
2888                 }
2889             }
2890         if (maxratio)
2891             if (*h * maxratio < *w) {
2892                 *h = (gint)(*w / maxratio);
2893
2894                 /* you cannot resize to nothing */
2895                 if (*h < 1) {
2896                     *h = 1;
2897                     *w = (gint)(*h * minratio);
2898                 }
2899             }
2900
2901         *w += self->base_size.width;
2902         *h += self->base_size.height;
2903     }
2904
2905     /* these override the above states! if you cant move you can't move! */
2906     if (user) {
2907         if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
2908             *x = self->area.x;
2909             *y = self->area.y;
2910         }
2911         if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
2912             *w = self->area.width;
2913             *h = self->area.height;
2914         }
2915     }
2916
2917     g_assert(*w > 0);
2918     g_assert(*h > 0);
2919 }
2920
2921
2922 void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
2923                       gboolean user, gboolean final, gboolean force_reply)
2924 {
2925     gint oldw, oldh;
2926     gboolean send_resize_client;
2927     gboolean moved = FALSE, resized = FALSE, rootmoved = FALSE;
2928     gboolean fmoved, fresized;
2929     guint fdecor = self->frame->decorations;
2930     gboolean fhorz = self->frame->max_horz;
2931     gboolean fvert = self->frame->max_vert;
2932     gint logicalw, logicalh;
2933
2934     /* find the new x, y, width, and height (and logical size) */
2935     client_try_configure(self, &x, &y, &w, &h, &logicalw, &logicalh, user);
2936
2937     /* set the logical size if things changed */
2938     if (!(w == self->area.width && h == self->area.height))
2939         SIZE_SET(self->logical_size, logicalw, logicalh);
2940
2941     /* figure out if we moved or resized or what */
2942     moved = (x != self->area.x || y != self->area.y);
2943     resized = (w != self->area.width || h != self->area.height);
2944
2945     oldw = self->area.width;
2946     oldh = self->area.height;
2947     RECT_SET(self->area, x, y, w, h);
2948
2949     /* for app-requested resizes, always resize if 'resized' is true.
2950        for user-requested ones, only resize if final is true, or when
2951        resizing in redraw mode */
2952     send_resize_client = ((!user && resized) ||
2953                           (user && (final ||
2954                                     (resized && config_resize_redraw))));
2955
2956     /* if the client is enlarging, then resize the client before the frame */
2957     if (send_resize_client && (w > oldw || h > oldh)) {
2958         XMoveResizeWindow(ob_display, self->window,
2959                           self->frame->size.left, self->frame->size.top,
2960                           MAX(w, oldw), MAX(h, oldh));
2961         frame_adjust_client_area(self->frame);
2962     }
2963
2964     /* find the frame's dimensions and move/resize it */
2965     fmoved = moved;
2966     fresized = resized;
2967
2968     /* if decorations changed, then readjust everything for the frame */
2969     if (self->decorations != fdecor ||
2970         self->max_horz != fhorz || self->max_vert != fvert)
2971     {
2972         fmoved = fresized = TRUE;
2973     }
2974
2975     /* adjust the frame */
2976     if (fmoved || fresized) {
2977         gulong ignore_start;
2978         if (!user)
2979             ignore_start = event_start_ignore_all_enters();
2980
2981         frame_adjust_area(self->frame, fmoved, fresized, FALSE);
2982
2983         if (!user)
2984             event_end_ignore_all_enters(ignore_start);
2985     }
2986
2987     if (!user || final) {
2988         gint oldrx = self->root_pos.x;
2989         gint oldry = self->root_pos.y;
2990         /* we have reset the client to 0 border width, so don't include
2991            it in these coords */
2992         POINT_SET(self->root_pos,
2993                   self->frame->area.x + self->frame->size.left -
2994                   self->border_width,
2995                   self->frame->area.y + self->frame->size.top -
2996                   self->border_width);
2997         if (self->root_pos.x != oldrx || self->root_pos.y != oldry)
2998             rootmoved = TRUE;
2999     }
3000
3001     /* This is kinda tricky and should not be changed.. let me explain!
3002
3003        When user = FALSE, then the request is coming from the application
3004        itself, and we are more strict about when to send a synthetic
3005        ConfigureNotify.  We strictly follow the rules of the ICCCM sec 4.1.5
3006        in this case (if force_reply is true)
3007
3008        When user = TRUE, then the request is coming from "us", like when we
3009        maximize a window or something.  In this case we are more lenient.  We
3010        used to follow the same rules as above, but _Java_ Swing can't handle
3011        this. So just to appease Swing, when user = TRUE, we always send
3012        a synthetic ConfigureNotify to give the window its root coordinates.
3013     */
3014     if ((!user && !resized && (rootmoved || force_reply)) ||
3015         (user && final && rootmoved))
3016     {
3017         XEvent event;
3018
3019         event.type = ConfigureNotify;
3020         event.xconfigure.display = ob_display;
3021         event.xconfigure.event = self->window;
3022         event.xconfigure.window = self->window;
3023
3024         ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
3025                  self->title, self->root_pos.x, self->root_pos.y, w, h);
3026
3027         /* root window real coords */
3028         event.xconfigure.x = self->root_pos.x;
3029         event.xconfigure.y = self->root_pos.y;
3030         event.xconfigure.width = w;
3031         event.xconfigure.height = h;
3032         event.xconfigure.border_width = self->border_width;
3033         event.xconfigure.above = None;
3034         event.xconfigure.override_redirect = FALSE;
3035         XSendEvent(event.xconfigure.display, event.xconfigure.window,
3036                    FALSE, StructureNotifyMask, &event);
3037     }
3038
3039     /* if the client is shrinking, then resize the frame before the client.
3040
3041        both of these resize sections may run, because the top one only resizes
3042        in the direction that is growing
3043      */
3044     if (send_resize_client && (w <= oldw || h <= oldh)) {
3045         frame_adjust_client_area(self->frame);
3046         XMoveResizeWindow(ob_display, self->window,
3047                           self->frame->size.left, self->frame->size.top, w, h);
3048     }
3049
3050     XFlush(ob_display);
3051 }
3052
3053 void client_fullscreen(ObClient *self, gboolean fs)
3054 {
3055     gint x, y, w, h;
3056
3057     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
3058         self->fullscreen == fs) return;                   /* already done */
3059
3060     self->fullscreen = fs;
3061     client_change_state(self); /* change the state hints on the client */
3062
3063     if (fs) {
3064         self->pre_fullscreen_area = self->area;
3065         /* if the window is maximized, its area isn't all that meaningful.
3066            save it's premax area instead. */
3067         if (self->max_horz) {
3068             self->pre_fullscreen_area.x = self->pre_max_area.x;
3069             self->pre_fullscreen_area.width = self->pre_max_area.width;
3070         }
3071         if (self->max_vert) {
3072             self->pre_fullscreen_area.y = self->pre_max_area.y;
3073             self->pre_fullscreen_area.height = self->pre_max_area.height;
3074         }
3075
3076         /* these will help configure_full figure out where to fullscreen
3077            the window */
3078         x = self->area.x;
3079         y = self->area.y;
3080         w = self->area.width;
3081         h = self->area.height;
3082     } else {
3083         g_assert(self->pre_fullscreen_area.width > 0 &&
3084                  self->pre_fullscreen_area.height > 0);
3085
3086         x = self->pre_fullscreen_area.x;
3087         y = self->pre_fullscreen_area.y;
3088         w = self->pre_fullscreen_area.width;
3089         h = self->pre_fullscreen_area.height;
3090         RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
3091     }
3092
3093     ob_debug("Window %s going fullscreen (%d)\n",
3094              self->title, self->fullscreen);
3095
3096     client_setup_decor_and_functions(self, FALSE);
3097     client_move_resize(self, x, y, w, h);
3098
3099     /* and adjust our layer/stacking. do this after resizing the window,
3100        and applying decorations, because windows which fill the screen are
3101        considered "fullscreen" and it affects their layer */
3102     client_calc_layer(self);
3103
3104     if (fs) {
3105         /* try focus us when we go into fullscreen mode */
3106         client_focus(self);
3107     }
3108 }
3109
3110 static void client_iconify_recursive(ObClient *self,
3111                                      gboolean iconic, gboolean curdesk,
3112                                      gboolean hide_animation)
3113 {
3114     GSList *it;
3115     gboolean changed = FALSE;
3116
3117
3118     if (self->iconic != iconic) {
3119         ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
3120                  self->window);
3121
3122         if (iconic) {
3123             /* don't let non-normal windows iconify along with their parents
3124                or whatever */
3125             if (client_normal(self)) {
3126                 self->iconic = iconic;
3127
3128                 /* update the focus lists.. iconic windows go to the bottom of
3129                    the list */
3130                 focus_order_to_bottom(self);
3131
3132                 changed = TRUE;
3133             }
3134         } else {
3135             self->iconic = iconic;
3136
3137             if (curdesk && self->desktop != screen_desktop &&
3138                 self->desktop != DESKTOP_ALL)
3139                 client_set_desktop(self, screen_desktop, FALSE, FALSE);
3140
3141             /* this puts it after the current focused window */
3142             focus_order_remove(self);
3143             focus_order_add_new(self);
3144
3145             changed = TRUE;
3146         }
3147     }
3148
3149     if (changed) {
3150         client_change_state(self);
3151         if (config_animate_iconify && !hide_animation)
3152             frame_begin_iconify_animation(self->frame, iconic);
3153         /* do this after starting the animation so it doesn't flash */
3154         client_showhide(self);
3155     }
3156
3157     /* iconify all direct transients, and deiconify all transients
3158        (non-direct too) */
3159     for (it = self->transients; it; it = g_slist_next(it))
3160         if (it->data != self)
3161             if (client_is_direct_child(self, it->data) || !iconic)
3162                 client_iconify_recursive(it->data, iconic, curdesk,
3163                                          hide_animation);
3164 }
3165
3166 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk,
3167                     gboolean hide_animation)
3168 {
3169     if (self->functions & OB_CLIENT_FUNC_ICONIFY || !iconic) {
3170         /* move up the transient chain as far as possible first */
3171         self = client_search_top_direct_parent(self);
3172         client_iconify_recursive(self, iconic, curdesk, hide_animation);
3173     }
3174 }
3175
3176 void client_maximize(ObClient *self, gboolean max, gint dir)
3177 {
3178     gint x, y, w, h;
3179
3180     g_assert(dir == 0 || dir == 1 || dir == 2);
3181     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
3182
3183     /* check if already done */
3184     if (max) {
3185         if (dir == 0 && self->max_horz && self->max_vert) return;
3186         if (dir == 1 && self->max_horz) return;
3187         if (dir == 2 && self->max_vert) return;
3188     } else {
3189         if (dir == 0 && !self->max_horz && !self->max_vert) return;
3190         if (dir == 1 && !self->max_horz) return;
3191         if (dir == 2 && !self->max_vert) return;
3192     }
3193
3194     /* these will help configure_full figure out which screen to fill with
3195        the window */
3196     x = self->area.x;
3197     y = self->area.y;
3198     w = self->area.width;
3199     h = self->area.height;
3200
3201     if (max) {
3202         if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
3203             RECT_SET(self->pre_max_area,
3204                      self->area.x, self->pre_max_area.y,
3205                      self->area.width, self->pre_max_area.height);
3206         }
3207         if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
3208             RECT_SET(self->pre_max_area,
3209                      self->pre_max_area.x, self->area.y,
3210                      self->pre_max_area.width, self->area.height);
3211         }
3212     } else {
3213         if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
3214             g_assert(self->pre_max_area.width > 0);
3215
3216             x = self->pre_max_area.x;
3217             w = self->pre_max_area.width;
3218
3219             RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
3220                      0, self->pre_max_area.height);
3221         }
3222         if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
3223             g_assert(self->pre_max_area.height > 0);
3224
3225             y = self->pre_max_area.y;
3226             h = self->pre_max_area.height;
3227
3228             RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
3229                      self->pre_max_area.width, 0);
3230         }
3231     }
3232
3233     if (dir == 0 || dir == 1) /* horz */
3234         self->max_horz = max;
3235     if (dir == 0 || dir == 2) /* vert */
3236         self->max_vert = max;
3237
3238     client_change_state(self); /* change the state hints on the client */
3239
3240     client_setup_decor_and_functions(self, FALSE);
3241     client_move_resize(self, x, y, w, h);
3242 }
3243
3244 void client_shade(ObClient *self, gboolean shade)
3245 {
3246     if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
3247          shade) ||                         /* can't shade */
3248         self->shaded == shade) return;     /* already done */
3249
3250     self->shaded = shade;
3251     client_change_state(self);
3252     client_change_wm_state(self); /* the window is being hidden/shown */
3253     /* resize the frame to just the titlebar */
3254     frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
3255 }
3256
3257 static void client_ping_event(ObClient *self, gboolean dead)
3258 {
3259     self->not_responding = dead;
3260     client_update_title(self);
3261
3262     if (!dead) {
3263         /* try kill it nicely the first time again, if it started responding
3264            at some point */
3265         self->close_tried_term = FALSE;
3266     }
3267 }
3268
3269 void client_close(ObClient *self)
3270 {
3271     if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
3272
3273     /* in the case that the client provides no means to requesting that it
3274        close, we just kill it */
3275     if (!self->delete_window)
3276         /* don't use client_kill(), we should only kill based on PID in
3277            response to a lack of PING replies */
3278         XKillClient(ob_display, self->window);
3279     else if (self->not_responding)
3280         client_kill(self);
3281     else
3282         /* request the client to close with WM_DELETE_WINDOW */
3283         PROP_MSG_TO(self->window, self->window, wm_protocols,
3284                     prop_atoms.wm_delete_window, event_curtime, 0, 0, 0,
3285                     NoEventMask);
3286 }
3287
3288 void client_kill(ObClient *self)
3289 {
3290     if (!self->client_machine && self->pid) {
3291         /* running on the local host */
3292         if (!self->close_tried_term) {
3293             ob_debug("killing window 0x%x with pid %lu, with SIGTERM\n",
3294                      self->window, self->pid);
3295             kill(self->pid, SIGTERM);
3296             self->close_tried_term = TRUE;
3297
3298             /* show that we're trying to kill it */
3299             client_update_title(self);
3300         }
3301         else {
3302             ob_debug("killing window 0x%x with pid %lu, with SIGKILL\n",
3303                      self->window, self->pid);
3304             kill(self->pid, SIGKILL); /* kill -9 */
3305         }
3306     }
3307     else
3308         XKillClient(ob_display, self->window);
3309 }
3310
3311 void client_hilite(ObClient *self, gboolean hilite)
3312 {
3313     if (self->demands_attention == hilite)
3314         return; /* no change */
3315
3316     /* don't allow focused windows to hilite */
3317     self->demands_attention = hilite && !client_focused(self);
3318     if (self->frame != NULL) { /* if we're mapping, just set the state */
3319         if (self->demands_attention)
3320             frame_flash_start(self->frame);
3321         else
3322             frame_flash_stop(self->frame);
3323         client_change_state(self);
3324     }
3325 }
3326
3327 static void client_set_desktop_recursive(ObClient *self,
3328                                          guint target,
3329                                          gboolean donthide,
3330                                          gboolean dontraise)
3331 {
3332     guint old;
3333     GSList *it;
3334
3335     if (target != self->desktop && self->type != OB_CLIENT_TYPE_DESKTOP) {
3336
3337         ob_debug("Setting desktop %u\n", target+1);
3338
3339         g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
3340
3341         old = self->desktop;
3342         self->desktop = target;
3343         PROP_SET32(self->window, net_wm_desktop, cardinal, target);
3344         /* the frame can display the current desktop state */
3345         frame_adjust_state(self->frame);
3346         /* 'move' the window to the new desktop */
3347         if (!donthide)
3348             client_hide(self);
3349         client_show(self);
3350         /* raise if it was not already on the desktop */
3351         if (old != DESKTOP_ALL && !dontraise)
3352             stacking_raise(CLIENT_AS_WINDOW(self));
3353         if (STRUT_EXISTS(self->strut))
3354             screen_update_areas();
3355         else
3356             /* the new desktop's geometry may be different, so we may need to
3357                resize, for example if we are maximized */
3358             client_reconfigure(self, FALSE);
3359     }
3360
3361     /* move all transients */
3362     for (it = self->transients; it; it = g_slist_next(it))
3363         if (it->data != self)
3364             if (client_is_direct_child(self, it->data))
3365                 client_set_desktop_recursive(it->data, target,
3366                                              donthide, dontraise);
3367 }
3368
3369 void client_set_desktop(ObClient *self, guint target,
3370                         gboolean donthide, gboolean dontraise)
3371 {
3372     self = client_search_top_direct_parent(self);
3373     client_set_desktop_recursive(self, target, donthide, dontraise);
3374 }
3375
3376 gboolean client_is_direct_child(ObClient *parent, ObClient *child)
3377 {
3378     while (child != parent && (child = client_direct_parent(child)));
3379     return child == parent;
3380 }
3381
3382 ObClient *client_search_modal_child(ObClient *self)
3383 {
3384     GSList *it;
3385     ObClient *ret;
3386
3387     for (it = self->transients; it; it = g_slist_next(it)) {
3388         ObClient *c = it->data;
3389         if ((ret = client_search_modal_child(c))) return ret;
3390         if (c->modal) return c;
3391     }
3392     return NULL;
3393 }
3394
3395 gboolean client_validate(ObClient *self)
3396 {
3397     XEvent e;
3398
3399     XSync(ob_display, FALSE); /* get all events on the server */
3400
3401     if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
3402         XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
3403         XPutBackEvent(ob_display, &e);
3404         return FALSE;
3405     }
3406
3407     return TRUE;
3408 }
3409
3410 void client_set_wm_state(ObClient *self, glong state)
3411 {
3412     if (state == self->wmstate) return; /* no change */
3413
3414     switch (state) {
3415     case IconicState:
3416         client_iconify(self, TRUE, TRUE, FALSE);
3417         break;
3418     case NormalState:
3419         client_iconify(self, FALSE, TRUE, FALSE);
3420         break;
3421     }
3422 }
3423
3424 void client_set_state(ObClient *self, Atom action, glong data1, glong data2)
3425 {
3426     gboolean shaded = self->shaded;
3427     gboolean fullscreen = self->fullscreen;
3428     gboolean undecorated = self->undecorated;
3429     gboolean max_horz = self->max_horz;
3430     gboolean max_vert = self->max_vert;
3431     gboolean modal = self->modal;
3432     gboolean iconic = self->iconic;
3433     gboolean demands_attention = self->demands_attention;
3434     gboolean above = self->above;
3435     gboolean below = self->below;
3436     gint i;
3437
3438     if (!(action == prop_atoms.net_wm_state_add ||
3439           action == prop_atoms.net_wm_state_remove ||
3440           action == prop_atoms.net_wm_state_toggle))
3441         /* an invalid action was passed to the client message, ignore it */
3442         return;
3443
3444     for (i = 0; i < 2; ++i) {
3445         Atom state = i == 0 ? data1 : data2;
3446
3447         if (!state) continue;
3448
3449         /* if toggling, then pick whether we're adding or removing */
3450         if (action == prop_atoms.net_wm_state_toggle) {
3451             if (state == prop_atoms.net_wm_state_modal)
3452                 action = modal ? prop_atoms.net_wm_state_remove :
3453                     prop_atoms.net_wm_state_add;
3454             else if (state == prop_atoms.net_wm_state_maximized_vert)
3455                 action = self->max_vert ? prop_atoms.net_wm_state_remove :
3456                     prop_atoms.net_wm_state_add;
3457             else if (state == prop_atoms.net_wm_state_maximized_horz)
3458                 action = self->max_horz ? prop_atoms.net_wm_state_remove :
3459                     prop_atoms.net_wm_state_add;
3460             else if (state == prop_atoms.net_wm_state_shaded)
3461                 action = shaded ? prop_atoms.net_wm_state_remove :
3462                     prop_atoms.net_wm_state_add;
3463             else if (state == prop_atoms.net_wm_state_skip_taskbar)
3464                 action = self->skip_taskbar ?
3465                     prop_atoms.net_wm_state_remove :
3466                     prop_atoms.net_wm_state_add;
3467             else if (state == prop_atoms.net_wm_state_skip_pager)
3468                 action = self->skip_pager ?
3469                     prop_atoms.net_wm_state_remove :
3470                     prop_atoms.net_wm_state_add;
3471             else if (state == prop_atoms.net_wm_state_hidden)
3472                 action = self->iconic ?
3473                     prop_atoms.net_wm_state_remove :
3474                     prop_atoms.net_wm_state_add;
3475             else if (state == prop_atoms.net_wm_state_fullscreen)
3476                 action = fullscreen ?
3477                     prop_atoms.net_wm_state_remove :
3478                     prop_atoms.net_wm_state_add;
3479             else if (state == prop_atoms.net_wm_state_above)
3480                 action = self->above ? prop_atoms.net_wm_state_remove :
3481                     prop_atoms.net_wm_state_add;
3482             else if (state == prop_atoms.net_wm_state_below)
3483                 action = self->below ? prop_atoms.net_wm_state_remove :
3484                     prop_atoms.net_wm_state_add;
3485             else if (state == prop_atoms.net_wm_state_demands_attention)
3486                 action = self->demands_attention ?
3487                     prop_atoms.net_wm_state_remove :
3488                     prop_atoms.net_wm_state_add;
3489             else if (state == prop_atoms.ob_wm_state_undecorated)
3490                 action = undecorated ? prop_atoms.net_wm_state_remove :
3491                     prop_atoms.net_wm_state_add;
3492         }
3493
3494         if (action == prop_atoms.net_wm_state_add) {
3495             if (state == prop_atoms.net_wm_state_modal) {
3496                 modal = TRUE;
3497             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3498                 max_vert = TRUE;
3499             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3500                 max_horz = TRUE;
3501             } else if (state == prop_atoms.net_wm_state_shaded) {
3502                 shaded = TRUE;
3503             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3504                 self->skip_taskbar = TRUE;
3505             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3506                 self->skip_pager = TRUE;
3507             } else if (state == prop_atoms.net_wm_state_hidden) {
3508                 iconic = TRUE;
3509             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3510                 fullscreen = TRUE;
3511             } else if (state == prop_atoms.net_wm_state_above) {
3512                 above = TRUE;
3513                 below = FALSE;
3514             } else if (state == prop_atoms.net_wm_state_below) {
3515                 above = FALSE;
3516                 below = TRUE;
3517             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3518                 demands_attention = TRUE;
3519             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3520                 undecorated = TRUE;
3521             }
3522
3523         } else { /* action == prop_atoms.net_wm_state_remove */
3524             if (state == prop_atoms.net_wm_state_modal) {
3525                 modal = FALSE;
3526             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3527                 max_vert = FALSE;
3528             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3529                 max_horz = FALSE;
3530             } else if (state == prop_atoms.net_wm_state_shaded) {
3531                 shaded = FALSE;
3532             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3533                 self->skip_taskbar = FALSE;
3534             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3535                 self->skip_pager = FALSE;
3536             } else if (state == prop_atoms.net_wm_state_hidden) {
3537                 iconic = FALSE;
3538             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3539                 fullscreen = FALSE;
3540             } else if (state == prop_atoms.net_wm_state_above) {
3541                 above = FALSE;
3542             } else if (state == prop_atoms.net_wm_state_below) {
3543                 below = FALSE;
3544             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3545                 demands_attention = FALSE;
3546             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3547                 undecorated = FALSE;
3548             }
3549         }
3550     }
3551
3552     if (max_horz != self->max_horz || max_vert != self->max_vert) {
3553         if (max_horz != self->max_horz && max_vert != self->max_vert) {
3554             /* toggling both */
3555             if (max_horz == max_vert) { /* both going the same way */
3556                 client_maximize(self, max_horz, 0);
3557             } else {
3558                 client_maximize(self, max_horz, 1);
3559                 client_maximize(self, max_vert, 2);
3560             }
3561         } else {
3562             /* toggling one */
3563             if (max_horz != self->max_horz)
3564                 client_maximize(self, max_horz, 1);
3565             else
3566                 client_maximize(self, max_vert, 2);
3567         }
3568     }
3569     /* change fullscreen state before shading, as it will affect if the window
3570        can shade or not */
3571     if (fullscreen != self->fullscreen)
3572         client_fullscreen(self, fullscreen);
3573     if (shaded != self->shaded)
3574         client_shade(self, shaded);
3575     if (undecorated != self->undecorated)
3576         client_set_undecorated(self, undecorated);
3577     if (above != self->above || below != self->below) {
3578         self->above = above;
3579         self->below = below;
3580         client_calc_layer(self);
3581     }
3582
3583     if (modal != self->modal) {
3584         self->modal = modal;
3585         /* when a window changes modality, then its stacking order with its
3586            transients needs to change */
3587         stacking_raise(CLIENT_AS_WINDOW(self));
3588
3589         /* it also may get focused. if something is focused that shouldn't
3590            be focused anymore, then move the focus */
3591         if (focus_client && client_focus_target(focus_client) != focus_client)
3592             client_focus(focus_client);
3593     }
3594
3595     if (iconic != self->iconic)
3596         client_iconify(self, iconic, FALSE, FALSE);
3597
3598     if (demands_attention != self->demands_attention)
3599         client_hilite(self, demands_attention);
3600
3601     client_change_state(self); /* change the hint to reflect these changes */
3602 }
3603
3604 ObClient *client_focus_target(ObClient *self)
3605 {
3606     ObClient *child = NULL;
3607
3608     child = client_search_modal_child(self);
3609     if (child) return child;
3610     return self;
3611 }
3612
3613 gboolean client_can_focus(ObClient *self)
3614 {
3615     /* choose the correct target */
3616     self = client_focus_target(self);
3617
3618     if (!self->frame->visible)
3619         return FALSE;
3620
3621     if (!(self->can_focus || self->focus_notify))
3622         return FALSE;
3623
3624     return TRUE;
3625 }
3626
3627 gboolean client_focus(ObClient *self)
3628 {
3629     /* we might not focus this window, so if we have modal children which would
3630        be focused instead, bring them to this desktop */
3631     client_bring_modal_windows(self);
3632
3633     /* choose the correct target */
3634     self = client_focus_target(self);
3635
3636     if (!client_can_focus(self)) {
3637         ob_debug_type(OB_DEBUG_FOCUS,
3638                       "Client %s can't be focused\n", self->title);
3639         return FALSE;
3640     }
3641
3642     ob_debug_type(OB_DEBUG_FOCUS,
3643                   "Focusing client \"%s\" (0x%x) at time %u\n",
3644                   self->title, self->window, event_curtime);
3645
3646     /* if using focus_delay, stop the timer now so that focus doesn't
3647        go moving on us */
3648     event_halt_focus_delay();
3649
3650     /* if there is a grab going on, then we need to cancel it. if we move
3651        focus during the grab, applications will get NotifyWhileGrabbed events
3652        and ignore them !
3653
3654        actions should not rely on being able to move focus during an
3655        interactive grab.
3656     */
3657     event_cancel_all_key_grabs();
3658
3659     xerror_set_ignore(TRUE);
3660     xerror_occured = FALSE;
3661
3662     if (self->can_focus) {
3663         /* This can cause a BadMatch error with CurrentTime, or if an app
3664            passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3665         XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
3666                        event_curtime);
3667     }
3668
3669     if (self->focus_notify) {
3670         XEvent ce;
3671         ce.xclient.type = ClientMessage;
3672         ce.xclient.message_type = prop_atoms.wm_protocols;
3673         ce.xclient.display = ob_display;
3674         ce.xclient.window = self->window;
3675         ce.xclient.format = 32;
3676         ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
3677         ce.xclient.data.l[1] = event_curtime;
3678         ce.xclient.data.l[2] = 0l;
3679         ce.xclient.data.l[3] = 0l;
3680         ce.xclient.data.l[4] = 0l;
3681         XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3682     }
3683
3684     xerror_set_ignore(FALSE);
3685
3686     ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d\n", xerror_occured);
3687     return !xerror_occured;
3688 }
3689
3690 static void client_present(ObClient *self, gboolean here, gboolean raise,
3691                            gboolean unshade)
3692 {
3693     if (client_normal(self) && screen_showing_desktop)
3694         screen_show_desktop(FALSE, self);
3695     if (self->iconic)
3696         client_iconify(self, FALSE, here, FALSE);
3697     if (self->desktop != DESKTOP_ALL &&
3698         self->desktop != screen_desktop)
3699     {
3700         if (here)
3701             client_set_desktop(self, screen_desktop, FALSE, TRUE);
3702         else
3703             screen_set_desktop(self->desktop, FALSE);
3704     } else if (!self->frame->visible)
3705         /* if its not visible for other reasons, then don't mess
3706            with it */
3707         return;
3708     if (self->shaded && unshade)
3709         client_shade(self, FALSE);
3710     if (raise)
3711         stacking_raise(CLIENT_AS_WINDOW(self));
3712
3713     client_focus(self);
3714 }
3715
3716 void client_activate(ObClient *self, gboolean here, gboolean raise,
3717                      gboolean unshade, gboolean user)
3718 {
3719     client_present(self, here, raise, unshade);
3720 }
3721
3722 static void client_bring_windows_recursive(ObClient *self,
3723                                            guint desktop,
3724                                            gboolean helpers,
3725                                            gboolean modals,
3726                                            gboolean iconic)
3727 {
3728     GSList *it;
3729
3730     for (it = self->transients; it; it = g_slist_next(it))
3731         client_bring_windows_recursive(it->data, desktop,
3732                                        helpers, modals, iconic);
3733
3734     if (((helpers && client_helper(self)) ||
3735          (modals && self->modal)) &&
3736         ((self->desktop != desktop && self->desktop != DESKTOP_ALL) ||
3737          (iconic && self->iconic)))
3738     {
3739         if (iconic && self->iconic)
3740             client_iconify(self, FALSE, TRUE, FALSE);
3741         else
3742             client_set_desktop(self, desktop, FALSE, FALSE);
3743     }
3744 }
3745
3746 void client_bring_helper_windows(ObClient *self)
3747 {
3748     client_bring_windows_recursive(self, self->desktop, TRUE, FALSE, FALSE);
3749 }
3750
3751 void client_bring_modal_windows(ObClient *self)
3752 {
3753     client_bring_windows_recursive(self, self->desktop, FALSE, TRUE, TRUE);
3754 }
3755
3756 gboolean client_focused(ObClient *self)
3757 {
3758     return self == focus_client;
3759 }
3760
3761 static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h)
3762 {
3763     guint i;
3764     gulong min_diff, min_i;
3765
3766     if (!self->nicons) {
3767         ObClientIcon *parent = NULL;
3768         GSList *it;
3769
3770         for (it = self->parents; it; it = g_slist_next(it)) {
3771             ObClient *c = it->data;
3772             if ((parent = client_icon_recursive(c, w, h)))
3773                 break;
3774         }
3775
3776         return parent;
3777     }
3778
3779     /* some kind of crappy approximation to find the icon closest in size to
3780        what we requested, but icons are generally all the same ratio as
3781        eachother so it's good enough. */
3782
3783     min_diff = ABS(self->icons[0].width - w) + ABS(self->icons[0].height - h);
3784     min_i = 0;
3785
3786     for (i = 1; i < self->nicons; ++i) {
3787         gulong diff;
3788
3789         diff = ABS(self->icons[i].width - w) + ABS(self->icons[i].height - h);
3790         if (diff < min_diff) {
3791             min_diff = diff;
3792             min_i = i;
3793         }
3794     }
3795     return &self->icons[min_i];
3796 }
3797
3798 const ObClientIcon* client_icon(ObClient *self, gint w, gint h)
3799 {
3800     ObClientIcon *ret;
3801     static ObClientIcon deficon;
3802
3803     if (!(ret = client_icon_recursive(self, w, h))) {
3804         deficon.width = deficon.height = 48;
3805         deficon.data = ob_rr_theme->def_win_icon;
3806         ret = &deficon;
3807     }
3808     return ret;
3809 }
3810
3811 void client_set_layer(ObClient *self, gint layer)
3812 {
3813     if (layer < 0) {
3814         self->below = TRUE;
3815         self->above = FALSE;
3816     } else if (layer == 0) {
3817         self->below = self->above = FALSE;
3818     } else {
3819         self->below = FALSE;
3820         self->above = TRUE;
3821     }
3822     client_calc_layer(self);
3823     client_change_state(self); /* reflect this in the state hints */
3824 }
3825
3826 void client_set_undecorated(ObClient *self, gboolean undecorated)
3827 {
3828     if (self->undecorated != undecorated &&
3829         /* don't let it undecorate if the function is missing, but let
3830            it redecorate */
3831         (self->functions & OB_CLIENT_FUNC_UNDECORATE || !undecorated))
3832     {
3833         self->undecorated = undecorated;
3834         client_setup_decor_and_functions(self, TRUE);
3835         client_change_state(self); /* reflect this in the state hints */
3836     }
3837 }
3838
3839 guint client_monitor(ObClient *self)
3840 {
3841     return screen_find_monitor(&self->frame->area);
3842 }
3843
3844 ObClient *client_direct_parent(ObClient *self)
3845 {
3846     if (!self->parents) return NULL;
3847     if (self->transient_for_group) return NULL;
3848     return self->parents->data;
3849 }
3850
3851 ObClient *client_search_top_direct_parent(ObClient *self)
3852 {
3853     ObClient *p;
3854     while ((p = client_direct_parent(self))) self = p;
3855     return self;
3856 }
3857
3858 static GSList *client_search_all_top_parents_internal(ObClient *self,
3859                                                       gboolean bylayer,
3860                                                       ObStackingLayer layer)
3861 {
3862     GSList *ret;
3863     ObClient *p;
3864
3865     /* move up the direct transient chain as far as possible */
3866     while ((p = client_direct_parent(self)) &&
3867            (!bylayer || p->layer == layer))
3868         self = p;
3869
3870     if (!self->parents)
3871         ret = g_slist_prepend(NULL, self);
3872     else
3873         ret = g_slist_copy(self->parents);
3874
3875     return ret;
3876 }
3877
3878 GSList *client_search_all_top_parents(ObClient *self)
3879 {
3880     return client_search_all_top_parents_internal(self, FALSE, 0);
3881 }
3882
3883 GSList *client_search_all_top_parents_layer(ObClient *self)
3884 {
3885     return client_search_all_top_parents_internal(self, TRUE, self->layer);
3886 }
3887
3888 ObClient *client_search_focus_parent(ObClient *self)
3889 {
3890     GSList *it;
3891
3892     for (it = self->parents; it; it = g_slist_next(it))
3893         if (client_focused(it->data)) return it->data;
3894
3895     return NULL;
3896 }
3897
3898 ObClient *client_search_parent(ObClient *self, ObClient *search)
3899 {
3900     GSList *it;
3901
3902     for (it = self->parents; it; it = g_slist_next(it))
3903         if (it->data == search) return search;
3904
3905     return NULL;
3906 }
3907
3908 ObClient *client_search_transient(ObClient *self, ObClient *search)
3909 {
3910     GSList *sit;
3911
3912     for (sit = self->transients; sit; sit = g_slist_next(sit)) {
3913         if (sit->data == search)
3914             return search;
3915         if (client_search_transient(sit->data, search))
3916             return search;
3917     }
3918     return NULL;
3919 }
3920
3921 static void detect_edge(Rect area, ObDirection dir,
3922                         gint my_head, gint my_size,
3923                         gint my_edge_start, gint my_edge_size,
3924                         gint *dest, gboolean *near_edge)
3925 {
3926     gint edge_start, edge_size, head, tail;
3927     gboolean skip_head = FALSE, skip_tail = FALSE;
3928
3929     switch (dir) {
3930         case OB_DIRECTION_NORTH:
3931         case OB_DIRECTION_SOUTH:
3932             edge_start = area.x;
3933             edge_size = area.width;
3934             break;
3935         case OB_DIRECTION_EAST:
3936         case OB_DIRECTION_WEST:
3937             edge_start = area.y;
3938             edge_size = area.height;
3939             break;
3940         default:
3941             g_assert_not_reached();
3942     }
3943
3944     /* do we collide with this window? */
3945     if (!RANGES_INTERSECT(my_edge_start, my_edge_size,
3946                 edge_start, edge_size))
3947         return;
3948
3949     switch (dir) {
3950         case OB_DIRECTION_NORTH:
3951             head = RECT_BOTTOM(area);
3952             tail = RECT_TOP(area);
3953             break;
3954         case OB_DIRECTION_SOUTH:
3955             head = RECT_TOP(area);
3956             tail = RECT_BOTTOM(area);
3957             break;
3958         case OB_DIRECTION_WEST:
3959             head = RECT_RIGHT(area);
3960             tail = RECT_LEFT(area);
3961             break;
3962         case OB_DIRECTION_EAST:
3963             head = RECT_LEFT(area);
3964             tail = RECT_RIGHT(area);
3965             break;
3966         default:
3967             g_assert_not_reached();
3968     }
3969     switch (dir) {
3970         case OB_DIRECTION_NORTH:
3971         case OB_DIRECTION_WEST:
3972             /* check if our window is past the head of this window */
3973             if (my_head <= head + 1)
3974                 skip_head = TRUE;
3975             /* check if our window's tail is past the tail of this window */
3976             if (my_head + my_size - 1 <= tail)
3977                 skip_tail = TRUE;
3978             /* check if the head of this window is closer than the previously
3979                chosen edge (take into account that the previously chosen
3980                edge might have been a tail, not a head) */
3981             if (head + (*near_edge ? 0 : my_size) < *dest)
3982                 skip_head = TRUE;
3983             /* check if the tail of this window is closer than the previously
3984                chosen edge (take into account that the previously chosen
3985                edge might have been a head, not a tail) */
3986             if (tail - (!*near_edge ? 0 : my_size) < *dest)
3987                 skip_tail = TRUE;
3988             break;
3989         case OB_DIRECTION_SOUTH:
3990         case OB_DIRECTION_EAST:
3991             /* check if our window is past the head of this window */
3992             if (my_head >= head - 1)
3993                 skip_head = TRUE;
3994             /* check if our window's tail is past the tail of this window */
3995             if (my_head - my_size + 1 >= tail)
3996                 skip_tail = TRUE;
3997             /* check if the head of this window is closer than the previously
3998                chosen edge (take into account that the previously chosen
3999                edge might have been a tail, not a head) */
4000             if (head - (*near_edge ? 0 : my_size) > *dest)
4001                 skip_head = TRUE;
4002             /* check if the tail of this window is closer than the previously
4003                chosen edge (take into account that the previously chosen
4004                edge might have been a head, not a tail) */
4005             if (tail + (!*near_edge ? 0 : my_size) > *dest)
4006                 skip_tail = TRUE;
4007             break;
4008         default:
4009             g_assert_not_reached();
4010     }
4011
4012     ob_debug("my head %d size %d\n", my_head, my_size);
4013     ob_debug("head %d tail %d deest %d\n", head, tail, *dest);
4014     if (!skip_head) {
4015         ob_debug("using near edge %d\n", head);
4016         *dest = head;
4017         *near_edge = TRUE;
4018     }
4019     else if (!skip_tail) {
4020         ob_debug("using far edge %d\n", tail);
4021         *dest = tail;
4022         *near_edge = FALSE;
4023     }
4024 }
4025
4026 void client_find_edge_directional(ObClient *self, ObDirection dir,
4027                                   gint my_head, gint my_size,
4028                                   gint my_edge_start, gint my_edge_size,
4029                                   gint *dest, gboolean *near_edge)
4030 {
4031     GList *it;
4032     Rect *a, *mon;
4033     Rect dock_area;
4034     gint edge;
4035
4036     a = screen_area(self->desktop, SCREEN_AREA_ALL_MONITORS,
4037                     &self->frame->area);
4038     mon = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR,
4039                       &self->frame->area);
4040
4041     switch (dir) {
4042     case OB_DIRECTION_NORTH:
4043         if (my_head >= RECT_TOP(*mon) + 1)
4044             edge = RECT_TOP(*mon) - 1;
4045         else
4046             edge = RECT_TOP(*a) - 1;
4047         break;
4048     case OB_DIRECTION_SOUTH:
4049         if (my_head <= RECT_BOTTOM(*mon) - 1)
4050             edge = RECT_BOTTOM(*mon) + 1;
4051         else
4052             edge = RECT_BOTTOM(*a) + 1;
4053         break;
4054     case OB_DIRECTION_EAST:
4055         if (my_head <= RECT_RIGHT(*mon) - 1)
4056             edge = RECT_RIGHT(*mon) + 1;
4057         else
4058             edge = RECT_RIGHT(*a) + 1;
4059         break;
4060     case OB_DIRECTION_WEST:
4061         if (my_head >= RECT_LEFT(*mon) + 1)
4062             edge = RECT_LEFT(*mon) - 1;
4063         else
4064             edge = RECT_LEFT(*a) - 1;
4065         break;
4066     default:
4067         g_assert_not_reached();
4068     }
4069     /* default to the far edge, then narrow it down */
4070     *dest = edge;
4071     *near_edge = TRUE;
4072
4073     for (it = client_list; it; it = g_list_next(it)) {
4074         ObClient *cur = it->data;
4075
4076         /* skip windows to not bump into */
4077         if (cur == self)
4078             continue;
4079         if (cur->iconic)
4080             continue;
4081         if (self->desktop != cur->desktop && cur->desktop != DESKTOP_ALL &&
4082             cur->desktop != screen_desktop)
4083             continue;
4084
4085         ob_debug("trying window %s\n", cur->title);
4086
4087         detect_edge(cur->frame->area, dir, my_head, my_size, my_edge_start,
4088                     my_edge_size, dest, near_edge);
4089     }
4090     dock_get_area(&dock_area);
4091     detect_edge(dock_area, dir, my_head, my_size, my_edge_start,
4092                 my_edge_size, dest, near_edge);
4093     g_free(a);
4094     g_free(mon);
4095 }
4096
4097 void client_find_move_directional(ObClient *self, ObDirection dir,
4098                                   gint *x, gint *y)
4099 {
4100     gint head, size;
4101     gint e, e_start, e_size;
4102     gboolean near;
4103
4104     switch (dir) {
4105     case OB_DIRECTION_EAST:
4106         head = RECT_RIGHT(self->frame->area);
4107         size = self->frame->area.width;
4108         e_start = RECT_TOP(self->frame->area);
4109         e_size = self->frame->area.height;
4110         break;
4111     case OB_DIRECTION_WEST:
4112         head = RECT_LEFT(self->frame->area);
4113         size = self->frame->area.width;
4114         e_start = RECT_TOP(self->frame->area);
4115         e_size = self->frame->area.height;
4116         break;
4117     case OB_DIRECTION_NORTH:
4118         head = RECT_TOP(self->frame->area);
4119         size = self->frame->area.height;
4120         e_start = RECT_LEFT(self->frame->area);
4121         e_size = self->frame->area.width;
4122         break;
4123     case OB_DIRECTION_SOUTH:
4124         head = RECT_BOTTOM(self->frame->area);
4125         size = self->frame->area.height;
4126         e_start = RECT_LEFT(self->frame->area);
4127         e_size = self->frame->area.width;
4128         break;
4129     default:
4130         g_assert_not_reached();
4131     }
4132
4133     client_find_edge_directional(self, dir, head, size,
4134                                  e_start, e_size, &e, &near);
4135     *x = self->frame->area.x;
4136     *y = self->frame->area.y;
4137     switch (dir) {
4138     case OB_DIRECTION_EAST:
4139         if (near) e -= self->frame->area.width;
4140         else      e++;
4141         *x = e;
4142         break;
4143     case OB_DIRECTION_WEST:
4144         if (near) e++;
4145         else      e -= self->frame->area.width;
4146         *x = e;
4147         break;
4148     case OB_DIRECTION_NORTH:
4149         if (near) e++;
4150         else      e -= self->frame->area.height;
4151         *y = e;
4152         break;
4153     case OB_DIRECTION_SOUTH:
4154         if (near) e -= self->frame->area.height;
4155         else      e++;
4156         *y = e;
4157         break;
4158     default:
4159         g_assert_not_reached();
4160     }
4161     frame_frame_gravity(self->frame, x, y);
4162 }
4163
4164 void client_find_resize_directional(ObClient *self, ObDirection side,
4165                                     gboolean grow,
4166                                     gint *x, gint *y, gint *w, gint *h)
4167 {
4168     gint head;
4169     gint e, e_start, e_size, delta;
4170     gboolean near;
4171     ObDirection dir;
4172
4173     switch (side) {
4174     case OB_DIRECTION_EAST:
4175         head = RECT_RIGHT(self->frame->area) +
4176             (self->size_inc.width - 1) * (grow ? 1 : -1);
4177         e_start = RECT_TOP(self->frame->area);
4178         e_size = self->frame->area.height;
4179         dir = grow ? OB_DIRECTION_EAST : OB_DIRECTION_WEST;
4180         break;
4181     case OB_DIRECTION_WEST:
4182         head = RECT_LEFT(self->frame->area) -
4183             (self->size_inc.width - 1) * (grow ? 1 : -1);
4184         e_start = RECT_TOP(self->frame->area);
4185         e_size = self->frame->area.height;
4186         dir = grow ? OB_DIRECTION_WEST : OB_DIRECTION_EAST;
4187         break;
4188     case OB_DIRECTION_NORTH:
4189         head = RECT_TOP(self->frame->area) -
4190             (self->size_inc.height - 1) * (grow ? 1 : -1);
4191         e_start = RECT_LEFT(self->frame->area);
4192         e_size = self->frame->area.width;
4193         dir = grow ? OB_DIRECTION_NORTH : OB_DIRECTION_SOUTH;
4194         break;
4195     case OB_DIRECTION_SOUTH:
4196         head = RECT_BOTTOM(self->frame->area) +
4197             (self->size_inc.height - 1) * (grow ? 1 : -1);
4198         e_start = RECT_LEFT(self->frame->area);
4199         e_size = self->frame->area.width;
4200         dir = grow ? OB_DIRECTION_SOUTH : OB_DIRECTION_NORTH;
4201         break;
4202     default:
4203         g_assert_not_reached();
4204     }
4205
4206     ob_debug("head %d dir %d\n", head, dir);
4207     client_find_edge_directional(self, dir, head, 1,
4208                                  e_start, e_size, &e, &near);
4209     ob_debug("edge %d\n", e);
4210     *x = self->frame->area.x;
4211     *y = self->frame->area.y;
4212     *w = self->frame->area.width;
4213     *h = self->frame->area.height;
4214     switch (side) {
4215     case OB_DIRECTION_EAST:
4216         if (grow == near) --e;
4217         delta = e - RECT_RIGHT(self->frame->area);
4218         *w += delta;
4219         break;
4220     case OB_DIRECTION_WEST:
4221         if (grow == near) ++e;
4222         delta = RECT_LEFT(self->frame->area) - e;
4223         *x -= delta;
4224         *w += delta;
4225         break;
4226     case OB_DIRECTION_NORTH:
4227         if (grow == near) ++e;
4228         delta = RECT_TOP(self->frame->area) - e;
4229         *y -= delta;
4230         *h += delta;
4231         break;
4232     case OB_DIRECTION_SOUTH:
4233         if (grow == near) --e;
4234         delta = e - RECT_BOTTOM(self->frame->area);
4235         *h += delta;
4236         break;
4237     default:
4238         g_assert_not_reached();
4239     }
4240     frame_frame_gravity(self->frame, x, y);
4241     *w -= self->frame->size.left + self->frame->size.right;
4242     *h -= self->frame->size.top + self->frame->size.bottom;
4243 }
4244
4245 ObClient* client_under_pointer(void)
4246 {
4247     gint x, y;
4248     GList *it;
4249     ObClient *ret = NULL;
4250
4251     if (screen_pointer_pos(&x, &y)) {
4252         for (it = stacking_list; it; it = g_list_next(it)) {
4253             if (WINDOW_IS_CLIENT(it->data)) {
4254                 ObClient *c = WINDOW_AS_CLIENT(it->data);
4255                 if (c->frame->visible &&
4256                     /* check the desktop, this is done during desktop
4257                        switching and windows are shown/hidden status is not
4258                        reliable */
4259                     (c->desktop == screen_desktop ||
4260                      c->desktop == DESKTOP_ALL) &&
4261                     /* ignore all animating windows */
4262                     !frame_iconify_animating(c->frame) &&
4263                     RECT_CONTAINS(c->frame->area, x, y))
4264                 {
4265                     ret = c;
4266                     break;
4267                 }
4268             }
4269         }
4270     }
4271     return ret;
4272 }
4273
4274 gboolean client_has_group_siblings(ObClient *self)
4275 {
4276     return self->group && self->group->members->next;
4277 }