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