openbox/client.c

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