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