openbox/client.c

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