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