1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 client.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
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.
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.
17 See the COPYING file for a copy of the GNU General Public License.
22 #include "startupnotify.h"
26 #include "moveresize.h"
29 #include "extensions.h"
40 #include "menuframe.h"
43 #include "render/render.h"
50 #include <X11/Xutil.h>
52 /*! The event mask to grab on client windows */
53 #define CLIENT_EVENTMASK (PropertyChangeMask | StructureNotifyMask | \
56 #define CLIENT_NOPROPAGATEMASK (ButtonPressMask | ButtonReleaseMask | \
61 ObClientCallback func;
65 GList *client_list = NULL;
67 static GSList *client_destroy_notifies = NULL;
69 static void client_get_all(ObClient *self, gboolean real);
70 static void client_get_startup_id(ObClient *self);
71 static void client_get_session_ids(ObClient *self);
72 static void client_get_area(ObClient *self);
73 static void client_get_desktop(ObClient *self);
74 static void client_get_state(ObClient *self);
75 static void client_get_shaped(ObClient *self);
76 static void client_get_mwm_hints(ObClient *self);
77 static void client_get_colormap(ObClient *self);
78 static void client_change_allowed_actions(ObClient *self);
79 static void client_change_state(ObClient *self);
80 static void client_change_wm_state(ObClient *self);
81 static void client_apply_startup_state(ObClient *self,
82 gint x, gint y, gint w, gint h);
83 static void client_restore_session_state(ObClient *self);
84 static gboolean client_restore_session_stacking(ObClient *self);
85 static ObAppSettings *client_get_settings_state(ObClient *self);
86 static void client_update_transient_tree(ObClient *self,
87 ObGroup *oldgroup, ObGroup *newgroup,
90 static void client_present(ObClient *self, gboolean here, gboolean raise);
91 static GSList *client_search_all_top_parents_internal(ObClient *self,
93 ObStackingLayer layer);
94 static void client_call_notifies(ObClient *self, GSList *list);
97 void client_startup(gboolean reconfig)
104 void client_shutdown(gboolean reconfig)
106 if (reconfig) return;
109 static void client_call_notifies(ObClient *self, GSList *list)
113 for (it = list; it; it = g_slist_next(it)) {
114 ClientCallback *d = it->data;
115 d->func(self, d->data);
119 void client_add_destroy_notify(ObClientCallback func, gpointer data)
121 ClientCallback *d = g_new(ClientCallback, 1);
124 client_destroy_notifies = g_slist_prepend(client_destroy_notifies, d);
127 void client_remove_destroy_notify(ObClientCallback func)
131 for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
132 ClientCallback *d = it->data;
133 if (d->func == func) {
135 client_destroy_notifies =
136 g_slist_delete_link(client_destroy_notifies, it);
142 void client_set_list()
144 Window *windows, *win_it;
146 guint size = g_list_length(client_list);
148 /* create an array of the window ids */
150 windows = g_new(Window, size);
152 for (it = client_list; it; it = g_list_next(it), ++win_it)
153 *win_it = ((ObClient*)it->data)->window;
157 PROP_SETA32(RootWindow(ob_display, ob_screen),
158 net_client_list, window, (gulong*)windows, size);
166 void client_manage_all()
171 XWindowAttributes attrib;
173 XQueryTree(ob_display, RootWindow(ob_display, ob_screen),
174 &w, &w, &children, &nchild);
176 /* remove all icon windows from the list */
177 for (i = 0; i < nchild; i++) {
178 if (children[i] == None) continue;
179 wmhints = XGetWMHints(ob_display, children[i]);
181 if ((wmhints->flags & IconWindowHint) &&
182 (wmhints->icon_window != children[i]))
183 for (j = 0; j < nchild; j++)
184 if (children[j] == wmhints->icon_window) {
192 for (i = 0; i < nchild; ++i) {
193 if (children[i] == None)
195 if (XGetWindowAttributes(ob_display, children[i], &attrib)) {
196 if (attrib.override_redirect) continue;
198 if (attrib.map_state != IsUnmapped)
199 client_manage(children[i]);
205 void client_manage(Window window)
209 XWindowAttributes attrib;
210 XSetWindowAttributes attrib_set;
212 gboolean activate = FALSE;
213 ObAppSettings *settings;
214 gint placex, placey, placew, placeh;
215 gboolean transient = FALSE;
219 /* check if it has already been unmapped by the time we started
220 mapping. the grab does a sync so we don't have to here */
221 if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
222 XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e))
224 XPutBackEvent(ob_display, &e);
226 ob_debug("Trying to manage unmapped window. Aborting that.\n");
228 return; /* don't manage it */
231 /* make sure it isn't an override-redirect window */
232 if (!XGetWindowAttributes(ob_display, window, &attrib) ||
233 attrib.override_redirect)
236 return; /* don't manage it */
239 /* is the window a docking app */
240 if ((wmhint = XGetWMHints(ob_display, window))) {
241 if ((wmhint->flags & StateHint) &&
242 wmhint->initial_state == WithdrawnState)
244 dock_add(window, wmhint);
252 ob_debug("Managing window: 0x%lx\n", window);
254 /* choose the events we want to receive on the CLIENT window */
255 attrib_set.event_mask = CLIENT_EVENTMASK;
256 attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK;
257 XChangeWindowAttributes(ob_display, window,
258 CWEventMask|CWDontPropagate, &attrib_set);
260 /* create the ObClient struct, and populate it from the hints on the
262 self = g_new0(ObClient, 1);
263 self->obwin.type = Window_Client;
264 self->window = window;
266 /* non-zero defaults */
267 self->wmstate = WithdrawnState; /* make sure it gets updated first time */
268 self->gravity = NorthWestGravity;
269 self->desktop = screen_num_desktops; /* always an invalid value */
270 self->user_time = focus_client ? focus_client->user_time : CurrentTime;
272 /* get all the stuff off the window */
273 client_get_all(self, TRUE);
275 /* specify that if we exit, the window should not be destroyed and
276 should be reparented back to root automatically */
277 XChangeSaveSet(ob_display, window, SetModeInsert);
279 /* create the decoration frame for the client window */
280 self->frame = frame_new(self);
282 frame_grab_client(self->frame);
284 /* we've grabbed everything and set everything that we need to at mapping
288 /* per-app settings override stuff from client_get_all, and return the
289 settings for other uses too. the returned settings is a shallow copy,
290 that needs to be freed with g_free(). */
291 settings = client_get_settings_state(self);
292 /* the session should get the last say though */
293 client_restore_session_state(self);
295 /* now we have all of the window's information so we can set this up */
296 client_setup_decor_and_functions(self, FALSE);
299 Time t = sn_app_started(self->startup_id, self->class);
300 if (t) self->user_time = t;
303 /* do this after we have a frame.. it uses the frame to help determine the
304 WM_STATE to apply. */
305 client_change_state(self);
307 /* add ourselves to the focus order */
308 focus_order_add_new(self);
310 /* do this to add ourselves to the stacking list in a non-intrusive way */
311 client_calc_layer(self);
313 /* focus the new window? */
314 if (ob_state() != OB_STATE_STARTING &&
315 (!self->session || self->session->focused) &&
317 /* this means focus=true for window is same as config_focus_new=true */
318 ((config_focus_new || (settings && settings->focus == 1)) ||
319 client_search_focus_tree_full(self)) &&
320 /* this checks for focus=false for the window */
321 (!settings || settings->focus != 0) &&
322 /* note the check against type Normal/Dialog/Utility,
323 not client_normal(self), which would also include other types.
324 in this case we want more strict rules for focus */
325 (self->type == OB_CLIENT_TYPE_NORMAL ||
326 self->type == OB_CLIENT_TYPE_UTILITY ||
327 self->type == OB_CLIENT_TYPE_DIALOG))
332 /* remove the client's border */
333 XSetWindowBorderWidth(ob_display, self->window, 0);
335 /* adjust the frame to the client's size before showing or placing
337 frame_adjust_area(self->frame, FALSE, TRUE, FALSE);
338 frame_adjust_client_area(self->frame);
340 /* where the frame was placed is where the window was originally */
341 placex = self->area.x;
342 placey = self->area.y;
343 placew = self->area.width;
344 placeh = self->area.height;
346 /* figure out placement for the window if the window is new */
347 if (ob_state() == OB_STATE_RUNNING) {
348 ob_debug("Positioned: %s @ %d %d\n",
349 (!self->positioned ? "no" :
350 (self->positioned == PPosition ? "program specified" :
351 (self->positioned == USPosition ? "user specified" :
352 (self->positioned == (PPosition | USPosition) ?
353 "program + user specified" :
354 "BADNESS !?")))), placex, placey);
356 ob_debug("Sized: %s @ %d %d\n",
357 (!self->sized ? "no" :
358 (self->sized == PSize ? "program specified" :
359 (self->sized == USSize ? "user specified" :
360 (self->sized == (PSize | USSize) ?
361 "program + user specified" :
362 "BADNESS !?")))), placew, placeh);
364 /* splash screens are also returned as TRUE for transient,
365 and so will be forced on screen below */
366 transient = place_client(self, &placex, &placey, settings);
368 /* make sure the window is visible. */
369 client_find_onscreen(self, &placex, &placey, placew, placeh,
370 /* non-normal clients has less rules, and
371 windows that are being restored from a
372 session do also. we can assume you want
373 it back where you saved it. Clients saying
374 they placed themselves are subjected to
375 harder rules, ones that are placed by
376 place.c or by the user are allowed partially
377 off-screen and on xinerama divides (ie,
378 it is up to the placement routines to avoid
379 the xinerama divides)
381 splash screens get "transient" set to TRUE by
382 the place_client call
384 ob_state() == OB_STATE_RUNNING &&
386 (!(self->positioned & USPosition) &&
387 client_normal(self) &&
391 /* if the window isn't user-sized, then make it fit inside
392 the visible screen area on its monitor. Use basically the same rules
393 for forcing the window on screen in the client_find_onscreen call.
395 do this after place_client, it chooses the monitor!
397 splash screens get "transient" set to TRUE by
398 the place_client call
400 if (ob_state() == OB_STATE_RUNNING &&
402 (!(self->sized & USSize) &&
403 client_normal(self) &&
406 /* make a copy to modify */
407 Rect a = *screen_area_monitor(self->desktop, client_monitor(self));
409 /* shrink by the frame's area */
410 a.width -= self->frame->size.left + self->frame->size.right;
411 a.height -= self->frame->size.top + self->frame->size.bottom;
413 /* fit the window inside the area */
414 if (placew > a.width || self->area.height > a.height) {
415 placew = MIN(self->area.width, a.width);
416 placeh = MIN(self->area.height, a.height);
418 ob_debug("setting window size to %dx%d\n",
419 self->area.width, self->area.height);
424 ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
425 "some restrictions may apply\n",
426 self->window, placex, placey, placew, placeh);
428 ob_debug(" but session requested %d, %d %d x %d instead, "
430 self->session->x, self->session->y,
431 self->session->w, self->session->h);
433 /* do this after the window is placed, so the premax/prefullscreen numbers
436 this also places the window
438 client_apply_startup_state(self, placex, placey, placew, placeh);
441 guint32 last_time = focus_client ?
442 focus_client->user_time : CurrentTime;
444 /* This is focus stealing prevention */
445 ob_debug_type(OB_DEBUG_FOCUS,
446 "Want to focus new window 0x%x with time %u "
448 self->window, self->user_time, last_time);
450 /* if it's on another desktop */
451 if (!(self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
452 && /* the timestamp is from before you changed desktops */
453 self->user_time && screen_desktop_user_time &&
454 !event_time_after(self->user_time, screen_desktop_user_time))
457 ob_debug_type(OB_DEBUG_FOCUS,
458 "Not focusing the window because its on another "
461 /* If something is focused, and it's not our relative... */
462 else if (focus_client && client_search_focus_tree_full(self) == NULL &&
463 client_search_focus_group_full(self) == NULL)
465 /* If time stamp is old, don't steal focus */
466 if (self->user_time && last_time &&
467 !event_time_after(self->user_time, last_time))
470 ob_debug_type(OB_DEBUG_FOCUS,
471 "Not focusing the window because the time is "
474 /* If its a transient (and parents aren't focused) and the time
475 is ambiguous (either the current focus target doesn't have
476 a timestamp, or they are the same (we probably inherited it
478 else if (client_has_parent(self) &&
479 (!last_time || self->user_time == last_time))
482 ob_debug_type(OB_DEBUG_FOCUS,
483 "Not focusing the window because it is a "
484 "transient, and the time is very ambiguous\n");
486 /* Don't steal focus from globally active clients.
487 I stole this idea from KWin. It seems nice.
489 else if (!(focus_client->can_focus ||
490 focus_client->focus_notify))
493 ob_debug_type(OB_DEBUG_FOCUS,
494 "Not focusing the window because a globally "
495 "active client has focus\n");
497 /* Don't move focus if it's not going to go to this window
499 else if (client_focus_target(self) != self) {
501 ob_debug_type(OB_DEBUG_FOCUS,
502 "Not focusing the window because another window "
503 "would get the focus anyway\n");
508 ob_debug_type(OB_DEBUG_FOCUS,
509 "Focus stealing prevention activated for %s with "
510 "time %u (last time %u)\n",
511 self->title, self->user_time, last_time);
512 /* if the client isn't focused, then hilite it so the user
514 client_hilite(self, TRUE);
518 /* This may look rather odd. Well it's because new windows are added
519 to the stacking order non-intrusively. If we're not going to focus
520 the new window or hilite it, then we raise it to the top. This will
521 take affect for things that don't get focused like splash screens.
522 Also if you don't have focus_new enabled, then it's going to get
523 raised to the top. Legacy begets legacy I guess?
525 if (!client_restore_session_stacking(self))
526 stacking_raise(CLIENT_AS_WINDOW(self));
529 mouse_grab_for_client(self, TRUE);
531 /* this has to happen before we try focus the window, but we want it to
532 happen after the client's stacking has been determined or it looks bad
537 gboolean stacked = client_restore_session_stacking(self);
538 client_present(self, FALSE, !stacked);
541 /* add to client list/map */
542 client_list = g_list_append(client_list, self);
543 g_hash_table_insert(window_map, &self->window, self);
545 /* this has to happen after we're in the client_list */
546 if (STRUT_EXISTS(self->strut))
547 screen_update_areas();
549 /* update the list hints */
552 /* free the ObAppSettings shallow copy */
555 ob_debug("Managed window 0x%lx plate 0x%x (%s)\n",
556 window, self->frame->window, self->class);
562 ObClient *client_fake_manage(Window window)
565 ObAppSettings *settings;
567 ob_debug("Pretend-managing window: %lx\n", window);
569 /* do this minimal stuff to figure out the client's decorations */
571 self = g_new0(ObClient, 1);
572 self->window = window;
574 client_get_all(self, FALSE);
575 /* per-app settings override stuff, and return the settings for other
576 uses too. this returns a shallow copy that needs to be freed */
577 settings = client_get_settings_state(self);
579 client_setup_decor_and_functions(self, FALSE);
581 /* create the decoration frame for the client window and adjust its size */
582 self->frame = frame_new(self);
583 frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
585 ob_debug("gave extents left %d right %d top %d bottom %d\n",
586 self->frame->size.left, self->frame->size.right,
587 self->frame->size.top, self->frame->size.bottom);
589 /* free the ObAppSettings shallow copy */
595 void client_unmanage_all()
597 while (client_list != NULL)
598 client_unmanage(client_list->data);
601 void client_unmanage(ObClient *self)
607 ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n",
608 self->window, self->frame->window,
609 self->class, self->title ? self->title : "");
611 g_assert(self != NULL);
613 /* we dont want events no more. do this before hiding the frame so we
614 don't generate more events */
615 XSelectInput(ob_display, self->window, NoEventMask);
617 /* ignore enter events from the unmap so it doesnt mess with the focus */
618 if (!client_focused(self) || !config_focus_under_mouse)
619 ignore_start = event_start_ignore_all_enters();
621 frame_hide(self->frame);
622 /* flush to send the hide to the server quickly */
625 if (!client_focused(self) || !config_focus_under_mouse)
626 event_end_ignore_all_enters(ignore_start);
628 mouse_grab_for_client(self, FALSE);
630 /* remove the window from our save set */
631 XChangeSaveSet(ob_display, self->window, SetModeDelete);
633 /* kill the property windows */
634 propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self);
636 /* update the focus lists */
637 focus_order_remove(self);
638 if (client_focused(self)) {
639 /* don't leave an invalid focus_client */
643 client_list = g_list_remove(client_list, self);
644 stacking_remove(self);
645 g_hash_table_remove(window_map, &self->window);
647 /* once the client is out of the list, update the struts to remove its
649 if (STRUT_EXISTS(self->strut))
650 screen_update_areas();
652 client_call_notifies(self, client_destroy_notifies);
654 /* tell our parent(s) that we're gone */
655 for (it = self->parents; it; it = g_slist_next(it))
656 ((ObClient*)it->data)->transients =
657 g_slist_remove(((ObClient*)it->data)->transients,self);
659 /* tell our transients that we're gone */
660 for (it = self->transients; it; it = g_slist_next(it)) {
661 ((ObClient*)it->data)->parents =
662 g_slist_remove(((ObClient*)it->data)->parents, self);
663 /* we could be keeping our children in a higher layer */
664 client_calc_layer(it->data);
667 /* remove from its group */
669 group_remove(self->group, self);
673 /* restore the window's original geometry so it is not lost */
679 if (self->fullscreen)
680 a = self->pre_fullscreen_area;
681 else if (self->max_horz || self->max_vert) {
682 if (self->max_horz) {
683 a.x = self->pre_max_area.x;
684 a.width = self->pre_max_area.width;
686 if (self->max_vert) {
687 a.y = self->pre_max_area.y;
688 a.height = self->pre_max_area.height;
692 self->fullscreen = self->max_horz = self->max_vert = FALSE;
693 /* let it be moved and resized no matter what */
694 self->functions = OB_CLIENT_FUNC_MOVE | OB_CLIENT_FUNC_RESIZE;
695 self->decorations = 0; /* unmanaged windows have no decor */
697 /* give the client its border back */
698 XSetWindowBorderWidth(ob_display, self->window, self->border_width);
700 client_move_resize(self, a.x, a.y, a.width, a.height);
703 /* reparent the window out of the frame, and free the frame */
704 frame_release_client(self->frame);
705 frame_free(self->frame);
708 if (ob_state() != OB_STATE_EXITING) {
709 /* these values should not be persisted across a window
711 PROP_ERASE(self->window, net_wm_desktop);
712 PROP_ERASE(self->window, net_wm_state);
713 PROP_ERASE(self->window, wm_state);
715 /* if we're left in an unmapped state, the client wont be mapped.
716 this is bad, since we will no longer be managing the window on
718 XMapWindow(ob_display, self->window);
721 /* update the list hints */
724 ob_debug("Unmanaged window 0x%lx\n", self->window);
726 /* free all data allocated in the client struct */
727 g_slist_free(self->transients);
728 for (j = 0; j < self->nicons; ++j)
729 g_free(self->icons[j].data);
730 if (self->nicons > 0)
732 g_free(self->wm_command);
734 g_free(self->icon_title);
738 g_free(self->client_machine);
739 g_free(self->sm_client_id);
743 void client_fake_unmanage(ObClient *self)
745 /* this is all that got allocated to get the decorations */
747 frame_free(self->frame);
751 /*! Returns a new structure containing the per-app settings for this client.
752 The returned structure needs to be freed with g_free. */
753 static ObAppSettings *client_get_settings_state(ObClient *self)
755 ObAppSettings *settings;
758 settings = config_create_app_settings();
760 for (it = config_per_app_settings; it; it = g_slist_next(it)) {
761 ObAppSettings *app = it->data;
762 gboolean match = TRUE;
764 g_assert(app->name != NULL || app->class != NULL);
766 /* we know that either name or class is not NULL so it will have to
767 match to use the rule */
769 !g_pattern_match(app->name, strlen(self->name), self->name, NULL))
771 else if (app->class &&
772 !g_pattern_match(app->class,
773 strlen(self->class), self->class, NULL))
775 else if (app->role &&
776 !g_pattern_match(app->role,
777 strlen(self->role), self->role, NULL))
781 ob_debug("Window matching: %s\n", app->name);
783 /* copy the settings to our struct, overriding the existing
784 settings if they are not defaults */
785 config_app_settings_copy_non_defaults(app, settings);
789 if (settings->shade != -1)
790 self->shaded = !!settings->shade;
791 if (settings->decor != -1)
792 self->undecorated = !settings->decor;
793 if (settings->iconic != -1)
794 self->iconic = !!settings->iconic;
795 if (settings->skip_pager != -1)
796 self->skip_pager = !!settings->skip_pager;
797 if (settings->skip_taskbar != -1)
798 self->skip_taskbar = !!settings->skip_taskbar;
800 if (settings->max_vert != -1)
801 self->max_vert = !!settings->max_vert;
802 if (settings->max_horz != -1)
803 self->max_horz = !!settings->max_horz;
805 if (settings->fullscreen != -1)
806 self->fullscreen = !!settings->fullscreen;
808 if (settings->desktop) {
809 if (settings->desktop == DESKTOP_ALL)
810 self->desktop = settings->desktop;
811 else if (settings->desktop > 0 &&
812 settings->desktop <= screen_num_desktops)
813 self->desktop = settings->desktop - 1;
816 if (settings->layer == -1) {
820 else if (settings->layer == 0) {
824 else if (settings->layer == 1) {
831 static void client_restore_session_state(ObClient *self)
835 ob_debug_type(OB_DEBUG_SM,
836 "Restore session for client %s\n", self->title);
838 if (!(it = session_state_find(self))) {
839 ob_debug_type(OB_DEBUG_SM,
840 "Session data not found for client %s\n", self->title);
844 self->session = it->data;
846 ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s\n",
849 RECT_SET_POINT(self->area, self->session->x, self->session->y);
850 self->positioned = USPosition;
851 self->sized = USSize;
852 if (self->session->w > 0)
853 self->area.width = self->session->w;
854 if (self->session->h > 0)
855 self->area.height = self->session->h;
856 XResizeWindow(ob_display, self->window,
857 self->area.width, self->area.height);
859 self->desktop = (self->session->desktop == DESKTOP_ALL ?
860 self->session->desktop :
861 MIN(screen_num_desktops - 1, self->session->desktop));
862 PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
864 self->shaded = self->session->shaded;
865 self->iconic = self->session->iconic;
866 self->skip_pager = self->session->skip_pager;
867 self->skip_taskbar = self->session->skip_taskbar;
868 self->fullscreen = self->session->fullscreen;
869 self->above = self->session->above;
870 self->below = self->session->below;
871 self->max_horz = self->session->max_horz;
872 self->max_vert = self->session->max_vert;
873 self->undecorated = self->session->undecorated;
876 static gboolean client_restore_session_stacking(ObClient *self)
880 if (!self->session) return FALSE;
882 mypos = g_list_find(session_saved_state, self->session);
883 if (!mypos) return FALSE;
885 /* start above me and look for the first client */
886 for (it = g_list_previous(mypos); it; it = g_list_previous(it)) {
889 for (cit = client_list; cit; cit = g_list_next(cit)) {
890 ObClient *c = cit->data;
891 /* found a client that was in the session, so go below it */
892 if (c->session == it->data) {
893 stacking_below(CLIENT_AS_WINDOW(self),
894 CLIENT_AS_WINDOW(cit->data));
902 void client_move_onscreen(ObClient *self, gboolean rude)
904 gint x = self->area.x;
905 gint y = self->area.y;
906 if (client_find_onscreen(self, &x, &y,
908 self->area.height, rude)) {
909 client_move(self, x, y);
913 gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h,
917 gint ox = *x, oy = *y;
918 gboolean rudel = rude, ruder = rude, rudet = rude, rudeb = rude;
922 RECT_SET(desired, *x, *y, w, h);
923 all_a = screen_area(self->desktop);
924 mon_a = screen_area_monitor(self->desktop, screen_find_monitor(&desired));
926 /* get where the frame would be */
927 frame_client_gravity(self->frame, x, y, w, h);
929 /* get the requested size of the window with decorations */
930 fw = self->frame->size.left + w + self->frame->size.right;
931 fh = self->frame->size.top + h + self->frame->size.bottom;
933 /* This makes sure windows aren't entirely outside of the screen so you
934 can't see them at all.
935 It makes sure 10% of the window is on the screen at least. At don't let
936 it move itself off the top of the screen, which would hide the titlebar
937 on you. (The user can still do this if they want too, it's only limiting
940 XXX watch for xinerama dead areas...
942 if (client_normal(self)) {
943 if (!self->strut.right && *x + fw/10 >= all_a->x + all_a->width - 1)
944 *x = all_a->x + all_a->width - fw/10;
945 if (!self->strut.bottom && *y + fh/10 >= all_a->y + all_a->height - 1)
946 *y = all_a->y + all_a->height - fh/10;
947 if (!self->strut.left && *x + fw*9/10 - 1 < all_a->x)
948 *x = all_a->x - fw*9/10;
949 if (!self->strut.top && *y + fh*9/10 - 1 < all_a->y)
950 *y = all_a->y - fw*9/10;
953 /* If rudeness wasn't requested, then figure out of the client is currently
954 entirely on the screen. If it is, and the position isn't changing by
955 request, and it is enlarging, then be rude even though it wasn't
958 Point oldtl, oldtr, oldbl, oldbr;
959 Point newtl, newtr, newbl, newbr;
960 gboolean stationary_l, stationary_r, stationary_t, stationary_b;
962 POINT_SET(oldtl, self->frame->area.x, self->frame->area.y);
963 POINT_SET(oldbr, self->frame->area.x + self->frame->area.width - 1,
964 self->frame->area.y + self->frame->area.height - 1);
965 POINT_SET(oldtr, oldbr.x, oldtl.y);
966 POINT_SET(oldbl, oldtl.x, oldbr.y);
968 POINT_SET(newtl, *x, *y);
969 POINT_SET(newbr, *x + fw - 1, *y + fh - 1);
970 POINT_SET(newtr, newbr.x, newtl.y);
971 POINT_SET(newbl, newtl.x, newbr.y);
973 /* is it moving or just resizing from some corner? */
974 stationary_l = oldtl.x == newtl.x;
975 stationary_r = oldtr.x == newtr.x;
976 stationary_t = oldtl.y == newtl.y;
977 stationary_b = oldbl.y == newbl.y;
979 /* if left edge is growing and didnt move right edge */
980 if (stationary_r && newtl.x < oldtl.x)
982 /* if right edge is growing and didnt move left edge */
983 if (stationary_l && newtr.x > oldtr.x)
985 /* if top edge is growing and didnt move bottom edge */
986 if (stationary_b && newtl.y < oldtl.y)
988 /* if bottom edge is growing and didnt move top edge */
989 if (stationary_t && newbl.y > oldbl.y)
993 /* This here doesn't let windows even a pixel outside the struts/screen.
994 * When called from client_manage, programs placing themselves are
995 * forced completely onscreen, while things like
996 * xterm -geometry resolution-width/2 will work fine. Trying to
997 * place it completely offscreen will be handled in the above code.
998 * Sorry for this confused comment, i am tired. */
999 if (rudel && !self->strut.left && *x < mon_a->x) *x = mon_a->x;
1000 if (ruder && !self->strut.right && *x + fw > mon_a->x + mon_a->width)
1001 *x = mon_a->x + MAX(0, mon_a->width - fw);
1003 if (rudet && !self->strut.top && *y < mon_a->y) *y = mon_a->y;
1004 if (rudeb && !self->strut.bottom && *y + fh > mon_a->y + mon_a->height)
1005 *y = mon_a->y + MAX(0, mon_a->height - fh);
1007 /* get where the client should be */
1008 frame_frame_gravity(self->frame, x, y, w, h);
1010 return ox != *x || oy != *y;
1013 static void client_get_all(ObClient *self, gboolean real)
1015 /* this is needed for the frame to set itself up */
1016 client_get_area(self);
1018 /* these things can change the decor and functions of the window */
1020 client_get_mwm_hints(self);
1021 /* this can change the mwmhints for special cases */
1022 client_get_type_and_transientness(self);
1023 client_get_state(self);
1024 client_update_normal_hints(self);
1026 /* get the session related properties, these can change decorations
1027 from per-app settings */
1028 client_get_session_ids(self);
1030 /* now we got everything that can affect the decorations */
1034 /* get this early so we have it for debugging */
1035 client_update_title(self);
1037 client_update_protocols(self);
1039 client_update_wmhints(self);
1040 /* this may have already been called from client_update_wmhints */
1041 if (self->transient_for == NULL)
1042 client_update_transient_for(self);
1044 client_get_startup_id(self);
1045 client_get_desktop(self);/* uses transient data/group/startup id if a
1046 desktop is not specified */
1047 client_get_shaped(self);
1050 /* a couple type-based defaults for new windows */
1052 /* this makes sure that these windows appear on all desktops */
1053 if (self->type == OB_CLIENT_TYPE_DESKTOP)
1054 self->desktop = DESKTOP_ALL;
1058 client_update_sync_request_counter(self);
1061 client_get_colormap(self);
1062 client_update_strut(self);
1063 client_update_icons(self);
1064 client_update_user_time_window(self);
1065 if (!self->user_time_window) /* check if this would have been called */
1066 client_update_user_time(self);
1067 client_update_icon_geometry(self);
1070 static void client_get_startup_id(ObClient *self)
1072 if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id)))
1074 PROP_GETS(self->group->leader,
1075 net_startup_id, utf8, &self->startup_id);
1078 static void client_get_area(ObClient *self)
1080 XWindowAttributes wattrib;
1083 ret = XGetWindowAttributes(ob_display, self->window, &wattrib);
1084 g_assert(ret != BadWindow);
1086 RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height);
1087 POINT_SET(self->root_pos, wattrib.x, wattrib.y);
1088 self->border_width = wattrib.border_width;
1090 ob_debug("client area: %d %d %d %d bw %d\n", wattrib.x, wattrib.y,
1091 wattrib.width, wattrib.height, wattrib.border_width);
1094 static void client_get_desktop(ObClient *self)
1096 guint32 d = screen_num_desktops; /* an always-invalid value */
1098 if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
1099 if (d >= screen_num_desktops && d != DESKTOP_ALL)
1100 self->desktop = screen_num_desktops - 1;
1103 ob_debug("client requested desktop 0x%x\n", self->desktop);
1106 gboolean first = TRUE;
1107 guint all = screen_num_desktops; /* not a valid value */
1109 /* if they are all on one desktop, then open it on the
1111 for (it = self->parents; it; it = g_slist_next(it)) {
1112 ObClient *c = it->data;
1114 if (c->desktop == DESKTOP_ALL) continue;
1120 else if (all != c->desktop)
1121 all = screen_num_desktops; /* make it invalid */
1123 if (all != screen_num_desktops) {
1124 self->desktop = all;
1126 /* try get from the startup-notification protocol */
1127 else if (sn_get_desktop(self->startup_id, &self->desktop)) {
1128 if (self->desktop >= screen_num_desktops &&
1129 self->desktop != DESKTOP_ALL)
1130 self->desktop = screen_num_desktops - 1;
1132 /* defaults to the current desktop */
1134 self->desktop = screen_desktop;
1138 static void client_get_state(ObClient *self)
1143 if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) {
1145 for (i = 0; i < num; ++i) {
1146 if (state[i] == prop_atoms.net_wm_state_modal)
1148 else if (state[i] == prop_atoms.net_wm_state_shaded)
1149 self->shaded = TRUE;
1150 else if (state[i] == prop_atoms.net_wm_state_hidden)
1151 self->iconic = TRUE;
1152 else if (state[i] == prop_atoms.net_wm_state_skip_taskbar)
1153 self->skip_taskbar = TRUE;
1154 else if (state[i] == prop_atoms.net_wm_state_skip_pager)
1155 self->skip_pager = TRUE;
1156 else if (state[i] == prop_atoms.net_wm_state_fullscreen)
1157 self->fullscreen = TRUE;
1158 else if (state[i] == prop_atoms.net_wm_state_maximized_vert)
1159 self->max_vert = TRUE;
1160 else if (state[i] == prop_atoms.net_wm_state_maximized_horz)
1161 self->max_horz = TRUE;
1162 else if (state[i] == prop_atoms.net_wm_state_above)
1164 else if (state[i] == prop_atoms.net_wm_state_below)
1166 else if (state[i] == prop_atoms.net_wm_state_demands_attention)
1167 self->demands_attention = TRUE;
1168 else if (state[i] == prop_atoms.ob_wm_state_undecorated)
1169 self->undecorated = TRUE;
1176 static void client_get_shaped(ObClient *self)
1178 self->shaped = FALSE;
1180 if (extensions_shape) {
1185 XShapeSelectInput(ob_display, self->window, ShapeNotifyMask);
1187 XShapeQueryExtents(ob_display, self->window, &s, &foo,
1188 &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
1190 self->shaped = (s != 0);
1195 void client_update_transient_for(ObClient *self)
1198 ObClient *target = NULL;
1200 if (XGetTransientForHint(ob_display, self->window, &t)) {
1201 if (t != self->window) { /* cant be transient to itself! */
1202 target = g_hash_table_lookup(window_map, &t);
1203 /* if this happens then we need to check for it*/
1204 g_assert(target != self);
1205 if (target && !WINDOW_IS_CLIENT(target)) {
1206 /* this can happen when a dialog is a child of
1207 a dockapp, for example */
1211 /* Setting the transient_for to Root is actually illegal, however
1212 applications from time have done this to specify transient for
1214 if (!target && self->group) {
1215 /* not transient to a client, see if it is transient for a
1217 if (t == RootWindow(ob_display, ob_screen)) {
1218 /* window is a transient for its group! */
1219 target = OB_TRAN_GROUP;
1223 } else if (self->transient && self->group)
1224 target = OB_TRAN_GROUP;
1226 client_update_transient_tree(self, self->group, self->group,
1227 self->transient_for, target);
1228 self->transient_for = target;
1232 static void client_update_transient_tree(ObClient *self,
1233 ObGroup *oldgroup, ObGroup *newgroup,
1234 ObClient* oldparent,
1235 ObClient *newparent)
1241 Group transient windows are not allowed to have other group
1242 transient windows as their children.
1246 /* No change has occured */
1247 if (oldgroup == newgroup && oldparent == newparent) return;
1249 /** Remove the client from the transient tree wherever it has changed **/
1251 /* If the window is becoming a direct transient for a window in its group
1252 then any group transients which were our children and are now becoming
1253 our parents need to stop being our children.
1255 Group transients can't be children of group transients already, but
1256 we could have any number of direct parents above up, any of which could
1257 be transient for the group, and we need to remove it from our children.
1259 if (oldparent != newparent &&
1260 newparent != NULL && newparent != OB_TRAN_GROUP &&
1261 newgroup != NULL && newgroup == oldgroup && client_normal(newparent))
1263 ObClient *look = client_search_top_direct_parent(newparent);
1264 self->transients = g_slist_remove(self->transients, look);
1265 look->parents = g_slist_remove(look->parents, self);
1269 /* If the group changed, or if we are just becoming transient for the
1270 group, then we need to remove any old group transient windows
1271 from our children. But if we were already transient for the group, then
1272 other group transients are not our children. */
1273 if ((oldgroup != newgroup ||
1274 (newparent == OB_TRAN_GROUP && oldparent != newparent)) &&
1275 oldgroup != NULL && oldparent != OB_TRAN_GROUP)
1277 for (it = self->transients; it; it = next) {
1278 next = g_slist_next(it);
1280 if (c->group == oldgroup && client_normal(self)) {
1281 self->transients = g_slist_delete_link(self->transients, it);
1282 c->parents = g_slist_remove(c->parents, self);
1287 /* If we used to be transient for a group and now we are not, or we're
1288 transient for a new group, then we need to remove ourselves from all
1290 if (oldparent == OB_TRAN_GROUP && (oldgroup != newgroup ||
1291 oldparent != newparent))
1293 for (it = self->parents; it; it = next) {
1294 next = g_slist_next(it);
1296 if (c->transient_for != OB_TRAN_GROUP && client_normal(c))
1298 c->transients = g_slist_remove(c->transients, self);
1299 self->parents = g_slist_delete_link(self->parents, it);
1303 /* If we used to be transient for a single window and we are no longer
1304 transient for it, then we need to remove ourself from its children */
1305 else if (oldparent != NULL && oldparent != OB_TRAN_GROUP &&
1306 oldparent != newparent && client_normal(oldparent))
1308 oldparent->transients = g_slist_remove(oldparent->transients, self);
1309 self->parents = g_slist_remove(self->parents, oldparent);
1312 /** Re-add the client to the transient tree wherever it has changed **/
1314 /* If we're now transient for a group and we weren't transient for it
1315 before then we need to add ourselves to all our new parents */
1316 if (newparent == OB_TRAN_GROUP && (oldgroup != newgroup ||
1317 oldparent != newparent))
1319 for (it = oldgroup->members; it; it = g_slist_next(it)) {
1322 c->transient_for != OB_TRAN_GROUP && client_normal(c))
1324 c->transients = g_slist_prepend(c->transients, self);
1325 self->parents = g_slist_prepend(self->parents, c);
1329 /* If we are now transient for a single window which we weren't before,
1330 we need to add ourselves to its children
1332 WARNING: Cyclical transient ness is possible if two windows are
1333 transient for eachother.
1335 else if (newparent != NULL && newparent != OB_TRAN_GROUP &&
1336 newparent != oldparent &&
1337 /* don't make ourself its child if it is already our child */
1338 !client_is_direct_child(self, newparent) &&
1339 client_normal(newparent))
1341 newparent->transients = g_slist_prepend(newparent->transients, self);
1342 self->parents = g_slist_prepend(self->parents, newparent);
1345 /* If the group changed then we need to add any new group transient
1346 windows to our children. But if we're transient for the group, then
1347 other group transients are not our children.
1349 WARNING: Cyclical transient-ness is possible. For e.g. if:
1350 A is transient for the group
1351 B is transient for A
1352 C is transient for B
1353 A can't be transient for C or we have a cycle
1355 if (oldgroup != newgroup && newgroup != NULL &&
1356 newparent != OB_TRAN_GROUP &&
1357 client_normal(self))
1359 for (it = newgroup->members; it; it = g_slist_next(it)) {
1361 if (c != self && c->transient_for == OB_TRAN_GROUP &&
1362 /* Don't make it our child if it is already our parent */
1363 !client_is_direct_child(c, self))
1365 self->transients = g_slist_prepend(self->transients, c);
1366 c->parents = g_slist_prepend(c->parents, self);
1372 static void client_get_mwm_hints(ObClient *self)
1377 self->mwmhints.flags = 0; /* default to none */
1379 if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints,
1381 if (num >= OB_MWM_ELEMENTS) {
1382 self->mwmhints.flags = hints[0];
1383 self->mwmhints.functions = hints[1];
1384 self->mwmhints.decorations = hints[2];
1390 void client_get_type_and_transientness(ObClient *self)
1397 self->transient = FALSE;
1399 if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) {
1400 /* use the first value that we know about in the array */
1401 for (i = 0; i < num; ++i) {
1402 if (val[i] == prop_atoms.net_wm_window_type_desktop)
1403 self->type = OB_CLIENT_TYPE_DESKTOP;
1404 else if (val[i] == prop_atoms.net_wm_window_type_dock)
1405 self->type = OB_CLIENT_TYPE_DOCK;
1406 else if (val[i] == prop_atoms.net_wm_window_type_toolbar)
1407 self->type = OB_CLIENT_TYPE_TOOLBAR;
1408 else if (val[i] == prop_atoms.net_wm_window_type_menu)
1409 self->type = OB_CLIENT_TYPE_MENU;
1410 else if (val[i] == prop_atoms.net_wm_window_type_utility)
1411 self->type = OB_CLIENT_TYPE_UTILITY;
1412 else if (val[i] == prop_atoms.net_wm_window_type_splash)
1413 self->type = OB_CLIENT_TYPE_SPLASH;
1414 else if (val[i] == prop_atoms.net_wm_window_type_dialog)
1415 self->type = OB_CLIENT_TYPE_DIALOG;
1416 else if (val[i] == prop_atoms.net_wm_window_type_normal)
1417 self->type = OB_CLIENT_TYPE_NORMAL;
1418 else if (val[i] == prop_atoms.kde_net_wm_window_type_override) {
1419 /* prevent this window from getting any decor or
1421 self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS |
1422 OB_MWM_FLAG_DECORATIONS);
1423 self->mwmhints.decorations = 0;
1424 self->mwmhints.functions = 0;
1426 if (self->type != (ObClientType) -1)
1427 break; /* grab the first legit type */
1432 if (XGetTransientForHint(ob_display, self->window, &t))
1433 self->transient = TRUE;
1435 if (self->type == (ObClientType) -1) {
1436 /*the window type hint was not set, which means we either classify
1437 ourself as a normal window or a dialog, depending on if we are a
1439 if (self->transient)
1440 self->type = OB_CLIENT_TYPE_DIALOG;
1442 self->type = OB_CLIENT_TYPE_NORMAL;
1445 /* then, based on our type, we can update our transientness.. */
1446 if (self->type == OB_CLIENT_TYPE_DIALOG ||
1447 self->type == OB_CLIENT_TYPE_TOOLBAR ||
1448 self->type == OB_CLIENT_TYPE_MENU ||
1449 self->type == OB_CLIENT_TYPE_UTILITY)
1451 self->transient = TRUE;
1455 void client_update_protocols(ObClient *self)
1458 guint num_return, i;
1460 self->focus_notify = FALSE;
1461 self->delete_window = FALSE;
1463 if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) {
1464 for (i = 0; i < num_return; ++i) {
1465 if (proto[i] == prop_atoms.wm_delete_window)
1466 /* this means we can request the window to close */
1467 self->delete_window = TRUE;
1468 else if (proto[i] == prop_atoms.wm_take_focus)
1469 /* if this protocol is requested, then the window will be
1470 notified whenever we want it to receive focus */
1471 self->focus_notify = TRUE;
1473 else if (proto[i] == prop_atoms.net_wm_sync_request)
1474 /* if this protocol is requested, then resizing the
1475 window will be synchronized between the frame and the
1477 self->sync_request = TRUE;
1485 void client_update_sync_request_counter(ObClient *self)
1489 if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) {
1490 self->sync_counter = i;
1492 self->sync_counter = None;
1496 void client_get_colormap(ObClient *self)
1498 XWindowAttributes wa;
1500 if (XGetWindowAttributes(ob_display, self->window, &wa))
1501 client_update_colormap(self, wa.colormap);
1504 void client_update_colormap(ObClient *self, Colormap colormap)
1506 if (colormap == self->colormap) return;
1508 ob_debug("Setting client %s colormap: 0x%x\n", self->title, colormap);
1510 if (client_focused(self)) {
1511 screen_install_colormap(self, FALSE); /* uninstall old one */
1512 self->colormap = colormap;
1513 screen_install_colormap(self, FALSE); /* install new one */
1515 self->colormap = colormap;
1518 void client_update_normal_hints(ObClient *self)
1524 self->min_ratio = 0.0f;
1525 self->max_ratio = 0.0f;
1526 SIZE_SET(self->size_inc, 1, 1);
1527 SIZE_SET(self->base_size, 0, 0);
1528 SIZE_SET(self->min_size, 0, 0);
1529 SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
1531 /* get the hints from the window */
1532 if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) {
1533 /* normal windows can't request placement! har har
1534 if (!client_normal(self))
1536 self->positioned = (size.flags & (PPosition|USPosition));
1537 self->sized = (size.flags & (PSize|USSize));
1539 if (size.flags & PWinGravity)
1540 self->gravity = size.win_gravity;
1542 if (size.flags & PAspect) {
1543 if (size.min_aspect.y)
1545 (gfloat) size.min_aspect.x / size.min_aspect.y;
1546 if (size.max_aspect.y)
1548 (gfloat) size.max_aspect.x / size.max_aspect.y;
1551 if (size.flags & PMinSize)
1552 SIZE_SET(self->min_size, size.min_width, size.min_height);
1554 if (size.flags & PMaxSize)
1555 SIZE_SET(self->max_size, size.max_width, size.max_height);
1557 if (size.flags & PBaseSize)
1558 SIZE_SET(self->base_size, size.base_width, size.base_height);
1560 if (size.flags & PResizeInc && size.width_inc && size.height_inc)
1561 SIZE_SET(self->size_inc, size.width_inc, size.height_inc);
1565 void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
1567 /* start with everything (cept fullscreen) */
1569 (OB_FRAME_DECOR_TITLEBAR |
1570 OB_FRAME_DECOR_HANDLE |
1571 OB_FRAME_DECOR_GRIPS |
1572 OB_FRAME_DECOR_BORDER |
1573 OB_FRAME_DECOR_ICON |
1574 OB_FRAME_DECOR_ALLDESKTOPS |
1575 OB_FRAME_DECOR_ICONIFY |
1576 OB_FRAME_DECOR_MAXIMIZE |
1577 OB_FRAME_DECOR_SHADE |
1578 OB_FRAME_DECOR_CLOSE);
1580 (OB_CLIENT_FUNC_RESIZE |
1581 OB_CLIENT_FUNC_MOVE |
1582 OB_CLIENT_FUNC_ICONIFY |
1583 OB_CLIENT_FUNC_MAXIMIZE |
1584 OB_CLIENT_FUNC_SHADE |
1585 OB_CLIENT_FUNC_CLOSE |
1586 OB_CLIENT_FUNC_BELOW |
1587 OB_CLIENT_FUNC_ABOVE |
1588 OB_CLIENT_FUNC_UNDECORATE);
1590 if (!(self->min_size.width < self->max_size.width ||
1591 self->min_size.height < self->max_size.height))
1592 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1594 switch (self->type) {
1595 case OB_CLIENT_TYPE_NORMAL:
1596 /* normal windows retain all of the possible decorations and
1597 functionality, and are the only windows that you can fullscreen */
1598 self->functions |= OB_CLIENT_FUNC_FULLSCREEN;
1601 case OB_CLIENT_TYPE_DIALOG:
1602 case OB_CLIENT_TYPE_UTILITY:
1603 /* these windows don't have anything added or removed by default */
1606 case OB_CLIENT_TYPE_MENU:
1607 case OB_CLIENT_TYPE_TOOLBAR:
1608 /* these windows can't iconify or maximize */
1609 self->decorations &= ~(OB_FRAME_DECOR_ICONIFY |
1610 OB_FRAME_DECOR_MAXIMIZE);
1611 self->functions &= ~(OB_CLIENT_FUNC_ICONIFY |
1612 OB_CLIENT_FUNC_MAXIMIZE);
1615 case OB_CLIENT_TYPE_SPLASH:
1616 /* these don't get get any decorations, and the only thing you can
1617 do with them is move them */
1618 self->decorations = 0;
1619 self->functions = OB_CLIENT_FUNC_MOVE;
1622 case OB_CLIENT_TYPE_DESKTOP:
1623 /* these windows are not manipulated by the window manager */
1624 self->decorations = 0;
1625 self->functions = 0;
1628 case OB_CLIENT_TYPE_DOCK:
1629 /* these windows are not manipulated by the window manager, but they
1630 can set below layer which has a special meaning */
1631 self->decorations = 0;
1632 self->functions = OB_CLIENT_FUNC_BELOW;
1636 /* Mwm Hints are applied subtractively to what has already been chosen for
1637 decor and functionality */
1638 if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
1639 if (! (self->mwmhints.decorations & OB_MWM_DECOR_ALL)) {
1640 if (! ((self->mwmhints.decorations & OB_MWM_DECOR_HANDLE) ||
1641 (self->mwmhints.decorations & OB_MWM_DECOR_TITLE)))
1643 /* if the mwm hints request no handle or title, then all
1644 decorations are disabled, but keep the border if that's
1646 if (self->mwmhints.decorations & OB_MWM_DECOR_BORDER)
1647 self->decorations = OB_FRAME_DECOR_BORDER;
1649 self->decorations = 0;
1654 if (self->mwmhints.flags & OB_MWM_FLAG_FUNCTIONS) {
1655 if (! (self->mwmhints.functions & OB_MWM_FUNC_ALL)) {
1656 if (! (self->mwmhints.functions & OB_MWM_FUNC_RESIZE))
1657 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1658 if (! (self->mwmhints.functions & OB_MWM_FUNC_MOVE))
1659 self->functions &= ~OB_CLIENT_FUNC_MOVE;
1660 /* dont let mwm hints kill any buttons
1661 if (! (self->mwmhints.functions & OB_MWM_FUNC_ICONIFY))
1662 self->functions &= ~OB_CLIENT_FUNC_ICONIFY;
1663 if (! (self->mwmhints.functions & OB_MWM_FUNC_MAXIMIZE))
1664 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1666 /* dont let mwm hints kill the close button
1667 if (! (self->mwmhints.functions & MwmFunc_Close))
1668 self->functions &= ~OB_CLIENT_FUNC_CLOSE; */
1672 if (!(self->functions & OB_CLIENT_FUNC_SHADE))
1673 self->decorations &= ~OB_FRAME_DECOR_SHADE;
1674 if (!(self->functions & OB_CLIENT_FUNC_ICONIFY))
1675 self->decorations &= ~OB_FRAME_DECOR_ICONIFY;
1676 if (!(self->functions & OB_CLIENT_FUNC_RESIZE))
1677 self->decorations &= ~(OB_FRAME_DECOR_GRIPS | OB_FRAME_DECOR_HANDLE);
1679 /* can't maximize without moving/resizing */
1680 if (!((self->functions & OB_CLIENT_FUNC_MAXIMIZE) &&
1681 (self->functions & OB_CLIENT_FUNC_MOVE) &&
1682 (self->functions & OB_CLIENT_FUNC_RESIZE))) {
1683 self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
1684 self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
1687 if (self->max_horz && self->max_vert) {
1688 /* you can't resize fully maximized windows */
1689 self->functions &= ~OB_CLIENT_FUNC_RESIZE;
1690 /* kill the handle on fully maxed windows */
1691 self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
1694 /* If there are no decorations to remove, don't allow the user to try
1696 if (self->decorations == 0)
1697 self->functions &= ~OB_CLIENT_FUNC_UNDECORATE;
1699 /* finally, the user can have requested no decorations, which overrides
1700 everything (but doesnt give it a border if it doesnt have one) */
1701 if (self->undecorated) {
1702 if (config_theme_keepborder)
1703 self->decorations &= OB_FRAME_DECOR_BORDER;
1705 self->decorations = 0;
1708 /* if we don't have a titlebar, then we cannot shade! */
1709 if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
1710 self->functions &= ~OB_CLIENT_FUNC_SHADE;
1712 /* now we need to check against rules for the client's current state */
1713 if (self->fullscreen) {
1714 self->functions &= (OB_CLIENT_FUNC_CLOSE |
1715 OB_CLIENT_FUNC_FULLSCREEN |
1716 OB_CLIENT_FUNC_ICONIFY);
1717 self->decorations = 0;
1720 client_change_allowed_actions(self);
1723 client_reconfigure(self);
1726 static void client_change_allowed_actions(ObClient *self)
1731 /* desktop windows are kept on all desktops */
1732 if (self->type != OB_CLIENT_TYPE_DESKTOP)
1733 actions[num++] = prop_atoms.net_wm_action_change_desktop;
1735 if (self->functions & OB_CLIENT_FUNC_SHADE)
1736 actions[num++] = prop_atoms.net_wm_action_shade;
1737 if (self->functions & OB_CLIENT_FUNC_CLOSE)
1738 actions[num++] = prop_atoms.net_wm_action_close;
1739 if (self->functions & OB_CLIENT_FUNC_MOVE)
1740 actions[num++] = prop_atoms.net_wm_action_move;
1741 if (self->functions & OB_CLIENT_FUNC_ICONIFY)
1742 actions[num++] = prop_atoms.net_wm_action_minimize;
1743 if (self->functions & OB_CLIENT_FUNC_RESIZE)
1744 actions[num++] = prop_atoms.net_wm_action_resize;
1745 if (self->functions & OB_CLIENT_FUNC_FULLSCREEN)
1746 actions[num++] = prop_atoms.net_wm_action_fullscreen;
1747 if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) {
1748 actions[num++] = prop_atoms.net_wm_action_maximize_horz;
1749 actions[num++] = prop_atoms.net_wm_action_maximize_vert;
1751 if (self->functions & OB_CLIENT_FUNC_ABOVE)
1752 actions[num++] = prop_atoms.net_wm_action_above;
1753 if (self->functions & OB_CLIENT_FUNC_BELOW)
1754 actions[num++] = prop_atoms.net_wm_action_below;
1755 if (self->functions & OB_CLIENT_FUNC_UNDECORATE)
1756 actions[num++] = prop_atoms.ob_wm_action_undecorate;
1758 PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num);
1760 /* make sure the window isn't breaking any rules now */
1762 if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) {
1763 if (self->frame) client_shade(self, FALSE);
1764 else self->shaded = FALSE;
1766 if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) {
1767 if (self->frame) client_iconify(self, FALSE, TRUE, FALSE);
1768 else self->iconic = FALSE;
1770 if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) {
1771 if (self->frame) client_fullscreen(self, FALSE);
1772 else self->fullscreen = FALSE;
1774 if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE) && (self->max_horz ||
1776 if (self->frame) client_maximize(self, FALSE, 0);
1777 else self->max_vert = self->max_horz = FALSE;
1781 void client_reconfigure(ObClient *self)
1783 client_configure(self, self->area.x, self->area.y,
1784 self->area.width, self->area.height,
1788 void client_update_wmhints(ObClient *self)
1792 /* assume a window takes input if it doesnt specify */
1793 self->can_focus = TRUE;
1795 if ((hints = XGetWMHints(ob_display, self->window)) != NULL) {
1798 if (hints->flags & InputHint)
1799 self->can_focus = hints->input;
1801 /* only do this when first managing the window *AND* when we aren't
1803 if (ob_state() != OB_STATE_STARTING && self->frame == NULL)
1804 if (hints->flags & StateHint)
1805 self->iconic = hints->initial_state == IconicState;
1808 self->urgent = (hints->flags & XUrgencyHint);
1809 if (self->urgent && !ur)
1810 client_hilite(self, TRUE);
1811 else if (!self->urgent && ur && self->demands_attention)
1812 client_hilite(self, FALSE);
1814 if (!(hints->flags & WindowGroupHint))
1815 hints->window_group = None;
1817 /* did the group state change? */
1818 if (hints->window_group !=
1819 (self->group ? self->group->leader : None))
1821 ObGroup *oldgroup = self->group;
1823 /* remove from the old group if there was one */
1824 if (self->group != NULL) {
1825 group_remove(self->group, self);
1829 /* add ourself to the group if we have one */
1830 if (hints->window_group != None) {
1831 self->group = group_add(hints->window_group, self);
1834 /* Put ourselves into the new group's transient tree, and remove
1835 ourselves from the old group's */
1836 client_update_transient_tree(self, oldgroup, self->group,
1837 self->transient_for,
1838 self->transient_for);
1840 /* Lastly, being in a group, or not, can change if the window is
1841 transient for anything.
1843 The logic for this is:
1844 self->transient = TRUE always if the window wants to be
1845 transient for something, even if transient_for was NULL because
1846 it wasn't in a group before.
1848 If parents was NULL and oldgroup was NULL we can assume
1849 that when we add the new group, it will become transient for
1852 If transient_for was OB_TRAN_GROUP, then it must have already
1853 had a group. If it is getting a new group, the above call to
1854 client_update_transient_tree has already taken care of
1855 everything ! If it is losing all group status then it will
1856 no longer be transient for anything and that needs to be
1859 if (self->transient &&
1860 ((self->parents == NULL && oldgroup == NULL) ||
1861 (self->transient_for == OB_TRAN_GROUP && !self->group)))
1862 client_update_transient_for(self);
1865 /* the WM_HINTS can contain an icon */
1866 if (hints->flags & IconPixmapHint)
1867 client_update_icons(self);
1873 void client_update_title(ObClient *self)
1876 gchar *visible = NULL;
1878 g_free(self->title);
1881 if (!PROP_GETS(self->window, net_wm_name, utf8, &data)) {
1882 /* try old x stuff */
1883 if (!(PROP_GETS(self->window, wm_name, locale, &data)
1884 || PROP_GETS(self->window, wm_name, utf8, &data))) {
1885 if (self->transient) {
1887 GNOME alert windows are not given titles:
1888 http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
1890 data = g_strdup("");
1892 data = g_strdup("Unnamed Window");
1896 if (self->client_machine) {
1897 visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1902 PROP_SETS(self->window, net_wm_visible_name, visible);
1903 self->title = visible;
1906 frame_adjust_title(self->frame);
1908 /* update the icon title */
1910 g_free(self->icon_title);
1913 if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
1914 /* try old x stuff */
1915 if (!(PROP_GETS(self->window, wm_icon_name, locale, &data) ||
1916 PROP_GETS(self->window, wm_icon_name, utf8, &data)))
1917 data = g_strdup(self->title);
1919 if (self->client_machine) {
1920 visible = g_strdup_printf("%s (%s)", data, self->client_machine);
1925 PROP_SETS(self->window, net_wm_visible_icon_name, visible);
1926 self->icon_title = visible;
1929 void client_update_strut(ObClient *self)
1933 gboolean got = FALSE;
1936 if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal,
1940 STRUT_PARTIAL_SET(strut,
1941 data[0], data[2], data[1], data[3],
1942 data[4], data[5], data[8], data[9],
1943 data[6], data[7], data[10], data[11]);
1949 PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) {
1955 /* use the screen's width/height */
1956 a = screen_physical_area();
1958 STRUT_PARTIAL_SET(strut,
1959 data[0], data[2], data[1], data[3],
1960 a->y, a->y + a->height - 1,
1961 a->x, a->x + a->width - 1,
1962 a->y, a->y + a->height - 1,
1963 a->x, a->x + a->width - 1);
1969 STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
1970 0, 0, 0, 0, 0, 0, 0, 0);
1972 if (!STRUT_EQUAL(strut, self->strut)) {
1973 self->strut = strut;
1975 /* updating here is pointless while we're being mapped cuz we're not in
1976 the client list yet */
1978 screen_update_areas();
1982 void client_update_icons(ObClient *self)
1988 for (i = 0; i < self->nicons; ++i)
1989 g_free(self->icons[i].data);
1990 if (self->nicons > 0)
1991 g_free(self->icons);
1994 if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) {
1995 /* figure out how many valid icons are in here */
1997 while (num - i > 2) {
2001 if (i > num || w*h == 0) break;
2005 self->icons = g_new(ObClientIcon, self->nicons);
2007 /* store the icons */
2009 for (j = 0; j < self->nicons; ++j) {
2012 w = self->icons[j].width = data[i++];
2013 h = self->icons[j].height = data[i++];
2015 if (w*h == 0) continue;
2017 self->icons[j].data = g_new(RrPixel32, w * h);
2018 for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
2023 self->icons[j].data[t] =
2024 (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
2025 (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
2026 (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
2027 (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
2036 if ((hints = XGetWMHints(ob_display, self->window))) {
2037 if (hints->flags & IconPixmapHint) {
2039 self->icons = g_new(ObClientIcon, self->nicons);
2040 xerror_set_ignore(TRUE);
2041 if (!RrPixmapToRGBA(ob_rr_inst,
2043 (hints->flags & IconMaskHint ?
2044 hints->icon_mask : None),
2045 &self->icons[self->nicons-1].width,
2046 &self->icons[self->nicons-1].height,
2047 &self->icons[self->nicons-1].data)){
2048 g_free(&self->icons[self->nicons-1]);
2051 xerror_set_ignore(FALSE);
2057 /* set the default icon onto the window
2058 in theory, this could be a race, but if a window doesn't set an icon
2059 or removes it entirely, it's not very likely it is going to set one
2060 right away afterwards */
2061 if (self->nicons == 0) {
2062 RrPixel32 *icon = ob_rr_theme->def_win_icon;
2065 data = g_new(gulong, 48*48+2);
2066 data[0] = data[1] = 48;
2067 for (i = 0; i < 48*48; ++i)
2068 data[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
2069 (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
2070 (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
2071 (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
2072 PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2);
2074 } else if (self->frame)
2075 /* don't draw the icon empty if we're just setting one now anyways,
2076 we'll get the property change any second */
2077 frame_adjust_icon(self->frame);
2080 void client_update_user_time(ObClient *self)
2083 gboolean got = FALSE;
2085 if (self->user_time_window)
2086 got = PROP_GET32(self->user_time_window,
2087 net_wm_user_time, cardinal, &time);
2089 got = PROP_GET32(self->window, net_wm_user_time, cardinal, &time);
2092 /* we set this every time, not just when it grows, because in practice
2093 sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes
2094 backward we don't want all windows to stop focusing. we'll just
2095 assume noone is setting times older than the last one, cuz that
2096 would be pretty stupid anyways
2098 self->user_time = time;
2100 /*ob_debug("window %s user time %u\n", self->title, time);*/
2104 void client_update_user_time_window(ObClient *self)
2108 if (!PROP_GET32(self->window, net_wm_user_time_window, window, &w))
2111 if (w != self->user_time_window) {
2112 /* remove the old window */
2113 propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self);
2114 self->user_time_window = None;
2116 if (self->group && self->group->leader == w) {
2117 ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
2118 "_NET_WM_USER_TYPE_WINDOW to its group leader\n");
2119 /* do it anyways..? */
2121 else if (w == self->window) {
2122 ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its "
2123 "_NET_WM_USER_TIME_WINDOW to itself\n");
2124 w = None; /* don't do it */
2127 /* add the new window */
2128 propwin_add(w, OB_PROPWIN_USER_TIME, self);
2129 self->user_time_window = w;
2131 /* and update from it */
2132 client_update_user_time(self);
2136 void client_update_icon_geometry(ObClient *self)
2141 RECT_SET(self->icon_geometry, 0, 0, 0, 0);
2143 if (PROP_GETA32(self->window, net_wm_icon_geometry, cardinal, &data, &num)
2146 /* don't let them set it with an area < 0 */
2147 RECT_SET(self->icon_geometry, data[0], data[1],
2148 MAX(data[2],0), MAX(data[3],0));
2152 static void client_get_session_ids(ObClient *self)
2159 if (!PROP_GET32(self->window, wm_client_leader, window, &leader))
2162 /* get the SM_CLIENT_ID */
2165 got = PROP_GETS(leader, sm_client_id, locale, &self->sm_client_id);
2167 PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id);
2169 /* get the WM_CLASS (name and class). make them "" if they are not
2173 got = PROP_GETSS(leader, wm_class, locale, &ss);
2175 got = PROP_GETSS(self->window, wm_class, locale, &ss);
2179 self->name = g_strdup(ss[0]);
2181 self->class = g_strdup(ss[1]);
2186 if (self->name == NULL) self->name = g_strdup("");
2187 if (self->class == NULL) self->class = g_strdup("");
2189 /* get the WM_WINDOW_ROLE. make it "" if it is not provided */
2192 got = PROP_GETS(leader, wm_window_role, locale, &s);
2194 got = PROP_GETS(self->window, wm_window_role, locale, &s);
2199 self->role = g_strdup("");
2201 /* get the WM_COMMAND */
2205 got = PROP_GETSS(leader, wm_command, locale, &ss);
2207 got = PROP_GETSS(self->window, wm_command, locale, &ss);
2210 /* merge/mash them all together */
2211 gchar *merge = NULL;
2214 for (i = 0; ss[i]; ++i) {
2217 merge = g_strconcat(merge, ss[i], NULL);
2219 merge = g_strconcat(ss[i], NULL);
2224 self->wm_command = merge;
2227 /* get the WM_CLIENT_MACHINE */
2230 got = PROP_GETS(leader, wm_client_machine, locale, &s);
2232 got = PROP_GETS(self->window, wm_client_machine, locale, &s);
2235 gchar localhost[128];
2237 gethostname(localhost, 127);
2238 localhost[127] = '\0';
2239 if (strcmp(localhost, s) != 0)
2240 self->client_machine = s;
2246 static void client_change_wm_state(ObClient *self)
2251 old = self->wmstate;
2253 if (self->shaded || self->iconic ||
2254 (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop))
2256 self->wmstate = IconicState;
2258 self->wmstate = NormalState;
2260 if (old != self->wmstate) {
2261 PROP_MSG(self->window, kde_wm_change_state,
2262 self->wmstate, 1, 0, 0);
2264 state[0] = self->wmstate;
2266 PROP_SETA32(self->window, wm_state, wm_state, state, 2);
2270 static void client_change_state(ObClient *self)
2272 gulong netstate[12];
2277 netstate[num++] = prop_atoms.net_wm_state_modal;
2279 netstate[num++] = prop_atoms.net_wm_state_shaded;
2281 netstate[num++] = prop_atoms.net_wm_state_hidden;
2282 if (self->skip_taskbar)
2283 netstate[num++] = prop_atoms.net_wm_state_skip_taskbar;
2284 if (self->skip_pager)
2285 netstate[num++] = prop_atoms.net_wm_state_skip_pager;
2286 if (self->fullscreen)
2287 netstate[num++] = prop_atoms.net_wm_state_fullscreen;
2289 netstate[num++] = prop_atoms.net_wm_state_maximized_vert;
2291 netstate[num++] = prop_atoms.net_wm_state_maximized_horz;
2293 netstate[num++] = prop_atoms.net_wm_state_above;
2295 netstate[num++] = prop_atoms.net_wm_state_below;
2296 if (self->demands_attention)
2297 netstate[num++] = prop_atoms.net_wm_state_demands_attention;
2298 if (self->undecorated)
2299 netstate[num++] = prop_atoms.ob_wm_state_undecorated;
2300 PROP_SETA32(self->window, net_wm_state, atom, netstate, num);
2303 frame_adjust_state(self->frame);
2306 ObClient *client_search_focus_tree(ObClient *self)
2311 for (it = self->transients; it; it = g_slist_next(it)) {
2312 if (client_focused(it->data)) return it->data;
2313 if ((ret = client_search_focus_tree(it->data))) return ret;
2318 ObClient *client_search_focus_tree_full(ObClient *self)
2320 if (self->parents) {
2323 for (it = self->parents; it; it = g_slist_next(it)) {
2324 ObClient *c = it->data;
2325 if ((c = client_search_focus_tree_full(it->data))) return c;
2331 /* this function checks the whole tree, the client_search_focus_tree
2332 does not, so we need to check this window */
2333 if (client_focused(self))
2335 return client_search_focus_tree(self);
2339 ObClient *client_search_focus_group_full(ObClient *self)
2344 for (it = self->group->members; it; it = g_slist_next(it)) {
2345 ObClient *c = it->data;
2347 if (client_focused(c)) return c;
2348 if ((c = client_search_focus_tree(it->data))) return c;
2351 if (client_focused(self)) return self;
2355 gboolean client_has_parent(ObClient *self)
2357 return self->parents != NULL;
2360 static ObStackingLayer calc_layer(ObClient *self)
2364 if (self->type == OB_CLIENT_TYPE_DESKTOP)
2365 l = OB_STACKING_LAYER_DESKTOP;
2366 else if (self->type == OB_CLIENT_TYPE_DOCK) {
2367 if (self->below) l = OB_STACKING_LAYER_NORMAL;
2368 else l = OB_STACKING_LAYER_ABOVE;
2370 else if ((self->fullscreen ||
2371 /* No decorations and fills the monitor = oldskool fullscreen.
2372 But not for maximized windows.
2374 (self->decorations == 0 &&
2375 !(self->max_horz && self->max_vert) &&
2376 RECT_EQUAL(self->area,
2377 *screen_physical_area_monitor
2378 (client_monitor(self))))) &&
2379 (client_focused(self) || client_search_focus_tree(self)))
2380 l = OB_STACKING_LAYER_FULLSCREEN;
2381 else if (self->above) l = OB_STACKING_LAYER_ABOVE;
2382 else if (self->below) l = OB_STACKING_LAYER_BELOW;
2383 else l = OB_STACKING_LAYER_NORMAL;
2388 static void client_calc_layer_recursive(ObClient *self, ObClient *orig,
2389 ObStackingLayer min)
2391 ObStackingLayer old, own;
2395 own = calc_layer(self);
2396 self->layer = MAX(own, min);
2398 if (self->layer != old) {
2399 stacking_remove(CLIENT_AS_WINDOW(self));
2400 stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
2403 for (it = self->transients; it; it = g_slist_next(it))
2404 client_calc_layer_recursive(it->data, orig,
2408 void client_calc_layer(ObClient *self)
2415 /* transients take on the layer of their parents */
2416 it = client_search_all_top_parents(self);
2418 for (; it; it = g_slist_next(it))
2419 client_calc_layer_recursive(it->data, orig, 0);
2422 gboolean client_should_show(ObClient *self)
2426 if (client_normal(self) && screen_showing_desktop)
2428 if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL)
2434 gboolean client_show(ObClient *self)
2436 gboolean show = FALSE;
2438 if (client_should_show(self)) {
2439 frame_show(self->frame);
2442 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2443 it needs to be in IconicState. This includes when it is on another
2446 client_change_wm_state(self);
2451 gboolean client_hide(ObClient *self)
2453 gboolean hide = FALSE;
2455 if (!client_should_show(self)) {
2456 if (self == focus_client) {
2457 /* if there is a grab going on, then we need to cancel it. if we
2458 move focus during the grab, applications will get
2459 NotifyWhileGrabbed events and ignore them !
2461 actions should not rely on being able to move focus during an
2464 event_cancel_all_key_grabs();
2467 frame_hide(self->frame);
2470 /* According to the ICCCM (sec 4.1.3.1) when a window is not visible,
2471 it needs to be in IconicState. This includes when it is on another
2474 client_change_wm_state(self);
2479 void client_showhide(ObClient *self)
2481 if (!client_show(self))
2485 gboolean client_normal(ObClient *self) {
2486 return ! (self->type == OB_CLIENT_TYPE_DESKTOP ||
2487 self->type == OB_CLIENT_TYPE_DOCK ||
2488 self->type == OB_CLIENT_TYPE_SPLASH);
2491 gboolean client_helper(ObClient *self)
2493 return (self->type == OB_CLIENT_TYPE_UTILITY ||
2494 self->type == OB_CLIENT_TYPE_MENU ||
2495 self->type == OB_CLIENT_TYPE_TOOLBAR);
2498 gboolean client_mouse_focusable(ObClient *self)
2500 return !(self->type == OB_CLIENT_TYPE_MENU ||
2501 self->type == OB_CLIENT_TYPE_TOOLBAR ||
2502 self->type == OB_CLIENT_TYPE_SPLASH ||
2503 self->type == OB_CLIENT_TYPE_DOCK);
2506 gboolean client_enter_focusable(ObClient *self)
2508 /* you can focus desktops but it shouldn't on enter */
2509 return (client_mouse_focusable(self) &&
2510 self->type != OB_CLIENT_TYPE_DESKTOP);
2514 static void client_apply_startup_state(ObClient *self,
2515 gint x, gint y, gint w, gint h)
2517 /* save the states that we are going to apply */
2518 gboolean iconic = self->iconic;
2519 gboolean fullscreen = self->fullscreen;
2520 gboolean undecorated = self->undecorated;
2521 gboolean shaded = self->shaded;
2522 gboolean demands_attention = self->demands_attention;
2523 gboolean max_horz = self->max_horz;
2524 gboolean max_vert = self->max_vert;
2528 /* turn them all off in the client, so they won't affect the window
2530 self->iconic = self->fullscreen = self->undecorated = self->shaded =
2531 self->demands_attention = self->max_horz = self->max_vert = FALSE;
2533 /* move the client to its placed position, or it it's already there,
2534 generate a ConfigureNotify telling the client where it is.
2536 do this after adjusting the frame. otherwise it gets all weird and
2537 clients don't work right
2539 do this before applying the states so they have the correct
2540 pre-max/pre-fullscreen values
2542 client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE);
2543 ob_debug("placed window 0x%x at %d, %d with size %d x %d\n",
2544 self->window, self->area.x, self->area.y,
2545 self->area.width, self->area.height);
2546 oldarea = self->area; /* save the area */
2547 RECT_SET(self->area, x, y, w, h); /* put where it should be for the premax stuff */
2549 /* apply the states. these are in a carefully crafted order.. */
2552 client_iconify(self, TRUE, FALSE, TRUE);
2554 client_fullscreen(self, TRUE);
2556 client_set_undecorated(self, TRUE);
2558 client_shade(self, TRUE);
2559 if (demands_attention)
2560 client_hilite(self, TRUE);
2562 if (max_vert && max_horz)
2563 client_maximize(self, TRUE, 0);
2565 client_maximize(self, TRUE, 2);
2567 client_maximize(self, TRUE, 1);
2569 /* if the window hasn't been configured yet, then do so now */
2570 if (!fullscreen && !max_vert && !max_horz) {
2571 self->area = oldarea;
2572 client_configure(self, x, y, w, h, FALSE, TRUE);
2575 /* set the desktop hint, to make sure that it always exists */
2576 PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
2578 /* nothing to do for the other states:
2587 void client_gravity_resize_w(ObClient *self, gint *x, gint oldw, gint neww)
2589 /* these should be the current values. this is for when you're not moving,
2591 g_assert(*x == self->area.x);
2592 g_assert(oldw == self->area.width);
2595 switch (self->gravity) {
2597 case NorthWestGravity:
2599 case SouthWestGravity:
2606 *x -= (neww - oldw) / 2;
2608 case NorthEastGravity:
2610 case SouthEastGravity:
2616 void client_gravity_resize_h(ObClient *self, gint *y, gint oldh, gint newh)
2618 /* these should be the current values. this is for when you're not moving,
2620 g_assert(*y == self->area.y);
2621 g_assert(oldh == self->area.height);
2624 switch (self->gravity) {
2626 case NorthWestGravity:
2628 case NorthEastGravity:
2635 *y -= (newh - oldh) / 2;
2637 case SouthWestGravity:
2639 case SouthEastGravity:
2645 void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h,
2646 gint *logicalw, gint *logicalh,
2649 Rect desired_area = {*x, *y, *w, *h};
2651 /* make the frame recalculate its dimentions n shit without changing
2652 anything visible for real, this way the constraints below can work with
2653 the updated frame dimensions. */
2654 frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
2656 /* work within the prefered sizes given by the window */
2657 if (!(*w == self->area.width && *h == self->area.height)) {
2658 gint basew, baseh, minw, minh;
2660 /* base size is substituted with min size if not specified */
2661 if (self->base_size.width || self->base_size.height) {
2662 basew = self->base_size.width;
2663 baseh = self->base_size.height;
2665 basew = self->min_size.width;
2666 baseh = self->min_size.height;
2668 /* min size is substituted with base size if not specified */
2669 if (self->min_size.width || self->min_size.height) {
2670 minw = self->min_size.width;
2671 minh = self->min_size.height;
2673 minw = self->base_size.width;
2674 minh = self->base_size.height;
2677 /* if this is a user-requested resize, then check against min/max
2680 /* smaller than min size or bigger than max size? */
2681 if (*w > self->max_size.width) *w = self->max_size.width;
2682 if (*w < minw) *w = minw;
2683 if (*h > self->max_size.height) *h = self->max_size.height;
2684 if (*h < minh) *h = minh;
2689 /* keep to the increments */
2690 *w /= self->size_inc.width;
2691 *h /= self->size_inc.height;
2693 /* you cannot resize to nothing */
2694 if (basew + *w < 1) *w = 1 - basew;
2695 if (baseh + *h < 1) *h = 1 - baseh;
2697 /* save the logical size */
2698 *logicalw = self->size_inc.width > 1 ? *w : *w + basew;
2699 *logicalh = self->size_inc.height > 1 ? *h : *h + baseh;
2701 *w *= self->size_inc.width;
2702 *h *= self->size_inc.height;
2707 /* adjust the height to match the width for the aspect ratios.
2708 for this, min size is not substituted for base size ever. */
2709 *w -= self->base_size.width;
2710 *h -= self->base_size.height;
2712 if (!self->fullscreen) {
2713 if (self->min_ratio)
2714 if (*h * self->min_ratio > *w) {
2715 *h = (gint)(*w / self->min_ratio);
2717 /* you cannot resize to nothing */
2720 *w = (gint)(*h * self->min_ratio);
2723 if (self->max_ratio)
2724 if (*h * self->max_ratio < *w) {
2725 *h = (gint)(*w / self->max_ratio);
2727 /* you cannot resize to nothing */
2730 *w = (gint)(*h * self->min_ratio);
2735 *w += self->base_size.width;
2736 *h += self->base_size.height;
2739 /* gets the frame's position */
2740 frame_client_gravity(self->frame, x, y, *w, *h);
2742 /* these positions are frame positions, not client positions */
2744 /* set the size and position if fullscreen */
2745 if (self->fullscreen) {
2749 i = screen_find_monitor(&desired_area);
2750 a = screen_physical_area_monitor(i);
2757 user = FALSE; /* ignore if the client can't be moved/resized when it
2759 } else if (self->max_horz || self->max_vert) {
2763 i = screen_find_monitor(&desired_area);
2764 a = screen_area_monitor(self->desktop, i);
2766 /* set the size and position if maximized */
2767 if (self->max_horz) {
2769 *w = a->width - self->frame->size.left - self->frame->size.right;
2771 if (self->max_vert) {
2773 *h = a->height - self->frame->size.top - self->frame->size.bottom;
2776 user = FALSE; /* ignore if the client can't be moved/resized when it
2780 /* gets the client's position */
2781 frame_frame_gravity(self->frame, x, y, *w, *h);
2783 /* these override the above states! if you cant move you can't move! */
2785 if (!(self->functions & OB_CLIENT_FUNC_MOVE)) {
2789 if (!(self->functions & OB_CLIENT_FUNC_RESIZE)) {
2790 *w = self->area.width;
2791 *h = self->area.height;
2800 void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
2801 gboolean user, gboolean final)
2804 gboolean send_resize_client;
2805 gboolean moved = FALSE, resized = FALSE;
2806 gboolean fmoved, fresized;
2807 guint fdecor = self->frame->decorations;
2808 gboolean fhorz = self->frame->max_horz;
2809 gboolean fvert = self->frame->max_vert;
2810 gint logicalw, logicalh;
2812 /* find the new x, y, width, and height (and logical size) */
2813 client_try_configure(self, &x, &y, &w, &h, &logicalw, &logicalh, user);
2815 /* set the logical size if things changed */
2816 if (!(w == self->area.width && h == self->area.height))
2817 SIZE_SET(self->logical_size, logicalw, logicalh);
2819 /* figure out if we moved or resized or what */
2820 moved = (x != self->area.x || y != self->area.y);
2821 resized = (w != self->area.width || h != self->area.height);
2823 oldw = self->area.width;
2824 oldh = self->area.height;
2825 RECT_SET(self->area, x, y, w, h);
2827 /* for app-requested resizes, always resize if 'resized' is true.
2828 for user-requested ones, only resize if final is true, or when
2829 resizing in redraw mode */
2830 send_resize_client = ((!user && resized) ||
2832 (resized && config_resize_redraw))));
2834 /* if the client is enlarging, then resize the client before the frame */
2835 if (send_resize_client && (w > oldw || h > oldh)) {
2836 XMoveResizeWindow(ob_display, self->window,
2837 self->frame->size.left, self->frame->size.top,
2838 MAX(w, oldw), MAX(h, oldh));
2839 frame_adjust_client_area(self->frame);
2842 /* find the frame's dimensions and move/resize it */
2846 /* if decorations changed, then readjust everything for the frame */
2847 if (self->decorations != fdecor ||
2848 self->max_horz != fhorz || self->max_vert != fvert)
2850 fmoved = fresized = TRUE;
2853 /* adjust the frame */
2854 if (fmoved || fresized)
2855 frame_adjust_area(self->frame, fmoved, fresized, FALSE);
2857 /* This is kinda tricky and should not be changed.. let me explain!
2859 When user = FALSE, then the request is coming from the application
2860 itself, and we are more strict about when to send a synthetic
2861 ConfigureNotify. We strictly follow the rules of the ICCCM sec 4.1.5
2864 When user = TRUE, then the request is coming from "us", like when we
2865 maximize a window or sometihng. In this case we are more lenient. We
2866 used to follow the same rules as above, but _Java_ Swing can't handle
2867 this. So just to appease Swing, when user = TRUE, we always send
2868 a synthetic ConfigureNotify to give the window its root coordinates.
2870 if ((!user && !resized) || (user && final))
2874 /* we have reset the client to 0 border width, so don't include
2875 it in these coords */
2876 POINT_SET(self->root_pos,
2877 self->frame->area.x + self->frame->size.left -
2879 self->frame->area.y + self->frame->size.top -
2880 self->border_width);
2882 event.type = ConfigureNotify;
2883 event.xconfigure.display = ob_display;
2884 event.xconfigure.event = self->window;
2885 event.xconfigure.window = self->window;
2887 ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n",
2888 self->title, self->root_pos.x, self->root_pos.y, w, h);
2890 /* root window real coords */
2891 event.xconfigure.x = self->root_pos.x;
2892 event.xconfigure.y = self->root_pos.y;
2893 event.xconfigure.width = w;
2894 event.xconfigure.height = h;
2895 event.xconfigure.border_width = self->border_width;
2896 event.xconfigure.above = None;
2897 event.xconfigure.override_redirect = FALSE;
2898 XSendEvent(event.xconfigure.display, event.xconfigure.window,
2899 FALSE, StructureNotifyMask, &event);
2902 /* if the client is shrinking, then resize the frame before the client.
2904 both of these resize sections may run, because the top one only resizes
2905 in the direction that is growing
2907 if (send_resize_client && (w <= oldw || h <= oldh)) {
2908 frame_adjust_client_area(self->frame);
2909 XMoveResizeWindow(ob_display, self->window,
2910 self->frame->size.left, self->frame->size.top, w, h);
2916 void client_fullscreen(ObClient *self, gboolean fs)
2920 if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) || /* can't */
2921 self->fullscreen == fs) return; /* already done */
2923 self->fullscreen = fs;
2924 client_change_state(self); /* change the state hints on the client */
2927 self->pre_fullscreen_area = self->area;
2928 /* if the window is maximized, its area isn't all that meaningful.
2929 save it's premax area instead. */
2930 if (self->max_horz) {
2931 self->pre_fullscreen_area.x = self->pre_max_area.x;
2932 self->pre_fullscreen_area.width = self->pre_max_area.width;
2934 if (self->max_vert) {
2935 self->pre_fullscreen_area.y = self->pre_max_area.y;
2936 self->pre_fullscreen_area.height = self->pre_max_area.height;
2939 /* these will help configure_full figure out where to fullscreen
2943 w = self->area.width;
2944 h = self->area.height;
2946 g_assert(self->pre_fullscreen_area.width > 0 &&
2947 self->pre_fullscreen_area.height > 0);
2949 x = self->pre_fullscreen_area.x;
2950 y = self->pre_fullscreen_area.y;
2951 w = self->pre_fullscreen_area.width;
2952 h = self->pre_fullscreen_area.height;
2953 RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0);
2956 client_setup_decor_and_functions(self, FALSE);
2957 client_move_resize(self, x, y, w, h);
2959 /* and adjust our layer/stacking. do this after resizing the window,
2960 and applying decorations, because windows which fill the screen are
2961 considered "fullscreen" and it affects their layer */
2962 client_calc_layer(self);
2965 /* try focus us when we go into fullscreen mode */
2970 static void client_iconify_recursive(ObClient *self,
2971 gboolean iconic, gboolean curdesk,
2972 gboolean hide_animation)
2975 gboolean changed = FALSE;
2978 if (self->iconic != iconic) {
2979 ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
2983 /* don't let non-normal windows iconify along with their parents
2985 if (client_normal(self)) {
2986 self->iconic = iconic;
2988 /* update the focus lists.. iconic windows go to the bottom of
2990 focus_order_to_bottom(self);
2995 self->iconic = iconic;
2997 if (curdesk && self->desktop != screen_desktop &&
2998 self->desktop != DESKTOP_ALL)
2999 client_set_desktop(self, screen_desktop, FALSE);
3001 /* this puts it after the current focused window */
3002 focus_order_remove(self);
3003 focus_order_add_new(self);
3010 client_change_state(self);
3011 if (config_animate_iconify && !hide_animation)
3012 frame_begin_iconify_animation(self->frame, iconic);
3013 /* do this after starting the animation so it doesn't flash */
3014 client_showhide(self);
3017 /* iconify all direct transients, and deiconify all transients
3019 for (it = self->transients; it; it = g_slist_next(it))
3020 if (it->data != self)
3021 if (client_is_direct_child(self, it->data) || !iconic)
3022 client_iconify_recursive(it->data, iconic, curdesk,
3026 void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk,
3027 gboolean hide_animation)
3029 if (self->functions & OB_CLIENT_FUNC_ICONIFY || !iconic) {
3030 /* move up the transient chain as far as possible first */
3031 self = client_search_top_direct_parent(self);
3032 client_iconify_recursive(self, iconic, curdesk, hide_animation);
3036 void client_maximize(ObClient *self, gboolean max, gint dir)
3040 g_assert(dir == 0 || dir == 1 || dir == 2);
3041 if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */
3043 /* check if already done */
3045 if (dir == 0 && self->max_horz && self->max_vert) return;
3046 if (dir == 1 && self->max_horz) return;
3047 if (dir == 2 && self->max_vert) return;
3049 if (dir == 0 && !self->max_horz && !self->max_vert) return;
3050 if (dir == 1 && !self->max_horz) return;
3051 if (dir == 2 && !self->max_vert) return;
3054 /* these will help configure_full figure out which screen to fill with
3058 w = self->area.width;
3059 h = self->area.height;
3062 if ((dir == 0 || dir == 1) && !self->max_horz) { /* horz */
3063 RECT_SET(self->pre_max_area,
3064 self->area.x, self->pre_max_area.y,
3065 self->area.width, self->pre_max_area.height);
3067 if ((dir == 0 || dir == 2) && !self->max_vert) { /* vert */
3068 RECT_SET(self->pre_max_area,
3069 self->pre_max_area.x, self->area.y,
3070 self->pre_max_area.width, self->area.height);
3073 if ((dir == 0 || dir == 1) && self->max_horz) { /* horz */
3074 g_assert(self->pre_max_area.width > 0);
3076 x = self->pre_max_area.x;
3077 w = self->pre_max_area.width;
3079 RECT_SET(self->pre_max_area, 0, self->pre_max_area.y,
3080 0, self->pre_max_area.height);
3082 if ((dir == 0 || dir == 2) && self->max_vert) { /* vert */
3083 g_assert(self->pre_max_area.height > 0);
3085 y = self->pre_max_area.y;
3086 h = self->pre_max_area.height;
3088 RECT_SET(self->pre_max_area, self->pre_max_area.x, 0,
3089 self->pre_max_area.width, 0);
3093 if (dir == 0 || dir == 1) /* horz */
3094 self->max_horz = max;
3095 if (dir == 0 || dir == 2) /* vert */
3096 self->max_vert = max;
3098 client_change_state(self); /* change the state hints on the client */
3100 client_setup_decor_and_functions(self, FALSE);
3101 client_move_resize(self, x, y, w, h);
3104 void client_shade(ObClient *self, gboolean shade)
3106 if ((!(self->functions & OB_CLIENT_FUNC_SHADE) &&
3107 shade) || /* can't shade */
3108 self->shaded == shade) return; /* already done */
3110 self->shaded = shade;
3111 client_change_state(self);
3112 client_change_wm_state(self); /* the window is being hidden/shown */
3113 /* resize the frame to just the titlebar */
3114 frame_adjust_area(self->frame, FALSE, FALSE, FALSE);
3117 void client_close(ObClient *self)
3121 if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
3123 /* in the case that the client provides no means to requesting that it
3124 close, we just kill it */
3125 if (!self->delete_window)
3129 XXX: itd be cool to do timeouts and shit here for killing the client's
3131 like... if the window is around after 5 seconds, then the close button
3132 turns a nice red, and if this function is called again, the client is
3136 ce.xclient.type = ClientMessage;
3137 ce.xclient.message_type = prop_atoms.wm_protocols;
3138 ce.xclient.display = ob_display;
3139 ce.xclient.window = self->window;
3140 ce.xclient.format = 32;
3141 ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
3142 ce.xclient.data.l[1] = event_curtime;
3143 ce.xclient.data.l[2] = 0l;
3144 ce.xclient.data.l[3] = 0l;
3145 ce.xclient.data.l[4] = 0l;
3146 XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3149 void client_kill(ObClient *self)
3151 XKillClient(ob_display, self->window);
3154 void client_hilite(ObClient *self, gboolean hilite)
3156 if (self->demands_attention == hilite)
3157 return; /* no change */
3159 /* don't allow focused windows to hilite */
3160 self->demands_attention = hilite && !client_focused(self);
3161 if (self->frame != NULL) { /* if we're mapping, just set the state */
3162 if (self->demands_attention)
3163 frame_flash_start(self->frame);
3165 frame_flash_stop(self->frame);
3166 client_change_state(self);
3170 void client_set_desktop_recursive(ObClient *self,
3177 if (target != self->desktop && self->type != OB_CLIENT_TYPE_DESKTOP) {
3179 ob_debug("Setting desktop %u\n", target+1);
3181 g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
3183 old = self->desktop;
3184 self->desktop = target;
3185 PROP_SET32(self->window, net_wm_desktop, cardinal, target);
3186 /* the frame can display the current desktop state */
3187 frame_adjust_state(self->frame);
3188 /* 'move' the window to the new desktop */
3190 client_showhide(self);
3191 /* raise if it was not already on the desktop */
3192 if (old != DESKTOP_ALL)
3193 stacking_raise(CLIENT_AS_WINDOW(self));
3194 if (STRUT_EXISTS(self->strut))
3195 screen_update_areas();
3198 /* move all transients */
3199 for (it = self->transients; it; it = g_slist_next(it))
3200 if (it->data != self)
3201 if (client_is_direct_child(self, it->data))
3202 client_set_desktop_recursive(it->data, target, donthide);
3205 void client_set_desktop(ObClient *self, guint target, gboolean donthide)
3207 self = client_search_top_direct_parent(self);
3208 client_set_desktop_recursive(self, target, donthide);
3211 gboolean client_is_direct_child(ObClient *parent, ObClient *child)
3213 while (child != parent && (child = client_direct_parent(child)));
3214 return child == parent;
3217 ObClient *client_search_modal_child(ObClient *self)
3222 for (it = self->transients; it; it = g_slist_next(it)) {
3223 ObClient *c = it->data;
3224 if ((ret = client_search_modal_child(c))) return ret;
3225 if (c->modal) return c;
3230 gboolean client_validate(ObClient *self)
3234 XSync(ob_display, FALSE); /* get all events on the server */
3236 if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) ||
3237 XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) {
3238 XPutBackEvent(ob_display, &e);
3245 void client_set_wm_state(ObClient *self, glong state)
3247 if (state == self->wmstate) return; /* no change */
3251 client_iconify(self, TRUE, TRUE, FALSE);
3254 client_iconify(self, FALSE, TRUE, FALSE);
3259 void client_set_state(ObClient *self, Atom action, glong data1, glong data2)
3261 gboolean shaded = self->shaded;
3262 gboolean fullscreen = self->fullscreen;
3263 gboolean undecorated = self->undecorated;
3264 gboolean max_horz = self->max_horz;
3265 gboolean max_vert = self->max_vert;
3266 gboolean modal = self->modal;
3267 gboolean iconic = self->iconic;
3268 gboolean demands_attention = self->demands_attention;
3269 gboolean above = self->above;
3270 gboolean below = self->below;
3273 if (!(action == prop_atoms.net_wm_state_add ||
3274 action == prop_atoms.net_wm_state_remove ||
3275 action == prop_atoms.net_wm_state_toggle))
3276 /* an invalid action was passed to the client message, ignore it */
3279 for (i = 0; i < 2; ++i) {
3280 Atom state = i == 0 ? data1 : data2;
3282 if (!state) continue;
3284 /* if toggling, then pick whether we're adding or removing */
3285 if (action == prop_atoms.net_wm_state_toggle) {
3286 if (state == prop_atoms.net_wm_state_modal)
3287 action = modal ? prop_atoms.net_wm_state_remove :
3288 prop_atoms.net_wm_state_add;
3289 else if (state == prop_atoms.net_wm_state_maximized_vert)
3290 action = self->max_vert ? prop_atoms.net_wm_state_remove :
3291 prop_atoms.net_wm_state_add;
3292 else if (state == prop_atoms.net_wm_state_maximized_horz)
3293 action = self->max_horz ? prop_atoms.net_wm_state_remove :
3294 prop_atoms.net_wm_state_add;
3295 else if (state == prop_atoms.net_wm_state_shaded)
3296 action = shaded ? prop_atoms.net_wm_state_remove :
3297 prop_atoms.net_wm_state_add;
3298 else if (state == prop_atoms.net_wm_state_skip_taskbar)
3299 action = self->skip_taskbar ?
3300 prop_atoms.net_wm_state_remove :
3301 prop_atoms.net_wm_state_add;
3302 else if (state == prop_atoms.net_wm_state_skip_pager)
3303 action = self->skip_pager ?
3304 prop_atoms.net_wm_state_remove :
3305 prop_atoms.net_wm_state_add;
3306 else if (state == prop_atoms.net_wm_state_hidden)
3307 action = self->iconic ?
3308 prop_atoms.net_wm_state_remove :
3309 prop_atoms.net_wm_state_add;
3310 else if (state == prop_atoms.net_wm_state_fullscreen)
3311 action = fullscreen ?
3312 prop_atoms.net_wm_state_remove :
3313 prop_atoms.net_wm_state_add;
3314 else if (state == prop_atoms.net_wm_state_above)
3315 action = self->above ? prop_atoms.net_wm_state_remove :
3316 prop_atoms.net_wm_state_add;
3317 else if (state == prop_atoms.net_wm_state_below)
3318 action = self->below ? prop_atoms.net_wm_state_remove :
3319 prop_atoms.net_wm_state_add;
3320 else if (state == prop_atoms.net_wm_state_demands_attention)
3321 action = self->demands_attention ?
3322 prop_atoms.net_wm_state_remove :
3323 prop_atoms.net_wm_state_add;
3324 else if (state == prop_atoms.ob_wm_state_undecorated)
3325 action = undecorated ? prop_atoms.net_wm_state_remove :
3326 prop_atoms.net_wm_state_add;
3329 if (action == prop_atoms.net_wm_state_add) {
3330 if (state == prop_atoms.net_wm_state_modal) {
3332 } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3334 } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3336 } else if (state == prop_atoms.net_wm_state_shaded) {
3338 } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3339 self->skip_taskbar = TRUE;
3340 } else if (state == prop_atoms.net_wm_state_skip_pager) {
3341 self->skip_pager = TRUE;
3342 } else if (state == prop_atoms.net_wm_state_hidden) {
3344 } else if (state == prop_atoms.net_wm_state_fullscreen) {
3346 } else if (state == prop_atoms.net_wm_state_above) {
3349 } else if (state == prop_atoms.net_wm_state_below) {
3352 } else if (state == prop_atoms.net_wm_state_demands_attention) {
3353 demands_attention = TRUE;
3354 } else if (state == prop_atoms.ob_wm_state_undecorated) {
3358 } else { /* action == prop_atoms.net_wm_state_remove */
3359 if (state == prop_atoms.net_wm_state_modal) {
3361 } else if (state == prop_atoms.net_wm_state_maximized_vert) {
3363 } else if (state == prop_atoms.net_wm_state_maximized_horz) {
3365 } else if (state == prop_atoms.net_wm_state_shaded) {
3367 } else if (state == prop_atoms.net_wm_state_skip_taskbar) {
3368 self->skip_taskbar = FALSE;
3369 } else if (state == prop_atoms.net_wm_state_skip_pager) {
3370 self->skip_pager = FALSE;
3371 } else if (state == prop_atoms.net_wm_state_hidden) {
3373 } else if (state == prop_atoms.net_wm_state_fullscreen) {
3375 } else if (state == prop_atoms.net_wm_state_above) {
3377 } else if (state == prop_atoms.net_wm_state_below) {
3379 } else if (state == prop_atoms.net_wm_state_demands_attention) {
3380 demands_attention = FALSE;
3381 } else if (state == prop_atoms.ob_wm_state_undecorated) {
3382 undecorated = FALSE;
3387 if (max_horz != self->max_horz || max_vert != self->max_vert) {
3388 if (max_horz != self->max_horz && max_vert != self->max_vert) {
3390 if (max_horz == max_vert) { /* both going the same way */
3391 client_maximize(self, max_horz, 0);
3393 client_maximize(self, max_horz, 1);
3394 client_maximize(self, max_vert, 2);
3398 if (max_horz != self->max_horz)
3399 client_maximize(self, max_horz, 1);
3401 client_maximize(self, max_vert, 2);
3404 /* change fullscreen state before shading, as it will affect if the window
3406 if (fullscreen != self->fullscreen)
3407 client_fullscreen(self, fullscreen);
3408 if (shaded != self->shaded)
3409 client_shade(self, shaded);
3410 if (undecorated != self->undecorated)
3411 client_set_undecorated(self, undecorated);
3412 if (above != self->above || below != self->below) {
3413 self->above = above;
3414 self->below = below;
3415 client_calc_layer(self);
3418 if (modal != self->modal) {
3419 self->modal = modal;
3420 /* when a window changes modality, then its stacking order with its
3421 transients needs to change */
3422 stacking_raise(CLIENT_AS_WINDOW(self));
3424 /* it also may get focused. if something is focused that shouldn't
3425 be focused anymore, then move the focus */
3426 if (focus_client && client_focus_target(focus_client) != focus_client)
3427 client_focus(focus_client);
3430 if (iconic != self->iconic)
3431 client_iconify(self, iconic, FALSE, FALSE);
3433 if (demands_attention != self->demands_attention)
3434 client_hilite(self, demands_attention);
3436 client_change_state(self); /* change the hint to reflect these changes */
3439 ObClient *client_focus_target(ObClient *self)
3441 ObClient *child = NULL;
3443 child = client_search_modal_child(self);
3444 if (child) return child;
3448 gboolean client_can_focus(ObClient *self)
3450 /* choose the correct target */
3451 self = client_focus_target(self);
3453 if (!self->frame->visible)
3456 if (!(self->can_focus || self->focus_notify))
3462 gboolean client_focus(ObClient *self)
3464 /* we might not focus this window, so if we have modal children which would
3465 be focused instead, bring them to this desktop */
3466 client_bring_modal_windows(self);
3468 /* choose the correct target */
3469 self = client_focus_target(self);
3471 if (!client_can_focus(self)) {
3472 ob_debug_type(OB_DEBUG_FOCUS,
3473 "Client %s can't be focused\n", self->title);
3477 ob_debug_type(OB_DEBUG_FOCUS,
3478 "Focusing client \"%s\" (0x%x) at time %u\n",
3479 self->title, self->window, event_curtime);
3481 /* if there is a grab going on, then we need to cancel it. if we move
3482 focus during the grab, applications will get NotifyWhileGrabbed events
3485 actions should not rely on being able to move focus during an
3488 event_cancel_all_key_grabs();
3490 xerror_set_ignore(TRUE);
3491 xerror_occured = FALSE;
3493 if (self->can_focus) {
3494 /* This can cause a BadMatch error with CurrentTime, or if an app
3495 passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
3496 XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
3500 if (self->focus_notify) {
3502 ce.xclient.type = ClientMessage;
3503 ce.xclient.message_type = prop_atoms.wm_protocols;
3504 ce.xclient.display = ob_display;
3505 ce.xclient.window = self->window;
3506 ce.xclient.format = 32;
3507 ce.xclient.data.l[0] = prop_atoms.wm_take_focus;
3508 ce.xclient.data.l[1] = event_curtime;
3509 ce.xclient.data.l[2] = 0l;
3510 ce.xclient.data.l[3] = 0l;
3511 ce.xclient.data.l[4] = 0l;
3512 XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
3515 xerror_set_ignore(FALSE);
3517 ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d\n", xerror_occured);
3518 return !xerror_occured;
3521 /*! Present the client to the user.
3522 @param raise If the client should be raised or not. You should only set
3523 raise to false if you don't care if the window is completely
3526 static void client_present(ObClient *self, gboolean here, gboolean raise)
3528 /* if using focus_delay, stop the timer now so that focus doesn't
3530 event_halt_focus_delay();
3532 if (client_normal(self) && screen_showing_desktop)
3533 screen_show_desktop(FALSE, self);
3535 client_iconify(self, FALSE, here, FALSE);
3536 if (self->desktop != DESKTOP_ALL &&
3537 self->desktop != screen_desktop)
3540 client_set_desktop(self, screen_desktop, FALSE);
3542 screen_set_desktop(self->desktop, FALSE);
3543 } else if (!self->frame->visible)
3544 /* if its not visible for other reasons, then don't mess
3548 client_shade(self, FALSE);
3550 stacking_raise(CLIENT_AS_WINDOW(self));
3555 void client_activate(ObClient *self, gboolean here, gboolean user)
3557 guint32 last_time = focus_client ? focus_client->user_time : CurrentTime;
3558 gboolean allow = FALSE;
3560 /* if the request came from the user, or if nothing is focused, then grant
3562 if the currently focused app doesn't set a user_time, then it can't
3563 benefit from any focus stealing prevention.
3565 if (user || !focus_client || !last_time)
3567 /* otherwise, if they didn't give a time stamp or if it is too old, they
3570 allow = event_curtime && event_time_after(event_curtime, last_time);
3572 ob_debug_type(OB_DEBUG_FOCUS,
3573 "Want to activate window 0x%x with time %u (last time %u), "
3574 "source=%s allowing? %d\n",
3575 self->window, event_curtime, last_time,
3576 (user ? "user" : "application"), allow);
3579 client_present(self, here, TRUE);
3581 /* don't focus it but tell the user it wants attention */
3582 client_hilite(self, TRUE);
3585 static void client_bring_windows_recursive(ObClient *self,
3593 for (it = self->transients; it; it = g_slist_next(it))
3594 client_bring_windows_recursive(it->data, desktop,
3595 helpers, modals, iconic);
3597 if (((helpers && client_helper(self)) ||
3598 (modals && self->modal)) &&
3599 ((self->desktop != desktop && self->desktop != DESKTOP_ALL) ||
3600 (iconic && self->iconic)))
3602 if (iconic && self->iconic)
3603 client_iconify(self, FALSE, TRUE, FALSE);
3605 client_set_desktop(self, desktop, FALSE);
3609 void client_bring_helper_windows(ObClient *self)
3611 client_bring_windows_recursive(self, self->desktop, TRUE, FALSE, FALSE);
3614 void client_bring_modal_windows(ObClient *self)
3616 client_bring_windows_recursive(self, self->desktop, FALSE, TRUE, TRUE);
3619 gboolean client_focused(ObClient *self)
3621 return self == focus_client;
3624 static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h)
3627 gulong min_diff, min_i;
3629 if (!self->nicons) {
3630 ObClientIcon *parent = NULL;
3633 for (it = self->parents; it; it = g_slist_next(it)) {
3634 ObClient *c = it->data;
3635 if ((parent = client_icon_recursive(c, w, h)))
3642 /* some kind of crappy approximation to find the icon closest in size to
3643 what we requested, but icons are generally all the same ratio as
3644 eachother so it's good enough. */
3646 min_diff = ABS(self->icons[0].width - w) + ABS(self->icons[0].height - h);
3649 for (i = 1; i < self->nicons; ++i) {
3652 diff = ABS(self->icons[i].width - w) + ABS(self->icons[i].height - h);
3653 if (diff < min_diff) {
3658 return &self->icons[min_i];
3661 const ObClientIcon* client_icon(ObClient *self, gint w, gint h)
3664 static ObClientIcon deficon;
3666 if (!(ret = client_icon_recursive(self, w, h))) {
3667 deficon.width = deficon.height = 48;
3668 deficon.data = ob_rr_theme->def_win_icon;
3674 void client_set_layer(ObClient *self, gint layer)
3678 self->above = FALSE;
3679 } else if (layer == 0) {
3680 self->below = self->above = FALSE;
3682 self->below = FALSE;
3685 client_calc_layer(self);
3686 client_change_state(self); /* reflect this in the state hints */
3689 void client_set_undecorated(ObClient *self, gboolean undecorated)
3691 if (self->undecorated != undecorated &&
3692 /* don't let it undecorate if the function is missing, but let
3694 (self->functions & OB_CLIENT_FUNC_UNDECORATE || !undecorated))
3696 self->undecorated = undecorated;
3697 client_setup_decor_and_functions(self, TRUE);
3698 client_change_state(self); /* reflect this in the state hints */
3702 guint client_monitor(ObClient *self)
3704 return screen_find_monitor(&self->frame->area);
3707 ObClient *client_direct_parent(ObClient *self)
3709 if (!self->parents) return NULL;
3710 if (self->transient_for == OB_TRAN_GROUP) return NULL;
3711 return self->parents->data;
3714 ObClient *client_search_top_direct_parent(ObClient *self)
3717 while ((p = client_direct_parent(self))) self = p;
3721 static GSList *client_search_all_top_parents_internal(ObClient *self,
3723 ObStackingLayer layer)
3728 /* move up the direct transient chain as far as possible */
3729 while ((p = client_direct_parent(self)) &&
3730 (!bylayer || p->layer == layer))
3734 ret = g_slist_prepend(NULL, self);
3736 ret = g_slist_copy(self->parents);
3741 GSList *client_search_all_top_parents(ObClient *self)
3743 return client_search_all_top_parents_internal(self, FALSE, 0);
3746 GSList *client_search_all_top_parents_layer(ObClient *self)
3748 return client_search_all_top_parents_internal(self, TRUE, self->layer);
3751 ObClient *client_search_focus_parent(ObClient *self)
3755 for (it = self->parents; it; it = g_slist_next(it))
3756 if (client_focused(it->data)) return it->data;
3761 ObClient *client_search_parent(ObClient *self, ObClient *search)
3765 for (it = self->parents; it; it = g_slist_next(it))
3766 if (it->data == search) return search;
3771 ObClient *client_search_transient(ObClient *self, ObClient *search)
3775 for (sit = self->transients; sit; sit = g_slist_next(sit)) {
3776 if (sit->data == search)
3778 if (client_search_transient(sit->data, search))
3784 #define WANT_EDGE(cur, c) \
3787 if (c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL && \
3788 cur->desktop != screen_desktop) \
3793 #define HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end) \
3794 if ((his_edge_start >= my_edge_start && \
3795 his_edge_start <= my_edge_end) || \
3796 (my_edge_start >= his_edge_start && \
3797 my_edge_start <= his_edge_end)) \
3800 /* finds the nearest edge in the given direction from the current client
3801 * note to self: the edge is the -frame- edge (the actual one), not the
3804 gint client_directional_edge_search(ObClient *c, ObDirection dir, gboolean hang)
3806 gint dest, monitor_dest;
3807 gint my_edge_start, my_edge_end, my_offset;
3814 a = screen_area(c->desktop);
3815 monitor = screen_area_monitor(c->desktop, client_monitor(c));
3818 case OB_DIRECTION_NORTH:
3819 my_edge_start = c->frame->area.x;
3820 my_edge_end = c->frame->area.x + c->frame->area.width;
3821 my_offset = c->frame->area.y + (hang ? c->frame->area.height : 0);
3823 /* default: top of screen */
3824 dest = a->y + (hang ? c->frame->area.height : 0);
3825 monitor_dest = monitor->y + (hang ? c->frame->area.height : 0);
3826 /* if the monitor edge comes before the screen edge, */
3827 /* use that as the destination instead. (For xinerama) */
3828 if (monitor_dest != dest && my_offset > monitor_dest)
3829 dest = monitor_dest;
3831 for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3832 gint his_edge_start, his_edge_end, his_offset;
3833 ObClient *cur = it->data;
3837 his_edge_start = cur->frame->area.x;
3838 his_edge_end = cur->frame->area.x + cur->frame->area.width;
3839 his_offset = cur->frame->area.y +
3840 (hang ? 0 : cur->frame->area.height);
3842 if(his_offset + 1 > my_offset)
3845 if(his_offset < dest)
3848 HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3851 case OB_DIRECTION_SOUTH:
3852 my_edge_start = c->frame->area.x;
3853 my_edge_end = c->frame->area.x + c->frame->area.width;
3854 my_offset = c->frame->area.y + (hang ? 0 : c->frame->area.height);
3856 /* default: bottom of screen */
3857 dest = a->y + a->height - (hang ? c->frame->area.height : 0);
3858 monitor_dest = monitor->y + monitor->height -
3859 (hang ? c->frame->area.height : 0);
3860 /* if the monitor edge comes before the screen edge, */
3861 /* use that as the destination instead. (For xinerama) */
3862 if (monitor_dest != dest && my_offset < monitor_dest)
3863 dest = monitor_dest;
3865 for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3866 gint his_edge_start, his_edge_end, his_offset;
3867 ObClient *cur = it->data;
3871 his_edge_start = cur->frame->area.x;
3872 his_edge_end = cur->frame->area.x + cur->frame->area.width;
3873 his_offset = cur->frame->area.y +
3874 (hang ? cur->frame->area.height : 0);
3877 if(his_offset - 1 < my_offset)
3880 if(his_offset > dest)
3883 HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3886 case OB_DIRECTION_WEST:
3887 my_edge_start = c->frame->area.y;
3888 my_edge_end = c->frame->area.y + c->frame->area.height;
3889 my_offset = c->frame->area.x + (hang ? c->frame->area.width : 0);
3891 /* default: leftmost egde of screen */
3892 dest = a->x + (hang ? c->frame->area.width : 0);
3893 monitor_dest = monitor->x + (hang ? c->frame->area.width : 0);
3894 /* if the monitor edge comes before the screen edge, */
3895 /* use that as the destination instead. (For xinerama) */
3896 if (monitor_dest != dest && my_offset > monitor_dest)
3897 dest = monitor_dest;
3899 for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3900 gint his_edge_start, his_edge_end, his_offset;
3901 ObClient *cur = it->data;
3905 his_edge_start = cur->frame->area.y;
3906 his_edge_end = cur->frame->area.y + cur->frame->area.height;
3907 his_offset = cur->frame->area.x +
3908 (hang ? 0 : cur->frame->area.width);
3910 if(his_offset + 1 > my_offset)
3913 if(his_offset < dest)
3916 HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3919 case OB_DIRECTION_EAST:
3920 my_edge_start = c->frame->area.y;
3921 my_edge_end = c->frame->area.y + c->frame->area.height;
3922 my_offset = c->frame->area.x + (hang ? 0 : c->frame->area.width);
3924 /* default: rightmost edge of screen */
3925 dest = a->x + a->width - (hang ? c->frame->area.width : 0);
3926 monitor_dest = monitor->x + monitor->width -
3927 (hang ? c->frame->area.width : 0);
3928 /* if the monitor edge comes before the screen edge, */
3929 /* use that as the destination instead. (For xinerama) */
3930 if (monitor_dest != dest && my_offset < monitor_dest)
3931 dest = monitor_dest;
3933 for(it = client_list; it && my_offset != dest; it = g_list_next(it)) {
3934 gint his_edge_start, his_edge_end, his_offset;
3935 ObClient *cur = it->data;
3939 his_edge_start = cur->frame->area.y;
3940 his_edge_end = cur->frame->area.y + cur->frame->area.height;
3941 his_offset = cur->frame->area.x +
3942 (hang ? cur->frame->area.width : 0);
3944 if(his_offset - 1 < my_offset)
3947 if(his_offset > dest)
3950 HIT_EDGE(my_edge_start, my_edge_end, his_edge_start, his_edge_end)
3953 case OB_DIRECTION_NORTHEAST:
3954 case OB_DIRECTION_SOUTHEAST:
3955 case OB_DIRECTION_NORTHWEST:
3956 case OB_DIRECTION_SOUTHWEST:
3957 /* not implemented */
3959 g_assert_not_reached();
3960 dest = 0; /* suppress warning */
3965 ObClient* client_under_pointer()
3969 ObClient *ret = NULL;
3971 if (screen_pointer_pos(&x, &y)) {
3972 for (it = stacking_list; it; it = g_list_next(it)) {
3973 if (WINDOW_IS_CLIENT(it->data)) {
3974 ObClient *c = WINDOW_AS_CLIENT(it->data);
3975 if (c->frame->visible &&
3976 /* ignore all animating windows */
3977 !frame_iconify_animating(c->frame) &&
3978 RECT_CONTAINS(c->frame->area, x, y))
3989 gboolean client_has_group_siblings(ObClient *self)
3991 return self->group && self->group->members->next;