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