openbox/client.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    client.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "client.h"
  21 #include "debug.h"
  22 #include "startupnotify.h"
  23 #include "dock.h"
  24 #include "xerror.h"
  25 #include "screen.h"
  26 #include "moveresize.h"
  27 #include "ping.h"
  28 #include "place.h"
  29 #include "prop.h"
  30 #include "extensions.h"
  31 #include "frame.h"
  32 #include "session.h"
  33 #include "event.h"
  34 #include "grab.h"
  35 #include "prompt.h"
  36 #include "focus.h"
  37 #include "stacking.h"
  38 #include "openbox.h"
  39 #include "group.h"
  40 #include "config.h"
  41 #include "menuframe.h"
  42 #include "keyboard.h"
  43 #include "mouse.h"
  44 #include "render/render.h"
  45 #include "gettext.h"
  46
  47 #ifdef HAVE_UNISTD_H
  48 #  include <unistd.h>
  49 #endif
  50
  51 #ifdef HAVE_SIGNAL_H
  52 #  include <signal.h> /* for kill() */
  53 #endif
  54
  55 #include <glib.h>
  56 #include <X11/Xutil.h>
  57
  58 /*! The event mask to grab on client windows */
  59 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
  60                           ColormapChangeMask)
  61
  62 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
  63                                 ButtonMotionMask)
  64
  65 typedef struct
  66 {
  67     ObClientCallback func;
  68     gpointer data;
  69 } ClientCallback;
  70
  71 GList          *client_list             = NULL;
  72
  73 static GSList  *client_destroy_notifies = NULL;
  74 static RrImage *client_default_icon     = NULL;
  75
  76 static void client_get_all(ObClient *self, gboolean real);
  77 static void client_get_startup_id(ObClient *self);
  78 static void client_get_session_ids(ObClient *self);
  79 static void client_get_area(ObClient *self);
  80 static void client_get_desktop(ObClient *self);
  81 static void client_get_state(ObClient *self);
  82 static void client_get_shaped(ObClient *self);
  83 static void client_get_mwm_hints(ObClient *self);
  84 static void client_get_colormap(ObClient *self);
  85 static void client_set_desktop_recursive(ObClient *self,
  86                                          guint target,
  87                                          gboolean donthide,
  88                                          gboolean dontraise);
  89 static void client_change_allowed_actions(ObClient *self);
  90 static void client_change_state(ObClient *self);
  91 static void client_change_wm_state(ObClient *self);
  92 static void client_apply_startup_state(ObClient *self,
  93                                        gint x, gint y, gint w, gint h);
  94 static void client_restore_session_state(ObClient *self);
  95 static gboolean client_restore_session_stacking(ObClient *self);
  96 static ObAppSettings *client_get_settings_state(ObClient *self);
  97 static void client_update_transient_tree(ObClient *self,
  98                                          ObGroup *oldgroup, ObGroup *newgroup,
  99                                          gboolean oldgtran, gboolean newgtran,
 100                                          ObClient* oldparent,
 101                                          ObClient *newparent);
 102 static void client_present(ObClient *self, gboolean here, gboolean raise,
 103                            gboolean unshade);
 104 static GSList *client_search_all_top_parents_internal(ObClient *self,
 105                                                       gboolean bylayer,
 106                                                       ObStackingLayer layer);
 107 static void client_call_notifies(ObClient *self, GSList *list);
 108 static void client_ping_event(ObClient *self, gboolean dead);
 109 static void client_prompt_kill(ObClient *self);
 110
 111 void client_startup(gboolean reconfig)
 112 {
 113     if ((client_default_icon = RrImageCacheFind(ob_rr_icons,
 114                                                 ob_rr_theme->def_win_icon,
 115                                                 ob_rr_theme->def_win_icon_w,
 116                                                 ob_rr_theme->def_win_icon_h)))
 117         RrImageRef(client_default_icon);
 118     else {
 119         client_default_icon = RrImageNew(ob_rr_icons);
 120         RrImageAddPicture(client_default_icon,
 121                           ob_rr_theme->def_win_icon,
 122                           ob_rr_theme->def_win_icon_w,
 123                           ob_rr_theme->def_win_icon_h);
 124     }
 125
 126     if (reconfig) return;
 127
 128     client_set_list();
 129 }
 130
 131 void client_shutdown(gboolean reconfig)
 132 {
 133     RrImageUnref(client_default_icon);
 134     client_default_icon = NULL;
 135
 136     if (reconfig) return;
 137 }
 138
 139 static void client_call_notifies(ObClient *self, GSList *list)
 140 {
 141     GSList *it;
 142
 143     for (it = list; it; it = g_slist_next(it)) {
 144         ClientCallback *d = it->data;
 145         d->func(self, d->data);
 146     }
 147 }
 148
 149 void client_add_destroy_notify(ObClientCallback func, gpointer data)
 150 {
 151     ClientCallback *d = g_new(ClientCallback, 1);
 152     d->func = func;
 153     d->data = data;
 154     client_destroy_notifies = g_slist_prepend(client_destroy_notifies, d);
 155 }
 156
 157 void client_remove_destroy_notify(ObClientCallback func)
 158 {
 159     GSList *it;
 160
 161     for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
 162         ClientCallback *d = it->data;
 163         if (d->func == func) {
 164             g_free(d);
 165             client_destroy_notifies =
 166                 g_slist_delete_link(client_destroy_notifies, it);
 167             break;
 168         }
 169     }
 170 }
 171
 172 void client_set_list(void)
 173 {
 174     Window *windows, *win_it;
 175     GList *it;
 176     guint size = g_list_length(client_list);
 177
 178     /* create an array of the window ids */
 179     if (size > 0) {
 180         windows = g_new(Window, size);
 181         win_it = windows;
 182         for (it = client_list; it; it = g_list_next(it), ++win_it)
 183             *win_it = ((ObClient*)it->data)->window;
 184     } else
 185         windows = NULL;
 186
 187     PROP_SETA32(RootWindow(ob_display, ob_screen),
 188                 net_client_list, window, (gulong*)windows, size);
 189
 190     if (windows)
 191         g_free(windows);
 192
 193     stacking_set_list();
 194 }
 195
 196 void client_manage_all(void)
 197 {
 198     guint i, j, nchild;
 199     Window w, *children;
 200     XWMHints *wmhints;
 201     XWindowAttributes attrib;
 202
 203     XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
 204                &w, &w, &children, &nchild);
 205
 206     /* remove all icon windows from the list */
 207     for (i = 0; i < nchild; i++) {
 208         if (children[i] == None) continue;
 209         wmhints = XGetWMHints(ob_display, children[i]);
 210         if (wmhints) {
 211             if ((wmhints->flags & IconWindowHint) &&
 212                 (wmhints->icon_window != children[i]))
 213                 for (j = 0; j < nchild; j++)
 214                     if (children[j] == wmhints->icon_window) {
 215                         children[j] = None;
 216                         break;
 217                     }
 218             XFree(wmhints);
 219         }
 220     }
 221
 222     /* manage windows in reverse order from how they were originally mapped.
 223        this is an attempt to manage children windows before their parents, so
 224        that when the parent is mapped, it can find the child */
 225     for (i = 0; i < nchild; ++i) {
 226         if (children[i] == None)
 227             continue;
 228         if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
 229             if (attrib.override_redirect) continue;
 230
 231             if (attrib.map_state != IsUnmapped)
 232                 client_manage(children[i], NULL);
 233         }
 234     }
 235     XFree(children);
 236 }
 237
 238 void client_manage(Window window, ObPrompt *prompt)
 239 {
 240     ObClient *self;
 241     XEvent e;
 242     XWindowAttributes attrib;
 243     XSetWindowAttributes attrib_set;
 244     XWMHints *wmhint;
 245     gboolean activate = FALSE;
 246     ObAppSettings *settings;
 247     gboolean transient = FALSE;
 248     Rect place, *monitor;
 249     Time launch_time, map_time;
 250     guint32 user_time;
 251
 252     grab_server(TRUE);
 253
 254     /* check if it has already been unmapped by the time we started
 255        mapping. the grab does a sync so we don't have to here */
 256     if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
 257         XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e))
 258     {
 259         XPutBackEvent(ob_display, &e);
 260
 261         ob_debug("Trying to manage unmapped window. Aborting that.\n");
 262         grab_server(FALSE);
 263         return; /* don't manage it */
 264     }
 265
 266     /* make sure it isn't an override-redirect window */
 267     if (!XGetWindowAttributes(ob_display, window, &attrib) ||
 268         attrib.override_redirect)
 269     {
 270         grab_server(FALSE);
 271         return; /* don't manage it */
 272     }
 273
 274     /* is the window a docking app */
 275     if ((wmhint = XGetWMHints(ob_display, window))) {
 276         if ((wmhint->flags & StateHint) &&
 277             wmhint->initial_state == WithdrawnState)
 278         {
 279             dock_add(window, wmhint);
 280             grab_server(FALSE);
 281             XFree(wmhint);
 282             return;
 283         }
 284         XFree(wmhint);
 285     }
 286
 287     ob_debug("Managing window: 0x%lx\n", window);
 288
 289     map_time = event_get_server_time();
 290
 291     /* choose the events we want to receive on the CLIENT window
 292        (ObPrompt windows can request events too) */
 293     attrib_set.event_mask = CLIENT_EVENTMASK |
 294         (prompt ? prompt->event_mask : 0);
 295     attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
 296     XChangeWindowAttributes(ob_display, window,
 297                             CWEventMask|CWDontPropagate, &attrib_set);
 298
 299     /* create the ObClient struct, and populate it from the hints on the
 300        window */
 301     self = g_new0(ObClient, 1);
 302     self->obwin.type = Window_Client;
 303     self->window = window;
 304     self->prompt = prompt;
 305
 306     /* non-zero defaults */
 307     self->wmstate = WithdrawnState; /* make sure it gets updated first time */
 308     self->gravity = NorthWestGravity;
 309     self->desktop = screen_num_desktops; /* always an invalid value */
 310
 311     /* get all the stuff off the window */
 312     client_get_all(self, TRUE);
 313
 314     ob_debug("Window type: %d\n", self->type);
 315     ob_debug("Window group: 0x%x\n", self->group?self->group->leader:0);
 316     ob_debug("Window name: %s class: %s\n", self->name, self->class);
 317
 318     /* now we have all of the window's information so we can set this up.
 319        do this before creating the frame, so it can tell that we are still
 320        mapping and doesn't go applying things right away */
 321     client_setup_decor_and_functions(self, FALSE);
 322
 323     /* specify that if we exit, the window should not be destroyed and
 324        should be reparented back to root automatically, unless we are managing
 325        an internal ObPrompt window  */
 326     if (!self->prompt)
 327         XChangeSaveSet(ob_display, window, SetModeInsert);
 328
 329     /* create the decoration frame for the client window */
 330     self->frame = frame_new(self);
 331
 332     frame_grab_client(self->frame);
 333
 334     /* we've grabbed everything and set everything that we need to at mapping
 335        time now */
 336     grab_server(FALSE);
 337
 338     /* per-app settings override stuff from client_get_all, and return the
 339        settings for other uses too. the returned settings is a shallow copy,
 340        that needs to be freed with g_free(). */
 341     settings = client_get_settings_state(self);
 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 static 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 gboolean client_validate(ObClient *self)
