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