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 = newparent;
1264         do {
1265             self->transients = g_slist_remove(self->transients, look);
1266             look->parents = g_slist_remove(look->parents, self);
1267             look = look->transient_for;
1268         } while (look != NULL && look != OB_TRAN_GROUP && client_normal(look));
1269     }
1270
1271
1272     /* If the group changed, or if we are just becoming transient for the
1273        group, then we need to remove any old group transient windows
1274        from our children. But if we were already transient for the group, then
1275        other group transients are not our children. */
1276     if ((oldgroup != newgroup ||
1277          (newparent == OB_TRAN_GROUP && oldparent != newparent)) &&
1278         oldgroup != NULL && oldparent != OB_TRAN_GROUP)
1279     {
1280         for (it = self->transients; it; it = next) {
1281             next = g_slist_next(it);
1282             c = it->data;
1283             if (c->group == oldgroup && client_normal(self)) {
1284                 self->transients = g_slist_delete_link(self->transients, it);
1285                 c->parents = g_slist_remove(c->parents, self);
1286             }
1287         }
1288     }
1289
1290     /* If we used to be transient for a group and now we are not, or we're
1291        transient for a new group, then we need to remove ourselves from all
1292        our ex-parents */
1293     if (oldparent == OB_TRAN_GROUP && (oldgroup != newgroup ||
1294                                        oldparent != newparent))
1295     {
1296         for (it = self->parents; it; it = next) {
1297             next = g_slist_next(it);
1298             c = it->data;
1299             if ((!c->transient_for || c->transient_for != OB_TRAN_GROUP) &&
1300                 client_normal(c))
1301             {
1302                 c->transients = g_slist_remove(c->transients, self);
1303                 self->parents = g_slist_delete_link(self->parents, it);
1304             }
1305         }
1306     }
1307     /* If we used to be transient for a single window and we are no longer
1308        transient for it, then we need to remove ourself from its children */
1309     else if (oldparent != NULL && oldparent != OB_TRAN_GROUP &&
1310              oldparent != newparent && client_normal(oldparent))
1311     {
1312         oldparent->transients = g_slist_remove(oldparent->transients, self);
1313         self->parents = g_slist_remove(self->parents, oldparent);
1314     }
1315
1316     /** Re-add the client to the transient tree wherever it has changed **/
1317
1318     /* If we're now transient for a group and we weren't transient for it
1319        before then we need to add ourselves to all our new parents */
1320     if (newparent == OB_TRAN_GROUP && (oldgroup != newgroup ||
1321                                        oldparent != newparent))
1322     {
1323         for (it = oldgroup->members; it; it = g_slist_next(it)) {
1324             c = it->data;
1325             if (c != self &&
1326                 (!c->transient_for ||
1327                  c->transient_for != OB_TRAN_GROUP) &&
1328                 client_normal(c))
1329             {
1330                 c->transients = g_slist_prepend(c->transients, self);
1331                 self->parents = g_slist_prepend(self->parents, c);
1332             }
1333         }
1334     }
1335     /* If we are now transient for a single window which we weren't before,
1336        we need to add ourselves to its children
1337
1338        WARNING: Cyclical transient ness is possible if two windows are
1339        transient for eachother.
1340     */
1341     else if (newparent != NULL && newparent != OB_TRAN_GROUP &&
1342              newparent != oldparent &&
1343              /* don't make ourself its child if it is already our child */
1344              !client_is_direct_child(self, newparent) &&
1345              client_normal(newparent))
1346     {
1347         newparent->transients = g_slist_prepend(newparent->transients, self);
1348         self->parents = g_slist_prepend(self->parents, newparent);
1349     }
1350
1351     /* If the group changed then we need to add any new group transient
1352        windows to our children. But if we're transient for the group, then
1353        other group transients are not our children.
1354
1355        WARNING: Cyclical transient-ness is possible. For e.g. if:
1356        A is transient for the group
1357        B is transient for A
1358        C is transient for B
1359        A can't be transient for C or we have a cycle
1360     */
1361     if (oldgroup != newgroup && newgroup != NULL &&
1362         newparent != OB_TRAN_GROUP)
1363     {
1364         for (it = newgroup->members; it; it = g_slist_next(it)) {
1365             c = it->data;
1366             if (c != self && c->transient_for == OB_TRAN_GROUP &&
1367                 /* Don't make it our child if it is already our parent */
1368                 !client_is_direct_child(c, self) &&
1369                 client_normal(self))
1370             {
1371                 self->transients = g_slist_prepend(self->transients, c);
1372                 c->parents = g_slist_prepend(c->parents, self);
1373             }
1374         }
1375     }
1376 }
1377
1378 static void client_get_mwm_hints(ObClient *self)
1379 {
1380     guint num;
1381     guint32 *hints;
1382
1383     self->mwmhints.flags = 0; /* default to none */
1384
1385     if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
1386                     &hints, &num)) {
1387         if (num >= OB_MWM_ELEMENTS) {
1388             self->mwmhints.flags = hints[0];
1389             self->mwmhints.functions = hints[1];
1390             self->mwmhints.decorations = hints[2];
1391         }
1392         g_free(hints);
1393     }
1394 }
1395
1396 void client_get_type_and_transientness(ObClient *self)
1397 {
1398     guint num, i;
1399     guint32 *val;
1400     Window t;
1401
1402     self->type = -1;
1403     self->transient = FALSE;
1404
1405     if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
1406         /* use the first value that we know about in the array */
1407         for (i = 0; i < num; ++i) {
1408             if (val[i] == prop_atoms.net_wm_window_type_desktop)
1409                 self->type = OB_CLIENT_TYPE_DESKTOP;
1410             else if (val[i] == prop_atoms.net_wm_window_type_dock)
1411                 self->type = OB_CLIENT_TYPE_DOCK;
1412             else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
1413                 self->type = OB_CLIENT_TYPE_TOOLBAR;
1414             else if (val[i] == prop_atoms.net_wm_window_type_menu)
1415                 self->type = OB_CLIENT_TYPE_MENU;
1416             else if (val[i] == prop_atoms.net_wm_window_type_utility)
1417                 self->type = OB_CLIENT_TYPE_UTILITY;
1418             else if (val[i] == prop_atoms.net_wm_window_type_splash)
1419                 self->type = OB_CLIENT_TYPE_SPLASH;
1420             else if (val[i] == prop_atoms.net_wm_window_type_dialog)
1421                 self->type = OB_CLIENT_TYPE_DIALOG;
1422             else if (val[i] == prop_atoms.net_wm_window_type_normal)
1423                 self->type = OB_CLIENT_TYPE_NORMAL;
1424             else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
1425                 /* prevent this window from getting any decor or
1426                    functionality */
1427                 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
1428                                          OB_MWM_FLAG_DECORATIONS);
1429                 self->mwmhints.decorations = 0;
1430                 self->mwmhints.functions = 0;
1431             }
1432             if (self->type != (ObClientType) -1)
1433                 break; /* grab the first legit type */
1434         }
1435         g_free(val);
1436     }
1437
1438     if (XGetTransientForHint(ob_display, self->window, &t))
1439         self->transient = TRUE;
1440
1441     if (self->type == (ObClientType) -1) {
1442         /*the window type hint was not set, which means we either classify
1443           ourself as a normal window or a dialog, depending on if we are a
1444           transient. */
1445         if (self->transient)
1446             self->type = OB_CLIENT_TYPE_DIALOG;
1447         else
1448             self->type = OB_CLIENT_TYPE_NORMAL;
1449     }
1450
1451     /* then, based on our type, we can update our transientness.. */
1452     if (self->type == OB_CLIENT_TYPE_DIALOG ||
1453         self->type == OB_CLIENT_TYPE_TOOLBAR ||
1454         self->type == OB_CLIENT_TYPE_MENU ||
1455         self->type == OB_CLIENT_TYPE_UTILITY)
1456     {
1457         self->transient = TRUE;
1458     }
1459 }
1460
1461 void client_update_protocols(ObClient *self)
1462 {
1463     guint32 *proto;
1464     guint num_return, i;
1465
1466     self->focus_notify = FALSE;
1467     self->delete_window = FALSE;
1468
1469     if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1470         for (i = 0; i < num_return; ++i) {
1471             if (proto[i] == prop_atoms.wm_delete_window)
1472                 /* this means we can request the window to close */
1473                 self->delete_window = TRUE;
1474             else if (proto[i] == prop_atoms.wm_take_focus)
1475                 /* if this protocol is requested, then the window will be
1476                    notified whenever we want it to receive focus */
1477                 self->focus_notify = TRUE;
1478 #ifdef SYNC
1479             else if (proto[i] == prop_atoms.net_wm_sync_request)
1480                 /* if this protocol is requested, then resizing the
1481                    window will be synchronized between the frame and the
1482                    client */
1483                 self->sync_request = TRUE;
1484 #endif
1485         }
1486         g_free(proto);
1487     }
1488 }
1489
1490 #ifdef SYNC
1491 void client_update_sync_request_counter(ObClient *self)
1492 {
1493     guint32 i;
1494
1495     if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
1496         self->sync_counter = i;
1497     } else
1498         self->sync_counter = None;
1499 }
1500 #endif
1501
1502 void client_get_colormap(ObClient *self)
1503 {
1504     XWindowAttributes wa;
1505
1506     if (XGetWindowAttributes(ob_display, self->window, &wa))
1507         client_update_colormap(self, wa.colormap);
1508 }
1509
1510 void client_update_colormap(ObClient *self, Colormap colormap)
1511 {
1512     if (colormap == self->colormap) return;
1513
1514     ob_debug("Setting client %s colormap: 0x%x\n", self->title, colormap);
1515
1516     if (client_focused(self)) {
1517         screen_install_colormap(self, FALSE); /* uninstall old one */
1518         self->colormap = colormap;
1519         screen_install_colormap(self, FALSE); /* install new one */
1520     } else
1521         self->colormap = colormap;
1522 }
1523
1524 void client_update_normal_hints(ObClient *self)
1525 {
1526     XSizeHints size;
1527     glong ret;
1528
1529     /* defaults */
1530     self->min_ratio = 0.0f;
1531     self->max_ratio = 0.0f;
1532     SIZE_SET(self->size_inc, 1, 1);
1533     SIZE_SET(self->base_size, 0, 0);
1534     SIZE_SET(self->min_size, 0, 0);
1535     SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1536
1537     /* get the hints from the window */
1538     if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1539         /* normal windows can't request placement! har har
1540         if (!client_normal(self))
1541         */
1542         self->positioned = (size.flags & (PPosition|USPosition));
1543         self->sized = (size.flags & (PSize|USSize));
1544
1545         if (size.flags & PWinGravity)
1546             self->gravity = size.win_gravity;
1547
1548         if (size.flags & PAspect) {
1549             if (size.min_aspect.y)
1550                 self->min_ratio =
1551                     (gfloat) size.min_aspect.x / size.min_aspect.y;
1552             if (size.max_aspect.y)
1553                 self->max_ratio =
1554                     (gfloat) size.max_aspect.x / size.max_aspect.y;
1555         }
1556
1557         if (size.flags & PMinSize)
1558             SIZE_SET(self->min_size, size.min_width, size.min_height);
1559
1560         if (size.flags & PMaxSize)
1561             SIZE_SET(self->max_size, size.max_width, size.max_height);
1562
1563         if (size.flags & PBaseSize)
1564             SIZE_SET(self->base_size, size.base_width, size.base_height);
1565
1566         if (size.flags & PResizeInc && size.width_inc && size.height_inc)
1567             SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1568     }
1569 }
1570
1571 void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
1572 {
1573     /* start with everything (cept fullscreen) */
1574     self->decorations =
1575         (OB_FRAME_DECOR_TITLEBAR |
1576          OB_FRAME_DECOR_HANDLE |
1577          OB_FRAME_DECOR_GRIPS |
1578          OB_FRAME_DECOR_BORDER |
1579          OB_FRAME_DECOR_ICON |
1580          OB_FRAME_DECOR_ALLDESKTOPS |
1581          OB_FRAME_DECOR_ICONIFY |
1582          OB_FRAME_DECOR_MAXIMIZE |
1583          OB_FRAME_DECOR_SHADE |
1584          OB_FRAME_DECOR_CLOSE);
1585     self->functions =
1586         (OB_CLIENT_FUNC_RESIZE |
1587          OB_CLIENT_FUNC_MOVE |
1588          OB_CLIENT_FUNC_ICONIFY |
1589          OB_CLIENT_FUNC_MAXIMIZE |
1590          OB_CLIENT_FUNC_SHADE |
1591          OB_CLIENT_FUNC_CLOSE |
1592          OB_CLIENT_FUNC_BELOW |
1593          OB_CLIENT_FUNC_ABOVE |
1594          OB_CLIENT_FUNC_UNDECORATE);
1595
1596     if (!(self->min_size.width < self->max_size.width ||
1597           self->min_size.height < self->max_size.height))
1598         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1599
1600     switch (self->type) {
1601     case OB_CLIENT_TYPE_NORMAL:
1602         /* normal windows retain all of the possible decorations and
1603            functionality, and are the only windows that you can fullscreen */
1604         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1605         break;
1606
1607     case OB_CLIENT_TYPE_DIALOG:
1608     case OB_CLIENT_TYPE_UTILITY:
1609         /* these windows don't have anything added or removed by default */
1610         break;
1611
1612     case OB_CLIENT_TYPE_MENU:
1613     case OB_CLIENT_TYPE_TOOLBAR:
1614         /* these windows can't iconify or maximize */
1615         self->decorations &= ~(OB_FRAME_DECOR_ICONIFY |
1616                                OB_FRAME_DECOR_MAXIMIZE);
1617         self->functions &= ~(OB_CLIENT_FUNC_ICONIFY |
1618                              OB_CLIENT_FUNC_MAXIMIZE);
1619         break;
1620
1621     case OB_CLIENT_TYPE_SPLASH:
1622         /* these don't get get any decorations, and the only thing you can
1623            do with them is move them */
1624         self->decorations = 0;
1625         self->functions = OB_CLIENT_FUNC_MOVE;
1626         break;
1627
1628     case OB_CLIENT_TYPE_DESKTOP:
1629         /* these windows are not manipulated by the window manager */
1630         self->decorations = 0;
1631         self->functions = 0;
1632         break;
1633
1634     case OB_CLIENT_TYPE_DOCK:
1635         /* these windows are not manipulated by the window manager, but they
1636            can set below layer which has a special meaning */
1637         self->decorations = 0;
1638         self->functions = OB_CLIENT_FUNC_BELOW;
1639         break;
1640     }
1641
1642     /* Mwm Hints are applied subtractively to what has already been chosen for
1643        decor and functionality */
1644     if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1645         if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1646             if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1647                    (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1648             {
1649                 /* if the mwm hints request no handle or title, then all
1650                    decorations are disabled, but keep the border if that's
1651                    specified */
1652                 if (self->mwmhints.decorations & OB_MWM_DECOR_BORDER)
1653                     self->decorations = OB_FRAME_DECOR_BORDER;
1654                 else
1655                     self->decorations = 0;
1656             }
1657         }
1658     }
1659
1660     if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1661         if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1662             if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1663                 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1664             if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1665                 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1666             /* dont let mwm hints kill any buttons
1667                if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1668                self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1669                if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1670                self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1671             */
1672             /* dont let mwm hints kill the close button
1673                if (! (self->mwmhints.functions & MwmFunc_Close))
1674                self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1675         }
1676     }
1677
1678     if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1679         self->decorations &= ~OB_FRAME_DECOR_SHADE;
1680     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1681         self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1682     if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1683         self->decorations &= ~(OB_FRAME_DECOR_GRIPS | OB_FRAME_DECOR_HANDLE);
1684
1685     /* can't maximize without moving/resizing */
1686     if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1687           (self->functions & OB_CLIENT_FUNC_MOVE) &&
1688           (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1689         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1690         self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1691     }
1692
1693     if (self->max_horz && self->max_vert) {
1694         /* you can't resize fully maximized windows */
1695         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1696         /* kill the handle on fully maxed windows */
1697         self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
1698     }
1699
1700     /* If there are no decorations to remove, don't allow the user to try
1701        toggle the state */
1702     if (self->decorations == 0)
1703         self->functions &= ~OB_CLIENT_FUNC_UNDECORATE;
1704
1705     /* finally, the user can have requested no decorations, which overrides
1706        everything (but doesnt give it a border if it doesnt have one) */
1707     if (self->undecorated) {
1708         if (config_theme_keepborder)
1709             self->decorations &= OB_FRAME_DECOR_BORDER;
1710         else
1711             self->decorations = 0;
1712     }
1713
1714     /* if we don't have a titlebar, then we cannot shade! */
1715     if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1716         self->functions &= ~OB_CLIENT_FUNC_SHADE;
1717
1718     /* now we need to check against rules for the client's current state */
1719     if (self->fullscreen) {
1720         self->functions &= (OB_CLIENT_FUNC_CLOSE |
1721                             OB_CLIENT_FUNC_FULLSCREEN |
1722                             OB_CLIENT_FUNC_ICONIFY);
1723         self->decorations = 0;
1724     }
1725
1726     client_change_allowed_actions(self);
1727
1728     if (reconfig)
1729         client_reconfigure(self);
1730 }
1731
1732 static void client_change_allowed_actions(ObClient *self)
1733 {
1734     gulong actions[12];
1735     gint num = 0;
1736
1737     /* desktop windows are kept on all desktops */
1738     if (self->type != OB_CLIENT_TYPE_DESKTOP)
1739         actions[num++] = prop_atoms.net_wm_action_change_desktop;
1740
1741     if (self->functions & OB_CLIENT_FUNC_SHADE)
1742         actions[num++] = prop_atoms.net_wm_action_shade;
1743     if (self->functions & OB_CLIENT_FUNC_CLOSE)
1744         actions[num++] = prop_atoms.net_wm_action_close;
1745     if (self->functions & OB_CLIENT_FUNC_MOVE)
1746         actions[num++] = prop_atoms.net_wm_action_move;
1747     if (self->functions & OB_CLIENT_FUNC_ICONIFY)
1748         actions[num++] = prop_atoms.net_wm_action_minimize;
1749     if (self->functions & OB_CLIENT_FUNC_RESIZE)
1750         actions[num++] = prop_atoms.net_wm_action_resize;
1751     if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
1752         actions[num++] = prop_atoms.net_wm_action_fullscreen;
1753     if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
1754         actions[num++] = prop_atoms.net_wm_action_maximize_horz;
1755         actions[num++] = prop_atoms.net_wm_action_maximize_vert;
1756     }
1757     if (self->functions & OB_CLIENT_FUNC_ABOVE)
1758         actions[num++] = prop_atoms.net_wm_action_above;
1759     if (self->functions & OB_CLIENT_FUNC_BELOW)
1760         actions[num++] = prop_atoms.net_wm_action_below;
1761     if (self->functions & OB_CLIENT_FUNC_UNDECORATE)
1762         actions[num++] = prop_atoms.ob_wm_action_undecorate;
1763
1764     PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
1765
1766     /* make sure the window isn't breaking any rules now */
1767
1768     if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
1769         if (self->frame) client_shade(self, FALSE);
1770         else self->shaded = FALSE;
1771     }
1772     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
1773         if (self->frame) client_iconify(self, FALSE, TRUE, FALSE);
1774         else self->iconic = FALSE;
1775     }
1776     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
1777         if (self->frame) client_fullscreen(self, FALSE);
1778         else self->fullscreen = FALSE;
1779     }
1780     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
1781                                                          self->max_vert)) {
1782         if (self->frame) client_maximize(self, FALSE, 0);
1783         else self->max_vert = self->max_horz = FALSE;
1784     }
1785 }
1786
1787 void client_reconfigure(ObClient *self)
1788 {
1789     client_configure(self, self->area.x, self->area.y,
1790                      self->area.width, self->area.height,
1791                      FALSE, TRUE);
1792 }
1793
1794 void client_update_wmhints(ObClient *self)
1795 {
1796     XWMHints *hints;
1797
1798     /* assume a window takes input if it doesnt specify */
1799     self->can_focus = TRUE;
1800
1801     if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
1802         gboolean ur;
1803
1804         if (hints->flags & InputHint)
1805             self->can_focus = hints->input;
1806
1807         /* only do this when first managing the window *AND* when we aren't
1808            starting up! */
1809         if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
1810             if (hints->flags & StateHint)
1811                 self->iconic = hints->initial_state == IconicState;
1812
1813         ur = self->urgent;
1814         self->urgent = (hints->flags & XUrgencyHint);
1815         if (self->urgent && !ur)
1816             client_hilite(self, TRUE);
1817         else if (!self->urgent && ur && self->demands_attention)
1818             client_hilite(self, FALSE);
1819
1820         if (!(hints->flags & WindowGroupHint))
1821             hints->window_group = None;
1822
1823         /* did the group state change? */
1824         if (hints->window_group !=
1825             (self->group ? self->group->leader : None))
1826         {
1827             ObGroup *oldgroup = self->group;
1828
1829             /* remove from the old group if there was one */
1830             if (self->group != NULL) {
1831                 group_remove(self->group, self);
1832                 self->group = NULL;
1833             }
1834
1835             /* add ourself to the group if we have one */
1836             if (hints->window_group != None) {
1837                 self->group = group_add(hints->window_group, self);
1838             }
1839
1840             /* Put ourselves into the new group's transient tree, and remove
1841                ourselves from the old group's */
1842             client_update_transient_tree(self, oldgroup, self->group,
1843                                          self->transient_for,
1844                                          self->transient_for);
1845
1846             /* Lastly, being in a group, or not, can change if the window is
1847                transient for anything.
1848
1849                The logic for this is:
1850                self->transient = TRUE always if the window wants to be
1851                transient for something, even if transient_for was NULL because
1852                it wasn't in a group before.
1853
1854                If transient_for was NULL and oldgroup was NULL we can assume
1855                that when we add the new group, it will become transient for
1856                something.
1857
1858                If transient_for was OB_TRAN_GROUP, then it must have already
1859                had a group. If it is getting a new group, the above call to
1860                client_update_transient_tree has already taken care of
1861                everything ! If it is losing all group status then it will
1862                no longer be transient for anything and that needs to be
1863                updated.
1864             */
1865             if (self->transient &&
1866                 ((self->transient_for == NULL && oldgroup == NULL) ||
1867                  (self->transient_for == OB_TRAN_GROUP && !self->group)))
1868                 client_update_transient_for(self);
1869         }
1870
1871         /* the WM_HINTS can contain an icon */
1872         if (hints->flags & IconPixmapHint)
1873             client_update_icons(self);
1874
1875         XFree(hints);
1876     }
1877 }
1878
1879 void client_update_title(ObClient *self)
1880 {
1881     gchar *data = NULL;
1882     gchar *visible = NULL;
1883
1884     g_free(self->title);
1885
1886     /* try netwm */
1887     if (!PROP_GETS(self->window, net_wm_name, utf8, &data)) {
1888         /* try old x stuff */
1889         if (!(PROP_GETS(self->window, wm_name, locale, &data)
1890               || PROP_GETS(self->window, wm_name, utf8, &data))) {
1891             if (self->transient) {
1892                 /*
1893                   GNOME alert windows are not given titles:
1894                   http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1895                 */
1896                 data = g_strdup("");
1897             } else
1898                 data = g_strdup("Unnamed Window");
1899         }
1900     }
1901
1902     if (self->client_machine) {
1903         visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1904         g_free(data);
1905     } else
1906         visible = data;
1907
1908     PROP_SETS(self->window, net_wm_visible_name, visible);
1909     self->title = visible;
1910
1911     if (self->frame)
1912         frame_adjust_title(self->frame);
1913
1914     /* update the icon title */
1915     data = NULL;
1916     g_free(self->icon_title);
1917
1918     /* try netwm */
1919     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
1920         /* try old x stuff */
1921         if (!(PROP_GETS(self->window, wm_icon_name, locale, &data) ||
1922               PROP_GETS(self->window, wm_icon_name, utf8, &data)))
1923             data = g_strdup(self->title);
1924
1925     if (self->client_machine) {
1926         visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1927         g_free(data);
1928     } else
1929         visible = data;
1930
1931     PROP_SETS(self->window, net_wm_visible_icon_name, visible);
1932     self->icon_title = visible;
1933 }
1934
1935 void client_update_strut(ObClient *self)
1936 {
1937     guint num;
1938     guint32 *data;
1939     gboolean got = FALSE;
1940     StrutPartial strut;
1941
1942     if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
1943                     &data, &num)) {
1944         if (num == 12) {
1945             got = TRUE;
1946             STRUT_PARTIAL_SET(strut,
1947                               data[0], data[2], data[1], data[3],
1948                               data[4], data[5], data[8], data[9],
1949                               data[6], data[7], data[10], data[11]);
1950         }
1951         g_free(data);
1952     }
1953
1954     if (!got &&
1955         PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
1956         if (num == 4) {
1957             const Rect *a;
1958
1959             got = TRUE;
1960
1961             /* use the screen's width/height */
1962             a = screen_physical_area();
1963
1964             STRUT_PARTIAL_SET(strut,
1965                               data[0], data[2], data[1], data[3],
1966                               a->y, a->y + a->height - 1,
1967                               a->x, a->x + a->width - 1,
1968                               a->y, a->y + a->height - 1,
1969                               a->x, a->x + a->width - 1);
1970         }
1971         g_free(data);
1972     }
1973
1974     if (!got)
1975         STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
1976                           0, 0, 0, 0, 0, 0, 0, 0);
1977
1978     if (!STRUT_EQUAL(strut, self->strut)) {
1979         self->strut = strut;
1980
1981         /* updating here is pointless while we're being mapped cuz we're not in
1982            the client list yet */
1983         if (self->frame)
1984             screen_update_areas();
1985     }
1986 }
1987
1988 void client_update_icons(ObClient *self)
1989 {
1990     guint num;
1991     guint32 *data;
1992     guint w, h, i, j;
1993
1994     for (i = 0; i < self->nicons; ++i)
1995         g_free(self->icons[i].data);
1996     if (self->nicons > 0)
1997         g_free(self->icons);
1998     self->nicons = 0;
1999
2000     if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
2001         /* figure out how many valid icons are in here */
2002         i = 0;
2003         while (num - i > 2) {
2004             w = data[i++];
2005             h = data[i++];
2006             i += w * h;
2007             if (i > num || w*h == 0) break;
2008             ++self->nicons;
2009         }
2010
2011         self->icons = g_new(ObClientIcon, self->nicons);
2012
2013         /* store the icons */
2014         i = 0;
2015         for (j = 0; j < self->nicons; ++j) {
2016             guint x, y, t;
2017
2018             w = self->icons[j].width = data[i++];
2019             h = self->icons[j].height = data[i++];
2020
2021             if (w*h == 0) continue;
2022
2023             self->icons[j].data = g_new(RrPixel32, w * h);
2024             for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
2025                 if (x >= w) {
2026                     x = 0;
2027                     ++y;
2028                 }
2029                 self->icons[j].data[t] =
2030                     (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
2031                     (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
2032                     (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
2033                     (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
2034             }
2035             g_assert(i <= num);
2036         }
2037
2038         g_free(data);
2039     } else {
2040         XWMHints *hints;
2041
2042         if ((hints = XGetWMHints(ob_display, self->window))) {
2043             if (hints->flags & IconPixmapHint) {
2044                 self->nicons++;
2045                 self->icons = g_new(ObClientIcon, self->nicons);
2046                 xerror_set_ignore(TRUE);
2047                 if (!RrPixmapToRGBA(ob_rr_inst,
2048                                     hints->icon_pixmap,
2049                                     (hints->flags & IconMaskHint ?
2050                                      hints->icon_mask : None),
2051                                     &self->icons[self->nicons-1].width,
2052                                     &self->icons[self->nicons-1].height,
2053                                     &self->icons[self->nicons-1].data)){
2054                     g_free(&self->icons[self->nicons-1]);
2055                     self->nicons--;
2056                 }
2057                 xerror_set_ignore(FALSE);
2058             }
2059             XFree(hints);
2060         }
2061     }
2062
2063     /* set the default icon onto the window
2064        in theory, this could be a race, but if a window doesn't set an icon
2065        or removes it entirely, it's not very likely it is going to set one
2066        right away afterwards */
2067     if (self->nicons == 0) {
2068         RrPixel32 *icon = ob_rr_theme->def_win_icon;
2069         gulong *data;
2070
2071         data = g_new(gulong, 48*48+2);
2072         data[0] = data[1] =  48;
2073         for (i = 0; i < 48*48; ++i)
2074             data[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
2075                 (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
2076                 (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
2077                 (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
2078         PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2);
2079         g_free(data);
2080     } else if (self->frame)
2081         /* don't draw the icon empty if we're just setting one now anyways,
2082            we'll get the property change any second */
2083         frame_adjust_icon(self->frame);
2084 }
2085
2086 void client_update_user_time(ObClient *self)
2087 {
2088     guint32 time;
2089     gboolean got = FALSE;
2090
2091     if (self->user_time_window)
2092         got = PROP_GET32(self->user_time_window,
2093                          net_wm_user_time, cardinal, &time);
2094     if (!got)
2095         got = PROP_GET32(self->window, net_wm_user_time, cardinal, &time);
2096
2097     if (got) {
2098         /* we set this every time, not just when it grows, because in practice
2099            sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes
2100            backward we don't want all windows to stop focusing. we'll just
2101            assume noone is setting times older than the last one, cuz that
2102            would be pretty stupid anyways
2103         */
2104         self->user_time = time;
2105
2106         /*ob_debug("window %s user time %u\n", self->title, time);*/
2107     }
2108 }
2109
2110 void client_update_user_time_window(ObClient *self)
2111 {
2112     guint32 w;
2113
2114     if (!PROP_GET32(self->window, net_wm_user_time_window, window, &w))
2115         w = None;
2116
2117     if (w != self->user_time_window) {
2118         /* remove the old window */
2119         propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self);
2120         self->user_time_window = None;
2121
2122         if (self->group && self->group->leader == w) {
2123             ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
2124                           "_NET_WM_USER_TYPE_WINDOW to its group leader\n");
2125             /* do it anyways..? */
2126         }
2127         else if (w == self->window) {
2128             ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
2129                           "_NET_WM_USER_TIME_WINDOW to itself\n");
2130             w = None; /* don't do it */
2131         }
2132
2133         /* add the new window */
2134         propwin_add(w, OB_PROPWIN_USER_TIME, self);
2135         self->user_time_window = w;
2136
2137         /* and update from it */
2138         client_update_user_time(self);
2139     }
2140 }
2141
2142 void client_update_icon_geometry(ObClient *self)
2143 {
2144     guint num;
2145     guint32 *data;
2146
2147     RECT_SET(self->icon_geometry, 0, 0, 0, 0);
2148
2149     if (PROP_GETA32(self->window, net_wm_icon_geometry, cardinal, &data, &num)
2150         && num == 4)
2151     {
2152         /* don't let them set it with an area < 0 */
2153         RECT_SET(self->icon_geometry, data[0], data[1],
2154                  MAX(data[2],0), MAX(data[3],0));
2155     }
2156 }
2157
2158 static void client_get_session_ids(ObClient *self)
2159 {
2160     guint32 leader;
2161     gboolean got;
2162     gchar *s;
2163     gchar **ss;
2164
2165     if (!PROP_GET32(self->window, wm_client_leader, window, &leader))
2166         leader = None;
2167
2168     /* get the SM_CLIENT_ID */
2169     got = FALSE;
2170     if (leader)
2171         got = PROP_GETS(leader, sm_client_id, locale, &self->sm_client_id);
2172     if (!got)
2173         PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id);
2174
2175     /* get the WM_CLASS (name and class). make them "" if they are not
2176        provided */
2177     got = FALSE;
2178     if (leader)
2179         got = PROP_GETSS(leader, wm_class, locale, &ss);
2180     if (!got)
2181         got = PROP_GETSS(self->window, wm_class, locale, &ss);
2182
2183     if (got) {
2184         if (ss[0]) {
2185             self->name = g_strdup(ss[0]);
2186             if (ss[1])
2187                 self->class = g_strdup(ss[1]);
2188         }
2189         g_strfreev(ss);
2190     }
2191
2192     if (self->name == NULL) self->name = g_strdup("");
2193     if (self->class == NULL) self->class = g_strdup("");
2194
2195     /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
2196     got = FALSE;
2197     if (leader)
2198         got = PROP_GETS(leader, wm_window_role, locale, &s);
2199     if (!got)
2200         got = PROP_GETS(self->window, wm_window_role, locale, &s);
2201
2202     if (got)
2203         self->role = s;
2204     else
2205         self->role = g_strdup("");
2206
2207     /* get the WM_COMMAND */
2208     got = FALSE;
2209
2210     if (leader)
2211         got = PROP_GETSS(leader, wm_command, locale, &ss);
2212     if (!got)
2213         got = PROP_GETSS(self->window, wm_command, locale, &ss);
2214
2215     if (got) {
2216         /* merge/mash them all together */
2217         gchar *merge = NULL;
2218         gint i;
2219
2220         for (i = 0; ss[i]; ++i) {
2221             gchar *tmp = merge;
2222             if (merge)
2223                 merge = g_strconcat(merge, ss[i], NULL);
2224             else
2225                 merge = g_strconcat(ss[i], NULL);
2226             g_free(tmp);
2227         }
2228         g_strfreev(ss);
2229
2230         self->wm_command = merge;
2231     }
2232
2233     /* get the WM_CLIENT_MACHINE */
2234     got = FALSE;
2235     if (leader)
2236         got = PROP_GETS(leader, wm_client_machine, locale, &s);
2237     if (!got)
2238         got = PROP_GETS(self->window, wm_client_machine, locale, &s);
2239
2240     if (got) {
2241         gchar localhost[128];
2242
2243         gethostname(localhost, 127);
2244         localhost[127] = '\0';
2245         if (strcmp(localhost, s) != 0)
2246             self->client_machine = s;
2247         else
2248             g_free(s);
2249     }
2250 }
2251
2252 static void client_change_wm_state(ObClient *self)
2253 {
2254     gulong state[2];
2255     glong old;
2256
2257     old = self->wmstate;
2258
2259     if (self->shaded || self->iconic ||
2260         (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop))
2261     {
2262         self->wmstate = IconicState;
2263     } else
2264         self->wmstate = NormalState;
2265
2266     if (old != self->wmstate) {
2267         PROP_MSG(self->window, kde_wm_change_state,
2268                  self->wmstate, 1, 0, 0);
2269
2270         state[0] = self->wmstate;
2271         state[1] = None;
2272         PROP_SETA32(self->window, wm_state, wm_state, state, 2);
2273     }
2274 }
2275
2276 static void client_change_state(ObClient *self)
2277 {
2278     gulong netstate[12];
2279     guint num;
2280
2281     num = 0;
2282     if (self->modal)
2283         netstate[num++] = prop_atoms.net_wm_state_modal;
2284     if (self->shaded)
2285         netstate[num++] = prop_atoms.net_wm_state_shaded;
2286     if (self->iconic)
2287         netstate[num++] = prop_atoms.net_wm_state_hidden;
2288     if (self->skip_taskbar)
2289         netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
2290     if (self->skip_pager)
2291         netstate[num++] = prop_atoms.net_wm_state_skip_pager;
2292     if (self->fullscreen)
2293         netstate[num++] = prop_atoms.net_wm_state_fullscreen;
2294     if (self->max_vert)
2295         netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
2296     if (self->max_horz)
2297         netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
2298     if (self->above)
2299         netstate[num++] = prop_atoms.net_wm_state_above;
2300     if (self->below)
2301         netstate[num++] = prop_atoms.net_wm_state_below;
2302     if (self->demands_attention)
2303         netstate[num++] = prop_atoms.net_wm_state_demands_attention;
2304     if (self->undecorated)
2305         netstate[num++] = prop_atoms.ob_wm_state_undecorated;
2306     PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
2307
2308     if (self->frame)
2309         frame_adjust_state(self->frame);
2310 }
2311
2312 ObClient *client_search_focus_tree(ObClient *self)
2313 {
2314     GSList *it;
2315     ObClient *ret;
2316
2317     for (it = self->transients; it; it = g_slist_next(it)) {
2318         if (client_focused(it->data)) return it->data;
2319         if ((ret = client_search_focus_tree(it->data))) return ret;
2320     }
2321     return NULL;
2322 }
2323
2324 ObClient *client_search_focus_tree_full(ObClient *self)
2325 {
2326     if (self->parents) {
2327         GSList *it;
2328
2329         for (it = self->parents; it; it = g_slist_next(it)) {
2330             ObClient *c = it->data;
2331             if ((c = client_search_focus_tree_full(it->data))) return c;
2332         }
2333
2334         return NULL;
2335     }
2336     else {
2337         /* this function checks the whole tree, the client_search_focus_tree
2338            does not, so we need to check this window */
2339         if (client_focused(self))
2340             return self;
2341         return client_search_focus_tree(self);
2342     }
2343 }
2344
2345 ObClient *client_search_focus_group_full(ObClient *self)
2346 {
2347     GSList *it;
2348
2349     if (self->group) {
2350         for (it = self->group->members; it; it = g_slist_next(it)) {
2351             ObClient *c = it->data;
2352
2353             if (client_focused(c)) return c;
2354             if ((c = client_search_focus_tree(it->data))) return c;
2355         }
2356     } else
2357         if (client_focused(self)) return self;
2358     return NULL;
2359 }
2360
2361 gboolean client_has_parent(ObClient *self)
2362 {
2363     return self->parents != NULL;
2364 }
2365
2366 static ObStackingLayer calc_layer(ObClient *self)
2367 {
2368     ObStackingLayer l;
2369
2370     if (self->type == OB_CLIENT_TYPE_DESKTOP)
2371         l = OB_STACKING_LAYER_DESKTOP;
2372     else if (self->type == OB_CLIENT_TYPE_DOCK) {
2373         if (self->below) l = OB_STACKING_LAYER_NORMAL;
2374         else l = OB_STACKING_LAYER_ABOVE;
2375     }
2376     else if ((self->fullscreen ||
2377               /* No decorations and fills the monitor = oldskool fullscreen.
2378                  But not for maximized windows.
2379               */
2380               (self->decorations == 0 &&
2381                !(self->max_horz && self->max_vert) &&
2382                RECT_EQUAL(self->area,
2383                           *screen_physical_area_monitor
2384                           (client_monitor(self))))) &&
2385              (client_focused(self) || client_search_focus_tree(self)))
2386         l = OB_STACKING_LAYER_FULLSCREEN;
2387     else if (self->above) l = OB_STACKING_LAYER_ABOVE;
2388     else if (self->below) l = OB_STACKING_LAYER_BELOW;
2389     else l = OB_STACKING_LAYER_NORMAL;
2390
2391     return l;
2392 }
2393
2394 static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
2395                                         ObStackingLayer min)
2396 {
2397     ObStackingLayer old, own;
2398     GSList *it;
2399
2400     old = self->layer;
2401     own = calc_layer(self);
2402     self->layer = MAX(own, min);
2403
2404     if (self->layer != old) {
2405         stacking_remove(CLIENT_AS_WINDOW(self));
2406         stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
2407     }
2408
2409     for (it = self->transients; it; it = g_slist_next(it))
2410         client_calc_layer_recursive(it->data, orig,
2411                                     self->layer);
2412 }
2413
2414 void client_calc_layer(ObClient *self)
2415 {
2416     ObClient *orig;
2417     GSList *it;
2418
2419     orig = self;
2420
2421     /* transients take on the layer of their parents */
2422     it = client_search_all_top_parents(self);
2423
2424     for (; it; it = g_slist_next(it))
2425         client_calc_layer_recursive(it->data, orig, 0);
2426 }
2427
2428 gboolean client_should_show(ObClient *self)
2429 {
2430     if (self->iconic)
2431         return FALSE;
2432     if (client_normal(self) && screen_showing_desktop)
2433         return FALSE;
2434     if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
2435         return TRUE;
2436
2437     return FALSE;
2438 }
2439
2440 gboolean client_show(ObClient *self)
2441 {
2442     gboolean show = FALSE;
2443
2444     if (client_should_show(self)) {
2445         frame_show(self->frame);
2446         show = TRUE;
2447
2448         /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2449            it needs to be in IconicState. This includes when it is on another
2450            desktop!
2451         */
2452         client_change_wm_state(self);
2453     }
2454     return show;
2455 }
2456
2457 gboolean client_hide(ObClient *self)
2458 {
2459     gboolean hide = FALSE;
2460
2461     if (!client_should_show(self)) {
2462         if (self == focus_client) {
2463             /* if there is a grab going on, then we need to cancel it. if we
2464                move focus during the grab, applications will get
2465                NotifyWhileGrabbed events and ignore them !
2466
2467                actions should not rely on being able to move focus during an
2468                interactive grab.
2469             */
2470             event_cancel_all_key_grabs();
2471         }
2472
2473         frame_hide(self->frame);
2474         hide = TRUE;
2475
2476         /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2477            it needs to be in IconicState. This includes when it is on another
2478            desktop!
2479         */
2480         client_change_wm_state(self);
2481     }
2482     return hide;
2483 }
2484
2485 void client_showhide(ObClient *self)
2486 {
2487     if (!client_show(self))
2488         client_hide(self);
2489 }
2490
2491 gboolean client_normal(ObClient *self) {
2492     return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
2493               self->type == OB_CLIENT_TYPE_DOCK ||
2494               self->type == OB_CLIENT_TYPE_SPLASH);
2495 }
2496
2497 gboolean client_helper(ObClient *self)
2498 {
2499     return (self->type == OB_CLIENT_TYPE_UTILITY ||
2500             self->type == OB_CLIENT_TYPE_MENU ||
2501             self->type == OB_CLIENT_TYPE_TOOLBAR);
2502 }
2503
2504 gboolean client_mouse_focusable(ObClient *self)
2505 {
2506     return !(self->type == OB_CLIENT_TYPE_MENU ||
2507              self->type == OB_CLIENT_TYPE_TOOLBAR ||
2508              self->type == OB_CLIENT_TYPE_SPLASH ||
2509              self->type == OB_CLIENT_TYPE_DOCK);
2510 }
2511
2512 gboolean client_enter_focusable(ObClient *self)
2513 {
2514     /* you can focus desktops but it shouldn't on enter */
2515     return (client_mouse_focusable(self) &&
2516             self->type != OB_CLIENT_TYPE_DESKTOP);
2517 }
2518
2519
2520 static void client_apply_startup_state(ObClient *self,
2521                                        gint x, gint y, gint w, gint h)
2522 {
2523     /* save the states that we are going to apply */
2524     gboolean iconic = self->iconic;
2525     gboolean fullscreen = self->fullscreen;
2526     gboolean undecorated = self->undecorated;
2527     gboolean shaded = self->shaded;
2528     gboolean demands_attention = self->demands_attention;
2529     gboolean max_horz = self->max_horz;
2530     gboolean max_vert = self->max_vert;
2531     Rect oldarea;
2532     gint l;
2533
2534     /* turn them all off in the client, so they won't affect the window
2535        being placed */
2536     self->iconic = self->fullscreen = self->undecorated = self->shaded =
2537         self->demands_attention = self->max_horz = self->max_vert = FALSE;
2538
2539     /* move the client to its placed position, or it it's already there,
2540        generate a ConfigureNotify telling the client where it is.
2541
2542        do this after adjusting the frame. otherwise it gets all weird and
2543        clients don't work right
2544
2545        do this before applying the states so they have the correct
2546        pre-max/pre-fullscreen values
2547     */
2548     client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE);
2549     ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
2550              self->window, self->area.x, self->area.y,
2551              self->area.width, self->area.height);
2552     oldarea = self->area;              /* save the area */
2553     RECT_SET(self->area, x, y, w, h);  /* put where it should be for the premax stuff */
2554
2555     /* apply the states. these are in a carefully crafted order.. */
2556
2557     if (iconic)
2558         client_iconify(self, TRUE, FALSE, TRUE);
2559     if (fullscreen)
2560         client_fullscreen(self, TRUE);
2561     if (undecorated)
2562         client_set_undecorated(self, TRUE);
2563     if (shaded)
2564         client_shade(self, TRUE);
2565     if (demands_attention)
2566         client_hilite(self, TRUE);
2567
2568     if (max_vert && max_horz)
2569         client_maximize(self, TRUE, 0);
2570     else if (max_vert)
2571         client_maximize(self, TRUE, 2);
2572     else if (max_horz)
2573         client_maximize(self, TRUE, 1);
2574
2575     /* if the window hasn't been configured yet, then do so now */
2576     if (!fullscreen && !max_vert && !max_horz) {
2577         self->area = oldarea;
2578         client_configure(self, x, y, w, h, FALSE, TRUE);
2579     }
2580
2581     /* set the desktop hint, to make sure that it always exists */
2582     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
2583
2584     /* nothing to do for the other states:
2585        skip_taskbar
2586        skip_pager
2587        modal
2588        above
2589        below
2590     */
2591 }
2592
2593 void client_gravity_resize_w(ObClient *self, gint *x, gint oldw, gint neww)
2594 {
2595     /* these should be the current values. this is for when you're not moving,
2596        just resizing */
2597     g_assert(*x == self->area.x);
2598     g_assert(oldw == self->area.width);
2599
2600     /* horizontal */
2601     switch (self->gravity) {
2602     default:
2603     case NorthWestGravity:
2604     case WestGravity:
2605     case SouthWestGravity:
2606     case StaticGravity:
2607     case ForgetGravity:
2608         break;
2609     case NorthGravity:
2610     case CenterGravity:
2611     case SouthGravity:
2612         *x -= (neww - oldw) / 2;
2613         break;
2614     case NorthEastGravity:
2615     case EastGravity:
2616     case SouthEastGravity:
2617         *x -= neww - oldw;
2618         break;
2619     }
2620 }
2621
2622 void client_gravity_resize_h(ObClient *self, gint *y, gint oldh, gint newh)
2623 {
2624     /* these should be the current values. this is for when you're not moving,
2625        just resizing */
2626     g_assert(*y == self->area.y);
2627     g_assert(oldh == self->area.height);
2628
2629     /* vertical */
2630     switch (self->gravity) {
2631     default:
2632     case NorthWestGravity:
2633     case NorthGravity:
2634     case NorthEastGravity:
2635     case StaticGravity:
2636     case ForgetGravity:
2637         break;
2638     case WestGravity:
2639     case CenterGravity:
2640     case EastGravity:
2641         *y -= (newh - oldh) / 2;
2642         break;
2643     case SouthWestGravity:
2644     case SouthGravity:
2645     case SouthEastGravity:
2646         *y -= newh - oldh;
2647         break;
2648     }
2649 }
2650
2651 void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h,
2652                           gint *logicalw, gint *logicalh,
2653                           gboolean user)
2654 {
2655     Rect desired_area = {*x, *y, *w, *h};
2656
2657     /* make the frame recalculate its dimentions n shit without changing
2658        anything visible for real, this way the constraints below can work with
2659        the updated frame dimensions. */
2660     frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
2661
2662     /* work within the prefered sizes given by the window */
2663     if (!(*w == self->area.width && *h == self->area.height)) {
2664         gint basew, baseh, minw, minh;
2665
2666         /* base size is substituted with min size if not specified */
2667         if (self->base_size.width || self->base_size.height) {
2668             basew = self->base_size.width;
2669             baseh = self->base_size.height;
2670         } else {
2671             basew = self->min_size.width;
2672             baseh = self->min_size.height;
2673         }
2674         /* min size is substituted with base size if not specified */
2675         if (self->min_size.width || self->min_size.height) {
2676             minw = self->min_size.width;
2677             minh = self->min_size.height;
2678         } else {
2679             minw = self->base_size.width;
2680             minh = self->base_size.height;
2681         }
2682
2683         /* if this is a user-requested resize, then check against min/max
2684            sizes */
2685
2686         /* smaller than min size or bigger than max size? */
2687         if (*w > self->max_size.width) *w = self->max_size.width;
2688         if (*w < minw) *w = minw;
2689         if (*h > self->max_size.height) *h = self->max_size.height;
2690         if (*h < minh) *h = minh;
2691
2692         *w -= basew;
2693         *h -= baseh;
2694
2695         /* keep to the increments */
2696         *w /= self->size_inc.width;
2697         *h /= self->size_inc.height;
2698
2699         /* you cannot resize to nothing */
2700         if (basew + *w < 1) *w = 1 - basew;
2701         if (baseh + *h < 1) *h = 1 - baseh;
2702
2703         /* save the logical size */
2704         *logicalw = self->size_inc.width > 1 ? *w : *w + basew;
2705         *logicalh = self->size_inc.height > 1 ? *h : *h + baseh;
2706
2707         *w *= self->size_inc.width;
2708         *h *= self->size_inc.height;
2709
2710         *w += basew;
2711         *h += baseh;
2712
2713         /* adjust the height to match the width for the aspect ratios.
2714            for this, min size is not substituted for base size ever. */
2715         *w -= self->base_size.width;
2716         *h -= self->base_size.height;
2717
2718         if (!self->fullscreen) {
2719             if (self->min_ratio)
2720                 if (*h * self->min_ratio > *w) {
2721                     *h = (gint)(*w / self->min_ratio);
2722
2723                     /* you cannot resize to nothing */
2724                     if (*h < 1) {
2725                         *h = 1;
2726                         *w = (gint)(*h * self->min_ratio);
2727                     }
2728                 }
2729             if (self->max_ratio)
2730                 if (*h * self->max_ratio < *w) {
2731                     *h = (gint)(*w / self->max_ratio);
2732
2733                     /* you cannot resize to nothing */
2734                     if (*h < 1) {
2735                         *h = 1;
2736                         *w = (gint)(*h * self->min_ratio);
2737                     }
2738                 }
2739         }
2740
2741         *w += self->base_size.width;
2742         *h += self->base_size.height;
2743     }
2744
2745     /* gets the frame's position */
2746     frame_client_gravity(self->frame, x, y, *w, *h);
2747
2748     /* these positions are frame positions, not client positions */
2749
2750     /* set the size and position if fullscreen */
2751     if (self->fullscreen) {
2752         Rect *a;
2753         guint i;
2754
2755         i = screen_find_monitor(&desired_area);
2756         a = screen_physical_area_monitor(i);
2757
2758         *x = a->x;
2759         *y = a->y;
2760         *w = a->width;
2761         *h = a->height;
2762
2763         user = FALSE; /* ignore if the client can't be moved/resized when it
2764                          is fullscreening */
2765     } else if (self->max_horz || self->max_vert) {
2766         Rect *a;
2767         guint i;
2768
2769         i = screen_find_monitor(&desired_area);
2770         a = screen_area_monitor(self->desktop, i);
2771
2772         /* set the size and position if maximized */
2773         if (self->max_horz) {
2774             *x = a->x;
2775             *w = a->width - self->frame->size.left - self->frame->size.right;
2776         }
2777         if (self->max_vert) {
2778             *y = a->y;
2779             *h = a->height - self->frame->size.top - self->frame->size.bottom;
2780         }
2781
2782         user = FALSE; /* ignore if the client can't be moved/resized when it
2783                          is maximizing */
2784     }
2785
2786     /* gets the client's position */
2787     frame_frame_gravity(self->frame, x, y, *w, *h);
2788
2789     /* these override the above states! if you cant move you can't move! */
2790     if (user) {
2791         if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
2792             *x = self->area.x;
2793             *y = self->area.y;
2794         }
2795         if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
2796             *w = self->area.width;
2797             *h = self->area.height;
2798         }
2799     }
2800
2801     g_assert(*w > 0);
2802     g_assert(*h > 0);
2803 }
2804
2805
2806 void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
2807                       gboolean user, gboolean final)
2808 {
2809     gint oldw, oldh;
2810     gboolean send_resize_client;
2811     gboolean moved = FALSE, resized = FALSE;
2812     gboolean fmoved, fresized;
2813     guint fdecor = self->frame->decorations;
2814     gboolean fhorz = self->frame->max_horz;
2815     gboolean fvert = self->frame->max_vert;
2816     gint logicalw, logicalh;
2817
2818     /* find the new x, y, width, and height (and logical size) */
2819     client_try_configure(self, &x, &y, &w, &h, &logicalw, &logicalh, user);
2820
2821     /* set the logical size if things changed */
2822     if (!(w == self->area.width && h == self->area.height))
2823         SIZE_SET(self->logical_size, logicalw, logicalh);
2824
2825     /* figure out if we moved or resized or what */
2826     moved = (x != self->area.x || y != self->area.y);
2827     resized = (w != self->area.width || h != self->area.height);
2828
2829     oldw = self->area.width;
2830     oldh = self->area.height;
2831     RECT_SET(self->area, x, y, w, h);
2832
2833     /* for app-requested resizes, always resize if 'resized' is true.
2834        for user-requested ones, only resize if final is true, or when
2835        resizing in redraw mode */
2836     send_resize_client = ((!user && resized) ||
2837                           (user && (final ||
2838                                     (resized && config_resize_redraw))));
2839
2840     /* if the client is enlarging, then resize the client before the frame */
2841     if (send_resize_client && (w > oldw || h > oldh)) {
2842         XMoveResizeWindow(ob_display, self->window,
2843                           self->frame->size.left, self->frame->size.top,
2844                           MAX(w, oldw), MAX(h, oldh));
2845         frame_adjust_client_area(self->frame);
2846     }
2847
2848     /* find the frame's dimensions and move/resize it */
2849     fmoved = moved;
2850     fresized = resized;
2851
2852     /* if decorations changed, then readjust everything for the frame */
2853     if (self->decorations != fdecor ||
2854         self->max_horz != fhorz || self->max_vert != fvert)
2855     {
2856         fmoved = fresized = TRUE;
2857     }
2858
2859     /* adjust the frame */
2860     if (fmoved || fresized)
2861         frame_adjust_area(self->frame, fmoved, fresized, FALSE);
2862
2863     /* This is kinda tricky and should not be changed.. let me explain!
2864
2865        When user = FALSE, then the request is coming from the application
2866        itself, and we are more strict about when to send a synthetic
2867        ConfigureNotify.  We strictly follow the rules of the ICCCM sec 4.1.5
2868        in this case.
2869
2870        When user = TRUE, then the request is coming from "us", like when we
2871        maximize a window or sometihng.  In this case we are more lenient.  We
2872        used to follow the same rules as above, but _Java_ Swing can't handle
2873        this. So just to appease Swing, when user = TRUE, we always send
2874        a synthetic ConfigureNotify to give the window its root coordinates.
2875     */
2876     if ((!user && !resized) || (user && final))
2877     {
2878         XEvent event;
2879
2880         /* we have reset the client to 0 border width, so don't include
2881            it in these coords */
2882         POINT_SET(self->root_pos,
2883                   self->frame->area.x + self->frame->size.left -
2884                   self->border_width,
2885                   self->frame->area.y + self->frame->size.top -
2886                   self->border_width);
2887
2888         event.type = ConfigureNotify;
2889         event.xconfigure.display = ob_display;
2890         event.xconfigure.event = self->window;
2891         event.xconfigure.window = self->window;
2892
2893         ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
2894                  self->title, self->root_pos.x, self->root_pos.y, w, h);
2895
2896         /* root window real coords */
2897         event.xconfigure.x = self->root_pos.x;
2898         event.xconfigure.y = self->root_pos.y;
2899         event.xconfigure.width = w;
2900         event.xconfigure.height = h;
2901         event.xconfigure.border_width = self->border_width;
2902         event.xconfigure.above = None;
2903         event.xconfigure.override_redirect = FALSE;
2904         XSendEvent(event.xconfigure.display, event.xconfigure.window,
2905                    FALSE, StructureNotifyMask, &event);
2906     }
2907
2908     /* if the client is shrinking, then resize the frame before the client.
2909
2910        both of these resize sections may run, because the top one only resizes
2911        in the direction that is growing
2912      */
2913     if (send_resize_client && (w <= oldw || h <= oldh)) {
2914         frame_adjust_client_area(self->frame);
2915         XMoveResizeWindow(ob_display, self->window,
2916                           self->frame->size.left, self->frame->size.top, w, h);
2917     }
2918
2919     XFlush(ob_display);
2920 }
2921
2922 void client_fullscreen(ObClient *self, gboolean fs)
2923 {
2924     gint x, y, w, h;
2925
2926     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
2927         self->fullscreen == fs) return;                   /* already done */
2928
2929     self->fullscreen = fs;
2930     client_change_state(self); /* change the state hints on the client */
2931
2932     if (fs) {
2933         self->pre_fullscreen_area = self->area;
2934         /* if the window is maximized, its area isn't all that meaningful.
2935            save it's premax area instead. */
2936         if (self->max_horz) {
2937             self->pre_fullscreen_area.x = self->pre_max_area.x;
2938             self->pre_fullscreen_area.width = self->pre_max_area.width;
2939         }
2940         if (self->max_vert) {
2941             self->pre_fullscreen_area.y = self->pre_max_area.y;
2942             self->pre_fullscreen_area.height = self->pre_max_area.height;
2943         }
2944
2945         /* these will help configure_full figure out where to fullscreen
2946            the window */
2947         x = self->area.x;
2948         y = self->area.y;
2949         w = self->area.width;
2950         h = self->area.height;
2951     } else {
2952         g_assert(self->pre_fullscreen_area.width > 0 &&
2953                  self->pre_fullscreen_area.height > 0);
2954
2955         x = self->pre_fullscreen_area.x;
2956         y = self->pre_fullscreen_area.y;
2957         w = self->pre_fullscreen_area.width;
2958         h = self->pre_fullscreen_area.height;
2959         RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
2960     }
2961
2962     client_setup_decor_and_functions(self, FALSE);
2963     client_move_resize(self, x, y, w, h);
2964
2965     /* and adjust our layer/stacking. do this after resizing the window,
2966        and applying decorations, because windows which fill the screen are
2967        considered "fullscreen" and it affects their layer */
2968     client_calc_layer(self);
2969
2970     if (fs) {
2971         /* try focus us when we go into fullscreen mode */
2972         client_focus(self);
2973     }
2974 }
2975
2976 static void client_iconify_recursive(ObClient *self,
2977                                      gboolean iconic, gboolean curdesk,
2978                                      gboolean hide_animation)
2979 {
2980     GSList *it;
2981     gboolean changed = FALSE;
2982
2983
2984     if (self->iconic != iconic) {
2985         ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
2986                  self->window);
2987
2988         if (iconic) {
2989             /* don't let non-normal windows iconify along with their parents
2990                or whatever */
2991             if (client_normal(self)) {
2992                 self->iconic = iconic;
2993
2994                 /* update the focus lists.. iconic windows go to the bottom of
2995                    the list */
2996                 focus_order_to_bottom(self);
2997
2998                 changed = TRUE;
2999             }
3000         } else {
3001             self->iconic = iconic;
3002
3003             if (curdesk && self->desktop != screen_desktop &&
3004                 self->desktop != DESKTOP_ALL)
3005                 client_set_desktop(self, screen_desktop, FALSE);
3006
3007             /* this puts it after the current focused window */
3008             focus_order_remove(self);
3009             focus_order_add_new(self);
3010
3011             changed = TRUE;
3012         }
3013     }
3014
3015     if (changed) {
3016         client_change_state(self);
3017         if (config_animate_iconify && !hide_animation)
3018             frame_begin_iconify_animation(self->frame, iconic);
3019         /* do this after starting the animation so it doesn't flash */
3020         client_showhide(self);
3021     }
3022
3023     /* iconify all direct transients, and deiconify all transients
3024        (non-direct too) */
3025     for (it = self->transients; it; it = g_slist_next(it))
3026         if (it->data != self)
3027             if (client_is_direct_child(self, it->data) || !iconic)
3028                 client_iconify_recursive(it->data, iconic, curdesk,
3029                                          hide_animation);
3030 }
3031
3032 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk,
3033                     gboolean hide_animation)
3034 {
3035     if (self->functions & OB_CLIENT_FUNC_ICONIFY || !iconic) {
3036         /* move up the transient chain as far as possible first */
3037         self = client_search_top_direct_parent(self);
3038         client_iconify_recursive(self, iconic, curdesk, hide_animation);
3039     }
3040 }
3041
3042 void client_maximize(ObClient *self, gboolean max, gint dir)
3043 {
3044     gint x, y, w, h;
3045
3046     g_assert(dir == 0 || dir == 1 || dir == 2);
3047     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
3048
3049     /* check if already done */
3050     if (max) {
3051         if (dir == 0 && self->max_horz && self->max_vert) return;
3052         if (dir == 1 && self->max_horz) return;
3053         if (dir == 2 && self->max_vert) return;
3054     } else {
3055         if (dir == 0 && !self->max_horz && !self->max_vert) return;
3056         if (dir == 1 && !self->max_horz) return;
3057         if (dir == 2 && !self->max_vert) return;
3058     }
3059
3060     /* these will help configure_full figure out which screen to fill with
3061        the window */
3062     x = self->area.x;
3063     y = self->area.y;
3064     w = self->area.width;
3065     h = self->area.height;
3066
3067     if (max) {
3068         if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
3069             RECT_SET(self->pre_max_area,
3070                      self->area.x, self->pre_max_area.y,
3071                      self->area.width, self->pre_max_area.height);
3072         }
3073         if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
3074             RECT_SET(self->pre_max_area,
3075                      self->pre_max_area.x, self->area.y,
3076                      self->pre_max_area.width, self->area.height);
3077         }
3078     } else {
3079         if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
3080             g_assert(self->pre_max_area.width > 0);
3081
3082             x = self->pre_max_area.x;
3083             w = self->pre_max_area.width;
3084
3085             RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
3086                      0, self->pre_max_area.height);
3087         }
3088         if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
3089             g_assert(self->pre_max_area.height > 0);
3090
3091             y = self->pre_max_area.y;
3092             h = self->pre_max_area.height;
3093
3094             RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
3095                      self->pre_max_area.width, 0);
3096         }
3097     }
3098
3099     if (dir == 0 || dir == 1) /* horz */
3100         self->max_horz = max;
3101     if (dir == 0 || dir == 2) /* vert */
3102         self->max_vert = max;
3103
3104     client_change_state(self); /* change the state hints on the client */
3105
3106     client_setup_decor_and_functions(self, FALSE);
3107     client_move_resize(self, x, y, w, h);
3108 }
3109
3110 void client_shade(ObClient *self, gboolean shade)
3111 {
3112     if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
3113          shade) ||                         /* can't shade */
3114         self->shaded == shade) return;     /* already done */
3115
3116     self->shaded = shade;
3117     client_change_state(self);
3118     client_change_wm_state(self); /* the window is being hidden/shown */
3119     /* resize the frame to just the titlebar */
3120     frame_adjust_area(self->frame, FALSE, FALSE, FALSE);
3121 }
3122
3123 void client_close(ObClient *self)
3124 {
3125     XEvent ce;
3126
3127     if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
3128
3129     /* in the case that the client provides no means to requesting that it
3130        close, we just kill it */
3131     if (!self->delete_window)
3132         client_kill(self);
3133
3134     /*
3135       XXX: itd be cool to do timeouts and shit here for killing the client's
3136       process off
3137       like... if the window is around after 5 seconds, then the close button
3138       turns a nice red, and if this function is called again, the client is
3139       explicitly killed.
3140     */
3141
3142     ce.xclient.type = ClientMessage;
3143     ce.xclient.message_type =  prop_atoms.wm_protocols;
3144     ce.xclient.display = ob_display;
3145     ce.xclient.window = self->window;
3146     ce.xclient.format = 32;
3147     ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
3148     ce.xclient.data.l[1] = event_curtime;
3149     ce.xclient.data.l[2] = 0l;
3150     ce.xclient.data.l[3] = 0l;
3151     ce.xclient.data.l[4] = 0l;
3152     XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3153 }
3154
3155 void client_kill(ObClient *self)
3156 {
3157     XKillClient(ob_display, self->window);
3158 }
3159
3160 void client_hilite(ObClient *self, gboolean hilite)
3161 {
3162     if (self->demands_attention == hilite)
3163         return; /* no change */
3164
3165     /* don't allow focused windows to hilite */
3166     self->demands_attention = hilite && !client_focused(self);
3167     if (self->frame != NULL) { /* if we're mapping, just set the state */
3168         if (self->demands_attention)
3169             frame_flash_start(self->frame);
3170         else
3171             frame_flash_stop(self->frame);
3172         client_change_state(self);
3173     }
3174 }
3175
3176 void client_set_desktop_recursive(ObClient *self,
3177                                   guint target,
3178                                   gboolean donthide)
3179 {
3180     guint old;
3181     GSList *it;
3182
3183     if (target != self->desktop && self->type != OB_CLIENT_TYPE_DESKTOP) {
3184
3185         ob_debug("Setting desktop %u\n", target+1);
3186
3187         g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
3188
3189         old = self->desktop;
3190         self->desktop = target;
3191         PROP_SET32(self->window, net_wm_desktop, cardinal, target);
3192         /* the frame can display the current desktop state */
3193         frame_adjust_state(self->frame);
3194         /* 'move' the window to the new desktop */
3195         if (!donthide)
3196             client_showhide(self);
3197         /* raise if it was not already on the desktop */
3198         if (old != DESKTOP_ALL)
3199             stacking_raise(CLIENT_AS_WINDOW(self));
3200         if (STRUT_EXISTS(self->strut))
3201             screen_update_areas();
3202     }
3203
3204     /* move all transients */
3205     for (it = self->transients; it; it = g_slist_next(it))
3206         if (it->data != self)
3207             if (client_is_direct_child(self, it->data))
3208                 client_set_desktop_recursive(it->data, target, donthide);
3209 }
3210
3211 void client_set_desktop(ObClient *self, guint target, gboolean donthide)
3212 {
3213     self = client_search_top_direct_parent(self);
3214     client_set_desktop_recursive(self, target, donthide);
3215 }
3216
3217 gboolean client_is_direct_child(ObClient *parent, ObClient *child)
3218 {
3219     while (child != parent && (child = client_direct_parent(child)));
3220     return child == parent;
3221 }
3222
3223 ObClient *client_search_modal_child(ObClient *self)
3224 {
3225     GSList *it;
3226     ObClient *ret;
3227
3228     for (it = self->transients; it; it = g_slist_next(it)) {
3229         ObClient *c = it->data;
3230         if ((ret = client_search_modal_child(c))) return ret;
3231         if (c->modal) return c;
3232     }
3233     return NULL;
3234 }
3235
3236 gboolean client_validate(ObClient *self)
3237 {
3238     XEvent e;
3239
3240     XSync(ob_display, FALSE); /* get all events on the server */
3241
3242     if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
3243         XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
3244         XPutBackEvent(ob_display, &e);
3245         return FALSE;
3246     }
3247
3248     return TRUE;
3249 }
3250
3251 void client_set_wm_state(ObClient *self, glong state)
3252 {
3253     if (state == self->wmstate) return; /* no change */
3254
3255     switch (state) {
3256     case IconicState:
3257         client_iconify(self, TRUE, TRUE, FALSE);
3258         break;
3259     case NormalState:
3260         client_iconify(self, FALSE, TRUE, FALSE);
3261         break;
3262     }
3263 }
3264
3265 void client_set_state(ObClient *self, Atom action, glong data1, glong data2)
3266 {
3267     gboolean shaded = self->shaded;
3268     gboolean fullscreen = self->fullscreen;
3269     gboolean undecorated = self->undecorated;
3270     gboolean max_horz = self->max_horz;
3271     gboolean max_vert = self->max_vert;
3272     gboolean modal = self->modal;
3273     gboolean iconic = self->iconic;
3274     gboolean demands_attention = self->demands_attention;
3275     gboolean above = self->above;
3276     gboolean below = self->below;
3277     gint i;
3278
3279     if (!(action == prop_atoms.net_wm_state_add ||
3280           action == prop_atoms.net_wm_state_remove ||
3281           action == prop_atoms.net_wm_state_toggle))
3282         /* an invalid action was passed to the client message, ignore it */
3283         return;
3284
3285     for (i = 0; i < 2; ++i) {
3286         Atom state = i == 0 ? data1 : data2;
3287
3288         if (!state) continue;
3289
3290         /* if toggling, then pick whether we're adding or removing */
3291         if (action == prop_atoms.net_wm_state_toggle) {
3292             if (state == prop_atoms.net_wm_state_modal)
3293                 action = modal ? prop_atoms.net_wm_state_remove :
3294                     prop_atoms.net_wm_state_add;
3295             else if (state == prop_atoms.net_wm_state_maximized_vert)
3296                 action = self->max_vert ? prop_atoms.net_wm_state_remove :
3297                     prop_atoms.net_wm_state_add;
3298             else if (state == prop_atoms.net_wm_state_maximized_horz)
3299                 action = self->max_horz ? prop_atoms.net_wm_state_remove :
3300                     prop_atoms.net_wm_state_add;
3301             else if (state == prop_atoms.net_wm_state_shaded)
3302                 action = shaded ? prop_atoms.net_wm_state_remove :
3303                     prop_atoms.net_wm_state_add;
3304             else if (state == prop_atoms.net_wm_state_skip_taskbar)
3305                 action = self->skip_taskbar ?
3306                     prop_atoms.net_wm_state_remove :
3307                     prop_atoms.net_wm_state_add;
3308             else if (state == prop_atoms.net_wm_state_skip_pager)
3309                 action = self->skip_pager ?
3310                     prop_atoms.net_wm_state_remove :
3311                     prop_atoms.net_wm_state_add;
3312             else if (state == prop_atoms.net_wm_state_hidden)
3313                 action = self->iconic ?
3314                     prop_atoms.net_wm_state_remove :
3315                     prop_atoms.net_wm_state_add;
3316             else if (state == prop_atoms.net_wm_state_fullscreen)
3317                 action = fullscreen ?
3318                     prop_atoms.net_wm_state_remove :
3319                     prop_atoms.net_wm_state_add;
3320             else if (state == prop_atoms.net_wm_state_above)
3321                 action = self->above ? prop_atoms.net_wm_state_remove :
3322                     prop_atoms.net_wm_state_add;
3323             else if (state == prop_atoms.net_wm_state_below)
3324                 action = self->below ? prop_atoms.net_wm_state_remove :
3325                     prop_atoms.net_wm_state_add;
3326             else if (state == prop_atoms.net_wm_state_demands_attention)
3327                 action = self->demands_attention ?
3328                     prop_atoms.net_wm_state_remove :
3329                     prop_atoms.net_wm_state_add;
3330             else if (state == prop_atoms.ob_wm_state_undecorated)
3331                 action = undecorated ? prop_atoms.net_wm_state_remove :
3332                     prop_atoms.net_wm_state_add;
3333         }
3334
3335         if (action == prop_atoms.net_wm_state_add) {
3336             if (state == prop_atoms.net_wm_state_modal) {
3337                 modal = TRUE;
3338             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3339                 max_vert = TRUE;
3340             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3341                 max_horz = TRUE;
3342             } else if (state == prop_atoms.net_wm_state_shaded) {
3343                 shaded = TRUE;
3344             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3345                 self->skip_taskbar = TRUE;
3346             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3347                 self->skip_pager = TRUE;
3348             } else if (state == prop_atoms.net_wm_state_hidden) {
3349                 iconic = TRUE;
3350             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3351                 fullscreen = TRUE;
3352             } else if (state == prop_atoms.net_wm_state_above) {
3353                 above = TRUE;
3354                 below = FALSE;
3355             } else if (state == prop_atoms.net_wm_state_below) {
3356                 above = FALSE;
3357                 below = TRUE;
3358             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3359                 demands_attention = TRUE;
3360             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3361                 undecorated = TRUE;
3362             }
3363
3364         } else { /* action == prop_atoms.net_wm_state_remove */
3365             if (state == prop_atoms.net_wm_state_modal) {
3366                 modal = FALSE;
3367             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3368                 max_vert = FALSE;
3369             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3370                 max_horz = FALSE;
3371             } else if (state == prop_atoms.net_wm_state_shaded) {
3372                 shaded = FALSE;
3373             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3374                 self->skip_taskbar = FALSE;
3375             } else if (state == prop_atoms.net_wm_state_skip_pager) {
3376                 self->skip_pager = FALSE;
3377             } else if (state == prop_atoms.net_wm_state_hidden) {
3378                 iconic = FALSE;
3379             } else if (state == prop_atoms.net_wm_state_fullscreen) {
3380                 fullscreen = FALSE;
3381             } else if (state == prop_atoms.net_wm_state_above) {
3382                 above = FALSE;
3383             } else if (state == prop_atoms.net_wm_state_below) {
3384                 below = FALSE;
3385             } else if (state == prop_atoms.net_wm_state_demands_attention) {
3386                 demands_attention = FALSE;
3387             } else if (state == prop_atoms.ob_wm_state_undecorated) {
3388                 undecorated = FALSE;
3389             }
3390         }
3391     }
3392
3393     if (max_horz != self->max_horz || max_vert != self->max_vert) {
3394         if (max_horz != self->max_horz && max_vert != self->max_vert) {
3395             /* toggling both */
3396             if (max_horz == max_vert) { /* both going the same way */
3397                 client_maximize(self, max_horz, 0);
3398             } else {
3399                 client_maximize(self, max_horz, 1);
3400                 client_maximize(self, max_vert, 2);
3401             }
3402         } else {
3403             /* toggling one */
3404             if (max_horz != self->max_horz)
3405                 client_maximize(self, max_horz, 1);
3406             else
3407                 client_maximize(self, max_vert, 2);
3408         }
3409     }
3410     /* change fullscreen state before shading, as it will affect if the window
3411        can shade or not */
3412     if (fullscreen != self->fullscreen)
3413         client_fullscreen(self, fullscreen);
3414     if (shaded != self->shaded)
3415         client_shade(self, shaded);
3416     if (undecorated != self->undecorated)
3417         client_set_undecorated(self, undecorated);
3418     if (above != self->above || below != self->below) {
3419         self->above = above;
3420         self->below = below;
3421         client_calc_layer(self);
3422     }
3423
3424     if (modal != self->modal) {
3425         self->modal = modal;
3426         /* when a window changes modality, then its stacking order with its
3427            transients needs to change */
3428         stacking_raise(CLIENT_AS_WINDOW(self));
3429
3430         /* it also may get focused. if something is focused that shouldn't
3431            be focused anymore, then move the focus */
3432         if (focus_client && client_focus_target(focus_client) != focus_client)
3433             client_focus(focus_client);
3434     }
3435
3436     if (iconic != self->iconic)
3437         client_iconify(self, iconic, FALSE, FALSE);
3438
3439     if (demands_attention != self->demands_attention)
3440         client_hilite(self, demands_attention);
3441
3442     client_change_state(self); /* change the hint to reflect these changes */
3443 }
3444
3445 ObClient *client_focus_target(ObClient *self)
3446 {
3447     ObClient *child = NULL;
3448
3449     child = client_search_modal_child(self);
3450     if (child) return child;
3451     return self;
3452 }
3453
3454 gboolean client_can_focus(ObClient *self)
3455 {
3456     /* choose the correct target */
3457     self = client_focus_target(self);
3458
3459     if (!self->frame->visible)
3460         return FALSE;
3461
3462     if (!(self->can_focus || self->focus_notify))
3463         return FALSE;
3464
3465     return TRUE;
3466 }
3467
3468 gboolean client_focus(ObClient *self)
3469 {
3470     /* we might not focus this window, so if we have modal children which would
3471        be focused instead, bring them to this desktop */
3472     client_bring_modal_windows(self);
3473
3474     /* choose the correct target */
3475     self = client_focus_target(self);
3476
3477     if (!client_can_focus(self)) {
3478         ob_debug_type(OB_DEBUG_FOCUS,
3479                       "Client %s can't be focused\n", self->title);
3480         return FALSE;
3481     }
3482
3483     ob_debug_type(OB_DEBUG_FOCUS,
3484                   "Focusing client \"%s\" (0x%x) at time %u\n",
3485                   self->title, self->window, event_curtime);
3486
3487     /* if there is a grab going on, then we need to cancel it. if we move
3488        focus during the grab, applications will get NotifyWhileGrabbed events
3489        and ignore them !
3490
3491        actions should not rely on being able to move focus during an
3492        interactive grab.
3493     */
3494     event_cancel_all_key_grabs();
3495
3496     xerror_set_ignore(TRUE);
3497     xerror_occured = FALSE;
3498
3499     if (self->can_focus) {
3500         /* This can cause a BadMatch error with CurrentTime, or if an app
3501            passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3502         XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
3503                        event_curtime);
3504     }
3505
3506     if (self->focus_notify) {
3507         XEvent ce;
3508         ce.xclient.type = ClientMessage;
3509         ce.xclient.message_type = prop_atoms.wm_protocols;
3510         ce.xclient.display = ob_display;
3511         ce.xclient.window = self->window;
3512         ce.xclient.format = 32;
3513         ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
3514         ce.xclient.data.l[1] = event_curtime;
3515         ce.xclient.data.l[2] = 0l;
3516         ce.xclient.data.l[3] = 0l;
3517         ce.xclient.data.l[4] = 0l;
3518         XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3519     }
3520
3521     xerror_set_ignore(FALSE);
3522
3523     ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d\n", xerror_occured);
3524     return !xerror_occured;
3525 }
3526
3527 /*! Present the client to the user.
3528   @param raise If the client should be raised or not. You should only set
3529                raise to false if you don't care if the window is completely
3530                hidden.
3531 */
3532 static void client_present(ObClient *self, gboolean here, gboolean raise)
3533 {
3534     /* if using focus_delay, stop the timer now so that focus doesn't
3535        go moving on us */
3536     event_halt_focus_delay();
3537
3538     if (client_normal(self) && screen_showing_desktop)
3539         screen_show_desktop(FALSE, self);
3540     if (self->iconic)
3541         client_iconify(self, FALSE, here, FALSE);
3542     if (self->desktop != DESKTOP_ALL &&
3543         self->desktop != screen_desktop)
3544     {
3545         if (here)
3546             client_set_desktop(self, screen_desktop, FALSE);
3547         else
3548             screen_set_desktop(self->desktop, FALSE);
3549     } else if (!self->frame->visible)
3550         /* if its not visible for other reasons, then don't mess
3551            with it */
3552         return;
3553     if (self->shaded)
3554         client_shade(self, FALSE);
3555     if (raise)
3556         stacking_raise(CLIENT_AS_WINDOW(self));
3557
3558     client_focus(self);
3559 }
3560
3561 void client_activate(ObClient *self, gboolean here, gboolean user)
3562 {
3563     guint32 last_time = focus_client ? focus_client->user_time : CurrentTime;
3564     gboolean allow = FALSE;
3565
3566     /* if the request came from the user, or if nothing is focused, then grant
3567        the request.
3568        if the currently focused app doesn't set a user_time, then it can't
3569        benefit from any focus stealing prevention.
3570     */
3571     if (user || !focus_client || !last_time)
3572         allow = TRUE;
3573     /* otherwise, if they didn't give a time stamp or if it is too old, they
3574        don't get focus */
3575     else
3576         allow = event_curtime && event_time_after(event_curtime, last_time);
3577
3578     ob_debug_type(OB_DEBUG_FOCUS,
3579                   "Want to activate window 0x%x with time %u (last time %u), "
3580                   "source=%s allowing? %d\n",
3581                   self->window, event_curtime, last_time,
3582                   (user ? "user" : "application"), allow);
3583
3584     if (allow)
3585         client_present(self, here, TRUE);
3586     else
3587         /* don't focus it but tell the user it wants attention */
3588         client_hilite(self, TRUE);
3589 }
3590
3591 static void client_bring_windows_recursive(ObClient *self,
3592                                            guint desktop,
3593                                            gboolean helpers,
3594                                            gboolean modals,
3595                                            gboolean iconic)
3596 {
3597     GSList *it;
3598
3599     for (it = self->transients; it; it = g_slist_next(it))
3600         client_bring_windows_recursive(it->data, desktop,
3601                                        helpers, modals, iconic);
3602
3603     if (((helpers && client_helper(self)) ||
3604          (modals && self->modal)) &&
3605         ((self->desktop != desktop && self->desktop != DESKTOP_ALL) ||
3606          (iconic && self->iconic)))
3607     {
3608         if (iconic && self->iconic)
3609             client_iconify(self, FALSE, TRUE, FALSE);
3610         else
3611             client_set_desktop(self, desktop, FALSE);
3612     }
3613 }
3614
3615 void client_bring_helper_windows(ObClient *self)
3616 {
3617     client_bring_windows_recursive(self, self->desktop, TRUE, FALSE, FALSE);
3618 }
3619
3620 void client_bring_modal_windows(ObClient *self)
3621 {
3622     client_bring_windows_recursive(self, self->desktop, FALSE, TRUE, TRUE);
3623 }
3624
3625 gboolean client_focused(ObClient *self)
3626 {
3627     return self == focus_client;
3628 }
3629
3630 static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h)
3631 {
3632     guint i;
3633     gulong min_diff, min_i;
3634
3635     if (!self->nicons) {
3636         ObClientIcon *parent = NULL;
3637         GSList *it;
3638
3639         for (it = self->parents; it; it = g_slist_next(it)) {
3640             ObClient *c = it->data;
3641             if ((parent = client_icon_recursive(c, w, h)))
3642                 break;
3643         }
3644
3645         return parent;
3646     }
3647
3648     /* some kind of crappy approximation to find the icon closest in size to
3649        what we requested, but icons are generally all the same ratio as
3650        eachother so it's good enough. */
3651
3652     min_diff = ABS(self->icons[0].width - w) + ABS(self->icons[0].height - h);
3653     min_i = 0;
3654
3655     for (i = 1; i < self->nicons; ++i) {
3656         gulong diff;
3657
3658         diff = ABS(self->icons[i].width - w) + ABS(self->icons[i].height - h);
3659         if (diff < min_diff) {
3660             min_diff = diff;
3661             min_i = i;
3662         }
3663     }
3664     return &self->icons[min_i];
3665 }
3666
3667 const ObClientIcon* client_icon(ObClient *self, gint w, gint h)
3668 {
3669     ObClientIcon *ret;
3670     static ObClientIcon deficon;
3671
3672     if (!(ret = client_icon_recursive(self, w, h))) {
3673         deficon.width = deficon.height = 48;
3674         deficon.data = ob_rr_theme->def_win_icon;
3675         ret = &deficon;
3676     }
3677     return ret;
3678 }
3679
3680 void client_set_layer(ObClient *self, gint layer)
3681 {
3682     if (layer < 0) {
3683         self->below = TRUE;
3684         self->above = FALSE;
3685     } else if (layer == 0) {
3686         self->below = self->above = FALSE;
3687     } else {
3688         self->below = FALSE;
3689         self->above = TRUE;
3690     }
3691     client_calc_layer(self);
3692     client_change_state(self); /* reflect this in the state hints */
3693 }
3694
3695 void client_set_undecorated(ObClient *self, gboolean undecorated)
3696 {
3697     if (self->undecorated != undecorated &&
3698         /* don't let it undecorate if the function is missing, but let
3699            it redecorate */
3700         (self->functions & OB_CLIENT_FUNC_UNDECORATE || !undecorated))
3701     {
3702         self->undecorated = undecorated;
3703         client_setup_decor_and_functions(self, TRUE);
3704         client_change_state(self); /* reflect this in the state hints */
3705     }
3706 }
3707
3708 guint client_monitor(ObClient *self)
3709 {
3710     return screen_find_monitor(&self->frame->area);
3711 }
3712
3713 ObClient *client_direct_parent(ObClient *self)
3714 {
3715     if (!self->parents) return NULL;
3716     if (self->transient_for == OB_TRAN_GROUP) return NULL;
3717     return self->parents->data;
3718 }
3719
3720 ObClient *client_search_top_direct_parent(ObClient *self)
3721 {
3722     ObClient *p;
3723     while ((p = client_direct_parent(self))) self = p;
3724     return self;
3725 }
3726
3727 static GSList *client_search_all_top_parents_internal(ObClient *self,
3728                                                       gboolean bylayer,
3729                                                       ObStackingLayer layer)
3730 {
3731     GSList *ret;
3732     ObClient *p;
3733
3734     /* move up the direct transient chain as far as possible */
3735     while ((p = client_direct_parent(self)) &&
3736            (!bylayer || p->layer == layer))
3737         self = p;
3738
3739     if (!self->parents)
3740         ret = g_slist_prepend(NULL, self);
3741     else
3742         ret = g_slist_copy(self->parents);
3743
3744     return ret;
3745 }
3746
3747 GSList *client_search_all_top_parents(ObClient *self)
3748 {
3749     return client_search_all_top_parents_internal(self, FALSE, 0);
3750 }
3751
3752 GSList *client_search_all_top_parents_layer(ObClient *self)
3753 {
3754     return client_search_all_top_parents_internal(self, TRUE, self->layer);
3755 }
3756
3757 ObClient *client_search_focus_parent(ObClient *self)
3758 {
3759     GSList *it;
3760
3761     for (it = self->parents; it; it = g_slist_next(it))
3762         if (client_focused(it->data)) return it->data;
3763
3764     return NULL;
3765 }
3766
3767 ObClient *client_search_parent(ObClient *self, ObClient *search)
3768 {
3769     GSList *it;
3770
3771     for (it = self->parents; it; it = g_slist_next(it))
3772         if (it->data == search) return search;
3773
3774     return NULL;
3775 }
3776
3777 ObClient *client_search_transient(ObClient *self, ObClient *search)
3778 {
3779     GSList *sit;
3780
3781     for (sit = self->transients; sit; sit = g_slist_next(sit)) {
3782         if (sit->data == search)
3783             return search;
3784         if (client_search_transient(sit->data, search))
3785             return search;
3786     }
3787     return NULL;
3788 }
3789
3790 #define WANT_EDGE(cur, c) \
3791             if (cur == c)                                                     \
3792                 continue;                                                     \
3793             if (c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL &&  \
3794                 cur->desktop != screen_desktop)                               \
3795                 continue;                                                     \
3796             if (cur->iconic)                                                  \
3797                 continue;
3798
3799 #define HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end) \
3800             if ((his_edge_start >= my_edge_start && \
3801                  his_edge_start <= my_edge_end) ||  \
3802                 (my_edge_start >= his_edge_start && \
3803                  my_edge_start <= his_edge_end))    \
3804                 dest = his_offset;
3805
3806 /* finds the nearest edge in the given direction from the current client
3807  * note to self: the edge is the -frame- edge (the actual one), not the
3808  * client edge.
3809  */
3810 gint client_directional_edge_search(ObClient *c, ObDirection dir, gboolean hang)
3811 {
3812     gint dest, monitor_dest;
3813     gint my_edge_start, my_edge_end, my_offset;
3814     GList *it;
3815     Rect *a, *monitor;
3816
3817     if(!client_list)
3818         return -1;
3819
3820     a = screen_area(c->desktop);
3821     monitor = screen_area_monitor(c->desktop, client_monitor(c));
3822
3823     switch(dir) {
3824     case OB_DIRECTION_NORTH:
3825         my_edge_start = c->frame->area.x;
3826         my_edge_end = c->frame->area.x + c->frame->area.width;
3827         my_offset = c->frame->area.y + (hang ? c->frame->area.height : 0);
3828
3829         /* default: top of screen */
3830         dest = a->y + (hang ? c->frame->area.height : 0);
3831         monitor_dest = monitor->y + (hang ? c->frame->area.height : 0);
3832         /* if the monitor edge comes before the screen edge, */
3833         /* use that as the destination instead. (For xinerama) */
3834         if (monitor_dest != dest && my_offset > monitor_dest)
3835             dest = monitor_dest;
3836
3837         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3838             gint his_edge_start, his_edge_end, his_offset;
3839             ObClient *cur = it->data;
3840
3841             WANT_EDGE(cur, c)
3842
3843             his_edge_start = cur->frame->area.x;
3844             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3845             his_offset = cur->frame->area.y +
3846                          (hang ? 0 : cur->frame->area.height);
3847
3848             if(his_offset + 1 > my_offset)
3849                 continue;
3850
3851             if(his_offset < dest)
3852                 continue;
3853
3854             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3855         }
3856         break;
3857     case OB_DIRECTION_SOUTH:
3858         my_edge_start = c->frame->area.x;
3859         my_edge_end = c->frame->area.x + c->frame->area.width;
3860         my_offset = c->frame->area.y + (hang ? 0 : c->frame->area.height);
3861
3862         /* default: bottom of screen */
3863         dest = a->y + a->height - (hang ? c->frame->area.height : 0);
3864         monitor_dest = monitor->y + monitor->height -
3865                        (hang ? c->frame->area.height : 0);
3866         /* if the monitor edge comes before the screen edge, */
3867         /* use that as the destination instead. (For xinerama) */
3868         if (monitor_dest != dest && my_offset < monitor_dest)
3869             dest = monitor_dest;
3870
3871         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3872             gint his_edge_start, his_edge_end, his_offset;
3873             ObClient *cur = it->data;
3874
3875             WANT_EDGE(cur, c)
3876
3877             his_edge_start = cur->frame->area.x;
3878             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3879             his_offset = cur->frame->area.y +
3880                          (hang ? cur->frame->area.height : 0);
3881
3882
3883             if(his_offset - 1 < my_offset)
3884                 continue;
3885
3886             if(his_offset > dest)
3887                 continue;
3888
3889             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3890         }
3891         break;
3892     case OB_DIRECTION_WEST:
3893         my_edge_start = c->frame->area.y;
3894         my_edge_end = c->frame->area.y + c->frame->area.height;
3895         my_offset = c->frame->area.x + (hang ? c->frame->area.width : 0);
3896
3897         /* default: leftmost egde of screen */
3898         dest = a->x + (hang ? c->frame->area.width : 0);
3899         monitor_dest = monitor->x + (hang ? c->frame->area.width : 0);
3900         /* if the monitor edge comes before the screen edge, */
3901         /* use that as the destination instead. (For xinerama) */
3902         if (monitor_dest != dest && my_offset > monitor_dest)
3903             dest = monitor_dest;
3904
3905         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3906             gint his_edge_start, his_edge_end, his_offset;
3907             ObClient *cur = it->data;
3908
3909             WANT_EDGE(cur, c)
3910
3911             his_edge_start = cur->frame->area.y;
3912             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3913             his_offset = cur->frame->area.x +
3914                          (hang ? 0 : cur->frame->area.width);
3915
3916             if(his_offset + 1 > my_offset)
3917                 continue;
3918
3919             if(his_offset < dest)
3920                 continue;
3921
3922             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3923         }
3924        break;
3925     case OB_DIRECTION_EAST:
3926         my_edge_start = c->frame->area.y;
3927         my_edge_end = c->frame->area.y + c->frame->area.height;
3928         my_offset = c->frame->area.x + (hang ? 0 : c->frame->area.width);
3929
3930         /* default: rightmost edge of screen */
3931         dest = a->x + a->width - (hang ? c->frame->area.width : 0);
3932         monitor_dest = monitor->x + monitor->width -
3933                        (hang ? c->frame->area.width : 0);
3934         /* if the monitor edge comes before the screen edge, */
3935         /* use that as the destination instead. (For xinerama) */
3936         if (monitor_dest != dest && my_offset < monitor_dest)
3937             dest = monitor_dest;
3938
3939         for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3940             gint his_edge_start, his_edge_end, his_offset;
3941             ObClient *cur = it->data;
3942
3943             WANT_EDGE(cur, c)
3944
3945             his_edge_start = cur->frame->area.y;
3946             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3947             his_offset = cur->frame->area.x +
3948                          (hang ? cur->frame->area.width : 0);
3949
3950             if(his_offset - 1 < my_offset)
3951                 continue;
3952
3953             if(his_offset > dest)
3954                 continue;
3955
3956             HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3957         }
3958         break;
3959     case OB_DIRECTION_NORTHEAST:
3960     case OB_DIRECTION_SOUTHEAST:
3961     case OB_DIRECTION_NORTHWEST:
3962     case OB_DIRECTION_SOUTHWEST:
3963         /* not implemented */
3964     default:
3965         g_assert_not_reached();
3966         dest = 0; /* suppress warning */
3967     }
3968     return dest;
3969 }
3970
3971 ObClient* client_under_pointer()
3972 {
3973     gint x, y;
3974     GList *it;
3975     ObClient *ret = NULL;
3976
3977     if (screen_pointer_pos(&x, &y)) {
3978         for (it = stacking_list; it; it = g_list_next(it)) {
3979             if (WINDOW_IS_CLIENT(it->data)) {
3980                 ObClient *c = WINDOW_AS_CLIENT(it->data);
3981                 if (c->frame->visible &&
3982                     /* ignore all animating windows */
3983                     !frame_iconify_animating(c->frame) &&
3984                     RECT_CONTAINS(c->frame->area, x, y))
3985                 {
3986                     ret = c;
3987                     break;
3988                 }
3989             }
3990         }
3991     }
3992     return ret;
3993 }
3994
3995 gboolean client_has_group_siblings(ObClient *self)
3996 {
3997     return self->group && self->group->members->next;
3998 }