openbox/client.c

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