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