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