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) 2003        Ben Jansens
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 See the COPYING file for a copy of the GNU General Public License.
  17 */
  18
  19 #include "client.h"
  20 #include "debug.h"
  21 #include "startupnotify.h"
  22 #include "dock.h"
  23 #include "xerror.h"
  24 #include "screen.h"
  25 #include "moveresize.h"
  26 #include "place.h"
  27 #include "prop.h"
  28 #include "extensions.h"
  29 #include "frame.h"
  30 #include "session.h"
  31 #include "event.h"
  32 #include "grab.h"
  33 #include "focus.h"
  34 #include "stacking.h"
  35 #include "openbox.h"
  36 #include "group.h"
  37 #include "config.h"
  38 #include "menuframe.h"
  39 #include "keyboard.h"
  40 #include "mouse.h"
  41 #include "render/render.h"
  42
  43 #include <glib.h>
  44 #include <X11/Xutil.h>
  45
  46 /*! The event mask to grab on client windows */
  47 #define CLIENT_EVENTMASK (PropertyChangeMask | FocusChangeMask | \
  48                           StructureNotifyMask)
  49
  50 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
  51                                 ButtonMotionMask)
  52
  53 typedef struct
  54 {
  55     ObClientDestructor func;
  56     gpointer data;
  57 } Destructor;
  58
  59 GList      *client_list        = NULL;
  60 GSList     *client_destructors = NULL;
  61
  62 static void client_get_all(ObClient *self);
  63 static void client_toggle_border(ObClient *self, gboolean show);
  64 static void client_get_startup_id(ObClient *self);
  65 static void client_get_area(ObClient *self);
  66 static void client_get_desktop(ObClient *self);
  67 static void client_get_state(ObClient *self);
  68 static void client_get_shaped(ObClient *self);
  69 static void client_get_mwm_hints(ObClient *self);
  70 static void client_get_gravity(ObClient *self);
  71 static void client_showhide(ObClient *self);
  72 static void client_change_allowed_actions(ObClient *self);
  73 static void client_change_state(ObClient *self);
  74 static void client_apply_startup_state(ObClient *self);
  75 static void client_restore_session_state(ObClient *self);
  76 static void client_restore_session_stacking(ObClient *self);
  77 static void client_urgent_notify(ObClient *self);
  78
  79 void client_startup(gboolean reconfig)
  80 {
  81     if (reconfig) return;
  82
  83     client_set_list();
  84 }
  85
  86 void client_shutdown(gboolean reconfig)
  87 {
  88 }
  89
  90 void client_add_destructor(ObClientDestructor func, gpointer data)
  91 {
  92     Destructor *d = g_new(Destructor, 1);
  93     d->func = func;
  94     d->data = data;
  95     client_destructors = g_slist_prepend(client_destructors, d);
  96 }
  97
  98 void client_remove_destructor(ObClientDestructor func)
  99 {
 100     GSList *it;
 101
 102     for (it = client_destructors; it; it = g_slist_next(it)) {
 103         Destructor *d = it->data;
 104         if (d->func == func) {
 105             g_free(d);
 106             client_destructors = g_slist_delete_link(client_destructors, it);
 107             break;
 108         }
 109     }
 110 }
 111
 112 void client_set_list()
 113 {
 114     Window *windows, *win_it;
 115     GList *it;
 116     guint size = g_list_length(client_list);
 117
 118     /* create an array of the window ids */
 119     if (size > 0) {
 120         windows = g_new(Window, size);
 121         win_it = windows;
 122         for (it = client_list; it != NULL; it = it->next, ++win_it)
 123             *win_it = ((ObClient*)it->data)->window;
 124     } else
 125         windows = NULL;
 126
 127     PROP_SETA32(RootWindow(ob_display, ob_screen),
 128                 net_client_list, window, (guint32*)windows, size);
 129
 130     if (windows)
 131         g_free(windows);
 132
 133     stacking_set_list();
 134 }
 135
 136 /*
 137   void client_foreach_transient(ObClient *self, ObClientForeachFunc func, void *data)
 138   {
 139   GSList *it;
 140
 141   for (it = self->transients; it; it = it->next) {
 142   if (!func(it->data, data)) return;
 143   client_foreach_transient(it->data, func, data);
 144   }
 145   }
 146
 147   void client_foreach_ancestor(ObClient *self, ObClientForeachFunc func, void *data)
 148   {
 149   if (self->transient_for) {
 150   if (self->transient_for != OB_TRAN_GROUP) {
 151   if (!func(self->transient_for, data)) return;
 152   client_foreach_ancestor(self->transient_for, func, data);
 153   } else {
 154   GSList *it;
 155
 156   for (it = self->group->members; it; it = it->next)
 157   if (it->data != self &&
 158   !((ObClient*)it->data)->transient_for) {
 159   if (!func(it->data, data)) return;
 160   client_foreach_ancestor(it->data, func, data);
 161   }
 162   }
 163   }
 164   }
 165 */
 166
 167 void client_manage_all()
 168 {
 169     unsigned int i, j, nchild;
 170     Window w, *children;
 171     XWMHints *wmhints;
 172     XWindowAttributes attrib;
 173
 174     XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
 175                &w, &w, &children, &nchild);
 176
 177     /* remove all icon windows from the list */
 178     for (i = 0; i < nchild; i++) {
 179         if (children[i] == None) continue;
 180         wmhints = XGetWMHints(ob_display, children[i]);
 181         if (wmhints) {
 182             if ((wmhints->flags & IconWindowHint) &&
 183                 (wmhints->icon_window != children[i]))
 184                 for (j = 0; j < nchild; j++)
 185                     if (children[j] == wmhints->icon_window) {
 186                         children[j] = None;
 187                         break;
 188                     }
 189             XFree(wmhints);
 190         }
 191     }
 192
 193     for (i = 0; i < nchild; ++i) {
 194         if (children[i] == None)
 195             continue;
 196         if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
 197             if (attrib.override_redirect) continue;
 198
 199             if (attrib.map_state != IsUnmapped)
 200                 client_manage(children[i]);
 201         }
 202     }
 203     XFree(children);
 204 }
 205
 206 void client_manage(Window window)
 207 {
 208     ObClient *self;
 209     XEvent e;
 210     XWindowAttributes attrib;
 211     XSetWindowAttributes attrib_set;
 212     XWMHints *wmhint;
 213     gboolean activate = FALSE;
 214
 215     grab_server(TRUE);
 216
 217     /* check if it has already been unmapped by the time we started mapping
 218        the grab does a sync so we don't have to here */
 219     if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
 220         XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e)) {
 221         XPutBackEvent(ob_display, &e);
 222
 223         grab_server(FALSE);
 224         return; /* don't manage it */
 225     }
 226
 227     /* make sure it isn't an override-redirect window */
 228     if (!XGetWindowAttributes(ob_display, window, &attrib) ||
 229         attrib.override_redirect) {
 230         grab_server(FALSE);
 231         return; /* don't manage it */
 232     }
 233
 234     /* is the window a docking app */
 235     if ((wmhint = XGetWMHints(ob_display, window))) {
 236         if ((wmhint->flags & StateHint) &&
 237             wmhint->initial_state == WithdrawnState) {
 238             dock_add(window, wmhint);
 239             grab_server(FALSE);
 240             XFree(wmhint);
 241             return;
 242         }
 243         XFree(wmhint);
 244     }
 245
 246     ob_debug("Managing window: %lx\n", window);
 247
 248     /* choose the events we want to receive on the CLIENT window */
 249     attrib_set.event_mask = CLIENT_EVENTMASK;
 250     attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
 251     XChangeWindowAttributes(ob_display, window,
 252                             CWEventMask|CWDontPropagate, &attrib_set);
 253
 254
 255     /* create the ObClient struct, and populate it from the hints on the
 256        window */
 257     self = g_new0(ObClient, 1);
 258     self->obwin.type = Window_Client;
 259     self->window = window;
 260
 261     /* non-zero defaults */
 262     self->title_count = 1;
 263     self->wmstate = NormalState;
 264     self->layer = -1;
 265     self->desktop = screen_num_desktops; /* always an invalid value */
 266
 267     client_get_all(self);
 268     client_restore_session_state(self);
 269
 270     sn_app_started(self->class);
 271
 272     client_change_state(self);
 273
 274     /* remove the client's border (and adjust re gravity) */
 275     client_toggle_border(self, FALSE);
 276
 277     /* specify that if we exit, the window should not be destroyed and should
 278        be reparented back to root automatically */
 279     XChangeSaveSet(ob_display, window, SetModeInsert);
 280
 281     /* create the decoration frame for the client window */
 282     self->frame = frame_new();
 283
 284     frame_grab_client(self->frame, self);
 285
 286     grab_server(FALSE);
 287
 288     client_apply_startup_state(self);
 289
 290     /* update the focus lists */
 291     focus_order_add_new(self);
 292
 293     stacking_add(CLIENT_AS_WINDOW(self));
 294     client_restore_session_stacking(self);
 295
 296     /* focus the new window? */
 297     if (ob_state() != OB_STATE_STARTING &&
 298         (config_focus_new || client_search_focus_parent(self)) &&
 299         /* note the check against Type_Normal/Dialog, not client_normal(self),
 300            which would also include other types. in this case we want more
 301            strict rules for focus */
 302         (self->type == OB_CLIENT_TYPE_NORMAL ||
 303          self->type == OB_CLIENT_TYPE_DIALOG))
 304     {
 305         activate = TRUE;
 306 #if 0
 307         if (self->desktop != screen_desktop) {
 308             /* activate the window */
 309             activate = TRUE;
 310         } else {
 311             gboolean group_foc = FALSE;
 312
 313             if (self->group) {
 314                 GSList *it;
 315
 316                 for (it = self->group->members; it; it = it->next)
 317                 {
 318                     if (client_focused(it->data))
 319                     {
 320                         group_foc = TRUE;
 321                         break;
 322                     }
 323                 }
 324             }
 325             if ((group_foc ||
 326                  (!self->transient_for && (!self->group ||
 327                                            !self->group->members->next))) ||
 328                 client_search_focus_tree_full(self) ||
 329                 !focus_client ||
 330                 !client_normal(focus_client))
 331             {
 332                 /* activate the window */
 333                 activate = TRUE;
 334             }
 335         }
 336 #endif
 337     }
 338
 339     if (ob_state() == OB_STATE_RUNNING) {
 340         int x = self->area.x, ox = x;
 341         int y = self->area.y, oy = y;
 342
 343         place_client(self, &x, &y);
 344
 345         /* make sure the window is visible */
 346         client_find_onscreen(self, &x, &y,
 347                              self->frame->area.width,
 348                              self->frame->area.height,
 349                              /* non-normal clients has less rules, and
 350                                 windows that are being restored from a session
 351                                 do also. we can assume you want it back where
 352                                 you saved it */
 353                              client_normal(self) && !self->session);
 354
 355         if (x != ox || y != oy)
 356             client_move(self, x, y);
 357     }
 358
 359     client_showhide(self);
 360
 361     /* use client_focus instead of client_activate cuz client_activate does
 362        stuff like switch desktops etc and I'm not interested in all that when
 363        a window maps since its not based on an action from the user like
 364        clicking a window to activate is. so keep the new window out of the way
 365        but do focus it. */
 366     if (activate) {
 367         /* if using focus_delay, stop the timer now so that focus doesn't go
 368            moving on us */
 369         event_halt_focus_delay();
 370
 371         client_focus(self);
 372         /* since focus can change the stacking orders, if we focus the window
 373            then the standard raise it gets is not enough, we need to queue one
 374            for after the focus change takes place */
 375         client_raise(self);
 376     }
 377
 378     /* client_activate does this but we aret using it so we have to do it
 379        here as well */
 380     if (screen_showing_desktop)
 381         screen_show_desktop(FALSE);
 382
 383     /* add to client list/map */
 384     client_list = g_list_append(client_list, self);
 385     g_hash_table_insert(window_map, &self->window, self);
 386
 387     /* this has to happen after we're in the client_list */
 388     screen_update_areas();
 389
 390     /* update the list hints */
 391     client_set_list();
 392
 393     keyboard_grab_for_client(self, TRUE);
 394     mouse_grab_for_client(self, TRUE);
 395
 396     ob_debug("Managed window 0x%lx (%s)\n", window, self->class);
 397 }
 398
 399 void client_unmanage_all()
 400 {
 401     while (client_list != NULL)
 402         client_unmanage(client_list->data);
 403 }
 404
 405 void client_unmanage(ObClient *self)
 406 {
 407     guint j;
 408     GSList *it;
 409
 410     ob_debug("Unmanaging window: %lx (%s)\n", self->window, self->class);
 411
 412     g_assert(self != NULL);
 413
 414     keyboard_grab_for_client(self, FALSE);
 415     mouse_grab_for_client(self, FALSE);
 416
 417     /* remove the window from our save set */
 418     XChangeSaveSet(ob_display, self->window, SetModeDelete);
 419
 420     /* we dont want events no more */
 421     XSelectInput(ob_display, self->window, NoEventMask);
 422
 423     frame_hide(self->frame);
 424
 425     client_list = g_list_remove(client_list, self);
 426     stacking_remove(self);
 427     g_hash_table_remove(window_map, &self->window);
 428
 429     /* update the focus lists */
 430     focus_order_remove(self);
 431
 432     /* once the client is out of the list, update the struts to remove it's
 433        influence */
 434     screen_update_areas();
 435
 436     for (it = client_destructors; it; it = g_slist_next(it)) {
 437         Destructor *d = it->data;
 438         d->func(self, d->data);
 439     }
 440
 441     if (focus_client == self) {
 442         XEvent e;
 443
 444         /* focus the last focused window on the desktop, and ignore enter
 445            events from the unmap so it doesnt mess with the focus */
 446         while (XCheckTypedEvent(ob_display, EnterNotify, &e));
 447         /* remove these flags so we don't end up getting focused in the
 448            fallback! */
 449         self->can_focus = FALSE;
 450         self->focus_notify = FALSE;
 451         self->modal = FALSE;
 452         client_unfocus(self);
 453     }
 454
 455     /* tell our parent(s) that we're gone */
 456     if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
 457         GSList *it;
 458
 459         for (it = self->group->members; it; it = it->next)
 460             if (it->data != self)
 461                 ((ObClient*)it->data)->transients =
 462                     g_slist_remove(((ObClient*)it->data)->transients, self);
 463     } else if (self->transient_for) {        /* transient of window */
 464         self->transient_for->transients =
 465             g_slist_remove(self->transient_for->transients, self);
 466     }
 467
 468     /* tell our transients that we're gone */
 469     for (it = self->transients; it != NULL; it = it->next) {
 470         if (((ObClient*)it->data)->transient_for != OB_TRAN_GROUP) {
 471             ((ObClient*)it->data)->transient_for = NULL;
 472             client_calc_layer(it->data);
 473         }
 474     }
 475
 476     /* remove from its group */
 477     if (self->group) {
 478         group_remove(self->group, self);
 479         self->group = NULL;
 480     }
 481
 482     /* give the client its border back */
 483     client_toggle_border(self, TRUE);
 484
 485     /* reparent the window out of the frame, and free the frame */
 486     frame_release_client(self->frame, self);
 487     self->frame = NULL;
 488
 489     if (ob_state() != OB_STATE_EXITING) {
 490         /* these values should not be persisted across a window
 491            unmapping/mapping */
 492         PROP_ERASE(self->window, net_wm_desktop);
 493         PROP_ERASE(self->window, net_wm_state);
 494         PROP_ERASE(self->window, wm_state);
 495     } else {
 496         /* if we're left in an iconic state, the client wont be mapped. this is
 497            bad, since we will no longer be managing the window on restart */
 498         if (self->iconic)
 499             XMapWindow(ob_display, self->window);
 500     }
 501
 502
 503     ob_debug("Unmanaged window 0x%lx\n", self->window);
 504
 505     /* free all data allocated in the client struct */
 506     g_slist_free(self->transients);
 507     for (j = 0; j < self->nicons; ++j)
 508         g_free(self->icons[j].data);
 509     if (self->nicons > 0)
 510         g_free(self->icons);
 511     g_free(self->title);
 512     g_free(self->icon_title);
 513     g_free(self->name);
 514     g_free(self->class);
 515     g_free(self->role);
 516     g_free(self->sm_client_id);
 517     g_free(self);
 518
 519     /* update the list hints */
 520     client_set_list();
 521 }
 522
 523 static void client_urgent_notify(ObClient *self)
 524 {
 525     if (self->urgent)
 526         frame_flash_start(self->frame);
 527     else
 528         frame_flash_stop(self->frame);
 529 }
 530
 531 static void client_restore_session_state(ObClient *self)
 532 {
 533     GList *it;
 534
 535     if (!(it = session_state_find(self)))
 536         return;
 537
 538     self->session = it->data;
 539
 540     RECT_SET_POINT(self->area, self->session->x, self->session->y);
 541     self->positioned = TRUE;
 542     if (self->session->w > 0)
 543         self->area.width = self->session->w;
 544     if (self->session->h > 0)
 545         self->area.height = self->session->h;
 546     XResizeWindow(ob_display, self->window,
 547                   self->area.width, self->area.height);
 548
 549     self->desktop = (self->session->desktop == DESKTOP_ALL ?
 550                      self->session->desktop :
 551                      MIN(screen_num_desktops - 1, self->session->desktop));
 552     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
 553
 554     self->shaded = self->session->shaded;
 555     self->iconic = self->session->iconic;
 556     self->skip_pager = self->session->skip_pager;
 557     self->skip_taskbar = self->session->skip_taskbar;
 558     self->fullscreen = self->session->fullscreen;
 559     self->above = self->session->above;
 560     self->below = self->session->below;
 561     self->max_horz = self->session->max_horz;
 562     self->max_vert = self->session->max_vert;
 563 }
 564
 565 static void client_restore_session_stacking(ObClient *self)
 566 {
 567     GList *it;
 568
 569     if (!self->session) return;
 570
 571     it = g_list_find(session_saved_state, self->session);
 572     for (it = g_list_previous(it); it; it = g_list_previous(it)) {
 573         GList *cit;
 574
 575         for (cit = client_list; cit; cit = g_list_next(cit))
 576             if (session_state_cmp(it->data, cit->data))
 577                 break;
 578         if (cit) {
 579             client_calc_layer(self);
 580             stacking_below(CLIENT_AS_WINDOW(self),
 581                            CLIENT_AS_WINDOW(cit->data));
 582             break;
 583         }
 584     }
 585 }
 586
 587 void client_move_onscreen(ObClient *self, gboolean rude)
 588 {
 589     int x = self->area.x;
 590     int y = self->area.y;
 591     if (client_find_onscreen(self, &x, &y,
 592                              self->frame->area.width,
 593                              self->frame->area.height, rude)) {
 594         client_move(self, x, y);
 595     }
 596 }
 597
 598 gboolean client_find_onscreen(ObClient *self, int *x, int *y, int w, int h,
 599                               gboolean rude)
 600 {
 601     Rect *a;
 602     int ox = *x, oy = *y;
 603
 604     frame_client_gravity(self->frame, x, y); /* get where the frame
 605                                                 would be */
 606
 607     /* XXX watch for xinerama dead areas */
 608
 609     a = screen_area(self->desktop);
 610     if (client_normal(self)) {
 611         if (!self->strut.right && *x >= a->x + a->width - 1)
 612             *x = a->x + a->width - self->frame->area.width;
 613         if (!self->strut.bottom && *y >= a->y + a->height - 1)
 614             *y = a->y + a->height - self->frame->area.height;
 615         if (!self->strut.left && *x + self->frame->area.width - 1 < a->x)
 616             *x = a->x;
 617         if (!self->strut.top && *y + self->frame->area.height - 1 < a->y)
 618             *y = a->y;
 619     }
 620
 621     if (rude) {
 622         /* this is my MOZILLA BITCHSLAP. oh ya it fucking feels good.
 623            Java can suck it too. */
 624
 625         /* dont let windows map/move into the strut unless they
 626            are bigger than the available area */
 627         if (w <= a->width) {
 628             if (!self->strut.left && *x < a->x) *x = a->x;
 629             if (!self->strut.right && *x + w > a->x + a->width)
 630                 *x = a->x + a->width - w;
 631         }
 632         if (h <= a->height) {
 633             if (!self->strut.top && *y < a->y) *y = a->y;
 634             if (!self->strut.bottom && *y + h > a->y + a->height)
 635                 *y = a->y + a->height - h;
 636         }
 637     }
 638
 639     frame_frame_gravity(self->frame, x, y); /* get where the client
 640                                                should be */
 641
 642     return ox != *x || oy != *y;
 643 }
 644
 645 static void client_toggle_border(ObClient *self, gboolean show)
 646 {
 647     /* adjust our idea of where the client is, based on its border. When the
 648        border is removed, the client should now be considered to be in a
 649        different position.
 650        when re-adding the border to the client, the same operation needs to be
 651        reversed. */
 652     int oldx = self->area.x, oldy = self->area.y;
 653     int x = oldx, y = oldy;
 654     switch(self->gravity) {
 655     default:
 656     case NorthWestGravity:
 657     case WestGravity:
 658     case SouthWestGravity:
 659         break;
 660     case NorthEastGravity:
 661     case EastGravity:
 662     case SouthEastGravity:
 663         if (show) x -= self->border_width * 2;
 664         else      x += self->border_width * 2;
 665         break;
 666     case NorthGravity:
 667     case SouthGravity:
 668     case CenterGravity:
 669     case ForgetGravity:
 670     case StaticGravity:
 671         if (show) x -= self->border_width;
 672         else      x += self->border_width;
 673         break;
 674     }
 675     switch(self->gravity) {
 676     default:
 677     case NorthWestGravity:
 678     case NorthGravity:
 679     case NorthEastGravity:
 680         break;
 681     case SouthWestGravity:
 682     case SouthGravity:
 683     case SouthEastGravity:
 684         if (show) y -= self->border_width * 2;
 685         else      y += self->border_width * 2;
 686         break;
 687     case WestGravity:
 688     case EastGravity:
 689     case CenterGravity:
 690     case ForgetGravity:
 691     case StaticGravity:
 692         if (show) y -= self->border_width;
 693         else      y += self->border_width;
 694         break;
 695     }
 696     self->area.x = x;
 697     self->area.y = y;
 698
 699     if (show) {
 700         XSetWindowBorderWidth(ob_display, self->window, self->border_width);
 701
 702         /* move the client so it is back it the right spot _with_ its
 703            border! */
 704         if (x != oldx || y != oldy)
 705             XMoveWindow(ob_display, self->window, x, y);
 706     } else
 707         XSetWindowBorderWidth(ob_display, self->window, 0);
 708 }
 709
 710
 711 static void client_get_all(ObClient *self)
 712 {
 713     client_get_area(self);
 714     client_update_transient_for(self);
 715     client_update_wmhints(self);
 716     client_get_startup_id(self);
 717     client_get_desktop(self);
 718     client_get_state(self);
 719     client_get_shaped(self);
 720
 721     client_get_mwm_hints(self);
 722     client_get_type(self);/* this can change the mwmhints for special cases */
 723
 724     {
 725         /* a couple type-based defaults for new windows */
 726
 727         /* this makes sure that these windows appear on all desktops */
 728         if (self->type == OB_CLIENT_TYPE_DESKTOP)
 729             self->desktop = DESKTOP_ALL;
 730
 731         /* dock windows default to ABOVE */
 732         if (self->type == OB_CLIENT_TYPE_DOCK && !self->below)
 733             self->above = TRUE;
 734     }
 735
 736     client_update_protocols(self);
 737
 738     client_get_gravity(self); /* get the attribute gravity */
 739     client_update_normal_hints(self); /* this may override the attribute
 740                                          gravity */
 741
 742     /* got the type, the mwmhints, the protocols, and the normal hints
 743        (min/max sizes), so we're ready to set up the decorations/functions */
 744     client_setup_decor_and_functions(self);
 745
 746     client_update_title(self);
 747     client_update_class(self);
 748     client_update_sm_client_id(self);
 749     client_update_strut(self);
 750     client_update_icons(self);
 751 }
 752
 753 static void client_get_startup_id(ObClient *self)
 754 {
 755     if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id)))
 756         if (self->group)
 757             PROP_GETS(self->group->leader,
 758                       net_startup_id, utf8, &self->startup_id);
 759 }
 760
 761 static void client_get_area(ObClient *self)
 762 {
 763     XWindowAttributes wattrib;
 764     Status ret;
 765
 766     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
 767     g_assert(ret != BadWindow);
 768
 769     RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
 770     self->border_width = wattrib.border_width;
 771 }
 772
 773 static void client_get_desktop(ObClient *self)
 774 {
 775     guint32 d = screen_num_desktops; /* an always-invalid value */
 776
 777     if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
 778         if (d >= screen_num_desktops && d != DESKTOP_ALL)
 779             self->desktop = screen_num_desktops - 1;
 780         else
 781             self->desktop = d;
 782     } else {
 783         gboolean trdesk = FALSE;
 784
 785         if (self->transient_for) {
 786             if (self->transient_for != OB_TRAN_GROUP) {
 787                 self->desktop = self->transient_for->desktop;
 788                 trdesk = TRUE;
 789             } else {
 790                 GSList *it;
 791
 792                 for (it = self->group->members; it; it = it->next)
 793                     if (it->data != self &&
 794                         !((ObClient*)it->data)->transient_for) {
 795                         self->desktop = ((ObClient*)it->data)->desktop;
 796                         trdesk = TRUE;
 797                         break;
 798                     }
 799             }
 800         }
 801         if (!trdesk) {
 802             /* try get from the startup-notification protocol */
 803             if (sn_get_desktop(self->startup_id, &self->desktop)) {
 804                 if (self->desktop >= screen_num_desktops &&
 805                     self->desktop != DESKTOP_ALL)
 806                     self->desktop = screen_num_desktops - 1;
 807             } else
 808                 /* defaults to the current desktop */
 809                 self->desktop = screen_desktop;
 810         }
 811     }
 812     if (self->desktop != d) {
 813         /* set the desktop hint, to make sure that it always exists */
 814         PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
 815     }
 816 }
 817
 818 static void client_get_state(ObClient *self)
 819 {
 820     guint32 *state;
 821     guint num;
 822
 823     if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) {
 824         gulong i;
 825         for (i = 0; i < num; ++i) {
 826             if (state[i] == prop_atoms.net_wm_state_modal)
 827                 self->modal = TRUE;
 828             else if (state[i] == prop_atoms.net_wm_state_shaded)
 829                 self->shaded = TRUE;
 830             else if (state[i] == prop_atoms.net_wm_state_hidden)
 831                 self->iconic = TRUE;
 832             else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
 833                 self->skip_taskbar = TRUE;
 834             else if (state[i] == prop_atoms.net_wm_state_skip_pager)
 835                 self->skip_pager = TRUE;
 836             else if (state[i] == prop_atoms.net_wm_state_fullscreen)
 837                 self->fullscreen = TRUE;
 838             else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
 839                 self->max_vert = TRUE;
 840             else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
 841                 self->max_horz = TRUE;
 842             else if (state[i] == prop_atoms.net_wm_state_above)
 843                 self->above = TRUE;
 844             else if (state[i] == prop_atoms.net_wm_state_below)
 845                 self->below = TRUE;
 846             else if (state[i] == prop_atoms.ob_wm_state_undecorated)
 847                 self->undecorated = TRUE;
 848         }
 849
 850         g_free(state);
 851     }
 852
 853     if (!(self->above || self->below)) {
 854         if (self->group) {
 855             /* apply stuff from the group */
 856             GSList *it;
 857             gint layer = -2;
 858
 859             for (it = self->group->members; it; it = g_slist_next(it)) {
 860                 ObClient *c = it->data;
 861                 if (c != self && !client_search_transient(self, c))
 862                 {
 863                     layer = MAX(layer,
 864                                 (c->above ? 1 : (c->below ? -1 : 0)));
 865                 }
 866             }
 867             switch (layer) {
 868             case -1:
 869                 self->below = TRUE;
 870                 break;
 871             case -2:
 872             case 0:
 873                 break;
 874             case 1:
 875                 self->above = TRUE;
 876                 break;
 877             default:
 878                 g_assert_not_reached();
 879                 break;
 880             }
 881         }
 882     }
 883 }
 884
 885 static void client_get_shaped(ObClient *self)
 886 {
 887     self->shaped = FALSE;
 888 #ifdef   SHAPE
 889     if (extensions_shape) {
 890         int foo;
 891         guint ufoo;
 892         int s;
 893
 894         XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
 895
 896         XShapeQueryExtents(ob_display, self->window, &s, &foo,
 897                            &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
 898                            &ufoo);
 899         self->shaped = (s != 0);
 900     }
 901 #endif
 902 }
 903
 904 void client_update_transient_for(ObClient *self)
 905 {
 906     Window t = None;
 907     ObClient *target = NULL;
 908
 909     if (XGetTransientForHint(ob_display, self->window, &t)) {
 910         self->transient = TRUE;
 911         if (t != self->window) { /* cant be transient to itself! */
 912             target = g_hash_table_lookup(window_map, &t);
 913             /* if this happens then we need to check for it*/
 914             g_assert(target != self);
 915             if (target && !WINDOW_IS_CLIENT(target)) {
 916                 /* this can happen when a dialog is a child of
 917                    a dockapp, for example */
 918                 target = NULL;
 919             }
 920
 921             if (!target && self->group) {
 922                 /* not transient to a client, see if it is transient for a
 923                    group */
 924                 if (t == self->group->leader ||
 925                     t == None ||
 926                     t == RootWindow(ob_display, ob_screen))
 927                 {
 928                     /* window is a transient for its group! */
 929                     target = OB_TRAN_GROUP;
 930                 }
 931             }
 932         }
 933     } else
 934         self->transient = FALSE;
 935
 936     /* if anything has changed... */
 937     if (target != self->transient_for) {
 938         if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
 939             GSList *it;
 940
 941             /* remove from old parents */
 942             for (it = self->group->members; it; it = g_slist_next(it)) {
 943                 ObClient *c = it->data;
 944                 if (c != self && !c->transient_for)
 945                     c->transients = g_slist_remove(c->transients, self);
 946             }
 947         } else if (self->transient_for != NULL) { /* transient of window */
 948             /* remove from old parent */
 949             self->transient_for->transients =
 950                 g_slist_remove(self->transient_for->transients, self);
 951         }
 952         self->transient_for = target;
 953         if (self->transient_for == OB_TRAN_GROUP) { /* transient of group */
 954             GSList *it;
 955
 956             /* add to new parents */
 957             for (it = self->group->members; it; it = g_slist_next(it)) {
 958                 ObClient *c = it->data;
 959                 if (c != self && !c->transient_for)
 960                     c->transients = g_slist_append(c->transients, self);
 961             }
 962
 963             /* remove all transients which are in the group, that causes
 964                circlular pointer hell of doom */
 965             for (it = self->group->members; it; it = g_slist_next(it)) {
 966                 GSList *sit, *next;
 967                 for (sit = self->transients; sit; sit = next) {
 968                     next = g_slist_next(sit);
 969                     if (sit->data == it->data)
 970                         self->transients =
 971                             g_slist_delete_link(self->transients, sit);
 972                 }
 973             }
 974         } else if (self->transient_for != NULL) { /* transient of window */
 975             /* add to new parent */
 976             self->transient_for->transients =
 977                 g_slist_append(self->transient_for->transients, self);
 978         }
 979     }
 980 }
 981
 982 static void client_get_mwm_hints(ObClient *self)
 983 {
 984     guint num;
 985     guint32 *hints;
 986
 987     self->mwmhints.flags = 0; /* default to none */
 988
 989     if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
 990                     &hints, &num)) {
 991         if (num >= OB_MWM_ELEMENTS) {
 992             self->mwmhints.flags = hints[0];
 993             self->mwmhints.functions = hints[1];
 994             self->mwmhints.decorations = hints[2];
 995         }
 996         g_free(hints);
 997     }
 998 }
 999