3594 {
3595     XEvent e;
3596
3597     XSync(ob_display, FALSE); /* get all events on the server */
3598
3599     if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
3600         XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
3601         XPutBackEvent(ob_display, &e);
3602         return FALSE;
3603     }
3604
3605     return TRUE;
3606 }
3607
3608 void client_set_wm_state(ObClient *self, glong state)
3609 {
3610     if (state == self->wmstate) return; /* no change */
3611
3612     switch (state) {
3613     case IconicState:
3614         client_iconify(self, TRUE, TRUE, FALSE);
3615         break;
3616     case NormalState:
3617         client_iconify(self, FALSE, TRUE, FALSE);
3618         break;
3619     }
3620 }
3621
3622 void client_set_state(ObClient *self, Atom action, glong data1, glong data2)
3623 {
3624     gboolean shaded = self->shaded;
3625     gboolean fullscreen = self->fullscreen;
3626     gboolean undecorated = self->undecorated;
3627     gboolean max_horz = self->max_horz;
3628     gboolean max_vert = self->max_vert;
3629     gboolean modal = self->modal;
3630     gboolean iconic = self->iconic;
3631     gboolean demands_attention = self->demands_attention;
3632     gboolean above = self->above;
3633     gboolean below = self->below;
3634     gint i;
3635
3636     if (!(action == prop_atoms.net_wm_state_add ||
3637           action == prop_atoms.net_wm_state_remove ||
3638           action == prop_atoms.net_wm_state_toggle))
3639         /* an invalid action was passed to the client message, ignore it */
3640         return;
3641
3642     for (i = 0; i < 2; ++i) {
3643         Atom state = i == 0 ? data1 : data2;
3644
3645         if (!state) continue;
3646
3647         /* if toggling, then pick whether we're adding or removing */
3648         if (action == prop_atoms.net_wm_state_toggle) {
3649             if (state == prop_atoms.net_wm_state_modal)
3650                 action = modal ? prop_atoms.net_wm_state_remove :
3651                     prop_atoms.net_wm_state_add;
3652             else if (state == prop_atoms.net_wm_state_maximized_vert)
3653                 action = self->max_vert ? prop_atoms.net_wm_state_remove :
3654                     prop_atoms.net_wm_state_add;
3655             else if (state == prop_atoms.net_wm_state_maximized_horz)
3656                 action = self->max_horz ? prop_atoms.net_wm_state_remove :
3657                     prop_atoms.net_wm_state_add;
3658             else if (state == prop_atoms.net_wm_state_shaded)
3659                 action = shaded ? prop_atoms.net_wm_state_remove :
3660                     prop_atoms.net_wm_state_add;
3661             else if (state == prop_atoms.net_wm_state_skip_taskbar)
3662                 action = self->skip_taskbar ?
3663                     prop_atoms.net_wm_state_remove :
3664                     prop_atoms.net_wm_state_add;
3665             else if (state == prop_atoms.net_wm_state_skip_pager)
3666                 action = self->skip_pager ?
3667                     prop_atoms.net_wm_state_remove :
3668                     prop_atoms.net_wm_state_add;
3669             else if (state == prop_atoms.net_wm_state_hidden)
3670                 action = self->iconic ?
3671                     prop_atoms.net_wm_state_remove :
3672                     prop_atoms.net_wm_state_add;
3673             else if (state == prop_atoms.net_wm_state_fullscreen)
3674                 action = fullscreen ?
3675                     prop_atoms.net_wm_state_remove :
3676                     prop_atoms.net_wm_state_add;
3677             else if (state == prop_atoms.net_wm_state_above)
3678                 action = self->above ? prop_atoms.net_wm_state_remove :
3679                     prop_atoms.net_wm_state_add;
3680             else if (state == prop_atoms.net_wm_state_below)
3681                 action = self->below ? prop_atoms.net_wm_state_remove :
3682                     prop_atoms.net_wm_state_add;
3683             else if (state == prop_atoms.net_wm_state_demands_attention)
3684                 action = self->demands_attention ?
3685                     prop_atoms.net_wm_state_remove :
3686                     prop_atoms.net_wm_state_add;
3687             else if (state == prop_atoms.ob_wm_state_undecorated)
3688                 action = undecorated ? prop_atoms.net_wm_state_remove :
3689                     prop_atoms.net_wm_state_add;
3690         }
3691
3692         if (action == prop_atoms.net_wm_state_add) {
3693             if (state == prop_atoms.net_wm_state_modal) {
3694                 modal = TRUE;
3695             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3696                 max_vert = TRUE;
3697             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3698                 max_horz = TRUE;
3699             } else if (state == prop_atoms.net_wm_state_shaded) {
3700                 shaded = TRUE;
3701             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3702                 self->skip_taskbar = TRUE;
3703             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3704                 self->skip_pager = TRUE;
3705             } else if (state == prop_atoms.net_wm_state_hidden) {
3706                 iconic = TRUE;
3707             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3708                 fullscreen = TRUE;
3709             } else if (state == prop_atoms.net_wm_state_above) {
3710                 above = TRUE;
3711                 below = FALSE;
3712             } else if (state == prop_atoms.net_wm_state_below) {
3713                 above = FALSE;
3714                 below = TRUE;
3715             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3716                 demands_attention = TRUE;
3717             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3718                 undecorated = TRUE;
3719             }
3720
3721         } else { /* action == prop_atoms.net_wm_state_remove */
3722             if (state == prop_atoms.net_wm_state_modal) {
3723                 modal = FALSE;
3724             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3725                 max_vert = FALSE;
3726             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3727                 max_horz = FALSE;
3728             } else if (state == prop_atoms.net_wm_state_shaded) {
3729                 shaded = FALSE;
3730             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3731                 self->skip_taskbar = FALSE;
3732             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3733                 self->skip_pager = FALSE;
3734             } else if (state == prop_atoms.net_wm_state_hidden) {
3735                 iconic = FALSE;
3736             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3737                 fullscreen = FALSE;
3738             } else if (state == prop_atoms.net_wm_state_above) {
3739                 above = FALSE;
3740             } else if (state == prop_atoms.net_wm_state_below) {
3741                 below = FALSE;
3742             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3743                 demands_attention = FALSE;
3744             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3745                 undecorated = FALSE;
3746             }
3747         }
3748     }
3749
3750     if (max_horz != self->max_horz || max_vert != self->max_vert) {
3751         if (max_horz != self->max_horz && max_vert != self->max_vert) {
3752             /* toggling both */
3753             if (max_horz == max_vert) { /* both going the same way */
3754                 client_maximize(self, max_horz, 0);
3755             } else {
3756                 client_maximize(self, max_horz, 1);
3757                 client_maximize(self, max_vert, 2);
3758             }
3759         } else {
3760             /* toggling one */
3761             if (max_horz != self->max_horz)
3762                 client_maximize(self, max_horz, 1);
3763             else
3764                 client_maximize(self, max_vert, 2);
3765         }
3766     }
3767     /* change fullscreen state before shading, as it will affect if the window
3768        can shade or not */
3769     if (fullscreen != self->fullscreen)
3770         client_fullscreen(self, fullscreen);
3771     if (shaded != self->shaded)
3772         client_shade(self, shaded);
3773     if (undecorated != self->undecorated)
3774         client_set_undecorated(self, undecorated);
3775     if (above != self->above || below != self->below) {
3776         self->above = above;
3777         self->below = below;
3778         client_calc_layer(self);
3779     }
3780
3781     if (modal != self->modal) {
3782         self->modal = modal;
3783         /* when a window changes modality, then its stacking order with its
3784            transients needs to change */
3785         stacking_raise(CLIENT_AS_WINDOW(self));
3786
3787         /* it also may get focused. if something is focused that shouldn't
3788            be focused anymore, then move the focus */
3789         if (focus_client && client_focus_target(focus_client) != focus_client)
3790             client_focus(focus_client);
3791     }
3792
3793     if (iconic != self->iconic)
3794         client_iconify(self, iconic, FALSE, FALSE);
3795
3796     if (demands_attention != self->demands_attention)
3797         client_hilite(self, demands_attention);
3798
3799     client_change_state(self); /* change the hint to reflect these changes */
3800 }
3801
3802 ObClient *client_focus_target(ObClient *self)
3803 {
3804     ObClient *child = NULL;
3805
3806     child = client_search_modal_child(self);
3807     if (child) return child;
3808     return self;
3809 }
3810
3811 gboolean client_can_focus(ObClient *self)
3812 {
3813     /* choose the correct target */
3814     self = client_focus_target(self);
3815
3816     if (!self->frame->visible)
3817         return FALSE;
3818
3819     if (!(self->can_focus || self->focus_notify))
3820         return FALSE;
3821
3822     return TRUE;
3823 }
3824
3825 gboolean client_focus(ObClient *self)
3826 {
3827     /* we might not focus this window, so if we have modal children which would
3828        be focused instead, bring them to this desktop */
3829     client_bring_modal_windows(self);
3830
3831     /* choose the correct target */
3832     self = client_focus_target(self);
3833
3834     if (!client_can_focus(self)) {
3835         ob_debug_type(OB_DEBUG_FOCUS,
3836                       "Client %s can't be focused\n", self->title);
3837         return FALSE;
3838     }
3839
3840     ob_debug_type(OB_DEBUG_FOCUS,
3841                   "Focusing client \"%s\" (0x%x) at time %u\n",
3842                   self->title, self->window, event_curtime);
3843
3844     /* if using focus_delay, stop the timer now so that focus doesn't
3845        go moving on us */
3846     event_halt_focus_delay();
3847
3848     event_cancel_all_key_grabs();
3849
3850     xerror_set_ignore(TRUE);
3851     xerror_occured = FALSE;
3852
3853     if (self->can_focus) {
3854         /* This can cause a BadMatch error with CurrentTime, or if an app
3855            passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3856         XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
3857                        event_curtime);
3858     }
3859
3860     if (self->focus_notify) {
3861         XEvent ce;
3862         ce.xclient.type = ClientMessage;
3863         ce.xclient.message_type = prop_atoms.wm_protocols;
3864         ce.xclient.display = ob_display;
3865         ce.xclient.window = self->window;
3866         ce.xclient.format = 32;
3867         ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
3868         ce.xclient.data.l[1] = event_curtime;
3869         ce.xclient.data.l[2] = 0l;
3870         ce.xclient.data.l[3] = 0l;
3871         ce.xclient.data.l[4] = 0l;
3872         XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3873     }
3874
3875     xerror_set_ignore(FALSE);
3876
3877     ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d\n", xerror_occured);
3878     return !xerror_occured;
3879 }
3880
3881 static void client_present(ObClient *self, gboolean here, gboolean raise,
3882                            gboolean unshade)
3883 {
3884     if (client_normal(self) && screen_showing_desktop)
3885         screen_show_desktop(FALSE, self);
3886     if (self->iconic)
3887         client_iconify(self, FALSE, here, FALSE);
3888     if (self->desktop != DESKTOP_ALL &&
3889         self->desktop != screen_desktop)
3890     {
3891         if (here)
3892             client_set_desktop(self, screen_desktop, FALSE, TRUE);
3893         else
3894             screen_set_desktop(self->desktop, FALSE);
3895     } else if (!self->frame->visible)
3896         /* if its not visible for other reasons, then don't mess
3897            with it */
3898         return;
3899     if (self->shaded && unshade)
3900         client_shade(self, FALSE);
3901     if (raise)
3902         stacking_raise(CLIENT_AS_WINDOW(self));
3903
3904     client_focus(self);
3905 }
3906
3907 /* this function exists to map to the net_active_window message in the ewmh */
3908 void client_activate(ObClient *self, gboolean here, gboolean raise,
3909                      gboolean unshade, gboolean user)
3910 {
3911     if (user || (self->desktop == DESKTOP_ALL ||
3912                  self->desktop == screen_desktop))
3913         client_present(self, here, raise, unshade);
3914     else
3915         client_hilite(self, TRUE);
3916 }
3917
3918 static void client_bring_windows_recursive(ObClient *self,
3919                                            guint desktop,
3920                                            gboolean helpers,
3921                                            gboolean modals,
3922                                            gboolean iconic)
3923 {
3924     GSList *it;
3925
3926     for (it = self->transients; it; it = g_slist_next(it))
3927         client_bring_windows_recursive(it->data, desktop,
3928                                        helpers, modals, iconic);
3929
3930     if (((helpers && client_helper(self)) ||
3931          (modals && self->modal)) &&
3932         ((self->desktop != desktop && self->desktop != DESKTOP_ALL) ||
3933          (iconic && self->iconic)))
3934     {
3935         if (iconic && self->iconic)
3936             client_iconify(self, FALSE, TRUE, FALSE);
3937         else
3938             client_set_desktop(self, desktop, FALSE, FALSE);
3939     }
3940 }
3941
3942 void client_bring_helper_windows(ObClient *self)
3943 {
3944     client_bring_windows_recursive(self, self->desktop, TRUE, FALSE, FALSE);
3945 }
3946
3947 void client_bring_modal_windows(ObClient *self)
3948 {
3949     client_bring_windows_recursive(self, self->desktop, FALSE, TRUE, TRUE);
3950 }
3951
3952 gboolean client_focused(ObClient *self)
3953 {
3954     return self == focus_client;
3955 }
3956
3957 RrImage* client_icon(ObClient *self)
3958 {
3959     RrImage *ret = NULL;
3960
3961     if (self->icon_set)
3962         ret = self->icon_set;
3963     else if (self->parents) {
3964         GSList *it;
3965         for (it = self->parents; it && !ret; it = g_slist_next(it))
3966             ret = client_icon(it->data);
3967     }
3968     if (!ret)
3969         ret = client_default_icon;
3970     return ret;
3971 }
3972
3973 void client_set_layer(ObClient *self, gint layer)
3974 {
3975     if (layer < 0) {
3976         self->below = TRUE;
3977         self->above = FALSE;
3978     } else if (layer == 0) {
3979         self->below = self->above = FALSE;
3980     } else {
3981         self->below = FALSE;
3982         self->above = TRUE;
3983     }
3984     client_calc_layer(self);
3985     client_change_state(self); /* reflect this in the state hints */
3986 }
3987
3988 void client_set_undecorated(ObClient *self, gboolean undecorated)
3989 {
3990     if (self->undecorated != undecorated &&
3991         /* don't let it undecorate if the function is missing, but let
3992            it redecorate */
3993         (self->functions & OB_CLIENT_FUNC_UNDECORATE || !undecorated))
3994     {
3995         self->undecorated = undecorated;
3996         client_setup_decor_and_functions(self, TRUE);
3997         client_change_state(self); /* reflect this in the state hints */
3998     }
3999 }
4000
4001 guint client_monitor(ObClient *self)
4002 {
4003     return screen_find_monitor(&self->frame->area);
4004 }
4005
4006 ObClient *client_direct_parent(ObClient *self)
4007 {
4008     if (!self->parents) return NULL;
4009     if (self->transient_for_group) return NULL;
4010     return self->parents->data;
4011 }
4012
4013 ObClient *client_search_top_direct_parent(ObClient *self)
4014 {
4015     ObClient *p;
4016     while ((p = client_direct_parent(self))) self = p;
4017     return self;
4018 }
4019
4020 static GSList *client_search_all_top_parents_internal(ObClient *self,
4021                                                       gboolean bylayer,
4022                                                       ObStackingLayer layer)
4023 {
4024     GSList *ret;
4025     ObClient *p;
4026
4027     /* move up the direct transient chain as far as possible */
4028     while ((p = client_direct_parent(self)) &&
4029            (!bylayer || p->layer == layer))
4030         self = p;
4031
4032     if (!self->parents)
4033         ret = g_slist_prepend(NULL, self);
4034     else
4035         ret = g_slist_copy(self->parents);
4036
4037     return ret;
4038 }
4039
4040 GSList *client_search_all_top_parents(ObClient *self)
4041 {
4042     return client_search_all_top_parents_internal(self, FALSE, 0);
4043 }
4044
4045 GSList *client_search_all_top_parents_layer(ObClient *self)
4046 {
4047     return client_search_all_top_parents_internal(self, TRUE, self->layer);
4048 }
4049
4050 ObClient *client_search_focus_parent(ObClient *self)
4051 {
4052     GSList *it;
4053
4054     for (it = self->parents; it; it = g_slist_next(it))
4055         if (client_focused(it->data)) return it->data;
4056
4057     return NULL;
4058 }
4059
4060 ObClient *client_search_focus_parent_full(ObClient *self)
4061 {
4062     GSList *it;
4063     ObClient *ret = NULL;
4064
4065     for (it = self->parents; it; it = g_slist_next(it)) {
4066         if (client_focused(it->data))
4067             ret = it->data;
4068         else
4069             ret = client_search_focus_parent_full(it->data);
4070         if (ret) break;
4071     }
4072     return ret;
4073 }
4074
4075 ObClient *client_search_parent(ObClient *self, ObClient *search)
4076 {
4077     GSList *it;
4078
4079     for (it = self->parents; it; it = g_slist_next(it))
4080         if (it->data == search) return search;
4081
4082     return NULL;
4083 }
4084
4085 ObClient *client_search_transient(ObClient *self, ObClient *search)
4086 {
4087     GSList *sit;
4088
4089     for (sit = self->transients; sit; sit = g_slist_next(sit)) {
4090         if (sit->data == search)
4091             return search;
4092         if (client_search_transient(sit->data, search))
4093             return search;
4094     }
4095     return NULL;
4096 }
4097
4098 static void detect_edge(Rect area, ObDirection dir,
4099                         gint my_head, gint my_size,
4100                         gint my_edge_start, gint my_edge_size,
4101                         gint *dest, gboolean *near_edge)
4102 {
4103     gint edge_start, edge_size, head, tail;
4104     gboolean skip_head = FALSE, skip_tail = FALSE;
4105
4106     switch (dir) {
4107         case OB_DIRECTION_NORTH:
4108         case OB_DIRECTION_SOUTH:
4109             edge_start = area.x;
4110             edge_size = area.width;
4111             break;
4112         case OB_DIRECTION_EAST:
4113         case OB_DIRECTION_WEST:
4114             edge_start = area.y;
4115             edge_size = area.height;
4116             break;
4117         default:
4118             g_assert_not_reached();
4119     }
4120
4121     /* do we collide with this window? */
4122     if (!RANGES_INTERSECT(my_edge_start, my_edge_size,
4123                 edge_start, edge_size))
4124         return;
4125
4126     switch (dir) {
4127         case OB_DIRECTION_NORTH:
4128             head = RECT_BOTTOM(area);
4129             tail = RECT_TOP(area);
4130             break;
4131         case OB_DIRECTION_SOUTH:
4132             head = RECT_TOP(area);
4133             tail = RECT_BOTTOM(area);
4134             break;
4135         case OB_DIRECTION_WEST:
4136             head = RECT_RIGHT(area);
4137             tail = RECT_LEFT(area);
4138             break;
4139         case OB_DIRECTION_EAST:
4140             head = RECT_LEFT(area);
4141             tail = RECT_RIGHT(area);
4142             break;
4143         default:
4144             g_assert_not_reached();
4145     }
4146     switch (dir) {
4147         case OB_DIRECTION_NORTH:
4148         case OB_DIRECTION_WEST:
4149             /* check if our window is past the head of this window */
4150             if (my_head <= head + 1)
4151                 skip_head = TRUE;
4152             /* check if our window's tail is past the tail of this window */
4153             if (my_head + my_size - 1 <= tail)
4154                 skip_tail = TRUE;
4155             /* check if the head of this window is closer than the previously
4156                chosen edge (take into account that the previously chosen
4157                edge might have been a tail, not a head) */
4158             if (head + (*near_edge ? 0 : my_size) <= *dest)
4159                 skip_head = TRUE;
4160             /* check if the tail of this window is closer than the previously
4161                chosen edge (take into account that the previously chosen
4162                edge might have been a head, not a tail) */
4163             if (tail - (!*near_edge ? 0 : my_size) <= *dest)
4164                 skip_tail = TRUE;
4165             break;
4166         case OB_DIRECTION_SOUTH:
4167         case OB_DIRECTION_EAST:
4168             /* check if our window is past the head of this window */
4169             if (my_head >= head - 1)
4170                 skip_head = TRUE;
4171             /* check if our window's tail is past the tail of this window */
4172             if (my_head - my_size + 1 >= tail)
4173                 skip_tail = TRUE;
4174             /* check if the head of this window is closer than the previously
4175                chosen edge (take into account that the previously chosen
4176                edge might have been a tail, not a head) */
4177             if (head - (*near_edge ? 0 : my_size) >= *dest)
4178                 skip_head = TRUE;
4179             /* check if the tail of this window is closer than the previously
4180                chosen edge (take into account that the previously chosen
4181                edge might have been a head, not a tail) */
4182             if (tail + (!*near_edge ? 0 : my_size) >= *dest)
4183                 skip_tail = TRUE;
4184             break;
4185         default:
4186             g_assert_not_reached();
4187     }
4188
4189     ob_debug("my head %d size %d\n", my_head, my_size);
4190     ob_debug("head %d tail %d dest %d\n", head, tail, *dest);
4191     if (!skip_head) {
4192         ob_debug("using near edge %d\n", head);
4193         *dest = head;
4194         *near_edge = TRUE;
4195     }
4196     else if (!skip_tail) {
4197         ob_debug("using far edge %d\n", tail);
4198         *dest = tail;
4199         *near_edge = FALSE;
4200     }
4201 }
4202
4203 void client_find_edge_directional(ObClient *self, ObDirection dir,
4204                                   gint my_head, gint my_size,
4205                                   gint my_edge_start, gint my_edge_size,
4206                                   gint *dest, gboolean *near_edge)
4207 {
4208     GList *it;
4209     Rect *a, *mon;
4210     Rect dock_area;
4211     gint edge;
4212
4213     a = screen_area(self->desktop, SCREEN_AREA_ALL_MONITORS,
4214                     &self->frame->area);
4215     mon = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR,
4216                       &self->frame->area);
4217
4218     switch (dir) {
4219     case OB_DIRECTION_NORTH:
4220         if (my_head >= RECT_TOP(*mon) + 1)
4221             edge = RECT_TOP(*mon) - 1;
4222         else
4223             edge = RECT_TOP(*a) - 1;
4224         break;
4225     case OB_DIRECTION_SOUTH:
4226         if (my_head <= RECT_BOTTOM(*mon) - 1)
4227             edge = RECT_BOTTOM(*mon) + 1;
4228         else
4229             edge = RECT_BOTTOM(*a) + 1;
4230         break;
4231     case OB_DIRECTION_EAST:
4232         if (my_head <= RECT_RIGHT(*mon) - 1)
4233             edge = RECT_RIGHT(*mon) + 1;
4234         else
4235             edge = RECT_RIGHT(*a) + 1;
4236         break;
4237     case OB_DIRECTION_WEST:
4238         if (my_head >= RECT_LEFT(*mon) + 1)
4239             edge = RECT_LEFT(*mon) - 1;
4240         else
4241             edge = RECT_LEFT(*a) - 1;
4242         break;
4243     default:
4244         g_assert_not_reached();
4245     }
4246     /* default to the far edge, then narrow it down */
4247     *dest = edge;
4248     *near_edge = TRUE;
4249
4250     for (it = client_list; it; it = g_list_next(it)) {
4251         ObClient *cur = it->data;
4252
4253         /* skip windows to not bump into */
4254         if (cur == self)
4255             continue;
4256         if (cur->iconic)
4257             continue;
4258         if (self->desktop != cur->desktop && cur->desktop != DESKTOP_ALL &&
4259             cur->desktop != screen_desktop)
4260             continue;
4261
4262         ob_debug("trying window %s\n", cur->title);
4263
4264         detect_edge(cur->frame->area, dir, my_head, my_size, my_edge_start,
4265                     my_edge_size, dest, near_edge);
4266     }
4267     dock_get_area(&dock_area);
4268     detect_edge(dock_area, dir, my_head, my_size, my_edge_start,
4269                 my_edge_size, dest, near_edge);
4270     g_free(a);
4271     g_free(mon);
4272 }
4273
4274 void client_find_move_directional(ObClient *self, ObDirection dir,
4275                                   gint *x, gint *y)
4276 {
4277     gint head, size;
4278     gint e, e_start, e_size;
4279     gboolean near;
4280
4281     switch (dir) {
4282     case OB_DIRECTION_EAST:
4283         head = RECT_RIGHT(self->frame->area);
4284         size = self->frame->area.width;
4285         e_start = RECT_TOP(self->frame->area);
4286         e_size = self->frame->area.height;
4287         break;
4288     case OB_DIRECTION_WEST:
4289         head = RECT_LEFT(self->frame->area);
4290         size = self->frame->area.width;
4291         e_start = RECT_TOP(self->frame->area);
4292         e_size = self->frame->area.height;
4293         break;
4294     case OB_DIRECTION_NORTH:
4295         head = RECT_TOP(self->frame->area);
4296         size = self->frame->area.height;
4297         e_start = RECT_LEFT(self->frame->area);
4298         e_size = self->frame->area.width;
4299         break;
4300     case OB_DIRECTION_SOUTH:
4301         head = RECT_BOTTOM(self->frame->area);
4302         size = self->frame->area.height;
4303         e_start = RECT_LEFT(self->frame->area);
4304         e_size = self->frame->area.width;
4305         break;
4306     default:
4307         g_assert_not_reached();
4308     }
4309
4310     client_find_edge_directional(self, dir, head, size,
4311                                  e_start, e_size, &e, &near);
4312     *x = self->frame->area.x;
4313     *y = self->frame->area.y;
4314     switch (dir) {
4315     case OB_DIRECTION_EAST:
4316         if (near) e -= self->frame->area.width;
4317         else      e++;
4318         *x = e;
4319         break;
4320     case OB_DIRECTION_WEST:
4321         if (near) e++;
4322         else      e -= self->frame->area.width;
4323         *x = e;
4324         break;
4325     case OB_DIRECTION_NORTH:
4326         if (near) e++;
4327         else      e -= self->frame->area.height;
4328         *y = e;
4329         break;
4330     case OB_DIRECTION_SOUTH:
4331         if (near) e -= self->frame->area.height;
4332         else      e++;
4333         *y = e;
4334         break;
4335     default:
4336         g_assert_not_reached();
4337     }
4338     frame_frame_gravity(self->frame, x, y);
4339 }
4340
4341 void client_find_resize_directional(ObClient *self, ObDirection side,
4342                                     gboolean grow,
4343                                     gint *x, gint *y, gint *w, gint *h)
4344 {
4345     gint head;
4346     gint e, e_start, e_size, delta;
4347     gboolean near;
4348     ObDirection dir;
4349
4350     switch (side) {
4351     case OB_DIRECTION_EAST:
4352         head = RECT_RIGHT(self->frame->area) +
4353             (self->size_inc.width - 1) * (grow ? 1 : 0);
4354         e_start = RECT_TOP(self->frame->area);
4355         e_size = self->frame->area.height;
4356         dir = grow ? OB_DIRECTION_EAST : OB_DIRECTION_WEST;
4357         break;
4358     case OB_DIRECTION_WEST:
4359         head = RECT_LEFT(self->frame->area) -
4360             (self->size_inc.width - 1) * (grow ? 1 : 0);
4361         e_start = RECT_TOP(self->frame->area);
4362         e_size = self->frame->area.height;
4363         dir = grow ? OB_DIRECTION_WEST : OB_DIRECTION_EAST;
4364         break;
4365     case OB_DIRECTION_NORTH:
4366         head = RECT_TOP(self->frame->area) -
4367             (self->size_inc.height - 1) * (grow ? 1 : 0);
4368         e_start = RECT_LEFT(self->frame->area);
4369         e_size = self->frame->area.width;
4370         dir = grow ? OB_DIRECTION_NORTH : OB_DIRECTION_SOUTH;
4371         break;
4372     case OB_DIRECTION_SOUTH:
4373         head = RECT_BOTTOM(self->frame->area) +
4374             (self->size_inc.height - 1) * (grow ? 1 : 0);
4375         e_start = RECT_LEFT(self->frame->area);
4376         e_size = self->frame->area.width;
4377         dir = grow ? OB_DIRECTION_SOUTH : OB_DIRECTION_NORTH;
4378         break;
4379     default:
4380         g_assert_not_reached();
4381     }
4382
4383     ob_debug("head %d dir %d\n", head, dir);
4384     client_find_edge_directional(self, dir, head, 1,
4385                                  e_start, e_size, &e, &near);
4386     ob_debug("edge %d\n", e);
4387     *x = self->frame->area.x;
4388     *y = self->frame->area.y;
4389     *w = self->frame->area.width;
4390     *h = self->frame->area.height;
4391     switch (side) {
4392     case OB_DIRECTION_EAST:
4393         if (grow == near) --e;
4394         delta = e - RECT_RIGHT(self->frame->area);
4395         *w += delta;
4396         break;
4397     case OB_DIRECTION_WEST:
4398         if (grow == near) ++e;
4399         delta = RECT_LEFT(self->frame->area) - e;
4400         *x -= delta;
4401         *w += delta;
4402         break;
4403     case OB_DIRECTION_NORTH:
4404         if (grow == near) ++e;
4405         delta = RECT_TOP(self->frame->area) - e;
4406         *y -= delta;
4407         *h += delta;
4408         break;
4409     case OB_DIRECTION_SOUTH:
4410         if (grow == near) --e;
4411         delta = e - RECT_BOTTOM(self->frame->area);
4412         *h += delta;
4413         break;
4414     default:
4415         g_assert_not_reached();
4416     }
4417     frame_frame_gravity(self->frame, x, y);
4418     *w -= self->frame->size.left + self->frame->size.right;
4419     *h -= self->frame->size.top + self->frame->size.bottom;
4420 }
4421
4422 ObClient* client_under_pointer(void)
4423 {
4424     gint x, y;
4425     GList *it;
4426     ObClient *ret = NULL;
4427
4428     if (screen_pointer_pos(&x, &y)) {
4429         for (it = stacking_list; it; it = g_list_next(it)) {
4430             if (WINDOW_IS_CLIENT(it->data)) {
4431                 ObClient *c = WINDOW_AS_CLIENT(it->data);
4432                 if (c->frame->visible &&
4433                     /* check the desktop, this is done during desktop
4434                        switching and windows are shown/hidden status is not
4435                        reliable */
4436                     (c->desktop == screen_desktop ||
4437                      c->desktop == DESKTOP_ALL) &&
4438                     /* ignore all animating windows */
4439                     !frame_iconify_animating(c->frame) &&
4440                     RECT_CONTAINS(c->frame->area, x, y))
4441                 {
4442                     ret = c;
4443                     break;
4444                 }
4445             }
4446         }
4447     }
4448     return ret;
4449 }
4450
4451 gboolean client_has_group_siblings(ObClient *self)
4452 {
4453     return self->group && self->group->members->next;
4454 }
4455
4456 /*! Returns TRUE if the client is running on the same machine as Openbox */
4457 gboolean client_on_localhost(ObClient *self)
4458 {
4459     return self->client_machine == NULL;
4460 }