Don't hilite new windows when we're restoring them from a saved session.
[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_colormap(ObClient *self);
84 static void client_set_desktop_recursive(ObClient *self,
85                                          guint target,
86                                          gboolean donthide,
87                                          gboolean dontraise);
88 static void client_change_allowed_actions(ObClient *self);
89 static void client_change_state(ObClient *self);
90 static void client_change_wm_state(ObClient *self);
91 static void client_apply_startup_state(ObClient *self,
92                                        gint x, gint y, gint w, gint h);
93 static void client_restore_session_state(ObClient *self);
94 static gboolean client_restore_session_stacking(ObClient *self);
95 static ObAppSettings *client_get_settings_state(ObClient *self);
96 static void client_update_transient_tree(ObClient *self,
97                                          ObGroup *oldgroup, ObGroup *newgroup,
98                                          gboolean oldgtran, gboolean newgtran,
99                                          ObClient* oldparent,
100                                          ObClient *newparent);
101 static void client_present(ObClient *self, gboolean here, gboolean raise,
102                            gboolean unshade);
103 static GSList *client_search_all_top_parents_internal(ObClient *self,
104                                                       gboolean bylayer,
105                                                       ObStackingLayer layer);
106 static void client_call_notifies(ObClient *self, GSList *list);
107 static void client_ping_event(ObClient *self, gboolean dead);
108 static void client_prompt_kill(ObClient *self);
109 static gboolean client_can_steal_focus(ObClient *self, Time steal_time,
110                                        Time launch_time);
111
112 void client_startup(gboolean reconfig)
113 {
114     if ((client_default_icon = RrImageCacheFind(ob_rr_icons,
115                                                 ob_rr_theme->def_win_icon,
116                                                 ob_rr_theme->def_win_icon_w,
117                                                 ob_rr_theme->def_win_icon_h)))
118         RrImageRef(client_default_icon);
119     else {
120         client_default_icon = RrImageNew(ob_rr_icons);
121         RrImageAddPicture(client_default_icon,
122                           ob_rr_theme->def_win_icon,
123                           ob_rr_theme->def_win_icon_w,
124                           ob_rr_theme->def_win_icon_h);
125     }
126
127     if (reconfig) return;
128
129     client_set_list();
130 }
131
132 void client_shutdown(gboolean reconfig)
133 {
134     RrImageUnref(client_default_icon);
135     client_default_icon = NULL;
136
137     if (reconfig) return;
138 }
139
140 static void client_call_notifies(ObClient *self, GSList *list)
141 {
142     GSList *it;
143
144     for (it = list; it; it = g_slist_next(it)) {
145         ClientCallback *d = it->data;
146         d->func(self, d->data);
147     }
148 }
149
150 void client_add_destroy_notify(ObClientCallback func, gpointer data)
151 {
152     ClientCallback *d = g_new(ClientCallback, 1);
153     d->func = func;
154     d->data = data;
155     client_destroy_notifies = g_slist_prepend(client_destroy_notifies, d);
156 }
157
158 void client_remove_destroy_notify(ObClientCallback func)
159 {
160     GSList *it;
161
162     for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
163         ClientCallback *d = it->data;
164         if (d->func == func) {
165             g_free(d);
166             client_destroy_notifies =
167                 g_slist_delete_link(client_destroy_notifies, it);
168             break;
169         }
170     }
171 }
172
173 void client_set_list(void)
174 {
175     Window *windows, *win_it;
176     GList *it;
177     guint size = g_list_length(client_list);
178
179     /* create an array of the window ids */
180     if (size > 0) {
181         windows = g_new(Window, size);
182         win_it = windows;
183         for (it = client_list; it; it = g_list_next(it), ++win_it)
184             *win_it = ((ObClient*)it->data)->window;
185     } else
186         windows = NULL;
187
188     PROP_SETA32(RootWindow(ob_display, ob_screen),
189                 net_client_list, window, (gulong*)windows, size);
190
191     if (windows)
192         g_free(windows);
193
194     stacking_set_list();
195 }
196
197 void client_manage_all(void)
198 {
199     guint i, j, nchild;
200     Window w, *children;
201     XWMHints *wmhints;
202     XWindowAttributes attrib;
203
204     XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
205                &w, &w, &children, &nchild);
206
207     /* remove all icon windows from the list */
208     for (i = 0; i < nchild; i++) {
209         if (children[i] == None) continue;
210         wmhints = XGetWMHints(ob_display, children[i]);
211         if (wmhints) {
212             if ((wmhints->flags & IconWindowHint) &&
213                 (wmhints->icon_window != children[i]))
214                 for (j = 0; j < nchild; j++)
215                     if (children[j] == wmhints->icon_window) {
216                         children[j] = None;
217                         break;
218                     }
219             XFree(wmhints);
220         }
221     }
222
223     /* manage windows in reverse order from how they were originally mapped.
224        this is an attempt to manage children windows before their parents, so
225        that when the parent is mapped, it can find the child */
226     for (i = 0; i < nchild; ++i) {
227         if (children[i] == None)
228             continue;
229         if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
230             if (attrib.override_redirect) continue;
231
232             if (attrib.map_state != IsUnmapped)
233                 client_manage(children[i], NULL);
234         }
235     }
236     XFree(children);
237 }
238
239 void client_manage(Window window, ObPrompt *prompt)
240 {
241     ObClient *self;
242     XEvent e;
243     XWindowAttributes attrib;
244     XSetWindowAttributes attrib_set;
245     XWMHints *wmhint;
246     gboolean activate = FALSE;
247     ObAppSettings *settings;
248     gboolean transient = FALSE;
249     Rect place, *monitor;
250     Time launch_time, map_time;
251     guint32 user_time;
252
253     grab_server(TRUE);
254
255     /* check if it has already been unmapped by the time we started
256        mapping. the grab does a sync so we don't have to here */
257     if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
258         XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e))
259     {
260         XPutBackEvent(ob_display, &e);
261
262         ob_debug("Trying to manage unmapped window. Aborting that.\n");
263         grab_server(FALSE);
264         return; /* don't manage it */
265     }
266
267     /* make sure it isn't an override-redirect window */
268     if (!XGetWindowAttributes(ob_display, window, &attrib) ||
269         attrib.override_redirect)
270     {
271         grab_server(FALSE);
272         return; /* don't manage it */
273     }
274
275     /* is the window a docking app */
276     if ((wmhint = XGetWMHints(ob_display, window))) {
277         if ((wmhint->flags & StateHint) &&
278             wmhint->initial_state == WithdrawnState)
279         {
280             dock_add(window, wmhint);
281             grab_server(FALSE);
282             XFree(wmhint);
283             return;
284         }
285         XFree(wmhint);
286     }
287
288     ob_debug("Managing window: 0x%lx\n", window);
289
290     map_time = event_get_server_time();
291
292     /* choose the events we want to receive on the CLIENT window
293        (ObPrompt windows can request events too) */
294     attrib_set.event_mask = CLIENT_EVENTMASK |
295         (prompt ? prompt->event_mask : 0);
296     attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
297     XChangeWindowAttributes(ob_display, window,
298                             CWEventMask|CWDontPropagate, &attrib_set);
299
300     /* create the ObClient struct, and populate it from the hints on the
301        window */
302     self = g_new0(ObClient, 1);
303     self->obwin.type = Window_Client;
304     self->window = window;
305     self->prompt = prompt;
306
307     /* non-zero defaults */
308     self->wmstate = WithdrawnState; /* make sure it gets updated first time */
309     self->gravity = NorthWestGravity;
310     self->desktop = screen_num_desktops; /* always an invalid value */
311
312     /* get all the stuff off the window */
313     client_get_all(self, TRUE);
314
315     ob_debug("Window type: %d\n", self->type);
316     ob_debug("Window group: 0x%x\n", self->group?self->group->leader:0);
317     ob_debug("Window name: %s class: %s role: %s\n", self->name, self->class, self->role);
318
319     /* per-app settings override stuff from client_get_all, and return the
320        settings for other uses too. the returned settings is a shallow copy,
321        that needs to be freed with g_free(). */
322     settings = client_get_settings_state(self);
323
324     /* now we have all of the window's information so we can set this up.
325        do this before creating the frame, so it can tell that we are still
326        mapping and doesn't go applying things right away */
327     client_setup_decor_and_functions(self, FALSE);
328
329     /* specify that if we exit, the window should not be destroyed and
330        should be reparented back to root automatically, unless we are managing
331        an internal ObPrompt window  */
332     if (!self->prompt)
333         XChangeSaveSet(ob_display, window, SetModeInsert);
334
335     /* create the decoration frame for the client window */
336     self->frame = frame_new(self);
337
338     frame_grab_client(self->frame);
339
340     /* we've grabbed everything and set everything that we need to at mapping
341        time now */
342     grab_server(FALSE);
343
344     /* the session should get the last say though */
345     client_restore_session_state(self);
346
347     /* tell startup notification that this app started */
348     launch_time = sn_app_started(self->startup_id, self->class, self->name);
349
350     if (!PROP_GET32(self->window, net_wm_user_time, cardinal, &user_time))
351         user_time = map_time;
352
353     /* do this after we have a frame.. it uses the frame to help determine the
354        WM_STATE to apply. */
355     client_change_state(self);
356
357     /* add ourselves to the focus order */
358     focus_order_add_new(self);
359
360     /* do this to add ourselves to the stacking list in a non-intrusive way */
361     client_calc_layer(self);
362
363     /* focus the new window? */
364     if (ob_state() != OB_STATE_STARTING &&
365         (!self->session || self->session->focused) &&
366         /* this means focus=true for window is same as config_focus_new=true */
367         ((config_focus_new || (settings && settings->focus == 1)) ||
368          client_search_focus_tree_full(self)) &&
369         /* NET_WM_USER_TIME 0 when mapping means don't focus */
370         (user_time != 0) &&
371         /* this checks for focus=false for the window */
372         (!settings || settings->focus != 0) &&
373         focus_valid_target(self, FALSE, FALSE, TRUE, FALSE, FALSE))
374     {
375         activate = TRUE;
376     }
377
378     /* remove the client's border */
379     XSetWindowBorderWidth(ob_display, self->window, 0);
380
381     /* adjust the frame to the client's size before showing or placing
382        the window */
383     frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
384     frame_adjust_client_area(self->frame);
385
386     /* where the frame was placed is where the window was originally */
387     place = self->area;
388     monitor = screen_physical_area_monitor(screen_find_monitor(&place));
389
390     /* figure out placement for the window if the window is new */
391     if (ob_state() == OB_STATE_RUNNING) {
392         ob_debug("Positioned: %s @ %d %d\n",
393                  (!self->positioned ? "no" :
394                   (self->positioned == PPosition ? "program specified" :
395                    (self->positioned == USPosition ? "user specified" :
396                     (self->positioned == (PPosition | USPosition) ?
397                      "program + user specified" :
398                      "BADNESS !?")))), place.x, place.y);
399
400         ob_debug("Sized: %s @ %d %d\n",
401                  (!self->sized ? "no" :
402                   (self->sized == PSize ? "program specified" :
403                    (self->sized == USSize ? "user specified" :
404                     (self->sized == (PSize | USSize) ?
405                      "program + user specified" :
406                      "BADNESS !?")))), place.width, place.height);
407
408         /* splash screens are also returned as TRUE for transient,
409            and so will be forced on screen below */
410         transient = place_client(self, &place.x, &place.y, settings);
411
412         /* make sure the window is visible. */
413         client_find_onscreen(self, &place.x, &place.y,
414                              place.width, place.height,
415                              /* non-normal clients has less rules, and
416                                 windows that are being restored from a
417                                 session do also. we can assume you want
418                                 it back where you saved it. Clients saying
419                                 they placed themselves are subjected to
420                                 harder rules, ones that are placed by
421                                 place.c or by the user are allowed partially
422                                 off-screen and on xinerama divides (ie,
423                                 it is up to the placement routines to avoid
424                                 the xinerama divides)
425
426                                 splash screens get "transient" set to TRUE by
427                                 the place_client call
428                              */
429                              ob_state() == OB_STATE_RUNNING &&
430                              (transient ||
431                               (!((self->positioned & USPosition) ||
432                                  (settings && settings->pos_given)) &&
433                                client_normal(self) &&
434                                !self->session &&
435                                /* don't move oldschool fullscreen windows to
436                                   fit inside the struts (fixes Acroread, which
437                                   makes its fullscreen window fit the screen
438                                   but it is not USSize'd or USPosition'd) */
439                                !(self->decorations == 0 &&
440                                  RECT_EQUAL(place, *monitor)))));
441     }
442
443     /* if the window isn't user-sized, then make it fit inside
444        the visible screen area on its monitor. Use basically the same rules
445        for forcing the window on screen in the client_find_onscreen call.
446
447        do this after place_client, it chooses the monitor!
448
449        splash screens get "transient" set to TRUE by
450        the place_client call
451     */
452     if (ob_state() == OB_STATE_RUNNING &&
453         (transient ||
454          (!(self->sized & USSize || self->positioned & USPosition) &&
455           client_normal(self) &&
456           !self->session &&
457           /* don't shrink oldschool fullscreen windows to fit inside the
458              struts (fixes Acroread, which makes its fullscreen window
459              fit the screen but it is not USSize'd or USPosition'd) */
460           !(self->decorations == 0 && RECT_EQUAL(place, *monitor)))))
461     {
462         Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &place);
463
464         /* get the size of the frame */
465         place.width += self->frame->size.left + self->frame->size.right;
466         place.height += self->frame->size.top + self->frame->size.bottom;
467
468         /* fit the window inside the area */
469         place.width = MIN(place.width, a->width);
470         place.height = MIN(place.height, a->height);
471
472         ob_debug("setting window size to %dx%d\n", place.width, place.height);
473
474         /* get the size of the client back */
475         place.width -= self->frame->size.left + self->frame->size.right;
476         place.height -= self->frame->size.top + self->frame->size.bottom;
477
478         g_free(a);
479     }
480
481     ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
482              "some restrictions may apply\n",
483              self->window, place.x, place.y, place.width, place.height);
484     if (self->session)
485         ob_debug("  but session requested %d, %d  %d x %d instead, "
486                  "overriding\n",
487                  self->session->x, self->session->y,
488                  self->session->w, self->session->h);
489
490     /* do this after the window is placed, so the premax/prefullscreen numbers
491        won't be all wacko!!
492
493        this also places the window
494     */
495     client_apply_startup_state(self, place.x, place.y,
496                                place.width, place.height);
497
498     g_free(monitor);
499     monitor = NULL;
500
501     ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s\n",
502                   activate ? "yes" : "no");
503     if (activate) {
504         activate = client_can_steal_focus(self, map_time, launch_time);
505
506         if (!activate) {
507             /* if the client isn't stealing focus, then hilite it so the user
508                knows it is there, but don't do this if we're restoring from a
509                session */
510             if (!client_restore_session_stacking(self))
511                 client_hilite(self, TRUE);
512         }
513     }
514     else {
515         /* This may look rather odd. Well it's because new windows are added
516            to the stacking order non-intrusively. If we're not going to focus
517            the new window or hilite it, then we raise it to the top. This will
518            take affect for things that don't get focused like splash screens.
519            Also if you don't have focus_new enabled, then it's going to get
520            raised to the top. Legacy begets legacy I guess?
521         */
522         if (!client_restore_session_stacking(self))
523             stacking_raise(CLIENT_AS_WINDOW(self));
524     }
525
526     mouse_grab_for_client(self, TRUE);
527
528     /* this has to happen before we try focus the window, but we want it to
529        happen after the client's stacking has been determined or it looks bad
530     */
531     {
532         gulong ignore_start;
533         if (!config_focus_under_mouse)
534             ignore_start = event_start_ignore_all_enters();
535
536         client_show(self);
537
538         if (!config_focus_under_mouse)
539             event_end_ignore_all_enters(ignore_start);
540     }
541
542     if (activate) {
543         gboolean stacked = client_restore_session_stacking(self);
544         client_present(self, FALSE, !stacked, TRUE);
545     }
546
547     /* add to client list/map */
548     client_list = g_list_append(client_list, self);
549     g_hash_table_insert(window_map, &self->window, self);
550
551     /* this has to happen after we're in the client_list */
552     if (STRUT_EXISTS(self->strut))
553         screen_update_areas();
554
555     /* update the list hints */
556     client_set_list();
557
558     /* free the ObAppSettings shallow copy */
559     g_free(settings);
560
561     ob_debug("Managed window 0x%lx plate 0x%x (%s)\n",
562              window, self->frame->window, self->class);
563
564     return;
565 }
566
567 ObClient *client_fake_manage(Window window)
568 {
569     ObClient *self;
570     ObAppSettings *settings;
571
572     ob_debug("Pretend-managing window: %lx\n", window);
573
574     /* do this minimal stuff to figure out the client's decorations */
575
576     self = g_new0(ObClient, 1);
577     self->window = window;
578
579     client_get_all(self, FALSE);
580     /* per-app settings override stuff, and return the settings for other
581        uses too. this returns a shallow copy that needs to be freed */
582     settings = client_get_settings_state(self);
583
584     client_setup_decor_and_functions(self, FALSE);
585
586     /* create the decoration frame for the client window and adjust its size */
587     self->frame = frame_new(self);
588     frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
589
590     ob_debug("gave extents left %d right %d top %d bottom %d\n",
591              self->frame->size.left, self->frame->size.right,
592              self->frame->size.top, self->frame->size.bottom);
593
594     /* free the ObAppSettings shallow copy */
595     g_free(settings);
596
597     return self;
598 }
599
600 void client_unmanage_all(void)
601 {
602     while (client_list)
603         client_unmanage(client_list->data);
604 }
605
606 void client_unmanage(ObClient *self)
607 {
608     GSList *it;
609     gulong ignore_start;
610
611     ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n",
612              self->window, self->frame->window,
613              self->class, self->title ? self->title : "");
614
615     g_assert(self != NULL);
616
617     /* we dont want events no more. do this before hiding the frame so we
618        don't generate more events */
619     XSelectInput(ob_display, self->window, NoEventMask);
620
621     /* ignore enter events from the unmap so it doesnt mess with the focus */
622     if (!config_focus_under_mouse)
623         ignore_start = event_start_ignore_all_enters();
624
625     frame_hide(self->frame);
626     /* flush to send the hide to the server quickly */
627     XFlush(ob_display);
628
629     if (!config_focus_under_mouse)
630         event_end_ignore_all_enters(ignore_start);
631
632     mouse_grab_for_client(self, FALSE);
633
634     /* remove the window from our save set, unless we are managing an internal
635        ObPrompt window */
636     if (!self->prompt)
637         XChangeSaveSet(ob_display, self->window, SetModeDelete);
638
639     /* update the focus lists */
640     focus_order_remove(self);
641     if (client_focused(self)) {
642         /* don't leave an invalid focus_client */
643         focus_client = NULL;
644     }
645
646     /* if we're prompting to kill the client, close that */
647     prompt_unref(self->kill_prompt);
648     self->kill_prompt = NULL;
649
650     client_list = g_list_remove(client_list, self);
651     stacking_remove(self);
652     g_hash_table_remove(window_map, &self->window);
653
654     /* once the client is out of the list, update the struts to remove its
655        influence */
656     if (STRUT_EXISTS(self->strut))
657         screen_update_areas();
658
659     client_call_notifies(self, client_destroy_notifies);
660
661     /* tell our parent(s) that we're gone */
662     for (it = self->parents; it; it = g_slist_next(it))
663         ((ObClient*)it->data)->transients =
664             g_slist_remove(((ObClient*)it->data)->transients,self);
665
666     /* tell our transients that we're gone */
667     for (it = self->transients; it; it = g_slist_next(it)) {
668         ((ObClient*)it->data)->parents =
669             g_slist_remove(((ObClient*)it->data)->parents, self);
670         /* we could be keeping our children in a higher layer */
671         client_calc_layer(it->data);
672     }
673
674     /* remove from its group */
675     if (self->group) {
676         group_remove(self->group, self);
677         self->group = NULL;
678     }
679
680     /* restore the window's original geometry so it is not lost */
681     {
682         Rect a;
683
684         a = self->area;
685
686         if (self->fullscreen)
687             a = self->pre_fullscreen_area;
688         else if (self->max_horz || self->max_vert) {
689             if (self->max_horz) {
690                 a.x = self->pre_max_area.x;
691                 a.width = self->pre_max_area.width;
692             }
693             if (self->max_vert) {
694                 a.y = self->pre_max_area.y;
695                 a.height = self->pre_max_area.height;
696             }
697         }
698
699         self->fullscreen = self->max_horz = self->max_vert = FALSE;
700         /* let it be moved and resized no matter what */
701         self->functions = OB_CLIENT_FUNC_MOVE | OB_CLIENT_FUNC_RESIZE;
702         self->decorations = 0; /* unmanaged windows have no decor */
703
704         /* give the client its border back */
705         XSetWindowBorderWidth(ob_display, self->window, self->border_width);
706
707         client_move_resize(self, a.x, a.y, a.width, a.height);
708     }
709
710     /* reparent the window out of the frame, and free the frame */
711     frame_release_client(self->frame);
712     frame_free(self->frame);
713     self->frame = NULL;
714
715     if (ob_state() != OB_STATE_EXITING) {
716         /* these values should not be persisted across a window
717            unmapping/mapping */
718         PROP_ERASE(self->window, net_wm_desktop);
719         PROP_ERASE(self->window, net_wm_state);
720         PROP_ERASE(self->window, wm_state);
721     } else {
722         /* if we're left in an unmapped state, the client wont be mapped.
723            this is bad, since we will no longer be managing the window on
724            restart */
725         XMapWindow(ob_display, self->window);
726     }
727
728     /* these should not be left on the window ever.  other window managers
729        don't necessarily use them and it will mess them up (like compiz) */
730     PROP_ERASE(self->window, net_wm_visible_name);
731     PROP_ERASE(self->window, net_wm_visible_icon_name);
732
733     /* update the list hints */
734     client_set_list();
735
736     ob_debug("Unmanaged window 0x%lx\n", self->window);
737
738     /* free all data allocated in the client struct */
739     RrImageUnref(self->icon_set);
740     g_slist_free(self->transients);
741     g_free(self->startup_id);
742     g_free(self->wm_command);
743     g_free(self->title);
744     g_free(self->icon_title);
745     g_free(self->original_title);
746     g_free(self->name);
747     g_free(self->class);
748     g_free(self->role);
749     g_free(self->client_machine);
750     g_free(self->sm_client_id);
751     g_free(self);
752 }
753
754 void client_fake_unmanage(ObClient *self)
755 {
756     /* this is all that got allocated to get the decorations */
757
758     frame_free(self->frame);
759     g_free(self);
760 }
761
762 static gboolean client_can_steal_focus(ObClient *self, Time steal_time,
763                                        Time launch_time)
764 {
765     gboolean steal;
766     gboolean relative_focused;
767     gboolean parent_focused;
768
769     steal = TRUE;
770
771     parent_focused = (focus_client != NULL &&
772                       client_search_focus_parent(self));
773     relative_focused = (focus_client != NULL &&
774                         (client_search_focus_tree_full(self) != NULL ||
775                          client_search_focus_group_full(self) != NULL));
776
777     /* This is focus stealing prevention */
778     ob_debug_type(OB_DEBUG_FOCUS,
779                   "Want to focus new window 0x%x at time %u "
780                   "launched at %u (last user interaction time %u)\n",
781                   self->window, steal_time, launch_time,
782                   event_last_user_time);
783
784     /* if it's on another desktop */
785     if (!(self->desktop == screen_desktop ||
786           self->desktop == DESKTOP_ALL) &&
787         /* the timestamp is from before you changed desktops */
788         launch_time && screen_desktop_user_time &&
789         !event_time_after(launch_time, screen_desktop_user_time))
790     {
791         steal = FALSE;
792         ob_debug_type(OB_DEBUG_FOCUS,
793                       "Not focusing the window because its on another "
794                       "desktop\n");
795     }
796     /* If something is focused... */
797     else if (focus_client) {
798         /* If the user is working in another window right now, then don't
799            steal focus */
800         if (!parent_focused &&
801             event_last_user_time && launch_time &&
802             event_time_after(event_last_user_time, launch_time) &&
803             event_last_user_time != launch_time &&
804             event_time_after(event_last_user_time,
805                              steal_time - OB_EVENT_USER_TIME_DELAY))
806         {
807             steal = FALSE;
808             ob_debug_type(OB_DEBUG_FOCUS,
809                           "Not focusing the window because the user is "
810                           "working in another window that is not "
811                           "its parent\n");
812         }
813         /* If the new window is a transient (and its relatives aren't
814            focused) */
815         else if (client_has_parent(self) && !relative_focused) {
816             steal = FALSE;
817             ob_debug_type(OB_DEBUG_FOCUS,
818                           "Not focusing the window because it is a "
819                           "transient, and its relatives aren't focused\n");
820         }
821         /* Don't steal focus from globally active clients.
822            I stole this idea from KWin. It seems nice.
823         */
824         else if (!(focus_client->can_focus ||
825                    focus_client->focus_notify))
826         {
827             steal = FALSE;
828             ob_debug_type(OB_DEBUG_FOCUS,
829                           "Not focusing the window because a globally "
830                           "active client has focus\n");
831         }
832         /* Don't move focus if it's not going to go to this window
833            anyway */
834         else if (client_focus_target(self) != self) {
835             steal = FALSE;
836             ob_debug_type(OB_DEBUG_FOCUS,
837                           "Not focusing the window because another window "
838                           "would get the focus anyway\n");
839         }
840         /* Don't move focus if the window is not visible on the current
841            desktop and none of its relatives are focused */
842         else if (!(self->desktop == screen_desktop ||
843                    self->desktop == DESKTOP_ALL) &&
844                  !relative_focused)
845         {
846             steal = FALSE;
847             ob_debug_type(OB_DEBUG_FOCUS,
848                           "Not focusing the window because it is on "
849                           "another desktop and no relatives are focused ");
850         }
851     }
852
853     if (!steal)
854         ob_debug_type(OB_DEBUG_FOCUS,
855                       "Focus stealing prevention activated for %s at "
856                       "time %u (last user interaction time %u)\n",
857                       self->title, steal_time, event_last_user_time);
858     return steal;
859 }
860
861 /*! Returns a new structure containing the per-app settings for this client.
862   The returned structure needs to be freed with g_free. */
863 static ObAppSettings *client_get_settings_state(ObClient *self)
864 {
865     ObAppSettings *settings;
866     GSList *it;
867
868     settings = config_create_app_settings();
869
870     for (it = config_per_app_settings; it; it = g_slist_next(it)) {
871         ObAppSettings *app = it->data;
872         gboolean match = TRUE;
873
874         g_assert(app->name != NULL || app->class != NULL);
875
876         /* we know that either name or class is not NULL so it will have to
877            match to use the rule */
878         if (app->name &&
879             !g_pattern_match(app->name, strlen(self->name), self->name, NULL))
880             match = FALSE;
881         else if (app->class &&
882                  !g_pattern_match(app->class,
883                                   strlen(self->class), self->class, NULL))
884             match = FALSE;
885         else if (app->role &&
886                  !g_pattern_match(app->role,
887                                   strlen(self->role), self->role, NULL))
888             match = FALSE;
889         else if ((signed)app->type >= 0 && app->type != self->type)
890             match = FALSE;
891
892         if (match) {
893             ob_debug("Window matching: %s\n", app->name);
894
895             /* copy the settings to our struct, overriding the existing
896                settings if they are not defaults */
897             config_app_settings_copy_non_defaults(app, settings);
898         }
899     }
900
901     if (settings->shade != -1)
902         self->shaded = !!settings->shade;
903     if (settings->decor != -1)
904         self->undecorated = !settings->decor;
905     if (settings->iconic != -1)
906         self->iconic = !!settings->iconic;
907     if (settings->skip_pager != -1)
908         self->skip_pager = !!settings->skip_pager;
909     if (settings->skip_taskbar != -1)
910         self->skip_taskbar = !!settings->skip_taskbar;
911
912     if (settings->max_vert != -1)
913         self->max_vert = !!settings->max_vert;
914     if (settings->max_horz != -1)
915         self->max_horz = !!settings->max_horz;
916
917     if (settings->fullscreen != -1)
918         self->fullscreen = !!settings->fullscreen;
919
920     if (settings->desktop) {
921         if (settings->desktop == DESKTOP_ALL)
922             self->desktop = settings->desktop;
923         else if (settings->desktop > 0 &&
924                  settings->desktop <= screen_num_desktops)
925             self->desktop = settings->desktop - 1;
926     }
927
928     if (settings->layer == -1) {
929         self->below = TRUE;
930         self->above = FALSE;
931     }
932     else if (settings->layer == 0) {
933         self->below = FALSE;
934         self->above = FALSE;
935     }
936     else if (settings->layer == 1) {
937         self->below = FALSE;
938         self->above = TRUE;
939     }
940     return settings;
941 }
942
943 static void client_restore_session_state(ObClient *self)
944 {
945     GList *it;
946
947     ob_debug_type(OB_DEBUG_SM,
948                   "Restore session for client %s\n", self->title);
949
950     if (!(it = session_state_find(self))) {
951         ob_debug_type(OB_DEBUG_SM,
952                       "Session data not found for client %s\n", self->title);
953         return;
954     }
955
956     self->session = it->data;
957
958     ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s\n",
959                   self->title);
960
961     RECT_SET_POINT(self->area, self->session->x, self->session->y);
962     self->positioned = USPosition;
963     self->sized = USSize;
964     if (self->session->w > 0)
965         self->area.width = self->session->w;
966     if (self->session->h > 0)
967         self->area.height = self->session->h;
968     XResizeWindow(ob_display, self->window,
969                   self->area.width, self->area.height);
970
971     self->desktop = (self->session->desktop == DESKTOP_ALL ?
972                      self->session->desktop :
973                      MIN(screen_num_desktops - 1, self->session->desktop));
974     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
975
976     self->shaded = self->session->shaded;
977     self->iconic = self->session->iconic;
978     self->skip_pager = self->session->skip_pager;
979     self->skip_taskbar = self->session->skip_taskbar;
980     self->fullscreen = self->session->fullscreen;
981     self->above = self->session->above;
982     self->below = self->session->below;
983     self->max_horz = self->session->max_horz;
984     self->max_vert = self->session->max_vert;
985     self->undecorated = self->session->undecorated;
986 }
987
988 static gboolean client_restore_session_stacking(ObClient *self)
989 {
990     GList *it, *mypos;
991
992     if (!self->session) return FALSE;
993
994     mypos = g_list_find(session_saved_state, self->session);
995     if (!mypos) return FALSE;
996
997     /* start above me and look for the first client */
998     for (it = g_list_previous(mypos); it; it = g_list_previous(it)) {
999         GList *cit;
1000
1001         for (cit = client_list; cit; cit = g_list_next(cit)) {
1002             ObClient *c = cit->data;
1003             /* found a client that was in the session, so go below it */
1004             if (c->session == it->data) {
1005                 stacking_below(CLIENT_AS_WINDOW(self),
1006                                CLIENT_AS_WINDOW(cit->data));
1007                 return TRUE;
1008             }
1009         }
1010     }
1011     return FALSE;
1012 }
1013
1014 void client_move_onscreen(ObClient *self, gboolean rude)
1015 {
1016     gint x = self->area.x;
1017     gint y = self->area.y;
1018     if (client_find_onscreen(self, &x, &y,
1019                              self->area.width,
1020                              self->area.height, rude)) {
1021         client_move(self, x, y);
1022     }
1023 }
1024
1025 gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h,
1026                               gboolean rude)
1027 {
1028     gint ox = *x, oy = *y;
1029     gboolean rudel = rude, ruder = rude, rudet = rude, rudeb = rude;
1030     gint fw, fh;
1031     Rect desired;
1032     guint i;
1033     gboolean found_mon;
1034
1035     RECT_SET(desired, *x, *y, w, h);
1036     frame_rect_to_frame(self->frame, &desired);
1037
1038     /* get where the frame would be */
1039     frame_client_gravity(self->frame, x, y);
1040
1041     /* get the requested size of the window with decorations */
1042     fw = self->frame->size.left + w + self->frame->size.right;
1043     fh = self->frame->size.top + h + self->frame->size.bottom;
1044
1045     /* If rudeness wasn't requested, then still be rude in a given direction
1046        if the client is not moving, only resizing in that direction */
1047     if (!rude) {
1048         Point oldtl, oldtr, oldbl, oldbr;
1049         Point newtl, newtr, newbl, newbr;
1050         gboolean stationary_l, stationary_r, stationary_t, stationary_b;
1051
1052         POINT_SET(oldtl, self->frame->area.x, self->frame->area.y);
1053         POINT_SET(oldbr, self->frame->area.x + self->frame->area.width - 1,
1054                   self->frame->area.y + self->frame->area.height - 1);
1055         POINT_SET(oldtr, oldbr.x, oldtl.y);
1056         POINT_SET(oldbl, oldtl.x, oldbr.y);
1057
1058         POINT_SET(newtl, *x, *y);
1059         POINT_SET(newbr, *x + fw - 1, *y + fh - 1);
1060         POINT_SET(newtr, newbr.x, newtl.y);
1061         POINT_SET(newbl, newtl.x, newbr.y);
1062
1063         /* is it moving or just resizing from some corner? */
1064         stationary_l = oldtl.x == newtl.x;
1065         stationary_r = oldtr.x == newtr.x;
1066         stationary_t = oldtl.y == newtl.y;
1067         stationary_b = oldbl.y == newbl.y;
1068
1069         /* if left edge is growing and didnt move right edge */
1070         if (stationary_r && newtl.x < oldtl.x)
1071             rudel = TRUE;
1072         /* if right edge is growing and didnt move left edge */
1073         if (stationary_l && newtr.x > oldtr.x)
1074             ruder = TRUE;
1075         /* if top edge is growing and didnt move bottom edge */
1076         if (stationary_b && newtl.y < oldtl.y)
1077             rudet = TRUE;
1078         /* if bottom edge is growing and didnt move top edge */
1079         if (stationary_t && newbl.y > oldbl.y)
1080             rudeb = TRUE;
1081     }
1082
1083     /* we iterate through every monitor that the window is at least partially
1084        on, to make sure it is obeying the rules on them all
1085
1086        if the window does not appear on any monitors, then use the first one
1087     */
1088     found_mon = FALSE;
1089     for (i = 0; i < screen_num_monitors; ++i) {
1090         Rect *a;
1091
1092         if (!screen_physical_area_monitor_contains(i, &desired)) {
1093             if (i < screen_num_monitors - 1 || found_mon)
1094                 continue;
1095
1096             /* the window is not inside any monitor! so just use the first
1097                one */
1098             a = screen_area(self->desktop, 0, NULL);
1099         } else {
1100             found_mon = TRUE;
1101             a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &desired);
1102         }
1103
1104         /* This makes sure windows aren't entirely outside of the screen so you
1105            can't see them at all.
1106            It makes sure 10% of the window is on the screen at least. And don't
1107            let it move itself off the top of the screen, which would hide the
1108            titlebar on you. (The user can still do this if they want too, it's
1109            only limiting the application.
1110         */
1111         if (client_normal(self)) {
1112             if (!self->strut.right && *x + fw/10 >= a->x + a->width - 1)
1113                 *x = a->x + a->width - fw/10;
1114             if (!self->strut.bottom && *y + fh/10 >= a->y + a->height - 1)
1115                 *y = a->y + a->height - fh/10;
1116             if (!self->strut.left && *x + fw*9/10 - 1 < a->x)
1117                 *x = a->x - fw*9/10;
1118             if (!self->strut.top && *y + fh*9/10 - 1 < a->y)
1119                 *y = a->y - fh*9/10;
1120         }
1121
1122         /* This here doesn't let windows even a pixel outside the
1123            struts/screen. When called from client_manage, programs placing
1124            themselves are forced completely onscreen, while things like
1125            xterm -geometry resolution-width/2 will work fine. Trying to
1126            place it completely offscreen will be handled in the above code.
1127            Sorry for this confused comment, i am tired. */
1128         if (rudel && !self->strut.left && *x < a->x) *x = a->x;
1129         if (ruder && !self->strut.right && *x + fw > a->x + a->width)
1130             *x = a->x + MAX(0, a->width - fw);
1131
1132         if (rudet && !self->strut.top && *y < a->y) *y = a->y;
1133         if (rudeb && !self->strut.bottom && *y + fh > a->y + a->height)
1134             *y = a->y + MAX(0, a->height - fh);
1135
1136         g_free(a);
1137     }
1138
1139     /* get where the client should be */
1140     frame_frame_gravity(self->frame, x, y);
1141
1142     return ox != *x || oy != *y;
1143 }
1144
1145 static void client_get_all(ObClient *self, gboolean real)
1146 {
1147     /* this is needed for the frame to set itself up */
1148     client_get_area(self);
1149
1150     /* these things can change the decor and functions of the window */
1151
1152     client_get_mwm_hints(self);
1153     /* this can change the mwmhints for special cases */
1154     client_get_type_and_transientness(self);
1155     client_get_state(self);
1156     client_update_normal_hints(self);
1157
1158     /* get the session related properties, these can change decorations
1159        from per-app settings */
1160     client_get_session_ids(self);
1161
1162     /* now we got everything that can affect the decorations */
1163     if (!real)
1164         return;
1165
1166     /* get this early so we have it for debugging */
1167     client_update_title(self);
1168
1169     client_update_protocols(self);
1170
1171     client_update_wmhints(self);
1172     /* this may have already been called from client_update_wmhints */
1173     if (!self->parents && !self->transient_for_group)
1174         client_update_transient_for(self);
1175
1176     client_get_startup_id(self);
1177     client_get_desktop(self);/* uses transient data/group/startup id if a
1178                                 desktop is not specified */
1179     client_get_shaped(self);
1180
1181     {
1182         /* a couple type-based defaults for new windows */
1183
1184         /* this makes sure that these windows appear on all desktops */
1185         if (self->type == OB_CLIENT_TYPE_DESKTOP)
1186             self->desktop = DESKTOP_ALL;
1187     }
1188
1189 #ifdef SYNC
1190     client_update_sync_request_counter(self);
1191 #endif
1192
1193     client_get_colormap(self);
1194     client_update_strut(self);
1195     client_update_icons(self);
1196     client_update_icon_geometry(self);
1197 }
1198
1199 static void client_get_startup_id(ObClient *self)
1200 {
1201     if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id)))
1202         if (self->group)
1203             PROP_GETS(self->group->leader,
1204                       net_startup_id, utf8, &self->startup_id);
1205 }
1206
1207 static void client_get_area(ObClient *self)
1208 {
1209     XWindowAttributes wattrib;
1210     Status ret;
1211
1212     ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
1213     g_assert(ret != BadWindow);
1214
1215     RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
1216     POINT_SET(self->root_pos, wattrib.x, wattrib.y);
1217     self->border_width = wattrib.border_width;
1218
1219     ob_debug("client area: %d %d  %d %d  bw %d\n", wattrib.x, wattrib.y,
1220              wattrib.width, wattrib.height, wattrib.border_width);
1221 }
1222
1223 static void client_get_desktop(ObClient *self)
1224 {
1225     guint32 d = screen_num_desktops; /* an always-invalid value */
1226
1227     if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
1228         if (d >= screen_num_desktops && d != DESKTOP_ALL)
1229             self->desktop = screen_num_desktops - 1;
1230         else
1231             self->desktop = d;
1232         ob_debug("client requested desktop 0x%x\n", self->desktop);
1233     } else {
1234         GSList *it;
1235         gboolean first = TRUE;
1236         guint all = screen_num_desktops; /* not a valid value */
1237
1238         /* if they are all on one desktop, then open it on the
1239            same desktop */
1240         for (it = self->parents; it; it = g_slist_next(it)) {
1241             ObClient *c = it->data;
1242
1243             if (c->desktop == DESKTOP_ALL) continue;
1244
1245             if (first) {
1246                 all = c->desktop;
1247                 first = FALSE;
1248             }
1249             else if (all != c->desktop)
1250                 all = screen_num_desktops; /* make it invalid */
1251         }
1252         if (all != screen_num_desktops) {
1253             self->desktop = all;
1254
1255             ob_debug("client desktop set from parents: 0x%x\n",
1256                      self->desktop);
1257         }
1258         /* try get from the startup-notification protocol */
1259         else if (sn_get_desktop(self->startup_id, &self->desktop)) {
1260             if (self->desktop >= screen_num_desktops &&
1261                 self->desktop != DESKTOP_ALL)
1262                 self->desktop = screen_num_desktops - 1;
1263             ob_debug("client desktop set from startup-notification: 0x%x\n",
1264                      self->desktop);
1265         }
1266         /* defaults to the current desktop */
1267         else {
1268             self->desktop = screen_desktop;
1269             ob_debug("client desktop set to the current desktop: %d\n",
1270                      self->desktop);
1271         }
1272     }
1273 }
1274
1275 static void client_get_state(ObClient *self)
1276 {
1277     guint32 *state;
1278     guint num;
1279
1280     if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) {
1281         gulong i;
1282         for (i = 0; i < num; ++i) {
1283             if (state[i] == prop_atoms.net_wm_state_modal)
1284                 self->modal = TRUE;
1285             else if (state[i] == prop_atoms.net_wm_state_shaded)
1286                 self->shaded = TRUE;
1287             else if (state[i] == prop_atoms.net_wm_state_hidden)
1288                 self->iconic = TRUE;
1289             else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
1290                 self->skip_taskbar = TRUE;
1291             else if (state[i] == prop_atoms.net_wm_state_skip_pager)
1292                 self->skip_pager = TRUE;
1293             else if (state[i] == prop_atoms.net_wm_state_fullscreen)
1294                 self->fullscreen = TRUE;
1295             else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
1296                 self->max_vert = TRUE;
1297             else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
1298                 self->max_horz = TRUE;
1299             else if (state[i] == prop_atoms.net_wm_state_above)
1300                 self->above = TRUE;
1301             else if (state[i] == prop_atoms.net_wm_state_below)
1302                 self->below = TRUE;
1303             else if (state[i] == prop_atoms.net_wm_state_demands_attention)
1304                 self->demands_attention = TRUE;
1305             else if (state[i] == prop_atoms.ob_wm_state_undecorated)
1306                 self->undecorated = TRUE;
1307         }
1308
1309         g_free(state);
1310     }
1311 }
1312
1313 static void client_get_shaped(ObClient *self)
1314 {
1315     self->shaped = FALSE;
1316 #ifdef SHAPE
1317     if (extensions_shape) {
1318         gint foo;
1319         guint ufoo;
1320         gint s;
1321
1322         XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
1323
1324         XShapeQueryExtents(ob_display, self->window, &s, &foo,
1325                            &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
1326                            &ufoo);
1327         self->shaped = !!s;
1328     }
1329 #endif
1330 }
1331
1332 void client_update_transient_for(ObClient *self)
1333 {
1334     Window t = None;
1335     ObClient *target = NULL;
1336     gboolean trangroup = FALSE;
1337
1338     if (XGetTransientForHint(ob_display, self->window, &t)) {
1339         if (t != self->window) { /* can't be transient to itself! */
1340             target = g_hash_table_lookup(window_map, &t);
1341             /* if this happens then we need to check for it */
1342             g_assert(target != self);
1343             if (target && !WINDOW_IS_CLIENT(target)) {
1344                 /* watch out for windows with a parent that is something
1345                    different, like a dockapp for example */
1346                 target = NULL;
1347             }
1348         }
1349
1350         /* Setting the transient_for to Root is actually illegal, however
1351            applications from time have done this to specify transient for
1352            their group */
1353         if (!target && self->group && t == RootWindow(ob_display, ob_screen))
1354             trangroup = TRUE;
1355     } else if (self->group && self->transient)
1356         trangroup = TRUE;
1357
1358     client_update_transient_tree(self, self->group, self->group,
1359                                  self->transient_for_group, trangroup,
1360                                  client_direct_parent(self), target);
1361     self->transient_for_group = trangroup;
1362
1363 }
1364
1365 static void client_update_transient_tree(ObClient *self,
1366                                          ObGroup *oldgroup, ObGroup *newgroup,
1367                                          gboolean oldgtran, gboolean newgtran,
1368                                          ObClient* oldparent,
1369                                          ObClient *newparent)
1370 {
1371     GSList *it, *next;
1372     ObClient *c;
1373
1374     g_assert(!oldgtran || oldgroup);
1375     g_assert(!newgtran || newgroup);
1376     g_assert((!oldgtran && !oldparent) ||
1377              (oldgtran && !oldparent) ||
1378              (!oldgtran && oldparent));
1379     g_assert((!newgtran && !newparent) ||
1380              (newgtran && !newparent) ||
1381              (!newgtran && newparent));
1382
1383     /* * *
1384       Group transient windows are not allowed to have other group
1385       transient windows as their children.
1386       * * */
1387
1388     /* No change has occured */
1389     if (oldgroup == newgroup &&
1390         oldgtran == newgtran &&
1391         oldparent == newparent) return;
1392
1393     /** Remove the client from the transient tree **/
1394
1395     for (it = self->transients; it; it = next) {
1396         next = g_slist_next(it);
1397         c = it->data;
1398         self->transients = g_slist_delete_link(self->transients, it);
1399         c->parents = g_slist_remove(c->parents, self);
1400     }
1401     for (it = self->parents; it; it = next) {
1402         next = g_slist_next(it);
1403         c = it->data;
1404         self->parents = g_slist_delete_link(self->parents, it);
1405         c->transients = g_slist_remove(c->transients, self);
1406     }
1407
1408     /** Re-add the client to the transient tree **/
1409
1410     /* If we're transient for a group then we need to add ourselves to all our
1411        parents */
1412     if (newgtran) {
1413         for (it = newgroup->members; it; it = g_slist_next(it)) {
1414             c = it->data;
1415             if (c != self &&
1416                 !client_search_top_direct_parent(c)->transient_for_group &&
1417                 client_normal(c))
1418             {
1419                 c->transients = g_slist_prepend(c->transients, self);
1420                 self->parents = g_slist_prepend(self->parents, c);
1421             }
1422         }
1423     }
1424
1425     /* If we are now transient for a single window we need to add ourselves to
1426        its children
1427
1428        WARNING: Cyclical transient-ness is possible if two windows are
1429        transient for eachother.
1430     */
1431     else if (newparent &&
1432              /* don't make ourself its child if it is already our child */
1433              !client_is_direct_child(self, newparent) &&
1434              client_normal(newparent))
1435     {
1436         newparent->transients = g_slist_prepend(newparent->transients, self);
1437         self->parents = g_slist_prepend(self->parents, newparent);
1438     }
1439
1440     /* Add any group transient windows to our children. But if we're transient
1441        for the group, then other group transients are not our children.
1442
1443        WARNING: Cyclical transient-ness is possible. For e.g. if:
1444        A is transient for the group
1445        B is transient for A
1446        C is transient for B
1447        A can't be transient for C or we have a cycle
1448     */
1449     if (!newgtran && newgroup &&
1450         (!newparent ||
1451          !client_search_top_direct_parent(newparent)->transient_for_group) &&
1452         client_normal(self))
1453     {
1454         for (it = newgroup->members; it; it = g_slist_next(it)) {
1455             c = it->data;
1456             if (c != self && c->transient_for_group &&
1457                 /* Don't make it our child if it is already our parent */
1458                 !client_is_direct_child(c, self))
1459             {
1460                 self->transients = g_slist_prepend(self->transients, c);
1461                 c->parents = g_slist_prepend(c->parents, self);
1462             }
1463         }
1464     }
1465
1466     /** If we change our group transient-ness, our children change their
1467         effective group transient-ness, which affects how they relate to other
1468         group windows **/
1469
1470     for (it = self->transients; it; it = g_slist_next(it)) {
1471         c = it->data;
1472         if (!c->transient_for_group)
1473             client_update_transient_tree(c, c->group, c->group,
1474                                          c->transient_for_group,
1475                                          c->transient_for_group,
1476                                          client_direct_parent(c),
1477                                          client_direct_parent(c));
1478     }
1479 }
1480
1481 void client_get_mwm_hints(ObClient *self)
1482 {
1483     guint num;
1484     guint32 *hints;
1485
1486     self->mwmhints.flags = 0; /* default to none */
1487
1488     if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
1489                     &hints, &num)) {
1490         if (num >= OB_MWM_ELEMENTS) {
1491             self->mwmhints.flags = hints[0];
1492             self->mwmhints.functions = hints[1];
1493             self->mwmhints.decorations = hints[2];
1494         }
1495         g_free(hints);
1496     }
1497 }
1498
1499 void client_get_type_and_transientness(ObClient *self)
1500 {
1501     guint num, i;
1502     guint32 *val;
1503     Window t;
1504
1505     self->type = -1;
1506     self->transient = FALSE;
1507
1508     if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
1509         /* use the first value that we know about in the array */
1510         for (i = 0; i < num; ++i) {
1511             if (val[i] == prop_atoms.net_wm_window_type_desktop)
1512                 self->type = OB_CLIENT_TYPE_DESKTOP;
1513             else if (val[i] == prop_atoms.net_wm_window_type_dock)
1514                 self->type = OB_CLIENT_TYPE_DOCK;
1515             else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
1516                 self->type = OB_CLIENT_TYPE_TOOLBAR;
1517             else if (val[i] == prop_atoms.net_wm_window_type_menu)
1518                 self->type = OB_CLIENT_TYPE_MENU;
1519             else if (val[i] == prop_atoms.net_wm_window_type_utility)
1520                 self->type = OB_CLIENT_TYPE_UTILITY;
1521             else if (val[i] == prop_atoms.net_wm_window_type_splash)
1522                 self->type = OB_CLIENT_TYPE_SPLASH;
1523             else if (val[i] == prop_atoms.net_wm_window_type_dialog)
1524                 self->type = OB_CLIENT_TYPE_DIALOG;
1525             else if (val[i] == prop_atoms.net_wm_window_type_normal)
1526                 self->type = OB_CLIENT_TYPE_NORMAL;
1527             else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
1528                 /* prevent this window from getting any decor or
1529                    functionality */
1530                 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
1531                                          OB_MWM_FLAG_DECORATIONS);
1532                 self->mwmhints.decorations = 0;
1533                 self->mwmhints.functions = 0;
1534             }
1535             if (self->type != (ObClientType) -1)
1536                 break; /* grab the first legit type */
1537         }
1538         g_free(val);
1539     }
1540
1541     if (XGetTransientForHint(ob_display, self->window, &t))
1542         self->transient = TRUE;
1543
1544     if (self->type == (ObClientType) -1) {
1545         /*the window type hint was not set, which means we either classify
1546           ourself as a normal window or a dialog, depending on if we are a
1547           transient. */
1548         if (self->transient)
1549             self->type = OB_CLIENT_TYPE_DIALOG;
1550         else
1551             self->type = OB_CLIENT_TYPE_NORMAL;
1552     }
1553
1554     /* then, based on our type, we can update our transientness.. */
1555     if (self->type == OB_CLIENT_TYPE_DIALOG ||
1556         self->type == OB_CLIENT_TYPE_TOOLBAR ||
1557         self->type == OB_CLIENT_TYPE_MENU ||
1558         self->type == OB_CLIENT_TYPE_UTILITY)
1559     {
1560         self->transient = TRUE;
1561     }
1562 }
1563
1564 void client_update_protocols(ObClient *self)
1565 {
1566     guint32 *proto;
1567     guint num_return, i;
1568
1569     self->focus_notify = FALSE;
1570     self->delete_window = FALSE;
1571
1572     if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1573         for (i = 0; i < num_return; ++i) {
1574             if (proto[i] == prop_atoms.wm_delete_window)
1575                 /* this means we can request the window to close */
1576                 self->delete_window = TRUE;
1577             else if (proto[i] == prop_atoms.wm_take_focus)
1578                 /* if this protocol is requested, then the window will be
1579                    notified whenever we want it to receive focus */
1580                 self->focus_notify = TRUE;
1581             else if (proto[i] == prop_atoms.net_wm_ping)
1582                 /* if this protocol is requested, then the window will allow
1583                    pings to determine if it is still alive */
1584                 self->ping = TRUE;
1585 #ifdef SYNC
1586             else if (proto[i] == prop_atoms.net_wm_sync_request)
1587                 /* if this protocol is requested, then resizing the
1588                    window will be synchronized between the frame and the
1589                    client */
1590                 self->sync_request = TRUE;
1591 #endif
1592         }
1593         g_free(proto);
1594     }
1595 }
1596
1597 #ifdef SYNC
1598 void client_update_sync_request_counter(ObClient *self)
1599 {
1600     guint32 i;
1601
1602     if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
1603         self->sync_counter = i;
1604     } else
1605         self->sync_counter = None;
1606 }
1607 #endif
1608
1609 static void client_get_colormap(ObClient *self)
1610 {
1611     XWindowAttributes wa;
1612
1613     if (XGetWindowAttributes(ob_display, self->window, &wa))
1614         client_update_colormap(self, wa.colormap);
1615 }
1616
1617 void client_update_colormap(ObClient *self, Colormap colormap)
1618 {
1619     if (colormap == self->colormap) return;
1620
1621     ob_debug("Setting client %s colormap: 0x%x\n", self->title, colormap);
1622
1623     if (client_focused(self)) {
1624         screen_install_colormap(self, FALSE); /* uninstall old one */
1625         self->colormap = colormap;
1626         screen_install_colormap(self, TRUE); /* install new one */
1627     } else
1628         self->colormap = colormap;
1629 }
1630
1631 void client_update_normal_hints(ObClient *self)
1632 {
1633     XSizeHints size;
1634     glong ret;
1635
1636     /* defaults */
1637     self->min_ratio = 0.0f;
1638     self->max_ratio = 0.0f;
1639     SIZE_SET(self->size_inc, 1, 1);
1640     SIZE_SET(self->base_size, -1, -1);
1641     SIZE_SET(self->min_size, 0, 0);
1642     SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1643
1644     /* get the hints from the window */
1645     if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1646         /* normal windows can't request placement! har har
1647         if (!client_normal(self))
1648         */
1649         self->positioned = (size.flags & (PPosition|USPosition));
1650         self->sized = (size.flags & (PSize|USSize));
1651
1652         if (size.flags & PWinGravity)
1653             self->gravity = size.win_gravity;
1654
1655         if (size.flags & PAspect) {
1656             if (size.min_aspect.y)
1657                 self->min_ratio =
1658                     (gfloat) size.min_aspect.x / size.min_aspect.y;
1659             if (size.max_aspect.y)
1660                 self->max_ratio =
1661                     (gfloat) size.max_aspect.x / size.max_aspect.y;
1662         }
1663
1664         if (size.flags & PMinSize)
1665             SIZE_SET(self->min_size, size.min_width, size.min_height);
1666
1667         if (size.flags & PMaxSize)
1668             SIZE_SET(self->max_size, size.max_width, size.max_height);
1669
1670         if (size.flags & PBaseSize)
1671             SIZE_SET(self->base_size, size.base_width, size.base_height);
1672
1673         if (size.flags & PResizeInc && size.width_inc && size.height_inc)
1674             SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1675
1676         ob_debug("Normal hints: min size (%d %d) max size (%d %d)\n   "
1677                  "size inc (%d %d) base size (%d %d)\n",
1678                  self->min_size.width, self->min_size.height,
1679                  self->max_size.width, self->max_size.height,
1680                  self->size_inc.width, self->size_inc.height,
1681                  self->base_size.width, self->base_size.height);
1682     }
1683     else
1684         ob_debug("Normal hints: not set\n");
1685 }
1686
1687 void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
1688 {
1689     /* start with everything (cept fullscreen) */
1690     self->decorations =
1691         (OB_FRAME_DECOR_TITLEBAR |
1692          OB_FRAME_DECOR_HANDLE |
1693          OB_FRAME_DECOR_GRIPS |
1694          OB_FRAME_DECOR_BORDER |
1695          OB_FRAME_DECOR_ICON |
1696          OB_FRAME_DECOR_ALLDESKTOPS |
1697          OB_FRAME_DECOR_ICONIFY |
1698          OB_FRAME_DECOR_MAXIMIZE |
1699          OB_FRAME_DECOR_SHADE |
1700          OB_FRAME_DECOR_CLOSE);
1701     self->functions =
1702         (OB_CLIENT_FUNC_RESIZE |
1703          OB_CLIENT_FUNC_MOVE |
1704          OB_CLIENT_FUNC_ICONIFY |
1705          OB_CLIENT_FUNC_MAXIMIZE |
1706          OB_CLIENT_FUNC_SHADE |
1707          OB_CLIENT_FUNC_CLOSE |
1708          OB_CLIENT_FUNC_BELOW |
1709          OB_CLIENT_FUNC_ABOVE |
1710          OB_CLIENT_FUNC_UNDECORATE);
1711
1712     if (!(self->min_size.width < self->max_size.width ||
1713           self->min_size.height < self->max_size.height))
1714         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1715
1716     switch (self->type) {
1717     case OB_CLIENT_TYPE_NORMAL:
1718         /* normal windows retain all of the possible decorations and
1719            functionality, and can be fullscreen */
1720         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1721         break;
1722
1723     case OB_CLIENT_TYPE_DIALOG:
1724         /* sometimes apps make dialog windows fullscreen for some reason (for
1725            e.g. kpdf does this..) */
1726         self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1727         break;
1728
1729     case OB_CLIENT_TYPE_UTILITY:
1730         /* these windows don't have anything added or removed by default */
1731         break;
1732
1733     case OB_CLIENT_TYPE_MENU:
1734     case OB_CLIENT_TYPE_TOOLBAR:
1735         /* these windows can't iconify or maximize */
1736         self->decorations &= ~(OB_FRAME_DECOR_ICONIFY |
1737                                OB_FRAME_DECOR_MAXIMIZE);
1738         self->functions &= ~(OB_CLIENT_FUNC_ICONIFY |
1739                              OB_CLIENT_FUNC_MAXIMIZE);
1740         break;
1741
1742     case OB_CLIENT_TYPE_SPLASH:
1743         /* these don't get get any decorations, and the only thing you can
1744            do with them is move them */
1745         self->decorations = 0;
1746         self->functions = OB_CLIENT_FUNC_MOVE;
1747         break;
1748
1749     case OB_CLIENT_TYPE_DESKTOP:
1750         /* these windows are not manipulated by the window manager */
1751         self->decorations = 0;
1752         self->functions = 0;
1753         break;
1754
1755     case OB_CLIENT_TYPE_DOCK:
1756         /* these windows are not manipulated by the window manager, but they
1757            can set below layer which has a special meaning */
1758         self->decorations = 0;
1759         self->functions = OB_CLIENT_FUNC_BELOW;
1760         break;
1761     }
1762
1763     /* Mwm Hints are applied subtractively to what has already been chosen for
1764        decor and functionality */
1765     if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1766         if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1767             if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1768                    (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1769             {
1770                 /* if the mwm hints request no handle or title, then all
1771                    decorations are disabled, but keep the border if that's
1772                    specified */
1773                 if (self->mwmhints.decorations & OB_MWM_DECOR_BORDER)
1774                     self->decorations = OB_FRAME_DECOR_BORDER;
1775                 else
1776                     self->decorations = 0;
1777             }
1778         }
1779     }
1780
1781     if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1782         if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1783             if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1784                 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1785             if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1786                 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1787             /* dont let mwm hints kill any buttons
1788                if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1789                self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1790                if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1791                self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1792             */
1793             /* dont let mwm hints kill the close button
1794                if (! (self->mwmhints.functions & MwmFunc_Close))
1795                self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1796         }
1797     }
1798
1799     if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1800         self->decorations &= ~OB_FRAME_DECOR_SHADE;
1801     if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1802         self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1803     if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1804         self->decorations &= ~(OB_FRAME_DECOR_GRIPS | OB_FRAME_DECOR_HANDLE);
1805
1806     /* can't maximize without moving/resizing */
1807     if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1808           (self->functions & OB_CLIENT_FUNC_MOVE) &&
1809           (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1810         self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1811         self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1812     }
1813
1814     if (self->max_horz && self->max_vert) {
1815         /* you can't resize fully maximized windows */
1816         self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1817         /* kill the handle on fully maxed windows */
1818         self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
1819     }
1820
1821     /* If there are no decorations to remove, don't allow the user to try
1822        toggle the state */
1823     if (self->decorations == 0)
1824         self->functions &= ~OB_CLIENT_FUNC_UNDECORATE;
1825
1826     /* finally, the user can have requested no decorations, which overrides
1827        everything (but doesnt give it a border if it doesnt have one) */
1828     if (self->undecorated)
1829         self->decorations &= (config_theme_keepborder ?
1830                               OB_FRAME_DECOR_BORDER : 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         /* We don't need to ignore enter events here.
2626            The window can hide/iconify in 3 different ways:
2627            1 - through an x message. in this case we ignore all enter events
2628                caused by responding to the x message (unless underMouse)
2629            2 - by a keyboard action. in this case we ignore all enter events
2630                caused by the action
2631            3 - by a mouse action. in this case they are doing stuff with the
2632                mouse and focus _should_ move.
2633
2634            Also in action_end, we simulate an enter event that can't be ignored
2635            so trying to ignore them is futile in case 3 anyways
2636         */
2637
2638         /* replay pending pointer event before hiding the window, in case it
2639            should be going to the window */
2640         mouse_replay_pointer();
2641
2642         frame_hide(self->frame);
2643         hide = TRUE;
2644
2645         /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2646            it needs to be in IconicState. This includes when it is on another
2647            desktop!
2648         */
2649         client_change_wm_state(self);
2650     }
2651     return hide;
2652 }
2653
2654 void client_showhide(ObClient *self)
2655 {
2656     if (!client_show(self))
2657         client_hide(self);
2658 }
2659
2660 gboolean client_normal(ObClient *self) {
2661     return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
2662               self->type == OB_CLIENT_TYPE_DOCK ||
2663               self->type == OB_CLIENT_TYPE_SPLASH);
2664 }
2665
2666 gboolean client_helper(ObClient *self)
2667 {
2668     return (self->type == OB_CLIENT_TYPE_UTILITY ||
2669             self->type == OB_CLIENT_TYPE_MENU ||
2670             self->type == OB_CLIENT_TYPE_TOOLBAR);
2671 }
2672
2673 gboolean client_mouse_focusable(ObClient *self)
2674 {
2675     return !(self->type == OB_CLIENT_TYPE_MENU ||
2676              self->type == OB_CLIENT_TYPE_TOOLBAR ||
2677              self->type == OB_CLIENT_TYPE_SPLASH ||
2678              self->type == OB_CLIENT_TYPE_DOCK);
2679 }
2680
2681 gboolean client_enter_focusable(ObClient *self)
2682 {
2683     /* you can focus desktops but it shouldn't on enter */
2684     return (client_mouse_focusable(self) &&
2685             self->type != OB_CLIENT_TYPE_DESKTOP);
2686 }
2687
2688 static void client_apply_startup_state(ObClient *self,
2689                                        gint x, gint y, gint w, gint h)
2690 {
2691     /* save the states that we are going to apply */
2692     gboolean iconic = self->iconic;
2693     gboolean fullscreen = self->fullscreen;
2694     gboolean undecorated = self->undecorated;
2695     gboolean shaded = self->shaded;
2696     gboolean demands_attention = self->demands_attention;
2697     gboolean max_horz = self->max_horz;
2698     gboolean max_vert = self->max_vert;
2699     Rect oldarea;
2700     gint l;
2701
2702     /* turn them all off in the client, so they won't affect the window
2703        being placed */
2704     self->iconic = self->fullscreen = self->undecorated = self->shaded =
2705         self->demands_attention = self->max_horz = self->max_vert = FALSE;
2706
2707     /* move the client to its placed position, or it it's already there,
2708        generate a ConfigureNotify telling the client where it is.
2709
2710        do this after adjusting the frame. otherwise it gets all weird and
2711        clients don't work right
2712
2713        do this before applying the states so they have the correct
2714        pre-max/pre-fullscreen values
2715     */
2716     client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE);
2717     ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
2718              self->window, x, y, w, h);
2719     /* save the area, and make it where it should be for the premax stuff */
2720     oldarea = self->area;
2721     RECT_SET(self->area, x, y, w, h);
2722
2723     /* apply the states. these are in a carefully crafted order.. */
2724
2725     if (iconic)
2726         client_iconify(self, TRUE, FALSE, TRUE);
2727     if (fullscreen)
2728         client_fullscreen(self, TRUE);
2729     if (undecorated)
2730         client_set_undecorated(self, TRUE);
2731     if (shaded)
2732         client_shade(self, TRUE);
2733     if (demands_attention)
2734         client_hilite(self, TRUE);
2735
2736     if (max_vert && max_horz)
2737         client_maximize(self, TRUE, 0);
2738     else if (max_vert)
2739         client_maximize(self, TRUE, 2);
2740     else if (max_horz)
2741         client_maximize(self, TRUE, 1);
2742
2743     /* if the window hasn't been configured yet, then do so now, in fact the
2744        x,y,w,h may _not_ be the same as the area rect, which can end up
2745        meaning that the client isn't properly moved/resized by the fullscreen
2746        function
2747        pho can cause this because it maps at size of the screen but not 0,0
2748        so openbox moves it on screen to 0,0 (thus x,y=0,0 and area.x,y don't).
2749        then fullscreen'ing makes it go to 0,0 which it thinks it already is at
2750        cuz thats where the pre-fullscreen will be. however the actual area is
2751        not, so this needs to be called even if we have fullscreened/maxed
2752     */
2753     self->area = oldarea;
2754     client_configure(self, x, y, w, h, FALSE, TRUE, FALSE);
2755
2756     /* set the desktop hint, to make sure that it always exists */
2757     PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
2758
2759     /* nothing to do for the other states:
2760        skip_taskbar
2761        skip_pager
2762        modal
2763        above
2764        below
2765     */
2766 }
2767
2768 void client_gravity_resize_w(ObClient *self, gint *x, gint oldw, gint neww)
2769 {
2770     /* these should be the current values. this is for when you're not moving,
2771        just resizing */
2772     g_assert(*x == self->area.x);
2773     g_assert(oldw == self->area.width);
2774
2775     /* horizontal */
2776     switch (self->gravity) {
2777     default:
2778     case NorthWestGravity:
2779     case WestGravity:
2780     case SouthWestGravity:
2781     case StaticGravity:
2782     case ForgetGravity:
2783         break;
2784     case NorthGravity:
2785     case CenterGravity:
2786     case SouthGravity:
2787         *x -= (neww - oldw) / 2;
2788         break;
2789     case NorthEastGravity:
2790     case EastGravity:
2791     case SouthEastGravity:
2792         *x -= neww - oldw;
2793         break;
2794     }
2795 }
2796
2797 void client_gravity_resize_h(ObClient *self, gint *y, gint oldh, gint newh)
2798 {
2799     /* these should be the current values. this is for when you're not moving,
2800        just resizing */
2801     g_assert(*y == self->area.y);
2802     g_assert(oldh == self->area.height);
2803
2804     /* vertical */
2805     switch (self->gravity) {
2806     default:
2807     case NorthWestGravity:
2808     case NorthGravity:
2809     case NorthEastGravity:
2810     case StaticGravity:
2811     case ForgetGravity:
2812         break;
2813     case WestGravity:
2814     case CenterGravity:
2815     case EastGravity:
2816         *y -= (newh - oldh) / 2;
2817         break;
2818     case SouthWestGravity:
2819     case SouthGravity:
2820     case SouthEastGravity:
2821         *y -= newh - oldh;
2822         break;
2823     }
2824 }
2825
2826 void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h,
2827                           gint *logicalw, gint *logicalh,
2828                           gboolean user)
2829 {
2830     Rect desired = {*x, *y, *w, *h};
2831     frame_rect_to_frame(self->frame, &desired);
2832
2833     /* make the frame recalculate its dimensions n shit without changing
2834        anything visible for real, this way the constraints below can work with
2835        the updated frame dimensions. */
2836     frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
2837
2838     /* gets the frame's position */
2839     frame_client_gravity(self->frame, x, y);
2840
2841     /* these positions are frame positions, not client positions */
2842
2843     /* set the size and position if fullscreen */
2844     if (self->fullscreen) {
2845         Rect *a;
2846         guint i;
2847
2848         i = screen_find_monitor(&desired);
2849         a = screen_physical_area_monitor(i);
2850
2851         *x = a->x;
2852         *y = a->y;
2853         *w = a->width;
2854         *h = a->height;
2855
2856         user = FALSE; /* ignore if the client can't be moved/resized when it
2857                          is fullscreening */
2858
2859         g_free(a);
2860     } else if (self->max_horz || self->max_vert) {
2861         Rect *a;
2862         guint i;
2863
2864         /* use all possible struts when maximizing to the full screen */
2865         i = screen_find_monitor(&desired);
2866         a = screen_area(self->desktop, i,
2867                         (self->max_horz && self->max_vert ? NULL : &desired));
2868
2869         /* set the size and position if maximized */
2870         if (self->max_horz) {
2871             *x = a->x;
2872             *w = a->width - self->frame->size.left - self->frame->size.right;
2873         }
2874         if (self->max_vert) {
2875             *y = a->y;
2876             *h = a->height - self->frame->size.top - self->frame->size.bottom;
2877         }
2878
2879         user = FALSE; /* ignore if the client can't be moved/resized when it
2880                          is maximizing */
2881
2882         g_free(a);
2883     }
2884
2885     /* gets the client's position */
2886     frame_frame_gravity(self->frame, x, y);
2887
2888     /* work within the preferred sizes given by the window, these may have
2889        changed rather than it's requested width and height, so always run
2890        through this code */
2891     {
2892         gint basew, baseh, minw, minh;
2893         gint incw, inch;
2894         gfloat minratio, maxratio;
2895
2896         incw = self->fullscreen || self->max_horz ? 1 : self->size_inc.width;
2897         inch = self->fullscreen || self->max_vert ? 1 : self->size_inc.height;
2898         minratio = self->fullscreen || (self->max_horz && self->max_vert) ?
2899             0 : self->min_ratio;
2900         maxratio = self->fullscreen || (self->max_horz && self->max_vert) ?
2901             0 : self->max_ratio;
2902
2903         /* base size is substituted with min size if not specified */
2904         if (self->base_size.width >= 0 || self->base_size.height >= 0) {
2905             basew = self->base_size.width;
2906             baseh = self->base_size.height;
2907         } else {
2908             basew = self->min_size.width;
2909             baseh = self->min_size.height;
2910         }
2911         /* min size is substituted with base size if not specified */
2912         if (self->min_size.width || self->min_size.height) {
2913             minw = self->min_size.width;
2914             minh = self->min_size.height;
2915         } else {
2916             minw = self->base_size.width;
2917             minh = self->base_size.height;
2918         }
2919
2920         /* This comment is no longer true */
2921         /* if this is a user-requested resize, then check against min/max
2922            sizes */
2923
2924         /* smaller than min size or bigger than max size? */
2925         if (*w > self->max_size.width) *w = self->max_size.width;
2926         if (*w < minw) *w = minw;
2927         if (*h > self->max_size.height) *h = self->max_size.height;
2928         if (*h < minh) *h = minh;
2929
2930         *w -= basew;
2931         *h -= baseh;
2932
2933         /* keep to the increments */
2934         *w /= incw;
2935         *h /= inch;
2936
2937         /* you cannot resize to nothing */
2938         if (basew + *w < 1) *w = 1 - basew;
2939         if (baseh + *h < 1) *h = 1 - baseh;
2940
2941         /* save the logical size */
2942         *logicalw = incw > 1 ? *w : *w + basew;
2943         *logicalh = inch > 1 ? *h : *h + baseh;
2944
2945         *w *= incw;
2946         *h *= inch;
2947
2948         *w += basew;
2949         *h += baseh;
2950
2951         /* adjust the height to match the width for the aspect ratios.
2952            for this, min size is not substituted for base size ever. */
2953         *w -= self->base_size.width;
2954         *h -= self->base_size.height;
2955
2956         if (minratio)
2957             if (*h * minratio > *w) {
2958                 *h = (gint)(*w / minratio);
2959
2960                 /* you cannot resize to nothing */
2961                 if (*h < 1) {
2962                     *h = 1;
2963                     *w = (gint)(*h * minratio);
2964                 }
2965             }
2966         if (maxratio)
2967             if (*h * maxratio < *w) {
2968                 *h = (gint)(*w / maxratio);
2969
2970                 /* you cannot resize to nothing */
2971                 if (*h < 1) {
2972                     *h = 1;
2973                     *w = (gint)(*h * minratio);
2974                 }
2975             }
2976
2977         *w += self->base_size.width;
2978         *h += self->base_size.height;
2979     }
2980
2981     /* these override the above states! if you cant move you can't move! */
2982     if (user) {
2983         if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
2984             *x = self->area.x;
2985             *y = self->area.y;
2986         }
2987         if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
2988             *w = self->area.width;
2989             *h = self->area.height;
2990         }
2991     }
2992
2993     g_assert(*w > 0);
2994     g_assert(*h > 0);
2995 }
2996
2997 void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
2998                       gboolean user, gboolean final, gboolean force_reply)
2999 {
3000     Rect oldframe;
3001     gint oldw, oldh;
3002     gboolean send_resize_client;
3003     gboolean moved = FALSE, resized = FALSE, rootmoved = FALSE;
3004     gboolean fmoved, fresized;
3005     guint fdecor = self->frame->decorations;
3006     gboolean fhorz = self->frame->max_horz;
3007     gboolean fvert = self->frame->max_vert;
3008     gint logicalw, logicalh;
3009
3010     /* find the new x, y, width, and height (and logical size) */
3011     client_try_configure(self, &x, &y, &w, &h, &logicalw, &logicalh, user);
3012
3013     /* set the logical size if things changed */
3014     if (!(w == self->area.width && h == self->area.height))
3015         SIZE_SET(self->logical_size, logicalw, logicalh);
3016
3017     /* figure out if we moved or resized or what */
3018     moved = (x != self->area.x || y != self->area.y);
3019     resized = (w != self->area.width || h != self->area.height);
3020
3021     oldw = self->area.width;
3022     oldh = self->area.height;
3023     oldframe = self->frame->area;
3024     RECT_SET(self->area, x, y, w, h);
3025
3026     /* for app-requested resizes, always resize if 'resized' is true.
3027        for user-requested ones, only resize if final is true, or when
3028        resizing in redraw mode */
3029     send_resize_client = ((!user && resized) ||
3030                           (user && (final ||
3031                                     (resized && config_resize_redraw))));
3032
3033     /* if the client is enlarging, then resize the client before the frame */
3034     if (send_resize_client && (w > oldw || h > oldh)) {
3035         XMoveResizeWindow(ob_display, self->window,
3036                           self->frame->size.left, self->frame->size.top,
3037                           MAX(w, oldw), MAX(h, oldh));
3038         frame_adjust_client_area(self->frame);
3039     }
3040
3041     /* find the frame's dimensions and move/resize it */
3042     fmoved = moved;
3043     fresized = resized;
3044
3045     /* if decorations changed, then readjust everything for the frame */
3046     if (self->decorations != fdecor ||
3047         self->max_horz != fhorz || self->max_vert != fvert)
3048     {
3049         fmoved = fresized = TRUE;
3050     }
3051
3052     /* adjust the frame */
3053     if (fmoved || fresized) {
3054         gulong ignore_start;
3055         if (!user)
3056             ignore_start = event_start_ignore_all_enters();
3057
3058         /* replay pending pointer event before move the window, in case it
3059            would change what window gets the event */
3060         mouse_replay_pointer();
3061
3062         frame_adjust_area(self->frame, fmoved, fresized, FALSE);
3063
3064         if (!user)
3065             event_end_ignore_all_enters(ignore_start);
3066     }
3067
3068     if (!user || final) {
3069         gint oldrx = self->root_pos.x;
3070         gint oldry = self->root_pos.y;
3071         /* we have reset the client to 0 border width, so don't include
3072            it in these coords */
3073         POINT_SET(self->root_pos,
3074                   self->frame->area.x + self->frame->size.left -
3075                   self->border_width,
3076                   self->frame->area.y + self->frame->size.top -
3077                   self->border_width);
3078         if (self->root_pos.x != oldrx || self->root_pos.y != oldry)
3079             rootmoved = TRUE;
3080     }
3081
3082     /* This is kinda tricky and should not be changed.. let me explain!
3083
3084        When user = FALSE, then the request is coming from the application
3085        itself, and we are more strict about when to send a synthetic
3086        ConfigureNotify.  We strictly follow the rules of the ICCCM sec 4.1.5
3087        in this case (if force_reply is true)
3088
3089        When user = TRUE, then the request is coming from "us", like when we
3090        maximize a window or something.  In this case we are more lenient.  We
3091        used to follow the same rules as above, but _Java_ Swing can't handle
3092        this. So just to appease Swing, when user = TRUE, we always send
3093        a synthetic ConfigureNotify to give the window its root coordinates.
3094     */
3095     if ((!user && !resized && (rootmoved || force_reply)) ||
3096         (user && final && rootmoved))
3097     {
3098         XEvent event;
3099
3100         event.type = ConfigureNotify;
3101         event.xconfigure.display = ob_display;
3102         event.xconfigure.event = self->window;
3103         event.xconfigure.window = self->window;
3104
3105         ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
3106                  self->title, self->root_pos.x, self->root_pos.y, w, h);
3107
3108         /* root window real coords */
3109         event.xconfigure.x = self->root_pos.x;
3110         event.xconfigure.y = self->root_pos.y;
3111         event.xconfigure.width = w;
3112         event.xconfigure.height = h;
3113         event.xconfigure.border_width = self->border_width;
3114         event.xconfigure.above = None;
3115         event.xconfigure.override_redirect = FALSE;
3116         XSendEvent(event.xconfigure.display, event.xconfigure.window,
3117                    FALSE, StructureNotifyMask, &event);
3118     }
3119
3120     /* if the client is shrinking, then resize the frame before the client.
3121
3122        both of these resize sections may run, because the top one only resizes
3123        in the direction that is growing
3124      */
3125     if (send_resize_client && (w <= oldw || h <= oldh)) {
3126         frame_adjust_client_area(self->frame);
3127         XMoveResizeWindow(ob_display, self->window,
3128                           self->frame->size.left, self->frame->size.top, w, h);
3129     }
3130
3131     XFlush(ob_display);
3132
3133     /* if it moved between monitors, then this can affect the stacking
3134        layer of this window or others - for fullscreen windows */
3135     if (screen_find_monitor(&self->frame->area) !=
3136         screen_find_monitor(&oldframe))
3137     {
3138         client_calc_layer(self);
3139     }
3140 }
3141
3142 void client_fullscreen(ObClient *self, gboolean fs)
3143 {
3144     gint x, y, w, h;
3145
3146     if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
3147         self->fullscreen == fs) return;                   /* already done */
3148
3149     self->fullscreen = fs;
3150     client_change_state(self); /* change the state hints on the client */
3151
3152     if (fs) {
3153         self->pre_fullscreen_area = self->area;
3154         /* if the window is maximized, its area isn't all that meaningful.
3155            save its premax area instead. */
3156         if (self->max_horz) {
3157             self->pre_fullscreen_area.x = self->pre_max_area.x;
3158             self->pre_fullscreen_area.width = self->pre_max_area.width;
3159         }
3160         if (self->max_vert) {
3161             self->pre_fullscreen_area.y = self->pre_max_area.y;
3162             self->pre_fullscreen_area.height = self->pre_max_area.height;
3163         }
3164
3165         /* these will help configure_full figure out where to fullscreen
3166            the window */
3167         x = self->area.x;
3168         y = self->area.y;
3169         w = self->area.width;
3170         h = self->area.height;
3171     } else {
3172         g_assert(self->pre_fullscreen_area.width > 0 &&
3173                  self->pre_fullscreen_area.height > 0);
3174
3175         x = self->pre_fullscreen_area.x;
3176         y = self->pre_fullscreen_area.y;
3177         w = self->pre_fullscreen_area.width;
3178         h = self->pre_fullscreen_area.height;
3179         RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
3180     }
3181
3182     ob_debug("Window %s going fullscreen (%d)\n",
3183              self->title, self->fullscreen);
3184
3185     client_setup_decor_and_functions(self, FALSE);
3186     client_move_resize(self, x, y, w, h);
3187
3188     /* and adjust our layer/stacking. do this after resizing the window,
3189        and applying decorations, because windows which fill the screen are
3190        considered "fullscreen" and it affects their layer */
3191     client_calc_layer(self);
3192
3193     if (fs) {
3194         /* try focus us when we go into fullscreen mode */
3195         client_focus(self);
3196     }
3197 }
3198
3199 static void client_iconify_recursive(ObClient *self,
3200                                      gboolean iconic, gboolean curdesk,
3201                                      gboolean hide_animation)
3202 {
3203     GSList *it;
3204     gboolean changed = FALSE;
3205
3206     if (self->iconic != iconic) {
3207         ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
3208                  self->window);
3209
3210         if (iconic) {
3211             /* don't let non-normal windows iconify along with their parents
3212                or whatever */
3213             if (client_normal(self)) {
3214                 self->iconic = iconic;
3215
3216                 /* update the focus lists.. iconic windows go to the bottom of
3217                    the list */
3218                 focus_order_to_bottom(self);
3219
3220                 changed = TRUE;
3221             }
3222         } else {
3223             self->iconic = iconic;
3224
3225             if (curdesk && self->desktop != screen_desktop &&
3226                 self->desktop != DESKTOP_ALL)
3227                 client_set_desktop(self, screen_desktop, FALSE, FALSE);
3228
3229             /* this puts it after the current focused window */
3230             focus_order_remove(self);
3231             focus_order_add_new(self);
3232
3233             changed = TRUE;
3234         }
3235     }
3236
3237     if (changed) {
3238         client_change_state(self);
3239         if (config_animate_iconify && !hide_animation)
3240             frame_begin_iconify_animation(self->frame, iconic);
3241         /* do this after starting the animation so it doesn't flash */
3242         client_showhide(self);
3243     }
3244
3245     /* iconify all direct transients, and deiconify all transients
3246        (non-direct too) */
3247     for (it = self->transients; it; it = g_slist_next(it))
3248         if (it->data != self)
3249             if (client_is_direct_child(self, it->data) || !iconic)
3250                 client_iconify_recursive(it->data, iconic, curdesk,
3251                                          hide_animation);
3252 }
3253
3254 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk,
3255                     gboolean hide_animation)
3256 {
3257     if (self->functions & OB_CLIENT_FUNC_ICONIFY || !iconic) {
3258         /* move up the transient chain as far as possible first */
3259         self = client_search_top_direct_parent(self);
3260         client_iconify_recursive(self, iconic, curdesk, hide_animation);
3261     }
3262 }
3263
3264 void client_maximize(ObClient *self, gboolean max, gint dir)
3265 {
3266     gint x, y, w, h;
3267
3268     g_assert(dir == 0 || dir == 1 || dir == 2);
3269     if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && max) return;/* can't */
3270
3271     /* check if already done */
3272     if (max) {
3273         if (dir == 0 && self->max_horz && self->max_vert) return;
3274         if (dir == 1 && self->max_horz) return;
3275         if (dir == 2 && self->max_vert) return;
3276     } else {
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     }
3281
3282     /* these will help configure_full figure out which screen to fill with
3283        the window */
3284     x = self->area.x;
3285     y = self->area.y;
3286     w = self->area.width;
3287     h = self->area.height;
3288
3289     if (max) {
3290         if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
3291             RECT_SET(self->pre_max_area,
3292                      self->area.x, self->pre_max_area.y,
3293                      self->area.width, self->pre_max_area.height);
3294         }
3295         if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
3296             RECT_SET(self->pre_max_area,
3297                      self->pre_max_area.x, self->area.y,
3298                      self->pre_max_area.width, self->area.height);
3299         }
3300     } else {
3301         if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
3302             g_assert(self->pre_max_area.width > 0);
3303
3304             x = self->pre_max_area.x;
3305             w = self->pre_max_area.width;
3306
3307             RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
3308                      0, self->pre_max_area.height);
3309         }
3310         if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
3311             g_assert(self->pre_max_area.height > 0);
3312
3313             y = self->pre_max_area.y;
3314             h = self->pre_max_area.height;
3315
3316             RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
3317                      self->pre_max_area.width, 0);
3318         }
3319     }
3320
3321     if (dir == 0 || dir == 1) /* horz */
3322         self->max_horz = max;
3323     if (dir == 0 || dir == 2) /* vert */
3324         self->max_vert = max;
3325
3326     client_change_state(self); /* change the state hints on the client */
3327
3328     client_setup_decor_and_functions(self, FALSE);
3329     client_move_resize(self, x, y, w, h);
3330 }
3331
3332 void client_shade(ObClient *self, gboolean shade)
3333 {
3334     if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
3335          shade) ||                         /* can't shade */
3336         self->shaded == shade) return;     /* already done */
3337
3338     self->shaded = shade;
3339     client_change_state(self);
3340     client_change_wm_state(self); /* the window is being hidden/shown */
3341     /* resize the frame to just the titlebar */
3342     frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
3343 }
3344
3345 static void client_ping_event(ObClient *self, gboolean dead)
3346 {
3347     if (self->not_responding != dead) {
3348         self->not_responding = dead;
3349         client_update_title(self);
3350
3351         if (dead)
3352             /* the client isn't responding, so ask to kill it */
3353             client_prompt_kill(self);
3354         else {
3355             /* it came back to life ! */
3356
3357             if (self->kill_prompt) {
3358                 prompt_unref(self->kill_prompt);
3359                 self->kill_prompt = NULL;
3360             }
3361
3362             self->kill_level = 0;
3363         }
3364     }
3365 }
3366
3367 void client_close(ObClient *self)
3368 {
3369     if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
3370
3371     /* if closing an internal obprompt, that is just cancelling it */
3372     if (self->prompt) {
3373         prompt_cancel(self->prompt);
3374         return;
3375     }
3376
3377     /* in the case that the client provides no means to requesting that it
3378        close, we just kill it */
3379     if (!self->delete_window)
3380         /* don't use client_kill(), we should only kill based on PID in
3381            response to a lack of PING replies */
3382         XKillClient(ob_display, self->window);
3383     else {
3384         /* request the client to close with WM_DELETE_WINDOW */
3385         PROP_MSG_TO(self->window, self->window, wm_protocols,
3386                     prop_atoms.wm_delete_window, event_curtime, 0, 0, 0,
3387                     NoEventMask);
3388
3389         /* we're trying to close the window, so see if it is responding. if it
3390            is not, then we will let them kill the window */
3391         if (self->ping)
3392             ping_start(self, client_ping_event);
3393
3394         /* if we already know the window isn't responding (maybe they clicked
3395            no in the kill dialog but it hasn't come back to life), then show
3396            the kill dialog */
3397         if (self->not_responding)
3398             client_prompt_kill(self);
3399     }
3400 }
3401
3402 #define OB_KILL_RESULT_NO 0
3403 #define OB_KILL_RESULT_YES 1
3404
3405 static gboolean client_kill_requested(ObPrompt *p, gint result, gpointer data)
3406 {
3407     ObClient *self = data;
3408
3409     if (result == OB_KILL_RESULT_YES)
3410         client_kill(self);
3411     return TRUE; /* call the cleanup func */
3412 }
3413
3414 static void client_kill_cleanup(ObPrompt *p, gpointer data)
3415 {
3416     ObClient *self = data;
3417
3418     g_assert(p == self->kill_prompt);
3419
3420     prompt_unref(self->kill_prompt);
3421     self->kill_prompt = NULL;
3422 }
3423
3424 static void client_prompt_kill(ObClient *self)
3425 {
3426     /* check if we're already prompting */
3427     if (!self->kill_prompt) {
3428         ObPromptAnswer answers[] = {
3429             { 0, OB_KILL_RESULT_NO },
3430             { 0, OB_KILL_RESULT_YES }
3431         };
3432         gchar *m;
3433         const gchar *y, *title;
3434
3435         title = self->original_title;
3436         if (title[0] == '\0') {
3437             /* empty string, so use its parent */
3438             ObClient *p = client_search_top_direct_parent(self);
3439             if (p) title = p->original_title;
3440         }
3441
3442         if (client_on_localhost(self)) {
3443             const gchar *sig;
3444
3445             if (self->kill_level == 0)
3446                 sig = "terminate";
3447             else
3448                 sig = "kill";
3449
3450             m = g_strdup_printf
3451                 (_("The window \"%s\" does not seem to be responding.  Do you want to force it to exit by sending the %s signal?"),
3452                  title, sig);
3453             y = _("End Process");
3454         }
3455         else {
3456             m = g_strdup_printf
3457                 (_("The window \"%s\" does not seem to be responding.  Do you want to disconnect it from the X server?"),
3458                  title);
3459             y = _("Disconnect");
3460         }
3461         /* set the dialog buttons' text */
3462         answers[0].text = _("Cancel");  /* "no" */
3463         answers[1].text = y;            /* "yes" */
3464
3465         self->kill_prompt = prompt_new(m, NULL, answers,
3466                                        sizeof(answers)/sizeof(answers[0]),
3467                                        OB_KILL_RESULT_NO, /* default = no */
3468                                        OB_KILL_RESULT_NO, /* cancel = no */
3469                                        client_kill_requested,
3470                                        client_kill_cleanup,
3471                                        self);
3472         g_free(m);
3473     }
3474
3475     prompt_show(self->kill_prompt, self, TRUE);
3476 }
3477
3478 void client_kill(ObClient *self)
3479 {
3480     /* don't kill our own windows */
3481     if (self->prompt) return;
3482
3483     if (client_on_localhost(self) && self->pid) {
3484         /* running on the local host */
3485         if (self->kill_level == 0) {
3486             ob_debug("killing window 0x%x with pid %lu, with SIGTERM",
3487                      self->window, self->pid);
3488             kill(self->pid, SIGTERM);
3489             ++self->kill_level;
3490
3491             /* show that we're trying to kill it */
3492             client_update_title(self);
3493         }
3494         else {
3495             ob_debug("killing window 0x%x with pid %lu, with SIGKILL\n",
3496                      self->window, self->pid);
3497             kill(self->pid, SIGKILL); /* kill -9 */
3498         }
3499     }
3500     else {
3501         /* running on a remote host */
3502         XKillClient(ob_display, self->window);
3503     }
3504 }
3505
3506 void client_hilite(ObClient *self, gboolean hilite)
3507 {
3508     if (self->demands_attention == hilite)
3509         return; /* no change */
3510
3511     /* don't allow focused windows to hilite */
3512     self->demands_attention = hilite && !client_focused(self);
3513     if (self->frame != NULL) { /* if we're mapping, just set the state */
3514         if (self->demands_attention) {
3515             frame_flash_start(self->frame);
3516
3517             /* if the window is on another desktop then raise it and make it
3518                the most recently used window */
3519             if (self->desktop != screen_desktop &&
3520                 self->desktop != DESKTOP_ALL)
3521             {
3522                 stacking_raise(CLIENT_AS_WINDOW(self));
3523                 focus_order_to_top(self);
3524             }
3525         }
3526         else
3527             frame_flash_stop(self->frame);
3528         client_change_state(self);
3529     }
3530 }
3531
3532 static void client_set_desktop_recursive(ObClient *self,
3533                                          guint target,
3534                                          gboolean donthide,
3535                                          gboolean dontraise)
3536 {
3537     guint old;
3538     GSList *it;
3539
3540     if (target != self->desktop && self->type != OB_CLIENT_TYPE_DESKTOP) {
3541
3542         ob_debug("Setting desktop %u\n", target+1);
3543
3544         g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
3545
3546         old = self->desktop;
3547         self->desktop = target;
3548         PROP_SET32(self->window, net_wm_desktop, cardinal, target);
3549         /* the frame can display the current desktop state */
3550         frame_adjust_state(self->frame);
3551         /* 'move' the window to the new desktop */
3552         if (!donthide)
3553             client_hide(self);
3554         client_show(self);
3555         /* raise if it was not already on the desktop */
3556         if (old != DESKTOP_ALL && !dontraise)
3557             stacking_raise(CLIENT_AS_WINDOW(self));
3558         if (STRUT_EXISTS(self->strut))
3559             screen_update_areas();
3560         else
3561             /* the new desktop's geometry may be different, so we may need to
3562                resize, for example if we are maximized */
3563             client_reconfigure(self, FALSE);
3564     }