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