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