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