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