X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Ffocus.c;h=72588a30a958b0bcacafbbc472d57565d3d9e25a;hb=7fddf2abc2b76e511be8fc14e22c1f310efe00ef;hp=fbac20ec35ff17c9562195e88428c5d49dc2468a;hpb=2b658f3d9bbb78ed3904edb44826b27380e80a1a;p=chaz%2Fopenbox diff --git a/openbox/focus.c b/openbox/focus.c index fbac20ec..72588a30 100644 --- a/openbox/focus.c +++ b/openbox/focus.c @@ -37,12 +37,20 @@ #include #include -#define FOCUS_INDICATOR_WIDTH 5 +#define FOCUS_INDICATOR_WIDTH 6 ObClient *focus_client = NULL; GList *focus_order = NULL; ObClient *focus_cycle_target = NULL; +/*! This variable is used for focus fallback. If we fallback to a window, we + set this to the window. And when focus goes somewhere after that, it will + be set to NULL. If between falling back to that window and something + getting focused, the window gets unmanaged, then if there are no incoming + FocusIn events, we fallback again because focus has just gotten itself lost. + */ +static ObClient *focus_tried = NULL; + struct { InternalWindow top; InternalWindow left; @@ -55,14 +63,12 @@ RrColor *color_white; static ObIconPopup *focus_cycle_popup; -static void focus_cycle_destructor(ObClient *client, gpointer data) -{ - /* end cycling if the target disappears. CurrentTime is fine, time won't - be used - */ - if (focus_cycle_target == client) - focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE); -} +static gboolean valid_focus_target(ObClient *ft, + gboolean all_desktops, + gboolean dock_windows, + gboolean desktop_windows); +static void focus_cycle_destroy_notify(ObClient *client, gpointer data); +static void focus_tried_hide_notify(ObClient *client, gpointer data); static Window createWindow(Window parent, gulong mask, XSetWindowAttributes *attrib) @@ -80,7 +86,9 @@ void focus_startup(gboolean reconfig) if (!reconfig) { XSetWindowAttributes attr; - client_add_destructor(focus_cycle_destructor, NULL); + client_add_destroy_notify(focus_cycle_destroy_notify, NULL); + client_add_destroy_notify(focus_tried_hide_notify, NULL); + client_add_hide_notify(focus_tried_hide_notify, NULL); /* start with nothing focused */ focus_nothing(); @@ -133,7 +141,9 @@ void focus_shutdown(gboolean reconfig) icon_popup_free(focus_cycle_popup); if (!reconfig) { - client_remove_destructor(focus_cycle_destructor); + client_remove_destroy_notify(focus_cycle_destroy_notify); + client_remove_destroy_notify(focus_tried_hide_notify); + client_remove_hide_notify(focus_tried_hide_notify); /* reset focus to root */ XSetInputFocus(ob_display, PointerRoot, RevertToNone, CurrentTime); @@ -170,7 +180,7 @@ void focus_set_client(ObClient *client) be used. */ if (focus_cycle_target) - focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE); + focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE); focus_client = client; @@ -187,9 +197,12 @@ void focus_set_client(ObClient *client) PROP_SET32(RootWindow(ob_display, ob_screen), net_active_window, window, active); } + + + focus_tried = NULL; /* focus isn't "trying" to go anywhere now */ } -ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old) +static ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old) { GList *it; ObClient *target = NULL; @@ -228,7 +241,7 @@ ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old) } - ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order\n"); + ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order\n"); for (it = focus_order; it; it = g_list_next(it)) if (allow_refocus || it->data != old) { ObClient *c = it->data; @@ -259,19 +272,26 @@ ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old) return desktop; } -void focus_fallback(gboolean allow_refocus) +ObClient* focus_fallback(gboolean allow_refocus) { ObClient *new; - ObClient *old = focus_client; + ObClient *old; + + old = focus_client; + new = focus_fallback_target(allow_refocus, focus_client); /* unfocus any focused clients.. they can be focused by Pointer events - and such, and then when I try focus them, I won't get a FocusIn event - at all for them. - */ + and such, and then when we try focus them, we won't get a FocusIn + event at all for them. */ focus_nothing(); - if ((new = focus_fallback_target(allow_refocus, old))) + if (new) { client_focus(new); + /* remember that we tried to send focus here */ + focus_tried = new; + } + + return new; } void focus_nothing() @@ -283,53 +303,133 @@ void focus_nothing() } focus_client = NULL; + focus_tried = NULL; /* focus isn't "trying" to go anywhere now */ + + /* if there is a grab going on, then we need to cancel it. if we move + focus during the grab, applications will get NotifyWhileGrabbed events + and ignore them ! + + actions should not rely on being able to move focus during an + interactive grab. + */ + if (keyboard_interactively_grabbed()) + keyboard_interactive_cancel(); /* when nothing will be focused, send focus to the backup target */ XSetInputFocus(ob_display, screen_support_win, RevertToPointerRoot, event_curtime); } -static void popup_cycle(ObClient *c, gboolean show) +static gchar *popup_get_name(ObClient *c, ObClient **nametarget) +{ + ObClient *p; + gchar *title = NULL; + const gchar *desk = NULL; + gchar *ret; + + /* find our highest direct parent, including non-normal windows */ + for (p = c; p->transient_for && p->transient_for != OB_TRAN_GROUP; + p = p->transient_for); + + if (c->desktop != DESKTOP_ALL && c->desktop != screen_desktop) + desk = screen_desktop_names[c->desktop]; + + /* use the transient's parent's title/icon if we don't have one */ + if (p != c && !strcmp("", (c->iconic ? c->icon_title : c->title))) + title = g_strdup(p->iconic ? p->icon_title : p->title); + + if (title == NULL) + title = g_strdup(c->iconic ? c->icon_title : c->title); + + if (desk) + ret = g_strdup_printf("%s [%s]", title, desk); + else { + ret = title; + title = NULL; + } + g_free(title); + + /* set this only if we're returning true and they asked for it */ + if (ret && nametarget) *nametarget = p; + return ret; +} + +static void popup_cycle(ObClient *c, gboolean show, + gboolean all_desktops, gboolean dock_windows, + gboolean desktop_windows) { + gchar *showtext = NULL; + ObClient *showtarget; + if (!show) { icon_popup_hide(focus_cycle_popup); - } else { + return; + } + + /* do this stuff only when the dialog is first showing */ + if (!focus_cycle_popup->popup->mapped && + !focus_cycle_popup->popup->delay_mapped) + { Rect *a; - ObClient *p; - gchar *text; - gchar *title = NULL; - const gchar *desk = NULL; + gchar **names; + GList *targets = NULL, *it; + gint n = 0, i; + /* position the popup */ a = screen_physical_area_monitor(0); icon_popup_position(focus_cycle_popup, CenterGravity, a->x + a->width / 2, a->y + a->height / 2); - icon_popup_width(focus_cycle_popup, MAX(a->width/3, POPUP_WIDTH)); icon_popup_height(focus_cycle_popup, POPUP_HEIGHT); + icon_popup_min_width(focus_cycle_popup, POPUP_WIDTH); + icon_popup_max_width(focus_cycle_popup, + MAX(a->width/3, POPUP_WIDTH)); - /* use the transient's parent's title/icon */ - p = client_search_top_parent(c); - if (c->desktop != DESKTOP_ALL && c->desktop != screen_desktop) - desk = screen_desktop_names[c->desktop]; + /* make its width to be the width of all the possible titles */ - if (p != c && !strcmp("", (c->iconic ? c->icon_title : c->title))) - title = g_strdup(p->iconic ? p->icon_title : p->title); - /*ptitle = g_strconcat((c->iconic ? c->icon_title : c->title), - " - ", - (p->iconic ? p->icon_title : p->title), - NULL); - */ - if (title == NULL) - title = g_strdup(c->iconic ? c->icon_title : c->title); - if (desk) - text = g_strdup_printf("%s [%s]", title, desk); - else - text = g_strdup(title); + /* build a list of all the valid focus targets */ + for (it = focus_order; it; it = g_list_next(it)) { + ObClient *ft = it->data; + if (valid_focus_target(ft, all_desktops, dock_windows + , desktop_windows)) + { + targets = g_list_prepend(targets, ft); + ++n; + } + } + /* make it null terminated so we can use g_strfreev */ + names = g_new(char*, n+1); + for (it = targets, i = 0; it; it = g_list_next(it), ++i) { + ObClient *ft = it->data, *t; + names[i] = popup_get_name(ft, &t); + + /* little optimization.. save this text and client, so we dont + have to get it again */ + if (ft == c) { + showtext = g_strdup(names[i]); + showtarget = t; + } + } + names[n] = NULL; - icon_popup_show(focus_cycle_popup, text, client_icon(p, 48, 48)); - g_free(text); - g_free(title); + icon_popup_text_width_to_strings(focus_cycle_popup, names, n); + g_strfreev(names); } + + + if (!showtext) showtext = popup_get_name(c, &showtarget); + icon_popup_show(focus_cycle_popup, showtext, + client_icon(showtarget, 48, 48)); + g_free(showtext); +} + +static void focus_cycle_destroy_notify(ObClient *client, gpointer data) +{ + /* end cycling if the target disappears. CurrentTime is fine, time won't + be used + */ + if (focus_cycle_target == client) + focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE); } void focus_cycle_draw_indicator() @@ -466,56 +566,79 @@ void focus_cycle_draw_indicator() } } +static gboolean has_valid_group_siblings_on_desktop(ObClient *ft, + gboolean all_desktops) + +{ + GSList *it; + + if (!ft->group) return FALSE; + + for (it = ft->group->members; it; it = g_slist_next(it)) { + ObClient *c = it->data; + /* check that it's not a helper window to avoid infinite recursion */ + if (c != ft && !client_helper(c) && + valid_focus_target(c, all_desktops, FALSE, FALSE)) + { + return TRUE; + } + } + return FALSE; +} + +/*! @param allow_helpers This is used for calling itself recursively while + checking helper windows. */ static gboolean valid_focus_target(ObClient *ft, gboolean all_desktops, - gboolean dock_windows) + gboolean dock_windows, + gboolean desktop_windows) { gboolean ok = FALSE; - /* we don't use client_can_focus here, because that doesn't let you - focus an iconic window, but we want to be able to, so we just check - if the focus flags on the window allow it, and its on the current - desktop */ - if (dock_windows) - ok = ft->type == OB_CLIENT_TYPE_DOCK; - else - ok = (ft->type == OB_CLIENT_TYPE_NORMAL || - ft->type == OB_CLIENT_TYPE_DIALOG || - ((ft->type == OB_CLIENT_TYPE_TOOLBAR || - ft->type == OB_CLIENT_TYPE_MENU || - ft->type == OB_CLIENT_TYPE_UTILITY) && - /* let alt-tab go to these windows when a window in its group - already has focus ... */ - ((focus_client && ft->group == focus_client->group) || - /* ... or if there are no application windows in its group */ - !client_has_application_group_siblings(ft)))); + + /* it's on this desktop unless you want all desktops. + + do this check first because it will usually filter out the most + windows */ + ok = (all_desktops || ft->desktop == screen_desktop || + ft->desktop == DESKTOP_ALL); + + /* the window can receive focus somehow */ ok = ok && (ft->can_focus || ft->focus_notify); - if (!dock_windows && /* use dock windows that skip taskbar too */ - !(ft->type == OB_CLIENT_TYPE_TOOLBAR || /* also, if we actually are */ - ft->type == OB_CLIENT_TYPE_MENU || /* being allowed to target */ - ft->type == OB_CLIENT_TYPE_UTILITY)) /* one of these, don't let */ - ok = ok && !ft->skip_taskbar; /* skip taskbar stop us */ - if (!all_desktops) - ok = ok && (ft->desktop == screen_desktop || - ft->desktop == DESKTOP_ALL); - ok = ok && ft == client_focus_target(ft); - return ok; -/* - { - GSList *it; - for (it = ft->transients; it; it = g_slist_next(it)) { - ObClient *c = it->data; + /* it's the right type of window */ + if (dock_windows || desktop_windows) + ok = ok && ((dock_windows && ft->type == OB_CLIENT_TYPE_DOCK) || + (desktop_windows && ft->type == OB_CLIENT_TYPE_DESKTOP)); + else + /* normal non-helper windows are valid targets */ + ok = ok && + ((client_normal(ft) && !client_helper(ft)) + || + /* helper windows are valid targets it... */ + (client_helper(ft) && + /* ...a window in its group already has focus ... */ + ((focus_client && ft->group == focus_client->group) || + /* ... or if there are no other windows in its group + that can be cycled to instead */ + !has_valid_group_siblings_on_desktop(ft, all_desktops)))); + + /* it's not set to skip the taskbar (unless it is a type that would be + expected to set this hint */ + ok = ok && ((ft->type == OB_CLIENT_TYPE_DOCK || + ft->type == OB_CLIENT_TYPE_DESKTOP || + ft->type == OB_CLIENT_TYPE_TOOLBAR || + ft->type == OB_CLIENT_TYPE_MENU || + ft->type == OB_CLIENT_TYPE_UTILITY) || + !ft->skip_taskbar); + + /* it's not going to just send fous off somewhere else (modal window) */ + ok = ok && ft == client_focus_target(ft); - if (frame_visible(c->frame)) - return FALSE; - } - return TRUE; - } -*/ + return ok; } void focus_cycle(gboolean forward, gboolean all_desktops, - gboolean dock_windows, + gboolean dock_windows, gboolean desktop_windows, gboolean linear, gboolean interactive, gboolean dialog, gboolean done, gboolean cancel) { @@ -560,13 +683,17 @@ void focus_cycle(gboolean forward, gboolean all_desktops, if (it == NULL) it = g_list_last(list); } ft = it->data; - if (valid_focus_target(ft, all_desktops, dock_windows)) { + if (valid_focus_target(ft, all_desktops, dock_windows, + desktop_windows)) + { if (interactive) { if (ft != focus_cycle_target) { /* prevents flicker */ focus_cycle_target = ft; focus_cycle_draw_indicator(); } - popup_cycle(ft, dialog); + /* same arguments as valid_focus_target */ + popup_cycle(ft, dialog, all_desktops, dock_windows, + desktop_windows); return; } else if (ft != focus_cycle_target) { focus_cycle_target = ft; @@ -588,15 +715,16 @@ done_cycle: if (interactive) { focus_cycle_draw_indicator(); - popup_cycle(ft, FALSE); + popup_cycle(ft, FALSE, FALSE, FALSE, FALSE); } return; } /* this be mostly ripped from fvwm */ -ObClient *focus_find_directional(ObClient *c, ObDirection dir, - gboolean dock_windows) +static ObClient *focus_find_directional(ObClient *c, ObDirection dir, + gboolean dock_windows, + gboolean desktop_windows) { gint my_cx, my_cy, his_cx, his_cy; gint offset = 0; @@ -621,9 +749,13 @@ ObClient *focus_find_directional(ObClient *c, ObDirection dir, /* the currently selected window isn't interesting */ if(cur == c) continue; - if (!dock_windows && !client_normal(cur)) + if (cur->type == OB_CLIENT_TYPE_DOCK && !dock_windows) continue; - if (dock_windows && cur->type != OB_CLIENT_TYPE_DOCK) + if (cur->type == OB_CLIENT_TYPE_DESKTOP && !desktop_windows) + continue; + if (!client_normal(cur) && + cur->type != OB_CLIENT_TYPE_DOCK && + cur->type != OB_CLIENT_TYPE_DESKTOP) continue; /* using c->desktop instead of screen_desktop doesn't work if the * current window was omnipresent, hope this doesn't have any other @@ -699,7 +831,7 @@ ObClient *focus_find_directional(ObClient *c, ObDirection dir, } void focus_directional_cycle(ObDirection dir, gboolean dock_windows, - gboolean interactive, + gboolean desktop_windows, gboolean interactive, gboolean dialog, gboolean done, gboolean cancel) { static ObClient *first = NULL; @@ -721,12 +853,14 @@ void focus_directional_cycle(ObDirection dir, gboolean dock_windows, if (!focus_cycle_target) focus_cycle_target = focus_client; if (focus_cycle_target) - ft = focus_find_directional(focus_cycle_target, dir, dock_windows); + ft = focus_find_directional(focus_cycle_target, dir, dock_windows, + desktop_windows); else { GList *it; for (it = focus_order; it; it = g_list_next(it)) - if (valid_focus_target(it->data, FALSE, dock_windows)) + if (valid_focus_target(it->data, FALSE, dock_windows, + desktop_windows)) ft = it->data; } @@ -737,7 +871,9 @@ void focus_directional_cycle(ObDirection dir, gboolean dock_windows, } } if (focus_cycle_target) { - popup_cycle(focus_cycle_target, dialog); + /* same arguments as valid_focus_target */ + popup_cycle(focus_cycle_target, dialog, FALSE, dock_windows, + desktop_windows); if (dialog) return; } @@ -751,7 +887,7 @@ done_cycle: focus_cycle_target = NULL; focus_cycle_draw_indicator(); - popup_cycle(ft, FALSE); + popup_cycle(ft, FALSE, FALSE, FALSE, FALSE); return; } @@ -816,3 +952,25 @@ ObClient *focus_order_find_first(guint desktop) } return NULL; } + +static void focus_tried_hide_notify(ObClient *client, gpointer data) +{ + XEvent ce; + + if (client == focus_tried) { + /* we were trying to focus this window but it's gone */ + + focus_tried = NULL; + + ob_debug_type(OB_DEBUG_FOCUS, "Tried to focus window 0x%x and it " + "is being unmanaged:\n"); + if (XCheckIfEvent(ob_display, &ce, event_look_for_focusin_client,NULL)) + { + XPutBackEvent(ob_display, &ce); + ob_debug_type(OB_DEBUG_FOCUS, " but another FocusIn is coming\n"); + } else { + ob_debug_type(OB_DEBUG_FOCUS, " so falling back focus again.\n"); + focus_fallback(TRUE); + } + } +}