X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fclient.c;h=6534e1b35dded385f9d5041dccd336fa8345b0eb;hb=0dc7eca4cdfff6425e19a0bace0f9ae8834d04e8;hp=164ab91b557bcb4061bf1eb6d7d68b42e5c94a9c;hpb=489844da325b248ff039de87ffc5593e0f8dd0a2;p=chaz%2Fopenbox diff --git a/openbox/client.c b/openbox/client.c index 164ab91b..6534e1b3 100644 --- a/openbox/client.c +++ b/openbox/client.c @@ -1,5 +1,5 @@ /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- - + client.c for the Openbox window manager Copyright (c) 2006 Mikael Magnusson Copyright (c) 2003-2007 Dana Jansens @@ -21,18 +21,15 @@ #include "debug.h" #include "startupnotify.h" #include "dock.h" -#include "xerror.h" #include "screen.h" #include "moveresize.h" +#include "ping.h" #include "place.h" -#include "prop.h" -#include "extensions.h" #include "frame.h" #include "session.h" #include "event.h" #include "grab.h" #include "focus.h" -#include "propwin.h" #include "stacking.h" #include "openbox.h" #include "group.h" @@ -41,11 +38,18 @@ #include "keyboard.h" #include "mouse.h" #include "render/render.h" +#include "gettext.h" +#include "obt/display.h" +#include "obt/prop.h" #ifdef HAVE_UNISTD_H # include #endif +#ifdef HAVE_SIGNAL_H +# include /* for kill() */ +#endif + #include #include @@ -75,6 +79,10 @@ static void client_get_state(ObClient *self); static void client_get_shaped(ObClient *self); static void client_get_mwm_hints(ObClient *self); static void client_get_colormap(ObClient *self); +static void client_set_desktop_recursive(ObClient *self, + guint target, + gboolean donthide, + gboolean dontraise); static void client_change_allowed_actions(ObClient *self); static void client_change_state(ObClient *self); static void client_change_wm_state(ObClient *self); @@ -94,6 +102,7 @@ static GSList *client_search_all_top_parents_internal(ObClient *self, gboolean bylayer, ObStackingLayer layer); static void client_call_notifies(ObClient *self, GSList *list); +static void client_ping_event(ObClient *self, gboolean dead); void client_startup(gboolean reconfig) @@ -141,7 +150,7 @@ void client_remove_destroy_notify(ObClientCallback func) } } -void client_set_list() +void client_set_list(void) { Window *windows, *win_it; GList *it; @@ -156,8 +165,8 @@ void client_set_list() } else windows = NULL; - PROP_SETA32(RootWindow(ob_display, ob_screen), - net_client_list, window, (gulong*)windows, size); + OBT_PROP_SETA32(obt_root(ob_screen), NET_CLIENT_LIST, WINDOW, + (gulong*)windows, size); if (windows) g_free(windows); @@ -165,121 +174,51 @@ void client_set_list() stacking_set_list(); } -void client_manage_all() -{ - guint i, j, nchild; - Window w, *children; - XWMHints *wmhints; - XWindowAttributes attrib; - - XQueryTree(ob_display, RootWindow(ob_display, ob_screen), - &w, &w, &children, &nchild); - - /* remove all icon windows from the list */ - for (i = 0; i < nchild; i++) { - if (children[i] == None) continue; - wmhints = XGetWMHints(ob_display, children[i]); - if (wmhints) { - if ((wmhints->flags & IconWindowHint) && - (wmhints->icon_window != children[i])) - for (j = 0; j < nchild; j++) - if (children[j] == wmhints->icon_window) { - children[j] = None; - break; - } - XFree(wmhints); - } - } - - for (i = 0; i < nchild; ++i) { - if (children[i] == None) - continue; - if (XGetWindowAttributes(ob_display, children[i], &attrib)) { - if (attrib.override_redirect) continue; - - if (attrib.map_state != IsUnmapped) - client_manage(children[i]); - } - } - XFree(children); -} - void client_manage(Window window) { ObClient *self; - XEvent e; - XWindowAttributes attrib; XSetWindowAttributes attrib_set; - XWMHints *wmhint; gboolean activate = FALSE; ObAppSettings *settings; - gint placex, placey, placew, placeh; gboolean transient = FALSE; + Rect place, *monitor; + Time launch_time, map_time; - grab_server(TRUE); + ob_debug("Managing window: 0x%lx", window); - /* check if it has already been unmapped by the time we started - mapping. the grab does a sync so we don't have to here */ - if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) || - XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e)) - { - XPutBackEvent(ob_display, &e); - - ob_debug("Trying to manage unmapped window. Aborting that.\n"); - grab_server(FALSE); - return; /* don't manage it */ - } - - /* make sure it isn't an override-redirect window */ - if (!XGetWindowAttributes(ob_display, window, &attrib) || - attrib.override_redirect) - { - grab_server(FALSE); - return; /* don't manage it */ - } - - /* is the window a docking app */ - if ((wmhint = XGetWMHints(ob_display, window))) { - if ((wmhint->flags & StateHint) && - wmhint->initial_state == WithdrawnState) - { - dock_add(window, wmhint); - grab_server(FALSE); - XFree(wmhint); - return; - } - XFree(wmhint); - } - - ob_debug("Managing window: 0x%lx\n", window); + map_time = event_get_server_time(); /* choose the events we want to receive on the CLIENT window */ attrib_set.event_mask = CLIENT_EVENTMASK; attrib_set.do_not_propagate_mask = CLIENT_NOPROPAGATEMASK; - XChangeWindowAttributes(ob_display, window, + XChangeWindowAttributes(obt_display, window, CWEventMask|CWDontPropagate, &attrib_set); /* create the ObClient struct, and populate it from the hints on the window */ self = g_new0(ObClient, 1); - self->obwin.type = Window_Client; + self->obwin.type = OB_WINDOW_CLASS_CLIENT; self->window = window; /* non-zero defaults */ self->wmstate = WithdrawnState; /* make sure it gets updated first time */ self->gravity = NorthWestGravity; self->desktop = screen_num_desktops; /* always an invalid value */ - self->user_time = focus_client ? focus_client->user_time : CurrentTime; /* get all the stuff off the window */ client_get_all(self, TRUE); - ob_debug("Window type: %d\n", self->type); - ob_debug("Window group: 0x%x\n", self->group?self->group->leader:0); + ob_debug("Window type: %d", self->type); + ob_debug("Window group: 0x%x", self->group?self->group->leader:0); + + /* now we have all of the window's information so we can set this up. + do this before creating the frame, so it can tell that we are still + mapping and doesn't go applying things right away */ + client_setup_decor_and_functions(self, FALSE); /* specify that if we exit, the window should not be destroyed and should be reparented back to root automatically */ - XChangeSaveSet(ob_display, window, SetModeInsert); + XChangeSaveSet(obt_display, window, SetModeInsert); /* create the decoration frame for the client window */ self->frame = frame_new(self); @@ -297,13 +236,8 @@ void client_manage(Window window) /* the session should get the last say though */ client_restore_session_state(self); - /* now we have all of the window's information so we can set this up */ - client_setup_decor_and_functions(self, FALSE); - - { - Time t = sn_app_started(self->startup_id, self->class); - if (t) self->user_time = t; - } + /* tell startup notification that this app started */ + launch_time = sn_app_started(self->startup_id, self->class, self->name); /* do this after we have a frame.. it uses the frame to help determine the WM_STATE to apply. */ @@ -329,7 +263,7 @@ void client_manage(Window window) } /* remove the client's border */ - XSetWindowBorderWidth(ob_display, self->window, 0); + XSetWindowBorderWidth(obt_display, self->window, 0); /* adjust the frame to the client's size before showing or placing the window */ @@ -337,35 +271,34 @@ void client_manage(Window window) frame_adjust_client_area(self->frame); /* where the frame was placed is where the window was originally */ - placex = self->area.x; - placey = self->area.y; - placew = self->area.width; - placeh = self->area.height; + place = self->area; + monitor = screen_physical_area_monitor(screen_find_monitor(&place)); /* figure out placement for the window if the window is new */ if (ob_state() == OB_STATE_RUNNING) { - ob_debug("Positioned: %s @ %d %d\n", + ob_debug("Positioned: %s @ %d %d", (!self->positioned ? "no" : (self->positioned == PPosition ? "program specified" : (self->positioned == USPosition ? "user specified" : (self->positioned == (PPosition | USPosition) ? "program + user specified" : - "BADNESS !?")))), placex, placey); + "BADNESS !?")))), place.x, place.y); - ob_debug("Sized: %s @ %d %d\n", + ob_debug("Sized: %s @ %d %d", (!self->sized ? "no" : (self->sized == PSize ? "program specified" : (self->sized == USSize ? "user specified" : (self->sized == (PSize | USSize) ? "program + user specified" : - "BADNESS !?")))), placew, placeh); + "BADNESS !?")))), place.width, place.height); /* splash screens are also returned as TRUE for transient, and so will be forced on screen below */ - transient = place_client(self, &placex, &placey, settings); + transient = place_client(self, &place.x, &place.y, settings); /* make sure the window is visible. */ - client_find_onscreen(self, &placex, &placey, placew, placeh, + client_find_onscreen(self, &place.x, &place.y, + place.width, place.height, /* non-normal clients has less rules, and windows that are being restored from a session do also. we can assume you want @@ -382,9 +315,16 @@ void client_manage(Window window) */ ob_state() == OB_STATE_RUNNING && (transient || - (!(self->positioned & USPosition) && + (!((self->positioned & USPosition) || + (settings && settings->pos_given)) && client_normal(self) && - !self->session))); + !self->session && + /* don't move oldschool fullscreen windows to + fit inside the struts (fixes Acroread, which + makes its fullscreen window fit the screen + but it is not USSize'd or USPosition'd) */ + !(self->decorations == 0 && + RECT_EQUAL(place, *monitor))))); } /* if the window isn't user-sized, then make it fit inside @@ -400,37 +340,37 @@ void client_manage(Window window) (transient || (!(self->sized & USSize || self->positioned & USPosition) && client_normal(self) && - !self->session))) + !self->session && + /* don't shrink oldschool fullscreen windows to fit inside the + struts (fixes Acroread, which makes its fullscreen window + fit the screen but it is not USSize'd or USPosition'd) */ + !(self->decorations == 0 && RECT_EQUAL(place, *monitor))))) { - Rect placer; + Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &place); - RECT_SET(placer, placex, placey, placew, placeh); - frame_rect_to_frame(self->frame, &placer); + /* get the size of the frame */ + place.width += self->frame->size.left + self->frame->size.right; + place.height += self->frame->size.top + self->frame->size.bottom; - Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &placer); + /* fit the window inside the area */ + place.width = MIN(place.width, a->width); + place.height = MIN(place.height, a->height); - /* shrink by the frame's area */ - a->width -= self->frame->size.left + self->frame->size.right; - a->height -= self->frame->size.top + self->frame->size.bottom; + ob_debug("setting window size to %dx%d", place.width, place.height); - /* fit the window inside the area */ - if (placew > a->width || self->area.height > a->height) { - placew = MIN(self->area.width, a->width); - placeh = MIN(self->area.height, a->height); + /* get the size of the client back */ + place.width -= self->frame->size.left + self->frame->size.right; + place.height -= self->frame->size.top + self->frame->size.bottom; - ob_debug("setting window size to %dx%d\n", - self->area.width, self->area.height); - } g_free(a); } - ob_debug("placing window 0x%x at %d, %d with size %d x %d. " - "some restrictions may apply\n", - self->window, placex, placey, placew, placeh); + "some restrictions may apply", + self->window, place.x, place.y, place.width, place.height); if (self->session) ob_debug(" but session requested %d, %d %d x %d instead, " - "overriding\n", + "overriding", self->session->x, self->session->y, self->session->w, self->session->h); @@ -439,53 +379,69 @@ void client_manage(Window window) this also places the window */ - client_apply_startup_state(self, placex, placey, placew, placeh); + client_apply_startup_state(self, place.x, place.y, + place.width, place.height); + + g_free(monitor); + monitor = NULL; + ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s", + activate ? "yes" : "no"); if (activate) { - guint32 last_time = focus_client ? - focus_client->user_time : CurrentTime; + gboolean raise = FALSE; /* This is focus stealing prevention */ ob_debug_type(OB_DEBUG_FOCUS, - "Want to focus new window 0x%x with time %u " - "(last time %u)\n", - self->window, self->user_time, last_time); + "Want to focus new window 0x%x at time %u " + "launched at %u (last user interaction time %u)", + self->window, map_time, launch_time, + event_last_user_time); + + if (menu_frame_visible || moveresize_in_progress) { + activate = FALSE; + raise = TRUE; + ob_debug_type(OB_DEBUG_FOCUS, + "Not focusing the window because the user is inside " + "an Openbox menu or is move/resizing a window and " + "we don't want to interrupt them"); + } /* if it's on another desktop */ - if (!(self->desktop == screen_desktop || self->desktop == DESKTOP_ALL) - && /* the timestamp is from before you changed desktops */ - self->user_time && screen_desktop_user_time && - !event_time_after(self->user_time, screen_desktop_user_time)) + else if (!(self->desktop == screen_desktop || + self->desktop == DESKTOP_ALL) && + /* the timestamp is from before you changed desktops */ + launch_time && screen_desktop_user_time && + !event_time_after(launch_time, screen_desktop_user_time)) { activate = FALSE; + raise = TRUE; ob_debug_type(OB_DEBUG_FOCUS, "Not focusing the window because its on another " - "desktop\n"); + "desktop"); } /* If something is focused, and it's not our relative... */ else if (focus_client && client_search_focus_tree_full(self) == NULL && client_search_focus_group_full(self) == NULL) { - /* If time stamp is old, don't steal focus */ - if (self->user_time && last_time && - !event_time_after(self->user_time, last_time)) + /* If the user is working in another window right now, then don't + steal focus */ + if (event_last_user_time && launch_time && + event_time_after(event_last_user_time, launch_time) && + event_last_user_time != launch_time && + event_time_after(event_last_user_time, + map_time - OB_EVENT_USER_TIME_DELAY)) { activate = FALSE; ob_debug_type(OB_DEBUG_FOCUS, - "Not focusing the window because the time is " - "too old\n"); + "Not focusing the window because the user is " + "working in another window"); } - /* If its a transient (and parents aren't focused) and the time - is ambiguous (either the current focus target doesn't have - a timestamp, or they are the same (we probably inherited it - from them) */ - else if (client_has_parent(self) && - (!last_time || self->user_time == last_time)) - { + /* If its a transient (and its parents aren't focused) */ + else if (client_has_parent(self)) { activate = FALSE; ob_debug_type(OB_DEBUG_FOCUS, "Not focusing the window because it is a " - "transient, and the time is very ambiguous\n"); + "transient, and its relatives aren't focused"); } /* Don't steal focus from globally active clients. I stole this idea from KWin. It seems nice. @@ -496,26 +452,39 @@ void client_manage(Window window) activate = FALSE; ob_debug_type(OB_DEBUG_FOCUS, "Not focusing the window because a globally " - "active client has focus\n"); + "active client has focus"); } /* Don't move focus if it's not going to go to this window anyway */ else if (client_focus_target(self) != self) { activate = FALSE; + raise = TRUE; ob_debug_type(OB_DEBUG_FOCUS, "Not focusing the window because another window " - "would get the focus anyway\n"); + "would get the focus anyway"); + } + else if (!(self->desktop == screen_desktop || + self->desktop == DESKTOP_ALL)) + { + activate = FALSE; + raise = TRUE; + ob_debug_type(OB_DEBUG_FOCUS, + "Not focusing the window because it is on " + "another desktop and no relatives are focused "); } } if (!activate) { ob_debug_type(OB_DEBUG_FOCUS, - "Focus stealing prevention activated for %s with " - "time %u (last time %u)\n", - self->title, self->user_time, last_time); + "Focus stealing prevention activated for %s at " + "time %u (last user interactioon time %u)", + self->title, map_time, event_last_user_time); /* if the client isn't focused, then hilite it so the user knows it is there */ client_hilite(self, TRUE); + /* we may want to raise it even tho we're not activating it */ + if (raise && !client_restore_session_stacking(self)) + stacking_raise(CLIENT_AS_WINDOW(self)); } } else { @@ -553,7 +522,7 @@ void client_manage(Window window) /* add to client list/map */ client_list = g_list_append(client_list, self); - g_hash_table_insert(window_map, &self->window, self); + window_add(&self->window, CLIENT_AS_WINDOW(self)); /* this has to happen after we're in the client_list */ if (STRUT_EXISTS(self->strut)) @@ -562,13 +531,20 @@ void client_manage(Window window) /* update the list hints */ client_set_list(); + /* watch for when the application stops responding. only do this for + normal windows, i.e. windows which have titlebars and close buttons + and things like that. + we don't need to stop pinging on unmanage, because it will be handled + automatically by the destroy callback! + */ + if (self->ping && client_normal(self)) + ping_start(self, client_ping_event); + /* free the ObAppSettings shallow copy */ g_free(settings); - ob_debug("Managed window 0x%lx plate 0x%x (%s)\n", + ob_debug("Managed window 0x%lx plate 0x%x (%s)", window, self->frame->window, self->class); - - return; } @@ -577,7 +553,7 @@ ObClient *client_fake_manage(Window window) ObClient *self; ObAppSettings *settings; - ob_debug("Pretend-managing window: %lx\n", window); + ob_debug("Pretend-managing window: %lx", window); /* do this minimal stuff to figure out the client's decorations */ @@ -595,8 +571,8 @@ ObClient *client_fake_manage(Window window) self->frame = frame_new(self); frame_adjust_area(self->frame, FALSE, TRUE, TRUE); - ob_debug("gave extents left %d right %d top %d bottom %d\n", - self->frame->size.left, self->frame->size.right, + ob_debug("gave extents left %d right %d top %d bottom %d", + self->frame->size.left, self->frame->size.right, self->frame->size.top, self->frame->size.bottom); /* free the ObAppSettings shallow copy */ @@ -605,7 +581,7 @@ ObClient *client_fake_manage(Window window) return self; } -void client_unmanage_all() +void client_unmanage_all(void) { while (client_list != NULL) client_unmanage(client_list->data); @@ -617,7 +593,7 @@ void client_unmanage(ObClient *self) GSList *it; gulong ignore_start; - ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)\n", + ob_debug("Unmanaging window: 0x%x plate 0x%x (%s) (%s)", self->window, self->frame->window, self->class, self->title ? self->title : ""); @@ -625,7 +601,7 @@ void client_unmanage(ObClient *self) /* we dont want events no more. do this before hiding the frame so we don't generate more events */ - XSelectInput(ob_display, self->window, NoEventMask); + XSelectInput(obt_display, self->window, NoEventMask); /* ignore enter events from the unmap so it doesnt mess with the focus */ if (!config_focus_under_mouse) @@ -633,7 +609,7 @@ void client_unmanage(ObClient *self) frame_hide(self->frame); /* flush to send the hide to the server quickly */ - XFlush(ob_display); + XFlush(obt_display); if (!config_focus_under_mouse) event_end_ignore_all_enters(ignore_start); @@ -641,10 +617,7 @@ void client_unmanage(ObClient *self) mouse_grab_for_client(self, FALSE); /* remove the window from our save set */ - XChangeSaveSet(ob_display, self->window, SetModeDelete); - - /* kill the property windows */ - propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self); + XChangeSaveSet(obt_display, self->window, SetModeDelete); /* update the focus lists */ focus_order_remove(self); @@ -655,7 +628,7 @@ void client_unmanage(ObClient *self) client_list = g_list_remove(client_list, self); stacking_remove(self); - g_hash_table_remove(window_map, &self->window); + window_remove(self->window); /* once the client is out of the list, update the struts to remove its influence */ @@ -708,7 +681,7 @@ void client_unmanage(ObClient *self) self->decorations = 0; /* unmanaged windows have no decor */ /* give the client its border back */ - XSetWindowBorderWidth(ob_display, self->window, self->border_width); + XSetWindowBorderWidth(obt_display, self->window, self->border_width); client_move_resize(self, a.x, a.y, a.width, a.height); } @@ -721,20 +694,25 @@ void client_unmanage(ObClient *self) if (ob_state() != OB_STATE_EXITING) { /* these values should not be persisted across a window unmapping/mapping */ - PROP_ERASE(self->window, net_wm_desktop); - PROP_ERASE(self->window, net_wm_state); - PROP_ERASE(self->window, wm_state); + OBT_PROP_ERASE(self->window, NET_WM_DESKTOP); + OBT_PROP_ERASE(self->window, NET_WM_STATE); + OBT_PROP_ERASE(self->window, WM_STATE); } else { /* if we're left in an unmapped state, the client wont be mapped. this is bad, since we will no longer be managing the window on restart */ - XMapWindow(ob_display, self->window); + XMapWindow(obt_display, self->window); } + /* these should not be left on the window ever. other window managers + don't necessarily use them and it will mess them up (like compiz) */ + OBT_PROP_ERASE(self->window, NET_WM_VISIBLE_NAME); + OBT_PROP_ERASE(self->window, NET_WM_VISIBLE_ICON_NAME); + /* update the list hints */ client_set_list(); - ob_debug("Unmanaged window 0x%lx\n", self->window); + ob_debug("Unmanaged window 0x%lx", self->window); /* free all data allocated in the client struct */ g_slist_free(self->transients); @@ -742,6 +720,7 @@ void client_unmanage(ObClient *self) g_free(self->icons[j].data); if (self->nicons > 0) g_free(self->icons); + g_free(self->startup_id); g_free(self->wm_command); g_free(self->title); g_free(self->icon_title); @@ -791,7 +770,7 @@ static ObAppSettings *client_get_settings_state(ObClient *self) match = FALSE; if (match) { - ob_debug("Window matching: %s\n", app->name); + ob_debug("Window matching: %s", app->name); /* copy the settings to our struct, overriding the existing settings if they are not defaults */ @@ -846,17 +825,17 @@ static void client_restore_session_state(ObClient *self) GList *it; ob_debug_type(OB_DEBUG_SM, - "Restore session for client %s\n", self->title); + "Restore session for client %s", self->title); if (!(it = session_state_find(self))) { ob_debug_type(OB_DEBUG_SM, - "Session data not found for client %s\n", self->title); + "Session data not found for client %s", self->title); return; } self->session = it->data; - ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s\n", + ob_debug_type(OB_DEBUG_SM, "Session data loaded for client %s", self->title); RECT_SET_POINT(self->area, self->session->x, self->session->y); @@ -866,13 +845,13 @@ static void client_restore_session_state(ObClient *self) self->area.width = self->session->w; if (self->session->h > 0) self->area.height = self->session->h; - XResizeWindow(ob_display, self->window, + XResizeWindow(obt_display, self->window, self->area.width, self->area.height); self->desktop = (self->session->desktop == DESKTOP_ALL ? self->session->desktop : MIN(screen_num_desktops - 1, self->session->desktop)); - PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop); + OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, self->desktop); self->shaded = self->session->shaded; self->iconic = self->session->iconic; @@ -931,6 +910,7 @@ gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h, gint fw, fh; Rect desired; guint i; + gboolean found_mon; RECT_SET(desired, *x, *y, w, h); frame_rect_to_frame(self->frame, &desired); @@ -980,13 +960,26 @@ gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h, rudeb = TRUE; } + /* we iterate through every monitor that the window is at least partially + on, to make sure it is obeying the rules on them all + + if the window does not appear on any monitors, then use the first one + */ + found_mon = FALSE; for (i = 0; i < screen_num_monitors; ++i) { Rect *a; - if (!screen_physical_area_monitor_contains(i, &desired)) - continue; + if (!screen_physical_area_monitor_contains(i, &desired)) { + if (i < screen_num_monitors - 1 || found_mon) + continue; - a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &desired); + /* the window is not inside any monitor! so just use the first + one */ + a = screen_area(self->desktop, 0, NULL); + } else { + found_mon = TRUE; + a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &desired); + } /* This makes sure windows aren't entirely outside of the screen so you can't see them at all. @@ -1003,7 +996,7 @@ gboolean client_find_onscreen(ObClient *self, gint *x, gint *y, gint w, gint h, if (!self->strut.left && *x + fw*9/10 - 1 < a->x) *x = a->x - fw*9/10; if (!self->strut.top && *y + fh*9/10 - 1 < a->y) - *y = a->y - fw*9/10; + *y = a->y - fh*9/10; } /* This here doesn't let windows even a pixel outside the @@ -1072,7 +1065,7 @@ static void client_get_all(ObClient *self, gboolean real) if (self->type == OB_CLIENT_TYPE_DESKTOP) self->desktop = DESKTOP_ALL; } - + #ifdef SYNC client_update_sync_request_counter(self); #endif @@ -1080,33 +1073,31 @@ static void client_get_all(ObClient *self, gboolean real) client_get_colormap(self); client_update_strut(self); client_update_icons(self); - client_update_user_time_window(self); - if (!self->user_time_window) /* check if this would have been called */ - client_update_user_time(self); client_update_icon_geometry(self); } static void client_get_startup_id(ObClient *self) { - if (!(PROP_GETS(self->window, net_startup_id, utf8, &self->startup_id))) + if (!(OBT_PROP_GETS(self->window, NET_STARTUP_ID, utf8, + &self->startup_id))) if (self->group) - PROP_GETS(self->group->leader, - net_startup_id, utf8, &self->startup_id); + OBT_PROP_GETS(self->group->leader, + NET_STARTUP_ID, utf8, &self->startup_id); } static void client_get_area(ObClient *self) { XWindowAttributes wattrib; Status ret; - - ret = XGetWindowAttributes(ob_display, self->window, &wattrib); + + ret = XGetWindowAttributes(obt_display, self->window, &wattrib); g_assert(ret != BadWindow); RECT_SET(self->area, wattrib.x, wattrib.y, wattrib.width, wattrib.height); POINT_SET(self->root_pos, wattrib.x, wattrib.y); self->border_width = wattrib.border_width; - ob_debug("client area: %d %d %d %d bw %d\n", wattrib.x, wattrib.y, + ob_debug("client area: %d %d %d %d bw %d", wattrib.x, wattrib.y, wattrib.width, wattrib.height, wattrib.border_width); } @@ -1114,12 +1105,12 @@ static void client_get_desktop(ObClient *self) { guint32 d = screen_num_desktops; /* an always-invalid value */ - if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) { + if (OBT_PROP_GET32(self->window, NET_WM_DESKTOP, CARDINAL, &d)) { if (d >= screen_num_desktops && d != DESKTOP_ALL) self->desktop = screen_num_desktops - 1; else self->desktop = d; - ob_debug("client requested desktop 0x%x\n", self->desktop); + ob_debug("client requested desktop 0x%x", self->desktop); } else { GSList *it; gboolean first = TRUE; @@ -1142,7 +1133,7 @@ static void client_get_desktop(ObClient *self) if (all != screen_num_desktops) { self->desktop = all; - ob_debug("client desktop set from parents: 0x%x\n", + ob_debug("client desktop set from parents: 0x%x", self->desktop); } /* try get from the startup-notification protocol */ @@ -1150,13 +1141,13 @@ static void client_get_desktop(ObClient *self) if (self->desktop >= screen_num_desktops && self->desktop != DESKTOP_ALL) self->desktop = screen_num_desktops - 1; - ob_debug("client desktop set from startup-notification: 0x%x\n", + ob_debug("client desktop set from startup-notification: 0x%x", self->desktop); } /* defaults to the current desktop */ else { self->desktop = screen_desktop; - ob_debug("client desktop set to the current desktop: %d\n", + ob_debug("client desktop set to the current desktop: %d", self->desktop); } } @@ -1166,33 +1157,33 @@ static void client_get_state(ObClient *self) { guint32 *state; guint num; - - if (PROP_GETA32(self->window, net_wm_state, atom, &state, &num)) { + + if (OBT_PROP_GETA32(self->window, NET_WM_STATE, ATOM, &state, &num)) { gulong i; for (i = 0; i < num; ++i) { - if (state[i] == prop_atoms.net_wm_state_modal) + if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_MODAL)) self->modal = TRUE; - else if (state[i] == prop_atoms.net_wm_state_shaded) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_SHADED)) self->shaded = TRUE; - else if (state[i] == prop_atoms.net_wm_state_hidden) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN)) self->iconic = TRUE; - else if (state[i] == prop_atoms.net_wm_state_skip_taskbar) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR)) self->skip_taskbar = TRUE; - else if (state[i] == prop_atoms.net_wm_state_skip_pager) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER)) self->skip_pager = TRUE; - else if (state[i] == prop_atoms.net_wm_state_fullscreen) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN)) self->fullscreen = TRUE; - else if (state[i] == prop_atoms.net_wm_state_maximized_vert) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT)) self->max_vert = TRUE; - else if (state[i] == prop_atoms.net_wm_state_maximized_horz) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ)) self->max_horz = TRUE; - else if (state[i] == prop_atoms.net_wm_state_above) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_ABOVE)) self->above = TRUE; - else if (state[i] == prop_atoms.net_wm_state_below) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_BELOW)) self->below = TRUE; - else if (state[i] == prop_atoms.net_wm_state_demands_attention) + else if (state[i] == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION)) self->demands_attention = TRUE; - else if (state[i] == prop_atoms.ob_wm_state_undecorated) + else if (state[i] == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED)) self->undecorated = TRUE; } @@ -1204,14 +1195,14 @@ static void client_get_shaped(ObClient *self) { self->shaped = FALSE; #ifdef SHAPE - if (extensions_shape) { + if (obt_display_extension_shape) { gint foo; guint ufoo; gint s; - XShapeSelectInput(ob_display, self->window, ShapeNotifyMask); + XShapeSelectInput(obt_display, self->window, ShapeNotifyMask); - XShapeQueryExtents(ob_display, self->window, &s, &foo, + XShapeQueryExtents(obt_display, self->window, &s, &foo, &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo); self->shaped = (s != 0); @@ -1225,22 +1216,22 @@ void client_update_transient_for(ObClient *self) ObClient *target = NULL; gboolean trangroup = FALSE; - if (XGetTransientForHint(ob_display, self->window, &t)) { + if (XGetTransientForHint(obt_display, self->window, &t)) { if (t != self->window) { /* cant be transient to itself! */ - target = g_hash_table_lookup(window_map, &t); + ObWindow *tw = window_find(t); /* if this happens then we need to check for it*/ - g_assert(target != self); - if (target && !WINDOW_IS_CLIENT(target)) { - /* this can happen when a dialog is a child of - a dockapp, for example */ - target = NULL; + g_assert(tw != CLIENT_AS_WINDOW(self)); + if (tw && WINDOW_IS_CLIENT(tw)) { + /* watch out for windows with a parent that is something + different, like a dockapp for example */ + target = WINDOW_AS_CLIENT(tw); } } /* Setting the transient_for to Root is actually illegal, however applications from time have done this to specify transient for their group */ - if (!target && self->group && t == RootWindow(ob_display, ob_screen)) + if (!target && self->group && t == obt_root(ob_screen)) trangroup = TRUE; } else if (self->group && self->transient) trangroup = TRUE; @@ -1249,7 +1240,7 @@ void client_update_transient_for(ObClient *self) self->transient_for_group, trangroup, client_direct_parent(self), target); self->transient_for_group = trangroup; - + } static void client_update_transient_tree(ObClient *self, @@ -1337,7 +1328,7 @@ static void client_update_transient_tree(ObClient *self, C is transient for B A can't be transient for C or we have a cycle */ - if (!newgtran && + if (!newgtran && newgroup && (!newparent || !client_search_top_direct_parent(newparent)->transient_for_group) && client_normal(self)) @@ -1356,7 +1347,8 @@ static void client_update_transient_tree(ObClient *self, /** If we change our group transient-ness, our children change their effect group transient-ness, which affects how they relate to other - group windows */ + group windows **/ + for (it = self->transients; it; it = g_slist_next(it)) { c = it->data; if (!c->transient_for_group) @@ -1375,8 +1367,8 @@ static void client_get_mwm_hints(ObClient *self) self->mwmhints.flags = 0; /* default to none */ - if (PROP_GETA32(self->window, motif_wm_hints, motif_wm_hints, - &hints, &num)) { + if (OBT_PROP_GETA32(self->window, MOTIF_WM_HINTS, MOTIF_WM_HINTS, + &hints, &num)) { if (num >= OB_MWM_ELEMENTS) { self->mwmhints.flags = hints[0]; self->mwmhints.functions = hints[1]; @@ -1394,27 +1386,28 @@ void client_get_type_and_transientness(ObClient *self) self->type = -1; self->transient = FALSE; - - if (PROP_GETA32(self->window, net_wm_window_type, atom, &val, &num)) { + + if (OBT_PROP_GETA32(self->window, NET_WM_WINDOW_TYPE, ATOM, &val, &num)) { /* use the first value that we know about in the array */ for (i = 0; i < num; ++i) { - if (val[i] == prop_atoms.net_wm_window_type_desktop) + if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP)) self->type = OB_CLIENT_TYPE_DESKTOP; - else if (val[i] == prop_atoms.net_wm_window_type_dock) + else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK)) self->type = OB_CLIENT_TYPE_DOCK; - else if (val[i] == prop_atoms.net_wm_window_type_toolbar) + else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR)) self->type = OB_CLIENT_TYPE_TOOLBAR; - else if (val[i] == prop_atoms.net_wm_window_type_menu) + else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU)) self->type = OB_CLIENT_TYPE_MENU; - else if (val[i] == prop_atoms.net_wm_window_type_utility) + else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY)) self->type = OB_CLIENT_TYPE_UTILITY; - else if (val[i] == prop_atoms.net_wm_window_type_splash) + else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH)) self->type = OB_CLIENT_TYPE_SPLASH; - else if (val[i] == prop_atoms.net_wm_window_type_dialog) + else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG)) self->type = OB_CLIENT_TYPE_DIALOG; - else if (val[i] == prop_atoms.net_wm_window_type_normal) + else if (val[i] == OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL)) self->type = OB_CLIENT_TYPE_NORMAL; - else if (val[i] == prop_atoms.kde_net_wm_window_type_override) { + else if (val[i] == OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE)) + { /* prevent this window from getting any decor or functionality */ self->mwmhints.flags &= (OB_MWM_FLAG_FUNCTIONS | @@ -1428,9 +1421,9 @@ void client_get_type_and_transientness(ObClient *self) g_free(val); } - if (XGetTransientForHint(ob_display, self->window, &t)) + if (XGetTransientForHint(obt_display, self->window, &t)) self->transient = TRUE; - + if (self->type == (ObClientType) -1) { /*the window type hint was not set, which means we either classify ourself as a normal window or a dialog, depending on if we are a @@ -1454,22 +1447,26 @@ void client_get_type_and_transientness(ObClient *self) void client_update_protocols(ObClient *self) { guint32 *proto; - guint num_return, i; + guint num_ret, i; self->focus_notify = FALSE; self->delete_window = FALSE; - if (PROP_GETA32(self->window, wm_protocols, atom, &proto, &num_return)) { - for (i = 0; i < num_return; ++i) { - if (proto[i] == prop_atoms.wm_delete_window) + if (OBT_PROP_GETA32(self->window, WM_PROTOCOLS, ATOM, &proto, &num_ret)) { + for (i = 0; i < num_ret; ++i) { + if (proto[i] == OBT_PROP_ATOM(WM_DELETE_WINDOW)) /* this means we can request the window to close */ self->delete_window = TRUE; - else if (proto[i] == prop_atoms.wm_take_focus) + else if (proto[i] == OBT_PROP_ATOM(WM_TAKE_FOCUS)) /* if this protocol is requested, then the window will be notified whenever we want it to receive focus */ self->focus_notify = TRUE; + else if (proto[i] == OBT_PROP_ATOM(NET_WM_PING)) + /* if this protocol is requested, then the window will allow + pings to determine if it is still alive */ + self->ping = TRUE; #ifdef SYNC - else if (proto[i] == prop_atoms.net_wm_sync_request) + else if (proto[i] == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST)) /* if this protocol is requested, then resizing the window will be synchronized between the frame and the client */ @@ -1485,18 +1482,19 @@ void client_update_sync_request_counter(ObClient *self) { guint32 i; - if (PROP_GET32(self->window, net_wm_sync_request_counter, cardinal, &i)) { + if (OBT_PROP_GET32(self->window, NET_WM_SYNC_REQUEST_COUNTER, CARDINAL,&i)) + { self->sync_counter = i; } else self->sync_counter = None; } #endif -void client_get_colormap(ObClient *self) +static void client_get_colormap(ObClient *self) { XWindowAttributes wa; - if (XGetWindowAttributes(ob_display, self->window, &wa)) + if (XGetWindowAttributes(obt_display, self->window, &wa)) client_update_colormap(self, wa.colormap); } @@ -1504,7 +1502,7 @@ void client_update_colormap(ObClient *self, Colormap colormap) { if (colormap == self->colormap) return; - ob_debug("Setting client %s colormap: 0x%x\n", self->title, colormap); + ob_debug("Setting client %s colormap: 0x%x", self->title, colormap); if (client_focused(self)) { screen_install_colormap(self, FALSE); /* uninstall old one */ @@ -1528,7 +1526,7 @@ void client_update_normal_hints(ObClient *self) SIZE_SET(self->max_size, G_MAXINT, G_MAXINT); /* get the hints from the window */ - if (XGetWMNormalHints(ob_display, self->window, &size, &ret)) { + if (XGetWMNormalHints(obt_display, self->window, &size, &ret)) { /* normal windows can't request placement! har har if (!client_normal(self)) */ @@ -1549,25 +1547,25 @@ void client_update_normal_hints(ObClient *self) if (size.flags & PMinSize) SIZE_SET(self->min_size, size.min_width, size.min_height); - + if (size.flags & PMaxSize) SIZE_SET(self->max_size, size.max_width, size.max_height); - + if (size.flags & PBaseSize) SIZE_SET(self->base_size, size.base_width, size.base_height); - + if (size.flags & PResizeInc && size.width_inc && size.height_inc) SIZE_SET(self->size_inc, size.width_inc, size.height_inc); - ob_debug("Normal hints: min size (%d %d) max size (%d %d)\n " - "size inc (%d %d) base size (%d %d)\n", + ob_debug("Normal hints: min size (%d %d) max size (%d %d)", self->min_size.width, self->min_size.height, - self->max_size.width, self->max_size.height, + self->max_size.width, self->max_size.height); + ob_debug("size inc (%d %d) base size (%d %d)", self->size_inc.width, self->size_inc.height, self->base_size.width, self->base_size.height); } else - ob_debug("Normal hints: not set\n"); + ob_debug("Normal hints: not set"); } void client_setup_decor_and_functions(ObClient *self, gboolean reconfig) @@ -1602,11 +1600,16 @@ void client_setup_decor_and_functions(ObClient *self, gboolean reconfig) switch (self->type) { case OB_CLIENT_TYPE_NORMAL: /* normal windows retain all of the possible decorations and - functionality, and are the only windows that you can fullscreen */ + functionality, and can be fullscreen */ self->functions |= OB_CLIENT_FUNC_FULLSCREEN; break; case OB_CLIENT_TYPE_DIALOG: + /* sometimes apps make dialog windows fullscreen for some reason (for + e.g. kpdf does this..) */ + self->functions |= OB_CLIENT_FUNC_FULLSCREEN; + break; + case OB_CLIENT_TYPE_UTILITY: /* these windows don't have anything added or removed by default */ break; @@ -1735,43 +1738,43 @@ static void client_change_allowed_actions(ObClient *self) /* desktop windows are kept on all desktops */ if (self->type != OB_CLIENT_TYPE_DESKTOP) - actions[num++] = prop_atoms.net_wm_action_change_desktop; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP); if (self->functions & OB_CLIENT_FUNC_SHADE) - actions[num++] = prop_atoms.net_wm_action_shade; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE); if (self->functions & OB_CLIENT_FUNC_CLOSE) - actions[num++] = prop_atoms.net_wm_action_close; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE); if (self->functions & OB_CLIENT_FUNC_MOVE) - actions[num++] = prop_atoms.net_wm_action_move; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE); if (self->functions & OB_CLIENT_FUNC_ICONIFY) - actions[num++] = prop_atoms.net_wm_action_minimize; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE); if (self->functions & OB_CLIENT_FUNC_RESIZE) - actions[num++] = prop_atoms.net_wm_action_resize; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE); if (self->functions & OB_CLIENT_FUNC_FULLSCREEN) - actions[num++] = prop_atoms.net_wm_action_fullscreen; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN); if (self->functions & OB_CLIENT_FUNC_MAXIMIZE) { - actions[num++] = prop_atoms.net_wm_action_maximize_horz; - actions[num++] = prop_atoms.net_wm_action_maximize_vert; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ); + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT); } if (self->functions & OB_CLIENT_FUNC_ABOVE) - actions[num++] = prop_atoms.net_wm_action_above; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE); if (self->functions & OB_CLIENT_FUNC_BELOW) - actions[num++] = prop_atoms.net_wm_action_below; + actions[num++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW); if (self->functions & OB_CLIENT_FUNC_UNDECORATE) - actions[num++] = prop_atoms.ob_wm_action_undecorate; + actions[num++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE); - PROP_SETA32(self->window, net_wm_allowed_actions, atom, actions, num); + OBT_PROP_SETA32(self->window, NET_WM_ALLOWED_ACTIONS, ATOM, actions, num); - /* make sure the window isn't breaking any rules now */ + /* make sure the window isn't breaking any rules now + + don't check ICONIFY here. just cuz a window can't iconify doesnt mean + it can't be iconified with its parent + */ if (!(self->functions & OB_CLIENT_FUNC_SHADE) && self->shaded) { if (self->frame) client_shade(self, FALSE); else self->shaded = FALSE; } - if (!(self->functions & OB_CLIENT_FUNC_ICONIFY) && self->iconic) { - if (self->frame) client_iconify(self, FALSE, TRUE, FALSE); - else self->iconic = FALSE; - } if (!(self->functions & OB_CLIENT_FUNC_FULLSCREEN) && self->fullscreen) { if (self->frame) client_fullscreen(self, FALSE); else self->fullscreen = FALSE; @@ -1789,8 +1792,8 @@ void client_update_wmhints(ObClient *self) /* assume a window takes input if it doesnt specify */ self->can_focus = TRUE; - - if ((hints = XGetWMHints(ob_display, self->window)) != NULL) { + + if ((hints = XGetWMHints(obt_display, self->window)) != NULL) { gboolean ur; if (hints->flags & InputHint) @@ -1876,17 +1879,17 @@ void client_update_title(ObClient *self) gchar *visible = NULL; g_free(self->title); - + /* try netwm */ - if (!PROP_GETS(self->window, net_wm_name, utf8, &data)) { + if (!OBT_PROP_GETS(self->window, NET_WM_NAME, utf8, &data)) { /* try old x stuff */ - if (!(PROP_GETS(self->window, wm_name, locale, &data) - || PROP_GETS(self->window, wm_name, utf8, &data))) { + if (!(OBT_PROP_GETS(self->window, WM_NAME, locale, &data) + || OBT_PROP_GETS(self->window, WM_NAME, utf8, &data))) { if (self->transient) { - /* - GNOME alert windows are not given titles: - http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html - */ + /* + GNOME alert windows are not given titles: + http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html + */ data = g_strdup(""); } else data = g_strdup("Unnamed Window"); @@ -1899,7 +1902,16 @@ void client_update_title(ObClient *self) } else visible = data; - PROP_SETS(self->window, net_wm_visible_name, visible); + if (self->not_responding) { + data = visible; + if (self->close_tried_term) + visible = g_strdup_printf("%s - [%s]", data, _("Killing...")); + else + visible = g_strdup_printf("%s - [%s]", data, _("Not Responding")); + g_free(data); + } + + OBT_PROP_SETS(self->window, NET_WM_VISIBLE_NAME, utf8, visible); self->title = visible; if (self->frame) @@ -1910,10 +1922,10 @@ void client_update_title(ObClient *self) g_free(self->icon_title); /* try netwm */ - if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data)) + if (!OBT_PROP_GETS(self->window, NET_WM_ICON_NAME, utf8, &data)) /* try old x stuff */ - if (!(PROP_GETS(self->window, wm_icon_name, locale, &data) || - PROP_GETS(self->window, wm_icon_name, utf8, &data))) + if (!(OBT_PROP_GETS(self->window, WM_ICON_NAME, locale, &data) || + OBT_PROP_GETS(self->window, WM_ICON_NAME, utf8, &data))) data = g_strdup(self->title); if (self->client_machine) { @@ -1922,7 +1934,16 @@ void client_update_title(ObClient *self) } else visible = data; - PROP_SETS(self->window, net_wm_visible_icon_name, visible); + if (self->not_responding) { + data = visible; + if (self->close_tried_term) + visible = g_strdup_printf("%s - [%s]", data, _("Killing...")); + else + visible = g_strdup_printf("%s - [%s]", data, _("Not Responding")); + g_free(data); + } + + OBT_PROP_SETS(self->window, NET_WM_VISIBLE_ICON_NAME, utf8, visible); self->icon_title = visible; } @@ -1933,8 +1954,9 @@ void client_update_strut(ObClient *self) gboolean got = FALSE; StrutPartial strut; - if (PROP_GETA32(self->window, net_wm_strut_partial, cardinal, - &data, &num)) { + if (OBT_PROP_GETA32(self->window, NET_WM_STRUT_PARTIAL, CARDINAL, + &data, &num)) + { if (num == 12) { got = TRUE; STRUT_PARTIAL_SET(strut, @@ -1946,7 +1968,7 @@ void client_update_strut(ObClient *self) } if (!got && - PROP_GETA32(self->window, net_wm_strut, cardinal, &data, &num)) { + OBT_PROP_GETA32(self->window, NET_WM_STRUT, CARDINAL, &data, &num)) { if (num == 4) { Rect *a; @@ -1980,11 +2002,17 @@ void client_update_strut(ObClient *self) } } +/* Avoid storing icons above this size if possible */ +#define AVOID_ABOVE 64 + void client_update_icons(ObClient *self) { guint num; guint32 *data; guint w, h, i, j; + guint num_seen; /* number of icons present */ + guint num_small_seen; /* number of icons small enough present */ + guint smallest, smallest_area; for (i = 0; i < self->nicons; ++i) g_free(self->icons[i].data); @@ -1992,28 +2020,57 @@ void client_update_icons(ObClient *self) g_free(self->icons); self->nicons = 0; - if (PROP_GETA32(self->window, net_wm_icon, cardinal, &data, &num)) { + if (OBT_PROP_GETA32(self->window, NET_WM_ICON, CARDINAL, &data, &num)) { /* figure out how many valid icons are in here */ i = 0; - while (num - i > 2) { - w = data[i++]; - h = data[i++]; - i += w * h; - if (i > num || w*h == 0) break; - ++self->nicons; - } + num_seen = num_small_seen = 0; + smallest = smallest_area = 0; + if (num > 2) + while (i < num) { + w = data[i++]; + h = data[i++]; + i += w * h; + /* watch for it being too small for the specified size, or for + zero sized icons. */ + if (i > num || w == 0 || h == 0) break; + + if (!smallest_area || w*h < smallest_area) { + smallest = num_seen; + smallest_area = w*h; + } + ++num_seen; + if (w <= AVOID_ABOVE && h <= AVOID_ABOVE) + ++num_small_seen; + } + if (num_small_seen > 0) + self->nicons = num_small_seen; + else if (num_seen) + self->nicons = 1; self->icons = g_new(ObClientIcon, self->nicons); - + /* store the icons */ i = 0; - for (j = 0; j < self->nicons; ++j) { + for (j = 0; j < self->nicons;) { guint x, y, t; w = self->icons[j].width = data[i++]; h = self->icons[j].height = data[i++]; - if (w*h == 0) continue; + /* if there are some icons smaller than the threshold, we're + skipping all the ones above */ + if (num_small_seen > 0) { + if (w > AVOID_ABOVE || h > AVOID_ABOVE) { + i += w*h; + continue; + } + } + /* if there were no icons smaller than the threshold, then we are + only taking the smallest available one we saw */ + else if (j != smallest) { + i += w*h; + continue; + } self->icons[j].data = g_new(RrPixel32, w * h); for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) { @@ -2028,17 +2085,19 @@ void client_update_icons(ObClient *self) (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset); } g_assert(i <= num); + + ++j; } g_free(data); } else { XWMHints *hints; - if ((hints = XGetWMHints(ob_display, self->window))) { + if ((hints = XGetWMHints(obt_display, self->window))) { if (hints->flags & IconPixmapHint) { self->nicons = 1; self->icons = g_new(ObClientIcon, self->nicons); - xerror_set_ignore(TRUE); + obt_display_ignore_errors(TRUE); if (!RrPixmapToRGBA(ob_rr_inst, hints->icon_pixmap, (hints->flags & IconMaskHint ? @@ -2050,7 +2109,7 @@ void client_update_icons(ObClient *self) g_free(self->icons); self->nicons = 0; } - xerror_set_ignore(FALSE); + obt_display_ignore_errors(FALSE); } XFree(hints); } @@ -2061,7 +2120,7 @@ void client_update_icons(ObClient *self) or removes it entirely, it's not very likely it is going to set one right away afterwards - if it has parents, then one of them will have an icon already + if it has parents, then one of them will have an icon already */ if (self->nicons == 0 && !self->parents) { RrPixel32 *icon = ob_rr_theme->def_win_icon; @@ -2074,7 +2133,7 @@ void client_update_icons(ObClient *self) (((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) + (((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) + (((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0); - PROP_SETA32(self->window, net_wm_icon, cardinal, data, 48*48+2); + OBT_PROP_SETA32(self->window, NET_WM_ICON, CARDINAL, data, 48*48+2); g_free(data); } else if (self->frame) /* don't draw the icon empty if we're just setting one now anyways, @@ -2082,62 +2141,6 @@ void client_update_icons(ObClient *self) frame_adjust_icon(self->frame); } -void client_update_user_time(ObClient *self) -{ - guint32 time; - gboolean got = FALSE; - - if (self->user_time_window) - got = PROP_GET32(self->user_time_window, - net_wm_user_time, cardinal, &time); - if (!got) - got = PROP_GET32(self->window, net_wm_user_time, cardinal, &time); - - if (got) { - /* we set this every time, not just when it grows, because in practice - sometimes time goes backwards! (ntpdate.. yay....) so.. if it goes - backward we don't want all windows to stop focusing. we'll just - assume noone is setting times older than the last one, cuz that - would be pretty stupid anyways - */ - self->user_time = time; - - /*ob_debug("window %s user time %u\n", self->title, time);*/ - } -} - -void client_update_user_time_window(ObClient *self) -{ - guint32 w; - - if (!PROP_GET32(self->window, net_wm_user_time_window, window, &w)) - w = None; - - if (w != self->user_time_window) { - /* remove the old window */ - propwin_remove(self->user_time_window, OB_PROPWIN_USER_TIME, self); - self->user_time_window = None; - - if (self->group && self->group->leader == w) { - ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its " - "_NET_WM_USER_TYPE_WINDOW to its group leader\n"); - /* do it anyways..? */ - } - else if (w == self->window) { - ob_debug_type(OB_DEBUG_APP_BUGS, "Window is setting its " - "_NET_WM_USER_TIME_WINDOW to itself\n"); - w = None; /* don't do it */ - } - - /* add the new window */ - propwin_add(w, OB_PROPWIN_USER_TIME, self); - self->user_time_window = w; - - /* and update from it */ - client_update_user_time(self); - } -} - void client_update_icon_geometry(ObClient *self) { guint num; @@ -2145,12 +2148,14 @@ void client_update_icon_geometry(ObClient *self) RECT_SET(self->icon_geometry, 0, 0, 0, 0); - if (PROP_GETA32(self->window, net_wm_icon_geometry, cardinal, &data, &num) - && num == 4) + if (OBT_PROP_GETA32(self->window, NET_WM_ICON_GEOMETRY, CARDINAL, + &data, &num)) { - /* don't let them set it with an area < 0 */ - RECT_SET(self->icon_geometry, data[0], data[1], - MAX(data[2],0), MAX(data[3],0)); + if (num == 4) + /* don't let them set it with an area < 0 */ + RECT_SET(self->icon_geometry, data[0], data[1], + MAX(data[2],0), MAX(data[3],0)); + g_free(data); } } @@ -2161,23 +2166,23 @@ static void client_get_session_ids(ObClient *self) gchar *s; gchar **ss; - if (!PROP_GET32(self->window, wm_client_leader, window, &leader)) + if (!OBT_PROP_GET32(self->window, WM_CLIENT_LEADER, WINDOW, &leader)) leader = None; /* get the SM_CLIENT_ID */ got = FALSE; if (leader) - got = PROP_GETS(leader, sm_client_id, locale, &self->sm_client_id); + got = OBT_PROP_GETS(leader, SM_CLIENT_ID, locale, &self->sm_client_id); if (!got) - PROP_GETS(self->window, sm_client_id, locale, &self->sm_client_id); + OBT_PROP_GETS(self->window, SM_CLIENT_ID, locale, &self->sm_client_id); /* get the WM_CLASS (name and class). make them "" if they are not provided */ got = FALSE; if (leader) - got = PROP_GETSS(leader, wm_class, locale, &ss); + got = OBT_PROP_GETSS(leader, WM_CLASS, locale, &ss); if (!got) - got = PROP_GETSS(self->window, wm_class, locale, &ss); + got = OBT_PROP_GETSS(self->window, WM_CLASS, locale, &ss); if (got) { if (ss[0]) { @@ -2194,9 +2199,9 @@ static void client_get_session_ids(ObClient *self) /* get the WM_WINDOW_ROLE. make it "" if it is not provided */ got = FALSE; if (leader) - got = PROP_GETS(leader, wm_window_role, locale, &s); + got = OBT_PROP_GETS(leader, WM_WINDOW_ROLE, locale, &s); if (!got) - got = PROP_GETS(self->window, wm_window_role, locale, &s); + got = OBT_PROP_GETS(self->window, WM_WINDOW_ROLE, locale, &s); if (got) self->role = s; @@ -2207,9 +2212,9 @@ static void client_get_session_ids(ObClient *self) got = FALSE; if (leader) - got = PROP_GETSS(leader, wm_command, locale, &ss); + got = OBT_PROP_GETSS(leader, WM_COMMAND, locale, &ss); if (!got) - got = PROP_GETSS(self->window, wm_command, locale, &ss); + got = OBT_PROP_GETSS(self->window, WM_COMMAND, locale, &ss); if (got) { /* merge/mash them all together */ @@ -2232,12 +2237,13 @@ static void client_get_session_ids(ObClient *self) /* get the WM_CLIENT_MACHINE */ got = FALSE; if (leader) - got = PROP_GETS(leader, wm_client_machine, locale, &s); + got = OBT_PROP_GETS(leader, WM_CLIENT_MACHINE, locale, &s); if (!got) - got = PROP_GETS(self->window, wm_client_machine, locale, &s); + got = OBT_PROP_GETS(self->window, WM_CLIENT_MACHINE, locale, &s); if (got) { gchar localhost[128]; + guint32 pid; gethostname(localhost, 127); localhost[127] = '\0'; @@ -2245,6 +2251,11 @@ static void client_get_session_ids(ObClient *self) self->client_machine = s; else g_free(s); + + /* see if it has the PID set too (the PID requires that the + WM_CLIENT_MACHINE be set) */ + if (OBT_PROP_GET32(self->window, NET_WM_PID, CARDINAL, &pid)) + self->pid = pid; } } @@ -2263,12 +2274,12 @@ static void client_change_wm_state(ObClient *self) self->wmstate = NormalState; if (old != self->wmstate) { - PROP_MSG(self->window, kde_wm_change_state, - self->wmstate, 1, 0, 0); + OBT_PROP_MSG(ob_screen, self->window, KDE_WM_CHANGE_STATE, + self->wmstate, 1, 0, 0, 0); state[0] = self->wmstate; state[1] = None; - PROP_SETA32(self->window, wm_state, wm_state, state, 2); + OBT_PROP_SETA32(self->window, WM_STATE, WM_STATE, state, 2); } } @@ -2279,30 +2290,30 @@ static void client_change_state(ObClient *self) num = 0; if (self->modal) - netstate[num++] = prop_atoms.net_wm_state_modal; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL); if (self->shaded) - netstate[num++] = prop_atoms.net_wm_state_shaded; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED); if (self->iconic) - netstate[num++] = prop_atoms.net_wm_state_hidden; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN); if (self->skip_taskbar) - netstate[num++] = prop_atoms.net_wm_state_skip_taskbar; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR); if (self->skip_pager) - netstate[num++] = prop_atoms.net_wm_state_skip_pager; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER); if (self->fullscreen) - netstate[num++] = prop_atoms.net_wm_state_fullscreen; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN); if (self->max_vert) - netstate[num++] = prop_atoms.net_wm_state_maximized_vert; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT); if (self->max_horz) - netstate[num++] = prop_atoms.net_wm_state_maximized_horz; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ); if (self->above) - netstate[num++] = prop_atoms.net_wm_state_above; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE); if (self->below) - netstate[num++] = prop_atoms.net_wm_state_below; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW); if (self->demands_attention) - netstate[num++] = prop_atoms.net_wm_state_demands_attention; + netstate[num++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION); if (self->undecorated) - netstate[num++] = prop_atoms.ob_wm_state_undecorated; - PROP_SETA32(self->window, net_wm_state, atom, netstate, num); + netstate[num++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED); + OBT_PROP_SETA32(self->window, NET_WM_STATE, ATOM, netstate, num); if (self->frame) frame_adjust_state(self->frame); @@ -2382,7 +2393,15 @@ static ObStackingLayer calc_layer(ObClient *self) (self->decorations == 0 && !(self->max_horz && self->max_vert) && RECT_EQUAL(self->area, *monitor))) && - (client_focused(self) || client_search_focus_tree(self))) + /* you are fullscreen while you or your children are focused.. */ + (client_focused(self) || client_search_focus_tree(self) || + /* you can be fullscreen if you're on another desktop */ + (self->desktop != screen_desktop && + self->desktop != DESKTOP_ALL) || + /* and you can also be fullscreen if the focused client is on + another monitor, or nothing else is focused */ + (!focus_client || + client_monitor(focus_client) != client_monitor(self)))) l = OB_STACKING_LAYER_FULLSCREEN; else if (self->above) l = OB_STACKING_LAYER_ABOVE; else if (self->below) l = OB_STACKING_LAYER_BELOW; @@ -2408,23 +2427,54 @@ static void client_calc_layer_recursive(ObClient *self, ObClient *orig, stacking_add_nonintrusive(CLIENT_AS_WINDOW(self)); } + /* we've been restacked */ + self->visited = TRUE; + for (it = self->transients; it; it = g_slist_next(it)) client_calc_layer_recursive(it->data, orig, self->layer); } +static void client_calc_layer_internal(ObClient *self) +{ + GSList *sit; + + /* transients take on the layer of their parents */ + sit = client_search_all_top_parents(self); + + for (; sit; sit = g_slist_next(sit)) + client_calc_layer_recursive(sit->data, self, 0); +} + void client_calc_layer(ObClient *self) { - ObClient *orig; - GSList *it; + GList *it; - orig = self; + /* skip over stuff above fullscreen layer */ + for (it = stacking_list; it; it = g_list_next(it)) + if (window_layer(it->data) <= OB_STACKING_LAYER_FULLSCREEN) break; - /* transients take on the layer of their parents */ - it = client_search_all_top_parents(self); + /* find the windows in the fullscreen layer, and mark them not-visited */ + for (; it; it = g_list_next(it)) { + if (window_layer(it->data) < OB_STACKING_LAYER_FULLSCREEN) break; + else if (WINDOW_IS_CLIENT(it->data)) + WINDOW_AS_CLIENT(it->data)->visited = FALSE; + } + + client_calc_layer_internal(self); + + /* skip over stuff above fullscreen layer */ + for (it = stacking_list; it; it = g_list_next(it)) + if (window_layer(it->data) <= OB_STACKING_LAYER_FULLSCREEN) break; - for (; it; it = g_slist_next(it)) - client_calc_layer_recursive(it->data, orig, 0); + /* now recalc any windows in the fullscreen layer which have not + had their layer recalced already */ + for (; it; it = g_list_next(it)) { + if (window_layer(it->data) < OB_STACKING_LAYER_FULLSCREEN) break; + else if (WINDOW_IS_CLIENT(it->data) && + !WINDOW_AS_CLIENT(it->data)->visited) + client_calc_layer_internal(it->data); + } } gboolean client_should_show(ObClient *self) @@ -2435,7 +2485,7 @@ gboolean client_should_show(ObClient *self) return FALSE; if (self->desktop == screen_desktop || self->desktop == DESKTOP_ALL) return TRUE; - + return FALSE; } @@ -2561,7 +2611,7 @@ static void client_apply_startup_state(ObClient *self, pre-max/pre-fullscreen values */ client_try_configure(self, &x, &y, &w, &h, &l, &l, FALSE); - ob_debug("placed window 0x%x at %d, %d with size %d x %d\n", + ob_debug("placed window 0x%x at %d, %d with size %d x %d", self->window, x, y, w, h); /* save the area, and make it where it should be for the premax stuff */ oldarea = self->area; @@ -2579,7 +2629,7 @@ static void client_apply_startup_state(ObClient *self, client_shade(self, TRUE); if (demands_attention) client_hilite(self, TRUE); - + if (max_vert && max_horz) client_maximize(self, TRUE, 0); else if (max_vert) @@ -2601,7 +2651,7 @@ static void client_apply_startup_state(ObClient *self, client_configure(self, x, y, w, h, FALSE, TRUE, FALSE); /* set the desktop hint, to make sure that it always exists */ - PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop); + OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, self->desktop); /* nothing to do for the other states: skip_taskbar @@ -2781,7 +2831,7 @@ void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h, /* you cannot resize to nothing */ if (basew + *w < 1) *w = 1 - basew; if (baseh + *h < 1) *h = 1 - baseh; - + /* save the logical size */ *logicalw = incw > 1 ? *w : *w + basew; *logicalh = inch > 1 ? *h : *h + baseh; @@ -2842,6 +2892,7 @@ void client_try_configure(ObClient *self, gint *x, gint *y, gint *w, gint *h, void client_configure(ObClient *self, gint x, gint y, gint w, gint h, gboolean user, gboolean final, gboolean force_reply) { + Rect oldframe; gint oldw, oldh; gboolean send_resize_client; gboolean moved = FALSE, resized = FALSE, rootmoved = FALSE; @@ -2864,6 +2915,7 @@ void client_configure(ObClient *self, gint x, gint y, gint w, gint h, oldw = self->area.width; oldh = self->area.height; + oldframe = self->frame->area; RECT_SET(self->area, x, y, w, h); /* for app-requested resizes, always resize if 'resized' is true. @@ -2875,7 +2927,7 @@ void client_configure(ObClient *self, gint x, gint y, gint w, gint h, /* if the client is enlarging, then resize the client before the frame */ if (send_resize_client && (w > oldw || h > oldh)) { - XMoveResizeWindow(ob_display, self->window, + XMoveResizeWindow(obt_display, self->window, self->frame->size.left, self->frame->size.top, MAX(w, oldw), MAX(h, oldh)); frame_adjust_client_area(self->frame); @@ -2937,11 +2989,11 @@ void client_configure(ObClient *self, gint x, gint y, gint w, gint h, XEvent event; event.type = ConfigureNotify; - event.xconfigure.display = ob_display; + event.xconfigure.display = obt_display; event.xconfigure.event = self->window; event.xconfigure.window = self->window; - ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d\n", + ob_debug("Sending ConfigureNotify to %s for %d,%d %dx%d", self->title, self->root_pos.x, self->root_pos.y, w, h); /* root window real coords */ @@ -2963,11 +3015,19 @@ void client_configure(ObClient *self, gint x, gint y, gint w, gint h, */ if (send_resize_client && (w <= oldw || h <= oldh)) { frame_adjust_client_area(self->frame); - XMoveResizeWindow(ob_display, self->window, + XMoveResizeWindow(obt_display, self->window, self->frame->size.left, self->frame->size.top, w, h); } - XFlush(ob_display); + XFlush(obt_display); + + /* if it moved between monitors, then this can affect the stacking + layer of this window or others - for fullscreen windows */ + if (screen_find_monitor(&self->frame->area) != + screen_find_monitor(&oldframe)) + { + client_calc_layer(self); + } } void client_fullscreen(ObClient *self, gboolean fs) @@ -3010,7 +3070,7 @@ void client_fullscreen(ObClient *self, gboolean fs) RECT_SET(self->pre_fullscreen_area, 0, 0, 0, 0); } - ob_debug("Window %s going fullscreen (%d)\n", + ob_debug("Window %s going fullscreen (%d)", self->title, self->fullscreen); client_setup_decor_and_functions(self, FALSE); @@ -3036,7 +3096,7 @@ static void client_iconify_recursive(ObClient *self, if (self->iconic != iconic) { - ob_debug("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"), + ob_debug("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"), self->window); if (iconic) { @@ -3096,7 +3156,7 @@ void client_iconify(ObClient *self, gboolean iconic, gboolean curdesk, void client_maximize(ObClient *self, gboolean max, gint dir) { gint x, y, w, h; - + g_assert(dir == 0 || dir == 1 || dir == 2); if (!(self->functions & OB_CLIENT_FUNC_MAXIMIZE)) return; /* can't */ @@ -3174,41 +3234,58 @@ void client_shade(ObClient *self, gboolean shade) frame_adjust_area(self->frame, FALSE, TRUE, FALSE); } -void client_close(ObClient *self) +static void client_ping_event(ObClient *self, gboolean dead) { - XEvent ce; + self->not_responding = dead; + client_update_title(self); + if (!dead) { + /* try kill it nicely the first time again, if it started responding + at some point */ + self->close_tried_term = FALSE; + } +} + +void client_close(ObClient *self) +{ if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return; /* in the case that the client provides no means to requesting that it close, we just kill it */ if (!self->delete_window) + /* don't use client_kill(), we should only kill based on PID in + response to a lack of PING replies */ + XKillClient(obt_display, self->window); + else if (self->not_responding) client_kill(self); - - /* - XXX: itd be cool to do timeouts and shit here for killing the client's - process off - like... if the window is around after 5 seconds, then the close button - turns a nice red, and if this function is called again, the client is - explicitly killed. - */ - - ce.xclient.type = ClientMessage; - ce.xclient.message_type = prop_atoms.wm_protocols; - ce.xclient.display = ob_display; - ce.xclient.window = self->window; - ce.xclient.format = 32; - ce.xclient.data.l[0] = prop_atoms.wm_delete_window; - ce.xclient.data.l[1] = event_curtime; - ce.xclient.data.l[2] = 0l; - ce.xclient.data.l[3] = 0l; - ce.xclient.data.l[4] = 0l; - XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce); + else + /* request the client to close with WM_DELETE_WINDOW */ + OBT_PROP_MSG_TO(self->window, self->window, WM_PROTOCOLS, + OBT_PROP_ATOM(WM_DELETE_WINDOW), event_curtime, + 0, 0, 0, NoEventMask); } void client_kill(ObClient *self) { - XKillClient(ob_display, self->window); + if (!self->client_machine && self->pid) { + /* running on the local host */ + if (!self->close_tried_term) { + ob_debug("killing window 0x%x with pid %lu, with SIGTERM", + self->window, self->pid); + kill(self->pid, SIGTERM); + self->close_tried_term = TRUE; + + /* show that we're trying to kill it */ + client_update_title(self); + } + else { + ob_debug("killing window 0x%x with pid %lu, with SIGKILL", + self->window, self->pid); + kill(self->pid, SIGKILL); /* kill -9 */ + } + } + else + XKillClient(obt_display, self->window); } void client_hilite(ObClient *self, gboolean hilite) @@ -3227,23 +3304,23 @@ void client_hilite(ObClient *self, gboolean hilite) } } -void client_set_desktop_recursive(ObClient *self, - guint target, - gboolean donthide, - gboolean dontraise) +static void client_set_desktop_recursive(ObClient *self, + guint target, + gboolean donthide, + gboolean dontraise) { guint old; GSList *it; if (target != self->desktop && self->type != OB_CLIENT_TYPE_DESKTOP) { - ob_debug("Setting desktop %u\n", target+1); + ob_debug("Setting desktop %u", target+1); g_assert(target < screen_num_desktops || target == DESKTOP_ALL); old = self->desktop; self->desktop = target; - PROP_SET32(self->window, net_wm_desktop, cardinal, target); + OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, target); /* the frame can display the current desktop state */ frame_adjust_state(self->frame); /* 'move' the window to the new desktop */ @@ -3286,7 +3363,7 @@ ObClient *client_search_modal_child(ObClient *self) { GSList *it; ObClient *ret; - + for (it = self->transients; it; it = g_slist_next(it)) { ObClient *c = it->data; if ((ret = client_search_modal_child(c))) return ret; @@ -3297,13 +3374,14 @@ ObClient *client_search_modal_child(ObClient *self) gboolean client_validate(ObClient *self) { - XEvent e; + XEvent e; - XSync(ob_display, FALSE); /* get all events on the server */ + XSync(obt_display, FALSE); /* get all events on the server */ - if (XCheckTypedWindowEvent(ob_display, self->window, DestroyNotify, &e) || - XCheckTypedWindowEvent(ob_display, self->window, UnmapNotify, &e)) { - XPutBackEvent(ob_display, &e); + if (XCheckTypedWindowEvent(obt_display, self->window, DestroyNotify, &e) || + XCheckTypedWindowEvent(obt_display, self->window, UnmapNotify, &e)) + { + XPutBackEvent(obt_display, &e); return FALSE; } @@ -3313,7 +3391,7 @@ gboolean client_validate(ObClient *self) void client_set_wm_state(ObClient *self, glong state) { if (state == self->wmstate) return; /* no change */ - + switch (state) { case IconicState: client_iconify(self, TRUE, TRUE, FALSE); @@ -3338,115 +3416,115 @@ void client_set_state(ObClient *self, Atom action, glong data1, glong data2) gboolean below = self->below; gint i; - if (!(action == prop_atoms.net_wm_state_add || - action == prop_atoms.net_wm_state_remove || - action == prop_atoms.net_wm_state_toggle)) + if (!(action == OBT_PROP_ATOM(NET_WM_STATE_ADD) || + action == OBT_PROP_ATOM(NET_WM_STATE_REMOVE) || + action == OBT_PROP_ATOM(NET_WM_STATE_TOGGLE))) /* an invalid action was passed to the client message, ignore it */ - return; + return; for (i = 0; i < 2; ++i) { Atom state = i == 0 ? data1 : data2; - + if (!state) continue; /* if toggling, then pick whether we're adding or removing */ - if (action == prop_atoms.net_wm_state_toggle) { - if (state == prop_atoms.net_wm_state_modal) - action = modal ? prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_maximized_vert) - action = self->max_vert ? prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_maximized_horz) - action = self->max_horz ? prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_shaded) - action = shaded ? prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_skip_taskbar) + if (action == OBT_PROP_ATOM(NET_WM_STATE_TOGGLE)) { + if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL)) + action = modal ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT)) + action = self->max_vert ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ)) + action = self->max_horz ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED)) + action = shaded ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR)) action = self->skip_taskbar ? - prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_skip_pager) + OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER)) action = self->skip_pager ? - prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_hidden) + OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN)) action = self->iconic ? - prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_fullscreen) + OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN)) action = fullscreen ? - prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_above) - action = self->above ? prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_below) - action = self->below ? prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.net_wm_state_demands_attention) + OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE)) + action = self->above ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW)) + action = self->below ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION)) action = self->demands_attention ? - prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; - else if (state == prop_atoms.ob_wm_state_undecorated) - action = undecorated ? prop_atoms.net_wm_state_remove : - prop_atoms.net_wm_state_add; + OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); + else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED)) + action = undecorated ? OBT_PROP_ATOM(NET_WM_STATE_REMOVE) : + OBT_PROP_ATOM(NET_WM_STATE_ADD); } - - if (action == prop_atoms.net_wm_state_add) { - if (state == prop_atoms.net_wm_state_modal) { + + if (action == OBT_PROP_ATOM(NET_WM_STATE_ADD)) { + if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL)) { modal = TRUE; - } else if (state == prop_atoms.net_wm_state_maximized_vert) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT)) { max_vert = TRUE; - } else if (state == prop_atoms.net_wm_state_maximized_horz) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ)) { max_horz = TRUE; - } else if (state == prop_atoms.net_wm_state_shaded) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED)) { shaded = TRUE; - } else if (state == prop_atoms.net_wm_state_skip_taskbar) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR)) { self->skip_taskbar = TRUE; - } else if (state == prop_atoms.net_wm_state_skip_pager) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER)) { self->skip_pager = TRUE; - } else if (state == prop_atoms.net_wm_state_hidden) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN)) { iconic = TRUE; - } else if (state == prop_atoms.net_wm_state_fullscreen) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN)) { fullscreen = TRUE; - } else if (state == prop_atoms.net_wm_state_above) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE)) { above = TRUE; below = FALSE; - } else if (state == prop_atoms.net_wm_state_below) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW)) { above = FALSE; below = TRUE; - } else if (state == prop_atoms.net_wm_state_demands_attention) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION)){ demands_attention = TRUE; - } else if (state == prop_atoms.ob_wm_state_undecorated) { + } else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED)) { undecorated = TRUE; } - } else { /* action == prop_atoms.net_wm_state_remove */ - if (state == prop_atoms.net_wm_state_modal) { + } else { /* action == OBT_PROP_ATOM(NET_WM_STATE_REMOVE) */ + if (state == OBT_PROP_ATOM(NET_WM_STATE_MODAL)) { modal = FALSE; - } else if (state == prop_atoms.net_wm_state_maximized_vert) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT)) { max_vert = FALSE; - } else if (state == prop_atoms.net_wm_state_maximized_horz) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ)) { max_horz = FALSE; - } else if (state == prop_atoms.net_wm_state_shaded) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SHADED)) { shaded = FALSE; - } else if (state == prop_atoms.net_wm_state_skip_taskbar) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR)) { self->skip_taskbar = FALSE; - } else if (state == prop_atoms.net_wm_state_skip_pager) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER)) { self->skip_pager = FALSE; - } else if (state == prop_atoms.net_wm_state_hidden) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_HIDDEN)) { iconic = FALSE; - } else if (state == prop_atoms.net_wm_state_fullscreen) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN)) { fullscreen = FALSE; - } else if (state == prop_atoms.net_wm_state_above) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_ABOVE)) { above = FALSE; - } else if (state == prop_atoms.net_wm_state_below) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_BELOW)) { below = FALSE; - } else if (state == prop_atoms.net_wm_state_demands_attention) { + } else if (state == OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION)){ demands_attention = FALSE; - } else if (state == prop_atoms.ob_wm_state_undecorated) { + } else if (state == OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED)) { undecorated = FALSE; } } @@ -3538,12 +3616,12 @@ gboolean client_focus(ObClient *self) if (!client_can_focus(self)) { ob_debug_type(OB_DEBUG_FOCUS, - "Client %s can't be focused\n", self->title); + "Client %s can't be focused", self->title); return FALSE; } ob_debug_type(OB_DEBUG_FOCUS, - "Focusing client \"%s\" (0x%x) at time %u\n", + "Focusing client \"%s\" (0x%x) at time %u", self->title, self->window, event_curtime); /* if using focus_delay, stop the timer now so that focus doesn't @@ -3559,35 +3637,35 @@ gboolean client_focus(ObClient *self) */ event_cancel_all_key_grabs(); - xerror_set_ignore(TRUE); - xerror_occured = FALSE; + obt_display_ignore_errors(TRUE); if (self->can_focus) { /* This can cause a BadMatch error with CurrentTime, or if an app passed in a bad time for _NET_WM_ACTIVE_WINDOW. */ - XSetInputFocus(ob_display, self->window, RevertToPointerRoot, + XSetInputFocus(obt_display, self->window, RevertToPointerRoot, event_curtime); } if (self->focus_notify) { XEvent ce; ce.xclient.type = ClientMessage; - ce.xclient.message_type = prop_atoms.wm_protocols; - ce.xclient.display = ob_display; + ce.xclient.message_type = OBT_PROP_ATOM(WM_PROTOCOLS); + ce.xclient.display = obt_display; ce.xclient.window = self->window; ce.xclient.format = 32; - ce.xclient.data.l[0] = prop_atoms.wm_take_focus; + ce.xclient.data.l[0] = OBT_PROP_ATOM(WM_TAKE_FOCUS); ce.xclient.data.l[1] = event_curtime; ce.xclient.data.l[2] = 0l; ce.xclient.data.l[3] = 0l; ce.xclient.data.l[4] = 0l; - XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce); + XSendEvent(obt_display, self->window, FALSE, NoEventMask, &ce); } - xerror_set_ignore(FALSE); + obt_display_ignore_errors(FALSE); - ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d\n", xerror_occured); - return !xerror_occured; + ob_debug_type(OB_DEBUG_FOCUS, "Error focusing? %d", + obt_display_error_occured); + return !obt_display_error_occured; } static void client_present(ObClient *self, gboolean here, gboolean raise, @@ -3619,34 +3697,7 @@ static void client_present(ObClient *self, gboolean here, gboolean raise, void client_activate(ObClient *self, gboolean here, gboolean raise, gboolean unshade, gboolean user) { - guint32 last_time = focus_client ? focus_client->user_time : CurrentTime; - gboolean allow = FALSE; - - /* if the currently focused app doesn't set a user_time, then it can't - benefit from any focus stealing prevention. - - if the timestamp is missing in the request then let it go through - even if it is source=app, because EVERY APPLICATION DOES THIS because - GTK IS VERY BUGGY AND HARDCODES source=application... WHY!? - */ - if (!last_time || !event_curtime) - allow = TRUE; - /* otherwise, if they didn't give a time stamp or if it is too old, they - don't get focus */ - else - allow = event_time_after(event_curtime, last_time); - - ob_debug_type(OB_DEBUG_FOCUS, - "Want to activate window 0x%x with time %u (last time %u), " - "source=%s allowing? %d\n", - self->window, event_curtime, last_time, - (user ? "user" : "application"), allow); - - if (allow) - client_present(self, here, raise, unshade); - else - /* don't focus it but tell the user it wants attention */ - client_hilite(self, TRUE); + client_present(self, here, raise, unshade); } static void client_bring_windows_recursive(ObClient *self, @@ -3702,7 +3753,7 @@ static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h) if ((parent = client_icon_recursive(c, w, h))) break; } - + return parent; } @@ -3756,7 +3807,7 @@ void client_set_layer(ObClient *self, gint layer) void client_set_undecorated(ObClient *self, gboolean undecorated) { if (self->undecorated != undecorated && - /* don't let it undecorate if the function is missing, but let + /* don't let it undecorate if the function is missing, but let it redecorate */ (self->functions & OB_CLIENT_FUNC_UNDECORATE || !undecorated)) { @@ -3776,7 +3827,7 @@ ObClient *client_direct_parent(ObClient *self) if (!self->parents) return NULL; if (self->transient_for_group) return NULL; return self->parents->data; -} +} ObClient *client_search_top_direct_parent(ObClient *self) { @@ -3791,7 +3842,7 @@ static GSList *client_search_all_top_parents_internal(ObClient *self, { GSList *ret; ObClient *p; - + /* move up the direct transient chain as far as possible */ while ((p = client_direct_parent(self)) && (!bylayer || p->layer == layer)) @@ -3848,6 +3899,111 @@ ObClient *client_search_transient(ObClient *self, ObClient *search) return NULL; } +static void detect_edge(Rect area, ObDirection dir, + gint my_head, gint my_size, + gint my_edge_start, gint my_edge_size, + gint *dest, gboolean *near_edge) +{ + gint edge_start, edge_size, head, tail; + gboolean skip_head = FALSE, skip_tail = FALSE; + + switch (dir) { + case OB_DIRECTION_NORTH: + case OB_DIRECTION_SOUTH: + edge_start = area.x; + edge_size = area.width; + break; + case OB_DIRECTION_EAST: + case OB_DIRECTION_WEST: + edge_start = area.y; + edge_size = area.height; + break; + default: + g_assert_not_reached(); + } + + /* do we collide with this window? */ + if (!RANGES_INTERSECT(my_edge_start, my_edge_size, + edge_start, edge_size)) + return; + + switch (dir) { + case OB_DIRECTION_NORTH: + head = RECT_BOTTOM(area); + tail = RECT_TOP(area); + break; + case OB_DIRECTION_SOUTH: + head = RECT_TOP(area); + tail = RECT_BOTTOM(area); + break; + case OB_DIRECTION_WEST: + head = RECT_RIGHT(area); + tail = RECT_LEFT(area); + break; + case OB_DIRECTION_EAST: + head = RECT_LEFT(area); + tail = RECT_RIGHT(area); + break; + default: + g_assert_not_reached(); + } + switch (dir) { + case OB_DIRECTION_NORTH: + case OB_DIRECTION_WEST: + /* check if our window is past the head of this window */ + if (my_head <= head + 1) + skip_head = TRUE; + /* check if our window's tail is past the tail of this window */ + if (my_head + my_size - 1 <= tail) + skip_tail = TRUE; + /* check if the head of this window is closer than the previously + chosen edge (take into account that the previously chosen + edge might have been a tail, not a head) */ + if (head + (*near_edge ? 0 : my_size) < *dest) + skip_head = TRUE; + /* check if the tail of this window is closer than the previously + chosen edge (take into account that the previously chosen + edge might have been a head, not a tail) */ + if (tail - (!*near_edge ? 0 : my_size) < *dest) + skip_tail = TRUE; + break; + case OB_DIRECTION_SOUTH: + case OB_DIRECTION_EAST: + /* check if our window is past the head of this window */ + if (my_head >= head - 1) + skip_head = TRUE; + /* check if our window's tail is past the tail of this window */ + if (my_head - my_size + 1 >= tail) + skip_tail = TRUE; + /* check if the head of this window is closer than the previously + chosen edge (take into account that the previously chosen + edge might have been a tail, not a head) */ + if (head - (*near_edge ? 0 : my_size) > *dest) + skip_head = TRUE; + /* check if the tail of this window is closer than the previously + chosen edge (take into account that the previously chosen + edge might have been a head, not a tail) */ + if (tail + (!*near_edge ? 0 : my_size) > *dest) + skip_tail = TRUE; + break; + default: + g_assert_not_reached(); + } + + ob_debug("my head %d size %d", my_head, my_size); + ob_debug("head %d tail %d deest %d", head, tail, *dest); + if (!skip_head) { + ob_debug("using near edge %d", head); + *dest = head; + *near_edge = TRUE; + } + else if (!skip_tail) { + ob_debug("using far edge %d", tail); + *dest = tail; + *near_edge = FALSE; + } +} + void client_find_edge_directional(ObClient *self, ObDirection dir, gint my_head, gint my_size, gint my_edge_start, gint my_edge_size, @@ -3855,6 +4011,7 @@ void client_find_edge_directional(ObClient *self, ObDirection dir, { GList *it; Rect *a, *mon; + Rect dock_area; gint edge; a = screen_area(self->desktop, SCREEN_AREA_ALL_MONITORS, @@ -3862,27 +4019,27 @@ void client_find_edge_directional(ObClient *self, ObDirection dir, mon = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &self->frame->area); - switch(dir) { + switch (dir) { case OB_DIRECTION_NORTH: - if (my_head >= RECT_TOP(*mon)) + if (my_head >= RECT_TOP(*mon) + 1) edge = RECT_TOP(*mon) - 1; else edge = RECT_TOP(*a) - 1; break; case OB_DIRECTION_SOUTH: - if (my_head <= RECT_BOTTOM(*mon)) + if (my_head <= RECT_BOTTOM(*mon) - 1) edge = RECT_BOTTOM(*mon) + 1; else edge = RECT_BOTTOM(*a) + 1; break; case OB_DIRECTION_EAST: - if (my_head <= RECT_RIGHT(*mon)) + if (my_head <= RECT_RIGHT(*mon) - 1) edge = RECT_RIGHT(*mon) + 1; else edge = RECT_RIGHT(*a) + 1; break; case OB_DIRECTION_WEST: - if (my_head >= RECT_LEFT(*mon)) + if (my_head >= RECT_LEFT(*mon) + 1) edge = RECT_LEFT(*mon) - 1; else edge = RECT_LEFT(*a) - 1; @@ -3894,10 +4051,8 @@ void client_find_edge_directional(ObClient *self, ObDirection dir, *dest = edge; *near_edge = TRUE; - for(it = client_list; it; it = g_list_next(it)) { + for (it = client_list; it; it = g_list_next(it)) { ObClient *cur = it->data; - gint edge_start, edge_size, head, tail; - gboolean skip_head = FALSE, skip_tail = FALSE; /* skip windows to not bump into */ if (cur == self) @@ -3908,89 +4063,16 @@ void client_find_edge_directional(ObClient *self, ObDirection dir, cur->desktop != screen_desktop) continue; - ob_debug("trying window %s\n", cur->title); + ob_debug("trying window %s", cur->title); - switch(dir) { - case OB_DIRECTION_NORTH: - case OB_DIRECTION_SOUTH: - edge_start = cur->frame->area.x; - edge_size = cur->frame->area.width; - break; - case OB_DIRECTION_EAST: - case OB_DIRECTION_WEST: - edge_start = cur->frame->area.y; - edge_size = cur->frame->area.height; - break; - default: - g_assert_not_reached(); - } - - /* do we collide with this window? */ - if (!RANGES_INTERSECT(my_edge_start, my_edge_size, - edge_start, edge_size)) - continue; - - switch(dir) { - case OB_DIRECTION_NORTH: - head = RECT_BOTTOM(cur->frame->area); - tail = RECT_TOP(cur->frame->area); - break; - case OB_DIRECTION_SOUTH: - head = RECT_TOP(cur->frame->area); - tail = RECT_BOTTOM(cur->frame->area); - break; - case OB_DIRECTION_EAST: - head = RECT_LEFT(cur->frame->area); - tail = RECT_RIGHT(cur->frame->area); - break; - case OB_DIRECTION_WEST: - head = RECT_RIGHT(cur->frame->area); - tail = RECT_LEFT(cur->frame->area); - break; - default: - g_assert_not_reached(); - } - - switch(dir) { - case OB_DIRECTION_NORTH: - case OB_DIRECTION_WEST: - if (my_head <= head + 1) - skip_head = TRUE; - if (my_head + my_size - 1 <= tail + 1) - skip_tail = TRUE; - if (head < *dest) - skip_head = TRUE; - if (tail - my_size < *dest) - skip_tail = TRUE; - break; - case OB_DIRECTION_SOUTH: - case OB_DIRECTION_EAST: - if (my_head >= head - 1) - skip_head = TRUE; - if (my_head - my_size + 1 >= tail - 1) - skip_tail = TRUE; - if (head > *dest) - skip_head = TRUE; - if (tail + my_size > *dest) - skip_tail = TRUE; - break; - default: - g_assert_not_reached(); - } - - ob_debug("my head %d size %d\n", my_head, my_size); - ob_debug("head %d tail %d deest %d\n", head, tail, *dest); - if (!skip_head) { - ob_debug("using near edge %d\n", head); - *dest = head; - *near_edge = TRUE; - } - else if (!skip_tail) { - ob_debug("using far edge %d\n", tail); - *dest = tail; - *near_edge = FALSE; - } + detect_edge(cur->frame->area, dir, my_head, my_size, my_edge_start, + my_edge_size, dest, near_edge); } + dock_get_area(&dock_area); + detect_edge(dock_area, dir, my_head, my_size, my_edge_start, + my_edge_size, dest, near_edge); + g_free(a); + g_free(mon); } void client_find_move_directional(ObClient *self, ObDirection dir, @@ -4064,36 +4146,36 @@ void client_find_resize_directional(ObClient *self, ObDirection side, gboolean grow, gint *x, gint *y, gint *w, gint *h) { - gint head, size; + gint head; gint e, e_start, e_size, delta; gboolean near; ObDirection dir; switch (side) { case OB_DIRECTION_EAST: - head = RECT_RIGHT(self->frame->area) + (self->size_inc.width - 1); - size = self->frame->area.width; + head = RECT_RIGHT(self->frame->area) + + (self->size_inc.width - 1) * (grow ? 1 : -1); e_start = RECT_TOP(self->frame->area); e_size = self->frame->area.height; dir = grow ? OB_DIRECTION_EAST : OB_DIRECTION_WEST; break; case OB_DIRECTION_WEST: - head = RECT_LEFT(self->frame->area) - (self->size_inc.width - 1); - size = self->frame->area.width; + head = RECT_LEFT(self->frame->area) - + (self->size_inc.width - 1) * (grow ? 1 : -1); e_start = RECT_TOP(self->frame->area); e_size = self->frame->area.height; dir = grow ? OB_DIRECTION_WEST : OB_DIRECTION_EAST; break; case OB_DIRECTION_NORTH: - head = RECT_TOP(self->frame->area) - (self->size_inc.height - 1); - size = self->frame->area.height; + head = RECT_TOP(self->frame->area) - + (self->size_inc.height - 1) * (grow ? 1 : -1); e_start = RECT_LEFT(self->frame->area); e_size = self->frame->area.width; dir = grow ? OB_DIRECTION_NORTH : OB_DIRECTION_SOUTH; break; case OB_DIRECTION_SOUTH: - head = RECT_BOTTOM(self->frame->area) + (self->size_inc.height - 1); - size = self->frame->area.height; + head = RECT_BOTTOM(self->frame->area) + + (self->size_inc.height - 1) * (grow ? 1 : -1); e_start = RECT_LEFT(self->frame->area); e_size = self->frame->area.width; dir = grow ? OB_DIRECTION_SOUTH : OB_DIRECTION_NORTH; @@ -4102,32 +4184,34 @@ void client_find_resize_directional(ObClient *self, ObDirection side, g_assert_not_reached(); } - client_find_edge_directional(self, dir, head, size, + ob_debug("head %d dir %d", head, dir); + client_find_edge_directional(self, dir, head, 1, e_start, e_size, &e, &near); + ob_debug("edge %d", e); *x = self->frame->area.x; *y = self->frame->area.y; *w = self->frame->area.width; *h = self->frame->area.height; switch (side) { case OB_DIRECTION_EAST: - if (near) --e; + if (grow == near) --e; delta = e - RECT_RIGHT(self->frame->area); *w += delta; break; case OB_DIRECTION_WEST: - if (near) ++e; + if (grow == near) ++e; delta = RECT_LEFT(self->frame->area) - e; *x -= delta; *w += delta; break; case OB_DIRECTION_NORTH: - if (near) ++e; + if (grow == near) ++e; delta = RECT_TOP(self->frame->area) - e; *y -= delta; *h += delta; break; case OB_DIRECTION_SOUTH: - if (near) --e; + if (grow == near) --e; delta = e - RECT_BOTTOM(self->frame->area); *h += delta; break; @@ -4139,7 +4223,7 @@ void client_find_resize_directional(ObClient *self, ObDirection side, *h -= self->frame->size.top + self->frame->size.bottom; } -ObClient* client_under_pointer() +ObClient* client_under_pointer(void) { gint x, y; GList *it; @@ -4172,30 +4256,3 @@ gboolean client_has_group_siblings(ObClient *self) { return self->group && self->group->members->next; } - -ObClientIcon *client_thumbnail(ObClient *self, gint wantw, gint wanth) -{ - ObClientIcon *ret; - RrPixel32 *data; - gint w, h; - - if (!self->frame->pixmap) return NULL; - if (!RrPixmapToRGBA(ob_rr_inst, self->frame->pixmap, None, &w, &h, &data)) - return NULL; - - /* resize the thumbnail (within aspect ratio) to the given sizes */ - - ret = g_new(ObClientIcon, 1); - ret->data = data; - ret->width = w; - ret->height = h; - return ret; -} - -void clienticon_free(ObClientIcon *ci) -{ - if (ci) { - g_free(ci->data); - g_free(ci); - } -}