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