2f9cfb8f564c10127c5df34716885132a6bb8510
[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_new(ClientCallback, 1);
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_free(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_new0(ObClient, 1);
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_free(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_free(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_new0(ObClient, 1);
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_free(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_free(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_free(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))
3572             screen_update_areas();
3573         else
3574             /* the new desktop's geometry may be different, so we may need to
3575                resize, for example if we are maximized */
3576             client_reconfigure(self, FALSE);
3577
3578         focus_cycle_addremove(self, FALSE);
3579     }
3580
3581     /* move all transients */
3582     for (it = self->transients; it; it = g_slist_next(it))
3583         if (it->data != self)
3584             if (client_is_direct_child(self, it->data))
3585                 client_set_desktop_recursive(it->data, target,
3586                                              donthide, dontraise);
3587 }
3588
3589 void client_set_desktop(ObClient *self, guint target,
3590                         gboolean donthide, gboolean dontraise)
3591 {
3592     self = client_search_top_direct_parent(self);
3593     client_set_desktop_recursive(self, target, donthide, dontraise);
3594
3595     focus_cycle_addremove(NULL, TRUE);
3596 }
3597
3598 gboolean client_is_direct_child(ObClient *parent, ObClient *child)
3599 {
3600     while (child != parent && (child = client_direct_parent(child)));
3601     return child == parent;
3602 }
3603
3604 ObClient *client_search_modal_child(ObClient *self)
3605 {
3606     GSList *it;
3607     ObClient *ret;
3608
3609     for (it = self->transients; it; it = g_slist_next(it)) {
3610         ObClient *c = it->data;
3611         if ((ret = client_search_modal_child(c))) return ret;
3612         if (c->modal) return c;
3613     }
3614     return NULL;
3615 }
3616
3617 static gboolean client_validate_unmap(ObClient *self, int n)
3618 {
3619     XEvent e;
3620     gboolean ret = TRUE;
3621
3622     if (XCheckTypedWindowEvent(obt_display, self->window, UnmapNotify, &e)) {
3623         if (n < self->ignore_unmaps) // ignore this one, but look for more
3624             ret = client_validate_unmap(self, n+1);
3625         else
3626             ret = FALSE; // the window is going to become unmanaged
3627
3628         /* put them back on the event stack so they end up in the same order */
3629         XPutBackEvent(obt_display, &e);
3630     }
3631
3632     return ret;
3633 }
3634
3635 gboolean client_validate(ObClient *self)
3636 {
3637     XEvent e;
3638
3639     XSync(obt_display, FALSE); /* get all events on the server */
3640
3641     if (XCheckTypedWindowEvent(obt_display, self->window, DestroyNotify, &e)) {
3642         XPutBackEvent(obt_display, &e);
3643         return FALSE;
3644     }
3645
3646     if (!client_validate_unmap(self, 0))
3647         return FALSE;
3648
3649     return TRUE;
3650 }
3651
3652 void client_set_wm_state(ObClient *self, glong state)
3653 {
3654     if (state == self->wmstate) return; /* no change */
3655
3656     switch (state) {
3657     case IconicState:
3658         client_iconify(self, TRUE, TRUE, FALSE);
3659         break;
3660     case NormalState:
3661         client_iconify(self, FALSE, TRUE, FALSE);
3662         break;
3663     }
3664 }
3665
3666 void client_set_state(ObClient *self, Atom action, glong data1, glong data2)
3667 {
3668     gboolean shaded = self->shaded;
3669     gboolean fullscreen = self->fullscreen;
3670     gboolean undecorated = self->undecorated;
3671     gboolean max_horz = self->max_horz;
3672     gboolean max_vert = self->max_vert;
3673     gboolean modal = self->modal;
3674     gboolean iconic = self->iconic;
3675     gboolean demands_attention = self->demands_attention;
3676     gboolean above = self->above;
3677     gboolean below = self->below;
3678     gint i;
3679     gboolean value;
3680
3681     if (!(action == OBT_PROP_ATOM(NET_WM_STATE_ADD) ||
3682           action == OBT_PROP_ATOM(NET_WM_STATE_REMOVE) ||
3683           action == OBT_PROP_ATOM(NET_WM_STATE_TOGGLE)))
3684         /* an invalid action was passed to the client message, ignore it */
3685         return;
3686
3687     for (i = 0; i < 2; ++i) {
3688         Atom state = i == 0 ? data1 : data2;
3689
3690         if (!state) continue;
3691
3692         /* if toggling, then pick whether we're adding or removing */
3693         if (action == OBT_PROP_ATOM(NET_WM_STATE_TOGGLE)) {
3694             if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL))
3695                 value = modal;
3696             else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT))
3697                 value = self->max_vert;
3698             else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ))
3699                 value = self->max_horz;
3700             else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED))
3701                 value = shaded;
3702             else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR))
3703                 value = self->skip_taskbar;
3704             else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER))
3705                 value = self->skip_pager;
3706             else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN))
3707                 value = self->iconic;
3708             else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN))
3709                 value = fullscreen;
3710             else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE))
3711                 value = self->above;
3712             else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW))
3713                 value = self->below;
3714             else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION))
3715                 value = self->demands_attention;
3716             else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED))
3717                 value = undecorated;
3718             else
3719                 g_assert_not_reached();
3720             action = value ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) :
3721                              OBT_PROP_ATOM(NET_WM_STATE_ADD);
3722         }
3723
3724         value = action == OBT_PROP_ATOM(NET_WM_STATE_ADD);
3725         if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL)) {
3726             modal = value;
3727         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT)) {
3728             max_vert = value;
3729         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ)) {
3730             max_horz = value;
3731         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED)) {
3732             shaded = value;
3733         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR)) {
3734             self->skip_taskbar = value;
3735         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER)) {
3736             self->skip_pager = value;
3737         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN)) {
3738             iconic = value;
3739         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN)) {
3740             fullscreen = value;
3741         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE)) {
3742             above = value;
3743             /* only unset below when setting above, otherwise you can't get to
3744                the normal layer */
3745             if (value)
3746                 below = FALSE;
3747         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW)) {
3748             /* and vice versa */
3749             if (value)
3750                 above = FALSE;
3751             below = value;
3752         } else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION)){
3753             demands_attention = value;
3754         } else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED)) {
3755             undecorated = value;
3756         }
3757     }
3758
3759     if (max_horz != self->max_horz || max_vert != self->max_vert) {
3760         if (max_horz != self->max_horz && max_vert != self->max_vert) {
3761             /* toggling both */
3762             if (max_horz == max_vert) { /* both going the same way */
3763                 client_maximize(self, max_horz, 0);
3764             } else {
3765                 client_maximize(self, max_horz, 1);
3766                 client_maximize(self, max_vert, 2);
3767             }
3768         } else {
3769             /* toggling one */
3770             if (max_horz != self->max_horz)
3771                 client_maximize(self, max_horz, 1);
3772             else
3773                 client_maximize(self, max_vert, 2);
3774         }
3775     }
3776     /* change fullscreen state before shading, as it will affect if the window
3777        can shade or not */
3778     if (fullscreen != self->fullscreen)
3779         client_fullscreen(self, fullscreen);
3780     if (shaded != self->shaded)
3781         client_shade(self, shaded);
3782     if (undecorated != self->undecorated)
3783         client_set_undecorated(self, undecorated);
3784     if (above != self->above || below != self->below) {
3785         self->above = above;
3786         self->below = below;
3787         client_calc_layer(self);
3788     }
3789
3790     if (modal != self->modal) {
3791         self->modal = modal;
3792         /* when a window changes modality, then its stacking order with its
3793            transients needs to change */
3794         stacking_raise(CLIENT_AS_WINDOW(self));
3795
3796         /* it also may get focused. if something is focused that shouldn't
3797            be focused anymore, then move the focus */
3798         if (focus_client && client_focus_target(focus_client) != focus_client)
3799             client_focus(focus_client);
3800     }
3801
3802     if (iconic != self->iconic)
3803         client_iconify(self, iconic, FALSE, FALSE);
3804
3805     if (demands_attention != self->demands_attention)
3806         client_hilite(self, demands_attention);
3807
3808     client_change_state(self); /* change the hint to reflect these changes */
3809
3810     focus_cycle_addremove(self, TRUE);
3811 }
3812
3813 ObClient *client_focus_target(ObClient *self)
3814 {
3815     ObClient *child = NULL;
3816
3817     child = client_search_modal_child(self);
3818     if (child) return child;
3819     return self;
3820 }
3821
3822 gboolean client_can_focus(ObClient *self)
3823 {
3824     /* choose the correct target */
3825     self = client_focus_target(self);
3826
3827     if (!self->frame->visible)
3828         return FALSE;
3829
3830     if (!(self->can_focus || self->focus_notify))
3831         return FALSE;
3832
3833     return TRUE;
3834 }
3835
3836 gboolean client_focus(ObClient *self)
3837 {
3838     /* we might not focus this window, so if we have modal children which would
3839        be focused instead, bring them to this desktop */
3840     client_bring_modal_windows(self);
3841
3842     /* choose the correct target */
3843     self = client_focus_target(self);
3844
3845     if (!client_can_focus(self)) {
3846         ob_debug_type(OB_DEBUG_FOCUS,
3847                       "Client %s can't be focused", self->title);
3848         return FALSE;
3849     }
3850
3851     ob_debug_type(OB_DEBUG_FOCUS,
3852                   "Focusing client \"%s\" (0x%x) at time %u",
3853                   self->title, self->window, event_curtime);
3854
3855     /* if using focus_delay, stop the timer now so that focus doesn't
3856        go moving on us */
3857     event_halt_focus_delay();
3858
3859     obt_display_ignore_errors(TRUE);
3860
3861     if (self->can_focus) {
3862         /* This can cause a BadMatch error with CurrentTime, or if an app
3863            passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3864         XSetInputFocus(obt_display, self->window, RevertToPointerRoot,
3865                        event_curtime);
3866     }
3867
3868     if (self->focus_notify) {
3869         XEvent ce;
3870         ce.xclient.type = ClientMessage;
3871         ce.xclient.message_type = OBT_PROP_ATOM(WM_PROTOCOLS);
3872         ce.xclient.display = obt_display;
3873         ce.xclient.window = self->window;
3874         ce.xclient.format = 32;
3875         ce.xclient.data.l[0] = OBT_PROP_ATOM(WM_TAKE_FOCUS);
3876         ce.xclient.data.l[1] = event_curtime;
3877         ce.xclient.data.l[2] = 0l;
3878         ce.xclient.data.l[3] = 0l;
3879         ce.xclient.data.l[4] = 0l;
3880         XSendEvent(obt_display, self->window, FALSE, NoEventMask, &ce);
3881     }
3882
3883     obt_display_ignore_errors(FALSE);
3884
3885     ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d",
3886                   obt_display_error_occured);
3887     return !obt_display_error_occured;
3888 }
3889
3890 static void client_present(ObClient *self, gboolean here, gboolean raise,
3891                            gboolean unshade)
3892 {
3893     if (client_normal(self) && screen_showing_desktop)
3894         screen_show_desktop(FALSE, self);
3895     if (self->iconic)
3896         client_iconify(self, FALSE, here, FALSE);
3897     if (self->desktop != DESKTOP_ALL &&
3898         self->desktop != screen_desktop)
3899     {
3900         if (here)
3901             client_set_desktop(self, screen_desktop, FALSE, TRUE);
3902         else
3903             screen_set_desktop(self->desktop, FALSE);
3904     } else if (!self->frame->visible)
3905         /* if its not visible for other reasons, then don't mess
3906            with it */
3907         return;
3908     if (self->shaded && unshade)
3909         client_shade(self, FALSE);
3910     if (raise)
3911         stacking_raise(CLIENT_AS_WINDOW(self));
3912
3913     client_focus(self);
3914 }
3915
3916 /* this function exists to map to the net_active_window message in the ewmh */
3917 void client_activate(ObClient *self, gboolean desktop,
3918                      gboolean here, gboolean raise,
3919                      gboolean unshade, gboolean user)
3920 {
3921     if ((user && (desktop ||
3922                   self->desktop == DESKTOP_ALL ||
3923                   self->desktop == screen_desktop)) ||
3924         client_can_steal_focus(self, event_curtime, CurrentTime))
3925     {
3926         client_present(self, here, raise, unshade);
3927     }
3928     else
3929         client_hilite(self, TRUE);
3930 }
3931
3932 static void client_bring_windows_recursive(ObClient *self,
3933                                            guint desktop,
3934                                            gboolean helpers,
3935                                            gboolean modals,
3936                                            gboolean iconic)
3937 {
3938     GSList *it;
3939
3940     for (it = self->transients; it; it = g_slist_next(it))
3941         client_bring_windows_recursive(it->data, desktop,
3942                                        helpers, modals, iconic);
3943
3944     if (((helpers && client_helper(self)) ||
3945          (modals && self->modal)) &&
3946         ((self->desktop != desktop && self->desktop != DESKTOP_ALL) ||
3947          (iconic && self->iconic)))
3948     {
3949         if (iconic && self->iconic)
3950             client_iconify(self, FALSE, TRUE, FALSE);
3951         else
3952             client_set_desktop(self, desktop, FALSE, FALSE);
3953     }
3954 }
3955
3956 void client_bring_helper_windows(ObClient *self)
3957 {
3958     client_bring_windows_recursive(self, self->desktop, TRUE, FALSE, FALSE);
3959 }
3960
3961 void client_bring_modal_windows(ObClient *self)
3962 {
3963     client_bring_windows_recursive(self, self->desktop, FALSE, TRUE, TRUE);
3964 }
3965
3966 gboolean client_focused(ObClient *self)
3967 {
3968     return self == focus_client;
3969 }
3970
3971 RrImage* client_icon(ObClient *self)
3972 {
3973     RrImage *ret = NULL;
3974
3975     if (self->icon_set)
3976         ret = self->icon_set;
3977     else if (self->parents) {
3978         GSList *it;
3979         for (it = self->parents; it && !ret; it = g_slist_next(it))
3980             ret = client_icon(it->data);
3981     }
3982     if (!ret)
3983         ret = client_default_icon;
3984     return ret;
3985 }
3986
3987 void client_set_layer(ObClient *self, gint layer)
3988 {
3989     if (layer < 0) {
3990         self->below = TRUE;
3991         self->above = FALSE;
3992     } else if (layer == 0) {
3993         self->below = self->above = FALSE;
3994     } else {
3995         self->below = FALSE;
3996         self->above = TRUE;
3997     }
3998     client_calc_layer(self);
3999     client_change_state(self); /* reflect this in the state hints */
4000 }
4001
4002 void client_set_undecorated(ObClient *self, gboolean undecorated)
4003 {
4004     if (self->undecorated != undecorated &&
4005         /* don't let it undecorate if the function is missing, but let
4006            it redecorate */
4007         (self->functions & OB_CLIENT_FUNC_UNDECORATE || !undecorated))
4008     {
4009         self->undecorated = undecorated;
4010         client_setup_decor_and_functions(self, TRUE);
4011         client_change_state(self); /* reflect this in the state hints */
4012     }
4013 }
4014
4015 guint client_monitor(ObClient *self)
4016 {
4017     return screen_find_monitor(&self->frame->area);
4018 }
4019
4020 ObClient *client_direct_parent(ObClient *self)
4021 {
4022     if (!self->parents) return NULL;
4023     if (self->transient_for_group) return NULL;
4024     return self->parents->data;
4025 }
4026
4027 ObClient *client_search_top_direct_parent(ObClient *self)
4028 {
4029     ObClient *p;
4030     while ((p = client_direct_parent(self))) self = p;
4031     return self;
4032 }
4033
4034 static GSList *client_search_all_top_parents_internal(ObClient *self,
4035                                                       gboolean bylayer,
4036                                                       ObStackingLayer layer)
4037 {
4038     GSList *ret;
4039     ObClient *p;
4040
4041     /* move up the direct transient chain as far as possible */
4042     while ((p = client_direct_parent(self)) &&
4043            (!bylayer || p->layer == layer))
4044         self = p;
4045
4046     if (!self->parents)
4047         ret = g_slist_prepend(NULL, self);
4048     else
4049         ret = g_slist_copy(self->parents);
4050
4051     return ret;
4052 }
4053
4054 GSList *client_search_all_top_parents(ObClient *self)
4055 {
4056     return client_search_all_top_parents_internal(self, FALSE, 0);
4057 }
4058
4059 GSList *client_search_all_top_parents_layer(ObClient *self)
4060 {
4061     return client_search_all_top_parents_internal(self, TRUE, self->layer);
4062 }
4063
4064 ObClient *client_search_focus_parent(ObClient *self)
4065 {
4066     GSList *it;
4067
4068     for (it = self->parents; it; it = g_slist_next(it))
4069         if (client_focused(it->data)) return it->data;
4070
4071     return NULL;
4072 }
4073
4074 ObClient *client_search_focus_parent_full(ObClient *self)
4075 {
4076     GSList *it;
4077     ObClient *ret = NULL;
4078
4079     for (it = self->parents; it; it = g_slist_next(it)) {
4080         if (client_focused(it->data))
4081             ret = it->data;
4082         else
4083             ret = client_search_focus_parent_full(it->data);
4084         if (ret) break;
4085     }
4086     return ret;
4087 }
4088
4089 ObClient *client_search_parent(ObClient *self, ObClient *search)
4090 {
4091     GSList *it;
4092
4093     for (it = self->parents; it; it = g_slist_next(it))
4094         if (it->data == search) return search;
4095
4096     return NULL;
4097 }
4098
4099 ObClient *client_search_transient(ObClient *self, ObClient *search)
4100 {
4101     GSList *sit;
4102
4103     for (sit = self->transients; sit; sit = g_slist_next(sit)) {
4104         if (sit->data == search)
4105             return search;
4106         if (client_search_transient(sit->data, search))
4107             return search;
4108     }
4109     return NULL;
4110 }
4111
4112 static void detect_edge(Rect area, ObDirection dir,
4113                         gint my_head, gint my_size,
4114                         gint my_edge_start, gint my_edge_size,
4115                         gint *dest, gboolean *near_edge)
4116 {
4117     gint edge_start, edge_size, head, tail;
4118     gboolean skip_head = FALSE, skip_tail = FALSE;
4119
4120     switch (dir) {
4121         case OB_DIRECTION_NORTH:
4122         case OB_DIRECTION_SOUTH:
4123             edge_start = area.x;
4124             edge_size = area.width;
4125             break;
4126         case OB_DIRECTION_EAST:
4127         case OB_DIRECTION_WEST:
4128             edge_start = area.y;
4129             edge_size = area.height;
4130             break;
4131         default:
4132             g_assert_not_reached();
4133     }
4134
4135     /* do we collide with this window? */
4136     if (!RANGES_INTERSECT(my_edge_start, my_edge_size,
4137                 edge_start, edge_size))
4138         return;
4139
4140     switch (dir) {
4141         case OB_DIRECTION_NORTH:
4142             head = RECT_BOTTOM(area);
4143             tail = RECT_TOP(area);
4144             break;
4145         case OB_DIRECTION_SOUTH:
4146             head = RECT_TOP(area);
4147             tail = RECT_BOTTOM(area);
4148             break;
4149         case OB_DIRECTION_WEST:
4150             head = RECT_RIGHT(area);
4151             tail = RECT_LEFT(area);
4152             break;
4153         case OB_DIRECTION_EAST:
4154             head = RECT_LEFT(area);
4155             tail = RECT_RIGHT(area);
4156             break;
4157         default:
4158             g_assert_not_reached();
4159     }
4160     switch (dir) {
4161         case OB_DIRECTION_NORTH:
4162         case OB_DIRECTION_WEST:
4163             /* check if our window is past the head of this window */
4164             if (my_head <= head + 1)
4165                 skip_head = TRUE;
4166             /* check if our window's tail is past the tail of this window */
4167             if (my_head + my_size - 1 <= tail)
4168                 skip_tail = TRUE;
4169             /* check if the head of this window is closer than the previously
4170                chosen edge (take into account that the previously chosen
4171                edge might have been a tail, not a head) */
4172             if (head + (*near_edge ? 0 : my_size) <= *dest)
4173                 skip_head = TRUE;
4174             /* check if the tail of this window is closer than the previously
4175                chosen edge (take into account that the previously chosen
4176                edge might have been a head, not a tail) */
4177             if (tail - (!*near_edge ? 0 : my_size) <= *dest)
4178                 skip_tail = TRUE;
4179             break;
4180         case OB_DIRECTION_SOUTH:
4181         case OB_DIRECTION_EAST:
4182             /* check if our window is past the head of this window */
4183             if (my_head >= head - 1)
4184                 skip_head = TRUE;
4185             /* check if our window's tail is past the tail of this window */
4186             if (my_head - my_size + 1 >= tail)
4187                 skip_tail = TRUE;
4188             /* check if the head of this window is closer than the previously
4189                chosen edge (take into account that the previously chosen
4190                edge might have been a tail, not a head) */
4191             if (head - (*near_edge ? 0 : my_size) >= *dest)
4192                 skip_head = TRUE;
4193             /* check if the tail of this window is closer than the previously
4194                chosen edge (take into account that the previously chosen
4195                edge might have been a head, not a tail) */
4196             if (tail + (!*near_edge ? 0 : my_size) >= *dest)
4197                 skip_tail = TRUE;
4198             break;
4199         default:
4200             g_assert_not_reached();
4201     }
4202
4203     ob_debug("my head %d size %d", my_head, my_size);
4204     ob_debug("head %d tail %d dest %d", head, tail, *dest);
4205     if (!skip_head) {
4206         ob_debug("using near edge %d", head);
4207         *dest = head;
4208         *near_edge = TRUE;
4209     }
4210     else if (!skip_tail) {
4211         ob_debug("using far edge %d", tail);
4212         *dest = tail;
4213         *near_edge = FALSE;
4214     }
4215 }
4216
4217 void client_find_edge_directional(ObClient *self, ObDirection dir,
4218                                   gint my_head, gint my_size,
4219                                   gint my_edge_start, gint my_edge_size,
4220                                   gint *dest, gboolean *near_edge)
4221 {
4222     GList *it;
4223     Rect *a;
4224     Rect dock_area;
4225     gint edge;
4226     guint i;
4227