openbox/client.c

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