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