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