openbox/client.c

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