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