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