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