openbox/client.c

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