1000 void client_get_type(ObClient *self)
1001 {
1002     guint num, i;
1003     guint32 *val;
1004
1005     self->type = -1;
1006
1007     if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
1008         /* use the first value that we know about in the array */
1009         for (i = 0; i < num; ++i) {
1010             if (val[i] == prop_atoms.net_wm_window_type_desktop)
1011                 self->type = OB_CLIENT_TYPE_DESKTOP;
1012             else if (val[i] == prop_atoms.net_wm_window_type_dock)
1013                 self->type = OB_CLIENT_TYPE_DOCK;
1014             else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
1015                 self->type = OB_CLIENT_TYPE_TOOLBAR;
1016             else if (val[i] == prop_atoms.net_wm_window_type_menu)
1017                 self->type = OB_CLIENT_TYPE_MENU;
1018             else if (val[i] == prop_atoms.net_wm_window_type_utility)
1019                 self->type = OB_CLIENT_TYPE_UTILITY;
1020             else if (val[i] == prop_atoms.net_wm_window_type_splash)
1021                 self->type = OB_CLIENT_TYPE_SPLASH;
1022             else if (val[i] == prop_atoms.net_wm_window_type_dialog)
1023                 self->type = OB_CLIENT_TYPE_DIALOG;
1024             else if (val[i] == prop_atoms.net_wm_window_type_normal)
1025                 self->type = OB_CLIENT_TYPE_NORMAL;
1026             else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
1027                 /* prevent this window from getting any decor or
1028                    functionality */
1029                 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
1030                                          OB_MWM_FLAG_DECORATIONS);
1031                 self->mwmhints.decorations = 0;
1032                 self->mwmhints.functions = 0;
1033             }
1034             if (self->type != (ObClientType) -1)
1035                 break; /* grab the first legit type */
1036         }
1037         g_free(val);
1038     }
1039
1040     if (self->type == (ObClientType) -1) {
1041         /*the window type hint was not set, which means we either classify
1042           ourself as a normal window or a dialog, depending on if we are a
1043           transient. */
1044         if (self->transient)
1045             self->type = OB_CLIENT_TYPE_DIALOG;
1046         else
1047             self->type = OB_CLIENT_TYPE_NORMAL;
1048     }
1049 }
1050
1051 void client_update_protocols(ObClient *self)
1052 {
1053     guint32 *proto;
1054     guint num_return, i;
1055
1056     self->focus_notify = FALSE;
1057     self->delete_window = FALSE;
1058
1059     if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1060         for (i = 0; i < num_return; ++i) {
1061             if (proto[i] == prop_atoms.wm_delete_window) {
1062                 /* this means we can request the window to close */
1063                 self->delete_window = TRUE;
1064             } else if (proto[i] == prop_atoms.wm_take_focus)
1065                 /* if this protocol is requested, then the window will be
1066                    notified whenever we want it to receive focus */
1067                 self->focus_notify = TRUE;
1068         }
1069         g_free(proto);
1070     }
1071 }
1072
1073 static void client_get_gravity(ObClient *self)
1074 {
1075     XWindowAttributes wattrib;
1076     Status ret;
1077
1078     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
1079     g_assert(ret != BadWindow);
1080     self->gravity = wattrib.win_gravity;
1081 }
1082
1083 void client_update_normal_hints(ObClient *self)
1084 {
1085     XSizeHints size;
1086     long ret;
1087     int oldgravity = self->gravity;
1088
1089     /* defaults */
1090     self->min_ratio = 0.0f;
1091     self->max_ratio = 0.0f;
1092     SIZE_SET(self->size_inc, 1, 1);
1093     SIZE_SET(self->base_size, 0, 0);
1094     SIZE_SET(self->min_size, 0, 0);
1095     SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1096
1097     /* get the hints from the window */
1098     if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1099         /* normal windows can't request placement! har har
1100         if (!client_normal(self))
1101         */
1102         self->positioned = !!(size.flags & (PPosition|USPosition));
1103
1104         if (size.flags & PWinGravity) {
1105             self->gravity = size.win_gravity;
1106
1107             /* if the client has a frame, i.e. has already been mapped and
1108                is changing its gravity */
1109             if (self->frame && self->gravity != oldgravity) {
1110                 /* move our idea of the client's position based on its new
1111                    gravity */
1112                 self->area.x = self->frame->area.x;
1113                 self->area.y = self->frame->area.y;
1114                 frame_frame_gravity(self->frame, &self->area.x, &self->area.y);
1115             }
1116         }
1117
1118         if (size.flags & PAspect) {
1119             if (size.min_aspect.y)
1120                 self->min_ratio = (float)size.min_aspect.x / size.min_aspect.y;
1121             if (size.max_aspect.y)
1122                 self->max_ratio = (float)size.max_aspect.x / size.max_aspect.y;
1123         }
1124
1125         if (size.flags & PMinSize)
1126             SIZE_SET(self->min_size, size.min_width, size.min_height);
1127
1128         if (size.flags & PMaxSize)
1129             SIZE_SET(self->max_size, size.max_width, size.max_height);
1130
1131         if (size.flags & PBaseSize)
1132             SIZE_SET(self->base_size, size.base_width, size.base_height);
1133
1134         if (size.flags & PResizeInc)
1135             SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1136     }
1137 }
1138
1139 void client_setup_decor_and_functions(ObClient *self)
1140 {
1141     /* start with everything (cept fullscreen) */
1142     self->decorations =
1143         (OB_FRAME_DECOR_TITLEBAR |
1144          (ob_rr_theme->show_handle ? OB_FRAME_DECOR_HANDLE : 0) |
1145          OB_FRAME_DECOR_GRIPS |
1146          OB_FRAME_DECOR_BORDER |
1147          OB_FRAME_DECOR_ICON |
1148          OB_FRAME_DECOR_ALLDESKTOPS |
1149          OB_FRAME_DECOR_ICONIFY |
1150          OB_FRAME_DECOR_MAXIMIZE |
1151          OB_FRAME_DECOR_SHADE |
1152          OB_FRAME_DECOR_CLOSE);
1153     self->functions =
1154         (OB_CLIENT_FUNC_RESIZE |
1155          OB_CLIENT_FUNC_MOVE |
1156          OB_CLIENT_FUNC_ICONIFY |
1157          OB_CLIENT_FUNC_MAXIMIZE |
1158          OB_CLIENT_FUNC_SHADE |
1159          OB_CLIENT_FUNC_CLOSE);
1160
1161     if (!(self->min_size.width < self->max_size.width ||
1162           self->min_size.height < self->max_size.height))
1163         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1164
1165     switch (self->type) {
1166     case OB_CLIENT_TYPE_NORMAL:
1167         /* normal windows retain all of the possible decorations and
1168            functionality, and are the only windows that you can fullscreen */
1169         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1170         break;
1171
1172     case OB_CLIENT_TYPE_DIALOG:
1173     case OB_CLIENT_TYPE_UTILITY:
1174         /* these windows cannot be maximized */
1175         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1176         break;
1177
1178     case OB_CLIENT_TYPE_MENU:
1179     case OB_CLIENT_TYPE_TOOLBAR:
1180         /* these windows get less functionality */
1181         self->functions &= ~(OB_CLIENT_FUNC_ICONIFY | OB_CLIENT_FUNC_RESIZE);
1182         break;
1183
1184     case OB_CLIENT_TYPE_DESKTOP:
1185     case OB_CLIENT_TYPE_DOCK:
1186     case OB_CLIENT_TYPE_SPLASH:
1187         /* none of these windows are manipulated by the window manager */
1188         self->decorations = 0;
1189         self->functions = 0;
1190         break;
1191     }
1192
1193     /* Mwm Hints are applied subtractively to what has already been chosen for
1194        decor and functionality */
1195     if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1196         if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1197             if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1198                    (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1199                 /* if the mwm hints request no handle or title, then all
1200                    decorations are disabled */
1201                 self->decorations = 0;
1202         }
1203     }
1204
1205     if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1206         if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1207             if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1208                 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1209             if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1210                 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1211             /* dont let mwm hints kill any buttons
1212                if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1213                self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1214                if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1215                self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1216             */
1217             /* dont let mwm hints kill the close button
1218                if (! (self->mwmhints.functions & MwmFunc_Close))
1219                self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1220             }
1221     }
1222
1223     if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1224         self->decorations &= ~OB_FRAME_DECOR_SHADE;
1225     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1226         self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1227     if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1228         self->decorations &= ~OB_FRAME_DECOR_GRIPS;
1229
1230     /* can't maximize without moving/resizing */
1231     if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1232           (self->functions & OB_CLIENT_FUNC_MOVE) &&
1233           (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1234         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1235         self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1236     }
1237
1238     /* kill the handle on fully maxed windows */
1239     if (self->max_vert && self->max_horz)
1240         self->decorations &= ~OB_FRAME_DECOR_HANDLE;
1241
1242     /* finally, the user can have requested no decorations, which overrides
1243        everything (but doesnt give it a border if it doesnt have one) */
1244     if (self->undecorated)
1245         self->decorations &= OB_FRAME_DECOR_BORDER;
1246
1247     /* if we don't have a titlebar, then we cannot shade! */
1248     if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1249         self->functions &= ~OB_CLIENT_FUNC_SHADE;
1250
1251     /* now we need to check against rules for the client's current state */
1252     if (self->fullscreen) {
1253         self->functions &= (OB_CLIENT_FUNC_CLOSE |
1254                             OB_CLIENT_FUNC_FULLSCREEN |
1255                             OB_CLIENT_FUNC_ICONIFY);
1256         self->decorations = 0;
1257     }
1258
1259     client_change_allowed_actions(self);
1260
1261     if (self->frame) {
1262         /* adjust the client's decorations, etc. */
1263         client_reconfigure(self);
1264     }
1265 }
1266
1267 static void client_change_allowed_actions(ObClient *self)
1268 {
1269     guint32 actions[9];
1270     int num = 0;
1271
1272     /* desktop windows are kept on all desktops */
1273     if (self->type != OB_CLIENT_TYPE_DESKTOP)
1274         actions[num++] = prop_atoms.net_wm_action_change_desktop;
1275
1276     if (self->functions & OB_CLIENT_FUNC_SHADE)
1277         actions[num++] = prop_atoms.net_wm_action_shade;
1278     if (self->functions & OB_CLIENT_FUNC_CLOSE)
1279         actions[num++] = prop_atoms.net_wm_action_close;
1280     if (self->functions & OB_CLIENT_FUNC_MOVE)
1281         actions[num++] = prop_atoms.net_wm_action_move;
1282     if (self->functions & OB_CLIENT_FUNC_ICONIFY)
1283         actions[num++] = prop_atoms.net_wm_action_minimize;
1284     if (self->functions & OB_CLIENT_FUNC_RESIZE)
1285         actions[num++] = prop_atoms.net_wm_action_resize;
1286     if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
1287         actions[num++] = prop_atoms.net_wm_action_fullscreen;
1288     if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
1289         actions[num++] = prop_atoms.net_wm_action_maximize_horz;
1290         actions[num++] = prop_atoms.net_wm_action_maximize_vert;
1291     }
1292
1293     PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
1294
1295     /* make sure the window isn't breaking any rules now */
1296
1297     if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
1298         if (self->frame) client_shade(self, FALSE);
1299         else self->shaded = FALSE;
1300     }
1301     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
1302         if (self->frame) client_iconify(self, FALSE, TRUE);
1303         else self->iconic = FALSE;
1304     }
1305     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
1306         if (self->frame) client_fullscreen(self, FALSE, TRUE);
1307         else self->fullscreen = FALSE;
1308     }
1309     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
1310                                                          self->max_vert)) {
1311         if (self->frame) client_maximize(self, FALSE, 0, TRUE);
1312         else self->max_vert = self->max_horz = FALSE;
1313     }
1314 }
1315
1316 void client_reconfigure(ObClient *self)
1317 {
1318     /* by making this pass FALSE for user, we avoid the emacs event storm where
1319        every configurenotify causes an update in its normal hints, i think this
1320        is generally what we want anyways... */
1321     client_configure(self, OB_CORNER_TOPLEFT, self->area.x, self->area.y,
1322                      self->area.width, self->area.height, FALSE, TRUE);
1323 }
1324
1325 void client_update_wmhints(ObClient *self)
1326 {
1327     XWMHints *hints;
1328     gboolean ur = FALSE;
1329     GSList *it;
1330
1331     /* assume a window takes input if it doesnt specify */
1332     self->can_focus = TRUE;
1333
1334     if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
1335         if (hints->flags & InputHint)
1336             self->can_focus = hints->input;
1337
1338         /* only do this when first managing the window *AND* when we aren't
1339            starting up! */
1340         if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
1341             if (hints->flags & StateHint)
1342                 self->iconic = hints->initial_state == IconicState;
1343
1344         if (hints->flags & XUrgencyHint)
1345             ur = TRUE;
1346
1347         if (!(hints->flags & WindowGroupHint))
1348             hints->window_group = None;
1349
1350         /* did the group state change? */
1351         if (hints->window_group !=
1352             (self->group ? self->group->leader : None)) {
1353             /* remove from the old group if there was one */
1354             if (self->group != NULL) {
1355                 /* remove transients of the group */
1356                 for (it = self->group->members; it; it = it->next)
1357                     self->transients = g_slist_remove(self->transients,
1358                                                       it->data);
1359
1360                 /* remove myself from parents in the group */
1361                 if (self->transient_for == OB_TRAN_GROUP) {
1362                     for (it = self->group->members; it; it = it->next) {
1363                         ObClient *c = it->data;
1364
1365                         if (c != self && !c->transient_for)
1366                             c->transients = g_slist_remove(c->transients,
1367                                                            self);
1368                     }
1369                 }
1370
1371                 group_remove(self->group, self);
1372                 self->group = NULL;
1373             }
1374             if (hints->window_group != None) {
1375                 self->group = group_add(hints->window_group, self);
1376
1377                 /* i can only have transients from the group if i am not
1378                    transient myself */
1379                 if (!self->transient_for) {
1380                     /* add other transients of the group that are already
1381                        set up */
1382                     for (it = self->group->members; it; it = it->next) {
1383                         ObClient *c = it->data;
1384                         if (c != self && c->transient_for == OB_TRAN_GROUP)
1385                             self->transients =
1386                                 g_slist_append(self->transients, c);
1387                     }
1388                 }
1389             }
1390
1391             /* because the self->transient flag wont change from this call,
1392                we don't need to update the window's type and such, only its
1393                transient_for, and the transients lists of other windows in
1394                the group may be affected */
1395             client_update_transient_for(self);
1396         }
1397
1398         /* the WM_HINTS can contain an icon */
1399         client_update_icons(self);
1400
1401         XFree(hints);
1402     }
1403
1404     if (ur != self->urgent) {
1405         self->urgent = ur;
1406         /* fire the urgent callback if we're mapped, otherwise, wait until
1407            after we're mapped */
1408         if (self->frame)
1409             client_urgent_notify(self);
1410     }
1411 }
1412
1413 void client_update_title(ObClient *self)
1414 {
1415     GList *it;
1416     guint32 nums;
1417     guint i;
1418     gchar *data = NULL;
1419     gboolean read_title;
1420     gchar *old_title;
1421
1422     old_title = self->title;
1423
1424     /* try netwm */
1425     if (!PROP_GETS(self->window, net_wm_name, utf8, &data))
1426         /* try old x stuff */
1427         if (!PROP_GETS(self->window, wm_name, locale, &data))
1428             data = g_strdup("Unnamed Window");
1429
1430     /* did the title change? then reset the title_count */
1431     if (old_title && 0 != strncmp(old_title, data, strlen(data)))
1432         self->title_count = 1;
1433
1434     /* look for duplicates and append a number */
1435     nums = 0;
1436     for (it = client_list; it; it = it->next)
1437         if (it->data != self) {
1438             ObClient *c = it->data;
1439             if (0 == strncmp(c->title, data, strlen(data)))
1440                 nums |= 1 << c->title_count;
1441         }
1442     /* find first free number */
1443     for (i = 1; i <= 32; ++i)
1444         if (!(nums & (1 << i))) {
1445             if (self->title_count == 1 || i == 1)
1446                 self->title_count = i;
1447             break;
1448         }
1449     /* dont display the number for the first window */
1450     if (self->title_count > 1) {
1451         char *ndata;
1452         ndata = g_strdup_printf("%s - [%u]", data, self->title_count);
1453         g_free(data);
1454         data = ndata;
1455     }
1456
1457     PROP_SETS(self->window, net_wm_visible_name, data);
1458
1459     self->title = data;
1460
1461     if (self->frame)
1462         frame_adjust_title(self->frame);
1463
1464     g_free(old_title);
1465
1466     /* update the icon title */
1467     data = NULL;
1468     g_free(self->icon_title);
1469
1470     read_title = TRUE;
1471     /* try netwm */
1472     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
1473         /* try old x stuff */
1474         if (!PROP_GETS(self->window, wm_icon_name, locale, &data)) {
1475             data = g_strdup(self->title);
1476             read_title = FALSE;
1477         }
1478
1479     /* append the title count, dont display the number for the first window */
1480     if (read_title && self->title_count > 1) {
1481         char *vdata, *ndata;
1482         ndata = g_strdup_printf(" - [%u]", self->title_count);
1483         vdata = g_strconcat(data, ndata, NULL);
1484         g_free(ndata);
1485         g_free(data);
1486         data = vdata;
1487     }
1488
1489     PROP_SETS(self->window, net_wm_visible_icon_name, data);
1490
1491     self->icon_title = data;
1492 }
1493
1494 void client_update_class(ObClient *self)
1495 {
1496     char **data;
1497     char *s;
1498
1499     if (self->name) g_free(self->name);
1500     if (self->class) g_free(self->class);
1501     if (self->role) g_free(self->role);
1502
1503     self->name = self->class = self->role = NULL;
1504
1505     if (PROP_GETSS(self->window, wm_class, locale, &data)) {
1506         if (data[0]) {
1507             self->name = g_strdup(data[0]);
1508             if (data[1])
1509                 self->class = g_strdup(data[1]);
1510         }
1511         g_strfreev(data);
1512     }
1513
1514     if (PROP_GETS(self->window, wm_window_role, locale, &s))
1515         self->role = s;
1516
1517     if (self->name == NULL) self->name = g_strdup("");
1518     if (self->class == NULL) self->class = g_strdup("");
1519     if (self->role == NULL) self->role = g_strdup("");
1520 }
1521
1522 void client_update_strut(ObClient *self)
1523 {
1524     guint num;
1525     guint32 *data;
1526     gboolean got = FALSE;
1527     StrutPartial strut;
1528
1529     if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
1530                     &data, &num)) {
1531         if (num == 12) {
1532             got = TRUE;
1533             STRUT_PARTIAL_SET(strut,
1534                               data[0], data[2], data[1], data[3],
1535                               data[4], data[5], data[8], data[9],
1536                               data[6], data[7], data[10], data[11]);
1537         }
1538         g_free(data);
1539     }
1540
1541     if (!got &&
1542         PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
1543         if (num == 4) {
1544             const Rect *a;
1545
1546             got = TRUE;
1547
1548             /* use the screen's width/height */
1549             a = screen_physical_area();
1550
1551             STRUT_PARTIAL_SET(strut,
1552                               data[0], data[2], data[1], data[3],
1553                               a->y, a->y + a->height - 1,
1554                               a->x, a->x + a->width - 1,
1555                               a->y, a->y + a->height - 1,
1556                               a->x, a->x + a->width - 1);
1557         }
1558         g_free(data);
1559     }
1560
1561     if (!got)
1562         STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
1563                           0, 0, 0, 0, 0, 0, 0, 0);
1564
1565     if (!STRUT_EQUAL(strut, self->strut)) {
1566         self->strut = strut;
1567
1568         /* updating here is pointless while we're being mapped cuz we're not in
1569            the client list yet */
1570         if (self->frame)
1571             screen_update_areas();
1572     }
1573 }
1574
1575 void client_update_icons(ObClient *self)
1576 {
1577     guint num;
1578     guint32 *data;
1579     guint w, h, i, j;
1580
1581     for (i = 0; i < self->nicons; ++i)
1582         g_free(self->icons[i].data);
1583     if (self->nicons > 0)
1584         g_free(self->icons);
1585     self->nicons = 0;
1586
1587     if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
1588         /* figure out how many valid icons are in here */
1589         i = 0;
1590         while (num - i > 2) {
1591             w = data[i++];
1592             h = data[i++];
1593             i += w * h;
1594             if (i > num || w*h == 0) break;
1595             ++self->nicons;
1596         }
1597
1598         self->icons = g_new(ObClientIcon, self->nicons);
1599
1600         /* store the icons */
1601         i = 0;
1602         for (j = 0; j < self->nicons; ++j) {
1603             guint x, y, t;
1604
1605             w = self->icons[j].width = data[i++];
1606             h = self->icons[j].height = data[i++];
1607
1608             if (w*h == 0) continue;
1609
1610             self->icons[j].data = g_new(RrPixel32, w * h);
1611             for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
1612                 if (x >= w) {
1613                     x = 0;
1614                     ++y;
1615                 }
1616                 self->icons[j].data[t] =
1617                     (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
1618                     (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
1619                     (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
1620                     (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
1621             }
1622             g_assert(i <= num);
1623         }
1624
1625         g_free(data);
1626     } else if (PROP_GETA32(self->window, kwm_win_icon,
1627                            kwm_win_icon, &data, &num)) {
1628         if (num == 2) {
1629             self->nicons++;
1630             self->icons = g_new(ObClientIcon, self->nicons);
1631             xerror_set_ignore(TRUE);
1632             if (!RrPixmapToRGBA(ob_rr_inst,
1633                                 data[0], data[1],
1634                                 &self->icons[self->nicons-1].width,
1635                                 &self->icons[self->nicons-1].height,
1636                                 &self->icons[self->nicons-1].data)) {
1637                 g_free(&self->icons[self->nicons-1]);
1638                 self->nicons--;
1639             }
1640             xerror_set_ignore(FALSE);
1641         }
1642         g_free(data);
1643     } else {
1644         XWMHints *hints;
1645
1646         if ((hints = XGetWMHints(ob_display, self->window))) {
1647             if (hints->flags & IconPixmapHint) {
1648                 self->nicons++;
1649                 self->icons = g_new(ObClientIcon, self->nicons);
1650                 xerror_set_ignore(TRUE);
1651                 if (!RrPixmapToRGBA(ob_rr_inst,
1652                                     hints->icon_pixmap,
1653                                     (hints->flags & IconMaskHint ?
1654                                      hints->icon_mask : None),
1655                                     &self->icons[self->nicons-1].width,
1656                                     &self->icons[self->nicons-1].height,
1657                                     &self->icons[self->nicons-1].data)){
1658                     g_free(&self->icons[self->nicons-1]);
1659                     self->nicons--;
1660                 }
1661                 xerror_set_ignore(FALSE);
1662             }
1663             XFree(hints);
1664         }
1665     }
1666
1667     if (self->frame)
1668         frame_adjust_icon(self->frame);
1669 }
1670
1671 static void client_change_state(ObClient *self)
1672 {
1673     guint32 state[2];
1674     guint32 netstate[11];
1675     guint num;
1676
1677     state[0] = self->wmstate;
1678     state[1] = None;
1679     PROP_SETA32(self->window, wm_state, wm_state, state, 2);
1680
1681     num = 0;
1682     if (self->modal)
1683         netstate[num++] = prop_atoms.net_wm_state_modal;
1684     if (self->shaded)
1685         netstate[num++] = prop_atoms.net_wm_state_shaded;
1686     if (self->iconic)
1687         netstate[num++] = prop_atoms.net_wm_state_hidden;
1688     if (self->skip_taskbar)
1689         netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
1690     if (self->skip_pager)
1691         netstate[num++] = prop_atoms.net_wm_state_skip_pager;
1692     if (self->fullscreen)
1693         netstate[num++] = prop_atoms.net_wm_state_fullscreen;
1694     if (self->max_vert)
1695         netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
1696     if (self->max_horz)
1697         netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
1698     if (self->above)
1699         netstate[num++] = prop_atoms.net_wm_state_above;
1700     if (self->below)
1701         netstate[num++] = prop_atoms.net_wm_state_below;
1702     if (self->undecorated)
1703         netstate[num++] = prop_atoms.ob_wm_state_undecorated;
1704     PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
1705
1706     client_calc_layer(self);
1707
1708     if (self->frame)
1709         frame_adjust_state(self->frame);
1710 }
1711
1712 ObClient *client_search_focus_tree(ObClient *self)
1713 {
1714     GSList *it;
1715     ObClient *ret;
1716
1717     for (it = self->transients; it != NULL; it = it->next) {
1718         if (client_focused(it->data)) return it->data;
1719         if ((ret = client_search_focus_tree(it->data))) return ret;
1720     }
1721     return NULL;
1722 }
1723
1724 ObClient *client_search_focus_tree_full(ObClient *self)
1725 {
1726     if (self->transient_for) {
1727         if (self->transient_for != OB_TRAN_GROUP) {
1728             return client_search_focus_tree_full(self->transient_for);
1729         } else {
1730             GSList *it;
1731             gboolean recursed = FALSE;
1732
1733             for (it = self->group->members; it; it = it->next)
1734                 if (!((ObClient*)it->data)->transient_for) {
1735                     ObClient *c;
1736                     if ((c = client_search_focus_tree_full(it->data)))
1737                         return c;
1738                     recursed = TRUE;
1739                 }
1740             if (recursed)
1741                 return NULL;
1742         }
1743     }
1744
1745     /* this function checks the whole tree, the client_search_focus_tree~
1746        does not, so we need to check this window */
1747     if (client_focused(self))
1748         return self;
1749     return client_search_focus_tree(self);
1750 }
1751
1752 static ObStackingLayer calc_layer(ObClient *self)
1753 {
1754     ObStackingLayer l;
1755
1756     if (self->fullscreen &&
1757         (client_focused(self) || client_search_focus_tree(self)))
1758         l = OB_STACKING_LAYER_FULLSCREEN;
1759     else if (self->type == OB_CLIENT_TYPE_DESKTOP)
1760         l = OB_STACKING_LAYER_DESKTOP;
1761     else if (self->type == OB_CLIENT_TYPE_DOCK) {
1762         if (self->above) l = OB_STACKING_LAYER_DOCK_ABOVE;
1763         else if (self->below) l = OB_STACKING_LAYER_DOCK_BELOW;
1764         else l = OB_STACKING_LAYER_NORMAL;
1765     }
1766     else if (self->above) l = OB_STACKING_LAYER_ABOVE;
1767     else if (self->below) l = OB_STACKING_LAYER_BELOW;
1768     else l = OB_STACKING_LAYER_NORMAL;
1769
1770     return l;
1771 }
1772
1773 static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
1774                                         ObStackingLayer l, gboolean raised)
1775 {
1776     ObStackingLayer old, own;
1777     GSList *it;
1778
1779     old = self->layer;
1780     own = calc_layer(self);
1781     self->layer = l > own ? l : own;
1782
1783     for (it = self->transients; it; it = it->next)
1784         client_calc_layer_recursive(it->data, orig,
1785                                     l, raised ? raised : l != old);
1786
1787     if (!raised && l != old)
1788         if (orig->frame) { /* only restack if the original window is managed */
1789             stacking_remove(CLIENT_AS_WINDOW(self));
1790             stacking_add(CLIENT_AS_WINDOW(self));
1791         }
1792 }
1793
1794 void client_calc_layer(ObClient *self)
1795 {
1796     ObStackingLayer l;
1797     ObClient *orig;
1798
1799     orig = self;
1800
1801     /* transients take on the layer of their parents */
1802     self = client_search_top_transient(self);
1803
1804     l = calc_layer(self);
1805
1806     client_calc_layer_recursive(self, orig, l, FALSE);
1807 }
1808
1809 gboolean client_should_show(ObClient *self)
1810 {
1811     if (self->iconic)
1812         return FALSE;
1813     if (client_normal(self) && screen_showing_desktop)
1814         return FALSE;
1815     /*
1816     if (self->transient_for) {
1817         if (self->transient_for != OB_TRAN_GROUP)
1818             return client_should_show(self->transient_for);
1819         else {
1820             GSList *it;
1821
1822             for (it = self->group->members; it; it = g_slist_next(it)) {
1823                 ObClient *c = it->data;
1824                 if (c != self && !c->transient_for) {
1825                     if (client_should_show(c))
1826                         return TRUE;
1827                 }
1828             }
1829         }
1830     }
1831     */
1832     if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
1833         return TRUE;
1834
1835     return FALSE;
1836 }
1837
1838 static void client_showhide(ObClient *self)
1839 {
1840
1841     if (client_should_show(self))
1842         frame_show(self->frame);
1843     else
1844         frame_hide(self->frame);
1845 }
1846
1847 gboolean client_normal(ObClient *self) {
1848     return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
1849               self->type == OB_CLIENT_TYPE_DOCK ||
1850               self->type == OB_CLIENT_TYPE_SPLASH);
1851 }
1852
1853 static void client_apply_startup_state(ObClient *self)
1854 {
1855     /* these are in a carefully crafted order.. */
1856
1857     if (self->iconic) {
1858         self->iconic = FALSE;
1859         client_iconify(self, TRUE, FALSE);
1860     }
1861     if (self->fullscreen) {
1862         self->fullscreen = FALSE;
1863         client_fullscreen(self, TRUE, FALSE);
1864     }
1865     if (self->undecorated) {
1866         self->undecorated = FALSE;
1867         client_set_undecorated(self, TRUE);
1868     }
1869     if (self->shaded) {
1870         self->shaded = FALSE;
1871         client_shade(self, TRUE);
1872     }
1873     if (self->urgent)
1874         client_urgent_notify(self);
1875
1876     if (self->max_vert && self->max_horz) {
1877         self->max_vert = self->max_horz = FALSE;
1878         client_maximize(self, TRUE, 0, FALSE);
1879     } else if (self->max_vert) {
1880         self->max_vert = FALSE;
1881         client_maximize(self, TRUE, 2, FALSE);
1882     } else if (self->max_horz) {
1883         self->max_horz = FALSE;
1884         client_maximize(self, TRUE, 1, FALSE);
1885     }
1886
1887     /* nothing to do for the other states:
1888        skip_taskbar
1889        skip_pager
1890        modal
1891        above
1892        below
1893     */
1894 }
1895
1896 void client_configure_full(ObClient *self, ObCorner anchor,
1897                            int x, int y, int w, int h,
1898                            gboolean user, gboolean final,
1899                            gboolean force_reply)
1900 {
1901     gint oldw, oldh;
1902     gboolean send_resize_client;
1903     gboolean moved = FALSE, resized = FALSE;
1904     guint fdecor = self->frame->decorations;
1905     gboolean fhorz = self->frame->max_horz;
1906
1907     /* make the frame recalculate its dimentions n shit without changing
1908        anything visible for real, this way the constraints below can work with
1909        the updated frame dimensions. */
1910     frame_adjust_area(self->frame, TRUE, TRUE, TRUE);
1911
1912     /* gets the frame's position */
1913     frame_client_gravity(self->frame, &x, &y);
1914
1915     /* these positions are frame positions, not client positions */
1916
1917     /* set the size and position if fullscreen */
1918     if (self->fullscreen) {
1919 #ifdef VIDMODE
1920         int dot;
1921         XF86VidModeModeLine mode;
1922 #endif
1923         Rect *a;
1924         guint i;
1925
1926         i = client_monitor(self);
1927         a = screen_physical_area_monitor(i);
1928
1929 #ifdef VIDMODE
1930         if (i == 0 && /* primary head */
1931             extensions_vidmode &&
1932             XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y) &&
1933             /* get the mode last so the mode.privsize isnt freed incorrectly */
1934             XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
1935             x += a->x;
1936             y += a->y;
1937             w = mode.hdisplay;
1938             h = mode.vdisplay;
1939             if (mode.privsize) XFree(mode.private);
1940         } else
1941 #endif
1942         {
1943             x = a->x;
1944             y = a->y;
1945             w = a->width;
1946             h = a->height;
1947         }
1948
1949         user = FALSE; /* ignore that increment etc shit when in fullscreen */
1950     } else {
1951         Rect *a;
1952
1953         a = screen_area_monitor(self->desktop, client_monitor(self));
1954
1955         /* set the size and position if maximized */
1956         if (self->max_horz) {
1957             x = a->x;
1958             w = a->width - self->frame->size.left - self->frame->size.right;
1959         }
1960         if (self->max_vert) {
1961             y = a->y;
1962             h = a->height - self->frame->size.top - self->frame->size.bottom;
1963         }
1964     }
1965
1966     /* gets the client's position */
1967     frame_frame_gravity(self->frame, &x, &y);
1968
1969     /* these override the above states! if you cant move you can't move! */
1970     if (user) {
1971         if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
1972             x = self->area.x;
1973             y = self->area.y;
1974         }
1975         if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
1976             w = self->area.width;
1977             h = self->area.height;
1978         }
1979     }
1980
1981     if (!(w == self->area.width && h == self->area.height)) {
1982         int basew, baseh, minw, minh;
1983
1984         /* base size is substituted with min size if not specified */
1985         if (self->base_size.width || self->base_size.height) {
1986             basew = self->base_size.width;
1987             baseh = self->base_size.height;
1988         } else {
1989             basew = self->min_size.width;
1990             baseh = self->min_size.height;
1991         }
1992         /* min size is substituted with base size if not specified */
1993         if (self->min_size.width || self->min_size.height) {
1994             minw = self->min_size.width;
1995             minh = self->min_size.height;
1996         } else {
1997             minw = self->base_size.width;
1998             minh = self->base_size.height;
1999         }
2000
2001         /* if this is a user-requested resize, then check against min/max
2002            sizes */
2003
2004         /* smaller than min size or bigger than max size? */
2005         if (w > self->max_size.width) w = self->max_size.width;
2006         if (w < minw) w = minw;
2007         if (h > self->max_size.height) h = self->max_size.height;
2008         if (h < minh) h = minh;
2009
2010         w -= basew;
2011         h -= baseh;
2012
2013         /* keep to the increments */
2014         w /= self->size_inc.width;
2015         h /= self->size_inc.height;
2016
2017         /* you cannot resize to nothing */
2018         if (basew + w < 1) w = 1 - basew;
2019         if (baseh + h < 1) h = 1 - baseh;
2020
2021         /* store the logical size */
2022         SIZE_SET(self->logical_size,
2023                  self->size_inc.width > 1 ? w : w + basew,
2024                  self->size_inc.height > 1 ? h : h + baseh);
2025
2026         w *= self->size_inc.width;
2027         h *= self->size_inc.height;
2028
2029         w += basew;
2030         h += baseh;
2031
2032         /* adjust the height to match the width for the aspect ratios.
2033            for this, min size is not substituted for base size ever. */
2034         w -= self->base_size.width;
2035         h -= self->base_size.height;
2036
2037         if (self->min_ratio)
2038             if (h * self->min_ratio > w) {
2039                 h = (int)(w / self->min_ratio);
2040
2041                 /* you cannot resize to nothing */
2042                 if (h < 1) {
2043                     h = 1;
2044                     w = (int)(h * self->min_ratio);
2045                 }
2046             }
2047         if (self->max_ratio)
2048             if (h * self->max_ratio < w) {
2049                 h = (int)(w / self->max_ratio);
2050
2051                 /* you cannot resize to nothing */
2052                 if (h < 1) {
2053                     h = 1;
2054                     w = (int)(h * self->min_ratio);
2055                 }
2056             }
2057
2058         w += self->base_size.width;
2059         h += self->base_size.height;
2060     }
2061
2062     g_assert(w > 0);
2063     g_assert(h > 0);
2064
2065     switch (anchor) {
2066     case OB_CORNER_TOPLEFT:
2067         break;
2068     case OB_CORNER_TOPRIGHT:
2069         x -= w - self->area.width;
2070         break;
2071     case OB_CORNER_BOTTOMLEFT:
2072         y -= h - self->area.height;
2073         break;
2074     case OB_CORNER_BOTTOMRIGHT:
2075         x -= w - self->area.width;
2076         y -= h - self->area.height;
2077         break;
2078     }
2079
2080     moved = x != self->area.x || y != self->area.y;
2081     resized = w != self->area.width || h != self->area.height;
2082
2083     oldw = self->area.width;
2084     oldh = self->area.height;
2085     RECT_SET(self->area, x, y, w, h);
2086
2087     /* for app-requested resizes, always resize if 'resized' is true.
2088        for user-requested ones, only resize if final is true, or when
2089        resizing in redraw mode */
2090     send_resize_client = ((!user && resized) ||
2091                           (user && (final ||
2092                                     (resized && config_redraw_resize))));
2093
2094     /* if the client is enlarging, the resize the client before the frame */
2095     if (send_resize_client && user && (w > oldw || h > oldh))
2096         XResizeWindow(ob_display, self->window, MAX(w, oldw), MAX(h, oldh));
2097
2098     /* move/resize the frame to match the request */
2099     if (self->frame) {
2100         if (self->decorations != fdecor || self->max_horz != fhorz)
2101             moved = resized = TRUE;
2102
2103         if (moved || resized)
2104             frame_adjust_area(self->frame, moved, resized, FALSE);
2105
2106         if (!resized && (force_reply || ((!user && moved) || (user && final))))
2107         {
2108             XEvent event;
2109             event.type = ConfigureNotify;
2110             event.xconfigure.display = ob_display;
2111             event.xconfigure.event = self->window;
2112             event.xconfigure.window = self->window;
2113
2114             /* root window real coords */
2115             event.xconfigure.x = self->frame->area.x + self->frame->size.left -
2116                 self->border_width;
2117             event.xconfigure.y = self->frame->area.y + self->frame->size.top -
2118                 self->border_width;
2119             event.xconfigure.width = w;
2120             event.xconfigure.height = h;
2121             event.xconfigure.border_width = 0;
2122             event.xconfigure.above = self->frame->plate;
2123             event.xconfigure.override_redirect = FALSE;
2124             XSendEvent(event.xconfigure.display, event.xconfigure.window,
2125                        FALSE, StructureNotifyMask, &event);
2126         }
2127     }
2128
2129     /* if the client is shrinking, then resize the frame before the client */
2130     if (send_resize_client && (!user || (w <= oldw || h <= oldh)))
2131         XResizeWindow(ob_display, self->window, w, h);
2132
2133     XFlush(ob_display);
2134 }
2135
2136 void client_fullscreen(ObClient *self, gboolean fs, gboolean savearea)
2137 {
2138     int x, y, w, h;
2139
2140     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
2141         self->fullscreen == fs) return;                   /* already done */
2142
2143     self->fullscreen = fs;
2144     client_change_state(self); /* change the state hints on the client,
2145                                   and adjust out layer/stacking */
2146
2147     if (fs) {
2148         if (savearea)
2149             self->pre_fullscreen_area = self->area;
2150
2151         /* these are not actually used cuz client_configure will set them
2152            as appropriate when the window is fullscreened */
2153         x = y = w = h = 0;
2154     } else {
2155         Rect *a;
2156
2157         if (self->pre_fullscreen_area.width > 0 &&
2158             self->pre_fullscreen_area.height > 0)
2159         {
2160             x = self->pre_fullscreen_area.x;
2161             y = self->pre_fullscreen_area.y;
2162             w = self->pre_fullscreen_area.width;
2163             h = self->pre_fullscreen_area.height;
2164             RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
2165         } else {
2166             /* pick some fallbacks... */
2167             a = screen_area_monitor(self->desktop, 0);
2168             x = a->x + a->width / 4;
2169             y = a->y + a->height / 4;
2170             w = a->width / 2;
2171             h = a->height / 2;
2172         }
2173     }
2174
2175     client_setup_decor_and_functions(self);
2176
2177     client_move_resize(self, x, y, w, h);
2178
2179     /* try focus us when we go into fullscreen mode */
2180     client_focus(self);
2181 }
2182
2183 static void client_iconify_recursive(ObClient *self,
2184                                      gboolean iconic, gboolean curdesk)
2185 {
2186     GSList *it;
2187     gboolean changed = FALSE;
2188
2189
2190     if (self->iconic != iconic) {
2191         ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
2192                  self->window);
2193
2194         self->iconic = iconic;
2195
2196         if (iconic) {
2197             if (self->functions & OB_CLIENT_FUNC_ICONIFY) {
2198                 long old;
2199
2200                 old = self->wmstate;
2201                 self->wmstate = IconicState;
2202                 if (old != self->wmstate)
2203                     PROP_MSG(self->window, kde_wm_change_state,
2204                              self->wmstate, 1, 0, 0);
2205
2206                 self->ignore_unmaps++;
2207                 /* we unmap the client itself so that we can get MapRequest
2208                    events, and because the ICCCM tells us to! */
2209                 XUnmapWindow(ob_display, self->window);
2210
2211                 /* update the focus lists.. iconic windows go to the bottom of
2212                    the list, put the new iconic window at the 'top of the
2213                    bottom'. */
2214                 focus_order_to_top(self);
2215
2216                 changed = TRUE;
2217             }
2218         } else {
2219             long old;
2220
2221             if (curdesk)
2222                 client_set_desktop(self, screen_desktop, FALSE);
2223
2224             old = self->wmstate;
2225             self->wmstate = self->shaded ? IconicState : NormalState;
2226             if (old != self->wmstate)
2227                 PROP_MSG(self->window, kde_wm_change_state,
2228                          self->wmstate, 1, 0, 0);
2229
2230             XMapWindow(ob_display, self->window);
2231
2232             /* this puts it after the current focused window */
2233             focus_order_remove(self);
2234             focus_order_add_new(self);
2235
2236             /* this is here cuz with the VIDMODE extension, the viewport can
2237                change while a fullscreen window is iconic, and when it
2238                uniconifies, it would be nice if it did so to the new position
2239                of the viewport */
2240             client_reconfigure(self);
2241
2242             changed = TRUE;
2243         }
2244     }
2245
2246     if (changed) {
2247         client_change_state(self);
2248         client_showhide(self);
2249         screen_update_areas();
2250     }
2251
2252     /* iconify all transients */
2253     for (it = self->transients; it != NULL; it = it->next)
2254         if (it->data != self) client_iconify_recursive(it->data,
2255                                                        iconic, curdesk);
2256 }
2257
2258 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk)
2259 {
2260     /* move up the transient chain as far as possible first */
2261     self = client_search_top_transient(self);
2262
2263     client_iconify_recursive(client_search_top_transient(self),
2264                              iconic, curdesk);
2265 }
2266
2267 void client_maximize(ObClient *self, gboolean max, int dir, gboolean savearea)
2268 {
2269     int x, y, w, h;
2270
2271     g_assert(dir == 0 || dir == 1 || dir == 2);
2272     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
2273
2274     /* check if already done */
2275     if (max) {
2276         if (dir == 0 && self->max_horz && self->max_vert) return;
2277         if (dir == 1 && self->max_horz) return;
2278         if (dir == 2 && self->max_vert) return;
2279     } else {
2280         if (dir == 0 && !self->max_horz && !self->max_vert) return;
2281         if (dir == 1 && !self->max_horz) return;
2282         if (dir == 2 && !self->max_vert) return;
2283     }
2284
2285     /* we just tell it to configure in the same place and client_configure
2286        worries about filling the screen with the window */
2287     x = self->area.x;
2288     y = self->area.y;
2289     w = self->area.width;
2290     h = self->area.height;
2291
2292     if (max) {
2293         if (savearea) {
2294             if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
2295                 RECT_SET(self->pre_max_area,
2296                          self->area.x, self->pre_max_area.y,
2297                          self->area.width, self->pre_max_area.height);
2298             }
2299             if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
2300                 RECT_SET(self->pre_max_area,
2301                          self->pre_max_area.x, self->area.y,
2302                          self->pre_max_area.width, self->area.height);
2303             }
2304         }
2305     } else {
2306         Rect *a;
2307
2308         a = screen_area_monitor(self->desktop, 0);
2309         if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
2310             if (self->pre_max_area.width > 0) {
2311                 x = self->pre_max_area.x;
2312                 w = self->pre_max_area.width;
2313
2314                 RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
2315                          0, self->pre_max_area.height);
2316             } else {
2317                 /* pick some fallbacks... */
2318                 x = a->x + a->width / 4;
2319                 w = a->width / 2;
2320             }
2321         }
2322         if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
2323             if (self->pre_max_area.height > 0) {
2324                 y = self->pre_max_area.y;
2325                 h = self->pre_max_area.height;
2326
2327                 RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
2328                          self->pre_max_area.width, 0);
2329             } else {
2330                 /* pick some fallbacks... */
2331                 y = a->y + a->height / 4;
2332                 h = a->height / 2;
2333             }
2334         }
2335     }
2336
2337     if (dir == 0 || dir == 1) /* horz */
2338         self->max_horz = max;
2339     if (dir == 0 || dir == 2) /* vert */
2340         self->max_vert = max;
2341
2342     client_change_state(self); /* change the state hints on the client */
2343
2344     client_setup_decor_and_functions(self);
2345
2346     client_move_resize(self, x, y, w, h);
2347 }
2348
2349 void client_shade(ObClient *self, gboolean shade)
2350 {
2351     if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
2352          shade) ||                         /* can't shade */
2353         self->shaded == shade) return;     /* already done */
2354
2355     /* when we're iconic, don't change the wmstate */
2356     if (!self->iconic) {
2357         long old;
2358
2359         old = self->wmstate;
2360         self->wmstate = shade ? IconicState : NormalState;
2361         if (old != self->wmstate)
2362             PROP_MSG(self->window, kde_wm_change_state,
2363                      self->wmstate, 1, 0, 0);
2364     }
2365
2366     self->shaded = shade;
2367     client_change_state(self);
2368     /* resize the frame to just the titlebar */
2369     frame_adjust_area(self->frame, FALSE, FALSE, FALSE);
2370 }
2371
2372 void client_close(ObClient *self)
2373 {
2374     XEvent ce;
2375
2376     if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
2377
2378     /* in the case that the client provides no means to requesting that it
2379        close, we just kill it */
2380     if (!self->delete_window)
2381         client_kill(self);
2382
2383     /*
2384       XXX: itd be cool to do timeouts and shit here for killing the client's
2385       process off
2386       like... if the window is around after 5 seconds, then the close button
2387       turns a nice red, and if this function is called again, the client is
2388       explicitly killed.
2389     */
2390
2391     ce.xclient.type = ClientMessage;
2392     ce.xclient.message_type =  prop_atoms.wm_protocols;
2393     ce.xclient.display = ob_display;
2394     ce.xclient.window = self->window;
2395     ce.xclient.format = 32;
2396     ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
2397     ce.xclient.data.l[1] = event_lasttime;
2398     ce.xclient.data.l[2] = 0l;
2399     ce.xclient.data.l[3] = 0l;
2400     ce.xclient.data.l[4] = 0l;
2401     XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
2402 }
2403
2404 void client_kill(ObClient *self)
2405 {
2406     XKillClient(ob_display, self->window);
2407 }
2408
2409 void client_set_desktop_recursive(ObClient *self,
2410                                   guint target, gboolean donthide)
2411 {
2412     guint old;
2413     GSList *it;
2414
2415     if (target != self->desktop) {
2416
2417         ob_debug("Setting desktop %u\n", target+1);
2418
2419         g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
2420
2421         /* remove from the old desktop(s) */
2422         focus_order_remove(self);
2423
2424         old = self->desktop;
2425         self->desktop = target;
2426         PROP_SET32(self->window, net_wm_desktop, cardinal, target);
2427         /* the frame can display the current desktop state */
2428         frame_adjust_state(self->frame);
2429         /* 'move' the window to the new desktop */
2430         if (!donthide)
2431             client_showhide(self);
2432         /* raise if it was not already on the desktop */
2433         if (old != DESKTOP_ALL)
2434             client_raise(self);
2435         screen_update_areas();
2436
2437         /* add to the new desktop(s) */
2438         if (config_focus_new)
2439             focus_order_to_top(self);
2440         else
2441             focus_order_to_bottom(self);
2442     }
2443
2444     /* move all transients */
2445     for (it = self->transients; it != NULL; it = it->next)
2446         if (it->data != self) client_set_desktop_recursive(it->data,
2447                                                            target, donthide);
2448 }
2449
2450 void client_set_desktop(ObClient *self, guint target, gboolean donthide)
2451 {
2452     client_set_desktop_recursive(client_search_top_transient(self),
2453                                  target, donthide);
2454 }
2455
2456 ObClient *client_search_modal_child(ObClient *self)
2457 {
2458     GSList *it;
2459     ObClient *ret;
2460
2461     for (it = self->transients; it != NULL; it = it->next) {
2462         ObClient *c = it->data;
2463         if ((ret = client_search_modal_child(c))) return ret;
2464         if (c->modal) return c;
2465     }
2466     return NULL;
2467 }
2468
2469 gboolean client_validate(ObClient *self)
2470 {
2471     XEvent e;
2472
2473     XSync(ob_display, FALSE); /* get all events on the server */
2474
2475     if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
2476         XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
2477         XPutBackEvent(ob_display, &e);
2478         return FALSE;
2479     }
2480
2481     return TRUE;
2482 }
2483
2484 void client_set_wm_state(ObClient *self, long state)
2485 {
2486     if (state == self->wmstate) return; /* no change */
2487
2488     switch (state) {
2489     case IconicState:
2490         client_iconify(self, TRUE, TRUE);
2491         break;
2492     case NormalState:
2493         client_iconify(self, FALSE, TRUE);
2494         break;
2495     }
2496 }
2497
2498 void client_set_state(ObClient *self, Atom action, long data1, long data2)
2499 {
2500     gboolean shaded = self->shaded;
2501     gboolean fullscreen = self->fullscreen;
2502     gboolean undecorated = self->undecorated;
2503     gboolean max_horz = self->max_horz;
2504     gboolean max_vert = self->max_vert;
2505     gboolean modal = self->modal;
2506     int i;
2507
2508     if (!(action == prop_atoms.net_wm_state_add ||
2509           action == prop_atoms.net_wm_state_remove ||
2510           action == prop_atoms.net_wm_state_toggle))
2511         /* an invalid action was passed to the client message, ignore it */
2512         return;
2513
2514     for (i = 0; i < 2; ++i) {
2515         Atom state = i == 0 ? data1 : data2;
2516
2517         if (!state) continue;
2518
2519         /* if toggling, then pick whether we're adding or removing */
2520         if (action == prop_atoms.net_wm_state_toggle) {
2521             if (state == prop_atoms.net_wm_state_modal)
2522                 action = modal ? prop_atoms.net_wm_state_remove :
2523                     prop_atoms.net_wm_state_add;
2524             else if (state == prop_atoms.net_wm_state_maximized_vert)
2525                 action = self->max_vert ? prop_atoms.net_wm_state_remove :
2526                     prop_atoms.net_wm_state_add;
2527             else if (state == prop_atoms.net_wm_state_maximized_horz)
2528                 action = self->max_horz ? prop_atoms.net_wm_state_remove :
2529                     prop_atoms.net_wm_state_add;
2530             else if (state == prop_atoms.net_wm_state_shaded)
2531                 action = shaded ? prop_atoms.net_wm_state_remove :
2532                     prop_atoms.net_wm_state_add;
2533             else if (state == prop_atoms.net_wm_state_skip_taskbar)
2534                 action = self->skip_taskbar ?
2535                     prop_atoms.net_wm_state_remove :
2536                     prop_atoms.net_wm_state_add;
2537             else if (state == prop_atoms.net_wm_state_skip_pager)
2538                 action = self->skip_pager ?
2539                     prop_atoms.net_wm_state_remove :
2540                     prop_atoms.net_wm_state_add;
2541             else if (state == prop_atoms.net_wm_state_fullscreen)
2542                 action = fullscreen ?
2543                     prop_atoms.net_wm_state_remove :
2544                     prop_atoms.net_wm_state_add;
2545             else if (state == prop_atoms.net_wm_state_above)
2546                 action = self->above ? prop_atoms.net_wm_state_remove :
2547                     prop_atoms.net_wm_state_add;
2548             else if (state == prop_atoms.net_wm_state_below)
2549                 action = self->below ? prop_atoms.net_wm_state_remove :
2550                     prop_atoms.net_wm_state_add;
2551             else if (state == prop_atoms.ob_wm_state_undecorated)
2552                 action = undecorated ? prop_atoms.net_wm_state_remove :
2553                     prop_atoms.net_wm_state_add;
2554         }
2555
2556         if (action == prop_atoms.net_wm_state_add) {
2557             if (state == prop_atoms.net_wm_state_modal) {
2558                 modal = TRUE;
2559             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
2560                 max_vert = TRUE;
2561             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
2562                 max_horz = TRUE;
2563             } else if (state == prop_atoms.net_wm_state_shaded) {
2564                 shaded = TRUE;
2565             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
2566                 self->skip_taskbar = TRUE;
2567             } else if (state == prop_atoms.net_wm_state_skip_pager) {
2568                 self->skip_pager = TRUE;
2569             } else if (state == prop_atoms.net_wm_state_fullscreen) {
2570                 fullscreen = TRUE;
2571             } else if (state == prop_atoms.net_wm_state_above) {
2572                 self->above = TRUE;
2573             } else if (state == prop_atoms.net_wm_state_below) {
2574                 self->below = TRUE;
2575             } else if (state == prop_atoms.ob_wm_state_undecorated) {
2576                 undecorated = TRUE;
2577             }
2578
2579         } else { /* action == prop_atoms.net_wm_state_remove */
2580             if (state == prop_atoms.net_wm_state_modal) {
2581                 modal = FALSE;
2582             } else if (state == prop_atoms.net_wm_state_maximized_vert) {
2583                 max_vert = FALSE;
2584             } else if (state == prop_atoms.net_wm_state_maximized_horz) {
2585                 max_horz = FALSE;
2586             } else if (state == prop_atoms.net_wm_state_shaded) {
2587                 shaded = FALSE;
2588             } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
2589                 self->skip_taskbar = FALSE;
2590             } else if (state == prop_atoms.net_wm_state_skip_pager) {
2591                 self->skip_pager = FALSE;
2592             } else if (state == prop_atoms.net_wm_state_fullscreen) {
2593                 fullscreen = FALSE;
2594             } else if (state == prop_atoms.net_wm_state_above) {
2595                 self->above = FALSE;
2596             } else if (state == prop_atoms.net_wm_state_below) {
2597                 self->below = FALSE;
2598             } else if (state == prop_atoms.ob_wm_state_undecorated) {
2599                 undecorated = FALSE;
2600             }
2601         }
2602     }
2603     if (max_horz != self->max_horz || max_vert != self->max_vert) {
2604         if (max_horz != self->max_horz && max_vert != self->max_vert) {
2605             /* toggling both */
2606             if (max_horz == max_vert) { /* both going the same way */
2607                 client_maximize(self, max_horz, 0, TRUE);
2608             } else {
2609                 client_maximize(self, max_horz, 1, TRUE);
2610                 client_maximize(self, max_vert, 2, TRUE);
2611             }
2612         } else {
2613             /* toggling one */
2614             if (max_horz != self->max_horz)
2615                 client_maximize(self, max_horz, 1, TRUE);
2616             else
2617                 client_maximize(self, max_vert, 2, TRUE);
2618         }
2619     }
2620     /* change fullscreen state before shading, as it will affect if the window
2621        can shade or not */
2622     if (fullscreen != self->fullscreen)
2623         client_fullscreen(self, fullscreen, TRUE);
2624     if (shaded != self->shaded)
2625         client_shade(self, shaded);
2626     if (undecorated != self->undecorated)
2627         client_set_undecorated(self, undecorated);
2628     if (modal != self->modal) {
2629         self->modal = modal;
2630         /* when a window changes modality, then its stacking order with its
2631            transients needs to change */
2632         client_raise(self);
2633     }
2634     client_calc_layer(self);
2635     client_change_state(self); /* change the hint to reflect these changes */
2636 }
2637
2638 ObClient *client_focus_target(ObClient *self)
2639 {
2640     ObClient *child;
2641
2642     /* if we have a modal child, then focus it, not us */
2643     child = client_search_modal_child(client_search_top_transient(self));
2644     if (child) return child;
2645     return self;
2646 }
2647
2648 gboolean client_can_focus(ObClient *self)
2649 {
2650     XEvent ev;
2651
2652     /* choose the correct target */
2653     self = client_focus_target(self);
2654
2655     if (!self->frame->visible)
2656         return FALSE;
2657
2658     if (!(self->can_focus || self->focus_notify))
2659         return FALSE;
2660
2661     /* do a check to see if the window has already been unmapped or destroyed
2662        do this intelligently while watching out for unmaps we've generated
2663        (ignore_unmaps > 0) */
2664     if (XCheckTypedWindowEvent(ob_display, self->window,
2665                                DestroyNotify, &ev)) {
2666         XPutBackEvent(ob_display, &ev);
2667         return FALSE;
2668     }
2669     while (XCheckTypedWindowEvent(ob_display, self->window,
2670                                   UnmapNotify, &ev)) {
2671         if (self->ignore_unmaps) {
2672             self->ignore_unmaps--;
2673         } else {
2674             XPutBackEvent(ob_display, &ev);
2675             return FALSE;
2676         }
2677     }
2678
2679     return TRUE;
2680 }
2681
2682 gboolean client_focus(ObClient *self)
2683 {
2684     /* choose the correct target */
2685     self = client_focus_target(self);
2686
2687     if (!client_can_focus(self)) {
2688         if (!self->frame->visible) {
2689             /* update the focus lists */
2690             focus_order_to_top(self);
2691         }
2692         return FALSE;
2693     }
2694
2695     if (self->can_focus) {
2696         /* RevertToPointerRoot causes much more headache than RevertToNone, so
2697            I choose to use it always, hopefully to find errors quicker, if any
2698            are left. (I hate X. I hate focus events.)
2699
2700            Update: Changing this to RevertToNone fixed a bug with mozilla (bug
2701            #799. So now it is RevertToNone again.
2702         */
2703         XSetInputFocus(ob_display, self->window, RevertToNone,
2704                        event_lasttime);
2705     }
2706
2707     if (self->focus_notify) {
2708         XEvent ce;
2709         ce.xclient.type = ClientMessage;
2710         ce.xclient.message_type = prop_atoms.wm_protocols;
2711         ce.xclient.display = ob_display;
2712         ce.xclient.window = self->window;
2713         ce.xclient.format = 32;
2714         ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
2715         ce.xclient.data.l[1] = event_lasttime;
2716         ce.xclient.data.l[2] = 0l;
2717         ce.xclient.data.l[3] = 0l;
2718         ce.xclient.data.l[4] = 0l;
2719         XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
2720     }
2721
2722 #ifdef DEBUG_FOCUS
2723     ob_debug("%sively focusing %lx at %d\n",
2724              (self->can_focus ? "act" : "pass"),
2725              self->window, (int) event_lasttime);
2726 #endif
2727
2728     /* Cause the FocusIn to come back to us. Important for desktop switches,
2729        since otherwise we'll have no FocusIn on the queue and send it off to
2730        the focus_backup. */
2731     XSync(ob_display, FALSE);
2732     return TRUE;
2733 }
2734
2735 void client_unfocus(ObClient *self)
2736 {
2737     if (focus_client == self) {
2738 #ifdef DEBUG_FOCUS
2739         ob_debug("client_unfocus for %lx\n", self->window);
2740 #endif
2741         focus_fallback(OB_FOCUS_FALLBACK_UNFOCUSING);
2742     }
2743 }
2744
2745 void client_activate(ObClient *self, gboolean here)
2746 {
2747     if (client_normal(self) && screen_showing_desktop)
2748         screen_show_desktop(FALSE);
2749     if (self->iconic)
2750         client_iconify(self, FALSE, here);
2751     if (self->desktop != DESKTOP_ALL &&
2752         self->desktop != screen_desktop) {
2753         if (here)
2754             client_set_desktop(self, screen_desktop, FALSE);
2755         else
2756             screen_set_desktop(self->desktop);
2757     } else if (!self->frame->visible)
2758         /* if its not visible for other reasons, then don't mess
2759            with it */
2760         return;
2761     if (self->shaded)
2762         client_shade(self, FALSE);
2763
2764     client_focus(self);
2765
2766     /* we do this an action here. this is rather important. this is because
2767        we want the results from the focus change to take place BEFORE we go
2768        about raising the window. when a fullscreen window loses focus, we need
2769        this or else the raise wont be able to raise above the to-lose-focus
2770        fullscreen window. */
2771     client_raise(self);
2772 }
2773
2774 void client_raise(ObClient *self)
2775 {
2776     action_run_string("Raise", self);
2777 }
2778
2779 void client_lower(ObClient *self)
2780 {
2781     action_run_string("Raise", self);
2782 }
2783
2784 gboolean client_focused(ObClient *self)
2785 {
2786     return self == focus_client;
2787 }
2788
2789 static ObClientIcon* client_icon_recursive(ObClient *self, int w, int h)
2790 {
2791     guint i;
2792     /* si is the smallest image >= req */
2793     /* li is the largest image < req */
2794     unsigned long size, smallest = 0xffffffff, largest = 0, si = 0, li = 0;
2795
2796     if (!self->nicons) {
2797         ObClientIcon *parent = NULL;
2798
2799         if (self->transient_for) {
2800             if (self->transient_for != OB_TRAN_GROUP)
2801                 parent = client_icon_recursive(self->transient_for, w, h);
2802             else {
2803                 GSList *it;
2804                 for (it = self->group->members; it; it = g_slist_next(it)) {
2805                     ObClient *c = it->data;
2806                     if (c != self && !c->transient_for) {
2807                         if ((parent = client_icon_recursive(c, w, h)))
2808                             break;
2809                     }
2810                 }
2811             }
2812         }
2813
2814         return parent;
2815     }
2816
2817     for (i = 0; i < self->nicons; ++i) {
2818         size = self->icons[i].width * self->icons[i].height;
2819         if (size < smallest && size >= (unsigned)(w * h)) {
2820             smallest = size;
2821             si = i;
2822         }
2823         if (size > largest && size <= (unsigned)(w * h)) {
2824             largest = size;
2825             li = i;
2826         }
2827     }
2828     if (largest == 0) /* didnt find one smaller than the requested size */
2829         return &self->icons[si];
2830     return &self->icons[li];
2831 }
2832
2833 const ObClientIcon* client_icon(ObClient *self, int w, int h)
2834 {
2835     ObClientIcon *ret;
2836     static ObClientIcon deficon;
2837
2838     if (!(ret = client_icon_recursive(self, w, h))) {
2839         deficon.width = deficon.height = 48;
2840         deficon.data = ob_rr_theme->def_win_icon;
2841         ret = &deficon;
2842     }
2843     return ret;
2844 }
2845
2846 /* this be mostly ripped from fvwm */
2847 ObClient *client_find_directional(ObClient *c, ObDirection dir)
2848 {
2849     int my_cx, my_cy, his_cx, his_cy;
2850     int offset = 0;
2851     int distance = 0;
2852     int score, best_score;
2853     ObClient *best_client, *cur;
2854     GList *it;
2855
2856     if(!client_list)
2857         return NULL;
2858
2859     /* first, find the centre coords of the currently focused window */
2860     my_cx = c->frame->area.x + c->frame->area.width / 2;
2861     my_cy = c->frame->area.y + c->frame->area.height / 2;
2862
2863     best_score = -1;
2864     best_client = NULL;
2865
2866     for(it = g_list_first(client_list); it; it = it->next) {
2867         cur = it->data;
2868
2869         /* the currently selected window isn't interesting */
2870         if(cur == c)
2871             continue;
2872         if (!client_normal(cur))
2873             continue;
2874         if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
2875             continue;
2876         if(cur->iconic)
2877             continue;
2878         if(client_focus_target(cur) == cur &&
2879            !(cur->can_focus || cur->focus_notify))
2880             continue;
2881
2882         /* find the centre coords of this window, from the
2883          * currently focused window's point of view */
2884         his_cx = (cur->frame->area.x - my_cx)
2885             + cur->frame->area.width / 2;
2886         his_cy = (cur->frame->area.y - my_cy)
2887             + cur->frame->area.height / 2;
2888
2889         if(dir == OB_DIRECTION_NORTHEAST || dir == OB_DIRECTION_SOUTHEAST ||
2890            dir == OB_DIRECTION_SOUTHWEST || dir == OB_DIRECTION_NORTHWEST) {
2891             int tx;
2892             /* Rotate the diagonals 45 degrees counterclockwise.
2893              * To do this, multiply the matrix /+h +h\ with the
2894              * vector (x y).                   \-h +h/
2895              * h = sqrt(0.5). We can set h := 1 since absolute
2896              * distance doesn't matter here. */
2897             tx = his_cx + his_cy;
2898             his_cy = -his_cx + his_cy;
2899             his_cx = tx;
2900         }
2901
2902         switch(dir) {
2903         case OB_DIRECTION_NORTH:
2904         case OB_DIRECTION_SOUTH:
2905         case OB_DIRECTION_NORTHEAST:
2906         case OB_DIRECTION_SOUTHWEST:
2907             offset = (his_cx < 0) ? -his_cx : his_cx;
2908             distance = ((dir == OB_DIRECTION_NORTH ||
2909                          dir == OB_DIRECTION_NORTHEAST) ?
2910                         -his_cy : his_cy);
2911             break;
2912         case OB_DIRECTION_EAST:
2913         case OB_DIRECTION_WEST:
2914         case OB_DIRECTION_SOUTHEAST:
2915         case OB_DIRECTION_NORTHWEST:
2916             offset = (his_cy < 0) ? -his_cy : his_cy;
2917             distance = ((dir == OB_DIRECTION_WEST ||
2918                          dir == OB_DIRECTION_NORTHWEST) ?
2919                         -his_cx : his_cx);
2920             break;
2921         }
2922
2923         /* the target must be in the requested direction */
2924         if(distance <= 0)
2925             continue;
2926
2927         /* Calculate score for this window.  The smaller the better. */
2928         score = distance + offset;
2929
2930         /* windows more than 45 degrees off the direction are
2931          * heavily penalized and will only be chosen if nothing
2932          * else within a million pixels */
2933         if(offset > distance)
2934             score += 1000000;
2935
2936         if(best_score == -1 || score < best_score)
2937             best_client = cur,
2938                 best_score = score;
2939     }
2940
2941     return best_client;
2942 }
2943
2944 void client_set_layer(ObClient *self, int layer)
2945 {
2946     if (layer < 0) {
2947         self->below = TRUE;
2948         self->above = FALSE;
2949     } else if (layer == 0) {
2950         self->below = self->above = FALSE;
2951     } else {
2952         self->below = FALSE;
2953         self->above = TRUE;
2954     }
2955     client_calc_layer(self);
2956     client_change_state(self); /* reflect this in the state hints */
2957 }
2958
2959 void client_set_undecorated(ObClient *self, gboolean undecorated)
2960 {
2961     if (self->undecorated != undecorated) {
2962         self->undecorated = undecorated;
2963         client_setup_decor_and_functions(self);
2964         client_change_state(self); /* reflect this in the state hints */
2965     }
2966 }
2967
2968 guint client_monitor(ObClient *self)
2969 {
2970     guint i;
2971     guint most = 0;
2972     guint mostv = 0;
2973
2974     for (i = 0; i < screen_num_monitors; ++i) {
2975         Rect *area = screen_physical_area_monitor(i);
2976         if (RECT_INTERSECTS_RECT(*area, self->frame->area)) {
2977             Rect r;
2978             guint v;
2979
2980             RECT_SET_INTERSECTION(r, *area, self->frame->area);
2981             v = r.width * r.height;
2982
2983             if (v > mostv) {
2984                 mostv = v;
2985                 most = i;
2986             }
2987         }
2988     }
2989     return most;
2990 }
2991
2992 ObClient *client_search_top_transient(ObClient *self)
2993 {
2994     /* move up the transient chain as far as possible */
2995     if (self->transient_for) {
2996         if (self->transient_for != OB_TRAN_GROUP) {
2997             return client_search_top_transient(self->transient_for);
2998         } else {
2999             GSList *it;
3000
3001             g_assert(self->group);
3002
3003             for (it = self->group->members; it; it = it->next) {
3004                 ObClient *c = it->data;
3005
3006                 /* checking transient_for prevents infinate loops! */
3007                 if (c != self && !c->transient_for)
3008                     break;
3009             }
3010             if (it)
3011                 return it->data;
3012         }
3013     }
3014
3015     return self;
3016 }
3017
3018 ObClient *client_search_focus_parent(ObClient *self)
3019 {
3020     if (self->transient_for) {
3021         if (self->transient_for != OB_TRAN_GROUP) {
3022             if (client_focused(self->transient_for))
3023                 return self->transient_for;
3024         } else {
3025             GSList *it;
3026
3027             for (it = self->group->members; it; it = it->next) {
3028                 ObClient *c = it->data;
3029
3030                 /* checking transient_for prevents infinate loops! */
3031                 if (c != self && !c->transient_for)
3032                     if (client_focused(c))
3033                         return c;
3034             }
3035         }
3036     }
3037
3038     return NULL;
3039 }
3040
3041 ObClient *client_search_parent(ObClient *self, ObClient *search)
3042 {
3043     if (self->transient_for) {
3044         if (self->transient_for != OB_TRAN_GROUP) {
3045             if (self->transient_for == search)
3046                 return search;
3047         } else {
3048             GSList *it;
3049
3050             for (it = self->group->members; it; it = it->next) {
3051                 ObClient *c = it->data;
3052
3053                 /* checking transient_for prevents infinate loops! */
3054                 if (c != self && !c->transient_for)
3055                     if (c == search)
3056                         return search;
3057             }
3058         }
3059     }
3060
3061     return NULL;
3062 }
3063
3064 ObClient *client_search_transient(ObClient *self, ObClient *search)
3065 {
3066     GSList *sit;
3067
3068     for (sit = self->transients; sit; sit = g_slist_next(sit)) {
3069         if (sit->data == search)
3070             return search;
3071         if (client_search_transient(sit->data, search))
3072             return search;
3073     }
3074     return NULL;
3075 }
3076
3077 void client_update_sm_client_id(ObClient *self)
3078 {
3079     g_free(self->sm_client_id);
3080     self->sm_client_id = NULL;
3081
3082     if (!PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id) &&
3083         self->group)
3084         PROP_GETS(self->group->leader, sm_client_id, locale,
3085                   &self->sm_client_id);
3086 }
3087
3088 /* finds the nearest edge in the given direction from the current client
3089  * note to self: the edge is the -frame- edge (the actual one), not the
3090  * client edge.
3091  */
3092 int client_directional_edge_search(ObClient *c, ObDirection dir)
3093 {
3094     int dest;
3095     int my_edge_start, my_edge_end, my_offset;
3096     GList *it;
3097     Rect *a;
3098
3099     if(!client_list)
3100         return -1;
3101
3102     a = screen_area(c->desktop);
3103
3104     switch(dir) {
3105     case OB_DIRECTION_NORTH:
3106         my_edge_start = c->frame->area.x;
3107         my_edge_end = c->frame->area.x + c->frame->area.width;
3108         my_offset = c->frame->area.y;
3109
3110         /* default: top of screen */
3111         dest = a->y;
3112
3113         for(it = g_list_first(client_list); it; it = it->next) {
3114             int his_edge_start, his_edge_end, his_offset;
3115             ObClient *cur = it->data;
3116
3117             if(cur == c)
3118                 continue;
3119             if(!client_normal(cur))
3120                 continue;
3121             if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3122                 continue;
3123             if(cur->iconic)
3124                 continue;
3125
3126             his_edge_start = cur->frame->area.x;
3127             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3128             his_offset = cur->frame->area.y + cur->frame->area.height;
3129
3130             if(his_offset + 1 > my_offset)
3131                 continue;
3132
3133             if(his_offset < dest)
3134                 continue;
3135
3136             if(his_edge_start >= my_edge_start &&
3137                his_edge_start <= my_edge_end)
3138                 dest = his_offset;
3139
3140             if(my_edge_start >= his_edge_start &&
3141                my_edge_start <= his_edge_end)
3142                 dest = his_offset;
3143
3144         }
3145         break;
3146     case OB_DIRECTION_SOUTH:
3147         my_edge_start = c->frame->area.x;
3148         my_edge_end = c->frame->area.x + c->frame->area.width;
3149         my_offset = c->frame->area.y + c->frame->area.height;
3150
3151         /* default: bottom of screen */
3152         dest = a->y + a->height;
3153
3154         for(it = g_list_first(client_list); it; it = it->next) {
3155             int his_edge_start, his_edge_end, his_offset;
3156             ObClient *cur = it->data;
3157
3158             if(cur == c)
3159                 continue;
3160             if(!client_normal(cur))
3161                 continue;
3162             if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3163                 continue;
3164             if(cur->iconic)
3165                 continue;
3166
3167             his_edge_start = cur->frame->area.x;
3168             his_edge_end = cur->frame->area.x + cur->frame->area.width;
3169             his_offset = cur->frame->area.y;
3170
3171
3172             if(his_offset - 1 < my_offset)
3173                 continue;
3174
3175             if(his_offset > dest)
3176                 continue;
3177
3178             if(his_edge_start >= my_edge_start &&
3179                his_edge_start <= my_edge_end)
3180                 dest = his_offset;
3181
3182             if(my_edge_start >= his_edge_start &&
3183                my_edge_start <= his_edge_end)
3184                 dest = his_offset;
3185
3186         }
3187         break;
3188     case OB_DIRECTION_WEST:
3189         my_edge_start = c->frame->area.y;
3190         my_edge_end = c->frame->area.y + c->frame->area.height;
3191         my_offset = c->frame->area.x;
3192
3193         /* default: leftmost egde of screen */
3194         dest = a->x;
3195
3196         for(it = g_list_first(client_list); it; it = it->next) {
3197             int his_edge_start, his_edge_end, his_offset;
3198             ObClient *cur = it->data;
3199
3200             if(cur == c)
3201                 continue;
3202             if(!client_normal(cur))
3203                 continue;
3204             if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3205                 continue;
3206             if(cur->iconic)
3207                 continue;
3208
3209             his_edge_start = cur->frame->area.y;
3210             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3211             his_offset = cur->frame->area.x + cur->frame->area.width;
3212
3213             if(his_offset + 1 > my_offset)
3214                 continue;
3215
3216             if(his_offset < dest)
3217                 continue;
3218
3219             if(his_edge_start >= my_edge_start &&
3220                his_edge_start <= my_edge_end)
3221                 dest = his_offset;
3222
3223             if(my_edge_start >= his_edge_start &&
3224                my_edge_start <= his_edge_end)
3225                 dest = his_offset;
3226
3227
3228         }
3229         break;
3230     case OB_DIRECTION_EAST:
3231         my_edge_start = c->frame->area.y;
3232         my_edge_end = c->frame->area.y + c->frame->area.height;
3233         my_offset = c->frame->area.x + c->frame->area.width;
3234
3235         /* default: rightmost edge of screen */
3236         dest = a->x + a->width;
3237
3238         for(it = g_list_first(client_list); it; it = it->next) {
3239             int his_edge_start, his_edge_end, his_offset;
3240             ObClient *cur = it->data;
3241
3242             if(cur == c)
3243                 continue;
3244             if(!client_normal(cur))
3245                 continue;
3246             if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
3247                 continue;
3248             if(cur->iconic)
3249                 continue;
3250
3251             his_edge_start = cur->frame->area.y;
3252             his_edge_end = cur->frame->area.y + cur->frame->area.height;
3253             his_offset = cur->frame->area.x;
3254
3255             if(his_offset - 1 < my_offset)
3256                 continue;
3257
3258             if(his_offset > dest)
3259                 continue;
3260
3261             if(his_edge_start >= my_edge_start &&
3262                his_edge_start <= my_edge_end)
3263                 dest = his_offset;
3264
3265             if(my_edge_start >= his_edge_start &&
3266                my_edge_start <= his_edge_end)
3267                 dest = his_offset;
3268
3269         }
3270         break;
3271     case OB_DIRECTION_NORTHEAST:
3272     case OB_DIRECTION_SOUTHEAST:
3273     case OB_DIRECTION_NORTHWEST:
3274     case OB_DIRECTION_SOUTHWEST:
3275         /* not implemented */
3276     default:
3277         g_assert_not_reached();
3278     }
3279     return dest;
3280 }
3281
3282 ObClient* client_under_pointer()
3283 {
3284     int x, y;
3285     GList *it;
3286     ObClient *ret = NULL;
3287
3288     if (screen_pointer_pos(&x, &y)) {
3289         for (it = stacking_list; it != NULL; it = it->next) {
3290             if (WINDOW_IS_CLIENT(it->data)) {
3291                 ObClient *c = WINDOW_AS_CLIENT(it->data);
3292                 if (c->frame->visible &&
3293                     RECT_CONTAINS(c->frame->area, x, y)) {
3294                     ret = c;
3295                     break;
3296                 }
3297             }
3298         }
3299     }
3300     return ret;
3301 }
3302
3303 gboolean client_has_group_siblings(ObClient *self)
3304 {
3305     return self->group && self->group->members->next;
3306 }