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