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